10 Must Ask Python Interview Questions For Hiring Managers

numbers = [1, 2, 3, 4, 5]

print(“List of numbers:”, numbers)

# Dictionary of names and ages

ages = {“Alice”: 30, “Bob”: 25, “Charlie”: 35}

print(“Dictionary of names and ages:”, ages)

# Set of unique values

unique_values = set([1, 2, 2, 3, 4, 4, 5])

print(“Set of unique values:”, unique_values)

with open(‘example.txt’, ‘w’) as file:

    file.write(“Hello, Python!\n”)

# Reading from a file

with open(‘example.txt’, ‘r’) as file:

    content = file.read()

    print(content)

import requests

from bs4 import BeautifulSoup

# Fetch the content from a web page

response = requests.get(‘http://example.com’)

webpage = response.content

# Parse the content with BeautifulSoup

soup = BeautifulSoup(webpage, ‘html.parser’)

title = soup.title.text

print(“Web page title:”, title)

import pandas as pd

# Creating a DataFrame

data = {‘Name’: [‘Alice’, ‘Bob’, ‘Charlie’], ‘Age’: [25, 30, 35]}

df = pd.DataFrame(data)

# Display the DataFrame

print(df)

• The list’s length is at least 1 and at most 1000.
• The integers are all distinct and range from 1 to n+1, where n is the list’s length.

    n = len(lst) + 1

    expected_sum = n * (n + 1) // 2

    actual_sum = sum(lst)

    return expected_sum – actual_sum

• Forgetting to add 1 to the length of the list when calculating the expected sum.
• Overlooking the possibility of large numbers and the impact on sum calculation (potential integer overflow in languages with fixed integer sizes).

• How would you solve this problem if the input list were not missing any numbers but had a duplicate?
• Can you improve the space complexity of your solution?

• The input, n, is a positive integer greater than 0.
• Assume n is reasonably small to avoid integer overflow issues (e.g., n <= 10,000).

    def __init__(self, limit):

        self.limit = limit

        self.count = 0

        self.a, self.b = 0, 1

    def __iter__(self):

        return self

    def __next__(self):

        if self.count < self.limit:

            self.count += 1

            a, self.a, self.b = self.a, self.b, self.a + self.b

            return a

        else:

            raise StopIteration

# Usage example

fib_iterator = FibonacciIterator(10)

print([num for num in fib_iterator])

• Not properly handling the StopIteration exception, which is necessary for an iterator when the end of the sequence is reached.
• Confusing the roles of __iter__() and __next__() in the iterator protocol.
• Incorrectly initializing or updating the Fibonacci sequence, leading to incorrect sequence values.

• How can this iterator be modified to reset itself and start the sequence over?
• Can you implement the same functionality using a generator function?

• The list can contain up to 10,000 integers.
• Integer values can range from -10,000 to 10,000.

    if len(arr) > 1:

        mid = len(arr) // 2  # Finding the mid of the array

        L = arr[:mid]  # Dividing the array elements into 2 halves

        R = arr[mid:]

        merge_sort(L)  # Sorting the first half

        merge_sort(R)  # Sorting the second half

        i = j = k = 0

        # Copy data to temp arrays L[] and R[]

        while i < len(L) and j < len(R):

            if L[i] < R[j]:

                arr[k] = L[i]

                i += 1

            else:

                arr[k] = R[j]

                j += 1

            k += 1

        # Checking if any element was left

        while i < len(L):

            arr[k] = L[i]

            i += 1

            k += 1

        while j < len(R):

            arr[k] = R[j]

            j += 1

            k += 1

    return arr

# Example usage

print(merge_sort([12, 4, 5, 3, 8, 7]))

• Failing to implement the merge logic correctly, which can lead to incorrect sorting or infinite loops.
• Not handling edge cases, such as lists with a single element or empty lists.
• Incorrectly calculating the middle index or not correctly merging the divided lists.

• How would you modify this function to sort the list in descending order?
• Can you optimize the space complexity of your merge sort implementation?

• The decorator should be general-purpose and not specific to any function.
• Ensure the execution time is printed in seconds.

def sample_function(delay_time):

    time.sleep(delay_time)

def measure_execution_time(func):

    def wrapper(*args, **kwargs):

        start_time = time.time()

        result = func(*args, **kwargs)

        end_time = time.time()

        execution_time = end_time – start_time

        print(f”Function `{func.__name__}` executed in {execution_time:.4f} seconds.”)

        return result

    return wrapper

# Example usage

@measure_execution_time

def sample_function(delay_time):

    time.sleep(delay_time)

    return “Finished”

sample_function(1)

• Forgetting to return the result of the decorated function, which can alter the expected behavior of the function.
• Not using *args and **kwargs to allow decorated functions to accept any number of positional and keyword arguments.
• Inaccurately measuring the execution time by placing the time measurement code incorrectly.

• How can you modify the decorator to log the execution time to a file instead of printing it?
• Can you extend the decorator to include memory usage measurement?

• A list of strings to be concatenated.
• An optional delimiter string (default is a space).

• The list can contain any number of strings.
• Strings can include any character.

Delimiter: “, “

    return delimiter.join(string_list)

# Example usage

print(concatenate_strings([“Python”, “is”, “awesome”]))

print(concatenate_strings([“Python”, “is”, “awesome”], “, “))

• Forgetting to handle cases where the list is empty, which should return an empty string.
• Incorrectly implementing the concatenation logic, leading to missing delimiters or additional delimiters at the start or end of the resulting string.

• How would you modify the function to handle lists containing data types other than strings (e.g., integers or floats)?
• Can you implement a version of this function that recursively concatenates nested lists of strings?

• The operands can be any integer from -10,000 to 10,000.
• Division operations should handle division by zero and return a message indicating the error.
• Only consider operations involving two operands and a single operator.

5

    try:

        operands = expression.split(‘ ‘)

        operand1 = int(operands[0])

        operator = operands[1]

        operand2 = int(operands[2])

        if operator == ‘+’:

            return operand1 + operand2

        elif operator == ‘-‘:

            return operand1 – operand2

        elif operator == ‘*’:

            return operand1 * operand2

        elif operator == ‘/’:

            if operand2 == 0:

                return “Error: Division by zero”

            else:

                return operand1 / operand2

    except ValueError:

        return “Invalid input”

# Example usage

print(basic_calculator(“8 – 3”))

• Not handling division by zero, which can lead to runtime errors.
• Incorrectly parsing the input string, leading to incorrect operations or operands.
• Not accounting for invalid inputs, such as non-numeric values for operands.

• How would you extend this calculator to handle expressions with more than two operands and multiple operators?
• Can you implement error handling for unsupported operators or incorrect formatting?

• The list can have up to 1,000 elements.
• Numbers can range from -10,000 to 10,000.

    return sum(numbers)

# Example usage

print(sum_numbers([1, 2, 3.5, 4]))

• Forgetting to handle different data types in the list, such as integers and floats, though Python’s sum() naturally handles this.
• Implementing a manual sum calculation loop unnecessarily, which can be less efficient and more error-prone than using the built-in function.

• How would you modify this function to exclude negative numbers from the sum?
• Can you extend this function to also calculate the average of the numbers in the list?

• The IP address string contains only digits and dots.
• The length of the string will not exceed 15 characters.

    parts = ip_address.split(“.”)

    if len(parts) != 4:

        return False

    for item in parts:

        if not item.isdigit() or not 0 <= int(item) <= 255:

            return False

        if item != str(int(item)):  # Prevents leading zeros

            return False

    return True

# Example usage

print(is_valid_ip(“192.168.1.1”))

• Not checking for the exact count of four parts after splitting the IP address, leading to acceptance of invalid addresses.
• Failing to check for leading zeros in each decimal number.
• Incorrectly allowing values outside the 0-255 range.

• How would you modify this function to validate IPv6 addresses as well?
• Can you improve the function to provide detailed error messages indicating why an IP address is invalid?

• Each list can contain up to 1,000 integers.
• Integers in each list can range from -10,000 to 10,000.

List 2: 2,3,4,52,3,4,5

    set1 = set(list1)

    set2 = set(list2)

    return list(set1 & set2)

# Example usage

print(find_intersection([1, 2, 2, 3], [2, 3, 4, 5]))

• Returning a list with duplicate elements by not converting the lists to sets for the intersection operation.
• Incorrectly assuming the input lists are already sorted or do not contain duplicates.
• Forgetting to convert the resulting set back into a list before returning.

• How would you handle finding the intersection if the lists contain other data types, such as strings or floats?
• Can you modify the function to preserve the order of elements in the intersection based on the first list?

• The start of the range is at least 2, and the end of the range does not exceed 10,000.
• The start is less than or equal to the end of the range.

End: 30

    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

    return [n for n in range(start, end + 1) if is_prime(n)]

# Example usage

print(generate_primes(10, 30))

• Not considering the efficient way to check for primality, which can significantly increase runtime for larger numbers.
• Forgetting to include the end of the range as part of the range to check for prime numbers.
• Misimplementing the primality test, such as by not properly handling edge cases (e.g., 1 is not prime).

• How could you optimize the primality check for very large numbers?
• Can you modify the function to generate primes using the Sieve of Eratosthenes method for better efficiency?