Python is widely used by leading companies such as Intel, IBM, NASA, Pixar, Netflix, Meta, JPMorgan Chase and Spotify due to its simplicity and rich ecosystem of libraries. Mastering key Python interview questions is essential for succeeding in coding assessments and technical interviews for Python developer roles.

1. Is Python a compiled language or an interpreted language?

Python is considered both a compiled and an interpreted language. First, Python source code (.py files) is compiled into bytecode (.pyc files). Then, the Python Virtual Machine (PVM) interprets and executes this bytecode line by line.

• Python code is first compiled into bytecode.
• The Python Virtual Machine (PVM) executes the bytecode.
• CPython, the most common Python implementation, both compiles and interprets code.
• Some implementations like PyPy use Just-In-Time (JIT) compilation for improved performance.

Therefore, Python combines features of both compiled and interpreted languages.

2. Is Indentation Required in Python?

Yes, indentation is required in Python. A Python interpreter can be informed that a group of statements belongs to a specific block of code by using Python indentation. Indentations make the code easy to read for developers in all programming languages but in Python, it is very important to indent the code in a specific order.

3. What is a dynamically typed language?

A dynamically typed language is a programming language in which the data type of a variable is determined at runtime. In Python, you do not need to declare the data type of a variable explicitly. Instead, Python automatically assigns the appropriate type based on the value stored in the variable.

x = 10       # x is an integer
x = "Hello"  # Now x is a string

Here, the variable x initially stores an integer and is later reassigned to a string. Python automatically updates the variable's type at runtime.

4. What are Built-in data types in Python?

The following are the standard or built-in data types in Python:

• Numeric: The numeric data type in Python represents the data that has a numeric value. A numeric value can be an integer, a floating number, or a complex number.
• Sequence Type: The sequence Data Type in Python is the ordered collection of similar or different data types. There are several sequence types in Python like String, List, Tuple, 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: In Python, 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 though it may consist of various elements.

5. What is the difference between a Mutable datatype and an Immutable data type?

• Mutable data types are objects whose values can be changed after they are created. Any modification is made in place without creating a new object. Common examples include lists, dictionaries and sets.
• Immutable data types are objects whose values cannot be changed after creation. If you modify them, Python creates a new object instead. Common examples include strings, tuples, integers and floats.

# Mutable example
a = [1, 2, 3]
a.append(4)
print(a)        

# Immutable example
s = "Hello"
s = s + " World"
print(s)       

Explanation: In the first example, the list a is modified directly by adding a new element. In the second example, strings are immutable, so concatenating " World" creates a new string object and assigns it back to s.

6. What is the difference between == and is in Python?

Both == and is are comparison operators, but they compare different things.

• == checks whether two objects have the same value.
• is checks whether two variables refer to the same object in memory.

a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(a == b)
print(a is b)
print(a is c)

True
False
True

7. What is the difference between / and // in Python?

/ represents precise division (result is a floating point number) whereas // represents floor division (result is an integer). For Example:

print(5//2)
print(5/2)

2
2.5

8. How do you floor a number in Python?

To floor a number in Python, you can use the math.floor() function, which returns the largest integer less than or equal to the given number.

• floor() method returns the floor of x i.e., the largest integer not greater than x. 
• Also, The method ceil (x) returns a ceiling value of x i.e., the smallest integer greater than or equal to x.

import math

n = 3.7
F_num = math.floor(n)

print(F_num) 

3

9. What is the difference between a Set and Dictionary?

Set is an unordered collection data type that is iterable, mutable and has no duplicate elements. Python’s set class represents the mathematical notion of a set. Defined using curly braces {} or the set() function.

Example: my_set = {1, 2, 3}

Dictionary is a collection of key-value pairs used to store and retrieve data using unique keys. Dictionaries preserve insertion order. Defined using curly braces {} with key-value pairs.

Example: my_dict = {"a": 1, "b": 2, "c": 3}

10. How is a dictionary different from a list?

A list is an ordered collection of items that are accessed using their index position, whereas a dictionary is an ordered collection of key-value pairs that are accessed using unique keys. Lists are suitable for storing sequential data, while dictionaries are ideal for storing data associated with meaningful keys.

# List
numbers = [10, 20, 30]
print(numbers[1])   

# Dictionary
student = {"name": "Emma", "marks": 95}
print(student["name"])

20
Emma

11. What is the difference between Python Arrays and Lists?

Arrays (when talking about the array module in Python) are specifically used to store a collection of numeric elements that are all of the same type. This makes them more efficient for storing large amounts of data and performing numerical computations where the type consistency is maintained.

from array import array
arr = array('i', [1, 2, 3, 4])  # Array of integers
print(arr)

array('i', [1, 2, 3, 4])

Lists are more flexible than arrays in that they can hold elements of different types (integers, strings, objects, etc.). They come built-in with Python and do not require importing any additional modules. Lists support a variety of operations that can modify the list.

a = [1, 'hello', 3.14, [1, 2, 3]]
print(a)

[1, 'hello', 3.14, [1, 2, 3]]

Read more about: List vs Array in Python

12. Difference between for loop and while loop in Python

• For loop: Used when we know how many times to repeat, often with lists, tuples, sets or dictionaries.
• While loop: Used when we only have an end condition and don’t know exactly how many times it will repeat.

for i in range(5):
    print(i)
    
print()

c = 0
while c < 5:
    print(c)
    c += 1

0
1
2
3
4

0
1
2
3
4

13. What is a break, continue and pass in Python? 

• Break statement: Used to terminate the loop or statement in which it is present. After that, the control will pass to the statements that are present after the break statement, if available.
• Continue: is also a loop control statement just like the break statement. continue statement is opposite to that of the break statement, instead of terminating the loop, it forces to execute the next iteration of the loop.
• Pass: means performing no operation or in other words, it is a placeholder in the compound statement, where there should be a blank left and nothing has to be written there.

14. What is a lambda function?

A lambda function is an anonymous function. This function can have any number of parameters but, can have just one statement. In the example, we defined a lambda function(upper) to convert a string to its upper case using upper().

s1 = 'GeeksforGeeks'
s2 = lambda func: func.upper()
print(s2(s1))

GEEKSFORGEEKS

15. What are map(), filter(), and reduce() in Python?

These functions are used for functional programming:

• map() applies a function to every element.
• filter() selects elements that satisfy a condition.
• reduce() combines all elements into a single value.

from functools import reduce

numbers = [1,2,3,4]
print(list(map(lambda x: x*2, numbers)))
print(list(filter(lambda x: x%2==0, numbers)))
print(reduce(lambda x,y:x+y, numbers))

[2, 4, 6, 8]
[2, 4]
10

16. Can we Pass a function as an argument in Python?

Yes, several arguments can be passed to a function, including objects, variables (of the same or distinct data types) and functions. Functions can be passed as parameters to other functions because they are objects. Higher-order functions are functions that can take other functions as arguments.

def add(x, y):
    return x + y

def apply_func(func, a, b):
    return func(a, b)

print(apply_func(add, 3, 5))

8

The add function is passed as an argument to apply_func, which applies it to 3 and 5.

17. What are *args and **kwargs?

*args: used to pass a variable number of arguments to a function. Python program to illustrate *args for a variable number of arguments.

def fun(*argv):
    for arg in argv:
        print(arg)

fun('Hello', 'Welcome', 'to', 'GeeksforGeeks')

Hello
Welcome
to
GeeksforGeeks

**kwargs: used to accept a variable number of keyword arguments. These arguments are collected into a dictionary, where the keys are the argument names and the values are the corresponding values.

def fun(**kwargs):
    for k, val in kwargs.items():
        print("%s == %s" % (k, val))

fun(s1='Geeks', s2='for', s3='Geeks')

s1 == Geeks
s2 == for
s3 == Geeks

18. How are arguments passed by value or by reference in Python?

Python uses Pass by Object Reference (also called Call by Object Sharing) to pass arguments to functions. Instead of passing values or references directly, Python passes a reference to the object. Whether the original object changes depends on whether it is mutable or immutable.

def call_by_val(x):
    x = x * 2
    return x

def call_by_ref(b):
    b.append("D")
    return b

a = ["E"]
num = 6

updated_num = call_by_val(num)
updated_list = call_by_ref(a)
print("Updated value after call_by_val:", updated_num)
print("Updated list after call_by_ref:", updated_list)

Updated value after call_by_val: 12
Updated list after call_by_ref: ['E', 'D']

19. What is a Variable Scope in Python?

The location where we can find a variable and also access it if required is called the scope of a variable.

• Python Local variable: Local variables are those that are initialized within a function and are unique to that function. A local variable cannot be accessed outside of the function.
• Python Global variables: Global variables are the ones that are defined and declared outside any function and are not specified to any function.
• Module-level scope: It refers to the global objects of the current module accessible in the program.
• Outermost scope: It refers to any built-in names that the program can call. The name referenced is located last among the objects in this scope.

20. What is the LEGB rule in Python?

Python follows the LEGB rule to resolve variable names. LEGB stands for:

• L – Local
• E – Enclosing
• G – Global
• B – Built-in

Python searches for a variable in this order until it is found.

x = "Global"

def outer():
    x = "Enclosing"

    def inner():
        x = "Local"
        print(x)

    inner()

outer()

Local

21. What are the global and nonlocal keywords in Python?

Both keywords allow modifying variables outside the current function.

• global modifies a global variable.
• nonlocal modifies a variable from the nearest enclosing function.

count = 0

def increment():
    global count
    count += 1

increment()
print(count)

1

Example of nonlocal:

def outer():
    x = 10

    def inner():
        nonlocal x
        x += 5

    inner()
    print(x)

outer()

15

22. What is docstring in Python?

Python documentation strings (or docstrings) provide a convenient way of associating documentation with Python modules, functions, classes and methods.

• Declaring Docstrings: Docstrings are written using triple single quotes (''') or triple double quotes (""") immediately below the module, class, method or function definition.
• Accessing Docstrings: Docstrings can be accessed using the __doc__ attribute of the object or by using the help() function.

def add(a, b):
    """Return the sum of two numbers."""
    return a + b

print(add.__doc__)
help(add)

Return the sum of two numbers.
Help on function add in module __main__:

add(a, b)
    Return the sum of two numbers.

Explanation: In this example, the function add() includes a docstring that describes its purpose. The docstring can be viewed directly using add.__doc__ or through the built-in help() function.

23. How can you concatenate two lists in Python?

We can concatenate two lists in Python using the +operator or the extend() method.

1. + operator: This creates a new list by joining two lists together.

a = [1, 2, 3]
b = [4, 5, 6]
res = a + b
print(res) 

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

2. extend() : This adds all the elements of the second list to the first list in-place.

a = [1, 2, 3]
b = [4, 5, 6]
a.extend(b)
print(a) 

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

24. What is the difference between append() and extend()?

Both methods add elements to a list:

• append() adds the entire object as a single element.
• extend() adds each element of an iterable individually.

a = [1,2]
a.append([3,4])
print(a)

b = [1,2]
b.extend([3,4])
print(b)

[1, 2, [3, 4]]
[1, 2, 3, 4]

25. What is the difference between remove(), pop(), and del?

All three remove elements from a list but work differently:

• remove() deletes the first matching value.
• pop() removes an element using its index and returns it.
• del deletes an element or an entire list.

num = [10,20,30,40]
num.remove(20)
num.pop()
del num[0]
print(num)

[30]

26. What is List Comprehension? Give an Example.

List comprehension is a way to create lists using a concise syntax. It allows us to generate a new list by applying an expression to each item in an existing iterable (such as a list or range). This helps us to write cleaner, more readable code compared to traditional looping techniques.

For example, if we have a list of integers and want to create a new list containing the square of each element, we can easily achieve this using list comprehension.

a = [2,3,4,5]
res = [val ** 2 for val in a]
print(res)

[4, 9, 16, 25]

27. How is Exceptional handling done in Python?

Exception handling in Python is used to manage runtime errors gracefully without stopping the program abruptly. Python provides three main keywords for handling exceptions:

• try: A block of code that is monitored for errors.
• except: Executes when an error occurs in the try block.
• finally: Executes after the try and except blocks, regardless of whether an error occurred. It’s used for cleanup tasks.

Example: Trying to divide a number by zero will cause an exception.

n = 10
try:
    res = n / 0  # Raises ZeroDivisionError

except ZeroDivisionError:
    print("Can't be divided by zero!")

finally:
    print("Execution completed.")

Can't be divided by zero!
Execution completed.

Explanation: In this example, dividing number by 0 raises a ZeroDivisionError. The try block contains the code that might cause an exception and the except block handles the exception, printing an error message instead of stopping the program.

28. What are Modules and Packages in Python?

A module is a single file that contains Python code (functions, variables, classes) which can be reused in other programs. You can think of it as a code library. For example: math is a built-in module that provides math functions like sqrt(), pi, etc.

import math
print(math.sqrt(16))  

4.0

Package is a collection of related modules stored in a directory. It helps in organizing and grouping modules together for easier management. For example: The numpy package contains multiple modules for numerical operations. To create a package, the directory must contain a special file named __init__.py.

29. What is the purpose of if __name__ == "__main__" in Python?

The if __name__ == "__main__" statement ensures that a block of code runs only when the file is executed directly, not when it is imported as a module.

def greet():
    print("Hello")

if __name__ == "__main__":
    greet()

Hello

Intermediate Python Interview Questions

30. What is slicing in Python?

Slicing is a technique used to extract a portion of a sequence such as a string, list, tuple or range. It allows to specify a starting index, an ending index and an optional step value.

Syntax: slice(start, stop, step)

l = [10, 20, 30, 40, 50]
res = slice(1, 4)
print(l[res])

[20, 30, 40]

31. Differentiate between List and Tuple?

Let’s analyze the differences between List and Tuple:

List

• Lists are Mutable datatype.
• Lists consume more memory
• The list is better for performing operations, such as insertion and deletion.
• The implication of iterations is Time-consuming

Tuple

• Tuples are Immutable datatype.
• Tuple consumes less memory as compared to the list
• A Tuple data type is appropriate for accessing the elements
• The implication of iterations is comparatively Faster

32. What is Dictionary Comprehension? Give an Example

Dictionary Comprehension is a concise way to create dictionaries from existing iterables. It allows to generate key-value pairs in a single line of code, making the code more readable and efficient.

keys = ['a', 'b', 'c', 'd', 'e']
values = [1, 2, 3, 4, 5]
d = {k: v for k, v in zip(keys, values)}
print(d)

{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

33. Is Tuple Comprehension possible in Python? If yes, how and if not why?

Tuple comprehensions are not directly supported, Python's existing features like generator expressions and the tuple() function provide flexible alternatives for creating tuples from iterable data.

(i for i in (1, 2, 3))

Explanation:

• In Python, expressions enclosed in parentheses with a for loop produce a generator expression, which generates values lazily one at a time.
• Since tuples are immutable sequences, Python does not provide a separate tuple comprehension syntax. Instead, the recommended approach is to use a generator expression and convert it into a tuple using tuple().

34. What is the difference between a shallow copy and a deep copy?

Below is the tabular difference between the Shallow Copy and Deep Copy:

35. What are Iterators in Python?

Iterators are used to iterate a group of elements, containers like a list. Iterators work on iterable objects such as lists, tuples and dictionaries. Python iterator implements __iter__() and the next() methods to iterate the stored elements. We generally use loops to iterate over the collections (list, tuple) in Python.

s = "GFG"
it = iter(s)

print(next(it))
print(next(it))
print(next(it))

G
F
G

36. What are Magic (Dunder) Methods in Python?

Magic methods are special methods whose names begin and end with double underscores. They allow developers to customize the behavior of objects. Common magic methods include:

• __init__()
• __str__()
• __repr__()
• __len__()

class Student:

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

    def __str__(self):
        return self.name

s = Student("Alice")
print(s)

Alice

37. What are Generators in Python?

Generators are a simple and memory-efficient way to create iterators in Python. They generate values one at a time only when needed, rather than storing all values in memory at once. A function becomes a generator if it contains the yield statement. Each time yield is executed, the function returns a value and pauses its execution. When the next value is requested, execution resumes from where it left off.

Generators automatically implement the __iter__() and __next__() methods, which allows them to be used directly in loops and with the next() function.

def fun(max):
    cnt = 1
    while cnt <= max:
        yield cnt
        cnt += 1

ctr = fun(5)
for n in ctr:
    print(n)

1
2
3
4
5

38. Which sorting technique is used by sort() and sorted() functions of python?

Python uses the Tim Sort algorithm for sorting. It’s a stable sorting whose worst case is O(N log N). It’s a hybrid sorting algorithm, derived from merge sort and insertion sort, designed to perform well on many kinds of real-world data.

39. What is the difference between sort() and sorted()?

sort()

• Sorts original list
• Changes existing list

sorted()

• Returns a new sorted list
• Does not modify original list

num = [3,1,2]

print(sorted(num))
print(num)

num.sort()
print(num)

[1, 2, 3]
[3, 1, 2]
[1, 2, 3]

40. Does Python supports multiple Inheritance?

When a class is derived from more than one base class it is called multiple Inheritance. The derived class inherits all the features of the base case.

Python does support multiple inheritances, unlike some programming languages that restrict multiple inheritance of classes. For example:

class A:
    def method_a(self):
        print("Method from class A")

class B:
    def method_b(self):
        print("Method from class B")

class C(A, B):
    pass

obj = C()
obj.method_a()
obj.method_b()

Method from class A
Method from class B

Explanation:

• A and B are parent classes, each defining one method.
• C(A, B) inherits from both parent classes.
• obj = C() creates an object of class C.
• The object obj can call methods from both A and B.

41. What is Method Resolution Order (MRO) in Python?

Method Resolution Order (MRO) defines the order in which Python searches for methods in classes when multiple inheritance is used. The MRO can be viewed using the mro() method.

class A:
    pass

class B(A):
    pass

class C(B):
    pass

print(C.mro())

[<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]

42. What is the purpose of the super() function in Python?

The super() function allows a child class to access methods and constructors of its parent class.

class Animal:

    def __init__(self):
        print("Animal")

class Dog(Animal):

    def __init__(self):
        super().__init__()
        print("Dog")

Dog()

Animal
Dog

43. What is Polymorphism in Python?

Polymorphism means "many forms." It allows same method name to perform different actions depending on the object that calls it. This is achieved through method overriding, where child classes provide their own implementation of a method defined in a parent class.

• The same method name can behave differently for different objects.
• Child classes can override methods of parent classes.
• It improves code flexibility and reusability.

class Animal:
    def sound(self):
        print("Some sound")

class Dog(Animal):
    def sound(self):
        print("Bark")

class Cat(Animal):
    def sound(self):
        print("Meow")

for animal in [Dog(), Cat()]:
    animal.sound()

Bark
Meow

Explanation:

• Dog and Cat override the sound() method of Animal.
• The same sound() method produces different outputs for different objects.
• This demonstrates polymorphism in Python.

44. Define encapsulation in Python?

Encapsulation is the process of hiding the internal state of an object and requiring all interactions to be performed through an object’s methods. This approach:

• Provides better control over data.
• Prevents accidental modification of data.
• Promotes modular programming.

Python achieves encapsulation through public, protected and private attributes.

45. How do you do data abstraction in Python?

Data Abstraction means providing only the essential details while hiding the implementation. It allows users to interact with an object through a simple interface without needing to understand its internal working. It's achieved using abstract base classes provided by the abc module. These classes define abstract methods that must be implemented by derived classes.

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

class Circle(Shape):
    def area(self):
        return 3.14 * 5 * 5

c = Circle()
print(c.area())

78.5

Explanation:

• Shape defines an abstract method area().
• Circle implements the area() method and Circle objects can use area() normally.
• The implementation details are hidden behind a common interface.

46. What are Decorators?

Decorators is a flexible way to modify or extend the behavior of functions or methods, without changing their actual code. A decorator is essentially a function that takes another function as an argument and returns a new function with enhanced functionality.

Decorators are often used in scenarios such as logging, authentication and memorization, allowing us to add additional functionality to existing functions or methods in a clean, reusable way.

47. What is a namespace in Python?

A namespace refers to a container where names (variables, functions, objects) are mapped to objects. In simple terms, a namespace is a space where names are defined and stored and it helps avoid naming conflicts by ensuring that names are unique within a given scope.

Types of Namespaces:

1. Built-in Namespace: Contains all the built-in functions and exceptions, like print(), int(), etc. These are available in every Python program.
2. Global Namespace: Contains names from all the objects, functions and variables in the program at the top level.
3. Local Namespace: Refers to names inside a function or method. Each function call creates a new local namespace.

48. How is memory management done in Python?

Python uses its private heap space to manage the memory. Basically, all the objects and data structures are stored in the private heap space. Even the programmer can not access this private space as the interpreter takes care of this space. Python also has an inbuilt garbage collector, which recycles all the unused memory and frees the memory and makes it available to the heap space.

Python manages memory automatically using a private heap, where all objects and data structures are stored. Python interpreter handles memory allocation and deallocation and an inbuilt garbage collector reclaims memory occupied by objects that are no longer in use.

• All objects and data structures are stored in a private heap.
• The Python interpreter manages memory allocation automatically.
• Programmers do not access the private heap directly.
• Python uses garbage collection to free unused memory.

49. How to delete a file using Python?

Python provides several ways to delete files, some of them are as following:

1. os.remove() deletes a file permanently.
2. send2trash.send2trash() moves a file to the recycle bin or trash. 
3. os.rmdir is used to remove empty directories, not files.

50. How do you debug a Python program?

1. Using pdb (Python Debugger): pdb is a built-in module that allows you to set breakpoints and step through the code line by line. You can start the debugger by adding import pdb; pdb.set_trace() in your code where you want to begin debugging.

import pdb
x = 5
pdb.set_trace()  # Debugger starts here
print(x)

Output

> /home/repl/02c07243-5df9-4fb0-a2cd-54fe6d597c80/main.py(4)<module>()
-> print(x)
(Pdb)

2. Using logging Module: For more advanced debugging, the logging module provides a flexible way to log messages with different severity levels (INFO, DEBUG, WARNING, ERROR, CRITICAL).

import logging
logging.basicConfig(level=logging.DEBUG)
logging.debug("This is a debug message")

Output

DEBUG:root:This is a debug message

51. What is the difference between xrange and range functions?

range() and xrange() were both used in Python 2 to generate sequences of numbers for iteration. In Python 3, there is no xrange, but the range function behaves like xrange.

• range(): returns a range object, which is an immutable sequence type that generates the numbers on demand. 
• xrange(): returns the generator object that can be used to display numbers only by looping. The only particular range is displayed on demand and hence called lazy evaluation.

Advanced Python Interview Questions & Answers 

52. What is PIP?

PIP stands for "Pip Installs Packages." It is Python’s standard package manager used to install, upgrade and manage third-party libraries and dependencies from the Python Package Index (PyPI).

• Used to install Python packages from PyPI.
• Comes pre-installed with most modern Python distributions.
• Supports installing, upgrading and uninstalling packages.
• Works from the command line.

pip install numpy

53. What is a zip function?

zip() function returns a zip object, which maps a similar index of multiple containers. It takes an iterable, converts it into an iterator and aggregates the elements based on iterables passed. It returns an iterator of tuples.

Syntax: zip(*iterables) 

names = ['Hiro', 'Mila', 'Tariq']
scores = [88, 94]
res = zip(names, scores)
print(list(res))

[('Hiro', 88), ('Mila', 94)]

54. Write a code to display the current time?

The datetime module provides the datetime.now() method, which returns the current local date and time. It is commonly used to display timestamps, log events, or retrieve the current system date and time.

from datetime import datetime
print("Current time is:", datetime.now())

Current time is: 2026-05-11 11:10:41.581886

55. What is __init__() in Python and how does self play a role in it?

__init__() is Python's equivalent of constructors in OOP, called automatically when a new object is created. It initializes the object's attributes with values but doesn’t handle memory allocation.

• Memory allocation is handled by the __new__() method, which is called before __init__().
• The self parameter in __init__() refers to the instance of the class, allowing access to its attributes and methods.
• self must be the first parameter in all instance methods, including __init__()

class MyClass:
    def __init__(self, value):
        self.value = value  # Initialize object attribute

    def display(self):
        print(f"Value: {self.value}")

obj = MyClass(10)
obj.display() 

Value: 10

56. What is the difference between __new__() and __init__()?

• __new__() creates a new instance of a class.
• __init__() initializes the created instance.

__new__() is called before __init__().

57. What are Access Specifiers in Python?

Python uses the ‘_’ symbol to determine the access control for a specific data member or a member function of a class. A Class in Python has three types of Python access modifiers:

• Public Access Modifier: Members declared normally (without any underscore) are public and can be accessed from anywhere.
• Protected Access Modifier: Members prefixed with a single underscore (_) are intended for internal use within the class and its subclasses. They can still be accessed from outside the class, but this is discouraged by convention.
• Private Access Modifier: Members prefixed with double underscores (__) are name-mangled by Python to make accidental access from outside the class more difficult.

class Student:
    def __init__(self):
        # Public
        self.name = "Mike"          
        # Protected
        self._roll_no = 101         
        # Private
        self.__marks = 95            

obj = Student()
print(obj.name)      
print(obj._roll_no)
print(obj._Student__marks)  

Mike
101
95

Explanation:

• name is a public attribute and can be accessed directly.
• _roll_no is a protected attribute, it is accessible outside the class but intended for internal use.
• __marks is a private attribute and is automatically renamed internally.
• obj._Student__marks accesses the private attribute using Python's name mangling mechanism.

58. What is the difference between @classmethod, @staticmethod and instance methods in Python?

• Instance Method: Operates on an instance of the class and has access to instance attributes and takes self as the first parameter.
• Class Method: Works with the class and takes cls as the first parameter. It is defined using @classmethod.
• Static Method: Does not access instance (self) or class (cls) data. It is defined using @staticmethod and is commonly used for utility functions related to the class.

class Student:
    school = "ABC School"

    def display(self, name):
        print(f"Student Name: {name}")

    @classmethod
    def show_school(cls):
        print(f"School: {cls.school}")

    @staticmethod
    def is_adult(age):
        return age >= 18

s = Student()
s.display("Kevin")
Student.show_school()
print(Student.is_adult(20))

Student Name: Kevin
School: ABC School
True

59. What are Pickling and Unpickling?

• Pickling: converts any Python object into a byte stream (not a string representation). This byte stream can then be stored in a file, sent over a network or saved for later use. The function used for pickling is pickle.dump().
• Unpickling: process of retrieving the original Python object from the byte stream (saved during pickling) is called unpickling. The function used for unpickling is pickle.load().

60. What are Exception Groups in Python?

Exception Groups are a feature introduced in Python 3.11 that allow multiple exceptions to be grouped together and handled in a structured way. They are particularly useful when several operations may fail independently, such as in concurrent or asynchronous programs.

ExceptionGroup class is used to combine multiple exceptions into a single object and the except* syntax is used to handle specific exception types within the group.

try:
    raise ExceptionGroup(
        "Example ExceptionGroup",
        [
            TypeError("Example TypeError"),
            ValueError("Example ValueError"),
            KeyError("Example KeyError"),
            AttributeError("Example AttributeError"),
        ]
    )
except* TypeError:
    print("Handled TypeError")
except* ValueError:
    print("Handled ValueError")
except* (KeyError, AttributeError):
    print("Handled KeyError and AttributeError")

Handled TypeError
Handled ValueError
Handled KeyError and AttributeError

61. What is a Context Manager in Python?

A context manager automatically manages resources such as files, network connections, or database connections. It is commonly used with the with statement.

with open("sample.txt", "r") as file:
    data = file.read()

Benefits:

• Automatically closes the file.
• Prevents resource leaks.
• Makes code cleaner and easier to read.

62. What are unit tests in Python?

Unit Testing is the first level of software testing where the smallest testable parts of the software are tested. This is used to validate that each unit of the software performs as designed. The unit test framework is Python’s xUnit style framework. The White Box Testing method is used for Unit testing.

import unittest
def add(a, b):
    return a + b

class TestAdd(unittest.TestCase):
    def test_addition(self):
        self.assertEqual(add(2, 3), 5)

if __name__ == "__main__":
    unittest.main()

Output

.
----------------------------------------------------------------------

Ran 1 test in 0.000s

OK

63. Python Global Interpreter Lock (GIL)?

Global Interpreter Lock (GIL) is a mechanism used in the CPython interpreter that allows only one thread to execute Python bytecode at a time. This simplifies memory management and makes the interpreter thread-safe.

• Python supports multithreading.
• In CPython, only one thread can execute Python bytecode at a time because of the GIL.
• The GIL mainly affects CPU-bound multithreaded programs.
• I/O-bound programs can still benefit from multithreading.
• Multiprocessing can be used to achieve true parallelism across multiple CPU cores.

64. What is the difference between Threading and Multiprocessing in Python?

Threading

• Uses multiple threads
• Shares memory
• Limited by the GIL for CPU-bound tasks

Multiprocessing

• Uses multiple processes
• Separate memory
• Not limited by the GIL

Threading is generally preferred for I/O-bound tasks, while multiprocessing is better suited for CPU-bound tasks.

65. What are async and await in Python?

async and await are used to write asynchronous programs that can perform multiple I/O operations concurrently without blocking execution.

import asyncio

async def greet():
    print("Hello")

asyncio.run(greet())

Hello

66. What are Function Annotations in Python?

• Function Annotation is a feature that allows you to add metadata to function parameters and return values. This way you can specify the input type of the function parameters and the return type of the value the function returns.
• Function annotations are arbitrary Python expressions that are associated with various parts of functions. These expressions are evaluated at compile time and have no life in Python’s runtime environment. Python does not attach any meaning to these annotations. They take life when interpreted by third-party libraries, for example, mypy.

67. What is Walrus Operator?

Walrus Operator allows to assign a value to a variable within an expression. This can be useful when you need to use a value multiple times in a loop, but don't want to repeat the calculation. It is represented by the `:=` syntax and can be used in a variety of contexts including while loops and if statements.

Note: Python versions before 3.8 doesn't support Walrus Operator.

numbers = [1, 2, 3, 4, 5]

while (n := len(numbers)) > 0:
    print(numbers.pop())

5
4
3
2
1

68. What is Python Switch Statement?

Python does not have a traditional switch statement like languages such as C, C++ or Java. Starting with Python 3.10, however, Python introduced structural pattern matching using the match and case keywords, which provides similar functionality.

value = 2

match value:
    case 1:
        result = "one"
    case 2:
        result = "two"
    case 3:
        result = "three"
    case _:
        result = "unknown"

print(result)

two

Relevant Resources

To do well in interviews, you need to understand core syntax, memory management, functions, recursion, data structures and practical coding problems.

1. Core Concepts: Strings, Lists, Tuples, Sets, Dictionaries. Pointers, Scope of Variables, Type Casting, File Handling, Memory Management
2. Advanced Topics: OOPs Concepts, Decorators, Generators, Lambda Functions, Packages, Class method vs Static method, Mutable vs Immutable Objects, Global Interpreter Lock.