python3 魔法方法

1. str 和 repr

用于对象的终端输出。

class test(object):

    def __init__(self):
        self.a = 100

    def __str__(self):
        return '我是__str__属性a的值为:%s' % self.a

    def __repr__(self):
        return '我是__repr__属性a的值为:%s' % self.a


t = test()
#print(t)       # 优先调用__str__,__str__没有定义，会去调用__repr__
print(str(t))   # 调用 __str__,__str__没有定义，会去调用__repr__
print(repr(t))  # 调用 __repr__
# __str__()用于显示给用户，而__repr__()用于显示给开发人员

2. cmp

此方法用于自定义两个对象的比较行为
这个方法在python3中已经被删除了。我们来学习下在python2中如何使用。
首要学习下 cmp() 这个內建函数。
```
In [7]: cmp(10,5)
Out[7]: 1

In [8]: cmp(5,10)
Out[8]: -1

In [9]: cmp(5,5)
Out[9]: 0
```
cmp()函数，接收两个参数。有如下的特点：
如果返回值为 1，代表第一个参数大于第二个参数。
如果返回值为-1，代表第一个参数小于第二个参数。
如果返回值为 0，代表第一个参数等于第二个参数。
抛出问题：如果有两个字符串，我们需要比较字符串的长度。使用cmp()函数如何达到我们的目的呢？
```
class Word(str):

    def __cmp__(self, other):

        if len(self) > len(other):
            return 1

        elif len(self) < len(other):
            return -1

        elif len(self) == len(other):
            print('----比较结果相等------')
            return 0

w1 = Word('asda')
w2 = Word('abcd')
print(w1==w2)
print(cmp(w1,w2))   # cmp函数的 两个参数都是 Word类型的时候，才会调用__cmp__方法
```
运行代码：打印了False和0.为什么第一个print没有打印True呢？而cmp()函数比较的结果是相等。
这是因为 cmp() 函数在比较的时候调用了 __cmp__ 方法，而 == 这个比较操作符，没有调用__cmp__ 方法。
如果使用 == 比较如何达到相同的效果呢？后面会介绍。
注意：__cmp__ 这个方法应该在 self > other 返回正整数。self < other 返回负整数。self == other 返回 0. 一定要严格遵守这条约定。

3. eq 、ne 、lt 、gt、le、ge

python2 中 __cmp__ 的替换方案.
__eq__ : 定义比较操作符 == 的行为
__ne__ : 定义比较操作符 != 的行为
__lt__ : 定义比较操作符 < 的行为
__gt__ : 定义比较操作符 > 的行为
__le__ : 定义比较操作符 <= 的行为
__ge__ : 定义比较操作符 >= 的行为
下面以 __eq__ 为例：如果想通过 == 来比较两个字符串的长度，应该如何做呢？
```
class Word(str):

    def __eq__(self, other):
        return len(self) == len(other)

w1 = Word('abc')
w2 = Word('jkl')

print(w1==w2)  # w1.__eq__(w2)
print(w1)
```
注意：这里，只有 Word类创建出来的字符串对象，在进行 == 比较时，才会通过比较字符串的长度得出比较结果。比如：'abc'=='def' 这样直接比较，还是用的python默认的方式进行比较的。其他的方法和 __eq__ 的用法是一样的。

4. getattr

当用户试图访问一个根本不存在（或者暂时不存在）的属性时，你可以通过这个魔法方法来定义类的行为。这个可以用于捕捉错误的拼写并且给出指引，使用废弃属性时给出警告（如果你愿意，仍然可以计算并且返回该属性），以及灵活地处理AttributeError。只有当试图访问不存在的属性时它才会被调用。
```
class Person(object):
    def __init__(self, name):
        self.name = name

    def __getattr__(self,name):
        return '%s is not exist' % name

a = Person('xiao')
print(a.age)    # 终端输出：age is not exist
```

5. getattribute

class Animal(object):

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __getattribute__(self, obj):
        if obj == 'name':
            print('-----记录日志name-------')
            return object.__getattribute__(self, obj)
        elif obj == 'age':
            print('-----记录日志age--------')
            return '禁止访问'

        elif obj == 'test':
            return object.__getattribute__(self, obj)

        elif obj == '__dict__':
            return '不允许访问！'

    def test(self):
        print("--test--")


a = Animal('xiao', 19)
print(a.name)
print(a.age)

a.test()
print(a.__dict__)
print(a.haha)

终端依次输出：
-----记录日志name-------
xiao
-----记录日志age--------
禁止访问
--test--
不允许访问！
None

print(a.name) 执行过程：
python解释器检测到 实例对象a需要访问name属性 ，
刚好，这个类重写了__getattribute__方法，
那么，程序就直接去执行__getattribute__方法,
执行完毕后，把__getattribute__方法的返回值，赋值给a.name,
最后执行print(a.name)

