一、eval、exec内置函数
1、eval函数
eval内置函数的使用场景：
①执行字符串会得到相应的执行结果
②一般用于类型转换得到dict、list、tuple等
2、exec函数
exec应用场景 用来辅助了解元类的概念
①执行字符串没有执行结果（没有返回值）
②将执行的字符串中产生的名字形成对应的局部名称空间
解析exec函数
exec函数帮我们运行字符串中的代码，把字符串中产生的名字放到名称空间里 自己定义全局作用域中的名字和字典，自己定义局部作用域的名字和字典
将所要执行的代码放到字符串中，在字符串中写好操作全局作用域的和局部作用域的 字符串内放一堆代码，exec来运行字符串中的代码的时候产生的名字都会放到名称空间里，
放到自己定义的全局或者是局部的名称空间里，如果声明是global，就会放到global的字典里
exec（字符串，global_dic, local_dic）
code = """
global x
x=0
y=2
"""
global_dic = {'x': 100000}
local_dic = {}
exec(code, global_dic, local_dic)
print(global_dic)
print(local_dic) # {'y': 2} code = """
x=1
y=2
def f1(self,a,b):
pass
"""
local_dic = {}
exec(code, {}, local_dic)
print(local_dic) # {'x': 1, 'y': 2, 'f1': <function f1 at 0x00000000027A8C80>}
二、类的名称空间的控制
class A:
pass print(A.__dict__) a = A()
print(a, type(a)) # <__main__.A object at 0x00000000021E7400> <class '__main__.A'> print(A, type(A)) # <class '__main__.A'> <class 'type'> print(type) # <class 'type'>
print(type(type)) # <class 'type'> 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__) # <class '__main__.C'> <class 'type'> (<class 'object'>,)
print(C.__dict__)
c1 = C()
print(c1.my_a) #
C.print_msg('') class D:
my_a = 10
my_b = 20 def __init__(self):
pass
@classmethod
def print_msg(cls, msg):
print(msg) c1 = C()
print(c1.my_a) #
C.print_msg('') #
三、元类
1、定义：
python中万物皆对象，所有用来创建对象的类，本身也是对象，类是type类的对象
type类叫做元类，是所有元类的基类
元类：制造类的类 --类的类
控制类的产生
控制类的对象的产生
2、__init__、__call__、__new__的用法
①__init__：实例化的时候会自动触发__init__的执行
②__call__：调用类的时候会自动触发
class Zoo:
def __init__(self):
print('') # 对象实例化时候触发
def __str__(self): # 打印对象的时候产生
return 'abc'
def __del__(self): # 删除对象的时候触发
pass
def __call__(self, *args, **kwargs): # 调用类的时候触发
print('')
obj = Zoo() #
print(obj) # abc
obj() # 2 # 调用对象
③__new__：
class CountError(Exception):
pass class MyMeta(type): # 自定义元类，重写init方法的目的：
# 1.该方法是从type中继承来的，所以参数同type的init
# 2.最终的工作(如果开辟空间，如果操作内存)还是要借助type
# 3.在交给type最终完成工作之前，可以对类的创建加以限制 *****
def __init__(cls, class_name: str, bases, namespace):
print(cls) # <class '__main__.Student'>
print(class_name) # Student
print(bases) # (<class 'object'>,)
print(namespace) # {'__module__': '__main__', '__qualname__': 'Student', '__init__': <function Student.__init__ at 0x0000000001EA89D8>}
# 需求：由给元类控制的类的类名必须首字母大写
if not class_name.istitle():
raise NameError('名字首字母必须大写')
# 需求：定义类是必须明确父类
if len(bases) == 0:
raise CountError('父类必须明确') # super(MyMeta, cls).__init__(class_name, bases, namespace)
super().__init__(class_name, bases, namespace) # 自定义元类，重写call方法的目的：
# 1.被该元类控制的类生成对象，会调用元类的call方法
# 2.在call中的返回值就是创建的对象
# 3.在call中
# 通过object开辟空间产生对象
# 用被控制的类回调到自己的init方法完成名称空间的赋值
# 将修饰好的对象反馈给外界
def __call__(cls, *args, **kwargs):
print('call fn run') # call fn run
obj = object.__new__(cls)
# 需求：所有通过该元类控制的类产生的对象都有meta_name该属性
obj.meta_name = cls.__name__
# obj.name = args[0]
# 调回当前被控制的类自身的init方法，完成名称空间的赋值
cls.__init__(obj, *args, **kwargs)
return obj # Student = MyMeta(class_name, bases, namespace)
class Student(object, metaclass=MyMeta):
def __init__(self, name, age):
print('init fn run') # init fn run
self.name = name
self.age = age
pass # stu = Student() # class Teacher(Student, metaclass=MyMeta):
# pass stu = Student('Bob', 18)
print(stu, stu.name, stu.age) # <__main__.Student object at 0x0000000001EB7FD0> Bob 18
stu = Student('Tom', 20)
print(stu.meta_name) # Student
3、自定义元类控制类的创建
需求：类名的首字母必须大写；类中必须写好文档注释
①需求：类名首字母必须大写
class Mymeta(type):
def __init__(self, class_name, class_bases, class_dic):
if not class_name.istitle():
raise TypeError('类名必须大写')
super().__init__(class_name, class_bases, class_dic) # 重用父类的方法 class Foo(object, metaclass=Mymeta):
pass ②需求： 类中必须有文档注释
class Mymeta(type):
def __init__(self, class_name, class_bases, class_dic):
if not class_dic.get('__doc__'):
raise TypeError('类中必须写好文档注释')
super().__init__(class_name, class_bases, class_dic) class Zoo(metaclass=Mymeta):
"""
文档注释
"""
pass
四、单例
1、定义：一个类只能产生一个实例
2、为什么要有单例：
①该类需要对象的产生
②对象一旦产生，在任何位置再实例化对象，只能得到第一次实例化出来的对象
3、单例实现的四种方法：
①方法1
class Songs():
__instance = None
@classmethod
def getInstance(cls):
# 对象没有创建返回，有直接返回
if cls.__instance == None:
cls.__instance = cls()
return cls.__instance # 约定别用 类名() 来实例化对象，用类方法来获取唯一对象
s1 = Songs()
s2 = Songs() print(s1) # <__main__.Songs object at 0x0000000001E776D8>
print(s2) # <__main__.Songs object at 0x0000000001E77710>
print(s1 is s2) # False s1 = Songs.getInstance()
s2 = Songs.getInstance() print(s1) # <__main__.Songs object at 0x00000000027A76D8>
print(s2) # <__main__.Songs object at 0x00000000027A76D8>
print(s1 is s2) # True ②方法2
class Songs:
__instance = None
def __new__(cls, song_name, *args, **kwargs):
if cls.__instance == None:
cls.__instance = object.__new__(cls)
cls.__instance.song_name = song_name
return cls.__instance def change_song(self, song_name):
self.song_name = song_name s1 = Songs('菊花爆满山')
s2 = Songs('感觉身体被掏空')
print(s1.song_name, s2.song_name) # 菊花爆满山 菊花爆满山
s2.change_song('感觉身体被掏空')
print(s1.song_name, s2.song_name) # 感觉身体被掏空 感觉身体被掏空 ③方法3：采用装饰器
def outer(cls):
_instance = None
def inner(*args, **kwargs):
nonlocal _instance
if _instance == None:
_instance = cls(*args, **kwargs)
return _instance
return inner @outer # Songs = outer(Songs)
class Songs:
pass s1 = Songs()
s2 = Songs()
print(s1) # <__main__.Songs object at 0x0000000001EB7748>
print(s2) # <__main__.Songs object at 0x0000000001EB7748>
print(s1 is s2) # True ④方法4
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) # <__main__.Songs object at 0x0000000001E775C0>
print(s2) # <__main__.Songs object at 0x0000000001E775C0>
print(s1 is s2) # True
