Top 50 Python Interview Questions and Answers

Object-Oriented Language
High-Level Language
Dynamically Typed Language
Extensive Support Libraries
Presence of Third-party Modules
Open Source and Community Development
Portable and Interactive

Python is a partially compiled and partially interpreted language. The compilation generates bytecode, which is executed by the Python interpreter according to the underlying platform.

‘#’ is used for comments in Python. Everything after ‘#’ on the same line is treated as a comment and is not executed.

Mutable data types (e.g., lists, dictionaries) can be modified after creation, whereas immutable data types (e.g., strings, tuples) cannot be changed once created.

In Python, everything is an object, and variables hold references to objects. Objects are passed by reference, but references are passed by value. Mutable objects can be modified within functions, but immutable objects cannot.

A set is an unordered collection of unique elements, while a dictionary is an unordered collection of key-value pairs.

List comprehension is a concise way to create a new list based on an existing list. It is a Pythonic way of writing a for loop with the additional benefit of being more readable and expressive.

A lambda function is an anonymous, small, and inline function defined using the “lambda” keyword. It can take any number of arguments but can have only one expression.

Brainstorming begins by identifying key themes or topics of interest. I jot down ideas, create mind maps, and explore different angles. Collaboration with colleagues and staying updated on industry trends also fuels my brainstorming process.

Exception handling in Python is done using `try`, `except`, and `finally` blocks. Code that might raise an exception is placed inside the `try` block, and if an exception occurs, the `except` block handles it. The `finally` block is executed regardless of whether an exception occurred or not.

Decorators in Python are a way to modify or enhance the behavior of functions or classes. They allow you to wrap another function, adding functionality to the wrapped function. Decorators are often used for logging, authentication, memoization, etc.

Pickling is the process of serializing Python objects into a byte stream, while unpickling is the process of deserializing the byte stream back into Python objects. Pickling allows objects to be saved to a file and later restored, preserving their state.

Errors and exceptions in Python are handled using `try`, `except`, and `finally` blocks. The code that might raise an exception is placed inside the `try` block. If an exception occurs, the `except` block handles it, and the `finally` block is executed regardless of whether an exception occurred or not.

The `super()` function is used to call a method from a parent class. It returns a temporary object of the superclass, allowing you to call its methods. It is commonly used in class inheritance to invoke methods from the base class.

The `with` statement simplifies exception handling by encapsulating common preparation and cleanup tasks in methods defined by a context manager. It ensures that acquired resources are properly released, even if an error occurs. Common use cases include file handling and database connections.

A shallow copy creates a new object but does not create copies of nested objects. Changes made to nested objects inside the shallow copy affect the original object.
A deep copy creates a new object and recursively creates copies of all nested objects. Changes made to nested objects inside the deep copy do not affect the original object.

The __str__ method is a special method, also known as a Dunder method (double underscore method), that is defined for classes in Python. It is responsible for providing a string representation of an object, which is the informal or human-readable representation of the object’s data. This string representation is what is displayed when the object is printed using the print() function or converted to a string using the str() built-in function.

The `__doc__` attribute in Python contains the docstring (documentation string) of a class, function, module, or method. It is used to provide information about the object, such as its purpose, parameters, and usage. Docstrings are enclosed in triple quotes and are accessible using the `__doc__` attribute.

In Python 2, `range()` generates a list of numbers, while `xrange()` generates an xrange object, which is a memory-efficient iterator. In Python 3, `xrange()` is no longer available, and `range()` behaves like Python 2’s `xrange()`.

In Python, *args and **kwargs are special syntax used for defining and calling functions that can accept a variable number of arguments. They are often used to create flexible and versatile functions that can handle different input scenarios.
*args
The *args syntax allows you to define a function that can accept an arbitrary number of non-keyword arguments. When you call the function, any positional arguments that are passed in are stored in a tuple represented by the *args parameter.
**kwargs
The **kwargs syntax allows you to define a function that can accept an arbitrary number of keyword arguments. When you call the function, any keyword arguments are stored in a dictionary represented by the **kwargs parameter.

The Global Interpreter Lock (GIL) is a mutex that protects access to Python objects, preventing multiple native threads from executing Python bytecode at once. This limits Python’s ability to fully utilize multiple CPU cores for parallel processing.

The `__name__` variable in Python is a special built-in variable. When a Python script is executed, `__name__` is set to `’__main__’`. It allows a module to detect whether it is being run as the main program or imported into another module.

Python is a high-level, general-purpose programming language. Python is a programming language that may be used to create desktop GUI apps, websites, and online applications. As a high-level programming language, Python also allows you to concentrate on the application’s essential functionality while handling routine programming duties. The basic grammar limitations of the programming language make it considerably easier to maintain the code base intelligible and the application manageable.

To generate a random, we use a random module of python. Here are some examples To generate a floating-point number from 0-1

import random
n = random.random()
print(n)
To generate a integer between a certain range (say from a to b): import random
n = random.randint(a,b)
print(n)

.py are the source code files in python that the python interpreter interprets.
.pyc are the compiled files that are bytecodes generated by the python compiler, but .pyc files are only created for inbuilt modules/files.

Spaces can be removed from a string in python by using strip() or replace() functions. Strip() function is used to remove the leading and trailing white spaces while the replace() function is used to remove all the white spaces in the string.

The variable’s accessibility is defined in python according to the location of the variable declaration, called the scope of variables in python. Scope Resolution refers to the order in which these variables are looked for a name to variable matching. Following is the scope defined in python for variable declaration.

a. Local scope – The variable declared inside a loop, the function body is accessible only within that function or loop.
b. Global scope – The variable is declared outside any other code at the topmost level and is accessible everywhere.
c. Enclosing scope – The variable is declared inside an enclosing function, accessible only within that enclosing function.
d. Built-in Scope – The variable declared inside the inbuilt functions of various modules of python has the built-in scope and is accessible only within that particular module.
The scope resolution for any variable is made in java in a particular order, and that order is
Local Scope -> enclosing scope -> global scope -> built-in scope

The list.count() method takes an element as an argument and returns the number of times that element appears in the list.

list1 = [1, 2, 3, 2, 4, 2]
element = 2
count = list1.count(element)
print(“The number of occurrences of”, element, “in the list is”, count)

The functools module in Python provides higher-order functions and operations on callable objects (functions, methods, etc.). It includes functions like partial(), wraps(), reduce(), and decorators like lru_cache() for memoization and total_ordering() for defining rich comparisons. These tools help in creating efficient, reusable, and well-behaved functions and classes.

from functools import wraps
def my_decorator(func):
@wraps(func)
def wrapper(*args, *kwargs): print(“Something is happening before the function is called.”) result = func(args, **kwargs)
print(“Something is happening after the function is called.”)
return result
return wrapper
@my_decorator
def say_hello():
“””This is a docstring.”””
print(“Hello!”)
print(say_hello.name) # Output: say_hello
print(say_hello.doc) # Output: This is a docstring.

The __call__ method in Python classes allows instances of a class to be called as if they were functions. When the __call__ method is defined in a class, objects of that class become callable, and you can invoke them using parentheses, just like you would with functions.

Here’s an example:

class CallableClass:
def __init__(self, x):
self.x = x
def __call__(self, y):
return self.x + y

obj = CallableClass(10)
result = obj(5) # Equivalent to obj.__call__(5)
print(result) # Output: 15

The async and await keywords in Python are used to define and work with asynchronous coroutines. Asynchronous programming allows you to write concurrent code that can handle many tasks at once without blocking the program’s execution. async defines a coroutine, and await is used to pause the execution of the coroutine until the awaited task is completed.

Here’s an example of using async and await:

import asyncio

async def foo():
print(“Start foo”)
await asyncio.sleep(2)
print(“End foo”)

async def bar():
print(“Start bar”)
await asyncio.sleep(1)
print(“End bar”)

async def main():
await asyncio.gather(foo(), bar())

asyncio.run(main())
Output: Start foo
Start bar
End bar
End foo

Metaclasses in Python provide a way to customize the behavior of classes. A metaclass is a class for classes. By defining a metaclass, you can control how new classes are created, initialized, and behave. Metaclasses are used for advanced purposes such as code inspection, modification, and code generation.

