from openpyxl import Workbook
# 엑셀파일 쓰기
write_wb = Workbook()
# 이름이 있는 시트를 생성
write_ws = write_wb.create_sheet('생성시트')
# Sheet1에다 입력
write_ws = write_wb.active
write_ws['A1'] = '숫자'
#행 단위로 추가
write_ws.append([1,2,3])
#셀 단위로 추가
write_ws.cell(5, 5, '5행5열')
write_wb.save("excel.xlsx")
#write_wb.save("C:/Users/Administrator/Desktop/숫자.xlsx") #절대경로
2. Excel 데이터 읽기
from openpyxl import load_workbook
# data_only=True로 해줘야 수식이 아닌 값으로 받아온다.
load_wb = load_workbook("C:/Users/Administrator/Desktop/기준/프로그래밍/과제대행/주식데이터크롤링/output.xlsx", data_only=True)
# 시트 이름으로 불러오기
load_ws = load_wb['Sheet1']
# 셀 주소로 값 출력
print(load_ws['B2'].value)
# 셀 좌표로 값 출력
print(load_ws.cell(3, 2).value)
# 지정한 셀의 값 출력
get_cells = load_ws['B3' : 'B6']
for row in get_cells:
for cell in row:
print(cell.value)
# 모든 행 단위로 출력
for row in load_ws.rows:
print(row)
# 모든 열 단위로 출력
for column in load_ws.columns:
print(column)
# 모든 행과 열 출력
all_values = []
for row in load_ws.rows:
row_value = []
for cell in row:
row_value.append(cell.value)
all_values.append(row_value)
print(all_values)
load_ws.cell(3, 3, 51470)
load_ws.cell(4, 3, 21470)
load_ws.cell(5, 3, 1470)
load_ws.cell(6, 3, 6470)
load_wb.save("C:/Users/Administrator/Desktop/기준/프로그래밍/과제대행/주식데이터크롤링/output.xlsx")
import requests
from bs4 import BeautifulSoup
from openpyxl import Workbook
url = 'https://finance.naver.com/'
print(f"정보를 가져올 웹 페이지: {url}")
response = requests.get(url)
response.raise_for_status()
html = response.text
soup = BeautifulSoup(html, 'html.parser')
tbody = soup.select_one('#container > div.aside > div.group_aside > div.aside_area.aside_popular > table > tbody')
trs = tbody.select('tr')
datas = []
for tr in trs:
name = tr.select_one('th > a').get_text()
current_price = tr.select_one('td').get_text()
change_direction = tr['class'][0]
change_price = tr.select_one('td > span').get_text()
datas.append([name, current_price, change_direction, change_price])
print("종목 정보 추출 완료.")
# 5. 엑셀 파일로 저장 준비
write_wb = Workbook() # 새로운 엑셀 워크북(파일) 생성
# write_ws = write_wb.create_sheet('결과') # 새 시트 생성 (기본 시트 사용 시 이 줄은 생략 가능)
write_ws = write_wb.active # 기본 시트 사용
for data in datas:
write_ws.append(data)
write_wb.save(r'네이버_인기종목1.xlsx')
# 필요한 라이브러리를 가져옵니다. import requests # 웹 페이지의 HTML 내용을 가져오기 위한 라이브러리 from bs4 import BeautifulSoup # HTML 내용을 파싱(분석)하여 필요한 데이터를 추출하기 위한 라이브러리 from openpyxl import Workbook # 엑셀 파일을 만들고 데이터를 쓰기 위한 라이브러리 # import os # 파일 경로 관련 작업을 위해 필요할 수 있지만, 이 코드에서는 직접 사용되지 않습니다.
# 1. 정보를 가져올 웹 페이지(URL)를 설정합니다. url = 'https://finance.naver.com/' print(f"정보를 가져올 웹 페이지: {url}") # 어떤 페이지에 접속할지 출력하여 확인합니다.
# 2. 설정된 URL로 웹 접속 요청을 보내고 응답을 받습니다. response = requests.get(url)
# 3. 웹 접속 요청이 성공했는지 확인합니다. (상태 코드 200번대 외에는 오류 발생) # raise_for_status()는 HTTP 오류 발생 시 예외를 발생시켜 프로그램이 멈추게 합니다. response.raise_for_status()
# 4. 웹 접속으로 받은 응답에서 HTML 내용을 텍스트로 가져옵니다. html = response.text
# 5. 가져온 HTML 텍스트를 BeautifulSoup 객체로 파싱합니다. # 'html.parser'는 파이썬 표준 라이브러리에 포함된 HTML 파서입니다. soup = BeautifulSoup(html, 'html.parser')
# 6. BeautifulSoup를 사용하여 원하는 데이터가 있는 HTML 요소를 찾습니다. # select_one()은 CSS 선택자로 지정된 첫 번째 요소를 찾습니다. # 이 선택자는 네이버 금융 메인 페이지의 인기 종목 테이블 본문(tbody)을 가리킵니다. # 주의: 웹사이트 구조가 변경되면 이 선택자는 더 이상 작동하지 않을 수 있습니다. tbody = soup.select_one('#container > div.aside > div.group_aside > div.aside_area.aside_popular > table > tbody')
# 7. 찾은 tbody 요소 안에서 모든 'tr'(테이블 행) 요소들을 찾습니다. # 각 tr 요소는 하나의 종목 정보를 담고 있습니다. trs = tbody.select('tr')
# 8. 추출한 종목 정보들을 저장할 빈 리스트를 생성합니다. datas = []
# 9. 찾은 각 종목 행(tr)에 대해 반복하면서 필요한 데이터를 추출합니다. for tr in trs: # 각 tr 요소를 순회합니다. # 각 종목 행 안에서 종목 이름, 현재가, 등락 정보 등을 찾습니다. # select_one()으로 특정 요소를 찾고, get_text()로 요소 안의 텍스트만 가져옵니다. # 만약 해당 요소가 없으면 get_text() 호출 시 오류가 발생할 수 있습니다. (원래 코드의 잠재적 오류) name_element = tr.select_one('th > a') # 종목 이름 (th 태그 안의 a 태그) current_price_element = tr.select_one('td') # 현재가 (보통 첫 번째 td 태그) change_price_element = tr.select_one('td > span') # 대비 가격 또는 등락률 (td 태그 안의 span 태그)
# 요소가 존재하는지 확인하고 텍스트를 가져옵니다. 없으면 'N/A' 등으로 처리하여 오류 방지 가능 (원래 코드는 오류 발생 가능) # 이 코드에서는 원래 코드대로 오류 처리가 없이 바로 get_text()를 사용합니다. name = name_element.get_text() # 종목 이름 텍스트 가져오기 current_price = current_price_element.get_text() # 현재가 텍스트 가져오기
# 등락 구분 정보는 tr 태그의 'class' 속성에 있습니다. (예: 'up', 'down', 'no_ch') # tr['class']는 클래스 이름들의 리스트를 반환하고, [0]으로 첫 번째 클래스 이름을 가져옵니다. change_direction = tr['class'][0]
change_price = change_price_element.get_text() # 대비 가격 또는 등락률 텍스트 가져오기
# 추출한 데이터를 리스트 형태로 만들고, datas 리스트에 추가합니다. datas.append([name, current_price, change_direction, change_price])
# 10. 모든 종목 정보 추출이 완료되었음을 출력합니다. print("종목 정보 추출 완료.")
# 11. 추출한 데이터를 저장할 새로운 엑셀 워크북(파일)을 생성합니다. write_wb = Workbook()
# 12. 워크북에 '결과'라는 이름의 새로운 워크시트(Sheet)를 생성합니다. # 또는 write_ws = write_wb.active 를 사용하여 기본 생성된 시트를 사용할 수도 있습니다. write_ws = write_wb.create_sheet('결과')
# (선택 사항) 엑셀 파일의 첫 행에 데이터의 제목(헤더)을 추가하면 좋습니다. # write_ws.append(['종목명', '현재가', '등락구분', '대비'])
# 13. 추출된 데이터 리스트(datas)에 대해 반복하면서 각 종목 데이터를 엑셀 시트에 추가합니다. for data in datas: # datas 리스트의 각 항목(종목 데이터 리스트 [name, ...])에 대해 반복 write_ws.append(data) # 엑셀 시트에 새로운 행으로 데이터를 추가합니다.
# 14. 작성된 엑셀 워크북을 지정된 경로와 파일 이름으로 저장합니다. # r'' 접두사는 경로 문자열 안에 역슬래시(\)가 특수 문자로 해석되지 않도록 합니다 (Windows 경로에 유용). # 이 부분을 원하는 실제 파일 경로와 이름으로 변경해야 합니다. write_wb.save(r'네이버_인기종목1.xlsx') # 현재 파이썬 스크립트 파일이 실행되는 폴더에 저장됩니다.
# (선택 사항) 저장이 완료되었음을 알리는 메시지를 추가합니다. # print(f"엑셀 파일 '네이버_인기종목1.xlsx' 저장이 완료되었습니다.")
pip는 "Pip Installs Packages"의 약자로, 파이썬으로 작성된 패키지(라이브러리)들을 설치하고 관리하는 데 사용되는 명령 줄 인터페이스입니다. PyPI(Python Package Index)라는 공식 파이썬 패키지 저장소에서 패키지를 가져와 설치하는 것이 기본 동작입니다. pip를 사용하면 프로젝트에 필요한 외부 라이브러리를 손쉽게 추가하거나 업데이트, 삭제할 수 있습니다.
"r"- 읽기 - 기본값. 파일을 읽기용으로 엽니다. 파일이 없으면 오류가 발생합니다. "a"- 추가 - 추가를 위해 파일을 열고, 파일이 없으면 파일을 생성합니다. "w"- 쓰기 - 쓰기를 위해 파일을 열고, 파일이 없으면 파일을 생성합니다. "x"- 생성 - 지정된 파일을 생성하고, 파일이 있으면 오류를 반환합니다.
1. 파일에 내용 쓰기 (짧은 버전)
memo.txt 파일을 만들고 (또는 덮어쓰고) 간단한 내용을 씁니다.
Python
# write_short.py
filename = "memo.txt"
# 'w' 모드로 파일을 열어 내용을 씁니다. (기존 내용은 사라짐)
with open(filename, 'w', encoding='utf-8') as f:
f.write("첫 줄입니다.\n")
f.write("두 번째 줄입니다.\n")
print(f"'{filename}' 파일에 쓰기 완료.")
설명:
with open(...): 파일을 열고, 블록이 끝나면 자동으로 닫습니다.
'w': 쓰기 모드입니다. 파일이 없으면 만들고, 있으면 내용을 덮어씁니다.
f.write(): 파일에 문자열을 씁니다.
2. 파일 내용 읽기 (짧은 버전)
memo.txt 파일의 내용을 읽어 화면에 출력합니다. (파일이 없으면 오류 발생)
Python
# read_short.py
filename = "memo.txt"
# 'r' 모드로 파일을 열어 내용을 읽습니다.
with open(filename, 'r', encoding='utf-8') as f:
content = f.read() # 파일 전체 내용을 읽음
print("--- 파일 내용 ---")
print(content.strip()) # 앞뒤 공백 제거 후 출력
print("--- 읽기 완료 ---")
설명:
'r': 읽기 모드입니다. 파일이 존재하지 않으면 이 프로그램은 오류를 내며 중단됩니다.
f.read(): 파일의 전체 내용을 문자열로 가져옵니다.
3. 파일에 내용 추가하기 (이어쓰기 - 짧은 버전)
memo.txt 파일의 기존 내용 끝에 새로운 내용을 추가합니다. (파일이 없으면 새로 만듦)
Python
# append_short.py
filename = "memo.txt"
# 'a' 모드로 파일을 열어 내용을 추가합니다.
with open(filename, 'a', encoding='utf-8') as f:
f.write("새로운 내용 추가.\n")
f.write("이어쓰기 테스트.\n")
print(f"'{filename}' 파일에 내용 추가 완료.")
설명:
'a': 추가 모드입니다. 파일이 없으면 새로 만들고, 파일이 있으면 맨 끝에 내용을 추가합니다.
4. 파일 삭제하기 (짧은 버전)
memo.txt 파일을 삭제합니다. (파일이 없으면 오류 발생)
Python
# delete_short.py
import os # os 모듈 필요
filename = "memo.txt"
# 파일을 삭제합니다.
# 만약 'memo.txt' 파일이 이 시점에 존재하지 않으면,
# 이 프로그램은 FileNotFoundError 오류를 내며 중단됩니다.
os.remove(filename)
print(f"'{filename}' 파일 삭제 완료.")
설명:
import os: 파일 시스템 관련 작업을 위해 os 모듈을 가져옵니다.
os.remove(filename): 지정된 파일을 삭제합니다. 파일이 존재하지 않으면 이 프로그램은 오류를 내며 중단됩니다.
실행 순서 및 주의사항:
write_short.py를 실행하여 memo.txt 파일을 만듭니다.
read_short.py를 실행하여 내용을 확인합니다.
append_short.py를 실행하여 내용을 추가합니다.
다시 read_short.py를 실행하여 추가된 내용을 확인합니다.
delete_short.py를 실행하여 파일을 삭제합니다.
delete_short.py 실행 후 다시 read_short.py나 delete_short.py를 실행하면 파일이 없으므로 오류가 발생하며 프로그램이 멈출 것입니다.
이 예제들은 "최대한 짧게"와 "예외 처리 없이"라는 요청에 맞춰 작성되었으므로, 실제 프로젝트에서는 상황에 맞게 오류 처리 로직을 추가하는 것이 바람직합니다.
# 프롬프트 (키보드로 ) 입력 받기
print("여러 줄을 입력하세요. 입력을 종료하려면 빈 줄에서 엔터를 누르세요.")
content = ""
while True:
line = input()
if line == "":
break
content += line + "\n"
# 입력한 내용을 파일에 저장하기
with open('abc.txt', 'w', encoding='utf-8') as f:
f.write(content)
print("입력한 내용이 abc.txt 파일에 저장되었습니다.")
파이썬으로 memo.txt 파일을 만들고, 그 파일에 내용을 쓰고, 읽고, 내용을 추가(수정의 한 형태)하고, 마지막으로 파일을 삭제하는 아주 쉽고 간단한 예제를 만들어 드릴게요.
각 단계별로 코드를 보여드리고 설명하겠습니다.
Python
import os # 파일을 삭제하거나 파일 존재 여부를 확인하기 위해 필요한 모듈입니다.
# 사용할 파일 이름 정의
filename = "memo.txt"
# --- 1. 파일에 내용 쓰기 (새 파일 생성 또는 덮어쓰기) ---
print(f"\n--- 1. '{filename}' 파일에 새 메모 작성하기 ---")
try:
# 'w' 모드는 파일을 쓰기 모드로 열고, 파일이 이미 존재하면 내용을 덮어씁니다.
# 파일이 없으면 새로 만듭니다.
# encoding='utf-8'은 한글을 포함한 다양한 문자를 문제없이 처리하기 위함입니다.
with open(filename, 'w', encoding='utf-8') as file:
file.write("안녕하세요!\n")
file.write("파이썬으로 파일 처리를 하고 있어요.\n")
file.write(f"오늘은 2025년 5월 14일입니다.\n") # 예시 날짜
file.write("첫 번째 메모 끝!\n")
print(f"'{filename}' 파일에 내용을 성공적으로 작성했습니다.")
except IOError as e:
print(f"파일 쓰기 중 오류가 발생했습니다: {e}")
# --- 2. 파일 내용 읽기 ---
print(f"\n--- 2. '{filename}' 파일 내용 전체 읽기 ---")
try:
# 'r' 모드는 파일을 읽기 모드로 엽니다.
with open(filename, 'r', encoding='utf-8') as file:
content = file.read() # 파일의 전체 내용을 하나의 문자열로 읽어옵니다.
print(f"\n'{filename}' 파일의 내용:")
print("------------------------------------")
print(content.strip()) # strip()은 앞뒤 공백/줄바꿈 제거
print("------------------------------------")
print("파일 읽기를 완료했습니다.")
except FileNotFoundError:
print(f"'{filename}' 파일을 찾을 수 없습니다. 먼저 파일을 작성해주세요.")
except IOError as e:
print(f"파일 읽기 중 오류가 발생했습니다: {e}")
# --- 3. 파일에 내용 추가하기 (수정의 한 방법) ---
# 기존 내용 끝에 새로운 내용을 이어 쓰는 방식입니다.
print(f"\n--- 3. '{filename}' 파일에 내용 추가하기 (이어쓰기) ---")
try:
# 'a' 모드는 파일을 추가 모드로 엽니다.
# 파일이 존재하면 파일의 끝에 내용을 추가하고, 파일이 없으면 새로 만듭니다.
with open(filename, 'a', encoding='utf-8') as file:
file.write("\n--- 추가된 메모 --- \n")
file.write("이 내용은 기존 메모 뒤에 추가됩니다.\n")
file.write("파일 수정(추가)도 간단하네요!\n")
print(f"'{filename}' 파일에 내용을 성공적으로 추가했습니다.")
# 내용이 잘 추가되었는지 다시 한번 읽어서 확인해봅시다.
print(f"\n--- 내용 추가 후 '{filename}' 파일 다시 읽기 ---")
with open(filename, 'r', encoding='utf-8') as file:
updated_content = file.read()
print(f"\n'{filename}' 파일의 업데이트된 내용:")
print("------------------------------------")
print(updated_content.strip())
print("------------------------------------")
print("파일 재확인 완료.")
except FileNotFoundError:
print(f"'{filename}' 파일을 찾을 수 없습니다. 내용을 추가하려면 파일이 존재해야 합니다.")
except IOError as e:
print(f"파일에 내용 추가 중 오류가 발생했습니다: {e}")
# 참고: 파일의 특정 부분을 "수정"하는 것은 조금 더 복잡합니다.
# 보통은 파일 전체를 읽어서 메모리에서 수정한 다음, 파일 전체를 다시 쓰는 방식을 사용합니다.
# 이 예제에서는 가장 간단한 "이어쓰기"로 수정의 한 형태를 보여드렸습니다.
# --- 4. 파일 삭제하기 ---
print(f"\n--- 4. '{filename}' 파일 삭제하기 ---")
try:
# os.path.exists(filename) 으로 파일이 실제로 존재하는지 먼저 확인합니다.
if os.path.exists(filename):
os.remove(filename) # os.remove() 함수로 파일을 삭제합니다.
print(f"'{filename}' 파일을 성공적으로 삭제했습니다.")
else:
print(f"'{filename}' 파일이 이미 존재하지 않습니다 (삭제할 수 없음).")
except OSError as e: # os.remove() 실행 중 발생할 수 있는 오류 (예: 권한 문제)
print(f"파일 삭제 중 오류가 발생했습니다: {e}")
# 삭제 후 파일이 정말 없는지 다시 한번 확인
print(f"\n--- 삭제 후 '{filename}' 파일 존재 여부 확인 ---")
if os.path.exists(filename):
print(f"'{filename}' 파일이 여전히 존재합니다. (삭제 실패)")
else:
print(f"'{filename}' 파일이 존재하지 않습니다. (성공적으로 삭제됨)")
코드 설명:
import os: 파일 시스템과 관련된 작업을 하기 위해 os 모듈을 가져옵니다. 파일 삭제나 파일 존재 여부 확인에 사용됩니다.
filename = "memo.txt": 우리가 작업할 파일의 이름을 변수에 저장해두면 편리합니다.
파일 쓰기 ('w' 모드):
with open(filename, 'w', encoding='utf-8') as file::
open() 함수로 파일을 엽니다.
'w'는 쓰기(write) 모드를 의미합니다. 파일이 이미 있다면 그 내용을 모두 지우고 새로 씁니다. 파일이 없다면 새로 만듭니다.
encoding='utf-8'은 한글이나 다른 특수 문자들을 올바르게 저장하고 읽기 위해 지정합니다.
with ... as file: 구문은 파일을 사용한 후 자동으로 닫아주기 때문에 안전하고 편리합니다. file은 열린 파일 객체를 가리키는 변수입니다.
file.write("내용\n"): 파일에 문자열을 씁니다. \n은 줄바꿈을 의미합니다.
파일 읽기 ('r' 모드):
with open(filename, 'r', encoding='utf-8') as file::
'r'은 읽기(read) 모드를 의미합니다. 파일이 존재하지 않으면 FileNotFoundError 예외가 발생합니다.
content = file.read(): 파일의 전체 내용을 하나의 문자열로 읽어와 content 변수에 저장합니다. (파일이 매우 크면 file.readline()이나 for line in file: 처럼 한 줄씩 읽는 방법도 있습니다.)
파일에 내용 추가하기 ('a' 모드):
with open(filename, 'a', encoding='utf-8') as file::
'a'는 추가(append) 모드를 의미합니다. 파일이 존재하면 파일의 맨 끝에 새로운 내용을 추가합니다. 파일이 없다면 'w' 모드처럼 새로 만듭니다. 기존 내용은 지워지지 않습니다.
이것이 "수정"의 가장 간단한 형태 중 하나입니다. 기존 내용을 유지하면서 정보를 덧붙이는 것이죠.
파일 삭제하기:
if os.path.exists(filename):: os.path.exists() 함수는 해당 경로에 파일이나 폴더가 존재하는지 확인하여 True 또는 False를 반환합니다. 삭제하기 전에 파일이 있는지 확인하는 것이 좋습니다.
os.remove(filename): os 모듈의 remove() 함수를 사용하여 지정된 파일을 삭제합니다. 파일이 없거나 권한이 없으면 오류가 발생할 수 있습니다.
try...except 블록:
파일 입출력 작업 중에는 여러 가지 오류(예: 파일을 찾을 수 없음, 디스크 공간 부족, 권한 없음 등)가 발생할 수 있습니다. try...except 블록을 사용하면 이런 오류가 발생했을 때 프로그램이 비정상적으로 종료되는 것을 막고 적절히 대처할 수 있습니다.
이 예제를 실행하면 memo.txt 파일이 생성되었다가 내용이 쓰이고, 읽히고, 추가된 후 마지막에는 삭제될 것입니다. 각 단계마다 터미널에 진행 상황이 출력됩니다.
안녕하세요! 파이썬에서 **예외 처리(Exception Handling)**에 대해 쉽고 간단하게 설명해 드리고, 아주 간단한 예제도 보여드릴게요.
예외(Exception)가 뭔가요?
프로그램을 만들다 보면 예상치 못한 문제들이 생길 수 있어요. 예를 들어,
숫자를 0으로 나누려고 할 때 (ZeroDivisionError)
파일을 열려고 하는데 그 파일이 없을 때 (FileNotFoundError)
숫자를 입력해야 하는 곳에 글자를 입력했을 때 (ValueError)
이런 식으로 프로그램 실행 중에 발생하는 오류나 문제 상황을 "예외"라고 불러요. 이런 예외가 발생하면 프로그램은 보통 그 자리에서 멈춰버린답니다. 😱
예외 처리는 왜 필요한가요?
프로그램 비정상 종료 방지: 예외가 발생해도 프로그램이 바로 꺼지지 않고, 문제를 부드럽게 처리해서 계속 실행되거나 안전하게 종료될 수 있게 해요.
사용자 경험 향상: 사용자에게 "알 수 없는 오류로 프로그램이 종료됩니다." 대신 "숫자를 입력해야 합니다."처럼 친절한 안내를 해줄 수 있어요.
코드 안정성 및 신뢰도 증가: 예외 상황을 미리 대비함으로써 프로그램이 더 튼튼해지고 믿을 수 있게 됩니다.
파이썬 예외 처리 기본 구조: try, except, else, finally
파이썬에서는 try와 except라는 특별한 명령어를 사용해서 예외를 처리해요.
try 블록:
예외가 발생할 가능성이 있는 코드를 이 안에 넣어요.
파이썬은 try 블록 안의 코드를 실행하다가 예외가 발생하면 즉시 실행을 멈추고 except 블록으로 점프해요.
except 블록:
try 블록에서 특정 예외가 발생했을 때 실행될 코드를 이 안에 넣어요.
어떤 종류의 예외를 처리할지 지정할 수 있어요 (예: except ValueError:).
여러 종류의 예외를 처리하기 위해 여러 개의 except 블록을 사용할 수도 있어요.
만약 모든 종류의 예외를 다 잡고 싶다면 except Exception: (또는 그냥 except:)을 쓸 수도 있지만, 보통은 어떤 예외가 발생했는지 명확히 아는 것이 좋아서 특정 예외를 지정하는 것을 권장해요.
else 블록 (선택 사항):
try 블록 안의 코드가 아무런 예외 없이 성공적으로 실행되었을 때만 실행될 코드를 이 안에 넣어요.
finally 블록 (선택 사항):
예외 발생 여부와 상관없이, try 블록 실행이 끝나면 항상 실행될 코드를 이 안에 넣어요.
주로 파일을 닫거나, 네트워크 연결을 해제하는 등 마무리 작업을 할 때 사용해요.
아주 간단한 예제: 사용자 입력 처리
사용자에게 나이를 숫자로 입력받는 간단한 프로그램을 만들어 볼게요. 만약 사용자가 숫자가 아닌 다른 것을 입력하면 ValueError라는 예외가 발생할 수 있어요. 이걸 처리해 봅시다.
Python
print("🎉 안녕하세요! 나이 계산 프로그램입니다. 🎉")
try:
# 1. 예외가 발생할 가능성이 있는 코드
user_input = input("당신의 나이를 숫자로 입력해주세요: ")
age = int(user_input) # 여기서 문자를 입력하면 ValueError 발생!
# 2. try 블록의 코드가 성공적으로 실행되면 이 부분이 실행됩니다.
if age < 0:
print("🤔 나이는 0보다 작을 수 없어요. 다시 시도해주세요.")
elif age > 130:
print("😲 정말인가요? 굉장히 오래 사셨네요! 혹시 숫자를 잘못 입력하셨나요?")
else:
print(f"😊 입력하신 나이는 {age}살이시군요!")
print(f"🥳 10년 후에는 {age + 10}살이 되시겠네요!")
except ValueError:
# 3. int() 함수가 user_input을 숫자로 바꾸지 못할 때 ValueError가 발생하면 이 블록이 실행됩니다.
print(f"💥 이런! '{user_input}'은(는) 숫자가 아니에요. 숫자로 정확히 입력해주세요.")
else:
# 4. try 블록에서 아무런 예외도 발생하지 않았을 때 실행됩니다.
print("👍 나이가 성공적으로 입력되었습니다.")
finally:
# 5. 예외 발생 여부와 관계없이 항상 마지막에 실행됩니다.
print("\n나이 계산 프로그램을 이용해주셔서 감사합니다! 👋")
코드 설명:
try::
user_input = input(...): 사용자에게 입력을 받습니다.
age = int(user_input): 입력받은 문자열을 정수(숫자)로 변환하려고 시도합니다. 만약 사용자가 "안녕"이나 "10살"처럼 숫자 형태가 아닌 값을 입력하면, 이 줄에서 ValueError 예외가 발생합니다.
except ValueError::
만약 try 블록 안에서 ValueError가 발생하면, 프로그램은 즉시 이 except ValueError: 블록으로 이동합니다.
print(f"💥 이런! '{user_input}'은(는) 숫자가 아니에요. ...") : 사용자에게 숫자를 잘못 입력했다고 친절하게 알려줍니다. 이 코드가 실행되면 프로그램이 꺼지지 않고 계속 진행됩니다 (여기서는 finally 블록으로).
else::
만약 try 블록에서 age = int(user_input) 코드가 아무 문제 없이 (즉, 사용자가 숫자를 잘 입력해서) 성공적으로 실행되면, 이 else: 블록 안의 코드가 실행됩니다.
print("👍 나이가 성공적으로 입력되었습니다.") 메시지가 출력됩니다.
finally::
try 블록에서 예외가 발생하든 안 하든, 심지어 except나 else 블록이 실행된 후에도 무조건 마지막으로 실행됩니다.
print("\n나이 계산 프로그램을 이용해주셔서 감사합니다! 👋") : 프로그램 종료 전에 항상 감사 인사를 합니다.
실행 결과 예시:
숫자를 제대로 입력했을 때:
🎉 안녕하세요! 나이 계산 프로그램입니다. 🎉
당신의 나이를 숫자로 입력해주세요: 30
😊 입력하신 나이는 30살이시군요!
🥳 10년 후에는 40살이 되시겠네요!
👍 나이가 성공적으로 입력되었습니다.
나이 계산 프로그램을 이용해주셔서 감사합니다! 👋
문자를 입력했을 때 (예외 발생):
🎉 안녕하세요! 나이 계산 프로그램입니다. 🎉
당신의 나이를 숫자로 입력해주세요: 안녕
💥 이런! '안녕'은(는) 숫자가 아니에요. 숫자로 정확히 입력해주세요.
나이 계산 프로그램을 이용해주셔서 감사합니다! 👋
이처럼 예외 처리를 사용하면 프로그램이 얘기치 않은 상황에도 유연하게 대처할 수 있고, 사용자에게 더 좋은 경험을 제공할 수 있답니다!
똑같은 지시를 내렸는데, 누가 그 지시를 받느냐에 따라 다른 행동을 하는 마법 같은 거라고 했지?
악기 연주 예시:
음악 연주회가 열렸다고 상상해 봐. 지휘자 아저씨가 모든 악기 연주자들에게 "연주 시작!"이라고 똑같이 외쳤어.
피아노 연주자는 피아노를 "딩동댕~" 하고 아름답게 연주할 거야.
기타 연주자는 기타를 "징징징~" 하고 신나게 연주하겠지?
북 연주자는 북을 "둥둥둥!" 하고 힘차게 칠 거야.
지휘자 아저씨는 똑같이 "연주 시작!"이라고 말했지만, 피아노, 기타, 북은 각자 자기만의 소리를 내지? 이것도 다형성이야!
파이썬 코드로 악기 연주 마법을 보자!
Python
# 모든 악기가 '소리내기' 재주를 가지고 있다고 알려주는 설계도야.
class 악기:
def 소리내기(self):
print("악기는 각자 다른 소리를 내요!")
# '악기' 설계도를 보고 만든 '피아노'
class 피아노(악기): # 피아노는 악기의 한 종류!
def 소리내기(self): # 피아노만의 특별한 소리내기!
print("딩동댕~ 아름다운 피아노 소리!")
# '악기' 설계도를 보고 만든 '기타'
class 기타(악기): # 기타도 악기의 한 종류!
def 소리내기(self): # 기타만의 특별한 소리내기!
print("징~ 징~ 신나는 기타 소리!")
# '악기' 설계도를 보고 만든 '플루트'
class 플루트(악기): # 플루트도 악기의 한 종류!
def 소리내기(self): # 플루트만의 특별한 소리내기!
print("휘리리릭~ 맑은 플루트 소리!")
# 자, 이제 여러 악기들을 준비해보자!
우리집_피아노 = 피아노()
내_통기타 = 기타()
예쁜_플루트 = 플루트()
# 악기들에게 소리를 내보라고 해볼까?
print("피아노야, 연주해봐!")
우리집_피아노.소리내기()
print("\n통기타야, 연주해봐!")
내_통기타.소리내기()
print("\n플루트야, 연주해봐!")
예쁜_플루트.소리내기()
print("\n--- 작은 음악회 시작! ---")
# 여러 악기를 모아보자.
우리_악단 = [우리집_피아노, 내_통기타, 예쁜_플루트]
for 하나의_악기 in 우리_악단:
# 똑같이 '소리내기()' 라고 했는데,
# '하나의_악기'가 피아노일 때, 기타일 때, 플루트일 때 각각 다른 소리가 나!
# 이것도 다형성 마법이지!
하나의_악기.소리내기()
코드 설명:
class 악기:: 모든 악기가 공통으로 가질 수 있는 재주인 소리내기()를 정의했어.
class 피아노(악기):, class 기타(악기):, class 플루트(악기):: 각 악기들이 악기의 특징을 물려받고, 자신만의 독특한 소리내기() 방법을 가지도록 만들었어.
우리집_피아노 = 피아노() 처럼 각 악기들을 실제로 만들었지.
우리_악단 = [우리집_피아노, 내_통기타, 예쁜_플루트] : 여러 악기를 우리_악단이라는 목록에 함께 담았어.
for 하나의_악기 in 우리_악단: 이 부분에서 마법이 일어나!
하나의_악기.소리내기()라는 똑같은 코드를 사용하는데도,
하나의_악기가 피아노일 때는 피아노 소리가 나고,
하나의_악기가 기타일 때는 기타 소리가 나고,
하나의_악기가 플루트일 때는 플루트 소리가 나지!
이렇게 똑같은 소리내기() 요청에 대해 각 악기가 자신만의 방식으로 연주하는 것, 이것이 바로 다형성이란다! 어때, 재미있지?
안녕! 파이썬의 '다형성'이라는 마법에 대해 알려줄게. 좀 어려운 말 같지만, 아주 재미있는 마술 같은 거야!
다형성이 뭐냐고요?
음... '여러 가지 모양'이라는 뜻이야. 똑같은 이름을 불렀는데, 또는 똑같은 행동을 시켰는데, 누가 대답하느냐 또는 누가 행동하느냐에 따라 다른 결과가 나오는 거지!
예를 들어 볼까?
우리 반 친구들한테 "자기소개 해봐!" 라고 선생님이 말씀하셨다고 생각해 보자.
철수는 "안녕, 나는 축구를 좋아하는 철수야!" 라고 말할 거야.
영희는 "안녕, 나는 그림 그리기를 좋아하는 영희야!" 라고 말할 거야.
민준이는 "안녕, 나는 로봇 만들기를 좋아하는 민준이야!" 라고 말할 거야.
선생님은 똑같이 "자기소개 해봐!" 라고 말씀하셨지만, 철수, 영희, 민준이는 각자 다른 자기소개를 했지? 이렇게 똑같은 지시에도 서로 다른 행동이나 말을 하는 것을 '다형성'이라고 해.
더 쉬운 예! 동물 소리 흉내 내기!
동물 친구들이 있다고 상상해 봐. 이 동물 친구들은 모두 "소리내기"라는 특별한 재주를 가지고 있어.
강아지한테 "소리내봐!" 하면 "멍멍!" 하고 짖을 거야.
고양이한테 "소리내봐!" 하면 "야옹~" 하고 울겠지?
병아리한테 "소리내봐!" 하면 "삐약삐약!" 할 거야.
모두 똑같이 "소리내봐!" 라는 말을 듣지만, 강아지, 고양이, 병아리는 각자 다른 소리를 내지? 이게 바로 다형성이야!
파이썬 코드로 이 마법을 한번 볼까?
다형성을 보여주기 위해 동물 예제를 사용해 보겠습니다. 동물 예제가 다형성을 이해하는 데 더 직관적일 수 있습니다.
Python
# 부모 클래스 Animal 정의
class Animal:
def __init__(self, name):
self.name = name
def speak(self):
# 이 메서드는 자식 클래스에서 오버라이드(재정의)될 것을 기대합니다.
raise NotImplementedError("Subclass must implement abstract method")
# Animal 클래스를 상속받는 자식 클래스 Dog 정의
class Dog(Animal):
def speak(self):
return f"{self.name}(이)가 멍멍! 하고 짖습니다."
# Animal 클래스를 상속받는 자식 클래스 Cat 정의
class Cat(Animal):
def speak(self):
return f"{self.name}(이)가 야옹~ 하고 웁니다."
# Animal 클래스를 상속받는 자식 클래스 Cow 정의
class Cow(Animal):
def speak(self):
return f"{self.name}(이)가 음메~ 하고 웁니다."
# 다양한 동물 객체 생성
dog = Dog("바둑이")
cat = Cat("나비")
cow = Cow("얼룩이")
# 동물 객체들을 리스트에 담기
animals = [dog, cat, cow]
# 리스트를 순회하며 각 동물의 speak() 메서드 호출
print("다형성을 이용한 동물 소리 내기:")
for animal in animals:
# 같은 animal.speak() 호출이지만,
# 객체의 실제 타입(Dog, Cat, Cow)에 따라 다른 행동을 보입니다.
print(animal.speak())
print("\n--- 개별 객체 호출 ---")
print(dog.speak())
print(cat.speak())
print(cow.speak())
-----------2번예제----------------------
# Person/Student 예제로 다형성 보기 (간단한 형태)
class Person:
def __init__(self, name):
self.name = name
def greet(self):
return f"{self.name}입니다. 안녕하세요!"
class Student(Person):
def __init__(self, name, student_id):
super().__init__(name)
self.student_id = student_id
# 부모 클래스의 greet 메서드를 오버라이드 (재정의)
def greet(self):
return f"저는 학생 {self.name}이고, 학번은 {self.student_id}입니다. 반갑습니다!"
person1 = Person("김철수")
student1 = Student("이영희", "2025001")
people = [person1, student1]
print("\n다형성을 이용한 인사하기:")
for person_obj in people:
# 같은 person_obj.greet() 호출이지만,
# 객체의 실제 타입(Person, Student)에 따라 다른 메시지가 출력됩니다.
print(person_obj.greet())
코드 설명 (동물 예제 기준):
class Animal::
__init__(self, name): 동물의 이름을 초기화합니다.
speak(self): 동물이 소리를 내는 메서드입니다. NotImplementedError를 발생시켜, 이 클래스를 상속받는 자식 클래스에서 반드시 이 메서드를 **오버라이드(재정의)**해야 함을 명시합니다. (필수는 아니지만 좋은 관행입니다.)
class Dog(Animal):, class Cat(Animal):, class Cow(Animal)::
각각 Animal 클래스를 상속받습니다.
speak(self) 메서드를 각 동물에 맞게 오버라이드하여 고유한 소리를 내도록 구현합니다. 예를 들어, Dog는 "멍멍!", Cat은 "야옹~"을 반환합니다.
객체 생성 및 리스트 활용:
Dog, Cat, Cow 타입의 객체들을 생성합니다.
이 객체들을 animals라는 하나의 리스트에 담습니다. 중요한 점은 이 리스트에는 Animal의 자식 클래스 객체들이 섞여 있다는 것입니다.
다형성 실행:
for animal in animals: 루프를 통해 리스트의 각 객체에 대해 animal.speak()를 호출합니다.
여기서 다형성이 발현됩니다. animal.speak()라는 동일한 형태의 코드를 호출하지만, animal 변수가 실제로 어떤 객체(Dog인지, Cat인지, Cow인지)를 가리키느냐에 따라 실행되는 speak 메서드의 내용이 달라집니다.
animal이 Dog 객체일 때는 Dog 클래스의 speak 메서드가 호출됩니다.
animal이 Cat 객체일 때는 Cat 클래스의 speak 메서드가 호출됩니다.
animal이 Cow 객체일 때는 Cow 클래스의 speak 메서드가 호출됩니다.
다형성(Polymorphism)의 핵심:
"여러 형태를 가질 수 있다"는 의미로, 동일한 이름의 메서드가 서로 다른 클래스에서 다른 방식으로 동작하는 것을 말합니다. 이를 통해 코드의 유연성과 확장성을 높일 수 있습니다. 위 예제에서는 speak()라는 동일한 요청에 대해 각 동물 객체가 자신만의 방식으로 응답하는 것을 볼 수 있습니다.
Person/Student 예제에서의 다형성:
Person 클래스와 이를 상속한 Student 클래스 모두 greet() 메서드를 가지고 있습니다. Student 클래스는 greet() 메서드를 자신에게 맞게 재정의(오버라이드)했습니다. people 리스트에 Person 객체와 Student 객체를 함께 넣고, 각 객체의 greet() 메서드를 호출하면 객체의 실제 타입에 따라 다른 인사말이 출력됩니다. 이것 또한 다형성의 예입니다.
다음은 제공해주신 Person 클래스를 상속받는 Student 클래스를 정의한 간단한 파이썬 상속 예제입니다.
Python
# 부모 클래스 Person 정의
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def introduce(self):
print(f"제 이름은 {self.name}이고, 나이는 {self.age}살입니다.")
# Person 클래스를 상속받는 자식 클래스 Student 정의
class Student(Person):
def __init__(self, name, age, student_id):
# 부모 클래스의 __init__ 메서드 호출
super().__init__(name, age)
self.student_id = student_id
def study(self):
print(f"학생 {self.name}(이)가 공부하고 있습니다. (학번: {self.student_id})")
# Person 객체 생성 및 메서드 호출
p1 = Person("John", 36)
print(p1.name)
print(p1.age)
p1.introduce()
print("-" * 20) # 구분선
# Student 객체 생성 및 메서드 호출
s1 = Student("Alice", 20, "2023001")
print(s1.name) # 부모 클래스로부터 상속받은 속성
print(s1.age) # 부모 클래스로부터 상속받은 속성
print(s1.student_id) # Student 클래스 고유의 속성
s1.introduce() # 부모 클래스로부터 상속받은 메서드
s1.study() # Student 클래스 고유의 메서드
재사용성: 똑같은 코드를 여러 번 반복해서 작성할 필요 없이, 한 번 함수로 만들어두면 필요할 때마다 불러서 사용할 수 있습니다. 커피 머신을 한 번 사두면 계속 커피를 만들 수 있는 것처럼요.
모듈화: 복잡한 프로그램을 작은 단위의 함수들로 쪼개어 관리하면, 각 부분이 어떤 역할을 하는지 파악하기 쉽고, 문제 발생 시 어느 부분에서 문제가 생겼는지 찾기 용이합니다.
가독성: 함수 이름을 잘 지어주면 코드만 봐도 이 부분이 어떤 일을 하는지 쉽게 이해할 수 있습니다.
✅ 1. 함수 정의 및 호출
✔️ 개념
함수는 어떤 작업을 수행하는 코드 블록입니다. 자주 쓰는 작업을 묶어서 재사용할 수 있도록 해줍니다.
✔️ 예제
python
def say_hello():
print("안녕하세요!")
say_hello() # 함수 호출
✅ 2. 매개변수(Parameter)와 반환값(Return Value)
✔️ 개념
매개변수는 함수에 전달되는 입력값입니다.
반환값은 함수가 실행된 후 결과로 돌려주는 값입니다.
✔️ 예제
python
def add(a, b): # a, b는 매개변수
return a + b # 반환값은 a + b
result = add(3, 5) # 3, 5는 인자(argument)
print("결과:", result)
✅ 3. 지역 변수와 전역 변수
✔️ 개념
지역 변수는 함수 안에서만 쓰이는 변수입니다.
전역 변수는 함수 밖에서도 접근 가능한 변수입니다.
✔️ 예제
python
x = 10 # 전역 변수
def example():
y = 5 # 지역 변수
print("x (전역 변수):", x)
print("y (지역 변수):", y)
example()
# print(y) # 에러: y는 함수 밖에서는 사용 불가
python 기본적인 전역 변수와 함수 내 접근
global_var = "나는 함수 밖의 전역 변수야!" # 함수 밖에서 선언된 전역 변수
def show_global():
print(f"함수 안: {global_var}") # 함수 안에서 전역 변수 읽기
print(f"함수 밖 (호출 전): {global_var}")
show_global()
print(f"함수 밖 (호출 후): {global_var}")
설명:
global_var는 모든 함수 바깥에서 만들어졌기 때문에 전역 변수입니다.
show_global 함수 안에서도 global_var에 접근하여 그 값을 읽을 수 있습니다.
함수 호출 전후로 함수 밖에서도 global_var의 값은 동일하게 유지됩니다.
✅ 4. 가변 인수 (*args, **kwargs)
✔️ 개념
*args: 여러 개의 위치 인자를 튜플로 받음
**kwargs: 키워드 인자들을 딕셔너리로 받음
✔️ 예제 1 - *args
python
def print_numbers(*args):
for num in args:
print(num)
print_numbers(1, 2, 3, 4, 5)
✔️ 예제 2 - **kwargs
python
def print_info(**kwargs):
for key, value in kwargs.items():
print(f"{key}: {value}")
print_info(name="홍길동", age=25, city="서울")
