面向对象的魔法方法

魔法方法:类中定义的双下方法都称为魔法方法
不需要人为调用 在特定的条件下会自动触发运行
eg:__init__创建空对象之后自动触发给对象添加独有的数据
1.__init__
    对象添加独有数据的时候自动触发
2.__str__
    对象被执行打印操作的时候自动触发
3.__call__
    对象加括号调用的时候自动触发
4.__getattr__
    对象点不存在的名字的时候自动触发
5.__getattribute__
    对象点名字就会自动触发 有它的存在就不会执行上面的__getattr__
6.__setattr__
    给对象添加或者修改数据的时候自动触发 对象.名字 = 值
7.__enter__
    当对象被当做with上下文管理操作的开始自动触发 并且该方法返回什么 as后面的变量名就会接收到什么
8.__exit__
    with上下文管理语法运行完毕之后自动触发(子代码结束)
9.__del__
    对象被执行删除（主动 被动）操作的时候自动触发
class C1：
    def __del__(self):
        print('__del__')
obj = C1()  #  可以是主动删除  也可以是垃圾回收机制自动清除
eg：
class C(object):
    def __init__(self, name):
        """类名加括号 给对象添加独有数据时自动触发"""
        self.name = name
        # print('__init__')

    def __str__(self):
        """
        对象在被执行打印操作的时候自动触发  该方法返回什么打印的结果就是什么
        并且该方法必须要返回一个字符串类型的数据
        """
        # return '哈哈哈'
        print(f'{self.name}说:哈哈哈')
        return f'{self.name}说:哈哈哈'

    def __call__(self, *args, **kwargs):
        """
        对象被加括号调用的时候自动触发
        该方法返回什么对象调用之后的返回值就是什么
        """
        print('__call__')
        print(args, kwargs)  # (123, 321) {'name': 'jason'}
        return 123  # 123

    def __getattr__(self, item):
        """
        对象在查找无法使用的名字时自动触发
        该方法返回什么 点不存在的名字就可以得到什么
        """
        # print('__getattr__')
        # print(item)   # age
        return 123

    def __getattribute__(self, item):
        """对象在查找名字的时候就会自动触发该方法"""
        # print('__getattribute__')
        # return '哈哈哈'

    def __setattr__(self, key, value):
        """当对象执行 对象.名字 = 值 的时候会自动触发"""
        print('__setattr__')
        # print(key, value)

    def __enter__(self):
        """当对象被当做with上下文管理操作的时候自动触发
        并且该方法返回什么 as后面的变量名就会接收到什么
        """
        return 123

    def __exit__(self, exc_type, exc_val, exc_tb):
        """当对象参与的with上下文管理语法运行完毕之后自动触发(子代码结束)"""
        f.close()

obj = C('jason')
# print(obj)  # <__main__.C object at 0x000001D6C1005B80> 产生对象的类中没有双下str
# print(obj)  # 哈哈哈  产生对象的类中有双下str
# obj()   # __call__
# res = obj()
# print(res)   # None
# res = obj(123,321,name='jason')
# print(res)
# print(obj.name)   # jason
# print(obj.age)  # 123
# obj.age = 18
# obj.name = 'tony'

with obj as f:
    print(f)

with open() as f:
    pass

魔法方法之双下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__可以产生空对象
"""

魔法方法笔试题

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:如何查看数据的数据类型"""
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类产生的>>>:元类(产生类的类)"""

创建类的两种方式

# 方式1:使用关键字class
class Teacher:
    school_name = '老男孩'

    def func1(self): pass

print(Teacher)  # <class '__main__.Teacher'>
print(Teacher.__dict__)
# 方式2:利用元类type   type(类名,类的父类,类的名称空间)
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('你是不是python程序员 懂不懂规矩 类名首字母应该大写啊!!!')
        super().__init__(what, bases, dict)

# 2.指定类的元类:利用关键字metaclass指定类的元类
# class myclass(metaclass=MyMetaClass):
#     desc = '元类其实很有趣 就是有点绕'

class Student(mteaclass=MyMetaClass):
    info = '我是学生 我很听话'

print(Student)
print(Student.__dict__)

元类定制对象的产生行为

"""
推导
    对象加括号会执行产生该对象类里面的 __call__
    类加括号会执行产生该类的类里面的   __call__
"""
"""给对象添加独有数据的时候  必须采用关键字参数传参"""
class MyMetaClass(type):
    def __call__(self, *args, **kwargs):
        # 1.产生一个空对象(骨架)
        # 2.调用__init__给对象添加独有的数据(血肉)
        # 3.返回创建好的对象
        # print(args)
        # 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.设计模式
    前人通过大量的验证创建出来解决一些问题的固定高效方法
2.IT行业
   23种
       创建型(共5种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。)
       结构型(共7种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。)
       行为型(共11种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。)

按字典序排列简介如下:

Abstract Factory（抽象工厂模式）：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

Adapter（适配器模式）：将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

Bridge（桥接模式）：将抽象部分与它的实现部分分离，使它们都可以独立地变化。

Builder（建造者模式）：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

Chain of Responsibility（责任链模式）：为解除请求的发送者和接收者之间耦合，而使多个对象都有机会处理这个请求。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它。

Command（命令模式）：将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可取消的操作。

Composite（组合模式）：将对象组合成树形结构以表示“部分-整体”的层次结构。它使得客户对单个对象和复合对象的使用具有一致性。

Decorator（装饰模式）：动态地给一个对象添加一些额外的职责。就扩展功能而言， 它比生成子类方式更为灵活。

Facade（外观模式）：为子系统中的一组接口提供一个一致的界面，Facade模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。

Factory Method（工厂模式）：定义一个用于创建对象的接口，让子类决定将哪一个类实例化。Factory Method使一个类的实例化延迟到其子类。

Flyweight（享元模式）：运用共享技术有效地支持大量细粒度的对象。

Interpreter（解析器模式）：给定一个语言, 定义它的文法的一种表示，并定义一个解释器, 该解释器使用该表示来解释语言中的句子。

Iterator（迭代器模式）：提供一种方法顺序访问一个聚合对象中各个元素，而又不需暴露该对象的内部表示。

Mediator（中介模式）：用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

Memento（备忘录模式）：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复到保存的状态。

Observer（观察者模式）：定义对象间的一种一对多的依赖关系,以便当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并自动刷新。

Prototype（原型模式）：用原型实例指定创建对象的种类，并且通过拷贝这个原型来创建新的对象。

Proxy（代理模式）：为其他对象提供一个代理以控制对这个对象的访问。

Singleton（单例模式）：保证一个类仅有一个实例，并提供一个访问它的全局访问点。 单例模式是最简单的设计模式之一，但是对于Java的开发者来说，它却有很多缺陷。在九月的专栏中，David Geary探讨了单例模式以及在面对多线程（multi-threading）、类装载器（class loaders）和序列化（serialization）时如何处理这些缺陷。 State（状态模式）：允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它所属的类。

Strategy（策略模式）：定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。本模式使得算法的变化可独立于使用它的客户。

Template Method（模板方法模式）：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。Template Method使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

Visitor（访问者模式）：表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。

单例模式

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