Cracking Python Interview Questions in 2024: What You Need to Know

5. What is a Python Decorator?

A decorator in Python is a design pattern that allows you to modify the behavior of a function or method. Decorators are typically used to add functionality to an existing code. The syntax involves using the @ symbol above the function definition. For example:

def my_decorator(func):

    def wrapper():

        print(“Something is happening before the function is called.“)

        func()

        print(“Something is happening after the function is called.”)

    return wrapper

@my_decorator

def say_hello():

    print(“Hello!”)

say_hello()

6. What are List Comprehensions and Generator Expressions?

List Comprehensions provide a concise way to create lists. For example, [x for x in range(10) if x % 2 == 0] generates a list of even numbers from 0 to 9.

Generator Expressions are similar to list comprehensions but use parentheses and yield items one at a time, saving memory. For example, (x for x in range(10) if x % 2 == 0) creates a generator object.

7. Explain the concept of Python’s Global Interpreter Lock (GIL).

The Global Interpreter Lock (GIL) is a mutex that protects access to Python objects, preventing multiple native threads from executing Python bytecodes simultaneously. This means that even in multi-threaded programs, only one thread can execute Python code at a time, which can be a bottleneck in CPU-bound and multi-threaded code. However, I/O-bound and multi-process code can benefit from Python’s threading and multiprocessing libraries, respectively.

Advanced Python Concepts

8. What is the difference between __init__ and __new__?

__init__ is the initializer method called after the instance is created to initialize the instance’s attributes.

__new__ is the method responsible for creating and returning a new instance of the class. It’s rarely overridden but can be used for custom object creation.

class MyClass:

    def __new__(cls, *args, **kwargs):

        print(“Creating instance“)

        return super(MyClass, cls).__new__(cls)

    def __init__(self, name):

        print(“Initializing instance“)

        self.name = name

obj = MyClass(“Python”)

9. How do you handle exceptions in Python?

Exceptions in Python are handled using the try, except, else, and finally blocks. For example:

try:

    # Code that might raise an exception

    result = 10 / 0

except  ZeroDivisionError:

    # Code that runs if exception occurs

    print(“Cannot divide by zero“)

else:

    # Code that runs if no exception occurs

    print(“Division successful“)

finally:

    # Code that runs no matter what

    print(“Execution complete“)

10. What is the use of self in Python classes?

self represents the instance of the class. It allows access to the attributes and methods of the class in object-oriented programming. For example:

class MyClass:

    def __init__(self, name):

        self.name = name

def greet(self):

        print(f”Hello, {self.name}”)

obj = MyClass(“Python”)

obj.greet()  # Output: Hello, Python

Common Python Libraries

11. What are some essential Python libraries and their uses?

• NumPy: Used for numerical computations and working with arrays.
• Pandas: Used for data manipulation and analysis.
• Matplotlib: Used for data visualization.
• Requests: Used for making HTTP requests.
• BeautifulSoup: Used for web scraping.
• Scikit-learn: Used for machine learning and data mining.

12. How do you use the requests library to make an HTTP GET request?

The requests library simplifies making HTTP requests. For example:

import requests

response = requests.get(‘https://api.example.com/data’)

if response.status_code == 200:

    data = response.json()

    print(data)

else:

    print(“Request failed“)

13. Explain the use of Pandas for data manipulation.

Pandas is a powerful library for data manipulation and analysis. It provides data structures like Series and DataFrame. For example, to read a CSV file and perform basic operations:

import pandas as pd

# Read CSV file

df = pd.read_csv(‘data.csv’)

# Display first 5 rows

print(df.head())

# Filter rows

filtered_df = df[df[‘column_name‘] > 10]

# Group by and aggregate

grouped_df = df.groupby(‘category’).sum()

Advanced Topics in Python

Import pandas as pd

14. What is multithreading and multiprocessing in Python?

• Multithreading: Running multiple threads (smaller units of process) concurrently. Suitable for I/O-bound tasks multiple processes concurrently. Suitable for CPU-bound tasks.

15. Explain the concept of asynchronous programming in Python.

Asynchronous programming allows tasks to run independently of the main program flow, making it possible to handle I/O-bound operations more efficiently. Python’s asyncio library is commonly used for this purpose. For example:

import asyncio

async def fetch_data():

    print(“Fetching data“)

    await asyncio.sleep(2)

    print(“Data fetched“)

async def main():

    await asyncio.gather(fetch_data(), fetch_data())

asyncio.run(main())

16. What is the difference between shallow copy and deep copy?

• Shallow Copy: Copies the reference pointers to the objects, so changes in the copied object affect the original object. Use the copy module:

import copy

list1 = [1, 2, [3, 4]]

list2 = copy.copy(list1)

• Deep Copy: Copies the objects and the elements within, so changes in the copied object do not affect the original object. Use the copy module:

import copy

list1 = [1, 2, [3, 4]]

list2 = copy.deepcopy(list1)