1. ํจ์ - ๊ธฐ์ด
๊ฐ๋
DEF) ์ด๋ค ์ผ์ ์ํํ๋ ์ฝ๋์ ๋ฉ์ด๋ฆฌ, ๋๋ ์ฝ๋์ ๋ฌถ์
- ์ฅ์
- ํ์ํ ๋๋ง๋ค ํธ์ถ์ด ๊ฐ๋ฅํ๋ค
- ๋ฐ๋ณต์ ์ผ๋ก ์ํํด์ผ ํ๋ ์ ๋ฌด๋ฅผ ํ ๋ฒ๋ง ์์ฑํด ๋์๋ ๋จ
- ⇒ ์ฝ๋ ์์ ์ ๊ฐ์ ์์ ์ ์ฌ๋ฌ ๋ฒ ๋ฐ๋ณตํ์ง ์์๋ ๋๋ค๋ ์ !
- ๋
ผ๋ฆฌ์ ์ธ ๋จ์๋ก ๋ถํ ์ด ๊ฐ๋ฅํ๋ค
- ๊ฐ๋จํ ๋ํ์ ๊ณ์ฐํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ๋๋ผ๋ ๊ณฑ์ ์ฝ๋, ๋ง์ ์ฝ๋, ๋๋์ ์ฝ๋ ๋ฑ์ผ๋ก ๋๋ ์ ์์
- ์ฝ๋์ ์บก์ํ
- ํจ์์ ์ธํฐํ์ด์ค๋ง ์ ์ ์ํ๋ค๋ฉด ๋ค๋ฅธ ์ฌ๋์ด ์ฝ๊ฒ ์ฝ๋๋ฅผ ๊ฐ์ ธ๋ค ์ฌ์ฉํ ์ ์์
- ์ธํฐํ์ด์ค์ ์ ์ = ์ ๋ ฅ๊ฐ(input)๊ณผ ์ถ๋ ฅ๊ฐ(output)์ ๋ช ํํ ํ๋ ๊ฒ
- ์ฝ๋์ ๋ด๋ถ ๊ตฌ์กฐ๋ฅผ ๋ชฐ๋ผ๋ ํจ์ ์ฌ์ฉ ๊ฐ๋ฅ
- ํจ์์ ์ธํฐํ์ด์ค๋ง ์ ์ ์ํ๋ค๋ฉด ๋ค๋ฅธ ์ฌ๋์ด ์ฝ๊ฒ ์ฝ๋๋ฅผ ๊ฐ์ ธ๋ค ์ฌ์ฉํ ์ ์์
- ํ์ํ ๋๋ง๋ค ํธ์ถ์ด ๊ฐ๋ฅํ๋ค
ํจ์ ์ ์ธ๊ณผ ์คํ
def ํจ์์ด๋ฆ (๋งค๊ฐ๋ณ์ #1 ...):
๋ช
๋ น๋ฌธ1
๋ช
๋ น๋ฌธ2
return <๋ฐํ๊ฐ>
- ์ฝ๋์ค๋ช
- def: ‘definition’์ ์ค์๋ง. ํจ์์ ์ ์๋ฅผ ์์ํ๋ค๋ ์๋ฏธ. ํจ์์ ์ ์ธ ๋ถ๋ถ์ ์ฝ๋์ ์ฒ์์ ์ ๋ ฅํด์ผ ํจ.
- ํจ์์ด๋ฆ: ๋ณ์๋ฅผ ์ง์ ํ๋ ๋ฐฉ์๊ณผ ๋น์ทํ๋ค
- ์๋ฌธ์ ์ ๋ ฅ
- ๋์ด์ฐ๊ธฐ์ ๊ฒฝ์ฐ ‘_’ ์ฌ์ฉ ex) save_model
- ๋์ฌ์ ๋ช ์ฌ๋ฅผ ํจ๊ป ์ฌ์ฉํ๋ ๊ฒฝ์ฐ๋ ๋ง์ ex) find_number
- ์งง๊ณ ๋ช ๋ฃํ ์ด๋ฆ
- ๋งค๊ฐ๋ณ์(parameter): ํจ์์์ ์ ๋ ฅ๊ฐ์ผ๋ก ์ฌ์ฉํ๋ ๋ณ์. 1๊ฐ ์ด์์ ๊ฐ์ ์ ์ ์ ์์.
- ๋ช ๋ น๋ฌธ: ๋ฐ๋์ ๋ค์ฌ์ฐ๊ธฐ ํ ํ ์ ๋ ฅ ํ์. if๋ for๋ฌธ ๋ฑ์ ์ ์ด๋ฌธ ์ฌ์ฉ ๊ฐ๋ฅ
- example
def calculate_rectangle_area(x,y)
return x*y
1) ํจ์์ด๋ฆ: calculate_rectangle_area
2) ๋งค๊ฐ๋ณ์: x, y
3) return: ๊ฐ์ ๋ฐํ = x์ y๋ฅผ ๊ณฑํ ๊ฐ
- ํจ์์ด๋ฆ
- ๋ด์ฉ์ ๊ฐ๋ฅํ๋ฉด ์งง๊ฒ
- ์ด๋ฆ์ ํจ์์ ์ญํ ๊ณผ ์๋๋ฅผ ๋ช ํํ
- ์ญํ
- ํ๋์ ํจ์์๋ ์ ์ฌํ ์ญํ ์ ํ๋ ์ฝ๋๋ง ํฌํจ
- ์ต์ํ์ ์ญํ ๋ง ์ํํ ์ ์๋๋ก ์์ฑ
- ํจ์๊ฐ ํ์ํ ๊ฒฝ์ฐ
- ๊ณตํต์ผ๋ก ์ฌ์ฉ๋๋ ์ฝ๋๋ฅผ ํจ์๋ก ๋ณํ
- ๋ณต์กํ ๋ก์ง์ด ์ฌ์ฉ๋์์ ๋ ์๋ณ ๊ฐ๋ฅํ ์ด๋ฆ์ ํจ์๋ก ๋ณํ
- ๋ณต์กํ ์กฐ๊ฑด์ด๋ ์์์ ์ฌ์ฉํ ๋
- ์คํ์์
def calculate_rectangle_area(x,y)
return x*y
rectangle_x = 10
rectangle_y = 20
print("์ฌ๊ฐํ x์ ๊ธธ์ด:", rectangle_x)
print("์ฌ๊ฐํ y์ ๊ธธ์ด:", rectangle_y)
#๋์ด๋ฅผ ๊ตฌํ๋ ํจ์ ํธ์ถ
print("์ฌ๊ฐํ์ ๋์ด:", calculate_rectangle_area(rectangle_x, rectangle_y))
<์ฝ๋ ์ค๋ช >
1. ๋จผ์ ํจ์๊ฐ ์ ์๋ def ๋ถ๋ถ์ ์คํX. ๋ณ๋์ ์ถ๋ ฅ์ด ์ผ์ด๋์ง ์์.
2. ํจ์๊ฐ ์ํํด์ผ ํ๋ ๋ช ๋ น์ ์คํ. ์์์๋ถํฐ ์ฐจ๋ก๋๋ก print๋ฌธ์ ์ํํ ๋ค, return x*y์ ์ํด ๋ฐํ๊ฐ 200์ด ๋ฐํ๋จ.
3. calculate_rectangle_area(rectangle_x, rectangle_y)์ด 200์ผ๋ก ์นํ๋๊ณ , ์ด๋ฅผ ํ๋ฉด์ ์ถ๋ ฅํจ.
์ฉ์ด
- ๋งค๊ฐ๋ณ์(parameter)
: ์ ์ฝ๋์์ ๊ดํธ ์์ ๋ค์ด์๋ x, y ๋ฑ
- ํจ์์ ์ธํฐํ์ด์ค ์ ์์ ์์ด ์ด๋ค ๋ณ์๋ฅผ ์ฌ์ฉํ๋์ง ์ ์ํ๋ ๊ฒ
- ์ธ์(argument)
: ์ค์ ๋ณ์์ ๋์ ๋๋ ๊ฐ
โ ์ค์ ๋ก ๋งค๊ฐ๋ณ์์ ์ธ์๋ ๊ตฌ๋ถ ์์ด ์ฌ์ฉํ๋ ๊ฒฝ์ฐ๊ฐ ๋ง๊ณ , ๋ชจ๋ ํจ์์ ์ ๋ ฅ๊ฐ์ผ๋ก ๋ถ๋ฅด๊ธฐ๋ ํจ
ํจ์์ ํํ
๋งค๊ฐ๋ณ์ X | ๋งค๊ฐ๋ณ์ O | |
๋ฐํ๊ฐ X | ํจ์ ๋ด๋ถ ๋ช ๋ น๋ฌธ๋ง ์ํ | ๋งค๊ฐ๋ณ์๋ฅผ ์ฌ์ฉํด ๋ช ๋ น๋ฌธ๋ง ์ํ |
๋ฐํ๊ฐ O | ๋งค๊ฐ๋ณ์ ์์ด ๋ช ๋ น๋ฌธ ์ํ ํ, ๊ฒฐ๊ณผ๊ฐ ๋ฐํ | ๋งค๊ฐ๋ณ์๋ฅผ ์ฌ์ฉํด ๋ช ๋ น๋ฌธ์ ์ํ ํ, ๊ฒฐ๊ณผ๊ฐ ๋ฐํ |
#case1
def a_rectangle_area(): #๋งค๊ฐ๋ณ์x, ๋ฐํ๊ฐx
print(5 * 7)
a_rectangle_area()
#case2
def b_rectangle_area(x,y): #๋งค๊ฐ๋ณ์o, ๋ฐํ๊ฐx
print(5 * 7)
b_rectangle_area(5,7)
#case3
def c_rectangle_area(): #๋งค๊ฐ๋ณ์x, ๋ฐํ๊ฐo
return(5 * 7)
print(c_rectangle_area())
#case4
def d_rectangle_area(x,y): #๋งค๊ฐ๋ณ์o, ๋ฐํ๊ฐo
return(5 * 7)
print(d_rectangle_area(5,7))
- case1
- ์ ๋ ฅ๊ฐ, ๋ฐํ๊ฐ ๋ชจ๋ X
- print(5*7)๋ก ์ธํด 35 ์ถ๋ ฅ
- a_rectangle_area()๋ ๋ฐํ๊ฐ์ด ์์ผ๋ฏ๋ก ํจ์ ์์ฒด์ ๊ฐ์ none
- case2
- ๋งค๊ฐ๋ณ์๊ฐ ์กด์ฌํ๋ ๋ฐํ๊ฐ์ X
- b_rectangle_area(5, 7) ์์ฒด๊ฐ 35๋ก ์นํ๋๋ ๊ฒ์ ์๋!
- ๋ฐํ์ด ์๋ค๋ฉด ํด๋น ํจ์๋ none์ผ๋ก ์นํ
- case3, case4
- ๋ฐํ๊ฐ์ด ์์
- ๋ ํจ์ ๋ชจ๋ return๋ฌธ์ผ๋ก ์ธํด 35๋ก ์นํ๋จ
- ํจ์์ ๋ฐํ๊ฐ์ด ์๋ ๊ฒฝ์ฐ, ํจ์๋ฅผ ํธ์ถํ๋ ๊ณณ์์ ํจ์์ ๋ฐํ๊ฐ์ ๋ณ์์ ํ ๋นํ์ฌ ์ฌ์ฉํ๋ ๊ฒ์ด ๊ฐ๋ฅ
2. ํจ์ - ์ฌํ
ํธ์ถ๋ฐฉ์
def f(x):
y=x
x=5
return y*y
x=3
print(f(x))
print(x)
- ๊ฐ์ ์ํ ํธ์ถ call by value
- ํจ์์ ์ธ์๋ฅผ ๋๊ธธ ๋ ๊ฐ๋ง ๋๊น
- ํจ์ ๋ด๋ถ์ ์ธ์๊ฐ ๋ณ๊ฒฝ ์ ํธ์ถ๋ ๋ณ์์ ์ํฅ X
- ์ฐธ์กฐ ํธ์ถ call by reference
- ํจ์์ ์ธ์๋ฅผ ๋๊ธธ ๋ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๋ฅผ ๋๊น
- ๋ณ์๊ฐ ์ ์ฅ๋๋ ๊ณต๊ฐ ์์ฒด์ ์๋ก์ด ๊ฐ์ ํ ๋นํ๋ฉด ๊ทธ ๊ณต๊ฐ์ ๊ฐ๋ฆฌํค๊ณ ์๋ ๋ค๋ฅธ ๋ณ์์๋ ์ํฅ์ ์ค
- ํจ์ ๋ด๋ถ์ ์ธ์๊ฐ ๋ณ๊ฒฝ ์ ํธ์ถ๋ ๋ณ์๊ฐ๋ ๋ณ๊ฒฝ
- ํจ์์ ์ธ์๋ฅผ ๋๊ธธ ๋ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๋ฅผ ๋๊น
ํ์ด์ฌ: ๊ฐ์ฒด ํธ์ถ call by object reference
- ๊ฐ์ฒด์ ์ฃผ์๋ฅผ ํจ์๋ก ๋๊ธฐ๊ธฐ ๋๋ฌธ์ ์ ๋ฌ๋ ๊ฐ์ฒด์ 1) ์๋ก์ด ๊ฐ์ ํ ๋นํ๊ฑฐ๋ 2) ํด๋น ๊ฐ์ฒด๋ฅผ ์ง์ธ ๋๋ ์ํฅ์ ์ฃผ์ง ์์
- But, ๋จ์ํ ํด๋น ๊ฐ์ฒด์ ๊ฐ์ ์ถ๊ฐํ ๋๋ ์ํฅ์ ์ค
def spam(eggs):
eggs.append(1) #๊ธฐ์กด ๊ฐ์ฒด์ ์ฃผ์๊ฐ์ [1] ์ถ๊ฐ
eggs = [2,3] #์๋ก์ด ๊ฐ์ฒด ์์ฑ
ham = [0]
spam(ham)
print(ham)
- ๋จผ์ ham์ด๋ผ๋ ๋ฆฌ์คํธ๋ฅผ ๋ง๋ค๊ณ , ํจ์ spam์ ham์ ์ธ์๋ก ์ ๋ ฅ
- ํจ์ ์์์ ์ด๋ฆ์ eggs (์ด๋, ham๊ณผ eggs๋ ๊ฐ์ฒด ํธ์ถ ๋ฐฉ์์ ์ํด ๊ฐ์ ์ฃผ์๋ฅผ ๊ณต์ )
- eggs.append(1)์์๋ ham, eggs ๋ชจ๋ ์ํฅ์ ๋ฐ์
- eggs=[2,3]์ ํตํด ๋ ์ด์ ham๊ณผ eggs๋ ๊ฐ์ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๋ฅผ ๊ฐ๋ฆฌํค์ง ์์
- ๊ทธ๋ฆฌ๊ณ ํจ์๋ฅผ ๋น ์ ธ๋์ print(ham) ์คํ์ ์ถ๊ฐ๋ [0,1]์ ์ถ๋ ฅ
- ์๋ก์ด ๊ฐ์ ํ ๋นํ๊ธฐ ์ ๊น์ง๋ ๊ธฐ์กด์ ๋์ด์จ ์ธ์ ๊ฐ์ฒด์ ์ฃผ์๊ฐ์ ๊ทธ๋๋ก ์ฌ์ฉํ๋ ๋ฐฉ์
๋ณ์ ์ฌ์ฉ๋ฒ์ scoping rule
DEF) ๋ณ์๊ฐ ์ฝ๋์์ ์ฌ์ฉ๋๋ ๋ฒ์
- ํจ์ ๋ด๋ถ์์ ์ฌ์ฉํ ๊ฒ์ธ์ง, ํ๋ก๊ทธ๋จ ์ ์ฒด์์ ์ฌ์ฉํ ๊ฒ์ธ์ง ๊ฒฐ์ ํ๋ ๊ฒ
def test(t):
print(x)
t=20 #์ง์ญ๋ณ์
print("In Function:", t)
x=10 #์ ์ญ๋ณ์
test(x)
print("In Main:", x)
print("In Main:", t)
*์คํํ์ ๊ฒฝ์ฐ print(”In Main:”, t)๋ ์ค๋ฅ ์ถ๋ ฅ. (๋ณ์ t๋ ํจ์ ๋ด๋ถ์์๋ง ์ฌ์ฉํ ์ ์๋ ์ง์ญ ๋ณ์.)
- ๊ณ ๋ คํด์ผ ํ ๋ณ์
- ์ง์ญ ๋ณ์ local variable: ํจ์ ๋ด๋ถ์์๋ง ์ฌ์ฉ
- ์ ์ญ ๋ณ์ global variable: ํ๋ก๊ทธ๋จ ์ ์ฒด์์ ์ฌ์ฉ
- ํจ์ ๋ด๋ถ์ ์ธ๋ถ์ ๋ณ์๊ฐ ๊ฐ์ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๋ฅผ ๊ฐ๋๋ก ํจ
- global ํค์๋๋ก ์ ์ธ
def f():
global s
s = "I love London!"
print(s)
s="I love Paris!"
f()
print(s)
- ์์ - ์ถ๋ ฅ ๊ฒฐ๊ณผ๋ฅผ ์์ธกํด๋ด ์๋ค
#Example1
def f():
s="I love London!"
print(s)
s="I love Paris!"
f()
print(s)
- ํจ์ ๋ด๋ถ์ ์ธ๋ถ์ ์๋ ๋ณ์ s๋ ์ด๋ฆ์ด ๊ฐ์ง๋ง ๋ค๋ฅธ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๋ฅผ ๊ฐ๊ณ ์๋ ์ ํ ๋ค๋ฅธ ๋ณ์
- ํจ์ ๋ด๋ถ์ s๋ ํด๋น ํจ์๊ฐ ์คํ๋๋ ๋์์๋ง ๋ฉ๋ชจ๋ฆฌ์ ์๋ค๊ฐ ํจ์๊ฐ ์ข ๋ฃ๋๋ฉด ์ฌ๋ผ์ง.
#Example2
def calculate(x,y):
total=x+y #์๋ก์ด ๊ฐ ํ ๋น์ผ๋ก ํจ์ ๋ด๋ถ total์ ์ง์ญ ๋ณ์
print("In Function")
print("a:",str(a),"b:",str(b),"a+b:",str(a+b),"total:",str(total))
return total
a=5 #a,b๋ ์ ์ญ ๋ณ์
b=7
total=0 #์ ์ญ ๋ณ์ total
print("In Program-1")
print("a:",str(a),"b:",str(b),"a+b:",str(a+b))
sum=calculate(a,b)
print("After Calculation")
print("Total:", str(total), "Sum:", str(sum)) #์ง์ญ ๋ณ์๋ ์ ์ญ ๋ณ์์ ์ํฅ ์ฃผ์ง ์์
#์ถ๋ ฅ๊ฒฐ๊ณผ
In Program-1
a:5 b:7 a+b:12 total:12
After Calculation
Total:0 Sum:12
์ฌ๊ทํจ์ recursive function
DEF) ์๊ธฐ ์์ ์ ๋ค์ ํธ์ถํ๋ ํจ์
- ์์ ์ ์ด์ฉํด ๋ค๋ฅธ ๊ฒ์ ์ ์ํ๋ค๋ ์๋ฏธ
- ์) ์ ํ์_ํฉํ ๋ฆฌ์ผfactorial ํจ์
def factorial(n):
if n==1:
return 1
else:
return n * factorial(n-1)
print(factorial(int(input("Input Number for Factorial Calculation: "))))
#์ถ๋ ฅ๊ฒฐ๊ณผ
Input Number for Factorial Calculation: 5
120
- ๊ธฐ๋ณธ ๊ตฌ์กฐ๊ฐ ์ข ๋ฃ ์กฐ๊ฑด, ๋จ๊ณ๋ณ ๋ฐํ์ผ๋ก ๊ตฌ์ฑ๋์ด ์์ผ๋ฏ๋ก ํฌ๊ฒ ๋ณ๊ฒฝ ์์ด๋ ์ฌ์ฉํ ์ ์์
3. ์ธ์ argument
์ธ์ ์ฌ์ฉ๋ฒ
์ข ๋ฅ ๋ด์ฉ
์ข ๋ฅ | ๋ด์ฉ |
ํค์๋ ์ธ์ | ํจ์์ ์ธํฐํ์ด์ค์์ ์ง์ ํ ๋ณ์๋ช ์ ์ฌ์ฉํด ํจ์์ ์ธ์๋ฅผ ์ง์ ํ๋ ๋ฐฉ๋ฒ |
๋ํดํธ ์ธ์ | ๋ณ๋์ ์ธ์๊ฐ์ด ์ ๋ ฅ๋์ง ์์ ๋ ์ธํฐํ์ด์ค ์ ์ธ์์ ์ง์ ํ ์ด๊น๊ฐ์ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ |
๊ฐ๋ณ ์ธ์ | ํจ์์ ์ธํฐํ์ด์ค์์ ์ง์ ํ ๋ณ์ ์ด์ธ์ ์ถ๊ฐ ๋ณ์๋ฅผ ํจ์์ ์ ๋ ฅํ ์ ์๋๋ก ์ง์ํ๋ ๋ฐฉ๋ฒ |
ํค์๋ ๊ฐ๋ณ ์ธ์ | ๋งค๊ฐ๋ณ์์ ์ด๋ฆ์ ๋ฐ๋ก ์ง์ ํ์ง ์๊ณ ์ ๋ ฅํ๋ ๋ฐฉ๋ฒ |
ํค์๋ ์ธ์ keyword arguments
DEF) ํจ์์ ์ ๋ ฅ๋๋ ๋งค๊ฐ๋ณ์์ ๋ณ์๋ช ์ ์ฌ์ฉํด ํจ์์ ์ธ์๋ฅผ ์ง์ ํ๋ ๋ฐฉ๋ฒ
def print_something(my_name, your_name):
print("hello {0}, my name is {1}".format(your_name, my_name))
print_something("Sungchul", "TEAMLAB")
print_something(your_name="TEAMLAB", my_name="Sungchul")
*์ถ๋ ฅ ๊ฒฐ๊ณผ๋ ๋์ผ
- ์ ๋ ฅ๋๋ ์์์ ์๊ด์์ด ํจ์์ ์ ๋ ฅ ๋ณ์๋ช ๋ง ์ ํํ ๊ธฐ์ฌ๋๋ค๋ฉด, ์ํ๋ ๋ณ์์ ์ธ์๋ฅผ ๋ฃ์ ์ ์์
๋ํดํธ ์ธ์ default arguments
DEF) ๋งค๊ฐ๋ณ์์ ๊ธฐ๋ณธ๊ฐ์ ์ง์ ํ์ฌ ์ฌ์ฉํ๊ณ , ์๋ฌด ๊ฐ๋ ์ธ์๋ก ๋์ด๊ฐ์ง ์์ ๋ ์ง์ ๋ ๊ธฐ๋ณธ๊ฐ์ ์ฌ์ฉํ๋ ๋ฐฉ์
def print_something_2(my_name, your_name="TEAMLAB"):
print("hello {0}, my name is {1}".format(your_name, my_name))
print_something_2("Sungchul", "TEAMLAB")
print_something_2("Sungchul")
*์ถ๋ ฅ ๊ฒฐ๊ณผ๋ ๋์ผ
- your_name ๋งค๊ฐ๋ณ์์ ๊ธฐ๋ณธ๊ฐ์ผ๋ก ‘TEAMLAB’์ด ์ง์ ๋จ
- ๋ณ๋์ ๊ฐ์ ํ ๋นํ์ง ์์๋ ์๋
๊ฐ๋ณ ์ธ์ variable-length arguments
DEF) ๋งค๊ฐ๋ณ์๋ฅผ ์ ํ์ง ์๊ณ ์ฌ์ฉํ๋ ๋ฐฉ์
โ ์
- ํญ์ ๊ฐ์๊ฐ ์ ํด์ง์ง ์์ ๋คํญ๋ฐฉ์ ์์ ๋ง์ ์ฐ์ฐ
- ๋งํธ ๊ณ์ฐ๊ธฐ์์ ํฉ์ฐ์ ์ํํ๋ ์ฐ์ฐ
- *(asterisk)๋ก ํํ
- ๊ณฑ์ ๋๋ ์ ๊ณฑ ์ฐ์ฐ ์ธ์๋ ๋ณ์๋ฅผ ๋ฌถ์ด์ฃผ๋ ๊ฐ๋ณ ์ธ์๋ฅผ ๋ง๋ค ๋ ์ฌ์ฉ
def asterisk_test(a,b,*args):
return a+b+sum(args)
print(asterisk_test(1,2,3,4,5))
15 #์คํ๊ฒฐ๊ณผ
*๋ณ์ a, b๋ฅผ ๋๊ฒจ๋ฐ๊ณ ๋๋จธ์ง๋ฅผ *args๋ก ๋๊ฒจ๋ฐ์
- *args = ๊ฐ๋ณ ์ธ์
- ์ถ๋ ฅ ์, ๊ดํธ๋ก ๋ฌถ์ฌ ์ถ๋ ฅ๋๋ ํํtuple ์๋ฃํ์
- ๋ณ์์ ์ด๋ฆ์ ์ง์ ํ ์ ์๋ค๋ ๋จ์
- ๋ฐ๋์ ์ผ๋ฐ์ ์ธ ํค์๋ ์ธ์์ ๋ํ ์ ์ธ์ด ๋ชจ๋ ๋๋ ํ ๋ง์ง๋ง์ ์ ์ธ๋์ด์ผ ํจ
def asterisk_test_2(*args):
x,y,*z=args
return x,y,z
print(asterisk_test_2(3,4,5,10,20))
(3,4,[5,10,20]) #์คํ๊ฒฐ๊ณผ
- ์ธํจํน๊ณผ ๋์ผํ ๊ฐ๋ ์ด๋ฏ๋ก ์ธํจํน ๊ฐ์ ๋ํ ๋ง์ถฐ์ผ ํจ
ํค์๋ ๊ฐ๋ณ ์ธ์ keyword variable-length arguments
DEF) ๋งค๊ฐ๋ณ์์ ์ด๋ฆ์ ๋ฐ๋ก ์ง์ ํ์ง ์๊ณ ์ ๋ ฅํ๋ ๋ฐฉ๋ฒ
- *๋ฅผ 2๊ฐ ์ฌ์ฉ, ๋ณ์๋ช kwargs
- ๋์
๋๋ฆฌ ์๋ฃํdictionary type์ผ๋ก ์ฌ์ฉ
- ๋ณ์๋ช ๊ณผ ๊ฐ์ ์์ผ๋ก ์ ์ฅํ๋ ๋ฐฉ์
- ๋ชจ๋ ๋งค๊ฐ๋ณ์์ ๋งจ ๋ง์ง๋ง, ์ฆ ๊ฐ๋ณ ์ธ์ ๋ค์์ ์ ์ธ
def kwargs_test(**kwargs):
print(kwargs)
print("First value is {first}".format(**kwargs))
print("Second value is {second}".format(**kwargs))
print("Third value is {third}".format(**kwargs))
kwargs_test(first=3, second=4, third=5)
#์ถ๋ ฅ๊ฒฐ๊ณผ
{'first':3, 'second':4, 'third':5}
Fist value is 3
Second value is 4
Third value is 5
'๐ ์คํฐ๋ > ํ์ด์ฌ ์คํฐ๋ ๊ฐ์์๋ฃ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[4ํ/๊น๋ฏผํ] 6์ฐจ์ ํ์ด์ฌ ์คํฐ๋ - ๋ฌธ์์ด (0) | 2023.04.28 |
---|---|
[4ํ/์ด์ ์] 6์ฐจ์ ํ์ด์ฌ ์คํฐ๋ - ๋ฌธ์์ด (0) | 2023.04.28 |
[1ํ/ํ์์] 5์ฐจ์ ํ์ด์ฌ ์คํฐ๋ - ํจ์ (0) | 2023.04.06 |
[4ํ/์ด์ ์] 5์ฐจ์ ํ์ด์ฌ ์คํฐ๋ - ํจ์ (0) | 2023.04.06 |
[1ํ/์ง๋ค์ธ] 5์ฐจ์ ํ์ด์ฌ ์คํฐ๋ - ํจ์ (0) | 2023.04.06 |