版本 0.19.0（2016 年 10 月 2 日）#

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

亮点包括：

merge_asof()对于 asof 风格的时间序列连接，请参见此处
.rolling()现在具有时间序列意识，请参见此处
read_csv()现在支持解析Categorical数据，参见这里
union_categorical()添加了用于组合分类的函数，请参阅此处
PeriodIndex现在有自己的period数据类型，并更改为与其他类更加一致Index。看这里
稀疏数据结构获得了int和booldtypes 的增强支持，请参见此处
比较操作Series不再忽略索引，请参阅此处了解 API 更改的概述。
实用功能的 pandas 开发 API 介绍，请参见此处。
弃用Panel4D和PanelND。我们建议使用xarray 包来表示这些类型的 n 维数据。
删除以前弃用的模块pandas.io.data, pandas.io.wb, pandas.tools.rplot。

警告

pandas >= 0.19.0 将不再在导入时静音 numpy ufunc 警告，请参阅此处。

新功能＃

`merge_asof`asof 风格的时间序列连接函数#

通过该函数添加了一个长期请求的功能merge_asof()，以支持时间序列的 asof 风格连接（GH 1870、GH 13695、GH 13709、GH 13902）。完整的文档在这里。

执行merge_asof()asof 合并，这与左连接类似，只是我们匹配最近的键而不是相等的键。

In [1]: left = pd.DataFrame({"a": [1, 5, 10], "left_val": ["a", "b", "c"]})

In [2]: right = pd.DataFrame({"a": [1, 2, 3, 6, 7], "right_val": [1, 2, 3, 6, 7]})

In [3]: left
Out[3]: 
    a left_val
0   1        a
1   5        b
2  10        c

[3 rows x 2 columns]

In [4]: right
Out[4]: 
   a  right_val
0  1          1
1  2          2
2  3          3
3  6          6
4  7          7

[5 rows x 2 columns]

我们通常希望尽可能精确匹配，否则使用最新的值。

In [5]: pd.merge_asof(left, right, on="a")
Out[5]: 
    a left_val  right_val
0   1        a          1
1   5        b          3
2  10        c          7

[3 rows x 3 columns]

我们还可以仅将行与先前的数据进行匹配，而不是完全匹配。

In [6]: pd.merge_asof(left, right, on="a", allow_exact_matches=False)
Out[6]: 
    a left_val  right_val
0   1        a        NaN
1   5        b        3.0
2  10        c        7.0

[3 rows x 3 columns]

在典型的时间序列示例中，我们拥有trades并且quotes想要asof-join它们。这也说明了by在合并之前使用参数对数据进行分组。

In [7]: trades = pd.DataFrame(
   ...:     {
   ...:         "time": pd.to_datetime(
   ...:             [
   ...:                 "20160525 13:30:00.023",
   ...:                 "20160525 13:30:00.038",
   ...:                 "20160525 13:30:00.048",
   ...:                 "20160525 13:30:00.048",
   ...:                 "20160525 13:30:00.048",
   ...:             ]
   ...:         ),
   ...:         "ticker": ["MSFT", "MSFT", "GOOG", "GOOG", "AAPL"],
   ...:         "price": [51.95, 51.95, 720.77, 720.92, 98.00],
   ...:         "quantity": [75, 155, 100, 100, 100],
   ...:     },
   ...:     columns=["time", "ticker", "price", "quantity"],
   ...: )
   ...: 

In [8]: quotes = pd.DataFrame(
   ...:     {
   ...:         "time": pd.to_datetime(
   ...:             [
   ...:                 "20160525 13:30:00.023",
   ...:                 "20160525 13:30:00.023",
   ...:                 "20160525 13:30:00.030",
   ...:                 "20160525 13:30:00.041",
   ...:                 "20160525 13:30:00.048",
   ...:                 "20160525 13:30:00.049",
   ...:                 "20160525 13:30:00.072",
   ...:                 "20160525 13:30:00.075",
   ...:             ]
   ...:         ),
   ...:         "ticker": ["GOOG", "MSFT", "MSFT", "MSFT", "GOOG", "AAPL", "GOOG", "MSFT"],
   ...:         "bid": [720.50, 51.95, 51.97, 51.99, 720.50, 97.99, 720.50, 52.01],
   ...:         "ask": [720.93, 51.96, 51.98, 52.00, 720.93, 98.01, 720.88, 52.03],
   ...:     },
   ...:     columns=["time", "ticker", "bid", "ask"],
   ...: )
   ...: 

In [9]: trades
Out[9]: 
                     time ticker   price  quantity
0 2016-05-25 13:30:00.023   MSFT   51.95        75
1 2016-05-25 13:30:00.038   MSFT   51.95       155
2 2016-05-25 13:30:00.048   GOOG  720.77       100
3 2016-05-25 13:30:00.048   GOOG  720.92       100
4 2016-05-25 13:30:00.048   AAPL   98.00       100

[5 rows x 4 columns]

In [10]: quotes
Out[10]: 
                     time ticker     bid     ask
0 2016-05-25 13:30:00.023   GOOG  720.50  720.93
1 2016-05-25 13:30:00.023   MSFT   51.95   51.96
2 2016-05-25 13:30:00.030   MSFT   51.97   51.98
3 2016-05-25 13:30:00.041   MSFT   51.99   52.00
4 2016-05-25 13:30:00.048   GOOG  720.50  720.93
5 2016-05-25 13:30:00.049   AAPL   97.99   98.01
6 2016-05-25 13:30:00.072   GOOG  720.50  720.88
7 2016-05-25 13:30:00.075   MSFT   52.01   52.03

[8 rows x 4 columns]

asof 合并连接on通常是一个有序的日期时间字段，在本例中，我们在该by字段中使用石斑鱼。这类似于左外连接，只不过前向填充会自动采用最新的非 NaN 值。

In [11]: pd.merge_asof(trades, quotes, on="time", by="ticker")
Out[11]: 
                     time ticker   price  quantity     bid     ask
0 2016-05-25 13:30:00.023   MSFT   51.95        75   51.95   51.96
1 2016-05-25 13:30:00.038   MSFT   51.95       155   51.97   51.98
2 2016-05-25 13:30:00.048   GOOG  720.77       100  720.50  720.93
3 2016-05-25 13:30:00.048   GOOG  720.92       100  720.50  720.93
4 2016-05-25 13:30:00.048   AAPL   98.00       100     NaN     NaN

[5 rows x 6 columns]

这将返回一个合并的 DataFrame，其中条目的顺序与原始左侧传递的 DataFrame（trades在本例中）相同，并且字段已quotes合并。

方法`.rolling()`现在可以感知时间序列#

.rolling()对象现在具有时间序列感知能力，并且可以接受window参数的时间序列偏移（或可转换）（GH 13327、GH 12995）。请参阅此处的完整文档。

In [12]: dft = pd.DataFrame(
   ....:     {"B": [0, 1, 2, np.nan, 4]},
   ....:     index=pd.date_range("20130101 09:00:00", periods=5, freq="s"),
   ....: )
   ....: 

In [13]: dft
Out[13]: 
                       B
2013-01-01 09:00:00  0.0
2013-01-01 09:00:01  1.0
2013-01-01 09:00:02  2.0
2013-01-01 09:00:03  NaN
2013-01-01 09:00:04  4.0

[5 rows x 1 columns]

这是一个常规的频率指数。使用整数窗口参数可以沿窗口频率滚动。

In [14]: dft.rolling(2).sum()
Out[14]: 
                       B
2013-01-01 09:00:00  NaN
2013-01-01 09:00:01  1.0
2013-01-01 09:00:02  3.0
2013-01-01 09:00:03  NaN
2013-01-01 09:00:04  NaN

[5 rows x 1 columns]

In [15]: dft.rolling(2, min_periods=1).sum()
Out[15]: 
                       B
2013-01-01 09:00:00  0.0
2013-01-01 09:00:01  1.0
2013-01-01 09:00:02  3.0
2013-01-01 09:00:03  2.0
2013-01-01 09:00:04  4.0

[5 rows x 1 columns]

指定偏移量可以更直观地指定滚动频率。

In [16]: dft.rolling("2s").sum()
Out[16]: 
                       B
2013-01-01 09:00:00  0.0
2013-01-01 09:00:01  1.0
2013-01-01 09:00:02  3.0
2013-01-01 09:00:03  2.0
2013-01-01 09:00:04  4.0

[5 rows x 1 columns]

使用非常规但仍然单调的索引，使用整数窗口滚动不会传递任何特殊计算。

In [17]: dft = pd.DataFrame(
   ....:     {"B": [0, 1, 2, np.nan, 4]},
   ....:     index=pd.Index(
   ....:         [
   ....:             pd.Timestamp("20130101 09:00:00"),
   ....:             pd.Timestamp("20130101 09:00:02"),
   ....:             pd.Timestamp("20130101 09:00:03"),
   ....:             pd.Timestamp("20130101 09:00:05"),
   ....:             pd.Timestamp("20130101 09:00:06"),
   ....:         ],
   ....:         name="foo",
   ....:     ),
   ....: )
   ....: 

In [18]: dft
Out[18]: 
                       B
foo                     
2013-01-01 09:00:00  0.0
2013-01-01 09:00:02  1.0
2013-01-01 09:00:03  2.0
2013-01-01 09:00:05  NaN
2013-01-01 09:00:06  4.0

[5 rows x 1 columns]

In [19]: dft.rolling(2).sum()
Out[19]: 
                       B
foo                     
2013-01-01 09:00:00  NaN
2013-01-01 09:00:02  1.0
2013-01-01 09:00:03  3.0
2013-01-01 09:00:05  NaN
2013-01-01 09:00:06  NaN

[5 rows x 1 columns]

使用时间规范为该稀疏数据生成可变窗口。

In [20]: dft.rolling("2s").sum()
Out[20]: 
                       B
foo                     
2013-01-01 09:00:00  0.0
2013-01-01 09:00:02  1.0
2013-01-01 09:00:03  3.0
2013-01-01 09:00:05  NaN
2013-01-01 09:00:06  4.0

[5 rows x 1 columns]

此外，我们现在允许使用可选on参数来指定 DataFrame 中的列（而不是默认的索引）。

In [21]: dft = dft.reset_index()

In [22]: dft
Out[22]: 
                  foo    B
0 2013-01-01 09:00:00  0.0
1 2013-01-01 09:00:02  1.0
2 2013-01-01 09:00:03  2.0
3 2013-01-01 09:00:05  NaN
4 2013-01-01 09:00:06  4.0

[5 rows x 2 columns]

In [23]: dft.rolling("2s", on="foo").sum()
Out[23]: 
                  foo    B
