一、类的成员
类的成员可以分为三大类：字段、方法和属性
注：所有成员中，只有普通字段的内容保存对象中，即：根据此类创建了多少对象，在内存中就有多少个普通字段。而其他的成员，则都是保存在类中，即：无论对象的多少，在内存中只创建一份。
一、字段
字段包括：普通字段和静态字段，他们在定义和使用中有所区别，而最本质的区别是内存中保存的位置不同，
- 普通字段属于对象
- 静态字段属于类
class Province:
# 静态字段
country ＝ '中国'
def __init__(self, name):
# 普通字段
self.name = name
# 直接访问普通字段
obj = Province('河北省')
print obj.name
# 直接访问静态字段
Province.country
由上述代码可以看出【普通字段需要通过对象来访问】【静态字段通过类访问】，在使用上可以看出普通字段和静态字段的归属是不同的。其在内容的存储方式类似如下图：
由上图可是：
- 静态字段在内存中只保存一份
- 普通字段在每个对象中都要保存一份
应用场景： 通过类创建对象时，如果每个对象都具有相同的字段，那么就使用静态字段
二、方法
方法包括：普通方法、静态方法和类方法，三种方法在内存中都归属于类，区别在于调用方式不同。
- 普通方法：由对象调用；至少一个self参数；执行普通方法时，自动将调用该方法的对象赋值给self；
- 类方法：由类调用； 至少一个cls参数；执行类方法时，自动将调用该方法的类复制给cls；
- 静态方法：由类调用；无默认参数；
class Foo:
def __init__(self, name):
self.name = name
def ord_func(self):
""" 定义普通方法，至少有一个self参数 """
# print(self.name)
print '普通方法'
@classmethod
def class_func(cls):
""" 定义类方法，至少有一个cls参数 """
print('类方法')
@staticmethod
def static_func():
""" 定义静态方法 ，无默认参数"""
print('静态方法')
# 调用普通方法
f = Foo()
f.ord_func()
# 调用类方法
Foo.class_func()
# 调用静态方法
Foo.static_func()
相同点：对于所有的方法而言，均属于类（非对象）中，所以，在内存中也只保存一份。
不同点：方法调用者不同、调用方法时自动传入的参数不同。
三、属性
如果你已经了解Python类中的方法，那么属性就非常简单了，因为Python中的属性其实是普通方法的变种。
对于属性，有以下三个知识点：
- 属性的基本使用
- 属性的两种定义方式
1、属性的基本使用
# ############### 定义 ###############
class Foo:
def func(self):
pass
# 定义属性
@property
def prop(self):
pass
# ############### 调用 ###############
foo_obj = Foo()
foo_obj.func()
foo_obj.prop #调用属性
由属性的定义和调用要注意一下几点：
- 定义时，在普通方法的基础上添加 @property 装饰器；
- 定义时，属性仅有一个self参数
- 调用时，无需括号
方法：foo_obj.func()
属性：foo_obj.prop
注意：属性存在意义是：访问属性时可以制造出和访问字段完全相同的假象
属性由方法变种而来，如果Python中没有属性，方法完全可以代替其功能。
实例：对于主机列表页面，每次请求不可能把数据库中的所有内容都显示到页面上，而是通过分页的功能局部显示，所以在向数据库中请求数据时就要显示的指定获取从第m条到第n条的所有数据（即：limit m,n），这个分页的功能包括：
- 根据用户请求的当前页和总数据条数计算出 m 和 n
- 根据m 和 n 去数据库中请求数据
# ############### 定义 ###############
class Pager:
def __init__(self, current_page):
# 用户当前请求的页码（第一页、第二页...）
self.current_page = current_page
# 每页默认显示10条数据
self.per_items = 10
@property
def start(self):
val = (self.current_page - 1) * self.per_items
return val
@property
def end(self):
val = self.current_page * self.per_items
return val
# ############### 调用 ###############
p = Pager(1)
p.start 就是起始值，即：m
p.end 就是结束值，即：n
从上述可见，Python的属性的功能是：属性内部进行一系列的逻辑计算，最终将计算结果返回。
2、属性的两种定义方式
属性的定义有两种方式：
- 装饰器 即：在方法上应用装饰器
- 静态字段 即：在类中定义值为property对象的静态字段
①装饰器方式：在类的普通方法上加上@property装饰器
我们知道Python中的类有经典类和新式类，新式类的属性比经典类的属性丰富。（ 如果类继object，那么该类是新式类 ）
经典类，具有一种@property装饰器（如上一步实例）
# ############### 定义 ###############
class Goods:
@property
def price(self):
return "wupeiqi"
# ############### 调用 ###############
obj = Goods()
result = obj.price # 自动执行 @property 修饰的 price 方法，并获取方法的返回值
新式类，具有三种@property装饰器
# ############### 定义 ###############
class Goods(object):
@property
def price(self):
print('@property')
@price.setter
def price(self, value):
print('@price.setter')
@price.deleter
def price(self):
print('@price.deleter')
# ############### 调用 ###############
obj = Goods()
obj.price # 自动执行 @property 修饰的 price 方法，并获取方法的返回值
obj.price = 123 # 自动执行 @price.setter 修饰的 price 方法，并将 123 赋值给方法的参数
del obj.price # 自动执行 @price.deleter 修饰的 price 方法
注：经典类中的属性只有一种访问方式，其对应被 @property 修饰的方法
新式类中的属性有三种访问方式，并分别对应了三个被@property、@方法名.setter、@方法名.deleter修饰的方法
由于新式类中具有三种访问方式，我们可以根据他们几个属性的访问特点，分别将三个方法定义为对同一个属性：获取、修改、删除
示例：
class Goods(object):
def __init__(self):
# 原价
self.original_price = 100
# 折扣
self.discount = 0.8
@property
def price(self):
# 实际价格 = 原价 * 折扣
new_price = self.original_price * self.discount
return new_price
@price.setter
def price(self, value):
self.original_price = value
@price.deltter
def price(self, value):
del self.original_price
obj = Goods()
obj.price # 获取商品价格
obj.price = 200 # 修改商品原价
del obj.price # 删除商品原价
②静态字段方式，创建值为property对象的静态字段
当使用静态字段的方式创建属性时，经典类和新式类无区别
class Foo：
def get_bar(self):
return 'wupeiqi'
# *必须两个参数
def set_bar(self, value):
return return 'set value' + value
def del_bar(self):
return 'wupeiqi'
BAR ＝ property(get_bar, set_bar, del_bar, 'description...')
obj = Foo()
obj.BAR # 自动调用第一个参数中定义的方法：get_bar
obj.BAR = "alex" # 自动调用第二个参数中定义的方法：set_bar方法，并将“alex”当作参数传入
del Foo.BAR # 自动调用第三个参数中定义的方法：del_bar方法
obj.BAE.__doc__ # 自动获取第四个参数中设置的值：description...
property的构造方法中有个四个参数
- 第一个参数是方法名，调用
对象.属性时自动触发执行方法 - 第二个参数是方法名，调用
对象.属性 ＝ XXX时自动触发执行方法 - 第三个参数是方法名，调用
del 对象.属性时自动触发执行方法 - 第四个参数是字符串，调用
对象.属性.__doc__，此参数是该属性的描述信息
由于静态字段方式创建属性具有三种访问方式，我们可以根据他们几个属性的访问特点，分别将三个方法定义为对同一个属性：获取、修改、删除
class Goods(object):
def __init__(self):
# 原价
self.original_price = 100
# 折扣
self.discount = 0.8
def get_price(self):
# 实际价格 = 原价 * 折扣
new_price = self.original_price * self.discount
return new_price
def set_price(self, value):
self.original_price = value
def del_price(self, value):
del self.original_price
PRICE = property(get_price, set_price, del_price, '价格属性描述...')
obj = Goods()
obj.PRICE # 获取商品价格
obj.PRICE = 200 # 修改商品原价
del obj.PRICE # 删除商品原价
总结：定义属性有两种方式，分别是【装饰器】和【静态字段】，而【装饰器】方式针对经典类和新式类又有所不同。
案例1：静态属性(@property)、类方法(@classmethod)、静态方法(@staticmethod)
class Room:
tag=1
def __init__(self,name,owner,width,length,heigh):
self.name=name
self.owner=owner
self.width=width
self.length=length
self.heigh=heigh
@property
def cal_area(self):
# print('%s 住的 %s 总面积是%s' % (self.owner,self.name, self.width * self.length))
return self.width * self.length
@classmethod
def tell_info(cls,x):
print(cls)
print('--》',cls.tag,x)#print('--》',Room.tag)
# def tell_info(self):
# print('---->',self.tag)
## @staticmethod 静态方法只是名义上归类管理，不能使用类变量和实例变量，类的工具包（不跟类绑定 也不跟实例绑定）
@staticmethod
def wash_body(a,b,c):
print('%s %s %s正在洗澡' %(a,b,c))
def test(x,y): #实例没法调用，r1.test(1,2) r1自动传入self 变成3个位置参数了（就是一个在类里面的普通函数，这样定义毫无意义）
print(x,y)
# Room.wash_body('alex','yuanhao','wupeiqi')
print(Room.__dict__)
## {'__module__': '__main__', 'tag': 1, '__init__': <function Room.__init__ at 0x000001D91F03AA60>, 'cal_area': <property object at 0x000001D91EDB0368>, 'tell_info': <classmethod object at 0x000001D91F046898>, 'wash_body': <staticmethod object at 0x000001D91F046828>, 'test': <function Room.test at 0x000001D9260BC950>, '__dict__': <attribute '__dict__' of 'Room' objects>, '__weakref__': <attribute '__weakref__' of 'Room' objects>, '__doc__': None}
r1=Room('厕所','alex',100,100,100000)
print(r1.__dict__)
## {'name': '厕所', 'owner': 'alex', 'width': 100, 'length': 100, 'heigh': 100000}
# r1.wash_body('alex','yuanhao','wupeiqi')
# Room.test(1,2)
# r1.test(1,2)
案例2：类的数据属性和函数属性的增、删、改、查
# ---------------------------案例1
class Chinese: #定义类
country="china"
def __init__(self,name):
self.name = name
def play_ball(self,ball):
print("%s正在打%s"%(self.name,ball))
p1 = Chinese("张三") #Chinese("张三") 实例化--->产生对象 p1
print(p1.__dict__) ##查看对象p1的属性字典
print(Chinese.__dict__) #查看类Chinese的属性字典
print(p1.country)
p1.country = "日本"
print("实例的p1 添加了数据--->",p1.country)
print("实例的--->",p1.country)
print("类的---->",Chinese.country)
Chinese.play_ball(p1,'篮球') #张三正在打篮球
##另一种方式--->相当于实例调用类方法 p1.play_ball('篮球')
Chinese("张三").play_ball('篮球') #张三正在打篮球
# ---------------------------案例2
class Chinese:
def __init__(self,name):
self.name = name
def play_ball(self,ball):
print("%s正在打%s"%(self.name,ball))
p1 = Chinese("张三")
# print(p1.country) #'Chinese' object has no attribute 'country'
p1.country = "日本"
print("实例的--->",p1.country)
print("类的---->",Chinese.country) #type object 'Chinese' has no attribute 'country'
# ---------------------------案例3 作用域
country = "中国"
class Chinese:
def __init__(self,name):
self.name = name
print("--------->",country)
def play_ball(self,ball):
print("%s正在打%s"%(self.name,ball))
p1 = Chinese("张三") #执行__init__ print() 打印出---------> 中国
# print(p1.country) #'Chinese' object has no attribute 'country'
p1.play_ball("篮球")
# ---------------------------案例3 作用域
country = "中国"
class Chinese:
country = "俄罗斯"
def __init__(self,name):
self.name = name
print("--------->",country)
def play_ball(self,ball):
print("%s正在打%s"%(self.name,ball))
Chinese("张三") #执行__init__ print() 打印出---------> 中国
p1 = Chinese("李四") #---------> 中国
print(p1.country) #俄罗斯
# ---------------------------案例4
class Chinese:
country = "中国"
li = [1,2,3,4]
def __init__(self,name):
self.name = name
def play_ball(self,ball):
print("%s正在打%s"%(self.name,ball))
p1 = Chinese("李四")
print(p1.li) #[1,2,3,4]
p1.li = ['xiong','wang']
print(p1.li) #['xiong','wang']
print(Chinese.li) ##[1,2,3,4]
print(Chinese.__dict__)
print(p1.__dict__) #{"name":"李四","li":['xiong','wang']}
# ---------------------------案例5
class Chinese:
country = "中国"
li = [1,2,3,4]
def __init__(self,name):
self.name = name
def play_ball(self,ball):
print("%s正在打%s"%(self.name,ball))
p1 = Chinese("李四")
print(p1.li) #[1,2,3,4]
print(Chinese.__dict__)
print(p1.__dict__) #{'name': '李四'}
p1.li.append("xiong")
print(p1.li) #[1, 2, 3, 4, 'xiong']
print(p1.__dict__) #{'name': '李四'}
print(Chinese.__dict__)
注意：
1、@property 静态属性装饰器就是负责把一个方法变成属性调用的(即将函数调用 【 对象.函数名() 】 变成 【对象.函数名】 )
class Room:
tag=1
def __init__(self,name,owner,width,length,heigh):
self.name=name
self.owner=owner
self.width=width
self.length=length
self.heigh=heigh
@property
def cal_area(self):
# print('%s 住的 %s 总面积是%s' % (self.owner,self.name, self.width * self.length))
return self.width * self.length
r1=Room('厕所','alex',100,100,100000)
r2=Room('公共厕所','yuanhao',1,1,1)
## 原来必须实例对象.函数名() 运行函数
r1.cal_area()
r2.cal_area()
## @property 之后 可以变成调用 数据属性一样，不用加括号运行了
print(r1.cal_area)
print(r2.cal_area)
小结：@property广泛应用在类的定义中，可以让调用者写出简短的代码，同时保证对参数进行必要的检查，这样，程序运行时就减少了出错的可能性
参考：https://www.liaoxuefeng.com/wiki/897692888725344/923030547069856
2、@classmethod 将类的函数方法不必通过类实例化一个实例对象调用，可以直接通过类调用
注意：@classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等
class Room:
tag=1
def __init__(self,name,owner,width,length,heigh):
self.name=name
self.owner=owner
self.width=width
self.length=length
self.heigh=heigh
@property
def cal_area(self):
# print('%s 住的 %s 总面积是%s' % (self.owner,self.name, self.width * self.length))
return self.width * self.length
def test(self):
print('from test',self.name)
print(self) #<__main__.Room object at 0x0000019A12B35898>
@classmethod
def tell_info(cls,x):
print(cls)
print('--》',cls.tag,x) #print('--》',Room.tag) 这里的cls 就相当于 self
# def tell_info(self):
# print('---->',self.tag)
# print(Room.tag)
## Room.test(1) #报错 'int' object has no attribute 'name'
r1=Room('厕所','alex',100,100,100000)
r1.tell_info(12)
r1.test()
Room.tell_info(10) # 不需要实例化对象，直接通过类 调用方法
class A(object):
bar = 1
def func1(self):
print ('foo')
@classmethod
def func2(cls):
print ('func2')
print (cls.bar)
cls().func1() # 调用 foo 方法
A.func2() # 静态方法func2 通过类调用
"""案例3：类方法classmethod"""
class A(object):
# 属性默认为类属性（可以给直接被类本身调用）
num = "类属性"
# 实例化方法（必须实例化类之后才能被调用）
def func1(self): # self : 表示实例化类后的地址id
print("开始运行func1函数。。。")
print(self)
print(self.num) # 传入self 可以通过self调用
# 类方法（不需要实例化类就可以被类本身调用）
@classmethod
def func2(cls): # cls : 表示没用被实例化的类本身
print("func2")
print(cls)
print(cls.num)
cls().func1()
# 不传递传递默认self参数的方法（该方法也是可以直接被类调用的，但是这样做不标准）
def func3():
print("开始运行func1函数》》》")
print(A.num) # 属性是可以直接用类本身调用的
# print(self.num) # 报错，没有传入self 是不可以通过self调用的
# A.func1() #这样调用是会报错：因为func1()调用时需要默认传递实例化类后的地址id参数，如果不实例化类是无法调用的
A.func2()
A.func3()
3、@staticmethod 静态方法
#案例1
class C(object):
@staticmethod
def f():
print('runoob');
C.f(); # 静态方法无需实例化
cobj = C()
cobj.f() # 也可以实例化后调用
#案例2
class Room:
tag=1
def __init__(self,name,owner,width,length,heigh):
self.name=name
self.owner=owner
self.width=width
self.length=length
self.heigh=heigh
@property
def cal_area(self):
# print('%s 住的 %s 总面积是%s' % (self.owner,self.name, self.width * self.length))
return self.width * self.length
@classmethod
def tell_info(cls,x):
print(cls)
print('--》',cls.tag,x)#print('--》',Room.tag)
# def tell_info(self):
# print('---->',self.tag)
## @staticmethod 静态方法只是名义上归类管理，不能使用类变量和实例变量，类的工具包（不跟类绑定 也不跟实例绑定）
@staticmethod
def wash_body(a,b,c):
print('%s %s %s正在洗澡' %(a,b,c))
def test(x,y): #（就是一个在类里面的普通函数，这样定义毫无意义）不推荐这样使用
print(x,y)
Room.wash_body('alex','yuanhao','wupeiqi') ## 静态方法无需实例化
Room.test(11,22) #直接通过类可以调用
r1=Room('厕所','alex',100,100,100000)
r1.wash_body('alex','yuanhao','wupeiqi') #也可以通过实例化对象调用
r1.test(33,44) ##报错，实例化对象没法调用 因为r1.test(1,2) r1自动传入self 变成3个位置参数了#
二、类成员的修饰符（双下划线）
Python面向对象设计中，字段、属性和方法的访问权限有两种，即公开的和私有。如果希望属性是私有的，在给属性/方法命名时可以用两个下划线作为开头
- 公有成员，在任何地方都能访问
- 类的内部访问（self.name）
- 实例对象（p1.name）
- 子类访问
- 私有成员，只有在类的内部才能访问
私有成员和公有成员的定义不同：私有成员命名时，前两个字符是下划线。（特殊成员除外，例如：__init__、__call__、__dict__等）
class C:
def __init__(self):
self.name = '公有字段'
self.__foo = "私有字段"
私有成员和公有成员的访问限制不同：
静态字段
公有静态字段：类可以访问；类内部可以访问；派生类中可以访问
class C:
name = "公有静态字段"
def func(self):
print(C.name)
class D(C):
def show(self):
print(C.name)
C.name # 类访问
obj = C()
obj.func() # 类内部可以访问
obj_son = D()
obj_son.show() # 派生类中可以访问
私有静态字段：仅类内部可以访问；
class C:
__name = "公有静态字段"
def func(self):
print(C.__name)
class D(C):
def show(self):
print(C.__name)
C.__name # 类访问 ==> 错误
obj = C()
obj.func() # 类内部可以访问 ==> 正确
obj_son = D()
obj_son.show() # 派生类中可以访问 ==> 错误
普通字段
公有普通字段：对象可以访问；类内部可以访问；派生类中可以访问
class C:
def __init__(self):
self.foo = "公有字段"
def func(self):
print(self.foo) # 类内部访问
class D(C):
def show(self):
print(self.foo) ＃ 派生类中访问
obj = C()
obj.foo # 通过对象访问
obj.func() # 类内部访问
obj_son = D();
obj_son.show() # 派生类中访问
私有普通字段：仅类内部可以访问；
class C:
def __init__(self):
self.__foo = "私有字段"
def func(self):
print(self.foo) # 类内部访问
class D(C):
def show(self):
print(self.foo) ＃ 派生类中访问
obj = C()
obj.__foo # 通过对象访问 ==> 错误
obj.func() # 类内部访问 ==> 正确
obj_son = D();
obj_son.show() # 派生类中访问 ==> 错误
方法、属性的访问于上述方式相似，即：私有成员只能在类内部使用
ps：非要访问私有属性的话，可以通过 对象._类__属性名
ps：Python并没有从语法上严格保证私有属性或方法的私密性，它只是给私有的属性和方法换了一个名字来“妨碍”对它们的访问。
如果想要强制访问私有字段，可以通过 【对象._类名__私有字段明 】访问（如：obj._C__foo），不建议强制访问私有成员。
下面的代码就可以验证这一点。之所以这样设定，可以用这样一句名言加以解释，就是“We are all consenting adults here”。
因为绝大多数程序员都认为开放比封闭要好，而且程序员要自己为自己的行为负责。
class Test:
def __init__(self, foo):
self.__foo = foo
def __bar(self):
print(self.__foo)
print('__bar')
def main():
test = Test('hello')
test._Test__bar()
print(test._Test__foo)
if __name__ == "__main__":
main()
在实际开发中，我们并不建议将属性设置为私有的，因为这会导致子类无法访问（后面会讲到）。所以大多数Python程序员会遵循一种命名惯例就是让属性名以单下划线开头来表示属性是受保护的，
本类之外的代码在访问这样的属性时应该要保持慎重。
这种做法并不是语法上的规则，单下划线开头的属性和方法外界仍然是可以访问的，所以更多的时候它是一种暗示或隐喻，关于这一点可以看看我的《Python - 那些年我们踩过的那些坑》文章中的讲解。
class Student(object):
def __init__(self,name,age,secret):
self.name = name
self.age = age
self.__secret = secret
@property
def name(self):
return self._name #self._name就是#self.name
@name.setter
def name(self,value):
if(isinstance(value,str)):
self._name = value
else:
self._name = "xxoo"
def getSecret(self):
print("双下划线只能在类的内部访问，__secret=",self.__secret)
stu = Student(12,18,'gaoji')
print(stu.name)
print(stu.getSecret())
#对象是访问不到的
print(stu.__secret) #AttributeError: 'Student' object has no attribute '__secret'
# __secret私有字段子类继承也是访问不到的
补充：isinstance(obj,cls)和issubclass(subclass,superclass)
①isinstance(obj,classinfo) 检查obj 是类 classinfo的实例对象(或理解为 来判断一个对象是否是一个已知的类型，类似 type())
实例1：
>>>a = 2 >>> isinstance (a,int) True >>> isinstance (a,str) False >>> isinstance (a,(str,int,list)) # 是元组中的一个返回 True True
实例2：
class A: pass class B(A): pass isinstance(A(), A) # returns True type(A()) == A # returns True isinstance(B(), A) # returns True type(B()) == A # returns False
基本类型来说 cls 可以是 int，float，bool，complex，str(字符串)，list，dict(字典)，set，tuple
注意的是，cls 的字符串是 str 而不是 string，字典也是简写 dict
②issubclass(sub, super) 检查sub 是 super 类的子类（派生类）
class Foo(object): pass class Bar(Foo): pass issubclass(Bar, Foo)
三、反射(hasattr getattr setattr delattr)（* * * * *）
1. 什么是反射
反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力（自省）。
2. python面向对象中的反射：
可以用字符串的方式去访问对象的属性，调用对象的方法（但是不能去访问方法），python中一切皆对象，都可以使用反射。
反射有四种方法:
hasattr：hasattr（object,name）
判断一个对象是否有name属性或者name方法。有就返回True，没有就返回False
getattr：getattr(object, name[, default]) -> value
获取对象的属性或者方法，如果存在则打印出来。hasattr和getattr配套使用
需要注意的是，如果返回的是对象的方法，返回出来的是对象的内存地址，如果需要运行这个方法，可以在后面添加一对（）
setattr：setattr(x, 'y', v) is equivalent to ``x.y = v''
给对象的属性赋值，若属性不存在，先创建后赋值
delattr：delattr(x, 'y') is equivalent to ``del x.y''
删除该对象指定的一个属性
class LearnPython(object): def __init__(self,name,value): self.name = name self.value = value def start(self): print("考试科目是【%s】，分数是【%s】"%(self.name,self.value)) t1 = LearnPython("python",12) print(t1.__dict__) t1.start() print(hasattr(t1,"name")) print(hasattr(t1,"xxoo")) print(getattr(t1,"name")) print(getattr(t1,"xxoo","没有该属性")) print(setattr(t1,"xxoo",'60')) delattr(t1,"value") print(t1.__dict__) #打印结果 {'name': 'python', 'value': 12} 考试科目是【python】，分数是【12】 True False python 没有该属性 None {'name': 'python', 'xxoo': '60'}
class Foo(object): staticField = "old boy" def __init__(self): self.name = 'wupeiqi' def func(self): return 'func' @staticmethod def bar(): return 'bar' def foo(self,val): print("设置类的self.age=",val) self.age = val print(getattr(Foo, 'staticField')) print(hasattr(Foo, 'func')) print(getattr(Foo, 'bar')) print(setattr(Foo, 'foo',18)) print(Foo.__dict__) """ old boy True <function Foo.bar at 0x0000013CC0C087B8> None {'__module__': '__main__', 'staticField': 'old boy', '__init__': <function Foo.__init__ at 0x000001F9199316A8>, 'func': <function Foo.func at 0x000001F91AAD87B8>, 'bar': <staticmethod object at 0x000001F91AAB39E8>, 'foo': 18, '__dict__': <attribute '__dict__' of 'Foo' objects>, '__weakref__': <attribute '__weakref__' of 'Foo' objects>, '__doc__': None} """
import sys def s1(): print('s1') def s2(): print('s2') this_module = sys.modules[__name__] print(hasattr(this_module, 's1')) print(getattr(this_module, 's2')) getattr(this_module, 's2')() """ True <function s2 at 0x000001ADC483A158> s2 """
应用1：导入其他模块，利用反射查找该模块是否存在某个方法
def test(): print('from the test')
""" 程序目录： module_test.py index.py 当前文件： index.py """ import module_test as obj #obj.test() print(hasattr(obj,'test')) getattr(obj,'test')()
为什么用反射之反射的好处？
好处一：实现可插拔机制
有俩程序员，一个Alex，一个是egon，Alex在写程序的时候需要用到egon所写的类，但是egon去跟女朋友度蜜月去了，还没有完成他写的类，
Alex想到了反射，使用了反射机制Alex可以继续完成自己的代码，等egon度蜜月回来后再继续完成类的定义并且去实现Alex想要的功能。
总之反射的好处就是，可以事先定义好接口，接口只有在被完成后才会真正执行，这实现了即插即用，这其实是一种‘后期绑定’，什么意思？
即你可以事先把主要的逻辑写好（只定义接口），然后后期再去实现接口的功能。
class FtpClient: 'ftp客户端,但是还么有实现具体的功能' def __init__(self,addr): print('正在连接服务器[%s]' %addr) self.addr=addr
from module import FtpClient f1=FtpClient('192.168.1.1') if hasattr(f1,'get'): func_get=getattr(f1,'get') func_get() else: print('---->不存在此方法') print('处理其他的逻辑')
好处二：动态导入模块（基于反射当前模块成员）
举例：
import importlib
mt = importlib.import_module('fanse_module.module_test')
mt.test() #from module_test.py the test()
反射的用法总结
四、类的特殊成员
上文介绍了Python的类成员以及成员修饰符，从而了解到类中有字段、方法和属性三大类成员，并且成员名前如果有两个下划线，则表示该成员是私有成员，私有成员只能由类内部调用。无论人或事物往往都有
不按套路出牌的情况，Python的类成员也是如此，存在着一些具有特殊含义的成员，详情如下：
1. __doc__ 2. __module__ 和 __class__ 3. __init__ 4. __del__ 5. __call__
6. __dict__ 7. __str__ 8、__getitem__、__setitem__、__delitem__ 9、__getslice__、__setslice__、__delslice__
10. __iter__ 11. __new__ 和 __metaclass__
__doc__
表示类的描述信息
class Foo:
""" 描述类信息，这是用于看片的神奇 """
def func(self):
pass
print(Foo.__doc__)
#输出：类的描述信息
__module__ 和 __class__
__module__ 表示当前操作的对象在那个模块
__class__ 表示当前操作的对象的类是什么
#./lib/aa.py
class C:
def __init__(self):
self.name = 'xiong'
#__moudule__和__class__.py 文件
from lib.aa import C
obj = C()
print(obj.name)
print(obj.__module__) # 输出 lib.aa，即：输出模块
print(obj.__class__) # 输出 lib.aa.C，即：输出类
__init__
构造方法，通过类创建对象时，自动触发执行
class Foo:
def __init__(self, name,age=18):
self.name = name
self.age = age
obj = Foo('xiong') # 自动执行类中的 __init__ 方法
__del__
析构方法，当对象在内存中被释放时，自动触发执行。
注：如果产生的对象仅仅只是python程序级别的（用户级），那么无需定义__del__，如果产生的对象的同时还会向操作系统发起系统调用，即一个对象有用户级与内核级两种资源，
比如（打开一个文件，创建一个数据库链接），则必须在清除对象的同时回收系统资源，这就用到了__del__
class Foo: def __del__(self): print('执行我啦') f1=Foo() del f1 #删除实例的时候__del__() 才会执行 print('------->') #输出结果 执行我啦 ------->
class Foo: def __del__(self): print('执行我啦') f1=Foo() # del f1 print('------->') #输出结果 -------> 执行我啦 #为何啊？？？ 当程序执行完之后内存释放，自动执行__del__()
典型的应用场景：
创建数据库类，用该类实例化出数据库链接对象，对象本身是存放于用户空间内存中，而链接则是由操作系统管理的，存放于内核空间内存中
当程序结束时，python只会回收自己的内存空间，即用户态内存，而操作系统的资源则没有被回收，这就需要我们定制__del__，在对象被删除前向操作系统发起关闭数据库链接的系统调用，回收资源
这与文件处理结束之后需要 f.close()是一个道理：
f=open('a.txt') #做了两件事，在用户空间拿到一个f变量，在操作系统内核空间打开一个文件 del f #只回收用户空间的f，操作系统的文件还处于打开状态 #所以我们应该在del f之前保证f.close()执行,即便是没有del，程序执行完毕也会自动del清理资源，于是文件操作的正确用法应该是 f=open('a.txt') 读写... f.close() 很多情况下大家都容易忽略f.close,这就用到了with上下文管理
__call__
对象后面加括号，触发类里面的__call__() 方法执行。
注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()
class Foo:
def __init__(self):
pass
def __call__(self, *args, **kwargs):
print('__call__')
obj = Foo() # 执行 __init__
obj() # 执行 __call__
__dict__
类或对象中的所有成员，如Person.__dict p1.__dict__
上文中我们知道：类的普通字段属于对象；类中的静态字段和方法等属于类，即：
class Province:
country = 'China'
def __init__(self, name, count):
self.name = name
self.count = count
def func(self, *args, **kwargs):
print 'func'
# 获取类的成员，即：静态字段、方法、
print(Province.__dict__)
# 输出：{'country': 'China', '__module__': '__main__', 'func': <function func at 0x10be30f50>, '__init__': <function __init__ at 0x10be30ed8>, '__doc__': None}
obj1 = Province('HeBei',10000)
print(obj1.__dict__)
# 获取 对象obj1 的成员
# 输出：{'count': 10000, 'name': 'HeBei'}
obj2 = Province('HeNan', 3888)
print(obj2.__dict__)
# 获取 对象obj1 的成员
# 输出：{'count': 3888, 'name': 'HeNan'}
__str__ ,__repr__ ,__format__
如果一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值
class Foo:
def __str__(self):
return 'xiong'
obj = Foo()
print(obj)
# 输出：xiong
__repr__ 和 __str__功能相似（二者同时存在时 __str__优先）
# l=list('hello')
#
# print(l) #['h','e','l','l','o'] #原理：返回对象 找list默认的__str__() 方法返回
# file=open('test.txt','w')
# print(file) #返回一个open类产生的对象
# class Foo:
# def __init__(self,name,age):
# self.name=name
# self.age=age
#
# def __str__(self):
# return '名字是%s 年龄是%s' %(self.name,self.age)
#
# f1=Foo('egon',18)
# print(str(f1)) #str(f1) ---> f1.__str__()
# print(f1) #str(f1) ---> f1.__str__()
#
# y=f1.__str__()
# print(y)
class Goo:
def __init__(self,name,age):
self.name=name
self.age=age
def __str__(self):
return '这是str'
def __repr__(self):
return '名字是%s 年龄是%s' %(self.name,self.age)
f1=Goo('egon',19)
"""只有 __repr__() 存在"""
#repr(f1) <====> f1.__repr__()
print(f1) # repr(f1) ---> f1.__repr__()
"""__str__() 和 __repr__() 同时存在"""
print(f1) #str（f1）---》f1.__str__()
__format__的高级玩法
"""low逼的玩法"""
x='{0}{0}{0}'.format('dog')
print(x)
class Date:
def __init__(self,year,mon,day):
self.year=year
self.mon=mon
self.day=day
d1=Date(2016,12,26)
x='{0.year}{0.mon}{0.day}'.format(d1)
y='{0.year}:{0.mon}:{0.day}'.format(d1)
z='{0.mon}-{0.day}-{0.year}'.format(d1)
print(x)
print(y)
print(z)
"""
dogdogdog
20161226
2016:12:26
12-26-2016
"""
"""高级的format玩法"""
date_dic = {
'ymd':'{0.year}{0.month}{0.day}',
'y-m-d':'{0.year}-{0.month}-0.day}',
'y:m:d':'{0.year}年:{0.month}月:{0.day}日',
'd-m-y':'{0.day}-{0.month}-{0.year}',
'y/m/d':'{0.year}/{0.month}/{0.day}',
}
class Date(object):
def __init__(self,year,month,day):
self.year = year
self.month = month
self.day = day
def __format__(self, format_spec):
if not format_spec or format_spec not in date_dic:
format_spec = 'ymd'
fmt = date_dic[format_spec]
return fmt.format(self)
d1 = Date(2019,5,19)
print(format(d1))
print(format(d1,'y:m:d')) ## print(d1.__format__("y:m:d"))
print(format(d1,'y/m/d'))
print(format(d1,'24564fdgsda163'))
"""
2019519
2019年:5月:19日
2019/5/19
2019519
"""
__slots__
1、__slots__ :是一个类变量,变量值可以是列表,元祖,或者可迭代对象,也可以是一个字符串(意味着所有实例只有一个数据属性)
2、引子:使用点来访问属性本质就是在访问类或者对象的__dict__属性字典(类的字典是共享的,而每个实例的是独立的)
3.为何使用__slots__:属性字典会占用大量内存,如果你有一个属性很少的类,但是有很多实例,
为了节省内存可以使用__slots__取代实例的__dict__当你定义__slots__后,__slots__就会为实例使用一种更加紧凑的内部表示。
实例通过一个很小的固定大小的数组来构建,而不是为每个实例定义一个属性字典,这跟元组或列表很类似。
在__slots__中列出的属性名在内部被映射到这个数组的指定小标上。
使用__slots__一个不好的地方就是我们不能再给实例添加新的属性了,只能使用在__slots__中定义的那些属性名。
4.注意事项:__slots__的很多特性都依赖于普通的基于字典的实现。另外,定义了__slots__后的类不再支持一些普通类特性了,比如多继承。
大多数情况下,你应该只在那些经常被用到的数据结构的类上定义__slots__比如在程序中需要创建某个类的几百万个实例对象。
关于__slots__的一个常见误区是它可以作为一个封装工具来防止用户给实例增加新的属性。
尽管使用__slots__可以达到这样的目的,但是这个并不是它的初衷。更多的是用来作为一个内存优化工具。
class Foo(object):
__slots__ = ['name','age']
# __slots__ = "gender"
f1 = Foo()
print(f1.__slots__) #['name', 'age']
f1.name = "xiong"
print(f1.name) #xiong
# print(f1.__dict__) #报错，'Foo' object has no attribute '__dict__'
# f1.country = 'china' #报错，内部实现原理--->__setattr__()--->f1.__dict__['country']='china'
__setattr__ __delattr__ __getattr__
都是对象 点 操作触发
__setattr__ 给对象设置属性时执行该函数，使用 self.__dict__[key] = value 给对象添加属性key=value
__delattr__ 删除对象属性时执行
__getattr__ 对象获取不存在的属性时执行
class Foo:
x=1
def __init__(self,y):
self.y=y
def __getattr__(self, item):
print('----> from getattr:你找的属性不存在')
def __setattr__(self, key, value):
#该函数中只能有一行代码
# print('----> from setattr')
# self.key=value #这就无限递归了,你好好想想
# self.__dict__[key]=value #应该使用它 向对象属性字典中添加属性key=value
self.__dict__[key] = value
def __delattr__(self, item):
print('----> from delattr')
# del self.item #无限递归了
self.__dict__.pop(item)
#__setattr__添加/修改属性会触发它的执行
f1=Foo(10)
print(f1.__dict__) # 因为你重写了__setattr__,凡是赋值操作都会触发它的运行,你啥都没写,就是根本没赋值,除非你直接操作属性字典,否则永远无法赋值
f1.z=3
print(f1.__dict__)
#__delattr__删除属性的时候会触发
f1.__dict__['a']=3#我们可以直接修改属性字典,来完成添加/修改属性的操作
del f1.a
print(f1.__dict__)
#
# #__getattr__只有在使用点调用属性且属性不存在的时候才会触发
print(f1.y) #10
f1.xxxxxx
__getitem__、__setitem__、__delitem__
用于对象索引操作，如字典 f1["key"]。以上分别表示获取、设置、删除数据
注意：与__getatrr__ __setattr__ __delattr__的区别
f1['age'] = 18 #__getitem__(self,item) 执行
f1.age1 = 19 #__getattr__(self,key) 执行
class Foo:
def __init__(self, name):
self.name = name
def __getitem__(self, item):
print("f1[item]时我执行", self.__dict__[item])
def __getattr__(self, key):
print("f1.key时我执行,且对象中不存在key")
def __setitem__(self, key, value):
print("执行__setitem__",key,value)
self.__dict__[key] = value
def __setattr__(self, key, value):
print("执行__setattr__",key,value)
self.__dict__[key] = value
def __delitem__(self, key):
print('del obj[key]时,我执行',key)
self.__dict__.pop(key)
def __delattr__(self, item):
print('del obj.key时,我执行',item)
self.__dict__.pop(item)
f1 = Foo('sb')
f1['age'] = 18
f1.age1 = 19
del f1.age1
del f1['age']
f1['name'] = 'alex'
f1.name = "xiong"
print(f1.__dict__)
f1['name']
f1.xxoo
#执行结果如下：
执行__setattr__ name sb
执行__setitem__ age 18
执行__setattr__ age1 19
del obj.key时,我执行 age1
del obj[key]时,我执行 age
执行__setitem__ name alex
执行__setattr__ name xiong
{'name': 'xiong'}
f1[item]时我执行 xiong
f1.key时我执行,且对象中不存在key
对标准数据类型进行自定义扩展
包装：python为大家提供了大量标准数据类型（字符串、列表、字典、元组、集合等），以及丰富的内置方法。
其实在很多场景下我们都需要基于标准数据类型来定制我们自己的数据类型，即新增或改写方法，
这就用到了我们刚学的继承/派生知识（其他的标准类型均可以通过下面的方式进行二次加工）
示例：继承Python标准的list类 扩展Mylist类 增加了类型识别（列表项只能是字符串）和获取列表正中间项的方法
class Mylist(list):
# 基类 list 中本来就有append方法，我们也可以自己重定义append 方法
def append(self,p_obj):
if(type(p_obj) is str):
# self.append(p_obj) #这 TMD 又在调自己定义的append方法 进入死循环了
# list.append(self,p_obj) # 调用Mylist 它爸的原始append方法，当然要把它自己self 传进去 （这种方法不推荐）
super().append(p_obj) #推荐用* * *
else:
print("sb只能append字符串！")
def show_middle(self):
mid_index = int(len(self)/2)
return self[mid_index]
# lis1 = list("nihao")
# print(lis1,type(lis1)) #['n', 'i', 'h', 'a', 'o'] <class 'list'>
lis2 = Mylist("nihao")
# print(lis2,type(lis2)) #['n', 'i', 'h', 'a', 'o'] <class '__main__.Mylist'>
# print(lis2.show_middle()) #h
# 自己没定义append之前
# lis2.append(123)
# print(lis2) #['n', 'i', 'h', 'a', 'o', 123]
"""自定义append 只能添加字符串"""
# 自己定义append之后
print(lis2)
lis2.append("xiong")
lis2.append(123)
print(lis2)
授权：授权是包装的一个特性（类似于一种组合的方式），包装一个类型通常是对已存在的类型的一些定制，这种做法可以新建、修改或删除原有产品的功能，其它的则保持原样。
授权的过程,即是所有更新的功能都是由新类的某部分来处理,但已存在的功能就授权给对象的默认属性。
实现授权的关键点就是覆盖 __getattr__ 方法
案例1：
class FileHandle(object):
def __init__(self,filename,mode="r",encoding = "utf-8"):
self.file = open(filename,mode,encoding=encoding)
self.mode = mode
self.encoding = encoding
def __getattr__(self, item):
# print(item,type(item)) #item 是字符串
# self.file.read
return getattr(self.file, item) #调用对象的item 属性/方法（授权python内置的文件操作方法）
f1 = FileHandle('a.txt','r+')
print(f1.file)
print(f1.__dict__)
print('==>',f1.readlines()) #触发__getattr__ #==> <built-in method read of _io.TextIOWrapper object at 0x000002617EF89CF0>
# fb = open('b.txt','r+') #通过Python内置的open() 方法打开文件，查看到 fb.read 指向的内存地址相同
# print("通过Python内置open()打开b文件指向的内存地址==>",fb.read) #<built-in method read of _io.TextIOWrapper object at 0x000002617EF89DC8>
# fb.close()
# #
print(f1.write)
f1.write('1111111111111111
')
f1.seek(0)
print('--->',f1.read())
案例2：要求给写入的每行信息前都要加上时间
""" 需求：要求写入的信息前都要加上时间"""
import time
class FileHandle:
def __init__(self,filename,mode='r',encoding='utf-8'):
self.file=open(filename,mode,encoding=encoding)
self.mode=mode
self.encoding=encoding
def write(self,line):
print('------------>',line)
t=time.strftime('%Y-%m-%d %X')
self.file.write('%s %s' %(t,line))
def __getattr__(self, item):
print("__getattr__====>")
# self.file.read
return getattr(self.file,item)
f1=FileHandle('c.txt','w+')
f1.write('1111111111111111
')
f1.write('cpu负载过高
')
f1.write('内存剩余不足
')
f1.write('硬盘剩余不足
')
f1.seek(0)
print('--->',f1.read())
"""
------------> 1111111111111111
------------> cpu负载过高
------------> 内存剩余不足
------------> 硬盘剩余不足
__getattr__====>
__getattr__====>
---> 2020-03-19 15:07:55 1111111111111111
2020-03-19 15:07:55 cpu负载过高
2020-03-19 15:07:55 内存剩余不足
2020-03-19 15:07:55 硬盘剩余不足
"""
__getattribute__ （* *）
obj.x 对象有或没有属性x 时都会调用 __getattribute__ 方法
class Foo: def __init__(self,x): self.x=x def __getattr__(self, item): print('执行的是我') # return self.__dict__[item] f1=Foo(10) print(f1.x) f1.xxxxxx #不存在的属性访问，触发__getattr__ 回顾
class Foo: def __init__(self,x): self.x=x def __getattribute__(self, item): print('不管是否存在,我都会执行') f1=Foo(10) f1.x f1.xxxxxx
#_*_coding:utf-8_*_ __author__ = 'Linhaifeng' class Foo: def __init__(self,x): self.x=x def __getattr__(self, item): print('执行的是我') # return self.__dict__[item] def __getattribute__(self, item): print('不管是否存在,我都会执行') raise AttributeError('哈哈') f1=Foo(10) f1.x f1.xxxxxx #当__getattribute__与__getattr__同时存在,只会执行__getattrbute__,除非__getattribute__在执行过程中抛出异常AttributeError
__next__和__iter__实现迭代器协议
__iter__ 用于迭代器，之所以列表、字典、元组可以进行for循环，是因为类型内部定义了 __iter__ ,for循环就是不断调用__netx__()方法，直到出现StopInteraction
"""简单示例""" class Foo: def __init__(self,x): self.x=x def __iter__(self): return self def __next__(self): n=self.x self.x+=1 return self.x f=Foo(3) print(next(f)) print(next(f)) print(next(f)) print(next(f)) print(next(f)) print("=====================================>") for i in f: print(i)
"""添加条件抛出异常 程序停止""" class Foo: def __init__(self,start,stop): self.num=start self.stop=stop def __iter__(self): return self def __next__(self): if self.num >= self.stop: raise StopIteration n=self.num self.num+=1 return n f=Foo(1,6) print(f.__next__()) print(f.__next__()) print(next(f)) print(next(f)) print(next(f)) print(next(f)) from collections import Iterable,Iterator print(isinstance(f,Iterator)) for i in Foo(1,5): print(i) #1 2 3 4
"""案例：模拟 开始值+步长 大于 结束值""" class Range: def __init__(self,n,stop,step): self.n=n self.stop=stop self.step=step def __next__(self): if self.n >= self.stop: raise StopIteration x=self.n self.n+=self.step return x def __iter__(self): return self for i in Range(1,7,3): # print(i)
"""案例：斐波那契数列""" class Fib: def __init__(self): self._a=0 self._b=1 def __iter__(self): return self def __next__(self): self._a ,self._b = self._b , self._a + self._b return self._a f1=Fib() # print(f1.__next__()) # print(next(f1)) # print(next(f1)) # print(next(f1)) # print(next(f1)) # print(next(f1)) for i in f1: if i > 100: break print('%s ' %i,end=' ')
__enter__和__exit__ ：上下文管理协议
我们知道在操作文件对象的时候可以这么写：
with open('a.txt') as f:
'代码块'
上述叫做上下文管理协议，即with语句，为了让一个对象兼容with语句，必须在这个对象的类中声明__enter__和__exit__方法
class Open: def __init__(self,name): self.name=name def __enter__(self): print('出现with语句,对象的__enter__被触发,有返回值则赋值给as声明的变量') # return self def __exit__(self, exc_type, exc_val, exc_tb): print('with中代码块执行完毕时执行我啊') with Open('a.txt') as f: print('=====>执行代码块') # print(f,f.name)
__exit__()中的三个参数分别代表 异常类型，异常值和追溯信息，with语句中代码块出现异常，则with后的代码都无法执行
异常类型：
class Open: def __init__(self,name): self.name=name def __enter__(self): print('出现with语句,对象的__enter__被触发,有返回值则赋值给as声明的变量') def __exit__(self, exc_type, exc_val, exc_tb): print('with中代码块执行完毕时执行我啊') print(exc_type) print(exc_val) print(exc_tb) with Open('a.txt') as f: print('=====>执行代码块') raise AttributeError('***着火啦,救火啊***') print('0'*100) #------------------------------->不会执行
如果__exit()返回值为True,那么异常会被清空，就好像啥都没发生一样，with 后面的语句正常执行
上下文管理协议的用途：
1.使用with语句的目的就是把代码块放入with中执行，with结束后，自动完成清理工作，无须手动干预
2.在需要管理一些资源比如文件，网络连接和锁的编程环境中，可以在__exit__中定制自动释放资源的机制，你无须再去关心这个问题，这将大有用处
##上下文管理协议：__enter__ , __exit__ 案例： class Foo: def __init__(self,name): self.name = name def __enter__(self): print('enter...') return self def __exit__(self, exc_type, exc_val, exc_tb): print("exit》》》") print(exc_type) #异常名称：<class 'NameError'> print(exc_val) #异常详细信息：name 'ghiqtehjdk' is not defined print(exc_tb) #异常追踪信息：<traceback object at 0x00000242F81DAB48> return True #程序不会抛出异常 终止,直接跳出with 继续执行后面程序 with Foo('a.txt') as f: print(f) print(ghiqtehjdk) #报错 直接触发 exit() print(f.name) print("with结束了！！！") ####解析释义 with obj as f: '代码块' 1、with obj ---> 触发obj.__enter__(),拿到 def __enter__() 的返回值 2、as f --->f = 返回值 3、with obj as f <===>f = obj.__enter__() 4、执行'代码块' 一、没有异常的情况下，整个'代码块'执行完毕之后触发__exit__(),它的三个参数返回None 二、有异常的情况下，'代码块'执行到异常处直接触发__exit__() a、如果__exit__ 返回值是 True，代表吞掉异常（执行完__exit__之后跳出with，继续执行后续程序） b、如果__exit__ 返回值不是 True，代表吐出异常（执行完__exit__之后直接终止程序） c、__exit__ 运行完毕就代表着整个with语句的执行完毕
五、描述符(__get__ ， __set__ ， __delete__) （* * * * * ）
描述符是干什么的？为什么要用描述符？
https://www.cnblogs.com/XJT2018/p/12525545.html
1、描述符是什么？
描述符本质就是一个新式类,在这个新式类中,至少实现了__get__() ， __set__() ， __delete__()中的一个,这也被称为描述符协议。
__get__() ：调用一个属性时，触发
__set__() ：为一个属性赋值时，触发
__delete__() ：采用del删除属性时，触发
class Foo: #在python3中Foo是新式类,它实现了三种方法,这个类就被称作一个描述符 def __get__(self, instance, owner): pass def __set__(self, instance, value): pass def __delete__(self, instance): pass
2、描述符是干什么的？
描述符的作用是用来代理(描述)另外一个类的属性的(必须把描述符定义成这个类的类属性，不能定义到构造函数中)
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='egon' f1.name del f1.name #疑问:何时,何地,会触发这三个方法的执行
#描述符Str class Str: def __get__(self, instance, owner): print('Str调用') def __set__(self, instance, value): print('Str设置...') def __delete__(self, instance): print('Str删除...') #描述符Int class Int: def __get__(self, instance, owner): print('Int调用') def __set__(self, instance, value): print('Int设置...') def __delete__(self, instance): print('Int删除...') class People: name=Str() age=Int() def __init__(self,name,age): #name被Str类代理,age被Int类代理, self.name=name self.age=age #何地触发？：定义成另外一个类的类属性 #何时触发？：且看下列演示 p1=People('alex',18) #描述符Str的使用 p1.name p1.name='egon' del p1.name #描述符Int的使用 p1.age p1.age=18 del p1.age #我们来瞅瞅到底发生了什么 print(p1.__dict__) print(People.__dict__) #补充 print(type(p1) == People) #type(obj)其实是查看obj是由哪个类实例化来的 print(type(p1).__dict__ == People.__dict__)
3、描述符分两种
一、数据描述符：至少实现了__get__()和__set__()
class Foo: def __set__(self, instance, value): print('set') def __get__(self, instance, owner): print('get')
二、非数据描述符：没有实现__set__()
class Foo: def __get__(self, instance, owner): print('get')
4、注意事项：
一、描述符本身应该定义成新式类,被代理的类也应该是新式类
二、必须把描述符定义成这个类的类属性，不能为定义到构造函数中
三、要严格遵循该优先级,优先级由高到底分别是：
- 类属性
- 数据描述符
- 实例属性
- 非数据描述符
- 找不到的属性触发__getattr__()
#描述符Str class Str: def __get__(self, instance, owner): print('Str调用') def __set__(self, instance, value): print('Str设置...') def __delete__(self, instance): print('Str删除...') class People: name=Str() def __init__(self,name,age): #name被Str类代理,age被Int类代理, self.name=name self.age=age #基于上面的演示,我们已经知道,在一个类中定义描述符它就是一个类属性,存在于类的属性字典中,而不是实例的属性字典 #那既然描述符被定义成了一个类属性,直接通过类名也一定可以调用吧,没错 People.name #恩,调用类属性name,本质就是在调用描述符Str,触发了__get__() People.name='egon' #那赋值呢,我去,并没有触发__set__() del People.name #赶紧试试del,我去,也没有触发__delete__() #结论:描述符对类没有作用-------->傻逼到家的结论 ''' 原因:描述符在使用时被定义成另外一个类的类属性,因而类属性比二次加工的描述符伪装而来的类属性有更高的优先级 People.name #恩,调用类属性name,找不到就去找描述符伪装的类属性name,触发了__get__() People.name='egon' #那赋值呢,直接赋值了一个类属性,它拥有更高的优先级,相当于覆盖了描述符,肯定不会触发描述符的__set__() del People.name #同上 '''
People.name #调用类属性name，本质就是在调用描述符Str，触发了__get__() People.name='egon' #那赋值呢,我去，并没有触发__set__()，类属性级别最高，直接用People.name='egon' 覆盖掉name = Str()
"""数据描述符 > 实例属性""" #描述符Str class Str: def __get__(self, instance, owner): print('Str调用') def __set__(self, instance, value): print('Str设置...') def __delete__(self, instance): print('Str删除...') class People: name=Str() def __init__(self,name,age): #name被Str类代理,age被Int类代理, self.name=name self.age=age p1=People('egon',18) #如果描述符是一个数据描述符(即有__get__又有__set__),那么p1.name的调用与赋值都是触发描述符的操作,于p1本身无关了,相当于覆盖了实例的属性 p1.name='egonnnnnn' p1.name print(p1.__dict__) #实例的属性字典中没有name,因为name是一个数据描述符,优先级高于实例属性，查看/赋值/删除都是跟描述符有关,与实例无关了 del p1.name
p1=People('egon',18) #实例化--->name='egon' 触发描述符__set__() #如果描述符是一个数据描述符(即有__get__又有__set__),那么p1.name的调用与赋值都是触发描述符的操作,于p1本身无关了,相当于覆盖了实例的属性 p1.name='egonnnnnn' p1.name print(p1.__dict__) #实例的属性字典中没有name,因为name是一个数据描述符,优先级高于实例属性，查看/赋值/删除都是跟描述符有关,与实例无关了 del p1.name #触发描述符 __delete__()
class Foo: def func(self): print('我胡汉三又回来了') f1=Foo() f1.func() #调用类的方法,也可以说是调用非数据描述符 #函数是一个非数据描述符对象(一切皆对象么) print(dir(Foo.func)) print(hasattr(Foo.func,'__set__')) print(hasattr(Foo.func,'__get__')) print(hasattr(Foo.func,'__delete__')) #有人可能会问,描述符不都是类么,函数怎么算也应该是一个对象啊,怎么就是描述符了 #笨蛋哥,描述符是类没问题,描述符在应用的时候不都是实例化成一个类属性么 #函数就是一个由非描述符类实例化得到的对象 #没错，字符串也一样 f1.func='这是实例属性啊' print(f1.func) del f1.func #删掉了非数据 f1.func()
class Foo: def __set__(self, instance, value): print('set') def __get__(self, instance, owner): print('get') class Room: name=Foo() def __init__(self,name,width,length): self.name=name self.width=width self.length=length #name是一个数据描述符,因为name=Foo()而Foo实现了get和set方法,因而比实例属性有更高的优先级 #对实例的属性操作,触发的都是描述符的 r1=Room('厕所',1,1) r1.name r1.name='厨房' class Foo: def __get__(self, instance, owner): print('get') class Room: name=Foo() def __init__(self,name,width,length): self.name=name self.width=width self.length=length #name是一个非数据描述符,因为name=Foo()而Foo没有实现set方法,因而比实例属性有更低的优先级 #对实例的属性操作,触发的都是实例自己的 r1=Room('厕所',1,1) r1.name r1.name='厨房'
class Foo: def func(self): print('我胡汉三又回来了') def __getattr__(self, item): print('找不到了当然是来找我啦',item) f1=Foo() f1.xxxxxxxxxxx
5、描述符使用
众所周知，python是弱类型语言，即参数的赋值没有类型限制，下面我们通过描述符机制来实现类型限制功能
class Str: def __init__(self,name): self.name=name def __get__(self, instance, owner): print('get--->',instance,owner) return instance.__dict__[self.name] def __set__(self, instance, value): print('set--->',instance,value) instance.__dict__[self.name]=value def __delete__(self, instance): print('delete--->',instance) instance.__dict__.pop(self.name) class People: name=Str('name') def __init__(self,name,age,salary): self.name=name self.age=age self.salary=salary p1=People('egon',18,3231.3) #调用 print(p1.__dict__) p1.name #赋值 print(p1.__dict__) p1.name='egonlin' print(p1.__dict__) #删除 print(p1.__dict__) del p1.name print(p1.__dict__)
class Str: def __init__(self,name): self.name=name def __get__(self, instance, owner): print('get--->',instance,owner) return instance.__dict__[self.name] def __set__(self, instance, value): print('set--->',instance,value) instance.__dict__[self.name]=value def __delete__(self, instance): print('delete--->',instance) instance.__dict__.pop(self.name) class People: name=Str('name') def __init__(self,name,age,salary): self.name=name self.age=age self.salary=salary #疑问:如果我用类名去操作属性呢 People.name #报错,错误的根源在于类去操作属性时,会把None传给instance #修订__get__方法 class Str: def __init__(self,name): self.name=name 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) instance.__dict__[self.name]=value def __delete__(self, instance): print('delete--->',instance) instance.__dict__.pop(self.name) class People: name=Str('name') def __init__(self,name,age,salary): self.name=name self.age=age self.salary=salary print(People.name) #完美,解决
class Str: 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): #如果不是期望的类型，则抛出异常 raise TypeError('Expected %s' %str(self.expected_type)) instance.__dict__[self.name]=value def __delete__(self, instance): print('delete--->',instance) instance.__dict__.pop(self.name) class People: name=Str('name',str) #新增类型限制str def __init__(self,name,age,salary): self.name=name self.age=age self.salary=salary p1=People(123,18,3333.3)#传入的name因不是字符串类型而抛出异常
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): raise TypeError('Expected %s' %str(self.expected_type)) instance.__dict__[self.name]=value def __delete__(self, instance): print('delete--->',instance) instance.__dict__.pop(self.name) class People: name=Typed('name',str) age=Typed('name',int) salary=Typed('name',float) def __init__(self,name,age,salary): self.name=name self.age=age self.salary=salary p1=People(123,18,3333.3) p1=People('egon','18',3333.3) p1=People('egon',18,3333)
大刀阔斧之后我们已然能实现功能了，但是问题是，如果我们的类有很多属性，你仍然采用在定义一堆类属性的方式去实现，low，这时候我需要教你一招：独孤九剑
def decorate(cls): print('类的装饰器开始运行啦------>') return cls @decorate #无参:People=decorate(People) class People: def __init__(self,name,age,salary): self.name=name self.age=age self.salary=salary p1=People('egon',18,3333.3)
def typeassert(**kwargs): def decorate(cls): print('类的装饰器开始运行啦------>',kwargs) 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 self.age=age self.salary=salary p1=People('egon',18,3333.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): raise TypeError('Expected %s' %str(self.expected_type)) 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(): 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 self.age=age self.salary=salary print(People.__dict__) p1=People('egon',18,3333.3)
6、描述符总结
描述符是可以实现大部分python类特性中的底层魔法,包括@classmethod,@staticmethd,@property甚至是__slots__属性
描述符是很多高级库和框架的重要工具之一,描述符通常是使用到装饰器或者元类的大型框架中的一个组件.
7、利用描述符原理完成一个自定制@property，实现延迟计算
（本质就是把一个函数属性利用装饰器原理做成一个描述符：类的属性字典中函数名为key，value为描述符类产生的对象）
class Room: def __init__(self,name,width,length): self.name=name self.width=width self.length=length @property def area(self): return self.width * self.length r1=Room('alex',1,1) print(r1.area)
class Lazyproperty: def __init__(self,func): self.func=func def __get__(self, instance, owner): print('这是我们自己定制的静态属性,r1.area实际是要执行r1.area()') if instance is None: return self 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) 相当于定义了一个类属性,即描述符 def area(self): return self.width * self.length r1=Room('alex',1,1) print(r1.area)
class Lazyproperty: def __init__(self,func): self.func=func def __get__(self, instance, owner): print('这是我们自己定制的静态属性,r1.area实际是要执行r1.area()') if instance is None: return self else: print('--->') value=self.func(instance) setattr(instance,self.func.__name__,value) #计算一次就缓存到实例的属性字典中 return value class Room: def __init__(self,name,width,length): self.name=name self.width=width self.length=length @Lazyproperty #area=Lazyproperty(area) 相当于'定义了一个类属性,即描述符' def area(self): return self.width * self.length r1=Room('alex',1,1) print(r1.area) #先从自己的属性字典找,没有再去类的中找,然后出发了area的__get__方法 print(r1.area) #先从自己的属性字典找,找到了,是上次计算的结果,这样就不用每执行一次都去计算
#缓存不起来了 class Lazyproperty: def __init__(self,func): self.func=func def __get__(self, instance, owner): print('这是我们自己定制的静态属性,r1.area实际是要执行r1.area()') if instance is None: return self else: value=self.func(instance) instance.__dict__[self.func.__name__]=value return value # return self.func(instance) #此时你应该明白,到底是谁在为你做自动传递self的事情 def __set__(self, instance, value): print('hahahahahah') class Room: def __init__(self,name,width,length): self.name=name self.width=width self.length=length @Lazyproperty #area=Lazyproperty(area) 相当于定义了一个类属性,即描述符 def area(self): return self.width * self.length print(Room.__dict__) r1=Room('alex',1,1) print(r1.area) print(r1.area) print(r1.area) print(r1.area) #缓存功能失效,每次都去找描述符了,为何,因为描述符实现了set方法,它由非数据描述符变成了数据描述符,数据描述符比实例属性有更高的优先级,因而所有的属性操作都去找描述符了
8、利用描述符原理完成一个自定制@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: name='linhaifeng' @ClassMethod # say_hi=ClassMethod(say_hi) def say_hi(cls): print('你好啊,帅哥 %s' %cls.name) People.say_hi() p1=People() p1.say_hi() #疑问,类方法如果有参数呢,好说,好说 class ClassMethod: def __init__(self,func): self.func=func def __get__(self, instance, owner): #类来调用,instance为None,owner为类本身,实例来调用,instance为实例,owner为类本身, def feedback(*args,**kwargs): print('在这里可以加功能啊...') return self.func(owner,*args,**kwargs) return feedback class People: name='linhaifeng' @ClassMethod # say_hi=ClassMethod(say_hi) def say_hi(cls,msg): print('你好啊,帅哥 %s %s' %(cls.name,msg)) People.say_hi('你是那偷心的贼') p1=People() p1.say_hi('你是那偷心的贼')
9、利用描述符原理完成一个自定制的@staticmethod
class StaticMethod: def __init__(self,func): self.func=func def __get__(self, instance, owner): #类来调用,instance为None,owner为类本身,实例来调用,instance为实例,owner为类本身, def feedback(*args,**kwargs): print('在这里可以加功能啊...') return self.func(*args,**kwargs) return feedback class People: @StaticMethod# say_hi=StaticMethod(say_hi) def say_hi(x,y,z): print('------>',x,y,z) People.say_hi(1,2,3) p1=People() p1.say_hi(4,5,6)
10、高级应用案例：类的装饰器+描述符
'''高级应用：类的装饰器+描述符''' class Typed: '''限定添加属性的类别''' def __init__(self,key,expect_type): self.key = key self.expect_type = expect_type def __get__(self, instance, owner): '''instance 是代理类的对象''' return instance.__dict__[self.key] def __set__(self, instance, value): '''value 是要设置的值''' if isinstance(value,self.expect_type): instance.__dict__[self.key] = value else: raise TypeError("%s传入的不是%s"%(self.key,self.expect_type)) def __delete__(self, instance): instance.__dict__.pop(self.key) def cls_decorate(**kwargs): '''向类中添加属性，并且属性被描述符代理''' def deco(obj): for key,val in kwargs.items(): setattr(obj,key,Typed(key,val)) #===> obj.key = val return obj return deco @cls_decorate(name=str,age=int,salary=float) #===> @deco ===>People = deco(People) 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 p1 = People("xiong",26,1223.22) print(People.__dict__) print(p1.__dict__) print(p1.name) print(p1.age) print(p1.salary)
六、反射 / 描述符 / 类的特殊成员 的用法总结
#反射/自省
hasattr(obj,'属性') #obj.属性 是否存在
getattr(obj,'属性') #obj.属性 获取属性，不存在报错
getattr(obj,'属性',default='值') #obj.属性 获取属性，不存在返回默认值
setattr(obj,'属性','属性的值') #obj.属性=属性的值
delattr(obj,'属性') #del obj.属性 删除属性
#类内置的3中属性操作方法
# __getattr__() __setattr__() __delattr__()
# obj点的方式去操作属性时触发
__getattr__() obj.属性，调用的属性不存在时触发
__setattr__() obj.属性=属性的值，设置属性时触发
__delattr__() del obj.属性，删除属性时触发
# __getitem__ __setitem__ __delitem__
# obj['属性'] 的方式去操作属性时触发
__getitem__ obj['属性'] 时触发
__setitem__ obj['属性']=属性的值 时触发
__delitem__ del obj['属性'] 时触发
#描述符：__get__ , __set__ , __delete__
描述就是一个新式类，这个类至少要实现上述3个方法中的一个
class 描述符:
def __get__(self, instance, owner):
print('__get__调用')
def __set__(self, instance, value):
print('__set__设置...')
def __delete__(self, instance):
print('__delete__删除...')
class 类名:
name = 描述符() #在这里定义
在什么地方使用？
在被描述类中定义
在什么时候会触发？
描述符是用来描述别人的，自己产生属性的获取/设置/删除 不会触发
obj = 类名()
obj.name #触发__get__
obj.name = 'xiong' #触发 __set__
del obj.name #触发 __delete__
#__del__ :析构方法
# 内存垃圾回收触发
# __getattribute__ :以点的方式调用属性都会触发（无论属性存不存在都会触发）
# __str__ ：定制print输出信息，print()
>>> class Bar:
... def __init__(self,name,age):
... self.name = name
... self.age = age
... def __str__(self):
... return "Bar's name=%s,age=%s"%(self.name,self.age)
...
>>> b1 = Bar('xiong',26)
>>> print(b1) #print() --->就是在执行 __str__()
Bar's name=xiong,age=26
>>> str(b1)
"Bar's name=xiong,age=26"
>>> class Foo:
... def __repr__(self):
... return '123'
...
>>> f1 = Foo()
>>> print(f1)
>>> str(f1)
'123'
>>> repr(f1)
'123'
#__slots__ :节省内存，所有实例共用一个属性字典（属性字典不能修改/删除）
#__doc__ :查看类说明文档信息
#__module__ :查看在哪个模块，__class__ 查看是由哪个类产生的
#__call__ :实例对象() --->实际就是在调用 call()方法
#__next__ , __iter__ :生成迭代器
class Fib:
def __init__(self):
self._a=0
self._b=1
def __iter__(self):
return self
def __next__(self):
self._a,self._b=self._b,self._a + self._b
return self._a
f1=Fib() #f1 = iter(f1)
print(f1.__next__())
print(next(f1))
print(next(f1))
for i in f1:
if i > 100:
break
print('%s ' %i,end='')
##上下文管理协议：__enter__ , __exit__
案例：
class Foo:
def __init__(self,name):
self.name = name
def __enter__(self):
print('enter...')
return self
def __exit__(self, exc_type, exc_val, exc_tb):
print("exit》》》")
print(exc_type) #异常名称：<class 'NameError'>
print(exc_val) #异常详细信息：name 'ghiqtehjdk' is not defined
print(exc_tb) #异常追踪信息：<traceback object at 0x00000242F81DAB48>
return True #程序不会抛出异常 终止,直接跳出with 继续执行后面程序
with Foo('a.txt') as f:
print(f)
print(ghiqtehjdk) #报错 直接触发 exit()
print(f.name)
print("with结束了！！！")
####解析释义
with obj as f:
'代码块'
1、with obj ---> 触发obj.__enter__(),拿到 def __enter__() 的返回值
2、as f --->f = 返回值
3、with obj as f <===>f = obj.__enter__()
4、执行'代码块'
一、没有异常的情况下，整个'代码块'执行完毕之后触发__exit__(),它的三个参数返回None
二、有异常的情况下，'代码块'执行到异常处直接触发__exit__()
a、如果__exit__ 返回值是 True，代表吞掉异常（执行完__exit__之后跳出with，继续执行后续程序）
b、如果__exit__ 返回值不是 True，代表吐出异常（执行完__exit__之后直接终止程序）
c、__exit__ 运行完毕就代表着整个with语句的执行完毕
metaclass 元类
链接：https://www.cnblogs.com/XJT2018/p/10895004.html
http://www.cnblogs.com/linhaifeng/articles/8029564.html
参考：http://www.cnblogs.com/linhaifeng/articles/6204014.html#_label6
https://www.cnblogs.com/wupeiqi/p/4766801.html
林海峰初级篇：https://www.cnblogs.com/linhaifeng/articles/6182264.html
林海峰高级篇：https://www.cnblogs.com/linhaifeng/articles/6204014.html#_label6
林海峰继承和派生篇：https://www.cnblogs.com/linhaifeng/articles/7340153.html
武沛齐初级篇：https://www.cnblogs.com/wupeiqi/p/4493506.html
武沛齐进阶篇：https://www.cnblogs.com/wupeiqi/p/4766801.html
Python 为什么要使用描述符？