Merge branch 'master' into fix_17415

Author: mroeschke

asv_bench/benchmarks/gil.py

@@ -180,19 +180,35 @@ def setup(self, method):
             raise NotImplementedError
         win = 100
         arr = np.random.rand(100000)
-        rolling = {'rolling_median': rolling_median,
-                   'rolling_mean': rolling_mean,
-                   'rolling_min': rolling_min,
-                   'rolling_max': rolling_max,
-                   'rolling_var': rolling_var,
-                   'rolling_skew': rolling_skew,
-                   'rolling_kurt': rolling_kurt,
-                   'rolling_std': rolling_std}
-
-        @test_parallel(num_threads=2)
-        def parallel_rolling():
-            rolling[method](arr, win)
-        self.parallel_rolling = parallel_rolling
+        if hasattr(DataFrame, 'rolling'):
+            rolling = {'rolling_median': 'median',
+                       'rolling_mean': 'mean',
+                       'rolling_min': 'min',
+                       'rolling_max': 'max',
+                       'rolling_var': 'var',
+                       'rolling_skew': 'skew',
+                       'rolling_kurt': 'kurt',
+                       'rolling_std': 'std'}
+            df = DataFrame(arr).rolling(win)
+
+            @test_parallel(num_threads=2)
+            def parallel_rolling():
+                getattr(df, rolling[method])()
+            self.parallel_rolling = parallel_rolling
+        else:
+            rolling = {'rolling_median': rolling_median,
+                       'rolling_mean': rolling_mean,
+                       'rolling_min': rolling_min,
+                       'rolling_max': rolling_max,
+                       'rolling_var': rolling_var,
+                       'rolling_skew': rolling_skew,
+                       'rolling_kurt': rolling_kurt,
+                       'rolling_std': rolling_std}
+
+            @test_parallel(num_threads=2)
+            def parallel_rolling():
+                rolling[method](arr, win)
+            self.parallel_rolling = parallel_rolling
 
     def time_rolling(self, method):
         self.parallel_rolling()

asv_bench/benchmarks/rolling.py

@@ -1,185 +1,41 @@
-from .pandas_vb_common import *
 import pandas as pd
 import numpy as np
 
+from .pandas_vb_common import setup  # noqa
 
-class DataframeRolling(object):
-    goal_time = 0.2
 
-    def setup(self):
-        self.N = 100000
-        self.Ns = 10000
-        self.df = pd.DataFrame({'a': np.random.random(self.N)})
-        self.dfs = pd.DataFrame({'a': np.random.random(self.Ns)})
-        self.wins = 10
-        self.winl = 1000
+class Methods(object):
 
-    def time_rolling_quantile_0(self):
-        (self.df.rolling(self.wins).quantile(0.0))
+    sample_time = 0.2
+    params = (['DataFrame', 'Series'],
+              [10, 1000],
+              ['int', 'float'],
+              ['median', 'mean', 'max', 'min', 'std', 'count', 'skew', 'kurt',
+               'sum', 'corr', 'cov'])
+    param_names = ['contructor', 'window', 'dtype', 'method']
 
-    def time_rolling_quantile_1(self):
-        (self.df.rolling(self.wins).quantile(1.0))
+    def setup(self, contructor, window, dtype, method):
+        N = 10**5
+        arr = np.random.random(N).astype(dtype)
+        self.roll = getattr(pd, contructor)(arr).rolling(window)
 
-    def time_rolling_quantile_median(self):
-        (self.df.rolling(self.wins).quantile(0.5))
+    def time_rolling(self, contructor, window, dtype, method):
+        getattr(self.roll, method)()
 
-    def time_rolling_median(self):
-        (self.df.rolling(self.wins).median())
 
-    def time_rolling_mean(self):
-        (self.df.rolling(self.wins).mean())
+class Quantile(object):
 
-    def time_rolling_max(self):
-        (self.df.rolling(self.wins).max())
+    sample_time = 0.2
+    params = (['DataFrame', 'Series'],
+              [10, 1000],
+              ['int', 'float'],
+              [0, 0.5, 1])
+    param_names = ['contructor', 'window', 'dtype', 'percentile']
 
-    def time_rolling_min(self):
-        (self.df.rolling(self.wins).min())
+    def setup(self, contructor, window, dtype, percentile):
+        N = 10**5
+        arr = np.random.random(N).astype(dtype)
+        self.roll = getattr(pd, contructor)(arr).rolling(window)
 
