郑文峰的博客 郑文峰的博客
首页
  • python之路
  • go之路
  • 其他
  • redis
  • mysql
  • docker
  • k8s
读书破万卷
周刊
关于
  • 导航 (opens new window)
  • 代码片段 (opens new window)
  • 收藏
  • 友链
  • 外部页面

    • 开往 (opens new window)
  • 索引

    • 分类
    • 标签
    • 归档
GitHub (opens new window)

zhengwenfeng

穷则变,变则通,通则久
首页
  • python之路
  • go之路
  • 其他
  • redis
  • mysql
  • docker
  • k8s
读书破万卷
周刊
关于
  • 导航 (opens new window)
  • 代码片段 (opens new window)
  • 收藏
  • 友链
  • 外部页面

    • 开往 (opens new window)
  • 索引

    • 分类
    • 标签
    • 归档
GitHub (opens new window)
  • python

    • 基础

      • python迭代器与生成器
      • python元编程
        • property动态属性
        • _getattribute 和 getattr_
        • 属性描述符
          • 属性描述符查找过程
        • 元类
          • 通过type创建class
          • 自定义元类
      • python垃圾回收机制
      • python上下文管理器
      • python装饰器的使用方法
      • 使用python实现单例模式的三种方式
      • python中import原理
    • 第三方库

    • django

    • flask

    • tornado

    • 其他

  • go

  • 其他

  • 编程
  • python
  • 基础
zhengwenfeng
2022-08-10
目录

python元编程

# property动态属性

通过使用property可以将方法像属性一样获取值。使用setter对方法进行赋值操作


from datetime import datetime, date
class Student:

    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
    
stu = Student("zhangsan", date(year=1995, month=3, day=7))
stu.age = 4
print(stu.age)

output: 24
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# getattribute 和 getattr

__getattr__在类中找不到属性时,调用该函数。 __getattribute__首先调用该函数,然后找属性.

在__getattribute__中抛出AttributeError时,会调用__getattr__

调用顺序 __getattribute__ > __getattr__

# 属性描述符

在类中只要实现了__get__、__set__、__delete__方法中的一个就认为是描述符. 只实现了__get__的对象是非数据描述符. 只读 实现了__get__和__set__的对象是数据描述符. 可读可写.

class IntField:
    def __get__(self):
        pass
        
    def __set__(self):
        pass
        
    def __delete__(self):
        pass
1
2
3
4
5
6
7
8
9

# 属性描述符查找过程

属性描述符发生的过程在__getattribute__中.

如果age是属性描述符,则调用IntField中的__get__获得属性值,如果获取失败,则调用__dict__获取值。如果age不是属性描述符,则直接获取__dict__对应的值。


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 value need")
        if value < 0:
            raise ValueError("positive value need")
        self.value = value
        
    def __delete__(self, instance):
        pass
    
class NonDataIntField:
    # 非数据属性描述符
    def __get__(self, instance, owner):
        return "NonDataIntField = {}".format(self.value)

class User:
    age = IntField()
    #age = NonDataIntField()

user = User()
user.name = "zhangsan"    # name不是属性描述符,所以直接加入到`__dict__`中
print(user.__dict__)

user.age = 12               # age是属性描述符, 调用`IntField`中的`__set__`方法, 而不会加入到`__dict__`中
print(user.__dict__)
print(user.age)              # 调用`IntField`中的`__get__`方法


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

# 元类

元类是创建类的类. type -> class -> 对象

所有的类都是通过type实例化得到的。

# 通过type创建class

使用type创建User类,该类继承Base类,并且有test方法和name属性


class Base:
    def __init__(self, *args, **kwargs):
        print("Base __init__")
        super().__init__(*args, **kwargs)

def test(self):
    print("test = {}".format(self.name))
 
User = type("User", (Base,), {"test": test, "name": "zhangsan"})
user = User()
user.test()


1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 自定义元类

自定义元类需要通过继承type实现

如果父类有metaclass,则子类和父类的创建都需要通过该元类实例化得到。



class BaseMeta(type):

    def __new__(cls, name, bases, args, **kwargs):
        # print(name)
        # print(bases)
        # print(args)
        print("BaseMeta __new__..")
        
        if name == "Base":
            return super().__new__(cls, name, bases, args, **kwargs)
            
        meta = args['Meta']
        name = getattr(meta, "name")    # 获取到A中meta的name的值. django的orm也是这样实现的
        print(name)
        
        return super().__new__(cls, name, bases, args, **kwargs)



class Base(metaclass=BaseMeta):

    def __new__(cls, *args, **kwargs):
        print("Base __new__..")
        return super().__new__(cls, *args, **kwargs)
        
    def __init__(self, *args, **kwargs):
        print("Base init..")
        super().__init__(*args, **kwargs)
    
class A(Base):

    def __new__(cls, *args, **kwargs):
        print("A __new__..")
        return super().__new__(cls, *args, **kwargs)
        
    def __init__(self, *args, **kwargs):
        print("A init..")
        super().__init__(*args, **kwargs)
        
    class Meta:
        name = "zhangsan"


# A和Base都会通过BaseMeta创建,所以会调用两次__new__创建实例
output:

BaseMeta __new__..
BaseMeta __new__..
zhangsan
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

元类的经典例子是django ORM

#python
上次更新: 2023/01/15, 15:47:48
python迭代器与生成器
python垃圾回收机制

← python迭代器与生成器 python垃圾回收机制→

最近更新
01
django rest_framework 分页
03-20
02
学习周刊-第03期-第09周
03-03
03
学习周刊-第02期-第08周
02-24
更多文章>
Theme by Vdoing | Copyright © 2022-2023 zhengwenfeng | MIT License
  • 跟随系统
  • 浅色模式
  • 深色模式
  • 阅读模式