索引和数据选择器

Pandas对象中的轴标记信息有多种用途：

  • 使用已知指标识别数据（即提供元数据），这对于分析，可视化和交互式控制台显示非常重要。
  • 启用自动和显式数据对齐。
  • 允许直观地获取和设置数据集的子集。

在本节中，我们将重点关注最后一点：即如何切片，切块，以及通常获取和设置pandas对象的子集。主要关注的是Series和DataFrame，因为他们在这个领域受到了更多的开发关注。

::: tip 注意

Python和NumPy索引运算符[]和属性运算符. 可以在各种用例中快速轻松地访问pandas数据结构。这使得交互式工作变得直观，因为如果您已经知道如何处理Python字典和NumPy数组，那么几乎没有新的东西需要学习。但是，由于预先不知道要访问的数据类型，因此直接使用标准运算符会有一些优化限制。对于生产代码，我们建议您利用本章中介绍的优化的pandas数据访问方法。

:::

::: danger 警告

是否为设置操作返回副本或引用可能取决于上下文。这有时被称为应该避免。请参阅返回视图与复制。chained assignment

:::

::: danger 警告

使用浮点数对基于整数的索引进行索引已在0.18.0中进行了说明，有关更改的摘要，请参见此处。

:::

见多指标/高级索引的MultiIndex和更先进的索引文件。

有关一些高级策略，请参阅食谱。

索引的不同选择

对象选择已经有许多用户请求的添加，以支持更明确的基于位置的索引。Pandas现在支持三种类型的多轴索引。

  • .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 切片 语义）。允许的输入是：

    • 一个整数，例如5。
    • 整数列表或数组。[4, 3, 0]
    • 带有整数的切片对象1:7。
    • 布尔数组。

    • 一个callable带有一个参数的函数（调用Series或DataFrame）并返回有效的索引输出（上面的一个）。

      版本0.18.1中的新功能。

      有关详细信息，请参阅按位置选择，高级索引和高级层次结构。

  • .loc，.iloc以及[]索引也可以接受一个callable索引器。在Select By Callable中查看更多信息。

从具有多轴选择的对象获取值使用以下表示法（使用.loc作为示例，但以下也适用.iloc）。任何轴访问器可以是空切片:。假设超出规范的轴是:，例如p.loc['a']相当于 。p.loc['a', :, :]

对象类型 索引
系列 s.loc[indexer]
数据帧 df.loc[row_indexer,column_indexer]

基础知识

正如在上一节中介绍数据结构时所提到的，索引的主要功能[]（也就是__getitem__ 那些熟悉在Python中实现类行为的人）是选择低维切片。下表显示了使用以下方法索引pandas对象时的返回类型值[]：

对象类型 选择 返回值类型
系列 series[label] 标量值
数据帧 frame[colname] Series 对应于colname

在这里，我们构建一个简单的时间序列数据集，用于说明索引功能：

  1. In [1]: dates = pd.date_range('1/1/2000', periods=8)
  3. In [2]: df = pd.DataFrame(np.random.randn(8, 4),
  4.    ...:                   index=dates, columns=['A', 'B', 'C', 'D'])
  5.    ...: 
  7. In [3]: df
  8. Out[3]: 
  9.                    A         B         C         D
  10. 2000-01-01  0.469112 -0.282863 -1.509059 -1.135632
  11. 2000-01-02  1.212112 -0.173215  0.119209 -1.044236
  12. 2000-01-03 -0.861849 -2.104569 -0.494929  1.071804
  13. 2000-01-04  0.721555 -0.706771 -1.039575  0.271860
  14. 2000-01-05 -0.424972  0.567020  0.276232 -1.087401
  15. 2000-01-06 -0.673690  0.113648 -1.478427  0.524988
  16. 2000-01-07  0.404705  0.577046 -1.715002 -1.039268
  17. 2000-01-08 -0.370647 -1.157892 -1.344312  0.844885

::: tip 注意

除非特别说明，否则索引功能都不是时间序列特定的。

:::

因此，如上所述，我们使用最基本的索引[]：

  1. In [4]: s = df['A']
  3. In [5]: s[dates[5]]
  4. Out[5]: -0.6736897080883706

您可以传递列表列表[]以按该顺序选择列。如果DataFrame中未包含列，则会引发异常。也可以这种方式设置多列：

  1. In [6]: df
  2. Out[6]: 
  3.                    A         B         C         D
  4. 2000-01-01  0.469112 -0.282863 -1.509059 -1.135632
  5. 2000-01-02  1.212112 -0.173215  0.119209 -1.044236
  6. 2000-01-03 -0.861849 -2.104569 -0.494929  1.071804
  7. 2000-01-04  0.721555 -0.706771 -1.039575  0.271860
  8. 2000-01-05 -0.424972  0.567020  0.276232 -1.087401
  9. 2000-01-06 -0.673690  0.113648 -1.478427  0.524988
  10. 2000-01-07  0.404705  0.577046 -1.715002 -1.039268
  11. 2000-01-08 -0.370647 -1.157892 -1.344312  0.844885
  13. In [7]: df[['B', 'A']] = df[['A', 'B']]
  15. In [8]: df
  16. Out[8]: 
  17.                    A         B         C         D
  18. 2000-01-01 -0.282863  0.469112 -1.509059 -1.135632
  19. 2000-01-02 -0.173215  1.212112  0.119209 -1.044236
  20. 2000-01-03 -2.104569 -0.861849 -0.494929  1.071804
  21. 2000-01-04 -0.706771  0.721555 -1.039575  0.271860
  22. 2000-01-05  0.567020 -0.424972  0.276232 -1.087401
  23. 2000-01-06  0.113648 -0.673690 -1.478427  0.524988
  24. 2000-01-07  0.577046  0.404705 -1.715002 -1.039268
  25. 2000-01-08 -1.157892 -0.370647 -1.344312  0.844885

您可能会发现这对于将变换（就地）应用于列的子集非常有用。

::: danger 警告

pandas在设置Series和DataFrame来自.loc和时对齐所有AXES .iloc。

这不会修改，df因为列对齐在赋值之前。

  1. In [9]: df[['A', 'B']]
  2. Out[9]: 
  3.                    A         B
  4. 2000-01-01 -0.282863  0.469112
  5. 2000-01-02 -0.173215  1.212112
  6. 2000-01-03 -2.104569 -0.861849
  7. 2000-01-04 -0.706771  0.721555
  8. 2000-01-05  0.567020 -0.424972
  9. 2000-01-06  0.113648 -0.673690
  10. 2000-01-07  0.577046  0.404705
  11. 2000-01-08 -1.157892 -0.370647
  13. In [10]: df.loc[:, ['B', 'A']] = df[['A', 'B']]
  15. In [11]: df[['A', 'B']]
  16. Out[11]: 
  17.                    A         B
  18. 2000-01-01 -0.282863  0.469112
  19. 2000-01-02 -0.173215  1.212112
  20. 2000-01-03 -2.104569 -0.861849
  21. 2000-01-04 -0.706771  0.721555
  22. 2000-01-05  0.567020 -0.424972
  23. 2000-01-06  0.113648 -0.673690
  24. 2000-01-07  0.577046  0.404705
  25. 2000-01-08 -1.157892 -0.370647

交换列值的正确方法是使用原始值：

  1. In [12]: df.loc[:, ['B', 'A']] = df[['A', 'B']].to_numpy()
  3. In [13]: df[['A', 'B']]
  4. Out[13]: 
  5.                    A         B
  6. 2000-01-01  0.469112 -0.282863
  7. 2000-01-02  1.212112 -0.173215
  8. 2000-01-03 -0.861849 -2.104569
  9. 2000-01-04  0.721555 -0.706771
  10. 2000-01-05 -0.424972  0.567020
  11. 2000-01-06 -0.673690  0.113648
  12. 2000-01-07  0.404705  0.577046
  13. 2000-01-08 -0.370647 -1.157892

:::

属性访问

您可以直接访问某个Series或列上的索引DataFrame作为属性：

  1. In [14]: sa = pd.Series([1, 2, 3], index=list('abc'))
  3. In [15]: dfa = df.copy()
  1. In [16]: sa.b
  2. Out[16]: 2
  4. In [17]: dfa.A
  5. Out[17]: 
  6. 2000-01-01    0.469112
  7. 2000-01-02    1.212112
  8. 2000-01-03   -0.861849
  9. 2000-01-04    0.721555
  10. 2000-01-05   -0.424972
  11. 2000-01-06   -0.673690
  12. 2000-01-07    0.404705
  13. 2000-01-08   -0.370647
  14. Freq: D, Name: A, dtype: float64
  1. In [18]: sa.a = 5
  3. In [19]: sa
  4. Out[19]: 
  5. a    5
  6. b    2
  7. c    3
  8. dtype: int64
  10. In [20]: dfa.A = list(range(len(dfa.index)))  # ok if A already exists
  12. In [21]: dfa
  13. Out[21]: 
  14.             A         B         C         D
  15. 2000-01-01  0 -0.282863 -1.509059 -1.135632
  16. 2000-01-02  1 -0.173215  0.119209 -1.044236
  17. 2000-01-03  2 -2.104569 -0.494929  1.071804
  18. 2000-01-04  3 -0.706771 -1.039575  0.271860
  19. 2000-01-05  4  0.567020  0.276232 -1.087401
  20. 2000-01-06  5  0.113648 -1.478427  0.524988
  21. 2000-01-07  6  0.577046 -1.715002 -1.039268
  22. 2000-01-08  7 -1.157892 -1.344312  0.844885
  24. In [22]: dfa['A'] = list(range(len(dfa.index)))  # use this form to create a new column
  26. In [23]: dfa
  27. Out[23]: 
  28.             A         B         C         D
  29. 2000-01-01  0 -0.282863 -1.509059 -1.135632
  30. 2000-01-02  1 -0.173215  0.119209 -1.044236
  31. 2000-01-03  2 -2.104569 -0.494929  1.071804
  32. 2000-01-04  3 -0.706771 -1.039575  0.271860
  33. 2000-01-05  4  0.567020  0.276232 -1.087401
  34. 2000-01-06  5  0.113648 -1.478427  0.524988
  35. 2000-01-07  6  0.577046 -1.715002 -1.039268
  36. 2000-01-08  7 -1.157892 -1.344312  0.844885

::: danger 警告

  • 仅当index元素是有效的Python标识符时才可以使用此访问权限，例如s.1，不允许。有关有效标识符的说明，请参见此处。
  • 如果该属性与现有方法名称冲突，则该属性将不可用，例如s.min，不允许。
  • 同样的，如果它与任何下面的列表冲突的属性将不可用：index， major_axis，minor_axis，items。
  • 在任何一种情况下，标准索引仍然可以工作，例如s['1']，s['min']和s['index']将访问相应的元素或列。

:::

如果您使用的是IPython环境，则还可以使用tab-completion来查看这些可访问的属性。

您还可以将a分配dict给一行DataFrame：

  1. In [24]: x = pd.DataFrame({'x': [1, 2, 3], 'y': [3, 4, 5]})
  3. In [25]: x.iloc[1] = {'x': 9, 'y': 99}
  5. In [26]: x
  6. Out[26]: 
  7.    x   y
  8. 0  1   3
  9. 1  9  99
  10. 2  3   5

您可以使用属性访问来修改DataFrame的Series或列的现有元素，但要小心; 如果您尝试使用属性访问权来创建新列，则会创建新属性而不是新列。在0.21.0及更高版本中，这将引发UserWarning：

  1. In [1]: df = pd.DataFrame({'one': [1., 2., 3.]})
  2. In [2]: df.two = [4, 5, 6]
  3. UserWarning: Pandas doesn't allow Series to be assigned into nonexistent columns - see https://pandas.pydata.org/pandas-docs/stable/indexing.html#attribute_access
  4. In [3]: df
  5. Out[3]:
  6.    one
  7. 0  1.0
  8. 1  2.0
  9. 2  3.0

切片范围

沿着任意轴切割范围的最稳健和一致的方法在详细说明该方法的“ 按位置选择”部分中描述.iloc。现在，我们解释使用[]运算符切片的语义。

使用Series，语法与ndarray完全一样，返回值的一部分和相应的标签：

  1. In [27]: s[:5]
  2. Out[27]: 
  3. 2000-01-01    0.469112
  4. 2000-01-02    1.212112
  5. 2000-01-03   -0.861849
  6. 2000-01-04    0.721555
  7. 2000-01-05   -0.424972
  8. Freq: D, Name: A, dtype: float64
  10. In [28]: s[::2]
  11. Out[28]: 
  12. 2000-01-01    0.469112
  13. 2000-01-03   -0.861849
  14. 2000-01-05   -0.424972
  15. 2000-01-07    0.404705
  16. Freq: 2D, Name: A, dtype: float64
  18. In [29]: s[::-1]
  19. Out[29]: 
  20. 2000-01-08   -0.370647
  21. 2000-01-07    0.404705
  22. 2000-01-06   -0.673690
  23. 2000-01-05   -0.424972
  24. 2000-01-04    0.721555
  25. 2000-01-03   -0.861849
  26. 2000-01-02    1.212112
  27. 2000-01-01    0.469112
  28. Freq: -1D, Name: A, dtype: float64

