Merge branch 'master' of https://github.com/pandas-dev/pandas into per_array

Author: jbrockmendel

asv_bench/benchmarks/categoricals.py

@@ -193,3 +193,20 @@ def time_categorical_series_is_monotonic_increasing(self):
 
  def time_categorical_series_is_monotonic_decreasing(self):
  self.s.is_monotonic_decreasing
+
+
+class Contains(object):
+
+ goal_time = 0.2
+
+ def setup(self):
+ N = 10**5
+ self.ci = tm.makeCategoricalIndex(N)
+ self.c = self.ci.values
+ self.key = self.ci.categories[0]
+
+ def time_categorical_index_contains(self):
+ self.key in self.ci
+
+ def time_categorical_contains(self):
+ self.key in self.c

asv_bench/benchmarks/groupby.py

@@ -5,7 +5,7 @@
 
 import numpy as np
 from pandas import (DataFrame, Series, MultiIndex, date_range, period_range,
- TimeGrouper, Categorical)
+ TimeGrouper, Categorical, Timestamp)
 import pandas.util.testing as tm
 
 from .pandas_vb_common import setup # noqa
@@ -385,6 +385,25 @@ def time_dtype_as_field(self, dtype, method, application):
  self.as_field_method()
 
 
+class RankWithTies(object):
+ # GH 21237
+ goal_time = 0.2
+ param_names = ['dtype', 'tie_method']
+ params = [['float64', 'float32', 'int64', 'datetime64'],
+ ['first', 'average', 'dense', 'min', 'max']]
+
+ def setup(self, dtype, tie_method):
+ N = 10**4
+ if dtype == 'datetime64':
+ data = np.array([Timestamp("2011/01/01")] * N, dtype=dtype)
+ else:
+ data = np.array([1] * N, dtype=dtype)
+ self.df = DataFrame({'values': data, 'key': ['foo'] * N})
+
+ def time_rank_ties(self, dtype, tie_method):
+ self.df.groupby('key').rank(method=tie_method)
+
+
 class Float32(object):
  # GH 13335
  goal_time = 0.2

ci/environment-dev.yaml

@@ -13,3 +13,4 @@ dependencies:
  - pytz
  - setuptools>=24.2.0
  - sphinx
+ - sphinxcontrib-spelling

ci/requirements_dev.txt

@@ -9,3 +9,4 @@ python-dateutil>=2.5.0
 pytz
 setuptools>=24.2.0
 sphinx
+sphinxcontrib-spelling

doc/source/_static/favicon.ico

@@ -1200,9 +1200,9 @@ Attributes and underlying data
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 **Axes**
 
- * **items**: axis 0; each item corresponds to a DataFrame contained inside
- * **major_axis**: axis 1; the index (rows) of each of the DataFrames
- * **minor_axis**: axis 2; the columns of each of the DataFrames
+* **items**: axis 0; each item corresponds to a DataFrame contained inside
+* **major_axis**: axis 1; the index (rows) of each of the DataFrames
+* **minor_axis**: axis 2; the columns of each of the DataFrames
 
 .. autosummary::
  :toctree: generated/

doc/source/api.rst

@@ -50,9 +50,8 @@ Attributes and the raw ndarray(s)
 
 pandas objects have a number of attributes enabling you to access the metadata
 
- * **shape**: gives the axis dimensions of the object, consistent with ndarray
- * Axis labels
-
+* **shape**: gives the axis dimensions of the object, consistent with ndarray
+* Axis labels
  * **Series**: *index* (only axis)
  * **DataFrame**: *index* (rows) and *columns*
  * **Panel**: *items*, *major_axis*, and *minor_axis*
@@ -131,9 +130,9 @@ Flexible binary operations
 With binary operations between pandas data structures, there are two key points
 of interest:
 
- * Broadcasting behavior between higher- (e.g. DataFrame) and
-  lower-dimensional (e.g. Series) objects.
- * Missing data in computations.
+* Broadcasting behavior between higher- (e.g. DataFrame) and
+ lower-dimensional (e.g. Series) objects.
+* Missing data in computations.
 
 We will demonstrate how to manage these issues independently, though they can
 be handled simultaneously.
@@ -462,10 +461,10 @@ produce an object of the same size. Generally speaking, these methods take an
 **axis** argument, just like *ndarray.{sum, std, ...}*, but the axis can be
 specified by name or integer:
 
- - **Series**: no axis argument needed
- - **DataFrame**: "index" (axis=0, default), "columns" (axis=1)
- - **Panel**: "items" (axis=0), "major" (axis=1, default), "minor"
-  (axis=2)
+* **Series**: no axis argument needed
+* **DataFrame**: "index" (axis=0, default), "columns" (axis=1)
+* **Panel**: "items" (axis=0), "major" (axis=1, default), "minor"
+ (axis=2)
 
 For example:
 
@@ -1187,11 +1186,11 @@ It is used to implement nearly all other features relying on label-alignment
 functionality. To *reindex* means to conform the data to match a given set of
 labels along a particular axis. This accomplishes several things:
 
- * Reorders the existing data to match a new set of labels
- * Inserts missing value (NA) markers in label locations where no data for
-  that label existed
- * If specified, **fill** data for missing labels using logic (highly relevant
-  to working with time series data)
+* Reorders the existing data to match a new set of labels
+* Inserts missing value (NA) markers in label locations where no data for
+ that label existed
+* If specified, **fill** data for missing labels using logic (highly relevant
+ to working with time series data)
 
 Here is a simple example:
 
@@ -1911,10 +1910,10 @@ the axis indexes, since they are immutable) and returns a new object. Note that
 **it is seldom necessary to copy objects**. For example, there are only a
 handful of ways to alter a DataFrame *in-place*:
 
- * Inserting, deleting, or modifying a column.
- * Assigning to the ``index`` or ``columns`` attributes.
- * For homogeneous data, directly modifying the values via the ``values``
-  attribute or advanced indexing.
+* Inserting, deleting, or modifying a column.
+* Assigning to the ``index`` or ``columns`` attributes.
+* For homogeneous data, directly modifying the values via the ``values``
+ attribute or advanced indexing.
 
 To be clear, no pandas method has the side effect of modifying your data;
 almost every method returns a new object, leaving the original object
@@ -2112,22 +2111,22 @@ Because the data was transposed the original inference stored all columns as obj
 The following functions are available for one dimensional object arrays or scalars to perform
 hard conversion of objects to a specified type:
 
-- :meth:`~pandas.to_numeric` (conversion to numeric dtypes)
+* :meth:`~pandas.to_numeric` (conversion to numeric dtypes)
 
  .. ipython:: python
 
  m = ['1.1', 2, 3]
  pd.to_numeric(m)
 
-- :meth:`~pandas.to_datetime` (conversion to datetime objects)
+* :meth:`~pandas.to_datetime` (conversion to datetime objects)
 
  .. ipython:: python
 
  import datetime
  m = ['2016-07-09', datetime.datetime(2016, 3, 2)]
  pd.to_datetime(m)
 
-- :meth:`~pandas.to_timedelta` (conversion to timedelta objects)
+* :meth:`~pandas.to_timedelta` (conversion to timedelta objects)
 
  .. ipython:: python
 

doc/source/basics.rst

@@ -542,11 +542,11 @@ Comparisons
 
 Comparing categorical data with other objects is possible in three cases:
 
- * Comparing equality (``==`` and ``!=``) to a list-like object (list, Series, array,
-  ...) of the same length as the categorical data.
- * All comparisons (``==``, ``!=``, ``>``, ``>=``, ``<``, and ``<=``) of categorical data to
-  another categorical Series, when ``ordered==True`` and the `categories` are the same.
- * All comparisons of a categorical data to a scalar.
+* Comparing equality (``==`` and ``!=``) to a list-like object (list, Series, array,
+ ...) of the same length as the categorical data.
+* All comparisons (``==``, ``!=``, ``>``, ``>=``, ``<``, and ``<=``) of categorical data to
+ another categorical Series, when ``ordered==True`` and the `categories` are the same.
+* All comparisons of a categorical data to a scalar.
 
 All other comparisons, especially "non-equality" comparisons of two categoricals with different
 categories or a categorical with any list-like object, will raise a ``TypeError``.

doc/source/categorical.rst

