【python基础】第37回 周总结
目录
1. 面对对象
1.1 面向对象前戏-人狗大战
1.1.1 推导1-创建出人和狗
# 1. 创造出人和狗
'''推导步骤 1 直接手写字典模拟一个个人和狗'''
person1 = {
'name': 'zhang',
'p_type': '猛男',
'attack_val': 10,
'life_val': 100
}
dog1 = {
'name': '小黑',
'p_type': '金毛',
'attack_val': 10,
'lisfe_val': 50
}
1.1.2 推导2-需要反复调用人与狗封装函数
'''推到步骤2 由于定义人和狗的字典基本不变，但是在很多地方又需要反复使用，所以封装成函数'''
def get_person(name, gender, age, d_type, attack_val, life_val):
"""
专用用于产生用户字典(创造人)
:param name: 姓名
:param gender: 性别
:param age: 年龄
:param d_type: 类型
:param attack_val:攻击力
:param life_val: 生命值
:return: 人的字典(人)
"""
person_obj = {
'name': name,
'gender': gender,
'age': age,
'd_type': d_type,
'attack_val': attack_val,
'life_val': life_val
}
return person_obj
p1 = get_person('jason', 'male', 18, '猛男', 10, 100)
p2 = get_person('li', 'male', 18, '淑女', 10, 50)
def get_dog(name, d_type, attack_val, life_val):
"""
专门用于产生狗字典(狗)
:param name: 狗的名字
:param d_type: 狗的类型
:param attack_val: 狗的攻击力
:param life_val: 狗的生命值
:return: 狗的字典(狗)
"""
dog_obj = {
'name': name,
'd_type': d_type,
'attack_val': attack_val,
'life_val': life_val
}
return dog_obj
d1 = get_dog('小黄狗','中华田园犬',8, 50)
d2 = get_dog('小奶狗','哈士奇',5, 20)
1.1.3 推导3-定义人与狗攻击的函数
'''推导步骤3：让人和狗具备攻击的能力，本质其实就是定义两个函数供人和狗调用'''
def person_attack(person_obj, dog_obj):
"""
专用提供给人调用 攻击狗
:param person_obj: 传人数据(字典)
:param dog_obj: 传狗数据(字典)
"""
print('即将被攻击的狗：%s 当前血量：%s' % (dog_obj.get('name'),dog_obj.get('life_val'))) # 先展示当前狗的状态
dog_obj['life_val'] -= person_obj.get('attack_val') # 人捶狗，直接用狗的生命值减去人的攻击力
print('人：%s 捶了 狗：%s 狗掉血：%s 剩余血量：%s' % (person_obj.get('name'),dog_obj.get('name'),person_obj.get('attack_val'),dog_obj.get('life_val')))
def dog_attack(dog_obj, person_obj):
"""
专用提供给狗调用 攻击人
:param dog_obj: 传狗数据(字典)
:param person_obj: 传人数据(字典)
"""
print('即将被攻击的人：%s 当前血量：%s' % (person_obj.get('name'), person_obj.get('life_val'))) # 先展示当前人的状态
person_obj['life_val'] -= dog_obj.get('attack_val') # 狗咬人 直接用人多生命值减去狗的攻击力
print('狗：%s 咬了 人：%s 人掉血：%s 剩余血量：%s' % (dog_obj.get('name'),person_obj.get('name'),dog_obj.get('attack_val'),person_obj.get('life_val')))
# 调用产生人和狗的函数
p1 = get_person('jason', 'male', 18, '猛男', 10, 100)
p2 = get_person('li', 'male', 18, '淑女', 10, 50)
d1 = get_dog('小黄狗','中华田园犬',8, 50)
d2 = get_dog('小奶狗','哈士奇',5, 20)
# 调用攻击彼此的函数
person_attack(p1,d1)
dog_attack(d2,p2)
1.1.4 推导4-攻击混乱代码优化
"""推导步骤4: 人和狗攻击乱套"""
person_attack(d2, p1)
dog_attack(p2, d1)
1.1.5 推导5-人与攻击函数绑定，狗与狗攻击函数绑定
"""推导步骤5: 人跟人攻击狗的函数绑定 狗跟狗攻击人的函数绑定
我们定义的函数默认情况下都是可以被任意调用的 但是现在我们想实现定义的函数只有特定的东西才可以调用
"""
def get_person(name, gender, age, p_type, attack_val, life_val):
"""
专用用于产生用户字典(创造人)
:param name: 姓名
:param gender: 性别
:param age: 年龄
:param d_type: 类型
:param attack_val:攻击力
:param life_val: 生命值
:return: 人的字典(人)
"""
def person_attack(person_obj, dog_obj):
"""
专用提供给人调用 攻击狗
:param person_obj: 传人数据(字典)
:param dog_obj: 传狗数据(字典)
"""
print('即将被攻击的狗:%s 当前血量:%s' % (dog_obj.get('name'), dog_obj.get('life_val'))) # 先展示当前狗的状态
dog_obj['life_val'] -= person_obj.get('attack_val') # 人锤狗 直接用狗的生命值减去人的攻击力
print('人:%s 锤了 狗:%s 狗掉血:%s 剩余血量:%s' % (
person_obj.get('name'), dog_obj.get('name'), person_obj.get('attack_val'), dog_obj.get('life_val')))
person_obj = {
'name': name,
'gender': gender,
'age': age,
'p_type': p_type,
'attack_val': attack_val,
'life_val': life_val,
'person_attack':person_attack
}
return person_obj
def get_dog(name, d_type, attack_val, life_val):
"""
专门用于产生狗字典(狗)
:param name: 狗的名字
:param d_type: 狗的类型
:param attack_val: 狗的攻击力
:param life_val: 狗的生命值
:return: 狗的字典(狗)
"""
def dog_attack(dog_obj, person_obj):
"""
专用提供给狗调用 攻击人
:param dog_obj: 传狗数据(字典)
:param person_obj: 传人数据(字典)
"""
print('即将被攻击的人:%s 当前血量:%s' % (person_obj.get('name'), person_obj.get('life_val'))) # 先展示当前人的状态
person_obj['life_val'] -= dog_obj.get('attack_val') # 狗咬人 直接用人的生命值减去狗的攻击力
print('狗:%s 咬了 人:%s 人掉血:%s 剩余血量:%s' % (
dog_obj.get('name'), person_obj.get('name'), dog_obj.get('attack_val'), person_obj.get('life_val')))
dog_obj = {
'name': name,
'd_type': d_type,
'attack_val': attack_val,
'life_val': life_val,
'dog_attack':dog_attack
}
return dog_obj
d1 = get_dog('小黄狗', '恶霸犬', 5,50 )
p1 = get_person('jason', 'male', 18, '猛男', 8, 80)
p1.get('person_attack')(p1, d1)
1.1.6 结论
- 将人的数据跟人的功能绑定到一起，只有人可以调用人的功能
- 将狗的数据跟狗的功能绑定到一起，只有狗可以调用狗的功能
- 我们将数据与功能绑定到一起的操作起名为:'面向对象编程'
- 本质:将特定的数据与特定的功能绑定到一起，将来只能彼此相互使用
1.2 编程思想
1.2.1 面向过程编程
- 过程就是流程，面向对象过程编程其实就是在执行一系列的流程
eg: 注册功能 登录功能 - 就是按照指定的步骤依次执行，最终就可以得到想要的结果
1.2.2 面向对象编程
- 核心就是'对象'二字，对象其实就是一个容器，里面将数据和功能绑定在一起
- eg: 游戏人物..只负责创造出该人物以及该人物具备的功能，至于后续战绩无人可知
1.2.3 结论
- 面向对象编程相当于让你给出一个问题的具体解决方案
- 面向对象编程相当于让你创造出一些事物之后不用你管
- 两种编程思想没有优劣之分 仅仅是使用场景不同，甚至很多时候是两者混合使用
1.3 类与对象的概念
1.3.1 对象
对象：数据与功能的结合体
1.3.2 类
类：多个对象相同的数据和功能的结合体
1.3.3 类比
类比学习法
一个人 对象
多个人 人类
一个狗 对象
多条狗 犬类
1.2.3 结论
- 类主要用于记录多个对象相同的数据和功能
- 对象则用于记录多个对象不同的数据和功能
- 在面向对象编程中，类仅仅是用于节省代码，对象才是核心
1.4 类与对象的创建
1.4.1 理解
- 在现实生活中理论是应该先有一个个的个体（对象）再有一个个的群体（类）
- 在编程世界中必须先有类才能产生对象
- 面向对象编程本质就是将数据和功能绑定在一起，但是为了突出面向对象的编程的形式
- python特地开发了一套语法专门用于面向对象编程的操作
1.4.2 创建类的完整语法
calss 类的名称：
# 对象公共的数据
# 对象公共的方法
# 数据与方法总称属性
- calss 是类的名字
- 后面是类的名称，类名的命名跟变量名一致，并且推荐首字母大写（为了更好的区分）
- 类体代码：公共的数据公共的方法（属性）
- 类体代码在类定义阶段就会执行
1.4.3 查看名称空间，取值
1.4.3.1 查看名称空间
class People:
# 学生对象公共的数据
school = '清华大学'
# 学生对象公共的方法
def choice_course(self):
print('正在选课')
# 查看名称空间的方法
print(People.__dict__) # 使用该方法查看名称空间 可以看成是一个字典
1.4.3.2 取值
- 字典取值
print(People.__dict__['school']) # 使用字典的取值方式获取名字
print(People.__dict__.get('choice_course')) # 使用字典的取值方式获取名字
- 句符号取值
print(People.school) # 清华大学
print(People.choice_course) # <function People.choice_course at 0x0000023B62878670>
1.5 对象实例化方法
1.5.1 定义
我们习惯将类或者对象句点符后面的东西称为属性名或者方法名
1.5.2 实列化方法
class Student:
# 学生对象公共的数据
school = '清华大学'
# 学生对象公共的方法
def choice_course(self):
print('正在选课')
'''类实例化产生对象>>>: 类名加括号'''
# 类名加括号，每次都会产生全新的对象
stu1 = Student()
stu2 = Student()
print(stu1) # <__main__.Student object at 0x000001895D834A60>
print(stu2) # <__main__.Student object at 0x000001895D86F130>
print(stu1.__dict__, stu2.__dict__) # {} {}
print(stu1.school) # 清华大学
print(stu2.school) # 清华大学
print(stu1.choice_course) # <bound method Student.choice_course of <__main__.Student object at 0x0000020F3A5E4A60>>
print(stu2.choice_course) # <bound method Student.choice_course of <__main__.Student object at 0x0000020F3A61F130>>
1.5.3 修改值
# 类名加括号，每次都会产生全新的对象
stu1 = Student()
stu2 = Student()
print(stu1.school) # 清华大学
print(stu2.school) # 清华大学
# print(stu1) # <__main__.Student object at 0x000001895D834A60>
# print(stu2) # <__main__.Student object at 0x000001895D86F130>
# print(stu1.__dict__, stu2.__dict__) # {} {}
Student.school = '北京大学'
print(stu1.school) # 北京大学
print(stu2.school) # 北京大学
1.6 对象的绑定方法
1.6.1 推导1-利用__dict__方法朝字典添加键值对
class Student:
# 学生对象公共的数据
school = '清华大学'
# 学生对象公共的方法
def choice_course(self):
print('正在选课')
# 对象独有的数据
obj1 = Student()
print(obj1.__dict__) # {}
print(obj1.school) # 清华大学
obj1.__dict__['name'] = 'jason' # 等价于 obj1.name = 'jason'
print(obj1.__dict__) # {'name': 'jason'}
print(obj1.name) # jason
obj1.__dict__['age'] = 18 # 等价于 obj1.age = 18
obj1.__dict__['gender'] = 'male' # 等价于 obj1.gender = 18
print(obj1.age) # 18
print(obj1.gender) # male
print(obj1.__dict__) # {'name': 'jason', 'age': 18, 'gender': 'male'}
1.6.2 推导2-将添加独有数据的代码封装成函数
'''推导思路2: 将添加独有数据的代码封装成函数'''
def init(obj, name, age, gender):
obj.__dict__['name'] = name
obj.__dict__['age'] = age
obj.__dict__['gender'] = gender
stu1 = Student()
stu2 = Student()
init(stu1,'jason',18,'male')
init(stu2, 'kevin',28,'female')
print(stu1.__dict__) # {'name': 'jason', 'age': 18, 'gender': 'male'}
print(stu2.__dict__) # {'name': 'kevin', 'age': 28, 'gender': 'female'}
1.6.3 推导3-init函数是专用给学生对象创建独有的数据 其他对象不能调用
class Student:
"""
1.先产生一个空对象
2.自动调用类里面的__init__方法 将产生的空对象当成第一个参数传入
3.将产生的对象返回出去
4.自动把self当作第一对象传过来
"""
def __init__(self, name, age, gender):
self.name = name # obj.__dict__['name'] = name
self.age = age # obj.__dict__['age'] = age
self.gender = gender # obj.__dict__['gender'] = gender
# 左右两边的名字虽然一样 但是意思不一样 左边的其实是字典的键 右边的其实是实参
# 学生对象公共的数据
school = '清华大学'
# 学生对象公共的方法
def choice_course(self):
print('正在选课')
stu1 = Student('jason', 18, 'male')
print(stu1.__dict__) # {'name': 'jason', 'age': 18, 'gender': 'male'}
stu2 = Student('kevin', 28, 'female')
print(stu2.__dict__) # {'name': 'kevin', 'age': 28, 'gender': 'female'}
1.7 对象独有的功能
针对对象独有的方法 我们没法真正实现
- 如果在全局则不是独有的
- 如果在类中则是公开的
- python解释器针对上述问题添加了一个非常牛的特性， 定义在类中的函数默认是绑定给对象的(相当于是对象独有的方法)
1.8 动静态方法
1.8.1 绑定给对象的方法
直接在类体代码中编写即可，对象调用会自动将对象当做第一个参数传入，类调用则有几个形参就传几个实参
1.8.2 绑定给类的方法
调用绑定类的方法，类调用会自动将类当做第一个参数传入，对象调用会自动将产生该对象的类当做第一个参数传入
1.8.3 静态方法
无论谁来调用都必须按照普普通通的函数传参方式
2.面向对象三大特性
2.1 继承
2.1.1 含义
- 在现实生活中继承其实就是用来描述人与人之间资源的关系。eg:儿子继承父亲的财产(拥有了父亲所有的资源)
- 在编程世界里继承其实就是用来描述类与类之间数据的关系。eg:类A继承类B(拥有了类B里面所有的数据和功能)
2.1.2 目的
- 现实生活中继承就是想占有别人的财产。eg:亲身父亲 干爹 干妈
- 编程世界里继承就是为了节省代码编写。eg:可以继承一个类 也可以继承多个类
2.1.3 语法结构
class 类名(类名)：
pass
- 定义类的时候在类名后家括号
- 括号内填写你需要继承的类名
- 括号内可以填写多个父类，逗号隔开即可
- 我们将被继承的类称之为：父类或基类或超类
- 我们将继承类的类称之为：子类或派生类
2.1.4 本质
- 抽象：将多个类共同的数据或功能抽取出来形成一个基类
- 继承：从下往上白嫖各个基类里面的资源
2.2 封装
2.2.1 定义
封装其实就是将数据或者功能隐藏起来（包起来，装起来），隐藏的目的不是让用户无法使用，而是给这些隐藏的数据开设特定的接口，让用户使用接口才可以去使用，而我们可以在添加一些额外的操作
2.2.2 特征
- 在定义阶段使用双下划线开头的名字，都是隐藏的属性，后续类和对象都是无法直接获取的
- 在python中不会真正的限制任何代码，隐藏的属性如果真的需要访问，也可以只不过需要做变形处理
- 格式 __变量名 = 值 _类名__变量名 = 值
- 隐藏就不改变使用变形之后的名字去访问，这样就是去了隐藏的意义
2.2.3 property伪装
2.2.3.1 理解
可以简单的理解为，将方法伪装成数据
obj.name # 数据只需要点名字
obj.func() # 方法至少还要加括号
2.2.3.2 扩展 体质指数（BMI）=体重（kg）÷身高^2（m）
class Person:
def __init__(self, name, weight, height):
self.name = name
self.weight = weight
self.height = height
@property
def BMI(self):
return self.weight / (self.height ** 2)
# BMI虽然需要计算获得 但是更像是人的数据
# TypeError: 'float' object is not callable
# p1 = Person('jason', 70, 1.80)
# res = p1.BMI()
# print(res)
p2 = Person('aaaa', 80, 1.70)
print(p2.BMI) # 68166089965398
2.3 多态
2.3.1 定义
多态：一种事物的多种形态
例：
水：液态，气态，固态
动物：人，狗，猫
2.3.2 结论
一种事物有多种形态，但是相同的功能应该有相同的名字这样的话 以后我无论拿到哪个具体的动物 都不需要管到底是谁 直接调用相同的功能即可，无论你是鸡 鸭 猫 狗 猪 只要你想叫 你就调用固定的叫的功能
2.3.3 强制操作，自觉遵守
import abc
# 指定metaclass属性将类设置为抽象类，抽象类本身只是用来约束子类的，不能被实例化
class Animal(metaclass=abc.ABCMeta):
@abc.abstractmethod # 该装饰器限制子类必须定义有一个名为talk的方法
def talk(self): # 抽象方法中无需实现具体的功能
pass
class Person(Animal): # 但凡继承Animal的子类都必须遵循Animal规定的标准
def talk(self):
pass
def run(self):
pass
obj = Person()
2.3.4 鸭子类型
只要你长得像鸭子 走路像鸭子 说话像鸭子 那么你就是鸭子
# 都是人会跑会吃
class Teacher:
def run(self):pass
def eat(self):pass
class Student:
def run(self):pass
def eat(self):pass
3. 名字查找顺序
3.1 不继承的情况下名字的查找顺序
先从对象自身查找，没有的话，再去产生该对象的类中查找（对象自身 >>> 类）
3.2 但继承的情况下名字的查找顺序
先从对象自身查找，然后是产生该对象的类 然后是一个个父类(对象 >>> 类 >>> 父类)
3.3 多继承的情况下名字的查找顺序
3.3.1 非菱形继承
非菱形继承(最后不会归总到一个我们自定义类上)深度优先(每个分支都走到底 再切换)
class D:
name = 'from D'
class E:
name = 'from E'
class F:
name = 'from F'
class A(D):
name = 'from A'
class B(E):
name = 'from B'
class C(F):
name = 'from C'
class My(A, B, C):
pass
obj = My()
print(obj.name)
3.3.2 菱形继承
菱形继承(最后归总到一个我们自定义类上)广度优先(前面几个分支都不会走最后一个类 最后一个分支才会走)
3.4 mro()方法查找顺序
可以使用类点mro()方法(结果是个列表)查看该类产生的对象名字的查找顺序
4. 经典类与新式类
4.1 经典类
不继承object或其子类的类(什么都不继承)
4.2 新式类
继承了object或其子类的类
4.3 python2 和 python3
- 在python3中所有的类默认都会继承object,也就意味着python3里面只有新式类
- 在python2中有经典类和新式类，由于经典类没有核心的功能 所以到了python3直接砍掉了
- 在定义类的时候,如果没有想要继承的父类,一般推荐以下写法,目的是为了兼容python2(码针对object无需关心 知道它的存在即可)
5. 派生方法
5.1 定义
- 子类中定义类与父类一模一样的方法并且扩展了该功能:派生（即子类继承了父类，并且在子类中定义了与父类一样的方法）
- 子类调用父类的方法super().父类的方法()
- 操作：拦截，添加，原路返回
5.2 派生实例
5.2.1 推导-时间模块与json模块
import datetime
import json
a = {
't1': datetime.datetime.today(),
't2': datetime.date.today()
}
res = json.dumps(a) # 序列化
print(res)
- 运行以上代码会报错，无法正常序列化
- 查看JSONEncoder源码发现序列化报错是有default方法触发的。
- json序列化python 数据类型是有限制的 不是所有的类型都可以,要被序列化的数据，里里外外都必须是下述类型才可以
5.2.2 解决方式
5.2.2.1 转换数据类型
手动将不符合数据类型要求的数据转成符合要求的
a = {
't1': str(datetime.datetime.today()),
't2': str(datetime.date.today())
}
res = json.dumps(a)
print(res) # {"t1": "2022-07-28 15:16:41.417239", "t2": "2022-07-28"}
5.2.2.2 利用派生方法
如果想要避免报错 那么肯定需要对default方法做修改(派生)
a = {
't1': datetime.datetime.today(),
't2': datetime.date.today()
}
class MyJsonEncode(json.JSONEncoder):
def default(self, o):
'''o 就是json即将要序列化的数据'''
if isinstance(o, datetime.datetime):
return o.strftime('%Y-%m-%d %H:%M:%S')
elif isinstance(o, datetime.date):
return o.strftime('%Y-%m-%d')
# 如果是可以序列化的类型，那么不做任何处理，直接让他序列化即可
return super().default(o)
res = json.dumps(a, cls=MyJsonEncode)
print(res) # {"t1": "2022-07-28 16:05:23", "t2": "2022-07-28"}
6. 面对对象之反射
6.1 定义
通过字符串来操作对象的数据或方法
6.2 主要方法
- hasattr():判断对象是否含有某个字符串对应的属性
- getattr():获取对象字符串对应的属性
- setattr():根据字符串给对象设置属性
- delattr():根据字符串给对象删除属性
6.3 什么情况下用反射
只要在需求中看到了关键字（...对象...字符串）那么肯定需要使用反射
6.4 反射实例
6.4.1 加载配置文件纯大写的配置
# 配置文件加载：获取配置文件中所有大写的配置，小写的直接忽略，组织成字典
import settings
new_dict = {}
# print(dir(settings)) # dir获取括号中对象可以调用的名字
# ['AGE', 'INFO', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'desc', 'name']
for i in dir(settings):
if i.isupper(): # 如果名字是纯大写 那么获取该大写名字对应的值 'AGE' 'INFO'
v = getattr(settings, i)
new_dict[i] = v
print(new_dict)
6.4.2 模拟操作系统cmd终端执行用户命名
class WinCmd(object):
def dir(self):
print('dir获取当前目录下所有的文件名称')
def ls(self):
print('ls获取当前路径下所有的文件名称')
def ipconfig(self):
print('ipconfig获取当前计算机的网卡信息')
obj = WinCmd()
while True:
cmd = input('请输入您的命令>>>:')
if hasattr(obj, cmd):
cmd_name = getattr(obj, cmd)
cmd_name()
else:
print('%s 不是内部或外部命令，也不是可运行的程序或批处理文件' % cmd)
7. 面向对象魔法方法
7.1 定义
- 魔法方法其实就是类中定义的双下方法，之所以会叫魔法方法原因是这些方法都是到达某个条件自动触发无需调用
- eg:__init__方法在给对象设置独有数据的时候自动触发（实例化）
7.2 魔法方法触发的条件
7.2.1 实例化对象的时候自动触发
# 1.实例化对象的时候自动触发
class MyClass(object):
def __init__(self, name):
print('__init__方法')
self.name = name
7.2.2 对象被执行打印操作的时候会自动触发
该方法必须返回一个字符串，返回什么字符串打印对象之后就展示什么
# 2.对象被执行打印操作的时候会自动触发
# 该方法必须返回一个字符串，返回什么字符串打印对象之后就展示什么
def __str__(self):
print('__str__方法')
print('这是类：%s 产生的一个对象')
return '对象：%s' %self
7.2.3 对象加括号调用，自动触发该方法
# 3.对象加括号调用，自动触发该方法
def __call__(self, *args, **kwargs):
print('__call__方法')
print(args)
print(kwargs)
7.2.4 当对象获取一个不存在的属性名，自动触发
该方法返回什么 对象获取不存在的属性名就会得到什么，形参item就是对象想要获取的不存在的属性名
# 4.当对象获取一个不存在的属性名，自动触发
# 该方法返回什么 对象获取不存在的属性名就会得到什么，形参item就是对象想要获取的不存在的属性
def __getattr__(self, item):
print('__getattr', item)
return '您想要获取的属性名:%s不存在'%item
7.2.5 对象操作属性值的1时候自动触发: 对象.属性名= 属性值
# 5.对象操作属性值的1时候自动触发: 对象.属性名= 属性值
def __setattr__(self, key, value):
print("__setattr__")
print(key)
print(value)
super().__setattr__(key, value)
7.2.6 对象在被删除(主动 被动)的时候自动触发
# 6.对象在被删除(主动 被动)的时候自动触发
def __del__(self):
print('__del__')
7.2.7 对象获取属性的时候自动触发
# 7.对象获取属性的时候自动触发
# 无论这个属性存不存在, 当类中既有__getattr__又有__getattribute__的时候 只会走后者
def __getattribute__(self, item):
print('__getattribute__')
# return super(MyClass, self).__getattribute__(item) # 复杂写法
return super().__getattribute__(item) # 简便写法
7.2.8 对象被with语法执行的时候自动触发
# 8.对象被with语法执行的时候自动触发
# 该方法返回什么 as关键字后面的变量名就能得到什么
def __enter__(self):
print('__enter__')
7.2.9 对象被with语法执行并运行完with子代码之后 自动触发
# 9.对象被with语法执行并运行完with子代码之后 自动触发
def __exit__(self, exc_type, exc_val, exc_tb):
print('__exit__')
7.3 魔法方法笔试题
# 补全以下代码 执行之后不报错
class Context:
pass
with Context() as f:
f.dp_something()
class Context:
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
pass
def do_something(self):
pass
with Context() as f:
f.do_something()
8. 元类
8.1 元类简介
8.1.1 基础阶段使用type来查找数据的数据类型。
s1 = '元类简介'
l2 = [1, 2, 3]
a = {'name': 'jason', 'age': 18}
print(type(s1)) # <class 'str'>
print(type(l2)) # <class 'list'>
print(type(a)) # <class 'dict'>
8.1.2 type用于查看产生当前对象的类是谁
学了面向对象之后，发现产看的不是数据类型，而是数据所属的类，我们定义的数据类型 其实本质还是通过各个类产生了对象
class MyClass:
pass
obj = MyClass()
print(type(obj)) # 查看产生对象obj的类:<class '__main__.MyClass'>
print(type(MyClass)) # 查看产生对象MyClass的类:<class 'type'>
8.1.3 结论
自定义的类都是由type类产生的，我们将产生类的类称之为 '元类'
8.2 产生类的两种的方式
8.2.1 方式1
1.class关键字
class MyClass:
pass
8.2.2 方式2
2.利用元类type
type(类名,类的父类,类的名称空间)
8.2.3 总结
学习元类其实就是掌握了类的产生过程，我们就可以在类的产生过程中高度定制化类的行为
eg: 类名必须首字母大写
8.3 元类的基本使用
8.3.1 只有继承了type的类才可以称之为是元类
如果想要切换产生类的元类不能使用继承 必须使用关键字metaclass声明
class MyMetaClass(type):
pass
class MyClass(metaclass=MyMetaClass):
pass
8.3.2 思考
# 思考
类中的__init__用于实例化对象
元类中__init__用于实例化类
class MyMetaClass(type):
def __init__(self,what, bases=None, dict=None):
# print('别晕')
# print('what', what) 类名
# print('bases', bases) 类的父类
# print('dict', dict) 类的名称空间
if not what.istitle():
# print('首字母必须大写 你会不会写python 面向对象学过吗 lowB')
raise Exception('首字母必须大写 你会不会写python 面向对象学过吗 lowB')
super().__init__(what, bases, dict)
9. 双下new
9.1 类产生对象的步骤
- 产生一个空对象
- 自动触发__init__方法实例化对象
- 返回实例化好的对象
9.2 双下new
- __new__方法专用于产生空对象（骨架）
- __init__方法专门用于给对象添加属性（血肉）
10. 操作系统
10.1 linux系统
- linux系统：一切皆文件
只要你能读数据 能写数据 那么你就是文件
# 内存 硬盘
class Txt: # Txt类有两个与文件类型同名的方法，即read和write
def read(self):
pass
def write(self):
pass
class Disk: # Disk类也有两个与文件类型同名的方法：read和write
def read(self):
pass
def write(self):
pass
class Memory: # Memory类也有两个与文件类型同名的方法：read和write
def read(self):
pass
def write(self):
pass
10.2 python
- python: 一切皆对象
只要你有数据 有功能 那么你就是对象
eg: 文件名 文件对象
模块名 模块对象
浙公网安备 33010602011771号