请注意，设置也适用：

  1. In [30]: s2 = s.copy()
  3. In [31]: s2[:5] = 0
  5. In [32]: s2
  6. Out[32]: 
  7. 2000-01-01    0.000000
  8. 2000-01-02    0.000000
  9. 2000-01-03    0.000000
  10. 2000-01-04    0.000000
  11. 2000-01-05    0.000000
  12. 2000-01-06   -0.673690
  13. 2000-01-07    0.404705
  14. 2000-01-08   -0.370647
  15. Freq: D, Name: A, dtype: float64

使用DataFrame，切片内部[] 切片。这主要是为了方便而提供的，因为它是如此常见的操作。

  1. In [33]: df[:3]
  2. Out[33]: 
  3.                    A         B         C         D
  4. 2000-01-01  0.469112 -0.282863 -1.509059 -1.135632
  5. 2000-01-02  1.212112 -0.173215  0.119209 -1.044236
  6. 2000-01-03 -0.861849 -2.104569 -0.494929  1.071804
  8. In [34]: df[::-1]
  9. Out[34]: 
  10.                    A         B         C         D
  11. 2000-01-08 -0.370647 -1.157892 -1.344312  0.844885
  12. 2000-01-07  0.404705  0.577046 -1.715002 -1.039268
  13. 2000-01-06 -0.673690  0.113648 -1.478427  0.524988
  14. 2000-01-05 -0.424972  0.567020  0.276232 -1.087401
  15. 2000-01-04  0.721555 -0.706771 -1.039575  0.271860
  16. 2000-01-03 -0.861849 -2.104569 -0.494929  1.071804
  17. 2000-01-02  1.212112 -0.173215  0.119209 -1.044236
  18. 2000-01-01  0.469112 -0.282863 -1.509059 -1.135632

按标签选择

::: danger 警告

是否为设置操作返回副本或引用可能取决于上下文。这有时被称为应该避免。请参阅返回视图与复制。chained assignment

:::

::: danger 警告

  1. In [35]: dfl = pd.DataFrame(np.random.randn(5, 4),
  2.    ....:                    columns=list('ABCD'),
  3.    ....:                    index=pd.date_range('20130101', periods=5))
  4.    ....: 
  6. In [36]: dfl
  7. Out[36]: 
  8.                    A         B         C         D
  9. 2013-01-01  1.075770 -0.109050  1.643563 -1.469388
  10. 2013-01-02  0.357021 -0.674600 -1.776904 -0.968914
  11. 2013-01-03 -1.294524  0.413738  0.276662 -0.472035
  12. 2013-01-04 -0.013960 -0.362543 -0.006154 -0.923061
  13. 2013-01-05  0.895717  0.805244 -1.206412  2.565646
  1. In [4]: dfl.loc[2:3]
  2. TypeError: cannot do slice indexing on <class 'pandas.tseries.index.DatetimeIndex'> with these indexers [2] of <type 'int'>

切片中的字符串喜欢可以转换为索引的类型并导致自然切片。

  1. In [37]: dfl.loc['20130102':'20130104']
  2. Out[37]: 
  3.                    A         B         C         D
  4. 2013-01-02  0.357021 -0.674600 -1.776904 -0.968914
  5. 2013-01-03 -1.294524  0.413738  0.276662 -0.472035
  6. 2013-01-04 -0.013960 -0.362543 -0.006154 -0.923061

:::

::: danger 警告

从0.21.0开始，pandas将显示FutureWarning带有缺少标签的列表的if索引。将来这会提高一个KeyError。请参阅list-like使用列表中缺少键的loc是不推荐使用。

:::

pandas提供了一套方法，以便拥有纯粹基于标签的索引。这是一个严格的包含协议。要求的每个标签必须在索引中，否则KeyError将被提出。切片时，如果索引中存在，则包括起始绑定和停止边界。整数是有效标签，但它们是指标签而不是位置。**

该.loc属性是主要访问方法。以下是有效输入：

  • 单个标签，例如5或'a'（注意，它5被解释为索引的标签。此用法不是索引的整数位置。）。
  • 列表或标签数组。['a', 'b', 'c']
  • 带有标签的切片对象'a':'f'（注意，与通常的python切片相反，包括起始和停止，当存在于索引中时！请参见切片标签。
  • 布尔数组。
  • A callable，参见按可调用选择。
  1. In [38]: s1 = pd.Series(np.random.randn(6), index=list('abcdef'))
  3. In [39]: s1
  4. Out[39]: 
  5. a    1.431256
  6. b    1.340309
  7. c   -1.170299
  8. d   -0.226169
  9. e    0.410835
  10. f    0.813850
  11. dtype: float64
  13. In [40]: s1.loc['c':]
  14. Out[40]: 
  15. c   -1.170299
  16. d   -0.226169
  17. e    0.410835
  18. f    0.813850
  19. dtype: float64
  21. In [41]: s1.loc['b']
  22. Out[41]: 1.3403088497993827

请注意，设置也适用：

  1. In [42]: s1.loc['c':] = 0
  3. In [43]: s1
  4. Out[43]: 
  5. a    1.431256
  6. b    1.340309
  7. c    0.000000
  8. d    0.000000
  9. e    0.000000
  10. f    0.000000
  11. dtype: float64

使用DataFrame：

  1. In [44]: df1 = pd.DataFrame(np.random.randn(6, 4),
  2.    ....:                    index=list('abcdef'),
  3.    ....:                    columns=list('ABCD'))
  4.    ....: 
  6. In [45]: df1
  7. Out[45]: 
  8.           A         B         C         D
  9. a  0.132003 -0.827317 -0.076467 -1.187678
  10. b  1.130127 -1.436737 -1.413681  1.607920
  11. c  1.024180  0.569605  0.875906 -2.211372
  12. d  0.974466 -2.006747 -0.410001 -0.078638
  13. e  0.545952 -1.219217 -1.226825  0.769804
  14. f -1.281247 -0.727707 -0.121306 -0.097883
  16. In [46]: df1.loc[['a', 'b', 'd'], :]
  17. Out[46]: 
  18.           A         B         C         D
  19. a  0.132003 -0.827317 -0.076467 -1.187678
  20. b  1.130127 -1.436737 -1.413681  1.607920
  21. d  0.974466 -2.006747 -0.410001 -0.078638

通过标签切片访问：

  1. In [47]: df1.loc['d':, 'A':'C']
  2. Out[47]: 
  3.           A         B         C
  4. d  0.974466 -2.006747 -0.410001
  5. e  0.545952 -1.219217 -1.226825
  6. f -1.281247 -0.727707 -0.121306

使用标签获取横截面（相当于df.xs('a')）：

  1. In [48]: df1.loc['a']
  2. Out[48]: 
  3. A    0.132003
  4. B   -0.827317
  5. C   -0.076467
  6. D   -1.187678
  7. Name: a, dtype: float64

要使用布尔数组获取值：

  1. In [49]: df1.loc['a'] > 0
  2. Out[49]: 
  3. A     True
  4. B    False
  5. C    False
  6. D    False
  7. Name: a, dtype: bool
  9. In [50]: df1.loc[:, df1.loc['a'] > 0]
  10. Out[50]: 
  11.           A
  12. a  0.132003
  13. b  1.130127
  14. c  1.024180
  15. d  0.974466
  16. e  0.545952
  17. f -1.281247

要明确获取值（相当于已弃用df.get_value('a','A')）：

  1. # this is also equivalent to ``df1.at['a','A']``
  2. In [51]: df1.loc['a', 'A']
  3. Out[51]: 0.13200317033032932

用标签切片

使用.loc切片时，如果索引中存在开始和停止标签，则返回位于两者之间的元素（包括它们）：

  1. In [52]: s = pd.Series(list('abcde'), index=[0, 3, 2, 5, 4])
  3. In [53]: s.loc[3:5]
  4. Out[53]: 
  5. 3    b
  6. 2    c
  7. 5    d
  8. dtype: object

如果两个中至少有一个不存在，但索引已排序，并且可以与开始和停止标签进行比较，那么通过选择在两者之间排名的标签，切片仍将按预期工作：

  1. In [54]: s.sort_index()
  2. Out[54]: 
  3. 0    a
  4. 2    c
  5. 3    b
  6. 4    e
  7. 5    d
  8. dtype: object
  10. In [55]: s.sort_index().loc[1:6]
  11. Out[55]: 
  12. 2    c
  13. 3    b
  14. 4    e
  15. 5    d
  16. dtype: object

然而，如果两个中的至少一个不存在并且索引未被排序，则将引发错误（因为否则将是计算上昂贵的，并且对于混合类型索引可能是模糊的）。例如，在上面的例子中，s.loc[1:6]会提高KeyError。

有关此行为背后的基本原理，请参阅 端点包含。

按位置选择

::: danger 警告

是否为设置操作返回副本或引用可能取决于上下文。这有时被称为应该避免。请参阅返回视图与复制。chained assignment

:::

Pandas提供了一套方法，以获得纯粹基于整数的索引。语义紧跟Python和NumPy切片。这些是0-based索引。切片时，所结合的开始被包括，而上限是排除。尝试使用非整数，甚至是有效的标签都会引发一个问题IndexError。

该.iloc属性是主要访问方法。以下是有效输入：

  • 一个整数，例如5。
  • 整数列表或数组。[4, 3, 0]
  • 带有整数的切片对象1:7。
  • 布尔数组。
  • A callable，参见按可调用选择。
  1. In [56]: s1 = pd.Series(np.random.randn(5), index=list(range(0, 10, 2)))
  3. In [57]: s1
  4. Out[57]: 
  5. 0    0.695775
  6. 2    0.341734
  7. 4    0.959726
  8. 6   -1.110336
  9. 8   -0.619976
  10. dtype: float64
  12. In [58]: s1.iloc[:3]
  13. Out[58]: 
  14. 0    0.695775
  15. 2    0.341734
  16. 4    0.959726
  17. dtype: float64
  19. In [59]: s1.iloc[3]
  20. Out[59]: -1.110336102891167

请注意，设置也适用：

  1. In [60]: s1.iloc[:3] = 0
  3. In [61]: s1
  4. Out[61]: 
  5. 0    0.000000
  6. 2    0.000000
  7. 4    0.000000
  8. 6   -1.110336
  9. 8   -0.619976
  10. dtype: float64

使用DataFrame：

  1. In [62]: df1 = pd.DataFrame(np.random.randn(6, 4),
  2.    ....:                    index=list(range(0, 12, 2)),
  3.    ....:                    columns=list(range(0, 8, 2)))
  4.    ....: 
  6. In [63]: df1
  7. Out[63]: 
  8.            0         2         4         6
  9. 0   0.149748 -0.732339  0.687738  0.176444
  10. 2   0.403310 -0.154951  0.301624 -2.179861
  11. 4  -1.369849 -0.954208  1.462696 -1.743161
  12. 6  -0.826591 -0.345352  1.314232  0.690579
  13. 8   0.995761  2.396780  0.014871  3.357427
  14. 10 -0.317441 -1.236269  0.896171 -0.487602

通过整数切片选择：

  1. In [64]: df1.iloc[:3]
  2. Out[64]: 
  3.           0         2         4         6
  4. 0  0.149748 -0.732339  0.687738  0.176444
  5. 2  0.403310 -0.154951  0.301624 -2.179861
  6. 4 -1.369849 -0.954208  1.462696 -1.743161
  8. In [65]: df1.iloc[1:5, 2:4]
  9. Out[65]: 
  10.           4         6
  11. 2  0.301624 -2.179861
  12. 4  1.462696 -1.743161
  13. 6  1.314232  0.690579
  14. 8  0.014871  3.357427

通过整数列表选择：

  1. In [66]: df1.iloc[[1, 3, 5], [1, 3]]
  2. Out[66]: 
  3.            2         6
  4. 2  -0.154951 -2.179861
  5. 6  -0.345352  0.690579
  6. 10 -1.236269 -0.487602
  1. In [67]: df1.iloc[1:3, :]
  2. Out[67]: 
  3.           0         2         4         6
  4. 2  0.403310 -0.154951  0.301624 -2.179861
  5. 4 -1.369849 -0.954208  1.462696 -1.743161
  1. In [68]: df1.iloc[:, 1:3]
  2. Out[68]: 
  3.            2         4
  4. 0  -0.732339  0.687738
  5. 2  -0.154951  0.301624
  6. 4  -0.954208  1.462696
  7. 6  -0.345352  1.314232
  8. 8   2.396780  0.014871
  9. 10 -1.236269  0.896171
  1. # this is also equivalent to ``df1.iat[1,1]``
  2. In [69]: df1.iloc[1, 1]
  3. Out[69]: -0.1549507744249032

