Python基础教程：类的特殊成员及高级特性

小鱼儿 2022-09-14 13:25 313阅读 0赞

**1 对象的格式化输出**

（1）如果需要对一个对象（实例）进行格式化输出，可以重写类的`__repr__()`和`__str__()`方法。

两者的区别：使用交互式解释器输出对象时，结果是`__repr__()`方法返回的字符串；使用 str() 或 print() 函数会输出`__str__()`方法返回的字符串。

参见下例：

class Point:
        """二维坐标系中的点"""
        def __init__(self, x, y):
            self.x = x
            self.y = y
    
        def __repr__(self):
            return "Point({0.x!r}, {0.y!r})".format(self)
    
        def __str__(self):
            return "({0.x!s}, {0.y!s})".format(self)

在交互式命令行【ipython】中的结果：

In [2]: point = Point(1, 2)
    
    In [3]: point
    Out[3]: Point(1, 2)
    
    In [4]: print(point)
    (1, 2)

可以看到，在交互式环境中格式化输出对象是Point(1, 2)；而通过print()打印出的对象是(1, 2)。

（2） 注意，在格式化中使用 !r 表示输出使用 `__repr__()`来代替默认的`__str__()`。

In [5]: print("point is {!r}".format(point))
    point is Point(1, 2)
    
    In [6]: print("point is {!s}".format(point))
    point is (1, 2)
    
    In [7]: print("point is {}".format(point))
    point is (1, 2)

如果`__str__()`没有被定义，会使用`__repr__()`来代替输出。通常来讲自定义`__repr__()`和 `__str__()`是很好的习惯，因为它能简化调试和实例输出。

**2 获取类的描述**

可以通过`__doc__`这个特殊字段获取类的描述【即类的注释】，用法 `类名.__doc__`,参见下列示例：

''' 学习中遇到问题没人解答？小编创建了一个Python学习交流QQ群：531509025 寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！ '''
    class A:
    
        """description..."""
    
        def func(self):
            pass
        
    print(A.__doc__)   
    # description...

**3 获取类或对象的所有成员**

可以通过`__dict__`获取到类或对象的所有成员信息（字典形式），用法 `类名.__dict__`或者`对象.__dict__`，参见下例：

class A:
    
        def __init__(self, name):
            self.name = name
    
        def func(self):
            pass
    
    
    # 获取类的所有成员
    print(A.__dict__)
    #{'__module__': '__main__', 'func': <function A.func at 0x00000000025976A8>, '__dict__': <attribute '__dict__' of 'A' objects>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}
    
    # 获取对象的所有成员
    obj = A("Liu You Yuan")
    print(obj.__dict__)
    # {'name': 'Liu You Yuan'}

可以看到类与对象成员之中，只有【普通字段】是存储在对象中的，其他成员都是在类中。

**4 获取创建当前操作的对象的类名**

通过`__class__`能够获取当前操作的对象是由哪个类所创建，用法`对象.__class__`,参见下例：

''' 学习中遇到问题没人解答？小编创建了一个Python学习交流QQ群：531509025 寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！ '''
    class A:
    
        def func(self):
            pass
    
    obj = A()
    
    # 获取 [当前操作的对象] 所在的类名
    print(obj.__class__)
    # <class '__main__.A'>

**5 获取创建当前操作的对象的类所在的模块名**

通过`__module__`能够获取创建当前操作的对象的类所在的模块，用法`对象.__module__`,参见下例：

class A:
    
        def func(self):
            pass
    
    obj = A()
    # 获取 [当前操作的对象] 所在的模块名
    print(obj.__module__)
    # __main__

**6 让对象可迭代**

只需要在类中实现`__iter__()`方法，即可让对象作用于for循环。参见如下例子：

class A:
        def __init__(self, lis):
            self.lis = lis
    
        def __iter__(self):
            return iter(self.lis)
    
    obj = A([2018, 0, 3, 1, 9])
    for i in obj:    # 当对象用于迭代时，实际是相当于迭代__iter__方法的返回值。
        print(i)
        
    # 2018
    # 0
    # 3
    # 1
    # 9

上例中，如果没有实现`__iter__()`方法，对象obj是不能被循环的。实际上，像list、dict、str等数据结构之所能够被迭代，就是其类中实现了`__iter__()`方法。

**7 让对象支持字典操作**

实现`__getitem__` / `__setitem__` / `__delitem__`， 可实现对象类似字典的操作，参见下例：

''' 学习中遇到问题没人解答？小编创建了一个Python学习交流QQ群：531509025 寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！ '''
    class Person:
    
        def __init__(self, name):
            self.name = name
    
        def __getitem__(self, k):
            return self.name
    
        def __setitem__(self, k, v):
            self.name = v
    
        def __delitem__(self, k):
            del self.name
    
    
    obj = Person("Jeo Chen")
    
    result = obj['name']          # 自动触发执行 __getitem__
    print(result)                 # Jeo Chen
    
    obj['name'] = 'Liu You Yuan'  # 自动触发执行 __setitem__
    print(obj['name'])            # Liu You Yuan
    
    del obj['name']               # 自动触发执行 __delitem__

