IDLE Python Turtle 100제

Python IDLE + turtle 완전 학습 자료

이 자료는 Python IDLE에서 바로 실행할 수 있는 거북이 그래픽 예제 100개를 기초부터 응용·심화까지 단계적으로 정리했습니다. 처음에는 이동·회전·펜 제어부터 시작하고, 이후 반복문, 함수, 좌표, 이벤트, 재귀, 자료구조, BFS·DFS, 프랙탈, OOP, 애니메이션, 반복 내접 다각형까지 확장합니다.

학습 방법은 코드를 먼저 실행 → 숫자 한 곳 수정 → 결과 비교 → 설명 읽기 → 직접 변형 순서가 가장 효과적입니다.

목차

001. 거북이 창 열기 002. 거북이 만들기 003. 앞으로 이동하기 004. 뒤로 이동하기 005. 왼쪽으로 회전 006. 오른쪽으로 회전 007. 펜 들기와 내리기 008. 좌표로 이동하기 009. 거북이 모양 바꾸기 010. 속도 조절하기 011. 선 색상 바꾸기 012. 선 굵기 바꾸기 013. 배경색 바꾸기 014. 정사각형 015. 정삼각형 016. 정오각형 017. 정n각형 018. 원 그리기 019. 반원 020. 점 찍기 021. 글자 쓰기 022. 현재 좌표 확인 023. 현재 방향 확인 024. 방향 직접 설정 025. 숨기기 026. 도장 찍기 027. 색 채우기 028. 별 그리기 029. 나선 정사각형 030. 원형 꽃 031. 무지개 선 032. while 정사각 나선 033. 함수로 정사각형 034. 크기가 다른 사각형 035. 함수로 정n각형 036. 함수로 별 037. 여러 위치에 사각형 038. RGB 색상 039. 랜덤 색상 040. 랜덤 워크 041. 좌표축 그리기 042. 사인 함수 그래프 043. 코사인 함수 그래프 044. 포물선 045. 원의 매개변수 표현 046. 나선 곡선 047. 장미곡선 048. 함수 반환값 활용 049. 리스트에 꼭짓점 저장 050. 리스트 좌표 연결 051. enumerate 활용 052. 두 거북이 053. 여러 거북이 리스트 054. 클릭 위치로 이동 055. 키보드로 전진 056. 키보드 조종 057. 화면 클릭 점 찍기 058. 재귀 전진 059. 재귀 정사각형 060. 재귀 별 061. 재귀 나선 062. 재귀 나무 063. 코흐 곡선 064. 코흐 눈송이 065. 시에르핀스키 삼각형 066. 재귀 원 067. 재귀 회전 다각형 068. 재귀 피보나치 길이 선 069. 스택 개념 시각화 070. 큐 개념 시각화 071. 클래스로 거북이 관리 072. OOP 정사각형 073. OOP 정n각형 074. OOP 여러 객체 075. 상속 활용 076. OOP 재귀 나무 077. OOP 나선 다각형 078. 내접 정사각형 반복 079. 내접 정n각형 080. 재귀 내접 정n각형 081. 테오도로스 와선 082. 극좌표 별 나선 083. 리사주 곡선 084. 하트 곡선 085. 카디오이드 086. 스피로그래프 087. 크기 변화 스피로그래프 088. 점선 만들기 089. 격자 그리기 090. 체스판 091. 막대그래프 092. 산점도 093. 간단한 BFS 시각화 094. 간단한 DFS 시각화 095. 백트래킹 미로 개념 096. 타이머 애니메이션 097. 공 튕기기 기초 098. 자동 회전 애니메이션 099. 간단한 경주 100. 원주 위 점
기초 예제 001

001. 거북이 창 열기

turtle 모듈을 불러오고 그래픽 창을 유지하는 가장 기본적인 코드입니다.
import turtle

turtle.done()
상세 설명
  • `import turtle`은 파이썬 표준 라이브러리의 거북이 그래픽 모듈을 불러옵니다.
  • `turtle.done()`은 거북이 창이 바로 닫히지 않도록 이벤트 루프를 시작합니다.
  • IDLE에서 실행하면 별도의 Turtle Graphics 창이 열립니다.
기초 예제 002

002. 거북이 만들기

실제로 움직일 거북이 객체를 하나 생성합니다.
import turtle

t = turtle.Turtle()

turtle.done()
상세 설명
  • `t = turtle.Turtle()`은 거북이 객체를 만들고 변수 `t`에 저장합니다.
  • 앞으로 이동, 회전, 색상 변경 같은 명령은 대부분 `t`를 통해 실행합니다.
기초 예제 003

003. 앞으로 이동하기

거북이를 현재 바라보는 방향으로 100픽셀 이동시킵니다.
import turtle

t = turtle.Turtle()
t.forward(100)

turtle.done()
상세 설명
  • `forward(100)`은 거북이를 100만큼 전진시킵니다.
  • 펜이 내려가 있으므로 이동 경로가 선으로 그려집니다.
기초 예제 004

004. 뒤로 이동하기

거북이를 현재 방향의 반대로 이동시킵니다.
import turtle

t = turtle.Turtle()
t.backward(100)

turtle.done()
상세 설명
  • `backward(100)`은 거북이가 바라보는 방향은 유지하면서 뒤로 100 이동합니다.
기초 예제 005

005. 왼쪽으로 회전

왼쪽으로 90도 회전하여 ㄴ자 모양의 선을 그립니다.
import turtle

t = turtle.Turtle()
t.forward(100)
t.left(90)
t.forward(100)

turtle.done()
상세 설명
  • `left(90)`은 거북이의 진행 방향을 반시계 방향으로 90도 바꿉니다.
기초 예제 006

006. 오른쪽으로 회전

오른쪽으로 90도 회전하여 꺾인 선을 그립니다.
import turtle

t = turtle.Turtle()
t.forward(100)
t.right(90)
t.forward(100)

turtle.done()
상세 설명
  • `right(90)`은 시계 방향 회전입니다.
기초 예제 007

007. 펜 들기와 내리기

선을 그리지 않고 이동하는 방법을 배웁니다.
import turtle

t = turtle.Turtle()

t.forward(50)
t.penup()
t.forward(50)
t.pendown()
t.forward(50)

turtle.done()
상세 설명
  • `penup()` 이후 이동은 선이 그려지지 않습니다.
  • `pendown()`을 호출하면 다시 선을 그립니다.
기초 예제 008

008. 좌표로 이동하기

절대 좌표를 이용해 원하는 위치로 이동합니다.
import turtle

