4.26（元类）学习总结

1.eval函数和exec函数

 eval内置函数的使用场景：
     1.执行字符串得到相应结果
     2.一般用于类型转换，得到dict，list，tuple等
eval:将字符串str当成有效的表达式来求值并返回计算结果

dic_str = "{'a': 1, 'b': 2, 'c': 3}"
print(eval(dic_str))

list = "[1,2,3,4,5]"
print(eval(list))

tuple_str = "(1,2,3,4,5)"
print(eval(tuple_str))

 exec内置函数：
     1.执行字符串没有执行结果（没有返回值）
     2.将执行的字符串种产生的名字形成对应的局部名称空间

source ='''
name = 'Bob'
age = 20
'''
class A:
    pass
a = A()
dic = {}
exec(source, {}, dic)
a.__dict__= dic
print(a.__dict__) # {'name': 'Bob', 'age': 20}
print(a.name) # Bob
print(a.age)  # 20

元类

1.什么是元类
在python中，万物皆对象，所有用来创建对象的类，
本身也是对象，类是type的对象。

 type类叫做元类，是所有元类的基类
元类：造类的类 -类的类
         --控制类的产生
         --控制类的对象的产生

s = '''
my_a = 10
my_b = 20
def __init__(self):
    pass
@classmethod
def print_msg(cls, msg):
    print(msg)
'''
dic = {}
exec(s, {}, dic)

C = type('C',(object,), dic)
print(C, type(C), C.__bases__)
print(C.__dict__)

c1 = C()
print(c1.my_a)
C.print_msg('12345')

class D:
    my_a = 10
    my_b = 20
    def __init__(self):
        pass
    @classmethod
    def print_msg(cls, msg):
        print(msg)

自定义元类

控制类的产生过程，以及该类对象的产生过程。

class MyMeta(type):
    # 控制类的创建过程
    def __init__(cls, class_name, bases, namespace):
        print(cls, class_name, bases, namespace)
        super().__init__(class_name, bases, namespace)
    def __call__(cls, *args, **kwargs):
        obj = object.__new__(cls)
        cls.__init__(obj, *args, **kwargs)
        return obj

# Student类与Student类的对象产生都可以被元类MyMeta控制
class Student(metaclass=MyMeta):
    def __init__(self, name, age):
        self.name = name
        self.age = age
stu = Student('owen', 18)
print(stu.name)

元类的应用

class MyMeta(type):
    def __call__(cls, *args, **kwargs):
        if not hasattr(cls, 'instance'):
            cls.instance = cls.__new__(cls)
            cls.instance.__init__(*args, **kwargs)
        return cls.instance
class A(metaclass = MyMeta):
    def __init__(self):
        self.ip = '1.1.1.0'

 单例

单例：一个类只能产生一个实例
为什么要有单例
     1.该类需要对象产生
     2.对象一旦产生,在任何位置再实例化对象,只能得到第一次实例化出来的对象
     3.在对象唯一创建后,可以通过属性修改或方法间接修改属性,来完成数据的更新,不能通过实例化方式更新数据

# 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.
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.
class A:
    __instance = None
    def __new__(cls, *args, **kwargs):
        if cls.__instance == None:
            cls.__instance = super().__new__()
        return cls.__instance
print(A(), A())

# 4.
class Single:
    pass
singleton = Single()

 选课系统分析面向对象思想

'''
1.做项目,优先考虑要用哪些对象:老师,学生,管理员,课程,学校等等,那就优先为这些对象创建对应的类,而不是优先考项目要去实现哪些功能,功能的出发点永远从创建类开始,优先想到该项目有哪些功能,重点向这些功能应该封装成什么类
2.类一旦有了,然后思考应该有哪些属性,这就是设计__init__方法的过程,然后思考该类的方法,不需要对象的参与,就是类方法,需要就是对象方法
3.对于数据的存储,我们最终要持久化到文件或硬盘,但数据要在程序中使用,那就必须在内存中使用,那么数据在内存中采用哪种方式存储,列表可以,但是索引标识数据方式不方便;字典可以,具有信息标识;对象也可以,具有信息标识,且访问数据修改数据采用.语法,相当简单,所以优选对象存储,这也是面向对象的优点
4.随着项目的发展,很多类仅仅用来存放数据,那这样的类可以称为Modle类,这些类的数据也具备很多业务逻辑,那我们面向对象思想中,不是将功能写在Model类中,而是定义处理业务的工具类,必然专门操作与数据打交道的操作,丢在DB_Handle类中,那这样专门处理业务逻辑的类,我们称为Ctrl类
5.大型项目中大量与用户交互的界面,我们用专门的类来控制,这就是View类,就选课系统而言,可以封装打印各自信息各种方法,在ctrl的合适位置调用即可,这就是面向对象的MVC设计模式
'''