Prime your brain first — retention follows
9 HOURS of Python Projects - From Beginner to Advanced
Introduction to 21 Python Projects Course
This video offers over 9 hours of content, featuring 21 unique Python projects designed for all skill levels.
Quiz Game: Basic Setup & User Input
The first project is a computer quiz game that asks users questions, tracks their score, and displays the final result as a fraction and percentage.
Quiz Game: Questions, Answers & Else Statements
To ask quiz questions, the `input()` function is reused, storing the user's answer in a variable (e.g., `answer`).
Quiz Game: Case Sensitivity & Scoring
Case sensitivity can cause unexpected program termination if user input (e.g., 'Yes') doesn't match the expected case ('yes').
Quiz Game: Project Review & Customization
The quiz game project serves as a foundational exercise, explaining core Python concepts like `print`, `input`, `if/else`, string methods, and basic arithmetic.
Number Guesser: Random Numbers & Input Validation
The number guesser game involves generating a random number and tracking how many guesses it takes the user to find it.
Number Guesser: Game Loop, Guesses & Hints
A `while True` loop is used to repeatedly ask the user for guesses until the correct number is found, creating an infinite loop that requires a `break` statement to exit.
Rock Paper Scissors: Game Setup & Computer Choice
The Rock Paper Scissors game tracks user and computer wins, ending when the user quits.
Rock Paper Scissors: Determining Winner & Score
The computer's choice is displayed using `print('Computer picked', computer_pick + '.')`, using string concatenation to avoid an extra space before the period.
Choose Your Own Adventure Game
The 'Choose Your Own Adventure' game is a highly customizable beginner project that allows users to make choices impacting their story path.
Password Manager: Basic File Operations (Add/View)
This project builds a password manager to organize and store passwords in a text file, initially without encryption.
Password Manager: Introducing Cryptography & Keys
The `view()` function opens `passwords.txt` in 'r' (read) mode to display stored entries.
Password Manager: Encryption/Decryption & Master Password Issue
The encryption process requires converting strings to bytes using `.encode()` before `f.encrypt()`.
Pig Game: Core Mechanics & Player Turns
The Pig game is a multiplayer dice game where players roll a die, accumulating points until they roll a '1' (losing all points for that turn) or decide to stop.
Pig Game: Scoring, Winning & Game Flow
At the start of each player's turn, their `current_score` for the turn is reset to `0`, and their `total_score` (from `player_scores`) is displayed.
Mad Libs Generator: Story & Word Replacement
The Mad Libs generator creates a story where users provide words (adjectives, nouns, etc.) to fill in blanks.
Math Quiz Game: Problem Generation & Timing
The math quiz game randomly generates arithmetic problems, requires correct answers to proceed, and times the user's completion.
Slot Machine: User Deposit, Lines & Bet Input
This project builds a text-based slot machine game where users deposit money, place bets, spin reels, and win based on combinations.
Slot Machine: Reel Generation & Display
The slot machine uses a 3x3 grid, with wins determined by three matching symbols in a row.
Slot Machine: Checking Winnings & Multipliers
The `SYMBOL_VALUE` dictionary assigns a multiplier to each symbol (e.g., 'D': 2, 'C': 3, 'B': 4, 'A': 5), with rarer symbols having higher multipliers.
Slot Machine: Game Loop, Balance & Play Again
The game's main loop (`while True`) continuously prompts the user to 'Press enter to spin' or 'Q to quit'.
Turtle Racing: User Input & Validation
This project creates a graphical turtle racing game where users select the number of turtles to race, and the turtles move randomly across the screen.
Turtle Racing: Screen Setup & Basic Turtle Movement
The `turtle` module (built into Python) is imported for 2D graphics, and `time` is imported for pausing execution.
Turtle Racing: Creating Multiple Turtles & Positioning
A `COLORS` list (e.g., 'red', 'green', 'blue') is defined globally to hold available turtle colors.
Turtle Racing: Race Logic, Winner & Dynamic Screen
The `race(colors)` function orchestrates the actual race, calling `create_turtles()` to get the racers.
Typing Test: Curses Module Intro & Start Screen
The typing speed test application uses the `curses` module for advanced terminal control, enabling features like text highlighting and screen clearing.
Typing Test: Real-time Input, Highlighting & Backspace
The `wpm_test()` function manages the core typing logic, displaying target text and processing user input.
Typing Test: WPM Calculation & Game Completion
To prevent `IndexError` when typing beyond `target_text` length, an `elif` condition (`len(current_text) < len(target_text)`) ensures characters are only added if there's corresponding target text.
Typing Test: Play Again & Random Text Loading
The entire game logic is wrapped in a `while True` loop in the `main` function, allowing the user to play multiple rounds.
Alarm Clock/Timer: Countdown & Sound Playback
This project creates a simple alarm clock/timer that counts down and plays a sound when finished.
Password Generator: Character Sets & Core Loop
This project builds a password generator that creates passwords with a specified minimum length and optional inclusion of numbers and special characters.
Password Generator: Criteria Checking & User Input
The `meets_criteria` boolean variable is updated in each loop iteration to determine if the password satisfies all requirements.
Maze Pathfinder: Curses Module & Maze Display
This project builds a maze navigator using the `curses` module to control terminal output, allowing for dynamic display and color.
Maze Pathfinder: BFS Algorithm Introduction & Queue
The Breadth-First Search (BFS) algorithm is used to find the shortest path from a start node ('O') to an end node ('X') in the maze.
Maze Pathfinder: Finding Neighbors, Path Tracking & Visualization
Inside the BFS loop, after checking for the end node, the algorithm finds all `neighbors` of the `current_pos`.
NBA Scraper: API Basics, Scoreboard Data & Display
This project demonstrates how to interact with a free NBA API (`data.nba.net`) to retrieve basketball data.
NBA Scraper: Team Stats, Filtering & Sorting
To retrieve team statistics, the `get_stats()` function accesses the 'leagueTeamStatsLeaders' link from the initial API response.
Currency Converter: API Setup & Listing Currencies
This project builds a currency converter using the `free.currencyconverterapi.com` API, which requires a free API key.
Currency Converter: Exchange Rates & Conversion Logic
The `exchange_rate()` function takes `currency1` and `currency2` (currency IDs) to fetch their exchange rate.
YouTube Video Downloader: PyTube & Tkinter
This project creates a simple YouTube video downloader using the `Pytube` library.
Automatic Folder Backup: Scheduling & File Operations
This project creates an automatic folder backup script using the `schedule` module for task scheduling.
Mastermind: Game Intro, Code Generation & Guess Input
This project builds the popular Mastermind game, where a player guesses a secret code of colors.
Mastermind: Code Checking Logic (Correct/Incorrect Positions)
The `check_code(guess, real_code)` function determines how many colors are in the correct position and how many are in the code but in the incorrect position.
Mastermind: Game Flow, Attempts & Win/Loss Conditions
The `game()` function orchestrates the entire Mastermind game flow.
Aim Trainer: Pygame Setup & Target Class Basics
This project builds a custom aim trainer game using the `Pygame` library, allowing for adjustable difficulty.
Aim Trainer: Dynamic Target Spawning & Removal
A `targets` list stores all active `Target` objects on the screen.
Aim Trainer: Mouse Collision, Stats & Top Bar Display
Game statistics tracked include `targets_pressed`, `clicks`, `start_time`, and `misses`.
Aim Trainer: Game End Screen & Accuracy Calculation
Targets are prevented from appearing in the top bar by adjusting the random `y` coordinate generation: `random.randint(TOP_BAR_HEIGHT + TARGET_PADDING, HEIGHT - TARGET_PADDING)`.
Python Scripting: Project Overview & Command Line Arguments
This project focuses on practical Python scripting skills, including command-line arguments, file/directory operations, and using `os`, `sys`, and `subprocess` modules.
Python Scripting: Finding & Copying Game Directories
The `find_all_game_paths(source_path)` function locates all relevant game directories within the `source_path`.
Scripting: JSON Metadata, Go Code Compilation & Subprocess
The `make_json_metadata_file(path, game_dirs)` function creates a JSON file with metadata about the copied games.
Save Notes
Sign in to save key points and create notes for this video.
Ask AI about this video
Sign in to ask questions and get AI-powered answers based on the video content.
Video Details & AI Summary
AI Analysis Summary
This extensive video provides over 9 hours of Python project tutorials, guiding learners from beginner to advanced levels. It covers 21 diverse projects, including interactive games like Quiz, Number Guesser, Rock Paper Scissors, Mastermind, and graphical applications like Turtle Racing and Aim Trainer. Additionally, it delves into practical applications such as a Password Manager, Alarm Clock, Typing Speed Test, NBA Data Scraper, Currency Converter, YouTube Downloader, Automatic Folder Backup, and advanced Python scripting for file system automation and external code compilation. The course emphasizes modular programming, robust input validation, and real-world problem-solving.
gemini-2.5-flashOriginal Video