面向对象：面向对象的魔法方法、魔法方法笔试题、元类、设计模式简介
目录
一、面向对象的魔法方法
魔法方法：是指方法名以两个下划线开头并以两个下划线结尾的方法
特点：调用时不需要人为调用，只要在特定条件下就会自动触发运行。
例如我们最开始学习类的时候使用到的双下init方法，就是在创建空对象之后自动触发给对象添加独有的数据。
1.__init__
类名加括号 给对象添加独有数据时自动触发
class C(object):
def __init__(self, name):
self.name = name
2.___str__
对象在被执行打印操作的时候自动触发，该方法返回什么打印的结果就是什么
并且该方法必须要返回一个字符串类型的数据
def __str__(self):
return f'对象:{self.name}'
3.__call__
对象加括号调用的时候自动触发 该方法返回什么对象调用之后的返回值就是什么
def __call__(self, *args, **kwargs):
print('__call__')
print(args, kwargs)
return 123
在使用双下call的时候要注意，返回值不能是self，会引起递归，从而出现报错的情况
4.__getattr__
对象在查找无法使用的名字（没有的名字）时自动触发，该方法的返回值是什么，点不存在的名字就可以得到什么
def __getattr__(self, item):
# print('__getattr__')
# print(item)
return f'抱歉 您索要的名字{item}压根不存在'
5.__getattribute__
对象在查找名字的时候就会自动触发该方法，有它的存在就不会执行上面的__getattr__
def __getattribute__(self, item):
# print('__getattribute__')
return '哈哈哈'
# print(type(item))
# if hasattr(self, item):
# return getattr(self, item)
# return f'抱歉 {item}名字不存在'
6.__setattr__
当对象执行 对象.名字=值 的时候就会自动触发
给对象添加或者修改数据的时候自动触发 对象.名字 = 值
def __setattr__(self, key, value):
# print('__setattr__')
# print(key, value)
pass
7.__enter__
当对象被当做with上下文管理操作的开始自动触发，并且该方法返回什么 as后面的变量名就会接收到什么（就我们平时写的f那里的名称）
def __enter__(self):
return 123
8.__exit__
当对象参与with上下文管理语法运行完毕之后自动触发(子代码结束)
def __exit__(self, exc_type, exc_val, exc_tb):
f.close()
我们在学习文件操作的时候不是说了，两种操作方式，with方式打开文件不需要使用f.close()关闭文件。
这里就相当于在结束的时候出发了双下exit然后内部执行了f.close()。
二、魔法方法笔试题
1.补全下列代码使得运行不报错即可
class Context:
pass
with Context() as f:
f.do_something()
答案如下：
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 MyDict(dict):
def __setattr__(self, key, value):
self[key] = value
def __getattr__(self, item):
return self.get(item)
obj = MyDict()
obj.name = 'jason'
obj.pwd = 18
obj.hobby = 'read'
# print(obj)
print(obj.name)
print(obj.pwd)
print(obj.hobby)
# print(obj)
# print(obj) # 字典存储的数据 {}
# print(obj.__dict__) # 字典对象名称空间 {'name': 'jason'}
print(type(obj))
三、元类
1、元类简介
1.元类定义推导
"""推导步骤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'>
我们使用type查看数据类型的时候发现这些类型的前面都有一个class，也就是说明所有的这些数据类型其实都是一个个不同的类。
"""推导步骤2:其实type方法是用来查看产生对象的类名"""
class Student:
pass
obj = Student()
print(type(obj)) # <class '__main__.Student'>
通过上面的尝试，我们发现使用type可以查看对象的产生者，也就是产生对象的类的名字
"""推导步骤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))
这里我们发现，产生type的类还是type，因此我们把产生类的类称作元类
"""结论:我们定义的类其实都是由type类产生的>>>:元类(产生类的类)"""
2.元类介绍
什么是元类呢？一切源自于一句话：python中一切皆为对象。
通过上面的推导流程，我们可以结合之前所学的知识点发现，几乎我们所有的对象都是实例化（调用类产生对象）得到的。
2、创建元类的两种方式
方式一:
使用关键字class
class Teacher:
school_name = '老女儿'
def func1(self):pass
print(Teacher)
print(Teacher.__dict__)
方式二:
利用元类type type(类名,类的父类,类的名称空间)
cls = type('Student', (object,), {'name':'jason'})
print(cls)
print(cls.__dict__)
"""
了解知识:名称空间的产生
1.手动写键值对
缺点：针对绑定方法不好定义
2.内置方法exec
能够运行字符串类型的代码并产生名称空间
"""
3、元类定制类的产生行为
"""
推导
对象是由类名加括号产生的 __init__
类是由元类加括号产生的 __init__
"""
这里我们自定义一个元类，来实现下面的目的：
"""所有的类必须首字母大写 否则无法产生"""
# 1.自定义元类:继承type的类也称之为元类
class MyMetaClass(type):
def __init__(self, what, bases=None, dict=None):
# print('what', what)
# print('bases', bases)
# print('dict', dict)
if not what.istitle():
raise TypeError('你是不是python程序员 懂不懂规矩 类名首字母应该大写啊!!!')
super().__init__(what, bases, dict)
# 2.指定类的元类:利用关键字metaclass指定类的元类
class myclass(metaclass=MyMetaClass):
desc = '元类其实很有趣 就是有点绕'
class Student(metaclass=MyMetaClass):
info = '我是学生 我很听话'
print(Student)
print(Student.__dict__)
代码运行流程简述：
1、类创建对象时，其实是先调用元类中的双下init产生一个空的对象。我们在双下init这里使用派生的方式，写上判断条件，如果生成独有数据值的参数不是关键字参数，那么直接主动报错，否则就直接调用type那边的双下init直接达成创建空类（通过一切皆对象来理解这里为什么是类）的操作。
4、元类定制对象的产生行为
"""
推导
对象加括号会执行产生该对象类里面的 __call__
类加括号会执行产生该类的类里面的 __call__
"""
这里我们自定义一个元类，来实现下面的目的：
"""给对象添加独有数据的时候 必须采用关键字参数传参"""
通过上面定制类的操作，我们得知产生对象的流程如下：
1.产生一个空对象(骨架)
2.调用__init__给对象添加独有的数据(血肉)
3.返回创建好的对象
因此这个判断参数是否为关键字的操作还是放在自定义元类中
class MyMetaClass(type):
def __call__(self, *args, **kwargs):
# print(args) # ('jason', 18, 'male')
# print(kwargs) # {}
if args:
raise TypeError("你怎么回事 Jason要求对象的独有数据必须按照关键字参数传参 我看你是不想干了！！！")
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('jason', 18, 'male')
obj = Student(name='jason',age= 18,gender= 'male')
print(obj.__dict__)
代码运行流程简述：
1、类创建对象时，其实是先调用元类中的双下call产生一个空的对象。我们在双下call这里使用派生的方式，写上判断条件，如果生成独有数据值的参数不是关键字参数，那么直接主动报错，否则就直接调用type那边的双下call直接达成创建空对象的操作。
2、我们创建出一个空的对象后，才是到类代码中的双下init这里执行添加参数的操作
3、接着把创建好的对象返回出去
5、魔法方法之双下new
上面我们说了类在创建对象的时候是使用对应的元类中的双下call来创建一个空的对象的，然后才到双下init中进行添加独有数据值的操作，这里我们要引出一个魔法方法——双下new，他就是产生空对象的代码。
ps：小知识点，双下new来自object中
class MyMetaClass(type):
def __call__(self, *args, **kwargs):
# 1.产生一个空对象(骨架)
obj = self.__new__(self)
# 2.调用__init__给对象添加独有的数据(血肉)
self.__init__(obj,*args, **kwargs)
# 3.返回创建好的对象
return obj
class Student(metaclass=MyMetaClass):
def __init__(self, name):
self.name = name
obj = Student('jason')
print(obj.name)
"""
__new__可以产生空对象
"""
代码运行流程简述：
1、类创建对象时，其实是先调用元类中的双下call产生一个空的对象。产生空对象用的是双下new方法
2、我们创建出一个空的对象后，调用双下init进行添加数据值的操作
3、接着把创建好的对象返回出去
四、设计模式简介
1.设计模式
对软件设计中普遍存在（反复出现）的各种问题，所提出的解决方案。每一个设计模式都系统地命名、解释和评价了面向对象系统中一个重要的和重复出现的设计。
设计模式分成三大类，总共有23种
创建型模式（5种）：工厂方法模式、抽象工厂模式、创建者模式、原型模式、单例模式
结构型模式（7种）：适配器模式、桥模式、组合模式、装饰模式、外观模式、享元模式、代理模式
行为型模式（11种）：解释器模式、责任链模式、命令模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、访问者模式、模板方法模式
2.单例模式
类加括号无论执行多少次永远只会产生一个对象
目的:
当类中有很多非常强大的方法 我们在程序中很多地方都需要使用
如果不做单例 会产生很多无用的对象浪费存储空间
我们想着使用单例模式 整个程序就用一个对象
from abc import abstractmethod, ABCMeta
class Singleton:
def __new__(cls, *args, **kwargs):
if not hasattr(cls, "_instance"):
cls._instance = super(Singleton, cls).__new__(cls)
return cls._instance
class MyClass(Singleton):
def __init__(self, a):
self.a = a
a = MyClass(10)
b = MyClass(20)
print(a.a)
print(b.a)
print(id(a), id(b))
五、作业
1.尝试使用多种方式实现单例模式
# 1.尝试使用多种方式实现单例模式
# 类加括号无论执行多少次永远只会产生一个对象
class Singleton_:
def __new__(self, *args, **kwargs):
if not hasattr(self, '_instance'):
self._instance = super(Singleton_, self).__new__(self)
return self._instance
# 我们通过今天的学习得知双下new是产生对象的方法，因此我们在这里进行派生操作，
# 用hasatter检测当前类是是否已经有创建过对象，如果没有就新建一个（使用super拿元类的双下new直接创建），如果有就返回有的那个对象
a = Singleton_()
b = Singleton_()
print(a)
print(b)
2.预习明日内容
选课系统
角色:学校、学员、课程、讲师
要求:1. 创建北京、上海 2 所学校
2. 创建linux , python , go 3个课程 ， linux\py 在北京开， go 在上海开
3. 课程包含，周期，价格，通过学校创建课程
4. 通过学校创建班级， 班级关联课程、讲师5. 创建学员时，选择学校，关联班级
5. 创建讲师角色时要关联学校，
6. 提供三个角色接口
6.1 学员视图， 可以注册， 交学费， 选择班级，
6.2 讲师视图， 讲师可管理自己的班级， 上课时选择班级， 查看班级学员列表 ， 修改所管理的学员的成绩
6.3 管理视图，创建讲师， 创建班级，创建课程
7. 上面的操作产生的数据都通过pickle序列化保存到文件里