t = turtle.Turtle()

t.goto(100, 100)
t.goto(-100, 100)
t.goto(0, 0)

turtle.done()
상세 설명
  • `goto(x, y)`는 현재 방향과 관계없이 지정한 좌표로 이동합니다.
  • 화면 중심은 기본적으로 `(0, 0)`입니다.
기초 예제 009

009. 거북이 모양 바꾸기

거북이 커서를 실제 거북이 모양으로 표시합니다.
import turtle

t = turtle.Turtle()
t.shape("turtle")
t.forward(100)

turtle.done()
상세 설명
  • `shape('turtle')` 외에도 `arrow`, `circle`, `square`, `triangle` 등을 사용할 수 있습니다.
기초 예제 010

010. 속도 조절하기

거북이가 그리는 속도를 조절합니다.
import turtle

t = turtle.Turtle()
t.speed(3)

for _ in range(4):
    t.forward(100)
    t.left(90)

turtle.done()
상세 설명
  • `speed(1)`은 느리고, 숫자가 커질수록 빨라집니다.
  • `speed(0)`은 애니메이션 지연을 최소화해 가장 빠르게 그립니다.
기초 예제 011

011. 선 색상 바꾸기

펜 색상을 변경합니다.
import turtle

t = turtle.Turtle()
t.pencolor("red")
t.forward(150)

turtle.done()
상세 설명
  • `pencolor()`은 선의 색을 지정합니다.
기초 예제 012

012. 선 굵기 바꾸기

선의 두께를 변경합니다.
import turtle

t = turtle.Turtle()
t.pensize(8)
t.forward(150)

turtle.done()
상세 설명
  • `pensize(8)`은 8픽셀 정도의 굵은 선을 사용합니다.
기초 예제 013

013. 배경색 바꾸기

화면 객체를 만들고 배경색을 지정합니다.
import turtle

screen = turtle.Screen()
screen.bgcolor("lightyellow")

t = turtle.Turtle()
t.forward(120)

turtle.done()
상세 설명
  • `turtle.Screen()`은 거북이 그래픽 창 자체를 제어합니다.
기초 예제 014

014. 정사각형

반복문으로 정사각형을 그립니다.
import turtle

t = turtle.Turtle()

for _ in range(4):
    t.forward(100)
    t.left(90)

turtle.done()
상세 설명
  • 같은 동작을 4번 반복하므로 `for`문이 적합합니다.
  • 정사각형의 외각은 90도입니다.
기초 예제 015

015. 정삼각형

정삼각형의 외각 120도를 이용합니다.
import turtle

t = turtle.Turtle()

for _ in range(3):
    t.forward(120)
    t.left(120)

turtle.done()
상세 설명
  • 정n각형의 외각은 `360 / n`입니다.
기초 예제 016

016. 정오각형

정오각형을 반복문으로 그립니다.
import turtle

t = turtle.Turtle()

for _ in range(5):
    t.forward(100)
    t.left(72)

turtle.done()
상세 설명
  • 오각형의 외각은 `360 / 5 = 72`도입니다.
기초 예제 017

017. 정n각형

입력값에 따라 여러 정다각형을 그립니다.
import turtle

n = int(input("변의 수: "))

t = turtle.Turtle()

for _ in range(n):
    t.forward(80)
    t.left(360 / n)

turtle.done()
상세 설명
  • `360 / n`을 사용하면 삼각형부터 여러 정다각형까지 일반화할 수 있습니다.
기초 예제 018

018. 원 그리기

반지름 100인 원을 그립니다.
import turtle

t = turtle.Turtle()
t.circle(100)

turtle.done()
상세 설명
  • `circle(radius)`는 현재 위치를 기준으로 원호 또는 원을 그립니다.
기초 예제 019

019. 반원

원 전체가 아닌 180도짜리 원호를 그립니다.
import turtle

t = turtle.Turtle()
t.circle(100, 180)

turtle.done()
상세 설명
  • `circle(반지름, 각도)`의 두 번째 인수는 그릴 원호의 중심각입니다.
기초 예제 020

020. 점 찍기

현재 위치에 원형 점을 표시합니다.
import turtle

t = turtle.Turtle()
t.dot(30, "blue")

turtle.done()
상세 설명
  • `dot(크기, 색상)`으로 점의 크기와 색상을 정할 수 있습니다.
활용 예제 021

021. 글자 쓰기

그래픽 화면에 문자열을 표시합니다.
import turtle

t = turtle.Turtle()
t.write("Hello Turtle!", font=("Arial", 20, "bold"))

turtle.done()
상세 설명
  • `write()`는 좌표 위에 텍스트를 출력합니다.
활용 예제 022

022. 현재 좌표 확인

거북이의 현재 위치를 콘솔에서 확인합니다.
import turtle

t = turtle.Turtle()
t.forward(100)

print(t.position())

turtle.done()
상세 설명
  • `position()`은 현재 `(x, y)` 좌표를 반환합니다.
활용 예제 023

023. 현재 방향 확인

거북이가 바라보는 방향을 확인합니다.
import turtle

t = turtle.Turtle()
t.left(45)

print(t.heading())

turtle.done()
상세 설명
  • 0도는 오른쪽, 90도는 위쪽 방향입니다.
활용 예제 024

024. 방향 직접 설정

상대 회전 대신 절대 방향을 설정합니다.
import turtle

t = turtle.Turtle()
t.setheading(90)
t.forward(100)

turtle.done()
상세 설명
  • `setheading(90)`은 거북이를 위쪽으로 향하게 합니다.
활용 예제 025

025. 숨기기

그림만 보이도록 거북이 커서를 숨깁니다.
import turtle

t = turtle.Turtle()
t.hideturtle()

for _ in range(4):
    t.forward(100)
    t.left(90)

turtle.done()
상세 설명
  • `hideturtle()`은 커서를 감추지만 그리기 기능은 그대로 유지됩니다.
활용 예제 026

026. 도장 찍기

현재 거북이 모양을 화면에 복사합니다.
import turtle

t = turtle.Turtle()
t.shape("turtle")

for _ in range(8):
    t.stamp()
    t.forward(40)

turtle.done()
상세 설명
  • `stamp()`는 이동 경로가 아니라 거북이 모양 자체를 찍습니다.
활용 예제 027

027. 색 채우기

닫힌 도형 내부를 색으로 채웁니다.
import turtle

t = turtle.Turtle()
t.fillcolor("skyblue")

t.begin_fill()

for _ in range(4):
    t.forward(120)
    t.left(90)

t.end_fill()

turtle.done()
상세 설명
  • `begin_fill()`부터 `end_fill()` 사이에 그린 닫힌 영역이 채워집니다.
활용 예제 028

028. 별 그리기

오각별을 그립니다.
import turtle

t = turtle.Turtle()

for _ in range(5):
    t.forward(180)
    t.right(144)

turtle.done()
상세 설명
  • 오각별은 매번 144도씩 회전하면 완성됩니다.
활용 예제 029

029. 나선 정사각형

선의 길이를 조금씩 늘려 사각 나선을 만듭니다.
import turtle

t = turtle.Turtle()

length = 10

for _ in range(40):
    t.forward(length)
    t.left(90)
    length += 5

turtle.done()
상세 설명
  • 반복마다 `length += 5`로 이동 거리가 증가합니다.
활용 예제 030

030. 원형 꽃

원을 회전시키며 반복하여 꽃 모양을 만듭니다.
import turtle

t = turtle.Turtle()
t.speed(0)

for _ in range(36):
    t.circle(80)
    t.left(10)

turtle.done()
상세 설명
  • 36번 × 10도 = 360도이므로 한 바퀴를 채웁니다.
활용 예제 031

031. 무지개 선

리스트의 색을 차례로 사용합니다.
import turtle

colors = ["red", "orange", "yellow", "green", "blue", "purple"]

t = turtle.Turtle()

for color in colors:
    t.pencolor(color)
    t.forward(60)
    t.left(60)

turtle.done()
상세 설명
  • `for color in colors`는 리스트 요소를 하나씩 꺼냅니다.
활용 예제 032

032. while 정사각 나선

`while` 반복문으로 조건이 참인 동안 나선을 그립니다.
import turtle

t = turtle.Turtle()

length = 10

while length <= 200:
    t.forward(length)
    t.left(90)
    length += 10

turtle.done()
상세 설명
  • 반복 횟수가 아니라 조건을 중심으로 제어할 때 `while`이 유용합니다.
활용 예제 033

033. 함수로 정사각형

반복되는 그리기 동작을 함수로 묶습니다.
import turtle

t = turtle.Turtle()

def square(size):
    for _ in range(4):
        t.forward(size)
        t.left(90)

square(120)

turtle.done()
상세 설명
  • `square(size)`는 크기를 매개변수로 받아 재사용할 수 있습니다.
활용 예제 034

034. 크기가 다른 사각형

같은 함수를 다른 인수로 여러 번 호출합니다.
import turtle

t = turtle.Turtle()

def square(size):
    for _ in range(4):
        t.forward(size)
        t.left(90)

square(50)
square(100)
square(150)

turtle.done()
상세 설명
  • 함수의 장점은 코드 중복을 줄이고 재사용성을 높이는 것입니다.
활용 예제 035

035. 함수로 정n각형

다각형 그리기를 일반화한 함수입니다.
import turtle

t = turtle.Turtle()

def polygon(n, size):
    for _ in range(n):
        t.forward(size)
        t.left(360 / n)

polygon(8, 70)

turtle.done()
상세 설명
  • `n`은 변의 수, `size`는 한 변의 길이입니다.
활용 예제 036

036. 함수로 별

별 모양을 하나의 함수로 정의합니다.
import turtle

t = turtle.Turtle()

def star(size):
    for _ in range(5):
        t.forward(size)
        t.right(144)

star(150)

turtle.done()
상세 설명
  • 복잡한 그림도 작은 기능 단위의 함수로 나누면 이해하기 쉽습니다.
활용 예제 037

037. 여러 위치에 사각형

좌표를 매개변수로 전달해 여러 위치에 그림을 배치합니다.
import turtle

t = turtle.Turtle()

def square(x, y, size):
    t.penup()
    t.goto(x, y)
    t.pendown()

    for _ in range(4):
        t.forward(size)
        t.left(90)

square(-150, 0, 80)
square(0, 0, 80)
square(150, 0, 80)

turtle.done()
상세 설명
  • 위치와 크기를 매개변수로 만들면 함수 활용 범위가 넓어집니다.
활용 예제 038

038. RGB 색상

RGB 숫자를 이용해 세밀하게 색을 지정합니다.
import turtle

screen = turtle.Screen()
screen.colormode(255)

t = turtle.Turtle()
t.pencolor(255, 100, 50)
t.forward(150)

turtle.done()
상세 설명
  • `colormode(255)`를 설정하면 각 색 성분을 0~255 범위로 지정할 수 있습니다.
활용 예제 039

039. 랜덤 색상

난수를 이용해 실행할 때마다 다른 색을 만듭니다.
import turtle
import random

screen = turtle.Screen()
screen.colormode(255)

t = turtle.Turtle()

for _ in range(20):
    color = (
        random.randint(0, 255),
        random.randint(0, 255),
        random.randint(0, 255)
    )

    t.pencolor(color)
    t.forward(20)
    t.left(30)

turtle.done()
상세 설명
  • `random.randint(a, b)`는 a부터 b 사이의 정수를 무작위로 반환합니다.
활용 예제 040

040. 랜덤 워크

거북이가 무작위 방향으로 이동하는 랜덤 워크입니다.
import turtle
import random

t = turtle.Turtle()
t.speed(0)

for _ in range(100):
    t.forward(20)
    t.left(random.choice([0, 90, 180, 270]))

turtle.done()
상세 설명
  • `random.choice()`는 리스트에서 하나를 무작위 선택합니다.
활용 예제 041

041. 좌표축 그리기

수학 그래프에 사용할 x축과 y축을 그립니다.
import turtle

t = turtle.Turtle()
t.speed(0)

t.penup()
t.goto(-250, 0)
t.pendown()
t.goto(250, 0)

t.penup()
t.goto(0, -250)
t.pendown()
t.goto(0, 250)

turtle.done()
상세 설명
  • 좌표 기반 그림은 `goto()`를 사용하면 편리합니다.
활용 예제 042

042. 사인 함수 그래프

수학 함수값을 좌표로 변환해 사인 곡선을 그립니다.
import turtle
import math

t = turtle.Turtle()
t.speed(0)

t.penup()

for x in range(-300, 301):
    y = 80 * math.sin(math.radians(x))

    if x == -300:
        t.goto(x, y)
        t.pendown()
    else:
        t.goto(x, y)

turtle.done()
상세 설명
  • 각 x에 대해 y값을 계산한 뒤 `(x, y)` 위치를 연결합니다.
활용 예제 043

043. 코사인 함수 그래프

코사인 함수 그래프를 그립니다.
import turtle
import math

t = turtle.Turtle()
t.speed(0)
t.penup()

for x in range(-300, 301):
    y = 80 * math.cos(math.radians(x))
    t.goto(x, y)
    t.pendown()

turtle.done()
상세 설명
  • `math.cos()`는 라디안 값을 받으므로 `math.radians()`로 변환합니다.
활용 예제 044

044. 포물선

좌표 계산으로 이차함수 그래프를 그립니다.
import turtle

t = turtle.Turtle()
t.speed(0)
t.penup()

for x in range(-200, 201):
    y = x * x / 200 - 100
    t.goto(x, y)
    t.pendown()

turtle.done()
상세 설명
  • 화면에 맞추기 위해 y값을 적절한 비율로 축소했습니다.
활용 예제 045

045. 원의 매개변수 표현

삼각함수로 원의 좌표를 직접 계산합니다.
import turtle
import math

t = turtle.Turtle()
t.speed(0)
t.penup()

for angle in range(361):
    x = 150 * math.cos(math.radians(angle))
    y = 150 * math.sin(math.radians(angle))

    t.goto(x, y)
    t.pendown()

turtle.done()
상세 설명
  • 원은 `x = r cos θ`, `y = r sin θ`로 표현할 수 있습니다.
응용 예제 046

046. 나선 곡선

극좌표 식으로 아르키메데스 나선을 그립니다.
import turtle
import math

t = turtle.Turtle()
t.speed(0)
t.penup()

for angle in range(720):
    r = angle * 0.2
    x = r * math.cos(math.radians(angle))
    y = r * math.sin(math.radians(angle))

    t.goto(x, y)
    t.pendown()

turtle.done()
상세 설명
  • 반지름 `r`이 각도에 비례해 커지므로 바깥쪽으로 퍼지는 나선이 됩니다.
응용 예제 047

047. 장미곡선

극좌표 장미곡선을 그립니다.
import turtle
import math

t = turtle.Turtle()
t.speed(0)
t.penup()

for angle in range(1441):
    theta = math.radians(angle)
    r = 180 * math.sin(5 * theta)

    x = r * math.cos(theta)
    y = r * math.sin(theta)

    t.goto(x, y)
    t.pendown()

turtle.done()
상세 설명
  • `r = a sin(kθ)` 형태에서 k 값에 따라 꽃잎 개수가 달라집니다.
응용 예제 048

048. 함수 반환값 활용

좌표 계산 함수가 값을 반환하도록 구성합니다.
import turtle
import math

def point_on_circle(radius, angle):
    x = radius * math.cos(math.radians(angle))
    y = radius * math.sin(math.radians(angle))
    return x, y

t = turtle.Turtle()

x, y = point_on_circle(150, 45)
t.goto(x, y)

turtle.done()
상세 설명
  • `return x, y`는 두 값을 튜플 형태로 반환합니다.
응용 예제 049

049. 리스트에 꼭짓점 저장

계산한 꼭짓점을 리스트에 저장합니다.
import turtle
import math

points = []

for i in range(5):
    angle = 90 + i * 72
    x = 150 * math.cos(math.radians(angle))
    y = 150 * math.sin(math.radians(angle))
    points.append((x, y))

print(points)

turtle.done()
상세 설명
  • 그래프나 다각형 알고리즘에서는 좌표를 리스트로 관리하면 편리합니다.
응용 예제 050

050. 리스트 좌표 연결

좌표 리스트를 순회하면서 다각형을 그립니다.
import turtle

points = [
    (-100, -100),
    (100, -100),
    (100, 100),
    (-100, 100)
]

t = turtle.Turtle()
t.penup()
t.goto(points[0])
t.pendown()

for p in points[1:]:
    t.goto(p)

t.goto(points[0])

turtle.done()
상세 설명
  • `points[1:]`는 두 번째 원소부터 끝까지 순회합니다.
응용 예제 051

051. enumerate 활용

리스트의 값과 인덱스를 동시에 사용합니다.
import turtle

points = [
    (-150, 0),
    (0, 150),
    (150, 0)
]

t = turtle.Turtle()

for i, p in enumerate(points):
    t.penup()
    t.goto(p)
    t.write(str(i))

turtle.done()
상세 설명
  • `enumerate()`는 `(번호, 값)` 형태로 데이터를 제공합니다.
응용 예제 052

052. 두 거북이

서로 독립적인 두 거북이 객체를 사용합니다.
import turtle

a = turtle.Turtle()
b = turtle.Turtle()

a.pencolor("red")
b.pencolor("blue")

a.forward(120)
b.left(90)
b.forward(120)

turtle.done()
상세 설명
  • 각 객체는 위치, 방향, 색상 상태를 따로 가집니다.
응용 예제 053

053. 여러 거북이 리스트

여러 거북이를 리스트로 관리합니다.
import turtle

turtles = []

for i in range(4):
    t = turtle.Turtle()
    t.left(i * 90)
    turtles.append(t)

for t in turtles:
    t.forward(150)

turtle.done()
상세 설명
  • 객체 여러 개를 리스트에 저장하면 반복문으로 일괄 제어할 수 있습니다.
응용 예제 054

054. 클릭 위치로 이동

마우스로 클릭한 위치로 거북이가 이동합니다.
import turtle

t = turtle.Turtle()

def move(x, y):
    t.goto(x, y)

turtle.onscreenclick(move)

turtle.done()
상세 설명
  • 이벤트가 발생하면 `move(x, y)` 함수가 자동 호출됩니다.
응용 예제 055

055. 키보드로 전진

위쪽 방향키를 누르면 거북이가 이동합니다.
import turtle

t = turtle.Turtle()

def move():
    t.forward(20)

screen = turtle.Screen()
screen.listen()
screen.onkey(move, "Up")

turtle.done()
상세 설명
  • `listen()`은 키보드 입력을 받을 준비를 하고, `onkey()`는 키와 함수를 연결합니다.
응용 예제 056

056. 키보드 조종

방향키를 이용한 간단한 거북이 조종 프로그램입니다.
import turtle

t = turtle.Turtle()

def forward():
    t.forward(20)

def left():
    t.left(15)

def right():
    t.right(15)

screen = turtle.Screen()
screen.listen()

screen.onkey(forward, "Up")
screen.onkey(left, "Left")
screen.onkey(right, "Right")

turtle.done()
상세 설명
  • 이벤트 기반 프로그래밍의 기본 구조를 익힐 수 있습니다.
