Python面向对象编程（三）
作者：springsnow 发布时间：2021-10-09 18:28:06
标签：Python,面向对象,编程
Python面向对象编程（一）
Python面向对象编程（二）
Python面向对象编程（三）
一、isinstance和issubclass
type()：不会认为子类实例是一种父类类型；
isinstance()：认为子类实例是一种父类类型。
issubclass()：判断是否为其子类。
class Foo(object):
pass
class Bar(Foo):
pass
print(type(Foo()) == Foo)
# True
print(type(Bar()) == Foo)
# False
# isinstance参数为对象和类
print(isinstance(Bar(), Foo))
# True
print(issubclass(Bar, Foo))
# True
print(issubclass(Foo, object))
# True
二、反射(hasattr和getattr和setattr和delattr)
1、反射在类中的使用
反射就是通过字符串来操作类或者对象的属性。反射本质就是在使用内置函数，其中反射有以下四个内置函数：
hasattr：判断一个方法是否存在与这个类中
getattr：根据字符串去获取obj对象里的对应的方法的内存地址，加"()"括号即可执行
setattr：通过setattr将外部的一个函数绑定到实例中
delattr：删除一个实例或者类中的方法
class People:
country = 'China'
def __init__(self, name):
self.name = name
def eat(self):
print('％s is eating' ％ self.name)
peo1 = People('nick')
print(hasattr(peo1, 'eat')) # peo1.eat
# True
print(getattr(peo1, 'eat')) # peo1.eat
# >
print(getattr(peo1, 'xxxxx', None))
# None
setattr(peo1, 'age', 18) # peo1.age=18
print(peo1.age)
# 18
print(peo1.__dict__)
# {'name': 'egon', 'age': 18}
delattr(peo1, 'name') # del peo1.name
print(peo1.__dict__)
# {'age': 18}
2、反射在模块中的使用
动态导入一个模块__import__，并且动态输入函数名然后执行相应功能。
注意：getattr,hasattr,setattr,delattr对模块的修改都在内存中进行，并不会影响文件中真实内容。
# dynamic.py
imp = input("请输入模块:")
commons = __import__(imp) # 等价于import imp
# commons = __import__(imp, fromlist=True) # 模块名可能不是在本级目录中存放着,改用这种方式就能导入成功
inp_func = input("请输入要执行的函数：")
f = getattr(commons, inp_func, None) # 作用:从导入模块中找到你需要调用的函数inp_func,然后返回一个该函数的引用.没有找到就烦会None
f() # 执行该函数
r = hasattr(commons, 'age') # 判断某个函数或者变量是否存在
print(r)
setattr(commons, 'age', 18) # 给commons模块增加一个全局变量age = 18，创建成功返回none
setattr(commons, 'age', lambda a: a + 1) # 给模块添加一个函数
delattr(commons, 'age') # 删除模块中某个变量或者函数
3、实例：基于反射机制模拟web框架路由
需求：比如我们输入<www.xxx.com/commons/f1> ，返回f1的结果。
# 动态导入模块，并执行其中函数
url = input("url: ")
target_host,target_module, target_func = url.split('/')
m = __import__('aaa.' + target_module, fromlist=True)
inp = url.split("/")[-1] # 分割url,并取出url最后一个字符串
if hasattr(m, inp): # 判断在commons模块中是否存在inp这个字符串
inp= getattr(m, inp) # 获取inp的引用
inp() # 执行
else:
print("404")
三、__getattr__、__setattr__和__delattr__和__getattribute__事件
__getattr__：只有在使用点调用属性且属性不存在的时候才会触发。比较有用
__delattr__：删除属性的时候会触发
__setattr__：添加/修改属性会触发它的执行
当你自己写__getattr__、__delattr__、__setattr__方法，系统会调用你写的方法，如果没写，系统调用默认
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)
f1 = Foo(10)
# ----> from setattr
print(f1.__dict__ ) # 因为你重写了__setattr__，凡是赋值操作都会触发它的运行，你啥都没写，就是根本没赋值。除非你直接操作属性字典，否则永远无法赋值
# {}
f1.z = 3
# ----> from setattr
print(f1.__dict__)
# {}
f1.__dict__['a'] = 3 # 我们可以直接修改属性字典，来完成添加/修改属性的操作（不会触发__setattr__）
del f1.a
# ----> from delattr
print(f1.__dict__)
# {}
__getattribute__
查找属性无论是否存在，都会执行。
class Foo:
def __init__(self, x):
self.x = x
def __getattribute__(self, item):
print('不管是否存在，我都会执行')
f1 = Foo(10)
f1.x
# 不管是否存在，我都会执行
f1.xxxxxx
# 不管是否存在，我都会执行
当__getattribute__与__getattr__同时存在，只会执行__getattrbute__，除非__getattribute__在执行过程中抛出异常AttributeError
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
# 不管是否存在,我都会执行
# 执行的是我
四、__setitem__和__getitem和__delitem__
__setitem__:中括号赋值时触发
__getitem__:中括号取值时触发
__delitem__：中括号删除时触发
__delattr__：.删除时触发
class Foo:
def __init__(self, name):
self.name = name
def __getitem__(self, item):
print('getitem执行', self.__dict__[item])
def __setitem__(self, key, value):
print('setitem执行')
self.__dict__[key] = value
def __delitem__(self, key):
print('del obj[key]时，delitem执行')
self.__dict__.pop(key)
def __delattr__(self, item):
print('del obj.key时，delattr执行')
self.__dict__.pop(item)
f1 = Foo('sb')
f1['age'] = 18
# setitem执行
f1['age1'] = 19
# setitem执行
f1['age']
# getitem执行 18
f1['name'] = 'tank'
# setitem执行
del f1.age1
# del obj.key时，delattr执行
del f1['age']
# del obj[key]时，delitem执行
print(f1.__dict__)
# {'name': 'tank'}
五、__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):
# 默认打印ymd的{0.year}:{0.month}:{0.day}格式
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-2016
六、__del__：析构方法
会在对象被删除之前自动触发
class People:
def __init__(self, name, age):
self.name = name
self.age = age
self.f = open('test.txt', 'w', encoding='utf-8')
def __del__(self):
print('run======>')
# 做回收系统资源相关的事情
self.f.close()
obj = People('egon', 18)
del obj # del obj会间接删除f的内存占用，但是还需要自定制__del__删除文件的系统占用
# run=-====>
七、__slots__
使用点来访问属性本质就是在访问类或者对象的__dict__属性字典(类的字典是共享的，而每个实例的是独立的)。
__slots__是一个类变量，变量值可以是列表，元祖，或者可迭代对象，也可以是一个字符串(意味着所有实例只有一个数据属性)
字典会占用大量内存，如果你有一个属性很少的类，但是有很多实例，为了节省内存可以使用__slots__取代实例的__dict__。
class Foo:
__slots__ = 'x'
f1 = Foo()
f1.x = 1
f1.y = 2 # 报错
print(f1.__slots__ ) # f1不再有__dict__
当你定义__slots__后，__slots__就会为实例使用一种更加紧凑的内部表示。使用__slots__后不能再给实例添加新的属性了，只能使用在__slots__中定义的那些属性名。
注意：__slots__的很多特性都依赖于普通的基于字典的实现。另外，定义了__slots__后的类不再支持一些普通类特性了，比如多继承。
大多数情况下，你应该只在那些经常被使用到的用作数据结构的类上定义__slots__比如在程序中需要创建某个类的几百万个实例对象 。
class Bar:
__slots__ = ['x', 'y']
n = Bar()
n.x, n.y = 1, 2
n.z = 3 # 报错
八、__doc__：返回类的注释信息
class Foo:
'我是描述信息'
pass
print(Foo.__doc__)
# 我是描述信息
该属性无法被继承
class Foo:
'我是描述信息'
pass
class Bar(Foo):
pass
print(Bar.__doc__) # 该属性无法继承给子类
# None
九、__call__：会在调用对象时自动触发。
构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()
class Foo:
def __init__(self):
print('__init__触发了')
def __call__(self, *args, **kwargs):
print('__call__触发了')
obj = Foo() # 执行 __init__
# __init__触发了
obj() # 执行 __call__
# __call__
十、__init__和__new__：类构造器
__new__方法的第一个参数是这个类，而其余的参数会在调用成功后全部传递给__init__方法初始化。
__new__方法（第一个执行）先于__init__方法执行：
class A:
pass
class B(A):
def __new__(cls):
print("__new__方法被执行")
return super().__new__(cls)
def __init__(self):
print("__init__方法被执行")
b = B()
# __new__方法被执行
# __init__方法被执行
绝大多数情况下，我们都不需要自己重写__new__方法，但在当继承一个不可变的类型（例如str类,int类等）时，它的特性就尤显重要了。我们举下面这个例子：
# 1、使用init的情况：
class CapStr1(str):
def __init__(self, string):
string = string.upper()
a = CapStr1("I love China!")
print(a)
# I love China! 无变化 ！！！！！！！
# 2、使用__new__的情况
class CapStr2(str):
def __new__(cls, string):
string = string.upper()
return super().__new__(cls, string)
a = CapStr2("I love China!")
print(a)
# I LOVE CHINA!
十一、__str__和__repr__
__str__：执行str函数或print函数触发
class Foo:
def __init__(self, name, age):
"""对象实例化的时候自动触发"""
self.name = name
self.age = age
def __str__(self):
print('打印的时候自动触发，但是其实不需要print即可打印')
return f'{self.name}:{self.age}' # 如果不返回字符串类型，则会报错
obj = Foo('nick', 18)
print(obj) # obj.__str__() # 打印的时候就是在打印返回值
# 打印的时候自动触发，但是其实不需要print即可打印
# nick:18
__repr__：执行repr函数或者交互式解释器触发
如果__str__没有被定义，那么就会使用__repr__来代替输出。
注意：这俩方法的返回值必须是字符串，否则抛出异常。
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)
s1 = School('oldboy1', '北京', '私立')
print('from repr: ', repr(s1))
# from repr: School(oldboy1,北京)
print('from str: ', str(s1))
# from str: (oldboy1,北京)
print(s1)
# (oldboy1,北京)
s1 # jupyter属于交互式
# School(oldboy1,北京)
十二、__module__和__class__
__module__ 表示当前操作的对象在那个模块
__class__表示当前操作的对象的类是什么
# lib/aa.py
class C:
def __init__(self):
self.name = 'SB'
# index.py
from lib.aa import C
obj = C()
print(obj.__module__) # 输出 lib.aa，即：输出模块
print(obj.__class__) # 输出 lib.aa.C，即：输出类
十三、实现文件上下文管理(__enter__和__exit__)
with语句，即上下文管理协议，为了让一个对象兼容with语句，必须在这个对象的类中声明__enter__和__exit__方法。
使用with语句的目的就是把代码块放入with中执行，with结束后，自动完成清理工作，无须手动干预
在需要管理一些资源比如文件，网络连接和锁的编程环境中，可以在__exit__中定制自动释放资源的机制，你无须再去关系这个问题，这将大有用处。
__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)
try:
with Open('a.txt') as f:
print('=====>执行代码块')
raise AttributeError('***着火啦，救火啊***')
except Exception as e:
print(e)
# 出现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) # ------------------------------->会执行
# 出现with语句，对象的__enter__被触发，有返回值则赋值给as声明的变量
# =====>执行代码块
# with中代码块执行完毕时执行我啊
# <class 'AttributeError'>
# ***着火啦，救火啊***
#
# 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
#
模拟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'>
十四、描述符(__get__和__set__和__delete__)
描述符是可以实现大部分python类特性中的底层魔法，包括@classmethod，@staticmethd，@property甚至是__slots__属性。
描述符是很多高级库和框架的重要工具之一，描述符通常是使用到装饰器或者元类的大型框架中的一个组件。
描述符本质就是一个新式类，在这个新式类中，至少实现了__get__()，__set__()，__delete__()中的一个，这也被称为描述符协议
__get__()：调用一个属性时，触发
__set__()：为一个属性赋值时，触发
__delete__()：采用del删除属性时，触发
描述符的作用是用来代理另外一个类的属性的。包含这三个方法的新式类称为描述符，由这个类产生的实例进行属性的调用/赋值/删除，并不会触发这三个方法
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 = 'nick'
f1.name
del f1.name
#无任何输出结果！！！
必须把描述符定义成这个类的类属性，不能定义到构造函数中。
class ST:
"""描述符Str"""
def __get__(self, instance, owner):
print('Str调用')
def __set__(self, instance, value):
print('Str设置...')
def __delete__(self, instance):
print('Str删除...')
class IN:
"""描述符Int"""
def __get__(self, instance, owner):
print('Int调用')
def __set__(self, instance, value):
print('Int设置...')
def __delete__(self, instance):
print('Int删除...')
class People:
name = ST()
age = IN()
def __init__(self, name, age): # name被ST类代理，age被IN类代理
self.name = name
self.age = age
p1 = People('alex', 18)
# Str设置...
# Int设置...
p1.name # Str调用
p1.name = 'nick' # Str设置...
del p1.name # Str删除...
p1.age # Int调用
p1.age = 18 # Int设置...
del p1.age # Int删除...
print(p1.__dict__) # {}
print(People.__dict__)
# {'__module__': '__main__', 'name': <__main__.ST object at 0x0000000002167490>, 'age': <__main__.IN object at 0x000000000234A700>, '__init__': , '__dict__': <attribute '__dict__' of 'People' objects>, '__weakref__': <attribute '__weakref__' of 'People' objects>, '__doc__': None}
print(type(p1) == People) # True
print(type(p1).__dict__ == People.__dict__) # True
1、使用描述符
众所周知，python是弱类型语言，即参数的赋值没有类型限制，下面我们通过描述符机制来实现类型限制功能。
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
try:
p1 = People(123, 18, 3333.3)
except Exception as e:
print(e)
# set---> <__main__.People object at 0x1082c7908> 123
# Expected <class 'str'>
try:
p1 = People('nick', '18', 3333.3)
except Exception as e:
print(e)
# set---> <__main__.People object at 0x1078dd438> nick
# set---> <__main__.People object at 0x1078dd438> 18
# Expected <class 'int'>
p1 = People('nick', 18, 3333.3)
# set---> <__main__.People object at 0x1081b3da0> nick
# set---> <__main__.People object at 0x1081b3da0> 18
# set---> <__main__.People object at 0x1081b3da0> 3333.3
2、类的装饰器:无参
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('nick', 18, 3333.3)
# 类的装饰器开始运行啦------>
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('nick', 18, 3333.3)
# 类的装饰器开始运行啦------> {'name': <class 'str'>, 'age': <class 'int'>, 'salary': <class 'float'>}
4、描述符与类装饰器结合使用
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__)
# 类的装饰器开始运行啦------> {'name': <class 'str'>, 'age': <class 'int'>, 'salary': <class 'float'>}
# {'__module__': '__main__', '__init__': , '__dict__': <attribute '__dict__' of 'People' objects>, '__weakref__': <attribute '__weakref__' of 'People' objects>, '__doc__': None, 'name': <__main__.Typed object at 0x000000000238F8B0>, 'age': <__main__.Typed object at 0x000000000238FF40>, 'salary': <__main__.Typed object at 0x000000000238FFA0>}
p1 = People('nick', 18, 3333.3)
# set---> <__main__.People object at 0x0000000001E07490> nick
# set---> <__main__.People object at 0x0000000001E07490> 18
# set---> <__main__.People object at 0x0000000001E07490> 3333.3
5、利用描述符原理自定制@property
实现延迟计算（本质就是把一个函数属性利用装饰器原理做成一个描述符：类的属性字典中函数名为key，value为描述符类产生的对象）
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, 2)
print(r1.area) # 先从自己的属性字典找,没有再去类的中找,然后出发了area的__get__方法
# 这是我们自己定制的静态属性，r1.area实际是要执行r1.area()
# --->
# 2
print(r1.area) # 先从自己的属性字典找,找到了,是上次计算的结果,这样就不用每执行一次都去计算
# 2
6、自定制@classmethod
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 = 'nick'
@ClassMethod # say_hi=ClassMethod(say_hi)
def say_hi(cls, msg):
print('你好啊,帅哥 ％s ％s' ％ (cls.name, msg))
People.say_hi('你是那偷心的贼')
p1 = People()
# 在这里可以加功能啊...
# 你好啊,帅哥 nick 你是那偷心的贼
p1.say_hi('你是那偷心的贼')
# 在这里可以加功能啊...
# 你好啊,帅哥 nick 你是那偷心的贼
7、自定制@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)
# 在这里可以加功能啊...
# ------> 1 2 3
p1 = People()
p1.say_hi(4, 5, 6)
# 在这里可以加功能啊...
# ------> 4 5 6
十五、元类(metaclass)
元类:负责产生该对象的类称之为元类，即元类可以简称为类的类
用class关键字创建一个类，用的默认的元类type，因此以前说不要用type作为类别判断
class People: # People=type(...)
country = 'China'
def __init__(self, name, age):
self.name = name
self.age = age
def eat(self):
print('％s is eating' ％ self.name)
print(type(People))
<class 'type'>
1、type实现
创建类的3个要素：类名，基类，类的名称空间
People = type(类名，基类，类的名称空间)
class_name = 'People' # 类名
class_bases = (object,) # 基类
class_dic = {} # 类的名称空间
class_body = """
country='China'
def __init__(self,name,age):
self.name=name
self.age=age
def eat(self):
print('％s is eating' ％self.name)
"""
exec(class_body, {}, class_dic, ) #执行class_body中的代码，然后把产生的名字丢入class_dic字典中
print(class_name) # People
print(class_bases) # (<class 'object'>,)
print(class_dic) # 类的名称空间
# {'country': 'China', '__init__': , 'eat': }
People1 = type(class_name, class_bases, class_dic)
print(People1) # <class '__main__.People'>
obj1 = People1(1, 2)
obj1.eat() # 1 is eating
2、自定义元类控制类
自定义元类控制类的产生过程，类的产生过程其实就是元类的调用过程。
分析用class自定义类的运行原理（而非元类的的运行原理）：
拿到一个字符串格式的类名class_name='People'
拿到一个类的基类们class_bases=(obejct,)
执行类体代码，拿到一个类的名称空间class_dic={...}
调用People=type(class_name,class_bases,class_dic)
class Mymeta(type): # 只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类
def __init__(self, class_name, class_bases, class_dic):
print('self:', self) # 现在是People
print('class_name:', class_name)
print('class_bases:', class_bases)
print('class_dic:', class_dic)
super(Mymeta, self).__init__(class_name, class_bases, class_dic) # 重用父类type的功能
class People(object, metaclass=Mymeta): # People=Mymeta(类名,基类们,类的名称空间)
country = 'China'
def __init__(self, name, age):
self.name = name
self.age = age
def eat(self):
print('％s is eating' ％ self.name)
# self: <class '__main__.People'>
# class_name: People
# class_bases: (<class 'object'>,)
# class_dic: {'__module__': '__main__', '__qualname__': 'People', 'country': 'China', '__init__': , 'eat': }
应用：我们可以控制类必须有文档。
class Mymeta(type): # 只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类
def __init__(self, class_name, class_bases, class_dic):
if class_dic.get('__doc__') is None or len(
class_dic.get('__doc__').strip()) == 0:
raise TypeError('类中必须有文档注释，并且文档注释不能为空')
if not class_name.istitle():
raise TypeError('类名首字母必须大写')
super(Mymeta, self).__init__(class_name, class_bases, class_dic) # 重用父类的功能
try:
class People(object, metaclass=Mymeta ): # People = Mymeta('People',(object,),{....})
# """这是People类"""
country = 'China'
def __init__(self, name, age):
self.name = name
self.age = age
def eat(self):
print('％s is eating' ％ self.name)
except Exception as e:
print(e)
# 类中必须有文档注释，并且文档注释不能为空
3、自定义元类控制类的实例化
类的调用，即类实例化就是元类的调用过程，可以通过元类Mymeta的__call__方法控制。
继承的查找顺序:子类->Class –>object–> Mymeta->type
class Mymeta(type):
def __call__(self, *args, **kwargs):
print(self) # self是People
print(args) # args = ('nick',)
print(kwargs) # kwargs = {'age':18}
# return 123
# 1. 先造出一个People的空对象，申请内存空间
# __new__方法接受的参数虽然也是和__init__一样，但__init__是在类实例创建之后调用，而 __new__方法正是创建这个类实例的方法。
obj = self.__new__(self) # 虽然和下面同样是People，但是People没有，找到的__new__是父类的
# 2. 为该对空对象初始化独有的属性
self.__init__(obj, *args, **kwargs)
# 3. 返回一个初始化好的对象
return obj
class People(object, metaclass=Mymeta): # People = Mymeta()，People()则会触发__call__
country = 'China'
def __init__(self, name, age):
self.name = name
self.age = age
def eat(self):
print('％s is eating' ％ self.name)
# 在调用Mymeta的__call__的时候，首先会找自己（如下函数）的，自己的没有才会找父类的
# def __new__(cls, *args, **kwargs):
# # print(cls) # cls是People
# # cls.__new__(cls) # 错误，无限死循环，自己找自己的，会无限递归
# obj = super(People, cls).__new__(cls) # 使用父类的，则是去父类中找__new__
# return obj
obj = People('nick', age=18)
# <class '__main__.People'>
# ('nick',)
# {'age': 18}
print(obj.__dict__)
# {'name': 'nick', 'age': 18}
4、练习：使用元类修改属性为隐藏属性
class Mymeta(type):
def __init__(self, class_name, class_bases, class_dic):
# 加上逻辑，控制类Foo的创建
super(Mymeta, self).__init__(class_name, class_bases, class_dic)
def __call__(self, *args, **kwargs):
# 加上逻辑，控制Foo的调用过程，即Foo对象的产生过程
obj = self.__new__(self)
self.__init__(obj, *args, **kwargs)
# 修改属性为隐藏属性
obj.__dict__ = {
'_％s__％s' ％ (self.__name__, k): v
for k, v in obj.__dict__.items()
}
return obj
class Foo(object, metaclass=Mymeta): # Foo = Mymeta(...)
def __init__(self, name, age, sex):
self.name = name
self.age = age
self.sex = sex
obj = Foo('nick', 18, 'male')
print(obj.age) # 'Foo' object has no attribute 'age'
print(obj.__dict__)
# {'_Foo__name': 'egon', '_Foo__age': 18, '_Foo__sex': 'male'}
5、利用元类实现单例模式
NAME = 'nick'
AGE = 18
class Mymeta(type):
def __init__(self,class_name,class_bases,class_dict):
super().__init__(class_name,class_bases,class_dict)
self.__instance = self(NAME,AGE)
def __call__(self,*args,**kwargs):
if len(args) == 0 and len(kwargs) == 0:
return self.__instance
obj = object.__new__(self)
self.__init__(obj,*args,**kwargs)
return obj
class People(metaclass=Mymeta):
def __init__(self,name,age):
self.name = name
self.age = age
peo1 = People()
peo2 = People()
来源：https://www.cnblogs.com/springsnow/p/11994440.html
0
投稿猜你喜欢
- 提起数据库，第一个想到的公司，一般都会是Oracle。该公司成立于1977年，最初是一家专门开发数据库的公司。Oracle在数据库领域一直处
1. 导入包我们这次的任务是随机生成一些离散的点，然后用直线（y = w *x + b ）去拟合首先看一下我们需要导入的包有torch 包为- 今天有人问起，晚上试着写出来，供参考； 以下代码兼容主流浏览器IE6、IE7、Firefox、Opera。从最简单的开始…………一
- 相信大家对于常见 CSS BUG 的处理已经相对比较熟悉，例如：IE6 Three Pixel Gap、IE5/6 Doubled Floa
- goto语句在Go编程语言中的goto语句提供无条件跳转从跳转到标记声明的功能。注意：使用goto语句是高度劝阻的在任何编程语言，因为它使得
- 我就废话不多说了，大家还是直接看代码吧~# 两个依赖包： sasl&thriftThe easier way I find to i
- 日一二三四五六'.split('') ['日','一','二&#
- 1、Python的内置高阶函数1.1 map()map()会根据提供的函数对指定序列做映射语法格式：map(function, iterab
- 编写 models.py 文件from django.db import models# Create your models here.c
- 前言最近重新再看python的基础知识，感觉自己还是对于这些知识很陌生，需要用的时候还是需要翻书查阅，还是先注重基础吧——我要重新把pyth
- 还记得以前在工作中，将爬来的其它网站的数据导到xml。但是会遇到一个问题：即网页会有ascII的控制字符。一开始以为是别人为了防止采集而加入
- date("yyyyMMdd",time()) date() 函数功能：用于格式化时间，返回一个字符串。&nb
- 本文实例讲述了PHP闭包定义与使用。分享给大家供大家参考，具体如下：<?phpfunction getClosure($i){ &nb
- 提起Apple，大部分人都会提起Apple的设计，除了Apple里拥有一批天才设计师外，还因为乔布斯对于设计有着苛刻的要求。所以在IT界，A
- 一、请求扩展1.before_request作用: 类比django中间件中的process_request，在请求到来执行路由函数之前先执
- 本文实例讲述了Django框架会话技术。分享给大家供大家参考，具体如下：会话技术1、Cookie客户端会话技术（数据存储在客户端）以key-
- 本文实例为大家分享了python使用正则筛选信用卡的具体代码，供大家参考，具体内容如下本文来源于两个简单的题目：1.判断一对单词是否是&qu
- 这几天不是很忙，就找了些拖动布局方面的资料看看，也学着写了个拖动布局的效果，没想到花了好多时间，七拼八凑，总算是把这个效果写出来了。哎！还是
- 我们在网页中使用CSS来设置网页、表格和字体大小，一般使用的是网络上较流行的9磅字：<STYLE type=TEXT/CSS
- 最近没事，写了个在项目经常要取城市或省份名的方法，所以改成了一个类．方便以后调用//****************************
