python - 为什么用 [ :] versus iloc[:] yield different results in pandas? 分配

Question

我对使用 iloc 的不同索引方法感到很困惑在 Pandas 。

假设我正在尝试将一维数据帧转换为二维数据帧。首先我有以下一维数据框

a_array = [1,2,3,4,5,6,7,8]
a_df = pd.DataFrame(a_array).T

我要将其转换为大小为 2x4 的二维数据帧.我首先按如下方式预设二维数据框:

b_df = pd.DataFrame(columns=range(4),index=range(2))

然后我使用for循环来帮助我转换 a_df (1-d) 到 b_df (2-d) 使用以下代码

for i in range(2):
    b_df.iloc[i,:] = a_df.iloc[0,i*4:(i+1)*4]

它只给我以下结果

     0    1    2    3
0    1    2    3    4
1  NaN  NaN  NaN  NaN

但是当我改了 b_df.iloc[i,:]至 b_df.iloc[i][:] .结果是正确的，如下所示，这就是我想要的

   0  1  2  3
0  1  2  3  4
1  5  6  7  8

谁能向我解释 .iloc[i,:] 之间的区别和 .iloc[i][:]是，为什么 .iloc[i][:]在我上面的例子中工作但不是 .iloc[i,:]

Answer 1

series.iloc[:] 之间有非常非常大的区别和 series[:] ，当回分配。 (i)loc始终检查以确保您分配的任何内容与受让人的索引相匹配。同时，[:]语法分配给底层 NumPy 数组，绕过索引对齐。

s = pd.Series(index=[0, 1, 2, 3], dtype='float')  
s                                                                          

0   NaN
1   NaN
2   NaN
3   NaN
dtype: float64

# Let's get a reference to the underlying array with `copy=False`
arr = s.to_numpy(copy=False) 
arr 
# array([nan, nan, nan, nan])

# Reassign using slicing syntax
s[:] = pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])                 
s                                                                          

0    1
1    2
2    3
3    4
dtype: int64

arr 
# array([1., 2., 3., 4.]) # underlying array has changed

# Now, reassign again with `iloc`
s.iloc[:] = pd.Series([5, 6, 7, 8], index=[3, 4, 5, 6]) 
s                                                                          

0    NaN
1    NaN
2    NaN
3    5.0
dtype: float64

arr 
# array([1., 2., 3., 4.])  # `iloc` created a new array for the series
                           # during reassignment leaving this unchanged

s.to_numpy(copy=False)     # the new underlying array, for reference                                                   
# array([nan, nan, nan,  5.]) 

现在您了解了区别，让我们看看您的代码中发生了什么。只需打印出循环的 RHS 即可查看您正在分配的内容:

for i in range(2): 
    print(a_df.iloc[0, i*4:(i+1)*4]) 

# output - first row                                                                   
0    1
1    2
2    3
3    4
Name: 0, dtype: int64
# second row. Notice the index is different
4    5
5    6
6    7
7    8
Name: 0, dtype: int64   

分配给 b_df.iloc[i, :] 时在第二次迭代中，索引不同，因此没有分配任何内容，您只能看到 NaN。然而，改变 b_df.iloc[i, :]至 b_df.iloc[i][:]将意味着您分配给底层 NumPy 数组，因此绕过索引对齐。这个操作更好地表示为

for i in range(2):
    b_df.iloc[i, :] = a_df.iloc[0, i*4:(i+1)*4].to_numpy()

b_df                                                                       

   0  1  2  3
0  1  2  3  4
1  5  6  7  8

还有值得一提的 this is a form of chained assignment, which is not a good thing ，并且还会使您的代码更难阅读和理解。