python-함수

양승천·2022년 11월 28일
0

python

목록 보기
4/5

함수(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가지가 있다.

  • 파라미터 x, 리턴x
def do_func_Type1():
    print("v파라미터x, 리턴x")
do_func_Type1()
  • 파라미터 o,리턴x
def do_func_Type2(num1,num2):
    if num1>num2:
        print("BIG")
    else:
        print("SMALL")
do_func_Type2(2,3)

SMALL
  • 파라미터x, 리턴o
def do_func_Type3():
    lst = list(range(1,101,2))
    return sum(lst)
do_func_Type3()

2500
  • 파라미터 O, 리턴O
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)

  • 한줄짜리 간단한 함수를 만들 때 사용
  • ex
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)
profile
되고싶다 직무전환 성공하자!

0개의 댓글