Table Of Contents

Search

Enter search terms or a module, class or function name.

What’s New in 0.24.0 (January XX, 2019)

Warning

The 0.24.x series of releases will be the last to support Python 2. Future feature releases will support Python 3 only. See Plan for dropping Python 2.7 for more.

These are the changes in pandas 0.24.0. See Release Notes for a full changelog including other versions of pandas.

New features

  • merge() now directly allows merge between objects of type DataFrame and named Series, without the need to convert the Series object into a DataFrame beforehand (GH21220)
  • ExcelWriter now accepts mode as a keyword argument, enabling append to existing workbooks when using the openpyxl engine (GH3441)
  • FrozenList has gained the .union() and .difference() methods. This functionality greatly simplifies groupby’s that rely on explicitly excluding certain columns. See Splitting an object into groups for more information (GH15475, GH15506).
  • DataFrame.to_parquet() now accepts index as an argument, allowing the user to override the engine’s default behavior to include or omit the dataframe’s indexes from the resulting Parquet file. (GH20768)
  • DataFrame.corr() and Series.corr() now accept a callable for generic calculation methods of correlation, e.g. histogram intersection (GH22684)
  • DataFrame.to_string() now accepts decimal as an argument, allowing the user to specify which decimal separator should be used in the output. (GH23614)
  • read_feather() now accepts columns as an argument, allowing the user to specify which columns should be read. (GH24025)
  • DataFrame.to_html() now accepts render_links as an argument, allowing the user to generate HTML with links to any URLs that appear in the DataFrame. See the section on writing HTML in the IO docs for example usage. (GH2679)
  • pandas.read_csv() now supports pandas extension types as an argument to dtype, allowing the user to use pandas extension types when reading CSVs. (GH23228)
  • DataFrame.shift() Series.shift(), ExtensionArray.shift(), SparseArray.shift(), Period.shift(), GroupBy.shift(), Categorical.shift(), NDFrame.shift() and Block.shift() now accept fill_value as an argument, allowing the user to specify a value which will be used instead of NA/NaT in the empty periods. (GH15486)

Accessing the values in a Series or Index

Series.array and Index.array have been added for extracting the array backing a Series or Index. (GH19954, GH23623)

In [1]: idx = pd.period_range('2000', periods=4)

In [2]: idx.array
Out[2]: 
<PeriodArray>
['2000-01-01', '2000-01-02', '2000-01-03', '2000-01-04']
Length: 4, dtype: period[D]

In [3]: pd.Series(idx).array
Out[3]: 
<PeriodArray>
['2000-01-01', '2000-01-02', '2000-01-03', '2000-01-04']
Length: 4, dtype: period[D]

Historically, this would have been done with series.values, but with .values it was unclear whether the returned value would be the actual array, some transformation of it, or one of pandas custom arrays (like Categorical). For example, with PeriodIndex, .values generates a new ndarray of period objects each time.

In [4]: id(idx.values)
Out[4]: 140390592249488

In [5]: id(idx.values)
Out[5]: 140390592249328

If you need an actual NumPy array, use Series.to_numpy() or Index.to_numpy().

In [6]: idx.to_numpy()
Out[6]: 
array([Period('2000-01-01', 'D'), Period('2000-01-02', 'D'),
       Period('2000-01-03', 'D'), Period('2000-01-04', 'D')], dtype=object)

In [7]: pd.Series(idx).to_numpy()
Out[7]: 
array([Period('2000-01-01', 'D'), Period('2000-01-02', 'D'),
       Period('2000-01-03', 'D'), Period('2000-01-04', 'D')], dtype=object)

For Series and Indexes backed by normal NumPy arrays, Series.array will return a new arrays.PandasArray, which is a thin (no-copy) wrapper around a numpy.ndarray. arrays.PandasArray isn’t especially useful on its own, but it does provide the same interface as any extension array defined in pandas or by a third-party library.

In [8]: ser = pd.Series([1, 2, 3])

In [9]: ser.array
Out[9]: 
<PandasArray>
[1, 2, 3]
Length: 3, dtype: int64

In [10]: ser.to_numpy()
Out[10]: array([1, 2, 3])

We haven’t removed or deprecated Series.values or DataFrame.values, but we highly recommend and using .array or .to_numpy() instead.

See Dtypes and Attributes and Underlying Data for more.

ExtensionArray operator support

A Series based on an ExtensionArray now supports arithmetic and comparison operators (GH19577). There are two approaches for providing operator support for an ExtensionArray:

  1. Define each of the operators on your ExtensionArray subclass.
  2. Use an operator implementation from pandas that depends on operators that are already defined on the underlying elements (scalars) of the ExtensionArray.

See the ExtensionArray Operator Support documentation section for details on both ways of adding operator support.

Optional Integer NA Support

Pandas has gained the ability to hold integer dtypes with missing values. This long requested feature is enabled through the use of extension types. Here is an example of the usage.

We can construct a Series with the specified dtype. The dtype string Int64 is a pandas ExtensionDtype. Specifying a list or array using the traditional missing value marker of np.nan will infer to integer dtype. The display of the Series will also use the NaN to indicate missing values in string outputs. (GH20700, GH20747, GH22441, GH21789, GH22346)

In [11]: s = pd.Series([1, 2, np.nan], dtype='Int64')

In [12]: s
Out[12]: 
0      1
1      2
2    NaN
Length: 3, dtype: Int64

Operations on these dtypes will propagate NaN as other pandas operations.

# arithmetic
In [13]: s + 1
Out[13]: 
0      2
1      3
2    NaN
Length: 3, dtype: Int64

# comparison
In [14]: s == 1
Out[14]: 
0     True
1    False
2    False
Length: 3, dtype: bool

# indexing
In [15]: s.iloc[1:3]
Out[15]: 
1      2
2    NaN
Length: 2, dtype: Int64

# operate with other dtypes
In [16]: s + s.iloc[1:3].astype('Int8')
Out[16]: 
0    NaN
1      4
2    NaN
Length: 3, dtype: Int64

# coerce when needed
In [17]: s + 0.01
Out[17]: 
0    1.01
1    2.01
2     NaN
Length: 3, dtype: float64

These dtypes can operate as part of of DataFrame.

In [18]: df = pd.DataFrame({'A': s, 'B': [1, 1, 3], 'C': list('aab')})

In [19]: df
Out[19]: 
     A  B  C
0    1  1  a
1    2  1  a
2  NaN  3  b

[3 rows x 3 columns]

In [20]: df.dtypes
Out[20]: 
A     Int64
B     int64
C    object
Length: 3, dtype: object

These dtypes can be merged & reshaped & casted.

In [21]: pd.concat([df[['A']], df[['B', 'C']]], axis=1).dtypes
Out[21]: 
A     Int64
B     int64
C    object
Length: 3, dtype: object

In [22]: df['A'].astype(float)
Out[22]: 
0    1.0
1    2.0
2    NaN
Name: A, Length: 3, dtype: float64

Reduction and groupby operations such as ‘sum’ work.

In [23]: df.sum()
Out[23]: 
A      3
B      5
C    aab
Length: 3, dtype: object

In [24]: df.groupby('B').A.sum()
Out[24]: 
B
1    3
3    0
Name: A, Length: 2, dtype: Int64

Warning

The Integer NA support currently uses the capitalized dtype version, e.g. Int8 as compared to the traditional int8. This may be changed at a future date.

See Nullable Integer Data Type for more.

Array

A new top-level method array() has been added for creating 1-dimensional arrays (GH22860). This can be used to create any extension array, including extension arrays registered by 3rd party libraries. See

See Dtypes for more on extension arrays.

In [25]: pd.array([1, 2, np.nan], dtype='Int64')
Out[25]: 
<IntegerArray>
[1, 2, NaN]
Length: 3, dtype: Int64

In [26]: pd.array(['a', 'b', 'c'], dtype='category')
Out[26]: 
[a, b, c]
Categories (3, object): [a, b, c]

Passing data for which there isn’t dedicated extension type (e.g. float, integer, etc.) will return a new arrays.PandasArray, which is just a thin (no-copy) wrapper around a numpy.ndarray that satisfies the extension array interface.

In [27]: pd.array([1, 2, 3])
Out[27]: 
<PandasArray>
[1, 2, 3]
Length: 3, dtype: int64

On their own, a arrays.PandasArray isn’t a very useful object. But if you need write low-level code that works generically for any ExtensionArray, arrays.PandasArray satisfies that need.

Notice that by default, if no dtype is specified, the dtype of the returned array is inferred from the data. In particular, note that the first example of [1, 2, np.nan] would have returned a floating-point array, since NaN is a float.

In [28]: pd.array([1, 2, np.nan])
Out[28]: 
<PandasArray>
[1.0, 2.0, nan]
Length: 3, dtype: float64

read_html Enhancements

read_html() previously ignored colspan and rowspan attributes. Now it understands them, treating them as sequences of cells with the same value. (GH17054)

In [29]: result = pd.read_html("""
   ....:   <table>
   ....:     <thead>
   ....:       <tr>
   ....:         <th>A</th><th>B</th><th>C</th>
   ....:       </tr>
   ....:     </thead>
   ....:     <tbody>
   ....:       <tr>
   ....:         <td colspan="2">1</td><td>2</td>
   ....:       </tr>
   ....:     </tbody>
   ....:   </table>""")
   ....:

Previous Behavior:

In [13]: result
Out [13]:
[   A  B   C
 0  1  2 NaN]

New Behavior:

In [30]: result
Out[30]: 
[   A  B  C
 0  1  1  2
 
 [1 rows x 3 columns]]

Storing Interval and Period Data in Series and DataFrame

Interval and Period data may now be stored in a Series or DataFrame, in addition to an IntervalIndex and PeriodIndex like previously (GH19453, GH22862).

In [31]: ser = pd.Series(pd.interval_range(0, 5))

In [32]: ser
Out[32]: 
0    (0, 1]
1    (1, 2]
2    (2, 3]
3    (3, 4]
4    (4, 5]
Length: 5, dtype: interval

In [33]: ser.dtype
Out[33]: interval[int64]

For periods:

In [34]: pser = pd.Series(pd.date_range("2000", freq="D", periods=5))

In [35]: pser
Out[35]: 
0   2000-01-01
1   2000-01-02
2   2000-01-03
3   2000-01-04
4   2000-01-05
Length: 5, dtype: datetime64[ns]