**8 优化大量对象占用的内存**

如果需要创建大量(成千上万)的对象，导致很占内存，可以通过特殊的静态字段`__solts__`来减少对象所占用的内存。

下例将对比定义`__solts__`和 没有定义`__solts__`的两个类在创建大量对象时占用的内存大小，其中用了【反射的知识】和 【tracemalloc包】。

tracemalloc包是跟踪由Python分配的内存块的调试工具。其中：  
（1）`tracemalloc.start()`方法表示开始跟踪Python内存分配，开始时内存占用设为1；tracemalloc.stop()表示停止跟踪；  
（2）`tracemalloc.get_traced_memory()`方法能获取由 tracemalloc 模块跟踪的内存块的当前大小和峰值大小作为元组：(current: int, peak: int)，单位为字节。

详细参见下例：

import tracemalloc
    
    ITEM_NUM = 10
    class HaveSlots:
        __slots__ = ['item%s' % i for i in range(ITEM_NUM)]
    
        def __init__(self):
            for i in range(len(self.__slots__)):
                setattr(self, 'item%s' % i, i)
    
    class NoSlots:
        def __init__(self):
            for i in range(ITEM_NUM):
                setattr(self, 'item%s' % i, i)
    
    
    # 开始跟踪
    tracemalloc.start()
    
    obj = [NoSlots() for i in range(100)]
    # 获取由 tracemalloc 模块跟踪的内存块的当前大小和峰值大小作为元组：(current: int, peak: int)
    print(tracemalloc.get_traced_memory())
    
    # 停止跟踪
    tracemalloc.stop()
    
    # 又开始跟踪，相当于重置
    tracemalloc.start()
    obj2 = [HaveSlots() for i in range(100)]
    print(tracemalloc.get_traced_memory())
    
    # (21832, 22219) # 未定义__slots__字段，创建100个对象占用的内存约为 21832 字节
    # (13760, 14147) # 定义__slots__字段，创建100个对象占用的内存约为 13760 字节

上例可见，当定义了`__slots__`字段时， 创建大量对象所占用的内存（13760） 明显小于 没有定义`__slots__`字段的内存（21832）。或许，你得到的占用内存大小与我得到的不一致，但不影响最终结论。

`__slots__`究竟做了什么来降低内存呢？

（1）默认情况下，自定义的对象都使用dict来存储属性（通过`obj.__dict__`查看），而python中的dict的底层需要考虑“降低hash冲突”，因此dict所占存储空间要比实际存储的元素大，会浪费一定的空间。  
（2）使用`__slots__`后的类所创建的对象只会用到这些\_slots\_\_定义的字段，也就是说，每个对象都是通过一个很小的固定大小的数组来构建字段，而不是字典。  
需要注意的是：  
（1）如果声明了`__slots__`，那么对象就不会再有`__dict__`属性。  
（2）使用`__slots__`意味着不能再给实例添加新的属性，只能使用在`__slots__`中定义的那些属性名。  
（3）定义了`__slots_`\_后的类不再支持一些普通类特性了，比如多继承。  
因此，如果需要创建成千上万的对象，`__slots__`比较适用；其他情况，还是要减少对`__slots__`使用的冲动。

**9 构造方法**

类中的`__init__()`方法就是类的构造方法了，通过类创建对象时，自动触发执行。参见下例：

''' 学习中遇到问题没人解答？小编创建了一个Python学习交流QQ群：531509025 寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！ '''
    class A:
    
        def __init__(self, name):
            self.name = name
            print("this is __init__")
    
    # 创建对象则自动触发__ini__方法。
    obj = A("Jeo Chen")
    # this is __init__

直到此时，才介绍构造方法其实是为后面的内容铺垫。这里说创建对象时自动触发执行构造方法是不准确的，继续往下读，会介绍`__init__`的真正作用。

**10 析构方法**

`__del__`方法即为类的析构方法，当对象在内存中被释放时，自动触发执行。不过，Python是有垃圾回收机制的高级语言，我们无需关心内存的分配和释放。解释器在进行垃圾回收时自动触发执行的析构方法。

class A:
        
        def __del__(self):
            pass

**11 `__call__`方法**

当在对象后面加括号，即 【对象()】会自动触发`__call__`方法，这一点要与构造方法相区别。构造方法是类名后面加括号，即【类名()】触发。

class A:
        def __call__(self):
            print("this __call__")
    
    obj = A()
    obj()   # 对象后面加括号，触发__call__
    # this __call__

**12 `__new__`方法**

实际上，在创建对象时，调用`__init__`方法之前，就调用了`__new__`方法。我们可以通过下例证明：

''' 学习中遇到问题没人解答？小编创建了一个Python学习交流QQ群：531509025 寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！ '''
    class A:
    
        def __init__(self, name):
            print("In A init")
            self.name = name
    
        def __new__(cls, *args, **kwargs):
            print("In A new",)
            return object.__new__(cls)
    
    # 创对象
    obj = A("Liu You Yuan")
    # In A new
    # In A init

