diff --git a/doc/source/whatsnew/v0.20.0.txt b/doc/source/whatsnew/v0.20.0.txt
index 3332bfcd65d50..4882acbe820ea 100644
--- a/doc/source/whatsnew/v0.20.0.txt
+++ b/doc/source/whatsnew/v0.20.0.txt
@@ -9,7 +9,7 @@ users upgrade to this version.
 
 Highlights include:
 
-- new ``.agg()`` API for Series/DataFrame similar to the groupby-rolling-resample API's, see :ref:`here <whatsnew_0200.enhancements.agg>`
+- New ``.agg()`` API for Series/DataFrame similar to the groupby-rolling-resample API's, see :ref:`here <whatsnew_0200.enhancements.agg>`
 - Integration with the ``feather-format``, including a new top-level ``pd.read_feather()`` and ``DataFrame.to_feather()`` method, see :ref:`here <io.feather>`.
 - The ``.ix`` indexer has been deprecated, see :ref:`here <whatsnew_0200.api_breaking.deprecate_ix>`
 - ``Panel`` has been deprecated, see :ref:`here <whatsnew_0200.api_breaking.deprecate_panel>`
@@ -45,8 +45,8 @@ New features
 ^^^^^^^^^^^
 
 Series & DataFrame have been enhanced to support the aggregation API. This is an already familiar API that
-is supported for groupby, window operations, and resampling. This allows one to express, possibly multiple,
-aggregation operations in a single concise way by using :meth:`~DataFrame.agg`,
+is supported for groupby, window operations, and resampling. This allows one to express aggregation operations
+in a single concise way by using :meth:`~DataFrame.agg`,
 and :meth:`~DataFrame.transform`. The full documentation is :ref:`here <basics.aggregate>` (:issue:`1623`).
 
 Here is a sample
diff --git a/pandas/core/base.py b/pandas/core/base.py
index 87c649c5fbd79..fd0846b0ad33c 100644
--- a/pandas/core/base.py
+++ b/pandas/core/base.py
@@ -370,42 +370,6 @@ def _gotitem(self, key, ndim, subset=None):
         """
         raise AbstractMethodError(self)
 
-    _agg_doc = """Aggregate using input function or dict of {column ->
-function}
-
-Parameters
-----------
-arg : function or dict
-    Function to use for aggregating groups. If a function, must either
-    work when passed a DataFrame or when passed to DataFrame.apply. If
-    passed a dict, the keys must be DataFrame column names.
-
-    Accepted Combinations are:
-      - string cythonized function name
-      - function
-      - list of functions
-      - dict of columns -> functions
-      - nested dict of names -> dicts of functions
-
-Notes
------
-Numpy functions mean/median/prod/sum/std/var are special cased so the
-default behavior is applying the function along axis=0
-(e.g., np.mean(arr_2d, axis=0)) as opposed to
-mimicking the default Numpy behavior (e.g., np.mean(arr_2d)).
-
-Returns
--------
-aggregated : DataFrame
-"""
-
-    _see_also_template = """
-See also
---------
-pandas.Series.%(name)s
-pandas.DataFrame.%(name)s
-"""
-
     def aggregate(self, func, *args, **kwargs):
         raise AbstractMethodError(self)
 
@@ -1150,30 +1114,39 @@ def factorize(self, sort=False, na_sentinel=-1):
 
         Examples
         --------
+
         >>> x = pd.Series([1, 2, 3])
         >>> x
         0    1
         1    2
         2    3
         dtype: int64
+
         >>> x.searchsorted(4)
         array([3])
+
         >>> x.searchsorted([0, 4])
         array([0, 3])
+
         >>> x.searchsorted([1, 3], side='left')
         array([0, 2])
+
         >>> x.searchsorted([1, 3], side='right')
         array([1, 3])
-        >>>
+
         >>> x = pd.Categorical(['apple', 'bread', 'bread', 'cheese', 'milk' ])
         [apple, bread, bread, cheese, milk]
         Categories (4, object): [apple < bread < cheese < milk]
+
         >>> x.searchsorted('bread')
         array([1])     # Note: an array, not a scalar
+
         >>> x.searchsorted(['bread'])
         array([1])
+
         >>> x.searchsorted(['bread', 'eggs'])
         array([1, 4])
+
         >>> x.searchsorted(['bread', 'eggs'], side='right')
         array([3, 4])    # eggs before milk
         """)
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 9a62259202653..67966374fcf9a 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -18,6 +18,7 @@
 import sys
 import types
 import warnings
