Complete Python Curriculum — From Basics to Advanced

This curriculum covers every topic you listed, with learning objectives, detailed subtopics, practical exercises,
mini-projects, suggested tools, and a checklist you can tick off as you learn.
Approach: theory + code + small exercises + 1 project per module. Aim for mastery: build, break, fix, and document.
Introduction & Learning Plan
Overview:
• Why learn Python: readability, ecosystem (web, data, automation), strong community.
• How to use this guide: follow sections sequentially for fundamentals; you can parallelize topics like Data Analysis
and Web once fundamentals are solid.
• Recommended weekly plan (example): 6–10 weeks foundation, 4–6 weeks intermediate, ongoing projects and
specialization.
• Tools: Python 3.11+ (or latest stable), PyCharm/VS Code, Git, GitHub, virtualenv/venv, Jupyter Notebook/Lab.
Basic Python Concepts
Learning objectives:
- Install Python and an IDE, run scripts.
- Understand basic data types, variables, input/output, string manipulation, and simple math.

Subtopics & notes:

1. Installing Python and PyCharm
- Install official Python from [Link] (choose stable 3.x).
- Setup PATH, verify with `python --version`.
- Install PyCharm Community (or use VS Code). Configure interpreter to use virtualenv.

2. Hello World program

- print("Hello, world!")
- Running via terminal, PyCharm run configs.

3. Mathematical operations
- +, -, *, /, // (floor), % (modulo), ** (power)
- Operator precedence and parentheses.

4. Strings
- Literals, escaping, raw strings, triple quotes.
- Indexing, slicing, immutability.

5. Accepting input
- input() returns string; convert with int(), float().

6. String operations & formatting

- Concatenation, `.join()`, `.split()`, `.strip()`, `.replace()`.
- f-strings (f"..."), `.format()`, % formatting.

7. Variables & in-place operators

- Naming conventions, dynamic typing.
- +=, -=, *=, //=, **=

8. First PyCharm program & debugging basics

- Breakpoints, step over, watch variables.

Practical exercises:
- Calculator: read two numbers, print sum, difference, product, quotient.
- Name parser: accept "First Last", output initials.

Mini project:
- CLI contact saver (store in CSV).
Control Structures
Learning objectives:
- Use conditional logic and loops to control program flow, process lists and iterative tasks.

Subtopics:
1. if / elif / else
- Nested conditions, truthiness, chained comparisons.
2. Lists
- Creation, indexing, append, extend, pop, remove, slicing.
3. List operations & functions
- len(), sorted(), reversed(), sum(), min(), max()
4. range()
- range(stop), range(start, stop, step) and using with loops.
5. Functions & code reuse (intro)
- def, docstrings, return values, scope (local vs global).
6. For loop & while loop
- iterate lists, enumerate(), zip(), loop control (break, continue).
7. Boolean logic
- and, or, not; De Morgan's laws.

Exercises & mini-projects:

- FizzBuzz
- Build frequency counter from input text
- Prime number sieve (simple)
Functions & Modules
Learning objectives:
- Write reusable functions, understand parameter passing, modularize code using modules and packages.

Subtopics:
1. Passing arguments: positional, keyword-only, default args, *args, **kwargs.
2. Return values & multiple returns (tuples).
3. Passing functions as arguments (higher-order functions).
4. Modules & packages: import, from ... import, __name__ == '__main__', creating packages with __init__.py.
5. Virtual environments and dependency management: pip, [Link], pipenv/poetry (overview).

Exercises:
- Small math module (factorial, permutations, combinations).
- Build a utility module and import it in multiple scripts.
Exception Handling & File Handling
Learning objectives:
- Handle errors gracefully, read/write files, and manage resources.

Subtopics:
1. Errors & exceptions: SyntaxError vs RuntimeError vs logical errors.
2. Try/except: specific exceptions, using Exception as e, else, finally blocks.
3. File handling: open(), read(), write(), with-context manager.
4. Reading and writing CSV and JSON files (use csv and json modules).
5. Appending to files, safe writes (temp files then move).
6. Logging basics with logging module.

