Intermediate Python Exercises: 65 Coding Problems with Solutions

Python is widely used and regarded as the most beginner-friendly programming language. However, to truly master it, you need to go beyond the basics and solve intermediate and advance coding problems. Also, you need to learn how to use advanced data structures, functional programming, and object-oriented design.

In this article, you’ll find a list of 65 intermediate Python coding questions primarily focuses on loops, list, dictionary, sets, OOP, decorators, Generators (yield), , and strings, multi-threading, List/Dict comprehensions, and Lambda functions, File Handling, regular expression, Date and Time, other miscellaneous topics.

These coding problems will improve your logic and coding skills, helping you write cleaner code and prepare for Python interviews.

What to Expect in These Exercises

Each exercise is structured to help you understand not just the how, but the why behind the code. Every problem includes:

• Practice Problem: You’ll get a clear description of what code you need to write.
• Exercise Purpose: You’ll learn why this skill is useful in real-world software development.
• Given Input and Expected Output: You’ll see examples to help you check your logic.
• Pythonic Hints: You will get a suggestion to guide you if you are stuck. These hints may point to a built-in function, module, algorithm, or concept, and will help you break down the problem without giving away the answer.
• Detailed Explanation: After you solve the problem, you will see a step-by-step breakdown of how the solution works and which Python concepts are used.
• Use the Online Python Code Editor to try out your solutions.

Exercise 1: List Comprehension Mastery

Practice Problem: Write a single-line list comprehension that takes a list of strings, filters out strings shorter than 4 characters, and converts the remaining strings to uppercase.

Exercise Purpose: List comprehensions are a hallmark of Pythonic code. They allow you to replace verbose for loops and .append() calls with a readable, optimized single line. This exercise teaches you how to combine transformation (uppercase) and filtering (length check) in one expression.

Given Input: words = ["apple", "bat", "cherry", "dog", "elderberry"]

Expected Output: ['APPLE', 'CHERRY', 'ELDERBERRY']

words = ["apple", "bat", "cherry", "dog", "elderberry"]

# Single line transformation and filtering
filtered_words = [w.upper() for w in words if len(w) >= 4]

print(f"Original: {words}")
print(f"Result:   {filtered_words}")Code language: Python (python)

Exercise 2: Dictionary Merging with Logic

Practice Problem: Write a function that merges two dictionaries. If a key exists in both dictionaries, sum their values. If a key exists in only one, include it as is.

Exercise Purpose: Real-world data often comes from multiple sources. Simply using dict.update() would overwrite duplicate keys. This exercise introduces you to efficient dictionary iteration and the dict.get(key, default) method, which is essential for avoiding KeyError.

Given Input: dict_a = {'a': 10, 'b': 20} dict_b = {'b': 5, 'c': 15}

Expected Output: Merged Dictionary: {'a': 10, 'b': 25, 'c': 15}

def merge_dicts(d1, d2):
    # Start with a copy of d1 to avoid modifying the original
    result = d1.copy()
    
    for key, value in d2.items():
        # .get(key, 0) returns 0 if the key doesn't exist yet
        result[key] = result.get(key, 0) + value
    
    return result

dict_a = {'a': 10, 'b': 20}
dict_b = {'b': 5, 'c': 15}

merged = merge_dicts(dict_a, dict_b)
print(f"Merged Dictionary: {merged}")Code language: Python (python)

Exercise 3: Frequency Map with Counter

Practice Problem: Create a function that takes a string and returns a count of how many times each character appears. Ignore spaces and make it case-insensitive.

Exercise Purpose: While you could build a frequency map with a standard loop, Python’s collections module offers a specialized tool called Counter. This exercise teaches you to leverage the Standard Library to write less code while increasing performance.

Given Input: text = "Python Programming"

Expected Output:

Character Frequency: 
Counter({'p': 2, 'y': 1, 't': 1, 'h': 1, 'o': 2, 'n': 2, 'r': 2, 'a': 1, 'g': 2, 'm': 2, 'i': 1})

from collections import Counter

def get_frequency(input_string):
    # Clean the string: remove spaces and lowercase everything
    clean_text = input_string.lower().replace(" ", "")
    
    # Counter automatically builds the frequency map
    return Counter(clean_text)

text = "Python Programming"
freq = get_frequency(text)

print(f"Original: {text}")
print(f"Character Frequency: {freq}")Code language: Python (python)

Exercise 4: Anagram Checker

Practice Problem: Write a function that determines if two strings are anagrams (contain the exact same characters in a different order).

Exercise Purpose: This problem introduces the concept of algorithmic sorting as a comparison tool. It demonstrates that transforming data into a “canonical” or “standard” form (sorted) makes comparison trivial.

Given Input: word1 = "listen", word2 = "silent"

Expected Output: Is "listen" an anagram of "silent"? True

def is_anagram(str1, str2):
    # Clean and sort both strings
    s1 = sorted(str1.lower().replace(" ", ""))
    s2 = sorted(str2.lower().replace(" ", ""))
    
    # If the sorted lists are identical, they are anagrams
    return s1 == s2

w1, w2 = "listen", "silent"
result = is_anagram(w1, w2)

print(f'Is "{w1}" an anagram of "{w2}"? {result}')Code language: Python (python)

Exercise 5: Flatten a Nested List

Practice Problem: Write a recursive function that takes a list containing other lists (of any depth) and returns a single “flat” list of all elements.

Exercise Purpose: Intermediate Python often involves dealing with nested data (like JSON). This exercise teaches Recursion—the ability of a function to call itself—to drill down into nested structures until it finds base values.

Given Input: nested = [1, [2, 3], [4, [5, 6]], 7]

Expected Output: Flattened: [1, 2, 3, 4, 5, 6, 7]

def flatten(lst):
    flat_list = []
    
    for item in lst:
        if isinstance(item, list):
            # Recursion: if it's a list, flatten it and extend our results
            flat_list.extend(flatten(item))
        else:
            # Base case: it's a single value, just add it
            flat_list.append(item)
            
    return flat_list

nested_data = [1, [2, 3], [4, [5, 6]], 7]
result = flatten(nested_data)

print(f"Original:  {nested_data}")
print(f"Flattened: {result}")Code language: Python (python)

Exercise 6: Reverse Each Word of a String

Practice Problem: Given a sentence, reverse each individual word within the string while maintaining the original word order.

Exercise Purpose: This exercise teaches you the difference between reversing a sequence (the whole string) and iterating through sub-sequences (words). It emphasizes the use of the .split() and .join() methods, which are essential for text processing.

Given Input: "Python is awesome"

Expected Output: "nohtyP si emosewa"

def reverse_individual_words(sentence):
    # Split sentence into words
    words = sentence.split()
    
    # Reverse each word using slicing
    reversed_words = [word[::-1] for word in words]
    
    # Join them back into a single string
    return " ".join(reversed_words)

# Usage
text = "Python is awesome"
result = reverse_individual_words(text)
print(f"Original: {text}")
print(f"Result:   {result}")Code language: Python (python)

Exercise 7: Palindrome Sentence

Practice Problem: Write a function to check if a full sentence is a palindrome. You must ignore case, spaces, and all punctuation marks.

Exercise Purpose: Real-world palindromes often include punctuation (e.g., “Madam, I’m Adam”). This exercise teaches you how to sanitize data using isalnum() (is alphanumeric) before performing logic, ensuring your algorithm only focuses on the relevant characters.

Given Input: "A man, a plan, a canal: Panama"

Expected Output: True

def is_palindrome_sentence(sentence):
    # Filter out punctuation and spaces, convert to lowercase
    clean_chars = [char.lower() for char in sentence if char.isalnum()]
    
    # Join into a string
    clean_str = "".join(clean_chars)
    
    # Compare with its reverse
    return clean_str == clean_str[::-1]

# Usage
test_s = "A man, a plan, a canal: Panama"
print(f"Is palindrome? {is_palindrome_sentence(test_s)}")Code language: Python (python)

Exercise 8: List Comprehension Filtering (Advanced)

Practice Problem: Given a list of strings, use a single list comprehension to extract strings that meet two criteria: they must be longer than 5 characters AND they must start with a vowel (a, e, i, o, u).

Exercise Purpose: This exercise builds “filter stacking” skills. In professional Python development, you often need to perform complex data extraction in a readable, concise way without writing multiple if statements.

Given Input: ["apple", "education", "ice", "ocean", "python", "umbrella"]

Expected Output: ['education', 'umbrella']

words = ["apple", "education", "ice", "ocean", "python", "umbrella"]

# Filter: starts with vowel AND length > 5
vowel_long = [
    w for w in words 
    if len(w) > 5 and w[0].lower() in 'aeiou'
]

print(f"Original: {words}")
print(f"Filtered: {vowel_long}")Code language: Python (python)

Exercise 9: Remove Duplicates (Preserving Order)

Practice Problem: Write a function that removes duplicate elements from a list. You cannot use set() because sets do not maintain the original order of elements.

Exercise Purpose: While list(set(items)) is the fastest way to get unique items, it scrambles the order. This exercise teaches you how to use an auxiliary “seen” collection to maintain sequence integrity, a common requirement in data logging.

Given Input: [1, 2, 2, 3, 1, 4, 2]

Expected Output: [1, 2, 3, 4]

def remove_duplicates_ordered(items):
    seen = set()
    result = []
    
    for x in items:
        if x not in seen:
            result.append(x)
            seen.add(x)
            
    return result

# Usage
nums = [1, 2, 2, 3, 1, 4, 2]
print(f"Cleaned List: {remove_duplicates_ordered(nums)}")Code language: Python (python)

Exercise 10: Circular Shift (Rotation)

Practice Problem: Create a function rotate_list(lst, n, direction) that shifts the elements of a list by N positions. The direction can be ‘left’ or ‘right’.

Exercise Purpose: List rotation is common in cryptography and UI carousels. This exercise teaches you how to use slicing and the modulo operator to handle shifts that are larger than the list length.

Given Input: List: [1, 2, 3, 4, 5], Shift: 2, Direction: 'right'

Expected Output: [4, 5, 1, 2, 3]

def rotate_list(lst, n, direction='right'):
    if not lst:
        return lst
        
    # Handle shifts larger than the list length
    n = n % len(lst)
    
    if direction == 'right':
        # Take the last n elements and put them at the front
        return lst[-n:] + lst[:-n]
    else:
        # Take the first n elements and put them at the back
        return lst[n:] + lst[:n]

# Usage
data = [1, 2, 3, 4, 5]
print(f"Right Shift 2: {rotate_list(data, 2, 'right')}")
print(f"Left Shift 1:  {rotate_list(data, 1, 'left')}")Code language: Python (python)

Exercise 11: Dictionary Merging (Value Grouping)

Practice Problem: Merge two dictionaries. If they share a key, the new dictionary should store a list containing values from both dictionaries instead of overwriting the first one.

Exercise Purpose: Standard dictionary merging (dict.update()) overwrites data. This exercise teaches you how to “preserve” data during a merge, which is essential when combining user settings or merging search results from different sources.

Given Input: d1 = {"a": 1, "b": 2}, d2 = {"b": 3, "c": 4}

Expected Output: {'a': [1], 'b': [2, 3], 'c': [4]}

def merge_and_group(dict1, dict2):
    combined = {}
    # Get all unique keys from both dictionaries
    all_keys = set(dict1.keys()) | set(dict2.keys())
    
    for key in all_keys:
        values = []
        if key in dict1:
            values.append(dict1[key])
        if key in dict2:
            values.append(dict2[key])
        combined[key] = values
        
    return combined

# Usage
d1 = {"a": 1, "b": 2}
d2 = {"b": 3, "c": 4}
print(f"Grouped Merge: {merge_and_group(d1, d2)}")Code language: Python (python)

Exercise 12: Inverted Index

Practice Problem: Create a function that “inverts” a dictionary. Convert a dictionary of Author: [List of Books] into a dictionary of Book: Author.

Exercise Purpose: This is the logic behind how search engines work! An Inverted Index allows you to search for a term (the book) and immediately find where it belongs (the author). It emphasizes the use of nested loops and dictionary assignment.

Given Input:

{"Orwell": ["1984", "Animal Farm"], "Huxley": ["Brave New World"]}Code language: Python (python)

Expected Output:

{'1984': 'Orwell', 'Animal Farm': 'Orwell', 'Brave New World': 'Huxley'}

def invert_bibliography(data):
    inverted = {}
    for author, books in data.items():
        for book in books:
            inverted[book] = author
    return inverted

# Usage
authors = {
    "Orwell": ["1984", "Animal Farm"],
    "Huxley": ["Brave New World"]
}
print(f"Inverted Index: {invert_bibliography(authors)}")Code language: Python (python)

Exercise 13: Dictionary Sorting (Lambda)

Practice Problem: Given a list of dictionaries (representing employees), sort them based on their “salary” in descending order using a lambda function.

Exercise Purpose: In data processing, you rarely sort simple lists of numbers. You almost always sort “objects” (dictionaries). This exercise teaches you how to use the key parameter in Python’s sort() to target specific fields within a complex structure.

Given Input:

employees = [{"name": "A", "salary": 50}, {"name": "B", "salary": 70}, {"name": "C", "salary": 60}]Code language: Python (python)

Expected Output:

[{'name': 'B', 'salary': 70}, {'name': 'C', 'salary': 60}, {'name': 'A', 'salary': 50}]

employees = [
    {"name": "Alice", "salary": 50000},
    {"name": "Bob", "salary": 70000},
    {"name": "Charlie", "salary": 60000}
]

# Sort by salary, highest first
sorted_staff = sorted(employees, key=lambda x: x['salary'], reverse=True)

for emp in sorted_staff:
    print(emp)Code language: Python (python)

Exercise 14: Subset and Superset Validation

Practice Problem: Write a script that takes two lists of integers from a user, converts them to sets, and determines if the first set is a Subset, a Superset, or Disjoint from the second.

Exercise Purpose: This exercise introduces formal relational logic between collections. Understanding these relationships is vital when managing user permissions (is this set of permissions a subset of the required ones?) or validating categories.

Given Input: Set A: {1, 2, 3}, Set B: {1, 2, 3, 4, 5}

Expected Output: Set A is a subset of Set B.

def validate_relationships(list1, list2):
    a = set(list1)
    b = set(list2)
    
    if a.issubset(b):
        print("Set A is a subset of Set B.")
    elif a.issuperset(b):
        print("Set A is a superset of Set B.")
    
    if a.isdisjoint(b):
        print("The sets are disjoint (they share no elements).")
    else:
        print(f"The sets share these elements: {a & b}")

# Usage
validate_relationships([1, 2], [1, 2, 3, 4])Code language: Python (python)

Exercise 15: Set Symmetric Difference

Practice Problem: Given two lists of student IDs, find the IDs that appear in either the first or the second list, but not in both.

Exercise Purpose: This is known as the Symmetric Difference. It is a powerful way to identify “exclusive” data. For example, finding customers who visited either in January or February, but did not visit in both months.

Given Input: list1 = [101, 102, 103], list2 = [103, 104, 105]

Expected Output: {101, 102, 104, 105}

def get_exclusive_ids(ids1, ids2):
    set1 = set(ids1)
    set2 = set(ids2)
    
    # Symmetric difference
    return set1 ^ set2

# Usage
january_visitors = [10, 20, 30, 40]
february_visitors = [30, 40, 50, 60]

exclusive = get_exclusive_ids(january_visitors, february_visitors)
print(f"Visitors exclusive to one month: {exclusive}")Code language: Python (python)

Exercise 16: Power Set Generation

Practice Problem: Write a function that generates the Power Set of a given set (a set of all possible subsets, including the empty set and the set itself).

Exercise Purpose: Generating power sets is a fundamental concept in Combinatorics and algorithm design (like solving the knapsack problem). This exercise introduces you to the itertools module, specifically combinations.

Given Input: [1, 2, 3]

Expected Output:

[(), (1,), (2,), (3,), (1, 2), (1, 3), (2, 3), (1, 2, 3)]

from itertools import combinations

def get_power_set(s):
    # Convert input to list to ensure we can index it
    elements = list(s)
    power_set = []
    
    for r in range(len(elements) + 1):
        # Generate all combinations of length r
        for combo in combinations(elements, r):
            power_set.append(combo)
            
    return power_set

# Usage
my_set = {1, 2, 3}
print(f"Power Set: {get_power_set(my_set)}")Code language: Python (python)

