0.23.0 中的新增内容（2018 年 5 月 15 日）#

这是 0.22.0 的主要版本，包括大量 API 更改、弃用、新功能、增强功能和性能改进以及大量错误修复。我们建议所有用户升级到此版本。

亮点包括：

更新前请检查API 更改和弃用。

警告

从 2019 年 1 月 1 日开始，pandas 功能版本将仅支持 Python 3。有关更多信息，请参阅删除 Python 2.7。

新功能＃

JSON 读/写可通过#进行往返orient='table'

DataFrame现在可以通过 JSON 写入A并随后读回，同时通过使用参数保留元数据orient='table'（请参阅GH 18912和GH 9146）。以前，没有任何可用orient值可以保证数据类型和索引名称以及其他元数据的保存。

In [1]: df = pd.DataFrame({'foo': [1, 2, 3, 4],
   ...:                    'bar': ['a', 'b', 'c', 'd'],
   ...:                    'baz': pd.date_range('2018-01-01', freq='d', periods=4),
   ...:                    'qux': pd.Categorical(['a', 'b', 'c', 'c'])},
   ...:                   index=pd.Index(range(4), name='idx'))
   ...: 

In [2]: df
Out[2]: 
     foo bar        baz qux
idx                        
0      1   a 2018-01-01   a
1      2   b 2018-01-02   b
2      3   c 2018-01-03   c
3      4   d 2018-01-04   c

[4 rows x 4 columns]

In [3]: df.dtypes
Out[3]: 
foo             int64
bar            object
baz    datetime64[ns]
qux          category
Length: 4, dtype: object

In [4]: df.to_json('test.json', orient='table')

In [5]: new_df = pd.read_json('test.json', orient='table')

In [6]: new_df
Out[6]: 
     foo bar        baz qux
idx                        
0      1   a 2018-01-01   a
1      2   b 2018-01-02   b
2      3   c 2018-01-03   c
3      4   d 2018-01-04   c

[4 rows x 4 columns]

In [7]: new_df.dtypes
Out[7]: 
foo             int64
bar            object
baz    datetime64[ns]
qux          category
Length: 4, dtype: object

请注意，index往返格式不支持该字符串，因为默认情况下使用它write_json来指示丢失的索引名称。

In [8]: df.index.name = 'index'

In [9]: df.to_json('test.json', orient='table')

In [10]: new_df = pd.read_json('test.json', orient='table')

In [11]: new_df
Out[11]: 
   foo bar        baz qux
0    1   a 2018-01-01   a
1    2   b 2018-01-02   b
2    3   c 2018-01-03   c
3    4   d 2018-01-04   c

[4 rows x 4 columns]

In [12]: new_df.dtypes
Out[12]: 
foo             int64
bar            object
baz    datetime64[ns]
qux          category
Length: 4, dtype: object

方法.assign()接受依赖参数#

现在DataFrame.assign()接受高于 3.6 的 python 版本的依赖关键字参数（另请参阅PEP 468）。如果参数是可调用的，后面的关键字参数现在可以引用前面的关键字参数。请参阅 此处的文档( GH 14207 )

In [13]: df = pd.DataFrame({'A': [1, 2, 3]})

In [14]: df
Out[14]: 
   A
0  1
1  2
2  3

[3 rows x 1 columns]

In [15]: df.assign(B=df.A, C=lambda x: x['A'] + x['B'])
Out[15]: 
   A  B  C
0  1  1  2
1  2  2  4
2  3  3  6

[3 rows x 3 columns]

警告

.assign()当您用于更新现有列时，这可能会巧妙地改变代码的行为。以前，引用其他正在更新的变量的可调用对象将获得“旧”值

以前的行为：

In [2]: df = pd.DataFrame({"A": [1, 2, 3]})

In [3]: df.assign(A=lambda df: df.A + 1, C=lambda df: df.A * -1)
Out[3]:
   A  C
0  2 -1
1  3 -2
2  4 -3

新行为：

In [16]: df.assign(A=df.A + 1, C=lambda df: df.A * -1)
Out[16]: 
   A  C
0  2 -2
1  3 -3
2  4 -4

[3 rows x 2 columns]

合并列和索引级别的组合#

DataFrame.merge()作为on、left_on和参数传递的字符串right_on 现在可以引用列名称或索引级别名称。这使得可以DataFrame在索引级别和列的组合上合并实例，而无需重置索引。请参阅合并列和级别文档部分。 （GH 14355）

In [17]: left_index = pd.Index(['K0', 'K0', 'K1', 'K2'], name='key1')

In [18]: left = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
   ....:                      'B': ['B0', 'B1', 'B2', 'B3'],
   ....:                      'key2': ['K0', 'K1', 'K0', 'K1']},
   ....:                     index=left_index)
   ....: 

In [19]: right_index = pd.Index(['K0', 'K1', 'K2', 'K2'], name='key1')

In [20]: right = pd.DataFrame({'C': ['C0', 'C1', 'C2', 'C3'],
   ....:                       'D': ['D0', 'D1', 'D2', 'D3'],
   ....:                       'key2': ['K0', 'K0', 'K0', 'K1']},
   ....:                      index=right_index)
   ....: 

In [21]: left.merge(right, on=['key1', 'key2'])
Out[21]: 
       A   B key2   C   D
key1                     
K0    A0  B0   K0  C0  D0
K1    A2  B2   K0  C1  D1
K2    A3  B3   K1  C3  D3

[3 rows x 5 columns]

按列和索引级别的组合排序#

DataFrame.sort_values()作为参数传递的字符串by现在可以引用列名称或索引级别名称。这样可以 DataFrame通过索引级别和列的组合对实例进行排序，而无需重置索引。请参阅按索引和值排序文档部分。 （GH 14353）

# Build MultiIndex
In [22]: idx = pd.MultiIndex.from_tuples([('a', 1), ('a', 2), ('a', 2),
   ....:                                  ('b', 2), ('b', 1), ('b', 1)])
   ....: 

In [23]: idx.names = ['first', 'second']

# Build DataFrame
In [24]: df_multi = pd.DataFrame({'A': np.arange(6, 0, -1)},
   ....:                         index=idx)
   ....: 

In [25]: df_multi
Out[25]: 
              A
first second   
a     1       6
      2       5
      2       4
b     2       3
      1       2
      1       1

[6 rows x 1 columns]

# Sort by 'second' (index) and 'A' (column)
In [26]: df_multi.sort_values(by=['second', 'A'])
Out[26]: 
              A
first second   
b     1       1
      1       2
a     1       6
b     2       3
a     2       4
      2       5

[6 rows x 1 columns]

使用自定义类型扩展 pandas（实验）#

pandas 现在支持将不一定是一维 NumPy 数组的类数组对象存储为 DataFrame 中的列或 Series 中的值。这允许第三方库实现对 NumPy 类型的扩展，类似于 pandas 实现分类、带有时区、周期和间隔的日期时间的方式。

作为演示，我们将使用cyberpandas，它提供了一种IPArray用于存储 IP 地址的类型。

In [1]: from cyberpandas import IPArray

In [2]: values = IPArray([
   ...:     0,
   ...:     3232235777,
   ...:     42540766452641154071740215577757643572
   ...: ])
   ...:
   ...:

IPArray不是普通的一维 NumPy 数组，但因为它是 pandas ExtensionArray，所以它可以正确存储在 pandas 的容器内。

In [3]: ser = pd.Series(values)

In [4]: ser
Out[4]:
0                         0.0.0.0
1                     192.168.1.1
2    2001:db8:85a3::8a2e:370:7334
dtype: ip

请注意，数据类型是ip。尊重底层数组的缺失值语义：

In [5]: ser.isna()
Out[5]:
0     True
1    False
2    False
dtype: bool

有关更多信息，请参阅扩展类型 文档。如果你构建了扩展阵列，请在生态页面上进行公示。

用于排除#中未观察到的类别的新observed关键字GroupBy

按类别分组包括输出中未观察到的类别。当按多个分类列进行分组时，这意味着您将获得所有类别的笛卡尔积，包括没有观察值的组合，这可能会导致出现大量组。我们添加了一个关键字observed来控制此行为，它默认为 observed=False向后兼容。 （GH 14942、GH 8138、GH 15217、GH 17594、GH 8669、GH 20583、GH 20902）

In [27]: cat1 = pd.Categorical(["a", "a", "b", "b"],
   ....:                       categories=["a", "b", "z"], ordered=True)
   ....: 

In [28]: cat2 = pd.Categorical(["c", "d", "c", "d"],
   ....:                       categories=["c", "d", "y"], ordered=True)
   ....: 

In [29]: df = pd.DataFrame({"A": cat1, "B": cat2, "values": [1, 2, 3, 4]})

In [30]: df['C'] = ['foo', 'bar'] * 2

In [31]: df
Out[31]: 
   A  B  values    C
0  a  c       1  foo
1  a  d       2  bar
2  b  c       3  foo
3  b  d       4  bar

[4 rows x 4 columns]

要显示所有值，之前的行为：

