eval、exec及元类、单例实现的5种方法

eval内置函数

# eval内置函数的使用场景：
#   1.执行字符串会得到相应的执行结果
#   2.一般用于类型转化，该函数执行完有返回值，得到dict、list、tuple等
​
dic_str = "{'a': 1, 'b': 2, 'c': 3}"
print(eval(dic_str))
​
list_str = "[1, 2, 3, 4, 5]"
print(eval(list_str))
​
tuple_str = "(1, 2, 3, 4, 5)"
print(eval(tuple_str))

 

exec内置函数

# exec应用场景
# 1.执行字符串没有执行结果(没有返回值)
# 2.将执行的字符串中产生的名字形成对应的局部名称空间
# 3.可以操作全局与局部两个名称空间，一般不用关心全局名称空间
​
source = '''
name = 'Bob'
age = 20
'''
class A:
    pass
a = A()
​
dic = {}
exec(source, {}, dic)
a.__dict__ = dic   # dic = {‘name': 'Bob', 'age': 20}
print(a.__dict__)
print(a.name)
print(a.age)

 

元类

# 元类：类的类
# 通过class产生的类，也是对象，而元类就是用来产生该对象的类
local_str = """
def __init__(self, name, age):
   self.name = name
   self.age = age
def study(self):
   print(self.name + '在学习')
"""
local_dic = {}
exec(local_str, {}, local_dic)
Student = type('Student', (), l_d)
print(Student)
​
​

type产生类

# 类是type的对象，可以通过type(参数)来创建类
​
# type(name, bases, namespace)
​
s = '''
my_a = 10
my_b = 20
def __init__(self):
   pass
@classmethod
def print_msg(cls, msg):
   print(msg)
'''
namespace = {}
exec(s, {}, namespace)
​
Student = type('Student', (object, ), namespace)
​
stu = Student()

 

 

自定义元类

# 元类：所有自定义的类本身也是对象，是元类的对象，所有自定义的类本质上是由元类实例化出来了
Student = type('Student', (object, ), namespace)
​
class MyMeta(type):
    # 在class Student时调用：Student类的创建 => 来控制类的创建
    
    # 自定义元类，重用init方法的目的：
    # 1.该方法是从type中继承来的，所以参数同type的init
    # 2.最终的工作(如果开辟空间，如果操作内存)还是要借助type
    # 3.在交给type最终完成工作之前，可以对类的创建加以限制 *****
    def __init__(cls, class_name, bases, namespace):
        # 目的：对class_name | bases | namespace加以限制 **********************
        super().__init__(class_name, bases, namespace)
    
    # 在Student()时调用：Student类的对象的创建 => 来控制对象的创建
    
    # 自定义元类，重写call方法的目的：
    # 1.被该元类控制的类生成对象，会调用元类的call方法
    # 2.在call中的返回值就是创建的对象
    # 3.在call中
    #       -- 通过object开辟空间产生对象
    #       -- 用被控制的类回调到自己的init方法完成名称空间的赋值
    #       -- 将修饰好的对象反馈给外界
    def __call__(cls, *args, **kwargs):
        # 目的：创建对象，就可以对对象加以限制 **********************
        obj = object.__new__(cls)  # 通过object为那个类开辟空间
        cls.__init__(obj, *args, **kwargs)  # 调回当前被控制的类自身的init方法，完成名称空间的赋值
        return obj
​
# 问题：
# 1.继承是想获得父级的属性和方法，元类是要将类的创建与对象的创建加以控制
# 2.类的创建由元类的__init__方法控制
#  -- 元类(class_name, bases, namespase) => 元类.__init__来完成实例化
# 3.类的对象的创建由元类的__call__方法控制
#   -- 对象产生是需要开辟空间，在__call__中用object.__new__()来完成的
class Student(object, metaclass=MyMeta):
    pass
​
# class Student: <=> type(class_name, bases, namespace)
​
​

 

单例

# 单例：一个类只能产生一个实例
# 为什么要有单例：
# 1.该类需要对象的产生
# 2.对象一旦产生，在任何位置再实例化对象，只能得到第一次实例化出来的对象
# 3.在对象唯一创建后，可以通过属性修改或方法间接修改属性，来完成数据的更新，不能通过实例化方式更新数据
​
## 单例
​
```python
#实现单例方法1--类方法及类封装属性
class Song:
    __instance = None
    def __init__(self):
        pass
    @classmethod
    def getInstance(cls):
        if cls.__instance == None:
            cls.__instance = cls()
        return cls.__instance
s1 = Song.getInstance()
s2 = Song.getInstance()
print(s1, s2)
​
#实现单例方法2--装饰器
```
​
```python
def singleton(cls):
    _instance = None
    def getInstance(*args, **kwargs):
        nonlocal _instance
        if _instance == None:
            _instance = cls(*args, **kwargs)
        return _instance
    return getInstance
​
@singleton
class A:
    def __init__(self, num):
        self.num = num
print(A(1), A(2), A(3))
​
#实现单例方法3--重用__new__方法
```
​
```python
class A:
    __instance = None
    def __new__(cls, *args, **kwargs):
        if cls.__instance == None:
            cls.__instance = super().__new__(cls)
        return cls.__instance
print(A(), A())
​
#实现单例方法4--模块导入（原理：一个模块只有在第一次导入时才会编译执行，之后都是从内存中寻找）
```
​
```python
# single_module.py
class Single:
    pass
singleton = Single()
​
# 测试文件
from single_module import singleton
print(singleton)
print(singleton)
​
​
#实现单例方法5--自定义元类，并将__call__方法重用
class SingleMeta(type):
    __instance = None
    def __call__(cls, *args, **kwargs):
        if SingleMeta.__instance == None:
            SingleMeta.__instance = object.__new__(cls)
            cls.__init__(SingleMeta.__instance, *args, **kwargs)
        return SingleMeta.__instance
​
​
class Songs(metaclass=SingleMeta):
    def __init__(self):
        pass
    pass
​
​
s1 = Songs()
s2 = Songs()
print(s1, s2)
​
```
​
​
​
### 就选课系统分析面向对象思想
​
```python
'''
1.做项目，优先考虑要用到哪些对象：老师、学生、管理员、课程、学校等等，那就优先为这些对象创建出对应的类，而不是优先考虑项目要去实现哪些功能，功能的出发点永远从创建类开始，优先想到了该项目有哪些功能，也是重点向这些功能应该封装成什么类
​
2.类一旦有了，再思考，该类应该有哪些属性，这就是设计__init__方法的过程，然后思考该类有哪些方法，不需要对象的参与，就是类方法，需要就是对象方法
​
3.对于数据的存储，我们最终要持久化到文件或是硬盘，但是数据要在程序中使用，那就必须在内存中使用，那么数据在内存中采用哪种方式存储，列表可以，但是索引标识数据方式很不方便，字典可以，具有信息标识，对象也可以，具有信息标识，而且访问数据修改数据采用.语法，相当简单，所以优选对象存储，这也是面向对象的优点
​
4.那么随着项目的发展，很多类就仅仅用来存放数据的，那这样的类就可以称之为Model类，那这些类的数据也具备很多业务逻辑，那我们在面向对象思想中，不是将功能写在Model类中，而是定义处理业务的工具类，必然专门操作与数据库打交道的操作，丢在DB_Handle类中，那这样专门处理业务逻辑的类，我们称之为Ctrl类
​
5.而大型项目中有大量与用户交互的页面，我们也用专门的类来控制，这就是View类，就选课系统而言，可以封装打印各自信息的各种方法，也是在Ctrl的合适位置调用即可，这就是面向对象的 MVC 设计模式
'''
```
​
​
​