class Car:
    pass

my_car = Car()

class Car:
    wheels = 4  # Class attribute

    def __init__(self, make, model):
        self.make = make  # Instance attribute
        self.model = model

class Car:
    def start(self):
        print("Starting the car.")

    def drive(self, speed):
        print(f"Driving the car at {speed} mph.")

class ElectricCar(Car):
    def __init__(self, make, model, battery_capacity):
        super().__init__(make, model)
        self.battery_capacity = battery_capacity

class BankAccount:
    def __init__(self, balance):
        self.__balance = balance  # Private attribute

    def deposit(self, amount):
        self.__balance += amount

class Dog:
    def speak(self):
        print("Woof!")

class Cat:
    def speak(self):
        print("Meow!")

animals = [Dog(), Cat()]
for animal in animals:
    animal.speak()

# Define a class named 'Dog'
class Dog:
    # Constructor method to initialize attributes
    def __init__(self, name, age):
        self.name = name  # Instance attribute
        self.age = age    # Instance attribute

    # Method to make the dog bark
    def bark(self):
        return f"{self.name} says Woof!"

    # Method to get the dog's age
    def get_age(self):
        return f"{self.name} is {self.age} years old."

# Create an object (instance) of the Dog class
my_dog = Dog("Buddy", 3)

# Accessing attributes and methods
print(my_dog.bark())         # Output: Buddy says Woof!
print(my_dog.get_age())      # Output: Buddy is 3 years old.

1. Class Definition: The Dog class is defined with an __init__ constructor method that initializes the name and age attributes when a new object is created.

2. Methods:
• The bark() method returns a string indicating that the dog barks.
• The get_age() method returns the age of the dog.

3. Creating an Object: An object named my_dog is created as an instance of the Dog class with the name "Buddy" and age 3.

4. Accessing Methods: The methods bark() and get_age() are called on the my_dog object, demonstrating how to interact with the object's behavior.

# Parent class
class Animal:
    def speak(self):
        return "Animal speaks"

# Child class
class Dog(Animal):
    def bark(self):
        return "Dog barks"

# Creating an object of the Dog class
my_dog = Dog()
print(my_dog.speak())  # Output: Animal speaks
print(my_dog.bark())   # Output: Dog barks

# Grandparent class
class Animal:
    def speak(self):
        return "Animal speaks"

# Parent class
class Dog(Animal):
    def bark(self):
        return "Dog barks"

# Child class
class Puppy(Dog):
    def weep(self):
        return "Puppy weeps"

# Creating an object of the Puppy class
my_puppy = Puppy()
print(my_puppy.speak())  # Output: Animal speaks
print(my_puppy.bark())   # Output: Dog barks
print(my_puppy.weep())   # Output: Puppy weeps

# Parent class 1
class Flyer:
    def fly(self):
        return "Can fly"

# Parent class 2
class Swimmer:
    def swim(self):
        return "Can swim"

# Child class inheriting from both Flyer and Swimmer
class Duck(Flyer, Swimmer):
    def quack(self):
        return "Duck quacks"

# Creating an object of the Duck class
my_duck = Duck()
print(my_duck.fly())     # Output: Can fly
print(my_duck.swim())    # Output: Can swim
print(my_duck.quack())    # Output: Duck quacks

# Parent class
class Animal:
    def speak(self):
        return "Animal speaks"

# Child class 1
class Dog(Animal):
    def bark(self):
        return "Dog barks"

# Child class 2
class Cat(Animal):
    def meow(self):
        return "Cat meows"

# Creating objects of Dog and Cat classes
my_dog = Dog()
my_cat = Cat()

print(my_dog.speak())  # Output: Animal speaks
print(my_dog.bark())   # Output: Dog barks

print(my_cat.speak())  # Output: Animal speaks
print(my_cat.meow())   # Output: Cat meows

• Single Inheritance: A child class inherits from one parent class.

• Multilevel Inheritance: A child class inherits from a parent that is also a child of another parent.

• Multiple Inheritance: A child class inherits from multiple parent classes.

• Hierarchical Inheritance: Multiple child classes inherit from the same parent class.

# Parent class
class Animal:
    def speak(self):
        return "Animal speaks"

# Child class
class Dog(Animal):
    def speak(self):  # Overriding the speak method
        return "Dog barks"

# Child class
class Cat(Animal):
    def speak(self):  # Overriding the speak method
        return "Cat meows"

# Creating objects of Dog and Cat classes
my_dog = Dog()
my_cat = Cat()

print(my_dog.speak())  # Output: Dog barks
print(my_cat.speak())  # Output: Cat meows

• The Animal class has a method called speak().

• Both Dog and Cat classes inherit from Animal and override the speak() method to provide their specific implementations.

• When calling speak() on instances of Dog and Cat, the overridden methods are executed.

class MathOperations:
    def add(self, a, b=0, c=0):  # Default arguments allow for overloading behavior
        return a + b + c

math_ops = MathOperations()

print(math_ops.add(5))          # Output: 5 (5 + 0 + 0)
print(math_ops.add(5, 10))      # Output: 15 (5 + 10 + 0)
print(math_ops.add(5, 10, 15))   # Output: 30 (5 + 10 + 15)

• The MathOperations class has an add() method that can take one, two, or three parameters.

• By providing default values for b and c, we can call add() with different numbers of arguments, demonstrating a form of method overloading.

• Polymorphism allows methods to do different things based on the object it is acting upon.

• Method Overriding enables subclasses to provide specific implementations for methods defined in their parent classes.

• Method Overloading can be simulated in Python using default arguments or variable-length arguments since Python does not support traditional method overloading.

1. Define the Vector Class: We will define a class with an initializer to set the vector's components and implement the __add__() method to handle addition.

class Vector:
    def __init__(self, x, y):
        self.x = x  # x-coordinate
        self.y = y  # y-coordinate

    def __add__(self, other):
        """Overload the + operator to add two vectors."""
        if isinstance(other, Vector):
            return Vector(self.x + other.x, self.y + other.y)
        return NotImplemented  # Return NotImplemented for unsupported types

    def __repr__(self):
        """Return a string representation of the vector."""
        return f"Vector({self.x}, {self.y})"

# Creating instances of Vector
v1 = Vector(2, 3)
v2 = Vector(4, 5)

# Using the overloaded + operator
result = v1 + v2

# Print the result
print("Result of v1 + v2:", result)  # Output: Result of v1 + v2: Vector(6, 8)

1. Class Definition: The Vector class is defined with an initializer (__init__) that takes two parameters (x and y) representing the coordinates of the vector.

2. Overloading the + Operator:
• The __add__() method is defined to handle addition.
• It checks if the other object being added is also an instance of Vector. If it is, it returns a new Vector object with the sum of the respective components.
• If the other object is not a Vector, it returns NotImplemented, which allows Python to handle unsupported operations gracefully.

3. String Representation: The __repr__() method provides a string representation of the vector for easier debugging and display.

4. Creating Instances: Two instances of Vector, v1 and v2, are created.

5. Using the Overloaded Operator: The overloaded + operator is used to add two vectors, resulting in a new vector that is printed out.

• Definition: Data abstraction refers to the concept of exposing only the essential features of an object while hiding the complex implementation details. It focuses on what an object does rather than how it does it.

• Purpose: The main goal of data abstraction is to reduce complexity by providing a simplified view of the object to the user. It allows users to interact with objects without needing to understand their internal workings.

• Implementation: In Python, data abstraction is typically achieved through abstract classes and interfaces. Abstract classes can define abstract methods that must be implemented by subclasses.

from abc import ABC, abstractmethod

# Abstract class
class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

# Concrete class
class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

# Using the abstract class
rectangle = Rectangle(5, 10)
print("Area of rectangle:", rectangle.area())  # Output: Area of rectangle: 50

• Definition: Data hiding is a principle that restricts access to certain details of an object. It ensures that sensitive data is protected from unauthorized access and modification. This is often achieved by making attributes private or protected.

• Purpose: The main goal of data hiding is to safeguard an object's internal state and prevent unintended interference or misuse. It enhances security and integrity by controlling access to the object's data.

• Implementation: In Python, data hiding can be implemented using naming conventions (e.g., prefixing an attribute with an underscore _ for protected or double underscores __ for private attributes).

class BankAccount:
    def __init__(self, balance):
        self.__balance = balance  # Private attribute

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount

    def get_balance(self):
        return self.__balance

# Using the BankAccount class
account = BankAccount(1000)
account.deposit(500)
print("Current Balance:", account.get_balance())  # Output: Current Balance: 1500

# Attempting to access the private attribute will raise an error
# print(account.__balance)  # Uncommenting this line will raise AttributeError

class Animal:
    pass

class Dog(Animal):
    pass

dog = Dog()
print(isinstance(dog, Dog))     # True
print(isinstance(dog, Animal))  # True

print(issubclass(Dog, Animal))  # True
print(issubclass(Animal, Dog))  # False

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

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)
        self.breed = breed

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

person = Person("John", 30)
print(person.name)  # Output: John
print(person.age)   # Output: 30

• Data Protection: Encapsulation helps protect the integrity of the data by restricting access to it.

• Controlled Access: It allows controlled access to the attributes through getter and setter methods.

• Maintainability: Changes to the internal implementation can be made without affecting external code that uses the class.

• Getter Method: A method that retrieves the value of a private attribute.

• Setter Method: A method that sets or updates the value of a private attribute.

class Employee:
    def __init__(self, name, salary):
        self.__name = name      # Private attribute
        self.__salary = salary  # Private attribute

    # Getter method for name
    def get_name(self):
        return self.__name

    # Setter method for name
    def set_name(self, name):
        self.__name = name

    # Getter method for salary
    def get_salary(self):
        return self.__salary

    # Setter method for salary with validation
    def set_salary(self, salary):
        if salary < 0:
            raise ValueError("Salary cannot be negative")
        self.__salary = salary


# Creating an object of Employee class
emp = Employee("Alice", 50000)

# Accessing attributes using getter methods
print("Employee Name:", emp.get_name())         # Output: Employee Name: Alice
print("Employee Salary:", emp.get_salary())     # Output: Employee Salary: 50000

# Modifying attributes using setter methods
emp.set_name("Bob")
emp.set_salary(60000)

print("Updated Employee Name:", emp.get_name())         # Output: Updated Employee Name: Bob
print("Updated Employee Salary:", emp.get_salary())     # Output: Updated Employee Salary: 60000

# Attempting to set a negative salary will raise an error
try:
    emp.set_salary(-1000)  # This will raise ValueError
except ValueError as e:
    print(e)  # Output: Salary cannot be negative

1. Class Definition: The Employee class encapsulates two private attributes: __name and __salary.

2. Getter Methods:
• get_name(): Returns the value of the private attribute __name.
• get_salary(): Returns the value of the private attribute __salary.

3. Setter Methods:
• set_name(name): Updates the value of __name.
• set_salary(salary): Updates the value of __salary, but includes validation to ensure that the salary cannot be negative.

4. Object Creation: An instance of the Employee class is created with initial values.

5. Accessing Attributes: The values are accessed using getter methods.

6. Modifying Attributes: The values are modified using setter methods, demonstrating how encapsulation allows controlled access to internal state.

7. Validation in Setters: The setter for salary checks if the new salary is valid before updating it, enforcing rules that help maintain data integrity.

1. Encapsulation: ADTs encapsulate the data and the operations that manipulate that data. This means that the implementation details are hidden from the user, allowing for a clean and clear interface.

2. Data Abstraction: ADTs provide a way to define complex data structures in terms of simpler ones. Users interact with the ADT through a defined interface, which abstracts away the complexities of the underlying implementation.

3. Modularity: By separating the interface from the implementation, ADTs promote modularity in programming. Changes to the implementation do not affect code that uses the ADT as long as the interface remains consistent.

4. Flexibility: ADTs allow for different implementations of the same data type. For example, a stack can be implemented using an array or a linked list, but both implementations can be treated as a stack ADT.

1. Improved Code Readability: By focusing on what operations are available rather than how they are implemented, code becomes easier to read and understand.

2. Ease of Maintenance: Changes to the implementation of an ADT do not affect code that relies on it, making maintenance easier and less error-prone.

3. Reusability: ADTs can be reused across different programs or modules without needing to change their internal workings.

4. Enhanced Security: By hiding implementation details, ADTs protect against unintended interference with the data structure's integrity.

class Stack:
    def __init__(self):
        self.__items = []  # Private attribute to hold stack items

    def push(self, item):
        """Add an item to the top of the stack."""
        self.__items.append(item)

    def pop(self):
        """Remove and return the top item from the stack."""
        if not self.is_empty():
            return self.__items.pop()
        raise IndexError("pop from empty stack")

    def peek(self):
        """Return the top item without removing it."""
        if not self.is_empty():
            return self.__items[-1]
        raise IndexError("peek from empty stack")

    def is_empty(self):
        """Check if the stack is empty."""
        return len(self.__items) == 0

    def size(self):
        """Return the number of items in the stack."""
        return len(self.__items)

# Using the Stack ADT
my_stack = Stack()
my_stack.push(10)
my_stack.push(20)
my_stack.push(30)

print("Top item:", my_stack.peek())  # Output: Top item: 30
print("Stack size:", my_stack.size())  # Output: Stack size: 3

