Python Fundamentals

Master Python from basics to advanced concepts with 210 topics across 29 chapters

🐍 Complete Python Learning Path

This comprehensive curriculum covers everything you need to become a Python expert. Click on any chapter to explore topics, or use the sidebar to navigate directly to specific concepts.

Code Examples

Best Practices

Pythonic Code

Interview Tips

Introduction to Python

7 topics

What is Python?

Understanding Python as a programming language

Setting Up Python Environment

Installing Python and setting up development environment

Your First Python Program

Writing and running your first Python script

Python REPL

Interactive Python interpreter

Python 2 vs Python 3

Key differences and migration

Virtual Environments

Managing project dependencies with venv and pip

Python IDEs and Editors

PyCharm, VS Code, Jupyter Notebooks

Basic Syntax

9 topics

Variables and Assignment

Creating and using variables in Python

Data Types

int, float, str, bool, None

Operators

Arithmetic, comparison, logical, bitwise operators

Type Conversion

Converting between data types

Input and Output

print() and input() functions

Comments and Documentation

Single-line, multi-line comments, docstrings

Indentation

Python code blocks and structure

Naming Conventions

PEP 8 style guide for naming

Python Keywords

Reserved words in Python

Strings

8 topics

String Basics

Creating and using strings

String Methods

split, join, strip, replace, find

String Formatting

f-strings, format(), % formatting

String Slicing

Accessing substrings with slicing

String Operations

Concatenation, repetition, membership

Escape Sequences

Special characters in strings

Raw Strings

Raw string literals for regex and paths

Unicode and Encoding

Working with Unicode in Python

Control Flow

8 topics

If Statements

Conditional execution with if, elif, else

For Loops

Iterating with for loops

While Loops

Condition-based iteration

Break and Continue

Loop control statements

Pass Statement

Placeholder for empty blocks

Range Function

Generating sequences with range()

Enumerate

Getting index and value in loops

Match-Case (Python 3.10+)

Pattern matching in Python

Lists

7 topics

List Basics

Creating and using lists

List Methods

append, extend, insert, remove, pop, sort

List Slicing

Accessing sublists with slicing

List Comprehensions

Creating lists with comprehension syntax

Nested Lists

2D lists and matrices

List Operations

Concatenation, repetition, membership

Copying Lists

Shallow vs deep copy

Tuples

5 topics

Tuple Basics

Creating and using tuples

Tuple Operations

Accessing and unpacking tuples

Tuple Unpacking

Multiple assignment with tuples

Named Tuples

Creating tuples with named fields

Tuples vs Lists

When to use each

Sets

5 topics

Set Basics

Creating and using sets

Set Operations

Union, intersection, difference

Set Methods

add, remove, discard, pop

Frozen Sets

Immutable sets

Set Comprehensions

Creating sets with comprehension syntax

Dictionaries

7 topics

Dictionary Basics

Creating and using dictionaries

Dictionary Methods

get, keys, values, items, update

Dictionary Comprehensions

Creating dicts with comprehension syntax

Nested Dictionaries

Dictionaries within dictionaries

DefaultDict

Dictionaries with default values

OrderedDict

Order-preserving dictionaries

Counter

Counting occurrences

Functions

12 topics

Function Basics

Defining and calling functions

Parameters and Arguments

Positional, keyword, default arguments

Return Values

Returning single and multiple values

*args and **kwargs

Variable-length arguments

Variable Scope

Local, global, nonlocal scope

Recursion

Functions calling themselves

Lambda Functions

Anonymous functions

Closures

Functions remembering their environment

Decorators

Modifying function behavior

Higher-Order Functions

Functions as arguments and return values

Docstrings

Documenting functions

First-Class Functions

Functions as objects

Built-in Functions

8 topics

map, filter, reduce

Functional programming utilities

zip Function

Combining iterables

sorted and reversed

Sorting and reversing iterables

any and all

Testing conditions on iterables

min, max, sum

Aggregate functions

len, type, isinstance

Type and length checking

eval and exec

Dynamic code execution

dir and help

Introspection functions

Modules & Packages

8 topics

Importing Modules

import, from, as statements

Creating Modules

Writing your own modules

Packages

Organizing modules into packages

pip and Package Management

Installing and managing packages

Standard Library Overview

Built-in modules in Python

os Module

Operating system interactions

sys Module

System-specific parameters

datetime Module

Working with dates and times

Object-Oriented Programming

10 topics

Classes and Objects

Defining classes and creating objects

init Method

Object initialization

Instance Variables

Object-specific data

Class Variables

Shared class-level data

Methods

Instance, class, and static methods

self Keyword

Referencing the instance

Properties

Getters, setters with @property

Dunder Methods

Magic methods like __str__, __repr__

Dataclasses

Simplified class definitions

slots

Memory optimization for classes

Inheritance

6 topics

Single Inheritance

Inheriting from one parent class

Multiple Inheritance

Inheriting from multiple classes

super() Function

Calling parent class methods

Method Overriding

Replacing parent methods

Method Resolution Order (MRO)

How Python resolves methods

Mixins

Reusable functionality through inheritance

Polymorphism & Abstraction

5 topics

Duck Typing

