Python Simple Scenario Based Interview Questions and Answers

Python Simple Scenario Based Interview Questions

1. Reverse a string.

def reverse_string(s): return s[::-1] result = reverse_string("hello") print(result) # Output: olleh

String slicing with a step of -1 reverses the string.

2. Check if a string is a palindrome.

def is_palindrome(s): return s == s[::-1] result = is_palindrome("madam") print(result) # Output: True

A palindrome reads the same forwards and backward.

3. Find the factorial of a number.

def factorial(n): if n == 0: return 1 else: return n * factorial(n-1) result = factorial(5) print(result) # Output: 120

Recursive function to calculate factorial.

4. Find the Fibonacci sequence up to n.

def fibonacci(n): fib_list = [0, 1] while fib_list[-1] + fib_list[-2] <= n: fib_list.append(fib_list[-1] + fib_list[-2]) return fib_list result = fibonacci(10) print(result) # Output: [0, 1, 1, 2, 3, 5, 8]

Generate Fibonacci sequence until the last number is less than or equal to n.

5. Check if a number is prime.

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

Check if a number is divisible by any number from 2 to its square root.

6. Remove duplicates from a list.

def remove_duplicates(lst): return list(set(lst)) result = remove_duplicates([1, 2, 2, 3, 4, 4, 5]) print(result) # Output: [1, 2, 3, 4, 5]

Using sets to remove duplicates efficiently.

7. Count the occurrences of each element in a list.

def count_occurrences(lst): counts = {} for item in lst: counts[item] = counts.get(item, 0) + 1 return counts result = count_occurrences([1, 2, 2, 3, 3, 3]) print(result) # Output: {1: 1, 2: 2, 3: 3}

Using a dictionary to store counts.

8. Find the largest element in a list.

def find_largest(lst): if not lst: return None return max(lst) result = find_largest([10, 5, 20, 8]) print(result) # Output: 20

Using the max() function to find the largest element.

9. Sort a list of dictionaries by a key.

def sort_dicts(lst, key): return sorted(lst, key=lambda x: x[key]) data = [{'name': 'Alice', 'age': 25}, {'name': 'Bob', 'age': 30}, {'name': 'Charlie', 'age': 20}] result = sort_dicts(data, 'age') print(result)

Using sorted() with a lambda function to sort by a specific key.

10. Find the intersection of two lists.

def intersection(list1, list2): return list(set(list1) & set(list2)) result = intersection([1, 2, 3, 4], [3, 4, 5, 6]) print(result) # Output: [3, 4]

Using sets to find common elements efficiently.

11. Implement a basic stack.

class Stack: def __init__(self): self.items = [] def push(self, item): self.items.append(item) def pop(self): return self.items.pop() if self.items else None def peek(self): return self.items[-1] if self.items else None def is_empty(self): return len(self.items) == 0 s = Stack() s.push(1) s.push(2) print(s.pop()) # Output: 2

Basic stack implementation using a list.

12. Implement a basic queue.

class Queue: def __init__(self): self.items = [] def enqueue(self, item): self.items.append(item) def dequeue(self): return self.items.pop(0) if self.items else None def is_empty(self): return len(self.items) == 0 q = Queue() q.enqueue(1) print(q.dequeue())

Basic queue implementation using a list.

13. Merge two dictionaries.

def merge_dicts(dict1, dict2): return {**dict1, **dict2} dict1 = {'a': 1, 'b': 2} dict2 = {'c': 3, 'd': 4} result = merge_dicts(dict1, dict2) print(result) # Output: {'a': 1, 'b': 2, 'c': 3, 'd': 4}

Using the ** operator to unpack dictionaries and merge them.

14. Get the value of a key in a dictionary, with a default if it doesn't exist.

def get_dict_value(dictionary, key, default=None): return dictionary.get(key, default) my_dict = {'name': 'Alice', 'age': 30} result = get_dict_value(my_dict, 'city', 'Unknown') print(result) # Output: Unknown

Using the get() method to retrieve a value with a default.

15. Create a list of tuples from two lists.

def create_tuples(list1, list2): return list(zip(list1, list2)) list1 = [1, 2, 3] list2 = ['a', 'b', 'c'] result = create_tuples(list1, list2) print(result) # Output: [(1, 'a'), (2, 'b'), (3, 'c')]

Using the zip() function to combine lists into tuples.

16. Unzip a list of tuples into separate lists.

def unzip_tuples(tuple_list): return list(zip(*tuple_list)) tuple_list = [(1, 'a'), (2, 'b'), (3, 'c')] result = unzip_tuples(tuple_list) print(result) # Output: [(1, 2, 3), ('a', 'b', 'c')]

Using the * operator with zip() to unzip tuples.

17. Find the most frequent element in a list using a dictionary.

def most_frequent(lst): counts = {} for item in lst: counts[item] = counts.get(item, 0) + 1 return max(counts, key=counts.get) lst = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4] result = most_frequent(lst) print(result) # Output: 4

Using a dictionary to count occurrences and then finding the max key based on value.

18. Check if all values in a dictionary are the same.

def all_values_same(dictionary): if not dictionary: return True values = list(dictionary.values()) return values.count(values[0]) == len(values) dict1 = {'a': 1, 'b': 1, 'c': 1} dict2 = {'a': 1, 'b': 2, 'c': 1} print(all_values_same(dict1)) # Output: True print(all_values_same(dict2)) # Output: False

Checks if the count of the first value equals the length of all values.