In [36]: pser.dtype
Out[36]: dtype('<M8[ns]')

Previously, these would be cast to a NumPy array with object dtype. In general, this should result in better performance when storing an array of intervals or periods in a Series or column of a DataFrame.

Use Series.array to extract the underlying array of intervals or periods from the Series:

In [37]: ser.array
Out[37]: 
IntervalArray([(0, 1], (1, 2], (2, 3], (3, 4], (4, 5]],
              closed='right',
              dtype='interval[int64]')

In [38]: pser.array
Out[38]: 
<DatetimeArray>
['2000-01-01 00:00:00', '2000-01-02 00:00:00', '2000-01-03 00:00:00',
 '2000-01-04 00:00:00', '2000-01-05 00:00:00']
Length: 5, dtype: datetime64[ns]

Warning

For backwards compatibility, Series.values continues to return a NumPy array of objects for Interval and Period data. We recommend using Series.array when you need the array of data stored in the Series, and Series.to_numpy() when you know you need a NumPy array.

See Dtypes and Attributes and Underlying Data for more.

New Styler.pipe() method

The Styler class has gained a pipe() method. This provides a convenient way to apply users’ predefined styling functions, and can help reduce “boilerplate” when using DataFrame styling functionality repeatedly within a notebook. (GH23229)

In [39]: df = pd.DataFrame({'N': [1250, 1500, 1750], 'X': [0.25, 0.35, 0.50]})

In [40]: def format_and_align(styler):
   ....:     return (styler.format({'N': '{:,}', 'X': '{:.1%}'})
   ....:                   .set_properties(**{'text-align': 'right'}))
   ....: 

In [41]: df.style.pipe(format_and_align).set_caption('Summary of results.')
Out[41]: <pandas.io.formats.style.Styler at 0x7faf31f49588>

Similar methods already exist for other classes in pandas, including DataFrame.pipe(), pandas.core.groupby.GroupBy.pipe(), and pandas.core.resample.Resampler.pipe().

Joining with two multi-indexes

DataFrame.merge() and DataFrame.join() can now be used to join multi-indexed Dataframe instances on the overlaping index levels (GH6360)

See the Merge, join, and concatenate documentation section.

In [42]: index_left = pd.MultiIndex.from_tuples([('K0', 'X0'), ('K0', 'X1'),
   ....:                                        ('K1', 'X2')],
   ....:                                        names=['key', 'X'])
   ....: 

In [43]: left = pd.DataFrame({'A': ['A0', 'A1', 'A2'],
   ....:                      'B': ['B0', 'B1', 'B2']}, index=index_left)
   ....: 

In [44]: index_right = pd.MultiIndex.from_tuples([('K0', 'Y0'), ('K1', 'Y1'),
   ....:                                         ('K2', 'Y2'), ('K2', 'Y3')],
   ....:                                         names=['key', 'Y'])
   ....: 

In [45]: right = pd.DataFrame({'C': ['C0', 'C1', 'C2', 'C3'],
   ....:                       'D': ['D0', 'D1', 'D2', 'D3']}, index=index_right)
   ....: 

In [46]: left.join(right)
Out[46]: 
            A   B   C   D
key X  Y                 
K0  X0 Y0  A0  B0  C0  D0
    X1 Y0  A1  B1  C0  D0
K1  X2 Y1  A2  B2  C1  D1

[3 rows x 4 columns]

For earlier versions this can be done using the following.

In [47]: pd.merge(left.reset_index(), right.reset_index(),
   ....:          on=['key'], how='inner').set_index(['key', 'X', 'Y'])
   ....: 
Out[47]: 
            A   B   C   D
key X  Y                 
K0  X0 Y0  A0  B0  C0  D0
    X1 Y0  A1  B1  C0  D0
K1  X2 Y1  A2  B2  C1  D1

[3 rows x 4 columns]

Renaming names in a MultiIndex

DataFrame.rename_axis() now supports index and columns arguments and Series.rename_axis() supports index argument (GH19978)

This change allows a dictionary to be passed so that some of the names of a MultiIndex can be changed.

Example:

In [48]: mi = pd.MultiIndex.from_product([list('AB'), list('CD'), list('EF')],
   ....:                                 names=['AB', 'CD', 'EF'])
   ....: 

In [49]: df = pd.DataFrame([i for i in range(len(mi))], index=mi, columns=['N'])

In [50]: df
Out[50]: 
          N
AB CD EF   
A  C  E   0
      F   1
   D  E   2
      F   3
B  C  E   4
      F   5
   D  E   6
      F   7

[8 rows x 1 columns]

In [51]: df.rename_axis(index={'CD': 'New'})
Out[51]: 
           N
AB New EF   
A  C   E   0
       F   1
   D   E   2
       F   3
B  C   E   4
       F   5
   D   E   6
       F   7

[8 rows x 1 columns]

See the Advanced documentation on renaming for more details.

Other Enhancements

Backwards incompatible API changes

  • A newly constructed empty DataFrame with integer as the dtype will now only be cast to float64 if index is specified (GH22858)
  • Series.str.cat() will now raise if others is a set (GH23009)
  • Passing scalar values to DatetimeIndex or TimedeltaIndex will now raise TypeError instead of ValueError (GH23539)
  • max_rows and max_cols parameters removed from HTMLFormatter since truncation is handled by DataFrameFormatter (GH23818)
  • read_csv() will now raise a ValueError if a column with missing values is declared as having dtype bool (GH20591)
  • The column order of the resultant DataFrame from MultiIndex.to_frame() is now guaranteed to match the MultiIndex.names order. (GH22420)
  • Incorrectly passing a DatetimeIndex to MultiIndex.from_tuples(), rather than a sequence of tuples, now raises a TypeError rather than a ValueError (GH24024)
  • pd.offsets.generate_range() argument time_rule has been removed; use offset instead (GH24157)
  • In 0.23.x, pandas would raise a ValueError on a merge of a numeric column (e.g. int dtyped column) and an object dtyped column (GH9780). We have re-enabled the ability to merge object and other dtypes; pandas will still raise on a merge between a numeric and an object dtyped column that is composed only of strings (GH21681)

Percentage change on groupby

Fixed a bug where calling pancas.core.groupby.SeriesGroupBy.pct_change() or pandas.core.groupby.DataFrameGroupBy.pct_change() would previously work across groups when calculating the percent change, where it now correctly works per group (GH21200, GH21235).

In [52]: df = pd.DataFrame({'grp': ['a', 'a', 'b'], 'foo': [1.0, 1.1, 2.2]})

In [53]: df
Out[53]: 
  grp  foo
0   a  1.0
1   a  1.1
2   b  2.2

[3 rows x 2 columns]

Previous behavior:

In [1]: df.groupby('grp').pct_change()
Out[1]:
   foo
0  NaN
1  0.1
2  1.0

New behavior:

In [54]: df.groupby('grp').pct_change()
Out[54]: 
   foo
0  NaN
1  0.1
2  NaN

[3 rows x 1 columns]

Dependencies have increased minimum versions

We have updated our minimum supported versions of dependencies (GH21242, GH18742, GH23774). If installed, we now require:

Package Minimum Version Required
numpy 1.12.0 X
bottleneck 1.2.0  
fastparquet 0.2.1  
matplotlib 2.0.0  
numexpr 2.6.1  
pandas-gbq 0.8.0  
pyarrow 0.7.0  
pytables 3.4.2  
scipy 0.18.1  
xlrd 1.0.0  
pytest (dev) 3.6  

Additionally we no longer depend on feather-format for feather based storage and replaced it with references to pyarrow (GH21639 and GH23053).

os.linesep is used for line_terminator of DataFrame.to_csv

DataFrame.to_csv() now uses os.linesep() rather than '\n' for the default line terminator (GH20353). This change only affects when running on Windows, where '\r\n' was used for line terminator even when '\n' was passed in line_terminator.

Previous Behavior on Windows:

In [1]: data = pd.DataFrame({"string_with_lf": ["a\nbc"],
   ...:                      "string_with_crlf": ["a\r\nbc"]})

In [2]: # When passing file PATH to to_csv,
   ...: # line_terminator does not work, and csv is saved with '\r\n'.
   ...: # Also, this converts all '\n's in the data to '\r\n'.
   ...: data.to_csv("test.csv", index=False, line_terminator='\n')

In [3]: with open("test.csv", mode='rb') as f:
   ...:     print(f.read())
Out[3]: b'string_with_lf,string_with_crlf\r\n"a\r\nbc","a\r\r\nbc"\r\n'

In [4]: # When passing file OBJECT with newline option to
   ...: # to_csv, line_terminator works.
   ...: with open("test2.csv", mode='w', newline='\n') as f:
   ...:     data.to_csv(f, index=False, line_terminator='\n')

In [5]: with open("test2.csv", mode='rb') as f:
   ...:     print(f.read())
Out[5]: b'string_with_lf,string_with_crlf\n"a\nbc","a\r\nbc"\n'

New Behavior on Windows:

Passing line_terminator explicitly, set thes line terminator to that character.

In [1]: data = pd.DataFrame({"string_with_lf": ["a\nbc"],
   ...:                      "string_with_crlf": ["a\r\nbc"]})

In [2]: data.to_csv("test.csv", index=False, line_terminator='\n')

In [3]: with open("test.csv", mode='rb') as f:
   ...:     print(f.read())
Out[3]: b'string_with_lf,string_with_crlf\n"a\nbc","a\r\nbc"\n'

On Windows, the value of os.linesep is '\r\n', so if line_terminator is not set, '\r\n' is used for line terminator.

In [1]: data = pd.DataFrame({"string_with_lf": ["a\nbc"],
   ...:                      "string_with_crlf": ["a\r\nbc"]})

In [2]: data.to_csv("test.csv", index=False)

In [3]: with open("test.csv", mode='rb') as f:
   ...:     print(f.read())
Out[3]: b'string_with_lf,string_with_crlf\r\n"a\nbc","a\r\nbc"\r\n'

For file objects, specifying newline is not sufficient to set the line terminator. You must pass in the line_terminator explicitly, even in this case.

In [1]: data = pd.DataFrame({"string_with_lf": ["a\nbc"],
   ...:                      "string_with_crlf": ["a\r\nbc"]})

In [2]: with open("test2.csv", mode='w', newline='\n') as f:
   ...:     data.to_csv(f, index=False)

