What are the different categories of Python interview questions

ullistrongBasicsstrong Covers fundamental syntax data types variables operators and control flowlilistrongData Structures and Algorithmsstrong Probes your understanding of lists tuples dictionaries sets functions loops and common algorithmslilistrongObjectOriented Programming OOPstrong Tests your knowledge of classes objects inheritance polymorphism and encapsulationlilistrongModules and Packagesstrong Evaluates your ability to import use and create moduleslilistrongException Handlingstrong Assesses your skills in handling errors and exceptionslilistrongFrameworks and Librariesstrong If relevant expects questions on specific frameworks like Django Flask or Pandasliul

What are some common mistakes candidates make in Python interviews

ullistrongNot understanding the Pythonic way of doing thingsstrong Python prioritizes readability and elegancelilistrongConfusing mutable and immutable data typesstrong Grasping the difference between lists and tuples is cruciallilistrongStruggling with builtin functions and modulesstrong Utilize Pythons vast ecosystem effectivelylilistrongPoor code qualitystrong Write clean wellcommented and efficient codelilistrongBeing overly reliant on memorized answersstrong Focus on understanding and explaining your thought processliul

Top 50+ Python Interview Questions and Answers

Q: How should I prepare for a Python programming interview

divTo prepare for a Python programming interview its essential to have a strong grasp of basic syntax and language features Additionally review core concepts such as data structures lists dictionaries tuples functions classes and common Python libraries Practice solving coding problems and familiarize yourself with Pythonic coding conventionsbrbrdiv

Q: What types of questions can I expect in a Python interview

divIn a Python interview you can expect questions ranging from basic syntax and language features to more advanced topics such as objectoriented programming functional programming algorithmic problemsolving and usage of specific libraries or frameworks You may also encounter questions related to Pythons ecosystem and best practicesdiv

06 Dec 2024

Question

6.95K Views

73 min read

Python Interview Questions and Answers

Python interview questions are an important part of hiring a software developer, data analyst, machine learning engineer, or backend developer. Python is a heterogeneous, dynamic, object-oriented, high-level programming language that has been found to be applicable in domains varying from web development to data science. The broad utilization thereby puts a demand on understanding the key concepts of Python and how one can solve practical problems using it.

In this Python tutorial, we have covered 50 Python interview questions and answers based on various topics that could arise during interviews for software engineer, data analyst, and data engineer roles in top-tier companies. Whether you are a fresher or someone experienced with 5, 8, or 10 years of experience, this article gives you the required knowledge and confidence needed to crush your next Python interview.

Explore:

Why Python?

Python remains articulate to many because it is relatively easy to learn and read, hence perfect for beginners. It enforces numerous libraries that help you do many tasks in the least amount of time, such as data analysis and web development. Many huge companies happen to use Python because it's flexible and efficient. We begin with the top 50 Python interview questions and answers, which are sure to help you ace your forthcoming job interview.

Get your answers in our:

Python Interview questions for freshers

What is Python? What are the applications of Python?

Python is a programming language that is easy to read and write. It is known for being simple and powerful, and it can be used for many different types of projects. Python supports different styles of programming, like creating programs step-by-step or working with objects.

Python is used in many areas, such as:

Web Development: It helps in building websites using tools like Django and Flask.
Data Science & Machine Learning: Python is great for working with data and creating machine learning models using libraries like Pandas and TensorFlow.
Automation & Scripting: It is used to automate repetitive tasks, making things easier.
Game Development: Simple games can be made using Python with libraries like Pygame.
Networking & System Administration: Python is helpful in managing networks and automating tasks on computers.
Desktop Applications: Python can create apps for computers using tools like Tkinter and PyQt.

Read More: What is Python Language? Overview of the Python Language

2. Why do we use the Python startup environment variable?

You use the Python startup environment variable to run a script automatically when Python starts.
It helps set up things like default settings or loading modules without typing them every time.
It is like a shortcut to make your Python environment ready to use faster.

3. What is a dynamically typed language?

A dynamically typed language means you don't need to declare the type of a variable when you create it.
Python, for example, figures out the type based on the value you assign.
It is like letting the language handle types for you, making it more flexible but sometimes less predictable.

4. What is a lambda function?

A lambda function is a small, anonymous function in Python that you can define in one line.
It is like a shortcut for creating simple functions without using the def keyword.
You use it for quick tasks, usually when you need a function just once or for a short operation.

You can assign a lambda function to a variable for quick calculations, like in this example:

product = lambda a, b : a * b
print(mul(2, 7)) # output is 10

You can also wrap a lambda function inside another function:

def wrapperFunc(n):
 return lambda a : a * n
prod = wrapperFunc(7)
print(prod(2)) # output is 14

5. What is the pass statement in Python?

The pass statement in Python is like a placeholder.
You use it when you need a block of code syntactically but don't want to execute any action yet.
It is like saying, "Do nothing for now, but I’ll add code here later."

Here’s an example of using the pass statement:

def passFunc():
 # does nothing
 pass
myEmptyFunc() # nothing happens

6. What is docstring in Python?

Python Documentation string or docstring is a multiline string for associating documentation with a specific code segment like Python modules, functions, classes, and methods. The docstring should describe what the function or method does.

Declaring Docstrings: The docstrings are declared using ”’triple single quotes”’ or “””triple double quotes””” just below the class, method, or function declaration. All functions should have a docstring.
Accessing Docstrings: The docstrings can be accessed using the __doc__ method of the object or using the help function.

What is meant by slicing in Python?

Slicing in Python is a way to access a part of a sequence, like a list, string, or tuple. It lets you extract elements using a start, stop, and optional step index. It is like cutting out a portion of the data for use.

Syntax

slice()
slice(start, stop, step)

Parameters:

start: starting integer
stop: integer until which the slicing takes place. At the '-1' index, the slicing stops.
step: incrementing value between each index.

The slice() function returns a sliced object containing elements in the given range only.

Example


myString = 'ScholarHat'
stObject = slice(3)
print(myString[stObject])
stObject = slice(1, 5, 2)
print(myString[stObject])

Output

Sch
col

Read More: What is Slicing in Python?

Python coding questions

8. Difference between a List and a Tuple in Python

Ans: Data can be collected in Python through lists and tuples. However, there is a great distinction between them. A list is what we call mutable; this means one can change it after creation, for example, by adding or removing elements or changing the elements in place. A tuple is an object we call immutable, meaning once created, it cannot be changed. Use a list when you want to have a collection that may need to be modified and tuples when you want to ensure that the data will not change.

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)
print("Tuple remains unchanged:", my_tuple)

Output


List after modification: [10, 2, 3]
Tuple remains unchanged: (1, 2, 3)

Explanation

Lists are mutable, meaning they can be modified after creation (elements can be added, removed, or changed).
Tuples are immutable, meaning once they are created, their elements cannot be changed.

9. Check if a Number is Even or Odd

Ans: You can determine if a number is even or odd by checking if it divides evenly by 2. An even number gives no remainder when divided by 2, while an odd number has a remainder of 1. Use the modulus operator (`%`) to easily check if a number is even or odd.

Example


number = int(input("Enter a number: "))

if number % 2 == 0:
    print(number, "is Even")
else:
    print(number, "is Odd")

Output


Enter a number: 5
5 is Odd

Explanation

The modulus is an arithmetic operator in Python (`%`) that checks for the remainder when a number is divided by 2.
If the remainder is 0, the number is even. If the remainder is 1, the number is odd.

10. Reverse a String in Python

Ans: To reverse a string in Python, you can use slicing in Python. Slicing with [::-1]: This makes a new string that's the reverse of the original. This is a quick way to reverse a string without using loops or extra functions.

Example


string = input("Enter a string: ")
reversed_string = string[::-1]
print("Reversed string:", reversed_string)

Output


Enter a string: hello
Reversed string: olleh

Explanation

Slicing with `[::-1]` reverses the string by starting from the last character and moving to the first one.
This is a simple, efficient method to reverse strings in Python.

11. Find the Maximum Number in a List

Ans: You can find the largest number in a list using the max() function in Python, which returns the highest value from the list. This is helpful when you want to find the biggest item on a list quickly.

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.

12. Remove Duplicates from a List

Ans: If you want to remove duplicate items from a list, you can convert it to a set, which only keeps unique items, and then convert it back to a list if needed. This is an easy way to keep only one instance of each item in your 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

Converting the list to a set removes duplicate values, as sets only contain unique elements.
You can then convert the set back to a list if you need the result in list form.

Python basic interview questions

13. What is a Python variable, and how do you declare it?

Ans: A variable in Python is a name given to a memory location. It is used to store data values. You don’t need to explicitly declare a variable in Python, as it is dynamically typed. You simply assign a value to a variable.

Example


# Declare a variable
name = "John"
age = 25
print("Name:", name)
print("Age:", age)

Output


Name: John
Age: 25

Explanation

A variable is a name identifier that holds values in memory. Assign any value to it using the = operator.
No need to define the type of a variable in Python; it will be defined by default according to the value being assigned.

14. What are the different data types available in Python?