@@ -18,11 +18,11 @@ was started to provide a more detailed look at the `R language
 party libraries as they relate to ``pandas``. In comparisons with R and CRAN
 libraries, we care about the following things:
 
- - **Functionality / flexibility**: what can/cannot be done with each tool
- - **Performance**: how fast are operations. Hard numbers/benchmarks are
-  preferable
- - **Ease-of-use**: Is one tool easier/harder to use (you may have to be
-  the judge of this, given side-by-side code comparisons)
+* **Functionality / flexibility**: what can/cannot be done with each tool
+* **Performance**: how fast are operations. Hard numbers/benchmarks are
+ preferable
+* **Ease-of-use**: Is one tool easier/harder to use (you may have to be
+ the judge of this, given side-by-side code comparisons)
 
 This page is also here to offer a bit of a translation guide for users of these
 R packages.

doc/source/comparison_with_r.rst

@@ -344,20 +344,20 @@ The weights used in the window are specified by the ``win_type`` keyword.
 The list of recognized types are the `scipy.signal window functions
 <https://docs.scipy.org/doc/scipy/reference/signal.html#window-functions>`__:
 
-- ``boxcar``
-- ``triang``
-- ``blackman``
-- ``hamming``
-- ``bartlett``
-- ``parzen``
-- ``bohman``
-- ``blackmanharris``
-- ``nuttall``
-- ``barthann``
-- ``kaiser`` (needs beta)
-- ``gaussian`` (needs std)
-- ``general_gaussian`` (needs power, width)
-- ``slepian`` (needs width).
+* ``boxcar``
+* ``triang``
+* ``blackman``
+* ``hamming``
+* ``bartlett``
+* ``parzen``
+* ``bohman``
+* ``blackmanharris``
+* ``nuttall``
+* ``barthann``
+* ``kaiser`` (needs beta)
+* ``gaussian`` (needs std)
+* ``general_gaussian`` (needs power, width)
+* ``slepian`` (needs width).
 
 .. ipython:: python
 
@@ -537,10 +537,10 @@ Binary Window Functions
 two ``Series`` or any combination of ``DataFrame/Series`` or
 ``DataFrame/DataFrame``. Here is the behavior in each case:
 
-- two ``Series``: compute the statistic for the pairing.
-- ``DataFrame/Series``: compute the statistics for each column of the DataFrame
+* two ``Series``: compute the statistic for the pairing.
+* ``DataFrame/Series``: compute the statistics for each column of the DataFrame
  with the passed Series, thus returning a DataFrame.
-- ``DataFrame/DataFrame``: by default compute the statistic for matching column
+* ``DataFrame/DataFrame``: by default compute the statistic for matching column
  names, returning a DataFrame. If the keyword argument ``pairwise=True`` is
  passed then computes the statistic for each pair of columns, returning a
  ``MultiIndexed DataFrame`` whose ``index`` are the dates in question (see :ref:`the next section
@@ -741,10 +741,10 @@ Aside from not having a ``window`` parameter, these functions have the same
 interfaces as their ``.rolling`` counterparts. Like above, the parameters they
 all accept are:
 
-- ``min_periods``: threshold of non-null data points to require. Defaults to
+* ``min_periods``: threshold of non-null data points to require. Defaults to
  minimum needed to compute statistic. No ``NaNs`` will be output once
  ``min_periods`` non-null data points have been seen.
-- ``center``: boolean, whether to set the labels at the center (default is False).
+* ``center``: boolean, whether to set the labels at the center (default is False).
 
 .. _stats.moments.expanding.note:
 .. note::
@@ -903,12 +903,12 @@ of an EW moment:
 One must specify precisely one of **span**, **center of mass**, **half-life**
 and **alpha** to the EW functions:
 
-- **Span** corresponds to what is commonly called an "N-day EW moving average".
-- **Center of mass** has a more physical interpretation and can be thought of
+* **Span** corresponds to what is commonly called an "N-day EW moving average".
+* **Center of mass** has a more physical interpretation and can be thought of
  in terms of span: :math:`c = (s - 1) / 2`.
-- **Half-life** is the period of time for the exponential weight to reduce to
+* **Half-life** is the period of time for the exponential weight to reduce to
  one half.
-- **Alpha** specifies the smoothing factor directly.
+* **Alpha** specifies the smoothing factor directly.
 
 Here is an example for a univariate time series: