面向对象学习目录
一 知识储备
exec：三个参数
参数一：字符串形式的命令
参数二：全局作用域（字典形式），如果不指定，默认为globals()
参数三：局部作用域（字典形式），如果不指定，默认为locals()
exec的使用
1 #可以把exec命令的执行当成是一个函数的执行，会将执行期间产生的名字存放于局部名称空间中 2 g={ 'x':1,'y':2} 3 l={} 4 5 exec(''' 6 global x,z 7 x=100 8 z=200 9 10 m=30011 ''',g,l)12 13 print(g) #{'x': 100, 'y': 2,'z':200,......}14 print(l) #{'m': 300}
二 引子（类也是对象）
1 class Foo:2 pass3 4 f1=Foo() #f1是通过Foo类实例化的对象
python中一切皆是对象，类本身也是一个对象，当使用关键字class的时候，python解释器在加载class的时候就会创建一个对象(这里的对象指的是类而非类的实例)，因而我们可以将类当作一个对象去使用，同样满足第一类对象的概念，可以：
把类赋值给一个变量
把类作为函数参数进行传递
把类作为函数的返回值
在运行时动态地创建类
上例可以看出f1是由Foo这个类产生的对象，而Foo本身也是对象，那它又是由哪个类产生的呢？
1 #type函数可以查看类型，也可以用来查看对象的类，二者是一样的2 print(type(f1)) # 输出：表示，obj 对象由Foo类创建3 print(type(Foo)) # 输出：
三 什么是元类？
元类是类的类， 是类的模板， 元类是用来控制如何创建类的，正如类是创建对象的模板一样，而元类的主要目的是为了控制类的创建行为
元类的实例化的结果为我们用class定义的类，正如类的实例为对象(f1对象是Foo类的一个实例，Foo类是 type 类的一个实例)
type是python的一个内建元类，用来直接控制生成类，python中任何class定义的类其实都是type类实例化的对象
四 创建类的两种方式
方式一：使用class关键字
1 class Chinese(object):2 country='China'3 def __init__(self,name,age):4 self.name=name5 self.age=age6 def talk(self):7 print('%s is talking' %self.name)
方式二：就是手动模拟class创建类的过程——将创建类的步骤拆分开，手动去创建
1 #准备工作： 2 3 #创建类主要分为三部分 4 5 1 类名 6 7 2 类的父类 8 9 3 类体10 11 12 #类名13 class_name='Chinese'14 #类的父类15 class_bases=(object,)16 #类体17 class_body="""18 country='China'19 def __init__(self,name,age):20 self.name=name21 self.age=age22 def talk(self):23 print('%s is talking' %self.name)24 """
步骤一（先处理类体->名称空间）：类体定义的名字都会存放于类的名称空间中（一个局部的名称空间），我们可以事先定义一个空字典，然后用exec去执行类体的代码（exec产生名称空间的过程与真正的class过程类似，只是后者会将__开头的属性变形），生成类的局部名称空间，即填充字典
1 class_dic={}2 exec(class_body,globals(),class_dic)3 4 5 print(class_dic)6 #{'country': 'China', 'talk': , '__init__': }
步骤二：调用元类type（也可以自定义）来产生类Chinense
1 Foo=type(class_name,class_bases,class_dic) #实例化type得到对象Foo，即我们用class定义的类Foo 2 3 4 print(Foo) 5 print(type(Foo)) 6 print(isinstance(Foo,type)) 7 ''' 89 10 True11 '''
我们看到，type 接收三个参数：
- 第 1 个参数是字符串 ‘Foo’，表示类名
- 第 2 个参数是元组 (object, )，表示所有的父类
- 第 3 个参数是字典，这里是一个空字典，表示没有定义的属性和方法
补充：若Foo类有继承，即class Foo(Bar):.... 则等同于type('Foo',(Bar,),{})
五 自定义元类控制类的行为
一个类没有声明自己的元类，默认他的元类就是type，除了使用元类type，用户也可以通过继承type来自定义元类（顺便我们也可以瞅一瞅元类如何控制类的行为，工作流程是什么）
egon5步带你学会元类（转自老男孩教育egon老师）
#知识储备： #产生的新对象 = object.__new__(继承object类的子类) #步骤一：如果说People=type(类名,类的父类们,类的名称空间)，那么我们定义元类如下，来控制类的创建class Mymeta(type): # 继承默认元类的一堆属性 def __init__(self, class_name, class_bases, class_dic): if '__doc__' not in class_dic or not class_dic.get('__doc__').strip(): raise TypeError('必须为类指定文档注释') if not class_name.istitle(): raise TypeError('类名首字母必须大写') super(Mymeta, self).__init__(class_name, class_bases, class_dic) class People(object, metaclass=Mymeta): country = 'China' def __init__(self, name, age): self.name = name self.age = age def talk(self): print('%s is talking' % self.name) #步骤二：如果我们想控制类实例化的行为，那么需要先储备知识__call__方法的使用class People(object,metaclass=type): def __init__(self,name,age): self.name=name self.age=age def __call__(self, *args, **kwargs): print(self,args,kwargs) # 调用类People，并不会出发__call__obj=People('egon',18) # 调用对象obj(1,2,3,a=1,b=2,c=3)，才会出发对象的绑定方法obj.__call__(1,2,3,a=1,b=2,c=3)obj(1,2,3,a=1,b=2,c=3) #打印：<__main__.People object at 0x10076dd30> (1, 2, 3) {'a': 1, 'b': 2, 'c': 3} #总结：如果说类People是元类type的实例，那么在元类type内肯定也有一个__call__，会在调用People('egon',18)时触发执行，然后返回一个初始化好了的对象obj #步骤三：自定义元类，控制类的调用（即实例化）的过程class Mymeta(type): #继承默认元类的一堆属性 def __init__(self,class_name,class_bases,class_dic): if not class_name.istitle(): raise TypeError('类名首字母必须大写') super(Mymeta,self).__init__(class_name,class_bases,class_dic) def __call__(self, *args, **kwargs): #self=People print(self,args,kwargs) # ('egon', 18) {} #1、实例化People，产生空对象obj obj=object.__new__(self) #2、调用People下的函数__init__，初始化obj self.__init__(obj,*args,**kwargs) #3、返回初始化好了的obj return obj class People(object,metaclass=Mymeta): country='China' def __init__(self,name,age): self.name=name self.age=age def talk(self): print('%s is talking' %self.name) obj=People('egon',18)print(obj.__dict__) #{'name': 'egon', 'age': 18} #步骤四：class Mymeta(type): #继承默认元类的一堆属性 def __init__(self,class_name,class_bases,class_dic): if not class_name.istitle(): raise TypeError('类名首字母必须大写') super(Mymeta,self).__init__(class_name,class_bases,class_dic) def __call__(self, *args, **kwargs): #self=People print(self,args,kwargs) # ('egon', 18) {} #1、调用self，即People下的函数__new__，在该函数内完成：1、产生空对象obj 2、初始化 3、返回obj obj=self.__new__(self,*args,**kwargs) #2、一定记得返回obj，因为实例化People(...)取得就是__call__的返回值 return obj class People(object,metaclass=Mymeta): country='China' def __init__(self,name,age): self.name=name self.age=age def talk(self): print('%s is talking' %self.name) def __new__(cls, *args, **kwargs): obj=object.__new__(cls) cls.__init__(obj,*args,**kwargs) return obj obj=People('egon',18)print(obj.__dict__) #{'name': 'egon', 'age': 18} #步骤五：基于元类实现单例模式,比如数据库对象,实例化时参数都一样,就没必要重复产生对象,浪费内存class Mysql: __instance=None def __init__(self,host='127.0.0.1',port='3306'): self.host=host self.port=port @classmethod def singleton(cls,*args,**kwargs): if not cls.__instance: cls.__instance=cls(*args,**kwargs) return cls.__instance obj1=Mysql()obj2=Mysql()print(obj1 is obj2) #False obj3=Mysql.singleton()obj4=Mysql.singleton()print(obj3 is obj4) #True #应用：定制元类实现单例模式class Mymeta(type): def __init__(self,name,bases,dic): #定义类Mysql时就触发 self.__instance=None super().__init__(name,bases,dic) def __call__(self, *args, **kwargs): #Mysql(...)时触发 if not self.__instance: self.__instance=object.__new__(self) #产生对象 self.__init__(self.__instance,*args,**kwargs) #初始化对象 #上述两步可以合成下面一步 # self.__instance=super().__call__(*args,**kwargs) return self.__instanceclass Mysql(metaclass=Mymeta): def __init__(self,host='127.0.0.1',port='3306'): self.host=host self.port=port obj1=Mysql()obj2=Mysql() print(obj1 is obj2)
六 练习题
练习一：在元类中控制把自定义类的数据属性都变成大写
1 class Mymetaclass(type): 2 def __new__(cls,name,bases,attrs): 3 update_attrs={} 4 for k,v in attrs.items(): 5 if not callable(v) and not k.startswith('__'): 6 update_attrs[k.upper()]=v 7 else: 8 update_attrs[k]=v 9 return type.__new__(cls,name,bases,update_attrs)10 11 class Chinese(metaclass=Mymetaclass):12 country='China'13 tag='Legend of the Dragon' #龙的传人14 def walk(self):15 print('%s is walking' %self.name)16 17 18 print(Chinese.__dict__)19 '''20 {'__module__': '__main__',21 'COUNTRY': 'China',22 'TAG': 'Legend of the Dragon',23 'walk': ,24 '__dict__': ,25 '__weakref__': ,26 '__doc__': None}27 '''
练习二：在元类中控制自定义的类无需init方法
1.元类帮其完成创建对象，以及初始化操作；
2.要求实例化时传参必须为关键字形式，否则抛出异常TypeError: must use keyword argument
3.key作为用户自定义类产生对象的属性，且所有属性变成大写
1 class Mymetaclass(type): 2 # def __new__(cls,name,bases,attrs): 3 # update_attrs={} 4 # for k,v in attrs.items(): 5 # if not callable(v) and not k.startswith('__'): 6 # update_attrs[k.upper()]=v 7 # else: 8 # update_attrs[k]=v 9 # return type.__new__(cls,name,bases,update_attrs)10 11 def __call__(self, *args, **kwargs):12 if args:13 raise TypeError('must use keyword argument for key function')14 obj = object.__new__(self) #创建对象，self为类Foo15 16 for k,v in kwargs.items():17 obj.__dict__[k.upper()]=v18 return obj19 20 class Chinese(metaclass=Mymetaclass):21 country='China'22 tag='Legend of the Dragon' #龙的传人23 def walk(self):24 print('%s is walking' %self.name)25 26 27 p=Chinese(name='egon',age=18,sex='male')28 print(p.__dict__)
