10 minutes to pandas - Reshaping

Hierarchical Indexing (MultiIndex)

In essence, it enables you to store and manipulate data
with an arbitrary number of dimensions
in lower dimensional data structures like Series (1d) and DataFrame (2d) 

 

MultiIndex 의 효용

The reason that the MultiIndex matters is that it can allow you to do grouping, selection
when loading data from a file, you may wish to generate your own MultiIndex when preparing the data set.

 

Index is like an address, that’s how any data point across the dataframe or series can be accessed.
Indices made it very easy to bring more information easily
Index make filtering very easy and also give you space to move forward and backwards in your data

 

 

Creating a MultiIndex (hierarchical index) object

---

A MultiIndex can be created from 
- a list of arrays (using MultiIndex.from_arrays()),
- an array of tuples (using MultiIndex.from_tuples()),
- a crossed set of iterables (using MultiIndex.from_product()),
- or a DataFrame (using MultiIndex.from_frame()).

df = pd.DataFrame(
    [["bar", "one"], ["bar", "two"], ["foo", "one"], ["foo", "two"]],
    columns=["first", "second"],
)

pd.MultiIndex.from_frame(df)

'''
MultiIndex([('bar', 'one'),
            ('bar', 'two'),
            ('foo', 'one'),
            ('foo', 'two')],
           names=['first', 'second'])
'''

iterables = [["bar", "baz", "foo", "qux"], ["one", "two"]]
pd.MultiIndex.from_product(iterables, names=["first", "second"])

'''
MultiIndex([('bar', 'one'),
            ('bar', 'two'),
            ('baz', 'one'),
            ('baz', 'two'),
            ('foo', 'one'),
            ('foo', 'two'),
            ('qux', 'one'),
            ('qux', 'two')],
           names=['first', 'second'])
'''

 

index 는 행과 열 모두에 적용할 수 있다.
(물론 DataFrame 을 생성할 때에는 index 는 행, columns 는 열이지만!)

df = pd.DataFrame(
    np.random.randn(3, 4), 
    index=["A", "B", "C"], 
    columns=index[:4]
)

 

그리고 행과 열의 위치를 이렇게 바꿀 수도 있다. 

df2 = df.T
df2

 

 

Indexing and Selecting data

---

 

Using loc

Tuple 은 Hierarcy 로 계층을 나타낼 수 있다. 
[("bar", "two")] 는 level = 0 는 "bar", level = 1 는 "two" 인 인덱스를 지칭한다. 

List 는 하나의 차원에서 여러 키를 지정할 때 사용한다.
[["bar", "baz"]] 는 level = 0 에서 "bar", "baz" 인 인덱스를 지칭한다. 

# level = 0 1차원까지 지정
df.loc["bar"]
df.loc["baz":"foo"]
df.loc[["bar", "baz"]]

# level = 1 2차원까지 지정
df.loc[("bar", "two")]
df.loc[("baz", "two"):"foo"]
df.loc[("baz", "two"):("qux", "one")]
df.loc[[("bar", "two"), ("qux", "one")]]

# level = 0 의 특정 값과 level = 1 의 특정값 
df.loc[(['bar', 'baz'], 'one'), 'A']
df.loc[(['bar', 'baz'], 'one'), ]   #, 필수
df.loc[(['bar', 'baz'], 'one'), :]  #, 필수

 

# You should specify all axes in the .loc specifier
.loc 에서는 가급적 모든 축의 정보를 명시해야한다.  

# 에러를 발생시키는 대표적인 사례들
df.loc[(['bar', 'baz'], 'one')]   #, 필수
df.loc[('bar':'qux', 'one'), ]   # () 안에서 : 사용불가

 

Using slicer

You can use slice(None) to select all the contents of that level.
You do not need to specify all the deeper levels, they will be implied as slice(None).

.loc[] 의 대괄호 내부에서 행과 열을 쉼표로 구분한다. 필요할 경우 () 로 행과 열을 감싼다.
첫번째 level 부터 명시한다. () 안의 , 로 차원을 구분한다. 

 

dfmi.loc[(slice("A1", "A3"), slice(None), ["C1", "C3"]), :]

# 행 level = 0 슬라이싱: 'A1' 이상 'A3' 이하
# 행 level = 1 전체
# 행 level = 2 배열: 'C1' 과 'C3'
# 행 level = 3 전체: 별도 표기 없음



dfmi.loc["A1", (slice(None), "foo")]

# 행 level = 0 단수: 'A1'
# 열 level = 0 전체
# 열 level = 1 단수: 'foo'

 

pd.IndexSlice

idx 로 시작하는 [] 배열이므로, 조금 더 가독성이 좋다. 
뒤의 차원은 생략하면 된다. 

idx = pd.IndexSlice
dfmi.loc[idx[:, :, ["C1", "C3"]], idx[:, "foo"]]

# 행 level = 0 전체 / level = 1 전체 / level = 2 C1, C3 
# 컬럼  level = 0 전체, level = 1 foo

 

mask 조건에 부합하는 인덱스만 필터링

특정 값이 조건에 만족하는 경우만 필터링 할 수 있다. 

mask = dfmi[('a', 'foo')] > 200
dfmi.loc[idx[mask, :, ['C1', 'C3']], idx[:, 'foo']]

 

xs()

xs (cross-section) 을 통해 특정 level 차원을 지정할 수 있다.
level 만 잘 명시해주면 되니, 다차원에서 헷갈려할 필요가 없다고.

df.xs("one", level="second")
# df.loc[(slice(None), "one"), :]

df.xs("one", level="second", axis=1)
# df.loc[:, (slice(None), "one")]


df = df.T
df.xs(("one", "bar"), level=("second", "first"), axis=1)

# 생략한 level 에 대해서도 표시하거나, 표시하지 않거나
df.xs('one', level='second', axis=1, drop_level = True)
df.xs('one', level='second', axis=1, drop_level = False)

 

 

Index 정리

---

 

set_index

제시되는 인덱스로 설정한다. 

dfm = pd.DataFrame(
    {"jim": [0, 0, 1, 1], "joe": ["x", "x", "z", "y"], "jolie": np.random.rand(4)}
)

dfm = dfm.set_index(["jim", "joe"])

dfm
'''
            jolie
jim joe          
0   x    0.490671
    x    0.120248
1   z    0.537020
    y    0.110968
'''

 

reset_index

인덱스를 0, 1, 2 등 RangeIndex 로 설정한다. (drop = False, default)
drop 은 하지 않는다! 다른 정보가 더 필요할 때 'key' 로 사용할 수 있기 때문이다. 

df.reset_index()

 

 

stack, unstack

열과 행 axis 를 바꿔본다. 

tuples = list(
    zip(
        *[
            ["bar", "bar", "baz", "baz", "foo", "foo", "qux", "qux"],
            ["one", "two", "one", "two", "one", "two", "one", "two"],
        ]
    )
)


index = pd.MultiIndex.from_tuples(tuples, names=["first", "second"])

df = pd.DataFrame(np.random.randn(4, 2), index=index, columns=["A", "B"])

df
'''
                     A         B
first second                    
bar   one    -0.727965 -0.589346
      two     0.339969 -0.693205
baz   one    -0.339355  0.593616
      two     0.884345  1.591431
'''


      
stacked = df.stack()   # 열을 행으로!
stacked
'''
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
dtype: float64
'''


stacked.unstack()   # index 의 마지막 차원을 열로
stacked.unstack(1)  # index 의 level = 1 차원을 열로

 

reindex

데이터와 인덱스를 독립적으로 생각하자.
해당 인덱스에 대한 데이터가 없으면 기본적으로 NaN 이다. 

index = ['Firefox', 'Chrome', 'Safari', 'IE10', 'Konqueror']
df = pd.DataFrame({'http_status': [200, 200, 404, 404, 301],
                  'response_time': [0.04, 0.02, 0.07, 0.08, 1.0]},
                  index=index)
                  
df
'''
           http_status  response_time
Firefox            200           0.04
Chrome             200           0.02
Safari             404           0.07
IE10               404           0.08
Konqueror          301           1.00
'''


new_index = ['Safari', 'Iceweasel', 'Comodo Dragon', 'IE10',
             'Chrome']
             
df.reindex(new_index)
'''
               http_status  response_time
Safari               404.0           0.07
Iceweasel              NaN            NaN    # 값이 없는 인덱스 NaN
Comodo Dragon          NaN            NaN    # 값이 없는 인덱스 NaN
IE10                 404.0           0.08
Chrome               200.0           0.02
'''


df.reindex(new_index, fill_value=0)

'''
               http_status  response_time
Safari                 404           0.07
Iceweasel                0           0.00      # 값이 없는 인덱스 NaN
Iceweasel                0           0.00      # 값이 없는 인덱스 NaN
Comodo Dragon            0           0.00      
IE10                   404           0.08
Chrome                 200           0.02
'''


