single row DataFrame to Series conversion
#### Code Sample, a copy-pastable example if possible

```python
# prepare data
s = pd.Series(np.arange(4), index=pd.MultiIndex.from_product([list('ab'), list('cd')]))
# note the index 'i' is constant so that groupby would produce a single group
df = pd.DataFrame.from_dict({'i': [True, True, True, True], 'x': np.arange(4), 'y': list('abcd')}).set_index(['i'])

# indexing: irreversible loss of dtype info
# There is no way to compute 'dataframe' result from the 'series' one.
>>> df.iloc[0].dtype                # series
dtype('O')
# vs
>>> df.iloc[[0]].dtypes             # dataframe (desirable output)
x     int64
y    object

# unstack: unexpected shape of double-unstack (should be one-row dataframe) 
>>> s.unstack()          # this produces expected output
   c  d
a  0  1
b  2  3
>>> s.unstack().unstack()           # this should be a one-row dataframe, not series
c  a    0
   b    2
d  a    1
   b    3
dtype: int64

# aggregate; same loss of dtype info as in indexing
>>> def get_1st_row(x):
...:     return x.iloc[0]

>>> df.aggregate(get_1st_row).dtype     # lost type info
dtype('O')
>>> df.groupby('i').aggregate(get_1st_row).dtypes   # desirable output
x     int64
y    object
dtype: object
>>> 

# doesn't play well with iterators.
# There should be no difference between iteration over groups
# in the groupby object, and the aggregation of the groupby object.
# The following two computations are morally equivalent, yet
# their results differ
>>> df2 = pd.concat({k: df for k in range(2)})
>>> df2.groupby(level=0).aggregate(get_1st_row)   # desirable output
   x  y
0  0  a
1  0  a
# vs
>>> pd.concat((_df.aggregate(get_1st_row) for k, _df in df2.groupby(level=0)))  # unexpected output
x    0
y    a
x    0
y    a
dtype: object
```
#### Problem description

Whenever pandas is to return a single-row dataframe it, conventionally, returns a series instead.
Examples of such operations include: a) indexing a single row, b) unstacking, c) dataframe aggregation, and d) groupby aggregation vs iteration over groups.

This leads to loss of dtype information, unexpected output shapes, and shape mismatch between two morally equivalent computations. 

My proposal is to add a new dataframe-row class DFRow(DataFrame) and return an instance of that class instead of returning Series in indexing, aggregation, transposition, and unstack-ing.
Returning a single-row DataFrame w/o casting it to DFRow would create ambiguity in unstack-ing:
DFRow should not be unstack-able (just as Series is not stack-able), but a generic single-row DataFrame should be unstack-able until its index levels are exhausted, at which point unstack() should return DFRow.

**UPDATE**
It turned out there is an existing way of controlling the shape of the output. Here is a workaround:
```
>>> df.aggregate([get_1st_row])
             x  y
get_1st_row  0  a
>>> pd.concat((_df.aggregate([get_1st_row]) for k, _df in df2.groupby(level=0)))
             x  y
get_1st_row  0  a
get_1st_row  0  a
```