응용 예제 057

057. 화면 클릭 점 찍기

마우스를 클릭할 때마다 해당 위치에 점을 찍습니다.
import turtle

t = turtle.Turtle()
t.hideturtle()

def draw_dot(x, y):
    t.penup()
    t.goto(x, y)
    t.dot(20)

turtle.onscreenclick(draw_dot)

turtle.done()
상세 설명
  • 클릭 이벤트의 x, y 좌표를 함수의 매개변수로 받습니다.
응용 예제 058

058. 재귀 전진

반복문 없이 재귀 호출로 여러 번 전진합니다.
import turtle

t = turtle.Turtle()

def line(n):
    if n == 0:
        return

    t.forward(20)
    line(n - 1)

line(10)

turtle.done()
상세 설명
  • `n == 0`은 재귀의 종료 조건입니다.
  • 매 호출마다 n이 1씩 줄어듭니다.
응용 예제 059

059. 재귀 정사각형

정사각형의 네 변을 재귀적으로 그립니다.
import turtle

t = turtle.Turtle()

def square(side):
    if side == 0:
        return

    t.forward(100)
    t.left(90)

    square(side - 1)

square(4)

turtle.done()
상세 설명
  • 반복문 대신 함수가 자기 자신을 다시 호출합니다.
응용 예제 060

060. 재귀 별

오각별을 재귀함수로 그립니다.
import turtle

t = turtle.Turtle()

def star(n):
    if n == 0:
        return

    t.forward(150)
    t.right(144)

    star(n - 1)

star(5)

turtle.done()
상세 설명
  • 재귀 호출 횟수가 별의 다섯 변에 대응합니다.
응용 예제 061

061. 재귀 나선

길이를 증가시키며 재귀적으로 나선을 그립니다.
import turtle

t = turtle.Turtle()

def spiral(length):
    if length > 200:
        return

    t.forward(length)
    t.left(90)

    spiral(length + 5)

spiral(10)

turtle.done()
상세 설명
  • 재귀 매개변수 자체가 상태 변화를 표현합니다.
응용 예제 062

062. 재귀 나무

대표적인 재귀 프랙탈인 이진 나무입니다.
import turtle

t = turtle.Turtle()
t.left(90)
t.speed(0)

def tree(length, depth):
    if depth == 0:
        return

    t.forward(length)
    t.left(30)

    tree(length * 0.7, depth - 1)

    t.right(60)

    tree(length * 0.7, depth - 1)

    t.left(30)
    t.backward(length)

tree(100, 6)

turtle.done()
상세 설명
  • 한 가지 가지에서 왼쪽과 오른쪽 두 재귀 호출이 발생합니다.
  • 마지막 `backward()`는 부모 가지 위치로 복귀하는 백트래킹 역할을 합니다.
응용 예제 063

063. 코흐 곡선

한 선분을 네 부분으로 재귀 분할하는 코흐 곡선입니다.
import turtle

t = turtle.Turtle()
t.speed(0)

def koch(length, depth):
    if depth == 0:
        t.forward(length)
        return

    koch(length / 3, depth - 1)
    t.left(60)
    koch(length / 3, depth - 1)
    t.right(120)
    koch(length / 3, depth - 1)
    t.left(60)
    koch(length / 3, depth - 1)

koch(400, 4)

turtle.done()
상세 설명
  • 깊이가 증가할수록 선분 수가 4배씩 늘어납니다.
응용 예제 064

064. 코흐 눈송이

코흐 곡선 세 개를 연결해 눈송이를 만듭니다.
import turtle

t = turtle.Turtle()
t.speed(0)

def koch(length, depth):
    if depth == 0:
        t.forward(length)
        return

    for angle in [60, -120, 60, 0]:
        koch(length / 3, depth - 1)
        t.left(angle)

for _ in range(3):
    koch(300, 3)
    t.right(120)

turtle.done()
상세 설명
  • 재귀 알고리즘과 반복문을 함께 사용하는 예제입니다.
응용 예제 065

065. 시에르핀스키 삼각형

삼각형을 세 개의 작은 삼각형으로 재귀 분할합니다.
import turtle

t = turtle.Turtle()
t.speed(0)

def triangle(size):
    for _ in range(3):
        t.forward(size)
        t.left(120)

def sierpinski(size, depth):
    if depth == 0:
        triangle(size)
        return

    sierpinski(size / 2, depth - 1)

    t.forward(size / 2)
    sierpinski(size / 2, depth - 1)

    t.backward(size / 2)

    t.left(60)
    t.forward(size / 2)
    t.right(60)

    sierpinski(size / 2, depth - 1)

    t.left(60)
    t.backward(size / 2)
    t.right(60)

sierpinski(300, 4)

turtle.done()
상세 설명
  • 프랙탈의 자기유사성을 재귀 구조로 표현합니다.
응용 예제 066

066. 재귀 원

원의 크기를 점점 줄이며 재귀적으로 그립니다.
import turtle

t = turtle.Turtle()
t.speed(0)

def circles(radius, depth):
    if depth == 0:
        return

    t.circle(radius)
    circles(radius * 0.8, depth - 1)

circles(150, 12)

turtle.done()
상세 설명
  • 재귀 인수 `radius`가 매 호출마다 0.8배가 됩니다.
응용 예제 067

067. 재귀 회전 다각형

축소와 회전을 재귀적으로 반복해 소용돌이 형태를 만듭니다.
import turtle

t = turtle.Turtle()
t.speed(0)

def polygon(size, depth):
    if depth == 0:
        return

    for _ in range(4):
        t.forward(size)
        t.left(90)

    t.left(10)
    polygon(size * 0.92, depth - 1)

polygon(220, 25)

turtle.done()
상세 설명
  • 매 단계에서 크기는 줄고 방향은 10도 회전합니다.
응용 예제 068

068. 재귀 피보나치 길이 선

재귀 피보나치 값을 거북이 이동 길이에 활용합니다.
import turtle

t = turtle.Turtle()

def fib(n):
    if n <= 1:
        return n
    return fib(n - 1) + fib(n - 2)

for i in range(2, 10):
    t.forward(fib(i) * 3)
    t.left(90)

turtle.done()
상세 설명
  • 수치 재귀와 그래픽을 연결한 예입니다.
응용 예제 069

069. 스택 개념 시각화

리스트의 `pop()`을 이용해 스택의 LIFO 구조를 그림으로 확인합니다.
import turtle

stack = [50, 80, 110, 140]

