# v0.8.0 (June 29, 2012)¶

This is a major release from 0.7.3 and includes extensive work on the time series handling and processing infrastructure as well as a great deal of new functionality throughout the library. It includes over 700 commits from more than 20 distinct authors. Most pandas 0.7.3 and earlier users should not experience any issues upgrading, but due to the migration to the NumPy datetime64 dtype, there may be a number of bugs and incompatibilities lurking. Lingering incompatibilities will be fixed ASAP in a 0.8.1 release if necessary. See the full release notes or issue tracker on GitHub for a complete list.

## Support for non-unique indexes¶

All objects can now work with non-unique indexes. Data alignment / join operations work according to SQL join semantics (including, if application, index duplication in many-to-many joins)

## NumPy datetime64 dtype and 1.6 dependency¶

Time series data are now represented using NumPy’s datetime64 dtype; thus, pandas 0.8.0 now requires at least NumPy 1.6. It has been tested and verified to work with the development version (1.7+) of NumPy as well which includes some significant user-facing API changes. NumPy 1.6 also has a number of bugs having to do with nanosecond resolution data, so I recommend that you steer clear of NumPy 1.6’s datetime64 API functions (though limited as they are) and only interact with this data using the interface that pandas provides.

See the end of the 0.8.0 section for a “porting” guide listing potential issues for users migrating legacy code bases from pandas 0.7 or earlier to 0.8.0.

Bug fixes to the 0.7.x series for legacy NumPy < 1.6 users will be provided as they arise. There will be no more further development in 0.7.x beyond bug fixes.

## Time series changes and improvements¶

Note

With this release, legacy scikits.timeseries users should be able to port their code to use pandas.

Note

See documentation for overview of pandas timeseries API.

New datetime64 representation

**speeds up join operations and data alignment**,**reduces memory usage**, and improve serialization / deserialization performance significantly over datetime.datetimeHigh performance and flexible

**resample**method for converting from high-to-low and low-to-high frequency. Supports interpolation, user-defined aggregation functions, and control over how the intervals and result labeling are defined. A suite of high performance Cython/C-based resampling functions (including Open-High-Low-Close) have also been implemented.Revamp of frequency aliases and support for

**frequency shortcuts**like ‘15min’, or ‘1h30min’New DatetimeIndex class supports both fixed frequency and irregular time series. Replaces now deprecated DateRange class

New

`PeriodIndex`

and`Period`

classes for representing time spans and performing**calendar logic**, including the 12 fiscal quarterly frequencies <timeseries.quarterly>. This is a partial port of, and a substantial enhancement to, elements of the scikits.timeseries code base. Support for conversion between PeriodIndex and DatetimeIndexNew Timestamp data type subclasses datetime.datetime, providing the same interface while enabling working with nanosecond-resolution data. Also provides easy time zone conversions.

Enhanced support for time zones. Add tz_convert and

`tz_lcoalize`

methods to TimeSeries and DataFrame. All timestamps are stored as UTC; Timestamps from DatetimeIndex objects with time zone set will be localized to local time. Time zone conversions are therefore essentially free. User needs to know very little about pytz library now; only time zone names as as strings are required. Time zone-aware timestamps are equal if and only if their UTC timestamps match. Operations between time zone-aware time series with different time zones will result in a UTC-indexed time series.Time series

**string indexing conveniences**/ shortcuts: slice years, year and month, and index values with stringsEnhanced time series

**plotting**; adaptation of scikits.timeseries matplotlib-based plotting codeNew

`date_range`

,`bdate_range`

, and`period_range`

factory functionsRobust

**frequency inference**function infer_freq and`inferred_freq`

property of DatetimeIndex, with option to infer frequency on construction of DatetimeIndexto_datetime function efficiently

**parses array of strings**to DatetimeIndex. DatetimeIndex will parse array or list of strings to datetime64**Optimized**support for datetime64-dtype data in Series and DataFrame columnsNew NaT (Not-a-Time) type to represent

**NA**in timestamp arraysOptimize Series.asof for looking up

**“as of” values**for arrays of timestampsMilli, Micro, Nano date offset objects

Can index time series with datetime.time objects to select all data at particular

**time of day**(`TimeSeries.at_time`

) or**between two times**(`TimeSeries.between_time`

)Add tshift method for leading/lagging using the frequency (if any) of the index, as opposed to a naive lead/lag using shift

## Other new features¶

New cut and

`qcut`

functions (like R’s cut function) for computing a categorical variable from a continuous variable by binning values either into value-based (`cut`

) or quantile-based (`qcut`

) binsRename

`Factor`

to`Categorical`

and add a number of usability featuresAdd limit argument to fillna/reindex

More flexible multiple function application in GroupBy, and can pass list (name, function) tuples to get result in particular order with given names

Add flexible replace method for efficiently substituting values

Enhanced read_csv/read_table for reading time series data and converting multiple columns to dates

Add comments option to parser functions: read_csv, etc.

Add dayfirst option to parser functions for parsing international DD/MM/YYYY dates

Allow the user to specify the CSV reader dialect to control quoting etc.

Handling thousands separators in read_csv to improve integer parsing.

Enable unstacking of multiple levels in one shot. Alleviate

`pivot_table`

bugs (empty columns being introduced)Move to klib-based hash tables for indexing; better performance and less memory usage than Python’s dict

Add first, last, min, max, and prod optimized GroupBy functions

New ordered_merge function

Add flexible comparison instance methods eq, ne, lt, gt, etc. to DataFrame, Series

Improve scatter_matrix plotting function and add histogram or kernel density estimates to diagonal

Add ‘kde’ plot option for density plots

Support for converting DataFrame to R data.frame through rpy2

Improved support for complex numbers in Series and DataFrame

Add pct_change method to all data structures

Add max_colwidth configuration option for DataFrame console output

Interpolate Series values using index values

Can select multiple columns from GroupBy

Add update methods to Series/DataFrame for updating values in place

Add

`any`

and`all`

method to DataFrame

## New plotting methods¶

`Series.plot`

now supports a `secondary_y`

option:

```
In [1]: plt.figure()
Out[1]: <Figure size 640x480 with 0 Axes>
In [2]: fx['FR'].plot(style='g')
Out[2]: <matplotlib.axes._subplots.AxesSubplot at 0x7ff51b9c1f28>
In [3]: fx['IT'].plot(style='k--', secondary_y=True)
Out[3]: <matplotlib.axes._subplots.AxesSubplot at 0x7ff51b9c1dd8>
```

Vytautas Jancauskas, the 2012 GSOC participant, has added many new plot
types. For example, `'kde'`

is a new option:

```
In [4]: s = pd.Series(np.concatenate((np.random.randn(1000),
...: np.random.randn(1000) * 0.5 + 3)))
...:
In [5]: plt.figure()
Out[5]: <Figure size 640x480 with 0 Axes>
In [6]: s.hist(density=True, alpha=0.2)
Out[6]: <matplotlib.axes._subplots.AxesSubplot at 0x7ff51b95dd30>
In [7]: s.plot(kind='kde')
Out[7]: <matplotlib.axes._subplots.AxesSubplot at 0x7ff51b95dd30>
```

See the plotting page for much more.

## Other API changes¶

Deprecation of

`offset`

,`time_rule`

, and`timeRule`

arguments names in time series functions. Warnings will be printed until pandas 0.9 or 1.0.

## Potential porting issues for pandas <= 0.7.3 users¶

The major change that may affect you in pandas 0.8.0 is that time series
indexes use NumPy’s `datetime64`

data type instead of `dtype=object`

arrays
of Python’s built-in `datetime.datetime`

objects. `DateRange`

has been
replaced by `DatetimeIndex`

but otherwise behaved identically. But, if you
have code that converts `DateRange`

or `Index`

objects that used to contain
`datetime.datetime`

values to plain NumPy arrays, you may have bugs lurking
with code using scalar values because you are handing control over to NumPy:

```
In [8]: import datetime
In [9]: rng = pd.date_range('1/1/2000', periods=10)
In [10]: rng[5]
Out[10]: Timestamp('2000-01-06 00:00:00', freq='D')
In [11]: isinstance(rng[5], datetime.datetime)
Out[11]: True
In [12]: rng_asarray = np.asarray(rng)
In [13]: scalar_val = rng_asarray[5]
In [14]: type(scalar_val)
Out[14]: numpy.datetime64
```

