5. Pandas 시작하기¶

가장 자주 살펴볼 라이브러리
고수준의 자료구조와 파이썬을 통한 빠르고 쉬운 데이터 분석 도구 포함
NumPy 기반에서 개발되어 NumPy를 사용하는 애플리케이션에서 쉽게 사용

Pandas 개발 동기¶

자동적으로 혹은 명시적으로 축의 이름에 따라 데이터를 정렬할 수 있는 자료 구조. 잘못 정렬된 데이터에 의한 일반적인 오류를 에방하고 다양한 소스에서 가져온 다양한 방식으로 색인되어 있는 데이터를 다룰 수 있는 기능
통합된 시계열 기능
시계열 데이터와 비시계열 데이터를 함께 다룰 수 있는 통합 자료 구조
산술연산과 한 축의 모든 값을 더하는 등의 데이터 축약연산은 축의 이름 같은 메타데이터로 전달될 수 있어야 함
누락된 데이터를 유연하게 처리할 수 있는 기능
SQL 같은 일반 데이터베이스처럼 데이터를 합치고 관계연산을 수행하는 기능
간편함, 단숨함에 대한 기본 방침

Pandas import 컨벤션¶

from pandas import Series, DataFrame

import pandas as pd

pd. 으로 시작하는게 좋지만 Series와 DataFrame은 많이 사용하기 때문에 local namespace로 import 하는 것이 훨씬 편함

5.1 pandas 자료 구조 소개¶

5.1.1. Series¶

Series는 일련의 객체를 담을 수 있는 1차원 배열 같은 자료 구조(어떤 NumPy 자료형이라도 담을 수 있다)
색인이라고 하는 배열의 데이터에 연관된 이름을 가지고 있다.

In [2]:

from pandas import Series, DataFrame
import pandas as pd

In [3]:

obj = Series([4, 7, -5, 3])

In [4]:

# Error! 배열이나 사전형으로 넘겨야 됨
obj2 = Series(4,7)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-4-30f352d974a3> in <module>()
      1 # Error! 배열이나 사전형으로 넘겨야 됨
----> 2 obj2 = Series(4,7)

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/core/series.pyc in __init__(self, data, index, dtype, name, copy, fastpath)
    584 
    585             if index is not None:
--> 586                 index = _ensure_index(index)
    587 
    588             if data is None:

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/core/index.pyc in _ensure_index(index_like, copy)
   2995             index_like = copy(index_like)
   2996 
-> 2997     return Index(index_like)
   2998 
   2999 

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/core/index.pyc in __new__(cls, data, dtype, copy, name, fastpath, **kwargs)
    129         elif np.isscalar(data):
    130             raise TypeError('Index(...) must be called with a collection '
--> 131                              'of some kind, %s was passed' % repr(data))
    132         else:
    133             # other iterable of some kind

TypeError: Index(...) must be called with a collection of some kind, 7 was passed

In [5]:

obj

Out[5]:

0    4
1    7
2   -5
3    3
dtype: int64

왼쪽에 색인
오른쪽에 색인의 값

In [6]:

obj.values

Out[6]:

array([ 4,  7, -5,  3])

In [7]:

obj.index

Out[7]:

Int64Index([0, 1, 2, 3], dtype=int64)

In [8]:

obj2 = Series([4, 7, -5, 3], index=['d', 'b', 'a', 'c'])

In [9]:

obj2

Out[9]:

d    4
b    7
a   -5
c    3
dtype: int64

In [10]:

obj2.index

Out[10]:

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

In [11]:

obj2['a']

Out[11]:

-5

In [12]:

obj2['d'] = 6

In [13]:

obj2[['c', 'a', 'd']]

Out[13]:

c    3
a   -5
d    6
dtype: int64

In [14]:

obj2

Out[14]:

d    6
b    7
a   -5
c    3
dtype: int64

불리언 배열을 사용해서 값을 걸러내거나 산술 곱셈을 수행하거나 또는 수학 함수를 적용하는 등 NumPy 배열연산을 수행해도 색인-값 연결은 유지

In [15]:

obj2[obj2 > 0]

Out[15]:

d    6
b    7
c    3
dtype: int64

In [16]:

obj2 * 2

Out[16]:

d    12
b    14
a   -10
c     6
dtype: int64

In [17]:

np.exp(obj2)

Out[17]:

d     403.428793
b    1096.633158
a       0.006738
c      20.085537
dtype: float64

Series == 고정 길이의 정렬된 사전형¶

In [18]:

'b' in obj2

Out[18]:

True

In [19]:

'e' in obj2

Out[19]:

False

In [20]:

sdata = {'Ohio': 35000,
         'Texas': 71000,
         'Oregon': 16000,
         'Utah': 5000}

In [21]:

obj3 = Series(sdata)

In [21]:

In [22]:

obj3

Out[22]:

Ohio      35000
Oregon    16000
Texas     71000
Utah       5000
dtype: int64

In [23]:

states = ['California', 'Ohio', 'Oregon', 'Texas']

In [24]:

obj4 = Series(sdata, index=states)

In [25]:

obj4

Out[25]:

California      NaN
Ohio          35000
Oregon        16000
Texas         71000
dtype: float64

NaN(not a number)¶

pandas에서는 누락된 값 혹은 NA 값으로 취급
'누락된'과 'NA'를 누락된 데이터로 지칭
pandas의 isnull과 notnull 함수는 누락된 함수를 찾을 때 사용
일반적인 프로그래밍 언어에서는 NULL 이라고도 한다.
각 프로그래밍 언어마다 다르지만 거의 비슷한 개념이 존재한다.

In [26]:

pd.isnull(obj4)

Out[26]:

California     True
Ohio          False
Oregon        False
Texas         False
dtype: bool

In [27]:

pd.notnull(obj4)

Out[27]:

California    False
Ohio           True
Oregon         True
Texas          True
dtype: bool

Series의 인스턴스 메서드¶

'hi'.isalpha()와 같이 인스턴스에서 바로 사용할 수 있는 편리함

In [28]:

obj4.isnull()

Out[28]:

California     True
Ohio          False
Oregon        False
Texas         False
dtype: bool

In [29]:

obj4.notnull()

Out[29]:

California    False
Ohio           True
Oregon         True
Texas          True
dtype: bool

Seriese의 가장 중요한 기능 - 다르게 색인된 데이터에 대한 산술연산¶

다르게 색인된 데이터에 각각 값이 있어야 하며
intersection이 되지 않는다면 NaN 표시
intersecion이 된다면 해당 operator 연산

In [30]:

obj3

Out[30]:

Ohio      35000
Oregon    16000
Texas     71000
Utah       5000
dtype: int64

In [31]:

obj4

Out[31]:

California      NaN
Ohio          35000
Oregon        16000
Texas         71000
dtype: float64

In [32]:

obj3 + obj4

Out[32]:

California       NaN
Ohio           70000
Oregon         32000
Texas         142000
Utah             NaN
dtype: float64

Series 객체와 Series의 색인은 모두 name 속성 존재¶

In [33]:

obj4.name = 'population'

In [34]:

obj4.index.name = 'state'

In [35]:

obj4

Out[35]:

state
California      NaN
Ohio          35000
Oregon        16000
Texas         71000
Name: population, dtype: float64

In [36]:

obj

Out[36]:

0    4
1    7
2   -5
3    3
dtype: int64

In [37]:

obj.index = ['Bob', 'Steve', 'Jeff', 'Ryan']

In [38]:

obj

Out[38]:

Bob      4
Steve    7
Jeff    -5
Ryan     3
dtype: int64

In [39]:

# 색인의 갯수를 맞춰줘야 한다. 당연하지.
obj.index = ['Bob', 'Steve', 'Jeff']

---------------------------------------------------------------------------
Exception                                 Traceback (most recent call last)
<ipython-input-39-f453eb87918d> in <module>()
      1 # 색인의 갯수를 맞춰줘야 한다. 당연하지.
----> 2 obj.index = ['Bob', 'Steve', 'Jeff']

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/core/generic.pyc in __setattr__(self, name, value)
   1271                 existing = getattr(self, name)
   1272                 if isinstance(existing, Index):
-> 1273                     object.__setattr__(self, name, value)
   1274                 elif name in self._info_axis:
   1275                     self[name] = value

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/lib.so in pandas.lib.AxisProperty.__set__ (pandas/lib.c:30028)()

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/core/series.pyc in _set_axis(self, axis, labels, fastpath)
    707         object.__setattr__(self, '_index', labels)
    708         if not fastpath:
--> 709             self._data.set_axis(axis, labels)
    710 
    711     def _set_subtyp(self, is_all_dates):

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/core/internals.pyc in set_axis(self, axis, value)
   3031         if len(value) != len(cur_axis):
   3032             raise Exception('Length mismatch (%d vs %d)'
-> 3033                             % (len(value), len(cur_axis)))
   3034         self.axes[axis] = value
   3035         self._shape = None

Exception: Length mismatch (3 vs 4)

5.1.2. DataFrame¶

표 같은 스프레드시트 형식의 자료 구조로 여러 개의 컬럼
각 컬럼은 서로 다른 종류의 값(숫자, 문자열, 불리언) 담을 수 있다
DataFrame은 로우와 컬럼에 대한 색인 존재.
이 DataFrame은 색인의 모양이 같은 Series 객체를 담고 있는 파이썬 사전으로 생각하면 편하다.
R의 data.frame 같은 다른 DataFrame과 비슷한 자료 구조와 비교했을 때, DataFrame에서의 로우 연산과 컬럼 연산은 거의 대칭적으로 취급
내부적으로 데이터는 하나 이상의 2차원 배열에 저장
고차원의 표 형식 데이터를 나중에 살펴볼 계층적 색인(Hierachical indexing)을 통해 쉽게 표현(고급 기능에 필수적인 요소)

DataFrame 객체 생성¶

같은 길이의 리스트에 담긴 사전 이용
NumPy 배열 이용

In [40]:

data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada'],
        'year': [2000, 2001, 2002, 2001, 2002],
        'pop': [1.5, 1.7, 3.6, 2.4, 2.9]}

In [41]:

frame = DataFrame(data)

In [42]:

frame

Out[42]:

	pop	state	year
0	1.5	Ohio	2000
1	1.7	Ohio	2001
2	3.6	Ohio	2002
3	2.4	Nevada	2001
4	2.9	Nevada	2002

In [43]:

# 원하는 순서대로 Column 지정 가능
# SQL에서 SELECT year, state pop FROM data 와 비슷하게 컬럼명 순서를 지정할 수 있다.
DataFrame(data, columns=['year', 'state', 'pop'])

Out[43]:

	year	state	pop
0	2000	Ohio	1.5
1	2001	Ohio	1.7
2	2002	Ohio	3.6
3	2001	Nevada	2.4
4	2002	Nevada	2.9

In [44]:

frame2 = DataFrame(data, columns=['year', 'state', 'pop', 'debt'],
                   index=['one', 'two', 'three', 'four', 'five'])

In [45]:

frame2

Out[45]:

	year	state	pop	debt
one	2000	Ohio	1.5	NaN
two	2001	Ohio	1.7	NaN
three	2002	Ohio	3.6	NaN
four	2001	Nevada	2.4	NaN
five	2002	Nevada	2.9	NaN

In [46]:

frame2.columns

Out[46]:

Index([u'year', u'state', u'pop', u'debt'], dtype=object)

In [47]:

type(frame2)

Out[47]:

pandas.core.frame.DataFrame

DataFrame 컬럼 접근 방법¶

사전 형식의 표기법으로 접근(frame2['state'])
속성 형식으로 접근(frame2.state)

In [48]:

frame2['state']

Out[48]:

one        Ohio
two        Ohio
three      Ohio
four     Nevada
five     Nevada
Name: state, dtype: object

In [49]:

frame2.state

Out[49]:

one        Ohio
two        Ohio
three      Ohio
four     Nevada
five     Nevada
Name: state, dtype: object

In [50]:

frame2.year

Out[50]:

one      2000
two      2001
three    2002
four     2001
five     2002
Name: year, dtype: int64

로우는 위치나 ix같은 몇 가지 메서드를 통해 접근 가능¶

In [51]:

frame2.ix['three']

Out[51]:

year     2002
state    Ohio
pop       3.6
debt      NaN
Name: three, dtype: object

In [52]:

# error 컬럼값인 year를 넣었을 시
frame2.ix['year']

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-52-d889787286f0> in <module>()
      1 # error 컬럼값인 year를 넣었을 시
----> 2 frame2.ix['year']

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/core/indexing.pyc in __getitem__(self, key)
     52             return self._getitem_tuple(key)
     53         else:
---> 54             return self._getitem_axis(key, axis=0)
     55 
     56     def _get_label(self, label, axis=0):

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/core/indexing.pyc in _getitem_axis(self, key, axis)
    582                     return self._get_loc(key, axis=axis)
    583 
--> 584             return self._get_label(key, axis=axis)
    585 
    586     def _getitem_iterable(self, key, axis=0):

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/core/indexing.pyc in _get_label(self, label, axis)
     64             return self.obj._xs(label, axis=axis, copy=False)
     65         except Exception:
---> 66             return self.obj._xs(label, axis=axis, copy=True)
     67 
     68     def _get_loc(self, key, axis=0):

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/core/frame.pyc in xs(self, key, axis, level, copy, drop_level)
   2171                                     drop_level=drop_level)
   2172         else:
