面向对象的魔法方法、元类
目录
一.面向对象的魔法方法
1.面向对象的魔法方法
魔法方法：类中定义的双下方法都称为魔法方法，不需要人为调用 ，在特定的条件下会自动触发运行
eg:__ init __创建空对象之后自动触发给对象添加度有哦的数据
| 序号 | 方法 | 功能 |
|---|---|---|
| 1 | __ init __ | 对象添加独有数据的时候自动触发 |
| 2 | __ str __ | 对象被执行打印操作的时候自动触发 |
| 3 | __ call __ | 对象加括号调用的时候自动触发 |
| 4 | __ getattr __ | 对象点不存在的名字的时候自动触发 |
| 5 | __ getattribute __ | 对象点名字就会自动触发 有它的存在就不会执行上面的 __ getattr __ |
| 6 | __ setattr __ | 给对象添加或修改数据的时候自动触发 对象.名字 = 值 |
| 7 | __ enter __ | 当对象被当做with上下文管理操作的开始自动触发，并且该方法返回什么，as后面的变量名就会接收到什么 |
| 8 | __ exit __ | with上下文管理语法运行完毕之后自动触发(子代码结束) |
2.魔法方法笔试题
- 笔试题一
补全下列代码使得运行不报错即可
class Context:
pass
with Context() as f:
f.do_something()
===========================================
解答：
class Contexe:
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()
- 笔试题二
自定义字典类型并让字典能够通过句点符的方式操作键值对
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) # 字典储存数据的数据 {'name': 'jason', 'pwd': 18, 'hobby': 'read'}
print(obj.__dict__) # 字典对象名称空间 {'name': 'jason'}
print(type(obj)) # <class '__main__.MyDict'>
二.元类
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'>
推导步骤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))
结论：我们定义的类其实都是由type类产生的>>>:元类（产生类的类）
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__)
4.元类定制对象的产生行为
"""
推导
对象加括号会执行产生该对象类里面的__call__
类加括号会执行产生该类的类里面的__call__
"""
'''给对象添加独有数据的时候，必须采用关键字参数传参'''
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)
三.魔法方法之双下new
class MyMetaClass(type):
def __call__(self, *args, **kwargs):
# 1.产生一哥空对象
obj = self.__new__(self)
# 2.调用__init__给对象添加独有的数据(血肉）
self.__init__(obj, *args, **kwargs)
return obj
class Student(metaclass=MyMetaClass):
def __init__(self, name):
self.name = name
obj = Student('jason')
print(obj.name)
"""
__new__可以产生空对象
"""
四.设计模式
1.设计模式简介
1.设计模式
前人通过大量的验证创建出来解决一些问题的固定高效方法
2.IT行业
23种
创建型，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式
结构型，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式
行为型，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式
ps:课下感兴趣可以简单看看
3.单例模式
类加括号无论执行多少次永远只会产生一个对象
目的:
当类中有很多非常强大的方法 我们在程序中很多地方都需要使用
如果不做单例 会产生很多无用的对象浪费存储空间
我们想着使用单例模式 整个程序就用一个对象
2.单例模式实现的多种方式
1:
class C1:
__instance = None
def __init__(self, name, age):
self.name = name
self.age = age
@classmethod
def singleton(cls):
if not cls.__instance:
cls.__instance = cls('jason', 18)
return cls.__instance
obj1 = C1.singleton()
obj2 = C1.singleton()
obj3 = C1.singleton()
print(id(obj1), id(obj2), id(obj3))
obj4 = C1('kevin', 28)
obj5 = C1('tony', 38)
print(id(obj4), id(obj5))
====================================================================================
2:
class Mymeta(type):
def __init__(self, name, bases, dic): # 定义类Mysql的实例出来
# 事先先从配置文件中取配置来造一个Mysql的实例出来
self.__instance = object.__new__(self) # 产生对象
self.__init__(self.instance, 'jaosn', 18) # 初始化对象
# 上述两步可以合成下面一步
# self.__instancce=super().__call__(*args, **kwargs)
super().__init__(name, bases, dic)
def __call__(self, *args, **kwargs): # Mysql(...)时触发
if args or kwargs: # args或kwargs内有值
obj = object.__new__(self)
self.__init__(obj, *args, **kwargs)
return obj
return self.__instance
class Mysql(metaclass=Mymeta):
def __init__(self, name, age):
self.name = name
self.age = age
obj1 = Mysql()
obj2 = Mysql()
print(id(obj1), id(obj2))
obj3 = Mysql('tony', 321)
obj4 = Mysql('kevin', 222)
print(id(obj3), id(obj4))
====================================================================================
3：
'''基于模块的单例模式：提前产生一个对象 之后到模块使用'''
class C1:
def __init__(self, name):
self.name = name
obj = c1('jason')
def outer(cls):
_instance = cls('jason', 18)
def inner(*args, **kwargs):
if args or kwargs:
obj = cls(*args, **kwargs)
return obj
return _instance
return inner
@outer # Mysql=outer(Mysql)
class Mysql:
def __init__(self, host, port):
self.host = host
self.port = port
obj1 = Mysql()
obj2 = Mysql()
obj3 = Mysql()
print(obj1 is obj2 is obj3) # True
obj4 = Mysql('1.1.1.3', 3307)
obj5 = Mysql('1.1.1.4', 3308)
print(obj3 is obj4) # False
五.pickle序列化模块
优势:能够序列化python中所有的类型
缺陷:只能够在python中使用 无法跨语言传输
需求:产生一个对象并保存到文件中 取出来还是一个对象
"""
需求:产生一个对象并保存到文件中 取出来还是一个对象
"""
class C1:
def __init__(self, name, age):
self.name = name
self.age = age
def func1(self):
print('from func1')
def func2(self):
print('from func2')
obj = C1('jason', 18)
# import json
# with open(r'a.txt','w',encoding='utf8') as f:
# json.dump(obj, f)
import pickle
with open(r'a.txt', 'wb') as f:
pickle.dump(obj, f)
with open(r'a.txt','rb') as f:
data = pickle.load(f)
print(data)
data.func1()
data.func2()
print(data.name)
