or和Python语句需要真值。对于panda，这些被认为是不明确的，因此应该使用“按位”|（或）或&（和）操作：

df = df[(df['col'] < -0.25) | (df['col'] > 0.25)]

对于这些类型的数据结构，它们被重载，以生成元素或和。

只是为了给这句话补充一些解释：

当你想得到熊猫的嘘声时，会抛出异常。系列：

>>> import pandas as pd
>>> x = pd.Series([1])
>>> bool(x)
ValueError: The truth value of a Series is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().

您到达了一个位置，在该位置运算符隐式地将操作数转换为布尔值（您使用了或，但它也适用于和、if和while）：

>>> x or x
ValueError: The truth value of a Series is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().
>>> x and x
ValueError: The truth value of a Series is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().
>>> if x:
...     print('fun')
ValueError: The truth value of a Series is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().
>>> while x:
...     print('fun')
ValueError: The truth value of a Series is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().

除了这四个语句之外，还有几个Python函数隐藏了一些bool调用（比如any、all、filter…）。pandas.Series通常不会有问题，但为了完整起见，我想提一下这些。

在您的案例中，例外并没有真正的帮助，因为它没有提到正确的替代方案。对于和和或，如果要按元素进行比较，可以使用：

numpy.logical_或：>>>将numpy导入为np>>>np.逻辑或（x，y）或简单地使用|运算符：>>>x |年numpy.logical_and：>>>np.逻辑和（x，y）或简单地使用&运算符：>>>x和y

如果您使用的是运算符，请确保正确设置括号，因为运算符优先。

有几个逻辑NumPy函数可以在pandas.Series上工作。

如果在执行if或while时遇到异常，则异常中提到的备选方案更适合。我将很快解释其中的每一个：

如果要检查系列是否为空：>>>x=pd.系列（[]）>>>x.空真的>>>x=pd.系列（[1]）>>>x.空错误如果没有明确的布尔解释，Python通常会将容器的长度（如列表、元组等）解释为真值。因此，如果您想进行类似Python的检查，可以这样做：如果x.size或如果不是x.empty，而不是如果x。如果“系列”包含且仅包含一个布尔值：>>>x=pd.系列（[100]）>>>（x>50）.bool（）真的>>>（x<50）.bool（）错误如果您想检查Series的第一项也是唯一一项（例如.bool（），但它甚至适用于非布尔内容）：>>>x=pd.系列（[100]）>>>x.项（）100如果要检查所有或任何项目是否不为零、不为空或不为False：>>>x=pd.系列（[0，1，2]）>>>x.all（）#因为一个元素为零错误>>>x.any（）#，因为一个（或多个）元素非零真的

对于布尔逻辑，请使用&和|。

np.random.seed(0)
df = pd.DataFrame(np.random.randn(5,3), columns=list('ABC'))

>>> df

          A         B         C
0  1.764052  0.400157  0.978738
1  2.240893  1.867558 -0.977278
2  0.950088 -0.151357 -0.103219
3  0.410599  0.144044  1.454274
4  0.761038  0.121675  0.443863

>>> df.loc[(df.C > 0.25) | (df.C < -0.25)]

          A         B         C
0  1.764052  0.400157  0.978738
1  2.240893  1.867558 -0.977278
3  0.410599  0.144044  1.454274
4  0.761038  0.121675  0.443863

要查看正在发生的情况，您将为每个比较获得一列布尔值，例如。，

df.C > 0.25

0     True
1    False
2    False
3     True
4     True
Name: C, dtype: bool

当您有多个条件时，将返回多个列。这就是联接逻辑不明确的原因。使用和或或单独处理每一列，因此首先需要将该列减少为一个布尔值。例如，查看每个列中的任何值或所有值是否为True。

# Any value in either column is True?
(df.C > 0.25).any() or (df.C < -0.25).any()

True

# All values in either column is True?
(df.C > 0.25).all() or (df.C < -0.25).all()

False

实现相同目的的一种复杂方式是将所有这些列压缩在一起，并执行适当的逻辑。

>>> df[[any([a, b]) for a, b in zip(df.C > 0.25, df.C < -0.25)]]

          A         B         C
0  1.764052  0.400157  0.978738
1  2.240893  1.867558 -0.977278
3  0.410599  0.144044  1.454274
4  0.761038  0.121675  0.443863

有关详细信息，请参阅文档中的布尔索引。

或者，也可以使用操作员模块。更多详细信息请参见Python文档：

import operator
import numpy as np
import pandas as pd

np.random.seed(0)
df = pd.DataFrame(np.random.randn(5,3), columns=list('ABC'))
df.loc[operator.or_(df.C > 0.25, df.C < -0.25)]

          A         B         C
0  1.764052  0.400157  0.978738
1  2.240893  1.867558 -0.977278
3  0.410599  0.144044  1.454274
4  0.761038  0.121675  0.4438

这个出色的答案很好地解释了正在发生的事情，并提供了解决方案。我想添加另一种可能适用于类似情况的解决方案：使用查询方法：

df = df.query("(col > 0.25) or (col < -0.25)")

