๐ ํ์ด์ฌ ์ด๋ณด ํ์ถ ํ๋ ! ํ์ด์ฌ ๋ด์ฅํจ์ ์์ ํฌํจ ์๋ฒฝ ๊ฐ์ด๋: ์ฝ๋ฉ ํจ์จ 100๋ฐฐ ๋์ด๋ ์นํธํค!
ํ์ด์ฌ ๋ด์ฅํจ์ ์์ ํฌํจ ํ์ ํ์ต ๊ฐ์ด๋! ์ฝ๋ฉ ์๊ฐ์ ์ค์ด๊ณ ํจ์จ์ ๋์ด๋ ํ์ด์ฌ ๋ด์ฅํจ์ 10๊ฐ์ง๋ฅผ ์์ ํ์ฌ ์ค์ ์์ ์ฝ๋์ ํจ๊ป ์ฝ๊ณ ์ ๋ฌธ์ ์ผ๋ก ์ค๋ช ํฉ๋๋ค.
์ ํ์ด์ฌ ๋ด์ฅํจ์๋ฅผ ์์์ผ ํ๋๊ฐ? ์ฝ๋ฉ ํจ์จ์ ๋น๋ฐ!
**ํ์ด์ฌ(Python)**์ ๊ฐ๊ฒฐํ๊ณ ๊ฐ๋ ฅํ ๋ฌธ๋ฒ ๋๋ถ์ ์ ์ธ๊ณ ๊ฐ๋ฐ์๋ค์๊ฒ ๊ฐ์ฅ ์ฌ๋๋ฐ๋ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด ์ค ํ๋์ ๋๋ค. ํ์ด์ฌ์ด ์ดํ ๋ก ๊ฐ๋ ฅํ ์ด์ ๋ ๋ฐ๋ก ๋ฐฉ๋ํ ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ๋๋ถ์ด, ๊ฐ๋ฐ์๊ฐ ์์ฃผ ์ฌ์ฉํ๋ ๊ธฐ๋ฅ์ ๋ฏธ๋ฆฌ ๊ตฌํํด ๋์ ๋ด์ฅํจ์(Built-in Functions) ๋๋ถ์ ๋๋ค.
์ด ํ์ด์ฌ ๋ด์ฅํจ์๋ค์ ๋ฅ์ํ๊ฒ ์ฌ์ฉํ๋ ๊ฒ์ ์ฝ๋๋ฅผ ๋ ์งง๊ฒ, ๋ ๋น ๋ฅด๊ฒ, ๊ทธ๋ฆฌ๊ณ ๋ "ํ์ด์จ๋(Pythonic)"ํ๊ฒ ์์ฑํ๋ ํต์ฌ ๋น๊ฒฐ์
๋๋ค. ๋ง์ฝ ์์ง๋ len(), print(), type() ๊ฐ์ ๊ธฐ๋ณธ์ ์ธ ํจ์๋ง ์ฌ์ฉํ๊ณ ์๋ค๋ฉด, ์ฌ๋ฌ๋ถ์ ํ์ด์ฌ์ด ์ ๊ณตํ๋ ๋ฌดํํ ์ ์ฌ๋ ฅ์ ์ ๋ฐ๋ง ์ฌ์ฉํ๊ณ ์๋ ์
์
๋๋ค. ์ด ๊ธ์์๋ ์ด๋ณด ๊ฐ๋ฐ์๊ฐ ๋ฐ๋์ ์์์ผ ํ ํ์ ํ์ด์ฌ ๋ด์ฅํจ์ ์์ ํฌํจ ์๋ฒฝ ๊ฐ์ด๋๋ฅผ ์ ๊ณตํฉ๋๋ค. ์ง๊ธ๋ถํฐ ํ์ด์ฌ ๋ด์ฅํจ์๋ฅผ ๋ง์คํฐํ๊ณ ์ฝ๋ฉ ์ค๋ ฅ์ ํ ๋จ๊ณ ์
๊ทธ๋ ์ด๋ํ ์ค๋น๋ฅผ ํด๋ณด์ธ์! 
์๋ฃํ ๋ณํ๊ณผ ์ํ ์ฐ์ฐ์ ๋ฌ์ธ: ํ์ ํ์ด์ฌ ๋ด์ฅํจ์ ์์ ํฌํจ
๋ฐ์ดํฐ๋ฅผ ๋ค๋ฃจ๋ ํ๋ก๊ทธ๋๋ฐ์์ ์๋ฃํ์ ๋ณํํ๊ฑฐ๋ ๊ธฐ๋ณธ์ ์ธ ์ํ ์ฐ์ฐ์ ์ํํ๋ ๊ฒ์ ํ์์ ์ ๋๋ค. ํ์ด์ฌ ๋ด์ฅํจ์๋ ์ด๋ฌํ ์์ ์ ๋จ ํ๋์ ๋ช ๋ น์ด๋ก ๊ฐ๊ฒฐํ๊ฒ ์ฒ๋ฆฌํ ์ ์๊ฒ ํด์ค๋๋ค.
| ํจ์ | ๊ธฐ๋ฅ ์์ฝ | ํ์ด์ฌ ๋ด์ฅํจ์ ์์ ํฌํจ |
| int() | ๊ฐ์ ์ ์ํ์ผ๋ก ๋ณํ | int("123") $\rightarrow$ 123 |
| str() | ๊ฐ์ ๋ฌธ์์ดํ์ผ๋ก ๋ณํ | str(3.14) $\rightarrow$ "3.14" |
| float() | ๊ฐ์ ๋ถ๋ ์์์ ํ์ผ๋ก ๋ณํ | float(100) $\rightarrow$ 100.0 |
| sum() | ์ดํฐ๋ฌ๋ธ(iterable) ๊ฐ์ฒด์ ํฉ๊ณ๋ฅผ ๊ณ์ฐ | sum([1, 2, 3]) $\rightarrow$ 6 |
| round() | ์ซ์๋ฅผ ๋ฐ์ฌ๋ฆผํ์ฌ ๋ฐํ | round(3.14159, 2) $\rightarrow$ 3.14 |
sum() ํจ์๋ฅผ ์ฌ์ฉํ ๋, ๋จ์ํ ๋ฆฌ์คํธ์ ํฉ์ ๊ตฌํ ๋ฟ๋ง ์๋๋ผ ์ด๊ธฐ๊ฐ์ ์ง์ ํ์ฌ ๋์ ํฉ๊ณ๋ฅผ ๊ณ์ฐํ ์๋ ์์ต๋๋ค.
์์ ์ฝ๋: ๋์ ํฉ๊ณ ๊ณ์ฐ
Pythonmy_list = [5, 10, 15] initial_value = 100 total_sum = sum(my_list, initial_value) # total_sum = 100 + 5 + 10 + 15 = 130 print(total_sum)
์ด์ฒ๋ผ ๊ฐ๋จํ ํ์ด์ฌ ๋ด์ฅํจ์ ์ฌ์ฉ๋ง์ผ๋ก๋ ๋ณต์กํ for ๋ฃจํ๋ฅผ ์๋ตํ๊ณ ์ฝ๋๋ฅผ ๊น๋ํ๊ฒ ๋ง๋ค ์ ์์ต๋๋ค.
๋ฐ์ดํฐ ๊ตฌ์กฐ๋ฅผ ์ง๋ฐฐํ๋ ํ์ด์ฌ ๋ด์ฅํจ์ ์์ ํฌํจ: map(), filter(), zip()
ํ์ด์ฌ์์ ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ๊ณ ๋ณํํ๋ ๋ฐ ๊ฐ์ฅ ์ค์ํ ์ญํ ์ ํ๋ ํจ์๋ค์ ๋ฐ๋ก map(), filter(), zip()์
๋๋ค. ์ด๋ค์ ๊ณ ์ฐจ ํจ์(Higher-order functions)์ ์ผ์ข
์ผ๋ก, ์ฝ๋ฉ ํ
์คํธ๋ ์ค๋ฌด์์ ๋ฐ์ดํฐ๋ฅผ ํจ์จ์ ์ผ๋ก ๋ค๋ฃฐ ๋ ๋ฐ๋์ ํ์ํฉ๋๋ค.
map(): ์ดํฐ๋ฌ๋ธ ๊ฐ์ฒด์ ๋ชจ๋ ์์์ ๋์ผํ ํจ์๋ฅผ ์ ์ฉํ์ฌ ์๋ก์ด ์ดํฐ๋ฌ๋ธ์ ๋ฐํํฉ๋๋ค.
์์ ์ฝ๋: ๋ฆฌ์คํธ์ ๋ชจ๋ ์์ ์ ๊ณฑํ๊ธฐ
Pythonnumbers = [1, 2, 3] # ๋๋ค ํจ์๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ ์์๋ฅผ ์ ๊ณฑ squared = list(map(lambda x: x**2, numbers)) # squared = [1, 4, 9] print(squared)filter(): ์ดํฐ๋ฌ๋ธ ๊ฐ์ฒด์ ์์ ์ค ํน์ ์กฐ๊ฑด(ํจ์์ ๋ฐํ ๊ฐ์ด
True์ธ ๊ฒฝ์ฐ)์ ๋ง์กฑํ๋ ์์๋ง ํํฐ๋งํ์ฌ ๋ฐํํฉ๋๋ค.์์ ์ฝ๋: ์ง์๋ง ๊ฑธ๋ฌ๋ด๊ธฐ
Pythonnumbers = [1, 2, 3, 4, 5, 6] # ๋๋ค ํจ์๋ฅผ ์ฌ์ฉํ์ฌ ์ง์๋ง ํํฐ๋ง even_numbers = list(filter(lambda x: x % 2 == 0, numbers)) # even_numbers = [2, 4, 6] print(even_numbers)zip(): ์ฌ๋ฌ ๊ฐ์ ์ดํฐ๋ฌ๋ธ ๊ฐ์ฒด๋ค์ ๋ณ๋ ฌ๋ก ๋ฌถ์ด(์์ถํ์ฌ) ํํ์ ์ดํฐ๋ฌ๋ธ์ ๋ง๋ญ๋๋ค.
์์ ์ฝ๋: ์ด๋ฆ๊ณผ ์ ์ ๋ฌถ๊ธฐ
Pythonnames = ["Alice", "Bob"] scores = [90, 85] # ๋ ๋ฆฌ์คํธ๋ฅผ ๋ฌถ์ด [('Alice', 90), ('Bob', 85)] ์์ฑ zipped_data = list(zip(names, scores)) print(zipped_data)
์ด ์ธ ๊ฐ์ง ํ์ด์ฌ ๋ด์ฅํจ์ ์์ ํฌํจ์ ํตํด, ๋ฐ๋ณต๋ฌธ ์์ด ๋ฐ์ดํฐ๋ฅผ ์กฐ์ํ๋ ํจ์ํ ํ๋ก๊ทธ๋๋ฐ์ ๊ฐ๋ ฅํจ์ ๋๊ปด๋ณด์ธ์.
๋ฐ์ดํฐ ๊ฒ์๊ณผ ์ ๋ ฌ์ ๋ง๋ฒ: max(), min(), sorted()
๋ฐ์ดํฐ์ ์์ ๊ฐ์ฅ ํฐ ๊ฐ, ๊ฐ์ฅ ์์ ๊ฐ์ ์ฐพ๊ฑฐ๋ ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฌํ๋ ๊ฒ์ ๋ฐ์ดํฐ ๋ถ์ ๋ฐ ์๊ณ ๋ฆฌ์ฆ ๊ตฌํ์ ๊ธฐ๋ณธ์ ๋๋ค. ํ์ด์ฌ ๋ด์ฅํจ์๋ ์ด ๊ณผ์ ์ ๋งค์ฐ ์ง๊ด์ ์ผ๋ก ์ฒ๋ฆฌํฉ๋๋ค.
max() / min(): ์ดํฐ๋ฌ๋ธ ๋ด์์ ์ต๋/์ต์ ๊ฐ์ ๋ฐํํฉ๋๋ค. ๋ณต์กํ ๊ฐ์ฒด ๋ฆฌ์คํธ์์๋
key์ธ์๋ฅผ ์ฌ์ฉํ์ฌ ํน์ ๊ธฐ์ค์ผ๋ก ์ต๋/์ต์ ๊ฐ์ฒด๋ฅผ ์ฐพ์ ์ ์์ต๋๋ค.์์ ์ฝ๋: ๋์ ๋๋ฆฌ ๋ฆฌ์คํธ์์ ์ต๋๊ฐ ์ฐพ๊ธฐ
Pythonstudents = [{'name': 'A', 'score': 95}, {'name': 'B', 'score': 88}] # 'score'๋ฅผ ๊ธฐ์ค์ผ๋ก ์ ์๊ฐ ๊ฐ์ฅ ๋์ ํ์ ์ฐพ๊ธฐ highest_scorer = max(students, key=lambda item: item['score']) print(highest_scorer) # {'name': 'A', 'score': 95}sorted(): ์๋ก์ด ์ ๋ ฌ๋ ๋ฆฌ์คํธ๋ฅผ ๋ฐํํฉ๋๋ค (์๋ณธ ๋ฆฌ์คํธ๋ ๋ณ๊ฒฝํ์ง ์์).
reverse=True์ธ์๋ฅผ ์ฌ์ฉํ์ฌ ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ์ด ๊ฐ๋ฅํฉ๋๋ค.์์ ์ฝ๋: ๋ฌธ์์ด ๋ฆฌ์คํธ๋ฅผ ๊ธธ์ด ์์ผ๋ก ์ ๋ ฌํ๊ธฐ
Pythonwords = ["apple", "kiwi", "banana", "orange"] # ๋ฌธ์์ด์ '๊ธธ์ด'๋ฅผ ๊ธฐ์ค์ผ๋ก ์ ๋ ฌ sorted_by_length = sorted(words, key=len) # sorted_by_length = ['kiwi', 'apple', 'banana', 'orange'] print(sorted_by_length)
max(), min(), sorted()์ key ์ธ์๋ฅผ ํ์ฉํ๋ ๊ฒ์ ๋ฐ์ดํฐ ์ฒ๋ฆฌ ์ ํ์ ์คํฌ์ด๋ฉฐ, ์ด๋ค ํ์ด์ฌ ๋ด์ฅํจ์ ์์ ํฌํจ ํ์ฉ๋ฒ์ ์๋ฌํ๋ฉด ์ฝ๋๊ฐ ํจ์ฌ ํจ์จ์ ์ผ๋ก ๋ฐ๋๋๋ค.
์กฐ๊ฑด ํ์ธ๊ณผ ์คํ ํ๋ฆ ์ ์ด: all(), any(), enumerate()
ํ๋ก๊ทธ๋จ์ ๋ ผ๋ฆฌ์ ํ๋ฆ์ ์ ์ดํ๊ฑฐ๋, ๋ฆฌ์คํธ ์ ์ฒด์ ์กฐ๊ฑด์ ํ ๋ฒ์ ํ์ธํ ๋ ์ ์ฉํ ํ์ด์ฌ ๋ด์ฅํจ์๋ค์ด ์์ต๋๋ค.
all(): ์ดํฐ๋ฌ๋ธ ๊ฐ์ฒด์ ๋ชจ๋ ์์๊ฐ
True์ด๋ฉดTrue๋ฅผ ๋ฐํํฉ๋๋ค. (๋น ์ดํฐ๋ฌ๋ธ์True)์์ ์ฝ๋: ๋ชจ๋ ์ซ์๊ฐ ์์์ธ์ง ํ์ธ
Pythonnumbers1 = [1, 2, 3] numbers2 = [1, -2, 3] print(all(x > 0 for x in numbers1)) # True print(all(x > 0 for x in numbers2)) # Falseany(): ์ดํฐ๋ฌ๋ธ ๊ฐ์ฒด์ ํ๋๋ผ๋ ์์๊ฐ
True์ด๋ฉดTrue๋ฅผ ๋ฐํํฉ๋๋ค. (๋น ์ดํฐ๋ฌ๋ธ์False)์์ ์ฝ๋: ํ๋๋ผ๋ ์์๊ฐ ์๋์ง ํ์ธ
Pythonprint(any(x < 0 for x in numbers2)) # Trueenumerate(): ์ดํฐ๋ฌ๋ธ ๊ฐ์ฒด๋ฅผ ์ํํ ๋ ์ธ๋ฑ์ค์ ์์๋ฅผ ํจ๊ป ๋ฌถ์ด ๋ฐํํฉ๋๋ค. (๊ฐ์ฅ ์์ฃผ ์ฌ์ฉ๋๋ ํ์ด์ฌ ๋ด์ฅํจ์ ์ค ํ๋)
์์ ์ฝ๋: ๋ฆฌ์คํธ์ ์ธ๋ฑ์ค์ ๊ฐ ์ถ๋ ฅ
Pythonfruits = ["์ฌ๊ณผ", "๋ฐ๋๋", "์ฒด๋ฆฌ"] for index, fruit in enumerate(fruits): print(f"์ธ๋ฑ์ค {index}: {fruit}") # ์ถ๋ ฅ: ์ธ๋ฑ์ค 0: ์ฌ๊ณผ, ์ธ๋ฑ์ค 1: ๋ฐ๋๋, ์ธ๋ฑ์ค 2: ์ฒด๋ฆฌ
enumerate()๋ฅผ ์ฌ์ฉํ๋ฉด range(len(list))๋ฅผ ์ฌ์ฉํ๋ ๊ฒ๋ณด๋ค ํจ์ฌ ๊ฐ๋
์ฑ์ด ์ข๊ณ ๋น ๋ฆ
๋๋ค. ์ด๋ค ํ์ด์ฌ ๋ด์ฅํจ์ ์์ ํฌํจ์ ํตํด ์กฐ๊ฑด ํ์ธ ๋ฐ ๋ฃจํ๋ฅผ ์ต์ ํํ ์ ์์ต๋๋ค.
๊ฒฐ๋ก : ํ์ด์ฌ ๋ด์ฅํจ์ ๋ง์คํฐ, ์ฝ๋ฉ ์ค๋ ฅ ํฅ์์ ์ง๋ฆ๊ธธ!
์ง๊ธ๊น์ง ํ์ด์ฌ ๋ด์ฅํจ์ ์์ ํฌํจํ์ฌ ์๋ฃํ ๋ณํ(int, str), ๋ฐ์ดํฐ ์ฒ๋ฆฌ(map, filter, zip), ์ ๋ ฌ/๊ฒ์(max, sorted), ์กฐ๊ฑด ํ์ธ(all, any, enumerate) ๋ฑ 10๊ฐ์ง ํ์ ํจ์๋ฅผ ์์ธํ ์ดํด๋ณด์์ต๋๋ค.
ํ์ด์ฌ ๋ด์ฅํจ์๋ฅผ ์ ํ์ฉํ๋ ๊ฒ์ ์ฝ๋ฉ์ ํจ์จ์ฑ๊ณผ ๊ฐ๋ ์ฑ์ ๋์์ ๋์ด๋ ๊ฐ์ฅ ๋น ๋ฅธ ๊ธธ์ ๋๋ค. ์ด ํจ์๋ค์ ๋ฐ๋ณต๋ฌธ์ด๋ ๋ณต์กํ ์กฐ๊ฑด๋ฌธ ๋์ ์ ์ ํ ์ฌ์ฉํ๋ฉด, ์ฝ๋๊ฐ ๊ฐ๊ฒฐํด์ง๊ณ ๋ฒ๊ทธ ๋ฐ์ ํ๋ฅ ๋ ์ค์ด๋ญ๋๋ค. ํ์ด์ฌ ๋ด์ฅํจ์๋ ๋จ์ํ ์ธ์ฐ๋ ๊ฒ์ด ์๋๋ผ, ์ค์ ์์ ์ฝ๋๋ฅผ ํตํด ์ง์ ์ฌ์ฉํด ๋ณด๊ณ ๊ทธ ์๋ฆฌ๋ฅผ ์ดํดํ๋ ๊ฒ์ด ์ค์ํฉ๋๋ค.
CTA: ์ค๋ ๋ฐฐ์ด ํ์ด์ฌ ๋ด์ฅํจ์๋ค์ ์ฌ๋ฌ๋ถ์ ๊ธฐ์กด ์ฝ๋์ ์ ์ฉํด ๋ณด์ธ์! ํ์ด์ฌ ๋ด์ฅํจ์ ์์ ํฌํจ ๊ฐ์ด๋๊ฐ ๋์์ด ๋์๋ค๋ฉด, ๋ค์์๋ ํ์ด์ฌ ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ๋ค๋ฅธ ์ ์ฉํ ๋ชจ๋(์: itertools, collections)์ ๋ํด์๋ ๊น์ด ์๊ฒ ๋ค๋ค๋ณด๊ฒ ์ต๋๋ค. ๊ถ๊ธํ ์ ์ ๋๊ธ๋ก ๋จ๊ฒจ์ฃผ์ธ์!
FAQ (์์ฃผ ๋ฌป๋ ์ง๋ฌธ)
Q1: ํ์ด์ฌ ๋ด์ฅํจ์๋ฅผ ์ง์ ๋ง๋ค์ด์ ์ฌ์ฉํ ์๋ ์๋์?
A: ๋ค, ๊ฐ๋ฅํฉ๋๋ค. ํ์ด์ฌ์ **ํจ์(function)**๋ฅผ ์ง์ ์ ์ํ ์ ์๋๋ก def ํค์๋๋ฅผ ์ ๊ณตํฉ๋๋ค. ํ์ง๋ง ์ด๋ฏธ ์กด์ฌํ๋ ํ์ด์ฌ ๋ด์ฅํจ์์ ์ด๋ฆ์ด ์ค๋ณต๋์ง ์๋๋ก ์ฃผ์ํด์ผ ํฉ๋๋ค. ๋ด์ฅ ํจ์์ ๋์ผํ ์ด๋ฆ์ผ๋ก ํจ์๋ฅผ ์ ์ํ๋ฉด ๋ด์ฅ ํจ์๊ฐ ๊ฐ๋ ค์ง๊ฒ ๋ฉ๋๋ค.
Q2: map() ํจ์๋ฅผ ์ฌ์ฉํ๋๋ฐ ๋ฆฌ์คํธ๊ฐ ๋ฐํ๋์ง ์๊ณ <map object at ...>๋ผ๊ณ ๋์ค๋๋ฐ ์ ๊ทธ๋ฐ๊ฐ์?
A: map() ํจ์๋ ๋ฉ๋ชจ๋ฆฌ ํจ์จ์ฑ์ ์ํด ์ดํฐ๋ ์ดํฐ(iterator) ๊ฐ์ฒด๋ฅผ ๋ฐํํฉ๋๋ค. ์ค์ ๊ฒฐ๊ณผ ๊ฐ์ ํ์ธํ๋ ค๋ฉด list() ํจ์๋ก ๋ช
์์ ์ผ๋ก ํ ๋ณํ์ ํด์ค์ผ ํฉ๋๋ค. (์: list(map(ํจ์, ์ดํฐ๋ฌ๋ธ))) ์ด๋ filter()๋ zip()์๋ ๋์ผํ๊ฒ ์ ์ฉ๋ฉ๋๋ค.
Q3: sorted()์ ๋ฆฌ์คํธ ๊ฐ์ฒด์ sort() ๋ฉ์๋๋ ์ด๋ค ์ฐจ์ด๊ฐ ์๋์?
A: ํ์ด์ฌ ๋ด์ฅํจ์์ธ **sorted()**๋ ์๋ก์ด ์ ๋ ฌ๋ ๋ฆฌ์คํธ๋ฅผ ๋ฐํํ๋ฉฐ, ์๋ณธ ๋ฆฌ์คํธ๋ ๋ณ๊ฒฝํ์ง ์์ต๋๋ค. ๋ฐ๋ฉด, ๋ฆฌ์คํธ ๊ฐ์ฒด์ sort() ๋ฉ์๋๋ ์๋ณธ ๋ฆฌ์คํธ๋ฅผ ์ ์๋ฆฌ์์(in-place) ์ ๋ ฌํ๊ณ ๋ฐํ ๊ฐ์ None์
๋๋ค. ์๋ณธ ๋ฐ์ดํฐ์ ๋ณด์กด ์ฌ๋ถ์ ๋ฐ๋ผ ์ ํํ์ฌ ์ฌ์ฉํฉ๋๋ค.
Q4: ํ์ด์ฌ ๋ด์ฅํจ์ ์์ ํฌํจ ์ธ์ ๋ ๋ง์ ํจ์๋ฅผ ๋ณด๋ ค๋ฉด ์ด๋๋ฅผ ์ฐธ๊ณ ํด์ผ ํ๋์?
A: ๊ฐ์ฅ ์ ํํ๊ณ ๊ณต์์ ์ธ ์ ๋ณด๋ **ํ์ด์ฌ ๊ณต์ ๋ฌธ์(Python Documentation)**์ "Built-in Functions" ์น์ ์ ์ฐธ๊ณ ํ๋ ๊ฒ์ ๋๋ค. ๋ชจ๋ ํ์ด์ฌ ๋ด์ฅํจ์์ ์ ์, ๋งค๊ฐ๋ณ์, ์ฌ์ฉ๋ฒ์ ๋ํ ์์ธํ ์ ๋ณด๋ฅผ ์ ๊ณตํฉ๋๋ค.

๋๊ธ
๋๊ธ ์ฐ๊ธฐ