-> 2173             loc = self.index.get_loc(key)
   2174 
   2175             if isinstance(loc, np.ndarray):

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/core/index.pyc in get_loc(self, key)
    824         loc : int if unique index, possibly slice or mask if not
    825         """
--> 826         return self._engine.get_loc(_values_from_object(key))
    827 
    828     def get_value(self, series, key):

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/index.so in pandas.index.IndexEngine.get_loc (pandas/index.c:3330)()

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/index.so in pandas.index.IndexEngine.get_loc (pandas/index.c:3210)()

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/hashtable.so in pandas.hashtable.PyObjectHashTable.get_item (pandas/hashtable.c:10484)()

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/hashtable.so in pandas.hashtable.PyObjectHashTable.get_item (pandas/hashtable.c:10438)()

KeyError: 'year'

In [53]:

# row name으로는 사전형식으로 접근 불가
frame2['three']

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-53-c83454b4dc1c> in <module>()
      1 # row name으로는 사전형식으로 접근 불가
----> 2 frame2['three']

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/core/frame.pyc in __getitem__(self, key)
   1827             return self._getitem_multilevel(key)
   1828         else:
-> 1829             return self._getitem_column(key)
   1830 
   1831     def _getitem_column(self, key):

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/core/frame.pyc in _getitem_column(self, key)
   1834         # get column
   1835         if self.columns.is_unique:
-> 1836             return self._get_item_cache(key)
   1837 
   1838         # duplicate columns

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/core/generic.pyc in _get_item_cache(self, item)
    782         res = cache.get(item)
    783         if res is None:
--> 784             values = self._data.get(item)
    785             res = self._box_item_values(item, values)
    786             cache[item] = res

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/core/internals.pyc in get(self, item)
   2349     def get(self, item):
   2350         if self.items.is_unique:
-> 2351             _, block = self._find_block(item)
   2352             return block.get(item)
   2353         else:

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/core/internals.pyc in _find_block(self, item)
   2638 
   2639     def _find_block(self, item):
-> 2640         self._check_have(item)
   2641         for i, block in enumerate(self.blocks):
   2642             if item in block:

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/core/internals.pyc in _check_have(self, item)
   2645     def _check_have(self, item):
   2646         if item not in self.items:
-> 2647             raise KeyError('no item named %s' % com.pprint_thing(item))
   2648 
   2649     def reindex_axis(self, new_axis, indexer=None, method=None, axis=0, fill_value=None, limit=None, copy=True):

KeyError: u'no item named three'

In [54]:

frame2[0]

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-54-d9f68b2221a2> in <module>()
----> 1 frame2[0]

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/core/frame.pyc in __getitem__(self, key)
   1827             return self._getitem_multilevel(key)
   1828         else:
-> 1829             return self._getitem_column(key)
   1830 
   1831     def _getitem_column(self, key):

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/core/frame.pyc in _getitem_column(self, key)
   1834         # get column
   1835         if self.columns.is_unique:
-> 1836             return self._get_item_cache(key)
   1837 
   1838         # duplicate columns

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/core/generic.pyc in _get_item_cache(self, item)
    782         res = cache.get(item)
    783         if res is None:
--> 784             values = self._data.get(item)
    785             res = self._box_item_values(item, values)
    786             cache[item] = res

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/core/internals.pyc in get(self, item)
   2349     def get(self, item):
   2350         if self.items.is_unique:
-> 2351             _, block = self._find_block(item)
   2352             return block.get(item)
   2353         else:

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/core/internals.pyc in _find_block(self, item)
   2638 
   2639     def _find_block(self, item):
-> 2640         self._check_have(item)
   2641         for i, block in enumerate(self.blocks):
   2642             if item in block:

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/core/internals.pyc in _check_have(self, item)
   2645     def _check_have(self, item):
   2646         if item not in self.items:
-> 2647             raise KeyError('no item named %s' % com.pprint_thing(item))
   2648 
   2649     def reindex_axis(self, new_axis, indexer=None, method=None, axis=0, fill_value=None, limit=None, copy=True):

KeyError: u'no item named 0'

컬럼 대입 가능¶

스칼라 값이나 배열의 값 대입 가능

In [55]:

frame2['debt'] = 16.5

In [56]:

frame2

Out[56]:

	year	state	pop	debt
one	2000	Ohio	1.5	16.5
two	2001	Ohio	1.7	16.5
three	2002	Ohio	3.6	16.5
four	2001	Nevada	2.4	16.5
five	2002	Nevada	2.9	16.5

In [57]:

frame2['debt'] = np.arange(5.)

In [58]:

frame2

Out[58]:

	year	state	pop	debt
one	2000	Ohio	1.5	0
two	2001	Ohio	1.7	1
three	2002	Ohio	3.6	2
four	2001	Nevada	2.4	3
five	2002	Nevada	2.9	4

In [59]:

# Length of values does not match length of index
frame2['debt'] = np.arange(10)

---------------------------------------------------------------------------
AssertionError                            Traceback (most recent call last)
<ipython-input-59-0ba39660d42a> in <module>()
      1 # Length of values does not match length of index
----> 2 frame2['debt'] = np.arange(10)

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/core/frame.pyc in __setitem__(self, key, value)
   1922         else:
   1923             # set column
-> 1924             self._set_item(key, value)
   1925 
   1926     def _setitem_slice(self, key, value):

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/core/frame.pyc in _set_item(self, key, value)
   1969         ensure homogeneity.
   1970         """
-> 1971         value = self._sanitize_column(key, value)
   1972         NDFrame._set_item(self, key, value)
   1973 

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/core/frame.pyc in _sanitize_column(self, key, value)
   2010             else:
   2011                 if len(value) != len(self.index):
-> 2012                     raise AssertionError('Length of values does not match '
   2013                                          'length of index')
   2014 

AssertionError: Length of values does not match length of index

리스트나 배열을 칼럼에 대입할 때는 대입하려는 값의 길이가 DataFrame의 크기와 같아야 한다.
Series를 대입하면 DataFrame의 색인에 따라 값이 대입되며 없는 색인에는 값이 대입되지 않는다.

In [60]:

val = Series([-1.2, -1.5, -1.7], index=['two', 'four', 'five'])

In [61]:

val

Out[61]:

two    -1.2
four   -1.5
five   -1.7
dtype: float64

In [62]:

type(val)

Out[62]:

pandas.core.series.Series

In [63]:

frame2['debt'] = val

In [64]:

frame2

Out[64]:

	year	state	pop	debt
one	2000	Ohio	1.5	NaN
two	2001	Ohio	1.7	-1.2
three	2002	Ohio	3.6	NaN
four	2001	Nevada	2.4	-1.5
five	2002	Nevada	2.9	-1.7

In [65]:

frame2['eastern'] = frame2.state == 'Ohio'

In [66]:

frame2

Out[66]:

	year	state	pop	debt	eastern
one	2000	Ohio	1.5	NaN	True
two	2001	Ohio	1.7	-1.2	True
three	2002	Ohio	3.6	NaN	True
four	2001	Nevada	2.4	-1.5	False
five	2002	Nevada	2.9	-1.7	False

In [67]:

del frame2['eastern']

In [68]:

frame2.columns

Out[68]:

Index([u'year', u'state', u'pop', u'debt'], dtype=object)

In [69]:

frame2

Out[69]:

	year	state	pop	debt
one	2000	Ohio	1.5	NaN
two	2001	Ohio	1.7	-1.2
three	2002	Ohio	3.6	NaN
four	2001	Nevada	2.4	-1.5
five	2002	Nevada	2.9	-1.7

DataFrame의 색인을 이용해서 생성된 칼럼은 내부 데이터에 대한 view이며 복사가 이루어지지 않는다.
따라서 이렇게 얻은 Series 객체에 대한 변경은 실제 DataFrame에 반영된다.
복사본이 필요할 때는 Series의 copy 메서드를 이용하자

중첩된 사전을 이용해서 데이터 생성¶

In [70]:

pop = {'Nevada': {2001: 2.4,
                  2002: 2.9},
       'Ohio': {2000: 1.5,
                2001: 1.7,
                2002: 3.6}}

In [71]:

pop

Out[71]:

{'Nevada': {2001: 2.4, 2002: 2.9}, 'Ohio': {2000: 1.5, 2001: 1.7, 2002: 3.6}}

In [72]:

type(pop)

Out[72]:

dict

In [73]:

frame3 = DataFrame(pop)

In [74]:

frame3

Out[74]:

	Nevada	Ohio
2000	NaN	1.5
2001	2.4	1.7
2002	2.9	3.6

In [75]:

type(frame3)

Out[75]:

pandas.core.frame.DataFrame

In [76]:

frame3['Ohio'][:-1]

Out[76]:

2000    1.5
2001    1.7
Name: Ohio, dtype: float64

In [77]:

frame3['Nevada'][:2]

Out[77]:

2000    NaN
2001    2.4
Name: Nevada, dtype: float64

로우, 컬럼 변경¶

In [78]:

frame3.T

Out[78]:

	2000	2001	2002
Nevada	NaN	2.4	2.9
Ohio	1.5	1.7	3.6

index를 직접 지정한다면 지정된 색인으로 DataFrame 생성¶

In [79]:

DataFrame(pop, index=[2001, 2002, 2003])

Out[79]:

	Nevada	Ohio
2001	2.4	1.7
2002	2.9	3.6
2003	NaN	NaN

In [80]:

DataFrame(pop)

Out[80]:

	Nevada	Ohio
2000	NaN	1.5
2001	2.4	1.7
2002	2.9	3.6

Series 객체를 담고 있는 사전 데이터도 같은 방식으로 취급¶

In [81]:

pdata = {'Ohio': frame3['Ohio'][:-1],
         'Nevada': frame3['Nevada'][:2]}

In [82]:

pdata

Out[82]:

{'Nevada': 2000    NaN
 2001    2.4
 Name: Nevada, dtype: float64, 'Ohio': 2000    1.5
 2001    1.7
 Name: Ohio, dtype: float64}

In [83]:

type(pdata)

Out[83]:

dict

In [84]:

DataFrame(pdata)

Out[84]:

	Nevada	Ohio
2000	NaN	1.5
2001	2.4	1.7

In [85]:

frame3

Out[85]:

	Nevada	Ohio
2000	NaN	1.5
2001	2.4	1.7
2002	2.9	3.6

In [86]:

frame3.index.name = 'year'; frame3.columns.name = 'state'

In [87]:

frame3

Out[87]:

state	Nevada	Ohio
year
2000	NaN	1.5
2001	2.4	1.7
2002	2.9	3.6

새로운 index를 생성하려고 했는데 계속 바뀌기만 하네..?¶

In [88]:

frame3.index.name = 'year3';

In [89]:

frame3

Out[89]:

state	Nevada	Ohio
year3
2000	NaN	1.5
2001	2.4	1.7
2002	2.9	3.6

In [90]:

 frame3.columns.name = 'state3'

In [91]:

frame3

Out[91]:

state3	Nevada	Ohio
year3
2000	NaN	1.5
2001	2.4	1.7
2002	2.9	3.6

In [92]:

frame3.values

Out[92]:

array([[ nan,  1.5],
       [ 2.4,  1.7],
       [ 2.9,  3.6]])

DataFrame의 칼럼에 서로 다른 dtype이 있다면 모든 칼럼을 수용하기 위해 그 칼럼 배열의 dtype이 선택된다.¶

In [93]:

frame2.values

Out[93]:

array([[2000, 'Ohio', 1.5, nan],
       [2001, 'Ohio', 1.7, -1.2],
       [2002, 'Ohio', 3.6, nan],
       [2001, 'Nevada', 2.4, -1.5],
       [2002, 'Nevada', 2.9, -1.7]], dtype=object)

DataFrame 생성자에서 사용 가능한 입력 데이터¶

형	설명
2차원 ndarray	데이터를 담고 있는 행렬. 선택적으로 로우와 칼럼의 이름을 전달할 수 있다.
배열, 리스트, 튜플의 사전	사전의 모든 항목은 같은 길이를 가져야 하며, 각 항목의 내용이 DataFrame의 칼럼이 된다.
NumPy의 구조화 배열	배열의 사전과 같은 방식으로 취급된다.
Series 사전	Series의 각 값이 컬럼이 된다. 명시적으로 색인을 넘겨주지 않으면 각 Series의 색인이 하나로 합쳐져서 형의 색인이 된다.
사전의 사전	내부에 있는 사전이 칼럼이 된다. 키 값은 'Series의 사전'과 마찬가지로 합쳐져 로우의 색인이 된다.
사전이나 Series의 리스트	리스트의 각 항목이 DataFrame의 로우가 된다. 합쳐진 사전의 키 값이나 Series의 색인이 DataFrame 칼럼의 이름이 된다.
리스트나 튜플의 리스트	'2차원 ndarray'와 같은 방식으로 취급된다.
다른 DataFrame	색인이 따로 지정되지 않는다면 DataFrame의 색인이 그대로 사용된다.
NumPy MaskedArray	'2차원 ndarray'와 같은 방식으로 취급되지만 마스크 값은 반환되는 DataFrame에서 NA 값이 된다.

5.1.3 색인 객체¶

pandas의 색인 객체는 표 형식의 데이터에서 각 로우와 칼럼에 대한 이름과 다른 메타데이터(축의 이름 등)를 저장하는 객체
Series나 DataFrame 객체를 생성할 때 사용하는 배열이나 혹은 다른 순차적인 이름은 내부적으로 색인으로 변환

In [94]:

obj = Series(range(3), index=['a', 'b', 'c'])

In [95]:

index = obj.index

In [96]:

index

Out[96]:

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

In [97]:

index[1:]

Out[97]:

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

In [98]:

# 색인 객체 변경 불가
index[1] = 'd'

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-98-cc123079b99c> in <module>()
      1 # 색인 객체 변경 불가
----> 2 index[1] = 'd'

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/core/base.pyc in _disabled(self, *args, **kwargs)
    139         """This method will not function because object is immutable."""
    140         raise TypeError("'%s' does not support mutable operations." %
--> 141                         self.__class__)
    142 
    143     __setitem__ = __setslice__ = __delitem__ = __delslice__ = _disabled

TypeError: '<class 'pandas.core.index.Index'>' does not support mutable operations.

In [99]:

index = pd.Index(np.arange(3))

In [100]:

index

Out[100]:

Int64Index([0, 1, 2], dtype=int64)

In [101]:

# index=는 함수의 키워드, 뒤의 index는 변수
obj2 = Series([1.5, -2.5, 0], index=index)

In [102]:

obj2

Out[102]:

0    1.5
1   -2.5
2    0.0
dtype: float64

In [103]:

obj2.index is index

Out[103]:

True

In [104]:

obj2.index

Out[104]:

Int64Index([0, 1, 2], dtype=int64)

In [105]:

index

Out[105]:

Int64Index([0, 1, 2], dtype=int64)

pandas의 주요 Index 객체¶

클래스	설명
Index	가장 일반적인 Index 객체이며, 파이썬 객체의 NumPy 배열 형식으로 축의 이름을 표현한다.
Int64Index	정수 값을 위한 특수한 Index
MultiIndex	단일 축에 여러 단계의 색인을 표현하는 계층적 색인 객체. 튜플의 배열과 유사하다고 볼 수 있다.
DatetimeIndex	나노초 타임스탬프를 저장한다(NumPy의 datetime64 dtype으로 표현된다).
PeriodIndex	기간 데이터를 위한 특수한 Index

In [106]:

frame3

Out[106]:

state3	Nevada	Ohio
year3
2000	NaN	1.5
2001	2.4	1.7
2002	2.9	3.6

In [107]:

'Ohio' in frame3.columns

Out[107]:

True

In [108]:

2003 in frame3.index

Out[108]:

False

색인 메서드 append 연습¶

연습해보고 싶으신 분들은 index.tab 눌러서 어떤 메소드가 있는지 확인하고 테스트 해보면 좋겠습니다.
대부분 상식적으로 있을법한 메소드들이 있네요.
그냥 이런 것들이 있구나 하고 머리속에 Indexing만 하고 나중에 필요할 때 직접 써보는 것을 추천합니다.
모든 메소드들을 테스트 해보고 익히는게 가장 좋겠지만 시간이 부족하니까요.

In [109]:

index

Out[109]:

Int64Index([0, 1, 2], dtype=int64)

In [110]:

index2 = pd.Index(np.arange(5))

In [111]:

index2

Out[111]:

Int64Index([0, 1, 2, 3, 4], dtype=int64)

In [112]:

sum_index = index.append(index2)

In [113]:

index

Out[113]:

Int64Index([0, 1, 2], dtype=int64)

In [114]:

sum_index

Out[114]:

Int64Index([0, 1, 2, 0, 1, 2, 3, 4], dtype=int64)

색인 메서드와 속성¶

메서드	설명
append	추가적인 Index 객체를 덧붙여 새로운 색인을 반환한다.
diff	색인의 차집합을 반환한다.
intersection	색인의 교집합을 반환한다.
union	색인의 합집합을 반환한다.
isin	넘겨받은 값이 해당 색인 위치에 존재하는지 알려주는 불리언 배열을 반환한다.
delete	i 위치의 색인이 삭제된 새로운 색인을 반환한다.
drop	넘겨받은 값이 삭제된 새로운 색인을 반환한다.
insert	i 위치에 값이 추가된 새로운 색인을 반환한다.
is_monotonic	색인이 단조성을 가진다면 True를 반환한다.
is_unique	중복되는 색인이 없다면 True를 반환한다.
unique	색인에서 중복되는 요소를 제거하고 유일한 값만을 반환한다.

5.2 핵심 기능¶

Series나 DataFrame에 저장된 데이터를 다루는 기본 방법 설명
중요한 기능에만 초점

5.2.1 재색인¶

저자 말로는 기막힌 기능중 하나가 reindex 라고 하는데 왜 중요한지 모르겠다. 당연한거 아닌가? 아직 실제적으로 데이터를 분석해 보는 일을 안해서 못 느끼는 걸 수도 있다.
reindex: 새로운 색인에 맞도록 객체를 새로 생성하는 기능

In [115]:

obj = Series([4.5, 7.2, -5.3, 3.6], index=['d', 'b', 'a', 'c'])

In [116]:

obj

Out[116]:

d    4.5
b    7.2
a   -5.3
c    3.6
dtype: float64

Series 객체에 대해 reindex를 호출하면 데이터를 새로운 색인에 맞게 재배열하고, 없는 색인 값이 있다면 비어있는 값을 새로 추가¶

In [117]:

obj2 = obj.reindex(['a', 'b', 'c', 'd', 'e'])

In [118]:

obj2

Out[118]:

a   -5.3
b    7.2
c    3.6
d    4.5
e    NaN
dtype: float64

In [119]:

# fill_value는 데이터 이가 빠진걸 채워넣을 수 있기 때문에 매우 좋은 기능이다.
obj.reindex(['a', 'b', 'c', 'd', 'e'], fill_value=0)

Out[119]:

a   -5.3
b    7.2
c    3.6
d    4.5
e    0.0
dtype: float64

객체가 원래 뷰에 대한 수정이 이루어지는 것인지? 아니면 복사한 객체에 대해 수정이 이루어지는 것인지? 명확하지 않다..¶

In [120]:

obj

Out[120]:

d    4.5
b    7.2
a   -5.3
c    3.6
dtype: float64

시계열 같은 순차적인 데이터를 재색인할 때 값을 보간하거나 채워 넣어야 할 경우¶

ffill을 사용하여 앞의 값으로 누락된 값을 채워 넣을 수 있다

In [121]:

obj3 = Series(['blue', 'purple', 'yellow'], index=[0, 2, 3])

In [122]:

obj3

Out[122]:

0      blue
2    purple
3    yellow
dtype: object

In [123]:

obj3.reindex(range(6), method='ffill')

Out[123]:

0      blue
1      blue
2    purple
3    yellow
4    yellow
5    yellow
dtype: object

reindex 메서드(보간) 옵션¶

인자	설명
ffill 또는 pad	앞의 값으로 채워 넣는다.
bfill 또는 backfill	뒤의 값으로 채워 넣는다.

In [124]:

frame = DataFrame(np.arange(9).reshape((3, 3)), index=['a', 'c', 'd'],
                  columns=['Ohio', 'Texas', 'California'])

In [125]:

frame

Out[125]:

	Ohio	Texas	California
a	0	1	2
c	3	4	5
d	6	7	8

In [126]:

frame2 = frame.reindex(['a', 'b', 'c', 'd'])

In [127]:

frame2

Out[127]:

	Ohio	Texas	California
a	0	1	2
b	NaN	NaN	NaN
c	3	4	5
d	6	7	8

In [128]:

states = ['Texas', 'Utah', 'California']

In [129]:

frame.reindex(columns=states)

Out[129]:

	Texas	Utah	California
a	1	NaN	2
c	4	NaN	5
d	7	NaN	8

로우와 칼럼을 모두 한 번에 재색인할 수 있지만 보간은 로우에 대해서만 이루어진다(axis 0)¶

In [130]:

frame

Out[130]:

	Ohio	Texas	California
a	0	1	2
c	3	4	5
d	6	7	8

In [131]:

# 1. 로우를 a,b,c,d로 재색인
# 2. 컬럼을 states로 재색인
# 3. 로우를 ffill로 보간 적용
frame.reindex(index=['a', 'b', 'c', 'd'], method='ffill',
              columns=states)

Out[131]:

	Texas	Utah	California
a	1	NaN	2
b	1	NaN	2
c	4	NaN	5
d	7	NaN	8

In [132]:

frame.ix[['a', 'b', 'c', 'd'], states]

Out[132]:

	Texas	Utah	California
a	1	NaN	2
b	NaN	NaN	NaN
c	4	NaN	5
d	7	NaN	8

In [133]:

frame.reindex?

재색인 함수 인자¶

인자	설명
index	색인으로 사용할 새로운 순서. Index 인스턴스나 다른 순차적인 자료 구조를 사용할 수 있다. 색인은 복사가 이루어지지 않고 그대로 사용된다.
method	보간 메서드
fill_value	재색인 과정 중에 새롭게 나타나는 비어있는 데이터를 채우기 위한 값
limit	전/후 보간 시에 사용할 최대 갭 크기
level	MultiIndex 단계(level)에 단순 색인을 맞춘다. 그렇지 않으면 MultiIndex의 하위 부분집합에 맞춘다.
copy	True인 경우 새로운 색인이 이전 색인과 같더라도 데이터를 복사한다. False라면 두 색인이 같은 경우 데이터를 복사하지 않는다.

5.2.2 하나의 로우 또는 칼럼 삭제하기¶

In [134]:

obj = Series(np.arange(5.), index=['a', 'b', 'c', 'd', 'e'])

In [135]:

obj

Out[135]:

a    0
b    1
c    2
d    3
e    4
dtype: float64

In [136]:

new_obj = obj.drop('c')

In [137]:

new_obj

Out[137]:

a    0
b    1
d    3
e    4
dtype: float64

In [138]:

obj.drop(['d', 'c'])

Out[138]:

a    0
b    1
e    4
dtype: float64

In [139]:

data = DataFrame(np.arange(16).reshape((4, 4)),
                 index=['Ohio', 'Colorado', 'Utah', 'New York'],
                 columns=['one', 'two', 'three', 'four'])

In [140]:

data

Out[140]:

	one	two	three	four
Ohio	0	1	2	3
Colorado	4	5	6	7
Utah	8	9	10	11
New York	12	13	14	15

In [141]:

data.drop(['Colorado', 'Ohio'])

Out[141]:

	one	two	three	four
Utah	8	9	10	11
New York	12	13	14	15

In [142]:

data.drop('two', axis=1)

Out[142]:

	one	three	four
Ohio	0	2	3
Colorado	4	6	7
Utah	8	10	11
New York	12	14	15

In [143]:

# list로 drop 할 목록 넘길 수도 있고
# 컬럼인지 로우인지 선택 가능
data.drop(['two', 'four'], axis=1)

Out[143]:

	one	three
Ohio	0	2
Colorado	4	6
Utah	8	10
New York	12	14

5.2.3 색인하기, 선택하기, 거르기¶

Series의 색인은 NumPy 배열의 색인과 유사하게 동작하는데, Seriese의 색인은 정수가 아니어도 된다는 점이 다르다.¶

In [144]:

obj = Series(np.arange(4.), index=['a', 'b', 'c', 'd'])

In [145]:

#obj = Series([1, 1.1, 2, 3], index=['a', 'b', 'c', 'd'])

In [146]:

obj

Out[146]:

a    0
b    1
c    2
d    3
dtype: float64

In [147]:

obj['b']

Out[147]:

1.0

In [148]:

obj[1]

Out[148]:

1.0

In [149]:

obj[2:4]

Out[149]:

c    2
d    3
dtype: float64

In [150]:

obj[['b', 'a', 'd']]

Out[150]:

b    1
a    0
d    3
dtype: float64

In [151]:

obj[[1, 3]]

Out[151]:

b    1
d    3
dtype: float64

In [152]:

obj[obj < 2]

Out[152]:

a    0
b    1
dtype: float64

라벨 이름으로 슬라이싱하는 것은 시작점과 끝점을 포함한다는 점이 일반 파이썬에서의 슬라이싱과 다른 점이다.¶

In [153]:

obj['b':'c']

Out[153]:

b    1
c    2
dtype: float64

In [154]:

obj['b':'c'] = 5

In [155]:

obj

Out[155]:

a    0
b    5
c    5
d    3
dtype: float64

In [156]:

data = DataFrame(np.arange(16).reshape((4, 4)),
                 index=['Ohio', 'Colorado', 'Utah', 'New York'],
                 columns=['one', 'two', 'three', 'four'])

In [157]:

data

Out[157]:

	one	two	three	four
Ohio	0	1	2	3
Colorado	4	5	6	7
Utah	8	9	10	11
New York	12	13	14	15

In [158]:

data['two']

Out[158]:

Ohio         1
Colorado     5
Utah         9
New York    13
Name: two, dtype: int64

In [159]:

data[['three', 'one']]

Out[159]:

	three	one
Ohio	2	0
Colorado	6	4
Utah	10	8
New York	14	12

슬라이싱으로 로우 선택¶

불리언 배열로 컬럼 선택¶

In [160]:

data[:2]

Out[160]:

	one	two	three	four
Ohio	0	1	2	3
Colorado	4	5	6	7

In [161]:

data[data['three'] > 5]

Out[161]:

	one	two	three	four
Colorado	4	5	6	7
Utah	8	9	10	11
New York	12	13	14	15

In [162]:

data

Out[162]:

	one	two	three	four
Ohio	0	1	2	3
Colorado	4	5	6	7
Utah	8	9	10	11
New York	12	13	14	15

In [163]:

# 실용성에 기인한 문법
data < 5

Out[163]:

	one	two	three	four
Ohio	True	True	True	True
Colorado	True	False	False	False
Utah	False	False	False	False
New York	False	False	False	False

In [164]:

data[data < 5] = 0

In [165]:

data

Out[165]:

	one	two	three	four
Ohio	0	0	0	0
Colorado	0	5	6	7
Utah	8	9	10	11
New York	12	13	14	15

ix 메소드에 대한 개인적인 생각¶

ix가 좋은 것 같다. 왜냐하면 앞은 행, 뒤는 열로 딱 형식이 정해져 있기 때문이다.
다른 메소드들 같은 경우 axis가 0일때 행일때도 있고 열일 때도 있다. 어떤 기준을 가지고 행이 되고, 열이 되는지 불명확하다.
즉, 쓸려면 한 번 검증이 필요하기 때문에 귀찮다.
그냥 ix 메소드를 사용해서 앞은 행, 뒤는 열로 생각할 필요없이 바로 사용하는게 훨씬 나에게 맞는 방법 같다.

In [166]:

data.ix['Colorado', ['two', 'three']]

Out[166]:

two      5
three    6
Name: Colorado, dtype: int64

In [167]:

data.ix[['Colorado', 'Utah'], ['two', 'three']]

Out[167]:

	two	three
Colorado	5	6
Utah	9	10

In [168]:

data.ix[['Colorado', 'Utah'], [3, 0, 1]]

Out[168]:

	four	one	two
Colorado	7	0	5
Utah	11	8	9

In [169]:

data.ix[2]

Out[169]:

one       8
two       9
three    10
four     11
Name: Utah, dtype: int64

In [170]:

data.ix[:'Utah', 'two']

Out[170]:

Ohio        0
Colorado    5
Utah        9
Name: two, dtype: int64

In [171]:

data.ix[data.three > 5, :3]

Out[171]:

	one	two	three
Colorado	0	5	6
Utah	8	9	10
New York	12	13	14

In [172]:

# ,를 기준으로 앞은 행. 뒤로는 열을 나타낸다.
data.ix[data.three > 5, :2]

Out[172]:

	one	two
Colorado	0	5
Utah	8	9
New York	12	13

빈번하게 일어나는 칼럼 선택 작업을 할 때마다 칼럼을 선택하기 위해 frame[:, col]이라고 입력해야 하는 것이 너무과하다고 생각¶

[김정주] - DataFrame에서는 기본적으로 컬럼을 기준으로 계산한다. 왜냐하면 로우보다 컬럼을 기준으로 데이터를 추출하는게 훨씬 많기 때문이다.¶

라벨 색인 기능을 모두 ix에 넣었다.

DataFrame의 값 선택하기¶

방식	설명
obj[val]	DataFrame에서 하나의 칼럼 또는 여러 칼럼을 선택한다. 편의를 위해 불리언 배열, 슬라이스, 불리언 DataFrame(어떤 기준에 근거해서 값을 대입해야 할 때)을 사용할 수 있다.
obj.ix[val]	DataFrame에서 로우의 부분집합을 선택한다.
obj.ix[:, val]	DataFrame에서 칼럼의 부분집합을 선택한다.
obj.ix[val1, val2]	DataFrame에서 로우와 칼럼의 부분집합을 선택한다.
reindex 메서드	하나 이상의 축을 새로운 색인으로 맞춘다.
xs 메서드	라벨 이름으로 단일 로우나 칼럼을 Series 형식으로 선택한다.
icol, irow 메서드	각각 정수 색인으로 단일 로우나 칼럼을 Series 형식으로 선택한다.
get_value, set_value 메서드	로우와 칼럼 이름으로 DataFrame의 값을 선택한다.

5.2.4 산술연산과 데이터 정렬¶

In [173]:

s1 = Series([7.3, -2.5, 3.4, 1.5], index=['a', 'c', 'd', 'e'])

In [174]:

s2 = Series([-2.1, 3.6, -1.5, 4, 3.1], index=['a', 'c', 'e', 'f', 'g'])

In [175]:

s1

Out[175]:

a    7.3
c   -2.5
d    3.4
e    1.5
dtype: float64

In [176]:

s2

Out[176]:

a   -2.1
c    3.6
e   -1.5
f    4.0
g    3.1
dtype: float64

In [177]:

s1 + s2

Out[177]:

a    5.2
c    1.1
d    NaN
e    0.0
f    NaN
g    NaN
dtype: float64

서로 겹치는 색인이 없다면 데이터는 NA 값이 된다.¶

산술연산 시 누락된 값은 전파
DataFrame에서는 로우와 칼럼 모두에 적용

DataFrame과 Series의 차이점은??¶

In [178]:

list('bcd')

Out[178]:

['b', 'c', 'd']

In [179]:

df1 = DataFrame(np.arange(9.).reshape((3, 3)), columns=list('bcd'),
                index=['Ohio', 'Texas', 'Colorado'])

In [180]:

df2 = DataFrame(np.arange(12.).reshape((4, 3)), columns=list('bde'),
                index=['Utah', 'Ohio', 'Texas', 'Oregon'])

In [181]:

df1

Out[181]:

	b	c	d
Ohio	0	1	2
Texas	3	4	5
Colorado	6	7	8

In [182]:

df2

Out[182]:

	b	d	e
Utah	0	1	2
Ohio	3	4	5
Texas	6	7	8
Oregon	9	10	11

In [183]:

df1 + df2

Out[183]:

	b	c	d	e
Colorado	NaN	NaN	NaN	NaN
Ohio	3	NaN	6	NaN
Oregon	NaN	NaN	NaN	NaN
Texas	9	NaN	12	NaN
Utah	NaN	NaN	NaN	NaN

산술연산 메서드에 채워 넣을 값 지정하기¶

In [184]:

df1 = DataFrame(np.arange(12.).reshape((3, 4)), columns=list('abcd'))

In [185]:

df2 = DataFrame(np.arange(20.).reshape((4, 5)), columns=list('abcde'))

In [186]:

df1

Out[186]:

	a	b	c	d
0	0	1	2	3
1	4	5	6	7
2	8	9	10	11

In [187]:

df2

Out[187]:

	a	b	c	d	e
0	0	1	2	3	4
1	5	6	7	8	9
2	10	11	12	13	14
3	15	16	17	18	19

In [188]:

df1 + df2

Out[188]:

	a	b	c	d	e
0	0	2	4	6	NaN
1	9	11	13	15	NaN
2	18	20	22	24	NaN
3	NaN	NaN	NaN	NaN	NaN

In [189]:

# fill value=0인데 왜 4,9,14,19로 채워지지??
df1.add(df2, fill_value=0)

Out[189]:

	a	b	c	d	e
0	0	2	4	6	4
1	9	11	13	15	9
2	18	20	22	24	14
3	15	16	17	18	19

In [190]:

df1.add(df2)

Out[190]:

	a	b	c	d	e
0	0	2	4	6	NaN
1	9	11	13	15	NaN
2	18	20	22	24	NaN
3	NaN	NaN	NaN	NaN	NaN

In [191]:

# 아하! 원래의 df2 값에 fill_value의 값을 더하는군!!
df1.add(df2, fill_value=1)

Out[191]:

	a	b	c	d	e
0	0	2	4	6	5
1	9	11	13	15	10
2	18	20	22	24	15
3	16	17	18	19	20

In [192]:

df1.add(df2, fill_value=2)

Out[192]:

	a	b	c	d	e
0	0	2	4	6	6
1	9	11	13	15	11
2	18	20	22	24	16
3	17	18	19	20	21

In [193]:

# 원래 내가 생각했던 함수의 역할이었지만 잘못된 생각인듯.
df1.reindex(columns=df2.columns, fill_value=0)

Out[193]:

	a	b	c	d
0	0	1	2	3
1	4	5	6	7
2	8	9	10	11

산술연산 메서드¶

메서드	설명
add	덧셈(+)을 위한 메서드
sub	뺄셈(-)을 위한 메서드
div	나눗셈(/)을 위한 메서드
mul	곱셈(*)을 위한 메서드

DataFrame과 Series 간의 연산¶

In [194]:

arr = np.arange(12.).reshape((3, 4))

In [195]:

arr

Out[195]:

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

In [196]:

arr[0]

Out[196]:

array([ 0.,  1.,  2.,  3.])

In [197]:

arr - arr[0]

Out[197]:

array([[ 0.,  0.,  0.,  0.],
       [ 4.,  4.,  4.,  4.],
       [ 8.,  8.,  8.,  8.]])

In [198]:

arr - arr[1]

Out[198]:

array([[-4., -4., -4., -4.],
       [ 0.,  0.,  0.,  0.],
       [ 4.,  4.,  4.,  4.]])

브로드캐스팅¶

In [199]:

frame = DataFrame(np.arange(12.).reshape((4, 3)), columns=list('bde'),
                  index=['Utah', 'Ohio', 'Texas', 'Oregon'])

In [200]:

series = frame.ix[0]

In [201]:

frame

Out[201]:

	b	d	e
Utah	0	1	2
Ohio	3	4	5
Texas	6	7	8
Oregon	9	10	11

In [202]:

series

Out[202]:

b    0
d    1
e    2
Name: Utah, dtype: float64

In [203]:

frame - series

Out[203]:

	b	d	e
Utah	0	0	0
Ohio	3	3	3
Texas	6	6	6
Oregon	9	9	9

기본적으로 DataFrame 과 Series 간의 산술연산은 Series의 색인을 DataFrame의 칼럼에 맞추고 아래 로우로 전파¶

만약 색인 값을 DataFrame의 칼럼이나 Series의 색인에서 찾을 수 없다면 그 객체는 형식을 맞추기 위해 재색인¶

In [204]:

series2 = Series(range(3), index=['b', 'e', 'f']) 

In [205]:

frame + series2

Out[205]:

	b	d	e	f
Utah	0	NaN	3	NaN
Ohio	3	NaN	6	NaN
Texas	6	NaN	9	NaN
Oregon	9	NaN	12	NaN

In [206]:

series2, type(series2)

Out[206]:

(b    0
 e    1
 f    2
 dtype: int64, pandas.core.series.Series)

In [207]:

frame

Out[207]:

	b	d	e
Utah	0	1	2
Ohio	3	4	5
Texas	6	7	8
Oregon	9	10	11

각 로우에 대해 연산을 수행하고 싶다면 산술연산 메서드 사용

In [208]:

series3 = frame['d']

In [209]:

frame

Out[209]:

	b	d	e
Utah	0	1	2
Ohio	3	4	5
Texas	6	7	8
Oregon	9	10	11

In [210]:

series3

Out[210]:

Utah       1
Ohio       4
Texas      7
Oregon    10
Name: d, dtype: float64

In [211]:

# 인자로 넘기는 axis 값은 연산을 적용할 축 번호
# axis=0은 DataFrame의 로우를 따라 연산을 수행
frame.sub(series3, axis=0)

Out[211]:

	b	e
Utah	-1	1
Ohio	-1	1
Texas	-1	1
Oregon	-1	1

5.2.5 함수 적용과 매핑¶

pandas 객체에도 NumPy의 유니버셜 함수(배열의 각 원소에 적용되는 메서드)를 적용 가능

In [212]:

frame = DataFrame(np.random.randn(4, 3), columns=list('bde'),
                  index=['Utah', 'Ohio', 'Texas', 'Oregon'])

In [213]:

np.abs(frame)

Out[213]:

	b	d	e
Utah	1.908651	0.943723	0.250739
Ohio	1.207835	1.298138	0.690437
Texas	1.227648	0.427507	0.235306
Oregon	0.430131	0.873474	0.594105

In [214]:

frame

Out[214]:

	b	d	e
Utah	-1.908651	0.943723	0.250739
Ohio	1.207835	-1.298138	-0.690437
Texas	-1.227648	-0.427507	-0.235306
Oregon	-0.430131	-0.873474	0.594105

자주 사용되는 또 다른 연산은 각 로우나 칼럼의 1차원 배열에 함수를 적용하는 것
DataFrame의 apply 메서드를 통해 수행

In [215]:

f = lambda x: x.max() - x.min()

In [216]:

# Applies function along input axis of DataFrame. 
# Objects passed to functions are Series objects having index either the DataFrame's index(axis=0)
# or the columns (axis=1).
# Return type depends on whether passed function aggregates

frame.apply?

In [217]:

# 1. b 컬럼 기준으로 row 값들을 대상으로
# 2. max값과 min값을 구한다.
# 3. max - min을 한 후 결과값 돌려준다.
# 1.107814 - (-0.026992) = 1.134806
frame.apply(f)

Out[217]:

b    3.116486
d    2.241861
e    1.284542
dtype: float64

In [218]:

# 0.328717 - 0.121724 = 0.206992
frame.apply(f, axis=1)

Out[218]:

Utah      2.852374
Ohio      2.505973
Texas     0.992342
Oregon    1.467579
dtype: float64

In [219]:

frame

Out[219]:

	b	d	e
Utah	-1.908651	0.943723	0.250739
Ohio	1.207835	-1.298138	-0.690437
Texas	-1.227648	-0.427507	-0.235306
Oregon	-0.430131	-0.873474	0.594105

axis의 로우, 컬럼 구분¶

로우¶

frame.sub(series3, axis=0)
frame.apply(f, aixs=1)
df.sum(axis=1)

컬럼¶

frame.sort_index(axis=1)

DataFrame에서 axis=¶

0: row
1: column

배열의 합계나 평균같은 일반적인 통계는 DataFrame의 메서드로 있으므로 apply 메서드를 사용해야만 하는 것은 아니다.
apply 메서드에 전달된 함수는 스칼라 값을 반환할 필요 없으며, Series 또는 여러 값을 반환해도 된다.

In [220]:

def f(x):
    return Series([x.min(), x.max()], index=['min', 'max'])

In [221]:

frame.apply(f)

Out[221]:

	b	d	e
min	-1.908651	-1.298138	-0.690437
max	1.207835	0.943723	0.594105

In [222]:

type(frame.apply(f))

Out[222]:

pandas.core.frame.DataFrame

In [223]:

format = lambda x: '%.2f' % x

In [224]:

frame.applymap(format)

Out[224]:

	b	d	e
Utah	-1.91	0.94	0.25
Ohio	1.21	-1.30	-0.69
Texas	-1.23	-0.43	-0.24
Oregon	-0.43	-0.87	0.59

In [225]:

frame['e'].map(format)

Out[225]:

Utah       0.25
Ohio      -0.69
Texas     -0.24
Oregon     0.59
Name: e, dtype: object

In [226]:

# 원래 float값인데 위에서 string 형식으로 변경했기 때문에 dtype이 object가 됐다.
frame['e']

Out[226]:

Utah      0.250739
Ohio     -0.690437
Texas    -0.235306
Oregon    0.594105
Name: e, dtype: float64

5.2.6 정렬과 순위¶

In [227]:

obj = Series(range(4), index=['d', 'a', 'b', 'c'])

In [228]:

obj.sort_index()

Out[228]:

a    1
b    2
c    3
d    0
dtype: int64

In [229]:

frame = DataFrame(np.arange(8).reshape((2, 4)), index=['three', 'one'],
                  columns=['d', 'a', 'b', 'c'])

In [230]:

frame

Out[230]:

	d	a	b	c
three	0	1	2	3
one	4	5	6	7

In [231]:

frame.sort_index()

Out[231]:

	d	a	b	c
one	4	5	6	7
three	0	1	2	3

In [232]:

frame.sort_index(axis=1)

Out[232]:

	a	b	c	d
three	1	2	3	0
one	5	6	7	4

index, column 모두 만족시키는 정렬은 어떻게 해야돼지???¶

In [233]:

frame.sort_index(axis=1, ascending=False)

Out[233]:

	d	c	b	a
three	0	3	2	1
one	4	7	6	5

In [234]:

obj = Series([4, 7, -3, 2])

In [235]:

# 값에 따라 정렬
obj.order()

Out[235]:

2   -3
3    2
0    4
1    7
dtype: int64

In [236]:

obj = Series([4, np.nan, 7, np.nan, -3, 2])

In [237]:

obj.order()

Out[237]:

4    -3
5     2
0     4
2     7
1   NaN
3   NaN
dtype: float64

정렬시 NaN은 가장 마지막에 위치¶

In [238]:

frame = DataFrame({'b': [4, 7, -3, 2],
                   'a': [0, 1, 0, 1]})

In [239]:

frame

Out[239]:

	a	b
0	0	4
1	1	7
2	0	-3
3	1	2

In [240]:

frame.sort_index(by='b')

Out[240]:

	a	b
