Programming/Python
Python Basic
RNRF
2021. 1. 11. 18:40
| 개발 환경 | Windows 10 64bit |
| 개발 프로그램 | Python 3.8 & VScode(Visual Studio Code) <Filename : PythonWorkspace> |
1. 숫자 자료형
print(5) # 5
print(-10) # -10
print(3.14) # 3.14
print(1000) # 1000
print(5+3) # 8
print(2*8) # 16
print(3*(3+1)) # 12
2. 문자열 자료형
print('풍선') # 풍선
print("나비") # 나비
print("ㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋ") # ㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋ
print("ㅋ"*9) # ㅋㅋㅋㅋㅋㅋㅋㅋㅋ
3. boolean 자료형
# 참 / 거짓
print(5 > 10) # False
print(5 < 10) # True
print(True) # True
print(Fasle) # False
print(not True) # False
print(not False) # True
print(not (5 > 10)) # True
4. 변수
# 1. 애완동물을 소개해 주세요~
print("우리집 강아지의 이름은 연탄이예요")
print("연탄이는 4살이며, 산책을 아주 좋아해요")
print("연탄이는 어른일까요? True")
# 출력 결과
우리집 강아지의 이름은 연탄이예요
연탄이는 4살이며, 산책을 아주 좋아해요
연탄이는 어른일까요? True
# 2. 변수 사용
animal = "강아지"
name = "연탄이"
age = 4 # age는 정수형 자료형이라 그냥 "4"를 이용
hobby = "산책"
is_adult = (age >= 3)
print("우리집 " + animal + "의 이름은 " + name + "예요")
print(name + "는 " + str(age) + "살이며, " + hobby + "을 아주 좋아해요") # str : 정수형->문자형
print(name + "는 어른일까요? " + str(is_adult)) # boolean형도 str 사용하여 문자형으로 변환해야한다.
# 출력 결과
우리집 강아지의 이름은 연탄이예요
연탄이는 4살이며, 산책을 아주 좋아해요
연탄이는 어른일까요? True
# 3. 변수를 중간에 선언 가능
animal = "고양이"
name = "해피"
age = 4
hobby = "낮잠"
is_adult = (age >= 3)
print("우리집 " + animal + "의 이름은 " + name + "예요")
hobby = "공놀이"
print(name + "는 " + str(age) + "살이며, " + hobby + "을 아주 좋아해요")
print(name + "는 어른일까요? " + str(is_adult))
# 출력 결과
우리집 고양이의 이름은 해피예요
해피는 4살이며, 공놀이을 아주 좋아해요
해피는 어른일까요? True
# 4. '+'와 'str'을 사용하지 않고 정수형을 출력 가능 : ','
animal = "고양이"
name = "해피"
age = 4
hobby = "낮잠"
is_adult = (age >= 3)
print("우리집 " + animal + "의 이름은 " + name + "예요")
hobby = "공놀이"
print(name, "는 ", age, "살이며, ", hobby, "을 아주 좋아해요")
print(name + "는 어른일까요? " + str(is_adult))
# 출력 결과
우리집 고양이의 이름은 해피예요
해피는 4 살이며, 공놀이 을 아주 좋아해요 # ','를 이용하여 띄워쓰기가 한칸 포함된다는 것을 주의!
해피는 어른일까요? True
5. 주석
# 주석은 프로그램상 코드는 포함 되어있지만, 실제로 실행은 되지 않는 문장으로 처리하는것
# 현재 문장의 '#'을 주석이라고 한다.
# 코드 시작에 '#'을 써서 그 줄을 주석처리하거나,
'''이렇게
하면
여러문장이
주석처리
됩니다'''
"""이렇게도
여러문장이
주석처리
됩니다"""
# VScode 프로그램에서는 여러줄을 드래그한 후, 'Ctrl+/'를 누르면 일괄적으로 주석처리된다.
# 해제도 같은 방법이다. 'Ctrl+/'
6. Quiz.1)
Quiz.1) 변수를 이용하여 다음 문장을 출력하시오.
변수명 : station
변수값 : "사당", "신도림", "인천공항" 순서대로 입력
출력 문장 : XX행 열차가 들어오고 있습니다.
station = "사당"
print(station + "행 열차가 들어오고 있습니다.")
#출력 결과
사당행 열차가 들어오고 있습니다.
----------------------------------------------------
station = "신도림"
print(station + "행 열차가 들어오고 있습니다.")
#출력 결과
신도림행 열차가 들어오고 있습니다.
----------------------------------------------------
station = "인천공항"
print(station + "행 열차가 들어오고 있습니다.")
#출력 결과
인천공항 열차가 들어오고 있습니다.
7. 연산자
print(1+1) # 2
print(3-2) # 1
print(5*2) # 10
print(6/3) # 2
print(2**3) # 2^3 = 8
print(5%3) # 2 (나머지 구하기)
print(10%3) # 1
print(5//3) # 1 (몫 구하기)
print(10//3) # 3
print(10 > 3) # True
print(4 >= 7) # False
print(10 < 3) # False
print(5 <= 5) # True
print(3 == 3) # True
print(4 == 2) # False
print(3+4 == 7 # True
print(1 != 3) # True
print(not(1 != 3)) # False
print((3 > 0) and (3 < 5)) # True
print((3 > 0) & (3 < 5)) # True
print((3 > 0) or (3 > 5)) # True
print((3 > 0) | (3 > 5)) # True
print(5 > 4 > 3) # True
print(5 > 4 > 7) # False
8. 간단한 수식
print(2 + 3 * 4) # 14
print((2 + 3) * 4) # 20
number = 2 + 3 * 4
print(number) # 14
number = number + 2
print(number) # 16
number += 2
print(number) # 18
number *= 2
print(number) # 36
number /= 2
print(number) # 18
number -= 2
print(number) # 16
number %= 5
print(number) # 1
9. 숫자처리함수
print(abs(-5)) # 5 : 절댓값
print(pow(4, 2)) # 4^2 = 4*4 = 16 : ',' 뒤 숫자 제곱
print(max(5, 12)) # 12 : 최댓값
print(min(5, 12)) # 5 : 최솟값
print(round(3.14)) # 3 : 반올림
print(round(4.99)) # 5 : 반올림
from math import *
print(floor(4.99)) # 4 : 내림
print(ceil(3.14)) # 4 : 올림
print(sqrt(16)) # 4 : 제곱근
10. 랜덤 함수
from random import *
print(random()) # 0.0 ~ 1.0 미만의 임의의 값 생성
print(random() * 10) # 0.0 ~ 10.0 미만의 임의의 값 생성
print(int(random() * 10)) # 0.0 ~ 10.0 미만의 임의의 값 중 소수점 제외한 정수값만 출력
print(int(random() * 10) + 1) # 1 ~ 10 이하의 임의의 값 생성
# 로또 번호 생성 (1 ~ 45에서 임의의 값 6개 출력)
print(int(random() * 45) + 1) # 1 ~ 45 이하의 임의의 값 생성
print(int(random() * 45) + 1) # 1 ~ 45 이하의 임의의 값 생성
print(int(random() * 45) + 1) # 1 ~ 45 이하의 임의의 값 생성
print(int(random() * 45) + 1) # 1 ~ 45 이하의 임의의 값 생성
print(int(random() * 45) + 1) # 1 ~ 45 이하의 임의의 값 생성
print(int(random() * 45) + 1) # 1 ~ 45 이하의 임의의 값 생성
print(randrange(1, 46)) # 1 ~ 46 미만의 임의의 값 생성
print(randrange(1, 46)) # 1 ~ 46 미만의 임의의 값 생성
print(randrange(1, 46)) # 1 ~ 46 미만의 임의의 값 생성
print(randrange(1, 46)) # 1 ~ 46 미만의 임의의 값 생성
print(randrange(1, 46)) # 1 ~ 46 미만의 임의의 값 생성
print(randrange(1, 46)) # 1 ~ 46 미만의 임의의 값 생성
print(randint(1, 45)) # 1 ~ 45 이하의 임의의 값 생성
print(randint(1, 45)) # 1 ~ 45 이하의 임의의 값 생성
print(randint(1, 45)) # 1 ~ 45 이하의 임의의 값 생성
print(randint(1, 45)) # 1 ~ 45 이하의 임의의 값 생성
print(randint(1, 45)) # 1 ~ 45 이하의 임의의 값 생성
print(randint(1, 45)) # 1 ~ 45 이하의 임의의 값 생성
11. Quiz.2)
Quiz.2) 당신은 최근에 코딩 스터디 모임을 새로 만들었습니다.
월 4회 스터디를 하는데 3번은 온라인으로 하고 1벝은 오프라인으로 하기로 했습니다.
아래 조건에 맞는 오프라인 모임 날짜를 정해주는 프로그램을 작성하시오.
조건1 : 랜덤으로 날짜를 뽑아야 함
조건2 : 월별 날짜는 다름을 감안하여 최소 일수인 28일 이내로 정함
조건3 : 매월 1~3일은 스터디 준비를 해야하므로 제외
출력문 예제 : 오프라인 스터디 모임 날짜는 매월 x 일로 선정되었습니다.
from random import *
date = randint(4, 28)
print("오프라인 스터디 모임 날짜는 매월 " + date + " 일로 선정되었습니다.")
# 출력 결과
오프라인 스터디 모임 날짜는 매월 13 일로 선정되었습니다.
12. 문자열
sentence = '나는 소년입니다'
print(sentence)
# 출력 결과
나는 소년입니다
------------------------------------
sentence2 = "파이썬은 쉬워요"
print(sentence2)
# 출력 결과
파이썬은 쉬워요
------------------------------------
sentence3 = """
나는 소년이고,
파이썬은 쉬워요
"""
print(sentence3)
# 출력 결과
나는 소년이고,
파이썬은 쉬워요
#
13. 슬라이싱
jumin = "990120-1234567"
print("성별 : " + jumin[7]) # 성별 : 1
print("연 : " + jumin[0:2]) # 연 : 99
# 0부터 2직전까지 (0, 1)
print("월 : " + jumin[2:4]) # 월 : 01
# 2부터 4직전까지 (2, 3)
print("일 : " + jumin[4:6]) # 월 : 20
# 4부터 6직전까지 (4, 6)
print("생년월일 : " + jumin[:6]) # 생년월일 : 990120
# 처음부터 6직전까지 (0, 6)
print("뒤 7자리 : " + jumin[7:]) # 뒤 7자리 : 1234567
# 7부터 끝까지
print("뒤 7자리 (뒤에부터) : " + jumin[-7:]) # 뒤 7자리 (뒤에부터) : 1234567
# 맨 뒤에서 7번째부터 끝까지
14. 문자열 처리 함수
python = "Python is Amazing"
print(python.lower()) # python is amazing
print(python.upper()) # PYTHON IS AMAZING
print(python[0].isupper()) # True
print(len(python)) # 17
print(python.replace("Python", "Java")) # Java is Amazing
index = python.index("n")
print(index) # 5
index = python.index("n", index + 1)
print(index) # 15
print(python.find("Java")) # -1
print(python.index("Java")) # Error
print("hi") # Error가 나서 다음줄인 "hi"가 출력되지 않는다.
<But...>
print(pytho.find("Java")) # -1 (find는 에러가 나지 않는다.)
print("hi") # hi
print(python.count("n")) # 2
15. 문자열 포맷
print("a" + "b") # ab
print("a", "b") # a b
# 방법.1
print("나는 %d살입니다." % 20) # 나는 20살입니다.
print("나는 %s을 좋아해요." % "파이썬") # 나는 파이썬을 좋아해요.
print("Apple 은 %c로 시작해요." % "A") # Apple 은 A로 시작해요.
# %s
print("나는 %s살입니다." % 20) # 나는 20살입니다.
# 뒤의 문자열 순서대로 %s에 삽입된다.
print("나는 %s색과 %s색을 좋아해요." % ("파란", "빨간")) # 나는 파란색과 빨간색을 좋아해요.
# 방법.2
print("나는 {}살입니다.".format(20)) # 나는 20살입니다.
print("나는 {}색과 {}색을 좋아헤요.".format("파란", "빨간")) # 나는 파란색과 빨간색을 좋아해요.
print("나는 {0}색과 {1}색을 좋아해요.".format("파란", "빨간")) # 나는 파란색과 빨간색을 좋아해요.
print("나는 {1}색과 {10}색을 좋아해요.".format("파란", "빨간")) # 나는 빨간색과 파란색을 좋아해요.
# 방법.3
print("나는 {age}살이며, {color}색을 좋아해요.".format(age = 20, color = "빨간"))
print("나는 {age}살이며, {color}색을 좋아해요.".format(color = "빨간", age = 20))
# 출력 결과
나는 20살이며, 빨간색을 좋아해요.
나는 20살이며, 빨간색을 좋아해요.
# 방법.4 (ver3.6 이상~)
age = 20
color = "빨간"
print(f"나는 {age}살이며, {color}색을 좋아해요.")
# 출력 결과
나는 20살이며, 빨간색을 좋아해요.
16. 탈출 문자
print("백문이 불여일견 백견이 불여일타")
# 출력 결과
백문이 불여일견 백견이 불여일타
print("백문이 불여일견
백견이 불여일타")
# 출력 결과
Error
# \n : 줄바꿈
print("백문이 불여일견\n백견이 불여일타")
# 출력 결과
백문이 불여일견
백문이 불여일타
# \" or \' : 문자내에서 따옴표
# 출력문 : 저는 "나도코딩"입니다.
print("저는 "나도코딩"입니다.") # Error
print("저는 '나도코딩'입니다.") # 저는 '나도코딩'입니다.
print('저는 "나도코딩"입니다.') # 저는 "나도코딩"입니다.
print("저는 \"나도코딩\"입니다.") # 저는 "나도코딩"입니다.
print("저는 \'나도코딩\'입니다.") # 저는 '나도코딩'입니다.
# \\ : 문장내에서 \
print("C:\Users\RNRF\Desktop\PythonWorkspace") # Error
print("C:\\Users\\RNRF\\Desktop\\PythonWorkspace") # C:\Users\RNRF\Desktop\PythonWorkspace
# \r : 커서를 맨 앞으로 이동
print("Red Apple\rPine") # PineApple
# \b : 백스페이스 (한 글자 삭제)
print("Redd\bApple") # RedApple
# \t : 탭
print("Red\tApple") # Red Apple
17. Quiz.3)
Quiz.3) 사이트별로 비밀번호를 만들어주는 프로그램을 작성하시오.
Ex.) http://naver.com
규칙1 : http:// 부분을 제외 -> naver.com
규칙2 : 처음 만나는 점(.) 이후 부분은 제외 -> naver
규칙3 : 남은 글자 중 처음 세자리 + 글자 갯수 + 글자 내 'e' 갯수 + "!"로 구성
(nav) (5) (1) (!)
Ex.) 생성된 비밀번호 : nav51!
url = "http://naver.com"
my_str = url.replace("http://", "") # 규칙1
print(my_str) # naver.com
my_str = my_str[:my_str.index(".")] # 규칙2 : my_str[0:5] 0 ~ 5 직전까지. (0, 1, 2, 3, 4)
print(my_str) # naver
password = my_str[:3] + str(len(my_str)) + str(my_str.count("e")) + "!"
print("{0} 의 비밀번호는 {1} 입니다.".format(url, password))
# 출력 결과
http://naver.com 의 비밀번호는 nav51! 입니다.
<IF, "url" is different? ...>
url = "http://google.com"
my_str = url.replace("http://", "")
my_str = my_str[:my_str.index(".")]
password = my_str[:3] + str(len(my_str)) + str(my_str.count("e")) + "!"
print("{0} 의 비밀번호는 {1} 입니다.".format(url, password))
# 출력 결과
http://google.com 의 비밀번호는 goo61! 입니다.
18. 리스트
# 리스트 []
# 지하철 칸별로 10명, 20명, 30명
subway1 = 10
subway2 = 20
subway3 = 30
# 리스트를 이용하면 좀 더 간편하다
subway = [10, 20, 30]
print(subway) # [10, 20, 30]
subway = ["유재석", "조세호", "박명수"]
print(subway) # ['유재석', '조세호', '박명수']
# 조세호씨가 몇 번째 칸에 타고 있는가?
print(subway.index("조세호")) # 1
# 하하씨가 다음 정류장에서 다음칸에 탐
subway.append("하하") # append는 무조건 맨 뒤에 추가한다.
print(subway) # ['유재석', '조세호', '박명수', '하하']
# 정형돈씨를 유재석 / 조세호 사이에 태워봄
subway.insert(1, "정형돈")
print(subway) # ['유재석', '정형돈', '조세호', '박명수', '하하']
# 지하철에 있는 사람을 한명씩 뒤에서 꺼냄
print(subway.pop()) # 하하
print(subway) # ['유재석', '정형돈', '조세호', '박명수']
print(subway.pop()) # 박명수
print(subway) # ['유재석', '정형돈', '조세호']
print(subway.pop()) # 조세호
print(subway) # ['유재석', '정형돈']
# 같은 이름의 사람이 몇명이 있는지 확인
subway,append("유재석")
print(subway) # ['유재석', '정형돈', '유재석']
print(subway.count("유재석")) # 2# 정렬도 가능
num_list = [5,2,4,3,1]
num_list.sort()
print(num_list) # [1, 2, 3, 4, 5]
# 순서 뒤집기 가능
num_list.reverse()
print(num_list) # [5, 4, 3, 2, 1]
# 모두 지우기
num_list.clear()
print(num_list) # []
# 다양한 자료형 함께 사용
num_list = [5,2,4,3,1]
mix_list = ["조세호", 20, True]
print(mix_list) # ['조세호', 20, True]
# 리스트 확장
num_list.extend(mix_list)
print(num_list) # [5, 2, 4, 3, 1, '조세호', 20, True]
19. 사전
cabinet = {3:"유재석", 100:"김태호"}
print(cabinet[3]) # 유재석
print(cabinet[100]) # 김태호
print(cabinet.get(3)) # 유재석
print(cabinet[5]) # Error
print("hi") # 6번줄의 Error문에 의해 출력이 되지 않는다.
print(cabinet.get(5)) # None
print("hi") # hi : get은 "None"을 표시하고 다음줄을 실행할 수 있다.
print(cabinet.get(5, "사용가능")) # 사용가능 : [5]가 없다면 뒤의 문자인 "사용가능"을 출력한다.
print("hi") # hi : get은 "None"을 표시하고 다음줄을 실행할 수 있다.
# 'in'을 이용한 사전에 속한 값이 있는지, 없는지를 확인할 수 있다.
print(3 in cabinet) # True
print(5 in cabinet) # Falsecabinet = {"A-3":"유재석", "B-100":"김태호"}
print(cabinet["A-3"]) # 유재석
print(cabinet["B-100"]) # 김태호
# 새 손님
print(cabinet) # {'A-3': '유재석', 'B-100': '김태호'}
cabinet["A-3"] = "김종국" # "A-3"의 "유재석" 대신 "김종국"으로 바뀜
cabinet["C-20"] = "조세호" # "C-20"이라는 새로운 사전에 "조세호"를 추가한다.
print(cabinet) # {'A-3': '김종국', 'B-100': '김태호', 'C-20': '조세호'}
# 간 손님
del cabinet["A-3"]
print(cabinet) # {'B-100': '김태호', 'C-20': '조세호'}
# key들만 출력
print(cabinet.keys()) # dict_keys(['B-100', 'C-20'])
# value들만 출력
print(cabinet.values()) # dict_values(['김태호', '조세호'])
# key, value 쌍으로 출력
print(cabinet.items()) # dict_items([('B-100', '김태호'), ('C-20', '조세호')])
# 목욕탕 폐점
cabinet.clear() # 사전의 모든 값을 지울수 있다.
print(cabinet) # {}
20. 튜플 ( 리스트와 달리 값을 변경할 수 없다. 리스트보다 속도가 빠르다.)
menu = ("돈까스", "치즈까스")
print(menu[0]) # 돈까스
print(menu[1]) # 치즈까스
# menu.add("생선까스") # Error : 'tuple' object has no attribute 'add'
# 일반적인 변수 선언
name = "김종국"
age = 20
hobby = "코딩"
print(name, age, hobby) # 김종국 20 코딩
# 튜플을 이용한 선언
(name, age, hobby) = ("김종국", 20, "코딩")
print(name, age, hobby) # 김종국 20 코딩
21. 세트
# 집합 (set)
# 중복 안됨, 순서 없음
my_set = {1,2,3,3,3}
print(my_str) # {1, 2, 3}
java = {"유재석", "김태호", "양세형"}
python = set(["유재석", "박명수"])
# 교집합 (java와 python을 모두 할 수 있는 개발자)
print(java & python) # {'유재석'}
print(java.intersection(python)) # {'유재석'}
# 합집합 (java를 할 수 있거나, python을 할 수 있는 개발자)
print(java | python) # {'김태호', '박명수', '유재석', '양세형'}
print(java.union(python)) # {'김태호', '박명수', '유재석', '양세형'}
# 차집합 (java를 할 수 있지만, python은 할 줄 모르는 개발자)
print(java - python) # {'양세형', '김태호'}
print(java.difference(python)) # {'양세형', '김태호'}
# python을 할 줄 아는 사람이 늘어남
python.add("김태호")
print(python) # {'박명수', '김태호', '유재석'}
# java를 잊었어요
java.remove("김태호")
print(java) # {'유재석', '양세형'}
22. 자료구조의 변경
# 자료구조의 변경
# 커피숍
menu = {"커피", "우유", "주스"}
print(menu, type(menu)) # {'커피', '우유', '주스'} <class 'set'>
menu = list(menu)
print(menu, type(menu)) # ['커피', '우유', '주스'] <class 'list'>
menu = tuple(menu)
print(menu, type(menu)) # ('커피', '우유', '주스') <class 'tuple'>
menu = set(menu)
print(menu, type(menu)) # {'커피', '우유', '주스'} <class 'set'>
23. Quiz.4)
Quiz.4) 당신의 학교에서는 파이썬 코딩 대회를 주최합니다.
참석률을 높이기 위해 댓글 이벤트를 진행하기로 하였습니다.
댓글 작성자들 중에 추첨을 통해 1명은 치킨, 3명은 커피 쿠폰을 받게 됩니다.
추첨 프로그램을 작성하시오.
조건1 : 편의상 댓글은 20명이 작성하였고, 아이디는 1~20이라고 가정
조건2 : 댓글 내용과 상관없이 무작위로 추첨하되 중복불가
조건3 : random 모듈의 shuffle과 sample을 활용
출력 예제 :
-- 당첨자 발표 --
치킨 당첨자 : 1
커피 당첨자 : [2, 3, 4]
-- 축하합니다 --
활용 예제 :
from random import *
lst = [1,2,3,4,5]
print(lst) # [1, 2, 3, 4, 5]
shuffle(lst)
print(lst) # [5, 4, 1, 3, 2] : 리스트에서 번호순서를 무작위로 출력
print(sample(lst, 1)) # [3] : 첫번째 인자인 리스트에서 두번째 인자인 몇개만큼 무작위로 샘플로 뽑겠다
Ex.)
from random import *
users = range(1,21)
# print(type(users)) # <class 'range'>
users = list(users) # 'shuffle'에서 'range'형은 사용할 경우 Error
# print(type(users)) # <class 'list'>
# print(users) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
shuffle(users)
# print(users) # [1, 18, 19, 5, 14, 8, 10, 7, 4, 15, 3, 12, 20, 16, 13, 11, 2, 9, 6, 17]
print(" -- 당첨자 발표 -- ")
print("치킨 당첨자 : {0}".format(winners[0]))
print("커피 당첨자 : {0}".format(winners[1:]))
print(" -- 축하합니다 -- ")
# 출력 결과
-- 당첨자 발표 --
치킨 당첨자 : 20
커피 당첨자 : [1, 3, 11]
-- 축하합니다 --
24. if
# 날씨
weather = input("오늘 날씨는 어때요? ")
if weather == "비" or weather == "눈":
print("우산을 챙기세요")
elif weather == "미세먼지":
print("마스크를 챙기세요")
else:
print("준비물 필요 없어요")
# 출력 결과
오늘 날씨는 어때요? 비(Enter Key)
우산을 챙기세요
------------------------------
오늘 날씨는 어때요? 미세먼지(Enter Key)
마스크를 챙기세요
------------------------------
오늘 날씨는 어때요? 맑아요(Enter Key)
준비물 필요 없어요
# 온도
temp = int(input("기온은 어때요? "))
if 30 <= temp:
print("너무 더워요. 나가지 마세요")
elif 10 <= temp and temp < 30: # 'and'를 사용해서 이어붙여도 되고,
print("괜찮은 날씨에요")
elif 0 <= temp < 10: # 수식처럼 이어붙여서 사용해도 결과는 같다
print("외투를 챙기세요")
else:
print("너무 추워요. 나가지 마세요")
# 출력 결과
기온은 어때요? 35(Enter Key)
너무 더워요. 나가지 마세요
------------------------------
기온은 어때요? 20(Enter Key)
괜찮은 날씨에요
------------------------------
기온은 어때요? 5(Enter Key)
외투를 챙기세요
------------------------------
기온은 어때요? -20(Enter Key)
너무 추워요. 나가지 마세요
25. for
# for문을 쓰지 않고 출력할때
print("대기번호 : 1") # 대기번호 : 1
print("대기번호 : 2") # 대기번호 : 2
print("대기번호 : 3") # 대기번호 : 3
print("대기번호 : 4") # 대기번호 : 4
for waiting_no in [0, 1, 2, 3, 4]:
print("대기번호 : {0}".format(waiting_no))
# 출력 결과
대기번호 : 0
대기번호 : 1
대기번호 : 2
대기번호 : 3
대기번호 : 4
# randrange()
for waiting_no in range(1, 6): # 1부터 6직전까지
print("대기번호 : {0}".format(waiting_no))
# 출력 결과
대기번호 : 1
대기번호 : 2
대기번호 : 3
대기번호 : 4
대기번호 : 5
# 스타벅스 손님 부르기
starbucks = ["아이언맨", "토르", "아이엠 그루트"]
for customer in starbucks:
print("{0}, 커피가 준비되었습니다.".format(customer))
# 출력 결과
아이언맨, 커피가 준비되었습니다.
토르, 커피가 준비되었습니다.
아이엠 그루트, 커피가 준비되었습니다.
26. while
# while
customer = "토르"
index = 5
while index >= 1:
print("{0}, 커피가 준비되었습니다. {1}번 남았어요.".format(customer, index))
index -= 1
if index == 0:
print("커피는 폐기처분되었습니다.")
# 출력 결과
토르, 커피가 준비되었습니다. 5번 남았어요.
토르, 커피가 준비되었습니다. 4번 남았어요.
토르, 커피가 준비되었습니다. 3번 남았어요.
토르, 커피가 준비되었습니다. 2번 남았어요.
토르, 커피가 준비되었습니다. 1번 남았어요.
커피는 폐기처분되었습니다.
customer = "아이언맨"
index = 1
while True:
print("{0}, 커피가 준비되었습니다. 호출 {1}회".format(customer, index))
index += 1
# 출력 결과
아이언맨, 커피가 준비되었습니다. 호출 1회
아이언맨, 커피가 준비되었습니다. 호출 2회
아이언맨, 커피가 준비되었습니다. 호출 3회
아이언맨, 커피가 준비되었습니다. 호출 4회
아이언맨, 커피가 준비되었습니다. 호출 5회
아이언맨, 커피가 준비되었습니다. 호출 6회
아이언맨, 커피가 준비되었습니다. 호출 7회
아이언맨, 커피가 준비되었습니다. 호출 8회
...... (계속 출력, 멈출려면 'Ctrl+C')
customer = "토르"
person = "Unknown"
while person != customer: # 조건이 만족될때까지 계속 반복한다
print("{0}, 커피가 준비되었습니다.".format(customer))
person = input("이름이 어떻게 되세요? ")
# 출력 결과
토르, 커피가 준비되었습니다.
이름이 어떻게 되세요? 아이언맨(Enter Key)
토르, 커피가 준비되었습니다.
이름이 어떻게 되세요? 아이엠 그루트(Enter Key)
토르, 커피가 준비되었습니다.
이름이 어떻게 되세요? 토르(Enter Key) # 'person != customer' 조건이 만족하여 반복문을 탈출한다
27. continue와 break
absent = [2, 5] # 결석
for student in range(1, 11): # 1,2,3,4,5,6,7,8,9,10
if student in absent:
continue
print("{0}, 책을 읽어봐".format(student))
# 출력 결과
1, 책을 읽어봐
3, 책을 읽어봐
4, 책을 읽어봐
6, 책을 읽어봐
7, 책을 읽어봐
8, 책을 읽어봐
9, 책을 읽어봐
10, 책을 읽어봐
absent = [2, 5] # 결석
no_book = [7] # 책을 깜빡했음
for student in range(1, 11): # 1,2,3,4,5,6,7,8,9,10
if student in absent:
continue
elif student in no_book:
print("오늘 수업 여기까지. {0}는 교무실로 따라와".format(student))
break
print("{0}, 책을 읽어봐".format(student))
# 출력 결과
1, 책을 읽어봐
3, 책을 읽어봐
4, 책을 읽어봐
6, 책을 읽어봐
오늘 수업 여기까지. 7는 교무실로 따라와
28. 한 줄 for
# 출석번호가 1 2 3 4, 앞에 100을 붙이기로 함 -> 101, 102, 103, 104.
students = [1,2,3,4,5]
print(students) # [1, 2, 3, 4, 5]
students = [i+100 for i in students]
print(students) # [101, 102, 103, 104, 105]
# 학생 이름을 길이로 변환
students = ["Iron man", "Thor", "I am groot"]
students = [len(i) for i in students]
print(students) # [8, 4, 10]
# 학생 이름을 대문자로 변환
students = ["Iron man", "Thor", "I am groot"]
students = [i.upper() for i in students]
print(students) # ['IRON MAN', 'THOR', 'I AM GROOT']
29. Quiz.5)
Quiz.5) 당신은 Cocoa 서비스를 이용하는 택시기사님입니다.
50명의 승객과 매칭 기회가 있을때, 총 탑승 승객수를 구하는 프로그램을 작성하시오.
조건1 : 승객별 운행소요시간은 5분 ~ 50분 사이의 난수로 정해집니다.
조건2 : 당신은 소요시간 5분 ~ 15분 사이의 승객만 매칭해야 합니다.
출력 예제 :
[0] 1번째 손님 (소요시간 : 15분)
[ ] 2번째 손님 (소요시간 : 50분)
[0] 3번째 손님 (소요시간 : 5분)
...
[ ] 50번째 손님 (소요시간 : 16분)
총 탑승 승객 : 2 분
Ex.)
from random import *
cnt = 0 # 총 탑승 승객 수
for customer in range(1, 51): # 승객 수 : 1 ~ 50명
waiting_time = randrange(5, 51) # 조건1 : 5 ~ 50분
if 5 <= waiting_time <= 15: # 조건2 : 5 ~ 15분 이내의 손님(=매칭 성공), 탑승 승객 수를 증가 처리
print("[0] {0}번째 손님 (소요시간 : {1}분)".format(customer, waiting_time))
cnt += 1
else: # 매칭에 실패한 경우
print("[ ] {0}번째 손님 (소요시간 : {1}분)".format(customer, waiting_time))
print("총 탑승 승객 : {0} 분".format(cnt))
# 출력 결과
[ ] 1번째 손님 (소요시간 : 20분)
[ ] 2번째 손님 (소요시간 : 40분)
[0] 3번째 손님 (소요시간 : 9분)
[ ] 4번째 손님 (소요시간 : 49분)
[ ] 5번째 손님 (소요시간 : 33분)
[ ] 6번째 손님 (소요시간 : 18분)
[0] 7번째 손님 (소요시간 : 8분)
[ ] 8번째 손님 (소요시간 : 42분)
[ ] 9번째 손님 (소요시간 : 19분)
[0] 10번째 손님 (소요시간 : 12분)
[0] 11번째 손님 (소요시간 : 5분)
[ ] 12번째 손님 (소요시간 : 42분)
[ ] 13번째 손님 (소요시간 : 49분)
[ ] 14번째 손님 (소요시간 : 25분)
[ ] 15번째 손님 (소요시간 : 29분)
[ ] 16번째 손님 (소요시간 : 33분)
[0] 17번째 손님 (소요시간 : 10분)
[0] 18번째 손님 (소요시간 : 7분)
[ ] 19번째 손님 (소요시간 : 49분)
[ ] 20번째 손님 (소요시간 : 22분)
[ ] 21번째 손님 (소요시간 : 17분)
[ ] 22번째 손님 (소요시간 : 33분)
[ ] 23번째 손님 (소요시간 : 25분)
[ ] 24번째 손님 (소요시간 : 48분)
[0] 25번째 손님 (소요시간 : 8분)
[ ] 26번째 손님 (소요시간 : 18분)
[0] 27번째 손님 (소요시간 : 6분)
[ ] 28번째 손님 (소요시간 : 35분)
[ ] 29번째 손님 (소요시간 : 44분)
[ ] 30번째 손님 (소요시간 : 19분)
[ ] 31번째 손님 (소요시간 : 41분)
[ ] 32번째 손님 (소요시간 : 41분)
[ ] 33번째 손님 (소요시간 : 19분)
[0] 34번째 손님 (소요시간 : 10분)
[ ] 35번째 손님 (소요시간 : 43분)
[ ] 36번째 손님 (소요시간 : 30분)
[ ] 37번째 손님 (소요시간 : 28분)
[ ] 38번째 손님 (소요시간 : 20분)
[ ] 39번째 손님 (소요시간 : 43분)
[ ] 40번째 손님 (소요시간 : 46분)
[ ] 41번째 손님 (소요시간 : 17분)
[0] 42번째 손님 (소요시간 : 15분)
[0] 43번째 손님 (소요시간 : 13분)
[ ] 44번째 손님 (소요시간 : 24분)
[ ] 45번째 손님 (소요시간 : 24분)
[ ] 46번째 손님 (소요시간 : 27분)
[ ] 47번째 손님 (소요시간 : 20분)
[ ] 48번째 손님 (소요시간 : 40분)
[ ] 49번째 손님 (소요시간 : 25분)
[0] 50번째 손님 (소요시간 : 9분)
총 탑승 승객 : 12 분
30. 함수
def open_account():
print("새로운 계좌가 생성되었습니다.")
open_account()
# 출력 결과
새로운 계좌가 생성되었습니다.
31. 전달값과 반환값
def open_account():
print("새로운 계좌가 생성되었습니다.")
def deposit(balance, money): # 입금
print("입금이 완료되었습니다. 잔액은 {0} 원입니다.".format(balance + money))
return balance + money
balance = 0 # 잔액
balance = deposit(balance, 1000)
print(balance)
# 출력 결과
입금이 완료되었습니다. 잔액은 1000 원입니다.
1000
---------------------------------------------------------------------------
def open_account():
print("새로운 계좌가 생성되었습니다.")
def deposit(balance, money): # 입금
print("입금이 완료되었습니다. 잔액은 {0} 원입니다.".format(balance + money))
return balance + money
def withdraw(balance, money): # 출금
if balance >= money: # 잔액이 출금보다 많으면
print("출금이 완료되었습니다. 잔액은 {0} 원입니다.".format(balance - money))
return balance - money
else:
print("출금이 완료되지 않았습니다. 잔액은 {0} 원입니다.".format(balance))
return balance
balance = 0 # 잔액
balance = deposit(balance, 1000)
balance = withdraw(balance, 2000)
# 출력 결과
입금이 완료되었습니다. 잔액은 1000 원입니다.
출금이 완료되지 않았습니다. 잔액은 1000 원입니다.
---------------------------------------------------------------------------
def open_account():
print("새로운 계좌가 생성되었습니다.")
def deposit(balance, money): # 입금
print("입금이 완료되었습니다. 잔액은 {0} 원입니다.".format(balance + money))
return balance + money
def withdraw(balance, money): # 출금
if balance >= money:
print("출금이 완료되었습니다. 잔액은 {0} 원입니다.".format(balance - money))
return balance - money
else:
print("출금이 완료되지 않았습니다. 잔액은 {0} 원입니다.".format(balance))
return balance
balance = 0 # 잔액
balance = deposit(balance, 1000)
balance = withdraw(balance, 500)
# 출력 결과
입금이 완료되었습니다. 잔액은 1000 원입니다.
출금이 완료되었습니다. 잔액은 500 원입니다.
---------------------------------------------------------------------------
def open_account():
print("새로운 계좌가 생성되었습니다.")
def deposit(balance, money): # 입금
print("입금이 완료되었습니다. 잔액은 {0} 원입니다.".format(balance + money))
return balance + money
def withdraw(balance, money): # 출금
if balance >= money:
print("출금이 완료되었습니다. 잔액은 {0} 원입니다.".format(balance - money))
return balance - money
else:
print("출금이 완료되지 않았습니다. 잔액은 {0} 원입니다.".format(balance))
return balance
def withdraw_night(balance, money): # 저녁에 출금
commission = 100 # 수수료 100원
return commission, balance - money - commission # 튜플 형식?
balance = 0 # 잔액
balance = deposit(balance, 1000)
commission, balance = withdraw_night(balance, 500) # 두개를 한꺼번에 받는다?
print("수수료 {0} 원이며, 잔액은 {1} 원입니다.".format(commission, balance))
# 출력 결과
입금이 완료되었습니다. 잔액은 1000 원입니다.
수수료 100 원이며, 잔액은 400 원입니다.
32. 기본값
def profile(name, age, main_lang):
print("이름 : {0}\t나이 : {1}\t주 사용 언어 : {2}" \
# '\' : 줄이 길어서 줄바꿈할때
.format(name, age, main_lang))
profile("유재석", 20, "파이썬")
profile("김태호", 25, "자바")
# 출력 결과
이름 : 유재석 나이 : 20 주 사용 언어 : 파이썬
이름 : 김태호 나이 : 25 주 사용 언어 : 자바
----------------------------------------------------------------------------
# 같은 학교, 같은 학년, 같은 반, 같은 수업
def profile(name, age=17, main_lang="파이썬"):
print("이름 : {0}\t나이 : {1}\t주 사용 언어 : {2}" \
.format(name, age, main_lang))
profile("유재석")
profile("김태호")
# 출력 결과
이름 : 유재석 나이 : 17 주 사용 언어 : 파이썬
이름 : 김태호 나이 : 17 주 사용 언어 : 파이썬
33. 키워드값 : 함수에 들어간 변수들을 순서와 상관없이 '키워드'를 통해 알아서 맞춰서 출력해준다.
def profile(name, age, main_lang):
print(name, age, main_lang)
profile(name="유재석", main_lang="파이썬", age=20)
profile(main_lang="자바", age=25, name="김태호")
# 출력 결과
유재석 20 파이썬
김태호 25 자바
34. 가변 인자
# 일반적으로 여러가지 변수를 받는 상황
def profile(name, age, lang1, lang2, lang3, lang4, lang5):
print("이름 : {0}\t나이 : {1}\t".format(name, age), end = " ") # 'end' : 개행이 아닌 바로 뒤에 출력해줌
print(lang1, lang2, lang3, lang4, lang5)
profile("유재석", 20, "Python", "java", "C", "C++", "C#")
profile("김태호", 25, "Kotlin", "Swift", "", "", "")
# 출력 결과
이름 : 유재석 나이 : 20 Python java C C++ C#
이름 : 김태호 나이 : 25 Kotlin Swift
# 가변 인자(+for문)을 이용해 여러가지 변수를 받는 상황
def profile(name, age, *language):
print("이름 : {0}\t나이 : {1}\t".format(name, age), end = " ")
for lang in language:
print(lang, end=" ")
print() # 개행추가
profile("유재석", 20, "Python", "java", "C", "C++", "C#", "JavaScript") # 위에 처럼 lang을 선언하지 않고도 추가가능
profile("김태호", 25, "Kotlin", "Swift")
# 출력 결과
이름 : 유재석 나이 : 20 Python java C C++ C# JavaScript
이름 : 김태호 나이 : 25 Kotlin Swift
35. 지역변수와 전역변수
지역변수 : 함수내에서만 사용 가능(함수 호출때 만들었다가 끝나면 사라진다.)
전역변수 : 프로그램 어디서든 부를수 있는 변수
gun = 10
def checkpoint(soldiers): # 경계근무
gun = gun - soldiers # 지역변수 'gun'
print("[함수 내] 남은 총 : {0}".format(gun))
pritn("전체 총 : {0}".format(gun))
checkpoint(2) # 2명이 경계근무 나감
print("남은 총 : {0}".format(gun))
# 출력 결과
Error - Why? : 'gun'은 함수내에서 만들어진 변수인데 초기화가 되지 않았기 때문에
------------------------------------------------------------------------
gun = 10
def checkpoint(soldiers): # 경계근무
gun = 20 # 지역변수 선언
gun = gun - soldiers
print("[함수 내] 남은 총 : {0}".format(gun))
print("전체 총 : {0}".format(gun))
checkpoint(2) # 2명이 경계근무 나감
print("남은 총 : {0}".format(gun))
# 출력 결과 (Error가 나타지않지만...)
전체 총 : 10 # 첫줄의 'gun = 10'이 출력
[함수 내] 남은 총 : 18 # 첫줄의 'gun = 10'이 아닌 함수내의 'gun = 20'을 받아서 출력된다.
남은 총 : 10 # 첫줄의 'gun = 10'이 출력
------------------------------------------------------------------------
gun = 10
def checkpoint(soldiers): # 경계근무
global gun # 전역 공간에 있는 gun 사용
gun = gun - soldiers
print("[함수 내] 남은 총 : {0}".format(gun))
print("전체 총 : {0}".format(gun))
checkpoint(2) # 2명이 경계근무 나감
print("남은 총 : {0}".format(gun))
# 출력 결과 (일반적으로 많이 사용되지는 않는다.)
전체 총 : 10
[함수 내] 남은 총 : 8
남은 총 : 8
------------------------------------------------------------------------
gun = 10
def checkpoint_ret(gun, soldiers):
gun = gun - soldiers
print("[함수 내] 남은 총 : {0}".format(gun))
return gun
print("전체 총 : {0}".format(gun))
gun = checkpoint_ret(gun, 2)
print("남은 총 : {0}".format(gun))
# 출력 결과 (함수를 이용한 반환값으로 지역변수 값을 변경하는게 가장 보기 좋다.)
전체 총 : 10
[함수 내] 남은 총 : 8
남은 총 : 8
36. Quiz.6)
Quiz.6) 표준 체중을 구하는 프로그램을 작성하시오.
* 표준 체중 : 각 개인의 키에 적당한 체중
(성별에 따른 공식)
남자 : 키(m) x 키(m) x 22
여자 : 키(m) x 키(m) x 21
조건1 : 표준 체중은 별도의 함수 내에서 계산
* 함수명 : std_weight
* 전달값 : 키(height), 성별(gender)
조건2 : 표준 체중은 소수점 둘째자리까지 표시
출력 예제 :
키 175cm 남자의 표준 체중은 67.38kg 입니다.
Ex.)
def std_weight(height, gender):
if gender == "남자":
return height * height * 22
else:
return height * height * 21
height = 175 # cm 단위
gender = "남자"
weight = round(std_weight(height / 100, gender), 2) # 조건2 : 'round'를 소수점 둘째자리까지 표시
print("키 {0}cm {1}의 표준 체중은 {2} 입니다.".format(height, gender, weight))
# 출력 결과
키 175cm 남자의 표준 체중은 67.38 입니다.
37. 표준입출력
print("Python", "Java") # Python Java : ','는 한칸 띄워서 출력
print("Python" + "Java") # PythonJava : '+'는 이어서 출력
print("Python", "Java", sep=",") # Python,Java : 띄워쓰기가 ','로 바뀌어 출력
print("Python", "Java", "JavaScript", sep=" vs ") # Python vs Java vs JavaScript : 띄워쓰기가 ' vs '로 바뀌어 출력
---------------------------------------------------------------------------------------
print("Python", "Java", sep=",")
print("무엇이 더 재밌을까요?")
# 출력 결과 (보통 'print'는 마지막에 개행이 자동으로 들어가고 출력된다.)
Python,Java
무엇이 더 재밌을까요?
print("Python", "Java", sep=",", end="?")
print("무엇이 더 재밌을까요?")
# 출력 결과 (마지막의 개행 대신 '?'로 바꿔서 출력된다. -> end="?")
Python,Java?무엇이 더 재밌을까요?
---------------------------------------------------------------------------------------
import sys
print("Python", "Java", file=sys.stdout)
print("Python", "Java", file=sys.stderr)
# 출력 결과
Python Java # 표준 출력으로 처리된다.
Python Java # 표준 에러로 처리된다.
---------------------------------------------------------------------------------------
# 시험 성적
scores = {"수학":0, "영어":50, "코딩":100} # 딕셔너리 형식 : key와 value
for subject, score in scores.items(): # key와 value를 튜플로 쌍으로 보내준다.
print(subject, score)
# 출력 결과
수학 0
영어 50
코딩 100
# 좀 더 출력결과를 깔끔하게 정렬해서
scores = {"수학":0, "영어":50, "코딩":100}
for subject, score in scores.items():
print(subject.ljust(8), str(score).rjust(4), sep=":")
# ljust : 왼쪽으로 정렬, '(8)'은 8칸을 확보한 상태로의 의미)
# rjust : 오른쪽으로 정렬, '(4)'는 4칸을 확본한 상태로의 의미)
# 출력 결과
수학 : 0
영어 : 50
코딩 : 100
---------------------------------------------------------------------------------------
# 은행 대기순번표
# 001, 002, 003, ...
for num in range(1,21):
print("대기번호 : " + str(num).zfill(3)) # zfill : 빈공간을 '0'으로 채워서 출력한다.
# 출력 결과
대기번호 : 001
대기번호 : 002
대기번호 : 003
대기번호 : 004
대기번호 : 005
대기번호 : 006
대기번호 : 007
대기번호 : 008
대기번호 : 009
대기번호 : 010
대기번호 : 011
대기번호 : 012
대기번호 : 013
대기번호 : 014
대기번호 : 015
대기번호 : 016
대기번호 : 017
대기번호 : 018
대기번호 : 019
대기번호 : 020
---------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------
# 표준 입력 : 표준 입력으로 입력받은 값은 무조건 '문자형'으로 저장된다.
answer = input("아무 값이나 입력하세요 : ")
print("입력하신 값은 " + answer + "입니다.")
# 출력 결과.1 : 정수형(숫자)
아무 값이나 입력하세요 : 10(Enter Key)
입력하신 값은 10입니다.
# 일반적으로 'str(answer)'를 해야하지만... Error가 나타나지 않는다.
# Why? 숫자가 문자형으로 저장되었기 때문이다.
# 출력 결과.2 : 문자열
아무 값이나 입력하세요 : 나도코딩(Enter Key)
입력하신 값은 나도코딩입니다.
38. 다양한 출력포맷
# 빈 자리는 빈공간으로 두고, 오른쪽 정렬을 하되, 총 10자리 공간을 확보
# {0: >10} : 빈공간은 ' '이고, 오른쪽 정렬은 '>'이고, 총 10자리 공간확보는 '10'이다.
print("{0: >10}".format(500))
# 출력 결과
500
---------------------------------------------------------------------------------------
# 양수일 땐 +로 표시, 음수일 땐 -로 표시
print("{0: >+10}".format(500))
print("{0: >+10}".format(-500))
# 출력 결과
+500
-500
---------------------------------------------------------------------------------------
# 왼쪽 정렬하고, 빈칸으로 _로 채움
print("{0:_<+10}".format(500))
print("{0:_<10}".format(500))
# 출력 결과
+500______
500_______
---------------------------------------------------------------------------------------
# 3자리마다 콤마를 찍어주기
print("{0:,}".format(100000000000))
# 3자리마다 콤마를 찍어주기, +/- 부호도 붙이기
print("{0:+,}".format(100000000000))
print("{0:+,}".format(-100000000000))
# 출력 결과
100,000,000,000
+100,000,000,000
-100,000,000,000
---------------------------------------------------------------------------------------
# 3자리마다 콤마를 찍어주기, 부호도 붙이고, 자릿수 확보하기
# 돈이 많으면 행복하니까. 빈 자리는 '^'로 채워주기
print("{0:^<+30,}".format(100000000000))
# 출력 결과
+100,000,000,000^^^^^^^^^^^^^^
---------------------------------------------------------------------------------------
# 소수점 출력
print("{0:f}".format(5/3))
# 소수점 특정 자리수까지만 표시
print("{0:.2f}".format(5/3)) # 소수점 3째 자리에서 반올림
# 출력 결과
1.666667
1.67
39. 파일 입출력
# 파일에 내용쓰기
score_file = open("score.txt", "w", encoding="utf8")
# 'w'는 쓰기 용도
# encoding을 하지 않을시 한글이 깨질수 있다.
print("수학 : 0", file=score_file)
print("영어 : 50", file=score_file)
score_file.close() # 열었던 파일을 닫는것까지 해줘야한다.
# 출력 결과
score.txt # 파일이 생성된다.
수학 : 0
영어 : 50
---------------------------------------------------------------------------------------
score_file = open("score.txt", "a", encoding="utf8")
# 'a'는 뒤에 이어쓰기 용도 (=append)
score_file.write("과학 : 80")
score_file.write("\n코딩 : 100")
# print는 자동으로 개행이 있지만, write는 없기 때문에 '\n'을 추가한다.
score_file.close()
# 출력 결과
score.txt # 기존에 있는 파일 이어쓰기
수학 : 0
영어 : 50
과학 : 80
코딩 : 100
---------------------------------------------------------------------------------------
# 파일을 읽어오기
score_file = open("score.txt", "r", encoding="utf8")
print(score_file.read())
score_file.close()
# 출력 결과
수학 : 0
영어 : 50
과학 : 80
코딩 : 100
---------------------------------------------------------------------------------------
score_file = open("score.txt", "r", encoding="utf8")
print(score_file.readline(), end="")
# 줄별로 읽기, 한 줄 읽고 커서는 다음 줄로 이동
# 'end'는 줄바꿈 기능 제거
print(score_file.readline(), end="")
print(score_file.readline(), end="")
print(score_file.readline(), end="")
score_file.close()
# 출력 결과
수학 : 0
영어 : 50
과학 : 80
코딩 : 100
---------------------------------------------------------------------------------------
# 파일을 불러올때 그 파일의 내용이 몇줄인지 모를때는? 반복문 이용
score_file = open("score.txt", "r", encoding="utf8")
while True:
line = score_file.readline()
if not line:
break
print(line, end="")
score_file.close()
# 출력 결과
수학 : 0
영어 : 50
과학 : 80
코딩 : 100
---------------------------------------------------------------------------------------
score_file = open("score.txt", "r", encoding="utf8")
lines = score_file.readlines()
# list 형태로 저장
for line in lines:
print(line, end="")
score_file.close()
# 출력 결과
수학 : 0
영어 : 50
과학 : 80
코딩 : 100
40. pickle : 프로그램 상에서 사용하고 있는 데이터를 파일형태로 저장(&불러오기)해준다.
<주의!!! 만약, 파이썬 파일명이 'pickle.py'로 되어있다면 Error가 발생한다. 파일명을 'my_pickle.py'로 변경하니 성공>
(AttributeError: partially initialized module 'pickle' has no attribute 'dump')
import pickle
profile_file = open("profile.pickle", "wb") # 'b'는 바이너리 파일을 의미한다. 'pickle'을 사용할 때 필수
profile = {"이름":"박명수", "나이":30, "취미":["축구", "골프", "코딩"]}
print(profile)
pickle.dump(profile, profile_file) # profile에 있는 정보를 profile_file에 저장
profile_file.close()
# 출력 결과
{'이름': '박명수', '나이': 30, '취미': ['축구', '골프', '코딩']}
profile.pickle # 파일이 생성된다.
��M # 내부의 내용은 깨지는것이 보인다. Why???
------------------------------------------------------------------------------------------
profile_file = open("profile.pickle", "rb")
profile = pickle.load(profile_file) # profile_file에 있는 정보를 profile에 불러오기
print(profile)
profile_file.close()
# 출력 결과
{'이름': '박명수', '나이': 30, '취미': ['축구', '골프', '코딩']}
41. with : 일반적으로 우리가 파일 작업을 할때, 파일을 열고, 파일을 닫는 작업을 했지만 'with'를 사용하면 좀 더 편하게 작업할 수 있다.
import pickle
with open("profile.pickle", "rb") as profile_file:
print(pickle.load(profile_file))
# 출력 결과
{'이름': '박명수', '나이': 30, '취미': ['축구', '골프', '코딩']}
# 해석
open("profile.pickle", "rb") : 'profile.pickle'이라는 파일을 열어서
as profile_file: : 'profile_file'이라는 변수에 저장하고
print(pickle.load(profile_file)) : 'profile_file'의 데이터를 'pickle.load'를 통해 불러와서 'print'로 출력해준다.
# 열었던 파일에 대해서 'close()' 하지 않아도 자동으로 종료해준다.
------------------------------------------------------------------------------------------
# 일반적인 파일을 pickle을 사용하지 않고 파일을 쓰고, 읽을때는?
# 쓰기
with open("study.txt", "w", encoding="utf8") as study_file:
study_file.write("파이썬을 열심히 공부하고 있어요")
# 출력 결과
study.txt # 파일이 생성된다.
파이썬을 열심히 공부하고 있어요
------------------------------------------------------------------------------------------
# 불러오기(읽기)
with open("study.txt", "r", encoding="utf8") as study_file:
print(study_file.read())
# 출력 결과
파이썬을 열심히 공부하고 있어요
42. Quiz.7)
Quiz.7) 당신의 회사에서는 매주 1회 작성해야하는 보고서가 있습니다.
보고서는 항상 아래와 같은 형태로 출력되어야 합니다.
1주차부터 50주차까지의 보고서 파일을 만드는 프로그램을 작성하시오.
조건 : 파일명은 '1주차.txt', '2주차.txt', ... 와 같이 만듭니다.
출력 예제 :
- X 주차 주간보고 -
부서 :
이름 :
업무 요약 :
Ex.)
for i in range(1, 51):
with open(str(i) + "주차.txt", "w", encoding="utf8") as report_file:
report_file.write("- {0} 주차 주간보고 -".format(i))
report_file.write("\n부서 :")
report_file.write("\n이름 :")
report_file.write("\n업무 요약")
# 출력 결과 : 1 ~ 50주차까지의 파일이 생성된다.
1주차.txt
2주차.txt
...
49주차.txt
50주차.txt
# 1주차.txt 파일의 내용
- 1 주차 주간보고 -
부서 :
이름 :
업무 요약
43. 클래스
# 클래스 없이 유닛을 생성한다면?
# 마린 : 공격 유닛, 군인. 총을 쏠 수 있음
name = "마린" # 유닛의 이름
hp = 40 # 유닛의 체력
damage = 5 # 유닛의 공격력
print("{0} 유닛이 생성되었습니다.".format(name))
print("체력 {0}, 공격력 {1}\n".format(hp, damage))
# 탱크 : 공격 유닛, 탱크. 포를 쏠 수 있는데, 일반모드 / 시즈모드.
tank_name = "탱크"
tank_hp = 150
tank_damage = 35
print("{0} 유닛이 생성되었습니다.".format(tank_name))
print("체력 {0}, 공격력 {1}\n".format(tank_hp, tank_damage))
def attack(name, location, damage):
print("{0} : {1} 방향으로 적군을 공격합니다. [공격력 {2}]".format( \
name, location, damage))
attack(name, "1시", damage)
attack((tank_name), "1시", damage)
# 출력 결과
마린 유닛이 생성되었습니다.
체력 40, 공격력 5
탱크 유닛이 생성되었습니다.
체력 150, 공격력 35
마린 : 1시 방향으로 적군을 공격합니다. [공격력 5]
탱크 : 1시 방향으로 적군을 공격합니다. [공격력 35]
----------------------------------------------------------------------------------------
# 만약, 탱크가 하나 더 추가된다면?
# 마린 : 공격 유닛, 군인. 총을 쏠 수 있음
name = "마린" # 유닛의 이름
hp = 40 # 유닛의 체력
damage = 5 # 유닛의 공격력
print("{0} 유닛이 생성되었습니다.".format(name))
print("체력 {0}, 공격력 {1}\n".format(hp, damage))
# 탱크 : 공격 유닛, 탱크. 포를 쏠 수 있는데, 일반모드 / 시즈모드.
tank_name = "탱크"
tank_hp = 150
tank_damage = 35
print("{0} 유닛이 생성되었습니다.".format(tank_name))
print("체력 {0}, 공격력 {1}\n".format(tank_hp, tank_damage))
tank2_name = "탱크"
tank2_hp = 150
tank2_damage = 35
print("{0} 유닛이 생성되었습니다.".format(tank2_name))
print("체력 {0}, 공격력 {1}\n".format(tank2_hp, tank2_damage))
def attack(name, location, damage):
print("{0} : {1} 방향으로 적군을 공격합니다. [공격력 {2}]".format( \
name, location, damage))
attack(name, "1시", damage)
attack((tank_name), "1시", tank_damage)
attack((tank2_name), "1시", tank2_damage)
# 출력 결과
마린 유닛이 생성되었습니다.
체력 40, 공격력 5
탱크 유닛이 생성되었습니다.
체력 150, 공격력 35
탱크 유닛이 생성되었습니다.
체력 150, 공격력 35
마린 : 1시 방향으로 적군을 공격합니다. [공격력 5]
탱크 : 1시 방향으로 적군을 공격합니다. [공격력 35]
탱크 : 1시 방향으로 적군을 공격합니다. [공격력 35]
----------------------------------------------------------------------------------------
# 만약, 수십개, 수백개의 유닛을 지정해야한다면? 'Class'가 필요하다.
# 'Class'는 '붕어빵 틀'에 비유한다. 같은 무언가를 찍어내는것에서 의미가 비슷하다.
class Unit:
def __init__(self, name, hp, damage):
self.name = name
self.hp = hp
self.damage = damage
print("{0} 유닛이 생성되었습니다.".format(self.name))
print("체력 {0}, 공격력 {1}".format(self.hp, self.damage))
marine1 = Unit("마린", 40, 5)
marine2 = Unit("마린", 40, 5)
tank = Unit("탱크", 150, 35)
# 출력 결과
마린 유닛이 생성되었습니다.
체력 40, 공격력 5
마린 유닛이 생성되었습니다.
체력 40, 공격력 5
탱크 유닛이 생성되었습니다.
체력 150, 공격력 35
44. __init__
class Unit:
def __init__(self, name, hp, damage): # '__init__'은 파이썬에 생성자를 의미한다.
# 마린이나 탱크라는 객체가 생성될때 자동으로 호출되는 부분.
self.name = name
self.hp = hp
self.damage = damage
print("{0} 유닛이 생성되었습니다.".format(self.name))
print("체력 {0}, 공격력 {1}".format(self.hp, self.damage))
marine1 = Unit("마린", 40, 5) # 'class'로 의해 만들어진것을 객채라고 한다.
marine2 = Unit("마린", 40, 5) # 마린과 탱크는 'Unit' 클래스의 '인스턴스'라고 표현할 수 있다.
tank = Unit("탱크", 150, 35)
marine3 = Unit("마린")
marine4 = Unit("마린", 40)
# 출력 결과
Error : 12번줄과 13번줄
Why? 함수뒤에 정의된 'self'를 제외한 요소 갯수(3개)만큼 선언을 해주어야한다.
45. 멤버 변수
class Unit:
def __init__(self, name, hp, damage):
self.name = name # 'self' 뒤의 'name'이 멤버 변수가 된다.
self.hp = hp # 'self' 뒤의 'hp'이 멤버 변수가 된다.
self.damage = damage # 'self' 뒤의 'damage'이 멤버 변수가 된다.
# 멤버 변수라고 하는것은 클래스 내에서 정의된 변수고, 그 변수를 가지고 초기화 할 수도 있고 쓸수도 있는것.
print("{0} 유닛이 생성되었습니다.".format(self.name))
print("체력 {0}, 공격력 {1}".format(self.hp, self.damage))
# 클래스 외부에서 작성
# 레이스 : 공중 유닛, 비행기. 클로킹 (상대방에게 보이지 않음)
wraith1 = Unit("레이스", 80, 5)
print("유닛 이름 : {0}, 공격력 : {1}".format(wraith1.name, wraith1.damage)) # 'wraith1.name, wraith1.damage'
# 출력 결과
레이스 유닛이 생성되었습니다.
체력 80, 공격력 5
유닛 이름 : 레이스, 공격력 : 5
----------------------------------------------------------------------------------------
class Unit:
def __init__(self, name, hp, damage):
self.name = name # 'self' 뒤의 'name'이 멤버 변수가 된다.
self.hp = hp # 'self' 뒤의 'hp'이 멤버 변수가 된다.
self.damage = damage # 'self' 뒤의 'damage'이 멤버 변수가 된다.
# 멤버 변수라고 하는것은 클래스 내에서 정의된 변수고, 그 변수를 가지고 초기화 할 수도 있고 쓸수도 있는것.
print("{0} 유닛이 생성되었습니다.".format(self.name))
print("체력 {0}, 공격력 {1}".format(self.hp, self.damage))
# marine1 = Unit("마린", 40, 5)
# marine2 = Unit("마린", 40, 5)
# tank = Unit("탱크", 150, 35)
# 레이스 : 공중 유닛, 비행기. 클로킹 (상대방에게 보이지 않음)
# 클래스 외부에서 작성
wraith1 = Unit("레이스", 80, 5)
print("유닛 이름 : {0}, 공격력 : {1}".format(wraith1.name, wraith1.damage)) # 'wraith1.name, wraith1.damage'
# 마인드 컨트롤 : 상대방 유닛을 내 것으로 만드는것 (빼앗음)
wraith2 = Unit("빼앗은 레이스", 80, 5)
wraith2.clocking = True
# 'clocking'이라는 변수는 'Unit' 클래스에 없는 변수이지만 외부의 'wraith2'에서 변수를 추가로 할당한 것이다.
# 파이썬에서는 추가로 변수를 외부에서 만들어서 쓸 수 있다. 하지만 'wraith1'에는 없는 변수라서 Error가 발생한다.
if wraith2.clocking == True:
print("{0}는 현재 클로킹 상태입니다.".format(wraith2.name))
# 클래스 외부에서 내가 원하는 변수를 확장을 할 수 있지만
# 그러한 확정된 변수는 확정을 한 객체에만 적용된다. 기존의 객체에는 적용되지 않는다.
46. 메소드 : 우리가 클래스를 만들면서 그 안에 만들어 넣은 함수를 의미한다.
class Unit:
def __init__(self, name, hp, damage):
self.name = name
self.hp = hp
self.damage = damage
print("{0} 유닛이 생성되었습니다.".format(self.name))
print("체력 {0}, 공격력 {1}".format(self.hp, self.damage))
# 공격 유닛
class AttackUnit:
def __init__(self, name, hp, damage): # 'self'는 자기 자신을 의미한다. 또한 클래스 내에서 메소드 앞에는 항상 'self'를 적는다.
self.name = name
self.hp = hp
self.damage = damage
def attack(self, location):
print("{0} : {1} 방향으로 적군을 공격합니다. [공격력 : {2}]"\
.format(self.name, location, self.damage))
# 'self.name'과 'self.damage'는 위에서 정의된 name과 damage를 쓰지만
# 'location'은 '.format(self.name, location, self.damage))'에서 전달받은 변수를 쓴다.
def damaged(self, damage):
print("{0} : {1} 데미지를 입었습니다.".format(self.name, damage))
self.hp -= damage
print("{0} : 현재 체력은 {1} 입니다.".format(self.name, self.hp))
if self.hp <= 0:
print("{0} : 파괴되었습니다.".format(self.name))
# 파이어뱃 : 공격 유닛, 화염방사기.
firebat1 = AttackUnit("파이어뱃", 50, 16)
firebat1.attack("5시")
# 공격 2번 받는다고 가정
firebat1.damaged(25)
firebat1.damaged(25)
# 출력 결과
파이어뱃 : 5시 방향으로 적군을 공격합니다. [공격력 : 16] # 'attack'이라는 함수를 통해서 출력됨.
파이어뱃 : 25 데미지를 입었습니다. # 'damaged'라는 함수를 통해서 출력됨.
파이어뱃 : 현재 체력은 25 입니다.
파이어뱃 : 25 데미지를 입었습니다.
파이어뱃 : 현재 체력은 0 입니다.
파이어뱃 : 파괴되었습니다.
47. 상속
# 일반 유닛
class Unit:
def __init__(self, name, hp):
self.name = name
self.hp = hp
# 일반 유닛, 공격 유닛에서 'self.name, self.hp' 부분이 겹친다. 이러한 상황에서 '상속'을 사용한다.
# 상속 받으면 '멤버 변수'와 '메소드'를 사용할 수 있게 된다.
# 공격 유닛
class AttackUnit(Unit): # '(Unit)' = 상속 기능 사용을 위해 추가
def __init__(self, name, hp, damage):
Unit.__init__(self, name, hp) # 상속 기능 사용을 위해 추가
self.damage = damage
def attack(self, location):
print("{0} : {1} 방향으로 적군을 공격합니다. [공격력 : {2}]"\
.format(self.name, location, self.damage))
def damaged(self, damage):
print("{0} : {1} 데미지를 입었습니다.".format(self.name, damage))
self.hp -= damage
print("{0} : 현재 체력은 {1} 입니다.".format(self.name, self.hp))
if self.hp <= 0:
print("{0} : 파괴되었습니다.".format(self.name))
# 매딕 : 의무병. (데미지가 없음)
# 파이어뱃 : 공격 유닛, 화염방사기.
firebat1 = AttackUnit("파이어뱃", 50, 16)
firebat1.attack("5시")
# 공격 2번 받는다고 가정
firebat1.damaged(25)
firebat1.damaged(25)
# 출력 결과 : '46. 메소드'와 같은 결과가 나온다.
파이어뱃 : 5시 방향으로 적군을 공격합니다. [공격력 : 16]
파이어뱃 : 25 데미지를 입었습니다.
파이어뱃 : 현재 체력은 25 입니다.
파이어뱃 : 25 데미지를 입었습니다.
파이어뱃 : 현재 체력은 0 입니다.
파이어뱃 : 파괴되었습니다.
48. 다중 상속 : '자식 클래스'에서 '부모 클래스'를 여러개 받는것.
# 일반 유닛
class Unit: # 부모클래스
def __init__(self, name, hp):
self.name = name
self.hp = hp
# 공격 유닛
class AttackUnit(Unit): # 자식클래스
def __init__(self, name, hp, damage):
Unit.__init__(self, name, hp)
self.damage = damage
def attack(self, location):
print("{0} : {1} 방향으로 적군을 공격합니다. [공격력 : {2}]"\
.format(self.name, location, self.damage))
def damaged(self, damage):
print("{0} : {1} 데미지를 입었습니다.".format(self.name, damage))
self.hp -= damage
print("{0} : 현재 체력은 {1} 입니다.".format(self.name, self.hp))
if self.hp <= 0:
print("{0} : 파괴되었습니다.".format(self.name))
# 드랍쉽 : 공중 유닛, 수송기. 마린 / 파이어뱃 / 탱크 등을 수송. 공격X
# 날 수 있는 기능을 가진 클래스
class Flyable:
def __init__(self, flying_speed):
self.flying_speed = flying_speed
def fly(self, name ,location):
print("{0} : {1} 방향으로 날아갑니다. [속도 {2}]"\
.format(name, location, self.flying_speed))
# 공중 공격 유닛 클래스
class FlyableAttackUnit(AttackUnit, Flyable): # 다중 상속
def __init__(self, name, hp, damage, flying_speed):
AttackUnit.__init__(self, name, hp, damage)
Flyable.__init__(self, flying_speed)
# 발키리 : 공중 공격 유닛, 한번에 14발 미사일 발사.
valkyrie = FlyableAttackUnit("발키리", 200, 6, 5)
valkyrie.fly(valkyrie.name, "3시")
# 출력 결과
발키리 : 3시 방향으로 날아갑니다. [속도 5]
49. 연산자 오버로딩 : 부모 클래스에서 정의된 메서드 말고, 자식 클래스에 정의된 메서드를 사용하고 싶을때 메서드를 새롭게 정의해서 사용할 수 있다.
# 일반 유닛
class Unit:
def __init__(self, name, hp, speed):
self.name = name
self.hp = hp
self.speed = speed
def move(self, location):
print("[지상 유닛 이동]")
print("{0} : {1} 방향으로 이동합니다. [속도 {2}]"\
.format(self.name, location, self.speed))
# 공격 유닛
class AttackUnit(Unit):
def __init__(self, name, hp, speed, damage):
Unit.__init__(self, name, hp, speed)
self.damage = damage
def attack(self, location):
print("{0} : {1} 방향으로 적군을 공격합니다. [공격력 : {2}]"\
.format(self.name, location, self.damage))
def damaged(self, damage):
print("{0} : {1} 데미지를 입었습니다.".format(self.name, damage))
self.hp -= damage
print("{0} : 현재 체력은 {1} 입니다.".format(self.name, self.hp))
if self.hp <= 0:
print("{0} : 파괴되었습니다.".format(self.name))
# 드랍쉽 : 공중 유닛, 수송기. 마린 / 파이어뱃 / 탱크 등을 수송. 공격X
# 날 수 있는 기능을 가진 클래스
class Flyable:
def __init__(self, flying_speed):
self.flying_speed = flying_speed
def fly(self, name ,location):
print("{0} : {1} 방향으로 날아갑니다. [속도 {2}]"\
.format(name, location, self.flying_speed))
# 공중 공격 유닛 클래스
class FlyableAttackUnit(AttackUnit, Flyable):
def __init__(self, name, hp, damage, flying_speed):
AttackUnit.__init__(self, name, hp, 0, damage) # 지상 speed 0
Flyable.__init__(self, flying_speed)
# 벌쳐 : 지상 유닛, 기동성이 좋음
vulture = AttackUnit("벌쳐", 80, 10, 20)
# 배틀크루저 : 공중 유닛, 체력도 굉장히 좋음, 공격력도 좋음
battlecruiser = FlyableAttackUnit("배틀크루저", 500, 25, 3)
vulture.move("11시")
battlecruiser.fly(battlecruiser.name, "9시")
# 출력 결과
[지상 유닛 이동]
벌쳐 : 11시 방향으로 이동합니다. [속도 10]
배틀크루저 : 9시 방향으로 날아갑니다. [속도 3]
-------------------------------------------------------------------------------
# 문제 발생
# 지상 유닛은 'move' 함수를 사용해야하고, 공중 유닛은 'fly' 함수를 사용해야한다.
# 매번 지상 유닛인지, 공중 유닛인지 확인을 해야하는 번거러움이 발생한다.
# 해결 : 연산자 오버로딩을 통해 'move' 함수만을 사용하게끔 한다.
# 일반 유닛
class Unit:
def __init__(self, name, hp, speed):
self.name = name
self.hp = hp
self.speed = speed
def move(self, location):
print("[지상 유닛 이동]")
print("{0} : {1} 방향으로 이동합니다. [속도 {2}]"\
.format(self.name, location, self.speed))
# 공격 유닛
class AttackUnit(Unit):
def __init__(self, name, hp, speed, damage):
Unit.__init__(self, name, hp, speed)
self.damage = damage
def attack(self, location):
print("{0} : {1} 방향으로 적군을 공격합니다. [공격력 : {2}]"\
.format(self.name, location, self.damage))
def damaged(self, damage):
print("{0} : {1} 데미지를 입었습니다.".format(self.name, damage))
self.hp -= damage
print("{0} : 현재 체력은 {1} 입니다.".format(self.name, self.hp))
if self.hp <= 0:
print("{0} : 파괴되었습니다.".format(self.name))
# 드랍쉽 : 공중 유닛, 수송기. 마린 / 파이어뱃 / 탱크 등을 수송. 공격X
# 날 수 있는 기능을 가진 클래스
class Flyable:
def __init__(self, flying_speed):
self.flying_speed = flying_speed
def fly(self, name ,location):
print("{0} : {1} 방향으로 날아갑니다. [속도 {2}]"\
.format(name, location, self.flying_speed))
# 공중 공격 유닛 클래스
class FlyableAttackUnit(AttackUnit, Flyable): # 다중 상속
def __init__(self, name, hp, damage, flying_speed):
AttackUnit.__init__(self, name, hp, 0, damage) # 지상 speed 0
Flyable.__init__(self, flying_speed)
# 연산자 오버로딩 사용
def move(self, location):
print("[공중 유닛 이동]")
self.fly(self.name, location)
# 벌쳐 : 지상 유닛, 기동성이 좋음
vulture = AttackUnit("벌쳐", 80, 10, 20)
# 배틀크루저 : 공중 유닛, 체력도 굉장히 좋음, 공격력도 좋음
battlecruiser = FlyableAttackUnit("배틀크루저", 500, 25, 3)
vulture.move("11시")
# battlecruiser.fly(battlecruiser.name, "9시")
battlecruiser.move("9시")
# 출력 결과
[지상 유닛 이동]
벌쳐 : 11시 방향으로 이동합니다. [속도 10]
[공중 유닛 이동]
배틀크루저 : 9시 방향으로 날아갑니다. [속도 3]
50. pass : 일단 함수가 완성되지 않았지만 넘어간다는 의미한다. Ex.) 'game_over()'
# 일반 유닛
class Unit:
def __init__(self, name, hp, speed):
self.name = name
self.hp = hp
self.speed = speed
def move(self, location):
print("[지상 유닛 이동]")
print("{0} : {1} 방향으로 이동합니다. [속도 {2}]"\
.format(self.name, location, self.speed))
# 공격 유닛
class AttackUnit(Unit):
def __init__(self, name, hp, speed, damage):
Unit.__init__(self, name, hp, speed)
self.damage = damage
def attack(self, location):
print("{0} : {1} 방향으로 적군을 공격합니다. [공격력 : {2}]"\
.format(self.name, location, self.damage))
def damaged(self, damage):
print("{0} : {1} 데미지를 입었습니다.".format(self.name, damage))
self.hp -= damage
print("{0} : 현재 체력은 {1} 입니다.".format(self.name, self.hp))
if self.hp <= 0:
print("{0} : 파괴되었습니다.".format(self.name))
# 날 수 있는 기능을 가진 클래스
class Flyable:
def __init__(self, flying_speed):
self.flying_speed = flying_speed
def fly(self, name ,location):
print("{0} : {1} 방향으로 날아갑니다. [속도 {2}]"\
.format(name, location, self.flying_speed))
# 공중 공격 유닛 클래스
class FlyableAttackUnit(AttackUnit, Flyable):
def __init__(self, name, hp, damage, flying_speed):
AttackUnit.__init__(self, name, hp, 0, damage)
Flyable.__init__(self, flying_speed)
def move(self, location):
print("[공중 유닛 이동]")
self.fly(self.name, location)
# 건물
class BuildingUnit(Unit):
def __init__(self, name, hp, location):
pass # 일단 함수가 완성되지 않았지만 넘어간다는 의미.
# 서플라이 디폿 : 건물, 1개 건물당 = 8만큼의 유닛 생성가능.
supply_depot = BuildingUnit("서플라이 디폿", 500, "7시")
# 출력 결과
아무런 반응 없이 종료된다.
------------------------------------------------------------------------------
# 일반 유닛
class Unit:
def __init__(self, name, hp, speed):
self.name = name
self.hp = hp
self.speed = speed
def move(self, location):
print("[지상 유닛 이동]")
print("{0} : {1} 방향으로 이동합니다. [속도 {2}]"\
.format(self.name, location, self.speed))
# 공격 유닛
class AttackUnit(Unit):
def __init__(self, name, hp, speed, damage):
Unit.__init__(self, name, hp, speed)
self.damage = damage
def attack(self, location):
print("{0} : {1} 방향으로 적군을 공격합니다. [공격력 : {2}]"\
.format(self.name, location, self.damage))
def damaged(self, damage):
print("{0} : {1} 데미지를 입었습니다.".format(self.name, damage))
self.hp -= damage
print("{0} : 현재 체력은 {1} 입니다.".format(self.name, self.hp))
if self.hp <= 0:
print("{0} : 파괴되었습니다.".format(self.name))
# 날 수 있는 기능을 가진 클래스
class Flyable:
def __init__(self, flying_speed):
self.flying_speed = flying_speed
def fly(self, name ,location):
print("{0} : {1} 방향으로 날아갑니다. [속도 {2}]"\
.format(name, location, self.flying_speed))
# 공중 공격 유닛 클래스
class FlyableAttackUnit(AttackUnit, Flyable):
def __init__(self, name, hp, damage, flying_speed):
AttackUnit.__init__(self, name, hp, 0, damage)
Flyable.__init__(self, flying_speed)
def move(self, location):
print("[공중 유닛 이동]")
self.fly(self.name, location)
# 건물
class BuildingUnit(Unit):
def __init__(self, name, hp, location):
pass # 일단 함수가 완성되지 않았지만 넘어간다는 의미.
# 서플라이 디폿 : 건물, 1개 건물당 = 8만큼의 유닛 생성가능.
supply_depot = BuildingUnit("서플라이 디폿", 500, "7시")
def game_start():
print("[알림] 새로운 게임을 시작합니다.")
def game_over():
pass
game_start()
game_over()
# 출력 결과
[알림] 새로운 게임을 시작합니다.
51. super
# 일반 유닛
class Unit:
def __init__(self, name, hp, speed):
self.name = name
self.hp = hp
self.speed = speed
def move(self, location):
print("[지상 유닛 이동]")
print("{0} : {1} 방향으로 이동합니다. [속도 {2}]"\
.format(self.name, location, self.speed))
# 공격 유닛
class AttackUnit(Unit):
def __init__(self, name, hp, speed, damage):
Unit.__init__(self, name, hp, speed)
self.damage = damage
def attack(self, location):
print("{0} : {1} 방향으로 적군을 공격합니다. [공격력 : {2}]"\
.format(self.name, location, self.damage))
def damaged(self, damage):
print("{0} : {1} 데미지를 입었습니다.".format(self.name, damage))
self.hp -= damage
print("{0} : 현재 체력은 {1} 입니다.".format(self.name, self.hp))
if self.hp <= 0:
print("{0} : 파괴되었습니다.".format(self.name))
# 날 수 있는 기능을 가진 클래스
class Flyable:
def __init__(self, flying_speed):
self.flying_speed = flying_speed
def fly(self, name ,location):
print("{0} : {1} 방향으로 날아갑니다. [속도 {2}]"\
.format(name, location, self.flying_speed))
# 공중 공격 유닛 클래스
class FlyableAttackUnit(AttackUnit, Flyable):
def __init__(self, name, hp, damage, flying_speed):
AttackUnit.__init__(self, name, hp, 0, damage)
Flyable.__init__(self, flying_speed)
def move(self, location):
print("[공중 유닛 이동]")
self.fly(self.name, location)
# 건물
class BuildingUnit(Unit):
def __init__(self, name, hp, location):
Unit.__init__(self, name, hp, 0) # 일반적인 상속을 이용한 방법
self.location = location
------------------------------------------------------------------------------
# 일반 유닛
class Unit:
def __init__(self, name, hp, speed):
self.name = name
self.hp = hp
self.speed = speed
def move(self, location):
print("[지상 유닛 이동]")
print("{0} : {1} 방향으로 이동합니다. [속도 {2}]"\
.format(self.name, location, self.speed))
# 공격 유닛
class AttackUnit(Unit):
def __init__(self, name, hp, speed, damage):
Unit.__init__(self, name, hp, speed)
self.damage = damage
def attack(self, location):
print("{0} : {1} 방향으로 적군을 공격합니다. [공격력 : {2}]"\
.format(self.name, location, self.damage))
def damaged(self, damage):
print("{0} : {1} 데미지를 입었습니다.".format(self.name, damage))
self.hp -= damage
print("{0} : 현재 체력은 {1} 입니다.".format(self.name, self.hp))
if self.hp <= 0:
print("{0} : 파괴되었습니다.".format(self.name))
# 날 수 있는 기능을 가진 클래스
class Flyable:
def __init__(self, flying_speed):
self.flying_speed = flying_speed
def fly(self, name ,location):
print("{0} : {1} 방향으로 날아갑니다. [속도 {2}]"\
.format(name, location, self.flying_speed))
# 공중 공격 유닛 클래스
class FlyableAttackUnit(AttackUnit, Flyable):
def __init__(self, name, hp, damage, flying_speed):
AttackUnit.__init__(self, name, hp, 0, damage)
Flyable.__init__(self, flying_speed)
def move(self, location):
print("[공중 유닛 이동]")
self.fly(self.name, location)
# 건물
class BuildingUnit(Unit):
def __init__(self, name, hp, location):
# Unit.__init__(self, name, hp, 0)
super().__init__(name, hp, 0) # 'super'를 사용할때는 'self' 정보는 제거한다.
self.location = location
# 출력 결과
Nope...
------------------------------------------------------------------------------
# 문제 발생
# 다중 상속에서 발생한다.
# 다중 상속이 필요한 상황에서 'super'를 사용할 경우 마지막의 상속받는 클래스만 호출된다.
# 그렇다면 다중 상속을 해야하거나, 모든 부모 클래스의 호출이 필요할 경우에는?
# 해결 : 따로 명시를 해야한다.
# Ex.) Unit.__init__(self)
Flyable.__init__(self)
class Unit:
def __init__(self):
print("Unit 생성자")
class Flyable:
def __init__(self):
print("Flyable 생성자")
class FlyableUnit(Unit, Flyable):
def __init__(self):
super().__init__()
# 드랍쉽
dropship = FlyableUnit()
# 출력 결과
Unit 생성자
------------------------------------------------------------------------------
class Unit:
def __init__(self):
print("Unit 생성자")
class Flyable:
def __init__(self):
print("Flyable 생성자")
class FlyableUnit(Flyable, Unit):
def __init__(self):
super().__init__()
# 드랍쉽
dropship = FlyableUnit()
# 출력 결과
Flyable 생성자
------------------------------------------------------------------------------
class Unit:
def __init__(self):
print("Unit 생성자")
class Flyable:
def __init__(self):
print("Flyable 생성자")
class FlyableUnit(Flyable, Unit):
def __init__(self):
# super().__init__()
Unit.__init__(self)
Flyable.__init__(self)
# 드랍쉽
dropship = FlyableUnit()
# 출력 결과
Unit 생성자
Flyable 생성자
53. Quiz.8)
Quiz.8) 주어진 코드를 활용하여 부동산 프로그램을 작성하시오.
출력 예제 :
총 3대의 매물이 있습니다.
강남 아파트 매매 10억 2010년
마포 오피스텔 전세 5억 2007년
송파 빌라 월세 500/50 2000년
[코드]
class House:
# 매물 초기화
def __init__(self, location, house_type, deal_type, price, completion_year):
pass
# 매물 정보 표시
def show_detail(self):
pass
Ex.)
class House:
# 매물 초기화
def __init__(self, location, house_type, deal_type, price, completion_year):
self.location = location
self.house_type = house_type
self.deal_type = deal_type
self.price = price
self.completion_year = completion_year
# 매물 정보 표시
def show_detail(self):
print(self.location, self.house_type, self.deal_type,\
self.price, self.completion_year)
houses = []
house1 = House("강남", "아파트", "매매", "10억", "2010년")
house2 = House("마포", "오피스텔", "전세", "5억", "2007년")
house3 = House("송파", "빌라", "월세", "500/50", "2000년")
# 'show_detail'을 통해서 정보를 표시해야하는데, 각각 'show_deatil' 하는게 귀찮기 때문에
# 리스트에 넣어서 for문을 통해서 일괄적으로 처리하려고 'append'를 사용했다.
houses.append(house1)
houses.append(house2)
houses.append(house3)
print("총 {0}대의 매물이 있습니다.".format(len(houses)))
for house in houses:
house.show_detail()
# 출력 결과
총 3대의 매물이 있습니다.
강남 아파트 매매 10억 2010년
마포 오피스텔 전세 5억 2007년
송파 빌라 월세 500/50 2000년
54. 예외처리 : 어떠한 Error가 발생했을때 처리해주는 것.
Ex.) 계산기에 숫자를 입력 받아야하는데 문자를 입력 받는다든지, 홈페이지에 접속했는데 주소를 잘못 적거나 사용자가 많아서 서버에 접속이 잘되지 않는 현상도 에러라고 할 수 있다.
print("나누기 전용 계산기입니다.")
num1 = int(input("첫 번째 숫자를 입력하세요 : "))
num2 = int(input("두 번째 숫자를 입력하세요 : "))
print("{0} / {1} = {2}".format(num1, num2, int(num1/num2)))
# 출력 결과
나누기 전용 계산기입니다.
첫 번째 숫자를 입력하세요 : 6 (Enter Key)
두 번째 숫자를 입력하세요 : 3 (Enter Key)
6 / 3 = 2
-------------------------------------------------------------------------------------
# 만약, 정수형이 아닌 다른 값을 넣었을때는?
# 출력 결과 : Error 발생
나누기 전용 계산기입니다.
첫 번째 숫자를 입력하세요 : 6 (Enter Key)
두 번째 숫자를 입력하세요 : 삼 (Enter Key) # 숫자가 아닌 문자를 입력
Traceback (most recent call last):
File "c:\Users\RNRF\Dropbox\내 PC (DESKTOP-0ETL6AH)\Desktop\PythonWorkspace\예외처리.py", line 3, in <module>
num2 = int(input("두 번째 숫자를 입력하세요 : "))
ValueError: invalid literal for int() with base 10: '삼'
-------------------------------------------------------------------------------------
# 문제 해결 : 예외처리 (ValueError)
try:
print("나누기 전용 계산기입니다.")
num1 = int(input("첫 번째 숫자를 입력하세요 : "))
num2 = int(input("두 번째 숫자를 입력하세요 : "))
print("{0} / {1} = {2}".format(num1, num2, int(num1/num2)))
except ValueError:
print("에러! 잘못된 값을 입력하였습니다.")
# 출력 결과
나누기 전용 계산기입니다.
첫 번째 숫자를 입력하세요 : 6 (Enter Key)
두 번째 숫자를 입력하세요 : 삼 (Enter Key)
에러! 잘못된 값을 입력하였습니다.
-------------------------------------------------------------------------------------
# 만약, '0'을 입력했다면?
# 출력 결과 : Error 발생
나누기 전용 계산기입니다.
첫 번째 숫자를 입력하세요 : 6 (Enter Key)
두 번째 숫자를 입력하세요 : 0 (Enter Key) # '0' 입력
Traceback (most recent call last):
File "c:\Users\RNRF\Dropbox\내 PC (DESKTOP-0ETL6AH)\Desktop\PythonWorkspace\예외처리.py", line 5, in <module>
print("{0} / {1} = {2}".format(num1, num2, int(num1/num2)))
ZeroDivisionError: division by zero
-------------------------------------------------------------------------------------
# 문제 해결 : 예외처리 (ZeroDivisionError)
try:
print("나누기 전용 계산기입니다.")
num1 = int(input("첫 번째 숫자를 입력하세요 : "))
num2 = int(input("두 번째 숫자를 입력하세요 : "))
print("{0} / {1} = {2}".format(num1, num2, int(num1/num2)))
except ValueError:
print("에러! 잘못된 값을 입력하였습니다.")
except ZeroDivisionError as err:
print(err)
# 출력 결과
나누기 전용 계산기입니다.
첫 번째 숫자를 입력하세요 : 6
두 번째 숫자를 입력하세요 : 0
division by zero # 'error'문만 출력
-------------------------------------------------------------------------------------
# 또 다른 예, 리스트(=[])
try:
print("나누기 전용 계산기입니다.")
nums = []
nums.append(int(input("첫 번째 숫자를 입력하세요 : ")))
nums.append(int(input("두 번째 숫자를 입력하세요 : ")))
nums.append(int(nums[0] / nums[1]))
print("{0} / {1} = {2}".format(nums[0], nums[1], nums[2]))
except ValueError:
print("에러! 잘못된 값을 입력하였습니다.")
except ZeroDivisionError as err:
print(err)
# 출력 결과
나누기 전용 계산기입니다.
첫 번째 숫자를 입력하세요 : 6
두 번째 숫자를 입력하세요 : 3
6 / 3 = 2
-------------------------------------------------------------------------------------
# 실수로 'nums.append(int(nums[0] / nums[1]))' 부분을 넣지 않았다면?
# 실제로 'nums[0]', 'nums[1]'은 있지만, 'nums[2]'는 존재하지 않는다.
try:
print("나누기 전용 계산기입니다.")
nums = []
nums.append(int(input("첫 번째 숫자를 입력하세요 : ")))
nums.append(int(input("두 번째 숫자를 입력하세요 : ")))
# nums.append(int(nums[0] / nums[1]))
print("{0} / {1} = {2}".format(nums[0], nums[1], nums[2]))
except ValueError:
print("에러! 잘못된 값을 입력하였습니다.")
except ZeroDivisionError as err:
print(err)
# 출력 결과 : Error 발생
나누기 전용 계산기입니다.
첫 번째 숫자를 입력하세요 : 6
두 번째 숫자를 입력하세요 : 3
Traceback (most recent call last):
File "c:\Users\RNRF\Dropbox\내 PC (DESKTOP-0ETL6AH)\Desktop\PythonWorkspace\예외처리.py", line 7, in <module>
print("{0} / {1} = {2}".format(nums[0], nums[1], nums[2]))
IndexError: list index out of range
-------------------------------------------------------------------------------------
# 문제 해결 : 예외처리 (expect:)
try:
print("나누기 전용 계산기입니다.")
nums = []
nums.append(int(input("첫 번째 숫자를 입력하세요 : ")))
nums.append(int(input("두 번째 숫자를 입력하세요 : ")))
# nums.append(int(nums[0] / nums[1]))
print("{0} / {1} = {2}".format(nums[0], nums[1], nums[2]))
except ValueError:
print("에러! 잘못된 값을 입력하였습니다.")
except ZeroDivisionError as err:
print(err)
except: # 'ValueError', 'ZeroDivisionError'를 제외한 다른 모든 에러는 밑에 출력문으로 한다.
print("알 수 없는 에러가 발생하였습니다.")
# 출력 결과
나누기 전용 계산기입니다.
첫 번째 숫자를 입력하세요 : 6
두 번째 숫자를 입력하세요 : 3
알 수 없는 에러가 발생하였습니다.
-------------------------------------------------------------------------------------
# 다른 문제 해결 : 예외처리 (Exception)
try:
print("나누기 전용 계산기입니다.")
nums = []
nums.append(int(input("첫 번째 숫자를 입력하세요 : ")))
nums.append(int(input("두 번째 숫자를 입력하세요 : ")))
# nums.append(int(nums[0] / nums[1]))
print("{0} / {1} = {2}".format(nums[0], nums[1], nums[2]))
except ValueError:
print("에러! 잘못된 값을 입력하였습니다.")
except ZeroDivisionError as err:
print(err)
except Exception as err:
print("알 수 없는 에러가 발생하였습니다.")
print(err)
# 출력 결과
나누기 전용 계산기입니다.
첫 번째 숫자를 입력하세요 : 6
두 번째 숫자를 입력하세요 : 3
알 수 없는 에러가 발생하였습니다.
list index out of range
55. 에러 발생시키기 : 의도적으로 에러를 발생시키는 것.
try:
print("한 자리 숫자 나누기 전용 계산기입니다.")
num1 = int(input("첫 번째 숫자를 입력하세요 : "))
num2 = int(input("두 번째 숫자를 입력하세요 : "))
if num1 >= 10 or num2 >= 10:
raise ValueError
print("{0} / {1} = {2}".format(num1, num2, int(num1 / num2)))
except ValueError:
print("잘못된 값을 입력하였습니다. 한 자리 숫자만 입력하세요.")
# 출력 결과 (정상적인 값 입력)
한 자리 숫자 나누기 전용 계산기입니다.
첫 번째 숫자를 입력하세요 : 6(Enter Key)
두 번째 숫자를 입력하세요 : 2(Enter Key)
6 / 2 = 3
# 출력 결과 (비정상적인 값 입력)
한 자리 숫자 나누기 전용 계산기입니다.
첫 번째 숫자를 입력하세요 : 10(Enter Key)
두 번째 숫자를 입력하세요 : 5(Enter Key)
잘못된 값을 입력하였습니다. 한 자리 숫자만 입력하세요.56. 사용자 정의 예외처리 : 파이썬에서 제공하는 에러 이외에 직접 정의해서 에러를 만들어서 사용
class BigNumberError(Exception):
pass
try:
print("한 자리 숫자 나누기 전용 계산기입니다.")
num1 = int(input("첫 번째 숫자를 입력하세요 : "))
num2 = int(input("두 번째 숫자를 입력하세요 : "))
if num1 >= 10 or num2 >= 10:
raise BigNumberError
print("{0} / {1} = {2}".format(num1, num2, int(num1 / num2)))
except ValueError:
print("잘못된 값을 입력하였습니다. 한 자리 숫자만 입력하세요.")
except BigNumberError:
print("에러가 발생하였습니다. 한 자리 숫자만 입력하세요.")
# 출력 결과 (비정상적인 값 입력)
한 자리 숫자 나누기 전용 계산기입니다.
첫 번째 숫자를 입력하세요 : 10(Enter Key)
두 번째 숫자를 입력하세요 : 5(Enter Key)
에러가 발생하였습니다. 한 자리 숫자만 입력하세요.
--------------------------------------------------------------------------------------------
# 에러에 원하는 메시지 출력시키려면?
class BigNumberError(Exception):
def __init__(self, msg):
self.msg = msg
def __str__(self):
return self.msg
try:
print("한 자리 숫자 나누기 전용 계산기입니다.")
num1 = int(input("첫 번째 숫자를 입력하세요 : "))
num2 = int(input("두 번째 숫자를 입력하세요 : "))
if num1 >= 10 or num2 >= 10:
raise BigNumberError("입력값 : {0}, {1}".format(num1, num2))
print("{0} / {1} = {2}".format(num1, num2, int(num1 / num2)))
except ValueError:
print("잘못된 값을 입력하였습니다. 한 자리 숫자만 입력하세요.")
except BigNumberError as err:
print("에러가 발생하였습니다. 한 자리 숫자만 입력하세요.")
print(err)
# 출력 결과
한 자리 숫자 나누기 전용 계산기입니다.
첫 번째 숫자를 입력하세요 : 10
두 번째 숫자를 입력하세요 : 5
에러가 발생하였습니다. 한 자리 숫자만 입력하세요.
입력값 : 10, 5
57. finally : 예외처리 중에서 정상적인 구문이든지, 에러 구문이든지 상관없이 무조건 실행되는것. 'try'문 마지막에 추가하면 된다.
class BigNumberError(Exception):
def __init__(self, msg):
self.msg = msg
def __str__(self):
return self.msg
try:
print("한 자리 숫자 나누기 전용 계산기입니다.")
num1 = int(input("첫 번째 숫자를 입력하세요 : "))
num2 = int(input("두 번째 숫자를 입력하세요 : "))
if num1 >= 10 or num2 >= 10:
raise BigNumberError("입력값 : {0}, {1}".format(num1, num2))
print("{0} / {1} = {2}".format(num1, num2, int(num1 / num2)))
except ValueError:
print("잘못된 값을 입력하였습니다. 한 자리 숫자만 입력하세요.")
except BigNumberError as err:
print("에러가 발생하였습니다. 한 자리 숫자만 입력하세요.")
print(err)
finally:
print("계산기를 이용해 주셔서 감사합니다.")
# 출력 결과 (정상적인 값 입력)
한 자리 숫자 나누기 전용 계산기입니다.
첫 번째 숫자를 입력하세요 : 6
두 번째 숫자를 입력하세요 : 2
6 / 2 = 3
계산기를 이용해 주셔서 감사합니다. # 'finally'에 의해서 무조건 출력
# 출력 결과 (비정상적인 값 입력)
한 자리 숫자 나누기 전용 계산기입니다.
첫 번째 숫자를 입력하세요 : 10
두 번째 숫자를 입력하세요 : 5
에러가 발생하였습니다. 한 자리 숫자만 입력하세요.
입력값 : 10, 5
계산기를 이용해 주셔서 감사합니다. # 'finally'에 의해서 무조건 출력
# 출력 결과 (비정상적인 값('0') 입력)
한 자리 숫자 나누기 전용 계산기입니다.
첫 번째 숫자를 입력하세요 : 5
두 번째 숫자를 입력하세요 : 0
계산기를 이용해 주셔서 감사합니다. # 'finally'에 의해서 무조건 출력
Traceback (most recent call last):
File "c:/Users/RNRF/Dropbox/내 PC (DESKTOP-JO08COD)/Desktop/pythonworksapce/finally.py", line 14, in <module>
print("{0} / {1} = {2}".format(num1, num2, int(num1 / num2)))
ZeroDivisionError: division by zero
58. Quiz.9)
Quiz.9) 동네에 항상 대기 손님이 있는 맛있는 치킨집이 있습니다.
대기 손님의 치킨 요리 시간을 줄이고자 자동 주문 시스템을 제작하였습니다.
시스템 코드를 확인하고 적절한 예외처리 구문을 넣으시오.
조건1 : 1보다 작거나, 숫자가 아닌 입력값이 들어올때는 ValueError로 처리
출력 메시지 : "잘못된 값을 입력하였습니다."
조건2 : 대기 손님이 주문할 수 있는 총 치킨량은 10마리로 한정
치킨 소진시 사용자 정의 에러[SoldOutError]를 발생시키고 프로그램 종료
출력 메시지 : "재고가 소진되어 더 이상 주문을 받지 않습니다."
[코드]
chicken = 10
waiting = 1 # 홀 안에는 현재 만석. 대기번호 1부터 시작
while(True):
print("[남은 치킨] : {0}".format(chicken))
order = int(input("치킨 몇 마리 주문하시겠습니까?"))
if order > chicken: # 남은 치킨보다 주문량이 많을때
print("재료가 부족합니다.")
else:
print("[대기번호 {0}] {1}마리 주문이 완료되었습니다."\
.format(waiting, order))
waiting += 1
chicken -= order
# 출력 결과
[남은 치킨] : 10
치킨 몇 마리 주문하시겠습니까?5(Enter Key)
[대기번호 1] 5마리 주문이 완료되었습니다.
[남은 치킨] : 5
치킨 몇 마리 주문하시겠습니까?2(Enter Key)
[대기번호 2] 2마리 주문이 완료되었습니다.
[남은 치킨] : 3
치킨 몇 마리 주문하시겠습니까?10(Enter Key)
재료가 부족합니다.
[남은 치킨] : 3
치킨 몇 마리 주문하시겠습니까?0(Enter Key) # '0'을 입력했지만, 출력문이 출력된다.
[대기번호 3] 0마리 주문이 완료되었습니다.
[남은 치킨] : 3
치킨 몇 마리 주문하시겠습니까?-1(Enter Key) # '-1'을 입력했지만, 오류가 아닌 '+1'의 결과가 나타난다.
[대기번호 4] -1마리 주문이 완료되었습니다.
[남은 치킨] : 4
치킨 몇 마리 주문하시겠습니까?10마리(Enter Key) # 숫자가 아니라 오류가 발생한다.
Traceback (most recent call last):
File "c:/Users/RNRF/Dropbox/내 PC (DESKTOP-JO08COD)/Desktop/pythonworksapce/Quiz9.py", line 15, in <module>
order = int(input("치킨 몇 마리 주문하시겠습니까?"))
ValueError: invalid literal for int() with base 10: '10마리'
Ex.)
class SoldOutError(Exception):
pass
chicken = 10
waiting = 1 # 홀 안에는 현재 만석. 대기번호 1부터 시작
while(True):
try:
print("[남은 치킨] : {0}".format(chicken))
order = int(input("치킨 몇 마리 주문하시겠습니까?"))
if order > chicken: # 남은 치킨보다 주문량이 많을때
print("재료가 부족합니다.")
elif order <= 0:
raise ValueError
else:
print("[대기번호 {0}] {1}마리 주문이 완료되었습니다."\
.format(waiting, order))
waiting += 1
chicken -= order
if chicken == 0:
raise SoldOutError
except ValueError:
print("잘못된 값을 입력하였습니다.")
except SoldOutError:
print("재고가 소진되어 더 이상 주문을 받지 않습니다.")
break
# 출력 결과
[남은 치킨] : 10
치킨 몇 마리 주문하시겠습니까?5(Enter Key)
[대기번호 1] 5마리 주문이 완료되었습니다.
[남은 치킨] : 5
치킨 몇 마리 주문하시겠습니까?3(Enter Key)
[대기번호 2] 3마리 주문이 완료되었습니다.
[남은 치킨] : 2
치킨 몇 마리 주문하시겠습니까?0(Enter Key)
잘못된 값을 입력하였습니다.
[남은 치킨] : 2
치킨 몇 마리 주문하시겠습니까?-10(Enter Key)
잘못된 값을 입력하였습니다.
[남은 치킨] : 2
치킨 몇 마리 주문하시겠습니까?4(Enter Key)
재료가 부족합니다.
[남은 치킨] : 2
치킨 몇 마리 주문하시겠습니까?세마리(Enter Key)
잘못된 값을 입력하였습니다.
[남은 치킨] : 2
치킨 몇 마리 주문하시겠습니까?2(Enter Key)
[대기번호 3] 2마리 주문이 완료되었습니다.
재고가 소진되어 더 이상 주문을 받지 않습니다.
59. 모듈 : 필요한것들 끼리 부품처럼 만들어진 파일이라고 보면된다.
예를 들어, '타이어'가 고장나면 '타이어'만 교체하면 된다. 또는 사고가 나서 '범퍼'가 망가지면 '범퍼'만 교체하면 된다.
파이썬에서는 함수 정의나 클래스 등의 파이썬 문장들을 담고 있는 파일을 '모듈'이라고 한다. 모듈의 확장자는 '.py'이다.
<주의. 모듈은 본인이 쓰려는 파일의 같은 경로에 있거나, 파이썬 라이브러리가 모여있는곳에 있어야 가능하다.>
# theater_module.py : 모듈 파일 생성
# 일반 가격
def price(people):
print("{0}명 가격은 {1}원 입니다.".format(people, people * 10000))
# 조조 할인 가격
def price_morning(people):
print("{0}명 조조 할인 가격은 {1}원 입니다.".format(people, people * 6000))
# 군인 할인 가격
def price_soldier(people):
print("{0}명 군인 할인 가격은 {1}원 입니다.".format(people, people * 4000))
------------------------------------------------------------------------------------
# 모듈.py : 사용해 볼 파이썬 파일 생성
# 'import'만을 사용
import theater_module
theater_module.price(3) # 3명이서 영화를 보러 갔을때 가격
theater_module.price_morning(4) # 4명이서 조조 할인 영화를 보러 갔을때 가격
theater_module.price_soldier(5) # 5명의 군인이 영화를 보러 갔을때 가격
# 출력 결과
3명 가격은 30000원 입니다.
4명 조조 할인 가격은 24000원 입니다.
5명 군인 할인 가격은 20000원 입니다.
------------------------------------------------------------------------------------
# 'as'를 덧붙여 사용 : 선언한 모듈명이 'theater_module'과 같이 길 경우에 별명을 붙여 짧게 쓴다.
import theater_module as mv
mv.price(3)
mv.price_morning(4)
mv.price_soldier(5)
# 출력 결과
3명 가격은 30000원 입니다.
4명 조조 할인 가격은 24000원 입니다.
5명 군인 할인 가격은 20000원 입니다.
------------------------------------------------------------------------------------
# 'from'을 사용 : 'theater_module'을 쓰지 않고 바로 모듈의 모든것을 사용하겠다는 의미이다.
from theater_module import * # Ex.) 'from random import *' 앞에서 써봤던 랜덤모듈
price(3)
price_morning(4)
price_soldier(5)
# 출력 결과
3명 가격은 30000원 입니다.
4명 조조 할인 가격은 24000원 입니다.
5명 군인 할인 가격은 20000원 입니다.
------------------------------------------------------------------------------------
# 'from'을 좀 더 변형하여 사용 : 선언한 모듈에서 필요한 함수만 사용하겠다는 의미이다.
from theater_module import price, price_morning
price(5)
price_morning(6)
# 출력 결과
5명 가격은 50000원 입니다.
6명 조조 할인 가격은 36000원 입니다.
------------------------------------------------------------------------------------
# 만약 모듈을 선언하지 않고 사용한다면? : 'price_soldier'
from theater_module import price, price_morning
price(5)
price_morning(6)
price_soldier(7) # 'from'을 통해 선언하지 않았다.
# 출력 결과 : Error
5명 가격은 50000원 입니다.
6명 조조 할인 가격은 36000원 입니다.
Traceback (most recent call last):
File "c:/Users/RNRF/Dropbox/내 PC (DESKTOP-JO08COD)/Desktop/pythonworksapce/모듈.py", line 23, in <module>
price_soldier(7)
NameError: name 'price_soldier' is not defined
------------------------------------------------------------------------------------
# 만약 모듈을 더 줄여서 쓰고 싶다면?
from theater_module import price_soldier as price
price(5) # 모듈에 처음 선언된 'price'가 아닌 위에 선언된 'price_soldier'의 별명이다.
# 출력 결과
5명 군인 할인 가격은 20000원 입니다.
60. 패키지 : 모듈들을 모아놓은 집합을 의미한다. 하나의 디렉토리에 여러개의 모듈을 모아놓은것.
예를들어, 본인이 신규 여행사의 패키지를 담당하게 되었다. 이 여행사는 태국과 베트남 여행을 패키지로 제공한다.
# 패키지 폴더를 생성.
New Folder : travel
# 패키지 폴더(=travel)안에 모듈 파일 생성 (3개 생성)
New File : thailnad.py & vietnam.py & __init__.py
# 사용해볼 파이썬 파일 생성 : 패키지.py
------------------------------------------------------------------------------
# thailnad.py
class ThailandPackage:
def detail(self):
print("[태국 패키지 3박 4일] 방콕, 파타야 여행 (야시장 투어) 50만원")
# vietnam.py
class VietnamPackage:
def detail(self):
print("[베트남 패키지 3박 4일] 다낭 효도 여행 60만원")
# __init__.py
# 패키지.py
import travel.thailand
trip_to = travel.thailand.ThailandPackage()
trip_to.detail()
# 출력 결과
[태국 패키지 3박 4일] 방콕, 파타야 여행 (야시장 투어) 50만원
------------------------------------------------------------------------------
# 주의. 'import'를 쓸때는 맨뒤의 '.thailand' 여기는 항상 모듈이나 패키지만 가능하다.
# 클래스나 함수는 'import'를 직접할 수 없다.
# 만약 클래스를 붙여본다면?
import travel.thailand.ThailandPackage
trip_to = travel.thailand.ThailandPackage()
trip_to.detail()
# 출력 결과 : Error
Traceback (most recent call last):
File "c:/Users/RNRF/Dropbox/내 PC (DESKTOP-JO08COD)/Desktop/pythonworksapce/패키지.py", line 2, in <module>
import travel.thailand.ThailandPackage
ModuleNotFoundError: No module named 'travel.thailand.ThailandPackage'; 'travel.thailand' is not a package
------------------------------------------------------------------------------
# 하지만 'from import'에서는 사용 가능하다.
from travel.thailand import ThailandPackage
# 'travel' 패키지 안에 있는 'thailand' 모듈에서 'ThailandPackage'라는 패키지를 임포트(=import)해온다.
trip_to = ThailandPackage()
trip_to.detail()
# 출력 결과
[태국 패키지 3박 4일] 방콕, 파타야 여행 (야시장 투어) 50만원
------------------------------------------------------------------------------
# 베트남 추가 : 'travel'까지만 'from' 해본다.
from travel import vietnam
trip_to = vietnam.VietnamPackage()
trip_to.detail()
# 출력 결과
[베트남 패키지 3박 4일] 다낭 효도 여행 60만원
61. __all__ : 패키지 생성과 사용방법
# 이전 강의에서 'from random import *'과 같이 random의 모든 기능을 사용처럼...
from travel import *
trip_to = vietnam.VietnamPackage() # 'vietnam' 부분이 에러가 발생한다.
trip_to.detail()
# 출력 결과 : Error
Traceback (most recent call last):
File "c:/Users/RNRF/Dropbox/내 PC (DESKTOP-JO08COD)/Desktop/pythonworksapce/패키지.py", line 15, in <module>
trip_to = vietnam.VietnamPackage()
NameError: name 'vietnam' is not defined
# Why? '*'을 쓴다는 것은 'travel'이라는 패키지에 있는 모든것을 가져오겠다는 것이다.
# 하지만 개발자가 이 문법상에서 공개범위를 설정해야한다.
# 패키지 안에 포함된 것 중에서 'import' 되어 있는것만 공개하고 원하지 않는것은 비공개 할 수 있다.
--------------------------------------------------------------------------------------
# 문제 해결 : '__init__.py'에 문장 추가
__all__ = ["vietnam"]
# 출력 결과 : '패키지.py'
[베트남 패키지 3박 4일] 다낭 효도 여행 60만원
--------------------------------------------------------------------------------------
Tip.) 파일 int 비활성화 : 'vietnam' 빨간줄 해제
: File - Preferences - Settings - 'linting' 입력 = 'Python > Linting: Enabled' 체크해제
# 설정을 하지 않아도 결과는 출력된다.
--------------------------------------------------------------------------------------
# 만약 'thailand' 정보를 쓰려면?
# 문제 해결 : '__init__.py'에 'thailand' 문장 추가
__all__ = ["vietnam", "thailand"]
from travel import *
trip_to = thailand.ThailandPackage()
trip_to.detail()
# 출력 결과 : '패키지.py'
[태국 패키지 3박 4일] 방콕, 파타야 여행 (야시장 투어) 50만원
62. 모듈 직접 실행 : 실제 코드는 길이가 길 수도 있다. 그렇기 때문에 모듈이 잘 실행되는지를 테스트 해봐야한다.
# thailand.py
class ThailandPackage:
def detail(self):
print("[태국 패키지 3박 4일] 방콕, 파타야 여행 (야시장 투어) 50만원")
if __name__ == "__main__":
print("Thailand 모듈을 직접 실행")
print("이 문장은 모듈을 직접 실행할 때만 실행돼요")
trip_to = ThailandPackage()
trip_to.detail()
else:
print("Thailnad 외부에서 모듈 호출")
----------------------------------------------------------------------------------
# vietnam.py
class VietnamPackage:
def detail(self):
print("[베트남 패키지 3박 4일] , 다낭 효도 여행 60만원")
----------------------------------------------------------------------------------
# __init__.py
__all__ = ["vietnam", "thailand"]
----------------------------------------------------------------------------------
# 모듈 직접 실행.py
from travel import *
trip_to = thailand.ThailandPackage()
trip_to.detail()
# 출력 결과 (모듈내에서 실행 = 'thailand.py'에서 실행)
Thailand 모듈을 직접 실행
이 문장은 모듈을 직접 실행할 때만 실행돼요
[태국 패키지 3박 4일] 방콕, 파타야 여행 (야시장 투어) 50만원
# 출력 결과 (모듈 외부에서 실행 = '모듈 직접 실행.py'에서 실행)
Thailnad 외부에서 모듈 호출
[태국 패키지 3박 4일] 방콕, 파타야 여행 (야시장 투어) 50만원
63. 패키지, 모듈 위치 : 지금 패키지나, 모듈이 어디에 위치하는지 확인할 수 있다.
지금까지 학습에서 패키지와 모듈은 현재 작성중인 실행 파일의 똑같은 경로에 위치했다. 패키지나 모듈을 호출하는 동일한 폴더에 존재 해야한다. 또는 파이썬내의 라이브러리들이 모여있는 폴더에 있어야 사용 가능하다.
import inspect
import random
print(inspect.getfile(random))
# 출력 결과
C:\Users\RNRF\AppData\Local\Programs\Python\Python39\lib\random.py
------------------------------------------------------------------------------------
from travel import *
import inspect
import random
print(inspect.getfile(random))
print(inspect.getfile(thailand))
# 출력 결과
C:\Users\RNRF\AppData\Local\Programs\Python\Python39\lib\random.py
c:\Users\RNRF\Dropbox\내 PC (DESKTOP-0ETL6AH)\Desktop\PythonWorkspace\travel\thailand.py
------------------------------------------------------------------------------------
# 'travel' 모듈을 'random'와 마찬가지로 'lib' 파일에 복사-붙여넣기해서 사용해본다.
# 테스트를 위해 기존의 'travel' 폴더는 'travel_temp'로 이름을 변경한다.
from travel import *
trip_to = thailand.ThailandPackage()
trip_to.detail()
import inspect
import random
print(inspect.getfile(random))
print(inspect.getfile(thailand))
# 출력 결과
Thailnad 외부에서 모듈 호출
[태국 패키지 3박 4일] 방콕, 파타야 여행 (야시장 투어) 50만원
C:\Users\RNRF\AppData\Local\Programs\Python\Python39\lib\random.py
C:\Users\RNRF\AppData\Local\Programs\Python\Python39\lib\travel\thailand.py
# 복붙한 'travel'은 'lib'에 있고, 이름을 변경한 'travel_temp'는 기존경로에 남아있다.
# 변경한 경로에 가져다 놓으면 다른 프로젝트를 할 때에도 똑같이 사용이 가능하게 된다.
64. pip install : 'pip'를 이용하여 패키지를 설치할 수 있다.
파이썬에서는 이미 만들어진 '패키지'를 활용하는것도 매우 중요한 부분 중 하나이다. 그렇다면 어디서 '패키지'를 다운 받을 수 있을까?
1. 'google'에서 'pypi'를 검색한다.
2. 'browse projects' 클릭 : 다양한 기준에서 패키지를 찾을 수 있다.
Ex-1.) 'beautifulsoup' 검색
Ex-2.) 'beautifulsoup' 설치
Ex-3.) 'terminal'에 'pip install beautifulsoup'을 붙여넣고 실행한다.
Ex-4.) 홈페이지의 예제 코드를 복붙하여 테스트 해본다.
from bs4 import BeautifulSoup
soup = BeautifulSoup("<p>Some<b>bad<i>HTML")
print(soup.prettify())
# 출력 결과
C:\Users\RNRF\AppData\Local\Programs\Python\Python39\lib\bs4\element.py:15: UserWarning: The soupsieve package is not installed. CSS selectors cannot be used.
warnings.warn(
c:\Users\RNRF\Dropbox\내 PC (DESKTOP-0ETL6AH)\Desktop\PythonWorkspace\pip install.py:2: GuessedAtParserWarning: No parser was explicitly specified, so I'm using the best available HTML parser for this system ("html.parser"). This usually isn't a problem, but if you run this code on another system, or in a different virtual environment, it may use a different parser and behave differently.
The code that caused this warning is on line 2 of the file c:\Users\RNRF\Dropbox\내 PC (DESKTOP-0ETL6AH)\Desktop\PythonWorkspace\pip install.py. To get rid of this warning, pass the additional argument 'features="html.parser"' to the BeautifulSoup constructor.
soup = BeautifulSoup("<p>Some<b>bad<i>HTML")
<p>
Some
<b>
bad
<i>
HTML
</i>
</b>
</p>
Tip.) 'pip list' : 현재 설치되어 있는 패키지 목록을 보여준다.
# Terminal
pip list(Enter Key)
# 출력 결과
Package Version
---------------------------------- -------------------
absl-py 0.11.0
alabaster 0.7.12
anaconda-client 1.7.2
anaconda-navigator 1.10.0
anaconda-project 0.8.3
argh 0.26.2
argon2-cffi 20.1.0
asn1crypto 1.4.0
astroid 2.4.2
astropy 4.0.2
astunparse 1.6.3
async-generator 1.10
atomicwrites 1.4.0
attrs 20.3.0
autopep8 1.5.4
Babel 2.8.1
backcall 0.2.0
backports.functools-lru-cache 1.6.1
backports.shutil-get-terminal-size 1.0.0
backports.tempfile 1.0
backports.weakref 1.0.post1
bcrypt 3.2.0
beautifulsoup4 4.9.3
bitarray 1.6.1
bkcharts 0.2
bleach 3.2.1
bokeh 2.2.3
boto 2.49.0
Bottleneck 1.3.2
brotlipy 0.7.0
bs4 0.0.1
cachetools 4.1.1
certifi 2020.6.20
cffi 1.14.3
chardet 3.0.4
click 7.1.2
cloudpickle 1.6.0
clyent 1.2.2
colorama 0.4.4
comtypes 1.1.7
conda 4.9.2
conda-build 3.20.5
conda-package-handling 1.7.2
conda-verify 3.4.2
contextlib2 0.6.0.post1
cryptography 3.1.1
cycler 0.10.0
Cython 0.29.21
cytoolz 0.11.0
dask 2.30.0
decorator 4.4.2
defusedxml 0.6.0
diff-match-patch 20200713
distributed 2.30.1
docutils 0.16
entrypoints 0.3
et-xmlfile 1.0.1
fastcache 1.1.0
filelock 3.0.12
flake8 3.8.4
Flask 1.1.2
fsspec 0.8.3
future 0.18.2
gast 0.3.3
gevent 20.9.0
glob2 0.7
google-auth 1.23.0
google-auth-oauthlib 0.4.2
google-pasta 0.2.0
greenlet 0.4.17
grpcio 1.33.2
h5py 2.10.0
HeapDict 1.0.1
html5lib 1.1
idna 2.10
imageio 2.9.0
imagesize 1.2.0
importlib-metadata 2.0.0
iniconfig 1.1.1
intervaltree 3.1.0
ipykernel 5.3.4
ipython 7.19.0
ipython-genutils 0.2.0
ipywidgets 7.5.1
isort 5.6.4
itsdangerous 1.1.0
jdcal 1.4.1
jedi 0.17.1
Jinja2 2.11.2
joblib 0.17.0
json5 0.9.5
jsonschema 3.2.0
jupyter 1.0.0
jupyter-client 6.1.7
jupyter-console 6.2.0
jupyter-core 4.6.3
jupyterlab 2.2.6
jupyterlab-pygments 0.1.2
jupyterlab-server 1.2.0
Keras 2.4.3
Keras-Preprocessing 1.1.2
keyring 21.4.0
kiwisolver 1.3.0
lazy-object-proxy 1.4.3
libarchive-c 2.9
llvmlite 0.34.0
locket 0.2.0
lxml 4.6.1
Markdown 3.3.3
MarkupSafe 1.1.1
matplotlib 3.3.2
mccabe 0.6.1
menuinst 1.4.16
mglearn 0.1.9
mistune 0.8.4
mkl-fft 1.2.0
mkl-random 1.1.1
mkl-service 2.3.0
mock 4.0.2
more-itertools 8.6.0
mpmath 1.1.0
msgpack 1.0.0
multipledispatch 0.6.0
navigator-updater 0.2.1
nbclient 0.5.1
nbconvert 6.0.7
nbformat 5.0.8
nest-asyncio 1.4.2
networkx 2.5
nltk 3.5
nose 1.3.7
notebook 6.1.4
numba 0.51.2
numexpr 2.7.1
numpy 1.18.5
numpydoc 1.1.0
oauthlib 3.1.0
olefile 0.46
opencv-python 4.4.0.46
openpyxl 3.0.5
opt-einsum 3.3.0
packaging 20.4
pandas 1.1.3
pandocfilters 1.4.3
paramiko 2.7.2
parso 0.7.0
partd 1.1.0
path 15.0.0
pathlib2 2.3.5
pathtools 0.1.2
patsy 0.5.1
pep8 1.7.1
pexpect 4.8.0
pickle-mixin 1.0.2
pickleshare 0.7.5
Pillow 8.0.1
pip 20.2.4
pkginfo 1.6.1
pluggy 0.13.1
ply 3.11
prometheus-client 0.8.0
prompt-toolkit 3.0.8
protobuf 3.14.0
psutil 5.7.2
py 1.9.0
pyasn1 0.4.8
pyasn1-modules 0.2.8
PyAudio 0.2.11
pycodestyle 2.6.0
pycosat 0.6.3
pycparser 2.20
pycurl 7.43.0.6
pydocstyle 5.1.1
pyflakes 2.2.0
Pygments 2.7.2
pylint 2.6.0
PyNaCl 1.4.0
pyodbc 4.0.0-unsupported
pyOpenSSL 19.1.0
pyparsing 2.4.7
pyreadline 2.1
pyrsistent 0.17.3
PySocks 1.7.1
pytesseract 0.3.7
pytest 0.0.0
python-dateutil 2.8.1
python-jsonrpc-server 0.4.0
python-language-server 0.35.1
pytz 2020.1
PyWavelets 1.1.1
pywin32 227
pywin32-ctypes 0.2.0
pywinpty 0.5.7
PyYAML 5.3.1
pyzmq 19.0.2
QDarkStyle 2.8.1
QtAwesome 1.0.1
qtconsole 4.7.7
QtPy 1.9.0
regex 2020.10.15
requests 2.24.0
requests-oauthlib 1.3.0
rope 0.18.0
rsa 4.6
Rtree 0.9.4
ruamel-yaml 0.15.87
scikit-image 0.17.2
scikit-learn 0.23.2
scipy 1.5.2
seaborn 0.11.0
Send2Trash 1.5.0
sequential 1.0.0
setuptools 50.3.1.post20201107
simplegeneric 0.8.1
singledispatch 3.4.0.3
sip 4.19.13
six 1.15.0
snowballstemmer 2.0.0
sortedcollections 1.2.1
sortedcontainers 2.2.2
soupsieve 2.0.1
SpeechRecognition 3.8.1
Sphinx 3.2.1
sphinxcontrib-applehelp 1.0.2
sphinxcontrib-devhelp 1.0.2
sphinxcontrib-htmlhelp 1.0.3
sphinxcontrib-jsmath 1.0.1
sphinxcontrib-qthelp 1.0.3
sphinxcontrib-serializinghtml 1.1.4
sphinxcontrib-websupport 1.2.4
spyder 4.1.5
spyder-kernels 1.9.4
SQLAlchemy 1.3.20
statsmodels 0.12.0
sympy 1.6.2
tables 3.6.1
tblib 1.7.0
tensorboard 2.4.0
tensorboard-plugin-wit 1.7.0
tensorflow 2.3.1
tensorflow-estimator 2.3.0
termcolor 1.1.0
terminado 0.9.1
testpath 0.4.4
threadpoolctl 2.1.0
tifffile 2020.10.1
toml 0.10.1
toolz 0.11.1
tornado 6.0.4
tqdm 4.50.2
traitlets 5.0.5
typing-extensions 3.7.4.3
ujson 4.0.1
unicodecsv 0.14.1
urllib3 1.25.11
watchdog 0.10.3
wcwidth 0.2.5
webencodings 0.5.1
Werkzeug 1.0.1
wheel 0.35.1
widgetsnbextension 3.5.1
win-inet-pton 1.1.0
win-unicode-console 0.5
wincertstore 0.2
wrapt 1.11.2
xlrd 1.2.0
XlsxWriter 1.3.7
xlwings 0.20.8
xlwt 1.3.0
xmltodict 0.12.0
yapf 0.30.0
zict 2.0.0
zipp 3.4.0
zope.event 4.5.0
zope.interface 5.1.2
Tips.) 'pip show beautifulsoup4' : 패키지에 대한 정보를 볼 수 있다.
# Terminal
pip show beautifulsoup4(Enter Key)
# 출력 결과
Name: beautifulsoup4
Version: 4.9.3
Summary: Screen-scraping library
Home-page: http://www.crummy.com/software/BeautifulSoup/bs4/
Author: Leonard Richardson
Author-email: leonardr@segfault.org
License: MIT
Location: c:\users\rnrf\anaconda3\lib\site-packages
Requires: soupsieve
Required-by: conda-build, bs4
Tips.) 'pip install --upgrade beautifulsoup4' : 패키지 업그레이드도 가능하다.
# Terminal
pip install --upgrade beautifulsoup4
# 출력 결과 (이미 업그레이드 되어 있음)
Requirement already up-to-date: beautifulsoup4 in c:\users\rnrf\anaconda3\lib\site-packages (4.9.3)
Requirement already satisfied, skipping upgrade: soupsieve>1.2; python_version >= "3.0" in c:\users\rnrf\anaconda3\lib\site-packages (from beautifulsoup4) (2.0.1)
Tips.) 'pip uninstall beautifulsoup4' : 패키지 삭제도 가능하다.
# Terminal
pip uninstall beautifulsoup4
# 출력 결과
Found existing installation: beautifulsoup4 4.9.3
Uninstalling beautifulsoup4-4.9.3:
Would remove:
c:\users\rnrf\anaconda3\lib\site-packages\beautifulsoup4-4.9.3.dist-info\*
c:\users\rnrf\anaconda3\lib\site-packages\bs4\*
Proceed (y/n)? y(Enter Key)
Successfully uninstalled beautifulsoup4-4.9.3
65. 내장 함수 : 'import' 필요없이 바로 사용 가능한 함수를 의미한다.
# Ex.1) input : 사용자 입력을 받는 함수
language = input("무슨 언어를 좋아하세요?")
print("{0}은 아주 좋은 언어입니다!".format(language))
# 출력 결과
무슨 언어를 좋아하세요?파이썬(Enter Key)
파이썬은 아주 좋은 언어입니다!
---------------------------------------------------------------------------------
# dir : 어떤 객체를 넘겨줬을 때 그 객체가 어떤 변수와 함수를 가지고 있는지 표시
print(dir())
import random # 외장 함수
print(dir())
# 출력 결과 ('random'이 추가된 것을 확인할 수 있다.)
['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__']
['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'random']
---------------------------------------------------------------------------------
# dir : 'pickle' 추가
print(dir())
import random # 외장 함수
print(dir())
import pickle
print(dir())
# 출력 결과 ('random' 뒤에 'pickle'이 추가된 것을 확인할 수 있다.)
['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__']
['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'random']
['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'pickle', 'random']
---------------------------------------------------------------------------------
# Ex.2) print(dir(random)) : 랜덤 모듈안에서 쓸 수 있는것들을 표시
# (= 'random.' 했을때 뒤에 자동으로 표시 되는것들이라고 생각하면 이해하기 쉽다.)
import random
print(dir(random))
# 출력 결과
['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST', 'SystemRandom', 'TWOPI', '_Sequence', '_Set', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_accumulate', '_acos', '_bisect', '_ceil', '_cos', '_e', '_exp', '_floor', '_inst', '_log', '_os', '_pi', '_random', '_repeat', '_sha512', '_sin', '_sqrt', '_test', '_test_generator', '_urandom', '_warn', 'betavariate', 'choice', 'choices', 'expovariate', 'gammavariate', 'gauss', 'getrandbits', 'getstate', 'lognormvariate', 'normalvariate', 'paretovariate', 'randbytes', 'randint', 'random', 'randrange', 'sample', 'seed', 'setstate', 'shuffle', 'triangular', 'uniform', 'vonmisesvariate', 'weibullvariate']
---------------------------------------------------------------------------------
# 그렇다면 '외장 함수' 이외에는?
# 예를 들어, 'list'
lst = [1, 2, 3]
print(dir(lst))
# 출력 결과 (리스트에서 사용하는것들이 표시된다.)
['__add__', '__class__', '__class_getitem__', '__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']
---------------------------------------------------------------------------------
# 예를 들어, 'name'(=변수)
name = "Jim"
print(dir(name))
# 출력 결과
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
---------------------------------------------------------------------------------
Tips.) 'google'에 'list of python builtins'를 검색 : '내장 함수' 검색
66. 외장 함수 : '내장 함수'와는 다르게 직접 'import'를 해서 사용해야한다.
'google'에 'list of python modules'를 검색 : '외장 함수' 검색
몇가지 예를 들어본다.
# glob : 경로 내의 폴더 / 파일 목록 조회 (윈도우 dir)
import glob
print(glob.glob("*.py")) # 확장자가 'py'인 모든 파일
# 출력 결과
['Boolean 자료형.py', 'helloworld.py', 'my_pickle.py', 'pass.py', 'pip install.py', 'Quiz1.py', 'Quiz4.py', 'Quiz7.py', 'Quiz8.py', 'super.py', 'super2.py', 'with.py', '__init__.py', '내장 함수.py', '다중 상속.py', '메소드.py', '멤버 변
수.py', '모듈 직접 실행.py', '문자열 자료형.py', '변수.py', '상속.py', '숫자 자료형.py', '스타크래프트 전반전.py', '스타크래프트 후반전.py', '에러 발생시키기.py', '연산자 오버로딩.py', '예외처리.py', '외장 함수.py', '클래스.py', '패키지, 모듈 위치.py']
--------------------------------------------------------------------------------------------
# os : 운영체제에서 제공하는 기본 기능
import os
print(os.getcwd()) # 현재 디렉토리
# 출력 결과
C:\Users\RNRF\Dropbox\내 PC (DESKTOP-0ETL6AH)\Desktop\PythonWorkspace
--------------------------------------------------------------------------------------------
import os
print(os.getcwd())
folder = "sample_dir"
if os.path.exists(folder):
print("이미 존재하는 폴더입니다.")
else:
os.makedirs(folder) # 폴더 생성
print(folder, "폴더를 생성하였습니다.")
# 출력 결과 (파일 목록에 'sample_dir'이 생성된 것을 확인할 수 있다.
C:\Users\RNRF\Dropbox\내 PC (DESKTOP-0ETL6AH)\Desktop\PythonWorkspace
sample_dir 폴더를 생성하였습니다.
--------------------------------------------------------------------------------------------
# 한번 더 실행
# 출력 결과
C:\Users\RNRF\Dropbox\내 PC (DESKTOP-0ETL6AH)\Desktop\PythonWorkspace
이미 존재하는 폴더입니다.
--------------------------------------------------------------------------------------------
# 'os.rmdir(folder)' 구문을 추가
# 출력 결과
C:\Users\RNRF\Dropbox\내 PC (DESKTOP-0ETL6AH)\Desktop\PythonWorkspace
이미 존재하는 폴더입니다.
sample_dir 폴더를 삭제하였습니다.
--------------------------------------------------------------------------------------------
# 목록 출력
import os
print(os.listdir())
# 출력 결과
['.vscode', 'Boolean 자료형.py', 'helloworld.py', 'my_pickle.py', 'pass.py', 'pip install.py', 'profile.pickle', 'Quiz1.py', 'Quiz4.py', 'Quiz7.py', 'Quiz8.py', 'score.txt', 'study.txt', 'super.py', 'super2.py', 'travel', 'with.py', '__init__.py', '__pycache__', '내장 함수.py', '다중 상속.py', '메소드.py', '멤버 변수.py', '모듈 직접 실행.py', '문자열 자료형.py', '변수.py', '상속.py', '숫자 자료형.py', '스타크래프트 전반전.py', '스타크래프트 후반전.py', '에러 발생시키기.py', '연산자 오버로딩.py', '예외처리.py', '외장 함수.py', '클래스.py', '패키지, 모듈 위치.py']
--------------------------------------------------------------------------------------------
# time : 시간 관련 함수
import time
print(time.localtime())
# 출력 결과
time.struct_time(tm_year=2021, tm_mon=1, tm_mday=11, tm_hour=18, tm_min=29, tm_sec=7, tm_wday=0, tm_yday=11, tm_isdst=0)
--------------------------------------------------------------------------------------------
# 좀 더 알아보기 쉽게 출력
import time
print(time.strftime("%Y-%m-%d %H:%M:%S"))
# 출력 결과
2021-01-11 18:30:09
--------------------------------------------------------------------------------------------
# OR 'datetime'을 이용하여 시간 출력
import datetime
print("오늘 날짜는 ", datetime.date.today())
# 출력 결과
오늘 날짜는 2021-01-11
--------------------------------------------------------------------------------------------
# timedelta : 두 날짜 사이의 간격
import datetime
today = datetime.date.today() # 오늘 날짜 저장
td = datetime.timedelta(days=100) # 100일 저장
print("우리가 만난지 100일은",today + td) # 오늘부터 100일 후
# 출력 결과
우리가 만난지 100일은 2021-04-21
67. Quiz.10)
Quiz.10) 프로젝트 내에 나만의 시그니처를 남기는 모듈을 만드시오
조건 : 모듈 파일명은 'byme.py'로 작성
(모듈 사용 예제)
import byme
byme.sign()
(출력 예제)
이 프로그램은 나도코딩에 의해 만들어졌습니다.
유튜브 : http://youtube.com
이메일 : nadocoding@gmail.com
Ex.)
# 'byme.py' 파일 생성
def sign():
print("이 프로그램은 나도코딩에 의해 만들어졌습니다.")
print("유튜브 : http://youtube.com")
print("이메일 : nadocoding@gmail.com")
# 'Quiz10.py'
import byme
byme.sign()
# 출력 결과
이 프로그램은 나도코딩에 의해 만들어졌습니다.
유튜브 : http://youtube.com
이메일 : nadocoding@gmail.com