目录
1.isinstance和isinstance
2.反射
2.1 反射模块
2.2 反射实际应用案列
2.3 反射隐藏属性and设置属性
3.反射内置方法 __setattr__ __delattr__ __getattr__
4.__getattribute__ 属性被访问时行为
5.__setitem__ __getitem__ __delitem__ []获取 设置 删除
6.__format__格式化打印格式
7.__str__ 显示内容
8.__del__ 关闭系统资源
9.__doc__ 类的注释信息
10.__call__ 预执行
11.__new__ 对象生成
12.__init__ 初始化
13.__all__ 限制属性
14.__len__ 计算长度
15.__hash__ 转换类型
16.__eq__ 对象 == 触发
17. __class__ 显示对象类
18.__module__ 显示对象所属模块
19.__slots__ 控制对象可以使用的属性
20. __dict__ 对象属性
21.__next__和__iter__ 实现迭代器
22.__enter__和__exit__ 上下文管理器
23.描述符
23.1 描述符小案例
23.2 描述符的分类
23.3描述符机制来实现类型限制功能
24.类的装饰器
24.1 自制property装饰器
24.2 @classmethod类方法
24.3 @staticmethod 静态方法
1.isinstance和isinstance
# 判断某个对象是不是某个类的实例
# isinstance()
class Person:
pass
class Student(Person):
pass
stu = Student()
#判断 两个对象是不是同一个类型
print(type(1) == type(1))
# 判断stu对象是不是Student类的实例
print(isinstance(stu,Student))
# 是不是子类
# issubclass()
# 判断一个类是不是 另一个类子类 (所有类都是object的子类或子子类)
print(issubclass(Student,object))
# 单继承（父类--》父类）
class Animal:
pass
class Dog(Animal):
pass
class TDog(Dog):
pass
print(issubclass(TDog,Dog))
print(issubclass(TDog,Animal))
# 多继承下
import json
class Foo:
pass
# 多继承
class Mydic(dict,Foo):
def to_json(self):
return json.dumps(self)
# 判断多继承类是不是子类
print(issubclass(Mydic,dict))
print(issubclass(Mydic,Foo))
# py3中：所有的类都是由type构造来的
# py3中：所有类都继承object
# print(type(object))
# print(type(type))
2.反射
"""
反射：通过字符串来操作类或者对象的属性
hasattr() # 判断一个对象中是否由某个属性或方法
getattr() # 通过字符串获取对象中的属性或方法
setattr() # 通过字符串设置对象的属性或方法
delattr() # 通过字符串删除对象的属性或方法
"""
# 一、hasattr() # 判断一个对象中是否由某个属性或方法
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def print_name(self):
print(self.name)
p = Person('mzk', 18)
# 判断p对象中是否有name属性和print_name方法
# p是对象判断字符串name属性是否存在
print(hasattr(p,'name'))
# print('name' in p.__dict__)
# p是对象判断字符串print_name方法是否存在
print(hasattr(p,'print_name'))
# print('print_name' in Person.__dict__)
# 二、getattr() # 通过字符串获取对象中的属性或方法
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def print_name(self):
print(self.name)
p = Person('mzk', 18)
# 一个通过字符串获得（反射），一个通过点：正常的对象调用方法
f=getattr(p,'print_name')
f=p.print_name
print(f) # 函数内存地址
f() # 执行
# 三、setattr() # 通过字符串设置对象的属性或方法
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def print_name(self):
print(self.name)
p = Person('mzk', 18)
# 反射属性到对象名称空间
p=setattr(p,'sex','男')
# 对象属性的设置
p.sex='男'
print(p)
# 反射属性到类名称空间
setattr(Person,'sex','男')
# 类的属性设置
Person.sex='未知'
print(p.sex)
# 反射方法到类的内部
def xxx(self):
print('xxx')
print(self.age)
# 绑定给对象的方法是写在类中，如果使用反射，要反射到类内部
setattr(Person,'print_age',xxx)
p.print_age()
# 反射对象
def xxx(obj):
print(obj.age)
setattr(p,'print_age',xxx)
p.print_age(p)
# 四、delattr() # 通过字符串删除对象的属性或方法
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def print_name(self):
print(self.name)
p = Person('mzk', 18)
delattr(p,'name') # 通过反射删除了属性
print(p.name) # 查询没有
delattr(p,'print_name') # 通过反射删除了方法
p.print_name() # 查询没有
2.1 反射模块
方法： __import__('字符串')
# 使用小方法
i=input('请输入使用哪个模块：')
# 模块以字符串形式传入
s1=__import__(i)
# 调用模块方法
s1.test()
# 打印模块中的变量
print(s1.name)
# 拓展,带路径的模块导入，点路径
i = input('请输入使用哪个模块：')
s1 = __import__(i, fromlist=True)
s1.test()
print(s1.name)
# 反射模块（py3中用的比较多，框架中）
import importlib
i=input('请输入您要使用的模块：')
a=importlib.import_module(i)
a.test()
2.2 反射实际应用案列
class Person:
def __init__(self, name, age, sex):
self.age = age
self.sex = sex
self.name = name
def print_age(self):
print(self.age)
def print_name(self):
print(self.name)
def print_sex(self):
print(self.sex)
def print_info(self):
print('我的名字是%s，年龄是%s，性别是%s' % (self.name, self.age, self.sex))
def server_forever(self):
while True:
ss = input('请输入您要执行的方法,按q退出') #
if 'q' == ss.lower(): break
if hasattr(self, ss):
# f=getattr(self,ss)
# f()
# 下面这一步等同于上面注释的那两个
getattr(self, ss)()
else:
print('您输入的指令不执行，我正在学习中')
p = Person('mzk', 18, '男')
p.server_forever()
2.3 反射隐藏属性and设置属性
# 反射成隐藏属性
class Person:
def __init__(self, name, age, sex):
self.age = age
self.sex = sex
self.__name = name
p = Person('lqz', 18, '男')
# name=getattr(p,'__name') # 这个方法拿不到隐藏属性
# __dict__方法中的写法可以拿到
name=getattr(p,'_Person__name')
print(name)
# 设置成隐藏属性
class Person:
def __init__(self, name, age, sex):
self.age = age
self.sex = sex
self.__name = name
def print_wife(self):
print(self.__wife)
p = Person('lqz', 18, '男')
# 对象方法：设置隐藏属性
setattr(p,'__wife','刘亦菲')
print(p.__wife) # 能拿到属性
# 对象和字符串类名加属性隐藏
setattr(p,'_Person__wife','刘亦菲')
print(p.__dict__)
print(p.__wife) # 拿不到
# 直接从方法中拿到返回值的隐藏属性
p.print_wife()
# 类的方法：设置隐藏属性
# 类和字符串类名加属性隐藏
setattr(Person,'_Person__wife','刘亦菲')
print(Person.__dict__)
print(Person._Person__wife) # 拿到隐藏属性
# 直接从方法中拿到返回值的隐藏属性
p.print_wife()
3.反射内置方法 __setattr__ adn __delattr__ and __getattr__
'''
# 面向对象中的魔法方法,在某种情况下就会触发它的执行
# __setattr__ ：在 对象.属性=值 会触发它的执行
# __getattr__ ：在 对象.属性 获取值会触发它的执行
# __delattr__ ：在 del 对象.属性 会触发它的执行
setattr(对象,key,value)
内部：对象.__setattr__(key,value)
保证对象必须要有__setattr__，所有类的基类，object中有__setattr__
'''
class Person:
def __setattr__(self, key, value):
# print('我执行了')
# print(key)
# print(value)
# setattr(self,key,value) # 本质会调用对象自己的__setattr__ ,出递归，报错
object.__setattr__(self,key,value)
def __getattr__(self, item): # 当属性不在对象中，会触发它的执行
print('我执行了')
def __delattr__(self, item):
# delattr(self,item)
print('删除会触发我')
p = Person()
p.name = 'mzk'
# print(p.age)
del p.name
4.__getattribute__ （了解即可）
'''
无论属性在对象中是否存在，都先触发__getattribute__的执行（用的比较少）
对象.属性 调用顺序
先执行：__getattribute__----》类的名称空间----》__getattr__（本质是去对象自己的名称空间拿东西）
对象.属性的查找顺序
当getattribute与getattr同时存在，只会执行getattrbute，
除非getattribute在执行过程中抛出异常AttributeError
重点： __getattribute__: 对象.属性---》__getattribute__---》__getattr__
'''
class Person:
name = 'lqz'
# 属性不存在，才触发
def __getattr__(self, item):
print('getattr触发了')
def __getattribute__(self, item):
print('__getattribute__触发了')
p = Person()
print(p.name)
5. __setitem__ 、__getitem__ 、__delitem__(了解即可)
'''
__getitem__:通过中括号取值触发它的执行
__setitem__：通过中括号赋值，触发它的执行
__delitem__：通过中括号删除值，触发它的执行
item系列
__getitem__: 对象['name'],触发它的执行
__setitem__： 对象['name']='value',触发它的执行
__delitem__: del 对象['name'],触发它的执行
应用：把一个对象做成既能.取值赋值，又能[] 取值赋值
-自己定义这种类（会出现递归现象，反射setattr）
-对象.__dict__
-object.__setattr__(self,key,value) 普通函数，有几个值，就传几个值
-object.__setattr__(self,key,value)
-对象.__name='mzk'
后期封装+setattr的使用（注意）
后期源码中常出现的操作（flask框架源码中使用）
-object.__setattr__(self,'_类名__属性名',value)
-对象.__dict__[_类名__属性名]='mzk'
-类内部使用 self.__属性名
-类外部使用： 对象._类名__属性名
'''
class Person:
def __getitem__(self, item):
print('__getitem__执行')
def __setitem__(self, key, value):
print('__setitem__执行')
def __delitem__(self, key):
print('__delitem__执行')
p=Person()
p['name']='lqz'
p['name']
del p['age']
# 自己定义一个字典，但是不继承字典
# 作业：写一个字典，不继承字典，支持 [] 取值赋值，不支持 . 取值赋值
class Mydict:
def __init__(self,**kwargs):
# 方案一
# for key,value in kwargs.items():
# setattr(self,key,value)
# 方案二
self.__dict__.update(kwargs)
# 方案三
# for key,value in kwargs.items():
# self.__dict__[key]=value
def __getitem__(self, item):
# 方案一
# return self.__dict__[item]
# 方案二
return getattr(self,item)
def __setitem__(self, key, value):
# 方案一
# setattr(self,key,value)
# 方案二
self.__dict__[key]=value
def __delitem__(self, key):
del self.__dict__[key]
dic=Mydict(name='lqz',age=18)
# 打印属性
print(dic.name)
# 触发__getitem__方法
print(dic['name'])
# 触发__setitem__方法
dic['age']=18
print(dic.age)
# 触发__delitem__方法
del dic.age
print(dic.__dict__)
6.__format__ 格式化打印格式(了解即可)
'''
__format__
-format(对象) ---》触发类中__format__的执行
-'{:n-m}'.format(对象) ---》触发类中__format__的执行
'''
# 一 字符串格式
s = '我的名字是：%s' % 'mzk'
print(s)
# 字符串的format方法支持的格式化方式
res = '我的名字是{}，年龄是{}'.format('mzk', 18)
res = '我的名字是{0}，年龄是{1}'.format('mzk', 18)
ll = ['mzk', 19]
l2 = ['男']
res = '我的名字是{0[0]}，年龄是{0[1]},性别是{1[0]}'.format(ll, l2)
dic = {'name': 'mzk', 'age': 19, 'sex': '男'}
res = '我的名字是{name}，年龄是{age},性别是{sex}'.format(**dic)
class Person:
def __init__(self):
self.name = 'mzk'
self.age = 19
self.sex = '男'
p = Person()
# res='我的名字是{0.name}，年龄是{0.age},性别是{0.sex}'.format(p)
res = '我的名字是{obj.name}，年龄是{obj.age},性别是{obj.sex}'.format(obj=p)
print(res)
# 对象的__format__
class Person():
__dic = {
'n-a': '名字是：{obj.name}-----年龄是：{obj.age}', # 名字是：mzk-年龄是：18
'n:a': '名字是：{obj.name}:::::年龄是：{obj.age}', # 名字是：mzk：年龄是：18
'n/a': '名字是：{obj.name}/////年龄是：{obj.age}', # 名字是：mzk/年龄是：18
}
def __init__(self, name, age, sex):
self.name = name
self.sex = sex
self.age = age
def __format__(self, format_spec):
# print(format_spec)
if format_spec and format_spec in self.__dic:
s = self.__dic[format_spec]
else:
s = self.__dic['n-a']
return s.format(obj=self)
p = Person('mzk', 18, '男')
# 内置函数
# 第一种触发它执行
# res=format(p)
# res=format(p,'n-a')
# res = format(p,'n/a')
# res = format(p,'n:a')
print(format(p, 'n-a'))
# 第二种触发方式
# print('n-a'.format(p))
# 写一个Date类，实例化的时候传入年 月 日，格式化方法
# d=Date(2020,12,23)
# print('y-m-d'.format(p)) # 2020-12-23
# print('y/m/d'.format(p)) # 2020/12/23
# print('y：m：d'.format(p)) # 2020：12：23
# print('y年m月d日'.format(p)) # 2020年12月23日
7.__str__显示内容
"""
__str__
前后带杠杠的都是特殊的内置函数 会在某些时机自动执行 一般情况我们不应该直接调用他们
当我们需要自定义打印显示内容时 就需要实现__str__方法
该方法必须返回一个字符串 返回的是什么 打印出来就是什么
"""
class Test:
def __init__(self,name):
self.name = name
def __str__(self):
print("str run....")
return self.name
t = Test("安米")
# __str__ : print(对象) 触发对象的 __str__
print(t)
# 在讲一个对象转换字符串时 本质就是在调用这个对象 __str__方法
print(str(t))
8.__del__关闭系统资源
"""
__del__
当对象被从内存中删除时会自动执行
另一种情况时 程序员手动删除了这个对象 也会自动执行
什么时候使用它
在python中 有自动内存管理机制 所以 python自己创建的数据 不需要我们做任何操作
但是有一种情况 我们使用python打开了一个不属于python管理的数据
比如打开了一个文件 这个文件一定是操作系统在打开 会占用系统内存 而python解释器无法操作系统内存的
所以 当你的python解释器运行结束后 文件依然处于打开状态 这时候就需要使用__del__来关闭系统资源
简单地说 当程序运行结束时 需要做一些清理操作 就使用__del__
__del__也称之为 析构函数
分析构造 并拆除这个对象
"""
class TextFile:
def __init__(self,filepath,mode="rt",encoding="utf-8"):
self.file = open(filepath,mode=mode,encoding=encoding)
def read(self):
return self.file.read()
def write(self,text):
self.file.write(text)
# 该方法其实就是一个通知性质 仅仅是告诉程序员 对象即将被删除
def __del__(self):
# 在这里关闭系统的文件 妥妥的
self.file.close()
tf = TextFile("今日内容.txt")
tf.read()
tf.write()
# tf.file.close() 不需要手动关闭了 在对象删除时会自动关闭
9. __doc__ 类的注释信息
'''
__doc__: 类下面的注释 类名.__doc__ ,把注释打印出来
'''
class Person:
'''
类的提示信息，注释
'''
pass
print(Person.__doc__)
from bs4 import BeautifulSoup
print(BeautifulSoup.__doc__)
# 注意：继承关系下，类的注释不能继承
class Animal:
'''
Animal的注释，动物类，所有属于动物的都继承我
'''
class Person(Animal):
pass
print(Animal.__doc__)
print(Person.__doc__)
10.__call__预执行
"""
__call__ 调用的意思
在对象被调用时 执行 函数 类
自定义元类的目的
1.可以通过__call__ 来控制对象的创建过程
2.可用控制类的创建过程
"""
# 自定义一个元类 元类也是一个类 但是需要继承type
class MyMeta(type):
# self 表示要创建对象的那个类(Person) *args是调用Person类时传入的参数
def __call__(self, *args, **kwargs):
print("MyMte中的 call run'")
print(self, *args, **kwargs)
# 下面的三步是固定写法 一个模板 只要你需要控制对象的创建过程 就应该先把模板写出来
# 1.创建空对象
obj = object.__new__(self)
# 2.调用初始化方法
self.__init__(obj, *args, **kwargs)
# self.__init__(obj)
# 3.得到一个完整的对象
return obj
# 修改Person类的元类为MyMeta
class Person(metaclass=MyMeta):
def __init__(self, name, age):
self.name = name
self.age = age
def __call__(self, *args, **kwargs):
print("call run...")
# 调用Person这个对象时 执行的是 Person的类(type)中__call__ 方法
p = Person("张三疯", 80)
# print(p)
# 当调用对象时 会执行该对象所属类中的__call__方法
p()
# print(p.name)
# print(p.age)
11.__new__ 对象生成
'''
__new__ 对象生成 ，类() 会触发,是在__init__之前触发
类实例化得到对象的本质是先调用__new__生成一个空对象，然后再调用__init__完成初始化
总结:类实例化得到对象,本质是在执行类的 __new__,返回什么对象,p拿到的就是什么对象,在__new__内部,调用了__init__
'''
class Person:
def __init__(self, name):
# 初始化,self这个对象,已经造出来了
# self是在哪里造出来的? __new__中造出来的
print('__init__执行了')
print(self)
self.name = name
# def __new__(cls, *args, **kwargs):
# print('我出生了')
# print(args)
# print(kwargs)
# # return 1
# cls.__init__(1,*args)
# ## 如果一个类,没有重写 __new__方法,在__new__中自动触发了对象的__init__的执行
def __new__(cls, *args, **kwargs):
print('我出生了')
# cls(*args,**kwargs) # 出递归
# obj=object.__new__(cls) # 静态方法之类来调用
obj = super().__new__(cls) # 静态方法之对象来调用
cls.__init__(obj, *args, **kwargs) # 穿衣服,调用__init__
## 如果一个类,没有重写 __new__方法,在__new__中自动触发了对象的__init__的执行
return obj # 必须要return,造出来的对象
p = Person('mzk')
print(p)
print(p.name)
# 列子
'''
Person()---->本质触发的是__new__,因为__new__返回什么对象就是什么
__init__是初始化方法,在__new__后执行的
__new__:创造出一个空对象,没有初始化
__init__:创造完空对象后,再触发它,完成初始化
'''
class Person:
def __init__(self,name):
print('我执行了,我是__init__')
self.name=name
def __new__(cls, *args, **kwargs):
print('我出生了')
# __new__内部会触发 self.__init__的执行
obj=object.__new__(cls)
# return {'name':'l1z'} # 不会触发__init__
return obj # 触发 __init__
p=Person('lqz') # 触发__new__,返回 1 对象
print(p)
12.__init__ 初始化
'''
__init__ 对象初始化调用 类() 会触发
'''
13.__all__ 限制属性
# a.py
__all__=['age','name']
age=10
name='lqz'
sex='男'
# __all__:使用from a import *导入模块时,限制能够使用的属性
# 在使用from a import * 导入模块时,只能导入__all__指定的属性
from a import *
print(age)
print(name)
# print(sex)
14.__len__ 计算长度
'''
__len__:计算对象长度,返回几,len(对象),结果就是几
len(对象)----》触发对象的__len__()
'''
class Foo:
def __init__(self, name, age):
self.name = name
self.age = age
def __len__(self):
return len(self.name)
f = Foo('lqz', 19)
print(len(f))
15.__hash__ 转换类型（了解即可）
'''
__hash__
-字典类型---》hash类型---》key值必须可hash
-可变类型（字典，列表）不可hash，不可变类型（数字，字符串，元组）可以hash，可以作为字典的key
-重写自己定制的类的hash方法，使对象可以hash
__hash__ ,hash(对象)触发执行,返回什么就是什么
如果一个对象不可hash,通过重写 __hash__让它变得可hash
'''
# 普通用法
l=['1',3,54,56]
dic={'name':'lqz'}
a=10
print(hash(a))
# print(hash(dic))
print(hash(l))
# 魔法方法
class Foo:
def __init__(self):
self.name = 'lqz'
self.l = ['1', 3, 4]
def __hash__(self):
return hash(self.name)
f = Foo()
print(hash(f))
16.__eq__对象 == 触发（了解即可）
'''
两个对象 == 比较的时候,触发 __eq__的执行,在内部,自定制比较规则即可
'''
class Foo:
def __str__(self):
return self.name
def __init__(self):
self.name='lqz'
def __eq__(self, other):
# print(self)
# print(other)
# 自己定制比较规则
if self.name == other.name:
return True
else:
return False
f1=Foo()
# f1.name='mzk'
f1.age=999
f2=Foo()
f2.age=888
print(f1==f2)
# print(f1 is f2)
17.__class__ 显示对象类（了解即可）
'''
__class__ 对象.__class 查看对象的类
'''
class Animal:
pass
class Person(Animal):
pass
print(Person.__bases__) # 查看所有父类
p=Person()
print(p.__class__) # 查看对象的类
18.__module__ 显示对象所属模块（了解即可）
'''
__modules__:看对象属于哪个模块
'''
from a import C
obj = C()
class Person():
pass
p=Person()
print(obj.__module__)
print(p.__module__)
19.__slots__ 控制对象可以使用的属性
'''
__slots__:控制对象可以使用的属性
-控制对象的属性（__dict__没了）
-对象很多，对象属性比价少
-本质：对象没有__dict__，统一被类的__dict__管理起来了，在dict内部使用更紧凑的存储方式，节约内存空间
'''
slots的使用
对象只拥有name和age属性,其它放不进去
class Person:
__slots__ = ['name', 'age'] # 对象只拥有name和age属性
# __slots__ = 'name'
def __init__(self, name, age):
self.name = name
self.age = age
def __str__(self):
return self.name
p = Person('mzk', 18)
print(p.name)
p.sex = '男'
20. __dict__ 对象属性
'''
__dict__ 查看对象中的属性
'''
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def __str__(self):
return self.name
p = Person('mzk', 18)
p.sex = '男'
print(p.__dict__)
21.__next__和__iter__实现迭代器
'''
0 python中的for循环，是依赖于迭代的循环，不依赖于索引
# 1 for i in 可迭代对象
# 2 java中 for(i=0;i++;i<10){}
# 3 python中 for循环的本质
for i in 可迭代对象:会调用可迭代对象的__iter__,得到一个迭代器对象，不停的调用对象.__next__，得到一个值，直到抛出异常，for循环结束
1 可迭代对象：对象有__iter__方法的，就是可迭代对象，调用__iter__,得到迭代器对象
2 迭代器对象：既有__iter__又有__next__对象，就是迭代器对象
__iter__和__next__
-可迭代对象：对象有__iter__方法，这个对象就是一个可迭代对象
-for循环本质就是在循环可迭代对象
-for i in 对象（必须是可迭代对象）
-for循环的本质：先调用对象的__iter__得到一个迭代器对象，然后调用迭代器对象的__next__ 方法，每次获得一个值（next这种获取值的方式不依赖于索 引，又叫迭代循环）
-迭代器对象：
-既有__iter__又有__next__的对象，就是迭代器对象
-迭代器对象一定是可迭代对象
-定制自己的可迭代对象
-重写类中的__iter__和__next__
-让它支持for循环直接循环（做出一种不依赖于索引取值的方式）
-不停的return 值，当要停下时，抛出异常
'''
＃ 链式调用(跟语言无关)
f.test().test2().test3() # java,js:中广泛应用,设计程序的模式
# 如何实现支持链式调用的对象
class Foo:
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
def print_name(self):
print(self.name)
return self
def print_age(self):
print(self.age)
return self
def print_sex(self):
print(self.sex)
return self
f=Foo('lqz',16,'男')
f.print_name()
f.print_sex()
f.print_age()
# 链式调用
f.print_name().print_sex().print_age()
# 1 给一个类,重写__iter__,__next__
class Foo:
def __init__(self):
self.__x = 1
def __iter__(self):
return self
def __next__(self):
self.__x += 1
return self.__x
f = Foo() # f就是一个可迭代对象,所以他就能够被for 循环
# 自定制可迭代对象(自己写的对象,可以迭代,可以被for循环)
for i in f: # f.__iter__()----->每循环一次,调用一下 f.__next__()
print(i)
# 2 加入异常,for循环该对象,可以停止
class Foo:
def __init__(self,start,end):
self.__start = start
self.__end=end
def __iter__(self):
return self
def __next__(self):
self.__start+=1
if self.__start>=self.__end:
raise StopIteration('') # 抛出一个异常,程序就结束了
return self.__start
for i in Foo(1,20):
print(i)
# 实现自己的range
class MyRange:
def __init__(self, start, end,step=1):
self.__start = start
self.__end = end
self.__step = step
def __iter__(self):
return self
def __next__(self):
self.__start += self.__step
if self.__start >= self.__end:
raise StopIteration('') # 抛出一个异常,程序就结束了
return self.__start
for i in MyRange(1, 20):
print(i)
# 斐波那契数列(通过__iter__和__next__实现)
# 产生小于多少的斐波那契数列
class Fib:
def __init__(self, count):
self.start = 0
self.second = 1
self.count = count
def __iter__(self):
return self
def __next__(self):
self.start,self.second=self.second,self.start+self.second
if self.start >= self.count:
raise StopIteration()
return self.start
for i in Fib(100):
print(i)
22.__enter__和__exit__上下文管理器
'''
with open() as f:
with 上述叫做上下文管理协议，即with语句，为了让一个对象兼容with语句，必须在这个对象的类中声明enter和exit方法
优点:
使用with语句的目的就是把代码块放入with中执行，with结束后，自动完成清理工作，无须手动干预
在需要管理一些资源比如文件，网络连接和锁的编程环境中，可以在exit中定制自动释放资源的机制，你无须再去关系这个问题，这将大有用处
-with：上下文管理协议
-with 对象 as f: # 处理异常，不被with管理后，会清理资源
代码
代码
-学过的 open,支持上下文管理协议
-自定制一些对象，支持with管理
-在类中重写 __enter__和__exit__
-with 你写的对象 as f:
# 触发对象的__enter__ 方法执行，做一些初始化的工作，返回一个对象，会给f
# 写代码，可以有异常，不用咱们手动处理异常
-脱离了with的管理，会执行对象的__exit__，处理异常，资源清理工作
'''
# __enter__ 和 __exit__
class Open:
def __enter__(self):
print('enter执行了')
def __exit__(self, exc_type, exc_val, exc_tb):
print('--',exc_type)
print('--',exc_val)
print('--',exc_tb)
print('exit执行了')
# with 对象,触发对象的 __enter__的执行
# 顶格写,脱离了with,就会执行 __exit__
with Open() as f:
print('with上下文管理器')
print(f)
print('with结束了')
class Open:
def __str__(self):
return 'f对象'
def __enter__(self):
print('enter执行了')
return self
def __exit__(self, exc_type, exc_val, exc_tb):
print('--',exc_type)
print('--',exc_val)
print('--',exc_tb)
print('exit执行了')
f=Open()
# print(f)
with f as ff1:
print('with上下文管理器')
print(f)
print(ff1) # enter的执行返回结果赋值给ff1
print(f is ff1)
print('with结束了')
# exit的参数解释:exit()中的三个参数分别代表异常类型，异常值和追溯信息,with语句中代码块出现异常，则with后的代码都无法执行
class Open:
def __enter__(self):
print('enter执行了')
return self
def __exit__(self, exc_type, exc_val, exc_tb):
print('异常类型',exc_type)
print('异常信息',exc_val)
print('追溯信息',exc_tb)
print('exit执行了')
return True # 忽略掉异常,不爆红
with Open() as f:
f.witer() # 没有
print('结束')
# 自定制一个open,打开文件
class Open:
def __init__(self, path, mod='rt', encoding='utf-8'):
self.f = open(path, mod, encoding=encoding)
def __enter__(self):
return self.f
def __exit__(self, exc_type, exc_val, exc_tb):
# 如果exc_tpye 不为空,表示with上下文内部出了错误,处理错误
if exc_type:
print('程序出错了,但是我处理好了,继续执行就好了')
print(exc_val)
return True
# 没有错误,正常结束,资源清理工作(关闭文件)
print('文件关闭了,放心好了')
self.f.close()
# def read(self):
# return self.f.read()
# 后期会使用with ,处理数据库链接,redis链接
with Open('a.txt', 'r', encoding='utf-8') as f:
res = f.read()
print(res)
23.描述符
'''
描述符是什么?
就是一个新式类,实现了 __get__ __set__ __delete__ 其中一个,就被称为描述符类
作用: 代理类属性
class Person:
name=描述符() # 代理类属性
描述符
-新式类，__get__ __set__ __delete__
-代理类的属性（一旦使用描述符代理，对象的__dict__中没有这个属性了）
-数据描述符和非数据描述符（__get__）
1.类属性
2.数据描述符
3.实例属性(对象属性)
4.非数据描述符
5.找不到的属性触发getattr()
-通过描述符写了一个控制对象类型的案例
-通过类装饰器+描述符实现对象类型控制
-自定制 property
-自定制 classmethod
-自定制 staticmethod
'''
23.1 描述符小案例
# 小案例,写一个描述符类(get,set,delete 参数都是固定的)
class Foo:
def __get__(self, instance, owner):
print('触发get')
def __set__(self, instance, value):
print('触发set')
def __delete__(self, instance):
print('触发delete')
f1 = Foo()
f1.name = 'mzk' # 不会触发 __set__的执行
# 这种情况会触发
class Str:
def __get__(self, instance, owner):
print('触发get')
def __set__(self, instance, value):
print('触发set')
def __delete__(self, instance):
print('触发delete')
class People:
age=19
name = Str()
def __init__(self, name): # name被Str类代理，age被Int类代理
self.name = name # 触发描述符类,set的执行
p=People('lqz')
print(p.name) # 触发描述符类,get的执行,由于get返回None,所以打印出None
23.2 描述符的分类
描述符分类:两类
'''
数据描述符: 除了get以外的,还写了别的
非数据描述符: 只有get,非数据描述符
'''
# 注意:
'''
描述符本身应该定义成新式类，被代理的类也应该是新式类
必须把描述符定义成这个类的类属性，不能为定义到构造函数中
要严格遵循该优先级，优先级由高到底分别是
1.类属性
2.数据描述符
3.实例属性(对象属性)
4.非数据描述符
5.找不到的属性触发getattr()
'''
#举例
class Person:
def __init__(self):
name='mzk' # 在函数中定义了一个局部变量,用完就没了,不属于任何对象或类
self.name='mzk' # 属于对象,放在对象的名称空间中
Person.name='mzk' # 属于类,放在类的名称空间中,对象也能使用的到
p=Person()
print(p.name)
print(Person.name)
# 举例
class Str:
def __get__(self, instance, owner):
print('触发get')
def __set__(self, instance, value):
print('触发set')
def __delete__(self, instance):
print('触发delete')
class People:
age = 19
name = Str()
def __init__(self, name): # name被Str类代理
self.name = name # 触发描述符类,set的执行
pass
p=People('lqz')
p.name='xxx' # 放到对象的名称空间
print(p.name)
23.3描述符机制来实现类型限制功能
# python是强类型动态语言
'''
1 强类型:不同类型直接不允许直接运算
res=1+'sddd' # python中不允许,类型转换后操作,js中允许,java:隐士类型转换,go语言强类型
2 动态语言(静态语言)
-动态语言---->解释型:js,php,python,不使用显示数据类型声明,声明变量不需要指定变量类型 var a='ddd'
-静态语言---->编译型:java,c,go,
'''
# 这种只是一个提示作用,不会限制(公司里通常这么做)
def test(a:int,b:str)->int:
print(a)
print(b)
return 18
test('1',89)
# 了解
class Typed:
def __init__(self, name, expected_type):
self.name = name
self.expected_type = expected_type
def __get__(self, instance, owner):
# print('get--->', instance, owner)
if instance is None:
return self
return instance.__dict__[self.name]
def __set__(self, instance, value):
if not isinstance(value, self.expected_type):
print('类型不匹配')
return
instance.__dict__[self.name] = value
print(instance.__dict__)
def __delete__(self, instance):
print('delete--->', instance)
instance.__dict__.pop(self.name)
class People:
name = Typed('name', str)
age = Typed('age', int)
salary = Typed('salary', float)
def __init__(self, name, age, salary):
self.name = name # 触发Typed的 __set__,
self.age = age
self.salary = salary
# 类People中的属性 name:str age:int salary:float
p = People('mzk', '19', 1000.1)
p.salary = '99'
print(p.__dict__)
24.类的装饰器
# 1.类的装饰器:无参
def decorate(cls):
print('类的装饰器开始运行啦------>')
return cls
@decorate # 类的装饰器 People=decorate(People) 仍旧是 People=People
class People:
pass
People() # 等同于 decorate(People)()--等同于-->People()
# 2.类的装饰器:有参
def typeassert(**kwargs):
def decorate(cls):
print('类的装饰器开始运行啦------>', kwargs)
return cls
return decorate
@typeassert(name='mzk', age=19) # 执行typeassert(name='mzk',age=19)--->decorate内层函数--->People=decorate(People)
class People:
pass
p = People()
# 3.使用类装饰器+描述符,实现对对象类型的控制
class Typed:
def __init__(self, name, expected_type):
self.name = name
self.expected_type = expected_type
def __get__(self, instance, owner):
print('get--->', instance, owner)
if instance is None:
return self
return instance.__dict__[self.name]
def __set__(self, instance, value):
print('set--->', instance, value)
if not isinstance(value, self.expected_type):
print('类型不匹配怕')
return
instance.__dict__[self.name] = value
def __delete__(self, instance):
print('delete--->', instance)
instance.__dict__.pop(self.name)
def typeassert(**kwargs):
def decorate(cls):
print('类的装饰器开始运行啦------>', kwargs)
for name, expected_type in kwargs.items():
'''
# 通过反射,把 name,Typed的对象,放到类中
# People.'name'=Typed('name',str)
# People.'age'=Typed('age',int)
# People.'salary'=Typed('salary',float)
本质就是如下
name = Typed('name', str)
age = Typed('age', int)
salary = Typed('salary', float)
'''
setattr(cls, name, Typed(name, expected_type))
return cls
return decorate
# 这种写法和下面的写法,效果,完全一致
@typeassert(
name=str, age=int, salary=float
) # 有参：1.运行typeassert(...)返回结果是decorate，此时参数都传给kwargs 2.People=decorate(People)
class People:
def __init__(self, name, age, salary):
self.name = name # 描述符类的 __set__
self.age = age
self.salary = salary
# 这种写法跟上面的写法,效果,完全一致
class People:
name = Typed('name', str)
age = Typed('age', int)
salary = Typed('salary', float)
def __init__(self, name, age, salary):
self.name = name
self.age = age
self.salary = salary
print(People.__dict__) # {'name':Typed的对象(属性不一样),'age':Typed的对象,'salary':Typed的对象}
# 实例化得到一个People对象
p=People('mzk',19,100.1)
p.age='15' ## 描述符类的 __set__
p.age=15
print(p.__dict__)
24.1 自制property装饰器
class Lazyproperty:
def __init__(self, func):
self.func = func
def __get__(self, instance, owner):
# self.func是 Room类的area的内存地址,普通函数---需要传对象 area(instance)
print('我被执行')
return self.func(instance) # 此时你应该明白，到底是谁在为你做自动传递self的事情
class Room:
def __init__(self, name, width, length):
self.name = name
self.width = width
self.length = length
@Lazyproperty # area=Lazyproperty(area)--->Lazyproperty类的__init__执行,把area放到了Lazyproperty的对象中然后返回了-->area代指Lazyproperty的对象
def area(self):
return self.width * self.length
r1 = Room('alex', 2, 3)
# r1.area是Lazyproperty的对象,类是描述符类---->r1.area会触发描述符类的 __get__方法
print(r1.area) # 触发描述符类的 __get__ 的执行
print(r1.area) # 触发描述符类的 __get__ 的执行
print(r1.area) # 触发描述符类的 __get__ 的执行
# 想缓存一下
class Lazyproperty:
def __init__(self, func):
self.func = func
def __get__(self, instance, owner):
print('我被执行')
res = self.func(instance)
# instance是r1对象,向r1对象中放了一个 r1.'函数名字'=6
instance.__dict__[self.func.__name__] = res
# 相当于
# instance.__dict__['area']=6
return res
# def __set__(self, instance, value): # 加了它,变成数据描述符,查找顺序就不对了,不能加它
class Room:
def __init__(self, name, width, length):
self.name = name
self.width = width
self.length = length
@Lazyproperty # area=Lazyproperty(area)--->Lazyproperty类的__init__执行,把area放到了Lazyproperty的对象中然后返回了-->area代指Lazyproperty的对象
def area(self):
return self.width * self.length
r1 = Room('alex', 2, 3)
# r1.area是Lazyproperty的对象,类是描述符类---->r1.area会触发描述符类的 __get__方法
print(r1.__dict__)
print(r1.area) # 触发描述符类的 __get__ 的执行
print(r1.__dict__) # {'name': 'alex', 'width': 2, 'length': 3,area:6}
print(r1.area) # 直接先从对象自身找
print(r1.area) # 直接从对象自身找
24.2 @classmethod类方法
@classmethod
class ClassMethod:
def __init__(self, func):
self.func = func
def __get__(self, instance,owner): #类来调用,instance为None,owner为类本身,实例来调用,instance为实例,owner为类本身,
def feedback():
print('在这里可以加功能啊...')
return self.func(owner)
return feedback
class People:
def __init__(self,name):
self.name=name
@ClassMethod # get_obj=ClassMethod(get_obj)--->ClassMethod的对象
def get_obj(cls):
print(cls)
print('这是类的绑定方法')
# People.get_obj # 触发 描述符类的__get__,--->返回feedback的内存地址
People.get_obj() # 其实执行的是feedback()--->self.func--->People类的get_obj方法,self.func(类)--->get_obj(People传入了)
24.3 @staticmethod 静态方法
@staticmethod
class StaticMethod:
def __init__(self, func):
self.func = func
def __get__(self, instance, owner):
def feedback():
print('在这里可以加功能啊...')
return self.func()
return feedback
class People:
def __init__(self, name):
self.name = name
@StaticMethod # get_obj=StaticMethod(get_obj)--->StaticMethod的对象
def get_obj():
print('这是静态方法')
# People.get_obj # --->触发__get__执行----feedback内存地址
People.get_obj() # feedback()
# 带参数情况下
class StaticMethod:
def __init__(self, func):
self.func = func
def __get__(self, instance, owner):
def feedback(*args, **kwargs):
print('在这里可以加功能啊...')
return self.func(*args, **kwargs)
return feedback
class People:
def __init__(self, name):
self.name = name
@StaticMethod # get_obj=StaticMethod(get_obj)--->StaticMethod的对象
def get_obj(a, b):
print(a, b)
print('这是静态方法')
# People.get_obj # --->触发__get__执行----feedback内存地址
People.get_obj(7, 8) # feedback()
网友评论