-    def time_rolling_std(self):
-        (self.df.rolling(self.wins).std())
-
-    def time_rolling_count(self):
-        (self.df.rolling(self.wins).count())
-
-    def time_rolling_skew(self):
-        (self.df.rolling(self.wins).skew())
-
-    def time_rolling_kurt(self):
-        (self.df.rolling(self.wins).kurt())
-
-    def time_rolling_sum(self):
-        (self.df.rolling(self.wins).sum())
-
-    def time_rolling_corr(self):
-        (self.dfs.rolling(self.wins).corr())
-
-    def time_rolling_cov(self):
-        (self.dfs.rolling(self.wins).cov())
-        
-    def time_rolling_quantile_0_l(self):
-        (self.df.rolling(self.winl).quantile(0.0))
-
-    def time_rolling_quantile_1_l(self):
-        (self.df.rolling(self.winl).quantile(1.0))
-
-    def time_rolling_quantile_median_l(self):
-        (self.df.rolling(self.winl).quantile(0.5))
-
-    def time_rolling_median_l(self):
-        (self.df.rolling(self.winl).median())
-
-    def time_rolling_mean_l(self):
-        (self.df.rolling(self.winl).mean())
-
-    def time_rolling_max_l(self):
-        (self.df.rolling(self.winl).max())
-
-    def time_rolling_min_l(self):
-        (self.df.rolling(self.winl).min())
-
-    def time_rolling_std_l(self):
-        (self.df.rolling(self.wins).std())
-
-    def time_rolling_count_l(self):
-        (self.df.rolling(self.wins).count())
-
-    def time_rolling_skew_l(self):
-        (self.df.rolling(self.wins).skew())
-
-    def time_rolling_kurt_l(self):
-        (self.df.rolling(self.wins).kurt())
-
-    def time_rolling_sum_l(self):
-        (self.df.rolling(self.wins).sum())
-
-
-class SeriesRolling(object):
-    goal_time = 0.2
-
-    def setup(self):
-        self.N = 100000
-        self.Ns = 10000
-        self.df = pd.DataFrame({'a': np.random.random(self.N)})
-        self.dfs = pd.DataFrame({'a': np.random.random(self.Ns)})
-        self.sr = self.df.a
-        self.srs = self.dfs.a
-        self.wins = 10
-        self.winl = 1000
-
-    def time_rolling_quantile_0(self):
-        (self.sr.rolling(self.wins).quantile(0.0))
-
-    def time_rolling_quantile_1(self):
-        (self.sr.rolling(self.wins).quantile(1.0))
-
-    def time_rolling_quantile_median(self):
-        (self.sr.rolling(self.wins).quantile(0.5))
-
-    def time_rolling_median(self):
-        (self.sr.rolling(self.wins).median())
-
-    def time_rolling_mean(self):
-        (self.sr.rolling(self.wins).mean())
-
-    def time_rolling_max(self):
-        (self.sr.rolling(self.wins).max())
-
-    def time_rolling_min(self):
-        (self.sr.rolling(self.wins).min())
-
-    def time_rolling_std(self):
-        (self.sr.rolling(self.wins).std())
-
-    def time_rolling_count(self):
-        (self.sr.rolling(self.wins).count())
-
-    def time_rolling_skew(self):
-        (self.sr.rolling(self.wins).skew())
-
-    def time_rolling_kurt(self):
-        (self.sr.rolling(self.wins).kurt())
-
-    def time_rolling_sum(self):
-        (self.sr.rolling(self.wins).sum())
-
-    def time_rolling_corr(self):
-        (self.srs.rolling(self.wins).corr())
-
-    def time_rolling_cov(self):
-        (self.srs.rolling(self.wins).cov())
-        
-    def time_rolling_quantile_0_l(self):
-        (self.sr.rolling(self.winl).quantile(0.0))
-
-    def time_rolling_quantile_1_l(self):
-        (self.sr.rolling(self.winl).quantile(1.0))
-
-    def time_rolling_quantile_median_l(self):
-        (self.sr.rolling(self.winl).quantile(0.5))
-
-    def time_rolling_median_l(self):
-        (self.sr.rolling(self.winl).median())
-
-    def time_rolling_mean_l(self):
-        (self.sr.rolling(self.winl).mean())
-
-    def time_rolling_max_l(self):
-        (self.sr.rolling(self.winl).max())
-
-    def time_rolling_min_l(self):
-        (self.sr.rolling(self.winl).min())
-
-    def time_rolling_std_l(self):
-        (self.sr.rolling(self.wins).std())
-
-    def time_rolling_count_l(self):
-        (self.sr.rolling(self.wins).count())
-
-    def time_rolling_skew_l(self):
-        (self.sr.rolling(self.wins).skew())
-
-    def time_rolling_kurt_l(self):
-        (self.sr.rolling(self.wins).kurt())
-
-    def time_rolling_sum_l(self):
-        (self.sr.rolling(self.wins).sum())
+    def time_quantile(self, contructor, window, dtype, percentile):
+        self.roll.quantile(percentile)

