revert back to minimal changes in doc folder

Signed-off-by: Fabian Haase <haase.fabian@gmail.com>

Author: FHaase

doc/source/advanced.rst

@@ -503,6 +503,47 @@ method, allowing you to permute the hierarchical index levels in one step:
 
    df[:5].reorder_levels([1,0], axis=0)
 
+.. _advanced.index_names:
+
+Renaming names of an ``Index`` or ``MultiIndex``
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The :meth:`~DataFrame.rename` method is used to rename the labels of a
+``MultiIndex``, and is typically used to rename the columns of a ``DataFrame``.
+The ``columns`` argument of ``rename`` allows a dictionary to be specified
+that includes only the columns you wish to rename.
+
+.. ipython:: python
+
+   df.rename(columns={0: "col0", 1: "col1"})
+
+This method can also be used to rename specific labels of the main index
+of the ``DataFrame``.
+
+.. ipython:: python
+
+   df.rename(index={"one" : "two", "y" : "z"})
+
+The :meth:`~DataFrame.rename_axis` method is used to rename the name of a
+``Index`` or ``MultiIndex``. In particular, the names of the levels of a
+``MultiIndex`` can be specified, which is useful if ``reset_index()`` is later
+used to move the values from the ``MultiIndex`` to a column.
+
+.. ipython:: python
+
+   df.rename_axis(index=['abc', 'def'])
+
+Note that the columns of a ``DataFrame`` are an index, so that using
+``rename_axis`` with the ``columns`` argument will change the name of that
+index.
+
+.. ipython:: python
+
+   df.rename_axis(columns="Cols").columns
+
+Both ``rename`` and ``rename_axis`` support specifying a dictionary,
+``Series`` or a mapping function to map labels/names to new values.
+
 Sorting a ``MultiIndex``
 ------------------------
 
@@ -738,15 +779,17 @@ values **not** in the categories, similarly to how you can reindex **any** panda
    Reshaping and Comparison operations on a ``CategoricalIndex`` must have the same categories
    or a ``TypeError`` will be raised.
 
-   .. code-block:: python
+   .. code-block:: ipython
+
+      In [9]: df3 = pd.DataFrame({'A' : np.arange(6),
+                                  'B' : pd.Series(list('aabbca')).astype('category')})
 
-      >>> df3 = pd.DataFrame({'A': np.arange(6),
-      ...                     'B': pd.Series(list('aabbca')).astype('category')})
-      >>> df3 = df3.set_index('B')
-      >>> df3.index
-      CategoricalIndex([u'a', u'a', u'b', u'b', u'c', u'a'], categories=[u'a', u'b', u'c'], ordered=False, name=u'B', dtype='category')
+      In [11]: df3 = df3.set_index('B')
 