In [32]: df.groupby(['A', 'B', 'C'], observed=False).count()
Out[32]: 
         values
A B C          
a c bar       0
    foo       1
  d bar       1
    foo       0
  y bar       0
...         ...
z c foo       0
  d bar       0
    foo       0
  y bar       0
    foo       0

[18 rows x 1 columns]

仅显示观测值：

In [33]: df.groupby(['A', 'B', 'C'], observed=True).count()
Out[33]: 
         values
A B C          
a c foo       1
  d bar       1
b c foo       1
  d bar       1

[4 rows x 1 columns]

对于旋转操作，此行为已由关键字控制dropna：

In [34]: cat1 = pd.Categorical(["a", "a", "b", "b"],
   ....:                       categories=["a", "b", "z"], ordered=True)
   ....: 

In [35]: cat2 = pd.Categorical(["c", "d", "c", "d"],
   ....:                       categories=["c", "d", "y"], ordered=True)
   ....: 

In [36]: df = pd.DataFrame({"A": cat1, "B": cat2, "values": [1, 2, 3, 4]})

In [37]: df
Out[37]: 
   A  B  values
0  a  c       1
1  a  d       2
2  b  c       3
3  b  d       4

[4 rows x 3 columns]

In [1]: pd.pivot_table(df, values='values', index=['A', 'B'], dropna=True)

Out[1]:
     values
A B
a c     1.0
  d     2.0
b c     3.0
  d     4.0

In [2]: pd.pivot_table(df, values='values', index=['A', 'B'], dropna=False)

Out[2]:
     values
A B
a c     1.0
  d     2.0
  y     NaN
b c     3.0
  d     4.0
  y     NaN
z c     NaN
  d     NaN
  y     NaN

Rolling/Expanding.apply() 接受raw=False将 a 传递Series给函数#

Series.rolling().apply()、DataFrame.rolling().apply()、 Series.expanding().apply()、DataFrame.expanding().apply()已获得一个raw=None参数。这类似于DataFame.apply().该参数允许向应用函数True发送数据。np.ndarray如果FalseaSeries会通过。默认值为None，它保留向后兼容性，因此默认为True，发送np.ndarray.在未来的版本中，默认设置将更改为False发送Series. （GH 5071，GH 20584）

In [38]: s = pd.Series(np.arange(5), np.arange(5) + 1)

In [39]: s
Out[39]: 
1    0
2    1
3    2
4    3
5    4
Length: 5, dtype: int64

通过Series：

In [40]: s.rolling(2, min_periods=1).apply(lambda x: x.iloc[-1], raw=False)
Out[40]: 
1    0.0
2    1.0
3    2.0
4    3.0
5    4.0
Length: 5, dtype: float64

模仿传递 ndarray 的原始行为：

In [41]: s.rolling(2, min_periods=1).apply(lambda x: x[-1], raw=True)
Out[41]: 
1    0.0
2    1.0
3    2.0
4    3.0
5    4.0
Length: 5, dtype: float64

DataFrame.interpolate已经获得了limit_areakwarg #

DataFrame.interpolate()获得了一个limit_area参数，可以进一步控制哪些NaNs 被替换。用于limit_area='inside'仅填充由有效值包围的 NaN，或用于limit_area='outside'仅填充NaN现有有效值之外的 s，同时保留内部有效值。 ( GH 16284 ) 请参阅此处的完整文档。

In [42]: ser = pd.Series([np.nan, np.nan, 5, np.nan, np.nan,
   ....:                  np.nan, 13, np.nan, np.nan])
   ....: 

In [43]: ser
Out[43]: 
0     NaN
1     NaN
2     5.0
3     NaN
4     NaN
5     NaN
6    13.0
7     NaN
8     NaN
Length: 9, dtype: float64

双向填充一个连续的内部值

In [44]: ser.interpolate(limit_direction='both', limit_area='inside', limit=1)
Out[44]: 
0     NaN
1     NaN
2     5.0
3     7.0
4     NaN
5    11.0
6    13.0
7     NaN
8     NaN
Length: 9, dtype: float64

向后填充所有连续的外部值

In [45]: ser.interpolate(limit_direction='backward', limit_area='outside')
Out[45]: 
0     5.0
1     5.0
2     5.0
3     NaN
4     NaN
5     NaN
6    13.0
7     NaN
8     NaN
Length: 9, dtype: float64

填充两个方向上所有连续的外部值

In [46]: ser.interpolate(limit_direction='both', limit_area='outside')
Out[46]: 
0     5.0
1     5.0
2     5.0
3     NaN
4     NaN
5     NaN
6    13.0
7    13.0
8    13.0
Length: 9, dtype: float64

函数get_dummies现在支持dtype参数#

nowget_dummies()接受一个dtype参数，该参数指定新列的数据类型。默认值仍为 uint8。 （GH 18330）

In [47]: df = pd.DataFrame({'a': [1, 2], 'b': [3, 4], 'c': [5, 6]})

In [48]: pd.get_dummies(df, columns=['c']).dtypes
Out[48]: 
a      int64
b      int64
c_5     bool
c_6     bool
Length: 4, dtype: object

In [49]: pd.get_dummies(df, columns=['c'], dtype=bool).dtypes
Out[49]: 
a      int64
b      int64
c_5     bool
c_6     bool
Length: 4, dtype: object

时间增量取模方法#

mod(%) 和操作现在在使用类似 timedelta 或数字参数的操作时divmod在对象上定义。Timedelta请参阅此处的文档。 （GH 19365）

In [50]: td = pd.Timedelta(hours=37)

In [51]: td % pd.Timedelta(minutes=45)
Out[51]: Timedelta('0 days 00:15:00')

方法.rank()处理存在的inf值#NaN

在以前的版本中，.rank()会将inf元素分配NaN为它们的等级。现在排名已正确计算。 （GH 6945）

In [52]: s = pd.Series([-np.inf, 0, 1, np.nan, np.inf])

In [53]: s
Out[53]: 
0   -inf
1    0.0
2    1.0
3    NaN
4    inf
Length: 5, dtype: float64

以前的行为：

In [11]: s.rank()
Out[11]:
0    1.0
1    2.0
2    3.0
3    NaN
4    NaN
dtype: float64

当前行为：

In [54]: s.rank()
Out[54]: 
0    1.0
1    2.0
2    3.0
3    NaN
4    4.0
Length: 5, dtype: float64

此外，以前如果您将inf或-inf值与值一起排名，则在使用“顶部”或“底部”参数时，NaN计算将无法区分无穷大。NaN

In [55]: s = pd.Series([np.nan, np.nan, -np.inf, -np.inf])

In [56]: s
Out[56]: 
0    NaN
1    NaN
2   -inf
3   -inf
Length: 4, dtype: float64

以前的行为：

In [15]: s.rank(na_option='top')
Out[15]:
0    2.5
1    2.5
2    2.5
3    2.5
dtype: float64

当前行为：

In [57]: s.rank(na_option='top')
Out[57]: 
0    1.5
1    1.5
2    3.5
3    3.5
Length: 4, dtype: float64

这些错误已被消除：

Series.str.cat已经获得了joinkwarg #

以前，Series.str.cat()与大多数相反pandas，Series在连接之前没有对齐索引（参见GH 18657）。该方法现在获得了一个关键字join来控制对齐方式，请参阅下面和此处的示例。

在 v.0.23 中将默认为 None （意味着不对齐），但此默认值将在 pandas 的未来版本中join更改为。'left'

In [58]: s = pd.Series(['a', 'b', 'c', 'd'])

In [59]: t = pd.Series(['b', 'd', 'e', 'c'], index=[1, 3, 4, 2])

In [60]: s.str.cat(t)
Out[60]: 
0    NaN
1     bb
2     cc
3     dd
Length: 4, dtype: object

In [61]: s.str.cat(t, join='left', na_rep='-')
Out[61]: 
0    a-
1    bb
2    cc
3    dd
Length: 4, dtype: object

此外，现在也Series.str.cat()适用（之前提出过；请参阅GH 20842）。CategoricalIndexValueError

DataFrame.astype执行按列转换为Categorical#

DataFrame.astype()Categorical现在可以通过提供字符串'category'或来执行按列转换CategoricalDtype。以前，尝试这样做会引发NotImplementedError.有关更多详细信息和示例，请参阅 文档的对象创建部分。 （GH 12860，GH 18099）

提供字符串'category'执行按列转换，只有标签作为类别出现在给定列集中：

In [62]: df = pd.DataFrame({'A': list('abca'), 'B': list('bccd')})

In [63]: df = df.astype('category')

In [64]: df['A'].dtype
Out[64]: CategoricalDtype(categories=['a', 'b', 'c'], ordered=False, categories_dtype=object)

In [65]: df['B'].dtype
Out[65]: CategoricalDtype(categories=['b', 'c', 'd'], ordered=False, categories_dtype=object)

提供 aCategoricalDtype将使每列中的类别与提供的 dtype 一致：

In [66]: from pandas.api.types import CategoricalDtype

In [67]: df = pd.DataFrame({'A': list('abca'), 'B': list('bccd')})

In [68]: cdt = CategoricalDtype(categories=list('abcd'), ordered=True)

In [69]: df = df.astype(cdt)

In [70]: df['A'].dtype
Out[70]: CategoricalDtype(categories=['a', 'b', 'c', 'd'], ordered=True, categories_dtype=object)

In [71]: df['B'].dtype
Out[71]: CategoricalDtype(categories=['a', 'b', 'c', 'd'], ordered=True, categories_dtype=object)

其他增强功能#

向后不兼容的 API 更改#

依赖项增加了最低版本#

我们更新了依赖项的最低支持版本 ( GH 15184 )。如果安装了，我们现在需要：

包裹

最低版本

必需的

问题

python-dateutil

2.5.0

X

GH 15184

开放式pyxl

2.4.0

GH 15184

美丽汤4

4.2.1

GH 20082

设置工具

24.2.0

GH 20698

从 dicts 实例化保留 Python 3.6+ 的 dict 插入顺序#

在 Python 3.6 之前，Python 中的字典没有正式定义的顺序。对于 Python 3.6 及更高版本，字典按插入顺序排序，请参阅 PEP 468。当您使用 Python 版本 3.6 或更高版本创建Series或 从字典创建时，pandas 将使用字典的插入顺序。 DataFrame（GH 19884）

以前的行为（以及当前行为，如果在 Python < 3.6 上）：

In [16]: pd.Series({'Income': 2000,
   ....:            'Expenses': -1500,
   ....:            'Taxes': -200,
   ....:            'Net result': 300})
Out[16]:
Expenses     -1500
Income        2000
Net result     300
Taxes         -200
dtype: int64

请注意，上面的系列是按索引值的字母顺序排序的。

新行为（对于 Python >= 3.6）：

In [72]: pd.Series({'Income': 2000,
   ....:            'Expenses': -1500,
   ....:            'Taxes': -200,
   ....:            'Net result': 300})
   ....: 
Out[72]: 
Income        2000
Expenses     -1500
Taxes         -200
Net result     300
Length: 4, dtype: int64

请注意，该系列现在按插入顺序排序。此新行为适用于所有相关的 pandas 类型（Series、DataFrame和SparseSeries ）SparseDataFrame。

如果您希望在使用 Python >= 3.6 时保留旧行为，您可以使用 .sort_index()：

In [73]: pd.Series({'Income': 2000,
   ....:            'Expenses': -1500,
   ....:            'Taxes': -200,
   ....:            'Net result': 300}).sort_index()
   ....: 
Out[73]: 
Expenses     -1500
Income        2000
Net result     300
Taxes         -200
Length: 4, dtype: int64

弃用面板#

Panel在 0.20.x 版本中已弃用，显示为DeprecationWarning.现在使用Panel将显示一个FutureWarning.表示 3D 数据的推荐方法是使用MultiIndex或使用DataFramexarray包。 pandas 提供了一种自动执行此转换的方法（GH 13563、GH 18324）。to_frame()to_xarray()

In [75]: import pandas._testing as tm

In [76]: p = tm.makePanel()

In [77]: p
Out[77]:
<class 'pandas.core.panel.Panel'>
Dimensions: 3 (items) x 3 (major_axis) x 4 (minor_axis)
Items axis: ItemA to ItemC
Major_axis axis: 2000-01-03 00:00:00 to 2000-01-05 00:00:00
Minor_axis axis: A to D

转换为多索引数据帧

In [78]: p.to_frame()
Out[78]:
                     ItemA     ItemB     ItemC
major      minor
2000-01-03 A      0.469112  0.721555  0.404705
           B     -1.135632  0.271860 -1.039268
           C      0.119209  0.276232 -1.344312
           D     -2.104569  0.113648 -0.109050
2000-01-04 A     -0.282863 -0.706771  0.577046
           B      1.212112 -0.424972 -0.370647
           C     -1.044236 -1.087401  0.844885
           D     -0.494929 -1.478427  1.643563
2000-01-05 A     -1.509059 -1.039575 -1.715002
           B     -0.173215  0.567020 -1.157892
           C     -0.861849 -0.673690  1.075770
           D      1.071804  0.524988 -1.469388

[12 rows x 3 columns]

转换为 xarray DataArray

In [79]: p.to_xarray()
Out[79]:
<xarray.DataArray (items: 3, major_axis: 3, minor_axis: 4)>
array([[[ 0.469112, -1.135632,  0.119209, -2.104569],
        [-0.282863,  1.212112, -1.044236, -0.494929],
        [-1.509059, -0.173215, -0.861849,  1.071804]],

       [[ 0.721555,  0.27186 ,  0.276232,  0.113648],
        [-0.706771, -0.424972, -1.087401, -1.478427],
        [-1.039575,  0.56702 , -0.67369 ,  0.524988]],

       [[ 0.404705, -1.039268, -1.344312, -0.10905 ],
        [ 0.577046, -0.370647,  0.844885,  1.643563],
        [-1.715002, -1.157892,  1.07577 , -1.469388]]])
Coordinates:
  * items       (items) object 'ItemA' 'ItemB' 'ItemC'
  * major_axis  (major_axis) datetime64[ns] 2000-01-03 2000-01-04 2000-01-05
  * minor_axis  (minor_axis) object 'A' 'B' 'C' 'D'

pandas.core.common 删除#

以下错误和警告消息已从pandas.core.common（GH 13634、GH 19769）中删除：

  • PerformanceWarning

  • UnsupportedFunctionCall

  • UnsortedIndexError

  • AbstractMethodError

这些可以从pandas.errors（自 0.19.0 起）导入。

进行更改以使输出DataFrame.apply一致#

DataFrame.apply()在应用返回类似列表的任意用户定义函数时不一致axis=1。一些错误和不一致问题得到了解决。如果应用的函数返回一个Series，那么pandas将返回一个DataFrame；否则将返回系列，这包括类似列表的情况（例如返回tuple或）（ GH 16353，GH 17437，GH 17970，GH 17348，GH 17892，GH 18573， GH 17602，GH 18775，GH 18901，GH 18919）。list

In [74]: df = pd.DataFrame(np.tile(np.arange(3), 6).reshape(6, -1) + 1,
   ....:                   columns=['A', 'B', 'C'])
   ....: 

In [75]: df
Out[75]: 
   A  B  C
0  1  2  3
1  1  2  3
2  1  2  3
3  1  2  3
4  1  2  3
5  1  2  3

[6 rows x 3 columns]

以前的行为：如果返回的形状恰好与原始列的长度匹配，则会返回DataFrame.如果返回形状不匹配，则Series返回带有列表的形状。

In [3]: df.apply(lambda x: [1, 2, 3], axis=1)
Out[3]:
   A  B  C
0  1  2  3
1  1  2  3
2  1  2  3
3  1  2  3
4  1  2  3
5  1  2  3

In [4]: df.apply(lambda x: [1, 2], axis=1)
Out[4]:
0    [1, 2]
1    [1, 2]
2    [1, 2]
3    [1, 2]
4    [1, 2]
5    [1, 2]
dtype: object

新行为：当应用的函数返回类似列表时，现在将始终返回Series.

In [76]: df.apply(lambda x: [1, 2, 3], axis=1)
Out[76]: 
0    [1, 2, 3]
1    [1, 2, 3]
2    [1, 2, 3]
3    [1, 2, 3]
4    [1, 2, 3]
5    [1, 2, 3]
Length: 6, dtype: object

In [77]: df.apply(lambda x: [1, 2], axis=1)
Out[77]: 
0    [1, 2]
1    [1, 2]
2    [1, 2]
3    [1, 2]
4    [1, 2]
5    [1, 2]
Length: 6, dtype: object

要扩展列，您可以使用result_type='expand'

In [78]: df.apply(lambda x: [1, 2, 3], axis=1, result_type='expand')
Out[78]: 
   0  1  2
0  1  2  3
1  1  2  3
2  1  2  3
3  1  2  3
4  1  2  3
5  1  2  3

[6 rows x 3 columns]

要在原始列中广播结果（正确长度的类似列表的旧行为），您可以使用result_type='broadcast'.形状必须与原始列相匹配。

In [79]: df.apply(lambda x: [1, 2, 3], axis=1, result_type='broadcast')
Out[79]: 
   A  B  C
0  1  2  3
1  1  2  3
2  1  2  3
3  1  2  3
4  1  2  3
5  1  2  3

[6 rows x 3 columns]

返回 aSeries允许控制确切的返回结构和列名称：

In [80]: df.apply(lambda x: pd.Series([1, 2, 3], index=['D', 'E', 'F']), axis=1)
Out[80]: 
   D  E  F
0  1  2  3
1  1  2  3
2  1  2  3
3  1  2  3
4  1  2  3
5  1  2  3

[6 rows x 3 columns]

连接将不再排序#

在 Pandas 的未来版本中，pandas.concat()当非串联轴尚未对齐时，将不再对其进行排序。当前的行为与以前的行为（排序）相同，但现在在sort未指定且非串联轴未对齐时发出警告（GH 4588）。

In [81]: df1 = pd.DataFrame({"a": [1, 2], "b": [1, 2]}, columns=['b', 'a'])

In [82]: df2 = pd.DataFrame({"a": [4, 5]})

In [83]: pd.concat([df1, df2])
Out[83]: 
     b  a
0  1.0  1
1  2.0  2
0  NaN  4
1  NaN  5

[4 rows x 2 columns]

要保持先前的行为（排序）并消除警告，请通过sort=True

In [84]: pd.concat([df1, df2], sort=True)
Out[84]: 
   a    b
0  1  1.0
1  2  2.0
0  4  NaN
1  5  NaN

[4 rows x 2 columns]

要接受未来的行为（不排序），请传递sort=False

请注意，此更改也适用于DataFrame.append()，它也收到了sort用于控制此行为的关键字。

构建更改#

  • 现在需要构建熊猫以进行开发（GH 18613）cython >= 0.24

  • 现在从源代码构建明确要求setuptools（setup.pyGH 18113）

  • 更新了 conda 配方以符合 conda-build 3.0+ ( GH 18002 )

索引除以零正确填充#

和 子类的除法运算Index现在将使用 和 来填充正数除以零np.inf，负数-np.inf除以零。这符合现有的行为。 （GH 19322，GH 19347）0 / 0np.nanSeries

以前的行为：

In [6]: index = pd.Int64Index([-1, 0, 1])

In [7]: index / 0
Out[7]: Int64Index([0, 0, 0], dtype='int64')

# Previous behavior yielded different results depending on the type of zero in the divisor
In [8]: index / 0.0
Out[8]: Float64Index([-inf, nan, inf], dtype='float64')

In [9]: index = pd.UInt64Index([0, 1])

In [10]: index / np.array([0, 0], dtype=np.uint64)
Out[10]: UInt64Index([0, 0], dtype='uint64')

In [11]: pd.RangeIndex(1, 5) / 0
ZeroDivisionError: integer division or modulo by zero

当前行为：

In [12]: index = pd.Int64Index([-1, 0, 1])
# division by zero gives -infinity where negative,
# +infinity where positive, and NaN for 0 / 0
In [13]: index / 0

# The result of division by zero should not depend on
# whether the zero is int or float
In [14]: index / 0.0

In [15]: index = pd.UInt64Index([0, 1])
In [16]: index / np.array([0, 0], dtype=np.uint64)

In [17]: pd.RangeIndex(1, 5) / 0

从字符串中提取匹配模式#

默认情况下，如果提取的是单个组，则从字符串中提取匹配模式str.extract()会返回 a （如果提取了多个组，则返回 a）。从 pandas 0.23.0 开始，除非 设置为，否则始终返回 a 。最后，是参数的可接受值（相当于），但现在引发。 （GH 11386）SeriesDataFramestr.extract()DataFrameexpandFalseNoneexpandFalseValueError

以前的行为：

In [1]: s = pd.Series(['number 10', '12 eggs'])

In [2]: extracted = s.str.extract(r'.*(\d\d).*')

In [3]: extracted
Out [3]:
0    10
1    12
dtype: object

In [4]: type(extracted)
Out [4]:
pandas.core.series.Series

新行为：

In [85]: s = pd.Series(['number 10', '12 eggs'])

In [86]: extracted = s.str.extract(r'.*(\d\d).*')

In [87]: extracted
Out[87]: 
    0
0  10
1  12

[2 rows x 1 columns]

In [88]: type(extracted)
Out[88]: pandas.core.frame.DataFrame

要恢复以前的行为，只需设置expand为False：

In [89]: s = pd.Series(['number 10', '12 eggs'])

In [90]: extracted = s.str.extract(r'.*(\d\d).*', expand=False)

In [91]: extracted
Out[91]: 
0    10
1    12
Length: 2, dtype: object

In [92]: type(extracted)
Out[92]: pandas.core.series.Series

#ordered参数的默认值CategoricalDtype

ordered参数的默认值CategoricalDtype已从 更改为 ，False以None允许更新categories而不影响ordered。下游对象的行为应保持一致，例如Categorical（GH 18790）

ordered在以前的版本中，该参数的默认值为False。如果未明确指定，这可能会导致当用户尝试更新时ordered参数无意中从 更改为True，因为它会默默地默认为。的新行为是保留 的现有值。FalsecategoriesorderedFalseordered=Noneordered

新行为：

In [2]: from pandas.api.types import CategoricalDtype

In [3]: cat = pd.Categorical(list('abcaba'), ordered=True, categories=list('cba'))

In [4]: cat
Out[4]:
[a, b, c, a, b, a]
Categories (3, object): [c < b < a]

In [5]: cdt = CategoricalDtype(categories=list('cbad'))

In [6]: cat.astype(cdt)
Out[6]:
[a, b, c, a, b, a]
Categories (4, object): [c < b < a < d]

请注意，在上面的示例中，转换后的内容Categorical已保留ordered=True。如果 的默认值ordered保留为False，则转换后的值Categorical将变得无序，尽管ordered=False从未明确指定。要更改 的值ordered，请将其显式传递给新的数据类型，例如。CategoricalDtype(categories=list('cbad'), ordered=False)

请注意，上述讨论的无意转换ordered在以前的版本中并未出现，因为存在阻止astype执行任何类型的类别到类别转换的单独错误（GH 10696、GH 18593）。这些错误已在此版本中修复，并促使更改 的默认值ordered。

在终端中更好地打印数据帧#

以前，最大列数的默认值为 pd.options.display.max_columns=20。这意味着相对较宽的数据框不适合终端宽度，pandas 会引入换行符来显示这 20 列。这导致输出相对难以阅读：

../_images/print_df_old.png

如果 Python 在终端中运行，则现在会自动确定最大列数，以便打印的数据框适合当前终端宽度 ( pd.options.display.max_columns=0) ( GH 17023 )。如果 Python 作为 Jupyter 内核（例如 Jupyter QtConsole 或 Jupyter Notebook，以及许多 IDE）运行，则无法自动推断该值，因此设置为20与以前版本相同的值。在终端中，这会产生更好的输出：

../_images/print_df_new.png

请注意，如果您不喜欢新的默认值，您可以随时自行设置此选项。要恢复到旧设置，您可以运行以下行：

pd.options.display.max_columns = 20

Datetimelike API 更改#

  • 默认Timedelta构造函数现在接受字符串作为参数（GH 19040）ISO 8601 Duration

  • NaT从Serieswith中减godtype='datetime64[ns]'返回Serieswithdtype='timedelta64[ns]'而不是dtype='datetime64[ns]'( GH 18808 )

  • NaTfrom的加法或减法TimedeltaIndex将返回TimedeltaIndex而不是DatetimeIndex( GH 19124 )

  • DatetimeIndex.shift()当索引对象频率为（GH 19147）时，现在TimedeltaIndex.shift()将引发NullFrequencyError（其子类ValueError，在旧版本中引发）None

  • NaNaSeries的加法和减法dtype='timedelta64[ns]'将产生 aTypeError而不是将NaNas处理NaT（GH 19274）

  • NaT现在，除法datetime.timedelta将返回NaN而不是加注（GH 17876）

  • Seriesa with dtypedtype='datetime64[ns]'和 a之间的操作PeriodIndex将正确引发TypeError（GH 18850）

  • Series与时区感知不匹配的时区相dtype='datetime64[ns]'减将引发TypeError而不是ValueError（GH 18817）

  • Timestamp将不再默默地忽略未使用的或无效的tz或tzinfo关键字参数（GH 17690）

  • Timestamp将不再默默地忽略无效freq参数（GH 5168）

  • CacheableOffset并且WeekDay在模块中不再可用pandas.tseries.offsets（GH 17830）

  • pandas.tseries.frequencies.get_freq_group()并pandas.tseries.frequencies.DAYS从公共 API 中删除（GH 18034）

  • Series.truncate()如果索引未排序，则会引发 a 而不是无用的DataFrame.truncate()（GH 17935）ValueErrorKeyError

  • Series.first现在DataFrame.first将引发 aTypeError 而不是NotImplementedError当索引不是 a DatetimeIndex( GH 20725 ) 时。

  • Series.last现在DataFrame.last将引发 aTypeError 而不是NotImplementedError当索引不是 a DatetimeIndex( GH 20725 ) 时。

  • 受限制的DateOffset关键字参数。以前，DateOffset子类允许任意关键字参数，这可能会导致意外行为。现在，只接受有效的论据。 （GH 17176，GH 18226）。

  • pandas.merge()尝试合并时区感知列和时区朴素列时提供信息更丰富的错误消息（GH 15800）

  • 对于DatetimeIndex和TimedeltaIndexwith freq=None，整数类型数组的加法或减法 orIndex将引发NullFrequencyError而不是TypeError( GH 19895 )

  • Timestamp构造函数现在接受nanosecond关键字或位置参数（GH 18898）

  • DatetimeIndex现在在实例化后设置属性AttributeError时会引发 an ( GH 3746 )tz

  • DatetimeIndex具有pytz时区的现在将返回一致的pytz时区（GH 18595）

