目录
面向对象高级
今日内容概要
- 面向对象的魔法方法
- 基于魔法方法的笔试题
- 元类简介
- 创建类的两种方式
- 元类定制类的产生行为
- 元类定制对象的产生行为
- 魔法方法之双下new方法
- 设计模式简介及单例模式
今日内容详细
面向对象的魔法方法
魔法方法：类中定义的双下方法都称为魔法方法
不需要人为调用 在特定的条件下会自动触发运行
eg：__init__创建空对象之后自动触发给对象添加独有的数据
1.__init__
对象添加独有数据的时候自动触发
class C(object):
def __init__(self, name):
'''类名加括号 给对象添加独有数据时自动触发'''
self.name = name
# print('__init__')
C('jason')
2.__str__
对象被执行打印操作的时候自动触发
class C(object):
def __init__(self, name):
'''类名加括号 给对象添加独有数据时自动触发'''
self.name = name
# print('__init__')
def __str__(self):
'''对象被执行打印操作的时候自动触发 该方法返回什么打印的结果就是什么
并且str返回的结果必须是一个字符串类型数据
'''
return f'对象:{self.name}'
obj = C('jason')
obj2 = C('kevin')
# # print(obj) # <__main__.C object at 0x000001499709A2E8> 产生对象的类中没有str
print(obj)
print(obj2)
3.__call__
对象加括号调用的时候自动触发
class C(object):
def __init__(self, name):
'''类名加括号 给对象添加独有数据时自动触发'''
self.name = name
# print('__init__')
def __call__(self, *args, **kwargs):
'''
对象加括号调用的时候自动触发 该方法返回什么对象调用之后的返回值是什么
'''
print('__call__')
print(args, kwargs) # 这两个参数就是接收对象调用时传入的参数
return 123
obj = C('jason')
res = obj(123, 345, name='jason', age = 18)
print(res)
4.__getattr__
对象点不存在的名字的时候自动触发
class C(object):
def __init__(self, name):
'''类名加括号 给对象添加独有数据时自动触发'''
self.name = name
# print('__init__')
def __getattr__(self, item):
'''对象在查找无法使用的名字时自动触发 该方法返回什么 点不存在的名字就可以得到什么'''
print('__getattr__')
print(item)
return f'抱歉 您索要的名字{item}压根不存在'
obj = C('jason')
print(obj.age) # 抱歉 您索要的名字age压根不存在
print(obj.xxx) # 抱歉 您索要的名字xxx压根不存在
5.__getattribute__
对象点名字就会自动触发 有它的存在就不会执行上面的__getattr__
class C(object):
def __init__(self, name):
'''类名加括号 给对象添加独有数据时自动触发'''
self.name = name
# print('__init__')
def __getattribute__(self, item): # 包含了getattr，在于getattr同时存在时会先触发这个
'''对象在查找名字的时候(无论对错)就会自动触发该方法，这个方法用得少 一般用getattr'''
print('__getattribute')
obj = C('jason')
print(obj.name)
print(obj.age)
6.__setattr__
给对象添加或者修改数据的时候自动触发 对象.名字=值
class C(object):
def __init__(self, name):
'''类名加括号 给对象添加独有数据时自动触发'''
self.name = name
# print('__init__')
def __setattr__(self, key, value):
'''当对象执行 对象.名字=值的时候就会自动触发'''
print('__setattr__')
print(key, value)
obj = C('jason')
obj.age = 118
7.__enter__
当对象被当做with上下文管理操作的开始自动触发 并且该方法返回什么 as后面的变量名就会接收到什么
8.__exit__
with上下文管理语法运行完毕之后自动触发(子代码结束)
class C(object):
def __init__(self, name):
'''类名加括号 给对象添加独有数据时自动触发'''
self.name = name
# print('__init__')
def __enter__(self):
'''当对象被当做with上下文管理操作的开始自动触发 并且该方法返回什么 as后面的变量名就会接收到什么'''
return 123
def __exit__(self, exc_type, exc_val, exc_tb):
'''当对象参与with上下文管理语法运行完毕之后自动触发(子代码结束)'''
print('__exit__')
obj = C('jason')
with obj as f:
print(f)
魔法方法笔试题
# 1.补全下列代码使得运行不报错即可
# class Context:
# pass
# with Context() as f:
# f.do_someing()
class Context:
def do_someing(self):
pass
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
pass
with Context() as f:
f.do_someing()
# 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 = 123
obj.hobby = 'read'
print(obj) # {'name': 'jason', 'pwd': 123, 'hobby': 'read'}
print(obj.name) # jason
print(obj.pwd) # 123
print(obj.hobby)
print(obj) # 字典存储的数据{}
print(obj.__dict__) # 字典对象的名称空间 {}
print(type(obj)) # <class '__main__.MyDict'>
元类简介
'''推导步骤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'>
"""结论：我们定义的类其实都是由type类产生的>>>:元类(产生类的类)"""
创建类的两种方式
# 方式1：使用关键字class
class Teacher:
school_name = '老女er'
def func1(self):pass
print(Teacher) # <class '__main__.Teacher'>
print(Teacher.__dict__)
# 方式2：利用元类type type(类名，类的父亲，类的名称空间)
cls = type('Student', (object,), {'name': 'jason'})
print(cls) # <class '__main__.Student'>
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)
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__)
魔法方法之双下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.设计模式
前人通过大量的验证创建出来解决一些问题的固定高效方法
2.IT行业
23种
创建型
结构型
行为型
PS:课下感兴趣可以简单看看
3.单例模式
类加括号无论执行多少次永远只会产生一个对象
目的：
当类中有很多非常强大的方法 我们在程序在很多地方都需要使用
如果不做单例 会产生很多无用的对象浪费存储空间
我们想着使用单例模式 整个程序就用一个对象