df.reindex(['http_status', 'user_agent'], axis="columns")
           http_status  user_agent
Firefox            200         NaN
Chrome             200         NaN
Safari             404         NaN
IE10               404         NaN
Konqueror          301         NaN

 

 

align

두개의 차원을 맞춘다. 

level=0 일 경우, 행의 차원을 맞춘다. (없는 값은 default broadcast 한다. 다른 값을 지정해줄 수도 있다. ) 

df = pd.DataFrame(
    [[1, 2, 3, 4], [6, 7, 8, 9]], columns=["D", "B", "E", "A"], index=[1, 2]
)
other = pd.DataFrame(
    [[10, 20, 30, 40], [60, 70, 80, 90], [600, 700, 800, 900]],
    columns=["A", "B", "C", "D"],
    index=[2, 3, 4],
)

df
'''
D  B  E  A
1  1  2  3  4
2  6  7  8  9
'''

other
'''
    A    B    C    D
2   10   20   30   40
3   60   70   80   90
4  600  700  800  900
'''

left, right = df.align(other, join="outer", axis=1)
# 명시된 axis, 열에 대해 index 를 맞춘다. (A, B, C, D, E)로. 없는 값은 NaN 이다.
left
'''
   A  B   C  D  E
1  4  2 NaN  1  3
2  9  7 NaN  6  8
'''

right
'''
    A    B    C    D   E
2   10   20   30   40 NaN
3   60   70   80   90 NaN
4  600  700  800  900 NaN
'''


left, right = df.align(other, join="outer", axis=0)
# 명시된 axis, 행에 대해 index 를 맞춘다. (1,2,3,4)로. 없는 값은 NaN 이다.

left
'''
    D    B    E    A
1  1.0  2.0  3.0  4.0
2  6.0  7.0  8.0  9.0
3  NaN  NaN  NaN  NaN
4  NaN  NaN  NaN  NaN
'''

right
'''
    A      B      C      D
1    NaN    NaN    NaN    NaN
2   10.0   20.0   30.0   40.0
3   60.0   70.0   80.0   90.0
4  600.0  700.0  800.0  900.0
'''


left, right = df.align(other, join="outer", axis=None)
# 전체 axis 에 대해 index 를 맞춘다. 없는 값은 NaN 이다.

left
'''
     A    B   C    D    E
1  4.0  2.0 NaN  1.0  3.0
2  9.0  7.0 NaN  6.0  8.0
3  NaN  NaN NaN  NaN  NaN
4  NaN  NaN NaN  NaN  NaN
'''

right
'''
       A      B      C      D   E
1    NaN    NaN    NaN    NaN NaN
2   10.0   20.0   30.0   40.0 NaN
3   60.0   70.0   80.0   90.0 NaN
4  600.0  700.0  800.0  900.0 NaN
'''

 

다차원의 reindexing 과 alignment

다차원에서 index 가 변경될 경우, 차원에 맞게 broadcasting (aka. 자기복제) 된다.

midx = pd.MultiIndex(
    levels=[["zero", "one"], ["x", "y"]], codes=[[1, 1, 0, 0], [1, 0, 1, 0]]
)

df = pd.DataFrame(np.random.randn(4, 2), index=midx)
df
'''
               0         1
one  y  1.519970 -0.493662
     x  0.600178  0.274230
zero y  0.132885 -0.023688
     x  2.410179  1.450520
'''


df2 = df.groupby(level=0).mean()  
df2 # (2,2)
'''
             0         1
one   1.060074 -0.109716
zero  1.271532  0.713416
'''

df2.reindex(df.index, level=0)  # (2,2) --> (4,2) 값은 broadcasting (차원에 맞게 복제)
               0         1
one  y  1.060074 -0.109716
     x  1.060074 -0.109716
zero y  1.271532  0.713416
     x  1.271532  0.713416

# aligning
df_aligned, df2_aligned = df.align(df2, level=0)
# df (4,2), df2 (2,2)

df_aligned # (4,2) --> (4,2) 그대로 
'''
               0         1
one  y  1.519970 -0.493662
     x  0.600178  0.274230
zero y  0.132885 -0.023688
     x  2.410179  1.450520
'''


df2_aligned # (2,2) --> (4,2) 값은 broadcasting (차원에 맞게 복제) 
'''               0         1
one  y  1.060074 -0.109716
     x  1.060074 -0.109716
zero y  1.271532  0.713416
     x  1.271532  0.713416
'''