其他 API 更改#

  • Series.astype()并且Index.astype()使用不兼容的 dtype 现在将引发 aTypeError而不是ValueError( GH 18231 )

  • Seriesobject使用dtyped tz 感知日期时间并指定的构造dtype=object现在将返回 dtyped object，Series以前这将推断日期时间 dtype ( GH 18231 )

  • 从空构造的Seriesof现在将具有类别 而不是，与传递空列表的情况一致（GH 18515）dtype=categorydictdtype=objectdtype=float64

  • MultiIndex现在分配a 中的所有 NaN 级别float而不是dtype，从而促进与( GH 17929object )的一致性。Index

  • a 的级别名称MultiIndex（当不是 None 时）现在要求是唯一的：尝试创建MultiIndex具有重复名称的 a 将引发 a ValueError( GH 18872 )

  • 不可散列的Index/的构造和重命名现在都会引发( GH 20527 )MultiIndexnamenamesTypeError

  • Index.map()现在可以接受Series字典输入对象（GH 12756、GH 18482、GH 18509）。

  • DataFrame.unstack()现在将默认填充np.nanforobject列。 （GH 12815）

  • IntervalIndexclosed如果参数与推断输入数据的关闭方式冲突，构造函数将引发（ GH 18421）

  • 将缺失值插入索引适用于所有类型的索引，并自动插入正确类型的缺失值（NaN、NaT等），无论传入的类型如何（GH 18295）

  • 当使用重复标签创建时，MultiIndex现在会引发ValueError. （GH 17464）

  • Series.fillna()现在，当将列表、元组或 DataFrame 作为 a 传递时，会引发 aTypeError而不是 a ( GH 18293 )ValueErrorvalue

  • pandas.DataFrame.merge()合并列时不再投射float列（GH 16572）objectintfloat

  • pandas.merge()现在ValueError尝试合并不兼容的数据类型时会引发一个问题（GH 9780）

  • 默认 NA 值UInt64Index已从 0 更改为NaN，这会影响使用 NA 进行掩码的方法，例如UInt64Index.where()( GH 18398 )

  • 重构setup.py为使用find_packages而不是显式列出所有子包（GH 18535）

  • 重新排列关键字参数的顺序以read_excel()与read_csv()（GH 16672）对齐

  • wide_to_long()以前将类似数字的后缀保留为objectdtype。现在，如果可能的话，它们会被转换为数字（GH 17627）

  • 在 中read_excel()，comment参数现在作为命名参数公开（GH 18735）

  • 重新排列关键字参数的顺序以read_excel()与read_csv()（GH 16672）对齐

  • 选项html.border和mode.use_inf_as_null在之前的版本中已弃用，现在将显示这些选项FutureWarning而不是DeprecationWarning( GH 19003 )

  • IntervalIndex并且IntervalDtype不再支持分类、对象和字符串子类型（GH 19016）

  • IntervalDtype现在无论子类型True如何都返回'interval'，并且无论子类型如何都IntervalDtype.name返回（ GH 18980）'interval'

  • KeyError现在，当在具有重复项的轴中放置不存在的元素时，会引发而不是ValueErrorin drop(), drop(), drop(), ( GH 19186 )drop()

  • Series.to_csv()现在接受一个compression参数，其工作方式与（GH 18958）compression中的参数相同DataFrame.to_csv()

  • 具有不兼容索引类型的集合操作（​​并集、差异...）IntervalIndex现在将引发 aTypeError而不是 a ValueError( GH 19329 )

  • DateOffset对象渲染更简单，例如代替（GH 19403）<DateOffset: days=1><DateOffset: kwds={'days': 1}>

  • Categorical.fillna现在验证它的value和method关键字参数。现在，当指定两者或均未指定时，它会引发，与Series.fillna()（GH 19682）的行为相匹配

  • pd.to_datetime('today')现在返回一个日期时间，与pd.Timestamp('today');一致之前pd.to_datetime('today')返回了一个.normalized()日期时间（GH 19935）

  • Series.str.replace()现在采用一个可选regex关键字，当设置为 时False，使用文字字符串替换而不是正则表达式替换（GH 16808）

  • DatetimeIndex.strftime()现在PeriodIndex.strftime()返回一个Index而不是 numpy 数组以与类似的访问器保持一致（GH 20127）

  • 当指定更长的索引时（GH 19714、GH 20391），从长度为 1 的列表构造 Series 不再广播该列表。

  • DataFrame.to_dict()orient='index'对于仅具有 int 和 float 列的 DataFrame，不再将 int 列转换为 float ( GH 18580 )

  • 传递给Series.rolling().aggregate(),DataFrame.rolling().aggregate()或其扩展表兄弟的用户定义函数现在将始终传递 a Series，而不是np.array;.apply()只有关键字raw，请参见此处。这与.aggregate()跨pandas的签名一致（ GH 20584）

  • 滚动和扩展类型NotImplementedError在迭代时引发（GH 11704）。

弃用#

  • Series.from_array并SparseSeries.from_array已弃用。使用普通的构造函数Series(..)代替SparseSeries(..)（GH 18213）。

  • DataFrame.as_matrix已弃用。请改用DataFrame.values（GH 18458）。

  • Series.asobject、DatetimeIndex.asobject、PeriodIndex.asobject和TimeDeltaIndex.asobject已被弃用。使用.astype(object)替代（GH 18572）

  • 按键元组分组现在会发出 aFutureWarning并且已弃用。将来，传递给的元组'by'将始终引用作为实际元组的单个键，而不是将元组视为多个键。要保留以前的行为，请使用列表而不是元组（GH 18314）

  • Series.valid已弃用。请改用Series.dropna()（GH 18800）。

  • read_excel()已弃用该skip_footer参数。使用skipfooter（GH 18836）

  • ExcelFile.parse()sheetname为了sheet_name与read_excel()（GH 20920 ）保持一致，已弃用。

  • 该is_copy属性已弃用，并将在未来版本中删除 ( GH 18801 )。

  • IntervalIndex.from_intervals已弃用，有利于IntervalIndex构造函数（GH 19263）

  • DataFrame.from_items已弃用。请改为使用DataFrame.from_dict()，或者DataFrame.from_dict(OrderedDict())如果您希望保留密钥顺序（GH 17320、GH 17312）

  • 使用包含某些缺失键的列表对 aMultiIndex或 a进行索引现在将显示 a ，这与其他类型的索引（GH 17758）一致。FloatIndexFutureWarning

  • 参数broadcast已.apply()弃用，取而代之的是result_type='broadcast'( GH 18577 )

  • 参数reduce已.apply()弃用，取而代之的是result_type='reduce'( GH 18577 )

  • 参数order已factorize()弃用，并将在未来版本中删除 ( GH 19727 )

  • Timestamp.weekday_name、DatetimeIndex.weekday_name和Series.dt.weekday_name已弃用，取而代之的是Timestamp.day_name()、DatetimeIndex.day_name()和Series.dt.day_name()( GH 12806 )

  • pandas.tseries.plotting.tsplot已弃用。使用Series.plot()（GH 18627）

  • Index.summary()已弃用并将在未来版本中删除（GH 18217）

  • NDFrame.get_ftype_counts()已弃用并将在未来版本中删除（GH 18243）

  • convert_datetime64中的参数已DataFrame.to_records()被弃用，并将在未来版本中删除。引发此参数的 NumPy 错误已得到解决。此参数的默认值也从 更改为True( NoneGH 18160 )。

  • Series.rolling().apply()、DataFrame.rolling().apply()、Series.expanding().apply()和DataFrame.expanding().apply()已弃用np.array默认传递 an 。人们需要传递新raw参数以明确传递的内容（GH 20584）

  • 和类的data、base、strides和属性已被弃用flags，并将在未来版本中删除 ( GH 20419 )。itemsizeSeriesIndex

  • DatetimeIndex.offset已弃用。使用DatetimeIndex.freq替代（GH 20716）

  • Timedelta不推荐使用整数 ndarray 和 a 之间的向下除法。除以Timedelta.value( GH 19761 )

  • 设置PeriodIndex.freq（不能保证正常工作）已被弃用。使用PeriodIndex.asfreq()替代（GH 20678）

  • Index.get_duplicates()已弃用并将在未来版本中删除（GH 20239）

  • 以前的负索引默认行为Categorical.take已被弃用。在未来的版本中，它将从含义缺失值更改为含义右侧的位置索引。未来的行为与Series.take()（GH 20664 ）一致。

  • 将多个轴传递给axis参数 inDataFrame.dropna()已被弃用，并将在未来版本中删除（GH 20987）

