Top 50+ Python Interview Questions and Answers

Example

 numbers = [3, 5, 2, 8, 1]
 max_number = max(numbers)
 print("Maximum number is:", max_number)

Output

Maximum number is: 8

Explanation

• The max() function returns the largest value from a list, simplifying the operation of finding the greatest number in a collection.
• This can be applied to numeric and string lists, returning the highest value according to the natural ordering.

Q 23. Write a program to remove duplicates from a list

Example

numbers = [1, 2, 2, 3, 4, 4, 5]
unique_numbers = list(set(numbers))
print("List after removing duplicates:", unique_numbers)

Output

List after removing duplicates: [1, 2, 3, 4, 5]

Explanation

• The list numbers contain some duplicate values, like 2 and 4, which appear more than once.
• By converting the list to a set and back to a list, all duplicates are removed, and unique values remain.

OOP's Interview Questions and Answers in Python

In Python Interview Questions, OOP questions test your understanding of object-oriented concepts like classes, objects, inheritance, and polymorphism.

Q 24. What is a class and an object in Python?

Let's understand the class and objects in Python in easier wordings:

• A class in Python is like a design or template that tells Python what kind of data and actions an object should have. It helps you create your own type of data structure to group related data and functions together in one place.
• An object in Python is something you create using a class. It is a real example that holds actual data and can do things using the class design. You can create many objects from one class, and each one will have its data.

Example

# Define a class
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age    
    def greet(self):
        return f"Hello, my name is {self.name} and I am {self.age} years old."
# Create an object (instance) of the class
person1 = Person("Alice", 30)
print(person1.greet())

Output

Hello, my name is Alice and I am 30 years old.

Explanation

• A class Person is created with a constructor to store the name and age and a method greet() to return a greeting message.
• An object person1 is made using the class, and calling greet() prints a message using the object’s data.

Q 25. What is inheritance in Python?

Inheritance in Python means one class (called the child class) can use the features (like variables and methods) of another class (called the parent class). It helps you reuse code and build relationships between classes, just like a child inherits qualities from parents in real life.

Importance of Inheritance

• It helps you reuse code, so you don’t need to write the same code again in different classes.
• It makes your program easier to manage and organize, especially when working with similar classes.
• It allows you to extend existing features by adding new ones without changing the original class.

Example

 # Parent class
 class Animal:
    def speak(self):
        return "Animal speaks"
 # Child class inheriting from Animal
 class Dog(Animal):
    def speak(self):
        return "Dog barks"
 # Create an object of the Dog class
 dog = Dog()
 print(dog.speak())

Output

Dog barks

Explanation

• Inheritance allows the `Dog` class to inherit the methods and attributes from the `Animal` class.
• The `Dog` class overrides the `speak()` method to provide its own implementation.

Q 26. What is polymorphism in Python?

Example

 # Parent class
 class Shape:
    def area(self):
        return "Area of the shape"
 # Child class
 class Circle(Shape):
    def area(self):
        return "Area of the circle"
 # Child class
 class Square(Shape):
    def area(self):
        return "Area of the square"
 # Create objects
 circle = Circle()
 square = Square()
 print(circle.area())
 print(square.area())

Output

 Area of the circle
 Area of the square

Explanation

• Polymorphism allows us to use the same method name (`area()`) in different classes (e.g., `Circle` and `Square`) to perform different actions.
• Each class defines its own version of the `area()` method.

Q 27. What is encapsulation in Python?

Example

 # Class with encapsulation
 class Account:
     def __init__(self, owner, balance):
         self.owner = owner
         self.__balance = balance  # Private attribute
    
     def deposit(self, amount):
         self.__balance += amount
    
     def withdraw(self, amount):
        if amount <= self.__balance:
            self.__balance -= amount
        else:
            print("Insufficient balance")    
    def get_balance(self):
        return self.__balance
 # Create object
 account = Account("Alice", 1000)
 account.deposit(500)
 account.withdraw(200)
 print("Balance:", account.get_balance())

Output

 Balance: 1300

Explanation

• Encapsulation allows restricting access to the balance (`__balance`) attribute by making it private.
• Methods like `deposit(),` `withdraw(),` and `get_balance()` are used to interact with the private attribute, promoting controlled access.

Q 28. What is the difference between `__str__` and `__repr__` in Python?

The `__str__` method defines a user-friendly string representation of an object, while `__repr__` defines an unambiguous string representation that can be used to recreate the object.

Example

 # Class with __str__ and __repr__
 class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age    
    def __str__(self):
        return f"Person: {self.name}, {self.age} years old"    
    def __repr__(self):
        return f"Person('{self.name}', {self.age})"
 # Create object
 person = Person("Alice", 30)
 print(str(person))  # User-friendly output
 print(repr(person))  # Unambiguous output

Output

Person: Alice, 30 years old
Person('Alice', 30)

Explanation

• `__str__` is used to define a string representation that is easy for humans to read, usually printed to the console.
• `__repr__` provides a more detailed, unambiguous string representation, often used for debugging or logging purposes.

Python Pandas Interview Questions and Answers

Python Interview Questions and Answers for Pandas are commonly asked to check your skills in handling and analyzing data using the Pandas library. These Python Pandas Interview Questions and Answers help you prepare for topics like data frames, data cleaning, and data manipulation in an easy way.

Q 29. What is Pandas, and how is it used in Python?

Pandas is an open-source data analysis and manipulation library in Python. It provides data structures like Series and DataFrame that make it easy to handle and analyze structured data.

Example

 # Import pandas
 import pandas as pd
 # Create a DataFrame
 data = {'Name': ['Alice', 'Bob', 'Charlie'], 'Age': [25, 30, 35]}
 df = pd.DataFrame(data)
 # Display DataFrame
 print(df)

Output

   Name  Age
 0  Alice   25
 1    Bob   30
 2 Charlie   35

Explanation

• Pandas are used for data manipulation and analysis. It provides powerful data structures such as `DataFrame` and `Series`.
• In the example, a `DataFrame` is created from a dictionary and displayed using `print()`.

Q 30. How do you handle missing data in a Pandas DataFrame?

In Pandas, missing data in a DataFrame can be handled by either removing it using dropna() or filling it using fillna(). You can also use functions like mean() or median() to smartly replace missing values and keep your data clean for analysis.

Example

 import pandas as pd
 # Create DataFrame with missing values
 data = {'Name': ['Alice', 'Bob', None], 'Age': [25, None, 35]}
 df = pd.DataFrame(data)
 # Check for missing values
 print(df.isna())
 # Fill missing values
 df_filled = df.fillna({"Name": "Unknown", "Age": df["Age"].mean()})
 print(df_filled)

Output

    Name   Age
 0  False  False
 1  False   True
 2   True  False

       Name  Age
 0    Alice   25.0
 1      Bob   30.0
 2  Unknown   35.0

Explanation

• The `isna()` function is used to detect missing values in a DataFrame. It returns a DataFrame of Boolean values indicating the presence of missing data.
• In the example, `fillna()` is used to replace missing values in the `Name` column with "Unknown" and in the `Age` column with the mean value.

Q 31. How do you filter rows based on conditions in a Pandas DataFrame?

You can filter rows in a DataFrame by applying conditions directly. Use boolean indexing to select rows where conditions are met.

Example

 import pandas as pd
 # Create DataFrame
 data = {'Name': ['Alice', 'Bob', 'Charlie'], 'Age': [25, 30, 35]}
 df = pd.DataFrame(data)

 # Filter rows where Age is greater than 30
 filtered_df = df[df['Age'] > 30]
 print(filtered_df)

Output

   Name  Age
 2  Charlie   35

Explanation

• A DataFrame is created using a dictionary that holds names and ages of three people.
• The code filters and prints only the rows where the age is greater than 30 using a condition on the 'Age' column.

Q 32. How do you merge two Pandas DataFrames?

Pandas provides the `merge()` function to combine two DataFrames based on a common column or index. It is similar to SQL join operations.

Example

import pandas as pd
# DataFrames to merge
df1 = pd.DataFrame({'ID': [1, 2, 3], 'Name': ['Alice', 'Bob', 'Charlie']})
df2 = pd.DataFrame({'ID': [1, 2, 4], 'Age': [25, 30, 35]})
# Merge DataFrames on 'ID'
merged_df = pd.merge(df1, df2, on='ID', how='inner')
print(merged_df)

Output

   ID    Name    Age
0   1    Alice   25
1   2    Bob     30

Explanation

• The `merge()` function combines `df1` and `df2` based on the common column `ID`.
• The `how='inner'` argument specifies that only rows with matching `ID` values in both DataFrames will be included in the result.

Q 33. How do you group data in Pandas?

Pandas provides the `groupby()` function to group data based on one or more columns and apply aggregation functions (e.g., `sum()`, `mean()`, `count()`) to the groups.

Example

import pandas as pd
# Create DataFrame
data = {'Category': ['A', 'B', 'A', 'B', 'A'],
        'Value': [10, 20, 30, 40, 50]}
df = pd.DataFrame(data)
# Group by 'Category' and calculate the sum of 'Value'
grouped_df = df.groupby('Category')['Value'].sum()
print(grouped_df)

Output

Category
A    90
B    60
Name: Value, dtype: int64

Explanation

• The `groupby()` function is used to group data by a specific column (in this case, `Category`), and then the aggregation function `sum()` is applied to the `Value` column.
• This allows you to analyze and summarize data based on categorical groupings.

Python Selenium Interview Questions and Answers

Python Selenium Interview Questions and Answers are commonly asked to test your skills in automating web browsers using Selenium with Python. These Python Interview Questions focus on real-time web testing tasks, and practicing such Python Interview Questions helps you prepare better for automation roles.

Q 34. What is Selenium, and how does it work with Python?

Selenium is an open-source tool for automating web browsers. It allows you to write Python scripts to control a browser's actions, such as navigating, clicking, and inputting data.

Example

 # Import the necessary modules
 from selenium import webdriver
 # Create a new instance of the Firefox WebDriver
 driver = webdriver.Firefox()
 # Open a website
 driver.get("https://www.example.com")
 # Close the browser
 driver.quit()

Output

# The browser window will open with the URL "https://www.example.com" and then close.

Explanation

• Selenium allows interaction with web pages using Python by controlling web browsers like Chrome, Firefox, etc.
• The example demonstrates opening a URL in Firefox and then closing the browser using `quit()`.

Q 35. What are WebDriver and WebElement in Selenium?

WebDriver is the core component of Selenium that controls the web browser. WebElement represents a single HTML element on the web page, which can be interacted with using various methods like `click()`, `send_keys()`, and `get_attribute()`.

Example

from selenium import webdriver
# Create an instance of the WebDriver
driver = webdriver.Chrome()
# Open a webpage
driver.get("https://www.google.com")
# Find the search input box (WebElement) and type a query
search_box = driver.find_element("name", "q")
search_box.send_keys("Selenium Python")
# Close the browser
driver.quit()

Output

# The Google search page will open, and the search term "Selenium Python" will be entered into the search box.

Explanation

• The WebDriver controls the browser, while WebElements represent individual HTML elements on the page (like the search box).
• The example demonstrates interacting with a WebElement (`q` input box) by sending a search term using the `send_keys()` method.

Q 36. How do you handle alerts in Selenium?

Selenium provides a way to handle browser alerts using the `Alert` interface. You can accept, dismiss, or retrieve the text of an alert using methods like `accept()`, `dismiss()`, and `text`.

Example

from selenium import webdriver
from selenium.webdriver.common.alert import Alert
# Open a webpage that triggers an alert
driver = webdriver.Chrome()
driver.get("https://www.w3schools.com/js/tryit.asp?filename=tryjs_alert")
# Switch to the iframe where the button is located
driver.switch_to.frame("iframeResult")
# Click the button to trigger the alert
driver.find_element("xpath", "/html/body/button").click()
# Switch to the alert and accept it
alert = Alert(driver)
alert.accept()
# Close the browser
driver.quit()

Output

# The alert will be accepted and the browser will close.

Explanation

• In this example, an alert is triggered by clicking a button, and we use the `Alert` class to interact with it.
• The `accept()` method is used to close the alert.

Q 37. How do you take a screenshot using Selenium in Python?

You can take a screenshot in Selenium using the `get_screenshot_as_file()` method, which saves the screenshot as an image file.

Example

 from selenium import webdriver
 # Open a webpage
 driver = webdriver.Chrome()
 driver.get("https://www.google.com")
 # Take a screenshot and save it to a file
 driver.get_screenshot_as_file("screenshot.png")
 # Close the browser
 driver.quit()

Output

# A screenshot of the Google homepage will be saved as "screenshot.png" in the current working directory.

Explanation

• The `get_screenshot_as_file()` method captures the current state of the browser and saves it as an image file.
• In this example, a screenshot of the Google homepage is saved as "screenshot.png".

Q 38. How do you locate elements in Selenium?

Selenium provides several ways to locate elements on a webpage, including by ID, name, class, XPath, and CSS selectors. These methods are used by functions like `find_element()` and `find_elements()`.

Example

 from selenium import webdriver
 # Open a webpage
 driver = webdriver.Chrome()
 driver.get("https://www.google.com")
 # Locate the search input box using its name attribute
 search_box = driver.find_element("name", "q")
 search_box.send_keys("Selenium Python")
 # Close the browser
 driver.quit()

Output

 # The Google search page will open, and the search term "Selenium Python" will be entered into the search box.

Explanation

• You can locate elements using various methods such as ID, name, class, XPath, and CSS selectors.
• In this example, `find_element()` is used to locate the search box by its `name` attribute (`q`).

Python Automation Interview Questions and Answers

Python Automation Interview Questions and Answers test your ability to automate tasks like web testing, file handling, and scripts using Python. These Python Interview Questions are helpful in checking how well you can write clean and efficient automation code.

Q 39. What is Python automation, and how can it be implemented?

Python automation refers to using Python scripts to perform repetitive tasks and automate manual processes. It can be implemented using libraries such as Selenium for web automation, `os` and `shutil` for file system automation, or `pyautogui` for GUI automation.

Example

import os
# Example: Renaming all files in a directory
directory = "path/to/your/directory"
for filename in os.listdir(directory):
    if filename.endswith(".txt"):
        new_name = filename.replace(".txt", "_renamed.txt")
        os.rename(os.path.join(directory, filename), os.path.join(directory, new_name))

Output

 # All `.txt` files in the specified directory will be renamed to have "_renamed" in their filenames.

Explanation

• Python automation can be used to automate tasks such as renaming files, sending emails, or web scraping.
• In the example, we use the `os` library to rename `.txt` files in a directory.

Q 40. How can you automate sending emails using Python?

You can automate sending emails in Python using the `smtplib` library to connect to an SMTP server, compose an email, and send it programmatically.

Example

 import smtplib
 from email.mime.text import MIMEText
 from email.mime.multipart import MIMEMultipart
 # Set up the server
 server = smtplib.SMTP("smtp.gmail.com", 587)
 server.starttls()
 server.login("your_email@gmail.com", "your_password")
 # Compose the email
 message = MIMEMultipart()
 message["From"] = "your_email@gmail.com"
 message["To"] = "recipient_email@gmail.com"
 message["Subject"] = "Test Email"
 body = "This is an automated email."
 message.attach(MIMEText(body, "plain"))
 # Send the email
 server.sendmail("your_email@gmail.com", "recipient_email@gmail.com", message.as_string())
 server.quit()

Output

 # The email will be sent to the recipient's inbox with the subject "Test Email" and body "This is an automated email."

Explanation

• In this example, we use the `smtplib` library to connect to Gmail's SMTP server, compose an email, and send it.
• You'll need to replace the placeholders with actual email and password details.

Q 41. How can you schedule tasks to run at a specific time in Python?

You can schedule tasks in Python using libraries like `schedule` or `APScheduler` to run Python functions at specific times or intervals.

Example

 import schedule
 import time
 # Define a task
 def job():
     print("Running scheduled task...")
 # Schedule the task to run every 10 seconds
 schedule.every(10).seconds.do(job)

 # Keep the script running to execute the task
 while True:
    schedule.run_pending()
    time.sleep(1)

Output

# The script will print "Running scheduled task..." every 10 seconds.

Explanation

• The `schedule` library allows you to schedule a Python function to run at specified intervals.
• In this example, the task is scheduled to run every 10 seconds and will keep running as long as the script is active.

Q 42. What are some best practices for writing Python automation scripts?

