1. lambda
lambda( )๋ ์ต๋ช
ํจ์๋ผ๊ณ ํ๋ฉฐ, ์ด๋ฆ์ด ์๋ ํจ์์
๋๋ค. ๊ฐ๋จํ ์์ ๋ก ์ค๋ช
๋๋ ค ๋ณผ๊ฒ์.
print()
๋ ์ด๋ฆ์ด ์๋ ํจ์์
๋๋ค. hojun = print hojun('hello world') #์ถ๋ ฅ๊ฐ #hello world
print
๋ฅผ hojun
์ผ๋ก ๋ฐ๊ณ printํจ์๋ฅผ ํธ์ถํ ์ ์์ต๋๋ค. ์ฆ, ์ด๋ฆ์ด ์๋ค๋ ๋ป์ ํจ์๋ฅผ ๊ฐ๋ฅดํค๊ณ ์๋ '๋ณ์๋ช
' ์ด๋ผ๊ณ ์๊ฐํ๋ฉด ๋ผ์.ย
ํ๊ฐ์ง ์์ ๋ฅผ ๋ ์ดํด๋ณด๋๋ก ํ ๊ฒ์.
์
๋ ฅ
def add(x, y): return x + y def sub(): pass def div(): pass def mul(): pass caculator = [add, sub, div, mul] print(caculator[0](10, 20))#0๋ฒ์งธ ๊ฐ์ add ์ ๋๋ค.
ย
์ถ๋ ฅ
30
์ฐ์ add, sub, div, mul์ด๋ผ๋ ์ฌ์น์ฐ์ฐ์ ์ํํ๋ ํจ์๋ฅผ ์ ์ธํด์ฃผ์์ต๋๋ค. ๊ทธ ๋ค์ ๊ฐ ํจ์๋ค์ ์ด๋ฆ์ calculator๋ผ๋ ๋ฐฐ์ด์ ๋ฃ์ด์ฃผ์๊ณ , print๋ก 0๋ฒ์งธ ๋ฐฐ์ด์ ํธ์ถํ์๋๋ ํจ์ add์ ๊ฒฐ๊ณผ๊ฐ์ธ 30์ด ๋์ค๊ฒ ๋์์ต๋๋ค.
์ฐ๋ฆฌ๊ฐ ์ผ๋ฐ์ ์ผ๋ก ์ฌ์ฉํ ์ ์๋ ๋ณ์์ ์์น์ ( )(๊ดํธ)๋ง ์ฌ์ฉํ์ง ์๋๋ค๋ฉด ๋ณ์์ฒ๋ผ ์ฌ์ฉํ ์ ์์ผ๋ฉฐ, ํธ์ถํ ๋๋ '( )'(๊ดํธ)๋ฅผ ์ฌ์ฉํด์ค๋๋ค.
ย
๊ทธ๋ผ lambdaํจ์๋ ์ ์ต๋ช
ํจ์ ์ผ๊น์? ์ด๋ฆ์ด ์๋ ํจ์๋ค๊ณผ๋ ๋ค๋ฅด๊ฒ ๋งค์ฐ ๊ฐ๊ฒฐํ๊ฒ ์์ฑํ ์ ์๊ธฐ ๋๋ฌธ์
๋๋ค.
lambda ๋งค๊ฐ๋ณ์ : ๊ฒฐ๊ณผ
์ด๋ ๊ฒ ๋จ ํ์ค๋ก ํจ์์ ๊ธฐ๋ฅ์ ๊ตฌํํ ์ ์์ด์! ๋ํ lambdaํจ์๋ return์ด๋ผ๋ ํค์๋๋ฅผ ์
๋ ฅํ์ง ์์๋ ๊ฒฐ๊ณผ ๋ถ๋ถ์ ํตํด ์๋์ผ๋ก returnํด์ค๋๋ค.
์์ ๋ฅผ ๋ณผ๊ฒ์.
์
๋ ฅ
์ ๊ณฑ = lambda x : x ** 2 ์ ๊ณฑ(3)
ย
์ถ๋ ฅ
9
ย
lambda( )ํจ์๋ฅผ ์ด์ฉํ์ฌ x๋ผ๋ ๋งค๊ฐ๋ณ์๊ฐ ๋ค์ด์ค๋ฉด
x ** 2
๋ฅผ ํ ๋ค returnํ๋ผ๋ ๋ป์
๋๋ค.ย
์
๋ ฅ
(lambda x : x ** 2)(3)
ย
์ถ๋ ฅ
9
ย
์ ์์ ์ฒ๋ผ ์ธ์๋ ๋ฐ๋ก ๋์
ํ ์ ์์ต๋๋ค.
ย
์ฆ lambda๋ ์ต๋ช
ํจ์๋ผ๋ ์ด๋ฆ์ฒ๋ผ ํจ์์ ์ด๋ฆ์ ์ ํ์ง ์๊ณ lambda๋ผ๋ ํค์๋๋ฅผ ์ด์ฉํด ํจ์์ฒ๋ผ ์ด์ฉํ ์ ์๋ค๋ ๋ป์
๋๋ค!
2. map( )
lambda ํจ์์ ๊ฐ์ฅ ๋ง์ด ์กฐํฉ๋์ด ์ด์ฉํ๋ ํจ์์
๋๋ค. ๊ฐ๋จํ ์ค๋ช
๋๋ฆฌ๋๋ก ํ ๊ฒ์.
๋ฐฉ๊ธ ์์์ ๋ง๋ค์๋ ๋งค๊ฐ๋ณ์๋ฅผ ์ ๊ณฑํ์ฌ returnํ๋ ํจ์๋ฅผ ๋ง๋ค์ด ๋ณผ๊ฒ๋๋ค. ๊ทธ๋ฐ๋ฐ ์๊น ์์์ ์์ฑํ๋ ์์ ๋ ํ๋์ ๊ฐ๋ง ๋ฐ๊ณ ํ๋์ ๊ฐ๋ง ๋ฆฌํดํ ์ ์์์ฃ ?
์ฌ๋ฌ๊ฐ์ด ๋ค์ด์ค๊ฒ ๋๋ค๋ฉด ์ด๋ป๊ฒ ํด์ผํ ๊น์?
์
๋ ฅ
# ์ฒซ๋ฒ์งธ ๋ฐฉ๋ฒ def ์ ๊ณฑ(x): return x ** 2 list(map(์ ๊ณฑ, [1, 2, 3, 4])) # ๋๋ฒ์งธ ๋ฐฉ๋ฒ list(map(lambda x : x ** 2, [1, 2, 3, 4]))
ย
์ถ๋ ฅ
[1, 4, 9, 16]
ย
์ฒซ๋ฒ์งธ ๋ฐฉ๋ฒ์ฒ๋ผ ์ด๋ฆ์ด ์๋ '์ ๊ณฑ'ํจ์๋ฅผ ์๋ก ์ ์ํ์ฌ ๋ง๋๋ ๋ฐฉ๋ฒ๋ ์๊ณ , lambdaํจ์๋ฅผ ์ ์ํ์ฌ ๋ง๋๋ ๋ฐฉ๋ฒ์ด ์์ต๋๋ค.
๋ ๋ฐฉ๋ฒ ๋ค map()ํจ์๋ฅผ ์ด์ฉํ์๋๋ฐ์, map์ ๋ฆฌ์คํธ์ ์์๋ค์ ์ง์ ๋ ํจ์๋ก ์ฒ๋ฆฌํด์ฃผ๋ ํจ์์
๋๋ค.
์ฆ, ์ฐ๋ฆฌ๋ [1,2,3,4]๋ผ๋ ๋ฆฌ์คํธ ์์๋ค์ '์ ๊ณฑ' ํน์ 'lambda x:x**2'๋ผ๋ ํจ์๋ก ์ฒ๋ฆฌํ๋๋ก ํ์์ต๋๋ค.
ย
map์ ์ฌ์ฉ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
map(ํจ์, ๋ฆฌ์คํธ ํน์ ํํ)
ย
3. filter( )
์ด๋ฒ์๋ lambda์ filter๋ฅผ ์ฌ์ฉํด๋ณด๋๋ก ํ ๊ฒ์.
์
๋ ฅ
list(filter(lambda x : x > 50, range(100)))
ย
์ถ๋ ฅ
[51, 52, 53, . . . ]
filter ํจ์๋ฅผ ์ด์ฉํ์ฌ 50๋ณด๋ค ํฐ x๊ฐ์ ์ถ๋ ฅํ๋๋ก ํ์์ต๋๋ค.
ย
ย
4. ์ค์ ๋ฌธ์
์๋ ๋ฌธ์ ๋ฅผ ํ์ด๋ณด์ธ์!
'์ซ์' ๋ฐฐ์ด์ '์น์' ๋ฐฐ์ด๊ณผ ์ง์ง์ด์ ์น์๋งํผ ์ ๊ณฑ์ ์์ผ์ค ๊ฒ ์
๋๋ค.
๋ต์ ํ๋จ์ ์์ผ๋ ๊ผญ ๋ฌธ์ ๋ฅผ ํ์ด๋ณด์๊ณ ํ์ธํด์ฃผ์ธ์:)
ย
์
๋ ฅ
์ซ์ = [1, 2, 3, 4, 5] ์น์ = [2, 2, 2, 3, 3] #๋ฌธ์ #1. ์ซ์์ ์น์๋ฅผ zip์ผ๋ก ๋งตํํด์ ์งํํ์ธ์. #2. ์ซ์๋ฅผ ์น์๋งํผ ์น์ํ์ฌ ๊ฒฐ๊ณผ๊ฐ์ ํํํด์ฃผ์ธ์. #3. ์น์ํ ๊ฐ์ด 100์ด์์ธ ๊ฐ์ ์ถ๋ ฅํ์ธ์. #4. ์น์ํ ๊ฐ์ ๋ชจ๋ ๋ํ์ธ์.
ย
์ถ๋ ฅ
# ๊ฒฐ๊ณผ๊ฐ์ ๋ค์๊ณผ ๊ฐ์์ผ ํฉ๋๋ค. # 1. ์ซ์์ ์น์๋ฅผ zip์ผ๋ก ๋งตํํด์ ์งํํ์ธ์. [(1, 2), (2, 2), (3, 2), (4, 3), (5, 3)] # 2. ์ซ์๋ฅผ ์น์๋งํผ ์น์ํ์ฌ ๊ฒฐ๊ณผ๊ฐ์ ํํํด์ฃผ์ธ์. [1, 4, 9, 64, 125] # 3. ์น์ํ ๊ฐ์ด 100์ด์์ธ ๊ฐ์ ์ถ๋ ฅํ์ธ์. [125] # 4. ์น์ํ ๊ฐ์ ๋ชจ๋ ๋ํ์ธ์ 203
ย
ย
ย
ย
ย
์ ๋ต
์
๋ ฅ
# 1. ์ซ์์ ์น์๋ฅผ zip์ผ๋ก ๋งตํํด์ ์งํํ์ธ์. list(zip(์ซ์, ์น์)) # 2. ์ซ์๋ฅผ ์น์๋งํผ ์น์ํ์ฌ ๊ฒฐ๊ณผ๊ฐ์ ํํํด์ฃผ์ธ์. list(map(lambda x: x[0] : x[1], zip(์ซ์, ์น์))) # 3. ์น์ํ ๊ฐ์ด 100์ด์์ธ ๊ฐ์ ์ถ๋ ฅํ์ธ์. list(filter(lambda x : x > 100, list(map(lambda x : x[0] ** x[1], zip(์ซ์, ์น์))))) # 4. ์น์ํ ๊ฐ์ ๋ชจ๋ ๋ํ์ธ์ sum(map(lambda x : x[0] ** x[1], zip(์ซ์, ์น์)))
ย