Learn Python —
Beginner to Professional

No programming experience needed. You will write and run your first Python program in module 1 and understand all core data structures by module 5.

1. 01Introduction to Python
   • History of Python — Guido van Rossum, Python 2 vs Python 3, Python 3.13
   • Why Python? Most popular language, data science, AI, automation, web
   • Installing Python 3.13+ from python.org and setting up PATH
   • IDEs: VS Code (with Python extension), PyCharm, Jupyter Notebook, IDLE
   • Writing and running your first program: print("Hello, World!")
   • Python's REPL (interactive interpreter) for quick experiments
2. 02Basic Syntax and Data Types
   • Variables: dynamic typing, naming conventions (snake_case)
   • Data types: int, float, complex, str, bool, NoneType
   • Type conversion: int(), float(), str(), bool()
   • Input/output: print(), input(), f-strings, format(), %
   • Comments: # single-line and """ """ multi-line docstrings
   • Indentation: Python's block structure — 4 spaces standard
3. 03Operators
   • Arithmetic: +, -, *, /, //, %, ** (integer division, modulo, exponent)
   • Comparison: ==, !=, >, <, >=, <= — return True/False
   • Logical: and, or, not — short-circuit evaluation
   • Assignment: =, +=, -=, *=, /=, //=, **=
   • Membership: in, not in — check if value is in a sequence
   • Identity: is, is not — check object identity (not equality)
4. 04Control Flow
   • if, elif, else — conditional execution
   • match-case statement — Python 3.10+ structural pattern matching
   • while loops — condition-based repetition
   • for loops — iterating over sequences and ranges
   • break, continue, pass — loop control
   • else clause on loops — runs when loop completes without break
5. 05Data Structures
   • Strings: indexing, slicing, methods (.strip, .split, .join, .replace, .upper)
   • Lists: creation, indexing, slicing, methods (append, pop, sort, reverse)
   • List comprehensions: [x*2 for x in range(10) if x % 2 == 0]
   • Tuples: immutable sequences, packing/unpacking, named tuples
   • Dictionaries: key-value pairs, all methods, dict comprehensions
   • Sets: unique values, union/intersection/difference, set comprehensions

Functions, OOP, file handling, and error management — the tools needed to write real, reusable Python programs.

6. 06Functions
   • Defining functions with def and calling them
   • Positional, keyword, default, and variable-length arguments
   • *args (tuple of extra positional args) and **kwargs (dict of extra keyword args)
   • Lambda functions: anonymous single-expression functions
   • Scope and closures: LEGB rule (Local, Enclosing, Global, Built-in)
   • Recursion: base case, recursive case, call stack, sys.setrecursionlimit
7. 07Modules and Packages
   • Importing modules: import, from-import, import as
   • Built-in modules: math, random, datetime, os, sys, pathlib, re
   • Creating custom modules and __init__.py packages
   • Virtual environments: venv, pip install, requirements.txt
   • if __name__ == "__main__": — module execution guard
8. 08File Handling
   • Reading and writing text files: open(), read(), write(), readlines()
   • The with statement as context manager — automatic file closing
   • File modes: r (read), w (write), a (append), rb/wb (binary)
   • Handling CSV files: csv module and reading/writing CSV data
   • Handling JSON files: json.load(), json.dump(), json.loads(), json.dumps()
   • pathlib.Path for cross-platform file and directory operations
9. 09Exception Handling
   • try / except / else / finally blocks
   • Catching specific exceptions: ValueError, TypeError, FileNotFoundError
   • Raising exceptions: raise ValueError("message")
   • Custom exception classes: class AppError(Exception)
   • Exception chaining: raise from — preserving the original traceback
10. 10Object-Oriented Programming (OOP)
    • Classes and objects: class definition, instantiation, attributes
    • __init__() constructor and self parameter
    • Instance variables vs class variables
    • Inheritance, super(), method overriding
    • Encapsulation: public, _protected, __private (name mangling)
    • Dunder methods: __str__, __repr__, __len__, __eq__, __add__, __iter__
11. 11Advanced OOP
    • @dataclass — auto-generate __init__, __repr__, __eq__ from fields
    • Abstract classes with ABC and @abstractmethod
    • @property, @setter, @deleter — computed and validated properties
    • @classmethod (receives cls) and @staticmethod (receives nothing)
    • Multiple inheritance and Method Resolution Order (MRO)
    • __slots__ for memory-efficient class instances

Decorators, generators, asyncio, and databases — the Python features that separate intermediate programmers from professional developers.

12. 12Advanced Python Features
    • Decorators: wrapping functions, @functools.wraps, stacking decorators
    • Parameterized decorators (decorator factories)
    • Generators: yield, generator functions vs list comprehensions, send()
    • Generator expressions: (x**2 for x in range(1000)) — memory-efficient
    • Iterators: __iter__ and __next__, iter(), next(), StopIteration
    • Context managers: __enter__/__exit__, @contextlib.contextmanager
13. 13Concurrency and Parallelism
    • Python's GIL — why threading doesn't parallelize CPU-bound code
    • threading: Thread, Lock, RLock, Queue — I/O-bound concurrency
    • multiprocessing: Process, Pool, Queue — true CPU parallelism
    • concurrent.futures: ThreadPoolExecutor, ProcessPoolExecutor, map()
    • asyncio: event loop, async def, await, asyncio.gather(), aiohttp
    • When to use threading vs multiprocessing vs asyncio
14. 14Working with Databases
    • SQLite with sqlite3: connect, create table, INSERT, SELECT, UPDATE, DELETE
    • Parameterized queries to prevent SQL injection
    • SQLAlchemy ORM: models, sessions, relationships, migrations with Alembic
    • Using PostgreSQL and MySQL with Python (psycopg2, PyMySQL)
    • Connection pooling and best practices for database management
15. 15Testing and Debugging
    • Python's pdb debugger: breakpoints, step, next, inspect variables
    • unittest: TestCase, assert methods, setUp/tearDown, test discovery
    • pytest: simpler syntax, fixtures, parametrize, plugins, coverage
    • Mocking with unittest.mock: Mock, MagicMock, patch, side_effect
    • Test-Driven Development (TDD): red → green → refactor workflow
    • Logging with the logging module — structured application logs

Django, Flask, NumPy, Pandas, scikit-learn, and packaging — the full Python ecosystem used by professional developers at Google, Netflix, Instagram, Spotify, and NASA.

16. 16Web Development with Flask
    • Flask fundamentals: app, routes (@app.route), request/response cycle
    • Jinja2 templates: rendering HTML, template inheritance, variables
    • Forms and POST data: request.form, WTForms
    • Flask Blueprints for modular applications
    • Flask with SQLAlchemy: database-backed Flask apps
17. 17Web Development with Django
    • Django's MTV architecture: Models, Templates, Views
    • Django ORM: models, migrations (makemigrations, migrate), querysets
    • Django admin panel for automatic CRUD interfaces
    • Django REST Framework (DRF) for building REST APIs
    • Authentication, sessions, middleware, and deployment (Gunicorn + Nginx)
    • FastAPI introduction: async REST APIs with type hints and auto-docs
18. 18NumPy — Numerical Computing
    • NumPy ndarray: creating arrays (np.array, np.zeros, np.linspace, np.arange)
    • Array indexing, slicing, and boolean masking
    • Broadcasting: operations on arrays with different shapes
    • Universal functions (ufuncs): np.sqrt, np.exp, np.sin — vectorized speed
    • Linear algebra: np.dot, np.linalg.inv, np.linalg.eig
    • Random number generation: np.random for simulations and ML
19. 19Pandas — Data Analysis
    • Series and DataFrame: creation, indexing (loc, iloc), dtypes
    • Loading data: read_csv(), read_excel(), read_json(), read_sql()
    • Data cleaning: dropna(), fillna(), astype(), rename(), drop duplicates
    • Data transformation: apply(), map(), groupby(), pivot_table(), melt()
    • Merging and joining DataFrames: merge(), concat(), join()
    • Time series analysis: DatetimeIndex, resample(), rolling()
20. 20Data Visualization
    • Matplotlib: line plots, bar charts, scatter plots, histograms, subplots
    • Matplotlib figure/axes API — customizing titles, labels, legends, colors
    • Seaborn: statistical visualization built on Matplotlib
    • Seaborn: heatmaps, pairplots, violin plots, boxplots, FacetGrid
    • Plotly for interactive visualizations in Jupyter Notebooks and web apps
21. 21Machine Learning with scikit-learn
    • Machine learning concepts: supervised vs unsupervised learning
    • Preprocessing: train_test_split, StandardScaler, LabelEncoder, OneHotEncoder
    • Classification: Logistic Regression, Decision Trees, Random Forests, SVM, KNN
    • Regression: Linear Regression, Ridge, Lasso, evaluation (MSE, R²)
    • Unsupervised: K-Means clustering, DBSCAN, PCA dimensionality reduction
    • Model evaluation: cross-validation, confusion matrix, precision, recall, F1
22. 22Advanced Topics
    • Metaclasses: class creation with type(), custom metaclasses
    • Descriptors: __get__, __set__, __delete__ — how @property works internally
    • Type hints: PEP 484, mypy, Annotated, TypeVar, Protocol, typing module
    • Python 3.13 features: new type parameter syntax, improved error messages
    • Packaging: pyproject.toml, build, twine — publishing a package to PyPI