함수(Function)
- 코드의 반복을 줄이거나 어떠한 용도를 위해 코드를 모아둔 것
- 어떠한 결과를 만들어내는 코드의 집합
- (재사용할)코드 묶음
num_list =[80,90,77,60,55,86] # 몸무게 열
avg = sum(num_list) / len(num_list)
deviation_list =[] # 편차를 담을 리스트
for num in num_list:
deviation = avg = num
deviation_list.append(deviation**2)
var = sum (deviation_list) / len(deviation_list)
var ** 0.5
75.77378614446204
함수 정의 방법
def <funtion_name>(parameter1,parameter2, ...):
code context
def get_std(num_list):
avg = sum(num_list1) / len(num_list1) # 평균
deviation_list =[ ] # 편차를 담을 리스트
for num in num_list1:
deviation = avg - num
deviation_list.append(deviation**2)
var = sum(deviation_list) / len(deviation_list)
return var ** 0.5
num_list = [29,34,435,23]
get_std(num_list)
13.760813929415658
함수를 정의할 때의 형태는 4가지가 있다.
def do_func_Type1():
print("v파라미터x, 리턴x")
do_func_Type1()
def do_func_Type2(num1,num2):
if num1>num2:
print("BIG")
else:
print("SMALL")
do_func_Type2(2,3)
SMALL
def do_func_Type3():
lst = list(range(1,101,2))
return sum(lst)
do_func_Type3()
2500
def do_func_type4(num1,num2):
return num1+num2
do_func_type4(10,20)
30
함수를 정의할때 명명 규칙에 대한 관례
- 함수 이름은 동사로 시작하며, 어떠한 기능을 추측할 수 있게 한다.
-함수 이름은 소문자로 작성하며, snak cass 따른다, ex) add_number
- 리스트를 아규먼트(인자)입력 받아서 짝수만 출력하는 함수를 만들어 보세요.
lst = [1,2,3,4,5,6,7,8,9,10,11]
for i in lst:
if i % 2 == 0:
print(i)
1
2
3
4
5
6
7
8
9
10
11
def get_std(lst):
for i in lst:
if i % 2 == 0:
print(i)
lst = [1,2,3,4,5,6,7,8,9,10,11]
get_std(lst)
2
4
6
8
10
- 이메일이 담긴 리스트를 인자로 받아 아이디만 추출해서 다시 새로운리스트에 담아 추출하는 함수
email_list = ["user1004@gmail.com","user22@naver.com","user30@gmail.com","user100@hanmail.net"]
email_list = ["user1004@gmail.com","user22@naver.com","user30@gmail.com","user100@hanmail.net"]
tmp = []
for email in email_list:
email = email.split("@")[0]
tmp.append(email)
tmp
['user1004', 'user22', 'user30', 'user100']
def emailid():
return [email.split("@")[0] for email in email_list]
emailid(email_list)
- 리스트를 인자로 받아 min-max scaling 적용하여 리스트로 변환하는 함수를 만드시오.
def sm(lst):
#lst = [3000, 3500, 4000, 9000, 8000, 12000]
min_value = min(lst)
size_value = max(lst) - min_value
tmp = []
for i in lst:
x = (i - min_value) / size_value
tmp.append(x)
return tmp
lst = [3000, 3500, 4000, 9000, 8000, 12000]
sm(lst)
[0.0,
0.05555555555555555,
0.1111111111111111,
0.6666666666666666,
0.5555555555555556,
1.0]
- 평균을 구하는 함수와 표준편차를 구하는 함수를 가각 구현하세요
def get_std(num_list):
avg = sum(num_list1) / len(num_list1) # 평균
deviation_list =[] # 편차를 담을 리스트
for num in num_list1:
deviation = avg = num
deviation_list.append(deviation**2)
var = sum (deviation_list) / len(deviation_list)
return var ** 0.5
def get_std(num_list):
avg = sum(num_list1) / len(num_list1) # 평균
for num in num_list1:
deviation = avg = num
return avg
num_list =[90,150,340,50,30,60]
get_std(num_list)
170
def get_std(num_list):
# 평균
deviation_list =[] # 편차를 담을 리스트
for num in num_list1:
deviation = avg = num
deviation_list.append(deviation**2)
std = sum (num_list) / len(num_list)
return var ** 0.5
num_list =[90,150,340,50,30,60]
get_std(num_list)
173.34705073926122
score1 = [100, 80, 62]
score2 = [90,81,70]
def get_avg(lst): # 평균
avg = sum(lst) / len(lst)
return avg
def get_std(lst): # 편차
avg = get_avg(lst)
diff_list = [ (avg - i) ** 2 for i in lst]
var = sum(diff_list) / len(diff_list)
return var ** 0.5
변수의 사용범위(Scope)
- 지역변수(local): 함수 내부에서 만들어진 지역변수는 함수 내에서만 사용가능(파라미터 포함)
- 전역변수(global): 함수 밖에서 만들어진 변수(어디서든 사용 가능)
- 파이썬의 제어문은 해당 안된다. 제어문의 변수는 전역변수이다.
gv = 10 # 안좋은 방법
def do_func():
print(gv)
do_func()
def do_func():# 안좋은 방법
global loc
loc = 100
do_func()
print(loc)
- 결론은 함수내에서 변수를 사용할때는 파라미터를 정의해서 인자를 받거나 자연수를 선언해서 사용
- 포지셔널 아규먼트
def do_func(a,b,c,): # 포지셔널 아규먼트(포지션 위치에 맞게 )
print(a,b,c)
do_func(1,2,3)
def do_func(a,b,c,): # 키워드 아규먼트(순서데로 넣지 않아도 됨 )
print(a,b,c)
do_func(a=1,b=2,c=3) # do_func(b=2,a=1,c=3)
- 디폴트(default) 파라미터
아규먼트를 넣어주지 않을때 파라미터에 지정된 초깃값을 사용한다.
def do_func(a,b,c=1):
print(a,b,c)
do_func("hellow",30)
- 가변 파라미터
*
이용해서 파라미터명 정의
일반적으로*args
로 사용
def do_func(*args): # packing
print(args)
print(sum(args))
print(len(args))
print(list(args))
do_func(1,2,3,4,5,6,)
def do_func(a,*args,b=100):
print(a)
print(args)
print(b)
do_func(1,2,3,4,5,6,7,200)
1
(2, 3, 4, 5, 6, 7, 200)
100
키워드 가변 파라미터
- 일반적으로
kwargs
로 표현
- 딕셔너리 형태로 묶임
def do_func(a,b,**kwargs):
print(a)
print(b)
print(kwargs)
do_func(10,20,c=30,name='승천',age=30)
10
20
{'c': 30, 'name': '승천', 'age': 30}
kwargs_dict = {
"c":30,
"name":"승천",
"age":30,
}
do_func(20,30,**kwargs_dict)
20
30
{'c': 30, 'name': '승천', 'age': 30}
def train_model(loss_fn,learning_rate,num_iterations):
print(loss_fn)
print(learning_rate)
print(num_iterations)
dict_args = {
"loss_fn":"mse",
"learning_rate": 0.001,
"num_iterations":100
}
train_model(**dict_args) # 딕셔너리를 언패킹하면 키워드 아규먼트 형식으로 풀린다.
mse
0.001
100
람다함수(lambda)
square = lambda x:x**2
square(5)
def get_max(lst):
result = max(lst)
return result
get_max = lambda lst:max(lst)
get_max([1,2,3])
3
def get_even(lst):
result = []
for n in lst:
if n % 2 == 0:
result.apped(n)
return result
get_even = lambda n:[ i for i in n if i % 2 == 0 ]
get_even(range(0,10))
[0, 2, 4, 6, 8]
콜백함수(call back function)
- 하수의 인자로 사용되는 함수를 말한다.
- 두수를 인자로 받아 더하는 함수와 빼는 함수를 만든다고 가정
- 두개의 함수 모두 실수가 들어올 경우 정수로 변경해야하는 공통 기능이 있어야 한다고 가정
- 실수를 정수로 변경하는 공통 기능은 어떠한 함수에 구현
- 어떠한 함수에 인자로 더하는 함수와 빼는 함수를 넣어서 더하는 처리와 빼는 처리를 한다면...
def convert_int(callback,a,b):
# 공통기능 부분
a = int(a)
b = int(b)
print(callback(a,b)) # 인자로 받은 콜백함수를 실행하여 결과값을 반환!
def add_func(num1,num2):
return num1+num2
def sub_func(num1,num2):
return num1-num2
convert_int(add_func,11.5,20.222)
31
None
convert_int(lambda a,b:a*b,10.11,3.0)
30
Decorator(장식하다, 꾸미다)
- 코드를 변경하지 않고 기능을 추가하거나 수정하고 싶을때 정의하는 표현식
- 내부함수의 주소를 리턴하는 클로져와 비슷하고 함수를 다른함수의 인자로 전달하는 방식과 비슷하다.
- 그냥 두가지 방식을 합쳤다고 보면 된다.
def decorator_func(org_func): #함수를 인자로 받는다.
def wrapper_func(): # 내부함수를 구현한다.
print("org_func 가 실행되기 전입니다.")
org_func() # org_func 함수를 진행
return wrapper_func #내부 함수의 주소를 반환
def do_func():
print("driginal 함수가 실행되었습니다.")
result = decorator_func(do_func) # 데코레이터 함수에 감싸고자하는 함수의 주소를 인자로 넣는다.
result() # wrapper_func() 코드 인자로 받은 함수가 실행
def decorator_func(org_func): #함수를 인자로 받는다.
def wrapper_func(): # 내부함수를 구현한다.
print("org_func 가 실행되기 전입니다.")
org_func() # org_func 함수를 진행
return wrapper_func #내부 함수의 주소를 반환
@decorator_func # == decorator_func(do_func)
def do_func():
print("driginal 함수가 실행되었습니다.")
do_func()
org_func 가 실행되기 전입니다.
driginal 함수가 실행되었습니다.
- 데코레이터로 감싸는 함수의 파라미터를 정의해야 한다면?
def decorator_func(org_func):
def wrapper_func(*args,**kwargs):
print(f'콜백함수가 실행되기 전입니다.')
result = org_func(*args,**kwargs)
print(f'콜백함수가 실행 완료 되었습니다.')
return result
return wrapper_func
@decorator_func
def do_func(a,b):
return a+b
do_func(3,5)
콜백함수가 실행되기 전입니다.
콜백함수가 실행 완료 되었습니다.
8
def shape(lst):
if len(lst) == 0:
result = 0,
elif type(lst) is list:
result = len(lst), len([0])
else:
result = len(lst),
return result
print(shape([0]))
print(shape([1,2,3]))
(1, 1)
(3, 1)