[Pandas] 판다스 데이터 구조

판다스 데이터 구조

• 판다스는 계층적으로 넘파이(NumPy) 바로 위에 위치하며, 시리즈(Series)와 데이터프레임(DataFrame) 데이터 구조를 지원함으로써 데이터를 빠르게 처리한다.

차원	이름	설명
1	시리즈(Series)	라벨 표시된 1차원의 동일한 형태의 배열
2	데이터프레임(DataFrame)	- 동일하지 않은 형태의 열을 가짐. - 라벨 표시된 2차원의, 크기 변동이 가능한 테이블형 구조

 

• 판다스 데이터 구조는 저차원 데이터를 유연하게 포함하는 컨테이너이다.
• 따라서 데이터프레임은 시리즈의 컨테이너이고, 시리즈는 스칼라의 컨테이너이다.
• 딕셔너리 데이터에서 적용하는 방법을 이용해 이들 컨테이너에 객체들을 넣거나 지울 수 있다.
• 판다스를 사용하기 위해 다음의 모듈을 임포트(Import) 한다.

# 넘파이(NumPy) 라이브러리 불러오기
import numpy as np

# 판다스(Pandas) 라이브러리 불러오기
import pandas as pd

 

• pd 를 사용하고 싶지 않다면 다음과 같이 입력한다.

from pandas import Series, DataFrame

 

• 다음 명령을 입력하여 판다스의 버전을 확인할 수 있다.

print(pd.__version__)

1.3.4

 

시리즈(Series)

• 정수, 문자열, 실수 또는 파이썬 객체 등의 데이터 형식을 가질 수 있는, 라벨 표시된 일차원 배열
• 시리즈 객체는 데이터와 데이터의 인덱스를 나타내는 라벨의 배열을 포함하는 컨테이너이다.
• 다음과 같이 호출하여 사용할 수 있다.

ser = pd.Series(data, index=index)

 

• data
  • 파이썬 딕셔너리형
  • ndarray 
  • 스칼라
• index
  • 축 라벨의 리스트

 

시리즈 객체 생성 방법

• 시리즈 객체는 크게 3가지 방법으로 생성할 수 있다.

 

① ndarray에서 시리즈 객체를 생성하는 방법

• 데이터가 ndarray 라면 이때 index는 데이터와 같은 길이여야 한다.
• index가 전달되지 않으면, 값은 [0, ..., len(data)-1]과 같이 생성된다.

ser = pd.Series(np.random.randn(4), index=['a', 'b', 'c', 'd'])
ser

a    1.396620
b   -0.129831
c    1.818473
d    0.892283
dtype: float64

 

• 클래스 객체인 pandas.Series의 속성 values와 index를 이용해 각 값을 구할 수 있다.

ser.values

array([ 1.39661962, -0.12983117,  1.81847307,  0.8922827 ])

 

ser.index

Index(['a', 'b', 'c', 'd'], dtype='object')

 

② 딕셔너리 데이터에서 시리즈 객체를 생성하는 방법

da = {'seoul' : 2000, 'busan' : 2500, 'daejeon' : 3000}
pd.Series(da)

seoul      2000
busan      2500
daejeon    3000
dtype: int64

 

• 다음과 같이 인덱스를 전달하면 인덱스의 라벨에 상응하는 da 데이터에 값을 적용해 반환한다.

da = {'a' : 0., 'b' : 1., 'c' : 2.}
pd.Series(da)

a    0.0
b    1.0
c    2.0
dtype: float64

 

• NaN(Not a Number) : 판다스에서 사용하는 표준 손실 값 표시자

pd.Series(da, index=['b', 'c', 'd', 'a'])

b    1.0
c    2.0
d    NaN
a    0.0
dtype: float64

 

③ 스칼라 값에서 시리즈 객체를 생성하는 방법

• 스칼라 데이터에서 시리즈 객체를 생성할 때는 라벨 표시를 위한 인덱스를 입력한다.

pd.Series(7., index=['a', 'b', 'c'])

a    7.0
b    7.0
c    7.0
dtype: float64

 

ndarray와의 유사성

• 시리즈는 ndarray와 매우 비슷하며, 넘파이 함수의 인수로 적용할 수 있다.
• 또한 슬라이싱 같은 연산을 수행할 수 있다.

ser[0]

1.3966196208161945

 

ser[:3]

a    1.396620
b   -0.129831
c    1.818473
dtype: float64

 

np.exp(ser)

a    4.041515
b    0.878244
c    6.162442
d    2.440695
dtype: float64

 

딕셔너리와의 유사성

• 시리즈는 인덱스 라벨로 값을 얻고 설정할 수 있다는 점에서 고정된 크기의 딕셔너리와 같다.
• 또한, 다음과 같이 ser 객체의 요소에 새로운 값을 동적 할당해 변경할 수 있다.

ser['a']

1.3966196208161945

 

ser['d']

0.8922827028273252

 

ser

a    1.396620
b   -0.129831
c    1.818473
d    0.892283
dtype: float64

 

넘파이와의 유사성

• 시리즈 객체도 넘파이처럼 산술 연산을 할 수 있다.

ser + ser

a    2.793239
b   -0.259662
c    3.636946
d    1.784565
dtype: float64

 

ser * 2

a    2.793239
b   -0.259662
c    3.636946
d    1.784565
dtype: float64

 

• 시리즈를 연산하면 라벨에 기반해 데이터를 자동 정렬한다는 점에서 ndarray와 차이가 있다.

ser[1:] + ser[:-1]

a         NaN
b   -0.259662
c    3.636946
d         NaN
dtype: float64

 

• 정렬되지 않은 시리즈 간 연산을 수행할 경우, 포함된 인덱스들의 합이 결과로 나타난다.
• 시리즈들을 연산할 때 한 시리즈나 다른 시리즈에서 라벨이 발견되지 않으면 결과는 NaN으로 표시된다.

 

시리즈 이름 설정과 변경

• 시리즈에 name 속성과 rename() 메소드를 적용하면 시리즈 이름을 설정하고 변경할 수 있다.

ser = pd.Series(np.random.randn(5), name='seoul')
ser

0    0.705889
1   -0.721955
2    0.702729
3    0.791814
4    0.469885
Name: seoul, dtype: float64

 

ser1 = ser.rename("busan")
ser1.name

'busan'

 

 

데이터프레임(DataFrame)

• 가장 일반적인 판다스 객체이며, 서로 다른 타입의 열로 구성되고 2차원 행 및 열 라벨을 가진다.
• 데이터프레임 객체는 시리즈 객체가 갖는 속성과 메소드들을 공유한다.
• 데이터프레임 객체는 여러 시리즈 객체를 모아놓은 객체라고 할 수 있다.
• 데이터프레임은 행과 열이 정렬된 데이터로 이루어져 있다.
• 시리즈와 마찬가지로, 데이터프레임에는 다음과 같은 형태의 데이터를 입력할 수 있다.
  • 1차원 ndarrays, 리스트, 딕셔너리 또는 시리즈의 딕셔너리
  • 2차원 ndarray
  • 시리즈 또는 또 다른 데이터프레임
• 데이터에 따라 행 라벨인 인덱스와 열 라벨인 열 인수들을 옵션으로 설정할 수 있다.
  • 그런 경우, 처리된 데이터프레임의 인덱스 또는 열을 생성한다.

 

딕셔너리에서 데이터프레임 객체 생성

• 딕셔너리에서 인덱스로 생성한 데이터프레임은 여러 시리즈 인덱스들의 합집합(Union)이다.

