一、isinstance(obj,cls)和issubclass(sub,super)
isinstance(obj,cls)检查是否obj是否是类 cls 的对象：
class Foo(object):
pass
obj = Foo()
isinstance(obj, Foo) # 判断对象是否是该类实例化的issubclass(sub, super)检查sub类是否是 super 类的派生类（子类）：
class Foo(object):
pass
class Bar(Foo):
pass
issubclass(Bar, Foo) # 判断是否属于父子类关系二、反射
反射概念：
反射的概念主要指程序可以访问、检测和修改它本身状态或行为的一种能力（自省）。它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。
python面向对象中的反射：
通过字符串的形式操作对象相关的属性。python中的一切事物都是对象（都可以使用反射）
4个可以实现自省的函数：
- hasattr(object,name) # 判断object中有没有一个name字符串对应的方法或属性
- getattr(object, name, default=None) # 从一个对象中获得该名称对应的属性，同时可进行赋值，默认值为None
- setattr(x, y, v) # 将给定对象上的命名属性设置为指定值， 等同于 x.y=v
- delattr(x, y) # 删除x对象中y的属性
4个方法的演示：
class BlackMedium:
feature='Ugly'
def __init__(self,name,addr):
self.name=name
self.addr=addr
def sell_house(self):
print('%s 黑中介卖房子啦,傻逼才买呢,但是谁能证明自己不傻逼' %self.name)
def rent_house(self):
print('%s 黑中介租房子啦,傻逼才租呢' %self.name)
b1=BlackMedium('万成置地','回龙观天露园')
#检测是否含有某属性
print(hasattr(b1,'name')) # 返回布尔值，结果为True
print(hasattr(b1,'sell_house')) # 结果为True
#获取属性值
n=getattr(b1,'name')
print(n)
func=getattr(b1,'rent_house')
func()
# getattr(b1,'aaaaaaaa') #报错
print(getattr(b1,'aaaaaaaa','不存在啊')) # 如果属性不存在，则创建该属性，属性名为'aaaaaaaaaa', 值为“不存在啊”
#设置属性
setattr(b1,'sb',True)
setattr(b1,'show_name',lambda self:self.name+'sb') # 通过匿名函数赋予属性值
print(b1.__dict__)
print(b1.show_name(b1))
#删除属性
delattr(b1,'addr')
delattr(b1,'show_name')
delattr(b1,'show_name111')#不存在,则报错
print(b1.__dict__) # 查看对象名称空间中的属性字典类也是对象：
class Foo(object):
staticField = "old boy"
def __init__(self):
self.name = 'wupeiqi'
def func(self):
return 'func'
@staticmethod
def bar(self):
return 'bar'
print(getattr(Foo, 'staticField'))
print(getattr(Foo, 'func'))
print(getattr(Foo, 'bar'))
反射当前模块成员：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import sys
def s1():
print( 's1')
def s2():
print ('s2')
this_module = sys.modules[__name__] # 获得模块字典，其中有Key为__name__的值
print(sys.modules)
print(this_module) # <module '__main__' from 'E:/blog/blog/app02/tests.py'>，查看模块所处路径位置
print(hasattr(this_module, 's1')) # True
print(getattr(this_module, 's2')) # <function s2 at 0x00000249B7DCE730>, 通过反射获得函数s2的内存地址
getattr(this_module, 's2')() # s2, 调用内存中的s2函数
导入其他模块，利用反射查找该模块是否存在某个方法：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
"""
当前文件： module_test.py
"""
def test():
print('from the test')#!/usr/bin/env python
# -*- coding:utf-8 -*-
"""
当前文件： index.py
"""
from app02 import module_test as obj
#obj.test()
print(hasattr(obj,'test')) # True
getattr(obj,'test')() # from the test
反射的好处：
- 好处一：实现可插拔机制：
有俩程序员，一个lili，一个是egon，lili在写程序的时候需要用到egon所写的类，但是egon去跟女朋友度蜜月去了，还没有完成他写的类，lili想到了反射，使用了反射机制lili可以继续完成自己的代码，等egon度蜜月回来后再继续完成类的定义并且去实现lili想要的功能。
反射的好处可以事先定义好接口，接口只有在被完成后才会真正执行，实现了即插即用。这其实是一种‘后期绑定’，什么意思？即你可以事先把主要的逻辑写好（只定义接口），然后后期再去实现接口的功能。
# 还没有实现代码功能
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('处理其他的逻辑')- 好处二：动态导入模块（基于反射当前模块成员）
三、_setattr_,_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 #应该使用它
def __delattr__(self, item):
print('----> from delattr')
# del self.item #无限递归了
self.__dict__.pop(item)
#__setattr__添加/修改属性会触发它的执行
f1=Foo(10) # 为y赋值为10，在属性字典中默认生成y：10
print(f1.__dict__)# 因为你重写了__setattr__,凡是赋值操作都会触发它的运行,重写的setattr中如果没有赋值,属性字典为空，除非在重写该函数中定义属性字典
f1.z=3
print(f1.__dict__) # 还是为空，因为__setattr__函数中没有为__dict__创建新的值
f1.__dict__['a']=3#我们可以直接修改属性字典,来完成添加/修改属性的操作
del f1.a # __delattr__删除属性的时候会触发
print(f1.__dict__) # 删除后属性字典为空
#__getattr__只有在使用点调用属性且属性不存在的时候才会触发
f1.xxxxxx
四、二次加工标准类型(包装)
包装：
python为大家提供了标准数据类型，以及丰富的内置方法，其实在很多场景下我们都需要基于标准数据类型来定制我们自己的数据类型，新增/改写方法，这就用到了我们刚学的继承/派生知识（其他的标准类型均可以通过下面的方式进行二次加工）
基于继承实现二次加工标准类型：
class List(list): #继承list所有的属性，也可以派生出自己新的，比如append和mid
def append(self, p_object):
' 派生自己的append：加上类型检查'
if not isinstance(p_object,int):
raise TypeError('must be int')
super().append(p_object) # 调用父类中的append方法
@property
def mid(self): # 获得列表中间位置的值
'新增自己的属性'
index=len(self)//2
return self[index]
l=List([1,2,3,4])
print(l)
l.append(5)
print(l)
# l.append('1111111') #报错，必须为int类型
print(l.mid) # 将对象l 传入mid函数中
#其余的方法都继承list的
l.insert(0,-123) # 在索引为0的位置添加-123
print(l)
l.clear()
print(l)
练习（clear加权限限制）：
class List(list):
def __init__(self,item,tag=False):
super().__init__(item)
self.tag=tag
def append(self, p_object):
if not isinstance(p_object,str):
raise TypeError
super().append(p_object)
def clear(self):
if not self.tag:
raise PermissionError
super().clear()
l=List([1,2,3],False)
print(l)
print(l.tag)
l.append('saf')
print(l)
# l.clear() # 抛出异常permissionError
l.tag=True #
l.clear() # 清除成功
print(l) # []授权：
授权是包装的一个特性, 包装一个类型通常是对已存在的类型的一些定制,这种做法可以新建,修改或删除原有产品的功能。其它的则保持原样。授权的过程,即是所有更新的功能都是由新类的某部分来处理,但已存在的功能就授权给对象的默认属性。
实现授权的关键点就是覆盖getattr方法:
import time
class FileHandle:
def __init__(self,filename,mode='r',encoding='utf-8'):
self.file=open(filename,mode,encoding=encoding)
def write(self,line):
t=time.strftime('%Y-%m-%d %T')
self.file.write('%s %s' %(t,line))
def __getattr__(self, item):
return getattr(self.file,item)
f1=FileHandle('b.txt','w+')
f1.write('你好啊')
f1.seek(0) # 移动光标到起始位置
print(f1.read()) # 访问read属性时，自动调用重写的__getattr__函数,通过函数中定义的getattr反射方法，再传入f1对象与属性名read，获得绑定方法，通过（）执行该方法
f1.close() # 关闭文件句柄
练习一：
#练习一
#练习一
class List:
def __init__(self,seq):
self.seq=seq
def append(self, p_object):
' 派生自己的append加上类型检查，覆盖原有的append'
if not isinstance(p_object,int):
raise TypeError('must be int')
self.seq.append(p_object)
@property
def mid(self):
'新增自己的方法'
index=len(self.seq)//2
return self.seq[index]
def __getattr__(self, item):
return getattr(self.seq,item)
def __str__(self):
return str(self.seq)
l=List([1,2,3])
print(l) # [1, 2, 3]
l.append(4) # [1, 2, 3, 4]
print(l)
# l.append('3333333') #报错，必须为int类型
print(l.mid) # 3
#基于授权，获得insert方法
l.insert(0,-123) # 通过访问insert属性，自动调用重写的__getattr__函数，再通过函数中的反射，获得l对象的绑定insert方法，再传入参数0，-123,通过()完成方法的调用
print(l) # [-123, 1, 2, 3, 4]
练习二：
class List:
def __init__(self,seq,permission=False):
self.seq=seq
self.permission=permission
def clear(self):
if not self.permission:
raise PermissionError('not allow the operation')
self.seq.clear()
def __getattr__(self, item):
return getattr(self.seq,item)
def __str__(self):
return str(self.seq)
l=List([1,2,3])
# l.clear() #此时没有权限，抛出异常
l.permission=True
print(l) # [1, 2, 3]
l.clear()
print(l) # []
#基于授权，获得insert方法
l.insert(0,-123)
print(l) # [-123]
五、 _getattribute_
_getattr_函数：
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__
"""
执行结果：
10
执行的是我
"""_getattribute_函数：
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
# 执行的结果：
"""
不管是否存在,我都会执行
执行的是我
不管是否存在,我都会执行
执行的是我
"""六、描述符(_get_,_set_,_delete_)
- 描述符是什么:
-描述符本质就是一个新式类,在这个新式类中,至少实现了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描述符的使用：
引子:描述符类产生的实例进行属性操作并不会触发三个方法的执行
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设置... Int设置...
#
# #描述符Str的使用
p1.name # Str调用
p1.name='egon' # Str设置...
del p1.name # Str删除...
#
# #描述符Int的使用
p1.age # Int调用
p1.age=18 # Int设置...
del p1.age # Int删除...
#
# #我们来瞅瞅到底发生了什么
print(p1.__dict__) # {}
print(People.__dict__) # 类的属性字典
#
# #补充
print(type(p1) == People) # True type(obj)其实是查看obj是由哪个类实例化来的
print(type(p1).__dict__ == People.__dict__) # True
描述符分两种：
- 数据描述符:至少实现了_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')注意事项:
一、 描述符本身应该定义成新式类,被代理的类也应该是新式类
二、 必须把描述符定义成这个类的类属性，不能为定义到构造函数中
三 、要严格遵循该优先级,优先级由高到底分别是：
1.类属性
2.数据描述符
3.实例属性
4.非数据描述符
5.找不到的属性触发_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 #同上
'''- 数据描述符>实例属性:
#描述符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- 实例属性>非数据描述符:
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 func(self):
print('我胡汉三又回来了')
def __getattr__(self, item):
print('找不到了当然是来找我啦',item)
f1=Foo()
f1.xxxxxxxxxxx描述符使用:
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)类的装饰器（无参）：
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)
# 执行结果：类的装饰器开始运行啦------> {'name': <class 'str'>, 'age': <class 'int'>, 'salary': <class 'float'>}终极方式：
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)总结：
描述符可实现大部分python类特性中的底层魔法,包括@classmethod,@staticmethd,@property甚至是slots属性，描述符是很多高级库和框架的重要工具之一,描述符通常是使用到装饰器或者元类的大型框架中的一个组件.
利用描述符原理完成一个自定制@property,实现延迟计算（本质就是把一个函数属性利用装饰器原理做成一个描述符：类的属性字典中函数名为key，value为描述符类产生的对象）
property回顾：
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)自定义一个@property：
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)
# 执行结果：
这是我们自己定制的静态属性,r1.area实际是要执行r1.area()
1实现延迟计算功能：
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) #先从自己的属性字典找,找到了,是上次计算的结果,这样就不用每执行一次都去计算利用描述符完成自定制的@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('你是那偷心的贼')利用描述符完成自定制@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)七、property回顾
一个静态属性property本质就是实现了get，set，delete三种方法
用法一：
class Foo:
@property
def AAA(self):
print('get的时候运行我啊')
@AAA.setter
def AAA(self,value):
print('set的时候运行我啊')
@AAA.deleter
def AAA(self):
print('delete的时候运行我啊')
#只有在属性AAA定义property后才能定义AAA.setter,AAA.deleter
f1=Foo()
f1.AAA
f1.AAA='aaa'
del f1.AAA
# 运行结果：
"""get的时候运行我啊
set的时候运行我啊
delete的时候运行我啊"""
用法二：
class Foo:
def get_AAA(self):
print('get的时候运行我啊')
def set_AAA(self,value):
print('set的时候运行我啊')
def delete_AAA(self):
print('delete的时候运行我啊')
AAA=property(get_AAA,set_AAA,delete_AAA) #内置property三个参数与get,set,delete一一对应
f1=Foo()
f1.AAA
f1.AAA='aaa'
del f1.AAA
"""
# 执行结果：
get的时候运行我啊
set的时候运行我啊
delete的时候运行我啊
"""案例：实现类型检测功能
#第一关：
class People:
def __init__(self,name):
self.name=name
@property
def name(self):
return self.name
p1=People('alex') #property自动实现了set和get方法属于数据描述符,比实例属性优先级高,所以你这面写会触发property内置的set,抛出异常
#第二关：修订版
class People:
def __init__(self,name):
self.name=name #实例化就触发property
@property
def name(self):
# return self.name #无限递归
print('get------>')
return self.DouNiWan
@name.setter
def name(self,value):
print('set------>')
self.DouNiWan=value
@name.deleter
def name(self):
print('delete------>')
del self.DouNiWan
p1=People('alex') # 触发@name.setter装饰器中的name函数， self.name实际是存放到self.DouNiWan里
print(p1.name) # get------> alex
print(p1.__dict__) # 对象的属性字典： {'DouNiWan': 'alex'}
p1.name='egon' # set------> 触发@name.setter装饰的name函数
print(p1.__dict__) # {'DouNiWan': 'egon'}
del p1.name # delete------>
print(p1.__dict__) # { }#第三关:加上类型检查
class People:
def __init__(self,name):
self.name=name #实例化就触发@name.setter
@property
def name(self):
# return self.name #无限递归
print('get------>')
return self.DouNiWan
@name.setter
def name(self,value):
print('set------>')
if not isinstance(value,str):
raise TypeError('必须是字符串类型')
self.DouNiWan=value
@name.deleter
def name(self):
print('delete------>')
del self.DouNiWan
p1=People('alex') #self.name实际是存放到self.DouNiWan里
print(p1.__dict__) # {'DouNiWan': 'alex'}
p1.name=1 # TypeError: 必须是字符串类型
八、_setitem_,_getitem_,_delitem_ (应用于Django中session的实现)
class Foo:
def __init__(self,name):
self.name=name
def __getitem__(self, item):
print(self.__dict__[item])
def __setitem__(self, key, value):
self.__dict__[key]=value
def __delitem__(self, key):
print('del obj[key]时,我执行')
self.__dict__.pop(key)
def __delattr__(self, item):
print('del obj.key时,我执行')
self.__dict__.pop(item)
f1=Foo('sb')
print(f1.__dict__) # {'name': 'sb'}
f1['age']=18
print(f1.__dict__) # {'name': 'sb', 'age': 18}
f1['age1']=19
print(f1.__dict__)
del f1.age1 # del obj.key时,我执行
print(f1.__dict__) # {'name': 'sb', 'age': 18}
del f1['age']
print(f1.__dict__) # {'name': 'sb'}
f1['name']='alex'
print(f1.__dict__) # {'name': 'alex'}
九、_str_,_repr_,_format_
改变对象的字符串显示str,repr、自定制格式化字符串format
#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'
format_dict={
'nat':'{obj.name}-{obj.addr}-{obj.type}',#学校名-学校地址-学校类型
'tna':'{obj.type}:{obj.name}:{obj.addr}',#学校类型:学校名:学校地址
'tan':'{obj.type}/{obj.addr}/{obj.name}',#学校类型/学校地址/学校名
}
class School:
def __init__(self,name,addr,type):
self.name=name
self.addr=addr
self.type=type
def __repr__(self):
return 'School(%s,%s)' %(self.name,self.addr)
def __str__(self):
return '(%s,%s)' %(self.name,self.addr)
def __format__(self, format_spec):
# if format_spec
if not format_spec or format_spec not in format_dict:
format_spec='nat'
fmt=format_dict[format_spec]
return fmt.format(obj=self) # 字符串格式化，
s1=School('oldboy1','北京','私立')
print('from repr: ',repr(s1)) # from repr: School(oldboy1,北京)
print('from str: ',str(s1)) # from str: (oldboy1,北京
print(s1) # (oldboy1,北京) 调用__str__内置函数
print(s1.__dict__) # {'name': 'oldboy1', 'addr': '北京', 'type': '私立'}
#
# '''
# str函数或者print函数--->obj.__str__()
# repr或者交互式解释器--->obj.__repr__()
# 如果__str__没有被定义,那么就会使用__repr__来代替输出
# 注意:这俩方法的返回值必须是字符串,否则抛出异常
# '''
print(format(s1,'nat')) # oldboy1-北京-私立
print(format(s1,'tna')) # 私立:oldboy1:北京
print(format(s1,'tan')) # 私立/北京/oldboy1
print(format(s1,'asfdasdffd')) # oldboy1-北京-私立自定义Format:
date_dic={
'ymd':'{0.year}:{0.month}:{0.day}',
'dmy':'{0.day}/{0.month}/{0.year}',
'mdy':'{0.month}-{0.day}-{0.year}',
}
class Date:
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(2016,12,29)
print(format(d1)) # 2016:12:29
print('{:mdy}'.format(d1)) # 12-29-2016isinstance与issubclass:
# _*_coding:utf-8_*_
__author__ = 'Linhaifeng'
class A:
pass
class B(A):
pass
print(issubclass(B, A)) # B是A的子类,返回True
a1 = A()
print(isinstance(a1, A)) # a1是A的实例
十、 _slots_
1._slots_是一个类变量,变量值可以是列表,元祖,或可迭代对象,也可以是一个字符串(意味着所有实例只有一个数据属性)
2.引子:*使用点来访问属性本质就是在访问类或者对象的dict属性字典*(类的字典是共享的,而每个实例的是独立的)
3.为何使用_slots_:字典会占用大量内存,如果有一个属性很少的类,但是有很多实例,为了节省内存可以使用_slots_取代实例的_dict_，
当定义slots后,slots就会为实例使用一种更加紧凑的内部表示。实例通过一个很小的固定大小的数组来构建,*而不是为每个实例定义一个字典,这跟元组或列表很类似*。在slots中列出的属性名在内部被映射到这个数组的指定小标上。使用slots不好的地方就是我们不能再给实例添加新的属性了,只能使用在slots中定义的那些属性名。
4.注意事项：slots的很多特性都依赖于普通的基于字典的实现。另外,定义了slots后的类不再支持一些普通类特性了,比如多继承。大多数情况下应该只在那些经常被使用到的用作数据结构的类上定义slots，比如在程序中需要创建某个类的几百万个实例对象 。
关于slots的一个常见误区是它可以作为一个封装工具来防止用户给实例增加新的属性。尽管使用slots可以达到这样的目的,但是这个并不是它的初衷。更多的是用来作为一个内存优化工具。
class Foo:
__slots__ = 'x'
f1 = Foo()
f1.x = 1
# f1.y = 2 # 报错
print(f1.__slots__) # x, f1不再有__dict__
#################################################
class Bar:
__slots__ = ['x', 'y'] # 覆盖__dic__函数
n = Bar()
n.x, n.y = 1, 2
print(n.x) # 1
print(n.__slots__) # ['x', 'y']
# print(n.__dict__) # AttributeError: 'Bar' object has no attribute '__dict__' n不再有__dict__
# n.z = 3 # 报错
class Foo:
__slots__ = ['name', 'age']
f1 = Foo()
f1.name = 'alex'
f1.age = 18
print(f1.__slots__) # ['name', 'age']
f2 = Foo()
f2.name = 'egon'
f2.age = 19
print(f2.__slots__) # ['name', 'age']
print(Foo.__dict__) # {'__module__': '__main__', '__slots__': ['name', 'age'], 'age': <member 'age' of 'Foo' objects>, 'name': <member 'name' of 'Foo' objects>, '__doc__': None}
# f1与f2都没有属性字典__dict__了,统一归__slots__管,节省内存
十一、_next_和_iter_实现迭代器协议
简单示范：
#_*_coding:utf-8_*_
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(1)
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,5)
from collections import Iterable,Iterator
print(isinstance(f,Iterator)) # True, f是迭代器
for i in Foo(1,5):
print(i)
"""打印结果：
1
2
3
4
"""模拟range的步长函数：
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: # >=7时，抛出异常
raise StopIteration
x=self.n
self.n+=self.step # 步长为3
return x
def __iter__(self):
return self
for i in Range(1,7,3): #
print(i)
"""
打印结果：
1
4
"""斐波那契数列：
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__()) # 1
# print(next(f1)) # 1
# print(next(f1)) # 2
for i in f1:
if i > 100:
break
print('%s ' %i,end='') # 1 1 2 3 5 8 13 21 34 55 89 十二、_doc_属性字典**
class Foo:
'我是描述信息'
pass
print(Foo.__doc__) # 我是描述信息, 类的属性字典
print(Foo().__dict__) # {} ， 对象的属性字典该属性无法被继承：
class Foo:
'我是描述信息'
pass
class Bar(Foo):
pass
print(Bar.__doc__) # None， 该属性无法继承给子类十二 _module_和_class_
module 表示当前操作的对象在哪个模块
class 表示当前操作的对象的类是什么
#!/usr/bin/env python
# -*- coding:utf-8 -*-
class C:
def __init__(self):
self.name = 'SB'from lib.aa import C
obj = C()
print obj.__module__ # 输出 lib.aa，即：输出模块
print obj.__class__ # 输出 lib.aa.C，即：输出类十三、_del_
析构方法，当对象在内存中被释放时，自动触发执行:
注：如果产生的对象是python程序级别的（用户级），无需定义del。
如果产生的对象的同时还会向操作系统发起系统调用，即一个对象有用户级与内核级两种资源，比如（打开一个文件，创建一个数据库链接），则必须在清除对象的同时回收系统资源，需要用del。
class Foo:
def __del__(self):
print('执行我啦')
f1=Foo()
del f1
"""
执行结果：
执行我啦
"""
自动执行del函数：
class Foo:
def __del__(self): # 程序结束后自动触发
print('执行我啦')
f1=Foo()
# del f1
print('------->')
"""
------->
执行我啦
"""
应用场景：
创建数据库类，用该类实例化出数据库链接对象，对象本身是存放于用户空间内存中，而链接则是由操作系统管理的，存放于内核空间内存中，当程序结束时，python只会回收自己的内存空间，即用户态内存，而操作系统的资源则没有被回收，这就需要我们定制del函数，在对象被删除前向操作系统发起关闭数据库链接的系统调用，回收资源。这与文件处理是一个道理。
f=open('a.txt') # 做了两件事，在用户空间拿到一个f变量，在操作系统内核空间打开一个文件
del f #只回收用户空间的f，操作系统的文件还处于打开状态
#所以我们应该在del f 之前保证f.close()执行,即便是没有del，程序执行完毕也会自动del清理资源，于是文件操作的正确用法应该是
f=open('a.txt') # 读写...
f.close()
# 很多情况下大家都容易忽略f.close,需要用with语句进行上下文管理 with open('a.txt', r) as f: f.read()十四、_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)
"""
执行结果：
出现with语句,对象的__enter__被触发,有返回值则赋值给as声明的变量
=====>执行代码块
with中代码块执行完毕时执行我啊
"""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) #------------------------------->不会执行
"""
执行结果：
出现with语句,对象的__enter__被触发,有返回值则赋值给as声明的变量
=====>执行代码块
with中代码块执行完毕时执行我啊
<class 'AttributeError'>
***着火啦,救火啊***
"""如果exit()返回值为True,那么异常会被清空，就好像啥都没发生一样，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)
return True
with Open('a.txt') as f:
print('=====>执行代码块')
raise AttributeError('***着火啦,救火啊***')
print('0'*100) #------------------------------->会执行模拟open:
class Open:
def __init__(self,filepath,mode='r',encoding='utf-8'):
self.filepath=filepath
self.mode=mode
self.encoding=encoding
def __enter__(self):
# print('enter')
self.f=open(self.filepath,mode=self.mode,encoding=self.encoding)
return self.f
def __exit__(self, exc_type, exc_val, exc_tb):
# print('exit')
self.f.close()
return True
def __getattr__(self, item):
return getattr(self.f,item)
with Open('a.txt','w') as f:
print(f)
f.write('aaaaaa')
f.wasdf #抛出异常，交给__exit__处理
"""
打印结果：
<_io.TextIOWrapper name='a.txt' mode='w' encoding='utf-8'>
"""用途：
1.使用with语句的目的就是把代码块放入with中执行，with结束后，自动完成清理工作，无须手动干预
2.在需要管理一些资源比如文件，网络连接和锁的编程环境中，可以在exit中定制自动释放资源的机制，你无须再去关系这个问题，这将大有用处
十五、_call_语句
对象后面加括号，触发该语句的执行。
注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 call 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()
class Foo:
def __init__(self):
pass
def __call__(self, *args, **kwargs):
print('__call__')
obj = Foo() # 执行 __init__
obj() # 执行 __call__十六、元类metaclass
知识储备：
exec：三个参数：
- 参数一：字符串形式的命令
- 参数二：全局作用域（字典形式），如果不指定，默认为globals()
- 参数三：局部作用域（字典形式），如果不指定，默认为locals()
#可以把exec命令的执行当成是一个函数的执行，会将执行期间产生的名字存放于局部名称空间中
g = {
'x': 1,
'y': 2
}
l = {}
exec(
'''
global x,z
x=100
z=200
m=300
''', g, l)
print(g) # {'x': 100, 'y': 2,'z':200,......}
print(l) # {'m': 300}
类也是对象：
class Foo:
pass
f1=Foo() #f1是通过Foo类实例化的对象python中一切皆是对象，类本身也是一个对象，当使用关键字class的时候，python解释器在加载class的时候就会创建一个对象(这里的对象指的是类而非类的实例)，因而我们可以将类当作一个对象去使用，同样满足第一类对象的概念，可以：
- 把类赋值给一个变量
- 把类作为函数参数进行传递
- 把类作为函数的返回值
- 在运行时动态地创建类
上例可以看出f1是由Foo这个类产生的对象，而Foo本身也是对象，那它又是由哪个类产生的呢？
#type函数可以查看类型，也可以用来查看对象的类，二者是一样的
print(type(f1)) # 输出：<class '__main__.Foo'> 表示，obj 对象由Foo类创建
print(type(Foo)) # 输出：<type 'type'> 元类是什么？
- 元类是类的类，是类的模板
- 元类是用来控制如何创建类的，正如类是创建对象的模板一样，而元类的主要目的是为了控制类的创建行为
- 元类的实例化的结果为我们用class定义的类，正如类的实例为对象(f1对象是Foo类的一个实例，Foo类是 type 类的一个实例)
- type是python的一个内建元类，用来直接控制生成类，python中任何class定义的类其实都是type类实例化的对象
创建类的2种方式：
- 方式一：使用class关键字：
class Chinese(object):
country='China'
def __init__(self,name,age):
self.name=name
self.age=age
def talk(self):
print('%s is talking' %self.name)-方式二：手动模拟class创建类的过程：将创建类的步骤拆分开，手动创建：
#创建类主要分为三部分
- 类名
- 类的父类
- 类体
#类名
class_name='Chinese'
#类的父类
class_bases=(object,)
#类体
class_body="""
country='China'
def __init__(self,name,age):
self.name=name
self.age=age
def talk(self):
print('%s is talking' %self.name)
"""步骤一:
（先处理类体->名称空间）：类体定义的名字都会存放于类的名称空间中（一个局部的名称空间），我们可以事先定义一个空字典，然后用exec去执行类体的代码（exec产生名称空间的过程与真正的class过程类似，只是后者会将__开头的属性变形），生成类的局部名称空间，即填充字典
# 类名
class_name='Chinese'
#类的父类
class_bases=(object,)
#类体
class_body="""
country='China'
def __init__(self,name,age):
self.name=name
self.age=age
def talk(self):
print('%s is talking' %self.name)
"""
class_dic={}
exec(class_body,globals(),class_dic) # 将类体中的数据赋值生成字典
print(class_dic) # {'country': 'China', '__init__': <function __init__ at 0x0000028DD30C1E18>, 'talk': <function talk at 0x0000028DD50DE730>}步骤二：调用元类type（也可以自定义）来产生类Chinense
# 类名
class_name = 'Chinese'
# 类的父类
class_bases = (object,)
# 类体
class_body = """
country='China'
def __init__(self,name,age):
self.name=name
self.age=age
def talk(self):
print('%s is talking' %self.name)
"""
class_dic = {}
exec(class_body, globals(), class_dic) # 将类体中的数据赋值生成字典
print(
class_dic) # {'country': 'China', '__init__': <function __init__ at 0x0000028DD30C1E18>, 'talk': <function talk at 0x0000028DD50DE730>}
Foo = type(class_name, class_bases, class_dic) # 实例化type得到对象Foo，即我们用class定义的类Foo
print(Foo) # <class '__main__.Chinese'>
print(type(Foo)) # <class 'type'>
print(isinstance(Foo, type)) # True
print(Foo.__dict__) # {'country': 'China', '__init__': <function __init__ at 0x000001C793E6E730>, 'talk':……注：
type 接收三个参数：
第 1 个参数是字符串 ‘Foo’，表示类名
第 2 个参数是元组 (object, )，表示所有的父类
第 3 个参数是字典，这里是一个空字典，表示没有定义属性和方法
补充：若Foo类有继承，即class Foo(Bar):…. 则等同于type(‘Foo’,(Bar,),{})
自定义元类控制类的行为：
一个类没有声明自己的元类，默认他的元类就是type，除了使用元类type，用户也可以通过继承type来自定义元类（查看元类如何控制类的行为及工作流程：
#知识储备：
#产生的新对象 = object.__new__(继承object类的子类)
#步骤一：如果说People=type(类名,类的父类们,类的名称空间)，那么我们定义元类如下，来控制类的创建
class Mymeta(type): # 继承默认元类的一堆属性
def __init__(self, class_name, class_bases, class_dic):
if '__doc__' not in class_dic or not class_dic.get('__doc__').strip():
raise TypeError('必须为类指定文档注释')
if not class_name.istitle():
raise TypeError('类名首字母必须大写')
super(Mymeta, self).__init__(class_name, class_bases, class_dic)
class People(object, metaclass=Mymeta):
country = 'China'
def __init__(self, name, age):
self.name = name
self.age = age
def talk(self):
print('%s is talking' % self.name)
#步骤二：如果我们想控制类实例化的行为，那么需要先储备知识__call__方法的使用
class People(object,metaclass=type):
def __init__(self,name,age):
self.name=name
self.age=age
def __call__(self, *args, **kwargs):
print(self,args,kwargs)
# 调用类People，并不会出发__call__
obj=People('egon',18)
# 调用对象obj(1,2,3,a=1,b=2,c=3)，才会出发对象的绑定方法obj.__call__(1,2,3,a=1,b=2,c=3)
obj(1,2,3,a=1,b=2,c=3) #打印：<__main__.People object at 0x10076dd30> (1, 2, 3) {'a': 1, 'b': 2, 'c': 3}
#总结：如果说类People是元类type的实例，那么在元类type内肯定也有一个__call__，会在调用People('egon',18)时触发执行，然后返回一个初始化好了的对象obj
#步骤三：自定义元类，控制类的调用（即实例化）的过程
class Mymeta(type): #继承默认元类的一堆属性
def __init__(self,class_name,class_bases,class_dic):
if not class_name.istitle():
raise TypeError('类名首字母必须大写')
super(Mymeta,self).__init__(class_name,class_bases,class_dic)
def __call__(self, *args, **kwargs):
#self=People
print(self,args,kwargs) #<class '__main__.People'> ('egon', 18) {}
#1、实例化People，产生空对象obj
obj=object.__new__(self)
#2、调用People下的函数__init__，初始化obj
self.__init__(obj,*args,**kwargs)
#3、返回初始化好了的obj
return obj
class People(object,metaclass=Mymeta):
country='China'
def __init__(self,name,age):
self.name=name
self.age=age
def talk(self):
print('%s is talking' %self.name)
obj=People('egon',18)
print(obj.__dict__) #{'name': 'egon', 'age': 18}
#步骤四：
class Mymeta(type): #继承默认元类的一堆属性
def __init__(self,class_name,class_bases,class_dic):
if not class_name.istitle():
raise TypeError('类名首字母必须大写')
super(Mymeta,self).__init__(class_name,class_bases,class_dic)
def __call__(self, *args, **kwargs):
#self=People
print(self,args,kwargs) #<class '__main__.People'> ('egon', 18) {}
#1、调用self，即People下的函数__new__，在该函数内完成：1、产生空对象obj 2、初始化 3、返回obj
obj=self.__new__(self,*args,**kwargs)
#2、一定记得返回obj，因为实例化People(...)取得就是__call__的返回值
return obj
class People(object,metaclass=Mymeta):
country='China'
def __init__(self,name,age):
self.name=name
self.age=age
def talk(self):
print('%s is talking' %self.name)
def __new__(cls, *args, **kwargs):
obj=object.__new__(cls)
cls.__init__(obj,*args,**kwargs)
return obj
obj=People('egon',18)
print(obj.__dict__) #{'name': 'egon', 'age': 18}
#步骤五：基于元类实现单例模式,比如数据库对象,实例化时参数都一样,就没必要重复产生对象,浪费内存
class Mysql:
__instance=None
def __init__(self,host='127.0.0.1',port='3306'):
self.host=host
self.port=port
@classmethod
def singleton(cls,*args,**kwargs):
if not cls.__instance:
cls.__instance=cls(*args,**kwargs)
return cls.__instance
obj1=Mysql()
obj2=Mysql()
print(obj1 is obj2) #False
obj3=Mysql.singleton()
obj4=Mysql.singleton()
print(obj3 is obj4) #True
应用：定制元类实现单例模式：
#应用：定制元类实现单例模式
class Mymeta(type):
def __init__(self,name,bases,dic): #定义类Mysql时就触发
self.__instance=None
super().__init__(name,bases,dic)
def __call__(self, *args, **kwargs): #Mysql(...)时触发
if not self.__instance:
self.__instance=object.__new__(self) #产生对象
self.__init__(self.__instance,*args,**kwargs) #初始化对象
#上述两步可以合成下面一步
# self.__instance=super().__call__(*args,**kwargs)
return self.__instance
class Mysql(metaclass=Mymeta):
def __init__(self,host='127.0.0.1',port='3306'):
self.host=host
self.port=port
obj1=Mysql()
obj2=Mysql()
print(obj1 is obj2)
练习：在元类中控制把自定义类的数据属性都变成大写
class Mymetaclass(type):
def __new__(cls,name,bases,attrs):
update_attrs={}
for k,v in attrs.items():
if not callable(v) and not k.startswith('__'):
update_attrs[k.upper()]=v
else:
update_attrs[k]=v
return type.__new__(cls,name,bases,update_attrs)
class Chinese(metaclass=Mymetaclass):
country='China'
tag='Legend of the Dragon' #龙的传人
def walk(self):
print('%s is walking' %self.name)
print(Chinese.__dict__)
'''
{'__module__': '__main__',
'COUNTRY': 'China',
'TAG': 'Legend of the Dragon',
'walk': <function Chinese.walk at 0x0000000001E7B950>,
'__dict__': <attribute '__dict__' of 'Chinese' objects>,
'__weakref__': <attribute '__weakref__' of 'Chinese' objects>,
'__doc__': None}
'''练习二：
- 元类帮其完成创建对象，以及初始化操作；
- 要求实例化时传参必须为关键字形式，否则抛出异常TypeError: must use keyword argument
- key作为用户自定义类产生对象的属性，且所有属性变成大写
class Mymetaclass(type):
# def __new__(cls,name,bases,attrs):
# update_attrs={}
# for k,v in attrs.items():
# if not callable(v) and not k.startswith('__'):
# update_attrs[k.upper()]=v
# else:
# update_attrs[k]=v
# return type.__new__(cls,name,bases,update_attrs)
def __call__(self, *args, **kwargs):
if args:
raise TypeError('must use keyword argument for key function')
obj = object.__new__(self) #创建对象，self为类Foo
for k,v in kwargs.items():
obj.__dict__[k.upper()]=v
return obj
class Chinese(metaclass=Mymetaclass):
country='China'
tag='Legend of the Dragon' #龙的传人
def walk(self):
print('%s is walking' %self.name)
p=Chinese(name='egon',age=18,sex='male')
print(p.__dict__)
7124
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
