Python

Fundamentals

Author: Dr. Chetan Gondaliya

Index of Chapters

1. Introduction to Python Programming

1.1. History of Python
1.2. Features of Python
1.3. Installing Python and IDEs
1.4. Writing and Executing Python Scripts
1.5. First Python Program
1.6. Exercises: Writing basic Python scripts
2. Python Variables and Data Types
2.1. Variables and Naming Conventions
2.2. Basic Data Types (int, float, str, bool)
2.3. Type Casting and Conversion
2.4. Python Input and Output
2.5. Practical: Creating a program with different data types
3. Operators and Expressions
3.1. Arithmetic, Assignment, Comparison, Logical, Bitwise Operators
3.2. Operator Precedence and Associativity
3.3. Working with Expressions
3.4. Exercise: Solving mathematical problems with Python
4. Control Flow: Decision Making
4.1. If, If-Else, Nested If statements
4.2. Conditional Expressions
4.3. Case Study: Decision-making in real-world applications
4.4. Practical: Implementing conditions for a simple game
5. Control Flow: Loops
5.1. For Loop, While Loop
5.2. Break, Continue, and Pass Statements
5.3. Nested Loops
5.4. Exercise: Generating patterns using loops
6. Functions in Python
6.1. Defining and Calling Functions
6.2. Arguments and Return Values
6.3. Recursion
6.4. Lambda Functions
6.5. Long Questions: Recursion and its applications in Python
7. Data Structures: Lists
7.1. Creating and Accessing Lists
7.2. List Methods and Operations
7.3. List Comprehension
7.4. Practical: Sorting and filtering data using lists
8. Data Structures: Tuples and Sets
8.1. Creating and Accessing Tuples
8.2. Tuples vs Lists
8.3. Working with Sets
 8.4. Exercises: Storing unique items in a set
9. Data Structures: Dictionaries
9.1. Key-Value Pairs
9.2. Accessing, Adding, and Removing Items
9.3. Dictionary Methods
9.4. Case Study: Dictionary-based data storage
10. File Handling in Python
10.1. Reading and Writing Files
10.2. Working with File Modes
10.3. Handling File Exceptions
10.4. Practical: Creating a text file logger
11. Exception Handling
11.1. Try, Except, Finally Blocks
11.2. Raising Exceptions
11.3. Custom Exceptions
11.4. Exercises: Error detection in user input
12. Modules and Packages
12.1. Importing Modules
12.2. Creating Custom Modules
12.3. Installing and Using External Packages
12.4. Practical: Working with Python libraries like math and random
13. Object-Oriented Programming: Classes and Objects
13.1. Defining Classes and Objects
13.2. Constructors and Destructors
13.3. Self and Instance Variables
13.4. Long Questions: Object-oriented design in Python
14. OOP: Inheritance, Polymorphism, and Encapsulation
14.1. Types of Inheritance
14.2. Overloading and Overriding Methods
14.3. Encapsulation and Access Modifiers
14.4. Practical: Designing an OOP-based system
15. Regular Expressions
15.1. Introduction to Regex
15.2. Matching Patterns
15.3. Searching and Replacing Patterns
15.4. Exercises: Validating input using regex
16. Working with Libraries: NumPy and Pandas
16.1. Basics of NumPy Arrays
16.2. Introduction to Pandas DataFrames
16.3. Data Analysis with Pandas
16.4. Practical: Analyzing datasets using Pandas
17. Working with Databases
17.1. Connecting Python with Databases (SQLite, MySQL)
17.2. CRUD Operations
17.3. Database Handling with sqlite3
17.4. Case Study: Creating a Python-based inventory management system
18. Web Scraping and APIs
18.1. Introduction to Web Scraping with BeautifulSoup
18.2. Making API Requests with Python (e.g., requests library)
18.3. Practical: Extracting data from a website using Python
19. GUI Programming with Tkinter
19.1. Introduction to Tkinter
19.2. Creating Basic GUI Applications
19.3. Adding Widgets, Buttons, and Event Handling
19.4. Exercises: Building a simple GUI calculator
20. Python for Data Visualization
20.1. Introduction to Matplotlib
20.2. Plotting Graphs, Charts, and Histograms
20.3. Customizing Graphs
20.4. Practical: Visualizing data with Python

Each chapter can include:

 Examples: Code snippets demonstrating concepts

 Exercises: Practical tasks for hands-on practice
 Long Questions: Conceptual and coding challenges
Chapter 1: Introduction to Python Programming

1.1. History of Python

 Origin and Development: Python was created by Guido van Rossum in the late 1980s and
released in 1991. It was developed as a successor to the ABC programming language.
 Evolution Over Time: Key versions of Python:
o Python 2.0 (2000): Introduced features like list comprehensions and garbage collection.
o Python 3.0 (2008): Major overhaul with significant improvements in syntax and libraries.
 Present Day: Python is one of the most popular programming languages, known for its
versatility and readability.

1.2. Features of Python

 Simple and Easy to Learn: Python’s syntax is straightforward, making it accessible for beginners.
 Interpreted Language: Python code is executed line-by-line, which helps in quick testing and
debugging.
 Cross-Platform: Python works on various operating systems (Windows, macOS, Linux, etc.).
 Extensive Libraries: Python has a vast ecosystem of libraries (e.g., NumPy, Pandas, Matplotlib)
that support data science, web development, automation, etc.
 Open Source: Python is free and open-source, meaning anyone can contribute to its
development.
 Dynamic Typing: Variables in Python don’t need explicit declaration of type; it is determined at
runtime.
 High-Level Language: Python abstracts many details of the computer’s hardware from the user.
 Support for Object-Oriented, Procedural, and Functional Programming: Python is flexible in
programming paradigms.

1.3. Installing Python and IDEs

 Installing Python:
o Steps to download Python from the official website:
https://www.python.org/downloads
o Installing Python on different platforms (Windows, macOS, Linux).
 Installing IDEs:
o Recommended IDEs for Python:
 IDLE: The default IDE that comes with Python installation.
 PyCharm: One of the most popular IDEs for Python, known for its powerful
features.
 VS Code: A lightweight editor with Python extensions.
 Jupyter Notebooks: Widely used in data science and research for interactive
coding.
1.4. Writing and Executing Python Scripts

 Creating a Python Script: Writing Python code in a .py file.

 Executing Python Script:
o Running scripts from the command line using python script_name.py.
o Executing scripts directly from IDEs like PyCharm or VS Code.
 Python Interpreter: The interactive mode to test small code snippets.

1.5. First Python Program

 Example: Writing the classic "Hello, World!" program:

python
Copy code
print("Hello, World!")

 Explanation of the Code:

o print() function: The most basic function to output data in Python.
o Quotes: Python allows both single (' ') and double (" ") quotes for string literals.
o Whitespace sensitivity: Indentation is crucial in Python; the language enforces
indentation for blocks of code.

1.6. Exercises: Writing Basic Python Scripts

 Exercise 1: Write a Python script to print your name and age.

python
Copy code
print("Name: John Doe")
print("Age: 25")

 Exercise 2: Write a Python script to perform basic arithmetic operations (addition, subtraction,
multiplication, division).

python
Copy code
a = 10
b = 5
print("Addition:", a + b)
print("Subtraction:", a - b)
print("Multiplication:", a * b)
print("Division:", a / b)

 Exercise 3: Write a Python script to calculate the area of a circle, given the radius.

