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)

我得到以下内容，该结果将在“目标”> 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

因此，从本质上来说，我很好奇为什么您要在“ loc / iloc”上使用“ where”，为什么它返回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是iloc和Pandas中的标准选择方式。 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）。

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

3 个答案: