[python]파이썬 - 함수function

함수(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

 

12.905640455070625

 

 

 

num_list = [180,195,164,155,170]

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

 

13.760813929415658

 

함수 정의 방법

def <function_name>(parameter1,parameter2, ...):
    code context

 

 

 

def get_std(num_list):
    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)
    return var ** 0.5

 

 

 

num_list = [29,34,435,23]
get_std(num_list)

 

175.99058923703848

 

 

get_std(num_list,num_list)

 

 

 

함수를 정의할때 형태는 4가지가 있다.

 

• 파라미터 X , 리턴 X

 

 

 

def do_func_type1():
    print("파라미터X, 리턴 X")
do_func_type1()

 

파라미터X, 리턴 X

 

 

 

a = print(1,2,3)
print(a)

 

None

 

• 파라미터 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

 

함수를 정의할때 명명 규칙에 대한 관례

• 함수이름은 동사로 시작하며, 어떠한 기능을 추측할수 있게한다.
• 함수이름은 소문자로 작성하며, snake case 따른다.(ex. add_number)

 

리스트를 아규먼트(인자)로 받아서 짝수만 출력하는 함수를 만들어 보세요.

 

 

 

def print_even(lst):
    for i in lst:
        if i % 2 == 0:
            print(i)

 

 

 

lst = [10,20,1,2,3]
print_even(lst)

 

10
20
2

 

두개의 숫자를 인자로 받고, 세번째 인자로 plus,minus,multiply, divide 중에 입력을 받아 
덧셈 , 뺄셈, 곱하기 ,나누기 중에 결과를 반환하는 함수를 만듭시다. 

 

 

 

def calculate(n1,n2,act):
    if act == "plus":
        result = n1 + n2
    elif act == "minus":
        result = n1 - n2
    elif act == "multiply":
        result = n1 * n2
    else:
        result = n1 / n2 if n2 else 0
    return result
calculate(10,0,"divide")

 

0

 

• 이메일이 담긴 리스트를 인자로 받아 아이디만 추출해서 다시 새로운 리스트에 담아 해당 리스트를 반환하는 함수를 만들어주세요.

  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"]

def email2id(email_list):
    tmp = []
    for email in email_list:
        email = email.split("@")[0]
        tmp.append(email)
    return tmp

 

 

 

 

def email2id(email_list):
    return [email.split("@")[0] for email in email_list ]
email2id(email_list)

 

['user1004', 'user22', 'user30', 'user100']

 

리스트를 인자로 받아 Min-Max Scaling 적용하여 리스트로 반환하는 함수를 만드시오.

 

x−Min(X)Max(X)−Min(X)

 

 

def scale_minmax(lst):
    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

 

 

 

 

def scale_minmax(lst):
    min_value = min(lst)
    size_value =  max(lst) - min_value
    return [(i - min_value) / size_value for i in lst]

 

 

 

 

lst = [490,50,23,434]
scale_minmax(lst)

 

[1.0, 0.057815845824411134, 0.0, 0.880085653104925]

 

리스트를 인자로 받아 평균을 구하는 함수와 표준편차를 구하는 함수를 각각 구현하세요.

 

μ=1N∑i=1Nxi

 

σ2=1N∑i=1N(xi−μ)2

 

 

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 

 

 

 

 

get_avg(score1) , get_std(score1)

 

(80.66666666666667, 15.520595635763755)

 

 

 

get_avg(score2) , get_std(score2)

 

(80.33333333333333, 8.178562764256865)

 

변수의 사용범위(Scope)

• 지역변수(local): 함수 내부에서 만들어진 지역변수는 함수 내에서만 사용가능(파라미터 포함)
• 전역변수(global): 함수 밖에서 만들어진 변수(어디서든 사용 가능)
• 파이썬의 제어문은 해당 안된다. 제어문의 변수는 전역변수이다.

 

 

 

# bad
gv = 10

def do_func():
    print(gv)

do_func()

 

10

 

 

 

gv = 10

def do_func():
    gv = 100
    print(gv)
do_func()

 

100

 

 

gv

 

10

 

 

 

def do_func():
    loc = 10
    print(loc)

do_func()

 

10

 

 

 

# bad
def do_func():
    global loc 
    loc = 100