+from textwrap import dedent
 
 from numpy import nan as NA
 import numpy as np
@@ -4200,7 +4201,43 @@ def _gotitem(self, key, ndim, subset=None):
         # TODO: _shallow_copy(subset)?
         return self[key]
 
-    @Appender(_shared_docs['aggregate'] % _shared_doc_kwargs)
+    _agg_doc = dedent("""
+    Examples
+    --------
+
+    >>> df = pd.DataFrame(np.random.randn(10, 3), columns=['A', 'B', 'C'],
+    ...                   index=pd.date_range('1/1/2000', periods=10))
+    >>> df.iloc[3:7] = np.nan
+
+    Aggregate these functions across all columns
+
+    >>> df.agg(['sum', 'min'])
+                A         B         C
+    sum -0.182253 -0.614014 -2.909534
+    min -1.916563 -1.460076 -1.568297
+
+    Different aggregations per column
+
+    >>> df.agg({'A' : ['sum', 'min'], 'B' : ['min', 'max']})
+                A         B
+    max       NaN  1.514318
+    min -1.916563 -1.460076
+    sum -0.182253       NaN
+
+    See also
+    --------
+    pandas.DataFrame.apply
+    pandas.DataFrame.transform
+    pandas.DataFrame.groupby.aggregate
+    pandas.DataFrame.resample.aggregate
+    pandas.DataFrame.rolling.aggregate
+
+    """)
+
+    @Appender(_agg_doc)
+    @Appender(_shared_docs['aggregate'] % dict(
+        versionadded='.. versionadded:: 0.20.0',
+        **_shared_doc_kwargs))
     def aggregate(self, func, axis=0, *args, **kwargs):
         axis = self._get_axis_number(axis)
 
