Python Interview Questions

Python Interview Questions and Answers for Experienced

51. 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.

• Python

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

       self.parent1_func()

       self.parent2_func()


# Driver's code

obj1 = Child()

obj1.child_func()

You can also try this code with Online Python Compiler

Run Code

Output: 
 

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

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. 

print(E1.name)

print(E1.age)

print(E1.salary)

You can also try this code with Online Python Compiler

Run Code

Output:

XYZ
23
20000

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

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)

obj.display()

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

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)

obj.display()

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

   pass   


class Child(Parent):

   pass   


# 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

Python

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

You can also try this code with Online Python Compiler

Run Code

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

@names_decorator

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 )

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

Syntax:

df1.append(df2)

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

Syntax:

PD.concat([df1, df2]) 

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

df1.join(df2)

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

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)  

You can also try this code with Online Python Compiler

Run Code

Output:

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:

df['column_name'].fillna(0)

Or by replacing it by the mean value of the column

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

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'])    
print(df)    
# To add new column fourth
df['fourth'] = df['first'] + info['third']    
print(df)  

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

   Names             

   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

print(df)

        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

Python

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

You can also try this code with Online Python Compiler

Run Code

Output:

[(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

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)
print(df)

You can also try this code with Online Python Compiler

Run Code

Output:

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

Python

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

You can also try this code with Online Python Compiler

Run Code

Output:

7

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.

Example:

• Python

Python

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

You can also try this code with Online Python Compiler

Run Code

Output:

CodinG NinjaS

Explanation: 

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

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)
   lis.append(nums[i])
   for j in range(i-1, -1, -1):
       if nums[j] < nums[i] and dp[j] == dp[i] - 1:
           lis.append(nums[j])
           i = j
           
   # Return the LIS in reverse order.
   
   return lis[::-1]
nums = [10, 22, 9, 33, 21, 50, 41, 60]
print(longest_increasing_subsequence(nums))

You can also try this code with Online Python Compiler

Run Code

Output: 

[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

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.
   
   helper(root)
   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)

You can also try this code with Online Python Compiler

Run Code

Output:
 

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.

Constraints:

• 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.

Code

• Python

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:
           heapq.heappop(end_times)
           
       # 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)

You can also try this code with Online Python Compiler

Run Code

Output:

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:

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]
>>lis
Output: [1996, 2000]

>>lis=[1997, 1998, 1999, 1999]
>>lis.remove(1999)
>>lis
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.

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. 

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.backends.sqlite3’,
  '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:

DATABASES = {
     '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.

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.

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
@names_decorator
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)
next(tr)
 
for movie in tr:
    title = movie.find(
        'td', {'class': 'titleColumn'} 
    ).find('a').contents[0]
    year = movie.find(
        'td', {'class': 'titleColumn'} 
    ).find(
        'span', {'class': 'secondaryInfo'}
    ).contents[0]
    rating = movie.find(
        'td', {'class': 'ratingColumn imdbRating'}    
    ).find('strong').contents[0]
    row = title + ' - ' + year + ' ' + ' ' + rating
    print(row)

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. 
Ex.
list( filter ( lambda x : x > 6 , range ( 9 ) ) ) 
Output:
[7, 8]

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

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

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)
print(dataframe.head())

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(
    {'Vehicle':['Etios','Lamborghini','Apache200','Pulsar200'],              
    'Type':["car","car","motorcycle","motorcycle"]}
    )

df

Output

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.

Python OOPS Interview Questions

123. What are the main principles of Object-Oriented Programming (OOP) in Python?

The main principles of OOP in Python are encapsulation, inheritance, polymorphism, and abstraction. All principles serve different roles in OOPs:

• Encapsulation: It helps in bundling the data and the methods into a single unit.
• Inheritance: It helps in creating a new class based on an existing class.
• Polymorphism: It helps using a common interface for different data types.
• Abstraction: It helps to hide complex implementation details.

124. How do you define a class in Python?

We can define a class in Python using the class keyword. It is followed by the class name and a colon. For example:

class MyClass:
    def __init__(self, value):
        self.value = value

125. What is the main purpose of the __init__ method in a Python class?

The __init__ method is a special method in Python. It is used for initializing a newly created object. It is called automatically when an object is instantiated. It is also used to set initial values for the object's attributes.

126. How do you implement inheritance in Python?

We can implement inheritance by creating a new class that derives from an existing class. For example:

class ParentClass:
    pass

class ChildClass(ParentClass):
    pass

127. What do you mean by method overriding in Python?

Method overriding means when a subclass provides a specific implementation for a method that is already defined in its superclass. This allows the subclass to modify or extend the behavior of the inherited method.

128. How do you achieve encapsulation in Python?

We can achieve encapsulation by using private and protected attributes and methods. Private attributes are prefixed with double underscores (e.g., __private_var). On the other hand, protected attributes are prefixed with a single underscore (e.g., _protected_var).

129. What is the difference between __str__ and __repr__ methods?

The __str__ method returns a human-readable string representation of an object, intended for end-users. On the other hand, the __repr__ method returns an unambiguous string representation. It is useful for debugging and development.

130. How can you create a class method and a static method?

Class methods are created using the @classmethod decorator. It takes cls as their first parameter. On the other hand, Static methods are created with the @staticmethod decorator. It does not take self or cls. For example:

class MyClass:
    @classmethod
    def class_method(cls):
        pass

    @staticmethod
    def static_method():
        pass

131. What is polymorphism in Python?

Polymorphism allows objects of different classes to be treated as objects of a common superclass. It enables a single function or method to operate differently based on the object’s type.

132. How do you implement multiple inheritance in Python?

We can implement multiple inheritance by specifying more than one parent class in the class definition. For example:

class B1:
    pass