d = {'one' : pd.Series([1., 2., 3.], index=['a', 'b', 'c']),
        'two' : pd.Series([1., 2., 3., 4.], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)
df

 

• 데이터프레임 객체 df에 대한 정보는 info() 메소드를 사용해 확인할 수 있다.
• pandas.DataFrame.info 메소드는 인덱스 dtype, 열 dtype, non-null 값 및 사용된 메모리 크기를 포함하여 데이터프레임에 대한 정보를 출력한다.

df.info()

<class 'pandas.core.frame.DataFrame'>
Index: 4 entries, a to d
Data columns (total 2 columns):
 #   Column  Non-Null Count  Dtype  
---  ------  --------------  -----  
 0   one     3 non-null      float64
 1   two     4 non-null      float64
dtypes: float64(2)
memory usage: 96.0+ bytes

 

df.dtypes

one    float64
two    float64
dtype: object

 

• 인덱스와 열 라벨 순서를 변경할 수 있다.

pd.DataFrame(d, index=['d', 'b', 'a'])

 

pd.DataFrame(d, index=['d', 'b', 'a'], columns=['two', 'three'])

 

• 인덱스와 열 속성을 이용해 각 행과 열 라벨에 접근할 수 있다.

df.index

Index(['a', 'b', 'c', 'd'], dtype='object')

 

df.columns

Index(['one', 'two'], dtype='object')

 

ndarrays나 리스트의 딕셔너리에서 데이터프레임 객체 생성

• 다음으로 리스트의 딕셔너리에서 데이터프레임 객체를 생성한다.

d = {'one' : [1., 2., 3.], 'two' : [3., 2., 1.]}

pd.DataFrame(d)

 

pd.DataFrame(d, index=['a', 'b', 'c'])

 

구조화된 배열 또는 레코드 배열에서 데이터프레임 객체 생성

• 배열이 ndarray 객체인 구조화된 배열에서 데이터프레임 객체를 생성한다.

arr = np.zeros((2, ), dtype=[('A', 'i4'), ('B', 'f4'), ('C', 'a10')])

arr[:] = [(1, 2., 'Hello'), (2, 3, 'World')]

arr

array([(1, 2., b'Hello'), (2, 3., b'World')],
      dtype=[('A', '<i4'), ('B', '<f4'), ('C', 'S10')])

 

pd.DataFrame(arr)

 

pd.DataFrame(arr, index=['first', 'second'])

 

pd.DataFrame(arr, columns=['C', 'A', 'B'])

 

딕셔너리의 리스트에서 데이터프레임 객체 생성

• 딕셔너리의 리스트에서 데이터프레임 객체를 생성하고, 특정 열을 선택해본다.

data = [{'a' : 1, 'b' : 2}, {'a' : 5, 'b' : 10, 'c' : 20}]
pd.DataFrame(data)

 

pd.DataFrame(data, columns=['a', 'b'])

 

튜플의 딕셔너리에서 데이터프레임 객체 생성

• 튜플의 딕셔너리에서 데이터프레임 객체를 생성할 수 있다.

pd.DataFrame({('a', 'b') : {('A', 'B') : 1, ('A', 'C') : 2},
             ('a', 'a') : {('A', 'C') : 1, ('A', 'B') : 4},
             ('a', 'c') : {('A', 'B') : 1, ('A', 'C') : 6},
             ('b', 'a') : {('A', 'C') : 1, ('A', 'B') : 8},
             ('b', 'b') : {('A', 'D') : 1, ('A', 'B') : 10}})

 

데이터프레임 생성자

• DataFrame.form_dict 생성자(Constructor)를 이용해 데이터프레임 객체를 생성할 수 있다.
• 이 생성자는 딕셔너리 또는 유사 배열 시퀀스인 리스트가 있는 dict()를 입력으로 받아서 데이터프레임을 반환한다.

dict([('A', [1, 2, 3]), ('B', [4, 5, 6])])

{'A': [1, 2, 3], 'B': [4, 5, 6]}

 

pd.DataFrame.from_dict(dict([('A', [1, 2, 3]), ('B', [4, 5, 6])]))

 

• 생성자에 orient='index'를 전달하면 키인 A와 B는 행 라벨이 된다.
• columns에는 원하는 열 이름을 전달할 수 있다.

pd.DataFrame.from_dict(dict([('A', [1, 2, 3]), ('B', [4, 5, 6])]), orient='index', columns=['one', 'two', 'three'])

 

• 클래스 객체인 DataFrame.from_records 생성자를 이용해 데이터프레임 객체를 생성할 수 있다.
• 이 생성자에는 튜플의 리스트 또는 구조화된 dtype인 ndarray를 입력할 수 있다.

arr

array([(1, 2., b'Hello'), (2, 3., b'World')],
      dtype=[('A', '<i4'), ('B', '<f4'), ('C', 'S10')])

 

pd.DataFrame.from_records(arr, index='C')

 

 

행과 열의 기본 처리

• 데이터프레임은 행과 열의 테이블 형태인 2차원 배열 데이터 구조를 가진다.
• 이런 데이터를 처리한다는 것은 행과 열을 선택하고, 지우고, 산술 연산을 하고, 이름을 부여하는 등 기본적인 처리를 하는 것 을 의미한다.

 

행 또는 열 선택, 추가, 삭제

• 데이터프레임에서는 딕셔너리형을 연산하는 것과 같은 방법으로 열을 선택하고, 추가하고, 지울 수 있다.

df['one']

a    1.0
b    2.0
c    3.0
d    NaN
Name: one, dtype: float64

 

df['two']

a    1.0
b    2.0
c    3.0
d    4.0
Name: two, dtype: float64

 

df['three'] = df['one'] * df['two']
df['flag'] = df['one'] > 2
df

 

• 열은 삭제할 수 있다.
• pandas.DataFrame.pop 메소드를 이용해 프레임에서 열을 추출하고 그 요소를 시리즈로 반환할 수 있다.

del df['two']    # 열 삭제

df.pop('three')

a    1.0
b    4.0
c    9.0
d    NaN
Name: three, dtype: float64

 

df

 

• 데이터프레임에 스칼라 값을 동적 할당하면 브로드캐스팅으로 열을 채운다.

df['ha'] = 'hiho'
df

 

• 데이터프레임과 다른 인덱스를 가진 시리즈를 삽입할 때는 데이터프레임의 인덱스에 맞춘다.

df['trunced_one'] = df['one'][:2]
df

• df['one'][:2]는 시리즈 객체(pandas.core.series.Series) 타입이다.

 

• DataFrame.insert 함수를 사용하면 데이터프레임의 특정 위치에 열을 삽입할 수 있다.

df.insert(1, 'hi', df['one'])    # 1: 두번째 열, hi: 삽입할 열 라벨, df['one']: 삽입할 값(시리즈형)
df

 

• pandas.Series.drop 함수를 이용하면 인덱스 라벨을 기준으로 시리즈의 요소를 제거하며 요소를 제거한 시리즈 객체를 결과로 반환한다.

ser = pd.Series(data=np.arange(3), index=['A', 'B', 'C'])
ser

A    0
B    1
C    2
dtype: int32

 

ser.drop(labels=['B', 'C'])

A    0
dtype: int32

 

인덱싱과 선택

• 기본적인 인덱싱 적용 방법은 다음과 같다.

적용 방법	구문	결과 타입
열 선택	df[col]	Series
라벨로 행 선택	df.loc[label]	Series
정수 위치로 행 선택	df.iloc[loc]	Series
행 슬라이스	df[5:10]	DataFrame
불리언 벡터로 행 선택	df[bool_vec]	DataFrame

 

pandas.DataFrame.loc와 pandas.DataFrame.iloc

• DataFrame.loc[] 속성
  • 라벨이나 불리언 배열을 이용해 행과 열 그룹에 접근한다.
  • 다음과 같은 형태를 입력할 수 있다.
    • 5 또는 a와 같은 단일 라벨
    • ['a', 'b', 'c']와 같은 리스트나 라벨의 배열
    • a:1와 같이 라벨이 있는 처음과 끝의 범위를 포함하는 슬라이스 객체
    • [True, False, True]와 같이 슬라이싱할 축과 같은 길이의 불리언 배열
    • 호출하는 시리즈나 데이터프레임을 인수로 가지는 호출 함수
• DataFame.iloc[] 속성
  • 주로 축 정수 위치(축의 0부터 length-1까지)와 함께 사용하지만, 불리언 배열도 사용할 수 있다.
  • 다음과 같은 형태의 데이터를 입력할 수 있다.
    • 정수
    • [4, 3, 0]과 같은 리스트나 정수들의 배열
    • 1:7과 같은 정숫값을 가지는 슬라이스 객체
    • 불리언 배열
    • 호출하는 시리즈나 데이터프레임을 인수로 가지는 호출 함수

 

df.loc['b']

one              2.0
hi               2.0
flag           False
ha              hiho
trunced_one      2.0
Name: b, dtype: object

 

• 행을 선택하면 시리즈를 반환하는데, 이때 시리즈의 인덱스가 데이터프레임의 열이다.

df.iloc[2]

one             3.0
hi              3.0
flag           True
ha             hiho
trunced_one     NaN
Name: c, dtype: object

 

데이터 정렬 및 산술 연산

• 데이터프레임 객체 간 연산을 실행하면, 이들 객체의 행과 열을 기준으로 자동으로 정렬된다.

df = pd.DataFrame(np.random.randn(5, 4), columns=['A', 'B', 'C', 'D'])
df2 = pd.DataFrame(np.random.randn(3, 3), columns=['A', 'B', 'C'])
df + df2

 

• 데이터프레임과 시리즈 간 연산을 실행할 때는 데이터프레임 열에 시리즈 인덱스를 정렬한다.
  • 이것은 행 방향으로 브로드캐스팅하는 것과 같다.

df - df.iloc[0]

 

• 데이터프레임과 스칼라 간 연산은 다음과 같이 실행된다.

df * 10 + 2

 

• 불리언 연산자는 다음과 같이 적용된다.

df1 = pd.DataFrame({'a' : [1, 0, 1], 'b' : [0, 1, 1]}, dtype=bool)
df2 = pd.DataFrame({'a' : [0, 1, 1], 'b' : [1, 1, 0]}, dtype=bool)

df1

 

df2

 

df1 & df2

 

df1 | df2

 

df1 ^ df2

 

-df1

 

전치

• 행과 열을 전치(Transpose)하려면 ndarray에서 사용한 것과 같이 T 속성을 적용한다.

df[:2]

 

df[:2].T

 

넘파이 함수들과 데이터프레임 연동

• log, exp, sqrt 등 넘파이 유니버셜 함수와 다른 넘파이 함수들을 데이터프레임과 연동해 사용할 수 있다.

 

df3 = pd.DataFrame(np.arange(12).reshape(3, 4), columns=['A', 'B', 'C', 'D'])

np.exp(df3)

 

np.asarray(df3)

array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

 

 

인덱스 관련 객체

• 판다스에서는 다음을 인덱스 관련 객체로 정한다.
  • Index
  • RangeIndex
  • CategoricalIndex
  • MultiIndex
  • IntervalIndex
  • DatetimeIndex
  • TimedeltaIndex
  • PeriodIndex
  • Int64Index
  • UInt64Index
  • Float64Index
• 이러한 인덱스 객체들은 순서가 있고 자를 수 있는 세트(Set)를 연산 처리하는 불변(Immutable) ndarray이다.
• 인덱스 객체들은 넘파이 배열과 유사하며, 넘파이 배열 객체가 가진 많은 속성을 사용할 수 있다.

 

>>> ind = pd.Index([1, 3, 5, 7, 9, 11])
>>> ind

Int64Index([1, 3, 5, 7, 9, 11], dtype='int64')

>>> ind[::2]
Int64Index([1, 5, 9], dtype='int64')

>>> ind.ndim, ind.shape
(1, (6,))

>>> ind[1] = 6
TypeError: Index does not support mutable operations

• 동적 할당으로 두 번째 위치 요소를 6으로 변경하려 했으나 오류가 발생했다.
  • 인덱스 객체의 변경 불가능한 특성은 다양한 데이터 연산을 안전하고 신뢰성 있게 처리할 수 있도록 한다.
    • 넘파이 배열과 판다스 인덱스 객체의 차이점

 

pandas.Index 클래스

• 순서가 정렬된 요솟값을 가지며, 요솟값은 자를 수 있지만 불변 ndarray 이다.
• 모든 판다스 객체들의 축 라벨을 저장하기 위한 기본 객체

>>> pd.Index([1, 2, 3])
Int64Index([1, 2, 3], dtype='int64')

>>> pd.Index(list('abc'))
Index(['a', 'b', 'c'], dtype='object')

 

pandas.RangleIndex 클래스

• 정수 범위에서 실행하는 불변 인덱스이다.
• 제한된 메모리에 변하지 않는 범위의 데이터를 저장하는 특수한 Int64Index
• 데이터프레임과 시리즈에 명시적인 인덱스를 제공하지 않을 때 기본적으로 사용하는 인덱스 타입

df = pd.DataFrame(np.arange(12).reshape(2, 6), columns=list('ABCDEF'))
df

 

df.index

RangeIndex(start=0, stop=2, step=1)

 

Int64Index, Uint64Index, Float64Index 클래스

• Int64Index 클래스
  • 모든 판다스 객체의 축 라벨을 저장하기 위한 기본 객체
  • 순수하게 정수 라벨을 갖는 특별한 인덱스
  • 64비트 정수의 불변 배열을 나타낸다.
  • 인덱스를 명시하지 않거나 정수를 사용할 때의 기본 인덱스 타입
• Uint64Index 클래스
  • 순서가 정렬되고 자를 수 있는 데이터 세트를 실행할 수 있는 불변 ndarray
  • 모든 판다스 객체의 축 라벨을 저장하는 기본 객체
  • 부호가 할당되지 않은 정수 라벨을 가진 경우 사용되는 특별한 인덱스
• Float64Index 클래스
  • 순서가 정렬되고 자를 수 있는 데이터 세트를 실행할 수 있는 불변 ndarray
  • 모든 판다스 객체의 축 라벨을 저장하는 기본 객체
  • 실수 라벨을 가진 경우 사용되는 특별한 인덱스

 

pandas.CategoricalIndex 클래스

• CategoricalIndex 클래스는 범주(Categorical)를 갖는 산재한 인덱스를 나타낸다.
• 판다스에서 데이터 타입이 범주형이라는 것은 통계학의 범주형 변수와 상응하는 데이터 타입이라는 의미이다.
• 성별, 혈액형, 학년, 출신지, 국적, 주식 시장에서 회사 명칭을 나타내는 심벌 등은 반복적이면서 범위가 제한되어 있는데, 판다스는 이러한 텍스트 데이터 분류들을 수식 연산처럼 처리할 수 있는 기능을 제공한다.
• 이러한 문자열 변수를 범주형 변수로 변환하면 사용 메모리를 절약할 수 있다.

ser = pd.Series(['ha', 'hi'] * 1000)
ser

0       ha
1       hi
2       ha
3       hi
4       ha
        ..
1995    hi
1996    ha
1997    hi
1998    ha
1999    hi
Length: 2000, dtype: object

 

ser.nbytes

16000

 

ser.astype('category')

0       ha
1       hi
2       ha
3       hi
4       ha
        ..
1995    hi
1996    ha
1997    hi
1998    ha
1999    hi
Length: 2000, dtype: category
Categories (2, object): ['ha', 'hi']

 

ser.astype('category').nbytes

2016

 

Pandas.Categorical 클래스

>>> s1 = pd.Categorical([1, 2, 3, 1, 2, 3])
>>> s1
[1, 2, 3, 1, 2, 3]
Categories (3, int64): [1, 2, 3]

>>> type(s1)
pandas.core.arrays.categorical.Categorical

>>> s1.dtype
CategoricalDtype(categories=[1, 2, 3], ordered=False)

>>> s2 = pd.Categorical(['a', 'b', 'c', 'a', 'b', 'c'])
>>> s2
['a', 'b', 'c', 'a', 'b', 'c']
Categories (3, object): ['a', 'b', 'c']

 

• ordered=True 를 입력하면 범주 순서에 따라 정렬되며, 최솟값과 최댓값을 가질 수 있다.

>>> s3 = pd.Categorical(['a', 'b', 'c', 'a', 'b', 'c'], ordered=True, categories=['c', 'b', 'a'])
>>> s3
['a', 'b', 'c', 'a', 'b', 'c']
Categories (3, object): ['c' < 'b' < 'a']

>>> s3.min(), s3.max()
('c', 'a')

 

• 범주를 가지는 시리즈나 데이터프레임의 열에서 범주형 데이터를 생성할 수 있는 몇 가지 방법이 있다.

① 시리즈를 구성할 때 dtype='category' 를 명시해 범주형 데이터를 생성하는 방법

ser = pd.Series(['a', 'b', 'c', 'a'], dtype='category')
ser

0    a
1    b
2    c
3    a
dtype: category
Categories (3, object): ['a', 'b', 'c']

 

② 시리즈나 데이터프레임의 열을 category dtype으로 변환하는 방법

df = pd.DataFrame({'A' : ['a', 'b', 'c', 'a']})
df['B'] = df['A'].astype('category')
df

 

df.dtypes

A      object
B    category
dtype: object

 

③ 데이터프레임 생성자에 dtype='category'를 명시하는 방법

• 데이터프레임의 모든 행은 객체가 생성되는 도중 혹은 생성 후에 범주형으로 한꺼번에 변환할 수 있다.
  • 따라서 데이터프레임 생성시에 dtype='category'를 명시함으로써 데이터프레임 생성 중 범주형으로 변환할 수 있다.

df = pd.DataFrame({'A' : list('abca'), 'B' : list('bccd')}, dtype='category')
df.dtypes

A    category
B    category
dtype: object

 

• 각 열에 존재하는 범주는 다를 수 있으며, 변환은 열 단위로 이루어진다.

df['A']

0    a
1    b
2    c
3    a
Name: A, dtype: category
Categories (3, object): ['a', 'b', 'c']

 

df['B']

0    b
1    c
2    c
3    d
Name: B, dtype: category
Categories (3, object): ['b', 'c', 'd']

 

④ DataFrame.astype()을 사용하는 방법

• DataFame.astype()을 사용하면 데이터프레임의 모든 열을 한꺼번에 범주형으로 변환할 수 있다.

df = pd.DataFrame({'A' : list('abca'), 'B' : list('bccd')})
df_cat = df.astype('category')
df_cat.dtypes

A    category
B    category
dtype: object

 

pandas.MultiIndex 클래스

• 멀티레벨 인덱싱(Multilevel Indexing) 또는 계층적 인덱싱(Hierarchical Indexing)은 특히 고차원 데이터를 분석하고 연산할 때 사용한다.
• 또한 1차원 시리즈나 2차원 데이터프레임 같은 저차원 데이터 구조에 고차원 데이터를 저장하거나 연산할 수 있게 한다.
• MultIndex 객체
  • 판다스 객체에서 축 라벨을 저장하는 표준 인덱스를 계층적으로 처리하는 것과 같다.
  • 유일하게 튜플 배열을 가진다.
• 멀티인덱스(Multiindex)를 생성하려면 헬퍼 메소드인 MultiIndex.from_arrays(), MultiIndex.from_product(), MultiIndex.from_tuples() 중 하나를 사용한다.
  • 헬퍼 메소드 : 주어진 일을 실행하기 위해 클래스를 넘나들며 반복적인 작업을 수행하는 메소드

arr = [[1, 1, 2, 2,], ['red', 'blue', 'red', 'blue']]
pd.MultiIndex.from_arrays(arr, names=('number', 'color'))

MultiIndex([(1,  'red'),
            (1, 'blue'),
            (2,  'red'),
            (2, 'blue')],
           names=['number', 'color'])

 

arr=[['ha', 'ha', 'hi', 'hi', 'ho', 'ho',], ['one', 'two', 'one', 'two', 'one', 'two']]
tuples = list(zip(*arr))
tuples

[('ha', 'one'),
 ('ha', 'two'),
 ('hi', 'one'),
 ('hi', 'two'),
 ('ho', 'one'),
 ('ho', 'two')]

 

ind = pd.MultiIndex.from_tuples(tuples, names=['first', 'second'])
ind

MultiIndex([('ha', 'one'),
            ('ha', 'two'),
            ('hi', 'one'),
            ('hi', 'two'),
            ('ho', 'one'),
            ('ho', 'two')],
           names=['first', 'second'])

 

ser = pd.Series(np.random.randn(6), index=ind)
ser

first  second
ha     one      -0.510980
       two      -1.401836
hi     one      -1.125459
       two      -1.031627
ho     one      -1.288188
       two      -1.198736
dtype: float64

 

• 시리즈나 데이터프레임에 배열의 리스트를 직접 전달하면 멀티인덱스를 자동 생성할 수 있다.

arr = [np.array(['ha', 'ha', 'hi', 'hi', 'ho', 'ho']),
      np.array(['one', 'two', 'one', 'two', 'one', 'two'])]
ser = pd.Series(np.random.randn(6), index=arr)
ser

ha  one   -0.867112
    two    1.493873
hi  one    1.026865
    two   -0.146608
ho  one   -0.934579
    two    2.373558
dtype: float64

 

df = pd.DataFrame(np.random.randn(6, 4), index=arr)
df

 

• 데이터프레임 df의 인덱스를 다음과 같이 구한다.

df.index

MultiIndex([('ha', 'one'),
            ('ha', 'two'),
            ('hi', 'one'),
            ('hi', 'two'),
            ('ho', 'one'),
            ('ho', 'two')],
           )

 

• 판다스 객체의 행이나 열 축에 ind를 인수로 적용한다.

df = pd.DataFrame(np.random.randn(3, 6), index=['A', 'B', 'C'], columns=ind)
df

 

pd.DataFrame(np.random.randn(3, 4), index=ind[:3], columns=ind[:4])

 

• 튜플을 축의 행 라벨로 사용할 수도 있다.

pd.Series(np.random.randn(6), index=tuples)

(ha, one)   -0.301471
(ha, two)    0.048705
(hi, one)    0.433145
(hi, two)    1.006454
(ho, one)   -0.401613
(ho, two)    0.595812
dtype: float64