iloc、ix和loc有何不同？

Question

有人能解释一下这三种切片方法有什么不同吗？
我见过the docs， 我也看到过theseanswers，但我仍然无法解释这三者是如何不同的。在我看来，它们在很大程度上是可以互换的，因为它们处于较低的切片级别。

例如，假设我们想要得到DataFrame的前五行。这三项工作是怎么做到的？

df.loc[:5]
df.ix[:5]
df.iloc[:5]

有人能提出三种使用上的区别更清楚的情况吗？

Answer 1

在我看来，公认的答案是令人困惑的，因为它使用的数据帧只缺少值。我也不喜欢.iloc的基于位置的这个词，相反，我更喜欢.iloc所代表的整数位置，因为它更具描述性。关键字是INTEGER-.iloc需要整数。

有关更多信息，请参见我关于子集选择的非常详细的blog series

---

.ix已弃用且不明确，不应使用

因为.ix被弃用，我们将只关注.loc和.iloc之间的区别。

在我们讨论这些区别之前，重要的是要理解数据帧具有帮助标识每个列和每个索引的标签。让我们看看示例数据帧：

df = pd.DataFrame({'age':[30, 2, 12, 4, 32, 33, 69],
                   'color':['blue', 'green', 'red', 'white', 'gray', 'black', 'red'],
                   'food':['Steak', 'Lamb', 'Mango', 'Apple', 'Cheese', 'Melon', 'Beans'],
                   'height':[165, 70, 120, 80, 180, 172, 150],
                   'score':[4.6, 8.3, 9.0, 3.3, 1.8, 9.5, 2.2],
                   'state':['NY', 'TX', 'FL', 'AL', 'AK', 'TX', 'TX']
                   },
                  index=['Jane', 'Nick', 'Aaron', 'Penelope', 'Dean', 'Christina', 'Cornelia'])

粗体中的所有单词都是标签。标签age、color、food、height、score和state用于列。其他标签Jane、Nick、Aaron、Penelope、Dean、Christina、Cornelia用于索引。

---

选择数据帧中特定行的主要方法是使用.loc和.iloc索引器。这些索引器中的每一个也可以用来同时选择列，但是现在只关注行更容易。此外，每个索引器都使用一组紧跟其名称的括号来进行选择。

.loc仅通过标签选择数据

我们将首先讨论.loc索引器，它只通过索引或列标签选择数据。在示例数据框中，我们提供了有意义的名称作为索引值。许多数据帧没有任何有意义的名称，而是默认为0到n-1之间的整数，其中n是数据帧的长度。

有三种不同的输入可以用于.loc

• 一串
• 字符串列表
• 使用字符串作为起始值和终止值的切片表示法

用.loc和字符串选择一行

要选择一行数据，请将索引标签放在.loc后面的括号内。

df.loc['Penelope']

这将数据行作为一个序列返回

age           4
color     white
food      Apple
height       80
score       3.3
state        AL
Name: Penelope, dtype: object

使用带有字符串列表的.loc选择多行

df.loc[['Cornelia', 'Jane', 'Dean']]

这将返回一个数据帧，其中的行按列表中指定的顺序排列：

使用.loc和切片符号选择多行

切片表示法由开始、停止和步进值定义。按标签切片时，pandas在返回中包含停止值。以下是从亚伦到迪恩的切片，包括在内。其步长未显式定义，但默认为1。

df.loc['Aaron':'Dean']

复杂切片的获取方式与Python列表相同。

.iloc仅按整数位置选择数据

现在我们转到.iloc。数据帧中的每一行和每一列数据都有一个整数位置来定义它。这是除了在输出中可视化显示的标签之外的。整数位置只是从0开始的左上角的行数/列数。

有三种不同的输入可以用于.iloc

• 整数
• 整数列表
• 使用整数作为起始值和终止值的切片表示法

用带整数的.iloc选择一行

df.iloc[4]

这将第5行（整数位置4）作为一个序列返回

age           32
color       gray
food      Cheese
height       180
score        1.8
state         AK
Name: Dean, dtype: object

使用带有整数列表的.iloc选择多行

df.iloc[[2, -2]]

这将返回第三行和第二行到最后一行的数据帧：

使用带有切片表示法的.iloc选择多行

df.iloc[:5:3]

---

S公司使用.loc和.iloc同时选择行和列

它们同时选择行和列的能力是它们的一个优秀能力。在上面的示例中，所有列都是从每个选择返回的。我们可以选择与行输入类型相同的列。我们只需要用一个逗号来分隔行和列选择。

例如，我们可以选择行Jane和Dean，它们的列高度、分数和状态如下：

df.loc[['Jane', 'Dean'], 'height':]