class B2:
    pass

class Derived(B1, B2):
    pass

Numpy Interview Questions

133. What is NumPy, and why is it used?

NumPy is a library for numerical computing in Python. It provides support for large, multi-dimensional arrays and matrices. it also helps with mathematical functions to operate on these arrays efficiently.

134. How do you create a NumPy array from a Python list?

We can create a NumPy array from a Python list using numpy.array(). For example:

import numpy as np
arrNumpy = np.array([1, 2, 3, 4])

135. What is the difference between np.array() and np.zeros()?

np.array() creates an array from existing data. On the other hand, np.zeros() creates an array filled with zeros. For example:

import numpy as np
arr1 = np.array([1, 2, 3])
arr2 = np.zeros((3, 4))

136. How do you perform element-wise operations in NumPy?

We can perform element-wise operations in NumPy using standard arithmetic operators directly on arrays. For example:

import numpy as np
arr = np.array([1, 2, 3])

# Adds 5 to each element
ans = arr + 5  

137. What is broadcasting in NumPy?

Broadcasting is a feature in NumPy. It allows operations between arrays of different shapes. It automatically expands the smaller array to match the shape of the larger array. It enables element-wise operations.

138. How do you calculate the mean of a NumPy array?

We can calculate the mean of a NumPy array using the np.mean() function. For example:

import numpy as np
arr = np.array([1, 2, 3, 4])
meanVal = np.mean(arr)

139. How can you reshape a NumPy array?

We can reshape a NumPy array using the reshape() method. For example:

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

# Reshapes to 2 rows and 3 columns
new_arr = arr.reshape((2, 3))  

140. What is the main purpose of np.vstack() and np.hstack()?

np.vstack() stacks arrays vertically (row-wise). On the other hand, np.hstack() stacks arrays horizontally (column-wise). For example:

import numpy as np
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
vstk = np.vstack((arr1, arr2))
hstk = np.hstack((arr1, arr2))

141. How do you perform matrix multiplication in NumPy?

We can perform matrix multiplication using the np.dot() function or the @ operator. For example:

import numpy as np
matrix1 = np.array([[1, 2], [3, 4]])
matrix2 = np.array([[5, 6], [7, 8]])
ans = np.dot(matrix1, matrix2)

142. What is the difference between np.copy() and np.view()?

np.copy() creates a new array with a copy of the data. On the other hand, np.view() creates a new view of the same data without copying. The changes to the view will affect the original array.

Python Programming Examples

Example 1: Fibonacci Sequence

• Python

Python

def fibonacci(n):
    a, b = 0, 1
    while a < n:
        print(a, end=' ')
        a, b = b, a + b
fibonacci(10)

You can also try this code with Online Python Compiler

Run Code

Output

0 1 1 2 3 5 8 

Example 2: Simple Calculator

• Python

Python

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

def subtract(x, y):
    return x - y

def multiply(x, y):
    return x * y

def divide(x, y):
    if y != 0:
        return x / y
    else:
        return "Cannot divide by zero"

print(add(10, 5))
print(subtract(10, 5))
print(multiply(10, 5))
print(divide(10, 0))

You can also try this code with Online Python Compiler

Run Code

Output

15
5
50
Cannot divide by zero

Python MCQ

1. What is the output of this Python code:

print(2 ** 3 ** 2)

A) 64

B) 512

C) 128

D) 81

Answer: B) 512

2. Which of the following is a mutable data type in Python?

A) Tuple

B) String

C) List

D) Integer

Answer: C) List

3. How do you start a comment in Python?

A) /*

B) //

C) #

D) <!--

Answer: C) #

4. What is the output of this Python code:

[1, 2] + [3, 4]

A) [1, 2, 3, 4]

B) [1, 2, [3, 4]]

C) [1, 2] + [3, 4]

D) [4, 3, 2, 1]

Answer: A) [1, 2, 3, 4]

5. How do you handle exceptions in Python?

A) try and catch

B) try and error

C) try and except

D) begin and rescue

Answer: C) try and except

6. What is the output of this Python code:

len("Python")

A) 5

B) 7

C) 6

D) 8

Answer: C) 6

7. Which method is used to add an element at the end of a list?

A) insert()

B) append()

C) extend()

D) add()

Answer: B) append()

8. What is the keyword used to define a function in Python?

A) func

B) define

C) def

D) function

Answer: C) def

9. What is the output of this Python code:

list(range(5))

A) [1, 2, 3, 4, 5]

B) [0, 1, 2, 3, 4]

C) [1, 2, 3, 4]

D) [0, 1, 2, 3, 4, 5]

Answer: B) [0, 1, 2, 3, 4]

10. How do you check the data type of a variable?

A) isinstance()

B) type()

C) check_type()

D) data_type()

Answer: B) type()

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.

How do I prepare for a Python interview?

To prepare for a Python interview, review key concepts such as data structures, algorithms, and object-oriented programming. Practice coding problems, understand common libraries, and be ready to discuss real-world applications and past projects.

What is a list in Python interview questions?

A list in Python is a mutable, ordered collection of items, which can be of different types. Lists are defined using square brackets and support various operations like indexing, slicing, and appending.

What is Boolean in Python?

In Python, a Boolean is a data type with two possible values: True and False. It is often used for conditional statements and logical operations to represent truth values and control flow in programs.

Conclusion

In the article, we discussed the top 100+ Python Interview Questions and Answers 2024.  This article provides a thorough overview of essential questions and answers, covering core concepts, advanced topics, and practical applications. 

Other Interview Questions

• Html interview questions
• Angular interview questions
• Manual testing interview questions
• Selenium interview questions
• Javascript Interview Questions
• Operating System Interview Questions
• jQuery interview questions
•  Programming 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!