Ans: Python consists of many different built-in data types in Python that help us save diverse values. Its main data types include integers, floating-point numbers, strings, and booleans. Collection data types in Python include lists, tuples, sets, and dictionaries.

Example


# Different data types
integer_var = 10
float_var = 10.5
string_var = "Hello"
boolean_var = True

print(integer_var, float_var, string_var, boolean_var)

Output


10 10.5 Hello True

Explanation

Python has multiple data types like integers, floats, strings, and booleans. These can store different kinds of values.
Python also provides collection types like lists, sets, tuples, and dictionaries to handle more complex data structures.

15. What is a function in Python?

Ans: A function in Python is a block of code that is designed to perform a specific task. It helps in organizing the code and allows code reuse. You define a function using the `def` keyword.

Example


# Define a function
def greet(name):
    return f"Hello, {name}!"

# Call the function
message = greet("Alice")
print(message)

Output


Hello, Alice!

Explanation

Functions are defined with the 'def' keyword, followed by the function name and parameters (if any).
Functions enable code reuse and can be called several times with different arguments to accomplish the same operation with different data.

16. How do you handle exceptions in Python?

Ans: Exception handling in Python uses the `try,` `except,` and `finally` blocks. The code that might raise an exception is placed inside the `try` block, and the `except` block handles the exception if it occurs.

Example


# Handling exceptions
try:
    x = 10 / 0  # Division by zero
except ZeroDivisionError as e:
    print("Error:", e)

Output


Error: division by zero

Explanation

The `try` block contains the code that might raise an exception.
If an exception occurs, the code in the `except` block is executed to handle the error and prevent the program from crashing.

17. How do you write a loop in Python?

Ans: Python has two types of loops: 'for' and 'while'. The 'for' loop is commonly used to iterate over a sequence (such as a list or range), but the 'while' loop is used to repeat an action until a condition no longer exists.

Example


# For loop example
for i in range(5):
    print("Iteration:", i)

# While loop example
count = 0
while count < 3:
    print("Count is:", count)
    count += 1

Output

Iteration: 0
Iteration: 1
Iteration: 2
Iteration: 3
Iteration: 4
Count is: 0
Count is: 1
Count is: 2

Explanation

The for loop runs over a sequence. It may be a list, range, etc. Here, range(5) is generating numbers from 0 to 4.
The while loop is a condition-based loop that keeps running while the condition is true. As soon as it becomes false, the loop stops.

18. What are built-in data types in Python?

Built-in data types in Python are the basic types that Python provides to handle different kinds of data.
These include types like integers, floats, strings, and booleans.
It is like having ready-made tools for storing and working with data.

What are built-in data types in Python?

Numeric Types: They have a numeric value. There are three different numeric types - integers, floating-point numbers, booleans, and complex numbers.
Sequence Types: It is the ordered collection of similar or different data types. There are four basic Sequence Types - lists, tuples, strings, and range.
Mapping Types: In Python, hashable data can be mapped to random objects using a mapping object. There is currently only one common mapping type, the dictionary, and mapping objects are mutable.
Set Types: A set is an unordered collection of data types that is iterable, mutable, and has no duplicate elements. The order of elements in a set is undefined.

Python OOPS Interview Questions

1. What is a class and an object in Python?

Ans: A class is a blueprint for creating objects (a particular data structure) and defining the attributes and behaviors that the objects will have. An object is an instance of a class. It is created by calling the class.

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 is a blueprint that defines the attributes and methods for the objects it creates.
An object is an instance of the class, created by calling the class.

2. What is inheritance in Python?

Ans: Inheritance in Python is a way to form new classes using classes that have already been defined. It allows a class to inherit attributes and methods from another class, thus facilitating code reusability.

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.

3. What is polymorphism in Python?

Ans: Polymorphism allows a class to define methods that have the same name but behave differently depending on the object that calls them. This can be achieved through method overriding in child classes.

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.

4. What is encapsulation in Python?

Ans: Encapsulation is the concept of bundling data (variables) and methods that operate on that data into a single unit or class. It helps to restrict direct access to some of an object’s attributes and methods.

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.

5. What is the difference between `str` and `repr` in Python?

Ans: The `__str__` method is used to define a user-friendly string representation of an object, while `__repr__` is used to define 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

1. What is Pandas and how is it used in Python?

Ans: 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()`.

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

Ans: Pandas provides several methods for handling missing data, such as `isna()`, `dropna()`, and `fillna()`. These methods can be used to check, remove, or fill missing data in a DataFrame.

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.

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

Ans: 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

Boolean indexing allows us to filter the rows of a DataFrame based on a condition. In this case, it selects rows where the `Age` is greater than 30.

4. How do you merge two Pandas DataFrames?

Ans: 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.

5. How do you group data in Pandas?

Ans: 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

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

Ans: Selenium is an open-source tool used to automate web browsers. It allows you to write scripts in Python 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()`.