In [3]: with open("test2.csv", mode='rb') as f:
   ...:     print(f.read())
Out[3]: b'string_with_lf,string_with_crlf\r\n"a\nbc","a\r\nbc"\r\n'

Proper handling of np.NaN in a string data-typed column with the Python engine

There was bug in read_excel() and read_csv() with the Python engine, where missing values turned to 'nan' with dtype=str and na_filter=True. Now, these missing values are converted to the string missing indicator, np.nan. (GH20377)

Previous Behavior:

In [5]: data = 'a,b,c\n1,,3\n4,5,6'
In [6]: df = pd.read_csv(StringIO(data), engine='python', dtype=str, na_filter=True)
In [7]: df.loc[0, 'b']
Out[7]:
'nan'

New Behavior:

In [55]: data = 'a,b,c\n1,,3\n4,5,6'

In [56]: df = pd.read_csv(StringIO(data), engine='python', dtype=str, na_filter=True)

In [57]: df.loc[0, 'b']
Out[57]: nan

Notice how we now instead output np.nan itself instead of a stringified form of it.

Parsing Datetime Strings with Timezone Offsets

Previously, parsing datetime strings with UTC offsets with to_datetime() or DatetimeIndex would automatically convert the datetime to UTC without timezone localization. This is inconsistent from parsing the same datetime string with Timestamp which would preserve the UTC offset in the tz attribute. Now, to_datetime() preserves the UTC offset in the tz attribute when all the datetime strings have the same UTC offset (GH17697, GH11736, GH22457)

Previous Behavior:

In [2]: pd.to_datetime("2015-11-18 15:30:00+05:30")
Out[2]: Timestamp('2015-11-18 10:00:00')

In [3]: pd.Timestamp("2015-11-18 15:30:00+05:30")
Out[3]: Timestamp('2015-11-18 15:30:00+0530', tz='pytz.FixedOffset(330)')

# Different UTC offsets would automatically convert the datetimes to UTC (without a UTC timezone)
In [4]: pd.to_datetime(["2015-11-18 15:30:00+05:30", "2015-11-18 16:30:00+06:30"])
Out[4]: DatetimeIndex(['2015-11-18 10:00:00', '2015-11-18 10:00:00'], dtype='datetime64[ns]', freq=None)

New Behavior:

In [58]: pd.to_datetime("2015-11-18 15:30:00+05:30")
Out[58]: Timestamp('2015-11-18 15:30:00+0530', tz='pytz.FixedOffset(330)')

In [59]: pd.Timestamp("2015-11-18 15:30:00+05:30")
Out[59]: Timestamp('2015-11-18 15:30:00+0530', tz='pytz.FixedOffset(330)')

Parsing datetime strings with the same UTC offset will preserve the UTC offset in the tz

In [60]: pd.to_datetime(["2015-11-18 15:30:00+05:30"] * 2)
Out[60]: DatetimeIndex(['2015-11-18 15:30:00+05:30', '2015-11-18 15:30:00+05:30'], dtype='datetime64[ns, pytz.FixedOffset(330)]', freq=None)

Parsing datetime strings with different UTC offsets will now create an Index of datetime.datetime objects with different UTC offsets

In [61]: idx = pd.to_datetime(["2015-11-18 15:30:00+05:30",
   ....:                       "2015-11-18 16:30:00+06:30"])
   ....: 

In [62]: idx
Out[62]: Index([2015-11-18 15:30:00+05:30, 2015-11-18 16:30:00+06:30], dtype='object')

In [63]: idx[0]
Out[63]: datetime.datetime(2015, 11, 18, 15, 30, tzinfo=tzoffset(None, 19800))

In [64]: idx[1]
Out[64]: datetime.datetime(2015, 11, 18, 16, 30, tzinfo=tzoffset(None, 23400))

Passing utc=True will mimic the previous behavior but will correctly indicate that the dates have been converted to UTC

In [65]: pd.to_datetime(["2015-11-18 15:30:00+05:30",
   ....:                 "2015-11-18 16:30:00+06:30"], utc=True)
   ....: 
Out[65]: DatetimeIndex(['2015-11-18 10:00:00+00:00', '2015-11-18 10:00:00+00:00'], dtype='datetime64[ns, UTC]', freq=None)

Time values in dt.end_time and to_timestamp(how='end')

The time values in Period and PeriodIndex objects are now set to ‘23:59:59.999999999’ when calling Series.dt.end_time, Period.end_time, PeriodIndex.end_time, Period.to_timestamp() with how='end', or PeriodIndex.to_timestamp() with how='end' (GH17157)

Previous Behavior:

In [2]: p = pd.Period('2017-01-01', 'D')
In [3]: pi = pd.PeriodIndex([p])

In [4]: pd.Series(pi).dt.end_time[0]
Out[4]: Timestamp(2017-01-01 00:00:00)

In [5]: p.end_time
Out[5]: Timestamp(2017-01-01 23:59:59.999999999)

New Behavior:

Calling Series.dt.end_time will now result in a time of ‘23:59:59.999999999’ as is the case with Period.end_time, for example

In [66]: p = pd.Period('2017-01-01', 'D')

In [67]: pi = pd.PeriodIndex([p])

In [68]: pd.Series(pi).dt.end_time[0]
Out[68]: Timestamp('2017-01-01 23:59:59.999999999')

In [69]: p.end_time
Out[69]: Timestamp('2017-01-01 23:59:59.999999999')

Datetime w/tz and unique

The return type of Series.unique() for datetime with timezone values has changed from an numpy.ndarray of Timestamp objects to a arrays.DatetimeArray (GH24024).

In [70]: ser = pd.Series([pd.Timestamp('2000', tz='UTC'),
   ....:                  pd.Timestamp('2000', tz='UTC')])
   ....:

Previous Behavior:

In [3]: ser.unique()
Out[3]: array([Timestamp('2000-01-01 00:00:00+0000', tz='UTC')], dtype=object)

New Behavior:

In [71]: ser.unique()
Out[71]: 
<DatetimeArray>
['2000-01-01 00:00:00+00:00']
Length: 1, dtype: datetime64[ns, UTC]

Sparse Data Structure Refactor

SparseArray, the array backing SparseSeries and the columns in a SparseDataFrame, is now an extension array (GH21978, GH19056, GH22835). To conform to this interface and for consistency with the rest of pandas, some API breaking changes were made:

  • SparseArray is no longer a subclass of numpy.ndarray. To convert a SparseArray to a NumPy array, use numpy.asarray().
  • SparseArray.dtype and SparseSeries.dtype are now instances of SparseDtype, rather than np.dtype. Access the underlying dtype with SparseDtype.subtype.
  • numpy.asarray(sparse_array) now returns a dense array with all the values, not just the non-fill-value values (GH14167)
  • SparseArray.take now matches the API of pandas.api.extensions.ExtensionArray.take() (GH19506):
    • The default value of allow_fill has changed from False to True.
    • The out and mode parameters are now longer accepted (previously, this raised if they were specified).
    • Passing a scalar for indices is no longer allowed.
  • The result of concat() with a mix of sparse and dense Series is a Series with sparse values, rather than a SparseSeries.
  • SparseDataFrame.combine and DataFrame.combine_first no longer supports combining a sparse column with a dense column while preserving the sparse subtype. The result will be an object-dtype SparseArray.
  • Setting SparseArray.fill_value to a fill value with a different dtype is now allowed.
  • DataFrame[column] is now a Series with sparse values, rather than a SparseSeries, when slicing a single column with sparse values (GH23559).
  • The result of Series.where() is now a Series with sparse values, like with other extension arrays (GH24077)

Some new warnings are issued for operations that require or are likely to materialize a large dense array:

  • A errors.PerformanceWarning is issued when using fillna with a method, as a dense array is constructed to create the filled array. Filling with a value is the efficient way to fill a sparse array.
  • A errors.PerformanceWarning is now issued when concatenating sparse Series with differing fill values. The fill value from the first sparse array continues to be used.

In addition to these API breaking changes, many Performance Improvements and Bug Fixes have been made.

Finally, a Series.sparse accessor was added to provide sparse-specific methods like Series.sparse.from_coo().

In [72]: s = pd.Series([0, 0, 1, 1, 1], dtype='Sparse[int]')

In [73]: s.sparse.density
Out[73]: 0.6

get_dummies() always returns a DataFrame

Previously, when sparse=True was passed to get_dummies(), the return value could be either a DataFrame or a SparseDataFrame, depending on whether all or a just a subset of the columns were dummy-encoded. Now, a DataFrame is always returned (GH24284).

Previous Behavior

The first get_dummies() returns a DataFrame because the column A is not dummy encoded. When just ["B", "C"] are passed to get_dummies, then all the columns are dummy-encoded, and a SparseDataFrame was returned.

In [2]: df = pd.DataFrame({"A": [1, 2], "B": ['a', 'b'], "C": ['a', 'a']})

In [3]: type(pd.get_dummies(df, sparse=True))
Out[3]: pandas.core.frame.DataFrame

In [4]: type(pd.get_dummies(df[['B', 'C']], sparse=True))
Out[4]: pandas.core.sparse.frame.SparseDataFrame

New Behavior

Now, the return type is consistently a DataFrame.

In [74]: type(pd.get_dummies(df, sparse=True))
Out[74]: pandas.core.frame.DataFrame

In [75]: type(pd.get_dummies(df[['B', 'C']], sparse=True))
Out[75]: pandas.core.sparse.frame.SparseDataFrame

Note

There’s no difference in memory usage between a SparseDataFrame and a DataFrame with sparse values. The memory usage will be the same as in the previous version of pandas.

Raise ValueError in DataFrame.to_dict(orient='index')

Bug in DataFrame.to_dict() raises ValueError when used with orient='index' and a non-unique index instead of losing data (GH22801)

In [76]: df = pd.DataFrame({'a': [1, 2], 'b': [0.5, 0.75]}, index=['A', 'A'])

In [77]: df
Out[77]: 
   a     b
A  1  0.50
A  2  0.75

[2 rows x 2 columns]

In [78]: df.to_dict(orient='index')
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-78-f5309a7c6adb> in <module>
----> 1 df.to_dict(orient='index')