Exercise 17: Age Calculator (Exact)

Practice Problem: Create a function that asks for a user’s birthdate (YYYY-MM-DD) and calculates their exact age today in years, months, and days.

Exercise Purpose: Date math is notoriously difficult because of leap years and varying month lengths. This exercise teaches you to use the datetime and dateutil.relativedelta modules, which are the industry standards for handling temporal data in Python.

Given Input: Birthdate: 1995-05-15, Today: 2026-01-02

Expected Output: Age: 30 years, 7 months, 18 days

from datetime import datetime
from dateutil.relativedelta import relativedelta

def calculate_exact_age(birthdate_str):
    try:
        # Parse the input string
        birthdate = datetime.strptime(birthdate_str, "%Y-%m-%d").date()
        today = datetime.now().date()
        
        # Calculate the difference
        diff = relativedelta(today, birthdate)
        
        return f"{diff.years} years, {diff.months} months, {diff.days} days"
    except ValueError:
        return "Invalid date format. Please use YYYY-MM-DD."

# Usage
# Note: You may need to install python-dateutil via pip
user_age = calculate_exact_age("1995-05-15")
print(f"Exact Age: {user_age}")Code language: Python (python)

Exercise 18: Countdown Timer (Time Delta)

Practice Problem: Write a function that calculates the exact number of days, hours, and minutes remaining until the upcoming New Year’s Day.

Exercise Purpose: This exercise teaches you how to perform arithmetic on time objects. Since time is not base-10, you cannot simply subtract numbers; you must use datetime objects and understand the “Timedelta” result to extract specific units.

Given Input: Current Date: 2026-01-02

Expected Output: 363 days, 16 hours, 50 minutes until New Year!

from datetime import datetime

def countdown_to_new_year():
    now = datetime.now()
    # Target: Jan 1 of the next year
    next_year = now.year + 1
    target = datetime(next_year, 1, 1)
    
    diff = target - now
    
    days = diff.days
    # Convert remaining seconds into hours and minutes
    hours, remainder = divmod(diff.seconds, 3600)
    minutes, _ = divmod(remainder, 60)
    
    return f"{days} days, {hours} hours, {minutes} minutes"

print(f"Time remaining: {countdown_to_new_year()} until New Year!")Code language: Python (python)

Exercise 19: Business Days Calculator

Practice Problem: Create a function that takes a start date and an integer N, then calculates the date exactly N business days (Monday–Friday) in the future.

Exercise Purpose: In professional settings (finance, shipping, legal), weekends are ignored. This exercise teaches you how to manipulate dates using a loop while applying conditional logic to “skip” specific days of the week.

Given Input: Start: Friday, 2026-01-02, Days to add: 5

Expected Output:

Start: Friday, 2026-01-02
Business Target: Friday, 2026-01-09

from datetime import timedelta, datetime

def add_business_days(start_date, n):
    current_date = start_date
    days_added = 0
    
    while days_added < n:
        current_date += timedelta(days=1)
        # weekday() returns 0 for Monday, 5 for Saturday, 6 for Sunday
        if current_date.weekday() < 5:
            days_added += 1
            
    return current_date

# Usage
start = datetime(2026, 1, 2) # A Friday
result = add_business_days(start, 5)
print(f"Start: {start.strftime('%A, %Y-%m-%d')}")
print(f"Business Target: {result.strftime('%A, %Y-%m-%d')}")Code language: Python (python)

Exercise 20: Custom Iterator Class

Practice Problem: Create a class PowerOfTwo that allows you to iterate through powers of 2 (1, 2, 4, 8…) up to a specified maximum exponent.

Exercise Purpose: To understand how Python’s for loop works under the hood, you must implement the Iterator Protocol. This requires two magic methods: __iter__ (which returns the iterator object itself) and __next__ (which returns the next value or raises StopIteration).

Given Input: powers = PowerOfTwo(3)

Expected Output: 1 2 4 8

class PowerOfTwo:
    def __init__(self, max_exponent):
        self.max = max_exponent
        self.n = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.n <= self.max:
            result = 2 ** self.n
            self.n += 1
            return result
        else:
            raise StopIteration

# Usage
for val in PowerOfTwo(3):
    print(val)Code language: Python (python)

Exercise 21: Find Duplicates in O(n) Time

Practice Problem: Write a function that identifies all duplicate elements in a list. The solution must run in linear time, meaning you should only traverse the list once.

Exercise Purpose: Many beginners use nested loops to find duplicates, resulting in O(n²) complexity (very slow for large data). This exercise teaches you to use a Set as a lookup table. Since checking if an item exists in a set takes O(1) (constant time), the entire operation stays highly efficient.

Given Input: numbers = [1, 2, 3, 2, 4, 5, 1, 6]

Expected Output: Duplicates found: {1, 2}

def find_duplicates(nums):
    seen = set()
    duplicates = set()
    
    for x in nums:
        if x in seen:
            duplicates.add(x)
        else:
            seen.add(x)
            
    return duplicates

numbers = [1, 2, 3, 2, 4, 5, 1, 6]
print(f"Duplicates found: {find_duplicates(numbers)}")Code language: Python (python)

Exercise 22: Singly Linked List Implementation

Practice Problem: Create a basic Node class and a LinkedList class. Implement a method to append a new node to the end of the list and a method to display the list.

Exercise Purpose: Python handles memory automatically, but understanding Linked Lists is fundamental for technical interviews and understanding how data is structured in memory. This exercise introduces Pointer logic (referencing one object from another).

Given Input: List operations: Append 10, Append 20, Append 30

Expected Output: 10 -> 20 -> 30 -> None

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

class LinkedList:
    def __init__(self):
        self.head = None

    def append(self, data):
        new_node = Node(data)
        if not self.head:
            self.head = new_node
            return
        
        last = self.head
        while last.next:
            last = last.next
        last.next = new_node

    def display(self):
        current = self.head
        while current:
            print(f"{current.data} -> ", end="")
            current = current.next
        print("None")

ll = LinkedList()
ll.append(10)
ll.append(20)
ll.append(30)
ll.display()Code language: Python (python)

Exercise 23: Stack Implementation (LIFO)

Practice Problem: Implement a Stack data structure using a Python list. Create methods for push (add), pop (remove), and peek (view top element).

Exercise Purpose: Stacks follow the Last-In, First-Out (LIFO) principle. They are used in “Undo” features in software and the “Back” button in browsers. This exercise teaches you how to restrict access to a list to follow a specific architectural pattern.

Given Input: Push: "google.com", "pynative.com" | Action: Pop

Expected Output:

Current Top: pynative.com
Popped: pynative.com
New Top: google.com

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()
        return "Stack is empty"

    def peek(self):
        return self.items[-1] if not self.is_empty() else None

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

browser_history = Stack()
browser_history.push("google.com")
browser_history.push("pynative.com")

print(f"Current Top: {browser_history.peek()}")
print(f"Popped: {browser_history.pop()}")
print(f"New Top: {browser_history.peek()}")Code language: Python (python)

Exercise 24: Queue Implementation (FIFO)

Practice Problem: Implement a Queue data structure using collections.deque. Create methods for enqueue (add to back) and dequeue (remove from front).

Exercise Purpose: Queues follow First-In, First-Out (FIFO). Using a standard Python list for a queue is slow because removing the first item (list.pop(0)) requires shifting all other items in memory. deque (Double Ended Queue) is designed to make adding/removing from both ends O(1).

Given Input: Enqueue: "Customer A", "Customer B" | Action: Dequeue

Expected Output:

Serving: Customer A
Next in line: Customer B

from collections import deque

class Queue:
    def __init__(self):
        self.buffer = deque()

    def enqueue(self, val):
        self.buffer.append(val)

    def dequeue(self):
        if len(self.buffer) == 0:
            return "Queue is empty"
        return self.buffer.popleft()

    def peek(self):
        return self.buffer[0] if self.buffer else None

ticket_line = Queue()
ticket_line.enqueue("Customer A")
ticket_line.enqueue("Customer B")

print(f"Serving: {ticket_line.dequeue()}")
print(f"Next in line: {ticket_line.peek()}")Code language: Python (python)

Exercise 25: Recursive Binary Search

