'Coding has over 700 languages', '67% of programming jobs aren’t in the technology industry', 'Coding is behind almost everything that is powered by electricity'
Last Updated: Dec 31, 2023

Python Interview Questions

Author Aman Srivastava
Basics of python
Free guided path
7 chapters
99+ problems
Earn badges and level up



Python is a computer programming language that is easy to learn and read due to its simple syntax. It is used in web development, Data Science, and artificial intelligence applications. Python has an extensive library of tools and resources, making it popular among developers.

Python Interview Questions

This blog will dive deep into the frequently asked python interview questions.

Get the tech career you deserve, faster!
Connect with our expert counsellors to understand how to hack your way to success
User rating 4.7/5
1:1 doubt support
95% placement record
Akash Pal
Senior Software Engineer
326% Hike After Job Bootcamp
Himanshu Gusain
Programmer Analyst
32 LPA After Job Bootcamp
After Job

Python Interview Questions Freshers

1. What is Python? What are some of its key features?

Python is a high-level, interpreted programming language known for its simplicity and readability. Its key features include dynamic typing, automatic memory management, and a rich standard library. It also has strong community support and is used for various applications such as web development, data analysis, and machine learning.

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

Lists are mutable. Tuples are immutable. 
Denoted by square brackets.Denoted by parenthesis.
Slower due to dynamic resizing and modifications.Faster due to fixed size and immutability.

3. What is the difference between a set and a dictionary in Python?

It is a collection of unique elements.It is a collection of key-value pairs.
Created using the set() function.Created using the dict() function.

Also See, Intersection in Python

4. What is the use of the "self" keyword in Python?

In Python, "self" refers to the instance of a class that a method calls. It is typically used within a method to refer to instance variables or contact other instance methods. When a method calls on an instance of a class, the self keyword accesses the instance's attributes and methods.

5. What is a lambda function in Python?

In Python, a lambda function is a small, anonymous function that can have any number of arguments but can only have one expression. Lambda functions are a shorthand for creating simple functions that are only needed once. They are made using the lambda keyword, followed by the function's arguments and a colon, and then the expression for evaluation. 

Read about: Swapcase in Python 

6. What is the difference between "range" and "xrange" in Python 2. x?

In Python 2. x, "range" and "xrange" generate integer sequences. However, "range" yields a list of integers simultaneously, while "xrange" generates them on-the-fly as needed. It can be more memory-efficient when working with large ranges, as it generates only one number simultaneously. In Python 3. x, "range" has been modified to behave like "xrange," and "xrange" no longer exists. 

7. What is the purpose of the "init" method in Python?

In Python, the __init__ method is a unique method that looks like a constructor, though it is not. It is used for instantiating objects of a class. It initializes the object's attributes with default values or values passed during object creation. This method is commonly used to set up an object's initial state and can also be used to perform other initialization tasks.

8. How can you check the type of a variable in Python?

In Python, the type() function determines the type of a variable. For example, type(variable) will return the style of the variable.

Alternatively, the isinstance() function can be used to check if a variable is an instance of a particular class. For example, isinstance(variable, int) will return True if the variable is an instance of the int class.

9. What is the difference between "is" and "==" in Python?

The "is" operator checks if two objects are the same object in memory. It returns True if both objects are identical, meaning they have the same memory address.

On the other hand, the "==" operator checks if two objects have the same value. It returns True if the values of the two objects are equal, regardless of whether they are the same object in memory.

10. What are decorators in Python, and how are they used?

In Python, decorators are functions that help the compiler know about the unique property associated with a particular function. By wrapping a function with another function, decorators can modify the input or output values of the function or add functionality to it before or after it executes. Decorators are often used to add cross-cutting concerns like logging, caching, or authentication in a reusable manner.

11. What is Python, and how is Python useful?

Python is a high-level, interpreted programming language first released in 1991. It is open-source, meaning the source code is freely available for modification and distribution. 

Python's popularity is due to its simple and readable syntax, versatility, and ease of use. It has a large standard library and a vast array of third-party libraries and frameworks that allow developers to build complex applications quickly and efficiently.

Python is useful in the following ways:

  • Python is useful for various applications, including web development, scientific computing, data analysis, machine learning, artificial intelligence, and automation. It is used by organizations such as Google, NASA, and Netflix and is also widely used in academia.
  • One of the main advantages of Python is its simplicity and readability. The syntax is easy to understand and write, making it accessible to every programmer.
  • Python also strongly focuses on code readability, making it easier for people to collaborate on projects and maintain code over time.
  • Another advantage of Python is its versatility. It can be used for various applications, from building simple scripts to creating complex applications with graphical user interfaces. 

12. How do you create a function in Python? 

def keyword is used to create a function in Python, followed by the name of the function and any parameters the function will accept in parentheses. The code inside the function should be indented to show that it is a part of it. Here is an example:

  • Python


def calculate_rectangle_area(length, width):
area = length * width
return area

# Call the function with arguments 5 and 10
result = calculate_rectangle_area(5, 10)

# Print the result



This function takes two parameters, length and width, and calculates the area of a rectangle using the formula area = length * width. The return statement returns the value of the area.

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

A list is a mutable data type in Python that uses square brackets [] to store an ordered collection of items.

On the other hand, a tuple is an immutable data type in Python that uses parentheses () to store an ordered collection of items. Tuples are faster and more memory-efficient than lists, especially for larger data collections.

SyntaxSquare brackets []Parentheses ()
LengthCan change lengthFixed length
PerformanceSlower for large listsFaster for large tuples
Use casesUsed for dynamic dataUsed for static data
Example declarationfruits = ['apple', 'banana']fruits = ('apple', 'banana')

14. What is a module in Python?

A module in Python is a file containing Python code that can be used in other Python programs.

A module is a self-contained unit of code that can include variables, functions, and classes that can be accessed and used in other Python programs. By organizing code into modules, you can avoid duplicating code across different programs and instead import and use the same code in multiple places, making it easier to maintain and reuse your code.

Python has many built-in modules that can be used for various purposes, such as working with files, network communication, data processing, and more. In addition, third-party modules can be installed and used in Python programs to extend their functionality.

To use a module in a Python program, you first need to import it using the import statement. Here is an example:

  • Python


import math
result = math.sqrt(12)



15. What is the difference between break and continue in Python?

Break and Continue are two keywords in Python that are used to change the flow of a loop. These keywords are used inside loops, such as for and while loops.

Both keywords are used to change the flow of a loop, but they have different effects on the loop:

  • Break - It exits the loop entirely and continues with the next statement after the loop.
  • Python


for i in range(10):
if i ==5:




  • Continue- It skips the current iteration and moves on to the next iteration of the loop.
  • Python


for i in range(10):
if i == 5:



16. How do you iterate over a list in Python? 

Let's consider the following code to explain iteration over a list in Python.

  • Python


numbers = [1, 2, 3, 4, 5]
for num in numbers:
if num % 2 == 0:
print(num, "is even")
print(num, "is odd")


1 is odd
2 is even
3 is odd
4 is even
5 is odd

Explanation: We have a list called numbers containing five integers. We use a for loop to iterate over the list, and on each iteration, we assign the current item in the list to the variable num. Then, we check if the number is even or odd using the modulus operator (%) and print out the result.

The 'for' loop iterates over the list from the first to the last item and executes the indented code block once for each item.

17. What is a dictionary in Python? 

A dictionary is a collection of key-value pairs that store and retrieve data. In other words, a dictionary is like a map that connects keys to values.


  • Python


student = {
"name": "Jaideep",
"age": 22,
"major": "Computer Science"


Computer Science

18. Write a Python factorial program without using if-else, for, and ternary operators.

We can use a recursive function that calculates the factorial of a given number without using if-else, for, and ternary operators:

The function recursively calls itself until it reaches the base case of n=1, at which point it returns 1. Each recursive call multiplies the current value of n by the result of the previous call, effectively calculating the factorial.

  • Python


def factorial(n):
return (n==1) or (n * factorial(n-1))



19. Write a Python code to check the Armstrong number.

  • Python


number = int(input("Enter a number: "))
order = len(str(number))
sum = 0
temp = number

while temp > 0:
digit = temp % 10
sum += digit ** order
temp //= 10

if number == sum:
print(number, "is an Armstrong number")
print(number, "is not an Armstrong number")


Enter a number: 34
34 is not an Armstrong number

20. What is the difference between deep and shallow copying of an object in Python?

Shallow copying creates and populates a new object referencing the original object's data. Suppose the original object contains mutable objects as elements. In that case, the new entity will reference the same mutable objects, and changes to the mutable objects are reflected in both the new and original objects. 

Deep copying creates a new object and recursively copies the original object's data and the data of any things it references. It means that the new entity and its simulated data are entirely independent of the original object and its data.

21. How does garbage collection work in Python?

In Python, garbage collection is the process of freeing up memory unused by the program. Python automatically uses a built-in system that counts how often an object is used. If the count goes to zero, the object is considered garbage and removed from memory. 

22. What is the difference between append() and extend() methods in Python lists?

In Python, both append() and extend() methods are used to add elements to a list, but they have some differences in functionality.

  • append() method: This method adds a single element to the end of a list. The element can be of any type, including another list.
  • extend() method: This method adds multiple elements to a list, such as elements from another list, tuple, or any iterable object. The elements are added one by one to the end of the list.

23. What is the purpose of the "yield" keyword in Python?

The "yield" keyword in Python creates generator functions that can produce a sequence of values. When we call a function with a "yield" statement, it returns a generator object. The generator object helps to iterate over the values produced by the function. The generator has values on-the-fly as it repeats over, which makes it a memory-efficient way to generate sequences.

24. What is the difference between "static method" and "class method" in Python?

A static method is a method bound to the class, not an instance of the class. It means it calls the class without creating an instance. Static methods define utility functions that don't depend on the state of the example or the class.

A class method is also bound to the class, but it takes a reference to the class itself as the first argument. Defined methods operate on the class itself rather than on the instances of the class. Class methods are alternative constructors for the class, which can create class instances with different initial parameters.

25. How can you create a generator in Python?

A generator is created using a function that contains the "yield" keyword. As the generator function is created, it returns a generator object to produce a sequence of values on-the-fly as the generator iterates. To create a generator function, define a function that contains one or more "yield" statements. Each "yield" statement should produce a value for the generator to return.

26. What is the difference between "map" and "filter" functions in Python?

"map" and "filter" are built-in functions operating on iterable objects. The main difference between the two functions is that "map" applies a given function to each item in an iterable and returns an iterator with the results. In contrast, "filter" applies a given function to each item in an iterable and returns an iterator with only the things that meet the given condition.

27. How can you handle exceptions in Python?

Exceptions are handled using a try-except block. The code that may raise an exception is put inside the "try" block, and the exception handler is inside the "except" block. If the try block raises an exception, the program flow is immediately transferred to the except block.

The except block can be used to catch a specific or general exception and handle the exception by providing an appropriate message to the user or performing other actions. We can also use it to raise a new exception or re-raise the original exception. 

28. What is the difference between a "module" and a "package" in Python?

A module is a single file containing Python code that can be imported and used in other Python codes. A module typically includes functions, classes, and variables used in other programs. Modules are a way to organize code and promote code reuse.

On the other hand, a package is a collection of related modules organized into a directory structure. A package contains an init.py file executed while package importing. The init.py file can contain initialization code and define the package's interface by specifying which modules are part of the package. 

29. What are some of the built-in data structures in Python, and how are they used?

Python has multiple built-in data structures, including lists, tuples, sets, and dictionaries, which store and organize data differently.

  1. Lists: Lists are ordered collections of items of different types. They are defined by enclosing a comma-separated list of values in square brackets. Lists are mutable, meaning you can remove, add or modify their items.
  2. Tuples: Tuples are similar to lists but immutable, meaning you cannot change their values once they are defined. Tuples are defined by enclosing a comma-separated list of values in parentheses.
  3. Sets: Sets are unordered collections of different items. They are defined by enclosing a comma-separated list of values in curly braces. Sets are helpful when you want to eliminate duplicates from a collection of objects.
  4. Dictionaries: Dictionaries are collections of key-value pairs. They are defined by enclosing a comma-separated list of key-value teams in curly braces, with a colon separating each key and its corresponding value. Dictionaries are helpful when looking up a particular key's value.

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

Mutable data types are those whose values can be changed after creation. When you modify a mutable object, it changes its value in place without creating a new object. Any other references to the object will also see the change.

On the other hand, immutable data types are those whose values cannot be changed after creation. When you modify an immutable object, you create a new object with the modified value. Any other references to the original object will not see the change.

Mutable datatype and an Immutable data type

31. What is the difference between '==' and 'is' in Python? 

In Python, the == operator and the is operator are used to compare two objects. However, they have different meanings and are used in different contexts.

The == operator compares the values of the objects, while the is operator checks whether the two objects are the same, i.e., whether they have the same identity.

== operatoris operator
It compares the values of two objects.It checks whether two objects are the same object.
It returns True if the values of two objects are equal.It returns True if two variables reference the same object in memory.
It returns False if the values of two objects are not equal.It returns False if two variables do not reference the same object in memory.
It is used for value comparison.It returns False if two variables do not reference the same object in memory.
Examples: a == b, x == 42.Examples: a is b, x is None.


  • Python


a = [4, 2, 1]
b = [4, 2, 1]
c = a
print(a == b)
print(a is b)
print(a is c)




  • True - the values of the objects are the same.
  • False - the objects have different identities.
  • True - both variables reference the same object in memory.

32. What is the difference between a shallow copy and a deep copy in Python?

The difference between a shallow copy and a deep copy in python are as follows:

Features Shallow CopyDeep Copy
DefinitionA shallow copy creates a new object but references the same memory addresses as the original object for the nested objects.A deep copy creates a new object with new memory addresses for the main object and any nested objects.
Syntaxnew_object = old_object.copy() or new_object = list(old_object)new_object = copy.deepcopy(old_object) or new_object = list(old_object).
Changes to nested objectsAny changes to the nested objects will reflect in both the original and copied objects.Changes made to the nested objects in the copied object will not reflect in the original object.
SpeedIt is faster than a deep copy because it does not create a new object for nested objects.Slower than a shallow copy because it creates a new object for each nested object.
Memory UsageLess memory usage because it shares memory addresses for nested objects.More memory usage because it creates new memory addresses for each nested object.

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

In Python, arguments are generally passed by reference, but how it works can be confusing.

When you pass an object to a function in Python, a reference to that object is passed to the function. This means that the function can modify the object, and those modifications will be reflected in the calling code.


  • Python


def modify_list(my_list):

# create a list
my_list = [1, 2, 3]

# call the modify_list function

# print the list


[1, 2, 3, 4]

Explanation: In this example, the ‘modify_list’ function modifies the original list by appending the value 4. When the function returns, the modified list is still accessible in the calling code.

However, there are some cases where it appears that Python is passing arguments by value. For example, when you pass an integer or a string to a function and modify it within it.

In conclusion, arguments in Python are generally passed by reference, which means that modifications made to objects within a function can affect the original object in the calling code. However, the behavior can vary depending on the type of object being passed since immutable objects like strings, and integers cannot be modified in place.

34. How to convert a list into a set?

To convert a list into a set in Python, you can use the built-in set() function. This function takes an iterable object (such as a list) as input and returns a new set object that contains all the unique elements in the iterable.

  • Python


my_list = [1, 2, 3, 3, 4, 4, 5]
my_set = set(my_list)


{1, 2, 3, 4, 5}


In the above code, we first define a list my_list containing duplicate elements. We then pass this list to the set() function to create a new set object, my_set, that contains only the unique elements of the original list.

Note that sets are unordered collections of unique elements, so the order of the elements in the original list may not be preserved in the resulting set.

35. How can you create Empty NumPy Array In Python?

You can create an empty NumPy array in Python using the numpy.empty() function. This function creates an array of a specified size and shape but with uninitialized entries. 

Here's an example:

  • Python


import numpy as np
# Create an empty array with shape (3, 4)
empty_arr = np.empty((3, 4))

This code will output an empty array of shape (3, 4), which means it has 3 rows and 4 columns, but with no values assigned to any of its entries:


[[1.86780114e-316 0.00000000e+000 5.31998820e-317 6.90266114e-310]
[6.90266150e-310 5.31998820e-317 6.90266114e-310 6.90266114e-310]
[6.90266114e-310 6.90266115e-310 5.31998820e-317 6.90266083e-310]]

As you can see, the array entries are uninitialized, containing whatever values were already in the memory space where the array was created. If you want to create an empty array with initialized entries, you can use the numpy.zeros() function instead.

36. What are Pickling and Unpickling? 

Pickling and unpickling are processes used in Python to serialize and deserialize objects. Serialization converts an object into a byte stream, which can be stored or transmitted over a network. Deserialization transforms a sequence of bytes, typically stored in a file or transmitted over a network, back into an object in memory that can be manipulated and used by a program.

  • Pickling converts a Python object hierarchy into a byte stream using the pickle module. This byte stream can be saved to a file or sent over a network. The pickle module can handle most Python objects, including complex data types such as lists, sets, and dictionaries.
  • Unpickling is the reverse process of pickling. It involves reading a byte stream and reconstructing the original Python object hierarchy. This is done using the pickle.load() function.

37. Write a code snippet to get an element, delete an element, and update an element in an array. 

  • Python


import numpy as np
# Create an array
arr = np.array([1, 2, 3, 4, 5])

# Get an element
element = arr[2]
print("Element at index 2:", element)

# Delete an element
arr = np.delete(arr, 3) # Delete element at index 3
print("Array after deleting element at index 3:", arr)

# Update an element
arr[1] = 6 # Update element at index 1 to 6
print("Array after updating element at index 1:", arr)


Element at index 2: 3
Array after deleting element at index 3: [1 2 3 5]
Array after updating element at index 1: [1 6 3 5]

38. What is a lambda function? How are these written in Python?

An anonymous function is also known as a lambda function. It can have any number of parameters but can have just one statement.

  • Python


v = lambda p,q : p+q
print(v(7, 5))



39. How to reverse lists in Python using slicing?

[::-1] is used to reverse the order of an array or a sequence.
For example

  • Python


import array as arr


array(‘i’, [5, 4, 3, 2, 1]) 

[::-1] reprints the array as a reversed copy of ordered data structures such as an array or a list. The original array or list remains unchanged.

l = [ 'a','b','c','d','e' ]


[ ‘e’, ‘d’, ‘c’, ‘b’, ‘a’ ] 

40. How can random numbers be generated in Python?

The Random module is a standard module that is used to generate a random number. The method is defined as:

import random

The statement random.random() method returns a floating-point number in the range of [0, 1). This function generates random float numbers. Here, The methods used with the random class are the bound methods of the hidden instances. The 'random' module instances can show the multithreading programs that create different examples of individual threads. 

41. What is the difference between range & ‘xrange’?

For the most Part, 'xrange' and 'range' have the same functionality. They both provide a way to generate a list of integers to use; however, you please. The only difference is that 'range' returns a Python list object while 'xrange' returns an 'xrange' object.
This means that 'xrange' doesn't generate a static list at run-time as 'range' does. It creates the values as you need them with a unique technique called yielding. This technique is used with a type of object known as generators. That means that if you have a vast range, you'd like to generate a list for, say, one billion, 'xrange' is the function to use.
This is especially true if you have an accurate memory sensitive system such as a cell phone that you are working with, as the 'range' function will use as much memory as it can to create your array of integers, which can result in a Memory Error and crash your program. The 'range' function is a memory hungry beast. 

42. How can you randomise the items of a list in place in Python? 

  • Python


from random import shuffle
x = ['This', 'sentence', 'will', 'be', 'shuffled', 'now']


['sentence', 'This', 'will', 'shuffled', 'be', 'now']

Every time output can be random.

43. What is the concept of pickling and unpickling in Python?

Python library offers a feature - serialisation out of the box. Serialising an object refers to transforming it into a format that it can store to deserialise it, later on, to obtain the original thing. Here, the pickle module comes into play. It accepts any Python object, converts it into a string representation, and dumps it into a file using the dump function; this process is called pickling. In contrast, the process of retrieving original Python objects from the stored string representation is called unpickling.

The process of serialisation in Python is known as pickling. Using the concept of 'pickling', any object in Python can be serialised into a byte stream and dump it as a file in the memory. The process of pickling is compact, but it can compress pickle objects further. Moreover, pickle keeps track of the serialised objects, and the serialisation is portable across versions.
The function is used for the above process 'pickle.dump()' from the pickle module in Python.

Unpickling is the opposite of pickling. It deserialises the byte stream to recreate the objects stored in the file and loads them in the memory.
The function is used for the above process 'pickle.load()'.

unpickling in Python

Image Source - Here

44. What are the generators in Python?

Functions that return an iterable set of items are called generators.
Generators are functions that return iterable collection of items, one at a time, in a fixed manner. Generators, generally, are used to create iterators with a different approach. They employ the use of yield keywords rather than return to return a generator object.
Let's try and build a generator for Factorials of numbers -

## generate factorials of numbers upto n
def factorial(n):
   i = 1
   fact = i
   while(i < n):
       fact *= i
       yield fact
       i += 1

a = factorial(8)    # create generator object 
## iterating using __next__(), for Python2, use next()
a.__next__()    # output => 1
a.__next__()    # output => 2
a.__next__()    # output => 6
a.__next__()    # output => 24
a.__next__()    # output => 120
a.__next__()    # output => 720
a.__next__()    # output => 5040
a.__next__()    # error
## iterating using loop
for i in factorial(10):
   print(i) # output => 1 2 6 24 120 720 5040 40320 362880 3628800

45. What are iterators in Python?

An iterator is an object.
It remembers the state, i.e., where it is used during iteration.
__iter__() method initializes an iterator.
It has a '__next__() ' method which returns the next item in iteration and points to the next element. Upon reaching the end of the iterable object, '__next__()' must return a StopIteration exception.
It is also self-iterable.
Iterators are objects using which we can iterate over iterable things like lists, strings, etc.

class LinkedList:
	def __init__(self, lst):     
       self.numbers = lst
   def __iter__(self):
       self.pos = 0
       return self
   def __next__(self):
       if(self.pos < len(self.numbers)):
           self.pos += 1
           return self.numbers[self.pos - 1]
           raise StopIteration

arr_obj = LinkedList([‘A’, ‘B’, ‘C’])
it = iter(arr_obj) # initialising an iterator object
print(next(it)) # output: ‘B’
print(next(it)) # output: ‘C’
# Throws Exception
# Traceback (most recent call last):
# ...
# StopIteration

46. What does '*args' and '**kwargs' stand for in Python? 

  • *args
    *args is a particular parameter used in the function definition to pass arguments with a variable number of items.
    "*" means variable length, and "args" is a name used as a convention.
def add(x, y, *args):
	add = a + b 
	for num in args:
       add += num
    return add
print(add(1, 2, 3, 4, 5)) # output: 15


  • **kwargs
    **kwargs is a special syntax used as the function definition to pass a variable-length keyword argument. Here, also, "kwargs" is used just as a convention. It can also use any other name to represent "kwargs" here.
    Keyworded argument means a variable that has a name when passed to the function. It is a dictionary of the variable terms and their value.
def KeyArguments(**kwargs):
   for key, value in kwargs.items():
       print(key + ": " + value)
KeyArguments(arg1 = "item 1", arg2 = "item 2", arg3 = "item 3")
# output:
# arg1: item 1
# arg2: item 2
# arg3: item 3

47. What are modules and packages in Python?

Python packages and Python modules are two mechanisms that allow for modular programming in Python. Modularizing has several advantages -

  • Simplicity: Working on single modules helps you focus on a relatively small portion of the existing problem. This makes development more manageable and less prone to errors.
  • Maintainability: Modules are designed to enforce the logical boundaries between different problem domains. If they are written to reduce interdependency, it is less likely that the modifications in a module might also impact other parts of the program.
  • Reusability: Functions defined in a module can easily be reused by the other parts of the application.
  • Scoping: Modules are typically defined as separate namespaces, which help avoid confusion between identifiers from other aspects of the program.

Modules are simply Python files with a '.py' extension and can have a set of functions, classes and variables defined. They can be imported and initialised using import statements if partial functionality is required to import the requisite classes or processes, such as the foo import bar.

Packages provide for hierarchical structuring of the module namespace using a '.' dot notation. As modules help avoid clashes between global and local variable names, similarly, packages can help prevent conflicts between module names.
Creating a package is easy since it also uses the system's inherent file structure that exists. Modules combined into a folder are known as packages. Importing a module or its contents from a package requires the package name as a prefix to the module's name joined by a dot.

48. How can one create classes in Python?

To create a class in Python, we use the keyword "class", as shown in the example below:

class Employee:
   def __init__(self, employee_name):
       self.name = employee_name

To instantiate or create the object from the class created above, we do the following:

employee = Employee("Jeff")

To access the name attribute, we call the attribute using the dot operator as shown below:

# Prints -> Jeff

49. How do you initialise an empty class in Python?

An empty class does not have any members defined inside it. It is created using the 'pass' keyword (the pass command does nothing in Python). We can make all the objects for this class outside the class.
For example-

  • Python


class EmptyClass:
obj = EmptyClass()
obj.name = "Arun"
print("Name created = ", obj.name)


Name created = Arun

50. How are access specifiers used in Python?

Python does not use access specifiers precisely like private, public, protected, etc. However, it does not deprive it to any variable. It has the concept of imitating variables' behaviour using a single (protected) or double underscore (private) as prefixed to variable names. By default, variables without prefixed underscores are public.

# to demonstrate access specifiers
class Employee:
    # protected members
    _name = None
    _age = None
    # private members
    __department = None
    # constructor
    def __init__(self, emp_name, age, department): 
         self._name = emp_name
         self._age = age
         self.__department = department
    # public member
    def display():
        print(self._name + " "+ self._age + " " + self.__department)

Python Interview Questions and Answers for Experienced

51. Does python support 'multiple inheritance'? How does it work in Python? Explain with an example.

Multiple Inheritance: This is achieved when one child class derives its members from more than one parent class. All the features of parent classes are inherited in the child class.

work in Python

Image Source - Here

  • Python


# Parent class1

class Parent1:

  def parent1_func(self):

      print("Hi I am the first Parent")

# Parent class2

class Parent2:

  def parent2_func(self):

      print("Hi I am the second Parent")

# Child class

class Child(Parent1, Parent2):

  def child_func(self):



# Driver's code

obj1 = Child()



Hi, I am the first Parent
Hi, I am the second Parent. 

52. Is it possible to call parent class without its instance creation?

Yes, it is possible if other child classes instantiate the base class or if the base class is a static method.

53. What is __init__?

'__init__' is a method or constructor in Python. This method automatically allocates memory when a new object/ instance of a class is created. All classes have the '__init__' method.
Example to show how to use it:

  • Python


class Employee:

   def __init__(self, name, age, salary):

       self.name = name

       self.age = age

       self.salary = 20000

E1 = Employee("XYZ", 23, 20000)

# E1 is the instance of class Employee.

# __init__ allocates memory for E1.






54. How can parent members be accessed inside a child class?

Following are the ways using which you can access parent class members within a child class:
By using the name of the Parent class: You can use name of the parent class to access attributes as shown in the example below:

class Parent(object):  

   # Constructor

   def __init__(self, name):

       self.name = name    


class Child(Parent): 

   # Constructor

   def __init__(self, name, age):

       Parent.name = name

       self.age = age


   def display(self):

       print(Parent.name, self.age)


# Driver Code

obj = Child("ChildClassInstance", 9)


55. Give an example of how is the 'super' function used in Python?

Using super(): The parent class members can access the super keyword in the child class.

class Parent(object):

   # Constructor

   def __init__(self, name):

       self.name = name    


class Child(Parent):

   # Constructor

   def __init__(self, name, age):         


       In Python 3.x, we can also use super().__init__(name)


       super(Child, self).__init__(name)

       self.age = age


   def display(self):

      # Note that Parent.name can’t be used 

      # here since super() is used in the constructor

      print(self.name, self.age)


# Driver Code

obj = Child("ChildClassInstance", 9)


56. How can you check if a class is a child of another class?

This is done by using a method called 'issubclass()' present in Python. The method tells if any class is a child of another class by returning true or false accordingly.
Example to show how to use it:

class Parent(object):


class Child(Parent):


# Driver Code

print(issubclass(Child, Parent))    # True

print(issubclass(Parent, Child))    # False

We can check if an object is also an instance of a class by making use of isinstance() method:

obj1 = Child()

obj2 = Parent()

print(isinstance(obj2, Child))    # False 

print(isinstance(obj2, Parent))   # True 

57. Write a one-liner to count the number of capital letters in a file. The code should work even if the file is too big to fit in memory.

Let us first work out a multiple line solution and then simplify it to a one-liner code.

with open(SOME_LARGE_FILE) as fh:

count = 0

text = fh.read()

for character in text:

    if character.isupper():

count += 1

We will now try to transform it into a single line.

count = sum(1 for line in fh for character in line if character.isupper())

58. What is the 'main' function in Python? How do you invoke it?

In the world of programming languages, the 'main' function is considered as an entry point for the execution for a program. But in Python, this is known that the interpreter serially interprets the file line-by-line. This means that Python does not provide the 'main()' function explicitly. But this doesn't mean that it a cannot simulate the execution of 'main'. It can do this by defining the user-defined 'main()' function and using the python file's '__name__' property. This '__name__' variable is a particular built-in variable that points to the current module's name. This can be done as shown below:

  • Python


def main():
  print("Hi Ninja!")
if __name__ == "__main__":

Output : 

Hi Ninja!

59. Are there any tools for identifying bugs and performing static analysis in Python?

Yes, tools like PyChecker and Pylint are used as a static analysis and linting tools, respectively. PyChecker helps find bugs in a python source code file and raises alerts for code issues and complexity. Pylint checks for a module's coding standards and supports different plugins to enable custom features to meet this requirement.

60. What are unit tests in Python?

Unit test is a unit testing Python framework.
Unit testing means testing various components of software separately. Can you think about why it is essential? Imagine a scenario; i.e. you are building software that uses three parts, namely A, B, and C. Suppose your software breaks at some point. How can one find which component was responsible for breaking the software? Maybe it was the component A that failed, which failed component B, which failed the software. There can be many such type of combinations.
This is why it becomes necessary to test all components properly to know which Part might be responsible for the failure of the software.

61. What are decorators, and how are they used in Python?

Decorators in Python are the functions that add functionality to an existing function in Python without changing the structure of the function itself. They are represented by the @decorator_name in Python and are called in a bottoms-up fashion. For example:

# decorator function to convert to lowercase

def lowercase_decorator(function):

   def wrapper():

       func = function()

       string_lowercase = func.lower()

       return string_lowercase

   return wrapper

# decorator function to split words

def splitter_decorator(function):

   def wrapper():

       func = function()

       string_split = func.split()

       return string_split

   return wrapper

@splitter_decorator # this is executed next

@lowercase_decorator # this is executed first

def hello():

   return 'Hello World'

hello()   # output => [ 'hello' , 'world' ]

The beauty of a decorator lies in the fact that besides adding functionality to the output of the method, they are can even accept arguments for functions and can further modify those arguments before passing them to the function itself. The are inner nested function, i.e. 'wrapper' function, plays a significant role here. It is implemented to enforce encapsulation and thus, keep itself hidden from the global scope.

# decorator function to capitalize names

def names_decorator(function):

   def wrapper(arg1, arg2):

       arg1 = arg1.capitalize()

       arg2 = arg2.capitalize()

       string_hello = function(arg1, arg2)

       return string_hello

   return wrapper


def say_hello(name1, name2):

   return 'Hello ' + name1 + '! Hello ' + name2 + '!'

say_hello('sara', 'ansh')   # output => 'Hello Sara! Hello Ansh!'

62. What are Python packages?

Python packages are namespaces containing multiple modules such as “os”, “sys”, “json”, “pandas” etc.

Read more about, Fibonacci Series in Python

63. What is the 'pandas' library used in Python? How is a 'pandas' data frame created?

Pandas is an open-source, python library used in data manipulation of applications that require high performance. The name is derived from "Panel Data", that has multidimensional data. It was developed in 2008 by Wes McKinney and designed for data analysis.
Pandas help perform five significant data analysis steps: load the data, clean/manipulate it, prepare it, model it, and analyse it.
A data frame is a 2D mutable and tabular structure representing data labelled with axes - rows and columns.
The syntax for creating data frame:

import pandas as pd

dataframe = pd.DataFrame( data, index, columns, dtype )

Data - Represents various forms such as series, map, ndarray, lists, dict etc.
index - Optional arguments that represent an index to row labels.
columns - Optional argument for column labels.
Type - the data type of each column. Again optional.

64. How can different pandas data frames be combined?

The data frames can be combined using the approaches below :

append() method: It is used to stack the data frames horizontally. 



concat() method: This is used to stack data frames vertically. This is best used when the data frames have the same columns fields.


PD.concat([df1, df2]) 

join() method: It is used for extracting data from various data frames having one or more common columns.


65. Can you create a series from the dictionary object in pandas?

One-dimensional array capable of storing different data types is called series. We can create pandas series from dictionary object as shown below:

  • Python


import pandas as pd    

dict_info = {'key1' : 2.0, 'key2' : 3.1, 'key3' : 2.2} 

series_obj = pd.Series(dict_info)   

print (series_obj)  


x     2.0
y     3.1
z     2.2
dtype: float64

If the index is not specified in the input method the keys of the dictionaries are sorted in ascending order for constructing the indices. If the index is passed, then it will extract values of the index label from the dictionary.

66. How will you identify and deal with missing values in a data frame?

We can identify if a data frame has missing values by using the 'IsNull()' and 'isna()' methods.

Missing_data_count = df.isnull().sum()

We can handle missing values here by either replacing the values in the columns with 0 as follows:


Or by replacing it by the mean value of the column

df['column_name'] = df['column_name'].fillna(   

67. How to add a new column to pandas dataframe?

A new column can be added to pandas dataframe as follows:

import pandas as pd      
data_info = {'first' : pd.Series([1, 2, 3], index = ['a', 'b', 'c']),    
       'second' : pd.Series([1, 2, 3, 4], index = ['a', 'b', 'c', 'd'])}    
df = pd.DataFrame(data_info)    
# To add new column third
df['third']=pd.Series([10,20,30], index= ['a','b','c'])    
# To add new column fourth
df['fourth'] = df['first'] + info['third']    

68. How will you delete indices, rows and columns from a data frame? 

To delete an Index:
Execute the 'del df.index.name' for removing the index by name.
Alternatively, the df.index. It can assign a name to None.
For example, if you have the below data frame:

Column 1


   John               1

   Jack               2

   Judy               3

   Jim                4

To drop the index name “Names”:

df.index.name = None

# Or run the below:

# del df.index.name


        Column 1

John          1

Jack          2

Judy          3

Jim           4

To delete row/column from a data frame:

  • 'drop()' method is used to delete row/column from a data frame.
  • The axis argument is passed in order to the drop method if the value is 0, it signals to drop/delete a row and a column if it's 1.
  • Additionally, we can try to delete rows/columns in-place by setting the value of 'inplace' to True. This makes sure that it is deleted without the need for reassignment.
  • It can delete the duplicate values from the row/column by using the drop_duplicates() method.

69. How can the first row be re-indexed as the name of the columns in pandas?

new_header = df.iloc[0] # grab the first row for the header

df = df[1:] # take the data less the header row

df.columns = new_header # set the header row as the df header

70. What do you understand by reindexing in pandas?

Reindexing is the process of confirming a data frame to a new index with optional filling logic. If the values are missing in previous index, 'NaN/NA' is placed in the location. A new object is returned to it unless a new index is produced equivalent to the current one. The copied value is set to False. This is also used for changing the indices of rows and columns in the data frame.

71. What is the difference between a "generator" and a "coroutine" in Python?

A generator is an iterator that generates values on the fly as needed. It is defined using the yield keyword and iterates over a "for" loop or calling the next() function. Generators are useful for generating large sequences of values that may be too large to store in memory. 

On the other hand, a coroutine is a special kind of function that can be paused and resumed at specific points. It is defined using the async def syntax and iterates using an async for loop or by calling the await function. Coroutines help perform asynchronous operations, such as network or database I/O, without blocking the main thread of execution.

72. How does Python's Global Interpreter Lock (GIL) affect multithreading and multiprocessing?

The Global Interpreter Lock (GIL) is the Python interpreter's mechanism to ensure that only one thread can execute Python bytecode at a time.

  1. In the case of multithreading, Python threads cannot take full advantage of multiple CPU cores to perform parallel processing. While threads can be helpful for I/O-bound tasks, they could be better suited for CPU-bound tasks that require intensive computation. In these cases, multiprocessing can be a better option.
  2. Multiprocessing involves running multiple instances of the Python interpreter in parallel, each with its own GIL. It allows for parallel processing on multi-core machines, as each process can utilize a separate CPU core.

73. What are some ways to improve a Python application's performance?

There are several ways to improve the performance of a Python application:

  1. Use efficient algorithms and data structures: Inefficient algorithms or data structures can lead to unnecessary computational overhead, slowing down the performance of your application.
  2. Optimise code with profiling: Profiling measures your code's performance to identify bottlenecks and areas to be optimized. Python has several built-in profiling tools, such as cProfile and time, to help you identify performance issues.
  3. Utilise built-in functions and libraries: Python has an extensive standard library with many built-in functions and modules optimized for performance.
  4. Implement parallelism with multiprocessing: Python's Global Interpreter Lock (GIL) can limit the performance of multi-threaded programs. However, multiprocessing takes advantage of multiple CPU cores for parallel processing.

74. What is the purpose of the "asyncio" library in Python?

The "asyncio" library is a built-in library in Python that provides an infrastructure for writing asynchronous, concurrent, and parallel code. It is designed to help developers write highly efficient and scalable network servers and clients. Asyncio enables you to write code that can perform I/O operations without blocking the main thread of execution, which can significantly improve the performance and responsiveness of your applications.

75. How can you optimize memory usage in a Python application?

Some ways to optimize memory usage in a Python application:

  1. Use generators and iterators: Generators and iterators can help reduce memory usage by allowing you to process data from one element simultaneously rather than loading the entire dataset into memory at once.
  2. Use built-in functions and modules: Built-in functions and modules like "itertools" and collections can help optimize memory usage by providing efficient algorithms and data structures optimized for memory usage.
  3. Avoid unnecessary copying of data: Python objects are often passed by reference, which can result in excessive data copying. To avoid this, you can use immutable objects like tuples or copy() functions to create shallow rather than deep copies.
  4. Use lazy loading: Lazy loading is a technique in which data is loaded into memory only when needed rather than the entire dataset. It can help reduce memory usage and improve performance.

Python Pandas Interview Questions

76. What are some best practices for designing and developing large-scale Python applications?

Some best practices for designing and developing large-scale Python applications:

  1. Use a modular architecture: Modular architecture allows you to break down your application into smaller, more manageable components. It makes it easier to understand, test, and maintain your code.
  2. Follow coding and conventions: Follow coding standards and conventions to ensure your code is readable and consistent. Use descriptive variable and function names, comments, and documentation.
  3. Write unit tests: Write unit tests to ensure that your code is correct and performs as expected. Use automated testing frameworks such as "unittest," "pytest," or "nose."
  4. Use version control: Use a system like Git to manage your code and collaborate with other developers. It allows you to track changes and revert to previous code versions.

77. How can you implement multithreading and multiprocessing in Python?

Multithreading and multiprocessing are two approaches to achieving concurrency in Python.

Multithreading involves running more than one thread within a single process, allowing multiple program parts to execute concurrently. Python provides a threading module that is used for multithreading. The simplest way to create a new thread is to instantiate the Thread class and pass it a callable object (e.g., a function) in that thread.

Multiprocessing involves running multiple processes that can execute concurrently, taking advantage of multiple CPUs or CPU cores. Python provides a multiprocessing module that is used for multiprocessing. The simplest way to create a new process is to instantiate the Process class and pass it a callable object (e.g., a function) in that process.

78. What is metaprogramming in Python?

Metaprogramming is a technique in which a program can manipulate or generate code dynamically during runtime. Python provides a rich set of features for metaprogramming, which can be helpful in various tasks, including code generation, debugging, testing, and optimizing.

One key feature that enables metaprogramming in Python is introspection, which allows a program to examine its structure and behavior. For example, the built-in dir() function can be used to get a list of all the attributes and methods of an object, while the getattr() and setattr() functions can be used to get or set a characteristic of an object dynamically.

79. What is the purpose of Python's "pickle" module?

The "pickle" module in Python provides a way to serialize and deserialize Python objects, meaning it can convert a Python object into a byte stream, which can then be stored or transmitted, then converted back to the original object. Converting an object into a byte stream is called "pickling," and restoring the stream into an object is called "unpickling."

The "pickle" module provides a way to easily store and transport complex Python objects between different programs or machines without manually converting the objects into a format that can be stored or transmitted.

80. How can you use Python for web development?

Python is used for web development, with several frameworks and tools available to build web applications. Some key Python web development frameworks include Django, Flask, and Pyramid.

  1. Django is a full-featured web framework that provides tools for building web applications, including an object-relational mapper (ORM), a templating engine, and an administration interface.
  2. Flask is a lightweight web framework that is easy to get started with and is designed to be highly customizable. It provides a minimal set of tools for building web applications.
  3. Pyramid is another web framework for Python that is highly flexible and can be used for building applications of any size or complexity. It follows the model-view-controller (MVC) architectural pattern and provides many tools for building web applications.

81. Given two lists, generate a list of pairs (one element from each list)with the help of the zip function.

Using the Zip function, you can generate a list of pairs from two lists.

We define lists list1 and list2 with values [1, 2, 3] and ['a', 'b', 'c'], respectively. We then use the zip() function to generate a new list of pairs, where the first element of each pair comes from list1 and the second element of each pair comes from list2.

The zip() function takes multiple iterables as arguments and returns an iterator that aggregates elements from each iterable into tuples. In this case, we pass in list1 and list2 as arguments to zip(). We then convert the resulting iterator to a list using the list() function.

  • Python


list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
pairs = list(zip(list1, list2))


[(1, 'a'), (2, 'b'), (3, 'c')]

82. What is DataFrame?

A data frame is a data structure used in programming and data analysis, often in the context of working with data in a tabular format. It is a two-dimensional table-like structure, with rows representing observations or cases and columns representing variables or attributes.

In Python, data frames are typically created using panda's library, which provides a DataFrame object that can be used to store and manipulate data in tabular format. Data frames can be created from various sources, including CSV files, Excel spreadsheets, SQL databases, etc.

  • Python


import pandas as pd
data = {'name': ['Raghav', 'Raju', 'Charu', 'Lokesh'],
'age': [25, 30, 35, 40],
'city': ['New York', 'London', 'Paris', 'Dubai']}
df = pd.DataFrame(data)


name    age   city
0   Raghav   25    New York
1    Raju    30    London
2   Charu    35     Paris
3  Lokesh    40     Dubai

83. What is the Global Interpreter Lock (GIL) in Python?

The Global Interpreter Lock (GIL) is a mechanism in Python that ensures only one thread executes Python bytecode at a time. This means that multiple threads can exist within a Python process but cannot execute Python bytecode in parallel.

The GIL is implemented in CPython, the default and most widely used implementation of the Python programming language. It is a design choice made to simplify memory management and improve performance by preventing conflicts that can occur when multiple threads access the same objects or data structures simultaneously.

While the GIL provides a certain level of safety and simplicity, it can limit the performance of CPU-bound tasks that are parallelizable, as only one thread can execute at a time. However, the GIL does not necessarily impact performance for I/O-bound tasks, which often rely on external resources such as disk or network, and therefore do not heavily use the CPU.

There have been attempts to work around the limitations of the GIL, such as using multiprocessing, which allows for parallel execution across multiple processes or using other implementations of Python, such as Jython or IronPython, that do not have a GIL. However, these solutions come with their trade-offs and may only sometimes be suitable for some use cases.

84. What is a lambda function?

A lambda function is a small, anonymous function that can be defined on the fly and used wherever a regular function is expected. It is created using the keyword lambda followed by a list of arguments, a colon, and the expression that the function will return when called.

Lambda functions are useful when you must define a simple function that will only be used in one place. However, they can be difficult to read and understand when they become too complex or are used in many places in your code.

Generally, it's a good practice to use regular named functions for more complex operations or functions that will be reused in multiple places.

Here we take a lambda function that takes two arguments and returns their sum:

  • Python


sum = lambda a, b: a + b
print(sum(3, 4))



85. What is the swapcase function in Python?

The swapcase() function is a built-in method for strings that returns a new string where all uppercase characters are converted to lowercase, and all lowercase characters are converted to uppercase. The original string is not modified.

The swapcase() function can be useful when you need to quickly and easily change the case of a string. For example, you might use it to normalize user input for a case-insensitive search or to format text for display in a particular way.


  • Python


my_string = "cODINg nINJAs"
new_string = my_string.swapcase()


CodinG NinjaS


The original string my_string contains both uppercase and lowercase characters. The swapcase() function is called on the string, which returns a new string where all the uppercase characters are converted to lowercase, and all the lowercase characters are converted to uppercase. The resulting string is then stored in the new_string variable.

86. Write a Python function that takes a list of integers and finds the list's longest increasing subsequence (LIS). The LIS is the longest subsequence of the list in which the elements are in increasing order.

You can use dynamic programming to find the longest increasing subsequence of a list of integers. Here's one way to write the longest_increasing_subsequence() function using dynamic programming:

  • Python


def longest_increasing_subsequence(nums):
n = len(nums)

# Initialize a dynamic programming table with ones.

dp = [1] * n

# Iterate over each element of nums and fill in the dp table.

for i in range(1, n):
for j in range(i):

# If nums[i] is greater than nums[j], update dp[i]

if nums[i] > nums[j]:
dp[i] = max(dp[i], dp[j] + 1)

# Initialize an empty list to hold the LIS and find its maximum length.

lis = []
max_len = max(dp)

# Backtrack from the maximum value of dp to find the LIS.

i = dp.index(max_len)
for j in range(i-1, -1, -1):
if nums[j] < nums[i] and dp[j] == dp[i] - 1:
i = j

# Return the LIS in reverse order.

return lis[::-1]
nums = [10, 22, 9, 33, 21, 50, 41, 60]


[10, 22, 33, 41, 60]

87. Write a function that takes a binary tree as input and returns the maximum path sum of any path in the tree.

  • Python


class TreeNode:
def __init__(self, val=0, left=None, right=None):
self.val = val
self.left = left
self.right = right
def max_path_sum(root):

# Define a helper function to calculate the maximum path sum recursively.

def helper(node):
nonlocal max_sum
if not node:
return 0
# Recursively calculate the maximum path sum from the left and right subtrees.

left_path_sum = helper(node.left)
right_path_sum = helper(node.right)

# Update the maximum path sum if the current path is better.

max_sum = max(max_sum, node.val, node.val + left_path_sum + right_path_sum, node.val + left_path_sum, node.val + right_path_sum)

# Return the maximum path sum from the current node.

return max(node.val, node.val + left_path_sum, node.val + right_path_sum)

# Initialize the maximum path sum to the minimum possible value.

max_sum = float('-inf')

# Recursively calculate the maximum path sum.

return max_sum

# Get user input to create a binary tree.

root_val = int(input("Enter the value of the root node: "))
root = TreeNode(root_val)

if input("Does the root node have a left child? (y/n) ") == 'y':
left_val = int(input("Enter the value of the left child: "))
root.left = TreeNode(left_val)

if input("Does the root node have a right child? (y/n) ") == 'y':
right_val = int(input("Enter the value of the right child: "))
root.right = TreeNode(right_val)

# Calculate the maximum path sum.

max_sum = max_path_sum(root)
print("The maximum path sum is:", max_sum)


Enter the value of the root node: 5
Does the root node have a left child? (y/n) y
Enter the value of the left child: 3
Does the root node have a right child? (y/n) y
Enter the value of the right child: 3
The maximum path sum is: 11

88. Given a list of intervals representing different meetings' start and end times, write a Python function to find the minimum number of meeting rooms required to hold all the meetings.


  • You may assume that each meeting starts and ends within the same day, so the start time is always less than the end time.
  • You may assume that the list of intervals is non-empty and contains at least one meeting.


  • Python


import heapq
def min_meeting_rooms(meetings):

# Sort the meeting intervals by their start times.

meetings.sort(key=lambda x: x[0])

# Initialize a priority queue to store the end times of the currently scheduled meetings.

end_times = []
for meeting in meetings:
start, end = meeting

# If the earliest scheduled meeting has already ended by the current
# meeting's start time, remove it from the priority queue.

if end_times and end_times[0] <= start:

# Add the current meeting's end time to the priority queue.

heapq.heappush(end_times, end)

# The size of the priority queue at any point in time represents
# the number of currently scheduled meetings that require separate rooms.

return len(end_times)

# Get user input for the meeting intervals.

n = int(input("Enter the number of meetings: "))
meetings = []
for i in range(n):
start = int(input("Enter the start time of meeting %d: " % (i+1)))
end = int(input("Enter the end time of meeting %d: " % (i+1)))
meetings.append((start, end))

# Calculate the minimum number of meeting rooms required.

min_rooms = min_meeting_rooms(meetings)

# Print the output.

print("The minimum number of meeting rooms required is:", min_rooms)


Enter the number of meetings: 4
Enter the start time of meeting 1: 1
Enter the end time of meeting 1: 3
Enter the start time of meeting 2: 7
Enter the end time of meeting 2: 9
Enter the start time of meeting 3: 11
Enter the end time of meeting 3: 13
Enter the start time of meeting 4: 15
Enter the end time of meeting 4: 1
The minimum number of meeting rooms required is: 1

89. Explain all file processing modes supported in Python?

Python has various file processing modes.

There are majorly three modes for opening files:

  • read-only mode (r)
  • write-only mode (w)
  • read-write mode (rw)

(Optional) For opening a text file using the above modes, we can also append ‘t’ with them as follows:

  • read-only mode (rt)
  • write-only mode (wt)
  • read-write mode (rwt)

Similarly, a binary file can only be appropriately parsed and read by appending 'be with them as follows:

  • read-only mode (RB)
  • write-only mode (wb)
  • read-write mode (rwb)

If you want to append the content in the files, we can also use the append mode (a):

  • For text files, mode would be 'at'
  • For binary files, it would be ‘ab’

90. What are the functions of file-related modules in Python? Give some examples of such types of modules?

Python has many file-related modules that can manipulate text files and binary files in a file system. It can also use them to pickle-unpickle data from files, while It can use some of them to create a text or binary file, update their content, copy, delete etc.
Some such modules are os, os.path, and shutil.os. The os.path module has function to access the file system, while the shutil.os module can also be used to copy or delete files.

91. What is the difference between opening a Python file versus using the 'with' statement to do the same? What is the syntax to do that?

Using the 'with' statement in Python, one can open a file that gets automatically closed as soon as the block of code, where 'with' is used, exits. In this way, we can opt not to use the close() method.

with open("filename", "mode") as file_var:

Also read,  Python filename extensions

92. How will you read a random line in a file?

We can read a random line in a file using the random module.
For example:

import random

def read_random_line(fname):
    lines = open(fname).read().splitlines()
    return random.choice(lines)

print(read_random_line ('randomfile.txt'))

93. Why isn’t all the memory deallocated after the end of execution of Python programs?

  • When Python programs exit, especially those using Python modules with circular references to other objects or the objects referenced from the global namespaces are not always deallocated or freed.
  • Since it is not possible to deallocate those portions of memory that the C library reserves.
  • On exit, because of having its efficient cleanup mechanism, Python would try to deallocate every object.

94. What advantages does Numpy Arrays Have over Nested Lists for data analysis with large datasets?

Numpy is written in C, so all its complexities are backed into a simple "to use module". While Lists, on the other hand, are dynamically typed. Therefore, Python checks the data type of each element every time it uses it. This makes Numpy arrays much faster than python lists.
Numpy has many additional functionalities that the list doesn't offer; for instance, It can automate many things in Numpy.

95. How are the arguments in Python by default passed? Is it by value or by reference?

By default, all the arguments are passed in Python by a reference. This means that It will reflect any changes made within the function in the original object.
Consider two sets of code shown below:

default passed

Image Source - here

In the first example, we only assign a value to one element of ‘l’, so the output becomes [3, 2, 3, 4].
In the second example, we have created a whole new object for 'l'. But, the values [3, 2, 3, 4] don't show up in the output as they are outside the function's definition.

96. What Is the Difference Between using ‘Del’ and ‘Remove()’ on Lists?

  • Del  -> removes all elements of a list within a given range 
    Syntax: del list[start:end]
  • remove() -> removes the first occurrence of a particular character 
    Syntax: list.remove(element)

Here is an example to understand the two statements - 

>>lis=[1997, 1998, 1999, 2000]
>>del lis[1:3]
Output: [1996, 2000]

>>lis=[1997, 1998, 1999, 1999]
Output: [1997, 1998, 1999]

Note that in the range 1:3, the elements are counted up to (the second index) 2 and not 3.

97. How does multi-threading take place, or can it be used in Python?

Python uses a multi-threading package to achieve multithreading across programs, but it comes with an overhead of the multi-threaded executions to spread to the rest of your program.
Python has a construct/mechanism which is known as the Global Interpreter Lock (GIL). It makes sure that only one of the 'threads' can execute at any single point in time. A thread acquires the GIL, does some work, and then passes the GIL onto the next thread.
This happens quickly so that it may seem like your threads are executing in parallel, but they are just taking turns using the same CPU core.
All this GIL passing adds an overhead to the execution. If one wants to make the code run faster, using the threading package often isn't a good idea.

98. What is the significance of Global Interpreter Lock in Python?

GIL stands for Global Interpreter Lock. It is a mutex used for limiting access to python objects and aids in effective thread synchronisation by avoiding deadlocks. GIL helps one in achieving multitasking (and not parallel computing). The following diagram represents how GIL works.

GIL in Python

Based on the diagram, there are three threads. The first thread acquires the GIL first and starts the I/O execution. When the I/O operations are done, the first thread releases the acquired GIL, which is taken up by the second thread. The process repeats, and the GIL is used by different threads alternatively, which is done until all threads have completed their execution. The threads that did not have the GIL lock go into a waiting state and resume execution only when it acquires the lock.

99. What is Flask? What are the benefits of using it?

Flask is a web microframework for Python based on "Werkzeug (which is a "WSGI" library), Jinja2 and good intentions" BSD license. Werkzeug and Jinja2 are two of the dependencies. This means it will have little to almost no dependencies on an external library.  It makes the framework light, along with a bit of dependency to update and fewer security bugs.

A session allows you to remember information from one request to another. In 'Flask', a session uses a signed cookie to look at the session contents and modify them. The user can change the session if only it has the secret key Flask.secret_key.

100. How does Flask handle database requests?

Flask supports database-powered application abstractions. Such a system requires creating a schema, which needs piping the schema.sql file into the sqlite3 command. Python developers need to install the sqlite3 package/module to create/use or initiate a database in Flask.

Flask allows to request the database in three ways:

  • before_request(): They are called before request and pass no arguments.
  • after_request(): They are called after request and pass the response sent to the client.
  • teardown_request(): They are called in situations as and when an exception gets raised, and the responses are not guaranteed. They are called after response has been constructed. They aren't allowed to modify the request, and the values are ignored.

Python Libraries Interview Questions

101. How does Django differ from Flask in terms of functionality?

Django and Flask map the URL or addresses typed in the web browsers to functions in Python. 
Flask is much simpler than Django, but Flask does not do a lot for you; that is, one needs to specify the details, whereas Django does a lot for you (has a batteries-included approach), whereas you would not need to do much work. Django consists of prewritten modules, which the user will need to most frequently whereas, Flask gives the users the freedom to create their parts of the backend modules required, making it more straightforward to understand. Technically both are equally good and have their pros and cons.

102. Mention the critical differences between using Django, Pyramid and Flask. 

  • Flask is a web “microframework” primarily built for a small application with more detailed requirements. In Flask, you have to use some external libraries to achieve most of the standard functionalities required. Flask has an "Always quickly ready to use" approach.
  • Pyramid is built for larger applications. It provides flexibility and lets the developers use the right tools required for their projects. Developers can choose the database, URL structure, templating style and more. The "Pyramid" framework is heavily configurable.
  • One can also use Django for larger applications, just like Pyramid. But comes with a specific structure and style/pattern of creating most functional components. It also includes an ORM.

103. Discuss the architecture pattern used in Django.

An MVC architecture has been there for a long time in the software industry since the very beginning. Almost all languages/frameworks use it with a slight variation, but the concept remains consistent.

MVC stands for Model – Views – Controller, where the 'Model' provides an interface for the data stored in the database. In contrast, the "View" is responsible for displaying Model Data to the user and also to take up information from the user, with the "Controller" in MVC being accountable for the entire logic behind the web application.

With this conceptual understanding of the pattern being followed or adopted in some way or the other in most frameworks, "Django" includes its implementation method in its web applications. Hence, its framework handles all the parts of the controller by itself.

Hence Django implements a particular kind of architecture known as the "MVT" (Model – View – Template) architecture. Where "MVT" stands for Model – View – Template, i.e.:-

  1. Model: Like "Model" in the MVC architecture, it has the same functionality for providing an interface for the data stored in the database.
  2. Template: Just like "Views" in MVC, Django makes use of "Templates" in its framework. "Templates" are responsible for the User Interface completely. It handles all static parts of the webpage along with the HTML, which the users visiting the webpage will perceive. 
  3. Views: In Django, Views link the Model data and the Templates. 
Architecture used in Django

Note: Like the controllers in MVC, views in Django MVT are responsible for handling all business logic behind the scenes across the web app. It acts as the bridge between 'models' and 'templates'.
It sees the user request,  retrieves appropriate data from the database, then renders back the template along with recovered data.
Therefore there is no separate controller in Django MVT architecture, and everything is based on Model -View – Template itself and hence the name MVT.

104. How does a Database setup and initialisation achieved in Django.

The significant initialisation steps for database setup in Django are done by editing and defining required settings in the mysite/setting.py; it is a standard python module with module-level representing Django settings.

SQLite is an integrated RDBMS that Django uses by default; it is easy for Django developers as it won't require any other type of installation. If your database choice is different, you have to the following keys in the DATABASE 'default' item to match your database connection settings.

  • Engines: you can change the database by defining the following config:
    'django.db.backeneds.mysql', 'django.db.backends.postgresql_psycopg2', 'django.db.backends.oracle' , so on ,
  • Name: The name of your database. In the case of an SQLite DB as your database, in that case, the database will be a file on your computer; the name should be an absolute path, including the file name of the file.

If one is not choosing SQLite as your database, then various settings/configurations such as Password, Host, User, etc., must be separately added.

Django uses SQLite as a default database component; it stores data as a single file in the filesystem. Suppose someone has a database server—PostgreSQL, MySQL, Oracle, MSSQL etc.—and wants to use it rather than the conventional SQLite. In that case, they use database's administration tools to create new databases for their Django projects. Either way, with an (empty) database in place, all that remains is to specify/detail Django how to use it. This is where the project's settings.py file comes in.

We will add the following lines of code to the setting.py file:

     'default': {
          'ENGINE' : 'django.db.backends.sqlite3',
          'NAME' : os.path.join(BASE_DIR, 'db.sqlite3'),


105. Define a simple VIEW endpoint in Django?

This is how we can write a simple view in Django:

from Django.http import HttpResponse
import datetime
def Current_datetime(request):
     now = datetime.datetime.now()
     html = "<html><body>It is {} right now!</body></html>".format(now)
     return HttpResponse(html)

This returns the current date and time as an HTML document.


106. Mention what the Django templates consist of.

"Templates" are simple text files.  It can create any text-based formats like XML, CSV, HTML, etc.  A template contains the variables that get replaced with the values when evaluated and tags (% tag %) that control the template's logic.

DJANGO Template


107. How are sessions maintained and used in the Django framework?

Django provides session tokens that let you store and retrieve data on a per-site-visitor basis. Django abstracts the process of sending and receiving cookies by placing a session ID cookie on the client-side and keeping all the related data on the server-side.

Django Framework

So the data itself is not stored client-side, which is also significant from the perspective of security.

108. What are the different styles of inheritances used in Django.

There are three possible inheritance styles used in Django:

  • Abstract Base Classes: The style is used when one only wants the parent's class to hold the information you don't want to type out for each model.
  • Multi-table Inheritance: The style is used If you sub-class an existing model and need each model to have its database table.
  • Proxy models: You can use this model If you only want to modify the Python level behaviour of the model without changing the model's fields.

109. How To Save An Image Locally Using Python Whose URL Address I Already Know?

We will use the following code to save an image locally from an URL address:

import urllib.request
urllib.request.urlretrieve("URL", "local-filename.jpg")

110. Are there any tools for identifying bugs and performing static analysis in Python?

Yes, tools like PyChecker and Pylint are used as static analysis and linting tools, respectively. PyChecker helps find bugs in the python source code files and raises alerts for the code issues and complexities. Pylint also checks for the module's coding standards and supports various plugins to enable custom features to meet this requirement.

111. What are unit tests in Python?

'Unittest' is a unit testing framework in Python.
Unit testing means testing various components of software separately. Can you think of the reason why unit testing is essential? Consider a scenario; you are building software that uses three parts, namely A, B, and C. Now, suppose your software breaks at some point. How will you find which component broke the software was? Maybe it was due to component A that failed, which failed component B, which failed the entire software. There can be many such combinations.
This is why it becomes necessary to test each component properly to know which Part might be highly responsible for failure of the software.


112. What are decorators, and how are they used in Python?

Decorators in Python are essentially functions that add functionality to existing functions in Python without changing the structures of the functions themselves. They are represented by '@decorator_name' in Python and are called in a bottoms-up fashion. For instance:

# decorator function to convert to lowercase
def lowercase_decorator(function):
   def wrapper():
       func = function()
       string_lowercase = func.lower()
       return string_lowercase
   return wrapper
# decorator function to split words
def splitter_decorator(function):
   def wrapper():
       func = function()
       string_split = func.split()
       return string_split
   return wrapper
@splitter_decorator # this is executed next
@lowercase_decorator # this is executed first
def hello():
   return 'Hello World'
hello()   # output => [ 'hello' , 'world' ]

The beauty of these decorators lies in the fact that besides adding functionalities to existing outputs of the methods, they can even accept arguments for functions and further modify those arguments before passing them to the function itself. The inner nested function, i.e. 'wrapper' function, plays significant role here. It is implemented in order to enforce encapsulation and thus, keep itself hidden from the global scope.

# decorator function to capitalize names
def names_decorator(function):
   def wrapper(arg1, arg2):
       arg1 = arg1.capitalize()
       arg2 = arg2.capitalize()
       string_hello = function(arg1, arg2)
       return string_hello
   return wrapper
def say_hello(name1, name2):
   return 'Hello ' + name1 + '! Hello ' + name2 + '!'
say_hello('sara', 'ansh')   # output => 'Hello Sara! Hello Ansh!'

113. Write a script to scrape data from IMDb top 250 movies page. It should only have fields of movie name, year, and rating.

We can use the following script for the same:

from bs4 import BeautifulSoup
import requests
import sys
url = '<a href="http://www.imdb.com/chart/top">http://www.imdb.com/chart/top</a>'
response = requests.get(url)
soup = BeautifulSoup(response.text)
tr = soup.findChildren("tr")
tr = iter(tr)
for movie in tr:
    title = movie.find(
        'td', {'class': 'titleColumn'} 
    year = movie.find(
        'td', {'class': 'titleColumn'} 
        'span', {'class': 'secondaryInfo'}
    rating = movie.find(
        'td', {'class': 'ratingColumn imdbRating'}    
    row = title + ' - ' + year + ' ' + ' ' + rating

The script above will help scrape data from IMDb's top 250 list.


114. What is meant by functional programming? Does Python follow a functional programming style? If yes, list few methods to implement functionally oriented programming in Python.

Functional programming is a coding style where the primary logic source in programs comes from functions.
Incorporating a functional style of programming means writing pure functions.
These are functions that cause little or no changes outside of their scope. These changes are referred to as side effects. Pure functions are used to reduce these side effects, which makes the code easy to follow, test, or debug.

Python does follow a functional programming style. Following are a few examples of functional programming in Python.

filter(): Filter lets us filter some of the values based on a conditional logic. 
list( filter ( lambda x : x > 6 , range ( 9 ) ) ) 
[7, 8]

map(): The 'Map' function applies a function to every element in an iterable.
list( map ( lambda x : x ** 2 , range ( 5 ) ) ) 
[0, 1, 4, 9, 16, 25]

reduce(): Reduce repeatedly reduces a sequence in a pair-wise manner until it reaches a single value.
from functools import reduce
reduce( lambda x , y : x - y , [1,2,3,4,5] ) 


115. What is the difference between NumPy and SciPy?

NumPy comprises array data types and the most basic linear and vector operations such as indexing, sorting, reshaping, essential element-wise functions, etc.
While all the numerical functionalities reside in SciPy, one of NumPy's essential goals is compatibility, so NumPy tries to retain all the features supported by either of its predecessors.
Thus NumPy also contains some linear algebra functions, even though these more appropriately belong in SciPy. In any case, SciPy contains fully-featured versions of the linear algebraic modules and many other numerical algorithms.
If you are doing scientific computing using Python then, you should probably install both NumPy and SciPy. However, most new features belong in SciPy rather than NumPy.

116. How are NumPy arrays advantageous over python lists?

The list data structure defined in Python is highly efficient and capable of performing various functions. But, they have severe limitations in computation vectorised operations that deal with element-wise multiplication and addition. 

Lists also require information regarding the type of every element, which results in overhead as type dispatching code and gets executes every time any operation is performed on any aspect. The NumPy arrays come into the picture as NumPy arrays handle all the limitations of python lists.

Additionally, as the sizes of the NumPy arrays increase, NumPy becomes around 30x times faster than Python Lists. Due to their homogenous nature, it can densely pack the Numpy arrays into the memory, which makes the memory free up quicker.

117. How will you access the dataset of a publicly shared spreadsheet in CSV format stored in Google Drive?

https://docs.python.org/3/We can use the StringIO module from the io module to read from the Google Drive link, and then we can use the pandas library using the obtained data source.

from io import StringIO
import pandas
csv_link = "https://docs.google.com/spreadsheets/d/..."
data_source = StringIO.StringIO(requests.get(csv_link).content))
dataframe = pd.read_csv(data_source)

118. What is meant by the term 'Regression'?

Regression is a supervised machine learning algorithm technique that is used to find the correlation between variables and help to predict the dependent variable(y) based upon the independent variable (x). It is mainly used for predictions, time series modelling, forecasting and determining the causal-effect relationship between variables.

There are two different types of regression algorithms in machine learning :
Linear Regression: is used when the variables are continuous and numeric.
Logistic Regression: is used when the variables are continuous and categorical.

119. What is classification? How would you import Decision Tree Classifier using the "Sklearn" module? 

  • Classification refers to a predictive modelling process where a class label is predicted for a given example of input data. It helps categorise the provided input into a label that other observations with similar features have. For example, one can use it to classify a mail, whether it is spam or not or check whether users will churn based on their behaviour.

    These are some  classification algorithms used in Machine Learning:
    • Decision tree
    • Random forest classifier
    • Support vector machine

This is how a decision tree classifier can be imported in “Sklearn”:

from sklearn.tree import DecisionTreeClassifier

120. What are pandas groupby?

The pandas "groupby" function is a feature supported by pandas that are used to split and group an object.  Like the RBMS languages such as sql/mysql/oracle "group by" it is also used to group data by classes, entities which can then be further used for aggregation. A dataframe can also be grouped by one or more columns. 

df = pd.DataFrame(





121. How do you split the data in train and test datasets in Python?

One can achieve this by using the "Scikit" machine learning  library and importing the "train_test_split" function in Python as shown below:

Import sklearn.model_selection.train_test_split

# test size = 30% and train = 70%

X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.33, random_state=0)

122. Is it possible to overfit a model if the data is split into train/test splits?

Yes, a common beginner’s mistake often is re-tuning a model or training new models with different parameters even after seeing its performance on the test set.

Also see, Python data analytics

Frequently Asked Questions

How do I prepare for a Python interview?

Make sure you are familiar with Python frameworks. When answering technical questions, be sure to make clear the steps you took to arrive at the right answer. Be ready for questions on soft skills. gather previous Python projects, and understand them. 

What are the 7 types of Python?

Python has seven types of operators which are arithmetic operators, assignment operators, comparison operators, logical operators, identity operators, membership operators, and bitwise operators. All these operators work with variables or values to execute mathematical operations.

What are the 4 main data types in Python?

A variable's type is specified using Python Data Types. It specifies the kind of data that will be kept in a variable. The four main data types available in Python are int, long, float, and complex.


In the article, we discussed various aspects of Python Interview Questions. We hope this blog has helped you enhance your knowledge regarding Python language.

Other Interview Questions


Check out Uber Interview Experience to learn about their hiring process.

You may refer to our Guided Path on Coding Ninjas Studio to enhance your skill set on DSA and many more. Check out essential interview questions, practice our available mock tests, and more!


Previous article
Interview Questions for Coding Round in Python
Next article
Priority Queue using Python
Guided path
Basics of python
7 chapters
127+ Problems
Earn badges and level up
Live masterclass