t = turtle.Turtle()
t.speed(0)

while stack:
    size = stack.pop()

    for _ in range(4):
        t.forward(size)
        t.left(90)

    t.left(10)

turtle.done()
상세 설명
  • 마지막에 넣은 140부터 먼저 꺼내집니다.
응용 예제 070

070. 큐 개념 시각화

deque의 `popleft()`를 이용해 FIFO 순서를 시각화합니다.
import turtle
from collections import deque

q = deque([50, 80, 110, 140])

t = turtle.Turtle()
t.speed(0)

while q:
    size = q.popleft()

    for _ in range(4):
        t.forward(size)
        t.left(90)

    t.left(10)

turtle.done()
상세 설명
  • 먼저 들어간 50이 먼저 처리됩니다.
심화 예제 071

071. 클래스로 거북이 관리

거북이 객체를 다른 클래스 안에 포함하는 OOP 구조입니다.
import turtle

class Drawer:
    def __init__(self):
        self.t = turtle.Turtle()

    def line(self, length):
        self.t.forward(length)

d = Drawer()
d.line(150)

turtle.done()
상세 설명
  • `self.t`는 객체가 소유한 거북이입니다.
심화 예제 072

072. OOP 정사각형

도형의 데이터와 기능을 클래스 하나로 묶습니다.
import turtle

class SquareDrawer:
    def __init__(self, size):
        self.size = size
        self.t = turtle.Turtle()

    def draw(self):
        for _ in range(4):
            self.t.forward(self.size)
            self.t.left(90)

s = SquareDrawer(120)
s.draw()

turtle.done()
상세 설명
  • `size`는 객체의 속성, `draw()`는 객체의 메서드입니다.
심화 예제 073

073. OOP 정n각형

다각형의 변 수와 크기를 객체 속성으로 관리합니다.
import turtle

class Polygon:
    def __init__(self, n, size):
        self.n = n
        self.size = size
        self.t = turtle.Turtle()

    def draw(self):
        for _ in range(self.n):
            self.t.forward(self.size)
            self.t.left(360 / self.n)

p = Polygon(7, 80)
p.draw()

turtle.done()
상세 설명
  • 하나의 클래스로 여러 종류의 정다각형 객체를 만들 수 있습니다.
심화 예제 074

074. OOP 여러 객체

같은 클래스로 서로 다른 객체를 생성합니다.
import turtle

class Polygon:
    def __init__(self, n, size):
        self.n = n
        self.size = size
        self.t = turtle.Turtle()

    def draw(self):
        for _ in range(self.n):
            self.t.forward(self.size)
            self.t.left(360 / self.n)

a = Polygon(3, 100)
b = Polygon(5, 100)

a.draw()
b.draw()

turtle.done()
상세 설명
  • 객체마다 n과 size 값을 독립적으로 가집니다.
심화 예제 075

075. 상속 활용

기초적인 클래스 상속 구조를 거북이와 연결합니다.
import turtle

class Shape:
    def __init__(self):
        self.t = turtle.Turtle()

class Square(Shape):
    def draw(self, size):
        for _ in range(4):
            self.t.forward(size)
            self.t.left(90)

s = Square()
s.draw(120)

turtle.done()
상세 설명
  • `Square(Shape)`는 Shape 클래스를 상속받습니다.
심화 예제 076

076. OOP 재귀 나무

재귀함수를 클래스 메서드로 구현합니다.
import turtle

class Tree:
    def __init__(self):
        self.t = turtle.Turtle()
        self.t.left(90)
        self.t.speed(0)

    def draw(self, length, depth):
        if depth == 0:
            return

        self.t.forward(length)
        self.t.left(30)

        self.draw(length * 0.7, depth - 1)

        self.t.right(60)

        self.draw(length * 0.7, depth - 1)

        self.t.left(30)
        self.t.backward(length)

tree = Tree()
tree.draw(100, 6)

turtle.done()
상세 설명
  • `self.draw()`가 자기 자신을 다시 호출하므로 재귀 메서드입니다.
심화 예제 077

077. OOP 나선 다각형

OOP와 재귀를 함께 사용한 도형입니다.
import turtle

class Spiral:
    def __init__(self):
        self.t = turtle.Turtle()
        self.t.speed(0)

    def draw(self, size, depth):
        if depth == 0:
            return

        for _ in range(4):
            self.t.forward(size)
            self.t.left(90)

        self.t.left(10)
        self.draw(size * 0.92, depth - 1)

s = Spiral()
s.draw(220, 25)

turtle.done()
상세 설명
  • 객체 상태와 재귀 알고리즘을 함께 관리할 수 있습니다.
심화 예제 078

078. 내접 정사각형 반복

각 변 위의 점을 연결해 실제 내접 정사각형을 반복 생성합니다.
import turtle

t = turtle.Turtle()
t.speed(0)

points = [
    (-150, -150),
    (150, -150),
    (150, 150),
    (-150, 150)
]

for _ in range(20):
    t.penup()
    t.goto(points[0])
    t.pendown()

    for p in points[1:]:
        t.goto(p)

    t.goto(points[0])

    new_points = []

    for i in range(4):
        x1, y1 = points[i]
        x2, y2 = points[(i + 1) % 4]

        x = 0.9 * x1 + 0.1 * x2
        y = 0.9 * y1 + 0.1 * y2

        new_points.append((x, y))

    points = new_points

turtle.done()
상세 설명
  • 새 꼭짓점은 이전 다각형의 각 변 위에 있으므로 다음 사각형은 이전 사각형에 내접합니다.
심화 예제 079

079. 내접 정n각형

정n각형의 각 변을 같은 비율로 나누어 반복 내접 다각형 나선을 만듭니다.
import turtle
import math

n = 6
r = 0.15
radius = 200

points = []

for i in range(n):
    a = math.radians(90 + i * 360 / n)
    points.append((radius * math.cos(a), radius * math.sin(a)))

t = turtle.Turtle()
t.speed(0)

for _ in range(25):
    t.penup()
    t.goto(points[0])
    t.pendown()

    for i in range(1, n):
        t.goto(points[i])

    t.goto(points[0])

    new_points = []

    for i in range(n):
        x1, y1 = points[i]
        x2, y2 = points[(i + 1) % n]

        new_points.append((
            (1-r)*x1 + r*x2,
            (1-r)*y1 + r*y2
        ))

    points = new_points

turtle.done()
상세 설명
  • `Q=(1-r)P_i+rP_(i+1)` 형태의 선형보간을 사용합니다.
심화 예제 080

