Breaking a problem into steps

Write out what your program should do in simple, human steps (like a recipe) before coding. Then match each step to Python tools such as input, loops, and conditionals.

Input / Processing / Output

Input: data from the user (with `input()`). Processing: calculations and decisions (variables, loops, `if`). Output: information shown to the user (with `print()`).

A named block of code that does a specific job. Example: `def play_game():` defines a function you can call whenever you want to run the game.

A separate file or built-in library with extra code you can reuse. You bring it in with `import`. Example: `import random` lets you use `random.randint()`.

The process of finding and fixing errors in your code. Common tools: reading error messages, adding temporary `print()` statements, and testing edge cases.

A structure that repeats code multiple times, such as `for` or `while`.

Data or information that a program receives, often from the user typing with `input()`.

A file or library that contains Python code you can reuse, imported with `import`.

Information that a program sends out, usually shown on the screen with `print()`.

Your First Mini Project: A Simple Interactive Python App — Getting Started with Python: A Gentle, Practical Introduction

Step 1: What You Will Build

Your First Mini App

You are going to build a complete, tiny Python app: a Number Guessing Game. The computer picks a secret number, and you try to guess it. After each guess, the app tells you if you are too high, too low, or correct.

Skills You Will Practice

This project lets you practice: input (reading what the user types), processing (variables, loops, conditionals), output (printing messages), functions (organizing code), and modules (using Python's built-in `random` module).

What You Will Do

In about 15 minutes, you will plan the game, write the code step by step, run and test it, fix simple bugs, and think about how you could extend or change it. You can use any Python environment you already have.

Step 2: Break the Game Into Small Steps

Plan in Plain Language

Before coding, write the game as simple steps: say hello, pick a secret number, give the player some tries, ask for a guess, say if it is too low, too high, or correct, and end the game when they win or run out of tries.

Match Steps to Python

Match each step to Python tools: secret number → `random` and a variable; tries → a loop; checking the guess → `if`/`elif`/`else`; asking the user → `input()` and `int`; messages → `print()`.

Why This Matters

You are learning to turn a real-world idea into code-friendly steps. This skill—breaking problems down—is what real developers use on much larger projects.

Step 3: Set Up the Basics (Imports and Greeting)

Now let us start coding the game from the top.

Import the random module (a built-in Python module) so we can pick a secret number.
Print a welcome message so the user knows what is happening.

Type this code into your Python file or editor:

Step 4: Generate the Secret Number and Ask for Guesses

Next, we will:

Use `random.randint(1, 100)` to choose a secret number.
Decide how many guesses the player gets.
Use a `for` loop to repeat the "ask for a guess" part.

Type this code under your previous code:

Step 5: Add Logic With Conditionals

Now let us add the decision-making part using `if`, `elif`, and `else` inside the loop.

We want to:

Check if the guess is less than, greater than, or equal to the secret number.
Stop the loop early if the player guesses correctly.

Replace the comment `# We will fill in the checking logic in the next step.` with this code:

Step 6: Organize With a Function

Why Use a Function?

Your game works now, but putting it into a function called `play_game()` makes it easier to reuse and extend. Functions group related code and keep your file tidy.

A Cleaner Game Structure

In `playgame()`, you welcome the user, pick the secret number, run the guessing loop, and print the result. Below that, a `while True` loop calls `playgame()` and asks if the user wants to play again.

What You Gained

This organized version adds basic input checking, lets the player replay without restarting Python, and shows how real apps are built from functions plus a small main loop.

Step 7: Debugging and Testing Your Game

Now it is time to test and debug (fix problems) using the habits you learned earlier.

Try these activities:

Force some errors on purpose

Run the game and, when it asks for a guess, type: `hello`
If you forgot the `isdigit()` check, you will see a `ValueError` when Python tries to convert `"hello"` to an `int`.
Add or check this part:
`if not guess_text.isdigit():`
`print("Please enter a whole number.")`
`continue`

Test edge cases (unusual but possible inputs)

Guess `1` and `100` to make sure the range works.
Guess the same wrong number every time to see the "out of attempts" message.
Guess the correct number on the first try (you might need to temporarily `print(secret_number)` for testing).

Use print debugging

Add a temporary line inside the loop: `print("DEBUG: secretnumber =", secretnumber)`
Run the game and make sure the logic matches what you see.
Remove or comment out the debug print when you are done.

Reflection questions (think or write a quick note)

Which bug or error message confused you the most?
What helped you finally fix it: reading the error, adding prints, or checking your plan?
If you had 10 more minutes, what is one feature you would add?

Step 8: Quick Check on Concepts

Test your understanding of how this mini project fits together.

Why is it helpful to put the game logic into a function like `play_game()` instead of leaving all the code at the top level?

It makes the game run faster in all cases.
It organizes the code so you can easily reuse it and call it multiple times.
Python requires all code to be inside functions.
It stops errors from ever happening.

Show Answer

Answer: B) It organizes the code so you can easily reuse it and call it multiple times.

Putting the logic in `play_game()` organizes related code in one place and lets you call it multiple times (for example, in a loop to replay the game). It does not guarantee no errors, and Python does not require everything to be in functions.

Step 9: Review Key Ideas

Flip through these cards to review the most important concepts from this mini project.

Breaking a problem into steps: Write out what your program should do in simple, human steps (like a recipe) before coding. Then match each step to Python tools such as input, loops, and conditionals.
Input / Processing / Output: Input: data from the user (with `input()`). Processing: calculations and decisions (variables, loops, `if`). Output: information shown to the user (with `print()`).
Function: A named block of code that does a specific job. Example: `def play_game():` defines a function you can call whenever you want to run the game.
Module: A separate file or built-in library with extra code you can reuse. You bring it in with `import`. Example: `import random` lets you use `random.randint()`.
Debugging: The process of finding and fixing errors in your code. Common tools: reading error messages, adding temporary `print()` statements, and testing edge cases.
Loop with `else`: In Python, a `for` or `while` loop can have an `else` block. The `else` runs only if the loop finishes normally (no `break`). In the game, it runs when the player uses all attempts.

Step 10: Your Turn to Customize

To really make this your project, try changing or adding at least one feature. Here are some ideas:

Change the range or difficulty

Let the user choose the maximum number (for example, 50, 100, or 1000).
Change `max_attempts` based on the range.

Add a score

Start with a score of 100.
Subtract some points for each wrong guess.
At the end, show the final score.

Give hints

After a few wrong guesses, print a hint like "The number is even" or "The number is greater than 50".

Log results to a file (optional)

After each game, append the result (win/lose, attempts, and date) to a text file using the `open()` function and the `datetime` module.

Activity:

Pick one idea from above (or make your own).
Write down, in plain language, the steps needed.
Then implement it in your code.

This is how real projects grow: one small improvement at a time.

Key Terms

loop: A structure that repeats code multiple times, such as `for` or `while`.
input: Data or information that a program receives, often from the user typing with `input()`.
module: A file or library that contains Python code you can reuse, imported with `import`.
output: Information that a program sends out, usually shown on the screen with `print()`.
function: A reusable block of code that performs a specific task, defined with `def name():`.
variable: A named place in memory where a value is stored, such as `secret_number` or `max_attempts`.
debugging: Finding and fixing errors or bugs in your code by testing, reading messages, and using tools like `print()`.
conditional: Code that runs only if a certain condition is true, using `if`, `elif`, and `else`.