Memory leak behaviour using MultiIndex from GroupBy objects 
In short: GroupBy group object (got by `get_group()` or by iterating over GroupBy) MultiIndex object is just a window to the original index. When you use this index to create another Series/DataFrame - the whole original index will be copied.

Detailed reproduction:

```python
df = pd.DataFrame({'A': range(1,55), 'B': range(10,550,10)}, 
             index=pd.MultiIndex.from_product([ [ str(i) for i in range(1,10) ], 
                                                [ chr(i) for i in range(ord('A'),ord('G'))] ]) )
df
```
```
1	A	1	10
	B	2	20
	C	3	30
	D	4	40
	E	5	50
	F	6	60
2	A	7	70
	B	8	80
	C	9	90
	D	10	100
	E	11	110
	F	12	120
3	A	13	130
	B	14	140
.... etc ....
```
```
df.memory_usage(deep=True)
```
```
Index    1450
A         432
B         432
dtype: int64
```
remember Index usage!

Now lets do `groupby` and get the first group.
```
A = df.groupby(level=0).get_group("1")
A
```

```
1	A	1	10
	B	2	20
	C	3	30
	D	4	40
	E	5	50
	F	6	60
```

But look at the index:
```
A.index
```
```
MultiIndex(levels=[['1', '2', '3', '4', '5', '6', '7', '8', '9'], ['A', 'B', 'C', 'D', 'E', 'F']],
           labels=[[0, 0, 0, 0, 0, 0], [0, 1, 2, 3, 4, 5]])
```
The original index here!
Memory usage confirms that:

```python
A.memory_usage(deep=True)
```

```
Index    1354
A          48
B          48
dtype: int64
```
But if we iterate - that's ok - we will see the only group '1' part of it:
```python
for el in A.index: print (el)
```
```
('1', 'B')
('1', 'C')
('1', 'D')
('1', 'E')
('1', 'F')
```

Now the main problem. Let's create another series object with the index (as we thought to) from the group '1'
```
r = pd.Series(['o1','o2','o3','o4','o5','o6'], index=A.index)
r
```
```
1  A    o1
   B    o2
   C    o3
   D    o4
   E    o5
   F    o6
dtype: object
```
Seems to be ok? But:

```
r.index
```
```
MultiIndex(levels=[['1', '2', '3', '4', '5', '6', '7', '8', '9'], ['A', 'B', 'C', 'D', 'E', 'F']],
           labels=[[0, 0, 0, 0, 0, 0], [0, 1, 2, 3, 4, 5]])
```
It the copy of the whole original index (with some kind slicing adaptor).

Imagine the repeating this operation with the very big original MultiIndex, as this was in my case. My little script consumes up to 80Gb of memory operating with 200-300thousand rows original dataframe

```
r.memory_usage(deep=True)
```
```
1708
```
Memory usage to big for this Series. 

Let's create the same using another approach:

```
A2 = df.loc["1"]
A2
```
```
    A  B
A  1  10
B  2  20
C  3  30
D  4  40
E  5  50
F  6  60
```
```
A2.memory_usage(deep=True)
```
```
Index    396
A         48
B         48
dtype: int64
```
```
A2.index
```
```
Index(['A', 'B', 'C', 'D', 'E', 'F'], dtype='object')
```

So group got by `.loc[]` copies just the required part of the index

To be accurate to compare, recreate multiindex with key '1' at the first key
```
r2 = pd.Series(['o1','o2','o3','o4','o5','o6'], index=pd.MultiIndex.from_product([['1'], A2.index]))
r2
```
```
r2.memory_usage(deep=True)
```
```
940
```

So, correct behaviour should be do copy the only part of original index when using it in pd.Series constructions here:
```
r = pd.Series(['o1','o2','o3','o4','o5','o6'], index=A.index)
```
<details>

INSTALLED VERSIONS
------------------
commit: None
python: 3.6.4.final.0
python-bits: 64
OS: Darwin
OS-release: 17.4.0
machine: x86_64
processor: i386
byteorder: little
LC_ALL: en_US.UTF-8
LANG: en_US.UTF-8
LOCALE: en_US.UTF-8

pandas: 0.21.0
pytest: None
pip: 9.0.1
setuptools: 36.5.0
Cython: None
numpy: 1.13.1
scipy: None
pyarrow: None
xarray: None
IPython: 6.2.0
sphinx: None
patsy: None
dateutil: 2.6.1
pytz: 2017.2
blosc: None
bottleneck: None
tables: None
numexpr: None
feather: None
matplotlib: 2.0.2
openpyxl: 2.4.8
xlrd: 1.1.0
xlwt: 1.3.0
xlsxwriter: None
lxml: 3.8.0
bs4: 4.6.0
html5lib: 0.999999999
sqlalchemy: 1.2.0
pymysql: 0.7.11.None
psycopg2: None
jinja2: 2.9.6
s3fs: None
fastparquet: None
pandas_gbq: None
pandas_datareader: None

</details>