080. 재귀 내접 정n각형

내접 다각형 생성을 재귀적으로 반복합니다.
import turtle
import math

n = 6
r = 0.15

t = turtle.Turtle()
t.speed(0)

points = []

for i in range(n):
    a = math.radians(90 + i * 360 / n)
    points.append((200 * math.cos(a), 200 * math.sin(a)))

def draw(points, depth):
    if depth == 0:
        return

    t.penup()
    t.goto(points[0])
    t.pendown()

    for i in range(1, n):
        t.goto(points[i])

    t.goto(points[0])

    new_points = []

    for i in range(n):
        x1, y1 = points[i]
        x2, y2 = points[(i + 1) % n]

        new_points.append((
            (1-r)*x1 + r*x2,
            (1-r)*y1 + r*y2
        ))

    draw(new_points, depth - 1)

draw(points, 25)

turtle.done()
상세 설명
  • 현재 도형을 그린 뒤 새 꼭짓점을 계산하고 `depth-1`로 다시 호출합니다.
심화 예제 081

081. 테오도로스 와선

연속된 직각삼각형으로 만들어지는 테오도로스 와선을 그립니다.
import turtle
import math

t = turtle.Turtle()
t.speed(0)

scale = 50
x, y = 1, 0

t.penup()
t.goto(0, 0)
t.pendown()
t.goto(x * scale, y * scale)

for n in range(1, 17):
    R = math.sqrt(x*x + y*y)

    new_x = x - y / R
    new_y = y + x / R

    t.goto(new_x * scale, new_y * scale)

    x, y = new_x, new_y

turtle.done()
상세 설명
  • 각 단계에서 길이 1인 변을 이전 반지름에 수직으로 추가하는 좌표식을 사용합니다.
심화 예제 082

082. 극좌표 별 나선

극좌표 반지름에 주기 변화를 넣어 별 모양 나선을 만듭니다.
import turtle
import math

t = turtle.Turtle()
t.speed(0)
t.penup()

for i in range(1200):
    theta = math.radians(i)
    r = 0.12 * i * (1 + 0.3 * math.sin(5 * theta))

    x = r * math.cos(theta)
    y = r * math.sin(theta)

    t.goto(x, y)
    t.pendown()

turtle.done()
상세 설명
  • 삼각함수와 나선을 결합한 심화 예제입니다.
심화 예제 083

083. 리사주 곡선

서로 다른 진동수의 사인 함수를 x, y 좌표에 사용합니다.
import turtle
import math

t = turtle.Turtle()
t.speed(0)
t.penup()

for i in range(2000):
    theta = math.radians(i)

    x = 200 * math.sin(3 * theta)
    y = 150 * math.sin(4 * theta)

    t.goto(x, y)
    t.pendown()

turtle.done()
상세 설명
  • 진동수 비율에 따라 다양한 폐곡선이 나타납니다.
심화 예제 084

084. 하트 곡선

매개변수 방정식으로 하트 모양을 그립니다.
import turtle
import math

t = turtle.Turtle()
t.speed(0)
t.penup()

for i in range(361):
    a = math.radians(i)

    x = 16 * math.sin(a) ** 3
    y = (
        13 * math.cos(a)
        - 5 * math.cos(2*a)
        - 2 * math.cos(3*a)
        - math.cos(4*a)
    )

    t.goto(x * 10, y * 10)
    t.pendown()

turtle.done()
상세 설명
  • 수학식을 화면 좌표로 변환하는 대표적인 예입니다.
심화 예제 085

085. 카디오이드

극좌표 카디오이드 곡선을 그립니다.
import turtle
import math

t = turtle.Turtle()
t.speed(0)
t.penup()

for i in range(721):
    theta = math.radians(i)
    r = 150 * (1 - math.cos(theta))

    x = r * math.cos(theta)
    y = r * math.sin(theta)

    t.goto(x, y)
    t.pendown()

turtle.done()
상세 설명
  • `r=a(1-cosθ)`는 심장형 곡선인 카디오이드의 한 표현입니다.
심화 예제 086

086. 스피로그래프

원을 조금씩 회전시켜 스피로그래프 패턴을 만듭니다.
import turtle

t = turtle.Turtle()
t.speed(0)

for _ in range(72):
    t.circle(100)
    t.left(5)

turtle.done()
상세 설명
  • 72 × 5 = 360도입니다.
심화 예제 087

087. 크기 변화 스피로그래프

회전과 반지름 변화를 동시에 적용합니다.
import turtle

t = turtle.Turtle()
t.speed(0)

for i in range(60):
    t.circle(30 + i)
    t.left(12)

turtle.done()
상세 설명
  • 두 개 이상의 상태 변화를 결합하면 더 복잡한 패턴이 생깁니다.
심화 예제 088

088. 점선 만들기

펜 상태를 반복적으로 바꾸어 점선을 만듭니다.
import turtle

t = turtle.Turtle()

for _ in range(20):
    t.pendown()
    t.forward(10)

    t.penup()
    t.forward(10)

turtle.done()
상세 설명
  • `pendown`과 `penup`을 번갈아 사용합니다.
심화 예제 089

089. 격자 그리기

이중 반복 대신 두 개의 반복문으로 격자를 만듭니다.
import turtle

t = turtle.Turtle()
t.speed(0)

for y in range(-200, 201, 40):
    t.penup()
    t.goto(-200, y)
    t.pendown()
    t.goto(200, y)

for x in range(-200, 201, 40):
    t.penup()
    t.goto(x, -200)
    t.pendown()
    t.goto(x, 200)

turtle.done()
상세 설명
  • 수평선과 수직선을 각각 반복하여 그립니다.
심화 예제 090

090. 체스판

이중 반복문과 짝홀 조건으로 체스판을 만듭니다.
import turtle

t = turtle.Turtle()
t.speed(0)

size = 40

for row in range(8):
    for col in range(8):
        x = -160 + col * size
        y = 160 - row * size

        t.penup()
        t.goto(x, y)
        t.pendown()

        if (row + col) % 2 == 0:
            t.begin_fill()

        for _ in range(4):
            t.forward(size)
            t.right(90)

        if (row + col) % 2 == 0:
            t.end_fill()

turtle.done()
상세 설명
  • 행 번호와 열 번호의 합이 짝수인 칸만 채웁니다.
심화 예제 091

091. 막대그래프

데이터 값을 막대의 높이로 바꾸어 간단한 막대그래프를 그립니다.
import turtle

data = [80, 120, 60, 150, 100]