使用整数位置（等效df.xs(1)）得到横截面：

  1. In [70]: df1.iloc[1]
  2. Out[70]: 
  3. 0    0.403310
  4. 2   -0.154951
  5. 4    0.301624
  6. 6   -2.179861
  7. Name: 2, dtype: float64

超出范围的切片索引正如Python / Numpy中一样优雅地处理。

  1. # these are allowed in python/numpy.
  2. In [71]: x = list('abcdef')
  4. In [72]: x
  5. Out[72]: ['a', 'b', 'c', 'd', 'e', 'f']
  7. In [73]: x[4:10]
  8. Out[73]: ['e', 'f']
  10. In [74]: x[8:10]
  11. Out[74]: []
  13. In [75]: s = pd.Series(x)
  15. In [76]: s
  16. Out[76]: 
  17. 0    a
  18. 1    b
  19. 2    c
  20. 3    d
  21. 4    e
  22. 5    f
  23. dtype: object
  25. In [77]: s.iloc[4:10]
  26. Out[77]: 
  27. 4    e
  28. 5    f
  29. dtype: object
  31. In [78]: s.iloc[8:10]
  32. Out[78]: Series([], dtype: object)

请注意，使用超出边界的切片可能会导致空轴（例如，返回一个空的DataFrame）。

  1. In [79]: dfl = pd.DataFrame(np.random.randn(5, 2), columns=list('AB'))
  3. In [80]: dfl
  4. Out[80]: 
  5.           A         B
  6. 0 -0.082240 -2.182937
  7. 1  0.380396  0.084844
  8. 2  0.432390  1.519970
  9. 3 -0.493662  0.600178
  10. 4  0.274230  0.132885
  12. In [81]: dfl.iloc[:, 2:3]
  13. Out[81]: 
  14. Empty DataFrame
  15. Columns: []
  16. Index: [0, 1, 2, 3, 4]
  18. In [82]: dfl.iloc[:, 1:3]
  19. Out[82]: 
  20.           B
  21. 0 -2.182937
  22. 1  0.084844
  23. 2  1.519970
  24. 3  0.600178
  25. 4  0.132885
  27. In [83]: dfl.iloc[4:6]
  28. Out[83]: 
  29.          A         B
  30. 4  0.27423  0.132885

一个超出范围的索引器会引发一个IndexError。任何元素超出范围的索引器列表都会引发 IndexError。

  1. >>> dfl.iloc[[4, 5, 6]]
  2. IndexError: positional indexers are out-of-bounds
  4. >>> dfl.iloc[:, 4]
  5. IndexError: single positional indexer is out-of-bounds

通过可调用选择

版本0.18.1中的新功能。

.loc，.iloc以及[]索引也可以接受一个callable索引器。在callable必须与一个参数（调用系列或数据帧）返回的有效输出索引功能。

  1. In [84]: df1 = pd.DataFrame(np.random.randn(6, 4),
  2.    ....:                    index=list('abcdef'),
  3.    ....:                    columns=list('ABCD'))
  4.    ....: 
  6. In [85]: df1
  7. Out[85]: 
  8.           A         B         C         D
  9. a -0.023688  2.410179  1.450520  0.206053
  10. b -0.251905 -2.213588  1.063327  1.266143
  11. c  0.299368 -0.863838  0.408204 -1.048089
  12. d -0.025747 -0.988387  0.094055  1.262731
  13. e  1.289997  0.082423 -0.055758  0.536580
  14. f -0.489682  0.369374 -0.034571 -2.484478
  16. In [86]: df1.loc[lambda df: df.A > 0, :]
  17. Out[86]: 
  18.           A         B         C         D
  19. c  0.299368 -0.863838  0.408204 -1.048089
  20. e  1.289997  0.082423 -0.055758  0.536580
  22. In [87]: df1.loc[:, lambda df: ['A', 'B']]
  23. Out[87]: 
  24.           A         B
  25. a -0.023688  2.410179
  26. b -0.251905 -2.213588
  27. c  0.299368 -0.863838
  28. d -0.025747 -0.988387
  29. e  1.289997  0.082423
  30. f -0.489682  0.369374
  32. In [88]: df1.iloc[:, lambda df: [0, 1]]
  33. Out[88]: 
  34.           A         B
  35. a -0.023688  2.410179
  36. b -0.251905 -2.213588
  37. c  0.299368 -0.863838
  38. d -0.025747 -0.988387
  39. e  1.289997  0.082423
  40. f -0.489682  0.369374
  42. In [89]: df1[lambda df: df.columns[0]]
  43. Out[89]: 
  44. a   -0.023688
  45. b   -0.251905
  46. c    0.299368
  47. d   -0.025747
  48. e    1.289997
  49. f   -0.489682
  50. Name: A, dtype: float64

您可以使用可调用索引Series。

  1. In [90]: df1.A.loc[lambda s: s > 0]
  2. Out[90]: 
  3. c    0.299368
  4. e    1.289997
  5. Name: A, dtype: float64

使用这些方法/索引器，您可以在不使用临时变量的情况下链接数据选择操作。

  1. In [91]: bb = pd.read_csv('data/baseball.csv', index_col='id')
  3. In [92]: (bb.groupby(['year', 'team']).sum()
  4.    ....:    .loc[lambda df: df.r > 100])
  5.    ....: 
  6. Out[92]: 
  7.            stint    g    ab    r    h  X2b  X3b  hr    rbi    sb   cs   bb     so   ibb   hbp    sh    sf  gidp
  8. year team                                                                                                      
  9. 2007 CIN       6  379   745  101  203   35    2  36  125.0  10.0  1.0  105  127.0  14.0   1.0   1.0  15.0  18.0
  10.      DET       5  301  1062  162  283   54    4  37  144.0  24.0  7.0   97  176.0   3.0  10.0   4.0   8.0  28.0
  11.      HOU       4  311   926  109  218   47    6  14   77.0  10.0  4.0   60  212.0   3.0   9.0  16.0   6.0  17.0
  12.      LAN      11  413  1021  153  293   61    3  36  154.0   7.0  5.0  114  141.0   8.0   9.0   3.0   8.0  29.0
  13.      NYN      13  622  1854  240  509  101    3  61  243.0  22.0  4.0  174  310.0  24.0  23.0  18.0  15.0  48.0
  14.      SFN       5  482  1305  198  337   67    6  40  171.0  26.0  7.0  235  188.0  51.0   8.0  16.0   6.0  41.0
  15.      TEX       2  198   729  115  200   40    4  28  115.0  21.0  4.0   73  140.0   4.0   5.0   2.0   8.0  16.0
  16.      TOR       4  459  1408  187  378   96    2  58  223.0   4.0  2.0  190  265.0  16.0  12.0   4.0  16.0  38.0

不推荐使用IX索引器

::: danger 警告

在0.20.0开始，.ix索引器已被弃用，赞成更加严格.iloc 和.loc索引。

:::

.ix在推断用户想要做的事情上提供了很多魔力。也就是说，.ix可以根据索引的数据类型决定按位置或通过标签进行索引。多年来，这引起了相当多的用户混淆。

建议的索引方法是：

  • .loc如果你想标记索引。
  • .iloc如果你想要定位索引。
  1. In [93]: dfd = pd.DataFrame({'A': [1, 2, 3],
  2.    ....:                     'B': [4, 5, 6]},
  3.    ....:                    index=list('abc'))
  4.    ....: 
  6. In [94]: dfd
  7. Out[94]: 
  8.    A  B
  9. a  1  4
  10. b  2  5
  11. c  3  6

以前的行为，您希望从“A”列中获取索引中的第0个和第2个元素。

  1. In [3]: dfd.ix[[0, 2], 'A']
  2. Out[3]:
  3. a    1
  4. c    3
  5. Name: A, dtype: int64

用.loc。这里我们将从索引中选择适当的索引，然后使用标签索引。

  1. In [95]: dfd.loc[dfd.index[[0, 2]], 'A']
  2. Out[95]: 
  3. a    1
  4. c    3
  5. Name: A, dtype: int64

这也可以.iloc通过在索引器上显式获取位置，并使用 位置索引来选择事物来表达。

  1. In [96]: dfd.iloc[[0, 2], dfd.columns.get_loc('A')]
  2. Out[96]: 
  3. a    1
  4. c    3
  5. Name: A, dtype: int64

要获得多个索引器，请使用.get_indexer：

  1. In [97]: dfd.iloc[[0, 2], dfd.columns.get_indexer(['A', 'B'])]
  2. Out[97]: 
  3.    A  B
  4. a  1  4
  5. c  3  6

不推荐使用缺少标签的列表进行索引

::: danger 警告

从0.21.0开始，使用.loc或[]包含一个或多个缺少标签的列表，不赞成使用.reindex。

:::

在以前的版本中，.loc[list-of-labels]只要找到至少1个密钥，使用就可以工作（否则会引起a KeyError）。不推荐使用此行为，并将显示指向此部分的警告消息。推荐的替代方案是使用.reindex()。

例如。

  1. In [98]: s = pd.Series([1, 2, 3])
  3. In [99]: s
  4. Out[99]: 
  5. 0    1
  6. 1    2
  7. 2    3
  8. dtype: int64

找到所有键的选择保持不变。

  1. In [100]: s.loc[[1, 2]]
  2. Out[100]: 
  3. 1    2
  4. 2    3
  5. dtype: int64

以前的行为

  1. In [4]: s.loc[[1, 2, 3]]
  2. Out[4]:
  3. 1    2.0
  4. 2    3.0
  5. 3    NaN
  6. dtype: float64

目前的行为

  1. In [4]: s.loc[[1, 2, 3]]
  2. Passing list-likes to .loc with any non-matching elements will raise
  3. KeyError in the future, you can use .reindex() as an alternative.
  5. See the documentation here:
  6. http://pandas.pydata.org/pandas-docs/stable/indexing.html#deprecate-loc-reindex-listlike
  8. Out[4]:
  9. 1    2.0
  10. 2    3.0
  11. 3    NaN
  12. dtype: float64

重新索引

实现选择潜在的未找到元素的惯用方法是通过.reindex()。另请参阅重建索引部分。

  1. In [101]: s.reindex([1, 2, 3])
  2. Out[101]: 
  3. 1    2.0
  4. 2    3.0
  5. 3    NaN
  6. dtype: float64

或者，如果您只想选择有效的密钥，则以下是惯用且有效的; 保证保留选择的dtype。

  1. In [102]: labels = [1, 2, 3]
  3. In [103]: s.loc[s.index.intersection(labels)]
  4. Out[103]: 
  5. 1    2
  6. 2    3
  7. dtype: int64

拥有重复索引会引发.reindex()：

  1. In [104]: s = pd.Series(np.arange(4), index=['a', 'a', 'b', 'c'])
  3. In [105]: labels = ['c', 'd']
  1. In [17]: s.reindex(labels)
  2. ValueError: cannot reindex from a duplicate axis

通常，您可以将所需标签与当前轴相交，然后重新索引。

  1. In [106]: s.loc[s.index.intersection(labels)].reindex(labels)
  2. Out[106]: 
  3. c    3.0
  4. d    NaN
  5. dtype: float64

但是，如果生成的索引重复，这仍然会提高。

  1. In [41]: labels = ['a', 'd']
  3. In [42]: s.loc[s.index.intersection(labels)].reindex(labels)
  4. ValueError: cannot reindex from a duplicate axis

选择随机样本

使用该sample()方法随机选择Series或DataFrame中的行或列。默认情况下，该方法将对行进行采样，并接受要返回的特定行数/列数或一小部分行。

  1. In [107]: s = pd.Series([0, 1, 2, 3, 4, 5])
  3. # When no arguments are passed, returns 1 row.
  4. In [108]: s.sample()
  5. Out[108]: 
  6. 4    4
  7. dtype: int64
  9. # One may specify either a number of rows:
  10. In [109]: s.sample(n=3)
  11. Out[109]: 
  12. 0    0
  13. 4    4
  14. 1    1
  15. dtype: int64
  17. # Or a fraction of the rows:
  18. In [110]: s.sample(frac=0.5)
  19. Out[110]: 
  20. 5    5
  21. 3    3
  22. 1    1
  23. dtype: int64

