Master Python: From Basics to

Advanced
Learn, Build, and Deploy Real-
World Python Applications

By Pranav Jha

August 19, 2025

Contents

1 Introduction to the Course 9

1.1 Course Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.2 Learning Objectives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.3 Who This Course is For . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.4 Expected Outcomes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

2 Setting up Python Environment in VS Code 11

2.1 Why VS Code? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.2 Choosing the Python Version . . . . . . . . . . . . . . . . . . . . . . . . 11
2.3 Creating a New Environment with Conda . . . . . . . . . . . . . . . . . 11
2.4 Activating the Environment . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.5 Working with Jupyter Notebooks in VS Code . . . . . . . . . . . . . . . 12
2.5.1 Installing Required Packages . . . . . . . . . . . . . . . . . . . . 12
2.6 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

3 Creating Python Environments for Your Projects 14

3.1 Method 1: Using python -m venv . . . . . . . . . . . . . . . . . . . . . 14
3.2 Method 2: Using virtualenv . . . . . . . . . . . . . . . . . . . . . . . . 15
3.3 Method 3: Using conda create (Recommended) . . . . . . . . . . . . . 15
3.4 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

4 Python Syntax and Semantics 17

4.1 Comments in Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
4.1.1 Single-line Comments . . . . . . . . . . . . . . . . . . . . . . . . 17
4.1.2 Multi-line Comments . . . . . . . . . . . . . . . . . . . . . . . . . 17
4.2 Syntax vs Semantics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
4.2.1 Syntax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
4.2.2 Semantics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
4.3 Basic Syntax Rules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
4.3.1 Case Sensitivity . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
4.3.2 Indentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
4.3.3 Line Continuation . . . . . . . . . . . . . . . . . . . . . . . . . . 18
4.3.4 Multiple Statements in a Single Line . . . . . . . . . . . . . . . . 19
4.4 Variables and Type Inference . . . . . . . . . . . . . . . . . . . . . . . . 19
4.5 Common Syntax Errors . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4.5.1 Name Errors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4.5.2 Indentation Errors . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4.6 Practical Example: Nested Indentation . . . . . . . . . . . . . . . . . . . 20

1
Python Fundamentals: Basics to Advanced 2

4.7 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

5 Introduction to Variables in Python 21

5.1 Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
5.2 What is a Variable? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
5.3 Declaring and Assigning Variables . . . . . . . . . . . . . . . . . . . . . . 21
5.4 Naming Conventions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
5.5 Variable Types and Dynamic Typing . . . . . . . . . . . . . . . . . . . . 22
5.6 Type Checking and Conversion . . . . . . . . . . . . . . . . . . . . . . . 23
5.7 Dynamic Typing in Python . . . . . . . . . . . . . . . . . . . . . . . . . 23
5.8 User Input and Typecasting . . . . . . . . . . . . . . . . . . . . . . . . . 23
5.9 Practical Example: Simple Calculator . . . . . . . . . . . . . . . . . . . . 24
5.10 Common Errors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
5.11 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

6 Python Data Types 25

6.1 Overview and Outline . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
6.2 Introduction to Data Types . . . . . . . . . . . . . . . . . . . . . . . . . 25
6.3 Basic Data Types in Python . . . . . . . . . . . . . . . . . . . . . . . . . 25
6.3.1 Integer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
6.3.2 Float . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
6.3.3 String . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
6.3.4 Boolean . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
6.4 Common Errors and Type Conversion . . . . . . . . . . . . . . . . . . . 26
6.4.1 Type Error Example . . . . . . . . . . . . . . . . . . . . . . . . . 26
6.4.2 Type Conversion Examples . . . . . . . . . . . . . . . . . . . . . 26
6.4.3 Invalid Conversion Example . . . . . . . . . . . . . . . . . . . . . 27
6.5 String Methods Preview . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
6.6 Advanced Data Types (Preview) . . . . . . . . . . . . . . . . . . . . . . 27
6.7 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

7 Python Operators 29
7.1 Overview and Outline . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
7.2 Introduction to Operators . . . . . . . . . . . . . . . . . . . . . . . . . . 29
7.3 Arithmetic Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
7.4 Comparison Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
7.5 Logical Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
7.6 Practical Example: Simple Calculator . . . . . . . . . . . . . . . . . . . . 31
7.7 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

8 Python Control Flow: Conditional Statements 32

8.1 Overview and Outline . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
8.2 Introduction to Conditional Statements . . . . . . . . . . . . . . . . . . . 32
8.3 The if Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
8.4 The else Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
8.5 The elif Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
8.6 Nested Conditional Statements . . . . . . . . . . . . . . . . . . . . . . . 33
8.7 Practical Example: Leap Year Checker . . . . . . . . . . . . . . . . . . . 33
8.8 Common Errors and Best Practices . . . . . . . . . . . . . . . . . . . . . 34
Python Fundamentals: Basics to Advanced 3

8.9 Assignment: Simple Calculator . . . . . . . . . . . . . . . . . . . . . . . 34

8.10 Assignment: Ticket Price Based on Age . . . . . . . . . . . . . . . . . . 35
8.11 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

9 Python Loops 36
9.1 Overview and Outline . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
9.2 Introduction to Loops . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
9.3 For Loop and Range Function . . . . . . . . . . . . . . . . . . . . . . . . 36
9.4 For Loop with Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
9.5 While Loop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
9.6 Loop Control Statements . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
9.6.1 Break . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
9.6.2 Continue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
9.6.3 Pass . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
9.7 Nested Loops . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
9.8 Practical Examples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
9.8.1 Sum of First n Natural Numbers . . . . . . . . . . . . . . . . . . 38
9.8.2 Prime Numbers Between 1 and 100 . . . . . . . . . . . . . . . . . 38
9.9 Common Errors and Best Practices . . . . . . . . . . . . . . . . . . . . . 39
9.10 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

10 Python Lists 40
10.1 Overview and Outline . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
10.2 Definition of Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
10.3 Creating a List . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
10.4 Accessing List Items . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
10.5 Modifying List Items . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
10.6 List Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
10.7 Slicing Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
10.8 Iterating Over Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
10.9 List Comprehension . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
10.9.1 Basic Syntax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
10.9.2 With Condition . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
10.10Nested Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
10.11Common Errors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
10.12Advanced List Comprehension . . . . . . . . . . . . . . . . . . . . . . . . 43
10.12.1 List Comprehension with Condition . . . . . . . . . . . . . . . . . 43
10.12.2 Nested List Comprehension . . . . . . . . . . . . . . . . . . . . . 43
10.12.3 List Comprehension with Function Calls . . . . . . . . . . . . . . 43
10.12.4 List Comprehension with Else Block (Assignment) . . . . . . . . 43
10.13Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

11 Python Tuples 45
11.1 Overview and Outline . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
11.2 Definition of Tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
11.3 Creating Tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
11.4 Accessing Tuple Elements . . . . . . . . . . . . . . . . . . . . . . . . . . 46
11.5 Tuple Operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
11.6 Immutable Nature of Tuples . . . . . . . . . . . . . . . . . . . . . . . . . 46
Python Fundamentals: Basics to Advanced 4

11.7 Tuple Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

11.8 Packing and Unpacking Tuples . . . . . . . . . . . . . . . . . . . . . . . 47
11.9 Nested Tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
11.10Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

12 Python Dictionaries 49
12.1 Overview and Outline . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
12.2 Introduction to Dictionaries . . . . . . . . . . . . . . . . . . . . . . . . . 49
12.3 Creating Dictionaries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
12.4 Accessing Dictionary Elements . . . . . . . . . . . . . . . . . . . . . . . . 50
12.5 Modifying Dictionary Elements . . . . . . . . . . . . . . . . . . . . . . . 50
12.6 Common Dictionary Methods . . . . . . . . . . . . . . . . . . . . . . . . 50
12.7 Iterating Over Dictionaries . . . . . . . . . . . . . . . . . . . . . . . . . . 51
12.8 Nested Dictionaries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
12.9 Dictionary Comprehension . . . . . . . . . . . . . . . . . . . . . . . . . . 51
12.10Common Errors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
12.11Conditional Dictionary Comprehension . . . . . . . . . . . . . . . . . . . 52
12.12Practical Examples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
12.12.1 Counting Frequency of Elements in a List . . . . . . . . . . . . . 52
12.12.2 Merging Two Dictionaries . . . . . . . . . . . . . . . . . . . . . . 52
12.13Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

13 Real World Examples Using Lists 54

13.1 Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
13.2 Managing a To-Do List . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
13.3 Organizing Student Grades . . . . . . . . . . . . . . . . . . . . . . . . . 54
13.4 Managing an Inventory . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
13.5 Collecting User Feedback . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
13.6 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

14 Python Functions 57
14.1 Overview and Outline . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
14.2 Introduction to Functions . . . . . . . . . . . . . . . . . . . . . . . . . . 57
14.3 Defining and Calling Functions . . . . . . . . . . . . . . . . . . . . . . . 57
14.4 Why Use Functions? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
14.5 Function with Multiple Parameters . . . . . . . . . . . . . . . . . . . . . 58
14.6 Default Parameters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
14.7 Variable Length Arguments . . . . . . . . . . . . . . . . . . . . . . . . . 58
14.7.1 Positional Arguments (*args) . . . . . . . . . . . . . . . . . . . . 58
14.7.2 Keyword Arguments (**kwargs) . . . . . . . . . . . . . . . . . . 58
14.7.3 Combining Positional and Keyword Arguments . . . . . . . . . . 59
14.8 Return Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
14.9 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
14.10Information Alert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
Python Fundamentals: Basics to Advanced 5

15 Functions in Python: Practical Examples 61

15.1 Temperature Conversion . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
15.2 Password Strength Checker . . . . . . . . . . . . . . . . . . . . . . . . . 61
15.3 Shopping Cart: Total Cost . . . . . . . . . . . . . . . . . . . . . . . . . . 62
15.4 Palindrome Checker . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
15.5 Factorial Using Recursion . . . . . . . . . . . . . . . . . . . . . . . . . . 63
15.6 Word Frequency in a File . . . . . . . . . . . . . . . . . . . . . . . . . . 63
15.7 Email Validation with Regular Expressions . . . . . . . . . . . . . . . . . 64

16 Lambda Functions in Python 65

16.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
16.2 Syntax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
16.3 Basic Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
16.4 Checking Even Numbers . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
16.5 Lambda with Multiple Parameters . . . . . . . . . . . . . . . . . . . . . 66
16.6 Using Lambda with Map . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
16.6.1 Without Map . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
16.6.2 With Map and Lambda . . . . . . . . . . . . . . . . . . . . . . . 66
16.7 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

17 The map() Function in Python 68

17.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
17.2 Basic Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
17.3 Using Lambda Functions with Map . . . . . . . . . . . . . . . . . . . . . 69
17.4 Mapping Multiple Iterables . . . . . . . . . . . . . . . . . . . . . . . . . 69
17.5 Using Built-in Functions with Map . . . . . . . . . . . . . . . . . . . . . 69
17.5.1 Type Conversion . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
17.5.2 String Manipulation . . . . . . . . . . . . . . . . . . . . . . . . . 69
17.6 Map with a List of Dictionaries . . . . . . . . . . . . . . . . . . . . . . . 70
17.7 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70

18 The filter() Function in Python 71

18.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
18.2 Basic Example: Filtering Even Numbers . . . . . . . . . . . . . . . . . . 71
18.3 Using Lambda Functions with Filter . . . . . . . . . . . . . . . . . . . . 72
18.4 Filter with Multiple Conditions . . . . . . . . . . . . . . . . . . . . . . . 72
18.5 Filter with Dictionaries . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
18.6 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73

19 Modules and Packages in Python 74

19.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
19.2 Importing Built-in Modules . . . . . . . . . . . . . . . . . . . . . . . . . 74
19.3 Third-party Packages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
19.4 Creating Custom Modules and Packages . . . . . . . . . . . . . . . . . . 75
19.4.1 Module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
19.4.2 Package . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
19.4.3 Sub-packages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
19.5 Key Takeaways . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
Python Fundamentals: Basics to Advanced 6

20 Python Standard Library Overview 77

20.1 Array Module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
20.2 Math Module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
20.3 Random Module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
20.4 OS Module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
20.5 Shutil Module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
20.6 JSON Module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
20.7 CSV Module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
20.8 Datetime Module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
20.9 Time Module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
20.10Regular Expression Module . . . . . . . . . . . . . . . . . . . . . . . . . 79
20.11Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80

21 File Operations in Python 81

21.1 Reading a File . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
21.1.1 Reading the Entire File . . . . . . . . . . . . . . . . . . . . . . . 81
21.1.2 Reading Line by Line . . . . . . . . . . . . . . . . . . . . . . . . 81
21.2 Writing to a File . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
21.2.1 Overwriting a File . . . . . . . . . . . . . . . . . . . . . . . . . . 81
21.2.2 Appending to a File . . . . . . . . . . . . . . . . . . . . . . . . . 82
21.2.3 Writing Multiple Lines . . . . . . . . . . . . . . . . . . . . . . . . 82
21.3 Binary File Operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
21.3.1 Writing to a Binary File . . . . . . . . . . . . . . . . . . . . . . . 82
21.3.2 Reading from a Binary File . . . . . . . . . . . . . . . . . . . . . 82
21.4 Copying File Content . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
21.5 Reading, Writing, and Using File Cursor . . . . . . . . . . . . . . . . . . 83
21.6 Practical Assignments . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
21.7 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83

22 Working with Directories and File Paths in Python 85

22.1 Creating a New Directory . . . . . . . . . . . . . . . . . . . . . . . . . . 85
22.2 Listing Files and Directories . . . . . . . . . . . . . . . . . . . . . . . . . 85
22.3 Joining Paths . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
22.4 Checking Path Existence . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
22.5 Checking File or Directory Type . . . . . . . . . . . . . . . . . . . . . . . 86
22.6 Relative vs. Absolute Paths . . . . . . . . . . . . . . . . . . . . . . . . . 86
22.7 Practical Notes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
22.8 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87

23 Exception Handling in Python 88

23.1 Introduction to Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . 88
23.2 Basic try-except Block . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
23.3 Handling Exception Objects . . . . . . . . . . . . . . . . . . . . . . . . . 88
23.4 Handling Multiple Exceptions . . . . . . . . . . . . . . . . . . . . . . . . 89
23.5 Using the else and finally Blocks . . . . . . . . . . . . . . . . . . . . . 89
23.5.1 The else Block . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
23.5.2 The finally Block . . . . . . . . . . . . . . . . . . . . . . . . . . 90
23.5.3 Practical Example: File Handling . . . . . . . . . . . . . . . . . . 90
23.6 Key Takeaways . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
Python Fundamentals: Basics to Advanced 7

24 Object-Oriented Programming in Python: Classes and Objects 92

