面向对象的魔法方法
魔法方法:类中定义的双下方法都称为魔法方法
特点:调用时不需要人为调用,只要在特定条件下就会自动触发运行.
例如:双下init创建空对象之后自动触发给对象添加独有的数据
常用魔法方法
1.__init__方法:
在创建一个对象时默认被调用，在开发中，如果希望在创建对象的同时，就设置对象的属性，可以对 __init__ 方法进行改造
2.__str__方法:
返回对象的描述信息，使用print()函数打印对象时，其实调用的就是这个对象的__str__方法
3.__call__方法:
可调用对象：凡是可以把一对括号()应用到某个对象身上都可称之为可调用对象，判断对象是否为可调用对象可以用函数 callable。例函数，内置函数、类都属于可调用对象
4.__getattr__方法:
在 [对象].[属性] 获取属性不存在的时候会触发它的执行
5.__getattribute__方法:
在[对象].[属性]就会自动触发,__getattribute__方法优先级比__getattr__高
6.__setattr__方法:
在 [对象].[属性] = [值] 设置属性值的时候就会触发它的执行
7.__enter__方法:
当对象被当做with上下文管理操作的开始自动触发 并且该方法返回什么 as后面的变量名就会接收到什么
8.__exit__方法:
当对象参与with上下文管理语法运行完毕之后自动触发(子代码结束)
9.__new__方法:
(1)触发机制：实例化对象的时候才触发
(2)作用：管理控制对象的生成过程
(3)参数：用一个cls来接收当前类，其他的参数根据实例化的参数决定
(4)返回值：return 可有可无 没有返回值，实例化的结果为None
(5)注意事项：__new__魔术方法和__init__的魔术方法的参数一致（除了第一个）
魔法方法笔试题
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'>
我们使用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类产生的>>>:元类(产生类的类)"""
创建类的两种方式
方式1:使用关键字class
class Teacher:
school_name = '年轻人不讲武德'
def func1(self):pass
print(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(metaclass=MyMetaClass):
info = '我是学生 我很听话'
print(Student)
print(Student.__dict__)
元类定制对象的产生行为
"""
推导
对象加括号会执行产生该对象类里面的 __call__
类加括号会执行产生该类的类里面的 __call__
"""
"""给对象添加独有数据的时候 必须采用关键字参数传参"""
class MyMetaClass(type):
def __call__(self, *args, **kwargs):
# 1.产生一个空对象(骨架)
# 2.调用__init__给对象添加独有的数据(血肉)
# 3.返回创建好的对象
# 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__)
设计模式简介
什么是设计模式
设计模式是面对各种问题进行提炼和抽象而形成的解决方案。这些设计方案是前人不断试验，考虑了封装性、复用性、效率、可修改、可移植等各种因素的高度总结。它不限于一种特定的语言，它是一种解决问题的思想和方法
设计模式分为三大类(23种模式)
创建类设计模式(5种)
单例模式、工厂模式（简单工厂模式、抽象工厂模式）、建造者模式、原型模式
结构类设计模式(7种)
代理模式、装饰器模式、适配器模式、门面模式、组合模式、享元模式、桥梁模式
行为类设计模式(11种)
策略模式、责任链模式、命令模式、中介者模式、模板模式、迭代器模式、访问者模式、观察者模式、解释器模式、备忘录模式、状态模式
单例模式
类加括号无论执行多少次永远只会产生一个对象
目的:
当类中有很多非常强大的方法 我们在程序中很多地方都需要使用
如果不做单例 会产生很多无用的对象浪费存储空间
我们想着使用单例模式 整个程序就用一个对象