Python 중급[2주차-1일] 함수, lambda, 모듈,클래스

이동일·2023년 7월 10일

pandas sql 파이썬

Python

목록 보기

5/10

1. 함수

1-1 함수란?

파이썬 의 함수는 수학의 함수와 동일하다

함수는 파이썬에서 기본 제공하는 내장함수와 사용자가 직접 선언하는 사용자 정의 함수가 있다.

ex) 사용자 정의 함수 예시

함수는 특정 기능을 재사용하기 위해서 사용한다.

def addCal():
    n1 = int(input('n1 입력 : '))
    n2 = int(input('n2 입력 : '))
    print(f'n1 + n2 = {n1 + n2}')
    

addCal()# addCal 을 5번 호출
addCal()
addCal()
addCal()
addCal()

1-2 함수 선언과 호출

1.함수는 def 키워드, 함수명, :, 들여쓰기를 이용해서 선언한다.

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


    print(f'n1 + n2 = {n1 + n2}')

addCal() #들여쓰기에서 정의후 addCal()을 사용하여 함수를 호출하자
addCal()
addCal()




#실습1
#오늘 날씨를 출력하는 함수를 선언하고 3번 호출해보자
def printWeatherInfo():
    print('오늘 날씨는 맑습니다. 기온은 25도입니다.' )

printWeatherInfo()
printWeatherInfo()
printWeatherInfo()






#실습2
#정수 두 개를 입력하면 곱셈과 나눗셈 연산 결과를 출력하는 함수를 만들고 호출해보자.

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함수 사용하여 소수점 2번째 까지 출력한다.

calFuc()
calFuc()
calFuc()

1-3 함수 내에서 또 다른 함수 호출

함수 내에서 또 다른 함수를 호출할 수 있다.
함수도 마찬가지로 pass를 이용해서 실행문을 생략할 수 있다.

#함수 내에서 또 다른 함수 호출
def fun1():
    print('fun1 호출')
    fun2()
    print('fun2 호출 후에 실행!') #제일 마지막에 실행된다  앞전 함수들의 호출을 먼저 출력한뒤 실행 된다.
def fun2():
    print('fun2 호출')
    fun3()

def fun3():
    print('fun3 호출')


fun1()





# pass를 이용해서 실행문 생략
def printTodayWeather():
    pass


def printTomorrowWeather():
    pass

printTodayWeather()
printTomorrowWeather()



#실습 구구단 출력 함수가 연쇄적으로 호출되도록 함수를 선언해보기
def guguDan2 ():
    for i in range(1, 10):
        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()

1-4 인수와 매개변수

함수 호출 시 함수에 데이터를 전달할 수 있다.
인수와 매개변수 개수는 일치해야 한다.
매개변수 개수가 정해지지 않은 경우'*'을 사용!

#함수 호출 시 함수에 데이터를 전달할 수 있다.

#1
def great():
    print('안녕하세요.')

great()



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

greet('홍길동','반착호')   #--> 홍길동 인수




# 인수와 매개변수 개수는 일치해야 한다.
def calculator(n1, n2):
    print(f'{n1} + {n2} = {n1 + n2}')
    print(f'{n1} - {n2} = {n1 - n2}')
    print(f'{n1} * {n2} = {n1 * n2}')
    print(f'{n1} / {n2} = {n1 / n2}')

#calculator(10, 20)  #인수2개 매개변수 2개 정상  작동
calculator(10)# 인수 1개 매개변수 2개 오류
#calculator(10,20,30) #인수 3개 매개변수 2개 오류



#매개변수 개수가 정해지지 않은 경우 '*'을 이용한다.
def printNumber(*numbers):
    # print(type(numbers)) 출력 결과 tuple이다 tuple은 반복 가능한 객체
    for number in numbers:
        print(number, end='')
    print()

printNumber()
printNumber(10)
printNumber(10, 20)
print(10, 20 ,30)

1-5 return 키워드를 이용한 데이터 반환

return 키워드를 이용하면 함수 실행 결과를 호출부로 반환할 수 있다.
함수가 return을 만나면 실행을 종료한다.
(주의!):return 이후의 구문은 실행 하지 않는다.

#return 키워드를 이용하면 함수 실행 결과를 호출부로 반환할 수 있다.
def calculator(n1, n2):
    result = n1 + n2

    return result

# print(calculator(10,20) )#result를 return을 통해서 반환된 결과를 출력해서 30
returnValue = calculator(10, 20)  #return result를 통해서 반환된 결과 30이 출력된다.
print(f'returnValue: {returnValue}')







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

    return result #n1+n2의 결과를 returnValue에 return 반환한다.
    print('Hello') #return 에 의해서 실행이 안된다.

# print(calculator(10,20) )#result를 return을 통해서 반환된 결과를 출력해서 30
returnValue = calculator(10, 20)  #return result를 통해서 반환된 결과 30이 출력된다.
print(f'returnValue: {returnValue}')




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

    return result

length = float(input('길이(cm) 입력:'))
returnValue = cmToMm(length) #31 입력하면 현재 여기엔 310 데이터가 들어있다.
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: {getOddRandomNum

1-6 함수의 지역변수와 전역변수

1.함수 밖에 선언된 변수로 어디에서나 사용은 가능하지만 함수 내부에서 수정 불가 (전역변수)

1-1 함수 내부에 있는 변수와 외부에서 선언된 변수는 다른 존재이다. 함수 내부에 있는 변수는 "지역변수"라고 부르고 외부에 있는 변수를 전역변수 라고 한다.

함수 안에 선언된 변수로 함수 안에서만 사용 가능하다(지역변수)

ex)전역변수

#함수 내 지역변수 예제
def printNumbers():
    num_in = 20
    print(f'num_in:{num_in}')
    
print(f'num_in: {num_in}')  ## --> 지역변수 num_in = 20 을 외부에서 호출할수 없다.








#global 함수를 이용하여 전역변수 값 수정
def printNumbers():
    global num_out
    num_out = 20
    print(f'num_out:{num_out}')

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





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

    print(f'삼각형 넓이: {triangleArea}')
    print(f'사각형 넓이: {squareArea}')

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



#실습2
#방문객 수를 카운트하는 함수를 만들어보기

def countvisit():
    global totalVisit
    totalVisit = totalVisit + 2

    print(f'누적 방문객 : {totalVisit}')

countvisit()
countvisit()
countvisit()
countvisit()

1-7 중첩 함수

함수안에 또 다른 함수가 있는 형태이다.
내부 함수를 함수 밖에서 호출할 수 없다.

#중첩함수(함수안에 또 다른 함수 존재)
def out_funtion():
    print('out_function called!')

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

    in_function()


out_funtion()





# 내부 함수를 함수 밖에서 호출 불가
#(에러발생 내부 변수를 밖에서 출력할려고 했기 때문에 발생한것)
def out_funtion():
    print('out_function called!')
    
    def in_function():
        print('in_function called!!')
        
    in_function()
    
in_function()


#위에 코드 정상작동 할려면 바깥변수 out_function()을 실행

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

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

    in_function()

out_funtion()









#실습1
#calculator()함수를 선언하고 calculator()안에 덧셈, 뺄셈, 곱셈, 나눗셈 함수를 선언하자

def calculator(n1, n2, operator):

    def addCal():
        print(f'덧셈 연산: {round(n1 + n2, 2)}')

    def subCal():
        print(f'뺄셈 연산: {round(n1 - n2, 2)}')

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

    def divCal():
        print(f'나눗셈 연산: {round(n1 / n2, 2)}')


    if operator ==1:
        addCal()

    elif operator == 2:
        subCal()

    elif operator == 3:
        mulCal()

    elif operator ==4:
        divCal()


while True:
    n1 = float(input('실수(n1) 입력 :'))
    n2 = float(input('실수(n2) 입력 :'))
    operator = int(input('1.덧셈,  2.뺄셈,  3.곱셈,  4.나눗셈,  5.종료 '))


    if operator == 5:
        print('종료')
        break
    calculator(n1,n2,operator)

1-8 lambda 함수

람다 키워드를 이용하면 함수 선언을 보다 간단하게 할 수 있다.

#1. 람다 함수 미적용
def calculoator(n1, n2):
    return n1 + n2
    
returnValue = calculoator(10,20)
print(f'returnValue: {returnValue}')




#2. 람다 함수 적용
def calculator(n1, n2):
    return n1 +n2

calculoator = lambda n1, n2: n1 +n2
returnValue = calculoator(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}')

2. 모듈

2-1 모듈

모듈이란, 이미 만들어진 훌륭한 기능으로 사용자는 쉽게 사용할 수 있다.(import math, import random, import datetime)

2.파이썬 모듈은 내부 모듈, 외부 모듈 그리고 사용자 모듈로 구분할 수 있다.

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

#random 모듈 실습

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

import random

rNum = random.randint(1, 10) 
print(f'rNum: {rNum}') #랜덤으로 1개 출력





# random 모듈을 이용해서 0부터 100사이의 난수 10개를 발생시켜 보자

import random

rNums = random.sample(range(1, 101), 10)
print(f'rNums: {rNums}')

2-1 모듈 제작

모듈은 특정 기능을 가지고 있는 파이썬 파일을 말한다

먼저 파이참에서 디렉토리 모듈을 따로 만든다.

2-1. 2-1에서 만든 모듈을 실행 파일을 만들어서 import후 실행한다.

2-2 실행결과

#위처럼 먼저 모듈 파일을 따로 만들고
#코드를 실행할 파일을 따로 만들어야한다.(이때 import 사용)





#실습 
#문자열을 거꾸로 반환하는 모듈을 만들어보자
#모듈 생성
def reverseStr(str):
    reversedString = ''
    for c in str:
        reversedString = c + reversedString
        
    return reversedString





#위에서 만든 모듈 import 사용
import reverseStr

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

2-2 모듈사용

as 키워드를 이용해서 모듈 이름을 단축 시킬 수 있다.
from ~as 키워드를 이용해서 특정 기능만 사용할 수 있다.

#먼저 디렉토리에다가 calculator2 파일을 만든다.
#(앞전 실습이랑 안곂칠려고 calculator2로 만들었다.)

#모듈 만들기1-1
#모듈명 calculator2
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}')
    
    
    
    
    
    
# 모듈 만들기 1-2    
# 모듈 불러오기

import calculator2 as cal 
#calculator2를 cal 줄엿다.

cal.add(10, 20)
cal.sub(10, 20)
cal.mul(10, 20)
cal.div(10, 20)





#from ~as 키워드 이용
#모듈 만들기 1-3
#1-2에서 만든 add,sub를 불러오기
from calculator2 import add
from calculator2 import sub
add(10, 20)
sub(10, 20)
# mul(10,20) #오류 발생 (from calculator2 import mul을 정의하지 않아서 오류)
#--------------------------------------------------------------------






#실습
#국어, 영어, 수학 점수를 입력하면 총점, 평균을 출력하는 모듈을 만들어보자
#모듈생성
scores = []

def addScore(s):
    scores.append(s) #리스트 scores변수를 추가한다

def getScores():
    return scores #

def getTotalScore(): #리스트sores의 점수 합계를 반환한다.
    total = 0
    for s in scores:
        total += s

    return total
    
    
#모듈 불러오기  
import scores as sc

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())

2-3 실행(메인)01

name에는 모듈 이름이 저장되거나 'main'이 저장된다.
addModule.py --> name = 'addModule'
subModule.py --> name = 'subModule'
mulModule.py --> name = 'mulModule'
divModule.py --> name = 'divModule'
module.py --> name = 'main'

#add, div, mul, sub 모듈을 만들어준다.


#sub 모듈
def add(n1, n2):
    return n1 + n2


if __name__ =='__main__':
    print(f'__name__: {__name__}')
#출력하면 실행파일 이기에  __main__이 나온다.
#------------------------------------------





#div 모듈
def div(n1, n2):
    return n1 / n2

# print(f'__name__: {__name__}')
#출력하면 실행파일 이기에  __main__이 나온다.
if __name__ =='__main__':
    print(f'__name__: {__name__}')
#----------------------------------------





#mul 모듈
def mul(n1, n2):
    return n1 * n2

# print(f'__name__: {__name__}')
#출력하면 실행파일 이기에  __main__이 나온다.
if __name__ =='__main__':
    print(f'__name__: {__name__}')
#-------------------------------------------






#div 모듈
def div(n1, n2):
    return n1 / n2

# print(f'__name__: {__name__}')
#출력하면 실행파일 이기에  __main__이 나온다.
if __name__ =='__main__':
    print(f'__name__: {__name__}')
#----------------------------------------------




#실행 모듈

import addModule
import submodule
import mulmodule
import divmodule


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

if __name__ == '__main__': #실행파일 mainn인 경우만 실행

    print(addModule.add(10,20))
    print(submodule.sub(10,20))
    print(mulmodule.mul(10,20))
    print(divmodule.div(10,20))



#여기서 실행하면  각 모듈들이 다음과 같이 출력된다.
# 직접 실행한게 아닌 외부에서 import가 되었기떄문이다.
# __name__: addModule
# __name__: submodule
# __name__: mulmodule
# __name__: divmodule


#출력이 안되게 할려면  각모듈에다가 if문으로 정의해보자
# if __name__ =='__main__':
#     print(f'__name__: {__name__}')

2-4 site_packages

site-packages에 있는 모듈은 어디서나 사용할 수 있다.
1-1 디렉토리 생성후 python 파일만들기
1-2 venv(파이참 안에 가상 환경 폴더에 디렉토리 넣어주기)
경로: venv --> Lib --> site-packages

2-5 자주 사용하는 외부 모듈