-      >>> pd.concat([df2, df3])
+      In [11]: df3.index
+      Out[11]: CategoricalIndex([u'a', u'a', u'b', u'b', u'c', u'a'], categories=[u'a', u'b', u'c'], ordered=False, name=u'B', dtype='category')
+
+      In [12]: pd.concat([df2, df3]
       TypeError: categories must match existing categories when appending
 
 .. _indexing.rangeindex:
@@ -1028,14 +1071,14 @@ On the other hand, if the index is not monotonic, then both slice bounds must be
     # OK because 2 and 4 are in the index
     df.loc[2:4, :]
 
-.. code-block:: python
+.. code-block:: ipython
 
     # 0 is not in the index
-    >>> df.loc[0:4, :]
+    In [9]: df.loc[0:4, :]
     KeyError: 0
 
     # 3 is not a unique label
-    >>> df.loc[2:3, :]
+    In [11]: df.loc[2:3, :]
     KeyError: 'Cannot get right slice bound for non-unique label: 3'
 
 ``Index.is_monotonic_increasing`` and ``Index.is_monotonic_decreasing`` only check that

doc/source/basics.rst

@@ -302,17 +302,23 @@ To evaluate single-element pandas objects in a boolean context, use the method
 
 .. warning::
 
-   Using a DataFrame as a condition will raise errors,
-   as you are trying to compare multiple values:
+   You might be tempted to do the following:
 
    .. code-block:: python
 
-       >>> if df:
-       ...     do_something()
-       ValueError: The truth value of an array is ambiguous. Use a.empty, a.any() or a.all().
+       >>> if df:                         # noqa: E999
+               ...
+
+   Or
+
+   .. code-block:: python
+
+       >>> df and df2                     # noqa: E999
+
+   These will both raise errors, as you are trying to compare multiple values.
+
+   .. code-block:: console
 
-       >>> if df and df2:
-       ...     do_something()
        ValueError: The truth value of an array is ambiguous. Use a.empty, a.any() or a.all().
 
 See :ref:`gotchas<gotchas.truth>` for a more detailed discussion.
@@ -1459,8 +1465,21 @@ for altering the ``Series.name`` attribute.
 
 .. _basics.rename_axis:
 
-The Panel class has a related :meth:`~Panel.rename_axis` class which can rename
-any of its three axes.
+.. versionadded:: 0.24.0
+
+The methods :meth:`~DataFrame.rename_axis` and :meth:`~Series.rename_axis`
+allow specific names of a `MultiIndex` to be changed (as opposed to the
+labels).
+
+.. ipython:: python
+
+   df = pd.DataFrame({'x': [1, 2, 3, 4, 5, 6],
+                      'y': [10, 20, 30, 40, 50, 60]},
+                     index=pd.MultiIndex.from_product([['a', 'b', 'c'], [1, 2]],
+                     names=['let', 'num']))
+   df
+   df.rename_axis(index={'let': 'abc'})
+   df.rename_axis(index=str.upper)
 
 .. _basics.iteration:
 

doc/source/comparison_with_sas.rst

@@ -298,8 +298,8 @@ see the :ref:`timeseries documentation<timeseries>` for more details.
 .. ipython:: python
    :suppress:
 
-   tips = tips.drop(['date1', 'date2', 'date1_year', 'date2_month',
-                     'date1_next', 'months_between'], axis=1)
+   tips = tips.drop(['date1','date2','date1_year',
+      'date2_month','date1_next','months_between'], axis=1)
 
 Selection of Columns
 ~~~~~~~~~~~~~~~~~~~~
@@ -744,9 +744,12 @@ XPORT is a relatively limited format and the parsing of it is not as
 optimized as some of the other pandas readers. An alternative way
 to interop data between SAS and pandas is to serialize to csv.
 
->>> # version 0.17, 10M rows
->>> %time df = pd.read_sas('big.xpt')
-Wall time: 14.6 s
+.. code-block:: ipython
 
->>> %time df = pd.read_csv('big.csv')
-Wall time: 4.86 s
+   # version 0.17, 10M rows
+
+   In [8]: %time df = pd.read_sas('big.xpt')
+   Wall time: 14.6 s
+
+   In [9]: %time df = pd.read_csv('big.csv')
+   Wall time: 4.86 s

doc/source/contributing.rst

@@ -783,12 +783,10 @@ We would name this file ``test_cool_feature.py`` and put in an appropriate place
        assert str(np.dtype(dtype)) == dtype
 
 
-   @pytest.mark.parametrize('dtype',
-                            ['float32',
-                             pytest.param('int16', marks=pytest.mark.skip),
-                             pytest.param('int32', marks=pytest.mark.xfail(
-                                 reason='example'))
-                             ])
+   @pytest.mark.parametrize(
+       'dtype', ['float32', pytest.param('int16', marks=pytest.mark.skip),
+                 pytest.param('int32', marks=pytest.mark.xfail(
+                     reason='to show how it works'))])
    def test_mark(dtype):
        assert str(np.dtype(dtype)) == 'float32'
 

doc/source/cookbook.rst

@@ -968,34 +968,37 @@ Parsing date components in multi-columns
 
 Parsing date components in multi-columns is faster with a format
 
-.. code-block::
+.. code-block:: ipython
 
-    >>> i = pd.date_range('20000101', periods=10000)
-    >>> df = pd.DataFrame({year: i.year, month: i.month, day: i.day})
-    >>> df.head()
+    In [30]: i = pd.date_range('20000101',periods=10000)
+
+    In [31]: df = pd.DataFrame(dict(year = i.year, month = i.month, day = i.day))
+
+    In [32]: df.head()
+    Out[32]:
        day  month  year
     0    1      1  2000
     1    2      1  2000
     2    3      1  2000
     3    4      1  2000
     4    5      1  2000
 
-    >>> %timeit pd.to_datetime(df.year * 10000 + df.month * 100 + df.day,
-    ...                        format='%Y%m%d')
+    In [33]: %timeit pd.to_datetime(df.year*10000+df.month*100+df.day,format='%Y%m%d')
     100 loops, best of 3: 7.08 ms per loop
 
     # simulate combinging into a string, then parsing
-    >>> ds = df.apply(lambda x: "%04d%02d%02d" %
-    ...               (x['year'], x['month'], x['day']), axis=1)
-    >>> ds.head()
+    In [34]: ds = df.apply(lambda x: "%04d%02d%02d" % (x['year'],x['month'],x['day']),axis=1)
+
+    In [35]: ds.head()
+    Out[35]:
     0    20000101
     1    20000102
     2    20000103
     3    20000104
     4    20000105
     dtype: object
 
-    >>> %timeit pd.to_datetime(ds)
+    In [36]: %timeit pd.to_datetime(ds)
     1 loops, best of 3: 488 ms per loop
 
 Skip row between header and data

doc/source/enhancingperf.rst

@@ -388,18 +388,19 @@ Consider the following toy example of doubling each observation:
     def double_every_value_withnumba(x):
         return x * 2
 
+.. code-block:: ipython
 
->>> # Custom function without numba
->>> %timeit df['col1_doubled'] = df.a.apply(double_every_value_nonumba)
-1000 loops, best of 3: 797 us per loop
+    # Custom function without numba
+    In [5]: %timeit df['col1_doubled'] = df.a.apply(double_every_value_nonumba)
+    1000 loops, best of 3: 797 us per loop
 
->>> # Standard implementation (faster than a custom function)
->>> %timeit df['col1_doubled'] = df.a*2
-1000 loops, best of 3: 233 us per loop
+    # Standard implementation (faster than a custom function)
+    In [6]: %timeit df['col1_doubled'] = df.a*2
+    1000 loops, best of 3: 233 us per loop
 
->>> # Custom function with numba
->>> %timeit df['col1_doubled'] = double_every_value_withnumba(df.a.values)
-1000 loops, best of 3: 145 us per loop
+    # Custom function with numba
+    In [7]: %timeit df['col1_doubled'] = double_every_value_withnumba(df.a.values)
+    1000 loops, best of 3: 145 us per loop
 
 Caveats
 ~~~~~~~

doc/source/gotchas.rst

@@ -96,32 +96,40 @@ something to a ``bool``. This happens in an ``if``-statement or when using the
 boolean operations: ``and``, ``or``, and ``not``. It is not clear what the result
 of the following code should be:
 
->>> if pd.Series([False, True, False]):
-...     print("I was true")
+.. code-block:: python
+
+    >>> if pd.Series([False, True, False]):     # noqa: E999
+         ...
 
 Should it be ``True`` because it's not zero-length, or ``False`` because there 
 are ``False`` values? It is unclear, so instead, pandas raises a ``ValueError``:
 
->>> if pd.Series([False, True, False]):
-...     print("I was true")
-Traceback
-    ...
-ValueError: The truth value of an array is ambiguous. Use a.empty, a.any() or a.all().
+.. code-block:: python
+
+    >>> if pd.Series([False, True, False]):
+    ...     print("I was true")
+    Traceback
+        ...
+    ValueError: The truth value of an array is ambiguous. Use a.empty, a.any() or a.all().
 
 You need to explicitly choose what you want to do with the ``DataFrame``, e.g.
 use :meth:`~DataFrame.any`, :meth:`~DataFrame.all` or :meth:`~DataFrame.empty`.
 Alternatively, you might want to compare if the pandas object is ``None``:
 
->>> if pd.Series([False, True, False]) is not None:
-...    print("I was not None")
-I was not None
+.. code-block:: python
+
+    >>> if pd.Series([False, True, False]) is not None:
+    ...     print("I was not None")
+    I was not None
 
 
 Below is how to check if any of the values are ``True``:
 
->>> if pd.Series([False, True, False]).any():
-...     print("I am any")
-I am any
+.. code-block:: python
+
+    >>> if pd.Series([False, True, False]).any():
+    ...     print("I am any")
+    I am any
 
 To evaluate single-element pandas objects in a boolean context, use the method 
 :meth:`~DataFrame.bool`:

doc/source/groupby.rst

@@ -81,10 +81,10 @@ object (more on what the GroupBy object is later), you may do the following:
 
 .. code-block:: python
 
-    # default is axis=0
-    >>> grouped = obj.groupby(key)
-    >>> grouped = obj.groupby(key, axis=1)
-    >>> grouped = obj.groupby([key1, key2])
+   # default is axis=0
+   >>> grouped = obj.groupby(key)
+   >>> grouped = obj.groupby(key, axis=1)
+   >>> grouped = obj.groupby([key1, key2])
 
 The mapping can be specified many different ways:
 

doc/source/io.rst

@@ -3483,7 +3483,6 @@ This format is specified by default when using ``put`` or ``to_hdf`` or by ``for
    .. code-block:: python
 
        >>> pd.DataFrame(randn(10, 2)).to_hdf('test_fixed.h5', 'df')
-
        >>> pd.read_hdf('test_fixed.h5', 'df', where='index>5')
        TypeError: cannot pass a where specification when reading a fixed format.
                   this store must be selected in its entirety
@@ -3580,13 +3579,14 @@ will yield a tuple for each group key along with the relative keys of its conten
 
     Hierarchical keys cannot be retrieved as dotted (attribute) access as described above for items stored under the root node.
 
-    .. code-block:: python
+    .. code-block:: ipython
 
-       >>> store.foo.bar.bah
+       In [8]: store.foo.bar.bah
        AttributeError: 'HDFStore' object has no attribute 'foo'
 
        # you can directly access the actual PyTables node but using the root node
-       >>> store.root.foo.bar.bah
+       In [9]: store.root.foo.bar.bah
+       Out[9]:
        /foo/bar/bah (Group) ''
          children := ['block0_items' (Array), 'block0_values' (Array), 'axis0' (Array), 'axis1' (Array)]
 
@@ -3737,7 +3737,7 @@ The right-hand side of the sub-expression (after a comparison operator) can be:
 
    instead of this
 
-   .. code-block:: python
+   .. code-block:: ipython
 
       string = "HolyMoly'"
       store.select('df', 'index == %s' % string)

setup.cfg

@@ -28,7 +28,6 @@ exclude =
     doc/temp/*.py,
     .eggs/*.py,
     versioneer.py
-    .tox
 
 [flake8-rst]
 ignore =