那么`__new__`方法到底有什么作用？下例演示了不调用`__init__`方法创建一个对象，详见如下：

class Person:
    
        def __init__(self, name):
            print("in Person init")
            self.name = name
    
        def __new__(cls, *args, **kwargs):
            print("In Person new",)
            return object.__new__(cls)
    
    # 不调用 __init__() 方法来创建Person对象
    obj = Person.__new__(Person)
    print(obj)
    print(obj.name)

执行结果如下：

In Person new
    <__main__.Person object at 0x00000000025E8EB8>
    Traceback (most recent call last):
      File "D:/githubfile/pythonclub/面向对象/new.py", line 34, in <module>
        print(obj.name)
    AttributeError: 'Person' object has no attribute 'name'

分析输出结果：  
（1）第一行打印了 “In Person new” 说明确实是调用了`__new__`方法；另外并没有打印 “in Person init” 说明确实没有调用`__init__`方法。  
（2）第二行打印了`<__main__.Person object at 0x00000000025E8EB8>`, 说明确实创建了一个对象。  
（3）接着有报错，报错内容说`AttributeError: 'Person' object has no attribute 'name'`, 对象并没有name属性（字段）。

综上，上例的结果不言而喻：

（1）`__new__`方法才是真正创建对象的，只不过它创建的对象在没调用`__init__`前是没有经过【初始化】的。  
（2）`__init__`方法是初始化对象的，【初始化】的过程也就是将字段封装到对象中，通过 对象.字段 就能访问。

**13 类是怎么产生的**

常常听到，“python 一切皆对象”， 如此，“类” 本身也是对象，既然是对象，必然有创建它的类。换言之，"类"这个对象，是由"某个特殊的类"实例化而来。这个特殊的类就是type()，又称元类。  
除了之前介绍的通过class关键字可以定义类，通过type()也能定义，参见下例：

''' 学习中遇到问题没人解答？小编创建了一个Python学习交流QQ群：531509025 寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！ '''
    def __init__(self, name):
        self.name = name
    
    def hello(self):
        print("hello {}".format(self.name))
    # 用type()定义类。第一个参数是类名，第二个参数是当前类的基类，第三个参数为类的成员
    Person = type('Person', (object,), { 'sayHi': hello, "__init__": __init__})
    
    obj = Person("Liu")
    print(obj)       # <__main__.Person object at 0x0000000002368E80>
    obj.sayHi()      # hello Liu

这样证实了通过元类type()也能定义一个类，而且跟用class关键字定义的效果一样，只不过不常用这种方式罢了。  
type()和我们平常创建类和对象有什么关系呢？我们可以通过下例一探究竟：

class MyType(type):
    
        def __init__(self, child_cls, bases=None, dict=None):
            print("In MyType init")
            super(MyType, self).__init__(child_cls, bases, dict)
    
        def __new__(cls, *args, **kwargs):
            print("In MyTyPe new")
            return type.__new__(cls, *args, **kwargs)
    
        def __call__(self, *args, **kwargs):
            print("In MyType call")
            obj = self.__new__(self, args, kwargs)
            self.__init__(obj, *args, **kwargs)
    
    class Person(object, metaclass=MyType):
    
        def __init__(self, name):
            print("In Person init")
            self.name = name
    
        def __new__(cls, *args, **kwargs):
            print("In Person new",)
            return object.__new__(cls)

在上例代码中，值得注意的是：  
（1）MyType继承了type类，同时自定义了`__init__ / __new__ / __call__`方法。  
（2）Person类中有个参数metaclass，用来指定创建Person的类， 也就是metaclass指定了由MyType这个类通过实例化，创建Person这个对象。  
（3）这里多说一句，于我们而言，Person是我们定义的一个类；于MyType而言，Person是MyType创建的一个对象。

上例输出结果如下：

In MyTyPe new
    In MyType init

这可以看出我们只是定义了两个类，做了一些自定义修改。当运行上述代码时，就已经调用了MyType类的`__new__`和`__init__`方法了，也就是这时候通过MyType已经创建好了Person这个对象了。

接着我们在上例中添加一行，再运行：

obj = Person("Liu You Yuan")

运行结果如下：

In MyTyPe new
    In MyType init
    In MyType call
    In Person new
    In Person init

分析：  
（1）当执行代码obj = Person(“Liu You Yuan”)， 我们把Person看成是MyType创建的对象，那么此行代码就是在Person对象后面加了括号，这就会触发MyType类中的`__call_`\_方法，打印“In MyType call”；  
（2）此时，`__call__`中的self就是Person这个对象，通过`self.__new__ / self.__init__`主动调用了Person中的`__new__` 和`__init__`，这也就创建出了obj这个对象。  
至此，我们知道，当我们创建一个类A，并通过类A创建对象obj时，实际上是经历了两个过程：  
（1）通过元类type创建我们定义的类A。  
（2）通过类A创建对象obj。