Python 시퀀스 데이터 다루기(jupyter notebook 실습)

 

 

In [1]:

from IPython.core.display import display, HTML
display(HTML("<style>.container {width:90% !important;}</style>"))

 

 

 

210524.ipynb 실습¶

#¶

툴팁 함수나 변수 뒤에 커서 또는 드래그하고

Shift + Enter

도움창 띄우기

?객체명

기본 단축키¶

\ : 단축키 도움말
\ : command mode 전환
\ : edit mode 전환
\ : 해당 셀 삭제
\ : 셀 추가(위로)
\ : 셀 추가(아래로)
\<Ctrl+Enter> : 해당 셀 실행
\<Shift+Enter> : 해당 셀 실행 후 다음셀로 커서 넘어감
\<c, v, x> : 셀 복사, 붙여넣기, 잘라내기
\<Shift+m> : 해당 셀&아래 셀 합치기
\ : 셀을 markdown 모드로 변경
\ : 셀을 code 모드로 변경
\<ctrl+/> : 커서 위치 라인 주석처리
\<Ctrl+Shift+-> : 현재 커서 위치에서 셀 분할
\<문자 쓸때 tab> : 메모리에 저장된 변수 목록 출력

 

PyData Stack¶

• 엑셀연산 자동화 : Pandas
• 사용자 인터페이스 : Jupyter
• 데이터 분석 : SciPy, NumPy, scikit-learn
• 시각화 : matplotlib, seaborn
• 빅데이터 : Blaze, PySpark
• I/O : PyTables, SQLAlchemy, redis

 

Note¶

DB 서비스 3종류 : E-R, Non E-R, QDB
DB는 일반적으로 서비스가 느리다. real time 서비스에 적합하지 않다.

Python Collections : 컨테이너 데이터형

• list, dict, set, tuple, "문자열"

연산자 : 원래 원형은 함수. 편리성을 위해 기호로 제공하는것(sum함수 -> + 연산자)

c++ 같은 저급 언어는 언어단에 접근하여 모듈 등을 직접 조작 가능 python 같은 고급 언어는 언어단 접근 불가 및 직접 조작 불가능

python 변수, 상수, 리터럴¶

상수 : python은 상수를 지원하지 않지만 클래스를 만들어 상수를 만들 수 있음

변수 : 메모리 번지에 대한 별칭

리터럴 : 변하지 않는 고유의 값, python 내장형들의 상수값을 위한 표기법

• 숫자 리터럴, 문자 리터럴('',"",''',"""), 논리값 리터럴(True, False), 특수 리터럴(None) 숫자 리터럴 : 정수(0b, 0o, 0x), 실수 리터럴(e나 소수점 포함), 복소수 리터럴(j로 끝나는 경우 복소수의 허수)

In [ ]:

In [ ]:

In [28]:

furry = True
large = True
if furry : 
    if large : 
        print("It's a yeti.")
    else :
        print("It's a cat!")
else :
    if large : 
        print("It's a whale.")
    else :
        print("It's a human. OR a hairless cat.")

 

It's a yeti.

In [29]:

list(map(lambda x:x+str(10), "abcdef"))

Out[29]:

['a10', 'b10', 'c10', 'd10', 'e10', 'f10']

In [26]:

'a' in 'lkjellklfa'

Out[26]:

True

In [30]:

"*" * 50, 20 * "="

Out[30]:

('**************************************************', '====================')

 

인덱스 슬라이싱¶

[start : end : step]

In [50]:

a = [23,4,6,2,89,6,78,12,3,1,5,45,2,763,7,34,5,215]
len(a)

Out[50]:

18

In [51]:

a[1::3]       # 인덱스 0 부터 끝까지 3칸 간격으로

Out[51]:

[4, 89, 12, 5, 763, 5]

In [46]:

a[:-3:2]      # 처음부터 끝에서 세번째까지 2칸 간격으로

Out[46]:

[23, 6, 89, 78, 3, 5, 2, 7]

In [43]:

a[::-1]       # 역순으로 재배열

Out[43]:

[215, 5, 34, 7, 763, 2, 45, 5, 1, 3, 12, 78, 6, 89, 2, 6, 4, 23]

In [53]:

a[:3:-2]      # step이 -이면 인덱스 역순 재배열 -18~-1 > 뒤에서부터~앞에서 4번째까지

Out[53]:

[215, 34, 763, 45, 1, 12, 6]

In [67]:

[1,2,3,4,5,6,7,8,9,10][::2]

Out[67]:

[1, 3, 5, 7, 9]

In [68]:

[1,2,3,4,5,6,7,8,9,10][::2][::2]

Out[68]:

[1, 5, 9]

 

문자열 함수¶

• str.split(sep=None, mxsplit=-1) : sep 구분 문자를 기준으로 분할하여 리스트로 반환
• str.join(iterable) : iterable의 문자열을 이어붙인 문자열 반환
• str.replace(old, new[,count]) : old를 new로 치환한 문자 반환(count : 앞의 count개만 치환)
• str.strip : 앞 뒤 공백제거
• str.find(sub[, start[, end]]) : 부분 문자열 sub가 슬라이스 내에 등장하는 가장 작은 문자열 인덱스 반환 없으면 -1 반환
• str.index(sub[, start[, end]]) : find() 와 비슷하지만 못찾으면 ValueError raise
• str.capitalize() : 현재 문자열의 첫 문자만 대문자이고 나머지가 소문자로 바꾼 복사본 반환

In [54]:

",".join(['a', 'b', 'c'])

Out[54]:

'a,b,c'

In [55]:

'I am a lunch box'.replace('lunch', 'blue')

Out[55]:

'I am a blue box'

In [63]:

"   ddddd     ddd  aa    ".strip()             # 앞뒤 공백제거

Out[63]:

'ddddd     ddd  aa'

In [62]:

"   ddddd     ddd  aa    ".replace(' ', "")    # 공백제거

Out[62]:

'ddddddddaa'

In [65]:

"i am a lunch box".capitalize()

Out[65]:

'I am a lunch box'

 

문자열 포맷팅¶

• %-string
• {}.format()
• f-string

In [70]:

actor = "richard Gere"
cat = "Chester"
weight = 28
thing = 'woodchuck'

In [107]:

'%+10s' % cat, '%-12s' % thing          # 오른쪽 정렬, 왼쪽 정렬

Out[107]:

('   Chester', 'woodchuck   ')

In [88]:

'{0:4}{1:2}'.format('1990', '1')

Out[88]:

'19901 '

In [97]:

'{0:4}{1:0>2}'.format('1999', '1')      # 날짜 format  0>2 : 0포함 2자리

Out[97]:

'199901'

In [105]:

'{0:4}{1:3>5}'.format('1999', '1')      # 날짜 format  3>5 : 5자리(부족하면 3으로 채움)

Out[105]:

'199933331'

In [113]:

'{0:4}{1:3>5}'.format('1999', '200000')     

Out[113]:

'1999200000'

In [110]:

for m in range(1,13):
    print('{0:4}/{1:0>2}/{2:0>2}'.format('2021', m, '20'))

 

2021/01/20
2021/02/20
2021/03/20
2021/04/20
2021/05/20
2021/06/20
2021/07/20
2021/08/20
2021/09/20
2021/10/20
2021/11/20
2021/12/20

In [112]:

for m in range(1,13):
    print(f"{'2021':4}/{m:0>2}/{'20':0>2}")

 

2021/01/20
2021/02/20
2021/03/20
2021/04/20
2021/05/20
2021/06/20
2021/07/20
2021/08/20
2021/09/20
2021/10/20
2021/11/20
2021/12/20

 

python 기본 문법¶

In [116]:

list('abc'), tuple('abc'), set('abc')         # 문자 하나씩 자료로 들어감

Out[116]:

(['a', 'b', 'c'], ('a', 'b', 'c'), {'a', 'b', 'c'})

In [127]:

t1 = ('ad', '3f')
t2 = ('gh', )          # 마지막에 , 있어도 알아서 처리 
t1 + t2

Out[127]:

('ad', '3f', 'gh')

In [128]:

a, b = 3,4
a, b

Out[128]:

(3, 4)

In [131]:

b, a = a,b    # swap
a,b

Out[131]:

(3, 4)

 

list 다루기¶

In [167]:

result = []
result.append(['홍길동'] + [36])        # 2차원 list
result.append(['아무개'] + [52])
result.append(['박예진'])
result     

Out[167]:

[['홍길동', 36], ['아무개', 52], ['박예진']]

In [168]:

result.append(['홍길동'] + [36])      
result.append(['박예진'])
result.append(['홍길동'] + [36])        
result

Out[168]:

[['홍길동', 36], ['아무개', 52], ['박예진'], ['홍길동', 36], ['박예진'], ['홍길동', 36]]

In [169]:

result.remove(['홍길동', 36])          # 해당하는 첫번재 자료 1개만 제거함
result

Out[169]:

[['아무개', 52], ['박예진'], ['홍길동', 36], ['박예진'], ['홍길동', 36]]

In [170]:

list(filter(lambda x:x != ['홍길동', 36], result))    # 특정 원소 모두 제거(필터링)

Out[170]:

[['아무개', 52], ['박예진'], ['박예진']]

In [174]:

sorted(result)            # 오름차순, ㄱ-ㅎ 순 정렬. 원래 값은 변함없고 복사본 반환

Out[174]:

[['박예진'], ['박예진'], ['아무개', 52], ['홍길동', 36], ['홍길동', 36]]

In [175]:

result.sort()            # 값 자체가 sort되어 변환됨
result

Out[175]:

[['박예진'], ['박예진'], ['아무개', 52], ['홍길동', 36], ['홍길동', 36]]

In [176]:

sorted(result, reverse=True)      #내림 차순

Out[176]:

[['홍길동', 36], ['홍길동', 36], ['아무개', 52], ['박예진'], ['박예진']]

In [178]:

result.sort(reverse=True)
result

Out[178]:

[['홍길동', 36], ['홍길동', 36], ['아무개', 52], ['박예진'], ['박예진']]

 

List 복사 방식¶

• deap copy : list(a), a.copy(), a[:]
• shallow copy : b = a --> 같은 메모리 참조

In [186]:

a = list(range(1,10))
a

Out[186]:

[1, 2, 3, 4, 5, 6, 7, 8, 9]

In [193]:

b = a.copy()          # 깊은 복사
b[0] = 10
a

Out[193]:

[100, 2, 3, 4, 5, 6, 7, 8, 9]

In [194]:

c = list(a)          # 깊은 복사
c[0] = 20
a

Out[194]:

[100, 2, 3, 4, 5, 6, 7, 8, 9]

In [195]:

d = a[:]             # 깊은 복사
d[0] = 30
a

Out[195]:

[100, 2, 3, 4, 5, 6, 7, 8, 9]

In [197]:

e = a                # 얕은 복사
e[0] = 100
a

Out[197]:

[100, 2, 3, 4, 5, 6, 7, 8, 9]

In [198]:

id(a), id(b), id(c), id(d), id(e)           # a와 e는 같은 객체

Out[198]:

(3218130992512, 3218153503552, 3218132415168, 3218131205824, 3218130992512)

 

2차원 list 복사하기¶

• copy.deepcopy() 사용해야한다. 중첩된 list, tuple에 들어있는 모든 자료를 복사한다.

In [267]:

import copy

In [390]:

a = [1,2,[8,9]]
b = copy.deepcopy(a)             # 깊은 복사시 2차원 이상이면 deapcopy 가 바람직
c = a[:]                         # 얕은 복사
d = a[:][:]                      # 얕은 복사
e = a.copy()                     # 이것도 얕은 복사

In [392]:

id(a), id(b), id(c), id(d), id(e)   # id는 다름(?)

Out[392]:

(3218160720320, 3218160719872, 3218149403328, 3218155171648, 3218152204160)

In [393]:

a[2][1] = 100
a

Out[393]:

[1, 2, [8, 100]]

In [394]:

c, d, e

Out[394]:

([1, 2, [8, 100]], [1, 2, [8, 100]], [1, 2, [8, 100]])

In [395]:

b       # 값 변화 없음

Out[395]:

[1, 2, [8, 9]]

In [396]:

id(a), id(b), id(c), id(d), id(e)

Out[396]:

(3218160720320, 3218160719872, 3218149403328, 3218155171648, 3218152204160)

In [397]:

a[0] = 10
a

Out[397]:

[10, 2, [8, 100]]

In [399]:

b, c,d, e

Out[399]:

([1, 2, [8, 9]], [1, 2, [8, 100]], [1, 2, [8, 100]], [1, 2, [8, 100]])

 

python 다차원 리스트 복사시 주의사항

2차원 이상 list부터 [[a] b]c 방식의 생성은 생성 단위가 [a,a,..] 즉 list이다.
따라서, mutable한 값을 복사하기때문에 얕은 복사로 실행된다.
(1차원은 a 단위 즉 숫자형인 immutable한 값의 복사기때문에 상관없다)
반복이 필요한 경우 리스트 컴프리헨션으로 하는것이 좋다.

In [430]:

a1 = [[0 for j in range(5)] for i in range(5)]
a1

Out[430]:

[[0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0]]

In [426]:

a1[2][3] =1
a1

Out[426]:

[[0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0],
 [0, 0, 0, 1, 0],
 [0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0]]

In [427]:

id(a1[0]), id(a1[1]), id(a1[2]), id(a1[3]), id(a1[4])

Out[427]:

(3218153442880, 3218155051200, 3218131205824, 3218153150976, 3218131850304)

In [428]:

a2 = [[0]*5]*5            # a2[0]~a2[4] 가 모두 같은 주소의 객체이다.
a2

Out[428]:

[[0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0]]

In [410]:

a2[2][3] = 1
a2

Out[410]:

[[0, 0, 0, 1, 0],
 [0, 0, 0, 1, 0],
 [0, 0, 0, 1, 0],
 [0, 0, 0, 1, 0],
 [0, 0, 0, 1, 0]]

In [421]:

id(a2[0]), id(a2[1]), id(a2[2]), id(a2[3]), id(a2[4])

Out[421]:

(3218143436928, 3218143436928, 3218143436928, 3218143436928, 3218143436928)

In [411]:

a3 = [[0]*5 for i in range(5)]
a3

Out[411]:

[[0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0]]

In [412]:

a3[2][3]=1
a3

Out[412]:

[[0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0],
 [0, 0, 0, 1, 0],
 [0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0]]

In [424]:

id(a3[0]), id(a3[1]), id(a3[2]), id(a3[3]), id(a3[4])

Out[424]:

(3218131849280, 3218155044096, 3218155043776, 3218155043072, 3218155042752)

 

zip 함수¶

zip(*iterables)

여러 개의 iterable 객체를 인자로 받은 후 순회하면서 각 인자의 i~n 번 요소를 순차적으로 재결합한 튜플 생성

In [247]:

english = 'Monday ', 'tuesday', 'Wednesday'
french = 'Lundi', 'Mardi', 'mercredi'

In [288]:

pairs = list(zip(english, french))
pairs

Out[288]:

[('Monday ', 'Lundi'), ('tuesday', 'Mardi'), ('Wednesday', 'mercredi')]

In [285]:

dict(zip(english, french))

Out[285]:

{'Monday ': 'Lundi', 'tuesday': 'Mardi', 'Wednesday': 'mercredi'}

In [286]:

list(zip('12345', 'ABCDEF', 'abcdef'))

Out[286]:

[('1', 'A', 'a'),
 ('2', 'B', 'b'),
 ('3', 'C', 'c'),
 ('4', 'D', 'd'),
 ('5', 'E', 'e')]

In [296]:

dict(zip('12345', 'ABCDEF'))          # dict 는 인자 2개 까지만

Out[296]:

{'1': 'A', '2': 'B', '3': 'C', '4': 'D', '5': 'E'}

In [ ]:

pairs = list(zip('12345', 'ABCDEF'))  

In [303]:

pairs

Out[303]:

[('1', 'A'), ('2', 'B'), ('3', 'C'), ('4', 'D'), ('5', 'E')]

In [300]:

number, letter= zip(*pairs)          # * 연산자 -> tuple로 스프레드

In [311]:

number, letter = zip(('1', 'A'), ('2', 'B'), ('3', 'C'), ('4', 'D'), ('5', 'E'))
number, letter

Out[311]:

(('1', '2', '3', '4', '5'), ('A', 'B', 'C', 'D', 'E'))

In [294]:

number

Out[294]:

('1', '2', '3', '4', '5')

In [295]:

letter

Out[295]:

('A', 'B', 'C', 'D', 'E')

 

리스트 컴프리헨션¶

느려서 데이터 분석시에는 잘 안쓴다함(numpy 모듈 사용)

In [312]:

number_list = [number * 11 for number in range(1,6)]
number_list

Out[312]:

[11, 22, 33, 44, 55]

In [313]:

number_list = [number for number in range(1,6) if number % 2 == 1]
number_list

Out[313]:

[1, 3, 5]

In [324]:

rows = range(1,4)
cols = range(1,3)
cells = [(row, col) for row in rows for col in cols]
cells

Out[324]:

[(1, 1), (1, 2), (2, 1), (2, 2), (3, 1), (3, 2)]

In [325]:

a = []
for row in rows:
    for col in cols:
        a.append((row, col))
a

Out[325]:

[(1, 1), (1, 2), (2, 1), (2, 2), (3, 1), (3, 2)]

 

Dict¶

• 생성하기
• 인덱싱
• 결합 및 해제 (전개 구문)
• Dict 컴프리헨션

In [326]:

lol = [['a', 'b'], ['c', 'd'], ['e', 'f']]
dict(lol)

Out[326]:

{'a': 'b', 'c': 'd', 'e': 'f'}

In [339]:

tos = ('ab', 'cd', 'ef')
dict(tos)

Out[339]:

{'a': 'b', 'c': 'd', 'e': 'f'}

In [341]:

pythons = {'aaa':'bbb', 'ccc':'john', 'idle':'eric', 'johns':'terry', 'plain':'michael'}
pythons

Out[341]:

{'aaa': 'bbb',
 'ccc': 'john',
 'idle': 'eric',
 'johns': 'terry',
 'plain': 'michael'}

In [358]:

pythons.keys()

Out[358]:

dict_keys(['aaa', 'ccc', 'idle', 'johns', 'plain'])

In [359]:

pythons.items()

Out[359]:

dict_items([('aaa', 'bbb'), ('ccc', 'john'), ('idle', 'eric'), ('johns', 'terry'), ('plain', 'michael')])

In [360]:

pythons.values()

Out[360]:

dict_values(['bbb', 'john', 'eric', 'terry', 'michael'])

In [355]:

pythons['aaa'], pythons['plain']

Out[355]:

('bbb', 'michael')

In [356]:

pythons.get('ccc')

Out[356]:

'john'

In [389]:

# pythons[0]       dict는 숫자 인덱싱 불가
pythons[list(pythons.keys())[i]] for i in lange(0,len(pythons))

Out[389]:

5

In [368]:

first = {'a' : 'agnos', 'b':'bliss'}
second = {'b':'bagels', 'c':'candy'}
{**first, **second}          # 결합하기 : ** 스프레드 연산자(dictionary전개 구문)

Out[368]:

{'a': 'agnos', 'b': 'bagels', 'c': 'candy'}

In [367]:

{**first, 'd':'ddd'}

Out[367]:

{'a': 'agnos', 'b': 'bliss', 'd': 'ddd'}

In [376]:

{*first, *second}           # * 는 tuple로 스프레드하기 때문에 키값만 받는다

Out[376]:

{'a', 'b', 'c'}

In [379]:

word = 'letters'
letter_counts = {letter:word.count(letter) for letter in word}
letter_counts

Out[379]:

{'l': 1, 'e': 2, 't': 2, 'r': 1, 's': 1}

In [18]:

10

Out[18]:

10

In [20]:

_

Out[20]:

10

In [21]:

add = lambda x,y:x+y

In [22]:

add

Out[22]:

<function __main__.<lambda>(x, y)>

In [23]:

add(2,3), add(3,4), _(1,2)

Out[23]:

(5, 7, 3)

In [ ]: