反射
定义：主要是指程序可以访问、检测和修改它本身状态或行为的一种能力（自省）
python面向对象中的反射：通过字符串的形式操作对象相关的属性。python中一切皆对象（都可以使用反射）
对对象的反射
class A:
static_field = '静态属性'
def __init__(self,name,age):
self.name = name
self.age = age
def func(self):
print('in A func')
obj = A('MC骚Q', 18)
# 判断obj对象中是否含有某种属性
print(hasattr(obj,'name')) # True
print(hasattr(obj,'func')) # True
# 获取某种属性，若存在返回属性值，若不存在，返回返回值
print(getattr(obj,'name')) # MC骚Q
print(getattr(obj,'name1',None)) # None
getattr(obj,'func')(obj) # in A func
# 设置属性
setattr(obj,'hobby','玩')
print(getattr(obj,'hobby')) # 玩
# 删除属性
delattr(obj,'name')
print(hasattr(obj,'name')) # False对类的反射
class A(object):
static_filed = 'LOL'
def __init__(self):
self.name = '草丛伦'
def func(self):
return 'in func'
@staticmethod
def func1():
return 'in func1'
print(getattr(A,'static_filed')) # LOL
print(getattr(A,'func')) # <function A.func at 0x0000027BB6CC32F0>
print(getattr(A,'func')(1)) # in func
print(getattr(A,'func1')()) # in func1对当前模块的反射
import sys
def func1():
print('in func1')
def func2():
print('in func2')
def func3():
print('in func3')
class B:
static = 'B类'
li = [f'fun{i}' for i in range(1,4)]
# 获取当前模块所有变量与值的对应关系
this_modules = sys.modules[__name__]
print(getattr(this_modules,'func1')) # <function func1 at 0x000001EE69146048>
getattr(this_modules,'func1')() # in func1
cls = getattr(this_modules,'B')
obj = cls()
print(cls.static) # B类
for i in li:
getattr(this_modules,i)() # in func1 in func2 in func3sys.modules是一个全局字典，该字典是python启动后就加载在内存中。每当程序员导入新的模块，sys.modules都将记录这些模块。字典sys.modules对于加载模块起到了缓冲的作用。当某个模块第一次导入，字典sys.modules将自动记录该模块。当第二次再导入该模块时，python会直接到字典中查找，从而加快了程序运行的速度。
其他模块的反射
# 一个模块中的代码
def test():
print('from the test')
'''
程序目录：
module_test.py
index.py
当前文件：
index.py
'''
# 另一个模块中的代码
import module_test as obj
print(hasattr(obj,'test')) # True
getattr(obj,'test')() # from the test反射的应用
class Auth:
li = [('login','登陆'),('register','注册'),('exit','退出')]
def login(self):
print('登陆')
def register(self):
print('注册')
def exit(self):
print('退出')
while 1:
obj = Auth()
for m,n in enumerate(obj.li,1):
print(m,n[1])
user_choice = input('请输入选择').strip()
if hasattr(obj,obj.li[int(user_choice)-1][0]):
getattr(obj,obj.li[int(user_choice)-1][0])()
else:
print('输入错误')
# 省去对多种情况的判断函数和方法的区别
如何区分
打印函数（方法）名
def func():
pass
class A:
def func(self):
pass
obj = A()
print(func) # <function func at 0x0000025FC2E73378> 函数
print(A.func) # <function A.func at 0x0000025FC2E73488> 函数
print(obj.func) # <bound method A.func of <__main__.A object at 0x0000025FB3F2FDD8>> 方法通过type模块验证
from types import FuntionType
from types import MethodType
def func():
pass
class A:
def func(self):
pass
obj = A()
print(isinstance(func,FuntionType)) # True
print(isinstance(A.func,FuntionType)) # True
print(isinstance(obj.func,FuntionType)) # False
print(isinstance(obj.func,MethodType)) # True静态方法是函数
from types import FunctionType
from types import MethodType
class A:
@staticmethod
def func():
pass
obj = A()
print(isinstance(A.func,FunctionType)) # True函数与方法的区别
双下方法
__len__当对对象执行len()方法时，就会自动执行
class B:
def __len__(self):
print(666)
b = B()
len(b) # len 一个对象就会触发__len__方法
class A:
def __init__(self):
self.a = 1
self.b = 2
def __len__(self):
return len(self.__dict__)
a = A()
print(len(a)) # 2__hash__当对对象执行hash()方法时，就会自动执行
class A:
def __init__(self):
self.a = 1
self.b = 2
def __hash__(self):
return hash(str(self.a)+str(self.b))
a = A()
print(hash(a)) # 打印'12'的hash值,-3594961296004182135__str__当打印对象时，就会自动执行
如果一个类中定义了__str__方法,那么在打印对象时,默认输出该方法的返回值
class A:
def __init__(self):
pass
def __str__(self):
return '铁憨憨'
a = A()
print(a) # 铁憨憨__repr__同__str__
如果一个类中定义了__repr__方法，那么在repr(对象)时，默认输出该方法的返回值
class A:
def __init__(self):
pass
def __str__(self):
return '铁憨憨'
a = A()
print(repr(a)) # 铁憨憨
print('%r'%a) # 铁憨憨__call__对象后加括号，会触发执行
class A:
def __init__(self):
pass
def __call__(self,*args,**kwargs):
print('__call__')
obj = A()
obj() # 执行__call__,打印__call____eq__当对两个对象比较时执行
class A:
def __init__(self):
self.a = 1
self.b = 2
def __eq__(self,obj):
if self.a == obj.a and self.b == obj.b:
return True
a = A()
b = A()
print(a == b)__del__析构方法，当对象在内存中被释放时，自动触发执行
析构函数的调用是由解释器在进行垃圾回收机制时自动出发执行的
class A:
def __del__(self):
print(111)
obj = A()
del obj # 111__new__构造函数，创建并返回一个新对象
class A:
def __init__(self):
self.x = 1
print('in init function')
def __new__(cls,*args,**kwargs):
print('in new function')
return object.__new__(cls,*args,**kwargs)
a = A()
print(a.x)
# in new function
# in init function
# 1单例模式：
class A:
__instance = None
def __new__(cls,*args,**kwargs):
if cls.__instance is None:
cls.__instance = object.__new__(cls)
return cls.__instance
a = A()
b = A()
print(a) # <__main__.A object at 0x0000015BC7C68E80>
print(b) # <__main__.A object at 0x0000015BC7C68E80>单例模式分析：一个类只能实例化一个对象,无论你实例化多少次,内存中都只有一个对象.
"""
单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例类的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。
【采用单例模式动机、原因】
对于系统中的某些类来说，只有一个实例很重要，例如，一个系统中可以存在多个打印任务，但是只能有一个正在工作的任务；一个系统只能有一个窗口管理器或文件系统；一个系统只能有一个计时工具或ID(序号)生成器。如在Windows中就只能打开一个任务管理器。如果不使用机制对窗口对象进行唯一化，将弹出多个窗口，如果这些窗口显示的内容完全一致，则是重复对象，浪费内存资源；如果这些窗口显示的内容不一致，则意味着在某一瞬间系统有多个状态，与实际不符，也会给用户带来误解，不知道哪一个才是真实的状态。因此有时确保系统中某个对象的唯一性即一个类只能有一个实例非常重要。
如何保证一个类只有一个实例并且这个实例易于被访问呢？定义一个全局变量可以确保对象随时都可以被访问，但不能防止我们实例化多个对象。一个更好的解决办法是让类自身负责保存它的唯一实例。这个类可以保证没有其他实例被创建，并且它可以提供一个访问该实例的方法。这就是单例模式的模式动机。
【单例模式优缺点】
【优点】
一、实例控制
单例模式会阻止其他对象实例化其自己的单例对象的副本，从而确保所有对象都访问唯一实例。
二、灵活性
因为类控制了实例化过程，所以类可以灵活更改实例化过程。
【缺点】
一、开销
虽然数量很少，但如果每次对象请求引用时都要检查是否存在类的实例，将仍然需要一些开销。可以通过使用静态初始化解决此问题。
二、可能的开发混淆
使用单例对象（尤其在类库中定义的对象）时，开发人员必须记住自己不能使用new关键字实例化对象。因为可能无法访问库源代码，因此应用程序开发人员可能会意外发现自己无法直接实例化此类。
三、对象生存期
不能解决删除单个对象的问题。在提供内存管理的语言中（例如基于.NET Framework的语言），只有单例类能够导致实例被取消分配，因为它包含对该实例的私有引用。在某些语言中（如 C++），其他类可以删除对象实例，但这样会导致单例类中出现悬浮引用__item__系列
对对象进行类似于字典的操作
class A:
def __init__(self,name):
self.name = name
def __getitem__(self,item):
print(item)
print('get时执行我')
def __setitem__(self,key,value):
self.name = value
print('set时执行')
def __delitem__(self,key):
print(f'del obj{[key]}时执行')
obj = A('皮皮寒')
obj['name'] # name get时执行我
obj['name'] = '铁憨憨' # set时执行
print(obj.name) # 只是触发了__setitem__实际并未更改，因此还是皮皮寒
del obj['name'] # del obj['name']时执行上下文管理器相关
对一个对象类似于进行with语句上下文管理的操作, 必须要在类中定义__enter__ __exit__
class A:
def __init__(self,text):
self.text = text
def __enter__(self): # 开启上下文管理器对象时触发此方法
self.text = self.text + '您来啦'
return self # 将实例化的对象返回给f1
def __exit__(self,exc_type,exc_val,exc_tb): # 执行完上下文管理器对象f1时触发此方法
self.text = self.text + '这就走啦'
with A('大爷') as f1:
print(f1.text)
print(f1.text)
# 大爷您来啦
# 大爷您来啦这就走啦原文：https://www.cnblogs.com/yaoqi17/p/11178138.html