스터디노트(Python 중급1~4)

zoe·2023년 3월 8일
python
0

함수란 ?

  • 함수에 들어온 데이터를 입력하여 연산(기능)을 수행하여 결과 반환
  • 내장 함수 : 기본적으로 제공하는 함수
  • 사용자 함수 : 사용자가 직접 선언하는 함수
  • 특정 기능을 재사용하기(반복적으로 사용하기) 위해서 사용
def addFun(x,y) :
    return x + y

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

addCal()
addCal()
addCal()
addCal()
addCal()

함수 선언과 호출

  • 함수는 def 키워드, 함수명, ':', 들여쓰기를 이용해서 선언
  • 함수명과 '()'를 이용해서 함수를 호출
  • 함수 선언만 하고 호출하지 않으면 동작하지 않음, 호출해야만 동작함
def addCal():
    n1 = int(input('n1 입력 : '))
    n2 = int(input('n1 입력 : '))
    print(f'n1 + n2 = {n1 + n2}')
    
addCal()
def printWeatherInfo():
    print('오늘 날씨는 맑습니다. 기온은 25도 입니다.')

printWeatherInfo()
printWeatherInfo()
printWeatherInfo()
  • 실습

    정수 두 개를 입력하면 곱셈과 나눗셈 연산 결과를 출력하는 함수를 만들고 호출

# 정수 두 개를 입력하면 곱셈과 나눗셈 연산 결과를 출력하는 함수를 만들고 호출

def calFun():
    n1 = int(input('n1 입력 : '))
    n2 = int(input('n2 입력 : '))
    print('n1 * n2 = {}' .format(n1 * n2))
    print(f'n1 / n2 = {round(n1 / n2,2)}')
calFun()

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

  • 함수 내에서 또 다른 함수 호출 가능
  • pass를 이용해서 실행문 생략 가능
def fun1():
    print('fun1 호출!')
    fun2()

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

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

fun1()
def printTodayWeather():
    pass
def printTomorrowWeather():
    pass

printTodayWeather()
printTodayWeather()
  • 실습

    다음과 같이 구구단 출력 함수가 연쇄적으로 호출되도록 함수를 선언

#  다음과 같이 구구단 출력 함수가 연쇄적으로 호출되도록 함수를 선언
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()

guguDan2()

인수와 매개변수

  • 함수 호출 시 함수에 데이터를 전달 할 수 있다
  • 인수와 매개변수 개수는 일치해야 함
  • 💡 매개변수 개수가 정해지지 않은 경우 '*'를 이용
def greet(customer):
    print('{} 고객님 안녕하세요' .format(customer))

greet('홍길동')
greet('박찬호')
def greet2(customer1, customer2):
    print('{}, {} 고객님 안녕하세요' .format(customer1, customer2))

greet2('박찬호', '홍길동')
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(5,6)
def printNumber(*numbers):
    for number in numbers:
        print(number, end='')
    print()

printNumber()
printNumber(1)
printNumber(1,2)
printNumber(1,2,3)
printNumber(1,2,3,4)
printNumber(1,2,3,4,5)
  • 실습

    국어, 영어, 수학 점수를 입력받고, 입력받은 점수를 이용해서 총점과 평균을 출력하는 함수를 생성

# 국어, 영어, 수학 점수를 입력받고, 입력받은 점수를 이용해서 총점과 평균을 출력하는 함수를 생성

def printScore(kor, eng, mat):
    sum = kor + eng + mat
    avg = sum / 3

    print(f'총점 : {sum}')
    print(f'평균 : {round(avg,2)}')

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

printScore(korScore, engScore, matScore)

데이터 변환

  • return 키워드를 이용하면 함수 실행 결과를 호출부로 반환할 수 있다
  • 함수가 return을 만나면 실행 종료한다
def calculator(n1, n2):
    print(n1 + n2)

calculator(10,20)


def calculator2(n1, n2):
    result = n1 + n2
    return result
returnValue = calculator2(10,20)
print(returnValue)
def divideNumber(n):
    if n % 2 == 0:
        return '짝수'
    else:
        return  '홀수'
returnValue = divideNumber(5)
print(f'returnValue : {returnValue}')
  • 실습

    사용자가 길이(cm)를 입력하면 mm로 환산한 값을 반환하는 함수를 생성

# 사용자가 길이(cm)를 입력하면 mm로 환산한 값을 반환하는 함수를 생성

def cmToMm(cm):
    result = cm * 10
    return result

length = float(input('길이(cm) 입력 : '))
returnValue = cmToMm(length)
print(f'returnValue : {returnValue}mm')
  • 실습

    💡 1부터 100까지의 정수 중에서 홀수인 난수를 반환하는 함수를 선언

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

import random

def getOddRandomNumber():
    while True:
        rNum = random.randint(1,100)
        if rNum % 2 != 0:
            break
    return rNum

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

지역변수와 전역변수

  • 전역변수 : 함수 밖에서 선언된 변수
  • 지역변수 : 함수 안에서 선언된 변수
  • 💡 함수 밖에 선언된 변수로 어디에서나 사용은 가능하지만 함수 안에서는 수정할 수 없다 (함수 밖에서 선언된 변수를 함수 안에서 값을 수정하더라도 함수 밖에서는 먼저 밖에서 선언된 값이 적용됨)
  • 함수 안에서 선언된 변수는 함수 안에서만 사용 가능
  • global 을 사용하면 함수 안에서도 전역변수의 값을 수정 가능
num_out = 10
def printNumber():
    num_out = 20 #함수 안에 새로 생성된 num_out임, 함수 안에서만 사용 가능
    print(f'num_out : {num_out}')

print(printNumber())
print(f'num_out : {num_out}')
def printNumber2():
    num_in = 20
    print(f'num_in : {num_in}')

printNumber2()
num_out = 10
def printNumber3():
    global num_out # ★
    num_out = 20
    print(f'num_out : {num_out}')

printNumber3()
print(f'num_out : {num_out}')
  • 실습

사용자가 가로, 세로 길이를 입력하면 삼각형과 사각형의 넓이를 출력하는 함수를 생성

# 사용자가 가로, 세로 길이를 입력하면 삼각형과 사각형의 넓이를 출력하는 함수를 생성

def printArea():
    triangleArea = (width * height) / 2
    squareArea = width * height

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

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

방문객 수를 카운트하는 함수 생성

# 방문객 수를 카운트하는 함수 생성

totalVisit = 0

def countTotalVisit():
    global totalVisit

    totalVisit = totalVisit + 1
    print('누적 방문객 : {}' .format(totalVisit))

countTotalVisit()
countTotalVisit()
countTotalVisit()
countTotalVisit()
countTotalVisit()

중첩함수

  • 함수 안에 또 다른 함수가 있는 형태
  • 내부 함수를 밖에서 호출할 수 없음
def out_funcion():
    print('out_function called!!')

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

    in_function()

out_funcion()
  • 실습

💡 calculator()함수를 선언하고 calculator() 안에 덧셈, 뺄셈, 곱셈, 나눗셈 함수를 선언

# 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:
    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)

💡 lambda 함수

  • lambda 키워드를 사용하면 함수 사용을 보다 간단하게 사용 가능
  • 실습

    삼각형, 사각형, 원의 넓이를 반환하는 lambda함수 생성

# 삼각형, 사각형, 원의 넓이를 반환하는 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'삼각형 넓이 : {round(triangleValue,2)}')
print(f'사각형 넓이 : {round(squareValue,2)}')
print(f'원 넓이 : {round(circleValue,2)}')

모듈

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

    ramdom 모듈을 이용해서 1부터 10까지의 정수 중 난수 1개를 발생시키기

# ramdom 모듈을 이용해서 1부터 10까지의 정수 중 난수 1개를 발생시키기

import random

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

ramdom 모듈을 이용해서 0부터 100사이의 난수 10개를 발생시키기

# ramdom 모듈을 이용해서 0부터 100사이의 난수 10개를 발생시키기

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

rNum = random.sample(range(0, 100),10) # sample : 난수 생성, sample(범위(range), 개수)
print(f'rNum : {rNum}')

모듈제작

  • 모듈 : 특정 기능을 가지고 있는 파이썬 파일
# calculator파일 
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}')
import calculator

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

로또 번호(6개)를 출력하는 모듈 생성

# lottoMachine 파일
import random

def getlottoNumbers():
    result = random.sample(range(1,46),6)
    return result
#로또 번호(6개)를 출력하는 모듈 생성
import lottoMachine

lottoNumbers = lottoMachine.getlottoNumbers()
print(f'lottoNumbers : {lottoNumbers}')
  • 실습

💡 문자열을 거꾸로 반환하는 모듈을 생성

# reverseStr 파일
def reversStr(str):
    reversString = ''

    for c in str:
        reversString = c + reversString # 새로운 글자가 앞으로 들어옴 ex) c + ba...

    return reversString
# 문자열을 거꾸로 반환하는 모듈을 생성

import reverseStr

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

💡 모듈사용

  • import 키워드를 이용해서 모듈을 임포트한다
  • as 키워드를 이용해서 모듈 이름 단축 가능
  • from ~ import 키워드를 이용해서 모듈의 특정 기능만 사용 가능 (모듈의 이름을 적지 않아도 된다)
    - from ~ import * : 전체 모듈을 가져올 수 있음
    - from ~ import A, B... : 한 번에 import를 할 때 여러 개의 기능을 가져올 수 있음
import calculator

calculator.add(10, 20)
calculator.sub(10, 20)
calculator.mul(10, 20)
calculator.div(10, 20)
import  calculator as cal

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

add(10, 20) # 모듈의 이름을 적지 않아도 된다 ★
sub(10, 20)
  • 실습

💡 국어, 영어, 수학 점수를 입력하면 총점, 평균을 출력하는 모듈을 생성

# scores 파일
scores = []

def addScore(s):
    scores.append(s) # append() : 리스트 끝에 x 1개를 그대로 넣음(모양 그대로) ★

def getScore():
    return scores

def getTotalScore():
    total = 0
    for s in scores:
        total += s
    return total

def getAvgScore():
    avg = getTotalScore() / len(scores)
    return avg
# 국어, 영어, 수학 점수를 입력하면 총점, 평균을 출력하는 모듈을 생성

import scores as sc

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

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

print(sc.getScore())
print(sc.getTotalScore())
print(sc.getAvgScore())

💡 실행(메인) 파일

  • name 에는 모듈 이름이 저장, 되거나 'main'이 저장된다.
  • 실행파일의 경우 name에 'main'이 저장된다
    - 실행파일 : 여러 개의 파이썬 파일을 만들었을 때 가장 먼저 실행할 파일
  • 실습

    단위 환산 모듈을 만들고 cm를 mm, inch, m, ft로 변환

