54 Python Machine Learning Interview Questions with Solutions (Updated for 2025)

Python consistently ranks as one of the top programming languages for machine learning applications, with the majority of data scientists using it.

Given how complex machine learning concepts already are, the simplicity and clear syntax of Python and the associated libraries make it easier for you to focus on the implementations without getting bogged down by intricate theoretics.

The availability of ML-specific libraries, including NumPy, Pandas, Scikit-learn, Keras, and TensorFlow, accelerates development time by providing pre-built functions and algorithms.

Owing to their practicality and popularity, it’s critical for you, as a candidate, to be familiar with recurring Python machine-learning interview questions to develop critical thinking and demonstrate your impeccable coding skills during your next technical round.

In machine learning interviews, Python questions come up very often, along with algorithm questions and general machine learning and modeling questions.

Typically, basic Python interview questions for machine learning test your algorithmic coding ability and ask you to perform tasks like using pandas, writing machine learning algorithms from scratch, or answering basic Python questions related to machine learning.

These questions assess your fundamental knowledge of Python’s use in machine learning, as well as practical Python coding skills:

• Basic Python Machine Learning Questions - Basic questions test your knowledge of fundamental concepts in machine learning, as well as Python’s most basic uses in model building.

• Python Pandas Machine Learning Questions - Pandas is a data analysis library in Python. In machine learning, pandas are commonly used for manipulating data, cleaning, and data preparation.

• Machine Learning Algorithms From Scratch - These questions ask you to write classic algorithmics from scratch, typically without the use of Python packages.

The fundamental Python concepts mentioned in this section are the backbone of implementing, optimizing, and debugging machine learning models. For example, machine learning often involves working with large datasets, and proficiency in Python’s data structures might enable more efficient data storage, retrieval, and manipulation.

Basic Python Syntax and Data Structures

1. What is the difference between global and local scope?

Answer: Global variables are accessible throughout the entire program, while local variables are only accessible within the function or block where they are defined.

2. What is an iterator in Python?

Answer: An iterator is an object that implements the iterator protocol, consisting of the __iter__() and __next__() methods. Iterators allow you to traverse through all the elements in a collection (like lists and tuples).

3. What is the __init__() function in Python?

Answer: **The __init__() function is a special method called a constructor, which is automatically invoked when a new instance of a class is created. It initializes the object’s attributes.

4. How can you check if all characters in a string are alphanumeric?

Answer: You can use the isalnum() method, which returns True if all characters in the string are alphanumeric (letters and numbers) and there is at least one character.

5. How can you convert a string to an integer?

Answer: You can use the int() function:

pythonnum = "5"
convert = int(pythonnum)  # convert will be 5 as an integer

6. What is indentation in Python, and why is it important?

Answer: Indentation refers to the spaces at the beginning of a code line. In Python, indentation is crucial as it defines the blocks of code. Unlike other programming languages where indentation is for readability only, Python uses it to determine the grouping of statements.

7. What is the correct syntax to output the type of a variable or object in Python?

Answer:

    python print(type(x))

8. Which collection does not allow duplicate members?

Answer: A set does not allow duplicate members.

9. How can you copy a list in Python?

Answer: You can copy a list using:

list2 = list1.copy()  # or list2 = list(list1)

10. How do you return a range of characters from a string?

Answer: You can use slicing:

    pythonb = "Hello, World!"
    substring = b[0:5]  *# Output: 'Hello'*

Python Object-Oriented Programming Interview Questions

11. What are the key principles of OOP?

Answer: The four main principles of OOP are:

• Encapsulation: Bundling data and methods inside a class.
• Abstraction: Hiding implementation details and exposing only necessary functionality.
• Inheritance: Creating a new class based on an existing class to reuse code.
• Polymorphism: Allowing objects of different classes to be treated as instances of the same class through method overriding or overloading.

12. How do you define a class and create an object in Python?

Answer:

class Car:
    def __init__(self, brand, model):
        self.brand = brand
        self.model = model

    def display_info(self):
        return f"{self.brand} {self.model}"
# Creating an object
my_car = Car("Toyota", "Corolla")
print(my_car.display_info())  # Output: Toyota Corolla

13. What is the difference between class variables and instance variables?

Answer:

• Instance variables are unique to each object and defined using self.
• Class variables are shared among all instances and defined outside __init__.

Example:

class Employee:
    company = "TechCorp"  # Class variable

    def __init__(self, name):
        self.name = name  # Instance variable

emp1 = Employee("Alice")
emp2 = Employee("Bob")
print(emp1.company)  # TechCorp
print(emp2.company)  # TechCorp

14. How does Python support encapsulation?

Answer: Python uses private (__variable) and protected (_variable) attributes to restrict access to class members.

Example:

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

    def get_balance(self):
        return self.__balance  # Accessor method

account = BankAccount(1000)
print(account.get_balance())  # 1000
# print(account.__balance)  # AttributeError

15. What is method overriding?

Answer: A child class provides a new implementation for a method already defined in the parent class.

Example:

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

class Dog(Animal):
    def speak(self):
        return "Bark"

dog = Dog()
print(dog.speak())  # Output: Bark

16. What is method overloading? Does Python support it?

Answer: Python does not support traditional method overloading like Java, but we can achieve similar functionality using default arguments or *args.

Example:

class MathOperations:
    def add(self, a, b, c=0):  # Overloading using default parameter
        return a + b + c

math = MathOperations()
print(math.add(2, 3))     # 5
print(math.add(2, 3, 4))  # 9

17. What is the difference between @staticmethod, @classmethod, and instance methods?

Answer:

• Instance Method: Works on instance variables (self).
• Class Method (@classmethod): Works on class variables (cls).
• Static Method (@staticmethod): Doesn’t require self or cls.

Example:

class Example:
    class_variable = "ClassVar"

    def instance_method(self):
        return "Instance Method"

    @classmethod
    def class_method(cls):
        return cls.class_variable

    @staticmethod
    def static_method():
        return "Static Method"

obj = Example()
print(obj.instance_method())  # Instance Method
print(Example.class_method())  # ClassVar
print(Example.static_method())  # Static Method

18. What is multiple inheritance, and how does Python resolve conflicts?

Answer: Python supports multiple inheritance, and it resolves conflicts using the Method Resolution Order (MRO).

Example:

class A:
    def show(self):
        return "A"

class B:
    def show(self):
        return "B"

class C(A, B):  # Multiple Inheritance
    pass

obj = C()
print(obj.show())  # Output: A (MRO: C → A → B)

Use C.mro() to check the method resolution order.

19. What is a metaclass in Python?

Answer: A metaclass is a class of a class that defines how classes behave. The default metaclass in Python is type.

Example:

class Meta(type):
    def __new__(cls, name, bases, dct):
        dct["greet"] = lambda self: "Hello"
        return super().__new__(cls, name, bases, dct)

class MyClass(metaclass=Meta):
    pass

obj = MyClass()
print(obj.greet())  # Output: Hello

20. What are super() and __init__() used for in Python OOP?

Answer:

• super() is used to call methods from the parent class.
• __init__() is a constructor method executed when an object is created.

Example:

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

class Child(Parent):
    def __init__(self, name, age):
        super().__init__(name)  # Calling parent constructor
        self.age = age

child = Child("Alice", 10)
print(child.name, child.age)  # Output: Alice 10

Error Handling and Debugging Techniques

21. What are the different types of errors in Python?**

Answer: Python errors fall into three main categories:

• Syntax Errors: Occurs when the Python interpreter encounters invalid syntax.

  print("Hello"  # SyntaxError: missing closing parenthesis
  

  • Runtime Errors (Exceptions): Occur during program execution, such as division by zero or accessing an undefined variable. python print(10 / 0) # ZeroDivisionError

• Logical Errors: The program runs but produces incorrect results due to a flaw in logic.

22. How do you handle exceptions in Python?

Answer: Use try-except blocks to catch and handle exceptions.

try:
    x = 10 / 0
except ZeroDivisionError as e:
    print(f"Error: {e}")  # Output: Error: division by zero

You can also use finally to execute code regardless of an exception.

try:
    file = open("test.txt", "r")
except FileNotFoundError:
    print("File not found!")
finally:
    print("Execution completed.")

23. What is the difference between except Exception as e and except:?

Answer:

• except Exception as e: Catches most exceptions but excludes system-exiting errors like KeyboardInterrupt.
• except: Catches all exceptions, including system-exiting exceptions, which is not recommended.

Example:

try:
    x = 1 / 0
except Exception as e:
    print(f"Caught an exception: {e}")

24. How do you raise exceptions in Python?

Answer: Use raise to manually trigger an exception.

def check_age(age):
    if age < 18:
        raise ValueError("Age must be 18 or above.")
    return "Access granted"

print(check_age(15))  # Raises ValueError

25. What is the purpose of assert in Python?

Answer: assert is used for debugging by checking conditions. If the condition is False, an AssertionError is raised.

x = 10
assert x > 0  # No error
assert x < 0, "x must be negative"  # Raises AssertionError

26. How do you log errors instead of printing them?

Answer: Use the logging module instead of print() for better error tracking.

import logging

logging.basicConfig(filename="errors.log", level=logging.ERROR)

try:
    1 / 0
except ZeroDivisionError as e:
    logging.error(f"Error: {e}")

27. How can you debug Python code?

Answer: Common debugging techniques include:

• Using print() statements to check variable values.

• Using pdb (Python Debugger) to step through code.

  import pdb
  pdb.set_trace()  # Set a breakpoint
  

  • Using IDE debuggers (e.g., PyCharm, VS Code).

    28. What is traceback in Python?

    Answer: The traceback module provides detailed error logs.

    import traceback
    try:
    1 / 0
    except ZeroDivisionError:
    print(traceback.format_exc())  # Prints the full stack trace
    

29. What is the difference between try-except and try-finally?

Answer:

• try-except handles errors.
• try-finally ensures the final block always executes, even if an error occurs.

Example:

try:
    file = open("test.txt", "r")
finally:
    print("Closing resources")  # Runs whether or not an error occurs

30. How do you handle multiple exceptions?

Answer: Use multiple except blocks or tuple unpacking.

try:
    x = int("abc")
except (ValueError, TypeError) as e:
    print(f"Error occurred: {e}")

Data cleaning and preprocessing are critical for machine learning interviews because they directly impact model performance, ensuring clean, consistent, and actionable data. Here are some of the common preprocessing machine learning interview questions that you must be aware of:

Handling Missing Values

31. What pre-processing techniques are you most familiar with in Python?

Pre-processing techniques are used to prepare data in Python, and there are many different techniques you can use. Some common ones you might talk about include:

• Normalization - In Python, normalization is done by adjusting the values in the feature vector.
• Dummy variables - Dummy variables is a pandas technique in which an indicator variable (0 or 1) indicates whether a categorical variable can take a specific value or not.
• Checking for outliers - There are many methods for checking for outliers, but some of the most common are univariate, multivariate, and Minkowski errors.

32. What are some ways to handle missing data in Python?

There are two common strategies. Omission and Imputation. Omission refers to removing rows or columns with missing values, while imputation refers to adding values to fill in missing observations.

There are some helpful modules in Scikit-learn that you can use for imputation. One is SimpleImputer, which fills missing values with a zero, or the median, mean, or mode, while IterativeImputer models each feature with missing values as a function of other features.

33. What are some ways to handle an imbalanced dataset?

An imbalanced dataset has skewed class proportions in a classification problem. Some of the ways to handle this include:

• Collecting more data
• Resampling data to correct oversampling or other imbalances
• Generating samples with the Synthetic Minority Oversampling Technique (or SMOTE)
• Testing various algorithms that include resampling in their design, like bagging or boosting

Data Transformation Techniques

34. What is regression? How would you implement regression in Python?

Regression is a supervised machine learning technique primarily used to find correlations between variables and make predictions for the dependent variable. Regression algorithms are generally used for predictions, building forecasts, time-series models, or identifying causation.

Most of these algorithms, like linear regression or logistic regression, can be implemented with Scikit-learn in Python.

35. How do you split training and testing datasets in Python?

You can do this in Python with the Scikit-learn module using the train_test_split function. This function splits arrays or matrices into random training and testing datasets.

Generally, about 75% of the data will go to the training dataset; however, you will likely test different iterations.

36. What are common hyperparameter tuning methods in Scikit-learn?

The two most commonly used methods are grid search and random search. Grid search is the process of defining a search space grid, and after you’ve selected hyperparameter values, grid search searches for the optimal combination.

Random search uses a wide range of hyperparam values and randomly iterates combinations. With random search, you specify the number of iterations (which you do not do in grid search).

Outlier Detection and Treatment

37. What parameters are most important for tree-based learners?

Some of the most common you could mention include:

• max_depth - This is the maximum depth per tree. This adds complexity but benefits from boosting performance.
• learning_rate - This determines step size at each iteration. A lower learning rate slows computation but increases the chance of reaching a model closer to the optimum.
• n_estimators - This refers to the number of trees in an ensemble or the number of boosting rounds.
• subsample - This is the fraction of observations to be sampled for each tree.

38. You are given a string that represents some floating-point number. Write a function, digit_accumulator, that returns the sum of every digit in the string.

To sum every digit in a string, the function identifies numerical characters using Python’s isdigit() method, converts them to integers, and accumulates their total. This approach ensures that non-digit characters are ignored, providing a simple and efficient way to handle mixed-content strings.

39. What are brute force algorithms? Provide an example.

Brute force algorithms try all possibilities to find a solution. For example, if you were trying to solve a 3-digit pin code, brute force would require you to test all possible combinations from 000 to 999.

One common brute force algorithm is linear search, which traverses an array to check for a match. One disadvantage of brute force algorithms is that they can be inefficient, and it’s usually more difficult to improve the algorithm’s performance within the framework.

From fraud detection to building recommendation systems in retail, machine learning concepts are critical for almost every modern pattern recognition technology. Let’s try to go through a couple of them to understand how they might challenge you in the interviews.

Coding Challenges Related to Algorithms

40. Find the First Non-Repeating Character in a String

• Use a dictionary (collections.Counter) to count character occurrences.
• Iterate through the string and return the first character with a count of 1.

from collections import Counter

def first_non_repeating(s):
    char_count = Counter(s)
    for char in s:
        if char_count[char] == 1:
            return char
    return None  # No unique character found

41. Given two sorted lists, write a function to merge them into one sorted list.

• Use two pointers to traverse both lists while merging them into a new list.
• Append remaining elements after traversal.

def merge_sorted_lists(l1, l2):
    i, j = 0, 0
    merged = []
    while i < len(l1) and j < len(l2):
        if l1[i] < l2[j]:
            merged.append(l1[i])
            i += 1
        else:
            merged.append(l2[j])
            j += 1
    return merged + l1[i:] + l2[j:]

42. Write a function that determines if two rectangles overlap. The rectangles are represented by their corner coordinates.

Two rectangles overlap if one is not entirely to the left, right, above, or below the other.

def is_overlap(rect1, rect2):
    (x1, y1, x2, y2) = rect1
    (a1, b1, a2, b2) = rect2
    return not (x2 <= a1 or a2 <= x1 or y2 <= b1 or b2 <= y1)

43. Given a string str, write a function perm_palindrome to determine whether there exists a permutation of str that is a palindrome.

A string can be rearranged into a palindrome if at most one character has an odd frequency.

from collections import Counter

def perm_palindrome(s):
    char_count = Counter(s)
    odd_count = sum(1 for count in char_count.values() if count % 2 != 0)
    return odd_count <= 1

44. You have an array of integers, nums of length n spanning 0 to n with one missing. Write a function missing_number that returns the missing number in the array.

• Use the sum formula for the first n natural numbers: Expected Sum=n(n+1)/2
• Subtract the actual sum from the expected sum to find the missing number.

def missing_number(nums):
    n = len(nums)
    expected_sum = n * (n + 1) // 2
    actual_sum = sum(nums)
    return expected_sum - actual_sum

45. Write a function median_rainfall to find the median amount of rainfall for the days on which it rained.

More context. You’re given a dataframe, df_rain, containing rainfall data. The dataframe has two columns: day of the week and rainfall in inches.

With this question, there are two key steps:

• Remove all days with no rain.
• Then, get the median of the dataframe.

46. Write a function to impute the median price of the selected California cheeses in place of the missing values.

This question requires you to use two built-in Pandas methods:

dataframe.column.median()

This method returns the median of a column in a dataframe.

dataframe.column.fillna(`value`)

This method applies value to all nan values in a given column.

47. Write a function to return a new list where all None values are replaced with the most recent non-None value in the list.

This easy Python question deals with pre-preprocessing. In it, you’re provided with a sorted list of positive integers with some entries being None.

Here’s the solution code for this problem:

def fill_none(input_list):
    prev_value = 0

    result = []
    for value in values:
        if value is None:
            result.append(prev_value)
        else:
            result.append(value)
            prev_value = value

    return result

48. Write a function named grades_colors to select only the rows where the student’s favorite color is green or red and their grade is above 90.

This question requires us to filter a data frame by two conditions: first, the student’s grade, and second, their favorite color.

Start by filtering by grade since it’s a bit simpler than filtering by strings. We can filter columns in pandas by setting our data frame equal to itself with the filter in place.

In this case:

df_students = df_students[df_students["grade"] > 90]

49. Calculate the t-value for the mean of ‘var’ against a null hypothesis that μ = μ_0.

This Python question has been asked in Facebook machine-learning interviews.

More context. You are given a dataframe with a single column, var. You do not have to calculate the p-value of the test or run the test.

Problems that ask you to write an algorithm from scratch are increasingly common in machine learning and computer vision interviews. The algorithms you are asked to write are like what you’d see on Scikit-learn.

This type of question evaluates your understanding of algorithms and your ability to implement them correctly and efficiently. More importantly, it assesses your grasp of machine learning concepts by requiring you to build algorithms from scratch—so simply calling rfr = RandomForest(x, y) won’t cut it.

While this may seem daunting, keep in mind that:

1. Interviewers aren’t looking for the most optimized version of an algorithm. Instead, they expect a straightforward, “vanilla” implementation that demonstrates your fundamental understanding.
2. You don’t need to master every algorithm. Only a handful are practical for an hour-long interview, as many are too complex to break down within that timeframe.

These are the algorithms you should study for machine learning Python interviews:

• K-nearest neighbors
• Decision tree
• Linear regression
• Logistic regression
• K-means clustering
• Gradient descent

You can practice with these sample machine learning algorithms from scratch interview questions:

50. Build a K-nearest neighbors classification model from scratch with the following conditions:

• Use Euclidean distance (the “2 norm”) as your closeness metric.
• Your function should be able to handle data frames of arbitrarily many rows and columns.
• If there is a tie in the class of the k nearest neighbors, rerun the search using k-1 neighbors instead.
• You may use pandas and numpy but NOT scikit-learn.

Example Output:

def kNN(k,data,new_point) -> 2

51. Build a random forest model from scratch.

The model should have these conditions:

• The model takes as input a dataframe df and an array new_point with a length equal to the number of fields in the df.
• All values of df and new_point are 0 or 1, i.e., all fields are dummy variables, and only two classes exist.
• Rather than randomly deciding what subspace of the data each tree in the forest will use like usual, make your forest out of decision trees that go through every permutation of the value columns of the data frame and split the data according to the value seen in new_point for that column.
• Return the majority vote on the class of new_point.
• You may use pandas and NumPy, but NOT scikit-learn.

52. Build a Logistic Regression from scratch.

The model should have these conditions:

• Return the parameters of the regression
• Do not include an intercept term
• Use basic gradient descent (with Newton’s method) as your optimization method and the log-likelihood as your loss function.
• Don’t include a penalty term.
• You may use Numpy and Pandas but NOT sci-kit-learn

53. Build a K-Means from scratch.

The model should have these conditions:

• A two-dimensional NumPy array data_points that is an arbitrary number of data points (rows) n and an arbitrary number of columns m.
• Number of k clusters k.
• The initial centroids value of the data points at each cluster initial_centroids.
• Return a list of the cluster of each point in the original list data_points with the same order (as an integer).

Example:

After clustering the points with two clusters, the points will be clustered as follows.

Note: There could be an infinite number of separating lines in this example.

54. Level Of Rain Water In 2D Terrain

Given a 2D terrain represented by an array of non-negative integers, where each integer represents the height of a terrain level at that index, implement an algorithm to calculate the total amount of rainwater that can be trapped in this terrain. Rainwater can only be trapped between two terrain levels with higher heights, and the trapped water cannot flow out through the edges.

The algorithm should have an optimal time complexity of O(n) and a space complexity of O(n). Provide a detailed explanation of the algorithm and its implementation in Python.

Check out these other useful links below:

1. Machine Learning Interview Questions

2. Google Machine Learning Interview Question

3. Introduction to Machine Learning: Machine Learning Interview Questions

4. Machine Learning Algorithm Interview Questions