Some best practices for writing Python automation scripts include: - Keeping scripts modular by writing reusable functions. - Using exception handling to catch and manage errors. - Implementing logging to track script execution and errors. - Avoid hardcoded values and use configuration files for flexibility. - Ensuring that the script can handle edge cases and unexpected situations.

Example

 import logging
 # Configure logging
 logging.basicConfig(filename="automation.log", level=logging.INFO)
 def perform_task(task):
     try:
         logging.info(f"Performing task: {task}")
         # Task code here
         # Simulate task execution
         if task == "fail":
             raise Exception("Task failed")
        logging.info(f"Task {task} completed successfully")
     except Exception as e:
         logging.error(f"Error performing task {task}: {e}")

 # Example usage
 perform_task("task_1")
 perform_task("fail")

Output

 # The log file will record:
 # INFO:root:Performing task: task_1
 # INFO:root:Task task_1 completed successfully
 # ERROR:root:Error performing task fail: Task failed

Explanation

• In this example, we configure logging to capture task progress and errors.
• Exception handling (`try-except`) ensures that errors during task execution are logged properly.

Q 43. How do you interact with APIs in Python for automation?

You can interact with APIs in Python using the `requests` library to send HTTP requests and retrieve or send data to external systems for automation tasks.

Example

 import requests
 # Make a GET request to a public API
 response = requests.get("https://jsonplaceholder.typicode.com/posts")
  # Check if the request was successful
 if response.status_code == 200:
     data = response.json()  # Parse JSON response
     print(data[:5])  # Print first 5 posts
 else:
     print("Failed to retrieve data.")

Output

# A list of the first 5 posts from the JSONPlaceholder API will be printed.

Explanation

• The `requests` library is used to send HTTP requests (GET, POST, etc.) to APIs.
• In this example, we retrieve posts from a public API (`jsonplaceholder`) and print the first 5 posts in the response.

Python Data Science Interview Questions and Answers

Python Data Science Interview Questions and Answers test your ability to automate tasks like web testing, file handling, and scripts using Python. These Python Interview Questions are helpful in checking how well you can write clean and efficient automation code.

Q 44. What is the difference between a list and a tuple in Python?

A list is mutable, meaning it can be changed after creation, whereas a tuple is immutable and cannot be modified after it is created.

Example

 # List (Mutable)
 my_list = [1, 2, 3]
 my_list[0] = 10  # Changing the first element is allowed
 print("List after modification:", my_list)
 # Tuple (Immutable)
 my_tuple = (1, 2, 3)
 try:
     my_tuple[0] = 10  # Attempting to modify will raise an error
 except TypeError as e:
     print("Error:", e)
 print("Tuple remains unchanged:", my_tuple)

Output

 List after modification: [10, 2, 3]
 Error: 'tuple' object does not support item assignment
 Tuple remains unchanged: (1, 2, 3)

Explanation

• Lists can be modified (mutable), but tuples are immutable and cannot be changed after creation.

Q 45. What is NumPy, and what are its main benefits in data science?

NumPy is a powerful library for numerical computing in Python. It provides support for large, multi-dimensional arrays and matrices and a large collection of mathematical functions to operate on them.

Example 

 import numpy as np
 # Create a NumPy array
 arr = np.array([1, 2, 3, 4, 5])
 print("NumPy Array:", arr)
 # Perform a mathematical operation
 arr_squared = arr ** 2
 print("Squared NumPy Array:", arr_squared)

Output

 NumPy Array: [1 2 3 4 5]
 Squared NumPy Array: [ 1  4  9 16 25]

Explanation

• NumPy provides efficient storage and operations for large data sets, allowing for operations such as element-wise math operations on arrays.

Q 46. What is Pandas, and how do you use it to manipulate data?

Pandas is a Python library used for data manipulation and analysis. It provides data structures like `DataFrame` and `Series` for working with structured data. It is widely used for cleaning, transforming, and analyzing data.

Example

 import pandas as pd
 # Create a DataFrame
 data = {'Name': ['Alice', 'Bob', 'Charlie'], 'Age': [24, 27, 22]}
 df = pd.DataFrame(data)
 # Print DataFrame
 print("DataFrame:")
 print(df)
 # Filter rows where Age is greater than 23
 filtered_df = df[df['Age'] > 23]
 print("\nFiltered DataFrame:")
 print(filtered_df)

