python面向对象中的魔法方法和类与对象

python面向对象中的魔法方法和类与对象

一,魔法方法

1.init

__init__方法可以简单的理解为类的构造方法（实际并不是构造方法，只是在类生成对象之后就会被执行），之前已经在上一篇博客中说明过了。

2.del

__del__方法是类中的析构方法，当对象消亡的时候（被解释器的垃圾回收的时候会执行这个方法）这个方法默认是不需要写的，不写的时候，默认是不做任何操作的。因为你不知道对象是在什么时候被垃圾回收掉，所以，除非你确实要在这里面做某些操作，不然不要自定义这个方法。

3.call

__call__方法在类的对象被执行的时候（obj()或者 类()()）会执行。

4.int

__int__方法，在对象被int()包裹的时候会被执行，例如int(obj)如果obj对象没有、__int__方法，那么就会报错。在这个方法中返回的值被传递到int类型中进行转换。

5.str

__str__方法和int方法一样，当对象被str(obj)包裹的时候，如果对象中没有这个方法将会报错，如果有这个方法，str()将接收这个方法返回的值在转换成字符串。

6.add

__add__方法在两个对象相加的时候，调用第一个对象的__add__方法，将第二个对象传递进来，至于怎么处理以及返回值，那是程序员自定义的，就如下面的例子：

class abc:
    def __init__(self,age):
        self.age=age
    def __add__(self,obj):
        return self.age+obj.age
a1=abc(18)
a2=abc(20)
print(a1+a2)
#执行结果：38

7.dict

__dict__方法在类里面有，在对象里面也有，这个方法是以字典的形式列出类或对象中的所有成员。就像下面的例子：

class abc:
    def __init__(self,age):
        self.age=age
    def __add__(self,obj):
        return self.age+obj.age
a1=abc(18)
print(abc.__dict__)
print(a1.__dict__)
#执行结果：
{'__add__': <function abc.__add__ at 0x0000020666C9E2F0>, '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'abc' objects>, '__init__': <function abc.__init__ at 0x0000020666C9E268>, '__doc__': None, '__dict__': <attribute '__dict__' of 'abc' objects>}
{'age': 18}

8.getitem setitem delitem

__getitem__方法匹配 对象[索引] 这种方式，__setitem__匹配 对象[索引]=value 这种方式，__delitem__匹配 del 对象[索引] 这种方式，例子如下:

class Foo:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __getitem__(self, item):  # 匹配:对象[item]这种形式
        return item+10
    def __setitem__(self, key, value):  # 匹配:对象[key]=value这种形式
        print(key,value)
    def __delitem__(self, key):  # 匹配:del 对象[key]这种形式
        print(key)
 
li=Foo("alex",18)
print(li[10])
li[10]=100
del li[10]
执行结果：
20
10 100
10

9.getslice setslice delslice

这三种方式在python2.7中还存在，用来对对象进行切片的，但是在python3之后，将这些特殊方法给去掉了，统一使用上面的方式对对象进行切片，因此在使用__getitem__ setitem 这两个方法之前要先判断传递进参数的类型是不是slice对象。例子如下：

class Foo:
    def __init__(self,name,age):
        self.name=name
        self.age=age
        self.li=[1,2,3,4,5,6,7]
    def __getitem__(self, item):  # 匹配:对象[item]这种形式
        if isinstance(item,slice):  # 如果是slice对象，返回切片后的结果
            return self.li[item]  # 返回切片结果
        elif isinstance(item,int):  # 如果是整形，说明是索引
            return item+10
    def __setitem__(self, key, value):  # 匹配:对象[key]=value这种形式
        print(key,value)
    def __delitem__(self, key):  # 匹配:del 对象[key]这种形式
        print(key)
    def __getslice__(self,index1,index2):
        print(index1,index2)
 
li=Foo("alex",18)
print(li[3:5])
#执行结果：
[4, 5]

10.iter

类的对象如果想要变成一个可迭代对象，那么对象中必须要有__iter__方法，并且这个方法返回的是一个迭代器。

for 循环的对象如果是一个可迭代的对象，那么会先执行对象中的__iter__方法，获取到迭代器，然后再执行迭代器中的__next__方法获取数据。如果for循环的是一个迭代器，那么直接执行迭代器中的__next__方法。

class Foo:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __iter__(self):
        return iter([1,2,3,4,5])  # 返回的是一个迭代器
li=Foo("alex",18)
 
# 1.如果类中有__iter__方法，他的对象就是可迭代对象
# 2.对象.__iter()的返回值是一个迭代器
# 3.for循环的如果是迭代器，直接执行.next方法
# 4.for循环的如果是可迭代对象，先执行对象.__iter()，获取迭代器再执行next
 
for i in li:
    print(i)
#执行结果：
1
2
3
4
5

11.isinstance和issubclass

之前讲过isinstance可以判断一个变量是否是某一种数据类型，其实，isinstance不只可以判断数据类型，也可以判断对象是否是这个类的对象或者是这个类的子类的对象，代码如下：

class Foo:
    def __init__(self,name,age):
        self.name=name
        self.age=age
class Son(Foo):
    pass
obj=Son("xiaoming",18)
print(isinstance(obj,Foo))
执行结果：True

issubclass用来判断一个类是否是某个类的子类，返回的是一个bool类型数据，代码如下：

class Foo:
    def __init__(self,name,age):
        self.name=name
        self.age=age
class Son(Foo):
    pass
obj=Son("xiaoming",18)
print(issubclass(Son,Foo))
执行结果：True

二,类与对象

new__和__metaclass

在python中，一切皆对象，我们定义的类其实。。。也是一个对象，那么，类本身是谁的对象呢？在python2.2之前（或者叫经典类中），所有的类，都是class的对象，但是在新式类中，为了将类型（int,str,float等）和类统一，所以，所有的类都是type类型的对象。当然，这个规则可以被修改，在类中有一个属性 metaclass 可以指定当前类该由哪个类进行实例化。而创建对象过程中，其实构造器不是__init__方法，而是__new__方法，这个方法会返回一个对象，这才是对象的构造器。下面是一个解释类实例化对象内部实现过程的代码段：

class Mytype(type):
    def __init__(self, what, bases=None, dict=None):
        super(Mytype,self).__init__(what, bases, dict)
    def __call__(self, *args, **kwargs):
        obj=self.__new__(self)
        self.__init__(obj, *args, **kwargs)
        return obj
class Foo:
    __metaclass__=Mytype
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __new__(cls, *args, **kwargs):
        return object.__new__(cls)
obj=Foo("xiaoming",18)
print(obj.name,obj.age)
执行结果：xiaoming 18