๐ ๊ฐ์๋ ธํธ ๐
- sort() : ๋ฆฌ์คํธ์ ์์๋ฅผ ์ ๋ ฌํ๋ ํจ์๋ก, ์๋ณธ์ ๋ฉค๋ฒ ์์๋ฅผ ๋ณ๊ฒฝํ๋ค. ๋ฐ๋ผ์ ์๋ณธ์ ์์๋ ๋ณ๊ฒฝํ์ง ์๊ณ , ์ ๋ ฌ๋ ๊ฐ์ ๊ตฌํ๋ ค๋ฉด sort ํจ์๋ฅผ ์ฌ์ฉํ ์ ์๋ค.
- sorted() : ๋งค๊ฐ๋ณ์๋ก ๋ค์ด์จ iterableํ ๋ฐ์ดํฐ๋ฅผ ์๋ก์ด ์ ๋ ฌ๋ ๋ฆฌ์คํธ๋ก ๋ง๋ค์ด์ ๋ฐํํด ์ฃผ๋ ํจ์๋ค.
sort ์์
list1 = [3, 2, 5, 1]
list2 = [i for i in list1] # ๋๋ copy.deepcopy๋ฅผ ์ฌ์ฉ
list2.sort()
sorted ์์
list1 = [3, 2, 5, 1]
list2 = sorted(list1)
โ ๋ฌธ์ 1 [ 2์ฐจ์ ๋ฆฌ์คํธ ๋ค์ง๊ธฐ ]
ํ๋ก๊ทธ๋๋จธ์ค
์ฝ๋ ์ค์ฌ์ ๊ฐ๋ฐ์ ์ฑ์ฉ. ์คํ ๊ธฐ๋ฐ์ ํฌ์ง์ ๋งค์นญ. ํ๋ก๊ทธ๋๋จธ์ค์ ๊ฐ๋ฐ์ ๋ง์ถคํ ํ๋กํ์ ๋ฑ๋กํ๊ณ , ๋์ ๊ธฐ์ ๊ถํฉ์ด ์ ๋ง๋ ๊ธฐ์ ๋ค์ ๋งค์นญ ๋ฐ์ผ์ธ์.
programmers.co.kr
๋ค์์ ๋ง์กฑํ๋ ํจ์, solution์ ์์ฑํด์ฃผ์ธ์.
- solution ํจ์๋ ์ด์ฐจ์ ๋ฆฌ์คํธ, mylist๋ฅผ ์ธ์๋ก ๋ฐ์ต๋๋ค
- solution ํจ์๋ mylist ์์์ ํ๊ณผ ์ด์ ๋ค์ง์ ํ ๊ฐ์ ๋ฆฌํดํด์ผํฉ๋๋ค.
์๋ฅผ ๋ค์ด mylist [[1, 2, 3], [4, 5, 6], [7, 8, 9]]๊ฐ ์ฃผ์ด์ง ๊ฒฝ์ฐ, solution ํจ์๋ [[1, 4, 7], [2, 5, 8], [3, 6, 9]] ์ ๋ฆฌํดํ๋ฉด ๋ฉ๋๋ค.
์ ํ ์กฐ๊ฑด
- mylist์ ์์์ ๊ธธ์ด๋ ๋ชจ๋ ๊ฐ์ต๋๋ค.
- mylist์ ๊ธธ์ด๋ mylist[0]์ ๊ธธ์ด์ ๊ฐ์ต๋๋ค.
- ๊ฐ ๋ฆฌ์คํธ์ ๊ธธ์ด๋ 100 ์ดํ์ธ ์์ฐ์์ ๋๋ค.
โ Solution
def solution(mylist):
answer = [[] * len(mylist) for _ in range(len(mylist))]
for i in range(len(mylist)):
for j in range(len(mylist[i])):
answer[i].append(mylist[j][i])
return answer
๊ณ์ ํ๋ฆฌ๋ ๋ฐ๋์ ๊ฐ์๋ ธํธ๋ฅผ ๋ณด๊ณ ํ์๋ค. ๋ณดํต์ 2์ค for๋ฌธ์ ์ด์ฉํ๋ค๊ณ ํ๋ค.
์ฃผ์ํ ์ ์ answer = [[ ]] ๋ก ์ด๊ธฐํ๋ฅผ ํ๋ฉด out of range ์ค๋ฅ๊ฐ ๋ ์ ์ ๋ ฅ๊ฐ์ ๋ง๊ฒ ์ด๊ธฐํ๋ฅผ ์์ผ์ค์ผ ํ๋ค.
โ Feedback โ
def solution(mylist):
return list(map(list, zip(*mylist)))
- zip(*iterables) : ๊ฐ iterables ์ ์์๋ค์ ๋ชจ์ผ๋ iterator๋ฅผ ๋ง๋ ๋ค.
ํํ์ iterator๋ฅผ ๋๋ ค์ฃผ๋๋ฐ, i ๋ฒ์งธ ํํ์ ๊ฐ ์ธ์๋ก ์ ๋ฌ๋ ์ํ์ค๋ ์ดํฐ๋ฌ๋ธ์ i ๋ฒ์งธ ์์๋ฅผ ํฌํจํ๋ค.
๋ค์ ๋งํด, ์ฌ๋ฌ ๊ฐ์ ์ํ ๊ฐ๋ฅํ(iterable) ๊ฐ์ฒด๋ฅผ ์ธ์๋ก ๋ฐ๊ณ , ๊ฐ ๊ฐ์ฒด๊ฐ ๋ด๊ณ ์๋ ์์๋ฅผ ํฐํ์ ํํ๋ก ์ฐจ๋ก๋ก ์ ๊ทผํ ์ ์๋ ๋ฐ๋ณต์(iterator)๋ฅผ ๋ฐํํ๋ค.
์์ 1
mylist = [1, 2, 3]
new_list = [40, 50, 60]
for i in zip(mylist, new_list):
print (i) #(1, 40) (2, 50) (3, 60)
์์ 2
list1 = [1, 2, 3, 4]
list2 = [100, 120, 30, 300]
list3 = [392, 2, 33, 1]
answer = []
for number1, number2, number3 in zip(list1, list2, list3):
print(number1 + number2 + number3)
์์ 3 (Key ๋ฆฌ์คํธ์ Value ๋ฆฌ์คํธ๋ก ๋์ ๋๋ฆฌ ์์ฑํ๊ธฐ)
animals = ['cat', 'dog', 'lion']
sounds = ['meow', 'woof', 'roar']
answer = dict(zip(animals, sounds)) # {'cat': 'meow', 'dog': 'woof', 'lion': 'roar'}
ํ์ด์ฌ์ zip ํจ์์ dict ์์ฑ์๋ฅผ ์ด์ฉํ๋ฉด ์ฝ๋ ๋จ ํ ์ค๋ก, ๋ ๋ฆฌ์คํธ๋ฅผ ํฉ์ณ ๋์ ๋๋ฆฌ๋ก ๋ง๋ค ์ ์๋ค.
โ ๋ฌธ์ 2 [ i๋ฒ์งธ ์์์ i+1๋ฒ์งธ ์์ ]
ํ๋ก๊ทธ๋๋จธ์ค
์ฝ๋ ์ค์ฌ์ ๊ฐ๋ฐ์ ์ฑ์ฉ. ์คํ ๊ธฐ๋ฐ์ ํฌ์ง์ ๋งค์นญ. ํ๋ก๊ทธ๋๋จธ์ค์ ๊ฐ๋ฐ์ ๋ง์ถคํ ํ๋กํ์ ๋ฑ๋กํ๊ณ , ๋์ ๊ธฐ์ ๊ถํฉ์ด ์ ๋ง๋ ๊ธฐ์ ๋ค์ ๋งค์นญ ๋ฐ์ผ์ธ์.
programmers.co.kr
์ซ์๋ฅผ ๋ด์ ๋ฆฌ์คํธ mylist๊ฐ solution ํจ์์ ํ๋ผ๋ฏธํฐ๋ก ์ฃผ์ด์ง๋๋ค. solution ํจ์๊ฐ mylist์ i๋ฒ์งธ ์์์ i+1๋ฒ์งธ ์์์ ์ฐจ๋ฅผ ๋ด์ ์ผ์ฐจ์ ๋ฆฌ์คํธ์ ์ฐจ๋ก๋ก ๋ด์ ๋ฆฌํดํ๋๋ก ์ฝ๋๋ฅผ ์์ฑํด์ฃผ์ธ์. ๋จ, ๋ง์ง๋ง์ ์๋ ์์๋ (๋ง์ง๋ง+1)๋ฒ์งธ์ ์์์์ ์ฐจ๋ฅผ ๊ตฌํ ์ ์์ผ๋, ์ด ๊ฐ์ ๊ตฌํ์ง ์์ต๋๋ค.
์ ํ ์กฐ๊ฑด
- mylist์ ๊ธธ์ด๋ 1 ์ด์ 100 ์ดํ์ธ ์์ฐ์์ ๋๋ค.
- mylist์ ์์๋ 1 ์ด์ 100 ์ดํ์ธ ์์ฐ์์ ๋๋ค.
์ ์ถ๋ ฅ ์