默认情况下，sample最多会返回每行一次，但也可以使用以下replace选项进行替换：

  1. In [111]: s = pd.Series([0, 1, 2, 3, 4, 5])
  3. # Without replacement (default):
  4. In [112]: s.sample(n=6, replace=False)
  5. Out[112]: 
  6. 0    0
  7. 1    1
  8. 5    5
  9. 3    3
  10. 2    2
  11. 4    4
  12. dtype: int64
  14. # With replacement:
  15. In [113]: s.sample(n=6, replace=True)
  16. Out[113]: 
  17. 0    0
  18. 4    4
  19. 3    3
  20. 2    2
  21. 4    4
  22. 4    4
  23. dtype: int64

默认情况下，每行具有相同的选择概率，但如果您希望行具有不同的概率，则可以将sample函数采样权重作为 weights。这些权重可以是列表，NumPy数组或系列，但它们的长度必须与您采样的对象的长度相同。缺失的值将被视为零的权重，并且不允许使用inf值。如果权重不总和为1，则通过将所有权重除以权重之和来对它们进行重新规范化。例如：

  1. In [114]: s = pd.Series([0, 1, 2, 3, 4, 5])
  3. In [115]: example_weights = [0, 0, 0.2, 0.2, 0.2, 0.4]
  5. In [116]: s.sample(n=3, weights=example_weights)
  6. Out[116]: 
  7. 5    5
  8. 4    4
  9. 3    3
  10. dtype: int64
  12. # Weights will be re-normalized automatically
  13. In [117]: example_weights2 = [0.5, 0, 0, 0, 0, 0]
  15. In [118]: s.sample(n=1, weights=example_weights2)
  16. Out[118]: 
  17. 0    0
  18. dtype: int64

应用于DataFrame时，只需将列的名称作为字符串传递，就可以使用DataFrame的列作为采样权重（假设您要对行而不是列进行采样）。

  1. In [119]: df2 = pd.DataFrame({'col1': [9, 8, 7, 6],
  2.    .....:                     'weight_column': [0.5, 0.4, 0.1, 0]})
  3.    .....: 
  5. In [120]: df2.sample(n=3, weights='weight_column')
  6. Out[120]: 
  7.    col1  weight_column
  8. 1     8            0.4
  9. 0     9            0.5
  10. 2     7            0.1

sample还允许用户使用axis参数对列而不是行进行采样。

  1. In [121]: df3 = pd.DataFrame({'col1': [1, 2, 3], 'col2': [2, 3, 4]})
  3. In [122]: df3.sample(n=1, axis=1)
  4. Out[122]: 
  5.    col1
  6. 0     1
  7. 1     2
  8. 2     3

最后，还可以sample使用random_state参数为随机数生成器设置种子，该参数将接受整数（作为种子）或NumPy RandomState对象。

  1. In [123]: df4 = pd.DataFrame({'col1': [1, 2, 3], 'col2': [2, 3, 4]})
  3. # With a given seed, the sample will always draw the same rows.
  4. In [124]: df4.sample(n=2, random_state=2)
  5. Out[124]: 
  6.    col1  col2
  7. 2     3     4
  8. 1     2     3
  10. In [125]: df4.sample(n=2, random_state=2)
  11. Out[125]: 
  12.    col1  col2
  13. 2     3     4
  14. 1     2     3

用放大设定

.loc/[]当为该轴设置不存在的键时，操作可以执行放大。

在这种Series情况下，这实际上是一种附加操作。

  1. In [126]: se = pd.Series([1, 2, 3])
  3. In [127]: se
  4. Out[127]: 
  5. 0    1
  6. 1    2
  7. 2    3
  8. dtype: int64
  10. In [128]: se[5] = 5.
  12. In [129]: se
  13. Out[129]: 
  14. 0    1.0
  15. 1    2.0
  16. 2    3.0
  17. 5    5.0
  18. dtype: float64

A DataFrame可以在任一轴上放大.loc。

  1. In [130]: dfi = pd.DataFrame(np.arange(6).reshape(3, 2),
  2.    .....:                    columns=['A', 'B'])
  3.    .....: 
  5. In [131]: dfi
  6. Out[131]: 
  7.    A  B
  8. 0  0  1
  9. 1  2  3
  10. 2  4  5
  12. In [132]: dfi.loc[:, 'C'] = dfi.loc[:, 'A']
  14. In [133]: dfi
  15. Out[133]: 
  16.    A  B  C
  17. 0  0  1  0
  18. 1  2  3  2
  19. 2  4  5  4

这就像是一个append操作DataFrame。

  1. In [134]: dfi.loc[3] = 5
  3. In [135]: dfi
  4. Out[135]: 
  5.    A  B  C
  6. 0  0  1  0
  7. 1  2  3  2
  8. 2  4  5  4
  9. 3  5  5  5

快速标量值获取和设置

因为索引[]必须处理很多情况（单标签访问，切片，布尔索引等），所以它有一些开销以便弄清楚你要求的是什么。如果您只想访问标量值，最快的方法是使用在所有数据结构上实现的at和iat方法。

与之类似loc，at提供基于标签的标量查找，同时iat提供类似于基于整数的查找iloc

  1. In [136]: s.iat[5]
  2. Out[136]: 5
  4. In [137]: df.at[dates[5], 'A']
  5. Out[137]: -0.6736897080883706
  7. In [138]: df.iat[3, 0]
  8. Out[138]: 0.7215551622443669

您也可以使用这些相同的索引器进行设置。

  1. In [139]: df.at[dates[5], 'E'] = 7
  3. In [140]: df.iat[3, 0] = 7

at 如果索引器丢失，可以如上所述放大对象。

  1. In [141]: df.at[dates[-1] + pd.Timedelta('1 day'), 0] = 7
  3. In [142]: df
  4. Out[142]: 
  5.                    A         B         C         D    E    0
  6. 2000-01-01  0.469112 -0.282863 -1.509059 -1.135632  NaN  NaN
  7. 2000-01-02  1.212112 -0.173215  0.119209 -1.044236  NaN  NaN
  8. 2000-01-03 -0.861849 -2.104569 -0.494929  1.071804  NaN  NaN
  9. 2000-01-04  7.000000 -0.706771 -1.039575  0.271860  NaN  NaN
  10. 2000-01-05 -0.424972  0.567020  0.276232 -1.087401  NaN  NaN
  11. 2000-01-06 -0.673690  0.113648 -1.478427  0.524988  7.0  NaN
  12. 2000-01-07  0.404705  0.577046 -1.715002 -1.039268  NaN  NaN
  13. 2000-01-08 -0.370647 -1.157892 -1.344312  0.844885  NaN  NaN
  14. 2000-01-09       NaN       NaN       NaN       NaN  NaN  7.0

布尔索引

另一种常见操作是使用布尔向量来过滤数据。运营商是：|for or，&for and和~for not。必须使用括号对这些进行分组，因为默认情况下，Python将评估表达式，例如as ，而期望的评估顺序是 。df.A > 2 & df.B < 3````df.A > (2 & df.B) < 3````(df.A > 2) & (df.B < 3)

使用布尔向量索引系列的工作方式与NumPy ndarray完全相同：

  1. In [143]: s = pd.Series(range(-3, 4))
  3. In [144]: s
  4. Out[144]: 
  5. 0   -3
  6. 1   -2
  7. 2   -1
  8. 3    0
  9. 4    1
  10. 5    2
  11. 6    3
  12. dtype: int64
  14. In [145]: s[s > 0]
  15. Out[145]: 
  16. 4    1
  17. 5    2
  18. 6    3
  19. dtype: int64
  21. In [146]: s[(s < -1) | (s > 0.5)]
  22. Out[146]: 
  23. 0   -3
  24. 1   -2
  25. 4    1
  26. 5    2
  27. 6    3
  28. dtype: int64
  30. In [147]: s[~(s < 0)]
  31. Out[147]: 
  32. 3    0
  33. 4    1
  34. 5    2
  35. 6    3
  36. dtype: int64

您可以使用与DataFrame索引长度相同的布尔向量从DataFrame中选择行（例如，从DataFrame的其中一列派生的东西）：

  1. In [148]: df[df['A'] > 0]
  2. Out[148]: 
  3.                    A         B         C         D   E   0
  4. 2000-01-01  0.469112 -0.282863 -1.509059 -1.135632 NaN NaN
  5. 2000-01-02  1.212112 -0.173215  0.119209 -1.044236 NaN NaN
  6. 2000-01-04  7.000000 -0.706771 -1.039575  0.271860 NaN NaN
  7. 2000-01-07  0.404705  0.577046 -1.715002 -1.039268 NaN NaN

列表推导和map系列方法也可用于产生更复杂的标准：

  1. In [149]: df2 = pd.DataFrame({'a': ['one', 'one', 'two', 'three', 'two', 'one', 'six'],
  2.    .....:                     'b': ['x', 'y', 'y', 'x', 'y', 'x', 'x'],
  3.    .....:                     'c': np.random.randn(7)})
  4.    .....: 
  6. # only want 'two' or 'three'
  7. In [150]: criterion = df2['a'].map(lambda x: x.startswith('t'))
  9. In [151]: df2[criterion]
  10. Out[151]: 
  11.        a  b         c
  12. 2    two  y  0.041290
  13. 3  three  x  0.361719
  14. 4    two  y -0.238075
  16. # equivalent but slower
  17. In [152]: df2[[x.startswith('t') for x in df2['a']]]
  18. Out[152]: 
  19.        a  b         c
  20. 2    two  y  0.041290
  21. 3  three  x  0.361719
  22. 4    two  y -0.238075
  24. # Multiple criteria
  25. In [153]: df2[criterion & (df2['b'] == 'x')]
  26. Out[153]: 
  27.        a  b         c
  28. 3  three  x  0.361719

随着选择方法通过标签选择，通过位置选择和高级索引，你可以沿着使用布尔向量与其他索引表达式中组合选择多个轴。

  1. In [154]: df2.loc[criterion & (df2['b'] == 'x'), 'b':'c']
  2. Out[154]: 
  3.    b         c
  4. 3  x  0.361719

使用isin进行索引

考虑一下isin()方法Series，该方法返回一个布尔向量，只要Series元素存在于传递列表中，该向量就为真。这允许您选择一列或多列具有所需值的行：

  1. In [155]: s = pd.Series(np.arange(5), index=np.arange(5)[::-1], dtype='int64')
  3. In [156]: s
  4. Out[156]: 
  5. 4    0
  6. 3    1
  7. 2    2
  8. 1    3
  9. 0    4
  10. dtype: int64
  12. In [157]: s.isin([2, 4, 6])
  13. Out[157]: 
  14. 4    False
  15. 3    False
  16. 2     True
  17. 1    False
  18. 0     True
  19. dtype: bool
  21. In [158]: s[s.isin([2, 4, 6])]
  22. Out[158]: 
  23. 2    2
  24. 0    4
  25. dtype: int64

Index对象可以使用相同的方法，当您不知道哪些搜索标签实际存在时，它们非常有用：

  1. In [159]: s[s.index.isin([2, 4, 6])]
  2. Out[159]: 
  3. 4    0
  4. 2    2
  5. dtype: int64
  7. # compare it to the following
  8. In [160]: s.reindex([2, 4, 6])
  9. Out[160]: 
  10. 2    2.0
  11. 4    0.0
  12. 6    NaN
  13. dtype: float64

除此之外，还MultiIndex允许选择在成员资格检查中使用的单独级别：

  1. In [161]: s_mi = pd.Series(np.arange(6),
  2.    .....:                  index=pd.MultiIndex.from_product([[0, 1], ['a', 'b', 'c']]))
  3.    .....: 
  5. In [162]: s_mi
  6. Out[162]: 
  7. 0  a    0
  8.    b    1
  9.    c    2
  10. 1  a    3
  11.    b    4
  12.    c    5
  13. dtype: int64
  15. In [163]: s_mi.iloc[s_mi.index.isin([(1, 'a'), (2, 'b'), (0, 'c')])]
  16. Out[163]: 
  17. 0  c    2
  18. 1  a    3
  19. dtype: int64
  21. In [164]: s_mi.iloc[s_mi.index.isin(['a', 'c', 'e'], level=1)]
  22. Out[164]: 
  23. 0  a    0
  24.    c    2
  25. 1  a    3
  26.    c    5
  27. dtype: int64

DataFrame也有一个isin()方法。调用时isin，将一组值作为数组或字典传递。如果values是一个数组，则isin返回与原始DataFrame形状相同的布尔数据框，并在元素序列中的任何位置使用True。

  1. In [165]: df = pd.DataFrame({'vals': [1, 2, 3, 4], 'ids': ['a', 'b', 'f', 'n'],
  2.    .....:                    'ids2': ['a', 'n', 'c', 'n']})
  3.    .....: 
  5. In [166]: values = ['a', 'b', 1, 3]
  7. In [167]: df.isin(values)
  8. Out[167]: 
  9.     vals    ids   ids2
  10. 0   True   True   True
  11. 1  False   True  False
  12. 2   True  False  False
  13. 3  False  False  False

