Python: Zero to Professional

Install Visual Studio Code, uv, and Python 3.12 to set up your development environment. Use the GitHub repo resources to configure the IDE and verify installations before you start coding.

Verify your Python and uv installations by checking versions, launch the Python interactive shell, perform basic calculations, print hello world, and learn how to exit the shell.

Discover why Python powers AI and ML with beginner-friendly syntax, rapid prototyping, and a massive ecosystem of libraries like PyTorch, TensorFlow, and NumPy.

Clone the course repo into a single projects folder, explore day 1 files in the IDE, and verify Python and essential packages are installed, with optional Jupyter notebook setup.

We completed day one by exploring why Python is important and introducing the course, then installed the ide, uv, and Python, with an optional Jupyter setup.

Create a python script file named welcome.py, write a hello world print statement, save the file, and run it from the terminal to display the message.

Explore Google Colab, a browser-based python environment that runs code on Google's infrastructure without local setup. Use markdown and code cells to run Hello world.

Explore Python fundamentals by writing code in Google Colab, learn how variables store values with dynamic typing, and practice declaring and printing age and name, then update values.

Master the basic Python data types, including int, float, str, and bool, and learn how Python's dynamic typing stores values in variables at runtime for beginner-friendly development.

Master Python fundamentals by naming and using variables, through dynamic typing and printing in Google Colab, showing assignment, value changes, and basic syntax.

Experiment with Python data types by declaring variables such as age, name, salary, tax rate, and is student; print their types to confirm int, string, float, and boolean.

Assign values to variables, overwrite them, and see how the last assignment determines the current value, with prints showing Tyson, Alex, and values flowing between variables.

Learn why printing an undefined variable raises an error and how defining nameThird beforehand prevents using an undefined variable.

Identify correct and incorrect Python names using examples, and practice comments with #. Avoid starting names with numbers or spaces, and don't use keywords like if; note case sensitivity.

Complete hands-on exercises to test your knowledge by coding along, pausing to write and run code, and print outputs for variables like name, age, city, and is_student.

Review day-2 progress by revisiting GitHub. Consolidate learning of variables, data types, and variable naming through hands-on coding and a final exercise, celebrating your second trophy.

Master Python fundamentals on day 2 by exploring variables, data types, and naming with coding; distinguish interpreters from compilers and learn control flows with if-else and loops to automate tasks.

Master python control flows with if, elif, and else to make decisions. Learn loops to repeat logic and understand indentation for clean, consistent code.

Learn how Python control flow uses if, elif, and else with proper indentation; explore blocks, colon syntax, and practical examples like age-based decisions and printing multiple statements.

Explore Python control flows with if, elif, and else, learn proper syntax and indentation, and identify common beginner mistakes like using a single equals or missing colons.

Explore Python control flows with illustrated if statements, else and elif, using age-based examples to show evaluation, indentation rules, and common mistakes like single equals and missing colons.

Master control flows by validating string length in Python: determine if a string exceeds 50 characters to classify input as good or bad, with practical, hands-on exercises.

Master using for and while loops in Python to repeat statements and automate tasks. Avoid infinite loops and apply loops to lists, files, games, and automation scripts.

Explore while loops driven by a condition, how the condition changes inside the block, and by example from five down to one, with notes on avoiding infinite loops.

Explore for loops and while loops with illustrations: print each employee from a list, one by one, and prompt for a number, cast to integer, until it equals five.

Learn to print the first 10 natural numbers using a while loop, with proper increment and loop control, and extend to summing 1 to a user-provided number.

Practice conditional statements, comparison operators, and if-else logic with for and while loops in Python, using collab notebooks, user input, and incremental steps to build automation.

We officially close day 3 by cementing control flows, including variables, data types, and conditional statements with loops, then prepare to learn functions and tackle the day 5 real-world project.

Learn to write modular Python code by defining and calling functions, using parameters and return values, and building reusable utility functions with the def keyword.

Explore function definitions with parameters, pass arguments, print results, and return values to create modular, parameter-driven code that handles sums and greetings.

Define functions with one responsibility, use meaningful names, accept inputs, return results, and avoid hard coding, demonstrated by a modular tax calculation using a configurable tax rate.

Explore Python function illustrations by implementing utility functions like add, subtract, is even, and convert to upper; learn about arithmetic operators and using a utilities file to verify results.

