Add "tee-like" function for easy introspection of intermediate steps in method chaining
### Enhanchment proposal: Add method to ease introspection of intermediate variables in chained methods

Method chaining allows us to compose easily readable "stories" of data processing steps, without having to come up with names for what is often temporary variables, but it comes at the expense of introspection of these intermediate variables... much like the Unix `tee`-command, which prints what's piped into it, while also piping it's input to the next function.

![pandas_tee](https://user-images.githubusercontent.com/2641327/52121370-b1c79700-261f-11e9-8f56-c66fc5278b0c.png)

The simplest way to achieve this is AFAIK to do:
```python
def tee(df):
    print(df)
    return df

# Apply method_1 to df, print the result, and apply method_2 to the output of df.method_1().
result = (df.method_1()
            .pipe(tee)
            .method_2()
         )
```
The line with the `tee`-function could simply be commented out using a single character, instead of having to comment out the `method_2()`-line and move the closing parenthesis (and likely also commenting out a `method_3()`, `method_4()`, ..., `method_n()` ).

But being able to omit the definition of `tee` and replace `.pipe(tee)` with `.tee()` would be preferable, and something which I think will help users adopt method chaining.

`tee` could be more advanced, perhaps something like 
```python
def tee(df, head=0, tail=0, sample=0, title=None, display_function=print):
    """
    Displays subset of df, and return the df-input unmodified.
    Defaut subsample is head=10.
    title-keyword sets a string to be displayed before the df
    is displayed.
    display_function is the function to use for displaying df,
    and defaults to the print function
    """
    concat_list = list()
    if head == tail == sample == 0:
        head = 10
    if head:
        concat_list.append(df.head(head))
    if sample:
        concat_list.append(df.sample(sample))
    if tail:
        concat_list.append(df.tail(tail))
    to_display = pd.concat(concat_list)
    if title:
        display_function(title)
    display_function(to_display)
    return df
```

I suspect that the method-chaining approach is well suited for parallelization, whether being done using Dask, a future version of Pandas or an interface to the Arrow-project.
I also suspect that asking for intermediate values in a distributed system might slow it down considerably, and that ordering of the data could be hard to maintain, so compatibility with a future distributed system might be something to consider if a `tee`-like function is implemented as part of Pandas.