通常，您需要将某些值与某些列匹配。只需将值设置dict为键为列的位置，值即为要检查的项目列表。

  1. In [168]: values = {'ids': ['a', 'b'], 'vals': [1, 3]}
  3. In [169]: df.isin(values)
  4. Out[169]: 
  5.     vals    ids   ids2
  6. 0   True   True  False
  7. 1  False   True  False
  8. 2   True  False  False
  9. 3  False  False  False

结合数据帧的isin同any()和all()方法来快速选择符合给定的标准对数据子集。要选择每列符合其自己标准的行：

  1. In [170]: values = {'ids': ['a', 'b'], 'ids2': ['a', 'c'], 'vals': [1, 3]}
  3. In [171]: row_mask = df.isin(values).all(1)
  5. In [172]: df[row_mask]
  6. Out[172]: 
  7.    vals ids ids2
  8. 0     1   a    a

该where()方法和屏蔽

从具有布尔向量的Series中选择值通常会返回数据的子集。为了保证选择输出与原始数据具有相同的形状，您可以where在Series和中使用该方法DataFrame。

仅返回选定的行：

  1. In [173]: s[s > 0]
  2. Out[173]: 
  3. 3    1
  4. 2    2
  5. 1    3
  6. 0    4
  7. dtype: int64

要返回与原始形状相同的系列：

  1. In [174]: s.where(s > 0)
  2. Out[174]: 
  3. 4    NaN
  4. 3    1.0
  5. 2    2.0
  6. 1    3.0
  7. 0    4.0
  8. dtype: float64

现在，使用布尔标准从DataFrame中选择值也可以保留输入数据形状。where在引擎盖下用作实现。下面的代码相当于。df.where(df < 0)

  1. In [175]: df[df < 0]
  2. Out[175]: 
  3.                    A         B         C         D
  4. 2000-01-01 -2.104139 -1.309525       NaN       NaN
  5. 2000-01-02 -0.352480       NaN -1.192319       NaN
  6. 2000-01-03 -0.864883       NaN -0.227870       NaN
  7. 2000-01-04       NaN -1.222082       NaN -1.233203
  8. 2000-01-05       NaN -0.605656 -1.169184       NaN
  9. 2000-01-06       NaN -0.948458       NaN -0.684718
  10. 2000-01-07 -2.670153 -0.114722       NaN -0.048048
  11. 2000-01-08       NaN       NaN -0.048788 -0.808838

此外，在返回的副本中，where使用可选other参数替换条件为False的值。

  1. In [176]: df.where(df < 0, -df)
  2. Out[176]: 
  3.                    A         B         C         D
  4. 2000-01-01 -2.104139 -1.309525 -0.485855 -0.245166
  5. 2000-01-02 -0.352480 -0.390389 -1.192319 -1.655824
  6. 2000-01-03 -0.864883 -0.299674 -0.227870 -0.281059
  7. 2000-01-04 -0.846958 -1.222082 -0.600705 -1.233203
  8. 2000-01-05 -0.669692 -0.605656 -1.169184 -0.342416
  9. 2000-01-06 -0.868584 -0.948458 -2.297780 -0.684718
  10. 2000-01-07 -2.670153 -0.114722 -0.168904 -0.048048
  11. 2000-01-08 -0.801196 -1.392071 -0.048788 -0.808838

您可能希望根据某些布尔条件设置值。这可以直观地完成，如下所示：

  1. In [177]: s2 = s.copy()
  3. In [178]: s2[s2 < 0] = 0
  5. In [179]: s2
  6. Out[179]: 
  7. 4    0
  8. 3    1
  9. 2    2
  10. 1    3
  11. 0    4
  12. dtype: int64
  14. In [180]: df2 = df.copy()
  16. In [181]: df2[df2 < 0] = 0
  18. In [182]: df2
  19. Out[182]: 
  20.                    A         B         C         D
  21. 2000-01-01  0.000000  0.000000  0.485855  0.245166
  22. 2000-01-02  0.000000  0.390389  0.000000  1.655824
  23. 2000-01-03  0.000000  0.299674  0.000000  0.281059
  24. 2000-01-04  0.846958  0.000000  0.600705  0.000000
  25. 2000-01-05  0.669692  0.000000  0.000000  0.342416
  26. 2000-01-06  0.868584  0.000000  2.297780  0.000000
  27. 2000-01-07  0.000000  0.000000  0.168904  0.000000
  28. 2000-01-08  0.801196  1.392071  0.000000  0.000000

默认情况下，where返回数据的修改副本。有一个可选参数，inplace以便可以在不创建副本的情况下修改原始数据：

  1. In [183]: df_orig = df.copy()
  3. In [184]: df_orig.where(df > 0, -df, inplace=True)
  5. In [185]: df_orig
  6. Out[185]: 
  7.                    A         B         C         D
  8. 2000-01-01  2.104139  1.309525  0.485855  0.245166
  9. 2000-01-02  0.352480  0.390389  1.192319  1.655824
  10. 2000-01-03  0.864883  0.299674  0.227870  0.281059
  11. 2000-01-04  0.846958  1.222082  0.600705  1.233203
  12. 2000-01-05  0.669692  0.605656  1.169184  0.342416
  13. 2000-01-06  0.868584  0.948458  2.297780  0.684718
  14. 2000-01-07  2.670153  0.114722  0.168904  0.048048
  15. 2000-01-08  0.801196  1.392071  0.048788  0.808838

::: tip 注意

签名DataFrame.where()不同于numpy.where()。大致相当于。df1.where(m, df2)````np.where(m, df1, df2)

  1. In [186]: df.where(df < 0, -df) == np.where(df < 0, df, -df)
  2. Out[186]: 
  3.                A     B     C     D
  4. 2000-01-01  True  True  True  True
  5. 2000-01-02  True  True  True  True
  6. 2000-01-03  True  True  True  True
  7. 2000-01-04  True  True  True  True
  8. 2000-01-05  True  True  True  True
  9. 2000-01-06  True  True  True  True
  10. 2000-01-07  True  True  True  True
  11. 2000-01-08  True  True  True  True

:::

对准

此外，where对齐输入布尔条件（ndarray或DataFrame），以便可以使用设置进行部分选择。这类似于部分设置通过.loc（但是在内容而不是轴标签上）。

  1. In [187]: df2 = df.copy()
  3. In [188]: df2[df2[1:4] > 0] = 3
  5. In [189]: df2
  6. Out[189]: 
  7.                    A         B         C         D
  8. 2000-01-01 -2.104139 -1.309525  0.485855  0.245166
  9. 2000-01-02 -0.352480  3.000000 -1.192319  3.000000
  10. 2000-01-03 -0.864883  3.000000 -0.227870  3.000000
  11. 2000-01-04  3.000000 -1.222082  3.000000 -1.233203
  12. 2000-01-05  0.669692 -0.605656 -1.169184  0.342416
  13. 2000-01-06  0.868584 -0.948458  2.297780 -0.684718
  14. 2000-01-07 -2.670153 -0.114722  0.168904 -0.048048
  15. 2000-01-08  0.801196  1.392071 -0.048788 -0.808838

哪里也可以接受axis和level参数在执行时对齐输入where。

  1. In [190]: df2 = df.copy()
  3. In [191]: df2.where(df2 > 0, df2['A'], axis='index')
  4. Out[191]: 
  5.                    A         B         C         D
  6. 2000-01-01 -2.104139 -2.104139  0.485855  0.245166
  7. 2000-01-02 -0.352480  0.390389 -0.352480  1.655824
  8. 2000-01-03 -0.864883  0.299674 -0.864883  0.281059
  9. 2000-01-04  0.846958  0.846958  0.600705  0.846958
  10. 2000-01-05  0.669692  0.669692  0.669692  0.342416
  11. 2000-01-06  0.868584  0.868584  2.297780  0.868584
  12. 2000-01-07 -2.670153 -2.670153  0.168904 -2.670153
  13. 2000-01-08  0.801196  1.392071  0.801196  0.801196

这相当于（但快于）以下内容。

  1. In [192]: df2 = df.copy()
  3. In [193]: df.apply(lambda x, y: x.where(x > 0, y), y=df['A'])
  4. Out[193]: 
  5.                    A         B         C         D
  6. 2000-01-01 -2.104139 -2.104139  0.485855  0.245166
  7. 2000-01-02 -0.352480  0.390389 -0.352480  1.655824
  8. 2000-01-03 -0.864883  0.299674 -0.864883  0.281059
  9. 2000-01-04  0.846958  0.846958  0.600705  0.846958
  10. 2000-01-05  0.669692  0.669692  0.669692  0.342416
  11. 2000-01-06  0.868584  0.868584  2.297780  0.868584
  12. 2000-01-07 -2.670153 -2.670153  0.168904 -2.670153
  13. 2000-01-08  0.801196  1.392071  0.801196  0.801196

版本0.18.1中的新功能。

哪里可以接受一个可调用的条件和other参数。该函数必须带有一个参数（调用Series或DataFrame），并返回有效的输出作为条件和other参数。

  1. In [194]: df3 = pd.DataFrame({'A': [1, 2, 3],
  2.    .....:                     'B': [4, 5, 6],
  3.    .....:                     'C': [7, 8, 9]})
  4.    .....: 
  6. In [195]: df3.where(lambda x: x > 4, lambda x: x + 10)
  7. Out[195]: 
  8.     A   B  C
  9. 0  11  14  7
  10. 1  12   5  8
  11. 2  13   6  9

面具

mask()是的反布尔运算where。

  1. In [196]: s.mask(s >= 0)
  2. Out[196]: 
  3. 4   NaN
  4. 3   NaN
  5. 2   NaN
  6. 1   NaN
  7. 0   NaN
  8. dtype: float64
  10. In [197]: df.mask(df >= 0)
  11. Out[197]: 
  12.                    A         B         C         D
  13. 2000-01-01 -2.104139 -1.309525       NaN       NaN
  14. 2000-01-02 -0.352480       NaN -1.192319       NaN
  15. 2000-01-03 -0.864883       NaN -0.227870       NaN
  16. 2000-01-04       NaN -1.222082       NaN -1.233203
  17. 2000-01-05       NaN -0.605656 -1.169184       NaN
  18. 2000-01-06       NaN -0.948458       NaN -0.684718
  19. 2000-01-07 -2.670153 -0.114722       NaN -0.048048
  20. 2000-01-08       NaN       NaN -0.048788 -0.808838

该query()方法

DataFrame对象有一个query() 允许使用表达式进行选择的方法。

您可以获取列的值，其中列b具有列值a和值之间的值c。例如：

  1. In [198]: n = 10
  3. In [199]: df = pd.DataFrame(np.random.rand(n, 3), columns=list('abc'))
  5. In [200]: df
  6. Out[200]: 
  7.           a         b         c
  8. 0  0.438921  0.118680  0.863670
  9. 1  0.138138  0.577363  0.686602
  10. 2  0.595307  0.564592  0.520630
  11. 3  0.913052  0.926075  0.616184
  12. 4  0.078718  0.854477  0.898725
  13. 5  0.076404  0.523211  0.591538
  14. 6  0.792342  0.216974  0.564056
  15. 7  0.397890  0.454131  0.915716
  16. 8  0.074315  0.437913  0.019794
  17. 9  0.559209  0.502065  0.026437
  19. # pure python
  20. In [201]: df[(df.a < df.b) & (df.b < df.c)]
  21. Out[201]: 
  22.           a         b         c
  23. 1  0.138138  0.577363  0.686602
  24. 4  0.078718  0.854477  0.898725
  25. 5  0.076404  0.523211  0.591538
  26. 7  0.397890  0.454131  0.915716
  28. # query
  29. In [202]: df.query('(a < b) & (b < c)')
  30. Out[202]: 
  31.           a         b         c
  32. 1  0.138138  0.577363  0.686602
  33. 4  0.078718  0.854477  0.898725
  34. 5  0.076404  0.523211  0.591538
  35. 7  0.397890  0.454131  0.915716

如果没有名称的列，则执行相同的操作但返回命名索引a。

  1. In [203]: df = pd.DataFrame(np.random.randint(n / 2, size=(n, 2)), columns=list('bc'))
  3. In [204]: df.index.name = 'a'
  5. In [205]: df
  6. Out[205]: 
  7.    b  c
  8. a      
  9. 0  0  4
  10. 1  0  1
  11. 2  3  4
  12. 3  4  3
  13. 4  1  4
  14. 5  0  3
  15. 6  0  1
  16. 7  3  4
  17. 8  2  3
  18. 9  1  1
  20. In [206]: df.query('a < b and b < c')
  21. Out[206]: 
  22.    b  c
  23. a      
  24. 2  3  4

