第070讲：类和对象（XIII）

小古比鱼

魔法方法__contains__()用于实现成员关系的检测，当使用in和not in进行成员关系判断时便会触发该方法；魔法方法__bool__()则与布尔测试bool()相对应。这节课主要讲的是魔法方法的代偿机制，所谓代偿，就是替代+补偿，指的是当本该发挥作用的魔法方法没有被定义时，Python便会退而求其次，寻找类似的相关方法来调用，如用__getitem__()作为__iter__()和__next__()的代偿，__iter__()和__next__()作为__contains__()的代偿，__len__()作为__bool__()的代偿等，看起来有点奇怪，其实也算是一种“不得已而为之”的折衷方案吧……
比较运算相关的魔法方法包括：__lt__()（<）、__le__()（<=）、__gt__()（>）、__ge__()（>=）、__eq__()（==）、__ne__()（!=）。通过重写这些魔法方法，可以实现对两个字符串长度而非编码值的快速比较。
最后，当我们不想让某个魔法方法生效时，只需将其赋值为None，此时若该魔法方法被触发，程序便会报错。通过这种手段，我们就可以阻止某些不希望的情形（如成员关系判断等）出现，抑制了Python可能引发误会的代偿机制，进而避免了难以调试的bug，真是未雨绸缪的好主意啊！

migu_sm1

Learning....
Support 小古比鱼

Ensoleile

代偿

1. #__contains__()主要用于实现成员关系的检测，对应in、not in
   
2. class C:
   
3.     def __init__(self, data):
   
4.         self.data = data
   
5.     def __contains__(self, item):
   
6.         print('hello')
   
7.         return item in self.data
   
8. 
   
9. c =C([1, 2, 3, 4, 5])
   
10. print(3 in c)
    
11. #hello
    
12. #True
    
13. #[1, 2, 3, 4, 5]对应self.data，3对应__contains__()魔法方法中的item
    
14. 
    
15. #__contains__()代偿 P189 -> __iter__() + __next__() -> __getitem__()
    
16. class C:
    
17.     def __init__(self, data):
    
18.         self.data = data
    
19.     def __iter__(self):
    
20.         print('iter', end='->')
    
21.         self.i = 0
    
22.         return self
    
23.     def __next__(self):
    
24.         print('next', end='->')
    
25.         if self.i == len(self.data):
    
26.             raise StopIteration
    
27.         item = self.data[self.i]
    
28.         self.i += 1
    
29.         return item
    
30. 
    
31. c =C([1, 2, 3, 4, 5])
    
32. print(3 in c)
    
33. #iter->next->next->next->True
    
34. #首先调用iter将列表变为迭代器，再按个使用next拿出数据比较，直到找到的时候返回True
    
35. print(6 in c)
    
36. #iter->next->next->next->next->next->next->False
    
37. 
    
38. class C:
    
39.     def __init__(self, data):
    
40.         self.data = data
    
41.     def __getitem__(self, item):# item对应的不是3 in c中的3，而是迭代时的0,1,2....
    
42.         print('getitem', end='->')
    
43.         return self.data[item]
    
44. 
    
45. c = C([1, 2, 3, 4, 5])
    
46. print(3 in c)
    
47. # getitem->getitem->getitem->True
    
48. print(6 in c)
    
49. # getitem->getitem->getitem->getitem->getitem->getitem->False
    
50. 
    
51. #__bool__()：布尔测试 -> __len__()
    
52. class D:
    
53.     def __bool__(self):
    
54.         print('bool')
    
55.         return True
    
56. 
    
57. d = D()
    
58. print(bool(d))
    
59. # bool
    
60. # True
    
61. 
    
62. class D:
    
63.     def __init__(self, data):
    
64.         self.data = data
    
65.     def __len__(self):
    
66.         print('len')
    
67.         return len(self.data)
    
68. 
    
69. d = D('fishc')
    
70. print(bool(d))
    
71. # len
    
72. # True   长度非零则直接返回True
    
73. d = D([])
    
74. print(bool(d))
    
75. # len
    
76. # False
    
77. 
    
78. #跟比较运算相关的魔法方法：P189   <   <=   >   >=   ==   !=
    
79. class S(str):
    
80.     def __lt__(self, other):
    
81.         return len(self) < len(other)
    
82.     def __gt__(self, other):
    
83.         return len(self) > len(other)
    
84.     def __eq__(self, other):
    
85.         return len(self) == len(other)
    
86. 
    
87. s1 = S('FishC')
    
88. s2 = S('fishc')
    
89. print(s1 < s2)#False
    
90. print(s1 > s2)#False
    
91. print(s1 == s2)#True
    
92. print(s1 != s2)#True
    
93. #__eq__()只会拦截等值判断（==），返回长度比较结果，不会拦截不等值判断（！=），故不等于号两边比较的依然是字符串ASCII码是否相同
    
94. print(s1 <= s2)#True
    
95. print(s1 >= s2)#False
    
96. 
    
97. #如果不想让某个魔法方法生效，可以直接将其赋值为None
    
98. class S(str):
    
99.     def __lt__(self, other):
    
100.         return len(self) < len(other)
     
101.     def __gt__(self, other):
     
102.         return len(self) > len(other)
     
103.     def __eq__(self, other):
     
104.         return len(self) == len(other)
     
105.     __le__ = None
     
106.     __ge__ = None
     
