魔法方法 元类
目录
面向对象魔法方法
定义：在类中定义的，以双下划线开头和结尾的方法，都称为魔法方法（例如:__init__）
特性：不需要人为调用，在特定的条件下会自动触发运行
__init__
触发：在通过类产生对象时触发。
用于给对象创建独有的属性。
class C(object):
def __init__(self, name): # 在类产生对象时__init__默认运行
self.name = name
print('__init__')
obj = C('cloud') # __init__
# __init__的运行还不是最早的 __init__具体执行时间后文元类部分再讲
__str__
触发：对象被执行打印操作的时候自动触发
要求：该方法的return后面返回值，会被打印。必须要有一个返回值 而且返回值必须是个字符串类型。
作用：用于区分不同的对象
# 1.错误使用
class C(object):
def __str__(self):
return 123 # 必须有返回值且返回值是字符串
obj = C()
print(obj) # TypeError: __str__ returned non-string (type int)
# 2.正常使用
class C(object):
def __str__(self):
return '__str__'
obj = C()
print(obj) # __str__
# 3.递归调用问题
class C(object):
def __str__(self):
print(self) # 这里打印对象 会再次调用__str__
return '递归调用'
obj = C()
print(obj) # RecursionError: maximum recursion depth exceeded while calling a Python object
__call__
触发：当对象被加括号调用的时候
正常情况，对象是不能被调用的。给类加上这个魔术方法后，调用对象时就会执行产生对象的类中的__call__。
__call__方法有：*args 、**kwargs 形参用于接受从对象传入的参数。
class C(object):
def __call__(self):
print('from __call__')
return 'back'
obj = C()
res = obj() # from __call__
print(res) # back
__getattr__ __getattribute__
先讲__getattr__。
触发：对象在查找一个无法使用的名字时自动触发
class C(object):
def __init__(self, age):
self.age = age
def __getattr__(self, item):
print('__getattr__', item)
return f'名字不存在>>>{item}'
obj = C(18)
res = obj.cloud # __getattr__ cloud # 查找不存在的名字
print(res) # 名字不存在>>>cloud
getattribute是getattr的老大。
触发:只要对象点名字就会自动触发 有它的存在就不会执行上面的__getattr__。会导致你访问不了名字 而是执行这个方法 并获得这个方法的返回值。
class C(object):
def __init__(self, age):
self.age = age
def __getattribute__(self, item):
print('hello')
return 'back'
obj = C(18)
res = obj.age # hello # 会导致访问不了age
print(res) # back
res = obj.cloud # hello # 查找不存在的名字也会触发
print(res) # back
__setattr__
触发: 给对象添加或者修改数据的时候自动触发。
比如这个语法: 对象.名字 = 值
注意__init__内的也算 会导致这个方法自动触发
每次修改、新增值都会触发 会触发多次
class C(object):
def __init__(self, name, age):
self.name = name
self.age = age
def __setattr__(self, key, value):
print('__setattr__已执行：')
print(key, value)
obj = C('alice', 18)
obj.name = 'cloud'
'''
终端输出：
__setattr__已执行：
name alice
__setattr__已执行：
age 18
__setattr__已执行：
name cloud
'''
__enter__ __exit__
这两个要一起使用，也就是在类中要同时存在enter、exit方法，否则with上下文管理器就会报错。
enter触发：当对象被当做with上下文管理操作的开始自动触发 并且该方法返回什么 as后面的变量名就会接收到什么
# 1.
class C(object):
def __enter__(self):
print('__enter__已执行')
return self
def __exit__(self, exc_type, exc_val, exc_tb): # 不加exit会报错
pass
obj = C()
with obj as f1: # __enter__已执行
print(f1) # <__main__.C object at 0x0000028F128D6670>
# 2.
class C(object):
def __enter__(self):
print('__enter__已执行')
return self
def __exit__(self, exc_type, exc_val, exc_tb):
pass
obj = C()
with obj as f1, C() as f2: # enter被触发了两次 # C()是产生一个新的对象
print(f1)
print(f2)
'''输出结果：
__enter__已执行
__enter__已执行
<__main__.C object at 0x000001F492266670>
<__main__.C object at 0x000001F492266C40>
'''
exit触发:with上下文管理语法运行完毕之后自动触发(子代码结束)
class C(object):
def __enter__(self):
pass
def __exit__(self, exc_type, exc_val, exc_tb):
print('exit') # 会输出
obj = C()
with obj as f:
pass
# 子代码结束会输出: exit
__del__
触发：对象被执行删除（主动、被动）操作的时候自动触发
删除有主动删除和被动删除。比如程序运行结束 会将内存空间的数据释放 此时会将你产生的对象删除 此时__del__也会执行。
魔法方法笔试题
题目1：
补全下列代码使得运行不报错即可
class Context:
pass
with Context() as f:
f.do_something()
# 题解1
class Context:
def do_something(self):
pass
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
pass
with Context() as f:
f.do_something()
# 题解2
class Context:
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
pass
def __getattr__(self, item):
return self
def __call__(self, *args, **kwargs):
print('你好')
with Context() as f: # 对象参与with上下文管理 开始触发__enter__ 结束也必须有__exit__
f.do_something()
题目2：
自定义字典类型并让字典能够通过句点符的方式操作键值对
# 自定义字典类型
class Mydict(dict):
def __setattr__(self, key, value): # 修改值的时候触发
self[key] = value
def __getattr__(self, item): # 如果名称空间名字 和字典中的名字重名呢？
return self.get(item) # 那么__getattr__是否就不会触发
obj = Mydict()
obj.name = 'jason'
obj.age = 18
print(obj) # {'name': 'jason', 'age': 18} # 成功添加
print(obj.name) # jason # 成功取值
# 补充
# 自定义字典类型
class Mydict(dict):
def __setattr__(self, key, value): # 修改值的时候触发
self[key] = value
def __getattr__(self, item): # 如果名称空间名字 和字典中的名字重名呢？
return self.get(item) # 那么__getattr__是否就不会触发
def name(self):
print('hhh')
obj = Mydict()
obj.name = 'jason'
obj.age = 18
print(obj) # {'name': 'jason', 'age': 18}
print(obj.name) # <bound method Mydict.name of {'name': 'jason', 'age': 18}> # 由于类中有name这个名字无法调用__getatter__
obj.name() # hhh
元类
推导流程
type类是产生类的类，也称为元类。
"""推导步骤1:如何查看数据的数据类型"""
s1 = 'hello world' # str()
l1 = [11, 22, 33, 44] # list()
d1 = {'name': 'jason', 'pwd': 123} # dict()
t1 = (11, 22, 33, 44) # tuple()
print(type(s1)) # <class 'str'>
print(type(l1)) # <class 'list'>
print(type(d1)) # <class 'dict'>
print(type(t1)) # <class 'tuple'>
"""推导步骤2:其实type方法是用来查看产生对象的类名"""
class Student:
pass
obj = Student()
print(type(obj)) # <class '__main__.Student'>
"""推导步骤3:python中一切皆对象 我们好奇type查看类名显示的是什么"""
class Student:
pass
obj = Student()
print(type(obj)) # <class '__main__.Student'>
print(type(Student)) # <class 'type'>
class A:pass
class B:pass
print(type(A), type(B)) # <class 'type'> <class 'type'>
"""结论:我们定义的类其实都是由type类产生的>>>:元类(产生类的类)"""
创建类的两种方式
class关键字
使用元类type
# 方式2:利用元类type type(类名,类的父类,类的名称空间)
cls = type('Student', (object,), {'name':'cloud'})
print(cls) # <class '__main__.Student'>
print(cls.__dict__)
obj = cls()
print(obj) # <__main__.Student object at 0x00000227E4EB59D0>
print(obj.name) # cloud
类名称空间的产生（使用type创建类）
- 手写键值对
可以发现使用type方法创建类时，第三个参数表示类的名称空间。
我们是通过手写键值对的方式，给类添加属性的，然而如何添加函数呢？
提前写个函数 然后将函数名写入字典
def func(self): # 会将对象传进来
print(self.name)
cls = type('Student', (object,), {'name':'cloud','func':func})
obj = cls()
print(func) # <function func at 0x00000119903F7280>
print(obj.func) # <bound method func of <__main__.Student object at 0x0000011990516670>> # 地址不同
obj.func() # cloud # 是一个神奇的函数！
- 内置方法exec
能够运行字符串类型的代码并产生名称空间
略了，有空来填坑= =
元类定制类的产生行为
干预类的生产！类的制作过程是什么？是流水线生产吗！首先必须要干预元类type 继承非元类的普通类无法干预类的产生行为 然而我们又无法改type源代码 所以要自己定义一个元类 然后使用自己的 元类产生类。
ps：继承了type的类也称之为元类。
metaclass参数指定元类
"""
推导
对象是由类名加括号产生的 ——>Student() __init__
类是由元类加括号产生的 ——>type(name, bases, dict) __init__
元类产生类的时候会不会也有__init__这种默认执行的方法?
元类中__init__产生类也要传东西！已知要传三个参数：type(类名，类的父类，类的名称空间)
"""
# 继承并重写元类的__init
class MyMetaClass(type): # 1.自定义元类:继承type的类也称之为元类
def __init__(cls, what, bases=None, dict=None): # 2.去看type源码把这一行copy下来
print(what) # 类名
print(bases) # 继承的父类
print(dict) # 名称空间
super().__init__(what, bases, dict) # 3.继续执行type类中的方法
class Student(object,metaclass=MyMetaClass): # 4.metaclass这个参数默认指定type这个元类 我们将其设置为自己创的元类
name = 'cloud'
def say(self):
print('hello')
输出结果：
限制类的产生：
"""需求：所有的类必须首字母大写 否则无法产生"""
class MyMetaClass(type):
def __init__(cls, what, bases=None, dict=None):
if not what.istitle():
raise TypeError('类的首字母必须大写！') # 看这里= =
super().__init__(what, bases, dict)
class student(object,metaclass=MyMetaClass): # TypeError: 类的首字母必须大写！
pass
class Teacher(object,metaclass=MyMetaClass):
pass
print(Teacher) # <class '__main__.Teacher'>
# 注意：继承于Student的子类，在类的产生过程中，也会受到元类的限制！
class little_student(Student):
pass
'''
这里会报错：
TypeError: 类的首字母必须大写！
'''
元类定制对象的产生行为
"""
推导
对象加括号会执行产生该对象类里面的 __call__
类加括号会执行产生该类的类里面的 __call__
"""
# 继承并重写元类中的__call__
class MyMetaClass(type):
def __call__(self, *args, **kwargs):
print(args) # 1.查看__call__中参数
print(kwargs)
super().__call__(*args, **kwargs) # 2.看一眼之后重新执行元类中的__call__
class Student(metaclass=MyMetaClass):
def __init__(self, name, age, gender):
self.name = name
self.age = age
self.gender = gender
obj = Student('cloud', 18, gender= 'male') # ('cloud', 18)
# {'gender': 'male'}
# 3.可以得知创建对象时 会将数据传入元类的__call__方法
__call__
元类双下call做了三件事：
1.负责产生空对象 (骨架)
2.调用子类的双下init 给对象添加独有的数据(血肉)
3.返回创建好的对象
"""给对象添加独有数据的时候 必须采用关键字参数传参"""
class MyMetaClass(type):
def __call__(self, *args, **kwargs):
# 1.产生一个空对象(骨架)
# 2.调用__init__给对象添加独有的数据(血肉)
# 3.返回创建好的对象
if args:
raise TypeError("必须按照关键字参数传参")
return super().__call__(*args, **kwargs)
class Student(object,metaclass=MyMetaClass):
def __init__(self, name, age):
self.name = name
self.age = age
# obj = Student('cloud', 18) # TypeError: 必须按照关键字参数传参
obj = Student(name= 'cloud', age= 18)
print(obj.name) # {'name': 'cloud', 'age': 18}
__new__
__new__方法可以产生一个空对象。在元类中的__call__方法会使用到__new__
例子：
class MyMetaClass(type):
def __call__(cls, *args, **kwargs):
# 1.使用__new__产生一个空对象(骨架)
obj = cls.__new__(cls)
# 2.调用Student.__init__给对象添加独有的数据(血肉)
cls.__init__(obj, *args, **kwargs)
# 3.返回创建好的对象
return True, obj
class Student(metaclass=MyMetaClass):
def __init__(self, name):
self.name = name
msg, obj= Student('cloud') # 产生对象时 触发元类__call__ 将student类和数据'cloud'传入元类
print(msg) # True
print(obj.__dict__) # {'name': 'cloud'}
"""
__new__可以产生空对象
"""
总结
- 元类的__call__才是真正产生对象的方法，子类__init__只是用于设置对象属性的一个接口。
- __init__在元类__call__的调用下运行。
- 元类__call__方法内的__new__用于产生一个空对象。
class MyMetaClass(type):
def __call__(cls, *args, **kwargs):
# 1.使用__new__产生一个空对象(骨架)
obj = cls.__new__(cls)
# 2.调用Student.__init__给对象添加独有的数据(血肉)
cls.__init__(obj, *args, **kwargs)
# 3.返回创建好的对象
return True, obj
class Student(metaclass=MyMetaClass):
def __init__(self, name):
self.name = name
msg,obj= Student('cloud')
print(msg) # True
print(obj.__dict__) # {'name': 'cloud'}
obj.__init__('alice') # 调用__init__
print(obj.__dict__) # {'name': 'alice'}
设计模式简介及单例模式
1.设计模式
前人通过大量的验证创建出来解决一些问题的固定高效方法
2.IT行业
23种
创建型
结构型
行为型
创建型模式（5种）：工厂方法模式、抽象工厂模式、创建者模式、原型模式、单例模式
结构型模式（7种）：适配器模式、桥模式、组合模式、装饰模式、外观模式、享元模式、代理模式
行为型模式（11种）：解释器模式、责任链模式、命令模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、访问者模式、模板方法模式
3.单例模式
类加括号无论执行多少次永远只会产生一个对象
目的:
当类中有很多非常强大的方法 我们在程序中很多地方都需要使用
如果不做单例 会产生很多无用的对象浪费存储空间
我们想着使用单例模式 整个程序就用一个对象
单例模式实现
'''
class_dict = {
'A' : '<__main__.A object at 0x0000019ADE6C59D0>',
'B' : '<__main__.B object at 0x0000019ADE69B0A0>',
'''
class_dict = {} # 将类产生的对象存入字典 每次都用这个字典里的对象
class MyMetaClass(type):
now_name = None
def __init__(cls, what, bases=None, dict=None):
MyMetaClass.now_name = what # 1.获取当前类名
def __call__(cls, *args, **kwargs):
if MyMetaClass.now_name not in class_dict: # 2.如果字典中没有这个类
obj = cls.__new__(cls) # 3.创建对象
cls.__init__(obj, *args, **kwargs)
class_dict[MyMetaClass.now_name] = obj # 4.新增键值对 >> 类名:对象
return obj
else: # 5.如果字典中有这个类名，直接取对象即可，就不产生新对象了。
obj = class_dict.get(MyMetaClass.now_name)
return obj
class A(metaclass=MyMetaClass):
def __init__(self, name, age):
self.name = name
self.age = age
obj = A('cloud',12)
print(obj) # <__main__.A object at 0x0000019ADE6C59D0>
obj = A('tony',19)
print(obj) # <__main__.A object at 0x0000019ADE6C59D0>
class B(metaclass=MyMetaClass):
def __init__(self, name, age):
self.name = name
self.age = age
obj2 = B('tony',10)
print(obj2) # <__main__.B object at 0x0000019ADE69B0A0>
obj2 = B('could',18)
print(obj2) # <__main__.B object at 0x0000019ADE69B0A0>
