魔术方法实现场景

1.new构造方法

class F():
    def __new__(cls,*args,**kwargs):
        print('这里在原有的基础上做一点事')
        return object.__new__(cls)

说明：
1.这里由于是最开始创建对象，如果你不写由于默认继承object会自动帮你创建
2.由于你手动使用new，又在return中调用object.new，我们可以在原有的功能上进行添加
3.参数：cls——类对象
由于这个时候对象并没有生成，所以传递进去的参数是F这个类

2.init初始化方法

class Foo(object):
    def __init__(self, name):
        self.name = name
obj = Foo("武沛齐")

作用：初始化成员变量（不写系统默认创建无参数的init方法）
参数：self——实例对象

3.call方法

class Hou():
    def __call__(self):
        print('侯震宇')
# 执行方式1
Hou()()
# 执行方式2
obj1 = Hou()
obj1()
# 执行方式3
Hou.__call__(obj1)
# 执行方式4
obj1.__call__()

作用：执行实例对象的“函数功能”，实质通过括号运算符调用call方法
参数：self ——实例对象

4.str方法

class Hou:
    def __str__(self):
        print('This is Hou')
obj = Hou()  
# 方式一
print(obj)
# 方式二
print(str(obj))
# 方式三
print(Hou.__str__(Hou())
# 方式四
print(Hou().__str__())

作用：str(obj)转化对象的时候，会自动查找str方法
参数：self——实例对象

5.dict

class Hou(object):
    def __init__(self,x):
        self.name = x
    def f1(self):
        pass
    def f2(self):
        pass
obj1 = Hou(19)
# 对象只会输出 成员变量
print(obj1.__dict__)
# 类会输出所有的(包括继承的)类方法和类变量
print(Hou.__dict__)

注意：dict不是方法！不是方法！不是方法！
原因：Hou.dict后面没有括号
如果是对象：dict输出的是成员变量
如果是类对象：dict输出的是所有的类变量和方法
对象的本质就是字典，所以它是可哈希的

6.getitem、setitem、delitem(重载运算符)[]

class Foo(object):
    def __init__(self,name,age):
        self.x1 = name
        self.x2 = age
        self.x3 = 0
    def __getitem__(self, key):
        if key == 'x1':
            return self.name
    def __setitem__(self, key, value):
        if key == 'x2':
            self.x1 = value
    def __delitem__(self, key):
        if key == 'x3':
            del self.x3
obj = Foo("武沛齐", 19)
print(obj["x1"])
obj['x2'] = 123
print(obj.x2)
del obj['x3']
print(obj.x3)

说明：
getitem:除self外，一个参数，调用格式为：obj[参数]
setitem:除self外，两个参数，调用格式为：obj[参数1]=参数2
delitem:除self外，一个参数，调用格式为：del obj[参数]

7.enter和exit方法：

class Foo(object):
    def __enter__(self):
        print("进入了")
        return 666
    def __exit__(self, exc_type, exc_val, exc_tb):
        print("出去了")
obj = Foo()
with obj as data:
    print(data)
"""过程分析：
1.with 后面跟的必须是一个对象 这里可以等价替换为with FOO() as data:
2.obj进入这个对象执行__enter__方法
3.enter方法执行的return结果返回给data
4.with后面的语句开始执行
5.执行完后，进入obj对象中执行__exit__方法
"""

8.add方法（重载运算符+）

class F():
    def __init__(self,num):
        self.num1 = num
    def add(self,other):
        return '{}+{}*i'.format(self.num1,other)
num1 = F(3)
num2 = F(5)
print(num1 + num2)

重载加法：从左到右次序，诸如此类重载运算符还有：




https://blog.csdn.net/zhangshuaijun123/article/details/82149056

9.getattr与setattr方法

class Comp():
    def __init__(self, real, imag):
        self._real = real
        self._imag = imag
    def __getattr__(self, key):
        if key == 'Real':
            return self._real
        return object.__getattribute__(self, key)
    def __setattr__(self, key, value):
        if key == 'real':
            # print(123,key,value)
            self._real = value
            # print(self._real)
        elif key == 'imag':
            self._imag = value
        else:
            # 如果不是上述内容，使用初始化定义
            object.__setattr__(self,key,value)
    def __str__(self):
        return '{}+{}i'.format(self._real, self._imag)

注意：getattr和setattr会对.运算进行重载，这个比较危险
1.setattr在设定的时候，一定要注明：如果出现其他情况object.getattr(self,key,value)
这个没有返回值，a.x = b
普通的这个句式只是进行了一个操作运算

2.getattr在设定的时候，一定要注明：如果出现其他情况
return object.getattr(self,key,value)
这个具有返回值，a.x
普通句式是获取a.x的内容，需要返回值

3.getattr的key是字符串，setattr的key是字符串，value是本身类型

4.getattr和@property发生冲突时，
由于a.x 事实上判定为函数，所以@property把方法伪装成属性，更贴近函数
所以property覆盖了getattr导致它不执行

5.setattr和@setter发生冲突的时候，setattr覆盖了后者
在object.setattr中应该使用了装饰器@setter,如果
setattr自己写会导致主不调用装饰器
两个在一起，判定setattr覆盖@setter

10.getattr(),setattr(),hasattr(),delattr()

getattr(对象，’成员名称’)：和getattr一样，这个在外部，那个在内部
这个实际上就是外部调用object.getattr(对象，’成员名称’)
setattr(对象，’成员名称’，值)：同上
hasattr(对称，’成员名称’)：这个内部调用的也是object.getattr(对象，’成员名称’)
delattr(对象，’成员名称’)：一样

11.迭代器与可迭代对象

1.iter方法

类对象中加入了，iter方法后
类对象就变成了可迭代对象

具体表现为：for i in obj # obj是个可迭代对象
这个流程是：先进入obj中查找iter(self)方法
然后根据iter中的指示，进入后续环节

2.next方法

类对象中加入了，next方法后，
如果里面有iter方法，这就是一个迭代器
具体表现为：for i in obj # obj是个迭代器
具体流程为：先进入obj中查找iter（self）方法
此时返回的是self 自己本身，接下来再次进入这个对象，查找next方法，
将return的结果赋值给i

class PositiveRange(object):
    def __init__(self, *args):
        self.step = 1
        self.counter = 0
        if len(args) == 1:
            self.end = args[0]
        elif len(args) == 2:
            self.counter = args[0] - self.step  # 这里要取头，因为后面直接next的
            self.end = args[1]
        elif len(args) == 3:
            self.end = args[1]
            self.step = args[2]
            self.counter = args[0] - self.step
    def __iter__(self):
        return self
    def __next__(self):
        self.counter += self.step
        if self.counter > self.end : # 这里要取尾
            raise StopIteration()
        return self.counter
for item in PositiveRange(10,50,2):  # 循环可迭代对象时，内部先执行obj.__iter__并获取迭代器对象；不断地执行迭代器对象的next方法。
    print('{: <5}'.format(item),end= '')