PythonTutorial

Python Tutorials For Beginners

Welcome to the Python Repository! This repository serves as a comprehensive guide to learning Python programming language, covering various topics and concepts with examples and explanations.

Table of Contents

1. What is Python

2. Features of Python

3. What is Python Used For

4. Modules in Python

5. Types of Modules

   • Built-in Modules
   • External Modules

6. Our First Program

7. Comments, Escape Sequences, and Print Statement

8. Variables

9. Data Types

10. Operators in Python

    • Arithmetic Operators
    • Comparison Operators
    • Logical Operators
    • Assignment Operators
    • Identity Operators
    • Membership Operators

11. Type Casting

    • Implicit Type Casting (Coercion)
    • Explicit Type Casting (Conversion)

12. Taking Input at Runtime

13. Strings and Its Methods

14. Conditional Statements

15. Match Case Statements

16. Looping Statements

    • For Loop
    • While Loop

17. Range and Its Parameters

18. List

19. Tuples

20. Break and Continue

21. Set and FrozenSet

22. Dictionary

23. Functions and Exception Handling

    • Functions
    • Positional Arguments
    • Keyword Arguments
    • Default Arguments
    • Gather Positional Arguments *
    • Gather Keyword Arguments **
    • Docstrings
    • Inner Functions
    • Anonymous Functions (Lambda Functions)
    • Recursion
    • Generators
    • Decorators
    • Namespace and Scope
    • Uses of _ and __ in Names
    • Exception Handling
    • Create Custom Exception
    • Map
    • Filter
    • Reduce

24. Modules and Packages

    • Importing Modules
    • Creating and Using Packages
    • Standard Packages

25. File Handling

    • Os Module
    • Opening Files
    • Reading Files
    • Writing Files
    • Closing Files
    • Working with Files

What is Python

Python is a high-level, interpreted, and general-purpose programming language known for its simplicity and readability. It is widely used in various domains, including web development, data analysis, artificial intelligence, automation, and more.

⬆ Back to Top

Features of Python

• Easy-to-learn syntax
• Interpreted nature (no need for compilation)
• Extensive standard library
• Dynamic typing
• Object-oriented programming support
• Cross-platform compatibility
• Open-source community development

⬆ Back to Top

What is Python Used For

Python is used for a wide range of applications, including:

• Web development (using frameworks like Django and Flask)
• Data analysis and visualization (using libraries like NumPy, Pandas, and Matplotlib)
• Machine learning and artificial intelligence (using libraries like TensorFlow and PyTorch)
• Automation and scripting
• Game development
• Network programming
• And much more!

⬆ Back to Top

Modules in Python

Modules in Python are files containing Python code that can be reused in other programs. They help in organizing code and promoting code reusability.

⬆ Back to Top

Types of Modules

Built-in Modules

Python comes with a rich set of built-in modules that are available for immediate use. Some commonly used built-in modules are:

• math
• random
• datetime
• os

External Modules

External modules are created by the Python community and are not part of the standard Python distribution. They can be installed using package managers like pip. For example:

• requests
• beautifulsoup4
• matplotlib

⬆ Back to Top

Our First Program

Let's start with the classic "Hello, World!" program, a simple program that displays the text "Hello, World!" on the screen.

print("Hello, World!")

⬆ Back to Top

Comments, Escape Sequences, and Print Statement

Python supports single-line and multi-line comments, escape sequences, and the print statement for displaying output.

# This is a single-line comment

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

print("Hello, Python!")
print("Line 1\nLine 2")

⬆ Back to Top

Variables

Variables in Python are used to store data of different data types, such as numbers, strings, or objects.

# Integer variable
age = 25

# String variable
name = "John Doe"

# Floating-point variable
price = 10.99

⬆ Back to Top

Data Types

Python supports various data types, including:

• Numeric types (int, float, complex)
• Sequence types (str, list, tuple)
• Boolean type (bool)
• Set types (set, frozenset)
• Mapping type (dict)

# Numeric types
age = 25
salary = 35000.50
complex_number = 3 + 5j

# Sequence types
name = "Alice"
numbers = [1, 2, 3, 4]
coordinates = (10, 20)

# Boolean type
is_valid = True

# Set types
fruits = {"apple", "banana", "orange"}
frozen_fruits = frozenset(fruits)

# Mapping type
person = {"name": "Bob", "age": 30}

⬆ Back to Top

Operators in Python

Python supports various types of operators to perform operations on variables and values.

Arithmetic Operators

a = 10
b = 5

print(a + b)  # Addition
print(a - b)  # Subtraction
print(a * b)  # Multiplication
print(a / b)  # Division
print(a % b)  # Modulo (Remainder)
print(a ** b) # Exponentiation

Comparison Operators

x = 10
y = 20

print(x == y)  # Equal to
print(x != y)  # Not equal to
print(x < y)   # Less than
print(x > y)   # Greater than
print(x <= y)  # Less than or equal to
print(x >= y)  # Greater than or equal to

Logical Operators

p = True
q = False

print(p and q)  # Logical AND
print(p or q)   # Logical OR
print(not p)    # Logical NOT

Assignment Operators

a = 10
b = 5

a += b  # Equivalent to a = a + b
a -= b  # Equivalent to a = a - b
a *= b  # Equivalent to a = a * b
a /= b  # Equivalent to a = a / b
a %= b  # Equivalent to a = a % b

Identity Operators

x = [1, 2, 3]
y = [1, 2, 3]
z = x

print(x is y)  # False (x and y are different objects)
print(x is z)  # True (x and z refer to the same object)
print(x is not y)  # True (x and y are different objects)

Membership Operators

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

print("apple" in fruits)    # True (apple is in the list)
print("grape" not in fruits)  # True (grape is not in the list)

⬆ Back to Top

Type Casting

Type casting allows converting one data type to another.

Implicit Type Casting (Coercion)

x = 10
y = 5.5

sum = x + y  # Python automatically converts 'x' to float before addition
print(sum)

   # Output: 15.5

Explicit Type Casting (Conversion)

x = "10"
y = 5

sum = int(x) + y  # Convert 'x' to int before addition
print(sum)       # Output: 15

⬆ Back to Top

Taking Input at Runtime

You can take user input at runtime using the input() function.

name = input("Enter your name: ")
print("Hello, " + name + "!")

⬆ Back to Top

Strings and Its Methods

Strings are sequences of characters in Python. They have various built-in methods for manipulation.

text = "Hello, Python!"

# Length of the string
print(len(text))  # Output: 14

# Convert to uppercase
print(text.upper())  # Output: HELLO, PYTHON!

# Convert to lowercase
print(text.lower())  # Output: hello, python!

# Count occurrences of a substring
print(text.count("o"))  # Output: 2

# Replace a substring
print(text.replace("Python", "World"))  # Output: Hello, World!

# Check if the string starts with a specific prefix
print(text.startswith("Hello"))  # Output: True

# Check if the string ends with a specific suffix
print(text.endswith("Python!"))  # Output: True

# Split the string into a list
print(text.split(","))  # Output: ['Hello', ' Python!']

⬆ Back to Top

Conditional Statements

Conditional statements allow executing different code blocks based on certain conditions.

x = 10

if x > 0:
    print("Positive")
elif x == 0:
    print("Zero")
else:
    print("Negative")

⬆ Back to Top

Match Case Statements

Match case (available in Python 3.10 and above) provides a more concise way to handle multiple conditions.

fruit = "apple"

match fruit:
    case "apple":
        print("It's an apple.")
    case "banana":
        print("It's a banana.")
    case "orange":
        print("It's an orange.")
    case _:
        print("Unknown fruit.")

⬆ Back to Top

Looping Statements

Looping statements allow executing a block of code repeatedly.

For Loop

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

for fruit in fruits:
    print(fruit)

While Loop

count = 1

while count <= 5:
    print(count)
    count += 1

While Loop with Else

count = 1

while count <= 5:
    print(count)
    count += 1
else:
    print("Count is greater than 5")

⬆ Back to Top

Range and Its Parameters

range() is a built-in function used to generate sequences of numbers.

# Generate numbers from 0 to 9 (excluding 10)
for num in range(10):
    print(num)

# Generate numbers from 5 to 9 (excluding 10)
for num in range(5, 10):
    print(num)

# Generate numbers from 1 to 10 with a step of 2
for num in range(1, 11, 2):
    print(num)

⬆ Back to Top

List

List are Mutable and Ordered Collection of items and can be changed or modified after its creation. List allows duplicate members. List is a collection which is ordered and changeable. Allows duplicate members. List is a collection which is ordered and changeable. Allows duplicate members.

⬆ Back to Top

Working with Lists in Python

Lists are mutable data structures in Python, meaning their elements can be changed after creation. Here's how you can perform various operations with lists:

⬆ Back to Top

Assigning Lists

# Lists can be modified, unlike tuples.
l_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(l_list)                 # Output: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(type(l_list))           # Output: <class 'list'>

⬆ Back to Top

Accessing List Elements

print(l_list[0])              # Output: 1
print(l_list[1])              # Output: 2
print(l_list[-1])             # Output: 10 (Negative Indexing)
print(l_list[-2])             # Output: 9  (Negative Indexing)
print(l_list[2:5])            # Output: [3, 4, 5] (Range of Indexes)
print(l_list[:5])             # Output: [1, 2, 3, 4, 5] (Range of Indexes)

