首页 > 文章列表 > python元类编程的基本使用

python元类编程的基本使用

Python
216 2023-03-17

1.1.propety动态属性

在面向对象编程中,我们一般把名词性的东西映射成属性,动词性的东西映射成方法。在python中他们对应的分别是属性self.xxx和类方法。但有时我们需要的属性需要根据其他属性动态的计算,此时如果直接使用属性方法处理,会导致数据不同步。下面介绍@property方法来动态创建类属性。

from datetime import datetime,date

 

class User:

    def __init__(self,name,birthday):

        self.name = name

        self.birthday = birthday

        self._age = 0

 

    @property

    def age(self):

        return datetime.now().year - self.birthday.year

 

    @age.setter

    def age(self,value):

        self._age = value

 

if __name__ == '__main__':

    user = User("derek",date(year=1994,month=11,day=11))

    user.age = 23

    print(user._age)   # 23

    print(user.age)    # 24 ,动态计算出来的

1.2.__getattr__和__getattribute__的区别

object.__getattr__(self, name) 

找不到attribute的时候,会调用getattr,返回一个值或AttributeError异常。 

object.__getattribute__(self, name) 

无条件被调用,通过实例访问属性。如果class中定义了__getattr__(),则__getattr__()不会被调用(除非显示调用或引发AttributeError异常)

(1)调用一个不存在的属性

class User:

    def __init__(self,info={}):

        self.info = info

 

    # def __getattr__(self, item):

    #     return self.info[item]

 

if __name__ == '__main__':

    user = User(info={"name":"derek","age":24})

    print(user.name)

会报错

(2)加了__getattr__之后就可以调用了

class User:

    def __init__(self,info={}):

        self.info = info

 

    #__getattr__是在查找不到属性的时候调用

    def __getattr__(self, item):

        return self.info[item]

 

if __name__ == '__main__':

    user = User(info={"name":"derek","age":24})

    print(user.name)    #derek

 (3)__getattribute__

class User:

    def __init__(self,info={}):

        self.info = info

 

    #__getattr__是在查找不到属性的时候调用

    def __getattr__(self, item):

        return self.info[item]

 

    #__getattribute不管属性存不存在,都访问这个

    def __getattribute__(self, item):

        return "zhang_derek"

 

 

if __name__ == '__main__':

    user = User(info={"name":"derek","age":24})

    #不管属性存不存在,都走__getattribute__

    print(user.name)    #zhang_derek     #即使属性存在也走__getattribute__

    print(user.test)     #zhang_derek    #不存在的属性也能打印

    print(user.company)   #zhang_derek   #不存在的属性也能打印

1.3.属性描述符

验证赋值的时候是不是int类型

#属性描述符

 

import numbers

 

#只要一个类实现了下面三种魔法函数中的一种,这个类就是属性描述符

class IntField:

    def __get__(self, instance, owner):

        return self.value

    def __set__(self, instance, value):

        if not isinstance(value,numbers.Integral):

            raise ValueError("必须为int")

        self.value = value

    def __delete__(self, instance):

        pass

 

class User:

    age = IntField()

 

if __name__ == '__main__':

    user = User()

    user.age = 24

    print(user.age)

如果user.age=24,值是int,可以正常打印  

如果user.age='test',传一个字符串,则会报错

1.4.__new__和__init__的区别

(1)__new__方法如果不返回对象,不会执行init方法

class User:

    def __new__(cls, *args, **kwargs):

        print("in new")

 

    def __init__(self,name):

        print("in init")

        self.name = name

 

# new是用用来控制对象的生成过程,在对象生成之前

# init是用来完善对象的

# 如果new方法不返回对象,则不会调用init函数

if __name__ == '__main__':

    user = User("derek")

运行结果:没有调用init方法

 (2)返回对象就会执行init方法

class User:

    def __new__(cls, *args, **kwargs):

        print("in new")         #in new

        print(cls)              #cls是当前class对象    <class '__main__.User'>

        print(type(cls))        #<class 'type'>

        return super().__new__(cls)   #必须返回class对象,才会调用__init__方法

 

    def __init__(self,name):

        print("in init")        #in init

        print(self)             #self是class的实例对象      <__main__.User object at 0x00000000021B8780>

        print(type(self))       #<class '__main__.User'>

        self.name = name

 

# new是用用来控制对象的生成过程,在对象生成之前

# init是用来完善对象的

# 如果new方法不返回对象,则不会调用init函数

if __name__ == '__main__':

    user = User(name="derek")

 

#总结

# __new__ 用来创建实例,在返回的实例上执行__init__,如果不返回实例那么__init__将不会执行

# __init__ 用来初始化实例,设置属性什么的

1.5.自定义元类

(1)前戏:通过传入不同的字符串动态的创建不同的类

def create_class(name):

    if name == 'user':

        class User:

            def __str__(self):

                return "user"

        return User

 

    elif name == "company":

        class Company:

            def __str__(self):

                return "company"

        return Company

 

if __name__ == '__main__':

    Myclass = create_class("user")

    my_obj = Myclass()

    print(my_obj)    #user

    print(type(my_obj))     #<class '__main__.create_class.<locals>.User'>

(2)用type创建

虽然上面的方法能够创建,但很麻烦,下面是type创建类的一个简单实例

# 一个简单type创建类的例子

#type(object_or_name, bases, dict)

#type里面有三个参数,第一个类名,第二个基类名,第三个是属性

User = type("User",(),{"name":"derek"})

 

my_obj = User()

print(my_obj.name)    #derek

(3)不但可以定义属性,还可以定义方法

def say(self):     #必须加self

    return "i am derek"

 

User = type("User",(),{"name":"derek","say":say})

 

my_obj = User()

print(my_obj.name)     #derek

print(my_obj.say())    #i am derek

(4)让type创建的类继承一个基类

def say(self):     #必须加self

    return "i am derek"

 

class BaseClass:

    def answer(self):

        return "i am baseclass"

 

#type里面有三个参数,第一个类名,第二个基类名,第三个是属性

User = type("User",(BaseClass,),{"name":"derek","say":say})

 

if __name__ == '__main__':

 

    my_obj = User()

    print(my_obj.name)          # derek

    print(my_obj.say())         # i am derek

    print(my_obj.answer())      # i am baseclass

1.6.什么是元类?

元类就是创建类的类,比如上面的type

在实际编码中,我们一般不直接用type去创建类,而是用元类的写法,自定义一个元类metaclass去创建

# 把User类创建的过程委托给元类去做,这样代码的分离性比较好

 

class MetaClass(type):

    def __new__(cls, *args, **kwargs):

        return super().__new__(cls,*args, **kwargs)

 

class User(metaclass=MetaClass):

    def __init__(self,name):

        self.name = name

 

    def __str__(self):

        return "test"

 

if __name__ == '__main__':

    #python中类的实例化过程,会首先寻找metaclass,通过metaclass去创建User类

    my_obj = User(name="derek")

    print(my_obj)    #test