@@ -4272,7 +4309,7 @@ def apply(self, func, axis=0, broadcast=False, raw=False, reduce=None,
         See also
         --------
         DataFrame.applymap: For elementwise operations
-        DataFrame.agg: only perform aggregating type operations
+        DataFrame.aggregate: only perform aggregating type operations
         DataFrame.transform: only perform transformating type operations
 
         Returns
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 9318a9f5ef27c..48ee1842dc4a0 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -2854,19 +2854,19 @@ def pipe(self, func, *args, **kwargs):
             return func(self, *args, **kwargs)
 
     _shared_docs['aggregate'] = ("""
-    Aggregate using input function or dict of {column ->
-    function}
+    Aggregate using callable, string, dict, or list of string/callables
 
-    .. versionadded:: 0.20.0
+    %(versionadded)s
 
     Parameters
     ----------
     func : callable, string, dictionary, or list of string/callables
         Function to use for aggregating the data. If a function, must either
-        work when passed a DataFrame or when passed to DataFrame.apply. If
-        passed a dict, the keys must be DataFrame column names.
+        work when passed a %(klass)s or when passed to %(klass)s.apply. For
+        a DataFrame, can pass a dict, if the keys are DataFrame column names.
 
         Accepted Combinations are:
+
         - string function name
         - function
         - list of functions
@@ -2879,12 +2879,11 @@ def pipe(self, func, *args, **kwargs):
     (e.g., np.mean(arr_2d, axis=0)) as opposed to
     mimicking the default Numpy behavior (e.g., np.mean(arr_2d)).
 
+    agg is an alias for aggregate. Use it.
+
     Returns
     -------
     aggregated : %(klass)s
-
-    See also
-    --------
     """)
 
     _shared_docs['transform'] = ("""
@@ -2899,18 +2898,40 @@ def pipe(self, func, *args, **kwargs):
         To apply to column
 
         Accepted Combinations are:
+
         - string function name
         - function
         - list of functions
         - dict of column names -> functions (or list of functions)
 
+    Returns
+    -------
+    transformed : %(klass)s
+
     Examples
     --------
+    >>> df = pd.DataFrame(np.random.randn(10, 3), columns=['A', 'B', 'C'],
+    ...                   index=pd.date_range('1/1/2000', periods=10))
+    df.iloc[3:7] = np.nan
+
     >>> df.transform(lambda x: (x - x.mean()) / x.std())
+                       A         B         C
+    2000-01-01  0.579457  1.236184  0.123424
+    2000-01-02  0.370357 -0.605875 -1.231325
+    2000-01-03  1.455756 -0.277446  0.288967
+    2000-01-04       NaN       NaN       NaN
+    2000-01-05       NaN       NaN       NaN
+    2000-01-06       NaN       NaN       NaN
+    2000-01-07       NaN       NaN       NaN
+    2000-01-08 -0.498658  1.274522  1.642524
+    2000-01-09 -0.540524 -1.012676 -0.828968
+    2000-01-10 -1.366388 -0.614710  0.005378
+
+    See also
+    --------
+    pandas.%(klass)s.aggregate
+    pandas.%(klass)s.apply
 
-    Returns
-    -------
-    transformed : %(klass)s
     """)
 
     # ----------------------------------------------------------------------
diff --git a/pandas/core/groupby.py b/pandas/core/groupby.py
index 1f715c685c27e..479d2f7d26eb6 100644
--- a/pandas/core/groupby.py
+++ b/pandas/core/groupby.py
@@ -5,6 +5,7 @@
 import collections
 import warnings
 import copy
+from textwrap import dedent
 
 from pandas.compat import (
     zip, range, lzip,
@@ -46,7 +47,7 @@
                                CategoricalIndex, _ensure_index)
 from pandas.core.categorical import Categorical
 from pandas.core.frame import DataFrame
-from pandas.core.generic import NDFrame
+from pandas.core.generic import NDFrame, _shared_docs
 from pandas.core.internals import BlockManager, make_block
 from pandas.core.series import Series
 from pandas.core.panel import Panel
@@ -2749,57 +2750,47 @@ def _selection_name(self):
         else:
             return self._selection
 
-    def aggregate(self, func_or_funcs, *args, **kwargs):
-        """
-        Apply aggregation function or functions to groups, yielding most likely
-        Series but in some cases DataFrame depending on the output of the
-        aggregation function
+    _agg_doc = dedent("""
+    Examples
+    --------
 
-        Parameters
-        ----------
-        func_or_funcs : function or list / dict of functions
-            List/dict of functions will produce DataFrame with column names
-            determined by the function names themselves (list) or the keys in
-            the dict
+    >>> s = Series([1, 2, 3, 4])
 
-        Notes
-        -----
-        agg is an alias for aggregate. Use it.
+    >>> s
+    0    1
+    1    2
+    2    3
+    3    4
+    dtype: int64
 
-        Examples
-        --------
-        >>> series
-        bar    1.0
-        baz    2.0
-        qot    3.0
-        qux    4.0
-
-        >>> mapper = lambda x: x[0] # first letter
-        >>> grouped = series.groupby(mapper)
-
-        >>> grouped.aggregate(np.sum)
-        b    3.0
-        q    7.0
-
-        >>> grouped.aggregate([np.sum, np.mean, np.std])
-           mean  std  sum
-        b  1.5   0.5  3
-        q  3.5   0.5  7
-
-        >>> grouped.agg({'result' : lambda x: x.mean() / x.std(),
-        ...              'total' : np.sum})
-           result  total
-        b  2.121   3
-        q  4.95    7
+    >>> s.groupby([1, 1, 2, 2]).min()
+    1    1
+    2    3
+    dtype: int64
 
-        See also
-        --------
-        apply, transform
+    >>> s.groupby([1, 1, 2, 2]).agg('min')
+    1    1
+    2    3
+    dtype: int64
 
-        Returns
-        -------
-        Series or DataFrame
-        """
+    >>> s.groupby([1, 1, 2, 2]).agg(['min', 'max'])
+       min  max
+    1    1    2
+    2    3    4
+
+    See also
+    --------
+    pandas.Series.groupby.apply
+    pandas.Series.groupby.transform
+    pandas.Series.aggregate
+
+    """)
+
+    @Appender(_agg_doc)
+    @Appender(_shared_docs['aggregate'] % dict(
+        klass='Series',
+        versionadded=''))
+    def aggregate(self, func_or_funcs, *args, **kwargs):
         _level = kwargs.pop('_level', None)
         if isinstance(func_or_funcs, compat.string_types):
             return getattr(self, func_or_funcs)(*args, **kwargs)
@@ -3905,9 +3896,67 @@ class DataFrameGroupBy(NDFrameGroupBy):
 
     _block_agg_axis = 1
 
