Top 25

ADVANCE LEVEL

Python
INTERVIEW QUESTIONS

Curated by tutort academy

 NOTE

These are advance level question that are actually

acted these days, and you can’t answer these if you
don’t learn these before.

Curated by tutort academy

 Question 1

What is the Global Interpreter Lock (GIL) in Python,

and how does it impact multi-threading?

The Global Interpreter Lock (GIL) is a mutex (short for mutual

exclusion) that allows only one thread to execute Python bytecode
at a time, even on multi-core processors. This limitation affects
multi-threading in Python because it prevents true parallel
execution of threads, limiting the performance benefits of multi-
core CPUs.

While the GIL makes Python threads less efficient for CPU-bound
tasks, it is not a problem for I/O-bound tasks, as threads can yield
the GIL during I/O operations. To achieve parallelism in CPU-
bound tasks, you can use the multiprocessing module, which
creates separate processes, each with its own Python interpreter
and memory space.

Example demonstrating GIL impact:

import threading

def count_up():

for _ in range(1000000):

pass

def count_down():

for _ in range(1000000):

pass

thread1 = threading.Thread(target=count_up)

thread2 = threading.Thread(target=count_down)

thread1.start()

thread2.start()

thread1.join()

thread2.join()

Curated by tutort academy

 Question 2

Explain the differences between shallow copy and

deep copy in Python, and how can you create them?

In Python, a shallow copy and a deep copy are two ways to

duplicate objects:

Shallow Copy: A shallow copy creates a new object but does not
create copies of nested objects within the original object. Instead,
it references the same nested objects. You can create a shallow
copy using the copy module's copy() function or by slicing.

import copy

original_list = [[1, 2, 3], [4, 5, 6]]

shallow_copied_list = copy.copy(original_list)

Deep Copy: A deep copy creates a completely independent copy

of the original object and all its nested objects. You can create a
deep copy using the copy module's deepcopy() function.

import copy

original_list = [[1, 2, 3], [4, 5, 6]]

deep_copied_list = copy.deepcopy(original_list)

Curated by tutort academy

 Question 3

What is the purpose of Python decorators? Provide

an example of how to use them.

Python decorators are a powerful feature that allows you to

modify or extend the behavior of functions or methods without
changing their source code. They are often used for tasks such as
logging, authentication, and memoization.

Here's an example of a simple decorator that logs the execution

time of a function:

import time

def timing_decorator(func):

def wrapper(*args, **kwargs):

start_time = time.time()

result = func(*args, **kwargs)

end_time = time.time()

print(f"{func.__name__} took {end_time - start_time}

seconds to execute.")

return result

return wrapper

@timing_decorator

def some_function():

# Your code here

time.sleep(2)

some_function()

From To
Placed with

Subhadip 100% Hike

Chowdhury

Curated by tutort academy

 Question 4

What is a generator in Python? How does it differ

from a regular function?

A generator in Python is a type of iterable, but it doesn't store all its

values in memory at once. Instead, it yields values one at a time,
which makes it memory-efficient for working with large datasets
or infinite sequences. Generators are defined using functions with
the yield keyword.

Here's an example of a simple generator function that generates

Fibonacci numbers:

def fibonacci_generator():

a, b = 0, 1

while True:

yield a

a, b = b, a + b

# Usage:

fib_gen = fibonacci_generator()

for _ in range(10):

print(next(fib_gen))

Regular functions, on the other hand, compute and return a value

using the return statement, and they do not retain their state
between calls.

Curated by tutort academy

 Question 5

Explain the purpose of the Python __init__ and

__del__ methods in classes.

The __init__ and __del__ methods are special methods in

Python classes:

__init__: This method is the constructor of a class and is called

when an instance of the class is created. It initializes the attributes
and sets up the object's initial state.

class MyClass:

def __init__(self, x):

self.x = x

obj = MyClass(5) # Calls __init__ with x=5

__del__: This method is called when an object is about to be

destroyed and its memory is being deallocated. It can be used to
perform cleanup operations or release resources associated with
the object.

class MyClass:

def __del__(self):

print("Object is being destroyed")

obj = MyClass()

del obj # Calls __del__ method

Note: The use of __del__ should be cautious, as Python's garbage collector

often handles object destruction automatically, and you may not need to
define this method in most cases.

Curated by tutort academy

 Question 6

What is a closure in Python, and why is it useful?

A closure is a nested function that remembers and has access to

variables from its containing (enclosing) function's scope even
after the containing function has finished executing. Closures are
useful for creating function factories and maintaining state across
multiple function calls.

Example of a closure:

def outer_function(x):

def inner_function(y):

return x + y

return inner_function

closure = outer_function(10)

result = closure(5) # result is 15

Tutort Benefits

1:1 Mentorship from

24x7 Live 1:1 Video based

Industry experts doubt support

Special support for

Resume building & Mock

foreign students Interview Preparations

Curated by tutort academy

 Question 7

Explain the use of the super() function in Python

and provide an example.

The super() function is used to call a method from the parent

(super) class in the context of a subclass. It is often used to invoke
the constructor of the parent class within the constructor of a
subclass.

Example of using super():

class Parent:

def __init__(self, x):

self.x = x

class Child(Parent):

def __init__(self, x, y):

super().__init__(x)

self.y = y

child_obj = Child(10, 20)

print(child_obj.x) # Output: 10

print(child_obj.y) # Output: 20

From To
Placed with

Akshat 300% Hike

Khandelwal

Curated by tutort academy

 Question 8

What is method resolution order (MRO) in Python,

and how is it determined?

Method Resolution Order (MRO) is the order in which Python looks

for methods and attributes in a class hierarchy. It is determined
using the C3 Linearization algorithm, which ensures a consistent
and predictable order when multiple inheritance is involved.

Code- class A:

def method(self):

print("A method")

class B(A):

def method(self):

print("B method")

class C(A):

def method(self):

print("C method")

class D(B, C):

pass

d = D()

d.method() # Output: B method

Curated by tutort academy

 Question 9

What is the purpose of the async and await

keywords in Python, and how are they used for
asynchronous programming?

The async and await keywords are used to define and work with
asynchronous code in Python, particularly in asynchronous
functions (coroutines). async marks a function as asynchronous,
and await is used to pause the execution of an asynchronous
function until an asynchronous operation completes.

Example of using async and await:

import asyncio

async def fetch_data(url):

response = await asyncio.gather(

asyncio.to_thread(requests.get, url),

asyncio.to_thread(requests.get, url)

return response

# Usage:

result = asyncio.run(fetch_data("https://tutort.com"))

Curated by tutort academy

 Question 10

Explain the Global Interpreter Lock (GIL) in Python

and its impact on multi-threading. How can you
achieve parallelism in Python despite the GIL?

(Continuation from question 1) The Global Interpreter Lock (GIL) is

a mutex that allows only one thread to execute Python bytecode
at a time, limiting the efficiency of multi-threading for CPU-bound
tasks. To achieve parallelism, you can use the multiprocessing
module, which creates separate processes, each with its own
Python interpreter and memory space.

Example using multiprocessing for parallelism:

import multiprocessing

def worker_function(x):

return x * x

if __name__ == "__main__":

pool = multiprocessing.Pool(processes=4)

result = pool.map(worker_function, [1, 2, 3, 4])

pool.close()

pool.join()

Curated by tutort academy

 Question 11

What is the Global Interpreter Lock (GIL) in Python,

and how does it impact multi-threading?

(Continuation from question 1) The Global Interpreter Lock (GIL) is

a mutex (short for mutual exclusion) that allows only one thread
to execute Python bytecode at a time, even on multi-core
processors. This limitation affects multi-threading in Python
because it prevents true parallel execution of threads, limiting the
performance benefits of multi-core CPUs.

While the GIL makes Python threads less efficient for CPU-bound
tasks, it is not a problem for I/O-bound tasks, as threads can yield
the GIL during I/O operations. To achieve parallelism in CPU-
bound tasks, you can use the multiprocessing module, which
creates separate processes, each with its own Python interpreter
and memory space.

Example demonstrating GIL impact:

import threading

def count_up():

for _ in range(1000000):

pass

def count_down():

for _ in range(1000000):

pass

thread1 = threading.Thread(target=count_up)

thread2 = threading.Thread(target=count_down)

thread1.start()

thread2.start()

thread1.join()

thread2.join()

Curated by tutort academy

 Question 12

Explain the differences between shallow copy and

deep copy in Python, and how can you create them?

(Continuation from question 2) In Python, a shallow copy and a

deep copy are two ways to duplicate objects:

Shallow Copy: A shallow copy creates a new object but does not
create copies of nested objects within the original object. Instead,
it references the same nested objects. You can create a shallow
copy using the copy module's copy() function or by slicing.

import copy

original_list = [[1, 2, 3], [4, 5, 6]]

shallow_copied_list = copy.copy(original_list)

Deep Copy: A deep copy creates a completely independent copy

of the original object and all its nested objects. You can create a
deep copy using the copy module's deepcopy() function.

import copy

original_list = [[1, 2, 3], [4, 5, 6]]

deep_copied_list = copy.deepcopy(original_list)

Curated by tutort academy

 Question 13

What is the purpose of Python decorators? Provide

an example of how to use them.

(Continuation from question 3) Python decorators are a powerful

feature that allows you to modify or extend the behavior of
functions or methods without changing their source code. They
are often used for tasks such as logging, authentication, and
memoization.

Here's an example of a simple decorator that logs the execution

time of a function:

import time

def timing_decorator(func):

def wrapper(*args, **kwargs):

start_time = time.time()

result = func(*args, **kwargs)

end_time = time.time()

print(f"{func.__name__} took {end_time - start_time}

seconds to execute.")

return result

return wrapper

@timing_decorator

def some_function():

# Your code here

time.sleep(2)

some_function()

Curated by tutort academy

 Question 14

What is a generator in Python? How does it differ

from a regular function?

(Continuation from question 4) A generator in Python is a type of

iterable, but it doesn't store all its values in memory at once.
Instead, it yields values one at a time, which makes it memory-
efficient for working with large datasets or infinite sequences.
Generators are defined using functions with the yield keyword.

Here's an example of a simple generator function that generates

Fibonacci numbers:

def fibonacci_generator():

a, b = 0, 1

while True:

yield a

a, b = b, a + b

# Usage:

fib_gen = fibonacci_generator()

for _ in range(10):

print(next(fib_gen))

From To
Placed with

Shaloni 100% Hike

Gangrade

Curated by tutort academy

 Question 15

Explain the purpose of the @staticmethod and

@classmethod decorators in Python, and provide
examples of when to use them.

The @staticmethod and @classmethod decorators are used to

define methods that are associated with a class rather than an
instance of the class.

@staticmethod: This decorator defines a static method that doesn't

depend on instance-specific data. Static methods can be called on
the class itself, without creating an instance of the class.

class MathUtility:

@staticmethod

def add(x, y):

return x + y

result = MathUtility.add(5, 3)

@classmethod: This decorator defines a class method that takes the

class itself as its first argument. Class methods are often used for
alternative constructors or to access and modify class-level attributes.

@classmethod

class MyClass:

def get_instance_count(cls):

count = 0

return cls.count

def __init__(self, value):

obj1 = MyClass(10)

self.value = value

obj2 = MyClass(20)

MyClass.count += 1
count = MyClass.get_instance_count() # count is 2

Curated by tutort academy

 Question 16

Explain the purpose of the @property decorator in

Python, and provide an example of its usage.

The @property decorator allows you to define a method as an

attribute, making it accessible like an attribute while still executing
custom logic when it is accessed.

Example of using @property:

class Circle:

def __init__(self, radius):

self._radius = radius

@property

def radius(self):

return self._radius

@radius.setter

def radius(self, value):

if value < 0:

raise ValueError("Radius

cannot be negative")

self._radius = value

@property

def area(self):

return 3.14 * self._radius * self._radius

circle = Circle(5)

print(circle.radius) # Access radius as if it's an attribute

circle.radius = 7 # Use the setter to change radius

print(circle.area) # Access area as a computed property

Curated by tutort academy

 Question 17

What is the purpose of the __str__ and __repr__

methods in Python classes?

The __str__ and __repr__ methods are used to define how

objects of a class should be represented as strings when they are
printed or converted to a string.

__str__: This method should return a user-friendly, informal

string representation of the object. It is called by the str() function
and when using print().

class MyClass:

def __str__(self):

return "This is a MyClass object"

__repr__: This method should return an unambiguous, formal

string representation of the object, which can be used to recreate
the object. It is called by the repr() function and can also be used
for debugging.

class MyClass:

def __init__(self, x):

self.x = x

def __repr__(self):

return f"MyClass({self.x})"

Curated by tutort academy

 Question 18

Explain how context managers work in Python and

provide an example of creating a custom context
manager.

Context managers in Python are used to set up and tear down

resources and ensure that they are properly managed, even in the
presence of exceptions. They are typically used with the with
statement.

Example of a custom context manager:

class MyContextManager:

def __enter__(self):

print("Entering the context")

return self # The object to be used within the context

def __exit__(self, exc_type, exc_value, traceback):

print("Exiting the context")

# Optional: Handle exceptions and return True if handled

# Usage:

with MyContextManager() as cm:

print("Inside the context")

Curated by tutort academy

 Question 19

What is the purpose of the __str__ and __repr__

methods in Python classes?

The __str__ and __repr__ methods are used to define how

objects of a class should be represented as strings when they are
printed or converted to a string.

__str__: This method should return a user-friendly, informal string

representation of the object. It is called by the str() function and
when using print().

class MyClass:

def __str__(self):

return "This is a MyClass object"

__repr__: This method should return an unambiguous, formal string

representation of the object, which can be used to recreate the object.
It is called by the repr() function and can also be used for debugging.

class MyClass:

def __init__(self, x):

self.x = x

def __repr__(self):

return f"MyClass({self.x})"

Curated by tutort academy

 Question 20

Explain how context managers work in Python and

provide an example of creating a custom context
manager.

Context managers in Python are used to set up and tear down

resources and ensure that they are properly managed, even in the
presence of exceptions. They are typically used with the with
statement.

Example of a custom context manager:

class MyContextManager:

def __enter__(self):

print("Entering the context")

return self # The object to be used within the context

def __exit__(self, exc_type, exc_value, traceback):

print("Exiting the context")

# Optional: Handle exceptions and return True if handled

# Usage:

with MyContextManager() as cm:

print("Inside the context")

Tutort Academy is always ready to provide job assistance in various

organizations such as MNCs and Startups, as well as help you with resume
writing, mock interviews, LinkedIn profile creation, and everything else
related to job search. They make you industry-ready.
Disha Patil

Curated by tutort academy

 Question 21

Explain the purpose of the functools module in Python

and provide an example of using its functions.

The functools module in Python provides higher-order functions

and operations on callable objects. It includes functions like
partial, reduce, and wraps for various purposes.

Example of using functools.partial:

from functools import partial

# Create a partial function with a fixed argument

multiply_by_two = partial(lambda x, y: x * y, y=2)

result = multiply_by_two(5) # Equivalent to calling lambda x: x * 2 with x=5

Why Tutort Academy?

Guaranteed
Hiring
Highest

100% Job Referrals 250+ Partners 2.1CR CTC

Tutort Academy is the best platform

This is a place where you grow not for students to learn things quickly
only on your IT skills but at a level and effectively. Everything from
that mends you internally, gives a interview preparation to core
boost to your confidence. Mentors Sagar Bansal subjects, puzzles, and coding
Dipti Kumari
are always there to help you guide practice has been taught to me. They
on this journey. cover all types of questions asked in
interviews, allowing you to develop
strong problem-solving skills.

Curated by tutort academy

 Question 22

What is monkey patching in Python, and when

might it be used?

Monkey patching refers to the practice of dynamically modifying

or extending the behavior of existing classes or modules at
runtime. It can be used to add, replace, or modify functions or
methods of existing code, often to fix bugs or add new features
without modifying the original source code.

Example of monkey patching:

# Original class

class Calculator:

def add(self, x, y):

return x + y

# Monkey patching to add a new method

def multiply(self, x, y):

return x * y

Calculator.multiply = multiply

# Usage

calc = Calculator()

result = calc.multiply(3, 4) # Result: 12

Curated by tutort academy

 Question 23

What are metaclasses in Python, and how are they

different from regular classes?

Metaclasses in Python are classes that define the behavior of

other classes, often referred to as "class factories." They control the
creation and behavior of classes at the class level. Metaclasses
are used for advanced purposes, such as enforcing coding
standards, code generation, and custom class creation.

Example of defining a metaclass:

class MyMeta(type):

def __init__(cls, name, bases, attrs):

# Perform custom actions here

pass

class MyClass(metaclass=MyMeta):

def __init__(self, x):

self.x = x

# MyClass is created with MyMeta as its metaclass

From To Switch from

Service Based
Sayan
Banerjee
Company

Curated by tutort academy

 Question 24

Explain the Global Interpreter Lock (GIL) in Python

and its impact on multi-threading. How can you
achieve parallelism in Python despite the GIL?

(Continuation from question 10) The Global Interpreter Lock (GIL)

is a mutex that allows only one thread to execute Python bytecode
at a time, limiting the efficiency of multi-threading for CPU-bound
tasks. To achieve parallelism, you can use the multiprocessing
module, which creates separate processes, each with its own
Python interpreter and memory space.

Example using multiprocessing for parallelism:

import multiprocessing

def worker_function(x):

return x * x

if __name__ == "__main__":

pool = multiprocessing.Pool(processes=4)

result = pool.map(worker_function, [1, 2, 3, 4])

pool.close()

pool.join()

Curated by tutort academy

 Question 25

Explain the concept of metaprogramming in Python

and provide an example of its use.

Metaprogramming in Python refers to the ability to write code that

can manipulate or generate code dynamically at runtime. It allows
you to create, modify, or analyze Python code programmatically,
often using introspection and reflection. Metaprogramming is a
powerful technique used in libraries, frameworks, and dynamic
systems.

Example of metaprogramming using Python's exec() function to

dynamically create and execute code:

# Dynamic code generation

variable_name = "x"

variable_value = 42

dynamic_code = f"{variable_name} = {variable_value}"

# Execute the dynamically generated code

exec(dynamic_code)

# Access the variable created dynamically

print(x) # Output: 42

In this example, we dynamically generate Python code as a string and

execute it using the exec() function. This technique is useful in situations
where code generation or dynamic behavior is required, but it should be
used with caution to avoid security risks and maintainability issues.

Curated by tutort academy

 Start Your
Upskilling with us

Explore More

www.tutort.net

Watch us on Youtube Read more on Quora

Explore our courses

Data Science & Machine Full Stack Data Science

Learning (AI & ML)

Follow us on