28

今日内容概要

面向对象的魔法方法

魔法方法：类中定义双下的方法都是魔法方法
不需要人为的调用在特定的条件下就会自动触发执行

常见的魔法方法

魔法方法	触发需要满足的条件
__ init __	对象添加独有的数据
__ str __	对对象进行打印操作
__ call __	对对象调用括号触发
__ getattr __	对象点一个不存在的名字时
__ getattribute __	不管对象点的名字存不存在都会触发
__ setattr __	给对象添加或者修改数据触发
__ enter __	当对象被当做with上下文管理操作的开始自动触发 并且该方法返回什么 as后面的变量名就会接收到什么
__ exit __	with上下文管理语法运行完毕之后自动触发(子代码结束)

魔法对象的实战(笔试题)

1.补全下列代码使得运行不报错即可
    class Context:
        pass
    with Context() as f:
        f.do_something()
#解决思路：
	1.当出现了 with 来将对象进行上下文操作我们就要往类中加上 __enter__ 和__exit__
 	2.其中__enter__后的返回值会被赋予给f所以更改__enter__ return的值 改为 self
	3.f.do_something()就等于>>>self.do_something()
    4.在类中定义do_something()即可
#代码实现
	class Context:
        
        def do_something(self):
            pass
        
        def __enter__(self):
            return self
        
        def __exit__(self):
            return self
        
    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.aaa = 'bbb'
    print(obj)		#{'aaa':'bbb'}
    print(obj.aaa)	# bbb
        

元类简介

'''推导流程1：如何查看数据的数据类型？'''
	我们查看一个数据类型都是使用 type来进行查看的
    l1 = [1,2,3,4]
    d1 = {'1':1,'2':2}
    print(type(l1))   # <class list>
    print(type(d1))   # <class dict>
	可见结果是一个类
'''推导流程2：其实type方法就是用来查看产生对象的类名'''
	class Student:
        pass
    
    obj = Student()
    print(type(obj))   # <class '__main__.Student'>
'''推导流程3：在python中一切皆对象 好奇如果在对Student进行查看'''
	print(type(Student)) # <class 'type'>
   

创建类的两种的方式

# 方式一：使用关键字class
	class 类名:
        子代码
#方式二：使用元类type
	type(类名,类的父类,类的名称空间)
补充:
    1.父类的填写是以元组的格式填写 当只有一个元素的时候记得加逗号
    2.如果不继承包括object则该类不会具有任何功能
    3.类的名称空间是以字典的形式写
    4.该方法并不常用
'''
了解知识：名称空间的产生
1.手写键值对
	针对需要绑定方法时就不好定义
2.使用内置方法exec
	能够识别字符串中是否具有可执行的代码 执行并产生名称空间
'''

元类定制类的产生行为

'''
推导
	对象是由类名加括号产生的	__init__
	类时由元类加括号产生的		__init__
'''
"""产生的类必须是大写字母开头 负责无法产生"""
#1.自定义一个元类 并继承type
class Mytype(type):
    def __init__(cls,what,bases=None, dict=None):
        if not what.istitle():
            raise TypeError('类名必须开头大写')
        super().__init__(what,bases,dict)
        
class aaa(metaclass = Mytype):
    pass

class Aaa(metaclass = Mytype):
    pass

这样就会拦截类名不是大写开头的 并主动报错 如果是大写开头则正常进行

元类定制对象的产生行为

'''
推导：
	对象加括号会执行产生对象类里面的	__call__
	类名加括号会执行该类里的		   __call__
'''
"""对象必须有独有的数据 必须采用关键字传参"""
class MyMetaclass(type):
    def __call__(self,*args,**kwargs):
        # 1.产生一个空对象(骨架)
        # 2.调用__init__给对象数据
        # 3.返回创建好的对象
        if args:
            raise TypeError('寄')
        return super().__call__(*args,**kwargs)
    
class Student(metaclass = MyMetaclass):
    def __init__(self,name,age):
        self.name = name
        self.age = age
        
obj = Student('xiaochen',18)		# 会直接报错 因为不是关键字传参
obj1 = Student(name = 'xiaochen',age='18')

魔法方法之双下new

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__可以产生空对象
'''你没对象我给你new一个'''

设计模式简介

1.设计模式
	前人通过大量的验证创建出来解决一些问题固定高效的办法
2.IT行业
	23种
    分为三大类型：
    	创建型
     	结构型
    	行为型
3.我们需要特别注意一个单列模式
	类加括号无论被执行多少次永远都只会产生一个对象
    目的：
    	当类中有许多非常强大的办法 我们在程序中很多地方都需要使用
        如果不做单例 会产生很多无用的对象浪费存储空间
        如果使用单列 那么程序就只有一个对象

面向对象到现在为止中间所出现的装饰器

装饰器	用法
@classmethod	被修饰的函数 默认绑定给类 类调用第一个参数就是自身 对象也可以调用并且会自动将产生该对象的类传入到第一个参数
@staticmethod	被装饰后的函数就会变成一个普通的函数
@property	被装饰的函数会被伪装成数据 可以通过句点符直接使用
@abc.abstractmethod	该装饰器限制子类必须定义有一个为talk的方法