目录
魔法方法、元类、设计模式
面向对象的魔法方法
魔法方法
概念：类中定义的双下方法都称为魔法方法
特性：不需要人为调用，在特定的条件下会自动触发运行
eg:__init__创建空对象之后自动触发
双下方法的八种方法
| 序号 | 双下方法 | 触发时点 |
|---|---|---|
| 1 | init | 对象添加独有数据的时候自动触发 |
| 2 | str | 对象被执行打印操作的时候自动触发 |
| 3 | call | 对象加括号调用的时候自动触发 |
| 4 | getattr | 对象点不存在的名字时候自动触发 |
| 5 | getattribute | 对象点名字就会自动触发，有它的存在就不会执行上面的__getattr__方法 |
| 6 | setattr | 给对象添加或者修改数据的时候自动触发，对象.名字=值 |
| 7 | enter | 当对象被当作with上下文管理操作的开始自动触发，并且该方法返回什么，as后面的变量名就会接收到什么 |
| 8 | exit | with上下文管理语法运行完毕之后自动触发（子代码结束） |
代码解析：
class C(object):
def __init__(self,name):
"""类名加括号 给对象添加独有数据时自动触发"""
self.name = name
print('__init__')
def __str__(self):
"""
对象在被执行打印操作的时候自动触发 该方法返回什么打印的结果就是什么
并且该方法必须要返回一个字符串类型的数据
"""
return f'对象：{self.name}'
def __call__(self, *args, **kwargs):
""" 对象加括号调用的时候自动触发 该方法返回什么对象调用之后的返回值就是什么"""
print('__call__')
print(args,kwargs) # () {}
return 123
def __getattr__(self, item):
"""对象在查找无法使用的名字时自动触发 该方法返回什么 点不存在的名字就可以得到什么"""
# print('__getattr__') # __getattr__
#print(item) # age
return f'抱歉，您想要的名字{item}不存在'
def __getattribute__(self, item):
"""对象在查找名字的时候就会自动触发该方法 """
# return '我在这'
print(type(item)) # <class 'str'>......<class 'str'>
if hasattr(self,item):
return getattr(self,item)
return f'抱歉，{item}名字不存在'
""" maximum recursion depth exceeded while calling a Python object:
就会变成一个递归函数，一直返回,因为对象在查找名字的时候就会自动触发该方法 """
def __setattr__(self, key, value):
"""当对象执行 对象.名字=值 的时候就会自动触发"""
print('__setattr__')
print(key,value) # age 18 name kiki
pass
def __enter__(self):
"""当对象被当做with上下文管理操作的开始自动触发 并且该方法返回什么 as后面的变量名就会接收到什么
"""
return 123
def __exit__(self, exc_type, exc_val, exc_tb):
"""当对象参与的with上下文管理语法运行完毕之后自动触发(子代码结束)"""
# f.close()
obj1 = C('kimi')
# 1.对象添加独有数据的时候自动触发
# obj1 = C('kimi') # __init__
# print(obj1) # <__main__.C object at 0x0000020D77C23B50>
# 2.对象被执行打印操作的时候自动触发
# obj1 = C('kimi')
# print(obj1) # 对象：kimi
#3.对象加括号调用的时候自动触发
# res = obj1()
# print(res) # 123
# 4.对象点不存在的名字的时候自动触发
# print(obj1.age) # 抱歉，您想要的名字age不存在
#5.对象点名字就会自动触发 有它的存在就不会执行上面的__getattr__
# print(obj1.name) # 我在这
# print(obj1.age)
# 6.给对象添加或者修改数据的时候自动触发 对象.名字 = 值
# obj1.age = 18
# obj1.name ='kiki'
# 7.当对象被当做with上下文管理操作的开始自动触发 并且该方法返回什么 as后面的变量名就会接收到什么
with obj1 as f:
print(f) # 123
# with open() as f:
# pass
基于魔法方法的笔试题
1.补全下列代码使得运行不报错即可
考试题：
class Context:
pass
with Context() as f:
f.do_something()
补全后的代码：
class Context:
def do_something(self):
pass
def __enter__(self):
# return 123 # 但是123没有点得功能
return self
def __exit__(self, exc_type, exc_val, exc_tb):
pass
with Context() as f:
f.do_something()
"""
解题过程
1. # Context()产生对象
2.对象当对象被当做with上下文管理操作的开始自动触发__enter__,那么就得捆绑__exit__方法
3.return 123 # 但是123没有点得功能，所以只能是对象去点,
4.f.do_something()的形式，我们在类中添加一个方法do_something
"""
2.自定义字典类型并让字典能够通过句点符的方式操作键值对
eg:
d= {'name':'kiki','age':19}
print(d.name)
思考：
首先第一步想要通过拿字典里面的数据，我们一般是通过键取值的，而题目想要通过点的方式去实现，但是 这种方式是实现不了，name是字典的数据，而不是字典的属性，不能通过点的方式去实现。
其次，当只要基于字典做一些功能的拓展时候，我们首先想到的是面向对象的派生方法，先引入类的方法
class MyDict(dict):
def __setattr__(self, key, value):
self[key] =value # 字典空间存的数据值
def __getattr__(self, item):
return self.get(item) # 是直接从字典空间里面拿数据，而不是字典对象的名称空间里
obj = MyDict()
#1.通过对象去添加的数据，是在对象的名称空间里
# obj.name = 'kimi'
# print(obj) # {} 字典存储的数据
# print(obj.__dict__) # {'name': 'kimi'} 字典对象的名称空间
# 2.思考，对象.名字 = 值 会触发__setattr__
obj.name = 'kimi' # 会触发__setattr__
print(obj) # {'name': 'kimi'}
print(obj.__dict__) # {} 此时的字典名称空间没有数据
# 3.添加到字典空间里的数据值，但名称空间没有，所以对象点空间中没有的名字会触发__getattr__
obj.age = 18
obj.hobby ='read'
print(obj.name) # kimi
print(obj.age) # 18
print(obj.hobby) # read
print(type(obj)) # <class '__main__.MyDict'>
元类简介
推导步骤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'>
print(type(Student)) # <class 'type'> 说明type就是元类
"""推导步骤3:python中一切皆对象 我们好奇type查看类名显示的是什么"""
class Student:
pass
obj = Student()
print(type(obj))
print(type(Student))
class A:pass
class B:pass
print(type(A),type(B)) # <class 'type'> <class 'type'>
"""结论:我们定义的类其实都是由type类产生的>>>:元类(产生类的类)"""
创建类的两种方式
方式1：使用关键字class
# 方式1：使用关键字class
class Teacher:
school_name = 'kimi'
def func(self):pass
print(Teacher) # <class '__main__.Teacher'>
print(Teacher.__dict__) # {'__module__': '__main__', 'school_name': 'kimi', ....}
方式2：利用元类type
# 方式2：利用元类type,type（类名，类的父类，类的名称空间）
cls = type('Student',(object,),{'name':'kimi'})
print(cls) # <class '__main__.Student'>
print(cls.__dict__) # {'name': 'kimi', '__module__': '__main__',....'__doc__': None}
了解知识：名称空间的产生
1.手动写键值对
针对绑定方法不好定义
2.内置方法exec（自动识别python中的代码，自动执行）
能够运行字符串类型的代码并产生名称空间
3.要是添加函数的，在cls前面添加
desc = """
name = 'kimi'
def func(self):pass"""
exec补充知识：
#exec：三个参数
#参数一：包含一系列python代码的字符串
#参数二：全局作用域（字典形式），如果不指定，默认为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}
元类中产生类的方法表达式：
元类定制类的产生行为
推导
对象是由类名加括号产生的 __init__
类是由元类加括号产生的 __init__
""" 所有的类必须是首字母大写 否则无法产生"""
分析：要想干预一个类的产生，必须要考虑到元类了，元类产生类
步骤：
# 1.自定义元类：继承type的类也称之为元类
class MyMetaClass(type):
pass
#3.类名加括号会触发__init__方法
# def __init__(self): # 飘黄线是因为元类type本身就有__init__方法
# pass
def __init__(self, what, bases=None, dict=None):
#4. 通过查看源码知道了双下ini里面的参数，重新编写双下init方法
print('what',what) # what myclass
print('bases', bases) # bases () 父类
print('dict', dict) # dict {'__module__': '__main__', '__qualname__': 'myclass','desc': '元类有点绕'}
if not what.istitle():
raise TypeError('类名首字母要大写')
super().__init__(what,bases,dict)
# 2.指定类的元类:利用关键字metaclass指定类的元类
# class myclass(MyMetaClass): # 括号里写MyMetaClass说明myclass也是元类了
# pass
# 首字母小写
class myclass(metaclass=MyMetaClass):
desc = '元类有点绕'
print(myclass)
print(myclass.__dict__)
# 首字母大写
class Student(metaclass=MyMetaClass):
info = '首字母大写了'
print(Student)
print(Student.__dict__)
"""类中的__init__是拦截对象的创建行为，是控制对象的行为
而元类中写的__init__是拦截类的创建行为，是控制类的行为"""
元类定制对象的产生行为
推导
对象加括号会执行产生该对象类里面的 __call__
类加括号会执行产生该类的类里面的 __call__
"""给对象添加独有数据的时候，必须采用关键字参数传参"""
"""给对象添加独有数据的时候，必须采用关键字参数传参"""
class MyMetaClass(type):
def __call__(self, *args, **kwargs):
# 1.产生一个空对象（）
# 2.调用__init__给对象添加独有的数据
# 3. 返回创建好的对象
print('__call__')
# print(args) # ('kiki', 18, 'male')
# print(kwargs) # {}
if args:
raise TypeError('要求对象的独有数据必须按照关键字传参')
return super().__call__(*args,**kwargs)
class Student(metaclass=MyMetaClass):
def __init__(self,name,age,gender):
print('__init__')
self.name = name
self.age = age
self.gender = gender
# obj = Student('kiki',18,'male') # 类名加括号是触发元类里面的__call__,括号里的数据是先给args和kwargs
obj = Student(name='kiki',age=18,gender='male')
print(obj.__dict__) # {'name': 'kiki', 'age': 18, 'gender': 'male'}
魔法方法之双下new方法
__new__:在元类中的__call__方法中产生一个空对象，然后调用__init__给对象添加独有的数据，最后返回建好的对象
class MyMeClass(type):
def __call__(self, *args, **kwargs):
# 1.产生一个空对象（）
obj = self.__new__(self) # self就是类Student
# 2.调用__init__给对象添加独有的数据
self.__init__(obj,*args,**kwargs)
# 3. 返回创建好的对象
return obj
class Student(metaclass=MyMeClass):
def __init__(self,name):
self.name = name
obj = Student('kimi')
print(obj.name) # kimi
""" __new__可以产生空对象"""
设计模式简介及单例模式
1.设计模式
前人通过大量的验证创建出来解决一些问题的固定高效方法
2.IT行业
23种
创建型
结构型
行为型
ps:课下感兴趣可以简单看看
3.单例模式
类加括号无论执行多少次永远只会产生一个对象
目的:
当类中有很多非常强大的方法 我们在程序中很多地方都需要使用
如果不做单例 会产生很多无用的对象浪费存储空间
我们想着使用单例模式 整个程序就用一个对象