Practice Problem: Implement the Binary Search algorithm recursively to find a target value in a sorted list.

Exercise Purpose: While you saw the iterative version in C, implementing it recursively in Python helps you understand how the Call Stack works. You split the problem into “sub-problems” until you reach a base case.

Given Input: Sorted List: [10, 20, 30, 40, 50, 60], Target: 50

Expected Output: Target found at index: 4

def binary_search_recursive(arr, low, high, x):
    # Base Case: target is not in the list
    if high < low:
        return -1

    mid = (low + high) // 2

    # If element is at the middle
    if arr[mid] == x:
        return mid
    
    # If element is smaller than mid, search left sub-array
    elif arr[mid] > x:
        return binary_search_recursive(arr, low, mid - 1, x)
    
    # If element is larger than mid, search right sub-array
    else:
        return binary_search_recursive(arr, mid + 1, high, x)

data = [10, 20, 30, 40, 50, 60]
target = 50
result = binary_search_recursive(data, 0, len(data) - 1, target)

print(f"Target found at index: {result}")Code language: Python (python)

Exercise 26: Lambda Sorting with Tuples

Practice Problem: Given a list of tuples representing employees (Name, Age, Salary), sort the list primarily by Salary in descending order.

Exercise Purpose: In Python, the sort() method and sorted() function are powerful, but they need help when dealing with complex objects. A lambda function is a small, anonymous “throwaway” function that tells Python exactly which part of the data structure to use as the sorting key.

Given Input:

employees = [("Alice", 30, 50000), ("Bob", 25, 75000), ("Charlie", 35, 60000)]Code language: Python (python)

Expected Output:

[('Bob', 25, 75000), ('Charlie', 35, 60000), ('Alice', 30, 50000)]

employees = [
    ("Alice", 30, 50000),
    ("Bob", 25, 75000),
    ("Charlie", 35, 60000)
]

# Sort by salary (index 2) in descending order
sorted_employees = sorted(employees, key=lambda emp: emp[2], reverse=True)

print("Employees sorted by Salary (High to Low):")
for emp in sorted_employees:
    print(emp)Code language: Python (python)

Exercise 27: Map and Filter Combination

Practice Problem: Given a list of numbers, use map() and filter() together to create a list of the squares of only the even numbers.

Exercise Purpose: While list comprehensions are often preferred, understanding map and filter is essential for functional programming and working with large data streams. This exercise teaches you how to chain data transformations: first removing unwanted data, then modifying the rest.

Given Input: nums = [1, 2, 3, 4, 5, 6]

Expected Output: [4, 16, 36]

nums = [1, 2, 3, 4, 5, 6]

# 1. Filter even numbers
# 2. Map those numbers to their squares
result = list(map(lambda x: x**2, filter(lambda x: x % 2 == 0, nums)))

print(f"Original: {nums}")
print(f"Squares of evens: {result}")Code language: Python (python)

Exercise 28: Custom @timer Decorator

Practice Problem: Write a decorator function named @timer that prints how many seconds a function takes to execute. Apply it to a function that simulates a heavy computation using time.sleep().

Exercise Purpose: Decorators are one of Python’s most powerful features. They allow you to “wrap” a function with extra logic (like logging, authentication, or timing) without changing the function’s internal code. This follows the Open-Closed Principle.

Given Input: A function waste_time() that sleeps for 1.5 seconds.

Expected Output: Function 'waste_time' took 1.5023 seconds to run.

import time

def timer(func):
    def wrapper(*args, **kwargs):
        start_time = time.perf_counter() # High-precision start
        result = func(*args, **kwargs)   # Run the actual function
        end_time = time.perf_counter()   # High-precision end
        
        duration = end_time - start_time
        print(f"Function '{func.__name__}' took {duration:.4f} seconds.")
        return result
    return wrapper

@timer
def waste_time():
    time.sleep(1.5)

waste_time()Code language: Python (python)

Exercise 29: Fibonacci Generator (Memory Efficiency)

Practice Problem: Create a generator function that yields Fibonacci numbers up to N. Instead of returning a full list, it should yield values one by one.

Exercise Purpose: If you need to generate a billion numbers, a list would crash your computer’s RAM. A Generator uses the yield keyword to return one value at a time and “pauses” its execution state. This is the key to handling Big Data in Python.

Given Input: n = 8

Expected Output:

First 8 Fibonacci numbers:
0 1 1 2 3 5 8 13 

def fibonacci_gen(limit):
    a, b = 0, 1
    count = 0
    while count < limit:
        yield a
        a, b = b, a + b
        count += 1

# Using the generator
fib = fibonacci_gen(8)

print("First 8 Fibonacci numbers:")
for num in fib:
    print(num, end=" ")Code language: Python (python)

Exercise 30: Custom Context Manager (with statement)

Practice Problem: Write a class that acts as a context manager for handling a database-style connection (Don’t do actual database connection, simply printing “Connected” and “Disconnected”). Use the with statement to ensure the connection is closed even if an error occurs.

Exercise Purpose: Managing resources like files, network sockets, or database connections is risky. If you forget to close them, you get memory leaks. Context managers automate this using the __enter__ and __exit__ magic methods.

Given Input: A block of code inside a with statement that might raise an Exception.

Expected Output:

Connecting to Database... Processing data... 
Error: something went wrong 
Closing Database Connection safely.

class DatabaseConnection:
    def __enter__(self):
        print("Connecting to Database...")
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        print("Closing Database Connection safely.")
        # Returning False allows any exception to propagate normally
        return False

# Usage
try:
    with DatabaseConnection() as db:
        print("Processing data...")
        raise Exception("something went wrong")
except Exception as e:
    print(f"Error: {e}")Code language: Python (python)

Exercise 31: The Versatile *args and **kwargs

Practice Problem: Create a “Logger” function that accepts a mandatory message string, followed by an unknown number of positional arguments (*args), and an unknown number of keyword arguments (**kwargs). The function should print the message, then list the extra arguments and metadata.

Exercise Purpose: Intermediate Pythonistas must write functions that are flexible. *args (tuples) and **kwargs (dictionaries) allow your functions to handle dynamic inputs. This is how major libraries like Django or Flask allow for highly customizable function calls.

Given Input:

log_event("User Login", "admin", "dashboard", timestamp="10:00 AM", status="Success")Code language: Python (python)

Expected Output:

Event: User Login
Details: ('admin', 'dashboard')
Metadata: {'timestamp': '10:00 AM', 'status': 'Success'}

def log_event(message, *args, **kwargs):
    print(f"Event: {message}")
    
    if args:
        print(f"Details: {args}")
    
    if kwargs:
        print(f"Metadata: {kwargs}")

# Usage
log_event("User Login", "admin", "dashboard", timestamp="10:00 AM", status="Success")Code language: Python (python)

Exercise 32: Zip and Enumerate Mapping

Practice Problem: You have two separate lists: one of student names and one of their exam scores. Use zip() to combine them into a dictionary, then use enumerate() to print a ranked list (1st, 2nd, 3rd…).

Exercise Purpose: Data often arrives in separate “columns” (lists). zip() is the standard Pythonic way to merge these columns. enumerate() is a cleaner alternative to using range(len(list)) when you need both the index and the value of an item.

Given Input:

names = ["Alice", "Bob", "Charlie"]
scores = [85, 92, 78]Code language: Python (python)

Expected Output:

Rank 1: Bob scored 92
Rank 2: Alice scored 85
Rank 3: Charlie scored 78

names = ["Alice", "Bob", "Charlie"]
scores = [85, 92, 78]

# Merge lists into a dictionary
score_map = dict(zip(names, scores))

# Sort by score (value) descending
ranked_scores = sorted(score_map.items(), key=lambda item: item[1], reverse=True)

# Enumerate for ranking
for i, (name, score) in enumerate(ranked_scores, start=1):
    print(f"Rank {i}: {name} scored {score}")Code language: Python (python)

Exercise 33: Memoization with lru_cache

Practice Problem: Write a recursive function fibonacci(n) to calculate the n^th number in the Fibonacci sequence. Use functools.lru_cache to optimize it so that it doesn’t recalculate the same values multiple times.

Exercise Purpose: Recursive functions for Fibonacci are notoriously slow (O(2ⁿ)) because they recalculate the same branches of the “recursion tree” over and over. Memoization stores the results of expensive function calls. Python’s lru_cache (Least Recently Used) is a built-in decorator that handles this automatically.