24.1 Introduction to Object-Oriented Programming . . . . . . . . . . . . . . . 92
24.2 Classes and Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
24.2.1 Basic Example: Car Class . . . . . . . . . . . . . . . . . . . . . . 92
24.3 Attributes and Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
24.3.1 Instance Variables . . . . . . . . . . . . . . . . . . . . . . . . . . 93
24.3.2 Constructor: __init__ Method . . . . . . . . . . . . . . . . . . 93
24.3.3 Instance Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
24.4 Example: Bank Account . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
24.4.1 Class Definition . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
24.4.2 Creating Objects and Using Methods . . . . . . . . . . . . . . . . 94
24.5 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94

25 Inheritance in Python: Single and Multiple Inheritance 96

25.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
25.2 Single Inheritance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
25.2.1 Parent Class Example: Car . . . . . . . . . . . . . . . . . . . . . 96
25.2.2 Child Class Example: Tesla . . . . . . . . . . . . . . . . . . . . . 96
25.3 Multiple Inheritance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
25.3.1 Base Classes Example: Animal and Pet . . . . . . . . . . . . . . 97
25.3.2 Derived Class Example: Dog . . . . . . . . . . . . . . . . . . . . 97
25.4 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98

26 Polymorphism in Python 99
26.1 Method Overriding . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
26.1.1 Example: Animal Sounds . . . . . . . . . . . . . . . . . . . . . . 99
26.2 Polymorphism with Functions . . . . . . . . . . . . . . . . . . . . . . . . 100
26.2.1 Example: Shapes and Areas . . . . . . . . . . . . . . . . . . . . . 100
26.3 Polymorphism with Abstract Base Classes . . . . . . . . . . . . . . . . . 100
26.3.1 Example: Vehicles . . . . . . . . . . . . . . . . . . . . . . . . . . 100
26.4 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101

27 Encapsulation in Python 102

27.1 Access Modifiers in Python . . . . . . . . . . . . . . . . . . . . . . . . . 102
27.2 Public Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
27.3 Private Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
27.4 Protected Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
27.5 Getter and Setter Methods . . . . . . . . . . . . . . . . . . . . . . . . . . 103
27.6 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104

28 Abstraction in Python 105

28.1 Real-World Examples of Abstraction . . . . . . . . . . . . . . . . . . . . 105
28.2 Abstract Classes in Python . . . . . . . . . . . . . . . . . . . . . . . . . 105
28.3 Implementing Abstract Methods in Child Classes . . . . . . . . . . . . . 106
28.4 Key Points . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
28.5 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
Python Fundamentals: Basics to Advanced 8

29 Magic Methods in Python 107

29.1 Introduction to Magic Methods . . . . . . . . . . . . . . . . . . . . . . . 107
29.2 Basic Example of Magic Methods . . . . . . . . . . . . . . . . . . . . . . 107
29.3 Overriding __str__ Method . . . . . . . . . . . . . . . . . . . . . . . . 108
29.4 Overriding __repr__ Method . . . . . . . . . . . . . . . . . . . . . . . 108
29.5 Key Points . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
29.6 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109

30 Operator Overloading in Python 110

30.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
30.2 Example: Vector Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
30.3 Explanation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
30.4 Key Points . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
30.5 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112

31 Creating Web Applications with Streamlit 113

31.1 Introduction to Streamlit . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
31.2 Getting Started . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
31.2.1 Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
31.2.2 Basic App Setup . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
31.3 Interactive Widgets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
31.3.1 Text Input . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
31.3.2 Slider . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
31.3.3 Select Box . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
31.3.4 File Uploader . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
31.4 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115

32 Building a Machine Learning Web App with Streamlit 116

32.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
32.2 Project Setup . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
32.2.1 Installing Dependencies . . . . . . . . . . . . . . . . . . . . . . . 116
32.2.2 Importing Libraries . . . . . . . . . . . . . . . . . . . . . . . . . . 116
32.3 Loading and Caching the Dataset . . . . . . . . . . . . . . . . . . . . . . 116
32.4 Training the Random Forest Model . . . . . . . . . . . . . . . . . . . . . 117
32.5 Creating Interactive Sliders for Input . . . . . . . . . . . . . . . . . . . . 117
32.6 Making Predictions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
32.7 Running the App . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
32.8 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
1 Introduction to the Course

1.1 Course Overview

Welcome to Master Python: From Basics to Advanced! This course is designed to
take you on a complete journey through Python programming, starting from fundamental
concepts and gradually progressing to advanced topics and real-world applications.
Python is one of the most popular and versatile programming languages in the world.
It is widely used in web development, data science, machine learning, artificial intelligence,
automation, and more. Its simple syntax and readability make it an excellent choice for
beginners, while its powerful libraries and frameworks make it suitable for advanced users.

1.2 Learning Objectives

By the end of this course, you will be able to:
• Understand and write Python code using variables, data types, and operators.

• Create and use functions, loops, and conditional statements effectively.

• Work with Python data structures such as lists, tuples, sets, and dictionaries.

• Apply object-oriented programming concepts, including classes, inheritance, and

polymorphism.

• Handle file operations and manage data efficiently.

• Use Python for real-world applications, including web development, data analysis,
and automation.

• Explore advanced topics like error handling, decorators, generators, and Python
libraries.

1.3 Who This Course is For

This course is ideal for:
• Beginners who want to start programming with Python.

• Intermediate programmers looking to strengthen their Python skills.

• Professionals aiming to apply Python in data science, AI, or web development.

9
Python Fundamentals: Basics to Advanced 10

1.4 Expected Outcomes

By completing this course, you will:

• Gain a strong foundation in Python programming.

• Be capable of building small to medium-scale Python applications.

• Be ready to explore specialized domains like AI, machine learning, or data ana-
lytics using Python.

• Develop problem-solving and logical thinking skills essential for programming.

2 Setting up Python Environment in
VS Code

Hello everyone, and welcome to the Python series! In this session, we will begin by setting
up our Python environment in VS Code.

2.1 Why VS Code?

I find VS Code an amazing IDE because it supports:

• Running both .py and Jupyter Notebook (.ipynb) files.

• Easy creation and management of environments.

• Extensions, code assistance, and many more productivity tools.

2.2 Choosing the Python Version

For this series, I will use the newest Python version available at the time: Python 3.12.
We will explore features introduced from Python 3.10 to 3.12.

Note
Always create a separate environment for each new project. This prevents depen-
dency conflicts and allows different projects to use different package versions.

2.3 Creating a New Environment with Conda

We will use the conda command to create our virtual environment.

1 conda create -p venv python==3.12

Listing 2.1: Creating a Python 3.12 environment in Conda

Here:

• venv is the environment name.

• python==3.12 specifies the version.

11
Python Fundamentals: Basics to Advanced 12

When prompted, press Y to proceed with installation. Basic libraries will be installed
automatically.

2.4 Activating the Environment

To activate the environment:

1 conda activate venv

Once activated, you can run Python files directly:

1 python [Link]

2.5 Working with Jupyter Notebooks in VS

Code
1. Create a new folder (e.g., Python_Basics). 2. Inside, create a Jupyter Notebook
file ([Link]). 3. Select the kernel: choose the venv environment (Python 3.12). 4.
Create Code cells and Markdown cells as needed.

Note
Execute a cell by pressing Shift+Enter.

2.5.1 Installing Required Packages

To run notebooks, you need ipykernel:

1 pip install ipykernel

You can maintain a [Link] file to keep track of all packages:

1 ipykernel
2 pandas
3 numpy
4 # Add more as needed

2.6 Conclusion
In this session, we learned:

• How to create and activate a conda environment.

• How to run Python scripts and notebooks in VS Code.

Python Fundamentals: Basics to Advanced 13

• How to install necessary packages.

In the next chapter, we will start exploring Python basics.

3 Creating Python Environments for
Your Projects

In this chapter, we will explore three different ways to create Python virtual environ-
ments for your projects. Creating a separate environment for each project is important
because:

• Different projects often require different versions of dependencies.

• It helps avoid package version conflicts.

• It keeps your global Python installation clean.

3.1 Method 1: Using python -m venv

This method requires only Python to be installed (no Anaconda).

Note
If you want a specific Python version, install that version first from [Link].

Steps
1. Open a terminal or command prompt.

2. Run:

1 python -m venv myenv

Listing 3.1: Creating a virtual environment using venv

3. Activate the environment:

• On Windows:

1 myenv\Scripts\activate

• On macOS/Linux:

1 source myenv/bin/activate

14
Python Fundamentals: Basics to Advanced 15

4. Install packages:

1 pip install pandas numpy

5. Deactivate when done:

1 deactivate

3.2 Method 2: Using virtualenv

This method works across Windows, macOS, and Linux.

Steps
1. Install virtualenv:

1 pip install virtualenv

2. Create the environment:

1 virtualenv -p python3.10 venv_name

3. Activate it (similar to Method 1):

• Windows:

1 venv_name\Scripts\activate

• macOS/Linux:

1 source venv_name/bin/activate

3.3 Method 3: Using conda create (Recom-

mended)
If you have Anaconda or Miniconda installed, this is often the most efficient method.

Steps
1. Create the environment with a specific Python version:

1 conda create -p venv_name python==3.10 -y

Python Fundamentals: Basics to Advanced 16

2. Activate:

1 conda activate venv_name

3. Install packages:

1 conda install pandas numpy

Note
Conda environments allow you to easily view installed packages and manage depen-
dencies.

3.4 Conclusion
We covered:

• python -m venv for a minimal setup.

• virtualenv for cross-platform flexibility.

• conda create for robust environment management.

Choose the method that best fits your workflow.

4 Python Syntax and Semantics

Welcome to the next session of our Python series. In this chapter, we will cover:

• Single-line and multi-line comments

• Definitions of syntax and semantics

• Basic syntax rules in Python

• Variable assignment, type inference, and dynamic typing

• Indentation rules and common syntax errors

• Practical code examples

4.1 Comments in Python

Python supports both single-line and multi-line comments.

4.1.1 Single-line Comments

Single-line comments begin with a hash symbol #:

1 # This is a single-line comment

2 print("Hello World") # Inline comment
Listing 4.1: Single-line comment

4.1.2 Multi-line Comments

Multi-line comments use triple quotes (""" ... """) in Python scripts:

1 """
2 Welcome to the Python course.
3 This is a multi-line comment.
4 """
Listing 4.2: Multi-line comment

Note: Multi-line comments may not work in Jupyter notebooks; single-line comments
are always safe.

17
Python Fundamentals: Basics to Advanced 18

4.2 Syntax vs Semantics

4.2.1 Syntax
Syntax refers to the rules that define the structure of valid Python programs. It is about
the correct arrangement of symbols and keywords.

4.2.2 Semantics
Semantics is the meaning or interpretation of code: what the program does when exe-
cuted. Syntax is how you write the code, semantics is what it does.

4.3 Basic Syntax Rules

4.3.1 Case Sensitivity
Python is case-sensitive. Variables with different capitalization are treated as distinct:

1 name = "Chris"
2 Name = "Nick"
3

4 print(name) # Outputs: Chris

5 print(Name) # Outputs: Nick
Listing 4.3: Case sensitivity example

4.3.2 Indentation
Python uses indentation instead of braces to define code blocks. Consistent use of spaces
(commonly four) or tabs is required:

1 age = 32
2 if age > 30:
3 print("Age is greater than 30") # Indented block
4 print("This prints regardless of the if condition") # Outside block
Listing 4.4: Indentation example

4.3.3 Line Continuation

Use a backslash (\) to continue a long statement on the next line:

1 total = 1 + 2 + 3 + \
2 4 + 5 + 6
3 print(total) # Outputs: 21
Listing 4.5: Line continuation example
 Python Fundamentals: Basics to Advanced 19

4.3.4 Multiple Statements in a Single Line

Separate statements with a semicolon (;):

1 x = 5; y = 10; z = x + y
2 print(z) # Outputs: 15
Listing 4.6: Multiple statements in one line

4.4 Variables and Type Inference

Python infers the type of a variable dynamically at runtime:

1 age = 32 # integer
2 name = "Chris" # string
3

4 print(type(age)) # <class 'int'>

5 print(type(name)) # <class 'str'>
6

7 variable = 10
8 print(type(variable)) # int
9 variable = "Chris"
10 print(type(variable)) # str
Listing 4.7: Type inference example

4.5 Common Syntax Errors

4.5.1 Name Errors
Using an undefined variable:

1 a = B # NameError: name 'B' is not defined

Listing 4.8: Name error example

4.5.2 Indentation Errors

Incorrect indentation:

1 age = 32
2 if age > 30:
3 print(age) # IndentationError
Listing 4.9: Indentation error example
Python Fundamentals: Basics to Advanced 20

4.6 Practical Example: Nested Indentation

1 if True:
2 print("Inside True block")
3 if False:
4 print("Inside nested False block")
5 print("Outside all blocks")
Listing 4.10: Nested indentation example

This prints twice: once for the True block and once for the statement outside all
blocks.

4.7 Summary
In this chapter, we covered:

• Single-line and multi-line comments

• Difference between syntax and semantics

• Case sensitivity, indentation, line continuation, and multiple statements

• Variables, type inference, and dynamic typing

• Common syntax and indentation errors

In the next chapter, we will explore variables, data types, and operators in Python.
5 Introduction to Variables in Python

5.1 Overview
Variables are fundamental elements in programming used to store data that can be refer-
enced and manipulated in a program. In Python, variables are created when you assign
a value to them; explicit declaration is not required.

5.2 What is a Variable?

Variables are fundamental elements in programming used to store data that can be refer-
enced and manipulated in a program. In Python, variables are created when you assign
a value to them. There is no need for explicit declaration or memory reservation; Python
handles this automatically.

1 a = 100

This statement creates a variable a and assigns it the value 100.

5.3 Declaring and Assigning Variables

Variables are declared and assigned using the assignment operator =. You can assign
values of any type:

1 age = 32
2 height = 6.1
3 name = "John"
4 is_student = True

You can print variables using the print() function:

1 print("Age:", age)
2 print("Height:", height)
3 print("Name:", name)
4 print("Is Student:", is_student)

21
Python Fundamentals: Basics to Advanced 22

5.4 Naming Conventions

Proper naming conventions help make code readable and maintainable. Important rules:
• Variable names should be descriptive.

• Must start with a letter or underscore (_).

• Can contain letters, numbers, and underscores.

• Cannot start with a number.

• Variable names are case sensitive.

Valid variable names:

1 first_name = "John"
2 last_name = "Nick"
3 score1 = 100
4 _is_valid = True

Invalid variable names:

1 1age = 30 # Invalid: starts with a number

2 first-name = "John" # Invalid: dash not allowed
3 @name = "John" # Invalid: special character not allowed

Case Sensitivity:

1 name = "Chris"
2 Name = "Naic"
3 print(name == Name) # False, different variables

5.5 Variable Types and Dynamic Typing

Python is dynamically typed, meaning the type of a variable is determined at runtime.
Common types include int, float, str, and bool.

1 age = 25 # int
2 height = 6.1 # float
3 name = "John" # str
4 is_student = True # bool

You can check the type using type():

1 print(type(age)) # <class 'int'>

2 print(type(height)) # <class 'float'>
3 print(type(name)) # <class 'str'>
4 print(type(is_student)) # <class 'bool'>
Python Fundamentals: Basics to Advanced 23

5.6 Type Checking and Conversion

Type checking helps you understand what type of data a variable holds. Type conversion
allows you to change the type of a variable.
Convert int to str:

1 age = 25
2 age_str = str(age)
3 print(age_str, type(age_str)) # '25' <class 'str'>

Convert str to int:

1 age = "25"
2 age_int = int(age)
3 print(age_int, type(age_int)) # 25 <class 'int'>

Convert float to int and vice versa:

1 height = 5.11
2 height_int = int(height) # 5
3 height_float = float(height_int) # 5.0
4 print(height_int, type(height_int))
5 print(height_float, type(height_float))

Invalid conversions:

1 name = "John"
2 int(name) # Raises ValueError

5.7 Dynamic Typing in Python

Python allows the type of a variable to change as the program executes:

1 var = 10
2 print(var, type(var)) # 10 <class 'int'>
3 var = "Hello"
4 print(var, type(var)) # Hello <class 'str'>
5 var = 3.14
6 print(var, type(var)) # 3.14 <class 'float'>

This flexibility is called dynamic typing.

5.8 User Input and Typecasting

Use the input() function to get user input. Input is always received as a string, so type
conversion may be needed.
Python Fundamentals: Basics to Advanced 24

1 age = input("Enter your age: ")

2 print(age, type(age)) # age is str
3

4 age_int = int(age)
5 print(age_int, type(age_int)) # age_int is int

5.9 Practical Example: Simple Calculator

A simple calculator using variables and input:

1 num1 = int(input("Enter first number: "))

2 num2 = int(input("Enter second number: "))
3

4 print("Sum:", num1 + num2)

5 print("Difference:", num1 - num2)
6 print("Product:", num1 * num2)
7 print("Quotient:", num1 / num2)

5.10 Common Errors

• Using invalid variable names (e.g., starting with a number or using special char-
acters).

• Type conversion errors (e.g., converting a non-numeric string to int).

• Forgetting that input() returns a string and not converting to int or float.

• Case sensitivity mistakes (e.g., using name and Name interchangeably).

5.11 Summary
• Variables store data and are dynamically typed in Python.

• Naming conventions help avoid errors and improve readability.

• Type checking and conversion are straightforward.

• Input from users is always a string and may need conversion.

• Python allows variable types to change during execution.

• Practical examples help reinforce concepts and highlight common errors.

6 Python Data Types

6.1 Overview and Outline

In this chapter, we will cover:
• Introduction to data types

• Importance of data types in programming

• Basic data types: integer, float, string, boolean

• Common errors and type conversion

• Preview of advanced data types (lists, tuples, sets, dictionaries)

• Practical examples

6.2 Introduction to Data Types

Data types are a classification of data which tells the compiler or interpreter how the
programmer intends to use the data. They determine:
• The type of operations that can be performed

• The values the data can take

• The amount of memory needed to store the data

Different data types (e.g., integer, float) require different amounts of memory. Proper
use of data types ensures efficient storage, correct operations, and helps prevent errors
and bugs.

6.3 Basic Data Types in Python

6.3.1 Integer
Stores whole numbers.

1 age = 35
2 print(type(age)) # <class 'int'>

25
Python Fundamentals: Basics to Advanced 26

6.3.2 Float
Stores decimal numbers.

1 height = 5.11
2 print(height) # 5.11
3 print(type(height)) # <class 'float'>

6.3.3 String
Stores sequences of characters.

1 name = "John"
2 print(name) # John
3 print(type(name)) # <class 'str'>

6.3.4 Boolean
Stores True or False values.

1 is_true = True
2 print(type(is_true)) # <class 'bool'>
3

4 a = 10
5 b = 10
6 print(a == b) # True
7 print(type(a == b)) # <class 'bool'>

6.4 Common Errors and Type Conversion

6.4.1 Type Error Example
Trying to add a string and an integer:

1 result = "hello" + 5 # TypeError: can only concatenate str (not "int") to

str

Fix: Use typecasting.

1 result = "hello" + str(5)

2 print(result) # hello5

6.4.2 Type Conversion Examples

 Python Fundamentals: Basics to Advanced 27

1 # String to int
2 num_str = "25"
3 num_int = int(num_str)
4 print(num_int, type(num_int)) # 25 <class 'int'>
5

6 # Float to int
7 height = 5.11
8 height_int = int(height)
9 print(height_int, type(height_int)) # 5 <class 'int'>
10

11 # Int to float
12 score = 100
13 score_float = float(score)
14 print(score_float, type(score_float)) # 100.0 <class 'float'>

6.4.3 Invalid Conversion Example

1 name = "John"
2 int(name) # ValueError: invalid literal for int() with base 10: 'John'

6.5 String Methods Preview

Strings have many built-in methods:

1 text = "hello"
2 print([Link]()) # HELLO
3 print([Link]()) # True
4 print([Link](10)) # ' hello '

We will explore more string methods and operations in later chapters.

6.6 Advanced Data Types (Preview)

Python also supports advanced data types:

• Lists

• Tuples

• Sets

• Dictionaries

These will be covered in detail in future chapters.

Python Fundamentals: Basics to Advanced 28

6.7 Summary
• Data types classify and manage data efficiently in Python.

• Basic types: int, float, str, bool.

• Type conversion and type errors are common; typecasting helps fix them.

• Strings have many useful methods.

• Advanced data types will be covered later.

 7 Python Operators

7.1 Overview and Outline

In this chapter, we will cover:

• Introduction to operators

• Arithmetic operators: addition, subtraction, multiplication, division, floor divi-

sion, modulus, exponentiation

• Comparison operators: equal to, not equal to, greater than, less than, greater
than or equal to, less than or equal to

• Logical operators: and, or, not

• Practical examples and common errors

• Simple calculator project

7.2 Introduction to Operators

Operators are symbols that perform mathematical, logical, or comparison operations on
values and variables. They are essential for building logic and performing calculations in
Python programs.

7.3 Arithmetic Operators

1 a = 10
2 b = 5
3

4 add_result = a + b # Addition
5 sub_result = a - b # Subtraction
6 mul_result = a * b # Multiplication
7 div_result = a / b # Division (float result)
8 floor_div_result = a // b # Floor Division (integer result)
9 mod_result = a % b # Modulus (remainder)
10 exp_result = a ** b # Exponentiation (a to the power of b)
11

12 print("Addition:", add_result)

29
 Python Fundamentals: Basics to Advanced 30

13 print("Subtraction:", sub_result)
14 print("Multiplication:", mul_result)
15 print("Division:", div_result)
16 print("Floor Division:", floor_div_result)
17 print("Modulus:", mod_result)
18 print("Exponentiation:", exp_result)

Notes:
• Division (/) returns a float.