print("Popped item:", my_stack.pop())  # Output: Popped item: 30
print("Stack size after pop:", my_stack.size())  # Output: Stack size after pop: 2

1. Class Definition: The Stack class encapsulates a private list __items that holds the elements of the stack.

2. Methods:
• push(item): Adds an item to the top of the stack.
• pop(): Removes and returns the top item from the stack.
• peek(): Returns the top item without removing it.
• is_empty(): Checks if there are any items in the stack.
• size(): Returns the number of items in the stack.

3. Usage: An instance of Stack is created, and various methods are used to manipulate and access its data.

• Push: Add an element to the top of the stack.

• Pop: Remove and return the top element of the stack.

• Peek/Top: Return the top element without removing it.

• isEmpty: Check if the stack is empty.

class Stack:
    def __init__(self):
        self.__items = []

    def push(self, item):
        self.__items.append(item)

    def pop(self):
        if not self.is_empty():
            return self.__items.pop()
        raise IndexError("pop from empty stack")

    def peek(self):
        if not self.is_empty():
            return self.__items[-1]
        raise IndexError("peek from empty stack")

    def is_empty(self):
        return len(self.__items) == 0

# Using the Stack ADT
stack = Stack()
stack.push(10)
stack.push(20)
print(stack.pop())  # Output: 20

• Enqueue: Add an element to the back of the queue.

• Dequeue: Remove and return the front element of the queue.

• Front/Peek: Return the front element without removing it.

• isEmpty: Check if the queue is empty.

class Queue:
    def __init__(self):
        self.__items = []

    def enqueue(self, item):
        self.__items.append(item)

    def dequeue(self):
        if not self.is_empty():
            return self.__items.pop(0)
        raise IndexError("dequeue from empty queue")

    def front(self):
        if not self.is_empty():
            return self.__items[0]
        raise IndexError("front from empty queue")

    def is_empty(self):
        return len(self.__items) == 0

# Using the Queue ADT
queue = Queue()
queue.enqueue(10)
queue.enqueue(20)
print(queue.dequeue())  # Output: 10

• Insert: Add an element at a specified position.

• Delete: Remove an element from a specified position.

• Access: Retrieve an element at a specified index.

• Length: Get the number of elements in the list.

class ListADT:
    def __init__(self):
        self.__items = []

    def insert(self, index, item):
        self.__items.insert(index, item)

    def delete(self, index):
        if 0 <= index < len(self.__items):
            del self.__items[index]
        else:
            raise IndexError("Index out of bounds")

    def access(self, index):
        if 0 <= index < len(self.__items):
            return self.__items[index]
        raise IndexError("Index out of bounds")

    def length(self):
        return len(self.__items)

# Using the List ADT
my_list = ListADT()
my_list.insert(0, 'a')
my_list.insert(1, 'b')
print(my_list.access(1))  # Output: b
my_list.delete(0)
print(my_list.length())    # Output: 1

• Stack ADT: Follows LIFO principle; supports operations like push, pop, and peek.

• Queue ADT: Follows FIFO principle; supports operations like enqueue, dequeue, and front.

• List ADT: Represents a collection of ordered elements; supports operations like insert, delete, access, and length.

def linear_search(arr, target):
    for i in range(len(arr)):
        if arr[i] == target:
            return i
    return -1

def binary_search(arr, target):
    left = 0
    right = len(arr) - 1

    while left <= right:
        mid = (left + right) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            left = mid + 1
        else:
            right = mid - 1

    return -1

def binary_search_recursive(arr, target, left=0, right=None):
    if right is None:
        right = len(arr) - 1

    if left > right:
        return -1

    mid = (left + right) // 2
    if arr[mid] == target:
        return mid
    elif arr[mid] < target:
        return binary_search_recursive(arr, target, mid + 1, right)
    else:
        return binary_search_recursive(arr, target, left, mid - 1)

# Example usage
sorted_list = [1, 3, 5, 7, 9, 11, 13, 15]

# Linear search
print("Linear search:")
print(linear_search(sorted_list, 7))  # Output: 3
print(linear_search(sorted_list, 10))  # Output: -1

# Binary search (non-recursive)
print("\\nBinary search (non-recursive):")
print(binary_search(sorted_list, 7))  # Output: 3
print(binary_search(sorted_list, 10))  # Output: -1

# Binary search (recursive)
print("\\nBinary search (recursive):")
print(binary_search_recursive(sorted_list, 7))  # Output: 3
print(binary_search_recursive(sorted_list, 10))  # Output: -1

1. Linear Search:
• The linear_search function takes an array arr and a target element target as input.
• It iterates through the array using a for loop and checks if each element matches the target.
• If a match is found, it returns the index of the element.
• If no match is found, it returns 1.

2. Binary Search (Non-Recursive):
• The binary_search function takes a sorted array arr and a target element target as input.
• It initializes left and right pointers to the start and end of the array, respectively.
• It enters a while loop that continues as long as left is less than or equal to right.
• In each iteration, it calculates the middle index mid and compares the element at mid with the target.
• If the element matches the target, it returns the index mid.
• If the element is less than the target, it updates left to mid + 1 to search in the right half.
• If the element is greater than the target, it updates right to mid - 1 to search in the left half.
• If the target is not found, it returns 1.

3. Binary Search (Recursive):
• The binary_search_recursive function takes a sorted array arr, a target element target, and optional left and right pointers as input.
• If right is not provided, it initializes right to the last index of the array.
• It checks if left is greater than right, indicating that the target is not found, and returns 1.
• Otherwise, it calculates the middle index mid and compares the element at mid with the target.
• If the element matches the target, it returns the index mid.
• If the element is less than the target, it recursively calls binary_search_recursive with left updated to mid + 1.
• If the element is greater than the target, it recursively calls binary_search_recursive with right updated to mid - 1.

def bubble_sort(arr):
    """Perform Bubble Sort on the array."""
    n = len(arr)
    for i in range(n):
        # Track if a swap was made
        swapped = False
        for j in range(0, n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]  # Swap
                swapped = True
        # If no two elements were swapped, the array is sorted
        if not swapped:
            break
    return arr

def selection_sort(arr):
    """Perform Selection Sort on the array."""
    n = len(arr)
    for i in range(n):
        min_index = i
        for j in range(i+1, n):
            if arr[j] < arr[min_index]:
                min_index = j
        # Swap the found minimum element with the first element
        arr[i], arr[min_index] = arr[min_index], arr[i]
    return arr

