[已解决]最后的false是怎么返回回来的？

wbzxz

1. >>> class C:
   
2.         def __init__(self, data):
   
3.                 self.data = data
   
4.         def __contains__(self,item):
   
5.                 print('ok')
   
6.                 print(item)
   
7. 
   
8.                
   
9. >>> c = C([1, 2, 3, 4, 5])
   
10. >>> 3 in c
    
11. ok
    
12. 3
    
13. False
    
14. >>> 6 in c
    
15. ok
    
16. 6
    
17. False

复制代码

请看上面这段代码，我没有在 "__contains__"方法里面写 return 语句， 为什么我在执行" 3 in c "这条语句的时候，自动返回了False呢？

最佳答案

月排行榜 / 总排行榜

FishC

2024-8-1 16:33:50

wbzxz 发表于 2024-08-01 16:33
>>> class C:
        def __init__(self, data):
                self.d ...

哈哈，看来你抓住了一个有趣的细节！让我们一起来理清楚这个逻辑。

在你的`__contains__`方法中，你返回的是`item`本身，而不是一个布尔值。对于Python来说，任何非空的一般对象（比如整数`3`、字符串、列表等）在布尔上下文中都是“真”的（即`True`），而只有以下几种情况会被视为“假”：

- `None`
- `False`
- `0`（零）
- 空的容器（如`[]`、`{}`、`()`等）

所以，在你的代码中，当你执行`3 in c`时，实际调用的是`c.__contains__(3)`，该方法打印出`ok`和`3`后，返回了`3`。因为`3`被视为“真”，因此`in`操作符最终返回`True`。

对于`None in c`，`c.__contains__(None)`返回的是`None`。`None`是“假”，所以`in`操作符返回`False`。

最后，`True in c`也是相似的道理，`c.__contains__(True)`返回`True`，而`True`被视为“真”，所以返回`True`。

总结一下：你返回的实际上是传入的`item`，然后Python根据这个值是否“真”来决定`in`运算的最终结果。如果你想更明确地控制`in`运算的返回值，可以直接返回`True`或`False`。例如：

1. def __contains__(self, item):
   
2.     print('ok')
   
3.     print(item)
   
4.     return item in self.data  # 假设你想检查 item 是否真的在 data 中

复制代码

希望这个解释能帮你搞清楚这个问题！如果还有其他问题，随时提问哦！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

跳转到最佳答案楼层

FishC

哈哈，好的问题！在Python中，当你使用`in`关键字检查一个对象是否包含某个元素时，实际上是调用该对象的`__contains__`方法。当你没有显式地返回任何值时，Python会默认返回`None`。但是，你可能会注意到你得到了`False`而不是`None`。

那么，究竟发生了什么呢？

在你的代码中，`c = C()`创建了一个对象`c`，然后你尝试在这个对象中查找`3`，实际上是执行了`c.__contains__(3)`。由于你在`__contains__`方法中没有返回任何内容，Python的默认返回是`None`。然而，对于`in`运算符来说，它的内部实现会把这个返回值与`False`进行比较。

具体来说，Python会自动处理包含关系：如果你在`__contains__`中没有返回`True`，它就会默认为`False`。换句话说，你虽然没有写返回语句，但`in`操作符的实现逻辑就是这样处理的。

所以在你执行`3 in c`时，由于`__contains__`没有返回`True`，Python就聪明地把它当成了`False`。就像一位老师问你：“你准备好了吗？”而你只是沉默着摇头，老师自然就会认为你还没准备好，不用过多解释！

希望这个解释让你笑了，也让你明白了！如果还有问题，随时问我哦！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

wbzxz

