02-3. 함수

Function

- 특정 목적을 위해 작성한 코드(연산)의 집합
- 반복되는 코드를 묶음으로 효율적인 코드를 작성하도록 해주는 기능
- 독립적인 호출과 간결한 코드 작성을 위해 사용 : 코드 작성의 반복을 줄일 수 있음!

기본함수

- 함수의 선언과 호출

a = 0
number = [30,80,90,50,70,60]
for i in number:
    a += i
a

->380

a = 0
number = [80,90,60,70,80,60]
for i in number:
    a += i
a

->440
같은 연산의 코드 작성을 반복해서 써야하기 때문에 불편하고 힘듦

---

1.1.선언, 호출, return, *args, **kwagrs

1.1.1.선언

def 함수명(param1, param2, ...):
    # 작성하고 싶은 코드 구분
    # ...
    # ...
    return 결과값

# 함수 선언
def total(score):
    a = 0
    for i in score:
        a += i
    print(a)

number = [80,90,50,70,60]
total(number)

->350

number = [30,80,90,70,60]
total(number)

->330

1.1.2.호출

def 함수명(파라미터):
    return

함수명(아규먼트)

- 파라미터 : 함수를 선언할 때 호출하는 부분에서 보내주는 데이터를 받는 함수
- 아규먼트 : 함수를 호출할 때 함수에 보내주는 데이터
- 함수를 선언할 때 파라미터의 타입과 갯수를 맞추지 않으면 에러 발생

def plus(num1, num2=10, num3=20): # 디폴트 파라미터 : 미리 선언해 놓은 변수, 파라미터명은 동일하지 않아도 됨.
    print(num1+num2+num3)

plus(1,2)

->23

plus(3, num3=100) # 아규먼트 : 키워드 아규먼트

->113

plus()

->『TypeError: plus() missing 1 required positional argument: 'num1'』

1.1.3.리턴

- 선언한 함수의 결과를 저장
- 함수 내에서 연산 진행 중에 return에 도달하면 연산이 종료
- return을 작성하지 않으면 결과값을 저장하지 않음

def text_print(text):
    print(text.lower())
    return text.lower()

text="Hello Python"
text_print(text).upper()

->hello python
'HELLO PYTHON'

# 함수 연산을 중단시키는 예제
def alpha_check(text):
    for i in text:
        if i.isalpha(): 
        # isalpha() : str타입의 변수가 알파벳으로 구성되어 있으면 True, 아니면 False를 반환
            continue
        else:
            print(text.index(i)+1)
    print("Clear!")
    return True

text1 = "waterme1on"
text2 = "Deepno1d"
text3 = "AI"
alpha_check(text1)

->8
Clear!
True

alpha_check(text2)

->7
Clear!
True

alpha_check(text3)

->Clear!
True

---

1.2. *args, **kwagrs

- 함수를 호출할 때 아규먼트와 키워드 아규먼트의 갯수를 특정 지을 수 없을 때 사용
- keyword args의 경우 아규먼트로 함수 호출 시 키워드를 작성하여 호출
- args는 튜플 타입
- kwargs는 딕셔너리 타입

def plus(*args, **kwargs): # args:변수명 없이 무작정 넣고 싶을 때, kwargs:변수명을 넣으면서 넣을
    print(type(args), args)
    print(type(kwargs), kwargs)
    return sum(args) + sum(list(kwargs.values()))

plus(1,2,3,4,5, num1=6, num2=7)

-><class 'tuple'> (1, 2, 3, 4, 5)
<class 'dict'> {'num1': 6, 'num2': 7}
28

1.2.1.list 타입 데이터를 args로 호출하는 방법

def func(num1, num2=10, num3=20):

    return num1+num2+num3

data = [1,2,3]
func(*data)

->6

data = [1,2,3,4]
func(*data)

->『TypeError: func() takes from 1 to 3 positional arguments but 4 were given』

def plus2(*args):
  return sum(args)
ls3 = [1,2,3,4,5,6]
plus2(*ls3)

->21

plus2(ls3) # 튜플화가 되어 계산할 수 없게 됨

->『TypeError: unsupported operand type(s) for +: 'int' and 'list'』

data = {
    "num2":100,
    "num3":200,
}
func(1,**data) # func(1,num2=100,num3=200)

->301

---

1.3.Docstring

- 함수를 선언할 때 함수에 대한 설명
- 어떤 파라미터를 받아주는지, 어떻게 동작을 하는지에 대한 내용

def text(msg):
  """
  이 함수에 대한 설명을 여기에 작성해주시오.
  """
  print("docstring 예제")

help(text)

->Help on function text in module main:

text(msg)
이 함수에 대한 설명을 여기에 작성해주시오.

print(text.__doc__)

->이 함수에 대한 설명을 여기에 작성해주시오.

---

1.4.지역변수와 전역변수

- 함수 안에서 선언되는 변수와 함수 밖에서 선언되는 변수의 범위
- global : 전역 # 어느 자리에서도 가공할 수 있을 때
- local : 지역 # 특정한 곳 안에서 이를테면 함수 안에서만 사용되거나 클래스 안에서만 사용되는 변수들

