iloc，ix和loc有何不同？

有人可以解释这三种切片方法有何不同吗？
我看过文档，也看过这些 答案，但仍然发现自己无法解释这三者之间的区别。在我看来，它们在很大程度上似乎是可互换的，因为它们处于切片的较低级别。

例如，假设我们要获取的前五行DataFrame。这三者如何运作？

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

有人可以提出三种用法之间的区别更清楚的情况吗？

注意：在熊猫版本0.20.0及更高版本中，ix已弃用，建议改为使用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整数类型），因此Notification 返回相同的Series 。

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

此处s.iloc[:6]按预期返回Series的前6行。但是，s.loc[:6]由于6不在索引中，所以引发KeyError 。

>>> 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

根据上面提到的细微之处，s.ix[:6]现在引发KeyError，因为它试图像在索引中loc找到一个那样工作，但找不到它6。因为我们的索引是整数类型，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。

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

有时在给定DataFrame的情况下，您将需要为行和列混合使用标签和位置索引方法。

例如，考虑以下DataFrame。如何最好地将行切成“ 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

在更高版本的熊猫中，我们可以使用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

get_loc()是一种索引方法，意思是“获取标签在此索引中的位置”。请注意，由于切片与iloc不包含其端点，因此如果还要行'c'，则必须在此值上加1。

此处的熊猫文档中还有其他示例。

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]

等等。现在，可能值得指出的是，a的默认行和列索引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'

我认为，可接受的答案令人困惑，因为它使用仅缺少值的DataFrame。我也不喜欢术语基于位置的.iloc，相反，喜欢整数位置，因为它是更描述性，正是.iloc代表。关键字是.ilocINTEGER-需要INTEGERS。

请参阅我关于子集选择的非常详细的博客系列，以了解更多信息

.ix已弃用且含糊不清，切勿使用

由于.ix已弃用，因此我们仅关注.loc和之间的差异.iloc。

在讨论差异之前，重要的是要了解DataFrames具有标签，这些标签可帮助标识每个列和每个索引。让我们看一个示例DataFrame：

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被用于索引。

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

.loc仅通过标签选择数据

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

您可以使用三种不同的输入 .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']]

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

使用带有切片符号的.loc选择多行

切片符号由开始，停止和步进值定义。按标签切片时，大熊猫在返回值中包含停止值。以下是从亚伦到迪恩（含）的片段。它的步长未明确定义，但默认为1。

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

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

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

现在转到.iloc。DataFrame中数据的每一行和每一列都有一个定义它的整数位置。这是在输出中直观显示的标签的补充。整数位置只是从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]]

这将返回第三行和倒数第二行的DataFrame：

使用带切片符号的.iloc选择多行

df.iloc[:5:3]

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

两者的一项出色功能.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以及第Cornelia2列和第4列，则可以.loc通过以下方式将整数转换为标签来使用：

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

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

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但是不能将其传递为布尔系列。您必须将boolean Series转换为numpy数组，如下所示：

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

选择所有行

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

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

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

大多数人都熟悉DataFrame索引运算符的主要目的，即选择列。字符串选择单个列作为系列，而字符串列表选择多个列作为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'