0 2013-01-01 09:00:00  0.0
1 2013-01-01 09:00:02  1.0
2 2013-01-01 09:00:03  3.0
3 2013-01-01 09:00:05  NaN
4 2013-01-01 09:00:06  4.0

[5 rows x 2 columns]

方法`read_csv`改进了对重复列名的支持#

现在支持重复的列名，read_csv()无论它们是在文件中还是作为参数传入names（ GH 7160、 GH 9424）

In [24]: data = "0,1,2\n3,4,5"

In [25]: names = ["a", "b", "a"]

以前的行为：

In [2]: pd.read_csv(StringIO(data), names=names)
Out[2]:
   a  b  a
0  2  1  2
1  5  4  5

第一a列包含与第二列相同的数据a，而它本应包含值。[0, 3]

新行为：

In [26]: pd.read_csv(StringIO(data), names=names)
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[26], line 1
----> 1 pd.read_csv(StringIO(data), names=names)

File ~/work/pandas/pandas/pandas/io/parsers/readers.py:1026, in read_csv(filepath_or_buffer, sep, delimiter, header, names, index_col, usecols, dtype, engine, converters, true_values, false_values, skipinitialspace, skiprows, skipfooter, nrows, na_values, keep_default_na, na_filter, verbose, skip_blank_lines, parse_dates, infer_datetime_format, keep_date_col, date_parser, date_format, dayfirst, cache_dates, iterator, chunksize, compression, thousands, decimal, lineterminator, quotechar, quoting, doublequote, escapechar, comment, encoding, encoding_errors, dialect, on_bad_lines, delim_whitespace, low_memory, memory_map, float_precision, storage_options, dtype_backend)
   1013 kwds_defaults = _refine_defaults_read(
   1014     dialect,
   1015     delimiter,
   (...)
   1022     dtype_backend=dtype_backend,
   1023 )
   1024 kwds.update(kwds_defaults)
-> 1026 return _read(filepath_or_buffer, kwds)

File ~/work/pandas/pandas/pandas/io/parsers/readers.py:617, in _read(filepath_or_buffer, kwds)
    614 nrows = kwds.get("nrows", None)
    616 # Check for duplicates in names.
--> 617 _validate_names(kwds.get("names", None))
    619 # Create the parser.
    620 parser = TextFileReader(filepath_or_buffer, **kwds)

File ~/work/pandas/pandas/pandas/io/parsers/readers.py:576, in _validate_names(names)
    574 if names is not None:
    575     if len(names) != len(set(names)):
--> 576         raise ValueError("Duplicate names are not allowed.")
    577     if not (
    578         is_list_like(names, allow_sets=False) or isinstance(names, abc.KeysView)
    579     ):
    580         raise ValueError("Names should be an ordered collection.")

ValueError: Duplicate names are not allowed.

方法`read_csv`支持`Categorical`直接解析#

该read_csv()函数现在支持Categorical在指定为 dtype ( GH 10153 ) 时解析列。根据数据的结构，与Categorical解析后转换相比，这可能会导致更快的解析时间和更低的内存使用量。请参阅此处的io文档。

In [27]: data = """
   ....: col1,col2,col3
   ....: a,b,1
   ....: a,b,2
   ....: c,d,3
   ....: """
   ....: 

In [28]: pd.read_csv(StringIO(data))
Out[28]: 
  col1 col2  col3
0    a    b     1
1    a    b     2
2    c    d     3

[3 rows x 3 columns]

In [29]: pd.read_csv(StringIO(data)).dtypes
Out[29]: 
col1    object
col2    object
col3     int64
Length: 3, dtype: object

In [30]: pd.read_csv(StringIO(data), dtype="category").dtypes
Out[30]: 
col1    category
col2    category
col3    category
Length: 3, dtype: object

各个列可以解析为Categorical使用 dict 规范

In [31]: pd.read_csv(StringIO(data), dtype={"col1": "category"}).dtypes
Out[31]: 
col1    category
col2      object
col3       int64
Length: 3, dtype: object

笔记

生成的类别将始终被解析为字符串（对象数据类型）。如果类别是数字，则可以使用该 to_numeric()函数进行转换，或者根据情况使用其他转换器，例如to_datetime().

In [32]: df = pd.read_csv(StringIO(data), dtype="category")

In [33]: df.dtypes
Out[33]: 
col1    category
col2    category
col3    category
Length: 3, dtype: object

In [34]: df["col3"]
Out[34]: 
0    1
1    2
2    3
Name: col3, Length: 3, dtype: category
Categories (3, object): ['1', '2', '3']

In [35]: new_categories = pd.to_numeric(df["col3"].cat.categories)

In [36]: df["col3"] = df["col3"].cat.rename_categories(new_categories)

In [37]: df["col3"]
Out[37]: 
0    1
1    2
2    3
Name: col3, Length: 3, dtype: category
Categories (3, int64): [1, 2, 3]

分类串联#

union_categoricals()添加了用于组合分类的函数，请参阅联合分类（GH 13361、GH 13763、GH 13846、GH 14173）

In [38]: from pandas.api.types import union_categoricals

In [39]: a = pd.Categorical(["b", "c"])

In [40]: b = pd.Categorical(["a", "b"])

In [41]: union_categoricals([a, b])
Out[41]: 
['b', 'c', 'a', 'b']
Categories (3, object): ['b', 'c', 'a']

concat现在append可以连接category具有不同categoriesas objectdtype 的 dtype ( GH 13524 )

In [42]: s1 = pd.Series(["a", "b"], dtype="category")

In [43]: s2 = pd.Series(["b", "c"], dtype="category")

以前的行为：

In [1]: pd.concat([s1, s2])
ValueError: incompatible categories in categorical concat

新行为：

In [44]: pd.concat([s1, s2])
Out[44]: 
0    a
1    b
0    b
1    c
Length: 4, dtype: object

半月偏移量#

pandas 获得了新的频率偏移SemiMonthEnd（“SM”）和SemiMonthBegin（“SMS”）。这些提供（默认情况下）分别锚定到月 15 日和月末以及月 15 日和月 1 日的日期偏移量。（GH 1543）

In [45]: from pandas.tseries.offsets import SemiMonthEnd, SemiMonthBegin

半月末：

In [46]: pd.Timestamp("2016-01-01") + SemiMonthEnd()
Out[46]: Timestamp('2016-01-15 00:00:00')

In [47]: pd.date_range("2015-01-01", freq="SM", periods=4)
Out[47]: DatetimeIndex(['2015-01-15', '2015-01-31', '2015-02-15', '2015-02-28'], dtype='datetime64[ns]', freq='SM-15')

半月开始：

In [46]: pd.Timestamp("2016-01-01") + SemiMonthBegin()
Out[46]: Timestamp('2016-01-15 00:00:00')

In [47]: pd.date_range("2015-01-01", freq="SMS", periods=4)
Out[47]: DatetimeIndex(['2015-01-01', '2015-01-15', '2015-02-01', '2015-02-15'], dtype='datetime64[ns]', freq='SMS-15')

使用锚定后缀，您还可以指定要使用的日期而不是 15 日。

In [50]: pd.date_range("2015-01-01", freq="SMS-16", periods=4)
Out[50]: DatetimeIndex(['2015-01-01', '2015-01-16', '2015-02-01', '2015-02-16'], dtype='datetime64[ns]', freq='SMS-16')

In [51]: pd.date_range("2015-01-01", freq="SM-14", periods=4)
Out[51]: DatetimeIndex(['2015-01-14', '2015-01-31', '2015-02-14', '2015-02-28'], dtype='datetime64[ns]', freq='SM-14')

新的索引方法#

中添加了以下方法和选项，以与和APIIndex更加一致。SeriesDataFrame

Index现在支持.where()相同形状索引的功能（GH 13170）

In [48]: idx = pd.Index(["a", "b", "c"])

In [49]: idx.where([True, False, True])
Out[49]: Index(['a', None, 'c'], dtype='object')

Index现在支持.dropna()排除缺失值（GH 6194）

In [50]: idx = pd.Index([1, 2, np.nan, 4])

In [51]: idx.dropna()
Out[51]: Index([1.0, 2.0, 4.0], dtype='float64')

对于MultiIndex，如果默认情况下缺少任何级别，则值将被删除。指定 how='all'仅删除所有级别均缺失的值。

In [52]: midx = pd.MultiIndex.from_arrays([[1, 2, np.nan, 4], [1, 2, np.nan, np.nan]])

In [53]: midx
Out[53]: 
MultiIndex([(1.0, 1.0),
            (2.0, 2.0),
            (nan, nan),
            (4.0, nan)],
           )

In [54]: midx.dropna()
Out[54]: 
MultiIndex([(1, 1),
            (2, 2)],
           )

In [55]: midx.dropna(how="all")
Out[55]: 
MultiIndex([(1, 1.0),
            (2, 2.0),
            (4, nan)],
           )

Index现在支持.str.extractall()返回 a DataFrame，请参阅此处的文档（GH 10008，GH 13156）

In [56]: idx = pd.Index(["a1a2", "b1", "c1"])

In [57]: idx.str.extractall(r"[ab](?P<digit>\d)")
Out[57]: 
        digit
  match      
0 0         1
  1         2
1 0         1

[3 rows x 1 columns]

Index.astype()现在接受一个可选的布尔参数copy，如果满足 dtype 的要求，则允许可选复制（GH 13209）

Google BigQuery 增强功能#

该read_gbq()方法获得了dialect允许用户指定是使用 BigQuery 的旧版 SQL 还是 BigQuery 的标准 SQL 的参数。有关更多详细信息，请参阅文档（ GH 13615）。
该to_gbq()方法现在允许 DataFrame 列顺序与目标表架构不同 ( GH 11359 )。

细粒度 NumPy 错误状态#

以前版本的 pandas 在pandas导入时会永久静音 numpy 的 ufunc 错误处理。 pandas 这样做是为了消除在缺失数据上使用 numpy ufunc 时产生的警告，这些数据通常表示为NaNs。不幸的是，这掩盖了应用程序中非 pandas 代码中出现的合法警告。从 0.19.0 开始，pandas 将使用numpy.errstate上下文管理器以更细粒度的方式消除这些警告，仅在 pandas 代码库中实际使用这些操作的地方进行。（GH 13109，GH 13145）

升级 pandas 后，您可能会看到代码发出新的 RuntimeWarnings消息。这些可能是合法的，并且在使用以前版本的 pandas 时，代码中可能存在根本原因，只是简单地消除了警告。在的源周围使用numpy.errstateRuntimeWarning来控制如何处理这些条件。

方法`get_dummies`现在返回整数数据类型#

该pd.get_dummies函数现在将虚拟编码列返回为小整数，而不是浮点数 ( GH 8725 )。这应该可以改善内存占用。

以前的行为：

