map ํจ์๋ฅผ ๊ฒ์ํ๋ค๊ฐ filter, reduce๊น์ง ํจ๊ป ์ ๋ฆฌ๋ ๊ธ์ ๋ดค๋ค. ๊ทผ๋ฐ lambda์ ๊ฐ์ด ์ฐ์ธ๋ค๊ณ ํด์, ๊ด๋ จ๋ ๋ด์ฉ์ ํจ๊ป ์ ๋ฆฌํด๋ณด๋ ค๊ณ ํ๋ค.
map, filter, reduce๋ javascript ์ฝ๋์นด๋ฐ๋ฏธ ๊ฐ์์์ iterator ๋ฐฐ์ธ ๋ ๋์๋ ๊ฐ๋ ์ธ๋ฐ ๋ญ๊ฐ ๋๋์ด ๋ค๋ฅด๋ค ๐
๋๋ค ํ์์ ํจ์๋ฅผ ๋ฑ ํ ์ค๋ง์ผ๋ก ๋ง๋ค๊ฒ ํด์ค๋ค. ์ฌ์ฉํ ๋๋ ์๋์ ๊ฐ์ด ์จ์ฃผ๋ฉด ๋๋ค.
lambda ์ธ์ : ํํ์
def hap(x, y):
return x + y
hap(10, 20) # result: 30
(lambda x,y: x + y)(10, 20) # result: 30
map์ ์ฒซ ๋ฒ์งธ ํ๋ผ๋ฏธํฐ๋ ํจ์, ๋ ๋ฒ์งธ๋ก๋ iterable์ด ๋ค์ด๊ฐ๋ค. ๊ทธ๋ฆฌ๊ณ iterable ๋ฐ์ดํฐ๋ฅผ ์ฒซ ๋ฒ์งธ ์ธ์์ธ ํจ์์ ๊ฐ๊ฐ ์ ๋ฌํ์ฌ ๊ฒฐ๊ณผ๊ฐ์ ๋ฐ๋๋ค.
๊ฒฐ๊ณผ๊ฐ์ ๊ฒฝ์ฐ python 2์์๋ listํ์ ๋ฐํํ์ง๋ง, 3์์๋ generatorํ์ผ๋ก ๋ฐํํ๋๋ก ๋ณ๊ฒฝ๋์๋ค. ๊ทธ๋์ ๋จ์ map ํจ์๋ง ์ฐ๊ฒ ๋ ๊ฒฝ์ฐ ์ธํฐํ๋ฆฌํฐ์ <map object at 0x10f9d6828> ์ด๋ฐ ์์ผ๋ก ๊ฒฐ๊ณผ๊ฐ์ด ์๋ iterator๋ฅผ returnํ๋ค.
๊ทธ๋์ list๋ก ๋ฐ๊ณ ์ถ๋ค๋ฉด list() ํจ์๋ก ๊ฐ์ธ์ type์ ๋ณ๊ฒฝํด์ผ ํ๋ค.
map(function_to_apply, list_of_inputs)
#๋์ด์ฐ๊ธฐ๋ก input๋๋ ์ ์ ๊ฐ ๋๊ฐ๋ฅผ ๋ฐ๋ ๋ณ์
a,b = map(int, input().split())
์ฒซ ๋ฒ์งธ ์ธ์๋ก ๋ค์ด์ค๋ ํจ์๋ฅผ ๋ฐ๋ก ํํํ๊ธฐ ์ํด lambda ํ์์ ์ด์ฉํ๋ฉด ๋ค์๊ณผ ๊ฐ์ด ๋ํ๋ผ ์ ์๋ค.
map(lambda x: x ** 2, range(5)) # ํ์ด์ฌ 2
[0, 1, 4, 9, 16]
>>> list(map(lambda x: x ** 2, range(5))) # ํ์ด์ฌ 2 ๋ฐ ํ์ด์ฌ 3
[0, 1, 4, 9, 16]
์ฝ๊ฒ ๋งํ๋ฉด iterator๋ฅผ returnํ๋ ํจ์๋ค. for loop์์ ์ฐ์๋๋ ๊ฐ๋ค์ ์ฌ์ฉ ๊ฐ๋ฅํ๊ฒ ๋ง๋ค๊ณ , next() ํจ์๋ฅผ ํตํด ํ๋ฒ์ ํ๋์ฉ ๊ฒ์๋ ์ ์๋ค๋ ์ ์์ ์ผ๋ฐ ํจ์์ ๋ค๋ฅด์ง ์์ง๋ง, yield statment๋ฅผ ๊ฐ๊ณ ์๋ค๋ ๊ฒ์ด ํฐ ์ฐจ์ด์ ์ด๋ค.
iterator๋ ํด๋์ค์ __iter__, __next__ ๋๋ __getitem__
๋ฉ์๋๋ฅผ ๊ตฌํํด์ผ ํ์ง๋ง ์ ๋๋ ์ดํฐ๋ ํจ์ ์์์ yield๋ผ๋ ํค์๋๋ง ์ฌ์ฉํ๋ฉด ๋์ด๋ค.
generator | A function which returns an iterator. It looks like a normal function except that it contains yield statements for producing a series of values usable in a for-loop or that can be retrieved one at a time with the next() function.
Each yield temporarily suspends processing, remembering the location execution state (including local variables and pending try-statements). When the generator resumes, it picks-up where it left-off (in contrast to functions which start fresh on every invocation).
์ผ๋ฐ ํจ์์ generator๋ฅผ ๊ตฌ๋ถ์์ผ์ฃผ๋ ๊ฐ์ฅ ํต์ฌ์ ์ธ ๋ถ๋ถ์ด๋ค. ๊ฐ yield๋ ์ผ์์ ์ผ๋ก ํ๋ก์ธ์ค๋ฅผ ๋ฉ์ถ๊ณ , ์คํ๋ถ๋ฅผ ๊ธฐ์ตํ๋ค. ๊ทธ๋ฆฌ๊ณ generator๊ฐ ๋ค์ ์ฌ์ฉ๋ ๋ ๋ง์ง๋ง์ผ๋ก ๋๋๋ ๋ถ๋ถ๋ถํฐ ์์ํ๋ค.
์ ๋๋ ์ดํฐ๋ ํ ๋ฒ ํธ์ถ๋ ๋๋ง๋ค ํ๋์ ๊ฐ๋ง์ ์ ๋ฌ(yield)ํ๋ค. ์ฆ, ์๋์ #1๊น์ง๋ ์์ง ์๋ฌด๋ฐ ๊ณ์ฐ์ ํ์ง ์๊ณ ๋๊ตฐ๊ฐ๊ฐ ๋ค์ ๊ฐ์ ๋ํด์ ๋ฌผ์ด๋ณด๊ธฐ๋ฅผ ๊ธฐ๋ค๋ฆฌ๊ณ ์๋ ์ํ์ธ ๊ฒ์ด๋ค.
def square_numbers(nums):
for i in nums:
yield i * i
my_nums = square_numbers([1, 2, 3, 4, 5]) #1
print my_nums
ํจ์๊ฐ True๋ก returnํ ์์๋ค ๋ชจ์ ๋ฆฌ์คํธ๋ก ๋ง๋ ๋ค. for loop๋ฅผ ๋ฎ์์ง๋ง ๋ด์ฅ ํจ์์ด๊ณ ์๋๊ฐ ๋น ๋ฅด๋ค.
number_list = range(-5, 5)
less_than_zero = list(filter(lambda x: x < 0, number_list))
print(less_than_zero)
# Output: [-5, -4, -3, -2, -1]
๋ฆฌ์คํธ์์ ์ด๋ค ๊ณ์ฐ์ ํ ๋ค ๊ฒฐ๊ณผ๋ฅผ ๋ด๋ณด๋ด๋๋ฐ์ ๋งค์ฐ ์ ์ฉํ ํจ์๋ค.
product = 1
list = [1, 2, 3, 4]
for num in list:
product = product * num
# product = 24
๋ฐฑ์ค ์ฝ๋ ๋ฌธ์ ๋ฅผ (์ ์ผ ์ฌ์ด๊ฑฐ๐) ํ๋๋ง ํ์ด๋ณด๋ ค๊ณ ํ๋ค๊ฐ input ๋ฐ๋๊ฑฐ๋ฅผ ๋ชฐ๋ผ์ ์ฌ์ค ์ ๋ฆฌ๋ฅผ ์์ํ๋ค. ๊ฐ์ ์คํํ๋ ๋ด์ฉ ์์ฒด๋ ์ด๋ ต์ง ์์๋ฐ, ์ฒ์์ ๊ฐ ๋ค์ด์ค๋ฉด ๋ด์ฉ์ ์คํํ๋๋ก ํ๋ ์ ๋ ฅ ๋ถ๋ถ์ด ์ ์ดํด๊ฐ ์ ๊ฐ๋ค.
๋ฌธ์ (1330): ๋ ์ ์ A์ B๊ฐ ์ฃผ์ด์ก์ ๋, A์ B๋ฅผ ๋น๊ตํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์
๋ ฅ ์ฒซ์งธ ์ค์ A์ B๊ฐ ์ฃผ์ด์ง๋ค. A์ B๋ ๊ณต๋ฐฑ ํ ์นธ์ผ๋ก ๊ตฌ๋ถ๋์ด์ ธ ์๋ค.
์ถ๋ ฅ ์ฒซ์งธ ์ค์ ๋ค์ ์ธ ๊ฐ์ง ์ค ํ๋๋ฅผ ์ถ๋ ฅํ๋ค.
A๊ฐ B๋ณด๋ค ํฐ ๊ฒฝ์ฐ์๋ '>', ์์ ๊ฒฝ์ฐ์๋ '<', ๊ฐ์ ๊ฒฝ์ฐ '=='๋ฅผ ์ถ๋ ฅํ๋ค.
์ ํ -10,000 โค A, B โค 10,000
์ธํฐํ๋ฆฌํฐ์์ ์ ๋ ฅ ๊ฐ์ ๋ฐ๋ ํจ์. terminal์์ input() ํจ์๋ฅผ ์คํํ๋ฉด ๊ฐ์ ๋ฃ์ ์ ์๋๋ก ์์ ํ์ดํ >>>๊ฐ ์ฌ๋ผ์ง๊ณ , ์ ๋ ฅ ์ ๊ฐ์ ๋ฐ๋ก ๋ฐํํ๋ค. ๋ง์ฝ ๋ณ์์ input() ํจ์๋ฅผ assign ํ๋ฉด ๋ณ์ ๊ฐ์ input๊ฐ์ด ๋ค์ด๊ฐ๋ค.
parameter์ ๋ฃ์ ๊ฐ์ ๊ธฐ์ค์ผ๋ก ๋ฌธ์์ด์ ๋๋์ด list๋ก returnํ๋ ํจ์๋ค. ๊ดํธ ์์ ์๋ฌด๊ฒ๋ ๋ฃ์น ์์ผ๋ฉด ๊ณต๋ฐฑ์ ๊ธฐ์ค์ผ๋ก ๋ฌธ์์ด์ ๋๋ ์ค๋ค.
a = "Life is too short"
a.split() # result: ['Life', 'is', 'too', 'short']
b = "a:b:c:d"
b.split(':') # result: ['a', 'b', 'c', 'd']
split๊ณผ ๋ฐ๋๋ก ๋ฌธ์์ด ์ฌ์ด์ ์ํ๋ ๊ฐ์ ์ ๋ ฅํด์ ํ๋๋ก ํฉ์ณ์ฃผ๋ ํจ์๋ ์๋ค. join ํจ์๋ ๋ฌธ์์ด๋ฟ๋ง ์๋๋ผ ์์ผ๋ก ๋ฐฐ์ธ ๋ฆฌ์คํธ๋ ํํ๋ ์ ๋ ฅ์ผ๋ก ์ฌ์ฉํ ์ ์๋ค.
",".join('abcd')
'a,b,c,d'
",".join(['a', 'b', 'c', 'd'])
'a,b,c
a, b = map(int, input().split())
if a > b:
print('>')
elif: a < b:
print('<')
else:
print('=')
๊ฐ์ฌํฉ๋๋ค~!