Function

def 함수이름(매개변수나열):
    함수내용작성
    [return 데이터]

# 매개변수도 없고 리턴도 없는 함수
def noArgNoReturnFunc() -> None:
    print("매개변수가 없고 리턴도 없는 함수")
    return None

# 함수 이름만 호출하면 참조가 리턴
print(noArgNoReturnFunc)

# 함수 호출
noArgNoReturnFunc()

# 매개변수가 있는 경우와 없는 경우
def noArgFunc() -> None:
    for _ in range(3):
        print("매개변수가 없는 함수")

# 파이썬에서도 매개변수에 자료형을 기재해주는 것을 권장
def argFunc(n: int) -> None:
    for _ in range(n):
        print("매개변수가 있는 함수")

# 하나의 값을 매개변수로 받아서 값을 변경하는 함수
def callByValue(n:int) -> None:
    print("n:", n)
    n = 10
    print(f"함수 내부에서 수정한 후 n:{n}")

x = 20
print(f"함수 호출 전: x: {x}")
# 함수에게 하나의 값을 전달하는 경우는 함수 내부에서 데이터를 수정할 수 없음
callByValue(x)
print(f"함수 호출 후 x:{x}")

def callByReference(li:list) -> None:
    print(f"함수 내부의 li: {li}")
    li[0] = "joy"
    print(f"함수 내부에서 수정한 후 li:{li}")

espa=["조이", "karina"]
print(f"함수 호출 전의 espa:{espa}")
# 벡터 자료형을 넘기는 경우는 함수 내부에서 벡터 자료형의 요소를 변경하면 변경된 함수 외부의 데이터에 적용됨
# 벡터 자료형의 경우는 참조를 넘기기 때문
callByReference(espa)
print(f"함수 호출 후의 espa: {espa}")

def orderParameter(a: int, b: int) -> None:
    print(a)
    print(b)
orderParameter(10, 20)

# 파이썬에서는 매개변수에 데이터를 대입할 때 이름과 함께 대입하는 것이 가능
# 순서를 변경해도 됨
# 이름을 생략하면 순서대로 대입함
orderParameter(a=10, b=30)
orderParameter(b=30, a=10)

# 매개변수에 이름을 대입할 때 한번 이름을 대입하면 그 이후 모든 데이터에 이름을 대입해야 함
# 첫번째 매개변수는 함수를 수행하기 위한 가장 중요한 데이터를 배정해서 이 데이터의 경우는 이름을 입력하지 않고 입력하도록 하는 경우가 많음
orderParameter(a=200, 100) # 실행안됨
orderParameter(100, b=100)

# 매개변수에 기본값이 있는 경우 함수를 호출할 때 생략하고 대입하는 것이 가능
# 매개변수에 기본값을 설정하면 뒤에 오는 모든 매개변수에도 기본값을 설정해야 함
def defaultParameter(a:int, b:int=0 c:int=0) -> None:
    print(a)
    print(b)

defaultParameter(10)

# range(1, 10, step=1)
r = range(stop=10, start=1, stop=2)
print(r)

# 여러 개의 데이터 리턴하면 튜플로 묶어서 리턴
def tupleReturn() -> tuple:
    return 100, 200

result = tupleReturn()
print(type(result))

r1, r2 = tupleReturn()

# 매개변수가 여러 개일 경우 1개로 대입해서 분할해서 적용
def personalInfo(name:str, age:int, gender:bool) -> None:
    print(f"이름: {name}")
    print(f"나이: {age}")
    print(f"성별: {gender}")

# personalInfo("아담", 34, True)
# personalInfo(name="아담", gender=False, age=32)

# 여러 개의 매개변수에 값을 대입할 때 list, tuple, set 1개를 사용할 수 있는데 이 경우는 앞에 *를 추가해야 함
personalInfo(*["아담", 34, True])

# dict는 *를 설정하면 key가 순서대로 대입됨
personalInfo(*{"name":"아담", "age":34, "gender":True})

# dict는 **을 설정해야 value가 대입됨
# 변수 이름과 동일한 key의 값이 대입됨
personalInfo(**{"name":"아담", "age":34, "gender":True})

# help(max)
print(max(10,30,20,40)) # 매개변수 개수 상관없음

# 매개변수를 만들 때 **를 이용하면 dict로 데이터가 대입
def dictFunction(** args) -> None:
    for i in args:
        print(i)
dictFunction(name="adam", age=21, gender=False)

# : 다음에 표현식을 설정해서 값의 제한을 설정할 수 있음
def annotationFunc(score: "int>=0" = 0) -> None:
    print(f"정수:{score}")

def annotationFunc(score: "int>=0" = 0) -> None:
    print(f"정수:{score}")
annotationFunc.__doc__ = "함수의 속성으로 도움말 추가"
help(annotationFunc)

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

def mins(a, b):
    return a-b

def calc(f, a, b):
    return f(a, b)

print(calc(plus, 20, 20))

def hello_korean() -> None:
    print("안녕하세요")

def hello_english() -> None:
    print("Hello")

def get_greeting(where) -> None:
    if where == 'K':
        return hello_korean
    else:
        return hello_english
hello = get_greeting(where = 'k')
hello()

# 파이썬은 함수 안에 함수를 만드는 것이 가능
def outer():
    n = 0
    def inner():
        n = n + 1
    return inner
closure = outer()
closure()
closure()

# 하나의 매개변수를 받아서 제곱해서 리턴하는 람다 함수
f = lambda x : x * x
f = f(10)
print(r)

# -10부터 10까지 숫자를 순회하면서 func의 return 값을 가지고 list를 만들어서 리턴
def three(func):
    return [func(x) for x in range(-10, 10)]
print(three(lambda x: x*x*x))

import datetime
li = [i for i in range(10000)]

r = []

# list를 순회하면서 각 데이터에 제곱을 해서 다시 list로 생성
before = datetime.datetime.now()
for i in li:
    r.append(i*i)
print(r[0], r[10])
after = datetime.datetime.now()

def f(x):
    return x*x
before = datetime.datetime.now()
# li의 모든 요소에 f 함수를 적용해서 결과를 가지고 그룹을 만들어줌
result = list(map(f, li))
after = datetime.datetime.now()

li = [i for i in range(100)]

# 3으로 나눈 나머지가 0인지 확인하는 함수를 람다로 만들어서 적용
result = list(filter(lambda x: x%3 ==0, li))

from functools import reduce

result = reduce(lambda x, y: x+y, [1,2,3,4,5])

names = ["adam", "itstudy"]
ages = [34, 43]

table = list(zip(names, ages))

keys = ["names", "ages"]
t = dict(zip(keys, [names, ages]))

def scope_test() -> None:
    # 함수 안에 a를 만들어서 1이라는 데이터를 가리킴
    # 이 변수는 함수 안에서만 사용 가능
    a = 1
    print(f"a:{a}")

a = 0 # 파일 안에 a 라는 변수를 만들고 0이라는 데이터를 가리킴
scope_test()
print(f"a:{a}") # 파일 안에서 만들어진 a를 호출

def scope_test() -> None:
    print(f"a:{a}") # 현재까지는 a를 만든 적이 없어서 이 a는 외부에 있는 a

    a = 1 # 에러가 발생
    print(f"local a:{a}")
    
a = 0 # 파일 안에 a 라는 변수를 만들고 0이라는 데이터를 가리킴
scope_test()
print(f"a:{a}") # 파일 안에서 만들어진 a를 호출

def scope_test() -> None:
    global a # a는 함수외부에 있는 a를 의미

    print(f"local a:{a}")
    
a = 0 # global이 가리킴
scope_test()
print(f"a:{a}")

def outer() -> None:
    a = 1
    def inner() -> None:
        print(a)
        # global은 함수 외부에서 변수를 찾아오게 되는데 함수 외부에는 a가 없어서 에러
        nonlocal a # outer()함수 내부에 선언된 a를 가리킴
        a = 100 # a에 100 할당 가능
        print(a)
    inner()
outer()

def outer():
    a = 0

    # 내부에 있는 함수에서 외부 함수의 데이터를 수정하도록 함수를 작성
    def inner() -> None:
        nonlocal a
        a = a+1
        print(a)
    return inner

# 외부 함수를 호출해서 내부 함수의 참조를 저장
r = outer()

#함수를 호출 - 내부 함수를 통해서 외부 함수의 데이터를 변경 가능함
# 이 문법을 closure 라고 함
r()
r() # a 값이 계속 증가

# 데코레이터로 수행될 함수는 매개변수로 하나의 함수를 받아야 함
def deco(func):
    def inner():
        print("데코레이터 동작")
        # 원래 함수 수행
        func()
        print("데코레이터 종료")
    return inner

@deco
def target():
    print("비즈니스 로직")

target()

import time

# func는 호출되는 함수의 참조
def logging(func):
    # *args는 호출되는 함수의 매개변수
    def logged(*args):
        start = time.time()
        
        # 함수의 호출 결과
        result = func(*args)

        # 걸린 시간 계산
        elapsed = time.time() - start

        # 함수 이름 가져오기
        name = func.__name__
        print(f"함수 이름: {name} 걸린 시간: {elapsed} 결과: {result}")
        # 이 구문이 없으면 재귀처럼 함수를 리턴하는 경우는 에러
        return result
    return logged

@logging
def noRecursiveFibonacci(n: int) -> int:
    l1 = 1
    l2 = 1
    result = 1
    idx = 3
    while idx <= n:
        result = l1 + l2
        l1 = l2
        l2 = result

        idx = idx + 1
    return result

@logging
def yesRecursiveFibonacci(n: int) -> int:
    return 1 if n<=2 else yesRecursiveFibonacci(n-1) + yesRecursiveFibonacci(n-2)
    
print(noRecursiveFibonacci(10))
yesRecursiveFibonacci(10)

import time
import functools

# func는 호출되는 함수의 참조
def logging(func):
    # *args는 호출되는 함수의 매개변수
    def logged(*args):
        start = time.time()
        
        # 함수의 호출 결과
        result = func(*args)

        # 걸린 시간 계산
        elapsed = time.time() - start

        # 함수 이름 가져오기
        name = func.__name__
        print(f"함수 이름: {name} 걸린 시간: {elapsed} 결과: {result}")
        return result
    return logged

@functools.lru_cache()
@logging
def yesRecursiveFibonacci(n: int) -> int:
    return 1 if n<=2 else yesRecursiveFibonacci(n-1) + yesRecursiveFibonacci(n-2)
    
yesRecursiveFibonacci(10)