3 Mini Python Projects - For Beginners

Main ideas / lessons

• The video demonstrates how to build three beginner-friendly Python projects from scratch, walking through the full process:
  • breaking down requirements
  • coding step-by-step
  • handling basic bugs/errors
• Each project teaches a core Python concept:
  1. Problem solving + loops + random numbers (game simulation)
  2. File I/O + parsing + string replacement (dynamic Mad Libs)
  3. Functions + randomness + eval + timing + input validation (math quiz)

---

Project 1: Pig Game (dice + turns + scoring)

Game rules being implemented

• Multiplayer turn-based dice game (up to 2–4 players).
• On a player’s turn:
  • They roll a die (1–6).
  • If the roll is not 1: add it to that player’s current turn score.
  • If the roll is 1:
    • their current turn score becomes 0
    • the turn ends immediately
  • The player can choose to continue rolling or stop at any time.
• When the player stops:
  • their current turn score is added to their total score.
• Game ends when someone reaches or exceeds a max score (set to 50 in the demo).
  • The winner is the player with the highest total after the final round of turns.

Implementation approach (step-by-step)

• Random die roll

  • Import random.
  • Create a reusable function (e.g., roll()):
    • use random to generate an integer between 1 and 6
    • return the rolled value

• Get number of players

  • Prompt: “enter the number of players (1 to 4)”
  • Loop until valid input:
    • accept only digits (players.isdigit())
    • convert to int
    • enforce constraints (minimum 2, maximum 4)
  • Uses input validation with repeated prompting (while True, break, and error messaging).

• Track scores

  • Set max_score = 50.
  • Create player_scores as a list of zeros sized to the number of players (via list comprehension).

• Main game loop

  • Continue while no player has reached the max score:
    • max(player_scores) < max_score

• Simulate each player’s turn

  • Loop over players using a for loop.
  • For each player:
    • initialize current_score = 0 for the turn
    • repeatedly ask whether to roll:
      • input accepts y in any case (lower())
    • inside a while True turn loop:
      • if the player chooses to stop, exit the turn loop
      • otherwise roll the die:
        • if roll == 1:
          • print “rolled a one, turn done”
          • set current_score = 0
          • end the turn
        • else:
          • add roll value to current_score
          • print current score
  • After the turn ends:
    • add current_score to the player’s total in player_scores[player_idx].

• Determine winner

  • Compute max_score_value = max(player_scores).
  • Find the index of the maximum using .index(...).
  • Print the winner (using index + 1 for human-friendly numbering).

Bug/issue mentioned

• Input validation logic mistake:
  • the “must be between…” message was printed due to misplaced conditional branches
  • fixed by adjusting the if/else structure.

---

Project 2: Mad Libs Generator (dynamic stories from a text file)

Core concept

• The story is stored in a text file (story.txt) in the same directory as the Python file.
• The story contains placeholders in the format:
  • <word> (angle-bracket tokens)
• The program:
  1. loads the story text from file
  2. extracts all unique placeholder words
  3. prompts the user for replacement text
  4. replaces placeholders in the story
  5. prints the completed story

Implementation approach (step-by-step, detailed)

• File I/O

  • Open story.txt for reading:
    • with open("story.txt", "r") as f:
  • Read the full contents:
    • story = f.read()

• Parse placeholders from the story

  • Loop through the story characters using enumerate(story) to track:
    • index i
    • character char
  • Track placeholder boundaries:
    • Target_start = "<"
    • Target_end = ">"
    • start_of_word = -1 (sentinel meaning “not inside a placeholder”)
  • When encountering <:
    • set start_of_word = i
  • When encountering > and start_of_word != -1:
    • extract token:
      • word = story[start_of_word : i+1]
    • add token to a collection of unique placeholders
    • reset start_of_word = -1

• Ensure placeholders are unique

  • Use a set rather than a list:
    • words = set()
  • use words.add(word) instead of append

• Collect user answers

  • Create dictionary answers = {}
  • For each placeholder token in words:
    • prompt:
      • answer = input("enter a word for " + word + ": ")
    • store:
      • answers[word] = answer

• Replace placeholders in the story

  • For each placeholder token word:
    • replace all occurrences:
      • story = story.replace(word, answers[word])
  • Important fix shown:
    • the return value of replace() must be assigned back to story
    • calling story.replace(...) without assignment has no effect

• Output

  • print the final story

Bug/issue mentioned

• Forgot to assign the result of replace() back to story:
  • fixed by changing to: story = story.replace(...)

---

Project 3: Timed Math Quiz (random problems + answer checking + timing)

Core concept

• Generate random math expressions.
• Present them one-by-one.
• The user cannot proceed until the answer is correct.
• Time the full quiz duration and report it.

Implementation approach (step-by-step, detailed)

• Imports

  • import random
  • import time

• Set constants

  • Operand range:
    • min_operand (e.g., 3)
    • max_operand (e.g., 12)
  • Allowed operators:
    • a string like "+-*/" (demo chooses operators that work well)
  • total_problems = 10 (configurable)

• Create problem generator function

  • Define generate_problem():
    • pick random integers:
      • left = random.randint(min_operand, max_operand)
      • right = random.randint(min_operand, max_operand)
    • pick a random operator:
      • operator = random.choice(operators)
    • build expression string:
      • expr = f"{left} {operator} {right}"
    • compute answer using eval:
      • answer = eval(expr)
    • return both (typically):
      • return expr, answer

• Quiz loop

  • Start a timer after the user indicates readiness (press Enter).
  • For each problem:
    • expr, answer = generate_problem()
    • ask for input:
      • guess = input("problem number X: " + expr + " = ")

• Force correctness before moving on

  • Use a while True loop:
    • user input (guess) is a string
    • computed answer is numeric
    • compare by converting answer to a string:
      • if guess == str(answer): break
    • otherwise repeat the prompt (another attempt)

• Track wrong answers

  • The video introduces:
    • wrong = 0
  • increments when an answer is incorrect
  • (main guaranteed behavior remains: user must get correct to advance)

• Timing

  • record:
    • start_time = time.time() after the user presses Enter
    • end_time = time.time() after all problems finish
  • compute duration:
    • total_time = end_time - start_time
  • print:
    • “finished in X seconds”

• User experience

  • continues until all correct answers are entered
  • reports performance at the end

Notable technique: eval

• The generator avoids manual operator-handling (if/else) by evaluating the expression string directly with Python’s eval().

---

Speakers / sources featured

• Primary speaker (video creator / instructor): unnamed person speaking directly on camera and coding live.
• External source mentioned: ChatGPT (used to generate the initial Mad Libs story text).
• External course/service referenced: programmingexpert.io (programming course promotion).
• Music: “[Music]” appears as a subtitle marker (no specific artist named).