【Python】【面向对象】类的特殊成员

class Foo:
    def __del__(self):
        print('wtf?')
        pass # 虽然这里没写如何del，但仍然从内存中删除

a = Foo()
b = a
del b # 不会触发 __del__ 因为引用数量不为0
del a # 触发 __del__，输出 "wtf?"，虽然 __del__ 方法没有指明如何删除，但仍然会从内存中删除

class Foo:
    """ 描述类信息，会被 __doc__ 打印出来 """
    def func(self):
        pass

print(Foo.__doc__)  # 输出： 描述类信息，会被 __doc__ 打印出来

class Foo:
    def __repr__(self):
        return 'repr method'


obj = Foo()
print(obj)
obj
# 输出：repr method

# __str__ 只重构与print(obj), str(obj) 相关的，会覆盖__repr__中的print功能
# __repr__ 既重构与print相关的，也重构与直接输出相关的

__getattr__(self,name) # 定义用户试图获取一个不存在的属性时的行为
__getattribute__(self,name) # 定义该类的属性被访问时的行为
__setattr__(self,name,value) # 定义当一个属性被设置时的行为
__delattr__(self,name)  # 定义当一个属性被删除时的行为

class New_int(int):
    def __add__(self, other):
        return int.__sub__(self,other) # 别用 self +/- other ， 否则无限递归
    def __sub__(self, other):
        return int.__add__(self,other)


a=New_int(5)
a+3

# 左操作数不支持相应操作时被调用，例如 1+<New_int> 这种写法
__radd__, __rsub__ , __rmul__ , __rturediv__ ,
__rfloordiv__ , __rmod__ , __rdivmod__ , __rpow__ ,
__rlshift__ , __rrshift__ , __rxor__ , __ror__

class Foo(object):

    def __getitem__(self, key):
        # 执行类似 obj[key] 的操作
        print('__getitem__', key)

    def __setitem__(self, key, value):
        # 执行类似 obj[key]=value 的操作
        print('__setitem__', key, value)

    def __delitem__(self, key):
        # 执行类似 del obj[key] 的操作
        print('__delitem__', key)

    def __len__(self):
        # 执行类似 len(obj) 的操作
        print('__len__')
        return 1  # 必须返回一个 integer ，否则报错

    def __iter__(self):
        # 执行迭代器操作
        print('__iter__')

    def __reversed__(self):
        # 执行 reversed() 操作
        print('__reversed__')

    def __contains__(self, item):
        # 执行 item in obj 和 item not in obj 操作
        print('__contains__')
        return 1  # 最后的 return 会被强制变成 bool 类型


obj = Foo()

result = obj['k1']     # 触发执行 __getitem__
obj['k2'] = 'wupeiqi'  # 触发执行 __setitem__
del obj['k1']          # 触发执行 __delitem__
len(obj)               # 触发执行 __len__
reversed(obj)          # 触发执行 __reversed__
1 in obj               # 触发执行 __contains__

it=iter([1,2,3])
next(it)
next(it)
next(it)
next(it) # 迭代到头会报一个 StopIteration 错误

class Fibs:
    def __init__(self):
        self.a = 0
        self.b = 1

    def __iter__(self):
        return self

    def __next__(self):
        self.a, self.b = self.b, self.a + self.b
        if self.a > 100: raise StopIteration
        return self.a


fibs = Fibs()

for i in fibs:
    print(i)

def myGen():
    print('生成器被执行！')
    yield 1
    yield 2

myG = myGen()
next(myG)
next(myG)
next(myG)  # 迭代到头后，会报一个 StopIteration 错误（同iter）

myG = myGen()
for i in myG:
    print(i)

def fibs():
    a, b = 0, 1
    while b < 100:
        yield b
        a, b = b, a + b


for i in fibs():
    print(i)

[i for i in fibs()]

class Resource():
    def __init__(self, filename=''):
        print('初始化 context manager, filename = {}'.format(filename))
        self.filename = filename

    def __enter__(self):
        print('获取资源, filename = {}'.format(self.filename))
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        print(f'关闭资源，异常类型 = {exc_type}, 异常值 = {exc_val}, 异常的错误栈信息 = {exc_tb}，如果主代码没有异常，三个参数都是 None')
        # return True，就相当于告诉Python解释器，主逻辑的异常我们已经捕获了，不需要再往外抛了
        # 如果 主逻辑本身就没有抛出异常，无论return True/False，都不会抛出异常
        return True

    def operate(self, num):
        1 / num  # 用来看 __exit__ 如何捕获一个错误
        print('执行某个操作，就是一个普通的方法')


# 可以同时 with 多个
with Resource('file1') as res1, Resource('file2') as res2:
    res1.operate(1)
    res2.operate(0)

初始化 context manager, filename = file1
获取资源, filename = file1
初始化 context manager, filename = file2
获取资源, filename = file2
执行某个操作，就是一个普通的方法
关闭资源，异常类型 = <class 'ZeroDivisionError'>, 异常值 = division by zero, 异常的错误栈信息 = <traceback object at 0x7fe433a88f00>，如果主代码没有异常，三个参数都是 None
关闭资源，异常类型 = None, 异常值 = None, 异常的错误栈信息 = None，如果主代码没有异常，三个参数都是 None

func.__code__.co_name  # 函数名
func.__code__.co_argcount  # 函数的参数个数，不包含*args与**kwargs
func.__code__.co_varnames  # tuple 形式的入参名，包含args，kwargs. ？有闭包时，还包含被闭包的函数名

func.__code__.co_filename  # 函数所在的文件
func.__code__.co_firstlineno  # 函数第一行在文件中的行数

func.__code__.co_kwonlyargcount  # 函数强制关键字参数个数

func.__code__.co_cellvars  # 闭包专用，外部函数中被内嵌函数调用的参数
func.__code__.co_freevars  # 闭包专用，内部函数中引用外部函数参数

# 下面这些还没查：
func.__code__.co_code  # ？似乎是编译后的二进制
func.__code__.co_consts  # ？似乎是涉及到的变量

func.__code__.co_flags
func.__code__.co_lnotab

func.__code__.co_names  # ？？
func.__code__.co_nlocals
func.__code__.co_stacksize

func.__defaults__ # 入参的默认值

# filename.py

print(__name__)
print(__file__) # 文件所在路径
print(__doc__) # 文件的注释

import filename

filename.__name__
filename.__file__
filename.__doc__