内容回顾：
1. 成员
- 变量
- 静态字段，类变量
- 方法
- 类方法
- 静态方法
- 实例方法
- 属性
2. 对象的嵌套
3. 特殊方法
__init__
new
call
getitem...
add
enter
exit
iter
str
dict
doc
4. 反射
- getattr
- has
- set
- del
5. issubclass/isinstance/type/callable ——> 内置函数
6. 公有和私有（修饰符）
7. 三大特性：继承、封装、多态
8. super
9. 函数和方法的区别？
10. self到底是谁？
11. 继承、多继承
12. 关于类变量的改变
面向对象
- 三大特性
- 继承
- 单继承，示例：
- 多继承，示例：
- super
- 封装
- 数据封装
- 方法封装
- 多态
- 鸭子模型
- 成员
- 变量
- 实例
- 类
- 方法
- 示例方法
- 类方法
- 静态方法
- 特殊方法
...
- 属性
- @property，分页
- 修饰符
- 私有
- 编写
- 派生类
- 公有
- 易错点
- self
内置函数：
- issubclass
- isinstance
- type
- callable
函数和方法的区别？
反射
问题：匿名函数是否可以在类中？可以
class Foo:
v = lambda self,x: x+1 #和下面相等
def v(self,x):
return x + 1
今日内容：
1. 约束
2. 自定义异常
3. hashlib
4. logging
内容详细：
1. 约束
建议使用：
class BaseMessage(object):
def send(self):
"""
必须继承BaseMessage，然后其中必须编写send方法。用于完成具体业务逻辑。
"""
raise NotImplementedError("send方法必须被重写.")
# raise Exception(".send() 必须被重写.")
BaseMessage(基类)类用于约束，约束其派生类：保证派生类中必须编写send方法，不然执行就会报错。
class BaseMessage(object):
def send(self):
"""
必须继承BaseMessage，然后其中必须编写send方法。用于完成具体业务逻辑。
"""
raise Exception()
class Msg(BaseMessage):
def send(self):
pass # 发送短信
def f1(self):
pass
def f2(self):
pass
def func(arg):
"""
报警通知的功能
"""
arg.send()
obj = Msg()
func(obj)
Python：
类
类：
class Foo:
pass
抽象类和抽象方法：
from abc import ABCMeta,abstractmethod
class Base(metaclass=ABCMeta): # 抽象类;就是定义抽象方法
def f1(self):
print(123)
@abstractmethod #定义抽象方法；继承类的类必须重写此方法
def f2(self): # 抽象方法
pass
class Foo(Base):
def f2(self):
print(666)
obj = Foo()
obj.f1()
Java、C#中:
类
类
class Foo:
def f1(self):
pass
def f2(self):
pass # 可人为抛出异常让子类实现这个方法。
class Bar(Foo):
def f1(self):
pass
抽象类，约束，约束继承它的派生类必须实现它其中的抽象方法。；
abstact class Foo:
def f1(self):
print(1,3,4)
abstact def f2(self):pass
class Bar(Foo):
def f2(self):
print('111')
------------------------------------------------
接口，接口中不允许在方法内部写代码，只能约束继承它的类必须实现接口中定义的所有方法。
interface IFoo:
def f1(self,x1):pass
def f2(self,x1):pass
interface IBar:
def f3(self,x1):pass
def f4(self,x1):pass
class Foo(IFoo,IBar):# 实现了2个接口
def f1(self,x1):pass
def f2(self,x1):pass
def f3(self,x1):pass
def f4(self,x1):pass
总结：
1. 什么是接口以及作用？
接口时一种数据类型，主要用于约束派生类中必须实现指定的方法。
Python中不存在，Java和C# 中是存在的。
2. Python中使用过什么来约束呢？（两种方法如下）
1 - 抽象类+抽象方法， 这个编写上麻烦。
2 - 人为主动抛出异常 raise NotImplementedError('必须被重写')
3. 约束时，抛出的异常是否可以用其他的？
不专业：raise Exception(".send() 必须被重写.")
专业：raise NotImplementedError(".send() 必须被重写.")
看代码，揣摩心思
5. 写代码：
class BaseMessage(object):
def send(self,x1):
"""
必须继承BaseMessage，然后其中必须编写send方法。用于完成具体业务逻辑。
"""
raise NotImplementedError(".send() 必须被重写.")
class Email(BaseMessage):
def send(self,x1):
"""
必须继承BaseMessage，然后其中必须编写send方法。用于完成具体业务逻辑。
"""
print('发送邮件')
obj = Email()
obj.send(1)
6. 应用场景：
多个类，内部都必须有某些方法时，需要使用基类+异常进行约束。
学员管理程序：
class IBase:
def login():
raise NotImplementedError(".send() 必须被重写.")
class Student:
def login(self):
pass
def score(self):
pass
class Teacher:
def login(self):
pass
def exam(self):
pass
class Manager(self):
def login(self):
pass
....
2. 自定义异常
# 知识点：如何自定义异常类？
class MyException(Exception):
def __init__(self,code,msg):
self.code = code
self.msg = msg
try:
# 知识点：主动抛出异常
raise MyException(1000,'操作异常')
except KeyError as obj:
print(obj,1111)
except MyException as obj: # 知识点：捕获异常
print(obj,2222)
except Exception as obj:
print(obj,3333)
3. 加密
关键词：撞库
加盐
4. 日志 logging
为什么要有日志？
给开发人员看，用于排查错误。
import logging
import traceback
logger=logging.basicConfig(filename='xxxxxxx.txt',
format='%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S',
level=30 #默认登记是30
)
logging.debug("x1")
logging.info("x2")
logging.warning("x3")
logging.error('x4')
logging.critical("x5")
#自定义级别
logging.log(31,'655555555555')
# CRITICAL = 50
# FATAL = CRITICAL
# ERROR = 40
# WARNING = 30
# WARN = WARNING
# INFO = 20
# DEBUG = 10
# NOTSET = 0
def func():
try:
a=1+a
except Exception as e:
#获取堆栈信息
print("ddddddddd", type(e))
print(str(e),type(e))
msg=traceback.format_exc() #获取到哪一行的日志报错；获取日志多一点
logging.critical(msg)
func()
自定义日志
import logging
#创建一个操作日志的对象logger(依赖FileHandler);可以再创建一个相同的日志对象logger，这样就可以将日志写入两个文件了
file_handler=logging.FileHandler('11.txt','a',encoding='utf-8')
file_handler.setFormatter(logging.Formatter(fmt="%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s"))
logger1=logging.Logger('s1',level=logging.ERROR)
logger1.addHandler(file_handler)
logger1.error('33333333333333333')
总结：
1. 约束 ***
2. md5 *****
3. 自定义异常 ***
4. 日志处理 ****
作业
1 类变量和实例变量的区别？
在类设计中，经常遇到两种类型的变量：类变量和实例变量。
简单的说，类变量（class variable）被该类的所有实例可以共享的变量；如果某个实例修改了该变量，这种变化可以被其他实例看到。
实例变量（object variable, instance variable）属于实例私有；对实例变量的操作不会影响到其他实例对象
一个是在类中，一个是在构造方法中
2 super的作用？
按照继承顺序查找下一个
super 是按照当前类的基础往上找，如果是self，则是回到原点找方法继续往上找
3 isinstance 和type的区别并用代码举例说明？
type更精准
4 补全代码
def func(arg):
#判断arg是否可以被调用，如果可以则执行并打印其返回值，
#否则直接打印结果
#用 callable 方发判断下即可
pass
5 补全代码
from types import MethodType,FunctionType
def func(*args):
#计算args 中函数，方法，Foo类对象的个数，并返回给调用者; 用 type
meth_count=0
func_count=0
obj_count=0
for i in args:
if isinstance(i,MethodType)
meth_count+=1
elif isinstance(I,FunctionType)
func_count+=1
elfi type(i,Foo)
return meth_count,func_count,obj_count
10 背写 你所了解的所有特殊方法并附示例
11
12
13
类变量和实例变量
15 如何让一个对象可以被执行？即后面加（）
有 __call__ 方法
16
total_course_list=[]
class Course():
def __init__(self, name, price, period):
self.name = name
self.price = price
self.period = period
class Student:
func_list=[{'text':"选课","name":"select_course"},
{'text': "选课", "name": "select_course"},
{'text': "删除", "name": "select_course"}
]
def __init__(self, name):
self.name = name
self.course = []
def select_course(self):
"""选择课程，已选择则不能再选"""
for i,item in enumerate(total_course_list,1):
print(i,item.name,item.price,item.period)
num=int(input("请选择要选择的课程"))
num=num-1
course_obj=total_course_list[num]
if course_obj not in self.course:
self.course.append(course_obj)
print("选课成功")
def show_selected_course(self):
"""查看自己所选课程"""
pass
def show_deleted_course(self):
"""删除已选课程"""
pass
def run():
"""主程序
1 根据course类创建10个课程
2 用户输入学生姓名，动态创建学生对象
3 查看所有课程
4 为学生选课
5 查看学生已选课程
6 删除已选课程
"""
for i in range( 1, 11 ):
obj = Course( 'xx-%s' % i, 90, 90 )
total_course_list.append(obj)
stu_name=input("请输入学生姓名")
stu=Student(stu_name)
for i,item in enumerate(stu.func_list,1):
print(i,item['text'])
while True:
num=int(input("请选择执行的功能序号"))
num=num-1
row=stu.func_list[num]
name=row["name"]
func=getattr(stu,name)
func()
if __name__ == '__main__':
run()
第
二
total_course_list=[]
class Course():
def __init__(self, name, price, period):
self.name = name
self.price = price
self.period = period
class Student:
func_list=[{'text':"选课","name":"select_course"},
{'text': "选课", "name": "select_course"},
{'text': "删除", "name": "select_course"}
]
def __init__(self, name):
self.name = name
self.course = []
def select_course(self):
"""选择课程，已选择则不能再选"""
for i,item in enumerate(total_course_list,1):
print(i,item.name,item.price,item.period)
num=int(input("请选择要选择的课程"))
num=num-1
course_obj=total_course_list[num]
if course_obj not in self.course:
self.course.append(course_obj)
print("选课成功")
def show_selected_course(self):
"""查看自己所选课程"""
pass
def show_deleted_course(self):
"""删除已选课程"""
pass
def run():
"""主程序
1 根据course类创建10个课程
2 用户输入学生姓名，动态创建学生对象
3 查看所有课程
4 为学生选课
5 查看学生已选课程
6 删除已选课程
"""
for i in range( 1, 11 ):
obj = Course( 'xx-%s' % i, 90, 90 )
total_course_list.append(obj)
stu_name=input("请输入学生姓名")
stu=Student(stu_name)
for i,item in enumerate(stu.func_list,1):
print(i,item['text'])
while True:
num=int(input("请选择执行的功能序号"))
num=num-1
row=stu.func_list[num]
name=row["name"]
func=getattr(stu,name)
func()
if __name__ == '__main__':
run()
——异常