About Python
Python is a general-purpose language that reads close to plain English, which is why
it's often the first language people learn and one of the most common ones used at
work. This course walks through it the way most developers actually learn it. It
starts with Introduction to Python (what it's used for, and how
it compares to other languages) and Installation & Setup
(interpreters, virtual environments, and running your first script).
Next comes Syntax & Basics: variables, types, and operators,
followed by Data Structures (lists, tuples, dicts, and sets) and
Control Flow & Loops. From there, Functions &
Scope covers writing reusable code, arguments, and closures, while
Modules, Packages & Environments covers organizing code and
managing dependencies with pip and virtual environments.
Object-Oriented Programming covers classes, inheritance, and
dunder methods. Files, Exceptions & Errors covers reading and
writing files and handling things going wrong gracefully, and
Standard Library & Third-Party Packages covers the tools that
ship with Python plus popular packages from PyPI.
Finally, Testing, Debugging & Concurrency covers writing tests
with pytest, debugging techniques, and running code concurrently with threading,
multiprocessing, and asyncio: the natural next step once single-threaded scripts
feel routine.
Content
11 modules
01
Introduction to Python
What Python is used for, why it's popular, and how it compares to other languages you might already know.
Use CasesInterpreted LanguagePython vs Other Languages
02
Installation & Setup
Getting Python running on your machine, picking an interpreter version, and setting up a virtual environment.
CPythonvenvpip
03
Syntax & Basics
Variables, core data types, operators, and the indentation-based syntax that shapes every Python program.
VariablesData TypesOperators
04
Data Structures
Storing and organizing data with lists, tuples, dictionaries, and sets, plus when to reach for each one.
Lists & TuplesDictionariesSets
05
Control Flow & Loops
Directing a program's logic with conditionals, for and while loops, and list comprehensions.
if/elif/elsefor & whileComprehensions
06
Functions & Scope
Writing reusable code with functions, arguments and return values, default and keyword arguments, and closures.
Arguments*args/**kwargsClosures
07
Modules, Packages & Environments
Splitting code across files and packages, and managing project dependencies cleanly.
importVirtual Environmentsrequirements.txt
08
Object-Oriented Programming
Modeling problems with classes and objects, inheritance, and the dunder methods that make objects feel native.
ClassesInheritanceDunder Methods
09
Files, Exceptions & Errors
Reading and writing files safely, and handling errors with try/except so programs fail gracefully.
File I/Otry/exceptContext Managers
10
Standard Library & Third-Party Packages
The batteries-included tools that ship with Python, and popular packages from PyPI worth knowing.
os & pathlibdatetime & jsonPyPI
11
Testing, Debugging & Concurrency
Writing tests with pytest, debugging techniques, and running code concurrently with threading, multiprocessing, and asyncio.
pytestDebuggingasyncio
Projects
5 builds
Build a Command-Line To-Do App
Use core data structures and control flow to build a script that adds, lists, and removes tasks from the terminal.
Parse and Analyze a CSV File
Read a real dataset with pandas, clean it up, and summarize it with sorting, filtering, and group-by.
Model a Library System with Classes
Practice object-oriented design by modeling books, members, and loans as classes with clear relationships.
Fetch and Store Data from a Public API
Call a public API with requests, handle errors that come back, and save the results to a JSON file.
Write a Test Suite with pytest
Add unit tests to one of your earlier projects and learn to catch regressions before they ship.
What You Can Do After This Course
By the end of the curriculum you'll have worked through 5 hands-on projects and
covered the core of what a developer role expects from someone who "knows Python."
Concretely, you'll be able to:
Write clean, idiomatic Python — comfortable with syntax, types, and the language's conventions.
Work with data structures fluently — choose between lists, tuples, dicts, and sets without guessing.
Structure larger programs — split code into functions, modules, and packages, and manage dependencies with virtual environments.
Design with objects — model problems with classes, inheritance, and Python's dunder methods.
Handle files and failures — read and write data safely and handle errors with try/except.
Reach for the right tool — know the standard library well and pull in third-party packages from PyPI when needed.
Test and scale your code — write tests with pytest, debug confidently, and run work concurrently when it counts.