We will write a Python program that uses a special drawing tool called 'Turtle'. Our goal is to make a light blue drawing screen and then draw a dark gray box around the edges. This box will be the border for our map!
Imagine drawing a picture on a piece of paper. First, you pick the paper color (light blue), and then you draw a frame around it (dark gray box). That's what we're doing with code!
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-10
What you should see:
test_setup_map_canvasNow, let's write our Python code in main.py! We need to set up our drawing screen and then draw a border around it.
Here are some helpful code examples:
1. Setting up your drawing screen:
import turtle
screen = turtle.Screen()
screen.setup(width=600, height=400) # Set the size of your drawing area
screen.bgcolor("lightblue") # Set the background color
2. Making a drawing pen (turtle):
my_pen = turtle.Turtle() # Create a new pen
my_pen.hideturtle() # Make the pen invisible
my_pen.speed(0) # Make the pen draw super fast!
my_pen.color("darkgray") # Set the pen color
my_pen.pensize(3) # Make the line thick
3. Moving your pen without drawing:
my_pen.penup() # Lift the pen up (no drawing)
my_pen.goto(50, 50) # Move to a new spot (like picking up your pencil and moving it)
my_pen.pendown() # Put the pen down (ready to draw)
4. Drawing lines by moving:
my_pen.forward(100) # Draw a line forward
my_pen.right(90) # Turn right
my_pen.goto(100, 0) # Go to a specific spot, drawing a line
5. Example of drawing a simple square:
# This is just an example, not for your border!
square_pen = turtle.Turtle()
square_pen.color("blue")
square_pen.pensize(2)
for _ in range(4):
square_pen.forward(50)
square_pen.left(90)
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-10
What you should see:
test_setup_map_canvas# 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").