python第三十课---面向对象的魔法方法，元类相关知识

昨日内容回顾

• 派生方法实战案例

  1.继承某个类
  2.重写被继承类里面的某个方法
  3.在方法内添加一些额外的操作
  4.最后利用super重新调用被继承类里面的方法
  """
  super:子类调用父类的方法		一定要注意与对象查找名字的顺序区分开
  以super所在的类为起始类或子类，去调该子类的父类
  """
  

• 三大特性之封装

  封装:将数据与功能封装到一起
  隐藏:在类的定义阶段名字前面使用两个下划线开头表示隐藏
  	class C1:
          __name = 'jason'
          def __func(self):pass
  	'''也有可能会出现单个下划线开头的变量名也表示隐藏的意思或者没有'''
  伪装:在类中定义的方法在调用时，伪装成数据不用加括号
  	class C2:
          @property
          def BMI(self):pass
  

• 三大特性之多态

  一种事物的多种形态
  1.多个类如果有相似之处, 那么里面针对相似的功能应该起相同的名字!!!
  	class Memory:
          def read(self):pass
    	class Disk:
          def read(self):pass
  2.强制规定子类编写父类中相同的方法(不是为了派生)
  abc模块  主要是面向对象多态性这一块体现出来的，目的是强制限制继承的子类，必须要有父类的一些方法名。但是我们更多时候是靠自己自觉。
  3.鸭子类型  看上去像鸭子,走路像鸭子,叫声像鸭子,那就是鸭子。为了补充多态性的，多个事物都看上去像一些东西，那么你们就应该是一样的，所以你们就应该有相同的方法，
  -------------------------------------------------
  4.实际案例，信息提示系统
    class QQ:
        def send(self):pass
    class Wechat:pass
        def send(self):pass
    class Email:pass
        def send(self):pass
   class Msg:pass
        def send(self):pass
  

• 面向对象之反射

  利用字符串操作对象的数据或方法
  1.hasattr()
  2.getattr()
  
  3.setattr()
  4.delattr()
  ps:反射从另外一个角度看，能够将面向对象的代码与用户交互起来
  

类名加括号生成对象这个过程就叫实例化

今日内容概要

• 面向对象的魔法方法
• 基于魔法方法的笔试题
• 元类简介
• 创建类的两种方式
• 元类定制类的产生行为
• 元类定制对象的产生行为
• 魔法方法之双下new方法
• 设计模式简介及单例模式
• 内置模块之pickle模块

今日内容详细

面向对象的魔法方法

魔法方法:类中定义的双下方法都称为魔法方法,这些方法都是父类object里面有的方法，相当于重写了它们的方法。

不需要人为调用，在特定的条件下回自动触发运行

例如:__init__创建空对象之后自动触发给对象添加独有的数据

1.__init__
	对象添加独有数据的时候自动触发！！！

2.___str__
	对象被执行打印操作的时候自动触发！！！
	该方法返回的是什么，打印的就是什么，返回值必须要是字符串类型数据
	注意在return的时候返回值里面不能包含对象本身，因为一旦打印对象，
	会执行___str__方法，当方法里面return 返回值里面包含对象本身的时候，
	打印返回值的时候就又会打印对象，打印对象就又会执行___str__方法，
	这样就出现递归调用了,所以在__str__方法里面不能返回对象本身，
	一返回对象本身就会打印对引对象本身，打印对象本身就又触发__str__方法，就会出现递归调用了！！！print（obj）,触发__str__ , 运行到 return f'{self}说：哈哈哈'
就变成了print(f'{self}说：哈哈哈'),
这个时候就可以将print(f'{self}说：哈哈哈')
看成是print（self，end''）加上print（f'说：哈哈哈'）两个部分了。

.

.
.
.
.
.
.
.
.
.

3.__call__(self, *args, **kwargs):
	对象加括号调用的时候自动触发！！！
	并且该方法返回什么，那么对象调用之后的返回值就是什么！！！
*接收多余的关键字参数组织成元组给args，**接收多余关键字参数组织成字典给kwargs
甚至可以把__call__ 当作对象加括号后，真正执行的家伙

.

.

.
.
.
.
.

4.__getattr__(self, item)
	对象点不存在的名字的时候自动触发！！！
	形参item就是接收的想找的不存在的名字。
该方法也可以有返回值，用print（对象点不存在的名字） 就会打印返回值了


5.__getattribute__
	对象点名字就会自动触发，有它的存在就不会执行上面的__getattr__
正常情况下，不要在类里面写这个方法，因为对象名称空间里面有的名字也没法正常拿了，都会直接触发该方法了，所以这个方法不怎么好用

.

.
.
.
.
.
.
.
.
.
.
.

6.__setattr__(self, key, value)
	给对象添加或者修改数据的时候自动触发  对象.名字 = 值

# 有一个注意事项，就是我们通过对象点名字的时候，虽然名字是变量名
# 但是触发了类里面__setattr__方法后，会将变量名转成字符串，也就是说，key接收的是字符串了