radius = 7
area = 3.14 * radius ** 2
print("Area of the circle:", area
Chapter 2: Python Variables and Data Types

2.1. Variables and Naming Conventions

 What are Variables?

o Variables are used to store data in memory that can be referenced and manipulated
later in the program.
o Python does not require explicit declaration of the variable type; it infers the type
automatically when you assign a value.

 Syntax for Variable Assignment:

python
Copy code
variable_name = value

 Example:

python
Copy code
x = 10
name = "Alice"

 Naming Conventions:
o Variables should start with a letter (a-z, A-Z) or an underscore (_) and can contain
alphanumeric characters and underscores.
o Variable names are case-sensitive (myVar and myvar are different).
o Use descriptive names: age, total_price rather than a, tp.
o Avoid using reserved keywords like if, for, while, etc.

 Best Practices:
o Use lowercase letters for variable names (e.g., student_name).
o Separate words using underscores (snake_case).
o Use meaningful variable names that describe the content or purpose.

2.2. Basic Data Types (int, float, str, bool)

 int (Integer):
o Used for whole numbers (positive or negative).
o Example:

python
Copy code
age = 25

 float (Floating Point Numbers):

 o Used for decimal numbers.
o Example:

python
Copy code
temperature = 36.6

 str (String):
o A sequence of characters enclosed in quotes (single, double, or triple).
o Example:

python
Copy code
name = "John Doe"

 bool (Boolean):
o Represents one of two values: True or False.
o Example:

python
Copy code
is_active = True
2.3. Type Casting and Conversion

 Implicit Type Conversion:

o Python automatically converts one data type to another when needed.
o Example:

python
Copy code
x = 5
y = 2.0
result = x + y # result will be a float (7.0)

 Explicit Type Conversion (Type Casting):

o int(): Converts a value to an integer.
o float(): Converts a value to a float.
o str(): Converts a value to a string.
o bool(): Converts a value to a boolean.
o Example:

python
Copy code
x = "5"
y = int(x) # y will be 5 (as integer)
z = float(x) # z will be 5.0 (as float)
2.4. Python Input and Output

 Output using print():

 o print() is used to display information to the console.
o Example:

python
Copy code
print("Hello, World!")

 Formatted Strings (f-strings):

o F-strings allow variables to be embedded directly in the string.
o Example:

python
Copy code
name = "Alice"
age = 25
print(f"My name is {name} and I am {age} years old.")

 Input using input():

o input() is used to take input from the user. The input is always treated as a string.
o Example:

python
Copy code
name = input("Enter your name: ")
print(f"Hello, {name}!")

 Converting Input to Other Types:

o Since input() always returns a string, you need to cast it to other types (if needed).
o Example:

python
Copy code
age = int(input("Enter your age: "))
print(f"You are {age} years old.")
2.5. Practical: Creating a Program with Different Data Types

 Problem Statement: Write a Python program that asks the user for their name, age,
height, and whether they are a student, and then prints out the information in a formatted
way.
 Sample Code:

python
Copy code
# Taking user input for different data types
name = input("Enter your name: ") # str
age = int(input("Enter your age: ")) # int
height = float(input("Enter your height in meters: ")) # float
is_student = input("Are you a student (yes/no)? ") # str

# Convert 'yes' or 'no' to a boolean value

if is_student.lower() == "yes":
 is_student = True
else:
is_student = False

# Output the gathered information

print(f"\nSummary:")
print(f"Name: {name}")
print(f"Age: {age}")
print(f"Height: {height} meters")
print(f"Student Status: {is_student}")

 Expected Output:

yaml
Copy code
Enter your name: Alice
Enter your age: 25
Enter your height in meters: 1.65
Are you a student (yes/no)? yes

Summary:
Name: Alice
Age: 25
Height: 1.65 meters
Student Status: True
Chapter 3: Operators and Expressions

3.1. Arithmetic, Assignment, Comparison, Logical, Bitwise Operators

Operators are special symbols in Python that perform operations on variables and values. They
are divided into various categories based on their functionality.

3.1.1 Arithmetic Operators

Arithmetic operators perform basic mathematical operations.

Operator Description Example

+ Addition x + y

- Subtraction x - y

* Multiplication x * y

/ Division x / y

% Modulus (remainder) x % y

** Exponentiation x ** y

// Floor Division x // y

 Example:

python
Copy code
a = 10
b = 3
print(a + b) # Output: 13
print(a - b) # Output: 7
print(a * b) # Output: 30
print(a / b) # Output: 3.3333
print(a % b) # Output: 1
print(a ** b) # Output: 1000
print(a // b) # Output: 3
3.1.2 Assignment Operators

Assignment operators are used to assign values to variables.

Operator Description Example

= Assigns value x = 5
Operator Description Example

+= Adds and assigns x += 3

-= Subtracts and assigns x -= 2

*= Multiplies and assigns x *= 4

/= Divides and assigns x /= 5

%= Modulus and assigns x %= 6

//= Floor division and assigns x //= 7

**= Exponentiation and assigns x **= 2

 Example:

python
Copy code
x = 10
x += 5 # Same as x = x + 5
print(x) # Output: 15
3.1.3 Comparison Operators

Comparison operators are used to compare two values, and they return True or False.

Operator Description Example

== Equal to x == y

!= Not equal to x != y

> Greater than x > y

< Less than x < y

>= Greater than or equal to x >= y

<= Less than or equal to x <= y

 Example:

python
Copy code
x = 10
y = 5
print(x == y) # Output: False
print(x > y) # Output: True
3.1.4 Logical Operators

Logical operators are used to combine conditional statements.

Operator Description Example

and True if both conditions are true x and y

or True if at least one condition is true x or y

not Inverts the result not x

 Example:

python
Copy code
x = True
y = False
print(x and y) # Output: False
print(x or y) # Output: True
print(not x) # Output: False
3.1.5 Bitwise Operators

Bitwise operators work on bits and perform bit-by-bit operations.

Operator Description Example

& AND x & y

` ` OR

^ XOR x ^ y

~ NOT ~x

<< Left Shift x << 2

>> Right Shift x >> 2

 Example:

python
Copy code
a = 5 # 101 in binary
b = 3 # 011 in binary
print(a & b) # Output: 1 (001 in binary)
print(a | b) # Output: 7 (111 in binary)
3.2. Operator Precedence and Associativity

 Operator Precedence: Determines the order in which operators are evaluated in an

expression. Python follows standard mathematical rules:
o Precedence from high to low:
1. Parentheses ()
2. Exponentiation **
3. Multiplication, Division, Modulus *, /, //, %
4. Addition, Subtraction +, -
5. Comparison operators (<, <=, >, >=, ==, !=)
6. Logical operators (not, and, or)

 Associativity: Defines the direction in which an expression is evaluated when operators

of the same precedence are used. Most operators are left-associative, except
exponentiation (**), which is right-associative.
o Example of Left-Associativity:

python
Copy code
print(5 - 3 + 2) # Output: 4 (evaluated as (5 - 3) + 2)

o Example of Right-Associativity:

python
Copy code
print(2 ** 3 ** 2) # Output: 512 (evaluated as 2 ** (3 ** 2))
3.3. Working with Expressions

Expressions are combinations of values, variables, and operators that are evaluated to produce a
result. Python evaluates expressions following the rules of operator precedence and associativity.

 Example of a Complex Expression:

python
Copy code
result = (5 + 2) * 3 / 2 ** 2
print(result) # Output: 5.25
3.4. Exercise: Solving Mathematical Problems with Python

In this section, you will apply operators and expressions to solve real-world problems. Below are
some exercises:

Exercise 1: Basic Arithmetic Calculator

Write a Python program that takes two numbers from the user and performs basic arithmetic
operations (addition, subtraction, multiplication, division).

python
Copy code
# Taking inputs from the user
num1 = float(input("Enter the first number: "))
num2 = float(input("Enter the second number: "))

# Performing arithmetic operations

print(f"Addition: {num1 + num2}")
print(f"Subtraction: {num1 - num2}")
print(f"Multiplication: {num1 * num2}")
print(f"Division: {num1 / num2}")
Exercise 2: Simple Interest Calculator

Write a Python program to calculate the simple interest using the formula:
Simple Interest = (Principal * Rate * Time) / 100

python
Copy code
# Taking inputs
principal = float(input("Enter the principal amount: "))
rate = float(input("Enter the rate of interest: "))
time = float(input("Enter the time (in years): "))

# Calculating simple interest

simple_interest = (principal * rate * time) / 100

# Displaying the result

print(f"Simple Interest: {simple_interest}")
Exercise 3: Find the Area of a Circle

Write a Python program to calculate the area of a circle using the formula:
Area = π * radius²

python
Copy code
import math

# Taking input from the user

radius = float(input("Enter the radius of the circle: "))

# Calculating the area

area = math.pi * radius ** 2

# Displaying the result

print(f"Area of the circle: {area}")
Chapter 4: Control Flow: Decision Making

In programming, the ability to make decisions based on certain conditions is crucial for
developing logical and efficient applications. Python provides powerful decision-making
constructs that allow you to control the flow of execution based on different conditions.

4.1. If, If-Else, Nested If Statements

Python provides several control structures to handle decision-making:

4.1.1 The if Statement

The if statement is used to execute a block of code only when a specified condition is True. It
allows a program to make decisions based on the values of variables.

 Syntax:

python
Copy code
if condition:
# Code to execute if the condition is True

 Description:
o The condition is an expression that evaluates to True or False.
o If the condition evaluates to True, the indented block of code under the if statement is
executed.
o If the condition evaluates to False, the block of code is skipped.

 Example:

python
Copy code
temperature = 30
if temperature > 25:
print("It's a hot day!")

In this example, the message "It's a hot day!" will be printed only if the temperature is
above 25.

4.1.2 The if-else Statement

The if-else statement allows you to define an alternative block of code that will be executed
when the condition is False. It ensures that some code is always executed regardless of whether
the condition is True or False.
  Syntax:

python
Copy code
if condition:
# Code to execute if the condition is True
else:
# Code to execute if the condition is False

 Description:
o The else block is optional but provides a fallback if the if condition is not satisfied.
o The code under the else block runs when the condition is False.

 Example:

python
Copy code
age = 16
if age >= 18:
print("You are eligible to vote.")
else:
print("You are not eligible to vote.")

In this case, if the age is less than 18, the message "You are not eligible to vote" will be
printed.

4.1.3 The elif Statement (Else-If)

The elif (short for else if) statement allows you to check multiple conditions in sequence. When
a condition is met, the corresponding block of code is executed, and the rest of the conditions are
skipped.

 Syntax:

python
Copy code
if condition1:
# Code if condition1 is True
elif condition2:
# Code if condition2 is True
else:
# Code if none of the conditions are True

 Description:
o elif is used when you need to test more than two conditions.
o Python evaluates each condition in sequence. If one condition is True, the
corresponding block of code is executed, and the remaining conditions are ignored.
o The else block is optional and runs if none of the conditions are True.

 Example:
 python
Copy code
score = 85
if score >= 90:
print("Grade: A")
elif score >= 75:
print("Grade: B")
elif score >= 60:
print("Grade: C")
else:
print("Grade: D")

Here, if the score is 85, the message "Grade: B" will be printed.

4.1.4 Nested if Statements

Sometimes, you may need to check multiple conditions inside another if block. This is called
nesting. Python allows you to place one if or else statement inside another to create more
complex decision structures.

 Syntax:

python
Copy code
if condition1:
if condition2:
# Code if both condition1 and condition2 are True
else:
# Code if condition1 is True but condition2 is False
else:
# Code if condition1 is False

 Description:
o Nested if statements are used when you want to check additional conditions inside an
existing condition.
o Be careful with indentation as it plays a crucial role in distinguishing nested blocks of
code.

 Example:

python
Copy code
age = 22
if age >= 18:
print("You are eligible to vote.")
if age >= 21:
print("You are also eligible to drink (in the US).")
else:
print("But you are not old enough to drink (in the US).")
else:
print("You are not eligible to vote.")
4.2. Conditional Expressions (Ternary Operator)

In some cases, you may want to write an if-else statement in a more compact form. Python
provides conditional expressions, also known as the ternary operator, for such cases.

 Syntax:

python
Copy code
result = true_value if condition else false_value

 Description:
o The ternary operator evaluates the condition. If the condition is True, the expression
returns the true_value; otherwise, it returns the false_value.
o This is a concise way to write an if-else statement in a single line.

 Example:

python
Copy code
age = 20
message = "Eligible to vote" if age >= 18 else "Not eligible to vote"
print(message)

Here, the value of message will be "Eligible to vote" if the age is 18 or more; otherwise,
it will be "Not eligible to vote".

4.3. Case Study: Decision-Making in Real-World Applications

4.3.1 Case Study: Online Shopping Cart

Imagine you're building an online shopping cart system for an e-commerce website. One of the
requirements is to determine whether a customer is eligible for free shipping based on the total
purchase amount.

 Scenario:
o Orders above $50 qualify for free shipping.
o If the order amount is below $50, a shipping fee of $5 is added.

 Solution:

python
Copy code
total_amount = float(input("Enter the total purchase amount: "))

if total_amount >= 50:

print("You are eligible for free shipping!")
else:
 print("Shipping fee applies: $5.")

 Description:
o This program uses the if-else statement to check whether the purchase amount
qualifies for free shipping or not.

4.3.2 Case Study: ATM Withdrawal System

Consider the scenario where you are developing an ATM system. The system needs to check
whether the user has enough balance and if the requested withdrawal amount is a multiple of
100.

 Scenario:
o The user can only withdraw multiples of 100.
o The ATM will check if the balance is sufficient before allowing the withdrawal.

 Solution:

python
Copy code
balance = 1000
withdraw_amount = int(input("Enter the amount to withdraw: "))

if withdraw_amount % 100 == 0:
if withdraw_amount <= balance:
balance -= withdraw_amount
print(f"Withdrawal successful! Your new balance is {balance}.")
else:
print("Insufficient balance.")
else:
print("Please enter an amount in multiples of 100.")

 Description:
o This program uses a nested if statement to ensure the withdrawal amount is valid and
the balance is sufficient.

4.4. Practical: Implementing Conditions for a Simple Game

Game: Number Guessing Game

In this exercise, you will build a simple number guessing game. The computer will generate a
random number between 1 and 10, and the user has to guess the number. The game provides
feedback on whether the guess is too high, too low, or correct.

 Steps:
1. The program generates a random number between 1 and 10.
2. The user inputs their guess.
3. The program checks if the guess matches the generated number.
4. The game continues until the user guesses correctly.
  Code:

python
Copy code
import random

# Generate a random number between 1 and 10

secret_number = random.randint(1, 10)
attempts = 0

while True:
guess = int(input("Guess the number between 1 and 10: "))
attempts += 1

if guess < secret_number:

print("Too low! Try again.")
elif guess > secret_number:
print("Too high! Try again.")
else:
print(f"Congratulations! You've guessed the number in {attempts}
attempts.")
break

 Description:

o This game uses the if-elif-else structure to provide feedback to the player.
o It tracks the number of attempts and congratulates the player upon guessing the correct
number.

Additional Challenge: Limiting the Number of Attempts

Enhance the game by limiting the number of attempts to 5. If the player doesn't guess the number
within 5 attempts, the game should end, and the correct number should be revealed.

 Code:

python
Copy code
import random

secret_number = random.randint(1, 10)

attempts = 0
max_attempts = 5

while attempts < max_attempts:

guess = int(input("Guess the number between 1 and 10: "))
attempts += 1

if guess < secret_number:

print("Too low! Try again.")
elif guess > secret_number:
print("Too high! Try again.")
else:
 print(f"Congratulations! You've guessed the number in {attempts}
attempts.")
break
else:
print(f"Sorry, you've used all {max_attempts} attempts. The correct
number was {secret_number}.")
Chapter 5: Control Flow: Loops

Loops are one of the most powerful control structures in Python. They allow you to execute a
block of code repeatedly, based on a condition or a sequence of elements. This chapter covers the
basics of loops, different loop control mechanisms, and practical exercises to master looping in
Python.

5.1. For Loop, While Loop

Loops in Python can be broadly classified into two types: the for loop and the while loop. Each
has its own unique use cases and syntax.

5.1.1 The for Loop

The for loop is used to iterate over a sequence (such as a list, tuple, string, or range) and execute
a block of code for each element in the sequence.

 Syntax:

python
Copy code
for variable in sequence:
# Code to execute for each element in the sequence

 Description:
o The for loop takes each element from the sequence (e.g., a list) and assigns it to a
variable.
o The indented block of code under the for loop is executed once for each element in the
sequence.

 Example:

python
Copy code
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
print(fruit)

Output:

Copy code
apple
banana
cherry
5.1.2 The while Loop

The while loop allows you to execute a block of code repeatedly as long as a given condition is
True. This is useful when the number of iterations is not predetermined.

 Syntax:

python
Copy code
while condition:
# Code to execute as long as the condition is True

 Description:
o The while loop continuously checks the condition. If the condition is True, the code
inside the loop is executed.
o The loop will continue to execute until the condition becomes False.
o Make sure that the condition will eventually become False; otherwise, the loop will
run indefinitely (infinite loop).

 Example:

python
Copy code
count = 1
while count <= 5:
print(count)
count += 1

Output:

Copy code
1
2
3
4
5

5.2. Break, Continue, and Pass Statements

Python provides additional control over loop execution using the break, continue, and pass
statements. These statements allow you to control how the loop behaves under specific
conditions.

5.2.1 The break Statement

The break statement is used to exit a loop prematurely. When the break statement is
encountered, the loop is immediately terminated, and the control moves to the next statement
after the loop.
  Syntax:

python
Copy code
for/while loop:
if condition:
break

 Example:

python
Copy code
for i in range(1, 11):
if i == 5:
break
print(i)

Output:

Copy code
1
2
3
4

In this example, the loop stops when i equals 5, and the loop exits.

5.2.2 The continue Statement

The continue statement is used to skip the current iteration of the loop and move on to the next
iteration. When continue is encountered, the rest of the code in the loop is ignored for that
iteration, and the next iteration begins.

 Syntax:

python
Copy code
for/while loop:
if condition:
continue

 Example:

python
Copy code
for i in range(1, 11):
if i == 5:
continue
print(i)

Output:
 Copy code
1
2
3
4
6
7
8
9
10

In this example, when i equals 5, the continue statement is triggered, skipping the
printing of 5 and moving directly to the next iteration.

5.2.3 The pass Statement

The pass statement is a placeholder. It does nothing and is used when a statement is
syntactically required but you don't want to execute any code. This is useful when you're
working with loops or functions that you plan to implement later.

 Syntax:

python
Copy code
for/while loop:
pass

 Example:

python
Copy code
for i in range(1, 6):
if i == 3:
pass # Do nothing for i == 3
else:
print(i)

Output:

Copy code
1
2
4
5

In this example, the pass statement does nothing when i equals 3, but the loop continues
with other values.
5.3. Nested Loops

In Python, you can place one loop inside another, known as nested loops. Each iteration of the
outer loop triggers the execution of the inner loop.

5.3.1 Syntax of Nested Loops

 Syntax:

python
Copy code
for outer_variable in outer_sequence:
for inner_variable in inner_sequence:
# Code to execute in the inner loop

 Description:
o Nested loops are often used when working with multi-dimensional data structures such
as matrices or tables.
o For each iteration of the outer loop, the inner loop runs through its entire sequence.

5.3.2 Example of Nested Loops

Here’s a simple example of a nested loop that prints out a pattern:

 Example:

python
Copy code
for i in range(1, 4):
for j in range(1, 4):
print(f"({i}, {j})", end=" ")
print() # Moves to the next line after the inner loop

Output:

scss
Copy code
(1, 1) (1, 2) (1, 3)
(2, 1) (2, 2) (2, 3)
(3, 1) (3, 2) (3, 3)

In this example, the outer loop controls the rows, while the inner loop controls the
columns.

5.3.3 Use Case of Nested Loops: Multiplication Table

Nested loops can also be used to generate a multiplication table:

 Example:
 python
Copy code
for i in range(1, 6):
for j in range(1, 6):
print(f"{i * j}", end="\t")
print()

Output:

Copy code
12 3 4 5
24 6 8 10
36 9 12 15
48 12 16 20
5 10 15 20 25

In this example, the outer loop iterates through the rows, and the inner loop prints the
product for each column.

5.4. Exercise: Generating Patterns Using Loops

One of the most common exercises for mastering loops is to generate patterns. Below are
examples and exercises to help you understand how loops can be used to create various patterns.

5.4.1 Example 1: Right-Angled Triangle Pattern

Generate a right-angled triangle pattern using a for loop.

 Problem: Print the following pattern:

markdown
Copy code
*
**
***
****
*****

 Solution:

python
Copy code
for i in range(1, 6):
print("*" * i)

o The outer loop controls the number of rows, and the * character is repeated based on
the value of i.
5.4.2 Example 2: Inverted Triangle Pattern

Generate an inverted triangle pattern.

 Problem: Print the following pattern:

markdown
Copy code
*****
****
***
**
*

 Solution:

python
Copy code
for i in range(5, 0, -1):
print("*" * i)

o This loop starts with 5 stars and decreases by 1 on each iteration.

5.4.3 Example 3: Number Pyramid Pattern

Generate a number pyramid pattern.

 Problem: Print the following pattern:

markdown
Copy code
1
2 2
3 3 3
4 4 4 4
5 5 5 5 5

 Solution:

python
Copy code
rows = 5
for i in range(1, rows + 1):
print(" " * (rows - i) + (str(i) + " ") * i)

o This loop adjusts the number of spaces to align the numbers in a pyramid shape.
Chapter 6: Functions in Python

Functions are essential building blocks in Python programming. They allow you to organize your
code into reusable pieces, reducing redundancy and improving readability. This chapter explores
how to define, call, and work with functions in Python, along with a look at recursion and
lambda functions.

6.1. Defining and Calling Functions

Functions are defined in Python using the def keyword, followed by a name and parentheses ().
A function can accept inputs (called arguments or parameters) and return a result using the
return statement.

6.1.1 Defining Functions

 Syntax:

python
Copy code
def function_name(parameters):
# Code block (function body)
return value

 Description:
o The def keyword is used to define a function.
o function_name is the name of the function.
o parameters (optional) are inputs passed into the function.
o The indented code block is the body of the function, which contains the statements that
will be executed when the function is called.
o A function may return a value using the return statement. If no return is provided,
the function will return None by default.

 Example:

python
Copy code
def greet(name):
return f"Hello, {name}!"

print(greet("Alice")) # Output: Hello, Alice!

6.1.2 Calling Functions

 Calling a Function:
 o To use a function, you "call" it by using its name followed by parentheses. If the function
takes arguments, pass the arguments inside the parentheses.

 Example:

python
Copy code
def add_numbers(a, b):
return a + b

result = add_numbers(10, 5)
print(result) # Output: 15

6.2. Arguments and Return Values

Functions in Python can accept inputs, known as arguments, and return outputs.

6.2.1 Positional Arguments

 Description:
o Positional arguments are passed to the function in the order in which they are defined.

 Example:

python
Copy code
def multiply(a, b):
return a * b

print(multiply(2, 5)) # Output: 10

6.2.2 Keyword Arguments

 Description:
o Keyword arguments are passed to a function by explicitly stating the parameter name.
They allow you to pass arguments in any order.

 Example:

python
Copy code
def introduce(name, age):
print(f"My name is {name}, and I am {age} years old.")

introduce(age=25, name="Bob") # Output: My name is Bob, and I am 25

years old.
6.2.3 Default Arguments

 Description:
 o Default arguments provide a default value for a parameter if no argument is passed
during the function call.

 Example:

python
Copy code
def greet(name, message="Welcome!"):
return f"Hello, {name}! {message}"

print(greet("Alice")) # Output: Hello, Alice! Welcome!

print(greet("Alice", "Goodbye")) # Output: Hello, Alice! Goodbye
6.2.4 Arbitrary Arguments (*args and **kwargs)

 Description:
o *args allows a function to accept a variable number of positional arguments.
o **kwargs allows a function to accept a variable number of keyword arguments.

 Example (*args):

python
Copy code
def add_numbers(*args):
return sum(args)

print(add_numbers(1, 2, 3, 4)) # Output: 10

 Example (**kwargs):

python
Copy code
def print_info(**kwargs):
for key, value in kwargs.items():
print(f"{key}: {value}")

print_info(name="Alice", age=25, city="Paris")

6.2.5 Return Values

 Description:
o Functions can return values using the return statement. The returned value can be
stored in a variable or used directly.
o A function can return multiple values as a tuple.

 Example:

python
Copy code
def get_square_and_cube(n):
return n**2, n**3

square, cube = get_square_and_cube(3)

 print(square, cube) # Output: 9 27

6.3. Recursion

Recursion is a technique where a function calls itself in order to solve a problem. Each recursive
call should bring the problem closer to a base case, which stops the recursion.

6.3.1 What is Recursion?

 Description:
o A recursive function is one that calls itself. It is typically used to solve problems that can
be broken down into smaller, similar sub-problems.
o A recursive function must have a base case to prevent it from calling itself indefinitely.

 Example: Calculating the factorial of a number using recursion.

python
Copy code
def factorial(n):
if n == 0: # Base case
return 1
else:
return n * factorial(n - 1)

print(factorial(5)) # Output: 120

6.3.2 Base Case and Recursive Case

 Base Case: The condition that stops the recursive calls. Without it, the function will call itself
indefinitely, leading to a stack overflow.
 Recursive Case: The part of the function that reduces the problem into a smaller instance and
calls the function again.

6.3.3 Advantages and Disadvantages of Recursion

 Advantages:
o Recursion can make the code more readable and elegant, especially when dealing with
problems like tree traversal, sorting algorithms (e.g., quicksort, mergesort), and the
Fibonacci sequence.
 Disadvantages:
o Recursive solutions can be less efficient due to repeated function calls.
o They may lead to stack overflow if not properly managed.

6.3.4 Example: Fibonacci Sequence Using Recursion

 Problem: Write a recursive function to calculate the nth Fibonacci number.

python
Copy code
 def fibonacci(n):
if n <= 1:
return n
else:
return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(6)) # Output: 8

6.4. Lambda Functions

Lambda functions are small, anonymous functions that can be defined in a single line. They are
often used when you need a short function for a short period of time.

6.4.1 What is a Lambda Function?

 Syntax:

python
Copy code
lambda arguments: expression

 Description:
o Lambda functions can take any number of arguments but can only have one expression.
o They are often used in conjunction with functions like map(), filter(), and
sorted().

 Example:

python
Copy code
# Lambda function to add two numbers
add = lambda x, y: x + y
print(add(5, 3)) # Output: 8
6.4.2 Use Cases for Lambda Functions

 Example: Using a lambda function with sorted() to sort a list of tuples by the second element.

python
Copy code
points = [(1, 2), (4, 1), (2, 3)]
sorted_points = sorted(points, key=lambda point: point[1])
print(sorted_points) # Output: [(4, 1), (1, 2), (2, 3)]
6.4.3 Lambda Functions with map(), filter(), and reduce()

 Example: Using map() to apply a lambda function to a list.

python
Copy code
numbers = [1, 2, 3, 4]
squares = list(map(lambda x: x ** 2, numbers))
 print(squares) # Output: [1, 4, 9, 16]

6.5. Long Questions: Recursion and its Applications in Python

1. Explain the concept of recursion and describe its working mechanism in Python
with an example.
o Define recursion and explain the base case and recursive case.
o Provide an example such as the factorial function or Fibonacci sequence.

2. Discuss the advantages and disadvantages of using recursion in Python.

o Mention the ease of problem-solving with recursion, such as tree traversal or divide-
and-conquer algorithms.
o Explain the drawbacks, including performance overhead and risk of stack overflow.

3. Describe real-world problems where recursion can be applied efficiently.

o Examples:
 Tower of Hanoi
 Binary Search
 Tree and Graph traversal (Depth-First Search)

4. Write a Python program to implement the Tower of Hanoi problem using recursion.
o Problem: Given three rods and a number of disks, move all the disks from one rod to
another following specific rules.
Chapter 7: Data Structures: Lists

Lists are one of the most versatile and commonly used data structures in Python. They allow you
to store and manipulate collections of data in an ordered manner. This chapter will introduce you
to lists, how to create and access them, and how to perform operations using various list
methods. Additionally, we will explore list comprehensions and a practical exercise on sorting
and filtering data.

7.1. Creating and Accessing Lists

7.1.1 What is a List?

A list is a mutable, ordered collection of items in Python. Lists can store elements of different
data types such as integers, strings, floats, or even other lists. Lists are defined by placing
elements inside square brackets [], separated by commas.

 Example:

python
Copy code
my_list = [1, 2, 3, "apple", 4.5, [5, 6, 7]]
7.1.2 Creating Lists

 Empty List: You can create an empty list and add elements later.

python
Copy code
empty_list = []

 List with Elements:

python
Copy code
fruits = ["apple", "banana", "cherry"]
numbers = [1, 2, 3, 4, 5]
7.1.3 Accessing Elements in a List

Lists are indexed starting from 0, meaning the first element is at index 0, the second element is
at index 1, and so on.

 Accessing a Single Element:

python
Copy code
fruits = ["apple", "banana", "cherry"]
 print(fruits[0]) # Output: apple
print(fruits[2]) # Output: cherry

 Negative Indexing: You can access elements from the end of the list using negative
indexing, where -1 refers to the last element.

python
Copy code
print(fruits[-1]) # Output: cherry

 Slicing: You can retrieve a portion of the list using the slicing syntax list[start:end],
which returns a new list from the start index up to, but not including, the end index.

python
Copy code
print(fruits[0:2]) # Output: ['apple', 'banana']
7.1.4 Modifying Lists

Lists are mutable, meaning you can modify them after creation by changing individual elements,
adding new elements, or removing them.

 Changing an Element:

python
Copy code
fruits[1] = "blueberry"
print(fruits) # Output: ['apple', 'blueberry', 'cherry']

7.2. List Methods and Operations

Python provides a rich set of built-in methods to manipulate and modify lists. Let's explore some
common list methods.

7.2.1 Adding Elements to a List

 append(): Adds a single element to the end of the list.

python
Copy code
fruits = ["apple", "banana"]
fruits.append("cherry")
print(fruits) # Output: ['apple', 'banana', 'cherry']

 insert(): Inserts an element at a specific index.

python
Copy code
fruits.insert(1, "orange")
print(fruits) # Output: ['apple', 'orange', 'banana']
  extend(): Adds multiple elements (or another list) to the end of the list.

python
Copy code
fruits.extend(["kiwi", "grape"])
print(fruits) # Output: ['apple', 'banana', 'kiwi', 'grape']
7.2.2 Removing Elements from a List

 remove(): Removes the first occurrence of a specified element.

python
Copy code
fruits.remove("banana")
print(fruits) # Output: ['apple', 'cherry']

 pop(): Removes and returns the element at a given index (default is the last element).

python
Copy code
fruits.pop() # Removes 'cherry'
print(fruits) # Output: ['apple']

 clear(): Removes all elements from the list.

python
Copy code
fruits.clear()
print(fruits) # Output: []
7.2.3 Other Useful List Methods

 index(): Returns the index of the first occurrence of a specified element.

python
Copy code
fruits = ["apple", "banana", "cherry"]
print(fruits.index("banana")) # Output: 1

 count(): Returns the number of times a specified element appears in the list.

python
Copy code
numbers = [1, 2, 2, 3, 4, 2]
print(numbers.count(2)) # Output: 3

 sort(): Sorts the list in ascending order.

python
Copy code
numbers = [3, 1, 4, 2]
numbers.sort()
print(numbers) # Output: [1, 2, 3, 4]
  reverse(): Reverses the order of the elements in the list.

python
Copy code
numbers.reverse()
print(numbers) # Output: [4, 3, 2, 1]

7.3. List Comprehension

List comprehension provides a concise way to create lists by generating them based on existing
lists or other sequences. It allows you to combine loops and conditional statements into a single
line.

7.3.1 Basic List Comprehension

 Syntax:

python
Copy code
new_list = [expression for item in iterable]

 Example: Generate a list of squares of numbers from 1 to 5.

python
Copy code
squares = [x ** 2 for x in range(1, 6)]
print(squares) # Output: [1, 4, 9, 16, 25]
7.3.2 List Comprehension with Conditionals

You can add an if condition to filter elements during list comprehension.

 Example: Create a list of even numbers from 1 to 10.

python
Copy code
even_numbers = [x for x in range(1, 11) if x % 2 == 0]
print(even_numbers) # Output: [2, 4, 6, 8, 10]
7.3.3 Nested List Comprehension

List comprehension can also be used for nested loops. This is useful for working with multi-
dimensional lists (lists of lists).

 Example: Generate a 3x3 matrix using nested list comprehension.

python
Copy code
matrix = [[row * col for col in range(1, 4)] for row in range(1, 4)]
print(matrix)
# Output: [[1, 2, 3], [2, 4, 6], [3, 6, 9]]
7.4. Practical: Sorting and Filtering Data Using Lists

Let's apply what we've learned by solving practical problems using lists.

7.4.1 Sorting a List of Tuples

Suppose we have a list of tuples where each tuple contains a student's name and score, and we
want to sort this list by score.

 Problem: Sort the list of students by their scores.

python
Copy code
students = [("Alice", 85), ("Bob", 92), ("Charlie", 78)]
sorted_students = sorted(students, key=lambda student: student[1])
print(sorted_students)
# Output: [('Charlie', 78), ('Alice', 85), ('Bob', 92)]
7.4.2 Filtering Data Using List Comprehension

Suppose you have a list of numbers and want to filter out the numbers that are greater than 10.

 Problem: Filter out numbers greater than 10 from the list.

python
Copy code
numbers = [4, 11, 9, 20, 15, 7]
filtered_numbers = [num for num in numbers if num > 10]
print(filtered_numbers) # Output: [11, 20, 15]
7.4.3 Removing Duplicates from a List

In some cases, you may want to remove duplicate elements from a list.

 Problem: Remove duplicates from a list of integers.

python
Copy code
numbers = [1, 2, 2, 3, 4, 4, 5]
unique_numbers = list(set(numbers))
print(unique_numbers) # Output: [1, 2, 3, 4, 5]
7.4.4 Combining List Operations

Now let’s create a more complex example where you have a list of students' scores, and you
want to:

1. Remove any scores below 50.

2. Sort the remaining scores in descending order.
Chapter 8: Data Structures: Tuples and Sets

In Python, tuples and sets are two important data structures that serve different purposes. While
tuples are immutable and ordered collections, sets are mutable, unordered collections of unique
elements. This chapter will help you understand when and how to use these structures
effectively.

8.1. Creating and Accessing Tuples

8.1.1 What is a Tuple?

A tuple is an immutable, ordered collection of elements. Once created, the elements of a tuple
cannot be changed. Tuples are often used to store related pieces of information that should not be
modified.

 Syntax: Tuples are created by placing elements inside parentheses (), separated by commas.

python
Copy code
my_tuple = (1, 2, 3, "apple", "banana")
8.1.2 Creating Tuples

 Empty Tuple:

python
Copy code
empty_tuple = ()

 Tuple with One Element: A comma is required after the element to indicate it’s a tuple.

python
Copy code
single_element_tuple = (5,)

 Tuple without Parentheses: You can create a tuple without using parentheses, known as
tuple packing.

python
Copy code
my_tuple = 1, 2, 3
8.1.3 Accessing Elements in a Tuple

Since tuples are ordered, elements can be accessed using indexing and slicing, just like lists.

 Accessing a Single Element:

 python
Copy code
my_tuple = (1, 2, 3, "apple")
print(my_tuple[0]) # Output: 1
print(my_tuple[3]) # Output: apple

 Negative Indexing: You can also access elements from the end of the tuple using
negative indices.

python
Copy code
print(my_tuple[-1]) # Output: apple

 Slicing: You can retrieve a portion of the tuple using slicing.

python
Copy code
print(my_tuple[1:3]) # Output: (2, 3)
8.1.4 Tuple Unpacking

Python allows you to "unpack" the elements of a tuple into individual variables.

 Example:

python
Copy code
my_tuple = ("Alice", 25, "Engineer")
name, age, profession = my_tuple
print(name) # Output: Alice
print(age) # Output: 25
print(profession) # Output: Engineer

8.2. Tuples vs Lists

Tuples and lists are both ordered collections in Python, but there are key differences between
them:

8.2.1 Immutability

 Tuples are immutable, meaning once a tuple is created, its elements cannot be changed, added,
or removed.
 Lists are mutable, allowing modifications such as adding, removing, or updating elements.

8.2.2 Use Cases

 Tuples are used when the order of items is important and the data should remain unchanged
throughout the program (e.g., coordinates, RGB color values, configurations).
 Lists are used when you need a collection of items that might change (e.g., shopping lists,
dynamic data collections).
8.2.3 Performance

 Tuples are generally faster than lists because they are immutable and have a smaller memory
footprint.
 Lists offer more flexibility but at the cost of additional memory usage and slower performance
compared to tuples.

8.2.4 Example Comparison:

 Tuple:

python
Copy code
my_tuple = (1, 2, 3)

 List:

python
Copy code
my_list = [1, 2, 3]

 Immutability Test:

python
Copy code
my_tuple[0] = 10 # This will raise an error because tuples are
immutable
my_list[0] = 10 # This will work because lists are mutable

8.3. Working with Sets

A set is an unordered, mutable collection of unique elements. Sets are used when you need to
store unique values and perform set operations like union, intersection, and difference.

8.3.1 Creating a Set

Sets are created using curly braces {} or the set() function. Duplicate values are automatically
removed.

 Syntax:

python
Copy code
my_set = {1, 2, 3, 3, 4} # Duplicate '3' will be removed
print(my_set) # Output: {1, 2, 3, 4}

 Using set():
 python
Copy code
my_set = set([1, 2, 2, 3])
print(my_set) # Output: {1, 2, 3}
8.3.2 Adding and Removing Elements in a Set

 add(): Adds a single element to the set.

python
Copy code
my_set.add(5)
print(my_set) # Output: {1, 2, 3, 4, 5}

 update(): Adds multiple elements to the set (can be another set, list, or tuple).

python
Copy code
my_set.update([6, 7])
print(my_set) # Output: {1, 2, 3, 4, 5, 6, 7}

 remove(): Removes a specific element from the set. If the element is not present, it raises
an error.

python
Copy code
my_set.remove(3)
print(my_set) # Output: {1, 2, 4, 5, 6, 7}

 discard(): Removes an element without raising an error if the element is not found.

python
Copy code
my_set.discard(10) # No error, even though 10 is not in the set
8.3.3 Set Operations

Sets support mathematical operations such as union, intersection, difference, and symmetric
difference.

 Union (|): Combines elements from both sets, removing duplicates.

python
Copy code
set1 = {1, 2, 3}
set2 = {3, 4, 5}
print(set1 | set2) # Output: {1, 2, 3, 4, 5}

 Intersection (&): Returns elements that are present in both sets.

python
Copy code
print(set1 & set2) # Output: {3}
  Difference (-): Returns elements that are in the first set but not in the second.

python
Copy code
print(set1 - set2) # Output: {1, 2}

 Symmetric Difference (^): Returns elements that are in either of the sets, but not in both.

python
Copy code
print(set1 ^ set2) # Output: {1, 2, 4, 5}
8.3.4 Checking Membership in a Set

You can use the in keyword to check if an element exists in a set.

 Example:

python
Copy code
print(3 in set1) # Output: True
print(6 in set1) # Output: False

8.4. Exercises: Storing Unique Items in a Set

Now that you understand how to work with sets, let’s apply these concepts in practical exercises.

8.4.1 Removing Duplicates from a List

 Problem: Given a list of numbers, remove all duplicates using a set.

python
Copy code
numbers = [1, 2, 3, 1, 2, 4, 5, 6, 4]
unique_numbers = list(set(numbers))
print(unique_numbers) # Output: [1, 2, 3, 4, 5, 6]
8.4.2 Finding Common Items in Two Sets

 Problem: Given two sets, find the common elements (intersection).

python
Copy code
set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
common_elements = set1 & set2
print(common_elements) # Output: {3, 4}
8.4.3 Combining Two Sets without Duplicates

 Problem: Merge two sets into one without any duplicates (union).
 python
Copy code
set1 = {1, 2, 3}
set2 = {2, 3, 4, 5}
merged_set = set1 | set2
print(merged_set) # Output: {1, 2, 3, 4, 5}
8.4.4 Finding Unique Elements in a Set

 Problem: Find elements that are present in one

Chapter 9: Data Structures: Dictionaries

A dictionary is a mutable, unordered collection of key-value pairs in Python. Each key in a

dictionary is unique, and it is associated with a corresponding value. Dictionaries are highly
efficient for storing and accessing data using unique identifiers.

9.1. Key-Value Pairs

Dictionaries are built from key-value pairs, where each key acts as an identifier for its
associated value.

9.1.1 What is a Dictionary?

A dictionary is defined by placing key-value pairs inside curly braces {}. Each key is separated
from its value by a colon :, and multiple key-value pairs are separated by commas.

 Syntax:

python
Copy code
my_dict = {key1: value1, key2: value2, key3: value3}

 Example:

python
Copy code
student = {
"name": "Alice",
"age": 20,
"grade": "A"
}
9.1.2 Characteristics of Dictionaries

 Keys must be immutable data types, such as strings, numbers, or tuples.

 Values can be of any data type, including lists, dictionaries, and sets.
 Dictionaries are unordered (as of Python 3.7, dictionaries maintain insertion order).

9.2. Accessing, Adding, and Removing Items

9.2.1 Accessing Items

You can access the value associated with a key by using square brackets [] or the get() method.
  Accessing Using Brackets:

python
Copy code
student = {"name": "Alice", "age": 20, "grade": "A"}
print(student["name"]) # Output: Alice

 Using get(): The get() method returns the value for the given key but allows you to
specify a default value if the key doesn’t exist.

python
Copy code
print(student.get("age")) # Output: 20
print(student.get("address", "N/A")) # Output: N/A
9.2.2 Adding or Updating Items

You can add a new key-value pair or update the value of an existing key by assigning a value to
the key.

 Adding New Key-Value Pair:

python
Copy code
student["address"] = "123 Main St"
print(student)
# Output: {'name': 'Alice', 'age': 20, 'grade': 'A', 'address': '123
Main St'}

 Updating an Existing Key:

python
Copy code
student["age"] = 21
print(student) # Output: {'name': 'Alice', 'age': 21, 'grade': 'A',
'address': '123 Main St'}
9.2.3 Removing Items

Dictionaries provide several ways to remove key-value pairs:

 pop(): Removes the key-value pair for the given key and returns the value.

python
Copy code
age = student.pop("age")
print(age) # Output: 21
print(student) # Output: {'name': 'Alice', 'grade': 'A', 'address':
'123 Main St'}

 del Keyword: Deletes the key-value pair for the specified key.

python
 Copy code
del student["address"]
print(student) # Output: {'name': 'Alice', 'grade': 'A'}

 clear(): Removes all items from the dictionary.

python
Copy code
student.clear()
print(student) # Output: {}

9.3. Dictionary Methods

Dictionaries come with a variety of built-in methods to help you perform common operations
efficiently.

9.3.1 keys()

The keys() method returns a view object that contains the keys of the dictionary.

 Example:

python
Copy code
student = {"name": "Alice", "age": 20, "grade": "A"}
print(student.keys()) # Output: dict_keys(['name', 'age', 'grade'])
9.3.2 values()

The values() method returns a view object that contains all the values in the dictionary.

 Example:

python
Copy code
print(student.values()) # Output: dict_values(['Alice', 20, 'A'])
9.3.3 items()

The items() method returns a view object that contains key-value pairs as tuples.

 Example:

python
Copy code
print(student.items()) # Output: dict_items([('name', 'Alice'), ('age',
20), ('grade', 'A')])
9.3.4 update()

The update() method updates the dictionary with key-value pairs from another dictionary or an
iterable of key-value pairs.

 Example:

python
Copy code
new_info = {"grade": "A+", "address": "123 Main St"}
student.update(new_info)
print(student) # Output: {'name': 'Alice', 'age': 20, 'grade': 'A+',
'address': '123 Main St'}
9.3.5 copy()

The copy() method returns a shallow copy of the dictionary, allowing you to make changes to
the new dictionary without affecting the original.

 Example:

python
Copy code
student_copy = student.copy()
print(student_copy) # Output: {'name': 'Alice', 'age': 20, 'grade':
'A+', 'address': '123 Main St'}

9.4. Case Study: Dictionary-Based Data Storage

Dictionaries are an excellent tool for organizing and storing data in key-value pairs, which
allows for fast lookups and efficient data manipulation. Let’s explore a case study where
dictionaries are used to manage data.

9.4.1 Student Management System

In this case study, we will use dictionaries to build a simple student management system that
stores information about students, including their name, age, and grades.

 Problem: Create a system that can store and retrieve student information and perform
operations like adding new students, updating grades, and printing a report card.

Step 1: Creating the Data Structure

We will use a dictionary where the key is the student ID and the value is another dictionary
containing details like name, age, and grades.

 Example:

python
 Copy code
students = {
1: {"name": "Alice", "age": 20, "grades": {"Math": 85, "Science":
90}},
2: {"name": "Bob", "age": 21, "grades": {"Math": 78, "Science":
82}},
3: {"name": "Charlie", "age": 19, "grades": {"Math": 92, "Science":
88}},
}
Step 2: Adding a New Student

We can add a new student by creating a new entry in the dictionary with a unique student ID.

 Adding a Student:

python
Copy code
def add_student(student_id, name, age, grades):
students[student_id] = {"name": name, "age": age, "grades": grades}

add_student(4, "David", 22, {"Math": 87, "Science": 85})

print(students)
Step 3: Updating Student Grades

We can update the grades of a student by accessing their grades dictionary and modifying the
value of a specific subject.

 Updating Grades:

python
Copy code
def update_grades(student_id, subject, new_grade):
students[student_id]["grades"][subject] = new_grade

update_grades(1, "Math", 95)

print(students[1]) # Output: {'name': 'Alice', 'age': 20, 'grades':
{'Math': 95, 'Science': 90}}
Step 4: Printing a Report Card

We can generate a report card for a student by accessing their grades and printing the details.

 Generating Report Card:

python
Copy code
def print_report_card(student_id):
student = students[student_id]
print(f"Report Card for {student['name']}:")
for subject, grade in student["grades"].items():
print(f"{subject}: {grade}")

print_report_card(1)
Step 5: Removing a Student

We can remove a student from the system using the del statement or the pop() method.

 Removing a Student:

python
Copy code
def remove_student(student_id):
students.pop(student_id, None)

remove_student(2)
print(students)
Chapter 10: File Handling in Python

File handling is an essential part of any programming language. In Python, file handling is
simple and efficient, enabling you to read from and write to files, handle different file modes,
and manage exceptions when working with files. This chapter will cover the basics of reading,
writing, and handling file operations, along with practical exercises.

10.1. Reading and Writing Files

10.1.1 Opening a File

Before reading from or writing to a file, you need to open it using the built-in open() function.
This function returns a file object, which provides methods for reading, writing, and closing the
file.

 Syntax:

python
Copy code
file_object = open("filename", mode)

 Example:

python
Copy code
file = open("example.txt", "r") # Opens file in read mode
10.1.2 Reading from a File

Python provides several methods to read content from a file, depending on how you want to
access the data.

 read(): Reads the entire content of the file as a single string.

python
Copy code
file = open("example.txt", "r")
content = file.read()
print(content)
file.close()

 readline(): Reads a single line from the file.

python
Copy code
file = open("example.txt", "r")
line = file.readline()
 print(line)
file.close()

 readlines(): Reads all lines and returns a list where each line is an element.

python
Copy code
file = open("example.txt", "r")
lines = file.readlines()
print(lines)
file.close()
10.1.3 Writing to a File

To write data to a file, you can use the write() or writelines() methods. Make sure the file is
opened in write mode ("w") or append mode ("a").

 write(): Writes a string to the file.

python
Copy code
file = open("example.txt", "w")
file.write("Hello, World!\n")
file.close()

 writelines(): Writes a list of strings to the file.

python
Copy code
lines = ["Line 1\n", "Line 2\n", "Line 3\n"]
file = open("example.txt", "w")
file.writelines(lines)
file.close()
10.1.4 Closing a File

Once the file operation is complete, it's important to close the file using the close() method.
This releases any system resources used by the file.

 Example:

python
Copy code
file = open("example.txt", "r")
content = file.read()
file.close()

10.2. Working with File Modes

When opening a file, you specify the mode that determines the type of operations allowed. Here
are some common file modes:
10.2.1 File Modes

 "r" (Read): Opens the file for reading. If the file does not exist, it raises an error.

python
Copy code
file = open("example.txt", "r")

 "w" (Write): Opens the file for writing. If the file exists, it truncates the file to zero
length. If it does not exist, it creates a new file.

python
Copy code
file = open("example.txt", "w")

 "a" (Append): Opens the file for appending. New data is added at the end of the file. If
the file does not exist, it creates a new file.

python
Copy code
file = open("example.txt", "a")

 "r+" (Read and Write): Opens the file for both reading and writing. The file must exist.

python
Copy code
file = open("example.txt", "r+")

 "w+" (Write and Read): Opens the file for both writing and reading. If the file exists, it
truncates the file. If it does not exist, it creates a new file.

python
Copy code
file = open("example.txt", "w+")

 "a+" (Append and Read): Opens the file for both appending and reading. If the file does
not exist, it creates a new file.

python
Copy code
file = open("example.txt", "a+")
10.2.2 Binary Mode

Files can also be opened in binary mode by adding "b" to the mode. This is useful for reading
or writing non-text files like images or audio files.

 Example:

python
 Copy code
file = open("image.jpg", "rb") # Opens file in binary read mode

10.3. Handling File Exceptions

When working with files, you should always be prepared to handle potential errors, such as
trying to open a file that does not exist. This is done using exception handling (try, except,
finally).

10.3.1 Common File-Related Exceptions

 FileNotFoundError: Raised when trying to open a file that does not exist.

python
Copy code
try:
file = open("nonexistent_file.txt", "r")
except FileNotFoundError:
print("File not found.")

 PermissionError: Raised when the program does not have the proper permissions to
access the file.

python
Copy code
try:
file = open("/protected/file.txt", "r")
except PermissionError:
print("You do not have permission to access this file.")
10.3.2 Using with Statement

Using the with statement simplifies file handling by automatically closing the file after the block
of code has executed. This is particularly useful for managing resources safely.

 Example:

python
Copy code
with open("example.txt", "r") as file:
content = file.read()
print(content)
# No need to manually close the file; it’s done automatically.

10.4. Practical: Creating a Text File Logger

In this practical exercise, you will create a simple text file logger that records actions or events
into a log file.
Problem Statement

Create a Python function that writes log messages to a text file. Each log entry should include the
current timestamp and a message.

Step 1: Import Required Modules

You will need the datetime module to record the current time in the log.

 Example:

python
Copy code
from datetime import datetime
Step 2: Create a Function to Write Logs

Define a function write_log() that opens a log file in append mode and writes the timestamp
along with the log message.

 Example:

python
Copy code
def write_log(message):
with open("log.txt", "a") as log_file:
timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
log_file.write(f"{timestamp} - {message}\n")
Step 3: Test the Logger

Test the write_log() function by writing different log messages.

 Example:

python
Copy code
write_log("Program started.")
write_log("User logged in.")
write_log("Error: Invalid input.")

This will create or append to a file log.txt with entries like:

yaml
Copy code
2024-10-24 14:45:00 - Program started.
2024-10-24 14:45:15 - User logged in.
2024-10-24 14:46:05 - Error: Invalid input.
Step 4: Enhancing the Logger

You can enhance the logger by adding features like different log levels (e.g., INFO, WARNING,
ERROR).

 Example:

python
Copy code
def write_log(message, level="INFO"):
with open("log.txt", "a") as log_file:
timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
log_file.write(f"{timestamp} - {level}: {message}\n")

# Example usage
write_log("Program started", "INFO")
write_log("User input invalid", "ERROR")
Chapter 11: Exception Handling

rrors and exceptions are inevitable in programming. Python provides robust tools for handling
exceptions, allowing developers to manage and respond to unexpected events in a controlled
manner. This chapter introduces exception handling in Python, focusing on using try, except,
and finally blocks, raising exceptions, and creating custom exceptions. By the end of this
chapter, you'll be able to detect and handle errors gracefully.

11.1. Try, Except, Finally Blocks

In Python, exception handling is done using try, except, and finally blocks. These constructs
allow you to handle exceptions and ensure that resources are properly managed.

11.1.1 The try and except Blocks

The try block contains code that might raise an exception. If an exception occurs, the except
block will catch the error and handle it appropriately, preventing the program from crashing.

 Syntax:

python
Copy code
try:
# Code that might raise an exception
except ExceptionType:
# Code that runs if the exception occurs

 Example:

python
Copy code
try:
num = int(input("Enter a number: "))
print(f"The number you entered is {num}")
except ValueError:
print("That was not a valid number.")

In this example, if the user enters a non-numeric value, the ValueError will be caught by the
except block, and the program will print a friendly error message.
11.1.2 The finally Block

The finally block contains code that will always execute, regardless of whether an exception
occurred or not. It is typically used to release resources or clean up, such as closing a file or
database connection.

 Syntax:

python
Copy code
try:
# Code that might raise an exception
except ExceptionType:
# Code that runs if an exception occurs
finally:
# Code that always runs (e.g., cleanup code)

 Example:

python
Copy code
try:
file = open("example.txt", "r")
content = file.read()
except FileNotFoundError:
print("File not found.")
finally:
file.close() # This will run no matter what

In this case, the finally block ensures that the file is closed whether or not an exception is
raised.

11.2. Raising Exceptions

Sometimes, you may want to raise an exception deliberately in response to certain conditions.
This is done using the raise keyword.

11.2.1 Raising an Exception

You can raise an exception using the raise statement. This can be useful for stopping program
execution when an unexpected situation arises.

 Syntax:

python
Copy code
raise ExceptionType("Error message")
  Example:

python
Copy code
age = int(input("Enter your age: "))
if age < 0:
raise ValueError("Age cannot be negative.")

If the user enters a negative value for age, the program will raise a ValueError with the message
"Age cannot be negative."

11.2.2 Raising Custom Error Messages

When raising exceptions, you can provide a custom error message to make the error more
informative.

 Example:

python
Copy code
password = input("Enter your password: ")
if len(password) < 6:
raise ValueError("Password must be at least 6 characters long.")

If the user enters a password shorter than 6 characters, the program will raise a ValueError with
a specific error message.

