Pandas Series 판다스 시리즈

Pandas Series 판다스 시리즈¶

Pandas¶

• 데이터 처리 및 분석을 위한 library

• 대용량 Data를 안정적이면서도 간편하게 처리

• 서로 다른 data type으로 column 단위들을 구성할 수 있음

• c.f. Numpy: 전체 배열 원소를 '동일한 타입'으로 제한

• 주요 기능

  • 데이터 입출력: .csv, .xlsx, RDB, JSON 등 다양한 format의 data 처리 가능

  • 데이터 가공: 분리, 결합, 계층, 피봇 등

  • 통계 분석 처리 등

In [1]:

#pandas library, Series, DataFrame namespace 불러오기

import pandas as pd

Series¶

• 1차원 배열과 유사한 자료형

• 색인 index : 행 번호

  • 각각의 데이터에 부여하는 속성, default: 0부터 1씩 증가하는 int

  • index parameter를 통해 새로운 value로 변경 가능

  • list, tuple 타입으로 새로운 값을 전달, 다차원 자료형은 사용할 수 없음

  • 전달하는 index의 개수와 data의 개수가 일치해야 함

• 각각의 색인과 data가 mapping되어 있음 > dict data type과 유사: dict + index

• 여러 가지 data type을 value로 사용 가능

1. Series 생성¶

• pd.Series(data)

  • data: single value(int, float, str) or iterable object(list, tuple, numpy 배열)

1. Series 속성¶

• 속성은 소괄호를 붙이지 않음: 함수 X

1. index : Series 객체의 index 배열을 반환

2. values : Series 객체의 data(value) 배열을 반환

3. name : Series 객체의 이름을 반환

4. dtype : Series 객체의 item data type을 반환

5. size : Series 객체의 data 개수(length)를 반환

6. shape : Series 객체의 구조(axis=0, axis=1, ..., axis=n-1)를 반환

• int 10을 data로 가지고 있는 Series

  • output 해석

  • 왼쪽 0: 자동으로 생성되는 기본 index 번호: 0부터 시작

  • 오른쪽 10: 입력한 data value

In [2]:

sr_1 = pd.Series(10)

sr_1

Out[2]:

0    10
dtype: int64

• value(data)를 얻을 때: indexing or slicing

In [3]:

sr_1[0]

Out[3]:

10

• Series 객체 내부에 저장된 값 확인

In [4]:

sr_1.values

Out[4]:

array([10], dtype=int64)

• index 확인

• RangeIndex: 기본적으로 생성되는 index번호를 사용하는 경우 부여됨

In [5]:

sr_1.index

Out[5]:

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

• str 입력

In [6]:

sr_2 = pd.Series('abc')

sr_2

Out[6]:

0    abc
dtype: object

In [7]:

sr_2.values

Out[7]:

array(['abc'], dtype=object)

In [8]:

sr_2.index

Out[8]:

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

• list data type 입력

In [9]:

sr_3 = pd.Series([1, 3, 5])

sr_3

Out[9]:

0    1
1    3
2    5
dtype: int64

In [10]:

sr_3.values

Out[10]:

array([1, 3, 5], dtype=int64)

In [11]:

sr_3.index

Out[11]:

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

• item data type이 다른 list 입력

In [12]:

sr_4 = pd.Series([10.3, "test", 2000, [1, 2, 3]])

sr_4

Out[12]:

0         10.3
1         test
2         2000
3    [1, 2, 3]
dtype: object

In [13]:

sr_4.values

Out[13]:

array([10.3, 'test', 2000, list([1, 2, 3])], dtype=object)

> data type 특정지을 수 없을때: dtype=object

In [14]:

sr_4.index

Out[14]:

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

• dict 입력: 자동 label index 부여: 'key' > label index, 'value' > data

In [15]:

sr_5 = pd.Series({'a':10, 'b':20, 'c':30})

sr_5

Out[15]:

a    10
b    20
c    30
dtype: int64

In [16]:

sr_5.values

Out[16]:

array([10, 20, 30], dtype=int64)

In [17]:

sr_5.index

Out[17]:

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

• dict로 입력해도 RangeIndex의 int index 사용 가능