• Floor division (//) returns the largest integer less than or equal to the result.

• Modulus (%) returns the remainder.

• Exponentiation (**) raises the first operand to the power of the second.

7.4 Comparison Operators

1 a = 10
2 b = 15
3

4 print(a == b) # Equal to
5 print(a != b) # Not equal to
6 print(a > b) # Greater than
7 print(a < b) # Less than
8 print(a >= b) # Greater than or equal to
9 print(a <= b) # Less than or equal to
10

11 # String comparison (case sensitive)

12 str1 = "John"
13 str2 = "John"
14 print(str1 == str2) # True
15

16 str3 = "john"
17 print(str1 == str3) # False

7.5 Logical Operators

1 x = True
2 y = False
3

4 print(x and y) # AND: True only if both are True

5 print(x or y) # OR: True if at least one is True
6 print(not x) # NOT: Inverts the boolean value

Truth Table:
 Python Fundamentals: Basics to Advanced 31

• and: True only if both operands are True.

• or: True if at least one operand is True.

• not: Inverts the operand.

7.6 Practical Example: Simple Calculator

1 num1 = float(input("Enter first number: "))
2 num2 = float(input("Enter second number: "))
3

4 print("Addition:", num1 + num2)

5 print("Subtraction:", num1 - num2)
6 print("Multiplication:", num1 * num2)
7 print("Division:", num1 / num2)
8 print("Floor Division:", num1 // num2)
9 print("Modulus:", num1 % num2)
10 print("Exponentiation:", num1 ** num2)

7.7 Summary
• Operators are used for arithmetic, comparison, and logical operations in Python.

• Arithmetic operators include: +, -, *, /, //, %, **.

• Comparison operators include: ==, !=, >, <, >=, <=.

• Logical operators include: and, or, not.

• Practical examples help reinforce concepts and highlight common errors.

8 Python Control Flow: Conditional
Statements

8.1 Overview and Outline

In this chapter, we will cover:

• Introduction to conditional statements

• The if statement

• The else statement

• The elif statement

• Nested conditional statements

• Practical examples and real-world use cases

• Common errors and best practices

• Assignments for practice

8.2 Introduction to Conditional Statements

Conditional statements allow you to control the flow of your program based on conditions.
They help you execute certain blocks of code only when specific conditions are met.

8.3 The if Statement

The if statement evaluates a condition and executes the block of code within it if the
condition is true.

1 age = 20
2 if age >= 18:
3 print("You are allowed to vote in the elections.")

32
Python Fundamentals: Basics to Advanced 33

8.4 The else Statement

The else statement executes a block of code if the condition in the if statement is false.

1 age = 16
2 if age >= 18:
3 print("You are eligible for voting.")
4 else:
5 print("You are a minor.")

8.5 The elif Statement

The elif (else if) statement allows you to check multiple conditions.

1 age = 20
2 if age < 13:
3 print("You are a child.")
4 elif age < 18:
5 print("You are a teenager.")
6 else:
7 print("You are an adult.")

8.6 Nested Conditional Statements

You can place one or more if, elif, or else statements inside another conditional block.

1 number = int(input("Enter the number: "))

2 if number > 0:
3 print("The number is positive.")
4 if number % 2 == 0:
5 print("The number is even.")
6 else:
7 print("The number is odd.")
8 else:
9 print("The number is zero or negative.")

8.7 Practical Example: Leap Year Checker

A year is a leap year if it is divisible by 4, but not by 100 unless it is also divisible by
400.

1 year = int(input("Enter the year: "))

2 if year % 4 == 0:
3 if year % 100 == 0:
 Python Fundamentals: Basics to Advanced 34

4 if year % 400 == 0:
5 print(f"{year} is a leap year.")
6 else:
7 print(f"{year} is not a leap year.")
8 else:
9 print(f"{year} is a leap year.")
10 else:
11 print(f"{year} is not a leap year.")

8.8 Common Errors and Best Practices

• Always use a colon (:) after if, elif, and else.

• Maintain proper indentation for code blocks.

• Use descriptive variable names and clear conditions.

• Test your code with different inputs to ensure all branches work.

8.9 Assignment: Simple Calculator

Write a program that takes two numbers and an operation (+, -, *, /,

1 num1 = float(input("Enter first number: "))

2 num2 = float(input("Enter second number: "))
3 operation = input("Enter operation (+, -, *, /, %, **): ")
4

5 if operation == "+":
6 result = num1 + num2
7 elif operation == "-":
8 result = num1 - num2
9 elif operation == "*":
10 result = num1 * num2
11 elif operation == "/":
12 result = num1 / num2
13 elif operation == "%":
14 result = num1 % num2
15 elif operation == "**":
16 result = num1 ** num2
17 else:
18 result = "Invalid operation"
19

20 print("Result:", result)
 Python Fundamentals: Basics to Advanced 35

8.10 Assignment: Ticket Price Based on Age

Write a program to determine ticket price based on age and student status.

1 age = int(input("Enter your age: "))

2 is_student = input("Are you a student? (yes/no): ").lower()
3

4 if age < 5:
5 price = 0
6 elif age < 12:
7 price = 10
8 elif age < 17:
9 if is_student == "yes":
10 price = 12
11 else:
12 price = 15
13 else:
14 price = 20
15

16 print(f"Your ticket price is: ${price}")

8.11 Summary
• Conditional statements control the flow of your program.

• Use if, elif, and else for decision making.

• Nested conditionals allow complex logic.

• Practice with real-world examples to master control flow.

9 Python Loops

9.1 Overview and Outline

In this chapter, we will cover:
• Introduction to loops

• For loop and the range() function

• While loop

• Loop control statements: break, continue, pass

• Nested loops

• Practical examples

• Common errors and best practices

9.2 Introduction to Loops

Loops allow you to execute a block of code multiple times. Python supports two main
types of loops: for loops and while loops.

9.3 For Loop and Range Function

The for loop is used to iterate over a sequence (such as a list, string, or range of numbers).

1 for i in range(5):
2 print(i)
3 # Output: 0 1 2 3 4

range(start, stop, step) generates a sequence of numbers:

1 for i in range(1, 6):

2 print(i)
3 # Output: 1 2 3 4 5
4

5 for i in range(1, 10, 2):

6 print(i)

36
 Python Fundamentals: Basics to Advanced 37

7 # Output: 1 3 5 7 9
8

9 for i in range(10, 0, -1):

10 print(i)
11 # Output: 10 9 8 7 6 5 4 3 2 1

9.4 For Loop with Strings

You can iterate over each character in a string:

1 text = "John Nayak"

2 for char in text:
3 print(char)

9.5 While Loop

The while loop continues to execute as long as the condition is true.

1 count = 0
2 while count < 5:
3 print(count)
4 count += 1
5 # Output: 0 1 2 3 4

9.6 Loop Control Statements

9.6.1 Break
Exits the loop prematurely.

1 for i in range(10):
2 if i == 5:
3 break
4 print(i)
5 # Output: 0 1 2 3 4

9.6.2 Continue
Skips the current iteration and continues with the next.

1 for i in range(10):
2 if i % 2 == 0:
3 continue
Python Fundamentals: Basics to Advanced 38

4 print(i)
5 # Output: 1 3 5 7 9

9.6.3 Pass
Does nothing; acts as a placeholder.

1 for i in range(5):
2 if i == 3:
3 pass
4 print(f"Number is {i}")

9.7 Nested Loops

A loop inside another loop.

1 for i in range(3):
2 for j in range(2):
3 print(f"i = {i}, j = {j}")

9.8 Practical Examples

9.8.1 Sum of First n Natural Numbers
Using a while loop:

1 n = 10
2 sum = 0
3 count = 1
4 while count <= n:
5 sum += count
6 count += 1
7 print("Sum of first", n, "natural numbers:", sum)

Using a for loop:

1 n = 10
2 sum = 0
3 for i in range(1, n+1):
4 sum += i
5 print("Sum of first", n, "natural numbers:", sum)

9.8.2 Prime Numbers Between 1 and 100

Python Fundamentals: Basics to Advanced 39

1 for num in range(2, 101):

2 for i in range(2, num):
3 if num % i == 0:
4 break
5 else:
6 print(num)

9.9 Common Errors and Best Practices

• Always update loop variables to avoid infinite loops.

• Use proper indentation for nested loops.

• Use break, continue, and pass appropriately.

• Test your code with different inputs.

9.10 Summary
Loops are powerful tools in Python that allow you to execute code multiple times. Un-
derstanding for and while loops, along with loop control statements, helps you solve a
wide range of programming tasks efficiently.
10 Python Lists

10.1 Overview and Outline

In this chapter, we will cover:

• Definition of lists

• Creating a list

• Accessing list items

• Modifying list items

• Common list methods

• Slicing lists

• Iterating over lists

• List comprehension

• Nested lists

• Common errors

10.2 Definition of Lists

Lists are ordered, mutable collections of items. They can contain items of different data
types.

10.3 Creating a List

1 # Empty list
2 my_list = []
3 print(type(my_list)) # <class 'list'>
4

5 # List of strings
6 names = ["John", "Jack", "Jacob"]
7 print(names)

40
 Python Fundamentals: Basics to Advanced 41

9 # Mixed data types

10 mixed_list = [1, "hello", 3.14, True]
11 print(mixed_list)

10.4 Accessing List Items

1 fruits = ["apple", "banana", "cherry", "kiwi", "guava"]
2

3 print(fruits[0]) # apple
4 print(fruits[2]) # cherry
5 print(fruits[-1]) # guava (last element)
6 print(fruits[1:4]) # ['banana', 'cherry', 'kiwi']
7 print(fruits[1:]) # ['banana', 'cherry', 'kiwi', 'guava']

10.5 Modifying List Items

1 fruits[1] = "watermelon"
2 print(fruits) # banana replaced by watermelon

10.6 List Methods

1 [Link]("orange") # Add to end
2 [Link](1, "banana") # Insert at index 1
3 [Link]("banana") # Remove first occurrence
4 last_fruit = [Link]() # Remove and return last item
5 index_cherry = [Link]("cherry") # Get index of 'cherry'
6 count_banana = [Link]("banana") # Count occurrences
7 [Link]() # Sort list
8 [Link]() # Reverse list
9 [Link]() # Remove all items

10.7 Slicing Lists

1 numbers = [1,2,3,4,5,6,7,8,9,10]
2 print(numbers[2:5]) # [3, 4, 5]
3 print(numbers[5:]) # [6, 7, 8, 9, 10]
4 print(numbers[::2]) # [1, 3, 5, 7, 9]
5 print(numbers[::-1]) # [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
Python Fundamentals: Basics to Advanced 42

10.8 Iterating Over Lists

1 for number in numbers:
2 print(number)
3

4 # Iterating with index

5 for index, number in enumerate(numbers):
6 print(f"Index {index}: {number}")

10.9 List Comprehension

10.9.1 Basic Syntax

1 # [expression for item in iterable]

2 squares = [x**2 for x in range(10)]
3 print(squares)

10.9.2 With Condition

1 # [expression for item in iterable if condition]

2 evens = [i for i in range(10) if i % 2 == 0]
3 print(evens)

10.10 Nested Lists

1 nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
2 print(nested_list[0]) # [1, 2, 3]
3 print(nested_list[1][2]) # 6

10.11 Common Errors

• IndexError: Accessing an index that does not exist.

• TypeError: Using wrong data type for list operations.

• Modifying a list slice with a non-list value.

 Python Fundamentals: Basics to Advanced 43

10.12 Advanced List Comprehension

10.12.1 List Comprehension with Condition

1 # Traditional way
2 even_numbers = []
3 for i in range(10):
4 if i % 2 == 0:
5 even_numbers.append(i)
6 print(even_numbers)
7

8 # List comprehension way

9 even_numbers = [num for num in range(10) if num % 2 == 0]
10 print(even_numbers)

10.12.2 Nested List Comprehension

You can use nested loops inside a list comprehension to create combinations or pairs.

1 list1 = [1, 2, 3]
2 list2 = ['a', 'b', 'c', 'd']
3

4 pairs = [(i, j) for i in list1 for j in list2]

5 print(pairs)
6 # Output: [(1, 'a'), (1, 'b'), ..., (3, 'd')]

10.12.3 List Comprehension with Function Calls

You can use function calls inside list comprehensions.

1 words = ["hello", "world", "Python", "list", "comprehension"]

2 lengths = [len(word) for word in words]
3 print(lengths)
4 # Output: [5, 5, 6, 4, 13]

10.12.4 List Comprehension with Else Block (Assignment)

Try to create a list comprehension that uses an else block for conditional logic.

1 # Example (for practice):

2 result = [x if x % 2 == 0 else -x for x in range(10)]
3 print(result)
4 # Output: [0, -1, 2, -3, 4, -5, 6, -7, 8, -9]
Python Fundamentals: Basics to Advanced 44

10.13 Conclusion
• Lists are ordered, mutable, and can hold mixed data types.

• Indexing and slicing allow you to access and modify items efficiently.

• Built-in list methods simplify common operations.

• List comprehensions provide a concise way to create and transform lists.

• Nested lists enable multi-dimensional data structures.

List comprehensions are a powerful and compact feature in Python, allowing you to
replace verbose loops with cleaner code. Understanding and practicing list comprehen-
sions will help you write more efficient and readable Python programs.
Practice with more examples to master lists and list comprehensions!
11 Python Tuples

11.1 Overview and Outline

In this chapter, we will cover:

• Definition of tuples

• Creating tuples

• Accessing tuple elements

• Tuple operations

• Immutable nature of tuples

• Common tuple methods

• Packing and unpacking tuples

• Nested tuples

• Practical examples

• Conclusion

11.2 Definition of Tuples

Tuples are ordered collections of items that are immutable. They are similar to lists,
but their elements cannot be changed once assigned.

11.3 Creating Tuples

1 # Empty tuple
2 empty_tuple = ()
3 print(empty_tuple)
4 print(type(empty_tuple)) # <class 'tuple'>
5

6 # Tuple from a list

7 numbers = tuple([1, 2, 3, 4, 5, 6])

45
 Python Fundamentals: Basics to Advanced 46

8 print(numbers)
9

10 # Mixed data types

11 mixed_tuple = (1, "hello", 3.14, True)
12 print(mixed_tuple)
13

14 # Convert tuple to list

15 as_list = list(numbers)
16 print(as_list)

11.4 Accessing Tuple Elements

1 print(numbers[0]) # First element
2 print(numbers[-1]) # Last element
3 print(numbers[0:4]) # Slicing
4 print(numbers[::-1]) # Reverse

11.5 Tuple Operations

1 # Concatenation
2 concat_tuple = numbers + mixed_tuple
3 print(concat_tuple)
4

5 # Repetition
6 repeat_tuple = mixed_tuple * 3
7 print(repeat_tuple)

11.6 Immutable Nature of Tuples

Tuples are immutable; you cannot change their elements after creation.

1 # Lists are mutable

2 my_list = [1, 2, 3, 4, 5]
3 my_list[0] = "John"
4 print(my_list)
5

6 # Tuples are immutable

7 try:
8 numbers[1] = "John"
9 except TypeError as e:
10 print(e) # 'tuple' object does not support item assignment
 Python Fundamentals: Basics to Advanced 47

11.7 Tuple Methods

1 # Count occurrences
2 print([Link](1)) # 1
3

4 # Index of value
5 print([Link](3)) # 2

11.8 Packing and Unpacking Tuples

1 # Packing
2 packed_tuple = (1, "hello", 3.14)
3 print(packed_tuple)
4

5 # Unpacking
6 a, b, c = packed_tuple
7 print(a, b, c)
8

9 # Unpacking with star

10 numbers = (1, 2, 3, 4, 5, 6)
11 first, *middle, last = numbers
12 print(first) # 1
13 print(middle) # [2, 3, 4, 5]
14 print(last) # 6

11.9 Nested Tuples

1 nested_tuple = ((1, 2, 3), ("a", "b", "c"), (True, False))
2 print(nested_tuple[0]) # (1, 2, 3)
3 print(nested_tuple[1][2]) # 'c'
4

5 # Iterating over nested tuples

6 for sub_tuple in nested_tuple:
7 for item in sub_tuple:
8 print(item, end=" ")
9 print()

11.10 Conclusion
Tuples are versatile and useful in many real-world scenarios where an immutable and
ordered collection is required. They are commonly used in data structures, function
Python Fundamentals: Basics to Advanced 48

arguments, return values, and as dictionary keys. Understanding tuples can improve the
efficiency and readability of your Python code.
12 Python Dictionaries

12.1 Overview and Outline

In this chapter, we will cover:

• Introduction to dictionaries

• Creating dictionaries

• Accessing dictionary elements

• Modifying dictionary elements

• Common dictionary methods

• Iterating over dictionaries

• Nested dictionaries

• Dictionary comprehension

• Common errors

12.2 Introduction to Dictionaries

Dictionaries are unordered collections of items stored as key-value pairs. Keys must be
unique and immutable; values can be of any type.

12.3 Creating Dictionaries

1 # Empty dictionary
2 empty_dict = {}
3 print(type(empty_dict)) # <class 'dict'>
4

5 # Another way
6 empty_dict2 = dict()
7 print(empty_dict2)
8

9 # Dictionary with key-value pairs

49
 Python Fundamentals: Basics to Advanced 50

10 student = {
11 "name": "John",
12 "age": 32,
13 "grade": "A"
14 }
15 print(student)

12.4 Accessing Dictionary Elements

1 # Access by key
2 print(student["grade"]) # A
3 print(student["age"]) # 32
4

5 # Using get method

6 print([Link]("grade")) # A
7 print([Link]("last_name")) # None
8 print([Link]("last_name", "Not available")) # Not available

12.5 Modifying Dictionary Elements

1 # Update value
2 student["age"] = 33
3

4 # Add new key-value pair

5 student["address"] = "India"
6

7 # Delete a key-value pair

8 del student["grade"]
9

10 print(student)

12.6 Common Dictionary Methods

1 # Get all keys
2 print([Link]())
3

4 # Get all values

5 print([Link]())
6

7 # Get all key-value pairs

8 print([Link]())
9
 Python Fundamentals: Basics to Advanced 51

10 # Shallow copy
11 student_copy = [Link]()
12 student["name"] = "John2"
13 print(student_copy["name"]) # John
14 print(student["name"]) # John2

12.7 Iterating Over Dictionaries

1 # Iterate over keys
2 for key in [Link]():
3 print(key)
4

5 # Iterate over values

6 for value in [Link]():
7 print(value)
8

9 # Iterate over key-value pairs

10 for key, value in [Link]():
11 print(f"{key}: {value}")

12.8 Nested Dictionaries

1 students = {
2 "student1": {"name": "John", "age": 32},
3 "student2": {"name": "Peter", "age": 35}
4 }
5 print(students["student2"]["name"]) # Peter
6

7 # Iterating over nested dictionaries

8 for student_id, student_info in [Link]():
9 print(f"{student_id}: {student_info}")
10 for key, value in student_info.items():
11 print(f"{key}: {value}")

12.9 Dictionary Comprehension

1 # Create a dictionary of squares
2 squares = {x: x**2 for x in range(5)}
3 print(squares)
4 # Output: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
Python Fundamentals: Basics to Advanced 52

12.10 Common Errors

• KeyError: Accessing a key that does not exist.

• Duplicate keys: Only the last value for a key is kept.

• Shallow copy: Use copy() to avoid reference issues.

12.11 Conditional Dictionary Comprehension

You can add conditions to dictionary comprehensions.

1 # Squares of only even numbers

2 even_squares = {x: x**2 for x in range(10) if x % 2 == 0}
3 print(even_squares)
4 # Output: {0: 0, 2: 4, 4: 16, 6: 36, 8: 64}

12.12 Practical Examples

12.12.1 Counting Frequency of Elements in a List

1 numbers = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
2 frequency = {}
3 for number in numbers:
4 if number in frequency:
5 frequency[number] += 1
6 else:
7 frequency[number] = 1
8 print(frequency)
9 # Output: {1: 1, 2: 2, 3: 3, 4: 4}

12.12.2 Merging Two Dictionaries

1 dict1 = {"a": 1, "b": 2}

2 dict2 = {"b": 3, "c": 4}
3 merged_dict = {**dict1, **dict2}
4 print(merged_dict)
5 # Output: {'a': 1, 'b': 3, 'c': 4}
Python Fundamentals: Basics to Advanced 53

12.13 Summary
Dictionaries are powerful data structures for storing and manipulating key-value pairs in
Python. They are mutable, support many useful methods, and can be nested or created
efficiently using dictionary comprehensions.
Dictionary comprehensions allow you to build dictionaries with conditions and concise
syntax. Dictionaries are commonly used for counting, merging, and organizing data.
Practice with more examples to master dictionary operations in Python!
 13 Real World Examples Using Lists

13.1 Overview
Lists are widely used in real-world applications and are a fundamental data structure in
Python. This chapter demonstrates practical examples of how lists can be used in various
scenarios.

13.2 Managing a To-Do List

1 # Create a to-do list
2 to_do_list = ["Buy groceries", "Clean the house", "Pay bills"]
3

4 # Add new tasks

5 to_do_list.append("Schedule meeting")
6 to_do_list.append("Go for a run")
7

8 # Remove a completed task

9 to_do_list.remove("Clean the house")
10

11 # Check if a task is in the list

12 if "Pay bills" in to_do_list:
13 print("Don't forget to pay the utility bills!")
14

15 # Print remaining tasks

16 print("To-do list remaining:")
17 for task in to_do_list:
18 print(f"- {task}")

13.3 Organizing Student Grades

1 grades = [85, 92, 78, 90, 88]
2

3 # Add a new grade

4 [Link](95)
5

6 # Calculate average grade

54
 Python Fundamentals: Basics to Advanced 55

7 average = sum(grades) / len(grades)

8

9 # Find highest and lowest grades

10 highest = max(grades)
11 lowest = min(grades)
12

13 print(f"Average grade: {average}")

14 print(f"Highest grade: {highest}")
15 print(f"Lowest grade: {lowest}")

13.4 Managing an Inventory

1 inventory = ["apples", "bananas", "oranges", "grapes"]
2

3 # Add a new item

4 [Link]("strawberries")
5

6 # Remove an item after delivery

7 [Link]("bananas")
8

9 # Check if an item is in stock

10 item = "oranges"
11 if item in inventory:
12 print(f"{item} are in stock.")
13 else:
14 print(f"{item} are out of stock.")
15

16 # Print current inventory

17 print("Inventory list:", inventory)

13.5 Collecting User Feedback

1 feedback = [
2 "Great service",
3 "Very satisfied",
4 "Could be better",
5 "Excellent experience"
6 ]
7

8 # Add a new feedback

9 [Link]("Not happy with the service")
10

11 # Count positive feedback

12 positive_count = sum(
 Python Fundamentals: Basics to Advanced 56

13 1 for comment in feedback if "great" in [Link]() or "excellent"

in [Link]()
14 )
15

16 print(f"Positive feedback count: {positive_count}")

17 print("User feedback comments:")
18 for comment in feedback:
19 print(f"- {comment}")

13.6 Summary
Lists are a versatile and commonly used data structure in Python. They help manage
tasks, organize data, and analyze information in many real-world applications. Practice
with these examples to strengthen your understanding of lists in Python.
 14 Python Functions

14.1 Overview and Outline

In this chapter, we will cover:

• What are functions?

• Why use functions?

• Defining and calling functions

• Function parameters and default parameters

• Variable length arguments: positional and keyword

• Return statement

• Practical examples

14.2 Introduction to Functions

A function is a block of code that performs a specific task. Functions help organize code,
enable code reuse, and improve readability.

14.3 Defining and Calling Functions

1 # Basic function syntax
2 def function_name(parameters):
3 """Docstring: describes the function."""
4 # Function body
5 return value
6

7 # Example: Check even or odd

8 def even_or_odd(num):
9 """Finds whether a number is even or odd."""
10 if num % 2 == 0:
11 print("The number is even")
12 else:
13 print("The number is odd")

57
 Python Fundamentals: Basics to Advanced 58

14

15 even_or_odd(24)

14.4 Why Use Functions?

Functions allow you to reuse code and keep your programs organized. Instead of repeating
code, you can call a function whenever needed.

14.5 Function with Multiple Parameters

1 def add(a, b):
2 """Returns the sum of two numbers."""
3 return a + b
4

5 result = add(2, 4)
6 print(result) # Output: 6

14.6 Default Parameters

1 def greet(name="Guest"):
2 print(f"Hello {name}, welcome to the Paradise!")
3

4 greet("John") # Output: Hello John, welcome to the Paradise!

5 greet() # Output: Hello Guest, welcome to the Paradise!

14.7 Variable Length Arguments

14.7.1 Positional Arguments (*args)

1 def print_numbers(*args):
2 for number in args:
3 print(number)
4

5 print_numbers(1, 2, 3, 4, 5, "John")

14.7.2 Keyword Arguments (**kwargs)

 Python Fundamentals: Basics to Advanced 59

1 def print_details(**kwargs):
2 for key, value in [Link]():
3 print(f"{key}: {value}")
4

5 print_details(name="John", age=32, country="India")

14.7.3 Combining Positional and Keyword Arguments

1 def print_all(*args, **kwargs):

2 print("Positional arguments:")
3 for val in args:
4 print(val)
5 print("Keyword arguments:")
6 for key, value in [Link]():
7 print(f"{key}: {value}")
8

9 print_all(1, 2, 3, name="John", age=32)

14.8 Return Statement

Functions can return values, including multiple values.

1 def multiply(a, b):

2 return a * b
3

4 result = multiply(2, 3)
5 print(result) # Output: 6
6

7 # Returning multiple values

8 def multi_return(a, b):
9 return a * b, a, b
10

11 x, y, z = multi_return(2, 3)
12 print(x, y, z) # Output: 6 2 3

14.9 Summary
Functions are essential for organizing, reusing, and maintaining code in Python. They
support parameters, default values, variable length arguments, and can return single or
multiple values. Practice writing and using functions to master this important concept!
Python Fundamentals: Basics to Advanced 60

14.10 Information Alert

Schedule learning time: Learning a little each day adds up. Research shows that
students who make learning a habit are more likely to reach their goals. Set time aside
to learn and get reminders using your learning scheduler.
 15 Functions in Python: Practical
Examples

In this chapter, we will explore several practical examples of Python functions. These
examples will reinforce key concepts such as parameters, conditionals, recursion, string
manipulation, dictionaries, and file operations.

15.1 Temperature Conversion

We begin with a simple but useful example: converting temperatures between Celsius
and Fahrenheit.

1 def convert_temperature(temperature, unit):

2 """
3 Converts temperature between Celsius and Fahrenheit.
4 unit = 'C' means convert Celsius to Fahrenheit
5 unit = 'F' means convert Fahrenheit to Celsius
6 """
7 if unit == 'C':
8 return (temperature * 9/5) + 32
9 elif unit == 'F':
10 return (temperature - 32) * 5/9
11 else:
12 return None
13

14 # Example usage
15 print(convert_temperature(25, 'C')) # 77.0
16 print(convert_temperature(77, 'F')) # 25.0
Listing 15.1: Temperature conversion function

This demonstrates how conditionals help handle different cases based on the unit
provided.

15.2 Password Strength Checker

Next, we create a function to check whether a password is strong. A strong password
should:
• Be at least 8 characters long

61
 Python Fundamentals: Basics to Advanced 62

• Contain at least one digit

• Contain at least one uppercase letter

• Contain at least one lowercase letter

• Contain at least one special character

1 def is_strong_password(password):
2 """
3 Checks if the given password is strong.
4 """
5 if len(password) < 8:
6 return False
7 if not any([Link]() for char in password):
8 return False
9 if not any([Link]() for char in password):
10 return False
11 if not any([Link]() for char in password):
12 return False
13 special_chars = "!@#$%^&*()-_=+[{]}|;:'\",<.>/?`~"
14 if not any(char in special_chars for char in password):
15 return False
16 return True
17

18 # Example usage
19 print(is_strong_password("WeakPwd")) # False
20 print(is_strong_password("Str0ngPwd!")) # True
Listing 15.2: Password strength checker

15.3 Shopping Cart: Total Cost

A practical use case of functions and dictionaries is computing the total cost of items in
a shopping cart.

1 def calculate_total_cost(cart):
2 total_cost = 0
3 for item in cart:
4 total_cost += item["price"] * item["quantity"]
5 return total_cost
6

7 # Example cart
8 cart = [
9 {"name": "Apple", "price": 0.5, "quantity": 4},
10 {"name": "Banana", "price": 0.3, "quantity": 6},
11 {"name": "Orange", "price": 0.7, "quantity": 3}
12 ]
13
 Python Fundamentals: Basics to Advanced 63

14 print(calculate_total_cost(cart)) # 5.9
Listing 15.3: Calculating total cost of shopping cart

15.4 Palindrome Checker

A palindrome is a string that reads the same forwards and backwards.

1 def is_palindrome(s):
2 s = [Link]().replace(" ", "")
3 return s == s[::-1]
4

5 # Example usage
6 print(is_palindrome("aba")) # True
7 print(is_palindrome("A man a plan a canal Panama")) # True
8 print(is_palindrome("hello")) # False
Listing 15.4: Palindrome check

15.5 Factorial Using Recursion

Recursion is when a function calls itself. A classic example is computing factorials.

1 def factorial(n):
2 if n == 0:
3 return 1
4 else:
5 return n * factorial(n - 1)
6

7 # Example usage
8 print(factorial(5)) # 120
Listing 15.5: Factorial with recursion

15.6 Word Frequency in a File

We can read a text file and count the frequency of each word using dictionaries.

1 def count_word_frequency(file_path):
2 word_count = {}
3 with open(file_path, "r") as file:
4 for line in file:
5 words = [Link]()
6 for word in words:
7 word = [Link]().strip(".,!?;:\"'()[]{}")
8 word_count[word] = word_count.get(word, 0) + 1
 Python Fundamentals: Basics to Advanced 64

9 return word_count
10

11 # Example usage
12 print(count_word_frequency("[Link]"))
Listing 15.6: Word frequency counter

15.7 Email Validation with Regular Expres-

sions
Finally, we can validate email addresses using regular expressions.

1 import re
2

3 def is_valid_email(email):
4 pattern = r'^[A-Za-z0-9+_.-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$'
5 return [Link](pattern, email) is not None
6

7 # Example usage
8 print(is_valid_email("user@[Link]")) # True
9 print(is_valid_email("invalid-email")) # False
Listing 15.7: Email validation

—
These examples demonstrate how Python functions can be applied in real-world sce-
narios such as data validation, text analysis, and simple mathematical computations.
16 Lambda Functions in Python

16.1 Introduction
In this chapter, we will discuss lambda functions in Python. Lambda functions are
small, anonymous functions defined using the lambda keyword.

• An anonymous function is simply a function without a name.

• Lambda functions can take any number of arguments, but they contain only
one expression.

• They are often used for short operations or as arguments to higher-order functions
such as map() and filter().

16.2 Syntax
The general syntax of a lambda function is:

lambda arguments : expression

16.3 Basic Example

Consider a simple function that adds two numbers:

1 def addition(a, b):

2 return a + b
3

4 print(addition(2, 3)) # 5
Listing 16.1: Standard function for addition

This function contains only a single expression. Instead of writing a full function
definition, we can use a lambda function:

1 addition = lambda a, b: a + b
2 print(addition(5, 6)) # 11
Listing 16.2: Addition using lambda

Here, addition is a variable holding a lambda function.

65
Python Fundamentals: Basics to Advanced 66

16.4 Checking Even Numbers

Let us now write a function to check whether a number is even:

1 def is_even(num):
2 return num % 2 == 0
3

4 print(is_even(24)) # True
Listing 16.3: Even check using a normal function

Using a lambda function:

1 is_even = lambda num: num % 2 == 0

2 print(is_even(12)) # True
Listing 16.4: Even check using lambda

16.5 Lambda with Multiple Parameters

Lambda functions can also accept multiple parameters.

1 addition = lambda x, y, z: x + y + z
2 print(addition(12, 13, 14)) # 39
Listing 16.5: Addition with three parameters

16.6 Using Lambda with Map

Lambda functions are commonly used with higher-order functions like map().

16.6.1 Without Map

To find the square of a number:

1 def square(num):
2 return num ** 2
3

4 print(square(2)) # 4
Listing 16.6: Square function

If we want to apply this to a list of numbers, we would normally write a loop.

16.6.2 With Map and Lambda

Instead, we can use map() with lambda:
Python Fundamentals: Basics to Advanced 67

1 numbers = [1, 2, 3, 4, 5, 6]
2 squared_numbers = list(map(lambda x: x**2, numbers))
3 print(squared_numbers) # [1, 4, 9, 16, 25, 36]
Listing 16.7: Using map with lambda

Here:

• The first argument of map() is a function (in this case, a lambda).

• The second argument is an iterable (the list numbers).

• The result is a map object, which we convert to a list.

16.7 Conclusion
Lambda functions allow us to write small, concise functions in a single line. They are
particularly powerful when combined with functions like map() and filter().
In the next chapter, we will discuss map() and filter() functions in detail.
17 The map() Function in Python

17.1 Introduction
In this chapter, we continue our discussion on Python by learning about the map()
function.
The map() function:
• Applies a given function to all the items in an input iterable (such as a list or
tuple).

• Returns a map object, which is an iterator.

• Is particularly useful for transforming data without writing explicit loops.

17.2 Basic Example

Let us first define a simple function that computes the square of a number:

1 def square(n):
2 return n * n
3

4 print(square(4)) # 16
5 print(square(10)) # 100
Listing 17.1: Square function

If we want to apply this function to a list of numbers, we can use map() instead of
writing a loop.

1 numbers = [1, 2, 3, 4, 5, 6, 7, 8]
2 result = map(square, numbers)
3 print(list(result))
4 # Output: [1, 4, 9, 16, 25, 36, 49, 64]
Listing 17.2: Using map with a defined function

Here:
• The first argument to map() is the function name (square).

• The second argument is the iterable (numbers).

• The result is a map object, which we convert into a list.

68
Python Fundamentals: Basics to Advanced 69

17.3 Using Lambda Functions with Map

Instead of defining a separate function, we can use lambda functions with map().

1 numbers = [1, 2, 3, 4, 5, 6]
2 result = list(map(lambda x: x * x, numbers))
3 print(result)
4 # Output: [1, 4, 9, 16, 25, 36]
Listing 17.3: Using map with a lambda function

Lambda functions make the code shorter and more readable.

17.4 Mapping Multiple Iterables

The map() function can also take multiple iterables. In such cases, the function should
accept the same number of arguments as the iterables.

1 numbers1 = [1, 2, 3]
2 numbers2 = [4, 5, 6]
3

4 added_numbers = list(map(lambda x, y: x + y, numbers1, numbers2))

5 print(added_numbers)
6 # Output: [5, 7, 9]
Listing 17.4: Adding two lists using map

17.5 Using Built-in Functions with Map

We can also apply built-in functions directly with map().

17.5.1 Type Conversion

1 string_numbers = ["1", "2", "3", "4"]

2 int_numbers = list(map(int, string_numbers))
3 print(int_numbers)
4 # Output: [1, 2, 3, 4]
Listing 17.5: Converting strings to integers

17.5.2 String Manipulation

1 words = ["apple", "banana", "cherry"]

2 upper_words = list(map([Link], words))
3 print(upper_words)
 Python Fundamentals: Basics to Advanced 70

4 # Output: ['APPLE', 'BANANA', 'CHERRY']

Listing 17.6: Converting words to uppercase

17.6 Map with a List of Dictionaries

We can even use map() on complex structures like a list of dictionaries.

1 def get_name(person):
2 return person["name"]
3

4 people = [
5 {"name": "John", "age": 32},
6 {"name": "Jack", "age": 33}
7 ]
8

9 names = list(map(get_name, people))

10 print(names)
11 # Output: ['John', 'Jack']
Listing 17.7: Extracting names from a list of dictionaries

17.7 Conclusion
The map() function is a powerful tool for applying transformations to iterable data struc-
tures.

• It can be used with regular functions, lambda functions, and even multiple iter-
ables.

• Built-in functions can also be applied directly using map().

• It improves code readability and efficiency by eliminating explicit loops.

By mastering map(), you can write concise, efficient, and more Pythonic code.
18 The filter() Function in Python

18.1 Introduction
The filter() function in Python constructs an iterator from elements of an iterable for
which a given function returns True. It is primarily used to filter out items from a
list (or any iterable) based on a condition.
Formally:
filter(function, iterable)
- function: A function that returns True or False. - iterable: The sequence (list, tuple,
dictionary, etc.) to filter.
The result is a filter object (an iterator), which can be converted to a list, tuple,
or other data structures.

18.2 Basic Example: Filtering Even Num-

bers
Let us define a function that checks whether a number is even:

1 def is_even(num):
2 return num % 2 == 0
3

4 print(is_even(24)) # True
5 print(is_even(13)) # False
Listing 18.1: Checking even numbers

Now, we can apply this function to filter only even numbers from a list:

1 numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

2

3 result = filter(is_even, numbers)

4 print(list(result))
5 # Output: [2, 4, 6, 8, 10, 12]
Listing 18.2: Filtering even numbers from a list

Here:

• is_even is the filtering function.

71
 Python Fundamentals: Basics to Advanced 72

• Only those elements for which the function returns True are included in the result.

18.3 Using Lambda Functions with Filter

We can avoid writing a separate function by using a lambda function.

1 numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
2

3 result = filter(lambda x: x > 5, numbers)

4 print(list(result))
5 # Output: [6, 7, 8, 9]
Listing 18.3: Filtering numbers greater than 5 using lambda

This provides a concise way to apply filtering logic inline.

18.4 Filter with Multiple Conditions

We can also filter elements using multiple conditions combined with logical operators.

1 numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
2

3 result = filter(lambda x: x > 5 and x % 2 == 0, numbers)

4 print(list(result))
5 # Output: [6, 8]
Listing 18.4: Filtering even numbers greater than 5

In this example:

• The number must be greater than 5.

• The number must also be even.

18.5 Filter with Dictionaries

The filter() function can also be applied to a list of dictionaries.

1 people = [
2 {"name": "John", "age": 32},
3 {"name": "Jack", "age": 33},
4 {"name": "John", "age": 25}
5 ]
6

7 def age_above_25(person):
8 return person["age"] > 25
9

10 result = filter(age_above_25, people)

11 print(list(result))
 Python Fundamentals: Basics to Advanced 73

12 # Output: [{'name': 'John', 'age': 32}, {'name': 'Jack', 'age': 33}]

Listing 18.5: Filtering people with age > 25

Here, only people whose age is greater than 25 are returned.

18.6 Conclusion
The filter() function is a powerful tool for data selection:

• It constructs iterators that return only elements satisfying a condition.

• It can be used with both named functions and lambda expressions.

• It supports filtering on complex data structures such as lists of dictionaries.

By mastering filter(), you can write concise, efficient, and Pythonic code for data
processing and manipulation.
19 Modules and Packages in Python

19.1 Introduction
Python is an open-source programming language with a rich ecosystem of modules and
packages. Modules and packages allow you to:

• Reuse code efficiently

• Organize code logically

• Access built-in or third-party functionality without rewriting it from scratch

19.2 Importing Built-in Modules

Python provides many built-in modules such as math. To use a module, you can import
it:

1 import math
2

3 print([Link](16)) # Output: 4.0

4 print([Link]) # Output: 3.141592653589793
Listing 19.1: Basic import

You can also import specific functions from a module:

1 from math import sqrt, pi

2

3 print(sqrt(25)) # Output: 5.0

4 print(pi) # Output: 3.141592653589793

Or import all functions using the wildcard *:

1 from math import *

2

3 print(sqrt(16)) # Output: 4.0

4 print(pi) # Output: 3.141592653589793

74
Python Fundamentals: Basics to Advanced 75

19.3 Third-party Packages

Third-party packages like NumPy are not included by default. You can install them using
pip:

1 pip install numpy

2 # or via [Link]:
3 pip install -r [Link]

After installation, you can import the package and optionally use an alias:

1 import numpy as np
2

3 arr = [Link]([1, 2, 3, 4])

4 print(arr) # Output: [1 2 3 4]

19.4 Creating Custom Modules and Pack-

ages
19.4.1 Module
A module is a Python file containing functions or classes. Example: [Link]:

1 # [Link]
2 def addition(a, b):
3 return a + b
4

5 def subtraction(a, b):

6 return a - b

19.4.2 Package
A package is a folder containing one or more modules and a special file __init__.py.
Example folder structure:
package/
__init__.py
[Link]
Import a function from a custom package:

1 from [Link] import addition, subtraction

2

3 print(addition(2, 3)) # Output: 5

4 print(subtraction(4, 3)) # Output: 1

Alternatively:
Python Fundamentals: Basics to Advanced 76

1 from package import maths

2

3 print([Link](2, 3)) # Output: 5

4 print([Link](4, 3)) # Output: 1

19.4.3 Sub-packages
Packages can contain sub-packages. Example folder structure:

1 package/
2 __init__.py
3 [Link]
4 subpackage/
5 __init__.py
6 [Link]

[Link]:

1 def multiply(a, b):

2 return a * b

Import from a sub-package:

1 from [Link] import multiply

2

3 print(multiply(4, 5)) # Output: 20

19.5 Key Takeaways

• Modules and packages help organize and reuse code efficiently.

• Built-in modules (math) provide ready-made functionality.

• Third-party packages (NumPy) can be installed via pip.

• Custom packages require a folder with an __init__.py file.

• Sub-packages allow hierarchical organization of complex codebases.

20 Python Standard Library Overview

Python provides a vast standard library that offers modules and packages to handle
common programming tasks. These libraries are open source and can be used to simplify
development and reduce code complexity. In this chapter, we discuss some commonly
used modules and their usage.

20.1 Array Module

The array module allows the creation of arrays with items restricted by type code.

1 import array
2

3 arr = [Link]('i', [1, 2, 3, 4]) # 'i' indicates integer type code

4 print(arr)

20.2 Math Module

The math module provides functions and constants for mathematical operations.

1 import math
2

3 print([Link](16))
4 print([Link])

20.3 Random Module

The random module is used to generate random numbers and select random items from
a collection.

1 import random
2

3 # Generate a random integer between 1 and 10

4 print([Link](1, 10))
5

6 # Select a random item from a list

7 choices = ['apple', 'banana', 'cherry']

77
 Python Fundamentals: Basics to Advanced 78

8 print([Link](choices))

20.4 OS Module
The os module provides functions to interact with the operating system, including file
and directory operations.

1 import os
2

3 # Get current working directory

4 print([Link]())
5

6 # Create a new directory

7 [Link]('test_dir')

20.5 Shutil Module

The shutil module performs high-level file operations such as copying files.

1 import shutil
2

3 # Copy [Link] to [Link]

4 [Link]('[Link]', '[Link]')

20.6 JSON Module

The json module enables serialization (converting a dictionary to JSON) and deserial-
ization (converting JSON to a dictionary).

1 import json
2

3 data = {'name': 'John', 'age': 25}

4

5 # Serialize dictionary to JSON string

6 json_str = [Link](data)
7 print(json_str, type(json_str))
8

9 # Deserialize JSON string back to dictionary

10 parsed_data = [Link](json_str)
11 print(parsed_data, type(parsed_data))
 Python Fundamentals: Basics to Advanced 79

20.7 CSV Module

The csv module allows reading from and writing to CSV files.

1 import csv
2

3 # Writing to CSV
4 with open('[Link]', 'w', newline='') as file:
5 writer = [Link](file)
6 [Link](['name', 'age'])
7 [Link](['John', 32])
8

9 # Reading from CSV

10 with open('[Link]', 'r') as file:
11 reader = [Link](file)
12 for row in reader:
13 print(row)

20.8 Datetime Module

The datetime module provides classes to manipulate dates and times.

1 from datetime import datetime, timedelta

2

3 now = [Link]()
4 print("Current time:", now)
5

6 # Calculate time one day ago

7 yesterday = now - timedelta(days=1)
8 print("Yesterday:", yesterday)

20.9 Time Module

The time module allows controlling execution flow, such as pausing the program.

1 import time
2

3 print([Link]())
4 [Link](2) # Pause execution for 2 seconds
5 print([Link]())

20.10 Regular Expression Module

The re module provides tools for pattern matching in strings.
Python Fundamentals: Basics to Advanced 80

1 import re
2

3 pattern = r'\d+'
4 text = "There are 123 apples"
5

6 match = [Link](pattern, text)

7 print([Link]()) # Output: 123

20.11 Summary
The Python standard library contains numerous modules for a variety of tasks. Com-
monly used modules include:

• array

• math

• random

• os

• shutil

• json

• csv

• datetime

• time

• re

These modules facilitate common programming operations, reduce development effort,

and enhance code readability. Exploring the standard library enables efficient implemen-
tation of complex functionalities without relying on external libraries.
21 File Operations in Python

Python provides robust support for handling both text and binary files. This chapter
discusses various file operations including reading, writing, appending, and working with
file cursors.

21.1 Reading a File

Python provides the open function to access files. By default, files are opened in read
mode ('r'). The with statement ensures proper closure of files.

21.1.1 Reading the Entire File

1 with open('[Link]', 'r') as file:

2 content = [Link]()
3 print(content)

Explanation: The read() method reads the entire content of the file. If the file
does not exist, Python will raise a FileNotFoundError.

21.1.2 Reading Line by Line

1 with open('[Link]', 'r') as file:

2 for line in file:
3 print([Link]())

Explanation: Iterating over the file object reads one line at a time. The strip()
method removes newline characters for cleaner output.

21.2 Writing to a File

Files can be opened in write mode ('w') to overwrite existing content, or append mode
('a') to add content at the end.

21.2.1 Overwriting a File

81
Python Fundamentals: Basics to Advanced 82

1 with open('[Link]', 'w') as file:

2 [Link]("Hello World\n")
3 [Link]("This is a new line\n")

Explanation: Opening a file in write mode ('w') erases existing content. Each
write() call adds content to the file.

21.2.2 Appending to a File

1 with open('[Link]', 'a') as file:

2 [Link]("Appending this line\n")

Explanation: Append mode ('a') adds new content at the end without deleting
existing data. The newline character '\n' ensures proper line separation.

21.2.3 Writing Multiple Lines

1 lines = ["First line\n", "Second line\n", "Third line\n"]

2 with open('[Link]', 'a') as file:
3 [Link](lines)

Explanation: writelines() writes a list of strings to the file sequentially.

21.3 Binary File Operations

Binary files store data in bytes. Python provides modes 'wb' and 'rb' for writing and
reading binary files.

21.3.1 Writing to a Binary File

1 with open('[Link]', 'wb') as file:

2 [Link](b"Hello World in bytes")

21.3.2 Reading from a Binary File

1 with open('[Link]', 'rb') as file:

2 content = [Link]()
3 print(content)
 Python Fundamentals: Basics to Advanced 83

21.4 Copying File Content

It is possible to read from a source file and write to a destination file.

1 with open('[Link]', 'r') as src, open('[Link]', 'w') as dst:

2 content = [Link]()
3 [Link](content)

21.5 Reading, Writing, and Using File Cur-

sor
Python provides the w+ mode to simultaneously read and write a file. The seek() method
resets the file cursor for reading after writing.

1 with open('[Link]', 'w+') as file:

2 [Link]("Hello World\n")
3 [Link]("This is a new line\n")
4

5 # Move cursor to the beginning

6 [Link](0)
7

8 # Read content after writing

9 content = [Link]()
10 print(content)

Explanation: When writing to a file in w+ mode, the cursor moves to the end. Using
seek(0) resets it to the beginning, allowing the content to be read.

21.6 Practical Assignments

1. Read a text file and count the number of lines, words, and characters.

2. Copy content from a source text file to a destination text file.

3. Write and read a file multiple times using w+ mode and seek() to manipulate the
file cursor.

21.7 Summary
Python provides powerful and flexible file handling mechanisms for both text and binary
files. Key operations include:

• open() with modes: r, w, a, r+, w+, rb, wb

• Reading entire file or line by line

Python Fundamentals: Basics to Advanced 84

• Writing, appending, and writing multiple lines

• Using seek() to manipulate file cursor

• Handling binary files using byte operations

Mastering these operations is essential for file manipulation tasks in Python program-
ming.
22 Working with Directories and File
Paths in Python

Python’s os module provides functionality to interact with the operating system, allowing
users to create directories, list files, manipulate paths, and check file or directory existence.
This chapter discusses these features with practical examples.

22.1 Creating a New Directory

A new directory can be created using the [Link]() function.

1 import os
2

3 new_directory = 'package'
4 [Link](new_directory)
5 print(f"Directory {new_directory} created")

Explanation: The above code creates a folder named package in the current working
directory and confirms creation with a message.

22.2 Listing Files and Directories

To list all files and directories within a folder, use the [Link]() method.

1 items = [Link]('.')
2 print(items)

Explanation: The dot (.) refers to the current working directory. This function
returns all files and subdirectories in the specified folder.

22.3 Joining Paths

Hardcoding paths can create compatibility issues across different operating systems.
Python provides [Link]() to build system-independent paths.

1 directory_name = 'folder'
2 file_name = '[Link]'

85
Python Fundamentals: Basics to Advanced 86

4 full_path = [Link](directory_name, file_name)

5 print(full_path)
6

7 absolute_path = [Link]([Link](), directory_name, file_name)

8 print(absolute_path)

Explanation: [Link]() constructs a relative or absolute path using the cur-

rent working directory ([Link]()) and folder/file names.

22.4 Checking Path Existence

Before performing file operations, it is essential to verify if a file or directory exists.

1 path = '[Link]'
2

3 if [Link](path):
4 print(f"The path {path} exists")
5 else:
6 print(f"The path {path} does not exist")

Explanation: [Link]() returns True if the specified path exists; otherwise,

it returns False.

22.5 Checking File or Directory Type

Python provides methods to determine whether a path is a file or a directory.

1 path = '[Link]'
2

3 if [Link](path):
4 print(f"The path {path} is a file")
5 elif [Link](path):
6 print(f"The path {path} is a directory")
7 else:
8 print(f"{path} is neither a file nor a directory")

Explanation: Use [Link]() and [Link]() to differentiate be-

tween files and folders.

22.6 Relative vs. Absolute Paths

A relative path specifies a location relative to the current working directory, whereas an
absolute path provides the full path from the root directory.

1 relative_path = 'folder/[Link]'
2 absolute_path = [Link](relative_path)
Python Fundamentals: Basics to Advanced 87

3 print(absolute_path)

Explanation: [Link]() converts a relative path to an absolute path,

which can be used reliably in file operations across different systems.

22.7 Practical Notes

• Always check whether a file or directory exists before performing operations to
avoid errors.

• Use [Link]() to maintain compatibility across operating systems.

• os module functions like mkdir(), listdir(), [Link](), isfile(), and

isdir() are essential for end-to-end projects involving multiple files and directo-
ries.

22.8 Summary
The os module provides essential utilities to manage directories and file paths in Python.
Key operations include:

• Creating directories with [Link]()

• Listing files and directories with [Link]()

• Joining paths using [Link]()

• Checking existence with [Link]()

• Identifying file or directory type with [Link]() and [Link]()

• Converting relative paths to absolute paths using [Link]()

Mastering these operations is crucial for robust file and directory management in
Python-based projects.
23 Exception Handling in Python

Exception handling in Python allows programmers to manage errors gracefully and take
corrective actions without stopping the execution of a program. This chapter introduces
the key concepts of exceptions and demonstrates how to handle them using try, except,
else, and finally blocks.

23.1 Introduction to Exceptions

Exceptions are events that disrupt the normal flow of a program. They occur when an
error is encountered during execution. Unlike syntax errors, exceptions are detected while
the program is running. Common examples include:

• ZeroDivisionError — division by zero.

• FileNotFoundError — file does not exist.

• ValueError — invalid value for an operation.

• TypeError — incorrect data type.

• NameError — variable is not defined.

23.2 Basic try-except Block

The try block contains code that may raise an exception. If an exception occurs, it is
caught by the except block.

1 try:
2 a = b
3 except NameError:
4 print("The variable has not been assigned.")

Explanation: Here, b is not defined. The NameError exception is caught, and a

user-friendly message is displayed instead of stopping the program.

23.3 Handling Exception Objects

You can capture the exception object to display more details:

88
Python Fundamentals: Basics to Advanced 89

1 try:
2 a = b
3 except NameError as e:
4 print(f"Exception occurred: {e}")

This prints the actual exception message: NameError: name 'b' is not defined.

23.4 Handling Multiple Exceptions

Different exceptions can be handled using multiple except blocks:

1 try:
2 result = 10 / num
3 except ValueError:
4 print("Not a valid number.")
5 except ZeroDivisionError:
6 print("Enter a denominator greater than zero.")
7 except Exception as e:
8 print(f"An unexpected error occurred: {e}")

Explanation:

• ValueError handles invalid input values.

• ZeroDivisionError handles division by zero.

• Exception is the base class for all exceptions and catches any other errors.

23.5 Using the else and finally Blocks

Python’s exception handling allows graceful management of runtime errors. In addition
to try and except blocks, Python provides else and finally for more control.

23.5.1 The else Block

The else block executes only if no exception occurs in the try block. It is useful for
code that should run after successful execution.

1 try:
2 num = int(input("Enter a number: "))
3 result = 10 / num
4 except ValueError:
5 print("Not a valid number.")
6 except ZeroDivisionError:
7 print("Enter a denominator greater than zero.")
8 else:
9 print(f"The result is {result}")
 Python Fundamentals: Basics to Advanced 90

Explanation:

• Executes only if the user inputs a valid number.

• Skipped if any exception occurs.

23.5.2 The finally Block

The finally block executes regardless of whether an exception occurs. It is commonly
used to release resources such as files or database connections.

1 try:
2 num = int(input("Enter a number: "))
3 result = 10 / num
4 except ZeroDivisionError:
5 print("You can't divide by zero.")
6 except ValueError:
7 print("Not a valid number.")
8 else:
9 print(f"The result is {result}")
10 finally:
11 print("Execution complete.")

Explanation:

• else runs only if no exception occurs.

• finally runs regardless of exceptions, making it ideal for cleanup tasks.

23.5.3 Practical Example: File Handling

1 try:
2 file = open("example_one.txt", "r")
3 content = [Link]()
4 print(content)
5 except FileNotFoundError:
6 print("The file does not exist.")
7 except Exception as e:
8 print(f"An error occurred: {e}")
9 finally:
10 if 'file' in locals() and not [Link]:
11 [Link]()
12 print("File closed.")

Explanation:

• Handles missing files gracefully with FileNotFoundError.

• Catches unexpected errors using the base Exception class.

• Ensures the file is always closed with finally.

Python Fundamentals: Basics to Advanced 91

23.6 Key Takeaways

• Use except to catch specific exceptions.

• Use else for code that should run if no exceptions occur.

• Use finally for cleanup tasks that must execute regardless of exceptions.

• Combine try, except, else, and finally for robust, user-friendly code.

Conclusion: Mastering try-except-else-finally blocks ensures that Python pro-

grams handle errors gracefully, maintain resource integrity, and provide clear, user-
friendly feedback.
24 Object-Oriented Programming in
Python: Classes and Objects

24.1 Introduction to Object-Oriented Pro-

gramming
Object-Oriented Programming (OOP) is a programming paradigm that uses objects to
design applications and computer programs. Python allows us to model real-world sce-
narios using classes and objects, which increases code reusability and efficiency. By
understanding OOP concepts, we can develop real-world use cases effectively.

24.2 Classes and Objects

A class is a blueprint for creating objects. It contains attributes (properties) and methods
(functions) that define the behavior and characteristics of the object.

24.2.1 Basic Example: Car Class

We can define a class in Python using the class keyword:

1 class Car:
2 pass

Here, Car is a class. We can now create objects (instances) from this class:

1 # Creating objects
2 audi = Car()
3 bmw = Car()
4

5 print(type(audi)) # Output: <class '__main__.Car'>

6 print(type(bmw)) # Output: <class '__main__.Car'>

Each object represents a specific instance of the class. For example, audi and bmw are
different cars, but they share the same blueprint provided by the Car class.

24.3 Attributes and Methods

92
Python Fundamentals: Basics to Advanced 93

24.3.1 Instance Variables

Attributes represent the properties of a class. We can define them for objects as follows:

1 [Link] = 4
2 tata = Car()
3 [Link] = 4

However, this approach is not recommended because attributes may not be consistent
across objects. Instead, we use a constructor method to initialize attributes.

24.3.2 Constructor: __init__ Method

The __init__ method is called a constructor and is used to initialize attributes when an
object is created. It uses the self keyword to refer to the current instance.

1 class Dog:
2 def __init__(self, name, age):
3 [Link] = name
4 [Link] = age

name and age are instance variables initialized during object creation:

1 dog1 = Dog("Buddy", 3)
2 dog2 = Dog("Lucy", 4)
3

4 print([Link], [Link]) # Output: Buddy 3

5 print([Link], [Link]) # Output: Lucy 4

24.3.3 Instance Methods

Methods define the behavior of objects. An instance method can access instance variables
using self:

1 class Dog:
2 def __init__(self, name, age):
3 [Link] = name
4 [Link] = age
5

6 def bark(self):
7 print(f"{[Link]} says Woof")

We can now call methods on specific objects:

1 [Link]() # Output: Buddy says Woof

2 [Link]() # Output: Lucy says Woof

Each object uses the same method but behaves according to its own attributes.
 Python Fundamentals: Basics to Advanced 94

24.4 Example: Bank Account

Let’s create a practical example of modeling a bank account using classes.

24.4.1 Class Definition

1 class BankAccount:
2 def __init__(self, owner, balance=0):
3 [Link] = owner
4 [Link] = balance
5

6 def deposit(self, amount):

7 [Link] += amount
8 print(f"{amount} is deposited. New balance: {[Link]}")
9

10 def withdraw(self, amount):

11 if amount > [Link]:
12 print("Insufficient funds")
13 else:
14 [Link] -= amount
15 print(f"{amount} is withdrawn. New balance: {[Link]}")
16

17 def get_balance(self):
18 return [Link]

24.4.2 Creating Objects and Using Methods

1 # Creating a bank account for Crush

2 account = BankAccount("Crush", 5000)
3

4 # Depositing money
5 [Link](100) # Output: 100 is deposited. New balance: 5100
6

7 # Withdrawing money
8 [Link](300) # Output: 300 is withdrawn. New balance: 4800
9

10 # Checking balance
11 print(account.get_balance()) # Output: 4800

24.5 Conclusion
Object-Oriented Programming in Python allows us to model real-world scenarios using
classes and objects. In this chapter, you have learned how to:

• Create classes and objects

Python Fundamentals: Basics to Advanced 95

• Define and use instance variables (attributes)

• Define and use instance methods

• Apply these concepts in a real-world example of a bank account

Understanding OOP is essential for writing reusable, maintainable, and scalable

Python applications.
 25 Inheritance in Python: Single and
Multiple Inheritance

25.1 Introduction
Inheritance is a fundamental concept in object-oriented programming (OOP) that allows
a class to inherit attributes and methods from another class. This promotes code reuse
and models real-world scenarios, such as inheriting property from parents.
In this chapter, we will discuss how to implement **single inheritance** and **mul-
tiple inheritance** in Python, with practical examples.

25.2 Single Inheritance

25.2.1 Parent Class Example: Car
We define a parent class Car with attributes windows, doors, and engine_type, along
with an instance method drive.

1 class Car:
2 def __init__(self, windows, doors, engine_type):
3 [Link] = windows
4 [Link] = doors
5 self.engine_type = engine_type
6

7 def drive(self):
8 print(f"The person will drive the {self.engine_type} car")
9

10 # Create an object of Car

11 car1 = Car(4, 5, "petrol")
12 [Link]()

25.2.2 Child Class Example: Tesla

The Tesla class inherits from Car and adds a new attribute is_self_driving along with
a method to show this feature.

1 class Tesla(Car):
2 def __init__(self, windows, doors, engine_type, is_self_driving):

96
 Python Fundamentals: Basics to Advanced 97

3 super().__init__(windows, doors, engine_type)

4 self.is_self_driving = is_self_driving
5

6 def self_driving_info(self):
7 print(f"Tesla supports self-driving: {self.is_self_driving}")
8

9 # Create an object of Tesla

10 tesla1 = Tesla(4, 5, "electric", True)
11 [Link]() # inherited from Car
12 tesla1.self_driving_info() # Tesla specific method

25.3 Multiple Inheritance

Multiple inheritance occurs when a class inherits from more than one base class.

25.3.1 Base Classes Example: Animal and Pet

1 class Animal:
2 def __init__(self, name):
3 [Link] = name
4

5 def speak(self):
6 print("Subclasses must implement this method")
7

8 class Pet:
9 def __init__(self, owner):
10 [Link] = owner

25.3.2 Derived Class Example: Dog

1 class Dog(Animal, Pet):

2 def __init__(self, name, owner):
3 Animal.__init__(self, name)
4 Pet.__init__(self, owner)
5

6 def speak(self):
7 return f"{[Link]} says woof"
8

9 # Create object of Dog

10 dog = Dog("Buddy", "Crush")
11 print([Link]()) # Output: Buddy says woof
12 print([Link]) # Output: Crush
Python Fundamentals: Basics to Advanced 98

25.4 Conclusion
• Single inheritance allows a child class to inherit attributes and methods from
a single parent class.

• Multiple inheritance allows a child class to inherit from multiple parent classes.

• Use of the super() function or direct parent class calls helps initialize inherited
attributes.

• Inheritance is useful for code reuse and modeling real-world relationships in

Python.
 26 Polymorphism in Python

Polymorphism is a fundamental concept in object-oriented programming that allows ob-

jects of different classes to be treated as objects of a common superclass. It provides a
mechanism to perform a single action in multiple forms, enhancing code flexibility and
maintainability. The term ”polymorphism” literally means ”many forms.”

26.1 Method Overriding

Method overriding enables a child class to provide a specific implementation of a method
that is already defined in its parent class. This allows derived classes to modify or extend
the behavior of the base class.

26.1.1 Example: Animal Sounds

1 class Animal:
2 def speak(self):
3 return "Sound of the animal"
4

5 class Dog(Animal):
6 def speak(self):
7 return "Woof"
8

9 class Cat(Animal):
10 def speak(self):
11 return "Meow"
12

13 dog = Dog()
14 cat = Cat()
15

16 print([Link]()) # Output: Woof

17 print([Link]()) # Output: Meow
Listing 26.1: Method Overriding with Animals

In this example, the method speak is overridden in each child class, allowing Dog and
Cat to produce distinct outputs.

99
 Python Fundamentals: Basics to Advanced 100

26.2 Polymorphism with Functions

Polymorphism can also be demonstrated using functions that operate on objects of dif-
ferent types in a uniform manner. This approach allows the same function to process
various object types, each implementing the required interface or method.

26.2.1 Example: Shapes and Areas

1 class Shape:
2 def area(self):
3 pass
4

5 class Rectangle(Shape):
6 def __init__(self, width, height):
7 [Link] = width
8 [Link] = height
9 def area(self):
10 return [Link] * [Link]
11

12 class Circle(Shape):
13 def __init__(self, radius):
14 [Link] = radius
15 def area(self):
16 return 3.14 * [Link] * [Link]
17

18 def print_area(shape):
19 print(f"The area is: {[Link]()}")
20

21 rect = Rectangle(4, 5)
22 circle = Circle(3)
23

24 print_area(rect) # Output: The area is: 20

25 print_area(circle) # Output: The area is: 28.26
Listing 26.2: Polymorphism with Shape Classes

The function print_area illustrates polymorphism by invoking the area method on

objects of different classes.

26.3 Polymorphism with Abstract Base Classes

In Python, interfaces are implemented through abstract base classes (ABCs). An abstract
base class defines a common interface for a group of related objects and enforces that
derived classes implement the required methods. This ensures consistency across multiple
implementations.

26.3.1 Example: Vehicles

 Python Fundamentals: Basics to Advanced 101

1 from abc import ABC, abstractmethod

2

3 class Vehicle(ABC):
4 @abstractmethod
5 def start_engine(self):
6 pass
7

8 class Car(Vehicle):
9 def start_engine(self):
10 return "Car engine started"
11

12 class Motorcycle(Vehicle):
13 def start_engine(self):
14 return "Motorcycle engine started"
15

16 car = Car()
17 motorcycle = Motorcycle()
18

19 print(car.start_engine()) # Output: Car engine started

20 print(motorcycle.start_engine()) # Output: Motorcycle engine started
Listing 26.3: Polymorphism using Abstract Base Classes

This example demonstrates how abstract base classes enforce method implementation,
while still supporting polymorphic behavior across multiple derived classes.

26.4 Conclusion
Polymorphism is an essential feature of object-oriented programming. It allows a sin-
gle function or method to handle objects from different classes, each implementing the
required method in its own way. By leveraging polymorphism, developers can write flexi-
ble, extensible, and maintainable code that accommodates future changes and extensions
without requiring modifications to existing logic.
27 Encapsulation in Python

Encapsulation is a core concept in object-oriented programming that helps in designing

maintainable and reusable code. It refers to the practice of bundling data (variables)
and methods that operate on that data into a single unit (a class) and restricting direct
access to some components of an object. This prevents accidental modification or misuse
of the data.

27.1 Access Modifiers in Python

Python supports three main types of access modifiers:

• Public: Variables and methods accessible from anywhere in the program.

• Protected: Variables and methods prefixed with a single underscore (‘_‘) that
should only be accessed within the class and its subclasses.

• Private: Variables and methods prefixed with double underscores (‘__‘) that
are intended to be hidden from outside the class.

27.2 Public Variables

Public instance variables can be accessed directly using the object.

1 class Person:
2 def __init__(self, name, age):
3 [Link] = name # Public variable
4 [Link] = age # Public variable
5

6 person = Person("Chris", 34)

7 print([Link]) # Output: Chris
8 print([Link]) # Output: 34
Listing 27.1: Public Variables Example

27.3 Private Variables

Private variables are not accessible directly outside the class. They are defined with
double underscores (‘__‘) and are intended to be hidden.

102
 Python Fundamentals: Basics to Advanced 103

1 class Person:
2 def __init__(self, name, age):
3 self.__name = name # Private variable
4 self.__age = age # Private variable
5

6 person = Person("Chris", 34)

7 # print(person.__name) # This would raise an AttributeError
Listing 27.2: Private Variables Example

27.4 Protected Variables

Protected variables, prefixed with a single underscore (‘_‘), can be accessed in subclasses
but are conventionally not accessed directly from outside the class.

1 class Person:
2 def __init__(self, name):
3 self._name = name # Protected variable
4

5 class Employee(Person):
6 def display_name(self):
7 return self._name
8

9 employee = Employee("Chris")
10 print(employee.display_name()) # Output: Chris
Listing 27.3: Protected Variables Example

27.5 Getter and Setter Methods

To access or modify private variables safely, Python uses getter and setter methods.
These allow controlled access to private attributes and can enforce constraints.

1 class Person:
2 def __init__(self, name, age):
3 self.__name = name
4 self.__age = age
5

6 # Getter methods
7 def get_name(self):
8 return self.__name
9

10 def get_age(self):
11 return self.__age
12

13 # Setter methods
14 def set_name(self, name):
 Python Fundamentals: Basics to Advanced 104

15 self.__name = name
16

17 def set_age(self, age):

18 if age > 0:
19 self.__age = age
20 else:
21 print("Age cannot be negative")
22

23 # Example usage
24 person = Person("Chris", 34)
25 print(person.get_name()) # Output: Chris
26 print(person.get_age()) # Output: 34
27

28 person.set_age(35)
29 print(person.get_age()) # Output: 35
30

31 person.set_age(-5) # Output: Age cannot be negative

Listing 27.4: Encapsulation Using Getter and Setter

27.6 Conclusion
Encapsulation in Python is achieved using access modifiers (public, protected, private)
and getter/setter methods.

• Public variables: Accessible from anywhere.

• Protected variables: Accessible within the class and subclasses.

• Private variables: Restricted to the class itself, accessed only through get-
ter/setter methods.

This approach hides internal implementation details while exposing only the neces-
sary interface, leading to safer and more maintainable code. Abstraction, which will
be discussed in the next chapter, builds upon encapsulation to further simplify complex
systems.
 28 Abstraction in Python

Abstraction is a fundamental concept in object-oriented programming (OOP). It involves

hiding complex implementation details while exposing only the essential features of an
object. This reduces programming complexity and enhances maintainability.

28.1 Real-World Examples of Abstraction

• Washing Machine: Users interact with buttons to start, stop, or set a timer,
while the internal washing process remains hidden.

• Mobile Phones or Laptops: Users see icons, buttons, or menus for operations
like shutting down or opening applications, but the underlying implementation is
concealed.

• AC Remote: The remote exposes essential controls, while the internal circuitry
and logic remain hidden.

28.2 Abstract Classes in Python

Python provides the abc module to implement abstraction. An abstract class serves
as a blueprint for derived classes and can contain both normal and abstract methods.
Abstract methods define a required interface but contain no implementation.

1 from abc import ABC, abstractmethod

2

3 # Abstract base class

4 class Vehicle(ABC):
5

6 def drive(self):
7 print("The vehicle is used for driving") # Normal method
8

9 @abstractmethod
10 def start_engine(self):
11 pass # Abstract method to be implemented by subclasses
Listing 28.1: Abstract Class and Method Example

105
 Python Fundamentals: Basics to Advanced 106

28.3 Implementing Abstract Methods in Child

Classes
Derived classes must implement all abstract methods from the abstract base class. This
ensures the necessary features are exposed, while complex implementation details are
handled internally.

1 class Car(Vehicle):
2

3 def start_engine(self):
4 print("Car engine started") # Implementation of abstract method
5

6 # Example usage
7 def operate_vehicle(vehicle):
8 vehicle.start_engine()
9

10 car = Car()
11 operate_vehicle(car) # Output: Car engine started
12 [Link]() # Output: The vehicle is used for driving
Listing 28.2: Derived Class Implementing Abstract Method

28.4 Key Points

• Abstraction hides the internal workings of an object and exposes only the required
interface.

• Abstract classes are defined by inheriting from ABC.

• Abstract methods must be implemented by derived classes, allowing flexibility in

how functionality is realized.

• Normal methods in abstract classes can still provide shared functionality accessi-
ble by all derived classes.

28.5 Conclusion
Abstraction simplifies interaction with objects by presenting only the necessary features
and hiding the internal complexities. It improves code maintainability, reusability, and
reduces cognitive load for developers. Python supports abstraction through abstract base
classes and abstract methods.
29 Magic Methods in Python

In our previous discussions, we have covered many concepts in object-oriented program-

ming (OOP), including function and method overriding, encapsulation, and abstraction.
In this chapter, we will explore magic methods in Python.

29.1 Introduction to Magic Methods

Magic methods, also known as dunder methods (double underscore methods), are special
methods that begin and end with double underscores. They allow you to define the
behavior of objects for built-in operations such as arithmetic, comparison, and string
representation.
Some common magic methods include:

• __init__ – Constructor, initializes a new instance of a class.

• __str__ – Returns a human-readable string representation of the object.

• __repr__ – Returns an official string representation of the object, useful for de-
bugging.

29.2 Basic Example of Magic Methods

1 class Person:
2 def __init__(self, name, age):
3 [Link] = name
4 [Link] = age
Listing 29.1: Defining a Class with Magic Methods

Creating an object of this class:

1 person = Person("John", 34)

2 print(person) # Default output: <__main__.Person object at 0x...>

By default, printing the object displays its memory address. To customize this, we
override the __str__ method.

107
 Python Fundamentals: Basics to Advanced 108

29.3 Overriding __str__ Method

1 class Person:
2 def __init__(self, name, age):
3 [Link] = name
4 [Link] = age
5

6 def __str__(self):
7 return f"{[Link]}, {[Link]} years old"
8

9 person = Person("John", 34)

10 print(person) # Output: John, 34 years old

29.4 Overriding __repr__ Method

The __repr__ method provides an official string representation of an object, often used
for debugging:

1 class Person:
2 def __init__(self, name, age):
3 [Link] = name
4 [Link] = age
5

6 def __repr__(self):
7 return f"Person(name={[Link]}, age={[Link]})"
8

9 person = Person("John", 34)

10 print(repr(person)) # Output: Person(name=John, age=34)

29.5 Key Points

• Magic methods define how objects behave with built-in operations.

• Overriding magic methods allows you to customize object behavior.

• Common magic methods include __init__, __str__, __repr__, __add__, __eq__,

and many more.

• You can explore additional magic methods to implement operator overloading or

other custom behaviors.
Python Fundamentals: Basics to Advanced 109

29.6 Conclusion
Magic methods provide a powerful way to define object behavior for built-in operations.
By overriding these methods, you can make your objects more intuitive, readable, and
functional. In the next chapter, we will explore operator overloading, which builds
upon magic methods to customize arithmetic and comparison operations.
 30 Operator Overloading in Python

In our previous discussion, we explored magic methods. In this chapter, we will learn
how to use these methods to perform operator overloading.

30.1 Introduction
Operator overloading allows you to define custom behavior for Python’s built-in operators
(such as +, -, *, ==, etc.) for your own objects. This is done by overriding specific magic
methods.

• __add__ for addition (+)

• __sub__ for subtraction (-)

• __mul__ for multiplication (*)

• __truediv__ for division (/)

• __eq__ for equality comparison (==)

• __lt__ for less than (<)

• __gt__ for greater than (>)

30.2 Example: Vector Class

We can overload operators for a simple 2D vector class.

1 class Vector:
2 def __init__(self, x, y):
3 self.x = x
4 self.y = y
5

6 # Addition
7 def __add__(self, other):
8 return Vector(self.x + other.x, self.y + other.y)
9

10 # Subtraction
11 def __sub__(self, other):
12 return Vector(self.x - other.x, self.y - other.y)

110
 Python Fundamentals: Basics to Advanced 111

13

14 # Multiplication (by scalar)

15 def __mul__(self, other):
16 return Vector(self.x * other, self.y * other)
17

18 # Equality check
19 def __eq__(self, other):
20 return self.x == other.x and self.y == other.y
21

22 # String representation
23 def __repr__(self):
24 return f"Vector(x={self.x}, y={self.y})"
25

26 # Create vector objects

27 v1 = Vector(2, 3)
28 v2 = Vector(4, 5)
29

30 # Operator overloading in action

31 print(v1 + v2) # Vector(x=6, y=8)
32 print(v1 - v2) # Vector(x=-2, y=-2)
33 print(v1 * 3) # Vector(x=6, y=9)
34 print(v1 == v2) # False
Listing 30.1: Vector Class with Operator Overloading

30.3 Explanation
• v1 + v2 calls v1.__add__(v2) and returns a new vector with summed coordi-
nates.

• v1 - v2 calls v1.__sub__(v2).

• v1 * 3 calls v1.__mul__(3) for scalar multiplication.

• v1 == v2 calls v1.__eq__(v2) and returns a boolean.

• __repr__ provides a human-readable representation for debugging and printing.

30.4 Key Points

• Operator overloading is achieved by overriding magic methods.

• You can overload arithmetic, comparison, and other operators for custom classes.

• This is particularly useful for mathematical objects like vectors, matrices, and
complex numbers.

• Proper implementation of these methods ensures your objects behave intuitively.

Python Fundamentals: Basics to Advanced 112

30.5 Conclusion
Magic methods and operator overloading are powerful features in Python. They allow you
to define custom behaviors for standard operators, making your objects more expressive
and easier to use in application development. You can apply this to vectors, matrices,
complex numbers, or any custom data structures.
31 Creating Web Applications with
Streamlit

In this chapter, we will learn how to create interactive web applications using Streamlit,
an open-source framework for machine learning and data science projects. Streamlit
allows you to build beautiful web apps using only Python scripts, without needing HTML
or CSS knowledge.

31.1 Introduction to Streamlit

Streamlit is widely used in data science and AI projects, including creating interactive
dashboards and generative AI chatbots. Its key features include:

• Easy Python integration

• Pre-built widgets (text input, sliders, select boxes, etc.)

• Charts and tables support

• Rapid prototyping for ML and data projects

31.2 Getting Started

31.2.1 Installation
Install the required packages using:

1 pip install -r [Link]

31.2.2 Basic App Setup

Create a Python file, e.g., [Link], and import Streamlit:

1 import streamlit as st
2 import pandas as pd
3 import numpy as np
4

5 # Title of the app

113
 Python Fundamentals: Basics to Advanced 114

6 [Link]("Hello Streamlit")
7

8 # Display a simple text

9 [Link]("This is a simple text.")
10

11 # Display a DataFrame
12 df = [Link]({
13 "Column 1": [1, 2, 3],
14 "Column 2": [4, 5, 6]
15 })
16 [Link]("Here is the DataFrame:")
17 [Link](df)
18

19 # Create a line chart

20 chart_data = [Link](
21 [Link](20, 3),
22 columns=['A', 'B', 'C']
23 )
24 st.line_chart(chart_data)

Run the app with:

1 streamlit run [Link]

The app will open in your browser at localhost:8501.

31.3 Interactive Widgets

Streamlit provides several widgets for user interaction. Examples:

31.3.1 Text Input

1 name = st.text_input("Enter your name:")

2

3 if name:
4 [Link](f"Hello {name}!")

31.3.2 Slider

1 age = [Link]("Select your age:", 0, 100, 25)

2 [Link](f"Your age is: {age}")

31.3.3 Select Box

Python Fundamentals: Basics to Advanced 115

1 options = ["Python", "Java", "C", "C++", "JavaScript"]

2 choice = [Link]("Choose your favorite programming language:", options
)
3 [Link](f"Your choice is: {choice}")

31.3.4 File Uploader

1 uploaded_file = st.file_uploader("Choose a CSV file", type="csv")

2

3 if uploaded_file is not None:

4 df = pd.read_csv(uploaded_file)
5 [Link](df)

31.4 Conclusion
Streamlit allows rapid development of interactive web apps for data science and machine
learning projects. Key points:

• No need for HTML/CSS knowledge

• Easy to display data, charts, and widgets

• Ideal for POCs and interactive dashboards

• Supports machine learning project deployment

In the next chapter, we will demonstrate an end-to-end machine learning application

built using Streamlit, showcasing how to make ML models interactive and accessible via
a web app.
32 Building a Machine Learning Web
App with Streamlit

In this chapter, we demonstrate how to create an interactive machine learning application

using Streamlit. This example uses the classic Iris dataset and a Random Forest classifier
to showcase predictions in real-time.

32.1 Introduction
Streamlit allows developers to create interactive web apps for data science and machine
learning without needing HTML or CSS. By combining sliders, input fields, and charts,
users can interact with models directly from the browser.

32.2 Project Setup

32.2.1 Installing Dependencies
Install the required packages using:

1 pip install -r [Link]

Ensure the environment includes streamlit, pandas, numpy, and scikit-learn.

32.2.2 Importing Libraries

1 import streamlit as st
2 import pandas as pd
3 import numpy as np
4 from [Link] import load_iris
5 from [Link] import RandomForestClassifier

32.3 Loading and Caching the Dataset

We define a function to load the Iris dataset and convert it into a pandas DataFrame.
Using the @st.cache_data decorator ensures that the dataset is cached and not reloaded
every time the app runs.

116
Python Fundamentals: Basics to Advanced 117

1 @st.cache_data
2 def load_data():
3 iris = load_iris()
4 df = [Link]([Link], columns=iris.feature_names)
5 df['species'] = [Link]
6 return df, iris.target_names
7

8 df, target_names = load_data()

32.4 Training the Random Forest Model

1 model = RandomForestClassifier()
2 X = [Link][:, :-1] # Independent features
3 y = df['species'] # Dependent feature
4 [Link](X, y)

32.5 Creating Interactive Sliders for Input

We use Streamlit sliders to allow users to input sepal length, sepal width, petal length,
and petal width interactively:

1 sepal_length = [Link]("Sepal Length", float([Link][:,0].min()), float(

[Link][:,0].max()))
2 sepal_width = [Link]("Sepal Width", float([Link][:,1].min()), float(df.
iloc[:,1].max()))
3 petal_length = [Link]("Petal Length", float([Link][:,2].min()), float(
[Link][:,2].max()))
4 petal_width = [Link]("Petal Width", float([Link][:,3].min()), float(df.
iloc[:,3].max()))

32.6 Making Predictions

The app collects the slider inputs into a list and predicts the Iris species using the trained
model:

1 input_data = [[sepal_length, sepal_width, petal_length, petal_width]]

2 prediction = [Link](input_data)
3 predicted_species = target_names[prediction[0]]
4 [Link](f"Predicted Iris Species: {predicted_species}")
Python Fundamentals: Basics to Advanced 118

32.7 Running the App

Run the Streamlit app using:

1 streamlit run [Link]

The app opens in the browser, displaying sliders for feature input and the predicted
Iris species in real-time.

32.8 Conclusion
This example demonstrates the power of Streamlit for creating interactive machine learn-
ing applications:

• Users can interactively adjust input features using sliders.

• Predictions from the machine learning model are updated instantly.

• Minimal code is required for front-end display; no HTML or CSS is necessary.

• Streamlit caching ensures efficient loading of datasets.

In the next chapter, we will explore more advanced interactive components and inte-
grate additional visualizations into a machine learning web app.