Python Interview Questions

Python is an interpreted language, but internally it follows multiple steps before executing code.

When a Python file is executed:

1. Python reads the source code.

2. It checks for syntax errors.

3. The code is compiled into bytecode (.pyc).

4. The Python Virtual Machine (PVM) executes the bytecode.

5. The program produces the output.

Because Python uses an interpreter, developers do not manually compile programs before running them.

A variable is a name used to store data in memory.

Unlike many programming languages, Python does not require developers to declare the data type explicitly. The interpreter automatically determines the type based on the assigned value.

Variables can store:

• Numbers

• Strings

• Lists

• Dictionaries

• Objects

• Functions

Python uses dynamic typing, meaning a variable can hold different types of values during execution.

Python provides several built-in data types for storing and manipulating data.

The most commonly used types are:

• int – Integer values

• float – Decimal values

• str – Text

• bool – True or False

• list – Ordered, mutable collection

• tuple – Ordered, immutable collection

• set – Unordered collection of unique elements

• dict – Key-value pairs

• NoneType – Represents the absence of a value

Choosing the appropriate data type helps improve code readability and performance.

A list is an ordered and mutable collection that can store multiple values, including values of different data types.

Lists allow duplicate elements and support indexing, slicing, updating, insertion, and deletion.

Because they are mutable, developers can modify a list after it has been created.

Lists are commonly used to store collections such as user records, product names, or API responses.

skills = ["Python", "React", "MongoDB"]
print(skills[0])
skills.append("Docker")
print(skills)

Output 
['Python', 'React', 'MongoDB', 'Docker']

A tuple is similar to a list because it stores multiple values in an ordered sequence. However, once a tuple is created, its contents cannot be modified.

Tuples are useful when working with data that should remain constant, such as coordinates, configuration values, or fixed records.

Since tuples are immutable, they are generally more memory-efficient and can be used as dictionary keys if all their elements are hashable.

A dictionary stores data as key-value pairs, allowing fast lookup based on unique keys.

Unlike lists, which access elements by index, dictionaries retrieve values using keys.

They are commonly used for storing structured data such as user profiles, product information, or configuration settings.

Dictionary keys must be unique and immutable, while values can be of any data type.

user = {
    "name": "Sam",
    "age": 24,
    "city": "Delhi"
}

print(user["name"])

Output 
Sam

Conditional statements allow a program to make decisions based on specific conditions.

Python provides:

• if

• elif

• else

The program evaluates each condition in order and executes the block associated with the first condition that evaluates to True.

Conditional statements are used in authentication, validation, business rules, and many other scenarios.

age = 20

if age >= 18:
    print("Eligible")
else:
    print("Not Eligible")

Output 
Eligible

Loops allow the same block of code to execute multiple times without rewriting it.

Python supports:

• for loop – Used to iterate over sequences such as lists, tuples, strings, or ranges.

• while loop – Executes as long as a condition remains true.

Loops are widely used for processing collections, reading files, performing calculations, and automating repetitive tasks.

for i in range(1, 6):
    print(i)

Output 
1
2
3
4
5

A function is a reusable block of code designed to perform a specific task.

Functions help organize code, reduce duplication, improve readability, and simplify maintenance. Instead of writing the same logic multiple times, developers can define it once and call it whenever needed.

Python supports:

• Built-in functions

• User-defined functions

• Lambda functions

• Recursive functions

Functions also make testing and debugging easier because each function has a well-defined responsibility.

def greet(name):
    return f"Hello, {name}"

print(greet("Sam"))

Output 
Hello, Sam

Object-Oriented Programming (OOP) is a programming paradigm that organizes code using classes and objects. A class acts as a blueprint, while an object is an instance of that blueprint.

OOP helps developers create modular, reusable, and maintainable code. It is especially useful for large applications because it groups related data and behavior together.

Python supports all major OOP concepts:

• Class

• Object

• Inheritance

• Encapsulation

• Polymorphism

• Abstraction

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

    def introduce(self):
        return f"My name is {self.name}"

student = Student("Peter")

print(student.introduce())

Output 
My name is Peter

Inheritance allows one class to inherit properties and methods from another class. This eliminates duplicate code and makes applications easier to maintain.

Polymorphism allows the same method name to behave differently depending on the object calling it.

Together, these concepts make applications more flexible and scalable.

class Animal:
    def sound(self):
        pass

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

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

print(Dog().sound())
print(Cat().sound())

Output 
Bark
Meow

A module is a single Python file containing variables, functions, or classes.

A package is a directory that contains multiple related modules and helps organize large applications.

Using modules and packages improves code organization, reusability, and maintainability.

Python provides many built-in modules such as:

• math

• random

• os

• datetime

• json

• collections

Exceptions occur when a program encounters an unexpected error during execution.

Without exception handling, the program terminates immediately.

Python provides:

• try

• except

• else

• finally

These blocks allow developers to gracefully handle errors instead of crashing the application.

Python provides built-in functions for working with files.

The open() function is used to open a file in different modes such as:

• Read (r)

• Write (w)

• Append (a)

• Binary (rb, wb)

Using the with statement is recommended because it automatically closes the file after use.

A decorator is a function that modifies or extends the behavior of another function without changing its source code.

Decorators are commonly used for:

• Logging

• Authentication

• Authorization

• Performance Monitoring

• Caching

• Input Validation

Frameworks like Flask, Django, and FastAPI use decorators extensively for routing and middleware.