In [18]:

sr_5[0]

Out[18]:

10

In [19]:

sr_5['a']

Out[19]:

10

• tuple 입력

In [20]:

sr_6 = pd.Series((1, 2, 3, 4, 5.0))

sr_6

Out[20]:

0    1.0
1    2.0
2    3.0
3    4.0
4    5.0
dtype: float64

In [21]:

sr_6.values

Out[21]:

array([1., 2., 3., 4., 5.])

• 인덱스 새로 지정

  • RangeIndex 범위만큼의 length를 가지는 list or tuple data로 전달

  • 행 개수(data 개수)와 동일한 length를 전달해야 한다.

    • label index가 없던 경우 > 새롭게 label index 부여

    • label index가 있던 경우 > 기존에 있던 label index에 덮어씌우기

In [22]:

sr_6.index

Out[22]:

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

In [23]:

sr_6.index = (2018, 2019, 2020, 2021, 2022)

sr_6

Out[23]:

2018    1.0
2019    2.0
2020    3.0
2021    4.0
2022    5.0
dtype: float64

• Series.index object에 대해서 item reference는 가능

In [24]:

sr_6.index

Out[24]:

Int64Index([2018, 2019, 2020, 2021, 2022], dtype='int64')

In [25]:

sr_6.index[0]

Out[25]:

2018

• index instance 내부의 단일 label index item만 수정하는 것은 불가능

In [26]:

sr_6.index[2] = 1998

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
~\AppData\Local\Temp\ipykernel_9864\1859156694.py in <module>
----> 1 sr_6.index[2] = 1998

~\anaconda3\lib\site-packages\pandas\core\indexes\base.py in __setitem__(self, key, value)
   5033     @final
   5034     def __setitem__(self, key, value):
-> 5035         raise TypeError("Index does not support mutable operations")
   5036 
   5037     def __getitem__(self, key):

TypeError: Index does not support mutable operations

• label index 수정 시 전체 index를 대입해야 한다

In [27]:

sr_6.index = ['q', 'w', 'e', 'r', 't']

sr_6

Out[27]:

q    1.0
w    2.0
e    3.0
r    4.0
t    5.0
dtype: float64

• dict data 없이 Series에 label index 부여하고 싶은 경우

  • 객체 생성 시, index를 optional parameter로 넘겨서 처리 가능

    • pd.Series(data, index=[...])

In [28]:

sr_7 = pd.Series([10, 20, 30, 40, 50], index=['Mon', 'Tue', 'Wed', 'Thu', 'Fri'])

sr_7

Out[28]:

Mon    10
Tue    20
Wed    30
Thu    40
Fri    50
dtype: int64

In [29]:

sr_7.index

Out[29]:

Index(['Mon', 'Tue', 'Wed', 'Thu', 'Fri'], dtype='object')

In [30]:

sr_7.values

Out[30]:

array([10, 20, 30, 40, 50], dtype=int64)

In [31]:

sr_7[2]

Out[31]:

30

In [32]:

sr_7['Wed']

Out[32]:

30

3. dict와 Series의 유사성¶

• dict 자료형으로 Series object 생성

In [33]:

my_dict = {'서울':100, '경기':200, '강원':300, '부산':400}
my_sample = pd.Series(my_dict)

print(my_dict)
print(my_sample)

{'서울': 100, '경기': 200, '강원': 300, '부산': 400}
서울    100
경기    200
강원    300
부산    400
dtype: int64

• Series객체와 in연산자
  • in 연산자를 사용해 내부 요소 검사: dict의 in연산자 사용법과 동일
  • key value에 해당하는 label index를 이용해 item의 존재 여부를 bool type return

In [34]:

print('서울' in my_dict)

print('강원' in my_sample)

True
True

• for loop에서 in연산자로 접근: iterable object dict의 key, Series의 value reference

In [35]:

for item in my_dict:
    print(item)
    
print('=' * 10)

for value in my_sample.values:
    print(value)

서울
경기
강원
부산
==========
100
200
300
400