2	0	-3
3	1	2
0	0	4
1	1	7

In [241]:

frame.sort_index(by=['a', 'b'])

Out[241]:

	a	b
2	0	-3
0	0	4
3	1	2
1	1	7

뭘 기준으로 rank 하는지 도저히 모르겠다..!! -> 스터디 후 알게 됨¶

In [242]:

obj = Series([7, -5, 7, 4, 2, 0, 4])

In [243]:

obj.rank()

Out[243]:

0    6.5
1    1.0
2    6.5
3    4.5
4    3.0
5    2.0
6    4.5
dtype: float64

Rank 해석¶

-5가 1.0
0이 2.0
2가 3.0
4가 4.5, 왜냐하면 동률이기 때문에 4.0이 안되고 4.0과 5.0의 중간인 4.5가 됨
7도 중복이기 때문에 6.0과 7.0 중간인 6.5가 됨

In [244]:

# 데이터 상에서 나타나는 순서에 따라 순위
obj.rank(method='first')

Out[244]:

0    6
1    1
2    7
3    4
4    3
5    2
6    5
dtype: float64

In [245]:

# 내림차순으로 순위
obj.rank(ascending=False, method='max')

Out[245]:

0    2
1    7
2    2
3    4
4    5
5    6
6    4
dtype: float64

In [246]:

frame = DataFrame({'b': [4.3, 7, -3, 2],
                   'a':[0, 1, 0, 1],
                   'c':[-2, 5, 8, -2.5]})

In [247]:

frame

Out[247]:

	a	b	c
0	0	4.3	-2.0
1	1	7.0	5.0
2	0	-3.0	8.0
3	1	2.0	-2.5

In [248]:

# 0, 4.3, -2.0 에서 rank 정함
frame.rank(axis=1)

Out[248]:

	a	b	c
0	2	3	1
1	1	3	2
2	2	1	3
3	2	3	1

In [249]:

# 0, 1, 0, 1 에서 rank 정함
frame.rank()

Out[249]:

	a	b	c
0	1.5	3	2
1	3.5	4	3
2	1.5	1	4
3	3.5	2	1

순위의 동률을 처리하는 메서드¶

메서드	설명
'average'	기본 값: 같은 값을 가지는 항목의 평균 값을 순위로 삼는다.
'min'	같은 값을 가지는 그룹을 낮은 순위로 매긴다.
'max'	같은 값을 가지는 그룹을 높은 순위로 매긴다.
'first'	데이터 내에서 위치에 따라 순위를 매긴다.

5.2.7 중복 색인¶

In [250]:

obj = Series(range(5), index=['a', 'a', 'b', 'b', 'c'])

In [251]:

obj

Out[251]:

a    0
a    1
b    2
b    3
c    4
dtype: int64

In [252]:

obj.index.is_unique

Out[252]:

False

중복되는 색인 값이 있으면 색인을 이용한 데이터 선택은 다르게 동작하고 하나의 Series 객체 반환
중복되는 색인 값이 없으면 색인을 이용한 데이터 선택은 스칼라 값을 반환

In [253]:

obj['a']

Out[253]:

array([0, 1])

In [254]:

# 책에서는 하나의 Series 객체 반환 한다고 했느데 numpy.ndarray네?!
type(obj['a'])

Out[254]:

numpy.ndarray

In [255]:

obj['c']

Out[255]:

In [256]:

df = DataFrame(np.random.randn(4, 3), index=['a', 'a', 'b', 'b'])

In [257]:

df

Out[257]:

	0	1	2
a	0.284454	1.189586	0.394071
a	0.754665	-1.483700	1.019817
b	0.246102	-1.525030	-0.418855
b	0.575552	0.920265	-0.012548

In [258]:

df.ix['b']

Out[258]:

	0	1	2
b	0.246102	-1.525030	-0.418855
b	0.575552	0.920265	-0.012548

5.3 기술통계 계산과 요약¶

pandas 객체는 일반적인 수학 메서드와 통계 메서드 존재
이 메서드는 대부분 Series나 DataFrame 하나의 칼럼이나 로우에서 단일 값(합이나 평균 같은)을 구하는 축소 혹은 요약통계 범주에 속함
처음부터 누락된 데이터를 제외하도록 설계

In [259]:

df = DataFrame([[1.4, np.nan], [7.1, -4.5],
                [np.nan, np.nan], [0.75, -1.3]],
               index=['a', 'b', 'c', 'd'],
               columns=['one', 'two'])

In [260]:

df

Out[260]:

	one	two
a	1.40	NaN
b	7.10	-4.5
c	NaN	NaN
d	0.75	-1.3

In [261]:

# NaN은 계산 안됨
df.sum()

Out[261]:

one    9.25
two   -5.80
dtype: float64

In [262]:

# 각 로우의 합 반환
df.sum(axis=1)

Out[262]:

a    1.40
b    2.60
c     NaN
d   -0.55
dtype: float64

In [263]:

df.mean(axis=1, skipna=False)

Out[263]:

a      NaN
b    1.300
c      NaN
d   -0.275
dtype: float64

축소 메서드 옵션¶

옵션	설명
axis	연산을 수행할 축. DataFrame에서 0은 로우고 1은 칼럼이다.
skipna	누락된 값을 제외할 것인지 정하는 옵션. 기본값은 True다.
level	계산하려는 축이 계층적 색인(다중 색인)이라면 레벨에 따라 묶어서 계산한다.

In [264]:

# Return index of first occurrence of maximum over requested axis.
# NA/null values are excluded.
df.idxmax?

In [265]:

df.idxmax()

Out[265]:

one    b
two    d
dtype: object

In [266]:

# cumulative. 아래로 갈수록 누산 됨
df.cumsum()

Out[266]:

	one	two
a	1.40	NaN
b	8.50	-4.5
c	NaN	NaN
d	9.25	-5.8

In [267]:

df

Out[267]:

	one	two
a	1.40	NaN
b	7.10	-4.5
c	NaN	NaN
d	0.75	-1.3

In [268]:

df.describe()

Out[268]:

	one	two
count	3.000000	2.000000
mean	3.083333	-2.900000
std	3.493685	2.262742
min	0.750000	-4.500000
25%	1.075000	-3.700000
50%	1.400000	-2.900000
75%	4.250000	-2.100000
max	7.100000	-1.300000

In [269]:

obj = Series(['a', 'a', 'b', 'c'] * 4)

In [270]:

obj.describe()

Out[270]:

count     16
unique     3
top        a
freq       8
dtype: object

In [271]:

obj

Out[271]:

0     a
1     a
2     b
3     c
4     a
5     a
6     b
7     c
8     a
9     a
10    b
11    c
12    a
13    a
14    b
15    c
dtype: object

기술통계와 요약통계¶

메서드	설명
count	NA 값을 제외한 값의 수를 반환한다.
describe	Series나 DataFrame의 각 칼럼에 대한 요약통계를 계산한다.
min, max	최소, 최대값을 계산한다.
argmin, argmax	각각 최소, 최대값을 갖고 있는 색인의 위치(정수)를 반환한다.
idxmin, idxmax	각각 최소, 최대 값을 갖고 있는 색인의 값을 반환한다.
quantile	0부터 1까지의 분위수를 계산한다.
sum	합을 계산한다.
mean	평균을 계산한다.
median	중간 값(50% 분위)을 반환한다.
mad	평균 값에서 절대 평균편차를 구한다.
var	표본 분산의 값을 구한다.
std	표본 정규 분산의 값을 구한다.
skew	표본 비대칭도(3차 적률)의 값을 구한다.
cumsum	누적 합을 구한다.
cummin, cummax	각각 누적 최소 값과 누적 최대 값을 계산한다.
cumprod	누적 곱을 구한다.
diff	1차 산술 차를 구한다(시게열 데이터 처리시 유용하다).
pct_change	퍼센트 변화율을 계산한다.

확률, 통계 모르면 힘들어진다.. 용어부터 이해가 가지 않기 때문에...¶

5.3.1 상관관계와 공분산¶

In [272]:

import pandas.io.data as web

all_data = {}

# GOOG -> GOOGL
for ticker in ['AAPL', 'IBM', 'MSFT', 'GOOGL']:
    all_data[ticker] = web.get_data_yahoo(ticker, '1/1/2000', '5/12/2014')

price = DataFrame({tic: data['Adj Close']
                   for tic, data in all_data.iteritems()})
volume = DataFrame({tic: data['Volume']
                    for tic, data in all_data.iteritems()})

In [273]:

# Percent change over given number of periods
returns = price.pct_change()

In [274]:

returns.tail()

Out[274]:

	AAPL	GOOGL	IBM	MSFT
Date
2014-05-06	-0.010893	-0.023836	-0.006416	-0.009195
2014-05-07	-0.003502	-0.008745	0.001958	0.009023
2014-05-08	-0.001783	0.004189	-0.002060	0.005621
2014-05-09	-0.004167	0.012400	0.006193	-0.002541
2014-05-12	0.012450	0.022426	0.013100	0.010953

In [275]:

price

Out[275]:

<class 'pandas.core.frame.DataFrame'>
DatetimeIndex: 3611 entries, 2000-01-03 00:00:00 to 2014-05-12 00:00:00
Data columns (total 4 columns):
AAPL     3611  non-null values
GOOGL    2449  non-null values
IBM      3611  non-null values
MSFT     3611  non-null values
dtypes: float64(4)

In [276]:

volume

Out[276]:

<class 'pandas.core.frame.DataFrame'>
DatetimeIndex: 3611 entries, 2000-01-03 00:00:00 to 2014-05-12 00:00:00
Data columns (total 4 columns):
AAPL     3611  non-null values
GOOGL    2449  non-null values
IBM      3611  non-null values
MSFT     3611  non-null values
dtypes: float64(1), int64(3)

In [277]:

returns.head()

Out[277]:

	AAPL	GOOGL	IBM	MSFT
Date
2000-01-03	NaN	NaN	NaN	NaN
2000-01-04	-0.084486	NaN	-0.033944	-0.033814
2000-01-05	0.014700	NaN	0.035137	0.010524
2000-01-06	-0.086519	NaN	-0.017284	-0.033422
2000-01-07	0.047577	NaN	-0.004344	0.013029

In [278]:

returns.MSFT

Out[278]:

Date
2000-01-03         NaN
2000-01-04   -0.033814
2000-01-05    0.010524
2000-01-06   -0.033422
2000-01-07    0.013029
2000-01-10    0.007420
2000-01-11   -0.025780
2000-01-12   -0.032510
2000-01-13    0.019015
2000-01-14    0.041155
2000-01-18    0.027253
2000-01-19   -0.072180
2000-01-20   -0.009274
2000-01-21   -0.021321
2000-01-24   -0.023911
...
2014-04-22    0.001261
2014-04-23   -0.007555
2014-04-24    0.004314
2014-04-25    0.001263
2014-04-28    0.023972
2014-04-29   -0.008625
2014-04-30   -0.002734
2014-05-01   -0.009970
2014-05-02   -0.007805
2014-05-05   -0.006597
2014-05-06   -0.009195
2014-05-07    0.009023
2014-05-08    0.005621
2014-05-09   -0.002541
2014-05-12    0.010953
Name: MSFT, Length: 3611

상관관계와 공분산 개념 이해¶

In [279]:

returns.MSFT.corr(returns.IBM)

Out[279]:

0.4984519862052475

In [280]:

returns.MSFT.cov(returns.IBM)

Out[280]:

0.00017666857300561051

In [281]:

returns.corr()

Out[281]:

	AAPL	GOOGL	IBM	MSFT
AAPL	1.000000	0.456068	0.406758	0.414118
GOOGL	0.456068	1.000000	0.397134	0.435762
IBM	0.406758	0.397134	1.000000	0.498452
MSFT	0.414118	0.435762	0.498452	1.000000

In [282]:

returns.cov()

Out[282]:

	AAPL	GOOGL	IBM	MSFT
AAPL	0.000807	0.000220	0.000199	0.000241
GOOGL	0.000220	0.000438	0.000114	0.000156
IBM	0.000199	0.000114	0.000298	0.000177
MSFT	0.000241	0.000156	0.000177	0.000421

In [283]:

#Compute pairwise correlation of columns, excluding NA/null values
returns.corr?

In [284]:

# Compute pairwise covariance of columns, excluding NA/null values
returns.cov?

In [285]:

returns.corrwith(returns.IBM)

Out[285]:

AAPL     0.406758
GOOGL    0.397134
IBM      1.000000
MSFT     0.498452
dtype: float64

In [286]:

returns.corrwith(volume)

Out[286]:

AAPL    -0.062011
GOOGL    0.053223
IBM     -0.032225
MSFT    -0.034290
dtype: float64

5.3.2 유일 값, 값 세기, 멤버십¶

In [287]:

obj = Series(['c', 'a', 'd', 'a', 'a', 'b', 'b', 'c', 'c'])

In [288]:

obj

Out[288]:

0    c
1    a
2    d
3    a
4    a
5    b
6    b
7    c
8    c
dtype: object

In [289]:

uniques = obj.unique()

In [290]:

uniques

Out[290]:

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

In [291]:

obj.value_counts()

Out[291]:

c    3
a    3
b    2
d    1
dtype: int64

In [292]:

obj.value_counts(sort=False, ascending=False)

Out[292]:

a    3
c    3
b    2
d    1
dtype: int64

In [293]:

obj.values

Out[293]:

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

In [294]:

pd.value_counts(obj.values)

Out[294]:

c    3
a    3
b    2
d    1
dtype: int64

In [295]:

pd.value_counts(obj.values, sort=False)

Out[295]:

a    3
c    3
b    2
d    1
dtype: int64

In [296]:

# sort가 True인데 왜 c, a 순으로 나오지..? 이해 불가..
# 책이랑 반대라서 개념 혼란
pd.value_counts(obj.values, sort=True)

Out[296]:

c    3
a    3
b    2
d    1
dtype: int64

In [297]:

obj2 = Series(['c', 'c', 'd', 'd', 'c', 'd'])
pd.value_counts(obj2.values, sort=True)

Out[297]:

c    3
d    3
dtype: int64

In [298]:

obj2 = Series(['d', 'c', 'c', 'd', 'c', 'd'])
pd.value_counts(obj2.values, sort=False)

Out[298]:

d    3
c    3
dtype: int64

In [299]:

mask = obj.isin(['b', 'c'])

In [300]:

mask

Out[300]:

0     True
1    False
2    False
3    False
4    False
5     True
6     True
7     True
8     True
dtype: bool

In [301]:

obj[mask]

Out[301]:

0    c
5    b
6    b
7    c
8    c
dtype: object

In [302]:

obj[True]

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-302-8d9c188ba330> in <module>()
----> 1 obj[True]

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/core/series.pyc in __getitem__(self, key)
    903     def __getitem__(self, key):
    904         try:
--> 905             return self.index.get_value(self, key)
    906         except InvalidIndexError:
    907             pass

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/core/index.pyc in get_value(self, series, key)
    834         k = _values_from_object(key)
    835         try:
--> 836             return self._engine.get_value(s, k)
    837         except KeyError as e1:
    838             if len(self) > 0 and self.inferred_type == 'integer':

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/index.so in pandas.index.IndexEngine.get_value (pandas/index.c:2658)()

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/index.so in pandas.index.IndexEngine.get_value (pandas/index.c:2473)()

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/index.so in pandas.index.IndexEngine.get_loc (pandas/index.c:3177)()

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/index.so in pandas.index.Int64Engine._check_type (pandas/index.c:6304)()

KeyError: True

유일 값, 값 세기, 버리기 메서드¶

메서드	설명
isin	Series의 각 원소가 넘겨받은 연속된 값에 속하는지를 나타내는 불리언 배열을 반환한다.
unique	Series에서 중복되는 값을 제거하고 유일한 값만 포함하는 배열을 반환한다. 결과는 Series에서 발견된 순서대로 반환된다.
value_counts	Series에서 유일 값에 대한 색인 값과 도수를 계산한다. 결과는 도수 값의 내림차순으로 정렬된다.

DataFrame의 여러 로우에 대해 히스토그램을 구해야 하는 경우¶

DataFrame의 apply 함수에 pandas.value_counts를 넘기면 다음과 같은 결과를 얻을 수 있다.
value_counts 메서드의 결과가 DataFrame의 칼럼 크기보다 작을 수 있기 때문에 fillna(0) 함수를 이용해서 비어있는 값은 0으로 채워준다.

이게 도저히 이해가 안된다... 뭘 말하는거지..?? 왠 히스토그램을 구하나? -> 이해됐다. counts 세는거니까 히스토그램이지¶

Qu1에 1이 1개 있고 2는 없고 3은 2개, 4도 2개
Qu2에 1은 1개, 2가 2개, 3이 2개, 4가 0개
Qu3에 1이 1개, 2가 1개, 4가 2개, 5가 1개

In [303]:

data = DataFrame({'Qu1': [1, 3, 4, 3, 4],
                  'Qu2': [2, 3, 1, 2, 3],
                  'Qu3': [1, 5, 2, 4, 4]})

In [304]:

data

Out[304]:

	Qu1	Qu2	Qu3
0	1	2	1
1	3	3	5
2	4	1	2
3	3	2	4
4	4	3	4

In [305]:

result = data.apply(pd.value_counts)

In [306]:

result

Out[306]:

	Qu1	Qu2	Qu3
1	1	1	1
2	NaN	2	1
3	2	2	NaN
4	2	NaN	2
5	NaN	NaN	1

In [307]:

result = data.apply(pd.value_counts).fillna(0)

In [308]:

result

Out[308]:

	Qu1	Qu2	Qu3
1	1	1	1
2	0	2	1
3	2	2	0
4	2	0	2
5	0	0	1

5.4 누락된 데이터 처리하기¶

누락된 데이터를 처리하는 일은 데이터 분석 애플리케이션에서 흔이 있는 일
누락 데이터를 가능한 쉽게 처리
모든 기술통계는 누락된 데이터를 배제하고 처리
누락된 데이터를 실수든 아니든 모두 NaN(Not a Number)으로 취급
누락된 값을 쉽게 찾을 수 있는 파수병 역할

In [309]:

string_data = Series(['aardvark', 'artichoke', np.nan, 'avocado'])

In [310]:

string_data

Out[310]:

0     aardvark
1    artichoke
2          NaN
3      avocado
dtype: object

In [311]:

string_data.isnull()

Out[311]:

0    False
1    False
2     True
3    False
dtype: bool

In [312]:

# Python 내장 None 또한 null 취급
string_data[0] = None

In [313]:

string_data.isnull()

Out[313]:

0     True
1    False
2     True
3    False
dtype: bool

NA 처리 메서드¶

인자	설명
dropna	누락된 데이터가 있는 축(로우, 칼럼)을 제외시킨다. 어느 정도의 누락 데이터까지 용인할 것인지 지정할 수 있다.
fillna	누락된 데이터를 대신할 값을 채우거나 'ffill' 또는 'bfill' 같은 보간 메서드를 적용한다.
isnull	누락되거나 NA인 값을 알려주는 불리언 값이 저장된, 같은 형의 객체를 반환한다.
notnull	isnull과 반대되는 메서드다.

자꾸 드는 의문점¶

이걸 배워서 어디에 써먹을 수 있을까?
지금 내게 당장 필요한 것인가? 현업에서 이 기술을 사용하지 않으면 진행할 수 없는가?
미래를 위한 투자로 봐야 되나?
직접 적용해 볼 예제들이 없으니 심심하다. 예제라도 있으면 실험해 보면서 할 수 있을텐데. 책이 너무 단조롭다. 그냥 문법 공부하는 느낌?

5.4.1 누락된 데이터 골라내기¶

In [314]:

from numpy import nan as NA

In [315]:

data = Series([1, NA, 3.5, NA, 7])

In [316]:

data.dropna()

Out[316]:

0    1.0
2    3.5
4    7.0
dtype: float64

In [317]:

data[data.notnull()]

Out[317]:

0    1.0
2    3.5
4    7.0
dtype: float64

Series와 DataFrame의 차이점은??¶

이걸 이해해야지 진도를 나갈 수 있을 것 같다.
그냥 파이썬 문법이고 약간 어려운 정도라 따라치기는 하지만 아직 어떤 점이 차이가 나는지 모르겠다.
이걸 어떻게 하면 쉽게 이해할 수 있을까?

2번째 보니 이해가 된다.¶

Series는 그냥 1차원 배열로 생각하면 되고
DataFrame은 엑셀 같이 스프레드시트라고 생각하면 될듯하다.
세세하게 차이점을 확인하고 싶다면 책을 참고

In [318]:

data = DataFrame([[1., 6.5, 3.], [1., NA, NA],
                  [NA, NA, NA], [NA, 6.5, 3]])

In [319]:

cleaned = data.dropna()

In [320]:

data

Out[320]:

	0	1	2
0	1	6.5	3
1	1	NaN	NaN
2	NaN	NaN	NaN
3	NaN	6.5	3

In [321]:

# NA가 하나라도 있으면 기본적으로 제외해서 보여줌
cleaned

Out[321]:

	0	1	2
0	1	6.5	3

In [322]:

data.dropna(how='all')

Out[322]:

	0	1	2
0	1	6.5	3
1	1	NaN	NaN
3	NaN	6.5	3

In [323]:

data.dropna?

In [324]:

# Failed. how에 들어가는 인자값이 어떤 것들이 있는지 어떻게 알지? -> any, all 2개만 있네. 
# 명령어 뒤에 ? 붙이면 설명 나옴
data.dropna(how='one')

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-324-649caaa8dea3> in <module>()
      1 # Failed. how에 들어가는 인자값이 어떤 것들이 있는지 어떻게 알지? -> any, all 2개만 있네.
      2 # 명령어 뒤에 ? 붙이면 설명 나옴
----> 3 data.dropna(how='one')

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/core/frame.pyc in dropna(self, axis, how, thresh, subset)
   2616         else:
   2617             if how is not None:
-> 2618                 raise ValueError('do not recognize %s' % how)
   2619             else:
   2620                 raise ValueError('must specify how or thresh')

ValueError: do not recognize one

In [325]:

data[4] = NA

In [326]:

data

Out[326]:

	0	1	2	4
0	1	6.5	3	NaN
1	1	NaN	NaN	NaN
2	NaN	NaN	NaN	NaN
3	NaN	6.5	3	NaN

In [327]:

data

Out[327]:

	0	1	2	4
0	1	6.5	3	NaN
1	1	NaN	NaN	NaN
2	NaN	NaN	NaN	NaN
3	NaN	6.5	3	NaN

In [328]:

# axis=0 is row.
data.dropna(axis=0, how='all')

Out[328]:

	0	1	2	4
0	1	6.5	3	NaN
1	1	NaN	NaN	NaN
3	NaN	6.5	3	NaN

In [329]:

data.dropna(axis=1, how='all')

Out[329]:

	0	1	2
0	1	6.5	3
1	1	NaN	NaN
2	NaN	NaN	NaN
3	NaN	6.5	3

In [330]:

data.dropna(axis=1)

Out[330]:

Int64Index([0, 1, 2, 3], dtype=int64)

Empty DataFrame

In [331]:

df = DataFrame(np.random.randn(7, 3))

In [332]:

df

Out[332]:

	0	1	2
0	1.105290	0.865731	-0.336369
1	-0.955932	0.748322	1.036024
2	-1.679063	0.568578	0.380878
3	-1.082717	0.511421	-0.244171
4	-0.014430	-2.473332	-1.772991
5	-0.384078	0.365353	-0.252302
6	-0.016087	-0.632474	-0.628749

In [333]:

# 여기에서는 :4라고 했으면 정상적으로는 0,1,2,3만 해당이 되야 되는데 4까지 적용이 되네???
# ix는 slicing 마지막 문자까지 포함 됨
df.ix[:4, 1] = NA; df.ix[:2, 2] = NA

In [334]:

df

Out[334]:

	0	1	2
0	1.105290	NaN	NaN
1	-0.955932	NaN	NaN
2	-1.679063	NaN	NaN
3	-1.082717	NaN	-0.244171
4	-0.014430	NaN	-1.772991
5	-0.384078	0.365353	-0.252302
6	-0.016087	-0.632474	-0.628749

thresh¶

몇 개 이상의 값이 들어있는 로우만 살펴보고 싶을 때

In [335]:

df.dropna(thresh=3)

Out[335]:

	0	1	2
5	-0.384078	0.365353	-0.252302
6	-0.016087	-0.632474	-0.628749

In [336]:

df.dropna(thresh=2)

Out[336]:

	0	1	2
3	-1.082717	NaN	-0.244171
4	-0.014430	NaN	-1.772991
5	-0.384078	0.365353	-0.252302
6	-0.016087	-0.632474	-0.628749

5.4.2 누락된 값 채우기¶

누락된 값을 제외시키지 않고(잠재적으로 다른 데이터도 함께 버려질 가능성이 있다) 데이터상의 '구멍'을 어떻게든 메우고 싶은 경우 ffillna 메서드 활용

In [337]:

df.fillna(0)

Out[337]:

	0	1	2
0	1.105290	0.000000	0.000000
1	-0.955932	0.000000	0.000000
2	-1.679063	0.000000	0.000000
3	-1.082717	0.000000	-0.244171
4	-0.014430	0.000000	-1.772991
5	-0.384078	0.365353	-0.252302
6	-0.016087	-0.632474	-0.628749

In [338]:

# dictionary 형식으로 받았는데 앞의 key가 컬럼을 나타냄
df.fillna({1: 0.5, 3: -1})

Out[338]:

	0	1	2
0	1.105290	0.500000	NaN
1	-0.955932	0.500000	NaN
2	-1.679063	0.500000	NaN
3	-1.082717	0.500000	-0.244171
4	-0.014430	0.500000	-1.772991
5	-0.384078	0.365353	-0.252302
6	-0.016087	-0.632474	-0.628749

In [339]:

df.fillna({2:0.5, 1:-1})

Out[339]:

	0	1	2
0	1.105290	-1.000000	0.500000
1	-0.955932	-1.000000	0.500000
2	-1.679063	-1.000000	0.500000
3	-1.082717	-1.000000	-0.244171
4	-0.014430	-1.000000	-1.772991
5	-0.384078	0.365353	-0.252302
6	-0.016087	-0.632474	-0.628749

In [340]:

df.fillna?

In [341]:

# fillna는 값을 채워 넣은 객체의 참조를 반환
_ = df.fillna(0, inplace=True)

In [342]:

df

Out[342]:

	0	1	2
0	1.105290	0.000000	0.000000
1	-0.955932	0.000000	0.000000
2	-1.679063	0.000000	0.000000
3	-1.082717	0.000000	-0.244171
4	-0.014430	0.000000	-1.772991
5	-0.384078	0.365353	-0.252302
6	-0.016087	-0.632474	-0.628749

In [343]:

_ = df.fillna(1, inplace=False)

In [344]:

df

Out[344]:

	0	1	2
0	1.105290	0.000000	0.000000
1	-0.955932	0.000000	0.000000
2	-1.679063	0.000000	0.000000
3	-1.082717	0.000000	-0.244171
4	-0.014430	0.000000	-1.772991
5	-0.384078	0.365353	-0.252302
6	-0.016087	-0.632474	-0.628749

In [345]:

df.fillna(1, inplace=True)

In [346]:

# 이미 NA값이 0.0 으로 채워져있기 때문에 1로 바뀌지 않는다.
df

Out[346]:

	0	1	2
0	1.105290	0.000000	0.000000
1	-0.955932	0.000000	0.000000
2	-1.679063	0.000000	0.000000
3	-1.082717	0.000000	-0.244171
4	-0.014430	0.000000	-1.772991
5	-0.384078	0.365353	-0.252302
6	-0.016087	-0.632474	-0.628749

In [347]:

df = DataFrame(np.random.randn(6, 3))

In [348]:

df.ix[2:, 1] = NA
df.ix[4:, 2] = NA

In [349]:

df

Out[349]:

	0	1	2
0	0.031714	0.522461	1.543997
1	1.084614	-1.225614	-0.680466
2	1.387762	NaN	0.723371
3	-1.152981	NaN	0.283652
4	1.282276	NaN	NaN
5	-1.048720	NaN	NaN

In [350]:

df.fillna(method='ffill')

Out[350]:

	0	1	2