Learn how functions can produce side effects by altering the environment, such as printing to the console or writing to a file, without returning a result.

Define a Python function calculate_simple_interest(P, T, R) to compute P*T*R/100, with example P=1000, T=2, R=0.5.

Recap day four by reviewing python functions, parameters vs arguments, and return values. Apply function best practices, explore side effects, and tackle a simple interest exercise for day five.

Recap day 4: finish learning functions and review days 1–4, covering variables, data types, and control flows, then prep for day 5's age eligibility checker project toward Python professionalism.

Launch a Colab project to build an age eligibility checker with a Python function, using boolean values and conditional logic to determine voting, driving, and senior benefits eligibility.

Use Python if-else to implement fizz buzz: print fizz for multiples of 3, buzz for 5, fizzbuzz for both, otherwise print the number, with user input.

Learn to execute and debug Python in Visual Studio Code by migrating Colab code, creating age-eligibility.py, using terminal run, extensions, and the Python debugger.

Recap day 5 with the age eligibility checker project completed in Google Colab, migrated to Visual Studio for coding and debugging, and tested in three modes.

Close week 1 by completing the age eligibility checker project and celebrate over 30% course progress. Week 2 introduces data structure, exception handling, and classes and objects through two projects.

Learn how to store and manage data with Python lists and dictionaries, using indexed access, slicing, modification, and key-value retrieval.

Explore list operations in Python, including append, insert at a specific index, remove by value, pop by index, and length, using practical fruit examples.

Learn to iterate through a list with a for loop, printing each item, and compare the range function as an efficient iterable for generating numbers and indexing by length.

Learn how to use Python dictionaries to store data as key-value pairs, access values by keys, mutate and add entries, and iterate with keys, values, and items.

Explore Python data structures with practical illustrations of lists and dictionaries, including slicing, negative indexing, mixed data types, and combining lists and dictionaries for real-world problems.

Use lists and dictionaries to create a command line to-do list. Implement adding, viewing, and removing tasks, enumerating with one-based indices in an interactive loop.

Explore Python data structures by revisiting lists and dictionaries, learning how to create and iterate them, and index key-value pairs through a real-world to-do list application.

Apply data structures—lists and dictionaries—to build a to-do list app, building on week 1 fundamentals of conditionals, loops, and functions; next, explore exception handling for robust code.

Learn how to handle runtime errors in Python using try, except, else, and finally, including multiple exception types and custom exceptions to enable graceful recovery.

Demonstrate Python exception handling by wrapping division code in try/except, catching zero division errors, and printing a graceful invalid input message. Explore specific exceptions and when to let others propagate.

Learn to handle specific exceptions like value error, use else for code that runs when no exception occurs, and finally to run code regardless of errors, with hands-on examples.

Learn how to raise exceptions in Python with the raise keyword, signaling unexpected input like a negative age and guiding library users according to business rules.

Explore Python exception handling through hands-on code: from try-except, else and finally, to with for safe file access, custom exceptions, and reading user-supplied files with clear error messages.

Apply exception handling to a real-world shopping cart checkout, validating inventory, stock, and item presence, while implementing custom exceptions and a complete checkout flow in Python.

Explore exception handling in Python, using try, except, else, and finally; raise and create custom exceptions, and manage multiple exceptions to build safer, crash-free programs.

Advance through Python fundamentals, mastering variables, operators, control flows, and functions; explore lists, dictionaries, and exception handling to build reliable code, with upcoming object oriented programming concepts and real-world projects.

Learn object oriented programming by exploring classes and objects, where a class is a blueprint and an object an instance, modeling real world entities with properties and behaviors.

Treat a class as a blueprint for creating objects, defining attributes like account number, account holder name, and balance, with methods deposit and withdraw, plus a constructor to initialize.

Define a Python class for complex numbers with real and imaginary parts, initialize with __init__, add two numbers to return a new complex, and implement __repr__ for display.

Learn how to model real-world entities in Python by creating a digital vending machine class with inventory and balance, supporting insert money, purchase, and show inventory.

Leverage classes as a blueprint to define structures, instantiate objects, and interact with them, illustrated by a digital vending machine example.

Learn how classes and objects represent real world entities in Python, with a week 2 recap on dictionaries, lists, exception handling, and modular programming, highlighting progress toward upcoming projects.

