[easyupclass] 초심자를 위한 빅데이터 분석 및 머신러닝 응용과정(파이썬) 10강 ~ 12강

arguments와 keyword arguments

- 함수 선언시 파라미터 수를 특정할 수 없을 경우

- keyword arguments는 아규먼트로 함수 호출시 키워드를 작성하여 호출

- args는 튜플

- kwargs는 딕셔너리

def hap (*args, **kwargs):
	print(type(args), args)
    print(type(kwargs, kwargs)
    return sum(args) + sum(list(kwargs.values()))
    
# args: (1, 2, 3, 4)
# kwargs: {num1 : 5, num2 : 6} 
hap(1, 2, 3, 4, num1=5, num2=6)

 

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

def gop(n1, n2, n3):
	return n1 * n2 * n3
    
ls = [2, 3, 4]
gop(*ls)

def hap2(*args):
	return sum(args)
    
# 리스트 안에 값이 몇 개든 함수 사용 가능
ls3 = [3, 4, 5, 6]
# 그냥 ls3 넣으면 에러 -> 튜플 타입이기 때문에
hap2(*ls3)

- func(*list)로 작성하면 list의 data들이 각각 파라미터로 들어감

- 함수의 파라미터 개수와 리스트의 개수가 맞지 않으면 에러

 

Join 문법

- 하나의 문자열을 합칠 수 있는 함수

# 리스트 안에 있는 문자열들을 합치는 함수

ls = ["python", "is", "very", "fun"]
" ".join(ls)

# 첫번째 알파벳만 대문자로 만들고 나머지는 소문자, 맨 끝에 .
# + list comprehension
def correction(text):
	sentence = ''.join(text[i].upper if not i else text[i] for i in range(len(text)))
    if sentence[-1] != ".":
    	sentenct += "."
        
    return sentence

 

Docstring

- 함수를 선언할 때 함수에 대한 설명

def exam(subj):
	""" 
    함수에 대한 설명
    """
    
help(exam)
exam.__doc__

 

---

 

지역변수와 전역변수

- 함수/클래스 안에서 선언되는 변수(지역변수)와 밖에서 선언되는 변수의 범위

- global: 전역

- local: 지역

global_v = 100

def exam():
	# 글로벌 변수 선언
	global global_v 
    global_v = 50
    
#global_v의 값은 50

 

Inner Function

- 함수 안에 함수가 선언되는 경우

   = 함수를 지역영역에 선언

def outer(a,b):
    def inner(c,d):
        return c+d
    return inner(a,b)
    
outer(1,2)

# 에러
inner(1,2) - outer 안에서만 사용 가능

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

outer(3,4)

# outer(3,4) = inner
# outer(3,4)의 아웃풋이 함수 자체가 됨
outer(3,4)(1,2)

- decorator의 개념이 더 중요

 

Callback function

- 함수를 args 파라미터로 설정해서 사용

- 함수가 다른 함수를 호출하여 결과값을 실행

- 재귀함수에서 잘 사용

def calc(func, a, b):
	return func(a, b)
    
def hap(a,b): 
    return a+b

def gop(a,b):
    return a * b
    
    
calc(hap, 3, 4)
# 7
calc(gop, 3, 4)
# 12

 

Lambda function

- 파라미터를 간단한 계산으로 리턴

- 선언을 하지 않음

- 연산을 끝내면 소멸하는 함수

   -> 다른 변수에 대입하면 계속 람다 함수를 실행

- lambda parameter : return value

- 메모리를 적게 씀!!

- 단순한 연산을 빠르게 처리할 때 많이 사용

hap2 = lambda a, b: a + b

hap2(4,5)
#9

substr = lambda x : x[int(len(x)/2)] if len(x)%2 else x[int(len(x)/2)-1:int(len(x)/2)+1]

 

Map

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

- 가상의 주소에 있는 것을 실제 물리 주소로 변환하는 것(data science)

# map(함수, 데이터셋)

ls=[1,2,3,4]

def odd_even(n):
    return "odd" if n%2 else "even"
    
# 형변환 필수
list(map(odd_even, ls))

num = input("number: ")
# 1 2 3 4 5
result = num.split(" ")
result = list(map(int, result))
result

numbers = list(map(int, input("numbers: ").split(" ")))
numbers

 

Filter

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

- lambda와 함께 많이 쓰임

# filter(함수, 데이터) # lambda로 간단하게 선언
# 형변환 필수

# 0~9까지
ls = range(10)

#홀수만 출력
list(filter(lambda x: True if x%2 else False, ls))

 

Reduce

- list 데이터를 처음부터 순서대로 특정 함수를 실행하여 결과를 누적

- reduce 패키지 

from functools import reduce

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

# reduce(함수, 데이터셋)
# 형변환 X
reduce(lambda x, y: x+y, ls)

 

---

 

Decorator

- 함수에서 코드를 바꾸지 않고 기능을 추가하거나 수정하고 싶을 때 사용

- inner function 개념을 확장해서 사용하는 방법

- inner function을 선언했을 때 인스턴트처럼 사용 = class 개념

- 큰 틀을 만들어두고 함수를 선언해서 집어넣기

- outer function에서 inner function을 사용할 수 있다 -> decorator 핵심 

- inner function을 포함하여 inner function을 쓸 수 있게 하는 함수 = decorator

   -> 함수 2개 선언 (밖, 안)

#decorator
def disp(func):
    def wrapper(*args, **kwaargs):
        print("your function is getting start!")
        res = func(*args, **kwargs)
        print(res)
        print("process done!")
        return res
    return wrapper


# 데코레이터 사용한다 선언
# disp의 func 자리에 plus 들어간 것 
@disp
def plus(a,b):
    res = a+b
    return res

 

예제1 : 함수의 실행 시간을 출력하는 함수 작성

def timer(func):
    import time
    def wrapper(*args, **kwargs):
        #함수 실행된 시간
        start_time = time.time()
        res = func(*args, **kwargs)
        #끝났을 때 시간
        end_time = time.time()
        print("Running Time : {}".format(end_time - start_time))
        return res
    #꼭 inner function 
    return wrapper
    
    
@timer
def test1(n1, n2):
    data = range(n1, n2+1)
    return sum(data)
    
@timer
def test2(n1, n2):
    res = 0
    for n in range(n1, n2+1):
        res += n
    return res

 

예제2 : 패스워드가 일치할 때 연산이 가능하도록 decorator 만들기

def check_pw(func):
    def wrapper(*args, **kwargs):
        pw = 'euc21'
        login = input("password : ")
        if login == pw:
            return func(*args, **kwargs)
        return "Wrong password"
    return wrapper
    
@check_pw
def hap(a,b):
    return a+b

<!-- Quiz 

- dict 형식의 id와 password를 생성하고 datas 안에 id와 password가 일치하는 경우에만 실행
- datas는 dict
- id: password
- decorator로 함수 실행
- 없거나 틀렸을 경우 접속이 불가능하다는 결과 출력 -->

# 내 코드
def login(func):
    def wrapper(*args, **kwargs):
        datas = {'qwer':'1234', 'asdf':'0987'}
        login_id = input("id : ")
        login_pw = input("password : ")
        if login_id in (datas.keys()):
            if login_pw == datas[login_id]:
                return func(*args, **kwargs)
        return "Access Denied"
    return wrapper

- wrapper에 args, kwargs 안 쓰면 에러