⬆ Back to Top

Loop Through a List

# Loop through a list
for x in l_list:
    print(x, end=",")         # Output: 1,2,3,4,5,6,7,8,9,10,
print()                       # To move to the next line

⬆ Back to Top

Modify List Items

# Modify list items directly
l_list[0] = 11
print("Modified list:", l_list)   # Output: Modified list: [11, 2, 3, 4, 5, 6, 7, 8, 9, 10]

⬆ Back to Top

Check if Item Exists in List

# Check if Item Exists
if 1 in l_list:
    print("Yes, '1' is in the list")  # Output: Yes, '1' is in the list
else:
    print("No, '1' is not in the list")

⬆ Back to Top

List Length

print("Length of list:", len(l_list))  # Output: Length of list: 10

Add Items to a List

# Add Items
# You can add items to a list using the append() or extend() method.
l_list.append(11)
print("List after append:", l_list)   # Output: List after append: [11, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

# You can also add multiple items at once using the extend() method.
l_list.extend([12, 13, 14])
print("List after extend:", l_list)   # Output: List after extend: [11, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

# Insert Items
# You can insert items at a given index using the insert() method.
l_list.insert(0, 0)
print("List After Insert:",l_list) #Output :List after Insert: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

⬆ Back to Top

Remove Items from a List

# Remove Items
# You can remove items from a list using the remove() method.
l_list.remove(11)
print("List after remove:", l_list)   # Output: List after remove: [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

# Alternatively, you can use the pop() method to remove an item at a specific index.
l_list.pop(0)
print("List after pop:", l_list)      # Output: List after pop: [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

# To remove all elements, you can use the clear() method.
l_list.clear()
print("List after clear:", l_list)    # Output: List after clear: []

⬆ Back to Top

Join Two Lists

l_list1 = [1, 2, 3]
l_list2 = [4, 5, 6]
l_list3 = l_list1 + l_list2
print("Join two lists:", l_list3)    # Output: Join two lists: [1, 2, 3, 4, 5, 6]

⬆ Back to Top

List Methods

# count()	Returns the number of times a specified value occurs in a list
l_list4 = [1, 1, 2, 3, 4, 1]
print("Count of 1 in list:", l_list4.count(1))   # Output: Count of 1 in list: 3

# index()	Searches the list for a specified value and returns the index of where it was found
print("Index of 2 in list:", l_list4.index(2))   # Output: Index of 2 in list: 2

⬆ Back to Top

Built-in Functions and Operators

# all()	Returns True if all items in an iterable object are true
print("All items in list are true:", all(l_list3))  # Output: All items in list are true: True

# any()	Returns True if any item in an iterable object is true
print("Any item in list is true:", any(l_list3))    # Output: Any item in list is true: True

# len()	Returns the length of an object
print("Length of list:", len(l_list3))             # Output: Length of list: 6

# max()	Returns the largest item in an iterable
print("Max item in list:", max(l_list3))           # Output: Max item in list: 6

# min()	Returns the smallest item in an iterable
print("Min item in list:", min(l_list3))           # Output: Min item in list: 1

# sum()	Returns the sum of all items in an iterable
print("Sum of all items in list:", sum(l_list3))    # Output: Sum of all items in list: 21

These are some of the basic operations and methods you can use to work with lists in Python.

⬆ Back to Top

Tuples

Tuples are immutable data structures in Python, which means once they are created, their elements cannot be changed. Let's explore various operations you can perform with tuples:

Assigning Tuples

# Tuples are immutable, which means you cannot change them once created.
l_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
print(l_tuple)                # Output: (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
print(type(l_tuple))          # Output: <class 'tuple'>

Accessing Tuple Elements

print(l_tuple[0])             # Output: 1
print(l_tuple[1])             # Output: 2
print(l_tuple[-1])            # Output: 10 (Negative Indexing)
print(l_tuple[-2])            # Output: 9  (Negative Indexing)
print(l_tuple[2:5])           # Output: (3, 4, 5) (Range of Indexes)
print(l_tuple[:5])            # Output: (1, 2, 3, 4, 5) (Range of Indexes)

Loop Through a Tuple

# Loop through a tuple
for x in l_tuple:
    print(x, end=",")         # Output: 1,2,3,4,5,6,7,8,9,10,
print()                       # To move to the next line

Convert Tuple to List and Modify

# Convert the tuple into a list to be able to change it
l_list = list(l_tuple)
l_list[0] = 11
l_tuple = tuple(l_list)
print("Converted to list from tuples:", l_tuple)  # Output: (11, 2, 3, 4, 5, 6, 7, 8, 9, 10)

Check if Item Exists in Tuple

# Check if Item Exists
if 1 in l_tuple:
    print("Yes, '1' is in the tuple")   # Output: Yes, '1' is in the tuple
else:
    print("No, '1' is not in the tuple")

Tuple Length

print("Length of tuple:", len(l_tuple))  # Output: Length of tuple: 10

Join Two Tuples

l_tuple1 = (1, 2, 3)
l_tuple2 = (4, 5, 6)
l_tuple3 = l_tuple1 + l_tuple2
print("Join two tuples:", l_tuple3)     # Output: Join two tuples: (1, 2, 3, 4, 5, 6)

⬆ Back to Top

Tuple Methods

# count()	Returns the number of times a specified value occurs in a tuple
print("Count of 1 in tuple:", l_tuple3.count(1))   # Output: Count of 1 in tuple: 1

# index()	Searches the tuple for a specified value and returns the position of where it was found
print("Index of 1 in tuple:", l_tuple3.index(1))   # Output: Index of 1 in tuple: 0

⬆ Back to Top

Built-in Functions and Operators

# all()	Returns True if all items in an iterable object are true
print("All items in tuple are true:", all(l_tuple3))  # Output: All items in tuple are true: True

# any()	Returns True if any item in an iterable object is true
print("Any item in tuple is true:", any(l_tuple3))    # Output: Any item in tuple is true: True

# len()	Returns the length of an object
print("Length of tuple:", len(l_tuple3))             # Output: Length of tuple: 6

# max()	Returns the largest item in an iterable
print("Max item in tuple:", max(l_tuple3))           # Output: Max item in tuple: 6

# min()	Returns the smallest item in an iterable
print("Min item in tuple:", min(l_tuple3))           # Output: Min item in tuple: 1

# sum()	Returns the sum of all items in an iterable
print("Sum of all items in tuple:", sum(l_tuple3))    # Output: Sum of all items in tuple: 21

⬆ Back to Top

Break and Continue

Break The Break statement enables a program to skip over a part of the code. A Break statement terminates the very loop it lies within. Example:

for i in range(1, 11):
    print(i, end=" ")
    if i == 5:
        break
    else:
        print("else block")
print("outside for loop")

Example

num = int(input("Enter a number to print Table: "))
for i in range(1,20):
    if i == 11:
        break
    else:
        print(num,"x",i,"=",num*i)

# Output:
# Enter a number to print Table: 5
# 5 x 1 = 5
# 5 x 2 = 10
# 5 x 3 = 15
# 5 x 4 = 20
# 5 x 5 = 25
# 5 x 6 = 30
# 5 x 7 = 35
# 5 x 8 = 40
# 5 x 9 = 45
# 5 x 10 = 50 It will come out of the loop after 10

⬆ Back to Top

Continue

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

num=int(input("Enter a number to print Table: "))
for i in range(1, 13):
    if i == 10:
        continue  # skip the current iteration and continue with the next iteration means it will skip 10 and continue with 11
    else:
        print(num,"x",i,"=",num*i)

#Output:
# Enter a number to print Table: 5
# 5 x 1 = 5
# 5 x 2 = 10
# 5 x 3 = 15
# 5 x 4 = 20
# 5 x 5 = 25
# 5 x 6 = 30
# 5 x 7 = 35
# 5 x 8 = 40
# 5 x 9 = 45
#Skip 10
# 5 x 11 = 55
# 5 x 12 = 60
# outside for loop

⬆ Back to Top

Set and FrozenSet

Set

A set is an unordered and unindexed collection of unique elements. It's mutable, meaning you can add or remove items after creation.

Creating a Set

# set of integers
my_set = {1, 2, 3}
print(my_set)

# set of mixed datatypes
my_set = {1.0, "Hello", (1, 2, 3)}
print(my_set)

# set cannot have duplicates
my_set = {1, 2, 3, 4, 3, 2}
print(my_set)

Methods and Examples

# initialize my_set
my_set = {1, 3}
print(my_set)  # Output: {1, 3}

# add an element
my_set.add(2)
print(my_set)  # Output: {1, 2, 3}

# add multiple elements
my_set.update([2, 3, 4])
print(my_set)  # Output: {1, 2, 3, 4}

# add list and set
my_set.update([4, 5], {1, 6, 8})
print(my_set)  # Output: {1, 2, 3, 4, 5, 6, 8}

# copy my_set
my_set2 = my_set.copy()
print(my_set2)  # Output: {1, 2, 3, 4, 5, 6, 8}

# pop an element
print(my_set2.pop())  # Output: 1

# remove an element
my_set2.remove(8)
print(my_set2)  # Output: {2, 3, 4, 5, 6}

# difference()
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}

