[Day 3] Python
๐ ํ์ด์ฌ ๋ฐ์ดํฐ ์คํธ๋ญ์ฒ(Data Structure)
๐ฅ ์คํ(Stack): LIFO(Last In First Out) ํํ๋ก ๋์ค์ ๋ฃ์ ๋ฐ์ดํฐ๋ฅผ ๋จผ์ ๋ฐํํ๋๋ก ๋ง๋ ๋ฉ๋ชจ๋ฆฌ ๊ตฌ์กฐ
list๋ฅผ ํ์ฉํด ๊ตฌํ์ด ๊ฐ๋ฅํ๊ณ ์ ๋ ฅ์ push(append()), ์ถ๋ ฅ์ pop(pop())์ด๋ผ๊ณ ํจ
๐ฅ ํ(Queue): FIFO(First In First Out) ํํ๋ก ๋จผ์ ๋ฃ์ ๋ฐ์ดํฐ๋ฅผ ๋จผ์ ๋ฐํํ๋๋ก ๋ง๋ ๋ฉ๋ชจ๋ฆฌ ๊ตฌ์กฐ
list๋ฅผ ํ์ฉํด ๊ตฌํ์ด ๊ฐ๋ฅํ๊ณ ์ ๋ ฅ์ push(append()), ์ถ๋ ฅ์ pop(pop(0))์ด๋ผ๊ณ ํจ
๐ฅ ํํ(Tuple): ๊ฐ์ ๋ณ๊ฒฝ์ด ๋ถ๊ฐ๋ฅํ ๋ฆฌ์คํธ๋ก ๋ฆฌ์คํธ์ ์ฐ์ฐ, ์ธ๋ฑ์ฑ, ์ฌ๋ผ์ด์ฑ์ ๊ฐ๋ฅํจ. ์ ์ธ์ '()' ์ฌ์ฉ
- ์ ์ฐ์ฃ ? ํ๋ก๊ทธ๋จ ์ค๊ฐ์ ๋ณ๊ฒฝ๋์ง ์๋ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅ(์ด๋ฆ, ํ๋ฒ ๋ฑ)ํ๊ณ ์ฌ์ฉ์์ ์ค์๋ฅผ ์ฌ์ ์ ๋ฐฉ์งํ ์ ์์
๐ฅ ์ (Set): ๊ฐ์ ์์, ์ค๋ณต ์์ด ์ ์ฅํ๋ ์๋ฃํ, set()๊ฐ์ฒด ์ ์ธ์ ํตํด ์์ฑ
์ํ์์์ ์งํฉ ์ฐ์ฐ์ด ๊ฐ๋ฅ(๊ต์งํฉ(intersection, &), ์ฐจ์งํฉ(difference, -), ํฉ์งํฉ(union, |))
๐ฅ ๋์ ๋๋ฆฌ(dict): ๋ฐ์ดํฐ ์ ์ฅ์ ๊ตฌ๋ถ์ ์ง์ ์ ์๋ ๊ฐ(key)์ ํจ๊ป ์ ์ฅํ๊ธฐ ์ํ ์๋ฃํ(Hash Table์ด๋ผ๊ณ ๋ถ๋ฆผ)
๊ตฌ๋ถ์ ์ํ ๋ฐ์ดํฐ ๊ณ ์ ๊ฐ์ Key, Identifier์ด๋ผ ํ๊ณ ๋ฐ์ดํฐ ๊ฐ์ Value๋ผ๊ณ ๋ถ๋ฆ
{key1:value1, key2:value2, ...}ํ์์ผ๋ก ์ฌ์ฉ
keys(), values(), items()ํจ์๊ฐ ์๊ณ ํํ๋ก ๋ฐํ(for ๋ฌธ์์ iterator์ ๋ง์ด ์ฌ์ฉ)
๐ฅ Collections: list, tuple, dict์ ๋ํ python built-in ํ์ฅ ์๋ฃ ๊ตฌ์กฐ(๋ชจ๋)
์ฌ์ฉ์์๊ฒ ํธ์์ฑ, ํจ์จ์ฑ ๋ฑ์ ์ ๊ณต
- deque: stack๊ณผ queue๋ฅผ ์ง์ํ๊ณ list์ ๋นํด ํจ์จ์ ์. rotate(), reverse()๋ฑ linked list์ ํน์ฑ์ ์ง์ํจ
- OrderedDict: dict๊ณผ ๋ฌ๋ฆฌ ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฅ ์์๋๋ก ๋ฐํํด์ฃผ์ง๋ง 3.6๋ฒ์ ๋ถํฐ๋ dict์๋ ์ง์ํด ์ฌ์ค์ ํ์ X
- defaultdict: dict type์ ๊ฐ์ ๊ธฐ๋ณธ ๊ฐ์ ์ง์ ํด ์ ๊ท ๊ฐ์ ๋ฃ์ด ์ค ์ ์์.
d = defaultdict(object)
d = defaultdict(lambda : 0) --> d['a']๋ฅผ ์คํํ์์ ๋ ํค๊ฐ์ a๊ฐ ์๋๋ผ๋ 0์ ๋ฐํํด ์ค
- Counter: Sequence type์ ๋ฐ์ดํฐ ์์๋ค์ ๊ฐ์๋ฅผ dictํํ๋ก ๋ฐํ
c = Counter
c = Counter('hello')
print(c) --> Counter({'e':1, 'h':1, 'l':2, 'o':1}) ํํ๋ก ์ถ๋ ฅ
elements()๋ก ๋ฆฌ์คํธํํ์ ๊ฐ์ ๋ฐํ๋ฐ์ ์ ์๊ณ set ์ฐ์ฐ์ด ๊ฐ๋ฅ(ํฉ์งํฉ, ๊ต์งํฉ, ์ฐจ์งํฉ)
- namedtuple: Tuple ํํ๋ก ๋ฐ์ดํฐ ๊ตฌ์กฐ์ฒด๋ฅผ ์ ์ฅํ๋ ๋ฐฉ๋ฒ Point = namedtuple('Point', ['x', 'y']) ํํ.
๐ %timeit ํจ์
-> sys๋ฅผ importํ๊ฒ๋๋ฉด ์ฌ์ฉํ ์ ์๋ ๊ธฐ๋ฅ์ผ๋ก ํจ์๊ฐ ์คํ๋๋๋ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ์ ํ์ธ ํ ์ ์๋ค.
๐ ํ์ด์ฌ ์คํ์ผ ์ฝ๋(Pythonic Code)
์ฌ์ฉ์ด์ 1. ๋จ์ ์ฝ๋์ ๋ํ ์ดํด๋ ↑
์ฌ์ฉ์ด์ 2. ํจ์จ(๋ ๋นจ๋ผ์ง๊ณ ์งง๊ฒ ์ฝ๋๋ฅผ ์งค ์ ์์)
์ฌ์ฉ์ด์ 3. ๋ฉ(์ ์ง๋๊ฑฐ ์ฒ๋ผ ๋ณด์)
๐ฅ Split & Join: String type์ ๊ฐ์ ์ฒ๋ฆฌ
- split(): "๊ธฐ์ค๊ฐ"์ผ๋ก ๋๋ list ํํ๋ก ๋ฐํ
- join(): "๊ธฐ์ค๊ฐ"์ผ๋ก ํฉ์ณ string ํํ๋ก ๋ฐํ
๐ฅ list comprehension: ๊ธฐ์กด์ list๋ฅผ ์ฌ์ฉํด ๊ฐ๋จํ ๋ค๋ฅธ list๋ฅผ ๋ง๋๋ ๊ธฐ๋ฒ. for๋ฌธ ๋ณด๋ค ๋น ๋ฆ
list = [i for i in ๐ฅ if ์กฐ๊ฑด]
list = [i+j for i in ๐ฅ for j in ๐จ] -> 2์ค for๋ฌธ ์์ผ๋ก ๋ฐ๋ณต(i ์์ j)
list = [[i+j for i in ๐ฅ] for j in ๐จ] -> j ๋จผ์ ๋๊ณ i๋ฅผ ์คํ
๐ฅ enumerate & zip: ๋ฆฌ์คํธ๋ฅผ ์ฒ๋ฆฌํ๋ ๋ฐฉ๋ฒ
- enumerate(): list์ element๋ฅผ ์ถ์ถํ ๋ ๋ฒํธ๋ฅผ ๋ถ์ฌ ์ถ์ถ -> ๋์ ๋๋ฆฌ๋ฅผ ๋ง๋ค๋ ์ฌ์ฉ ๊ฐ๋ฅ
- zip(): ๋๊ฐ์ list ๊ฐ์ ๋ณ๋ ฌ์ ์ผ๋ก ์ถ์ถํ๋ ๋ฐฉ๋ฒ
๐ฅ Lambda & Map & Reduce: PEP8 ์ดํ๋ก ์ฌ์ฉ์ ๊ถ์ฅํ์ง ์์ผ๋, ํ์ฌ๊น์ง ๋ง์ด ์ฌ์ฉ.
- lambda: ํจ์์ด๋ฆ ์์ด, ํจ์์ฒ๋ผ ์ธ ์ ์๋ ์ต๋ช ํจ์. ์ํ์ ๋๋ค ๋์์์ ์ ๋
f = (lambda x, y: x+y)
f(10, 50) => 60 ์ถ๋ ฅ
(lambda x, y: x+y)(10, 50) => 60 ์ถ๋ ฅ
- map: ๋๊ฐ ์ด์์ list์๋ ์ ์ฉ ๊ฐ๋ฅํจ, if ๋ฌธ๋ ์ฌ์ฉ ๊ฐ๋ฅ
iteration์ ์์ฑ -> listํจ์๋ก list๋ฅผ ๋ง๋ค ์ ์์.
์คํ ์์ ์ ๊ฐ์ ์์ฑ, ๋ฉ๋ชจ๋ฆฌ ํจ์จ์ --> list comprehension์ผ๋ก ๋์ฒด๊ฐ ๊ฐ๋ฅ
- reduce: map๊ณผ ๋ฌ๋ฆฌ list์ ๋๊ฐ์ ํจ์๋ฅผ ์ ์ฉํด ํตํฉ => ๋์ฉ๋ ๋ฐ์ดํฐ ์ฒ๋ฆฌ์ ์ฌ์ฉ
from functools import reduce๋ก ๋ถ๋ฌ ์ฌ ์ ์์
๐ฅ Iterable object: ์ํ์คํ ์๋ฃํ์์ ๋ฐ์ดํฐ๋ฅผ ์์๋๋ก ์ถ์ถํ๋ object
๋ด๋ถ์ ์ผ๋ก __iter__์ __next__๊ฐ ๊ตฌํ๋์ด ์์. -> iter()์ next()ํจ์๋ก iterable ๊ฐ์ฒด๋ฅผ ์ฌ์ฉ
iter_list = iter(["์์ธ", "๋ถ์ฐ", "๋๊ตฌ"]) ==> ๊ฐ์ด ์๋ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๊ฐ์ ์ ์ฅํ๊ณ ์์
next(iter_list) -> ์์ธ ์ถ๋ ฅ
next(iter_list) -> ๋ถ์ฐ ์ถ๋ ฅ
next(iter_list) -> ๋๊ตฌ ์ถ๋ ฅ
๐ฅ generator: iterable object๋ฅผ ํน์ํ ํํ๋ก ์ฌ์ฉํด์ฃผ๋ ํจ์
๋ฉ๋ชจ๋ฆฌ ์ฃผ์๊ฐ๋ง ๊ฐ์ง๊ณ ์๋ค๊ฐ element๊ฐ ์ฌ์ฉ๋๋ ์์ ์ ๊ฐ์ ๋ฉ๋ชจ๋ฆฌ์ ๋ฐํ
-> yield๋ฅผ ์ฌ์ฉํด ํ๋ฒ์ ํ๋์ element๋ง ๋ฐํ. list comprehension๊ณผ ์ ์ฌํ๊ฒ ์์ฑ๊ฐ๋ฅ-()์ฌ์ฉ
์ผ๋ฐ์ ์ธ iterator๋ณด๋ค generator์ด ํจ์ฌ ์์ ๋ฉ๋ชจ๋ฆฌ ์ฉ๋ ์ฌ์ฉ
gen_ex = (n*n for n in range(50)) => gen_ex์๋ 0~49์ ์๋ฅผ ์ ์ฅํ ์ ์๋ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๊ฐ ์ ์ฅ๋จ.
- ์ธ์ ์ฌ์ฉํ๋์? list type์ ๋ฐ์ดํฐ๋ฅผ ๋ฐํํด ์ฃผ๋ ํจ์, ํฐ ๋ฐ์ดํฐ ์ฒ๋ฆฌ, ํ์ผ ๋ฐ์ดํฐ ์ฒ๋ฆฌ์ ์ฌ์ฉ
๐ฅ Function Passng Argument: ํจ์์ ์ ๋ ฅ๋๋ argument์ ๋ค์ํ ํํ๊ฐ ์กด์ฌ
- Keyword argument: ํจ์์ ์ ๋ ฅ๋๋ parameter์ ๋ณ์๋ช ์ ์ฌ์ฉํด arguments๋ฅผ ๋๊น
def ex(a, b, c):
return a+b+c
print(ex(b="am", c ="python", a="I") => Iampython ์ผ๋ก ์ถ๋ ฅ
- Default argument: parameter์ ๊ธฐ๋ณธ ๊ฐ์ ์ฌ์ฉํด ์ ๋ ฅ์ด ๋ค์ด์ค์ง ์์์ ๊ฒฝ์ฐ ๊ธฐ๋ณธ ๊ฐ ์ถ๋ ฅ
def ex(a = 3, b):
return a + b
print(ex(10)) => 13์ด ์ถ๋ ฅ
- Variable-length asterisk: ๊ฐ์๊ฐ ์ ํด์ง์ง ์์ ๋ณ์๋ฅผ ํจ์ parameter๋ก ์ฌ์ฉ, '*'๊ธฐํธ ์ฌ์ฉ, Tuple ํํ๋ก ์ฌ์ฉ
def ex(a, b, *args):
return a+b+sum(args)
print(1,2,3,4,5) => 1->a, 2->b, (3,4,5)->args๋ก ๋๊ฒจ์ค. ๋ฐ๋ผ์, 15๊ฐ ์ถ๋ ฅ
- Keyword variable-length: parameter ์ด๋ฆ์ ๋ฐ๋ก ์ง์ ํ์ง ์๊ณ ์ ๋ ฅํ ๋ ์ฌ์ฉ, '**'๋ฅผ ์ฌ์ฉํด ํ์
dict type์ผ๋ก ์ฌ์ฉ ๊ฐ๋ฅ, ๊ฐ๋ณ์ธ์๋ ์ค์ง ํ๊ฐ๋ง ๊ธฐ์กด ๊ฐ๋ณ์ธ์ ๋ค์์ ์ฌ์ฉํ ์ ์์
def ex(**kwargs):
print(args)
ex('f' = 1, 's' = 2, 't' = 3) => {'f':1, 's':2, 't':3} ์ด ์ถ๋ ฅ
def ex(a, b, *args, **kwargs):
print(a, b, args, kwargs)
ex(1, 2, 3, 4, 5, 6, 7, 'f' = 1, 's' = 2) => ex(1, 2, (3, 4, 5, 6, 7), {'f':1, 's':2})๋ก ๊ฐ๋๊ฒ๊ณผ ๋น์ท <- ์์๊ฐ ์ค์
- Asterisk: '*' ๊ธฐํธ๋ก, ๊ณฑ์ , ์ ๊ณฑ, ๊ฐ๋ณ์ธ์, ๊ทธ๋ฆฌ๊ณ Unpacking a container๋ก ์ฌ์ฉ์ด ๊ฐ๋ฅ
๐ Unpacking a Container
-> tuple, dict ๋ฑ ์๋ฃํ์ ๋ค์ด๊ฐ ์๋ ๊ฐ์ unpackingํ๋ ์ญํ , ํจ์ ์ ๋ ฅ๊ฐ, zip ๋ฑ์ ์ ์ฉํ๊ฒ ์ฌ์ฉ ๊ฐ๋ฅ
def ex(a, * args):
print(a, *args)
ex(1, *(2, 3, 4, 5)) => 1 2 3 4 5 ๊ฐ ์ถ๋ ฅ
print(*[1, 2, 3, 4, 5]) => 1 2 3 4 5 ๊ฐ ์ถ๋ ฅ