11.3. Custom Exceptions

Python allows you to create your own exceptions by defining custom exception classes. This is
useful when you need to handle specific types of errors that are not covered by built-in
exceptions.

11.3.1 Defining a Custom Exception

A custom exception is defined by subclassing the built-in Exception class or any of its
subclasses.

 Syntax:

python
Copy code
class CustomException(Exception):
pass

 Example:
 python
Copy code
class NegativeValueError(Exception):
"""Raised when a negative value is provided"""
pass

def check_positive(number):
if number < 0:
raise NegativeValueError("Negative values are not allowed.")
else:
print(f"Positive number: {number}")

try:
check_positive(-5)
except NegativeValueError as e:
print(e) # Output: Negative values are not allowed.

In this example, NegativeValueError is a custom exception class. If a negative number is

passed to the check_positive() function, the custom exception is raised and caught by the
except block.

11.3.2 Adding Additional Functionality to Custom Exceptions

You can also extend your custom exceptions by adding more functionality, such as custom
attributes or methods.

 Example:

python
Copy code
class NegativeValueError(Exception):
def __init__(self, value):
self.value = value
super().__init__(f"Negative value error: {value}")

def check_positive(number):
if number < 0:
raise NegativeValueError(number)
else:
print(f"Positive number: {number}")

try:
check_positive(-10)
except NegativeValueError as e:
print(e) # Output: Negative value error: -10

In this example, the custom exception class NegativeValueError stores the invalid value and
includes it in the error message.
11.4. Exercises: Error Detection in User Input

Let’s apply what you’ve learned about exception handling by solving practical problems where
we validate user input and handle errors gracefully.

Exercise 1: Detecting Invalid Numbers

 Problem: Write a function that takes input from the user and raises an exception if the input is
not a valid number.

python
Copy code
def get_number():
try:
number = int(input("Enter a number: "))
print(f"Valid number: {number}")
except ValueError:
print("Error: You must enter a valid integer.")

get_number()

If the user enters a non-integer value, the program catches the ValueError and prints an error
message.

Exercise 2: Validating Age Input

 Problem: Create a function that asks the user for their age. Raise a ValueError if the age is
negative, and handle the exception with a user-friendly message.

python
Copy code
def get_age():
try:
age = int(input("Enter your age: "))
if age < 0:
raise ValueError("Age cannot be negative.")
print(f"Your age is {age}.")
except ValueError as e:
print(f"Error: {e}")

get_age()

If the user enters a negative value for age, the program will raise and catch the ValueError, and
display a custom error message.

Exercise 3: Password Length Validation

 Problem: Write a function that asks the user to enter a password. If the password length is less
than 6 characters, raise an exception and provide a meaningful error message.
 python
