def linear_search(data, target):
    for i in range(len(data)):
        if data[i] == target:
            return i  # Return the index of the found element
    return -1 # Return -1 if the element is not found

# Example
my_list = [4, 2, 7, 1, 9, 5]
print(f"Linear Search: Element 7 found at index {linear_search(my_list, 7)}")

def binary_search(sorted_data, target):
    low = 0
    high = len(sorted_data) - 1
    
    while low <= high:
        mid = (low + high) // 2
        if sorted_data[mid] < target:
            low = mid + 1
        elif sorted_data[mid] > target:
            high = mid - 1
        else:
            return mid # Element found
    return -1 # Element not found

# Example
my_sorted_list = [1, 2, 4, 5, 7, 9]
print(f"Binary Search: Element 7 found at index {binary_search(my_sorted_list, 7)}")

def bubble_sort(data):
    n = len(data)
    for i in range(n):
        # Last i elements are already in place
        for j in range(0, n-i-1):
            if data[j] > data[j+1]:
                # Swap the elements
                data[j], data[j+1] = data[j+1], data[j]
    return data

# Example
my_list_to_sort = [4, 2, 7, 1, 9, 5]
print(f"Bubble Sort: Sorted list is {bubble_sort(my_list_to_sort)}")

def factorial(n):
    # Base case: if n is 1 or 0, factorial is 1
    if n == 0 or n == 1:
        return 1
    # Recursive step: n * factorial of (n-1)
    else:
        return n * factorial(n - 1)

# Example
num = 5
print(f"Recursion: Factorial of {num} is {factorial(num)}")

items = [1, 2, 2, 3, 4]
for item in items:
    if item == 2:
        items.remove(item)
print(items)
# Output: [1, 2, 3, 4]

for item in items[:]:
    if item == 2:
          items.remove(item)
print(items)
# Output: [1, 3, 4]

data = data[-1:] + data[:-1]

q.rotate(1)

q.rotate(-2)

workers.rotate(-1)

import inspect

def has_subclasses(cls):
    return any(issubclass(sub, cls) for sub in inspect.getmembers(sys.modules[cls.__module__], inspect.isclass))

for i, item in enumerate(items):
    print(i, item)

```python
# Example usage
from functools import reduce

# map
squared = map(lambda x: x**2, [1, 2, 3, 4])
print(list(squared))

# filter
evens = filter(lambda x: x % 2 == 0, [1, 2, 3, 4, 5])
print(list(evens))

# reduce
total = reduce(lambda x, y: x + y, [1, 2, 3, 4])
pr

class Weird:
    def eq(self, other):
        return True  # always says "equal"

obj = Weird()

print(obj == None)  # True
print(obj is None)  # False

import copy

# Original list with nested structure
original = [[1, 2, 3], [4, 5, 6]]

# 1. Shallow copy
shallow = copy.copy(original)
shallow[0][0] = 'X'
# Oh no! Both lists have changed, because the nested list wasn't copied, but passed by reference
print(f"Original after shallow: {original}") # [['X', 2, 3], [4, 5, 6]]

# Restore the data
original = [[1, 2, 3], [4, 5, 6]]

# 2. Deep copy
deep = copy.deepcopy(original)
deep[0][0] = 'X'
# Everything is fine! Only deep has changed, the original remains untouched
print(f"Original after deep:    {original}") # [[1, 2, 3], [4, 5, 6]]

from itertools import combinations

def get_unique_pairs(items):
    return list(combinations(items, 2))

print(get_unique_pairs(['A', 'B', 'C', 'D']))

# Output:
# [('A', 'B'), ('A', 'C'), ('A', 'D'), ('B', 'C'), ('B', 'D'), ('C', 'D')]