pandas对象中的轴标签信息有许多用途：
使用已知的指标标识数据（即提供元数据），这对于分析，可视化和交互式控制台显示很重要。
启用自动和显式数据对齐。
允许直观地获取和设置数据集的子集。
在本节中，我们将重点关注最后一点：即如何切片，切块，以及通常如何获取和设置熊猫对象的子集。主要重点将放在Series和DataFrame上，因为它们在该领域得到了更多的开发关注。
注意 Python和NumPy索引运算符[]和属性运算符. 可在各种用例中快速轻松地访问熊猫数据结构。这使交互式工作变得直观，因为如果您已经知道如何处理Python字典和NumPy数组，则没有什么新的知识要学习。但是，由于事先不知道要访问的数据类型，因此直接使用标准运算符存在一些优化限制。对于生产代码，我们建议您利用本章中介绍的优化的熊猫数据访问方法。
警告 为设置操作返回副本还是参考，可能取决于上下文。这有时被称为，应该避免。请参阅返回视图与复制。chained assignment
警告 在0.18.0中已阐明了对基于整数的带有浮点数的索引的索引，有关更改的摘要，请参见此处。
见多指标/高级索引的MultiIndex和更先进的索引文件。
有关某些高级策略，请参见本食谱。
不同的选择索引
对象选择具有许多用户请求的添加项，以支持更明确的基于位置的索引。熊猫现在支持三种类型的多轴索引。
.loc主要基于标签，但也可以与布尔数组一起使用。找不到物品时.loc将升高KeyError。允许的输入为：
单个标签，例如5或'a'（请注意，它5被解释为索引的 标签。此用法不是沿索引的整数位置。）
标签列表或标签数组。['a', 'b', 'c']
带标签的切片对象'a':'f'（注意，相反普通的Python片，都开始和停止都包括在内，存在于索引时！见切片用标签）。
布尔数组
一个callable带有一个参数的函数（调用Series或DataFrame），并且返回用于索引的有效输出（上述之一）。
0.18.1版中的新功能。
有关更多信息，请参见按标签选择。
.iloc主要是整数位置（来自0于 length-1所述轴线的），但也可以用布尔阵列使用。 如果请求的索引器超出边界，.iloc则将增加IndexError，但切片索引器除外，该索引允许越界索引。（这符合Python / NumPy slice 语义）。允许的输入为：
整数，例如5。
整数列表或数组。[4, 3, 0]
具有int的slice对象1:7。
布尔数组。
一个callable带有一个参数的函数（调用Series或DataFrame），并且返回用于索引的有效输出（上述之一）。
0.18.1版中的新功能。
请参阅“ 按位置选择”，“ 高级索引编制”和“ 高级层次结构”。
.loc，.iloc以及[]索引也可以接受callable作为索引器。有关更多信息，请参见“ 按呼叫选择”。
从具有多轴选择的对象中获取值使用以下符号（.loc作为示例，但以下内容同样适用.iloc）。任何轴访问器都可以为null slice :。轴冷落的规格被假定为:，例如p.loc['a']相当于 。p.loc['a', :, :]
对象类型 索引器
系列 s.loc[indexer]
数据框 df.loc[row_indexer,column_indexer]
基础
正如在上一节介绍数据结构时所提到的那样，使用[]（__getitem__ 对于熟悉在Python中实现类行为的人员而言）进行索引的主要功能是选择低维切片。下表显示了使用索引pandas对象时的返回类型值[]：
对象类型 选拔 返回值类型
系列 series[label] 标量值
数据框 frame[colname] Series 对应于姓
在这里，我们构造了一个简单的时间序列数据集，用于说明索引功能：
In [1]: dates = pd.date_range('1/1/2000', periods=8)
In [2]: df = pd.DataFrame(np.random.randn(8, 4),
...: index=dates, columns=['A', 'B', 'C', 'D'])
...:
In [3]: df
Out[3]:
A B C D
2000-01-01 0.469112 -0.282863 -1.509059 -1.135632
2000-01-02 1.212112 -0.173215 0.119209 -1.044236
2000-01-03 -0.861849 -2.104569 -0.494929 1.071804
2000-01-04 0.721555 -0.706771 -1.039575 0.271860
2000-01-05 -0.424972 0.567020 0.276232 -1.087401
2000-01-06 -0.673690 0.113648 -1.478427 0.524988
2000-01-07 0.404705 0.577046 -1.715002 -1.039268
2000-01-08 -0.370647 -1.157892 -1.344312 0.844885
注意 除非特别说明，否则索引功能都不是特定于时间序列的。
因此，如上所述，我们使用的是最基本的索引[]：
In [4]: s = df['A']
In [5]: s[dates[5]]
Out[5]: -0.6736897080883706
您可以将列列表传递[]给以该顺序选择列。如果DataFrame中不包含列，则将引发异常。也可以以这种方式设置多列：
In [6]: df
Out[6]:
A B C D
2000-01-01 0.469112 -0.282863 -1.509059 -1.135632
2000-01-02 1.212112 -0.173215 0.119209 -1.044236
2000-01-03 -0.861849 -2.104569 -0.494929 1.071804
2000-01-04 0.721555 -0.706771 -1.039575 0.271860
2000-01-05 -0.424972 0.567020 0.276232 -1.087401
2000-01-06 -0.673690 0.113648 -1.478427 0.524988
2000-01-07 0.404705 0.577046 -1.715002 -1.039268
2000-01-08 -0.370647 -1.157892 -1.344312 0.844885
In [7]: df[['B', 'A']] = df[['A', 'B']]
In [8]: df
Out[8]:
A B C D
2000-01-01 -0.282863 0.469112 -1.509059 -1.135632
2000-01-02 -0.173215 1.212112 0.119209 -1.044236
2000-01-03 -2.104569 -0.861849 -0.494929 1.071804
2000-01-04 -0.706771 0.721555 -1.039575 0.271860
2000-01-05 0.567020 -0.424972 0.276232 -1.087401
2000-01-06 0.113648 -0.673690 -1.478427 0.524988
2000-01-07 0.577046 0.404705 -1.715002 -1.039268
2000-01-08 -1.157892 -0.370647 -1.344312 0.844885
您可能会发现这对于将转换（就地）应用于列的子集很有用。
警告 设置Series和DataFrame从.loc和中时，pandas会对齐所有轴.iloc。
这不会修改，df因为列对齐是在赋值之前。
In [9]: df[['A', 'B']]
Out[9]:
A B
2000-01-01 -0.282863 0.469112
2000-01-02 -0.173215 1.212112
2000-01-03 -2.104569 -0.861849
2000-01-04 -0.706771 0.721555
2000-01-05 0.567020 -0.424972
2000-01-06 0.113648 -0.673690
2000-01-07 0.577046 0.404705
2000-01-08 -1.157892 -0.370647
In [10]: df.loc[:, ['B', 'A']] = df[['A', 'B']]
In [11]: df[['A', 'B']]
Out[11]:
A B
2000-01-01 -0.282863 0.469112
2000-01-02 -0.173215 1.212112
2000-01-03 -2.104569 -0.861849
2000-01-04 -0.706771 0.721555
2000-01-05 0.567020 -0.424972
2000-01-06 0.113648 -0.673690
2000-01-07 0.577046 0.404705
2000-01-08 -1.157892 -0.370647
交换列值的正确方法是使用原始值：
In [12]: df.loc[:, ['B', 'A']] = df[['A', 'B']].to_numpy()
In [13]: df[['A', 'B']]
Out[13]:
A B
2000-01-01 0.469112 -0.282863
2000-01-02 1.212112 -0.173215
2000-01-03 -0.861849 -2.104569
2000-01-04 0.721555 -0.706771
2000-01-05 -0.424972 0.567020
2000-01-06 -0.673690 0.113648
2000-01-07 0.404705 0.577046
2000-01-08 -0.370647 -1.157892
属性访问
您可以直接将Series或上的索引DataFrame作为属性访问：
In [14]: sa = pd.Series([1, 2, 3], index=list('abc'))
In [15]: dfa = df.copy()
In [16]: sa.b
Out[16]: 2
In [17]: dfa.A
Out[17]:
2000-01-01 0.469112
2000-01-02 1.212112
2000-01-03 -0.861849
2000-01-04 0.721555
2000-01-05 -0.424972
2000-01-06 -0.673690
2000-01-07 0.404705
2000-01-08 -0.370647
Freq: D, Name: A, dtype: float64
In [18]: sa.a = 5
In [19]: sa
Out[19]:
a 5
b 2
c 3
dtype: int64
In [20]: dfa.A = list(range(len(dfa.index))) # ok if A already exists
In [21]: dfa
Out[21]:
A B C D
2000-01-01 0 -0.282863 -1.509059 -1.135632
2000-01-02 1 -0.173215 0.119209 -1.044236
2000-01-03 2 -2.104569 -0.494929 1.071804
2000-01-04 3 -0.706771 -1.039575 0.271860
2000-01-05 4 0.567020 0.276232 -1.087401
2000-01-06 5 0.113648 -1.478427 0.524988
2000-01-07 6 0.577046 -1.715002 -1.039268
2000-01-08 7 -1.157892 -1.344312 0.844885
In [22]: dfa['A'] = list(range(len(dfa.index))) # use this form to create a new column
In [23]: dfa
Out[23]:
A B C D
2000-01-01 0 -0.282863 -1.509059 -1.135632
2000-01-02 1 -0.173215 0.119209 -1.044236
2000-01-03 2 -2.104569 -0.494929 1.071804
2000-01-04 3 -0.706771 -1.039575 0.271860
2000-01-05 4 0.567020 0.276232 -1.087401
2000-01-06 5 0.113648 -1.478427 0.524988
2000-01-07 6 0.577046 -1.715002 -1.039268
2000-01-08 7 -1.157892 -1.344312 0.844885
警告
仅当index元素是有效的Python标识符（例如s.1，不允许使用）时，才能使用此访问权限。有关有效标识符的说明，请参见此处。
如果属性与现有方法名称冲突（例如s.min不允许），则该属性将不可用。
同样，该属性将不可用，如果它与下列任何名单的冲突：index， major_axis，minor_axis，items。
在任何一种情况下，标准索引仍然可以工作，例如s['1']，s['min']和s['index']将访问相应的元素或列。
如果使用的是IPython环境，则也可以使用制表符补全来查看这些可访问的属性。
您还可以将分配dict给的一行DataFrame：
In [24]: x = pd.DataFrame({'x': [1, 2, 3], 'y': [3, 4, 5]})
In [25]: x.iloc[1] = {'x': 9, 'y': 99}
In [26]: x
Out[26]:
x y
0 1 3
1 9 99
2 3 5
您可以使用属性访问来修改Series或DataFrame列的现有元素，但要小心；如果您尝试使用属性访问来创建新列，则它将创建一个新属性而不是一个新列。在0.21.0及更高版本中，这将引发UserWarning：
In [1]: df = pd.DataFrame({'one': [1., 2., 3.]})
In [2]: df.two = [4, 5, 6]
UserWarning: Pandas doesn't allow Series to be assigned into nonexistent columns - see https://pandas.pydata.org/pandas-docs/stable/indexing.html#attribute_access
In [3]: df
Out[3]:
one
0 1.0
1 2.0
2 3.0
切片范围
在“ 按位置选择”部分详细介绍了该.iloc方法，介绍了沿任意轴切片范围的最可靠，最一致的方法。现在，我们解释使用[]运算符进行切片的语义。
使用Series时，语法与ndarray完全一样，返回值的一部分和相应的标签：
In [27]: s[:5]
Out[27]:
2000-01-01 0.469112
2000-01-02 1.212112
2000-01-03 -0.861849
2000-01-04 0.721555
2000-01-05 -0.424972
Freq: D, Name: A, dtype: float64
In [28]: s[::2]
Out[28]:
2000-01-01 0.469112
2000-01-03 -0.861849
2000-01-05 -0.424972
2000-01-07 0.404705
Freq: 2D, Name: A, dtype: float64
In [29]: s[::-1]
Out[29]:
2000-01-08 -0.370647
2000-01-07 0.404705
2000-01-06 -0.673690
2000-01-05 -0.424972
2000-01-04 0.721555
2000-01-03 -0.861849
2000-01-02 1.212112
2000-01-01 0.469112
Freq: -1D, Name: A, dtype: float64
请注意，设置同样适用：
In [30]: s2 = s.copy()
In [31]: s2[:5] = 0
In [32]: s2
Out[32]:
2000-01-01 0.000000
2000-01-02 0.000000
2000-01-03 0.000000
2000-01-04 0.000000
2000-01-05 0.000000
2000-01-06 -0.673690
2000-01-07 0.404705
2000-01-08 -0.370647
Freq: D, Name: A, dtype: float64
使用DataFrame时，[] 在rows中对切片进行切片。由于这是一种常见的操作，因此在很大程度上是为了方便而提供的。
In [33]: df[:3]
Out[33]:
A B C D
2000-01-01 0.469112 -0.282863 -1.509059 -1.135632
2000-01-02 1.212112 -0.173215 0.119209 -1.044236
2000-01-03 -0.861849 -2.104569 -0.494929 1.071804
In [34]: df[::-1]
Out[34]:
A B C D
2000-01-08 -0.370647 -1.157892 -1.344312 0.844885
2000-01-07 0.404705 0.577046 -1.715002 -1.039268
2000-01-06 -0.673690 0.113648 -1.478427 0.524988
2000-01-05 -0.424972 0.567020 0.276232 -1.087401
2000-01-04 0.721555 -0.706771 -1.039575 0.271860
2000-01-03 -0.861849 -2.104569 -0.494929 1.071804
2000-01-02 1.212112 -0.173215 0.119209 -1.044236
2000-01-01 0.469112 -0.282863 -1.509059 -1.135632
按标签选择
警告 为设置操作返回副本还是参考，可能取决于上下文。这有时被称为，应该避免。请参阅返回视图与复制。chained assignment
警告
.loc当您提供与索引类型不兼容（或可转换）的切片器时，它是严格的。例如在中使用整数DatetimeIndex。这些将引发一个TypeError。
In [35]: dfl = pd.DataFrame(np.random.randn(5, 4),
....: columns=list('ABCD'),
....: index=pd.date_range('20130101', periods=5))
....:
In [36]: dfl
Out[36]:
A B C D
2013-01-01 1.075770 -0.109050 1.643563 -1.469388
2013-01-02 0.357021 -0.674600 -1.776904 -0.968914
2013-01-03 -1.294524 0.413738 0.276662 -0.472035
2013-01-04 -0.013960 -0.362543 -0.006154 -0.923061
2013-01-05 0.895717 0.805244 -1.206412 2.565646
In [4]: dfl.loc[2:3]
TypeError: cannot do slice indexing on <class 'pandas.tseries.index.DatetimeIndex'> with these indexers [2] of <type 'int'>
切片中的字符串喜欢可以转换为索引的类型并导致自然切片。
In [37]: dfl.loc['20130102':'20130104']
Out[37]:
A B C D
2013-01-02 0.357021 -0.674600 -1.776904 -0.968914
2013-01-03 -1.294524 0.413738 0.276662 -0.472035
2013-01-04 -0.013960 -0.362543 -0.006154 -0.923061
警告 从0.21.0开始，pandas将显示FutureWarningif索引，其中包含缺少标签的列表。在未来，这将引发KeyError。请参见类似列表的列表。不推荐使用在列表中缺少键的loc。
熊猫提供了一整套方法，以便具有纯基于标签的索引。这是一个基于严格包含的协议。要求的每个标签都必须在索引中，否则KeyError将引发a。切片时，如果索引中存在起始边界和终止边界，则都将包括在内。整数是有效的标签，但它们引用的是标签，而不是position。
该.loc属性是主要的访问方法。以下是有效输入：
单个标签，例如5或'a'（请注意，它5被解释为索引的标签。此用法不是沿索引的整数位置。）
标签列表或标签数组。['a', 'b', 'c']
带标签的切片对象'a':'f'（注意，相反普通的Python片，都开始和停止都包括在内，存在于索引时！见切片用标签）。
布尔数组。
A callable，请参见按可调用选择。
In [38]: s1 = pd.Series(np.random.randn(6), index=list('abcdef'))
In [39]: s1
Out[39]:
a 1.431256
b 1.340309
c -1.170299
d -0.226169
e 0.410835
f 0.813850
dtype: float64
In [40]: s1.loc['c':]
Out[40]:
c -1.170299
d -0.226169
e 0.410835
f 0.813850
dtype: float64
In [41]: s1.loc['b']
Out[41]: 1.3403088497993827
请注意，设置同样适用：
In [42]: s1.loc['c':] = 0
In [43]: s1
Out[43]:
a 1.431256
b 1.340309
c 0.000000
d 0.000000
e 0.000000
f 0.000000
dtype: float64
使用DataFrame：
In [44]: df1 = pd.DataFrame(np.random.randn(6, 4),
....: index=list('abcdef'),
....: columns=list('ABCD'))
....:
In [45]: df1
Out[45]:
A B C D
a 0.132003 -0.827317 -0.076467 -1.187678
b 1.130127 -1.436737 -1.413681 1.607920
c 1.024180 0.569605 0.875906 -2.211372
d 0.974466 -2.006747 -0.410001 -0.078638
e 0.545952 -1.219217 -1.226825 0.769804
f -1.281247 -0.727707 -0.121306 -0.097883
In [46]: df1.loc[['a', 'b', 'd'], :]
Out[46]:
A B C D
a 0.132003 -0.827317 -0.076467 -1.187678
b 1.130127 -1.436737 -1.413681 1.607920
d 0.974466 -2.006747 -0.410001 -0.078638
通过标签切片访问：
In [47]: df1.loc['d':, 'A':'C']
Out[47]:
A B C
d 0.974466 -2.006747 -0.410001
e 0.545952 -1.219217 -1.226825
f -1.281247 -0.727707 -0.121306
要使用标签（相当于df.xs('a')）获取横截面：
In [48]: df1.loc['a']
Out[48]:
A 0.132003
B -0.827317
C -0.076467
D -1.187678
Name: a, dtype: float64
要使用布尔数组获取值：
In [49]: df1.loc['a'] > 0
Out[49]:
A True
B False
C False
D False
Name: a, dtype: bool
In [50]: df1.loc[:, df1.loc['a'] > 0]
Out[50]:
A
a 0.132003
b 1.130127
c 1.024180
d 0.974466
e 0.545952
f -1.281247
为了显式地获取值（等效于deprecated df.get_value('a','A')）：
# this is also equivalent to ``df1.at['a','A']``
In [51]: df1.loc['a', 'A']
Out[51]: 0.13200317033032932
带标签切片
.loc与切片一起使用时，如果索引中同时包含开始标签和停止标签，则返回位于两者之间的元素（包括它们）：
In [52]: s = pd.Series(list('abcde'), index=[0, 3, 2, 5, 4])
In [53]: s.loc[3:5]
Out[53]:
3 b
2 c
5 d
dtype: object
如果这两个中的至少一个不存在的，但该指数进行排序，并能对启动和停止的标签进行比较，然后切片仍然会按预期方式工作，通过选择的标签，其排名在两者之间：
In [54]: s.sort_index()
Out[54]:
0 a
2 c
3 b
4 e
5 d
dtype: object
In [55]: s.sort_index().loc[1:6]
Out[55]:
2 c
3 b
4 e
5 d
dtype: object
但是，如果不存在两者中的至少一个并且未对索引进行排序，则将引发错误（因为这样做会导致计算量大，并且可能对混合类型索引造成歧义）。例如，在上面的示例中，s.loc[1:6]将上升KeyError。
按位置选择
警告 为设置操作返回副本还是参考，可能取决于上下文。这有时被称为，应该避免。请参阅返回视图与复制。chained assignment
Pandas提供了一组方法，以便获得纯粹基于整数的索引。语义严格遵循Python和NumPy切片。这些正在0-based索引。当切片，开始结合被包含，而上限是排除。尝试使用非整数，即使有效标签也将引发IndexError。
该.iloc属性是主要的访问方法。以下是有效输入：
整数，例如5。
整数列表或数组。[4, 3, 0]
具有int的slice对象1:7。
布尔数组。
A callable，请参见按可调用选择。
In [56]: s1 = pd.Series(np.random.randn(5), index=list(range(0, 10, 2)))
In [57]: s1
Out[57]:
0 0.695775
2 0.341734
4 0.959726
6 -1.110336
8 -0.619976
dtype: float64
In [58]: s1.iloc[:3]
Out[58]:
0 0.695775
2 0.341734
4 0.959726
dtype: float64
In [59]: s1.iloc[3]
Out[59]: -1.110336102891167
请注意，设置同样适用：
In [60]: s1.iloc[:3] = 0
In [61]: s1
Out[61]:
0 0.000000
2 0.000000
4 0.000000
6 -1.110336
8 -0.619976
dtype: float64
使用DataFrame：
In [62]: df1 = pd.DataFrame(np.random.randn(6, 4),
....: index=list(range(0, 12, 2)),
....: columns=list(range(0, 8, 2)))
....:
In [63]: df1
Out[63]:
0 2 4 6
0 0.149748 -0.732339 0.687738 0.176444
2 0.403310 -0.154951 0.301624 -2.179861
4 -1.369849 -0.954208 1.462696 -1.743161
6 -0.826591 -0.345352 1.314232 0.690579
8 0.995761 2.396780 0.014871 3.357427
10 -0.317441 -1.236269 0.896171 -0.487602
通过整数切片选择：
In [64]: df1.iloc[:3]
Out[64]:
0 2 4 6
0 0.149748 -0.732339 0.687738 0.176444
2 0.403310 -0.154951 0.301624 -2.179861
4 -1.369849 -0.954208 1.462696 -1.743161
In [65]: df1.iloc[1:5, 2:4]
Out[65]:
4 6
2 0.301624 -2.179861
4 1.462696 -1.743161
6 1.314232 0.690579
8 0.014871 3.357427
通过整数列表选择：
In [66]: df1.iloc[[1, 3, 5], [1, 3]]
Out[66]:
2 6
2 -0.154951 -2.179861
6 -0.345352 0.690579
10 -1.236269 -0.487602
In [67]: df1.iloc[1:3, :]
Out[67]:
0 2 4 6
2 0.403310 -0.154951 0.301624 -2.179861
4 -1.369849 -0.954208 1.462696 -1.743161
In [68]: df1.iloc[:, 1:3]
Out[68]:
2 4
0 -0.732339 0.687738
2 -0.154951 0.301624
4 -0.954208 1.462696
6 -0.345352 1.314232
8 2.396780 0.014871
10 -1.236269 0.896171
# this is also equivalent to ``df1.iat[1,1]``
In [69]: df1.iloc[1, 1]
Out[69]: -0.1549507744249032
要使用整数位置（等于df.xs(1)）获取横截面：
In [70]: df1.iloc[1]
Out[70]:
0 0.403310
2 -0.154951
4 0.301624
6 -2.179861
Name: 2, dtype: float64
超出范围切片索引的处理方式与Python / Numpy中一样。
# these are allowed in python/numpy.
In [71]: x = list('abcdef')
In [72]: x
Out[72]: ['a', 'b', 'c', 'd', 'e', 'f']
In [73]: x[4:10]
Out[73]: ['e', 'f']
In [74]: x[8:10]
Out[74]: []
In [75]: s = pd.Series(x)
In [76]: s
Out[76]:
0 a
1 b
2 c
3 d
4 e
5 f
dtype: object
In [77]: s.iloc[4:10]
Out[77]:
4 e
5 f
dtype: object
In [78]: s.iloc[8:10]
Out[78]: Series([], dtype: object)
请注意，使用超出范围的切片可能会导致一个空轴（例如，返回一个空的DataFrame）。
In [79]: dfl = pd.DataFrame(np.random.randn(5, 2), columns=list('AB'))
In [80]: dfl
Out[80]:
A B
0 -0.082240 -2.182937
1 0.380396 0.084844
2 0.432390 1.519970
3 -0.493662 0.600178
4 0.274230 0.132885
In [81]: dfl.iloc[:, 2:3]
Out[81]:
Empty DataFrame
Columns: []
Index: [0, 1, 2, 3, 4]
In [82]: dfl.iloc[:, 1:3]
Out[82]:
B
0 -2.182937
1 0.084844
2 1.519970
3 0.600178
4 0.132885
In [83]: dfl.iloc[4:6]
Out[83]:
A B
4 0.27423 0.132885
超出范围的单个索引器将引发IndexError。任何元素超出范围的索引器列表都会引发 IndexError。
>>> dfl.iloc[[4, 5, 6]]
IndexError: positional indexers are out-of-bounds
>>> dfl.iloc[:, 4]
IndexError: single positional indexer is out-of-bounds
通过可调用选择
0.18.1版中的新功能。
.loc，.iloc以及[]索引也可以接受callable作为索引器。在callable必须与一个参数（呼叫系列或数据帧）返回的有效输出索引功能。
In [84]: df1 = pd.DataFrame(np.random.randn(6, 4),
....: index=list('abcdef'),
....: columns=list('ABCD'))
....:
In [85]: df1
Out[85]:
A B C D
a -0.023688 2.410179 1.450520 0.206053
b -0.251905 -2.213588 1.063327 1.266143
c 0.299368 -0.863838 0.408204 -1.048089
d -0.025747 -0.988387 0.094055 1.262731
e 1.289997 0.082423 -0.055758 0.536580
f -0.489682 0.369374 -0.034571 -2.484478
In [86]: df1.loc[lambda df: df.A > 0, :]
Out[86]:
A B C D
c 0.299368 -0.863838 0.408204 -1.048089
e 1.289997 0.082423 -0.055758 0.536580
In [87]: df1.loc[:, lambda df: ['A', 'B']]
Out[87]:
A B
a -0.023688 2.410179
b -0.251905 -2.213588
c 0.299368 -0.863838
d -0.025747 -0.988387
e 1.289997 0.082423
f -0.489682 0.369374
In [88]: df1.iloc[:, lambda df: [0, 1]]
Out[88]:
A B
a -0.023688 2.410179
b -0.251905 -2.213588
c 0.299368 -0.863838
d -0.025747 -0.988387
e 1.289997 0.082423
f -0.489682 0.369374
In [89]: df1[lambda df: df.columns[0]]
Out[89]:
a -0.023688
b -0.251905
c 0.299368
d -0.025747
e 1.289997
f -0.489682
Name: A, dtype: float64
您可以在中使用可调用索引Series。
In [90]: df1.A.loc[lambda s: s > 0]
Out[90]:
c 0.299368
e 1.289997
Name: A, dtype: float64
使用这些方法/索引器，您可以链接数据选择操作，而无需使用临时变量。
In [91]: bb = pd.read_csv('data/baseball.csv', index_col='id')
In [92]: (bb.groupby(['year', 'team']).sum()
....: .loc[lambda df: df.r > 100])
....:
Out[92]:
stint g ab r h X2b ... so ibb hbp sh sf gidp
year team ...
2007 CIN 6 379 745 101 203 35 ... 127.0 14.0 1.0 1.0 15.0 18.0
DET 5 301 1062 162 283 54 ... 176.0 3.0 10.0 4.0 8.0 28.0
HOU 4 311 926 109 218 47 ... 212.0 3.0 9.0 16.0 6.0 17.0
LAN 11 413 1021 153 293 61 ... 141.0 8.0 9.0 3.0 8.0 29.0
NYN 13 622 1854 240 509 101 ... 310.0 24.0 23.0 18.0 15.0 48.0
SFN 5 482 1305 198 337 67 ... 188.0 51.0 8.0 16.0 6.0 41.0
TEX 2 198 729 115 200 40 ... 140.0 4.0 5.0 2.0 8.0 16.0
TOR 4 459 1408 187 378 96 ... 265.0 16.0 12.0 4.0 16.0 38.0
[8 rows x 18 columns]
IX Indexer已弃用
警告 在0.20.0开始，.ix索引器已被弃用，赞成更加严格.iloc 和.loc索引。
.ix在推断用户想要做什么方面提供了很多魔力。也就是说，.ix可以根据索引的数据类型决定是否通过标签对位置进行索引。多年来，这引起了相当多的用户混乱。
推荐的索引编制方法是：
.loc如果要标记索引。
.iloc如果要位置索引。
In [93]: dfd = pd.DataFrame({'A': [1, 2, 3],
....: 'B': [4, 5, 6]},
....: index=list('abc'))
....:
In [94]: dfd
Out[94]:
A B
a 1 4
b 2 5
c 3 6
以前的行为，您希望从“ A”列的索引中获取第0个元素和第2个元素。
In [3]: dfd.ix[[0, 2], 'A']
Out[3]:
a 1
c 3
Name: A, dtype: int64
使用.loc。在这里，我们将从索引中选择适当的索引，然后使用标签索引。
In [95]: dfd.loc[dfd.index[[0, 2]], 'A']
Out[95]:
a 1
c 3
Name: A, dtype: int64
也可以使用来表达这一点.iloc，方法是明确获取索引器上的位置，并使用 位置索引来选择事物。
In [96]: dfd.iloc[[0, 2], dfd.columns.get_loc('A')]
Out[96]:
a 1
c 3
Name: A, dtype: int64
要获取多个索引器，请使用.get_indexer：
In [97]: dfd.iloc[[0, 2], dfd.columns.get_indexer(['A', 'B'])]
Out[97]:
A B
a 1 4
c 3 6
不建议使用带有缺少标签的列表建立索引
警告 从0.21.0开始，不推荐使用.loc或[]带有一个或多个缺少标签的列表，而推荐使用.reindex。
在以前的版本中，.loc[list-of-labels]只要找到至少一个键，使用就可以工作（否则会引发KeyError）。不建议使用此行为，它将显示一条警告消息，指向此部分。推荐的替代方法是使用.reindex()。
例如。
In [98]: s = pd.Series([1, 2, 3])
In [99]: s
Out[99]:
0 1
1 2
2 3
dtype: int64
找到所有键的选择保持不变。
In [100]: s.loc[[1, 2]]
Out[100]:
1 2
2 3
dtype: int64
以前的行为
In [4]: s.loc[[1, 2, 3]]
Out[4]:
1 2.0
2 3.0
3 NaN
dtype: float64
当前行为
In [4]: s.loc[[1, 2, 3]]
Passing list-likes to .loc with any non-matching elements will raise
KeyError in the future, you can use .reindex() as an alternative.
See the documentation here:
http://pandas.pydata.org/pandas-docs/stable/indexing.html#deprecate-loc-reindex-listlike
Out[4]:
1 2.0
2 3.0
3 NaN
dtype: float64
重建索引
实现选择潜在未找到元素的惯用方式是通过.reindex()。另请参阅“ 重新索引编制 ”部分。
In [101]: s.reindex([1, 2, 3])
Out[101]:
1 2.0
2 3.0
3 NaN
dtype: float64
另外，如果您只想选择有效的密钥，则以下是惯用且有效的；保证保留选择的dtype。
In [102]: labels = [1, 2, 3]
In [103]: s.loc[s.index.intersection(labels)]
Out[103]:
1 2
2 3
dtype: int64
索引重复会产生.reindex()：
In [104]: s = pd.Series(np.arange(4), index=['a', 'a', 'b', 'c'])
In [105]: labels = ['c', 'd']
In [17]: s.reindex(labels)
ValueError: cannot reindex from a duplicate axis
通常，您可以将所需的标签与当前轴相交，然后重新索引。
In [106]: s.loc[s.index.intersection(labels)].reindex(labels)
Out[106]:
c 3.0
d NaN
dtype: float64
但是，如果您生成的索引重复，这仍然会增加。
In [41]: labels = ['a', 'd']
In [42]: s.loc[s.index.intersection(labels)].reindex(labels)
ValueError: cannot reindex from a duplicate axis
选择随机样本
使用该sample()方法从Series或DataFrame中随机选择行或列。该方法默认情况下将对行进行采样，并接受要返回的特定数量的行/列，或一部分行。
In [107]: s = pd.Series([0, 1, 2, 3, 4, 5])
# When no arguments are passed, returns 1 row.
In [108]: s.sample()
Out[108]:
4 4
dtype: int64
# One may specify either a number of rows:
In [109]: s.sample(n=3)
Out[109]:
0 0
4 4
1 1
dtype: int64
# Or a fraction of the rows:
In [110]: s.sample(frac=0.5)
Out[110]:
5 5
3 3
1 1
dtype: int64
默认情况下，sample将最多返回每一行一次，但也可以使用以下replace选项进行替换采样：
In [111]: s = pd.Series([0, 1, 2, 3, 4, 5])
# Without replacement (default):
In [112]: s.sample(n=6, replace=False)
Out[112]:
0 0
1 1
5 5
3 3
2 2
4 4
dtype: int64
# With replacement:
In [113]: s.sample(n=6, replace=True)
Out[113]:
0 0
4 4
3 3
2 2
4 4
4 4
dtype: int64
默认情况下，每行被选择的概率相同，但是如果您希望行具有不同的概率，则可以将sample函数采样权重传递为 weights。这些权重可以是列表，NumPy数组或系列，但是它们的长度必须与要采样的对象相同。缺少的值将被视为权重为零，并且不允许使用inf值。如果权重不等于1，将通过将所有权重除以权重之和来重新归一化。例如：
In [114]: s = pd.Series([0, 1, 2, 3, 4, 5])
In [115]: example_weights = [0, 0, 0.2, 0.2, 0.2, 0.4]
In [116]: s.sample(n=3, weights=example_weights)
Out[116]:
5 5
4 4
3 3
dtype: int64
# Weights will be re-normalized automatically
In [117]: example_weights2 = [0.5, 0, 0, 0, 0, 0]
In [118]: s.sample(n=1, weights=example_weights2)
Out[118]:
0 0
dtype: int64
应用于DataFrame时，只需将列名作为字符串传递，就可以将DataFrame的一列用作采样权重（前提是要对行而不是列进行采样）。
In [119]: df2 = pd.DataFrame({'col1': [9, 8, 7, 6],
.....: 'weight_column': [0.5, 0.4, 0.1, 0]})
.....:
In [120]: df2.sample(n=3, weights='weight_column')
Out[120]:
col1 weight_column
1 8 0.4
0 9 0.5
2 7 0.1
sample还允许用户使用axis参数对列而不是行进行采样。
In [121]: df3 = pd.DataFrame({'col1': [1, 2, 3], 'col2': [2, 3, 4]})
In [122]: df3.sample(n=1, axis=1)
Out[122]:
col1
0 1
1 2
2 3
最后，还可以sample使用random_state参数为的随机数生成器设置种子，该种子将接受整数（作为种子）或NumPy RandomState对象。
In [123]: df4 = pd.DataFrame({'col1': [1, 2, 3], 'col2': [2, 3, 4]})
# With a given seed, the sample will always draw the same rows.
In [124]: df4.sample(n=2, random_state=2)
Out[124]:
col1 col2
2 3 4
1 2 3
In [125]: df4.sample(n=2, random_state=2)
Out[125]:
col1 col2
2 3 4
1 2 3
放大设置
.loc/[]当为该轴设置不存在的键时，这些操作可以执行放大操作。
在这种Series情况下，这实际上是附加操作。
In [126]: se = pd.Series([1, 2, 3])
In [127]: se
Out[127]:
0 1
1 2
2 3
dtype: int64
In [128]: se[5] = 5.
In [129]: se
Out[129]:
0 1.0
1 2.0
2 3.0
5 5.0
dtype: float64
阿DataFrame可以在任一轴通过被放大.loc。
In [130]: dfi = pd.DataFrame(np.arange(6).reshape(3, 2),
.....: columns=['A', 'B'])
.....:
In [131]: dfi
Out[131]:
A B
0 0 1
1 2 3
2 4 5
In [132]: dfi.loc[:, 'C'] = dfi.loc[:, 'A']
In [133]: dfi
Out[133]:
A B C
0 0 1 0
1 2 3 2
2 4 5 4
这就像对的append操作DataFrame。
In [134]: dfi.loc[3] = 5
In [135]: dfi
Out[135]:
A B C
0 0 1 0
1 2 3 2
2 4 5 4
3 5 5 5
快速获取和设置标量值
由于with索引[]必须处理很多情况（单标签访问，切片，布尔索引等），因此要弄清楚您要的内容有一点开销。如果只想访问标量值，最快的方法是使用at和iat方法，它们在所有数据结构上实现。
与相似loc，at提供基于标签的标量查找，而类似于iat提供基于整数的查找iloc
In [136]: s.iat[5]
Out[136]: 5
In [137]: df.at[dates[5], 'A']
Out[137]: -0.6736897080883706
In [138]: df.iat[3, 0]
Out[138]: 0.7215551622443669
您也可以使用这些相同的索引器进行设置。
In [139]: df.at[dates[5], 'E'] = 7
In [140]: df.iat[3, 0] = 7
at 如果缺少索引器，可能会像上面一样就地放大对象。
In [141]: df.at[dates[-1] + pd.Timedelta('1 day'), 0] = 7
In [142]: df
Out[142]:
A B C D E 0
2000-01-01 0.469112 -0.282863 -1.509059 -1.135632 NaN NaN
2000-01-02 1.212112 -0.173215 0.119209 -1.044236 NaN NaN
2000-01-03 -0.861849 -2.104569 -0.494929 1.071804 NaN NaN
2000-01-04 7.000000 -0.706771 -1.039575 0.271860 NaN NaN
2000-01-05 -0.424972 0.567020 0.276232 -1.087401 NaN NaN
2000-01-06 -0.673690 0.113648 -1.478427 0.524988 7.0 NaN
2000-01-07 0.404705 0.577046 -1.715002 -1.039268 NaN NaN
2000-01-08 -0.370647 -1.157892 -1.344312 0.844885 NaN NaN
2000-01-09 NaN NaN NaN NaN NaN 7.0
布尔索引
另一个常见的操作是使用布尔向量来过滤数据。运算符是：|for or，&for and和~for not。这些必须通过使用括号中，由于默认Python会计算表达式如被分组为 ，而所希望的评价顺序是 。df.A > 2 & df.B < 3df.A > (2 & df.B) < 3(df.A > 2) & (df.B < 3)
使用布尔向量为Series编制索引的方式与NumPy ndarray完全相同：
In [143]: s = pd.Series(range(-3, 4))
In [144]: s
Out[144]:
0 -3
1 -2
2 -1
3 0
4 1
5 2
6 3
dtype: int64
In [145]: s[s > 0]
Out[145]:
4 1
5 2
6 3
dtype: int64
In [146]: s[(s < -1) | (s > 0.5)]
Out[146]:
0 -3
1 -2
4 1
5 2
6 3
dtype: int64
In [147]: s[~(s < 0)]
Out[147]:
3 0
4 1
5 2
6 3
dtype: int64
您可以使用布尔向量从DataFrame中选择行，该布尔向量的长度与DataFrame的索引相同（例如，从DataFrame的列之一派生的值）：
In [148]: df[df['A'] > 0]
Out[148]:
A B C D E 0
2000-01-01 0.469112 -0.282863 -1.509059 -1.135632 NaN NaN
2000-01-02 1.212112 -0.173215 0.119209 -1.044236 NaN NaN
2000-01-04 7.000000 -0.706771 -1.039575 0.271860 NaN NaN
2000-01-07 0.404705 0.577046 -1.715002 -1.039268 NaN NaN
列表推导和mapSeries方法也可以用于产生更复杂的条件：
In [149]: df2 = pd.DataFrame({'a': ['one', 'one', 'two', 'three', 'two', 'one', 'six'],
.....: 'b': ['x', 'y', 'y', 'x', 'y', 'x', 'x'],
.....: 'c': np.random.randn(7)})
.....:
# only want 'two' or 'three'
In [150]: criterion = df2['a'].map(lambda x: x.startswith('t'))
In [151]: df2[criterion]
Out[151]:
a b c
2 two y 0.041290
3 three x 0.361719
4 two y -0.238075
# equivalent but slower
In [152]: df2[[x.startswith('t') for x in df2['a']]]
Out[152]:
a b c
2 two y 0.041290
3 three x 0.361719
4 two y -0.238075
# Multiple criteria
In [153]: df2[criterion & (df2['b'] == 'x')]
Out[153]:
a b c
3 three x 0.361719
随着选择方法通过标签选择，选择的位置，和高级索引你可能比一个轴使用布尔向量与其他索引表达式中合并一起更选择。
In [154]: df2.loc[criterion & (df2['b'] == 'x'), 'b':'c']
Out[154]:
b c
3 x 0.361719
用isin索引
考虑isin()方法Series，该方法将返回一个布尔向量，该布尔向量Series在传递的列表中存在的任何元素处都为真。这使您可以选择一行或多列具有所需值的行：
In [155]: s = pd.Series(np.arange(5), index=np.arange(5)[::-1], dtype='int64')
In [156]: s
Out[156]:
4 0
3 1
2 2
1 3
0 4
dtype: int64
In [157]: s.isin([2, 4, 6])
Out[157]:
4 False
3 False
2 True
1 False
0 True
dtype: bool
In [158]: s[s.isin([2, 4, 6])]
Out[158]:
2 2
0 4
dtype: int64
相同的方法可用于Index对象，并且在您不知道实际上找到了哪个标签的情况下很有用：
In [159]: s[s.index.isin([2, 4, 6])]
Out[159]:
4 0
2 2
dtype: int64
# compare it to the following
In [160]: s.reindex([2, 4, 6])
Out[160]:
2 2.0
4 0.0
6 NaN
dtype: float64
除此之外，还MultiIndex允许选择一个单独的级别以用于成员资格检查：
In [161]: s_mi = pd.Series(np.arange(6),
.....: index=pd.MultiIndex.from_product([[0, 1], ['a', 'b', 'c']]))
.....:
In [162]: s_mi
Out[162]:
0 a 0
b 1
c 2
1 a 3
b 4
c 5
dtype: int64
In [163]: s_mi.iloc[s_mi.index.isin([(1, 'a'), (2, 'b'), (0, 'c')])]
Out[163]:
0 c 2
1 a 3
dtype: int64
In [164]: s_mi.iloc[s_mi.index.isin(['a', 'c', 'e'], level=1)]
Out[164]:
0 a 0
c 2
1 a 3
c 5
dtype: int64
DataFrame也有一个isin()方法。调用时isin，将一组值作为数组或dict传递。如果values是一个数组，则isin返回一个与原始DataFrame形状相同的布尔值DataFrame，无论元素在值序列中的什么位置都为True。
In [165]: df = pd.DataFrame({'vals': [1, 2, 3, 4], 'ids': ['a', 'b', 'f', 'n'],
.....: 'ids2': ['a', 'n', 'c', 'n']})
.....:
In [166]: values = ['a', 'b', 1, 3]
In [167]: df.isin(values)
Out[167]:
vals ids ids2
0 True True True
1 False True False
2 True False False
3 False False False
通常，您需要将某些值与某些列匹配。只需将值设置为a即可dict，键是列，而值是要检查的项目列表。
In [168]: values = {'ids': ['a', 'b'], 'vals': [1, 3]}
In [169]: df.isin(values)
Out[169]:
vals ids ids2
0 True True False
1 False True False
2 True False False
3 False False False
将DataFrame isin与any()和all()方法结合使用，可以快速选择满足给定条件的数据子集。要选择每一列均符合其条件的行：
In [170]: values = {'ids': ['a', 'b'], 'ids2': ['a', 'c'], 'vals': [1, 3]}
In [171]: row_mask = df.isin(values).all(1)
In [172]: df[row_mask]
Out[172]:
vals ids ids2
0 1 a a
该where()方法和屏蔽
从具有布尔向量的Series中选择值通常会返回数据的子集。为了确保选择输出具有与原始数据相同的形状，可以where在Series和中使用方法DataFrame。
要仅返回选定的行：
In [173]: s[s > 0]
Out[173]:
3 1
2 2
1 3
0 4
dtype: int64
要返回与原始形状相同的系列：
In [174]: s.where(s > 0)
Out[174]:
4 NaN
3 1.0
2 2.0
1 3.0
0 4.0
dtype: float64
现在，从具有布尔条件的DataFrame中选择值还可以保留输入数据的形状。where在后台使用作为实现。以下代码等效于。df.where(df < 0)
In [175]: df[df < 0]
Out[175]:
A B C D
2000-01-01 -2.104139 -1.309525 NaN NaN
2000-01-02 -0.352480 NaN -1.192319 NaN
2000-01-03 -0.864883 NaN -0.227870 NaN
2000-01-04 NaN -1.222082 NaN -1.233203
2000-01-05 NaN -0.605656 -1.169184 NaN
2000-01-06 NaN -0.948458 NaN -0.684718
2000-01-07 -2.670153 -0.114722 NaN -0.048048
2000-01-08 NaN NaN -0.048788 -0.808838
此外，在返回的副本中，使用where一个可选other参数替换条件为False的值。
In [176]: df.where(df < 0, -df)
Out[176]:
A B C D
2000-01-01 -2.104139 -1.309525 -0.485855 -0.245166
2000-01-02 -0.352480 -0.390389 -1.192319 -1.655824
2000-01-03 -0.864883 -0.299674 -0.227870 -0.281059
2000-01-04 -0.846958 -1.222082 -0.600705 -1.233203
2000-01-05 -0.669692 -0.605656 -1.169184 -0.342416
2000-01-06 -0.868584 -0.948458 -2.297780 -0.684718
2000-01-07 -2.670153 -0.114722 -0.168904 -0.048048
2000-01-08 -0.801196 -1.392071 -0.048788 -0.808838
您可能希望根据某些布尔条件设置值。可以像这样直观地完成：
In [177]: s2 = s.copy()
In [178]: s2[s2 < 0] = 0
In [179]: s2
Out[179]:
4 0
3 1
2 2
1 3
0 4
dtype: int64
In [180]: df2 = df.copy()
In [181]: df2[df2 < 0] = 0
In [182]: df2
Out[182]:
A B C D
2000-01-01 0.000000 0.000000 0.485855 0.245166
2000-01-02 0.000000 0.390389 0.000000 1.655824
2000-01-03 0.000000 0.299674 0.000000 0.281059
2000-01-04 0.846958 0.000000 0.600705 0.000000
2000-01-05 0.669692 0.000000 0.000000 0.342416
2000-01-06 0.868584 0.000000 2.297780 0.000000
2000-01-07 0.000000 0.000000 0.168904 0.000000
2000-01-08 0.801196 1.392071 0.000000 0.000000
默认情况下，where返回数据的修改后的副本。有一个可选参数，inplace以便可以在不创建副本的情况下修改原始数据：
In [183]: df_orig = df.copy()
In [184]: df_orig.where(df > 0, -df, inplace=True)
In [185]: df_orig
Out[185]:
A B C D
2000-01-01 2.104139 1.309525 0.485855 0.245166
2000-01-02 0.352480 0.390389 1.192319 1.655824
2000-01-03 0.864883 0.299674 0.227870 0.281059
2000-01-04 0.846958 1.222082 0.600705 1.233203
2000-01-05 0.669692 0.605656 1.169184 0.342416
2000-01-06 0.868584 0.948458 2.297780 0.684718
2000-01-07 2.670153 0.114722 0.168904 0.048048
2000-01-08 0.801196 1.392071 0.048788 0.808838
注意 的签名DataFrame.where()不同于numpy.where()。大致相当于。df1.where(m, df2)np.where(m, df1, df2)
In [186]: df.where(df < 0, -df) == np.where(df < 0, df, -df)
Out[186]:
A B C D
2000-01-01 True True True True
2000-01-02 True True True True
2000-01-03 True True True True
2000-01-04 True True True True
2000-01-05 True True True True
2000-01-06 True True True True
2000-01-07 True True True True
2000-01-08 True True True True
对准
此外，where对齐输入的布尔条件（ndarray或DataFrame），以便可以通过设置进行部分选择。这类似于通过进行部分设置.loc（但在内容而非轴标签上）。
In [187]: df2 = df.copy()
In [188]: df2[df2[1:4] > 0] = 3
In [189]: df2
Out[189]:
A B C D
2000-01-01 -2.104139 -1.309525 0.485855 0.245166
2000-01-02 -0.352480 3.000000 -1.192319 3.000000
2000-01-03 -0.864883 3.000000 -0.227870 3.000000
2000-01-04 3.000000 -1.222082 3.000000 -1.233203
2000-01-05 0.669692 -0.605656 -1.169184 0.342416
2000-01-06 0.868584 -0.948458 2.297780 -0.684718
2000-01-07 -2.670153 -0.114722 0.168904 -0.048048
2000-01-08 0.801196 1.392071 -0.048788 -0.808838
执行时，where还可以接受axis和level参数以对齐输入where。
In [190]: df2 = df.copy()
In [191]: df2.where(df2 > 0, df2['A'], axis='index')
Out[191]:
A B C D
2000-01-01 -2.104139 -2.104139 0.485855 0.245166
2000-01-02 -0.352480 0.390389 -0.352480 1.655824
2000-01-03 -0.864883 0.299674 -0.864883 0.281059
2000-01-04 0.846958 0.846958 0.600705 0.846958
2000-01-05 0.669692 0.669692 0.669692 0.342416
2000-01-06 0.868584 0.868584 2.297780 0.868584
2000-01-07 -2.670153 -2.670153 0.168904 -2.670153
2000-01-08 0.801196 1.392071 0.801196 0.801196
这等效于（但比以下速度更快）。
In [192]: df2 = df.copy()
In [193]: df.apply(lambda x, y: x.where(x > 0, y), y=df['A'])
Out[193]:
A B C D
2000-01-01 -2.104139 -2.104139 0.485855 0.245166
2000-01-02 -0.352480 0.390389 -0.352480 1.655824
2000-01-03 -0.864883 0.299674 -0.864883 0.281059
2000-01-04 0.846958 0.846958 0.600705 0.846958
2000-01-05 0.669692 0.669692 0.669692 0.342416
2000-01-06 0.868584 0.868584 2.297780 0.868584
2000-01-07 -2.670153 -2.670153 0.168904 -2.670153
2000-01-08 0.801196 1.392071 0.801196 0.801196
0.18.1版中的新功能。
在哪里可以接受一个callable作为条件和other参数。该函数必须带有一个参数（调用Series或DataFrame），并且返回有效输出作为条件和other参数。
In [194]: df3 = pd.DataFrame({'A': [1, 2, 3],
.....: 'B': [4, 5, 6],
.....: 'C': [7, 8, 9]})
.....:
In [195]: df3.where(lambda x: x > 4, lambda x: x + 10)
Out[195]:
A B C
0 11 14 7
1 12 5 8
2 13 6 9
遮罩
mask()是的逆布尔运算where。
In [196]: s.mask(s >= 0)
Out[196]:
4 NaN
3 NaN
2 NaN
1 NaN
0 NaN
dtype: float64
In [197]: df.mask(df >= 0)
Out[197]:
A B C D
2000-01-01 -2.104139 -1.309525 NaN NaN
2000-01-02 -0.352480 NaN -1.192319 NaN
2000-01-03 -0.864883 NaN -0.227870 NaN
2000-01-04 NaN -1.222082 NaN -1.233203
2000-01-05 NaN -0.605656 -1.169184 NaN
2000-01-06 NaN -0.948458 NaN -0.684718
2000-01-07 -2.670153 -0.114722 NaN -0.048048
2000-01-08 NaN NaN -0.048788 -0.808838
该query()方法
DataFrame对象具有query() 允许使用表达式进行选择的方法。
您可以获取框架的值，其中column b的值在column a和的值之间c。例如：
In [198]: n = 10
In [199]: df = pd.DataFrame(np.random.rand(n, 3), columns=list('abc'))
In [200]: df
Out[200]:
a b c
0 0.438921 0.118680 0.863670
1 0.138138 0.577363 0.686602
2 0.595307 0.564592 0.520630
3 0.913052 0.926075 0.616184
4 0.078718 0.854477 0.898725
5 0.076404 0.523211 0.591538
6 0.792342 0.216974 0.564056
7 0.397890 0.454131 0.915716
8 0.074315 0.437913 0.019794
9 0.559209 0.502065 0.026437
# pure python
In [201]: df[(df.a < df.b) & (df.b < df.c)]
Out[201]:
a b c
1 0.138138 0.577363 0.686602
4 0.078718 0.854477 0.898725
5 0.076404 0.523211 0.591538
7 0.397890 0.454131 0.915716
# query
In [202]: df.query('(a < b) & (b < c)')
Out[202]:
a b c
1 0.138138 0.577363 0.686602
4 0.078718 0.854477 0.898725
5 0.076404 0.523211 0.591538
7 0.397890 0.454131 0.915716
做同样的事情，但是如果没有名称为的列，则使用命名索引a。
In [203]: df = pd.DataFrame(np.random.randint(n / 2, size=(n, 2)), columns=list('bc'))
In [204]: df.index.name = 'a'
In [205]: df
Out[205]:
b c
a
0 0 4
1 0 1
2 3 4
3 4 3
4 1 4
5 0 3
6 0 1
7 3 4
8 2 3
9 1 1
In [206]: df.query('a < b and b < c')
Out[206]:
b c
a
2 3 4
相反，如果您不想或无法命名索引，则可以index在查询表达式中使用该名称 ：
In [207]: df = pd.DataFrame(np.random.randint(n, size=(n, 2)), columns=list('bc'))
In [208]: df
Out[208]:
b c
0 3 1
1 3 0
2 5 6
3 5 2
4 7 4
5 0 1
6 2 5
7 0 1
8 6 0
9 7 9
In [209]: df.query('index < b < c')
Out[209]:
b c
2 5 6
注意 如果索引名与列名重叠，则列名优先。例如，
In [210]: df = pd.DataFrame({'a': np.random.randint(5, size=5)})
In [211]: df.index.name = 'a'
In [212]: df.query('a > 2') # uses the column 'a', not the index
Out[212]:
a
a
1 3
3 3
您仍然可以通过使用特殊标识符'index'在查询表达式中使用索引：
In [213]: df.query('index > 2')
Out[213]:
a
a
3 3
4 2
如果由于某种原因您有一个名为的列index，那么您也可以引用该索引ilevel_0，但是在这一点上，您应该考虑将列重命名为不太模糊的名称。
MultiIndex query()语法
您也可以将a的级别与a DataFrame一起使用 MultiIndex，就好像它们是框架中的列一样：
In [214]: n = 10
In [215]: colors = np.random.choice(['red', 'green'], size=n)
In [216]: foods = np.random.choice(['eggs', 'ham'], size=n)
In [217]: colors
Out[217]:
array(['red', 'red', 'red', 'green', 'green', 'green', 'green', 'green',
'green', 'green'], dtype='<U5')
In [218]: foods
Out[218]:
array(['ham', 'ham', 'eggs', 'eggs', 'eggs', 'ham', 'ham', 'eggs', 'eggs',
'eggs'], dtype='<U4')
In [219]: index = pd.MultiIndex.from_arrays([colors, foods], names=['color', 'food'])
In [220]: df = pd.DataFrame(np.random.randn(n, 2), index=index)
In [221]: df
Out[221]:
0 1
color food
red ham 0.194889 -0.381994
ham 0.318587 2.089075
eggs -0.728293 -0.090255
green eggs -0.748199 1.318931
eggs -2.029766 0.792652
ham 0.461007 -0.542749
ham -0.305384 -0.479195
eggs 0.095031 -0.270099
eggs -0.707140 -0.773882
eggs 0.229453 0.304418
In [222]: df.query('color == "red"')
Out[222]:
0 1
color food
red ham 0.194889 -0.381994
ham 0.318587 2.089075
eggs -0.728293 -0.090255
如果的级别MultiIndex未命名，则可以使用特殊名称来引用它们：
In [223]: df.index.names = [None, None]
In [224]: df
Out[224]:
0 1
red ham 0.194889 -0.381994
ham 0.318587 2.089075
eggs -0.728293 -0.090255
green eggs -0.748199 1.318931
eggs -2.029766 0.792652
ham 0.461007 -0.542749
ham -0.305384 -0.479195
eggs 0.095031 -0.270099
eggs -0.707140 -0.773882
eggs 0.229453 0.304418
In [225]: df.query('ilevel_0 == "red"')
Out[225]:
0 1
red ham 0.194889 -0.381994
ham 0.318587 2.089075
eggs -0.728293 -0.090255
约定为ilevel_0，表示的第0级为“索引级别0” index。
query()用例
一个用例query()是当您有一组 DataFrame对象，这些对象具有共同的列名称（或索引级别/名称）的子集。您可以将相同的查询传递给两个框架，而 不必指定要查询的框架
In [226]: df = pd.DataFrame(np.random.rand(n, 3), columns=list('abc'))
In [227]: df
Out[227]:
a b c
0 0.224283 0.736107 0.139168
1 0.302827 0.657803 0.713897
2 0.611185 0.136624 0.984960
3 0.195246 0.123436 0.627712
4 0.618673 0.371660 0.047902
5 0.480088 0.062993 0.185760
6 0.568018 0.483467 0.445289
7 0.309040 0.274580 0.587101
8 0.258993 0.477769 0.370255
9 0.550459 0.840870 0.304611
In [228]: df2 = pd.DataFrame(np.random.rand(n + 2, 3), columns=df.columns)
In [229]: df2
Out[229]:
a b c
0 0.357579 0.229800 0.596001
1 0.309059 0.957923 0.965663
2 0.123102 0.336914 0.318616
3 0.526506 0.323321 0.860813
4 0.518736 0.486514 0.384724
5 0.190804 0.505723 0.614533
6 0.891939 0.623977 0.676639
7 0.480559 0.378528 0.460858
8 0.420223 0.136404 0.141295
9 0.732206 0.419540 0.604675
10 0.604466 0.848974 0.896165
11 0.589168 0.920046 0.732716
In [230]: expr = '0.0 <= a <= c <= 0.5'
In [231]: map(lambda frame: frame.query(expr), [df, df2])
Out[231]: <map at 0x7fb06bd71cf8>
query()Python与Pandas语法比较
完整的类似numpy的语法：
In [232]: df = pd.DataFrame(np.random.randint(n, size=(n, 3)), columns=list('abc'))
In [233]: df
Out[233]:
a b c
0 7 8 9
1 1 0 7
2 2 7 2
3 6 2 2
4 2 6 3
5 3 8 2
6 1 7 2
7 5 1 5
8 9 8 0
9 1 5 0
In [234]: df.query('(a < b) & (b < c)')
Out[234]:
a b c
0 7 8 9
In [235]: df[(df.a < df.b) & (df.b < df.c)]
Out[235]:
a b c
0 7 8 9
删除括号会稍微好一点（通过绑定使比较运算符比&和更紧密地绑定|）。
In [236]: df.query('a < b & b < c')
Out[236]:
a b c
0 7 8 9
使用英语代替符号：
In [237]: df.query('a < b and b < c')
Out[237]:
a b c
0 7 8 9
非常接近您在纸上书写的方式：
In [238]: df.query('a < b < c')
Out[238]:
a b c
0 7 8 9
在in与运营商not in
query()还支持Python in和 比较运算符的特殊用法，为调用a 或方法提供了简洁的语法 。not inisinSeriesDataFrame
# get all rows where columns "a" and "b" have overlapping values
In [239]: df = pd.DataFrame({'a': list('aabbccddeeff'), 'b': list('aaaabbbbcccc'),
.....: 'c': np.random.randint(5, size=12),
.....: 'd': np.random.randint(9, size=12)})
.....:
In [240]: df
Out[240]:
a b c d
0 a a 2 6
1 a a 4 7
2 b a 1 6
3 b a 2 1
4 c b 3 6
5 c b 0 2
6 d b 3 3
7 d b 2 1
8 e c 4 3
9 e c 2 0
10 f c 0 6
11 f c 1 2
In [241]: df.query('a in b')
Out[241]:
a b c d
0 a a 2 6
1 a a 4 7
2 b a 1 6
3 b a 2 1
4 c b 3 6
5 c b 0 2
# How you'd do it in pure Python
In [242]: df[df.a.isin(df.b)]
Out[242]:
a b c d
0 a a 2 6
1 a a 4 7
2 b a 1 6
3 b a 2 1
4 c b 3 6
5 c b 0 2
In [243]: df.query('a not in b')
Out[243]:
a b c d
6 d b 3 3
7 d b 2 1
8 e c 4 3
9 e c 2 0
10 f c 0 6
11 f c 1 2
# pure Python
In [244]: df[~df.a.isin(df.b)]
Out[244]:
a b c d
6 d b 3 3
7 d b 2 1
8 e c 4 3
9 e c 2 0
10 f c 0 6
11 f c 1 2
您可以将其与其他表达式结合使用以进行非常简洁的查询：
# rows where cols a and b have overlapping values
# and col c's values are less than col d's
In [245]: df.query('a in b and c < d')
Out[245]:
a b c d
0 a a 2 6
1 a a 4 7
2 b a 1 6
4 c b 3 6
5 c b 0 2
# pure Python
In [246]: df[df.b.isin(df.a) & (df.c < df.d)]
Out[246]:
a b c d
0 a a 2 6
1 a a 4 7
2 b a 1 6
4 c b 3 6
5 c b 0 2
10 f c 0 6
11 f c 1 2
注意 请注意，在Python中对in和进行了评估，因为 该操作不等效。但是，在香草Python中仅对 / 表达式本身进行求值。例如，在表达式中not innumexpr innot in
df.query('a in b + c + d')
(b + c + d)通过评估numexpr和然后的in 操作在普通的Python评价。通常，将使用可以评估的任何操作numexpr。
==运算符与list对象的特殊用法
list使用==/ 将值a与列进行比较!=类似于in/ 。not in
In [247]: df.query('b == ["a", "b", "c"]')
Out[247]:
a b c d
0 a a 2 6
1 a a 4 7
2 b a 1 6
3 b a 2 1
4 c b 3 6
5 c b 0 2
6 d b 3 3
7 d b 2 1
8 e c 4 3
9 e c 2 0
10 f c 0 6
11 f c 1 2
# pure Python
In [248]: df[df.b.isin(["a", "b", "c"])]
Out[248]:
a b c d
0 a a 2 6
1 a a 4 7
2 b a 1 6
3 b a 2 1
4 c b 3 6
5 c b 0 2
6 d b 3 3
7 d b 2 1
8 e c 4 3
9 e c 2 0
10 f c 0 6
11 f c 1 2
In [249]: df.query('c == [1, 2]')
Out[249]:
a b c d
0 a a 2 6
2 b a 1 6
3 b a 2 1
7 d b 2 1
9 e c 2 0
11 f c 1 2
In [250]: df.query('c != [1, 2]')
Out[250]:
a b c d
1 a a 4 7
4 c b 3 6
5 c b 0 2
6 d b 3 3
8 e c 4 3
10 f c 0 6
# using in/not in
In [251]: df.query('[1, 2] in c')
Out[251]:
a b c d
0 a a 2 6
2 b a 1 6
3 b a 2 1
7 d b 2 1
9 e c 2 0
11 f c 1 2
In [252]: df.query('[1, 2] not in c')
Out[252]:
a b c d
1 a a 4 7
4 c b 3 6
5 c b 0 2
6 d b 3 3
8 e c 4 3
10 f c 0 6
# pure Python
In [253]: df[df.c.isin([1, 2])]
Out[253]:
a b c d
0 a a 2 6
2 b a 1 6
3 b a 2 1
7 d b 2 1
9 e c 2 0
11 f c 1 2
布尔运算符
您可以使用单词not或~运算符取反布尔表达式。
In [254]: df = pd.DataFrame(np.random.rand(n, 3), columns=list('abc'))
In [255]: df['bools'] = np.random.rand(len(df)) > 0.5
In [256]: df.query('~bools')
Out[256]:
a b c bools
2 0.697753 0.212799 0.329209 False
7 0.275396 0.691034 0.826619 False
8 0.190649 0.558748 0.262467 False
In [257]: df.query('not bools')
Out[257]:
a b c bools
2 0.697753 0.212799 0.329209 False
7 0.275396 0.691034 0.826619 False
8 0.190649 0.558748 0.262467 False
In [258]: df.query('not bools') == df[~df.bools]
Out[258]:
a b c bools
2 True True True True
7 True True True True
8 True True True True
当然，表达式也可以任意复杂：
# short query syntax
In [259]: shorter = df.query('a < b < c and (not bools) or bools > 2')
# equivalent in pure Python
In [260]: longer = df[(df.a < df.b) & (df.b < df.c) & (~df.bools) | (df.bools > 2)]
In [261]: shorter
Out[261]:
a b c bools
7 0.275396 0.691034 0.826619 False
In [262]: longer
Out[262]:
a b c bools
7 0.275396 0.691034 0.826619 False
In [263]: shorter == longer
Out[263]:
a b c bools
7 True True True True
性能query()
DataFrame.query()numexpr对于大型框架，使用速度比Python快。
../_images/query-perf.png
注意 仅当您的框架中有大约200,000行以上时，才可以看到使用numexpr引擎的性能优势DataFrame.query()。
../_images/query-perf-small.png
此图是使用组成的DataFrame，其中包含3列，每个列包含使用生成的浮点值numpy.random.randn()。
重复数据
如果要标识和删除DataFrame中的重复行，有两种方法会有所帮助：duplicated和drop_duplicates。每个参数都以用于标识重复行的列作为参数。
duplicated 返回一个布尔矢量，其长度为行数，并指示是否重复一行。
drop_duplicates 删除重复的行。
默认情况下，观察到的重复集的第一行被认为是唯一的，但是每种方法都有一个keep参数来指定要保留的目标。
keep='first' （默认）：标记/删除重复项，但第一次出现除外。
keep='last'：标记/删除重复项（最后一次除外）。
keep=False：标记/删除所有重复项。
In [264]: df2 = pd.DataFrame({'a': ['one', 'one', 'two', 'two', 'two', 'three', 'four'],
.....: 'b': ['x', 'y', 'x', 'y', 'x', 'x', 'x'],
.....: 'c': np.random.randn(7)})
.....:
In [265]: df2
Out[265]:
a b c
0 one x -1.067137
1 one y 0.309500
2 two x -0.211056
3 two y -1.842023
4 two x -0.390820
5 three x -1.964475
6 four x 1.298329
In [266]: df2.duplicated('a')
Out[266]:
0 False
1 True
2 False
3 True
4 True
5 False
6 False
dtype: bool
In [267]: df2.duplicated('a', keep='last')
Out[267]:
0 True
1 False
2 True
3 True
4 False
5 False
6 False
dtype: bool
In [268]: df2.duplicated('a', keep=False)
Out[268]:
0 True
1 True
2 True
3 True
4 True
5 False
6 False
dtype: bool
In [269]: df2.drop_duplicates('a')
Out[269]:
a b c
0 one x -1.067137
2 two x -0.211056
5 three x -1.964475
6 four x 1.298329
In [270]: df2.drop_duplicates('a', keep='last')
Out[270]:
a b c
1 one y 0.309500
4 two x -0.390820
5 three x -1.964475
6 four x 1.298329
In [271]: df2.drop_duplicates('a', keep=False)
Out[271]:
a b c
5 three x -1.964475
6 four x 1.298329
另外，您可以传递列列表以标识重复项。
In [272]: df2.duplicated(['a', 'b'])
Out[272]:
0 False
1 False
2 False
3 False
4 True
5 False
6 False
dtype: bool
In [273]: df2.drop_duplicates(['a', 'b'])
Out[273]:
a b c
0 one x -1.067137
1 one y 0.309500
2 two x -0.211056
3 two y -1.842023
5 three x -1.964475
6 four x 1.298329
要按索引值删除重复项，请使用，Index.duplicated然后执行切片。该keep参数具有相同的选项集。
In [274]: df3 = pd.DataFrame({'a': np.arange(6),
.....: 'b': np.random.randn(6)},
.....: index=['a', 'a', 'b', 'c', 'b', 'a'])
.....:
In [275]: df3
Out[275]:
a b
a 0 1.440455
a 1 2.456086
b 2 1.038402
c 3 -0.894409
b 4 0.683536
a 5 3.082764
In [276]: df3.index.duplicated()
Out[276]: array([False, True, False, False, True, True])
In [277]: df3[~df3.index.duplicated()]
Out[277]:
a b
a 0 1.440455
b 2 1.038402
c 3 -0.894409
In [278]: df3[~df3.index.duplicated(keep='last')]
Out[278]:
a b
c 3 -0.894409
b 4 0.683536
a 5 3.082764
In [279]: df3[~df3.index.duplicated(keep=False)]
Out[279]:
a b
c 3 -0.894409
类似字典的get()方法
每个Series或DataFrame都有一个get可以返回默认值的方法。
In [280]: s = pd.Series([1, 2, 3], index=['a', 'b', 'c'])
In [281]: s.get('a') # equivalent to s['a']
Out[281]: 1
In [282]: s.get('x', default=-1)
Out[282]: -1
该lookup()方法
有时，您需要提取给定一系列行标签和列标签的一组值，并且该lookup方法允许这样做并返回NumPy数组。例如：
In [283]: dflookup = pd.DataFrame(np.random.rand(20, 4), columns = ['A', 'B', 'C', 'D'])
In [284]: dflookup.lookup(list(range(0, 10, 2)), ['B', 'C', 'A', 'B', 'D'])
Out[284]: array([0.3506, 0.4779, 0.4825, 0.9197, 0.5019])
索引对象
pandas Index类及其子类可以看作实现了有序的多集。允许重复。但是，如果您尝试将Index具有重复条目的对象转换为 set，则会引发异常。
Index还提供了查找，数据对齐和重新索引所需的基础结构。Index直接创建一个最简单的方法 是将a list或其他序列传递给 Index：
In [285]: index = pd.Index(['e', 'd', 'a', 'b'])
In [286]: index
Out[286]: Index(['e', 'd', 'a', 'b'], dtype='object')
In [287]: 'd' in index
Out[287]: True
您还可以传递name要存储在索引中的：
In [288]: index = pd.Index(['e', 'd', 'a', 'b'], name='something')
In [289]: index.name
Out[289]: 'something'
名称（如果已设置）将显示在控制台显示屏中：
In [290]: index = pd.Index(list(range(5)), name='rows')
In [291]: columns = pd.Index(['A', 'B', 'C'], name='cols')
In [292]: df = pd.DataFrame(np.random.randn(5, 3), index=index, columns=columns)
In [293]: df
Out[293]:
cols A B C
rows
0 1.295989 0.185778 0.436259
1 0.678101 0.311369 -0.528378
2 -0.674808 -1.103529 -0.656157
3 1.889957 2.076651 -1.102192
4 -1.211795 -0.791746 0.634724
In [294]: df['A']
Out[294]:
rows
0 1.295989
1 0.678101
2 -0.674808
3 1.889957
4 -1.211795
Name: A, dtype: float64
设置的元数据
索引是“不可改变的大多是”，但它可以设置和改变它们的元数据，如指数name（或为MultiIndex，levels和 codes）。
您可以使用rename，set_names，set_levels，和set_codes 直接设置这些属性。他们默认返回一个副本。但是，您可以指定inplace=True将数据更改到位。
有关MultiIndexes的用法，请参阅高级索引。
In [295]: ind = pd.Index([1, 2, 3])
In [296]: ind.rename("apple")
Out[296]: Int64Index([1, 2, 3], dtype='int64', name='apple')
In [297]: ind
Out[297]: Int64Index([1, 2, 3], dtype='int64')
In [298]: ind.set_names(["apple"], inplace=True)
In [299]: ind.name = "bob"
In [300]: ind
Out[300]: Int64Index([1, 2, 3], dtype='int64', name='bob')
set_names，set_levels以及set_codes还需要一个可选的 level参数
In [301]: index = pd.MultiIndex.from_product([range(3), ['one', 'two']], names=['first', 'second'])
In [302]: index
Out[302]:
MultiIndex(levels=[[0, 1, 2], ['one', 'two']],
codes=[[0, 0, 1, 1, 2, 2], [0, 1, 0, 1, 0, 1]],
names=['first', 'second'])
In [303]: index.levels[1]
Out[303]: Index(['one', 'two'], dtype='object', name='second')
In [304]: index.set_levels(["a", "b"], level=1)
Out[304]:
MultiIndex(levels=[[0, 1, 2], ['a', 'b']],
codes=[[0, 0, 1, 1, 2, 2], [0, 1, 0, 1, 0, 1]],
names=['first', 'second'])
在索引对象设置操作
两个主要操作是和。这些可以直接称为实例方法，也可以通过重载运算符使用。通过该方法提供差异。union (|)intersection (&).difference()
In [305]: a = pd.Index(['c', 'b', 'a'])
In [306]: b = pd.Index(['c', 'e', 'd'])
In [307]: a | b
Out[307]: Index(['a', 'b', 'c', 'd', 'e'], dtype='object')
In [308]: a & b
Out[308]: Index(['c'], dtype='object')
In [309]: a.difference(b)
Out[309]: Index(['a', 'b'], dtype='object')
该操作也可用，该操作返回出现在或中的元素，但不同时出现在这两个元素中。这等效于所创建的索引，其中删除了重复项。symmetric_difference (^)idx1idx2idx1.difference(idx2).union(idx2.difference(idx1))
In [310]: idx1 = pd.Index([1, 2, 3, 4])
In [311]: idx2 = pd.Index([2, 3, 4, 5])
In [312]: idx1.symmetric_difference(idx2)
Out[312]: Int64Index([1, 5], dtype='int64')
In [313]: idx1 ^ idx2
Out[313]: Int64Index([1, 5], dtype='int64')
注意 设置操作产生的索引将按升序排序。
缺失值
重要 即使Index可以保留缺少的值（NaN），如果您不希望有任何意外的结果，也应避免使用。例如，某些操作会隐式排除缺失值。
Index.fillna 用指定的标量值填充缺少的值。
In [314]: idx1 = pd.Index([1, np.nan, 3, 4])
In [315]: idx1
Out[315]: Float64Index([1.0, nan, 3.0, 4.0], dtype='float64')
In [316]: idx1.fillna(2)
Out[316]: Float64Index([1.0, 2.0, 3.0, 4.0], dtype='float64')
In [317]: idx2 = pd.DatetimeIndex([pd.Timestamp('2011-01-01'),
.....: pd.NaT,
.....: pd.Timestamp('2011-01-03')])
.....:
In [318]: idx2
Out[318]: DatetimeIndex(['2011-01-01', 'NaT', '2011-01-03'], dtype='datetime64[ns]', freq=None)
In [319]: idx2.fillna(pd.Timestamp('2011-01-02'))
Out[319]: DatetimeIndex(['2011-01-01', '2011-01-02', '2011-01-03'], dtype='datetime64[ns]', freq=None)
设置/重置索引
有时候，您会在DataFrame中加载或创建数据集，并希望在完成后添加索引。有几种不同的方法。
设置索引
DataFrame有一个set_index()方法，该方法采用列名（对于常规Index）或列名列表（对于MultiIndex）。要创建一个新的，重新索引的DataFrame：
In [320]: data
Out[320]:
a b c d
0 bar one z 1.0
1 bar two y 2.0
2 foo one x 3.0
3 foo two w 4.0
In [321]: indexed1 = data.set_index('c')
In [322]: indexed1
Out[322]:
a b d
c
z bar one 1.0
y bar two 2.0
x foo one 3.0
w foo two 4.0
In [323]: indexed2 = data.set_index(['a', 'b'])
In [324]: indexed2
Out[324]:
c d
a b
bar one z 1.0
two y 2.0
foo one x 3.0
two w 4.0
该append关键字选项让你保持现有索引并追加给列一个多指标：
In [325]: frame = data.set_index('c', drop=False)
In [326]: frame = frame.set_index(['a', 'b'], append=True)
In [327]: frame
Out[327]:
c d
c a b
z bar one z 1.0
y bar two y 2.0
x foo one x 3.0
w foo two w 4.0
中的其他选项set_index允许您不要删除索引列或就地添加索引（无需创建新对象）：
In [328]: data.set_index('c', drop=False)
Out[328]:
a b c d
c
z bar one z 1.0
y bar two y 2.0
x foo one x 3.0
w foo two w 4.0
In [329]: data.set_index(['a', 'b'], inplace=True)
In [330]: data
Out[330]:
c d
a b
bar one z 1.0
two y 2.0
foo one x 3.0
two w 4.0
重置指数
为方便起见，DataFrame上有一个新函数，reset_index()该函数 将索引值传输到DataFrame的列中并设置一个简单的整数索引。这是的逆运算set_index()。
In [331]: data
Out[331]:
c d
a b
bar one z 1.0
two y 2.0
foo one x 3.0
two w 4.0
In [332]: data.reset_index()
Out[332]:
a b c d
0 bar one z 1.0
1 bar two y 2.0
2 foo one x 3.0
3 foo two w 4.0
输出与SQL表或记录数组更相似。从索引派生的列的名称是存储在names属性中的名称。
您可以使用level关键字仅删除部分索引：
In [333]: frame
Out[333]:
c d
c a b
z bar one z 1.0
y bar two y 2.0
x foo one x 3.0
w foo two w 4.0
In [334]: frame.reset_index(level=1)
Out[334]:
a c d
c b
z one bar z 1.0
y two bar y 2.0
x one foo x 3.0
w two foo w 4.0
reset_index接受一个可选参数drop，如果为true，则该参数将简单地丢弃索引，而不是将索引值放在DataFrame的列中。
添加临时索引
如果您自己创建索引，则可以将其分配给该index字段：
data.index = index
返回视图与副本
在熊猫对象中设置值时，必须注意避免所谓的 。这是一个例子。chained indexing
In [335]: dfmi = pd.DataFrame([list('abcd'),
.....: list('efgh'),
.....: list('ijkl'),
.....: list('mnop')],
.....: columns=pd.MultiIndex.from_product([['one', 'two'],
.....: ['first', 'second']]))
.....:
In [336]: dfmi
Out[336]:
one two
first second first second
0 a b c d
1 e f g h
2 i j k l
3 m n o p
比较这两种访问方法：
In [337]: dfmi['one']['second']
Out[337]:
0 b
1 f
2 j
3 n
Name: second, dtype: object
In [338]: dfmi.loc[:, ('one', 'second')]
Out[338]:
0 b
1 f
2 j
3 n
Name: (one, second), dtype: object
两者都会产生相同的结果，那么您应该使用哪个呢？了解这些操作的顺序以及为什么方法2（.loc）比方法1（链接[]）更可取是很有启发性的。
dfmi['one']选择列的第一级并返回一个单独索引的DataFrame。然后另一个Python操作dfmi_with_one['second']选择由索引的系列'second'。这由变量指示，dfmi_with_one因为熊猫将这些操作视为单独的事件。例如，对的单独调用__getitem__，因此必须将它们视为线性操作，它们接连发生。
与之形成对照的是df.loc[:,('one','second')]，将嵌套的元组传递(slice(None),('one','second'))给的单个调用 __getitem__。这使大熊猫可以将其作为一个整体来处理。此外，这种操作顺序可以明显更快，并且如果需要的话，可以使两个轴分度。
为什么使用链接索引时分配失败？
上一节中的问题仅仅是性能问题。有什么用的了SettingWithCopy警告？当您执行可能需要花费几毫秒的时间时，我们通常不会发出警告！
但是事实证明，分配给链式索引的产品具有固有的不可预测的结果。要查看此内容，请考虑Python解释器如何执行此代码：
dfmi.loc[:, ('one', 'second')] = value
# becomes
dfmi.loc.__setitem__((slice(None), ('one', 'second')), value)
但是此代码的处理方式不同：
dfmi['one']['second'] = value
# becomes
dfmi.__getitem__('one').__setitem__('second', value)
看到__getitem__那里吗？在简单情况之外，很难预测它是否将返回视图或副本（这取决于数组的内存布局，有关大熊猫对此不做任何保证），因此很难确定将__setitem__要修改dfmi还是返回一个临时对象。之后立即扔出去。那什么SettingWithCopy是警告你！
注意 您可能想知道loc 在第一个示例中我们是否应该关注该属性。但dfmi.loc要保证dfmi 自身具有修改的索引行为，因此dfmi.loc.__getitem__/ 直接dfmi.loc.__setitem__进行操作dfmi。当然， dfmi.loc.__getitem__(idx)可以是的视图或副本dfmi。
有时SettingWithCopy在没有明显的链接索引进行时，有时会发出警告。这些SettingWithCopy是旨在捕获的错误 ！熊猫可能正在尝试警告您，您已经这样做了：
def do_something(df):
foo = df[['bar', 'baz']] # Is foo a view? A copy? Nobody knows!
# ... many lines here ...
# We don't know whether this will modify df or not!
foo['quux'] = value
return foo
kes！
评估顺序很重要
使用链式索引时，索引操作的顺序和类型将部分确定结果是原始对象的切片还是该切片的副本。
Pandas之所以这样，是SettingWithCopyWarning因为分配分片的副本通常不是故意的，而是由链式索引导致的错误，该错误将原本应有分片的副本返回。
如果您希望熊猫在某种程度上信任链式索引表达式的分配，可以将选项 设置mode.chained_assignment为以下值之一：
'warn'，即默认值，表示SettingWithCopyWarning已打印a。
'raise'意味着大熊猫会筹集一个SettingWithCopyException 你必须处理的。
None 将完全消除警告。
In [339]: dfb = pd.DataFrame({'a': ['one', 'one', 'two',
.....: 'three', 'two', 'one', 'six'],
.....: 'c': np.arange(7)})
.....:
# This will show the SettingWithCopyWarning
# but the frame values will be set
In [340]: dfb['c'][dfb.a.str.startswith('o')] = 42
但是，此操作正在副本上，将无法使用。
>>> pd.set_option('mode.chained_assignment','warn')
>>> dfb[dfb.a.str.startswith('o')]['c'] = 42
Traceback (most recent call last)
...
SettingWithCopyWarning:
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_index,col_indexer] = value instead
链接的分配也可以在混合dtype框架中进行设置。
注意 这些设置规则适用于.loc/.iloc。
这是正确的访问方法：
In [341]: dfc = pd.DataFrame({'A': ['aaa', 'bbb', 'ccc'], 'B': [1, 2, 3]})
In [342]: dfc.loc[0, 'A'] = 11
In [343]: dfc
Out[343]:
A B
0 11 1
1 bbb 2
2 ccc 3
这可以在次工作，但它不能保证，因此应避免：
In [344]: dfc = dfc.copy()
In [345]: dfc['A'][0] = 111
In [346]: dfc
Out[346]:
A B
0 111 1
1 bbb 2
2 ccc 3
这根本不起作用，因此应避免：
>>> pd.set_option('mode.chained_assignment','raise')
>>> dfc.loc[0]['A'] = 1111
Traceback (most recent call last)
...
SettingWithCopyException:
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_index,col_indexer] = value instead
警告 链接的作业警告/异常旨在通知用户可能无效的作业。可能存在误报；意外报告链接分配的情况
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
