PA

TH
FI
N
D
ER
PY
TH
O
N
:C
O
N
C
EP
T
TO
C
R
EA
TI
O
N

1
 N
O
TI
EA
R
C
TO
PATHFINDER PYTHON: T
EP
C
N

CONCEPT TO CREATION
O
:C
N
O

-
TH

HARSHINI S
PY
ER
D
N
FI
TH
PA

2
TABLE OF CONTENTS:
Preface

Acknowledgments

1.​Introduction to Python
2.​Data Types and Variables

N
3.​Control Structures

O
TI
4.​Functions

EA
5.​Object-Oriented Programming (OOP)

R
6.​Error and Exception Handling

C
7.​Modules and Libraries

TO
8.​File Handling
9.​Advanced Topics
T
EP
C

Conclusion
N
O
:C

Appendix A: Python Cheat Sheet

N
O

Appendix B: Further Resources

TH
PY
ER
D
N
FI
TH
PA

3
Preface
In the ever-evolving world of technology, programming has become an essential skill for
professionals and enthusiasts alike. Among the multitude of programming languages,
Python stands out as a versatile, easy-to-learn, and powerful language that has captured the

N
interest of developers worldwide. Its broad applicability, from web development to data

O
analysis and artificial intelligence, makes it a cornerstone of modern computing.

TI
EA
This Book, “PATHFINDER PYTHON:CONCEPT TO CREATION” is designed to serve as a
definitive resource for both beginners and experienced programmers. It provides a

R
structured and detailed journey through Python, starting from foundational concepts and

C
progressing to advanced topics. Each chapter is crafted to build a strong understanding of

TO
the language, supported by clear definitions, in-depth explanations, and practical examples.

T
Key features of this eBook include:EP
●​ A thorough introduction to Python’s syntax and unique characteristics.
C

●​ Detailed exploration of essential programming constructs such as data types, control

N

structures, and functions.

O

●​ Insight into advanced concepts like object-oriented programming, error handling, and
:C

decorators.
N

●​ Practical knowledge of Python’s extensive libraries and their real-world applications.

O

●​ Hands-on examples and exercises to reinforce learning and foster problem-solving

TH

skills.
PY

Whether you are a student beginning your programming journey, a professional looking to
expand your skill set, or an enthusiast eager to explore Python’s capabilities, this Book offers
ER

valuable insights to help you master the language and achieve your goals.
D

I hope this guide inspires you to delve deeper into Python programming and empowers you
N

to create innovative solutions. Happy coding!

FI
TH
PA

4
 N
O
TI
Acknowledgments

EA
This book is the result of a journey filled with learning, guidance, and unwavering support,

R
C
and I owe its creation to several remarkable individuals and institutions.

TO
First and foremost, I extend my heartfelt gratitude to my technical mentor. Her guidance,
encouragement, and expertise have been instrumental in shaping my understanding and

T
approach to programming. Without her support, this achievement would not have been
EP
possible.
C

I am incredibly proud to be a student of Face Prep Campus, which has provided me with
N

numerous opportunities to grow and learn. My gratitude also extends to Shrimathi

O

Devkunvar Nanalal Bhatt Vaishnav College for Women, which has supported me at every
:C

step of my academic journey. Their encouragement and belief in my potential have been
N

invaluable.
O
TH

To my mentors, educators, and the entire community that has guided me, I am truly thankful.
This work stands as a testament to the incredible support and learning environment you
PY

have provided me.

ER

Thank you all for making this possible.

D
N
FI
TH
PA

5
PATHFINDER PYTHON:CONCEPT TO CREATION

Chapter 1: Introduction to Python

Definition:

Python is a high-level, interpreted, and general-purpose programming language

N
known for its simplicity and readability. Created by Guido van Rossum in 1991, Python is

O
widely used for web development, data analysis, artificial intelligence, scientific computing,

TI
automation, and more.

EA
Key Features:

R
C
1.​ Simple Syntax: Python's syntax is straightforward, making it beginner-friendly and

TO
easy to write and understand.
2.​ Interpreted: Python code is executed line-by-line, allowing for immediate feedback
and easier debugging.

T
EP
3.​ Dynamic Typing: Variables do not require explicit declaration of data types; Python
infers them during runtime.
C

4.​ Extensive Libraries: Python comes with a vast collection of standard libraries, and
N

there are thousands of third-party libraries available for specialized tasks.

O

5.​ Cross-Platform: Python programs can run seamlessly on different operating

:C

systems like Windows, macOS, and Linux.

N

6.​ Community Support: Python has a large and active community, making it easy to
O

find resources, tutorials, and help.

TH

Example:
PY

# Simple Python program

ER

print("Hello, World!")
D
N
FI
TH

#This program outputs the text "Hello, World!" to the screen.

PA

6
Chapter 2: Data Types and Variables
Definition:

Data types define the kind of data a variable can hold, such as integers, decimals, or text.
Variables act as containers for storing data values.

Common Data Types in Python:

Python, being a dynamically-typed programming language, allows you to work with various

N
data types without declaring them explicitly. Below is a detailed explanation of the most

O
commonly used data types in Python:

TI
EA
1. Integer (int)

R
●​ Definition: The int data type is used to represent whole numbers, both positive and

C
negative, including zero. It does not include fractional or decimal values.​

TO
●​ Characteristics:​

T
EP
○​ Integers in Python have unlimited precision, meaning they can represent very
C

large numbers.
N

○​ Basic operations such as addition, subtraction, multiplication, and division can

O

be performed using integers.

:C

Example:​
N

​
O
TH

age = 30
PY

score = -15
ER

large_number = 12345678901234567890
D
N
FI

print(type(age)) # Output: <class 'int'>

TH
PA

2. Floating Point (float)

●​ Definition: The float data type represents numbers that have a decimal point or
are expressed in exponential (scientific) notation.​

●​ Characteristics:​

○​ Used for more precise numerical calculations involving fractions.

7
 ○​ Can handle very small and very large numbers using exponential notation
(e.g., 1.5e3 for 1500).

Example:​

pi = 3.14159

temperature = -15.5

large_float = 1.2e6 # Equivalent to 1,200,000

N
O
print(type(pi)) # Output: <class 'float'>

TI
EA
R
C
3. String (str)

TO
●​ Definition: A string is a sequence of characters enclosed within single quotes ('),
double quotes ("), or triple quotes (''' or """).​
T
EP
●​ Characteristics:​
C
N

○​ Strings are immutable, meaning their values cannot be changed after

O

creation.
:C

○​ Supports various operations like concatenation, slicing, and repetition.

N
O

Example:​
TH

​
PY

greeting = "Hello, World!"

ER

name = 'Alina'
D
N

multi_line = '''This is a multi-line

FI
TH

string.'''
PA

print(type(greeting)) # Output: <class 'str'>

4. Boolean (bool)

●​ Definition: A boolean represents one of two possible values: True or False. It is

commonly used in conditional statements and logical operations.​

8
 ●​ Characteristics:​

○​ Internally, True is represented as 1 and False as 0.

○​ Often the result of comparison or logical expressions.

Example:​
​

is_active = True

N
O
has_permission = False

TI
EA
print(type(is_active)) # Output: <class 'bool'>

R
C
TO
5. List (list)

●​ Definition: A list is an ordered collection of items, which can be of any data type.
T
EP
Lists are mutable, meaning they can be modified after creation.​
C

●​ Characteristics:​
N
O

○​ Allows duplicate elements.

:C

○​ Can contain a mix of data types (e.g., integers, strings, other lists).
N
O

Example:​
TH

​
PY

is_active = True
ER

fruits = ["apple", "banana", "cherry"]

D
N

mixed_list = [1, "text", 3.5, True]

FI
TH

fruits.append("orange")
PA

print(fruits) # Output: ['apple', 'banana', 'cherry', 'orange']

6. Tuple (tuple)

●​ Definition: A tuple is an ordered, immutable collection of items. Like lists, a tuple

can contain items of mixed data types.​

9
 ●​ Characteristics:​

○​ Tuples are faster than lists due to immutability.

○​ Commonly used to represent fixed collections of related items.

Example:​
​

coordinates = (10, 20)

N
colors = ("red", "green", "blue")

O
TI
print(type(coordinates)) # Output: <class 'tuple'>

EA
R
C
7. Set (set)

TO
●​ Definition: A set is an unordered collection of unique items. It is mutable but does
T
EP
not allow duplicate values.​
C

●​ Characteristics:​
N
O

○​ Commonly used for operations like union, intersection, and difference.

:C

○​ Items in a set must be hashable (e.g., immutable data types).

N
O

Example:​
TH

​
PY

unique_numbers = {1, 2, 3, 4, 4}
ER

print(unique_numbers) # Output: {1, 2, 3, 4}

D
N

unique_numbers.add(5)
FI
TH

print(unique_numbers) # Output: {1, 2, 3, 4, 5}

PA

8. Dictionary (dict)

●​ Definition: A dictionary is a collection of key-value pairs, where each key is

unique and is associated with a specific value.​

●​ Characteristics:​

10
 ○​ Keys must be immutable (e.g., strings, numbers, or tuples), while values can
be of any data type.
○​ Dictionaries are mutable.

Example:​
​

student = {"name": "Alina", "age": 25, "course": "Computer Science"}

print(student["name"]) # Output: Alina

N
O
student["age"] = 26

TI
EA
print(student) # Output: {'name': 'Alina', 'age': 26, 'course':

R
'Computer Science'}

C
TO
9. None (NoneType)
T
EP
●​ Definition: None represents the absence of a value or a null value. It is often used to
C

initialize variables or indicate that a function does not return a value.​

N
O

●​ Characteristics:​
:C
N

○​ Only one instance of NoneType exists.

O

○​ It evaluates to False in a boolean context.

TH

Example:​
PY

​
ER

result = None
D
N

if result is None:
FI
TH

print("No value assigned yet") # Output: No value assigned yet

PA

Variables in Python:

A variable in Python is essentially a name that is used to store and reference data. It allows
you to associate a value with a name, which can then be used in your program for
computations, operations, or logic. Python is a dynamically typed language, meaning you do
not need to declare the type of a variable explicitly. The interpreter infers the type of the
variable based on the value assigned to it.

11
1. Creating and Assigning Variables

In Python, you create a variable by assigning a value to a name using the = operator. There
is no need to declare the type explicitly.

Example:

x = 10 # x is an integer

name = "John" # name is a string

N
O
height = 5.5 # height is a float

TI
EA
R
2. Variable Naming Rules

C
TO
Variable names in Python must follow these rules:

●​ Variable names can contain letters (a-z, A-Z), digits (0-9), and underscores (_).

T
EP
●​ Variable names cannot start with a digit.
●​ Python keywords, such as if, else, class, and while, cannot be used as variable
C

names.
N
O

Examples of valid variable names:

:C
N
O

x = 5
TH
PY

name = "Alice"

total_amount = 100
ER
D
N
FI

Examples of invalid variable names:

TH

1st_number = 10 # Cannot start with a digit

PA

class = "Math" # 'class' is a reserved keyword

3. Dynamic Typing

Python does not require you to specify the type of a variable at the time of creation. The type
is automatically assigned based on the value it holds.

12
Example:

a = 10 # a is an integer

a = "Hello" # a is now a string (no need to declare its type again)

4. Reassigning Variables

N
You can change the value of a variable during the execution of the program by reassigning it.

O
Python allows this flexibility because of its dynamic typing system.

TI
EA
Example:

R
x = 100

C
x = 200 # x is now holding the value 200

TO
T
EP
5. Types of Data Stored in Variables
C
N

Python supports several data types, and variables can store any of them. Common types
O

include:
:C

●​ Integers: Whole numbers, e.g., x = 10

N
O

●​ Floats: Decimal numbers, e.g., y = 3.14

TH

●​ Strings: Sequences of characters, e.g., name = "Alice"

●​ Lists: Ordered collections of items, e.g., numbers = [1, 2, 3]
PY

●​ Booleans: True or False values, e.g., flag = True

ER
D
N
FI
TH
PA

13
Chapter 3: Control Structures
Control Structures in Python

Control structures are fundamental building blocks in Python that determine the flow of
execution of a program. They allow programmers to control the decision-making process
and the order in which statements are executed, enabling the creation of dynamic and
flexible code. Control structures are categorized into three main types: sequential, selection,
and iteration.

N
1. Sequential Control

O
TI
Definition: Sequential control is the default mode of execution in Python, where statements

EA
are executed one after another in the order in which they are written.

R
Example:

C
TO
# Sequential execution

T
print("Welcome to Python programming!")
EP
print("This is an example of sequential control.")
C
N
O

Explanation: In this example, the two print statements are executed one after the other in
:C

the given order.

N

2. Selection Control (Decision-Making)

O
TH

Definition:
PY

Selection control allows the program to make decisions based on conditions and execute
ER

specific blocks of code depending on the outcome of these conditions.

D

Key Constructs:
N
FI

●​ if
TH

●​ if-else
PA

●​ if-elif-else

Brief Explanation:

Selection control helps the program decide which part of the code to execute based on a
condition. The condition is evaluated as True or False, and the corresponding block of
code runs accordingly.

Examples:

14
1. If Statement:

# Example of if statement

age = 18

if age >= 18:

print("You are eligible to vote.")

N
O
Explanation: If the condition age >= 18 is True, the message is displayed.

TI
EA
2. If-Else Statement:

R
# Example of if-else statement

C
TO
number = int(input("Enter a number: "))

T
if number % 2 == 0:
EP
print("The number is even.")
C
N

else:
O
:C

print("The number is odd.")

N
O
TH

Explanation: Depending on whether the number is divisible by 2, the program decides

PY

which message to display.

ER

3. If-Elif-Else Statement:
D

# Example of if-elif-else statement

N
FI

marks = int(input("Enter your marks: "))

TH

if marks >= 90:

PA

print("Grade: A")

elif marks >= 75:

print("Grade: B")

elif marks >= 50:

print("Grade: C")

15
else:

print("Grade: F")

Explanation: The program evaluates the marks and assigns a grade based on the
conditions in the if-elif-else ladder.

3. Iteration Control (Loops)

N
O
Definition:

TI
EA
Iterative control allows a block of code to be executed repeatedly, either for a fixed number
of times or while a certain condition holds true. Loops enable automation of repetitive tasks

R
in Python programs.

C
TO
Key Loop Constructs:

T
1.​ for loop
EP
2.​ while loop
C
N

Brief Explanation:
O
:C

●​ for Loop: Used for iterating over a sequence (like a list, tuple, or range) or other
N

iterable objects.
O

●​ while Loop: Executes as long as a specified condition evaluates to True.

TH

Examples:
PY

1. For Loop:
ER

# Example of a for loop

D
N

for i in range(1, 6):

FI
TH

print(f"Iteration: {i}")
PA

Explanation: The for loop iterates over the range of numbers from 1 to 5, printing each
iteration.

2. While Loop:

# Example of a while loop

count = 1

16
while count <= 5:

print(f"Count: {count}")

count += 1

Explanation: The while loop continues to execute as long as the condition (count <= 5)

N
is True.

O
TI
EA
4. Jump Statements

R
Definition: Jump statements alter the normal flow of execution by jumping to a different part

C
of the code.

TO
Key Constructs:

●​ break
T
EP
●​ continue
C

●​ pass
N
O

a) Break Statement
:C
N

Example:
O

# Using break in a loop

TH

for i in range(1, 10):

PY

if i == 5:
break
ER

print(i)
D
N

Explanation:
FI
TH

●​ The break statement exits the loop when i equals 5.

PA

b) Continue Statement

Example:

# Using continue in a loop

for i in range(1, 10):
if i % 2 == 0:
continue
print(i)

17
Explanation:

●​ The continue statement skips the current iteration when i is even.

c) Pass Statement

Example:

# Using pass in a loop

N
for i in range(5):

O
if i == 3:

TI
pass

EA
print(i)

R
C
TO
Explanation:

●​ The pass statement acts as a placeholder and does nothing, allowing the program to

T
EP
continue normally.
C
N
O
:C
N
O
TH
PY
ER
D
N
FI
TH
PA

18
Chapter 4: Functions
Understanding Functions in Python

Functions in Python are reusable blocks of code that perform a specific task. They help in
making programs modular, more readable, and easier to debug. Python functions are
defined using the def keyword.

Key Components of a Function:

N
1.​ Function Definition:

O
TI
A function is defined using the def keyword, followed by the function name and

EA
parentheses.

R
Example:​

C
TO
def greet():

T
EP
print("Hello, World!")
C
N
O

2.​ Function Call:​

:C

A function is executed by calling its name followed by parentheses.

N
O

Example:​
TH
PY

greet() # Output: Hello, World!

ER

3.​ Parameters and Arguments:​

D

●​ Parameters are variables listed in the function definition.

N

●​ Arguments are values passed to the function when it is called.

FI
TH

Example:​
PA

def greet_person(name):

print(f"Hello, {name}!")

greet_person("Alice") # Output: Hello, Alice!

19
 4.​ Return Statement:​
Functions can return values using the return keyword.

Example:​

def add(a, b):

return a + b

result = add(5, 3)

N
O
print(result) # Output: 8

TI
EA
R
C
Types of Functions:

TO
1.​ Built-in Functions:​
Python comes with many predefined functions, such as print(), len(), type(),

T
EP
etc.
2.​ User-defined Functions:​
C

Functions created by the user to perform specific tasks.

N
O

Example:​
:C
N

def multiply(a, b):

O
TH

return a * b
PY
ER

3.​ Lambda Functions:​

D

Anonymous functions defined using the lambda keyword.

N
FI

Example:​
TH
PA

square = lambda x: x ** 2

print(square(4)) # Output: 16

4.​ Recursive Functions:​

Functions that call themselves to solve smaller instances of a problem.

20
Example:​

def factorial(n):

if n == 0:

return 1

else:

N
return n * factorial(n - 1)

O
TI
print(factorial(5)) # Output: 120

EA
R
C
Advantages of Using Functions:

TO
●​ Code Reusability: Write once, use multiple times.

T
●​ Modularity: Break down complex problems into smaller, manageable parts.
EP
●​ Improved Readability: Functions with descriptive names make the code
C

self-explanatory.
N

●​ Ease of Testing: Test individual functions independently.

O
:C

Example of a Complete Function:

N
O
TH

# Function to check if a number is even

PY

def is_even(number):
ER

if number % 2 == 0:
D
N

return True
FI
TH

else:
PA

return False

# Using the function

num = 10

if is_even(num):

print(f"{num} is even.")

21
else:

print(f"{num} is odd.")

# Output: 10 is even.

N
O
TI
EA
R
C
TO
T
EP
C
N
O
:C
N
O
TH
PY
ER
D
N
FI
TH
PA

22
Chapter 5: Object-Oriented Programming (OOP)
Object-Oriented Programming (OOP) in Python

Object-Oriented Programming (OOP) is a paradigm in programming that organizes code into

reusable and interconnected objects. Python, being an object-oriented language, supports
the creation and management of objects and classes. This approach makes programs
modular, scalable, and easier to maintain.

Key Concepts of OOP in Python

N
O
1.​ Classes and Objects:

TI
●​ A class is a blueprint for creating objects. It defines attributes (data) and

EA
methods (behavior) that the objects created from the class will have.
●​ An object is an instance of a class.

R
C
Example:​

TO
​

T
EP
class Car:
C

def __init__(self, brand, model):

N
O

self.brand = brand
:C
N

self.model = model
O
TH

def display_info(self):
PY

return f"Car: {self.brand} {self.model}"

ER

my_car = Car("Toyota", "Corolla")

D

print(my_car.display_info()) # Output: Car: Toyota Corolla

N
FI
TH

2.​ Encapsulation:​
PA

●​ Encapsulation involves bundling data (attributes) and methods (functions)

into a single unit, typically a class.
●​ It helps to restrict direct access to certain components of an object, using
access modifiers like private (denoted by __ before an attribute).

Example:​
​

23
class BankAccount:

def __init__(self, balance):

self.__balance = balance # Private attribute

def deposit(self, amount):

self.__balance += amount

def get_balance(self):

N
O
TI
return self.__balance

EA
account = BankAccount(1000)

R
C
account.deposit(500)

TO
print(account.get_balance()) # Output: 1500

T
EP
C

3.​ Inheritance:​
N
O

●​ Inheritance allows one class (child class) to inherit attributes and methods
:C

from another class (parent class).

●​ It promotes code reuse and establishes relationships between classes.
N
O

Example:​
TH

​
PY

class Animal:
ER

def __init__(self, name):

D
N
FI

self.name = name
TH

def speak(self):
PA

return "Animal sound"

class Dog(Animal):

def speak(self):

return f"{self.name} says Woof!"

dog = Dog("Buddy")

24
print(dog.speak()) # Output: Buddy says Woof!

4.​ Polymorphism:

Polymorphism allows methods in different classes to have the same name but
behave differently depending on the object invoking them.

Example:​
​

N
O
TI
class Bird:

EA
def fly(self):

R
C
return "Birds can fly."

TO
class Penguin(Bird):

T
EP
def fly(self):
C

return "Penguins cannot fly."

N
O

def describe_flying(creature):
:C
N

print(creature.fly())
O
TH

bird = Bird()
PY

penguin = Penguin()
ER

describe_flying(bird) # Output: Birds can fly.

D

describe_flying(penguin) # Output: Penguins cannot fly.

N
FI
TH

5.​ Abstraction:​
PA

●​ Abstraction hides complex implementation details and exposes only the

essential features of an object.
●​ Abstract classes cannot be instantiated and are used as templates for other
classes. Python provides the abc module for creating abstract classes.

Example:​
​

25
from abc import ABC, abstractmethod

class Vehicle(ABC):

@abstractmethod

def start_engine(self):

pass

class Car(Vehicle):

N
O
TI
def start_engine(self):

EA
return "Car engine started."

R
C
my_car = Car()

TO
print(my_car.start_engine()) # Output: Car engine started.

T
EP
C

Advantages of OOP in Python

N
O

●​ Modularity: Code is organized into smaller, manageable sections.

:C

●​ Reusability: Classes and methods can be reused across programs.

●​ Scalability: OOP makes it easier to extend and modify existing code.
N

●​ Abstraction: Hides complexity and allows focus on essential details.

O
TH

OOP Best Practices in Python

PY

●​ Follow naming conventions: Use PascalCase for class names.

ER

●​ Keep methods short and focused on a single responsibility.

●​ Use inheritance only when necessary to avoid unnecessary complexity.
D

●​ Leverage Python's built-in features, such as super(), to access parent class

N

methods.
FI
TH
PA

26
Chapter 6: Error and Exception Handling
Error and Exception Handling in Python

Error and exception handling in Python ensures that a program can deal with unexpected
situations during runtime without crashing. Python provides a structured way to handle these
situations, allowing developers to write robust and error-resilient code.

Types of Errors in Python

N
1.​ Syntax Errors:​

O
TI
●​ Occur when the Python interpreter detects incorrect syntax in the code.

EA
Example:​

R
C
print("Hello World" # Missing closing parenthesis

TO
2.​ Runtime Errors (Exceptions):​

T
EP
●​ Occur during the program's execution.
●​ Examples include division by zero, accessing a non-existent file, or using
C

undefined variables.
N
O

Example:​
:C
N

result = 10 / 0 # Division by zero

O
TH

Common Python Exceptions

PY

1.​ ValueError: Raised when a function receives an argument of the correct type but an
inappropriate value.
ER

2.​ TypeError: Raised when an operation is performed on incompatible types.

3.​ IndexError: Raised when attempting to access an index outside the range of a list or
D
N

sequence.
FI

4.​ KeyError: Raised when accessing a non-existent key in a dictionary.

5.​ ZeroDivisionError: Raised when attempting to divide by zero.
TH

6.​ FileNotFoundError: Raised when a file operation (like opening) fails because the file
PA

does not exist.

Exception Handling in Python

Python provides the try and except blocks to handle exceptions gracefully.

Basic Syntax

try:

27
 # Code that might raise an exception
except ExceptionType:
# Code to execute if the specified exception occurs

Example

try:
num = int(input("Enter a number: "))

N
O
result = 10 / num

TI
print("Result:", result)

EA
except ZeroDivisionError:
print("Error: Cannot divide by zero.")

R
except ValueError:

C
print("Error: Invalid input. Please enter a number.")

TO
T
EP
Using else
C

Code inside the else block runs only if no exceptions are raised.
N
O
:C

try:
N
O

file = open("example.txt", "r")

TH

except FileNotFoundError:
print("Error: File not found.")
PY

else:
print(file.read())
ER

file.close()
D
N
FI

Using finally
TH
PA

Code inside the finally block always executes, regardless of whether an exception
occurred.

try:
num = int(input("Enter a number: "))
result = 10 / num
print("Result:", result)
except ZeroDivisionError:

28
 print("Error: Cannot divide by zero.")
finally:
print("Execution completed.")

Raising Exceptions

You can explicitly raise exceptions using the raise statement.

N
try:

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

TI
EA
if age < 0:
raise ValueError("Age cannot be negative.")

R
except ValueError as e:

C
print("Error:", e)

TO
T
EP
Custom Exceptions
C
N
O

You can define custom exceptions by subclassing the built-in Exception class.
:C
N

class NegativeNumberError(Exception):
O
TH

pass
try:
PY

num = int(input("Enter a positive number: "))

if num < 0:
ER

raise NegativeNumberError("Negative numbers are not allowed.")

D

except NegativeNumberError as e:
N

print("Error:", e)
FI
TH
PA

Best Practices for Exception Handling

1.​ Be specific: Catch specific exceptions instead of using a general except block.
2.​ Use meaningful messages: Provide clear error messages to help debug issues.
3.​ Avoid silencing exceptions: Do not use an empty except block; always handle the
exception appropriately.
4.​ Clean up resources: Use the finally block to release resources like files or
database connections.

29
 5.​ Leverage context management: Use with statements for file handling and other
resources to ensure proper cleanup.​
with open("example.txt", "r") as file:
data = file.read()

N
O
TI
EA
R
C
TO
T
EP
C
N
O
:C
N
O
TH
PY
ER
D
N
FI
TH
PA

30
Chapter 7: Modules and Libraries
Modules and Libraries in Python

Python is a powerful programming language known for its simplicity and versatility. One of
the features that make Python highly efficient and reusable is its support for modules and
libraries. Below is an in-depth explanation of these two concepts, with additional details to
enhance understanding.

1. Modules

N
O
Definition: A module in Python is a file containing Python code, such as functions, classes,

TI
and variables, which can be reused in other Python programs. Modules help organize code

EA
into smaller, manageable, and reusable components.

R
Key Characteristics of Modules:

C
TO
●​ A module is simply a Python file with a .py extension.
●​ It allows logical organization of Python code by separating related functionalities.

T
●​ Modules can be imported into other Python scripts to reuse code, reducing
EP
redundancy.
C

Types of Modules:
N
O

1.​ Built-in Modules: These are modules that come pre-installed with Python. They
:C

cover a wide range of functionalities, from mathematical operations to system-related

N

tasks. Examples include:​

O
TH

●​ math: Provides mathematical functions.

●​ os: Interacts with the operating system.
PY

●​ sys: Accesses system-specific parameters and functions.

●​ random: Generates random numbers.
ER
D

Example:​
N

​
FI
TH

import math
print(math.sqrt(16)) # Outputs: 4.0
PA

2.​ User-defined Modules: These are custom modules created by the user. Any .py file
with Python code can act as a module when imported into another script.

Example:​

#Create a file mymodule.py:

def greet(name):

31
 return f"Hello, {name}!"

#Use the module in another script:

import mymodule
print(mymodule.greet("Alice"))

Importing Modules:

Modules can be imported in various ways:

N
O
●​ Basic Import:​

TI
EA
import math

R
●​ Import Specific Functions or Variables:​

C
TO
from math import sqrt
print(sqrt(25))

T
EP
●​ Import with Aliases:​
C
N

import math as m
O

print(m.sqrt(36))
:C
N

●​ Import All Contents (not recommended for larger modules):​

O
TH

from math import *

PY

Advantages of Modules:
ER

●​ Code Reusability: Write once and use it in multiple scripts.

D

●​ Improved Maintainability: Simplifies debugging and updates.

N

●​ Namespace Management: Prevents naming conflicts by encapsulating code in

FI

modules.
TH

Special Attributes in Modules:

PA

Modules come with special attributes such as __name__, which represents the module’s
name. When a module is executed directly, __name__ is set to "__main__".

Example:

# In mymodule.py
if __name__ == "__main__":

32
 print("This is executed directly!")

2. Libraries

Definition:

A library is a collection of modules that provide specific functionalities, such as scientific

computing, data analysis, or web development. Libraries are often more extensive and may
include multiple interrelated modules.

N
O
Key Features of Libraries:

TI
●​ They simplify complex tasks by offering pre-built solutions.

EA
●​ Libraries may depend on other libraries, forming ecosystems.

R
●​ Examples include machine learning, data visualization, and network communication

C
libraries.

TO
Popular Python Libraries:

T
1.​ NumPy:​
EP
Provides support for multi-dimensional arrays and numerical computations.
C

Example:​
N
O

import numpy as np
:C

arr = np.array([1, 2, 3, 4])

N

print(np.mean(arr)) # Outputs: 2.5

O
TH
PY

2.​ Pandas:​
Enables data manipulation and analysis through data structures like DataFrames.
ER

Example:​
D
N

import pandas as pd
FI

data = {"Name": ["Alice", "Bob"], "Age": [25, 30]}

TH

df = pd.DataFrame(data)
print(df)
PA

3.​ Matplotlib:​
Offers tools for creating static, animated, and interactive visualizations.

Example:​

import matplotlib.pyplot as plt

plt.plot([1, 2, 3], [4, 5, 6])

33
plt.show()

4.​ Requests:​
Simplifies HTTP requests to interact with APIs or web pages.

Example:​

import requests
response = requests.get("https://api.example.com")

N
print(response.status_code)

O
TI
EA
5.​ Scikit-learn:​

R
Provides tools for machine learning algorithms and models.

C
TO
Example:​

T
from sklearn.linear_model import LinearRegression
EP
model = LinearRegression()
C
N
O

Installing Libraries:
:C
N

Libraries can be installed using Python’s package manager, pip. For example:
O
TH

pip install numpy

PY

Advantages of Libraries:
ER

●​ Time-Saving: Pre-written code reduces development effort.

D

●​ Encourages Best Practices: Libraries are often created and maintained by experts.
N

●​ Supports Complex Applications: Simplifies building advanced systems.

FI
TH

Difference Between Modules and Libraries

PA

Aspect Module Library

Definition A single file containing Python A collection of modules.

code.

Scope Limited to the functionalities in the Broader, often including many

file. interrelated modules.

Examples math, os, random NumPy, Pandas, Matplotlib

34
 Aspect Module Library

Installatio No installation needed for built-in Requires installation via pip.

n modules.

Chapter 8: File Handling

N
O
TI
File handling in Python refers to the process of reading from and writing to files. Python

EA
provides built-in functions and methods to interact with different types of files, such as text
files, binary files, and more.

R
C
1. Opening a File

TO
To work with a file in Python, you must first open it using the open() function. This function

T
requires the file name and the mode in which the file is to be opened.
EP
C

file = open('example.txt', 'r') # 'r' is for reading

N
O
:C

Common file modes:

N
O

●​ 'r': Read (default)

TH

●​ 'w': Write (creates a new file or overwrites)

●​ 'a': Append
PY

●​ 'b': Binary mode (for non-text files)

ER

2. Reading from a File

D
N

Once a file is opened in the correct mode, you can read its contents using:
FI
TH

●​ read(): Reads the entire file.

PA

content = file.read()

●​ readline(): Reads one line at a time.

line = file.readline()

●​ readlines(): Returns a list of all lines.

lines = file.readlines()

35
3. Writing to a File

To write data into a file, use the write() or writelines() methods:

●​ write(): Writes a string to a file.

file = open('output.txt', 'w')

file.write('Hello, world!')

●​ writelines(): Writes a list of strings to a file.

N
O
lines = ['First line\n', 'Second line\n']

TI
file.writelines(lines)

EA
4. Closing a File

R
C
It is important to close the file after completing operations to free up system resources.

TO
file.close()

T
EP
5. Using with Statement
C
N

Using the with statement automatically handles file closing and prevents errors if an
O

exception occurs.
:C

with open('example.txt', 'r') as file:

N

content = file.read()
O
TH

6. File Operations:
PY

●​ File Seek: Moves the pointer to a specific location in the file.

ER

file.seek(0) # Moves to the start of the file

D
N

●​ File Tell: Returns the current position of the file pointer.

FI
TH

position = file.tell()
PA

7. Error Handling

File handling operations might throw exceptions like FileNotFoundError, which can be
handled using try-except blocks.

try:
file = open('nonexistent.txt', 'r')
except FileNotFoundError:
print("File not found.")

36
 PA
TH
FI
N
D
ER
PY
TH
O
N
:C
O
N
C
EP
T
TO
C
R
EA
TI
O
N

37
Chapter 9: Advanced Topics
This chapter introduces three advanced techniques that improve the efficiency and
readability of Python code:

1.​ List Comprehensions:

○​ This feature provides a concise way to create lists based on existing
sequences, such as iterating over a range or filtering elements.
○​ Example: [x**2 for x in range(10)] generates a list of squares of
numbers from 0 to 9. It's an efficient and more readable way to generate lists

N
compared to using a loop.

O
2.​ Generators:

TI
○​ A generator yields items one at a time, saving memory by generating values

EA
only when they are needed, instead of storing all items in memory.
○​ Example: A function with the yield keyword produces a generator object.

R
C
When iterated, it returns values one at a time. This is useful when dealing
with large datasets.

TO
3.​ Decorators:
○​ Decorators modify or extend the behavior of functions or methods without

T
changing their actual code. They are commonly used for logging,
EP
authentication, or enforcing rules.
C

○​ Example: The @decorator syntax applies a decorator to a function,

N

allowing extra behavior before or after the function call, such as printing
O

messages in the case of the say_hello function.

:C
N
O
TH
PY
ER
D
N
FI
TH
PA

38
Conclusion:
This Book now provides a detailed exploration of Python, making it suitable for both
beginners and experienced programmers to Continue practicing the examples and exploring
Python's vast ecosystem to enhance your skills! Python has cemented its place as one of
the most versatile and powerful programming languages of the modern era. Its simplicity and
readability make it an excellent choice for beginners, while its extensive libraries and
frameworks enable professionals to tackle complex projects. From web development to
machine learning, Python provides tools and resources to turn ideas into reality.

N
As you continue your Python journey, remember to practice consistently, explore real-world

O
projects, and engage with the vibrant Python community. With dedication and curiosity, you

TI
can unlock Python's full potential and make a meaningful impact in the tech world.

EA
R
C
TO
T
EP
C
N
O
:C
N
O
TH
PY
ER
D
N
FI
TH
PA

39
Appendix A: Python Cheat Sheet
●​ Data Types: int, float, str, list, tuple, dict, set, bool
●​ Common Functions: len(), print(), type(), range()
●​ String Methods: upper(), lower(), split(), join()
●​ List Methods: append(), remove(), pop(), sort()
●​ Dictionary Methods: keys(), values(), items()
●​ File Handling: open(), read(), write()
●​ Control Structures: if, elif, else, for, while

N
O
TI
EA
Appendix B: Further Resources

R
C
●​ Official Documentation: Python.org
●​ Online Tutorials: Codecademy, W3Schools, Real Python

TO
●​ Books: "Automate the Boring Stuff with Python", "Python Crash Course"

T
EP
C
N
O
:C
N
O
TH
PY
ER
D
N
FI
TH
PA

40