-    @Substitution(name='groupby')
-    @Appender(SelectionMixin._see_also_template)
-    @Appender(SelectionMixin._agg_doc)
+    _agg_doc = dedent("""
+    Examples
+    --------
+
+    >>> df = pd.DataFrame({'A': [1, 1, 2, 2],
+    ...                    'B': [1, 2, 3, 4],
+    ...                    'C': np.random.randn(4)})
+
+    >>> df
+       A  B         C
+    0  1  1  0.362838
+    1  1  2  0.227877
+    2  2  3  1.267767
+    3  2  4 -0.562860
+
+    The aggregation is for each column.
+
+    >>> df.groupby('A').agg('min')
+       B         C
+    A
+    1  1  0.227877
+    2  3 -0.562860
+
+    Multiple aggregations
+
+    >>> df.groupby('A').agg(['min', 'max'])
+        B             C
+      min max       min       max
+    A
+    1   1   2  0.227877  0.362838
+    2   3   4 -0.562860  1.267767
+
+    Select a column for aggregation
+
+    >>> df.groupby('A').B.agg(['min', 'max'])
+       min  max
+    A
+    1    1    2
+    2    3    4
+
+    Different aggregations per column
+
+    >>> df.groupby('A').agg({'B': ['min', 'max'], 'C': 'sum'})
+        B             C
+      min max       sum
+    A
+    1   1   2  0.590716
+    2   3   4  0.704907
+
+    See also
+    --------
+    pandas.DataFrame.groupby.apply
+    pandas.DataFrame.groupby.transform
+    pandas.DataFrame.aggregate
+
+    """)
+
+    @Appender(_agg_doc)
+    @Appender(_shared_docs['aggregate'] % dict(
+        klass='DataFrame',
+        versionadded=''))
     def aggregate(self, arg, *args, **kwargs):
         return super(DataFrameGroupBy, self).aggregate(arg, *args, **kwargs)
 
@@ -4166,9 +4215,6 @@ def groupby_series(obj, col=None):
 
 class PanelGroupBy(NDFrameGroupBy):
 
-    @Substitution(name='groupby')
-    @Appender(SelectionMixin._see_also_template)
-    @Appender(SelectionMixin._agg_doc)
     def aggregate(self, arg, *args, **kwargs):
         return super(PanelGroupBy, self).aggregate(arg, *args, **kwargs)
 
diff --git a/pandas/core/resample.py b/pandas/core/resample.py
index 1685a5d75245d..cbb2f6a93c2fd 100644
--- a/pandas/core/resample.py
+++ b/pandas/core/resample.py
@@ -2,6 +2,7 @@
 import numpy as np
 import warnings
 import copy
+from textwrap import dedent
 
 import pandas as pd
 from pandas.core.base import AbstractMethodError, GroupByMixin
@@ -254,66 +255,56 @@ def plot(self, *args, **kwargs):
         # have the warnings shown here and just have this work
         return self._deprecated('plot').plot(*args, **kwargs)
 
+    _agg_doc = dedent("""
+
+    Examples
+    --------
+    >>> s = Series([1,2,3,4,5],
+                    index=pd.date_range('20130101',
+                                        periods=5,freq='s'))
+    2013-01-01 00:00:00    1
+    2013-01-01 00:00:01    2
+    2013-01-01 00:00:02    3
+    2013-01-01 00:00:03    4
+    2013-01-01 00:00:04    5
+    Freq: S, dtype: int64
+
+    >>> r = s.resample('2s')
+    DatetimeIndexResampler [freq=<2 * Seconds>, axis=0, closed=left,
+                            label=left, convention=start, base=0]
+
+    >>> r.agg(np.sum)
+    2013-01-01 00:00:00    3
+    2013-01-01 00:00:02    7
+    2013-01-01 00:00:04    5
+    Freq: 2S, dtype: int64
+
+    >>> r.agg(['sum','mean','max'])
+                         sum  mean  max
+    2013-01-01 00:00:00    3   1.5    2
+    2013-01-01 00:00:02    7   3.5    4
+    2013-01-01 00:00:04    5   5.0    5
+
+    >>> r.agg({'result' : lambda x: x.mean() / x.std(),
+               'total' : np.sum})
+                         total    result
+    2013-01-01 00:00:00      3  2.121320
+    2013-01-01 00:00:02      7  4.949747
+    2013-01-01 00:00:04      5       NaN
+
+    See also
+    --------
+    pandas.DataFrame.groupby.aggregate
+    pandas.DataFrame.resample.transform
+    pandas.DataFrame.aggregate
+
+    """)
+
+    @Appender(_agg_doc)
+    @Appender(_shared_docs['aggregate'] % dict(
+        klass='DataFrame',
+        versionadded=''))
     def aggregate(self, arg, *args, **kwargs):
