RizTech Academy logo
RizTech Academy

Python Complete Foundation

Learn Python properly, from your first line of code to writing programs you would not be embarrassed to show an employer.

Most Python tutorials teach you syntax and stop. You finish knowing what a for loop looks like but with no idea how to structure a program, handle an error sensibly, or write something a teammate could read.

This course goes further. You will write real programs from the second module, make the mistakes deliberately so you recognise them later, and finish able to build a small command-line application from scratch with tests around it.

Every lesson has something to type. Reading about Python does not make you a programmer — the practice at the end of each lesson is the part that matters.

Who this is for

  • Complete beginners with no programming background
  • Students who have learnt some Python in college but cannot yet build anything on their own
  • Anyone joining our Full-Stack track who needs Python before Django

What you need first

  • A computer with at least 4 GB RAM running Windows, macOS or Linux
  • A reliable internet connection for the initial setup
  • No prior programming experience required

Tools you will use

Python 3.12+VS Codepip & venvpytestGit

By the end you can

  • Read and write Python confidently, including the parts beginners usually avoid
  • Choose the right data structure for a problem instead of using lists for everything
  • Structure a program across multiple files and modules
  • Handle errors deliberately rather than letting programs crash
  • Read and write files, and work with JSON and CSV data
  • Write classes when they help and avoid them when they do not
  • Write tests with pytest and understand why they save you time
  • Set up a virtual environment and manage dependencies like a professional
Reference code

Stuck? Compare your work

The finished capstone — a command-line expense tracker with 25 tests, built across module 11. Standard library only, so it runs with no install beyond Python itself.

It is there for when you are stuck, not to start from. Type the code yourself first — copying it will teach you very little.

View on GitHub
Syllabus

12 modules, 68 lessons

Work through these in order. Each lesson is short enough to finish in one sitting and ends with something to build, not a quiz.

  1. 1

    Getting Started

    Get Python running on your machine and understand what is actually happening when you run a program.

    1. What Python is, and what it is actually used for10 min
    2. Installing Python on Windows, macOS and Linux15 min
    3. Setting up VS Code for Python15 min
    4. Your first program, and what happens when you run it15 min
    5. The REPL: your fastest way to test an idea10 min
  2. 2

    Variables and Data Types

    The building blocks. Strings, numbers, booleans, and why type matters more than beginners expect.

    1. Variables and naming things well15 min
    2. Numbers: integers, floats, and the floating point trap20 min
    3. Strings and f-strings25 min
    4. Booleans, None, and truthiness15 min
    5. Type conversion and why input() always gives you a string15 min
  3. 3

    Control Flow

    Making decisions and repeating work — the point where a script becomes a program.

    1. if, elif and else20 min
    2. Comparison and logical operators15 min
    3. for loops and range()20 min
    4. while loops, and how to avoid infinite ones15 min
    5. break, continue and loop else15 min
    6. Practice: building a number-guessing game30 min
  4. 4

    Data Structures

    Lists, dictionaries, tuples and sets — and how to pick the right one instead of defaulting to a list.

    1. Lists: creating, indexing, slicing25 min
    2. List methods you will actually use20 min
    3. Dictionaries: the workhorse of Python25 min
    4. Tuples and when immutability helps15 min
    5. Sets and fast membership testing15 min
    6. Nested structures and working with real-world data25 min
    7. List and dictionary comprehensions25 min
    8. Choosing the right structure: a decision guide20 min
  5. 5

    Functions

    Writing reusable code, and understanding scope — the concept that trips up most self-taught beginners.

    1. Defining and calling functions20 min
    2. Arguments: positional, keyword and default25 min
    3. Return values, and functions that return nothing15 min
    4. Scope: local, global, and why your variable is not changing25 min
    5. *args and **kwargs20 min
    6. Docstrings and type hints20 min
    7. Practice: refactoring a messy script into functions30 min
  6. 6

    Errors and Debugging

    Reading a traceback, handling failure deliberately, and finding bugs without guessing.

    1. How to read a traceback20 min
    2. The errors every beginner hits, and what they mean25 min
    3. try, except, else and finally25 min
    4. Raising your own exceptions20 min
    5. Debugging with print, breakpoints and the VS Code debugger25 min
  7. 7

    Files and Data

    Reading and writing real data — the point where your programs start being useful.

    1. Reading and writing text files25 min
    2. Context managers and why you should always use with15 min
    3. Working with JSON25 min
    4. Working with CSV files25 min
    5. File paths done properly with pathlib20 min
  8. 8

    Modules, Packages and Environments

    Splitting code across files, using other people’s code, and keeping projects isolated.

    1. Modules and imports20 min
    2. The standard library tour: what is already built in25 min
    3. Virtual environments, and why they matter20 min
    4. Installing packages with pip and pinning requirements20 min
    5. Structuring a Python project25 min
  9. 9

    Object-Oriented Python

    Classes explained without the jargon — including when you should not use them.

    1. Why classes exist, explained with a real problem20 min
    2. Defining a class, __init__ and self25 min
    3. Methods, attributes and encapsulation25 min
    4. Inheritance and composition30 min
    5. Dunder methods: making your objects behave like built-ins25 min
    6. Dataclasses: less boilerplate20 min
    7. When a function is the better answer15 min
  10. 10

    Testing and Code Quality

    Writing tests, formatting code, and the habits that separate a hobbyist from a professional.

    1. Why tests save you time, with a worked example20 min
    2. pytest: writing your first tests30 min
    3. Arrange, act, assert and good test names25 min
    4. Formatting and linting with Ruff20 min
    5. Git basics for a Python project30 min
  11. 11

    Best Practices: Code Others Can Read

    Naming, size, docstrings and review. The difference between somebody who can make it work and somebody worth hiring.

    1. Naming things, which is most of the job35 min
    2. How big is too big35 min
    3. Docstrings, type hints and comments that say why30 min
    4. Asking forgiveness, and failing fast35 min
    5. Reading code, and reviewing it without being unbearable30 min
  12. 12

    Capstone Project

    Build a complete command-line application from scratch, with tests and a README.

    1. The brief: an expense tracker15 min
    2. Planning before you code20 min
    3. Building it step by step60 min
    4. Adding tests40 min
    5. Polish, README and publishing to GitHub30 min
Next courseKotlin Complete Foundation

Learning this with a mentor is faster

Going through a course like this one is how you qualify for our six-month internship, for selected students, mostly from Pune. Clear the interview and you build real-world projects with my mentorship.

About the internshipAll courses