Python Interview Questions

What are the key features of Python?

Some key features of Python in brief:

  • Readable and Simple Syntax: Python emphasizes code readability and has a simple and clean syntax, making it easy to learn and understand.
  • High-level Language: Python abstracts many low-level programming details, allowing developers to focus more on problem-solving than on the complexities of the language itself.
  • Interpreted and Interactive: Python is an interpreted language, meaning code is executed line by line, facilitating interactive development and rapid prototyping.
  • Dynamic Typing: Python uses dynamic typing, enabling variables to be declared without specifying their type. This flexibility enhances code flexibility and reduces verbosity.
  • Extensive Standard Library: Python comes with a vast standard library that provides support for a wide range of tasks, from file handling to web development, enabling developers to build applications efficiently.
  • Platform Independent: Python code can run on various platforms without modification, including Windows, macOS, and Linux, promoting cross-platform compatibility.
  • Object-Oriented Programming: Python supports object-oriented programming (OOP) principles, allowing developers to create modular and reusable code through classes and objects.
  • Community Support: Python has a large and active community of developers who contribute libraries, frameworks, and resources, making it easy to find solutions to problems and collaborate on projects.
  • Versatility: Python is suitable for various types of projects, including web development, data analysis, machine learning, artificial intelligence, automation, and more, making it a versatile language for diverse applications.
  • Open Source: Python is open-source, meaning its source code is freely available, allowing developers to modify and distribute it as needed, fostering collaboration and innovation within the community.

What is PEP 8?

PEP 8 stands for "Python Enhancement Proposal 8." It is a style guide for Python code written by Guido van Rossum, Barry Warsaw, and Nick Coghlan. PEP 8 provides guidelines and best practices for writing Python code in a consistent and readable manner.

Some key points of PEP 8:

  • Code layout: Recommendations for indentation, line length, and whitespace usage to improve code readability.
  • Naming conventions: Guidelines for naming variables, functions, classes, and modules to promote clarity and consistency.
  • Comments and documentation: Suggestions for writing effective comments and docstrings to explain code functionality.
  • Programming recommendations: Advice on coding style, such as using descriptive names, avoiding unnecessary parentheses, and organizing imports.
  • Overall readability: Emphasis on writing code that is easy to understand and maintain, promoting the Pythonic way of writing code.

Explain the differences between Python 2 and Python 3.

Python 2 and Python 3 are two major versions of the Python programming language, Some key between Python 2 and Python 3:

Feature Python 2 Python 3
Print Statement Uses print statement Uses print() function
Division Integer division by default (/ operator) True division by default (/ operator)
Unicode Support Limited support for Unicode, strings are ASCII by default Full support for Unicode, strings are Unicode by default
xrange() Function Used for generating sequences Replaced by range() function
raw_input() Function Used for user input Replaced by input() function
Error Handling Uses except Exception, e: syntax Uses except Exception as e: syntax
__str__ vs. __unicode__ __str__ for byte strings, __unicode__ for Unicode __str__ handles both byte and Unicode strings
next() Function Uses next() function Still uses next() function
Iteration dict.keys(), dict.values(), and dict.items() return lists dict.keys(), dict.values(), and dict.items() return iterators
<> Operator Supports <> for inequality Removed, use != for inequality
__div__ Operator Supports __div__ for division Removed, use __truediv__ or __floordiv__ for division
try Statement No support for finally block with try Supports finally block with try

How do you comment out multiple lines of code in Python?

You can comment out multiple lines of code in Python by enclosing them within triple quotes (`'''` or `"""`). This creates a multi-line string that Python ignores as a comment.

What is a Python virtual environment, and why is it used?

A Python virtual environment is an isolated environment where you can install and manage Python packages independently of the system-wide Python installation. It's used to avoid conflicts between project dependencies and to ensure reproducibility of environments across different systems.

How do you reverse a string in Python?

we can reverse a string in Python using slicing. 

my_string = "hello"
reversed_string = my_string[::-1]

How do you install third-party packages in Python?

Third-party packages in Python can be installed using the 'pip' package manager. You can use the command 'pip install <package_name>' to install a package from the Python Package Index (PyPI).

Explain the difference between lists and tuples in Python.

Some key difference between lists and tuples:

Feature Lists Tuples
Mutable Lists are mutable, meaning elements can be changed after creation Tuples are immutable, meaning elements cannot be changed after creation
Syntax Enclosed in square brackets [ ] Enclosed in parentheses ( )
Performance Lists are slower for iteration and element access due to their mutable nature Tuples are faster for iteration and element access due to their immutable nature
Use Cases Ideal for collections of items where the order or content might change, such as a list of tasks or user inputs Suitable for fixed collections of items that should not be changed, such as coordinates or configuration settings
Memory Consumption Lists consume more memory due to their mutable nature and the need for additional overhead to support resizing Tuples consume less memory due to their immutable nature, resulting in better memory efficiency

How do you handle dates and times in Python?

Python's 'datetime' module provides classes for manipulating dates and times. You can create, manipulate, format, and perform arithmetic with dates and times using this module. 

from datetime import datetime, timedelta

now =
print("Current date and time:", now)

future_date = now + timedelta(days=7)
print("Date seven days from now:", future_date)

formatted_date = now.strftime("%Y-%m-%d %H:%M:%S")
print("Formatted date:", formatted_date)

Explain the difference between 'append()' and 'extend()' methods in Python lists.

Some key difference between 'append()' and 'extend()' methods:

Feature append() Method extend() Method
Operation Adds a single element to the end of the list Adds multiple elements to the end of the list
Input Accepts one argument, which can be any data type, including lists Accepts one iterable (e.g., list, tuple, set), and adds its elements to the end of the list
Mutation Modifies the original list in place Modifies the original list in place
Return Value Returns None Returns None
Example my_list.append(5) my_list.extend([6, 7, 8])
Use Case Useful for adding individual elements to a list Useful for combining multiple lists or iterable objects into one list

What is the use of '__str__' method in Python?

The '__str__' method in Python provides a custom string representation for objects. It enables instances of a class to be printed or converted to strings using functions like 'str()' or 'print()'. By implementing '__str__', developers can enhance code readability and debugging by formatting object attributes into human-readable strings, aiding in effective communication of an object's state.

What is a decorator in Python?

A decorator in Python is a function that takes another function as an argument and extends its behavior without modifying it. Decorators are typically used to add functionality to functions or methods, such as logging, authentication, or caching.

Explain the concept of list comprehensions in Python.

List comprehensions provide a concise way to create lists in Python by applying an expression to each item in an iterable. They are more readable and often more efficient than using traditional loops. 

squares = [x**2 for x in range(10)]

How does inheritance work in Python?

Inheritance allows a class to inherit attributes and methods from another class, called the superclass or parent class. A subclass or child class can access and extend the functionality of the parent class. It promotes code reusability and enables hierarchical organization of classes. Subclasses can override methods or define new ones, customizing behavior while inheriting common functionality from the parent class.

Explain the difference between '__getattr__' and '__getattribute__' in Python.

Some key difference between '__getattr__' and '__getattribute__':

Feature __getattr__ __getattribute__
Triggering Called when an attribute is not found via normal attribute lookup Called for every attribute access, even if the attribute exists
Invocation Invoked only for missing attributes Invoked for all attribute accesses, including existing ones
Control Provides a fallback mechanism for attribute access Overrides the default behavior of attribute access
Implementation Can be implemented in classes to handle dynamic attribute lookup Must be implemented carefully to avoid infinite recursion
Use Cases Useful for dynamically generating attributes or handling missing attributes Suitable for intercepting all attribute accesses and customizing behavior

What is the purpose of 'if __name__ == "__main__":' in Python scripts?

The purpose of 'if __name__ == "__main__":' in Python scripts is to provide a conditional block that executes only when the script is run directly as the main program, and not when it's imported as a module in another script. This construct allows developers to include code that should only run when the script is executed standalone, such as script-specific functionality, test code, or initialization routines. It helps differentiate between script execution and module importation, promoting code modularity and reusability.

What is the difference between '==' and 'is' operators in Python?

Some key difference between '==' and 'is' operators:

Feature '==' Operator 'is' Operator
Comparison Compares the values of two objects Checks if two objects refer to the same memory location
Usage Used to test for equality of values Used to test for object identity
Example a == b returns True if the values of a and b are equal a is b returns True if a and b refer to the same object in memory
Implementation Implemented by the __eq__() method Implemented by the __is__() method
Immutable Objects Works with both mutable and immutable objects Works with immutable objects such as integers and strings, but may not work as expected with mutable objects due to object recycling in memory

How do you open and read a file in Python?

We can open and read a file in Python using the 'open()' function.

with open('file.txt', 'r') as f:
    data =

What is the purpose of the '__init__' method in Python?

The '__init__' method is a special method in Python classes used to initialize objects. It is called automatically when a new instance of the class is created and is commonly used to set up initial values for object attributes.

How do you handle exceptions in Python?

Exceptions in Python are handled using:

  • try: The try block is used to enclose the code that may raise an exception.
  • except: The except block is used to catch and handle exceptions. You can specify the type of exception to catch, or use a generic except block to catch any exception.
  • else: The else block is optional and is executed only if no exception occurs in the try block.
  • finally: The finally block is optional and is executed regardless of whether an exception occurs or not. It is typically used to perform cleanup actions, such as closing files or releasing resources.
    # Code that may raise an exception
    result = 10 / 0
except ZeroDivisionError as e:
    # Handling specific exception
    print("Error:", e)
except Exception as e:
    # Handling any other exception
    print("An error occurred:", e)
    # Executed if no exception occurs
    print("No exception occurred")
    # Cleanup actions
    print("Finally block executed")

How do you create a generator function in Python?

Generator functions in Python are defined like regular functions but use the 'yield' keyword to return values one at a time, suspending and resuming their state between each call. 

def my_generator():
    yield 1
    yield 2
    yield 3

gen = my_generator()
for value in gen:

Explain the difference between 'yield' and 'return' in Python.

'return' is a statement that terminates the execution of a function and returns a value to the caller. 'yield', on the other hand, is used in generator functions to produce a sequence of values, suspending and resuming execution between each value. While 'return' exits the function permanently, 'yield' allows the function to produce multiple values over time, maintaining its state between calls.

What are lambda functions in Python, and when are they used?

Lambda functions, also known as anonymous functions, are small, single-expression functions defined using the 'lambda' keyword. They are used when a function is needed for a short period and is unlikely to be reused elsewhere. Lambda functions are commonly used with higher-order functions like 'map()', 'filter()', and 'sorted()'.

How do you perform multithreading in Python?

Multithreading can be performed using the threading module:

  • Import the threading module: Start by importing the threading module.
  • Define a function: Create a function that represents the task you want to perform concurrently.
  • Create Thread objects: Instantiate Thread objects, passing the function to execute as the target parameter.
  • Start the threads: Call the start() method on each Thread object to start the execution of the target function concurrently.
  • Join the threads (optional): If you want the main program to wait for all threads to finish execution, call the join() method on each Thread object.

What is a dictionary in Python?

A dictionary in Python is an unordered collection of key-value pairs. It's defined using curly braces '{ }' and can be accessed, modified, and iterated over using its keys and values. Dictionaries are commonly used to store and manipulate data in a structured way, with fast lookups based on keys.

How do you remove duplicates from a list in Python?

You can remove duplicates from a list in Python using various approaches. One common method is to convert the list to a set, which automatically removes duplicates due to its property of uniqueness, and then convert it back to a list. Another approach is to use a loop or list comprehension to iterate over the list and filter out duplicate elements.

Explain the use of 'map()' and 'filter()' functions in Python.

'map()' and 'filter()' are built-in functions in Python used to transform and filter iterables, respectively. 'map()' applies a function to each element of an iterable and returns an iterator of the results. 'filter()' applies a function to each element of an iterable and returns an iterator containing only the elements for which the function returns 'True'.

What is the purpose of the '' file in Python packages?

The '' file in Python packages serves two purposes: it indicates that the directory is a Python package, and it can also be used to initialize the package's namespace. It's executed when the package is imported, allowing for initialization code or exposing selected objects from within the package.

Explain the concept of slicing in Python.

Slicing in Python refers to extracting a subset of elements from an iterable (such as a list, string, or tuple) using a specified start, stop, and step size. It's done using the syntax 'iterable[start:stop:step]', where 'start' is the starting index, 'stop' is the stopping index (exclusive), and 'step' is the step size.

What is a set in Python?

A set in Python is an unordered collection of unique elements. It's defined using curly braces '{ }' or the 'set()' constructor. Sets support operations like union, intersection, difference, and symmetric difference, making them useful for tasks like removing duplicates or testing membership.

How do you handle regular expressions in Python?

Python's 're' module provides support for regular expressions. Regular expressions are patterns used to match character combinations in strings. Here's a basic example:

import re

pattern = r'\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b'
text = "Contact us at [email protected]"

if re.match(pattern, text, re.IGNORECASE):
    print("Valid email address")
    print("Invalid email address")

How do you iterate over a dictionary in Python?

You can iterate over a dictionary in Python using a loop or dictionary methods. For example, you can use a 'for' loop to iterate over the keys, values, or key-value pairs using the 'items()' method.

Explain the differences between 'deepcopy()' and 'copy()' in Python.

Some key difference between 'deepcopy()' and 'copy()' in Python:

Feature deepcopy() copy()
Module Provided by the copy module Provided by the copy module
Type of Copy Creates a deep copy of objects, including nested objects Creates a shallow copy of objects, only copying the top-level structure
Recursive Copy Recursively copies all objects, including nested objects Only copies the top-level objects, leaving references to nested objects unchanged
Memory Usage May consume more memory due to duplicating nested objects Generally consumes less memory, as it does not duplicate nested objects
Performance May be slower, especially for deeply nested structures Generally faster, as it does not perform recursive copying
Use Cases Useful when you need a completely independent copy of objects, unaffected by changes to the original Suitable when you only need a shallow copy and don't want to duplicate nested objects

What is the purpose of the 'zip()' function in Python?

The 'zip()' function in Python is used to combine multiple iterables (lists, tuples, etc.) element-wise into a single iterator of tuples. It returns an iterator that generates tuples where the 'i'th tuple contains the 'i'th element from each of the input iterables.

How do you sort a dictionary by value in Python?

You can sort a dictionary by its values in Python using the 'sorted()' function with a custom key argument that specifies sorting based on values rather than keys. Alternatively, you can use the 'items()' method to convert the dictionary into a list of tuples, sort the list based on values, and then convert it back to a dictionary.

 What are context managers in Python?

Context managers in Python are objects that enable the execution of certain code blocks within a context, typically ensuring resource management (like opening and closing files) or setting up and tearing down of conditions (like acquiring and releasing locks). They are implemented using the 'with' statement. Here's an example using a file context manager:

with open('file.txt', 'r') as f:
    data =

What is the purpose of the 'with' statement in Python?

The 'with' statement in Python is used to ensure proper acquisition and release of resources, such as files or network connections. It simplifies resource management by automatically closing or releasing resources when the block of code inside the 'with' statement exits, even if an exception occurs.

Explain the Global Interpreter Lock (GIL) in Python.

The Global Interpreter Lock (GIL) in Python is a mutex that protects access to Python objects, preventing multiple native threads from executing Python bytecode simultaneously. This means that only one thread can execute Python bytecode at a time, limiting the parallelism achievable with multithreading for CPU-bound tasks.

How do you handle JSON data in Python?

JSON data in Python can be handled using the 'json' module, which provides functions for encoding Python data structures into JSON strings ('json.dumps()') and decoding JSON strings into Python data structures ('json.loads()'). This allows for interoperability between Python and other systems that use JSON for data interchange.

How do you perform unit testing in Python?

Unit testing in Python can be performed using the built-in 'unittest' framework or third-party libraries like 'pytest'. Unit tests are written as separate functions or methods that verify the behavior of individual units (functions, methods, or classes) of code in isolation.

Explain the difference between 'os.path.join()' and 'os.join.path()' in Python.

Some key difference between 'os.path.join()' and 'os.join.path()' in Python:

Feature os.path.join() os.join.path()
Purpose Combines multiple path components into a single path Not a standard function in the os module
Module Part of the os.path module Non-existent function in the os module
Function Invocation os.path.join(path1, path2, ...) Invalid function name
Return Value Returns a normalized path string Not applicable
Usage Commonly used for constructing file paths in a platform-independent manner Does not exist as a built-in function

What are Python decorators and how do you use them?

Python decorators are functions that modify the behavior of other functions or methods. They allow you to add functionality to existing code without modifying it. Decorators are typically used to wrap functions or methods with additional logic.

def my_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        print("Something is happening after the function is called.")
    return wrapper

def say_hello():


What is the purpose of the 'asyncio' module in Python?

The 'asyncio' module in Python provides infrastructure for writing single-threaded concurrent code using coroutines, multiplexing I/O access over sockets and other resources, running network clients and servers, and other related primitives. It's particularly useful for writing scalable I/O-bound network servers.

How do you connect to a database using Python?

Python provides several libraries for connecting to databases, such as 'sqlite3', 'MySQLdb', 'psycopg2' (for PostgreSQL), and 'pymongo' (for MongoDB). Here's a simple example using 'sqlite3':