do_func()

 

 

print(loc)

 

100

 

* 결론은 함수내에서 변수를 사용할때는 파라미터를 정의해서 인자를 받거나 지역변수를 선언해서 사용하세요. *

 

얕은 복사 vs 깊은 복사

 

 

 

data = [
    [None,2,3],
    [4,5,6]
]

 

 

 

def do_func(lst):
    lst[0][0] = 100
    return lst

 

 

 

fill_data = do_func(data[:])
fill_data

 

[[100, 2, 3], [4, 5, 6]]

 

 

data

 

[[100, 2, 3], [4, 5, 6]]

 

 

a = [1,2,3]
b = a
b.append(5)
print(a)
print(b)

 

[1, 2, 3, 5]
[1, 2, 3, 5]

 

 

 

 

a = [1,2,3]
b = a[:]

b.append(5)
print(a)
print(b)

 

[1, 2, 3]
[1, 2, 3, 5]

 

 

 

 

a = [1,2,[3,4]]
b = 2

b[2].append(5) # [3,4]

print(a)
print(b)

 

[1, 2, [3, 4, 5]]
[1, 2, [3, 4, 5]]

 

 

 

import copy

a = [1,2,[3,4]]
b = copy.deepcopy(a)

b[2].append(5)
print(a)
print(b)

def do_func(a):
    copy()
    a.append(2)

 

[1, 2, [3, 4]]
[1, 2, [3, 4, 5]]

 

 

키워드 아규먼트

 

 

 

def do_func(a,b,c):
    print(a,b,c)

do_func(1,2,3) # positional argument

 

1 2 3

 

 

do_func(a=1,b=2,c=3)

 

1 2 3

 

 

 

do_func(b=2,a=1,c=3)

 

1 2 3

 

파라미터를 정의하는 방식

 

디폴트(default) 파라미터

• 아규먼트를 넣어주지 않을때 파라미터에 지정된 초깃값을 사용한다.

 

 

print?

 

 

 

print(1,2,3,sep="/")

 

1/2/3

 

 

def do_func(a="hello",b=2,c=1):
    print(a,b,c)
do_func()

 

hello 2 1

 

• 디폴트 파라미터는 일반 파라미터 뒤에 넣어줘야한다.

 

 

 

def do_func(a,b=1,c):
    print(a,b,c)

 

 

 

행과 열로 구성되어 있는 리스트를 인자로 받고
추가로 열을 선택할수 있는 정수를 인자로 받아 
열부분 리스트로 반환하는 함수를 만드세요.

lst = [
    [1,2,3],
    [4,5,6],
    [7,8,9]
]

def get_column(lst,i=0):
    code context


get_column(lst)

Output:
[2,5,8]

 

 

lst = [
    [1,2,3],
    [4,5,6],
    [7,8,9]
]

def get_column(lst,i=0):
    return [ n[i] for n in lst]

 

 

 

 

def get_column(lst,i=0):
    tmp = []
    for n in lst:
        tmp.append(n[i])
    return tmp

get_column(lst)

 

[1, 4, 7]

 

가변 파라미터

• 함수를 정의하면서 아규먼트가 n개 이상이 들어 올수 있다면 가변파라미터를 정의해주면 된다.(0개 포함)
• * 를 이용해서 파라미터명을 정의해주면 된다.
• 일반적으로 *args 표현
• 함수내부에서는 튜플 묶인다.

 

 

 

print(1,2,3,4,54,56)

 

1 2 3 4 54 56

 

 

 

def do_func(*args): # packing 
    print(args)
    print(sum(args))
    print(list(args))

do_func(1,2,3,4,4,5)

 

(1, 2, 3, 4, 4, 5)
19
[1, 2, 3, 4, 4, 5]

 

 

do_func()

 

()
0
[]

 

 

 

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

 

 

 

do_func(1,2,3,4,5,6,7,b=200)

 

1
(2, 3, 4, 5, 6, 7)
200

 

 

 

def do_func(*args):
    print(args)

 

 

 

 

tup = (1,2,3,4,5,6,7)
do_func(*tup) # do_func(1, 2, 3, 4, 5, 6, 7)

 

(1, 2, 3, 4, 5, 6, 7)

 

 

 

lst = [1,2,3,4,5,6]
do_func(*lst)

 