Copy code
def check_password():
try:
password = input("Enter a password: ")
if len(password) < 6:
raise ValueError("Password must be at least 6 characters
long.")
print("Password accepted.")
except ValueError as e:
print(f"Error: {e}")

check_password()

If the user enters a password shorter than 6 characters, the program will raise a ValueError and
provide a helpful message.

Exercise 4: Custom Exception for Bank Withdrawal

 Problem: Create a custom exception called InsufficientFundsError and write a function

that simulates a bank withdrawal. If the withdrawal amount is greater than the account balance,
raise the custom exception.

python
Copy code
class InsufficientFundsError(Exception):
def __init__(self, balance, amount):
super().__init__(f"Insufficient funds: Cannot withdraw {amount}
with a balance of {balance}.")
self.balance = balance
self.amount = amount

def withdraw(balance, amount):

if amount > balance:
raise InsufficientFundsError(balance, amount)
balance -= amount
print(f"Withdrawal successful. New balance: {balance}")

try:
withdraw(1000, 1500)
except InsufficientFundsError as e:
print(e) # Output: Insufficient funds: Cannot withdraw 1500 with a
balance of 1000.

In this example, the custom exception InsufficientFundsError is raised when the withdrawal
amount exceeds the available balance, and a meaningful error message is displayed.
Chapter 12: Modules and Packages

As your Python projects grow in size and complexity, organizing your code becomes essential.
Modules and packages provide a way to structure your code into manageable and reusable
components. In this chapter, you will learn how to import and create modules, work with
external packages, and explore some commonly used libraries.

12.1. Importing Modules

12.1.1 What is a Module?

A module is simply a Python file that contains definitions (functions, variables, classes) and
statements. Modules allow you to break your code into separate files and reuse code across
different projects.

 Example:

python
Copy code
# my_module.py
def greet(name):
return f"Hello, {name}!"
12.1.2 Importing a Module

You can import a module into another script or program using the import statement.

 Syntax:

python
Copy code
import module_name

 Example:

python
Copy code
import my_module

print(my_module.greet("Alice")) # Output: Hello, Alice!

12.1.3 Importing Specific Elements from a Module

You can also import specific functions, classes, or variables from a module using the from
keyword.

 Syntax:
 python
Copy code
from module_name import specific_element

 Example:

python
Copy code
from my_module import greet

print(greet("Bob")) # Output: Hello, Bob!

12.1.4 Importing with an Alias

You can give a module or function an alias using the as keyword, which is helpful when dealing
with long module names.

 Syntax:

python
Copy code
import module_name as alias

 Example:

python
Copy code
import my_module as mod

print(mod.greet("Charlie")) # Output: Hello, Charlie!

12.1.5 Importing All Elements from a Module

You can import all elements from a module using *. However, this is not recommended for large
modules as it can lead to namespace collisions.

 Syntax:

python
Copy code
from module_name import *

 Example:

python
Copy code
from my_module import *

print(greet("Dave")) # Output: Hello, Dave!

12.2. Creating Custom Modules
12.2.1 What is a Custom Module?

A custom module is a Python file that you create, which can contain functions, variables, and
classes. You can then import this module into other Python files to reuse the code.

12.2.2 Steps to Create a Custom Module

1. Step 1: Create a new Python file (e.g., utilities.py).

2. Step 2: Define functions, variables, or classes in that file.
3. Step 3: Save the file and import it into other Python programs.

 Example (utilities.py):

python
Copy code
def add(a, b):
return a + b

def subtract(a, b):

return a - b

 Example (Using utilities.py in another script):

python
Copy code
import utilities

result = utilities.add(10, 5)
print(result) # Output: 15
12.2.3 Module Search Path

When you import a module, Python searches for it in the following locations:

1. The current directory.

2. Directories in the PYTHONPATH environment variable.
3. Python's default directory (lib).

You can check the module search paths using sys.path.

 Example:

python
Copy code
import sys
print(sys.path)
12.3. Installing and Using External Packages

External packages can be installed using Python’s package manager, pip. Packages are
collections of modules that are organized in a directory.

12.3.1 Installing a Package with pip

pip is the standard tool for installing Python packages from the Python Package Index (PyPI).

 Command:

bash
Copy code
pip install package_name

 Example:

bash
Copy code
pip install requests

Once installed, you can import and use the package in your code.

 Example (Using requests):

python
Copy code
import requests

response = requests.get("https://api.github.com")
print(response.status_code) # Output: 200
12.3.2 Viewing Installed Packages

To view the list of installed packages, use the following command:

 Command:

bash
Copy code
pip list
12.3.3 Uninstalling a Package

You can uninstall a package using the following command:

 Command:

bash
Copy code
pip uninstall package_name
12.4. Practical: Working with Python Libraries like math and random

Python provides several built-in libraries that make tasks like mathematical computations and
generating random numbers easy. Let’s explore practical examples using the math and random
modules.

12.4.1 Working with the math Module

The math module provides many mathematical functions such as square root, trigonometry, and
constants like π (pi).

 Importing math:

python
Copy code
import math

 Example: Calculate the square root of a number.

python
Copy code
number = 16
result = math.sqrt(number)
print(result) # Output: 4.0

 Example: Find the sine of an angle (in radians).

python
Copy code
angle = math.radians(90)
sine_value = math.sin(angle)
print(sine_value) # Output: 1.0

 Example: Use the pi constant to calculate the circumference of a circle.

python
Copy code
radius = 5
circumference = 2 * math.pi * radius
print(circumference) # Output: 31.41592653589793
12.4.2 Working with the random Module

The random module provides tools to generate random numbers, shuffle sequences, and select
random elements from a list.

 Importing random:

python
 Copy code
import random

 Example: Generate a random integer between two values.

python
Copy code
random_number = random.randint(1, 100)
print(random_number) # Output: (random number between 1 and 100)

 Example: Choose a random element from a list.

python
Copy code
fruits = ["apple", "banana", "cherry", "orange"]
random_fruit = random.choice(fruits)
print(random_fruit) # Output: (random fruit from the list)

 Example: Shuffle a list.

python
Copy code
numbers = [1, 2, 3, 4, 5]
random.shuffle(numbers)
print(numbers) # Output: (shuffled list of numbers)
12.4.3 Practical Exercise: Dice Roll Simulator

Create a simple dice roll simulator using the random module.

 Problem: Write a function roll_dice() that simulates rolling two six-sided dice and
returns the sum of the numbers rolled.
 Solution:

python
Copy code
import random

def roll_dice():
die1 = random.randint(1, 6)
die2 = random.randint(1, 6)
return die1 + die2

result = roll_dice()
print(f"You rolled a total of {result}")

Each time you run the program, it will simulate the rolling of two dice and print the total of the
numbers rolled.
Chapter 13: Object-Oriented Programming: Classes
and Objects
Object-Oriented Programming (OOP) is a powerful programming paradigm that organizes code
into objects. Python fully supports OOP, allowing you to create classes, define objects, and
encapsulate data and behavior into reusable structures. This chapter will introduce the core
concepts of OOP, focusing on defining classes, using constructors, working with instance
variables, and exploring object-oriented design.

13.1. Defining Classes and Objects

13.1.1 What is a Class?

A class is a blueprint for creating objects. It defines the properties (attributes) and behaviors
(methods) that the objects created from it will have. In Python, classes are defined using the
class keyword.

 Syntax:

python
Copy code
class ClassName:
# Class attributes and methods
13.1.2 What is an Object?

An object is an instance of a class. Objects have the attributes and behaviors defined by the
class, and each object can have its own unique values for the attributes.

 Creating an Object:

python
Copy code
obj = ClassName() # Object creation
13.1.3 Example of a Class and Object

 Example: Define a class Car and create an object from it.

python
Copy code
class Car:
def __init__(self, brand, model):
self.brand = brand
self.model = model

def display_info(self):
print(f"Car Brand: {self.brand}, Model: {self.model}")
 my_car = Car("Toyota", "Camry")
my_car.display_info() # Output: Car Brand: Toyota, Model: Camry

In this example:

 The class Car has two attributes (brand and model) and one method (display_info).
 my_car is an object created from the class Car.

13.2. Constructors and Destructors

13.2.1 What is a Constructor?

A constructor is a special method in a class that gets called automatically when an object of the
class is created. In Python, the constructor is the __init__() method.

 Purpose of the Constructor:

o Initialize object attributes when an object is created.
o Set up any necessary resources.

 Example:

python
Copy code
class Book:
def __init__(self, title, author):
self.title = title
self.author = author

def display(self):
print(f"Book: {self.title} by {self.author}")

my_book = Book("1984", "George Orwell")

my_book.display() # Output: Book: 1984 by George Orwell

In this example, the __init__() method initializes the title and author attributes when the
Book object is created.

13.2.2 What is a Destructor?

A destructor is a special method that is called when an object is about to be destroyed or when
the program finishes execution. In Python, the destructor is the __del__() method.

 Purpose of the Destructor:

o Clean up resources like closing files or database connections when the object is no
longer needed.

 Example:
 python
Copy code
class FileHandler:
def __init__(self, filename):
self.filename = filename
self.file = open(filename, 'r')

def __del__(self):
self.file.close()
print(f"File {self.filename} closed.")

handler = FileHandler("example.txt")
del handler # Manually call the destructor

In this example, the destructor ensures that the file is closed when the FileHandler object is
deleted.

13.3. Self and Instance Variables

13.3.1 The self Parameter

In Python, the first parameter of any method in a class is typically named self. The self
parameter represents the instance of the class and allows you to access the attributes and methods
of the object.

 Purpose of self:
o self is used to refer to the current object (instance) of the class.
o It allows each object to have its own distinct attributes and methods.

 Example:

python
Copy code
class Person:
def __init__(self, name):
self.name = name

def greet(self):
print(f"Hello, my name is {self.name}")

person1 = Person("Alice")
person1.greet() # Output: Hello, my name is Alice

In this example, self.name refers to the name attribute of the current Person object.

13.3.2 Instance Variables

Instance variables are variables that belong to an instance of a class (i.e., an object). Each object
has its own copy of instance variables, which are typically initialized in the constructor.
  Example:

python
Copy code
class Dog:
def __init__(self, breed, name):
self.breed = breed
self.name = name

dog1 = Dog("Labrador", "Buddy")

dog2 = Dog("Beagle", "Charlie")

print(dog1.name) # Output: Buddy

print(dog2.name) # Output: Charlie

In this example:

 dog1 and dog2 are two different objects, each having their own values for the name and breed
instance variables.

13.3.3 Class Variables vs Instance Variables

 Class Variables: These are shared by all instances of the class. They are declared within
the class but outside any method.
 Instance Variables: These are unique to each instance and are usually defined in the
__init__() method.
 Example:

python
Copy code
class Animal:
kingdom = "Animalia" # Class variable

def __init__(self, name):

self.name = name # Instance variable

a1 = Animal("Lion")
a2 = Animal("Elephant")

print(a1.kingdom) # Output: Animalia

print(a2.kingdom) # Output: Animalia

In this example, kingdom is a class variable shared by all instances, while name is an instance
variable specific to each object.

13.4. Long Questions: Object-Oriented Design in Python

To deepen your understanding of OOP principles, let’s explore some long questions that require
applying the concepts of classes, objects, inheritance, and design.
Question 1: Design a Bank Account System

 Problem Statement: Design a class BankAccount that has attributes for the account
holder's name, account number, and balance. Implement methods for depositing,
withdrawing, and displaying the account details.
 Solution:

python
Copy code
class BankAccount:
def __init__(self, holder_name, account_number, balance=0):
self.holder_name = holder_name
self.account_number = account_number
self.balance = balance

def deposit(self, amount):

self.balance += amount
print(f"Deposited {amount}. New balance: {self.balance}")

def withdraw(self, amount):

if amount > self.balance:
print("Insufficient funds")
else:
self.balance -= amount
print(f"Withdrew {amount}. New balance: {self.balance}")

def display_account_info(self):
print(f"Account Holder: {self.holder_name}")
print(f"Account Number: {self.account_number}")
print(f"Balance: {self.balance}")

# Example usage
account = BankAccount("Alice", "12345678", 500)
account.deposit(200)
account.withdraw(100)
account.display_account_info()
Question 2: Design a Library Management System

 Problem Statement: Design a Library class that allows users to borrow and return
books. The library should keep track of available books and borrowed books.
 Solution:

python
Copy code
class Library:
def __init__(self, books):
self.available_books = books
self.borrowed_books = {}

def display_books(self):
print("Available Books:")
for book in self.available_books:
print(book)
 def borrow_book(self, user, book):
if book in self.available_books:
self.available_books.remove(book)
self.borrowed_books[book] = user
print(f"{user} borrowed {book}.")
else:
print(f"Sorry, {book} is not available.")

def return_book(self, book):

if book in self.borrowed_books:
user = self.borrowed_books.pop(book)
self.available_books.append(book)
print(f"{user} returned {book}.")
else:
print(f"{book} was not borrowed from this library.")

# Example usage
library = Library(["The Hobbit", "1984", "Pride and Prejudice"])
library.display_books()
library.borrow_book("Alice", "1984")
library.return_book("1984")
library.display_books()
Question 3: Inheritance and Method Overriding

 Problem Statement: Create a base

Chapter 14: OOP: Inheritance, Polymorphism, and
Encapsulation

In object-oriented programming, the concepts of inheritance, polymorphism, and

encapsulation are key to designing systems that are modular, reusable, and easy to maintain. In
this chapter, we will explore these concepts and their implementation in Python, followed by
practical exercises to apply these principles.

14.1. Types of Inheritance

Inheritance allows a class (child or derived class) to inherit attributes and methods from another
class (parent or base class). Python supports various types of inheritance, which allow you to
create hierarchical class structures.

14.1.1 Single Inheritance

In single inheritance, a child class inherits from one parent class.

 Example:

python
Copy code
class Animal:
def speak(self):
print("Animal speaks.")

class Dog(Animal):
def bark(self):
print("Dog barks.")

dog = Dog()
dog.speak() # Inherited from Animal class
dog.bark() # Defined in Dog class
14.1.2 Multiple Inheritance

In multiple inheritance, a child class can inherit from more than one parent class.

 Example:

python
Copy code
class Flyer:
def fly(self):
print("Can fly.")
 class Swimmer:
def swim(self):
print("Can swim.")

class Duck(Flyer, Swimmer):

pass

duck = Duck()
duck.fly() # Output: Can fly.
duck.swim() # Output: Can swim.
14.1.3 Multilevel Inheritance

In multilevel inheritance, a class is derived from a class that is already derived from another
class, creating a chain of inheritance.

 Example:

python
Copy code
class Vehicle:
def move(self):
print("Vehicle moves.")

class Car(Vehicle):
def drive(self):
print("Car drives.")

class ElectricCar(Car):
def charge(self):
print("Electric car charges.")

tesla = ElectricCar()
tesla.move() # Output: Vehicle moves.
tesla.drive() # Output: Car drives.
tesla.charge()# Output: Electric car charges.
14.1.4 Hierarchical Inheritance

In hierarchical inheritance, multiple classes inherit from the same base class.

 Example:

python
Copy code
class Animal:
def speak(self):
print("Animal speaks.")

class Dog(Animal):
def bark(self):
print("Dog barks.")

class Cat(Animal):
def meow(self):
 print("Cat meows.")

dog = Dog()
cat = Cat()
dog.speak() # Output: Animal speaks.
cat.speak() # Output: Animal speaks.
14.1.5 Hybrid Inheritance

In hybrid inheritance, a combination of two or more types of inheritance is used in the program.
Python supports hybrid inheritance, but care must be taken to avoid the diamond problem.

 Example:

python
Copy code
class A:
pass

class B(A):
pass

class C(A):
pass

class D(B, C):

pass

14.2. Overloading and Overriding Methods

14.2.1 Method Overloading

Method overloading allows a class to have multiple methods with the same name but different
parameters. However, Python does not support method overloading by default, but you can
achieve similar behavior using default arguments.

 Example:

python
Copy code
class Calculator:
def add(self, a, b, c=0): # Overloading using default parameter
return a + b + c

calc = Calculator()
print(calc.add(5, 10)) # Output: 15
print(calc.add(5, 10, 20)) # Output: 35
14.2.2 Method Overriding

Method overriding occurs when a child class provides a specific implementation of a method
that is already defined in its parent class. The child class method overrides the parent class
method.
  Example:

python
Copy code
class Animal:
def speak(self):
print("Animal speaks.")

class Dog(Animal):
def speak(self): # Overriding the speak method
print("Dog barks.")

dog = Dog()
dog.speak() # Output: Dog barks.

In this example, the speak method in the Dog class overrides the speak method in the Animal
class.

14.2.3 Super Function

The super() function is used to call a method from the parent class in a child class. This is
especially useful when overriding methods.

 Example:

python
Copy code
class Parent:
def show(self):
print("Parent method.")

class Child(Parent):
def show(self):
super().show() # Calling the parent class method
print("Child method.")

c = Child()
c.show()

14.3. Encapsulation and Access Modifiers

Encapsulation is the concept of bundling data and methods that operate on that data within a
single unit (class) and controlling access to that data using access modifiers.

14.3.1 Public, Protected, and Private Attributes

 Public Attributes: These attributes can be accessed from anywhere in the program. In
Python, all class attributes and methods are public by default.

python
 Copy code
class MyClass:
def __init__(self):
self.public_var = "I am public"

obj = MyClass()
print(obj.public_var) # Output: I am public

 Protected Attributes: These attributes can be accessed within the class and by
subclasses (indicated by a single underscore _).

python
Copy code
class MyClass:
def __init__(self):
self._protected_var = "I am protected"

class SubClass(MyClass):
def access_protected(self):
print(self._protected_var)

obj = SubClass()
obj.access_protected() # Output: I am protected

 Private Attributes: These attributes can only be accessed within the class (indicated by
double underscores __).

python
Copy code
class MyClass:
def __init__(self):
self.__private_var = "I am private"

def access_private(self):
print(self.__private_var)

obj = MyClass()
obj.access_private() # Output: I am private
# print(obj.__private_var) # This will raise an AttributeError
14.3.2 Getter and Setter Methods

To access or modify private attributes, you can use getter and setter methods, which provide
controlled access to private data.

 Example:

python
Copy code
class Student:
def __init__(self, name, age):
self.__name = name
self.__age = age
 def get_age(self):
return self.__age

def set_age(self, age):

if age > 0:
self.__age = age
else:
print("Invalid age.")

student = Student("Alice", 20)

print(student.get_age()) # Output: 20
student.set_age(25)
print(student.get_age()) # Output: 25

In this example, the get_age() and set_age() methods allow controlled access and
modification of the private __age attribute.

14.4. Practical: Designing an OOP-Based System

Let’s apply the concepts of inheritance, polymorphism, and encapsulation to design an OOP-
based system.

Problem Statement: Design a Zoo Management System

Create a class hierarchy that represents a zoo. The base class Animal should have methods for
common behaviors (e.g., eat, sleep). Specific animals like Lion, Elephant, and Bird should
inherit from Animal and implement their own specific behaviors.

Step 1: Create a Base Class Animal

 Base Class:

python
Copy code
class Animal:
def __init__(self, name):
self.name = name

def eat(self):
print(f"{self.name} is eating.")

def sleep(self):
print(f"{self.name} is sleeping.")
Step 2: Create Subclasses for Specific Animals

 Subclass for Lion:

python
Copy code
 class Lion(Animal):
def roar(self):
print(f"{self.name} is roaring.")

 Subclass for Elephant:

python
Copy code
class Elephant(Animal):
def trumpet(self):
print(f"{self.name} is trumpeting.")

 Subclass for Bird:

python
Copy code
class Bird(Animal):
def fly(self):
print(f"{self.name} is flying.")
Step 3: Demonstrate Polymorphism and Encapsulation

 Main Program:

python
Copy code
def zoo_program():
lion = Lion("Leo")
elephant = Elephant("Dumbo")
Chapter 15: Regular Expressions

Regular expressions (regex) are a powerful tool for pattern matching and string manipulation.
Regex allows you to search, match, and replace text based on patterns. This chapter introduces
the basics of regular expressions in Python, how to match patterns, search and replace text, and
apply regex in practical exercises like validating input.

15.1. Introduction to Regex

Regular expressions are sequences of characters that define search patterns. Python’s re module
provides support for regex operations, allowing you to match, search, and manipulate text
efficiently.

15.1.1 What is a Regular Expression?

A regular expression is a special string that represents a search pattern. It can be simple (e.g.,
searching for a specific word) or complex (e.g., searching for a pattern of letters, digits, or
special characters).

15.1.2 Importing the re Module

To use regular expressions in Python, you need to import the re module.

 Example:

python
Copy code
import re
15.1.3 Basic Special Characters in Regex

Here are some commonly used special characters in regular expressions:

 .: Matches any character except a newline.

 ^: Matches the start of a string.
 $: Matches the end of a string.
 *: Matches 0 or more occurrences of the preceding character.
 +: Matches 1 or more occurrences of the preceding character.
 ?: Matches 0 or 1 occurrence of the preceding character.
 []: Used to define a character set.
 \d: Matches any digit.
 \w: Matches any word character (letters, digits, and underscores).
 \s: Matches any whitespace character (spaces, tabs, newlines).
15.2. Matching Patterns

Matching patterns is the most basic operation in regular expressions. You can use the
re.match() function to match a pattern from the start of a string.

15.2.1 Using re.match()

The re.match() function checks if the pattern matches the beginning of the string.

 Syntax:

python
Copy code
re.match(pattern, string)

 Example:

python
Copy code
import re

pattern = r"\d{3}" # Pattern to match three digits

result = re.match(pattern, "123abc")
if result:
print("Match found!")
else:
print("No match.")

In this example, the pattern \d{3} matches any string that starts with three digits.

15.2.2 Using Groups in Matching

You can use parentheses () in regex patterns to capture groups of characters.

 Example:

python
Copy code
pattern = r"(\d{3})-(\d{2})"
match = re.match(pattern, "123-45")
if match:
print(match.group(1)) # Output: 123
print(match.group(2)) # Output: 45

In this example, the regex pattern captures two groups: three digits followed by two digits.
15.2.3 Matching Multiple Occurrences

You can use special characters like *, +, and {} to match multiple occurrences of a pattern.

 Example:

python
Copy code
pattern = r"a+"
result = re.match(pattern, "aaaabc")
if result:
print("Match found!") # Output: Match found!

In this case, the pattern a+ matches one or more occurrences of the letter "a."

15.3. Searching and Replacing Patterns

Regular expressions allow you to search for patterns within a string and replace matched patterns
with other text.

15.3.1 Using re.search()

The re.search() function scans the entire string for a match, returning the first match it finds.

 Syntax:

python
Copy code
re.search(pattern, string)

 Example:

python
Copy code
pattern = r"\d{3}"
result = re.search(pattern, "abc123xyz")
if result:
print("Match found!") # Output: Match found!

Unlike re.match(), which only checks the beginning of the string, re.search() looks for the
pattern anywhere in the string.

15.3.2 Using re.findall()

The re.findall() function returns all non-overlapping matches of the pattern in the string as a
list.
  Syntax:

python
Copy code
re.findall(pattern, string)

 Example:

python
Copy code
pattern = r"\d+"
result = re.findall(pattern, "There are 3 apples and 12 oranges.")
print(result) # Output: ['3', '12']

In this example, re.findall() returns all the digits present in the string.

15.3.3 Using re.sub() for Replacing Patterns

The re.sub() function replaces all occurrences of a pattern in the string with a replacement text.

 Syntax:

python
Copy code
re.sub(pattern, replacement, string)

 Example:

python
Copy code
pattern = r"\d+"
result = re.sub(pattern, "number", "There are 3 apples and 12 oranges.")
print(result) # Output: There are number apples and number oranges.

In this case, re.sub() replaces all occurrences of one or more digits with the word "number."

15.4. Exercises: Validating Input Using Regex

Let’s apply regex to practical use cases by validating user input, such as email addresses, phone
numbers, and passwords.

Exercise 1: Validating an Email Address

 Problem: Write a function that validates if an email address is in a proper format (e.g.,
name@example.com).
 Solution:
 python
Copy code
import re

def validate_email(email):
pattern = r"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$"
if re.match(pattern, email):
print("Valid email address.")
else:
print("Invalid email address.")

validate_email("test@example.com") # Output: Valid email address.

Exercise 2: Validating a Phone Number

 Problem: Write a function that validates if a phone number follows the format (XXX)
XXX-XXXX where X is a digit.
 Solution:

python
Copy code
def validate_phone(phone):
pattern = r"^\(\d{3}\) \d{3}-\d{4}$"
if re.match(pattern, phone):
print("Valid phone number.")
else:
print("Invalid phone number.")

validate_phone("(123) 456-7890") # Output: Valid phone number.

Exercise 3: Validating a Password

 Problem: Write a function that validates if a password is at least 8 characters long and
contains both letters and numbers.
 Solution:

python
Copy code
def validate_password(password):
pattern = r"^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d]{8,}$"
if re.match(pattern, password):
print("Valid password.")
else:
print("Invalid password.")

validate_password("abc12345") # Output: Valid password.

Exercise 4: Replacing Dates in a Text

 Problem: Write a function that finds dates in the format MM/DD/YYYY and replaces them
with the format YYYY-MM-DD.
 Solution:

python
Copy code
 def replace_dates(text):
pattern = r"(\d{2})/(\d{2})/(\d{4})"
new_text = re.sub(pattern, r"\3-\1-\2", text)
print(new_text)

replace_dates("The event is on 05/12/2024.") # Output: The event is on

2024-05-12.

In this example, re.sub() is used to transform the date format from MM/DD/YYYY to YYYY-MM-
DD.
Chapter 16: Working with Libraries: NumPy and
Pandas

Python is widely used in data science and scientific computing, and two of the most powerful
libraries for these purposes are NumPy and Pandas. NumPy provides support for large, multi-
dimensional arrays and matrices, while Pandas is built for data manipulation and analysis,
offering powerful tools like DataFrames. This chapter introduces these libraries and guides you
through data analysis tasks.

16.1. Basics of NumPy Arrays

NumPy (Numerical Python) is a fundamental library for scientific computing in Python. It

provides support for arrays, which are collections of elements of the same type.

16.1.1 What is a NumPy Array?

A NumPy array is a grid of values, all of the same type, indexed by a tuple of non-negative
integers. NumPy arrays are more efficient than Python lists, making them ideal for performing
complex mathematical operations.

16.1.2 Installing NumPy

Before using NumPy, you need to install it using pip.

 Command:

bash
Copy code
pip install numpy
16.1.3 Creating NumPy Arrays

You can create NumPy arrays using the numpy.array() function. Arrays can be one-
dimensional or multi-dimensional.

 Example:

python
Copy code
import numpy as np

# Creating a 1D array
arr1 = np.array([1, 2, 3, 4, 5])
print(arr1)
 # Creating a 2D array
arr2 = np.array([[1, 2, 3], [4, 5, 6]])
print(arr2)
16.1.4 NumPy Array Operations

NumPy arrays allow for a variety of mathematical operations. Unlike Python lists, operations on
NumPy arrays are element-wise and highly optimized.

 Example:

python
Copy code
arr = np.array([1, 2, 3])
print(arr + 1) # Output: [2 3 4]
print(arr * 2) # Output: [2 4 6]
16.1.5 Array Slicing and Indexing

You can slice and index NumPy arrays to access specific elements, rows, or columns.

 Example:

python
Copy code
arr = np.array([[1, 2, 3], [4, 5, 6]])
print(arr[0, 1]) # Output: 2
print(arr[:, 1]) # Output: [2 5] (second column)
16.1.6 Common NumPy Functions

NumPy provides several built-in functions for statistical and mathematical operations:

 np.sum(): Computes the sum of elements.

 np.mean(): Computes the average.
 np.max() and np.min(): Find the maximum and minimum values.
 np.reshape(): Changes the shape of an array.
 Example:

python
Copy code
arr = np.array([1, 2, 3, 4, 5])
print(np.sum(arr)) # Output: 15
print(np.mean(arr)) # Output: 3.0

16.2. Introduction to Pandas DataFrames

Pandas is a library designed for data manipulation and analysis. It provides two primary data
structures: Series (1D) and DataFrames (2D). DataFrames are particularly powerful for
handling tabular data like spreadsheets or SQL tables.
16.2.1 What is a DataFrame?

A DataFrame is a two-dimensional, size-mutable, and heterogeneous data structure, similar to a

table or a spreadsheet in Excel. It consists of rows and columns, each column representing a
specific variable (attribute) and each row representing an observation (record).

16.2.2 Installing Pandas

Before using Pandas, install it using pip.

 Command:

bash
Copy code
pip install pandas
16.2.3 Creating DataFrames

You can create DataFrames from various sources, such as dictionaries, lists, or NumPy arrays.

 Example: Creating a DataFrame from a dictionary.

python
Copy code
import pandas as pd

data = {
'Name': ['Alice', 'Bob', 'Charlie'],
'Age': [25, 30, 35],
'City': ['New York', 'Los Angeles', 'Chicago']
}
df = pd.DataFrame(data)
print(df)
16.2.4 Accessing Data in DataFrames

You can access columns, rows, or specific elements in a DataFrame using labels or indices.

 Accessing a Column:

python
Copy code
print(df['Name']) # Output: Column with names

 Accessing a Row (using loc for labels or iloc for integer-based index):

python
Copy code
print(df.loc[0]) # Access row by label
print(df.iloc[1]) # Access row by index
16.2.5 Basic DataFrame Operations

Pandas supports a wide range of operations such as filtering, adding columns, and performing
aggregate functions.

 Filtering Rows:

python
Copy code
print(df[df['Age'] > 30]) # Output: Rows where age is greater than 30

 Adding a New Column:

python
Copy code
df['Salary'] = [50000, 60000, 70000]
print(df)

16.3. Data Analysis with Pandas

Pandas is a versatile tool for data analysis, allowing you to read, manipulate, clean, and analyze
data easily. This section covers some common data analysis operations.

16.3.1 Reading Data from Files

Pandas can read data from a variety of file formats, including CSV, Excel, JSON, and SQL
databases.

 Reading a CSV File:

python
Copy code
df = pd.read_csv("data.csv")
print(df.head()) # Display the first 5 rows of the DataFrame
16.3.2 Handling Missing Data

Real-world datasets often contain missing or null values. Pandas provides methods to detect and
handle missing data.

 Checking for Missing Data:

python
Copy code
print(df.isnull().sum()) # Output: Number of missing values in each
column

 Filling Missing Values:

 python
Copy code
df.fillna(0, inplace=True) # Fill missing values with 0

 Dropping Rows with Missing Values:

python
Copy code
df.dropna(inplace=True)
16.3.3 Grouping and Aggregating Data

You can group data based on a specific column and perform aggregate operations like sum,
mean, or count.

 Example: Grouping data by a column and calculating the average.

python
Copy code
grouped = df.groupby('City')['Age'].mean()
print(grouped)
16.3.4 Sorting and Filtering Data

You can sort the data by columns and filter specific rows based on conditions.

 Sorting:

python
Copy code
sorted_df = df.sort_values(by='Age', ascending=False)
print(sorted_df)

 Filtering Rows:

python
Copy code
filtered_df = df[df['Salary'] > 60000]
print(filtered_df)

16.4. Practical: Analyzing Datasets Using Pandas

Let’s apply the knowledge gained to analyze a dataset using Pandas.

Problem Statement: Analyze Employee Data

You are given an employee dataset in CSV format containing information such as Name, Age,
Department, Salary, and City. Perform the following tasks:

1. Load the dataset into a DataFrame.

2. Display basic information about the dataset.
 3. Identify and handle missing data.
4. Filter employees earning more than $60,000.
5. Group employees by Department and calculate the average salary.
6. Sort the employees by Age in descending order.

Solution:
python
Copy code
import pandas as pd

# Step 1: Load the dataset

df = pd.read_csv("employees.csv")

# Step 2: Display basic information

print(df.info())
print(df.head())

# Step 3: Handle missing data

df.fillna(0, inplace=True)

# Step 4: Filter employees earning more than $60,000

high_earners = df[df['Salary'] > 60000]
print(high_earners)

# Step 5: Group by Department and calculate average salary

average_salary_by_dept = df.groupby('Department')['Salary'].mean()
print(average_salary_by_dept)

# Step 6: Sort employees by Age in descending order

sorted_by_age = df.sort_values(by='Age', ascending=False)
print(sorted_by_age)

This practical exercise demonstrates how to load, analyze, and manipulate real-world datasets
using Pandas.

This chapter introduces the essential tools for working with data in Python using NumPy and
Pandas. You learned how to create and manipulate arrays with NumPy, handle DataFrames with
Pandas, and perform basic data analysis tasks.
Chapter 17: Working with Databases

Databases are essential for storing and managing large amounts of data. Python offers various
libraries to interact with databases like SQLite and MySQL, enabling you to perform CRUD
(Create, Read, Update, Delete) operations. This chapter covers how to connect Python with
databases, execute SQL queries, handle databases using SQLite, and includes a case study to
build a Python-based inventory management system.

17.1. Connecting Python with Databases (SQLite, MySQL)

17.1.1 Introduction to SQLite

SQLite is a lightweight, file-based database that is built into Python. It requires no separate
server, making it ideal for small applications or local development.

17.1.2 Introduction to MySQL

MySQL is a widely-used relational database management system (RDBMS). You can connect
Python with MySQL for scalable applications that require more powerful database management
than SQLite.

17.1.3 Installing Required Packages

To connect Python with MySQL, you need to install the mysql-connector-python package.

 Installing SQLite: SQLite is built into Python, so no installation is required.

 Installing MySQL Connector:

bash
Copy code
pip install mysql-connector-python
17.1.4 Connecting to SQLite Database

You can connect to an SQLite database using the sqlite3 module, which is included in
Python’s standard library.

 Example:

python
Copy code
import sqlite3

# Connecting to an SQLite database (or creating one if it doesn't exist)

connection = sqlite3.connect('example.db')
 # Creating a cursor object to interact with the database
cursor = connection.cursor()
17.1.5 Connecting to MySQL Database

To connect to a MySQL database, you need to use the mysql.connector library.

 Example:

python
Copy code
import mysql.connector

connection = mysql.connector.connect(
host="localhost",
user="root",
password="your_password",
database="your_database"
)

cursor = connection.cursor()

17.2. CRUD Operations

CRUD operations are the basic operations you can perform on a database: Create, Read,
Update, and Delete.

17.2.1 Creating Tables (Create)

You can create tables in a database by executing SQL CREATE TABLE statements using the cursor
object.

 Example: Creating a table in SQLite.

python
Copy code
cursor.execute('''
CREATE TABLE IF NOT EXISTS users (
id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT,
age INTEGER,
email TEXT
)
''')
connection.commit()
17.2.2 Inserting Data into Tables (Create)

You can insert data into tables using SQL INSERT INTO statements.

 Example:
 python
Copy code
cursor.execute('''
INSERT INTO users (name, age, email) VALUES (?, ?, ?)
''', ('Alice', 25, 'alice@example.com'))
connection.commit()
17.2.3 Reading Data from Tables (Read)

You can read data from a table using SQL SELECT statements.

 Example:

python
Copy code
cursor.execute('SELECT * FROM users')
rows = cursor.fetchall()
for row in rows:
print(row)
17.2.4 Updating Data in Tables (Update)

You can update data in a table using SQL UPDATE statements.

 Example:

python
Copy code
cursor.execute('''
UPDATE users SET age = ? WHERE name = ?
''', (30, 'Alice'))
connection.commit()
17.2.5 Deleting Data from Tables (Delete)

You can delete data from a table using SQL DELETE FROM statements.

 Example:

python
Copy code
cursor.execute('''
DELETE FROM users WHERE name = ?
''', ('Alice',))
connection.commit()

17.3. Database Handling with sqlite3

The sqlite3 module in Python provides all the necessary methods to interact with an SQLite
database. Here are some key functionalities:
17.3.1 Creating and Connecting to a Database

 Example:

python
Copy code
import sqlite3

connection = sqlite3.connect('inventory.db')
cursor = connection.cursor()
17.3.2 Executing SQL Commands

You can execute SQL commands using the cursor.execute() method and pass parameters
using placeholders (?).

 Example:

python
Copy code
cursor.execute('INSERT INTO products (name, price, quantity) VALUES
(?, ?, ?)', ('Laptop', 1200, 5))
connection.commit()
17.3.3 Fetching Data

You can fetch all rows from a query result using fetchall() or fetch one row at a time using
fetchone().

 Example:

python
Copy code
cursor.execute('SELECT * FROM products')
rows = cursor.fetchall()
for row in rows:
print(row)
17.3.4 Handling Transactions

You can group several SQL statements into a transaction. If all the statements succeed, you can
commit the transaction using connection.commit(). If an error occurs, you can roll back the
transaction using connection.rollback().
17.4. Case Study: Creating a Python-Based Inventory Management
System
Problem Statement

Design a Python-based inventory management system where users can add new products, update
stock levels, delete products, and view all products in the inventory. The system should store all
data in an SQLite database.

Step 1: Database Setup

Create a database to store product information, including product_id, name, price, and
quantity.

 Example:

python
Copy code
import sqlite3

# Connect to the database

connection = sqlite3.connect('inventory.db')
cursor = connection.cursor()

# Create products table

cursor.execute('''
CREATE TABLE IF NOT EXISTS products (
product_id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT,
price REAL,
quantity INTEGER
)
''')
connection.commit()
Step 2: Adding Products

Allow users to add new products to the inventory.

 Example:

python
Copy code
def add_product(name, price, quantity):
cursor.execute('''
INSERT INTO products (name, price, quantity) VALUES (?, ?, ?)
''', (name, price, quantity))
connection.commit()

# Example usage
add_product('Laptop', 1200, 5)
Step 3: Viewing All Products

Create a function to display all products in the inventory.

 Example:

python
Copy code
def view_products():
cursor.execute('SELECT * FROM products')
rows = cursor.fetchall()
for row in rows:
print(row)

# Example usage
view_products()
Step 4: Updating Product Information

Create a function to update the quantity or price of a product.

 Example:

python
Copy code
def update_product(product_id, price=None, quantity=None):
if price:
cursor.execute('UPDATE products SET price = ? WHERE product_id =
?', (price, product_id))
if quantity:
cursor.execute('UPDATE products SET quantity = ? WHERE
product_id = ?', (quantity, product_id))
connection.commit()

# Example usage
update_product(1, price=1300, quantity=10)
Step 5: Deleting Products

Create a function to delete a product from the inventory.

 Example:

python
Copy code
def delete_product(product_id):
cursor.execute('DELETE FROM products WHERE product_id = ?',
(product_id,))
connection.commit()

# Example usage
delete_product(2)
Step 6: Running the Inventory Management System

You can integrate all the functions into a simple menu-driven program.

 Example:

python
Copy code
def main():
while True:
print("\nInventory Management System")
print("1. Add product")
print("2. View products")
print("3. Update product")
print("4. Delete product")
print("5. Exit")

choice = input("Enter your choice: ")

if choice == '1':
name = input("Enter product name: ")
price = float(input("Enter product price: "))
quantity = int(input("Enter product quantity: "))
add_product(name, price, quantity)
elif choice == '2':
view_products()
elif choice == '3':
product_id = int(input("Enter product ID to update: "))
price = float(input("Enter new price: "))
quantity = int(input("Enter new quantity: "))
update_product(product_id, price=price, quantity=quantity)
elif choice == '4':
product_id = int(input("Enter product ID to delete: "))
delete_product(product_id)
elif choice == '5':
break
else:
print("Invalid choice! Please try again.")

if __name__ == '__main__':
main()

This chapter provides a solid introduction to database operations in Python. You learned how to
connect to databases like SQLite and MySQL, perform CRUD operations, and handle database
transactions.
Chapter 18: Web Scraping and APIs

The ability to retrieve and interact with data from websites and APIs is a crucial skill in modern
programming. Web scraping involves extracting data from websites, while APIs (Application
Programming Interfaces) allow you to communicate with web services and retrieve structured
data. This chapter introduces the basics of web scraping using BeautifulSoup and how to
interact with APIs using Python’s requests library.

18.1. Introduction to Web Scraping with BeautifulSoup

Web scraping allows you to extract information from websites. BeautifulSoup is a Python
library used to parse HTML and XML documents, making it easier to navigate and extract
content.

18.1.1 What is Web Scraping?

Web scraping is the process of extracting data from a website by parsing the HTML code of
web pages. It is useful for collecting large amounts of data, automating data collection, or
extracting content that is not provided through an API.

18.1.2 Installing Required Libraries

To perform web scraping, you need to install the following libraries:

 requests: Used to make HTTP requests to download web pages.

 BeautifulSoup: Used to parse the HTML content and extract data.
 Command:

bash
Copy code
pip install requests
pip install beautifulsoup4
18.1.3 Fetching Web Pages with requests

The first step in web scraping is to fetch the content of the web page using the requests library.

 Example:

python
Copy code
import requests

url = "https://example.com"
response = requests.get(url)
 if response.status_code == 200:
print("Page fetched successfully!")
html_content = response.text
else:
print(f"Failed to fetch page. Status code: {response.status_code}")
18.1.4 Parsing HTML with BeautifulSoup

Once the HTML content is fetched, you can parse it with BeautifulSoup to extract specific
information.

 Example:

python
Copy code
from bs4 import BeautifulSoup

soup = BeautifulSoup(html_content, 'html.parser')

print(soup.title.text) # Output: Title of the web page
18.1.5 Navigating the HTML Tree

You can navigate through the HTML structure to find specific elements (like div, span, a, etc.)
using tags, classes, or IDs.

 Example: Extract all hyperlinks (<a> tags).

python
Copy code
links = soup.find_all('a')
for link in links:
print(link.get('href'))
18.1.6 Extracting Specific Data

You can extract specific information from a page using methods like find(), find_all(), or
CSS selectors.

 Example: Extract all paragraphs (<p> tags) with a specific class.

python
Copy code
paragraphs = soup.find_all('p', class_='specific-class')
for paragraph in paragraphs:
print(paragraph.text)

18.2. Making API Requests with Python (e.g., requests library)

Many websites provide APIs that allow developers to access structured data directly, without
needing to scrape HTML. You can use the requests library to interact with APIs and retrieve
data.
18.2.1 What is an API?

An API (Application Programming Interface) is a set of rules that allow programs to interact
with each other. Web APIs typically provide data in formats like JSON or XML and allow you
to perform tasks such as retrieving, creating, updating, or deleting data on a web server.

18.2.2 Making GET Requests

To retrieve data from an API, you can make a GET request using the requests library.

 Example: Fetch data from a public API.

python
Copy code
import requests

url = "https://api.github.com/users/octocat"
response = requests.get(url)

if response.status_code == 200:
data = response.json() # Parse JSON response
print(data)
else:
print("Failed to retrieve data")
18.2.3 Making POST Requests

You can send data to an API using a POST request, often used when submitting forms or
uploading data.

 Example:

python
Copy code
payload = {'username': 'john_doe', 'password': 'password123'}
response = requests.post("https://example.com/login", data=payload)

if response.status_code == 200:
print("Login successful!")
else:
print("Failed to log in")
18.2.4 Handling API Authentication

Some APIs require authentication, typically through API keys, OAuth tokens, or HTTP Basic
Authentication.

 Example: Using an API key in a request.

python
Copy code
headers = {'Authorization': 'Bearer YOUR_API_KEY'}
 response = requests.get('https://api.example.com/data', headers=headers)

if response.status_code == 200:
print("Data retrieved successfully")
else:
print("Failed to authenticate")
18.2.5 Working with JSON Data

Most APIs return data in JSON format. You can use Python's json() method to convert the
response to a Python dictionary.

 Example:

python
Copy code
import requests

url = "https://jsonplaceholder.typicode.com/posts/1"
response = requests.get(url)

if response.status_code == 200:
post_data = response.json()
print(post_data['title']) # Output: Title of the post

18.3. Practical: Extracting Data from a Website Using Python

Problem Statement

You need to extract the latest news headlines from a website and store them in a text file.
Additionally, you will use an API to retrieve weather information for a specific location.

Step 1: Web Scraping News Headlines

You can scrape the latest news headlines from a news website using BeautifulSoup.

 Example:

python
Copy code
import requests
from bs4 import BeautifulSoup

url = "https://news.ycombinator.com/"
response = requests.get(url)
soup = BeautifulSoup(response.text, 'html.parser')

# Find all headlines

headlines = soup.find_all('a', class_='storylink')

with open('news_headlines.txt', 'w') as file:

for headline in headlines:
file.write(headline.text + '\n')
 print("Headlines saved to news_headlines.txt")
Step 2: Making an API Request for Weather Data

You can use a weather API like OpenWeatherMap to retrieve the current weather for a given
city.

 Example:

python
Copy code
import requests

api_key = "YOUR_API_KEY"
city = "London"
url = f"http://api.openweathermap.org/data/2.5/weather?
q={city}&appid={api_key}&units=metric"

response = requests.get(url)

if response.status_code == 200:
weather_data = response.json()
print(f"Weather in {city}: {weather_data['main']['temp']}°C")
else:
print("Failed to retrieve weather data")
Step 3: Combining Scraped Data with API Data

You can combine the news headlines with the weather data and store them together.

 Example:

python
Copy code
with open('news_and_weather.txt', 'w') as file:
file.write("Latest News Headlines:\n")
for headline in headlines:
file.write(headline.text + '\n')

file.write("\nWeather Information:\n")
file.write(f"City: {city}, Temperature: {weather_data['main']
['temp']}°C\n")

print("News and weather data saved to news_and_weather.txt")

Key Takeaways from Chapter 18:

 Web Scraping allows you to extract data from websites by parsing HTML using libraries like
BeautifulSoup.
 APIs provide structured data that you can access programmatically, often through HTTP
requests using the requests library.
 You can combine web scraping and API requests to gather comprehensive datasets and perform
tasks like data extraction and automation.
Chapter 19: GUI Programming with Tkinter

Tkinter is the standard Python library for creating Graphical User Interfaces (GUIs). With
Tkinter, you can build interactive desktop applications with windows, buttons, text fields, and
more. This chapter covers the basics of Tkinter, creating simple GUI applications, adding
widgets, and handling user events. A practical exercise on building a GUI-based calculator will
help reinforce these concepts.

19.1. Introduction to Tkinter

19.1.1 What is Tkinter?

Tkinter is a built-in Python library that provides tools for creating desktop GUIs. It is cross-
platform and widely used for building simple and efficient GUI applications. Tkinter allows you
to create windows, add widgets (such as buttons, labels, text boxes), and handle user input.

19.1.2 Installing Tkinter

Tkinter comes pre-installed with Python on most platforms. To check if Tkinter is available, you
can try importing it:

 Command:

python
Copy code
import tkinter as tk

If it raises an error, you may need to install it via your package manager (Linux) or download the
appropriate libraries.

19.1.3 Basic Structure of a Tkinter Application

Every Tkinter application consists of a main window, which is the base container for all other
GUI elements.

 Example: Creating a simple Tkinter window.

python
Copy code
import tkinter as tk

# Create the main window

root = tk.Tk()

# Set the window title

 root.title("My First Tkinter App")

# Set the window size

root.geometry("300x200")

# Run the application

root.mainloop()

In this example:

 root = tk.Tk() creates the main window.

 root.mainloop() runs the application and waits for user input or events.

19.2. Creating Basic GUI Applications

19.2.1 Adding Widgets to a Window

Tkinter provides various widgets like labels, buttons, text boxes, and entry fields that you can
add to your GUI.

 Example: Adding a label widget.

python
Copy code
label = tk.Label(root, text="Hello, Tkinter!")
label.pack() # Add the label to the window

The pack() method arranges the widget in the window.

19.2.2 Setting Window Properties

You can modify the properties of the Tkinter window, such as its title, size, and background
color.

 Example: Setting window properties.

python
Copy code
root.title("My GUI App")
root.geometry("400x300") # Width x Height
root.configure(bg="lightblue") # Set background color
19.2.3 Creating Layouts

Tkinter provides three main geometry managers to arrange widgets: pack(), grid(), and place().

 pack(): Places widgets in the window in a top-down fashion.

 grid(): Organizes widgets in a grid (rows and columns).
 place(): Places widgets at specific coordinates.
  Example: Using grid() for layout.

python
Copy code
label1 = tk.Label(root, text="First Name")
label1.grid(row=0, column=0)

entry1 = tk.Entry(root)
entry1.grid(row=0, column=1)

19.3. Adding Widgets, Buttons, and Event Handling

19.3.1 Adding Buttons

You can add buttons to your GUI and define actions that will be performed when the button is
clicked.

 Example: Adding a button.

python
Copy code
def on_click():
print("Button clicked!")

button = tk.Button(root, text="Click Me", command=on_click)

button.pack()

Here, the command parameter is used to link a function (on_click()) to the button.

19.3.2 Entry Fields for User Input

You can add Entry widgets to capture user input, such as text fields for entering names or
numbers.

 Example: Adding an entry field.

python
Copy code
entry = tk.Entry(root)
entry.pack()

def display_text():
entered_text = entry.get() # Get the text from the entry field
print(entered_text)

button = tk.Button(root, text="Submit", command=display_text)

button.pack()

In this example, the entry.get() method retrieves the text entered by the user.
19.3.3 Event Handling in Tkinter

Event handling allows your GUI application to respond to user actions, such as mouse clicks,
key presses, and button clicks.

 Example: Binding an event.

python
Copy code
def on_key_press(event):
print(f"Key pressed: {event.char}")

root.bind("<KeyPress>", on_key_press)

This binds the KeyPress event to the on_key_press() function, which prints the key pressed by
the user.

19.4. Exercises: Building a Simple GUI Calculator

In this exercise, you'll create a basic GUI calculator using Tkinter. The calculator will support
basic arithmetic operations such as addition, subtraction, multiplication, and division.

Step 1: Setting Up the GUI Layout

You will start by creating a window and adding buttons for numbers and operations.

 Example:

python
Copy code
import tkinter as tk

root = tk.Tk()
root.title("Calculator")

entry = tk.Entry(root, width=20, borderwidth=3)

entry.grid(row=0, column=0, columnspan=4)

Here, an Entry widget is created for displaying input and results, and the layout is organized
using grid().

Step 2: Adding Buttons for Numbers

Create buttons for numbers 0-9 and arrange them in a grid.

 Example:
 python
Copy code
def button_click(number):
current = entry.get()
entry.delete(0, tk.END)
entry.insert(0, current + str(number))

button_1 = tk.Button(root, text="1", padx=20, pady=10, command=lambda:

button_click(1))
button_1.grid(row=1, column=0)

# Add buttons for 2, 3, ..., 9 in a similar manner

The lambda function is used to pass the button value to the button_click() function when
clicked.

Step 3: Adding Operation Buttons

Add buttons for operations like addition, subtraction, multiplication, and division.

 Example:

python
Copy code
def button_add():
first_number = entry.get()
global f_num
global operation
operation = "addition"
f_num = int(first_number)
entry.delete(0, tk.END)

button_add = tk.Button(root, text="+", padx=20, pady=10,

command=button_add)
button_add.grid(row=1, column=3)
Step 4: Implementing Equals and Clear Buttons

The "equals" button will calculate the result, and the "clear" button will reset the input.

 Example:

python
Copy code
def button_equal():
second_number = entry.get()
entry.delete(0, tk.END)

if operation == "addition":
entry.insert(0, f_num + int(second_number))
# Add cases for subtraction, multiplication, and division

button_equal = tk.Button(root, text="=", padx=20, pady=10,

command=button_equal)
 button_equal.grid(row=4, column=3)

def button_clear():
entry.delete(0, tk.END)

button_clear = tk.Button(root, text="C", padx=20, pady=10,

command=button_clear)
button_clear.grid(row=4, column=0)
Step 5: Running the Calculator

Once all buttons are added, you can run the calculator by calling the main event loop.

 Final Code:

python
Copy code
root.mainloop()

This completes the simple calculator GUI.

Summary of Chapter 19:

 Tkinter is a built-in Python library for creating GUI applications.

 You can add widgets like labels, buttons, and entry fields to build interactive interfaces.
 Event handling allows the application to respond to user input, such as mouse clicks and key
presses.
 The practical exercise of building a simple GUI calculator demonstrates how to combine widgets
and event handling.
Chapter 20: Python for Data Visualization

Data visualization is a crucial part of data analysis. Python offers several libraries for creating
graphical representations of data, with Matplotlib being one of the most widely used libraries
for creating static, animated, and interactive visualizations. In this chapter, you will learn the
basics of Matplotlib, how to plot different types of graphs and charts, customize plots, and apply
these skills in a practical data visualization project.

20.1. Introduction to Matplotlib

Matplotlib is a comprehensive library for creating static, animated, and interactive visualizations
in Python. It is widely used for generating plots, graphs, histograms, and more.

20.1.1 What is Matplotlib?

Matplotlib is a plotting library that provides control over every aspect of the plot, making it
highly customizable. It can generate plots of different types, including line plots, scatter plots,
bar charts, histograms, and more.

20.1.2 Installing Matplotlib

To use Matplotlib, you need to install it using pip.

 Command:

bash
Copy code
pip install matplotlib
20.1.3 Basic Structure of a Matplotlib Plot

The basic elements of a Matplotlib plot include the figure, axes, labels, and legends. You can
create a simple plot by importing the pyplot module from Matplotlib.

 Example: Creating a simple line plot.

python
Copy code
import matplotlib.pyplot as plt

# Data
x = [1, 2, 3, 4, 5]
y = [1, 4, 9, 16, 25]

# Creating a plot
 plt.plot(x, y)

# Adding title and labels

plt.title("Simple Line Plot")
plt.xlabel("X Axis")
plt.ylabel("Y Axis")

# Display the plot

plt.show()

In this example:

 plt.plot() creates the line plot.

 plt.show() displays the plot.

20.2. Plotting Graphs, Charts, and Histograms

Matplotlib supports a wide variety of plots for different data visualization needs. This section
covers common types of plots such as line plots, scatter plots, bar charts, and histograms.

20.2.1 Line Plots

Line plots are used to visualize data points connected by straight lines. This type of plot is often
used to display trends over time.

 Example:

python
Copy code
plt.plot([1, 2, 3, 4], [1, 4, 9, 16])
plt.title("Line Plot")
plt.xlabel("X Axis")
plt.ylabel("Y Axis")
plt.show()
20.2.2 Scatter Plots

Scatter plots display data points as individual markers on the plot, often used to show
relationships between variables.

 Example:

python
Copy code
x = [5, 10, 15, 20, 25]
y = [10, 20, 25, 40, 50]
plt.scatter(x, y)
plt.title("Scatter Plot")
plt.show()
20.2.3 Bar Charts

Bar charts represent categorical data using rectangular bars with lengths proportional to the
values they represent.

 Example:

python
Copy code
categories = ["A", "B", "C", "D"]
values = [5, 10, 15, 7]
plt.bar(categories, values)
plt.title("Bar Chart")
plt.show()
20.2.4 Histograms

Histograms show the distribution of data by grouping the data into bins. They are useful for
understanding the frequency distribution of data.

 Example:

python
Copy code
data = [1, 2, 2, 3, 3, 3, 4, 4, 5]
plt.hist(data, bins=5)
plt.title("Histogram")
plt.show()

In this example, the data is divided into 5 bins to show the frequency of different values.

20.3. Customizing Graphs

One of the key strengths of Matplotlib is its flexibility. You can customize nearly every aspect of
a plot, including line styles, colors, markers, labels, titles, legends, and more.

20.3.1 Customizing Line Styles and Colors

You can change the appearance of lines and markers in your plots by specifying styles, colors,
and markers.

 Example: Customizing line style and color.

python
Copy code
plt.plot([1, 2, 3, 4], [1, 4, 9, 16], linestyle='--', color='r',
marker='o')
plt.title("Customized Line Plot")
plt.show()
20.3.2 Adding Legends

Legends help identify the different data series in a plot. You can add legends to your plot using
the plt.legend() function.

 Example:

python
Copy code
plt.plot([1, 2, 3, 4], [1, 4, 9, 16], label="Data 1")
plt.plot([1, 2, 3, 4], [2, 3, 5, 8], label="Data 2")
plt.legend()
plt.show()
20.3.3 Titles, Labels, and Annotations

Adding titles, axis labels, and annotations improves the readability of your graphs.

 Example:

python
Copy code
plt.plot([1, 2, 3, 4], [1, 4, 9, 16])
plt.title("Graph Title")
plt.xlabel("X Axis Label")
plt.ylabel("Y Axis Label")
plt.text(2, 9, "Annotated Point") # Annotating a point on the plot
plt.show()
20.3.4 Subplots and Multiple Plots

You can create multiple subplots within the same figure using plt.subplot(). This is useful
when you need to display multiple plots side by side.

 Example:

python
Copy code
plt.subplot(1, 2, 1) # First subplot in a 1x2 grid
plt.plot([1, 2, 3], [1, 4, 9])

plt.subplot(1, 2, 2) # Second subplot in a 1x2 grid

plt.plot([1, 2, 3], [2, 3, 5])

plt.show()

20.4. Practical: Visualizing Data with Python

In this section, you will apply the concepts learned to create a comprehensive data visualization
project using Matplotlib. The goal is to visualize data and extract meaningful insights.
Problem Statement: Visualizing Sales Data

You have sales data for different product categories across multiple months. Your task is to
visualize:

1. Monthly sales trends using a line plot.

2. Sales distribution by product category using a bar chart.
3. Distribution of individual product sales using a histogram.

Step 1: Loading the Data

For simplicity, you can create a dataset using lists or load it from a CSV file using Pandas.

 Example:

python
Copy code
import matplotlib.pyplot as plt
import pandas as pd

data = {
'Month': ['Jan', 'Feb', 'Mar', 'Apr', 'May'],
'Electronics': [5000, 6000, 7000, 8000, 7500],
'Clothing': [2000, 2500, 2300, 2400, 2200],
'Groceries': [3000, 3200, 3400, 3600, 3500]
}
df = pd.DataFrame(data)
Step 2: Visualizing Monthly Sales Trends

Create a line plot to visualize the monthly sales trend for each product category.

 Example:

python
Copy code
plt.plot(df['Month'], df['Electronics'], label="Electronics",
marker='o')
plt.plot(df['Month'], df['Clothing'], label="Clothing", marker='o')
plt.plot(df['Month'], df['Groceries'], label="Groceries", marker='o')

plt.title("Monthly Sales Trend")

plt.xlabel("Month")
plt.ylabel("Sales")
plt.legend()
plt.show()
Step 3: Visualizing Sales by Category

Create a bar chart to show the total sales for each product category.

 Example:
 python
Copy code
total_sales = df[['Electronics', 'Clothing', 'Groceries']].sum()
categories = total_sales.index
values = total_sales.values

plt.bar(categories, values)
plt.title("Total Sales by Category")
plt.ylabel("Sales")
plt.show()
Step 4: Visualizing Sales Distribution

Create a histogram to visualize the distribution of sales values across all months.

 Example:

python
Copy code
plt.hist(df['Electronics'], bins=5, alpha=0.5, label='Electronics')
plt.hist(df['Clothing'], bins=5, alpha=0.5, label='