We will write a Python program that uses our special drawing tool, 'Turtle', to draw a simple shape, like a filled circle. This circle will be our 'landmark'! We will tell the Turtle exactly where to draw it (using x and y numbers) and what color it should be.
This helps us learn how to make our Turtle draw specific shapes at exact places with different colors!
Here's what a filled circle drawn by Turtle looks 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-20
What you should see:
test_draw_landmark_A_calls_turtle_correctlyNow, let's write our Python code in main.py! You'll be working inside the draw_landmark_A function. Remember, we want to draw a filled circle at a specific spot with a certain color.
Here are some helpful code examples:
1. How to make a function that takes information:
def draw_shape(x_pos, y_pos, shape_color):
# Your drawing code goes here
print(f"Drawing a shape at ({x_pos}, {y_pos}) with color {shape_color}")
draw_shape(10, 20, "red")
2. Moving your pen without drawing:
import turtle
my_pen = turtle.Turtle()
my_pen.penup() # Lift the pen up (no drawing)
my_pen.goto(30, 40) # Move to a new spot
my_pen.pendown() # Put the pen down (ready to draw)
3. Setting color and filling shapes:
import turtle
my_pen = turtle.Turtle()
my_pen.color("green") # Set the color
my_pen.begin_fill() # Start filling
my_pen.circle(25) # Draw your shape (e.g., a circle)
my_pen.end_fill() # Stop filling and fill the shape
4. Drawing a circle:
import turtle
my_pen = turtle.Turtle()
my_pen.circle(50) # Draws a circle with radius 50
5. Lifting the pen after drawing:
import turtle
my_pen = turtle.Turtle()
# ... drawing code ...
my_pen.penup() # Lift the pen after you're done drawing
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-20
What you should see:
test_draw_landmark_A_calls_turtle_correctly# 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").