In [1]: pd.get_dummies(['a', 'b', 'a', 'c']).dtypes

Out[1]:
a    float64
b    float64
c    float64
dtype: object

新行为：

In [58]: pd.get_dummies(["a", "b", "a", "c"]).dtypes
Out[58]: 
a    bool
b    bool
c    bool
Length: 3, dtype: object

将值向下转换为`to_numeric`#中可能的最小数据类型

pd.to_numeric()现在接受一个downcast参数，如果可能的话，该参数会将数据向下转换为最小的指定数字数据类型（GH 13352）

In [59]: s = ["1", 2, 3]

In [60]: pd.to_numeric(s, downcast="unsigned")
Out[60]: array([1, 2, 3], dtype=uint8)

In [61]: pd.to_numeric(s, downcast="integer")
Out[61]: array([1, 2, 3], dtype=int8)

熊猫开发 API #

作为使 pandas API 在未来更加统一和易于访问的一部分，我们创建了 pandas 的标准子包，pandas.api以保存公共 API。我们首先公开pandas.api.types.更多子包和官方认可的 API 将在 pandas 的未来版本中发布（GH 13147，GH 13634）

以下内容现已成为此 API 的一部分：

In [62]: import pprint

In [63]: from pandas.api import types

In [64]: funcs = [f for f in dir(types) if not f.startswith("_")]

In [65]: pprint.pprint(funcs)
['CategoricalDtype',
 'DatetimeTZDtype',
 'IntervalDtype',
 'PeriodDtype',
 'infer_dtype',
 'is_any_real_numeric_dtype',
 'is_array_like',
 'is_bool',
 'is_bool_dtype',
 'is_categorical_dtype',
 'is_complex',
 'is_complex_dtype',
 'is_datetime64_any_dtype',
 'is_datetime64_dtype',
 'is_datetime64_ns_dtype',
 'is_datetime64tz_dtype',
 'is_dict_like',
 'is_dtype_equal',
 'is_extension_array_dtype',
 'is_file_like',
 'is_float',
 'is_float_dtype',
 'is_hashable',
 'is_int64_dtype',
 'is_integer',
 'is_integer_dtype',
 'is_interval',
 'is_interval_dtype',
 'is_iterator',
 'is_list_like',
 'is_named_tuple',
 'is_number',
 'is_numeric_dtype',
 'is_object_dtype',
 'is_period_dtype',
 'is_re',
 'is_re_compilable',
 'is_scalar',
 'is_signed_integer_dtype',
 'is_sparse',
 'is_string_dtype',
 'is_timedelta64_dtype',
 'is_timedelta64_ns_dtype',
 'is_unsigned_integer_dtype',
 'pandas_dtype',
 'union_categoricals']

笔记

从内部模块调用这些函数pandas.core.common现在将显示DeprecationWarning（GH 13990）

其他增强功能#

Timestamp现在可以接受类似于datetime.datetime()（GH 10758，GH 11630）的位置和关键字参数

In [66]: pd.Timestamp(2012, 1, 1)
Out[66]: Timestamp('2012-01-01 00:00:00')

In [67]: pd.Timestamp(year=2012, month=1, day=1, hour=8, minute=30)
Out[67]: Timestamp('2012-01-01 08:30:00')

该.resample()函数现在接受一个on=或level=参数，用于在类似日期时间的列或MultiIndex级别上重新采样（GH 13500）

In [68]: df = pd.DataFrame(
   ....:     {"date": pd.date_range("2015-01-01", freq="W", periods=5), "a": np.arange(5)},
   ....:     index=pd.MultiIndex.from_arrays(
   ....:         [[1, 2, 3, 4, 5], pd.date_range("2015-01-01", freq="W", periods=5)],
   ....:         names=["v", "d"],
   ....:     ),
   ....: )
   ....: 

In [69]: df
Out[69]: 
                   date  a
v d                       
1 2015-01-04 2015-01-04  0
2 2015-01-11 2015-01-11  1
3 2015-01-18 2015-01-18  2
4 2015-01-25 2015-01-25  3
5 2015-02-01 2015-02-01  4

[5 rows x 2 columns]

In [74]: df.resample("M", on="date")[["a"]].sum()
Out[74]:
            a
date
2015-01-31  6
2015-02-28  4

[2 rows x 1 columns]

In [75]: df.resample("M", level="d")[["a"]].sum()
Out[75]:
            a
d
2015-01-31  6
2015-02-28  4

[2 rows x 1 columns]

现在可以首先尝试获取应用程序默认凭据.get_credentials()的方法。有关更多详细信息，请参阅文档（GH 13577）。GbqConnector
and.tz_localize()的方法获得了关键字，因此您可以将不存在的时间戳强制转换为。默认行为仍然是提高（GH 13057）DatetimeIndexTimestamperrorsNaTNonExistentTimeError
.to_hdf/read_hdf()现在接受文件路径（GH 11773）的路径对象（例如pathlib.Path，）py.path.local
with已获得对 ( GH 12933 )、( GH 13321 ) 和选项 ( GH 13381pd.read_csv() )的支持。engine='python'decimalna_filtermemory_map
与 Python API 一致，pd.read_csv()现在将解释+inf为正无穷大 ( GH 13274 )
已pd.read_html()获得对na_values, converters,keep_default_na选项的支持 ( GH 13461 )
Categorical.astype()现在接受一个可选的布尔参数copy，当 dtype 是分类时有效（GH 13209）
DataFrame获得了.asof()根据所选子集返回最后一个非 NaN 值的方法（GH 13358）
如果传入对象DataFrame列表，构造函数现在将遵循键顺序（GH 13304）OrderedDict
pd.read_html()已获得对该decimal选项的支持（GH 12907）
Series已获得类似于( GH 13336 )的属性.is_monotonic, .is_monotonic_increasing, ,.is_monotonic_decreasingIndex
DataFrame.to_sql()现在允许单个值作为所有列的 SQL 类型 ( GH 11886 )。
Series.append现在支持该ignore_index选项（GH 13677）
.to_stata()现在StataWriter可以使用字典将变量标签写入 Stata dta 文件，将列名设置为标签（GH 13535、GH 13536）
.to_stata()并StataWriter会自动将datetime64[ns]列转换为 Stata 格式%tc，而不是引发ValueError( GH 12259 )
read_stata()并StataReader在读取具有重复值标签的 Stata 文件时抛出更明确的错误消息convert_categoricals=True（GH 13923）
DataFrame.style现在将渲染稀疏的多索引（GH 11655）
DataFrame.style现在将显示列级别名称（例如DataFrame.columns.names）（GH 13775）

DataFrame已获得使用（GH 10806）根据行中的值重新排序列的支持df.sort_values(by='...', axis=1)

In [70]: df = pd.DataFrame({"A": [2, 7], "B": [3, 5], "C": [4, 8]}, index=["row1", "row2"])

In [71]: df
Out[71]: 
      A  B  C
row1  2  3  4
row2  7  5  8

[2 rows x 3 columns]

In [72]: df.sort_values(by="row2", axis=1)
Out[72]: 
      B  A  C
row1  3  2  4
row2  5  7  8

[2 rows x 3 columns]

向I/O添加了有关读取具有混合数据类型的列的危险以及如何处理它的文档( GH 13746 )
to_html()现在有一个border参数来控制开始标记中的值<table>。默认值是该选项的值html.border，默认为 1。这也会影响笔记本的 HTML repr，但由于 Jupyter 的 CSS 包含 border-width 属性，因此视觉效果是相同的。（GH 11563）。
未安装且使用连接字符串时引发ImportErrorsql 函数（ GH 11920）。sqlalchemy
与 matplotlib 2.0 的兼容性。旧版本的 pandas 也应该与 matplotlib 2.0 ( GH 13333 )一起使用
Timestamp、Period、DatetimeIndex和PeriodIndexaccessor.dt获得了一个.is_leap_year属性来检查日期是否属于闰年。（GH 13727）
astype()现在将接受列名到数据类型映射的字典作为参数dtype。（GH 12086）
and已获得对读取和写入 json 行的支持，并带有pd.read_json选项请参阅行分隔 json ( GH 9180 )DataFrame.to_jsonlines
read_excel()现在支持 true_values 和 false_values 关键字参数 ( GH 13347 )
groupby()现在将接受一个标量和一个单元素列表来指定level非MultiIndex石斑鱼。（GH 13907）
Excel 日期列中的不可转换日期将在不进行转换的情况下返回，并且该列将为objectdtype，而不是引发异常 ( GH 10001 )。
pd.Timedelta(None)现已接受并将返回NaT，镜像pd.Timestamp（GH 13687）
pd.read_stata()现在可以处理某些格式 111 文件，这些文件是 SAS 在生成 Stata dta 文件时生成的 ( GH 11526 )
Series现在Index支持divmod返回一系列或索引的元组。对于广播规则（GH 14208），其行为类似于标准二元运算符。

API 更改#

`Series.tolist()`现在将返回 Python 类型#

Series.tolist()现在将在输出中返回 Python 类型，模仿 NumPy.tolist()行为 ( GH 10904 )

In [73]: s = pd.Series([1, 2, 3])

以前的行为：

In [7]: type(s.tolist()[0])
Out[7]:
 <class 'numpy.int64'>

新行为：

In [74]: type(s.tolist()[0])
Out[74]: int

`Series`不同索引的运算符#

以下Series运算符已更改以使所有运算符保持一致，包括DataFrame（GH 1134、GH 4581、GH 13538）

Series比较运算符现在ValueError在index不同时引发。
Seriesindex逻辑运算符将左侧和右侧对齐。

警告

直到0.18.1，Series相同长度的比较，即使.index不同也会成功（结果忽略.index）。从 0.19.0 开始，这将变得ValueError更加严格。本节还介绍了如何使用灵活的比较方法（例如.eq.

结果，SeriesandDataFrame运算符的行为如下：

算术运算符#

算术运算符将两者对齐index（没有变化）。

In [75]: s1 = pd.Series([1, 2, 3], index=list("ABC"))

In [76]: s2 = pd.Series([2, 2, 2], index=list("ABD"))

In [77]: s1 + s2
Out[77]: 
A    3.0
B    4.0
C    NaN
D    NaN
Length: 4, dtype: float64

In [78]: df1 = pd.DataFrame([1, 2, 3], index=list("ABC"))

In [79]: df2 = pd.DataFrame([2, 2, 2], index=list("ABD"))

In [80]: df1 + df2
Out[80]: 
     0
A  3.0
B  4.0
C  NaN
D  NaN

[4 rows x 1 columns]

比较运算符#

比较运算符ValueError在.index不同时引发。

以前的行为( Series):

Series.index只要两者具有相同的长度，比较值就忽略：

In [1]: s1 == s2
Out[1]:
A    False
B     True
C    False
dtype: bool

