1) ๋ด์ฅ ํจ์
(1) map(func, iterable)
- iterable ์์๋ค์ ํด๋น ํจ์์ ์ ์ฉ์์ผ Map ํํ๋ก Return ํ๊ธฐ ๋๋ฌธ์ list ํน์ tuple ์๋ฃํ์ผ๋ก ๋ณํ์์ผ ์ฃผ์ด์ผ ํ๋ค.
- ๋ํ์ ์ผ๋ก iterable์๋ ๋ฆฌ์คํธ, ํํ, ๋ฌธ์์ด ๋ฑ์ด ์ฌ์ฉ๋์ด์ง๋ค.
- ์ฆ, map() ํจ์๋ function์ iterable์ ๋ชจ๋ ์์์ ๋ํด ์ ์ฉํ๊ณ function์ ์ํด ๋ณ๊ฒฝ๋ iterator๋ฅผ ๋ฐํํ๋ค
[์์]
L = [1,2]
x, y = map(str, L)
(2) filter(func, iterable)
- iterable ์์๋ค์ ํด๋น ํจ์์ ์ ์ฉ์์ผ filter ํํ๋ก Return ํ๊ธฐ ๋๋ฌธ์ list ํน์ tuple ์๋ฃํ์ผ๋ก ๋ณํ์์ผ ์ฃผ์ด์ผ ํ๋ค.
- ๋ํ์ ์ผ๋ก iterable์๋ ๋ฆฌ์คํธ, ํํ, ๋ฌธ์์ด ๋ฑ์ด ์ฌ์ฉ๋์ด์ง๋ค. (์ , ๋์ ๋๋ฆฌ๋ ์ฌ์ฉํ ์ ์์ง๋ง ๋ณ๋ก..?)
- ์ฆ, filter() ํจ์๋ ์ธ์๋ก ๋ฐ์ function์ ๊ฐ๊ฐ์ iterable ์์์ ๋ํด Boolean ๊ฐ์ ๋ฐํํ๋ฉฐ True ๊ฐ์ ๋ฐํํ๋ฉด ๊ทธ ์์๋ ๋จ๊ฒ ๋๊ณ False๋ฅผ ๋ฐํํ๋ฉด ๊ทธ ์์๋ ์ ๊ฑฐ๋๋ค!
[์์]
L = [1,2,3,4,5]
x, y = filter(lambda x : x < 3, L)
[์ฐธ๊ณ ] ๋๋คํจ์ (lambda)
- ๊ฐ๋จํ๊ฒ ์ค๋ช ํ์๋ฉด ์ด๋ฆ์ด ์๋ ํจ์ (์ต๋ช ํจ์)๋ก ์ผ๋ฐ์ ์ผ๋ก ํจ์๋ฅผ def ํค์๋๋ฅผ ์ฌ์ฉํ์ฌ ์ ์ธํ๋ฉด ๋ฉ๋ชจ๋ฆฌ์ ์ฝ๋ ์์ญ์ ์ ์ฅ๋์ด ๊ณ์ ์ฌ์ฌ์ฉํ ์ ์์ง๋ง ๋๋ค ํจ์๋ ์ฐ๊ณ ๋ฒ๋ฆด ์ ์๋ ์ผ์์ ์ธ ํจ์์ด๋ค.
- ๊ฐ๋จํ ๊ธฐ๋ฅ์ ์ผ๋ฐ์ ์ธ ํจ์์ ๊ฐ์ด ์ ์ํ๊ธฐ๋ณด๋ค ํ์ํ ๊ณณ์์ ๋๋คํจ์๋ก ์ ์ํ์ฌ ์ฌ์ฉํ๊ณ ๋ฒ๋ฆด ์ ์๊ธฐ ๋๋ฌธ์ ์ฝ๋๊ฐ ๊ฐ๊ฒฐํด์ง๊ณ ๋ฉ๋ชจ๋ฆฌ๊ฐ ์ ์ฝ๋๋ค๋ ์ฅ์ ์ด ์๋ค.
- ๊ทธ๋ฆฌ๊ณ ํ์ด์ฌ๋ JavaScript์ฒ๋ผ ๋๋ถ๋ถ์ ๊ธฐ๋ฅ์ ๊ฐ์ฒด๋ก ๋ค๋ฃจ๊ณ ์ผ๊ธ ๊ฐ์ฒด์ ํน์ง ๋ํ ๊ฐ์ง๊ณ ์๊ธฐ ๋๋ฌธ์ ๋๋คํจ์๋ฅผ ๋ณ์์ ๋ฃ์ด ์ฌ์ฉํ ์ ์๋ค.
[๊ธฐ์กด]
def add(num1, num2):
result = num1 + num2
return result
>>> add(5, 10)
[labmda]
(lambda x, y : x + y)(5, 10)
๋๋
func = lambda x, y : x + y
>>> func(5, 10)
- ๋๋คํจ์ ํ์ : “lambda ๋งค๊ฐ๋ณ์ : ํํ์”
- ๋๋ค ํจ์๋ ์ด๋ฆ์ด ์๋ ์ต๋ช ํจ์์ด๊ธฐ์ ๋ฉ๋ชจ๋ฆฌ ์์ ๋ฐ๋ก ์ ์ฅ๋์ง ์์ ๋ค์ ์ฌ์ฉํ ์ ์์ง๋ง ์ต๋ช ํจ์๋ ์ผ๋จ (์ผ๊ธ) ๊ฐ์ฒด๋ก ๋ค๋ค์ง๊ธฐ ๋๋ฌธ์ ๋ณ์์ ์ ์ฅํ์ฌ ์ฌ์ฌ์ฉํ ์ ์๋ค!!
- ๋ํ, ๋๋คํจ์๋ return ํค์๋๋ฅผ ์ ์ง ์์๋ ์๋์ผ๋ก ๊ฒฐ๊ณผ๊ฐ์ return ํ๋ค!
๋ฐ์ํ
'๐ง Programming > Python' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
Python - ๋ด์ฅํจ์ (any, all) (0) | 2023.08.14 |
---|---|
Python - ๋ด์ฅํจ์ (zip) (0) | 2023.08.14 |
Python - ํจ์ (Function) ์ ์ธ (0) | 2023.08.08 |
Python - ํ ์ค ๋ณตํฉ๋ฌธ (if, for) (0) | 2023.08.04 |
Python - ํ ์ค for๋ฌธ (Comprehension) (0) | 2023.08.04 |