├── .gitignore
├── README.md
├── bgcolor_yellow.py
├── blue_flowers.py
├── cartesian.png
├── click_rose.py
├── click_spiral.py
├── click_square.py
├── colorful_hex.png
├── colorful_squares.py
├── curve_path.py
├── curve_path_filled.py
├── dashed_lines.py
├── draw_circles.py
├── draw_many_circles.py
├── filled_square.py
├── first_square.py
├── goto.png
├── home.png
├── import_and_forward.png
├── onkey.png
├── orig_cartesian.png
├── orig_screenshot_bgcolor_yellow.png
├── orig_screenshot_blue_flowers.png
├── orig_screenshot_click_rose.png
├── orig_screenshot_click_spiral.png
├── orig_screenshot_click_square.png
├── orig_screenshot_colorful_squares.png
├── orig_screenshot_curve_path.png
├── orig_screenshot_curve_path_filled.png
├── orig_screenshot_dashed_lines1.png
├── orig_screenshot_dashed_lines2.png
├── orig_screenshot_draw_circles.png
├── orig_screenshot_draw_many_circles.png
├── orig_screenshot_filled_square.png
├── orig_screenshot_first_square.png
├── orig_screenshot_peace.png
├── orig_screenshot_random_goto1.png
├── orig_screenshot_random_goto2.png
├── orig_screenshot_random_goto3.png
├── orig_screenshot_random_goto4.png
├── orig_screenshot_random_position.png
├── orig_screenshot_random_tracer.png
├── orig_screenshot_setheading_turtle1.png
├── orig_screenshot_setheading_turtle2.png
├── orig_screenshot_setheading_turtle3.png
├── orig_screenshot_setheading_turtle4.png
├── orig_screenshot_solution_cross.png
├── orig_screenshot_solution_cube.png
├── orig_screenshot_solution_equilateral_triangle.png
├── orig_screenshot_solution_hexagon.png
├── orig_screenshot_solution_nested_squares.png
├── orig_screenshot_solution_octagon.png
├── orig_screenshot_solution_pentagon.png
├── orig_screenshot_solution_random_hello.png
├── orig_screenshot_solution_right_triangle.png
├── orig_screenshot_solution_star.png
├── orig_screenshot_solution_star_outline.png
├── orig_screenshot_solution_triforce.png
├── orig_screenshot_spiral.png
├── orig_screenshot_spiral_black_bg.png
├── orig_screenshot_spiral_rainbow.png
├── orig_screenshot_square_circle_86.png
├── orig_screenshot_square_for_loop_86.png
├── orig_screenshot_square_random1.png
├── orig_screenshot_square_random2.png
├── orig_screenshot_square_random3.png
├── orig_screenshot_square_random4.png
├── orig_screenshot_square_smaller.png
├── orig_screenshot_square_smaller_bug.png
├── orig_screenshot_turtle_directions.png
├── orig_screenshot_turtlecolors1.png
├── orig_screenshot_turtlecolors2.png
├── orig_screenshot_turtlecolors3.png
├── orig_screenshot_turtlecolors4.png
├── orig_screenshot_write_hello.png
├── oscar1.jpg
├── oscar2.jpg
├── oscar3.jpg
├── oscar4.jpg
├── pencolor.png
├── pensize.png
├── random_goto.py
├── random_position.py
├── random_tracer.py
├── rgb_background.py
├── screenshot_bgcolor_yellow.jpg
├── screenshot_blue_flowers.jpg
├── screenshot_click_rose.jpg
├── screenshot_click_spiral.jpg
├── screenshot_click_square.jpg
├── screenshot_colorful_squares.jpg
├── screenshot_colorful_squares.png
├── screenshot_curve_path.jpg
├── screenshot_curve_path.png
├── screenshot_curve_path_filled.jpg
├── screenshot_curve_path_filled.png
├── screenshot_dashed1.png
├── screenshot_dashed2.png
├── screenshot_dashed_lines1.jpg
├── screenshot_dashed_lines2.jpg
├── screenshot_draw_circles.jpg
├── screenshot_draw_circles.png
├── screenshot_draw_many_circles.jpg
├── screenshot_draw_many_circles.png
├── screenshot_filled_square.jpg
├── screenshot_filled_square.png
├── screenshot_first_square.jpg
├── screenshot_peace.jpg
├── screenshot_random_goto1.jpg
├── screenshot_random_goto2.jpg
├── screenshot_random_goto3.jpg
├── screenshot_random_goto4.jpg
├── screenshot_random_position.jpg
├── screenshot_random_tracer.jpg
├── screenshot_random_tracer.png
├── screenshot_setheading_turtle1.jpg
├── screenshot_setheading_turtle2.jpg
├── screenshot_setheading_turtle3.jpg
├── screenshot_setheading_turtle4.jpg
├── screenshot_sierpinski_game.jpg
├── screenshot_solution_cross.jpg
├── screenshot_solution_cube.jpg
├── screenshot_solution_equilateral_triangle.jpg
├── screenshot_solution_hexagon.jpg
├── screenshot_solution_nested_squares.jpg
├── screenshot_solution_octagon.jpg
├── screenshot_solution_pentagon.jpg
├── screenshot_solution_random_hello.jpg
├── screenshot_solution_right_triangle.jpg
├── screenshot_solution_star.jpg
├── screenshot_solution_star_outline.jpg
├── screenshot_solution_triforce.jpg
├── screenshot_spiral.jpg
├── screenshot_spiral_black_bg.jpg
├── screenshot_spiral_rainbow.jpg
├── screenshot_spiral_random.jpg
├── screenshot_square_circle_86.jpg
├── screenshot_square_for_loop_86.jpg
├── screenshot_square_random1.jpg
├── screenshot_square_random2.jpg
├── screenshot_square_random3.jpg
├── screenshot_square_random4.jpg
├── screenshot_square_smaller.jpg
├── screenshot_square_smaller_bug.jpg
├── screenshot_stamp_path.jpg
├── screenshot_star_outline.jpg
├── screenshot_star_outline.png
├── screenshot_turtle_directions.jpg
├── screenshot_turtlecolors1.jpg
├── screenshot_turtlecolors2.jpg
├── screenshot_turtlecolors3.jpg
├── screenshot_turtlecolors4.jpg
├── screenshot_write_hello.jpg
├── setheading.png
├── setheading_turtle.py
├── sierpinski_game.py
├── simple_turtle_tutorial.css
├── simple_turtle_tutorial.md
├── simple_turtle_tutorial_de.md
├── simple_turtle_tutorial_es.md
├── simple_turtle_tutorial_fr.md
├── simple_turtle_tutorial_ru.md
├── solution_cross.py
├── solution_cross_setheading.py
├── solution_cube.py
├── solution_equilateral_triangle.py
├── solution_fan.py
├── solution_hexagon.py
├── solution_nested_squares.py
├── solution_octagon.py
├── solution_pentagon.py
├── solution_random_hello.py
├── solution_right_triangle.py
├── solution_star.py
├── solution_star_outline.py
├── solution_triforce.py
├── spiral.py
├── spiral_black_bg.py
├── spiral_color.py
├── spiral_rainbow.py
├── spiral_red.py
├── square.png
├── square_circle_86.py
├── square_for_loop.py
├── square_for_loop_86.py
├── square_random.py
├── square_smaller.py
├── square_smaller_bug.py
├── square_spiral.png
├── square_variable.py
├── stamp.png
├── stamp_path.py
├── test_example_programs.py
├── turn_left.png
├── turn_right.png
├── turtle_directions.py
├── turtlecolors.py
├── undo_after.png
├── undo_before.png
└── write_hello.py
/.gitignore:
--------------------------------------------------------------------------------
1 | dist
2 | _build
3 | *.pyc
4 | __pycache__
5 | simple-turtle-tutorial-for-python.egg-info
6 | simple_turtle_tutorial.html
7 | _deleteme.py
8 | .DS_Store
9 | delme*
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # simple-turtle-tutorial-for-python
2 |
3 | **[Link to the tutorial](simple_turtle_tutorial.md)**
4 |
5 | A simple tutorial for Python's turtle.py written by Al Sweigart. This tutorial is written using common English words (like the Simple English Wikipedia is written) so it can easily translate into other languages.
6 |
7 | Please read https://simple.wikipedia.org/wiki/Wikipedia:How_to_write_Simple_English_pages
8 |
9 | This tutorial and its translations will be published on ReadTheDocs.org. This tutorial is not meant to replace the official turtle.py documentation.
10 |
11 | The "Prime Directives" of this tutorial are:
12 |
13 | * This tutorial is written in simple English, understandable by children and non-native English speakers.
14 | * ~~This tutorial covers the turtle.py module, but not programming or Python.~~
15 | * ~~This is not a project-based tutorial, but instead a simple list of all the turtle functions with examples.~~
16 | * The Python code in this tutorial should be kept simple. No recursion, classes, list comprehensions, or complicated data structures. Programs should be under 30 lines.
17 | * This tutorial's code should work with Python 2 and Python 3.
18 |
19 |
20 | As the Tortuga project translates the turtle.py module into other languages, this tutorial can be adapted to use those translated modules.
--------------------------------------------------------------------------------
/bgcolor_yellow.py:
--------------------------------------------------------------------------------
1 | # bgcolor_yellow.py
2 | from turtle import *
3 |
4 | pensize(4)
5 | speed('fastest')
6 | bgcolor('yellow')
7 | pencolor('blue')
8 |
9 | for i in range(50): # Loop 50 times instead of 4.
10 | forward(200)
11 | left(86)
12 | hideturtle()
13 | done()
--------------------------------------------------------------------------------
/blue_flowers.py:
--------------------------------------------------------------------------------
1 | # blue_flowers.py
2 | from turtle import *
3 | from random import *
4 |
5 | tracer(100, 0)
6 |
7 | for n in range(50):
8 | # Move to a random location:
9 | penup()
10 | x = randint(-300, 300)
11 | y = randint(-300, 300)
12 | goto(x, y)
13 | pendown()
14 |
15 | # Make a random blue color:
16 | pencolor((0, 0, random()))
17 |
18 | # Make a random pen thickness:
19 | pensize(randint(1, 5))
20 |
21 | # Make a random size for the circles:
22 | circle_size = randint(10, 40)
23 |
24 | # Draw six circles.
25 | for i in range(6):
26 | circle(circle_size)
27 | left(60)
28 | update()
29 | done()
30 |
--------------------------------------------------------------------------------
/cartesian.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/cartesian.png
--------------------------------------------------------------------------------
/click_rose.py:
--------------------------------------------------------------------------------
1 | # click_rose.py
2 | from turtle import *
3 | from random import *
4 |
5 | tracer(1000, 0)
6 | bgcolor('black')
7 | hideturtle()
8 |
9 | def draw_rose(x, y):
10 | # Move to the XY coordinates of the mouse click:
11 | penup()
12 | goto(x, y)
13 | pendown()
14 |
15 | # Draw a red rose bud:
16 | for i in range(100):
17 | # Set random pen color and size for each line:
18 | pencolor((random(), 0, 0))
19 | pensize(randint(2, 5))
20 | forward(i)
21 | left(randint(50, 70))
22 | update()
23 |
24 |
25 | # Set the draw_rose() function to be called when a click happens:
26 | getscreen().onclick(draw_rose)
27 |
28 | done()
--------------------------------------------------------------------------------
/click_spiral.py:
--------------------------------------------------------------------------------
1 | # click_spiral.py
2 | from turtle import *
3 | from random import *
4 |
5 | tracer(1000, 0) # TODO
6 |
7 | def draw_spiral(x, y):
8 | # Move to the XY coordinates of the mouse click:
9 | penup()
10 | goto(x, y)
11 | pendown()
12 |
13 | # Draw a spiral:
14 | setheading(0)
15 | line_length = randint(50, 200)
16 | turn_radius = randint(50, 70)
17 | for i in range(100):
18 | forward(i)
19 | left(turn_radius)
20 | update()
21 |
22 | # Set the draw_spiral() function to be called when a click happens:
23 | getscreen().onclick(draw_spiral)
24 | done()
--------------------------------------------------------------------------------
/click_square.py:
--------------------------------------------------------------------------------
1 | # click_square.py
2 | from turtle import *
3 |
4 | speed('fastest')
5 |
6 | def draw_square(x, y):
7 | # Move to the XY coordinates of the mouse click:
8 | penup()
9 | goto(x, y)
10 | pendown()
11 |
12 | # Draw a square:
13 | for i in range(4):
14 | forward(100)
15 | left(90)
16 |
17 | # Set the draw_square() function to be called when a click happens:
18 | getscreen().onclick(draw_square) # NOTE: There is no () after draw_square
19 | done()
20 |
--------------------------------------------------------------------------------
/colorful_hex.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/colorful_hex.png
--------------------------------------------------------------------------------
/colorful_squares.py:
--------------------------------------------------------------------------------
1 | # colorful_squares.py
2 |
3 | from turtle import *
4 | from random import *
5 |
6 | pensize(4)
7 | tracer(10, 0)
8 |
9 | for i in range(100): # Draw 100 squares.
10 | # Move to a random place:
11 | penup()
12 | goto(randint(-400, 200), randint(-400, 200))
13 | pendown()
14 |
15 | # Set fill and pen colors to something random:
16 | fillcolor((random(), random(), random()))
17 | pencolor((random(), random(), random()))
18 |
19 | # Make the square size random:
20 | line_length = randint(20, 200)
21 |
22 | # Draw the filled-in square:
23 | begin_fill()
24 | for j in range(4):
25 | forward(line_length)
26 | left(90)
27 | end_fill()
28 |
29 | done()
--------------------------------------------------------------------------------
/curve_path.py:
--------------------------------------------------------------------------------
1 | # curve_path.py
2 |
3 | from turtle import *
4 | from random import *
5 |
6 | tracer(4, 0)
7 |
8 | for i in range(100):
9 | # Move the turtle back to 0, 0:
10 | penup()
11 | home()
12 | pendown()
13 |
14 | # Set a random heading and draw several short lines with changing direction:
15 | setheading(randint(0, 360))
16 | for j in range(randint(200, 600)):
17 | forward(1)
18 | left(randint(-4, 4))
19 |
20 |
21 | update()
22 | done()
23 |
--------------------------------------------------------------------------------
/curve_path_filled.py:
--------------------------------------------------------------------------------
1 | # curve_path_filled.py
2 |
3 | from turtle import *
4 | from random import *
5 |
6 | tracer(4, 0)
7 |
8 | for i in range(50):
9 | fillcolor((random(), random(), random()))
10 |
11 | # Set a random heading and draw several short lines with changing direction:
12 | setheading(randint(0, 360))
13 | begin_fill()
14 | for j in range(randint(200, 600)):
15 | forward(1)
16 | left(randint(-4, 4))
17 | home()
18 | end_fill()
19 |
20 | update()
21 | done()
22 |
--------------------------------------------------------------------------------
/dashed_lines.py:
--------------------------------------------------------------------------------
1 | # dashed_lines.py
2 | from turtle import *
3 | from random import *
4 |
5 | pensize(4)
6 | speed('fastest')
7 |
8 | for i in range(12):
9 | # Face a random direction:
10 | setheading(randint(0, 360))
11 |
12 | # Make a dashed line in that direction:
13 | for j in range(6):
14 | pendown()
15 | forward(10) # Draw a line segment.
16 | penup()
17 | forward(10) # Move without drawing a line segment.
18 |
19 | # Make one last line segment:
20 | pendown()
21 | forward(10)
22 |
23 | done()
24 |
--------------------------------------------------------------------------------
/draw_circles.py:
--------------------------------------------------------------------------------
1 | # draw_circles.py
2 | from turtle import *
3 |
4 | speed('fastest')
5 |
6 | # Draw circle in the top half of the window:
7 | setheading(0) # Face right.
8 | for i in range(20):
9 | circle(i * 10)
10 |
11 | # Draw circles in the bottom half of the window:
12 | setheading(180) # Face left.
13 | for i in range(20):
14 | circle(i * 10)
15 |
16 | done()
17 |
--------------------------------------------------------------------------------
/draw_many_circles.py:
--------------------------------------------------------------------------------
1 | # draw_many_circles.py
2 | from turtle import *
3 |
4 | speed('fastest')
5 |
6 | for j in range(6):
7 | setheading(j)
8 | for i in range(20):
9 | circle(i * 10)
10 |
11 | setheading(j + 120)
12 | for i in range(20):
13 | circle(i * 10)
14 |
15 | setheading(j + 240)
16 | for i in range(20):
17 | circle(i * 10)
18 |
19 | done()
20 |
--------------------------------------------------------------------------------
/filled_square.py:
--------------------------------------------------------------------------------
1 | # filled_square.py
2 |
3 | from turtle import *
4 |
5 | pensize(4)
6 |
7 | fillcolor('blue')
8 |
9 | begin_fill()
10 | for i in range(4):
11 | forward(200)
12 | left(90)
13 | end_fill()
14 |
15 | done()
--------------------------------------------------------------------------------
/first_square.py:
--------------------------------------------------------------------------------
1 | # first_square.py
2 |
3 | # This is a comment.
4 | # Everything after # is a "comment" and is not run as code.
5 | # Use comments to make notes to yourself about your code.
6 |
7 | from turtle import *
8 |
9 | pensize(4) # Make the lines thicker than normal.
10 |
11 | forward(200) # Move the turtle forward 200 steps.
12 | left(90) # Turn the turtle left by 90 degrees.
13 |
14 | # Move forward and turn three more times:
15 | forward(200)
16 | left(90)
17 | forward(200)
18 | left(90)
19 | forward(200)
20 | left(90)
21 |
22 | done() # Without this, the Turtle window may immediately close before you can see the picture.
23 |
--------------------------------------------------------------------------------
/goto.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/goto.png
--------------------------------------------------------------------------------
/home.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/home.png
--------------------------------------------------------------------------------
/import_and_forward.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/import_and_forward.png
--------------------------------------------------------------------------------
/onkey.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/onkey.png
--------------------------------------------------------------------------------
/orig_cartesian.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_cartesian.png
--------------------------------------------------------------------------------
/orig_screenshot_bgcolor_yellow.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_bgcolor_yellow.png
--------------------------------------------------------------------------------
/orig_screenshot_blue_flowers.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_blue_flowers.png
--------------------------------------------------------------------------------
/orig_screenshot_click_rose.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_click_rose.png
--------------------------------------------------------------------------------
/orig_screenshot_click_spiral.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_click_spiral.png
--------------------------------------------------------------------------------
/orig_screenshot_click_square.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_click_square.png
--------------------------------------------------------------------------------
/orig_screenshot_colorful_squares.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_colorful_squares.png
--------------------------------------------------------------------------------
/orig_screenshot_curve_path.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_curve_path.png
--------------------------------------------------------------------------------
/orig_screenshot_curve_path_filled.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_curve_path_filled.png
--------------------------------------------------------------------------------
/orig_screenshot_dashed_lines1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_dashed_lines1.png
--------------------------------------------------------------------------------
/orig_screenshot_dashed_lines2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_dashed_lines2.png
--------------------------------------------------------------------------------
/orig_screenshot_draw_circles.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_draw_circles.png
--------------------------------------------------------------------------------
/orig_screenshot_draw_many_circles.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_draw_many_circles.png
--------------------------------------------------------------------------------
/orig_screenshot_filled_square.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_filled_square.png
--------------------------------------------------------------------------------
/orig_screenshot_first_square.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_first_square.png
--------------------------------------------------------------------------------
/orig_screenshot_peace.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_peace.png
--------------------------------------------------------------------------------
/orig_screenshot_random_goto1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_random_goto1.png
--------------------------------------------------------------------------------
/orig_screenshot_random_goto2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_random_goto2.png
--------------------------------------------------------------------------------
/orig_screenshot_random_goto3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_random_goto3.png
--------------------------------------------------------------------------------
/orig_screenshot_random_goto4.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_random_goto4.png
--------------------------------------------------------------------------------
/orig_screenshot_random_position.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_random_position.png
--------------------------------------------------------------------------------
/orig_screenshot_random_tracer.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_random_tracer.png
--------------------------------------------------------------------------------
/orig_screenshot_setheading_turtle1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_setheading_turtle1.png
--------------------------------------------------------------------------------
/orig_screenshot_setheading_turtle2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_setheading_turtle2.png
--------------------------------------------------------------------------------
/orig_screenshot_setheading_turtle3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_setheading_turtle3.png
--------------------------------------------------------------------------------
/orig_screenshot_setheading_turtle4.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_setheading_turtle4.png
--------------------------------------------------------------------------------
/orig_screenshot_solution_cross.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_solution_cross.png
--------------------------------------------------------------------------------
/orig_screenshot_solution_cube.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_solution_cube.png
--------------------------------------------------------------------------------
/orig_screenshot_solution_equilateral_triangle.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_solution_equilateral_triangle.png
--------------------------------------------------------------------------------
/orig_screenshot_solution_hexagon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_solution_hexagon.png
--------------------------------------------------------------------------------
/orig_screenshot_solution_nested_squares.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_solution_nested_squares.png
--------------------------------------------------------------------------------
/orig_screenshot_solution_octagon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_solution_octagon.png
--------------------------------------------------------------------------------
/orig_screenshot_solution_pentagon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_solution_pentagon.png
--------------------------------------------------------------------------------
/orig_screenshot_solution_random_hello.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_solution_random_hello.png
--------------------------------------------------------------------------------
/orig_screenshot_solution_right_triangle.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_solution_right_triangle.png
--------------------------------------------------------------------------------
/orig_screenshot_solution_star.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_solution_star.png
--------------------------------------------------------------------------------
/orig_screenshot_solution_star_outline.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_solution_star_outline.png
--------------------------------------------------------------------------------
/orig_screenshot_solution_triforce.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_solution_triforce.png
--------------------------------------------------------------------------------
/orig_screenshot_spiral.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_spiral.png
--------------------------------------------------------------------------------
/orig_screenshot_spiral_black_bg.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_spiral_black_bg.png
--------------------------------------------------------------------------------
/orig_screenshot_spiral_rainbow.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_spiral_rainbow.png
--------------------------------------------------------------------------------
/orig_screenshot_square_circle_86.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_square_circle_86.png
--------------------------------------------------------------------------------
/orig_screenshot_square_for_loop_86.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_square_for_loop_86.png
--------------------------------------------------------------------------------
/orig_screenshot_square_random1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_square_random1.png
--------------------------------------------------------------------------------
/orig_screenshot_square_random2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_square_random2.png
--------------------------------------------------------------------------------
/orig_screenshot_square_random3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_square_random3.png
--------------------------------------------------------------------------------
/orig_screenshot_square_random4.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_square_random4.png
--------------------------------------------------------------------------------
/orig_screenshot_square_smaller.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_square_smaller.png
--------------------------------------------------------------------------------
/orig_screenshot_square_smaller_bug.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_square_smaller_bug.png
--------------------------------------------------------------------------------
/orig_screenshot_turtle_directions.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_turtle_directions.png
--------------------------------------------------------------------------------
/orig_screenshot_turtlecolors1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_turtlecolors1.png
--------------------------------------------------------------------------------
/orig_screenshot_turtlecolors2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_turtlecolors2.png
--------------------------------------------------------------------------------
/orig_screenshot_turtlecolors3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_turtlecolors3.png
--------------------------------------------------------------------------------
/orig_screenshot_turtlecolors4.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_turtlecolors4.png
--------------------------------------------------------------------------------
/orig_screenshot_write_hello.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/orig_screenshot_write_hello.png
--------------------------------------------------------------------------------
/oscar1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/oscar1.jpg
--------------------------------------------------------------------------------
/oscar2.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/oscar2.jpg
--------------------------------------------------------------------------------
/oscar3.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/oscar3.jpg
--------------------------------------------------------------------------------
/oscar4.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/oscar4.jpg
--------------------------------------------------------------------------------
/pencolor.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/pencolor.png
--------------------------------------------------------------------------------
/pensize.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/pensize.png
--------------------------------------------------------------------------------
/random_goto.py:
--------------------------------------------------------------------------------
1 | # random_goto.py
2 | from turtle import *
3 | from random import *
4 |
5 | pensize(4)
6 |
7 | for i in range(6):
8 | x = randint(-400, 400)
9 | y = randint(-400, 400)
10 | goto(x, y)
11 | write(position(), font=('Arial', 18, 'normal'))
12 |
13 | done()
14 |
--------------------------------------------------------------------------------
/random_position.py:
--------------------------------------------------------------------------------
1 | # random_position.py
2 | from turtle import *
3 | from random import *
4 |
5 | for i in range(8):
6 | write(position(), font=('Arial', 18, 'normal'))
7 | left(randint(0, 90))
8 | forward(100)
9 |
10 | done()
11 |
--------------------------------------------------------------------------------
/random_tracer.py:
--------------------------------------------------------------------------------
1 | # random_tracer.py
2 |
3 | from turtle import *
4 | from random import *
5 |
6 | tracer(10, 0)
7 |
8 | for i in range(1000):
9 | goto(randint(-400, 400), randint(-400, 400))
10 |
11 | update()
12 | done()
13 |
--------------------------------------------------------------------------------
/rgb_background.py:
--------------------------------------------------------------------------------
1 | from turtle import *
2 |
3 | # Set up some constants for slider positions:
4 | RED_X = -200
5 | GREEN_X = 0
6 | BLUE_X = 200
7 | TOP = 200
8 | BOTTOM = -200
9 | SLIDER_LENGTH = abs(TOP - BOTTOM)
10 | CLICK_RANGE = 20
11 | TEXT_OFFSET = -75
12 | COLOR_BOXES = ((0,0,0), (128,128,128), (128,0,0), (128,128,0), (0,128,0), (0,128,128), (0,0,128), (128,0,128), (128,128,64), (0,64,64), (0,128,255), (0,64,128), (128,0,255), (128,64,0),
13 | (255,255,255), (192,192,192), (255,0,0), (255,255,0), (0,255,0), (0,255,255), (0,0,255), (255,0,255), (255,255,128), (0,255,128), (128,255,255), (128,128,255), (255,0,128), (255,128,64))
14 | COLOR_BOX_SIZE = 30
15 | COLOR_BOX_TOP = 280
16 | COLOR_BOX_LEFT = -240
17 | COLOR_BOX_GAP = 5
18 |
19 | # Set up global variables:
20 | red_setting = 0.5
21 | green_setting = 0.5
22 | blue_setting = 0.5
23 | bgcolor((red_setting, green_setting, blue_setting))
24 | color_box_values = []
25 |
26 | # Draw slider lines:
27 | tracer(1000, 0)
28 | hideturtle()
29 | pensize(6)
30 | setheading(270)
31 | for x in (RED_X, 0, BLUE_X):
32 | penup()
33 | goto(x, TOP)
34 | pendown()
35 | forward(SLIDER_LENGTH)
36 |
37 | # Draw color boxes:
38 | colormode(255)
39 | pensize(1)
40 | for i, color in enumerate(COLOR_BOXES):
41 | if i < 14:
42 | x = COLOR_BOX_LEFT + (i * COLOR_BOX_SIZE) + (i * COLOR_BOX_GAP)
43 | y = COLOR_BOX_TOP # Top row of the two rows.
44 | else:
45 | x = COLOR_BOX_LEFT + ((i-14) * COLOR_BOX_SIZE) + ((i-14) * COLOR_BOX_GAP)
46 | y = COLOR_BOX_TOP - COLOR_BOX_GAP - COLOR_BOX_SIZE # Bottom row of the two rows.
47 | color_box_values.append((x,y))
48 |
49 | penup()
50 | goto(x, y)
51 | setheading(0)
52 | pendown()
53 | fillcolor(color)
54 | begin_fill()
55 | for j in range(4):
56 | forward(COLOR_BOX_SIZE)
57 | right(90)
58 | end_fill()
59 | colormode(1)
60 |
61 | # Create new turtle cursors for the square slider handles:
62 | red_cursor = Turtle()
63 | green_cursor = Turtle()
64 | blue_cursor = Turtle()
65 | for cursor, color, x in ((red_cursor, 'red', RED_X), (green_cursor, 'green', GREEN_X), (blue_cursor, 'blue', BLUE_X)):
66 | cursor.speed('fastest')
67 | cursor.shape('square')
68 | cursor.fillcolor(color)
69 | cursor.penup()
70 | cursor.goto(x, 0)
71 |
72 | # Create a new turtle cursor for the text:
73 | rw = Turtle()
74 | gw = Turtle()
75 | bw = Turtle()
76 | for t in (rw, gw, bw):
77 | t.hideturtle()
78 | t.penup()
79 | t.pencolor('black')
80 |
81 |
82 |
83 | def handle_click(x, y):
84 | #print('click', x, y)
85 | # Check if the click is on a color box:
86 |
87 |
88 | # Check if the click is on a slider:
89 | if y > TOP or y < BOTTOM:
90 | return # Outside of range, so do nothing.
91 | elif x >= RED_X - CLICK_RANGE and x <= RED_X + CLICK_RANGE:
92 | # Only the drag function if the click happened off of the turtle cursor:
93 | if y > red_cursor.ycor() + 10 or y < red_cursor.ycor() - 10:
94 | handle_red_drag(x, y)
95 | elif x >= GREEN_X - CLICK_RANGE and x <= GREEN_X + CLICK_RANGE:
96 | # Only the drag function if the click happened off of the turtle cursor:
97 | if y > green_cursor.ycor() + 10 or y < green_cursor.ycor() - 10:
98 | handle_green_drag(x, y)
99 | elif x >= BLUE_X - CLICK_RANGE and x <= BLUE_X + CLICK_RANGE:
100 | # Only the drag function if the click happened off of the turtle cursor:
101 | if y > blue_cursor.ycor() + 10 or y < blue_cursor.ycor() - 10:
102 | handle_blue_drag(x, y)
103 |
104 |
105 | def write_rgb_values():
106 | #print((red_setting, green_setting, blue_setting))
107 |
108 | if (red_setting + green_setting + blue_setting) / 3 < 0.5:
109 | rw.pencolor('white')
110 | gw.pencolor('white')
111 | bw.pencolor('white')
112 | else:
113 | rw.pencolor('black')
114 | gw.pencolor('black')
115 | bw.pencolor('black')
116 |
117 | red_text = str(round(red_setting, 2)).ljust(4, '0') + ' ' + str(round(red_setting * 255))
118 | rw.clear()
119 | rw.goto(RED_X + TEXT_OFFSET, BOTTOM - 50)
120 | rw.write(red_text, font=('Arial', 24, 'normal'))
121 |
122 | green_text = str(round(green_setting, 2)).ljust(4, '0') + ' ' + str(round(green_setting * 255))
123 | gw.clear()
124 | gw.goto(GREEN_X + TEXT_OFFSET, BOTTOM - 50)
125 | gw.write(green_text, font=('Arial', 24, 'normal'))
126 |
127 | blue_text = str(round(blue_setting, 2)).ljust(4, '0') + ' ' + str(round(blue_setting * 255))
128 | bw.clear()
129 | bw.goto(BLUE_X + TEXT_OFFSET, BOTTOM - 50)
130 | bw.write(blue_text, font=('Arial', 24, 'normal'))
131 |
132 | update()
133 |
134 |
135 | def handle_red_drag(x, y):
136 | global red_setting
137 | print('red drag', x, y)
138 |
139 | if y > TOP:
140 | red_setting = 1.0
141 | red_cursor.sety(TOP)
142 | elif y < BOTTOM:
143 | red_setting = 0.0
144 | red_cursor.sety(BOTTOM)
145 | else:
146 | red_setting = abs(y - BOTTOM) / SLIDER_LENGTH
147 | red_cursor.sety(y)
148 |
149 | #print('red drag', x, y, red_setting)
150 | bgcolor((red_setting, green_setting, blue_setting))
151 | write_rgb_values()
152 |
153 |
154 | def handle_green_drag(x, y):
155 | global green_setting
156 | print('green drag', x, y)
157 |
158 | if y > TOP:
159 | green_setting = 1.0
160 | green_cursor.sety(TOP)
161 | elif y < BOTTOM:
162 | green_setting = 0.0
163 | green_cursor.sety(BOTTOM)
164 | else:
165 | green_setting = abs(y - BOTTOM) / SLIDER_LENGTH
166 | green_cursor.sety(y)
167 |
168 | #print('green drag', x, y, green_setting)
169 | bgcolor((red_setting, green_setting, blue_setting))
170 | write_rgb_values()
171 |
172 |
173 | def handle_blue_drag(x, y):
174 | global blue_setting
175 | print('blue drag', x, y)
176 |
177 | if y > TOP:
178 | blue_setting = 1.0
179 | blue_cursor.sety(TOP)
180 | elif y < BOTTOM:
181 | blue_setting = 0.0
182 | blue_cursor.sety(BOTTOM)
183 | else:
184 | blue_setting = abs(y - BOTTOM) / SLIDER_LENGTH
185 | blue_cursor.sety(y)
186 |
187 | #print('blue drag', x, y, blue_setting)
188 | bgcolor((red_setting, green_setting, blue_setting))
189 | write_rgb_values()
190 |
191 |
192 | getscreen().onclick(handle_click)
193 | red_cursor.ondrag(handle_red_drag)
194 | green_cursor.ondrag(handle_green_drag)
195 | blue_cursor.ondrag(handle_blue_drag)
196 | #ontimer(write_rgb_values)
197 | write_rgb_values()
198 |
199 | update()
200 | done()
201 |
--------------------------------------------------------------------------------
/screenshot_bgcolor_yellow.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_bgcolor_yellow.jpg
--------------------------------------------------------------------------------
/screenshot_blue_flowers.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_blue_flowers.jpg
--------------------------------------------------------------------------------
/screenshot_click_rose.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_click_rose.jpg
--------------------------------------------------------------------------------
/screenshot_click_spiral.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_click_spiral.jpg
--------------------------------------------------------------------------------
/screenshot_click_square.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_click_square.jpg
--------------------------------------------------------------------------------
/screenshot_colorful_squares.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_colorful_squares.jpg
--------------------------------------------------------------------------------
/screenshot_colorful_squares.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_colorful_squares.png
--------------------------------------------------------------------------------
/screenshot_curve_path.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_curve_path.jpg
--------------------------------------------------------------------------------
/screenshot_curve_path.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_curve_path.png
--------------------------------------------------------------------------------
/screenshot_curve_path_filled.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_curve_path_filled.jpg
--------------------------------------------------------------------------------
/screenshot_curve_path_filled.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_curve_path_filled.png
--------------------------------------------------------------------------------
/screenshot_dashed1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_dashed1.png
--------------------------------------------------------------------------------
/screenshot_dashed2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_dashed2.png
--------------------------------------------------------------------------------
/screenshot_dashed_lines1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_dashed_lines1.jpg
--------------------------------------------------------------------------------
/screenshot_dashed_lines2.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_dashed_lines2.jpg
--------------------------------------------------------------------------------
/screenshot_draw_circles.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_draw_circles.jpg
--------------------------------------------------------------------------------
/screenshot_draw_circles.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_draw_circles.png
--------------------------------------------------------------------------------
/screenshot_draw_many_circles.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_draw_many_circles.jpg
--------------------------------------------------------------------------------
/screenshot_draw_many_circles.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_draw_many_circles.png
--------------------------------------------------------------------------------
/screenshot_filled_square.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_filled_square.jpg
--------------------------------------------------------------------------------
/screenshot_filled_square.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_filled_square.png
--------------------------------------------------------------------------------
/screenshot_first_square.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_first_square.jpg
--------------------------------------------------------------------------------
/screenshot_peace.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_peace.jpg
--------------------------------------------------------------------------------
/screenshot_random_goto1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_random_goto1.jpg
--------------------------------------------------------------------------------
/screenshot_random_goto2.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_random_goto2.jpg
--------------------------------------------------------------------------------
/screenshot_random_goto3.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_random_goto3.jpg
--------------------------------------------------------------------------------
/screenshot_random_goto4.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_random_goto4.jpg
--------------------------------------------------------------------------------
/screenshot_random_position.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_random_position.jpg
--------------------------------------------------------------------------------
/screenshot_random_tracer.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_random_tracer.jpg
--------------------------------------------------------------------------------
/screenshot_random_tracer.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_random_tracer.png
--------------------------------------------------------------------------------
/screenshot_setheading_turtle1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_setheading_turtle1.jpg
--------------------------------------------------------------------------------
/screenshot_setheading_turtle2.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_setheading_turtle2.jpg
--------------------------------------------------------------------------------
/screenshot_setheading_turtle3.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_setheading_turtle3.jpg
--------------------------------------------------------------------------------
/screenshot_setheading_turtle4.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_setheading_turtle4.jpg
--------------------------------------------------------------------------------
/screenshot_sierpinski_game.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_sierpinski_game.jpg
--------------------------------------------------------------------------------
/screenshot_solution_cross.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_solution_cross.jpg
--------------------------------------------------------------------------------
/screenshot_solution_cube.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_solution_cube.jpg
--------------------------------------------------------------------------------
/screenshot_solution_equilateral_triangle.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_solution_equilateral_triangle.jpg
--------------------------------------------------------------------------------
/screenshot_solution_hexagon.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_solution_hexagon.jpg
--------------------------------------------------------------------------------
/screenshot_solution_nested_squares.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_solution_nested_squares.jpg
--------------------------------------------------------------------------------
/screenshot_solution_octagon.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_solution_octagon.jpg
--------------------------------------------------------------------------------
/screenshot_solution_pentagon.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_solution_pentagon.jpg
--------------------------------------------------------------------------------
/screenshot_solution_random_hello.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_solution_random_hello.jpg
--------------------------------------------------------------------------------
/screenshot_solution_right_triangle.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_solution_right_triangle.jpg
--------------------------------------------------------------------------------
/screenshot_solution_star.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_solution_star.jpg
--------------------------------------------------------------------------------
/screenshot_solution_star_outline.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_solution_star_outline.jpg
--------------------------------------------------------------------------------
/screenshot_solution_triforce.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_solution_triforce.jpg
--------------------------------------------------------------------------------
/screenshot_spiral.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_spiral.jpg
--------------------------------------------------------------------------------
/screenshot_spiral_black_bg.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_spiral_black_bg.jpg
--------------------------------------------------------------------------------
/screenshot_spiral_rainbow.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_spiral_rainbow.jpg
--------------------------------------------------------------------------------
/screenshot_spiral_random.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_spiral_random.jpg
--------------------------------------------------------------------------------
/screenshot_square_circle_86.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_square_circle_86.jpg
--------------------------------------------------------------------------------
/screenshot_square_for_loop_86.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_square_for_loop_86.jpg
--------------------------------------------------------------------------------
/screenshot_square_random1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_square_random1.jpg
--------------------------------------------------------------------------------
/screenshot_square_random2.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_square_random2.jpg
--------------------------------------------------------------------------------
/screenshot_square_random3.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_square_random3.jpg
--------------------------------------------------------------------------------
/screenshot_square_random4.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_square_random4.jpg
--------------------------------------------------------------------------------
/screenshot_square_smaller.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_square_smaller.jpg
--------------------------------------------------------------------------------
/screenshot_square_smaller_bug.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_square_smaller_bug.jpg
--------------------------------------------------------------------------------
/screenshot_stamp_path.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_stamp_path.jpg
--------------------------------------------------------------------------------
/screenshot_star_outline.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_star_outline.jpg
--------------------------------------------------------------------------------
/screenshot_star_outline.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_star_outline.png
--------------------------------------------------------------------------------
/screenshot_turtle_directions.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_turtle_directions.jpg
--------------------------------------------------------------------------------
/screenshot_turtlecolors1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_turtlecolors1.jpg
--------------------------------------------------------------------------------
/screenshot_turtlecolors2.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_turtlecolors2.jpg
--------------------------------------------------------------------------------
/screenshot_turtlecolors3.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_turtlecolors3.jpg
--------------------------------------------------------------------------------
/screenshot_turtlecolors4.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_turtlecolors4.jpg
--------------------------------------------------------------------------------
/screenshot_write_hello.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/screenshot_write_hello.jpg
--------------------------------------------------------------------------------
/setheading.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/setheading.png
--------------------------------------------------------------------------------
/setheading_turtle.py:
--------------------------------------------------------------------------------
1 | # setheading_turtle.py
2 |
3 | from turtle import *
4 | from random import *
5 |
6 | pensize(4)
7 | left(randint(0, 360))
8 | write(heading(), font=('Arial', 48, 'normal'))
9 | forward(200)
10 |
11 | setheading(45)
12 | write(heading(), font=('Arial', 48, 'normal'))
13 | forward(200)
14 |
15 | done()
16 |
--------------------------------------------------------------------------------
/sierpinski_game.py:
--------------------------------------------------------------------------------
1 | # sierpinski_game.py
2 | from turtle import *
3 | from random import *
4 |
5 | shape('circle') # Make the turtle cursor a circle.
6 | speed('fast')
7 | penup()
8 |
9 | # Set up the coordinates of the three points of the triangle: A, B, and C
10 | # (You can change these coordinates to anything you like!)
11 |
12 | # Point A is at the top-middle:
13 | AX = 0
14 | AY = 400
15 | goto(AX, AY)
16 | stamp()
17 |
18 | # Point B is at the lower left:
19 | BX = -400
20 | BY = -400
21 | goto(BX, BY)
22 | stamp()
23 |
24 | # Point C is at the lower right:
25 | CX = 400
26 | CY = -400
27 | goto(CX, CY)
28 | stamp()
29 |
30 | # Start the turtle at point A:
31 | x, y = AX, AY
32 |
33 | # Make 1,200 circle stamps:
34 | for i in range(1200):
35 | # Randomly pick one of the three points to move towards:
36 | r = randint(1, 3)
37 |
38 | if r == 1:
39 | # Move to halfway to point A:
40 | setheading(towards(AX, AY))
41 | forward(distance(AX, AY) / 2)
42 | if r == 2:
43 | # Move to halfway to point B:
44 | setheading(towards(BX, BY))
45 | forward(distance(BX, BY) / 2)
46 | if r == 3:
47 | # Move to halfway to point C:
48 | setheading(towards(CX, CY))
49 | forward(distance(CX, CY) / 2)
50 |
51 | # Stamp at the new location.
52 | stamp()
53 |
54 | done()
55 |
--------------------------------------------------------------------------------
/simple_turtle_tutorial.css:
--------------------------------------------------------------------------------
1 | .screenshot {
2 | width: 300px;
3 | }
4 |
5 | .color_td {
6 | width: 30px;
7 | height: 30px;
8 | }
--------------------------------------------------------------------------------
/simple_turtle_tutorial_de.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Ein Einfaches Turtle-Tutorial für das Modul turtle.py von Python
3 | author: Al Sweigart
4 | language: de
5 | ---
6 |
7 |
8 |
9 |
16 |
17 | # Ein Einfaches Turtle-Tutorial für das Modul turtle.py von Python
18 |
19 | *Ein Programmierhandbuch für Schüler:innen und deren Eltern, Lehrer:innen und Kursleiter:innen.*
20 |
21 | **Dieses Dokument befindet sich noch in Arbeit und ist nicht vollständig.**
22 |
23 | Dies ist ein Tutorial zur Turtle-Programmierung von Al Sweigart, Autor von *Automate the Boring Stuff with Python* und anderen Büchern. Alle seine Bücher können kostenlos online gelesen werden unter [https://inventwithpython.com](https://inventwithpython.com)
24 |
25 | ## Inhaltsverzeichnis
26 |
27 | 1. [Einleitung](#einleitung)
28 | 1. [Ein Quadrat Zeichnen](#ein-quadrat-zeichnen)
29 | 1. [Ein Kleineres Quadrat Zeichnen](#ein-kleineres-quadrat-zeichnen)
30 | 1. [Häufige Fehler und Fehlermeldungen](#häufige-fehler-und-fehlermeldungen)
31 | 1. [Ein Quadrat mit einer Schleife Zeichnen](#ein-quadrat-mit-einer-schleife-zeichnen)
32 | 1. [Kurze Wiederholung 1](#kurze-wiederholung-1)
33 | 1. [Übungsaufgaben 1](#übungsaufgaben-1)
34 | 1. [Text im Turtle-Fenster Schreiben](#text-im-turtle-fenster-schreiben)
35 | 1. [Winkel](#winkel)
36 | 1. [XY-Koordinatensystem](#xy-koordinatensystem)
37 | 1. [Home, Löschen, Zurücksetzen, Rückgängig](#home-löschen-zurücksetzen-rückgängig)
38 | 1. [Kurze Wiederholung 2](#kurze-wiederholung-2)
39 | 1. [Übungsaufgaben 2](#übungsaufgaben-2)
40 | 1. [Farben](#farben)
41 | 1. [Stift Heben und Senken](#stift-heben-und-senken)
42 | 1. [Quadratische Spiralen Beispiele](#quadratische-spiralen-beispiele)
43 | 1. [Sehr Schnelles Zeichnen](#sehr-schnelles-zeichnen)
44 | 1. [Interaktives Zeichnen](#interaktives-zeichnen)
45 | 1. [Kurven und Kreise Zeichnen](#kurven-und-kreise-zeichnen)
46 | 1. [Blumenprogramm](#blumenprogramm)
47 | 1. [Gefüllte Formen](#gefüllte-formen)
48 | 1. [Weitere Informationen](#weitere-informationen)
49 | 1. [Fortgeschrittene Turtle-Herausforderungen](#fortgeschrittene-turtle-herausforderungen)
50 | 1. [Lösungen](#lösungen)
51 | 1. [Autor kontaktieren](#autor-kontaktieren)
52 |
53 |
54 | ## Einleitung
55 |
56 | Turtle-Grafik ist eine einfache Möglichkeit, Programmieren durch Zeichnen mit Code zu lernen. Du steuerst einen virtuellen Stift, die sogenannte *Turtle*, die sich auf dem Bildschirm bewegt und dabei Linien zeichnet. Mit dem Computer Bilder zu erstellen ist eine unterhaltsame Art, Programmieren zu lernen. Man kann sich die Turtle wie ein [Etch A Sketch](https://de.wikipedia.org/wiki/Etch_A_Sketch) vorstellen, das über ein Python-Programm gesteuert wird.
57 |
58 | Diese Anleitung erklärt, wie man das `turtle`-Modul von Python verwendet. Sie lehrt jedoch nicht die Programmiersprache Python selbst. Es ist hilfreich, wenn du bereits ein paar grundlegende Konzepte kennst, wie Variablen, Operatoren, Schleifen, Funktionen, das Importieren von Modulen und Zufallszahlen. Das kostenlose Buch [Automate the Boring Stuff with Python](https://automatetheboringstuff.com/) ist ein guter Einstieg für komplette Anfänger:innen.
59 |
60 | Bevor du loslegst, musst du den *Python-Interpreter* von [python.org](https://python.org) herunterladen und installieren – das ist die Software, die Python-Code ausführt. Du brauchst auch einen Code-Editor, wie IDLE, [Mu](https://codewith.mu/) oder [Visual Studio Code](https://code.visualstudio.com/download).
61 |
62 | Programme, die in Python geschrieben sind, nennt man Python-Programme. Nicht alle Python-Programme nutzen Turtle-Grafik. In diesem Handbuch nennen wir Programme, die das `turtle`-Modul verwenden, "Turtle-Programme".
63 |
64 | Auch wenn du noch nicht programmieren kannst, kannst du den Beispielcode einfach in deinen Editor kopieren und ausführen.
65 |
66 |
67 |
68 | ## Ein Quadrat Zeichnen
69 |
70 | Lass uns ein Programm schreiben, das ein Quadrat zeichnet. Erstelle eine neue Datei in deinem Code-Editor. Speichere sie unter dem Namen *first_square.py*. Gib folgenden Python-Code ein:
71 |
72 | ```python
73 | # first_square.py
74 |
75 | # Das ist ein Kommentar.
76 | # Alles nach dem # ist ein "Kommentar" und wird nicht als Code ausgeführt.
77 | # Verwende Kommentare, um dir Notizen zu deinem Code zu machen.
78 |
79 | from turtle import *
80 |
81 | pensize(4) # Mache die Linien dicker als normal.
82 |
83 | forward(200) # Bewege die Turtle 200 Schritte vorwärts.
84 | left(90) # Drehe die Turtle um 90 Grad nach links.
85 |
86 | # Noch drei Mal vorwärts bewegen und drehen:
87 | forward(200)
88 | left(90)
89 | forward(200)
90 | left(90)
91 | forward(200)
92 | left(90)
93 |
94 | done() # Ohne diese Zeile würde sich das Turtle-Fenster sofort schließen.
95 | ```
96 |
97 | Speichere die Datei und führe das Programm aus. (In IDLE kannst du **F5** drücken oder **Run > Run Module** aus dem Menü wählen. In Visual Studio Code klickst du auf **Run > Run Without Debugging**. Bei anderen Editoren kann es anders funktionieren.)
98 |
99 | Beim Ausführen erscheint ein neues Fenster (das *Turtle-Fenster*) mit dieser Zeichnung:
100 |
101 | 
102 |
103 | Die Turtle erscheint als Dreieck. Stell dir vor, sie hält einen Stift und zeichnet beim Bewegen eine Linie. Der Code steuert ihre Bewegung:
104 |
105 | 1. Bewege dich 200 Schritte vorwärts (die Turtle blickt nach rechts).
106 | 2. Drehe dich 90 Grad nach links.
107 | 3. Wiederhole das noch dreimal.
108 | 4. Am Ende steht die Turtle wieder an der Startposition und blickt in die Ausgangsrichtung.
109 | 5. Das Fenster bleibt offen, damit du die Zeichnung betrachten kannst.
110 |
111 | Mit diesen neun Schritten zeichnet die Turtle ein Quadrat.
112 |
113 | Erklärung der Befehle:
114 |
115 | ```python
116 | # first_square.py
117 |
118 | # Das ist ein Kommentar.
119 | # Alles nach dem # ist ein Kommentar und wird ignoriert.
120 | ```
121 |
122 | Der Kommentar `# first_square.py` hilft nur zur Orientierung und ist für Python bedeutungslos.
123 |
124 | Leere Zeilen werden ebenfalls ignoriert.
125 |
126 | ```python
127 | from turtle import *
128 | ```
129 |
130 | Du MUSST diese Zeile am Anfang jedes Turtle-Programms haben. Sie lädt das `turtle`-Modul und ermöglicht die Nutzung der Funktionen wie `pensize()`, `forward()`, `left()` und `done()`.
131 |
132 | Wenn du sie vergisst, bekommst du einen Fehler wie `NameError: name 'forward' is not defined`.
133 |
134 | ```python
135 | pensize(4) # Mache die Linien dicker.
136 | ```
137 |
138 | `pensize` ist eine Funktion, und `pensize(4)` ist ein Funktionsaufruf. Eine *Funktion* ist ein kleiner Programmblock, den du ausführen kannst. Der Wert `4` ist das *Argument* der Funktion.
139 |
140 | Wir schreiben immer Klammern `()` hinter Funktionsnamen, um sie als Funktion kenntlich zu machen.
141 |
142 | ```python
143 | forward(200) # Bewege die Turtle 200 Schritte vorwärts.
144 | left(90) # Drehe sie 90 Grad nach links.
145 | ```
146 |
147 | Die Turtle bewegt sich in ihrer aktuellen Blickrichtung und zeichnet eine Linie hinter sich. `left(90)` dreht sie um 90 Grad gegen den Uhrzeigersinn.
148 |
149 | Willst du sie im Uhrzeigersinn drehen, verwende `right()`.
150 |
151 | ```python
152 | done() # Hält das Fenster offen.
153 | ```
154 |
155 | Ohne `done()` würde sich das Fenster sofort wieder schließen, wenn das Programm endet. Auch wenn `done()` keine Argumente hat, müssen die Klammern `()` geschrieben werden.
156 |
157 | Es gibt viele weitere Turtle-Funktionen. In diesem Tutorial lernst du viele davon kennen, mit denen du schöne Bilder zeichnen kannst.
158 |
159 | Aber fangen wir mit noch ein paar einfachen Beispielen an.
160 |
161 |
162 |
163 | ## Ein Kleineres Quadrat Zeichnen
164 |
165 | Lass uns ein kleineres Quadrat zeichnen. Dazu ändern wir `forward(200)` zu `forward(25)`.
166 | Erstelle eine neue Datei und speichere sie als *square_smaller.py*. Gib diesen Code ein:
167 |
168 | ```python
169 | # square_smaller.py
170 | from turtle import *
171 |
172 | pensize(4)
173 | forward(25) # Die Turtle bewegt sich jetzt nur 25 Schritte.
174 | left(90)
175 | forward(25)
176 | left(90)
177 | forward(25)
178 | left(90)
179 | forward(25)
180 | left(90)
181 | done()
182 | ```
183 |
184 | Wenn du das Programm ausführst, entsteht ein kleineres Quadrat, da die Linien nur 25 Schritte lang sind.
185 |
186 | 
187 |
188 | Achte darauf, **alle vier** `forward(200)`-Befehle auf `forward(25)` zu ändern. Wenn du eine vergisst, wird das Quadrat falsch.
189 |
190 | Hier ist ein Beispiel mit einem Fehler – *square_smaller_bug.py*:
191 |
192 | ```python
193 | # square_smaller_bug.py
194 | from turtle import *
195 |
196 | pensize(4)
197 | forward(25)
198 | left(90)
199 | forward(25)
200 | left(90)
201 | forward(200) # Ups! Diese Zeile wurde nicht geändert!
202 | left(90)
203 | forward(25)
204 | left(90)
205 | done()
206 | ```
207 |
208 | Dieses Programm enthält einen *Bug* und zeichnet das Quadrat falsch:
209 |
210 | 
211 |
212 | Fehler passieren! Es ist kein Problem. Du kannst sie beheben.
213 | Dein Computer tut genau das, was du ihm sagst. Aber es liegt an dir sicherzustellen, dass er auch das tut, **was du eigentlich willst**.
214 | Wenn dein Programm einen Fehler enthält, lies deinen Code sorgfältig und finde heraus, was nicht stimmt.
215 |
216 |
217 |
218 | ## Häufige Fehler und Fehlermeldungen
219 |
220 | Wenn du Python-Code schreibst, bekommst du möglicherweise Fehlermeldungen beim Ausführen.
221 | Achte genau auf die Fehlermeldung – besonders auf die Zeilennummer, an der der Fehler aufgetreten ist.
222 |
223 | Hier sind einige häufige Fehler und ihre Ursachen:
224 |
225 | * **`ModuleNotFoundError: No module named 'trutle'`** – Tippfehler im Import. Wahrscheinlich hast du `from trutle import *` statt `turtle` geschrieben.
226 | * **`NameError: name 'froward' is not defined`** – Tippfehler bei einem Funktions- oder Variablennamen, z. B. `froward(100)` statt `forward`.
227 | * **`TypeError: forward() missing 1 required positional argument: 'distance'`** – Du hast `forward()` ohne Argument geschrieben, es fehlt also die Anzahl der Schritte.
228 | * **`TypeError: left() takes 1 positional argument but 2 were given`** – Du hast `left()` mit zu vielen Argumenten aufgerufen, z. B. `left(90, 45)`. Die Funktion erwartet nur **ein** Argument.
229 | * **`IndentationError: unexpected indent`** – Zu viele oder unpassende Leerzeichen am Zeilenanfang.
230 | * **`IndentationError: expected an indented block after 'for' statement on line 5`** – Nach einer Schleife wie `for i in range(4):` fehlt eine eingerückte Codezeile.
231 | * **`SyntaxError: invalid syntax`** – Allgemeiner Fehler. Python versteht deinen Code nicht. Meistens passiert das bei Tippfehlern, vergessenen Klammern oder falscher Einrückung.
232 |
233 | 💡 Wenn der Fehler laut Meldung in Zeile 5 liegt, kann es gut sein, dass der Fehler **eigentlich in Zeile 4** steckt – Python merkt es manchmal erst später.
234 |
235 |
236 |
237 | ## Ein Quadrat mit einer Variablen zeichnen
238 |
239 | Anstatt direkt `25` in `forward(25)` zu schreiben, können wir eine *Variable* verwenden.
240 | Der Name der Variable ist `line_length` und sie speichert den Wert `25`.
241 |
242 | Speichere eine neue Datei als *square_variable.py* und gib folgenden Code ein:
243 |
244 | ```python
245 | # square_variable.py
246 | from turtle import *
247 |
248 | pensize(4)
249 | line_length = 25 # Diese Variable speichert die Zahl 25.
250 | forward(line_length) # Die Turtle bewegt sich 25 Schritte vorwärts.
251 | left(90)
252 | forward(line_length)
253 | left(90)
254 | forward(line_length)
255 | left(90)
256 | forward(line_length)
257 | left(90)
258 | done()
259 | ```
260 |
261 | Wenn du das Programm ausführst, zeichnet es das gleiche Quadrat wie zuvor:
262 |
263 | 
264 |
265 | Jetzt musst du aber nur noch **eine** Stelle ändern, um die Größe des Quadrats zu verändern!
266 | Versuche es z. B. mit `line_length = 300` oder `line_length = 5`.
267 |
268 |
269 |
270 | ## Ein Quadrat mit einer Schleife zeichnen
271 |
272 | Nun schreiben wir ein Programm, das ein Quadrat mit einer `for`-Schleife zeichnet.
273 | Speichere die Datei als *square_for_loop.py* und gib diesen Code ein:
274 |
275 | ```python
276 | # square_for_loop.py
277 | from turtle import *
278 |
279 | pensize(4)
280 |
281 | # Der eingerückte Code läuft 4 Mal:
282 | for i in range(4):
283 | forward(200)
284 | left(90)
285 | done()
286 | ```
287 |
288 | Der eingerückte Code unter `for i in range(4):` wird **vier Mal** ausgeführt.
289 | Achte genau auf die Einrückung! Es sollten **vier Leerzeichen** vor `forward(200)` und `left(90)` stehen.
290 |
291 | Beispiel mit Punkten zur Veranschaulichung:
292 |
293 | ```
294 | for i in range(4):
295 | ....forward(200)
296 | ....left(90)
297 | done()
298 | ```
299 |
300 | Dieses Programm zeichnet wie zuvor ein Quadrat:
301 |
302 | 
303 |
304 | ---
305 |
306 | Nun ändern wir das Programm so, dass die Turtle sich um **86 Grad** statt 90 dreht.
307 | Speichere es als *square_for_loop_86.py*:
308 |
309 | ```python
310 | # square_for_loop_86.py
311 | from turtle import *
312 |
313 | pensize(4)
314 |
315 | for i in range(4):
316 | forward(200)
317 | left(86) # Drehe um 86 Grad statt 90.
318 | done()
319 | ```
320 |
321 | Das ergibt keine perfekte Ecke:
322 |
323 | 
324 |
325 | ---
326 |
327 | Was passiert, wenn wir diese Schleife 50-mal statt 4-mal wiederholen?
328 |
329 | Speichere das folgende Programm als *square_circle_86.py*:
330 |
331 | ```python
332 | # square_circle_86.py
333 | from turtle import *
334 |
335 | pensize(4)
336 | speed('fastest')
337 |
338 | for i in range(50): # 50 Durchläufe statt 4
339 | forward(200)
340 | left(86)
341 | hideturtle()
342 | done()
343 | ```
344 |
345 | Dieses Programm zeichnet deutlich mehr und schneller.
346 | Wir nutzen `speed('fastest')`, damit die Turtle sich schneller bewegt.
347 | Die Funktion `hideturtle()` blendet den Pfeil aus.
348 |
349 | Das sieht dann so aus:
350 |
351 | 
352 |
353 |
354 |
355 | Nun erweitern wir unser Programm und verwenden **Zufallszahlen** für die Drehung.
356 |
357 | Speichere die Datei als *square_random.py*:
358 |
359 | ```python
360 | # square_random.py
361 | from turtle import *
362 | from random import *
363 |
364 | pensize(4)
365 | speed('fastest')
366 |
367 | for i in range(50):
368 | forward(200)
369 | # Drehe dich zufällig zwischen 80 und 100 Grad:
370 | left(randint(80, 100))
371 | hideturtle()
372 | done()
373 | ```
374 |
375 | Da das Programm `randint(80, 100)` verwendet, ist jedes Ergebnis etwas anders.
376 |
377 | Hier sind ein paar mögliche Ausgaben:
378 |
379 | 
380 | 
381 | 
382 | 
383 |
384 | Die Zeile `from random import *` ermöglicht es, die Funktion `randint()` zu verwenden.
385 | Diese gibt eine zufällige **ganze Zahl** zurück, die wir direkt an die `left()`-Funktion übergeben können.
386 |
387 | Die Zeile `left(randint(80, 100))` dreht die Turtle also jedes Mal anders.
388 |
389 | ---
390 |
391 | Wenn wir Schleifen **und** Zufallszahlen kombinieren, entsteht sogenannte **generative Kunst**.
392 | Wir erschaffen nicht direkt die Kunst, sondern das **Programm**, das sie generiert.
393 |
394 | Es gibt viele kreative Bilder, die du mit Turtle zeichnen kannst!
395 |
396 |
397 |
398 | ## Kurze Wiederholung 1
399 |
400 | Lass uns wiederholen, welche Python-Anweisungen du bisher kennengelernt hast:
401 |
402 | Kommentare beginnen mit dem Zeichen `#`:
403 |
404 | ```python
405 | # Das ist ein Kommentar.
406 | ```
407 |
408 | Alles hinter dem `#` wird ignoriert. Kommentare sind Notizen im Code – sie verändern nichts an der Ausführung.
409 |
410 | ---
411 |
412 | Dein Programm muss das Turtle-Modul importieren:
413 |
414 | ```python
415 | from turtle import *
416 | ```
417 |
418 | Ohne diese Zeile funktionieren die Turtle-Funktionen nicht.
419 |
420 | ---
421 |
422 | Es gibt Funktionen, die die Turtle bewegen:
423 |
424 | ```python
425 | forward(100) # Bewege die Turtle 100 Schritte vorwärts.
426 | backward(100) # Bewege die Turtle 100 Schritte rückwärts.
427 | forward(-100) # Ist das gleiche wie rückwärts.
428 | ```
429 |
430 | ---
431 |
432 | Funktionen zum Drehen der Turtle:
433 |
434 | ```python
435 | left(90) # Drehe nach links (gegen den Uhrzeigersinn).
436 | right(45) # Drehe nach rechts (im Uhrzeigersinn).
437 | ```
438 |
439 | Negative Zahlen drehen in die entgegengesetzte Richtung.
440 |
441 | ---
442 |
443 | Standardmäßig zeichnet die Turtle eine dünne Linie. Mit `pensize()` kannst du sie dicker machen:
444 |
445 | ```python
446 | pensize(4)
447 | ```
448 |
449 | ---
450 |
451 | Am Ende deines Programms solltest du `done()` aufrufen:
452 |
453 | ```python
454 | done()
455 | ```
456 |
457 | Damit bleibt das Turtle-Fenster offen, bis du es schließt.
458 |
459 | ---
460 |
461 | Du kannst Zahlen direkt übergeben oder in Variablen speichern:
462 |
463 | ```python
464 | line_length = 25
465 | forward(line_length)
466 | ```
467 |
468 | ---
469 |
470 | `for`-Schleifen führen Code mehrfach aus:
471 |
472 | ```python
473 | for i in range(4):
474 | forward(200)
475 | left(90)
476 | ```
477 |
478 | ---
479 |
480 | Um die Turtle schneller zu machen, rufe `speed('fastest')` auf:
481 |
482 | ```python
483 | speed('fastest')
484 | ```
485 |
486 | ---
487 |
488 | Willst du den Pfeil (die Turtle) ausblenden, nutze:
489 |
490 | ```python
491 | hideturtle()
492 | ```
493 |
494 | ---
495 |
496 | Du kannst Zufallszahlen nutzen:
497 |
498 | ```python
499 | from random import *
500 | forward(randint(1, 100))
501 | ```
502 |
503 | Die Funktion `randint(1, 100)` gibt eine zufällige ganze Zahl zwischen 1 und 100 zurück.
504 |
505 |
506 |
507 | ## Übungsaufgaben 1
508 |
509 | Erstelle Programme, die die folgenden Bilder zeichnen.
510 | Die Lösungen findest du später im Abschnitt [Lösungen](#lösungen).
511 | Dein Code und deine Zeichnungen müssen nicht exakt gleich aussehen – es gibt viele Wege zum Ziel.
512 |
513 | ---
514 |
515 | ### Gleichseitiges Dreieck
516 | Dateiname: *solution_equilateral_triangle.py*
517 | *Tipp: Alle Seiten sind 200 Schritte lang. Der erste Drehwinkel beträgt 60 Grad, die weiteren 120 Grad.*
518 |
519 | 
520 |
521 | ---
522 |
523 | ### Fünfeck
524 | Dateiname: *solution_pentagon.py*
525 | *Tipp: Alle Seiten 200 Schritte. Drehwinkel: 72 Grad.*
526 |
527 | 
528 |
529 | ---
530 |
531 | ### Sechseck
532 | Dateiname: *solution_hexagon.py*
533 | *Tipp: Seitenlänge 200, Drehwinkel 60 Grad.*
534 |
535 | 
536 |
537 | ---
538 |
539 | ### Achteck
540 | Dateiname: *solution_octagon.py*
541 | *Tipp: Seitenlänge 100, Drehwinkel 45 Grad.*
542 |
543 | 
544 |
545 | ---
546 |
547 | ### Rechtwinkliges Dreieck
548 | Dateiname: *solution_right_triangle.py*
549 | *Tipp: Zwei Seiten sind je 200 lang, der dritte 282.8 (nach Satz des Pythagoras). Drehwinkel: 90 und 135 Grad.*
550 |
551 | 
552 |
553 | ---
554 |
555 | ### Stern
556 | Dateiname: *solution_star.py*
557 | *Tipp: Alle Linien 200 lang. Drehwinkel: 144 Grad.*
558 |
559 | 
560 |
561 | ---
562 |
563 | ### Verschachtelte Quadrate
564 | Dateiname: *solution_nested_squares.py*
565 | *Tipp: Zeichne Quadrate mit Seitenlängen 100, 150, 200, 250, 300.
566 | Nutze ggf. eine Schleife in einer Schleife.*
567 |
568 | 
569 |
570 | ---
571 |
572 | ### Kreuz
573 | Dateiname: *solution_cross.py*
574 | *Tipp: Alle Linien 100 lang. Nutze sowohl `left()` als auch `right()`.*
575 |
576 | 
577 |
578 | ---
579 |
580 | ### Würfel
581 | Dateiname: *solution_cube.py*
582 | *Tipp: Alle Linien 100 lang. Winkel: 45, 90 oder 135 Grad.
583 | Du kannst `forward()` gefolgt von `backward()` nutzen, um zurück zur Ausgangsposition zu kommen.*
584 |
585 | 
586 |
587 | ---
588 |
589 | ### Triforce
590 | Dateiname: *solution_triforce.py*
591 | *Tipp: Linien des äußeren Dreiecks: 100 Schritte. Winkel: 60 oder 120 Grad.
592 | Du kannst Linien überlagern. Manchmal ist `forward(50)` nützlich.*
593 |
594 | 
595 |
596 |
597 |
598 | ## Text im Turtle-Fenster schreiben
599 |
600 | Die Turtle kann nicht nur Linien zeichnen, sondern auch Text im Fenster schreiben.
601 | Die Funktion `write()` nimmt einen Text-String als Argument und schreibt ihn an die aktuelle Position der Turtle.
602 |
603 | Speichere eine neue Datei als *write_hello.py* und gib diesen Code ein:
604 |
605 | ```python
606 | # write_hello.py
607 |
608 | from turtle import *
609 |
610 | write('Hallo, Welt!')
611 | forward(80)
612 | right(45)
613 | forward(50)
614 | write('123456789', font=('Arial', 48, 'normal'))
615 | right(45)
616 | forward(30)
617 | write('oOoOoOoOoOo')
618 | done()
619 | ```
620 |
621 | Wenn du das Programm ausführst, sieht das Fenster etwa so aus:
622 |
623 | 
624 |
625 | Die linke untere Ecke des Textes ist die aktuelle Position der Turtle.
626 | Beispielsweise wird `write('Hallo, Welt!')` in der Mitte des Fensters geschrieben, weil die Turtle dort startet.
627 |
628 | Danach bewegt sie sich mit `forward(80)`, `right(45)` und `forward(50)`.
629 |
630 | Der Aufruf `write('123456789', font=('Arial', 48, 'normal'))` schreibt den Text in einer größeren Schrift.
631 |
632 | Die `font=`-Angabe ist ein **Schlüsselwort-Argument**. Sie besteht aus drei Teilen:
633 |
634 | - dem Namen der Schriftart (`'Arial'`)
635 | - der Schriftgröße (z. B. `48`)
636 | - dem Stil (`'normal'`, `'bold'`, `'italic'`, `'underline'` oder Kombinationen wie `'bold italic'`)
637 |
638 | Wenn du `font=` weglässt, wird standardmäßig `('Arial', 8, 'normal')` verwendet.
639 |
640 | Wichtig: Die Schriftart muss auf deinem Computer installiert sein. Die Größe **muss** eine Zahl sein (nicht `'48'`).
641 |
642 |
643 |
644 | ## Winkel
645 |
646 | In Turtle-Programmen messen wir Entfernungen in Schritten. Zum Beispiel bewegt `forward(100)` die Turtle 100 Schritte.
647 | Auch Drehungen und Richtungen werden mit Zahlen – in **Grad** – angegeben.
648 |
649 | Stell dir vor, du schaust von oben auf die Turtle.
650 | Wenn sie sich nach rechts dreht, bewegt sie sich **im Uhrzeigersinn**.
651 | Dreht sie sich nach links, bewegt sie sich **gegen den Uhrzeigersinn**.
652 |
653 | Ein voller Kreis hat **360 Grad**.
654 | Wenn die Turtle sich um 180 Grad dreht, blickt sie in die entgegengesetzte Richtung.
655 | Vier 90-Grad-Drehungen ergeben ebenfalls eine volle Umdrehung: 90 + 90 + 90 + 90 = 360.
656 |
657 | ---
658 |
659 | Die **Richtung**, in die die Turtle gerade zeigt, wird *heading* genannt.
660 | Beim Start eines Programms zeigt die Turtle **nach rechts** – das ist **0 Grad**.
661 | Dreht sie sich nach links, steigen die Gradzahlen:
662 |
663 | - 0 Grad: rechts
664 | - 90 Grad: oben
665 | - 180 Grad: links
666 | - 270 Grad: unten
667 | - 360 Grad: wieder rechts (gleich wie 0 Grad)
668 |
669 | ---
670 |
671 | Die Funktion `heading()` gibt den aktuellen Blickwinkel der Turtle zurück.
672 |
673 | Speichere eine neue Datei als *turtle_directions.py*:
674 |
675 | ```python
676 | # turtle_directions.py
677 | from turtle import *
678 |
679 | for i in range(24):
680 | forward(100) # Bewege dich in aktueller Richtung.
681 | write(heading(), font=('Arial', 20, 'normal')) # Schreibe den Winkel.
682 | backward(100) # Gehe zurück zur Mitte.
683 | left(15) # Drehe dich 15 Grad nach links.
684 | done()
685 | ```
686 |
687 | Das Fenster sieht so aus:
688 |
689 | 
690 |
691 | ---
692 |
693 | Die Funktionen `left()` und `right()` drehen die Turtle **relativ zur aktuellen Richtung**.
694 | Beispiel: Ist der aktuelle Winkel 45 Grad, dann ergibt `left(90)` eine neue Richtung von 135 Grad.
695 |
696 | Wenn du willst, dass die Turtle **genau** in eine bestimmte Richtung schaut, nutze `setheading()`.
697 |
698 | Speichere dazu dieses Programm als *setheading_turtle.py*:
699 |
700 | ```python
701 | # setheading_turtle.py
702 | from turtle import *
703 | from random import *
704 |
705 | pensize(4)
706 | left(randint(0, 360))
707 | write(heading())
708 | forward(200)
709 |
710 | setheading(45)
711 | write(heading())
712 | forward(200)
713 |
714 | done()
715 | ```
716 |
717 | Dieses Programm startet mit einer zufälligen Drehung.
718 | Dann schreibt es den aktuellen Winkel auf den Bildschirm und bewegt sich 200 Schritte.
719 |
720 | Anschließend setzt `setheading(45)` die Richtung **fest** auf 45 Grad (nach oben rechts),
721 | egal, in welche Richtung die Turtle vorher gezeigt hat.
722 |
723 | Hier sind Beispiele:
724 |
725 | 
726 | 
727 |
728 |
729 |
730 | ## XY-Koordinatensystem
731 |
732 | Neben Richtungen können wir die **Position** der Turtle auch mit Zahlen beschreiben.
733 | Das geschieht mit dem sogenannten **kartesischen Koordinatensystem**.
734 |
735 | Dabei gibt es zwei Werte:
736 |
737 | - Der **X-Wert** beschreibt, wie weit rechts oder links die Turtle ist.
738 | - Der **Y-Wert** beschreibt, wie weit oben oder unten sie ist.
739 |
740 | Zusammen geben **X** und **Y** die genaue Position an.
741 |
742 | ---
743 |
744 | Ein paar Regeln:
745 |
746 | - Die Mitte des Fensters heißt *Ursprung* und hat die Koordinaten `(0, 0)`
747 | - Der **X-Wert** nimmt zu, wenn man nach rechts geht, und ab, wenn man nach links geht
748 | - Der **Y-Wert** nimmt zu, wenn man nach oben geht, und ab, wenn man nach unten geht
749 | - Turtle links vom Ursprung → negativer X-Wert
750 | - Turtle unten im Fenster → negativer Y-Wert
751 |
752 | Hier ist ein Bild zur Veranschaulichung:
753 |
754 | 
755 |
756 | ---
757 |
758 | Speichere ein Programm als *random_position.py*:
759 |
760 | ```python
761 | # random_position.py
762 | from turtle import *
763 | from random import *
764 |
765 | for i in range(8):
766 | write(position())
767 | left(randint(0, 90))
768 | forward(100)
769 |
770 | done()
771 | ```
772 |
773 | Ergebnis:
774 |
775 | 
776 |
777 | ---
778 |
779 | Die Funktionen `forward()` und `backward()` bewegen die Turtle **relativ** zur aktuellen Position.
780 |
781 | Willst du die Turtle an eine bestimmte XY-Position setzen, verwende `goto(x, y)`.
782 |
783 | Speichere folgendes Programm als *random_goto.py*:
784 |
785 | ```python
786 | # random_goto.py
787 | from turtle import *
788 | from random import *
789 |
790 | pensize(4)
791 |
792 | for i in range(6):
793 | x = randint(-400, 400)
794 | y = randint(-400, 400)
795 | goto(x, y)
796 | write(position(), font=('Arial', 18, 'normal'))
797 |
798 | done()
799 | ```
800 |
801 | Das ergibt eine Zeichnung wie:
802 |
803 | 
804 |
805 | Die Position wird per Zufall gewählt mit `randint(-400, 400)`.
806 | `goto(x, y)` setzt die Turtle direkt auf diese Koordinaten.
807 |
808 |
809 |
810 | ## Home, Clear, Reset, Undo
811 |
812 | Die Turtle zeichnet Linien, während sie sich bewegt.
813 | Es gibt mehrere Funktionen, um die Zeichnung oder die Position zu verändern:
814 |
815 | - `home()` bringt die Turtle zurück zur Mitte `(0, 0)` und richtet sie auf 0 Grad aus (nach rechts)
816 | - `clear()` löscht alles, was die Turtle gezeichnet hat (aber nicht die Position oder Richtung)
817 | - `reset()` kombiniert `clear()` und `home()` – also: löschen + zur Mitte zurückkehren
818 | - `undo()` macht den letzten Schritt rückgängig (z. B. die letzte Linie)
819 |
820 | Du kannst `undo()` mehrfach aufrufen, um mehrere Aktionen rückgängig zu machen.
821 |
822 |
823 |
824 | ## Kurze Wiederholung 2
825 |
826 | Lass uns die neuen Anweisungen zusammenfassen:
827 |
828 | ```python
829 | write('Hallo, Welt!')
830 | write('Hallo, Welt!', font=('Arial', 48, 'normal'))
831 | ```
832 |
833 | Die Funktion `write()` schreibt Text an die aktuelle Position der Turtle.
834 | Mit dem Argument `font=` kannst du Schriftart, Größe und Stil angeben.
835 |
836 | ---
837 |
838 | ```python
839 | setheading(90)
840 | richtung = heading()
841 | ```
842 |
843 | - `setheading()` setzt die Blickrichtung der Turtle (0 = rechts, 90 = oben, 180 = links, 270 = unten)
844 | - `heading()` gibt die aktuelle Richtung zurück
845 |
846 | ---
847 |
848 | ```python
849 | goto(250, -100) # Bewege die Turtle zu den Koordinaten 250, -100
850 | ```
851 |
852 | XY-Koordinaten geben die genaue Position an.
853 |
854 | - Ursprung = `(0, 0)`
855 | - X nimmt nach rechts zu, nach links ab
856 | - Y nimmt nach oben zu, nach unten ab
857 |
858 | ---
859 |
860 | Funktionen zum Zurücksetzen oder Löschen:
861 |
862 | - `home()` → zurück zur Mitte und Blick nach rechts
863 | - `clear()` → löscht die Zeichnung
864 | - `reset()` → wie `clear()` + `home()`
865 | - `undo()` → macht letzte Aktion rückgängig
866 |
867 |
868 |
869 | ## Übungsaufgaben 2
870 |
871 | Erstelle Programme, die die folgenden Bilder zeichnen.
872 | Verwende jeweils die angegebenen Hinweise und Funktionen.
873 |
874 | ---
875 |
876 | ### Sternumriss
877 | Dateiname: *solution_star_outline.py*
878 | Nur `goto()` verwenden.
879 | *Tipp: Koordinaten: (0, 300), (70, 95), (285, 95), (110, -35), (175, -260),
880 | (0, -100), (-175, -260), (-110, -35), (-285, 95), (-70, 95), (0, 300)*
881 |
882 | 
883 |
884 | ---
885 |
886 | ### Kreuz mit `setheading()`
887 | Dateiname: *solution_cross_setheading.py*
888 | Kein `left()` oder `right()` verwenden, nur `setheading()`.
889 | *Tipp: Linien 100 Schritte. Blickrichtungen: 0, 90, 180, 270 Grad.*
890 |
891 | 
892 |
893 | ---
894 |
895 | ### Zufällige Grüße
896 | Dateiname: *solution_random_hello.py*
897 | Schreibe 100-mal „Hallo, Welt!“ an zufällige Stellen im Fenster.
898 | Die Schriftgröße soll zufällig zwischen 12 und 48 liegen.
899 | Keine Linien zeichnen und die Turtle verstecken.
900 |
901 | 
902 |
903 |
904 |
905 | ## Farben
906 |
907 | Du kannst die Hintergrundfarbe des Fensters mit `bgcolor()` ändern.
908 | Verwende dazu Farbnamen als Text (z. B. `'red'`) oder RGB-Werte.
909 |
910 | Beispiele für Farb-Namen und ihre RGB-Werte:
911 |
912 | - `'black'` = `(0.0, 0.0, 0.0)`
913 | - `'blue'` = `(0.0, 0.0, 1.0)`
914 | - `'brown'` = `(0.6, 0.4, 0.2)`
915 | - `'orange'` = `(1.0, 0.5, 0.0)`
916 | - `'gray'` = `(0.5, 0.5, 0.5)`
917 | - `'green'` = `(0.0, 1.0, 0.0)`
918 | - `'purple'` = `(0.5, 0.0, 0.5)`
919 | - `'violet'` = `(0.56, 0.0, 1.0)`
920 | - `'pink'` = `(1.0, 0.75, 0.8)`
921 | - `'yellow'` = `(1.0, 1.0, 0.0)`
922 | - `'white'` = `(1.0, 1.0, 1.0)`
923 | - `'red'` = `(1.0, 0.0, 0.0)`
924 | - `'magenta'` = `(1.0, 0.0, 1.0)`
925 | - `'cyan'` = `(0.0, 1.0, 1.0)`
926 |
927 | ---
928 |
929 | Um die Stiftfarbe (Linienfarbe) zu ändern, verwende `pencolor()`.
930 |
931 | Beispiel:
932 |
933 | ```python
934 | bgcolor('yellow')
935 | pencolor('blue')
936 | ```
937 |
938 | Dies ergibt einen gelben Hintergrund und blaue Linien – wie hier:
939 |
940 | 
941 |
942 | ---
943 |
944 | ### RGB-Werte
945 |
946 | Farben können auch mit drei Werten erstellt werden: **Rot**, **Grün** und **Blau**.
947 |
948 | Jeder Wert ist zwischen `0.0` (kein Anteil) und `1.0` (maximal).
949 |
950 | Beispiele:
951 |
952 | - `(1.0, 0.0, 0.0)` → Rot
953 | - `(0.0, 1.0, 0.0)` → Grün
954 | - `(0.0, 0.0, 1.0)` → Blau
955 | - `(1.0, 1.0, 0.0)` → Gelb (Rot + Grün)
956 | - `(1.0, 1.0, 1.0)` → Weiß
957 | - `(0.0, 0.0, 0.0)` → Schwarz
958 |
959 | Dunklere Farben: kleinere Werte
960 | Hellere Farben: größere Werte
961 |
962 | ---
963 |
964 | ### Farbe selbst anpassen
965 |
966 | Nutze das Hilfsprogramm **turtlecolors**:
967 | Kopiere den Code von
968 | [https://raw.githubusercontent.com/asweigart/turtlecolors/refs/heads/main/src/turtlecolors/__init__.py](https://raw.githubusercontent.com/asweigart/turtlecolors/refs/heads/main/src/turtlecolors/__init__.py)
969 | in eine Datei namens `turtlecolors.py` und führe das Programm aus.
970 |
971 | Du kannst die Schieberegler für Rot, Grün und Blau bewegen, um neue Farben zu erstellen.
972 |
973 | So sieht das Programm aus:
974 |
975 | 
976 |
977 |
978 |
979 | ## Stift anheben und absenken
980 |
981 | Stell dir vor, die Turtle hält einen Stift im Mund.
982 | Wenn der Stift **unten ist**, wird beim Bewegen eine Linie gezeichnet.
983 | Wenn der Stift **angehoben ist**, bewegt sich die Turtle **ohne zu zeichnen**.
984 |
985 | Nutze `pendown()` (Stift senken) und `penup()` (Stift heben), um zu steuern, ob gezeichnet wird.
986 |
987 | ---
988 |
989 | ### Beispiel: gestrichelte Linien
990 |
991 | Speichere das folgende Programm als *dashed_lines.py*:
992 |
993 | ```python
994 | # dashed_lines.py
995 | from turtle import *
996 | from random import *
997 |
998 | pensize(4)
999 | speed('fastest')
1000 |
1001 | for i in range(12):
1002 | # In zufällige Richtung drehen:
1003 | setheading(randint(0, 360))
1004 |
1005 | # Eine gestrichelte Linie in dieser Richtung zeichnen:
1006 | for j in range(6):
1007 | pendown()
1008 | forward(10) # Linie zeichnen
1009 | penup()
1010 | forward(10) # Lücke lassen
1011 |
1012 | # Letztes Stück zeichnen:
1013 | pendown()
1014 | forward(10)
1015 |
1016 | done()
1017 | ```
1018 |
1019 | Das äußere `for` wiederholt den Vorgang 12-mal für 12 Striche.
1020 | Im inneren `for` wird jedes Mal 10 Schritte gezeichnet und 10 Schritte ausgelassen.
1021 |
1022 | Beispiele für das Ergebnis:
1023 |
1024 | 
1025 | 
1026 |
1027 |
1028 |
1029 | ## Quadratische Spiralen
1030 |
1031 | Lass uns ein Programm schreiben, das eine quadratische Spirale zeichnet.
1032 | Speichere eine neue Datei als *spiral.py*:
1033 |
1034 | ```python
1035 | # spiral.py
1036 | from turtle import *
1037 |
1038 | speed('fastest')
1039 | for i in range(300):
1040 | forward(i) # Die Variable i bestimmt die Linienlänge
1041 | left(91)
1042 | hideturtle()
1043 | done()
1044 | ```
1045 |
1046 | Das Ergebnis:
1047 |
1048 | 
1049 |
1050 | Hier verwenden wir zum ersten Mal die Schleifenvariable `i` tatsächlich in `forward(i)`.
1051 |
1052 | Im ersten Schleifendurchlauf ist `i = 0`, dann `i = 1`, dann `i = 2` usw., bis `i = 299`.
1053 | Dadurch wird jede Linie ein bisschen länger als die vorherige.
1054 |
1055 | ---
1056 |
1057 | ### Zahlen verändern das Muster
1058 |
1059 | Wenn du `left(91)` z. B. auf `left(88)` oder `left(93)` änderst, ändert sich das Muster.
1060 |
1061 | ---
1062 |
1063 | ### Farbige Spirale mit Zufall
1064 |
1065 | Speichere folgendes als *spiral_black_bg.py*:
1066 |
1067 | ```python
1068 | # spiral_black_bg.py
1069 | from turtle import *
1070 | from random import *
1071 |
1072 | colors = ['red', 'orange', 'yellow', 'blue', 'green', 'purple']
1073 |
1074 | speed('fastest')
1075 | pensize(3)
1076 | bgcolor('black')
1077 | for i in range(300):
1078 | pencolor(choice(colors))
1079 | forward(i)
1080 | left(91)
1081 | hideturtle()
1082 | done()
1083 | ```
1084 |
1085 | Ergebnis:
1086 |
1087 | 
1088 |
1089 | ---
1090 |
1091 | ### Regenbogen-Spirale
1092 |
1093 | Speichere als *spiral_rainbow.py*:
1094 |
1095 | ```python
1096 | # spiral_rainbow.py
1097 | from turtle import *
1098 |
1099 | speed('fastest')
1100 | pensize(3)
1101 | bgcolor('black')
1102 |
1103 | pencolor('red')
1104 | for i in range(60):
1105 | forward(i)
1106 | left(91)
1107 |
1108 | pencolor('orange')
1109 | for i in range(60):
1110 | forward(60 + i)
1111 | left(91)
1112 |
1113 | pencolor('yellow')
1114 | for i in range(60):
1115 | forward(120 + i)
1116 | left(91)
1117 |
1118 | pencolor('green')
1119 | for i in range(60):
1120 | forward(180 + i)
1121 | left(91)
1122 |
1123 | pencolor('blue')
1124 | for i in range(60):
1125 | forward(240 + i)
1126 | left(91)
1127 |
1128 | pencolor('purple')
1129 | for i in range(60):
1130 | forward(300 + i)
1131 | left(91)
1132 |
1133 | done()
1134 | ```
1135 |
1136 | Jede Farbe erhält ihren eigenen Schleifenblock mit zunehmender Startlänge.
1137 | So entsteht eine große, bunte Spirale:
1138 |
1139 | 
1140 |
1141 |
1142 |
1143 | ## Sehr schnell zeichnen
1144 |
1145 | Wenn `speed('fastest')` immer noch zu langsam ist, kannst du `tracer()` und `update()` verwenden.
1146 |
1147 | Normalerweise zeichnet Turtle jede Linie nacheinander – das kann bei vielen Linien langsam sein.
1148 | Mit `tracer(1000, 0)` wird nur alle 1000 Linien das Fenster aktualisiert.
1149 | Mit `update()` kannst du dann manuell das Fenster aktualisieren.
1150 |
1151 | ---
1152 |
1153 | ### Beispiel: 1000 Linien schnell zeichnen
1154 |
1155 | Speichere als *random_tracer.py*:
1156 |
1157 | ```python
1158 | # random_tracer.py
1159 | from turtle import *
1160 | from random import *
1161 |
1162 | tracer(10, 0)
1163 |
1164 | for i in range(1000):
1165 | goto(randint(-400, 400), randint(-400, 400))
1166 |
1167 | update()
1168 | done()
1169 | ```
1170 |
1171 | Das Ergebnis:
1172 |
1173 | 
1174 |
1175 | - Mit `tracer(10, 0)` dauert es ein paar Sekunden
1176 | - Mit `tracer(1000, 0)` fast sofort
1177 | - Noch höhere Werte (z. B. `tracer(10000, 0)`) helfen nur, wenn dein Computer schnell genug ist
1178 |
1179 | **Achtung:** Wenn du `update()` vergisst, wird nichts gezeichnet!
1180 |
1181 |
1182 |
1183 | ## Interaktives Zeichnen
1184 |
1185 | Mit Turtle kannst du auch interaktive Programme schreiben.
1186 | Dazu brauchst du eigene Funktionen (mit `def`) und das Ereignis `onclick()`.
1187 |
1188 | ---
1189 |
1190 | ### Beispiel: Klick zeichnet Quadrat
1191 |
1192 | Speichere *click_square.py*:
1193 |
1194 | ```python
1195 | # click_square.py
1196 | from turtle import *
1197 |
1198 | speed('fastest')
1199 |
1200 | def draw_square(x, y):
1201 | penup()
1202 | goto(x, y)
1203 | pendown()
1204 | for i in range(4):
1205 | forward(100)
1206 | left(90)
1207 |
1208 | getscreen().onclick(draw_square) # Achtung: KEINE () nach draw_square!
1209 | done()
1210 | ```
1211 |
1212 | Bei jedem Mausklick wird `draw_square()` aufgerufen.
1213 | Die `x`- und `y`-Werte geben die Klickposition an.
1214 | Dort wird dann ein Quadrat gezeichnet.
1215 |
1216 | Beispiel:
1217 |
1218 | 
1219 |
1220 | ---
1221 |
1222 | ### Spirale bei Klick
1223 |
1224 | Speichere *click_spiral.py*:
1225 |
1226 | ```python
1227 | # click_spiral.py
1228 | from turtle import *
1229 | from random import *
1230 |
1231 | tracer(1000, 0)
1232 |
1233 | def draw_spiral(x, y):
1234 | penup()
1235 | goto(x, y)
1236 | pendown()
1237 |
1238 | line_length = randint(50, 200)
1239 | turn_radius = randint(50, 70)
1240 | for i in range(randint(50, 200)):
1241 | forward(i)
1242 | left(turn_radius)
1243 | update()
1244 |
1245 | getscreen().onclick(draw_spiral)
1246 | done()
1247 | ```
1248 |
1249 | Ergebnis nach mehreren Klicks:
1250 |
1251 | 
1252 |
1253 | ---
1254 |
1255 | ### Rote Rosen auf schwarzem Hintergrund
1256 |
1257 | Speichere *click_rose.py*:
1258 |
1259 | ```python
1260 | # click_rose.py
1261 | from turtle import *
1262 | from random import *
1263 |
1264 | tracer(1000, 0)
1265 |
1266 | def draw_rose(x, y):
1267 | pencolor('red')
1268 | pensize(randint(2, 5))
1269 | penup()
1270 | goto(x, y)
1271 | pendown()
1272 |
1273 | for i in range(100):
1274 | pencolor((random(), 0, 0))
1275 | pensize(randint(2, 5))
1276 | forward(i)
1277 | left(randint(50, 70))
1278 | update()
1279 |
1280 | bgcolor('black')
1281 | getscreen().onclick(draw_rose)
1282 | done()
1283 | ```
1284 |
1285 | Erzeuge mit wenigen Klicks ein Rosenbild:
1286 |
1287 | 
1288 |
1289 |
1290 |
1291 | ## Kurven und Kreise zeichnen
1292 |
1293 | Das Turtle-Modul kann nur **gerade Linien** zeichnen.
1294 | Aber indem du **viele kleine Linien mit leichten Drehungen** aneinanderreihst,
1295 | kannst du **Kurven und Kreise** erzeugen.
1296 |
1297 | ---
1298 |
1299 | ### Beispiel: Kurvige Pfade
1300 |
1301 | Speichere *curve_path.py*:
1302 |
1303 | ```python
1304 | # curve_path.py
1305 | from turtle import *
1306 | from random import *
1307 |
1308 | tracer(4, 0)
1309 |
1310 | for i in range(100): # 100 kurvige Pfade
1311 | penup()
1312 | home()
1313 | pendown()
1314 |
1315 | setheading(randint(0, 360))
1316 | for j in range(randint(200, 600)):
1317 | forward(1)
1318 | left(randint(-4, 4))
1319 |
1320 | update()
1321 | done()
1322 | ```
1323 |
1324 | Ergebnis:
1325 |
1326 | 
1327 |
1328 | ---
1329 |
1330 | ### Kreise zeichnen
1331 |
1332 | Turtle hat eine `circle()`-Funktion, die intern aus 360 kurzen Linien besteht.
1333 |
1334 | Speichere *draw_circles.py*:
1335 |
1336 | ```python
1337 | # draw_circles.py
1338 | from turtle import *
1339 |
1340 | speed('fastest')
1341 |
1342 | # Obere Kreise
1343 | setheading(0)
1344 | for i in range(20):
1345 | circle(i * 10)
1346 |
1347 | # Untere Kreise
1348 | setheading(180)
1349 | for i in range(20):
1350 | circle(i * 10)
1351 |
1352 | done()
1353 | ```
1354 |
1355 | - `setheading(0)` → Kreis **nach oben**
1356 | - `setheading(180)` → Kreis **nach unten**
1357 |
1358 | Das Programm erzeugt 40 Kreise, die größer werden:
1359 |
1360 | 
1361 |
1362 | ---
1363 |
1364 | ### Viele überlappende Kreise
1365 |
1366 | Speichere *draw_many_circles.py*:
1367 |
1368 | ```python
1369 | # draw_many_circles.py
1370 | from turtle import *
1371 |
1372 | speed('fastest')
1373 |
1374 | for j in range(6):
1375 | setheading(j)
1376 | for i in range(20):
1377 | circle(i * 10)
1378 |
1379 | setheading(j + 120)
1380 | for i in range(20):
1381 | circle(i * 10)
1382 |
1383 | setheading(j + 240)
1384 | for i in range(20):
1385 | circle(i * 10)
1386 |
1387 | done()
1388 | ```
1389 |
1390 | Das erzeugt ein schönes Blumenmuster:
1391 |
1392 | 
1393 |
1394 |
1395 |
1396 | ## Blumen-Programm (Blue Flowers)
1397 |
1398 | Jetzt erstellen wir ein Programm für **generative Kunst** – das heißt:
1399 | Wir programmieren etwas, das Bilder **zufällig** erzeugt.
1400 |
1401 | Dieses Programm zeichnet **blaue Blumen** aus sechs Kreisen,
1402 | an zufälligen Positionen, Größen und Farben.
1403 |
1404 | ---
1405 |
1406 | Speichere das folgende Programm:
1407 |
1408 | ```python
1409 | from turtle import *
1410 | from random import *
1411 |
1412 | tracer(100, 0)
1413 |
1414 | for n in range(50):
1415 | penup()
1416 | x = randint(-300, 300)
1417 | y = randint(-300, 300)
1418 | goto(x, y)
1419 | pendown()
1420 |
1421 | pencolor((0, 0, random()))
1422 | pensize(randint(1, 5))
1423 | circle_size = randint(10, 40)
1424 |
1425 | for i in range(6):
1426 | circle(circle_size)
1427 | left(60)
1428 |
1429 | update()
1430 | done()
1431 | ```
1432 |
1433 | Das Programm zeichnet 50 Blumen an zufälligen Orten.
1434 | Jede Blume besteht aus sechs Kreisen.
1435 |
1436 | Ergebnis:
1437 |
1438 | 
1439 |
1440 | Du kannst das Programm mehrmals ausführen,
1441 | um jedes Mal ein neues, zufälliges Kunstwerk zu erzeugen.
1442 |
1443 |
1444 |
1445 | ## Gefüllte Formen
1446 |
1447 | Bisher haben wir nur **Linien** gezeichnet.
1448 | Aber du kannst auch **gefüllte Formen** erstellen.
1449 |
1450 | Dazu verwendest du:
1451 |
1452 | 1. `fillcolor('FARBE')` – setzt die Füllfarbe
1453 | 2. `begin_fill()` – startet den Füllbereich
1454 | 3. `...` (zeichne die Form)
1455 | 4. `end_fill()` – füllt den Bereich mit der gewählten Farbe
1456 |
1457 | ---
1458 |
1459 | ### Beispiel: Gefülltes Quadrat
1460 |
1461 | Speichere *filled_square.py*:
1462 |
1463 | ```python
1464 | # filled_square.py
1465 |
1466 | from turtle import *
1467 |
1468 | pensize(4)
1469 | fillcolor('blue')
1470 |
1471 | begin_fill()
1472 | for i in range(4):
1473 | forward(200)
1474 | left(90)
1475 | end_fill()
1476 |
1477 | done()
1478 | ```
1479 |
1480 | Ergebnis:
1481 |
1482 | 
1483 |
1484 | ---
1485 |
1486 | ### Zufällige bunte Quadrate
1487 |
1488 | Speichere *colorful_squares.py*:
1489 |
1490 | ```python
1491 | # colorful_squares.py
1492 | from turtle import *
1493 | from random import *
1494 |
1495 | pensize(4)
1496 | tracer(10, 0)
1497 |
1498 | for i in range(100):
1499 | penup()
1500 | goto(randint(-400, 200), randint(-400, 200))
1501 | pendown()
1502 |
1503 | fillcolor((random(), random(), random()))
1504 | pencolor((random(), random(), random()))
1505 |
1506 | line_length = randint(20, 200)
1507 |
1508 | begin_fill()
1509 | for j in range(4):
1510 | forward(line_length)
1511 | left(90)
1512 | end_fill()
1513 |
1514 | done()
1515 | ```
1516 |
1517 | Das Fenster zeigt dann 100 zufällige, gefüllte Quadrate:
1518 |
1519 | 
1520 |
1521 | ---
1522 |
1523 | ### Gefüllte Kurven
1524 |
1525 | Speichere *curve_path_filled.py*:
1526 |
1527 | ```python
1528 | # curve_path_filled.py
1529 | from turtle import *
1530 | from random import *
1531 |
1532 | tracer(4, 0)
1533 |
1534 | for i in range(50):
1535 | fillcolor((random(), random(), random()))
1536 | setheading(randint(0, 360))
1537 |
1538 | begin_fill()
1539 | for j in range(randint(200, 600)):
1540 | forward(1)
1541 | left(randint(-4, 4))
1542 | home()
1543 | end_fill()
1544 |
1545 | update()
1546 | done()
1547 | ```
1548 |
1549 | Das Ergebnis: zufällige bunte Formen:
1550 |
1551 | 
1552 |
1553 |
1554 |
1555 | ## Weitere Informationen
1556 |
1557 | Dieses Tutorial zeigt dir nur den Anfang.
1558 | Mit dem `turtle`-Modul kannst du noch viel mehr machen!
1559 |
1560 | Hier findest du weiterführende Informationen:
1561 |
1562 | - [Offizielle Dokumentation von turtle (Python.org)](https://docs.python.org/3/library/turtle.html)
1563 | - [Liste aller Turtle-Funktionen](https://docs.python.org/3/library/turtle.html#turtle-methods)
1564 | - [Kapitel 9 im Buch *The Recursive Book of Recursion*](https://inventwithpython.com/recursion/chapter9.html)
1565 | - [Kapitel 13 im selben Buch (Fraktale mit turtle)](https://inventwithpython.com/recursion/chapter13.html)
1566 |
1567 | ---
1568 |
1569 | Python enthält auch ein Programm mit Beispielen namens `turtledemo`.
1570 | Erstelle eine Datei mit folgendem Code:
1571 |
1572 | ```python
1573 | import turtledemo.__main__
1574 | turtledemo.__main__.main()
1575 | ```
1576 |
1577 | Du kannst aus dem Menü verschiedene Beispielprogramme auswählen und ausführen.
1578 | Der Quellcode wird ebenfalls angezeigt!
1579 |
1580 | Beispiel: das Peace-Symbol
1581 |
1582 | 
1583 |
1584 | ---
1585 |
1586 | ## Fortgeschrittene Turtle-Herausforderungen
1587 |
1588 | Wenn du eine Herausforderung suchst, versuche die Kunstwerke von
1589 | [Oscar Reutersvärd](https://de.wikipedia.org/wiki/Oscar_Reutersv%C3%A4rd) mit turtle nachzubauen.
1590 |
1591 | Viele davon findest du auf der Website [Impossible World](https://im-possible.info/english/library/index.html).
1592 |
1593 | Beispielbilder:
1594 |
1595 | 
1596 | 
1597 |
1598 | ---
1599 |
1600 | ## Lösungen
1601 |
1602 | Die Lösungen zu den Übungsaufgaben findest du im Original-Tutorial:
1603 | [https://inventwithpython.com/turtle](https://inventwithpython.com/turtle)
1604 |
1605 | Oder direkt im GitHub-Repository:
1606 | [https://github.com/asweigart/simple-turtle-tutorial-for-python](https://github.com/asweigart/simple-turtle-tutorial-for-python)
1607 |
1608 | ---
1609 |
1610 | ## Kontakt
1611 |
1612 | Wenn du Fragen hast oder beim Übersetzen helfen möchtest,
1613 | schreib eine E-Mail an [al@inventwithpython.com](mailto:al@inventwithpython.com)
1614 |
1615 |
--------------------------------------------------------------------------------
/simple_turtle_tutorial_es.md:
--------------------------------------------------------------------------------
1 | ## Tutorial de Turtle en Español
2 |
3 | (Este archivo contiene la traducción completa del tutorial de turtle.py en Markdown. Para obtener el contenido completo, por favor solicita la reconstrucción de secciones específicas o el archivo original.)
--------------------------------------------------------------------------------
/simple_turtle_tutorial_ru.md:
--------------------------------------------------------------------------------
1 | # Простой учебник по Turtle для Python
2 |
3 |
4 |
5 | ## Введение
6 |
7 | Графика Turtle — это простой способ изучать программирование с помощью рисования.
8 | Вы управляете виртуальной ручкой, называемой **черепашкой** (*turtle*), чтобы она перемещалась по экрану и рисовала линии.
9 | Вы создаёте изображения на компьютере, изучая при этом основы программирования.
10 | Можно представить себе черепашку как [игру Etch A Sketch](https://ru.wikipedia.org/wiki/Etch_A_Sketch), управляемую программой на Python.
11 |
12 | В этом учебнике объясняется, как использовать модуль `turtle` в Python.
13 | Он не обучает самому языку Python. Полезно уже знать такие понятия, как переменные, операторы, циклы, функции, импорт модулей и случайные числа.
14 | Бесплатная книга [«Автоматизация рутинных задач с помощью Python»](https://automatetheboringstuff.com/) отлично подойдёт новичкам.
15 |
16 | Перед началом убедитесь, что у вас установлен **интерпретатор Python** с сайта [python.org](https://python.org).
17 | Также понадобится редактор кода, например IDLE, [Mu](https://codewith.mu/) или [Visual Studio Code](https://code.visualstudio.com/download).
18 |
19 | Программы, написанные на Python, называются Python-программами. Не все из них используют графику turtle.
20 | Но в этом руководстве мы будем называть такие программы «Turtle-программами».
21 |
22 | Даже если вы ещё не умеете программировать, вы можете просто копировать код из этого руководства в редактор и запускать его.
23 |
24 | ## Содержание
25 |
26 | 1. [Введение](#Введение)
27 | 1. [Рисуем квадрат](#Рисуем-квадрат)
28 | 1. [Рисуем меньший квадрат](#Рисуем-меньший-квадрат)
29 | 1. [Частые ошибки и сообщения об ошибках](#Частые-ошибки-и-сообщения-об-ошибках)
30 | 1. [Рисуем квадрат с помощью цикла](#Рисуем-квадрат-с-помощью-цикла)
31 | 1. [Краткий обзор 1](#Краткий-обзор-1)
32 | 1. [Практические упражнения 1](#Практические-упражнения-1)
33 | 1. [Пишем текст в окне Turtle](#Пишем-текст-в-окне-Turtle)
34 | 1. [Углы](#Углы)
35 | 1. [Декартовы координаты XY](#Декартовы-координаты-XY)
36 | 1. [Домой, очистить, сбросить, отменить](#Домой-очистить-сбросить-отменить)
37 | 1. [Краткий обзор 2](#Краткий-обзор-2)
38 | 1. [Практические упражнения 2](#Практические-упражнения-2)
39 | 1. [Цвета](#Цвета)
40 | 1. [Поднять и опустить ручку](#Поднять-и-опустить-ручку)
41 | 1. [Примеры квадратных спиралей](#Примеры-квадратных-спиралей)
42 | 1. [Очень быстрое рисование](#Очень-быстрое-рисование)
43 | 1. [Интерактивное рисование](#Интерактивное-рисование)
44 | 1. [Рисуем кривые и окружности](#Рисуем-кривые-и-окружности)
45 | 1. [Программа «Синие цветы»](#Программа-Синие-цветы)
46 | 1. [Закрашенные фигуры](#Закрашенные-фигуры)
47 | 1. [Дополнительные ресурсы](#Дополнительные-ресурсы)
48 | 1. [Сложные задания с Turtle](#Сложные-задания-с-Turtle)
49 | 1. [Решения](#Решения)
50 | 1. [Связь с автором](#Связь-с-автором)
51 |
52 |
53 |
54 | ## Рисуем квадрат
55 |
56 | Создадим программу, которая рисует квадрат.
57 | Откройте редактор кода, создайте новый файл и сохраните его как *first_square.py*.
58 | Введите следующий код на Python:
59 |
60 | ```python
61 | # first_square.py
62 |
63 | # Это комментарий.
64 | # Всё, что идёт после символа # — это «комментарий» и не выполняется как код.
65 | # Используйте комментарии для заметок и пояснений в коде.
66 |
67 | from turtle import *
68 |
69 | pensize(4) # Сделать линии толще обычного.
70 |
71 | forward(200) # Переместить черепашку вперёд на 200 шагов.
72 | left(90) # Повернуть черепашку влево на 90 градусов.
73 |
74 | # Повторить движение вперёд и поворот ещё три раза:
75 | forward(200)
76 | left(90)
77 | forward(200)
78 | left(90)
79 | forward(200)
80 | left(90)
81 |
82 | done() # Без этой строки окно Turtle может сразу закрыться.
83 | ```
84 |
85 | Сохраните файл и запустите программу.
86 | (Если вы используете IDLE, нажмите клавишу **F5** или выберите меню **Run > Run Module**.
87 | В Visual Studio Code — **Run > Run Without Debugging**.)
88 |
89 | При запуске откроется новое окно, которое мы будем называть *окном Turtle*. В нём появится изображение:
90 |
91 | [
](https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/refs/heads/master/screenshot_first_square.jpg)
92 |
93 | В окне черепашка выглядит как треугольник.
94 | Представьте, что она рисует линию ручкой, пока движется.
95 |
96 | Программа делает следующее:
97 |
98 | 1. Движется вперёд на 200 шагов (черепашка смотрит вправо).
99 | 2. Поворачивает влево на 90°.
100 | 3. Движется вперёд на 200 шагов.
101 | 4. Поворачивает влево на 90°.
102 | 5. Повторяет ещё два раза — в итоге получается квадрат.
103 |
104 | Теперь подробнее разберём каждую инструкцию:
105 |
106 | ```python
107 | # first_square.py
108 |
109 | # Это комментарий.
110 | # Всё, что идёт после символа # — это «комментарий» и не выполняется как код.
111 | ```
112 |
113 | Строки, начинающиеся с `#`, — это **комментарии**. Python их игнорирует.
114 | Пустые строки также пропускаются.
115 |
116 | ```python
117 | from turtle import *
118 | ```
119 |
120 | **Обязательно** пишите эту строку в начале каждой turtle-программы.
121 | Она подключает модуль `turtle`, чтобы можно было использовать такие функции, как `pensize()`, `forward()`, `left()` и `done()`.
122 |
123 | Если забыть эту строку, программа выдаст ошибку `NameError`.
124 |
125 | ```python
126 | pensize(4) # Сделать линии толще.
127 | ```
128 |
129 | `pensize` — это функция, и `pensize(4)` — это её вызов.
130 | Функции могут принимать аргументы, как здесь — число 4.
131 |
132 | Мы всегда будем писать имя функции с `()` — например, `pensize()`, чтобы показать, что это функция.
133 |
134 | ```python
135 | forward(200) # Переместить черепашку вперёд на 200 шагов.
136 | left(90) # Повернуть черепашку влево на 90 градусов.
137 | ```
138 |
139 | `forward(200)` перемещает черепашку вперёд по текущему направлению и рисует линию.
140 | `left(90)` поворачивает черепашку влево (против часовой стрелки) на 90 градусов.
141 |
142 | Существует также функция `right()`, если нужно повернуть по часовой стрелке.
143 |
144 | ```python
145 | done() # Без этой строки окно Turtle может сразу закрыться.
146 | ```
147 |
148 | Функция `done()` говорит Python подождать, пока пользователь закроет окно.
149 | Без неё окно может закрыться сразу после завершения программы.
150 |
151 | Даже если у функции нет аргументов, как `done`, скобки `()` писать всё равно нужно.
152 |
153 | ---
154 |
155 | В этом уроке вы познакомились с функциями `forward()`, `left()` и `done()` из модуля `turtle`.
156 | С их помощью можно рисовать фигуры и картинки!
157 |
158 | Давайте теперь напишем ещё несколько простых программ.
159 |
160 |
161 |
162 | ## Рисуем меньший квадрат
163 |
164 | Теперь нарисуем квадрат меньшего размера.
165 | Вместо `forward(200)` используем `forward(25)`.
166 | Создайте новый файл и сохраните его как *square_smaller.py*:
167 |
168 | ```python
169 | # square_smaller.py
170 | from turtle import *
171 |
172 | pensize(4)
173 | forward(25) # Теперь черепашка движется только на 25 шагов.
174 | left(90)
175 | forward(25)
176 | left(90)
177 | forward(25)
178 | left(90)
179 | forward(25)
180 | left(90)
181 | done()
182 | ```
183 |
184 | Программа рисует меньший квадрат, потому что каждая сторона короче:
185 |
186 | [
](https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/refs/heads/master/screenshot_square_smaller.jpg)
187 |
188 | **Важно:** необходимо изменить **все четыре** строки с `forward(200)` на `forward(25)`.
189 | Если вы забудете хотя бы одну, квадрат получится неправильным.
190 |
191 | Вот пример с ошибкой — программа *square_smaller_bug.py*:
192 |
193 | ```python
194 | # square_smaller_bug.py
195 | from turtle import *
196 |
197 | pensize(4)
198 | forward(25)
199 | left(90)
200 | forward(25)
201 | left(90)
202 | forward(200) # Ой! Здесь забыли изменить!
203 | left(90)
204 | forward(25)
205 | left(90)
206 | done()
207 | ```
208 |
209 | Программа содержит **ошибку (баг)** и рисует неправильную фигуру:
210 |
211 | [
](https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/refs/heads/master/screenshot_square_smaller_bug.jpg)
212 |
213 | Ошибаться — это нормально! Просто внимательно проверьте код.
214 | Компьютер делает **ровно то**, что вы ему сказали — не больше и не меньше.
215 | Важно убедиться, что ваши **намерения** совпадают с тем, что **делает программа**.
216 |
217 |
218 |
219 | ## Частые ошибки и сообщения об ошибках
220 |
221 | При написании программ вы можете столкнуться с ошибками.
222 | Обратите внимание на **текст ошибки** и **номер строки**, где она произошла.
223 |
224 | Вот самые распространённые ошибки и причины их появления:
225 |
226 | - **`ModuleNotFoundError: No module named 'trutle'`** — опечатка в названии модуля. Например, `from trutle import *` вместо `turtle`.
227 |
228 | - **`NameError: name 'froward' is not defined`** — опечатка в имени функции или переменной. Например, `froward(100)` вместо `forward(100)`.
229 |
230 | - **`TypeError: forward() missing 1 required positional argument: 'distance'`** — вызов функции без нужного аргумента. Например, `forward()` без числа.
231 |
232 | - **`TypeError: left() takes 1 positional argument but 2 were given`** — передано слишком много аргументов. Например, `left(90, 45)`.
233 |
234 | - **`IndentationError: unexpected indent`** — слишком много пробелов в начале строки.
235 |
236 | - **`IndentationError: expected an indented block after 'for' statement on line 5`** — отсутствует отступ после строки с циклом, например: `for i in range(4):`.
237 |
238 | - **`SyntaxError: invalid syntax`** — общая ошибка синтаксиса. Python не может понять, что вы имели в виду.
239 |
240 | Иногда ошибка указывается на одной строке,
241 | но **причина** ошибки может быть в предыдущей строке!
242 |
243 | Внимательно читайте сообщение об ошибке.
244 | Оно подсказывает, **в чём проблема** и **где искать**.
245 |
246 |
247 |
248 | ## Рисуем квадрат с помощью цикла
249 |
250 | Теперь нарисуем квадрат, используя **цикл `for`**.
251 | Создайте новый файл и сохраните его как *square_for_loop.py*.
252 | Введите следующий код:
253 |
254 | ```python
255 | # square_for_loop.py
256 | from turtle import *
257 |
258 | pensize(4)
259 |
260 | # Вложенные строки выполняются 4 раза:
261 | for i in range(4):
262 | forward(200)
263 | left(90)
264 | done()
265 | ```
266 |
267 | Строки внутри цикла `for i in range(4):` выполняются **4 раза**.
268 | Это означает, что черепашка пройдёт 4 стороны квадрата.
269 |
270 | Убедитесь, что отступ **точно 4 пробела** перед строками `forward(...)` и `left(...)`.
271 | Если отступы неправильные, появится ошибка `IndentationError`.
272 |
273 | Пример отступов, помеченных точками:
274 |
275 | ```
276 | for i in range(4):
277 | ....forward(200)
278 | ....left(90)
279 | done()
280 | ```
281 |
282 | Программа нарисует квадрат:
283 |
284 | 
285 |
286 | ---
287 |
288 | Теперь изменим угол поворота.
289 | Сохраните новую версию программы как *square_for_loop_86.py*:
290 |
291 | ```python
292 | # square_for_loop_86.py
293 | from turtle import *
294 |
295 | pensize(4)
296 |
297 | for i in range(4):
298 | forward(200)
299 | left(86) # Повернуть на 86°, а не 90
300 | done()
301 | ```
302 |
303 | Это создаст немного «искривлённый» квадрат:
304 |
305 | 
306 |
307 | ---
308 |
309 | Теперь увеличим количество повторений до **50**, чтобы получилась окружность.
310 |
311 | Сохраните файл как *square_circle_86.py*:
312 |
313 | ```python
314 | # square_circle_86.py
315 | from turtle import *
316 |
317 | pensize(4)
318 | speed('fastest')
319 |
320 | for i in range(50): # Повторить 50 раз
321 | forward(200)
322 | left(86)
323 | hideturtle()
324 | done()
325 | ```
326 |
327 | Здесь мы также добавили `speed('fastest')`, чтобы ускорить рисование.
328 |
329 | `hideturtle()` скрывает треугольник-курсор в конце.
330 |
331 | Результат:
332 |
333 | 
334 |
335 | ---
336 |
337 | Можно сделать рисунок **случайным**, используя `randint()` из модуля `random`.
338 |
339 | Сохраните файл как *square_random.py*:
340 |
341 | ```python
342 | # square_random.py
343 | from turtle import *
344 | from random import *
345 |
346 | pensize(4)
347 | speed('fastest')
348 |
349 | for i in range(50):
350 | forward(200)
351 | # Случайный поворот от 80 до 100 градусов:
352 | left(randint(80, 100))
353 | hideturtle()
354 | done()
355 | ```
356 |
357 | Каждый запуск даёт **разный результат**:
358 |
359 | 
360 | 
361 |
362 | Функция `randint(80, 100)` возвращает случайное целое число от 80 до 100.
363 |
364 | Такие программы создают **генеративное искусство** —
365 | вы пишете код, а компьютер создаёт изображения!
366 |
367 |
368 |
369 | ## Краткий обзор 1
370 |
371 | Вот что мы узнали до сих пор:
372 |
373 | - Комментарии начинаются с символа `#`:
374 |
375 | ```python
376 | # Это комментарий
377 | ```
378 |
379 | Комментарии не влияют на выполнение кода.
380 |
381 | ---
382 |
383 | - Подключаем модуль `turtle`:
384 |
385 | ```python
386 | from turtle import *
387 | ```
388 |
389 | ---
390 |
391 | - Черепашка может двигаться:
392 |
393 | ```python
394 | forward(100) # Вперёд на 100 шагов
395 | backward(100) # Назад на 100 шагов
396 | ```
397 |
398 | ---
399 |
400 | - Можно поворачивать:
401 |
402 | ```python
403 | left(90) # Влево на 90°
404 | right(45) # Вправо на 45°
405 | ```
406 |
407 | Отрицательные числа поворачивают в противоположную сторону.
408 |
409 | ---
410 |
411 | - Устанавливаем толщину линии:
412 |
413 | ```python
414 | pensize(4)
415 | ```
416 |
417 | ---
418 |
419 | - Чтобы окно не закрывалось сразу:
420 |
421 | ```python
422 | done()
423 | ```
424 |
425 | ---
426 |
427 | - Переменные хранят значения:
428 |
429 | ```python
430 | line_length = 25
431 | forward(line_length)
432 | ```
433 |
434 | ---
435 |
436 | - Используем цикл `for`:
437 |
438 | ```python
439 | for i in range(4):
440 | forward(200)
441 | left(90)
442 | ```
443 |
444 | ---
445 |
446 | - Ускоряем черепашку:
447 |
448 | ```python
449 | speed('fastest')
450 | ```
451 |
452 | ---
453 |
454 | - Скрываем черепашку:
455 |
456 | ```python
457 | hideturtle()
458 | ```
459 |
460 | ---
461 |
462 | - Случайные числа:
463 |
464 | ```python
465 | from random import *
466 | left(randint(80, 100))
467 | ```
468 |
469 | ---
470 |
471 | ## Практические упражнения 1
472 |
473 | Попробуйте нарисовать эти фигуры.
474 | Подсказки даны в описаниях. Решения — в конце учебника.
475 |
476 | ---
477 |
478 | **Равносторонний треугольник**
479 | Все стороны — 200 шагов, повороты: сначала 60°, затем 120°:
480 |
481 | 
482 |
483 | ---
484 |
485 | **Пятиугольник**
486 | 5 сторон по 200 шагов. Каждый поворот — 72°:
487 |
488 | 
489 |
490 | ---
491 |
492 | **Шестиугольник**
493 | 6 сторон по 200 шагов. Повороты — 60°:
494 |
495 | 
496 |
497 | ---
498 |
499 | **Восьмиугольник**
500 | 8 сторон по 100 шагов. Повороты — 45°:
501 |
502 | 
503 |
504 | ---
505 |
506 | **Прямоугольный треугольник**
507 | Стороны: 200, 200 и 282.8 шагов. Повороты: 90° и 135°:
508 |
509 | 
510 |
511 | ---
512 |
513 | **Звезда**
514 | 5 линий по 200 шагов. Повороты — 144°:
515 |
516 | 
517 |
518 | ---
519 |
520 | **Вложенные квадраты**
521 | Квадраты со сторонами: 100, 150, 200, 250, 300. Можно использовать вложенные циклы:
522 |
523 | 
524 |
525 | ---
526 |
527 | **Крест**
528 | Все линии по 100 шагов. Повороты 90°, включая left и right:
529 |
530 | 
531 |
532 | ---
533 |
534 | **Куб**
535 | Стороны — по 100 шагов. Повороты — 45°, 90°, 135°. Можно накладывать линии:
536 |
537 | 
538 |
539 | ---
540 |
541 | **Трифорс**
542 | Треугольники с поворотами 60° и 120°. Некоторые перемещения — на 50 шагов:
543 |
544 | 
545 |
546 |
547 |
548 | ## Пишем текст в окне Turtle
549 |
550 | Черепашка может писать **текст** в окне, как и рисовать линии.
551 | Для этого используется функция `write()` — она принимает строку текста и пишет её на экране в текущем положении черепашки.
552 |
553 | Создайте файл *write_hello.py* и введите следующий код:
554 |
555 | ```python
556 | # write_hello.py
557 | from turtle import *
558 |
559 | write('Hello, world!')
560 | forward(80)
561 | right(45)
562 | forward(50)
563 | write('123456789', font=('Arial', 48, 'normal'))
564 | right(45)
565 | forward(30)
566 | write('oOoOoOoOoOo')
567 | done()
568 | ```
569 |
570 | ---
571 |
572 | Когда вы запускаете эту программу, черепашка пишет текст в окне:
573 |
574 | 
575 |
576 | ---
577 |
578 | Левая нижняя точка текста будет в том месте, где находится черепашка при вызове `write()`.
579 |
580 | Пример:
581 |
582 | ```python
583 | write('Hello, world!')
584 | ```
585 |
586 | Черепашка пишет текст, затем перемещается вперёд и снова пишет.
587 |
588 | ---
589 |
590 | ### Шрифт и стиль
591 |
592 | Вы можете указать параметры шрифта с помощью аргумента `font=`:
593 |
594 | ```python
595 | write('123456789', font=('Arial', 48, 'normal'))
596 | ```
597 |
598 | Значение `font=` — это кортеж из 3 элементов:
599 |
600 | 1. Название шрифта: `'Arial'`
601 | 2. Размер шрифта: `48` (число, не строка!)
602 | 3. Стиль шрифта: `'normal'`, `'bold'`, `'italic'`, `'underline'`, или комбинация (например, `'bold italic'`)
603 |
604 | ---
605 |
606 | Если `font=` не указан, по умолчанию используется `('Arial', 8, 'normal')`.
607 |
608 | Убедитесь, что указанный шрифт установлен на вашем компьютере.
609 |
610 |
611 |
612 | ## Углы
613 |
614 | В Turtle-программах расстояние измеряется в **шагах**.
615 | Например, `forward(100)` перемещает черепашку на 100 шагов.
616 |
617 | Но направление и повороты можно измерять в **градусах**.
618 |
619 | ---
620 |
621 | ### Представьте вид сверху
622 |
623 | Представьте, что вы смотрите сверху вниз на черепашку.
624 |
625 | - Если она поворачивает **вправо** — это **по часовой стрелке**
626 | - Если она поворачивает **влево** — это **против часовой стрелки**
627 |
628 | ---
629 |
630 | ### Углы поворота
631 |
632 | - **Полный круг** — это 360°
633 | - Поворот на 180° меняет направление на противоположное
634 | - Поворот на 90° — это «обычный» прямой угол
635 | - Четыре поворота по 90° возвращают черепашку в исходное направление
636 |
637 | ```python
638 | left(90)
639 | left(90)
640 | left(90)
641 | left(90) # Теперь черепашка смотрит туда же, куда изначально
642 | ```
643 |
644 | ---
645 |
646 | ### Направление (heading)
647 |
648 | Python отслеживает **направление**, куда «смотрит» черепашка:
649 |
650 | - 0° — вправо
651 | - 90° — вверх
652 | - 180° — влево
653 | - 270° — вниз
654 | - 360° = 0° — тоже вправо
655 |
656 | ---
657 |
658 | Функция `heading()` возвращает текущее направление черепашки.
659 |
660 | ---
661 |
662 | Пример. Создайте файл *turtle_directions.py*:
663 |
664 | ```python
665 | # turtle_directions.py
666 | from turtle import *
667 |
668 | for i in range(24):
669 | forward(100) # Движение вперёд
670 | write(heading(), font=('Arial', 20, 'normal')) # Написать текущее направление
671 | backward(100) # Вернуться в центр
672 | left(15) # Повернуть на 15°
673 | done()
674 | ```
675 |
676 | 
677 |
678 | ---
679 |
680 | Функция `left()` и `right()` поворачивают **относительно текущего направления**.
681 |
682 | Но функция `setheading()` устанавливает **абсолютное направление**.
683 |
684 | ---
685 |
686 | Пример. Файл *setheading_turtle.py*:
687 |
688 | ```python
689 | # setheading_turtle.py
690 | from turtle import *
691 | from random import *
692 |
693 | pensize(4)
694 | left(randint(0, 360))
695 | write(heading())
696 | forward(200)
697 |
698 | setheading(45)
699 | write(heading())
700 | forward(200)
701 |
702 | done()
703 | ```
704 |
705 | ---
706 |
707 | Черепашка поворачивает случайно, пишет текущее направление,
708 | а потом `setheading(45)` устанавливает направление на 45° (вверх-вправо).
709 | На экране отображается `"45.0"`.
710 |
711 | Каждый запуск будет начинаться по-разному, но потом всегда направляется под 45°:
712 |
713 | 
714 |
715 |
716 |
717 | ## Декартовы координаты XY
718 |
719 | Как градусы описывают направление, так **координаты XY** описывают положение черепашки на экране.
720 |
721 | ---
722 |
723 | В системе координат:
724 |
725 | - **X** — как далеко черепашка находится **влево или вправо**
726 | - **Y** — как далеко она **вверх или вниз**
727 |
728 | ---
729 |
730 | ### Правила координат:
731 |
732 | - Центр окна — это **начало координат**: `(0, 0)`
733 | - X увеличивается вправо и уменьшается влево
734 | - Y увеличивается вверх и уменьшается вниз
735 | - Левая половина окна — отрицательный X
736 | - Правая половина — положительный X
737 | - Нижняя часть окна — отрицательный Y
738 | - Верхняя часть — положительный Y
739 |
740 | ---
741 |
742 | Вот пример из Википедии:
743 |
744 | 
745 |
746 | ---
747 |
748 | ### position()
749 |
750 | Функция `position()` возвращает координаты текущего положения черепашки.
751 |
752 | Создайте файл *random_position.py*:
753 |
754 | ```python
755 | # random_position.py
756 | from turtle import *
757 | from random import *
758 |
759 | for i in range(8):
760 | write(position())
761 | left(randint(0, 90))
762 | forward(100)
763 |
764 | done()
765 | ```
766 |
767 | 
768 |
769 | ---
770 |
771 | ### goto(x, y)
772 |
773 | Функция `goto()` перемещает черепашку в заданную точку (X, Y).
774 |
775 | ---
776 |
777 | Пример. Файл *random_goto.py*:
778 |
779 | ```python
780 | # random_goto.py
781 | from turtle import *
782 | from random import *
783 |
784 | pensize(4)
785 |
786 | for i in range(6):
787 | x = randint(-400, 400)
788 | y = randint(-400, 400)
789 | goto(x, y)
790 | write(position(), font=('Arial', 18, 'normal'))
791 |
792 | done()
793 | ```
794 |
795 | ---
796 |
797 | Каждый раз координаты случайны. Результаты могут выглядеть так:
798 |
799 | 
800 | 
801 |
802 | ---
803 |
804 | Перемещение с помощью `goto(x, y)` не зависит от текущего направления.
805 |
806 |
807 |
808 | ## Домой, очистить, сбросить, отменить
809 |
810 | Когда черепашка движется, она оставляет за собой линии.
811 | С помощью следующих функций можно **очистить** или **отменить** действия:
812 |
813 | ---
814 |
815 | ### home()
816 |
817 | Возвращает черепашку в центр окна — координаты `(0, 0)` —
818 | и устанавливает направление на 0° (вправо).
819 |
820 | То же самое, что:
821 |
822 | ```python
823 | goto(0, 0)
824 | setheading(0)
825 | ```
826 |
827 | ---
828 |
829 | ### clear()
830 |
831 | Удаляет **все нарисованные линии**, но оставляет черепашку на месте.
832 |
833 | ---
834 |
835 | ### reset()
836 |
837 | Удаляет всё (как `clear()`),
838 | и возвращает черепашку в центр (как `home()`).
839 |
840 | ---
841 |
842 | ### undo()
843 |
844 | Отменяет **последнее действие** черепашки (например, линию).
845 |
846 | Можно вызывать `undo()` несколько раз подряд, чтобы поэтапно отменить рисование.
847 |
848 | ---
849 |
850 | Пример использования всех команд:
851 |
852 | ```python
853 | from turtle import *
854 |
855 | forward(100)
856 | left(90)
857 | forward(100)
858 | undo()
859 | undo()
860 | clear()
861 | reset()
862 | done()
863 | ```
864 |
865 |
866 |
867 | ## Краткий обзор 2
868 |
869 | Вот что мы узнали в последних разделах:
870 |
871 | ---
872 |
873 | ```python
874 | write('Hello, world!')
875 | write('Привет!', font=('Arial', 48, 'bold italic'))
876 | ```
877 |
878 | - Функция `write()` выводит текст в текущем положении черепашки.
879 | - Аргумент `font=` задаёт шрифт, размер и стиль (например, `'bold'`, `'italic'`).
880 |
881 | ---
882 |
883 | ```python
884 | setheading(90)
885 | current_heading = heading()
886 | ```
887 |
888 | - `setheading(угол)` задаёт **направление** черепашки в градусах.
889 | - `heading()` возвращает текущий угол направления.
890 |
891 | ---
892 |
893 | ```python
894 | goto(250, -100)
895 | ```
896 |
897 | - `goto(x, y)` перемещает черепашку в указанные координаты.
898 | - Центр окна: `(0, 0)` — это **начало координат**.
899 | - X увеличивается вправо, уменьшается влево.
900 | - Y увеличивается вверх, уменьшается вниз.
901 |
902 | ---
903 |
904 | ```python
905 | home()
906 | clear()
907 | reset()
908 | undo()
909 | ```
910 |
911 | - `home()` возвращает в центр и направляет вправо.
912 | - `clear()` удаляет всё, не меняя положение.
913 | - `reset()` = `clear()` + `home()`.
914 | - `undo()` отменяет последнее действие.
915 |
916 |
917 |
918 | ## Практические упражнения 2
919 |
920 | Попробуйте написать программы, которые рисуют следующие изображения.
921 | Подсказки даны ниже. Решения находятся в конце учебника.
922 |
923 | ---
924 |
925 | ### Звезда по координатам
926 |
927 | Создайте программу *solution_star_outline.py*.
928 | Используйте только `goto()` для рисования.
929 | Координаты точек:
930 |
931 | ```
932 | (0, 300), (70, 95), (285, 95), (110, -35), (175, -260),
933 | (0, -100), (-175, -260), (-110, -35), (-285, 95), (-70, 95), (0, 300)
934 | ```
935 |
936 | 
937 |
938 | ---
939 |
940 | ### Крест с setheading()
941 |
942 | Создайте *solution_cross_setheading.py*.
943 | Используйте только `setheading()`, а не `left()` или `right()`.
944 |
945 | Подсказка: все линии по 100 шагов, направления — 0, 90, 180, 270.
946 |
947 | 
948 |
949 | ---
950 |
951 | ### Случайный текст
952 |
953 | Создайте *solution_random_hello.py*.
954 | Черепашка должна написать «Hello, world!» 100 раз в случайных местах.
955 | Шрифт — случайного размера от 12 до 48.
956 | Не рисовать линии, скрыть черепашку.
957 |
958 | 
959 |
960 |
961 |
962 | ## Цвета
963 |
964 | Вы можете изменить:
965 |
966 | - **Цвет фона окна** с помощью `bgcolor()`
967 | - **Цвет линий черепашки** с помощью `pencolor()`
968 |
969 | ---
970 |
971 | ### Примеры стандартных цветов:
972 |
973 | ```python
974 | bgcolor('black') # чёрный
975 | pencolor('blue') # синий
976 | pencolor('orange') # оранжевый
977 | pencolor('purple') # фиолетовый
978 | ```
979 |
980 | ---
981 |
982 | Вот таблица соответствий цветов и их RGB-значений:
983 |
984 | | Цвет | RGB |
985 | |------------|--------------------------|
986 | | `'black'` | `(0.0, 0.0, 0.0)` |
987 | | `'white'` | `(1.0, 1.0, 1.0)` |
988 | | `'red'` | `(1.0, 0.0, 0.0)` |
989 | | `'green'` | `(0.0, 1.0, 0.0)` |
990 | | `'blue'` | `(0.0, 0.0, 1.0)` |
991 | | `'yellow'` | `(1.0, 1.0, 0.0)` |
992 | | `'cyan'` | `(0.0, 1.0, 1.0)` |
993 | | `'pink'` | `(1.0, 0.75, 0.8)` |
994 | | `'gray'` | `(0.5, 0.5, 0.5)` |
995 | | `'violet'` | `(0.56, 0.0, 1.0)` |
996 |
997 | ---
998 |
999 | Цвета можно задавать как **текстовые строки** или **кортежи RGB**.
1000 |
1001 | ---
1002 |
1003 | ### Пример
1004 |
1005 | Изменим фон и цвет линий в *square_circle_86.py*:
1006 |
1007 | ```python
1008 | bgcolor('yellow')
1009 | pencolor('blue')
1010 | ```
1011 |
1012 | Результат:
1013 |
1014 | 
1015 |
1016 | ---
1017 |
1018 | ### RGB цвета
1019 |
1020 | Формат RGB использует **красный**, **зелёный** и **синий** компоненты —
1021 | значения от `0.0` (отсутствие) до `1.0` (максимум).
1022 |
1023 | - `(1.0, 0.0, 0.0)` — чисто красный
1024 | - `(0.0, 0.0, 0.0)` — чёрный
1025 | - `(1.0, 1.0, 1.0)` — белый
1026 | - `(1.0, 1.0, 0.0)` — жёлтый
1027 |
1028 | ---
1029 |
1030 | Чтобы подобрать цвет, используйте приложение **turtlecolors**.
1031 |
1032 | Скопируйте содержимое:
1033 | [https://raw.githubusercontent.com/asweigart/turtlecolors/refs/heads/main/src/turtlecolors/__init__.py](https://raw.githubusercontent.com/asweigart/turtlecolors/refs/heads/main/src/turtlecolors/__init__.py)
1034 | в файл *turtlecolors.py* и запустите.
1035 |
1036 | Вы увидите окно с ползунками RGB и полученным цветом.
1037 |
1038 | ---
1039 |
1040 | Пример:
1041 |
1042 | 
1043 |
1044 |
1045 |
1046 | ## Поднятие и опускание пера
1047 |
1048 | Представьте, что черепашка держит ручку.
1049 | Когда ручка **прижата к земле**, она рисует.
1050 | Когда ручка **поднята**, черепашка движется, но **не оставляет следа**.
1051 |
1052 | ---
1053 |
1054 | Используйте следующие функции:
1055 |
1056 | ```python
1057 | pendown() # опустить перо (включить рисование)
1058 | penup() # поднять перо (отключить рисование)
1059 | ```
1060 |
1061 | ---
1062 |
1063 | Черепашка по умолчанию начинает с **опущенным** пером.
1064 |
1065 | ---
1066 |
1067 | ### Пример: пунктирные линии
1068 |
1069 | Создайте файл *dashed_lines.py*:
1070 |
1071 | ```python
1072 | # dashed_lines.py
1073 | from turtle import *
1074 | from random import *
1075 |
1076 | pensize(4)
1077 | speed('fastest')
1078 |
1079 | for i in range(12):
1080 | setheading(randint(0, 360)) # случайное направление
1081 |
1082 | for j in range(6): # нарисовать 6 штрихов
1083 | pendown()
1084 | forward(10)
1085 | penup()
1086 | forward(10)
1087 |
1088 | pendown()
1089 | forward(10) # последний штрих
1090 |
1091 | done()
1092 | ```
1093 |
1094 | ---
1095 |
1096 | Каждый запуск будет разным:
1097 |
1098 | 
1099 | 
1100 |
1101 | ---
1102 |
1103 | Такой приём можно использовать для пунктирных, прерывистых и составных линий.
1104 |
1105 |
1106 |
1107 | ## Примеры квадратных спиралей
1108 |
1109 | Создадим программу, которая рисует квадратную спираль.
1110 | Создайте файл *spiral.py* и введите следующий код:
1111 |
1112 | ```python
1113 | # spiral.py
1114 | from turtle import *
1115 |
1116 | speed('fastest')
1117 | for i in range(300):
1118 | forward(i) # перемещение на i шагов
1119 | left(91)
1120 | hideturtle()
1121 | done()
1122 | ```
1123 |
1124 | ---
1125 |
1126 | Результат:
1127 |
1128 | 
1129 |
1130 | ---
1131 |
1132 | Здесь переменная `i` увеличивается от 0 до 299.
1133 | Каждая итерация делает линию длиннее, создавая спираль.
1134 |
1135 | ---
1136 |
1137 | Теперь добавим случайный цвет каждой линии.
1138 |
1139 | Создайте *spiral_black_bg.py*:
1140 |
1141 | ```python
1142 | # spiral_black_bg.py
1143 | from turtle import *
1144 | from random import *
1145 |
1146 | colors = ['red', 'orange', 'yellow', 'blue', 'green', 'purple']
1147 |
1148 | speed('fastest')
1149 | pensize(3)
1150 | bgcolor('black')
1151 | for i in range(300):
1152 | pencolor(choice(colors))
1153 | forward(i)
1154 | left(91)
1155 | hideturtle()
1156 | done()
1157 | ```
1158 |
1159 | ---
1160 |
1161 | 
1162 |
1163 | ---
1164 |
1165 | Теперь нарисуем **радугу**.
1166 | Создайте *spiral_rainbow.py*:
1167 |
1168 | ```python
1169 | # spiral_rainbow.py
1170 | from turtle import *
1171 |
1172 | speed('fastest')
1173 | pensize(3)
1174 | bgcolor('black')
1175 |
1176 | pencolor('red')
1177 | for i in range(60):
1178 | forward(i)
1179 | left(91)
1180 |
1181 | pencolor('orange')
1182 | for i in range(60):
1183 | forward(60 + i)
1184 | left(91)
1185 |
1186 | pencolor('yellow')
1187 | for i in range(60):
1188 | forward(120 + i)
1189 | left(91)
1190 |
1191 | pencolor('green')
1192 | for i in range(60):
1193 | forward(180 + i)
1194 | left(91)
1195 |
1196 | pencolor('blue')
1197 | for i in range(60):
1198 | forward(240 + i)
1199 | left(91)
1200 |
1201 | pencolor('purple')
1202 | for i in range(60):
1203 | forward(300 + i)
1204 | left(91)
1205 |
1206 | done()
1207 | ```
1208 |
1209 | ---
1210 |
1211 | Результат:
1212 |
1213 | 
1214 |
1215 | ---
1216 |
1217 | Каждый цвет рисуется своим циклом, начиная с определённой длины.
1218 |
1219 |
1220 |
1221 | ## Очень быстрое рисование
1222 |
1223 | Иногда `speed('fastest')` недостаточно.
1224 | Можно использовать `tracer()` и `update()` для **очень быстрого** рисования.
1225 |
1226 | ---
1227 |
1228 | ### tracer(n, delay)
1229 |
1230 | - `tracer(n, 0)` — обновлять экран **каждые n шагов**
1231 | - Чем больше `n`, тем быстрее работает программа
1232 |
1233 | ---
1234 |
1235 | ### update()
1236 |
1237 | После вызова `tracer()`, экран **не обновляется автоматически**.
1238 | Вы должны вызвать `update()`, когда всё нарисовано.
1239 |
1240 | ---
1241 |
1242 | Пример: создадим *random_tracer.py*:
1243 |
1244 | ```python
1245 | # random_tracer.py
1246 | from turtle import *
1247 | from random import *
1248 |
1249 | tracer(10, 0)
1250 |
1251 | for i in range(1000):
1252 | goto(randint(-400, 400), randint(-400, 400))
1253 |
1254 | update()
1255 | done()
1256 | ```
1257 |
1258 | ---
1259 |
1260 | При `tracer(10, 0)` рисование занимает несколько секунд.
1261 |
1262 | При `tracer(1000, 0)` — почти мгновенно.
1263 |
1264 | ---
1265 |
1266 | Если в окне ничего не видно, вы, возможно, забыли вызвать `update()`.
1267 |
1268 | ---
1269 |
1270 | ### Когда использовать
1271 |
1272 | - При рисовании **тысяч линий**
1273 | - При генеративном искусстве
1274 | - При отладке программ с большим количеством рисования
1275 |
1276 |
1277 |
1278 | ## Интерактивное рисование
1279 |
1280 | С помощью Python можно создавать **интерактивные рисунки**.
1281 |
1282 | Функция `getscreen().onclick()` позволяет вызывать вашу функцию при **щелчке мышью**.
1283 |
1284 | ---
1285 |
1286 | ### Пример: квадраты по клику
1287 |
1288 | Создайте *click_square.py*:
1289 |
1290 | ```python
1291 | # click_square.py
1292 | from turtle import *
1293 |
1294 | speed('fastest')
1295 |
1296 | def draw_square(x, y):
1297 | penup()
1298 | goto(x, y)
1299 | pendown()
1300 |
1301 | for i in range(4):
1302 | forward(100)
1303 | left(90)
1304 |
1305 | getscreen().onclick(draw_square) # без скобок!
1306 | done()
1307 | ```
1308 |
1309 | ---
1310 |
1311 | Щелкая в разных местах окна, вы будете рисовать квадраты:
1312 |
1313 | 
1314 |
1315 | ---
1316 |
1317 | ### Пример: спирали по клику
1318 |
1319 | Создайте *click_spiral.py*:
1320 |
1321 | ```python
1322 | # click_spiral.py
1323 | from turtle import *
1324 | from random import *
1325 |
1326 | tracer(1000, 0)
1327 |
1328 | def draw_spiral(x, y):
1329 | penup()
1330 | goto(x, y)
1331 | pendown()
1332 |
1333 | line_length = randint(50, 200)
1334 | turn_radius = randint(50, 70)
1335 | for i in range(randint(50, 200)):
1336 | forward(i)
1337 | left(turn_radius)
1338 | update()
1339 |
1340 | getscreen().onclick(draw_spiral)
1341 | done()
1342 | ```
1343 |
1344 | ---
1345 |
1346 | После нескольких щелчков вы получите:
1347 |
1348 | 
1349 |
1350 | ---
1351 |
1352 | ### Пример: красные розы
1353 |
1354 | Создайте *click_rose.py*:
1355 |
1356 | ```python
1357 | # click_rose.py
1358 | from turtle import *
1359 | from random import *
1360 |
1361 | tracer(1000, 0)
1362 |
1363 | def draw_rose(x, y):
1364 | pencolor('red')
1365 | pensize(randint(2, 5))
1366 |
1367 | penup()
1368 | goto(x, y)
1369 | pendown()
1370 |
1371 | for i in range(100):
1372 | pencolor((random(), 0, 0)) # оттенок красного
1373 | pensize(randint(2, 5))
1374 | forward(i)
1375 | left(randint(50, 70))
1376 | update()
1377 |
1378 | bgcolor('black')
1379 | getscreen().onclick(draw_rose)
1380 |
1381 | done()
1382 | ```
1383 |
1384 | ---
1385 |
1386 | Результат:
1387 |
1388 | 
1389 |
1390 | ---
1391 |
1392 | Теперь вы можете создавать генеративное искусство по щелчку мышью!
1393 |
1394 |
1395 |
1396 | ## Рисуем дуги и круги
1397 |
1398 | Модуль turtle не может рисовать настоящие кривые,
1399 | но можно создать **иллюзию кривизны**, рисуя **много маленьких отрезков**.
1400 |
1401 | ---
1402 |
1403 | ### Пример: изогнутые линии
1404 |
1405 | Создайте файл *curve_path.py*:
1406 |
1407 | ```python
1408 | # curve_path.py
1409 | from turtle import *
1410 | from random import *
1411 |
1412 | tracer(4, 0)
1413 |
1414 | for i in range(100):
1415 | penup()
1416 | home()
1417 | pendown()
1418 |
1419 | setheading(randint(0, 360))
1420 | for j in range(randint(200, 600)):
1421 | forward(1)
1422 | left(randint(-4, 4))
1423 |
1424 | update()
1425 | done()
1426 | ```
1427 |
1428 | ---
1429 |
1430 | Результат:
1431 |
1432 | 
1433 |
1434 | ---
1435 |
1436 | Кривая — это просто **много маленьких прямых**, повернутых под разными углами.
1437 |
1438 | ---
1439 |
1440 | ### Круги
1441 |
1442 | В turtle есть функция `circle(radius)`, которая рисует **многоугольник с 360 сторонами**,
1443 | что выглядит как круг.
1444 |
1445 | ---
1446 |
1447 | Создайте файл *draw_circles.py*:
1448 |
1449 | ```python
1450 | # draw_circles.py
1451 | from turtle import *
1452 |
1453 | speed('fastest')
1454 |
1455 | setheading(0) # вверх
1456 | for i in range(20):
1457 | circle(i * 10)
1458 |
1459 | setheading(180) # вниз
1460 | for i in range(20):
1461 | circle(i * 10)
1462 |
1463 | done()
1464 | ```
1465 |
1466 | ---
1467 |
1468 | 
1469 |
1470 | ---
1471 |
1472 | Когда черепашка смотрит вправо (`0`), круг рисуется вверх.
1473 | Когда влево (`180`) — вниз.
1474 |
1475 | ---
1476 |
1477 | `circle(i * 10)` рисует круги с радиусом `0`, `10`, `20`, ..., `190`.
1478 |
1479 | ---
1480 |
1481 | ### Много кругов
1482 |
1483 | Создайте *draw_many_circles.py*:
1484 |
1485 | ```python
1486 | # draw_many_circles.py
1487 | from turtle import *
1488 |
1489 | speed('fastest')
1490 |
1491 | for j in range(6):
1492 | setheading(j)
1493 | for i in range(20):
1494 | circle(i * 10)
1495 |
1496 | setheading(j + 120)
1497 | for i in range(20):
1498 | circle(i * 10)
1499 |
1500 | setheading(j + 240)
1501 | for i in range(20):
1502 | circle(i * 10)
1503 |
1504 | done()
1505 | ```
1506 |
1507 | ---
1508 |
1509 | Результат:
1510 |
1511 | 
1512 |
1513 | ---
1514 |
1515 | Измените параметры и наблюдайте, как меняется рисунок.
1516 | При необходимости замените `speed('fastest')` на `tracer(1000, 0)` и добавьте `update()`.
1517 |
1518 |
1519 |
1520 | ## Программа «Синие цветы»
1521 |
1522 | Давайте создадим программу генеративного искусства:
1523 | она рисует синие цветы из шести кругов случайного размера, цвета и толщины пера.
1524 |
1525 | ---
1526 |
1527 | Создайте файл *blue_flowers.py*:
1528 |
1529 | ```python
1530 | from turtle import *
1531 | from random import *
1532 |
1533 | tracer(100, 0)
1534 |
1535 | for n in range(50):
1536 | # Переместиться в случайную точку:
1537 | penup()
1538 | x = randint(-300, 300)
1539 | y = randint(-300, 300)
1540 | goto(x, y)
1541 | pendown()
1542 |
1543 | # Случайный синий цвет:
1544 | pencolor((0, 0, random()))
1545 |
1546 | # Случайная толщина:
1547 | pensize(randint(1, 5))
1548 |
1549 | # Случайный радиус:
1550 | circle_size = randint(10, 40)
1551 |
1552 | # Нарисовать 6 кругов:
1553 | for i in range(6):
1554 | circle(circle_size)
1555 | left(60)
1556 |
1557 | update()
1558 | done()
1559 | ```
1560 |
1561 | ---
1562 |
1563 | Результат:
1564 |
1565 | 
1566 |
1567 | ---
1568 |
1569 | Каждый запуск даёт уникальный узор из «цветов» в синей гамме.
1570 |
1571 | Это и есть генеративное искусство — вы создаёте **программу, которая создаёт рисунки**.
1572 |
1573 |
1574 |
1575 | ## Закрашенные фигуры
1576 |
1577 | До сих пор мы рисовали только линии.
1578 | Но черепашка также может рисовать **залитые фигуры**.
1579 |
1580 | ---
1581 |
1582 | ### Как закрасить фигуру
1583 |
1584 | 1. Установите цвет заливки с помощью `fillcolor()`
1585 | 2. Вызовите `begin_fill()`
1586 | 3. Нарисуйте форму
1587 | 4. Вызовите `end_fill()` для завершения заливки
1588 |
1589 | ---
1590 |
1591 | ### Пример: закрашенный квадрат
1592 |
1593 | Создайте файл *filled_square.py*:
1594 |
1595 | ```python
1596 | # filled_square.py
1597 |
1598 | from turtle import *
1599 |
1600 | pensize(4)
1601 | fillcolor('blue')
1602 |
1603 | begin_fill()
1604 | for i in range(4):
1605 | forward(200)
1606 | left(90)
1607 | end_fill()
1608 |
1609 | done()
1610 | ```
1611 |
1612 | ---
1613 |
1614 | Результат:
1615 |
1616 | 
1617 |
1618 | ---
1619 |
1620 | ### Пример: случайные квадраты
1621 |
1622 | Создайте *colorful_squares.py*:
1623 |
1624 | ```python
1625 | # colorful_squares.py
1626 |
1627 | from turtle import *
1628 | from random import *
1629 |
1630 | pensize(4)
1631 | tracer(10, 0)
1632 |
1633 | for i in range(100):
1634 | penup()
1635 | goto(randint(-400, 200), randint(-400, 200))
1636 | pendown()
1637 |
1638 | fillcolor((random(), random(), random()))
1639 | pencolor((random(), random(), random()))
1640 | line_length = randint(20, 200)
1641 |
1642 | begin_fill()
1643 | for j in range(4):
1644 | forward(line_length)
1645 | left(90)
1646 | end_fill()
1647 |
1648 | done()
1649 | ```
1650 |
1651 | ---
1652 |
1653 | Результат:
1654 |
1655 | 
1656 |
1657 | ---
1658 |
1659 | ### Пример: цветные изогнутые формы
1660 |
1661 | Создайте *curve_path_filled.py*:
1662 |
1663 | ```python
1664 | # curve_path_filled.py
1665 |
1666 | from turtle import *
1667 | from random import *
1668 |
1669 | tracer(4, 0)
1670 |
1671 | for i in range(50):
1672 | fillcolor((random(), random(), random()))
1673 | setheading(randint(0, 360))
1674 |
1675 | begin_fill()
1676 | for j in range(randint(200, 600)):
1677 | forward(1)
1678 | left(randint(-4, 4))
1679 | home()
1680 | end_fill()
1681 |
1682 | update()
1683 | done()
1684 | ```
1685 |
1686 | ---
1687 |
1688 | Результат:
1689 |
1690 | 
1691 |
1692 | ---
1693 |
1694 | Функции `begin_fill()` и `end_fill()` работают с **любой формой**,
1695 | не обязательно с прямыми углами.
1696 |
1697 |
1698 |
1699 | ## Дополнительная информация
1700 |
1701 | В этом учебнике мы рассмотрели основы модуля `turtle` в Python.
1702 | Вот где можно узнать больше:
1703 |
1704 | ---
1705 |
1706 | ### Документация
1707 |
1708 | - [Официальная документация модуля turtle (на английском)](https://docs.python.org/3/library/turtle.html)
1709 | - [Список всех функций turtle](https://docs.python.org/3/library/turtle.html#turtle-methods)
1710 |
1711 | ---
1712 |
1713 | ### Рекурсивные рисунки
1714 |
1715 | - [Глава 9 из книги *The Recursive Book of Recursion*](https://inventwithpython.com/recursion/chapter9.html)
1716 | Примеры рекурсивного рисования черепашкой
1717 | - [Глава 13 из той же книги](https://inventwithpython.com/recursion/chapter13.html)
1718 | Фракталы и рекурсия
1719 |
1720 | ---
1721 |
1722 | ### Программа turtledemo
1723 |
1724 | Python поставляется с встроенной демонстрационной программой **turtledemo**.
1725 |
1726 | Создайте файл со следующим кодом:
1727 |
1728 | ```python
1729 | import turtledemo.__main__
1730 | turtledemo.__main__.main()
1731 | ```
1732 |
1733 | ---
1734 |
1735 | После запуска появится окно с меню.
1736 | Выберите одну из демонстраций и нажмите **Start**.
1737 |
1738 | 
1739 |
1740 | ---
1741 |
1742 | Слева вы увидите исходный код примера — вы можете изучать, как он работает.
1743 |
1744 | ---
1745 |
1746 | Желаю удачи в вашем путешествии по программированию!
1747 |
1748 |
1749 |
1750 | ## Сложные черепашьи задачи
1751 |
1752 | Если вы ищете более сложные рисунки для рисования программой,
1753 | вдохновитесь работами **Оскара Рейтерсварда**.
1754 |
1755 | ---
1756 |
1757 | Оскар Рейтерсвард — шведский художник, известный своими невозможными фигурами.
1758 | Его работы можно найти на сайте [Impossible World](https://im-possible.info/english/library/index.html)
1759 | или через [поиск изображений по имени](https://duckduckgo.com/?q=Oscar+Reutersv%C3%A4rd&iax=images&ia=images)
1760 |
1761 | ---
1762 |
1763 | Вот примеры таких рисунков:
1764 |
1765 | 
1766 | 
1767 | 
1768 | 
1769 |
1770 | ---
1771 |
1772 | Попробуйте повторить эти фигуры с помощью turtle-программирования!
1773 |
1774 |
1775 |
1776 | ## Решения упражнений
1777 |
1778 | Вот решения к практическим заданиям:
1779 |
1780 | ---
1781 |
1782 | ```python
1783 | # solution_equilateral_triangle.py
1784 | from turtle import *
1785 | pensize(4)
1786 |
1787 | right(60)
1788 | forward(200)
1789 |
1790 | right(120)
1791 | forward(200)
1792 |
1793 | right(120)
1794 | forward(200)
1795 |
1796 | done()
1797 | ```
1798 |
1799 | ---
1800 |
1801 | ```python
1802 | # solution_pentagon.py
1803 | from turtle import *
1804 | pensize(4)
1805 |
1806 | for i in range(5):
1807 | left(72)
1808 | forward(200)
1809 |
1810 | done()
1811 | ```
1812 |
1813 | ---
1814 |
1815 | ```python
1816 | # solution_hexagon.py
1817 | from turtle import *
1818 | pensize(4)
1819 |
1820 | for i in range(6):
1821 | left(60)
1822 | forward(200)
1823 |
1824 | done()
1825 | ```
1826 |
1827 | ---
1828 |
1829 | ```python
1830 | # solution_octagon.py
1831 | from turtle import *
1832 | pensize(4)
1833 |
1834 | for i in range(8):
1835 | left(45)
1836 | forward(100)
1837 |
1838 | done()
1839 | ```
1840 |
1841 | ---
1842 |
1843 | ```python
1844 | # solution_right_triangle.py
1845 | from turtle import *
1846 | pensize(4)
1847 |
1848 | forward(200)
1849 | right(90)
1850 | forward(200)
1851 | right(135)
1852 | forward(282.8)
1853 |
1854 | done()
1855 | ```
1856 |
1857 | ---
1858 |
1859 | ```python
1860 | # solution_star.py
1861 | from turtle import *
1862 | pensize(4)
1863 |
1864 | for i in range(5):
1865 | right(144)
1866 | forward(300)
1867 |
1868 | done()
1869 | ```
1870 |
1871 | ---
1872 |
1873 | ```python
1874 | # solution_nested_squares.py
1875 | from turtle import *
1876 | pensize(4)
1877 |
1878 | for line_length in range(100, 350, 50):
1879 | for i in range(4):
1880 | forward(line_length)
1881 | left(90)
1882 |
1883 | done()
1884 | ```
1885 |
1886 | ---
1887 |
1888 | ```python
1889 | # solution_cross.py
1890 | from turtle import *
1891 | pensize(4)
1892 |
1893 | for i in range(4):
1894 | forward(100)
1895 | right(90)
1896 |
1897 | forward(100)
1898 | right(90)
1899 |
1900 | forward(100)
1901 | left(90)
1902 |
1903 | done()
1904 | ```
1905 |
1906 | ---
1907 |
1908 | ```python
1909 | # solution_cube.py
1910 | from turtle import *
1911 | pensize(4)
1912 |
1913 | for i in range(4):
1914 | forward(200)
1915 | right(90)
1916 |
1917 | left(45)
1918 | forward(200)
1919 | right(45)
1920 | forward(200)
1921 | right(135)
1922 | forward(200)
1923 | backward(200)
1924 | left(45)
1925 | forward(200)
1926 | right(45)
1927 | forward(200)
1928 | backward(200)
1929 | right(45)
1930 | forward(200)
1931 | left(45)
1932 | forward(200)
1933 | backward(200)
1934 | right(135)
1935 | forward(200)
1936 |
1937 | done()
1938 | ```
1939 |
1940 | ---
1941 |
1942 | ```python
1943 | # solution_triforce.py
1944 | from turtle import *
1945 | pensize(4)
1946 |
1947 | right(60)
1948 | forward(400)
1949 | right(120)
1950 | forward(400)
1951 | right(120)
1952 | forward(400)
1953 | right(120)
1954 | forward(200)
1955 | right(60)
1956 | forward(200)
1957 | right(120)
1958 | forward(200)
1959 | right(120)
1960 | forward(200)
1961 |
1962 | done()
1963 | ```
1964 |
1965 | ---
1966 |
1967 | ```python
1968 | # solution_star_outline.py
1969 | from turtle import *
1970 |
1971 | pensize(4)
1972 | penup()
1973 | goto(0, 300)
1974 |
1975 | pendown()
1976 | goto(70, 95)
1977 | goto(285, 95)
1978 | goto(110, -35)
1979 | goto(175, -260)
1980 | goto(0, -100)
1981 | goto(-175, -260)
1982 | goto(-110, -35)
1983 | goto(-285, 95)
1984 | goto(-70, 95)
1985 | goto(0, 300)
1986 |
1987 | done()
1988 | ```
1989 |
1990 | ---
1991 |
1992 | ```python
1993 | # solution_cross_setheading.py
1994 | from turtle import *
1995 | pensize(4)
1996 |
1997 | setheading(0)
1998 | forward(100)
1999 | setheading(270)
2000 | forward(100)
2001 | setheading(180)
2002 | forward(100)
2003 |
2004 | setheading(270)
2005 | forward(100)
2006 | setheading(180)
2007 | forward(100)
2008 | setheading(90)
2009 | forward(100)
2010 |
2011 | setheading(180)
2012 | forward(100)
2013 | setheading(90)
2014 | forward(100)
2015 | setheading(0)
2016 | forward(100)
2017 |
2018 | setheading(90)
2019 | forward(100)
2020 | setheading(0)
2021 | forward(100)
2022 | setheading(270)
2023 | forward(100)
2024 |
2025 | done()
2026 | ```
2027 |
2028 | ---
2029 |
2030 | ```python
2031 | # solution_random_hello.py
2032 | from turtle import *
2033 | from random import *
2034 |
2035 | tracer(1000, 0)
2036 | penup()
2037 | hideturtle()
2038 |
2039 | for i in range(100):
2040 | goto(randint(-400, 400), randint(-400, 400))
2041 | write('Hello, world!', font=('Arial', randint(12, 48), 'normal'))
2042 |
2043 | update()
2044 | done()
2045 | ```
2046 |
2047 |
--------------------------------------------------------------------------------
/solution_cross.py:
--------------------------------------------------------------------------------
1 | # solution_cross.py
2 | from turtle import *
3 | pensize(4)
4 |
5 | for i in range(4):
6 | forward(100)
7 | right(90)
8 |
9 | forward(100)
10 | right(90)
11 |
12 | forward(100)
13 | left(90)
14 |
15 | done()
16 |
--------------------------------------------------------------------------------
/solution_cross_setheading.py:
--------------------------------------------------------------------------------
1 | # solution_cross_setheading.py
2 | from turtle import *
3 | pensize(4)
4 |
5 | # Right bump:
6 | setheading(0) # Face right.
7 | forward(100)
8 | setheading(270) # Face down.
9 | forward(100)
10 | setheading(180) # Face left.
11 | forward(100)
12 |
13 | # Bottom bump:
14 | setheading(270) # Face down.
15 | forward(100)
16 | setheading(180) # Face left.
17 | forward(100)
18 | setheading(90) # Face up.
19 | forward(100)
20 |
21 | # Left bump:
22 | setheading(180) # Face left.
23 | forward(100)
24 | setheading(90) # Face up.
25 | forward(100)
26 | setheading(0) # Face right.
27 | forward(100)
28 |
29 | # Top bump:
30 | setheading(90) # Face up.
31 | forward(100)
32 | setheading(0) # Face right.
33 | forward(100)
34 | setheading(270) # Face down.
35 | forward(100)
36 |
37 | done()
38 |
--------------------------------------------------------------------------------
/solution_cube.py:
--------------------------------------------------------------------------------
1 | # solution_cube.py
2 | from turtle import *
3 | pensize(4)
4 |
5 | # Front square:
6 | for i in range(4):
7 | forward(200)
8 | right(90)
9 |
10 | # Top left diagonal:
11 | left(45)
12 | forward(200)
13 | right(45)
14 |
15 | # Top side of back square:
16 | forward(200)
17 | right(135)
18 | forward(200)
19 | backward(200)
20 | left(45)
21 |
22 | # Right side of back square:
23 | forward(200)
24 | right(45)
25 | forward(200)
26 | backward(200)
27 | right(45)
28 |
29 | # Bottom side of back square:
30 | forward(200)
31 | left(45)
32 | forward(200)
33 | backward(200)
34 |
35 | # Left side of back square:
36 | right(135)
37 | forward(200)
38 |
39 | done()
40 |
--------------------------------------------------------------------------------
/solution_equilateral_triangle.py:
--------------------------------------------------------------------------------
1 | # solution_equilateral_triangle.py
2 | from turtle import *
3 | pensize(4)
4 |
5 | right(60)
6 | forward(200)
7 |
8 | right(120)
9 | forward(200)
10 |
11 | right(120)
12 | forward(200)
13 |
14 | done()
15 |
--------------------------------------------------------------------------------
/solution_fan.py:
--------------------------------------------------------------------------------
1 | # solution_fan.py
2 | from turtle import *
3 | from random import *
4 | pensize(4)
5 | speed('fastest')
6 |
7 | for i in range(10):
8 | goto(randint(-400, 400), randint(-400, 400))
9 | setheading(randint(0, 360))
10 | forward(100)
11 | home()
12 |
13 | done()
14 |
--------------------------------------------------------------------------------
/solution_hexagon.py:
--------------------------------------------------------------------------------
1 | # solution_hexagon.py
2 | from turtle import *
3 | pensize(4)
4 |
5 | left(60)
6 | forward(200)
7 |
8 | left(60)
9 | forward(200)
10 |
11 | left(60)
12 | forward(200)
13 |
14 | left(60)
15 | forward(200)
16 |
17 | left(60)
18 | forward(200)
19 |
20 | left(60)
21 | forward(200)
22 |
23 | # Or you can run:
24 | # for i in range(6):
25 | # left(60)
26 | # forward(200)
27 | done()
28 |
--------------------------------------------------------------------------------
/solution_nested_squares.py:
--------------------------------------------------------------------------------
1 | # solution_nested_squares.py
2 | from turtle import *
3 | pensize(4)
4 |
5 | line_length = 100
6 | for i in range(4):
7 | forward(line_length)
8 | left(90)
9 |
10 | line_length = 150
11 | for i in range(4):
12 | forward(line_length)
13 | left(90)
14 |
15 | line_length = 200
16 | for i in range(4):
17 | forward(line_length)
18 | left(90)
19 |
20 | line_length = 250
21 | for i in range(4):
22 | forward(line_length)
23 | left(90)
24 |
25 | line_length = 300
26 | for i in range(4):
27 | forward(line_length)
28 | left(90)
29 |
30 | # Or you can run:
31 | #for line_length in range(100, 350, 50):
32 | # for i in range(4):
33 | # forward(line_length)
34 | # left(90)
35 | done()
36 |
--------------------------------------------------------------------------------
/solution_octagon.py:
--------------------------------------------------------------------------------
1 | # solution_octogon.py
2 | from turtle import *
3 | pensize(4)
4 |
5 | left(45)
6 | forward(100)
7 |
8 | left(45)
9 | forward(100)
10 |
11 | left(45)
12 | forward(100)
13 |
14 | left(45)
15 | forward(100)
16 |
17 | left(45)
18 | forward(100)
19 |
20 | left(45)
21 | forward(100)
22 |
23 | left(45)
24 | forward(100)
25 |
26 | left(45)
27 | forward(100)
28 |
29 | # Or you can run:
30 | # for i in range(8):
31 | # left(45)
32 | # forward(100)
33 | done()
34 |
--------------------------------------------------------------------------------
/solution_pentagon.py:
--------------------------------------------------------------------------------
1 | # solution_pentagon.py
2 | from turtle import *
3 | pensize(4)
4 |
5 | left(72)
6 | forward(200)
7 |
8 | left(72)
9 | forward(200)
10 |
11 | left(72)
12 | forward(200)
13 |
14 | left(72)
15 | forward(200)
16 |
17 | left(72)
18 | forward(200)
19 |
20 | # Or you can run:
21 | # for i in range(5):
22 | # left(72)
23 | # forward(200)
24 | done()
25 |
--------------------------------------------------------------------------------
/solution_random_hello.py:
--------------------------------------------------------------------------------
1 | # solution_random_hello.py
2 | from turtle import *
3 | from random import *
4 |
5 | tracer(1000, 0)
6 | penup()
7 | hideturtle()
8 |
9 | for i in range(100):
10 | goto(randint(-400, 400), randint(-400, 400))
11 | write('Hello, world!', font=('Arial', randint(12, 48), 'normal'))
12 |
13 | update()
14 | done()
15 |
--------------------------------------------------------------------------------
/solution_right_triangle.py:
--------------------------------------------------------------------------------
1 | # solution_right_triangle.py
2 | from turtle import *
3 | pensize(4)
4 |
5 | forward(200)
6 | right(90)
7 | forward(200)
8 | right(135)
9 | forward(282.8)
10 |
11 | done()
12 |
--------------------------------------------------------------------------------
/solution_star.py:
--------------------------------------------------------------------------------
1 | # solution_star.py
2 | from turtle import *
3 | pensize(4)
4 |
5 | right(144)
6 | forward(300)
7 |
8 | right(144)
9 | forward(300)
10 |
11 | right(144)
12 | forward(300)
13 |
14 | right(144)
15 | forward(300)
16 |
17 | right(144)
18 | forward(300)
19 |
20 | # Or you can run:
21 | #for i in range(5):
22 | # right(144)
23 | # forward(300)
24 | done()
25 |
--------------------------------------------------------------------------------
/solution_star_outline.py:
--------------------------------------------------------------------------------
1 | # solution_star_outline.py
2 | from turtle import *
3 |
4 | # Move the turtle to the first point of the star:
5 | pensize(4)
6 | penup()
7 | goto(0, 300)
8 |
9 | # Draw lines to the other points of the star:
10 | pendown()
11 | goto(70, 95)
12 | goto(285, 95)
13 | goto(110, -35)
14 | goto(175, -260)
15 | goto(0, -100)
16 | goto(-175, -260)
17 | goto(-110, -35)
18 | goto(-285, 95)
19 | goto(-70, 95)
20 | goto(0, 300)
21 |
22 | done()
--------------------------------------------------------------------------------
/solution_triforce.py:
--------------------------------------------------------------------------------
1 | # solution_cross.py
2 | from turtle import *
3 | pensize(4)
4 |
5 | right(60)
6 | forward(400)
7 |
8 | right(120)
9 | forward(400)
10 |
11 | right(120)
12 | forward(400)
13 |
14 | right(120)
15 | forward(200)
16 |
17 | right(60)
18 | forward(200)
19 |
20 | right(120)
21 | forward(200)
22 |
23 | right(120)
24 | forward(200)
25 |
26 | done()
27 |
--------------------------------------------------------------------------------
/spiral.py:
--------------------------------------------------------------------------------
1 | # spiral.py
2 | from turtle import *
3 |
4 | speed('fastest')
5 | for i in range(300):
6 | forward(i) # Use the i variable for the function argument.
7 | left(91)
8 | hideturtle()
9 | done()
10 |
--------------------------------------------------------------------------------
/spiral_black_bg.py:
--------------------------------------------------------------------------------
1 | # spiral_black_bg.py
2 | from turtle import *
3 | from random import *
4 |
5 | colors = ['red', 'orange', 'yellow', 'blue', 'green', 'purple']
6 |
7 | speed('fastest')
8 | pensize(3)
9 | bgcolor('black')
10 | for i in range(300):
11 | pencolor(choice(colors))
12 | forward(i)
13 | left(91)
14 | hideturtle()
15 | done()
16 |
--------------------------------------------------------------------------------
/spiral_color.py:
--------------------------------------------------------------------------------
1 | # spiral_color.py
2 | from turtle import *
3 | from random import *
4 |
5 | colors = ['red', 'purple', 'blue', 'green', 'yellow', 'orange']
6 |
7 | speed('fastest')
8 | for x in range(300):
9 | pencolor(choice(colors))
10 | forward(x)
11 | left(91)
12 | hideturtle()
13 | done()
--------------------------------------------------------------------------------
/spiral_rainbow.py:
--------------------------------------------------------------------------------
1 | # spiral_rainbow.py
2 | from turtle import *
3 |
4 | speed('fastest')
5 | pensize(3)
6 | bgcolor('black')
7 |
8 | pencolor('red')
9 | for i in range(60):
10 | forward(i)
11 | left(91)
12 |
13 | pencolor('orange')
14 | for i in range(60):
15 | forward(60 + i)
16 | left(91)
17 |
18 | pencolor('yellow')
19 | for i in range(60):
20 | forward(120 + i)
21 | left(91)
22 |
23 | pencolor('green')
24 | for i in range(60):
25 | forward(180 + i)
26 | left(91)
27 |
28 | pencolor('blue')
29 | for i in range(60):
30 | forward(240 + i)
31 | left(91)
32 |
33 | pencolor('purple')
34 | for i in range(60):
35 | forward(300 + i)
36 | left(91)
37 |
38 | done()
39 |
--------------------------------------------------------------------------------
/spiral_red.py:
--------------------------------------------------------------------------------
1 | # spiral_red.py
2 | from turtle import *
3 |
4 | speed('fastest')
5 | pencolor('red') # Make the lines red.
6 | for i in range(30):
7 | forward(i)
8 | left(91)
9 | hideturtle()
10 | done()
11 |
--------------------------------------------------------------------------------
/square.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/square.png
--------------------------------------------------------------------------------
/square_circle_86.py:
--------------------------------------------------------------------------------
1 | # square_circle_86.py
2 | from turtle import *
3 |
4 | pensize(4)
5 | speed('fastest')
6 |
7 | for i in range(50): # Loop 50 times instead of 4.
8 | forward(200)
9 | left(86)
10 | hideturtle()
11 | done()
--------------------------------------------------------------------------------
/square_for_loop.py:
--------------------------------------------------------------------------------
1 | # square_for_loop.py
2 | from turtle import *
3 |
4 | pensize(4)
5 |
6 | # The indented lines of code run 4 times:
7 | for i in range(4):
8 | forward(200)
9 | left(90)
10 | done()
11 |
--------------------------------------------------------------------------------
/square_for_loop_86.py:
--------------------------------------------------------------------------------
1 | # square_for_loop_86.py
2 | from turtle import *
3 |
4 | pensize(4)
5 |
6 | for i in range(4):
7 | forward(200)
8 | left(86) # Turn left 86 degrees instead of 90.
9 | done()
--------------------------------------------------------------------------------
/square_random.py:
--------------------------------------------------------------------------------
1 | # square_random.py
2 | from turtle import *
3 | from random import *
4 |
5 | pensize(4)
6 | speed('fastest')
7 |
8 | for i in range(50):
9 | forward(200)
10 | # Turn left a random number of degrees between 80 and 100:
11 | left(randint(85, 95))
12 | hideturtle()
13 | done()
--------------------------------------------------------------------------------
/square_smaller.py:
--------------------------------------------------------------------------------
1 | # square_smaller.py
2 | from turtle import *
3 |
4 | pensize(4)
5 | forward(25) # Now the turtle moves forward only 25 steps.
6 | left(90)
7 | forward(25)
8 | left(90)
9 | forward(25)
10 | left(90)
11 | forward(25)
12 | left(90)
13 | done()
--------------------------------------------------------------------------------
/square_smaller_bug.py:
--------------------------------------------------------------------------------
1 | # square_smaller_buy.py
2 | from turtle import *
3 |
4 | pensize(4)
5 | forward(25)
6 | left(90)
7 | forward(25)
8 | left(90)
9 | forward(200) # Uh oh, we forgot to change this line!
10 | left(90)
11 | forward(25)
12 | left(90)
13 | done()
14 |
--------------------------------------------------------------------------------
/square_spiral.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/square_spiral.png
--------------------------------------------------------------------------------
/square_variable.py:
--------------------------------------------------------------------------------
1 | # square_variable.py
2 | from turtle import *
3 |
4 | pensize(4)
5 | line_length = 25 # This variable stores the number 25.
6 | forward(line_length) # The turtle moves 25 steps because line_length is 25.
7 | left(90)
8 | forward(line_length)
9 | left(90)
10 | forward(line_length)
11 | left(90)
12 | forward(line_length)
13 | left(90)
14 | done()
--------------------------------------------------------------------------------
/stamp.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/stamp.png
--------------------------------------------------------------------------------
/stamp_path.py:
--------------------------------------------------------------------------------
1 | # stamp_path.py
2 | from turtle import *
3 | from random import *
4 |
5 | shape('turtle')
6 | speed('fastest')
7 | penup()
8 | bgcolor((0.1, 0.6, 0.8)) # Set the background color to a light blue.
9 |
10 | start_heading = 0
11 | while start_heading < 360:
12 | home()
13 | setheading(start_heading)
14 | pencolor('white')
15 | fillcolor(choice(['green', 'yellow']))
16 | for j in range(12):
17 | left(randint(-20, 20)) # Randomly turn up to 20 degrees left or right.
18 | forward(30) # 30 step gap in between stamps.
19 | stamp()
20 | start_heading = start_heading + 20
21 |
22 | done()
23 |
--------------------------------------------------------------------------------
/test_example_programs.py:
--------------------------------------------------------------------------------
1 | # This script extracts the Python programs out of simple_turtle_tutorial.md and checks their syntax.
2 |
3 | import os
4 | import platform
5 | import sys
6 |
7 | fo = open('simple_turtle_tutorial.md')
8 | content= fo.read()
9 | fo.close()
10 |
11 | while True:
12 | # find where the next python script is
13 | start_pos = content.find("```python\n")
14 | if start_pos == -1:
15 | break
16 |
17 | end_pos = content.index('```', start_pos + len('```python\n'))
18 | script = content[start_pos + len('```python\n') : end_pos]
19 |
20 | # remove that script from the file contents
21 | content = content[end_pos + len('```\n'):]
22 |
23 | # output the python script to a temp file
24 | temp_script_filename = open('_deleteme.py', 'w')
25 | temp_script_filename.write(script)
26 | temp_script_filename.close()
27 |
28 | # compile the code to do a syntax check
29 | if platform.system() == 'Windows':
30 | # Check that the code is compatible with Python 2
31 | os.system('py -2 -m py_compile _deleteme.py')
32 | os.system('py -3 -m py_compile _deleteme.py')
33 | else:
34 | os.system('python3 -m py_compile _deleteme.py')
35 | sys.stdout.write('.') # Each period marks that we've tested one program.
36 | sys.stdout.flush()
37 |
38 | os.unlink('_deleteme.py')
--------------------------------------------------------------------------------
/turn_left.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/turn_left.png
--------------------------------------------------------------------------------
/turn_right.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/turn_right.png
--------------------------------------------------------------------------------
/turtle_directions.py:
--------------------------------------------------------------------------------
1 | # turtle_directions.py
2 | from turtle import *
3 |
4 | for i in range(24):
5 | forward(200) # Move forward in the current direction.
6 | write(heading(), font=('Arial', 12, 'normal')) # Write the degrees of the direction.
7 | backward(200) # Move back to the center.
8 | left(15) # Turn left by 15 degrees and repeat.
9 | done()
--------------------------------------------------------------------------------
/turtlecolors.py:
--------------------------------------------------------------------------------
1 | from turtle import *
2 |
3 | # Set up some constants for slider positions:
4 | RED_X = -200
5 | GREEN_X = 0
6 | BLUE_X = 200
7 | TOP = 200
8 | BOTTOM = -200
9 | SLIDER_LENGTH = abs(TOP - BOTTOM)
10 | CLICK_RANGE = 40
11 | TEXT_X_OFFSET = -75
12 | TEXT_Y = BOTTOM - 60
13 | COLOR_BOXES = ((0,0,0), (128,128,128), (128,0,0), (128,128,0), (0,128,0), (0,128,128), (0,0,128), (128,0,128), (128,128,64), (0,64,64), (0,128,255), (0,64,128), (128,0,255), (128,64,0),
14 | (255,255,255), (192,192,192), (255,0,0), (255,255,0), (0,255,0), (0,255,255), (0,0,255), (255,0,255), (255,255,128), (0,255,128), (128,255,255), (128,128,255), (255,0,128), (255,128,64))
15 | COLOR_BOX_SIZE = 30
16 | COLOR_BOX_TOP = 320
17 | COLOR_BOX_LEFT = -240
18 | COLOR_BOX_GAP = 5
19 |
20 | # Set up global variables:
21 | red_setting = 0.5
22 | green_setting = 0.5
23 | blue_setting = 0.5
24 | bgcolor((red_setting, green_setting, blue_setting))
25 | color_box_positions = []
26 | red_cursor = Turtle()
27 | green_cursor = Turtle()
28 | blue_cursor = Turtle()
29 | rw = Turtle()
30 | gw = Turtle()
31 | bw = Turtle()
32 |
33 |
34 | def print_color_values():
35 | # Note: I could have hard-coded all these color values, but I'd
36 | # to know if any of these names become invalid for turtle.py.
37 |
38 | canvas = getcanvas()
39 |
40 | # Convert color name to RGB tuple:
41 | for color_name in ('aliceblue','antiquewhite','antiquewhite1','antiquewhite2','antiquewhite3','antiquewhite4','aqua','aquamarine1','aquamarine2','aquamarine3','aquamarine4','azure','azure1','azure2','azure3','azure4','beige','bisque1','bisque2','bisque3','bisque4','black','blanchedalmond','blue','blue2','blue3','blue4','blueviolet','brown','brown1','brown2','brown3','brown4','burlywood','burlywood1','burlywood2','burlywood3','burlywood4','cadetblue','cadetblue1','cadetblue2','cadetblue3','cadetblue4','chartreuse','chartreuse1','chartreuse2','chartreuse3','chartreuse4','chocolate','chocolate1','chocolate2','chocolate3','chocolate4','coral','coral1','coral2','coral3','coral4','cornflowerblue','cornsilk','cornsilk1','cornsilk2','cornsilk3','cornsilk4','crimson','cyan','cyan2','cyan3','cyan4','darkgoldenrod','darkgoldenrod1','darkgoldenrod2','darkgoldenrod3','darkgoldenrod4','darkgray','darkgreen','darkkhaki','darkolivegreen','darkolivegreen1','darkolivegreen2','darkolivegreen3','darkolivegreen4','darkorange','darkorange1','darkorange2','darkorange3','darkorange4','darkorchid','darkorchid1','darkorchid2','darkorchid3','darkorchid4','darksalmon','darkseagreen','darkseagreen1','darkseagreen2','darkseagreen3','darkseagreen4','darkslateblue','darkslategray','darkslategray1','darkslategray2','darkslategray3','darkslategray4','darkturquoise','darkviolet','deeppink1','deeppink2','deeppink3','deeppink4','deepskyblue','deepskyblue1','deepskyblue2','deepskyblue3','deepskyblue4','dimgray','dodgerblue1','dodgerblue2','dodgerblue3','dodgerblue4','firebrick','firebrick1','firebrick2','firebrick3','firebrick4','floralwhite','forestgreen','gainsboro','ghostwhite','gold1','gold2','gold3','gold4','goldenrod','goldenrod1','goldenrod2','goldenrod3','goldenrod4','gray','gray1','gray10','gray11','gray12','gray13','gray14','gray15','gray16','gray17','gray18','gray19','gray2','gray20','gray21','gray22','gray23','gray24','gray25','gray26','gray27','gray28','gray29','gray3','gray30','gray31','gray32','gray33','gray34','gray35','gray36','gray37','gray38','gray39','gray4','gray40','gray42','gray43','gray44','gray45','gray46','gray47','gray48','gray49','gray5','gray50','gray51','gray52','gray53','gray54','gray55','gray56','gray57','gray58','gray59','gray6','gray60','gray61','gray62','gray63','gray64','gray65','gray66','gray67','gray68','gray69','gray7','gray70','gray71','gray72','gray73','gray74','gray75','gray76','gray77','gray78','gray79','gray8','gray80','gray81','gray82','gray83','gray84','gray85','gray86','gray87','gray88','gray89','gray9','gray90','gray91','gray92','gray93','gray94','gray95','gray97','gray98','gray99','green','green1','green2','green3','green4','greenyellow','honeydew1','honeydew2','honeydew3','honeydew4','hotpink','hotpink1','hotpink2','hotpink3','hotpink4','indianred','indianred1','indianred2','indianred3','indianred4','indigo','ivory1','ivory2','ivory3','ivory4','khaki','khaki1','khaki2','khaki3','khaki4','lavender','lavenderblush1','lavenderblush2','lavenderblush3','lavenderblush4','lawngreen','lemonchiffon1','lemonchiffon2','lemonchiffon3','lemonchiffon4','lightblue','lightblue1','lightblue2','lightblue3','lightblue4','lightcoral','lightcyan1','lightcyan2','lightcyan3','lightcyan4','lightgoldenrod1','lightgoldenrod2','lightgoldenrod3','lightgoldenrod4','lightgoldenrodyellow','lightgrey','lightpink','lightpink1','lightpink2','lightpink3','lightpink4','lightsalmon1','lightsalmon2','lightsalmon3','lightsalmon4','lightseagreen','lightskyblue','lightskyblue1','lightskyblue2','lightskyblue3','lightskyblue4','lightslateblue','lightslategray','lightsteelblue','lightsteelblue1','lightsteelblue2','lightsteelblue3','lightsteelblue4','lightyellow1','lightyellow2','lightyellow3','lightyellow4','limegreen','linen','magenta','magenta2','magenta3','magenta4','maroon','maroon1','maroon2','maroon3','maroon4','mediumorchid','mediumorchid1','mediumorchid2','mediumorchid3','mediumorchid4','mediumpurple','mediumpurple1','mediumpurple2','mediumpurple3','mediumpurple4','mediumseagreen','mediumslateblue','mediumspringgreen','mediumturquoise','mediumvioletred','midnightblue','mintcream','mistyrose1','mistyrose2','mistyrose3','mistyrose4','moccasin','navajowhite1','navajowhite2','navajowhite3','navajowhite4','navy','oldlace','olive','olivedrab','olivedrab1','olivedrab2','olivedrab3','olivedrab4','orange','orange1','orange2','orange3','orange4','orangered1','orangered2','orangered3','orangered4','orchid','orchid1','orchid2','orchid3','orchid4','palegoldenrod','palegreen','palegreen1','palegreen2','palegreen3','palegreen4','paleturquoise1','paleturquoise2','paleturquoise3','paleturquoise4','palevioletred','palevioletred1','palevioletred2','palevioletred3','palevioletred4','papayawhip','peachpuff1','peachpuff2','peachpuff3','peachpuff4','pink','pink1','pink2','pink3','pink4','plum','plum1','plum2','plum3','plum4','powderblue','purple','purple1','purple2','purple3','purple4','red1','red2','red3','red4','rosybrown','rosybrown1','rosybrown2','rosybrown3','rosybrown4','royalblue','royalblue1','royalblue2','royalblue3','royalblue4','salmon','salmon1','salmon2','salmon3','salmon4','sandybrown','seagreen1','seagreen2','seagreen3','seagreen4','seashell1','seashell2','seashell3','seashell4','sienna','sienna1','sienna2','sienna3','sienna4','silver','skyblue','skyblue1','skyblue2','skyblue3','skyblue4','slateblue','slateblue1','slateblue2','slateblue3','slateblue4','slategray','slategray1','slategray2','slategray3','slategray4','snow1','snow2','snow3','snow4','springgreen','springgreen1','springgreen2','springgreen3','steelblue','steelblue1','steelblue2','steelblue3','steelblue4','tan','tan1','tan2','tan3','tan4','teal','thistle','thistle1','thistle2','thistle3','thistle4','tomato1','tomato2','tomato3','tomato4','turquoise','turquoise1','turquoise2','turquoise3','turquoise4','violet','violetred','violetred1','violetred2','violetred3','violetred4','wheat','wheat1','wheat2','wheat3','wheat4','white','whitesmoke','yellow1','yellow2','yellow3','yellow4'):
42 | rgb_16bit = canvas.winfo_rgb(color_name) # e.g. returns (65535, 0, 0) for 'red'.
43 | rgb_255 = tuple(c // 256 for c in rgb_16bit) # Scale down to 8-bit.
44 | rgb_1 = tuple([round(n / 255, 2) for n in rgb_255])
45 | rgb_hex = '#' + ''.join([hex(n)[2:].rjust(2, '0').upper() for n in rgb_255])
46 |
47 | # Separated by dashes for easy double-click highlighting (and not CSV because tuples contain commas):
48 | print(color_name, rgb_255, rgb_1, rgb_hex, sep='-')
49 |
50 |
51 | def handle_click(x, y):
52 | global red_setting, green_setting, blue_setting
53 |
54 | #print('click', x, y)
55 |
56 | # Check if the click is on a color box:
57 | for i, (boxx, boxy) in enumerate(color_box_positions):
58 | if (boxx <= x <= (boxx + COLOR_BOX_SIZE)) and (boxy >= y >= (boxy - COLOR_BOX_SIZE)):
59 | #print('color box clicked', i)
60 | red_setting, green_setting, blue_setting = COLOR_BOXES[i]
61 |
62 | # Adjust for colormode 1 (the values in COLOR_BOXES are in colormode 255):
63 | red_setting /= 255
64 | green_setting /= 255
65 | blue_setting /= 255
66 |
67 | # Move sliders into correct position:
68 | red_cursor.sety( BOTTOM + (SLIDER_LENGTH * red_setting))
69 | green_cursor.sety(BOTTOM + (SLIDER_LENGTH * green_setting))
70 | blue_cursor.sety( BOTTOM + (SLIDER_LENGTH * blue_setting))
71 |
72 | # Update background color and text:
73 | bgcolor((red_setting, green_setting, blue_setting))
74 | write_rgb_values()
75 |
76 |
77 |
78 | # Check if the click is on a slider:
79 | if y > TOP or y < BOTTOM:
80 | return # Outside of range, so do nothing.
81 | elif x >= RED_X - CLICK_RANGE and x <= RED_X + CLICK_RANGE:
82 | # Only the drag function if the click happened off of the turtle cursor:
83 | if y > red_cursor.ycor() + 10 or y < red_cursor.ycor() - 10:
84 | handle_red_drag(x, y)
85 | elif x >= GREEN_X - CLICK_RANGE and x <= GREEN_X + CLICK_RANGE:
86 | # Only the drag function if the click happened off of the turtle cursor:
87 | if y > green_cursor.ycor() + 10 or y < green_cursor.ycor() - 10:
88 | handle_green_drag(x, y)
89 | elif x >= BLUE_X - CLICK_RANGE and x <= BLUE_X + CLICK_RANGE:
90 | # Only the drag function if the click happened off of the turtle cursor:
91 | if y > blue_cursor.ycor() + 10 or y < blue_cursor.ycor() - 10:
92 | handle_blue_drag(x, y)
93 |
94 |
95 | def get_color_values_text(setting):
96 | spacer = ' '
97 | setting255 = round(setting * 255)
98 |
99 | return str(round(setting, 2)).ljust(4, '0') + spacer + \
100 | str(setting255) + spacer + \
101 | '#' + hex(setting255)[2:].rjust(2, '0').upper()
102 |
103 | def write_rgb_values():
104 | #print((red_setting, green_setting, blue_setting))
105 |
106 | # Make text white when background is dark, and black when background is light:
107 | if (red_setting + green_setting + blue_setting) / 3 < 0.5:
108 | rw.pencolor('white')
109 | gw.pencolor('white')
110 | bw.pencolor('white')
111 | else:
112 | rw.pencolor('black')
113 | gw.pencolor('black')
114 | bw.pencolor('black')
115 |
116 | for cursor, x, setting in ((rw, RED_X, red_setting), (gw, GREEN_X, green_setting), (bw, BLUE_X, blue_setting)):
117 | cursor.clear()
118 | cursor.goto(x + TEXT_X_OFFSET, TEXT_Y)
119 | cursor.write(get_color_values_text(setting), font=('Arial', 18, 'normal'))
120 |
121 | update()
122 |
123 |
124 | def handle_red_drag(x, y):
125 | global red_setting
126 | #print('red drag', x, y)
127 |
128 | if y > TOP:
129 | red_setting = 1.0
130 | red_cursor.sety(TOP)
131 | elif y < BOTTOM:
132 | red_setting = 0.0
133 | red_cursor.sety(BOTTOM)
134 | else:
135 | red_setting = abs(y - BOTTOM) / SLIDER_LENGTH
136 | red_cursor.sety(y)
137 |
138 | #print('red drag', x, y, red_setting)
139 | bgcolor((red_setting, green_setting, blue_setting))
140 | write_rgb_values()
141 |
142 |
143 | def handle_green_drag(x, y):
144 | global green_setting
145 | #print('green drag', x, y)
146 |
147 | if y > TOP:
148 | green_setting = 1.0
149 | green_cursor.sety(TOP)
150 | elif y < BOTTOM:
151 | green_setting = 0.0
152 | green_cursor.sety(BOTTOM)
153 | else:
154 | green_setting = abs(y - BOTTOM) / SLIDER_LENGTH
155 | green_cursor.sety(y)
156 |
157 | #print('green drag', x, y, green_setting)
158 | bgcolor((red_setting, green_setting, blue_setting))
159 | write_rgb_values()
160 |
161 |
162 | def handle_blue_drag(x, y):
163 | global blue_setting
164 | #print('blue drag', x, y)
165 |
166 | if y > TOP:
167 | blue_setting = 1.0
168 | blue_cursor.sety(TOP)
169 | elif y < BOTTOM:
170 | blue_setting = 0.0
171 | blue_cursor.sety(BOTTOM)
172 | else:
173 | blue_setting = abs(y - BOTTOM) / SLIDER_LENGTH
174 | blue_cursor.sety(y)
175 |
176 | #print('blue drag', x, y, blue_setting)
177 | bgcolor((red_setting, green_setting, blue_setting))
178 | write_rgb_values()
179 |
180 |
181 | def main():
182 | # Draw slider lines:
183 | tracer(1000, 0)
184 | hideturtle()
185 | pensize(6)
186 | setheading(270)
187 | for x in (RED_X, 0, BLUE_X):
188 | penup()
189 | goto(x, TOP)
190 | pendown()
191 | forward(SLIDER_LENGTH)
192 |
193 | # Draw color boxes:
194 | colormode(255)
195 | pensize(1)
196 | for i, color in enumerate(COLOR_BOXES):
197 | if i < 14:
198 | x = COLOR_BOX_LEFT + (i * COLOR_BOX_SIZE) + (i * COLOR_BOX_GAP)
199 | y = COLOR_BOX_TOP # Top row of the two rows.
200 | else:
201 | x = COLOR_BOX_LEFT + ((i-14) * COLOR_BOX_SIZE) + ((i-14) * COLOR_BOX_GAP)
202 | y = COLOR_BOX_TOP - COLOR_BOX_GAP - COLOR_BOX_SIZE # Bottom row of the two rows.
203 | color_box_positions.append((x,y))
204 |
205 | penup()
206 | goto(x, y)
207 | setheading(0)
208 | pendown()
209 | fillcolor(color)
210 | begin_fill()
211 | for j in range(4):
212 | forward(COLOR_BOX_SIZE)
213 | right(90)
214 | end_fill()
215 | colormode(1)
216 |
217 | # Setup turtle cursors for the square slider handles:
218 | for cursor, color, x in ((red_cursor, 'red', RED_X), (green_cursor, 'green', GREEN_X), (blue_cursor, 'blue', BLUE_X)):
219 | cursor.resizemode('auto')
220 | cursor.pensize(10)
221 | cursor.shape('square')
222 | cursor.fillcolor(color)
223 | cursor.penup()
224 | cursor.goto(x, 0)
225 |
226 | # Setup turtle cursors for the text:
227 | for t in (rw, gw, bw):
228 | t.hideturtle()
229 | t.penup()
230 | t.pencolor('black')
231 |
232 |
233 | # Print all color names and their values to stdio for easy copy/pasting:
234 | print_color_values()
235 |
236 | getscreen().onclick(handle_click)
237 | red_cursor.ondrag(handle_red_drag)
238 | green_cursor.ondrag(handle_green_drag)
239 | blue_cursor.ondrag(handle_blue_drag)
240 | #ontimer(write_rgb_values)
241 | write_rgb_values()
242 |
243 | update()
244 | done()
245 |
246 |
247 |
248 | if __name__ == '__main__':
249 | main()
250 |
--------------------------------------------------------------------------------
/undo_after.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/undo_after.png
--------------------------------------------------------------------------------
/undo_before.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asweigart/simple-turtle-tutorial-for-python/c3a89620fff2ae8426b334f280edd1ef27ceeb75/undo_before.png
--------------------------------------------------------------------------------
/write_hello.py:
--------------------------------------------------------------------------------
1 | # write_hello.py
2 |
3 | from turtle import *
4 |
5 | write('Hello, world!')
6 | forward(80)
7 | right(45)
8 | forward(50)
9 | write('123456789', font=('Arial', 48, 'normal'))
10 | right(45)
11 | forward(30)
12 | write('oOoOoOoOoOo')
13 | done()
14 |
--------------------------------------------------------------------------------