Exercises:
- CSV reader that summarizes numeric columns.
- Log file analyzer that counts ERROR/WARNING entries.
Some More Types & Utilities
Learning objectives:
- Masterate compound types and useful operations.

Subtopics:
1. Dictionaries
- creation, access, get(), keys(), values(), items(), dict comprehensions.
2. Tuples
- immutability, packing/unpacking.
3. List slicing
- negative indices, step parameter.
4. List comprehensions
- simple and conditional comprehensions.
5. String formatting & functions
- .upper(), .lower(), .find(), .count(), regex intro.
6. Numeric functions & the math module
- [Link], [Link], random module basics.

Exercises:
- Word frequency dict from a file.
- Transform list using comprehension with a filter.
Functional Programming
Learning objectives:
- Learn functional tools for concise and expressive transformations.

Subtopics:
1. Functional programming concepts: pure functions, immutability.
2. Lambdas (anonymous functions).
3. map(), filter(), reduce() (from functools).
4. Generators and yield for memory-efficient iteration.
5. itertools module: chain, combinations, permutations, groupby.

Exercises:
- Use generators to stream large file processing.
- Build a pipeline using map/filter to transform data.
Object-Oriented Programming (OOP)
Learning objectives:
- Model problems with classes, inheritance, encapsulation, and polymorphism.

Subtopics:
1. Classes & objects: syntax, methods, attributes.
2. Class methods, static methods, and @property.
3. Constructors (__init__), instance vs class attributes.
4. Method implementation, special methods (__str__, __repr__).
5. Function-based vs OOP solutions.
6. Inheritance (single, multiple, multi-level) and super().
7. Operator overloading (__add__, etc).
8. Data hiding (name mangling) and composition vs inheritance.
9. Recursion examples and when to use them.
10. Sets and set operations.

Exercises:
- Build a simple BankAccount class with deposit/withdraw and transaction history.
- Implement a small shape hierarchy (Rectangle, Square, Circle).
Regular Expressions
Learning objectives:
- Use regex for searching, extracting, and validating text patterns.

Subtopics:
1. re module basics: compile, search, match, fullmatch, findall, finditer.
2. Substitution with [Link].
3. Special characters: ., ^, $, \d, \w, \s, character classes, quantifiers (*, +, ?), greedy vs lazy.
4. Groups and named groups, lookahead/lookbehind (advanced).
5. Practical tasks: validate email/phone, extract timestamps, log parsing.

Exercises:
- Build a small log parser using regex to extract fields.
GUI Apps with Tkinter
Learning objectives:
- Build basic desktop GUI apps using Tkinter.

Subtopics:
1. Tkinter basics: root window, mainloop.
2. Using Frames and Grid layout.
3. Widgets: Label, Button, Entry, Text, Listbox, Combobox.
4. Handling events and callbacks.
5. Using classes to structure Tk apps.
6. Toolbars, status bar, messagebox, simple drawing with Canvas.

Project:
- Build a simple note-taking app with save/load using file dialogs.
Building Calculator App with Tkinter
Step-by-step:
- Part 1: layout and numeric buttons wiring.
- Part 2: expression building and safe evaluation (avoid eval; use ast or custom parser).
- Part 3: add memory, clear, decimal handling.
- Part 4: polish UI, keyboard bindings, error handling.

Exercises:
- Add history and copy/paste support.
Building Database Apps with PostgreSQL & Python
Learning objectives:
- Connect Python apps to PostgreSQL, perform CRUD, and build simple data-driven apps.

Subtopics:
1. Databases basics: relational concepts, SQL CRUD.
2. PostgreSQL: installation overview, pgAdmin.
3. Creating databases and tables, primary keys, foreign keys.
4. psycopg2 basics: connect, execute, commit, parameterized queries to avoid SQL injection.
5. Using ORMs briefly (SQLAlchemy or Django ORM).
6. Virtualenv setup, installing psycopg2 (binary vs source), handling connection strings.
7. Create table, insert, select, update, delete from Python.
8. Build a small app layout: forms -> validation -> save to DB.
9. Search functionality and listing entries with pagination.

Project:
- Contact management app with search and detail view.
Data Analysis Using Python
Learning objectives:
- Use Python's data stack to load, clean, analyze, and visualize data.

Subtopics:
1. Jupyter Notebooks / Lab: interactive exploration.
2. NumPy for arrays and numerical ops.
3. Pandas for DataFrame operations: read_csv, groupby, pivot_table, merging, joins, handling missing data.
4. Data cleaning: treating missing values, outliers, normalization.
5. Exploratory Data Analysis (EDA): summary stats, correlations.
6. Visualization: Matplotlib, Seaborn basics (plot types, saving figures).
7. Introduction to machine learning pipeline: scikit-learn basics (train/test split, basic models).
8. Feature engineering and simple model evaluation metrics.

Projects:
- EDA for a public dataset (e.g., Titanic or any CSV).
- Simple predictive model pipeline (linear regression or classification).
Make Web Applications in Python Using Django
Learning objectives:
- Build and deploy web apps with Django: models, views, templates, forms, authentication.

Subtopics:
1. Django project and app structure.
2. Models and migrations.
3. Admin interface and registering models.
4. Views (function-based and class-based), URL routing.
5. Templates and static files.
6. Forms and validation.
7. Authentication and permissions.
8. REST APIs with Django REST Framework (overview).
9. Deployment basics: collectstatic, Gunicorn, Nginx, environment variables.
10. Security best practices: SECRET_KEY, DEBUG False, SQL injection considerations, CSRF, XSS.

Projects:
- Build a blog with CRUD, user accounts, and comments.
- Extend to a REST API and simple frontend with Bootstrap or React.
Capstone Projects & Real-World Practice
Capstone ideas:
- Full-stack app: Django backend + React frontend + PostgreSQL (e.g., task manager).
- Data project: End-to-end analysis and model including EDA, feature engineering, and deployment (Flask/Django
REST serving).
- Automation: build scripts that integrate with APIs (e.g., Twitter scraping, automating Excel reports).

Advice:
- Version control: use Git, make clear commits.
- Write tests: pytest basics.
- Document: README, setup instructions.
- Deploy small projects (Heroku/Render/VPS) to learn ops.
Study Checklist (tick as you go)
Below is a checklist you can use. Each section has many sub-items — use these to track mastery.

Basic Python Concepts:

■ Install Python & IDE and run "Hello World"
■ Mathematical operations and precedence
■ Strings, indexing & slicing
■ Input handling & type conversion
■ Variables & in-place operators
■ Run & debug in PyCharm

Control Structures:
■ if / elif / else
■ Lists: create, modify, slice
■ List functions & range
■ For & while loops, enumerate & zip
■ Functions: def, return, scope
■ Boolean logic

Functions & Modules:

■ Positional & keyword args, *args, **kwargs
■ Return values & docstrings
■ Modules & packages, __main__
■ Virtualenv & requirements

Exceptions & Files:

■ Try/except/else/finally
■ File read/write & with-context
■ CSV & JSON handling
■ Basic logging

Types & Utilities:

■ Dictionaries & dict methods
■ Tuples & unpacking
■ Comprehensions & slicing
■ String & numeric functions

Functional Programming:
■ Lambdas, map, filter, reduce
■ Generators & yield
■ itertools basics

OOP:
■ Class & instance attributes
■ Methods, @classmethod, @staticmethod
■ Inheritance & polymorphism
■ Operator overloading & data hiding

Regex:
■ Basic patterns, search, findall, sub
■ Groups & named groups
■ Practical validation tasks

GUI (Tkinter):
■ Widgets, layout, events
■ Using classes for apps
■ File dialogs & message boxes
■ Build calculator & note app

Databases:
■ SQL basics (SELECT/INSERT/UPDATE/DELETE)
■ PostgreSQL setup & psycopg2 queries
■ ORM overview
■ Build CRUD app & search

Data Analysis:
■ Jupyter basics
■ NumPy arrays
■ Pandas DataFrame ops
■ EDA & visualization
■ Basic ML pipeline (sklearn)

Django:
■ Create project & apps
■ Models, migrations, admin
■ Views, templates, forms
■ Authentication & deployment

Final Tasks:
■ Build at least 3 complete projects
■ Write tests for core functions
■ Deploy one app online
■ Keep a portfolio/GitHub updated