import sqlite3

conn = sqlite3.connect('example.db')
cursor = conn.cursor()

cursor.execute('''CREATE TABLE IF NOT EXISTS stocks
               (date text, trans text, symbol text, qty real, price real)''')

cursor.execute("INSERT INTO stocks VALUES ('2006-01-05','BUY','RHAT',100,35.14)")


Explain the purpose of the 'pickle' module in Python.

The 'pickle' module in Python is used for serializing and deserializing Python object structures. It can convert complex Python objects into a byte stream and vice versa, allowing objects to be persisted to files or sent over the network.

Explain the purpose of the 'sys' module in Python.

The 'sys' module provides access to some variables used or maintained by the Python interpreter, as well as functions that interact strongly with the interpreter. It's often used for accessing command-line arguments, exiting the interpreter, or interacting with the Python runtime environment.

What is the purpose of the 'logging' module in Python?

The 'logging' module in Python provides a flexible framework for emitting log messages from Python programs. It supports various logging levels and destinations (such as files, streams, sockets), making it suitable for a wide range of logging needs, from simple to complex.

How do you create and use classes in Python?

Classes in Python are created using the 'class' keyword. They encapsulate data for the object and define methods to operate on that data. 

class MyClass:
    def __init__(self, name): = name

    def greet(self):

obj = MyClass("Alice")

What are iterators and iterables in Python?

Iterator is an object that implements the iterator protocol, which consists of the methods '__iter__()' and '__next__()'. Iterables are objects that can return iterators. Iterators are used to traverse sequences, like lists or strings, while iterables are objects that can be iterated over.

Explain the difference between a shallow copy and a deep copy in Python.

A shallow copy creates a new object but does not recursively copy the objects inside. A deep copy, on the other hand, creates a new object and recursively copies the objects found in the original. Changes to the original objects in a deep copy will not affect the copied objects, whereas changes in a shallow copy may.

How do you handle errors and exceptions in Python?

Errors and exceptions in Python are handled using 'try', 'except', and optionally 'finally' blocks. The 'try' block contains the code that may raise an exception, and the 'except' block catches and handles the exceptions. 

    result = 10 / 0
except ZeroDivisionError:
    print("Error: Division by zero")

What is the purpose of the 'collections' module in Python?

The 'collections' module in Python provides specialized container datatypes beyond the built-in types like lists and dictionaries. It includes classes like 'deque', 'Counter', 'OrderedDict', and 'defaultdict', which are useful for specific tasks like counting elements, maintaining order, and implementing stacks or queues.

How do you implement multithreading in Python?

Multithreading in Python can be implemented using the 'threading' module. Threads are lightweight processes within a process, allowing for concurrent execution. 

import threading

def print_numbers():
    for i in range(5):

thread = threading.Thread(target=print_numbers)

Explain the purpose of the 'os' module in Python.

The 'os' module in Python provides a way of using operating system-dependent functionality. It allows you to interact with the operating system, such as navigating the filesystem, executing shell commands, and accessing environment variables.

How do you handle binary data in Python?

Binary data in Python can be handled using the built-in 'bytes' and 'bytearray' types. These represent sequences of bytes, which can be manipulated using various methods and functions. 

data = b'hello'

What is the purpose of the 'random' module in Python?

The 'random' module in Python provides functions for generating random numbers, selecting random elements from sequences, and shuffling sequences. Its purpose is to introduce randomness into Python programs, which is useful for various tasks such as simulations, games, statistical sampling, and cryptography. The 'random' module includes functions like 'random()', 'randint()', 'choice()', 'shuffle()', and 'sample()', allowing developers to incorporate random behavior into their programs easily. This module is essential for creating unpredictable outcomes and adding variability to Python applications.

How do you create and use virtual environments in Python?

Virtual environments in Python can be created using the 'venv' module (or 'virtualenv' package). They allow you to isolate Python environments, including dependencies and packages, for different projects. Here's how you create and activate a virtual environment:

python -m venv myenv
source myenv/bin/activate  # On Unix/Linux
myenv\Scripts\activate.bat  # On Windows

What is the purpose of the 're' module in Python?

The 're' module in Python facilitates pattern matching and manipulation of strings using regular expressions. It enables tasks such as searching for specific patterns, validating input data, and extracting substrings based on predefined rules. With 're', developers can perform complex text transformations efficiently, making it essential for tasks involving text processing, data validation, and parsing in Python applications.