Note: Without cache, this would take minutes; with cache, it’s instant.

Given Input: fibonacci(50)

Expected Output:

Fibonacci(50) = 12586269025

from functools import lru_cache

@lru_cache(maxsize=None)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

# Calculation
n = 50
print(f"Fibonacci({n}) = {fibonacci(n)}")
print(f"Cache Info: {fibonacci.cache_info()}")Code language: Python (python)

Exercise 34: Set Operations for Data Analysis

Exercise Purpose: Sets are not just for removing duplicates; they are powerful mathematical tools for comparing collections. Using set logic is much faster and more readable than writing multiple for loops with if conditions.

Given Input:

trial = [1, 2, 3, 4, 5]
paid = [4, 5, 6, 7, 8]Code language: Python (python)

Expected Output:

Upgraded (Both): {4, 5}
Leads (Trial only): {1, 2, 3}
Unique Status (Not both): {1, 2, 3, 6, 7, 8}

trial = {1, 2, 3, 4, 5} # Converted to sets
paid = {4, 5, 6, 7, 8}

upgraded = trial & paid
leads = trial - paid
unique = trial ^ paid

print(f"Upgraded (Both): {upgraded}")
print(f"Leads (Trial only): {leads}")
print(f"Unique Status (Not both): {unique}")Code language: Python (python)

Exercise 35: Inheritance and Method Overriding

Practice Problem: Create a base class Vehicle with an attribute called brand and a method fuel_type(). Then, create a subclass ElectricCar that inherits from Vehicle and overrides the fuel_type() method to return “Electricity.”

Exercise Purpose: Inheritance allows you to define a general behavior in a “parent” class and then specialize it in a “child” class. This prevents code duplication (DRY—Don’t Repeat Yourself) and creates a logical hierarchy in your software.

Given Input: car = ElectricCar("Tesla")

Expected Output:

Brand: Tesla
Fuel Type: Electricity

class Vehicle:
    def __init__(self, brand):
        self.brand = brand

    def fuel_type(self):
        return "Petrol/Diesel"

class ElectricCar(Vehicle):
    # Override the fuel_type method
    def fuel_type(self):
        return "Electricity"

# Usage
my_tesla = ElectricCar("Tesla")
print(f"Brand: {my_tesla.brand}")
print(f"Fuel Type: {my_tesla.fuel_type()}")Code language: Python (python)

Exercise 36: Encapsulation (Private Attributes)

Practice Problem: Create a BankAccount class where the balance is a private attribute (cannot be accessed directly from outside the class). Provide deposit and withdraw methods to modify the balance safely.

Exercise Purpose: Encapsulation is about data protection. By making attributes private, you prevent external code from accidentally setting a balance to a negative number or a string. You force all changes to go through “gatekeeper” methods.

Given Input:

account = BankAccount(100)
account.deposit(50)
account.withdraw(200) # This should trigger a warningCode language: Python (python)

Expected Output:

Deposited 50.
New Balance: 150 
Insufficient funds! Final Balance: 150

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

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
            print(f"Deposited {amount}. New Balance: {self.__balance}")

    def withdraw(self, amount):
        if 0 < amount <= self.__balance:
            self.__balance -= amount
            print(f"Withdrew {amount}. New Balance: {self.__balance}")
        else:
            print("Insufficient funds!")

    def get_balance(self):
        return self.__balance

# Usage
acc = BankAccount(100)
acc.deposit(50)
acc.withdraw(200)
print(f"Final Balance: {acc.get_balance()}")Code language: Python (python)

Exercise 37: Property Decorators (@property)

Practice Problem: Create a Student class with a name and a score. Use the @property decorator to create a getter for the score, and a @score.setter to ensure that any score assigned is between 0 and 100.

Exercise Purpose: Property decorators allow you to treat a method like an attribute. This is “Pythonic” because it allows you to add validation logic (like checking the 0–100 range) later in development without changing the way users interact with your class.

Given Input:

s = Student("Kevin")
s.score = 105 # Should trigger a ValueErrorCode language: Python (python)

Expected Output: ValueError: Score must be between 0 and 100.

class Student:
    def __init__(self, name):
        self.name = name
        self._score = 0 # Internal storage

    @property
    def score(self):
        return self._score

    @score.setter
    def score(self, value):
        if 0 <= value <= 100:
            self._score = value
        else:
            raise ValueError("Score must be between 0 and 100.")

# Usage
s = Student("Kevin")
try:
    s.score = 95  # Looks like attribute assignment, but calls the setter
    print(f"{s.name}'s score: {s.score}")
    s.score = 105 # This will fail
except ValueError as e:
    print(f"Error: {e}")Code language: Python (python)

Exercise 38: Class Methods vs. Static Methods

Practice Problem: Create a class Pizza that has a price attribute. Implement a @classmethod called margherita() that returns a pre-configured Pizza object and a @staticmethod called validate_topping() that checks if a topping is “healthy.”

Exercise Purpose: 1. Class Methods are “Factory” methods; they have access to the class (cls) and are used to create specific instances. 2. Static Methods are “Utility” methods; they live inside the class for organization but don’t need access to class or instance data.

Given Input:

my_pizza = Pizza.margherita()
is_valid = Pizza.validate_topping("pineapple")Code language: Python (python)

Expected Output:

Pizza ordered: Margherita
Is topping valid? True

class Pizza:
    def __init__(self, name, toppings):
        self.name = name
        self.toppings = toppings

    @classmethod
    def margherita(cls):
        # Returns a new instance of the class (factory pattern)
        return cls("Margherita", ["cheese", "tomato"])

    @staticmethod
    def validate_topping(topping):
        # Independent utility logic
        prohibited = ["plastic", "metal"]
        return topping not in prohibited

# Usage
order = Pizza.margherita()
print(f"Pizza ordered: {order.name}")
print(f"Is 'mushrooms' valid? {Pizza.validate_topping('mushrooms')}")Code language: Python (python)

Exercise 39: Magic Methods (__str__ and __add__)

Practice Problem: Create a Point class that represents (x, y) coordinates. Implement __str__ so that printing the object looks like (x, y) and implement __add__ so that p1 + p2 adds the coordinates together.

Exercise Purpose: “Magic methods” (or Dunder methods) allow your custom objects to “hook into” Python’s built-in syntax. By implementing __add__, you tell Python what the + sign should do when it encounters your objects.

Given Input:

p1 = Point(1, 2)
p2 = Point(3, 4)
print(p1 + p2)Code language: Python (python)

Expected Output: (4, 6)

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    # Controls how the object is printed
    def __str__(self):
        return f"({self.x}, {self.y})"

    # Overloads the '+' operator
    def __add__(self, other):
        new_x = self.x + other.x
        new_y = self.y + other.y
        return Point(new_x, new_y)

# Usage
p1 = Point(1, 2)
p2 = Point(3, 4)
combined = p1 + p2

print(f"Point 1: {p1}")
print(f"Point 2: {p2}")
print(f"Combined Result: {combined}")Code language: Python (python)

Exercise 40: Abstract Base Classes (ABC)

Practice Problem: Create an abstract base class Shape with an abstract method area(). Then, implement two subclasses, Circle and Square, that provide the actual logic for calculating their respective areas.

Exercise Purpose: Abstract Base Classes (ABCs) act as a contract. They define a set of methods that all subclasses must implement. If you try to instantiate a subclass that hasn’t defined area(), Python will raise an error. This is vital for building large frameworks where you want to ensure consistency across many different modules.

Given Input: shapes = [Circle(5), Square(4)]

Expected Output:

Circle Area: 78.54 Square Area: 16

from abc import ABC, abstractmethod
import math

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

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
    
    def area(self):
        return math.pi * (self.radius ** 2)

class Square(Shape):
    def __init__(self, side):
        self.side = side
        
    def area(self):
        return self.side ** 2

# Usage
shapes = [Circle(5), Square(4)]
for s in shapes:
    print(f"{type(s).__name__} Area: {s.area():.2f}")Code language: Python (python)

Exercise 41: Multiple Inheritance and MRO

Practice Problem: Create two classes, Flyer (with a fly() method) and Swimmer (with a swim() method). Create a Duck class that inherits from both. Use the __mro__ attribute to inspect the search order.

