Click any module to expand. Covers Python 3.6+ (f-strings), 3.8 (walrus operator), 3.10 (match-case), 3.12+ (improved error messages). Not legacy Python 2 — modern Python as used in industry and interviews today.
How Python works, setting up the environment, and core language building blocks
Why Python dominates: readability, vast ecosystem, community size. CPython vs PyPy. Python's role in web dev (Django/Flask), data science (Pandas/NumPy), AI/ML (TensorFlow/PyTorch), automation, and scripting. Python 2 vs 3 — why 2 is dead.
Installing Python 3.12+. Setting up VS Code / PyCharm / Jupyter Notebook. Running scripts from terminal. REPL for experimentation. Understanding PATH and python vs python3.
id() function, is vs ==. Reference counting and garbage collection. Mutable vs immutable types — the single most important Python concept. Why integers are cached (-5 to 256). How variable assignment works (names bound to objects, not boxes holding values).
int (arbitrary precision), float (IEEE 754), complex, bool, str, None. Dynamic typing — variables don't have types, objects do. Type checking with type() and isinstance(). var keyword doesn't exist — Python infers types.
Arithmetic (// floor division, ** power, % modulo). Comparison (==, is). Logical (and, or, not — short-circuit). Bitwise (&, |, ^, ~, <<, >>). Walrus operator := (Python 3.8) — assignment inside expressions.
input() returns strings — always cast. print() with sep, end, file parameters. String formatting: f-strings (Python 3.6+, the modern way), .format(), % formatting (legacy). f-string expressions: f"{name!r}" f"{price:.2f}".
if/elif/else (no switch in old Python). for with range(), while, break, continue, else clause on loops. match-case structural pattern matching (Python 3.10) — Python's answer to switch, but far more powerful.
Python's built-in data structures — the most powerful in any mainstream language
List creation, indexing (positive/negative), slicing (start:stop:step). append, extend, insert, remove, pop, sort, reverse. List as a dynamic array — O(1) append, O(n) insert at beginning. Deep copy vs shallow copy (copy module).
Why tuples exist when lists do (hashable, faster, semantic "record" meaning). Tuple packing/unpacking: a, b = b, a (swap). Extended unpacking: first, *rest = [1,2,3,4]. Named tuples from collections. Tuples as dict keys.
dict creation, access ([], .get()), .keys(), .values(), .items(). Guaranteed insertion order (Python 3.7+). Dictionary comprehensions. Merging dicts: {**d1, **d2} and d1 | d2 (Python 3.9). defaultdict and Counter from collections.
Unique elements, O(1) membership testing. Set operations: union (|), intersection (&), difference (-), symmetric_difference (^). frozenset — immutable sets usable as dict keys. Duplicate removal: list(set(data)).
List comprehension: [x**2 for x in range(10) if x%2==0]. Dict comprehension: {k:v for k,v in items}. Set comprehension. Generator expressions (lazy evaluation with parentheses). Nested comprehensions for matrix operations.
Counter — frequency counting in one line. defaultdict — never get KeyError again. deque — O(1) append/pop from both ends. namedtuple — lightweight immutable records. OrderedDict (less useful since Python 3.7). ChainMap.
Text processing, building reusable functions, and Python's functional toolkit
Immutability of strings. split(), join(), strip(), replace(), find(), startswith(), endswith(), upper/lower/title. String slicing and reversal ([::-1]). Regular expressions basics with re module (match, search, findall, sub).
Function definition, parameters, return values (multiple returns via tuple unpacking). Docstrings and help(). First-class functions — functions are objects (assignable, passable, storable). Type hints: def greet(name: str) -> str.
Positional, keyword, default arguments. *args (variable positional), **kwargs (variable keyword). Argument unpacking: func(*list), func(**dict). Keyword-only arguments (after *). Positional-only arguments (before /, Python 3.8).
Local, Enclosing, Global, Built-in scope resolution. global and nonlocal keywords. Closures — functions that remember their enclosing scope. Why closures matter for decorators and callbacks. Common scope pitfalls with mutable defaults.
Lambda: anonymous single-expression functions. map() — apply function to every element. filter() — keep elements matching condition. reduce() (from functools) — accumulate to single value. When to use vs list comprehension.
Recursive patterns in Python (factorial, Fibonacci, tree traversal). Python's recursion limit (default 1000, sys.setrecursionlimit). Higher-order functions — functions that accept or return functions. sorted() with key parameter.
enumerate() — index + value together. zip() — parallel iteration. zip_longest from itertools. all(), any(), sum(), min(), max() with key. reversed(), sorted() with custom keys. The Python iteration protocol.
Classes, inheritance, dunder methods, decorators, and Pythonic OOP patterns
Class definition, __init__ constructor, self parameter. Instance vs class attributes. Creating and using objects. Everything is an object in Python — even classes (type metaclass).
__str__ vs __repr__ (human vs developer representation). __eq__, __hash__ (making objects comparable and hashable). __len__, __getitem__, __setitem__ (making objects behave like containers). __add__, __mul__ (operator overloading). __enter__, __exit__ (context managers).
Python's convention-based access control: public (name), protected (_name), private (__name — name mangling). No true access restriction — "we're all consenting adults." Property decorator for controlled access.
@property — Pythonic getters/setters (no explicit get_name()/set_name()). @classmethod — methods that receive the class, not instance (factory pattern). @staticmethod — utility methods with no access to class/instance. When to use each.
Single and multiple inheritance. super() — cooperative method resolution. MRO algorithm (C3 linearisation). Diamond inheritance problem and how Python resolves it (unlike C++). Mixin pattern. isinstance() and issubclass().
ABC and @abstractmethod — enforcing interface contracts. Why Python needs ABCs when it has duck typing. collections.abc: Iterable, Sequence, Mapping — checking structural types. Designing class hierarchies with ABCs.
@dataclass (Python 3.7) — auto-generated __init__, __repr__, __eq__. field() for defaults, frozen=True for immutability. __slots__ — memory optimisation by preventing __dict__ creation. When to use dataclass vs regular class vs namedtuple.
Advanced Python patterns that power frameworks, libraries, and elegant code
What a decorator IS (a function that wraps another function). Building decorators from first principles: closures → wrapper function → @syntax. Decorators with arguments. functools.wraps for preserving metadata. Real-world: @timer, @retry, @cache, @login_required.
@functools.lru_cache — memoisation in one line (Fibonacci from O(2^n) to O(n)). @functools.cache (Python 3.9). @functools.total_ordering. @functools.wraps. How Flask's @app.route works under the hood.
__iter__() and __next__() — how for loops actually work. Building custom iterators. StopIteration exception. iter() with sentinel value. Why iterators are memory-efficient (lazy evaluation). The difference between iterable and iterator.
Generator functions (yield instead of return). Generator expressions (parentheses instead of brackets). yield from for delegating to sub-generators. Memory efficiency — processing million-row files without loading them into memory. send() and generator-based coroutines.
How with works (__enter__, __exit__). File handling with context managers. contextlib.contextmanager decorator — creating context managers from generators. Building custom context managers for database connections, timer utilities, and temporary state changes.
itertools: chain, product, permutations, combinations, groupby, islice, count, cycle, repeat. functools: partial, reduce, lru_cache, total_ordering. Writing efficient, memory-conscious Python using these standard library tools.
Writing robust code, working with files, and organising Python projects
try-except for catching specific exceptions. else clause — runs only if no exception (often missed). finally — guaranteed cleanup. Multiple except blocks. Exception chaining with from. Bare except — why it's dangerous.
BaseException → Exception hierarchy. Creating custom exceptions (subclass Exception). raise keyword. When to raise vs when to return error codes. EAFP vs LBYL — Python's "ask forgiveness, not permission" philosophy.
open() modes: r, w, a, r+, b (binary). with open() as f — the Pythonic way (never forget to close). read(), readline(), readlines() vs iteration. Writing with write() and writelines(). pathlib.Path — modern file path handling (Python 3.4+).
json.dumps() / json.loads() — Python dict ↔ JSON string. json.dump() / json.load() for file I/O. csv module: reader, writer, DictReader, DictWriter. pickle for Python object serialisation (and why it's insecure for untrusted data).
import, from...import, as alias. __name__ == "__main__" guard — why every script needs it. Creating packages with __init__.py. Relative vs absolute imports. sys.path and how Python finds modules.
Why virtual environments matter (dependency isolation). venv creation and activation. pip install, pip freeze, requirements.txt. The Python packaging ecosystem. pyproject.toml (modern project configuration).
Type hints: def greet(name: str) -> str. Typing module: List, Dict, Optional, Union, Tuple, Any. Why type hints matter — better IDE support, documentation, and team collaboration. mypy for static type checking. Not enforced at runtime.
The data science starter kit — numerical computing, data analysis, and charting
ndarray creation: array(), zeros(), ones(), arange(), linspace(). Array indexing, slicing, boolean indexing. Vectorised operations (element-wise math without loops). Broadcasting rules. reshape, flatten, transpose. Why NumPy is 50x faster than Python lists for numerical work.
Matrix multiplication (@ operator, np.dot). np.linalg: inverse, determinant, eigenvalues. Statistical functions: mean, median, std, var, percentile. Random number generation: np.random. Practical: processing image data as arrays.
Series (1D labelled array) and DataFrame (2D table). Creating from dicts, lists, CSV files. Indexing: loc (label), iloc (position). Head, tail, shape, info, describe — exploring data. Column selection, filtering rows, adding/dropping columns.
Handling missing data: isna, dropna, fillna. Data types and conversion (astype). String methods via .str accessor. Sorting (sort_values, sort_index). Renaming columns. apply() for custom transformations. Lambda with apply for row-level logic.
groupby() — split-apply-combine pattern. Aggregation: sum, mean, count, agg() with custom functions. merge() — SQL-style joins (inner, left, right, outer). concat() — stacking DataFrames. pivot_table() — Excel-style summarisation.
Matplotlib: figure, axes, plot, scatter, bar, hist, pie. Subplots and customisation (titles, labels, legends, colours). Seaborn: statistical plots (boxplot, heatmap, pairplot, countplot). Saving figures. When to use Matplotlib vs Seaborn.
Concurrency, quality assurance, and Python 3.10+ features
threading module — GIL (Global Interpreter Lock) and why threads don't give true parallelism for CPU-bound work. multiprocessing — bypassing GIL with separate processes. concurrent.futures: ThreadPoolExecutor, ProcessPoolExecutor. When to use which.
Event loop, coroutines, async def, await. asyncio.run(), asyncio.gather() for concurrent I/O. Async context managers and iterators. When async is the right choice (I/O-bound: API calls, file reads, database queries) vs when it's wrong (CPU-bound).
Pattern syntax: character classes, quantifiers, anchors, groups. re.match, re.search, re.findall, re.sub. Compiled patterns for performance. Named groups. Practical: email validation, log parsing, data extraction from text.
Why testing matters. unittest: TestCase, setUp, tearDown, assert methods. pytest: simpler syntax, fixtures, parametrize. Writing test cases for functions and classes. Test-driven development (TDD) basics. Coverage reporting.
os module: environment variables, process info, os.path. sys module: command-line arguments (sys.argv), Python path, exit codes. pathlib.Path — modern, object-oriented file paths. Practical: building CLI tools and file processing scripts.
match-case structural pattern matching (3.10). Exception groups and except* (3.11). Improved error messages with suggestions (3.11/3.12). Performance improvements (3.11 — 25% faster). tomllib for TOML parsing (3.11). What's coming in Python 3.13+.
Anagrams, palindromes, frequency counts, sorting — using Pythonic idioms, not C-style loops.
Library/banking/e-commerce system using classes, inheritance, dunder methods, and dataclasses.
Build @timer, @retry, @validate decorators from scratch — understanding how Flask/Django work under the hood.
Clean, transform, and visualise a real dataset (CSV/JSON) using Pandas and Matplotlib — the daily workflow of a data analyst.
Build a command-line tool that reads files, processes data (regex/JSON), and outputs results — using argparse, pathlib, and virtual environments.
Write a utility module with full test coverage — learning TDD by doing, not by reading about it.
Expert trainers explain concepts, live-code solutions, and demonstrate Pythonic patterns. 3–5 sessions per week, each with interactive exercises.
Daily Python problems on our platform — data structure manipulation, string processing, and OOP tasks with Python 3.12 interpreter and automated testing.
MCQ tests on Python concepts + timed coding challenges. Auto-evaluated with topic-wise analytics showing which areas need reinforcement.
Student-wise dashboards tracking Python fluency, Pandas proficiency, and coding speed. TPOs see batch-level readiness for Python-requiring roles.
Google, Amazon, Flipkart, Paytm — all accept Python solutions for coding interviews. Python's readability means students write correct code faster, and built-ins like Counter, defaultdict, and heapq are powerful DSA tools that C++ STL users envy.
Every Data Analyst, Data Scientist, ML Engineer, and AI Engineer job requires Python. NumPy, Pandas, Matplotlib, scikit-learn, TensorFlow, PyTorch — the entire ML/AI ecosystem is Python-first. This module builds the foundation all of them need.
TCS NQT, Infosys SP, and Cognizant GenC now accept Python as a language option in their coding rounds. Wipro NLTH includes Python-specific MCQs. Students who can code in Python AND Java have a significant advantage over single-language candidates.
LLM APIs (OpenAI, Anthropic), LangChain, RAG systems, AI agents, prompt engineering tools, web scraping, task automation — the entire GenAI ecosystem is Python-native. Students learning Python now are positioned for the fastest-growing tech segment.
E-305, Industrial Area, Sahibzada Ajit Singh Nagar, Punjab 160055, IN