.

.

.
.
正常通过中括号，往字典里面放键值的时候，键是要用字符串的
我们看到在对象点属性=值，触发双下setattr的时候，key接收的就已经是字符串了！！！

.
.
.
.
.
.
.
.

7.__enter__
	当对象被当做with上下文管理操作的开始,自动触发
	并且该方法返回什么 as后面的变量名就会接收到什么


8.__exit__
	with上下文管理语法运行完毕之后自动触发(子代码结束)

.
.
.
.
.
.
.
.
.

魔法方法笔试题 重要！！！

1.补全下列代码使得运行不报错即可

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()

解题思路：首先看到Context() 知道生成了一个对象，当对象参与with上下文管理的时候，会自动触发__enter__魔法方法， exit 一般情况下又是和__enter__方法联合起来用的，所以先把这两个自定义方法写出来。
这时候再看 f.do_something()代码，f是触发__enter__方法后，接收到的返回值。
考虑到对象点名字比较好操作，所以f最好就是一个对象，所以__enter__方法里面让return返回对象本身，这样f就等于对象了，这样对象点do_something()，我们只需要在类体代码里面再定义一个do_something的函数，这样整体代码就不会报错了。

.
.
.
.
.
.
.
.

2.自定义字典类型并让字典能够通过句点符的方式操作键值对 面试题--重要！！！

用面向对象的方法，弄出一个字典，并且这个字典还能通过点的方式来进行取值！！所以肯定是基于原来字典的功能做一个派生操作！！

python 自带的字典类型是不支持通过字典点的方式来进行取值的！！
自定义字典类型并让字典能够通过句点符的方式操作键值对
class MyDict(dict):   # 先自定义一个类继承字典，这样就拥有了dict类里面所有的东西了
    pass
obj = MyDict()        # 生成的就是一个空字典
obj.name = 'jason'
print(obj)            # 字典存储的数据  {}
print(obj.__dict__)   # 字典对象名称空间  {'name': 'jason'}
-----------------------------------------------

.
.
.
.

obj.name = 'jason'   现在不是想让我们用这个语法操作名称空间了，
而是想让该语法来操作字典里面的数据了！！！怎么办？？？

要用到魔法方法了，当我们在用对象.名字 = 值  的时候会自动触发__setattr__魔法方法，
前提是类里有该方法。

__setattr__(self, key, value)
该语法里面，self就是对象obj，key接收的就是name，value接收的就是'jason'

------------------------------------------------


class MyDict(dict):
    def __setattr__(self, key, value):
        self[key] = value    # 在这给字典添加键值对
obj = MyDict()
obj.name = 'jason'
obj.pwd = 18
obj.hobby = 'read'
print(obj)
print(obj.__dict__)
# 这个时候名称空间里面就没有了，因为这个__setattr__方法被我们重写了！！！
# 这个方法如果不写，还是正常往名称空间里面加，被重写后就往字典里面塞了！！！
# 字典存储的数据值，和字典名称空间是两个独立的东西，注意区分！！！

.
现在通过对象名点的方式实现了往字典加值了。
怎么通过对象名点的方式，从字典里面取值了？？？
注意现在，通过对象点的方式，是拿的名称空间里面的名字，此时对象名称空间里面是没有名字的
所以通过obj.name是拿不到name对应的值的！！！

还是要用到魔法方法，对象点一个不存在的名字的时候，如果类里面有__getattr__方法的时候，
就会自动触发该方法。


__getattr__(self, item)
该语法里面 item接收的是对象想找，但名称空间不存在的名字

----------------------------------------------------

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.name)   # obj.name自动触发__getattr__方法，最后返回值被打印了
print(obj.pwd)
print(obj.hobby)

这样最后就可以用字典用句点符，也实现往字典里面添加值与取值了！！！
总体就是利用继承与派生的方法，及魔法方法的组合运用达到的效果！！！

.
.
.
.

元类简介

推导步骤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中一切皆对象，所以也可以把类Student当作一个对象，

我们好奇type查看类名显示的是什么

"""也就是产生Student这个类的类是什么？"""


class Student:
    pass
obj = Student()
print(type(obj))     # <class '__main__.Student'>
print(type(Student))   # <class 'type'>  我们所定义的类都是由type产生的
class A:pass
class B:pass
print(type(A), type(B))
print(type(type))     # type类还是由type类产生的

结论:我们定义的类其实都是由type类产生的,所以type类又叫元类(产生类的类)

.
.
.
.
.
.
.

创建类的两种方式

方式1:使用关键字class

class Teacher:
    school_name = '老女儿'
    def func1(self):pass
print(Teacher)
print(Teacher.__dict__)

.
.
.
.
.
.

方式2:利用元类type type(类名,类的父类,类的名称空间)

type源码注释告诉我们：
type(object) -> the object's type
->这个符号，就是返回值的意思，或者就是产生的意思
当我们往括号里面放一个对象时，它就会产生对象的类型，这也是我们之前一直用的方法