请参见索引和选择数据。

（我目前正在使用的数据帧的一些测试表明，这种方法比在一系列布尔运算中使用逐位运算符要慢一点：2毫秒对870µs）

一条警告：至少有一种情况是列名恰好是Python表达式，这一点并不简单。我的列名为WT_38hph_IP_2、WT_38ph_input_2和log2（WT_38kph_IP_2/WT_38lph_input_2），希望执行以下查询：“（log2（WT_38hph_IP_2/WT_38hph_input_3）>1）和（WT_38h ph_IP_2>20）”

我获得了以下异常级联：

键错误：“log2”UndefinedVariableError:未定义名称“log2”ValueError:“log2”不是受支持的函数

我想发生这种情况是因为查询解析器试图从前两列中提取一些内容，而不是用第三列的名称来标识表达式。

这里提出了一种可能的解决方法。

Pandas使用位&|。此外，每个条件都应该包装在（）内。

这是有效的：

data_query = data[(data['year'] >= 2005) & (data['year'] <= 2010)]

但没有括号的相同查询不会：

data_query = data[(data['year'] >= 2005 & data['year'] <= 2010)]

我遇到了同样的错误，并在PySpark数据帧中停滞了几天。由于我比较了两个字段中的整数值，所以通过用0填充na值，我成功地解决了这个问题。

您需要在panda中使用按位运算符|而不是或和&，而不是和。您不能简单地使用python中的bool语句。

对于非常复杂的过滤，请创建一个掩码并在数据帧上应用该掩码。将所有查询放入掩码并应用它，

mask = (df["col1"]>=df["col2"]) & (stock["col1"]<=df["col2"])
df_new = df[mask]

一件小事，浪费了我的时间。

将条件（如果使用“=”，“！=”进行比较）放在括号中。未能做到这一点也会引发这种例外。

这将起作用：

df[(some condition) conditional operator (some conditions)]

这不会：

df[some condition conditional-operator some condition]

我将尝试给出三种最常见的方法的基准（上面也提到过）：

from timeit import repeat

setup = """
import numpy as np;
import random;
x = np.linspace(0,100);
lb, ub = np.sort([random.random() * 100, random.random() * 100]).tolist()
"""
stmts = 'x[(x > lb) * (x <= ub)]', 'x[(x > lb) & (x <= ub)]', 'x[np.logical_and(x > lb, x <= ub)]'

for _ in range(3):
    for stmt in stmts:
        t = min(repeat(stmt, setup, number=100_000))
        print('%.4f' % t, stmt)
    print()

结果：

0.4808 x[(x > lb) * (x <= ub)]
0.4726 x[(x > lb) & (x <= ub)]
0.4904 x[np.logical_and(x > lb, x <= ub)]

0.4725 x[(x > lb) * (x <= ub)]
0.4806 x[(x > lb) & (x <= ub)]
0.5002 x[np.logical_and(x > lb, x <= ub)]

0.4781 x[(x > lb) * (x <= ub)]
0.4336 x[(x > lb) & (x <= ub)]
0.4974 x[np.logical_and(x > lb, x <= ub)]

但是，熊猫系列不支持*，NumPy Array比熊猫数据帧快（大约慢1000倍，见数字）：

from timeit import repeat

setup = """
import numpy as np;
import random;
import pandas as pd;
x = pd.DataFrame(np.linspace(0,100));
lb, ub = np.sort([random.random() * 100, random.random() * 100]).tolist()
"""
stmts = 'x[(x > lb) & (x <= ub)]', 'x[np.logical_and(x > lb, x <= ub)]'

for _ in range(3):
    for stmt in stmts:
        t = min(repeat(stmt, setup, number=100))
        print('%.4f' % t, stmt)
    print()

结果：

0.1964 x[(x > lb) & (x <= ub)]
0.1992 x[np.logical_and(x > lb, x <= ub)]

0.2018 x[(x > lb) & (x <= ub)]
0.1838 x[np.logical_and(x > lb, x <= ub)]

0.1871 x[(x > lb) & (x <= ub)]
0.1883 x[np.logical_and(x > lb, x <= ub)]

注意：添加一行代码x=x.to_numpy（）大约需要20µs。

对于喜欢%timeit的人：

import numpy as np
import random
lb, ub = np.sort([random.random() * 100, random.random() * 100]).tolist()
lb, ub
x = pd.DataFrame(np.linspace(0,100))

def asterik(x):
    x = x.to_numpy()
    return x[(x > lb) * (x <= ub)]

def and_symbol(x):
    x = x.to_numpy()
    return x[(x > lb) & (x <= ub)]

def numpy_logical(x):
    x = x.to_numpy()
    return x[np.logical_and(x > lb, x <= ub)]

for i in range(3):
    %timeit asterik(x)
    %timeit and_symbol(x)
    %timeit numpy_logical(x)
    print('\n')

结果：

23 µs ± 3.62 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
35.6 µs ± 9.53 µs per loop (mean ± std. dev. of 7 runs, 100000 loops each)
31.3 µs ± 8.9 µs per loop (mean ± std. dev. of 7 runs, 100000 loops each)


