Skip to content

Introduction

Download slides (PDF) Open the video course

Six pictures cover the whole course: what you get, what you learn and in what order, how every section is taught, what you build, and the two ways to run the code yourself.

What You Get

Python for Absolute Beginners, by the numbers: from zero programming experience to writing and shipping your own Python programs. 13 sections, setup to classes, in order. 295 plus concepts, each one is a demo you can run. 60 plus practice problems where you write the code. 60 plus workshop problems, a bigger task per step, optional and for more practice. 2 real projects, built with you line by line. No experience needed: we install Python together, then start at print(), and nothing is assumed. Every solution included: try it yourself first, then compare with the full solution file. Every line on screen: you watch each line being typed and run, and nothing is pasted in already finished

What You Learn, and in What Order

Your Python journey: 13 sections, 295 plus concepts and 2 real projects, with 32 hours of video, every concept taught on screen line by line. Part 1, Foundations: Setup, then Variables and Data Types with 32 concepts in 1 hour 43 minutes, Strings and f-strings with 20 concepts in 1 hour 26, Operators and Conditionals with 19 in 1 hour 38, Collections with 51 in 3 hours 37, Loops and Comprehensions with 45 in 4 hours 08, and Functions with 47 in 5 hours 16, leading to Milestone Project 1, the CLI Expense Tracker, which uses only Sections 1 to 7, takes 7 build steps and runs 2 hours 18. Part 2, Leveling Up: Type Hints with 9 concepts in 38 minutes, Error Handling with 12 in 1 hour 31, Files JSON and Paths with 16 in 1 hour 15, Standard Library with 21 in 1 hour 09, Virtual Environments and Packaging which is 7 command-line steps in 1 hour 38, and Classes and OOP with 25 in 2 hours 13, leading to Milestone Project 2, the CLI Persistent Expense Tracker, which uses all Sections 1 to 13, takes 11 build steps and runs 3 hours 29

Python Keywords You Will Write

Python keywords, 30 of 35 by the end. Python has only 35 keywords and you will have written 30 of them yourself by the end of this course. Covered: True, False, None; and, or, not, in, is; if, elif, else; for, while, break, continue; def, return, lambda; class; try, except, finally, raise; import, from, as; global, nonlocal; with; and pass. Not covered here, and left for later courses: assert, del, yield, async and await, plus the four soft keywords match, case, underscore and type

How You Learn

How you learn here: the same rhythm in every section, and it ends in a real project rather than an exercise. Step 1, learn: a Concept is one small idea, a demo you run, and its exact output, written by Kalyan with every line typed on screen, and there are 295 plus concepts. Step 2, practice: a Practice problem is a short problem for that concept where you write the code and a solution file is there to compare against, and there are 60 plus problems. Step 3, combine: a Workshop is a bigger task that puts the concepts together, optional and for more practice, where you write the code and a solution file is there to compare against, and there are 60 plus problems. Step 4, build: a Project, where Milestone 1 builds the app and Milestone 2 rebuilds it properly, built by Kalyan with you line by line, across 2 milestone projects. Try first, then check: every practice and workshop problem ships with a full solution file, so attempt it yourself, then compare

Running the Concept Demos

Running the concept demos: every concept is a few lines you can run, and there are two ways to get them onto your machine. Way 1, from the course website at https python-for-beginners.stacksimplify.com: open the section page and find the concept, copy the code block in one click, paste it into that section's lecture file, then run it and compare with the output on the page. Way 2, from the GitHub repo at https github.com slash stacksimplify slash python-for-absolute-beginners: clone python-for-absolute-beginners once, open the section's python-learn folder, where every step is a file such as s05_step01_lists.py, and run it as it is with nothing to copy. Which one: typing it yourself sticks better, so use Way 1 while you learn, and keep the repo open as the finished reference and for the days you just want to run something fast

Practice and Workshop Problems

Practice and workshop problems: the same two routes as the demos, but here the point is that you write the code first. Way 1, on the course website at https python-for-beginners.stacksimplify.com: the Question gives the task and its expected output, the Hint is there if you are stuck and gives a nudge rather than the answer, and the Solution opens only after you have tried, with everything on one page so there is nothing to download to get started. Way 2, in the GitHub repo at https github.com slash stacksimplify slash python-for-absolute-beginners: the question file is python-practice slash s05_practice01_lists.py, which holds the task as comments with empty space below for you to write, and the solution file sits in the solutions folder as s05_practice01_sol_lists.py, with workshops working the same way under python-workshop. The one rule: the solution is always one click or one folder away, which makes it easy to peek, so write your own version first, even a wrong one, because that attempt is what makes the solution stick

Every Section at a Glance

One concept map per section, in the order you will meet them, with the two milestone projects where they land.

Section 01: set up your Python workbench. Pick your operating system, install two things, then everyone meets again for the same two steps. On macOS you install Python (download, install, verify, and try the REPL) and install VS Code (the editor, plus the Python extensions). On Windows you do the same two: install Python and install VS Code. Both paths then lead to the same two steps: VS Code Configuration, which is the theme, the file icons, and the course settings; and the course repo in VS Code, which you download, open, and find your way around. Watch the videos for your own operating system: on macOS follow the macOS install videos, on Windows follow the Windows ones, and from VS Code Configuration onward every video is the same for everyone