如果您不希望或不能命名索引，则可以index在查询表达式中使用该名称 ：

  1. In [207]: df = pd.DataFrame(np.random.randint(n, size=(n, 2)), columns=list('bc'))
  3. In [208]: df
  4. Out[208]: 
  5.    b  c
  6. 0  3  1
  7. 1  3  0
  8. 2  5  6
  9. 3  5  2
  10. 4  7  4
  11. 5  0  1
  12. 6  2  5
  13. 7  0  1
  14. 8  6  0
  15. 9  7  9
  17. In [209]: df.query('index < b < c')
  18. Out[209]: 
  19.    b  c
  20. 2  5  6

::: tip 注意

如果索引的名称与列名称重叠，则列名称优先。例如，

  1. In [210]: df = pd.DataFrame({'a': np.random.randint(5, size=5)})
  3. In [211]: df.index.name = 'a'
  5. In [212]: df.query('a > 2')  # uses the column 'a', not the index
  6. Out[212]: 
  7.    a
  8. a   
  9. 1  3
  10. 3  3

您仍然可以使用特殊标识符’index’在查询表达式中使用索引：

  1. In [213]: df.query('index > 2')
  2. Out[213]: 
  3.    a
  4. a   
  5. 3  3
  6. 4  2

如果由于某种原因你有一个名为列的列index，那么你也可以引用索引ilevel_0，但是此时你应该考虑将列重命名为不那么模糊的列。

:::

MultiIndex query()语法

您还可以使用的水平DataFrame带 MultiIndex，好像他们是在框架柱：

  1. In [214]: n = 10
  3. In [215]: colors = np.random.choice(['red', 'green'], size=n)
  5. In [216]: foods = np.random.choice(['eggs', 'ham'], size=n)
  7. In [217]: colors
  8. Out[217]: 
  9. array(['red', 'red', 'red', 'green', 'green', 'green', 'green', 'green',
  10.        'green', 'green'], dtype='<U5')
  12. In [218]: foods
  13. Out[218]: 
  14. array(['ham', 'ham', 'eggs', 'eggs', 'eggs', 'ham', 'ham', 'eggs', 'eggs',
  15.        'eggs'], dtype='<U4')
  17. In [219]: index = pd.MultiIndex.from_arrays([colors, foods], names=['color', 'food'])
  19. In [220]: df = pd.DataFrame(np.random.randn(n, 2), index=index)
  21. In [221]: df
  22. Out[221]: 
  23.                    0         1
  24. color food                    
  25. red   ham   0.194889 -0.381994
  26.       ham   0.318587  2.089075
  27.       eggs -0.728293 -0.090255
  28. green eggs -0.748199  1.318931
  29.       eggs -2.029766  0.792652
  30.       ham   0.461007 -0.542749
  31.       ham  -0.305384 -0.479195
  32.       eggs  0.095031 -0.270099
  33.       eggs -0.707140 -0.773882
  34.       eggs  0.229453  0.304418
  36. In [222]: df.query('color == "red"')
  37. Out[222]: 
  38.                    0         1
  39. color food                    
  40. red   ham   0.194889 -0.381994
  41.       ham   0.318587  2.089075
  42.       eggs -0.728293 -0.090255

如果MultiIndex未命名的级别，您可以使用特殊名称引用它们：

  1. In [223]: df.index.names = [None, None]
  3. In [224]: df
  4. Out[224]: 
  5.                    0         1
  6. red   ham   0.194889 -0.381994
  7.       ham   0.318587  2.089075
  8.       eggs -0.728293 -0.090255
  9. green eggs -0.748199  1.318931
  10.       eggs -2.029766  0.792652
  11.       ham   0.461007 -0.542749
  12.       ham  -0.305384 -0.479195
  13.       eggs  0.095031 -0.270099
  14.       eggs -0.707140 -0.773882
  15.       eggs  0.229453  0.304418
  17. In [225]: df.query('ilevel_0 == "red"')
  18. Out[225]: 
  19.                  0         1
  20. red ham   0.194889 -0.381994
  21.     ham   0.318587  2.089075
  22.     eggs -0.728293 -0.090255

约定是ilevel_0，这意味着第0级的“索引级别0” index。

query()用例

用例query()是当您拥有一组具有共同 DataFrame列名（或索引级别/名称）子集的对象时。您可以将相同的查询传递给两个帧，而 无需指定您对查询感兴趣的帧

  1. In [226]: df = pd.DataFrame(np.random.rand(n, 3), columns=list('abc'))
  3. In [227]: df
  4. Out[227]: 
  5.           a         b         c
  6. 0  0.224283  0.736107  0.139168
  7. 1  0.302827  0.657803  0.713897
  8. 2  0.611185  0.136624  0.984960
  9. 3  0.195246  0.123436  0.627712
  10. 4  0.618673  0.371660  0.047902
  11. 5  0.480088  0.062993  0.185760
  12. 6  0.568018  0.483467  0.445289
  13. 7  0.309040  0.274580  0.587101
  14. 8  0.258993  0.477769  0.370255
  15. 9  0.550459  0.840870  0.304611
  17. In [228]: df2 = pd.DataFrame(np.random.rand(n + 2, 3), columns=df.columns)
  19. In [229]: df2
  20. Out[229]: 
  21.            a         b         c
  22. 0   0.357579  0.229800  0.596001
  23. 1   0.309059  0.957923  0.965663
  24. 2   0.123102  0.336914  0.318616
  25. 3   0.526506  0.323321  0.860813
  26. 4   0.518736  0.486514  0.384724
  27. 5   0.190804  0.505723  0.614533
  28. 6   0.891939  0.623977  0.676639
  29. 7   0.480559  0.378528  0.460858
  30. 8   0.420223  0.136404  0.141295
  31. 9   0.732206  0.419540  0.604675
  32. 10  0.604466  0.848974  0.896165
  33. 11  0.589168  0.920046  0.732716
  35. In [230]: expr = '0.0 <= a <= c <= 0.5'
  37. In [231]: map(lambda frame: frame.query(expr), [df, df2])
  38. Out[231]: <map at 0x7f65f7952d30>

query()Python与pandas语法比较

完全类似numpy的语法：

  1. In [232]: df = pd.DataFrame(np.random.randint(n, size=(n, 3)), columns=list('abc'))
  3. In [233]: df
  4. Out[233]: 
  5.    a  b  c
  6. 0  7  8  9
  7. 1  1  0  7
  8. 2  2  7  2
  9. 3  6  2  2
  10. 4  2  6  3
  11. 5  3  8  2
  12. 6  1  7  2
  13. 7  5  1  5
  14. 8  9  8  0
  15. 9  1  5  0
  17. In [234]: df.query('(a < b) & (b < c)')
  18. Out[234]: 
  19.    a  b  c
  20. 0  7  8  9
  22. In [235]: df[(df.a < df.b) & (df.b < df.c)]
  23. Out[235]: 
  24.    a  b  c
  25. 0  7  8  9

通过删除括号略微更好（通过绑定使比较运算符绑定比&和更紧|）。

  1. In [236]: df.query('a < b & b < c')
  2. Out[236]: 
  3.    a  b  c
  4. 0  7  8  9

使用英语而不是符号：

  1. In [237]: df.query('a < b and b < c')
  2. Out[237]: 
  3.    a  b  c
  4. 0  7  8  9

非常接近你如何在纸上写它：

  1. In [238]: df.query('a < b < c')
  2. Out[238]: 
  3.    a  b  c
  4. 0  7  8  9

在in与运营商not in

query()还支持Python in和 比较运算符的特殊用法，为调用或的方法提供了简洁的语法 。not in````isin````Series````DataFrame

  1. # get all rows where columns "a" and "b" have overlapping values
  2. In [239]: df = pd.DataFrame({'a': list('aabbccddeeff'), 'b': list('aaaabbbbcccc'),
  3.    .....:                    'c': np.random.randint(5, size=12),
  4.    .....:                    'd': np.random.randint(9, size=12)})
  5.    .....: 
  7. In [240]: df
  8. Out[240]: 
  9.     a  b  c  d
  10. 0   a  a  2  6
  11. 1   a  a  4  7
  12. 2   b  a  1  6
  13. 3   b  a  2  1
  14. 4   c  b  3  6
  15. 5   c  b  0  2
  16. 6   d  b  3  3
  17. 7   d  b  2  1
  18. 8   e  c  4  3
  19. 9   e  c  2  0
  20. 10  f  c  0  6
  21. 11  f  c  1  2
  23. In [241]: df.query('a in b')
  24. Out[241]: 
  25.    a  b  c  d
  26. 0  a  a  2  6
  27. 1  a  a  4  7
  28. 2  b  a  1  6
  29. 3  b  a  2  1
  30. 4  c  b  3  6
  31. 5  c  b  0  2
  33. # How you'd do it in pure Python
  34. In [242]: df[df.a.isin(df.b)]
  35. Out[242]: 
  36.    a  b  c  d
  37. 0  a  a  2  6
  38. 1  a  a  4  7
  39. 2  b  a  1  6
  40. 3  b  a  2  1
  41. 4  c  b  3  6
  42. 5  c  b  0  2
  44. In [243]: df.query('a not in b')
  45. Out[243]: 
  46.     a  b  c  d
  47. 6   d  b  3  3
  48. 7   d  b  2  1
  49. 8   e  c  4  3
  50. 9   e  c  2  0
  51. 10  f  c  0  6
  52. 11  f  c  1  2
  54. # pure Python
  55. In [244]: df[~df.a.isin(df.b)]
  56. Out[244]: 
  57.     a  b  c  d
  58. 6   d  b  3  3
  59. 7   d  b  2  1
  60. 8   e  c  4  3
  61. 9   e  c  2  0
  62. 10  f  c  0  6
  63. 11  f  c  1  2

您可以将此与其他表达式结合使用，以获得非常简洁的查询：

  1. # rows where cols a and b have overlapping values
  2. # and col c's values are less than col d's
  3. In [245]: df.query('a in b and c < d')
  4. Out[245]: 
  5.    a  b  c  d
  6. 0  a  a  2  6
  7. 1  a  a  4  7
  8. 2  b  a  1  6
  9. 4  c  b  3  6
  10. 5  c  b  0  2
  12. # pure Python
  13. In [246]: df[df.b.isin(df.a) & (df.c < df.d)]
  14. Out[246]: 
  15.     a  b  c  d
  16. 0   a  a  2  6
  17. 1   a  a  4  7
  18. 2   b  a  1  6
  19. 4   c  b  3  6
  20. 5   c  b  0  2
  21. 10  f  c  0  6
  22. 11  f  c  1  2

::: tip 注意

请注意in并在Python中进行评估，因为 它没有相应的操作。但是，只有 / expression本身在vanilla Python中进行评估。例如，在表达式中not in````numexpr** in````not in

  1. df.query('a in b + c + d')

(b + c + d)通过评估numexpr和然后的in 操作在普通的Python评价。通常，任何可以使用的评估操作numexpr都是。

:::

==运算符与list对象的特殊用法

一个比较list值的使用列==/ !=工程，以类似in/ 。not in

  1. In [247]: df.query('b == ["a", "b", "c"]')
  2. Out[247]: 
  3.     a  b  c  d
  4. 0   a  a  2  6
  5. 1   a  a  4  7
  6. 2   b  a  1  6
  7. 3   b  a  2  1
  8. 4   c  b  3  6
  9. 5   c  b  0  2
  10. 6   d  b  3  3
  11. 7   d  b  2  1
  12. 8   e  c  4  3
  13. 9   e  c  2  0
  14. 10  f  c  0  6
  15. 11  f  c  1  2
  17. # pure Python
  18. In [248]: df[df.b.isin(["a", "b", "c"])]
  19. Out[248]: 
  20.     a  b  c  d
  21. 0   a  a  2  6
  22. 1   a  a  4  7
  23. 2   b  a  1  6
  24. 3   b  a  2  1
  25. 4   c  b  3  6
  26. 5   c  b  0  2
  27. 6   d  b  3  3
  28. 7   d  b  2  1
  29. 8   e  c  4  3
  30. 9   e  c  2  0
  31. 10  f  c  0  6
  32. 11  f  c  1  2
  34. In [249]: df.query('c == [1, 2]')
  35. Out[249]: 
  36.     a  b  c  d
  37. 0   a  a  2  6
  38. 2   b  a  1  6
  39. 3   b  a  2  1
  40. 7   d  b  2  1
  41. 9   e  c  2  0
  42. 11  f  c  1  2
  44. In [250]: df.query('c != [1, 2]')
  45. Out[250]: 
  46.     a  b  c  d
  47. 1   a  a  4  7
  48. 4   c  b  3  6
  49. 5   c  b  0  2
  50. 6   d  b  3  3
  51. 8   e  c  4  3
  52. 10  f  c  0  6
  54. # using in/not in
  55. In [251]: df.query('[1, 2] in c')
  56. Out[251]: 
  57.     a  b  c  d
  58. 0   a  a  2  6
  59. 2   b  a  1  6
  60. 3   b  a  2  1
  61. 7   d  b  2  1
  62. 9   e  c  2  0
  63. 11  f  c  1  2
  65. In [252]: df.query('[1, 2] not in c')
  66. Out[252]: 
  67.     a  b  c  d
  68. 1   a  a  4  7
  69. 4   c  b  3  6
  70. 5   c  b  0  2
  71. 6   d  b  3  3
  72. 8   e  c  4  3
  73. 10  f  c  0  6
  75. # pure Python
  76. In [253]: df[df.c.isin([1, 2])]
  77. Out[253]: 
  78.     a  b  c  d
  79. 0   a  a  2  6
  80. 2   b  a  1  6
  81. 3   b  a  2  1
  82. 7   d  b  2  1
  83. 9   e  c  2  0
  84. 11  f  c  1  2

