Technologies You Will Learn
Python
VS Code
PyCharm
Python IDLE
Command Line
Curriculum
Complete Core Python Curriculum
01
Python Introduction & Software Installation
15 Topics
Part 1
Introduction to Programming Languages
Introduction to Python Programming Language
History, Creator and Evolution of Python
Features and Advantages of Python
Applications and Future Scope of Python
Python Implementations: CPython, PyPy and Others
Python vs Java vs C vs C++
Python Versions and Python 3 Overview
Python Software Download and Installation
Python Interpreter and Interactive Mode
Python IDE Introduction and Installation (VS Code, PyCharm)
Writing and Executing the First Python Program
Running Python Programs Using the Command Line
Python Interactive Shell vs Script Mode
Python IDLE Introduction
02
Python Program Structure & Internal Working
12 Topics
Part 1
Python Program Structure and Syntax
Indentation and Code Blocks
Statements, Expressions and Comments
Single-Line and Multi-Line Comments
Python Source Code Execution Process
How Python Executes a Program Internally
Python Interpreter and Bytecode
Python Virtual Machine (PVM) — Concept and Working
Python Source Files and .pyc Bytecode Files
Python Interactive Interpreter and REPL
__name__ and the __main__ Execution Check
Common Syntax Errors and Their Solutions
03
Python Programming Fundamentals
22 Topics
Part 1
Variables and Variable Assignment
Rules for Naming Variables
Keywords and Identifiers
Constants and Naming Conventions
Literals in Python
Built-in Data Types Overview
Numeric Data Types: int, float, complex
Boolean Data Type: bool
String Data Type: str
None Type: NoneType
Dynamic Typing in Python
Strong Typing in Python
Checking Types Using type() and isinstance()
Object Identity Using id()
Mutable and Immutable Objects — Introduction
Multiple Variable Assignment
Variable Swapping and Unpacking
Type Conversion and Type Casting
Implicit and Explicit Type Conversion
Taking User Input Using input()
Displaying Output Using print()
Comments, Docstrings and Code Readability
04
Operators and Expressions
16 Topics
Part 1
Introduction to Operators and Expressions
Arithmetic Operators
Floor Division and Modulus Operators
Relational and Comparison Operators
Logical Operators: and, or, not
Assignment and Augmented Assignment Operators
Bitwise Operators
Membership Operators: in, not in
Identity Operators: is, is not
Difference Between == and is
Operator Precedence and Associativity
Short-Circuit Evaluation
Truthy and Falsy Values
Chained Comparisons
Operator Overloading — Introduction
Operator-Based Logical Programs
05
Control Statements & Logical Programming Practice
24 Topics
Part 1
Introduction to Control Flow
if Statement
if-else Statement
if-elif-else Statement
Nested Conditional Statements
Conditional Expressions (Ternary Operator)
match-case Statement
for Loop
while Loop
range() Function
Nested Loops
break Statement
continue Statement
pass Statement
Loop else Clause
enumerate() and zip() in Loops
Infinite Loops and Loop Control
Number-Based Logical Programs
Prime Number and Factorial Programs
Palindrome and Armstrong Number Programs
Star Pattern Programs
Number Pattern Programs
Alphabet Pattern Programs
Nested Loop-Based Problem Solving
06
Python Strings — Hands-on Practice
23 Topics
Part 1
String Introduction and Features
Creating Strings Using Single, Double and Triple Quotes
String Indexing and Negative Indexing
String Slicing and Step Values
String Immutability
String Concatenation and Repetition
String Membership and Comparison
Escape Sequences and Raw Strings
String Formatting Using f-Strings
String Formatting Using format()
String Formatting Using % Operator
Common String Methods
Searching and Counting Substrings
Replacing and Splitting Strings
Joining Strings Using join()
Removing Whitespace Using strip(), lstrip() and rstrip()
String Validation Methods
Checking Prefixes and Suffixes
String Character Encoding: Unicode and UTF-8
String Programs: Reverse, Palindrome and Anagrams
Character Frequency and Duplicate Characters
Word Frequency and Word Counting
Advanced String Logical Questions
07
Python Lists — Operations & Logical Questions
23 Topics
Part 2
List Introduction and Features
Creating Lists and Accessing Elements
Positive and Negative Indexing
List Slicing
Mutable Nature of Lists
Adding Elements: append(), extend(), insert()
Removing Elements: remove(), pop(), clear()
Searching and Counting Elements
Sorting Lists Using sort() and sorted()
Reversing Lists
Copying Lists and Reference Behavior
Shallow Copy vs Deep Copy
List Aliasing and Nested Lists
Iterating Through Lists
List Unpacking
List Comprehensions
Nested List Comprehensions
Lists as Stacks
Using collections.deque for Queue Operations
List-Based Logical Programs
Finding Minimum, Maximum, Second Largest and Missing Elements
Removing Duplicates and Finding Common Elements
Sorting and Searching Problems Using Lists
08
Python Tuples and Sets
20 Topics
Part 2
Tuple Introduction and Features
Creating Tuples and Accessing Elements
Single-Element Tuple and Tuple Packing
Tuple Unpacking
Tuple Immutability
Tuple Methods: count() and index()
Nested Tuples and Tuple Operations
Lists vs Tuples
Set Introduction and Features
Creating Sets and Accessing Set Elements
Set Mutability and Uniqueness
Adding and Removing Set Elements
Union, Intersection and Difference
Symmetric Difference
Subsets, Supersets and Disjoint Sets
Set Comprehensions
Frozen Sets: frozenset
Set Operations and Membership Testing
Lists vs Tuples vs Sets
Practical Programs Using Tuples and Sets
09
Python Dictionaries — Key-Value Data Structures
18 Topics
Part 2
Dictionary Introduction and Features
Creating Dictionaries
Accessing Values Using Keys
Adding and Updating Key-Value Pairs
Removing Elements Using pop(), popitem() and del
Dictionary Methods: get(), update(), setdefault()
Dictionary Views: keys(), values(), items()
Iterating Through Dictionaries
Dictionary Keys and Hashability
Dictionary Membership Testing
Nested Dictionaries
Dictionary Unpacking and Merging
Dictionary Comprehensions
Sorting Dictionaries by Keys and Values
Counting Frequencies Using Dictionaries
Grouping and Aggregating Data
Lists vs Dictionaries
Practical Dictionary-Based Programs
10
Functions in Python
25 Topics
Part 2
Introduction to Functions
Built-in Functions vs User-Defined Functions
Defining and Calling Functions Using def
Function Parameters and Arguments
Positional Arguments
Keyword Arguments
Default Arguments
Variable-Length Arguments: *args
Keyword Variable-Length Arguments: **kwargs
Positional-Only and Keyword-Only Parameters
Returning Values Using return
Multiple Return Values and Tuple Unpacking
Difference Between print() and return
Local and Global Variables
global and nonlocal Keywords
Variable Scope and the LEGB Rule
Python Namespace and Name Resolution
First-Class Functions
Functions as Arguments and Return Values
Lambda Functions
Recursive Functions
Recursion vs Iteration
Docstrings and Function Annotations
Type Hints in Functions
Function Design and Best Practices
11
Modules, Packages and Imports
18 Topics
Part 2
Introduction to Modules
Creating User-Defined Modules
Importing Modules Using import
Importing Specific Names Using from
Import Aliases Using as
Understanding import * and Its Limitations
Module Search Path and sys.path
Module Attributes: __name__, __file__, __doc__
Executing Modules as Scripts
Introduction to Packages
Creating Packages and Subpackages
__init__.py and Package Initialization
Absolute and Relative Imports
Importing from Nested Packages
Circular Imports and Their Prevention
Exploring Built-in and Standard Library Modules
Creating Reusable Python Code
Modular Program Design
12
Exception Handling in Python
18 Topics
Part 2
Errors and Exceptions Introduction
Syntax Errors vs Runtime Exceptions
Common Built-in Exceptions
Exception Hierarchy and BaseException
try and except Blocks
Handling Multiple Exceptions
Exception Aliasing Using as
else Clause in Exception Handling
finally Block
Raising Exceptions Using raise
Exception Chaining
User-Defined Exceptions
Creating Custom Exception Classes
Assertions Using assert
Exception Propagation and Tracebacks
Exception Handling Best Practices
Resource Cleanup and Exception Safety
Practical Programs with Exception Handling
13
Python File Handling and Input/Output
19 Topics
Part 2
File Handling Introduction
Opening Files Using open()
File Modes: r, w, a, x
Text Mode vs Binary Mode
Reading Files Using read(), readline() and readlines()
Writing Data Using write() and writelines()
File Pointer and tell() / seek()
Closing Files and Resource Management
Context Managers and the with Statement
File Encoding and UTF-8
Working with Binary Files
File and Directory Operations Using os and pathlib
Copying, Renaming and Deleting Files
Checking File and Directory Existence
Reading and Writing CSV Files
Working with JSON Data
Pickle Serialization and Deserialization
File Exceptions and Error Handling
Practical File-Based Programs
14
Object-Oriented Programming (OOP) in Python
36 Topics
Part 3
Programming Paradigms: Procedural vs Object-Oriented
Introduction to OOP Concepts
Classes and Objects
Creating Classes Using class
Creating Objects and Accessing Attributes
The self Parameter
Instance Variables and Instance Methods
Constructors Using __init__()
Default and Parameterized Initialization
Object Attributes vs Class Attributes
Class Methods Using @classmethod
Static Methods Using @staticmethod
Instance, Class and Static Methods
Encapsulation and Data Hiding
Public, Protected and Private Naming Conventions
Name Mangling in Python
Properties Using @property
Getters, Setters and Validation
Inheritance and Its Types
Single, Multilevel and Multiple Inheritance
Hierarchical and Hybrid Inheritance
Method Overriding
super() and Parent-Class Initialization
Method Resolution Order (MRO)
Polymorphism and Duck Typing
Operator Overloading
Abstraction Using the abc Module
Abstract Classes and Abstract Methods
Composition, Aggregation and Object Relationships
Association and Dependency Between Objects
Tight Coupling vs Loose Coupling
Multiple Inheritance and Diamond Problem
Object Identity, Equality and References
Object Copying and Lifecycle
Garbage Collection and Reference Counting
OOP Design Best Practices
15
Advanced OOP and Special Methods
17 Topics
Part 3
Introduction to Python's Data Model
Magic Methods and Dunder Methods
__str__() and __repr__()
__len__(), __bool__() and Object Truthiness
__eq__(), __lt__() and Comparison Methods
Arithmetic Operator Overloading
__iter__() and __next__() Introduction
__call__() and Callable Objects
__new__() vs __init__()
Dataclasses Using @dataclass
Named Tuples and Structured Objects
Enumerations Using the enum Module
Multiple Inheritance and Cooperative super()
Mixins and Reusable Class Behavior
Class Decorators — Introduction
Creating Custom Container-Like Objects
Object Representation and Comparison Design
16
Iterators, Generators and Comprehensions
15 Topics
Part 4
Iterable vs Iterator
The iter() and next() Functions
Creating Custom Iterators
Iterator Protocol
Generator Functions Using yield
Generator Execution and State Preservation
Generator Expressions
yield vs return
yield from and Generator Delegation
Lazy Evaluation
Memory Efficiency of Generators
List, Set and Dictionary Comprehensions
Nested Comprehensions and Conditional Filtering
Generator Expressions vs List Comprehensions
Practical Iterator and Generator Programs
17
Decorators, Closures and Functional Programming
18 Topics
Part 4
Introduction to Functional Programming
Functions as First-Class Objects
Nested Functions
Closures and Lexical Scope
Introduction to Decorators
Creating Custom Function Decorators
Decorators with Arguments
Decorating Functions with Parameters and Return Values
Preserving Metadata Using functools.wraps
Stacking Multiple Decorators
Class Methods and Static Methods as Decorators
Built-in Decorators: property, classmethod, staticmethod
map(), filter() and zip()
any(), all() and sorted()
lambda with Functional Operations
functools.reduce() and Other Utilities
Partial Functions Using functools.partial
Functional Programming vs OOP
18
Regular Expressions (Regex)
17 Topics
Part 4
Introduction to Regular Expressions
Python's re Module
Raw Strings and Regex Patterns
Regex Metacharacters
Character Classes and Character Sets
Quantifiers and Repetition
Anchors and Word Boundaries
Groups and Capturing Groups
Named Groups and Non-Capturing Groups
Alternation and Escaping
Greedy vs Non-Greedy Matching
match(), search() and fullmatch()
findall() and finditer()
Substitution Using sub() and subn()
Splitting Strings Using Regex
Practical Validation: Email, Phone and Password Formats
Extracting and Cleaning Text Data
19
Python Standard Library and Useful Modules
22 Topics
Part 4
Introduction to Python Standard Library
Mathematical Operations Using math
Random Values Using random
Date and Time Using datetime
Time Measurement Using time
Calendar Operations Using calendar
Operating System Operations Using os
File Paths Using pathlib
Command-Line Arguments Using sys and argparse
Collections Utilities: Counter, defaultdict, deque, namedtuple
Iteration Utilities Using itertools
Functional Utilities Using functools
Data Copying Using copy
Decimal Arithmetic Using decimal
Fraction Calculations Using fractions
Binary Data Using struct
Temporary Files and Directories
File Matching Using glob
Logging Using the logging Module
Measuring Execution Time and Performance
Environment Variables and Configuration
Practical Standard Library Programs
20
Python Virtual Environments and Package Management
14 Topics
Part 4
Python Package Ecosystem Introduction
Introduction to PyPI
Installing Packages Using pip
Upgrading and Uninstalling Packages
Checking Installed Packages
Creating Virtual Environments Using venv
Activating and Deactivating Virtual Environments
Installing Dependencies Inside a Virtual Environment
Managing Dependencies Using requirements.txt
Freezing and Reinstalling Dependencies
Understanding Module and Package Name Conflicts
Introduction to pyproject.toml
Python Package Structure and Distribution Basics
Reproducible Python Development Environments
21
Advanced Language Features and Memory Management
20 Topics
Part 4
Names, Objects and References
Mutable vs Immutable Objects — Detailed Working
Shallow Copy vs Deep Copy — Internal Behavior
Python Memory Management Overview
Reference Counting and Garbage Collection
Scope, Namespace and Object Lifetime
Global Interpreter Lock (GIL) — Introduction
Hashability and Equality
Hash Tables and Dictionary/Set Internals
Iterable, Iterator and Generator Performance
Context Managers and the Context Management Protocol
Creating Custom Context Managers
Type Hints and the typing Module
Common Type Annotations: list, dict, Optional, Union
Structural Pattern Matching
Debugging Using pdb and IDE Debuggers
Unit Testing Using unittest
Test Organization and Assertions
Code Quality and PEP 8
Pythonic Code and Best Practices
22
Project 1 — Console-Based Games
8 Topics
Part 5
Project Introduction and Requirements
Number Guessing Game
Rock Paper Scissors Game
Input Validation and Exception Handling
Score Tracking and Replay Functionality
Using Functions to Organize Code
Randomization and Game Logic
Testing and Debugging the Games
23
Project 2 — Console-Based Banking Application
10 Topics
Part 5
Project Requirements and System Architecture
Designing the Account and Customer Classes
Creating Accounts and Generating Account IDs
Deposit and Withdrawal Operations
Balance Inquiry and Transaction History
Input Validation and Custom Exceptions
Using Dictionaries and Lists to Manage Records
File-Based Data Persistence
Modularizing the Application
Logging, Testing and Error Handling
24
Project 3 — Student Management System
12 Topics
Part 5
Project Requirements and Application Design
Designing Student and Course Classes
Adding and Viewing Student Records
Updating and Deleting Student Records
Searching and Sorting Student Data
Marks, Grades and Result Calculation
Managing Data Using Dictionaries and Lists
Storing and Retrieving Records Using CSV/JSON
Menu-Driven Application Development
Input Validation and Exception Handling
Modular Code Structure
Testing and Final Project Review
25
Python Coding Practice & Interview Preparation
16 Topics
Part 5
Basic Python Output-Based Questions
Data Types and Type Conversion Questions
Operators and Control Flow Questions
String-Based Coding Problems
List and Array-Style Problems
Tuple, Set and Dictionary Questions
Function and Recursion Problems
OOP Concepts and Code-Based Questions
Exception Handling Questions
File Handling and Module Questions
Mutable vs Immutable and Reference Questions
Iterators, Generators and Decorators
Output Prediction and Debugging Exercises
Time and Space Complexity — Introduction
Common Python Developer Interview Questions
Coding Assessment and Mock Interview Practice
26
Quiz — Test Yourself
9 Topics
Part 5
Python Fundamentals Quiz
Operators and Control Statements Quiz
Strings and Collections Quiz
Functions and Modules Quiz
Exception Handling and File Handling Quiz
OOP Concepts Quiz
Advanced Python Quiz
Output-Based and Debugging Quiz
Final Core Python Assessment
