Python continues to be one of the most widely used programming languages for web development, automation, data analysis, testing, scripting, artificial intelligence, and many other areas of software development.

Because Python is relatively easy to learn, interviewers often go beyond basic syntax. They may ask about object-oriented programming, memory management, iterators, decorators, asynchronous programming, exception handling, and other concepts that reveal how well you understand the language.

If you are preparing for a Python interview, the following questions cover a useful mix of beginner, intermediate, and advanced topics. The explanations are written with practical interview discussions in mind, so you can understand not only what each concept means but also when it is useful.

1. What are the main features of Python?

Python is a high-level, general-purpose programming language known for its readable syntax and large ecosystem.

Some of its important characteristics are:

• Readable syntax: Python code is generally concise and easy to understand.
• Dynamically typed: You do not normally declare a variable's type explicitly.
• Object-oriented: Python supports classes, inheritance, encapsulation, and polymorphism.
• Multi-paradigm: You can use procedural, object-oriented, functional, and other programming styles.
• Large standard library: Python includes modules for tasks such as file handling, JSON processing, networking, dates, testing, and more.
• Extensive third-party ecosystem: Thousands of packages are available through the Python Package Index (PyPI).
• Cross-platform: Python programs can run on Windows, macOS, Linux, and other supported platforms.
• Automatic memory management: Python manages object memory automatically through mechanisms such as reference counting and garbage collection in CPython.

Python is also widely used because developers can usually build and maintain applications with less code than in many lower-level languages.

2. What is the difference between Python 2 and Python 3?

Python 2 reached its official end of life in January 2020, so Python 3 is the version used for current development.

There are several important differences between the two versions.

The print function

Python 2 allowed:

print "Hello"

Python 3 uses print() as a function:

print("Hello")

Division

In Python 3, / performs true division:

print(5 / 2)

The result is:

2.5

For floor division, Python 3 uses //:

print(5 // 2)

The result is:

2

Strings

Python 3 uses Unicode text strings by default. Python 2 distinguished between ordinary byte strings and Unicode strings in a way that often required additional handling.

For modern projects, Python 3 should be used rather than Python 2.

3. What is a decorator in Python?

A decorator is a callable that allows you to modify or extend the behavior of another function or class without changing its original implementation.

Decorators are commonly used for logging, authorization, caching, timing, validation, and other cross-cutting functionality.

For example:

def log_call(func):
    def wrapper():
        print("Function is being called")
        return func()

    return wrapper


@log_call
def say_hello():
    print("Hello!")


say_hello()

The @log_call syntax applies the decorator to say_hello().

In real applications, decorators often need to accept arbitrary arguments. In that situation, *args and **kwargs are commonly used in the wrapper.

It is also good practice to use functools.wraps() when writing reusable decorators because it preserves useful metadata from the original function.

4. What is a lambda function?

A lambda is a small anonymous function created using the lambda keyword.

For example:

add = lambda x, y: x + y

print(add(5, 3))

Output:

8

A lambda can accept multiple arguments, but its body must contain a single expression.

Lambdas are often useful for short operations passed to functions such as sorted(), map(), or filter().

For example:

names = ["John", "Alex", "Robert"]

names.sort(key=lambda name: len(name))

For complicated logic, a normal def function is usually easier to read.

5. How does Python manage memory and garbage collection?

Python automatically manages memory, so developers generally do not have to manually allocate and release memory.

In CPython, one of the primary mechanisms is reference counting. When an object's reference count reaches zero, the object can generally be deallocated immediately.

Reference counting alone cannot handle every situation. For example, two objects can reference each other and form a cycle. CPython therefore also has a cyclic garbage collector that can detect and clean up certain reference cycles.

Python's memory management is more complicated internally than simply “unused objects are deleted.” Objects are allocated through Python's memory-management system, and implementation details can vary between Python implementations.

For most application development, the important point is that Python handles object memory automatically, while developers should still avoid unnecessarily retaining references to objects that are no longer needed.

6. What is the difference between shallow copy and deep copy?

Python provides copy.copy() for shallow copying and copy.deepcopy() for deep copying.

Consider this example:

import copy

original = [[1, 2], [3, 4]]

shallow = copy.copy(original)
deep = copy.deepcopy(original)

A shallow copy creates a new outer object but keeps references to the nested objects.

A deep copy recursively copies nested objects as well.

This difference matters when working with mutable objects such as lists and dictionaries.

For example:

shallow[0].append(5)

The nested list referenced by shallow is also referenced by original, so the change can be visible through both objects.

With deepcopy(), the nested list is copied, so modifying the copied structure does not modify the corresponding nested object in the original structure.

Deep copying is not always necessary, however. It can be more expensive and may have special behavior with certain objects. The correct approach depends on what kind of object you are copying.

7. What is a generator in Python?

A generator is an iterator that produces values lazily instead of creating all of its results at once.

A generator function uses the yield keyword.

For example:

def count_up_to(limit):
    number = 1

    while number <= limit:
        yield number
        number += 1


for value in count_up_to(5):
    print(value)

The function produces one value at a time.

This can be particularly useful when processing large files, database results, API responses, or streams of data because the entire result does not have to be stored in memory at once.

A generator is not automatically “faster” than a list. Its main advantage is lazy evaluation and reduced memory usage when only one item at a time is required.

8. How does multithreading work in Python?

Python provides the threading module for creating and managing threads.

For CPython, the Global Interpreter Lock (GIL) has traditionally meant that only one thread at a time executes Python bytecode in the standard GIL-enabled interpreter.

Because of this, threads are commonly useful for I/O-bound work such as:

• Network requests
• File operations
• Waiting for external services
• Database operations

For CPU-intensive work, multiprocessing or other approaches may be more appropriate when using a traditional GIL-enabled CPython build.

There is an important modern qualification: recent Python versions include support for free-threaded CPython builds, which can run without the traditional GIL. Therefore, saying “Python can never execute Python code in parallel because of the GIL” is no longer completely accurate.

When answering this question in an interview, it is better to explain the GIL in the context of the particular Python implementation and build being discussed.

9. What are Python's built-in data types?

Python provides several built-in data types.

Numeric types

• int
• float
• complex

Sequence types

• list
• tuple
• range

Text type

• str

Mapping type

• dict

Set types

• set
• frozenset

Boolean type

• bool

Binary types

• bytes
• bytearray
• memoryview

Python also has NoneType, whose only value is None.

Choosing the appropriate type depends on the problem. For example, a list is useful for a mutable sequence, while a tuple can represent a fixed collection of values.

10. What is self in Python?

self refers to the current instance when an instance method is called.

For example:

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

    def display_name(self):
        print(self.name)

When we create an object:

employee = Employee("John")
employee.display_name()

Python passes the employee instance to display_name() as the first argument.

self is a convention rather than a Python keyword. You could technically use another name, but using self is the standard and recommended practice.

It allows an instance method to access instance attributes and other instance methods.

11. What are comprehensions in Python?

Comprehensions provide a concise way to create collections from iterable objects.

List comprehension

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

Set comprehension

unique_squares = {x ** 2 for x in range(10)}

Dictionary comprehension

square_dict = {x: x ** 2 for x in range(10)}

Comprehensions can also include conditions:

even_numbers = [x for x in range(10) if x % 2 == 0]

They are useful when the logic remains easy to understand. If a comprehension becomes too complicated, a normal loop may be more readable.

12. What is the purpose of __init__()?

__init__() is a special method that is normally called to initialize an instance after the instance has been created.

For example:

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

Now:

employee = Employee("John", "IT")

causes the initialization method to receive the values "John" and "IT".

An important interview detail is that __init__() does not actually create the object. Object creation is handled through mechanisms involving __new__(). __init__() is responsible for initializing the newly created instance.

13. How does exception handling work in Python?

Python uses try, except, else, and finally blocks for exception handling.

For example:

try:
    result = 10 / 0
except ZeroDivisionError:
    print("Cannot divide by zero")
finally:
    print("Execution completed")

The try block contains code that may raise an exception.

The except block handles a matching exception.

The finally block runs whether an exception occurs or not, making it useful for cleanup operations.

Python also supports an else block:

try:
    result = 10 / 2
except ZeroDivisionError:
    print("Invalid operation")
else:
    print(result)

The else block executes when the try block completes without raising an exception.

14. What is the difference between is and ==?

The operators == and is serve different purposes.

== compares values:

a = [1, 2, 3]
b = [1, 2, 3]

print(a == b)

Output:

True

is checks object identity:

print(a is b)

Output:

False

Although the lists contain the same values, they are two different objects.

If we write:

c = a

print(a is c)

the result is:

True

because both variables refer to the same object.

A common recommendation is to use is for identity checks, especially when checking for None:

if value is None:
    ...

15. How do you manage Python packages and dependencies?

Python packages are commonly installed using package-management tools such as pip.

For example:

pip install requests

Projects can specify dependencies in a requirements.txt file:

requests
pytest

They can then be installed with:

pip install -r requirements.txt

Python also provides the built-in venv module for creating virtual environments:

python -m venv .venv

A virtual environment keeps project dependencies isolated from the system Python installation and from other projects.

For larger projects, developers may also use modern packaging and dependency-management tools such as Poetry, uv, or PDM.

16. What are Python's main data structures?

Python provides several important built-in data structures.

List

A list is ordered and mutable, and it can contain duplicate values.

numbers = [1, 2, 3, 2]

Tuple

A tuple is ordered and immutable.

coordinates = (10, 20)

Set

A set stores unique elements and supports efficient membership testing.

numbers = {1, 2, 3}

Dictionary

A dictionary stores key-value pairs.

person = {
    "name": "John",
    "age": 30
}

Modern Python dictionaries preserve insertion order. This behavior is part of the Python language specification in current Python versions.

Each data structure has different characteristics, so the choice should depend on the operation you need to perform.

17. What is a context manager in Python?

A context manager defines a runtime context and ensures that setup and cleanup operations are handled correctly.

The with statement is commonly used with context managers.

For example:

with open("example.txt", "r") as file:
    content = file.read()

Once the with block finishes, the file is automatically closed.

Context managers are useful whenever a resource needs reliable cleanup, including files, database connections, locks, and other resources.

You can also create your own context manager by implementing __enter__() and __exit__(), or by using contextlib.

18. How do you perform unit testing in Python?

Python includes the unittest module for writing unit tests.

For example:

import unittest


class TestMathOperations(unittest.TestCase):

    def test_addition(self):
        self.assertEqual(1 + 1, 2)


if __name__ == "__main__":
    unittest.main()

Python developers also commonly use third-party testing frameworks such as pytest.

A good unit test should generally test one behavior or logical unit and should produce a predictable result.

Tests can help catch regressions when an application is modified or extended.

19. What is an async function in Python?

An async function is a coroutine function that can use await to pause its execution while waiting for an asynchronous operation.

For example:

import asyncio


async def say_hello():
    await asyncio.sleep(1)
    print("Hello")


asyncio.run(say_hello())

Asynchronous programming is particularly useful for applications that spend significant time waiting for I/O operations, such as network requests.

The important point is that async does not automatically make CPU-intensive code faster. It is primarily a model for handling concurrency, especially around asynchronous I/O.

20. What are the global and nonlocal keywords?

Both keywords affect variable scope, but they refer to different scopes.

The global keyword tells Python that a variable inside a function refers to a variable defined at module level.

count = 0


def increase():
    global count
    count += 1

The nonlocal keyword is used inside nested functions when you want to modify a variable belonging to an enclosing function.

def outer():
    count = 10

    def inner():
        nonlocal count
        count += 1

    inner()
    print(count)


outer()

Output:

11

In general, excessive use of global state can make code harder to maintain, so these keywords should be used when they genuinely fit the design.

21. Does Python support method overloading?

Python does not support traditional compile-time method overloading in the same way languages such as Java or C++ do.

If you define multiple methods with the same name in a Python class, the later definition replaces the earlier one.

Instead, Python developers can use default arguments, *args, **kwargs, or other techniques to support different calling patterns.

For example:

def greet(name=None):
    if name is None:
        print("Hello!")
    else:
        print(f"Hello, {name}!")


greet()
greet("Alice")

This provides behavior similar to simple method overloading without defining multiple methods with the same name.

22. What is a metaclass in Python?

A metaclass is the class used to create classes.

In the same way that an object is an instance of a class, a class is normally an instance of the type metaclass.

For example:

class Meta(type):
    def __new__(cls, name, bases, namespace):
        print(f"Creating class: {name}")
        return super().__new__(cls, name, bases, namespace)


class MyClass(metaclass=Meta):
    pass

When MyClass is created, the metaclass participates in the class-creation process.

Metaclasses are an advanced feature. They can be useful for frameworks, automatic class registration, validation, and other specialized tasks, but they are usually unnecessary for ordinary application code.

23. What is the purpose of __str__()?

__str__() defines the informal, human-readable representation of an object.

For example:

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

    def __str__(self):
        return f"Employee: {self.name}"


employee = Employee("John")

print(employee)

Output:

Employee: John

When an object is passed to str() or generally displayed using print(), Python can use __str__() to obtain a readable representation.

For debugging and developer-oriented representations, classes can also implement __repr__().

24. What is the difference between append() and extend()?

Both methods add data to a list, but they behave differently.

append() adds one object to the end of a list:

numbers = [1, 2, 3]

numbers.append([4, 5])

print(numbers)

Result:

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

extend() takes an iterable and adds its elements individually:

numbers = [1, 2, 3]

numbers.extend([4, 5])

print(numbers)

Result:

[1, 2, 3, 4, 5]

A useful way to remember the difference is that append() adds one object, while extend() adds the items produced by iterating over another iterable.

25. What are some commonly used Python built-in functions?

Python provides many functions that are available without importing additional modules.

Some commonly used examples include:

• len() — returns the number of items.
• type() — returns an object's type.
• isinstance() — checks whether an object is an instance of a specified type or class.
• range() — creates a range object.
• sum() — calculates the sum of values.
• min() — returns the smallest value.
• max() — returns the largest value.
• sorted() — returns a sorted list from an iterable.
• enumerate() — provides indexes while iterating.
• zip() — combines elements from multiple iterables.
• map() — applies a function to items in an iterable.
• filter() — selects items based on a condition.

Knowing these functions can make Python code shorter and more expressive.

26. How can you handle a missing key in a dictionary?

There are several ways to deal with a key that may not exist.

Using get()

person = {"name": "John"}

age = person.get("age", 0)

print(age)

Output:

0

Unlike direct indexing, get() does not raise KeyError when the key is missing.

Using setdefault()

person.setdefault("age", 30)

This inserts the key with the specified default value if the key does not already exist.

Using defaultdict

The collections module provides defaultdict:

from collections import defaultdict

counts = defaultdict(int)

counts["apple"] += 1

Here, a missing key automatically gets the default value produced by int(), which is 0.

The appropriate approach depends on whether you simply need to read a value, insert a default, or repeatedly build a collection.

27. What is monkey patching in Python?

Monkey patching means modifying a class, module, or object at runtime.

For example:

class MyClass:
    def greet(self):
        return "Hello"


def new_greet(self):
    return "Hi"


MyClass.greet = new_greet

obj = MyClass()

print(obj.greet())

Output:

Hi

The original greet() method has been replaced at runtime.

Monkey patching can be useful in testing and in certain frameworks, but it can also make software harder to understand and maintain because behavior is changed dynamically.

For production code, explicit dependency injection or other design approaches are often easier to maintain when they can achieve the same goal.

28. How does list slicing work in Python?

List slicing allows you to retrieve part of a sequence.

The general syntax is:

sequence[start:stop:step]

For example:

numbers = [0, 1, 2, 3, 4, 5, 6]

print(numbers[1:5])

Output:

[1, 2, 3, 4]

The stop index is not included.

You can also omit the start or stop value:

print(numbers[:3])

Result:

[0, 1, 2]

And you can specify a step:

print(numbers[::2])

Result:

[0, 2, 4, 6]

Negative steps can be used to traverse a sequence in reverse:

print(numbers[::-1])

This produces a reversed copy of the list.

29. What is the purpose of the with statement?

The with statement is used to work with context managers.

Its main benefit is that it helps ensure that resources are cleaned up correctly after the block finishes.

For example:

with open("data.txt", "r") as file:
    data = file.read()

The file is closed automatically when the with block is exited, including when an exception occurs during the block.

The with statement is not limited to files. It can also be used with locks, database connections, temporary resources, and custom context managers.

Because Question 17 already introduces context managers, this question is closely related. In an interview, you can explain that the context manager defines the setup and cleanup behavior, while the with statement provides the syntax for using that context safely.

30. What are *args and **kwargs in Python?

*args allows a function to receive a variable number of positional arguments.

For example:

def show_values(*args):
    for value in args:
        print(value)


show_values(10, 20, 30)

Inside the function, args is a tuple.

**kwargs allows a function to receive a variable number of keyword arguments.

def show_details(**kwargs):
    for key, value in kwargs.items():
        print(f"{key} = {value}")


show_details(name="John", age=30)

Inside the function, kwargs is a dictionary.

The names args and kwargs are conventions. The * and ** syntax is what gives the parameters their special behavior.

You can also combine them with regular parameters:

def example(name, *args, **kwargs):
    print(name)
    print(args)
    print(kwargs)

This pattern is particularly common when writing flexible functions, wrappers, decorators, and APIs.

Final Thoughts

Preparing for a Python interview is not only about memorizing definitions. Interviewers often want to know whether you understand why a particular feature exists, when you would use it, and what trade-offs it introduces.

Start with the fundamentals such as data types, lists, dictionaries, functions, exceptions, and classes. Once those concepts are comfortable, spend time on generators, decorators, context managers, asynchronous programming, memory management, and Python's object model.

It is also worth practicing small coding problems alongside these theory questions. A strong interview preparation routine should combine conceptual understanding with the ability to write and explain working Python code.

Most importantly, when you encounter a Python interview question, try to explain the concept in your own words and support the explanation with a small example. That usually demonstrates a much deeper understanding than simply recalling a definition.