我试图了解any()和all()Python 内置函数是如何工作的。
我正在尝试比较元组，以便如果任何值不同，它将返回True，如果它们都相同，它将返回False。在这种情况下，他们如何返回 [False, False, False]？
d是一个defaultdict(list)。
print d['Drd2']
# [[1, 5, 0], [1, 6, 0]]
print list(zip(*d['Drd2']))
# [(1, 1), (5, 6), (0, 0)]
print [any(x) and not all(x) for x in zip(*d['Drd2'])]
# [False, False, False]
据我所知，这应该输出
# [False, True, False]
因为（1,1）相同，（5,6）不同，（0,0）相同。
为什么它对所有元组评估为 False？
您可以粗略地将any和分别all视为一系列逻辑or和and运算符。
任何
anyTrue当至少有一个元素是 Truthy时将返回。阅读真值测试。
全部
allTrue只有当所有元素都为真时才会返回。
真值表
+-----------------------------------------+---------+---------+
| | any | all |
+-----------------------------------------+---------+---------+
| All Truthy values | True | True |
+-----------------------------------------+---------+---------+
| All Falsy values | False | False |
+-----------------------------------------+---------+---------+
| One Truthy value (all others are Falsy) | True | False |
+-----------------------------------------+---------+---------+
| One Falsy value (all others are Truthy) | True | False |
+-----------------------------------------+---------+---------+
| Empty Iterable | False | True |
+-----------------------------------------+---------+---------+
注1：空的iterable case在官方文档中有解释，像这样
True如果可迭代的任何元素为真，则返回。如果可迭代对象为空，则返回False
由于没有一个元素是真的，它False在这种情况下返回。
True如果可迭代对象的所有元素都为真（或者可迭代对象为空），则返回。
由于没有一个元素是假的，所以True在这种情况下它会返回。
笔记2：
any另一件需要了解的重要事情all是，一旦他们知道结果，它就会使执行短路。优点是，不需要消耗整个可迭代对象。例如，
>>> multiples_of_6 = (not (i % 6) for i in range(1, 10))
>>> any(multiples_of_6)
True
>>> list(multiples_of_6)
[False, False, False]
这里，(not (i % 6) for i in range(1, 10))是一个生成器表达式，True如果当前的数字在 1 和 9 之间是 6 的倍数，则返回。any迭代multiples_of_6并且当它遇到时6，它找到一个真值，所以它立即返回True，其余的multiples_of_6不迭代。这就是我们在打印时看到的，和list(multiples_of_6)的结果。789
这个优秀的东西在这个答案中被非常巧妙地使用了。
有了这个基本的了解，如果我们看一下你的代码，你就知道了
any(x) and not all(x)
这确保了至少其中一个值是真实的，但不是全部。这就是它回归的原因[False, False, False]。如果您真的想检查两个数字是否不相同，
print [x[0] != x[1] for x in zip(*d['Drd2'])]
Python
any和all函数是如何工作的？
any如果有任何和所有（分别）元素是，则all获取迭代并返回。TrueTrue
>>> any([0, 0.0, False, (), '0']), all([1, 0.0001, True, (False,)])
(True, True) # ^^^-- truthy non-empty string
>>> any([0, 0.0, False, (), '']), all([1, 0.0001, True, (False,), {}])
(False, False) # ^^-- falsey
如果可迭代对象为空，则any返回False和all返回True。
>>> any([]), all([])
(False, True)
all我今天在课堂上any为学生做示范。他们大多对空迭代的返回值感到困惑。以这种方式解释它导致很多灯泡打开。
他们any和all都寻找允许他们停止评估的条件。我给出的第一个示例要求他们评估整个列表中每个元素的布尔值。
（请注意，列表文字本身并不是惰性求值的——你可以用迭代器得到它——但这只是为了说明目的。）
这是任何和所有的 Python 实现：
def any(iterable):
for i in iterable:
if i:
return True
return False # for an empty iterable, any returns False!
def all(iterable):
for i in iterable:
if not i:
return False
return True # for an empty iterable, all returns True!
当然，真正的实现是用 C 语言编写的，并且性能要高得多，但是您可以替换上面的内容并在此（或任何其他）答案中的代码中获得相同的结果。
allall检查元素是False（所以它可以返回False），True如果它们都不是，则返回False。
>>> all([1, 2, 3, 4]) # has to test to the end!
True
>>> all([0, 1, 2, 3, 4]) # 0 is False in a boolean context!
False # ^--stops here!
>>> all([])
True # gets to end, so True!
any工作方式any是它检查元素是否存在True（因此它可以返回True), then it returnsFalse if none of them wereTrue`。
>>> any([0, 0.0, '', (), [], {}]) # has to test to the end!
False
>>> any([1, 0, 0.0, '', (), [], {}]) # 1 is True in a boolean context!
True # ^--stops here!
>>> any([])
False # gets to end, so False!
我认为，如果您牢记捷径行为，您将直观地了解它们的工作原理，而无需参考真值表。
all和any捷径：首先，创建一个noisy_iterator：
def noisy_iterator(iterable):
for i in iterable:
print('yielding ' + repr(i))
yield i
现在让我们使用我们的示例来嘈杂地遍历列表：
>>> all(noisy_iterator([1, 2, 3, 4]))
yielding 1
yielding 2
yielding 3
yielding 4
True
>>> all(noisy_iterator([0, 1, 2, 3, 4]))
yielding 0
False
我们可以all在第一次 False 布尔检查时看到停止。
并any在第一次 True 布尔检查时停止：
>>> any(noisy_iterator([0, 0.0, '', (), [], {}]))
yielding 0
yielding 0.0
yielding ''
yielding ()
yielding []
yielding {}
False
>>> any(noisy_iterator([1, 0, 0.0, '', (), [], {}]))
yielding 1
True
让我们看一下来源以确认上述内容。
以下是 的来源any：
static PyObject *
builtin_any(PyObject *module, PyObject *iterable)
{
PyObject *it, *item;
PyObject *(*iternext)(PyObject *);
int cmp;
it = PyObject_GetIter(iterable);
if (it == NULL)
return NULL;
iternext = *Py_TYPE(it)->tp_iternext;
for (;;) {
item = iternext(it);
if (item == NULL)
break;
cmp = PyObject_IsTrue(item);
Py_DECREF(item);
if (cmp < 0) {
Py_DECREF(it);
return NULL;
}
if (cmp > 0) {
Py_DECREF(it);
Py_RETURN_TRUE;
}
}
Py_DECREF(it);
if (PyErr_Occurred()) {
if (PyErr_ExceptionMatches(PyExc_StopIteration))
PyErr_Clear();
else
return NULL;
}
Py_RETURN_FALSE;
}
这是来源all：
static PyObject *
builtin_all(PyObject *module, PyObject *iterable)
{
PyObject *it, *item;
PyObject *(*iternext)(PyObject *);
int cmp;
it = PyObject_GetIter(iterable);
if (it == NULL)
return NULL;
iternext = *Py_TYPE(it)->tp_iternext;
for (;;) {
item = iternext(it);
if (item == NULL)
break;
cmp = PyObject_IsTrue(item);
Py_DECREF(item);
if (cmp < 0) {
Py_DECREF(it);
return NULL;
}
if (cmp == 0) {
Py_DECREF(it);
Py_RETURN_FALSE;
}
}
Py_DECREF(it);
if (PyErr_Occurred()) {
if (PyErr_ExceptionMatches(PyExc_StopIteration))
PyErr_Clear();
else
return NULL;
}
Py_RETURN_TRUE;
}
我知道这很旧，但我认为在代码中显示这些函数的样子可能会有所帮助。这确实说明了逻辑，比文本或表格 IMO 更好。实际上，它们是用 C 而不是纯 Python 实现的，但它们是等价的。
def any(iterable):
for item in iterable:
if item:
return True
return False
def all(iterable):
for item in iterable:
if not item:
return False
return True
特别是，您可以看到空迭代的结果只是自然结果，而不是特殊情况。您还可以看到短路行为；实际上，不发生短路会做更多的工作。
当 Guido van Rossum（Python 的创建者）第一次提出添加any()andall()时，他只是通过发布上面的代码片段来解释它们。
您要询问的相关代码来自我在此处给出的答案。它旨在解决比较多个位数组的问题 - 即1和的集合0。
any并且all当您可以依赖值的“真实性”时很有用 - 即它们在布尔上下文中的值。1 是True0 是False，答案利用了便利性。5 恰好也是True，所以当你把它混合到你可能的输入中时......好吧。不工作。
您可以改为执行以下操作：
[len(set(x)) > 1 for x in zip(*d['Drd2'])]
它缺乏前一个答案的美感（我真的很喜欢 的外观any(x) and not all(x)），但它完成了工作。
>>> any([False, False, False])
False
>>> any([False, True, False])
True
>>> all([False, True, True])
False
>>> all([True, True, True])
True
s = "eFdss"
s = list(s)
all(i.islower() for i in s ) # FALSE
any(i.islower() for i in s ) # TRUE
all() 函数用于检查集合的每个成员是否为真。例如，all() 函数可用于更简洁地对以下形式的语句进行条件化：
if all entre's are vegan this is a vegan restaurant
在代码中：
restaurant_is_vegan = all(x is vegan for x in menu)
如果菜单（迭代器）上的每个项目 (x) 对于条件（是素食主义者；x == 素食主义者）的计算结果为 True，则 all 语句将计算为 True。
更多示例：https ://www.alpharithms.com/python-all-function-223809/
这个概念很简单：
M =[(1, 1), (5, 6), (0, 0)]
1) print([any(x) for x in M])
[True, True, False] #only the last tuple does not have any true element
2) print([all(x) for x in M])
[True, True, False] #all elements of the last tuple are not true
3) print([not all(x) for x in M])
[False, False, True] #NOT operator applied to 2)
4) print([any(x) and not all(x) for x in M])
[False, False, False] #AND operator applied to 1) and 3)
# if we had M =[(1, 1), (5, 6), (1, 0)], we could get [False, False, True] in 4)
# because the last tuple satisfies both conditions: any of its elements is TRUE
#and not all elements are TRUE
list = [1,1,1,0]
print(any(list)) # will return True because there is 1 or True exists
print(all(list)) # will return False because there is a 0 or False exists
return all(a % i for i in range(3, int(a ** 0.5) + 1)) # when number is divisible it will return False else return True but the whole statement is False .