exec内置函数的补充
exec: 是一个python内置函数，可以将字符串的代码添加到名称空间中;
- 全局名称空间
- 局部名称空间
exec(字符串形式的代码, 全局名称空间, 局部名称空间)
# 使用exec, code相当于局部名称空间中的名字
code = '''
global x
x = 100 y = 20
def func():
pass def __init__():
pass
''' # 自定义的全局名称空间
global_dic = {
'x': 10000
} # 自定义的局部名称空间
local_dic = { 'y':300
} # print(global_dic)
#
# print(local_dic) exec(code, global_dic, local_dic)
print(global_dic) # {'x': 100, ...} 此处全局变量1000被code中x=100替换 # print(local_dic)
# {'y': 20, 'func': <function func at 0x00000000003D1E18>, '__init__': <function __init__ at 0x00000000023789D8>}
# 局部空间y=300被code中y=20替换
元类
1.什么是元类？
- 类的类就是type, 其实type就是元类;
2.元类的作用?
- 元类可以控制类的创建过程!
3.如何创建元类以及使用?
# 1.一切皆对象
list1 = [] # list1 = list([])
# print(type(list1)) # <class 'list'> # 2.自定一个类
class Chinese(object):
country = 'china'
def __init__(self, name, age, sex):
self.name = name
self.age = age
self.sex = sex p_obj = Chinese('tank', 17, 'male')
# print(type(p_obj)) # <class '__main__.Chinese'>
print(Chinese) # 类本质上也是一个对象，因为在python中 一切皆对象 ;
# print(type(Chinese)) # <class 'type'> 说明Chinese类是有type实例化的对象
# 3.如何产生类的:
# 1) 通过class关键字产生类
# 2) 通过调用type类: type() ---> obj ---> Chinese # what: 指的是类名
# bases: 继承的父类 (object, )
# dict: 类的名称空间 code = '''
country = 'china'
def __init__(self, name, age, sex):
self.name = name
self.age = age
self.sex = sex
'''
# class_attr
class_attr = {}
exec(code, {}, class_attr) # type(类的名字, 类的基类, 类的名称空间) ----> 类 ---> 对象
obj = type('Chinese', (object, ), class_attr) # def __init__(what, bases=None, dict=None)
# print(obj)
Chinese = obj
print(Chinese) # <class '__main__.Chinese'>
chinese_obj = obj('tank',18,'male')
print(chinese_obj.country) # china
1.什么是元类？
类的类就是type, 其实type就是元类;
2.为什么要使用元类???
元类可以控制类的创建过程!
# type是python内置的元类
# 自定义一个元类
class MyMetaClass(type): # 控制类的创建
# 优酷需要用到的部分;
def __init__(self, class_name, class_bases, class_dict): # self， obj
print(type(class_name))
# print(class_name.istitle())
if not class_name.istitle():
raise NameError('类的首字母必须大写!')
if not class_dict.get('__doc__'):
raise TypeError('必须给我写注释!!!') # 必须将类中的类名、类的基类、类的名称空间，一并返回给 type中的__init__
super().__init__(class_name, class_bases, class_dict) # 了解: 元类更深层次的作用
# 控制调用类的行为
# 为什么调用类就一定会产生一个空对象，为什么一定会执行__new__
# 其实就是type内部一定会调用一次__call__，由__call__来帮你调用__new__。
# 元类中的__call__就是创建类的过程!!!
def __call__(self, *args, **kwargs):
print(args) # Foo类括号中的值
# 1.造一个空对象obj
obj = object.__new__(self) # 创造一个空的对象 # self ---> User
print(obj.__dict__, 1111111)
# 2.调用类时，__call__会立马调用User.__init__, 并且将obj连同Foo括号内的参数一同传给__init__
self.__init__(obj, *args, **kwargs)
# return一个真正创建的对象
return obj # obj = MyMetaClass()
# obj() # obj() ----> User(10, 20) ----> user_obj
# 被控制类在定义阶段 类名(metaclass=自定义的元类) ---> 会将当前类的
# 1)类名、2)基类、3)类的名称空间 一并 传给 自定义的元类
# metaclass ---> 自定义的元类 ---> 调用自定义的元类(类名, 基类, 类的名称空间)
# type(类名, 基类, 类的名称空间) class User(object, metaclass=MyMetaClass): # MyMetaClass(User, (object, ), {'x':10}) '''tank是真的很帅啊，真的舍不得你们啊!!!'''
def __init__(self):
pass
x = 10 obj = User()
print(obj)
'''
<class 'str'>
()
{} 11111111
<__main__.User object at 0x000000000258C4E0>
'''
属性查找顺序
class Mymeta(type): # 但凡继承了type的类才能称之为自定义的元类,否则就是只是一个普通的类
# n=444
def __call__(self, *args, **kwargs): #self=OldboyTeacher这个类
# 1. 先产生一个空对象
tea_obj = self.__new__(self) # tea_obj是OldboyTeacher这个类的对象
# print(self.__new__ is object.__new__)
# tea_obj=object.__new__(self) # 2. 执行__init__方法,完成对象的初始属性操作
self.__init__(tea_obj, *args, **kwargs)
# 3. 返回初始化好的那个对象
return tea_obj class Bar:
# n = 33
pass class Foo(Bar):
# n = 222
pass class OldboyTeacher(Foo, metaclass=Mymeta): # OldboyTeacher=Mymeta('OldboyTeacher',(object,),{...})
# n = 111
school = 'Oldboy' def __init__(self, name, age, sex):
self.name = name #None.name='egon'
self.age = age
self.sex = sex def score(self):
print('%s is scoring' % self.name) def __new__(cls, *args, **kwargs):
# print('=====>')
return super().__new__(cls) tea1 = OldboyTeacher('egon', 18, 'male')
# print(tea1)
print(tea1.__dict__) # print(OldboyTeacher.n) # print(object.__new__)
图示顺序：