这将使用行的标签列表和列的切片表示法

我们自然可以使用.iloc只使用整数来执行类似的操作。

df.iloc[[1,4], 2]
Nick      Lamb
Dean    Cheese
Name: food, dtype: object

---

同时选择标签和整数位置

.ix用于同时选择标签和整数位置，这是有用的，但有时混淆和模棱两可，谢天谢地，它已被弃用。如果需要使用标签和整数位置的组合进行选择，则必须同时选择标签和整数位置。

例如，如果要选择行Nick和Cornelia以及列2和列4，可以使用.loc，方法是将整数转换为具有以下内容的标签：

col_names = df.columns[[2, 4]]
df.loc[['Nick', 'Cornelia'], col_names] 

或者，使用get_loc索引方法将索引标签转换为整数。

labels = ['Nick', 'Cornelia']
index_ints = [df.index.get_loc(label) for label in labels]
df.iloc[index_ints, [2, 4]]

布尔选择

.loc索引器也可以进行布尔选择。例如，如果我们对查找年龄大于30的所有行感兴趣，并且只返回food和score列，则可以执行以下操作：

df.loc[df['age'] > 30, ['food', 'score']] 

您可以用.iloc复制它，但不能传递布尔序列。必须将布尔序列转换为如下numpy数组：

df.iloc[(df['age'] > 30).values, [2, 4]] 

---

选择所有行

可以使用.loc/.iloc来进行列选择。您可以使用冒号选择所有行，如下所示：

df.loc[:, 'color':'score':2]

---

索引运算符[]也可以选择行和列，但不能同时选择。

大多数人都熟悉DataFrame索引操作符的主要用途，即选择列。字符串选择单个列作为序列，字符串列表选择多个列作为数据帧。

df['food']

Jane          Steak
Nick           Lamb
Aaron         Mango
Penelope      Apple
Dean         Cheese
Christina     Melon
Cornelia      Beans
Name: food, dtype: object

使用列表可选择多个列

df[['food', 'score']]

人们不太熟悉的是，当使用切片表示法时，选择按行标签或整数位置进行。这是非常混乱的东西，我几乎从来没有使用，但它确实工作。

df['Penelope':'Christina'] # slice rows by label

df[2:6:2] # slice rows by integer location

在选择行时，最好使用.loc/.iloc的明确性。单独的索引运算符无法同时选择行和列。

df[3:5, 'color']
TypeError: unhashable type: 'slice'

Answer 2

iloc基于整数定位工作。所以不管你的行标签是什么，你总是可以，例如，通过执行

df.iloc[0]

或者最后五排

df.iloc[-5:]

也可以在列上使用它。这将检索第三列：

df.iloc[:, 2]    # the : in the first position indicates all rows

可以组合它们以获得行和列的交集：

df.iloc[:3, :3] # The upper-left 3 X 3 entries (assuming df has 3+ rows and columns)

另一方面，.loc使用命名索引。让我们用字符串作为行和列标签来设置数据框：

df = pd.DataFrame(index=['a', 'b', 'c'], columns=['time', 'date', 'name'])

然后我们可以通过第一排

df.loc['a']     # equivalent to df.iloc[0]

以及'date'列的后两行

df.loc['b':, 'date']   # equivalent to df.iloc[1:, 1]

等等。现在，可能值得指出的是，DataFrame的默认行和列索引是0的整数，在本例中，iloc和loc的工作方式相同。这就是为什么你的三个例子是等价的。如果有字符串或日期时间等非数字索引，df.loc[:5]将引发错误。

此外，您还可以使用数据帧的__getitem__进行列检索：

df['time']    # equivalent to df.loc[:, 'time']

现在假设您想要混合位置和命名索引，即使用行上的名称和列上的位置进行索引（为了澄清，我的意思是从我们的数据框中选择，而不是创建一个行索引中包含字符串和列索引中包含整数的数据框）。这就是.ix的来源：

df.ix[:2, 'time']    # the first two rows of the 'time' column

我认为值得一提的是，您还可以将布尔向量传递给loc方法。例如：

 b = [True, False, True]
 df.loc[b] 

将返回df的第一行和第三行。这相当于df[b]用于选择，但也可用于通过布尔向量赋值：

df.loc[b, 'name'] = 'Mary', 'John'

Answer 3

注意：在pandas 0.20.0及更高版本中，ix是deprecated，而鼓励使用loc和iloc。我保留了这个答案中描述ix的部分，作为早期版本熊猫用户的参考。下面添加的示例显示了ix的替代方案。

---

首先，这里简要介绍三种方法：

• loc从索引中获取具有特定标签的行（或列）。
• iloc获取索引中特定位置的行（或列）（因此它只接受整数）。
• ix通常尝试类似于loc的行为，但如果索引中不存在标签，则返回类似于iloc的行为。

