[제로베이스] 데이터 사이언스 15기 - (05-12 파이썬 중급 스터디노트)

윤태호·2023년 5월 12일
pythonzerobase
0
post-thumbnail

오늘 수강한 강의 - 파이썬 중급 문제풀이 (46 ~ 59)

모듈 46 ~ 52

[1] 합격 여부 출력 모듈

모듈

def exampleResult(s1, s2, s3, s4, s5):
    passAvgScore = 60; limitScore = 40
    def getTotal():
        totalScore = s1 + s2 + s3 + s4 +s5
        print('총점: {}'.format(totalScore))
        return totalScore
    def getAverage():
        avg = getTotal() / 5
        print('평균: {}'.format(avg))
        return avg
    def printPassOrFail():
        print('{}: Pass'.format(s1)) if s1 >= limitScore else print('{}: Fail'.format(s1))
        print('{}: Pass'.format(s2)) if s1 >= limitScore else print('{}: Fail'.format(s2))
        print('{}: Pass'.format(s3)) if s1 >= limitScore else print('{}: Fail'.format(s3))
        print('{}: Pass'.format(s4)) if s1 >= limitScore else print('{}: Fail'.format(s4))
        print('{}: Pass'.format(s5)) if s1 >= limitScore else print('{}: Fail'.format(s5))
    def printFinalPassFail():
        if getAverage() >= passAvgScore:
            if s1 >= limitScore and s2 >= limitScore and s3 >= limitScore and s4 >= limitScore and s5 >= limitScore:
                print('Final Pass!!')
            else:
                print('Final Fail!!')
        else:
            print('Final Fail!!')
    getAverage()
    printPassOrFail()
    printFinalPassFail()

ex.py

import passOrFail as pf
if __name__ == '__main__':
    sub1 = int(input('과목 1 점수 입력: '))
    sub2 = int(input('과목 2 점수 입력: '))
    sub3 = int(input('과목 3 점수 입력: '))
    sub4 = int(input('과목 4 점수 입력: '))
    sub5 = int(input('과목 5 점수 입력: '))
    pf.exampleResult(sub1, sub2, sub3, sub4, sub5)

[2] 상품 구매 개수에 따라 할인율이 결정되는 모듈

모듈

def calculatorTotalPrice(gs):
    if len(gs) <= 0:
        print('구매 상품이 없습니다')
        return
    rate = 25
    totalPrice = 0
    rates = {1:5., 2:10, 3:15, 4:20}
    if len(gs) in rates:
        rate = rates[len[gs]]
    for g in gs:
        totalPrice += g * (1 - rate * 0.01)
    return [rate, int(totalPrice)]

ex.py

import discount as dc
if __name__ == '__main__':
    flag = True
    gs = []
    while flag:
        selectNumber = int(input('1.구매, 2.종료'))
        if selectNumber == 1:
            goods_price = int(input('상품 가격 입력: '))
            gs.append(goods_price)
        elif selectNumber == 2:
            result = dc.calculatorTotalPrice(gs)
            flag = False
    print('할인율: {}%'.format(result[0]))
    print('합계: {}원'.format(result[1]))

[3] 로또 모듈 프로그램

모듈

import random
userNums = []; randNums = []; collNums = []
randBonusNum = 0
def setUserNums(ns):
    global userNums
    userNums = ns
def getUserNums():
    return userNums
def setRandNums():
    global randNums
    randNums = random.sample(range(1, 46), 6)
def getRandNums():
    return randNums
def setBonusNum():
    global randBonusNum
    while True:
        randBonusNum = random.randint(1, 45)
        if randBonusNum not in randNums:
            break
def getBonusNum():
    return randBonusNum
def lottoResult():
    global userNums
    global randNums
    global collNums
    collNums = []
    for un in userNums:
        if un in randNums:
            collNums.append(un)
    if len(collNums) == 6:
        print('1등 당첨!!')
        print('번호: {}'.format(collNums))
    elif (len(collNums) == 5) and (randBonusNum in userNums):
        print('2등 당첨!!')
        print('번호: {}, 보너스 번호: {}'.format(collNums, randBonusNum))
    elif len(collNums) == 5:
        print('3등 당첨!!')
        print('번호: {}'.format(collNums))
    elif len(collNums) == 4:
        print('4등 당첨!!')
        print('번호: {}'.format(collNums))
    elif len(collNums) == 3:
        print('5등 당첨!!')
        print('번호: {}'.format(collNums))
    else:
        print('아쉽습니다. 다음기회에~')
        print('가게 번호: {}'.format(randNums))
        print('보너스 번호: {}'.format(randBonusNum))
        print('선택 번호: {}'.format(userNums))
        print('일치 번호: {}'.format(collNums))
def startLotto():
    n1 = int(input('번호(1~45) 입력: '))
    n2 = int(input('번호(1~45) 입력: '))
    n3 = int(input('번호(1~45) 입력: '))
    n4 = int(input('번호(1~45) 입력: '))
    n5 = int(input('번호(1~45) 입력: '))
    n6 = int(input('번호(1~45) 입력: '))
    selectNums = [n1, n2, n3, n4, n5, n6]
    setUserNums(selectNums)
    setRandNums()
    setBonusNum()
    lottoResult()

ex.py

import lotto as lt
lt.startLotto()

[4] 순열 계산 모듈

모듈

def getPermutationCnt(n, r, logPrint = True):
    result = 1
    for n in range(n, (n-r), -1):
        if logPrint: print('n : {}'.format(n))
        result = result * n
    return result
from itertools import permutations
def getPermutations(ns, r):
    pList = list(permutations(ns, r))
    print('{}P{} 개수: {}'.format(len(ns), r, len(pList)))
    for n in permutations(ns, r):
        print(n, end=', ')
if __name__ == '__main__':
    numN = int(input('numN 입력: '))
    numR = int(input('numR 입력: '))
    print('{}P{}: {}'.format(numN, numR, getPermutationCnt(numN, numR, logPrint=False)))
    ns = [1, 2, 3, 4, 5, 6, 7, 8]
    getPermutations(ns, 3)

ex.py

import permutation as pt
numN = int(input('numN 입력: '))
numR = int(input('numR 입력: '))
listVar = [1, 2, 3, 4, 5, 6, 7, 8]
rVar = 3
pt.getPermutations(listVar, rVar)

[5] 조합 계산 모듈

모듈

def getCombinationCnt(n, r, logPrint = True):
    resultP = 1
    resultR = 1
    resultC = 1
    for n in range(n, (n - r), -1):
        resultP = resultP * n
    if logPrint: 
        print('resultP : {}'.format(resultP))
    for n in range(r, 0, -1):
        resultR = resultR * n
    if logPrint: 
        print('resultR: {}'.format(resultR))
    resultC = int(resultP / resultR)
    if logPrint:
        print('resultC: {}'.format(resultC))
    return resultC
from itertools import combinations
def getCombinations(ns, r):
    cList = list(combinations(ns, r))
    print('{}C{} 개수: {}'.format(len(ns), r, len(cList)))
    for n in combinations(ns, r):
        print(n, end=', ')
if __name__ == '__main__':
    numN = int(input('numN 입력: '))
    numR = int(input('numR 입력: '))
    print('{}C{}: {}'.fomrat(numN, numR, getCombinationCnt(numN, numR, logPrint=False)))
    ns = [1, 2, 3, 4, 5, 6, 7, 8]
    getCombinations(ns, 3)

ex.py

import combination as ct
numN = int(input('numN 입력: '))
numR = int(input('numR 입력: '))
print('{}C{}: {}'.format(numN, numR, ct.getCombinationCnt(numN, numR, logPrint=False)))
listVar = [1, 2, 3, 4, 5, 6, 7, 8]
rVar = 3
ct.getCombinations(listVar, rVar)

[6] (수입과 공과금을 입력하면) 공과금 총액과 수입 대비 공과금 비율을 계산하는 모듈

모듈

income =  0
waterPrice = 0; electricPrice = 0; gasPrice = 0
def setIncome(ic):
    global income
    income = ic
def getIncome():
    return income
def setWaterPrice(wp):
    global waterPrice
    waterPrice = wp
def getWaterPrice():
    return waterPrice
def setElectricPrice(ep):
    global electricPrice
    electricPrice = ep
def getElectricPrice():
    return electricPrice
def setGasPrice(gp):
    global gasPrice
    gasPrice = gp
def getGasPrice():
    return gasPrice
def getUtilityBill():
    result = waterPrice + electricPrice + gasPrice
    return result
def getUtilityBillRate():
    result = getUtilityBill() / getIncome() * 100
    return result

ex.py

import utilityBill as ub
inputIncome = int(input('수입 입력: '))
ub.setIncome(inputIncome)
inputWaterPrice = int(input('수도 요금 입력: '))
ub.setWaterPrice(inputWaterPrice)
inputElectricPrice = int(input('전기 요금 입력: '))
ub.setElectricPrice(inputElectricPrice)
inputGasPrice = int(input('가스 요금 입력: '))
ub.setGasPrice(inputGasPrice)
print('공과금: {}원'.format(ub.getUtilityBill()))
print('수입 대비 공과금 비율: {}%'.format(ub.getUtilityBillRate()))

[7] 패키지와 모듈을 만들고 연산 결과 출력

arithmetic
[basic_operator]

def add(n1, n2):
    return round(n1 + n2, 2)
def sub(n1, n2):
    return round(n1 - n2, 2)
def mul(n1, n2):
    return round(n1 * n2, 2)
def div(n1, n2):
    return round(n1 / n2, 2)

[developer_operator]

def mod(n1, n2):
    return round(n1 % n2, 2)
def flo(n1, n2):
    return round(n1 // n2, 2)
def exp(n1, n2):
    return round(n1 ** n2, 2)

shape
[circle_area]

def calCircleArea(r):
    return round(r ** 2 * 3.14, 2)

[triangle_square_area]

def calTriangleArea(w, h):
    return round(w * h / 2, 2)
def calSquareArea(w, h):
    return round(w * h, 2)

ex.py

from arithmetic import basic_operator as bo
from arithmetic import developer_oerator as do
from shape import triangle_square_area as tsa
from shape import circle_area as ca
inputNumber1 = float(input('숫자1 입력: '))
inputNumber2 = float(input('숫자2 입력: '))
print('{} + {} = {}'.format(inputNumber1, inputNumber2, bo.add(inputNumber1, inputNumber2)))
print('{} - {} = {}'.format(inputNumber1, inputNumber2, bo.sub(inputNumber1, inputNumber2)))
print('{} * {} = {}'.format(inputNumber1, inputNumber2, bo.mul(inputNumber1, inputNumber2)))
print('{} / {} = {}'.format(inputNumber1, inputNumber2, bo.div(inputNumber1, inputNumber2)))
print('{} % {} = {}'.format(inputNumber1, inputNumber2, do.mod(inputNumber1, inputNumber2)))
print('{} // {} = {}'.format(inputNumber1, inputNumber2, do.flo(inputNumber1, inputNumber2)))
print('{} ** {} = {}'.format(inputNumber1, inputNumber2, do.exp(inputNumber1, inputNumber2)))
inputWidth = float(input('가로 길이 입력: '))
inputHeight = float(input('세로 길이 입력: '))
print('삼각형 넓이: {}'.format(tsa.calTriangleArea(inputWidth, inputHeight)))
print('사각형 넓이: {}'.format(tsa.calSquareArea(inputWidth, inputHeight)))
inputRadius = float(input('반지름 입력: '))
print('사각형 넓이: {}'.format(ca.calCircleArea(inputRadius)))

클래스 53 ~ 59

[1] 회원가입 클래스와 회원정보를 관리하는 클래스를 만들고 회원가입 로그인 기능을 구현

클래스

class Member:
    def __init__(self, i, p):
        self.id = i
        self.pw = p
class MemberRepository:
    def __init__(self):
        self.members = {}
    def addMember(self, m):
        self.members[m.id] = m.pw
    def loginMember(self, i, p):
        isMember = i in self.members
        if isMember and self.members[i] == p:
            print('{}: log-in success!!'.format(i))
        else:
            print('{}: log-in fail!!'.format(i))
    def removeMember(self, i, p):
        del self.members[i]
    def printMembers(self):
        for mk in self.members.keys():
            print('ID: {}'.format(mk))
            print('PW: {}'.format(self.members[mk]))

ex.py

import member as mb
mems = mb.MemberRepository()
for i in range(3):
    mId = input('아이디 입력: ')
    mPw = input('비밀번호 입력: ')
    mem = mb.Member(mId, mPw)
    mems.addMember(mem)
mems.printMembers()
mems.loginMember('abc@gmail.com', '1234')
mems.loginMember('def@gmail.com', '5678')
mems.loginMember('ghi@gmail.com', '9012')
mems.removeMember('abc@gmail.com', '1234')
mems.printMembers()

[2] TV 클래스를 상속 구조로 만들고 객체를 생성

클래스

class NormalTv:
    def __init__(self, i=32, c='black', r='full-HD'):
        self.inch = i
        self.color = c
        self.resolution = r
        self.smartTv = 'off'
        self.aiTv = 'off'
    def turnOn(self):
        print('TV power on!!')
    def turnOff(self):
        print('TV power off!!')
    def printTvInfo(self):
        print('inch: {}inch'.format(self.inch))
        print('color: {}'.format(self.color))
        print('resolution: {}'.format(self.resolution))
        print('smartTv: {}'.format(self.smartTv))
        print('aiTv: {}'.format(self.aiTv))
class Tv4k(NormalTv):
    def __init__(self, i, c, r='4k'):
        super().__init__(i, c, r)
    def setSmartTv(self, s):
        self.smartTv = s
class Tv8k(NormalTv):
    def __init__(self, i, c, r='8k'):
        super().__init__(i, c, r)
    def setSmartTv(self, s):
        self.smartTv = s
    def setAiTv(self, a):
        self.aiTv = a
if __name__ == '__main__':
    my4KTv = Tv4k('65', 'silver', '4K')
    my4KTv.setSmartTv('on')
    my4KTv.turnOn()
    my4KTv.printTvInfo()
    my4KTv.turnOff()
    my8KTv = Tv8k('75', 'black', '8K')
    my8KTv.setSmartTv('on')
    my8KTv.setAiTv('on')
    my8KTv.turnOn()
    my8KTv.printTvInfo()
    my8KTv.turnOff()

ex.py

import smartTv as st
my4KTv = st.Tv4k('65', 'silver', '4K')
my4KTv.setSmartTv('on')
my4KTv.turnOn()
my4KTv.printTvInfo()
my4KTv.turnOff()
friend4KTv = st.Tv4k('55', 'white', '4K')
friend4KTv.setSmartTv('off')
friend4KTv.turnOn()
friend4KTv.printTvInfo()
friend4KTv.turnOff()
my8KTv = st.Tv8k('75', 'black', '8K')
my8KTv.setSmartTv('on')
my8KTv.setAiTv('on')
my8KTv.turnOn()
my8KTv.printTvInfo()
my8KTv.turnOff()
friend8KTv = st.Tv8k('86', 'red', '8K')
friend8KTv.setSmartTv('on')
friend8KTv.setAiTv('off')
friend8KTv.turnOn()
friend8KTv.printTvInfo()
friend8KTv.turnOff()

[3] 도서 관리 프로그램

  • 참고 명세서

클래스

class Book:
    def __init__(self, name, price, isbn):
        self.bName = name
        self.bPrice = price
        self.bIsbn = isbn
class BookRepository:
    def __init__(self):
        self.bDic = {}
    def registBook(self, b):
        self.bDic[b.bIsbn] = b
    def removeBook(self, isbn):
        del self.bDic[isbn]
    def printBooksInfo(self):
        for isbn in self.bDic.keys():
            b = self.bDic[isbn]
            print('{}, {}, {}'.format(b.bName, b.bPrice, b.bIsbn))
    def printBookInfo(self, isbn):
        if isbn in self.bDic:
            b = self.bDic[isbn]
            print('{}, {}, {}'.format(b.bName, b.bPrice, b.bIsbn))
        else:
            print('Lookup result does not exist')

ex.py

import book as bk
myBRepository = bk.BookRepository()
myBRepository.registBook(bk.Book('python', 20000, '1234567890'))
myBRepository.registBook(bk.Book('java', 25000, '852147963'))
myBRepository.registBook(bk.Book('c/c++', 27000, '951378624'))
myBRepository.registBook(bk.Book('javascript', 15000, '9874563254'))
myBRepository.printBooksInfo()
myBRepository.printBookInfo('1234567890')
myBRepository.removeBook('1234567890')
myBRepository.printBooksInfo()
friendBRepository = bk.BookRepository()
friendBRepository.registBook(bk.Book('python', 10000, '1234567890'))
friendBRepository.registBook(bk.Book('java', 15000, '852147963'))
friendBRepository.registBook(bk.Book('c/c++', 17000, '951378624'))
friendBRepository.registBook(bk.Book('javascript', 5000, '9874563254'))
friendBRepository.printBooksInfo()
friendBRepository.printBookInfo('1234567890')
friendBRepository.removeBook('1234567890')
friendBRepository.printBooksInfo()

[4] 추상 클래스를 이용하여 한/영 사전 클래스 만들기

클래스

from abc import ABCMeta
from abc import abstractmethod
class AbsDictionary(metaclass=ABCMeta):
    def __init__(self):
        self.wordDic = {}
    @abstractmethod
    def registWord(self, w1, w2):
        pass
    @abstractmethod
    def removeWord(self, w1):
        pass
    @abstractmethod
    def updateWord(self, w1, w2):
        pass
    @abstractmethod
    def searchWord(self, w1):
        pass
class KorToEng(AbsDictionary):
    def __init__(self):
        super().__init__()
    def registWord(self, w1, w2):
        print('[KorToEng] registWord() : {} to {}'.format(w1, w2))
        self.wordDic[w1] = w2
    def removeWord(self, w1):
        print('[KorToEng] removeWord() : {}'.format(w1))
        del self.wordDic[w1]
    def updateWord(self, w1, w2):
        print('[KorToEng] updateWord() : {} to {}'.format(w1, w2))
        self.wordDic[w1] = w2
    def searchWord(self, w1):
        print('[KorToEng] searchWord() : {}'.format(w1))
        return self.wordDic[w1]
    def printWords(self):
        for k in self.wordDic:
            print('{} : {}'.format(k, self.wordDic[k]))
class KorToJpa(AbsDictionary):
    def __init__(self):
        super().__init__()
    def registWord(self, w1, w2):
        print('[KorToJpa] registWord() : {} to {}'.format(w1, w2))
        self.wordDic[w1] = w2
    def removeWord(self, w1):
        print('[KorToJpa] removeWord() : {}'.format(w1))
        del self.wordDic[w1]
    def updateWord(self, w1, w2):
        print('[KorToJpa] updateWord() : {} to {}'.format(w1, w2))
        self.wordDic[w1] = w2
    def searchWord(self, w1):
        print('[KorToJpa] searchWord() : {}'.format(w1))
        return self.wordDic[w1]
    def printWords(self):
        for k in self.wordDic:
            print('{} : {}'.format(k, self.wordDic[k]))

ex.py

import ADictionary as dic
kTe = dic.KorToEng()
kTe.registWord('책', 'bok')
kTe.registWord('나비', 'butterfly')
kTe.registWord('연필', 'pencil')
kTe.registWord('학생', 'student')
kTe.registWord('선생님', 'teacher')
kTe.updateWord('책', 'book')
kTe.updateWord('학생', 'studen')
print('책 : {}'.format(kTe.searchWord("책")))
print('나비 : {}'.format(kTe.searchWord("나비")))
print('연필 : {}'.format(kTe.searchWord("연필")))
print('학생 : {}'.format(kTe.searchWord("학생")))
print('선생님 : {}'.format(kTe.searchWord("선생님")))

[5] 주사위 게임 클래스 (컴퓨터와 사용자의 게임 결과 출력)

클래스

import random as rd
class Dice:
    def __init__(self):
        self.cNum = 0
        self.uNum = 0
    def setCnum(self):
        print('[Dice] steCnum()')
        self.cNum = rd.randint(1, 6)
    def setUnum(self):
        print('[Dice] steUnum()')
        self.uNum = rd.randint(1, 6)
    def startGame(self):
        print('[Dice] startGame()')
        self.setCnum()
        self.setUnum()
    def printResult(self):
        print('[Dice] printResult()')
        if self.cNum == 0 or self.uNum == 0:
            print('주사위 숫자 설정 전 입니다.')
        else:
            if self.cNum > self.uNum:
                print('컴퓨터 vs 유저 : {} vs {} >> 컴퓨터 승!!'.format(self.cNum, self.uNum))
            elif self.cNum < self.uNum:
                print('컴퓨터 vs 유저 : {} vs {} >> 유저 승!!'.format(self.cNum, self.uNum))
            elif self.cNum == self.uNum:
                print('컴퓨터 vs 유저 : {} vs {} >> 무승부!!'.format(self.cNum, self.uNum))

ex.py

import dice
dc = dice.Dice()
dc.startGame()
dc.printResult()

[6] 자동차 경주 게임 클래스

  • (자동차는 랜덤하게 이동하며, 편의상 10초 동안 주행한다고 할 때 가장 멀리 이동한 자동차가 우승하는 게임)

Car 클래스

import random
class Car:
    def __init__(self, n='fire car', c='red', s=200):
        self.name = n
        self.color = c
        self.max_speed = s
        self.distance = 0
    def printCarInfo(self):
        print('name: {}, color: {}, max_speed: {}'.format(self.name, self.color, self.max_speed))
    def controlSpeed(self):
        return random.randint(0, self.max_speed)
    def getDistanceForHour(self):
        return self.controlSpeed() * 1

CarRacing 클래스

from time import sleep
class CarRacing:
    def __init__(self):
        self.cars = []
        self.rankings = []
    def startRacing(self):
        for i in range(10):
            print('Racing: {}바퀴'.format(i+1))
            for car in self.cars:
                car.distance += car.getDistanceForHour()
            sleep(1)
    def printCurrentCarDistance(self):
        for car in self.cars:
            print('{}: {}\t\t'.format(car.name, car.distance), end='')
        print()
    def addCar(self, c):
        self.cars.append(c)

ex.py

from car_game import racing as rc
from car_game import car
myCarGame = rc.CarRacing()
car01 = car.Car('Car01', 'white', 250)
car02 = car.Car('Car02', 'black', 200)
car03 = car.Car('Car03', 'yellow', 220)
car04 = car.Car('Car04', 'red', 280)
car05 = car.Car('Car05', 'blue', 150)
myCarGame.addCar(car01)
myCarGame.addCar(car02)
myCarGame.addCar(car03)
myCarGame.addCar(car04)
myCarGame.addCar(car05)
myCarGame.startRacing()

[7] mp3 플레이어 클래스 (노래 등록 후 재생)

Song 클래스

import random
from time import sleep
class Song:
    def __init__(self, t, s, pt):
        self.title = t
        self.singer = s
        self.play_time = pt
    def printSongInfo(self):
        print('Title: {}, Singer: {}, Play time: {}'.format(self.title, self.singer, self.play_time))

Player 클래스

class Player:
    def __init__(self):
        self.songList = []
        self.isLoop = False
    def addSong(self, s):
        self.songList.append(s)
    def play(self):
        if self.isLoop:
            while self.isLoop:
                for s in self.songList:
                    print('Title: {}, Singer: {}, Play time: {}sec'.format(s.title, s.singer, s.play_time))
                    sleep(s.play_time)
        else:
            for s in self.songList:
                print('Title: {}, Singer: {}, Play time: {}sec'.format(s.title, s.singer, s.play_time))
                sleep(s.play_time)
    def suffle(self):
        random.shuffle(self.songList)
    def setIsLoop(self, flag):
        self.isLoop = flag

ex.py

import mp3player as mp3
s1 = mp3.Song('기다려', '구원찬', 3)
s2 = mp3.Song('Long Time No', '구원찬', 4)
s3 = mp3.Song('Restless', 'BIBI', 2)
s4 = mp3.Song('Bye bye my blue', '백예린', 5)
s5 = mp3.Song('Another One', 'Mac Demarco', 4)
player = mp3.Player()
player.addSong(s1)
player.addSong(s2)
player.addSong(s3)
player.addSong(s4)
player.addSong(s5)
player.setIsLoop(False)
player.suffle()
player.play()

총평

재미있었던 부분

클래스를 만들어서 상속시키고 ex.py 파일에서 실행시키면 프로그램이 돌아가는것이 가장 재미있는 부분이었다
여러 문제풀이로 해보니 큰 틀은 이해가 좀 가는 느낌이다

어려웠던 부분

모듈은 여전히 어려운 것 같다
오늘 해본 모듈 관련 문제풀이가 대부분 수학과 관련된 것들이 많아서 그런가 조금 헷갈리고 멈칫하는 부분이 많았다

느낀점 및 내일 학습 계획

완벽하다는 느낌은 아니어도 큰 틀들이 조금씩 이해가 되는 느낌이다
오늘 했던 OT에서도 매니저님이 말씀하셨듯이 너무 꼼꼼히 하려하지말고 손으로 코드를 직접 짜보고 이해하며 익히는 것에 중점을 두려고한다

profile
윤태호
데이터 부트캠프 참여중
이전 포스트

[제로베이스] 데이터 사이언스 15기 - (05-11 파이썬 중급 스터디노트)

다음 포스트

[제로베이스] 데이터 사이언스 15기 - (05-15 파이썬 중급 스터디노트)

0개의 댓글