1.math 모듈, random 모듈, time 모듈

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


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

# 거듭제곱
print(f'pow(13, 2) : {pow(13, 2)}') #169 출력
print(f'pow(13, 2) : {pow(13, 3)}') #2197


#반올림
print(f'{round(3.141592, 2)}')#소수점둘째 자리까지만 표현(세번째 반환 (버림))
print(f'{round(3.141592, 3)}')#3.142 출력  5에서 1올려가지고 3.141에서 3.142가된다.
print(f'{round(3.141592, 4)}')# 3.1415에서 3.1416출력

print(f'{round(3.141595, 5)}')# 3.14159출력  5번째를 올림해야하는데 맨마지막이 2라서 3.14159그대로출력
#1592에서 1596으로 변경해서 출력하면  3.1416출력 --159에서 16출력




import math
#절대값(fabs)
print(f'math.fabs(-10): {math.fabs(-10)}') #10출력
print(f'math.fabs(-0.12895) : {math.fabs(-0.12895)}')

#올림(ceil)
print(f'math.ceil(5.21): {math.ceil(5.21)}') # 올림 6
print(f'math.ceil(-5.21): {math.ceil(-5.21)}') #올림 -5

#내림(floor)
print(f'math.floor(5.21): {math.floor(5.21)}')#내림 5
print(f'math.floor(-5.21): {math.floor(-5.21)}')#내림 -6



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



#최대공약수(gcd)
print(f'math.gcd(14, 21:){math.gcd(11, 121)}') #최대 공약수 11

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

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








#시간 표현 time.localtime()
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}')

2-7 객체지향 프로그래밍

객체를 이용한 프로그램으로 객체는 속성과 가능으로 구성된다.
객체(Object) = 속성(Attribue) + 기능(Function)

2.객체는 클래스에서 생성된다.
3. 코드 재사용, 모듈화에 좋다.
코드에서는 결합도가 낮아야 유지 보수 확장성에 좋다.

2-8 클래스와 객체 생성

클래스는 class 키워드와 속성(변수) 그리고 기능(함수)를 이용해서 만든다.

2.객체는 클래스의 생성자를 호출한다.

class Car:

    def __init__(self, col, len): #매개변수 (자동차  속성)
        self.color = col
        self.length = len


    def doStop(self): #자동차 기능
        print('Stop!')

    def doStart(self): #자동차 기능
        print('Start')

    def printCarInfo(self):
        print(f'self.color :{self.color}')
        print(f'self.length :{self.length}')



#객체 생성
#여기서 car1과 car2는 서로 연관 없는 객체이다.
car1 = Car('red', 200)
car2 = Car('blue', 300)

car1.printCarInfo()
print('--------')
car2.printCarInfo()

car1.doStop()
car1.doStart()

2-9 객체속성 변경

class NewGenerationPC:

    def __init__(self, name, cpu, memory, ssd):
        self.name = name #객체에 속한 속성이다
        self.cpu = cpu #객체에 속한 속성이다
        self.memory = memory #객체에 속한 속성이다
        self.ssd = ssd #객체에 속한 속성이다


    def doExcel(self):
        print('EXCEL RUN!!')

    def doExcel(self):
        print('Phtoshop run')

    def printPCInfo(self):
        print(f'self.name: {self.name}')
        print(f'self.cpu: {self.cpu}')
        print(f'self.memory: {self.memory}')
        print(f'self.ssd: {self.ssd}')


#클래스로 부터 객체 만들기
#내컴퓨터 사양 출력
myPC = NewGenerationPC('myPc','i5','16G', '256G')
myPC.printPCInfo()

#친구 컴퓨터 사양 출력
print('------------')
friendPc = NewGenerationPC('FriendPc','i7','16G', '512G')
friendPc.printPCInfo()

print('----------------')
#사양 바꾸기
myPC.cpu = 'i9'
myPC.memory = '64G'
myPC.ssd = '1T'
myPC.printPCInfo()

후기

어려워졌다. 강의 듣고 코드를 분석하는데 시간이 너무 오래 걸린다. 제로베이스 오기 전에도 클래스 분야에서 어려움을 느꼈는데 오늘도 여전히 어려웠다. 좀 더 효율적으로 공부를 할 순 없을까 하루 강의 할당량이 너무 많다.... 이런~~!!!!!!!!!
개발자 친형: 그냥해 그냥하면 됨
ㅎㅎㅎㅎㅎ
벨로그 학습 정리를 엄청나게 간추릴 예정이다

(파이썬 강의 이미지는 제로베이스에서 퍼옴)

이동일

이전 포스트

Python[1주차-4일]기초문제풀이3~5

다음 포스트