Exercise Purpose: Python allows a class to inherit from multiple parents. However, this can get complicated (the “Diamond Problem”). This exercise teaches you how Python resolves which method to call using the Method Resolution Order (MRO).

Given Input:

d = Duck()
d.fly()
d.swim()Code language: Python (python)

Expected Output:

Flying high!
Swimming fast!
MRO: (<class '__main__.Duck'>, <class '__main__.Flyer'>, <class '__main__.Swimmer'>, <class 'object'>)

class Flyer:
    def fly(self):
        print("Flying high!")

class Swimmer:
    def swim(self):
        print("Swimming fast!")

class Duck(Flyer, Swimmer):
    pass

# Usage
d = Duck()
d.fly()
d.swim()

print(f"MRO: {Duck.__mro__}")Code language: Python (python)

Exercise 42: Composition over Inheritance

Practice Problem: Build a Computer class that is “composed” of a CPU object and a RAM object, rather than inheriting from them.

Exercise Purpose: A common mantra in software engineering is “Compose instead of Inherit.” While inheritance implies a “is-a” relationship (a Dog is a Mammal), composition implies a “has-a” relationship (a Computer has a CPU). This makes your code more modular and easier to change later.

Given Input: my_comp = Computer("Intel i7", "16GB")

Expected Output: Computer with Intel i7 CPU and 16GB RAM.

class CPU:
    def __init__(self, model):
        self.model = model

class RAM:
    def __init__(self, size):
        self.size = size

class Computer:
    def __init__(self, cpu_model, ram_size):
        # The Computer "has" a CPU and RAM
        self.cpu = CPU(cpu_model)
        self.ram = RAM(ram_size)

    def __str__(self):
        return f"Computer with {self.cpu.model} CPU and {self.ram.size} RAM."

# Usage
my_pc = Computer("Intel i7", "16GB")
print(my_pc)Code language: Python (python)

Exercise 43: The Singleton Pattern

Practice Problem: Implement a Database class that ensures only one instance of itself can ever exist. If a user tries to create a second instance, it should return the first one created.

Exercise Purpose: Sometimes, you need exactly one instance of a class to coordinate actions across a system (like a log file manager or a database connection pool). This exercise introduces the __new__ magic method, which controls the actual creation of the object (before __init__ even runs).

Given Input:

db1 = Database()
db2 = Database()
print(db1 is db2)Code language: Python (python)

Expected Output:

Loading Database... True (Both variables point to the same memory address)

class Database:
    _instance = None # Class-level variable to hold the single instance

    def __new__(cls):
        if cls._instance is None:
            print("Loading Database (First time only)...")
            cls._instance = super(Database, cls).__new__(cls)
        return cls._instance

# Usage
db1 = Database()
db2 = Database()

print(f"Are they the same instance? {db1 is db2}")Code language: Python (python)

Exercise 44: Data Classes (@dataclass)

Practice Problem: Refactor a standard Book class (with title, author, and pages) into a dataclass. Show how it automatically handles __init__ and __repr__.

Exercise Purpose: Writing self.x = x fifty times in a large project is tedious. Python 3.7+ introduced dataclasses to automatically generate “boilerplate” code like __init__, __repr__ (printable representation), and __eq__. It makes your code cleaner and faster to write.

Given Input: b1 = Book("1984", "George Orwell", 328)

Expected Output: Book(title='1984', author='George Orwell', pages=328)

from dataclasses import dataclass

@dataclass
class Book:
    title: str
    author: str
    pages: int

# Usage
b1 = Book("1984", "George Orwell", 328)
b2 = Book("1984", "George Orwell", 328)

print(b1) # Automatically has a nice __repr__
print(f"Is b1 equal to b2? {b1 == b2}") # Automatically handles comparisonCode language: Python (python)

Exercise 45: CSV Processor

Practice Problem: Write a script that reads a CSV file containing employee names and salaries. Calculate the average salary and write the results (Original Data + Average) into a new CSV file.

Exercise Purpose: CSV (Comma-Separated Values) is the most common format for data exchange. This exercise teaches you to use the built-in csv module, specifically DictReader and DictWriter, which allow you to treat rows as dictionaries rather than just lists of strings.

Given Input (data.csv):

Name,Salary
Alice,50000
Bob,60000
Charlie,70000

Expected Output:

output.csv: 
Includes the original data and a final row: Average,60000.0.

import csv

def process_salaries(input_file, output_file):
    salaries = []
    rows = []

    # Read the data
    with open(input_file, mode='r', newline='') as f:
        reader = csv.DictReader(f)
        for row in reader:
            salaries.append(int(row['Salary']))
            rows.append(row)

    avg_salary = sum(salaries) / len(salaries)

    # Write the data
    fieldnames = ['Name', 'Salary']
    with open(output_file, mode='w', newline='') as f:
        writer = csv.DictWriter(f, fieldnames=fieldnames)
        writer.writeheader()
        writer.writerows(rows)
        writer.writerow({'Name': 'Average', 'Salary': avg_salary})

# Note: You would need a 'data.csv' file in your directory to run this.Code language: Python (python)

Exercise 46: JSON Parser and Nested Access

Practice Problem: Given a JSON string representing a user profile with nested settings, parse the string and safely update a specific nested value (e.g., changing the “theme” from “light” to “dark”).

Exercise Purpose: JSON is the language of the web. Most APIs send and receive data in this format. This exercise teaches you how to convert between Python objects (dictionaries/lists) and JSON strings using the json module.

Given Input:

user_json = '{"id": 1, "profile": {"name": "Alice", "settings": {"theme": "light"}}}'Code language: Python (python)

Expected Output:

Updated JSON: {"id": 1, "profile": {"name": "Alice", "settings": {"theme": "dark"}}}

import json

user_json = '{"id": 1, "profile": {"name": "Alice", "settings": {"theme": "light"}}}'

# Convert string to dictionary
data = json.loads(user_json)

# Access nested keys and update
data['profile']['settings']['theme'] = 'dark'

# Convert back to JSON string with pretty printing
updated_json = json.dumps(data, indent=4)

print("Updated Profile Settings:")
print(updated_json)Code language: Python (python)

Exercise 47: Regular Expressions (Email Extractor)

Practice Problem: Write a script that takes a long block of messy text and extracts all valid email addresses using the re module.

Exercise Purpose: Regular Expressions (Regex) are a language within a language. They are used for advanced pattern matching. Instead of writing complex loops to search for an “@” and a “.”, Regex allows you to define a “template” that describes what an email looks like.

Given Input:

text = "Contact us at support@company.com or sales.dept@office.org for help."Code language: Python (python)

Expected Output: ['support@company.com', 'sales.dept@office.org']

import re

text = "Contact us at support@company.com or sales.dept@office.org for help."

# Regex pattern for a standard email
email_pattern = r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}'

emails = re.findall(email_pattern, text)

print(f"Emails found: {emails}")Code language: Python (python)

Exercise 48: Robust Error Handling (Try/Except/Finally)

Practice Problem: Write a function divide_numbers(a, b) that handles ZeroDivisionError and TypeError (if the user passes a string). Use a finally block to print “Operation complete” regardless of the outcome.

Exercise Purpose: Real-world code fails. Users enter text where they should enter numbers, and servers go offline. Professional Pythonistas use try/except to “catch” these errors gracefully so the entire program doesn’t crash.

Given Input:

1. divide_numbers(10, 2)
2. divide_numbers(10, 0)
3. divide_numbers(10, "apple")

Expected Output:

Result: 5.0
Operation complete.
--------------------
Error: Cannot divide by zero!
Operation complete.
--------------------
Error: Please provide numbers (integers or floats).
Operation complete.

def divide_numbers(a, b):
    try:
        result = a / b
        print(f"Result: {result}")
    except ZeroDivisionError:
        print("Error: Cannot divide by zero!")
    except TypeError:
        print("Error: Please provide numbers (integers or floats).")
    except Exception as e:
        print(f"An unexpected error occurred: {e}")
    finally:
        print("Operation complete.")

# Tests
divide_numbers(10, 0)
print("-" * 20)
divide_numbers(10, "apple")Code language: Python (python)

Exercise 49: OS Module (File Searcher)

Practice Problem: Write a function that walks through a directory and all of its subdirectories, printing the full path of every .txt file it finds.

Exercise Purpose: Being able to navigate the file system programmatically is a core skill for automation. The os.walk() function is a powerful generator that handles the complex recursion of folders for you.

Given Input: A root directory name.

Expected Output:

Found: /Users/name/Documents/notes.txt 
Found: /Users/name/Documents/Work/todo.txt

import os

def find_txt_files(start_dir):
    for root, dirs, files in os.walk(start_dir):
        for file in files:
            if file.endswith(".txt"):
                # Join the folder path and file name correctly
                full_path = os.path.join(root, file)
                print(f"Found: {full_path}")

# Usage (Use '.' for current directory)
find_txt_files('.')Code language: Python (python)

Exercise 50: Multi-threading (Concurrency)

Practice Problem: Use the threading module to run two functions simultaneously. One function should “Download File A” and the other “Download File B” (using time.sleep to simulate the delay).

Exercise Purpose: Python is often “I/O bound,” meaning it spends a lot of time waiting for things (like web downloads). Threading allows your program to do other work while waiting, effectively running tasks in parallel and saving time.

Given Input: Two tasks taking 2 seconds each.

Expected Output:

Total time taken: 2 seconds (instead of 4 seconds).

import threading
import time

def download_file(name, duration):
    print(f"Starting download: {name}")
    time.sleep(duration)
    print(f"Finished download: {name}")

start = time.perf_counter()

# Create threads
t1 = threading.Thread(target=download_file, args=("File_A", 2))
t2 = threading.Thread(target=download_file, args=("File_B", 2))

# Start threads
t1.start()
t2.start()

# Wait for both to finish before continuing
t1.join()
t2.join()

end = time.perf_counter()
print(f"Total time taken: {end - start:.2f} seconds")Code language: Python (python)

Exercise 51: API Requests with Error Handling

Practice Problem: Use the requests library to fetch data from a public API (like JSONPlaceholder). Handle potential connection errors or timeouts using a try/except block.

Exercise Purpose: Most modern Python applications rely on third-party APIs. Learning to handle the “unreliability” of the internet (timeouts, 404 errors, 500 server errors) is what makes a script “robust.”

Given Input:

URL = "https://jsonplaceholder.typicode.com/todos/1"Code language: Python (python)

Expected Output:

Status Code: 200 Data: {'userId': 1, 'id': 1, 'title': 'delectus aut autem', 'completed': False}

import requests

def get_todo_data(todo_id):
    url = f"https://jsonplaceholder.typicode.com/todos/{todo_id}"
    try:
        response = requests.get(url, timeout=5)
        
        # This raises an error if the status is 4xx or 5xx
        response.raise_for_status()
        
        data = response.json()
        print(f"Data: {data}")
        
    except requests.exceptions.HTTPError as err:
        print(f"HTTP Error: {err}")
    except requests.exceptions.ConnectionError:
        print("Error: Could not connect to the server.")
    except Exception as e:
        print(f"An error occurred: {e}")

get_todo_data(1)Code language: Python (python)

Exercise 52: Word Frequency Counter

Practice Problem: Write a function that takes a paragraph of text and returns a dictionary where the keys are unique words and the values are the number of times those words appear. Ensure the counter is case-insensitive and ignores punctuation.

Exercise Purpose: This combines string cleaning (regex or string methods) with dictionary logic. It’s a foundational task for Natural Language Processing (NLP) and data analysis.

Given Input:

text = "Python is great. Python is fast, and learning Python is fun!"Code language: Python (python)

Expected Output:

{'python': 3, 'is': 3, 'great': 1, 'fast': 1, 'and': 1, 'learning': 1, 'fun': 1}

import re
from collections import Counter

def count_words(text):
    # Remove punctuation using Regex and convert to lowercase
    clean_text = re.sub(r'[^\w\s]', '', text).lower()
    
    # Split into words and count
    words = clean_text.split()
    return dict(Counter(words))

text = "Python is great. Python is fast, and learning Python is fun!"
print(f"Word Frequency: {count_words(text)}")Code language: Python (python)

Exercise 53: Student Management System

Practice Problem: Create a system using a dictionary of dictionaries to manage student records. Implement functions to add_student, update_grade, and display_all. Each student should have a unique ID.

Exercise Purpose: This exercise teaches you how to manage Nested Data Structures. In Python, dictionaries are often used as “in-memory databases” before transitioning to actual SQL or NoSQL databases.

Given Input:

1. Add ID 101: “Alice”, Grade: “A”
2. Update ID 101: Grade: “A+”

Expected Output: ID: 101 | Name: Alice | Grade: A+

students = {}

def add_student(s_id, name, grade):
    students[s_id] = {"name": name, "grade": grade}

def update_grade(s_id, new_grade):
    if s_id in students:
        students[s_id]["grade"] = new_grade
    else:
        print("Student not found.")

def display_students():
    for s_id, info in students.items():
        print(f"ID: {s_id} | Name: {info['name']} | Grade: {info['grade']}")

add_student(101, "Alice", "A")
update_grade(101, "A+")
display_students()Code language: Python (python)

Exercise 54: Password Strength Checker