-        """
-        Apply aggregation function or functions to resampled groups, yielding
-        most likely Series but in some cases DataFrame depending on the output
-        of the aggregation function
-
-        Parameters
-        ----------
-        func_or_funcs : function or list / dict of functions
-            List/dict of functions will produce DataFrame with column names
-            determined by the function names themselves (list) or the keys in
-            the dict
-
-        Notes
-        -----
-        agg is an alias for aggregate. Use it.
-
-        Examples
-        --------
-        >>> s = Series([1,2,3,4,5],
-                        index=pd.date_range('20130101',
-                                            periods=5,freq='s'))
-        2013-01-01 00:00:00    1
-        2013-01-01 00:00:01    2
-        2013-01-01 00:00:02    3
-        2013-01-01 00:00:03    4
-        2013-01-01 00:00:04    5
-        Freq: S, dtype: int64
-
-        >>> r = s.resample('2s')
-        DatetimeIndexResampler [freq=<2 * Seconds>, axis=0, closed=left,
-                                label=left, convention=start, base=0]
-
-        >>> r.agg(np.sum)
-        2013-01-01 00:00:00    3
-        2013-01-01 00:00:02    7
-        2013-01-01 00:00:04    5
-        Freq: 2S, dtype: int64
-
-        >>> r.agg(['sum','mean','max'])
-                             sum  mean  max
-        2013-01-01 00:00:00    3   1.5    2
-        2013-01-01 00:00:02    7   3.5    4
-        2013-01-01 00:00:04    5   5.0    5
-
-        >>> r.agg({'result' : lambda x: x.mean() / x.std(),
-                   'total' : np.sum})
-                             total    result
-        2013-01-01 00:00:00      3  2.121320
-        2013-01-01 00:00:02      7  4.949747
-        2013-01-01 00:00:04      5       NaN
-
-        See also
-        --------
-        transform
-
-        Returns
-        -------
-        Series or DataFrame
-        """
 
         self._set_binner()
         result, how = self._aggregate(arg, *args, **kwargs)
diff --git a/pandas/core/series.py b/pandas/core/series.py
index f03091d7e6a66..e5f1d91eedfec 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -8,6 +8,7 @@
 
 import types
 import warnings
+from textwrap import dedent
 
 from numpy import nan, ndarray
 import numpy as np
@@ -2174,7 +2175,31 @@ def _gotitem(self, key, ndim, subset=None):
         """
         return self
 
-    @Appender(generic._shared_docs['aggregate'] % _shared_doc_kwargs)
+    _agg_doc = dedent("""
+    Examples
+    --------
+
+    >>> s = Series(np.random.randn(10))
+
+    >>> s.agg('min')
+    -1.3018049988556679
+
+    >>> s.agg(['min', 'max'])
+    min   -1.301805
+    max    1.127688
+    dtype: float64
+
+    See also
+    --------
+    pandas.Series.apply
+    pandas.Series.transform
+
+    """)
+
+    @Appender(_agg_doc)
+    @Appender(generic._shared_docs['aggregate'] % dict(
+        versionadded='.. versionadded:: 0.20.0',
+        **_shared_doc_kwargs))
     def aggregate(self, func, axis=0, *args, **kwargs):
         axis = self._get_axis_number(axis)
         result, how = self._aggregate(func, *args, **kwargs)
diff --git a/pandas/core/window.py b/pandas/core/window.py
index 6fdc05a13b773..6d8f12e982f12 100644
--- a/pandas/core/window.py
+++ b/pandas/core/window.py
@@ -39,10 +39,11 @@
 from pandas.compat.numpy import function as nv
 from pandas.util.decorators import (Substitution, Appender,
                                     cache_readonly)
+from pandas.core.generic import _shared_docs
 from textwrap import dedent
 
 
-_shared_docs = dict()
+_shared_docs = dict(**_shared_docs)
 _doc_template = """
 
 Returns
@@ -611,9 +612,48 @@ def f(arg, *args, **kwargs):
 
         return self._wrap_results(results, blocks, obj)
 
