1์ฃผ์ฐจ ์์์ผ
- ํ์ด์ฌ ์๋ฃ๊ตฌ์กฐ
- 'ํ์ด์ฌ์ค๋ฌ์ด' ์ฝ๋
- ํจ์๋ 1๊ธ ๊ฐ์ฒด
๋ฆฌ์คํธ๋ง ๋จน๊ณ ์ด ์๋ ์์์์
collections
๋ชจ๋์ deque()
๋ฅผ ์ด์ฉํ๋ฉด ๋๋ค.deque
ํ์ ์คํ์ ํฉ์น ๊ฒ ๊ฐ์ ์๋ฃํ. ์ ์ชฝ์์ push/pop
์ด ๊ฐ๋ฅํ๋ค.
linked list ํํ๋ก ๊ตฌํ๋์ด ํ ํญ๋ชฉ์ด ๋ค์ ํญ๋ชฉ์ ์ฃผ์๋ฅผ ๊ฐ๊ณ ์๋ค.
๊ทธ๋์ ๊ฐ์ด๋ฐ ์๋ ์์๋ฅผ ํ๋ ์ง์ฐ๋ ๊ฒ ๋น ๋ฅด๋ค! ์ฐ๊ฒฐ ๋๊ณ ๋ค๋ฅธ ๋ ์ฐ๊ฒฐํ๋ฉด ๋์ด๋ค. ๋ฆฌ์คํธ๋ ๊ฐ์ด๋ฐ ์๋ ์์ ์ง์ฐ๋ ค๋ฉด ๋ค์ ์ ๋ค์ ํ ์นธ์ฉ ์์ผ๋ก ๋ฐ์ด์ค์ผ ํด์ ์๊ฐ์ด ์กฐ๊ธ ๋ ๊ฑธ๋ฆฐ๋ค.
deque
๋ ์๋ ์์ชฝ์์ push
์ pop
์ด ๊ฐ๋ฅํ๋ฐ push/pop
์ ํ์ชฝ์ผ๋ก๋ง ํ๋ฉด ํ๋ ์คํ์ฒ๋ผ ์ธ ์ ์๋ค.
queue ๋ชจ๋: popleft(), append()
stack ๋ชจ๋: pop(), append()
set
๋ง ๊ทธ๋๋ก ์งํฉ์ด๋ค. intersection, union, difference
๋ฑ ์งํฉ ์ฐ์ฐ์ ์ฌ์ฉํ ์ ์๊ณ ์ค๋ณต ์์๋ฅผ ํ์ฉํ์ง ์๋๋ค.
a&b
, a|b
, a-b
์ ๊ฐ์ ์ฐ์ฐ์๋ฅผ ํตํด ๊ตฌํ ์๋ ์๋ค. (์ค๋ฒ๋ก๋ฉ๋์ด ์์) split()
๋ฌธ์์ด์ split()
ํ๋ฉด ๊ณต๋ฐฑ, ์ํฐ, \n ์ ๊ธฐ์ค์ผ๋ก ์ชผ๊ฐ์ ๋ฆฌ์คํธ๋ฅผ ๋ง๋ค์ด ์ค๋ค.
split(',')
์ฒ๋ผ ํน์ ๋ฌธ์์ด์ ๊ธฐ์ค์ผ๋ก ์ชผ๊ฐค ์๋ ์๋ค.
join()
๋ฆฌ์คํธ, ํํ ๋ฑ iterable
์ ''.join()
ํ๋ฉด ํญ๋ชฉ์ ๋ค ๋ถ์ฌ์ ๋ฌธ์์ด๋ก ๋ง๋ค์ด ์ค๋ค.
'-'.join()
์ฒ๋ผ ํญ๋ชฉ ์ฌ์ด์ ํน์ ๋ฌธ์์ด์ ๋ฃ์ด์ ์ฐ๊ฒฐํ ์๋ ์๋ค.
s = "ab cd ef-gh"
print(s.split())
print(s.split('-'))
>>> ['ab', 'cd', 'ef-gh']
['ab cd ef', 'gh']
---------------------------------
lst = ['a','b','c']
print(''.join())
print('!'.join())
>>> abc
a!b!c
append()
ํ๋ ๊ฒ๋ณด๋ค ๋น ๋ฅด๋ค๊ณ ํ๋ค.a = [i*i for i in range(10) if i%2]
b = [(i,j) for i in range(3) for j in range(2)]
c = [[(i,j) for i in range(3)] for j in range(2)]
print(a)
print(b)
print(c)
>>> [1, 3, 5, 7, 9]
[(0, 0), (0, 1), (1, 0), (1, 1), (2, 0), (2, 1)]
[[(0, 0), (1, 0), (2, 0)], [(0, 1), (1, 1), (2, 1)]]
myStr = "coffee"
a = {i:v for i,v in enumerate(myStr)}
b = {v:i for i,v in enumerate(myStr)}
# ๋์
๋๋ฆฌ๋ ํค ์ค๋ณต์ ํ์ฉํ์ง ์๊ธฐ ๋๋ฌธ์ ๊ฐ์ ํค๋ฅผ ์ฌ๋ฌ ๋ฒ ๋ฑ๋กํ ๊ฒฝ์ฐ
# ๋์ค์ ๋ฑ๋ก๋ ๊ฐ์ผ๋ก ๋ฎ์ด์์์ง๋ค
print(a)
print(b)
>>> {0: 'c', 1: 'o', 2: 'f', 3: 'f', 4: 'e', 5: 'e'}
{'c': 0, 'o': 1, 'f': 3, 'e': 5}
ํจ์๋ 1๊ธ ๊ฐ์ฒด๋ค, ํจ์๋ 1๊ธ ๊ฐ์ฒด๋ค, ํจ์๋ 1๊ธ ๊ฐ์ฒด...๊ฐ ๋ญ์ง?
1๊ธ ๊ฐ์ฒด๋ ๋งค๊ฐ๋ณ์๋ก ์ ๋ฌํ ์ ์๊ณ , ๋ณ์์ ๋์ ํ ์ ์๊ณ , ํจ์๊ฐ ๋ฐํํ ์ ์๋ ๊ฐ์ฒด๋ฅผ ๋งํ๋ค.
ํ์ด์ฌ์์ ํจ์๋ 1๊ธ ๊ฐ์ฒด๋ผ์ ๋งค๊ฐ๋ณ์์ ๋ฃ๊ฑฐ๋ ํ ์ ์๋ค.
ํจ์๊ฐ ๊ผญ ํ์ด์ฌ์์๋ง 1๊ธ ๊ฐ์ฒด์ธ ๊ฒ์ ์๋๋ค.
def add(a, b):
return a+b
def sub(a, b):
return a-b
def calc(func, a, b): # ํจ์๋ฅผ ๋งค๊ฐ๋ณ์๋ก ๋ฐ์์ ๋ฐ์ ํจ์๋ฅผ ์ํ
return func(a,b)
print(calc(add, 3, 5)) # calc ํจ์์ ์ธ์๋ก add ํจ์๋ฅผ ๋๊ฒจ์ฃผ์๋ค
print(calc(sub, 3, 5)) # calc ํจ์์ ์ธ์๋ก sub ํจ์๋ฅผ ๋๊ฒจ์ฃผ์๋ค
>>> 8
-2
map()
์ ์ฒซ ๋ฒ์งธ ์ธ์๋ sorted()
์ ๋ ๋ฒ์งธ ์ธ์๋ ์ด๋ฐ ์์ผ๋ก ํจ์ ์์ฒด๋ฅผ ๋ฐ๋๋ค. sorted()
์์ ์ ๋ ฌํ ๊ธฐ์ค๊ฐ์ ๊ณ ๋ฅผ ๋ lambda
๋ก ์ธ๋ผ์ธ ํจ์๋ฅผ ๋ง๋ค์ด ์ฐ๊ณค ํ๋๋ฐ ๊ทธ๊ฒ ํจ์ ์์ฒด๋ฅผ ๋๊ฒจ์ฃผ๊ธฐ ์ํด์ ๊ทธ๋ฌ๋ ๊ฑฐ์๋ค. ๊ทธ๋ ๋ค๋ฉด ์๋ ์ฝ๋์ฒ๋ผ def
๋ฅผ ์ฌ์ฉํด์ ๋ง๋ค ์๋ ์๋ค.
def getKey(item):
return item[1] # ๊ทธ๋ฅ 1๋ฒ ํญ๋ชฉ์ ๋๋ ค์ฃผ๋ ์น๊ตฌ
a = [(1,2), (8,1), (0,4)]
print(sorted(a, getKey))
# getKey ํจ์์ ๋งค๊ฐ๋ณ์์ ๋ญ ๋ฐ๋ก ์ ๋ฃ์ด์ฃผ๊ณ ํจ์๋ง ์ ๋ฌํ๋ค.
# ์ ๋ฌ๋ฐ์ ํจ์ getKey๋ sorted ํจ์๊ฐ ์คํํ๋ค.
>>> [(8,1), (1,2), (0,4)]
์ค์ ์ ๋ค์ ๊ฐ์์์ ์ฌ๋ฐ์๋ ๋ถ๋ถ ์๊ธฐ๋ ํ๊ณ ๊ถ๊ธํด์ ๋ ์ฐพ์๋ณธ ๋ถ๋ถ ์๊ธฐ๋ ํ๊ณ ์ง๋ฌธ๋ ์ข ํ๊ณ ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ์๊ธฐ๋ ์ข ํ๊ณ ์๋ฐ์คํฌ๋ฆฝํธ ์๊ธฐ๋ ํ๊ณ ํ์ค์คํค AI ์๊ธฐ๋ ํ๊ณ ์กฐ๊ต๋์ ์ด๋ํด์ ์ง๋ฌธ๋ ๋ช ๊ฐ์ง ํ๊ณ ์ง๋ก ์๊ธฐ๋ ํ๊ณ ์ ์์ฝง์์ผ๐ง ์๊ธฐ๋ ํ๋ค.