新行为( Series)：

In [2]: s1 == s2
Out[2]:
ValueError: Can only compare identically-labeled Series objects

笔记

要获得与以前版本相同的结果（根据忽略的位置比较值.index），请比较两者.values。

In [81]: s1.values == s2.values
Out[81]: array([False,  True, False])

如果您想比较Series对齐其.index，请参阅下面的灵活比较方法部分：

In [82]: s1.eq(s2)
Out[82]: 
A    False
B     True
C    False
D    False
Length: 4, dtype: bool

当前行为（DataFrame，没有变化）：

In [3]: df1 == df2
Out[3]:
ValueError: Can only compare identically-labeled DataFrame objects

逻辑运算符#

.index逻辑运算符将左侧和右侧对齐。

之前的行为( )，仅保留Series左侧：index

In [4]: s1 = pd.Series([True, False, True], index=list('ABC'))
In [5]: s2 = pd.Series([True, True, True], index=list('ABD'))
In [6]: s1 & s2
Out[6]:
A     True
B    False
C    False
dtype: bool

新行为( Series)：

In [83]: s1 = pd.Series([True, False, True], index=list("ABC"))

In [84]: s2 = pd.Series([True, True, True], index=list("ABD"))

In [85]: s1 & s2
Out[85]: 
A     True
B    False
C    False
D    False
Length: 4, dtype: bool

笔记

Series逻辑运算符NaN用填充结果False。

笔记

要获得与以前版本相同的结果（仅根据左侧索引比较值），您可以使用reindex_like：

In [86]: s1 & s2.reindex_like(s1)
Out[86]: 
A     True
B    False
C    False
Length: 3, dtype: bool

当前行为（DataFrame，没有变化）：

In [87]: df1 = pd.DataFrame([True, False, True], index=list("ABC"))

In [88]: df2 = pd.DataFrame([True, True, True], index=list("ABD"))

In [89]: df1 & df2
Out[89]: 
       0
A   True
B  False
C  False
D  False

[4 rows x 1 columns]

灵活的比较方式#

Series灵活的比较方法，如eq、ne、le、lt，ge现在gt将两者对齐index。如果您想比较两个Series 具有不同的，请使用这些运算符index。

In [90]: s1 = pd.Series([1, 2, 3], index=["a", "b", "c"])

In [91]: s2 = pd.Series([2, 2, 2], index=["b", "c", "d"])

In [92]: s1.eq(s2)
Out[92]: 
a    False
b     True
c    False
d    False
Length: 4, dtype: bool

In [93]: s1.ge(s2)
Out[93]: 
a    False
b     True
c     True
d    False
Length: 4, dtype: bool

以前，这与比较运算符的工作原理相同（见上文）。

`Series`输入任务晋升#

ASeries现在将正确提升其 dtype 以将不兼容的值分配给当前 dtype ( GH 13234 )

In [94]: s = pd.Series()

以前的行为：

In [2]: s["a"] = pd.Timestamp("2016-01-01")

In [3]: s["b"] = 3.0
TypeError: invalid type promotion

新行为：

In [95]: s["a"] = pd.Timestamp("2016-01-01")

In [96]: s["b"] = 3.0

In [97]: s
Out[97]: 
a    2016-01-01 00:00:00
b                    3.0
Length: 2, dtype: object

In [98]: s.dtype
Out[98]: dtype('O')

功能`.to_datetime()`变化#

以前，如果.to_datetime()遇到混合整数/浮点数和字符串，但没有日期时间，errors='coerce'则会将所有转换为NaT.

以前的行为：

In [2]: pd.to_datetime([1, 'foo'], errors='coerce')
Out[2]: DatetimeIndex(['NaT', 'NaT'], dtype='datetime64[ns]', freq=None)

当前行为：

现在将使用默认单位ns.转换整数/浮点数。

In [99]: pd.to_datetime([1, "foo"], errors="coerce")
Out[99]: DatetimeIndex(['1970-01-01 00:00:00.000000001', 'NaT'], dtype='datetime64[ns]', freq=None)

与以下相关的错误修复.to_datetime()：

pd.to_datetime()传递整数或浮点数时出现错误，并且没有unit“and” errors='coerce'（GH 13180）。
pd.to_datetime()传递无效数据类型（例如 bool）时出现错误；现在将尊重errors关键字（GH 13176）
和dtypespd.to_datetime()上溢出的错误（GH 13451）int8int16
pd.to_datetime()raise AttributeErrorwith中的错误NaN，并且其他字符串在以下情况下无效errors='ignore'（GH 12424）
错误在指定pd.to_datetime()时未正确转换浮点数unit，导致日期时间被截断（GH 13834）

合并更改#

合并现在将保留连接键的数据类型（GH 8596）

In [100]: df1 = pd.DataFrame({"key": [1], "v1": [10]})

In [101]: df1
Out[101]: 
   key  v1
0    1  10

[1 rows x 2 columns]

In [102]: df2 = pd.DataFrame({"key": [1, 2], "v1": [20, 30]})

In [103]: df2
Out[103]: 
   key  v1
0    1  20
1    2  30

[2 rows x 2 columns]

以前的行为：

In [5]: pd.merge(df1, df2, how='outer')
Out[5]:
   key    v1
0  1.0  10.0
1  1.0  20.0
2  2.0  30.0

In [6]: pd.merge(df1, df2, how='outer').dtypes
Out[6]:
key    float64
v1     float64
dtype: object

新行为：

我们能够保留连接键

In [104]: pd.merge(df1, df2, how="outer")
Out[104]: 
   key  v1
0    1  10
1    1  20
2    2  30

[3 rows x 2 columns]

In [105]: pd.merge(df1, df2, how="outer").dtypes
Out[105]: 
key    int64
v1     int64
Length: 2, dtype: object

当然，如果引入了缺失值，那么生成的数据类型将被向上转换，这与之前的数据类型没有变化。

In [106]: pd.merge(df1, df2, how="outer", on="key")
Out[106]: 
   key  v1_x  v1_y
0    1  10.0    20
1    2   NaN    30

[2 rows x 3 columns]

In [107]: pd.merge(df1, df2, how="outer", on="key").dtypes
Out[107]: 
key       int64
v1_x    float64
v1_y      int64
Length: 3, dtype: object

方法`.describe()`改变#

输出索引中的百分位数标识符.describe()现在将四舍五入到保持它们不同的最小精度（GH 13104）

In [108]: s = pd.Series([0, 1, 2, 3, 4])

In [109]: df = pd.DataFrame([0, 1, 2, 3, 4])

以前的行为：

百分位数最多四舍五入到小数点后一位，ValueError如果百分位数重复，则数据帧的值可能会升高。

In [3]: s.describe(percentiles=[0.0001, 0.0005, 0.001, 0.999, 0.9995, 0.9999])
Out[3]:
count     5.000000
mean      2.000000
std       1.581139
min       0.000000
0.0%      0.000400
0.1%      0.002000
0.1%      0.004000
50%       2.000000
99.9%     3.996000
100.0%    3.998000
100.0%    3.999600
max       4.000000
dtype: float64

In [4]: df.describe(percentiles=[0.0001, 0.0005, 0.001, 0.999, 0.9995, 0.9999])
Out[4]:
...
ValueError: cannot reindex from a duplicate axis

新行为：

In [110]: s.describe(percentiles=[0.0001, 0.0005, 0.001, 0.999, 0.9995, 0.9999])
Out[110]: 
count     5.000000
mean      2.000000
std       1.581139
min       0.000000
0.01%     0.000400
0.05%     0.002000
0.1%      0.004000
50%       2.000000
99.9%     3.996000
99.95%    3.998000
99.99%    3.999600
max       4.000000
Length: 12, dtype: float64

In [111]: df.describe(percentiles=[0.0001, 0.0005, 0.001, 0.999, 0.9995, 0.9999])
Out[111]: 
               0
count   5.000000
mean    2.000000
std     1.581139
min     0.000000
0.01%   0.000400
0.05%   0.002000
0.1%    0.004000
50%     2.000000
99.9%   3.996000
99.95%  3.998000
99.99%  3.999600
max     4.000000

[12 rows x 1 columns]

此外：

传递重复percentiles现在将引发ValueError.
.describe()具有混合数据类型列索引的 DataFrame 上的错误，这之前会引发TypeError( GH 13288 )

`Period`变化＃

现在`PeriodIndex`有`period`dtype #

PeriodIndex现在有自己的period数据类型。 dtypeperiod是 pandas 扩展 dtypecategory或时区感知 dtype ( ) ( GH 13941 )。由于此更改，不再具有整数数据类型：datetime64[ns, tz]PeriodIndex

以前的行为：

In [1]: pi = pd.PeriodIndex(['2016-08-01'], freq='D')

In [2]: pi
Out[2]: PeriodIndex(['2016-08-01'], dtype='int64', freq='D')

In [3]: pd.api.types.is_integer_dtype(pi)
Out[3]: True

In [4]: pi.dtype
Out[4]: dtype('int64')

新行为：

In [112]: pi = pd.PeriodIndex(["2016-08-01"], freq="D")

In [113]: pi
Out[113]: PeriodIndex(['2016-08-01'], dtype='period[D]')

In [114]: pd.api.types.is_integer_dtype(pi)
Out[114]: False

In [115]: pd.api.types.is_period_dtype(pi)
Out[115]: True

In [116]: pi.dtype
Out[116]: period[D]

In [117]: type(pi.dtype)
Out[117]: pandas.core.dtypes.dtypes.PeriodDtype

`Period('NaT')`现在返回`pd.NaT`#

以前，具有与不同的Period自己的表示形式。现在已经改为返回。（GH 12759，GH 13582）Period('NaT')pd.NaTPeriod('NaT')pd.NaT

以前的行为：

In [5]: pd.Period('NaT', freq='D')
Out[5]: Period('NaT', 'D')

新行为：

这些导致pd.NaT不提供freq选项。

In [118]: pd.Period("NaT")
Out[118]: NaT

In [119]: pd.Period(None)
Out[119]: NaT

为了兼容Period加法和减法，pd.NaT现在支持加法和减法int。此前它提出了ValueError。

以前的行为：

In [5]: pd.NaT + 1
...
ValueError: Cannot add integral value to Timestamp without freq.

新行为：

In [120]: pd.NaT + 1
Out[120]: NaT

In [121]: pd.NaT - 1
Out[121]: NaT

`PeriodIndex.valuesPeriod`现在返回对象数组#

.values更改为返回对象数组Period，而不是整数数组 ( GH 13988 )。

以前的行为：

In [6]: pi = pd.PeriodIndex(['2011-01', '2011-02'], freq='M')
In [7]: pi.values
Out[7]: array([492, 493])

新行为：

In [122]: pi = pd.PeriodIndex(["2011-01", "2011-02"], freq="M")

In [123]: pi.values
Out[123]: array([Period('2011-01', 'M'), Period('2011-02', 'M')], dtype=object)

索引`+`/`-`不再用于集合操作#

基本索引类型和 DatetimeIndex（不是数字索引类型）的加法和减法之前执行了集合操作（集合并集和差集）。此行为自 0.15.0 起已被弃用（支持使用特定的 .union()和.difference()方法），现在已被禁用。如果可能，+和-现在用于按元素操作，例如用于连接字符串或减go日期时间（GH 8227、GH 14127）。

以前的行为：

In [1]: pd.Index(['a', 'b']) + pd.Index(['a', 'c'])
FutureWarning: using '+' to provide set union with Indexes is deprecated, use '|' or .union()
Out[1]: Index(['a', 'b', 'c'], dtype='object')

新行为：相同的操作现在将执行逐元素加法：

In [124]: pd.Index(["a", "b"]) + pd.Index(["a", "c"])
Out[124]: Index(['aa', 'bc'], dtype='object')

请注意，数字 Index 对象已经执行了逐元素操作。例如，添加两个整数索引的行为没有改变。现在，基础Index已与此行为保持一致。

In [125]: pd.Index([1, 2, 3]) + pd.Index([2, 3, 4])
Out[125]: Index([3, 5, 7], dtype='int64')

此外，由于这一更改，现在可以减go两个 DatetimeIndex 对象，从而得到 TimedeltaIndex：

以前的行为：

In [1]: (pd.DatetimeIndex(['2016-01-01', '2016-01-02'])
   ...:  - pd.DatetimeIndex(['2016-01-02', '2016-01-03']))
FutureWarning: using '-' to provide set differences with datetimelike Indexes is deprecated, use .difference()
Out[1]: DatetimeIndex(['2016-01-01'], dtype='datetime64[ns]', freq=None)

新行为：

In [126]: (
   .....:     pd.DatetimeIndex(["2016-01-01", "2016-01-02"])
   .....:     - pd.DatetimeIndex(["2016-01-02", "2016-01-03"])
   .....: )
   .....: 
Out[126]: TimedeltaIndex(['-1 days', '-1 days'], dtype='timedelta64[ns]', freq=None)

`Index.difference`并`.symmetric_difference`改变#

Index.difference现在，我们Index.symmetric_difference将更加一致地将NaN这些价值观视为任何其他价值观。（GH 13514）

In [127]: idx1 = pd.Index([1, 2, 3, np.nan])

In [128]: idx2 = pd.Index([0, 1, np.nan])

以前的行为：

In [3]: idx1.difference(idx2)
Out[3]: Float64Index([nan, 2.0, 3.0], dtype='float64')

In [4]: idx1.symmetric_difference(idx2)
Out[4]: Float64Index([0.0, nan, 2.0, 3.0], dtype='float64')

新行为：

In [129]: idx1.difference(idx2)
Out[129]: Index([2.0, 3.0], dtype='float64')

In [130]: idx1.symmetric_difference(idx2)
Out[130]: Index([0.0, 2.0, 3.0], dtype='float64')

`Index.unique`一致返回`Index`#

Index.unique()现在返回唯一值作为 Index适当的dtype. （GH 13395）。以前，大多数Index类返回np.ndarray、和DatetimeIndex， TimedeltaIndex并PeriodIndex返回Index以保留时区等元数据。

以前的行为：

In [1]: pd.Index([1, 2, 3]).unique()
Out[1]: array([1, 2, 3])

In [2]: pd.DatetimeIndex(['2011-01-01', '2011-01-02',
   ...:                   '2011-01-03'], tz='Asia/Tokyo').unique()
Out[2]:
DatetimeIndex(['2011-01-01 00:00:00+09:00', '2011-01-02 00:00:00+09:00',
               '2011-01-03 00:00:00+09:00'],
              dtype='datetime64[ns, Asia/Tokyo]', freq=None)

新行为：

In [131]: pd.Index([1, 2, 3]).unique()
Out[131]: Index([1, 2, 3], dtype='int64')

In [132]: pd.DatetimeIndex(
   .....:     ["2011-01-01", "2011-01-02", "2011-01-03"], tz="Asia/Tokyo"
   .....: ).unique()
   .....: 
Out[132]: 
DatetimeIndex(['2011-01-01 00:00:00+09:00', '2011-01-02 00:00:00+09:00',
               '2011-01-03 00:00:00+09:00'],
              dtype='datetime64[ns, Asia/Tokyo]', freq=None)

`MultiIndex`构造函数，`groupby`并`set_index`保留分类数据类型#

MultiIndex.from_arrays现在MultiIndex.from_product将保留级别中的分类数据类型MultiIndex（GH 13743，GH 13854）。

In [133]: cat = pd.Categorical(["a", "b"], categories=list("bac"))

In [134]: lvl1 = ["foo", "bar"]

In [135]: midx = pd.MultiIndex.from_arrays([cat, lvl1])

In [136]: midx
Out[136]: 
MultiIndex([('a', 'foo'),
            ('b', 'bar')],
           )

以前的行为：

In [4]: midx.levels[0]
Out[4]: Index(['b', 'a', 'c'], dtype='object')

In [5]: midx.get_level_values[0]
Out[5]: Index(['a', 'b'], dtype='object')

新行为：单一级别现在是CategoricalIndex：

In [137]: midx.levels[0]
Out[137]: CategoricalIndex(['b', 'a', 'c'], categories=['b', 'a', 'c'], ordered=False, dtype='category')

In [138]: midx.get_level_values(0)
Out[138]: CategoricalIndex(['a', 'b'], categories=['b', 'a', 'c'], ordered=False, dtype='category')

已对进行了类似的更改MultiIndex.from_product。因此，groupby还set_index保留索引中的分类数据类型

In [139]: df = pd.DataFrame({"A": [0, 1], "B": [10, 11], "C": cat})

In [140]: df_grouped = df.groupby(by=["A", "C"], observed=False).first()

In [141]: df_set_idx = df.set_index(["A", "C"])

以前的行为：

In [11]: df_grouped.index.levels[1]
Out[11]: Index(['b', 'a', 'c'], dtype='object', name='C')
In [12]: df_grouped.reset_index().dtypes
Out[12]:
A      int64
C     object
B    float64
dtype: object

In [13]: df_set_idx.index.levels[1]
Out[13]: Index(['b', 'a', 'c'], dtype='object', name='C')
In [14]: df_set_idx.reset_index().dtypes
Out[14]:
A      int64
C     object
B      int64
dtype: object

新行为：

In [142]: df_grouped.index.levels[1]
Out[142]: CategoricalIndex(['b', 'a', 'c'], categories=['b', 'a', 'c'], ordered=False, dtype='category', name='C')

In [143]: df_grouped.reset_index().dtypes
Out[143]: 
A       int64
C    category
B     float64
Length: 3, dtype: object

In [144]: df_set_idx.index.levels[1]
Out[144]: CategoricalIndex(['b', 'a', 'c'], categories=['b', 'a', 'c'], ordered=False, dtype='category', name='C')

In [145]: df_set_idx.reset_index().dtypes
Out[145]: 
A       int64
C    category
B       int64
Length: 3, dtype: object

函数`read_csv`将逐步枚举块#

当在指定或不指定索引的read_csv()情况下调用时chunksize=n，每个块都会有一个独立生成的索引，从0到n-1。现在，它们被赋予一个渐进索引，从0第一个块开始，从第二个块开始，依此类推，这样，当连接时，它们与不带n参数调用的结果相同（GH 12185）。read_csv()chunksize=

In [146]: data = "A,B\n0,1\n2,3\n4,5\n6,7"

以前的行为：

In [2]: pd.concat(pd.read_csv(StringIO(data), chunksize=2))
Out[2]:
   A  B
0  0  1
1  2  3
0  4  5
1  6  7

新行为：

In [147]: pd.concat(pd.read_csv(StringIO(data), chunksize=2))
Out[147]: 
   A  B
0  0  1
1  2  3
2  4  5
3  6  7

[4 rows x 2 columns]

稀疏的变化#

这些更改使 pandas 能够处理具有更多数据类型的稀疏数据，并为工作提供更流畅的数据处理体验。

类型`int64`和`bool`支持增强#

稀疏数据结构现在获得了int64和的增强支持bool dtype（GH 667、GH 13849）。

以前，稀疏数据float64默认为 dtype，即使所有输入均为int或booldtype。您必须dtype明确指定使用 dtype 创建稀疏数据int64。另外，fill_value必须明确指定，因为默认值np.nan不会出现在int64或bool数据中。

In [1]: pd.SparseArray([1, 2, 0, 0])
Out[1]:
[1.0, 2.0, 0.0, 0.0]
Fill: nan
IntIndex
Indices: array([0, 1, 2, 3], dtype=int32)

# specifying int64 dtype, but all values are stored in sp_values because
# fill_value default is np.nan
In [2]: pd.SparseArray([1, 2, 0, 0], dtype=np.int64)
Out[2]:
[1, 2, 0, 0]
Fill: nan
IntIndex
Indices: array([0, 1, 2, 3], dtype=int32)

In [3]: pd.SparseArray([1, 2, 0, 0], dtype=np.int64, fill_value=0)
Out[3]:
[1, 2, 0, 0]
Fill: 0
IntIndex
Indices: array([0, 1], dtype=int32)

从 v0.19.0 开始，稀疏数据保留输入 dtype，并使用更合适的fill_value默认值（0对于int64dtype，False对于booldtype）。

In [148]: pd.arrays.SparseArray([1, 2, 0, 0], dtype=np.int64)
Out[148]: 
[1, 2, 0, 0]
Fill: 0
IntIndex
Indices: array([0, 1], dtype=int32)

In [149]: pd.arrays.SparseArray([True, False, False, False])
Out[149]: 
[True, False, False, False]
Fill: False
IntIndex
Indices: array([0], dtype=int32)

请参阅文档了解更多详细信息。

运算符现在保留数据类型#

稀疏数据结构现在可以dtype在算术运算后保留（GH 13848）

s = pd.SparseSeries([0, 2, 0, 1], fill_value=0, dtype=np.int64)
s.dtype

s + 1

稀疏数据结构现在支持astype内部转换dtype（GH 13900）

s = pd.SparseSeries([1.0, 0.0, 2.0, 0.0], fill_value=0)
s
s.astype(np.int64)

astype如果数据包含无法转换为指定的值，则失败dtype。请注意，该限制适用于fill_value默认值np.nan。

In [7]: pd.SparseSeries([1., np.nan, 2., np.nan], fill_value=np.nan).astype(np.int64)
Out[7]:
ValueError: unable to coerce current fill_value nan to int64 dtype