删除先前版本的弃用/更改#

  • 针对过时用法的警告（例如当前两个参数具有不同的 dtypes 时发出的警告，并建议使用）现已被删除（GH 8074）Categorical(codes, categories)Categorical()Categorical.from_codes

  • a 的levels和属性不再可以直接设置（GH 4039）。labelsMultiIndex

  • pd.tseries.util.pivot_annual已被删除（自 v0.19 起已弃用）。使用pivot_table替代（GH 18370）

  • pd.tseries.util.isleapyear已被删除（自 v0.19 起已弃用）。使用.is_leap_yearDatetime-likes 中的属性来代替（GH 18370）

  • pd.ordered_merge已被删除（自 v0.19 起已弃用）。使用pd.merge_ordered（GH 18459）

  • 该类SparseList已被删除（GH 14007）

  • 和pandas.io.wb存根pandas.io.data模块已被删除（GH 13735）

  • Categorical.from_array已被删除（GH 13854）

  • freq和参数how已从DataFrame 和 Series 的rolling//方法expanding中删除（自 v0.18 起已弃用）。ewm相反，在调用方法之前重新采样。 （GH 18601和GH 18668）

  • DatetimeIndex.to_datetime、Timestamp.to_datetime、PeriodIndex.to_datetime、 和Index.to_datetime已被删除（GH 8254、GH 14096、GH 14113）

  • read_csv()已删除skip_footer参数（GH 13386）

  • read_csv()已删除as_recarray参数（GH 13373）

  • read_csv()已删除buffer_lines参数（GH 13360）

  • read_csv()已删除compact_ints和use_unsigned参数（GH 13323）

  • 该Timestamp班级已放弃该offset属性以支持freq（GH 13593）

  • Series、Categorical和类Index已删除该reshape方法（GH 13012）

  • pandas.tseries.frequencies.get_standard_freq已被删除，取而代之的是pandas.tseries.frequencies.to_offset(freq).rule_code（GH 13874）

  • 该freqstr关键字已被删除，pandas.tseries.frequencies.to_offset以支持freq( GH 13874 )

  • 和Panel4D类PanelND已被删除（GH 13776）

  • 该类Panel已删除to_long和toLong方法（GH 19077）

  • 选项display.line_with和display.height被删除，分别支持display.width和display.max_rows（GH 4391，GH 19107）

  • labels该类的属性已Categorical被删除，以支持Categorical.codes( GH 7768 )

  • 该flavor参数已从to_sql()方法中删除（GH 13611）

  • 模块pandas.tools.hashing和pandas.util.hashing已被删除（GH 16223）

  • 顶级函数pd.rolling_*,pd.expanding_*和pd.ewm*已被删除（自 v0.18 起已弃用）。相反，使用 DataFrame/Series 方法rolling，expanding以及ewm（GH 18723）

  • 来自pandas.core.commonfor 函数的导入is_datetime64_dtype现在已被删除。这些位于pandas.api.types. （GH 13634，GH 19769）

  • 和infer_dst中的关键字 已被删除。相当于 、 和( GH 7963 )。Series.tz_localize()DatetimeIndex.tz_localize()DatetimeIndexinfer_dst=Trueambiguous='infer'infer_dst=Falseambiguous='raise'

  • 当.resample()从急切操作更改为惰性操作（如.groupby()v0.18.0 中）时，我们放置了兼容性（使用 a FutureWarning），因此操作将继续工作。现在已完全删除，因此 aResampler将不再转发兼容操作（GH 20554）

  • 从( GH 20271 )中删除长期不推荐使用的axis=None参数.replace()

性能改进#

  • 索引器打开Series或DataFrame不再创建引用循环（GH 17956）

  • 添加了关键字参数 ，cache以to_datetime()提高转换重复日期时间参数的性能（GH 11665）

  • DateOffset算术性能得到提高（GH 18218）

  • Series将对象转换Timedelta为天、秒等……通过底层方法的矢量化加速（GH 18092）

  • .map()改进了输入的性能Series/dict（GH 15081）

  • 天、秒和微秒的重写Timedelta属性已被删除，而是利用其内置的 Python 版本（GH 18242）

  • Series在某些情况下，构造将减少输入数据的副本数量（GH 17449）

  • Series.dt.date()改进了和DatetimeIndex.date()( GH 18058 )的性能

  • Series.dt.time()改进了和DatetimeIndex.time()( GH 18461 )的性能

  • 改进的性能IntervalIndex.symmetric_difference()( GH 18475 )

  • 改进了业务月和业务季度频率的算术运算DatetimeIndex性能（GH 18489）Series

  • Series()/ DataFrame()tab 完成限制为 100 个值，以获得更好的性能。 （GH 18587）

  • 改进了未安装瓶颈时DataFrame.median()的性能（ GH 16468）axis=1

  • 提高了大型索引的性能MultiIndex.get_loc()，但代价是降低了小型索引的性能（GH 18519）

  • MultiIndex.remove_unused_levels()当没有未使用的级别时提高性能，但代价是存在时性能下降（ GH 19289）

  • Index.get_loc()改进了非唯一索引的性能（ GH 19478）

  • .rolling()改进了成对和.expanding()with.cov()和运算的性能.corr()( GH 17917 )

  • 改进的性能GroupBy.rank()( GH 15779 )

  • 改进了和.rolling()上变量的性能（GH 19521）.min().max()

  • GroupBy.ffill()改进了和GroupBy.bfill()( GH 11296 )的性能

  • GroupBy.any()改进了和GroupBy.all()( GH 15435 )的性能

  • GroupBy.pct_change()改进了( GH 19165 )的性能

  • Series.isin()改进了分类数据类型的性能（ GH 20003）

  • 改进了系列具有某些索引类型时的性能。这体现在带有( GH 19764 )的大型系列的打印速度较慢getattr(Series, attr)DatetimeIndex

  • 修复了某些对象列的性能回归GroupBy.nth()（GroupBy.last()GH 19283）

  • 改进的性能Categorical.from_codes()( GH 18501 )

文档更改#

感谢所有参与 3 月 10 日举行的 pandas 文档冲刺的贡献者。我们有来自全球 30 多个地点的约 500 名参与者。您应该注意到许多 API 文档字符串已经有了很大的改进。

同时做出的贡献太多，无法包含每个改进的发行说明，但此GitHub 搜索应该可以让您了解改进了多少文档字符串。

特别感谢Marc Garcia组织了这次冲刺。有关更多信息，请阅读NumFOCUS 博客文章，回顾冲刺。

  • 将“numpy”的拼写更改为“NumPy”，将“python”更改为“Python”。 （GH 19017）

  • 使用冒号或句点引入代码示例时保持一致性。重写了一些句子以使其更加清晰，添加了对函数、方法和类的更多动态引用。 （GH 18941、GH 18948、GH 18973、GH 19017）

  • DataFrame.assign()在合并文档的串联部分添加了参考( GH 18665 )

Bug修复＃

分类#

警告

pandas 0.21 中引入了一类错误，在比较具有相同类别但顺序不同的多个无序数组时，会影响、和索引等CategoricalDtype操作的正确性。我们强烈建议在执行这些操作之前升级或手动调整您的类别。mergeconcatCategorical

  • 比较两个具有相同类别但顺序不同的Categorical.equals无序数组时返回错误结果的错误（ GH 16603）Categorical

  • pandas.api.types.union_categoricals()对于类别顺序不同的无序分类时，返回错误结果的错误。这会影响pandas.concat()分类数据（GH 19096）。

  • 加入具有相同类别但顺序不同的pandas.merge()无序对象时返回错误结果的错误（ GH 19551）Categorical

  • 当无序对象具有相同类别 但顺序不同时，CategoricalIndex.get_indexer()返回错误结果的 错误（ GH 19551）targetCategoricalself

  • 分类数据类型存在错误Index.astype()，其中结果索引未转换为CategoricalIndex所有类型索引的 a ( GH 18630 )

  • 现有分类数据未更新的错误（Series.astype()GH 10696 、 GH 18593）Categorical.astype()

  • Series.str.split()错误地expand=True在空字符串上引发 IndexError ( GH 20002 )。

  • Index构造函数中的错误dtype=CategoricalDtype(...)wherecategories和ordered未维护（GH 19032）

  • Series带有标量的构造函数中的错误以及未维护的位置和dtype=CategoricalDtype(...)位置（ GH 19565）categoriesordered

  • 未转换为 Python 类型的错误Categorical.__iter__（GH 19909）

  • pandas.factorize()返回 的唯一代码时出现错误uniques。现在返回Categorical与输入具有相同数据类型的 ( GH 19721 )

  • pandas.factorize()在返回值中包含缺失值的项目时出现错误uniques（GH 19721）

  • 错误将Series.take()分类数据解释-1为indices缺失值标记，而不是系列的最后一个元素（GH 20664）

类似日期时间#

