一:元类
# 元类,即函数type(clsName,bases,dict)
# 方式一:
# code = """
# country = 'China' #局部名字
# def __init__(self,name,age):
# self.name = name
# self.age = age
# """
# class_dict = {}
# exec(code,{},class_dict) #将字符串中的代码产生的全局名字与值放入第二个参数里,局部名字与值放入第三个参数里
# Chinese = type('Chinese',(object,),class_dict)
# 方式二:
def __init__(self,name,age):
self.name = name
self.age = age
Chinese = type('Chinese',(),{'__init__':__init__,'country':'China'})
c1 = Chinese('rock',18)
print(c1.name,c1.age,c1.country)
# 定制元类,即定制函数type(clsName,bases,dict)
class MyMeta(type): # 继承自元类type,重写__new__方法,从而控制类的属性的创建
def __new__(cls, cls_name,bases,dict):
attrs = ((key,value) for key,value in dict.items())
lower_attrs = ((key.lower(), value) for key,value in attrs) #将属性名全改为小写
dict = {}
for k,v in lower_attrs:
# dict.setdefault(k,v)
dict[k]=v
# return type.__new__(cls,cls_name,bases,dict)
return super().__new__(cls, cls_name,bases,dict)
class Foo(metaclass=MyMeta):
Name = 'rock'
# __metaclass__ = MyMeta 这是python2中的用法
f1 = Foo()
f2 = Foo()
print(f1.Name) #'Foo' object has no attribute 'Name'
print(f2.name) # rock
二:单例模式
单例模式,也叫单子模式,是一种常用的软件设计模式。在应用这个模式时,单例对象的类必须保证只有一个实例存在。许多时候整个系统只需要拥有一个的全局对象,这样有利于我们协调系统整体的行为。比如在某个服务器程序中,该服务器的配置信息存放在一个文件中,这些配置数据由一个单例对象统一读取,然后服务进程中的其他对象再通过这个单例对象获取这些配置信息。这种方式简化了在复杂环境下的配置管理。
实现单例模式方法小结:
# 方法一:使用模块
# mysingleton.py
class Singleton:
def foo(self):
pass
singleton = Singleton()
# 需要使用时导入该单例
# other.py
from mysingleton import singleton
# 方法二:使用装饰器
# 多线程下需要加锁
# from threading import Lock
def singleton(cls):
# instance_lock = Lock()
instances = {}
def wrapper(*args, **kwargs):
if cls not in instances:
# with instance_lock:
# if cls not in instances:
instances[cls] = cls(*args, **kwargs)
return instances[cls]
return wrapper
@singleton
class Foo:
pass
# 方法三:使用元类 类是由元类type实例化而来,实例化类时(调用类对象),触发元类的__call__方法
class Singleton(type):
def __call__(cls, *args, **kwargs):
if not hasattr(cls,'_instance'):
cls._instance = super().__call__(*args, **kwargs)
return cls._instance
class MyClass(metaclass=Singleton):
pass
f1 = MyClass()
f2 = MyClass()
print(f1 is f2) # True
# 方法四:使用类方法
# 支持多线程
from threading import Lock
class Singleton:
_instance_lock = Lock()
@classmethod
def get_instance(cls, *args, **kwargs):
if not hasattr(cls, "_instance"):
with Singleton._instance_lock:
# if not hasattr(cls, "_instance"):
cls._instance = cls(*args, **kwargs)
return cls._instance
class MyClass(Singleton):
pass
# 方法五:重写 __new__方法
from threading import Lock
class Singleton():
_instance_lock = Lock()
def __new__(cls,cls_name,bases,dict):
if not hasattr(cls, '_instance'):
with Singleton._instance_lock:
# if not hasattr(cls, '_instance'):
cls._instance = super().__new__(cls,cls_name,bases,dict)
return cls._instance
class MyClass(Singleton):
pass