obj的值就是'name'这个字符串。
注意：实例对象 调用这个类的方法的时候（所有方法），也会调用 __getattribute__ 方法。
属性不存在也会触发这个 方法。

6. setattr

它允许你自定义某个属性的赋值行为，不管这个属性存在与否，也就是说你可以对任意属性的任何变化都定义自己的规则。
当给实例属性赋值的时候，这个方法会被调用。如果你在 __setattr__ 方法里面去给属性赋值，会导致无限递归。
```
class Person(object):
    def __init__(self, age):
        self.age = age

    def __setattr__(self,name,value):
        print('%s is not exist' % name)

a = Person(18)
print(a.age)
```
当创建实例对象a的时候，执行__init__方法，给实例属性age赋值，(注意：执行到这里并没有给age属性赋值),然后调用 __setattr__ 方法。继续执行 print(a.age) 语句，程序会抛出 AttributeError 这个异常，因为还没有给 name 属性赋值。应该怎么做呢？
在 __setattr__ 方法里调用下父类的 __setattr__ 的方法就行了。( object.__setattr__(self, name, value) )

7. delattr

这个魔法方法和 __setattr__ 几乎相同，只不过它是用于处理删除属性时的行为。和 __setattr__ 一样，使用它时也需要多加小心，防止产生无限递归.(在 __delattr__ 的实现中调用 del self.name 会导致无限递归)。
```
class Person(object):

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

    def __delattr__(self, name):
        print('-------删除属性--------')

a = Person('xiao')
print(a.name)
del a.name
print(a.name)
```
当代码执行到 del a.name 时(此时，并没有执行 del a.name )，会调用 __delattr__ 方法，如果想让程序继续执行 del a.name 那么需要在 __delattr__ 方法中调用父类的方法

8. reversed

用于反向迭代

class test(object):
    def __init__(self, b):  # 5 [0,1,2,3,4]

        self.b = b

    def __iter__(self):
        self.a = 0
        return self

    def __next__(self):
        if self.a < self.b:
            i = self.a
            self.a += 1
            return i
        else:
            raise StopIteration

    def __reversed__(self):
        print('hahah')
        return sorted(self, reverse=True)


it = test(10)
print(list(it))
print(list(reversed(it)))

reversed(s), 相当于 s.__reversed__().
__reversed__ 方法要求返回一个迭代器。
s 这个对象，需要实现 __reversed__ 方法。如果没有实现 __reversed__ 方法，reversed(s) 会把 s 这个对象当成一个序列处理，如果s不是序列，就会抛出类型错误异常。

9. len

返回容器的长度

class test(object):

    def __init__(self):
        self.li = [1, 2, 3]

    def __len__(self):
        print('test')
        return len(self.li)

t = test()
print(len(t))

len(t) ,实际上调用了 t 的__len__ 方法。

10. contains

定义对象通过 in 或者 not in 测试成员时的行为。

class test(object):

    def __contains__(self,item):
        print('item is {}'.format(item))
        return True

t = test()
print(1 in t)
print(1 not in t)

11. getitem

适用于序列和字典这些对象 (列表，元祖，字符串等等)

定义对象通过 self[key] 访问时的行为。

class Seq(object):

    def __getitem__(self, i):
        print("__getslice__")
        print(i)
        return 100


obj = Seq()
print(obj[1:2])
print("--------------------")
print(obj["abc"])

依次输出：
__getslice__
slice(1, 2, None)
100
--------------------
__getslice__
abc
100

12. setitem

定义对象通过 self[key] = value 赋值时的行为。

class Seq(list):

    def __setitem__(self, i, value):
        print("__getslice__")
        print(i)
        print(value)
        super().__setitem__(i, value)


obj = Seq()
obj[0:2] = [1, 2]  # 设置的值 必须是 可迭代对象
print(obj[0:2])
print("--------------------")

输出：
__getslice__
slice(0, 2, None)
[1, 2]
[1, 2]
--------------------

13. delitem

定义对象通过 del self[key] 删除时的行为。

class test(object):

    def __delitem__(self, key):
        print('key is {}'.format(key))


t = test()

del t[1]
print('--------分割线-----------')
del t['name']

python3 魔法方法

1. __str__ 和 __repr__

2. __cmp__

3. __eq__ 、__ne__ 、__lt__ 、__gt__、__le__、__ge__

4. __getattr__

5. __getattribute__

6. __setattr__

7. __delattr__

8. __reversed__

9. __len__

10. __contains__

11. __getitem__

12. __setitem__

13. __delitem__

友情链接更多精彩内容