Start day 4 of week 2 to tackle a weekly project that applies data structures, exception handling, and classes and objects by building a number guessing game in Colab.

Learn to implement a Python number guessing game using a class, random number generation between 1 and 100, and interactive command-line input with low/high hints.

Recap of day 4, week 2, featuring a Python number guessing game built with classes and an infinite loop, using random and if-else for number comparisons.

Master Python fundamentals and advanced topics through week 1 concepts like variables and loops, and week 2 data structures and classes, as you complete day 4's weekly number guessing game.

Start day 5 of week 2 and begin the weekly project to build a student grading system using data structures, classes, and conditional statements in Python.

Implement a student grading system in Python using a StudentManager class, dictionary storage, and add/update/view operations, with grade validation and a custom StudentNotFoundError.

We completed the week 2 final project, a comprehensive student grading system with multiple classes and objects interacting, applying exception handling and fundamental concepts learned earlier.

Close out week 2 by completing the student grading system project, building on week 1 fundamentals—from variables and data types to control flows, functions, data structures, classes, and exception handling.

Learn about file handling in python, including opening, reading, writing, and appending, and explore binary mode, encoding, and persistent storage with data files like data.txt.

Open, read, write, and append files in Python, testing output.txt with modes w, a, and x. Use with to auto-close file handles and catch exceptions.

Explore file handling in Python by opening, reading, writing, and appending with safe context managers and error handling, then apply these concepts in a real-world scenario.

Develop a file based login system in python with a user manager that loads users from users.txt, supports add and login, and uses read, write, and append modes.

Learn file handling by building a simulated login system that stores and validates username and password in a file, demonstrating persistent storage across runs.

Close day 1 of week 3 by mastering file handling while consolidating Python fundamentals—variables, data types, operators, if-else, loops, and modular programming, plus dictionaries, lists, exceptions, and OOPS programming.

Learn how to use SQLite with Python to manage databases, perform CRUD operations, and connect applications to a file-based database while understanding ACID and data integrity.

Use SQLite with Python to create databases, a cursor, and perform create, read, update, and delete operations with commits. Work with company.db and student.db toward an expense tracker project.

Create an expense tracker using a file-based SQLite database. Implement table creation, add and view expenses, and compute total spending and spending by category, using SQL concepts and database handling.

Explore databases by learning to interact with a database using SQL, build an expense tracker, save expenses, view all entries, and calculate the total.

Advance through Python fundamentals and databases, finishing day 2 of week 3 with an official checkmark on databases.

Apply file handling and exception handling to build a log file analyzer that processes web server logs and outputs key metrics.

Implement a Python log file analyzer that processes a sample log, counts total, successful and failed requests using defaultdict, and reports the most accessed endpoint and most frequent type.

Recap the day three project with a log file analyzer handling a production web server log to count successful and failed entries and compute metrics for a concise report.

Master file handling and SQLite databases while building the log file analyzer, reinforcing Python fundamentals like variables, data types, operators, control flow, and functions across weeks 1 to 3.

Begin day 4 of week 3 by launching the banking system weekly project in Colab, copying it to drive, and starting implementation from the GitHub link.

Conclude week 3 by building and running a stock watcher that fetches real-time prices via Massive.com rest api, showcasing Python requests, classes, and object interactions.

Complete a banking system project in Python, applying week one to three fundamentals, including variables, control flow, functions, data structures, file handling, and databases.

Learn to build a stock watcher project by calling the Massive.com real-time stock API in Python, fetch live prices, parse JSON, and display results.

Build a stock watchlist with add, remove, and list functions; test offline with random prices, then use massive.com API for the previous-day prices displayed in the CLI.

Build a Python stock watcher that fetches previous day close prices via a REST API. Test with offline mode and manage a watch list with add, list, view, and remove.

Complete day 5 of week 3 by building a stock watcher that uses a live rest api call to Massive.com, fetching real-time prices and printing them.

Finish week 3 by applying Python fundamentals to the stock watcher project, including variables, data types, control flows, modular programming, and real-time REST API with persistent storage.

Master Python basics—variables, data types, control flows, loops, functions, and data structures—and apply APIs, file handling, and classes to a live stock price project, enabling roles in software and AI.