Output

 DataFrame:
      Name  Age
 0    Alice   24
 1      Bob   27
 2  Charlie   22

 Filtered DataFrame:
     Name  Age
 0  Alice   24
 1    Bob   27

Explanation

• Pandas provides `DataFrame` objects, which allow you to filter, aggregate, and manipulate data efficiently.
• The example demonstrates how to filter rows from a DataFrame based on a condition (Age > 23).

Q 47. Explain the concept of a "for loop" in Python with an example.

A `for loop` in Python is used to iterate over a sequence (like a list, tuple, or string) and execute a block of code multiple times.

Example

 # Example of a for loop iterating over a list
 numbers = [1, 2, 3, 4, 5]
 for num in numbers:
     print(f"Square of {num}: {num ** 2}")

Output

 Square of 1: 1
 Square of 2: 4
 Square of 3: 9
 Square of 4: 16
 Square of 5: 25

Explanation

• The `for loop` iterates over each element in the list, and the code inside the loop is executed for each element.

Q 48. What is the difference between `loc[]` and `iloc[]` in Pandas?

`loc[]` is used for label-based indexing (i.e., selecting data by the row/column labels). - `iloc[]` is used for position-based indexing (i.e., selecting data by the row/column positions).

Example

 import pandas as pd
 data = {'Name': ['Alice', 'Bob', 'Charlie'], 'Age': [24, 27, 22]}
 df = pd.DataFrame(data)
 # Using loc[] to select by label
 print("Using loc[]:\n", df.loc[0])  # Selecting the first row by label
 # Using iloc[] to select by index
 print("\nUsing iloc[]:\n", df.iloc[0])  # Selecting the first row by index

Output

  Using loc[]:
  Name    Alice
  Age        24
  Name: 0, dtype: object

 Using iloc[]:
  Name    Alice
  Age        24
  Name: 0, dtype: object

Explanation

• `loc[]` is used for label-based indexing, whereas `iloc[]` is used for position-based indexing.
• In the example, both `loc[]` and `iloc[]` return the same result because we're selecting the first row (position 0) in both cases.

Q 49. What is a DataFrame in Pandas?

A `DataFrame` is a 2-dimensional labeled data structure in Pandas, similar to a table or spreadsheet, where data is organized into rows and columns.

Example

 import pandas as pd
 # Create a DataFrame
  data = {'City': ['New York', 'Los Angeles', 'Chicago'], 'Population': [8419600, 3980400, 2716000]}
 df = pd.DataFrame(data)
 print("DataFrame:")
 print(df)

Output

DataFrame:
          City  Population
0     New York     8419600
1  Los Angeles     3980400
2      Chicago     2716000

Explanation

• A `DataFrame` in Pandas is a 2-dimensional table that holds data in rows and columns, making it easy to manipulate and analyze data.

Q 50. How would you handle missing data in a Pandas DataFrame?

Missing data in Pandas can be handled using `dropna()`, `fillna()`, or by imputing values based on other rows/columns.

Example

 import pandas as pd
 import numpy as np
 # Create a DataFrame with missing values
 data = {'Name': ['Alice', 'Bob', np.nan], 'Age': [24, np.nan, 22]}
 df = pd.DataFrame(data)
 # Handling missing values by filling with a default value
 df_filled = df.fillna({'Name': 'Unknown', 'Age': df['Age'].mean()})
 print("DataFrame after filling missing values:")
 print(df_filled)

Output

DataFrame after filling missing values:
      Name   Age
0    Alice  24.0
1      Bob  23.0
2  Unknown  22.0

Explanation

• You can fill in missing values using `fill ()`, either with a specific value or a method like the mean or median.

Python Interview Questions PDF By ScholarHat.pdf from Scholarhat

Conclusion

In conclusion, Practicing Python Interview Questions is one of the best ways to strengthen your core Python skills. These Python Interview Questions help you understand real-world coding patterns, improve your logic, and get you ready for technical interviews. With consistent practice with these Python Interview Questions, you build the confidence to crack interviews smoothly.

To go beyond the basics, join the Data Science with Python Certification Course. This course teaches you how to use Python for real data tasks like analysis, visualization, and machine learning.