The __slots__ attribute in Python classes restricts the attributes that instances of the class can have. It is a tuple specifying the allowed attribute names. By using __slots__, you can reduce memory overhead and improve attribute access speed for instances of the class. However, it is important to note that __slots__ should be used carefully, as it prevents the addition of new attributes to instances dynamically.

Method Resolution Order (MRO) defines the order in which base classes are searched when looking for a method in a class hierarchy. In Python, MRO is determined using the C3 linearization algorithm (also known as C3 superclass linearization). It ensures a consistent and predictable order for method resolution in multiple inheritance scenarios.

Python uses a garbage collector to automatically manage memory allocation and deallocation. The garbage collector keeps track of which objects are no longer being used and removes them from memory. This makes it easy for Python programmers to write memory-safe code without having to worry about manually allocating and deallocating memory.

A class is a blueprint for creating objects. It defines the attributes and methods that all objects of that class will have. An instance is a specific object that is created from a class. Each instance has its own set of values for the attributes defined by the class.

A module is a file of Python code that can be imported into other programs. A package is a collection of modules that are organized into a hierarchy of directories. Packages are used to group related modules together and to make it easier to import them from other programs.

Inheritance is a way of creating new classes that inherit the attributes and methods of existing classes. This allows you to reuse code and create more complex class hierarchies. Python implements inheritance using a technique called “method resolution order” (MRO). MRO determines the order in which Python searches for methods when they are called on an object.

Python supports concurrent programming using a technique called “global interpreter lock” (GIL). The GIL ensures that only one thread can execute Python bytecode at a time, which prevents data races and other concurrency issues.

Python’s global interpreter lock (GIL) prevents multiple threads from executing Python bytecode at the same time. This can make it difficult to achieve thread safety in Python applications.

There are a few potential solutions to this problem:
*Use a thread-local data structure to store data that needs to be accessed by *multiple threads.
*Use a mutex to lock access to shared data.
*Use an asynchronous programming model, such as asyncio, to avoid the GIL.

Monkey patching is a technique for modifying the behavior of a program by replacing its functions or classes with new ones. Monkey patching is often used to make quick and easy changes to a program, but it can also make the program more difficult to understand and test.

Asynchronous programming is a way of writing programs that can handle multiple tasks at the same time. This can be useful for writing programs that need to respond to user input, make network requests, or perform other I/O-bound tasks.
Python has a few different concurrency models, including threads, greenlets, and asyncio. Each model has its own advantages and disadvantages.

import numpy as np
n1=np.array([10,20,30,40,50,60])
print(np.mean(n1))
print(np.median(n1))
print(np.std(n1))

All the upper cases in a string can be converted into lowercase by using the method: string.lower()
ex:
string = ‘GREATLEARNING’ print(string.lower())

One of the ways we can get a list of keys is by using: dict.keys()
This method returns all the available keys in the dictionary.
dict = {1:a, 2:b, 3:c} dict.keys()
o/p: [1, 2, 3]

Reindexing is the process of re-assigning the index of a pandas dataframe.
Code:
import pandas as pd
bikes=["bajaj","tvs","herohonda","kawasaki","bmw"]
cars=["lamborghini","masserati","ferrari","hyundai","ford"]
d={"cars":cars,"bikes":bikes}
df=pd.DataFrame(d)
a=[10,20,30,40,50]
df.index=a
df

vstack() is a function to align rows vertically. All rows must have the same number of elements.
Code:
import numpy as np
n1=np.array([10,20,30,40,50])
n2=np.array([50,60,70,80,90])
print(np.vstack((n1,n2)))

Pickling is the process of converting a Python object hierarchy into a byte stream for storing it into a database. It is also known as serialization. Unpickling is the reverse of pickling. The byte stream is converted back into an object hierarchy.

There are several ways to debug a Python program:
*Using the print statement to print out variables and intermediate results to the console
*Using a debugger like pdb or ipdb
*Adding assert statements to the code to check for certain conditions

Exceptions in Python can be handled using a try–except block.
For example:
Copy codetry:
# code that may raise an exception except SomeExceptionType:
# code to handle the exception