• label index 변경: pd.Series(data, index=label_index)

  • 지정한 label_index 기준으로 Series 생성

  • 지정한 label_index에 매칭되지 않는 data는 NaN값으로 저장됨

    • NaN: Not a Number: numpy에서 해당 위치가 비었음을 의미하는 data(null)

    • c.f. None: Python primitive null data type

In [36]:

new_index = ['서울', '강원', '경기', '제주']

new_sample = pd.Series(my_dict, index=new_index)
new_sample

Out[36]:

서울    100.0
강원    300.0
경기    200.0
제주      NaN
dtype: float64

In [37]:

my_dict

Out[37]:

{'서울': 100, '경기': 200, '강원': 300, '부산': 400}

4. 인덱싱(indexing)¶

• 특정 값(single value)을 reference

  • referenced index: RangeIndex int index, label index

  • 새로운 label index를 지정해도, RangeIndex int index 사용 가능

In [38]:

my_data = {'a':10, 'b':20, 'c':30}
sr_6 = pd.Series(my_data)

sr_6

Out[38]:

a    10
b    20
c    30
dtype: int64

• Indexing

  • Index indexing: _Series object_.index[RangeIndex int index]

  • value(item) indexing: _Series object_[RangeIndex int index or label index]

In [39]:

print(sr_6.index[0])

print(sr_6[0])

a
10

In [40]:

sr_6['a']

Out[40]:

10

• '요일'-int data

In [41]:

sr_7

Out[41]:

Mon    10
Tue    20
Wed    30
Thu    40
Fri    50
dtype: int64

• label index에 해당하는 data value 변경

  • _Series_.index[label_index]: Error

  • _Series_.index[RangeIndex]: data value 아닌 label index 추출, 변경 불가능

  • _Series_[label_index or RangeIndex]: 변경 가능

In [42]:

sr_7.index['Mon']

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
~\AppData\Local\Temp\ipykernel_9864\963837586.py in <module>
----> 1 sr_7.index['Mon']

~\anaconda3\lib\site-packages\pandas\core\indexes\base.py in __getitem__(self, key)
   5067             key = np.asarray(key, dtype=bool)
   5068 
-> 5069         result = getitem(key)
   5070         # Because we ruled out integer above, we always get an arraylike here
   5071         if result.ndim > 1:

IndexError: only integers, slices (`:`), ellipsis (`...`), numpy.newaxis (`None`) and integer or boolean arrays are valid indices

In [43]:

print(sr_7['Tue'])

sr_7['Tue'] = 200
sr_7

20

Out[43]:

Mon     10
Tue    200
Wed     30
Thu     40
Fri     50
dtype: int64

In [44]:

print(sr_7[0])

sr_7[0] = 100
sr_7

10

Out[44]:

Mon    100
Tue    200
Wed     30
Thu     40
Fri     50
dtype: int64

• Series에서 두 개 이상의 원하는 행(row)만 추출하기: 행(row) == label index

  • 추출 할 row들을 이중 list로 indexing: _Series_[[row1, row2, ..., rowN]]

In [45]:

sr_7[['Mon', 'Thu']]

Out[45]:

Mon    100
Thu     40
dtype: int64

• list안의 tuple로 추출 불가능

In [46]:

sr_7[('Mon', 'Thu')]

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
~\AppData\Local\Temp\ipykernel_9864\3856407577.py in <module>
----> 1 sr_7[('Mon', 'Thu')]

~\anaconda3\lib\site-packages\pandas\core\series.py in __getitem__(self, key)
    982             return self._get_values(key)
    983 
--> 984         return self._get_with(key)
    985 
    986     def _get_with(self, key):

~\anaconda3\lib\site-packages\pandas\core\series.py in _get_with(self, key)
    997             )
    998         elif isinstance(key, tuple):
--> 999             return self._get_values_tuple(key)
   1000 
   1001         elif not is_list_like(key):

~\anaconda3\lib\site-packages\pandas\core\series.py in _get_values_tuple(self, key)
   1032 
   1033         if not isinstance(self.index, MultiIndex):
-> 1034             raise KeyError("key of type tuple not found and not a MultiIndex")
   1035 
   1036         # If key is contained, would have returned by now

KeyError: 'key of type tuple not found and not a MultiIndex'