- 83๊ณผ 48์ ์ฐจ๋ 35์ ๋๋ค.
- 48๊ณผ 13์ ์ฐจ๋ 35์ ๋๋ค.
- 13๊ณผ 4์ ์ฐจ๋ 9์ ๋๋ค.
- 4์ 71์ ์ฐจ๋ 67์ ๋๋ค.
- 71๊ณผ 11์ ์ฐจ๋ 60์ ๋๋ค.
๋ฐ๋ผ์ [35, 35, 9, 67, 60]๋ฅผ ๋ฆฌํดํฉ๋๋ค.
โ Solution
def solution(mylist):
for i in range(1,len(mylist)):
mylist[i-1] -= mylist[i]
if i == len(mylist)-1:
mylist.pop(i)
return list(map(abs,mylist))
๋ณดํต์ len๊ณผ index๋ฅผ ์ฌ์ฉํด์ ๊ฐ ์์์ ์ ๊ทผํ๋ค. ๋ฆฌ์คํธ์์ ๋ ๊ฐ์ฉ ๊บผ๋ด๊ณ ์ถ์๋๋ฐ ์ ์ ๋๋ค.
โ Feedback โ
def solution(mylist):
answer = []
for a, b in zip(mylist, mylist[1:]):
answer.append(abs(a-b))
return answer
- ํ์ด์ฌ์ zip์ ์ด์ฉํ๋ฉด index๋ฅผ ์ฌ์ฉํ์ง ์๊ณ ๊ฐ ์์์ ์ ๊ทผํ ์ ์๋ค.
- ์ฃผ์ํ ์ : zip ํจ์์ ์๋ก ๊ธธ์ด๊ฐ ๋ค๋ฅธ ๋ฆฌ์คํธ๊ฐ ์ธ์๋ก ๋ค์ด์ค๋ ๊ฒฝ์ฐ์๋ ๊ธธ์ด๊ฐ ์งง์ ์ชฝ ๊น์ง๋ง ์ดํฐ๋ ์ด์ ์ด ์ด๋ฃจ์ด์ง๋ค. ๋ ์์ธํ ๋ด์ฉ์ ๊ณต์ ๋ ํผ๋ฐ์ค - zip ์ฐธ๊ณ
โ ๋ฌธ์ 3 [ ๋ชจ๋ ๋ฉค๋ฒ์ type ๋ณํํ๊ธฐ ]
ํ๋ก๊ทธ๋๋จธ์ค
์ฝ๋ ์ค์ฌ์ ๊ฐ๋ฐ์ ์ฑ์ฉ. ์คํ ๊ธฐ๋ฐ์ ํฌ์ง์ ๋งค์นญ. ํ๋ก๊ทธ๋๋จธ์ค์ ๊ฐ๋ฐ์ ๋ง์ถคํ ํ๋กํ์ ๋ฑ๋กํ๊ณ , ๋์ ๊ธฐ์ ๊ถํฉ์ด ์ ๋ง๋ ๊ธฐ์ ๋ค์ ๋งค์นญ ๋ฐ์ผ์ธ์.
programmers.co.kr
๋ฌธ์์ด ๋ฆฌ์คํธ mylist๋ฅผ ์ ๋ ฅ๋ฐ์, ์ด ๋ฆฌ์คํธ๋ฅผ ์ ์ํ ๋ฆฌ์คํธ๋ก ๋ฐ๊พผ ๊ฐ์ ๋ฆฌํดํ๋ ํจ์, solution์ ๋ง๋ค์ด์ฃผ์ธ์. ์๋ฅผ ๋ค์ด mylist๊ฐ ['1', '100', '33'] ์ธ ๊ฒฝ์ฐ, solution ํจ์๋ [1, 100, 33] ์ ๋ฆฌํดํ๋ฉด ๋ฉ๋๋ค.
์ ํ ์กฐ๊ฑด
- mylist์ ๊ธธ์ด๋ 100 ์ดํ์ธ ์์ฐ์์ ๋๋ค.
- mylist์ ์์๋ 10์ง์ ์ซ์๋ก ํํํ ์ ์๋ ๋ฌธ์์ด์ ๋๋ค. ์ฆ, 'as2' ์ ๊ฐ์ ๋ฌธ์์ด์ ๋ค์ด์์ง ์์ต๋๋ค.
์ ์ถ๋ ฅ ์