# uniConversion 파일
def cmToMm(n):
    return round(n*10,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')
# 단위 환산 모듈을 만들고 cm를 mm, inch, m, ft로 변환

import unitConversion as uc

if __name__ == '__main__' :
    inputNumber = int(input('길이(cm) 입력 : '))

    returnValue = uc.cmToMm(inputNumber)
    print(f'returnValue : {returnValue}mm')

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

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

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

💡 패키지

  • 패키지를 이용하면 관련 있는 모듈을 그룹으로 관리 가능
  • 모듈의 기능을 디렉토리별로 정리해 놓은 것
  • (사용자가 만들 경우 동일한 경로의 디렉토리의 패키지를 사용 가능)

💡 site-packages

  • site-package : 해당 경로 안에 있으면 어디서나 패키지 사용이 가능
  • 실습

💡 site-packages에 약수와 소수를 리스트로 반환하는 모듈을 생성

# divisor_pac 디렉토리 파일 

# def divisor(inputNumber):
#     temp = []
#     for i in range(1, inputNumber+1):
#         if inputNumber % i == 0 :
#             temp.append(i)
#     return temp
#
# def prime_number(inputNumber): # https://codingpractices.tistory.com/entry/Python-%EC%86%8C%EC%88%98-%EC%B0%BE%EA%B8%B0-%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98
#     temp = []
#     for i in range(2,inputNumber+1) :
#         count = 0
#         for j in range(2, i+1) :
#             if i % j == 0:
#                 count += 1
#         if count == 1:
#             temp.append(i)
#     return temp

def divisor(inputNumber):
    result = []
    for number in range(1, (inputNumber + 1)):
        if inputNumber % number == 0:
            result.append(number)

    return result



def prime_number(inputNumber):
    result = []
    for number in range(2, (inputNumber + 1)):
        flag = True
        for n in range(2, number):
            if number % n == 0:
                flag = False
                break

        if (flag):
            result.append(number)

    return result

from divisor_pac import divisor_mod as dm

print('10의 약수 : {}' .format(dm.divisor(10)))
print('50까지의 소수 : {}' .format(dm.prime_number(50)))

💡 자주 사용하는 모듈

  • 수학 관련 모듈 (math 모듈)
  • 난수 관련 모듈 (random 모듈)
  • 시간 관련 모듈 (time 모듈)
# 수학 관련 함수
# 합
import random

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

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

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

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

# 반올림
print(f'round(3.141592, 1): {round(3.141592, 1)}')
print(f'round(3.141592, 2): {round(3.141592, 2)}')
print(f'round(3.141592, 3): {round(3.141592, 3)}')
print(f'round(3.141592, 4): {round(3.141592, 4)}')
print(f'round(3.141592, 5): {round(3.141592, 5)}')



# math 모듈
import math

#절댓값
print(f'math.fabs(-10): {math.fabs(-10)}')
print(f'math.fabs(-0.12895): {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)}')

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

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

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


# random 모듈

# 0이상 1미만 난수
print(f'random.random(): {random.random()}')

# 1이상 20이하 난수
print(f'random.randint(1, 20): {random.randint(1, 20)}')

# 1이상 20미만 난수
print(f'random.randrange(1, 20): {random.randrange(1, 20)}')

# 1이상 21미만 난수 5개
print(f'random.sample(range(1, 21), 5): {random.sample(range(1, 21), 5)}')

# 무작위 한개 추출
listVar = [0, 1, 2, 3, 4, 5, 6]
print(f'random.choice(listVar): {random.choice(listVar)}')

# 섞음
print(f'listVar: {listVar}')
random.shuffle(listVar)
print(f'shuffle listVar: {listVar}')


# 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}')

💡 객체지향 프로그래밍

  • 객체(Object) = 속성(Attribute) + 기능(Function) (객체는 속성과 기능으로 구성)
  • 객체는 클래스에서 생성된다
  • 코드 재사용, 모듈화에 좋다

💡 클래스와 객체 생성

  • 클래스는 class 키워드와 속성(변수), 기능(함수)를 이용해서 만든다
  • 객체는 클래스의 생성자를 호출한다
class Car:

    def __init__(self, col, len): # 생성자, 속성
        self.color = col  # 초기화
        self.length = len

    def doStop(self): # 기능, 매개변수를 self로 받아야 함
        print('STOP!!')

    def doStart(self):
        print('START!!')

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


car1 = Car('red',200)
car2 = Car('blue', 300)

car1.printCarInfo()
car2.printCarInfo()
  • 실습

    행기 클래스를 만들고 비행기 객체 5개를 생성

# 비행기 클래스를 만들고 비행기 객체 5개를 생성
class Airplane:

    def __init__(self, col, len, wei):
        self.color = col
        self.length = len
        self.weight = wei

    def takeOff(self):
        print('이륙!')

    def laning(self):
        print('착륙')

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


airplane1 = Airplane('red',200,2000)
airplane2 = Airplane('blue',150,2200)
airplane3 = Airplane('green',180,2100)
airplane4 = Airplane('white',220,1900)
airplane5 = Airplane('black',210,2300)

airplane1.printAirplaneInfo()
airplane2.printAirplaneInfo()
airplane3.printAirplaneInfo()
airplane4.printAirplaneInfo()
airplane5.printAirplaneInfo()

객체 속성 변경

  • 객체 속성은 변경할 수 있다
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 doPhotoshop(self):
        print('PHOTOSHOP 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()
friendPC = NewGenerationPC('friendPC','i7','32G','512G')
friendPC.printPCInfo()

myPC.cpu = 'i9'
myPC.memory = '64G'
myPC.ssd = '1T'
myPC.printPCInfo()
  • 실습

    계산기 클래스를 만들고 사칙연산을 실행

# 계산기 클래스를 만들고 사칙연산을 실행

class Calculator:
    def __init__(self):
        self.number1 = 0
        self.number2 = 0
        self.result = 0

    def add(self):
        self.result = self.number1 + self.number2
        return self.result
    def sub(self):
        self.result = self.number1 - self.number2
        return self.result
    def mul(self):
        self.result = self.number1 * self.number2
        return self.result
    def div(self):
        self.result = self.number1 / self.number2
        return self.result

    def printCalculator(self):
        print('calculator.add() : {}'.format(self.add()))
        print('calculator.sub() : {}'.format(self.sub()))
        print(f'calculator.sub() : {self.mul()}')
        print(f'calculator.sub() : {self.div()}')

math1 = Calculator()
math1.number1 = 10
math1.number2 = 20
math1.printCalculator()

math1.number1 = 3
math1.number2 = 5
math1.printCalculator()

💻 출처 : 제로베이스 데이터 취업 스쿨

profile
zoe
#데이터분석 #퍼포먼스마케팅 #데이터 #디지털마케팅
이전 포스트

😢 스터디노트(Python 기초 문제풀이)

다음 포스트

스터디노트(Python 중급5~7)

0개의 댓글