107.     __ne__ = None
     
108. 
     
109. s1 = S('FishC')
     
110. s2 = S('fishc')
     
111. try:
     
112.     s1 != s2
     
113. except TypeError as e:
     
114.     print(e)
     
115. #'NoneType' object is not callable
     
116. 
     
117. #这种做法也适用与代偿实现，定义第一个魔法方法为None后可以使代偿不实现
     
118. class C:
     
119.     def __init__(self, data):
     
120.         self.data = data
     
121.     def __iter__(self):
     
122.         print('iter', end='->')
     
123.         self.i = 0
     
124.         return self
     
125.     def __next__(self):
     
126.         print('next', end='->')
     
127.         if self.i == len(self.data):
     
128.             raise StopIteration
     
129.         item = self.data[self.i]
     
130.         self.i += 1
     
131.         return item
     
132.     __contains__ = None#__contains__ -> __iter__() + __next__() -> __getitem__()
     
133. 
     
134. c = C([1, 2, 3, 4, 5])
     
135. try:
     
136.     print(3 in c)
     
137. except TypeError as e:
     
138.     print(e)
     
139. #'C' object is not a container

复制代码

Tzz123

Ensoleile 发表于 2023-1-7 15:27
代偿

鱼油你好，我有些地方有点看不懂，不知能不能请你解惑一下。
你的第34行代码：按个使用next拿出数据比较，比如next拿出1，则item = 1，return item后执行什么操作呢？如果是3 in item的话好像不行吧，next（）返回的类型是int，这样3 in 3 我试过了会报错。
还有就是为什么没找到会继续使用next寻找？而找到了又是如何输出True而不继续遍历完列表呢？

deep-cy

Tzz123 发表于 2023-2-16 13:01
鱼油你好，我有些地方有点看不懂，不知能不能请你解惑一下。
你的第34行代码：按个使用next拿出数据比较 ...

return item 后比较 3 == item ， 不相等就继续__next__ , 3 in  3 报错是因为后面的参数需要可迭代对象 ，没找到继续找是因为代偿机制 ，找到了就相当于 3 == 3 为True。  总结为一句话就是in运算符的机制需要后面的参数为可迭代对象。

Solo丶Hand

## __contains\_\_(self, item)

用于实现成员关系的检测,对应的运算符是in 和 not in

```python
class C:
    def __init__(self, data):
        self.data = data
    def __contains__(self, item):
        print("嗨~")
        return item in self.data

   
c = C([1, 2, 3, 4, 5])
3 in c
嗨~
True
6 in c
嗨~
False
```

### 代偿

Python在找不到`__iter__()`和`__next__()`魔法方法的情况下就会去查找`__getitem__()`方法

如果说没有实现`__contains__()`,但又使用了in和not in,namepython就会去查找`__iter__()`和`__next__()`魔法方法

```python
class C:
    def __init__(self, data):
        self.data = data
    def __iter__(self):
        print("Iter", end = ' -> ')
        self.i = 0
        return self
    def __next__(self):
        print("Next", end = ' -> ')
        if self.i == len(self.data):
            raise StopIteration
        item = self.data[self.i]
        self.i += 1
        return item

   
c = C([1, 2, 3, 4, 5])
3 in c
```

只要return和要找的值一样就结束了

如果没有`__iter__()`和`__next__()`,会去找`__getitem__()`的魔法方法

```python
class C:
    def __init__(self, data):
        self.data = data
    def __getitem__(self, index):
        print("Getitem", end = ' -> ')
        return self.data[index]

   
c = C([1, 2, 3, 4, 5])
3 in c
Getitem -> Getitem -> Getitem -> True
6 in c
Getitem -> Getitem -> Getitem -> Getitem -> Getitem -> Getitem -> False
```



## __bool\_\_()

```python
class D:
    def __bool__(self):
        print("Bool")
        return True

   
d = D()
bool(d)
Bool
True
```

代偿,如果没有定义`__bool__()`魔法方法,那么Python就会去找找是否存在`__len__()`这个魔法方法,返回值非零则是True

```python
class D:
    def __init__(self, data):
        self.data = data
    def __len__(self):
        print("Len")
        return len(self.data)

   
d =  D("Solo")
bool(d)
Len
True
bool(d)
Len
False
```

## 比较运算

1. <   `__lt__(self, other)`
2. <= `__le__(self, other)`
3. \>   `__gt__(self, other)`
4. \>= `__ge__(self, other)`
5. ==  `__eq__(self, other)`
6. !=   `__ne__(self, other)`

字符串默认比较编码值大小,修改为比较长度

```python
class S(str):
    def __lt__(self, other):
        return len(self) < len(other)
    def __gt__(self, other):
        return len(self) > len(other)
    def __eq__(self, other):
        return len(self) == len(other)
    __le__ = None
    __ge__ = None

   
s1 = S("Solo")
s2 = S("solo")
s1 < s2
False
s1 > s2
False
s1 == s2
True
s1 != s2 ##没有定义!=方法
True
s1 <= s2
Traceback (most recent call last):
  File "<pyshell#235>", line 1, in <module>
    s1 <= s2
TypeError: 'NoneType' object is not callable
```

亦又

  def __contains__(self, name):
        for student in self.students.values():
            if student.name == name:
                return student

这里返回student，是不是相当于触发之后，要进行布尔运算，得出布尔值？