Introduction

The os module in Python provides functions to interact with the operating system. It allows you to work with files, folders, system paths, and environment variables and execute system commands.

Why Use the `os` Module?

Task you want to do	`os` Module Feature
Get current directory	os.getcwd()
Change directory	os.chdir()
Create/Remove folders	os.mkdir() / os.rmdir()
List files and folders	os.listdir()
Work with environment variables	os.environ
Join file paths safely	os.path.join()
Delete a file	os.remove()
Run system commands	os.system()

Importing OS Module

import os

Directory Operations

Get the current working directory

import os
print(os.getcwd())

Change working directory

os.chdir("C:/Users")

List all files and folders

print(os.listdir())

Create and Delete Directories

Create a new folder

os.mkdir("myfolder")

Remove a folder (only if empty)

os.rmdir("myfolder")

Create multiple nested directories

os.makedirs("main/subfolder/new")

Remove nested directories

os.removedirs("main/subfolder/new")

File Handling

Delete a file

os.remove("sample.txt")

Rename a file

os.rename("oldname.txt", "newname.txt")

Path Operations (os.path)

Function	Description
`os.path.join()`	Safely join folder and file names
`os.path.exists()`	Check if path/file exists
`os.path.isdir()`	Check if the path is file
`os.path.isfile()`	Check if the path is a file
`os.path.getsize()`	Get file size in bytes

Example

# This will join the folder path and file name.
path = os.path.join("folder", "file.txt")

# This will return True if path exists.
print(os.path.exists(path))

# get size of file 
print(os.path.getsize(path))

Environment Variables

View environment variables

print(os.environ)

Fetch a specific variable

print(os.environ.get("PATH"))

Run System Commands

Open Command Prompt / Terminal command

# get list of file and folder in windos current directory.
os.system("dir")     # Windows

# get list of file and folder in linux current directory.
os.system("ls")      # Mac/Linux

Examples of Python OS Module

Create a Folder Only If It Doesn’t Exist

import os

folder = "project_data"

if not os.path.exists(folder):
    os.mkdir(folder)
    print("Folder created")
else:
    print("Folder already exists")

List Files Only (Exclude folders)

import os

for item in os.listdir():
    if os.path.isfile(item):
        print("File:", item)

List Folders Only (Exclude files)

import os

for item in os.listdir():
    if os.path.isdir(item):
        print("Folder:", item)

Recursively List Files from All Subdirectories

import os

path = "C:/Users"
for root, dirs, files in os.walk(path):
    print("Current Path:", root)
    print("Folders:", dirs)
    print("Files:", files)
    print("----------")

Count Number of Files and Folders

import os

files = 0
folders = 0

for item in os.listdir():
    if os.path.isfile(item):
        files += 1
    elif os.path.isdir(item):
        folders += 1

print("Files:", files)
print("Folders:", folders)

Copy File to Another Folder (Using os)

os doesn’t have copy directly, so use system command

import os
os.system("copy source.txt destination\\")   # Windows
os.system("cp source.txt destination/")      # Linux/Mac

Get File Size in KB / MB

import os

file = "example.txt"
size = os.path.getsize(file)  # in bytes

print(size / 1024, "KB")
print(size / (1024*1024), "MB")

Check File Permissions

import os

filepath = "example.txt"

print("Readable:", os.access(filepath, os.R_OK))
print("Writable:", os.access(filepath, os.W_OK))
print("Executable:", os.access(filepath, os.X_OK))

Execute Multiple Commands at Once

import os

os.system("dir && echo Hello World")  # Windows
# os.system("ls; echo Hello World")   # Linux/Mac

Change File Permission (Linux/Mac)

import os

os.chmod("script.sh", 0o755)  # Owner read/write/execute, others read/execute

What is a CSV File?

CSV stands for Comma-Separated Values and is commonly used for tabular data like spreadsheets.

Python has a built-in csv module for handling CSV files.

import csv

Write to CSV File

Write Rows Manually

import csv

with open("students.csv", "w", newline="") as file:
    writer = csv.writer(file)
    
    writer.writerow(["Name", "Age", "City"])  # Header
    writer.writerow(["Deepesh", 30, "Delhi"])
    writer.writerow(["Riya", 25, "Mumbai"])

Write Multiple Rows (Loop / List)

import csv

data = [
    ["Name", "Age", "City"],
    ["Aman", 28, "Pune"],
    ["Neha", 24, "Chennai"],
    ["Kunal", 29, "Bangalore"]
]

with open("data.csv", "w", newline="") as file:
    writer = csv.writer(file)
    writer.writerows(data)   # write all rows at once

Read CSV File

Read and Print Entire File

import csv

with open("students.csv", "r") as file:
    reader = csv.reader(file)
    
    for row in reader:
        print(row)

Read CSV as Dictionary

💡 Best when the first row contains headers.

import csv

with open("students.csv", "r") as file:
    reader = csv.DictReader(file)
    
    for row in reader:
        print(row["Name"], row["City"])

Write CSV Using Dictionary

import csv

data = [
    {"Name": "Raj", "Age": 27, "City": "Delhi"},
    {"Name": "Simran", "Age": 23, "City": "Kolkata"}
]

with open("students_dict.csv", "w", newline="") as file:
    fieldnames = ["Name", "Age", "City"]
    writer = csv.DictWriter(file, fieldnames=fieldnames)

    writer.writeheader()
    writer.writerows(data)

Append to a CSV File

import csv

with open("students.csv", "a", newline="") as file:
    writer = csv.writer(file)
    writer.writerow(["Kiran", 22, "Hyderabad"])

Handling Custom Delimiters

Example: Semi-colon ; separated file

import csv

with open("data_semicolon.csv", "r") as file:
    reader = csv.reader(file, delimiter=";")
    for row in reader:
        print(row)

Real Example: CSV Filtering

Print only rows where Age > 25

import csv

with open("students.csv", "r") as file:
    reader = csv.DictReader(file)
    
    for row in reader:
        if int(row["Age"]) > 25:
            print(row)

Summary

Task	Method
Write row	`writer.writerow()`
Write multiple rows	`writer.writerows()`
Read CSV	`csv.reader()`
Read as dict	`csv.DictReader()`
Write dict	`csv.DictWriter()`
Append data	`"a"` mode
Change delimiter	`delimiter=";"`

JSON in Python

JSON (JavaScript Object Notation) is used for storing and exchanging data, commonly in APIs and configuration files.

Python has a built-in module:

import json

Write (Save) JSON to a File

Example Dictionary/Data

data = {
    "name": "Deepesh",
    "age": 30,
    "skills": ["Python", "Selenium", "Automation"]
}

Save to JSON file

import json

with open("data.json", "w") as file:
    json.dump(data, file, indent=4)

indent=4 makes the JSON formatted & readable.

Read (Load) JSON from a File

import json

with open("data.json", "r") as file:
    content = json.load(file)
    print(content)

Output

{'name': 'Deepesh', 'age': 30, 'skills': ['Python', 'Selenium', 'Automation']}

Now content is a Python dictionary, and you can access elements like:

print(content["name"])
print(content["skills"][1])

Convert Python Data ↔ JSON String

Convert Python → JSON string

import json

person = {"city": "Delhi", "pin": 110001}
json_string = json.dumps(person)
print(json_string)

Convert JSON string → Python

import json

json_str = '{"status": "success", "code": 200}'
data = json.loads(json_str)
print(data)

Update JSON File

import json

# Read existing content
with open("data.json", "r") as file:
    data = json.load(file)

# Modify data
data["age"] = 31
data["skills"].append("API Testing")

# Write back to file
with open("data.json", "w") as file:
    json.dump(data, file, indent=4)

Work with Lists in JSON

Example JSON file (`employees.json`)

[
    {"id": 1, "name": "Ankit"},
    {"id": 2, "name": "Riya"}
]

Add a new record

import json

with open("employees.json", "r") as file:
    employees = json.load(file)

employees.append({"id": 3, "name": "Aman"})

with open("employees.json", "w") as file:
    json.dump(employees, file, indent=4)

Summary

Task	Function
Write Python → JSON file	json.dump()
Read JSON file → Python	json.load()
Python → JSON string	json.dumps()
JSON string → Python	json.loads()

openpyxl for Excel Handling

Install openpyxl (if not installed)

pip install openpyxl

Create / Write to an Excel File

from openpyxl import Workbook

wb = Workbook()                # Create workbook
ws = wb.active                 # Select active sheet
ws.title = "Students"          # Rename sheet

# Write data
ws['A1'] = "Name"
ws['B1'] = "Marks"
ws['A2'] = "Deepesh"
ws['B2'] = 85

wb.save("students.xlsx")       # Save file
print("File created successfully")

Write Multiple Rows

Using append()

from openpyxl import Workbook

wb = Workbook()
ws = wb.active

data = [
    ["Name", "Marks"],
    ["Ankit", 90],
    ["Riya", 88],
    ["Aman", 76]
]

for row in data:
    ws.append(row)

wb.save("marks.xlsx")
print("Data written successfully")

Read Excel File

Read the whole sheet of data

from openpyxl import load_workbook

wb = load_workbook("marks.xlsx")
ws = wb.active

for row in ws.rows:
    for cell in row:
        print(cell.value, end="  |  ")
    print()

Read Specific Cells

By cell address

from openpyxl import load_workbook

wb = load_workbook("marks.xlsx")
ws = wb.active

print(ws['A1'].value)   # Header
print(ws['B2'].value)   # Marks of 2nd row

Read by Rows / Columns

By Row

for row in ws.iter_rows(min_row=1, max_row=4, values_only=True):
    print(row)

By Column

for col in ws.iter_cols(min_col=1, max_col=2, values_only=True):
    print(col)

Update Existing Excel File

from openpyxl import load_workbook

wb = load_workbook("marks.xlsx")
ws = wb.active

ws['B3'] = 95  # Update marks for row 3
wb.save("marks.xlsx")

print("File updated")

Add a New Sheet

wb = load_workbook("marks.xlsx")
wb.create_sheet(title="Summary")   # Add at end
wb.save("marks.xlsx")

Delete Sheet

wb = load_workbook("marks.xlsx")
del wb["Summary"]
wb.save("marks.xlsx")

Get Sheet Names

print(wb.sheetnames)

Apply Basic Formatting

from openpyxl.styles import Font

ws['A1'].font = Font(bold=True, size=12, color="FF0000")
ws['B1'].font = Font(bold=True, size=12)
wb.save("marks.xlsx")

Calculate Total & Average

from openpyxl import Workbook

wb = Workbook()
ws = wb.active

data = [
    ["Name", "M1", "M2", "M3", "Total", "Average"],
    ["Raj", 85, 90, 88],
    ["Simran", 78, 82, 80],
]

for row in data:
    ws.append(row)

# Add formulas
ws['E2'] = "=B2+C2+D2"
ws['F2'] = "=E2/3"
ws['E3'] = "=B3+C3+D3"
ws['F3'] = "=E3/3"

wb.save("report.xlsx")
print("Report created!")

Summary

Task	Method
Create file	Workbook()
Load file	load_workbook()
Write cell	ws[‘A1’] = value
Append row	ws.append()
Read	ws.rows, iter_rows()
Formatting	Font()

Program Examples

Read Excel File

import openpyxl

def read_excel_file(file_path, sheet_name, cell_name):
    # Load the workbook
    workbook = openpyxl.load_workbook(file_path)
    # Select the specified sheet
    sheet = workbook[sheet_name]
    # Read the value from the specified cell
    cell_value = sheet[cell_name].value
    print(f"Value in {cell_name} of sheet '{sheet_name}': {cell_value}")

# read one cell data 
read_excel_file(file_path='users_data.xlsx', sheet_name='Sheet1', cell_name='A2')

Write Excel File

def write_excel_file(file_path, sheet_name, cell_name, data):
    # Load the workbook
    workbook = openpyxl.load_workbook(file_path)
    # Select the specified sheet
    sheet = workbook[sheet_name]
    # Write data to the specified cell
    sheet[cell_name] = data
    
    # Save the workbook
    workbook.save(file_path)
    print(f"Data written to sheet '{sheet_name}' starting at {cell_name}.")



write_excel_file(file_path='users_data.xlsx', sheet_name='Sheet1', cell_name='D2', data='Learning Excel with Python')

1. Local Scope Example

Variables declared inside a function are local to that function.

def my_function():
    x = 10   # local variable
    print("Inside function:", x)

my_function()
print("Outside function:", x)  # ❌ Error: x is not defined

2. Global Scope Example

Variable declared outside a function can be accessed anywhere.

x = 50   # global variable

def display():
    print("Inside function:", x)

display()
print("Outside function:", x)

3. Modifying Global Variable Inside a Function

Use the global keyword to change it.

count = 0

def update():
    global count
    count = count + 1
    print("Inside function:", count)

update()
print("Outside function:", count)

4. Enclosing Scope (Nested Functions)

Inner function can access variable from the outer function.

def outer():
    name = "Python"   # enclosing variable

    def inner():
        print("Accessing enclosing variable:", name)
    
    inner()

outer()

5. Modify Enclosing Variable using `nonlocal`

The nonlocal keyword allows modifying a variable in the outer (enclosing) function.

def outer():
    count = 10
    
    def inner():
        nonlocal count
        count += 5
        print("Inside inner:", count)
    
    inner()
    print("Inside outer:", count)

outer()

Introduction to Python Tuples

Python tuples are one of the core built-in data types that every Python programmer interacts with sooner or later. They look simple on the surface, yet they offer incredible power, speed, and reliability. If you’ve ever needed a collection that doesn’t change, tuples are your best friend. They’re lightweight, fast, and perfect for grouping related information.

What Is a Tuple in Python?

A tuple is an ordered, immutable collection of elements. That means once a tuple is created, you cannot change its contents—no adding, deleting, or modifying individual items. This immutability makes tuples extremely efficient and safer for storing fixed data.

Syntax of Creating Tuples

my_tuple = (10, 20, 30)

# Yes, it's that simple.

Key Features of Python Tuples

Immutable Nature

Once created, you cannot modify a tuple. This allows Python to optimize performance behind the scenes.

Ordered and Indexed

A tuple maintains the order of elements. You can access items using indexes starting from 0.

Allow Duplicate Values

Unlike sets, tuples happily store repeated values.

How to Create Tuples in Python

Creating an Empty Tuple

empty_tuple = ()

Tuple with Multiple Data Types

mixed_tuple = (10, "hello", 3.14, True)

Single-Element Tuple

Here’s a common mistake:

not_a_tuple = (5)     # This is NOT a tuple
actual_tuple = (5,)   # This IS a tuple

Nested Tuple

nested_tuple = (1, 2, (3, 4, 5))

Accessing Tuple Elements

Using Indexing

colors = ("red", "green", "blue")
print(colors[0])  # red

Negative Indexing

print(colors[-1])  # blue

Accessing Nested Elements

nested = (1, (10, 20, 30), 3)
print(nested[1][1])  # 20

Tuple Slicing

Basic Slicing

my_tuple = (0, 1, 2, 3, 4, 5)
print(my_tuple[1:4])  # (1, 2, 3)

Slicing with Steps

print(my_tuple[0:6:2])  # (0, 2, 4)

Tuple Methods

count(): Counts how many times a value appears.

nums = (1, 2, 2, 3)
print(nums.count(2))  # 2

index() : Returns the position of a value.

print(nums.index(3))  # 3

Tuple Operations

Concatenation

t1 = (1, 2)
t2 = (3, 4)
print(t1 + t2)  # (1, 2, 3, 4)

Repetition

print(t1 * 3)  # (1, 2, 1, 2, 1, 2)

Membership Testing

print(2 in t1)  # True

Tuple Packing and Unpacking

Packing

packed = 10, 20, 30

Unpacking

a, b, c = packed

Using Asterisk Operator

a, *b = (1, 2, 3, 4, 5)
print(a)  # 1
print(b)  # [2, 3, 4, 5]

Iterating Through Tuples

Using for Loop

for item in ("A", "B", "C"):
    print(item)

Using while Loop

i = 0
t = ("x", "y", "z")
while i < len(t):
    print(t[i])
    i += 1

Tuple Comprehensions (with Generator Expressions)

There’s no actual “tuple comprehension,” but generator expressions behave similarly.

Example

gen = (x*x for x in range(5))
print(tuple(gen))  # (0, 1, 4, 9, 16)

Real-World Applications of Tuples

Returning Multiple Values

def calc(a, b):
    return a+b, a*b

print(calc(3, 4))

Python Tuple Example Program

numbers = (10, 20, 30, 40, 50)

print("First:", numbers[0])
print("Slice:", numbers[1:4])
print("Count of 20:", numbers.count(20))
print("Index of 30:", numbers.index(30))

Python String Methods

String Methods:

len(): Returns the length of a string. Here’s an example:

# Using len() to get the length of a string
my_string = "Python Programming"

# Get the length of the string
length = len(my_string)

print("The length of the string is:", length)  # Output: 18

lower(): Converts all characters in a string to lowercase. Here’s an example:

# Using lower() to convert string to lowercase
my_string = "Python Programming"

# Convert the string to lowercase
lowercase_string = my_string.lower()

print("Original string:", my_string)  # Output: Python Programming
print("Lowercase string:", lowercase_string)  # Output: python programming

upper(): Converts all characters in a string to uppercase. Here’s an example:

# Using upper() to convert string to uppercase
my_string = "Python Programming"

# Convert the string to uppercase
uppercase_string = my_string.upper()

print("Original string:", my_string)  # Output: Python Programming
print("Uppercase string:", uppercase_string)  # Output: PYTHON PROGRAMMING

title(): Capitalizes the first character of each word in a string. Here’s an example:

# Using title() to capitalize the first character of each word
my_string = "python programming is fun"

# Convert the string to title case
title_string = my_string.title()

print("Original string:", my_string)  # Output: python programming is fun
print("Title case string:", title_string)  # Output: Python Programming Is Fun

capitalize(): Capitalizes the first character of a string. Here’s an example:

# Using capitalize() to capitalize the first character of a string
my_string = "python programming"

# Capitalize the first character
capitalized_string = my_string.capitalize()

print("Original string:", my_string)  # Output: python programming
print("Capitalized string:", capitalized_string)  # Output: Python programming

swapcase(): Swaps the case of all characters in a string. Here’s an example:

# Using swapcase() to swap the case of all characters in a string
my_string = "Python Programming"

# Swap the case of all characters
swapped_string = my_string.swapcase()

print("Original string:", my_string)  # Output: Python Programming
print("Swapped case string:", swapped_string)  # Output: pYTHON pROGRAMMING

count(): Returns the number of occurrences of a substring in a string. Here’s an example:

# Using count() to count occurrences of a substring
my_string = "Python programming is fun. Python is easy to learn."

# Count the occurrences of the word "Python"
count_python = my_string.count("Python")

print("Occurrences of 'Python':", count_python)  # Output: 2

find(): Returns the index of the first occurrence of a substring in a string. Here’s an example:

# Using find() to find the index of the first occurrence of a substring
my_string = "Python programming is fun."

# Find the index of the first occurrence of "Python"
index_python = my_string.find("Python")

print("Index of 'Python':", index_python)  # Output: 0

rfind(): Returns the index of the last occurrence of a substring in a string.

# Using rfind() to find the index of the last occurrence of a substring
my_string = "Python programming is fun. Python is easy to learn."

# Find the index of the last occurrence of "Python"
last_index_python = my_string.rfind("Python")

print("Index of the last 'Python':", last_index_python)  # Output: 36

10. index(): Like `find()`, but raises a `ValueError` if the substring is not found.

# Using index() to find the index of the first occurrence of a substring
my_string = "Python programming is fun."

# Find the index of the first occurrence of "Python"
index_python = my_string.index("Python")

print("Index of 'Python':", index_python)  # Output: 0

rindex(): Like `rfind()`, but raises a `ValueError` if the substring is not found.

# Using rindex() to find the index of the last occurrence of a substring
my_string = "Python programming is fun. Python is easy to learn."

# Find the index of the last occurrence of "Python"
last_index_python = my_string.rindex("Python")

print("Index of the last 'Python':", last_index_python)  # Output: 36

startswith(): Returns `True` if a string starts with a specified prefix, otherwise `False`.

# Using startswith() to check if the string starts with a specified prefix
my_string = "Python programming is fun."

# Check if the string starts with "Python"
starts_with_python = my_string.startswith("Python")

print("Starts with 'Python':", starts_with_python)  # Output: True

endswith(): Returns `True` if a string ends with a specified suffix, otherwise `False`.

# Using endswith() to check if the string ends with a specified suffix
my_string = "Python programming is fun."

# Check if the string ends with "fun."
ends_with_fun = my_string.endswith("fun.")

print("Ends with 'fun.':", ends_with_fun)  # Output: True

replace(): Replaces all occurrences of a substring with another substring.

# Using replace() to replace all occurrences of a substring
my_string = "Python is fun. Python is awesome."

# Replace "Python" with "Java"
new_string = my_string.replace("Python", "Java")

print("Original string:", my_string)
print("New string:", new_string)

15. strip(): Removes whitespace (or other characters) from the beginning and end of a string.

str1  = "  Python Programming "
# The string method will remove the beginning and ending strings.
result = str1.strip()
print(result)

Output:
Python Programming

rstrip(): Removes whitespace (or other characters) from the end of a string.

# Using rstrip() to remove trailing whitespace
my_string = "Hello, world!    "

# Remove the trailing whitespace
new_string = my_string.rstrip()

print("Original string:", repr(my_string))
print("New string:", repr(new_string))

lstrip(): Removes whitespace (or other characters) from the beginning of a string.

# Using lstrip() to remove leading whitespace
my_string = "    Hello, world!"

# Remove the leading whitespace
new_string = my_string.lstrip()

print("Original string:", repr(my_string))
print("New string:", repr(new_string))

split(): Splits a string into a list of substrings using a specified delimiter.

# Using split() to split a string into a list of words
my_string = "Python is fun!"

# Split the string by whitespace (default behavior)
words = my_string.split()

print("List of words:", words)

rsplit(): Splits a string from the right into a list of substrings using a specified delimiter.

# Using rsplit() to split a string from the right
my_string = "Python is fun and Python is awesome"

# Split the string by whitespace from the right
words = my_string.rsplit()

print("List of words:", words)

The separator used is the comma, which is passed as an argument to the rsplit() method. The 1 argument is used to specify that only one splitting should occur, which in this case splits the last fruit from the first two. Finally, we print the list of fruits.

20. join(): Joins a list of strings into a single string using a specified delimiter.

# Joining with a space
words = ["Hello", "world", "Python", "rocks!"]
sentence = " ".join(words)
print(sentence)  # Output: "Hello world Python rocks!"

# Joining with a comma
items = ["apple", "banana", "cherry"]
csv_line = ",".join(items)
print(csv_line)  # Output: "apple,banana,cherry"

# Joining with a hyphen
letters = ["a", "b", "c", "d"]
hyphenated = "-".join(letters)
print(hyphenated)  # Output: "a-b-c-d"

isalnum(): Returns `True` if a string contains only alphanumeric characters, otherwise `False`.

# String with only letters and numbers
print("Hello123".isalnum())  # Output: True

# String with only letters
print("Python".isalnum())  # Output: True

# String with only numbers
print("2024".isalnum())  # Output: True

# String with a space
print("Hello World".isalnum())  # Output: False

# String with special characters
print("Hello@123".isalnum())  # Output: False

# Empty string
print("".isalnum())  # Output: False

isalpha(): Returns `True` if a string contains only alphabetic characters, otherwise `False`.

# String with only letters
print("Python".isalpha())  # Output: True

# String with a space
print("Hello World".isalpha())  # Output: False

# String with numbers
print("Python3".isalpha())  # Output: False

# String with special characters
print("Hello!".isalpha())  # Output: False

# Empty string
print("".isalpha())  # Output: False

isdigit() : Returns `True` if a string contains only digits; otherwise, `False`.

# String with only digits
print("12345".isdigit())  # Output: True

# String with letters
print("123abc".isdigit())  # Output: False

# String with a space
print("123 456".isdigit())  # Output: False

# Empty string
print("".isdigit())  # Output: False

islower(): Returns `True` if all characters in a string are lowercase, otherwise `False`.

# All lowercase letters
print("hello".islower())  # Output: True

# Mixed case
print("Hello".islower())  # Output: False

# Digits and special characters are ignored
print("hello123!".islower())  # Output: True

# Contains an uppercase letter
print("helloWorld".islower())  # Output: False

# Empty string
print("".islower())  # Output: False

25. isupper(): Returns `True` if all characters in a string are uppercase, otherwise `False`.

# All uppercase letters
print("HELLO".isupper())  # Output: True

# Mixed case
print("Hello".isupper())  # Output: False

# Includes digits and symbols
print("HELLO123!".isupper())  # Output: True

# Contains a lowercase letter
print("HELLOworld".isupper())  # Output: False

# Empty string
print("".isupper())  # Output: False

istitle(): Returns `True` if a string is titlecased (i.e., the first character of each word is capitalized), otherwise `False`.

# Title-cased string
print("Hello World".istitle())  # Output: True

# Mixed case
print("Hello world".istitle())  # Output: False

# Uppercase string
print("HELLO WORLD".istitle())  # Output: False

# Lowercase string
print("hello world".istitle())  # Output: False

# Single title-cased word
print("Python".istitle())  # Output: True

isspace(): Returns `True` if a string contains only whitespace characters, otherwise `False`.

# Only spaces
print("   ".isspace())  # Output: True

# Only tabs
print("\t\t".isspace())  # Output: True

# Newline characters
print("\n\n".isspace())  # Output: True

# Mixed whitespace characters
print(" \t\n".isspace())  # Output: True

# Empty string
print("".isspace())  # Output: False

maketrans(): Creates a translation table to be used with the `translate()` function.

# Mapping characters 'a' -> '1', 'b' -> '2', 'c' -> '3'
trans_table = str.maketrans("abc", "123")
text = "abcde"
print(text.translate(trans_table))  # Output: "123de"

translate(): Returns a copy of a string with specified characters replaced.

# Create a translation table to replace 'a' -> '1', 'b' -> '2', 'c' -> '3'
trans_table = str.maketrans("abc", "123")
text = "abcde"
print(text.translate(trans_table))  # Output: "123de"

zfill(): Pads a numeric string with zeros on the left until the specified width is reached.

# Example using zfill() to pad a string with leading zeros
number = "42"
padded_number = number.zfill(5)

print(padded_number)  # Output: '00042'

expandtabs(): Replaces tabs in a string with spaces.

# Example using expandtabs() to replace tabs with spaces
text = "Hello\tWorld\tPython"
expanded_text = text.expandtabs(4)  # Replaces tabs with 4 spaces

print(expanded_text)  

# Output: 
'Hello   World   Python'

encode(): Encodes a string using a specified encoding.

# Encoding a string using UTF-8
my_string = "hello world"
encoded_string = my_string.encode("utf-8")

print(encoded_string)  # Output: b'hello world'

format_map(): Formats a string using a dictionary.

# Using format_map() to format a string using a dictionary
person = {"name": "Alice", "age": 30}

# Format string using the dictionary
formatted_string = "My name is {name} and I am {age} years old.".format_map(person)

print(formatted_string)

isdecimal(): Returns `True` if a string contains only decimal characters, otherwise `False`.

# Using isdecimal() to check if a string contains only decimal characters
my_string = "12345"

# Check if the string contains only decimal characters
is_decimal = my_string.isdecimal()

print(is_decimal)  # Output: True

isnumeric(): Returns `True` if a string contains only numeric characters, otherwise `False`.

# Using isnumeric() to check if a string contains only numeric characters
my_string = "12345"

# Check if the string is numeric
is_numeric = my_string.isnumeric()

print(is_numeric)  # Output: True

partition(): It splits the string into parts based on the first occurrence of the substring.

# Using partition() to split a string based on the first occurrence of a substring
my_string = "Hello, world! Welcome to Python."

# Split the string at the first occurrence of ","
result = my_string.partition(",")

print(result)

Python List Comprehension

List Comprehension

List comprehension is a concise and expressive way of creating lists in Python. It allows you to define a list and its elements within a single line of code, combining the functionality of a for loop, optional if conditions, and even nested loops. List comprehensions are preferred for their readability and efficiency compared to traditional for loops.

Simple For Loop List Comprehension:

This type of list comprehension is used to create a list by iterating over elements from an iterable (e.g., list, tuple, string) without any filtering or conditions. Here’s an example:

# Example list
numbers = [1, 2, 3, 4, 5]

# List comprehension without filtering or conditions
new_list = [num for num in numbers]

print(new_list)  # Output: [1, 2, 3, 4, 5]

Loop and If Condition List Comprehension:

This type of list comprehension includes an if condition to filter elements while iterating over the iterable. Only elements that satisfy the condition are included in the new list. Here’s an example:

# Example list
numbers = [1, 2, 3, 4, 5, 6]

# List comprehension with an if condition
even_numbers = [num for num in numbers if num % 2 == 0]

print(even_numbers)  # Output: [2, 4, 6]

Loop and If-Else Condition List Comprehension:

# Example list
numbers = [1, 2, 3, 4, 5, 6]

# List comprehension with if-else condition
result = ['Even' if num % 2 == 0 else 'Odd' for num in numbers]

print(result)
# Output: ['Odd', 'Even', 'Odd', 'Even', 'Odd', 'Even']

This type of list comprehension allows you to perform different operations based on the if-else condition while iterating over the iterable. Here’s an example:

Nested Loop List Comprehension:

This type of list comprehension allows you to use nested loops for creating more complex lists by iterating over multiple iterables simultaneously. Here’s an example:

# Example nested loops
colors = ['red', 'green', 'blue']
objects = ['ball', 'box', 'pen']

# List comprehension with nested loops
combinations = [f"{color} {obj}" for color in colors for obj in objects]

print(combinations)
# Output: ['red ball', 'red box', 'red pen', 'green ball', 'green box', 'green pen', 'blue ball', 'blue box', 'blue pen']

Shallow Copy and Deep Copy of Lists in Python:

In Python, when dealing with lists or other compound data structures, understanding the concepts of shallow copy and deep copy is crucial. Both concepts involve creating a new copy of an existing list, but they differ in how they handle nested objects within the list.

Shallow Copy:

A shallow copy of a list creates a new list object but does not create copies of the elements inside the list. Instead, it copies references to the original objects. This means that changes made to nested objects within the copied list will affect the original list, and vice versa. To perform a shallow copy, you can use the `copy()` method or the slicing notation `[:]`. Example of Shallow Copy:

import copy

# Original list with a nested list
original_list = [[1, 2, 3], [4, 5, 6]]

# Shallow copy using the copy() method
shallow_copy1 = original_list.copy()

# Shallow copy using slicing notation
shallow_copy2 = original_list[:]

# Modifying a nested element in the copied list
shallow_copy1[0][0] = 99

print("Original List:", original_list)
# Output: Original List: [[99, 2, 3], [4, 5, 6]]

print("Shallow Copy 1:", shallow_copy1)
# Output: Shallow Copy 1: [[99, 2, 3], [4, 5, 6]]

print("Shallow Copy 2:", shallow_copy2)
# Output: Shallow Copy 2: [[99, 2, 3], [4, 5, 6]]

Deep Copy:

A deep copy of a list creates a new list object and also recursively creates copies of all the nested objects within the original list. In other words, the copied list and its nested objects are entirely independent of the original list and its nested objects. To perform a deep copy, you need to use the `deepcopy()` function from the `copy` module. Example of Deep Copy:

import copy

# Original list with nested lists
original_list = [[1, 2, 3], [4, 5, 6]]

# Creating a deep copy
deep_copy = copy.deepcopy(original_list)

# Modifying a nested element in the deep copy
deep_copy[0][0] = 99

print("Original List:", original_list)
# Output: Original List: [[1, 2, 3], [4, 5, 6]]

print("Deep Copy:", deep_copy)
# Output: Deep Copy: [[99, 2, 3], [4, 5, 6]]

Shallow copy is faster and suitable when you want to create a new list but share references to nested objects. Deep copy is appropriate when you need an entirely independent copy of the original list and all its nested objects.

Python List Methods And Functions

Python List Methods

Lists in Python have many built-in methods that you can use to modify or manipulate the list. Here are some of the most commonly used methods:

append() – It is used to add an element to the end of the list.

# Define a list
my_list = ['apple', 'banana', 'cherry']

# Add an element to the end of the list
my_list.append('date')

# Print the updated list
print(my_list)

extend() – It is used to add the elements of another list to the end of the list or to combine two lists.

# Define a list
my_list = ['apple', 'banana']

# Extend the list with a tuple
my_list.extend(('cherry', 'date'))

# Extend the list with a set
my_list.extend({'elderberry', 'fig'})

# Print the updated list
print(my_list)

insert() – It is used to insert an element at a specific position in the list.

# Define a list
my_list = ['apple', 'banana', 'cherry']

# Insert an element at index 1
my_list.insert(1, 'date')

# Print the updated list
print(my_list)

4. remove() – It is used to remove the first occurrence of an element from the list.

# Define a list
my_list = ['apple', 'banana', 'cherry', 'banana']

# Remove the first occurrence of 'banana'
my_list.remove('banana')

# Print the updated list
print(my_list)

pop() – It removes and returns the element at a specific position in the list.

# Define a list
my_list = ['apple', 'banana', 'cherry']

# Remove and return the last element
removed_element = my_list.pop()

# Print the updated list and the removed element
print("Updated list:", my_list)
print("Removed element:", removed_element)

6. sort() – It sorts the elements of the list in ascending order.

# Define a list of numbers
my_list = [3, 1, 4, 1, 5, 9, 2, 6]

# Sort the list in descending order
my_list.sort(reverse=True)

# Print the sorted list
print(my_list)

7 .reverse() – It reverses the order of the elements in the list.

# Define a list of strings
my_list = ['apple', 'banana', 'cherry']

# Reverse the list
my_list.reverse()

# Print the reversed list
print(my_list)

clear() – It is used to remove all elements from a list, effectively emptying the list. After the clear() function is applied to a list, the list becomes empty with a length of 0.

# Define a list of strings
my_list = ['apple', 'banana', 'cherry']

# Clear all elements from the list
my_list.clear()

# Print the cleared list
print(my_list)

copy() – It creates a shallow copy of a list. The shallow copy means that a new list is created with the same elements as the original list, but the elements themselves are not duplicated. Any changes made to the elements in the copied list will also affect the original list, and vice versa.

# Define a list with immutable elements
my_list = [1, 2, 3]

# Create a shallow copy of the list
my_list_copy = my_list.copy()

# Modify the copied list
my_list_copy.append(4)

# Print both lists
print("Original list:", my_list)
print("Copied list:", my_list_copy)

index() – It is used to find the index of the first occurrence of a specified element within a list. If the element is not found in the list, it raises a ValueError.

# Define a list
my_list = ['apple', 'banana', 'cherry']

# Find the index of 'banana'
index_of_banana = my_list.index('banana')

# Print the index
print("Index of 'banana':", index_of_banana)

count() – It is used to count the number of occurrences of a specified element in a list.

# Define a list
my_list = ['apple', 'banana', 'cherry', 'banana', 'apple']

# Count occurrences of 'banana'
banana_count = my_list.count('banana')

# Print the count
print("Count of 'banana':", banana_count)

Updating list values:

Lists in Python are mutable, and their values can be updated by using the slice and assignment the ( = ) operator.

# Define a list
my_list = [1, 2, 3, 4, 5]

# Remove elements at indices 1 to 3
my_list[1:4] = []

# Print the updated list
print(my_list)

Built-in function for Python lists:

Here are some examples of commonly used built-in functions for lists in Python:

len(): It returns the length of the list.

# Define a list
my_list = [1, 2, 3, 4, 5]

# Get the length of the list
list_length = len(my_list)

# Print the length
print("Length of the list:", list_length)

max(): It returns the largest element in the list.

# Define a list of numbers
my_list = [1, 5, 3, 9, 2]

# Get the largest element in the list
largest_element = max(my_list)

# Print the largest element
print("Largest element:", largest_element)

min(): It returns the smallest element in the list.

# Define a list of numbers
my_list = [10, 5, 20, 3, 8]

# Get the smallest element in the list
smallest_element = min(my_list)

# Print the smallest element
print("Smallest element:", smallest_element)

sum(): It returns the sum of all elements in the list.

# Define a list of numbers
my_list = [1, 2, 3, 4, 5]

# Calculate the sum of the elements in the list
total_sum = sum(my_list)

# Print the total sum
print("Sum of the list:", total_sum)

5. sorted(): It returns a new sorted list.

# Define a list of numbers
my_list = [5, 2, 9, 1, 5, 6]

# Get a new sorted list
sorted_list = sorted(my_list)

# Print the sorted list
print("Sorted list:", sorted_list)

list(): It converts an iterable to a list.

# Define a tuple
my_tuple = (1, 2, 3, 4)

# Convert the tuple to a list
my_list = list(my_tuple)

# Print the list
print("List from tuple:", my_list)

7. any(): It returns True if at least one element in the list is True.

# Define a list of Boolean values
my_list = [False, False, True, False]

# Check if any element is True
result = any(my_list)

# Print the result
print("Any True in the list:", result)

all(): It returns True if all elements in the list are True.

# Define a list of Boolean values
my_list = [True, True, True]

# Check if all elements are True
result = all(my_list)

# Print the result
print("All True in the list:", result)

9. enumerate(): It returns an iterator that contains tuples of (index, element) pairs.

# Define a list
my_list = ['apple', 'banana', 'cherry']

# Use enumerate to get index and element
for index, element in enumerate(my_list):
    print(f"Index: {index}, Element: {element}")

# Output:

Index: 0, Element: apple
Index: 1, Element: banana
Index: 2, Element: cherry

zip(): It returns an iterator that aggregates elements from multiple lists into tuples.

# Define two lists
list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']

# Use zip to combine them into tuples
zipped = zip(list1, list2)

# Convert the zipped object to a list and print
zipped_list = list(zipped)
print(zipped_list)

11.reversed(): It returns a reverse iterator that can be used to iterate over a list in reverse order.

# Define a list
my_list = [1, 2, 3, 4, 5]

# Convert the reversed iterator to a list
reversed_list = list(reversed(my_list))

# Print the reversed list
print(reversed_list)

Data Type Conversion in Python

Datatype Conversion:

Below is a table that demonstrates the conversion of various Python data types into other data types. Each entry in the table includes the original data type, the target data type, a code snippet to perform the conversion, and an example output.

Integer(int) : Convert int Data Type to all other Data Type.

Data Type	Target Data Type	Code	Output
int	float	num_int = 10 num_float = float(num_int)	10.0
int	str	num_int = 42 num_str = str(num_int)	’42’
int	complex	num_int = 5 num_complex = complex(num_int)	(5+0j)
int	list	num_int = 123 num_list = list(num_int)	TypeError: ‘int’ object is not iterable Conversion is not possible
int	dict	num_int = 1 num_dict = dict(num_int)	TypeError: ‘int’ object is not iterable Conversion is not possible
int	tuple	num_int = 7 num_tuple = tuple(num_int)	TypeError: ‘int’ object is not iterable Conversion is not possible
int	bool	num_int = 0 num_bool = bool(num_int) print(num_bool) num_int1 = 123 num_bool1 = bool(num_int1) print(num_bool1)	False True

Float: Convert Float Data Type to all other Data Type.

Data Type	Target Data Type	Code	Output
float	int	num_float = 10.5 num_int = int(num_float)	10
float	str	num_float = 3.14 num_str = str(num_float)	‘3.14’
float	complex	num_float = 3.0 num_complex = complex(num_float,4.5)	(3+4.5j)
float	list	num_float = 3.14 num_list = list(num_float)	TypeError: ‘int’ object is not iterable Conversion is not possible
float	dict	num_float = 2.5 num_dict = dict(num_float)	TypeError: ‘int’ object is not iterable Conversion is not possible
float	tuple	num_float = 1.5 num_tuple = float(num_float)	TypeError: ‘int’ object is not iterable Conversion is not possible
float	bool	num_int = 0 num_bool = bool(num_int) print(num_bool) num_int1 = 12.3 num_bool1 = bool(num_int1) print(num_bool1)	False True

Complex : Convert complex data type to all other data type.

Data Type	Target Data Type	Code	Output
complex	int	num_complex = complex(3, 4) num_int = int(num_complex)	TypeError: int() argument must be a string, a bytes-like object or a real number, not ‘complex’ Conversion is not possible.
complex	float	i). num_complex = complex(3, 4) num_float = float(num_complex) ii). num_complex = complex(3, 4) num_float = float(num_complex.real)	i).TypeError: float() argument must be a string or a real number, not ‘complex’ Conversion is not possible. ii). 3
complex	str	num_complex = complex(1, 2)<br>num_str = str(num_complex)	‘(1+2j)’
complex	list	num_complex = complex(2, 3) num_list = [num_complex.real, num_complex.imag]	[2.0, 3.0]
complex	dict	num_complex = complex(2, 1) num_dict = {‘real’: num_complex.real, ‘imag’: num_complex.imag}	{‘real’: 2.0, ‘imag’: 1.0}
complex	tuple	num_complex = complex(4, 5) num_tuple = (num_complex.real, num_complex.imag)	(4.0, 5.0)
complex	bool	num_complex = complex(0, 0) num_bool = bool(num_complex)	False

String(str) : Convert str data type to all other data type.

Data Type	Target Data Type	Code	Output
str	int	num_str = ‘987’ num_int = int(num_str)	987
str	float	num_str = ‘2.71’ num_float = float(num_str)	2.71
str	complex	num_str = ‘1+2j’ num_complex = complex(num_str)	(1+2j)
str	list	str_val = ‘hello’ list_val = list(str_val)	[‘h’, ‘e’, ‘l’, ‘l’, ‘o’]
str	dict	str_val = ‘hello’ dict_val = {str_val: len(str_val)}	{‘hello’: 5}
str	tuple	str_val = ‘abc’ tuple_val = tuple(str_val)	(‘a’, ‘b’, ‘c’)
str	bool	str_val = ‘True’ bool_val = bool(str_val)	True

List(list) : Convert list data type to all other data type.

Data Type	Target Data Type	Code	Output
list	int	num_list = [1, 2, 3] num_int = int(”.join(map(str, num_list)))	123
list	float	num_list = [3, 1, 4] num_float = float(”.join(map(str, num_list)))	314.0
list	str	num_list = [10, 20, 30] num_str = ‘, ‘.join(map(str, num_list))	’10, 20, 30′
list	complex	num_list = [2, 3] num_complex = complex(num_list[0], num_list[1])	(2+3j)
list	dict	num_list = [1, 2] num_dict = dict(zip(num_list, [‘one’, ‘two’]))	{1: ‘one’, 2: ‘two’}
list	tuple	num_list = [7, 8, 9] num_tuple = tuple(num_list)	(7, 8, 9)
list	bool	num_list = [0, 1, 0] num_bool = any(num_list)	True

Tuple(tuple) : Convert tuple data type to all other data type.

Data Type	Target Data Type	Code	Output
tuple	int	num_tuple = (4, 5, 6) num_int = int(”.join(map(str, num_tuple)))	456
tuple	float	num_tuple = (1, 2) num_float = float(‘.’.join(map(str, num_tuple)))	1.2
tuple	str	num_tuple = (7, 8, 9) num_str = ‘, ‘.join(map(str, num_tuple))	‘7, 8, 9’
tuple	complex	num_tuple = (3, 4) num_complex = complex(num_tuple[0], num_tuple[1])	(3+4j)
tuple	list	num_tuple = (10, 20) num_list = list(num_tuple)	[10, 20]
tuple	dict	num_tuple = (‘x’, 1) num_dict = dict([num_tuple])	{‘x’: 1}
tuple	bool	num_tuple = (0, 0) num_bool = any(num_tuple)	False

Dictionary(dict) : Convert dict data type to all other data type.

Data Type	Target Data Type	Code	Output
ict	int	num_dict = {‘a’: 1} num_int = int(list(num_dict.keys())[0])	97
dict	float	num_dict = {‘pi’: 3.14} num_float = float(list(num_dict.values())[0])	3.14
dict	str	num_dict = {1: ‘one’} num_str = str(list(num_dict.keys())[0])	‘1’
dict	complex	num_dict = {3: 5} num_complex = complex(list(num_dict.keys())[0], list(num_dict.values())[0])	(3+5j)
dict	list	num_dict = {‘a’: 1, ‘b’: 2} num_list = list(num_dict.items())	[(‘a’, 1), (‘b’, 2)]
dict	tuple	num_dict = {‘x’: 10, ‘y’: 20} num_tuple = tuple(num_dict.items())	((‘x’, 10), (‘y’, 20))
dict	bool	num_dict = {‘flag’: True} num_bool = bool(list(num_dict.values())[0])	True

Set : Convert set data type to all other data type.

Data Type	Target Data Type	Code	Output
set	int	num_set = {1, 2, 3} num_int = int(”.join(map(str, num_set)))	123
set	float	num_set = {3, 1, 4} num_float = float(”.join(map(str, num_set)))	314.0
set	str	num_set = {10, 20, 30} num_str = ‘, ‘.join(map(str, num_set))	’10, 20, 30′
set	complex	num_set = {2, 3} num_complex = complex(list(num_set)[0], list(num_set)[1])	(2+3j)
set	list	num_set = {1, 2, 3} num_list = list(num_set)	[1, 2, 3]
set	dict	num_set = {1, 2, 3} num_dict = dict.fromkeys(num_set, ‘value’)	{1: ‘value’, 2: ‘value’, 3: ‘value’}
set	tuple	num_set = {7, 8, 9) num_tuple = tuple(num_set)	(8, 9, 7)
set	bool	num_set = set() num_bool = bool(num_set)	False

Boolean(bool) : Convert bool data type to all other data type.

Data Type	Target Data Type	Code	Output
bool	int	num_bool = False num_int = int(num_bool)	0
bool	float	num_bool = True num_float = float(num_bool)	1.0
bool	str	num_bool = True num_str = str(num_bool)	‘True‘
bool	complex	num_bool = True num_complex = complex(int(num_bool), 0)	(1+0j)
bool	list	num_bool = False num_list = [int(num_bool)]	[0]
bool	dict	num_bool = True num_dict = {str(num_bool): ‘boolean’}	{‘True’: ‘boolean’}
bool	tuple	num_bool = False num_tuple = (int(num_bool),)	(0,)

Introduction

Why Use the os Module?

Importing OS Module

Directory Operations

Get the current working directory

Change working directory

List all files and folders

Create and Delete Directories

Create a new folder

Remove a folder (only if empty)

Create multiple nested directories

Remove nested directories

File Handling

Delete a file

Rename a file

Path Operations (os.path)

Example

Environment Variables

View environment variables

Fetch a specific variable

Run System Commands

Open Command Prompt / Terminal command

Examples of Python OS Module

Create a Folder Only If It Doesn’t Exist

List Files Only (Exclude folders)

List Folders Only (Exclude files)

Recursively List Files from All Subdirectories

Count Number of Files and Folders

Copy File to Another Folder (Using os)

Get File Size in KB / MB

Check File Permissions

Execute Multiple Commands at Once

Change File Permission (Linux/Mac)

What is a CSV File?

Write to CSV File

Write Rows Manually

Write Multiple Rows (Loop / List)

Read CSV File

Read and Print Entire File

Read CSV as Dictionary

Write CSV Using Dictionary

Append to a CSV File

Handling Custom Delimiters

Real Example: CSV Filtering

Print only rows where Age > 25

Summary

JSON in Python

Write (Save) JSON to a File

Example Dictionary/Data

Save to JSON file

Read (Load) JSON from a File

Convert Python Data ↔ JSON String

Convert Python → JSON string

Convert JSON string → Python

Update JSON File

Work with Lists in JSON

Example JSON file (employees.json)

Add a new record

Summary

openpyxl for Excel Handling

Install openpyxl (if not installed)

Create / Write to an Excel File

Write Multiple Rows

Using append()

Read Excel File

Read the whole sheet of data

Read Specific Cells

By cell address

Read by Rows / Columns

By Row

By Column

Update Existing Excel File

Add a New Sheet

Delete Sheet

Get Sheet Names

Apply Basic Formatting

Calculate Total & Average

Summary

Program Examples

Read Excel File

Why Use the `os` Module?

Example JSON file (`employees.json`)

5. Modify Enclosing Variable using `nonlocal`