为什么用[：]与iloc [：]分配在熊猫中会产生不同的结果？

我对iloc在熊猫中使用不同的索引方法感到困惑。

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

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,:]

分配回来时，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

还值得一提的是，这是链式分配的一种形式，这不是一件好事，并且还会使您的代码更难以阅读和理解。

区别在于，在第一种情况下，Python解释器将代码执行为：

b_df.iloc[i,:] = a_df.iloc[0,i*4:(i+1)*4]
#as
b_df.iloc.__setitem__((i, slice(None)), value)

该值将在等式的右侧。在第二种情况下，Python解释器将代码执行为：

b_df.iloc[i][:] = a_df.iloc[0,i*4:(i+1)*4]
#as
b_df.iloc.__getitem__(i).__setitem__(slice(None), value)

该值再次位于等式的右侧。

在这两种情况的每种情况下，由于键（i，slice（None））和slice（None）的不同，将在内部setitem中调用不同的方法。因此，我们有不同的行为。

谁能向我解释.iloc[i,:]和 之间的区别.iloc[i][:]是什么

.iloc[i,:]和之间的区别.iloc[i][:]

如果.iloc[i,:]您要直接访问的特定位置DataFrame，请选择第th行的所有（:）列i。据我所知，等于不指定第二维（.iloc[i]）。

如果.iloc[i][:]您要执行2个链接的操作。因此，的结果.iloc[i]将受到的影响[:]。使用这组值由熊猫本身气馁这里有一个警告，所以你不应该使用它：

是否返回副本或参考以进行设置操作，可能取决于上下文。有时称为链式分配，应避免

...以及为什么.iloc[i][:]在上面的示例中有效，但没有.iloc[i,:]

正如在OP注释中提到的@Scott一样，数据对齐是固有的，因此=如果左侧没有索引，则不会包含右侧的索引。这就是NaN第二行上有值的原因。

因此，为清楚起见，您可以执行以下操作：

for i in range(2):
    # Get the slice
    a_slice = a_df.iloc[0, i*4:(i+1)*4]
    # Reset the indices
    a_slice.reset_index(drop=True, inplace=True)
    # Set the slice into b_df
    b_df.iloc[i,:] = a_slice

或者您可以转换为list而不是使用reset_index：

for i in range(2):
    # Get the slice
    a_slice = a_df.iloc[0, i*4:(i+1)*4]
    # Convert the slice into a list and set it into b_df
    b_df.iloc[i,:] = list(a_slice)