FishC 发表于 2024-8-1 16:07
哈哈，好的问题！在Python中，当你使用`in`关键字检查一个对象是否包含某个元素时，实际上是调用该对象的`_ ...

哦，那是不是可以这样理解，两个问题：
1. 虽然我定义了`__contains__`方法， 但是针对in运算符来说，它除了执行`__contains__`方法的内容之外，还要和  `__contains__` 方法的返回值，进行一次逻辑运算符是"or"的逻辑运算呢？

FishC

wbzxz 发表于 2024-08-01 16:24
哦，那是不是可以这样理解，两个问题：
1. 虽然我定 ...

哈哈，你的理解有点道理，但实际上Python内部并没有直接使用“或”运算符来处理`in`操作。我们可以这样理解：

1. 当你使用`in`运算符时，Python会调用对象的`__contains__`方法来检查某个元素是否在对象中。
2. 如果`__contains__`返回了`True`，那么`in`运算符就会返回`True`，表示元素确实在对象中。
3. 如果`__contains__`返回了`False`或者没有返回值（即默认返回`None`），Python就会将其视为`False`。

所以说，实际上`in`运算符只是在内部判断`__contains__`的返回值，看它是不是`True`。如果不是，就会返回`False`。而不是在`None`和`False`之间用“或”运算符进行逻辑运算。

可以简单地想象成这样：`in`运算符借助`__contains__`来询问对象：“这个元素在你这里吗？”然后对象要么回答“是的，我有”（返回`True`），要么答非所问（返回`None`或`False`），最后`in`运算符就根据这两种情况做出结论。

希望这个解释能更清楚！如果还有任何其他疑问，我们可以一起继续深潜哦！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

wbzxz

FishC 发表于 2024-8-1 16:24
哈哈，你的理解有点道理，但实际上Python内部并没有直接使用“或”运算符来处理`in`操作。我们可以这样 ...

1. >>> class C:
   
2.         def __init__(self, data):
   
3.                 self.data = data
   
4.         def __contains__(self,item):
   
5.                 print('ok')
   
6.                 print(item)
   
7.                 return item
   
8. 
   
9.        
   
10. >>> c = C([1, 2, 3, 4, 5])
    
11. >>> 3 in c
    
12. ok
    
13. 3
    
14. True
    
15. >>> None in c
    
16. ok
    
17. None
    
18. False
    
19. >>> True in c
    
20. ok
    
21. True
    
22. True

复制代码

但是请看我上面的代码，比如" 3 in c"这条语句，返回值是3，而不是True，按照您的说法，不是True的话，就应该返回False，而" 3 in c"这条语句实际返回的是True。请问是为什么？

FishC

wbzxz 发表于 2024-08-01 16:33
>>> class C:
        def __init__(self, data):
                self.d ...

哈哈，看来你抓住了一个有趣的细节！让我们一起来理清楚这个逻辑。

在你的`__contains__`方法中，你返回的是`item`本身，而不是一个布尔值。对于Python来说，任何非空的一般对象（比如整数`3`、字符串、列表等）在布尔上下文中都是“真”的（即`True`），而只有以下几种情况会被视为“假”：

- `None`
- `False`
- `0`（零）
- 空的容器（如`[]`、`{}`、`()`等）

所以，在你的代码中，当你执行`3 in c`时，实际调用的是`c.__contains__(3)`，该方法打印出`ok`和`3`后，返回了`3`。因为`3`被视为“真”，因此`in`操作符最终返回`True`。

对于`None in c`，`c.__contains__(None)`返回的是`None`。`None`是“假”，所以`in`操作符返回`False`。

最后，`True in c`也是相似的道理，`c.__contains__(True)`返回`True`，而`True`被视为“真”，所以返回`True`。

总结一下：你返回的实际上是传入的`item`，然后Python根据这个值是否“真”来决定`in`运算的最终结果。如果你想更明确地控制`in`运算的返回值，可以直接返回`True`或`False`。例如：

1. def __contains__(self, item):
   
2.     print('ok')
   
3.     print(item)
   
4.     return item in self.data  # 假设你想检查 item 是否真的在 data 中

复制代码

希望这个解释能帮你搞清楚这个问题！如果还有其他问题，随时提问哦！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

歌者文明清理员

楼上错误回答，应该是默认False。