0	0.031714	0.522461	1.543997
1	1.084614	-1.225614	-0.680466
2	1.387762	-1.225614	0.723371
3	-1.152981	-1.225614	0.283652
4	1.282276	-1.225614	0.283652
5	-1.048720	-1.225614	0.283652

In [351]:

df.fillna(method='ffill', limit=2)

Out[351]:

	0	1	2
0	0.031714	0.522461	1.543997
1	1.084614	-1.225614	-0.680466
2	1.387762	-1.225614	0.723371
3	-1.152981	-1.225614	0.283652
4	1.282276	NaN	0.283652
5	-1.048720	NaN	0.283652

In [352]:

data = Series([1., NA, 3.5, NA, 7])

fillna에 평균값이나 중간값을 전달해서 데이터의 높낮이를 줄일 수 있다.

In [353]:

data.fillna(data.mean())

Out[353]:

0    1.000000
1    3.833333
2    3.500000
3    3.833333
4    7.000000
dtype: float64

In [354]:

data

Out[354]:

0    1.0
1    NaN
2    3.5
3    NaN
4    7.0
dtype: float64

fillna 함수 인자¶

인자	설명
value	비어있는 값을 채울 스칼라 값이나 사전 형식의 객체
method	보간 방식. 기본적으로 'ffill'을 사용한다.
axis	값을 채워 넣을 축. 기본 값은 0
inace	복사본을 생성하지 않고 호출한 객체를 변경한다. 기본값은 False
limit	값을 앞 혹은 뒤에서 몇 개까지 채울지를 지정한다.

5.5 계층적 색인¶

계층적 색인은 pandas의 중요한 기능
축에 대해 다중(둘 이상) 색인 단계를 지정할 수 있도록 해준다.
약간 추상적으로 말하면 차원이 높은(고차원) 데이터를 낮은 차원의 형식으로 다룰 수 있게 해주는 기능

In [355]:

