Question

例如我有简单的DF：

import pandas as pd
from random import randint

df = pd.DataFrame({'A': [randint(1, 9) for x in xrange(10)],
                   'B': [randint(1, 9)*10 for x in xrange(10)],
                   'C': [randint(1, 9)*100 for x in xrange(10)]})

我可以使用Pandas的方法和惯用法从“A”中选择“B”的相应值大于50，“C” - 不等于900吗？

Answer 1

当然！设置：

>>> import pandas as pd
>>> from random import randint
>>> df = pd.DataFrame({'A': [randint(1, 9) for x in range(10)],
                   'B': [randint(1, 9)*10 for x in range(10)],
                   'C': [randint(1, 9)*100 for x in range(10)]})
>>> df
   A   B    C
0  9  40  300
1  9  70  700
2  5  70  900
3  8  80  900
4  7  50  200
5  9  30  900
6  2  80  700
7  2  80  400
8  5  80  300
9  7  70  800

我们可以应用列操作并获取布尔系列对象：

>>> df["B"] > 50
0    False
1     True
2     True
3     True
4    False
5    False
6     True
7     True
8     True
9     True
Name: B
>>> (df["B"] > 50) & (df["C"] == 900)
0    False
1    False
2     True
3     True
4    False
5    False
6    False
7    False
8    False
9    False

[更新，切换到新式.loc]：

然后我们可以使用它们来索引对象。对于读访问，您可以链接索引：

>>> df["A"][(df["B"] > 50) & (df["C"] == 900)]
2    5
3    8
Name: A, dtype: int64

但是你可能会遇到麻烦，因为视图和副本之间的区别在于写访问。您可以改为使用.loc：

>>> df.loc[(df["B"] > 50) & (df["C"] == 900), "A"]
2    5
3    8
Name: A, dtype: int64
>>> df.loc[(df["B"] > 50) & (df["C"] == 900), "A"].values
array([5, 8], dtype=int64)
>>> df.loc[(df["B"] > 50) & (df["C"] == 900), "A"] *= 1000
>>> df
      A   B    C
0     9  40  300
1     9  70  700
2  5000  70  900
3  8000  80  900
4     7  50  200
5     9  30  900
6     2  80  700
7     2  80  400
8     5  80  300
9     7  70  800

请注意，我不小心输入了== 900而不是!= 900或~(df["C"] == 900)，但我太懒了，无法修复它。为读者锻炼。：^）

Answer 2

另一种解决方案是使用query方法：

import pandas as pd

from random import randint
df = pd.DataFrame({'A': [randint(1, 9) for x in xrange(10)],
                   'B': [randint(1, 9) * 10 for x in xrange(10)],
                   'C': [randint(1, 9) * 100 for x in xrange(10)]})
print df

   A   B    C
0  7  20  300
1  7  80  700
2  4  90  100
3  4  30  900
4  7  80  200
5  7  60  800
6  3  80  900
7  9  40  100
8  6  40  100
9  3  10  600

print df.query('B > 50 and C != 900')

   A   B    C
1  7  80  700
2  4  90  100
4  7  80  200
5  7  60  800

现在，如果要更改A列中的返回值，可以保存其索引：

my_query_index = df.query('B > 50 & C != 900').index

....并使用.iloc来改变它们，即：

df.iloc[my_query_index, 0] = 5000

print df

      A   B    C
0     7  20  300
1  5000  80  700
2  5000  90  100
3     4  30  900
4  5000  80  200
5  5000  60  800
6     3  80  900
7     9  40  100
8     6  40  100
9     3  10  600

Answer 3

您可以使用pandas，它具有一些内置函数供比较。因此，如果您要选择满足“ B”和“ C”条件的“ A”值（假设您要返回一个DataFrame pandas对象）

df[['A']][df.B.gt(50) & df.C.ne(900)]

df[['A']]将以DataFrame格式返回A列。

pandas的“ gt”函数将返回B列中大于50的位置，而“ ne”将返回不等于900的位置。

Answer 4

请记住使用括号！

请记住，&运算符优先于>或<等运算符。这就是为什么

4 < 5 & 6 > 4

评估为False。因此，如果您使用的是pd.loc，则需要在逻辑语句两边加上方括号，否则会出现错误。这就是为什么：

df.loc[(df['A'] > 10) & (df['B'] < 15)]

代替

df.loc[df['A'] > 10 & df['B'] < 15]

这将导致

TypeError：无法将dtyped的[float64]数组与类型为[bool]的标量进行比较

使用pandas.DataFrame中的复杂条件进行选择

4 个答案: