016. 자주 사용하는 모듈
기본적으로 알아두면 좋은 모듈
- 자주 사용하는 모듈
- 수학(math), 난수(random), 시간(time)모듈은 코딩할 때 유용하게 사용된다
#수학 관련 함수
#합
listVar = [2, 5, 3.14, 58, 10, 2] #리스트의 전체적인 합 구하려면
print(f'sum(listVar): {sum(listVar)}') #sum이 리스트 아이템 다 더해줌
#최댓값
listVar = [2, 5, 3.14, 56, 10, 2]
print(f'max(listVar): {max(listVar)}')
#최솟값
listVar = [2, 5, 3.14, 56, 10, 2]
print(f'min(listVar): {min(listVar)}')
#거듭제곱
listVar = [2, 5, 3.14, 56, 10, 2]
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)}')
print(f'{round(3.141592, 2)}')
print(f'{round(3.141592, 3)}')
print(f'{round(3.141592, 4)}')
print(f'{round(3.141592, 5)}')
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)}')
-->
sum(listVar): 80.14
max(listVar): 56
min(listVar): 2
pow(13, 2): 169
pow(13, 3): 2197
pow(13, 4): 28561
3.1
3.14
3.142
3.1416
3.14159
math.fabs(-10): 10.0
math.fabs(-0.12895): 0.12895
math.ceil(5.21): 6
math.ceil(-5.21): -5
math.floor(5.21): 5
math.floor(-5.21): -6
math.trunc(5.21): 5
math.trunc(-5.21): -5
math.gcd(14, 21) : 7
math.factorial(10) : 3628800
math.sqrt(4) : 2.0
math.sqrt(12) : 3.4641016151377544--
# 시간 관련 함수
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_mon() : {lt.tm_mon}')
print(f'lt.tm_hour() : {lt.tm_hour}')
print(f'lt.tm_min() : {lt.tm_min}')
print(f'lt.tm_sec() : {lt.tm_sec}')
-->
time.localtime() : time.struct_time(tm_year=2023, tm_mon=10, tm_mday=21, tm_hour=15, tm_min=46, tm_sec=15, tm_wday=5, tm_yday=294, tm_isdst=0)
lt.tm_year() : 2023
lt.tm_mon() : 10
lt.tm_mday() : 21
lt.tm_mon() : 10
lt.tm_hour() : 15
lt.tm_min() : 46
lt.tm_sec() : 15
017. 객체지향 프로그래밍
객체를 이용한 프로그램으로, 객체는 속성과 기능으로 구성된다.
현존하는 모든 프로그래밍 언어는 객체지향
- 객체지향 프로그래밍
- 객체를 이용한 프로그램으로 객체는 속성과 기능으로 구성된다.
- 일상의 계산기
-속성: 숫자
-기능: 덧셈, 뺄셈 ...
즉, 가상의 계산기를 프로그래밍할 때도 속성과 기능을 생각해야한다. - 자동차
-속성: 색상, 길이, 가격
-기능: 전진, 후진, 정지 ... - 객체(object) = 속성(attribute) + 기능(function)
- 객체 만들기(생성)
- 객체는 클래스에서 생성된다.
- 클래스를 만들때 속성과 기능을 정의하면된다.
- 클래스: 객체 만들기 위한 하나의 틀
->명령(생성자 호출)
-> 붕어빵틀을 통해 붕어빵을 무한대로 생성하듯, 클래스로부터 객체를 무한대로 생성가능하다.
-> 이렇게 생성된 객체들을 통해 프로그램이 돌아간다.
- 객체사용의 장점
- 코드 재사용, 모듈화에 좋다
- 자동차A(배터리 일체형)
= 부품 결합도가 높다.
= 자동차와 배터리가 붙어있어서 수명을 다하면, 교체도 충전도 어려워서 버리고 새로운 자동차를 생산해야함.
= 소프트웨어에서 안 좋은 방법. - 자동차B(배터리 교체형)
= 부품 결합도가 낮다.
= 배터리만 버리고 새로운 걸 꽂으면 됨.
= 소프트웨어적으로 가장 이상적인 방법.
= 기능, 부품을 모듈화해서 언제든 교체가능 - 자동차C(배터리 충전형)
= 부품 결합도 높은
= 충전에 기다리는 시간이 소요됨.
= A < C < B
018. 클래스와 객체 생성
객체를 이용한 프로그램으로, 객체는 속성과 기능으로 구성된다.
- 클래스 만들기.
- 클래스는 class키워드와, 속성(변수), 기능(함수)를 이용해서 만든다.
객체를 만들기 위한 것. 선언만 했다고 기능실행되지는 않음.
class Car: #'클래스선언' #class의 이름 첫글자는 대문자로
def __init__(self, col, ilen): #'생성자, 속성(변수)'
self.color = col #self = 나 자신 = Car #속성 마음대로 정하면 됨
self.length = len()
def doStop(self): #'기능(함수)' #매개변수->self = Car라는 클래스 안에 포함된 기능이라는 뜻
print('stop')
def doStart(self):
print('start')- 객체생성
- 객체는 클래스의 생성자를 호출한다
- 클래스를 만들어놓으면 객체를 생성할 때, 갖고 있는 init 매소드가 뜬다.
엄밀히 말하면 생성자는 숨어있지만.
car=클래스 이름 + () 으로 호출하면 눈에 보이지 않는 생성자를 호출한다. 그러면 자동으로 init를 호출하게 된다. - 객체 생성시 처음 넘긴 값을 그대로 전달해줘서 속성이 초기화된다.
즉, 필요한 값을 넣어주면, 객체가 초기화된다 = 속성의 값이 초기화된다.
class Car: #'클래스선언' #class의 이름 첫글자는 대문자로
def __init__(self, col, len): #'생성자, 속성(변수)'
self.color = col #self = 나 자신 = Car #속성 마음대로 정하면 됨
self.length = len
def doStop(self): #'기능(함수)' #매개변수->self = Car라는 클래스 안에 포함된 기능이라는 뜻
print('stop')
def doStart(self):
print('start')
def printCarInfo(self):
print(f'self.color : {self.color}')
print(f'self.length : {self.length}')
car1 = Car('red', 200) #필요한 매개변수, 속성을 초기화해주는 매개변수값을 담는다.
car2 = Car('blue', 300)
car1.printCarInfo()
car2.printCarInfo()
car1.doStop()
car1.doStart()
-->
self.color : red
self.length : 200
self.color : blue
self.length : 300
stop
start- car1, car2
= 클래스 하나에 -> 오브젝트가 2개 생성된 것
실습) 비행기 클래스를 만들고 비행기 객체 5개를 생성해보자
class Airplane:
def __init__(self, color, size, country):
self.color = color
self.size = size
self.country = country
def start(self):
print(start)
def stop(self):
print(stop)
def printAirInfo(self):
print(f'color: {self.color}')
print(f'size: {self.size}')
print(f'country: {self.country}')
air1 = Airplane('red', 50, 'philippines')
air1.printAirInfo()
-->
color: red
size: 50
country: philippines019. 객체 속성 변경
객체의 속성값을 변경하자!
- 객체 속성 변경
- 객체 속성은 변경할 수 있다.
class NewGenerationPc:
def __init__(self, name, cpu, memory, ssd): # 객체초기화에 사용
self.name = name #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 doPCInfo(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}')
# class 는 사용하면서 추가, 삭제하며 수정함
myPc = NewGenerationPc('myPc', 'i5', '16G', '256G')
myPc.doPCInfo()
friendPc = NewGenerationPc('friendPc', 'i7', '32G', '512G')
friendPc.doPCInfo()
#객체속성수정
myPc.cpu = 'i9'
myPc.memory = '64G'
myPc.ssd = '1T'
myPc.doPCInfo()
-->
self.name = myPc
self.cpu = i5
self.memory = 16G
self.ssd = 256G
self.name = friendPc
self.cpu = i7
self.memory = 32G
self.ssd = 512G
self.name = myPc
self.cpu = i9
self.memory = 64G
self.ssd = 1T실습) 계산기 클래스를 만들고 사칙연산을 실행해보자
class Calculator:
def __init__(self, number1, number2, result):
self.number1 = number1
self.number2 = number2
self.result = result
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 printResult(self):
print(f'calculator.add() = {Calculator.add(self)}')
print(f'calculator.sub() = {Calculator.sub(self)}')
print(f'calculator.mul() = {Calculator.mul(self)}')
print(f'calculator.div() = {Calculator.div(self)}')
cal1 = Calculator(10, 20, 0)
cal1.printResult()
cal2 = Calculator(9, 4, 0)
cal2.printResult()
-->
calculator.add() = 30
calculator.sub() = -10
calculator.mul() = 200
calculator.div() = 0.5
calculator.add() = 13
calculator.sub() = 5
calculator.mul() = 36
calculator.div() = 2.25아아아아아아ㅏㅏㅏ아아악
별로 어려운 파트도 아닌 것 같은데 100% 이해된 게 아니라 변형하려고 하면 엄청 헷갈린다 스트레스바당리마어리ㅏㅇ리ㅏㅇㄻ이
한번 공부했다고 절대 내꺼 된 게 아니다.
착각하면 안된다.
기도하면서 여러번 반복해서 보고 공부하면서 내껄로 만들자