pandas’s `Timestamp`

object is a subclass of `datetime.datetime`

that has
nanosecond support (the `nanosecond`

field store the nanosecond value between
0 and 999). It should substitute directly into any code that used
`datetime.datetime`

values before. Thus, I recommend not casting
`DatetimeIndex`

to regular NumPy arrays.

If you have code that requires an array of `datetime.datetime`

objects, you
have a couple of options. First, the `astype(object)`

method of `DatetimeIndex`

produces an array of `Timestamp`

objects:

```
In [15]: stamp_array = rng.astype(object)
In [16]: stamp_array
Out[16]:
Index([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, 2000-01-06 00:00:00,
2000-01-07 00:00:00, 2000-01-08 00:00:00, 2000-01-09 00:00:00,
2000-01-10 00:00:00],
dtype='object')
In [17]: stamp_array[5]
Out[17]: Timestamp('2000-01-06 00:00:00', freq='D')
```

To get an array of proper `datetime.datetime`

objects, use the
`to_pydatetime`

method:

```
In [18]: dt_array = rng.to_pydatetime()
In [19]: dt_array
Out[19]:
array([datetime.datetime(2000, 1, 1, 0, 0),
datetime.datetime(2000, 1, 2, 0, 0),
datetime.datetime(2000, 1, 3, 0, 0),
datetime.datetime(2000, 1, 4, 0, 0),
datetime.datetime(2000, 1, 5, 0, 0),
datetime.datetime(2000, 1, 6, 0, 0),
datetime.datetime(2000, 1, 7, 0, 0),
datetime.datetime(2000, 1, 8, 0, 0),
datetime.datetime(2000, 1, 9, 0, 0),
datetime.datetime(2000, 1, 10, 0, 0)], dtype=object)
In [20]: dt_array[5]
Out[20]: datetime.datetime(2000, 1, 6, 0, 0)
```

matplotlib knows how to handle `datetime.datetime`

but not Timestamp
objects. While I recommend that you plot time series using `TimeSeries.plot`

,
you can either use `to_pydatetime`

or register a converter for the Timestamp
type. See matplotlib documentation for more on this.

Warning

There are bugs in the user-facing API with the nanosecond datetime64 unit
in NumPy 1.6. In particular, the string version of the array shows garbage
values, and conversion to `dtype=object`

is similarly broken.

```
In [21]: rng = pd.date_range('1/1/2000', periods=10)
In [22]: rng
Out[22]:
DatetimeIndex(['2000-01-01', '2000-01-02', '2000-01-03', '2000-01-04',
'2000-01-05', '2000-01-06', '2000-01-07', '2000-01-08',
'2000-01-09', '2000-01-10'],
dtype='datetime64[ns]', freq='D')
In [23]: np.asarray(rng)
Out[23]:
array(['2000-01-01T00:00:00.000000000', '2000-01-02T00:00:00.000000000',
'2000-01-03T00:00:00.000000000', '2000-01-04T00:00:00.000000000',
'2000-01-05T00:00:00.000000000', '2000-01-06T00:00:00.000000000',
'2000-01-07T00:00:00.000000000', '2000-01-08T00:00:00.000000000',
'2000-01-09T00:00:00.000000000', '2000-01-10T00:00:00.000000000'],
dtype='datetime64[ns]')
In [24]: converted = np.asarray(rng, dtype=object)
In [25]: converted[5]
Out[25]: Timestamp('2000-01-06 00:00:00', freq='D')
```

**Trust me: don’t panic**. If you are using NumPy 1.6 and restrict your
interaction with `datetime64`

values to pandas’s API you will be just
fine. There is nothing wrong with the data-type (a 64-bit integer
internally); all of the important data processing happens in pandas and is
heavily tested. I strongly recommend that you **do not work directly with
datetime64 arrays in NumPy 1.6** and only use the pandas API.

**Support for non-unique indexes**: In the latter case, you may have code
inside a `try:... catch:`

block that failed due to the index not being
unique. In many cases it will no longer fail (some method like `append`

still
check for uniqueness unless disabled). However, all is not lost: you can
inspect `index.is_unique`

and raise an exception explicitly if it is
`False`

or go to a different code branch.