时间增量#

  • Timedelta.__mul__()乘以NaT返回NaT而不是提高 a 的错误TypeError（GH 19819）

  • 错误在于Series将结果dtype='timedelta64[ns]'进行加法或减法转换为（GH 17250）TimedeltaIndexdtype='int64'

  • 错误之处Series在于dtype='timedelta64[ns]'，加法或减法TimedeltaIndex可能会返回Series名称不正确的 a ( GH 19043 )

  • 错误地允许错误地插入Timedelta.__floordiv__()和除以许多不兼容的 numpy 对象（ GH 18846）Timedelta.__rfloordiv__()

  • 将类似时间增量的标量对象除以TimedeltaIndex执行倒数运算的错误（GH 19125）

  • 除以TimedeltaIndexaSeries会返回 a而不是 a 的错误（GH 19042）TimedeltaIndexSeries

  • 错误Timedelta.__add__()，Timedelta.__sub__()添加或减go一个np.timedelta64对象将返回另一个对象np.timedelta64而不是Timedelta( GH 19738 )

  • 错误Timedelta.__floordiv__()，Timedelta.__rfloordiv__()对Tick对象进行操作会引发 aTypeError而不是返回数值（GH 19738）

  • Period.asfreq()附近的周期可能被错误转换的错误（GH 19643，GH 19834）datetime(1, 1, 1)

  • Timedelta.total_seconds()例如，导致精度错误的错误Timedelta('30S').total_seconds()==30.000000000000004（GH 19458）

  • Timedelta.__rmod__()使用numpy.timedelta64返回的timedelta64对象而不是Timedelta( GH 19820 )进行操作的错误

  • 在长度不匹配的情况下，TimedeltaIndex乘法现在TimedeltaIndex将提高TypeError而不是提高（ GH 19333）ValueError

  • TimedeltaIndex使用np.timedelta64引发a 的对象对 a 进行索引时出现错误TypeError（GH 20393）

时区＃

  • 从包含 tz-naive 和 tz-aware 值的数组创建 a 时出现的错误Series将导致Seriesdtype 为 tz-aware 而不是 object ( GH 16406 )

  • 时区感知DatetimeIndex与NaT错误提升的比较中的错误TypeError（GH 19276）

  • DatetimeIndex.astype()在时区感知数据类型之间转换以及从时区感知转换为天真的时出现错误（ GH 18951）

  • 比较中的错误，在尝试比较时区感知和时区幼稚的 datetimelike 对象时DatetimeIndex失败（ GH 18162）TypeError

  • Series具有 dtype 的构造函数中的原始日期时间字符串本地化错误( GH 174151 )datetime64[ns, tz]

  • Timestamp.replace()现在将优雅地处理夏令时转换（GH 18319）

  • tz-aware 中的错误DatetimeIndex，其中 aTimedeltaIndex或数组的加法/减法dtype='timedelta64[ns]'不正确（GH 17558）

  • DatetimeIndex.insert()插入NaT时区感知索引时错误引发的错误（ GH 16357）

  • 构造函数中的错误DataFrame，其中 tz 感知的 Datetimeindex 和给定的列名将导致空DataFrame（GH 19157）

  • Timestamp.tz_localize()将时间戳本地化到最小或最大有效值附近可能会溢出并返回具有不正确纳秒值的时间戳的错误( GH 12677 )

  • 迭代时出现错误DatetimeIndex，该错误使用固定时区偏移进行本地化，将纳秒精度四舍五入为微秒（GH 19603）

  • DataFrame.diff()引发IndexErrortz 感知值的错误( GH 18578 )

  • melt()将 tz-aware dtypes 转换为 tz-naive 的错误（ GH 15785）

  • 如果为具有时区感知值的单个列调用，则Dataframe.count()引发了一个错误。 （GH 13407）ValueErrorDataframe.dropna()

偏移量#

  • WeekOfMonth加法和Week减法无法正确滚动的错误（ GH 18510、GH 18672、GH 18864）

  • WeekOfMonth引发LastWeekOfMonth构造函数默认关键字参数的错误ValueError（GH 19142）

  • 错误FY5253Quarter，LastWeekOfMonth其中回滚和前滚行为与加法和减法行为不一致（GH 18854）

  • 年末日期的加法和减法增量错误但未标准化为午夜的错误FY5253（GH 18854）datetime

  • FY5253日期偏移量可能错误地引发AssertionError算术运算中的错误（ GH 14774）

数字#

  • Series具有 int 或 float 列表的构造函数中的错误dtype=str，其中指定dtype='str'或dtype='U'无法将数据元素转换为字符串（GH 16605）

  • Index乘法和除法方法中的错误，其中使用 a 进行操作Series将返回Index对象而不是对象Series（GH 19042）

  • 构造函数中的错误DataFrame导致数据包含非常大的正数或非常大的负数OverflowError（GH 18584）

  • Index构造函数中的错误，dtype='uint64'其中类似 int 的浮点数未被强制转换为UInt64Index（GH 18400）

  • DataFrame弯曲算术中的错误（例如），在框架或长度为零的极端情况下未能引发（ GH 19522）df.add(other, fill_value=foo)fill_valueNoneNotImplementedErrorother

  • Index具有类似 timedelta 的标量的数字类型对象的乘法和除法返回TimedeltaIndex而不是提升TypeError（GH 19333）

  • Bug，其中NaN返回而不是 0 Series.pct_change()，而DataFrame.pct_change()何时fill_method不是None（GH 19873）

字符串#

索引#

多重索引#

IO #

绘图#

  • 尝试绘图但未安装 matplotlib 时出现更好的错误消息（GH 19810）。

  • DataFrame.plot()ValueError现在当xory参数形成不正确时会引发 a ( GH 18671 )

  • DataFrame.plot()作为位置给出的时间x和参数中的错误y导致线图、条形图和面积图的引用列不正确（GH 20056）

  • 使用秒和小数部分格式化刻度标签时出现错误datetime.time()（GH 18478）。

  • Series.plot.kde()已在文档字符串（GH 18461 ）中公开了 argsind和。该参数现在也可以是整数（样本点的数量）。bw_methodind

  • DataFrame.plot()现在支持多列参数y（GH 19699）

GroupBy/重新采样/滚动#

稀疏#

  • SparseDataFrame从密集Series或不受支持的类型创建引发不受控制的异常的错误（ GH 19374）

  • 导致异常的错误SparseDataFrame.to_csv（GH 19384）

  • SparseSeries.memory_usage通过访问非稀疏元素导致段错误的错误（ GH 19368）

  • 构造 时的错误SparseArray：如果data是标量并且已定义，则无论标量的数据类型如何，index它都将强制执行。 float64（GH 19163）

重塑#

其他＃

贡献者#

