16 元类

程序员文章站 2024-01-09 20:07:58

面向对象学习目录 1 面向对象介绍 2 类、实例、属性、方法详解 3 面向过程与面向对象进一步比较 4 类与对象 5 属性查找与绑定方法 6 小结 7 继承与派生 8 组合 9 抽象类 10 多态 11 封装 12 绑定方法与非绑定方法 13 内置方法（上） 14 内置方法（中）之描述符 15 内置 ......

面向对象学习目录

1 面向对象介绍

一知识储备

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=300
11 ''',g,l)
12  
13 print(g) #{'x': 100, 'y': 2,'z':200,......}
14 print(l) #{'m': 300}

二引子（类也是对象）

1 class Foo:
2 　　pass
3  
4 f1=Foo() #f1是通过Foo类实例化的对象

　　python中一切皆是对象，类本身也是一个对象，当使用关键字class的时候，python解释器在加载class的时候就会创建一个对象(这里的对象指的是类而非类的实例)，因而我们可以将类当作一个对象去使用，同样满足第一类对象的概念，可以：

　　把类赋值给一个变量

　　把类作为函数参数进行传递

　　把类作为函数的返回值

　　在运行时动态地创建类

上例可以看出f1是由Foo这个类产生的对象，而Foo本身也是对象，那它又是由哪个类产生的呢？

1 #type函数可以查看类型，也可以用来查看对象的类，二者是一样的
2 print(type(f1)) # 输出：<class '__main__.Foo'> 表示，obj 对象由Foo类创建
3 print(type(Foo)) # 输出：<type 'type'>

三什么是元类？

　　元类是类的类，是类的模板，元类是用来控制如何创建类的，正如类是创建对象的模板一样，而元类的主要目的是为了控制类的创建行为

　　元类的实例化的结果为我们用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=name
5         self.age=age
6     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=name
21     self.age=age
22 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': <function talk at 0x101a560c8>, '__init__': <function __init__ at 0x101a56668>}

步骤二：调用元类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 '''
 8 <class '__main__.Chinese'>
 9 <class 'type'>
10 True
11 '''

我们看到，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) #<class '__main__.People'> ('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) #<class '__main__.People'> ('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.__instance
class 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': <function Chinese.walk at 0x0000000001E7B950>,
24 '__dict__': <attribute '__dict__' of 'Chinese' objects>,
25 '__weakref__': <attribute '__weakref__' of 'Chinese' objects>,
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为类Foo
15  
16         for k,v in kwargs.items():
17             obj.__dict__[k.upper()]=v
18         return obj
19  
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__)

上一篇： PHP Socket 编程

下一篇：支付宝七夕未来红包怎么发送?支付宝七夕未来红包发送教程

16 元类

一知识储备

二引子（类也是对象）

三什么是元类？

四创建类的两种方式

五自定义元类控制类的行为

六练习题

16 元类

电影票房将破200亿元大数据运用面临两大障碍

用于大数据的并查集（基于HBase）的java类

php实现的替换敏感字符串类实例，字符串实例_PHP教程

CI分页类首页、尾页不显示的解决方法_PHP

java 中关于抽象类和接口的一些知识

寂寞在燃烧：春水堂以2999元“激活”高品质硅胶娃娃

php学习笔记类的声明与对象实例化_php基础

String类equals方法详解（包含异对象访问value的个人见解）

版主 sqlsrv 自个儿弄的简单类还需要您的帮助

16 元类

一 知识储备

二 引子（类也是对象）

三 什么是元类？

四 创建类的两种方式

五 自定义元类控制类的行为

六 练习题

16 元类

电影票房将破200亿元 大数据运用面临两大障碍

用于大数据的并查集（基于HBase）的java类

php实现的替换敏感字符串类实例，字符串实例_PHP教程

CI分页类首页、尾页不显示的解决方法_PHP

java 中 关于抽象类和接口的一些知识

寂寞在燃烧：春水堂以2999元“激活”高品质硅胶娃娃

php学习笔记 类的声明与对象实例化_php基础

String类equals方法详解（包含异对象访问value的个人见解）

版主 sqlsrv 自个儿弄的简单类还需要您的帮助

一知识储备

二引子（类也是对象）

三什么是元类？

四创建类的两种方式

五自定义元类控制类的行为

六练习题

电影票房将破200亿元大数据运用面临两大障碍

java 中关于抽象类和接口的一些知识

php学习笔记类的声明与对象实例化_php基础