布尔运算符

您可以使用单词not或~运算符否定布尔表达式。

  1. In [254]: df = pd.DataFrame(np.random.rand(n, 3), columns=list('abc'))
  3. In [255]: df['bools'] = np.random.rand(len(df)) > 0.5
  5. In [256]: df.query('~bools')
  6. Out[256]: 
  7.           a         b         c  bools
  8. 2  0.697753  0.212799  0.329209  False
  9. 7  0.275396  0.691034  0.826619  False
  10. 8  0.190649  0.558748  0.262467  False
  12. In [257]: df.query('not bools')
  13. Out[257]: 
  14.           a         b         c  bools
  15. 2  0.697753  0.212799  0.329209  False
  16. 7  0.275396  0.691034  0.826619  False
  17. 8  0.190649  0.558748  0.262467  False
  19. In [258]: df.query('not bools') == df[~df.bools]
  20. Out[258]: 
  21.       a     b     c  bools
  22. 2  True  True  True   True
  23. 7  True  True  True   True
  24. 8  True  True  True   True

当然，表达式也可以是任意复杂的：

  1. # short query syntax
  2. In [259]: shorter = df.query('a < b < c and (not bools) or bools > 2')
  4. # equivalent in pure Python
  5. In [260]: longer = df[(df.a < df.b) & (df.b < df.c) & (~df.bools) | (df.bools > 2)]
  7. In [261]: shorter
  8. Out[261]: 
  9.           a         b         c  bools
  10. 7  0.275396  0.691034  0.826619  False
  12. In [262]: longer
  13. Out[262]: 
  14.           a         b         c  bools
  15. 7  0.275396  0.691034  0.826619  False
  17. In [263]: shorter == longer
  18. Out[263]: 
  19.       a     b     c  bools
  20. 7  True  True  True   True

的表现¶query()

DataFrame.query()````numexpr对于大型帧，使用比Python略快。

query-perf

::: tip 注意

如果您的框架超过大约200,000行，您将只看到使用numexpr引擎的性能优势DataFrame.query()。

query-perf-small

:::

此图是使用DataFrame3列创建的，每列包含使用生成的浮点值numpy.random.randn()。

重复数据

如果要识别和删除DataFrame中的重复行，有两种方法可以提供帮助：duplicated和drop_duplicates。每个都将用于标识重复行的列作为参数。

  • duplicated 返回一个布尔向量，其长度为行数，表示行是否重复。
  • drop_duplicates 删除重复的行。

默认情况下，重复集的第一个观察行被认为是唯一的，但每个方法都有一个keep参数来指定要保留的目标。

  • keep='first' （默认值）：标记/删除重复项，第一次出现除外。
  • keep='last'：标记/删除重复项，除了最后一次出现。
  • keep=False：标记/删除所有重复项。
  1. In [264]: df2 = pd.DataFrame({'a': ['one', 'one', 'two', 'two', 'two', 'three', 'four'],
  2.    .....:                     'b': ['x', 'y', 'x', 'y', 'x', 'x', 'x'],
  3.    .....:                     'c': np.random.randn(7)})
  4.    .....: 
  6. In [265]: df2
  7. Out[265]: 
  8.        a  b         c
  9. 0    one  x -1.067137
  10. 1    one  y  0.309500
  11. 2    two  x -0.211056
  12. 3    two  y -1.842023
  13. 4    two  x -0.390820
  14. 5  three  x -1.964475
  15. 6   four  x  1.298329
  17. In [266]: df2.duplicated('a')
  18. Out[266]: 
  19. 0    False
  20. 1     True
  21. 2    False
  22. 3     True
  23. 4     True
  24. 5    False
  25. 6    False
  26. dtype: bool
  28. In [267]: df2.duplicated('a', keep='last')
  29. Out[267]: 
  30. 0     True
  31. 1    False
  32. 2     True
  33. 3     True
  34. 4    False
  35. 5    False
  36. 6    False
  37. dtype: bool
  39. In [268]: df2.duplicated('a', keep=False)
  40. Out[268]: 
  41. 0     True
  42. 1     True
  43. 2     True
  44. 3     True
  45. 4     True
  46. 5    False
  47. 6    False
  48. dtype: bool
  50. In [269]: df2.drop_duplicates('a')
  51. Out[269]: 
  52.        a  b         c
  53. 0    one  x -1.067137
  54. 2    two  x -0.211056
  55. 5  three  x -1.964475
  56. 6   four  x  1.298329
  58. In [270]: df2.drop_duplicates('a', keep='last')
  59. Out[270]: 
  60.        a  b         c
  61. 1    one  y  0.309500
  62. 4    two  x -0.390820
  63. 5  three  x -1.964475
  64. 6   four  x  1.298329
  66. In [271]: df2.drop_duplicates('a', keep=False)
  67. Out[271]: 
  68.        a  b         c
  69. 5  three  x -1.964475
  70. 6   four  x  1.298329

此外，您可以传递列表列表以识别重复。

  1. In [272]: df2.duplicated(['a', 'b'])
  2. Out[272]: 
  3. 0    False
  4. 1    False
  5. 2    False
  6. 3    False
  7. 4     True
  8. 5    False
  9. 6    False
  10. dtype: bool
  12. In [273]: df2.drop_duplicates(['a', 'b'])
  13. Out[273]: 
  14.        a  b         c
  15. 0    one  x -1.067137
  16. 1    one  y  0.309500
  17. 2    two  x -0.211056
  18. 3    two  y -1.842023
  19. 5  three  x -1.964475
  20. 6   four  x  1.298329

要按索引值删除重复项，请使用Index.duplicated然后执行切片。keep参数可以使用相同的选项集。

  1. In [274]: df3 = pd.DataFrame({'a': np.arange(6),
  2.    .....:                     'b': np.random.randn(6)},
  3.    .....:                    index=['a', 'a', 'b', 'c', 'b', 'a'])
  4.    .....: 
  6. In [275]: df3
  7. Out[275]: 
  8.    a         b
  9. a  0  1.440455
  10. a  1  2.456086
  11. b  2  1.038402
  12. c  3 -0.894409
  13. b  4  0.683536
  14. a  5  3.082764
  16. In [276]: df3.index.duplicated()
  17. Out[276]: array([False,  True, False, False,  True,  True])
  19. In [277]: df3[~df3.index.duplicated()]
  20. Out[277]: 
  21.    a         b
  22. a  0  1.440455
  23. b  2  1.038402
  24. c  3 -0.894409
  26. In [278]: df3[~df3.index.duplicated(keep='last')]
  27. Out[278]: 
  28.    a         b
  29. c  3 -0.894409
  30. b  4  0.683536
  31. a  5  3.082764
  33. In [279]: df3[~df3.index.duplicated(keep=False)]
  34. Out[279]: 
  35.    a         b
  36. c  3 -0.894409

类字典get()方法

Series或DataFrame中的每一个都有一个get可以返回默认值的方法。

  1. In [280]: s = pd.Series([1, 2, 3], index=['a', 'b', 'c'])
  3. In [281]: s.get('a')  # equivalent to s['a']
  4. Out[281]: 1
  6. In [282]: s.get('x', default=-1)
  7. Out[282]: -1

该lookup()方法

有时，您希望在给定一系列行标签和列标签的情况下提取一组值，并且该lookup方法允许此操作并返回NumPy数组。例如：

  1. In [283]: dflookup = pd.DataFrame(np.random.rand(20, 4), columns = ['A', 'B', 'C', 'D'])
  3. In [284]: dflookup.lookup(list(range(0, 10, 2)), ['B', 'C', 'A', 'B', 'D'])
  4. Out[284]: array([0.3506, 0.4779, 0.4825, 0.9197, 0.5019])

索引对象

pandas Index类及其子类可以视为实现有序的多集合。允许重复。但是，如果您尝试将Index具有重复条目的对象转换为a set，则会引发异常。

Index还提供了查找，数据对齐和重建索引所需的基础结构。Index直接创建的最简单方法 是将一个list或其他序列传递给 Index：

  1. In [285]: index = pd.Index(['e', 'd', 'a', 'b'])
  3. In [286]: index
  4. Out[286]: Index(['e', 'd', 'a', 'b'], dtype='object')
  6. In [287]: 'd' in index
  7. Out[287]: True

您还可以传递一个name存储在索引中：

  1. In [288]: index = pd.Index(['e', 'd', 'a', 'b'], name='something')
  3. In [289]: index.name
  4. Out[289]: 'something'

名称（如果已设置）将显示在控制台显示中：

  1. In [290]: index = pd.Index(list(range(5)), name='rows')
  3. In [291]: columns = pd.Index(['A', 'B', 'C'], name='cols')
  5. In [292]: df = pd.DataFrame(np.random.randn(5, 3), index=index, columns=columns)
  7. In [293]: df
  8. Out[293]: 
  9. cols         A         B         C
  10. rows                              
  11. 0     1.295989  0.185778  0.436259
  12. 1     0.678101  0.311369 -0.528378
  13. 2    -0.674808 -1.103529 -0.656157
  14. 3     1.889957  2.076651 -1.102192
  15. 4    -1.211795 -0.791746  0.634724
  17. In [294]: df['A']
  18. Out[294]: 
  19. rows
  20. 0    1.295989
  21. 1    0.678101
  22. 2   -0.674808
  23. 3    1.889957
  24. 4   -1.211795
  25. Name: A, dtype: float64

设置元数据

索引是“不可改变的大多是”，但它可以设置和改变它们的元数据，如指数name（或为MultiIndex，levels和 codes）。

您可以使用rename，set_names，set_levels，和set_codes 直接设置这些属性。他们默认返回一份副本; 但是，您可以指定inplace=True使数据更改到位。

有关MultiIndexes的使用，请参阅高级索引。

  1. In [295]: ind = pd.Index([1, 2, 3])
  3. In [296]: ind.rename("apple")
  4. Out[296]: Int64Index([1, 2, 3], dtype='int64', name='apple')
  6. In [297]: ind
  7. Out[297]: Int64Index([1, 2, 3], dtype='int64')
  9. In [298]: ind.set_names(["apple"], inplace=True)
  11. In [299]: ind.name = "bob"
  13. In [300]: ind
  14. Out[300]: Int64Index([1, 2, 3], dtype='int64', name='bob')

set_names，set_levels并且set_codes还采用可选 level参数

  1. In [301]: index = pd.MultiIndex.from_product([range(3), ['one', 'two']], names=['first', 'second'])
  3. In [302]: index
  4. Out[302]: 
  5. MultiIndex([(0, 'one'),
  6.             (0, 'two'),
  7.             (1, 'one'),
  8.             (1, 'two'),
  9.             (2, 'one'),
  10.             (2, 'two')],
  11.            names=['first', 'second'])
  13. In [303]: index.levels[1]
  14. Out[303]: Index(['one', 'two'], dtype='object', name='second')
  16. In [304]: index.set_levels(["a", "b"], level=1)
  17. Out[304]: 
  18. MultiIndex([(0, 'a'),
  19.             (0, 'b'),
  20.             (1, 'a'),
  21.             (1, 'b'),
  22.             (2, 'a'),
  23.             (2, 'b')],
  24.            names=['first', 'second'])

在Index对象上设置操作

两个主要业务是和。这些可以直接称为实例方法，也可以通过重载运算符使用。通过该方法提供差异。union (|)````intersection (&)````.difference()

  1. In [305]: a = pd.Index(['c', 'b', 'a'])
  3. In [306]: b = pd.Index(['c', 'e', 'd'])
  5. In [307]: a | b
  6. Out[307]: Index(['a', 'b', 'c', 'd', 'e'], dtype='object')
  8. In [308]: a & b
  9. Out[308]: Index(['c'], dtype='object')
  11. In [309]: a.difference(b)
  12. Out[309]: Index(['a', 'b'], dtype='object')