โ Solution 1
def solution(mylist):
return list(map(int, mylist))
โ Solution 2
def solution(mylist):
return [int(i) for i in mylist]
- map(function, iterable) : Iterable์ ๋ชจ๋ ๋ฉค๋ฒ์ type์ ๋ณํํ ์ ์๋ค.
์ฒ์์ mapํจ์๋ฅผ ์จ์ ํ์๊ณ , ๋ ๋ฒ์งธ๋ ๋ฐ๋ณต๋ฌธ์ ์ด์ฉํด ํ์๋ค. ๊ฐ์๋ ธํธ์์๋ mapํจ์๋ฅผ ์ถ์ฒํ๋ค.
โ ๋ฌธ์ 4 [ map ํจ์ ์์ฉํ๊ธฐ ]
ํ๋ก๊ทธ๋๋จธ์ค
์ฝ๋ ์ค์ฌ์ ๊ฐ๋ฐ์ ์ฑ์ฉ. ์คํ ๊ธฐ๋ฐ์ ํฌ์ง์ ๋งค์นญ. ํ๋ก๊ทธ๋๋จธ์ค์ ๊ฐ๋ฐ์ ๋ง์ถคํ ํ๋กํ์ ๋ฑ๋กํ๊ณ , ๋์ ๊ธฐ์ ๊ถํฉ์ด ์ ๋ง๋ ๊ธฐ์ ๋ค์ ๋งค์นญ ๋ฐ์ผ์ธ์.
programmers.co.kr
์ ํ ์กฐ๊ฑด
- mylist์ ๊ธธ์ด๋ 100 ์ดํ์ธ ์์ฐ์์ ๋๋ค.
- mylist ๊ฐ ์์์ ๊ธธ์ด๋ 100 ์ดํ์ธ ์์ฐ์์ ๋๋ค.
์ ์ถ๋ ฅ ์

โ Solution
def solution(mylist):
answer = list(map(len, mylist))
return answer
๋๊ตฐ๊ฐ len์ ๊ดํด ์ง๋ฌธ์ ํ๋๋ฐ ์๋ก ์๊ฒ ๋ผ์ ์ ์ด๋ณธ๋ค.
map์ ๋๋ฒ์งธ ์ธ์์ ๊ฐ ์์์ ์ฒซ๋ฒ์งธ ์ธ์๋ก ๋ค์ด์จ ํจ์๋ฅผ ์ ์ฉํด์ค๋๋ค.
• ํจ์๋ค์ ()๋ฅผ ๋ถ์ด๋ฉด, ์ด๋ ๋ ์ด์ ํจ์๊ฐ ์๋๋ผ ํจ์๊ฐ ๋ฆฌํดํ ๊ฐ์ ์๋ฏธํฉ๋๋ค.์ฆ,
• len -> ํจ์๋ฅผ ์๋ฏธํจlen() -> ํจ์๋ฅผ ํธ์ถํ์ฌ ๋ฐ์ ๋ฆฌํด๊ฐ์ ์๋ฏธํจ