t = turtle.Turtle()
t.speed(0)

x = -200

for value in data:
    t.penup()
    t.goto(x, -150)
    t.pendown()

    for length in [value, 40, value, 40]:
        t.forward(length)
        t.left(90)

    x += 70

turtle.done()
상세 설명
  • 자료 시각화의 기본 원리를 직접 구현할 수 있습니다.
심화 예제 092

092. 산점도

무작위 데이터 점들을 화면에 표시합니다.
import turtle
import random

t = turtle.Turtle()
t.hideturtle()

for _ in range(100):
    x = random.randint(-250, 250)
    y = random.randint(-200, 200)

    t.penup()
    t.goto(x, y)
    t.dot(5)

turtle.done()
상세 설명
  • 각 자료를 좌표 하나로 표현하는 산점도의 기본 구조입니다.
심화 예제 093

093. 간단한 BFS 시각화

큐를 이용한 BFS 방문 순서를 점으로 표시합니다.
import turtle
from collections import deque

graph = {
    "A": ["B", "C"],
    "B": ["D", "E"],
    "C": ["F"],
    "D": [],
    "E": [],
    "F": []
}

positions = {
    "A": (0, 150),
    "B": (-100, 50),
    "C": (100, 50),
    "D": (-150, -70),
    "E": (-50, -70),
    "F": (100, -70)
}

q = deque(["A"])
visited = {"A"}

t = turtle.Turtle()
t.hideturtle()

while q:
    node = q.popleft()

    t.penup()
    t.goto(positions[node])
    t.dot(25)
    t.write(node)

    for nxt in graph[node]:
        if nxt not in visited:
            visited.add(nxt)
            q.append(nxt)

turtle.done()
상세 설명
  • BFS는 가까운 깊이의 정점부터 차례대로 방문합니다.
심화 예제 094

094. 간단한 DFS 시각화

재귀함수를 이용해 DFS 방문 순서를 표현합니다.
import turtle

graph = {
    "A": ["B", "C"],
    "B": ["D", "E"],
    "C": ["F"],
    "D": [],
    "E": [],
    "F": []
}

positions = {
    "A": (0, 150),
    "B": (-100, 50),
    "C": (100, 50),
    "D": (-150, -70),
    "E": (-50, -70),
    "F": (100, -70)
}

t = turtle.Turtle()
t.hideturtle()
visited = set()

def dfs(node):
    visited.add(node)

    t.penup()
    t.goto(positions[node])
    t.dot(25)
    t.write(node)

    for nxt in graph[node]:
        if nxt not in visited:
            dfs(nxt)

dfs("A")

turtle.done()
상세 설명
  • DFS는 한 경로를 가능한 깊게 탐색한 뒤 되돌아옵니다.
심화 예제 095

095. 백트래킹 미로 개념

재귀 탐색과 백트래킹의 기본 원리를 작은 미로에서 표현합니다.
import turtle

maze = [
    [0, 0, 1, 0],
    [1, 0, 1, 0],
    [0, 0, 0, 0],
    [0, 1, 1, 0]
]

t = turtle.Turtle()
t.shape("turtle")
t.penup()

cell = 60
visited = set()

def go(r, c):
    if r < 0 or r >= 4 or c < 0 or c >= 4:
        return False

    if maze[r][c] == 1 or (r, c) in visited:
        return False

    visited.add((r, c))

    x = -90 + c * cell
    y = 90 - r * cell

    t.goto(x, y)
    t.stamp()

    if (r, c) == (3, 3):
        return True

    return (
        go(r + 1, c)
        or go(r, c + 1)
        or go(r - 1, c)
        or go(r, c - 1)
    )

go(0, 0)

turtle.done()
상세 설명
  • 갈 수 없는 위치에서는 False를 반환하고 다른 경로를 탐색합니다.
심화 예제 096

096. 타이머 애니메이션

일정 시간 간격으로 함수를 반복 호출해 애니메이션을 만듭니다.
import turtle

screen = turtle.Screen()
t = turtle.Turtle()

def move():
    t.forward(5)
    screen.ontimer(move, 50)

move()

turtle.done()
상세 설명
  • `ontimer(함수, 밀리초)`는 일정 시간이 지난 뒤 함수를 호출합니다.
심화 예제 097

097. 공 튕기기 기초

좌표와 속도를 이용해 화면 벽에서 공이 반사되도록 합니다.
import turtle

screen = turtle.Screen()
screen.setup(600, 400)

ball = turtle.Turtle()
ball.shape("circle")
ball.penup()

dx = 4
dy = 3

def move():
    global dx, dy

    ball.setx(ball.xcor() + dx)
    ball.sety(ball.ycor() + dy)

    if ball.xcor() > 280 or ball.xcor() < -280:
        dx *= -1

    if ball.ycor() > 180 or ball.ycor() < -180:
        dy *= -1

    screen.ontimer(move, 20)

move()
turtle.done()
상세 설명
  • 벽에 닿으면 해당 방향의 속도 부호를 반대로 바꿉니다.
심화 예제 098

098. 자동 회전 애니메이션

타이머를 이용해 거북이를 계속 회전시킵니다.
import turtle

screen = turtle.Screen()
t = turtle.Turtle()
t.shape("turtle")

def spin():
    t.left(10)
    screen.ontimer(spin, 50)

spin()

turtle.done()
상세 설명
  • 무한 반복문 대신 이벤트 기반 반복을 사용하므로 창이 멈추지 않습니다.
심화 예제 099

099. 간단한 경주

난수를 사용해 두 거북이의 경주를 구현합니다.
import turtle
import random

a = turtle.Turtle()
b = turtle.Turtle()

a.penup()
b.penup()

a.goto(-250, 50)
b.goto(-250, -50)

while a.xcor() < 250 and b.xcor() < 250:
    a.forward(random.randint(1, 10))
    b.forward(random.randint(1, 10))

turtle.done()
상세 설명
  • 각 반복마다 이동 거리가 달라져 결과가 매번 달라질 수 있습니다.
심화 예제 100

100. 원주 위 점

원의 둘레에 일정한 각도 간격으로 점을 배치합니다.
import turtle
import math

t = turtle.Turtle()
t.hideturtle()

for angle in range(0, 360, 15):
    x = 150 * math.cos(math.radians(angle))
    y = 150 * math.sin(math.radians(angle))

    t.penup()
    t.goto(x, y)
    t.dot(8)

turtle.done()
상세 설명
  • 각도를 균등하게 나누면 원주 위 점들도 균등하게 배치됩니다.