[python] 함수 / 모듈

1️⃣ 파이썬 중급

1. 함수란?

• 함수는 파이썬에서 기본으로 제공하는 '내장함수'와 사용자가 직접 선언하는 '사용자 함수'가 있다.
• ex) print(), input(), sort()
• 함수를 사용하는 이유: 효율적으로 특정 기능을 재사용하기 위해서 사용한다.
• 함수는 기능으로, 만들어 놓고 필요할 때 사용한다.

def addFun(x, y):
	return x + y
print(addFun(100, 50))

>>>150

2. 함수 선언과 호출

• 함수는 def 키워드, 함수명, :, 들여쓰기를 이용해서 선언한다.
• 함수 -> 기능이 잘 드러나는 이름으로 만드는 것이 좋다.
• ex) 변수 -> 주로 명사를 씀
• 실행문은 반드시 '들여쓰기' 한다!

def calFuc():
    n1 = int(input('n1 입력: '))
    n2 = int(input('n2 입력: '))

    print(f'n1 * n2 = {n1 * n2}') #실행문은 반드시 들여쓰기를 한다.
    print(f'n1 / n2 = {round(n1 / n2, 2)}') #round 함수: 소수점 몇째자리까지만 출력해라

calFuc()
calFuc()
calFuc()

3. 함수 내에서 또 다른 함수 호출

def guguDan2():
	for i in range(1, 10): #1부터 9까지
    	print('2 * {} = {}'.format(i, 2*i)
    guguDan3()
    
def guguDan3():
    for i in range(1,10):
        print('3 * {} = {}'.format(i, 3*i))
    guguDan4()
    
def guguDan4():
    for i in range(1,10):
        print('4 * {} = {}'.format(i, 4*i))
    guguDan5()
    
def guguDan5():
    for i in range(1,10):
        print('5 * {} = {}'.format(i, 5*i))

guguDan2()
   

4. 인수와 매개변수

• 함수는 선언부와 호출부로 나뉜다.
• 호출부에서 전달한 '인수(parameter)'를 선언부의 '매개변수'로 받는다.
• '인수'와 '매개변수'의 개수는 일치해야 한다. -> 불일치 시, missing error 발생
• 매개변수가 정해지지 않은 경우 매개변수 앞에 을 붙여준다.(ex) numbers)

#인수, 매개변수 1개
def greet(customer): #customer: 매개변수
    print('{}님 안녕하세요.'.format(customer)) #매개변수

greet('홍길동') #홍길동: 인수

#인수, 매개변수 2개
def greet(customer1, customer2):
	print({}님 안녕하세요.'.format(customer1, customer2))

greet('박찬호', '홍길동')

def printNumber(*numbers):
	for number in nubmers:
    	print(number, end='') #개행을 하지 마라!
    print()

#호출부
printNumber()
printNumber(10)
printNumber(10, 20)
printNumber(10, 20, 30)

#국어, 영어, 수학 점수를 입력받고, 입력받은 점수를 이용해서 총점과 평균을 출력하는 함수를 만들어 보자.
#선언부
def printScore(kor, eng, mat):
	sum = kor + eng + math
    avg = sum / 3
    
    #함수의 실행부는 들여쓰기 한다.
    print(f'총점: {sum}')
    print(f'평균: {round(avg, 2)}') #소수점 둘째자리까지 나타낸다.

#입력
korScore = int(input('국어 점수 입력: '))
engScore = int(input('영어 점수 입력: '))
matScore = int(input('수학 점수 입력: '))

#호출부
printScore(korScore, engScore, matScore)

>>>
국어 점수 입력: 10
영어 점수 입력: 10
수학 점수 입력: 10
총점: 30
평균: 10.0

5. 데이터 변환: return

• 함수의 결과를 반환 받아야할 때, return 키워드를 사용한다.
• return 함수를 통해 (선언부에서) 호출부로 다시 변수를 반환할 수 있다.
• 함수가 return을 만나면 실행을 종료한다!

def calculator(n1, n2):
    result = n1 + n2
    return result
    #함수가 return을 만나면 실행을 종료한다.
    print('Hello') #실행 안됨

#return 함수를 통해 다시 호출부로 변수를 반환할 수 있다.
returnValue = calculator(10, 20)
print(f'returnValue: {returnValue}')

#실습하기1: 사용자가 길이(cm)를 입력하면 mm로 환산한 값을 반환하는 함수를 만들어보자.
def cmToMm(cm):
    result = cm * 10
    return result

length = float(input('길이(cm)입력: '))
returnValue = cmToMm(length) #다시 한 번 변수 선언
print(f'returnValue: {returnValue}mm')

#실습하기2
#1부터 100까지의 정수 중에서 홀수인 난수를 반환하는 함수를 선언하자.

import random

def getOddRandomNumber():

	while True:
    rNum = random.randint(1, 100)
    if rNum % 2 != 0: #홀수라면 빠져나오기
    	break
    return rNum

print(f'returnValue: {getOddRandomNumber()}'}

6. 전역변수와 지역변수, global 키워드

1) 전역변수

• 함수 밖에 선언된 변수로 어디에서나 사용은 가능하지만 '함수 안에서 수정할 수는 없다'.
• 수정하려 한다면 새로운 변수가 탄생하게 된다.

num_out = 10 #함수 밖에서 num_out 이라는 변수를 초기화 해준 것
def printNumbers():
    num_out = 20 #윗 줄의 num_out과 전혀 다른 변수
    print(f'num_out: {num_out}')

printNumbers() #num_out: 20

print(f'num_out: {num_out}') #num_out: 10

2) 지역 변수

• 함수 안에 선언된 변수로 함수 안에서만 사용 가능하다.
• 함수 외부에서는 사용할 수 없다.

#지역 변수는 함수 밖에서는 사용할 수 없다.
def printNumbers():
	num_in = 20 #num_in은 함수 안에서 정의된 지역변수
    print(f'num_in: {num_in}')

# printNumber()
print(f'num_in: {num_in}') #따라서 함수 밖에서 따로 호출할 수 없다 -> nameerror 발생

3) global 키워드

• global을 사용하면 함수 안에서도 전역변수의 값을 수정할 수 있다.

num_out = 10 #전역변수
def printNumbers():
    global num_out #global 키워드 사용
    num_out = 20 #활용해서 바꾼다.
    print(f'num_out: {num_out}')

printNumbers() #num_out : 20
print(f'num_out: {num_out}') #num_out : 20

#실습하기1
#사용자가 가로, 세로 길이를 입력하면 삼각형과 사각형의 넓이를 출력하는 함수를 만들어보자.
#선언부
def printArea():
	triangleArea = width * height / 2
    squareArea = width * height
    
    print(f'삼각형의 넓이: {triangleArea}')
    print(f'사각형의 넓이: {squareArea]')
    

#입력 받기
width = int(input('가로 길이 입력: '))
height = int(input('세로 길이 입력: '))
printArea()

#실습하기2
#방문객 수를 카운트 하는 함수를 만들어보자. -> global 키워드 이용!

totalVisit = 0
def countTotalVisit():
    global totalVisit
    totalVisit = totalVisit + 1
    print(f'누적 방문객: {totalVisit}')

countTotalVisit()
countTotalVisit()
countTotalVisit()

>>>
누적 방문객: 1
누적 방문객: 2
누적 방문객: 3

7. 중첩함수

• 중첩함수란?: 함수 안에 또 다른 함수가 있는 형태
• 함수 안에서만 사용이 가능하다.

def out_function():
    print('out_fuction called!')

    def in_function():
        print('in_fuction called!')

    in_function() #밖에서는 출력 불가

out_function()

>>>
out_fuction called!
in_fuction called!

#실습하기: 계산기 만드릭

def calculator(n1, n2, operator):
	
    def addCal():
    	print(f'덧셈 연산: {n1 + n2}')
    
    def subCal():
    	print(f'뺄셈 연산: {n1 - n2}')

    def mulCal():
        print(f'곱셈 연산: {n1 * n2}')

    def divCal():
        print(f'나눗셈 연산: {n1 / n2}')
        
	if operator == 1:
    	addCal()
    elif operator == 2:
    	subCal()
    elif operator == 3:
    	mulCal()
    elif operator == 4:
    	divCal()

#호출부
while True:
	num1 = float(input('실수(n1) 입력: '))
    num2 = float(input('실수(n2) 입력: '))
    operatorNum = int(input('1.덧셈, 2.뺄셈, 3.곱셈, 4.나눗셈, 5.종료'))
    
    if operatorNum == 5:
    	print('Bye~')
        break
    
    calculator(num1, num2, operatorNum)

8. lambda 함수

• lambda 키워드를 이용하면 함수 선언을 보다 간단하게 할 수 있다.
• 형태: lambda 변수1, 변수2 :(콜론) 함수 내부에 있던 식

#기존
def calculator(n1, n2):
    return n1 + n2

returnValue = calculator(10, 20) #변수에 담아주기
print(f'returnValue: {returnValue}')

#lambda 함수
calculator = lambda n1, n2 : n1 + n2 #lambda 변수1, 변수2 :(콜론) 함수 내부에 있던 식

returnValue = calculator(10, 20) #변수에 담아주기
print(f'returnValue: {returnValue}')

#실습하기
#삼각형, 사각형, 원의 넓이를 반환하는 lambda함수를 만들어보자.

getTriangleArea = lambda n1, n2 : n1 * n2 / 2
getSquareArea = lambda n1, n2 : n1 * n2
getCircleArea = lambda r : r*r*3.14

width = int(input('가로 길이 입력: '))
height = int(input('세로 길이 입력: '))
radius = int(input('반지름 길이 입력: '))

triangleValue = getTriangleArea(width, height)
squareValue = getSquareArea(width, height)
circleValue = getCircleArea(radius)

print(f'삼각형 넓이: {triangleValue}')
print(f'사각형 넓이: {squareValue}')
print(f'원 넓이: {circleValue}')

9. 모듈(sample())

• 모듈: 함수가 선언되어 있는(특정 기능을 가지고 있는) 파이썬 파일

• 이미 만들어진 훌륭한 기능으로 사용자는 쉽게 사용할 수 있다.

• 모듈 종류

1. 계산 모듈
2. 난수 모듈
3. 날짜 / 시간 모듈

• 모듈 구분

1. 내부 모듈 -> 파이썬 설치 시 기본적으로 사용할 수 있는 모듈
2. 외부 모듈 -> 별도 설치 후 사용할 수 있는 모듈 ex)pandas
3. 사용자 모듈 -> 사용자가 직접 만든 모듈

• sample(range 함수를 이용한 범위, 난수 몇 개를 발생 시킬 것이냐)

#실습1
#random 모듈을 이용해서 1부터 10까지의 정수 중 난수 1개를 발생시켜 보자.

import random
rNum = random.randint(1, 10)
print(f'rNum: {rNum}')

rNums = random.sample(range(0, 101), 10) #0부터 100까지 10개 출력!
print(f'rNums: {rNums}')

10. 모듈제작(실행)(from ~ import ~ 기능)

#문자열을 거꾸로 반환하는 모듈을 만들어보자.
#'a,b,c,d' 문자열
# 새 문자열 = a + 새 문자열('')
# 새 문자열 = b + 새 문자열('a')
# 새 문자열 = c + 새 문자열('ba')
# 새 문자열 = d + 새 문자열('cba')

def reverseStr(str):
    reversedString = ''
    for i in str:
        reversedString = i + reversedString

    return reversedString

#실행하기
import reverseStr

userInputStr = input('문자열 입력: ')
reversedString = reverseStr.reverseStr(userInputStr)
print(f'reversedString: {reversedString}')

• from 기능: 모듈에서 특정 기능만 사용하겠다.

#계산기 모듈
def add(n1, n2):
    print(f'덧셈 결과: {n1 + n2}')

def sub(n1, n2):
    print(f'뺄셈 결과: {n1 - n2}')

def mul(n1, n2):
    print(f'곱셈 결과: {n1 * n2}')

def div(n1, n2):
    print(f'나눗셈 결과: {n1 / n2}')

#실행하기
from calculator import add
from calculator import sub

add(10, 20)
sub(10, 20)

#실행하기2
from calculator import add, sub
add(10, 20)
sub(10, 20)

• cf) 모든 기능을 가져오겠다.

from calculator import *
add(10, 20)
sub(10, 20)
mul(10, 20)
div(10, 20)

11. 모듈 사용(import ~ as ~)

• as 키워드: 모듈 이름을 단축시킬 수 있다.

#실행하기
import calculator as cal
cal.add(10, 20)
cal.sub(10, 20)
cal.mul(10, 20)
cal.div(10, 20)

#실습하기
#국어, 영어, 수학 점수를 입력하면 총점, 평균을 출력하는 모듈을 만들어보자.
import scores as sc #scores라는 모듈을 불러오고

korScore = int(input('국어 점수 입력: '))
engScore = int(input('영어 점수 입력: '))
matScore = int(input('수학 점수 입력: '))

sc.addScore(korScore)
sc.addScore(engScore)
sc.addScore(matScore)

print(sc.getScores()) #모듈에서 특정 함수 실행, 리스트 가져오기
print(sc.getTotalScore())
print(sc.getAvgScore())

12. ~ 13. 실행(메인) 파일

• 전역변수 name을 이용한 실행파일 지정
• name에는 모듈 이름이 저장되거나 'main'이 저장된다.
• name은 기본적으로 파일 이름이 저장된다.
• 실행(메일) 파일 한정, 파일 이름이 아닌 main으로 이름이 저장된다.
  • addModule.py / name = 'addModule'
  • subModule.py / name = 'subModule'
  • mulModule.py / name = 'mulModule'
  • divModule.py / name = 'divModule'
  • module.py / name = 'main'

• 프로젝트를 하나로 묶었을 때 어떤 파일을 먼저 실행해야 할지 알 수 없다.
• 파이썬 파일은 전역 변수에서 자신의 파이썬 파일 이름이 아닌 main을 먼저 찾는다.

import addModule
import subModule
import mulModule
import divModule

def mod(n1, n2):
    return n1 % n2
    

#실행 파일 일때만 실행해라.
if __name__ == '__main__':
	print(addModule.add(10, 20))
    print(subModule.sub(10, 20))
    print(mulModule.mul(10, 20))
    print(divModule.div(10, 20))

#단위 환산 모듈을 만들고 cm를 mm, inch, m, ft로 변환해보자.
#unit
def cmToMm(n):
	round round(n*10, 3) #소수점 3번째 자리에서 반올림

def cmToInch(n):
    return round(n * 0.393, 3)

def cmToM(n):
    return round(n * 0.01, 3)

def cmToFt(n):
    return round(n * 0.032, 3)

if __name__ = '__main__':
	print(f'10cm: {cmToMm(10)}mm')
    print(f'10cm: {cmToInch(10)}inch')
    print(f'10cm: {cmToM(10)}m')
    print(f'10cm: {cmToFt(10)}ft')

#실행파일
import unit

if __name__ == '__main__':
	inputNumber = int(input('길이(cm) 입력: '))
    
    returnValue = unit.cmToMm(inputNumber)
    print(f'returnValue: {returnValue}mm')

	returnValue = unit.cmToInch(inputNumber)
    print(f'returnValue: {returnValue}inch')

    returnValue = unit.cmToM(inputNumber)
    print(f'returnValue: {returnValue}m')

    returnValue = unit.cmToFt(inputNumber)
    print(f'returnValue: {returnValue}ft')

14. 패키지

