We will write a Python program that uses our special drawing tool, 'Turtle', to draw two different shapes: a square and a triangle. We will make two special helpers (functions), one for drawing a square and one for drawing a triangle. Then, we will tell our program to use these helpers to draw both shapes on the screen.
This helps us learn how to make different helpers for different drawing jobs!
Here's what your drawing screen should look like:
Before we start, let's run the tests to see what we need to fix.
Run this command in your terminal:
pytest module-1.1/blueprint-7/quest-40
What you should see:
test_draw_landmark_type_Atest_draw_landmark_type_Btest_draw_all_landmarks_calls_sub_functionstest_draw_all_landmarks_turtle_integrationNow, let's write our Python code in main.py! We need to create two special helpers (functions) for drawing different shapes, and then use them to draw both shapes on the screen.
Here are some helpful code examples:
1. How to make a function that draws a square:
import turtle
def draw_square(my_turtle, x, y, size):
my_turtle.penup()
my_turtle.goto(x, y)
my_turtle.pendown()
my_turtle.setheading(0) # Face right
for _ in range(4):
my_turtle.forward(size)
my_turtle.left(90)
my_turtle.penup()
2. How to make a function that draws a triangle:
import turtle
def draw_triangle(my_turtle, x, y, size):
my_turtle.penup()
my_turtle.goto(x, y)
my_turtle.pendown()
my_turtle.setheading(0) # Face right
for _ in range(3):
my_turtle.forward(size)
my_turtle.left(120)
my_turtle.penup()
3. How to call your drawing functions:
import turtle
my_artist = turtle.Turtle()
# Call the square drawing function
draw_square(my_artist, -50, 50, 30)
# Call the triangle drawing function
draw_triangle(my_artist, 50, -50, 40)
4. Setting up your drawing pen (Turtle):
import turtle
my_pen = turtle.Turtle()
my_pen.hideturtle() # Make it invisible
my_pen.speed(0) # Make it super fast!
Now, let's run the tests again to see if your code works.
Run this command in your terminal again:
pytest module-1.1/blueprint-7/quest-40
What you should see:
test_draw_landmark_type_Atest_draw_landmark_type_Btest_draw_all_landmarks_calls_sub_functionstest_draw_all_landmarks_turtle_integration# Python Fundamentals Refresher
## Functions with Parameters
Functions are blocks of reusable code. Parameters are like placeholders for values that a function needs to do its job.
* **Defining a function:**
```python
def greet(name: str, greeting: str):
# Function code uses name and greeting
print(f"{greeting}, {name}!")
```
* **Calling a function:**
```python
greet("Alice", "Hello")
# Output: Hello, Alice!
```
* **Formatting Strings (f-strings):**
A convenient way to embed expressions inside string literals.
* `f"{variable}"`: Inserts the value of `variable`.
* `f"{float_variable:.2f}"`: Formats a floating-point number to two decimal places.
## Looping with `range()`
`for` loops are used to repeat a block of code multiple times. `range()` generates a sequence of numbers.
* **Basic loop:**
```python
for i in range(3): # i will be 0, 1, 2
print(i)
# Output:
# 0
# 1
# 2
```
* **Using the loop variable for numbered lists:**
`range(len(my_list))` iterates through indices of a list.
```python
items = ["Apple", "Banana", "Cherry"]
for i in range(len(items)):
# i starts at 0, so add 1 for 1-based numbering
print(f"{i + 1}. {items[i]}")
# Output:
# 1. Apple
# 2. Banana
# 3. Cherry
```
## Running Scripts
The `if __name__ == "__main__":` block:
Code inside this block only runs when the script is executed directly (e.g., `python your_script.py`), not when it's imported as a module into another script.
```python
def setup():
print("Setting up...")
def run_program():
print("Running program logic...")
if __name__ == "__main__":
print("Script is being run directly.")
setup()
run_program()
The turtle module draws on a window called the "screen".
import turtle
screen = turtle.Screen()
screen.setup(width=600, height=400) # Set window dimensions
screen.bgcolor("lightblue") # Use color names or hex codes
screen.tracer(0) # Turn off updates
# ... drawing code ...
screen.update() # Show the drawing
screen.tracer(1) # Turn updates back on (optional, often done implicitly by done())
turtle.done() # Or screen.mainloop()
The "turtle" is the cursor that draws on the screen. You can have multiple turtles.
artist = turtle.Turtle()
artist.hideturtle()
artist.speed(0) # Fastest
artist.speed(5) # Medium speed
artist.color("red") # Sets both pen and fill color
artist.pencolor("blue") # Sets only pen color
artist.fillcolor("green")# Sets only fill color
artist.pensize(3) # Set pen thickness to 3 pixels
artist.penup()
artist.pendown()
Commands to move the turtle and draw lines or shapes. The screen's center is (0, 0).
artist.goto(100, 50) # Move to x=100, y=50
artist.forward(100) # Move 100 units forward
artist.backward(50) # Move 50 units backward
artist.left(90) # Turn left by 90 degrees
artist.right(45) # Turn right by 45 degrees
artist.setheading(0) # Set direction to 0 degrees (East)
# 0: East, 90: North, 180: West, 270: South
# Assuming pen is down and turtle is at a corner facing along an edge
side = 50
for _ in range(4):
artist.forward(side)
artist.left(90)
radius = 30
artist.circle(radius)
Draw shapes that are filled with a solid color.
fillcolor() or the color() command (which sets both pen and fill).
artist.fillcolor("blue")
begin_fill() before drawing the shape, and end_fill() after the shape is complete.
artist.fillcolor("yellow")
artist.begin_fill()
# ... drawing commands for the shape (e.g., square, circle, polygon) ...
artist.end_fill()
Organize your drawing code into functions for reusability.
def draw_dot_at(t, x, y, dot_color, dot_size):
t.penup()
t.goto(x, y)
t.pendown()
t.dot(dot_size, dot_color) # Draws a filled circle
my_turtle = turtle.Turtle()
draw_dot_at(my_turtle, 100, 100, "purple", 20) # Draw a purple dot
draw_dot_at(my_turtle, -50, 0, "orange", 10) # Draw an orange dot
Use loops to draw the same shape multiple times at different locations or with variations.
positions = [(100, 100), (-50, 0), (0, -150)]
my_turtle = turtle.Turtle()
my_turtle.speed(0) # Draw fast
for pos_x, pos_y in positions:
# Call a drawing function for each position
draw_dot_at(my_turtle, pos_x, pos_y, "green", 15)
my_turtle = turtle.Turtle()
my_turtle.speed(0)
for i in range(5): # Draw 5 circles
x = -200 + i * 100 # Space circles 100 units apart horizontally
y = 0
my_turtle.penup()
my_turtle.goto(x, y - 20) # Position for circle bottom (radius 20)
my_turtle.pendown()
my_turtle.circle(20)
Use the write() method to display text on the canvas.
artist.penup()
artist.goto(0, 150) # Move to position for text
artist.color("black") # Set text color
artist.write("My Map Title", align="center", font=("Arial", 16, "bold"))
write() parameters:
arg: The string to write.move (optional, boolean): If True, the turtle moves to the end of the text. Default is False.align (optional, string): Alignment of the text relative to the turtle's position ("left", "center", or "right"). Default is "left".font (optional, tuple): A tuple (name, size, style). name is a font family string (e.g., "Arial", "Courier", "Times New Roman"). size is an integer font height. style is a string ("normal", "bold", "italic").