data = Series(np.random.randn(10),
              index = [['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'd', 'd'],
                       [1, 2, 3, 1, 2, 3, 1, 2, 2, 3]])

In [356]:

data

Out[356]:

a  1   -0.041546
   2   -1.894623
   3    1.326466
b  1   -0.210593
   2    1.410247
   3    2.717005
c  1    1.639305
   2   -2.528040
d  2   -0.947952
   3   -0.001164
dtype: float64

In [357]:

data.index

Out[357]:

MultiIndex
[(u'a', 1), (u'a', 2), (u'a', 3), (u'b', 1), (u'b', 2), (u'b', 3), (u'c', 1), (u'c', 2), (u'd', 2), (u'd', 3)]

In [358]:

data['b']

Out[358]:

1   -0.210593
2    1.410247
3    2.717005
dtype: float64

In [359]:

data['b':'c']

Out[359]:

b  1   -0.210593
   2    1.410247
   3    2.717005
c  1    1.639305
   2   -2.528040
dtype: float64

In [360]:

data.ix[['b', 'd']]

Out[360]:

b  1   -0.210593
   2    1.410247
   3    2.717005
d  2   -0.947952
   3   -0.001164
dtype: float64

In [361]:

data['b':'d']

Out[361]:

b  1   -0.210593
   2    1.410247
   3    2.717005
c  1    1.639305
   2   -2.528040
d  2   -0.947952
   3   -0.001164
dtype: float64

In [362]:

# Failed!
data['b', 'c']

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-362-c6d18aac3c30> in <module>()
      1 # Failed!
----> 2 data['b', 'c']

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/core/series.pyc in __getitem__(self, key)
    925             key = _check_bool_indexer(self.index, key)
    926 
--> 927         return self._get_with(key)
    928 
    929     def _get_with(self, key):

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/core/series.pyc in _get_with(self, key)
    942             if isinstance(key, tuple):
    943                 try:
--> 944                     return self._get_values_tuple(key)
    945                 except:
    946                     if len(key) == 1:

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/core/series.pyc in _get_values_tuple(self, key)
    990 
    991         # If key is contained, would have returned by now
--> 992         indexer, new_index = self.index.get_loc_level(key)
    993         return self._constructor(self.values[indexer], index=new_index, name=self.name)
    994 

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/core/index.pyc in get_loc_level(self, key, level, drop_level)
   2638                 if len(key) == self.nlevels:
   2639                     if self.is_unique:
-> 2640                         return self._engine.get_loc(_values_from_object(key)), None
   2641                     else:
   2642                         indexer = slice(*self.slice_locs(key, key))

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/index.so in pandas.index.IndexEngine.get_loc (pandas/index.c:3330)()

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/index.so in pandas.index.IndexEngine.get_loc (pandas/index.c:3210)()

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/hashtable.so in pandas.hashtable.PyObjectHashTable.get_item (pandas/hashtable.c:10484)()

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/hashtable.so in pandas.hashtable.PyObjectHashTable.get_item (pandas/hashtable.c:10438)()

KeyError: ('b', 'c')

In [363]:

data[:, 2]

Out[363]:

a   -1.894623
b    1.410247
c   -2.528040
d   -0.947952
dtype: float64

In [364]:

# 현재 index가 multi index니까
# 앞은 a,b,c,d 중에 하나
# 뒤는 1,2,3 중에 하나
data['a',2]

Out[364]:

-1.8946225480802827

In [365]:

# 없는 키니까 당연히 에러. c는 2번째 index가 1,2 밖에 없음
data['c',3]

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-365-668c176dd129> in <module>()
      1 # 없는 키니까 당연히 에러. c는 2번째 index가 1,2 밖에 없음
----> 2 data['c',3]

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/core/series.pyc in __getitem__(self, key)
    925             key = _check_bool_indexer(self.index, key)
    926 
--> 927         return self._get_with(key)
    928 
    929     def _get_with(self, key):

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/core/series.pyc in _get_with(self, key)
    942             if isinstance(key, tuple):
    943                 try:
--> 944                     return self._get_values_tuple(key)
    945                 except:
    946                     if len(key) == 1:

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/core/series.pyc in _get_values_tuple(self, key)
    990 
    991         # If key is contained, would have returned by now
--> 992         indexer, new_index = self.index.get_loc_level(key)
    993         return self._constructor(self.values[indexer], index=new_index, name=self.name)
    994 

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/core/index.pyc in get_loc_level(self, key, level, drop_level)
   2638                 if len(key) == self.nlevels:
   2639                     if self.is_unique:
-> 2640                         return self._engine.get_loc(_values_from_object(key)), None
   2641                     else:
   2642                         indexer = slice(*self.slice_locs(key, key))

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/index.so in pandas.index.IndexEngine.get_loc (pandas/index.c:3330)()

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/index.so in pandas.index.IndexEngine.get_loc (pandas/index.c:3210)()

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/hashtable.so in pandas.hashtable.PyObjectHashTable.get_item (pandas/hashtable.c:10484)()

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/hashtable.so in pandas.hashtable.PyObjectHashTable.get_item (pandas/hashtable.c:10438)()

KeyError: ('c', 3)

In [366]:

data['c', 2]

Out[366]:

-2.5280397543435429

In [367]:

data

Out[367]:

a  1   -0.041546
   2   -1.894623
   3    1.326466
b  1   -0.210593
   2    1.410247
   3    2.717005
c  1    1.639305
   2   -2.528040
d  2   -0.947952
   3   -0.001164
dtype: float64

계층적 색인은 데이터를 재형성하고 피벗 테이블 생성같은 그룹 기반의 작업을 할 때 중요하게 사용
unstack 메서드를 사용해서 데이터를 새롭게 배열 가능

stack은 쌓는다. unstack은 당연히 쌓여져 있는 것을 푼다 라는 의미로 생각됨¶

In [368]:

data.unstack()

Out[368]:

	1	2	3
a	-0.041546	-1.894623	1.326466
b	-0.210593	1.410247	2.717005
c	1.639305	-2.528040	NaN
d	NaN	-0.947952	-0.001164

In [369]:

# 당연히 unstack 후에 다시 stack 하니 다시 돌아가겠지
data.unstack().stack()

Out[369]:

a  1   -0.041546
   2   -1.894623
   3    1.326466
b  1   -0.210593
   2    1.410247
   3    2.717005
c  1    1.639305
   2   -2.528040
d  2   -0.947952
   3   -0.001164
dtype: float64

In [370]:

frame = DataFrame(np.arange(12).reshape((4, 3)),
                  index=[['a', 'a', 'b', 'b'], [1, 2, 1, 2]],
                  columns=[['Ohio', 'Ohio', 'Colorado'],
                           ['Green', 'Red', 'Green']])

In [371]:

frame

Out[371]:

		Ohio		Colorado
		Green	Red	Green
a	1	0	1	2
a	2	3	4	5
b	1	6	7	8
b	2	9	10	11

In [372]:

frame.index.names = ['key1', 'key2']

In [373]:

frame.columns.names = ['state', 'color']

In [374]:

frame

Out[374]:

	state	Ohio		Colorado
	color	Green	Red	Green
key1	key2
a	1	0	1	2
a	2	3	4	5
b	1	6	7	8
b	2	9	10	11

In [375]:

frame['Ohio']

Out[375]:

	color	Green	Red
key1	key2
a	1	0	1
a	2	3	4
b	1	6	7
b	2	9	10

MultiIndex는 따로 생성한 다음에 재사용¶

In [376]:

pd.MultiIndex.from_arrays([['Ohio', 'Ohio', 'Colorado'], ['Green', 'Red', 'Green']],
                       names=['state', 'color'])

Out[376]:

MultiIndex
[(u'Ohio', u'Green'), (u'Ohio', u'Red'), (u'Colorado', u'Green')]

5.5.1 계층 순서 바꾸고 정렬하기¶

swallevel은 넘겨받은 2개의 계층 번호나 이름이 뒤바뀐 새로운 객체를 반환(하지만 데이터는 변경되지 않는다)¶

In [377]:

frame.swaplevel('key1', 'key2')

Out[377]:

	state	Ohio		Colorado
	color	Green	Red	Green
key2	key1
1	a	0	1	2
2	a	3	4	5
1	b	6	7	8
2	b	9	10	11

In [378]:

frame

Out[378]:

	state	Ohio		Colorado
	color	Green	Red	Green
key1	key2
a	1	0	1	2
a	2	3	4	5
b	1	6	7	8
b	2	9	10	11

swaplevel¶

0, 1인 index로도 swap 할 수 있고
이름으로도 swap 할 수 있다.

sortlevel¶

0: key1
1: kye2
이름으로도 할 수 있다.
를 정렬 기준으로 한다는 것

In [379]:

frame.sortlevel?

In [380]:

frame.sortlevel(1)

Out[380]:

	state	Ohio		Colorado
	color	Green	Red	Green
key1	key2
a	1	0	1	2
b	1	6	7	8
a	2	3	4	5
b	2	9	10	11

In [381]:

frame.sortlevel('key2')

Out[381]:

	state	Ohio		Colorado
	color	Green	Red	Green
key1	key2
a	1	0	1	2
b	1	6	7	8
a	2	3	4	5
b	2	9	10	11

In [382]:

frame.sortlevel(0)

Out[382]:

	state	Ohio		Colorado
	color	Green	Red	Green
key1	key2
a	1	0	1	2
a	2	3	4	5
b	1	6	7	8
b	2	9	10	11

In [383]:

frame.sortlevel('key1')

Out[383]:

	state	Ohio		Colorado
	color	Green	Red	Green
key1	key2
a	1	0	1	2
a	2	3	4	5
b	1	6	7	8
b	2	9	10	11

In [384]:

frame.swaplevel(0, 1).sortlevel(0)

Out[384]:

	state	Ohio		Colorado
	color	Green	Red	Green
key2	key1
1	a	0	1	2
1	b	6	7	8
2	a	3	4	5
2	b	9	10	11

In [385]:

frame.swaplevel(0, 1).sortlevel(1)

Out[385]:

	state	Ohio		Colorado
	color	Green	Red	Green
key2	key1
1	a	0	1	2
2	a	3	4	5
1	b	6	7	8
2	b	9	10	11

In [386]:

frame

Out[386]:

	state	Ohio		Colorado
	color	Green	Red	Green
key1	key2
a	1	0	1	2
a	2	3	4	5
b	1	6	7	8
b	2	9	10	11

In [387]:

frame.swaplevel(1, 0)

Out[387]:

	state	Ohio		Colorado
	color	Green	Red	Green
key2	key1
1	a	0	1	2
2	a	3	4	5
1	b	6	7	8
2	b	9	10	11

In [388]:

frame.swaplevel('key2', 'key1')

Out[388]:

	state	Ohio		Colorado
	color	Green	Red	Green
key2	key1
1	a	0	1	2
2	a	3	4	5
1	b	6	7	8
2	b	9	10	11

In [389]:

frame.swaplevel('key1', 'key2')

Out[389]:

	state	Ohio		Colorado
	color	Green	Red	Green
key2	key1
1	a	0	1	2
2	a	3	4	5
1	b	6	7	8
2	b	9	10	11

In [390]:

frame

Out[390]:

	state	Ohio		Colorado
	color	Green	Red	Green
key1	key2
a	1	0	1	2
a	2	3	4	5
b	1	6	7	8
b	2	9	10	11

5.5.2 단계별 요약통계¶

기술통계와 요약통계는 level 옵션을 가지고 있다.
어떠한 축에 대해 합을 구하고 싶은 단계 지정

개인적인 생각으로 프로그래밍 잘 배우는 방법¶

책에 있는대로 먼저 쳐본다.
책에 있는 예제를 변수나 상수들만 살짝 바꿔서 테스트 해본다.
책에 있는 소스들을 나만의 방법으로 다시 재창조 해본다.

In [391]:

frame.sum(level='key1')

Out[391]:

state	Ohio		Colorado
color	Green	Red	Green
key1
a	3	5	7
b	15	17	19

In [392]:

frame.sum(level='key2')

Out[392]:

state	Ohio		Colorado
color	Green	Red	Green
key2
1	6	8	10
2	12	14	16

In [393]:

#  soqnwjrdmfh  pandas의 groupby 기능 이용해서 구현
frame.sum(level='color', axis=1)

Out[393]:

	color	Green	Red
key1	key2
a	1	2	1
a	2	8	4
b	1	14	7
b	2	20	10

In [394]:

frame

Out[394]:

	state	Ohio		Colorado
	color	Green	Red	Green
key1	key2
a	1	0	1	2
a	2	3	4	5
b	1	6	7	8
b	2	9	10	11

5.5.3 DataFrame의 칼럼 사용하기¶

In [395]:

frame = DataFrame({'a': range(7),
                   'b': range(7, 0, -1),
                   'c': ['one', 'one', 'one', 'two', 'two', 'two', 'two'],
                   'd': [0, 1, 2, 0, 1, 2, 3]})

In [396]:

frame

Out[396]:

	a	b	c	d
0	0	7	one	0
1	1	6	one	1
2	2	5	one	2
3	3	4	two	0
4	4	3	two	1
5	5	2	two	2
6	6	1	two	3

In [397]:

frame2 = frame.set_index(['c', 'd'])

In [398]:

frame2

Out[398]:

		a	b
c	d
one	0	0	7
	1	1	6
	2	2	5
two	0	3	4
	1	4	3
	2	5	2
	3	6	1

In [399]:

frame.set_index(['c', 'd'], drop=False)

Out[399]:

		a	b	c	d
c	d
one	0	0	7	one	0
	1	1	6	one	1
	2	2	5	one	2
two	0	3	4	two	0
	1	4	3	two	1
	2	5	2	two	2
	3	6	1	two	3

In [400]:

# 계층적 색인 단계 -> 컬럼
frame2.reset_index()

Out[400]:

	c	d	a	b
0	one	0	0	7
1	one	1	1	6
2	one	2	2	5
3	two	0	3	4
4	two	1	4	3
5	two	2	5	2
6	two	3	6	1

In [401]:

frame2

Out[401]:

		a	b
c	d
one	0	0	7
	1	1	6
	2	2	5
two	0	3	4
	1	4	3
	2	5	2
	3	6	1

5.6 pandas와 관련된 기타 주제¶

5.6.1 정수 색인¶

여기 ser 객체는 0, 1, 2 색인을 가지고 있지만 사용자가 원하는 것이 위치 색인인지? 이름 색인인지 알아맞히는 것은 어려운 일
일관성을 유지하기 위해 색인 값을 가진 축 색인이 있을 경우 정수 데이터는 항상 이름을 지향

In [425]:

ser = Series(np.arange(3.))

In [426]:

# 왼쪽에 있는 것이 이름 색인(0, 1, 2)
# 위치색인은 0, 1, 2 번째 순서대로 있는 것
# 현재는 위치 색인과, 이름 색인이 같기 때문에 프로그램에게는 혼동이 올 수 밖에
ser

Out[426]:

0    0
1    1
2    2
dtype: float64

In [431]:

ser[0]

Out[431]:

0.0

In [433]:

ser[2]

Out[433]:

2.0

In [434]:

# -1이 0,1,2,...,-2,-1 의 정수
ser[-1]

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-434-e3493e85eec5> in <module>()
      1 # -1이 0,1,2,...,-2,-1 의 정수
----> 2 ser[-1]

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/core/series.pyc in __getitem__(self, key)
    903     def __getitem__(self, key):
    904         try:
--> 905             return self.index.get_value(self, key)
    906         except InvalidIndexError:
    907             pass

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/core/index.pyc in get_value(self, series, key)
    834         k = _values_from_object(key)
    835         try:
--> 836             return self._engine.get_value(s, k)
    837         except KeyError as e1:
    838             if len(self) > 0 and self.inferred_type == 'integer':

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/index.so in pandas.index.IndexEngine.get_value (pandas/index.c:2658)()

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/index.so in pandas.index.IndexEngine.get_value (pandas/index.c:2473)()

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/index.so in pandas.index.IndexEngine.get_loc (pandas/index.c:3210)()

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/hashtable.so in pandas.hashtable.Int64HashTable.get_item (pandas/hashtable.c:6422)()

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/hashtable.so in pandas.hashtable.Int64HashTable.get_item (pandas/hashtable.c:6366)()

KeyError: -1

In [404]:

ser

Out[404]:

0    0
1    1
2    2
dtype: float64

정수 색인이 아닐때

In [443]:

ser5 = Series([0, 0, 1], index=[5, 6, 7])

In [444]:

ser5

Out[444]:

5    0
6    0
7    1
dtype: int64

In [445]:

# 이걸 보면 이름 색인으로 접근하는 것을 알 수 있다.
ser5[6]

Out[445]:

In [450]:

# 이름 색인이 정수라면 위치 색인을 사용할 수 없다.
ser5[-1]

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-450-cf70057686cf> in <module>()
----> 1 ser5[-1]

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/core/series.pyc in __getitem__(self, key)
    903     def __getitem__(self, key):
    904         try:
--> 905             return self.index.get_value(self, key)
    906         except InvalidIndexError:
    907             pass

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/core/index.pyc in get_value(self, series, key)
    834         k = _values_from_object(key)
    835         try:
--> 836             return self._engine.get_value(s, k)
    837         except KeyError as e1:
    838             if len(self) > 0 and self.inferred_type == 'integer':

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/index.so in pandas.index.IndexEngine.get_value (pandas/index.c:2658)()

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/index.so in pandas.index.IndexEngine.get_value (pandas/index.c:2473)()

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/index.so in pandas.index.IndexEngine.get_loc (pandas/index.c:3210)()

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/hashtable.so in pandas.hashtable.Int64HashTable.get_item (pandas/hashtable.c:6422)()

/Library/Python/2.7/site-packages/pandas-0.12.0_307_g3a2fe0b-py2.7-macosx-10.8-intel.egg/pandas/hashtable.so in pandas.hashtable.Int64HashTable.get_item (pandas/hashtable.c:6366)()

KeyError: -1

In [405]:

ser2 = Series(np.arange(3.), index=['a', 'b', 'c'])

In [406]:

ser2

Out[406]:

a    0
b    1
c    2
dtype: float64

In [451]:

ser2[0]

Out[451]:

0.0

In [453]:

ser2[1]

Out[453]:

1.0

In [407]:

ser2[-1]

Out[407]:

2.0

In [408]:

# ix는 끝 인덱스인 1까지 포함한다.
ser.ix[:1]

Out[408]:

0    0
1    1
dtype: float64

만일 색인의 종류에 상관없이 위치 기반의 색인이 필요하다면 Series의 iget_value 메서드와 DataFrame의 irow, icol 메서드를 사용하면 된다¶

In [409]:

ser3 = Series(range(3), index=[-5, 1, 3])

In [410]:

ser3

Out[410]:

-5    0
 1    1
 3    2
dtype: int64

In [411]:

# 0,1의 1번째에 있는 값을 보여준다.
ser3.iget_value(1)

Out[411]:

In [412]:

ser3.iget_value(2)

Out[412]:

In [435]:

ser4 = Series([5,6,7], index=[-5, 1, 3])

In [436]:

# 위치인지 다시 한 번 확인했다.
# 위 예제에서는 이름 색인을 지정해주었지만(-5, 1, 3) 아무래도 혼란스러워서 다시 한 번 테스트 해봤다.
ser4.iget_value(0)

Out[436]:

In [413]:

frame = DataFrame(np.arange(6).reshape((3, 2)), index=[2, 0, 1])

In [414]:

frame.irow(0)

Out[414]:

0    0
1    1
Name: 2, dtype: int64

In [415]:

frame

Out[415]:

	0	1
2	0	1
0	2	3
1	4	5

In [416]:

frame.irow(1)

Out[416]:

0    2
1    3
Name: 0, dtype: int64

5.6.2 Panel 데이터¶

Panel은 DataFrame의 3차원 버전
pandas 개발은 스프레드시트 형식의 데이터를 다루는 데 초점
계층적 색인을 이용하면 대개의 경우 N차원의 배열은 불필요

In [454]:

# GOOG -> GOOGL
import pandas.io.data as web
pdata = pd.Panel(dict((stk, web.get_data_yahoo(stk, '1/1/2009', '6/1/2012'))
                      for stk in ['AAPL', 'GOOGL', 'MSFT', 'DELL']))

In [455]:

pdata

Out[455]:

<class 'pandas.core.panel.Panel'>
Dimensions: 4 (items) x 868 (major_axis) x 6 (minor_axis)
Items axis: AAPL to MSFT
Major_axis axis: 2009-01-02 00:00:00 to 2012-06-01 00:00:00
Minor_axis axis: Open to Adj Close

In [456]:

pdata = pdata.swapaxes('items', 'minor')

In [457]:

pdata

Out[457]:

<class 'pandas.core.panel.Panel'>
Dimensions: 6 (items) x 868 (major_axis) x 4 (minor_axis)
Items axis: Open to Adj Close
Major_axis axis: 2009-01-02 00:00:00 to 2012-06-01 00:00:00
Minor_axis axis: AAPL to MSFT

In [458]:

pdata['Adj Close']

Out[458]:

<class 'pandas.core.frame.DataFrame'>
DatetimeIndex: 868 entries, 2009-01-02 00:00:00 to 2012-06-01 00:00:00
Data columns (total 4 columns):
AAPL     861  non-null values
DELL     868  non-null values
GOOGL    861  non-null values
MSFT     861  non-null values
dtypes: float64(4)

ix를 이용한 라벨 색인을 통한 접근은 3차원에도 일반화되어 특정 날짜나 어떤 기간 동안의 모든 데이터를 다음처럼 선택할 수 있다¶

In [459]:

# 1번째 인자: Open, High, Low, Close, Volume, Adj Close
# 2번째 인자: 날짜
# 3번째 인자: 회사
pdata.ix[:, '6/1/2012', :]

Out[459]:

	Open	High	Low	Close	Volume	Adj Close
AAPL	569.16	572.65	560.52	560.99	18606700	536.20
DELL	12.15	12.30	12.05	12.07	19397600	11.68
GOOGL	571.79	572.65	568.35	570.98	6109600	285.78
MSFT	28.76	28.96	28.44	28.45	56634300	26.82

In [468]:

pdata.ix['High', '5/22/2012':, :]

Out[468]:

	AAPL	DELL	GOOGL	MSFT
Date
2012-05-22	573.88	15.29	613.81	29.88
2012-05-23	572.80	13.10	609.60	29.40
2012-05-24	576.50	12.63	611.92	29.30
2012-05-25	565.85	12.70	601.73	29.36
2012-05-28	NaN	12.46	NaN	NaN
2012-05-29	574.00	12.84	599.13	29.72
2012-05-30	579.99	12.70	591.90	29.48
2012-05-31	581.50	12.54	590.00	29.42
2012-06-01	572.65	12.30	572.65	28.96

In [470]:

pdata.ix['High', '5/22/2012', :]

Out[470]:

AAPL     573.88
DELL      15.29
GOOGL    613.81
MSFT      29.88
Name: 2012-05-22 00:00:00, dtype: float64

In [477]:

pdata.ix['Open', '5/22/2012', 'AAPL']

Out[477]:

569.54999999999995

In [478]:

pdata.ix['High', '5/22/2012':, 'AAPL']

Out[478]:

Date
2012-05-22    573.88
2012-05-23    572.80
2012-05-24    576.50
2012-05-25    565.85
2012-05-28       NaN
2012-05-29    574.00
2012-05-30    579.99
2012-05-31    581.50
2012-06-01    572.65
Name: AAPL, dtype: float64

In [460]:

pdata.ix['Adj Close', '5/22/2012':, :]

Out[460]:

	AAPL	DELL	GOOGL	MSFT
Date
2012-05-22	532.36	14.59	300.70	28.05
2012-05-23	545.35	12.08	305.04	27.44
2012-05-24	540.34	12.04	302.13	27.40
2012-05-25	537.45	12.05	296.06	27.39
2012-05-28	NaN	12.05	NaN	NaN
2012-05-29	546.98	12.25	297.47	27.86
2012-05-30	553.58	12.15	294.41	27.66
2012-05-31	552.20	11.93	290.72	27.51
2012-06-01	536.20	11.68	285.78	26.82

통계 모델에 맞게 Panel 데이터를 출력하는 다른 방법은 DataFrame을 쌓아 놓는 것¶

In [479]:

# Dimensions: 6, 3, 4 라는걸 확인할 수 있다.
pdata.ix[:, '5/30/2012':, :]

Out[479]:

<class 'pandas.core.panel.Panel'>
Dimensions: 6 (items) x 3 (major_axis) x 4 (minor_axis)
Items axis: Open to Adj Close
Major_axis axis: 2012-05-30 00:00:00 to 2012-06-01 00:00:00
Minor_axis axis: AAPL to MSFT

In [461]:

stacked = pdata.ix[:, '5/30/2012':, :].to_frame()

In [462]:

stacked

Out[462]:

		Open	High	Low	Close	Volume	Adj Close
Date	minor
2012-05-30	AAPL	569.20	579.99	566.56	579.17	18908200	553.58
	DELL	12.59	12.70	12.46	12.56	19787800	12.15
	GOOGL	588.16	591.90	583.53	588.23	3809500	294.41
	MSFT	29.35	29.48	29.12	29.34	41585500	27.66
2012-05-31	AAPL	580.74	581.50	571.46	577.73	17559800	552.20
	DELL	12.53	12.54	12.33	12.33	19955600	11.93
	GOOGL	588.72	590.00	579.00	580.86	5930600	290.72
	MSFT	29.30	29.42	28.94	29.19	39134000	27.51
2012-06-01	AAPL	569.16	572.65	560.52	560.99	18606700	536.20
	DELL	12.15	12.30	12.05	12.07	19397600	11.68
	GOOGL	571.79	572.65	568.35	570.98	6109600	285.78
	MSFT	28.76	28.96	28.44	28.45	56634300	26.82

In [463]:

type(stacked), type(pdata)

Out[463]:

(pandas.core.frame.DataFrame, pandas.core.panel.Panel)

DataFrame에는 to_panel 메서드와 그 반대인 to_frame 메서드가 있다¶

In [464]:

stacked.to_panel()

Out[464]:

<class 'pandas.core.panel.Panel'>
Dimensions: 6 (items) x 3 (major_axis) x 4 (minor_axis)
Items axis: Open to Adj Close
Major_axis axis: 2012-05-30 00:00:00 to 2012-06-01 00:00:00
Minor_axis axis: AAPL to MSFT