同时还提供了操作，它返回出现在任一元件或，但不是在两者。这相当于创建的索引，删除了重复项。symmetric_difference (^)````idx1````idx2````idx1.difference(idx2).union(idx2.difference(idx1))

  1. In [310]: idx1 = pd.Index([1, 2, 3, 4])
  3. In [311]: idx2 = pd.Index([2, 3, 4, 5])
  5. In [312]: idx1.symmetric_difference(idx2)
  6. Out[312]: Int64Index([1, 5], dtype='int64')
  8. In [313]: idx1 ^ idx2
  9. Out[313]: Int64Index([1, 5], dtype='int64')

::: tip 注意

来自设置操作的结果索引将按升序排序。

:::

在Index.union()具有不同dtypes的索引之间执行时，必须将索引强制转换为公共dtype。通常，虽然并非总是如此，但这是对象dtype。例外是在整数和浮点数据之间执行联合。在这种情况下，整数值将转换为float

  1. In [314]: idx1 = pd.Index([0, 1, 2])
  3. In [315]: idx2 = pd.Index([0.5, 1.5])
  5. In [316]: idx1 | idx2
  6. Out[316]: Float64Index([0.0, 0.5, 1.0, 1.5, 2.0], dtype='float64')

缺少值

即使Index可以保存缺失值（NaN），但如果您不想要任何意外结果，也应该避免使用。例如，某些操作会隐式排除缺失值。

Index.fillna 使用指定的标量值填充缺失值。

  1. In [317]: idx1 = pd.Index([1, np.nan, 3, 4])
  3. In [318]: idx1
  4. Out[318]: Float64Index([1.0, nan, 3.0, 4.0], dtype='float64')
  6. In [319]: idx1.fillna(2)
  7. Out[319]: Float64Index([1.0, 2.0, 3.0, 4.0], dtype='float64')
  9. In [320]: idx2 = pd.DatetimeIndex([pd.Timestamp('2011-01-01'),
  10.    .....:                          pd.NaT,
  11.    .....:                          pd.Timestamp('2011-01-03')])
  12.    .....: 
  14. In [321]: idx2
  15. Out[321]: DatetimeIndex(['2011-01-01', 'NaT', '2011-01-03'], dtype='datetime64[ns]', freq=None)
  17. In [322]: idx2.fillna(pd.Timestamp('2011-01-02'))
  18. Out[322]: DatetimeIndex(['2011-01-01', '2011-01-02', '2011-01-03'], dtype='datetime64[ns]', freq=None)

设置/重置索引

有时您会将数据集加载或创建到DataFrame中，并希望在您已经完成之后添加索引。有几种不同的方式。

设置索引

DataFrame有一个set_index()方法，它采用列名（对于常规Index）或列名列表（对于a MultiIndex）。要创建新的重新索引的DataFrame：

  1. In [323]: data
  2. Out[323]: 
  3.      a    b  c    d
  4. 0  bar  one  z  1.0
  5. 1  bar  two  y  2.0
  6. 2  foo  one  x  3.0
  7. 3  foo  two  w  4.0
  9. In [324]: indexed1 = data.set_index('c')
  11. In [325]: indexed1
  12. Out[325]: 
  13.      a    b    d
  14. c               
  15. z  bar  one  1.0
  16. y  bar  two  2.0
  17. x  foo  one  3.0
  18. w  foo  two  4.0
  20. In [326]: indexed2 = data.set_index(['a', 'b'])
  22. In [327]: indexed2
  23. Out[327]: 
  24.          c    d
  25. a   b          
  26. bar one  z  1.0
  27.     two  y  2.0
  28. foo one  x  3.0
  29.     two  w  4.0

该append关键字选项让你保持现有索引并追加给列一个多指标：

  1. In [328]: frame = data.set_index('c', drop=False)
  3. In [329]: frame = frame.set_index(['a', 'b'], append=True)
  5. In [330]: frame
  6. Out[330]: 
  7.            c    d
  8. c a   b          
  9. z bar one  z  1.0
  10. y bar two  y  2.0
  11. x foo one  x  3.0
  12. w foo two  w  4.0

其他选项set_index允许您不删除索引列或就地添加索引（不创建新对象）：

  1. In [331]: data.set_index('c', drop=False)
  2. Out[331]: 
  3.      a    b  c    d
  4. c                  
  5. z  bar  one  z  1.0
  6. y  bar  two  y  2.0
  7. x  foo  one  x  3.0
  8. w  foo  two  w  4.0
  10. In [332]: data.set_index(['a', 'b'], inplace=True)
  12. In [333]: data
  13. Out[333]: 
  14.          c    d
  15. a   b          
  16. bar one  z  1.0
  17.     two  y  2.0
  18. foo one  x  3.0
  19.     two  w  4.0

重置索引

为方便起见，DataFrame上有一个新函数，它将 reset_index()索引值传输到DataFrame的列中并设置一个简单的整数索引。这是反向操作set_index()。

  1. In [334]: data
  2. Out[334]: 
  3.          c    d
  4. a   b          
  5. bar one  z  1.0
  6.     two  y  2.0
  7. foo one  x  3.0
  8.     two  w  4.0
  10. In [335]: data.reset_index()
  11. Out[335]: 
  12.      a    b  c    d
  13. 0  bar  one  z  1.0
  14. 1  bar  two  y  2.0
  15. 2  foo  one  x  3.0
  16. 3  foo  two  w  4.0

输出更类似于SQL表或记录数组。从索引派生的列的名称是存储在names属性中的名称。

您可以使用level关键字仅删除索引的一部分：

  1. In [336]: frame
  2. Out[336]: 
  3.            c    d
  4. c a   b          
  5. z bar one  z  1.0
  6. y bar two  y  2.0
  7. x foo one  x  3.0
  8. w foo two  w  4.0
  10. In [337]: frame.reset_index(level=1)
  11. Out[337]: 
  12.          a  c    d
  13. c b               
  14. z one  bar  z  1.0
  15. y two  bar  y  2.0
  16. x one  foo  x  3.0
  17. w two  foo  w  4.0

reset_index采用一个可选参数drop，如果为true，则只丢弃索引，而不是将索引值放在DataFrame的列中。

添加ad hoc索引

如果您自己创建索引，则可以将其分配给index字段：

  1. data.index = index

返回视图与副本

在pandas对象中设置值时，必须注意避免调用所谓的对象 。这是一个例子。chained indexing

  1. In [338]: dfmi = pd.DataFrame([list('abcd'),
  2.    .....:                      list('efgh'),
  3.    .....:                      list('ijkl'),
  4.    .....:                      list('mnop')],
  5.    .....:                     columns=pd.MultiIndex.from_product([['one', 'two'],
  6.    .....:                                                         ['first', 'second']]))
  7.    .....: 
  9. In [339]: dfmi
  10. Out[339]: 
  11.     one          two       
  12.   first second first second
  13. 0     a      b     c      d
  14. 1     e      f     g      h
  15. 2     i      j     k      l
  16. 3     m      n     o      p

比较这两种访问方法：

  1. In [340]: dfmi['one']['second']
  2. Out[340]: 
  3. 0    b
  4. 1    f
  5. 2    j
  6. 3    n
  7. Name: second, dtype: object
  1. In [341]: dfmi.loc[:, ('one', 'second')]
  2. Out[341]: 
  3. 0    b
  4. 1    f
  5. 2    j
  6. 3    n
  7. Name: (one, second), dtype: object

这两者都产生相同的结果，所以你应该使用哪个？理解这些操作的顺序以及为什么方法2（.loc）比方法1（链接[]）更受欢迎是有益的。

dfmi['one']选择列的第一级并返回单索引的DataFrame。然后另一个Python操作dfmi_with_one['second']选择索引的系列'second'。这由变量指示，dfmi_with_one因为pandas将这些操作视为单独的事件。例如，单独调用__getitem__，因此它必须将它们视为线性操作，它们一个接一个地发生。

对比这个df.loc[:,('one','second')]将一个嵌套的元组传递(slice(None),('one','second'))给一个单独的调用 __getitem__。这允许pandas将其作为单个实体来处理。此外，这种操作顺序可以明显更快，并且如果需要，允许人们对两个轴进行索引。

使用链式索引时为什么分配失败？

上一节中的问题只是一个性能问题。这是怎么回事与SettingWithCopy警示？当你做一些可能花费几毫秒的事情时，我们通常不会发出警告！

但事实证明，分配链式索引的产品具有固有的不可预测的结果。要看到这一点，请考虑Python解释器如何执行此代码：

  1. dfmi.loc[:, ('one', 'second')] = value
  2. # becomes
  3. dfmi.loc.__setitem__((slice(None), ('one', 'second')), value)

但是这个代码的处理方式不同：

  1. dfmi['one']['second'] = value
  2. # becomes
  3. dfmi.__getitem__('one').__setitem__('second', value)

看到__getitem__那里？除了简单的情况之外，很难预测它是否会返回一个视图或一个副本（它取决于数组的内存布局，关于哪些pandas不能保证），因此是否__setitem__会修改dfmi或者是一个临时对象之后立即抛出。那什么SettingWithCopy是警告你！

::: tip 注意

您可能想知道我们是否应该关注loc 第一个示例中的属性。但dfmi.loc保证dfmi 本身具有修改的索引行为，因此dfmi.loc.__getitem__/ 直接dfmi.loc.__setitem__操作dfmi。当然， dfmi.loc.__getitem__(idx)可能是一个视图或副本dfmi。

:::

有时SettingWithCopy，当没有明显的链式索引时，会出现警告。这些SettingWithCopy是旨在捕获的错误 ！Pandas可能会试图警告你，你已经这样做了：

  1. def do_something(df):
  2.     foo = df[['bar', 'baz']]  # Is foo a view? A copy? Nobody knows!
  3.     # ... many lines here ...
  4.     # We don't know whether this will modify df or not!
  5.     foo['quux'] = value
  6.     return foo

哎呀！

评估订单事项

使用链式索引时，索引操作的顺序和类型会部分确定结果是原始对象的切片还是切片的副本。

Pandas有，SettingWithCopyWarning因为分配一个切片的副本通常不是故意的，而是由链式索引引起的错误返回一个预期切片的副本。

如果您希望pandas或多或少地信任链接索引表达式的赋值，则可以将选项 设置mode.chained_assignment为以下值之一：

  • 'warn'，默认值表示SettingWithCopyWarning打印。
  • 'raise'意味着大Pandas会提出SettingWithCopyException 你必须处理的事情。
  • None 将完全压制警告。
  1. In [342]: dfb = pd.DataFrame({'a': ['one', 'one', 'two',
  2.    .....:                           'three', 'two', 'one', 'six'],
  3.    .....:                     'c': np.arange(7)})
  4.    .....: 
  6. # This will show the SettingWithCopyWarning
  7. # but the frame values will be set
  8. In [343]: dfb['c'][dfb.a.str.startswith('o')] = 42

然而，这是在副本上运行，不起作用。

  1. >>> pd.set_option('mode.chained_assignment','warn')
  2. >>> dfb[dfb.a.str.startswith('o')]['c'] = 42
  3. Traceback (most recent call last)
  4.      ...
  5. SettingWithCopyWarning:
  6.      A value is trying to be set on a copy of a slice from a DataFrame.
  7.      Try using .loc[row_index,col_indexer] = value instead

链式分配也可以在混合dtype帧中进行设置。

::: tip 注意

这些设置规则适用于所有.loc/.iloc。

:::

这是正确的访问方法：

  1. In [344]: dfc = pd.DataFrame({'A': ['aaa', 'bbb', 'ccc'], 'B': [1, 2, 3]})
  3. In [345]: dfc.loc[0, 'A'] = 11
  5. In [346]: dfc
  6. Out[346]: 
  7.      A  B
  8. 0   11  1
  9. 1  bbb  2
  10. 2  ccc  3

这有时会起作用，但不能保证，因此应该避免：

  1. In [347]: dfc = dfc.copy()
  3. In [348]: dfc['A'][0] = 111
  5. In [349]: dfc
  6. Out[349]: 
  7.      A  B
  8. 0  111  1
  9. 1  bbb  2
  10. 2  ccc  3

这根本不起作用，所以应该避免：

  1. >>> pd.set_option('mode.chained_assignment','raise')
  2. >>> dfc.loc[0]['A'] = 1111
  3. Traceback (most recent call last)
  4.      ...
  5. SettingWithCopyException:
  6.      A value is trying to be set on a copy of a slice from a DataFrame.
  7.      Try using .loc[row_index,col_indexer] = value instead

::: danger 警告

链式分配警告/异常旨在通知用户可能无效的分配。可能存在误报; 无意中报告链式作业的情况。

:::