-    @Substitution(name='rolling')
-    @Appender(SelectionMixin._see_also_template)
-    @Appender(SelectionMixin._agg_doc)
+    _agg_doc = dedent("""
+    Examples
+    --------
+
+    >>> df = pd.DataFrame(np.random.randn(10, 3), columns=['A', 'B', 'C'])
+    >>> df
+              A         B         C
+    0 -2.385977 -0.102758  0.438822
+    1 -1.004295  0.905829 -0.954544
+    2  0.735167 -0.165272 -1.619346
+    3 -0.702657 -1.340923 -0.706334
+    4 -0.246845  0.211596 -0.901819
+    5  2.463718  3.157577 -1.380906
+    6 -1.142255  2.340594 -0.039875
+    7  1.396598 -1.647453  1.677227
+    8 -0.543425  1.761277 -0.220481
+    9 -0.640505  0.289374 -1.550670
+
+    >>> df.rolling(3, win_type='boxcar').agg('mean')
+              A         B         C
+    0       NaN       NaN       NaN
+    1       NaN       NaN       NaN
+    2 -0.885035  0.212600 -0.711689
+    3 -0.323928 -0.200122 -1.093408
+    4 -0.071445 -0.431533 -1.075833
+    5  0.504739  0.676083 -0.996353
+    6  0.358206  1.903256 -0.774200
+    7  0.906020  1.283573  0.085482
+    8 -0.096361  0.818139  0.472290
+    9  0.070889  0.134399 -0.031308
+
+    See also
+    --------
+    pandas.DataFrame.rolling.aggregate
+    pandas.DataFrame.aggregate
+
+    """)
+
+    @Appender(_agg_doc)
+    @Appender(_shared_docs['aggregate'] % dict(
+        versionadded='',
+        klass='Series/DataFrame'))
     def aggregate(self, arg, *args, **kwargs):
         result, how = self._aggregate(arg, *args, **kwargs)
         if result is None:
@@ -1081,9 +1121,62 @@ def _validate_freq(self):
                              "compat with a datetimelike "
                              "index".format(self.window))
 
-    @Substitution(name='rolling')
-    @Appender(SelectionMixin._see_also_template)
-    @Appender(SelectionMixin._agg_doc)
+    _agg_doc = dedent("""
+    Examples
+    --------
+
+    >>> df = pd.DataFrame(np.random.randn(10, 3), columns=['A', 'B', 'C'])
+    >>> df
+              A         B         C
+    0 -2.385977 -0.102758  0.438822
+    1 -1.004295  0.905829 -0.954544
+    2  0.735167 -0.165272 -1.619346
+    3 -0.702657 -1.340923 -0.706334
+    4 -0.246845  0.211596 -0.901819
+    5  2.463718  3.157577 -1.380906
+    6 -1.142255  2.340594 -0.039875
+    7  1.396598 -1.647453  1.677227
+    8 -0.543425  1.761277 -0.220481
+    9 -0.640505  0.289374 -1.550670
+
+    >>> df.rolling(3).sum()
+              A         B         C
+    0       NaN       NaN       NaN
+    1       NaN       NaN       NaN
+    2 -2.655105  0.637799 -2.135068
+    3 -0.971785 -0.600366 -3.280224
+    4 -0.214334 -1.294599 -3.227500
+    5  1.514216  2.028250 -2.989060
+    6  1.074618  5.709767 -2.322600
+    7  2.718061  3.850718  0.256446
+    8 -0.289082  2.454418  1.416871
+    9  0.212668  0.403198 -0.093924
+
+
+    >>> df.rolling(3).agg({'A':'sum', 'B':'min'})
+              A         B
+    0       NaN       NaN
+    1       NaN       NaN
+    2 -2.655105 -0.165272
+    3 -0.971785 -1.340923
+    4 -0.214334 -1.340923
+    5  1.514216 -1.340923
+    6  1.074618  0.211596
+    7  2.718061 -1.647453
+    8 -0.289082 -1.647453
+    9  0.212668 -1.647453
+
+    See also
+    --------
+    pandas.Series.rolling
+    pandas.DataFrame.rolling
+
+    """)
+
+    @Appender(_agg_doc)
+    @Appender(_shared_docs['aggregate'] % dict(
+        versionadded='',
+        klass='Series/DataFrame'))
     def aggregate(self, arg, *args, **kwargs):
         return super(Rolling, self).aggregate(arg, *args, **kwargs)
 