gv = 10
def test():
    print(gv)
test()

->10

gv

->10

gv = 10
def test2():
    gv = 100
    print(gv)
test2()

->100

gv

->10

---

1.5.Inner Function

- 함수가 지역영역에 선언, 함수 안에 함수가 선언

def outer(a,b):
    def inner(c,d): # inner함수는 지역함수
        return c+d
    return inner(a,b)

outer(1,2)

->3

inner(2,3)

->『NameError: name 'inner' is not defined』

def outer2(a,b):
    def inner(c,d):
        return c+d
    return inner # outer2(a,b) == inner

outer2(1,2)

-><function __main__.outer2.<locals>.inner(c, d)>

outer2(1,2)(3,4) # inner(3,4)

->7

outer2(500, 1000)(3,4)

->7

---

1.6.CallBack Function : 함수를 아규먼트 파라미터로 설정해서 사용

- 함수를 args 파라미터로 설정해서 사용
- 함수가 다른 함수를 호출하여 결과값을 실행
- 재귀함수에서 주로 사용

def calc(func, a, b): # calc(함수, 아규먼트)

    return func(a,b)

def plus(a,b):
    return a+b
def minus(a,b):
    return a-b

calc(plus, 1, 2)

->3

calc(minus, 1, 2)

->-1

---

Lambda Function

- 파라미터를 간단한 계산으로 리턴되는 함수 : 삼항연산

def plus(a,b):
    return a+b
plus(1,2)

->3

# calc(func,a,b)
calc(lambda a,b:a*b, 3,4)

->12

---

1.8.Map, Filter, Reduce

1.8.1.Map

- 순서가 있는 데이터 집합에서 모든 값에 함수를 적용시켜 결과를 출력

ls = [1,2,3,4]
def odd_even(num):
    return "odd" if num%2 else "even"

odd_even(3), odd_even(4)

->('odd', 'even')

# map("함수", "데이터셋")
list(map(odd_even, ls))
# map(odd_even, ls) : 리스트로 형 변환해야됨!

->['odd', 'even', 'odd', 'even']

1.8.2.Filter

- 리스트 데이터에서 특정 조건에 맞는 것만 출력

# filter(함수, 데이터)
ls = range(10)
list(filter(lambda data:True if data%2 else False, ls))

->[1, 3, 5, 7, 9]

1.8.3.Reduce

- 리스트 데이터를 처음부터 순서대로 특정 함수를 실행하여 결과를 누적시켜 주는 함수

from functools import reduce
ls = [1,2,3,4,5,6,7]
# reduce(함수, 데이터)
reduce(lambda x,y:x+y, ls)

->28

---

1.9.Decorator

- 함수에서 코드를 바꾸지 않고 기능을 추가하거나 수정하고 싶을 때 사용하는 문법
- inner function을 선언했을 때 인스턴트처럼 사용 -> class의 개념
- 큰 틀을 만들어주고 함수를 선언해서 집어 넣기

def a():
    code_1
    code_2
    code_3

def b():
    code_1
    code_4
    code_3

- 데코레이터 사용

def mother(func):
    def wrapper(*args, **kwargs):
        code_1
        result = func(*args, **kwargs)
        code_3
        return result
    return wrapper

@mother
def son1():
    code_2

@mother
def son2():
    code_4

# a
def plus(a, b):
    print("start")    # code1
    result = a + b    # code2
    print("result : {}".format(result))    # code3
    return result

plus(6,7)

->start
result : 13
13

# b
def minus(a,b):
    print("start")  # code1
    result = a-b    # code2
    print("result : {}".format(result)) # code3
    return result

# c
def display(func):
    def wrapper(*args, **kwargs):
        print("Let's start")  # code1
        result = func(*args, **kwargs)  # code2, code4
        print("result: {}".format(result))  # code3
        return result
    return wrapper

@display
def plus(a,b):
    result = a+b
    return result

plus(1,2)

->Let's start
result: 3
3

1.9.1.decorator 실행 예제

- 함수의 실행 시간을 출력하는 함수

def timer(func):
    import time
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print("running time : {}".format(end_time-start_time))
        return result
    return wrapper

@timer
def test1(num1, num2):
    data = range(num1, num2+1)
    return sum(data)

@timer
def test2(num1, num2):
    result = 0
    for num in range(num1, num2+1):
        result += num
    return result

test1(1, 50000)

->running time : 0.0010187625885009766
1250025000

test2(1,50000)

->running time : 0.007382392883300781
1250025000

1.9.2.패스워드를 입력 받아야 함수가 실행되도록 하는 데코레이터 작성

def check_pwd(func):
    def wrapper(*args, **kwargs):
        pw = "deep11"
        #check pw
        input_pw = input("insert pw: ")
        if input_pw == pw: return func(*args, **kwargs)
        return "not allow!"
    return wrapper

@timer
@check_pwd
def plus(a,b):
    return a+b

plus(1,2)

->insert pw: deep11
running time : 5.081146240234375
3

plus(2,3)

->insert pw: ds
running time : 1.3841471672058105
not allow!