doc/source/whatsnew/v0.22.0.txt

@@ -263,8 +263,10 @@ Conversion
 - Adding a ``Period`` object to a ``datetime`` or ``Timestamp`` object will now correctly raise a ``TypeError`` (:issue:`17983`)
 - Fixed a bug where ``FY5253`` date offsets could incorrectly raise an ``AssertionError`` in arithmetic operatons (:issue:`14774`)
 - Bug in :meth:`Index.astype` with a categorical dtype where the resultant index is not converted to a :class:`CategoricalIndex` for all types of index (:issue:`18630`)
+- Bug in :meth:`Series.astype` and ``Categorical.astype()`` where an existing categorical data does not get updated (:issue:`10696`, :issue:`18593`)
 - Bug in localization of a naive, datetime string in a ``Series`` constructor with a ``datetime[ns, timezone]`` dtype (:issue:`174151`)
 
+
 Indexing
 ^^^^^^^^
 
@@ -278,6 +280,8 @@ Indexing
 - Bug in :func:`IntervalIndex.symmetric_difference` where the symmetric difference with a non-``IntervalIndex`` did not raise (:issue:`18475`)
 - Bug in indexing a datetimelike ``Index`` that raised ``ValueError`` instead of ``IndexError`` (:issue:`18386`).
 - Bug in tz-aware :class:`DatetimeIndex` where addition/subtraction with a :class:`TimedeltaIndex` or array with ``dtype='timedelta64[ns]'`` was incorrect (:issue:`17558`)
+- :func:`Index.to_series` now accepts ``index`` and ``name`` kwargs (:issue:`18699`)
+- :func:`DatetimeIndex.to_series` now accepts ``index`` and ``name`` kwargs (:issue:`18699`)
 
 I/O
 ^^^

pandas/core/categorical.py

@@ -436,9 +436,12 @@ def astype(self, dtype, copy=True):
 
         """
         if is_categorical_dtype(dtype):
-            if copy is True:
-                return self.copy()
-            return self
+            # GH 10696/18593
+            dtype = self.dtype._update_dtype(dtype)
+            self = self.copy() if copy else self
+            if dtype == self.dtype:
+                return self
+            return self._set_dtype(dtype)
         return np.array(self, dtype=dtype, copy=copy)
 
     @cache_readonly

pandas/core/indexes/base.py

@@ -983,20 +983,32 @@ def _format_attrs(self):
             attrs.append(('length', len(self)))
         return attrs
 
-    def to_series(self, **kwargs):
+    def to_series(self, index=None, name=None):
         """
         Create a Series with both index and values equal to the index keys
         useful with map for returning an indexer based on an index
 
+        Parameters
+        ----------
+        index : Index, optional
+            index of resulting Series. If None, defaults to original index
+        name : string, optional
+            name of resulting Series. If None, defaults to name of original
+            index
+
         Returns
         -------
         Series : dtype will be based on the type of the Index values.
         """
 
         from pandas import Series
-        return Series(self._to_embed(),
-                      index=self._shallow_copy(),
-                      name=self.name)
+
+        if index is None:
+            index = self._shallow_copy()
+        if name is None:
+            name = self.name
+
+        return Series(self._to_embed(), index=index, name=name)
 
     def to_frame(self, index=True):
         """

pandas/core/indexes/datetimes.py

@@ -932,7 +932,7 @@ def _get_time_micros(self):
             values = self._local_timestamps()
         return fields.get_time_micros(values)
 
-    def to_series(self, keep_tz=False):
+    def to_series(self, keep_tz=False, index=None, name=None):
         """
         Create a Series with both index and values equal to the index keys
         useful with map for returning an indexer based on an index
@@ -954,15 +954,24 @@ def to_series(self, keep_tz=False):
 
               Series will have a datetime64[ns] dtype. TZ aware
               objects will have the tz removed.
+        index : Index, optional
+            index of resulting Series. If None, defaults to original index
+        name : string, optional
+            name of resulting Series. If None, defaults to name of original
+            index
 
         Returns
         -------
         Series
         """
         from pandas import Series
-        return Series(self._to_embed(keep_tz),
-                      index=self._shallow_copy(),
-                      name=self.name)
+
+        if index is None:
+            index = self._shallow_copy()
+        if name is None:
+            name = self.name
+
+        return Series(self._to_embed(keep_tz), index=index, name=name)
 
     def _to_embed(self, keep_tz=False, dtype=None):
         """