其他稀疏修复#

进行子类化SparseDataFrame，SparseSeries现在在切片或转置时保留类类型。（GH 13787）
SparseArraywith booldtype 现在支持逻辑（布尔）运算符（GH 14000）
SparseSeries索引中的错误MultiIndex []可能会引发IndexError（GH 13144）
SparseSeries索引结果中的错误MultiIndex []可能正常Index（GH 13144）
错误中SparseDataFrame没有axis=None默认为axis=0（GH 13048）
SparseSeries使用 dtype 进行创建和SparseDataFrame创建object可能会引发错误TypeError（GH 11633）
错误SparseDataFrame不尊重传递的SparseArrayorSparseSeries的 dtype 和fill_value( GH 13866 )
错误SparseArray并且SparseSeries不应用 ufunc fill_value( GH 13853 )
BugSparseSeries.abs错误地保留负值fill_value（GH 13853）
多类型上的单行切片中的错误SparseDataFrame，类型以前被迫浮动（GH 13917）
切片中的错误SparseSeries将整数数据类型更改为浮点数（GH 8292）
SparseDataFarme比较操作中可能会出现错误TypeError（GH 13001）
SparseDataFarme.isnull加薪中的错误ValueError（GH 8276）
SparseSeriesdtype表示中的错误bool可能会出现IndexError（GH 13110）
SparseSeries和SparseDataFrameofbool或dtype中的错误int64可能会显示其值，如float64dtype ( GH 13110 )
SparseArray使用dtype 的稀疏索引中的错误bool可能会返回不正确的结果（GH 13985）
SparseArray创建的错误SparseSeries可能会丢失dtype（GH 13999）
SparseSeries与密集相比的错误返回正常Series而不是SparseSeries（GH 13999）

索引器数据类型更改#

笔记

此更改仅影响在 Windows 上运行的 64 位 python，并且仅影响相对高级的索引操作

诸如Index.get_indexer返回索引器数组之类的方法，将该数组强制为“platform int”，以便它可以直接在 3rd 方库操作中使用numpy.take。以前，平台 int 被定义为np.int_ 对应于 C 整数，但正确的类型以及现在使用的类型是np.intp，它对应于可以容纳指针的 C 整数大小（GH 3033、GH 13972）。

这些类型在许多平台上都是相同的，但对于 Windows 上的 64 位 python， np.int_是 32 位，而np.intp对于 64 位。更改此行为可以提高该平台上许多操作的性能。

以前的行为：

In [1]: i = pd.Index(['a', 'b', 'c'])

In [2]: i.get_indexer(['b', 'b', 'c']).dtype
Out[2]: dtype('int32')

新行为：

In [1]: i = pd.Index(['a', 'b', 'c'])

In [2]: i.get_indexer(['b', 'b', 'c']).dtype
Out[2]: dtype('int64')

其他 API 更改#

Timestamp.to_pydatetime将发出一个UserWarningwhen warn=True，并且实例具有非零的纳秒数，以前这会向标准输出（GH 14101）打印一条消息。
Series.unique()with datetime 和 timezone 现在返回Timestampwith timezone ( GH 13565 ) 的返回数组。
Panel.to_sparse()NotImplementedError调用时会引发异常（ GH 13778）。
Index.reshape()NotImplementedError调用时会引发异常（ GH 12882）。
.filter()强制关键字参数的互斥（GH 12399）。
eval类型的向上转换规则float32已更新，以与 NumPy 的规则更加一致。float64如果将 pandasfloat32对象乘以标量 float64 ( GH 12388 )，则新行为不会向上转换。
如果在 groupby 或重新采样对象上调用UnsupportedFunctionCallNumPy ufunc 之类的函数，现在会引发错误( GH 12811 )。np.mean
__setitem__将不再将可调用的 rhs 作为函数应用而不是存储它。直接调用where即可获取之前的行为（GH 13299）。
调用将尊重通过（GH 13161）.sample()设置的随机种子numpy.random.seed(n)
Styler.apply现在对函数必须返回的输出更加严格。对于axis=0或axis=1，输出形状必须相同。对于axis=None，输出必须是具有相同列和索引标签的 DataFrame ( GH 13222 )。
Float64Index.astype(int)ValueError如果Float64Index包含NaN值现在将引发（ GH 13149）
TimedeltaIndex.astype(int)现在DatetimeIndex.astype(int)将返回Int64Index而不是np.array（GH 13209）
Period将多个频率传递到正常状态Index现在会返回Indexdtype object( GH 13664 )
PeriodIndex.fillnawithPeriod现在具有不同的频率强制为objectdtype ( GH 13664 )
从现在开始，多面箱线图DataFrame.boxplot(by=col)返回一个“ Serieswhen return_typeis not None”。以前这些返回一个OrderedDict.请注意return_type=None，默认情况下，它们仍然返回二维 NumPy 数组（GH 12216、GH 7096）。
pd.read_hdf如果提供了,和以外的模式，现在将引发 aValueError而不是。（GH 13623）KeyErrorrr+a
pd.read_csv()、pd.read_table()、并在调用不存在的文件时pd.read_hdf()引发 Python 3.x 的内置异常；FileNotFoundError这是向后移植的，如IOErrorPython 2.x ( GH 14086 )
更多信息异常通过 csv 解析器传递。异常类型现在将是原始异常类型，而不是CParserError( GH 13652 )。
pd.read_csv()当编码长度超过一个字符时，C 引擎现在将发出 aParserWarning或引发 a ( GH 14065 )ValueErrorsep
DataFrame.values现在将返回混合类型float64和数据类型，符合（GH 10364，GH 13917）DataFrameint64uint64np.find_common_type
.groupby.groups现在将返回对象的字典，而不是orIndex的字典（GH 14293）np.ndarraylists

弃用#

Series.reshape已Categorical.reshape被弃用，并将在后续版本中删除（GH 12882，GH 12882）
PeriodIndex.to_datetime已被弃用，取而代之的是PeriodIndex.to_timestamp（GH 8254）
Timestamp.to_datetime已被弃用，取而代之的是Timestamp.to_pydatetime（GH 8254）
Index.to_datetime并DatetimeIndex.to_datetime已被弃用pd.to_datetime（GH 8254）
pandas.core.datetools模块已被弃用，并将在后续版本中删除（GH 14094）
SparseList已被弃用并将在未来版本中删除（GH 13784）
DataFrame.to_html()并DataFrame.to_latex()删除了colSpace有利于col_space（GH 13857）的参数
DataFrame.to_sql()已弃用该flavor参数，因为在未安装 SQLAlchemy 时它是多余的（GH 13611）
已弃用的read_csv关键字：
- compact_ints已use_unsigned被弃用，并将在未来版本中删除（GH 13320）
- buffer_lines已被弃用并将在未来版本中删除（GH 13360）
- as_recarray已被弃用并将在未来版本中删除（GH 13373）
- skip_footer已被弃用，skipfooter并将在未来版本中删除（GH 13349）
顶级pd.ordered_merge()已重命名为pd.merge_ordered()，原始名称将在未来版本中删除（GH 13358）
Timestamp.offset属性（并在构造函数中命名为 arg）已被弃用，取而代之的是freq（GH 12160）
pd.tseries.util.pivot_annual已弃用。pivot_table作为替代使用，这里有一个例子（GH 736）
pd.tseries.util.isleapyear已被弃用，并将在后续版本中删除。日期时间喜欢者现在有一个.is_leap_year属性（GH 13727）
Panel4D和PanelND构造函数已被弃用，并将在未来版本中删除。表示这些类型的 n 维数据的推荐方法是使用xarray 包。 pandas 提供了一种to_xarray()自动执行此转换的方法（GH 13564）。
pandas.tseries.frequencies.get_standard_freq已弃用。改用pandas.tseries.frequencies.to_offset(freq).rule_code（GH 13874）
pandas.tseries.frequencies.to_offset的freqstr关键字已被弃用，取而代之的是freq（GH 13874）
Categorical.from_array已被弃用，并将在未来版本中删除（GH 13854）

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

该SparsePanel课程已被删除（GH 13778）
该pd.sandbox模块已被删除，以支持外部库pandas-qt（GH 13670）
pandas.io.data和模块pandas.io.wb被删除，以支持pandas-datareader 包（GH 13724）。
该pandas.tools.rplot模块已被删除，取而代之的是seaborn包（GH 13855）
DataFrame.to_csv()已删除该engine参数，在 0.17.1 中已弃用（GH 11274、GH 13419）
DataFrame.to_dict()已删除outtype参数以支持orient（GH 13627，GH 8486）
pd.Categorical直接放弃了ordered属性的设置，转而采用该set_ordered方法（GH 13671）
pd.Categorical已放弃该levels属性以支持categories（GH 8376）
DataFrame.to_sql()已删除mysql参数选项flavor（GH 13611）
Panel.shift()已删除lags参数以支持periods（GH 14041）
pd.Index已放弃该diff方法，转而采用difference（GH 13669）
pd.DataFrame已放弃该to_wide方法，转而采用to_panel（GH 14039）
Series.to_csv已删除nanRep参数以支持na_rep（GH 13804）
Series.xs、、、、并已删除参数( GHDataFrame.xs 13781 )Panel.xsPanel.major_xsPanel.minor_xscopy
str.split已删除return_type参数以支持expand( GH 13701 )
删除旧时间规则（偏移别名），自 0.17.0 起已弃用（自 0.8.0 起已成为别名）（GH 13590、GH 13868）。现在遗留时间规则提出了ValueError。有关当前支持的偏移量的列表，请参阅此处。
return_type和参数的默认值从DataFrame.plot.box更改为。这些方法现在默认返回 matplotlib 轴，而不是艺术家字典。请参阅此处（GH 6581）。DataFrame.boxplotNone"axes"
模块中的和功能被tquery删除（GH 5950）。uquerypandas.io.sql

性能改进#

改进了稀疏的性能IntIndex.intersect（GH 13082）
BlockIndex当块数量很大时，改进了稀疏算术的性能，但建议IntIndex在这种情况下使用（GH 13082）
改进了性能，DataFrame.quantile()因为它现在按块运行（GH 11623）
改进了 float64 哈希表操作的性能，修复了 python 3 中一些非常慢的索引和 groupby 操作（GH 13166、GH 13334）
改进的性能DataFrameGroupBy.transform( GH 12737 )
Index改进了和Series .duplicated( GH 10235 )的性能
Index.difference改进了( GH 12044 )的性能
RangeIndex.is_monotonic_increasing改进了和的性能is_monotonic_decreasing（GH 13749）
DatetimeIndex改进了( GH 13692 )中日期时间字符串解析的性能
改进的哈希性能Period（GH 12817）
改进了带有时区的日期时间的性能factorize（GH 13750）
通过在较大索引上延迟创建索引哈希表来提高性能（GH 14266）
改进的性能groupby.groups( GH 14293 )
内省内存使用情况时不必要地具体化 MultiIndex ( GH 14308 )

Bug修复＃

错误groupby().shift()，在极少数情况下，当按缺失值的列进行分组时，可能会导致段错误或损坏（GH 13813）
groupby().cumsum()计算cumprod时的错误axis=1。（GH 13994）
未遵守参数的pd.to_timedelta()错误（GH 13613）errors
中的错误io.json.json_normalize()，其中非 ascii 键引发异常（GH 13213）
在( GH 11858 )中传递非默认索引Seriesasxerr或时出现错误yerr.plot()
如果启用子图或在图后移动图例，则面积图中的错误会错误地绘制图例（需要 matplotlib 1.5.0 才能正确绘制面积图图例）（GH 9161、GH 13544）
DataFrame对象类型赋值中的错误Index，其中结果列对于原始对象是可变的。（GH 13522）
matplotlib 中的错误AutoDataFormatter；这将恢复第二个缩放格式并重新添加微秒缩放格式（GH 13131）
HDFStore从具有固定格式和start/或指定的选择中选择的错误stop现在将返回所选范围（GH 8287）
当传入Categorical.from_codes()无效参数时引发无用错误的错误（GH 14058）ordered
SeriesWindows 上的整数元组构造错误不返回默认 dtype (int64) ( GH 13646 )
另外还有一个类似日期时间的对象的错误TimedeltaIndex，其中附加溢出未被捕获（GH 14068）
.groupby(..).resample(..)多次调用同一对象时出现的错误（ GH 13174）
.to_records()当索引名称是 unicode 字符串时出现错误（ GH 13172）
.memory_usage()调用未实现的对象时出现错误（ GH 12924）
与 nans中的回归Series.quantile（也出现在.median()和中.describe()）；此外，现在Series用分位数命名（GH 13098，GH 13146）
SeriesGroupBy.transform日期时间值和缺失组的错误（ GH 13191）
Series在类似日期时间的数字运算中错误地强制为空的错误（ GH 13844）
Categorical当传递包含时区的日期时间时，构造函数中存在错误Categorical（GH 14190）
指数上升Series.str.extractall()时出现错误（GH 13156）strValueError
Series.str.extractall()单个组和量词的错误（ GH 13382）
错误DatetimeIndex和Period减法引发ValueError或AttributeError而不是TypeError（GH 13078）
使用混合数据创建的Index错误可能没有数据类型（GH 13324）SeriesNaNNaTdatetime64
错误Index并Series可能忽略np.datetime64('nat')并np.timdelta64('nat')推断 dtype ( GH 13324 )
错误PeriodIndex和Period减法提高AttributeError（GH 13071）
在某些情况下PeriodIndex返回索引的构造错误（ GH 13067）float64
当空时没有适当.resample(..)改变PeriodIndex它的错误（ GH 13067）freq
当空时，不保留其类型或名称并适当地保留其类型或名称的.resample(..)错误（GH 13212）PeriodIndexDataFrame
groupby(..).apply(..)当传递的函数返回每组标量值时出现错误（ GH 13468）。
groupby(..).resample(..)传递某些关键字会引发异常的错误（ GH 13235）
依赖于索引排序以获得正确结果的.tz_converttz-aware 上的错误（ GH 13306）DateTimeIndex
错误.tz_localize可能dateutil.tz.tzlocal会返回不正确的结果（GH 13583）
DatetimeTZDtypedtype中的错误dateutil.tz.tzlocal不能被视为有效的 dtype ( GH 13583 )
尝试加载包含一个或多个分类列的单个数据集的 HDF 文件时出现的错误pd.read_hdf()，除非将键参数设置为数据集的名称，否则会失败。（GH 13231）
错误.rolling()允许在对象的构造中使用负整数窗口Rolling()，但稍后聚合会失败（GH 13383）
Series使用元组值数据和数字索引进行索引时出现错误（ GH 13509）
打印中的错误pd.DataFrame，其中 dtype 的异常元素object导致段错误（GH 13717）
排名中的错误Series可能会导致段错误（GH 13445）
各种索引类型中的错误，它不会传播传递的索引的名称（GH 12309）
错误DatetimeIndex，没有遵守copy=True（GH 13205）
DatetimeIndex.is_normalized在本地时区的情况下，标准化 date_range 的返回错误（GH 13459）
pd.concatand中的错误.append可能会强制将datetime64andtimedelta转换object为包含 python 内置的datetimeortimedelta而不是Timestampor Timedelta( GH 13626 )
当结果为dtype 时PeriodIndex.append可能会出现错误（GH 13221）AttributeErrorobject
错误CategoricalIndex.append可能会接受正常list（GH 13626）
错误pd.concat并.append具有相同的时区被重置为 UTC ( GH 7795 )
如果数据包含 DST 边界附近的日期时间，则会出现错误Series并DataFrame .append引发错误（ GH 13626）AmbiguousTimeError
DataFrame.to_csv()即使仅为非数字值指定了引号（GH 12922、GH 13259），浮点值仍被引用的错误
仅使用布尔列进行DataFrame.describe()提升的错误（ GH 13898）ValueError
MultiIndex当级别不唯一时返回额外元素的切片错误（ GH 12896）
错误.str.replace不会TypeError因无效替换而引发（GH 13438）
MultiIndex.from_arrays未检查输入数组长度匹配的错误（ GH 13599）
错误cartesian_product和MultiIndex.from_product可能会因空输入数组而引发（GH 12258）
pd.read_csv()在极少数情况下对流/文件进行大块迭代时可能会导致段错误或损坏的错误（ GH 13703）
pd.read_csv()当传入包含标量的字典时导致引发错误的错误na_values（GH 12224）
pd.read_csv()由于不忽略 BOM 而导致 BOM 文件被错误解析的错误( GH 4793 )
当传入 numpy 数组时引发错误的pd.read_csv()错误（GH 12546）engine='python'usecols
pd.read_csv()当使用参数解析为日期时，索引列被错误解析的错误thousands（GH 14066）
数据转换为数值后未检测到值的pd.read_csv()错误（GH 13314）engine='python'NaN
两个引擎的参数均未正确验证的pd.read_csv()错误( GH 10476 )nrows
错误pd.read_csv()，engine='python'其中混合大小写形式的无穷大未被正确解释（GH 13274）
pd.read_csv()未解析engine='python'尾随值的错误NaN（GH 13320）
使用 Python 3在 Windows 上读取时pd.read_csv()出现错误( GH 13398 )engine='python'tempfile.TemporaryFile
pd.read_csv()阻止usecolskwarg 接受单字节 unicode 字符串的错误( GH 13219 )
pd.read_csv()防止usecols成为空集的错误（ GH 13402）
C 引擎中的错误pd.read_csv()，其中 NULL 字符未被解析为 NULL ( GH 14012 )
即使指定为（GH 13411），也不pd.read_csv()接受engine='c'NULL 的错误quotecharquotingNone
当引用被指定为非数字时，字段未正确转换为浮动的pd.read_csv()错误（GH 13411）engine='c'
pd.read_csv()Python 2.x 中使用非 UTF8 编码、多字符分隔数据的错误( GH 3404 )
中的错误pd.read_csv()，其中 utf-xx 的别名（例如 UTF-xx、UTF_xx、utf_xx）引发了 UnicodeDecodeError ( GH 13549 )
pd.read_csv、pd.read_table、和中的错误，其中文件由解析器打开，但如果和都是，pd.read_fwf则文件未关闭。（GH 13940）pd.read_statapd.read_saschunksizeiteratorNone
StataReader、StataWriter、XportReader和中的错误SAS7BDATReader，当出现错误时文件未正确关闭。（GH 13940）
当是列表时pd.pivot_table()，其中的错误margins_name被忽略（ GH 13354）aggfunc
pd.Series.str.zfill、center、ljust、中的错误rjust，并且pad当传递非整数时，没有引发TypeError（GH 13598）
检查 a 中是否有空对象时出现错误TimedeltaIndex，该对象始终返回True（GH 13603）
如果包含类似日期时间的数据类型Series，则会出现算术错误（GH 13043）TypeErrorobject
错误Series.isnull()并Series.notnull()忽略Period('NaT')（GH 13737）
BugSeries.fillna()且不Series.dropna()影响Period('NaT')( GH 13737
错误地在dtyped上.fillna(value=np.nan)引发错误（GH 14021）KeyErrorcategorySeries
扩展数据类型创建中的错误，其中创建的类型不相同/相同（GH 13285）
.resample(..)IPython 内省触发错误警告的错误( GH 13618 )
错误NaT-Period引发AttributeError（GH 13071）
如果 rhs 包含( GH 9005 )，则比较中的错误Series可能会输出不正确的结果NaT
如果包含 dtype ( GH 13592 )，则错误和比较可能会输出不正确的Series结果IndexNaTobject
如果位于右侧，Period还会引发错误（ GH 13069）TypeErrorPeriod
Period和Series或Index比较中的错误引发TypeError（GH 13200）
错误pd.set_eng_float_format()会阻止 NaN 和 Inf 格式化（GH 11981）
错误中的.unstackdtypeCategorical重置.ordered为True( GH 13249 )
清除日期时间解析中的一些编译时警告（GH 13607）
如果数据包含 DST 边界附近的日期时间，则会factorize引发错误（ GH 13750）AmbiguousTimeError
如果新索引包含 DST 边界和多级别，则会.set_index引发错误（ GH 12920）AmbiguousTimeError
如果数据包含 DST 边界附近的日期时间，则会.shift引发错误（ GH 13926）AmbiguousTimeError
当列和查询与任何值都不匹配时，错误会pd.read_hdf()返回不正确的结果（ GH 13792）DataFramecategorical
.iloc使用非 lexsorted MultiIndex 进行索引时出现错误（ GH 13797）
.loc在反向排序中使用日期字符串进行索引时出现错误DatetimeIndex（GH 14316）
Series处理零暗淡 NumPy 数组时比较运算符中的错误（ GH 13006）
错误.combine_first可能返回不正确dtype（GH 7630，GH 10567）
根据第一个结果是否存在，groupbywhere返回不同结果的错误（GH 12824）applyNone
groupby(..).nth()如果之后调用，组密钥包含不一致的错误.head()/.tail()（GH 12839）
错误.to_html，.to_latex并.to_string默默地忽略通过formatters关键字传递的自定义日期时间格式化程序（GH 10690）
错误，如果定义则DataFrame.iterrows()不会产生子类（ GH 13977）Series
pd.to_numeric当errors='coerce'输入包含不可散列对象时出现错误（ GH 13324）
Timedelta无效算术和比较中的错误可能会引发ValueError而不是TypeError（GH 13624）
无效日期时间解析中的错误可能会引发to_datetime而不是（GH 11169，GH 11287）DatetimeIndexTypeErrorValueError
Index使用 tz 感知Timestamp和不匹配选项创建的错误tz错误地强制时区（GH 13692）
纳秒频率的错误DatetimeIndex不包括end( GH 13672 )指定的时间戳
使用( GH 14155 )Series设置切片时出现错误np.timedelta64
如果超出界限，则会Index引发错误，而不是强制转换为dtype ( GH 13663 )OutOfBoundsDatetimedatetimedatetime64[ns]object
错误Index可能会忽略指定datetime64或timedelta64传递为dtype（GH 13981）
RangeIndex可以在没有参数的情况下创建错误，而不是引发错误TypeError（GH 13793）
如果数据超出范围，则会.value_counts()引发错误（GH 13663）OutOfBoundsDatetimedatetime64[ns]
如果输入具有除( GH 9114 )以外的其他单位，则DatetimeIndex可能会出现错误OutOfBoundsDatetimenp.datetime64ns
使用 dtype以外的其他单位Series进行创建时出现错误，导致值不正确 ( GH 13876 )np.datetime64nsobject
timedelta 数据出现错误resample，其中数据被转换为浮点数（GH 13119）。
如果输入类似日期时间具有除（GH 13389）以外的单位，则pd.isnull() pd.notnull()引发错误TypeErrorns
如果输入类似日期时间的单位不是（GH 13389），则pd.merge()可能会出现错误TypeErrorns
如果设置了错误HDFStore/read_hdf()丢弃（ GH 13884）DatetimeIndex.nametz
Categorical.remove_unused_categories()将 dtype更改.codes为平台 int 中的错误（ GH 13261）
对多个列（包括分类列）进行分组时，groupbywith中的错误会返回所有 NaN（ GH 13204）as_index=False
df.groupby(...)[...]getitem中的错误Int64Index引发了错误（GH 13731）
DataFrame.style分配给索引名称的CSS 类中存在错误。以前它们被分配为，其中是级别数 + 1。现在它们被分配，其中是该 MultiIndex 的正确级别。"col_heading level<n> col<c>"n"index_name level<n>"n
由于与另一个名为 apiclient ( GH 13454 )的 python 包发生命名冲突pd.read_gbq()，可能会引发错误ImportError: No module named discovery
错误Index.union返回错误的结果，并带有命名的空索引（GH 13432）
使用混合整数索引时 Python3 中的错误Index.difference和引发（ GH 13432、GH 12814）DataFrame.join
datetime.datetime从 tz-aware系列中减go tz-aware 的错误datetime64（GH 14088）
.to_excel()当 DataFrame 包含 MultiIndex 时出现错误，其中包含具有 NaN 值的标签 ( GH 13511 )
无效频率偏移字符串（如“D1”、“-2-3H”）中的错误可能不会引发ValueError（GH 13930）
concat具有级别的groupby分层框架中的错误RangeIndex（GH 13542）。
仅包含 dtype值的Series.str.contains()系列中的错误（GH 14171）NaNobject
agg()groupby 数据帧上的函数中的错误将datetime64[ns]列的 dtype 更改为float64（GH 12821）
使用 NumPy ufunc 来PeriodIndex添加或减go整数 raise时出现错误IncompatibleFrequency。请注意，建议使用标准运算符，例如+or -，因为标准运算符使用更有效的路径（GH 13980）
NaT返回操作中的错误float而不是datetime64[ns]（GH 12941）
当（GH 13894）时Series，灵活算术方法（如.add()）中的错误会出现ValueErroraxis=None
添加了杂散空行的列中DataFrame.to_csv()出现错误（ GH 6618）MultiIndex
当输入不是但包含相同值时DatetimeIndex，TimedeltaIndex和中的错误PeriodIndex.equals()可能会返回（ GH 13107）TrueIndex
如果包含接近 DST 边界的日期时间，则针对带有时区的日期时间的分配中的错误可能不起作用（GH 14146）
使用 python 2 ( GH 14241 )截断长浮点文字的错误pd.eval()和查询HDFStore
当列不在 df 中并且列包含重复值时，Index会引发显示不正确列的错误（ GH 13822）KeyError
当频率组合偏移别名时出现错误Period并创建错误的日期（ GH 13874）PeriodIndex
.to_string()使用整数调用时会出现错误line_width，并index=False引发 UnboundLocalError 异常，因为idx在赋值之前引用了该异常。
eval()参数resolvers不接受列表的错误（ GH 14095）
stack,中的错误get_dummies，make_axis_dummies不保留（多）索引中的分类数据类型（GH 13854）
PeriodIndex现在可以接受list并且array其中包含pd.NaT（GH 13430）
如果分组数据帧包含空箱，则df.groupbywhere返回任意值的错误（ GH 13629）.median()
忽略参数Index.copy()的错误（ GH 14302）name

贡献者#

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

阿德里安·埃默里 +
亚历克斯·阿列克谢耶夫
亚历克斯·维格 +
艾伦·里德尔 +
阿莫尔+
阿莫尔·阿格拉瓦尔 +
安迪·R·特雷尔 +
安东尼奥·帕特尼奥
本·坎德尔 +
鲍勃·巴克斯利 +
布雷特·罗森 +
卡米洛·科塔 +
克里斯
克里斯·格林诺兹
克里斯·沃斯
克里斯蒂安·休顿
克里斯托弗·艾科克
丹尼尔·西拉吉 +
道格拉斯·麦克尼尔
德鲁里·勒普顿 +
爱德华多·布兰卡斯·雷耶斯 +
艾略特·马斯登 +
埃文·赖特
菲利克斯·马尔钦诺夫斯基 +
弗朗西斯·T·奥多诺万
杰兰特鸭 +
贾科莫·费罗尼 +
格兰特·罗克 +
加博·利普塔克
哈雷穆尔·阿里 +
哈桑·沙米姆 +
尤利乌斯·柯特 +
伊万·纳扎罗夫 +
杰夫·雷巴克
杰弗里·杰拉德 +
詹·奥尔森 +
吉姆·克里斯特
乔·杰夫尼克
约翰·埃文斯 +
约翰·弗里曼
约翰·利克泽 +
约翰·W·奥布莱恩
约翰·兹温克 +
约翰尼·吉尔 +
乔丹·埃伦里奇 +
乔里斯·范登博什
乔什·豪斯 +
约瑟夫白兰地+
陈嘉禾
卡米尔·辛迪 +
克比谢登
内核+
凯文·谢泼德
马蒂厄·布鲁彻 +
马克西米利安·鲁斯
迈克尔·谢勒 +
迈克·格雷厄姆 +
莫尔塔达·梅哈尔
穆罕默德·哈西卜·塔里克 +
内特·乔治+
尼尔·帕利 +
尼古拉斯·博诺特
氧化磷
潘登/佐拉+
保罗+
保罗·梅斯特梅克 +
保利·维尔塔宁
帕维尔·科德克 +
彼得罗·巴蒂斯顿
彼得·尤查 +
拉维·库马尔·尼米 +
罗伯特·吉塞克
罗伯特·科恩 +
罗杰·托马斯
罗伊·凯斯 +
拉塞尔·史密斯 +
萨希尔·杜阿 +
桑吉夫·洛博 +
萨索·斯塔诺夫尼克 +
肖恩·海德 +
辛赫克斯
斯蒂芬·卡佩尔 +
史蒂夫·崔 +
斯图尔特·亨德森 +
苏达山孔格+
托马斯·卡斯威尔
汤姆·奥格斯普格
汤姆·伯德 +
乌韦·霍夫曼 +
威尔·艾德 +
张翔+
YG-陆 +
亚杜南丹 +
雅罗斯拉夫·哈尔琴科
金子雄一郎+
阿德内乌
阿格拉博索 +
巴巴克基瓦尼 +
c123w+
克里斯-B1
克马祖洛 +
征服者1492 +
铬3+
dsm054
格菲扬
哈苏尔1610 +
亚姆辛哈 +
杰基冷 +
动力+
皮尤查+
普里扬克贾因 +
辛赫克斯
瓦格纳 +
yui-knk +
张锦杰+
zn平均值+
颜发才（Yan Facai） +

版本 0.19.0（2016 年 10 月 2 日）#

新功能＃

merge_asofasof 风格的时间序列连接函数#

方法.rolling()现在可以感知时间序列#

方法read_csv改进了对重复列名的支持#

方法read_csv支持Categorical直接解析#

分类串联#

半月偏移量#

新的索引方法#

Google BigQuery 增强功能#

细粒度 NumPy 错误状态#

方法get_dummies现在返回整数数据类型#

将值向下转换为to_numeric#中可能的最小数据类型

熊猫开发 API #

其他增强功能#

API 更改#

Series.tolist()现在将返回 Python 类型#

Series不同索引的运算符#

算术运算符#

比较运算符#

逻辑运算符#

灵活的比较方式#

Series输入任务晋升#

功能.to_datetime()变化#

合并更改#

方法.describe()改变#

Period变化＃

现在PeriodIndex有perioddtype #

Period('NaT')现在返回pd.NaT#

PeriodIndex.valuesPeriod现在返回对象数组#

索引+/-不再用于集合操作#

Index.difference并.symmetric_difference改变#

Index.unique一致返回Index#

MultiIndex构造函数，groupby并set_index保留分类数据类型#

函数read_csv将逐步枚举块#

稀疏的变化#

类型int64和bool支持增强#

运算符现在保留数据类型#

其他稀疏修复#

索引器数据类型更改#

其他 API 更改#

弃用#

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

性能改进#

Bug修复＃

贡献者#

`merge_asof`asof 风格的时间序列连接函数#

方法`.rolling()`现在可以感知时间序列#

方法`read_csv`改进了对重复列名的支持#

方法`read_csv`支持`Categorical`直接解析#

方法`get_dummies`现在返回整数数据类型#

将值向下转换为`to_numeric`#中可能的最小数据类型

`Series.tolist()`现在将返回 Python 类型#

`Series`不同索引的运算符#

`Series`输入任务晋升#

功能`.to_datetime()`变化#

方法`.describe()`改变#

`Period`变化＃

现在`PeriodIndex`有`period`dtype #

`Period('NaT')`现在返回`pd.NaT`#

`PeriodIndex.valuesPeriod`现在返回对象数组#

索引`+`/`-`不再用于集合操作#

`Index.difference`并`.symmetric_difference`改变#

`Index.unique`一致返回`Index`#

`MultiIndex`构造函数，`groupby`并`set_index`保留分类数据类型#

函数`read_csv`将逐步枚举块#

类型`int64`和`bool`支持增强#