# set1 - set2
print(set1.difference(set2))  # Output: {1, 2, 3}

# intersection()
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}

# set1 intersection set2
print(set1.intersection(set2))  # Output: {4, 5}

# union()
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}

# union of two sets
set3 = set1.union(set2)
print(set3)  # Output: {1, 2, 3, 4, 5, 6, 7, 8}

⬆ Back to Top

FrozenSet

A frozenset is an immutable version of a set. It's hashable, can be used as a dictionary key, and can't be changed after creation. It's often used in situations where immutability is required.

Creating a FrozenSet

# Create a set
numbers = {1, 2, 3, 4, 5, 6}
print(numbers)

# Create a FrozenSet from a list
vowels = ["a", "e", "i", "o", "u"]
fSet = frozenset(vowels)
print(fSet)

# Create a FrozenSet from a tuple
vowels = ("a", "e", "i", "o", "u")
print(vowels)

# Create a FrozenSet from a dictionary
person = {"name": "John", "age": 23, "sex": "male"}
fSet = frozenset(person)
print(fSet)

⬆ Back to Top

FrozenSet Methods and Examples

# copying a frozen set
vowels = ("a", "e", "i", "o", "u")
fSet = frozenset(vowels)
fSet1 = fSet.copy()
print(fSet1)

# difference of two frozen sets
set1 = frozenset([1, 2, 3, 4])
set2 = frozenset([3, 4, 5, 6])
set3 = set1.difference(set2)
print(set3)

# intersection of two frozen sets
set1 = frozenset([1, 2, 3, 4])
set2 = frozenset([3, 4, 5, 6])
set3 = set1.intersection(set2)
print(set3)

# checking if two frozen sets are disjoint
set1 = frozenset([1, 2, 3, 4])
set2 = frozenset([5, 6, 7, 8])
print(set1.isdisjoint(set2))

# check if one frozen set is a subset of another
set1 = frozenset([1, 2, 3, 4])
set2 = frozenset([1, 2, 3, 4, 5])
set3 = frozenset([1, 2, 3])
print(set2.issubset(set1))
print(set3.issubset(set1))

# check if one frozen set is a superset of another
set1 = frozenset([1, 2, 3, 4])
set2 = frozenset([1, 2, 3, 4, 5])
set3 = frozenset([1, 2, 3])
print(set1.issuperset(set2))
print(set1.issuperset(set3))

# symmetric difference of two frozen sets
set1 = frozenset([1, 2, 3, 4])
set2 = frozenset([3, 4, 5, 6])
set3 = set1.symmetric_difference(set2)
print(set3)

# union of two frozen sets
set1 = frozenset([1, 2, 3, 4])
set2 = frozenset([3, 4, 5, 6])
set3 = set1.union(set2)
print(set3)

⬆ Back to Top

Dictionary

A dictionary in Python is a collection of key-value pairs. Each key in a dictionary must be unique, and it is associated with a corresponding value. Dictionaries are defined using curly braces {} and the key-value pairs are separated by colons. Here are some dictionary syntax examples:

1. Basic Dictionary:

my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}

2. Dictionary with Different Data Types:

person = {'name': 'Alice', 'age': 30, 'is_student': False}

3. Nested Dictionary (Dictionary of Dictionaries):

students = {
    'student1': {'name': 'Bob', 'age': 25},
    'student2': {'name': 'Charlie', 'age': 28}
}

4. Accessing Values by Key:

person = {'name': 'Alice', 'age': 30}
name = person['name']
age = person['age']

5. Adding a New Key-Value Pair:

person = {'name': 'Alice', 'age': 30}
person['city'] = 'New York'

6. Modifying a Value:

person = {'name': 'Alice', 'age': 30}
person['age'] = 31

7. Dictionary with Various Data Types as Values:

data = {'name': 'John', 'age': 25, 'grades': [90, 85, 92]}

8. Using Dictionary Methods (e.g., keys(), values(), items()):

person = {'name': 'Alice', 'age': 30}
keys = person.keys()
values = person.values()
items = person.items()

9. Removing a Key-Value Pair:

person = {'name': 'Alice', 'age': 30}
removed_value = person.pop('age')

10. Dictionary Comprehension:

numbers = {'one': 1, 'two': 2, 'three': 3}
squared_numbers = {key: value ** 2 for key, value in numbers.items()}

⬆ Back to Top

Methods and Examples

1. clear() - Removes all the elements from the dictionary:

my_dict = {'a': 1, 'b': 2, 'c': 3}
my_dict.clear()
print(my_dict)  # Output: {}

2. copy() - Returns a copy of the dictionary:

original_dict = {'name': 'Alice', 'age': 30}
copied_dict = original_dict.copy()
print(copied_dict)  # Output: {'name': 'Alice', 'age': 30}

3. fromkeys() - Returns a dictionary with the specified keys and value:

keys = ['a', 'b', 'c']
value = 0
new_dict = dict.fromkeys(keys, value)
print(new_dict)  # Output: {'a': 0, 'b': 0, 'c': 0}

4. get() - Returns the value of the specified key:

my_dict = {'name': 'Bob', 'age': 25}
age = my_dict.get('age')
print(age)  # Output: 25

5. items() - Returns a list containing a tuple for each key-value pair:

my_dict = {'a': 1, 'b': 2, 'c': 3}
items = my_dict.items()
print(items)  # Output: dict_items([('a', 1), ('b', 2), ('c', 3)])

6. keys() - Returns a list containing the dictionary's keys:

my_dict = {'name': 'Charlie', 'age': 28, 'location': 'XYZ'}
keys = my_dict.keys()
print(keys)  # Output: dict_keys(['name', 'age', 'location'])

7. pop() - Removes the element with the specified key:

my_dict = {'x': 10, 'y': 20, 'z': 30}
value = my_dict.pop('y')
print(value)  # Output: 20
print(my_dict)  # Output: {'x': 10, 'z': 30}

8. popitem() - Removes the last inserted key-value pair:

my_dict = {'a': 1, 'b': 2, 'c': 3}
removed_item = my_dict.popitem()
print(removed_item)  # Output: ('c', 3)
print(my_dict)  # Output: {'a': 1, 'b': 2}

9. setdefault() - Returns the value of the specified key. If the key does not exist, inserts the key with the specified value:

my_dict = {'name': 'Eve'}
age = my_dict.setdefault('age', 22)
print(my_dict)  # Output: {'name': 'Eve', 'age': 22}

10. update() - Updates the dictionary with the specified key-value pairs:

my_dict = {'a': 1, 'b': 2}
my_dict.update({'b': 3, 'c': 4})
print(my_dict)  # Output: {'a': 1, 'b': 3, 'c': 4}

11. values() - Returns a list of all the values in the dictionary:

my_dict = {'x': 10, 'y': 20, 'z': 30}
values = my_dict.values()
print(values)  # Output: dict_values([10, 20, 30])

⬆ Back to Top

Functions and Exception Handling

Functions

Definition: Functions are blocks of reusable code that perform a specific task. They help in organizing code and making it more modular.

Clarification: Functions allow you to define a set of instructions that can be executed whenever needed. They take input arguments, process them, and return an output. This makes your code easier to read, maintain, and debug.

Syntax:

def function_name(parameter1, parameter2, ...):
    # Function body
    # Code to perform the task
    return result  # Optional

Simple Example:

def greet(name):
    return "Hello, " + name + "!"

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

Complex Example:

def calculate_total(price, quantity, tax_rate=0.1):
    subtotal = price * quantity
    tax_amount = subtotal * tax_rate
    total = subtotal + tax_amount
    return total

item_price = 25
item_quantity = 2
final_total = calculate_total(item_price, item_quantity)
print("Total:", final_total)  # Output: Total: 55.0

⬆ Back to Top

Positional Arguments

Definition: Positional arguments are values or variables passed to a function in a specific order. They are matched with function parameters based on their positions.

Clarification: When calling a function with positional arguments, their order matters. The first argument is assigned to the first parameter, the second argument to the second parameter, and so on.

Syntax:

function_name(arg1, arg2, ...)

Example:

def add(a, b):
    return a + b

result = add(3, 5)
print(result)  # Output: 8

⬆ Back to Top

Keyword Arguments

Definition: Keyword arguments are values or variables passed to a function using parameter names as keys. This allows you to specify which argument corresponds to which parameter, regardless of their positions.

Clarification: Keyword arguments enhance the clarity of function calls, especially when dealing with functions that have many parameters. They make the code more readable and less prone to errors caused by misplaced arguments.

Syntax:

function_name(param1=value1, param2=value2, ...)

Example:

def divide(dividend, divisor):
    return dividend / divisor

result = divide(dividend=10, divisor=2)
print(result)  # Output: 5.0

⬆ Back to Top

Default Arguments

Definition: Default arguments are values assigned to function parameters during function definition. If a value is not provided for that parameter when calling the function, the default value is used.

Clarification: Default arguments allow you to make certain parameters optional. If a value is provided, it overrides the default; otherwise, the default value is used.

Syntax:

def function_name(param1=default_value1, param2=default_value2, ...):
    # Function body

Example:

def power(base, exponent=2):
    return base ** exponent

result1 = power(3)
result2 = power(2, 3)
print(result1)  # Output: 9
print(result2)  # Output: 8

⬆ Back to Top

Gather Positional Arguments *

Definition: The asterisk (*) is used in a function parameter to gather any remaining positional arguments into a tuple. This allows a function to accept a variable number of arguments.

Clarification: The gathered positional arguments are collected into a tuple. This is useful when you're not sure how many arguments will be passed to the function.

Syntax:

def function_name(arg1, arg2, *args):
    # Function body

Example:

def concatenate(separator, *strings):
    return separator.join(strings)

result = concatenate("-", "a", "b", "c")
print(result)  # Output: a-b-c

⬆ Back to Top

Gather Keyword Arguments **

Definition: The double asterisk (**) is used in a function parameter to gather any remaining keyword arguments into a dictionary. This allows a function to accept a variable number of keyword arguments.

Clarification: The gathered keyword arguments are collected into a dictionary. This is useful when you want to pass a varying number of named arguments to a function.

Syntax:

def function_name(arg1, arg2, **kwargs):
    # Function body

Example:

def display_info(**details):
    for key, value in details.items():
        print(key + ": " + value)

display_info(name="Alice", age="30", city="New York")
# Output:
# name: Alice
# age: 30
# city: New York

⬆ Back to Top

Docstrings

Definition: Docstrings (Document Strings) are string literals used to document a Python module, class, function, or method. They serve as a form of documentation and are accessible using the built-in help() function or within integrated development environments (IDEs) like Jupyter Notebook or code editors.

Clarification: Docstrings provide explanations about the purpose, usage, parameters, and return values of functions and methods. They help developers understand how to use and work with the code they encounter, making it easier to collaborate and maintain codebases.

Syntax:

def function_name(parameter1, parameter2):
    """
    Brief description of the function or method.

    More detailed explanation of what the function does and how to use it.

    :param parameter1: Description of parameter1.
    :param parameter2: Description of parameter2.
    :return: Description of what the function returns.
    """
    # Function body
    # ...

Example:

def calculate_total(price, quantity, tax_rate=0.1):
    """
    Calculate the total cost of items including tax.

    This function takes the price, quantity, and an optional tax rate to calculate
    the total cost of items including tax.

    :param price: The price of each item.
    :param quantity: The quantity of items.
    :param tax_rate: The tax rate (default is 0.1).
    :return: The total cost including tax.
    """
    subtotal = price * quantity
    tax_amount = subtotal * tax_rate
    total = subtotal + tax_amount
    return total

To access the docstring of a function or method, you can use the help() function or by using the .__doc__ attribute.

print(help(calculate_total))
# Output: Displays the docstring of the calculate_total function.

print(calculate_total.__doc__)
# Output: Prints the docstring of the calculate_total function means it will print whatever we have written in the docstring.

⬆ Back to Top

Inner Functions

Definition: Inner functions, also known as nested functions, are functions defined within the scope of another enclosing function. They are nested inside other functions and have access to the variables and resources of their containing function.

Clarification: Inner functions are a way to encapsulate and organize code by keeping related functionality together. They are often used to perform specialized tasks within the context of the enclosing function, and they can access the arguments and variables of that outer function.

Syntax:

def outer_function(outer_arguments):
    # Outer function code

    def inner_function(inner_arguments):
        # Inner function code
        # Access outer_arguments and other variables from the outer function

    # More outer function code

Example:

def calculate_tax(price, quantity, tax_rate):
    def apply_tax(subtotal):
        return subtotal * tax_rate

    subtotal = price * quantity
    tax_amount = apply_tax(subtotal)
    total_cost = subtotal + tax_amount
    return total_cost

price = 25
quantity = 2
tax_rate = 0.1
total = calculate_tax(price, quantity, tax_rate)
print("Total cost with tax:", total)

Inner functions are useful for:

1. Encapsulation: Keeping related functionality together and avoiding polluting the global namespace.
2. Information Hiding: Concealing details of a specific calculation or operation within the outer function.
3. Code Reusability: Inner functions can be reused within the same outer function or even in other functions defined within the same scope.

# Example : How to define Inner Functions in Python?
def outerFunction(text):
    def innerFunction():
        print(text)

    innerFunction()


outerFunction("Hey!")

# Output: Hey!

# Example : How to access Inner Function?
def outerFunction(text):
    def innerFunction():
        print(text)

    return innerFunction


myFunction = outerFunction("Hey!")
myFunction()

# Output: Hey!

⬆ Back to Top

Anonymous Functions (Lambda Functions)

Definition: Anonymous functions, also known as lambda functions, are small, unnamed functions defined using the lambda keyword. They are typically used for simple operations and are often used in functional programming constructs like map, filter, and reduce.

Clarification: Lambda functions are used when you need a small function for a short period, and you don't want to define a full-fledged named function using the def keyword. They are concise and can take multiple arguments but can only contain a single expression.

Syntax:

lambda arguments: expression

Example 1 - Basic Usage:

# Lambda function to add two numbers
add = lambda x, y: x + y

result = add(5, 3)
print(result)  # Output: 8

Example 2 - Using Lambda with map:

# Using lambda with map to square a list of numbers
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x ** 2, numbers))

print(squared)  # Output: [1, 4, 9, 16, 25]

Example 3 - Using Lambda with filter:

# Using lambda with filter to get even numbers from a list
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
evens = list(filter(lambda x: x % 2 == 0, numbers))

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

Example 4 - Using Lambda with sorted:

# Using lambda with sorted to sort a list of tuples based on the second element
data = [(1, 5), (3, 2), (2, 8)]
sorted_data = sorted(data, key=lambda x: x[1])

print(sorted_data)  # Output: [(3, 2), (1, 5), (2, 8)]

Lambda functions are especially handy when you need a simple function for a short-lived task. However, for more complex or reusable functions, it's recommended to use the def keyword to define named functions for better readability and maintainability of your code.

⬆ Back to Top

Recursion

Definition: Recursion is a programming concept where a function calls itself to solve a problem. In the context of programming, it's a technique where a function performs a task in part and delegates the rest of the task to itself. Recursion is often used to solve problems that can be divided into smaller, similar subproblems.

Principles of Recursion:

1. Base Case: Every recursive function should have a base case, which defines when the recursion should stop. When the base case is met, the function returns a value or performs a specific action.

2. Recursive Case: In the recursive case, the function divides the problem into smaller, similar subproblems. It calls itself with modified inputs, moving closer to the base case.

3. Termination: Recursion should lead to the termination of the function. In other words, each recursive call should make progress toward the base case.

Example 1 - Factorial Calculation:

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

result = factorial(5)
print(result)  # Output: 120 (5! = 5 * 4 * 3 * 2 * 1)

Example 2 - Fibonacci Sequence:

def fibonacci(n):
    if n <= 0:  # Base case
        return 0
    elif n == 1:  # Base case
        return 1
    else:
        return fibonacci(n - 1) + fibonacci(n - 2)  # Recursive case

result = fibonacci(7)
print(result)  # Output: 13 (Fibonacci sequence: 0, 1, 1, 2, 3, 5, 8, 13)

Example 3 - Directory Tree Traversal:

import os

def list_files(path):
    if os.path.isfile(path):
        print("File:", path)
    elif os.path.isdir(path):
        print("Directory:", path)
        for item in os.listdir(path):
            list_files(os.path.join(path, item))  # Recursive case

list_files("/path/to/your/directory")

Recursion is a powerful and elegant technique, but it should be used judiciously, as excessive recursion can lead to stack overflow errors. When used appropriately, recursion simplifies problem-solving by breaking complex tasks into smaller, more manageable parts.

⬆ Back to Top

Generators

Definition: Generators in Python are a type of iterable, much like lists or tuples. However, unlike lists that store all their values in memory at once, generators create values on the fly, one at a time, using a special type of function called a generator function. This allows generators to be memory-efficient and particularly useful when dealing with large datasets.

Clarification: Generator functions are defined using the yield keyword instead of return. When a generator function is called, it doesn't execute immediately; instead, it returns a generator object. The values are produced and retrieved from the generator using iteration constructs like loops. This on-demand generation of values makes generators efficient for processing large data streams.

Syntax:

def generator_function(parameters):
    # Generator function code
    yield value  # Produces a value in the generator

Example 1 - Simple Generator Function:

def count_up_to(n):
    i = 1
    while i <= n:
        yield i
        i += 1

# Using the generator to print numbers up to 5
counter = count_up_to(5)
for num in counter:
    print(num)
# Output: 1 2 3 4 5

Example 2 - Generator Expression:

# Using a generator expression to generate a sequence of squared numbers
squared = (x ** 2 for x in range(1, 6))
for num in squared:
    print(num)
# Output: 1 4 9 16 25

Example 3 - Infinite Generator:

def infinite_counter():
    i = 1
    while True:
        yield i
        i += 1

# Using an infinite generator to generate numbers on-demand
counter = infinite_counter()
for _ in range(5):
    print(next(counter))
# Output: 1 2 3 4 5

Example 4 - Generate a Random Number:

import random


def lottery():
    # returns 6 numbers between 1 and 40
    for i in range(6):
        yield random.randint(1, 40)

    # returns a 7th number between 1 and 15
    yield random.randint(1, 15)


for random_number in lottery():
    print("And the next number is... %d!" % (random_number))

Example 5 - Generator For Even Numbers:

def even_numbers(n):
    for i in range(1, n):
        if i % 2 == 0:
            yield i


for number in even_numbers(11):
    print("Even number: ", number)

Generators are particularly beneficial when dealing with large datasets, as they allow you to work with data one piece at a time, without the need to load everything into memory. They're commonly used in scenarios like reading large files, streaming data processing, and creating efficient custom iterators.

⬆ Back to Top

Decorators

Definition: In Python, decorators are a powerful and flexible way to modify or enhance the behavior of functions or methods without changing their code. Decorators are functions themselves and are typically used to add additional functionality or modify the behavior of other functions or methods. They are often used for tasks like logging, authentication, and measuring execution time.

Clarification: Decorators are applied to functions or methods using the "@" symbol followed by the decorator's name. When a decorated function is called, it is wrapped by the decorator, allowing you to execute code before and/or after the original function's execution.

Syntax:

def decorator_function(original_function):
    def wrapper(*args, **kwargs):
        # Code to execute before the original function
        result = original_function(*args, **kwargs)
        # Code to execute after the original function
        return result
    return wrapper

@decorator_function
def function_to_decorate(*args, **kwargs):
    # Original function code

Example 1 - Basic Decorator:

def greeting_decorator(func):
    def wrapper(*args, **kwargs):
        print("Hello, this is a decorated function!")
        result = func(*args, **kwargs)
        print("Goodbye from the decorator!")
        return result
    return wrapper

@greeting_decorator
def say_hello(name):
    print(f"Hello, {name}!")

say_hello("Alice")
# Output:
# Hello, this is a decorated function!
# Hello, Alice!
# Goodbye from the decorator!

Example 2 - Decorator with Arguments:

def repeat_decorator(num_repeats):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(num_repeats):
                func(*args, **kwargs)
        return wrapper
    return decorator

@repeat_decorator(3)
def say_hello(name):
    print(f"Hello, {name}!")

say_hello("Bob")
# Output:
# Hello, Bob!
# Hello, Bob!
# Hello, Bob!

Example 3 - Class-based Decorator:

class TimingDecorator:
    def __init__(self, func):
        self.func = func

    def __call__(self, *args, **kwargs):
        import time
        start_time = time.time()
        result = self.func(*args, **kwargs)
        end_time = time.time()
        print(f"{self.func.__name__} took {end_time - start_time:.2f} seconds to run.")
        return result

@TimingDecorator
def slow_function():
    import time
    time.sleep(2)

slow_function()
# Output: slow_function took 2.00 seconds to run.

Decorators are a powerful tool in Python for enhancing the functionality of functions or methods without modifying their core code. They can be used for a wide range of purposes, making your code more modular and maintainable.

⬆ Back to Top

Namespace and Scope

Definition: In Python, a namespace is a container that holds a collection of identifiers (such as variable names, function names, class names) and maps them to their corresponding objects (like values, functions, or classes). Each namespace has a specific scope, which defines the region of code where a particular namespace is accessible.

Clarification:

• Namespace: A namespace is like a dictionary that associates names (identifiers) with objects. Namespaces provide a way to organize and avoid naming conflicts in your code.

• Scope: Scope refers to the region of code where a particular namespace is accessible. Python has several levels of scope, including global scope (accessible throughout the entire program) and local scope (restricted to a specific function or block of code).

Examples:

1. Global Namespace and Scope:

global_var = 10  # This is in the global namespace

def my_function():
    local_var = 5  # This is in the local namespace of my_function
    print(global_var)  # Accessing a global variable from within the function

my_function()
print(local_var)  # This will result in an error because local_var is not in the global scope

In this example, global_var is in the global namespace, so it's accessible from both the global scope and within my_function. However, local_var is in the local namespace of my_function, making it inaccessible from the global scope.

2. Built-in Namespace: Python also has a built-in namespace containing functions and objects like print(), len(), str(), etc. These can be used without importing them explicitly.

print(len("Hello"))  # Here, len() is from the built-in namespace

3. Namespace Conflicts:

x = 5

def my_function(x):
    print("Local x:", x)  # This x is from the local scope
    print("Global x:", globals()['x'])  # Accessing the global x explicitly

my_function(10)

In this example, there's a local variable x within my_function, and there's a global variable x. To access the global x within the function, we use globals() to access the global namespace.

⬆ Back to Top

Uses of _ and __ in Names

In Python, the use of underscores _ and __ in variable and attribute names follows certain conventions and has specific meanings. Here's an explanation of their common uses:

Underscore _

1. Single Underscore Prefix _var:

   • By convention, a single underscore prefix (_var) is used to indicate that a variable or attribute is intended to be private. It's a signal to other developers that they should not access this variable directly from outside the class or module.

   • It doesn't make the variable truly private; it's more of a naming convention to respect encapsulation.

   • Example:

     class MyClass:
         def __init__(self):
             self._private_var = 42
     
     obj = MyClass()
     print(obj._private_var)  # Accessing a "private" variable (not recommended)

2. Single Underscore as a Placeholder _:

   • The single underscore _ is often used as a placeholder variable when you don't intend to use the value. It's a convention to indicate that the value itself is not important.
   • Example:

     for _ in range(5):
         # Perform some action 5 times, but we don't need the loop variable
         print("Hello")

Double Underscore __

1. Name Mangling with Double Underscores __var:

   • When a variable or attribute is prefixed with double underscores (__var), Python performs name mangling to make it less accessible outside the class.

   • It effectively changes the name of the variable to include the class name, which makes it more challenging to accidentally override attributes from parent classes.

   • Example:

     class MyClass:
         def __init__(self):
             self.__private_var = 42
     
     obj = MyClass()
     # Accessing a "name-mangled" variable requires using the mangled name
     print(obj._MyClass__private_var)

2. Double Underscore for Special Methods __method__:

   • In Python, certain methods like __init__, __str__, and __add__ have special meanings. By convention, they are surrounded by double underscores.

   • Defining these special methods in your class allows you to customize the behavior of objects when used in specific contexts (e.g., object initialization, string representation, or addition).

   • Example:

     class MyClass:
         def __init__(self, value):
             self.value = value
     
         def __str__(self):
             return f"MyClass instance with value: {self.value}"
     
     obj = MyClass(42)
     print(obj)  # This calls the __str__ method

Both single and double underscores are conventions in Python, and their use does not enforce access control. It's important to respect these conventions to improve code readability and maintainability and to avoid accidental variable clashes, especially in larger codebases and collaborations.

⬆ Back to Top

Exception Handling

Error Handling with try and except

Definition: In Python, try and except blocks are used to handle exceptions (errors) that may occur during program execution. The try block contains the code that might raise an exception, while the except block specifies how to handle and recover from those exceptions.

Clarification: Error handling is crucial for preventing your program from crashing when it encounters unexpected situations or errors. By using try and except, you can gracefully handle errors and take appropriate actions, such as logging the error, providing a default value, or displaying a user-friendly message.

Syntax:

try:
    # Code that may raise an exception
except ExceptionType as exception_variable:
    # Code to handle the exception
else:
    # Code to execute if no exception occurred (optional)
finally:
    # Code that always runs, whether an exception occurred or not (optional)

Example 1 - Handling a Specific Exception:

try:
    x = 10 / 0  # Division by zero
except ZeroDivisionError as e:
    print("Error:", e)
    x = 0  # Handle the error by setting x to a default value

print("Result:", x)  # Output: Error: division by zero, Result: 0

Example 2 - Handling Multiple Exceptions:

try:
    num = int("abc")  # This will raise a ValueError
except ValueError as e:
    print("ValueError:", e)
except TypeError as e:
    print("TypeError:", e)
else:
    print("No exception occurred.")

Example 3 - Using finally:

try:
    file = open("nonexistent.txt", "r")
    data = file.read()
except FileNotFoundError as e:
    print("FileNotFoundError:", e)
else:
    print("File opened successfully.")
finally:
    file.close()  # Ensure the file is closed, even if an exception occurred

In these examples, the try block contains code that may raise exceptions. If an exception occurs, it's caught by the corresponding except block, allowing you to handle it gracefully. The else block is executed if no exception occurs, and the finally block always runs, regardless of whether an exception occurred or not.

By using try and except, you can make your Python programs more robust and user-friendly by handling errors in a controlled manner. ⬆ Back to Top

Create Custom Exceptions

Creating custom exceptions in Python allows you to define and raise your own specific error types when exceptional situations occur in your code. This can make error handling more precise and informative. Here's how to define and raise custom exceptions in Python:

Defining Custom Exceptions

To create a custom exception, you need to define a new class that inherits from the built-in Exception class or one of its subclasses, such as ValueError or RuntimeError. Typically, it's best to inherit from Exception directly for more generic custom exceptions or from a specific exception class if your custom exception represents a particular error type.

Syntax:

class CustomException(Exception):
    def __init__(self, message="Custom exception occurred"):
        self.message = message
        super().__init__(self.message)

In the code above, we define a custom exception named CustomException that inherits from Exception. We also provide an optional message parameter to allow custom error messages when raising this exception.

Raising Custom Exceptions

Once you've defined your custom exception, you can raise it using the raise statement when an exceptional condition occurs in your code.

Syntax:

raise CustomException("A custom error message")

Example:

class CustomException(Exception):
    def __init__(self, message="Custom exception occurred"):
        self.message = message
        super().__init__(self.message)

def divide(a, b):
    if b == 0:
        raise CustomException("Division by zero is not allowed")
    return a / b

try:
    result = divide(10, 0)
except CustomException as e:
    print("Custom Exception:", e)
else:
    print("Result:", result)

In this example, we define the CustomException class and use it to raise a custom exception when dividing by zero. When the exception is caught in the except block, you can access the custom error message associated with it.

⬆ Back to Top

Map

Definition: The map function in Python is a built-in function that applies a specified function to each item in an iterable (e.g., a list, tuple, or other iterable objects) and returns a new iterable (usually a map object, which can be converted to a list or another iterable). It is commonly used for performing a transformation or mapping operation on each element of a sequence.

Syntax:

map(function, iterable, ...)

• function: The function to apply to each item in the iterable.
• iterable: An iterable (e.g., a list) whose elements will be processed by the function.

Example: Using map to Square Numbers

# Define a function to square a number
def square(x):
    return x ** 2

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

# Use map to apply the square function to each element in the list
squared_numbers = map(square, numbers)

# Convert the map object to a list (or use it as an iterable)
squared_numbers_list = list(squared_numbers)

print(squared_numbers_list)

Output:

[1, 4, 9, 16, 25]

Key Points:

• The map function applies the specified function to each item in the iterable, producing a map object.
• You can convert the map object to a list or another iterable using the list() function or iterate through it directly.
• The map function is often used to avoid writing explicit loops for simple transformation tasks, making code more concise and readable.
• You can use map with multiple iterables by providing additional iterable arguments, and the function should accept as many arguments as there are iterables.

Example: Using map with Multiple Iterables

# Define a function to add two numbers
def add(x, y):
    return x + y

# Create two lists of numbers
numbers1 = [1, 2, 3]
numbers2 = [10, 20, 30]

# Use map to apply the add function to pairs of elements from both lists
sums = map(add, numbers1, numbers2)

# Convert the map object to a list (or use it as an iterable)
sums_list = list(sums)

print(sums_list)

Output:

[11, 22, 33]

⬆ Back to Top

Filter

Definition: The filter function in Python is a built-in function that allows you to filter elements from an iterable (e.g., a list) based on a specified function or condition. It creates a new iterable containing only the elements that meet the condition defined by the given function.

Syntax:

filter(function, iterable)

• function: The function that defines the condition for filtering elements. This function should return True or False.
• iterable: The iterable (e.g., a list) from which elements will be filtered.

Example: Using filter to Filter Even Numbers

# Define a function to check if a number is even
def is_even(x):
    return x % 2 == 0

# Create a list of numbers
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Use filter to get only the even numbers from the list
even_numbers = filter(is_even, numbers)

# Convert the filter object to a list (or use it as an iterable)
even_numbers_list = list(even_numbers)

print(even_numbers_list)

Output:

[2, 4, 6, 8, 10]

Key Points:

• The filter function applies the specified function (the filter condition) to each item in the iterable, creating a filter object.
• The filter object is an iterator, and you can convert it to a list or another iterable using the list() function or iterate through it directly.
• The specified function should return True for elements that should be included in the filtered result and False for elements to be excluded.
• filter is a powerful tool for selecting elements from a collection based on a custom condition, making it useful for data filtering and selection tasks.
• In Python 3, filter returns an iterable, so you may need to convert it to a list or tuple to see the filtered results.

Example: Using filter with Lambda Function

You can also use filter with a lambda function for simpler filtering tasks:

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

# Use filter with a lambda function to filter even numbers
even_numbers = filter(lambda x: x % 2 == 0, numbers)

even_numbers_list = list(even_numbers)

print(even_numbers_list)

Output:

[2, 4, 6, 8, 10]

⬆ Back to Top

Reduce

Definition: The reduce function in Python is part of the functools module and allows you to repeatedly apply a specified function to the elements of an iterable (e.g., a list), accumulating a single result. It's particularly useful for performing aggregations or calculations that involve combining elements in a sequence step by step.

Syntax:

functools.reduce(function, iterable[, initializer])

• function: The function to apply cumulatively to the items in the iterable.
• iterable: The iterable (e.g., a list) whose elements will be reduced.
• initializer (optional): An initial value that serves as the first argument to the function. If not provided, the first two elements of the iterable are used as the initial values.

Example: Using reduce to Find the Sum of Numbers

import functools

# Define a function to add two numbers
def add(x, y):
    return x + y

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

# Use reduce to find the sum of numbers
result = functools.reduce(add, numbers)

print(result)

Output:

15

Key Points:

• The reduce function applies the specified function cumulatively to the items in the iterable, taking two at a time.
• It starts with the first two elements of the iterable (or the initializer if provided) and combines them using the function.
• The result is then combined with the next element in the iterable, and this process continues until all elements have been processed.
• reduce is particularly useful for performing operations that involve aggregation or accumulation, such as finding the sum, product, or maximum value of a sequence.
• You can use reduce with both built-in functions and custom functions.
• In Python 3, reduce has been moved to the functools module, so you need to import it as shown in the example.

Example: Using reduce with a Custom Function

import functools

# Define a custom function to find the maximum of two numbers
def find_max(x, y):
    return x if x > y else y

# Create a list of numbers
numbers = [12, 45, 6, 78, 23]

# Use reduce to find the maximum value in the list
max_value = functools.reduce(find_max, numbers)

print(max_value)

Output:

78

⬆ Back to Top

Modules and Packages

Definition: In Python, a module is a file containing Python code that can be reused in other Python programs. A package is a way to organize related modules into directories. Modules and packages promote code reusability, maintainability, and organization in larger projects.

Modules:

• A module is a single Python file containing variables, functions, and classes.
• It can be used to encapsulate related code, making it easier to manage and maintain.
• You can create your own modules or use built-in ones from the Python Standard Library.

Packages:

• A package is a directory that contains multiple related Python modules.
• Packages are indicated by the presence of an __init__.py file within the directory (it can be empty).
• Packages allow you to organize your code hierarchically, providing structure to your project.

Using Modules:

1. Importing Entire Modules:

   import module_name
   result = module_name.function_name()

2. Importing Specific Components:

   from module_name import function_name, variable_name
   result = function_name()

3. Importing with Alias:

   import module_name as alias_name
   result = alias_name.function_name()

Using Packages:

1. Importing Modules from Packages:

   from package_name import module_name
   result = module_name.function_name()

2. Nested Packages: You can have packages within packages to create a hierarchical structure.

   from package_name.subpackage_name import module_name
   result = module_name.function_name()

Significance:

• Code Organization: Modules and packages help organize your code into manageable units. This is crucial for large projects where maintaining a clean codebase is essential.

• Code Reusability: Modules and packages allow you to reuse code across multiple parts of your project or even in different projects.

• Collaboration: In collaborative coding environments, modules and packages make it easier to divide tasks among team members, each working on different parts of the project.

• Third-Party Libraries: Many third-party libraries, such as NumPy, Pandas, and Matplotlib, are organized into modules and packages. Understanding this structure is essential for utilizing these libraries effectively.

Example:

Consider a project for creating a game. You can have modules like player.py, enemy.py, and utils.py. These can be organized into a package named game. This structure makes it easier to manage game-related code.

game/
    __init__.py
    player.py
    enemy.py
    utils.py

In your main script, you can import these modules as needed:

from game import player, enemy, utils

player.initialize_player()
enemy.spawn_enemy()
utils.calculate_score()

Modules and packages are fundamental concepts in Python that facilitate code organization, reusability, and collaboration, making them essential for developing maintainable and scalable projects.

⬆ Back to Top

Importing Modules

Definition: In Python, modules are files containing Python code that can be reused in other programs. They are essential for code organization, reusability, and maintainability. Importing modules allows you to access functions, classes, and variables defined in those modules.

Basic Syntax:

import module_name

Example:

import math  # Importing the math module
result = math.sqrt(16)  # Using a function from the math module

Importing Specific Components:

from module_name import function_name, variable_name

Example:

from random import randint  # Importing the randint function from the random module
random_number = randint(1, 100)

Importing with Alias:

import module_name as alias_name

Example:

import datetime as dt  # Importing the datetime module with the alias 'dt'
current_time = dt.datetime.now()

Best Practices for Importing Modules

1. Use Explicit Imports: Avoid using wildcard imports (from module_name import *) as they can make it unclear where functions or variables are coming from. Explicit imports provide clarity.

2. Import Standard Library First: When organizing your imports, it's a common practice to import standard library modules first, followed by third-party libraries, and finally, your project-specific modules.

3. Follow PEP 8 Guidelines: Adhere to Python's PEP 8 style guide, which recommends using lowercase module names separated by underscores (e.g., import os, not import OS).

4. Import All Required Modules at the Top: Import all necessary modules at the beginning of your script or module to make dependencies clear and easily visible.

5. Use Descriptive Names: Choose meaningful names for modules and aliases to enhance code readability. For example, import numpy as np is a common alias for the NumPy library.

6. Avoid Circular Imports: Be cautious of circular imports, where module A imports module B, and module B imports module A. This can lead to unexpected behavior.

7. Document Dependencies: Consider including a comment or documentation at the top of your script/module listing the external modules used, their versions, and any installation instructions (for third-party modules).

Example with Best Practices

# Standard library imports
import os
import datetime

# Third-party library imports
import numpy as np
import pandas as pd

# Project-specific module imports
from my_module import my_function

⬆ Back to Top

Creating and Using Packages

Definition: In Python, a package is a directory containing one or more related Python modules. It allows you to organize your code into a hierarchical structure, making it easier to manage and maintain larger projects.

Creating a Package:

1. Create a directory with a name that will become your package name.

   my_package/
   

2. Inside the package directory, you can create multiple module files (.py) containing Python code.

   my_package/
       __init__.py
       module1.py
       module2.py
   

3. The __init__.py file can be empty or contain initialization code for the package.

Using a Package:

1. Import modules from the package in your Python script using dot notation.

   from my_package import module1, module2

2. Use functions, classes, and variables defined in the imported modules as needed.

   result1 = module1.function1()
   result2 = module2.function2()

Example:

Let's create a simple package named my_package with two modules, module1 and module2.

my_package/
    __init__.py
    module1.py
    module2.py

Contents of module1.py:

def function1():
    return "Function 1 from module 1"

Contents of module2.py:

def function2():
    return "Function 2 from module 2"

Now, in your Python script, you can use the package and its modules as follows:

from my_package import module1, module2

result1 = module1.function1()
result2 = module2.function2()

print(result1)  # Output: Function 1 from module 1
print(result2)  # Output: Function 2 from module 2

Nested Packages:

You can create a hierarchical structure by nesting packages within other packages. For example:

my_package/
    __init__.py
    module1.py
    sub_package/
        __init__.py
        module3.py

In this structure, you can import module3 as follows:

from my_package.sub_package import module3

result3 = module3.function3()
print(result3)  # Output: Function 3 from module 3

⬆ Back to Top

Standard Packages

Definition: The Python Standard Library is a collection of modules and packages that come bundled with the Python interpreter. These modules provide a wide range of functionalities, from basic operations to advanced features, and can be readily used without requiring additional installations.

Key Features:

1. Versatility: The Python Standard Library covers a vast array of domains, including file I/O, data manipulation, networking, web development, mathematics, and more.

2. Reliability: These modules are thoroughly tested, stable, and widely used, making them reliable choices for various programming tasks.

3. Cross-Platform: The Standard Library is available on all major platforms, ensuring your Python code is portable.

4. Documentation: The Python Standard Library is well-documented, with official documentation available online, making it easy to find information and examples.

Examples of Commonly Used Modules:

1. os: Provides a portable way to use operating system-dependent functionality like file and directory operations.

2. datetime: Offers classes for manipulating dates and times, making it useful for working with timestamps.

3. json: Enables encoding and decoding JSON (JavaScript Object Notation) data, a common data interchange format.

4. math: Provides mathematical functions and constants for mathematical operations.

5. random: Offers functions for generating random numbers and making random selections.

6. urllib: Allows for interacting with websites and web services, enabling HTTP requests and responses.

7. collections: Provides additional data structures like namedtuple, deque, and Counter for more advanced data manipulation.

Example: Using the datetime Module

import datetime

# Get the current date and time
current_time = datetime.datetime.now()
print("Current Date and Time:", current_time)

# Format a date as a string
formatted_date = current_time.strftime("%Y-%m-%d %H:%M:%S")
print("Formatted Date:", formatted_date)

Example: Using the os Module

import os

# Get the current working directory
current_directory = os.getcwd()
print("Current Directory:", current_directory)

# List files in a directory
file_list = os.listdir(current_directory)
print("Files in Directory:", file_list)

The Python Standard Library simplifies the development process by providing readily available solutions for a wide range of tasks, saving you time and effort. Learning to utilize these modules effectively is a valuable skill for any Python programmer. To explore the complete list of modules and their documentation, refer to the official Python documentation available online.

⬆ Back to Top

File Handling

Definition: File handling in Python refers to the process of reading from and writing to files on your computer's storage. It allows you to interact with files, such as reading data from text files, writing data to text files, and performing various operations like creating, deleting, and renaming files.

Key File Handling Operations:

1. Opening a File: You need to open a file before you can read from or write to it. Python provides built-in functions like open() to open files.

   file = open("example.txt", "r")  # Open the file in read mode

2. Reading from a File: You can read the contents of a file using methods like read(), readline(), or by iterating through the file object.

   content = file.read()  # Read the entire file

3. Writing to a File: To write data to a file, you need to open it in write mode ("w") or append mode ("a").

   with open("output.txt", "w") as output_file:
       output_file.write("Hello, World!")

4. Closing a File: It's important to close a file after you've finished working with it to free up system resources.

   file.close()

Context Managers (with Statement): The with statement is used for file handling to ensure that files are properly closed after their suite finishes execution. It simplifies the process of file handling.

with open("example.txt", "r") as file:
    content = file.read()
    # File is automatically closed when the block exits

Common File Modes:

• "r": Read (default mode). Opens the file for reading.

• "w": Write. Opens the file for writing. Creates a new file or truncates an existing file.

• "a": Append. Opens the file for writing, but appends data to the end of the file.

• "b": Binary mode. Reads or writes binary data (e.g., "rb" for reading binary).

• "x": Exclusive creation. Opens the file for writing, but it will fail if the file already exists.

• "t": Text mode (default). Used with "r", "w", or "a" to specify text mode. For example, "rt" for reading text.

• "+": Update mode. Used with "r" or "w" to allow both reading and writing. For example, "r+" for reading and writing.

• "rb": Read a binary file.

• "wb": Write to a binary file (creates or truncates).

• "ab": Append to a binary file.

• "xt": Exclusive creation of a text file.

• "r+": Read and write in text mode.

• "w+": Read and write, creating the file if it doesn't exist (text mode).

• "a+": Read and append, creating the file if it doesn't exist (text mode).

File Handling Practices:

• Always close files using file.close() or use the with statement to ensure proper file closure.
• Check if a file exists before opening it to avoid errors.
• Handle exceptions when working with files, as file operations can raise exceptions if something goes wrong.

Example: Reading from a File

with open("example.txt", "r") as file:
    content = file.read()
    print(content)

Example: Writing to a File

with open("output.txt", "w") as output_file:
    output_file.write("Hello, World!")

Exclusive Creation - "x":

try:
    with open("new_file.txt", "x") as file:
        file.write("This is a new file.")
except FileExistsError:
    print("File already exists.")

Text Mode (Default) - "t":

with open("text_file.txt", "rt") as file:
    content = file.read()
    print(content)

Update Mode - "+":

with open("existing_file.txt", "r+") as file:
    content = file.read()
    file.write("Appending new data.")

Read a Binary File - "rb":

with open("binary_file.bin", "rb") as file:
    binary_data = file.read()
    # Process binary data

Write to a Binary File - "wb":

with open("binary_output.bin", "wb") as file:
    binary_data = b"This is binary data."
    file.write(binary_data)

Append to a Binary File - "ab":

with open("binary_output.bin", "ab") as file:
    binary_data = b"Appending binary data."
    file.write(binary_data)

Exclusive Creation of a Text File - "xt":

try:
    with open("new_text_file.txt", "xt") as file:
        file.write("This is a new text file.")
except FileExistsError:
    print("File already exists.")

Read and Write in Text Mode - "r+":

with open("read_write_file.txt", "r+") as file:
    content = file.read()
    file.write("Appending new data.")

Read and Write, Creating the File if It Doesn't Exist (Text Mode) - "w+":

with open("new_or_existing_file.txt", "w+") as file:
    file.write("This file may or may not have existed before.")
    file.seek(0)  # Move the file cursor to the beginning
    content = file.read()
    print(content)

Read and Append, Creating the File if It Doesn't Exist (Text Mode) - "a+":

with open("new_or_existing_file.txt", "a+") as file:
    file.write("This file may or may not have existed before.")
    file.seek(0)  # Move the file cursor to the beginning
    content = file.read()
    print(content)

File handling is a fundamental aspect of programming, and Python's file handling capabilities make it easy to work with various file types and perform essential data input and output operations. Understanding file handling is crucial for tasks such as data processing, log analysis, and configuration management.

⬆ Back to Top

Os Module

Definition: The os module in Python provides a portable way to interact with the operating system, allowing you to perform various operating system-related tasks, such as file and directory operations, environment variable manipulation, and more. It abstracts platform-specific differences, making your code more cross-platform compatible.

Commonly Used os Functions and Methods:

1. File and Directory Operations:

   • os.getcwd(): Get the current working directory.

   import os
   current_directory = os.getcwd()

   • os.listdir(path): List files and directories in a specified directory.

   file_list = os.listdir("/path/to/directory")

   • os.mkdir(path): Create a new directory.

   os.mkdir("new_directory")

   • os.rename(src, dst): Rename a file or directory.

   os.rename("old_name.txt", "new_name.txt")

   • os.remove(path): Remove a file.

   os.remove("file_to_delete.txt")

   • os.rmdir(path): Remove an empty directory.

   os.rmdir("empty_directory")

2. Path Manipulation:

   • os.path.join(path, *paths): Join one or more path components into a single path.

   full_path = os.path.join("/path/to", "directory", "file.txt")

   • os.path.exists(path): Check if a file or directory exists.

   if os.path.exists("file_or_directory"):
       # Perform file operations

3. Environment Variables:

   • os.environ: A dictionary-like object containing environment variables.

   value = os.environ.get("MY_ENV_VARIABLE")

4. Platform Identification:

   • os.name: Get the name of the operating system (e.g., "posix" or "nt" for Unix-like or Windows systems).

   platform_name = os.name

Example: Listing Files in a Directory

import os

directory_path = "/path/to/directory"
if os.path.exists(directory_path):
    file_list = os.listdir(directory_path)
    print("Files in directory:", file_list)
else:
    print("Directory not found.")

The os module is a powerful tool for working with files, directories, and environment variables in a cross-platform way. It simplifies many common system-related tasks and allows your Python code to run consistently on different operating systems.

⬆ Back to Top

Opening Files

Definition: In Python, opening files is a fundamental operation that allows you to access and manipulate data stored in files on your computer's storage. Python provides built-in functions for opening, reading from, and writing to files.

File Opening Modes:

• Read Mode ("r"): Opens a file for reading. This is the default mode if no mode is specified.

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

• Write Mode ("w"): Opens a file for writing. If the file already exists, it truncates its contents; if it doesn't exist, it creates a new file.

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

• Append Mode ("a"): Opens a file for writing, but appends data to the end of the file. If the file doesn't exist, it creates a new file.

  file = open("log.txt", "a")

Using with Statement:

The with statement is a recommended practice for file handling in Python. It ensures that the file is properly closed after the code block finishes executing. This is useful for preventing resource leaks.

with open("example.txt", "r") as file:
    content = file.read()

Common File Operations:

1. Reading from a File:

   • Use methods like read(), readline(), or iterate through the file object to read data from a file.

   content = file.read()

2. Writing to a File:

   • Use the write() method to write data to a file. Remember to open the file in write mode ("w" or "a") to enable writing.

   with open("output.txt", "w") as output_file:
       output_file.write("Hello, World!")

3. Closing a File:

   • After you've finished working with a file, it's important to close it to release system resources.

   file.close()

Best Practices:

• Always close files using file.close() or use the with statement to ensure proper file closure.
• Check if a file exists before opening it to avoid errors.
• Handle exceptions when working with files, as file operations can raise exceptions if something goes wrong.

Example: Reading from a File

with open("example.txt", "r") as file:
    content = file.read()
    print(content)

Example: Writing to a File

with open("output.txt", "w") as output_file:
    output_file.write("Hello, World!")

⬆ Back to Top

Reading Files

Definition: Reading files in Python involves the process of accessing and extracting data from files stored on your computer's storage. Python provides built-in functions and methods to open and read data from various types of files, including text files, CSV files, JSON files, and more.

Opening Files for Reading:

To read from a file in Python, you must first open the file using the open() function. You specify the file's name and the mode as "r" (read mode). This mode allows you to read the file's contents without modifying it.

# Opening a file for reading
with open("example.txt", "r") as file:
    content = file.read()

Reading Methods:

Python offers several methods for reading file content:

1. read(): Reads the entire contents of the file as a string.

content = file.read()

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

line = file.readline()

3. readlines(): Reads all lines of the file and returns them as a list.

lines = file.readlines()

Iterating through a File:

You can also iterate through the lines of a file using a for loop. This is useful when processing large files line by line to conserve memory.

with open("example.txt", "r") as file:
    for line in file:
        # Process each line

Common File Formats:

• Text Files: Simple plain text files containing human-readable text.
• CSV Files: Comma-separated values files used for storing tabular data.
• JSON Files: JavaScript Object Notation files for storing structured data.
• XML Files: Extensible Markup Language files for representing structured data.

Example: Reading from a Text File

Consider the following content in a file named example.txt:

Hello, World!
This is a sample file.
Python is awesome!

Here's how you can read and print its content:

with open("example.txt", "r") as file:
    content = file.read()
    print(content)

The output will be:

Hello, World!
This is a sample file.
Python is awesome!

Example: Reading from a CSV File

Consider the following content in a file named example.csv:

Name,Email,Phone
Alice,
Bob,
Charlie,

Here's how you can read and print its content:

import csv

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

⬆ Back to Top

Writing Files

Definition: Writing files in Python involves the process of creating, opening, and adding data to files stored on your computer's storage. Python provides built-in functions and methods to open files in write mode ("w") or append mode ("a") and then write data to these files.

Opening Files for Writing:

To write to a file in Python, you must first open the file using the open() function. You specify the file's name and the mode as "w" (write mode) to create a new file or truncate an existing file, or "a" (append mode) to add data to the end of an existing file.

# Opening a file for writing
with open("output.txt", "w") as output_file:
    output_file.write("Hello, World!")

File Writing Methods:

Python offers a few methods for writing data to a file:

1. write(text): Writes the specified text to the file. If the file doesn't exist, it creates a new one; if it exists, it truncates the file's contents.

with open("output.txt", "w") as output_file:
    output_file.write("Hello, World!")

2. writelines(lines): Writes a list of lines to the file. You need to add newline characters ("\n") at the end of each line if you want them separated by newlines.

lines = ["Line 1", "Line 2", "Line 3"]
with open("output.txt", "w") as output_file:
    output_file.writelines(lines)

Appending Data to a File:

If you want to add data to an existing file without overwriting its contents, you can open the file in append mode ("a"):

# Opening a file for appending
with open("log.txt", "a") as log_file:
    log_file.write("Error: Something went wrong\n")

Common File Formats:

• Text Files: Simple plain text files containing human-readable text.
• CSV Files: Comma-separated values files used for storing tabular data.
• JSON Files: JavaScript Object Notation files for storing structured data.
• XML Files: Extensible Markup Language files for representing structured data.

Example: Writing to a Text File

Here's how you can create a new file or overwrite an existing one with some content:

with open("output.txt", "w") as output_file:
    output_file.write("Hello, World!\n")
    output_file.write("This is a new line.")

The content of output.txt will be:

Hello, World!
This is a new line.

⬆ Back to Top

Closing Files

Definition: Closing files in Python refers to the process of explicitly ending the connection between your Python program and an open file. It's important to close files after reading from or writing to them to ensure that system resources are freed up and that changes are saved properly.

Using the with Statement:

In Python, the recommended way to work with files is by using the with statement. This context manager ensures that the file is automatically closed when the block of code inside it is exited. This prevents resource leaks and potential data corruption.

with open("example.txt", "r") as file:
    content = file.read()
# The file is automatically closed when this block is exited

Explicitly Closing Files:

If you choose not to use the with statement, it's crucial to explicitly close the file using the close() method. Failing to do so may lead to resource leaks and issues with data not being saved properly.

file = open("example.txt", "r")
content = file.read()
file.close()  # Close the file explicitly

Best Practices:

• Always close files using file.close() or use the with statement to ensure proper file closure.
• Avoid relying on Python's automatic garbage collection for closing files, as it may not close the file immediately.

Example: Using the with Statement

with open("example.txt", "r") as file:
    content = file.read()
# The file is automatically closed when this block is exited

Example: Explicitly Closing a File

file = open("example.txt", "r")
content = file.read()
file.close()  # Close the file explicitly

⬆ Back to Top

Working with Files

Definition: Working with files in Python involves various operations, including reading from and writing to files, checking file existence, navigating directories, and handling exceptions related to file operations. Python provides a rich set of tools and modules to facilitate these tasks.

Key File Operations:

1. Opening Files: Use the open() function to open a file. Specify the filename and the mode (e.g., "r" for reading, "w" for writing, "a" for appending).

   with open("example.txt", "r") as file:
       content = file.read()

2. Reading from Files: You can read file contents using methods like read(), readline(), or readlines().

   content = file.read()

3. Writing to Files: To write data to a file, open it in write mode ("w") or append mode ("a") and use the write() method.

   with open("output.txt", "w") as output_file:
       output_file.write("Hello, World!")

4. File Closing: It's crucial to close files using file.close() or utilize the with statement to ensure proper file closure.

   file.close()

5. File Existence Check: You can check if a file exists before attempting to open or manipulate it using the os.path.exists() function.

   import os
   if os.path.exists("example.txt"):
       # Perform file operations

6. Working with Directories: The os module provides functions like os.listdir(), os.mkdir(), and os.chdir() for navigating and manipulating directories.

   import os
   file_list = os.listdir("/path/to/directory")

7. Exception Handling: When working with files, handle exceptions using try and except blocks to gracefully manage errors, such as file not found or permission issues.

   try:
       with open("example.txt", "r") as file:
           content = file.read()
   except FileNotFoundError:
       print("File not found.")

Best Practices:

• Use the with statement for file handling to ensure proper file closure and prevent resource leaks.
• Check for file existence before performing file operations to avoid exceptions.
• Handle exceptions related to file operations to provide meaningful error messages.

Example: Reading and Writing a File

try:
    # Reading from a file
    with open("example.txt", "r") as file:
        content = file.read()
    print("File content:", content)

    # Writing to a file
    with open("output.txt", "w") as output_file:
        output_file.write("Hello, World!")
except FileNotFoundError:
    print("File not found.")
except Exception as e:
    print("An error occurred:", str(e))

⬆ Back to Top

---

⬆ Back to Top

License

This project is licensed under the MIT License.