/pandas/pandas/core/frame.py in to_dict(self, orient, into)
   1303             if not self.index.is_unique:
   1304                 raise ValueError(
-> 1305                     "DataFrame index must be unique for orient='index'."
   1306                 )
   1307             return into_c((t[0], dict(zip(self.columns, t[1:])))

ValueError: DataFrame index must be unique for orient='index'.

Tick DateOffset Normalize Restrictions

Creating a Tick object (Day, Hour, Minute, Second, Milli, Micro, Nano) with normalize=True is no longer supported. This prevents unexpected behavior where addition could fail to be monotone or associative. (GH21427)

Previous Behavior:

In [2]: ts = pd.Timestamp('2018-06-11 18:01:14')

In [3]: ts
Out[3]: Timestamp('2018-06-11 18:01:14')

In [4]: tic = pd.offsets.Hour(n=2, normalize=True)
   ...:

In [5]: tic
Out[5]: <2 * Hours>

In [6]: ts + tic
Out[6]: Timestamp('2018-06-11 00:00:00')

In [7]: ts + tic + tic + tic == ts + (tic + tic + tic)
Out[7]: False

New Behavior:

In [79]: ts = pd.Timestamp('2018-06-11 18:01:14')

In [80]: tic = pd.offsets.Hour(n=2)

In [81]: ts + tic + tic + tic == ts + (tic + tic + tic)
Out[81]: True

Period Subtraction

Subtraction of a Period from another Period will give a DateOffset. instead of an integer (GH21314)

Previous Behavior:

In [2]: june = pd.Period('June 2018')

In [3]: april = pd.Period('April 2018')

In [4]: june - april
Out [4]: 2

New Behavior:

In [82]: june = pd.Period('June 2018')

In [83]: april = pd.Period('April 2018')

In [84]: june - april
Out[84]: <2 * MonthEnds>

Similarly, subtraction of a Period from a PeriodIndex will now return an Index of DateOffset objects instead of an Int64Index

Previous Behavior:

In [2]: pi = pd.period_range('June 2018', freq='M', periods=3)

In [3]: pi - pi[0]
Out[3]: Int64Index([0, 1, 2], dtype='int64')

New Behavior:

In [85]: pi = pd.period_range('June 2018', freq='M', periods=3)

In [86]: pi - pi[0]
Out[86]: Index([<0 * MonthEnds>, <MonthEnd>, <2 * MonthEnds>], dtype='object')

Addition/Subtraction of NaN from DataFrame

Adding or subtracting NaN from a DataFrame column with timedelta64[ns] dtype will now raise a TypeError instead of returning all-NaT. This is for compatibility with TimedeltaIndex and Series behavior (GH22163)

In [87]: df = pd.DataFrame([pd.Timedelta(days=1)])

In [88]: df
Out[88]: 
       0
0 1 days

[1 rows x 1 columns]

Previous Behavior:

In [4]: df = pd.DataFrame([pd.Timedelta(days=1)])

In [5]: df - np.nan
Out[5]:
    0
0 NaT

New Behavior:

In [2]: df - np.nan
...
TypeError: unsupported operand type(s) for -: 'TimedeltaIndex' and 'float'

DataFrame Comparison Operations Broadcasting Changes

Previously, the broadcasting behavior of DataFrame comparison operations (==, !=, …) was inconsistent with the behavior of arithmetic operations (+, -, …). The behavior of the comparison operations has been changed to match the arithmetic operations in these cases. (GH22880)

The affected cases are:

  • operating against a 2-dimensional np.ndarray with either 1 row or 1 column will now broadcast the same way a np.ndarray would (GH23000).
  • a list or tuple with length matching the number of rows in the DataFrame will now raise ValueError instead of operating column-by-column (GH22880.
  • a list or tuple with length matching the number of columns in the DataFrame will now operate row-by-row instead of raising ValueError (GH22880).
In [89]: arr = np.arange(6).reshape(3, 2)

In [90]: df = pd.DataFrame(arr)

In [91]: df
Out[91]: 
   0  1
0  0  1
1  2  3
2  4  5

[3 rows x 2 columns]

Previous Behavior:

In [5]: df == arr[[0], :]
    ...: # comparison previously broadcast where arithmetic would raise
Out[5]:
       0      1
0   True   True
1  False  False
2  False  False
In [6]: df + arr[[0], :]
...
ValueError: Unable to coerce to DataFrame, shape must be (3, 2): given (1, 2)

In [7]: df == (1, 2)
    ...: # length matches number of columns;
    ...: # comparison previously raised where arithmetic would broadcast
...
ValueError: Invalid broadcasting comparison [(1, 2)] with block values
In [8]: df + (1, 2)
Out[8]:
   0  1
0  1  3
1  3  5
2  5  7

In [9]: df == (1, 2, 3)
    ...:  # length matches number of rows
    ...:  # comparison previously broadcast where arithmetic would raise
Out[9]:
       0      1
0  False   True
1   True  False
2  False  False
In [10]: df + (1, 2, 3)
...
ValueError: Unable to coerce to Series, length must be 2: given 3

New Behavior:

# Comparison operations and arithmetic operations both broadcast.
In [92]: df == arr[[0], :]
Out[92]: 
       0      1
0   True   True
1  False  False
2  False  False

[3 rows x 2 columns]

In [93]: df + arr[[0], :]
Out[93]: 
   0  1
0  0  2
1  2  4
2  4  6

[3 rows x 2 columns]

# Comparison operations and arithmetic operations both broadcast.
In [94]: df == (1, 2)
Out[94]: 
       0      1
0  False  False
1  False  False
2  False  False

[3 rows x 2 columns]

In [95]: df + (1, 2)
Out[95]: 
   0  1
0  1  3
1  3  5
2  5  7

[3 rows x 2 columns]

# Comparison operations and arithmetic opeartions both raise ValueError.
In [6]: df == (1, 2, 3)
...
ValueError: Unable to coerce to Series, length must be 2: given 3

In [7]: df + (1, 2, 3)
...
ValueError: Unable to coerce to Series, length must be 2: given 3

DataFrame Arithmetic Operations Broadcasting Changes

DataFrame arithmetic operations when operating with 2-dimensional np.ndarray objects now broadcast in the same way as np.ndarray broadcast. (GH23000)

In [96]: arr = np.arange(6).reshape(3, 2)

In [97]: df = pd.DataFrame(arr)

In [98]: df
Out[98]: 
   0  1
0  0  1
1  2  3
2  4  5

[3 rows x 2 columns]

Previous Behavior:

In [5]: df + arr[[0], :]   # 1 row, 2 columns
...
ValueError: Unable to coerce to DataFrame, shape must be (3, 2): given (1, 2)
In [6]: df + arr[:, [1]]   # 1 column, 3 rows
...
ValueError: Unable to coerce to DataFrame, shape must be (3, 2): given (3, 1)

New Behavior:

In [99]: df + arr[[0], :]   # 1 row, 2 columns
Out[99]: 
   0  1
0  0  2
1  2  4
2  4  6

[3 rows x 2 columns]

In [100]: df + arr[:, [1]]   # 1 column, 3 rows
Out[100]: 
   0   1
0  1   2
1  5   6
2  9  10

[3 rows x 2 columns]

ExtensionType Changes

Equality and Hashability

Pandas now requires that extension dtypes be hashable. The base class implements a default __eq__ and __hash__. If you have a parametrized dtype, you should update the ExtensionDtype._metadata tuple to match the signature of your __init__ method. See pandas.api.extensions.ExtensionDtype for more (GH22476).

Reshaping changes

  • dropna() has been added (GH21185)
  • repeat() has been added (GH24349)
  • The ExtensionArray constructor, _from_sequence now take the keyword arg copy=False (GH21185)
  • pandas.api.extensions.ExtensionArray.shift() added as part of the basic ExtensionArray interface (GH22387).
  • searchsorted() has been added (GH24350)
  • Support for reduction operations such as sum, mean via opt-in base class method override (GH22762)
  • ExtensionArray.isna() is allowed to return an ExtensionArray (GH22325).

Dtype changes

  • ExtensionDtype has gained the ability to instantiate from string dtypes, e.g. decimal would instantiate a registered DecimalDtype; furthermore the ExtensionDtype has gained the method construct_array_type (GH21185)
  • Added ExtensionDtype._is_numeric for controlling whether an extension dtype is considered numeric (GH22290).
  • Added pandas.api.types.register_extension_dtype() to register an extension type with pandas (GH22664)
  • Updated the .type attribute for PeriodDtype, DatetimeTZDtype, and IntervalDtype to be instances of the dtype (Period, Timestamp, and Interval respectively) (GH22938)

Other changes

Bug Fixes

Series and Index Data-Dtype Incompatibilities

Series and Index constructors now raise when the data is incompatible with a passed dtype= (GH15832)

Previous Behavior:

In [4]: pd.Series([-1], dtype="uint64")
Out [4]:
0    18446744073709551615
dtype: uint64

New Behavior:

In [4]: pd.Series([-1], dtype="uint64")
Out [4]:
...
OverflowError: Trying to coerce negative values to unsigned integers

Crosstab Preserves Dtypes

crosstab() will preserve now dtypes in some cases that previously would cast from integer dtype to floating dtype (GH22019)

Previous Behavior:

In [3]: df = pd.DataFrame({'a': [1, 2, 2, 2, 2], 'b': [3, 3, 4, 4, 4],
   ...:                    'c': [1, 1, np.nan, 1, 1]})
In [4]: pd.crosstab(df.a, df.b, normalize='columns')
Out[4]:
b    3    4
a
1  0.5  0.0
2  0.5  1.0

New Behavior:

In [3]: df = pd.DataFrame({'a': [1, 2, 2, 2, 2],
   ...:                    'b': [3, 3, 4, 4, 4],
   ...:                    'c': [1, 1, np.nan, 1, 1]})
In [4]: pd.crosstab(df.a, df.b, normalize='columns')

Concatenation Changes

Calling pandas.concat() on a Categorical of ints with NA values now causes them to be processed as objects when concatenating with anything other than another Categorical of ints (GH19214)

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

In [102]: c = pd.Series([0, 1, np.nan], dtype="category")

Previous Behavior

In [3]: pd.concat([s, c])
Out[3]:
0    0.0
1    1.0
2    NaN
0    0.0
1    1.0
2    NaN
dtype: float64

New Behavior

In [103]: pd.concat([s, c])
Out[103]: 
0      0
1      1
2    NaN
0      0
1      1
2    NaN
Length: 6, dtype: object

Datetimelike API Changes

Other API Changes

  • Accessing a level of a MultiIndex with a duplicate name (e.g. in get_level_values()) now raises a ValueError instead of a KeyError (GH21678).
  • Invalid construction of IntervalDtype will now always raise a TypeError rather than a ValueError if the subdtype is invalid (GH21185)
  • Trying to reindex a DataFrame with a non unique MultiIndex now raises a ValueError instead of an Exception (GH21770)
  • Index subtraction will attempt to operate element-wise instead of raising TypeError (GH19369)
  • pandas.io.formats.style.Styler supports a number-format property when using to_excel() (GH22015)
  • DataFrame.corr() and Series.corr() now raise a ValueError along with a helpful error message instead of a KeyError when supplied with an invalid method (GH22298)
  • shift() will now always return a copy, instead of the previous behaviour of returning self when shifting by 0 (GH22397)
  • DataFrame.set_index() now allows all one-dimensional list-likes, raises a TypeError for incorrect types, has an improved KeyError message, and will not fail on duplicate column names with drop=True. (GH22484)
  • Slicing a single row of a DataFrame with multiple ExtensionArrays of the same type now preserves the dtype, rather than coercing to object (GH22784)
  • DateOffset attribute _cacheable and method _should_cache have been removed (GH23118)
  • Series.searchsorted(), when supplied a scalar value to search for, now returns a scalar instead of an array (GH23801).
  • Categorical.searchsorted(), when supplied a scalar value to search for, now returns a scalar instead of an array (GH23466).
  • Categorical.searchsorted() now raises a KeyError rather that a ValueError, if a searched for key is not found in its categories (GH23466).
  • Index.hasnans() and Series.hasnans() now always return a python boolean. Previously, a python or a numpy boolean could be returned, depending on circumstances (GH23294).
  • The order of the arguments of DataFrame.to_html() and DataFrame.to_string() is rearranged to be consistent with each other. (GH23614)
  • CategoricalIndex.reindex() now raises a ValueError if the target index is non-unique and not equal to the current index. It previously only raised if the target index was not of a categorical dtype (GH23963).
  • Series.to_list() and Index.to_list() are now aliases of Series.tolist respectively Index.tolist (GH8826)
  • The result of SparseSeries.unstack is now a DataFrame with sparse values, rather than a SparseDataFrame (issue:24372).

Deprecations

Integer Addition/Subtraction with Datetimes and Timedeltas is Deprecated

In the past, users could—in some cases—add or subtract integers or integer-dtype arrays from Timestamp, DatetimeIndex and TimedeltaIndex.

This usage is now deprecated. Instead add or subtract integer multiples of the object’s freq attribute (GH21939, GH23878).

Previous Behavior:

In [5]: ts = pd.Timestamp('1994-05-06 12:15:16', freq=pd.offsets.Hour())
In [6]: ts + 2
Out[6]: Timestamp('1994-05-06 14:15:16', freq='H')

In [7]: tdi = pd.timedelta_range('1D', periods=2)
In [8]: tdi - np.array([2, 1])
Out[8]: TimedeltaIndex(['-1 days', '1 days'], dtype='timedelta64[ns]', freq=None)

In [9]: dti = pd.date_range('2001-01-01', periods=2, freq='7D')
In [10]: dti + pd.Index([1, 2])
Out[10]: DatetimeIndex(['2001-01-08', '2001-01-22'], dtype='datetime64[ns]', freq=None)

New Behavior:

In [104]: ts = pd.Timestamp('1994-05-06 12:15:16', freq=pd.offsets.Hour())

In [105]: ts + 2 * ts.freq
Out[105]: Timestamp('1994-05-06 14:15:16', freq='H')

In [106]: tdi = pd.timedelta_range('1D', periods=2)

In [107]: tdi - np.array([2 * tdi.freq, 1 * tdi.freq])
Out[107]: TimedeltaIndex(['-1 days', '1 days'], dtype='timedelta64[ns]', freq=None)

In [108]: dti = pd.date_range('2001-01-01', periods=2, freq='7D')

In [109]: dti + pd.Index([1 * dti.freq, 2 * dti.freq])
Out[109]: DatetimeIndex(['2001-01-08', '2001-01-22'], dtype='datetime64[ns]', freq=None)

Passing Integer data and a timezone to DatetimeIndex

The behavior of DatetimeIndex when passed integer data and a timezone is changing in a future version of pandas. Previously, these were interpreted as wall times in the desired timezone. In the future, these will be interpreted as wall times in UTC, which are then converted to the desired timezone (GH24559).

The default behavior remains the same, but issues a warning:

In [3]: pd.DatetimeIndex([946684800000000000], tz="US/Central")
/bin/ipython:1: FutureWarning:
    Passing integer-dtype data and a timezone to DatetimeIndex. Integer values
    will be interpreted differently in a future version of pandas. Previously,
    these were viewed as datetime64[ns] values representing the wall time
    *in the specified timezone*. In the future, these will be viewed as
    datetime64[ns] values representing the wall time *in UTC*. This is similar
    to a nanosecond-precision UNIX epoch. To accept the future behavior, use

        pd.to_datetime(integer_data, utc=True).tz_convert(tz)

    To keep the previous behavior, use

        pd.to_datetime(integer_data).tz_localize(tz)

 #!/bin/python3
 Out[3]: DatetimeIndex(['2000-01-01 00:00:00-06:00'], dtype='datetime64[ns, US/Central]', freq=None)

As the warning message explains, opt in to the future behavior by specifying that the integer values are UTC, and then converting to the final timezone:

In [110]: pd.to_datetime([946684800000000000], utc=True).tz_convert('US/Central')
Out[110]: DatetimeIndex(['1999-12-31 18:00:00-06:00'], dtype='datetime64[ns, US/Central]', freq=None)

The old behavior can be retained with by localizing directly to the final timezone:

In [111]: pd.to_datetime([946684800000000000]).tz_localize('US/Central')
Out[111]: DatetimeIndex(['2000-01-01 00:00:00-06:00'], dtype='datetime64[ns, US/Central]', freq=None)

Converting Timezone-Aware Series and Index to NumPy Arrays

The conversion from a Series or Index with timezone-aware datetime data will change to preserve timezones by default (GH23569).

NumPy doesn’t have a dedicated dtype for timezone-aware datetimes. In the past, converting a Series or DatetimeIndex with timezone-aware datatimes would convert to a NumPy array by

  1. converting the tz-aware data to UTC
  2. dropping the timezone-info
  3. returning a numpy.ndarray with datetime64[ns] dtype

Future versions of pandas will preserve the timezone information by returning an object-dtype NumPy array where each value is a Timestamp with the correct timezone attached

In [112]: ser = pd.Series(pd.date_range('2000', periods=2, tz="CET"))

In [113]: ser
Out[113]: 
0   2000-01-01 00:00:00+01:00
1   2000-01-02 00:00:00+01:00
Length: 2, dtype: datetime64[ns, CET]

The default behavior remains the same, but issues a warning

In [8]: np.asarray(ser)
/bin/ipython:1: FutureWarning: Converting timezone-aware DatetimeArray to timezone-naive
      ndarray with 'datetime64[ns]' dtype. In the future, this will return an ndarray
      with 'object' dtype where each element is a 'pandas.Timestamp' with the correct 'tz'.

        To accept the future behavior, pass 'dtype=object'.
        To keep the old behavior, pass 'dtype="datetime64[ns]"'.
  #!/bin/python3
Out[8]:
array(['1999-12-31T23:00:00.000000000', '2000-01-01T23:00:00.000000000'],
      dtype='datetime64[ns]')

The previous or future behavior can be obtained, without any warnings, by specifying the dtype

Previous Behavior

In [114]: np.asarray(ser, dtype='datetime64[ns]')
Out[114]: array(['1999-12-31T23:00:00.000000000', '2000-01-01T23:00:00.000000000'], dtype='datetime64[ns]')

Future Behavior

# New behavior
In [115]: np.asarray(ser, dtype=object)
Out[115]: 
array([Timestamp('2000-01-01 00:00:00+0100', tz='CET', freq='D'),
       Timestamp('2000-01-02 00:00:00+0100', tz='CET', freq='D')], dtype=object)

Or by using Series.to_numpy()

In [116]: ser.to_numpy()
Out[116]: 
array([Timestamp('2000-01-01 00:00:00+0100', tz='CET', freq='D'),
       Timestamp('2000-01-02 00:00:00+0100', tz='CET', freq='D')], dtype=object)

In [117]: ser.to_numpy(dtype="datetime64[ns]")
Out[117]: array(['1999-12-31T23:00:00.000000000', '2000-01-01T23:00:00.000000000'], dtype='datetime64[ns]')

All the above applies to a DatetimeIndex with tz-aware values as well.

Removal of prior version deprecations/changes

  • The LongPanel and WidePanel classes have been removed (GH10892)
  • Series.repeat() has renamed the reps argument to repeats (GH14645)
  • Several private functions were removed from the (non-public) module pandas.core.common (GH22001)
  • Removal of the previously deprecated module pandas.core.datetools (GH14105, GH14094)
  • Strings passed into DataFrame.groupby() that refer to both column and index levels will raise a ValueError (GH14432)
  • Index.repeat() and MultiIndex.repeat() have renamed the n argument to repeats (GH14645)
  • The Series constructor and .astype method will now raise a ValueError if timestamp dtypes are passed in without a unit (e.g. np.datetime64) for the dtype parameter (GH15987)
  • Removal of the previously deprecated as_indexer keyword completely from str.match() (GH22356, GH6581)
  • The modules pandas.types, pandas.computation, and pandas.util.decorators have been removed (GH16157, GH16250)
  • Removed the pandas.formats.style shim for pandas.io.formats.style.Styler (GH16059)
  • pandas.pnow, pandas.match, pandas.groupby, pd.get_store, pd.Expr, and pd.Term have been removed (GH15538, GH15940)
  • Categorical.searchsorted() and Series.searchsorted() have renamed the v argument to value (GH14645)
  • pandas.parser, pandas.lib, and pandas.tslib have been removed (GH15537)
  • Index.searchsorted() have renamed the key argument to value (GH14645)
  • DataFrame.consolidate and Series.consolidate have been removed (GH15501)
  • Removal of the previously deprecated module pandas.json (GH19944)
  • The module pandas.tools has been removed (GH15358, GH16005)
  • SparseArray.get_values() and SparseArray.to_dense() have dropped the fill parameter (GH14686)
  • DataFrame.sortlevel and Series.sortlevel have been removed (GH15099)
  • SparseSeries.to_dense() has dropped the sparse_only parameter (GH14686)
  • DataFrame.astype() and Series.astype() have renamed the raise_on_error argument to errors (GH14967)
  • is_sequence, is_any_int_dtype, and is_floating_dtype have been removed from pandas.api.types (GH16163, GH16189)

Performance Improvements

Bug Fixes

Categorical

  • Bug in Categorical.from_codes() where NaN values in codes were silently converted to 0 (GH21767). In the future this will raise a ValueError. Also changes the behavior of .from_codes([1.1, 2.0]).
  • Bug in Categorical.sort_values() where NaN values were always positioned in front regardless of na_position value. (GH22556).
  • Bug when indexing with a boolean-valued Categorical. Now a boolean-valued Categorical is treated as a boolean mask (GH22665)
  • Constructing a CategoricalIndex with empty values and boolean categories was raising a ValueError after a change to dtype coercion (GH22702).
  • Bug in Categorical.take() with a user-provided fill_value not encoding the fill_value, which could result in a ValueError, incorrect results, or a segmentation fault (GH23296).
  • In Series.unstack(), specifying a fill_value not present in the categories now raises a TypeError rather than ignoring the fill_value (GH23284)
  • Bug when resampling DataFrame.resample() and aggregating on categorical data, the categorical dtype was getting lost. (GH23227)
  • Bug in many methods of the .str-accessor, which always failed on calling the CategoricalIndex.str constructor (GH23555, GH23556)
  • Bug in Series.where() losing the categorical dtype for categorical data (GH24077)
  • Bug in Categorical.apply() where NaN values could be handled unpredictably. They now remain unchanged (GH24241)
  • Bug in Categorical comparison methods incorrectly raising ValueError when operating against a DataFrame (GH24630)
  • Bug in Categorical.set_categories() where setting fewer new categories with rename=True caused a segmentation fault (GH24675)

Datetimelike

  • Fixed bug where two DateOffset objects with different normalize attributes could evaluate as equal (GH21404)
  • Fixed bug where Timestamp.resolution() incorrectly returned 1-microsecond timedelta instead of 1-nanosecond Timedelta (GH21336, GH21365)
  • Bug in to_datetime() that did not consistently return an Index when box=True was specified (GH21864)
  • Bug in DatetimeIndex comparisons where string comparisons incorrectly raises TypeError (GH22074)
  • Bug in DatetimeIndex comparisons when comparing against timedelta64[ns] dtyped arrays; in some cases TypeError was incorrectly raised, in others it incorrectly failed to raise (GH22074)
  • Bug in DatetimeIndex comparisons when comparing against object-dtyped arrays (GH22074)
  • Bug in DataFrame with datetime64[ns] dtype addition and subtraction with Timedelta-like objects (GH22005, GH22163)
  • Bug in DataFrame with datetime64[ns] dtype addition and subtraction with DateOffset objects returning an object dtype instead of datetime64[ns] dtype (GH21610, GH22163)
  • Bug in DataFrame with datetime64[ns] dtype comparing against NaT incorrectly (GH22242, GH22163)
  • Bug in DataFrame with datetime64[ns] dtype subtracting Timestamp-like object incorrectly returned datetime64[ns] dtype instead of timedelta64[ns] dtype (GH8554, GH22163)
  • Bug in DataFrame with datetime64[ns] dtype subtracting np.datetime64 object with non-nanosecond unit failing to convert to nanoseconds (GH18874, GH22163)
  • Bug in DataFrame comparisons against Timestamp-like objects failing to raise TypeError for inequality checks with mismatched types (GH8932, GH22163)
  • Bug in DataFrame with mixed dtypes including datetime64[ns] incorrectly raising TypeError on equality comparisons (GH13128, GH22163)
  • Bug in DataFrame.values returning a DatetimeIndex for a single-column DataFrame with tz-aware datetime values. Now a 2-D numpy.ndarray of Timestamp objects is returned (GH24024)
  • Bug in DataFrame.eq() comparison against NaT incorrectly returning True or NaN (GH15697, GH22163)
  • Bug in DatetimeIndex subtraction that incorrectly failed to raise OverflowError (GH22492, GH22508)
  • Bug in DatetimeIndex incorrectly allowing indexing with Timedelta object (GH20464)
  • Bug in DatetimeIndex where frequency was being set if original frequency was None (GH22150)
  • Bug in rounding methods of DatetimeIndex (round(), ceil(), floor()) and Timestamp (round(), ceil(), floor()) could give rise to loss of precision (GH22591)
  • Bug in to_datetime() with an Index argument that would drop the name from the result (GH21697)
  • Bug in PeriodIndex where adding or subtracting a timedelta or Tick object produced incorrect results (GH22988)
  • Bug in the Series repr with period-dtype data missing a space before the data (GH23601)
  • Bug in date_range() when decrementing a start date to a past end date by a negative frequency (GH23270)
  • Bug in Series.min() which would return NaN instead of NaT when called on a series of NaT (GH23282)
  • Bug in Series.combine_first() not properly aligning categoricals, so that missing values in self where not filled by valid values from other (GH24147)
  • Bug in DataFrame.combine() with datetimelike values raising a TypeError (GH23079)
  • Bug in date_range() with frequency of Day or higher where dates sufficiently far in the future could wrap around to the past instead of raising OutOfBoundsDatetime (GH14187)
  • Bug in period_range() ignoring the frequency of start and end when those are provided as Period objects (GH20535).
  • Bug in PeriodIndex with attribute freq.n greater than 1 where adding a DateOffset object would return incorrect results (GH23215)
  • Bug in Series that interpreted string indices as lists of characters when setting datetimelike values (GH23451)
  • Bug in DataFrame when creating a new column from an ndarray of Timestamp objects with timezones creating an object-dtype column, rather than datetime with timezone (GH23932)
  • Bug in Timestamp constructor which would drop the frequency of an input Timestamp (GH22311)
  • Bug in DatetimeIndex where calling np.array(dtindex, dtype=object) would incorrectly return an array of long objects (GH23524)
  • Bug in Index where passing a timezone-aware DatetimeIndex and dtype=object would incorrectly raise a ValueError (GH23524)
  • Bug in Index where calling np.array(dtindex, dtype=object) on a timezone-naive DatetimeIndex would return an array of datetime objects instead of Timestamp objects, potentially losing nanosecond portions of the timestamps (GH23524)
  • Bug in Categorical.__setitem__ not allowing setting with another Categorical when both are undordered and have the same categories, but in a different order (GH24142)
  • Bug in date_range() where using dates with millisecond resolution or higher could return incorrect values or the wrong number of values in the index (GH24110)
  • Bug in DatetimeIndex where constructing a DatetimeIndex from a Categorical or CategoricalIndex would incorrectly drop timezone information (GH18664)
  • Bug in DatetimeIndex and TimedeltaIndex where indexing with Ellipsis would incorrectly lose the index’s freq attribute (GH21282)
  • Clarified error message produced when passing an incorrect freq argument to DatetimeIndex with NaT as the first entry in the passed data (GH11587)
  • Bug in to_datetime() where box and utc arguments were ignored when passing a DataFrame or dict of unit mappings (GH23760)
  • Bug in Series.dt where the cache would not update properly after an in-place operation (GH24408)
  • Bug in PeriodIndex where comparisons against an array-like object with length 1 failed to raise ValueError (GH23078)
  • Bug in DatetimeIndex.astype(), PeriodIndex.astype() and TimedeltaIndex.astype() ignoring the sign of the dtype for unsigned integer dtypes (GH24405).
  • Fixed bug in Series.max() with datetime64[ns]-dtype failing to return NaT when nulls are present and skipna=False is passed (GH24265)
  • Bug in to_datetime() where arrays of datetime objects containing both timezone-aware and timezone-naive datetimes would fail to raise ValueError (GH24569)

Timedelta

Timezones

Offsets

  • Bug in FY5253 where date offsets could incorrectly raise an AssertionError in arithmetic operatons (GH14774)
  • Bug in DateOffset where keyword arguments week and milliseconds were accepted and ignored. Passing these will now raise ValueError (GH19398)
  • Bug in adding DateOffset with DataFrame or PeriodIndex incorrectly raising TypeError (GH23215)
  • Bug in comparing DateOffset objects with non-DateOffset objects, particularly strings, raising ValueError instead of returning False for equality checks and True for not-equal checks (GH23524)

Numeric

  • Bug in Series __rmatmul__ doesn’t support matrix vector multiplication (GH21530)
  • Bug in factorize() fails with read-only array (GH12813)
  • Fixed bug in unique() handled signed zeros inconsistently: for some inputs 0.0 and -0.0 were treated as equal and for some inputs as different. Now they are treated as equal for all inputs (GH21866)
  • Bug in DataFrame.agg(), DataFrame.transform() and DataFrame.apply() where, when supplied with a list of functions and axis=1 (e.g. df.apply(['sum', 'mean'], axis=1)), a TypeError was wrongly raised. For all three methods such calculation are now done correctly. (GH16679).
  • Bug in Series comparison against datetime-like scalars and arrays (GH22074)
  • Bug in DataFrame multiplication between boolean dtype and integer returning object dtype instead of integer dtype (GH22047, GH22163)
  • Bug in DataFrame.apply() where, when supplied with a string argument and additional positional or keyword arguments (e.g. df.apply('sum', min_count=1)), a TypeError was wrongly raised (GH22376)
  • Bug in DataFrame.astype() to extension dtype may raise AttributeError (GH22578)
  • Bug in DataFrame with timedelta64[ns] dtype arithmetic operations with ndarray with integer dtype incorrectly treating the narray as timedelta64[ns] dtype (GH23114)
  • Bug in Series.rpow() with object dtype NaN for 1 ** NA instead of 1 (GH22922).
  • Series.agg() can now handle numpy NaN-aware methods like numpy.nansum() (GH19629)
  • Bug in Series.rank() and DataFrame.rank() when pct=True and more than 2:sup:24 rows are present resulted in percentages greater than 1.0 (GH18271)
  • Calls such as DataFrame.round() with a non-unique CategoricalIndex() now return expected data. Previously, data would be improperly duplicated (GH21809).
  • Added log10, floor and ceil to the list of supported functions in DataFrame.eval() (GH24139, GH24353)
  • Logical operations &, |, ^ between Series and Index will no longer raise ValueError (GH22092)
  • Checking PEP 3141 numbers in is_scalar() function returns True (GH22903)
  • Reduction methods like Series.sum() now accept the default value of keepdims=False when called from a NumPy ufunc, rather than raising a TypeError. Full support for keepdims has not been implemented (GH24356).

Conversion

Strings

  • Bug in Index.str.partition() was not nan-safe (GH23558).
  • Bug in Index.str.split() was not nan-safe (GH23677).
  • Bug Series.str.contains() not respecting the na argument for a Categorical dtype Series (GH22158)
  • Bug in Index.str.cat() when the result contained only NaN (GH24044)

Interval

  • Bug in the IntervalIndex constructor where the closed parameter did not always override the inferred closed (GH19370)
  • Bug in the IntervalIndex repr where a trailing comma was missing after the list of intervals (GH20611)
  • Bug in Interval where scalar arithmetic operations did not retain the closed value (GH22313)
  • Bug in IntervalIndex where indexing with datetime-like values raised a KeyError (GH20636)
  • Bug in IntervalTree where data containing NaN triggered a warning and resulted in incorrect indexing queries with IntervalIndex (GH23352)

Indexing

  • Bug in DataFrame.ne() fails if columns contain column name “dtype” (GH22383)
  • The traceback from a KeyError when asking .loc for a single missing label is now shorter and more clear (GH21557)
  • PeriodIndex now emits a KeyError when a malformed string is looked up, which is consistent with the behavior of DatetimeIndex (GH22803)
  • When .ix is asked for a missing integer label in a MultiIndex with a first level of integer type, it now raises a KeyError, consistently with the case of a flat Int64Index, rather than falling back to positional indexing (GH21593)
  • Bug in Index.reindex() when reindexing a tz-naive and tz-aware DatetimeIndex (GH8306)
  • Bug in Series.reindex() when reindexing an empty series with a datetime64[ns, tz] dtype (GH20869)
  • Bug in DataFrame when setting values with .loc and a timezone aware DatetimeIndex (GH11365)
  • DataFrame.__getitem__ now accepts dictionaries and dictionary keys as list-likes of labels, consistently with Series.__getitem__ (GH21294)
  • Fixed DataFrame[np.nan] when columns are non-unique (GH21428)
  • Bug when indexing DatetimeIndex with nanosecond resolution dates and timezones (GH11679)
  • Bug where indexing with a Numpy array containing negative values would mutate the indexer (GH21867)
  • Bug where mixed indexes wouldn’t allow integers for .at (GH19860)
  • Float64Index.get_loc now raises KeyError when boolean key passed. (GH19087)
  • Bug in DataFrame.loc() when indexing with an IntervalIndex (GH19977)
  • Index no longer mangles None, NaN and NaT, i.e. they are treated as three different keys. However, for numeric Index all three are still coerced to a NaN (GH22332)
  • Bug in scalar in Index if scalar is a float while the Index is of integer dtype (GH22085)
  • Bug in MultiIndex.set_levels() when levels value is not subscriptable (GH23273)
  • Bug where setting a timedelta column by Index causes it to be casted to double, and therefore lose precision (GH23511)
  • Bug in Index.union() and Index.intersection() where name of the Index of the result was not computed correctly for certain cases (GH9943, GH9862)
  • Bug in Index slicing with boolean Index may raise TypeError (GH22533)
  • Bug in PeriodArray.__setitem__ when accepting slice and list-like value (GH23978)
  • Bug in DatetimeIndex, TimedeltaIndex where indexing with Ellipsis would lose their freq attribute (GH21282)
  • Bug in iat where using it to assign an incompatible value would create a new column (GH23236)

Missing

  • Bug in DataFrame.fillna() where a ValueError would raise when one column contained a datetime64[ns, tz] dtype (GH15522)
  • Bug in Series.hasnans() that could be incorrectly cached and return incorrect answers if null elements are introduced after an initial call (GH19700)
  • Series.isin() now treats all NaN-floats as equal also for np.object-dtype. This behavior is consistent with the behavior for float64 (GH22119)
  • unique() no longer mangles NaN-floats and the NaT-object for np.object-dtype, i.e. NaT is no longer coerced to a NaN-value and is treated as a different entity. (GH22295)
  • DataFrame() and Series() now properly handle numpy masked arrays with hardened masks. Previously, constructing a DataFrame or Series from a masked array with a hard mask would create a pandas object containing the underlying value, rather than the expected NaN. (GH24574)

MultiIndex

I/O

  • Bug in read_csv() in which a column specified with CategoricalDtype of boolean categories was not being correctly coerced from string values to booleans (GH20498)
  • Bug in DataFrame.to_sql() when writing timezone aware data (datetime64[ns, tz] dtype) would raise a TypeError (GH9086)
  • Bug in DataFrame.to_sql() where a naive DatetimeIndex would be written as TIMESTAMP WITH TIMEZONE type in supported databases, e.g. PostgreSQL (GH23510)
  • Bug in read_excel() when parse_cols is specified with an empty dataset (GH9208)
  • read_html() no longer ignores all-whitespace <tr> within <thead> when considering the skiprows and header arguments. Previously, users had to decrease their header and skiprows values on such tables to work around the issue. (GH21641)
  • read_excel() will correctly show the deprecation warning for previously deprecated sheetname (GH17994)
  • read_csv() and func:read_table() will throw UnicodeError and not coredump on badly encoded strings (GH22748)
  • read_csv() will correctly parse timezone-aware datetimes (GH22256)
  • Bug in read_csv() in which memory management was prematurely optimized for the C engine when the data was being read in chunks (GH23509)
  • Bug in read_csv() in unnamed columns were being improperly identified when extracting a multi-index (GH23687)
  • read_sas() will parse numbers in sas7bdat-files that have width less than 8 bytes correctly. (GH21616)
  • read_sas() will correctly parse sas7bdat files with many columns (GH22628)
  • read_sas() will correctly parse sas7bdat files with data page types having also bit 7 set (so page type is 128 + 256 = 384) (GH16615)
  • Bug in read_sas() in which an incorrect error was raised on an invalid file format. (GH24548)
  • Bug in detect_client_encoding() where potential IOError goes unhandled when importing in a mod_wsgi process due to restricted access to stdout. (GH21552)
  • Bug in DataFrame.to_html() with index=False misses truncation indicators (…) on truncated DataFrame (GH15019, GH22783)
  • Bug in DataFrame.to_html() with index=False when both columns and row index are MultiIndex (GH22579)
  • Bug in DataFrame.to_html() with index_names=False displaying index name (GH22747)
  • Bug in DataFrame.to_html() with header=False not displaying row index names (GH23788)
  • Bug in DataFrame.to_html() with sparsify=False that caused it to raise TypeError (GH22887)
  • Bug in DataFrame.to_string() that broke column alignment when index=False and width of first column’s values is greater than the width of first column’s header (GH16839, GH13032)
  • Bug in DataFrame.to_string() that caused representations of DataFrame to not take up the whole window (GH22984)
  • Bug in DataFrame.to_csv() where a single level MultiIndex incorrectly wrote a tuple. Now just the value of the index is written (GH19589).
  • HDFStore will raise ValueError when the format kwarg is passed to the constructor (GH13291)
  • Bug in HDFStore.append() when appending a DataFrame with an empty string column and min_itemsize < 8 (GH12242)
  • Bug in read_csv() in which memory leaks occurred in the C engine when parsing NaN values due to insufficient cleanup on completion or error (GH21353)
  • Bug in read_csv() in which incorrect error messages were being raised when skipfooter was passed in along with nrows, iterator, or chunksize (GH23711)
  • Bug in read_csv() in which MultiIndex index names were being improperly handled in the cases when they were not provided (GH23484)
  • Bug in read_csv() in which unnecessary warnings were being raised when the dialect’s values conflicted with the default arguments (GH23761)
  • Bug in read_html() in which the error message was not displaying the valid flavors when an invalid one was provided (GH23549)
  • Bug in read_excel() in which extraneous header names were extracted, even though none were specified (GH11733)
  • Bug in read_excel() in which column names were not being properly converted to string sometimes in Python 2.x (GH23874)
  • Bug in read_excel() in which index_col=None was not being respected and parsing index columns anyway (GH18792, GH20480)
  • Bug in read_excel() in which usecols was not being validated for proper column names when passed in as a string (GH20480)
  • Bug in DataFrame.to_dict() when the resulting dict contains non-Python scalars in the case of numeric data (GH23753)
  • DataFrame.to_string(), DataFrame.to_html(), DataFrame.to_latex() will correctly format output when a string is passed as the float_format argument (GH21625, GH22270)
  • Bug in read_csv() that caused it to raise OverflowError when trying to use ‘inf’ as na_value with integer index column (GH17128)
  • Bug in read_fwf() in which the compression type of a file was not being properly inferred (GH22199)
  • Bug in pandas.io.json.json_normalize() that caused it to raise TypeError when two consecutive elements of record_path are dicts (GH22706)
  • Bug in DataFrame.to_stata(), pandas.io.stata.StataWriter and pandas.io.stata.StataWriter117 where a exception would leave a partially written and invalid dta file (GH23573)
  • Bug in DataFrame.to_stata() and pandas.io.stata.StataWriter117 that produced invalid files when using strLs with non-ASCII characters (GH23573)
  • Bug in HDFStore that caused it to raise ValueError when reading a Dataframe in Python 3 from fixed format written in Python 2 (GH24510)

Plotting

Groupby/Resample/Rolling

Reshaping

Sparse

  • Updating a boolean, datetime, or timedelta column to be Sparse now works (GH22367)
  • Bug in Series.to_sparse() with Series already holding sparse data not constructing properly (GH22389)
  • Providing a sparse_index to the SparseArray constructor no longer defaults the na-value to np.nan for all dtypes. The correct na_value for data.dtype is now used.
  • Bug in SparseArray.nbytes under-reporting its memory usage by not including the size of its sparse index.
  • Improved performance of Series.shift() for non-NA fill_value, as values are no longer converted to a dense array.
  • Bug in DataFrame.groupby not including fill_value in the groups for non-NA fill_value when grouping by a sparse column (GH5078)
  • Bug in unary inversion operator (~) on a SparseSeries with boolean values. The performance of this has also been improved (GH22835)
  • Bug in SparseArary.unique() not returning the unique values (GH19595)
  • Bug in SparseArray.nonzero() and SparseDataFrame.dropna() returning shifted/incorrect results (GH21172)
  • Bug in DataFrame.apply() where dtypes would lose sparseness (GH23744)
  • Bug in concat() when concatenating a list of Series with all-sparse values changing the fill_value and converting to a dense Series (GH24371)

Style

  • background_gradient() now takes a text_color_threshold parameter to automatically lighten the text color based on the luminance of the background color. This improves readability with dark background colors without the need to limit the background colormap range. (GH21258)
  • background_gradient() now also supports tablewise application (in addition to rowwise and columnwise) with axis=None (GH15204)
  • bar() now also supports tablewise application (in addition to rowwise and columnwise) with axis=None and setting clipping range with vmin and vmax (GH21548 and GH21526). NaN values are also handled properly.

Build Changes

Other

  • Bug where C variables were declared with external linkage causing import errors if certain other C libraries were imported before Pandas. (GH24113)

Contributors

A total of 334 people contributed patches to this release. People with a “+” by their names contributed a patch for the first time.

  • AJ Dyka +
  • Aaron Critchley
  • Adam Hooper
  • Adam J. Stewart
  • Adam Kim
  • Adam Klimont +
  • Addison Lynch +
  • Alan Hogue +
  • Alex Radu +
  • Alex Rychyk
  • Alex Strick van Linschoten +
  • Alex Volkov +
  • Alexander Buchkovsky
  • Alexander Hess +
  • Alexander Ponomaroff +
  • Allison Browne +
  • Aly Sivji
  • Andrew
  • Andrew Gross +
  • Andrew Spott +
  • Andy +
  • Aniket uttam +
  • Anjali2019 +
  • Anjana S +
  • Antti Kaihola +
  • Anudeep Tubati +
  • Arjun Sharma +
  • Armin Varshokar
  • Artem Bogachev
  • ArtinSarraf +
  • Barry Fitzgerald +
  • Bart Aelterman +
  • Ben James +
  • Ben Nelson +
  • Benjamin Grove +
  • Benjamin Rowell +
  • Benoit Paquet +
  • Boris Lau +
  • Brett Naul
  • Brian Choi +
  • C.A.M. Gerlach +
  • Carl Johan +
  • Chalmer Lowe
  • Chang She
  • Charles David +
  • Cheuk Ting Ho
  • Chris
  • Chris Roberts +
  • Christopher Whelan
  • Chu Qing Hao +
  • Da Cheezy Mobsta +
  • Damini Satya
  • Daniel Himmelstein
  • Daniel Saxton +
  • Darcy Meyer +
  • DataOmbudsman
  • David Arcos
  • David Krych
  • Dean Langsam +
  • Diego Argueta +
  • Diego Torres +
  • Dobatymo +
  • Doug Latornell +
  • Dr. Irv
  • Dylan Dmitri Gray +
  • Eric Boxer +
  • Eric Chea
  • Erik +
  • Erik Nilsson +
  • Fabian Haase +
  • Fabian Retkowski
  • Fabien Aulaire +
  • Fakabbir Amin +
  • Fei Phoon +
  • Fernando Margueirat +
  • Florian Müller +
  • Fábio Rosado +
  • Gabe Fernando
  • Gabriel Reid +
  • Giftlin Rajaiah
  • Gioia Ballin +
  • Gjelt
  • Gosuke Shibahara +
  • Graham Inggs
  • Guillaume Gay
  • Hannah Ferchland
  • Haochen Wu
  • Hubert +
  • HubertKl +
  • HyunTruth +
  • Iain Barr
  • Ignacio Vergara Kausel +
  • Irv Lustig +
  • IsvenC +
  • Jacopo Rota
  • Jakob Jarmar +
  • James Bourbeau +
  • James Myatt +
  • James Winegar +
  • Jan Rudolph
  • Jared Groves +
  • Jason Kiley +
  • Javad Noorbakhsh +
  • Jay Offerdahl +
  • Jeff Reback
  • Jeongmin Yu +
  • Jeremy Schendel
  • Jerod Estapa +
  • Jesper Dramsch +
  • Jim Jeon +
  • Joe Jevnik
  • Joel Nothman
  • Joel Ostblom +
  • Jordi Contestí
  • Jorge López Fueyo +
  • Joris Van den Bossche
  • Jose Quinones +
  • Jose Rivera-Rubio +
  • Josh
  • Jun +
  • Justin Zheng +
  • Kaiqi Dong +
  • Kalyan Gokhale
  • Kang Yoosam +
  • Karl Dunkle Werner +
  • Karmanya Aggarwal +
  • Kevin Markham +
  • Kevin Sheppard
  • Kimi Li +
  • Koustav Samaddar +
  • Krishna +
  • Kristian Holsheimer +
  • Ksenia Gueletina +
  • Kyle Prestel +
  • LJ +
  • LeakedMemory +
  • Li Jin +
  • Licht Takeuchi
  • Luca Donini +
  • Luciano Viola +
  • Mak Sze Chun +
  • Marc Garcia
  • Marius Potgieter +
  • Mark Sikora +
  • Markus Meier +
  • Marlene Silva Marchena +
  • Martin Babka +
  • MatanCohe +
  • Mateusz Woś +
  • Mathew Topper +
  • Matt Boggess +
  • Matt Cooper +
  • Matt Williams +
  • Matthew Gilbert
  • Matthew Roeschke
  • Max Kanter
  • Michael Odintsov
  • Michael Silverstein +
  • Michael-J-Ward +
  • Mickaël Schoentgen +
  • Miguel Sánchez de León Peque +
  • Ming Li
  • Mitar
  • Mitch Negus
  • Monson Shao +
  • Moonsoo Kim +
  • Mortada Mehyar
  • Myles Braithwaite
  • Nehil Jain +
  • Nicholas Musolino +
  • Nicolas Dickreuter +
  • Nikhil Kumar Mengani +
  • Nikoleta Glynatsi +
  • Ondrej Kokes
  • Pablo Ambrosio +
  • Pamela Wu +
  • Parfait G +
  • Patrick Park +
  • Paul
  • Paul Ganssle
  • Paul Reidy
  • Paul van Mulbregt +
  • Phillip Cloud
  • Pietro Battiston
  • Piyush Aggarwal +
  • Prabakaran Kumaresshan +
  • Pulkit Maloo
  • Pyry Kovanen
  • Rajib Mitra +
  • Redonnet Louis +
  • Rhys Parry +
  • Rick +
  • Robin
  • Roei.r +
  • RomainSa +
  • Roman Imankulov +
  • Roman Yurchak +
  • Ruijing Li +
  • Ryan +
  • Ryan Nazareth +
  • Rüdiger Busche +
  • SEUNG HOON, SHIN +
  • Sandrine Pataut +
  • Sangwoong Yoon
  • Santosh Kumar +
  • Saurav Chakravorty +
  • Scott McAllister +
  • Sean Chan +
  • Shadi Akiki +
  • Shengpu Tang +
  • Shirish Kadam +
  • Simon Hawkins +
  • Simon Riddell +
  • Simone Basso
  • Sinhrks
  • Soyoun(Rose) Kim +
  • Srinivas Reddy Thatiparthy (శ్రీనివాస్ రెడ్డి తాటిపర్తి) +
  • Stefaan Lippens +
  • Stefano Cianciulli
  • Stefano Miccoli +
  • Stephen Childs
  • Stephen Pascoe
  • Steve Baker +
  • Steve Cook +
  • Steve Dower +
  • Stéphan Taljaard +
  • Sumin Byeon +
  • Sören +
  • Tamas Nagy +
  • Tanya Jain +
  • Tarbo Fukazawa
  • Thein Oo +
  • Thiago Cordeiro da Fonseca +
  • Thierry Moisan
  • Thiviyan Thanapalasingam +
  • Thomas Lentali +
  • Tim D. Smith +
  • Tim Swast
  • Tom Augspurger
  • Tomasz Kluczkowski +
  • Tony Tao +
  • Triple0 +
  • Troels Nielsen +
  • Tuhin Mahmud +
  • Tyler Reddy +
  • Uddeshya Singh
  • Uwe L. Korn +
  • Vadym Barda +
  • Varad Gunjal +
  • Victor Maryama +
  • Victor Villas
  • Vincent La
  • Vitória Helena +
  • Vu Le
  • Vyom Jain +
  • Weiwen Gu +
  • Wenhuan
  • Wes Turner
  • Wil Tan +
  • William Ayd
  • Yeojin Kim +
  • Yitzhak Andrade +
  • Yuecheng Wu +
  • Yuliya Dovzhenko +
  • Yury Bayda +
  • Zac Hatfield-Dodds +
  • aberres +
  • aeltanawy +
  • ailchau +
  • alimcmaster1
  • alphaCTzo7G +
  • amphy +
  • araraonline +
  • azure-pipelines[bot] +
  • benarthur91 +
  • bk521234 +
  • cgangwar11 +
  • chris-b1
  • cxl923cc +
  • dahlbaek +
  • dannyhyunkim +
  • darke-spirits +
  • david-liu-brattle-1
  • davidmvalente +
  • deflatSOCO
  • doosik_bae +
  • dylanchase +
  • eduardo naufel schettino +
  • euri10 +
  • evangelineliu +
  • fengyqf +
  • fjdiod
  • fl4p +
  • fleimgruber +
  • gfyoung
  • h-vetinari
  • harisbal +
  • henriqueribeiro +
  • himanshu awasthi
  • hongshaoyang +
  • igorfassen +
  • jalazbe +
  • jbrockmendel
  • justinchan23 +
  • louispotok
  • marcosrullan +
  • miker985
  • nicolab100 +
  • nprad
  • nsuresh +
  • ottiP
  • pajachiet +
  • raguiar2 +
  • ratijas +
  • realead +
  • robbuckley +
  • saurav2608 +
  • sideeye +
  • ssikdar1
  • svenharris +
  • syutbai +
  • testvinder +
  • thatneat
  • tmnhat2001
  • tomascassidy +
  • tomneep
  • topper-123
  • vkk800 +
  • winlu +
  • ym-pett +
  • yrhooke +
  • ywpark1 +
  • zertrin
  • zhezherun +
Scroll To Top