Discover, learn, and get inspired by our curated collection of Python code examples. From simple scripts to complex applications.
# ----------------------------------------------------
# 조건문 (미세먼지 농도에 따른 마스크 착용 권고)
# ----------------------------------------------------
dust_level = int(input("미세먼지 농도를 입력하세요 (단위: ㎍/㎥): "))
if dust_level >= 76:
print("매우 나쁨: 외출을 자제하고 마스크를 꼭 착용하세요.")
elif dust_level >= 36:
print("나쁨: 마스크 착용을 권고합니다.")
elif dust_level >= 16:
print("보통: 마스크를 착용할 필요는 없습니다.")
else:
print("좋음: 쾌적한 공기입니다!")
# ----------------------------------------------------
# 반복문 (구구단 출력)
# ----------------------------------------------------
dan = int(input("출력하고 싶은 구구단 수를 입력하세요: "))
print(f"--- {dan}단 ---")
for i in range(1, 10):
print(f"{dan} x {i} = {dan * i}")
# ----------------------------------------------------
# 리스트 (친구 이름 관리 및 검색)
# ----------------------------------------------------
friends = ["철수", "영희", "민수", "수진"]
print("내 친구들:", friends)
# 친구 추가
new_friend = input("새로운 친구 이름을 입력하세요: ")
friends.append(new_friend)
print("친구 추가 후:", friends)
# 친구 검색
search_name = input("찾고 싶은 친구 이름을 입력하세요: ")
if search_name in friends:
print(f"{search_name}은(는) 친구 목록에 있습니다.")
else:
print(f"{search_name}은(는) 친구 목록에 없습니다.")
# 친구 삭제 (예시)
# friends.remove("철수")
# print("철수 삭제 후:", friends)
# ----------------------------------------------------
# 함수 (간단한 계산기)
# ----------------------------------------------------
def add(a, b):
return a + b
def subtract(a, b):
return a - b
def multiply(a, b):
return a * b
def divide(a, b):
if b == 0:
return "0으로 나눌 수 없습니다."
else:
return a / b
num1 = int(input("첫 번째 숫자를 입력하세요: "))
num2 = int(input("두 번째 숫자를 입력하세요: "))
operator = input("연산자를 입력하세요 (+, -, *, /): ")
if operator == '+':
result = add(num1, num2)
elif operator == '-':
result = subtract(num1, num2)
elif operator == '*':
result = multiply(num1, num2)
elif operator == '/':
result = divide(num1, num2)
else:
result = "잘못된 연산자입니다."
print(f"결과: {result}")
# ----------------------------------------------------
# CSV 파일 읽고 데이터 처리 (간단한 성적 처리)
# ----------------------------------------------------
import csv
# 가상의 성적 데이터 (students.csv 파일로 저장한다고 가정)
# 이름,국어,영어,수학
# 김철수,90,85,92
# 이영희,78,92,88
# 박민수,95,70,80
# 'students.csv' 파일 생성 (실제 실행 시 이 부분을 주석 해제하거나 파일을 직접 생성해야 합니다.)
# with open('students.csv', 'w', newline='', encoding='utf-8') as f:
# writer = csv.writer(f)
# writer.writerow(['이름', '국어', '영어', '수학'])
# writer.writerow(['김철수', 90, 85, 92])
# writer.writerow(['이영희', 78, 92, 88])
# writer.writerow(['박민수', 95, 70, 80])
try:
with open('students.csv', 'r', encoding='utf-8') as file:
reader = csv.reader(file)
header = next(reader) # 헤더 읽기
print("--- 학생 성적 평균 ---")
for row in reader:
name = row[0]
korean = int(row[1])
english = int(row[2])
math = int(row[3])
average = (korean + english + math) / 3
print(f"{name}의 평균 점수: {average:.2f}점") # 소수점 둘째자리까지 표시
except FileNotFoundError:
print("students.csv 파일을 찾을 수 없습니다. 파일을 생성해주세요.")
except Exception as e:
print(f"오류 발생: {e}")
# ----------------------------------------------------
# 간단한 규칙 기반 챗봇 (인공지능의 한 예시)
# ----------------------------------------------------
def simple_chatbot(message):
message = message.lower() # 소문자로 변환하여 비교
if "안녕" in message or "hi" in message:
return "안녕하세요! 무엇을 도와드릴까요?"
elif "날씨" in message:
return "오늘 날씨는 맑고 쾌청합니다!" # 실제 날씨 API 연결은 어려움
elif "이름" in message:
return "저는 AI 챗봇입니다."
elif "고마워" in message or "땡큐" in message:
return "천만에요! 또 궁금한 거 있으세요?"
elif "종료" in message or "exit" in message:
return "다음에 또 만나요!"
else:
return "죄송해요, 이해하지 못했습니다. 다른 질문을 해주세요."
print("간단한 챗봇과 대화해보세요. '종료'를 입력하면 대화가 끝납니다.")
while True:
user_input = input("나: ")
if user_input.lower() == "종료":
print(simple_chatbot(user_input))
break
response = simple_chatbot(user_input)
print(f"챗봇: {response}")
# ----------------------------------------------------
# 기본 도형 그리기: 사각형과 삼각형
# ----------------------------------------------------
import turtle # turtle 모듈을 불러옵니다.
# 펜 설정 (선택 사항)
turtle.speed(1) # 거북이 속도 설정 (1: 가장 느림, 10: 빠름, 0: 즉시)
turtle.pensize(3) # 펜 두께 설정
turtle.color("blue") # 펜 색상 설정
# 사각형 그리기
print("사각형을 그립니다.")
for _ in range(4): # 4번 반복
turtle.forward(100) # 100만큼 앞으로 이동
turtle.right(90) # 오른쪽으로 90도 회전
# 위치 이동 (펜을 들고 이동해야 선이 안 그려집니다)
turtle.penup() # 펜을 듭니다.
turtle.goto(-150, 50) # 특정 좌표로 이동합니다.
turtle.pendown() # 펜을 내립니다.
# 삼각형 그리기
turtle.color("red") # 펜 색상 변경
print("삼각형을 그립니다.")
for _ in range(3): # 3번 반복
turtle.forward(100)
turtle.right(120) # 정삼각형을 위해 120도 회전
turtle.done() # 그림이 그려진 창을 유지합니다.
# ----------------------------------------------------
# 별 그리기
# ----------------------------------------------------
import turtle
screen = turtle.Screen() # 화면 객체 생성
screen.bgcolor("black") # 배경색을 검정색으로 설정
star = turtle.Turtle() # 거북이 객체 생성
star.color("gold") # 별 색상 설정
star.pensize(2)
star.speed(5)
print("별을 그립니다.")
for i in range(5): # 오각별
star.forward(150)
star.right(144) # 360 / 5 = 72, 72 * 2 = 144 (오각별 각도 계산)
star.penup()
star.goto(100, -100)
star.pendown()
star.color("lightblue")
star.speed(8)
print("작은 별들을 그립니다.")
for _ in range(20): # 작은 별 여러 개 그리기
for i in range(5):
star.forward(30)
star.right(144)
star.penup()
star.forward(20) # 조금씩 이동하며 그리기
star.right(18) # 별들 간의 간격
star.pendown()
turtle.done()
# ----------------------------------------------------
# 원 그리기와 색 채우기
# ----------------------------------------------------
import turtle
circle_turtle = turtle.Turtle()
circle_turtle.speed(5)
circle_turtle.pensize(2)
print("색이 채워진 원을 그립니다.")
circle_turtle.color("purple", "lightgreen") # 펜 색상, 채울 색상
circle_turtle.begin_fill() # 색 채우기 시작
circle_turtle.circle(80) # 반지름이 80인 원을 그립니다.
circle_turtle.end_fill() # 색 채우기 종료
# 여러 개의 원 그리기 (위치 이동)
circle_turtle.penup()
circle_turtle.goto(-100, 100)
circle_turtle.pendown()
print("여러 개의 원을 그립니다.")
circle_turtle.color("orange", "yellow")
circle_turtle.begin_fill()
circle_turtle.circle(50)
circle_turtle.end_fill()
circle_turtle.penup()
circle_turtle.goto(100, 100)
circle_turtle.pendown()
circle_turtle.color("cyan", "blue")
circle_turtle.begin_fill()
circle_turtle.circle(60)
circle_turtle.end_fill()
turtle.done()
# ----------------------------------------------------
# 함수를 이용한 복잡한 패턴 그리기 (나선형)
# ----------------------------------------------------
import turtle
spiral_turtle = turtle.Turtle()
spiral_turtle.speed(0) # 가장 빠른 속도
print("나선형 패턴을 그립니다.")
colors = ["red", "purple", "blue", "green", "orange", "yellow"]
for i in range(300):
spiral_turtle.pencolor(colors[i % 6]) # 펜 색상 변경 (6가지 색상 반복)
spiral_turtle.forward(i) # 이동 거리를 점차 늘림
spiral_turtle.left(59) # 회전 각도 (나선형 모양을 만듦)
turtle.done()
#----------------------------------------------------
# 클릭 이벤트 활용 (화면 클릭 시 점 찍기)
#----------------------------------------------------
import turtle
screen = turtle.Screen()
screen.setup(width=600, height=400) # 화면 크기 설정
screen.title("클릭하면 점 찍기")
dot_painter = turtle.Turtle()
dot_painter.shape("turtle") # 거북이 모양을 거북이 아이콘으로 변경
dot_painter.color("green")
dot_painter.penup() # 처음에는 펜을 들고 시작
def draw_dot(x, y):
dot_painter.goto(x, y) # 클릭한 위치로 이동
dot_painter.dot(10, "red") # 반지름 10인 빨간색 점을 찍습니다.
print(f"클릭한 위치: ({x}, {y})")
print("화면을 클릭하면 점이 찍힙니다. 닫으려면 창을 닫으세요.")
screen.onclick(draw_dot) # 화면 클릭 이벤트를 draw_dot 함수에 연결
turtle.done()
# ----------------------------------------------------
# 단순 나선형 원 (반지름이 점점 커지는 형태)
# ----------------------------------------------------
import turtle
# 화면 설정
screen = turtle.Screen()
screen.setup(width=700, height=700) # 화면 크기 설정
screen.bgcolor("black") # 배경색을 검정으로
# 거북이 객체 생성
spiral_pen = turtle.Turtle()
spiral_pen.speed(0) # 가장 빠른 속도로 설정 (0이 가장 빠름)
spiral_pen.pencolor("lime") # 펜 색상 설정
print("나선형 원을 그립니다 (반지름 증가).")
# 나선형 원 그리기
# 시작 반지름
radius = 10
# 증가량
radius_increase = 2
for i in range(100): # 100번 반복
spiral_pen.circle(radius) # 현재 반지름으로 원 그리기
radius += radius_increase # 반지름을 증가
# 원을 다 그릴 때마다 조금씩 회전하여 나선형 효과를 강조
# 이 부분을 조절하여 나선형의 밀도를 바꿀 수 있습니다.
spiral_pen.right(5) # 오른쪽으로 5도 회전
turtle.done() # 그림이 완료되면 창을 유지합니다.
# ----------------------------------------------------
# 좀 더 복잡하고 시각적으로 흥미로운 나선형 (다채로운 색상)
# ----------------------------------------------------
import turtle
import colorsys # 색상 시스템 모듈
# 화면 설정
screen = turtle.Screen()
screen.setup(width=700, height=700)
screen.bgcolor("black")
# 거북이 객체 생성
fancy_spiral_pen = turtle.Turtle()
fancy_spiral_pen.speed(0)
fancy_spiral_pen.pensize(2) # 펜 두께 설정
print("다채로운 나선형 패턴을 그립니다.")
# 나선형 패턴 그리기
# 'i'가 증가할수록 이동 거리와 색상이 변합니다.
for i in range(360): # 360번 반복 (각도와 연관 지어 생각하기 좋음)
# HSV 색상 모델을 RGB로 변환하여 다양한 색상 생성
# hue (색상) 값을 0에서 1까지 변화시키면 무지개색 순환
c = colorsys.hsv_to_rgb(i / 360, 1, 1) # i / 360은 0.0 ~ 0.99... 범위
fancy_spiral_pen.pencolor(c) # 펜 색상 설정
fancy_spiral_pen.forward(i) # 앞으로 이동 거리를 점차 늘림
fancy_spiral_pen.left(59) # 왼쪽으로 59도 회전 (나선형 모양을 만듦)
turtle.done()
import matplotlib.pyplot as plt
# 데이터 준비
categories = ['사과', '바나나', '오렌지', '딸기']
values = [25, 30, 15, 20]
# 막대 그래프 그리기
plt.bar(categories, values, color=['red', 'yellow', 'orange', 'pink']) # 막대 색상 지정
# 제목 및 축 라벨 설정
plt.title("과일 판매량")
plt.xlabel("과일 종류")
plt.ylabel("판매량 (개)")
plt.show()
import matplotlib.pyplot as plt
import numpy as np
t = np.linspace(-10, 10, 100)
sig = 1 / (1 + np.exp(-t))
fig, ax = plt.subplots()
ax.axhline(y=0, color="black", linestyle="--")
ax.axhline(y=0.5, color="black", linestyle=":")
ax.axhline(y=1.0, color="black", linestyle="--")
ax.axvline(color="grey")
ax.axline((0, 0.5), slope=0.25, color="black", linestyle=(0, (5, 5)))
ax.plot(t, sig, linewidth=2, label=r"$\sigma(t) = \frac{1}{1 + e^{-t}}$")
ax.set(xlim=(-10, 10), xlabel="t")
ax.legend(fontsize=14)
plt.show()
import matplotlib.pyplot as plt
fig, ax = plt.subplots()
fruits = ['apple', 'blueberry', 'cherry', 'orange']
counts = [40, 100, 30, 55]
bar_labels = ['red', 'blue', '_red', 'orange']
bar_colors = ['tab:red', 'tab:blue', 'tab:red', 'tab:orange']
ax.bar(fruits, counts, label=bar_labels, color=bar_colors)
ax.set_ylabel('fruit supply')
ax.set_title('Fruit supply by kind and color')
ax.legend(title='Fruit color')
plt.show()
import matplotlib.pyplot as plt
import numpy as np
# Fixing random state for reproducibility
np.random.seed(19680801)
dt = 0.01
t = np.arange(0, 30, dt)
nse1 = np.random.randn(len(t)) # white noise 1
nse2 = np.random.randn(len(t)) # white noise 2
# Two signals with a coherent part at 10 Hz and a random part
s1 = np.sin(2 * np.pi * 10 * t) + nse1
s2 = np.sin(2 * np.pi * 10 * t) + nse2
fig, axs = plt.subplots(2, 1, layout='constrained')
axs[0].plot(t, s1, t, s2)
axs[0].set_xlim(0, 2)
axs[0].set_xlabel('Time (s)')
axs[0].set_ylabel('s1 and s2')
axs[0].grid(True)
cxy, f = axs[1].cohere(s1, s2, NFFT=256, Fs=1. / dt)
axs[1].set_ylabel('Coherence')
plt.show()
import matplotlib.pyplot as plt import numpy as np # Fixing random state for reproducibility np.random.seed(19680801) N = 100 r0 = 0.6 x = 0.9 * np.random.rand(N) y = 0.9 * np.random.rand(N) area = (20 * np.random.rand(N))**2 # 0 to 10 point radii c = np.sqrt(area) r = np.sqrt(x ** 2 + y ** 2) area1 = np.ma.masked_where(r < r0, area) area2 = np.ma.masked_where(r >= r0, area) plt.scatter(x, y, s=area1, marker='^', c=c) plt.scatter(x, y, s=area2, marker='o', c=c) # Show the boundary between the regions: theta = np.arange(0, np.pi / 2, 0.01) plt.plot(r0 * np.cos(theta), r0 * np.sin(theta)) plt.show()
import turtle
# 화면 설정
screen = turtle.Screen()
screen.title("Python Turtle Parking Simulation")
screen.bgcolor("lightgray")
screen.setup(width=800, height=600)
# 주차 슬롯 그리기
def draw_parking_slot(x, y, width=80, height=150):
slot = turtle.Turtle()
slot.penup()
slot.goto(x, y)
slot.pendown()
slot.color("black")
slot.pensize(3)
for _ in range(2):
slot.forward(width)
slot.left(90)
slot.forward(height)
slot.left(90)
slot.hideturtle()
# 주차장 만들기 (5개 슬롯)
start_x = -300
for i in range(5):
draw_parking_slot(start_x + i * 120, 100)
# 차량 생성
car = turtle.Turtle()
car.shape("square")
car.shapesize(stretch_wid=3, stretch_len=2)
car.color("blue")
car.penup()
car.goto(0, -200)
# 차량 이동 함수
def move_forward():
car.sety(car.ycor() + 20)
def move_backward():
car.sety(car.ycor() - 20)
def move_left():
car.setx(car.xcor() - 20)
def move_right():
car.setx(car.xcor() + 20)
# 키 바인딩
screen.listen()
screen.onkeypress(move_forward, "Up")
screen.onkeypress(move_backward, "Down")
screen.onkeypress(move_left, "Left")
screen.onkeypress(move_right, "Right")
screen.mainloop()
import turtle
# 화면 설정
screen = turtle.Screen()
screen.setup(width=800, height=600)
screen.bgcolor("white")
screen.title("사각형 그리기 및 움직이기 예제")
screen.tracer(0) # 애니메이션 끄기
# 사각형 그리기용 터틀
drawer = turtle.Turtle()
drawer.hideturtle()
drawer.pensize(3)
drawer.color("blue")
drawer.speed(0)
# 사각형 그리기 함수
def draw_square(t, size, x, y):
t.penup()
t.goto(x, y)
t.pendown()
for _ in range(4):
t.forward(size)
t.right(90)
t.penup()
def update():
screen.update()
# 정적 사각형 그리기
draw_square(drawer, 100, -150, 100)
draw_square(drawer, 80, 150, 100)
draw_square(drawer, 120, -150, -150)
draw_square(drawer, 60, 150, -150)
# 화면 유지
update()
screen.mainloop()
import turtle
# 설정값
HEIGHT = 10
WIDTH = 20
CELL_SIZE = 30 # 한 칸의 픽셀 크기
PLAYER_COLOR = 'blue'
BG_COLOR = 'white'
# turtle 세팅
screen = turtle.Screen()
screen.setup(width=WIDTH * CELL_SIZE + 40, height=HEIGHT * CELL_SIZE + 40)
screen.bgcolor(BG_COLOR)
screen.title("Turtle Car Lane Game")
screen.tracer(0)
# 차량 생성 (한 번만)
car = turtle.Turtle()
car.shape("square")
car.shapesize(stretch_wid=3, stretch_len=2)
car.color(PLAYER_COLOR)
car.penup()
car.goto(0 + 125 + CELL_SIZE, -HEIGHT // 2 * CELL_SIZE + CELL_SIZE // 2)
car.showturtle()
# 차량 이동 거리
MOVE_STEP = 20
def move_left():
# 자유롭게 좌측으로 이동
car.setx(car.xcor() - MOVE_STEP)
update()
def move_right():
# 자유롭게 우측으로 이동
car.setx(car.xcor() + MOVE_STEP)
update()
def update():
screen.update()
# 키 바인딩
screen.listen()
screen.onkeypress(move_left, "Left")
screen.onkeypress(move_right, "Right")
update()
screen.mainloop()
import turtle
# 설정값
HEIGHT = 10
WIDTH = 20
CELL_SIZE = 30 # 한 칸의 픽셀 크기
PLAYER_COLOR = 'blue'
BG_COLOR = 'white'
# turtle 세팅
screen = turtle.Screen()
screen.setup(width=WIDTH * CELL_SIZE + 40, height=HEIGHT * CELL_SIZE + 40)
screen.bgcolor(BG_COLOR)
screen.title("Turtle Car Lane Game")
screen.tracer(0)
# 차량 생성 (한 번만)
car = turtle.Turtle()
car.shape("square")
car.shapesize(stretch_wid=3, stretch_len=2)
car.color(PLAYER_COLOR)
car.penup()
car.goto(0 + 125 + CELL_SIZE, -HEIGHT // 2 * CELL_SIZE + CELL_SIZE // 2)
car.showturtle()
# 차량 이동 거리
MOVE_STEP = 20
def move_left():
# 자유롭게 좌측으로 이동
car.setx(car.xcor() - MOVE_STEP)
update()
def move_right():
# 자유롭게 우측으로 이동
car.setx(car.xcor() + MOVE_STEP)
update()
def update():
screen.update()
# 키 바인딩
screen.listen()
screen.onkeypress(move_left, "Left")
screen.onkeypress(move_right, "Right")
update()
screen.mainloop()
def move_up():
# 자유롭게 위로 이동
car.sety(car.ycor() + MOVE_STEP)
update()
def move_down():
# 자유롭게 아래로 이동
car.sety(car.ycor() - MOVE_STEP)
update()
# 키 바인딩 추가
screen.onkeypress(move_up, "Up")
screen.onkeypress(move_down, "Down")
import turtle
# 설정값
HEIGHT = 10
WIDTH = 20
CELL_SIZE = 30 # 한 칸의 픽셀 크기
PLAYER_COLOR = 'blue'
LANE_COLOR = 'black'
BG_COLOR = 'white'
# turtle 세팅
screen = turtle.Screen()
screen.setup(width=WIDTH * CELL_SIZE + 40, height=HEIGHT * CELL_SIZE + 40)
screen.bgcolor(BG_COLOR)
screen.title("Turtle Car Lane Game")
screen.tracer(0)
# 차선 그리기용 turtle (lane)
lane = turtle.Turtle()
lane.hideturtle()
lane.penup()
lane.pensize(3)
lane.color(LANE_COLOR)
# 차량 생성 (한 번만)
car = turtle.Turtle()
car.shape("square")
car.shapesize(stretch_wid=3, stretch_len=2)
car.color(PLAYER_COLOR)
car.penup()
car.goto(0 + 125 + CELL_SIZE, -HEIGHT // 2 * CELL_SIZE + CELL_SIZE // 2)
car.showturtle()
# 차선 그리기 함수
def draw_lanes():
lane.clear()
# 좌측 차선
x = -WIDTH // 2 * CELL_SIZE
lane.goto(x, HEIGHT // 2 * CELL_SIZE)
lane.pendown()
lane.goto(x, -HEIGHT // 2 * CELL_SIZE)
lane.penup()
# 중앙선
x = 0
lane.color('orange') # 중앙선을 주황색으로 설정
lane.goto(x, HEIGHT // 2 * CELL_SIZE)
lane.pendown()
lane.goto(x, -HEIGHT // 2 * CELL_SIZE)
lane.penup()
lane.color(LANE_COLOR) # 다른 차선은 원래 색상으로 복원
# 우측 차선
x = (WIDTH // 2 - 1) * CELL_SIZE
lane.goto(x, HEIGHT // 2 * CELL_SIZE)
lane.pendown()
lane.goto(x, -HEIGHT // 2 * CELL_SIZE)
lane.penup()
# 차량 이동 거리
MOVE_STEP = 20
def move_left():
# 자유롭게 좌측으로 이동
car.setx(car.xcor() - MOVE_STEP)
update()
def move_right():
# 자유롭게 우측으로 이동
car.setx(car.xcor() + MOVE_STEP)
update()
def update():
draw_lanes()
screen.update()
# 키 바인딩
screen.listen()
screen.onkeypress(move_left, "Left")
screen.onkeypress(move_right, "Right")
update()
screen.mainloop()
import turtle
# 설정값
HEIGHT = 10
WIDTH = 20
CELL_SIZE = 30 # 한 칸의 픽셀 크기
PLAYER_COLOR = 'blue'
LANE_COLOR = 'black'
BG_COLOR = 'white'
# turtle 세팅
screen = turtle.Screen()
screen.setup(width=WIDTH * CELL_SIZE + 40, height=HEIGHT * CELL_SIZE + 40)
screen.bgcolor(BG_COLOR)
screen.title("Turtle Car Lane Game")
screen.tracer(0)
# 차선 그리기용 turtle (lane)
lane = turtle.Turtle()
lane.hideturtle()
lane.penup()
lane.pensize(3)
lane.color(LANE_COLOR)
# 차량 생성 (한 번만)
car = turtle.Turtle()
car.shape("square")
car.shapesize(stretch_wid=3, stretch_len=2)
car.color(PLAYER_COLOR)
car.penup()
car.goto(0 + 125 + CELL_SIZE, -HEIGHT // 2 * CELL_SIZE + CELL_SIZE // 2)
car.showturtle()
# 차선 그리기 함수
def draw_lanes():
lane.clear()
# 좌측 차선
x = -WIDTH // 2 * CELL_SIZE
lane.goto(x, HEIGHT // 2 * CELL_SIZE)
lane.pendown()
lane.goto(x, -HEIGHT // 2 * CELL_SIZE)
lane.penup()
# 중앙선
x = 0
lane.color('orange') # 중앙선을 주황색으로 설정
lane.goto(x, HEIGHT // 2 * CELL_SIZE)
lane.pendown()
lane.goto(x, -HEIGHT // 2 * CELL_SIZE)
lane.penup()
lane.color(LANE_COLOR) # 다른 차선은 원래 색상으로 복원
# 우측 차선
x = (WIDTH // 2 - 1) * CELL_SIZE
lane.goto(x, HEIGHT // 2 * CELL_SIZE)
lane.pendown()
lane.goto(x, -HEIGHT // 2 * CELL_SIZE)
lane.penup()
# 차량 이동 거리
MOVE_STEP = 20
def move_left():
# 중앙선(x=0)으로 이동하려 하면 우측으로 보정
if car.xcor() - MOVE_STEP <= 0:
car.setx(car.xcor() + MOVE_STEP)
else:
car.setx(car.xcor() - MOVE_STEP)
update()
def move_right():
# 우측 차선 넘으려 하면 좌측으로 보정
max_x = (WIDTH // 2 - 2) * CELL_SIZE # 우측 차선 바로 왼쪽까지 허용
if car.xcor() + MOVE_STEP > max_x:
car.setx(car.xcor() - MOVE_STEP)
else:
car.setx(car.xcor() + MOVE_STEP)
update()
def draw_signal():
# 신호등 위치: 우측 상단
signal = turtle.Turtle()
signal.hideturtle()
signal.penup()
radius = 15
x = WIDTH // 2 * CELL_SIZE - 2 * radius
y = HEIGHT // 2 * CELL_SIZE - 2 * radius
# 차량이 차선 범위 안에 있으면 초록색, 아니면 빨간색
car_x = car.xcor()
min_x = CELL_SIZE # 중앙선 바로 오른쪽
max_x = (WIDTH // 2 - 2) * CELL_SIZE - 10 # 우측 차선 바로 왼쪽보다 약간 더 좁게
if min_x <= car_x <= max_x:
color = 'green'
else:
color = 'red'
signal.goto(x, y)
signal.pendown()
signal.fillcolor(color)
signal.begin_fill()
signal.circle(radius)
signal.end_fill()
signal.penup()
def update():
draw_lanes()
draw_signal()
screen.update()
def exit_game():
screen.bye()
# 키 바인딩
screen.listen()
screen.onkeypress(move_left, "Left")
screen.onkeypress(move_right, "Right")
screen.onkeypress(exit_game, "Escape")
update()
screen.mainloop()
import turtle
import random
import math
import time
# 설정값
HEIGHT = 10
WIDTH = 20
CELL_SIZE = 30
PLAYER_COLOR = 'blue'
LANE_COLOR = 'black'
BG_COLOR = 'white'
ONCOMING_CAR_COLOR = 'red'
SAFE_DISTANCE = 80
# 도로 경계
ROAD_LEFT = -WIDTH // 2 * CELL_SIZE
ROAD_RIGHT = (WIDTH // 2 - 1) * CELL_SIZE
ROAD_CENTER = 0
# turtle 세팅
screen = turtle.Screen()
screen.setup(width=WIDTH * CELL_SIZE + 40, height=HEIGHT * CELL_SIZE + 40)
screen.bgcolor(BG_COLOR)
screen.title("자율주행 레벨 1: ACC")
screen.tracer(0)
# 차선 그리기용 turtle
lane = turtle.Turtle()
lane.hideturtle()
lane.penup()
lane.pensize(3)
lane.color(LANE_COLOR)
# 플레이어 차량 생성
player_car = turtle.Turtle()
player_car.shape("square")
player_car.shapesize(stretch_wid=3, stretch_len=2)
player_car.color(PLAYER_COLOR)
player_car.penup()
player_car.goto(0, -HEIGHT // 2 * CELL_SIZE + CELL_SIZE // 2)
player_car.showturtle()
# 상대 차량들을 저장할 리스트
oncoming_cars = []
# 차량 생성 타이머 및 제한 설정
car_spawn_timer = 0
car_spawn_interval = 100
max_cars = 2
# 상대 차량 생성 함수
def create_oncoming_car():
car_obj = turtle.Turtle()
car_obj.shape("square")
car_obj.shapesize(stretch_wid=3, stretch_len=2)
car_obj.color(ONCOMING_CAR_COLOR)
car_obj.penup()
# 우측 차선에서만 차량 생성
x = random.randint(int(ROAD_CENTER + CELL_SIZE), int(ROAD_RIGHT - CELL_SIZE))
y = HEIGHT // 2 * CELL_SIZE + 50
car_obj.goto(x, y)
car_obj.showturtle()
car_obj.speed = 2
car_obj.is_stopped = False
car_obj.original_color = ONCOMING_CAR_COLOR
return car_obj
# 초기 상대 차량들 생성
oncoming_cars = [create_oncoming_car()]
# 차선 그리기 함수
def draw_lanes():
lane.clear()
# 좌측 차선
lane.color(LANE_COLOR)
lane.goto(ROAD_LEFT, HEIGHT // 2 * CELL_SIZE)
lane.pendown()
lane.goto(ROAD_LEFT, -HEIGHT // 2 * CELL_SIZE)
lane.penup()
# 중앙선
lane.color('orange')
lane.goto(ROAD_CENTER, HEIGHT // 2 * CELL_SIZE)
lane.pendown()
lane.goto(ROAD_CENTER, -HEIGHT // 2 * CELL_SIZE)
lane.penup()
# 우측 차선
lane.color(LANE_COLOR)
lane.goto(ROAD_RIGHT, HEIGHT // 2 * CELL_SIZE)
lane.pendown()
lane.goto(ROAD_RIGHT, -HEIGHT // 2 * CELL_SIZE)
lane.penup()
# 안전 거리 표시용 turtle
safe_distance_indicator = turtle.Turtle()
safe_distance_indicator.hideturtle()
safe_distance_indicator.penup()
safe_distance_indicator.color('yellow')
safe_distance_indicator.pensize(2)
def draw_safe_distance():
"""플레이어 차량 앞뒤에 안전 거리 표시"""
safe_distance_indicator.clear()
px, py = player_car.xcor(), player_car.ycor()
# 앞쪽 안전 거리 라인 (빨간색)
safe_distance_indicator.color('red')
safe_distance_indicator.penup()
safe_distance_indicator.goto(px - 20, py + SAFE_DISTANCE)
safe_distance_indicator.pendown()
safe_distance_indicator.goto(px + 20, py + SAFE_DISTANCE)
# 뒤쪽 안전 거리 라인 (노란색)
safe_distance_indicator.color('yellow')
safe_distance_indicator.penup()
safe_distance_indicator.goto(px - 20, py - SAFE_DISTANCE)
safe_distance_indicator.pendown()
safe_distance_indicator.goto(px + 20, py - SAFE_DISTANCE)
# 새로운 충돌 고려 함수 - X축 위치와 Y축 거리 기반
def should_car_stop(car):
"""차량이 정지해야 하는지 판단 (X축 위치와 Y축 거리 기반)"""
player_x = player_car.xcor()
player_y = player_car.ycor()
car_x = car.xcor()
car_y = car.ycor()
# X축: 같은 차선에 있는지 확인 (차량 폭 고려)
car_width = 40 # stretch_len * 20
x_overlap = abs(player_x - car_x) < car_width
# Y축: 안전 거리 내에 있는지 확인
y_distance = abs(player_y - car_y)
y_too_close = y_distance < SAFE_DISTANCE
# 같은 차선에 있고 안전 거리 내에 있으면 정지
return x_overlap and y_too_close
# 상대 차량들 업데이트 함수
def update_oncoming_cars():
global oncoming_cars, car_spawn_timer
# 차량 생성
car_spawn_timer += 1
active_cars = sum(1 for car in oncoming_cars if car.isvisible())
if car_spawn_timer >= car_spawn_interval and active_cars < max_cars:
oncoming_cars.append(create_oncoming_car())
car_spawn_timer = 0
# 각 차량 업데이트
for i, car in enumerate(oncoming_cars):
if not car.isvisible():
continue
# 새로운 충돌 고려 함수 사용
if should_car_stop(car):
car.is_stopped = True
car.color('orange')
else:
car.is_stopped = False
car.color(car.original_color)
# 이동
if not car.is_stopped:
car.sety(car.ycor() - car.speed)
# 화면 밖으로 나가면 제거
if car.ycor() < -HEIGHT // 2 * CELL_SIZE - 50:
car.hideturtle()
oncoming_cars.remove(car)
break
# 실제 충돌 감지 (차량이 겹치는 경우)
player_x, player_y = player_car.xcor(), player_car.ycor()
car_x, car_y = car.xcor(), car.ycor()
x_collision = abs(player_x - car_x) < 30 # 차량 폭의 절반
y_collision = abs(player_y - car_y) < 30 # 차량 높이의 절반
if x_collision and y_collision:
game_over()
# 게임 오버 함수
def game_over():
game_over_text = turtle.Turtle()
game_over_text.hideturtle()
game_over_text.penup()
game_over_text.color('red')
game_over_text.goto(0, 0)
game_over_text.write("Simulation is OVER!", align="center", font=("Arial", 24, "bold"))
screen.update()
time.sleep(2)
screen.bye()
# 플레이어 차량 이동 함수들
def move_left():
player_car.setx(player_car.xcor() - CELL_SIZE)
update()
def move_right():
player_car.setx(player_car.xcor() + CELL_SIZE)
update()
# 신호등 그리기 함수
def draw_signal():
signal = turtle.Turtle()
signal.hideturtle()
signal.penup()
radius = 15
x = ROAD_RIGHT + 2 * radius
y = HEIGHT // 2 * CELL_SIZE - 2 * radius
signal.goto(x, y)
signal.pendown()
signal.fillcolor('green')
signal.begin_fill()
signal.circle(radius)
signal.end_fill()
signal.penup()
# UI 정보 표시
def draw_ui():
ui = turtle.Turtle()
ui.hideturtle()
ui.penup()
ui.color('black')
ui.goto(-WIDTH // 2 * CELL_SIZE, HEIGHT // 2 * CELL_SIZE + 20)
active_cars = sum(1 for car in oncoming_cars if car.isvisible())
ui.write(f"안전거리: {SAFE_DISTANCE}px | 활성차량: {active_cars}/{max_cars} | 조작: ← → | ESC: 종료", font=("Arial", 12, "normal"))
# 업데이트 함수
def update():
draw_lanes()
draw_safe_distance()
draw_signal()
draw_ui()
update_oncoming_cars()
screen.update()
# 게임 종료 함수
def exit_game():
screen.bye()
# 자동 업데이트 함수
def auto_update():
update()
screen.ontimer(auto_update, 50)
# 키 바인딩
screen.listen()
screen.onkeypress(move_left, "Left")
screen.onkeypress(move_right, "Right")
screen.onkeypress(exit_game, "Escape")
# 초기 화면 그리기
draw_lanes()
draw_safe_distance()
draw_signal()
draw_ui()
# 자동 업데이트 시작
auto_update()
screen.mainloop()
import turtle
import random
import math
import time
# 설정값
HEIGHT = 10
WIDTH = 20
CELL_SIZE = 30
PLAYER_COLOR = 'blue'
LANE_COLOR = 'black'
BG_COLOR = 'white'
ONCOMING_CAR_COLOR = 'red'
SAFE_DISTANCE = 80
MOVE_STEP = 20
# 도로 경계
ROAD_LEFT = -WIDTH // 2 * CELL_SIZE
ROAD_RIGHT = (WIDTH // 2 - 1) * CELL_SIZE
ROAD_CENTER = 0
# turtle 세팅
screen = turtle.Screen()
screen.setup(width=WIDTH * CELL_SIZE + 40, height=HEIGHT * CELL_SIZE + 40)
screen.bgcolor(BG_COLOR)
screen.title("자율주행 레벨 2")
screen.tracer(0)
# 차선 그리기용 turtle
lane = turtle.Turtle()
lane.hideturtle()
lane.penup()
lane.pensize(3)
lane.color(LANE_COLOR)
# 플레이어 차량 생성
player_car = turtle.Turtle()
player_car.shape("square")
player_car.shapesize(stretch_wid=3, stretch_len=2)
player_car.color(PLAYER_COLOR)
player_car.penup()
player_car.goto(0 + 125 + CELL_SIZE, -HEIGHT // 2 * CELL_SIZE + CELL_SIZE // 2)
player_car.showturtle()
# 상대 차량들을 저장할 리스트
oncoming_cars = []
# 차량 생성 타이머 및 제한 설정
car_spawn_timer = 0
car_spawn_interval = 100
max_cars = 2
# 상대 차량 생성 함수
def create_oncoming_car():
car_obj = turtle.Turtle()
car_obj.shape("square")
car_obj.shapesize(stretch_wid=3, stretch_len=2)
car_obj.color(ONCOMING_CAR_COLOR)
car_obj.penup()
# 우측 차선에서만 차량 생성
x = random.randint(int(ROAD_CENTER + CELL_SIZE), int(ROAD_RIGHT - CELL_SIZE))
y = HEIGHT // 2 * CELL_SIZE + 50
car_obj.goto(x, y)
car_obj.showturtle()
car_obj.speed = 2
car_obj.is_stopped = False
car_obj.original_color = ONCOMING_CAR_COLOR
return car_obj
# 초기 상대 차량들 생성
oncoming_cars = [create_oncoming_car()]
# 차선 그리기 함수
def draw_lanes():
lane.clear()
# 좌측 차선
x = ROAD_LEFT
lane.color(LANE_COLOR)
lane.goto(x, HEIGHT // 2 * CELL_SIZE)
lane.pendown()
lane.goto(x, -HEIGHT // 2 * CELL_SIZE)
lane.penup()
# 중앙선
x = ROAD_CENTER
lane.color('orange')
lane.goto(x, HEIGHT // 2 * CELL_SIZE)
lane.pendown()
lane.goto(x, -HEIGHT // 2 * CELL_SIZE)
lane.penup()
lane.color(LANE_COLOR)
# 우측 차선
x = ROAD_RIGHT
lane.goto(x, HEIGHT // 2 * CELL_SIZE)
lane.pendown()
lane.goto(x, -HEIGHT // 2 * CELL_SIZE)
lane.penup()
# 안전 거리 표시용 turtle
safe_distance_indicator = turtle.Turtle()
safe_distance_indicator.hideturtle()
safe_distance_indicator.penup()
safe_distance_indicator.color('yellow')
safe_distance_indicator.pensize(2)
def draw_safe_distance():
"""플레이어 차량 앞뒤에 안전 거리 표시"""
safe_distance_indicator.clear()
px, py = player_car.xcor(), player_car.ycor()
# 앞쪽 안전 거리 라인 (빨간색)
safe_distance_indicator.color('red')
safe_distance_indicator.penup()
safe_distance_indicator.goto(px - 20, py + SAFE_DISTANCE)
safe_distance_indicator.pendown()
safe_distance_indicator.goto(px + 20, py + SAFE_DISTANCE)
# 뒤쪽 안전 거리 라인 (노란색)
safe_distance_indicator.color('yellow')
safe_distance_indicator.penup()
safe_distance_indicator.goto(px - 20, py - SAFE_DISTANCE)
safe_distance_indicator.pendown()
safe_distance_indicator.goto(px + 20, py - SAFE_DISTANCE)
# 충돌 고려 함수 - X축 위치와 Y축 거리 기반
def should_car_stop(car):
"""차량이 정지해야 하는지 판단 (X축 위치와 Y축 거리 기반)"""
player_x = player_car.xcor()
player_y = player_car.ycor()
car_x = car.xcor()
car_y = car.ycor()
# X축: 같은 차선에 있는지 확인 (차량 폭 고려)
car_width = 40 # stretch_len * 20
x_overlap = abs(player_x - car_x) < car_width
# Y축: 안전 거리 내에 있는지 확인
y_distance = abs(player_y - car_y)
y_too_close = y_distance < SAFE_DISTANCE
# 같은 차선에 있고 안전 거리 내에 있으면 정지
return x_overlap and y_too_close
# 상대 차량들 업데이트 함수
def update_oncoming_cars():
global oncoming_cars, car_spawn_timer
# 차량 생성
car_spawn_timer += 1
active_cars = sum(1 for car in oncoming_cars if car.isvisible())
if car_spawn_timer >= car_spawn_interval and active_cars < max_cars:
oncoming_cars.append(create_oncoming_car())
car_spawn_timer = 0
# 각 차량 업데이트
for i, car in enumerate(oncoming_cars):
if not car.isvisible():
continue
# 충돌 고려 함수 사용
if should_car_stop(car):
car.is_stopped = True
car.color('orange')
else:
car.is_stopped = False
car.color(car.original_color)
# 이동
if not car.is_stopped:
car.sety(car.ycor() - car.speed)
# 화면 밖으로 나가면 제거
if car.ycor() < -HEIGHT // 2 * CELL_SIZE - 50:
car.hideturtle()
oncoming_cars.remove(car)
break
# 실제 충돌 감지 (차량이 겹치는 경우)
player_x, player_y = player_car.xcor(), player_car.ycor()
car_x, car_y = car.xcor(), car.ycor()
x_collision = abs(player_x - car_x) < 30 # 차량 폭의 절반
y_collision = abs(player_y - car_y) < 30 # 차량 높이의 절반
if x_collision and y_collision:
game_over()
# 게임 오버 함수
def game_over():
game_over_text = turtle.Turtle()
game_over_text.hideturtle()
game_over_text.penup()
game_over_text.color('red')
game_over_text.goto(0, 0)
game_over_text.write("Simulation is OVER!", align="center", font=("Arial", 24, "bold"))
screen.update()
time.sleep(2)
screen.bye()
# 플레이어 차량 이동 함수들 (차선 제한 적용)
def move_left():
"""플레이어 차량을 왼쪽으로 이동 (차선 제한 적용)"""
# 중앙선(x=0)으로 이동하려 하면 우측으로 보정
if player_car.xcor() - MOVE_STEP <= ROAD_CENTER:
player_car.setx(player_car.xcor() + MOVE_STEP)
else:
player_car.setx(player_car.xcor() - MOVE_STEP)
update()
def move_right():
"""플레이어 차량을 오른쪽으로 이동 (차선 제한 적용)"""
# 우측 차선 넘으려 하면 좌측으로 보정
max_x = ROAD_RIGHT - CELL_SIZE # 우측 차선 바로 왼쪽까지 허용
if player_car.xcor() + MOVE_STEP > max_x:
player_car.setx(player_car.xcor() - MOVE_STEP)
else:
player_car.setx(player_car.xcor() + MOVE_STEP)
update()
# 신호등 그리기 함수
def draw_signal():
"""신호등 그리기"""
signal = turtle.Turtle()
signal.hideturtle()
signal.penup()
radius = 15
x = ROAD_RIGHT + 2 * radius
y = HEIGHT // 2 * CELL_SIZE - 2 * radius
# 차량이 차선 범위 안에 있으면 초록색, 아니면 빨간색
car_x = player_car.xcor()
min_x = ROAD_CENTER + CELL_SIZE # 중앙선 바로 오른쪽
max_x = ROAD_RIGHT - CELL_SIZE - 10 # 우측 차선 바로 왼쪽보다 약간 더 좁게
if min_x <= car_x <= max_x:
color = 'green'
else:
color = 'red'
signal.goto(x, y)
signal.pendown()
signal.fillcolor(color)
signal.begin_fill()
signal.circle(radius)
signal.end_fill()
signal.penup()
# UI 정보 표시
def draw_ui():
"""UI 정보 표시"""
ui = turtle.Turtle()
ui.hideturtle()
ui.penup()
ui.color('black')
ui.goto(-WIDTH // 2 * CELL_SIZE, HEIGHT // 2 * CELL_SIZE + 20)
active_cars = sum(1 for car in oncoming_cars if car.isvisible())
ui.write(f"안전거리: {SAFE_DISTANCE}px | 활성차량: {active_cars}/{max_cars} | 조작: ← → | ESC: 종료", font=("Arial", 12, "normal"))
# 업데이트 함수
def update():
draw_lanes()
draw_safe_distance()
draw_signal()
draw_ui()
update_oncoming_cars()
screen.update()
# 게임 종료 함수
def exit_game():
screen.bye()
# 자동 업데이트 함수
def auto_update():
update()
screen.ontimer(auto_update, 50)
# 키 바인딩
screen.listen()
screen.onkeypress(move_left, "Left")
screen.onkeypress(move_right, "Right")
screen.onkeypress(exit_game, "Escape")
# 초기 화면 그리기
draw_lanes()
draw_safe_distance()
draw_signal()
draw_ui()
# 자동 업데이트 시작
auto_update()
screen.mainloop()
import random
a = 6 #주사위를 굴릴 횟수 부분
j=0; k=0; l=0; m=0; n=0; o=0
for i in range(1,a+1) :
ii = random. randint (1,6)
if ii==1 :
j=j+1
if ii==2 :
k=k+1
if ii==3 :
l=l+1
if ii==4 :
m=m+1
if ii==5 :
n=n+1
if ii==6 :
o=o+1
average = (i+j+k+l+m+n) /6
print("1이 나온 횟수 : ", j)
print("2가 나온 횟수 :", k)
print("3이 나온 횟수,", l)
print("4가 나온 횟수", m)
print("5가 나온 횟수 :", n)
print("6이 나온 횟수 :", o)
print("각 눈이 나온 평균 횟수 :", average)
import random
a = 6
count = [0, 0, 0, 0, 0, 0]
for i in range(a):
ii = random.randint(1, 6)
count[ii - 1] += 1 # 주사위 눈 1~6 → 인덱스 0~5
average = sum(count) / len(count)
for i in range(6):
print(i+1,"이 나온 횟수:",count[i],"회")
print("각 눈이 나온 평균 횟수:", average)
import random
names = ['지아','이태','형주','지석','동윤','홍규','현국','나나','현웅','지훈']
print('오늘의 발표자는', random.sample(names,5), '입니다')
# random. sample(): 리스트 항목 중 n개를 랜덤으로 추출하여 새로운 리스트를 만듦. 원본은 유지됨.
import random, time
import turtle as t
names = ['지아', '이태', '형주', '지석', '동윤', '홍규', '현국', '나나', '현웅', '지훈']
n = 5 # 뽑는 인원
t.title("발표자 뽑기")
t.hideturtle()
t.pendown()
for x in range(20) : # 20번 깜빡임
tstr ="오늘의 발표자는 "
for _ in range(n):
tstr += "%s " %names[random.randrange(0, len(names))]
tstr += "입니다"
t.write(tstr, False, "center", ("나눔고딕",13, "bold"))
t.clear( )
time. sleep(0.1)
t.write(tstr, False, "center",("나눔고딕" , 13, "bold"))
import random, time
import turtle as t
#사용자에게 발표자 명단 입력 받기
input_names = input("발표자 이름들을 쉼표(,)로 구분해서 입력하세요: ")
names = input_names.replace(" ", "").split(",")
# 뽑을 인원 수 입력
n = int(input("발표자를 몇 명 뽑을까요? (최대 " + str(len(names)) + "명): "))
t.title("발표자 뽑기")
t. hideturtle()
t. pendown()
for x in range(10): # 10번 깜빡임
tstr ="오늘의 발표자는 "
for _ in range(n):
tstr += "%s " %names[random.randrange(0, len(names))]
tstr += "입니다"
t.write(tstr, False, "center", ("나눔고딕",13, "bold"))
t.clear( )
time.sleep(0.3)
t.write(tstr, False, "center",("나눔고딕" , 13, "bold"))
import random, time
import turtle as t
#사용자에게 발표자 명단 입력 받기
input_names = input("발표자 이름들을 쉼표(,)로 구분해서 입력하세요: ")
names = input_names.replace(" ", "").split(",")
# 뽑을 인원 수 입력
n = int(input("발표자를 몇 명 뽑을까요? (최대 " + str(len(names)) + "명): "))
t.title("발표자 뽑기")
t. hideturtle()
t. pendown()
for x in range(10): # 10번 깜빡임
tstr ="오늘의 발표자는 "
for _ in range(n):
tstr += "%s " %names[random.randrange(0, len(names))]
tstr += "입니다"
t.write(tstr, False, "center", ("나눔고딕",13, "bold"))
t.clear( )
time.sleep(0.3)
t.write(tstr, False, "center",("나눔고딕" , 13, "bold"))
import random, time
import turtle as t
#사용자에게 발표자 명단 입력 받기
input_names = input("발표자 이름들을 쉼표(,)로 구분해서 입력하세요: ")
names = input_names.replace(" ", "").split(",")
# 뽑을 인원 수 입력
n = int(input("발표자를 몇 명 뽑을까요? (최대 " + str(len(names)) + "명): "))
t.title("발표자 뽑기")
t. hideturtle()
t. pendown()
for x in range(10): # 10번 깜빡임
tstr ="오늘의 발표자는 "
for _ in range(n):
tstr += "%s " %names[random.randrange(0, len(names))]
tstr += "입니다"
t.write(tstr, False, "center", ("나눔고딕",13, "bold"))
t.clear( )
time.sleep(0.3)
t.write(tstr, False, "center",("나눔고딕" , 13, "bold"))
# 정점 수
n = 5
# 인접 리스트 초기화 (빈 리스트로 채운 2차원 리스트)
graph = [[] for _ in range(n)]
# 정점 정보
vertex = ['서울','대전','광주','강릉','부산']
# 간선 정보: (출발 노드, 도착 노드, 가중치)
edges = [
(0, 3, 169), # 0번 정점과 3번 정점은 169 km 의 가중치로 연결되어 있다.
(1, 3, 205), # 1번 정점과 3번 정점은 205 km 의 가중치로 연결되어 있다.
(2, 0, 268), # 2번 정점과 0번 정점은 268 km 의 가중치로 연결되어 있다.
(2, 1, 140), # 2번 정점과 1번 정점은 140 km 의 가중치로 연결되어 있다.
(3, 4, 286) # 3번 정점과 4번 정점은 286 km 의 가중치로 연결되어 있다.
# 이어서 추가로 간선정보 작성하기
]
# 인접 리스트 구성 (무방향 그래프)
for u, v, w in edges:
graph[u].append([v, w]) # 리스트로 저장: [도착 정점, 가중치]
graph[v].append([u, w]) # 반대 방향도 추가. 이 때 방향이 반대인 중복된 간선이 입력되면 안됨.
# 출력
print("[정점 정보]")
for i in range(n):
print(f"{i}: {vertex[i]}",end=' ')
print("\n[간선 정보]")
for i in range(n):
print(f"정점 {i} → {graph[i]}")
# 정점 수
n = 5
# 인접 리스트 초기화 (빈 리스트로 채운 2차원 리스트)
graph = [[] for _ in range(n)]
# 정점 정보
vertex = ['서울','대전','광주','강릉','부산']
# 간선 정보: (출발 노드, 도착 노드, 가중치)
edges = [
(0, 3, 169), # 0번 정점과 3번 정점은 169 km 의 가중치로 연결되어 있다.
(1, 3, 205), # 1번 정점과 3번 정점은 205 km 의 가중치로 연결되어 있다.
(2, 0, 268), # 2번 정점과 0번 정점은 268 km 의 가중치로 연결되어 있다.
(2, 1, 140), # 2번 정점과 1번 정점은 140 km 의 가중치로 연결되어 있다.
(3, 4, 286) # 3번 정점과 4번 정점은 286 km 의 가중치로 연결되어 있다.
# 이어서 추가로 간선정보 작성하기
]
# 인접 리스트 구성 (무방향 그래프)
for u, v, w in edges:
graph[u].append([v, w]) # 리스트로 저장: [도착 정점, 가중치]
graph[v].append([u, w]) # 반대 방향도 추가. 이 때 방향이 반대인 중복된 간선이 입력되면 안됨.
# 출력
print("[정점 정보]")
for i in range(n):
print(f"{i}: {vertex[i]}",end=' ')
print("\n[간선 정보]")
for i in range(n):
print(f"정점 {i} → {graph[i]}")
def dijkstra(start):
INF = float('inf')
distance = [INF] * n # 인접하지 않은 정점의 비용은 무한대로 초기화
visited = [False] * n # 방문 여부 표시
distance[start] = 0 # 출발지의 비용은 항상 0
for _ in range(n):
# 방문하지 않은 노드 중 최단 거리 노드 선택
min_dist = INF
min_index = -1
for i in range(n):
if not visited[i] and distance[i] < min_dist:
min_dist = distance[i]
min_index = i
if min_index == -1:
break # 연결되지 않은 정점만 남았을 경우 종료
visited[min_index] = True
# 선택된 정점에서 인접한 정점 거리 업데이트
for neighbor, weight in graph[min_index]:
if not visited[neighbor] and distance[min_index] + weight < distance[neighbor]:
distance[neighbor] = distance[min_index] + weight
return distance
# 예시 실행: 0번 정점에서 시작
start_node = 0
shortest_distances = dijkstra(start_node)
# 출력
print(f"정점 {start_node} {vertex[start_node]}에서의 최단 거리:")
for i, d in enumerate(shortest_distances):
print(f" - 정점 {i}: {d}")
# 정점 수
n = 3
# 인접 리스트 초기화 (빈 리스트로 채운 2차원 리스트)
graph = [[] for _ in range(n)]
### 정점 정보 저장
vertex = ['서울','대전','광주'] # 예시: 서울, 대전
### 간선 정보 저장: (출발 노드, 도착 노드, 가중치)
edges = [
(0, 1, 100), # 예시: 0번 정점과 1번 정점은 100 km 의 가중치로 연결되어 있다.
(1, 2, 300) # 예시: 1번 정점과 2번 정점은 300 km 의 가중치로 연결되어 있다.
# 이어서 추가로 간선정보 작성하기
]
# 인접 리스트 구성 (무방향 그래프)
for u, v, w in edges:
graph[u].append([v, w]) # 리스트로 저장: [도착 정점, 가중치]
graph[v].append([u, w]) # 반대 방향도 추가. 이 때 방향이 반대인 중복된 간선이 입력되면 안됨.
# 출력
print("[정점 정보]")
for i in range(n):
print(f"{i}: {vertex[i]}",end=' ')
print("\n[간선 정보]")
for i in range(n):
print(f"정점 {i} → {graph[i]}")
def dijkstra(start):
INF = float('inf')
distance = [INF] * n # 인접하지 않은 정점의 비용은 무한대로 초기화
visited = [False] * n # 방문 여부 표시
distance[start] = 0 # 출발지의 비용은 항상 0
for _ in range(n):
# 방문하지 않은 노드 중 최단 거리 노드 선택
min_dist = INF
min_index = -1
for i in range(n):
if not visited[i] and distance[i] < min_dist:
min_dist = distance[i]
min_index = i
if min_index == -1:
break # 연결되지 않은 정점만 남았을 경우 종료
visited[min_index] = True
# 선택된 정점에서 인접한 정점 거리 업데이트
for neighbor, weight in graph[min_index]:
if not visited[neighbor] and distance[min_index] + weight < distance[neighbor]:
distance[neighbor] = distance[min_index] + weight
return distance
### start_node에 출발지의 정점 번호를 저장
start_node = 0 # 예시: 0번 정점을 출발지로 지정
shortest_distances = dijkstra(start_node)
# 출력
print(f"정점 {start_node} {vertex[start_node]}에서의 최단 거리:")
for i, d in enumerate(shortest_distances):
print(f" - 정점 {i}: {d}")
temperature = 27 # 정수형(int): 오늘의 기온 humidity = 65.5 # 실수형(float): 오늘의 습도 weather = "맑음" # 문자열(str): 오늘의 날씨
temperature = 27 # 정수형(int): 오늘의 기온
humidity = 65.5 # 실수형(float): 오늘의 습도
weather = "맑음" # 문자열(str): 오늘의 날씨
print("현재 기온:", temperature, "℃")
print("현재 습도:", humidity, "%")
print("날씨 상태:", weather)
import requests
import xml.etree.ElementTree as ET #XML 라이브러리
url = "https://www.w3schools.com/xml/simple.xml"
response = requests.get(url) #API 호출
root = ET.fromstring(response.content) #XML 파싱
first_food = root.find("food") #food 정보 추출
name = first_food.find("name").text
price = first_food.find("price").text
print(f"음식명: {name}")
print(f"가격: {price}")
import xml.etree.ElementTree as ET
# XML 데이터를 문자열로 저장
xml_data = '''
<response>
<body>
<items>
<item>
<category>TMP</category>
<obsrValue>27</obsrValue>
</item>
<item>
<category>REH</category>
<obsrValue>60</obsrValue>
</item>
</items>
</body>
</response>
'''
root = ET.fromstring(xml_data) # 문자열을 파싱
items = root.findall('.//item') # item 항목 모두 찾기
temperature = humidity = None # 변수 초기화
# 항목에서 데이터 추출
for item in items:
category = item.find('category').text
value = item.find('obsrValue').text
if category == 'TMP':
temperature = value
elif category == 'REH':
humidity = value
# 결과 출력
print("현재 기온:", temperature, "℃")
print("현재 습도:", humidity, "%")
import matplotlib.pyplot as plt
# 예시 데이터 (최근 5일간 평균 기온)
dates = ["7/1", "7/2", "7/3", "7/4", "7/5"]
temps = [27.3, 28.1, 30.0, 31.2, 29.5]
# 콘솔 출력
for d, t in zip(dates, temps):
print(f"{d} 평균기온: {t}℃")
#그래프 시각화
plt.plot(dates, temps, marker='o', color='skyblue')
plt.title("최근 5일간 평균기온 변화")
plt.xlabel("날짜")
plt.ylabel("기온(℃)")
plt.grid(True)
plt.show()
import requests
import xml.etree.ElementTree as ET
from datetime import datetime, timedelta
# 기상청 API 정보
SERVICE_KEY = "m9JDST5bopm1QCsGbMHOiMil9Cj2y1F/V3doZqx0BtR4UN8/zwHZZtZ+sBVh/TT5m5EoXMNmdLO5Z9RH5dCyKQ=="
NX, NY = "60", "127" # 각 지역 좌표(예시는 서울)
def base_dt():
now = datetime.now().replace(second=0, microsecond=0)
base_time = now.replace(minute=0)
if now.minute < 45:
base_time -= timedelta(hours=1)
return base_time.strftime("%Y%m%d"), base_time.strftime("%H%M")
def pty_text(code: str) -> str:
return {
"0": "맑음",
"1": "비",
"2": "비/눈",
"3": "눈",
"4": "소나기",
"5": "빗방울",
"6": "빗방울/눈날림",
"7": "눈날림",
}.get(code, "맑음")
def pty_emoji(text: str) -> str:
if "비" in text or "소나기" in text or "빗방울" in text:
return "🌧️"
if "눈" in text:
return "❄️"
if "맑음" in text:
return "☀️"
return "☁️"
# API 요청 → XML 파싱 → 값 추출
def fetch_nowcast(nx=NX, ny=NY):
base_date, base_time = base_dt()
url = "http://apis.data.go.kr/1360000/VilageFcstInfoService_2.0/getUltraSrtNcst"
params = {
"serviceKey": SERVICE_KEY,
"numOfRows": "100",
"pageNo": "1",
"dataType": "XML",
"base_date": base_date,
"base_time": base_time,
"nx": nx,
"ny": ny,
}
r = requests.get(url, params=params, timeout=8)
r.raise_for_status()
root = ET.fromstring(r.content)
# 오류 메시지 확인(있으면 진단용 출력)
result_msg = root.findtext(".//resultMsg")
if result_msg and result_msg != "NORMAL_SERVICE":
print("[진단] resultMsg:", result_msg)
data = {}
for it in root.findall(".//item"):
c = it.findtext("category")
v = it.findtext("obsrValue") # 실황 값
if c and v:
data[c] = v
info = {
"base": f"{base_date} {base_time[:2]}:{base_time[2:]}",
"T1H": data.get("T1H", "-"), # 기온(℃)
"REH": data.get("REH", "-"), # 습도(%)
"WSD": data.get("WSD", "-"), # 풍속(m/s)
"PTY": pty_text(data.get("PTY", "0")),
}
return info
# 콘솔 출력
def print_console(info):
icon = pty_emoji(info["PTY"])
print("== 나의 날씨 대시보드 (콘솔) ==")
print(f"기준 시각 : {info['base']} (45분 규칙 적용)")
print(f"강수 형태 : {info['PTY']} {icon}")
print(f"기온(℃) : {info['T1H']}")
print(f"습도(%) : {info['REH']}")
print(f"풍속(m/s) : {info['WSD']}")
# 메인
if __name__ == "__main__":
try:
info = fetch_nowcast()
print_console(info)
except Exception as e:
print("[에러]", e)