21.4 µs ± 3.35 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
21.9 µs ± 1.02 µs per loop (mean ± std. dev. of 7 runs, 100000 loops each)
21.7 µs ± 500 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)


25.1 µs ± 3.71 µs per loop (mean ± std. dev. of 7 runs, 100000 loops each)
36.8 µs ± 18.3 µs per loop (mean ± std. dev. of 7 runs, 100000 loops each)
28.2 µs ± 5.97 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

我在这个命令中遇到了一个错误：

if df != '':
    pass

但当我把它改成这样时，它起了作用：

if df is not '':
    pass

如果您有多个值：

df['col'].all()

如果只有一个值：

df['col'].item()

这是初学者在Pandas中创建多个条件时非常常见的问题。一般来说，有两种可能的情况导致此错误：

条件1：Python运算符优先级

有一段布尔索引|索引和选择数据-panda文档解释了这一点：

另一个常见的操作是使用布尔向量来过滤数据。运算符为：| for or，&for and，~ for not。这些必须使用括号进行分组。默认情况下，Python会将df['A']>2&df['B']<3这样的表达式求值为df['A']>（2&df['B']）<3，而所需的求值顺序是（df['A']>2）&（df['B']<3）。

# Wrong
df['col'] < -0.25 | df['col'] > 0.25

# Right
(df['col'] < -0.25) | (df['col'] > 0.25)

有一些可能的方法可以去掉括号，稍后我将介绍这一点。

条件2：操作员/声明不当

正如前面的报价中所解释的，您需要使用| for or、&for and和~ for not。

# Wrong
(df['col'] < -0.25) or (df['col'] > 0.25)

# Right
(df['col'] < -0.25) | (df['col'] > 0.25)

另一种可能的情况是在if语句中使用布尔级数。

# Wrong
if pd.Series([True, False]):
    pass

很明显，Python if语句接受类似布尔的表达式，而不是Pandas系列。您应该根据需要使用错误消息中列出的pandas.Series.any或方法将Series转换为值。

例如：

# Right
if df['col'].eq(0).all():
    # If you want all column values equal to zero
    print('do something')

# Right
if df['col'].eq(0).any():
    # If you want at least one column value equal to zero
    print('do something')

让我们来讨论在第一种情况下如何避开括号。

使用Pandas数学函数Pandas定义了许多数学函数，包括比较，如下所示：pandas.Series.lt（）表示小于；pandas.Series.gt（）表示大于；pandas.Series.le（）表示小于等于；pandas.Series.ge（）表示大于或等于；pandas.Series.ne（）表示不相等；pandas.Series.eq（）表示相等；因此，您可以使用df=df[（df['col']<-0.25）|（df['col']>0.25）]#等于df=df[df['col'].lt（-0.25）|df['col'].gt（0.25）]使用pandas.Series.between（）如果要在两个值之间选择行，可以使用pandas.Series.between：df['col]。between（左，右）等于（左<=df['col']）&（df['cor']<=右）；df['col].bween（左，右，包括='left）等于（左<=df['col']）&（df['cor']<右）；df['col].bween（left，right，inclusive='right'）等于（左<df['col']）&（df['cor']<=右）；df['col].bween（左，右，包括='norther'）等于（左<df['col']）&（df['cor']<右）；df=df[（df['col']>-0.25）&（df['col']<0.25）]#等于df=df[df['col'].介于（-0.25，0.25，包括“任一”）]使用pandas.DataFrame.query（）前面引用的文档有一章query（）方法很好地解释了这一点。pandas.DataFrame.query（）可以帮助您选择带有条件字符串的DataFrame。在查询字符串中，可以使用按位运算符（&和|）及其布尔表（和/或）。此外，可以省略括号，但出于可读性的原因，我不建议使用。df=df[（df['col']<-0.25）|（df['col']>0.25）]#等于df=df.query（'col<-0.25或col>0.25'）使用pandas.DataFrame.eval（）pandas.DataFrame.eval（）计算描述DataFrame列操作的字符串。因此，我们可以使用此方法来构建多个条件。语法与pandas.DataFrame.query（）相同。df=df[（df['col']<-0.25）|（df['col']>0.25）]#等于df=df[df.eval（'col<-0.25或col>0.25'）]pandas.DataFrame.query（）和pandas.DetaFrame.eval（）可以做的事情比我在这里描述的要多。建议您阅读他们的文档并与他们一起玩得开心。

我在熊猫数据框架中工作时也遇到过同样的问题。

我使用过：numpy.logical_and：

在这里，我试图选择Id与41d7853匹配且degree_type不与Certification匹配的行。

如下所示：

display(df_degrees.loc[np.logical_and(df_degrees['person_id'] == '41d7853' , df_degrees['degree_type'] !='Certification')])

如果我尝试编写如下代码：

display(df_degrees.loc[df_degrees['person_id'] == '41d7853' and df_degrees['degree_type'] !='Certification'])

我们将得到错误：

ValueError: The truth value of a Series is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().

我使用了numpy.logical_，它对我很有用。