Create cool projects in Python to sharpen your coding skills. 

Welcome to Create & Learn Python Skill Builder! 

Whey you learn a new programming language like Python, it is very important to practice by creating projects. This Python Skill Builder has been created to help students accomplish exactly that! Build fun Python projects such as puzzles, games, digital cards, and more. 

If you are taking our [Python for AI](https://www.create-learn.us/coding-for-kids/python?utm_source=site&utm_campaign=psbuilder) course, you can use this Python Skill Builder as a companion tool for the classes. 

New to Python or want to learn more about? Check out our  [Python for AI](https://www.create-learn.us/coding-for-kids/python?utm_source=site&utm_campaign=psbuilder#classes) class where you will learn a wide range of essential Python concepts while making fun projects. Our classes are up to 5 students only and is [free to get started](https://www.create-learn.us/coding-for-kids/python?utm_source=site&utm_campaign=psbuilder#python_0). 

If you have signed up for Python for AI 1-4, your class registration comes with 6 months of free access to Python Skill Builder. Just sign in to your account, the access will be enabled automatically.  

Welcome to Python Skill Builder

Founded by a former Google Product Director and an early Uber engineer, Create & Learn offers top quality live online computer science classes to K-12 students. With more than 40 courses, our curriculum was co-designed with experts from Google, Code.org, and more. and covers a rich set of topics such as coding, AI, robotics, digital design, and cloud computing.

We offer quality experiences that you can trust!

We're the only [5 stars kids coding program](https://www.google.com/search?q=create+%26+learn+reviews) at scale based on Facebook ratings and have served over 100K students. We have won the [Facebook (Meta) Engineer for the Week Impact award](https://engineerfortheweek.fb.com/impact/) three times and have been featured by prestigious education programs such as[ Minecraft Education](https://education.minecraft.net/en-us/blog/the-why-and-how-building-full-coding-curriculum-using-minecraft-), Roblox Education, and code.org. Because of our top quality, we are also partners of Stride, Bright Horizons, and Meta.

Check out this video to learn more about our philosophy and what our live virtual classes look like.

About Create & Learn

### How to use the Python Skill Builder

Each page has a new project for you to code and the project maps to one of our Python for AI sessions. You will see a Trinket Window on the right hand side of the screen. You can code directly in that window just like how you do it on the [Trinket.io](https://trinket.io/) web site. 

As shown in the gif below, type your code in the window, click Run ► button to run, click the pen icon to edit the code. Click on the right arrow on the top right to sign in to Trinket website, if not already, so you can save your project. 

CPT2309142219-527x206.gif

###  AI Coach

You will be learning together with an AI Coach powered by ChatGPT (!), like the one shown in this image. 

Screen Shot 2023-09-14 at 10.38.02 PM.png

We have divided each project into several steps. For each step, try to code it yourself. If you are not sure how to do it, or run into a bug, you may click **Ask a Question** button  and then type your question in the chat window. Once you finished the step, click **Yes, I got it** to move on to the next step. 

That's it! Are you ready to get started?

Click the **Next** button to go to the first project.



Getting Started

Are you new to Python? Have you learned basics of Python syntax and Python Turtle? If not, join our [free live  online Python intro](https://www.create-learn.us/coding-for-kids/python?utm_source=site&utm_campaign=skillbuilder) class with one of our awesome teachers, or start learning right away by going over the [Python Intro Tutorial together with an AI Learning Coach](https://www.create-learn.us/quickstart/python/1?utm_source=site&utm_campaign=skillbuilder). The live online class and AI guided tutorial covers similar content. 

The next two projects under this section assume you know what we cover in the[ Free Python Intro class](https://www.create-learn.us/coding-for-kids/python?utm_source=site&utm_campaign=skillbuilder#python_0), i.e. basics of Python and Python Turtle syntax. 

Give them a try and have fun!

Want to learn more about Python? Join our [Python for AI](https://www.create-learn.us/coding-for-kids/python?utm_source=site&utm_campaign=skillbuilder#classes) class to learn the essential elements of Python coding, with a focus on the aspects of Python that are most relevant to Artificial Intelligence. Our regular courses are all taught live online by experienced teachers with a small group of up to 5 students only. You will learn a lot, have fun, and create with code!

Your First Python Projects (Free)

# Rainbow Circle

Draw a circle with multiple colors like the one below using what you learned from the [Python intro class](https://www.create-learn.us/coding-for-kids/python?utm_source=site&utm_campaign=psbuilder#python_0). Sign up to[ join the Free Python Intro class](https://www.create-learn.us/coding-for-kids/python?utm_source=site&utm_campaign=psbuilder#python_0), If you haven't done it already, or review what we learned in class by going over this [self-guided tutorial](https://www.create-learn.us/quickstart/python/1?pageId=1).


Rainbow Circle.gif

### Step 1 - Draw one piece of arc using 1 color

**Hint**: consider using the following methods:

 import turtle
 turtle.color("color name")
 turtle.circle(r, x)      # draw a arc with radius r and angle x


### Step 2 - Draw the remaining five arcs 

Change to a different color to draw each arc. You can find all the color supported by Python Turtle on this page [https://trinket.io/docs/colors](link).



### Step 3 - Adjust the thickness of the line

**Hint**: consider using the following method

turtle.pensize(x)


Python Intro - Rainbow

# Ninja 

Draw a ninja stick figure like the one below. 

Ninja Figure.gif

### Step 1: Draw head and arms

Consider using the following methods:
 
turtle.penup()
turtle.pendown()
turtle.goto(x,y)
turtle.circle(r)
turtle.forward(x)
turtle.left(x)
turtle.right(x)

**Hint**: 
- Remember you need to import turtle module first before using it.  
- forward (-20) move turtle to the opposite direction of forward (20). This might be an easier way to move your turtle back to where it was than using goto().

### Step 2: Draw body and legs

The idea is very similar to above. Use goto(x, y) to move turtle to the right spot before drawing the body. You might need to consider moving the starting point of the whole stick figure up, if you need more space for legs at the bottom. 


### Step 3: Adjust color and line thickness.  

Adjust your stick figure using turtle.pensize() and turtle.pencolor( ). 


Python Intro - Ninja

Projects in this section maps to [**Unit 1 of our Python for AI course**](https://www.create-learn.us/coding-for-kids/python?utm_source=site&utm_campaign=skillbuilder#python_1). 

Here are some of the key concepts we cover:
- Basic Python syntax
- Data types
- Conditional (if statement)
- Logic and math operations
- Loops 
- Functions
- Built-in data structures

Projects in this section assume you know the concepts above already. If you are new to Python, join our [Python for AI](https://www.create-learn.us/coding-for-kids/python?utm_source=site&utm_campaign=skillbuilder#classes) class to learn the essential elements of Python coding. Our regular courses are all taught live online by experienced teachers with a small group of up to 5 students only. You will learn a lot and have fun!

Python - Unit 1

# Music Recommender

Create a music recommender program, like the one shown below, that asks the user what mood they're in or what activity they're doing, such as studying, exercising, or relaxing. Suggest a song or genre of music based on their input. 

CPT2312091548-369x285.gif

## Step 1: Get the user's input

✅ **Do This:** First, ask the user what activity they are doing right now -- studying, exercising, or relaxing.

💡**Hint:** You'll need to use the `input()` function to do this! Don't forget to save the user's answer into a variable.

 

<details>
<summary>I forgot what a variable is!</summary>
 
Imagine you have a toy box. You can put different toys inside the box, take them out, and replace them with other toys. In the world of computer programming, a variable is like that toy box. It's a named container where you can store information, like numbers, words, or even lists of things. Just like how you label your toy box with a name ("My Toys"), in programming, you give your variable a name so you can find and use the information inside it later. And just as you can change the toys in your toy box, you can also change what's stored in a variable anytime you want!
</details>

## Step 2: Make a recommendation if their answer matches the first choice

Next, we need to check if the user selected our first option. For example, since our first option is `"studying"`, we want to check if the variable containing the user's response also contains `"studying"`.

✅ **Do This:** Write an `if` statement to check if the user's response is the same as your first option. If this is `True`, create a variable called `recommendation` and set it to the song or genre or music you want to recommend for that activity.

## Step 3: Make a recommendation if their answer matches the other choices

Now, we need to check if the user one of our other options. For example, since one of our other options is `"exercising"`, we want to check if the variable containing the user's response also contains `"exercising"`.

✅ **Do This:** Write an `elif` statement to check if the user's response is the same as `"exercising"`. If this is `True`, create a variable called `recommendation` and set it to the song or genre or music you want to recommend for that activity.

✅ **Do This:** Write an `elif` statement to check if the user's response is the same as `"relaxing"`. If this is `True`, create a variable called `recommendation` and set it to the song or genre or music you want to recommend for that activity.

💡 **Hint:** You'll need to have separate `elif` statements for each additional activity. So if you have three activities you're checking for, you'll have an `if` statement for the first activity, and two `elif` statements for the other two activities.

## Step 4: Let the user know there is no recommendation if their activity doesn't match our options

If the user's activity doesn't match any of our options, we want to let the user know that we don't have a recommendation for that activity. We can use an `else` statement to set our `recommendation` variable to an appropriate message if the user's activity doesn't match.

✅ **Do This:** Write an `else` statement that sets a variable called `recommendation` to `"Sorry, I don't have a recommendation for that activity."`

## Step 5: Show the result to the user

Let's tell the user the result!

✅ **Do This:** Print a statement that contains the activity the user entered and the genre of music or song that you recommend for that activity. For example, `"Since you are studying, I recommend listening to: classical music or lo-fi beats"`

💡 **Hint:** Use the `print()` function to print the result. Remember, you'll need to use the `+` operator to combine strings with variables.

## 🌟 Here is one solution for this project.

Use this as a reference to help you finish your code if you need it.

Music Recommender

# **Triangle Troubles**
Are triangles giving you trouble? Create this fun project to find out if a triangle is valid, the perimeter of a triangle, and its type based on the length of its sides. 

ezgif.com-optimize.gif

### **Key Concepts Review**
- **User Input:** Get information from the user with `input()`.
- **Variables:** Store information you are going to use later in your program.
- **String to Integer Conversion:** To convert a string to an integer, use int().
- **Conditionals:** Perform an action `if` some condition is `True` or another if it is `False`.

### **Let's Get Started!**
A triangle is a basic shape with three sides.

Group 4.png

According to the length of their sides, triangles can be considered:
- **Equilateral**: if `3` sides are the same length
- **Isosceles:** if `2` sides are the same length
- **Scalene:** if all sides are different



Let's get started by asking the user's input and evaluating the triangle. 

### **Step 1 - User's Input**

**Goal**: Ask the user the length of the three sides.

**Hints**:
- For each side of the triangle ask the user to enter its length using `input()`. Don't forget to save it into a variable!
- Convert the user's input to a number by using `int()`.  

For example:
> `side1 = int(input("Enter the length of the first side: "))`


### **Step 2 - Check if the Triangle is Valid**

**Goal**: Check if a triangle is valid based on its sides.

**Hints**:
-  A triangle is valid if the sum of any two sides is greater than the third side. 
-  Use `if` statements to check if a condition is true.
-  You can create more complex conditions with `and` and `or`.
-  Print a message to the user letting them know if the triangle was valid.


### **Step 3 - Triangle Type and Perimeter**

**Goal**: For valid triangles, let's calculate the perimeter and determine its type.

**Hints**:
-  If the triangle is valid:
    -  Calculate the perimeter by adding all three sides.
    -  Check its type - Equilateral, Isosceles, or Scalene by comparing the length of the sides.
    -  Print the results.


### **Step 4 - We are finished!**
You've just created your own triangle solver! 

See the complete source code below:

🌟 Want to play with the code yourself? **[Remix it here](https://trinket.io/library/trinkets/ba828919b6)**.

### **Ready for a challenge?**
Calculate the area of the triangle given its three sides.
- You will need to calculate the semi-perimeter, which is `perimeter / 2`
- Use Heron's formula to calculate the area, where `s` is the semi-perimeter.

Triangle Solver

# Monster Battle Arena

Create a game that has the user choose a monster, like dragon, griffin, or unicorn, then have the computer select a random monster. Determine the winner of the game based on the following rules:

* Dragon beats Griffin
* Griffin beats Unicorn
* Unicorn beats Dragon

## Step 1: Get the user's input

✅ **Do This:** First, ask the user to choose which monster they want to play with -- Dragon, Griffin, or Unicorn.

💡 **Hint:** You'll need to use the `input()` function to do this! Don't forget to save the user's answer into a variable.

 

<details>
<summary>I forgot what a variable is!</summary>
 
Imagine you have a toy box. You can put different toys inside the box, take them out, and replace them with other toys. In the world of computer programming, a variable is like that toy box. It's a named container where you can store information, like numbers, words, or even lists of things. Just like how you label your toy box with a name ("My Toys"), in programming, you give your variable a name so you can find and use the information inside it later. And just as you can change the toys in your toy box, you can also change what's stored in a variable anytime you want!
</details>

## Step 2: Get a random monster for the computer

Next, we need to get a random monster for the computer. We'll do this by generating a random number between 1 and 3. This way we can:

* Assign `"Dragon"` to the computer if the random number is `1`
* Assign `"Griffin"` to the computer if the random number is `2`
* Assign `"Unicorn"` to the computer if the random number is `3`

✅ **Do This:** Use `random.randint()` to generate a random number between 1 and 3, and store the result in a variable called `bot_choice`.

✅ **Do This:** Use `if/elif/else` to check the random number and assign a monster to bot.
* If `bot_choice` is `1`, create a variable called `bot` and set it to `"Dragon"`.
* If `bot_choice` is `2`, create a variable called `bot` and set it to `"Griffin"`.
* Otherwise, create a variable called `bot` and set it to `"Unicorn"`.

💡 **Hint:** You'll need to import the `random` module as the first line of your program.

<details>
<summary>I forgot how to use the random module.</summary>
 
Before you can use the <code>random</code> module, you need to tell Python that you want to use it in your program. This is called importing the module. Here's how you do it:
 
<code>import random</code>
 
Now, let's say you want Python to pick a random number between 1 and 10 for you. Here's how you would do it:
 
<code>random_number = random.randint(1, 10)</code>
 
This will make Python pick a number between 1 and 10 (including both 1 and 10) and store it in a variable called <code>random_number</code>. You can then print or use that number any way you like!
</details>

## Step 3: Print the monsters for the user and the computer

We need to let the user know what monsters have been chosen.

✅ **Do This:** Print the monster that the user chose and the monster that the computer has.

💡 **Hint:** Use the `print()` function to print the result. Remember, you'll need to use the `+` operator to combine strings with variables.

## Step 4: Determine the winner

Now, let's check who won! Remember, the rules are:

* Dragon beats Griffin
* Griffin beats Unicorn
* Unicorn beats Dragon

✅ **Do This:** Use `if/elif/else` to compare the user's monster with the bot's monster and print who won.

💡 **Hint:** You'll need to use `and` to check the user's monster and the bot's monster. For example, if we want to check if the user's monster is `"Dragon"` and the bot's monster is `"Griffin"`, then we would write:

```
user == "Dragon" and bot == "Griffin"
```

Don't forget to check if there's a tie!

## Step 5: Let the user keep playing

Finally, we want to let the user keep playing and choose another monster. We can do this using a `while` loop to repeat the game logic.

✅ **Do This:** Move your game code inside a `while` loop that infinitely repeats.

Monster Battle Arena

# **Turtle Race**
Join a fun turtle race where you control the pace, press Enter to make the turtles move, and cheer for your favorite as they dash towards the finish line!

ezgif.com-optimize (1).gif

### **Key Concepts Review**
- **User Input:** Get information from the user with `input()`.
- **Variables:** Store information you are going to use later in your program.
- **Conditionals:** Perform an action `if` some condition is `True` or another if it is `False`.
- **Loops:** Repeat instructions `while` a condition is `True`.
- **Import:** Bring additional functionality into your project. 

### **Let's Get Started!**
It's race day and we will have `3` turtles racing against each other.  The user controls the pace of the race by hitting the Enter key to keep the turtles moving. Each turtle will move a random amount and the first turtle to reach the finish line wins!

### **Step 1 - Setting up the Turtles**

**Goal**: Create **three** turtles of different colors.

**Hints**:
- Import the `turtle` module.
- Create three turtles, each with a different color. For example, the code below will create a turtle, set its color, and make sure it does not draw as it moves:

- The turtles must not overlap. You can use `goto()` to send a turtle to a specific location. For example:

- Try sending the turtles to the following locations:
    - Turtle 1 ⟶ `(-100, 50)`
    - Turtle 2 ⟶ `(-100, 0)`
    - Turtle 3 ⟶ `(-100, -50)`

### **Step 2 - Setting Up the Finish Line**

**Goal**: Create the finish line. 

**Hints**:
-  Another turtle needs to be created for the finish line.
-  The line is a vertical post drawn by the extra turtle.
-  The line should be start at `(100, 80)` and go to `(100, -80)`
-  This means that `x=100` is the finish line!
-  Don't forget to use `penup()` and `pendown()`.

### **Step 3 - Run Turtles, Run!**

**Goal**: Make the turtles move a random amount when the user hits `Enter`.

**Hints**:
-  Ask the user to press `Enter` to move the turtles using `input()`
-  Each turtle should move a random amount. Generate random numbers using `random.randint()`. Try numbers between 10 and 40.
-  A turtle can move with the `forward()` method. For example, to move a turtle 20 steps we could do:


### **Step 4 - Check who won!**

**Goal**: Check if any turtle has reached the finish line and if so, determine the winner!

**Hints**:
-  Get the `x` coordinate of each turtle. To get the coordinate you can use:

-  If any of the turtles are past the `x=100` position (the finish line), then we have a winner!
-  Determine the winner by checking which one of the turtles was the one to cross the finish line.

### **Step 5 - Game Loop**

**Goal**: Chances are no turtle won on the first round, so we must keep the turtles moving until there is a winner.

**Hints**:
- Use a `while` loop to repeat the process created in Steps #3 and #4.
- You may use `break` to stop the loop at any point.

### **Step 6 - We are finished!**
You've just created your own high-stakes turtle racing game!

See the complete source code below:

🌟 Want to play with the code yourself? **[Remix it here](https://trinket.io/python/2f3bda1d10)**.

Turtle Race  

# Personalized Greeting Cards

Create a program that lets users design their own virtual greeting card, with options for different occasions like birthdays and thank you notes. Users can choose the type of card, input a name or message, and see their customized card on the screen.

 

## Step 1: Explore the starter code

✅ **Do This:** Take a look at the starter code provided. Notice how the `turtle` module is imported and a screen and turtle object are set up for you. The turtle screen is set up to be 400 pixels wide and 400 pixels tall, and the turtle object, named `pen`, is hidden from view since it won't be drawing all the time.

💡 **Hint:** Understanding the starter code is a crucial step, as it sets the foundation for your program. If you have questions about what a specific part of the code does, try asking the AI Coach 👇🏽

## Step 2: Draw the card

✅ **Do This:** First, let's draw a white rectangle on the screen. This rectangle will act as the base of your greeting card.

1. Move the `pen` to `(-150, -100)`.
2. Use `pen.fillcolor("white")` and `pen.begin_fill()` before drawing the card to set the color of the card to `"white"` (or a different color of your choice).
3. Use a `for` loop to perform the following steps twice:
 * Move forward `300`
 * Turn left `90`
 * Move forward `200`
 * Turn left `90`
4. Use `pen.end_fill()` to stop filling shapes with the color you set.

💡 **Hint:** You can use the following functions to move the pen around and draw. Remember to also use `pen.penup()` to move the pen without drawing.
* `pen.goto(x, y)`
* `pen.pendown()`
* `pen.forward(distance)`
* `pen.left(angle)`

✅ **Do This:** Now that you have drawn the card, move your code into a function called `drawcard()`. Outside of the function at the end of your program, call `drawcard()` to make sure everything still works.

## Step 3: Get user input for a birthday card

Before we create our birthday card function, let's ask the user for some information that we'll need.

***Note:*** *You can comment out or remove the call to the `drawcard()` function that you have at the end of the program.*

✅ **Do This:** First, let's start by letting the user know what the options are. Use `print()` to print the following:

```
1. Birthday Card
2. Thank You Card
3. Exit
```

✅ **Do This:** Get the user's choice using `input()` and store it into a variable called `choice`.

✅ **Do This:** If the user selects option `1`, ask the user for the name for the birthday card.

💡 **Hint:** The `input()` function gets the user's response as a string. Keep this in mind when checking if the user's response is `1`!

## Step 4: Write the birthday card function

✅ **Do This:** Create a function named `birthdaycard(name)` that draws a card and writes a birthday message on it. Make sure to include the person's name in the message.
1. Start by clearing the screen using the provided `clearscreen()` function.
2. Call the `drawcard()` function to draw the base of the card.
3. Move the `pen` to `(0, 20)` and set the `pen.color("black")`.
4. Use `pen.write()` to write a birthday message on the card. For example:

```
pen.write("Happy Birthday " + name + "!", align="center", font=("Arial", 12, "bold"))
```

## Step 5: Show the birthday card

✅ **Do This:** Add a call to the `birthdaycard()` function after you get the user's input with the name they provide.

## Step 6: Get user input for a thank you card

Before we create our thank you card function, let's add some `elif` statements for the other options the user can select.

✅ **Do This:** Add an `elif` branch that checks if the user chose `"2"`. If they do:
* Prompt the user for a name to show on the thank you card and store it in a variable called `name`.
* Prompt the user for the message to show on the thank you card and store it in a variable called `message`.

✅ **Do This:** Add another `elif` branch that checks if the user chose `"3"`. If they do, print a goodbye message.

✅ **Do This:** Add an `else` branch that lets the user know they entered an invalid option.

## Step 7: Write the thank you card function

✅ **Do This:** Create a function called `thankyoucard(name, message)` that draws a card and writes a thank you message on it. This message should include the person's name and a custom message.
1. Start by clearing the screen using the provided `clearscreen()` function.
2. Call the `drawcard()` function to draw the base of the card.
3. Move the `pen` to `(0, 20)` and set the `pen.color("black")`.
4. Use `pen.write()` to write a message on the card thanking the person by name. For example:

```
pen.write("Thank you " + name + "!", align="center", font=("Arial", 12, "bold"))
```

5. Move then `pen` back to `(0, 20)` and set the `pen.color("black")`.
6. Use `pen.write()` to write the message provided by the user. For example:

```
pen.write(message, align="center", font=("Arial", 12))
```

## Step 8: Show the thank you card

✅ **Do This:** If the user chose to create a thank you card, call the `thankyoucard()` function with the provided name and message to show the card.

## Step 9: Incorporate a loop for multiple cards

✅ **Do This:** Wrap your code in a `while` loop to allow users to create multiple cards without restarting the program.

💡 **Hint:** You may want to add a `break` after saying goodbye to the user when they choose to exit so it exits the loop.

## (Optional) Step 10: Add extra features!

✅ **Do This:** If you're feeling creative, try adding more card types, designs, or even animations!

💡 **Hint:** Explore the `turtle` module's documentation to find more drawing and animation features you can use.

Greeting Cards

# **Cave Escape**
Navigate through a mysterious cave filled with hidden treasures and unexpected surprises. Navigate the twists and turns, avoid lava pits, and find the exit! Join the adventure and see if you have what it takes to become the ultimate cave explorer!


cave-escape-walkthrough.gif

### **Key Concepts Review**
- **User Input:** Get information from the user with `input()`.
- **Random:** We `import random` to create random numbers.
- **Functions:** Organize and avoid rewriting blocks of code. 
- **Loops:** Repeat instructions a certain number of times.

### **Let's Get Started!**
You're in a dark cave. You start at a white circle in the bottom left corner, and you can only move to the right or go up. The exit is at top right. 



Group 3.png

But here is twist! Along the way, there will be surprises. You might stumble upon dangerous lava pits that you need to avoid, or you could discover extra lives to help you on your quest. Reach the red flag at the very top and exit the cave! 

**You start with 3 lives so be careful!**

### **Step 1 - Move Around**

**Goal**: Ask the user where they want to move. Use `R` for right and `U` for moving up.

**Hints**:
- Ask where the user wants to move with `input()`. 
- Keep track of the location `(x, y)` of the user with variables. 
- As they move, let the user know where they are in the cave by printing their position.


### **Step 2 - Watch Your Step**

**Goal**: When we move, we might find surprises like lava or extra lives. Create a function to generate a random number each time that maps to different events. Check what luck had in store for the player!

**Hints**:
-   Use the `def` keyword to create a function. 
-   Use `random.randint()` to generate a random numbers and assign events to them. For example:
    - `1` ⟶ for extra life
    - `2` ⟶ for lava
    - Anything else is just a safe pass.
-  Use `print()` to let the user know what happened!
-  The function should:
    -  `return -1` when the user lost a life
    -  `return 1` when the user gained a life
    -  `return 0` when it was a safe move.

### **Step 3 - Update User's Lives**

**Goal**: update player life based on the results of the previous function.

**Hints**:
- If your function returns `-1`, `1`, or `0`, you can simply add this to the variable that keeps track of the user's lives.

### **Step 4 - Game Loop**

**Goal**: Let the user keep moving until they find the exit or they run out of lives. 

**Hints**:
- Use a `while` loop to repeat the process if the user hasn't found the exit and still has lives left.
- Congratulate them if they reached the exit and let them know if they lost.


### **Step 5 - We are finished!**
You've just created your own Cave Escape! Have fun playing it! 

See the complete source code below:

🌟 Want to play with the code yourself? **[Remix it here](https://trinket.io/python/a3b0c08c53)**.

### **Optional - Ready for an extra challenge?**
Make sure that the user cannot move outside the limits of the cave:
- Once the user has reached the top of the cave (y = 4), it should not be able to keep moving up. 
- Once the user has reached the rightmost point of the cave (x = 4), it should not be able to keep moving right.

Cave Escape 

# **Slam**
Let's play Slam! A number between 1-6 is chosen as the slam number for each game. Players then take turns to roll 3 dice and try to have each dice match the slam number. One match earns one point, two matches give 5 points, and three matches mean an automatic win! Multiple rounds might be played in a game. Play against the computer and whoever reach 15 points first wins! 

ezgif.com-optimize (2).gif

### **Key Concepts Review**
- **Random:** We import random to create random numbers.
- **Conditionals:** Perform an action `if` some condition is `True`.
- **Loops:** Repeat instructions while a condition is `True`.
- **Functions:** Organize and avoid rewriting blocks of code.

### **Let's Get Started!**
Slam is a three-dice game. Players take turns rolling the 3 dice to match the _slam number_. Points are awarded based on the number of dice that match the slam number:

- **Single-Slam:** One dice matches the slam number (`1` point).
- **Small-Slam:** Two dice match the slam number (`5` points).
- **Grand-Slam**: All three dice match the slam number (`15` points).

Group 9 (1).png

### **Step 1 - Choose slam number**

**Goal**: Ask the user to press `Enter` to start the game and get the random slam number to set up the game.

**Hints**:
- Ask the user to hit `Enter` with `input()`. This starts the game.
- Generate the slam number, a random number between 1 and 6 with `random.randint()`. Print it on the screen to let the player know!
- The slam number remains the same throughout the game!
- The score should start with `0` for the user and the bot.


### **Step 2 - Roll and Slam!**

**Goal**: Create a function that rolls three dice, checks if there is any slam combination, and returns the earned points. 

**Hints**:
- Use the `def` keyword to create a function that has the slam number as a parameter.
- Generate random numbers for the dice. 
- Print the rolled dice values to the screen.
- You can use `if` to check each dice against the slam number and count the score according.
    -  `score 0` when there is No Slam
    -  `score 1` when there is a Single-Slam
    -  `score 5` when there is a Small-Slam
    -  `score 15` when there is a Grand-Slam
- Function should return score


### **Step 3 - Your Turn, Bot's Turn!**

**Goal**: Play and Computer take turns rolling the dice. As the player earns points, add points to their overall score. The first player to reach `15` wins!

**Hints**:
- Print whose player's turn it is.
- Use the function you created in the previous step. Since your function returns the number of points earned in a round, add this to the variable that keeps track of the user's or bot's overall score. 
- The party that reaches `15` points first wins!

### **Step 4 - Game Loop!**

**Goal**: It is unlikely that someone wins in the first round, so keep playing until on side wins!

**Hints**:
- Use a `while` loop to repeat the process if there hasn't been a winner yet!
- You may use `break` to stop a loop from repeating.
- Print who won!

### **Step 5 - We are finished!**
You've just created your own slam game! Test your luck against the computer and become a slam master!

See the complete source code below:

🌟 Want to play with the code yourself? **[Remix it here](https://trinket.io/python/61883a1a2f)**.

Slam Game

# **Lucky Things**

What should you do to get good luck today? Create this fun project, where by entering a number, it will show you which activity will likely bring you good luck today! 🙂


lucky_things.gif

### **Key Concepts Review**

- **Lists:** A way to store multiple items in Python. 
- **String to Integer Conversion:** To convert a string to an integer, use `int()`. 
- **Modulo Operator:** The `%` symbol is used to find the remainder of a division. 
- **Accessing List Elements:** You can access an element in a list by its index, starting from 0. For example, `activities[0]` returns the first element in the list.

### **Let's get started!**

We will create a `list` with several different fun activities that you like. We will then prompt the user for a number. Finally, we will display the lucky activity that corresponds to that number!

### **Step 1 - Setting Up the List of Lucky Things**

**Goal:** Create a `list` containing seven different lucky activities.
**Hints:**

- Use square brackets `[]` to define a `list` in Python. For instance, the list may be called `lucky_things`.
- Each item in your `list` should be a `string` (enclosed in quotes `' '` or `" "` ) representing an activity.

For example, this is a list with two activities:
> `["jump rope for 2 mins", "give mom a hug"]`


### **Step 2 - Asking for User Input**
**Goal:** Prompt the user to enter an integer and store this number.
**Hints:**
- Use `input()` to get the user's input and save it into a variable. 
- Convert the input to an integer using `int()`. 

> For example: 
> `num = int(input("Enter a whole number: "))` 

### **Step 3 - Selecting and Displaying the Lucky Thing**

**Goal:** Use the user's number to find and display the lucky thing for the day.
**Hints:**
- Calculate the remainder of the user's number divided by 7 using the mod operation `%`.  
> For example, if the user's number is stored in `num`, use `num % 7` to get the remainder. If `num = 10`, then `num % 7 = 3`

- Use this remainder as an index to select an item from your `lucky_things` list. List indices start at 0.
> For example: 
> `lucky_things[3]` is the 4th item in the list.

### **Step 4 - We finished!**

We are done with our project! See the complete source code below:

Want to play with the code yourself? **[Remix it here](https://trinket.io/python/78699c40ac)**.

 Lucky Things

# **Numdle: Number Puzzle Adventure**

**Welcome to Numdle!**
Create a four-digit secret code and let the user guess it in 10 tries. After each guess, for each digit in the guess, let user know if they got the right number, but in the wrong place (close match), or if they got both the number and the position right (perfect match)! 


numdle3.gif

### **Key Concepts Review**
- **User Input:** Get information from the user with `input()`.
- **String to Integer Conversion:** To convert a string to an integer, use `int()`.
- **Random:**  `import random` before using random number generator function 
- **Lists:** A way to store multiple items in Python.
- **Accessing List Elements:** You can access an element in a list by its index, starting from 0. For example, `numbers[0]` returns the first element in the list.
- **Loops:** Repeat instructions a certain number of times.

### **Let's Jump In!**
We will create a `list` with four random numbers that the user has to guess. We will then prompt the user for several numbers. Finally, we will tell the user if they got the right number but in the wrong place, or if they got everything right!

### **Step 1 - Create the Secret Code**

**Goal**: Set up a list of four random numbers, each from 0 to 9.
**Hints**:
- You can create a random single digit integer using `random.randint(0, 9)`
- Create your secret list: `secret_numbers = []`.
- You can add items to the list using the `append` method. 
  > 	secret_numbers.append(3)

- Repeat the steps to fill the list with four random numbers using a `for` loop:
  >     for i in range(4):
  >         # code to repeat


### **Step 2 - Get the User's Guess**

**Goal**: Ask the user to enter four numbers separated by a space. 

**Hints**:
-   You can use `input()` to ask for the user's guess.
-   We will use this pattern to transform the user's input into a list of numbers. This is a very common pattern to read multiple input numbers on the same line.
> `user_guesses = [int(x) for x in user_input.split()]`





### **Step 3 - Check for Perfect and Close Matches**

**Goal**: Determine how many digits in the user's guess are correct and in the right position, and how many are correct but in the wrong position. Tell the user how they did and give feedback.

numdle.png

For example, if your guess is 1234, and the secret is 1359, the 1 is a **perfect match** (correct number and correct spot) and 3 is a close match (there is a 3 in the secret number, but it is at a different spot).

**Hints**:
- Use a loop to compare the user's guess with each number in the secret code.
- Use a counter to keep track of the perfect matches and another one for the close ones. 
- To check if a number is in the list you could do something like this:
> 	if (5 in secret_numbers_list):
-  Let the user know how they did. If all four numbers match, congratulate the user, otherwise let them know how many were exactly matched, and how many were close.


### **Step 4 - Game Loop**

**Goal**: Give the user multiple attempts to get the secret code right. Move the code from previous steps into a loop to give them 10 attempts.

**Hints**:
- Allow the user to keep making guesses until they guess the secret code or run out of attempts.
- If the user ran out of attempts, reveal the secret code!

### **We are finished!**
You've just created and played Numdle! See the complete source code below:

🌟 Want to play with the code yourself? **[Remix it here](https://trinket.io/python/f2607628c5)**.

Number Puzzle

Projects in this section maps to [**Unit 2 of our Python for AI course**](https://www.create-learn.us/coding-for-kids/python?utm_source=site&utm_campaign=skillbuilder#python_2). 

We will focus on new concepts covered in Unit 2 and introduce additional variations and functionalities that we didn't cover in class. Some examples are:
 - Lists (arrays)
 - Advance Strings operations
 - Text Files	
 - Dictionary	
 - Matplotlib 

The projects will also continue to review concepts in Unit 1, such as functions, conditional, and loops. 

Projects in this section assume you know the concepts above already. If you are new to Python or only have some basic knowledge, join our [Python for AI](https://www.create-learn.us/coding-for-kids/python?utm_source=site&utm_campaign=skillbuilder#classes) class to learn the essential elements of Python coding. You may be able to start from Unit 2 (skip Unit 1 class), if you have done some basic Python before. Ping us at info@createandlearn.us to see which one might be the best git. Our regular courses are all taught live online by experienced teachers with a small group of up to 5 students only.  

Enjoy!

Python - Unit 2

# **Fortune Cookie Message Generator**

Get to experience the magic of receiving a fortune cookie message tailored to player's current emotion. Just enter if the person is feeling happy or sad and you'll get a fortune message filled with positivity and encouragement! Get ready to smile and laugh!

Fortune-ezgif.com-optimize.gif

### **Key Concepts Review**
- **Random:** We import random to create random numbers.
- **Conditionals:** Perform an action `if` some condition is `True`.
- **Lists:** A way to store multiple items in Python.
- **User Input:** Get information from the user with `input()`.

### **Let's Get Started!**
Get ready to receive a fortune cookie message crafted just for your current mood - whether you are happy or sad, to brighten your day! 🌟

Group 16.png

### **Step 1 - Create Fortune Messages**

In this step, you'll define two lists containing fortune messages. One for when player is happy and one for when player is sad. 

**Goal**: Define the lists of fortune messages.

**Hints**:
- Create two lists: one for happy and one for sad fortune messages.
- Populate each list with uplifting fortune messages. 
- To create a list in Python, you can use square brackets [] and separate the elements with commas. 

### **Step 2 - Ask How the User is Feeling**

Once the fortune messages are ready, prompt the user to enter how they are feeling (happy or sad).

**Goal:** Get the user's current emotion.

**Hints**:
- Use the `input()` function to prompt the user for input.
- Store the input in a variable.


### **Step 3 - Pick a Random Fortune Message**

Based on the user's input, randomly select a fortune message from the corresponding list of fortune messages.

**Goal:** Generate a fortune message based on the user's emotion.

**Hints**:
- Use `if` and `else` to check the user's emotion.
- Use `random.choice(list_name)` to select a random fortune message from the appropriate list. Don't forget to `import random`.
- Store the selected fortune message in a variable and show it to the user.


### **Step 4 - We are finished!**

Congratulations! You've just created a fortune cookie message generator! You can now cheer your friends up when they are sad and motivate them when they are happy!

See the complete source code below:

🌟 Want to play with the code yourself? **[Remix it here](https://trinket.io/python/c9781229b7)**.

### **Challenge: Add More Fortune Messages!**

In this optional step, you'll join your list of fortune messages with additional messages. You will make use of the concatenate or join (`"+"`) operator to create a bigger list of messages.

**Goal**: Use the concatenate (`"+"`) operator to expand your list of happy and sad messages.

**Hints**:
-  You can join two lists using the `+` operator. For example:


- Add the lists below to your initial lists:

Fortune Cookie Message

# **Word Unscrambler**
In this fun game, you'll get a scrambled word and your challenge is to put it back in the right order. How? By providing the right order of the letters using their index, you will reorganize them and make sense out of that word!

WordUnscrambler-ezgif.com-optimize.gif

### **Key Concepts Review**
- **Lists:** A way to store multiple items in Python.
- **Random:** We `import` random to pick and shuffle random words from a list.
- **Loops:** Go over the items in a list using a `for` loop.
- **String Indexing:** Access individual characters in a word using their index.

### **Let's Get Started!**
In Word Unscrambler, you are presented with a scrambled word, where the letters are mixed up and out of order. Your objective is to rearrange these letters into their correct order by using the indices (the positions of the letters in the scrambled word) to determine where each letter should go in the correct word. For example, in the case below, player is given letters C R A, and the answer is 0 2 1, to get the word CAR. Note, index of the first letter is 0, following the convention of Python. 

Group 10 (1).png

### **Step 1 - Prepare & Show the Scrambled Word**

**Goal**: Randomly choose a word from a word bank and mix up its letters.

**Hints**:
- We need a list of words as our word bank. Create a list of at least 5 words. 
- We can use `random.choice()` to pick a random word from a list.
- Strings are immutable, let's convert it to a list first using `list(word)`.
- We can now scramble that word using `random.shuffle()`. For example:
> `scrambled_word = random.shuffle(secret_word)`
- Show the scrambled word to the user. You can transform a list back into a string with: 
> `print(' '.join(your_list))`


### **Step 2 - Time for Guessing!**

**Goal**: Ask the player to guess the right order of the letters.

**Hints**:
- Ask the player to provide the letters' indices in the right order but separated by a space. 
- Use the following pattern to obtain a list with the indices entered:
> `indices = input("Indices: ").split()`


### **Step 3 - Unscramble!**

**Goal**: Create an unscrambled version of the word with the user's indices.

**Hints**:
- We need to reconstruct the word in the order specified by the user. Start with an empty string.
- Iterate over the list of indices. Add the letter corresponding to the index to your initial string.
- Don't forget to convert the indices to an integer first!

### **Step 4 - Did the player get it right?**

**Goal**: Check to see if the player unscrambled the word correctly.

**Hints**:
- Use an `if` statement to check if the unscrambled word and the secret word are the same.
- Congratulate the user if they got it right.
- Let the user know what was the word if they got it wrong.

### **Step 5 - We are finished!**
Congratulations! You've just created your own word unscramble game. Test your skills and see if you can unscramble the words like a pro! 

See the complete source code below:

🌟 Want to play with the code yourself? **[Remix it here](https://trinket.io/python/8df1ffc7d4)**.

Word Unscrambler

# **Morse Code**
Morse code is a cool way to communicate with just dots and dashes. Learn more about [how it works here](https://www.history.navy.mil/content/dam/museums/undersea/education/Morse%20Code.pdf). In this Morse code game, you'll be given a secret message in Morse code, where dots (.) and dashes (-) represent letters. Your mission is to decode this Morse code and turn it into regular English words using the help of a Python dictionary! So, put on your detective hat, decipher the code, and have a blast playing this challenge!

MorseCode-ezgif.com-optimize.gif

### **Key Concepts Review**
- **Files:** Locations on a disk that store information.
- **Dictionary:** A collection of key-value pairs.
- **Random:** We `import` random to pick random items from a list.
- **Loops:** Go over the items in a list using a `for` loop.
- **Conditional Statements:** We use `if` statements to check if your guess is correct.

### **Let's Get Started!**
In this challenge, you'll be given a file of secret codes written in[ Morse code](https://www.history.navy.mil/content/dam/museums/undersea/education/Morse%20Code.pdf), a special code that uses dots (`.`) and dashes (`-`). One message will be randomly presented to you and your goal is to decipher it. 

Group 11.png

We have created a dictionary with Morse code for most letters to make it easier for you. However, the Morse code for all the vowels are missing from the dictionary. We will need to add the missing vowels and start decoding. Let's see how fast you can get the message right!

### **Step 1 - Prepare Morse Code Dictionary**

**Goal**: Complete the translation dictionary by adding the missing vowel entries.

Click on the morse.py tab, next to main.py on right hand side Trinket window. You will see the dictionary "morse_to_letters" is defined in there with morse codes for most letters. The missing ones are all the vowels. Recall that dictionaries are used to store data values in key:value pairs. A **dictionary** is a collection which is ordered, changeable and do not allow duplicates. To get a refresher of Python Dictionary, [check out this tutorial](https://www.w3schools.com/python/python_dictionaries.asp). 

**Hints**:
- The `morse_to_letters` dictionary has been imported for you. It contains the translation from Morse code to letters. The vowels are missing! 
- Add to the dictionary to include the translation for the vowels. 



For example, this will add the code `.-` and its translation `A` to the dictionary.

Follow the same format to add the rest of the vowels to the morse.py. Note that you need to enter upper case letters. 
    - Code `.-`     →   `E`
    - Code `..`      →   `I`
    - Code `---`   →   `O`
    - Code `..-`    →   `U`

### **Step 2 - Randomly Select a Morse Code Message!**

For simplicity, we have created a file `codes.txt` with some words coded in Morse Code. You can see it on the right hand side in the Trinket window also. Click on the tab and take a look. Feel free to add more coded words to it following the same format. 

**Goal**: Read the messages from the `codes.txt` file and select one to play with the user.

**Hints**:
- Open the `codes.txt` file to access the Morse code messages. Each line is a new message.
- Use `readlines()` to read the file and put its contents in a list. Each line will be an item in the list.
- Use `random.choice()` to pick a random Morse message from your list. 
- Remove any whitespace that may be before or after the message using `strip()`. For example:
    > `message = message.strip()`


### **Step 3 - Translate Morse Code to English!**

**Goal**: Generate the correct Morse code translation to compare with the user's guess. 

**Hints**:
- Initialize an empty string to store the translation from Morse code to English.
- Split the selected Morse message into individual Morse code elements using `split()` . For example:
> `morse_code_elements = message.split()`
- For each morse code element, use the dictionary to figure out the translation and add it to the empty string.
- At the end, you should have the English version to compare with the user's guess.

### **Step 4 - Check the User's Guess**

**Goal**: Ask the player to guess and check if their guess is correct.

**Hints**:
- Print a message to let the player know it is their turn to guess the translation.
- Let them enter their answer in uppercase.
- Check if their guess matches the correct translation.
- Congratulate the user if the guess is correct, otherwise, tell them the correct answer.

### **Step 5 - We are finished!**
Congratulations! You've just cracked the Morse Code Decoder game. Now, you can test your code-breaking skills and decipher Morse code like a pro!

See the complete source code below:

🌟 Want to play with the code yourself? **[Remix it here](https://trinket.io/python/69cae046df)**.

Morse Code Puzzle

# **Password Power-Up**

Become a password wizard and fortify your accounts against intruders. Power up your password with a mix of letters, numbers, and special characters. Made a weak password? No worries, this tool will help you check and identify the weaknesses. 

Ready to test your password's might? Let's create super strong passwords!

PasswordPowerUp-ezgif.com-optimize.gif

### **Key Concepts Review**
- **Strings:** Sequences of words or characters.
- **String Length:** Find out how many characters are in a string with `len()`
- **Character Checking:** Check if a character is lowercase, uppercase, or a number using `islower()`, `isupper()`, and `isdigit()` respectively.
- **Loops:** Repeat a block of code for each item in a sequence using `for x in sequence`

### **Let's Get Started!**
Boost your password with Password Power-Up! Given a password, the tool checks your password strength based on the following dimensions:
- how long your password is
- if it includes a mix of letters, numbers, and symbols

Strong passwords should include at least 12 characters and use a combination of uppercase letters, lowercase letters, numbers, and symbols.
 

### **Step 1 - Prompt for Password Input**

**Goal:** Begin by collecting a password from the user.

**Hints:**
- Use `input()` to prompt the user to enter their password.
- Store the entered password in a variable to check its strength.

### **Step 2 - Analyze Password Characteristics**

**Goal**: Check the password against each criterion to evaluate its strength.

**Hints**:
- Determine the password's length by using the `len()` function.


- Iterate through each character in the password using a `for` loop.
- Use the `islower()`, `isupper()`, `isdigit()` methods to check for lowercase letters, uppercase letters, and numbers, respectively. See an example below:


- Check if the character is a special character. For simplicity, you can ask if the character is contained in the string below.


- Define variables to track whether the criteria are met. For instance, you may define a variable called **has_lowercase**, and set it to 1 if one of the characters is a lower case character. 

### **Step 3 - Calculate Password Strength**

**Goal**: Determine the overall strength of the password based on the criteria met.

**Hints**:
- Use a variable to hold the strength score of the password.
- Increase the strength score by one for each criterion the password meets:
    - Password length is greater than 12
    - Contains at least one lowercase letter.
    - Contains at least one uppercase letter.
    - Contains at least one number.
    - Contains at least one special character.
- For each criterion not met, give advice on how to improve the password strength, such as adding more characters, including a number, or using a mix of uppercase and lowercase letters.


### **Step 4 - Provide User Feedback**

**Goal**: Tell the user how strong their password is.

**Hints**:
- Use `if` statements to check the strength score:
    - **Strength score >= 4:** Congratulate the user on a strong password!
    - **Strength score >= 2:** Tell the user its a medium strength password.
    - **Less than 2:** Tell the user it is a weak password. 

### **Step 5 - All Done! Your Password is Powered Up!**

Kudos on elevating your password with Password Power-Up! Experiment with different character combinations to make your passwords even stronger. Keep leveling up your game and stay secure!

See the complete source code below:

🌟 Want to play with the code yourself? **[Remix it here](https://trinket.io/python/b407178a13)**.

Password Power-Up

# **Turtle Sketchpad**

Have fun drawing alongside the computer. Place squares, triangles, circles, and stars at random places on the canvas. 
Made a mistake? Simply undo your previous steps! 
Did it turn out to be a masterpiece? Save the sequence of steps for later! 

Whether you're a beginner or a seasoned artist, draw alongside the computer with Turtle Sketchpad!

TurtleSketchpad-ezgif.com-optimize.gif

### **Key Concepts Review**
- **Turtle:** A module for creating drawings and animations.
- **Files:** Locations on a disk that store information.
- **Write into a file:** Use `open()` in `w` mode to write a new file. Use `write()` to add contents to it.
- **Read from a file:** Use `open()` in `r` mode to read from a file. Use `read()` to get its contents.
- **Close a file:** Make sure to always `close()` your files!  
- **Lists:** Store multiple items. You can add to a list using `append()`. You can remove the last item added with `pop()`.

### **Let's Get Started!**
Embark on a creative journey with Turtle Sketchpad. Ask the user to pick a shape they would like to draw on the screen and draw it at a random location. The user may undo their last drawing and keep adding other shapes. Finally, when the user is done, they can save their masterpiece steps into a file!

### **Step 1 - Setting Up the Drawing Environment**

In this step, you'll import functions from `shape.py` that allow you to draw squares, triangles, circles, and stars. 

**Goal**: Import the drawing functions for the sketchpad.

**Hints**:
- There are several functions inside `shape.py` that we need to import:
    - `draw_square`
    - `draw_triangle`
    - `draw_circle`
    - `draw_star`
- We can import all of them at once using:
> `from shape import *`
- Don't forget to set the turtle speed to maximum with `turtle.speed(0)`.


### **Step 2 - Let the User Choose**

In this step, you'll allow the user to choose what action they want to perform. They may want to draw a shape, undo their last drawing, or save their masterpiece. 

**Goal**: To ask for the user's input to determine what to do.

**Hints**:
- Ask the user whether they want to draw a shape (and which one) or if they want to undo or save their work.
- Make sure that if they select a valid option.

We will work on the drawing, undoing, and saving in the next steps.

### **Step 3 - Drawing Shapes**

If the user chooses to draw a shape, we will create that shape in a random location.

**Goal**: To generate a random coordinate for X and Y and place the desired shape in that location.

**Hints**:
- Use `random.randint()` to get random X and Y coordinates between `-150` and `150`.
- Call the right function from the `shape` module to draw the desired shape. 
- Use the generated X and Y coordinate as arguments for the function.
- Keep track of the shapes drawn by creating lists for the shapes, X locations, and Y locations. Use the `append()` method to add to each list to remember what was drawn and where.
- Use a variable to count how many drawings have been placed on the screen.

<details>
<summary>Optional Steps</summary>
<li>Modify your code to use a function for calling the right function from the <code>shape</code> module to draw the desired shape. </li>
<li>If you are modifying variables outside your function, use <code>global my_variable</code> at the beginning of your function.</li>
</details>

### **Step 4 - Undoing Drawings**

To undo the drawings, clear the canvas with `turtle.clear()` and then redraw all the shapes except for the last one. 

**Goal**: Undo the last drawing placed on the screen.

**Hints**:
- Clear the screen with `turtle.clear()`
- If there are drawings on the screen, redraw all shapes except the last one.
- Use the `pop()` method to remove the last item added to each list. See an example below:

- Check the lists to redraw the remaining shapes in the corresponding X and Y locations.
- Update the variable that keeps track of the number of drawings on the screen.
- If there were no drawings on the screen, print a message indicating that there was nothing to undo.

<details>
<summary>Optional Steps</summary>
<li>Modify your code to use a function for undoing and clearing the screen.</li>
<li>If you did the optional portion of Step 3, you may call that function for redrawing the remaining shapes.</li>
<li>If you are modifying variables outside your function, use <code>global my_variable</code> at the beginning of your function.</li>
</details>

### **Step 5 - Saving Drawings**

In this step, we allow the user to save the sequence of drawn shapes to a file.

**Goal:** Save the steps needed to recreate the drawing into a text file.

**Hints**:
- Iterate through the lists of saved shapes, X, and Y locations. 
- Use `open()` in write mode (`"w"`) to create a new file.
- Use `write()` to add content to the file. 
- Each line of the file should follow this format:
 > `shape at (x, y)` 
- Close the file in the end and finish the program.


<details>
<summary>Optional Steps</summary>
<li>Create a function that takes in a file name as an argument to save the file.</li>
<li>If you are modifying variables outside your function, use <code>global my_variable</code> at the beginning of your function.</li>
</details>

### **Step 6 - Main Loop**

In this part, we'll wrap the code from Steps 2-5 inside a while loop to create the main loop. This loop will continue until the user decides to save and quit.

**Goal:** Use a loop to repeat until the user decides to save and quit.

**Hints:**
- Use a `while` loop with a condition to keep the loop running until the user saves and quits.
- You may also use a `while True` loop and decide when to stop the loop with `break`.

### **Step 7 - We are finished!**

Congratulations on completing the Turtle Sketchpad! You can now create your own masterpieces! Feel free to add more shapes and make the project more entertaining!

See the complete source code below:

🌟 Want to play with the code yourself? **[Remix it here](https://trinket.io/python/7b17a35470)**.

Turtle Shape Sketchpad

# **Random Lines Showdown**

Experience a statistical face-off as we generate two sets of 10 random integers, plot them, and compare key statistical values such as their max, min, and sum. Determine the winner in each category and venture into the randomness of the generated data.

RandomLinesShowdown.png

### **Key Concepts Review**
- **Data Visualization:** The graphical representation of data to gain insights and patterns.
- **Matplotlib:** A popular library used for creating charts.
- **Lists:** Store multiple items. Add items to it using `append()`.
- **Finding Max/Min in a List:** Use `max(list_name)` and `min(list_name)` to find the largest and smallest value in a list.
- **Adding all Values in a List:** Use `sum(list_name)` to add all the values in a list.
- **Plotting:** Use functions like `plt.plot()` and `plt.show()` from Matplotlib to create and show line charts.

### **Let's Get Started!**
You are about to explore the dynamics of random data. You will generate and store random numbers in a list and calculate key insights such as their maximum, minimum, and total sum of the elements.  Determine the winner for each category (max, min, sum).

### **Step 1 - Generate Random Data**

In this step, you'll generate random data for two lists. You will generate 10 random integers per list.

**Goal**: To create a pair of lists with random numerical data for plotting.

**Hints**:
- Remember to `import random` to generate random numbers.
- Create two empty lists.
- Generate 10 random integers between 1 - 100 for each list using a `for` loop and `random.randint()`.
- Use `append()` to add the integers to the lists.

### **Step 2 - Plot the Data**

Once you have generated the random numbers, you can plot them using `matplotlib`. 

**Goal**: Plot the two random lists and add a title and labels to the plot.

**Hints**:
- Don't forget to `import matplotlib.pyplot as plt`.
- Plot the generated data using `plt.plot()`
- Add a title using `plt.title()`.
- Add labels for the X and Y axis using `plt.xlabel()` and `plt.ylabel()`
- Display the plot using `plt.show()`.

### **Step 3 - Calculate Statistics**

Now that you have plotted the data, it's time to see which line is superior! We will calculate the maximum, minimum, and the sum for each list using Python's built-in functions `max()`, `min()`, and `sum()`!

**Goal:** Calculate statistics on the list to see who won for each category (max, min, sum).

**Hints**:
- Calculate the maximum value of each list using the `max()` function.


- Calculate the minimum value of each list using the `min()` function.


- Calculate the sum of all values in each list using the `sum()` function.


- Don't forget to display the calculated statistics for each list.

### **Step 4 - Compare Results**

After calculating the statistics, let's compare to see which list won for the max, min, and sum categories.

**Goal:** Determine the winner by comparing their statistics.

**Hints**:
- Compare the maximum values of both lists and determine which list has a higher maximum value.
- Compare the minimum values of both lists and determine which list has a lower minimum value.
- Compare the sum of values in both lists and determine which list has a higher sum.
- Print the comparison results.

### **Step 5 - We are finished!**

Congratulations on completing the analysis and visualization of the random data! You've successfully plotted two sets of random lines and explored their characteristics through statistical analysis.

See the complete source code below:

🌟 Want to play with the code yourself? **[Remix it here](https://trinket.io/python/990c2414c3)**.