Python Programming

Learn how to install Python, configure your development environment, and use the interactive interpreter and IDE tools effectively.

Understand how Python handles variables, dynamic typing, and the core built-in types including integers, floats, strings, and booleans.

Master arithmetic, comparison, logical, and bitwise operators, and understand how Python evaluates expressions and handles type coercion.

Learn how to direct program execution using if/elif/else statements, for and while loops, break, continue, and the walrus operator.

Understand how to define and call functions, work with parameters and return values, and grasp variable scope and closure rules in Python.

Learn the differences between mutable lists and immutable tuples, including indexing, slicing, comprehensions, and common patterns.

Master key-value mappings with dictionaries and unique collections with sets, including their performance characteristics and use cases.

Dive deep into string methods, formatting (f-strings, format()), encoding, regular expressions, and text manipulation techniques.

Understand list, dict, and set comprehensions, generator expressions, and the yield keyword for memory-efficient iteration.

Learn how to define classes, create instances, use __init__ and other special methods, and understand the relationship between classes and objects.

Understand single and multiple inheritance, method resolution order (MRO), abstract base classes, and how polymorphism works in Python.

Master dunder methods like __repr__, __eq__, __hash__, __iter__, and __context__ to make your objects behave like built-in types.

Learn modern Python approaches to structured data using dataclasses, named tuples, and when to use each over regular classes.

Understand functions as objects, higher-order functions, closures, and common functional patterns like map, filter, and reduce.

Learn how decorators work under the hood, write your own function and class decorators, and understand common use cases like caching and logging.

Explore the standard library modules that provide powerful tools for functional-style programming, lazy evaluation, and function composition.

Master try/except/finally, custom exception hierarchies, context managers, and best practices for writing robust error handling code.

Learn to read and write files, work with paths using pathlib, and serialize data with JSON, CSV, and pickle.

Understand Python's import system, create your own packages, manage namespaces, and learn about relative vs absolute imports.

Learn to isolate project dependencies with venv, understand pip, requirements.txt, pyproject.toml, and modern tools like uv and poetry.

Add type annotations to your code, understand generics and protocols, and use mypy or pyright for static type checking.

Understand the GIL, when to use threads vs processes, and how to write concurrent code using threading, multiprocessing, and concurrent.futures.

Learn asynchronous programming with coroutines, the event loop, async iterators, and when async is the right choice over threads.

Explore Python's object model in depth — how classes are created, the descriptor protocol, and when metaclasses are the right tool.

Write unit tests, use fixtures and parameterization, mock dependencies, measure coverage, and integrate tests into your development workflow.

Profile your code, understand time and space complexity in practice, use caching, and know when to reach for C extensions or alternative implementations.