• 패키지를 이용하면 관련있는 모듈을 그룹으로 관리할 수 있다.
• 디렉토리 안에 여러 파일

from calculatorForInt import addCal
from calculatorForInt import subCal
from calculatorForInt import mulCal
from calculatorForInt import divCal

print(addCal.add(10, 20))
print(subCal.sub(10, 20))
print(mulCal.mul(10, 20))
print(divCal.div(10, 20))

#실행파일
from calculatorForFloat import addCal
from calculatorForFloat import subCal
from calculatorForFloat import mulCal
from calculatorForFloat import divCal

print(addCal.add(10, 20))
print(subCal.sub(10, 20))
print(mulCal.mul(10, 20))
print(divCal.div(10, 20))

15. site-packages

• site-packages에 있는 모듈은 어디서나 사용할 수 있다.
• 모듈이 많아지면 패키지로 묶어서 사용
• 모듈은 동일한 directory에 있어야 실행이 가능했음 -> 어디서나 범용적으로 사용하고 싶을 때 씀

import sys

for path in sys.path: #모듈이 있는 경로를 나열해주는 값
    print(path)

16. 자주 사용하는 외부 모듈

• 수학, 난수, 시간 모듈은 코딩할 때 유용하게 사용된다.
• math 모듈: 수학 관련 모듈
• random 모듈: 난수 관련 모듈
• time 모듈: 시간 관련 모듈

#수학 관련 함수

#합: sum()
listVar = [2,5,3.14,58,10,2]
print(f'sum(lisVar):{sum(listVar)}')

#최댓값: max()
listVar = [2,5,3.14,58,10,2]
print(f'max(lisVar):{max(listVar)}')

#최솟값: min()
listVar = [2,5,3.14,58,10,2]
print(f'min(lisVar):{min(listVar)}')

#거듭제곱: pow()
print(f'pow(13, 2):{pow(13, 2)}')
print(f'pow(13, 3):{pow(13, 3)}')
print(f'pow(13, 4):{pow(13, 4)}')

#반올림: round()
print(round(1.5)) # 정수 부분이 홀수일 경우: 올림
print(round(2.5)) # 정수 부분이 짝수일 경우: 내림
print(round(3.5))
print(round(4.5))
print(round(5.5))

#math 모듈
import math

#절댓값
print(f'math.fabs(-10): {math.fabs(-10)}')
print(f'math.fabs(-10): {math.fabs(-0.12895)}')

#올림: 소수점 값이 있는 경우 '무조건' 올려서 다음 정수값을 반환한다.
print(f'math.ceil(5.21): {math.ceil(5.21)}')
print(f'math.ceil(5.21): {math.ceil(-5.21)}') #음수에 대한 올림도 가능

#내림: 소수점 값이 있는 경우 소수점을 내림하여 정수값을 반환한다.
print(f'math.floor(5.21): {math.floor(5.21)}')
print(f'math.floor(5.21): {math.floor(-5.21)}')

#버림
print(f'math.trunc(5.21): {math.trunc(5.21)}')
print(f'math.trunc(-5.21): {math.trunc(-5.21)}')

#최대공약수 -> for문 이용도 가능
#math.gcd()
print(f'math.gcd(14, 21): {math.gcd(14, 21)}')

#팩토리얼
print(f'math.factorial(10): {math.factorial(10)}')

#제곱근
print(f'math.sqrt(12): : {math.sqrt(12)}')

---------------------
#time 모듈
import time

lt = time.localtime()
print(f'time.localtime(): {lt}')

print(f'lt.tm_year: {lt.tm_year}')
print(f'lt.tm_mon: {lt.tm_mon}')
print(f'lt.tm_mday: {lt.tm_mday}')
print(f'lt.tm_hour: {lt.tm_hour}')
print(f'lt.tm_min: {lt.tm_min}')
print(f'lt.tm_sec: {lt.tm_sec}')
print(f'lt.tm_wday: {lt.tm_wday}') #요일: 0부터 시작, 금요일이라면 4