1、引子（类也是对象）
exec：三个参数
参数一：字符串形式的命令
参数二：全局作用域（字典形式），如果不指定，默认就是用全局 globals()
参数三：局部作用域（字典形式），如果不指定，默认就是用局部 locals()
exec会在指定的局部作用域内执行字符串内的代码，除非明确地使用global关键字
g={ \'x\':1, \'y\':2, \'teachers\':{\'egon\',\'alex\',\'yuanhao\',\'wupeiqi\'} } l={\'birds\':[1,2,3]} # exec(""" # def func(): # global x # x=\'egon\' # func() # """,g,l) # print(g) # print(l) exec(""" # exec 当成一个函数的执行 global x x=\'egon\' """,g,l) # 需要指定一下全局作用域是谁和局部作用域是谁 print(g) print(l) 知识储备exec命令
class Foo: x=1 def run(self): pass # print(type(Foo)) f1=Foo() # f1 是通过 Foo 类实例化的对象
python中一切皆是对象，类本身也是一个对象，当使用关键字class的时候，python解释器在加载class的时候就会创建一个对象(这里的对象指的是类而非类的实例)，因而我们可以将类当作一个对象去使用，同样满足第一类对象的概念，可以：
把类赋值给一个变量
把类作为函数参数进行传递
把类作为函数的返回值
在运行时动态地创建类
上例可以看出f1是由Foo这个类产生的对象，而Foo本身也是对象，那它又是由哪个类产生的呢？
2、什么是元类？
元类是类的类，是类的模板
元类是用来控制如何创建类的，正如类是创建对象的模板一样，而元类的主要目的是为了控制类的创建行为
元类的实例化的结果为我们用class定义的类，正如类的实例为对象(f1对象是Foo类的一个实例，Foo类是 type 类的一个实例)
type是python的一个内建元类，用来直接控制生成类，python中任何class定义的类其实都是type类实例化的对象
3、创建类的两种方式
方式一：使用class关键字
class Chinese(object): country=\'China\' def __init__(self,name,age): self.name=name self.age=age def talk(self): print(\'%s is talking\' %self.name)
方式二（就是手动模拟class创建类的过程）：将创建类的步骤拆分开，手动去创建
准备工作：
创建类主要分为三部分
1 类名
2 类的父类
3 类体
步骤一（先处理类体->名称空间）：类体定义的名字都会存放于类的名称空间中（一个局部的名称空间），我们可以事先定义一个空字典，生成类的局部名称空间
class_name=\'Chinese\' #模拟类名 class_bases=(object,) # 模拟新式类继承 object 类 country=\'China\' # 模拟类的数据属性 def __init__(self,name,age): # 模拟类的 init 方法 self.name=name self.age=age def talk(self): # 模拟类的函数属性 print(\'%s is talking\' %self.name) class_dic={ # 模拟类的命长空间 __dict__ \'country\':country, \'__init__\':__init__, \'talk\':talk, }
步骤二：调用元类type（也可以自定义）来产生类Chinense
Chinese=type(class_name,class_bases,class_dic) #实例化 type 得到对象Chinese，即我们用class定义的类Chinese print(Chinese) print(type(Chinese)) print(isinstance(Chinese,type)) \'\'\' <class \'__main__.Chinese\'> <class \'type\'> True \'\'\' 我们看到，type 接收三个参数： 第 1 个参数是字符串 ‘Chinese’，表示类名 第 2 个参数是元组 (object, )，表示所有的父类 第 3 个参数是字典，这里是一个空字典，表示没有定义属性和方法 补充：若Chinese类有继承，即class Chinese(Bar):.... 则等同于type(\'Chinese\',(Bar,),{})
4、元类总结
一个类没有声明自己的元类，默认他的元类就是type，除了使用元类type，用户也可以通过继承type来自定义元类（顺便我们也可以瞅一瞅元类如何控制类的行为，工作流程是什么）
class Mymeta(type): def __init__(self,name,bases,dic): print(\'===>Mymeta.__init__\') # print(self) # <class \'__main__.Foo\'> # print(class_name) # Foo # print(class_bases) # () # print(class_dic) # Foo 的属性 def __new__(cls, *args, **kwargs): print(\'===>Mymeta.__new__\') return type.__new__(cls,*args,**kwargs) def __call__(self, *args, **kwargs): print(\'aaa\') obj=self.__new__(self) self.__init__(self,*args,**kwargs) # self 是 Foo，跑的对象自己的 init，obj.name=\'egon\'，obj 是 f return obj # 返回 f class Foo(metaclass=Mymeta): def __init__(self,name): self.name=name def __new__(cls, *args, **kwargs): return object.__new__(cls)\'\'\' 需要记住一点:名字加括号的本质(即,任何name()的形式),都是先找到name的爹,然后执行:爹.__call__ 而爹.__call__一般做两件事: 主要用来控制实例化的行为 1.调用name.__new__方法，并返回一个对象 2.进而调用name.__init__方法对儿子name进行初始化 \'\'\'
\'\'\' class 定义Foo,并指定元类为Mymeta,这就相当于要用Mymeta创建一个新的对象Foo,于是相当于执行 Foo=Mymeta(\'foo\',(...),{...}) 因此我们可以看到,只定义class就会有如下执行效果 ===>Mymeta.__new__ ===>Mymeta.__init__ 实际上class Foo(metaclass=Mymeta)是触发了Foo=Mymeta(\'Foo\',(...),{...})操作, 遇到了名字加括号的形式,即Mymeta(...),于是就去找Mymeta的爹type,然后执行type.__call__(...)方法 于是触发Mymeta.__new__方法得到一个具体的对象,然后触发Mymeta.__init__方法对对象进行初始化 \'\'\' \'\'\' obj=Foo(\'egon\') # Foo 在元类里面是一个对象，对象()，就执行 call 方法，Foo.__call__(Foo,\'egon\') Foo() # 对象本身不能加括号运行，可以运行的原因是因为继承的元类里面有 call 方法 \'\'\'\'\'\' 总结:元类的难点在于执行顺序很绕,其实我们只需要记住两点就可以了 1.谁后面跟括号,就从谁的爹中找__call__方法执行 type->Mymeta->Foo->obj Mymeta()触发type.__call__ Foo()触发Mymeta.__call__ obj()触发Foo.__call__ 2.__call__内按先后顺序依次调用儿子的__new__和__init__方法 \'\'\'
单例模式：优化内存，无论你实例化多少次，始终用同一个对象
# 方式1 class Mysql: __instance=None # 先定义一个空 def __init__(self): self.host=\'127.0.0.1\' self.port=3306 @classmethod # 绑定类的方法，由类来调用 def single(cls): # 实例化对象的时候要通过这个类的这个方法实例化 if cls.__instance is None: # 实例化的时候看下是否为空 obj=cls() # 正常实例化 cls.__instance=obj # 实例化实例化后赋值 return cls.__instance # 返回对象 def conn(self): pass def execute(self): pass obj1=Mysql.single() obj2=Mysql.single() print(obj1 is obj2) # true 两个实例都是同一个内存空间
#方式2：元类的方式 class Mymeta(type): def __init__(self,class_name,class_bases,class_dic): if not class_name.istitle(): raise TypeError(\'类名的首字母必须大写\') if \'__doc__\' not in class_dic or not class_dic[\'__doc__\'].strip(): raise TypeError(\'必须有注释，且注释不能为空\') super(Mymeta,self).__init__(class_name,class_bases,class_dic) self.__instance=None def __call__(self, *args, **kwargs): #obj=Chinese(\'egon\',age=18) if not self.__instance: # 初始 __instance 的属性不存在，self 是 mysql 类 obj=object.__new__(self) # 手动调用 objcect.__new__方法生成一个空对象 self.__init__(obj) # 手动调用 Mysql.__init__() 的初始化方法，init 里面需要传入 self 对象，self 是 obj self.__instance=obj # 属性赋值 obj return self.__instance # 返回属性也就返回实例化对象 class Mysql(object,metaclass=Mymeta): \'\'\' mysql xxx \'\'\' def __init__(self): self.host=\'127.0.0.1\' self.port=3306 def conn(self): pass def execute(self): pass obj1=Mysql() obj2=Mysql() obj3=Mysql() print(obj1 is obj2 is obj3)
5、练习题
class Mymeta(type): def __init__(self,class_name,class_bases,class_dic): # pass # print(self) # print(class_name) # print(class_bases) # print(class_dic) for key in class_dic: # 遍历子类下面的每个属性 if not callable(class_dic[key]):continue if not class_dic[key].__doc__ or not class_dic[\'__doc__\'].strip(): # 如果属性里面没有注释，就下面报错 raise TypeError(\'小子，你没写注释，赶紧去写\') # type.__init__(self,class_name,class_bases,class_dic) # if hasattr(self,\'__doc__\'): # 类有没有 doc # if not self.__dict__[\'__doc__\']: # 类的 doc 有没有注释，没有就报错 # raise TypeError(\'没有注释\') class Foo(metaclass=Mymeta): x=1 def run(self): \'run function\' # __doc__ print(\'running\') # def __doc__(self): # print(\'hahahahaha\') # Foo=Mymeta(\'Foo\',(object,),{\'x\':1,\'run\':run}) print(Foo.__dict__) print(Foo.__dict__[\'run\'].__doc__) # 打印函数属性的 doc
class Mymetaclass(type): def __new__(cls, name,bases,attrs): update_attrs={} for k,v in attrs.items(): print(type(k)) # 字典里面的键是字符串 if not callable(k) and not k.startswith(\'__\'): # 如果值为不可调用的，且数据属性不是以 __ 开头，就把数据属性名变为大写 update_attrs[k.upper()]=v else: update_attrs[k]=v return type.__new__(cls,name,bases,update_attrs) class Foo(metaclass=Mymetaclass): country=\'China\' tag=\'Dragon\' def walk(self): print(\'%s is walking\'%Foo.tag) print(Foo.__dict__) # print(callable(Foo.walk)) a=\'abc\' def abc(): pass if not callable(\'abc\') and not a.startswith(\'__\'): print(\'ok\') else: print(\'no\')
class Mymetaclass(type): # def __new__(cls,name,bases,attrs): # update_attrs={} # for k,v in attrs.items(): # if not callable(v) and not k.startswith(\'__\'): # update_attrs[k.upper()]=v # else: # update_attrs[k]=v # return type.__new__(cls,name,bases,update_attrs) def __call__(self, *args, **kwargs): print(args) if args: # 如果只传了一个值，就报错 raise TypeError(\'must use keyword argument for key function\') obj = object.__new__(self) #创建对象，self为类 Chinese for k,v in kwargs.items(): obj.__dict__[k.upper()]=v return obj class Chinese(metaclass=Mymetaclass): country=\'China\' tag=\'Legend of the Dragon\' #龙的传人 def walk(self): print(\'%s is walking\' %self.name) p=Chinese(name=\'EGON\') print(p.__dict__) ---------------- () {\'NAME\': \'EGON\'}
.