5. 슬라이싱 (Slicing)¶

• _Series_[start index: stop index: step]

  • 특정 범위의 값을 선택하거나 변경: RangeIndex int index, label index 둘 다 사용 가능

    • RangeIndex int index slicing: not including stop index

    • label index slicing: including stop index

In [47]:

sr_en = pd.Series([10, 20, 30, 40, 50], index=list('abcde'))

sr_en

Out[47]:

a    10
b    20
c    30
d    40
e    50
dtype: int64

In [48]:

# RangeIndex: 0 ~ 1
sr_en[0:2]

Out[48]:

a    10
b    20
dtype: int64

In [49]:

# label index: 'a' ~ 'c'
sr_en['a':'c']

Out[49]:

a    10
b    20
c    30
dtype: int64

In [50]:

# RangeIndex int index + step
sr_en[0:5:2]

Out[50]:

a    10
c    30
e    50
dtype: int64

In [51]:

# label index + step
sr_en['b':'d':2]

Out[51]:

b    20
d    40
dtype: int64

6. 조건 색인(Boolean Indexing)¶

• Series[dtype=bool Series]

  • 원본 객체와 같은 shape과 index, dtype=bool인 Series 객체로 indexing

  • Series object에 vector, scalar opration을 적용 > dtype=bool인 object return

In [52]:

sr_int = pd.Series([10, -3, -31, 34, -35, 14, -61, 12, 0])

sr_int

Out[52]:

0    10
1    -3
2   -31
3    34
4   -35
5    14
6   -61
7    12
8     0
dtype: int64

• 비교연산자 < + scalar value 0

  • 조건 만족 여부 bool type(True or False)을 item으로 갖는 Series obj return

In [53]:

sr_int < 0

Out[53]:

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

• Boolean Indexing: Series[dtype=bool Series]

In [54]:

sr_int[sr_int < 0]

Out[54]:

1    -3
2   -31
4   -35
6   -61
dtype: int64

• 두 개 이상의 조건 처리: and $\rightarrow$ &, or $\rightarrow$ |

In [55]:

sr_int[(sr_int > 10) & (sr_int < 40)]

Out[55]:

3    34
5    14
7    12
dtype: int64

7. Operation with scalar value, Series object¶

• Operation between Series object and scalar value

  • BroadCasting 발생

• Operation between Series object and Series object

  • 일치하는 label index간 연산 수행, 공동으로 존재하지 않는 경우 NaN return

  • label index가 없는 경우 RangeIndex int index 차례대로 연산 수행
    > item 개수 다르면 NaN return

  • optional parameter fill_value=value: NaN 대체 가능

    

• 연산의 종류

  • add: +, sr.add(sr)

  • subtract: -, sr.sub(sr)

  • multiply: *, sr.mul(sr)

  • divide: /, sr.div(sr)

  • modulo: %, sr.mod(sr)

  • int divide: //, sr.floordiv(sr)

In [56]:

sr_1 = pd.Series([1, 2, 3, 4], index=list('abcd'))

sr_2 = pd.Series([10, 20, 30, 40, 50, 60], index=list('acdefg'))

In [57]:

sr_1

Out[57]:

a    1
b    2
c    3
d    4
dtype: int64

In [58]:

sr_2

Out[58]:

a    10
c    20
d    30
e    40
f    50
g    60
dtype: int64

• Operation between Series object and scalar value > BroadCasting

In [59]:

sr_2 * 3

Out[59]:

a     30
c     60
d     90
e    120
f    150
g    180
dtype: int64

• Operation between Series object and Series object

  • 공통 label index or RangeIndex int index끼리 연산
    > 한 객체에만 존재하는 index: NaN value로 채워짐

In [60]:

sr_1 + sr_2

Out[60]:

a    11.0
b     NaN
c    23.0
d    34.0
e     NaN
f     NaN
g     NaN
dtype: float64

• optional parameter fill_value=value

  • 공통으로 존재하지 않는 index의 value에 대해 NaN 대신 value로 연산 적용

In [61]:

sr_1.add(sr_2, fill_value=0)

Out[61]:

a    11.0
b     2.0
c    23.0
d    34.0
e    40.0
f    50.0
g    60.0
dtype: float64

In [62]:

sr_1.add(sr_2, fill_value=100)

Out[62]:

a     11.0
b    102.0
c     23.0
d     34.0
e    140.0
f    150.0
g    160.0
dtype: float64

• subtract operation between Series object

In [63]:

sr_1.sub(sr_2)

Out[63]:

a    -9.0
b     NaN
c   -17.0
d   -26.0
e     NaN
f     NaN
g     NaN
dtype: float64

In [64]:

sr_1.sub(sr_2, fill_value=0)

Out[64]:

a    -9.0
b     2.0
c   -17.0
d   -26.0
e   -40.0
f   -50.0
g   -60.0
dtype: float64

• multiply operation between Series object

In [65]:

sr_1.mul(sr_2)

Out[65]:

a     10.0
b      NaN
c     60.0
d    120.0
e      NaN
f      NaN
g      NaN
dtype: float64

In [66]:

sr_1 * sr_2

Out[66]:

a     10.0
b      NaN
c     60.0
d    120.0
e      NaN
f      NaN
g      NaN
dtype: float64

In [67]:

sr_1.mul(sr_2, fill_value=1)

Out[67]:

a     10.0
b      2.0
c     60.0
d    120.0
e     40.0
f     50.0
g     60.0
dtype: float64

• divide operation

In [68]:

sr_1 / sr_2

Out[68]:

a    0.100000
b         NaN
c    0.150000
d    0.133333
e         NaN
f         NaN
g         NaN
dtype: float64

In [69]:

sr_1.div(sr_2)

Out[69]:

a    0.100000
b         NaN
c    0.150000
d    0.133333
e         NaN
f         NaN
g         NaN
dtype: float64

In [70]:

sr_1.div(sr_2, fill_value=1)

Out[70]:

a    0.100000
b    2.000000
c    0.150000
d    0.133333
e    0.025000
f    0.020000
g    0.016667
dtype: float64

pandas documentation

> 연습 문제¶

1. 실습 데이터 생성

• 1 이상 100 미만, 난수 정수값 26개 저장한 Series, alphabet으로 laveling

In [71]:

import numpy as np

arr_data = np.random.randint(1, 100, size=26)
sr_data = pd.Series(arr_data, index=list('abcdefghijklmnopqrstuvwxyz'))

sr_data

Out[71]:

a    78
b    75
c    46
d    43
e    53
f    73
g    23
h    84
i    48
j    79
k     5
l    71
m    27
n    38
o    24
p    50
q    99
r    39
s    22
t    13
u    61
v    84
w    45
x    57
y    66
z    14
dtype: int32

1. label index='k' item value print

In [72]:

sr_data['k']

Out[72]:

5

1. label index='a', 'f', 'c' item value print

In [73]:

sr_data[['a', 'f', 'c']]

Out[73]:

a    78
f    73
c    46
dtype: int32

1. RangeIndex int index 5 ~ 15 item value print

In [74]:

sr_data[5:16]

Out[74]:

f    73
g    23
h    84
i    48
j    79
k     5
l    71
m    27
n    38
o    24
p    50
dtype: int32

1. 뒤부터 5개 row 출력

In [75]:

sr_data[-5:]

Out[75]:

v    84
w    45
x    57
y    66
z    14
dtype: int32

1. Series object의 item 개수 출력

In [76]:

sr_data.size

Out[76]:

26

In [77]:

len(sr_data)

Out[77]:

26

1. item value들의 평균보다 큰 item만 출력

In [78]:

sr_data[sr_data > sr_data.values.mean()]

Out[78]:

a    78
b    75
e    53
f    73
h    84
j    79
l    71
q    99
u    61
v    84
x    57
y    66
dtype: int32

In [79]:

sr_data[sr_data > sr_data.mean()]

Out[79]:

a    78
b    75
e    53
f    73
h    84
j    79
l    71
q    99
u    61
v    84
x    57
y    66
dtype: int32

1. data item value 중에 50이 있는지 확인하여 bool type print

In [80]:

50 in sr_data.values

Out[80]:

True