2. What are WebDriver and WebElement in Selenium?

Ans: 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.

3. How do you handle alerts in Selenium?

Ans: 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.

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

Ans: 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".

5. How do you locate elements in Selenium?

Ans: 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

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

Ans: Python automation refers to the process of 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.

2. How can you automate sending emails using Python?

Ans: 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.

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

Ans: 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.

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

Ans: 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.

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

Ans: 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

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

Ans: 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.

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

Ans: NumPy is a powerful library for numerical computing in Python, providing support for large, multi-dimensional arrays and matrices, along with a large collection of mathematical functions to operate on these arrays.

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.

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

Ans: 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).

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

Ans: 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.

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

Ans: - `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.

6. What is a DataFrame in Pandas?

Ans: 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.

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

Ans: 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 missing values using `fillna()`, either with a specific value or a method like the mean or median.

Summary

Python Interview Questions are important for checking your understanding of Python basics. This article has 50 commonly asked questions that cover key topics like data structures, exception handling, and object-oriented programming. It is designed for both beginners and experienced developers, helping you feel more confident and ready for real programming challenges. No matter how much experience you have, this guide will help you do well in your next technical interview.

To learn more about Python concepts and by using Python, you start your career as a data scientist. Think about joining ScholarHat's Data Science with Python Certification Course.

FAQs

To prepare for a Python programming interview, it's essential to have a strong grasp of basic syntax and language features. Additionally, review core concepts such as data structures (lists, dictionaries, tuples), functions, classes, and common Python libraries. Practice solving coding problems and familiarize yourself with Pythonic coding conventions.

In a Python interview, you can expect questions ranging from basic syntax and language features to more advanced topics such as object-oriented programming, functional programming, algorithmic problem-solving, and usage of specific libraries or frameworks. You may also encounter questions related to Python's ecosystem and best practices.

Basics: Covers fundamental syntax, data types, variables, operators, and control flow.
Data Structures and Algorithms: Probes your understanding of lists, tuples, dictionaries, sets, functions, loops, and common algorithms.
Object-Oriented Programming (OOP): Tests your knowledge of classes, objects, inheritance, polymorphism, and encapsulation.
Modules and Packages: Evaluates your ability to import, use, and create modules.
Exception Handling: Assesses your skills in handling errors and exceptions.
Frameworks and Libraries: If relevant, expects questions on specific frameworks like Django, Flask, or Pandas.

Not understanding the Pythonic way of doing things: Python prioritizes readability and elegance.
Confusing mutable and immutable data types: Grasping the difference between lists and tuples is crucial.
Struggling with built-in functions and modules: Utilize Python's vast ecosystem effectively.
Poor code quality: Write clean, well-commented, and efficient code.
Being overly reliant on memorized answers: Focus on understanding and explaining your thought process.

01 Career Opportunities

02 Beginner

03 Intermediate

04 Questions

05 Training Programs

Top 50+ Python Interview Questions and Answers

Free Data Structures & Algorithms Online Course

Python Interview Questions and Answers

Why Python?

Python Interview questions for freshers

What is Python? What are the applications of Python?

2. Why do we use the Python startup environment variable?

3. What is a dynamically typed language?

4. What is a lambda function?

5. What is the pass statement in Python?

6. What is docstring in Python?

What is meant by slicing in Python?

Syntax

Example

Output

Python coding questions

8. Difference between a List and a Tuple in Python

Example

Output

Explanation

9. Check if a Number is Even or Odd

Example

Output

Explanation

10. Reverse a String in Python

Example

Output

Explanation

11. Find the Maximum Number in a List

Example

Output

Explanation

12. Remove Duplicates from a List

Example

Output

Explanation

Python basic interview questions

13. What is a Python variable, and how do you declare it?

Example

Output

Explanation

14. What are the different data types available in Python?

Example

Output

Explanation

15. What is a function in Python?

Example

Output

Explanation

16. How do you handle exceptions in Python?

Example

Output

Explanation

17. How do you write a loop in Python?

Example

Output

Explanation

18. What are built-in data types in Python?

Python OOPS Interview Questions

1. What is a class and an object in Python?

Example

Output

Explanation

2. What is inheritance in Python?

Example

Output

Explanation

3. What is polymorphism in Python?

Example

Output

Explanation

4. What is encapsulation in Python?

Example

Output

Explanation

5. What is the difference between `str` and `repr` in Python?