Python Pandas - “loc”和“where”之间的区别？

Question

只是好奇 'where' 的行为以及为什么要在 'loc' 上使用它。

如果我创建一个数据框：

df = pd.DataFrame({'ID':[1,2,3,4,5,6,7,8,9,10], 
                   'Run Distance':[234,35,77,787,243,5435,775,123,355,123],
                   'Goals':[12,23,56,7,8,0,4,2,1,34],
                   'Gender':['m','m','m','f','f','m','f','m','f','m']})

然后应用'where'函数：

df2 = df.where(df['Goals']>10)

我得到以下过滤掉Goals> 10的结果，但将其他所有内容保留为NaN：

  Gender  Goals    ID  Run Distance                                                                                                                                                  
0      m   12.0   1.0         234.0                                                                                                                                                  
1      m   23.0   2.0          35.0                                                                                                                                                  
2      m   56.0   3.0          77.0                                                                                                                                                  
3    NaN    NaN   NaN           NaN                                                                                                                                                  
4    NaN    NaN   NaN           NaN                                                                                                                                                  
5    NaN    NaN   NaN           NaN                                                                                                                                                  
6    NaN    NaN   NaN           NaN                                                                                                                                                  
7    NaN    NaN   NaN           NaN                                                                                                                                                  
8    NaN    NaN   NaN           NaN                                                                                                                                                  
9      m   34.0  10.0         123.0  

如果我使用'loc'函数：

df2 = df.loc[df['Goals']>10]

它返回没有 NaN 值的子集数据帧：

  Gender  Goals  ID  Run Distance                                                                                                                                                    
0      m     12   1           234                                                                                                                                                    
1      m     23   2            35                                                                                                                                                    
2      m     56   3            77                                                                                                                                                    
9      m     34  10           123 

所以基本上我很好奇为什么你会使用 'where' 而不是 'loc/iloc' 以及为什么它返回 NaN 值？

Answer 1

将loc 视为过滤器 - 只给我符合条件的 df 部分。

where 最初来自 numpy。它遍历一个数组并检查每个元素是否符合条件。因此，它会返回整个数组，并返回结果或NaN。 where 的一个不错的功能是您还可以取回不同的东西，例如df2 = df.where(df['Goals']>10, other='0')，将不满足条件的值替换为0。

ID  Run Distance Goals Gender
0   1   234      12     m
1   2   35       23     m
2   3   77       56     m
3   0   0        0      0
4   0   0        0      0
5   0   0        0      0
6   0   0        0      0
7   0   0        0      0
8   0   0        0      0
9   10  123      34     m

另外，where 仅用于条件过滤，loc 是 Pandas 中的标准选择方式，iloc 也是如此。 loc 使用行名和列名，而iloc 使用它们的索引号。所以对于loc，你可以选择返回，比如df.loc[0:1, ['Gender', 'Goals']]：

    Gender  Goals
0   m   12
1   m   23

Answer 2

如果检查文档DataFrame.where，它将按条件替换行 - 默认为 NAN，但可以指定值：

df2 = df.where(df['Goals']>10)
print (df2)
     ID  Run Distance  Goals Gender
0   1.0         234.0   12.0      m
1   2.0          35.0   23.0      m
2   3.0          77.0   56.0      m
3   NaN           NaN    NaN    NaN
4   NaN           NaN    NaN    NaN
5   NaN           NaN    NaN    NaN
6   NaN           NaN    NaN    NaN
7   NaN           NaN    NaN    NaN
8   NaN           NaN    NaN    NaN
9  10.0         123.0   34.0      m

df2 = df.where(df['Goals']>10, 100)
print (df2)
    ID  Run Distance  Goals Gender
0    1           234     12      m
1    2            35     23      m
2    3            77     56      m
3  100           100    100    100
4  100           100    100    100
5  100           100    100    100
6  100           100    100    100
7  100           100    100    100
8  100           100    100    100
9   10           123     34      m

另一种语法称为boolean indexing，用于过滤行 - 删除匹配条件的行。

df2 = df.loc[df['Goals']>10]
#alternative
df2 = df[df['Goals']>10]

print (df2)
   ID  Run Distance  Goals Gender
0   1           234     12      m
1   2            35     23      m
2   3            77     56      m
9  10           123     34      m

如果可以使用loc，还可以按条件按行过滤，按名称按列过滤：

s = df.loc[df['Goals']>10, 'ID']
print (s)
0     1
1     2
2     3
9    10
Name: ID, dtype: int64

df2 = df.loc[df['Goals']>10, ['ID','Gender']]
print (df2)
   ID Gender
0   1      m
1   2      m
2   3      m
9  10      m

Answer 3

• loc 只检索符合条件的行。
• where 返回整个数据框，替换不符合条件的行（默认为 NaN）。