python元类 与 单例模式

一：元类

# 元类，即函数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

# 方法三：使用元类

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