We will write a Python program that draws many little houses (landmarks) on our map! We will make a special helper that knows how to draw one house. Then, we will use a 'loop' to tell our helper to draw three houses in different spots on the map.
This helps us learn how to draw the same thing many times without writing the same code over and over!
Here's what your map should look like with the houses:
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-30
What you should see:
test_populate_neighborhood_loop_and_callstest_draw_simple_landmark_drawing_logicNow, let's write our Python code in main.py! You'll be working on two main parts:
draw_simple_landmark function: This function will draw one house (a blue square with a red triangle roof) at a specific spot.populate_neighborhood function: This function will use a loop to call draw_simple_landmark many times to draw all the houses.Here are some helpful code examples:
1. How to make a function that draws with a Turtle:
import turtle
def draw_star(my_turtle, x, y, size):
my_turtle.penup()
my_turtle.goto(x, y)
my_turtle.pendown()
my_turtle.color("gold")
my_turtle.begin_fill()
for _ in range(5):
my_turtle.forward(size)
my_turtle.right(144)
my_turtle.end_fill()
# You would call it like this:
# artist = turtle.Turtle()
# draw_star(artist, 0, 0, 50)
2. Drawing a square:
import turtle
my_pen = turtle.Turtle()
my_pen.color("blue")
my_pen.begin_fill()
for _ in range(4):
my_pen.forward(40)
my_pen.left(90)
my_pen.end_fill()
3. Drawing a triangle:
import turtle
my_pen = turtle.Turtle()
my_pen.color("green")
my_pen.begin_fill()
my_pen.goto(0, 0) # Start point
my_pen.goto(50, 100) # Peak
my_pen.goto(100, 0) # End point
my_pen.goto(0, 0) # Back to start to close
my_pen.end_fill()
4. Using a for loop to draw many things:
import turtle
my_artist = turtle.Turtle()
spots = [(-100, 0), (0, 50), (100, -20)]
for x_coord, y_coord in spots:
my_artist.penup()
my_artist.goto(x_coord, y_coord)
my_artist.pendown()
my_artist.dot(10, "purple") # Draw a dot at each spot
5. 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!
my_pen.penup() # Lift pen up
my_pen.pendown() # Put pen down
my_pen.color("red") # Set color
my_pen.begin_fill() # Start filling
my_pen.end_fill() # Stop filling
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-30
What you should see:
test_populate_neighborhood_loop_and_callstest_draw_simple_landmark_drawing_logic# 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").