(1, 2, 3, 4, 5, 6)

 

• packing , unpacking
  • packing :하나의 변수에 여러 객체를 묶어서 담는 방식
  • unpacking : 묶여 있는 여러객체를 여러변수에 풀어서 담는 방식

 

 

 

list1 = [1,2,3]
list2 = [4,5,6]

for item1,item2 in zip(list1,list2):
    print(item1,item2)

 

1 4
2 5
3 6

 

 

for item in zip(list1,list2):
    print(item)

 

(1, 4)
(2, 5)
(3, 6)

 

 

 

a,b = [1,2]
print(a)
print(b)

 

1
2

 

키워드 가변 파라미터

• 함수를 정의하면서 키워드 아규먼트가 n개이상 들어 올수 있다(0개 포함)
• 일반적으로 **kwargs 로 표현
• 함수내부에 딕셔너리 형태로 묶인다.
• 키워드 아규먼트에서 키워드가 key 값이 되고, 아규먼트가 value 된다.

 

 

 

def do_func(a,b,**kwargs):
    print(a)
    print(b)
    print(kwargs)

 

 

 

do_func(10,20,c=30,name="관수",age=40)

 

10
20
{'c': 30, 'name': '관수', 'age': 40}

 

 

kwargs_dict = {
    "c" : 30,
    "name":"관수",
    "age" : 42
}

do_func(20,30,**kwargs_dict) # c=30,name="관수",age=42

 

20
30
{'c': 30, 'name': '관수', 'age': 42}

 

 

 

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

 

print 함수의 sep , end 를 dict 정의해서 언패킹하여 넣어보세요.
출력결과는 다음과 같습니다..

Output:
파이썬#자바!

 

 

 

 

dict_args = {
    "sep" : "#",
    "end" : "!"
}
print("파이썬","자바", **dict_args  )

 

파이썬#자바!

 

• 여러 종류의 파라미터를 정의할때 순서

 

 

 

def do_func(postional_param,default_param="default_value", *args,**kwargs):
    pass

 

 

 

for i in range(10):
    pass

 

 

다음의 리스트에서 최대값이 위치한 인덱스를 반환하는 함수와
최소값이 위치한 인덱스를 반환하는 함수를 작성하세요.
data = [80,70,60,99,87,86]

def argmax(lst):
    code context

def argmin(lst):
    code context

 

 

 

data = [80,70,60,99,87,86]
def argmax(lst):
    return lst.index(max(lst))
def argmin(lst):
    return lst.index(min(lst))

print(argmax(data))
print(argmin(data))

 

 

 

start , end 값을 입력 받아 리스트를 반환하는 함수를 생성하시오.

ex)
arange(1,5) -> [1,2,3,4]
arange(5) -> [0,1,2,3,4]  # end값 생략된경우

 

 

 

def arange(start,end = None):
    if end is None:
        result = list(range(start))
    else:
        result = list(range(start,end))
    return result

print(arange(10))
print(arange(2,10))
print(arange(-10,2))
print(arange(4,0))

 

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[2, 3, 4, 5, 6, 7, 8, 9]
[-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1]
[]

 

 

# bad
def arange(*args):
    if len(args) == 1:
        result = list(range(args[0]))
    else:
        result = list(range(args[0],args[1]))
    return result

 

 

정수 혹은 튜플을 입력받아 0으로만 채워진 행렬 형태의 리스트를 반환하는 함수를 작성하시오.

ex)
zeros(3) -> [0,0,0]
zeros((2,3)) -> [[0,0,0], [0,0,0]]

[
    [0,0,0],
    [0,0,0]
]

 

 

 

 

def zeros(shape):
    if type(shape) is int:
        result = [0] * shape
    else:
        result = [ [0] * shape[1] for i in range(shape[0])]
    return result
print(zeros(5))
print(zeros([2,3]))
print(zeros([6,1]))
[0, 0, 0, 0, 0]
[[0, 0, 0], [0, 0, 0]]
[[0], [0], [0], [0], [0], [0]]

 

 

 

 

[0] * 3
[0, 0, 0]

 

 

(0) # 튜플이 아니다.
0

 

 

 

 

# 튜플은 , dlTdjdigka
(0,)
(0,)