Variables and Data Types concept map

Strings and f-strings: concept map

Operators, Booleans, and Conditionals: concept map

Collections: concept map

Loops and Comprehensions: concept map

Functions: concept map (1 of 2)

Functions: concept map (2 of 2)

Milestone Project-1, what you will build: a real program you run from the terminal, built with dictionaries and functions and nothing beyond Sections 01 to 07. On screen, the Expense Tracker menu: 1 Add expense, 2 List expenses, 3 Total spent, 4 Spending by category, 5 Show one category, 6 Quit, and the prompt Choose 1 to 6, six choices and you write every one of them. Behind it, what you write in Project 1: one expense is a dictionary with three keys; all of them are a plain list held in main(); the five actions live in f5_actions.py, one function per menu choice; and the helpers f1 to f4 validate, format a row, total, and total by category. Project 1 comes after Section 07, in 7 build steps

Milestone Project-1: CLI Expense Tracker, what you will build. Seven steps build it, through the five menu actions. 01 Add expense, with add_expense() and is_valid_amount() over description, amount and category, built in Step-03. 02 List expenses, with list_expenses() and format_row(), built in Step-04. 03 Total spent, with show_total() and compute_total(), built in Step-05. 04 Spending by category, with show_by_category() and compute_by_category(), built in Step-06. 05 Show one category, with filter_by_category() and format_row(), built in Step-07

Type Hints: concept map

Error Handling and Debugging: concept map

Files, JSON and Paths concept map

Standard Library Essentials concept map

Environments and Packaging concept map

Classes and OOP Basics: concept map

Milestone Projects 1 and 2: what you build. One app, built twice. Project 1 with dictionaries and functions. Project 2 rebuilt with classes, with its data saved to a file. On screen, a terminal running the Expense Tracker menu: the title line, then 1 Add expense, 2 List expenses, 3 Total spent, 4 Spending by category, 5 Show one category, 6 Quit, and the prompt Choose 1 to 6. Green marks what changes in Project 2: the 2.0 added to the title, and choice 6, which becomes Save and quit. Behind it, four things change. One expense: a dictionary with three keys becomes class Expense, one object with four attributes. All of them: a plain list in main becomes class ExpenseBook, which holds the list and the methods. Choice 6: Quit, which just exits, becomes Save and quit, which writes the file first. After you quit: the data is gone because it lived in memory, and instead it is saved to data slash expenses dot json and is still there next run. Project 1 comes after Section 07, in 7 build steps. Project 2 comes after Section 13, in 11 build steps

Milestone Project-2: upgrade the CLI Expense Tracker to a Persistent Expense Tracker. The same Expense Tracker and the same menu, with Milestone 2 changing how it works inside, using Sections 08 to 13. One expense goes from a dictionary with three keys to an Expense object with attributes. Who owns the list goes from main() holding expenses to ExpenseBook owning it. Reading a value goes from expense of amount to expense.amount. Total spent, by category and one category all become methods on the book. Types gains hints in Section 08. Quit and restart goes from everything is gone to book.save() and book.load() writing data slash expenses dot json in Section 10. A broken file is handled with try and except in Section 09, a warning and no crash. New answers gain a created_at time stamp in Section 11. One package adds a .venv and pip install rich in Section 12, for a real table as a bonus

Milestone Project-2: CLI Persistent Expense Tracker, what you will build, 1 of 2. Eleven steps build it, and Steps 01 to 06 turn your Milestone 1 code into objects and a book. 01 Copy Milestone 1 in, with main() and show_menu(), so your tracker runs as 2.0. 02 Type hints everywhere, across all six files with no logic change. 03 One expense is an object, with class Expense and __init__(), so dictionary keys become object attributes. 04 ExpenseBook holds the list, and every action takes the ExpenseBook. 05 Helpers become methods in the ExpenseBook class. 06 Stamp every expense, with created_at and datetime.now(), to log each expense with a time stamp

Milestone Project-2: CLI Persistent Expense Tracker, what you will build, 2 of 2. Steps 07 to 11 give it a file, a guard, a full run, and the optional rich bonus. 07 Save to JSON, with save(), json.dumps() and write_text(), so choice 6 becomes save to a JSON file and quit. 08 Load it back, with load(), json.loads() and read_text(), so your data survives a restart. 09 Do not crash, with try and except and json.JSONDecodeError, handling a broken file with a warning and no crash. 10 Run it all, every one of the six choices against data slash expenses dot json, the finished Expense Tracker end to end. 11 The rich bonus, with a .venv, pip install rich and Console().print(), an installed package and a real table

Ready to begin? Section 01 sets up Python on your machine, then the sections run in order.

Prefer to learn by watching?

The full video course teaches every concept on screen and builds the projects with you, step by step.

Get the Video Course

Next: Section 01: Python Environment Setup

🎉 New Course
Python for Absolute Beginners
$15.99 $84.99 81% OFF
Get the Video Course