If it walks like a duck...

Abstract Classes

Using abc module

Interfaces in Python

Protocols and ABCs

Operator Overloading

Custom operators for classes

Protocols (PEP 544)

Structural subtyping

Encapsulation

4 topics

Public and Private Members

Naming conventions for access control

Name Mangling

Double underscore prefix

Getters and Setters

Controlled access to attributes

Descriptors

Advanced attribute access control

Advanced OOP

6 topics

Metaclasses

Classes that create classes

Class Decorators

Decorators for classes

Singleton Pattern

Ensuring single instance

Factory Pattern

Object creation patterns

Composition vs Inheritance

Choosing the right approach

Dependency Injection

Loose coupling pattern

Exception Handling

8 topics

Try-Except Blocks

Basic exception handling

Multiple Exceptions

Catching different exception types

else and finally

Cleanup and success blocks

Raising Exceptions

Throwing exceptions with raise

Custom Exceptions

Creating your own exception classes

Exception Chaining

Preserving exception context

Context Managers

with statement and resource management

Assert Statements

Debugging with assertions

File Handling

9 topics

Opening and Closing Files

open() and close() functions

Reading Files

read, readline, readlines

Writing Files

write, writelines

File Modes

r, w, a, b, + modes

with Statement for Files

Context manager for files

Binary Files

Reading and writing binary data

JSON Files

Working with JSON data

CSV Files

Working with CSV data

pathlib Module

Modern path handling

Iterators & Generators

7 topics

Iterators

__iter__ and __next__ methods

Iterables

Objects that can be iterated

Generators

Creating iterators with yield

Generator Expressions

Memory-efficient comprehensions

itertools Module

Advanced iteration utilities

yield from

Delegating to subgenerators

Infinite Iterators

Generators that never end

Functional Programming

6 topics

Pure Functions

Functions without side effects

Immutability

Working with immutable data

functools Module

partial, reduce, lru_cache

Currying and Partial Application

Breaking down functions

Function Composition

Combining functions

Monads in Python

Optional, Result patterns

Type Hints & Annotations

7 topics

Type Hints Basics

Adding type annotations

typing Module

List, Dict, Optional, Union

Generics

Type variables and generic types

Type Aliases

Creating type shortcuts

mypy

Static type checking

Protocols

Structural subtyping

Runtime Type Checking

pydantic and validation

Concurrency

10 topics

Threading Basics

Creating and managing threads

Global Interpreter Lock (GIL)

Understanding Python GIL

Multiprocessing

Parallel processing with processes

asyncio Basics

async/await syntax

Coroutines

Cooperative multitasking

Event Loops

asyncio event loop

Thread Synchronization

Locks, semaphores, conditions

concurrent.futures

High-level concurrency

Thread-Safe Queues

queue module for IPC

Deadlocks and Race Conditions

Common concurrency issues

Testing

7 topics

unittest Module

Built-in testing framework

pytest

Popular testing framework

Test Fixtures

Setup and teardown

Mocking

unittest.mock for isolation

Test Coverage

Measuring code coverage

Test-Driven Development

Writing tests first

doctest

Testing through documentation

Debugging & Profiling

6 topics

pdb Debugger

Built-in Python debugger

Logging

logging module

Profiling

cProfile and profiling tools

Memory Profiling

Finding memory leaks

timeit Module

Measuring execution time

Traceback Analysis

Understanding stack traces

Database Access

6 topics

SQLite with Python

Built-in database support

Python DB-API

Standard database interface

ORM Basics

Object-Relational Mapping

SQLAlchemy

Popular ORM library

Connection Pooling

Managing database connections

Async Database Access

asyncpg, aiosqlite

Web Development Basics

7 topics

HTTP Basics

Understanding HTTP protocol

requests Library

Making HTTP requests

Flask Introduction

Microframework basics

Django Introduction

Full-stack framework basics

FastAPI Introduction

Modern async API framework

REST APIs

Building RESTful services

Web Scraping

BeautifulSoup, Scrapy

Data Science Essentials

7 topics

NumPy Basics

Numerical computing with arrays

Pandas Basics

DataFrames and data manipulation

Matplotlib

Data visualization

Jupyter Notebooks

Interactive computing

Data Cleaning

Preprocessing and cleaning data

Scikit-learn Introduction

Machine learning basics

Statistics with Python

Statistical analysis

Advanced Topics

7 topics

Metaprogramming

Code that generates code

Memory Management

Understanding Python memory

C Extensions

Writing Python extensions in C

Cython

Python with C performance

Packaging and Distribution

Creating distributable packages

Performance Optimization

Making Python code faster

Python Internals

How Python works under the hood

Best Practices

8 topics

PEP 8 Style Guide

Python code style conventions

Code Organization

Structuring Python projects

Documentation

Writing good documentation

Code Review

Best practices for reviews

Security Best Practices

Writing secure Python code

Linting and Formatting

pylint, flake8, black

Dependency Management

Managing project dependencies

CI/CD for Python

Continuous integration and deployment

💡 Interview Focus

Topics marked with 💼 in the sidebar are frequently asked in technical interviews. Make sure to pay special attention to these concepts for your interview preparation.