@@ -1288,9 +1381,49 @@ def _get_window(self, other=None):
         return (max((len(obj) + len(obj)), self.min_periods)
                 if self.min_periods else (len(obj) + len(obj)))
 
-    @Substitution(name='expanding')
-    @Appender(SelectionMixin._see_also_template)
-    @Appender(SelectionMixin._agg_doc)
+    _agg_doc = dedent("""
+    Examples
+    --------
+
+    >>> df = pd.DataFrame(np.random.randn(10, 3), columns=['A', 'B', 'C'])
+    >>> df
+              A         B         C
+    0 -2.385977 -0.102758  0.438822
+    1 -1.004295  0.905829 -0.954544
+    2  0.735167 -0.165272 -1.619346
+    3 -0.702657 -1.340923 -0.706334
+    4 -0.246845  0.211596 -0.901819
+    5  2.463718  3.157577 -1.380906
+    6 -1.142255  2.340594 -0.039875
+    7  1.396598 -1.647453  1.677227
+    8 -0.543425  1.761277 -0.220481
+    9 -0.640505  0.289374 -1.550670
+
+    >>> df.ewm(alpha=0.5).mean()
+              A         B         C
+    0 -2.385977 -0.102758  0.438822
+    1 -1.464856  0.569633 -0.490089
+    2 -0.207700  0.149687 -1.135379
+    3 -0.471677 -0.645305 -0.906555
+    4 -0.355635 -0.203033 -0.904111
+    5  1.076417  1.503943 -1.146293
+    6 -0.041654  1.925562 -0.588728
+    7  0.680292  0.132049  0.548693
+    8  0.067236  0.948257  0.163353
+    9 -0.286980  0.618493 -0.694496
+
+    See also
+    --------
+    pandas.DataFrame.expanding.aggregate
+    pandas.DataFrame.rolling.aggregate
+    pandas.DataFrame.aggregate
+
+    """)
+
+    @Appender(_agg_doc)
+    @Appender(_shared_docs['aggregate'] % dict(
+        versionadded='',
+        klass='Series/DataFrame'))
     def aggregate(self, arg, *args, **kwargs):
         return super(Expanding, self).aggregate(arg, *args, **kwargs)
 
@@ -1534,9 +1667,47 @@ def __init__(self, obj, com=None, span=None, halflife=None, alpha=None,
     def _constructor(self):
         return EWM
 
-    @Substitution(name='ewm')
-    @Appender(SelectionMixin._see_also_template)
-    @Appender(SelectionMixin._agg_doc)
+    _agg_doc = dedent("""
+    Examples
+    --------
+
+    >>> df = pd.DataFrame(np.random.randn(10, 3), columns=['A', 'B', 'C'])
+    >>> df
+              A         B         C
+    0 -2.385977 -0.102758  0.438822
+    1 -1.004295  0.905829 -0.954544
+    2  0.735167 -0.165272 -1.619346
+    3 -0.702657 -1.340923 -0.706334
+    4 -0.246845  0.211596 -0.901819
+    5  2.463718  3.157577 -1.380906
+    6 -1.142255  2.340594 -0.039875
+    7  1.396598 -1.647453  1.677227
+    8 -0.543425  1.761277 -0.220481
+    9 -0.640505  0.289374 -1.550670
+
+    >>> df.ewm(alpha=0.5).mean()
+              A         B         C
+    0 -2.385977 -0.102758  0.438822
+    1 -1.464856  0.569633 -0.490089
+    2 -0.207700  0.149687 -1.135379
+    3 -0.471677 -0.645305 -0.906555
+    4 -0.355635 -0.203033 -0.904111
+    5  1.076417  1.503943 -1.146293
+    6 -0.041654  1.925562 -0.588728
+    7  0.680292  0.132049  0.548693
+    8  0.067236  0.948257  0.163353
+    9 -0.286980  0.618493 -0.694496
+
+    See also
+    --------
+    pandas.DataFrame.rolling.aggregate
+
+    """)
+
+    @Appender(_agg_doc)
+    @Appender(_shared_docs['aggregate'] % dict(
+        versionadded='',
+        klass='Series/DataFrame'))
     def aggregate(self, arg, *args, **kwargs):
         return super(EWM, self).aggregate(arg, *args, **kwargs)