Let's begin by reviewing our objective.
Our goal is to create a Python script that defines and calls a function draw_landmark_A(x, y, color) to draw a simple representation of one landmark (e.g., a filled circle) at specified (x, y) coordinates with a given color using Turtle.
Next, we'll run pytest to see the failing tests. This confirms the engineering specification we need to meet.
Run the tests in your terminal:
pytest
Test Results:
test_draw_landmark_A_calls_turtle_correctlyNow, let's build the solution by following the TODO comments in the skeleton code (main.py).
With the code in place, let's run the tests again to validate our work.
Run the tests in your terminal:
pytest
Test Results:
test_draw_landmark_A_calls_turtle_correctly
All tests passed!# 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").