guxh的python笔记八：特殊方法

 1，类的特殊方法 　

新建一个类，本章内容中的特殊方法如果不创建类或新增方法，默认使用的就是下面的类：

class Foo:
    """this is Foo"""
    typecode = 'd'

    def __init__(self, x):
        self.x = x

    def run(self):
        return self.x

f = Foo(1)

　　

__doc__：类的描述信息

print(f.__doc__)  # this is Foo

　　

__module_：对象所属modul，如果是当前执行文件的即__main__，如果是import的，可以查看所属的module

print(f.__module__)  # __main__

import pandas as pd
df = pd.DataFrame()
print(df.__module__)  # pandas.core.frame

　　

__class__：对象所属类，等效于type

print(f.__class__)   # <class '__main__.Foo'>
print(type(f))       # <class '__main__.Foo'>

　　

__dir__：

函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；

for i in dir():
    print(i)

输出为：
Foo
__annotations__
__builtins__
__cached__
__doc__
__file__
__loader__
__name__
__package__
__spec__
f

带参数时，返回参数的属性、方法列表。

for i in dir(Foo):
    print(i)

输出为：
__class__
__delattr__
__dict__
__dir__
__doc__
__eq__
__format__
__ge__
__getattribute__
__gt__
__hash__
__init__
__init_subclass__
__le__
__lt__
__module__
__ne__
__new__
__reduce__
__reduce_ex__
__repr__
__setattr__
__sizeof__
__str__
__subclasshook__
__weakref__
run
typecode

类的实例比类多了实例属性：

print(set(dir(f)) - set(dir(Foo))) # {'x'} 
print(set(dir(Foo)) - set(dir(f))) # set()

__mro__：打印类的层次结构

>>> FileNotFoundError.__mro__
(<class 'FileNotFoundError'>, <class 'OSError'>, <class 'Exception'>, <class 'BaseException'>, <class 'object'>)

__dict__：打印类/实例的属性

dict只能使用obj.__dict__，不能使用dict(obj)，因为后者会被视为字典的初始化

打印所有实例的属性(不包括类属性)：

f = Foo(1)
print(f.__dict__)   # {'x': 1}

打印所有类属性(不包括实例的属性)：

for k, v in Foo.__dict__.items():
    print(k, v)

输出为：
__module__ : __main__
__doc__ : this is Foo
typecode : d
__init__ : <function Foo.__init__ at 0x000001AC45314620>
__dict__ : <attribute '__dict__' of 'Foo' objects>
__weakref__ : <attribute '__weakref__' of 'Foo' objects> 

注意__dir__和__dict__的区别：前者显示类/实例所有的属性/方法（如果是实例显示的是类+实例的属性/方法），后者显示类/实例属性键值对（类和属性只会分别显示自己特有的）

 __call__：让类的实例变为可调用

class Foo:

    def __call__(self, *args, **kwargs):
        return 1

print(Foo()())   # 1，第一次()是实例化，第二次()是调用

　　

__get__、__set__、__delete__：描述符协议，属性的设置/取值/删除

__getattr__、__setattr__、__delattr__：动态属性的设值/取值/删除，详见类的属性

__getattribute__：获取已经存在的属性值，__getattr__是获取不存在的属性值的方法

__getitem__、__setitem__、__delitem__：[]运算符，分量的获取/设置/删除

class Foo:

    def __init__(self, components):
        self._components = sorted(components)

    def __setitem__(self, key, value):
        self._components[key] = value

    def __getitem__(self, item):
        return self._components[item]

    def __repr__(self):
        return '<Foo: {}>'.format(self._components)

访问与设置分量：

f = Foo([3, 5, 1, 9])   # <Foo: [1, 3, 5, 9]>
print(f)
print(f[1])   # 3
f[0] = 10
print(f)      # <Foo: [10, 3, 5, 9]>

　　

__enter__，__exit__：上下文管理器，先触发__enter__，再触发with代码块，最后触发__exit__

class Foo:

    def __enter__(self):
        return 'enter获取的内容'   # 可以没有返回内容

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('exit时只需的内容')


with Foo() as f:
    print(f)   # f获取的是__enter__返回的结果

输出为:
enter获取的内容
exit时只需的内容

　　

__slot__：存储实例属性方式改为元组方式

缺省存储实例属性是字典方式，在__dict__中，改为元组方式可以节省空间，但是属性范围受到slot元组限制

class Foo:
    __slots__ = ('x', 'y')

　　

__reversed__：反向迭代协议，让序列类型对象支持反向迭代，如果没有该协议，可以先把对象变成列表再用列表的反向迭代协议

class Foo:
    def __init__(self, components):
        self.components = [x*x for x in components]

    def __reversed__(self):
        return reversed(self.components)    # 委托给self.components背后的生成器

f = Foo([1, 3, 5, 7, 9])
for i in reversed(f):
    print(i)

__format__: 

_formats = {'ymd': '{d.year}-{d.month}-{d.day}',
            'mdy': '{d.month}/{d.day}/{d.year}'}

class Foo:

    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day

    def __format__(self, code):
        if code == '':
            code = 'ymd'
        fmt = _formats[code]
        return fmt.format(d=self)

f = Foo(2019, 1, 25)
print(format(f))           # 2019-1-25
print(format(f, 'mdy'))    # 1/25/2019

__new__：可以实例化时跳过构造函数

class Date:

    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day

>>>d = Date.__new__(Date)
>>>d
<__main__.Date object at 0x10b353400>
>>>d.year
AttributeError: 'Date' object has no attribute 'year'

__metaclass__：待补充

 __init__：略

__del__：略

__str__：略

__repr__：返回的内容最好符合obj = eval(repr(obj))，即返回内容可以直接用来实例化

没有定义__repr__或者__str__时，返回的是对象的内存地址：

class User:
    def __init__(self, user_id):
        self.user_id = user_id
u = User(3)
print(u)     # <__main__.User object at 0x000002E85D7383C8>

使用猴子补丁定义__repr__，再打印u：

def repr(instance):
    return 'User({})'.format(instance.user_id)
User.__repr__ = repr
u = User(3)
print(u)     # User(3)

u的repr返回内容可以直接拿来实例化：

u1 = eval(repr(u)) 
print(u1)       # User(3)
print(u is u1)  # False，u和u1不是同一个实例

__contain__：in测试首先调用的特殊方法，下面自建了一个类似字典的Dict类，但是in测试测的是key，而不是values：

class Dict:

    def __init__(self, **kwargs):
        self.map = kwargs

    def __contains__(self, item):
        if item in self.map.values():
            return True

d = Dict(a=1, b=2) 
print('a' in d)  # False
print(1 in d)  # True

2，操作需要支持的特殊方法

序列：__len__，__getitem__

切片：__getitem__

迭代/元组拆包：1）__iter__；2）__getitem__（index从0开始）

可散列：__hash__，__eq__

in测试：1）__contains__；2）__iter__；3）__getitem__

描述符：__set__，__get__，__delete__ （可部分实现）

动态属性存取：__getattr__、__setattr__、__delattr__

[]分量存取：__getitem__、__setitem__、__delitem__

运算符+= ：1）__iadd__，2）__add__

上下文管理器：__enter__，__exit__

 反向迭代：__reversed__