The melt method allows for you to select certain columns of data and set them to be index columns which separate out the data. It will then convert the remaining items into variable - value relations. 

```python
         first last  height  weight
person A  John  Doe     5.5     130
       B  Mary   Bo     6.0     150
```
Transforming the data using ```df.melt(id_vars = ["first", "last"])```
```python
  first last variable  value
0  John  Doe   height    5.5
1  Mary   Bo   height    6.0
2  John  Doe   weight  130.0
3  Mary   Bo   weight  150.0
```

The index values 0-3 can also be removed by setting the ignore_index = false.

University of Michigan - Ann Arbor

Data doesn't always come in the format that is very useful or helpful for performing analysis and sometimes can be re-organized to make things easier to view. Reshaping can change the relative position of certain information to help draw emphasis between different pieces of data. Consider the following example:
```python
                     A         B
first second                    
bar   one     0.721555 -0.706771
      two    -1.039575  0.271860
baz   one    -0.424972  0.567020
      two     0.276232 -1.087401
```
Using the ```.stack()``` method the data can be modified to look like this
```python
first  second   
bar    one     A   -0.727965
               B   -0.589346
       two     A    0.339969
               B   -0.693205
baz    one     A   -0.339355
               B    0.593616
       two     A    0.884345
               B    1.591431
```
You can also include an argument when using the stack method to specify which columns you want to stack. The same logic and usage applies when using the inverse function ```.unstack()```.

Both ```.stack()``` and ```.unstack()``` will return a sorted copy of the dataframe. 

Reshaping Data

You can also have multiple levels when reshaping your data. This will help you provide more specificity to how you want your data to be manipulated. If given the following data set:
```python
exp                 A         B         A         B
animal            cat       cat       dog       dog
hair_length      long      long     short     short
0            1.075770 -0.109050  1.643563 -1.469388
1            0.357021 -0.674600 -1.776904 -0.968914
2           -1.294524  0.413738  0.276662 -0.472035
3           -0.013960 -0.362543 -0.006154 -0.923061
```
We can specify a compression of the levels animal and hair_length using ```df.stack(level=["animal", "hair_length"])```. The resulting DF will be
```python
exp                          A         B
  animal hair_length                    
0 cat    long         1.075770 -0.109050
  dog    short        1.643563 -1.469388
1 cat    long         0.357021 -0.674600
  dog    short       -1.776904 -0.968914
2 cat    long        -1.294524  0.413738
  dog    short        0.276662 -0.472035
3 cat    long        -0.013960 -0.362543
  dog    short       -0.006154 -0.923061
```

However if the subgroups do not have the same set of labels i.e long/short or cat/dog then there might be missing data when using stack and unstack methods. i.e.
```python
exp                  B          
animal             dog       cat
first second                    
bar   one     0.805244 -1.206412
      two     1.340309 -1.170299
foo   one     1.607920  1.024180
qux   two     0.769804 -1.281247
```
When you unstack this using ```df.unstack()```
```python
exp            B                              
animal       dog                 cat          
second       one       two       one       two
first                                         
bar     0.805244  1.340309 -1.206412 -1.170299
foo     1.607920       NaN  1.024180       NaN
qux          NaN  0.769804       NaN -1.281247
```

To overcome this issue, you can use the fill_value parameter to modify what the missing values will be set as. It is important that missing values are handled as soon as they show up to avoid it affecting later usage of the data frame causing unexpected behavior.

Advance Stack Manipulation

Reshaping using Melt

Pandas pivot table usage is built for the pivoting of aggregate numerical data. Given the following data frame
```python
        A  B    C         D         E          F
0     one  A  foo  0.341734 -0.317441 2013-01-01
1     one  B  foo  0.959726 -1.236269 2013-02-01
2     two  C  foo -1.110336  0.896171 2013-03-01
3   three  A  bar -0.619976 -0.487602 2013-04-01
4     one  B  bar  0.149748 -0.082240 2013-05-01
..    ... ..  ...       ...       ...        ...
19  three  B  foo  0.690579 -2.213588 2013-08-15
20    one  C  foo  0.995761  1.063327 2013-09-15
21    one  A  bar  2.396780  1.266143 2013-10-15
22    two  B  bar  0.014871  0.299368 2013-11-15
23  three  C  bar  3.357427 -0.863838 2013-12-15

[24 rows x 6 columns]
```
We can pivot it to display the data in column D with index information from columns A and B and column separation using column C with  ```pd.pivot_table(df, values="D", index=["A", "B"], columns=["C"])```.

This will generate the following table. 
```python
C             bar       foo
A     B                    
one   A  1.120915 -0.514058
      B -0.338421  0.002759
      C -0.538846  0.699535
three A -1.181568       NaN
      B       NaN  0.433512
      C  0.588783       NaN
two   A       NaN  1.000985
      B  0.158248       NaN
      C       NaN  0.176180
```

Aggregate functions can also be used. ```pd.pivot_table(df, values="D", index=["B"], columns=["A", "C"], aggfunc=np.sum)``` would produce :
```python
A       one               three                 two          
C       bar       foo       bar       foo       bar       foo
B                                                            
A  2.241830 -1.028115 -2.363137       NaN       NaN  2.001971
B -0.676843  0.005518       NaN  0.867024  0.316495       NaN
C -1.077692  1.399070  1.177566       NaN       NaN  0.352360
```

Learn Before

Related