def tim_sort(arr):
    """Perform Tim Sort on the array."""
    min_run = 32  # Minimum run size

    # Function to perform insertion sort on a small segment of the array
    def insertion_sort(sub_arr, left, right):
        for i in range(left + 1, right + 1):
            key_item = sub_arr[i]
            j = i - 1
            while j >= left and sub_arr[j] > key_item:
                sub_arr[j + 1] = sub_arr[j]
                j -= 1
            sub_arr[j + 1] = key_item

    # Sort individual subarrays of size RUN using insertion sort
    n = len(arr)
    for start in range(0, n, min_run):
        end = min(start + min_run - 1, n - 1)
        insertion_sort(arr, start, end)

    # Merge sorted subarrays using merge function
    size = min_run
    while size < n:
        for left in range(0, n, size * 2):
            mid = min(n - 1, left + size - 1)
            right = min((left + 2 * size - 1), (n - 1))
            if mid < right:
                merged_array = merge(arr[left:mid + 1], arr[mid + 1:right + 1])
                arr[left:left + len(merged_array)] = merged_array
        size *= 2

    return arr

def merge(left, right):
    """Merge two sorted arrays."""
    result = []
    i = j = 0

    while i < len(left) and j < len(right):
        if left[i] <= right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1

    result.extend(left[i:])
    result.extend(right[j:])

    return result

# Example usage
if __name__ == "__main__":
    sample_list = [64, 34, 25, 12, 22, 11, 90]

    print("Original List:", sample_list)

    print("\\nBubble Sort Result:", bubble_sort(sample_list.copy()))

    print("\\nSelection Sort Result:", selection_sort(sample_list.copy()))

    print("\\nTim Sort Result:", tim_sort(sample_list.copy()))

• Description: Bubble sort repeatedly steps through the list to be sorted, compares adjacent elements and swaps them if they are in the wrong order. The pass through the list is repeated until the list is sorted.

• Complexity: Average and worst-case time complexity is
  .

• Description: Selection sort divides the input list into two parts: a sorted part and an unsorted part. It repeatedly selects the smallest (or largest) element from the unsorted part and moves it to the end of the sorted part.

• Complexity: Average and worst-case time complexity is
  .

• Description: Tim sort is a hybrid sorting algorithm derived from merge sort and insertion sort. It divides the array into smaller segments (runs), sorts them using insertion sort, and then merges them using a modified merge process.

• Complexity: Average time complexity is
  .

• Push: Add an element to the top of the stack.

• Pop: Remove and return the top element of the stack.

• Peek: Return the top element without removing it.

• isEmpty: Check if the stack is empty.

class Stack:
    def __init__(self):
        self.__items = []

    def push(self, item):
        self.__items.append(item)

    def pop(self):
        if not self.is_empty():
            return self.__items.pop()
        raise IndexError("pop from empty stack")

    def peek(self):
        if not self.is_empty():
            return self.__items[-1]
        raise IndexError("peek from empty stack")

    def is_empty(self):
        return len(self.__items) == 0

# Example usage
stack = Stack()
stack.push(10)
stack.push(20)
print("Top item:", stack.peek())  # Output: Top item: 20
print("Popped item:", stack.pop())  # Output: Popped item: 20

• Enqueue: Add an element to the back of the queue.

• Dequeue: Remove and return the front element of the queue.

• Front/Peek: Return the front element without removing it.

• isEmpty: Check if the queue is empty.

class Queue:
    def __init__(self):
        self.__items = []

    def enqueue(self, item):
        self.__items.append(item)

    def dequeue(self):
        if not self.is_empty():
            return self.__items.pop(0)
        raise IndexError("dequeue from empty queue")

    def front(self):
        if not self.is_empty():
            return self.__items[0]
        raise IndexError("front from empty queue")

    def is_empty(self):
        return len(self.__items) == 0

# Example usage
queue = Queue()
queue.enqueue(10)
queue.enqueue(20)
print("Front item:", queue.front())  # Output: Front item: 10
print("Dequeued item:", queue.dequeue())  # Output: Dequeued item: 10

• Insert: Add an element at a specified position.

• Delete: Remove an element from a specified position.

• Access: Retrieve an element at a specified index.

• Length: Get the number of elements in the list.

class ListADT:
    def __init__(self):
        self.__items = []

    def insert(self, index, item):
        self.__items.insert(index, item)

    def delete(self, index):
        if 0 <= index < len(self.__items):
            del self.__items[index]
        else:
            raise IndexError("Index out of bounds")

    def access(self, index):
        if 0 <= index < len(self.__items):
            return self.__items[index]
        raise IndexError("Index out of bounds")

    def length(self):
        return len(self.__items)

# Example usage
my_list = ListADT()
my_list.insert(0, 'a')
my_list.insert(1, 'b')
print("Accessed item:", my_list.access(1))  # Output: Accessed item: b
my_list.delete(0)
print("Length of list:", my_list.length())   # Output: Length of list: 1

• Stack ADT implements LIFO behavior with operations like push, pop, and peek.

• Queue ADT implements FIFO behavior with operations like enqueue, dequeue, and front.

• List ADT provides ordered collections with operations for insertion, deletion, access, and length.

class BankAccount:
    def __init__(self, balance):
        self.__balance = balance  # Private attribute

    def deposit(self, amount):
        self.__balance += amount

    def withdraw(self, amount):
        if self.__balance >= amount:
            self.__balance -= amount
        else:
            print("Insufficient funds.")

account = BankAccount(1000)
account.__balance  # AttributeError: 'BankAccount' object has no attribute '__balance'

class BankAccount:
    def __init__(self, balance):
        self._balance = balance  # Protected attribute

    def _calculate_interest(self):
        # Protected method
        return self._balance * 0.05

    def deposit(self, amount):
        self._balance += amount

    def withdraw(self, amount):
        if self._balance >= amount:
            self._balance -= amount
        else:
            print("Insufficient funds.")

account = BankAccount(1000)
account._balance  # 1000 (accessible but should be treated as protected)
account._calculate_interest()  # 50.0

• Definition: Data abstraction refers to the concept of exposing only the essential features of an object while hiding the complex implementation details. It focuses on what an object does rather than how it does it.

• Purpose: The main goal of data abstraction is to reduce complexity by providing a simplified view of the object to the user. It allows users to interact with objects without needing to understand their internal workings.

• Implementation: In Python, data abstraction is typically achieved through abstract classes and interfaces. Abstract classes can define abstract methods that must be implemented by subclasses.

from abc import ABC, abstractmethod

# Abstract class
class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

# Concrete class
class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius * self.radius

# Using the abstract class
circle = Circle(5)
print("Area of circle:", circle.area())  # Output: Area of circle: 78.5

• Definition: Data hiding is a principle that restricts access to certain details of an object. It ensures that sensitive data is protected from unauthorized access and modification. This is often achieved by making attributes private or protected.

• Purpose: The main goal of data hiding is to safeguard an object's internal state and prevent unintended interference or misuse. It enhances security and integrity by controlling access to the object's data.

• Implementation: In Python, data hiding can be implemented using naming conventions (e.g., prefixing an attribute with an underscore _ for protected or double underscores __ for private attributes).

class BankAccount:
    def __init__(self, balance):
        self.__balance = balance  # Private attribute

    def deposit(self, amount):
        self.__balance += amount

    def get_balance(self):
        return self.__balance

# Using the BankAccount class
account = BankAccount(1000)
account.deposit(500)
print("Current Balance:", account.get_balance())  # Output: Current Balance: 1500

# Attempting to access the private attribute will raise an error
# print(account.__balance)  # Uncommenting this line will raise AttributeError

def linear_search(arr, target):
    """Perform Linear Search on the array."""
    for index in range(len(arr)):
        if arr[index] == target:
            return index  # Return the index of the found element
    return -1  # Return -1 if the element is not found

def binary_search(arr, target):
    """Perform Binary Search (Non-Recursive) on a sorted array."""
    left, right = 0, len(arr) - 1

    while left <= right:
        mid = (left + right) // 2
        if arr[mid] == target:
            return mid  # Return the index of the found element
        elif arr[mid] < target:
            left = mid + 1  # Search in the right half
        else:
            right = mid - 1  # Search in the left half

    return -1  # Return -1 if the element is not found

def binary_search_recursive(arr, target, left=0, right=None):
    """Perform Binary Search (Recursive) on a sorted array."""
    if right is None:
        right = len(arr) - 1

    if left > right:
        return -1  # Base case: element not found

    mid = (left + right) // 2
    if arr[mid] == target:
        return mid  # Return the index of the found element
    elif arr[mid] < target:
        return binary_search_recursive(arr, target, mid + 1, right)  # Search in the right half
    else:
        return binary_search_recursive(arr, target, left, mid - 1)  # Search in the left half

# Example usage
if __name__ == "__main__":
    sample_list = [1, 3, 5, 7, 9, 11, 13, 15]  # Sorted list for binary search

    # Linear search
    print("Linear Search:")
    print("Index of 7:", linear_search(sample_list, 7))   # Output: Index of 7: 3
    print("Index of 10:", linear_search(sample_list, 10)) # Output: Index of 10: -1

    # Binary search (Non-Recursive)
    print("\\nBinary Search (Non-Recursive):")
    print("Index of 7:", binary_search(sample_list, 7))   # Output: Index of 7: 3
    print("Index of 10:", binary_search(sample_list, 10)) # Output: Index of 10: -1

    # Binary search (Recursive)
    print("\\nBinary Search (Recursive):")
    print("Index of 7:", binary_search_recursive(sample_list, 7))   # Output: Index of 7: 3
    print("Index of 10:", binary_search_recursive(sample_list, 10)) # Output: Index of 10: -1

1. Linear Search:
• The linear_search function iterates through each element in the array. If it finds an element that matches the target value, it returns its index. If no match is found after checking all elements, it returns 1.

2. Binary Search (Non-Recursive):
• The binary_search function works on a sorted array. It initializes two pointers (left and right) to represent the current search range. It calculates the middle index and compares the middle element with the target. If they match, it returns the index. If the middle element is less than the target, it narrows down to the right half; otherwise, it narrows down to the left half.

3. Binary Search (Recursive):
• The binary_search_recursive function performs a similar operation as the non-recursive version but uses recursion to narrow down the search range. It takes additional parameters for left and right indices to keep track of the current search range.

• The script demonstrates how to use each search algorithm with a sample sorted list. It prints out results for both existing and non-existing elements.

def bubble_sort(arr):
    """Perform Bubble Sort on the array."""
    n = len(arr)
    for i in range(n):
        # Track if a swap was made
        swapped = False
        for j in range(0, n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]  # Swap
                swapped = True
        # If no two elements were swapped, the array is sorted
        if not swapped:
            break
    return arr

def selection_sort(arr):
    """Perform Selection Sort on the array."""
    n = len(arr)
    for i in range(n):
        min_index = i
        for j in range(i+1, n):
            if arr[j] < arr[min_index]:
                min_index = j
        # Swap the found minimum element with the first element
        arr[i], arr[min_index] = arr[min_index], arr[i]
    return arr

def tim_sort(arr):
    """Perform Tim Sort on the array."""
    min_run = 32  # Minimum run size

    # Function to perform insertion sort on a small segment of the array
    def insertion_sort(sub_arr, left, right):
        for i in range(left + 1, right + 1):
            key_item = sub_arr[i]
            j = i - 1
            while j >= left and sub_arr[j] > key_item:
                sub_arr[j + 1] = sub_arr[j]
                j -= 1
            sub_arr[j + 1] = key_item

    # Sort individual subarrays of size RUN using insertion sort
    n = len(arr)
    for start in range(0, n, min_run):
        end = min(start + min_run - 1, n - 1)
        insertion_sort(arr, start, end)

    # Merge sorted subarrays using merge function
    size = min_run
    while size < n:
        for left in range(0, n, size * 2):
            mid = min(n - 1, left + size - 1)
            right = min((left + 2 * size - 1), (n - 1))
            if mid < right:
                merged_array = merge(arr[left:mid + 1], arr[mid + 1:right + 1])
                arr[left:left + len(merged_array)] = merged_array
        size *= 2

    return arr

def merge(left, right):
    """Merge two sorted arrays."""
    result = []
    i = j = 0

    while i < len(left) and j < len(right):
        if left[i] <= right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1

    result.extend(left[i:])
    result.extend(right[j:])

    return result

# Example usage
if __name__ == "__main__":
    sample_list = [64, 34, 25, 12, 22, 11, 90]

    print("Original List:", sample_list)

    print("\\nBubble Sort Result:", bubble_sort(sample_list.copy()))

    print("\\nSelection Sort Result:", selection_sort(sample_list.copy()))

    print("\\nTim Sort Result:", tim_sort(sample_list.copy()))

• Description: Bubble sort repeatedly steps through the list to be sorted, compares adjacent elements and swaps them if they are in the wrong order. The pass through the list is repeated until the list is sorted.

• Complexity: Average and worst-case time complexity is O(n^2).

• Description: Selection sort divides the input list into two parts: a sorted part and an unsorted part. It repeatedly selects the smallest (or largest) element from the unsorted part and moves it to the end of the sorted part.

• Complexity: Average and worst-case time complexity is O(n^2).

• Description: Tim sort is a hybrid sorting algorithm derived from merge sort and insertion sort. It divides the array into smaller segments (runs), sorts them using insertion sort, and then merges them using a modified merge process.

• Complexity: Average time complexity is O(n log n).

1. re.search(pattern, string): Searches for the pattern in the string and returns a match object if found.

2. re.match(pattern, string): Checks for a match only at the beginning of the string.

3. re.findall(pattern, string): Returns a list of all occurrences of the pattern in the string.

4. re.sub(pattern, replacement, string): Replaces occurrences of the pattern with a specified replacement string.

import re

# Sample text
text = "The rain in Spain falls mainly on the plain."

# Search for the word 'rain'
match = re.search(r'rain', text)
if match:
    print("Found:", match.group())  # Output: Found: rain
else:
    print("Not found.")

# Find all words that start with 'p'
words_starting_with_p = re.findall(r'\\bp\\w+', text)
print("Words starting with 'p':", words_starting_with_p)  # Output: ['plain']

# Replace 'Spain' with 'France'
new_text = re.sub(r'Spain', 'France', text)
print("Updated Text:", new_text)  # Output: The rain in France falls mainly on the plain.

• Description: Matches any single character except a newline.

pattern = r'a.b'  # Matches 'a' followed by any character and then 'b'
text = "acb aeb axb"
matches = re.findall(pattern, text)
print("Matches for 'a.b':", matches)  # Output: Matches for 'a.b': ['acb', 'aeb', 'axb']

• Description: Matches the start of a string.

pattern = r'^The'  # Matches if the string starts with 'The'
text = "The rain in Spain."
match = re.match(pattern, text)
if match:
    print("Match found at start:", match.group())  # Output: Match found at start: The

• Description: Matches the end of a string.

pattern = r'plain.$'  # Matches if the string ends with 'plain.'
text = "The rain in Spain falls mainly on the plain."
match = re.search(pattern, text)
if match:
    print("Match found at end:", match.group())  # Output: Match found at end: plain.

• Description: Matches zero or more occurrences of the preceding element.

pattern = r'ba*'  # Matches 'b' followed by zero or more 'a's
text = "b ba baa bba"
matches = re.findall(pattern, text)
print("Matches for 'ba*':", matches)  # Output: Matches for 'ba*': ['b', 'ba', 'baa', 'b']

import re

text = "The rain in Spain"
pattern = r"rain"

match = re.search(pattern, text)
if match:
    print("Found:", match.group())  # Output: Found: rain
else:
    print("Not found.")

import re

text = "Hello! How are you?"
escaped_text = re.escape(text)

print("Escaped Text:", escaped_text)  # Output: Escaped Text: Hello\\!\\ How\\ are\\ you\\?

import re

text = "The rain in Spain"
pattern = r"Spain"
replacement = "France"

new_text = re.sub(pattern, replacement, text)
print("Updated Text:", new_text)  # Output: Updated Text: The rain in France

import re

text = "apple, banana; cherry orange"
pattern = r"[;, ]+"  # Split by comma, semicolon, or space

result = re.split(pattern, text)
print("Split Result:", result)  # Output: Split Result: ['apple', 'banana', 'cherry', 'orange']

import re

pattern = re.compile(r"\\d+")  # Compile a regex pattern to find digits

text = "There are 12 apples and 15 oranges."
matches = pattern.findall(text)

print("Digits found:", matches)  # Output: Digits found: ['12', '15']

import re

text = "The rain in Spain falls mainly on the plain."
pattern = r"\\bain\\b"  # Match the word 'ain'

matches = re.findall(pattern, text)
print("Matches found:", matches)  # Output: Matches found: ['ain', 'ain']

• re.search(): Searches for a pattern and returns the first match.

• re.escape(): Escapes special characters in a string.

• re.sub(): Replaces occurrences of a pattern with a replacement string.

• re.split(): Splits a string by the occurrences of a pattern.

• re.compile(): Compiles a regex pattern into a regex object.

• re.findall(): Returns all non-overlapping matches of the pattern as a list.

• Description: Matches any digit character (equivalent to [0-9]).

import re

text = "The price is 100 dollars."
pattern = r"\\d+"  # Matches one or more digits

matches = re.findall(pattern, text)
print("Digits found:", matches)  # Output: Digits found: ['100']

• Description: Matches any character that is not a digit (equivalent to [^0-9]).

import re

text = "abc123xyz"
pattern = r"\\D+"  # Matches one or more non-digit characters

matches = re.findall(pattern, text)
print("Non-digits found:", matches)  # Output: Non-digits found: ['abc', 'xyz']

• Description: Matches any alphanumeric character (equivalent to [a-zA-Z0-9_]).

import re

text = "Hello World! Welcome to Python3."
pattern = r"\\w+"  # Matches one or more word characters

matches = re.findall(pattern, text)
print("Word characters found:", matches)  # Output: Word characters found: ['Hello', 'World', 'Welcome', 'to', 'Python3']

• Description: Matches any whitespace character (spaces, tabs, newlines). It is equivalent to [ \\t\\n\\r\\f\\v].

import re

text = "Hello,\\nWorld! Welcome to Python."
pattern = r"\\s+"  # Matches one or more whitespace characters

matches = re.split(pattern, text)
print("Text split by whitespace:", matches)  # Output: Text split by whitespace: ['Hello,', 'World!', 'Welcome', 'to', 'Python.']

• \\d: Matches any digit (0-9).

• \\D: Matches any non-digit character.

• \\w: Matches any word character (alphanumeric + underscore).

• \\s: Matches any whitespace character.

• Character Set: [abc] matches any one of the characters a, b, or c.

• Range of Characters: [a-z] matches any lowercase letter from a to z.

• Negation: [^abc] matches any character that is not a, b, or c.

import re

text = "The rain in Spain falls mainly on the plain."
pattern = r"[aeiou]"  # Matches any vowel

matches = re.findall(pattern, text)
print("Vowels found:", matches)  # Output: Vowels found: ['e', 'a', 'i', 'i', 'a', 'i', 'a', 'a', 'i', 'a']

import re

text = "12345abcde"
pattern = r"[0-9]"  # Matches any digit

matches = re.findall(pattern, text)
print("Digits found:", matches)  # Output: Digits found: ['1', '2', '3', '4', '5']

import re

text = "Hello World!"
pattern = r"[^aeiou ]"  # Matches any character that is not a vowel or space

matches = re.findall(pattern, text)
print("Consonants and punctuation found:", matches)  # Output: Consonants and punctuation found: ['H', 'l', 'l', 'W', 'r', 'l', 'd', '!']

import re

text = "Sample Text 123!"
pattern = r"[A-Za-z0-9]"  # Matches any alphanumeric character (letters and digits)

matches = re.findall(pattern, text)
print("Alphanumeric characters found:", matches)  # Output: Alphanumeric characters found: ['S', 'a', 'm', 'p', 'l', 'e', 'T', 'e', 'x', 't', '1', '2', '3']

@decorator_function
def original_function():
    # Function implementation

def original_function():
    # Function implementation

original_function = decorator_function(original_function)

import time

def timer_decorator(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()  # Start time before calling the function
        result = func(*args, **kwargs)  # Call the original function
        end_time = time.time()  # End time after calling the function
        print(f"Function '{func.__name__}' executed in {end_time - start_time:.4f} seconds.")
        return result  # Return the result of the original function
    return wrapper

@timer_decorator
def slow_function():
    time.sleep(2)  # Simulate a slow operation
    print("Function complete!")

# Call the decorated function
slow_function()

Function complete!
Function 'slow_function' executed in 2.0004 seconds.

1. Decorator Definition: The timer_decorator function is defined to take another function (func) as an argument. Inside it, we define a nested wrapper function that adds functionality (timing) around the call to func.

2. Timing Logic: The wrapper records the start time before calling func, then calls it with any arguments it received (args and *kwargs allow for flexible argument passing), and finally records the end time after func has executed.

3. Returning Result: The result of func is returned so that the original functionality remains intact.

4. Using the Decorator: The @timer_decorator syntax is used to apply the decorator to slow_function. When slow_function is called, it now includes timing functionality.

import re

def contains_at_least_three_ones(binary_string):
    # Regular expression pattern to check for at least three '1's
    pattern = r'(.*1.*1.*1.*)'

    # Use re.search to find the pattern in the binary string
    match = re.search(pattern, binary_string)

    if match:
        return True  # The string contains at least three '1's
    else:
        return False  # The string does not contain at least three '1's

# Example usage
binary_string_1 = "1101001"  # Contains three '1's
binary_string_2 = "1010"      # Contains two '1's
binary_string_3 = "00000"     # Contains no '1's

print(f"Binary string '{binary_string_1}' contains at least three 1s: {contains_at_least_three_ones(binary_string_1)}")  # Output: True
print(f"Binary string '{binary_string_2}' contains at least three 1s: {contains_at_least_three_ones(binary_string_2)}")  # Output: False
print(f"Binary string '{binary_string_3}' contains at least three 1s: {contains_at_least_three_ones(binary_string_3)}")  # Output: False

1. Importing the re Module: The script starts by importing the re module, which provides support for regular expressions in Python.

2. Defining the Function: The function contains_at_least_three_ones takes a binary string as input.

3. Regular Expression Pattern:
• The pattern r'(.*1.*1.*1.*)' is used to match any string that contains at least three occurrences of the character 1.
• The .* means "zero or more of any character," allowing for any characters (including 0s) to be present between the 1s.

4. Using re.search():
• The function uses re.search() to look for the specified pattern in the binary string.
• If a match is found, it returns True, indicating that there are at least three 1s in the string. Otherwise, it returns False.

5. Example Usage:
• The script tests the function with different binary strings and prints whether each string contains at least three 1s.

Binary string '1101001' contains at least three 1s: True
Binary string '1010' contains at least three 1s: False
Binary string '00000' contains at least three 1s: False

import re

def check_binary_string(binary_string):
    # Regular expression pattern
    # ^0[01]{0,} (starts with 0 and has odd length)
    # ^1[01]{1,} (starts with 1 and has even length)
    pattern = r'^(0[01]*|1[01]{1,})$'

    # Check if the string matches the pattern
    match = re.match(pattern, binary_string)

    if match:
        # Check the length condition
        if binary_string[0] == '0' and len(binary_string) % 2 == 1:
            return "The binary string starts with '0' and has an odd length."
        elif binary_string[0] == '1' and len(binary_string) % 2 == 0:
            return "The binary string starts with '1' and has an even length."

    return "The binary string does not meet the specified conditions."

# Example usage
binary_string_1 = "011"   # Starts with 0 and has odd length
binary_string_2 = "100"   # Starts with 1 and has even length
binary_string_3 = "00000"  # Starts with 0 and has odd length
binary_string_4 = "111"    # Starts with 1 but has odd length

print(check_binary_string(binary_string_1))  # Output: The binary string starts with '0' and has an odd length.
print(check_binary_string(binary_string_2))  # Output: The binary string starts with '1' and has an even length.
print(check_binary_string(binary_string_3))  # Output: The binary string starts with '0' and has an odd length.
print(check_binary_string(binary_string_4))  # Output: The binary string does not meet the specified conditions.

1. Importing the re Module: The script begins by importing the re module, which provides support for regular expressions.

2. Defining the Function: The function check_binary_string takes a binary string as input.

3. Regular Expression Pattern:
• The pattern r'^(0[1]*|1[1]{1,})$' is used to match:
• ^0[1]*: A string that starts with 0 followed by any combination of 0s and 1s (including none).
• |: This indicates an OR condition.
• ^1[1]{1,}: A string that starts with 1 followed by at least one character that can be either 0 or 1.
• The entire pattern ensures that the string consists only of valid binary digits.

4. Using re.match(): The function checks if the input string matches the regex pattern.

5. Length Condition Check:
• If the match is found, it checks if the first character is 0 and whether the length of the string is odd using len(binary_string) % 2 == 1.
• If it starts with 1, it checks for an even length using len(binary_string) % 2 == 0.

6. Example Usage: The script tests various binary strings against the defined conditions and prints appropriate messages based on whether they meet the criteria.

The binary string starts with '0' and has an odd length.
The binary string starts with '1' and has an even length.
The binary string starts with '0' and has an odd length.
The binary string does not meet the specified conditions.

import socket

# Create a socket object
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# Get local machine name
host = socket.gethostname()

# Reserve a port for your service
port = 12345

# Connect the socket to the host and port
s.connect((host, port))

1. Import the socket module.

2. Create a socket object using socket.socket(). The first argument specifies the address family (socket.AF_INET for IPv4), and the second argument specifies the socket type (socket.SOCK_STREAM for TCP).

3. Get the local machine name using socket.gethostname().

4. Reserve a port for the service (in this case, port 12345).

5. Connect the socket to the host and port using s.connect().

import socket

# Create a socket object
serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# Get local machine name
host = socket.gethostname()

# Get the port
port = 12345

# Bind the socket to the host and port
serversocket.bind((host, port))

# Listen for incoming connections
serversocket.listen(5)

while True:
    # Wait for a connection
    clientsocket, addr = serversocket.accept()
    print(f'Got connection from {addr}')

    # Receive the data in small chunks and retransmit it
    while True:
        data = clientsocket.recv(1024)
        if not data:
            break
        print(f'Received: {data.decode()}')
        clientsocket.sendall(data)

    # Clean up the connection
    clientsocket.close()

1. Creates a socket object.

2. Binds the socket to a specific host and port using serversocket.bind().

3. Listens for incoming connections using serversocket.listen().

4. Enters a loop to handle incoming connections.

5. Waits for a connection using serversocket.accept().

6. Receives data from the client using clientsocket.recv().

7. Sends the received data back to the client using clientsocket.sendall().

8. Closes the client socket connection using clientsocket.close().

import socket

# Create a TCP/IP socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

• Address Family: socket.AF_INET is used for IPv4 addresses.

• Socket Type: socket.SOCK_STREAM is used for TCP connections.

# Bind the socket to an address and port
server_address = ('localhost', 12345)
sock.bind(server_address)

# Listen for incoming connections
sock.listen(5)  # The argument specifies the maximum number of queued connections

# Accept a connection
client_socket, client_address = sock.accept()
print(f"Connection from {client_address} has been established.")

# Connect to the server
server_address = ('localhost', 12345)
sock.connect(server_address)

message = "Hello, Server!"
sock.sendall(message.encode())

data = client_socket.recv(1024)  # Buffer size is 1024 bytes
print(f"Received: {data.decode()}")

client_socket.close()  # Close client connection
sock.close()           # Close server socket

import socket

def start_server():
    # Create a TCP/IP socket
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    # Bind the socket to an address and port
    server_address = ('localhost', 12345)
    server_socket.bind(server_address)

    # Listen for incoming connections
    server_socket.listen(5)
    print("Server is listening...")

    while True:
        # Accept a connection
        client_socket, client_address = server_socket.accept()
        print(f"Connection from {client_address} has been established.")

        # Receive data from client
        data = client_socket.recv(1024)
        print(f"Received: {data.decode()}")

        # Send response back to client
        response = "Hello from server!"
        client_socket.sendall(response.encode())

        # Close client connection
        client_socket.close()

if __name__ == "__main__":
    start_server()

import socket

def start_client():
    # Create a TCP/IP socket
    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    # Connect to the server
    server_address = ('localhost', 12345)
    client_socket.connect(server_address)

    # Send data to server
    message = "Hello, Server!"
    client_socket.sendall(message.encode())

    # Receive response from server
    data = client_socket.recv(1024)
    print(f"Received from server: {data.decode()}")

    # Close the connection
    client_socket.close()

if __name__ == "__main__":
    start_client()

• Creating a Socket: Use socket.socket().

• Binding: Use bind() on the server side.

• Listening: Use listen() on the server side.

• Accepting Connections: Use accept() on the server side.

• Connecting: Use connect() on the client side.

• Sending/Receiving Data: Use sendall() and recv().

• Closing Sockets: Use close() when done.

1. Thread ID: A unique identifier assigned to each thread within a process.

2. Thread State: The current state of the thread, such as running, ready, waiting, or terminated.

3. Thread Priority: The priority level of the thread, which determines its scheduling order.

4. Program Counter: The address of the next instruction to be executed by the thread.

5. CPU Registers: The values of the CPU registers associated with the thread, which are used to maintain the execution context.

6. Thread Stack: A stack used by the thread to store return addresses, local variables, and function parameters.

7. Thread Attributes: Additional information about the thread, such as the thread's name, scheduling policy, and resource limits.

8. Pointers: Pointers to other TCBs, such as the next and previous TCBs in a linked list or queue.

• Concurrency: Multiple threads can work on different tasks at the same time, improving responsiveness.

• Resource Sharing: Threads share the same memory space, which allows for easier data sharing between them.

• I/O Bound Tasks: Multithreading is particularly useful for I/O-bound tasks where threads can be in a waiting state while waiting for external resources.

1. Using the Thread class from the threading module.

2. Using a subclass of the Thread class.

import threading
import time

def print_numbers():
    for i in range(5):
        print(f"Number: {i}")
        time.sleep(1)  # Simulate a delay

# Create a thread
thread = threading.Thread(target=print_numbers)

# Start the thread
thread.start()

# Wait for the thread to complete
thread.join()

print("Thread has finished execution.")

• The print_numbers function prints numbers from 0 to 4 with a delay of 1 second between each print.

• A thread is created using threading.Thread, specifying print_numbers as the target function.

• The thread is started using start(), and the main program waits for it to finish using join().

import threading
import time

class MyThread(threading.Thread):
    def run(self):
        for i in range(5):
            print(f"Number from MyThread: {i}")
            time.sleep(1)  # Simulate a delay

# Create an instance of MyThread
my_thread = MyThread()

# Start the thread
my_thread.start()

# Wait for the thread to complete
my_thread.join()

print("MyThread has finished execution.")

• A custom class MyThread is created that inherits from threading.Thread.

• The run() method is overridden to define what the thread should do when started.

• An instance of MyThread is created and started, similar to the previous example.

import threading

# Shared resource
counter = 0
lock = threading.Lock()

def increment():
    global counter
    for _ in range(100000):
        lock.acquire()  # Acquire lock before accessing shared resource
        counter += 1
        lock.release()  # Release lock after accessing shared resource

# Create multiple threads
threads = []
for _ in range(2):
    thread = threading.Thread(target=increment)
    threads.append(thread)
    thread.start()

# Wait for all threads to complete
for thread in threads:
    thread.join()

print(f"Final counter value: {counter}")

• A global variable counter is shared among threads.

• A lock is used to ensure that only one thread can increment the counter at a time, preventing race conditions.

• Each thread increments the counter 100,000 times while acquiring and releasing the lock appropriately.

import threading
import time

# Shared resource
counter = 0
lock = threading.Lock()

def increment():
    global counter
    for _ in range(100000):
        # Acquire the lock before accessing the shared resource
        lock.acquire()
        try:
            counter += 1  # Increment the shared counter
        finally:
            # Always release the lock in a finally block to ensure it's released even if an error occurs
            lock.release()

# Create multiple threads
threads = []
for _ in range(2):  # Creating two threads
    thread = threading.Thread(target=increment)
    threads.append(thread)
    thread.start()

# Wait for all threads to complete
for thread in threads:
    thread.join()

print(f"Final counter value: {counter}")

1. Importing Modules: The script imports the threading and time modules.

2. Shared Resource: A global variable counter is defined, which will be accessed by multiple threads.

3. Creating a Lock: A lock object is created using lock = threading.Lock().

4. Increment Function: The increment() function increments the shared counter. It uses the following steps:
• Acquires the lock before modifying the counter.
• Increments the counter within a try block to ensure that it can handle exceptions properly.
• Releases the lock in a finally block, ensuring that it is always released even if an error occurs during incrementing.

5. Creating Threads: Two threads are created and started, each executing the increment() function.

6. Joining Threads: The main program waits for both threads to complete using join().

7. Final Output: After all threads have finished executing, it prints the final value of counter.

Final counter value: 200000