需要注意的是，有些微妙之处可能会使ix的使用变得有些棘手：

• 如果索引是整数类型，ix将只使用基于标签的索引，而不会返回到基于位置的索引。如果标签不在索引中，则会引发错误。

• 如果索引不只包含整数，那么给定一个整数，ix将立即使用基于位置的索引，而不是基于标签的索引。但是，如果给ix另一种类型（例如字符串），它可以使用基于标签的索引。

---

要说明这三种方法之间的差异，请考虑以下系列：

>>> s = pd.Series(np.nan, index=[49,48,47,46,45, 1, 2, 3, 4, 5])
>>> s
49   NaN
48   NaN
47   NaN
46   NaN
45   NaN
1    NaN
2    NaN
3    NaN
4    NaN
5    NaN

我们来看看整型值3的切片。

在本例中，s.iloc[:3]返回前3行（因为它将3视为位置）和s.loc[:3]返回前8行（因为它将3视为标签）：

>>> s.iloc[:3] # slice the first three rows
49   NaN
48   NaN
47   NaN

>>> s.loc[:3] # slice up to and including label 3
49   NaN
48   NaN
47   NaN
46   NaN
45   NaN
1    NaN
2    NaN
3    NaN

>>> s.ix[:3] # the integer is in the index so s.ix[:3] works like loc
49   NaN
48   NaN
47   NaN
46   NaN
45   NaN
1    NaN
2    NaN
3    NaN

注意s.ix[:3]返回与s.loc[:3]相同的序列，因为它首先查找标签，而不是处理位置（并且s的索引是整型的）。

如果我们尝试使用不在索引中的整数标签（比如6），会怎么样？

这里s.iloc[:6]按预期返回序列的前6行。但是，s.loc[:6]会引发一个KeyError，因为6不在索引中。

>>> s.iloc[:6]
49   NaN
48   NaN
47   NaN
46   NaN
45   NaN
1    NaN

>>> s.loc[:6]
KeyError: 6

>>> s.ix[:6]
KeyError: 6

如上所述，由于试图像loc那样工作，但在索引中找不到6，因此s.ix[:6]现在引发了一个KeyError。因为我们的索引是整型的，ix不会返回到类似iloc的行为。

但是，如果我们的索引是混合类型的，那么给定一个整数ix的行为将立即类似于iloc，而不是引发一个KeyError：

>>> s2 = pd.Series(np.nan, index=['a','b','c','d','e', 1, 2, 3, 4, 5])
>>> s2.index.is_mixed() # index is mix of different types
True
>>> s2.ix[:6] # now behaves like iloc given integer
a   NaN
b   NaN
c   NaN
d   NaN
e   NaN
1   NaN

请记住，ix仍然可以接受非整数，其行为类似于loc：

>>> s2.ix[:'c'] # behaves like loc given non-integer
a   NaN
b   NaN
c   NaN

一般建议是，如果只使用标签编制索引，或者只使用整数位置编制索引，请坚持使用loc或iloc以避免出现意外结果-请尝试不要使用ix。

---

结合基于位置和基于标签的索引

有时给定一个数据帧，您会希望混合使用行和列的标签和位置索引方法。

例如，考虑以下数据帧。如何最好地将行分割为“c”和并包含这两个行，然后取前四列？

>>> df = pd.DataFrame(np.nan, 
                      index=list('abcde'),
                      columns=['x','y','z', 8, 9])
>>> df
    x   y   z   8   9
a NaN NaN NaN NaN NaN
b NaN NaN NaN NaN NaN
c NaN NaN NaN NaN NaN
d NaN NaN NaN NaN NaN
e NaN NaN NaN NaN NaN

在较早版本的pandas（0.20.0之前）中，ix让您可以非常整洁地执行此操作-我们可以按标签分割行，按位置分割列（注意，对于列，ix将默认为基于位置的切片，因为4不是列名）：

>>> df.ix[:'c', :4]
    x   y   z   8
a NaN NaN NaN NaN
b NaN NaN NaN NaN
c NaN NaN NaN NaN

在以后的pandas版本中，我们可以使用iloc和另一种方法的帮助来实现这个结果：

>>> df.iloc[:df.index.get_loc('c') + 1, :4]
    x   y   z   8
a NaN NaN NaN NaN
b NaN NaN NaN NaN
c NaN NaN NaN NaN

^{}是一个索引方法，意思是“获取标签在此索引中的位置”。请注意，由于使用iloc进行切片不包括其端点，因此如果还需要行“c”，则必须向该值添加1。

熊猫的文档中还有更多的例子。