5 장. 파이썬 날개 달기, 객체지향 프로그래밍
I. 클래스클래스(class) 는 객체 지향 프로그래밍(OOP) 에서 특정 객체를 생성하기 위해 변수와 메소드 ( 함수) 를 정의하는 일종의 틀(template) 이다.
클래스는 객체를 생성하기 위해 변수와 메소드( 함수) 를 정의하는 일종의 틀
모듈: 변수, 함수 또는 크랠스를 모아 놓은 파일 파이썬 파일
패키지 : 모듈을 계층적( 디렉터리 구조) 으로 관리
함수-> 클래스-> 모듈-> 패키지
class 는 변수하고 함수로 주어진다.
class 안에 쓰는 것을 메소드 라고 한다.
클래스는 도대체 왜 필요한가?
함수를 이용해 계산기의 ‘ 더하기‘ 기능을 구현한 예:
#add1.py
result = 0
def add(num):
global result
result += num
return result
print(add(3))#3
print(add(4))#7
계산된 결과값을 유지하기 위해서 result 라는 전역 변수(global) 를 사용했음
실행하면 예상한 대로 다음과 같은 결과값이 출력됨
한 프로그램에서 2 대의 계산기가 필요한 상황이 발생하면 어떻게 해야 할까?
각 계산기는 각각의 결과값을 유지하기 위해 add 함수를 각각 따로 만들어야 함
#add2.py
result1 = 0
result2 = 0
# 계산기 1
def add1(num):
global result1
result1 += num
return result1
# 계산기 2
def add2(num):
global result2
result2 += num
return result2
print(add1(3))#3
print(add1(4))#7
print(add2(3))#3
print(add2(7))#10
똑같은 일을 하는 add1 과 add2 함수를 만들었고, 결과값을 유지하면서 저장하는 전역 변수 result1, result2 가 필요하게 되었음
결과값은 다음과 같이 출력됨
위와 같은 경우 클래스를 이용하면 간단하게 해결할 수 있음
#add3.py
class Calculator:
def __init__(self):
self.result = 0
def add(self,num):
self.result += num
return self.result
def sub(self,num):
self.result -= num
return self.result
cal1 = Calculator()
cal2 = Calculator()
print(cal1.add(3))
print(cal1.add(4))
print(cal2.add(3))
print(cal2.add(7))
실행하면 함수 2 개를 사용했을 때와 동일한 결과가 출력됨
Calculator 클래스로 만든 별개의 계산기 cal1, cal2( 객체) 는 각각의 역할을 수행함
계산기(cal1, cal2) 의 결과값도 각각 독립적인 값을 유지함
클래스를 사용하면 계산기 대수가 늘어나더라도 객체를 생성하기만 하면 되기 때문에 함수를 사용하는 경우와 달리 매우 간단해짐
Calculator 클래스에 빼기 기능 함수를 추가한 예:
>>> def sub(self,num):
self.result -= num
return self.result
=> 클래스와 객체
클래스는 과자 틀과 비슷함
클래스(class) 란 똑같은 무엇인가를 계속 만들어낼 수 있는 설계 도면이고 ( 과자 틀) , 객체(object) 란 클래스로 만든 피조물 ( 과자 틀을 사용해 만든 과자) 을 뜻함
과자 틀 -> 클래스(class)
과자 틀을 사용해 만든 과자 ->(object)
클래스의 간단한 예:
>>> class Cookie:
... pass
...
위의 클래스는 아무런 기능도 갖고 있지 않은 껍질뿐인 클래스임
하지만 껍질뿐인 클래스도 객체를 생성하는 기능이 있음
객체는 클래스로 만들며, 1 개의 클래스는 무수히 많은 객체를 만들어낼 수 있음
>>> a = Cookie
>>> a
<class '__main__.Cookie'>#Cookie 라는 클래스이다.
>>> id(a)
1254491128320
앞에서 만든 Cookie 클래스의 객체를 만드는 방법
>>> a = Cookie()
Cookie() 의 결과값을 돌려받은 a 와 b 가 객체임
함수를 사용해서 그 결과값을 돌려받는 모습과 비슷함
>>> a
<__main__.Cookie object at 0x000001241595E820>
>>> type(a)
<class '__main__.Cookie'>
[ 객체와 인스턴스의 차이]
클래스로 만든 객체를 인스턴스라고도 함
a = Cookie() 이렇게 만든 a 는 객체임
a 객체는 Cookie 의 인스턴스임
즉 인스턴스라는 말은 특정 객체(a) 가 어떤 클래스(Cookie) 의 객체인지를 관계 위주로 설명할 때 사용됨
a 는 ‘인스턴스’ 보다는 a 는 ‘객체’라는 표현이 어울림
a 는 ‘Cookie 의 객체’보다는 a 는 ‘Cookie 의 인스턴스’라는 표현이 어울림
#self 라는 틀별한 의미를 가지고 있다. 첫 번째 매개변수 self
self.first = first
self.second = second
self 에 따라 매개변수가 다를 수 있다.
self 는 객체가 default 로 넘어간다.
self 는 객체자신을 얘긴한다. 나를 호출한 자기 자신을 얘기한다.
def setdata(self, first, second)
self.first = first
self.second = second -> 메소드의 수행문
self 는 객체로 바꾼다. 번역을 하고 a.first a 가 부르는 객체이다.
a.setdata() 시 self 가 a 이다.
함수는 입력값 가지고 결과값 내는 것이다.
반복해서 사용할때
함수밖에 하고 안에 변수가 다르게 사용하는 게 좋다.
class 안에서는 return 을 안해도 된다.
함수의 결과값은 하나이다.
함수를 빠져나갈때는 return.break 사용하면 안된다.
thread 문제에서 클래스 문제가
thread 관련 연습문제
#PPT_5.9_thread.py
#CPU 하나가 순서대로 진행한 것이다.
import time
import threading
class RacingCar:
def __init__(self,name):
self.carName = name
def runCar(self):
for i in range(0,5):
carStr = self.carName + '-%d.\n' % (i+1)
print(carStr,end="")
time.sleep(0.1)
## 매인 코드 부분
car1 = RacingCar("H 자동차")
car2 = RacingCar("K 자동차")
car3 = RacingCar("D 자동차")
# 객체를 3 개 생성한다.
th1 = threading.Thread(target = car1.runCar)
th2 = threading.Thread(target = car2.runCar)
th3 = threading.Thread(target = car3.runCar)
# 스레드 시작 시키는 것
th1.start()
th2.start()
th3.start()
# 스레드 종료 시키는 것
th1.join()
th2.join()
th3.join()
=> 사칙연산 클래스 만들기
클래스를 어떻게 만들지 먼저 구상하기
사칙연산을 가능하게 하는 FourCal 클래스가 다음처럼 동작한다고 가정함
=> 클래스 구조 만들기
>>> class FourCal:
pass
a = FourCal() 처럼 객체를 아무 기능이 없이 만듦
FourCal 클래스는 아무런 변수나 함수도 포함하지 않지만, 원하는 객체 a 를 만들 수 있는 기능은 가지고 있음
>>> a = FourCal()
>>> type(a)
a = FourCal() 로 a 객체를 먼저 만들고, 그 다음에 type(a) 로 a 라는 객체가 어떤 타입인지 알아보았음
역시 객체 a 가 FourCal 클래스의 객체임을 알 수 있음
=> 객체에 숫자 지정할 수 있게 만들기
>>> class FourCal:
def setdata(self,first,second):
self.first = first
self.second = second
이전에 만들었던 pass 문장을 삭제하고, setdata 함수를 만듦
클래스 안에 함수는 메소드(Method) 라고 부름
a.setdata(4, 2)
a 객체에 사칙연산을 할 때 사용할 2 개의 숫자를 먼저 알려주기 위해 연산을 수행할 대상(4, 2) 을 객체에 지정할 수 있게 만듦
① setdata 메소드의 매개변수
매개변수로 self, first, second 라는 3 개의 입력값을 받음
메소드의 첫 번째 매개변수 self 는 특별한 의미를 가짐
>>> a = FourCal()
>>> a.setdata(4,2) <- 객체를 통해 클래스의 매소드를 호출하려면 도트(.) 연산자를 사용함
a.setdata(4, 2) 처럼 호출하면 setdata 메소드의 첫 번째 매개변수 self 에는 setdata 메소드를 호출한 객체 a 가 자동으로 전달됨
==>[ 매소드의 또 다른 호출 방법]
>>> a = FourCal()
>>> FourCal.setdata(a,4,2)
‘클래스명. 메소드‘ 형태로 호출할 때는 객체 a 를 첫 번째 매개변수 self 에 전달해 주어야 함
반면에 앞에서 보았듯이 ‘객체. 메소드‘ 형태로 호출할 때는 self 를 반드시 생략해서 호출해야 함
② setdata 메소드의 수행문
a.setdata(4, 2) 처럼 호출하면 setdata 메소드의 매개변수 first, second 에는 각각 값 4 와 2 가 전달되어 setdata 메소드의 수행문은 다음과 같이 해석됨
self 는 전달된 객체 a 이므로 다시 다음과 같이 해석됨
a 객체에 객체변수 first 가 생성되고 값 4 가 저장됨
객체에 생성되는 객체만의 변수를 객체변수라고 부름
>>> a = FourCal()
>>> a.setdata(4,2)
>>> print(a.first)
>>> print(a.second)
a 객체에 객체변수 first 와 second 가 생성되었음을 확인할 수 있음
>>> a= FourCal()
>>> b= FourCal()
>>> a.setdata(4,2)
>>> print(a.first)
>>> b.setdata(3,7)
>>> print(b.first)
a 와 b 객체는 first 라는 객체변수를 가지고 있지만 그 변수의 값은 각기 다름
객체변수는 다른 객체에 영향을 받지 않고 독립적으로 그 값을 유지함
=> 더하기 기능 만들기
>>> class FourCal:
def setdata(self,first,second):
self.first = first
self.second = second
def add(self):
result = self.first + self.second
return result
>>> a= FourCal()
>>> a.setdata(4,2)
>>> print(a.add())
a.add() 라고 호출하면 새로 추가된 add 메소드가 호출되어 값 6 이 출력됨
어떤 과정을 거쳐 출력되는지 add 메소드를 자세히 살펴봄
add 메소드의 매개변수는 self 이고, 반환 값은 result 임
=> 곱하기, 빼기, 나누기 기능 만들기
>>> class FourCal:
def setdata(self,first,second):
self.first = first
self.second = second
def add(self):
result = self.first + self.second
return result
def mul(self):
result = self.first * self.second
return result
def sub(self):
result = self.first - self.second
return result
def div(self):
result = self.first / self.second
return result
>>> a= FourCal()
>>> b= FourCal()
>>> a.setdata(4,2)
>>> b.setdata(3,8)
>>> a.add()
>>> a.mul()
>>> a.sub()
>>> a.div()
>>> b.add()
>>> b.mul()
>>> b.sub()
>>> b.div()
=> 생성자(Constructor)
위에서 만든 FourCal 클래스를 다음과 같이 실행하면 어떻게 될까?
>>> a= FourCal()
>>> a.add()
FourCal 클래스의 인스턴스 a 에 setdata 메소드를 수행하지 않고, add 메소드를 수행하면 오류가 발생함.
왜냐하면 setdata 메소드를 수행해야 객체 a 의 first 와 second 가 생성되는 때문임
객체에 초기값을 설정해야 할 필요가 있을 때는 생성자를 구현하는 것이 안전함
생성자(Constructor) 란 객체가 생성될 때 자동으로 호출되는 메소드를 의미함
메소트 이름으로 __init__ 를 사용하면 이 메소드는 생성자가 됨
>>> class FourCal:
def __init__(self,first,second):
self.first = first
self.second = second
def setdata(self,first,second):
self.first = first
self.second = second
def add(self):
result = self.first + self.second
return result
def mul(self):
result = self.first * self.second
return result
def sub(self):
result = self.first - self.second
return result
def div(self):
result = self.first / self.second
return result
==> 생성자 __init__ 메소드
setdata 메소드와의 차이점은 이름을 __init__ 으로 했기 때문에 생성자로 인식되어 객체가 생성되는 시점에 자동으로 호출됨
>>> a= FourCal()
>>> a= FourCal(4,2)
__init__ 메소드가 호출되면 객체변수가 생성되는 것을 확인할 수 있음
>>> a= FourCal(4,2)
>>> print(a.first)
>>> print(a.second)
>>> a.add()
>>> a.div()
==> 연습문제
===>res 형태로 받기
#FourCal()
class FourCal():
def setdata(self, first,second):
self.first = first
self.second = second
self.res = 0
def add(self):#. a/b 중에서 어떤것인지
self.res = self.first + self.second
def mul(self):
self.res = self.first * self.second
def sub(self):
self.res = self.first - self.second
def div(self):
self.res = self.first / self.second
# 객체 변수는 많이 만들지 않은게 좋다. 사이즈를 작게 하는 게 좋다.
그래서 self.res = 0 비효율성이다.
a = FourCal() <-a = FourCal 처럼 입력해서 a 라는 객체를 만듦
a.setdata(4,2) <-a.setdata(4, 2) 처럼 입력해서 4 와 2 라는 숫자를 a 에 지정해 줌
print("a.first %d " % a.first)
print("a.second %d " % a.second)
a.add()
print("a.add() %d " % a.res) <-a.add() 를 수행하면 두 수를 합한 결과(4 + 2) 를 돌려줌
a.mul()
print("a.mul() %d " % a.res) <-a.mul() 를 수행하면 두 수를 곱한 결과(4 * 2) 를 돌려줌
a.sub()
print("a.sub() %d " % a.res) <-a.sub() 를 수행하면 두 수를 뺀 결과(4 - 2) 를 돌려줌
a.div()
print("a.div() %d " % a.res) <-a.div() 를 수행하면 두 수를 나눈 결과(4 / 2) 를 돌려줌
b = FourCal()
b.setdata(5,5)
print("b.first %d " % b.first)
print("b.second %d " % b.second)
b.add()
print("b.add() %d " % b.res)
b.mul()
print("b.mul() %d " % b.res)
b.sub()
print("b.sub() %d " % b.res)
b.div()
print("a.div() %d " % b.res)
#init 용도
def __init__(self, first, second):#.
#__init__ .setdata 안해도 된다.
self.first = first
self.second = second
#def setdata(self, first,second):
# self.first = first
# self.second = second
def add(self):#. a/b 중에서 어떤것인지
result = self.first + self.second
return result
def mul(self):
result = self.first * self.second
return result
def sub(self):
result = self.first - self.second
return result
def div(self):
result = self.first / self.second
return result
a = FourCal(4,2)#FourCal 매개변수 만들어라
#a.setdata(4,2)
print("a.first %d " % a.first)
print("a.second %d " % a.second)
print("a.add() %d " % a.add())
print("a.mul() %d " % a.mul())
print("a.sub() %d " % a.sub())
print("a.div() %d " % a.div())
b = FourCal(3,8)
#b.setdata(3,8)
print("a.first %d " % b.first)
print("a.second %d " % b.second)
print("a.add() %d " % b.add())
print("a.mul() %d " % b.mul())
print("a.sub() %d " % b.sub())
print("a.div() %d " % b.div())
a 라는 객체 만들때 __init__ 생긴다.
=> 클래스의 상속
상속(Inheritance) 이란 ‘물려받다’라는 뜻으로, 어떤 클래스를 만들 때 다른 클래스의 기능을 물려받을 수 있게 만드는 것임
FourCal 클래스를 상속하는 MoreFourCal 클래스 만들기
#class 상속
>>> class MoreFourCal(FourCal):
pass
>>> a = MoreFourCal(4,2)
>>> a.add()
>>> a.mul()
MoreFourCal 클래스는 FourCal 클래스의 모든 기능을 사용할 수 있음
클래스의 상속 사용법
class 클래스 이름( 상속할 클래스 이름)
기능이 개선된 기능을 만들겠다.
FourCal 를 수정불가할때 수정권한이 없을 경우 MoreFourCal.
solution 소스 안준다. 그래서 소스는 없고 상속받아서 한다.
내 부모 클라스의 메소드를 전부 사용가능하다.
a 의 b 제곱 을 계산하는 MoreFourcal 클래스 만들기
>>> class MoreFourCal(FourCal):
def pow(self):
result = self.first ** self.second
return result
>>> a = MoreFourCal(4,2)
>>> a.pow()
[ 왜 상속을 해야 할까?]
상속은 기존 클래스를 변경하지 않고 기능을 추가하거나 기존 기능을 변경 하려고 할 때 사용한다.
기존 클래스가 라이브러리 형태로 제공되거나 수정이 허용되지 않는 상황이 라면 상속을 사용해야 한다.
=> 매소드 오버라이딩(Overriding)
>>> a= FourCal(4,0)
>>> a.div()
div 메소드를 호출하면 4 를 0 으로 나누려고 하기 때문에 오류가 발생함
0 으로 나누면 오류가 난다.
자식의 메소드를 불러 쓴다.
>>> class SafeFourCal(FourCal):
def div(self):
if self.second == 0:
return 0
else:
return self.first / self.second
>>> a= SafeFourCal(4,0)
>>> a.div()
SafeFourCal 클래스는 FourCal 클래스에 있는 div 메소드를 동일한 이름으로 다시 작성하였음
부모 클래스에 있는 메소드를 동일한 이름으로 다시 만드는 것을 메소드 오버라이딩(Overriding, 덮어쓰기) 이라고 함
메소드를 오버라이딩하면 부모 클래스의 메소드 대신 오버라이딩한 메소드가 호출됨
=> 클래스 변수
>>> class Family:
lastname = "" #Family 안에 있는 변수 전역변수
Family 클래스에 선언한 lastname 이 클래스 변수임
클래스 변수는 클래스 안에 메소드( 함수) 와 마찬가지로 변수를 선언하여 생성함
클래스 변수 사용
>>> class Family:
lastname = ""
>>> print(Family.lastname)# 클래스 이름. 클래스 변수로 사용
>>> a = Family()
>>> b = Family()
>>> print(a.lastname)# 클래스로 만든 객체를 통해서 사용
>>> print(b.lastname)
Family 클래스의 lastname 을 “ 박” 이라는 문자열로 바꾸면 어떻게 될까?
>>> Family.lastname =" 박"
>>> print(a.lastname)# 박
>>> print(b.lastname)# 박
# 클래스 변수 값을 변경했더니 클래스로 만든 객체의 lastname 값도 모두 변경됨
# 즉, 클래스 변수는 클래스로 만든 모든 객체에 공유된다는 특징이 있음
a.lastname ="kim"# 이 경우 메모리에 주소가 바꿔진다.
print(a.lastname)#kim
print(b.lastname)# 박
대입하는것
연습문제 모듈을 클래스로 바꾸기
#126 1
class Calcultor:
def __init__(self):
self.value = 0
def add(self,val):
self.value += val
class UpgradeCalculator(Calcultor):
def minus(self,val):
self.value -= val
cal = UpgradeCalculator()
cal.add(10)
cal.minus(7)
print(cal.value)#10 에서 7 을 뺀 3 을 출력
#2 번
class Calculator:
def __init__(self):
self.value = 0
def add(self,val):
self.value += val
class MaxLmitCalculator(Calculator):
def add(self,val):
self.value += val
if self.value>= 100:
self.value = 100
cal = MaxLmitCalculator()
cal.add(50) #50 더하기
cal.add(60) #60 더하기
print(cal.value)#100 을 출력
# 계산기 class
class Calculator:
def __init__(self,oper,var1,var2):
self.oper = oper
self.var1 = var1
self.var2 = var2
def cal(self):
result = eval(str(self.var1)+self.oper+str(self.var2))
return result
# 에러메시지 class
class ErrMessage:
def __init__(self,var):
self.var = var
def intErr(self):
print('.'.format(self.var))
operList = ('+','-','*','/')
var=var1=var2 = 0 # 값 초기화
while True:
#1.
while True:
oper= input(" ('+','-','*','/') 을 입력하세요")
if oper in operList:
break
else:print(".")
#2.
while True:
try:
var = var1 = int(input(". : "))
except ValueError : #
ErrMessage(var).intErr()
continue
break
while True:
try:
var = var2 = int(input(". : "))
if oper=="/" and var2== 0:
print("'%s' %d 가 불가능합니다." % (oper,var2))
continue
else:
break
except ValueError : #
ErrMessage(var).intErr()
continue
break
#3.
cal = Calculator(oper, var1, var2)
print(" : %d %s %d = %d" % (var1,oper,var2, cal.cal()))
#4.
result = input("enter .")
if result == '':
print(".")
break
else:print(".")
II. 모듈모듈이란?
함수나 변수 또는 클래스를 모아 놓은 파일
다른 파이썬 프로그램에서 불러와 사용할 수 있게끔 만든 파이썬 파일이라고도 함
디렉트리 검색
>>> import os
>>> os.getcwd()
'C:\\Users\\admin\\AppData\\Local\\Programs\\Python\\Python38'
디렉트리를 확인해야 한다.
# 모듈화
# 계산기 class
class Calculator:
def __init__(self,oper,var1,var2):
self.oper = oper
self.var1 = var1
self.var2 = var2
def cal(self):
result = eval(str(self.var1)+self.oper+str(self.var2))
return result
import cal_04_1216 as cal
# 에러메시지 class
class ErrMessage:
def __init__(self,var):
self.var = var
def intErr(self):
print('.'.format(self.var))
operList = ('+','-','*','/')
var=var1=var2 = 0 # 값 초기화
while True:
#1.
while True:
oper= input(" ('+','-','*','/') 을 입력하세요")
if oper in operList:
break
else:print(".")
#2.
while True:
try:
var = var1 = int(input(". : "))
except ValueError : #
ErrMessage(var).intErr()
continue
break
while True:
try:
var = var2 = int(input(". : "))
if oper=="/" and var2== 0:
print("'%s' %d 가 불가능합니다." % (oper,var2))
continue
else:
break
except ValueError : #
ErrMessage(var).intErr()
continue
break
#3.
cal1 = cal.Calculator(oper, var1, var2)
res = cal1.cal()
print(" : %d %s %d = %d" % (var1,oper,var2, res))
#4.
result = input("enter .")
if result == '':
print(".")
break
else:print(".")
모듈 만들기
# mod1.py
def add(a,b):
return a+b
def sub(a,b):
return a-b
위와 같이 add 와 sub 함수만 있는 파일 mod1.py 를 만들고, c:\doit 디렉터리에 저장
확장자 .py 로 만든 파이썬 파일은 모두 모듈임
=> 모듈 불러오기
import mod1
print(mod1.add(3,4))
print(mod1.sub(3,4))
mod1.py 를 불러오기 위해 import mod1 이라고 입력함
import 는 이미 만들어진 파이썬 모듈을 사용할 수 있게 해주는 명령어임
mod1.py 파일에 있는 add 함수를 사용하기 위해서는 mod1.add 처럼 모듈 이름 뒤에 ‘.’( 도트 연산자) 를 붙이고 함수 이름을 쓰면 됨
=>import 의 사용 방법
import 모듈 이름
모듈 이름은 mod1.py 에서 .py 라는 확장자를 제거한 mod1 만을 가리킴
모듈 이름. 함수 이름 처럼 사용함
=> 모듈 이름 없이 함수 이름만 쓰는 방법
from 모듈 이름 import 모듈 함수
모듈 이름을 붙이지 않고 모듈의 함수를 쓸 수 있음
from mod1 import add
add(3,4)
mod1.py 파일의 add 함수만 사용할 수 있음
add 함수와 sub 함수를 모두 사용하는 방법은 2 가지가 있음
① from mod1 import add, sub
② from mod1 import *
①
② 번 방법은 * 문자를 사용하여 모든 함수를 불러올 수 있음
=> if __name__ == “__main__”: 의 의미
# mod1.py
def add(a,b):
return a+b
def sub(a,b):
return a-b
print(add(1,4))
print(add(4,2))
add(1, 4) 와 sub(4, 2) 의 결과를 출력하는 문장을 추가함
작성한 mod1.py 파일을 다음과 같이 실행함
# 모듈 테스트시 사용하면 됨 다른데서 import
if __name__ == "__main__":
print(add(1, 4))
if __name__ == "__main__": import 로 호출시는 실행되지 말아라 라는 뜻이다.
이러한 문제를 방지하려면, mod1.py 파일의 마지막 부분을 변경해야 함
# mod1.py
def add(a,b):
return a+b
def sub(a,b):
return a-b
if __name__ == "__main__":
print(add(1,4))
print(add(4,2))
#python mod1.py cmd 창에서 호출
if __name__ == “__main__”: 을 사용하면 C:\doit>python mod1.py 처럼 직접 이 파일을 실행시켰을 때는 __name__ == “__main__” 이 참이 되어 if 문 다음 문장이 수행됨
반대로 대화형 인터프리터나 다른 파일에서 이 모듈을 불러서 사용할 때는 __name__ == “__main__” 이 거짓이 되어 if 문 다음 문장이 수행되지 않음
=> 클래스나 변수 등을 포함한 모듈
#mod2.py
PI = 3.141592 # 원주율 값에 해당하는 PI 변수
class Math: # 원의 넓이를 계산하는 Math 클래스
def solv(self, r):
return PI * (r ** 2)
def add(a,b): # 두 값을 더하는 add 함수
return a+b
# 파일을 직접 실행시켰을 때 수행됨
if __name__ == "__main__":
print(PI)
a = Math()
print(a.solv(2))
print(add(PI,4.4))
변수, 클래스, 함수 등을 모두 포함하고 있는 모듈임
#mod2.py 모듈을 다른 파일에서 불러오기
import mod2 as mod2
result = mod2.add(3,4)
print(result)
print(mod2.PI)
print(mod2.Math().solv(2))
#print(mod2.__name__)
# 모델 이름이 들어간다.mod2
CMD 창에서 해결 하는 방법
cd C:\doit
mkdir mymod # 새 디렉터리 생성
move mod2.py mymod # 지정한 디렉터리로 파일 이동
1.sys.path.append( 모듈을 저장한 디렉터리) 사용하기
import sys
sys.path
sys.path.append("C:/doit/mymod")
2.pythonpathn 환결 변수 사용하기
set PYTHONPATH = C:\doit\mymod
python
import mod2
III. 패키지패키지란 무엇인가?
패키지(Package) 는 도트(.) 를 사용하여 파이썬 모듈을 계층적( 디렉터리 구조) 으로 관리할 수 있게 해줌
관리의 효율성
모듈 이름이 A.B 인 경우에 A 는 패키지이름이 되고, B 는 A 패키지의 B 모듈이 됨
파이썬 패키지는 디렉터리와 파이썬 모듈로 이루어진 구조임
game, sound, graphic, play 는 디렉터리 이름 이고, 확장자가 .py 인 파일이 파이썬 모듈임
game 디렉터리가 이 패키지의 루트 디렉터 리이고, sound, graphic, play 는 서브 디렉터 리임
패키지 구조로 파이썬 프로그램을 만드는 것 이 공동 작업이나 유지 보수 등 여러 면에서 유리함
각 디렉터리에 __init__.py 파일을 만들어 놓기만 하고 내용은 일단 비워 둠
일반 디렉터리와 구분하는 것 이다.
__init__.py 있으면 패키지이다.
=> 패키지 만들기
==> 패키지 기본 구성 요소 준비하기
1. C:\doit 디렉터리 밑에 game 및 서브 디렉터리를 생성하고 .py 파일들을 만듦
C:/doit/game/__init__.py
C:/doit/game/sound/__init__.py
C:/doit/game/sound/echo.py
C:/doit/game/graphic/__init__.py
C:/doit/game/graphic/render.py
2. 각 디렉터리에 __init__.py 파일을 만들어 놓기만 하고 내용은 일단 비워 둠
3. echo.py 파일은 다음과 같이 만듦
#echo.py
def echo_test():
print("echo")
4. render 파일을 다음과 같이 만듦
#render.py
def render_test():
print("render")
5. game 패키지를 참조할 수 있도록 명령 프롬프트창에서 set 명령어로 PYTHONPATH 환경 변수에 C:\doit 디렉터리를 추가함
명렬 프롬프트
C:\>set PYTHONPATH=C:\doit
C:\>python
Python 3.5.1 (v3.5.1:37a07cee5969, Dec 6 2015, 01:54:25) [MSC v.1900 64 bit
(AM... Type "help", "copyright", "credits" or "license" for more information.
>>>
=> 패키지 안의 함수 실행하기
==> 패키지를 사용하여 echo.py 파일의 echo_test 함수를 실행해 봄 (3 가지 방법)
3 가지 방법
첫 번째, echo 모듈을 import 하여 실행하는 방법( 폴더이름)
>>> import game.sound.echo
>>> game.sound.echo.echo_test()
echo
두 번째, echo 모듈이 있는 디렉터리 까지를 from ··· import 하여 실행하는 방법(from- 폴더이름)
>>> from game.sound import echo
>>> echo.echo_test()
echo
세 번째, echo 모듈의 echo_test 함수를 직접 import 하여 실행하는 방법(from- 폴더이름)
>>> from game.sound.echo import echo_test
>>> echo_test()
echo
import game 을 수행하면 game 디렉터리의 모듈 또는 game 디렉터리의 __init__.py 에 정의된 것만 참조할 수 있음
도트 연산자(.) 를 사용해서 import a.b.c 처럼 import 할 때 가장 마지막 항목인 c 는 반드시 모듈 또는 패키지여야만 함
cmd
set PYTHONPATH=C:\doIt
python shell
>>> import sys
>>> sys.path.append("c:\doIt")
>>> import game.sound.echo
>>> game.sound.echo.echo_test()
echo
# 현재 경로 출력
>>> import os
>>> os.getcwd()
교제 페이지 213,214
>>> from game.sound.echo import *
>>> echo_test()
echo
import 는 모듈까지 가능하다.
패키지 안의 함수 사용할 때 주의사항
첫 번째, 다음과 같이 echo_test 함수를 사용하는 것은 불가능함=> 패키지까지는 안된다.
>>> import game
>>> game.sound.echo.echo_test()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: ‘module' object has no attribute ‘sound’
import game 을 수행하면 game 디렉터리의 모듈 또는 game 디렉터리의 __init__.py 에 정의된 것만 참조할 수 있음
두 번째, import 마직막 항목에 함수를 사용하는 것도 불가능함
>>> import game.sound.echo.echo_test
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ImportError: No module named echo_test
도트 연산자(.) 를 사용해서 import a.b.c 처럼 import 할 때 가장 마지막 항목인 c 는 반드시 모듈 또는 패키지여야만 함
==>__init__.py 의 용도
__init__.py 파일은 해당 디렉터리가 패키지의 일부임을 알려주는 역할을 함
game, sound, graphic 등 패키지에 포함된 디렉터리에 __init__.py 파일이 없다면 패키지로 인식되지 않음
sound 디렉터리의 __init__.py 를 제거하고 다음을 수행해 봄
>>> import game.sound.echo
Traceback (most recent call last): File "<stdin>", line 1, in <module> ImportError: No module named sound.echo
sound 디렉터리에 __init__.py 파일이 없어서 ImportError 가 발생하게 됨
python3.3 버전부터는 __init__.py 파일이 없어도 패키지로 인식함. 하위 버전 호환을 위해 생성하는 것이 안전함
==> __all__ 의 용도
>>> from game.sound import *
>>> echo.echo_test()
Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name ‘echo’ is not defined
echo 모듈을 사용할 수 있어야 할 것 같은데, echo 라는 이름이 정의되지 않았다는 이름 오류(NameError) 가 발생함
오류 이유는, 특정 디텍터리의 모듈을 * 를 사용하여 import 할 때에는 해당 디렉터리의 __init__.py 파일에 __all__ 변수를 설정해야 함
# C:\doit/game/sound/__init_.py
__all__ = [‘echo’]
여기서 __all__ 이 의미하는 것은 sound 디렉터리에서 * 기호를 이용하여 import 할 경우 이곳에 정의된 echo 모듈만 import 된다는 의미임
>>> from game.sound import *
>>> echo.echo_test()
echo
__init__.py
페케지 확인
모듈인지 확인
=>relative 패키지
graphic 디렉터리의 render.py 모듈이 sound 디렉터리의 echo.py 모듈을 사용하려면,
render.py 를 수정하면 가능함
# render.py
from game.sound.echo import echo_test
def render_test():
print ("render")
echo_test()
from game.sound.echo import echo_test 라는 문장을 추가하여 echo_test() 함수를 사용할 수 있도록 수정함
수정 후 다음과 같이 수행함
>>> from game.graphic.render import render_test
>>> render_test()
render
echo
상대경로
from game.sound.echo import echo_test
절대경로
from ..sound.echo import echo_test
.. 은 부모 디렉터리, . 은 현재 디렉터리를 의미함
전체 경로를 이용하여 import 할 수 있지만, relative 하게 import 하는 것도 가능함
# render.py
from ..sound.echo import echo_test
def render_test():
print ("render")
echo_test()
.. 은 부모 디렉터리, . 은 현재 디렉터리를 의미함
graphic 과 sound 디렉터리는 동일한 깊이(depth) 이므로 부모 디렉터리(..) 를 사용하여 위와 같은 import 가 가능한 것임
.. 과 같은 relative 한 접근자는 render.py 와 같이 모듈 안에서만 사용해야 함
파이썬 인터프리터에서 relative 한 접근자를 사용하면 ‘SystemError: cannot perform relative import’ 와 같은 오류가 발생함
IV. 예외 처리프로그램을 만들다 보면 수없이 많은 오류를 만나게 됨
오류가 발생하는 이유는 프로그램이 잘못 동작하는 것을 막기 위한 배려임
하지만 이러한 오류를 무시하고 싶을 때가 있는데 try, except 를 이용해서 예외적으로 오류를 처리할 수 있게 해줌
오류는 어떨 때 발생하는가?
try, except 문
try: ···
except:
[[as 오류 메시지 변수]]:
#lambda
add = lambda a,b:a+b
result = add(3,4)
print(result)
input1 = input("6. 숫자를 여러 개 입력하세요 :")
result =["\u2605"*int(n) for n in input1]
print(result)
python 에서 thread 자주 사용하는지:
경로 바꾸는 두가지 방식죽 다 사용해도 되는지?
sys.path.append()
os.chdir
#thread_car01.py
#CPU 하나가 순서대로 진행한 것이다.
import time
class RacingCar:
def __init__(self,name):
self.carName = name
def runCar(self):
for i in range(0,5):
carStr = self.carName + '-%d.' % (i+1)
print(carStr)
time.sleep(0.1)
## 매인 코드 부분
car1 = RacingCar("H 자동차")
car2 = RacingCar("K 자동차")
car3 = RacingCar("D 자동차")
car1.runCar()
car2.runCar()
car3.runCar()
#thread_car01.py
#CPU 하나가 순서대로 진행한 것이다.
import time
import threading
class RacingCar:
def __init__(self,name):
self.carName = name
def runCar(self):
for i in range(0,5):
carStr = self.carName + '-%d.\n' % (i+1)
print(carStr,end="")
time.sleep(0.1)
## 매인 코드 부분
car1 = RacingCar("H 자동차")
car2 = RacingCar("K 자동차")
car3 = RacingCar("D 자동차")
# 객체를 3 개 생성한다.
th1 = threading.Thread(target = car1.runCar)
th2 = threading.Thread(target = car2.runCar)
th3 = threading.Thread(target = car3.runCar)
# 스레드 시작 시키는 것
th1.start()
th2.start()
th3.start()
# 스레드 종료 시키는 것
th1.join()
th2.join()
th3.join()
IV. 예외 처리
프로그램을 만들다 보면 수없이 많은 오류를 만나게 됨
오류가 발생하는 이유는 프로그램이 잘못 동작하는 것을 막기 위한 배려임
하지만 이러한 오류를 무시하고 싶을 때가 있는데 try, except 를 이용해서 예외적으 로 오류를 처리할 수 있게 해줌
오류는 어떨 때 발생하는가?
오타를 입력했을 때 발생하는 구문 오류
디렉터리 안에 없는 파일을 열려고 시도할 때 발생하는 오류
>>> f = open(" 나없는파일",'r')
없는 파일을 열려고 시도하면 ‘FileNotFoundError’ 오류가 발생함
>>> 4 /0
4 를 0 으로 나누려니까 ‘ZeroDivisionError’ 오류가 발생함
리스트에 존재하지 않는 요소를 얻으려고 할 때 발생하는 오류
>>> a= [1,2,3]
>>> a[4]
a[4] 는 a 리스트에서 얻을 수 없는 값이므로 ‘IndexError’ 오류가 발생함
=> 오류 예외 처리 기법
==> try, except 문
기본 구조
try 블록 수행 중 오류가 발생하면 except 블록이 수행됨
하지만 try 블록에서 오류가 발생하지 않는다면, except 블록은 수행되지 않음
except 구문의 [ ] 기호는 괄호 안의 내용을 생략할 수 있다는 관례 표기법임
1. try, except 만 쓰는 방법
오류 종류에 상관없이 오류가 발생하면 except 블록을 수행함
2. 발생 오류만 포함한 except 문
오류가 발생했을 때 except 문에 미리 정해 놓은 오류 이름과 일치할 때만 except 블록을 수행한다는 의미임
3. 발생 오류와 오류 메시지 변수까지 포함한 except 문
두 번째 경우에서 오류 메시지의 내용까지 알고 싶을 때 사용하는 방법임
try:
4/0
except ZeroDivisionError as e:
print(e)
위처럼 4 를 0 으로 나누려고 하면 ZeroDivisionError 가 발생하여 except 블록이 실행되고 e 라는 오류 메시지를 다음과 같이 출력함
결과 =>
### 교재 224 페이지
a= [1,2,3]
try:
a[4]
except IndexError as e:
print(e)
결과 :
=> try ·· else
try 문은 else 절을 지원함
else 절은 예외가 발생하지 않은 경우에 실행되며 반드시 except 절 바로 다음에 위치함
try:
f = open('foo.txt','r')
except FileNotFoundError as e:
print(str(e))
else:
data = f.read()
print(data)
f.close()
만약 foo.txt 라는 파일이 없다면 except 절이 수행되고, 있다면 else 절이 수행됨
결과 =>
=> try ·· finally
try 문에는 finally 절을 사용할 수 있음
finally 절은 try 문 수행 도중 예외 발생 여부에 상관없이 항상 수행됨
보통 finally 절은 사용한 리소스를 close 해야 할 때에 많이 사용함
foo.txt 라는 파일을 쓰기 모드로 연 후에 try 문이 수행된 후 예외 발생 여부에 상 관없이 finally 절에서 f.close() 로 열린 파일을 닫을 수 있음
f = open('foo.txt','w')
try:
#
print(1)
finally:
f.close()
결과 =>
=> 여러 개의 오류 처리하기
0 으로 나누는 오류와 인덱싱 오류를 같이 처리한 예:
try:
a = [1,2]
print(a[3])
4/0
except ZeroDivisionError:
print("0.")
except IndexError:
print(".")
결과 =>
먼저 발생한 오류의 문자열이 출력됨
오류 메시지 변수를 사용한 예:
try:
a = [1,2]
print(a[3])
4/0
except ZeroDivisionError as e:
print(e)
except IndexError as e:
print(e)
결과 =>
ZeroDivisionError 와 IndexError 를 함께 처리한 예:
try:
a = [1,2]
print(a[3])
4/0
except (ZeroDivisionError,IndexError) as e:
print(e)
2 개 이상의 오류를 동시에 처리하기 위해 괄호로 묶어 처리함
결과 =>
=> 오류 회피하기
프로그래밍을 하다 보면 특정 오류가 발생할 경우 그냥 통과시켜야 할 때가 있음
try:
f = open('','r')
except FileNotFoundError:
pass
try 문 안에서 FileNotFoundError 가 발생할 경우에 pass 를 사용해 오류를 회피함
=> 오류 일부러 발생시키기 raise
프로그래밍을 하다 보면 오류를 일부러 발생시켜야 할 경우도 생김
raise NotImplementedError
메소드에 오류나 문제 발생시
raise 라는 명령어를 이용해 오류를 강제로 발생시킬 수 있음
raise
강제로 오류를 발생시키는 예"
class Bird:
def fly(self):
raise NotImplementedError
Bird 클래스를 상속받는 자식 클래스는 반드시 fly 라는 함수를 구현해야 한다는 의지를 보여 줌
자식 클래스가 fly 함수를 구현하지 않은 상태로 fly 함수를 호출한다면 어떻게 될까?
class Eagle(Bird):
pass
eagle = Eagle()
eagle.fly()
Eagle 클래스에서 fly 함수를 구현하지 않아서, Bird 클래스의 fly 함수가 호출됨
#NotImplementedError
#NameError: name 'NotError' is not defined
raise 문에 의해 NotImplemented Error 가 발생할 것임
NotImplementedError 가 발생되지 않게 하려면 Eagle 클래스에 fly 함수 구현해야 함
class Bird1:
def fly(self):
raise NotImplementedError
class Eagle1(Bird1):
def fly(self):
print("very fast")
eagle1 = Eagle1()
eagle1.fly()
자식 클래스에 fly 함수를 구현한 후 프로그램을 실행하면 오류 없이 출력됨
결과 =>
=> 예외 만들기
프로그램 수행 도중 특수한 경우에는 예외를 직접 만들어서 사용함
별명을 출력해 주는 예:
class MyError(Exception):
pass
def say_nick(nick):
if nick == '':
raise MyError()
print(nick)
say_nick(' 천사')
say_nick(' 바보')
#raise MyError()
결과 =>
프로그램 실행해 보면 ‘ 천사’ 가 한 번 출력된 후, MyError 가 발생함
예외 처리 기법을 사용하여 MyError 발생을 예외 처리해 봄:
class MyError(Exception):
pass
def say_nick(nick):
if nick == '':
raise MyError()
print(nick)
오류 메시지를 사용하고 싶다면 예외 처리해 봄
try:
say_nick('')
say_nick('')
except MyError:
print(".")
결과 =>
프로그램 실행해 보면 print(e) 로 오류 메시지가 출력되지 않는 것을 확인함
오류 클래스에 __str__ 메소드 구현
#myError-> 오류 메시지 만들어 지는 함수
class MyError(Exception):
def __str__(self):
return "."
def say_nick(nick):
if nick == '':
raise MyError()
print(nick)
try:
say_nick('')
say_nick('')
except MyError as e:
print(e)
결과 =>
__str__ 메소드는 print(e) 처럼 오류 메시지를 print 문으로 출력하느 메소드임
V. 내장 함수Don’t Reinvent The Wheel, 이미 있는 것을 다시 만드느라 쓸데없이 시간을 낭비하지 말라. 파이썬 내장 함수들은 import 없이 사용할 수 있음
=>abs
abs(x) 는 어떤 숫자를 입력을 받았을 때, 그 숫자의 절대값을 돌려주는 함수
>>> abs(3)
3
>>> abs(-3)
3
>>> abs(-1.2)
1.2
=> all
all(x) 는 반복 가능한 자료형 x 를 입력 인수로 받으며 이 x 가 모두 참이면 True, 거짓이 하나라도 있으면 False 를 돌려줌
>>> all([1,2,3])
True
리스트 자료형[1, 2, 3] 은 모든 요소가 참이므로 True 를 돌려줌
>>> all([1,2,3,0])
False
리스트 자료형[1, 2, 3, 0] 중에서 요소 0 은 거짓이므로 False 를 돌려줌
=> any
any(x) 는 x 중 하나라도 참이 있으면 True 를 돌려주고, x 가 모두 거짓일 때에만 False 를 돌려줌. all(x) 의 반대임.
any 는 all
>>> any([1,2,3,0])
True
리스트 자료형[1, 2, 3, 0] 중에서 1, 2, 3 이 참이므로 True 를 돌려줌
>>> any([0,""])
False
리스트 자료형[0, “”] 의 요소 0 과 “” 은 모두 거짓이므로 False 를 돌려줌
=> chr
chr(i) 는 아스키 코드 값을 입력으로 받아 그 코드에 해당하는 문자를 출력하는 함수
>>> chr(97)
'a'
>>> chr(48)
'0'
>>> chr(13)
'\r'
아스키 코드 97 은 소문자 a
아스키 코드 48 은 숫자 0
# 숫자화 한것 아스키 코드 0~ 126
>>> ord('a')
97
>>> ord('b')
98
ort->8 진수
dir 은 객체가 자체적으로 가지고 있는 변수나 함수를 보여줌
>>> dir([1,2,3])
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
>>> dir({'1':'a'})
['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
=> divmod
divmod(a, b) 는 2 개 숫자를 입력으로 받아서 a 를 b 로 나눈 몫과 나머지를 튜플 형태 로 돌려주는 함수
>>> div = divmod(7,3)
>>> div
(2, 1)
7 나누기 3 의 몫은 2, 나머지는 1
>>> div[0]
2
>>> div[1]
1
=>enumerate
순서가 있는 자료형( 리스트, 튜플, 문자열) 을 입력으로 받아 인덱스 값을 포함하는 enumerate 객체를 돌려주는 함수
>>> for i,name in enumerate(['body','foo','bar']):
... print(i,name)
...
0 body
1 foo
2 bar
>>> names = ['kim','lee','gil']
>>> for i, name in enumerate(names):
... print('%d 번: %s' % (i,name))
...
0 번: kim
1 번: lee
2 번: gil
순서 값과 함께 body, foo, bar 가 순서대로 출력됨
enumerate 를 for 문과 함께 사용하면 자료형의 현재 순서(index) 와 그 값을 쉽게 알 수 있음
for 문처럼 반복되는 구간에서 객체가 현재 어느 위치에 있는지 알려주는 인덱스 값이 필요할 때 enumerate 함수를 사용하면 유용함
=>eval
eval(expression) 은 실행 가능한 문자열(1+2, ‘hi’ + ‘a’ 등) 을 입력으로 받아 문자열을 실행한 결과값을 돌려주는 함수
eval 함수는 문자열을 계산한다.
>>> eval('1+2')
3
>>> eval("'hi'+'a'")
'hia'
>>> eval('divmod(4,3)')
(1, 1)
보통 eval 은 입력 받은 문자열로 파이썬 함수나 클래스를 동적으로 실행하고 싶 은 경우에 사용됨
=> filter
첫 번째 인수로 함수 이름을, 두 번째 인수로 그 함수에 차례로 들어갈 자료형을 받음
두 번째 인수인 반복 가능한 자료형 요소가 첫 번째 인수인 함수에 입력되었을 때 반 환 값이 참인 것만 걸러내서 돌려줌
positive 함수는 리스트를 입력받아 양수 값을 돌려주는 함수
#positive.py
def positive(l):
result = []
for i in l:
if i > 0:
result.append(i)
return result
print(positive([1, -3, 2, 0, -5, 6]))
결과 =>
filter 함수를 사용하면 앞의 내용을 간략하게 작성할 수 있음
def positive1(x):
return x >0
print(list(filter(positive1,[1, -3, 2, 0, -5, 6])))
결과값 =>
두 번째 인수인 리스트의 요소들이 첫 번째 인수인 positive 함수에 입력되었을 때 리턴값이 참인 것만 묶어서 돌려 줌
lambda 를 사용하면 더 간략하게 작성할 수 있음
print(list(filter(lambda x:x>0,[1, -3, 2, 0, -5, 6])))
결과값 =>
=>hex
hex(x) 는 정수 값을 입력받아 16 진수(hexadecimal) 로 변환하여 돌려주는 함수
>>> hex(234)
'0xea'
>>> hex(3)
'0x3'
=> id
id(object) 는 객체를 입력 받아 객체의 고유 주소 값( 레퍼런스) 을 돌려주는 함수
>>> a = 3
>>> id(a)
140722314516192
>>> id(3)
140722314516192
>>> b = a
>>> id(b)
140722314516192
3, a, b 는 모두 같은 객체를 가리킴 같은 고유 주소 값
id(4) 라고 입력하면 4 는 3, a, b 와 다른 객체이므로 다른 고유 주소 값이 출력됨
>>> id(4)
140722314516224
=>input
input([prompt]) 은 사용자 입력을 받는 함수
매개변수로 문자열을 주면, 그 문자열은 프롬프트가 됨
>>> a = input()
hi
>>> a
'hi'
>>> b = input("Enter:")
Enter:hi
>>> b
'hi'
Enter: 라는 프롬프트를 띄우고 사용자 입력을 받음
=>int
int(x) 는 문자열 형태의 숫자나 소수점이 있는 숫자 등을 정수 형태로 돌려주는 함수
>>> int('3')
3
>>> int(3.4)
3
int(x, radix) 는 radix 진수로 표현된 문자열 x 를 10 진수로 변환하여 돌려줌
>>> int('11',2)
3
>>> int('1A',16)
26
=>isinstance
isinstance(object, class) 는 첫 번째 인수로 인스턴스, 두 번째 인수로 클래스를 받음
인스턴스가 그 클래스의 인스턴스인지 판단해 참이면 True, 거짓이면 False 를 돌려줌
>>> class Person:pass
>>> a = Person()
>>> isinstance(a, Person)
True
a 가 Person 클래스가 만든 인스턴스이므로 True 를 돌려줌
>>> b = 3
>>> isinstance(b,Person)
False
b 는 Person 클래스가 만든 인스턴스가 아니므로 False 를 돌려줌
=>lambda
lambda 는 함수를 생성할 때 사용하는 예약어로 def 와 동일한 역할을 함
함수를 한 줄로 간결하게 만들 때 사용함
def 를 사용해야 할 정도로 복잡하지 않거나 def 를 사용할 수 없는 곳에 쓰임
[ 함수명 = ] lambda 매개변수1, 매개변수2, … : 매개변수를 사용한 표현식
리스트 내에 lambda 함수 만들기
>>> myList = [lambda a, b:a+b, lambda a, b:a*b]
>>> myList
[<function <lambda> at 0x000001D423D08E50>, <function <lambda> at 0x000001D423D08EE0>]
>>> myList[0]
<function <lambda> at 0x000001D423D08E50>
>>> myList[0](3,4)
7
리스트의 첫 번째 요소 myList[0] 은 2 개의 입력값을 받아 두 값의 합을 돌려주는 lambda 함수임
>>> myList[1](3,4)
12
리스트의 두 번째 요소 myList[1] 은 2 개의 입력값을 받아 두 값의 곱을 돌려주는 lambda 함수임
=> len
len(s) 은 입력값 s 의 길이( 요소의 전체 개수) 를 돌려주는 함수
>>> len("python")
6
>>> len([1,2,3])
3
>>> len((1,'a'))
2
=> list
list(s) 는 반복 가능한 자료형 s 를 입력받아 리스트를 돌려주는 함수
>>> list("python")
['p', 'y', 't', 'h', 'o', 'n']
>>> list((1,2,3))
[1, 2, 3]
list 함수에 리스트를 입력으로 주면 똑같은 리스트를 복사하여 돌려 줌
>>> a = [1,2,3]
>>> b = list(a)
>>> b
[1, 2, 3]
=> map
map(f, iterable) 은 함수(f) 와 반복 가능한(iterable) 자료형을 입력으로 받음
map 은 입력받은 자료형의 각 요소를 함수 f 가 수행한 결과를 묶어서 돌려주는 함수
two_times 함수는 리스트 요소를 입력받아 각 요소에 2 를 곱한 결과값을 돌려 줌 #two_times.py
def two_times(numberList):
result = []
for number in numberList:
result.append(number * 2)
return result
result = two_times([1,2,3,4])
print(result)# [2, 4, 6, 8]
결과 =>
==> map 함수를 사용하면 앞의 내용을 간략하게 작성할 수 있음
>>> def two_times(x):return x*2
>>> list(map(two_times,[1,2,3,4]))
[2, 4, 6, 8]
==> lambda 를 사용하면 더 간략하게 작성할 수 있음
>>> list(map(lambda a: a*2, [1,2,3,4]))
[2, 4, 6, 8]
=> max
max(iterable) 는 인수로 반복 가능한 자료형을 입력받아 최대값을 돌려주는 함수
>>> max([1,2,3])
3
>>> max("python")
'y'
=> min
min(iterable) 는 인수로 반복 가능한 자료형을 입력받아 최소값을 돌려주는 함수
>>> min([1,2,3])
1
>>> min("python")
'h'
=> oct
oct(x) 는 정수 형태의 숫자를 8 진수 문자열로 바꾸어 돌려주는 함수
>>> oct(34)
'0o42'
>>> oct(12345)
'0o30071'
=>open
b 바이너리 모드로 파일 열기
open(filename, [mode]) 은 ‘ 파일 이름’ 과 ‘ 읽기 방법‘ 을 입력받아 파일 객체를 돌려주는 함수
읽기 방법(mode) 을 생략하면 기본값인 읽기 전용 모드(r) 로 파일 객체를 만들어 돌려줌
b 는 w, r, a 와 함께 사용됨
>>> f = open("binary_fil", "rb")
rb 는 ‘ 바이너리 읽기 모드’ 를 의미함
>>> fread = open("read_mode.txt", "r")
>>> fread2 = open("read_mode.txt")
fread 와 fread2 는 동일한 방법임
즉, 모드 부분이 생략되면 기본값으로 읽기 모드인 r 을 갖게 됨
>>> fappend = open("append_mode.txt", "a")
추가 모드(a) 로 파일을 여는 예제임
=> ord
ord(c) 는 문자를 입력으로 받아 아스키 코드 값을 리턴하는 함수
>>> ord('a')
97
>>> ord('0')
48
=>pow
pow(x, y) 는 x 의 y 제곱한 결과값을 리턴하는 함수
>>> pow(2,4)
16
>>> pow(3,3)
27
=> range
range([start,]stop[,step]) 는 for 문과 함께 자주 사용되는 함수
입력받은 숫자에 해당하는 범위 값을 반복 가능한 객체로 만들어 돌려줌
==> 인수가 하나일 경우
>>> list(range(5))
[0, 1, 2, 3, 4]
시작 숫자를 지정해 주지 않으면 range 함수는 0 부터 시작함
==> 인수가 2 개일 경우
>>> list(range(5,10))
[5, 6, 7, 8, 9]
끝 숫자 10 은 포함되지 않는다는 것에 주의
입력으로 주어지는 2 개의 인수는 시작 숫자와 끝 숫자를 나타냄
==> 인수가 3 개일 경우
>>> list(range(1,10,2))
[1, 3, 5, 7, 9]
1 부터 9 까지, 숫자 사이의 거리는 2
>>> list(range(0,-10,-1))
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
0 부터 -9 까지, 숫자 사이의 거리는 -1
세 번째 인수는 숫자 사이의 거리를 의미함
=> round
round(number[,ndigits]) 함수는 숫자를 입력받아 반올림해 주는 함수
>>> round(4.6)
5
>>> round(4.2)
4
>>> round(5.678,2)
5.68
실수 5.678 을 소수점 2 자리까지만 반올림하여 표시
=> sorted
sorted(iterable) 함수는 입력값을 정렬한 후 그 결과를 리스트로 돌려주는 함수
객체 자체를 정렬하지 않음
>>> sorted(['a','c','b'])
['a', 'b', 'c']
>>> sorted(['a','c','c'])
['a', 'c', 'c']
>>> sorted("zero")
['e', 'o', 'r', 'z']
>>> a = [3,1,2]
>>> a
[3, 1, 2]
>>> sorted(a)
[1, 2, 3]
>>> a = [3,1,2]
>>> sorted(a,reverse = True)
[3, 2, 1]
>>> sorted([3,1,2])
[1, 2, 3]
>>> sorted(["a","c","b"])
['a', 'b', 'c']
>>> sorted("zero")
['e', 'o', 'r', 'z']
>>> a = [3,1,2]
>>> sorted(a)
[1, 2, 3]
>>> a
[3, 1, 2]
=> sort
sort(iterable) 함수는 리스트 객체 그 자체를 정렬할 뿐 정렬된 결과를 돌려주지 않음
sort 결과 값은 없고
>>> a = [3,1,2]
>>> result = a.sort() # sort 함수로 a 리스트 정렬
>>> print(result)
None # 반환값이 없기 때문에 None 이 출력됨
>>> a
[1, 2, 3]
>>> result = a.sort(reverse = True)
>>> a
[3, 2, 1]
sort 함수는 반환값이 없기 때문에 result 변수에 저장되는 값이 없음
따라서 print(result) 를 하면 None 이 출력됨
sort 함수를 수행한 후 반환값은 없지만, 리스트 객체 a 를 확인하면 [3, 1, 2] 가 [1, 2, 3] 으로 정렬됨
=> str
str(object) 은 문자열 형태로 객체를 반환하여 돌려주는 함수
>>> str(3)
'3'
>>> str('hi')
'hi'
>>> str('hi'.upper())
'HI'
=> sum
sum(iterable) 은 입력받은 리스트나 튜플의 모든 요소의 합을 돌려주는 함수
>>> sum([1,2,3])
6
>>> sum([4,5,6])
15
=> tuple
tuple(iterable) 은 반복 가능한 자료형을 입력 받아 튜플 형태로 바꾸어 돌려주는 함수
>>> tuple("abc")
('a', 'b', 'c')
>>> tuple([1,2,3])
(1, 2, 3)
>>> tuple((1,2,3))
(1, 2, 3)
튜플이 입력으로 들어오면 그대로 돌려준다
=> type
type(object) 은 입력값의 자료형이 무엇인지 알려 주는 함수
>>> type("abc") # “abc” 는 문자열 자료형
<class 'str'>
>>> type([]) # [ ] 는 리스트 자료형
<class 'list'>
>>> type(open("test","w")) # 파일 자료형
<class '_io.TextIOWrapper'>
=> zip
>>> list(zip([1,2,3,7],[4,5,6]))
[(1, 4), (2, 5), (3, 6)]
>>> list(zip([1,2,3],[4,5,6]))
[(1, 4), (2, 5), (3, 6)]
>>> list(zip([1,2,3],[4,5,6],[7,8,9]))
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
>>> list(zip("abc","def"))
[('a', 'd'), ('b', 'e'), ('c', 'f')]
VI. 외장 함수전 세계의 파이썬 사용자들이 만든 유용한 프로그램을 모아 놓은 것이 라이브러리임 파이썬 라이브러리는 설치할 때 자동으로 컴퓨터에 설치함
C:\Users\admin\AppData\Local\Programs\Python\Python38\Lib
=>sys
sys 모듈은 파이썬 인터프리터가 제공하는 변수와 함수를 제어할 수 있게 해주는 모듈
명령 행에서 인수 전달하기 - sys.argv
명령 프롬프트 창에서 test.py 뒤에 또 다른 값들을 함께 넣어 주면 sys.argv 리스트에 그 값이 추가됨
# C:/doit/Mymod/argv_test.py
import sys
print(sys.argv)
python 명령어 뒤의 모든 것들이 공백을 기준으로 나뉘어서 sys.argv 리스트의 요소가 됨
=> 강제로 스크립트 종료하기 - sys.exit
import sys
>>> sys.exit()
python shell 에서 가능하다.
sys.exit 는 [Ctrl+Z] 나 [Ctrl+D] 를 눌러서 대화형 인터프리터를 종료하는 것과 같음
프로그램 파일 내에서 사용하면 프로그램을 중단함
=> 자신이 만든 모듈 불러와 사용하기 - sys.path
>>> import sys
>>> sys.path
['C:\\doIt\\excersize', 'C:\\Users\\admin\\AppData\\Local\\Programs\\Python\\Python38\\Lib\\idlelib', 'C:\\Users\\admin\\AppData\\Local\\Programs\\Python\\Python38\\python38.zip', 'C:\\Users\\admin\\AppData\\Local\\Programs\\Python\\Python38\\DLLs', 'C:\\Users\\admin\\AppData\\Local\\Programs\\Python\\Python38\\lib', 'C:\\Users\\admin\\AppData\\Local\\Programs\\Python\\Python38', 'C:\\Users\\admin\\AppData\\Local\\Programs\\Python\\Python38\\lib\\site-packages']
sys.path 는 파이썬 모듈들이 저장되어 있는 위치를 나타냄
즉, 이 위치에 있는 파이썬 모듈들은 경로에 상관없이 어디에서나 불러올 수 있음
‘ ’ 는 현재 디렉터리를 의미함
# C:/doit/Mymod/path_append.py
import sys
sys.path.append("C:/doit/Mymod")
위와 같이 파이썬 프로그램 파일에서 sys.path.append 를 이용해 경로명을 추가함
이렇게 하고 난 후에는 C:\doit\Mymod 디렉터리에 있는 모듈을 불러와서 사용함
=>pickle
pickle->b binary 상태만 가능하다.
pickle 은 객체의 형태를 그대로 유지하면서 파일에 저장하고 불러올 수 있게 하는 모듈
>>> import pickle
>>> f = open("test.txt",'wb')
>>> data = {1:'python',2:'you need'}
>>> pickle.dump(data,f)
>>> f.close()
pickle 모듈의 dump 함수를 이용하여 딕셔너리 객체인 data 를 파일에 저장함
>>> import pickle
>>> f = open("test.txt",'rb')
>>> data = pickle.load(f)
>>> print(data)
{1: 'python', 2: 'you need'}
pickle.dump 로 저장한 파일을 pickle.load 를 이용해서 원래 있던 딕셔너리 객체 (data) 상태 그대로 불러옴
=>OS
OS 모듈은 환경 변수나 디렉터리, 파일 등의 OS 자원을 제어할 수 있게 해주는 모듈
=> 내 시스템의 환경 변수 값을 알고 싶을 때 - os.environ
>>> import os
>>> os.environ
os.environ 은 현재 시스템의 환경 변수에 대한 정보들을 딕셔너리 객체로 돌려줌
객체가 딕셔너리이기 때문에 다음과 같이 호출할 수 있음
>>> os.environ['PATH']
시스템의 PATH 환경 변수에 대한 내용임
=> 디렉터리 위치 변경하기 - os.chdir
>>> os.chdir("C:\WINDOWS")
os.chdir 을 사용하면 현재 디렉터리의 위치를 변경할 수 있음
=> 디렉터리 위치 돌려받기 - os.getcwd
>>> os.getcwd()
'C:\\doIt\\excersize'
=> 시스템 명령어 호출하기 - os.system
>>> os.system("dir")
0
시스템 자체의 프로그램이나 기타 명령어를 파이썬에서 호출할 수 있음
os.system(“ 명령어”) 처럼 사용함
현재 디렉터리에서 시스템 명령어인 dir 을 실행하는 예제임
os.environ[’PATH’] -> 시스템의 PATH 환경 변수에 대한 내용임
os.getcwd() ->current working director
os.chdir(”C:\WINDOWS”)->change director
sys.path.append("")
=> 실행한 시스템 명령어의 결과값 리턴 받기 - os.popen
>>> f= os.popen("dir")
os.popen 은 시스템 명령어를 실행시킨 결과값을 읽기 모드 형태의 파일 객체로 돌려줌
print(f.read())
읽어 들인 파일 객체의 내용을 보기 위해서는 read() 를 사용함
=> 기타 유용한 os 관련 함수
os.system(”dir”)
os.system("calc")
=> shutil
shutil 은 파일을 복사해 주는 파이썬 모듈
shutil 은 파일을 복사해 주는 파이썬 모듈
파일 복사하기 - shutil.copy(src, dst)
>>> import shutil
>>> shutil.copy("test.txt","dst.txt")
'dst.txt'
src.txt 파일과 동일한 내용의 파일이 dst.txt 로 복사되는 것을 확인함
=>glob
특정 디렉터리에 있는 파일 이름을 모두 알아야 할 때 사용하는 모듈
디렉터리에 있는 파일들을 리스트로 만들기 - glob(pathname)
>>> import glob
>>> glob.glob("C:\doIt\q*")
[]
glob 모듈은 디렉터리 내의 파일들을 읽어서 돌려줌
*, ? 등 메타 문자를 써서 원하는 파일만 읽어 들일 수 있음
=>tempfile
파일을 임시로 만들어서 사용할 때 유용한 모듈
tempfile.mktemp() 는 중복되지 않는 임시 파일의 이름을 무작위로 만들어서 돌려줌
>>> import tempfile
>>> filename = tempfile.mktemp()
>>> filename
'C:\\Users\\admin\\AppData\\Local\\Temp\\tmpi8xvs8as'
=> tempfile.TemporaryFile() 은 임시 저장 공간으로 사용할 파일 객체를 돌려줌
>>> import tempfile
>>> f = tempfile.TemporaryFile()
>>> f.close()# 생성한 임시 파일이 자동으로 삭제됨
이 파일은 기본적으로 바이너리 쓰기 모드(wb) 임
f.close() 가 호출되면 이 파일 객체는 자동으로 사라짐
>>> import time
>>> time.time()
1576554477.726312
>>> time.localtime(time.time())
time.struct_time(tm_year=2019, tm_mon=12, tm_mday=17, tm_hour=12, tm_min=48, tm_sec=5, tm_wday=1, tm_yday=351, tm_isdst=0)
=> time
==> time.time
>>> import time
>>> time.time()
1578386701.804986
time.time() 은 UTC(Universal Time Coordinated, 협정 세계 표준시) 를 사용하여 현재 시간을 실수 형태로 돌려주는 함수
1970 년 1 월 1 일 0 시 0 분 0 초를 기준으로 지난 시간을 초 단위로 돌려줌
=> time.localtime
>>> time.localtime(time.time())
time.struct_time(tm_year=2020, tm_mon=1, tm_mday=7, tm_hour=17, tm_min=45, tm_sec=43, tm_wday=1, tm_yday=7, tm_isdst=0)
time.localtime 은 time.time() 에 의해서 반환된 실수값을 이용해서 연도, 월, 일, 시, 분, 초, ··· 의 형태로 바꾸어 주는 함수
>>> t = time.localtime(time.time())
>>> t.tm_year
2019
=> time.asctime
>>> time.asctime(time.localtime(time.time()))
'Tue Jan 7 17:47:52 2020'
time.localtime 에 의해서 반환된 튜플 형태의 값을 인수로 받아서 날짜와 시간을 알아보기 쉬운 형태로 리턴하는 함수
=> time.ctime
>>> time.ctime()
'Tue Jan 7 17:48:22 2020'
time.strftime
strftime 함수는 시간에 관계된 것을 세밀하게 표현할 수 있는 포맷 코드를 제공
time.strftime(‘ 출력할 형식 포맷 코드’, time.localtime(time.time()))
시간에 관계된 것을 표현하는 포맷 코드
>>> time.strftime('%y%m%d',time.localtime(time.time()))
'191217'
>>> import time
>>> time.strftime('%x',time.localtime(time.time()))
'01/07/20'
>>> time.strftime('%c',time.localtime(time.time()))
'Tue Jan 7 21:15:17 2020'
time.strftime 을 사용한 예제임
=>time.sleep
#sleep1.py
import time
for i in range(10):
print(i)
time.sleep(1)
time.sleep 함수는 주로 루프 안에서 많이 사용됨
이 함수를 사용하면 일정한 시간 간격을 두고 루프를 실행할 수 있음
위의 예는 1 초 간격으로 0 부터 9 까지의 숫자를 출력함
time.sleep 함수의 인수는 실수 형태로 쓸 수 있음
=>calendar
carlendar 는 파이썬에서 달력을 볼 수 있게 해주는 모듈임
calendar.calendar( 연도) 로 사용하면 그 해 전체 달력을 볼 수 있음
>>> import calendar
>>> print(calendar.calendar(2020))
calendar.prcal( 연도) 를 사용해도 위와 같은 결과를 얻을 수 있음
>>> calendar.prcal(2020)
calendar.prmonth( 년도, 월) 로 사용하면 그 달의 달력만 보여줌
>>> calendar.prmonth(2020,1)
calendar.weekday( 연도, 월, 일) 함수는 그 날짜에 해당하는 요일 정보를 돌려줌
>>> calendar.weekday(2020,1,7)
월요일은 0, 화요일은 1, 수요일은 2, 목요일은 3, 금요일은 4, 토요일은 5, 일요일은 6 이라는 값을 돌려줌
calendar.monthrange( 연도, 월) 함수는 입력 받은 달의 1 일이 무슨 요일인지와 그 달이 며칠까지 있는지를 튜플 형태로 돌려줌
>>> calendar.monthrange(2020,1)
(2, 31)
2015 년 12 월 1 일은 화요일이고, 이 달은 31 일까지 있다는 것을 보여 줌
=> random
random 은 난수( 규칙이 없는 임의의 수) 를 발생시키는 모듈
random.random() 는 0.0 에서 1.0 사이의 실수 중에서 난수 값을 돌려줌
>>> import random
>>> random.random()
0.7571404612949787
>>> random.randint(1,10)
6
>>> random.randrange(0,20)
7
random.randint(x, y) 는 x 에서 y 사이의 정수 중에서 난수 값을 돌려줌
>>> random.randint(1,10)
8
>>> random.randint(1,55)
50
random.randrange(x, y[,z]) 는 x 에서 y 사이의 정수 중에서 난수 값을 돌려줌
>>> random.randrange(0,29)
1
random 모듈을 이용해서 재미있는 함수를 만들어 봄
#random_pop.py
import random
def random_pop(data): # 리스트의 요소 중에서 무작위로 하나를 선택하여 꺼내서 돌려줌
number = random.randint(0,len(data)-1)
return data.pop(number)
if __name__ == "__main__":
data = [1,2,3,4,5]
while data:
print(random_pop(data))
결과 =>
random_pop 함수는 random.choice 함수를 사용하면 직관적으로 만들 수 있음
def random_pop(data):
number = random.choice(data)
data.remove(number)
return number
if __name__ == "__main__":
data = [1,2,3,4,5]
while data:
print(random_pop(data))
결과 =>
random.shuffle 는 리스트의 항목을 무작위로 섞고 싶을 때는 사용하는 함수
>>> import random
>>> data = [1,2,3,4,5]
>>> random.shuffle(data)
>>> data
[4, 1, 3, 2, 5]
=> webbrowser
webbrowser 는 시스템에서 사용하는 기본 웹 브라우저를 자동으로 실행하는 모듈
>>> import webbrowser
>>> webbrowser.open("http://google.com ")
True
웹 브라우저를 자동으로 실행시키고, http://google.com 으로 가게 해줌
webbrower 의 open 함수는 웹 브라우저가 실행된 상태이면 입력주소로 이동함
>>> webbrowser.open_new("http://google.com ")
True
스레드를 다루는 thrading 모듈
컴퓨터에서 동작하고 있는 프로그램을 프로세스라고 한다.
보통 1 개의 프로세스는 한 가지 일만 하지만 스레드를 사용하면 한 프로세스 안에서 2 가지 또는 그 이상의 일을 동시에 수행할 수 있다.
#thread_test.py
import time
def long_task():#5 초의 시간이 걸리는 함수
for i in range(5):
time.sleep(1) #1.
print("working: %s \n" % i)
print("Start")
for i in range(5): #long_task 를 5 회 수행한다.
long_task()
print("End")
# 총 25 초의 시간이 걸린다.
#thread_test.py
import time
import threading # 스레드를 생성하기 위해서는 threading 모듈이 필요하다.
def long_task():#5 초의 시간이 걸리는 함수
for i in range(5):
time.sleep(1) #1.
print("working: %s \n" % i)
print("Start")
threads = []
for i in range(5): #long_task 를 5 회 수행한다.
t = threading.Thread(target = long_task) #.
threads.append(t)
for t in threads:
t.start() #.
print("End")
#5 초 걸린다.
#thread_test.py
import time
import threading # 스레드를 생성하기 위해서는 threading 모듈이 필요하다.
def long_task():#5 초의 시간이 걸리는 함수
for i in range(5):
time.sleep(1) #1.
print("working: %s \n" % i)
print("Start")
threads = []
for i in range(5): #long_task 를 5 회 수행한다.
t = threading.Thread(target = long_task) #.
threads.append(t)
for t in threads:
t.start() #.
for t in threads:
t.join() #join.
print("End")
working: 0
working: 1
working: 2
working: 3
working: 4
……..
#join 함수는 해당 스레드가 종료될 때 까지 기다리게 한다. 따라서 위와 같이 수정하면
# 우리가 원하던 출력을 보게 된다.
스레드가 하나하나 씩 진행된다.
working: 0
working: 0
working: 0
working: 0
working: 0
working: 0
working: 0
working: 0
working: 0
working: 0
……
연습문제
#262 페이지
#1.
class Calculator:
def __init__(self):
self.value = 0
def add(self, val):
self.value += val
class UpgrageCalculator(Calculator):
def minus(self, val):
self.value -= val
cal = UpgrageCalculator()
cal.add(10)
cal.minus(7)
print(cal.value) #10 에서 7 을 뺀 3 을 출력
#2.
class Calculator:
def __init__(self):
self.value = 0
def add(self, val):
self.value += val
class MaxLimitCalculator(Calculator):
def add(self, val):
self.value += val
if self.value > 100:
self.value = 100
cal= MaxLimitCalculator()
cal.add(50)#50 더하기
cal.add(60)#60 더하기
print(cal.value)#100 출력
#3.
>>> all([1,2,abs(-3)-3])
False
>>> chr(ord('a')) == 'a'
True
>>> abs(-3)-3
0
#4.
>>> list(filter(lambda x :x>0 ,[1,-2,3,-5,8,-3]))
[1, 3, 8]
#5.
>>> hex(234)
'0xea'
>>> int('0xea',16)
234
#6.
>>> list(map(lambda x: x* 3, [1,2,3,4]))
[3, 6, 9, 12]
#7.
>>> max([-8,2,7,5,-3,5,0,1])
7
>>> min([-8,2,7,5,-3,5,0,1])
-8
#8.
>>> 17 /3
5.666666666666667
>>> round(17/3,4)
5.6667
#9.cmd 창에서 호출
import sys
numbers = sys.argv[1:]# 파일 이름을 제외한 명령 행의 모든 입력
result = 0;
for number in numbers:
result += number
print(result)
#10.
import os
os.chdir("c:\doIt")
result = os.popen("dir")
print(result.read())
#11.
>>> import glob
>>> glob.glob("c:\doit\*.py")
[]
#12.
>>> import time
>>> time.strftime('%Y/%m/%d %H:%M:%S',time.localtime(time.time()))
'2020/01/07 22:11:15'
#13.
import random
result = []
while len(result) < 6:
num = random.randint(1,45)
if num not in result:
result.append(num)
print(result)
결과 =>