共有 328 人为此版本贡献了补丁。名字带有“+”的人首次贡献了补丁。

  • 亚伦·克里奇利

  • 阿卜杜阿里JK +

  • 亚当·胡珀 +

  • 阿尔伯特·维拉诺瓦·德尔·莫拉尔

  • 亚历杭德罗·贾科梅蒂 +

  • 亚历杭德罗·霍曼 +

  • 亚历克斯·瑞奇克

  • 亚历山大·布赫科夫斯基

  • 亚历山大·莱内尔 +

  • 亚历山大·迈克尔·沙德

  • 阿里·西夫吉 +

  • 安德烈亚斯·科尔特林格 +

  • 安德鲁

  • 安德鲁·布伊 +

  • 安德拉斯·诺沃萨特 +

  • 安迪·疯狂+

  • 安迪·R·特雷尔

  • 英乐+

  • 阿尼尔·库马尔·帕莱孔达 +

  • 安托万·皮特鲁 +

  • 安东尼奥·林德 +

  • 安东尼奥·莫利纳 +

  • 安东尼奥·奎诺内斯 +

  • 阿明·瓦尔绍卡 +

  • 阿乔姆·博加乔夫 +

  • 阿维森+

  • 阿齐兹·奥鲁瓦费米 +

  • 本·奥法斯 +

  • 伯恩哈德·蒂尔 +

  • 巴韦什·波达 +

  • 比尔史特拉 +

  • 布莱尔+

  • 鲍勃·哈夫纳

  • 布雷特·瑙尔+

  • 布洛克·孟德尔

  • 布莱斯·金塔 +

  • 卡洛斯·爱德华多·莫雷拉·多斯桑托斯 +

  • 卡洛斯·加西亚·马尔克斯 +

  • 卡罗尔·威林

  • 卓廷豪 +

  • 奇特兰克·迪克西特 +

  • 克里斯

  • 克里斯·伯尔 +

  • 克里斯·卡塔尔福 +

  • 克里斯·马祖洛

  • 克里斯蒂安·查瓦拉 +

  • 吉汉·杰伊汉 +

  • 克莱门斯·布伦纳

  • 科林+

  • 科尼利厄斯·里门施奈德

  • 水晶锣+

  • 达安·范豪维尔梅伦

  • 丹·迪克西 +

  • 丹尼尔·弗兰克 +

  • 丹尼尔·加里多 +

  • 丹尼尔佐久间 +

  • 数据监察员+

  • 戴夫·赫希菲尔德

  • 戴夫·刘易斯 +

  • 大卫·阿德里安·卡尼奥内斯·卡斯特拉诺 +

  • 大卫·阿科斯 +

  • 大卫·C·霍尔 +

  • 大卫·费舍尔

  • 大卫·霍斯 +

  • 大卫·卢茨 +

  • 大卫·波罗 +

  • 大卫·斯坦斯比

  • 丹尼斯·卡毛 +

  • 狄龙·尼德胡特

  • 迪米特里+

  • 欧文博士

  • 德罗·阿塔里亚

  • 埃里克·谢 +

  • 埃里克·基斯林格

  • 埃里克·O·勒比戈 (EOL) +

  • 饭神+

  • 法比安·雷特科夫斯基 +

  • 费萨尔+

  • 加布里埃尔·德·梅埃图 +

  • 詹保罗·马卡里奥 +

  • 吉夫林·拉贾雅

  • 吉尔伯托·奥林皮奥 +

  • 吉娜+

  • 盖尔特+

  • 格雷厄姆·英格斯 +

  • 格兰特·罗克

  • 格兰特·史密斯 +

  • 格热戈日·科内法乌 +

  • 吉列尔梅·贝尔特拉米尼

  • 哈盖哈吉尔 +

  • 哈米什·皮特凯斯利 +

  • 哈马德·马什库尔 +

  • 汉娜·费奇兰 +

  • 汉斯

  • 吴浩辰 +

  • 久萨罗查 +

  • 伊恩·巴尔 +

  • 易卜拉欣·沙拉夫·埃尔登 +

  • 伊格纳西·福什 +

  • 伊戈尔·康拉多·阿尔维斯·德利马 +

  • 伊戈尔·谢尔文斯基 +

  • 伊曼流+

  • 英戈尔夫·贝克尔

  • 伊斯雷尔·萨埃塔·佩雷斯

  • 伊娃·科耶夫斯卡 +

  • 雅库布·诺瓦茨基 +

  • 简FF +

  • 扬·科赫 +

  • 简·韦克曼

  • 贾内尔·佐特坎普 +

  • 杰森·班德洛 +

  • 豪梅·博内 +

  • 杰·阿拉马尔 +

  • 杰夫·雷巴克

  • 珍娜·维吉斯特

  • 吴吉米 +

  • 吴晶强 +

  • 约阿希姆·瓦格纳 +

  • 琼·马丁·米拉莱斯 +

  • 乔尔·诺斯曼

  • 乔恩公园 +

  • 约翰·坎特 +

  • 约翰尼·梅斯 +

  • 乔恩·米斯

  • 乔纳斯·舒尔茨 +

  • 钟原+

  • 乔迪竞赛 +

  • 乔里斯·范登博什

  • 何塞·FR·丰塞卡 +

  • 乔维克斯+

  • 胡里奥·马丁内斯 +

  • 约尔格·多普费尔特

  • 小林一德 +

  • 凯特·苏尔塔 +

  • 肯尼思+

  • 凯文·库尔

  • 凯文·谢泼德

  • 克日什托夫·乔姆斯基

  • 克塞尼亚+

  • 克谢尼娅·博布罗娃 +

  • 库纳尔·戈萨尔 +

  • 柯蒂斯·克斯坦 +

  • 凯尔·巴伦 +

  • 拉克什·阿罗拉 +

  • 劳伦斯·格弗特 +

  • 莱夫·沃尔什

  • 利亚姆·马歇尔 +

  • 利亚姆3851 +

  • 竹内光

  • 柳德米拉 +

  • 卢多维科·鲁索 +

  • 梅布尔·比利亚尔巴 +

  • 马南·帕尔·辛格 +

  • 曼拉吉·辛格

  • 马克+

  • 马克·加西亚

  • 马可·海姆肯 +

  • 玛丽亚德尔马尔比比洛尼 +

  • 马里奥·科尔切罗 +

  • 马克·伍德布里奇 +

  • 马丁·茹努瓦 +

  • 梅森·加洛 +

  • 马蒂亚斯·海基拉 +

  • 马特·布雷默-海斯

  • 马特·柯克+

  • 马特·梅诺 +

  • 马修·柯克 +

  • 马修·洛克林 +

  • 马修·罗斯克

  • 马蒂亚斯·布索尼耶 +

  • 马克斯·米哈伊洛夫 +

  • 马克西姆·韦克斯勒 +

  • 马克西米利安·鲁斯

  • 马克西米利亚诺·格列柯 +

  • 迈克尔·彭科夫

  • 迈克尔·罗特格 +

  • 迈克尔·塞利克 +

  • 迈克尔·瓦斯科姆

  • 三重~~~

  • 迈克·库兹马 +

  • 李明+

  • 米塔尔+

  • 米奇·内格斯 +

  • 蒙大拿低+

  • 莫里茨·明斯特 +

  • 莫尔塔达·梅哈尔

  • 迈尔斯·布雷斯韦特 +

  • 内特·约德

  • 尼古拉斯·乌尔萨 +

  • 尼克·奇穆拉

  • 尼科斯·卡拉吉安纳基斯 +

  • 尼蓬·萨德维尔卡 +

  • 尼斯·马滕森 +

  • 诺亚+

  • 诺埃米·埃尔泰特 +

  • 奥利维尔·比洛多 +

  • 翁德雷·科克斯 +

  • 小野艾伯哈德+

  • 保罗·甘塞尔 +

  • 保罗·曼尼诺 +

  • 保罗·雷迪

  • 保罗·罗伯托·德奥利维拉·卡斯特罗 +

  • 佩佩·弗洛雷斯 +

  • 彼得·霍夫曼

  • 菲尔·吴 +

  • 彼得罗·巴蒂斯顿

  • 普拉纳夫·苏瑞 +

  • 普里扬卡·奥贾 +

  • 普尔基特·马卢 +

  • 自述文件机器人 +

  • 雷·贝尔+

  • 里卡多·马廖凯蒂 +

  • 里德万·卢特拉 +

  • 罗伯特·迈耶

  • 罗宾

  • 罗宾·基普兰特 +

  • 罗汉·潘迪特 +

  • 洛克·米赫夫 +

  • 鲁兹·阿扎里

  • 里斯扎德·T·卡莱塔 +

  • 萨姆·科汉

  • 符山姆

  • 萨米尔·穆萨利 +

  • 塞缪尔·西纳约科 +

  • 尹相雄

  • 莎拉杰西卡+

  • 沙拉德·维贾拉普拉姆 +

  • 舒巴姆·乔杜里 +

  • 吴诗英 +

  • 西采·布劳威尔

  • 西蒙娜·巴索+

  • 斯蒂芬妮·德尔普雷特 +

  • 斯特凡诺·钱丘利 +

  • 斯蒂芬·蔡尔兹 +

  • 斯蒂芬·沃兰德 +

  • 斯蒂恩·范·霍伊 +

  • 斯文

  • 塔莉莎·普马尔 +

  • 深泽塔尔博 +

  • 特德·彼得鲁 +

  • 托马斯·卡斯威尔

  • 蒂姆·霍夫曼 +

  • 蒂姆·斯瓦斯特

  • 汤姆·奥格斯普格

  • 汤米+

  • 图利奥·卡萨格兰德 +

  • 图沙尔·古普塔 +

  • 图沙尔·米塔尔 +

  • 乌普卡·利德 +

  • 维克多别墅 +

  • 文斯·W+

  • 维尼修斯·菲格雷多 +

  • 维平·库马尔 +

  • 沃贝尔

  • 文欢+

  • 韦斯·特纳

  • 威廉·艾德

  • 林威尔逊 +

  • Xbar

  • 雅罗斯拉夫·哈尔琴科

  • 伊美

  • 崔永善 +

  • 宜安+

  • 张亦萌

  • 朱宝和+

  • 赵子豪 +

  • 数据集日 +

  • 阿基尔博维奇 +

  • 阿科塞尔+

  • 阿林德1 +

  • 阿姆塔+

  • 博尔克德布鲁因

  • 贝尔蒂纳托

  • 古尔克

  • 查理0389 +

  • 克里斯-B1

  • 斯法卡斯 +

  • 达吉克斯+

  • 放气SOCO +

  • 德雷斯特-htwg

  • 不和谐

  • 德马尼科夫斯基礁 +

  • 唐K23 +

  • 埃尔卢比奥 +

  • 五莫克+

  • 菲迪奥德

  • 飞特+

  • 弗罗斯勒+

  • 加布里埃尔克劳

  • 格菲扬

  • 加塞姆纳德夫

  • h-vetinari +

  • 希曼舒阿瓦斯蒂 +

  • 伊纳姆夫+

  • 杰弗德+

  • 爵士麦片+

  • 杰布罗克门德尔

  • 仁W+

  • jjames34 +

  • 乔阿夫 +

  • 乔德斯 +

  • 杰申德尔

  • 胡安·于格 +

  • l736x+

  • 卢斯帕兹+

  • 姆德博克+

  • 米格尔莫林 +

  • 迈克985

  • 米克尔·坎普罗东 +

  • 奥雷塔+

  • 奥蒂普+

  • 彼得潘姆杰 +

  • 拉法瑞+

  • 拉夫-M +

  • 准备就绪15728 +

  • 米哈埃尔+

  • 萨姆赫姆斯+

  • 脚本+

  • sfoo+

  • 史蒂芬西米克 +

  • 斯通比格

  • tmnhat2001 +

  • 汤姆尼普 +

  • 礼帽-123

  • 电视3141+

  • 维拉凯+

  • xpvpc+

  • 张辉+