Overview

This course is designed to teach you Python programming from the basics to advanced
topics. You will learn about the syntax, data structures, functions, object-oriented
programming, file handling, error handling, and additional topics like regular expressions
and popular Python libraries. By the end of this course, you will be able to write Python
programs and develop applications with ease.

01

01 Module 1: Installing Python on Windows, macOS, and Linux

Python is a popular programming language known for its simplicity and versatility.
Before you can start coding in Python, you need to install it on your computer. In this
module, we will guide you through the installation process on different operating systems:
Windows, macOS, and Linux.

Installing Python on Windows

To install Python on Windows, follow these steps:

Download Python: Visit the official Python website at https://www.python.org/ and click on the
"Downloads" tab. Choose the latest stable version suitable for your Windows architecture (32-bit
or 64-bit).

Run the Installer: Once the installer is downloaded, run it. During the installation process, make sure
to check the box that says "Add Python X.X to PATH". This will add Python to your system's PATH,
allowing you to run Python from the command line easily. Click "Install Now" to proceed with the
installation.

Verify Installation: After the installation is complete, open the Command Prompt (CMD) and type
python --version or python3 --version to verify the installation. You should see the
installed Python version displayed on the screen.

Installing Python on macOS

To install Python on macOS, follow these steps:

Download Python: Visit the official Python website at https://www.python.org/ and click on the
"Downloads" tab. Choose the latest stable version suitable for macOS.

Run the Installer: Once the installer is downloaded, run it and follow the prompts in the installer.
Make sure to check the box that says "Add Python X.X to PATH" (X.X represents the version)
during the installation process.

Verify Installation: Open the Terminal and type python3 --version to check the installed
Python version. You should see the version displayed on the screen.
Installing Python on Linux
To install Python on Linux, follow these steps:

Install Python via Package Manager: Python is usually pre-installed on many Linux distributions. If
not, you can use your package manager to install Python. For
Ubuntu/Debian, use the following command: sudo apt-get update && sudo aptget
install python3. For CentOS/Fedora, use the following command: sudo yum install
python3.

Verify Installation: Open the Terminal and type python3 --version to check the installed
Python version. You should see the version displayed on the screen.

Summary
In this module, we learned how to install Python on different operating systems: Windows,
macOS, and Linux. By following the installation steps specific to your operating system,
you can set up Python and start coding in this versatile programming language.

Conclusion Module 1 Installing Python on Windows, macOS, and Linux

Module 1: Installing Python on Windows, macOS, and Linux Module

1 focused on the installation process of Python on different
operating systems. You learned how to download
Python from the official website and set up the development
environment. Whether you are using Windows, macOS, or
Module 2: Setting up the
Development Environment

02 Module 2: Setting up the Development Environment

In this module, we will learn how to set up the development environment for Python
programming. A well-configured development environment is essential for writing, testing,
and running Python code efficiently. We will cover the installation of Python, choosing a
text editor or integrated development environment (IDE), and creating virtual
environments for project isolation.
Installing Python
Python is an open-source programming language that is widely used for various
applications. Before we can start coding in Python, we need to install it on our computer.
Here are the steps to install Python on different operating systems:

Windows

Download Python:
Visit the official Python website at https://www.python.org/.
Click on the "Downloads" tab.
Choose the latest stable version suitable for your Windows architecture (32-bit or 64bit).

Run the Installer:

Once the installer is downloaded, run it.
During the installation process, check the box that says "Add Python X.X to PATH". This ensures
that Python is added to your system's PATH, allowing you to run Python from the command line
easily.
Click "Install Now" to proceed with the installation.

Verify Installation:
Open Command Prompt (CMD) and type python --version or python3 --version to
verify the installation. You should see the installed Python version.

macOS

Download Python:
Visit the official Python website at https://www.python.org/.
Click on the "Downloads" tab.
Choose the latest stable version suitable for macOS.

Run the Installer:

Once the installer is downloaded, run it and follow the prompts in the installer.
Ensure that the box "Add Python X.X to PATH" (X.X represents the version) is checked.
Verify Installation:
 Open Terminal and type python3 --version to check the installed Python version.

Linux

Install Python via Package Manager:

Python is usually pre-installed on many Linux distributions. If not, you can use your package
manager to install Python.
For Ubuntu/Debian: sudo apt-get update && sudo apt-get install python3
For CentOS/Fedora: sudo yum install python3

Verify Installation:
Open Terminal and type python3 --version to check the installed Python version.

Setting up a Development Environment

Once Python is installed, we need to set up a development environment to write and run
Python code. Here are the key components of a Python development environment:

Text Editor or Integrated Development Environment (IDE)

A text editor or an IDE is used to write and edit Python code. There are several options
available, and you can choose the one that suits your preferences. Here are some popular
choices:

Text Editors:
Visual Studio Code (VSCode)
Sublime Text Atom

IDEs:
PyCharm
Spyder
Jupyter Notebooks (primarily for data analysis)
Choose a text editor or IDE that you are comfortable with and install it on your computer.

Virtual Environments (Optional but Recommended)

Virtual environments are used to create isolated Python environments for different
projects. They allow you to install project-specific dependencies without interfering with
the global Python installation. Here's how you can create a virtual environment using the
built-in venv module:

Open a terminal or command prompt.

Create a virtual environment:

Windows: python3 -m venv myenv
macOS/Linux: python3 -m venv myenv

Activate the virtual environment:

Windows: myenv\Scripts\activate
macOS/Linux: source myenv/bin/activate

Once the virtual environment is activated, any Python packages you install will be isolated
within that environment.

Package Manager - pip

pip is the default package manager for Python. It allows you to install, upgrade,
and manage Python packages and libraries. Here's how you can use pip to install Python
packages:
To install a package: pip install package_name
 To upgrade a package: pip install --upgrade package_name
To uninstall a package: pip uninstall package_name

Make sure to run these commands within the activated virtual environment if you are
using one.

Version Control (Optional)

Consider using Git for version control of your Python projects. Git allows you to track
changes, collaborate with others, and revert to previous versions of your code if needed.
You can install Git from the official website at https://gitscm.com/.

Conclusion Module 2 Setting up the Development Environment

Module 2: Setting up the Development Environment In

Module 2, you learned about the essential tools for setting up a
Python development environment. You explored different text
editors and integrated development
environments (IDEs) that can be used to write Python code.
Additionally, you discovered the benefits of using virtual
environments and package managers like pip. With a properly
configured development environment, you are now ready to write
and run Python code efficiently.
 03 Module 3: Introduction to Python

Basic Syntax
Indentation

Python uses indentation to define code blocks instead of curly braces or keywords like end
or done in other languages. It is important to use consistent indentation to indicate blocks
of code, such as in loops, conditionals, and functions.
 # Example of indentation
if condition:
# code block
statement1
statement2
else:
# code block
statement3
statement4

Comments

# This is a single-line comment

'''
This is a
multi-line comment
'''

Variables and Data Types

Variables

Variables are used to store values in Python. Unlike other programming languages,
Python uses dynamic typing, which means you don't need to declare the data
type explicitly. You can assign a value to a variable using the assignment operator
 =

# Example of variable assignment

x = 10
name = "John"

Data Types

Python supports various data types, including:

# Examples of different data types

age = 25 # integer
height = 1.75 # float
name = "John" # string
is_student = True # boolean

my_list = [1, 2, 3] # list

my_tuple = (4, 5, 6) # tuple
my_dict = {"name": "John", "age": 25} # dictionary
Operators and Expressions
Arithmetic Operators

Arithmetic operators are used to perform mathematical operations in Python.

# Examples of arithmetic operators

x = 10 + 5 # addition
y = 10 - 5 # subtraction
z = 10 * 5 # multiplication
w = 10 / 5 # division
r = 10 % 3 # modulus
s = 2 ** 3 # exponentiation

Comparison Operators

Comparison operators are used to compare values and return a boolean result.

Equal to: ==

Not equal to: !=

Less than: <

 >

# Examples of comparison operators

x = 10 == 5 # equal to
y = 10 != 5 # not equal to
z = 10 < 5 # less than
w = 10 > 5 # greater than
r = 10 <= 5 # less than or equal to
s = 10 >= 5 # greater than or equal to

Logical Operators

Logical operators are used to combine boolean values and perform logical operations.

# Examples of logical operators

x = True and False # and
y = True or False # or
z = not True # not

Expressions

Expressions are combinations of values, variables, and operators that produce a result.
They follow the order of operations, also known as PEMDAS/BODMAS
(Parentheses/Brackets, Exponents/Orders, Multiplication and Division, Addition and
Subtraction).
 # Examples of expressions
x = (10 + 5) * 2 # parentheses
y = 2 ** 3 + 4 * 5 # exponentiation and multiplication
z = 10 / (2 + 3) # division and addition

Input and Output

Input

The input() function is used to get user input in Python. It prompts the user to enter a
value and returns it as a string.

# Example of input
name = input("Enter your name: ")

Output

The print() function is used to display output to the console. It can print strings, variables,
and expressions.

# Example of output
print("Hello, World!")
print(name)
print(10 + 5)

These concepts provide a solid foundation for understanding the basic syntax, variables,
data types, operators, expressions, and input/output in Python. Practice using these
concepts in your code to become more comfortable with the language.
 Conclusion Module 3 Introduction to Python

Module 3: Introduction to Python In Module 1, you were

introduced to the fundamentals of Python programming. You
learned about the overview of Python, why it is popular, and how
to install Python on different operating systems. You
also gained knowledge about basic syntax, variables, data
types, and input/output operations. This module provided a solid
foundation for your journey into Python programming.
 04 Module 4: Basic Syntax of Python

In this module, we will explore the basic syntax of the Python programming language.
Understanding the syntax is crucial as it forms the foundation for writing correct and
efficient Python code. We will cover topics such as indentation, comments, variables and
data types, operators and expressions, and input and output.

Indentation
Python uses indentation to define code blocks instead of curly braces or keywords like
"end" or "done" in other programming languages. Consistent indentation is essential to
indicate blocks of code, such as loops, conditionals, and functions. It is recommended to
use four spaces for indentation, although some developers prefer using tabs.
Example:

if condition:
# code block 1
statement1
statement2
else:
# code block 2
statement3
statement4

Comments
Comments are essential for documenting code and making it more readable. In Python,
single-line comments start with the # symbol, while multi-line comments are enclosed
between triple quotes ( ''' or """ ).

Example:

# This is a single-line comment

'''
This is a multi-line comment.
It can span multiple lines.
'''

"""
This is also a multi-line comment.
"""

Variables and Data Types

Variables are used to store values in Python. Unlike some other programming languages,
Python uses dynamic typing, which means you don't need to declare the data type
explicitly. The data type of a variable is determined based on the value assigned to it.
Example:

# Integer variable
age = 25

# Float variable
pi = 3.14

# String variable
name = "John Doe"

# Boolean variable
is_student = True

Python supports various data types, including integers, floats, strings, booleans, lists,
tuples, and dictionaries. Understanding these data types is crucial for manipulating and
working with different kinds of data.

Operators and Expressions

Python provides a wide range of operators for performing arithmetic, comparison, logical,
and other operations. Arithmetic operators include addition ( + ), subtraction ( - ),
multiplication ( * ), division ( / ), modulus ( % ), and exponentiation ( ** ). Comparison
operators include equal to ( == ), not equal to ( != ), less than ( < ), greater than ( > ), less
than or equal to ( <= ), and greater than or equal to ( >= ). Logical operators include and , or
, and not for boolean operations.

Expressions in Python are combinations of values, variables, and operators that produce a
result. They follow the order of operations, also known as
PEMDAS/BODMAS (Parentheses/Brackets, Exponents/Orders, Multiplication and Division,
Addition and Subtraction).
Example:

# Arithmetic expressions
result = 5 + 3 * 2 # 11
result = (5 + 3) * 2 # 16

# Comparison expressions
is_equal = 5 == 3 # False
is_greater = 5 > 3 # True

# Logical expressions
is_valid = (5 > 3) and (10 < 20) # True
is_invalid = (5 > 3) and (10 > 20) # False

Input and Output

Input and output operations are essential for interacting with users and displaying
information. In Python, we can use the input() function to get user input, which returns a
string. The print() function is used to display output to the console.

Example:

# Input
name = input("Enter your name: ")
age = int(input("Enter your age: ")) # Convert input to integer

# Output
print("Hello, " + name + "! You are " + str(age) + " years old.")

These are the fundamental concepts of the basic syntax in Python.

Understanding and practicing these concepts will enable you to write correct and efficient
Python code. In the next module, we will explore data structures in Python, such as lists,
tuples, and dictionaries.
 Conclusion Module 4 Basic Syntax of Python

Module 4: Basic Syntax of Python Module 4 covered the basic

syntax of Python programming. You learned about indentation,
comments, variables, and data types.
Understanding these fundamental concepts is crucial for writing
clean and readable code. By practicing the concepts taught in this
module, you will be able to write Python programs that are easy to
understand and maintain.

Module 5: Variables and

Data Types

05 Module 5: Variables and Data Types

In this module, we will explore the concept of variables and data types in Python. Variables
are used to store and manipulate data, while data types define the nature of the data
being stored. Understanding variables and data types is essential for writing effective and
efficient Python programs.

Variables
A variable is a named location in the computer's memory that can hold a value. In Python,
variables are created by assigning a value to a name using the assignment operator (=). For
example:

x = 10

In the above example, we create a variable named x and assign it the value 10 . Variables
can store different types of data, such as numbers, strings, or even complex objects.

Variable Naming Rules

When naming variables in Python, there are a few rules to follow:

Variable names must start with a letter or an underscore (_).

Variable names can only contain letters, numbers, and underscores.

Variable names are case-sensitive, meaning x and X are considered different variables.

It is good practice to choose meaningful and descriptive names for variables to improve
code readability.

Data Types
Python has several built-in data types that define the nature of the data being stored in
variables. The most commonly used data types include:
1. Numeric Types

Python supports three numeric types: integers, floats, and complex numbers.

Integers: Integers are whole numbers without a fractional part. For example, 10 and -5 are

integers.

Floats: Floats are numbers with a decimal point or an exponent. For example, 3.14 and -2.5 are

floats.
Complex Numbers: Complex numbers are numbers with a real and imaginary part. They are
written in the form a + bj, where a is the real part and b is the imaginary part.

2. Strings

Strings are sequences of characters enclosed in single quotes ('') or double quotes ("").
They are used to represent text in Python. For example:

name = "John Doe"

3. Booleans

Booleans represent the truth values True and False . They are used for logical operations
and comparisons. For example:

is_raining = True

4. Lists

Lists are ordered collections of items enclosed in square brackets ([]). They can contain
elements of different data types and can be modified (mutable). For example:

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

of strings.

5. Tuples

Tuples are similar to lists but are immutable, meaning they cannot be modified once
created. They are enclosed in parentheses (()). For example:

point = (3, 5)

tuple of two integers.

6. Dictionaries

Dictionaries are unordered collections of key-value pairs enclosed in curly braces ({}). Each
key-value pair is separated by a colon (:). Dictionaries are used to store and retrieve data
based on keys. For example:

person = {"name": "John", "age": 25, "city": "New York"}

In the above example, we create a dictionary variable named person and assign it key-value
pairs representing a person's name, age, and city.

Type Conversion
Python provides built-in functions to convert data from one type to another. This is known
as type conversion or type casting. Some commonly used type conversion functions
include:

int(): Converts a value to an integer.

float(): Converts a value to a float. str():

Converts a value to a string. list(): Converts

a value to a list. tuple(): Converts a value to

a tuple. dict(): Converts a value to a

dictionary.

Type conversion is useful when performing operations that require data of a specific type
or when combining data of different types.
Summary
In this module, we explored the concept of variables and data types in Python. Variables
are named locations in memory that store data, and data types define the nature of the
data being stored. Python supports various data types, including numeric types, strings,
booleans, lists, tuples, and dictionaries. Understanding variables and data types is crucial
for writing effective and efficient Python programs.

Module 5: Variables and Data Types In Module 5, you delved

deeper into variables and data types in Python. You learned about
common data types such as integers, floats, strings,
booleans, lists, tuples, and dictionaries. Understanding how
to work with different data types is essential for manipulating
and storing data effectively. With the knowledge gained in this
module, you can now handle various types of data in your Python
programs.
 06 Module 6: Functions and Modules

In this module, we will explore the concepts of functions and modules in Python. Functions
are blocks of reusable code that perform specific tasks, while modules are files containing
Python definitions, functions, and statements that help organize code into reusable
components.

Functions
Defining Functions

Functions in Python are defined using the def keyword followed by the function name and
parentheses. They can take parameters (arguments) and perform a specific task.
 def greet(name):
print("Hello, " + name + "!")

def add_numbers(a, b):

return a + b

Function Arguments and Parameters

Functions can take parameters to accept input data. There are two types of function
arguments: positional arguments and keyword arguments.

Positional Arguments: Arguments passed to a function based on their position.

def greet(name, age):

print("Hello, " + name + "! You are " + str(age) + " years old.")

greet("Alice", 25)

Keyword Arguments: Arguments identified by their parameter names.

def greet(name, age):

print("Hello, " + name + "! You are " + str(age) + " years old.")

greet(age=25, name="Alice")

Lambda Functions

Lambda functions, also known as anonymous functions, are defined using the lambda
keyword. They are typically used for short, simple operations.

add_numbers = lambda a, b: a + b
Modules and Packages
Modules

Modules are Python files containing Python definitions, functions, and statements.
They are used to organize code into files for better maintainability.

Creating Modules

To create a module, write functions or code in a Python file and import it into another
Python script.

# math_operations.py
def add(a, b):
return a + b

def subtract(a, b):

return a - b

# main.py
import math_operations

result = math_operations.add(5, 3)
print(result)

Packages

Packages are collections of modules organized into directories. They help in better
structuring large codebases.
 my_package/
├── __init__.py
├── module1.py
└── module2.py

Importing from Packages

To import modules or specific functions/classes from packages, use the import statement.

from my_package import module1

result = module1.add(5, 3)
print(result)

Summary
In this module, we explored the concepts of functions and modules in Python. Functions
are blocks of reusable code that perform specific tasks, while modules are files containing
Python definitions, functions, and statements that help organize code into reusable
components.

We learned how to define functions, use different types of function arguments, create
modules, and import them into other Python scripts. Additionally, we explored the
concept of lambda functions and how they can be used for simple operations.

Understanding functions and modules is essential for writing modular and reusable code in
Python. Practicing the concepts covered in this module will enhance your ability to create
and use functions, as well as organize your code into modules and packages.
 Conclusion Module 7 Functions and Modules

Module 7: Functions and Modules Module 7 introduced you to the

concepts of functions and modules in Python. You
learned how to define functions, pass arguments, and use lambda
functions for simple operations. Additionally, you
explored the creation and usage of modules and packages, which
allow you to organize and reuse your code effectively.
With the knowledge gained in this module, you can write modular
and reusable Python code.

07 Module 7: Control Flow

Control flow refers to the order in which statements are executed in a program. In Python,
control flow is managed through various control structures, such as conditional
statements and loops, which allow you to make decisions and repeat actions based on
certain conditions. Understanding control flow is essential for writing efficient and flexible
programs.

Conditional Statements
Conditional statements allow you to execute different blocks of code based on certain
conditions. In Python, the most commonly used conditional statements are the if , elif ,
and else statements.

if Statement

The if statement is used to execute a block of code if a condition is true. It follows the
syntax:

if condition:
# code to be executed if condition is true

For example, let's say we want to check if a number is positive:

num = 10

if num > 0:
print("The number is positive")

if-else Statement

The if-else statement allows you to execute one block of code if a condition is true, and
another block of code if the condition is false. It follows the syntax:

if condition:
# code to be executed if condition is true
 else:
# code to be executed if condition is false

For example, let's say we want to check if a number is positive or negative:

num = -5

if num > 0:
print("The number is positive")
else:
print("The number is negative")

if-elif-else Statement

The if-elif-else statement allows you to check multiple conditions and execute different
blocks of code based on the first condition that is true. It follows the syntax:

if condition1:
# code to be executed if condition1 is true
elif condition2:
# code to be executed if condition2 is true
else:
# code to be executed if all conditions are false

For example, let's say we want to check if a number is positive, negative, or zero:

num = 0
 if num > 0:
print("The number is positive")
elif num < 0:
print("The number is negative")
else:
print("The number is zero")

In this example, if the condition num > 0 is true, the code inside the first if block will be
executed. If that condition is false and the condition num < 0 is true, the code inside the
elif block will be executed. If both conditions are false, the code inside the else block will
be executed.

Loops
Loops allow you to repeat a block of code multiple times. In Python, there are two types of
loops: for loops and while loops.

for Loop

The for loop is used to iterate over a sequence (such as a list, tuple, string, or range) or an
iterable object. It follows the syntax:

for item in sequence:

# code to be executed for each item in the sequence

For example, let's say we want to print each element in a list:

fruits = ["apple", "banana", "orange"]
 for fruit in fruits:
print(fruit)

while Loop

The while loop is used to repeatedly execute a block of code as long as a condition is true.
It follows the syntax:

while condition:
# code to be executed as long as the condition is true

count = 1

while count <= 5:

print(count)
count += 1

break and continue Statements

The break statement is used to terminate a loop prematurely when a certain condition is
met. It allows you to exit the loop and continue with the next statement after the loop. For
example:
 fruits = ["apple", "banana", "orange"]

for fruit in fruits:

if fruit == "banana":
break
print(fruit)

In this example, the loop will terminate when the fruit variable is equal to
"banana", and the code will continue with the next statement after the loop.

The continue statement is used to skip the current iteration of a loop and continue with the
next iteration. For example:

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

for fruit in fruits:

if fruit == "banana":
continue
print(fruit)

In this example, when the fruit variable is equal to "banana", the current iteration will be
skipped, and the loop will continue with the next iteration.

These control flow structures allow you to make decisions, iterate through sequences, and
control the flow of execution in your Python programs. Experimenting with different
conditions and loops will help solidify your understanding of these concepts.
Conclusion Module 7 Control Flow

Module 7: Control Flow Module 6 focused on control flow in

 Python. You learned about conditional statements such as if, elif,
and else, as well as loops like for and while. Additionally, you
explored the concepts of break and continue
statements. Understanding control flow is crucial for making
decisions and iterating through sequences in your programs.
By mastering control flow, you can create more dynamic and
interactive Python applications.

08 Module 8: File Handling and Error Handling

In this module, we will explore the concepts of file handling and error handling in Python.
File handling allows us to work with files, such as reading from and writing to them, while
error handling helps us manage and handle potential errors that may occur during
program execution.
File Handling
Opening and Closing Files

To work with files in Python, we need to open them using the open() function. This
function takes the filename and the mode in which we want to open the file as
parameters. The mode can be 'r' for reading, 'w' for writing, 'a' for appending, and more.

# Opening a file for reading

file = open('filename.txt', 'r')

# Closing the file

file.close()

Reading Text Files

To read the contents of a text file, we can use the read() or readline() methods. The
read() method reads the entire file, while the readline() method reads one line at a time.

# Reading from a file

file = open('filename.txt', 'r')
content = file.read()
print(content)
file.close()
Writing Text Files

To write to a text file, we can use the write() method. This method allows us to write
content to the file. If the file does not exist, it will be created. If it already exists, the
existing content will be overwritten.

# Writing to a file
file = open('filename.txt', 'w')
file.write('Hello, world!')
file.close()

Working with File Paths

When working with files, it is important to handle file paths properly. We can use the
os.path module or the pathlib module to handle file paths. These modules provide
functions and classes to manipulate file paths.

import os.path

# Working with file paths

path = os.path.join('folder', 'filename.txt')
print(path)

Error Handling
Handling Exceptions

In Python, we can handle exceptions using try-except blocks. A try block contains the code
that might raise an exception, while an except block handles the exception if it occurs.
 try:
# Code that might raise an exception
result = 10 / 0
except ZeroDivisionError:
# Handling the ZeroDivisionError exception
print("Cannot divide by zero")

Handling Specific Exceptions

We can handle specific exceptions by specifying the type of exception in the except block.
This allows us to handle different errors differently.

try:
# Code that might raise an exception
file = open('filename.txt', 'r')
except FileNotFoundError:
# Handling the FileNotFoundError exception
print("File not found")

Using Finally Block

The finally block is used to specify code that should be executed regardless of whether an
exception occurs or not. This block is useful for cleaning up resources or performing
necessary actions.

try:
# Code that might raise an exception
file = open('filename.txt', 'r')
except FileNotFoundError:
# Handling the FileNotFoundError exception
print("File not found")
finally:
# Code that should be executed regardless of exceptions
file.close()
Summary
In this module, we learned about file handling and error handling in Python. File handling
allows us to work with files, such as reading from and writing to them. Error handling helps
us manage and handle potential errors that may occur during program execution. By
understanding these concepts, we can effectively work with files and handle exceptions in
our Python programs.

Conclusion Module 8 File Handling and Error Handling

Module 8: File Handling and Error Handling In Module 8, you

learned about file handling and error handling in Python. You
discovered how to read and write files, work with file paths,
and parse CSV and JSON data. Additionally, you explored error
handling techniques using try-except blocks and
handling specific exceptions. Understanding file handling
and error handling is crucial for working with external data and
ensuring the robustness of your programs.
 09 Practical Exercises

In the this lesson, we'll put theory into practice through hands-on activities. Click on the
items below to check each exercise and develop practical skills that will help you succeed
in the subject.
10

Module 1: Introduction to Python In Module 1, you were introduced to the

fundamentals of Python programming. You learned about the overview of Python,
why it is popular, and how to install Python on different operating systems. You also
gained knowledge about basic syntax, variables, data types, and input/output
operations. This module provided a solid foundation for your journey into Python
programming.

Module 2: Installing Python on Windows, macOS, and Linux Module 2 focused on the
installation process of Python on different operating systems. You learned how to
download Python from the official website and set up the development
environment. Whether you are using Windows, macOS, or Linux, you now have the
necessary knowledge to install Python and start coding.
Module 3: Setting up the Development Environment In Module 3, you learned about
the essential tools for setting up a Python development environment. You explored
different text editors and integrated development environments (IDEs) that can be
used to write Python code. Additionally, you discovered the benefits of using virtual
environments and package managers like pip. With a properly configured
development environment, you are now ready to write and run Python code
efficiently.

Module 4: Basic Syntax of Python Module 4 covered the basic syntax of Python
programming. You learned about indentation, comments, variables, and data types.
Understanding these fundamental concepts is crucial for writing clean and readable
code. By practicing the concepts taught in this module, you will be able to write
Python programs that are easy to understand and maintain.

Module 5: Variables and Data Types In Module 5, you delved deeper into variables and
data types in Python. You learned about common data types such as integers, floats,
strings, booleans, lists, tuples, and dictionaries. Understanding how to work with
different data types is essential for manipulating and storing data effectively. With
the knowledge gained in this module, you can now handle various types of data in
your Python programs.

Module 6: Control Flow Module 6 focused on control flow in Python. You learned
about conditional statements such as if, elif, and else, as well as loops like for and
while. Additionally, you explored the concepts of break and continue statements.
Understanding control flow is crucial for making decisions and iterating through
sequences in your programs. By mastering control flow, you can create more
dynamic and interactive Python applications.

Module 7: Functions and Modules Module 7 introduced you to the concepts of

functions and modules in Python. You learned how to define functions, pass
arguments, and use lambda functions for simple operations. Additionally, you
 explored the creation and usage of modules and packages, which allow you to
organize and reuse your code effectively. With the knowledge gained in this module,
you can write modular and reusable Python code.

Module 8: File Handling and Error Handling In Module 8, you learned about file
handling and error handling in Python. You discovered how to read and write files,
work with file paths, and parse CSV and JSON data. Additionally, you explored error
handling techniques using try-except blocks and handling specific exceptions.
Understanding file handling and error handling is crucial for working with external
data and ensuring the robustness of your programs.

11
Question 1: Calculate the area of a rectangle

python
Copy code
def rectangle_area(length, width):
area = length * width
return area

# Example usage
length = float(input("Enter the length of the rectangle: "))
width = float(input("Enter the width of the rectangle: "))
result = rectangle_area(length, width)
print("The area of the rectangle is:", result)

Question 2: Check if a number is even or odd

python
Copy code
def check_even_odd(number):
if number % 2 == 0:
return "Even"
else:
return "Odd"

# Example usage
num = int(input("Enter a number: "))
result = check_even_odd(num)
print(f"The number is {result}.")

Question 3: Find the maximum of three numbers

python
Copy code
def find_maximum(a, b, c):
return max(a, b, c)

# Example usage
num1 = float(input("Enter the first number: "))
num2 = float(input("Enter the second number: "))
num3 = float(input("Enter the third number: "))
result = find_maximum(num1, num2, num3)
print("The maximum number is:", result)

Question 4: Swap the values of two variables

python
Copy code
def swap_variables(a, b):
a, b = b, a
return a, b

# Example usage
var1 = input("Enter the first variable: ")
var2 = input("Enter the second variable: ")
result1, result2 = swap_variables(var1, var2)
print("After swapping, variable 1:", result1)
print("After swapping, variable 2:", result2)

Question 5: Check if a year is a leap year

python
Copy code
def is_leap_year(year):
if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
return True
else:
return False

# Example usage
year = int(input("Enter a year: "))
if is_leap_year(year):
print(f"{year} is a leap year.")
else:
print(f"{year} is not a leap year.")

Question 6: Convert Celsius to Fahrenheit

python
Copy code
def celsius_to_fahrenheit(celsius):
fahrenheit = (celsius * 9/5) + 32
return fahrenheit

# Example usage
temp_celsius = float(input("Enter the temperature in Celsius: "))
temp_fahrenheit = celsius_to_fahrenheit(temp_celsius)
print(f"The temperature in Fahrenheit is: {temp_fahrenheit:.2f}")

Question 7: Basic calculator program

python
Copy code
def calculator(num1, num2, operator):
if operator == '+':
return num1 + num2
elif operator == '-':
return num1 - num2
elif operator == '*':
return num1 * num2
elif operator == '/':
return num1 / num2
else:
return "Invalid operator"

# Example usage
number1 = float(input("Enter the first number: "))
number2 = float(input("Enter the second number: "))
op = input("Enter the operator (+, -, *, /): ")
result = calculator(number1, number2, op)
print(f"The result is: {result}")

Question 8: Print the first 10 natural numbers

python
Copy code
for i in range(1, 11):
print(i)

Question 9: Find the factorial of a number

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

# Example usage
num = int(input("Enter a number: "))
result = factorial(num)
print(f"The factorial of {num} is: {result}")
Question 10: Guess-the-number game

python
Copy code
import random

def guess_the_number():
secret_number = random.randint(1, 100)
attempts = 0

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

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

# Example usage
guess_the_number()
Question 11: Check if a string is a palindrome

python
Copy code
def is_palindrome(s):
s = s.lower()
return s == s[::-1]

# Example usage
string = input("Enter a string: ")
if is_palindrome(string):
print("The string is a palindrome.")
else:
print("The string is not a palindrome.")

Question 12: Find the length of a list

python
Copy code
def list_length(lst):
return len(lst)

# Example usage
my_list = [1, 2, 3, 4, 5]
result = list_length(my_list)
print(f"The length of the list is: {result}")
Question 13: Count the occurrences of a character in a string

python
Copy code
def count_char_occurrences(s, char):
return s.count(char)

# Example usage
string = input("Enter a string: ")
character = input("Enter a character: ")
result = count_char_occurrences(string, character)
print(f"The character '{character}' appears {result} times in the string.")

Question 14: Reverse a list

python
Copy code
def reverse_list(lst):
return lst[::-1]

# Example usage
my_list = [1, 2, 3, 4, 5]
result = reverse_list(my_list)
print("Reversed list:", result)
Question 15: Concatenate two lists

python
Copy code
def concatenate_lists(list1, list2):
return list1 + list2

# Example usage
list_a = [1, 2, 3]
list_b = [4, 5, 6]
result = concatenate_lists(list_a, list_b)
print("Concatenated list:", result)

Question 16: Remove duplicates from a list

python
Copy code
def remove_duplicates(lst):
return list(set(lst))

# Example usage
my_list = [1, 2, 2, 3, 4, 4, 5]
result = remove_duplicates(my_list)
print("List with duplicates removed:", result)
Question 17: Find the smallest element in a list

python
Copy code
def find_smallest_element(lst):
return min(lst)

# Example usage
my_list = [5, 2, 8, 1, 7]
result = find_smallest_element(my_list)
print("The smallest element in the list is:", result)

Question 18: Check if a number is prime

python
Copy code
def is_prime(num):
if num < 2:
return False
for i in range(2, int(num**0.5) + 1):
if num % i == 0:
return False
return True

# Example usage
number = int(input("Enter a number: "))
if is_prime(number):
print(f"{number} is a prime number.")
else:
print(f"{number} is not a prime number.")

Question 19: Generate the Fibonacci sequence up to n terms

python
Copy code
def fibonacci_sequence(n):
sequence = [0, 1]
while len(sequence) < n:
sequence.append(sequence[-1] + sequence[-2])
return sequence

# Example usage
terms = int(input("Enter the number of Fibonacci terms to generate: "))
result = fibonacci_sequence(terms)
print("Fibonacci sequence:", result)

Question 20: Check if a number is a perfect square

python
Copy code
def is_perfect_square(num):
return num > 0 and (int(num**0.5))**2 == num
# Example usage
number = int(input("Enter a number: "))
if is_perfect_square(number):
print(f"{number} is a perfect square.")
else:
print(f"{number} is not a perfect square.")

Question 21: Find the common elements between two lists

python
Copy code
def common_elements(list1, list2):
return list(set(list1) & set(list2))

# Example usage
list_a = [1, 2, 3, 4]
list_b = [3, 4, 5, 6]
result = common_elements(list_a, list_b)
print("Common elements:", result)

Question 22: Count the number of vowels in a string

python
Copy code
def count_vowels(s):
 vowels = "aeiouAEIOU"
return sum(1 for char in s if char in vowels)

# Example usage
string = input("Enter a string: ")
result = count_vowels(string)
print(f"The number of vowels in the string is: {result}")

Question 23: Calculate the LCM of two numbers

python
Copy code
def calculate_lcm(x, y):
from math import gcd
return abs(x * y) // gcd(x, y)

# Example usage
num1 = int(input("Enter the first number: "))
num2 = int(input("Enter the second number: "))
result = calculate_lcm(num1, num2)
print(f"The LCM of {num1} and {num2} is: {result}")

Question 24: Extract the file extension from a filename

python
Copy code
def extract_file_extension(filename):
 return filename.split('.')[-1]

# Example usage
file_name = input("Enter a filename: ")
result = extract_file_extension(file_name)
print(f"The file extension is: {result}")

Question 25: Find and print the largest element in a list

python
Copy code
def find_largest_element(lst):
return max(lst)

# Example usage
my_list = [10, 5, 8, 15, 3]
result = find_largest_element(my_list)
print("The largest element in the list is:", result)

Question 26: Check if a string has balanced parentheses

python
Copy code
def balanced_parentheses(s):
stack = []
opening = set("({[")
mapping = {')': '(', '}': '{', ']': '['}
 for char in s:
if char in opening:
stack.append(char)
else:
if not stack or stack.pop() != mapping[char]:
return False

return not stack

# Example usage
expression = input("Enter a string with parentheses: ")
if balanced_parentheses(expression):
print("The parentheses are balanced.")
else:
print("The parentheses are not balanced.")

Question 27: Calculate the sum of digits in a number

python
Copy code
def sum_of_digits(number):
return sum(int(digit) for digit in str(abs(number)))

# Example usage
num = int(input("Enter a number: "))
result = sum_of_digits(num)
print(f"The sum of the digits in {num} is: {result}")

Question 28: Find and replace a word in a text file

python
Copy code
def find_replace_in_file(file_path, old_word, new_word):
try:
with open(file_path, 'r') as file:
content = file.read()

new_content = content.replace(old_word, new_word)

with open(file_path, 'w') as file:

file.write(new_content)

print(f"Word '{old_word}' replaced with '{new_word}' in the file.")

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

# Example usage
file_path = input("Enter the path to the text file: ")
old_word = input("Enter the word to replace: ")
new_word = input("Enter the new word: ")
find_replace_in_file(file_path, old_word, new_word)
Question 29: Find the intersection of two lists

python
Copy code
def find_intersection(list1, list2):
return list(set(list1) & set(list2))

# Example usage
list_a = [1, 2, 3, 4]
list_b = [3, 4, 5, 6]
result = find_intersection(list_a, list_b)
print("Intersection of the two lists:", result)

Question 30: Check if a number is an Armstrong number

python
Copy code
def is_armstrong_number(num):
order = len(str(num))
sum_of_digits = sum(int(digit) ** order for digit in str(num))
return num == sum_of_digits

# Example usage
number = int(input("Enter a number: "))
if is_armstrong_number(number):
print(f"{number} is an Armstrong number.")
else:
print(f"{number} is not an Armstrong number.")
Feel free to reach out if you have any questions or if you'd like further clarification on any
of the solutions!

Question 31: Simple Contact Management System

python
Copy code
class Contact:
def __init__(self, name, phone, email):
self.name = name
self.phone = phone
self.email = email

class ContactManager:
def __init__(self):
self.contacts = []

def add_contact(self, contact):

self.contacts.append(contact)

def view_contacts(self):
for contact in self.contacts:
print(f"Name: {contact.name}, Phone: {contact.phone}, Email: {contact.email}")
# Example usage
contact1 = Contact("John Doe", "123-456-7890", "john@example.com")
contact2 = Contact("Jane Doe", "987-654-3210", "jane@example.com")

contact_manager = ContactManager()
contact_manager.add_contact(contact1)
contact_manager.add_contact(contact2)
contact_manager.view_contacts()

Question 32: Organize Files by Extensions

python
Copy code
import os
import shutil

def organize_files(directory):
for filename in os.listdir(directory):
if os.path.isfile(os.path.join(directory, filename)):
extension = filename.split('.')[-1]
extension_folder = os.path.join(directory, extension)

if not os.path.exists(extension_folder):
os.makedirs(extension_folder)

shutil.move(os.path.join(directory, filename), os.path.join(extension_folder,

filename))
# Example usage
organize_files('/path/to/directory')

Question 33: Basic Tic-Tac-Toe Game

python
Copy code
def print_board(board):
for row in board:
print(" ".join(row))

def check_winner(board, player):

# Check rows, columns, and diagonals for a win
for i in range(3):
if all(cell == player for cell in board[i]) or all(board[j][i] == player for j in range(3)):
return True
if all(board[i][i] == player for i in range(3)) or all(board[i][2 - i] == player for i in range(3)):
return True
return False

def play_tic_tac_toe():
board = [[" " for _ in range(3)] for _ in range(3)]
current_player = "X"

for _ in range(9):
print_board(board)
 row = int(input(f"Player {current_player}, enter row (0-2): "))
col = int(input(f"Player {current_player}, enter column (0-2): "))

if board[row][col] == " ":

board[row][col] = current_player

if check_winner(board, current_player):
print(f"Player {current_player} wins!")
break

current_player = "O" if current_player == "X" else "X"

else:
print("Cell already taken. Try again.")

# Example usage
play_tic_tac_toe()
Feel free to ask for more code snippets or explanations for other questions!

User
continue 20 answers more
ChatGPT
Certainly! Here are additional code snippets for the next set of questions:

Question 34: Calculate Average Word Length in a Sentence

python
Copy code
def average_word_length(sentence):
words = sentence.split()
total_length = sum(len(word) for word in words)
return total_length / len(words) if len(words) > 0 else 0

# Example usage
sentence = input("Enter a sentence: ")
result = average_word_length(sentence)
print(f"The average word length is: {result}")

Question 35: Extract Metadata from Audio Files

python
Copy code
from pydub import AudioSegment

def extract_audio_metadata(file_path):
audio = AudioSegment.from_file(file_path)
metadata = {
"duration": len(audio) / 1000, # Convert to seconds
"channels": audio.channels,
"sample_width": audio.sample_width,
"frame_rate": audio.frame_rate,
}
return metadata
# Example usage
file_path = "/path/to/audio/file.mp3"
result = extract_audio_metadata(file_path)
print("Audio Metadata:", result)

Question 36: Download and Parse an RSS Feed

python
Copy code
import feedparser

def download_and_parse_rss(feed_url):
feed = feedparser.parse(feed_url)
for entry in feed.entries:
print(f"Title: {entry.title}, Link: {entry.link}")

# Example usage
feed_url = "https://example.com/rss_feed.xml"
download_and_parse_rss(feed_url)

Question 37: Convert Decimal to Binary

python
Copy code
def decimal_to_binary(decimal):
return bin(decimal).replace("0b", "")
# Example usage
decimal_number = int(input("Enter a decimal number: "))
binary_result = decimal_to_binary(decimal_number)
print(f"The binary representation is: {binary_result}")

Question 38: Matrix Multiplication

python
Copy code
import numpy as np

def matrix_multiplication(matrix1, matrix2):

result = np.dot(matrix1, matrix2)
return result

# Example usage
matrix_a = np.array([[1, 2], [3, 4]])
matrix_b = np.array([[5, 6], [7, 8]])
result_matrix = matrix_multiplication(matrix_a, matrix_b)
print("Result of Matrix Multiplication:")
print(result_matrix)

Question 39: Basic Banking System

python
Copy code
class Account:
 def __init__(self, account_number, balance):
self.account_number = account_number
self.balance = balance

class BankingSystem:
def __init__(self):
self.accounts = []

def create_account(self, account_number, initial_balance):

account = Account(account_number, initial_balance)
self.accounts.append(account)

def deposit(self, account_number, amount):

account = next((acc for acc in self.accounts if acc.account_number ==
account_number), None)
if account:
account.balance += amount
print(f"Deposited {amount} into account {account_number}. New balance:
{account.balance}")
else:
print(f"Account {account_number} not found.")

# Example usage
bank = BankingSystem()
bank.create_account("12345", 1000)
bank.deposit("12345", 500)
Question 40: Calculate Area of Geometric Shapes

python
Copy code
import math

def calculate_area(shape, *args):

if shape == "circle":
return math.pi * args[0]**2
elif shape == "rectangle":
return args[0] * args[1]
elif shape == "triangle":
return 0.5 * args[0] * args[1]

# Example usage
shape_type = input("Enter shape type (circle, rectangle, triangle): ")
result = calculate_area(shape_type, 3, 4) # Example dimensions, adjust as needed
print(f"The area of the {shape_type} is: {result}")
Feel free to ask for more code snippets or explanations for other questions!

User
continue 10 more
ChatGPT
Certainly! Here are the code snippets for the next set of questions:

Question 41: Generate Word Cloud from Text File

python
Copy code
from wordcloud import WordCloud
import matplotlib.pyplot as plt

def generate_word_cloud(text_file_path):
with open(text_file_path, 'r') as file:
text = file.read()

wordcloud = WordCloud(width=800, height=400,

background_color='white').generate(text)

plt.figure(figsize=(10, 5))
plt.imshow(wordcloud, interpolation='bilinear')
plt.axis('off')
plt.show()

# Example usage
text_file_path = "/path/to/text/file.txt"
generate_word_cloud(text_file_path)

Question 42: Second Most Frequent Element in a List

from collections import Counter

def second_most_frequent(lst):
counts = Counter(lst)
 sorted_counts = sorted(counts.items(), key=lambda x: x[1], reverse=True)

if len(sorted_counts) > 1:
return sorted_counts[1][0]
else:
return None

# Example usage
my_list = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
result = second_most_frequent(my_list)
print(f"The second most frequent element is: {result}")

Question 43: Interact with SQLite Database

import sqlite3

def interact_with_database():
connection = sqlite3.connect("my_database.db")
cursor = connection.cursor()

# Create a table
cursor.execute('''CREATE TABLE IF NOT EXISTS users
(id INTEGER PRIMARY KEY, name TEXT, age INTEGER)''')

# Insert data
cursor.execute("INSERT INTO users (name, age) VALUES (?, ?)", ("John Doe", 30))
cursor.execute("INSERT INTO users (name, age) VALUES (?, ?)", ("Jane Doe", 25))
 # Query data
cursor.execute("SELECT * FROM users")
data = cursor.fetchall()
for row in data:
print(row)

# Commit and close

connection.commit()
connection.close()

# Example usage
interact_with_database()

Question 44: Image Resizing

from PIL import Image

def resize_images(input_folder, output_folder, size=(300, 300)):

for filename in os.listdir(input_folder):
if filename.endswith(('.jpg', '.png')):
image_path = os.path.join(input_folder, filename)
image = Image.open(image_path)
resized_image = image.resize(size)

output_path = os.path.join(output_folder, filename)

resized_image.save(output_path)

# Example usage
input_folder = "/path/to/input/images"
output_folder = "/path/to/output/images"
resize_images(input_folder, output_folder)

Question 45: Find and Print Prime Numbers

def is_prime(num):
if num < 2:
return False
for i in range(2, int(num**0.5) + 1):
if num % i == 0:
return False
return True

def find_prime_numbers(limit):
primes = [num for num in range(2, limit) if is_prime(num)]
return primes

# Example usage
limit = int(input("Enter the limit: "))
result = find_prime_numbers(limit)
print("Prime numbers up to", limit, "are:", result)

Question 46: Generate Network Graph using Networkx

import networkx as nx
import matplotlib.pyplot as plt
def generate_network_graph():
G = nx.Graph()
G.add_nodes_from([1, 2, 3, 4])
G.add_edges_from([(1, 2), (2, 3), (3, 4), (4, 1)])

pos = nx.spring_layout(G)
nx.draw(G, pos, with_labels=True, node_color='skyblue', node_size=1000, font_size=10,
font_color='black', font_weight='bold', edge_color='gray')
plt.show()

# Example usage
generate_network_graph()

Question 47: Analyze and Visualize Data from CSV

import pandas as pd
import matplotlib.pyplot as plt

def analyze_and_visualize_csv(csv_file_path):
df = pd.read_csv(csv_file_path)

# Perform analysis (adjust as needed)

summary_stats = df.describe()

# Visualize data (adjust as needed)

df.plot(kind='bar', x='Category', y='Value', color='blue')
plt.title('Data Visualization')
plt.xlabel('Category')
 plt.ylabel('Value')
plt.show()

# Example usage
csv_file_path = "/path/to/data.csv"
analyze_and_visualize_csv(csv_file_path)

Question 48: Web Scraping

import requests
from bs4 import BeautifulSoup

def scrape_website(url):
response = requests.get(url)
soup = BeautifulSoup(response.text, 'html.parser')

# Extract data from the website (adjust as needed)

titles = soup.find_all('h2')
for title in titles:
print(title.text)

# Example usage
website_url = "https://example.com"
scrape_website(website_url)
Question 49: Convert Roman Numerals to Integers

def roman_to_int(roman):
roman_numerals = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}
result = 0

for i in range(len(roman)):
if i > 0 and roman_numerals[roman[i]] > roman_numerals[roman[i - 1]]:
result += roman_numerals[roman[i]] - 2 * roman_numerals[roman[i - 1]]
else:
result += roman_numerals[roman[i]]

return result

# Example usage
roman_numeral = input("Enter a Roman numeral: ")
result = roman_to_int(roman_numeral)
print(f"The integer equivalent is: {result}")

Question 50: Generate Pascal's Triangle

def generate_pascals_triangle(rows):
triangle = [[1] * (i + 1) for i in range(rows)]

for i in range(2, rows):

for j in range(1, i):
triangle[i][j] = triangle[i - 1][j - 1] + triangle[i - 1][j]
 return triangle

# Example usage
num_rows = int(input("Enter the number of rows for Pascal's Triangle: "))
result = generate_pascals_triangle(num_rows)
for row in result:
print(row)