Practice Problem: Write a function that takes a string and returns a “Strength Score” (0–5). The password gets 1 point for meeting each criteria: 8+ characters, has uppercase, has lowercase, has a digit, and has a special character (e.g., !, @, #).

Exercise Purpose: This reinforces the use of Boolean Logic and string character testing methods like .isupper(), .isdigit(), and the any() function.

Given Input: "P@ss123"

Expected Output: Strength: 5/5 (Very Strong)

def check_password(password):
    checks = [
        len(password) >= 8,
        any(char.isupper() for char in password),
        any(char.islower() for char in password),
        any(char.isdigit() for char in password),
        any(not char.isalnum() for char in password) # Special character check
    ]
    
    score = sum(checks)
    levels = {5: "Very Strong", 4: "Strong", 3: "Moderate", 2: "Weak", 1: "Very Weak", 0: "Invalid"}
    
    return f"Strength: {score}/5 ({levels.get(score)})"

print(check_password("P@ssword123"))Code language: Python (python)

Exercise 55: Number Guessing Game (Computer vs User)

Practice Problem: Create a game where the computer picks a random number between 1 and 100. The user has 10 attempts to guess it. After each guess, the computer tells the user if the actual number is “Higher” or “Lower.”

Exercise Purpose: This project focuses on Control Flow (while-loops) and the random module. It also introduces basic User Input Validation to ensure the game doesn’t crash if a user types something that isn’t a number.

Given Input: Target: 42 | User Guess: 50

Expected Output:

I'm thinking of a number between 1 and 100.
(10 left) Enter guess: 45
Higher!
(9 left) Enter guess: 97
Lower!
(8 left) Enter guess: 52
Higher!
(7 left) Enter guess: 85
Lower!
(6 left) Enter guess: 93
Lower!
(5 left) Enter guess: 54
Correct! The number was 54.

import random

def play_game():
    target = random.randint(1, 100)
    attempts = 10
    
    print("I'm thinking of a number between 1 and 100.")

    while attempts > 0:
        try:
            guess = int(input(f"({attempts} left) Enter guess: "))
        except ValueError:
            print("Invalid input. Enter a number!")
            continue

        if guess == target:
            print(f"Correct! The number was {target}.")
            return
        elif guess < target:
            print("Higher!")
        else:
            print("Lower!")
        
        attempts -= 1

    print(f"Game Over. The number was {target}.")

# play_game() # Uncomment to runCode language: Python (python)

Exercise 56: File Word Count Tool

Practice Problem: Write a script that reads a text file and prints the total number of lines, words, and characters (including spaces).

Exercise Purpose: This mimics the Unix wc (word count) command. It teaches you how to efficiently process a file line-by-line, which is a key skill for working with large logs or text datasets.

Given Input (sample.txt):

Hello World
Python is fun.

Expected Output: Lines: 2 | Words: 5 | Characters: 27

def file_stats(filename):
    lines, words, chars = 0, 0, 0
    
    try:
        with open(filename, 'r') as f:
            for line in f:
                lines += 1
                words += len(line.split())
                chars += len(line)
        
        print(f"Lines: {lines} | Words: {words} | Characters: {chars}")
    except FileNotFoundError:
        print("The file does not exist.")

# file_stats("my_story.txt")Code language: Python (python)

Exercise 57: Prime Number Generator

Practice Problem: Write a function that takes a range (start and end) and returns a list of all prime numbers within that range. Optimize the check by only testing divisors up to the square root of the number.

Exercise Purpose: This exercise sharpens your understanding of nested loops and mathematical optimization. Checking divisors up to sqrt{n} significantly improves performance compared to checking every number up to n.

Given Input: Range: 10 to 50

Expected Output:

Primes: [11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]

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

def generate_primes(start, end):
    return [num for num in range(start, end + 1) if is_prime(num)]

# Usage
primes = generate_primes(10, 50)
print(f"Primes in range: {primes}")Code language: Python (python)

Exercise 58: Email Validation Program

Practice Problem: Create a script that asks for an email address and validates it against a comprehensive Regular Expression. It should check for a username, the @ symbol, a domain name, and a valid top-level domain (like .com or .org).

Exercise Purpose: While basic string methods can find an “@” sign, only Regular Expressions (Regex) can ensure the structure of the email is truly valid according to web standards.

Given Input:

email1 = "python_pro@gmail.com"
email2 = "bad-email@com"Code language: Python (python)

Expected Output:

'python_pro@gmail.com' is a Valid Email
'bad-email@com' is an Invalid Email

import re

def validate_email(email):
    # Pattern: [name] @ [domain] . [extension]
    regex = r'^[a-z0-9]+[\._]?[a-z0-9]+[@]\w+[.]\w{2,3}$'
    
    if re.search(regex, email):
        print(f"'{email}' is a Valid Email")
    else:
        print(f"'{email}' is an Invalid Email")

# Usage
validate_email("python_pro@gmail.com")
validate_email("bad-email@com")Code language: Python (python)

Exercise 59: File-Based To-Do List App

Practice Problem: Build a simple CLI app that allows users to add tasks to a text file, view the current list, and “clear” the list. The tasks should persist even after the program is closed.

Exercise Purpose: This introduces Persistent Storage. Instead of data disappearing when the script ends (RAM), we save it to the hard drive (Disk).

Given Input:

Add Task: "Buy Milk"
Add Task: "Finish Python Project"

Expected Output:

--- My To-Do List --- 
1. Buy Milk
2. Finish Python Project

FILE_NAME = "todo.txt"

def add_task(task):
    with open(FILE_NAME, "a") as f:
        f.write(task + "\n")

def view_tasks():
    try:
        with open(FILE_NAME, "r") as f:
            print("\n--- Current Tasks ---")
            for i, line in enumerate(f, 1):
                print(f"{i}. {line.strip()}")
    except FileNotFoundError:
        print("No tasks found.")

def clear_tasks():
    open(FILE_NAME, "w").close() # Opening in 'w' mode clears the file
    print("List cleared.")

# Usage
add_task("Code in Python")
add_task("Walk the dog")
view_tasks()Code language: Python (python)

Exercise 60: Random Password Generator

Practice Problem: Write a script that generates a random, secure password. The user should be able to specify the desired length, and the password must include a mix of uppercase letters, lowercase letters, numbers, and symbols.

Exercise Purpose: This project teaches you to use the secrets module (which is more secure than random for passwords) and the string module, which contains pre-defined constants like all letters and punctuation.

Given Input: Length: 12

Expected Output: Generated Password: 4k#79!zP[2mQ

import secrets
import string

def generate_password(length):
    if length < 4:
        return "Length too short!"
    
    # Define the character pool
    pool = string.ascii_letters + string.digits + string.punctuation
    
    # Generate password using secrets for cryptographic security
    password = "".join(secrets.choice(pool) for _ in range(length))
    return password

# Usage
print(f"Secure Password: {generate_password(16)}")Code language: Python (python)

Exercise 61: Pascal’s Triangle

Practice Problem: Write a function to generate the first N rows of Pascal’s Triangle. Each number is the sum of the two numbers directly above it. See print patterns in Python.

Exercise Purpose: This is a classic algorithmic challenge that tests your ability to manage indices and nested lists. It requires thinking about the relationship between a current row and the row that came before it.

Given Input: Rows: 5

Expected Output:

[1]
[1, 1]
[1, 2, 1]
[1, 3, 3, 1]
[1, 4, 6, 4, 1]

def generate_pascal(n):
    triangle = [[1]]
    
    for i in range(1, n):
        prev_row = triangle[-1]
        # Start the row with 1
        new_row = [1]
        
        # Calculate the middle elements
        for j in range(1, i):
            new_row.append(prev_row[j-1] + prev_row[j])
        
        # End the row with 1
        new_row.append(1)
        triangle.append(new_row)
        
    return triangle

# Usage
for row in generate_pascal(5):
    print(row)Code language: Python (python)

Exercise 62: Smart Property Decorators

Practice Problem: Create a Circle class with a radius attribute. Implement area as a property. If the user changes the radius, the area should reflect the change automatically without needing a manual function call.

Exercise Purpose: This demonstrates Reactive Programming within OOP. Properties allow you to expose calculated data as if it were a simple variable, ensuring that your object’s internal state is always consistent.

Given Input: c = Circle(5), then c.radius = 10

Expected Output: Initial Area: 78.54 Updated Area: 314.16

import math

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

    @property
    def area(self):
        # This re-calculates every time the property is accessed
        return math.pi * (self.radius ** 2)

# Usage
c = Circle(5)
print(f"Area with radius 5: {c.area:.2f}")

c.radius = 10
print(f"Area with radius 10: {c.area:.2f}")Code language: Python (python)

Exercise 63: Caesar Cipher Implementation

Practice Problem: Implement a function that encrypts a message by shifting each letter by a fixed number of positions in the alphabet. It should handle uppercase, lowercase, and ignore non-alphabetic characters.

Exercise Purpose: This is an introduction to Algorithms and Character Encoding. It teaches you how to use ord() (char to integer) and chr() (integer to char) while using the modulo operator to “wrap around” the alphabet from Z back to A.

Given Input: Message: "Hello!", Shift: 3

Expected Output: "Khoor!"

def caesar_cipher(text, shift):
    result = ""
    for char in text:
        if char.isalpha():
            # Determine if we start at 'A' or 'a'
            start = ord('A') if char.isupper() else ord('a')
            # Calculate new position within 0-25 range
            new_pos = (ord(char) - start + shift) % 26
            result += chr(start + new_pos)
        else:
            result += char # Keep punctuation/spaces as is
    return result

# Usage
encrypted = caesar_cipher("Hello World!", 3)
print(f"Encrypted: {encrypted}")
print(f"Decrypted: {caesar_cipher(encrypted, -3)}")Code language: Python (python)

Exercise 64: Hollow Triangle Pattern

Practice Problem: Write a script that prints a hollow triangle of height N. The edges should consist of stars (*), but the interior should be empty space.

Exercise Purpose: This challenges your Coordinate Logic. You must determine the exact conditions under which a star should be printed (the first column, the last column, or the last row) versus a space.

Given Input: Height: 5

Expected Output:

    *    
   * *   
  *   *  
 *     * 
*********

def print_hollow_triangle(n):
    for i in range(1, n + 1):
        for j in range(1, 2 * n):
            # Condition for the two sides of the triangle and the base
            if j == n - i + 1 or j == n + i - 1 or i == n:
                print("*", end="")
            else:
                print(" ", end="")
        print() # New line

print_hollow_triangle(5)Code language: Python (python)

Exercise 65: Solid Diamond Pattern

Practice Problem: Create a script that prints a solid diamond. The user provides the height of the top half, and the program must mirror it to create the bottom half.

Exercise Purpose: This exercise focuses on Symmetry and Loop Ranges. You must learn how to reverse a range (growth vs. shrink) to ensure the diamond aligns perfectly at its widest point.

Given Input:

Size: 4

Expected Output:

   *
  ***
 *****
*******
 *****
  ***
   *

def print_diamond(n):
    # Top Half (Growth)
    for i in range(1, n + 1):
        print(" " * (n - i) + "*" * (2 * i - 1))
    
    # Bottom Half (Shrink)
    for i in range(n - 1, 0, -1):
        print(" " * (n - i) + "*" * (2 * i - 1))

print_diamond(4)Code language: Python (python)