모듈(module)과 패키지 (package)

• 모듈 : 함수나 클래스로 등의 소스 파일(*.py)
• 패키지 : 여러 모듈을 모아서 폴더로 제공

---

함수(function)

• 외부에서 들어오는 값을 매개변수로 받아서 함수내의 실행문을 통해서 매개변수를 처리하고 그 결과를 반환
• 내장함수, 사용자 정의 함수

내장 함수 : built-in or import

• built-in : 별도의 import 없이 사용 , 함수()
• import : 모듈.함수()
• 모듈이나 패키지에서 제공하는 함수
• import 모듈명
• form 모듈명 import 함수명1, 함수명2 ...

import builtins
#dir(builtins) # 내장 클래스, 내장 함수 목록 보기

dataset = list(range(1,6))
print(dataset) # [1, 2, 3, 4, 5]

[1, 2, 3, 4, 5]

# (1) builtins 함수
print('len=', len(dataset))
print('sum=', sum(dataset)) # sum= 15
print('max=', max(dataset))
print('min=', min(dataset))

len= 5
sum= 15
max= 5
min= 1

# (2) import 함수
import statistics # 수학/통계 함수 모듈(statistics.py) - 방법1

# import
print('평균=', statistics.mean(dataset)) 
print('중위수=', statistics.median(dataset))

평균= 3
중위수= 3

from statistics import variance, stdev # - 방법2
print("표본 분산=", variance(dataset))
print("표본 표준편차=", stdev(dataset))

표본 분산= 2.5
표본 표준편차= 1.5811388300841898

from statistics import * # - 방법3
print('평균=', mean(dataset)) 
print('중위수=', median(dataset))
print("표본 분산=", variance(dataset))
print("표본 표준편차=", stdev(dataset))

평균= 3
중위수= 3
표본 분산= 2.5
표본 표준편차= 1.5811388300841898

# dir() : 객체의 변수, 내장함수, 내장클래스 목록 반환
print(dir(statistics))
print('-'*50)
print(dir(dataset))

['Decimal', 'Fraction', 'StatisticsError', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_coerce', '_convert', '_counts', '_exact_ratio', '_fail_neg', '_find_lteq', '_find_rteq', '_isfinite', '_ss', '_sum', 'bisect_left', 'bisect_right', 'collections', 'groupby', 'harmonic_mean', 'math', 'mean', 'median', 'median_grouped', 'median_high', 'median_low', 'mode', 'numbers', 'pstdev', 'pvariance', 'stdev', 'variance']
--------------------------------------------------
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

dataset = list(range(1,6))
dataset.insert(0, 100)
print(dataset) 
dataset.pop(0)
print(dataset) 

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

# zip : iterable 한 객체와 객체간의 원소를 묶어서 tuple로 반환

z = zip([1,3,5], [2,4,6])
print(z)

l = list(z)
print(l)

d = dict(l)
print(d)

<zip object at 0x0000020DCD6CEB08>
[(1, 2), (3, 4), (5, 6)]
{1: 2, 3: 4, 5: 6}

사용자 정의 함수

'''
형식) 
def 함수([인수]) :
    실행문
    실행문
    [return 값] 
'''

# (1) 인수가 없는 함수
def userFunc1():
    print('userFunc1')

userFunc1() # 함수 호출

userFunc1

# (2) 인수가 있는 함수 : 값전달
def userFunc2(x, y):
    print('userFunc2')
    z = x + y
    print('z=', z)

userFunc2(10, 20)  # 함수 호출

userFunc2
z= 30

# 인수가 있는 함수 : 객체 전달
def refFunc(x):
    x[0] = 100
    print(x)
    
l = [1,2,3]
refFunc(l)
print(l)

[100, 2, 3]
[100, 2, 3]

# (3) return 있는 함수
def userFunc3(x, y):
    print('userFunc3')
    tot = x + y
    sub = x - y
    mul = x * y
    div = x / y
    
    return tot, sub, mul, div

# 실인수 : 키보드 입력
x = int(input('x 입력 : '))
y = int(input('y 입력 : '))

t, s, m, d = userFunc3(x, y)
print('tot =', t)
print('sub =', s)
print('mul =', m)
print('div =', d)

x 입력 : 5
y 입력 : 3
userFunc3
tot = 8
sub = 2
mul = 15
div = 1.6666666666666667

산포도 함수

• 산포도 : 평균으로 부터 값의 분산정도를 나타내는 척도
• 분산 = (sum(x변량-산술평균)**2)) / (n-1)
• 표준편차 = sqrt(분산)

from statistics import mean, variance
from math import sqrt

# 산술평균  
def Avg(data):
    avg = mean(data)
    return avg

# 분산/표준편차 
def var_sd(data): # [2,4,5,6,1,8] - avg
    avg = Avg(data) # 함수 호출
    # list 내포
    diff = [ (d - avg)**2  for d in data]
    
    var = sum(diff) / (len(data) - 1)
    sd = sqrt(var)
    
    return var, sd

dataset = [2,4,5,6,1,8]

print('산술평균 =', Avg(dataset))
# 산술평균 = 4.333333333333333

산술평균 = 4.333333333333333

v, s = var_sd(dataset)
print('분산 =', v)
print('표준편차=', s)

분산 = 6.666666666666666
표준편차= 2.581988897471611

print('내장함수 분산 =', variance(dataset))

내장함수 분산 = 6.666666666666666

피타고라스 정리 함수

def pytha(s, t) :
    a = s**2 - t**2
    b = 2 * s * t
    c = s**2 + t**2
    print("피타고라스의 정리 : 3변의 길이 : ",a,b,c)

pytha(3,1)

피타고라스의 정리 : 3변의 길이 :  8 6 10

몬테카를로 시뮬레이션 함수

• 현실적으로 불가능한 묹의 해답을 얻기 위해서 난수의 확률 분포를 이용하여 모의실험으로 근사적 해를 구하는 기법
• 중심극한정리 : 표본의 크기가 클수록 근사적으로 표본의 평균이 모평균과 같고, 분산이 모분산과 같은 정규분포를 따름

import random

# 단계 1 : 동전 앞면과 뒷면의 난수 확률분포 함수 정의
def coin(n) :
    result = []
    for i in range(n) :
        r = random.randint(0, 1)
        if (r == 1) :
            result.append(1) # 앞면
        else :
            result.append(0) # 뒷면
    #print(result[0])
    return result

print(coin(10)) # [0, 1, 1, 0, 1, 0, 0, 1, 0, 1]

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

# 단계 2 : 몬테카를로 시뮬레이션 함수 정의
def montaCoin(n) :
    cnt = 0
    for i in range(n) :
        cnt += coin(1)[0] # coin 함수 호출

    result = cnt / n # 동전 앞면과 뒷면의 누적 결과를 시행 횟수(n)로 나눈다.
    #print(cnt, n)
    return result

for i in range(30):
    pass
    #print(montaCoin(10000)) 

#단계 3 : 몬테카를로 시뮬레이션 함수 호출
print(montaCoin(10)) 
print(montaCoin(30)) 
print(montaCoin(100)) 
print(montaCoin(1000))
print(montaCoin(10000))

0.3
0.5
0.58
0.505
0.503

가변인수 함수

• 한 개 가인수로 여러 개 실인수 받을 수 있는 인수

# (1) 여러 명의 이름 받는 가변인수 def 함수명(*인수)
def Func1(name, *names):
    print(name)  # 가인수 : 홍길동
    print(names)  # 가변 인수 : ('이순신', '유관순')

Func1("홍길동", "이순신", "유관순")

홍길동
('이순신', '유관순')

# statistics 모듈 import
from statistics import mean, variance, stdev

# (2) 통계량 구하는 함수
def statis(func, *data):
    if func == 'avg':
        return mean(data)
    elif func == 'var':
        return variance(data)
    elif func == 'std':
        return stdev(data)  # var, sd
    else:
        return 'TypeError'

print('avg=', statis('avg', 1, 2, 3, 4, 5))  
print('var=', statis('var', 1, 2, 3, 4, 5))  
print('std=', statis('std', 1, 2, 3, 4, 5))  

avg= 3
var= 2.5
std= 1.5811388300841898

# (3) 사전형 가변인수 def 함수명(**인수)
def emp_func(name, age, **other):
    print(name)
    print(age)
    print(other)  # {'addre': '서울시', 'height': 175, 'weight': 65}

emp_func('홍길동', 35, addre='서울시', height=175, weight=65)

홍길동
35
{'addre': '서울시', 'height': 175, 'weight': 65}

람다함수 Lambda

• 정의와 호출을 한번 에 하는 익명함수
• 변수 = lambda 매개변수 : 리턴값

# (1) 일반함수
def Adder(x, y):
    add = x + y
    return add

print('add=', Adder(10, 20))

add= 30

# (2) 람다 함수
print('add=', (lambda x, y: x + y)(10, 20))

add= 30

# lambda에서 가변 인수 사용
calc = lambda dan, su: dan * su
print('price =', calc(2500, 5))  # price = 12500

calc2 = lambda dan, *su, **product: print(dan, su, product)

calc2(10000, 3, 5, a=2500, b=3000)

price = 12500
10000 (3, 5) {'a': 2500, 'b': 3000}

scope : 전역변수/지역변수

• 전역변수 : 전 지역 사용
• 지역변수 : 함수 or 블럭(if, while, for) 사용

x = 50  # 전역변수

def local_func(x):
    x += 50  # 지역변수 -> 종료 시점 소멸

local_func(x)
print('x=', x)  # x= 50

x= 50

# 전역변수 함수내 사용
def global_func():
    global x  # 전역변수 x 사용
    x += 50  # x+50 = 100

global_func()
print('x=', x)  # x= 100

x= 150

중첩함수(inner function)

• 함수 내부에 또 다른 함수가 내장된 형태
• outer 함수 역할 : 값 생성, inner함수 포함
• inner 함수 역할 : 값 대상 연산 수행(합계 -> 평균)

'''
형식)
def  outer_func(인수) :
    문장1

    def inner_func(인수) :
        문장2
        return 문장2

    return inner_func
'''

일급함수와 클로저

• 일급함수 : 함수를 변수에 저장하거나 인수 또는 리턴 값으로 사용가능
• 클로저 : 내부 함수를 외부 함수의 리턴값으로 사용시 외부 함수가 종료되어도 내부 함수에 선언된 변수가 소멸되지 않고 활용 가능함

# (1) 일급 함수
def a():  # outer
    print('outer a')

    def b():  # inner
        print('inner b')

    return b

b = a()  # 외부 함수 호출 - a 함수
b()  # 내부 함수 호출 - b 함수

outer a
inner b

# (2) 함수 클로저

def outer_func(data):
    dataSet = data  # 값(1~100) 생성

    # inner
    def tot():
        tot_val = sum(dataSet)
        return tot_val

    def avg(tot_val):
        avg_val = tot_val / len(dataSet)
        return avg_val

    return tot, avg  # inner 반환

data = list(range(1, 101))

# 외부함수 호출 : data 생성
tot, avg = outer_func(data)

# 내부함수 호출
tot_val = tot()
print('tot =', tot_val)

avg_val = avg(tot_val)
print('avg =', avg_val)

tot = 5050
avg = 50.5

중첩함수를 활용한 산포도 함수

#문) 중첩함수 문제 
# - outer 함수 : data 생성, inner 함수 포함 
# - inner 함수 : data 대상으로 avg -> var(avg_val) -> std(var_val)

from statistics import mean  # 평균
from math import sqrt  # 제곱근

data = [4, 5, 3.5, 2.5, 6.3, 5.5]


def scattering_func(data):  # outer
    dataSet = data  # data 생성

    # inner
    def avg_func():
        avg_val = mean(dataSet)
        return avg_val

    def var_func(avg):
        # var = (sum(변량-산술평균)**2)) / (n-1)
        diff = [ (data - avg) ** 2 for data in dataSet ]
        #print(diff)  # 1차원
        #print(sum(diff))  # 0차원
        var_val = sum(diff) / (len(dataSet) - 1)

        return var_val

    def std_func(var):
        std_val = sqrt(var)
        return std_val

    return avg_func, var_func, std_func  # inner 반환

# outer 호출
avg, var, std = scattering_func(data)

# 내부 함수 호출
print('평균 : ', avg())
print('분산 : ', var(avg()))
print('표준편차 :', std(var(avg())))

평균 :  4.466666666666667
분산 :  1.9466666666666668
표준편차 : 1.39522996909709

getter, setter, nonlocal

def main_func(num):
    num_val = num  # 함수 내 변수=100 -> 200

    def getter():  # 인수 없음, return 있음
        return num_val

    def setter(value):  # 인수 있음, return 없음
        nonlocal num_val  # outer 변수 지정
        num_val = value

    return getter, setter


getter, setter = main_func(100)  # num 생성

print('num =', getter())  # num = 100
setter(200)  # num 값 수정
print('num =', getter())  # num 수정 확인 : num = 200

num = 100
num = 200

함수 장식자(decoration)

• @함수명

# 래퍼 함수
def wrap(func) :
    def decorated() :
        print('방가워요!')
        func()
        print('잘가요!')
    return decorated # 클로저 함수

# 함수 장식자 적용
@wrap
def hello() :
    print('hi ~ ', "홍길동")


# 함수 호출
hello()

방가워요!
hi ~  홍길동
잘가요!

재귀함수 recursive function

• 함수 내부에서 자신의 함수를 반복적으로 호출하는 함수
• 조건 : exit 조건 필요

# (1) 1~n 카운트(n=5: 1 2 3 4 5)
def Counter(n):
    if n == 0 :
        return 0 # exit 조건 
    else :
        Counter(n-1) # 5(first) -> 4(5-1) -> 3(4-1) -> 2(3-1) -> 1(2-1) [0(1-1)]
        '''
        stack(5, 4, 3, 2, 1) : LIFO
        return 값은 stack 저장되지 않음 
        '''
        print(n, end = ' ') # 중복 출력
        # 1 2 3 4 5  

# 함수 호출1
print('n=0 : ', Counter(0)) # n=0 :  0

# 함수 호출2
Counter(5)

n=0 :  0
1 2 3 4 5 

# (2) 1~n 누적합(1+2+3+4+5=15)
def Adder(n):
    if n == 1 : # n=1 -> exit 조건 
        return 1
    else :
        # 재귀호출 
        result = n + Adder(n-1) 
        # 5(first)->4(5-1) -> 3(4-1) -> 2(3-1) | [1(2-1)] 
        '''
        1. stack(5, 4, 3, 2)
        2. 덧셈 : 1 + [2 + 3 + 4 + 5 ]         
        '''   
        print(n, end = ' ')   # 2 3 4 5   
        return result # 15
    
print('n=1 :', Adder(1)) # n=1 : 1
print('\nn=5 :', Adder(5)) # n=5 : 15

def factorial(n):
    if n == 1:
        return 1;
    else:
        result = n * factorial(n-1)
        print(n, end = ' ')   # 2 3 4 5   
        return result # 15

print('n=1 :', factorial(1)) # n=1 : 1
print('\nn=5! :', factorial(5)) # n=5 : 15

n=1 : 1
2 3 4 5 
n=5! : 120