type(name, bases, dict) -> a new type
name 是类的名字, bases 是类的父类, dict是类的名称空间
当我们往括号里面放3个参数的时候，这种方式就是用来产生一个类。

cls = type('Student', (object,), {'name':'jason'})
print(cls)
print(cls.__dict__)


"""
了解知识:名称空间的产生
1.手动写键值对
    针对绑定方法不好定义
2.内置方法exec
    能够运行字符串类型的代码并产生名称空间
"""

。

.
.
.
.
.

元类定制类的产生行为

# 推导
	类名加括号产生对象时，触发类里的        __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('懂不懂规矩 类名首字母应该大写啊!!!')
        super().__init__(what, bases, dict)  # 子类继承调用父类type里面的__init__方法


因为类名小写了，所以走到if那边被raise主动报错了，所以导致该类创建不起来
------------------------------------------------
class Student(metaclass=MyMetaClass):    # 利用关键字metaclass指定类的元类
    info = '我是学生 我很听话'
# cls = MyMetaClass('Student',(object,),{'info':'我是学生 我很听话'})  # 等价于上面

print(Student)
print(Student.__dict__)
类名首字母大写，所以该类可以正常创建
-------------------------------------------------

.
.
.
.
.
.

元类定制对象的产生行为

# 推导
    对象加括号会触发   产生对象的类里面的 __call__
    # 类加括号会触发  产生类的类(元类)里面的__call__

---------------------------------------------------

# 需求： 给对象添加独有数据的时候 必须采用关键字参数传参"

class MyMetaClass(type):
    def __call__(self, *args, **kwargs):
        # 双下call里面干三件事
        # 1.产生一个空对象(骨架)
        # 2.调用__init__给对象添加独有的数据(血肉)
        # 3.返回创建好的对象
        # print(args)  # args接收（多余的位置参数组成的元组）
        # {} kwargs接收（多余的关键字参数组成的字典）
        if args:  # 如果args接收到了值，说明用户有用位置参数传参了
            raise TypeError("Jason要求对象的独有数据必须按照关键字参数传参！！！")
        return super().__call__(*args, **kwargs)


class Student(metaclass=MyMetaClass):
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender


obj = Student(name='jason',age= 18,gender= 'male')
# 该语法先触发元类里面的__call__方法，把括号里面的产生交给__call__去处理
print(obj.__dict__)

--------------------------------------------------------


# 总结

# 类加括号生成对象，会先执行元类的双下call方法，双下call方法里面干了3件事

# 1 产生一个空对象（元类产生的类点自己的__new__方法）
# 2 调用类里面双下init（元类产生的类点自己的__init__方法）
# 3 返回实例化的对象

.
.
.
.
.
.

魔法方法之 双下new

class MyMetaClass(type):

    def __call__(cls, *args, **kwargs):

        # 1. 产生一个空对象(骨架)
        obj = cls.__new__(cls)  # cls就是 元类的生成的对象就是Student类
        # 类调用元类的双下new  产生类自己的空对象

        # 2. 类调用__init__给对象添加独有的数据(血肉)
        cls.__init__(obj,*args, **kwargs)

        # 3. 返回创建好的对象
        return obj


class Student(metaclass=MyMetaClass):
    def __init__(self, name):
        self.name = name

obj = Student('jason')  # 触发元类的双下call ，把类自己当第一个参数传进去了
print(obj.name)

-------------------------------------

# 类名.__new__可以产生 类的空对象

.
.
.
.
.
.

设计模式简介

1.设计模式
	前人通过大量的验证创建出来解决一些问题的固定高效方法
2.IT行业
	23种
        创建型
        结构型
        行为型
 	ps:课下感兴趣可以简单看看

------------------------------------------

3.单例模式
	类加括号无论执行多少次永远只会产生一个对象
	目的:
        当类中有很多非常强大的方法 我们在程序中很多地方都需要使用
        如果不做单例 会产生很多无用的对象浪费存储空间
        我们想着使用单例模式 整个程序就用一个对象

.
.
.
.
.

作业

1.整理今日内容及博客
	仔细体会元类推导流程
2.尝试使用多种方式实现单例模式
3.预习明日内容
	选课系统
  	 角色:学校、学员、课程、讲师
 	 要求:1. 创建北京、上海 2 所学校
    2. 创建linux , python , go 3个课程 ， linux\py 在北京开， go 在上海开
    3. 课程包含，周期，价格，通过学校创建课程 
    4. 通过学校创建班级， 班级关联课程、讲师5. 创建学员时，选择学校，关联班级
    5. 创建讲师角色时要关联学校， 
    6. 提供三个角色接口  
    	6.1 学员视图， 可以注册， 交学费， 选择班级，  
    	6.2 讲师视图， 讲师可管理自己的班级， 上课时选择班级， 查看班级学员列表 ， 修改所管理的学员的成绩   
    	6.3 管理视图，创建讲师， 创建班级，创建课程
    7. 上面的操作产生的数据都通过pickle序列化保存到文件里