100 Python Interview Questions with Answers

Python is a high-level, interpreted, general-purpose programming language known for readable syntax and a large ecosystem. It's used for web development, data analysis, automation, and AI/ML because it lets developers build and iterate quickly.

Easy-to-read syntax, dynamic typing, interpreted execution, an extensive standard library, cross-platform support, and a strong community-driven package ecosystem (PyPI).

Python source is first compiled to bytecode (.pyc) and then executed by the Python Virtual Machine (PVM) — so it's technically both, though it's commonly described as an interpreted language.

PEP 8 is Python's official style guide covering naming conventions, indentation, and formatting to keep code consistent and readable across projects.

Python 3 uses print() as a function, true division by default, and unicode strings by default, and is the actively maintained version; Python 2 reached end-of-life in 2020.

A collection of built-in modules (like os, sys, math, json) that ship with Python and provide ready-made functionality without needing external installation.

Python uses automatic memory management via reference counting plus a cyclic garbage collector to reclaim memory from objects with circular references.

PEPs (Python Enhancement Proposals) are design documents proposing new features or conventions for Python; PEP 8 (style) and PEP 20 (Zen of Python) are among the most referenced.

A set of guiding principles for writing Python code, viewable via import this, emphasizing readability and simplicity — e.g. "Simple is better than complex."

Web development (Django/Flask), data analysis (pandas), machine learning (TensorFlow/PyTorch), automation and scripting, and backend APIs.

int, float, complex, str, bool, list, tuple, dict, set, frozenset, and NoneType.

Mutable objects (list, dict, set) can be changed after creation; immutable objects (int, str, tuple) cannot — any "change" actually creates a new object.

Using the built-in type() function, e.g. type(x).

Explicitly converting one data type to another using functions like int(), str(), float() — e.g. int("5") converts a string to an integer.

== compares values for equality; is compares object identity — whether two references point to the same object in memory.

A special singleton value representing the absence of a value, similar to null in other languages.

No. Variables are names bound to objects in memory, and Python is dynamically typed, so you don't declare a variable's type explicitly.

The region of code where a variable is accessible, governed by the LEGB rule: Local, Enclosing, Global, Built-in.

Local variables exist within a function's scope; global variables are defined at module level and accessible throughout, unless a function explicitly declares global.

A variable's type is determined at runtime based on the value assigned, and the same variable name can later be rebound to a value of a different type.

== != > < >= <= — used to compare two values and return a boolean.

/ performs true (float) division; // performs floor division, returning the largest integer less than or equal to the result.

It evaluates conditions top to bottom and executes the block under the first True condition, falling back to else if none match.

for iterates over a sequence or iterable for a known/finite range; while repeats as long as a condition stays True, useful when the number of iterations isn't known upfront.

break exits a loop entirely; continue skips to the next iteration; pass is a no-op placeholder used where syntax requires a statement.

A one-line conditional: value_if_true if condition else value_if_false.

In and/or expressions, Python stops evaluating as soon as the result is determined, returning the deciding value rather than a plain boolean.

and, or, not — used to combine or invert boolean expressions.

Introduced in Python 3.8, it lets you assign a value to a variable as part of an expression, e.g. if (n := len(data)) > 10:.

Python 3's range() returns a lazy iterable (matching Python 2's xrange); Python 2's range() built a full list in memory upfront.

Using the def keyword followed by a name, parentheses for parameters, and a colon — e.g. def greet(name):.

Parameters are the names listed in a function's definition; arguments are the actual values passed when calling the function.

Parameters that take a preset value if no argument is provided at call time, defined as def f(x=10):.

*args collects extra positional arguments into a tuple; **kwargs collects extra keyword arguments into a dictionary, letting functions accept a variable number of inputs.

An anonymous, single-expression function defined with the lambda keyword, e.g. lambda x: x * 2, often used for short throwaway operations.

A function is a standalone block of reusable code; a method is a function defined inside and bound to a class or object.

A function calling itself to solve a smaller instance of the same problem, typically requiring a base case to avoid infinite recursion.

It exits a function and optionally sends a value back to the caller; a function without an explicit return returns None.

Functions that wrap another function to extend or modify its behavior without changing its source code, applied using the @decorator syntax.

Python uses "pass by object reference": immutable objects behave like pass-by-value since they can't be modified in place, while mutable objects can be modified in place, resembling pass-by-reference.

A blueprint for creating objects, defining attributes and methods shared by all instances created from it.

A class is the definition/template; an object is a specific instance created from that class with its own state.

It's the constructor method automatically called when a new object is created, typically used to initialize instance attributes.

A reference to the current instance, used to access its attributes and methods; it's the first parameter of instance methods by convention.

A mechanism where a child class derives attributes and methods from a parent class, enabling code reuse, defined as class Child(Parent):.

When a child class provides its own implementation of a method already defined in its parent class.

The ability for different classes to implement the same method name in different ways, so the same call behaves differently depending on the object's type.

Bundling data and methods within a class and restricting direct access to some of them — implemented in Python via naming conventions (_protected, __private) rather than strict access modifiers.

Instance methods take self and operate on an instance; class methods take cls and operate on the class (@classmethod); static methods take neither, behaving like a plain function grouped inside the class (@staticmethod).

When a class inherits from more than one parent class; Python resolves method lookup order using the C3 linearization algorithm, visible via the class's __mro__.

Lists are mutable and defined with []; tuples are immutable and defined with (). Tuples are generally faster and used for fixed collections.

An insertion-ordered collection of key-value pairs, defined with {}, offering fast lookup by key.

A set is an unordered collection of unique elements; unlike a list, it automatically removes duplicates and doesn't support indexing.

A common approach is list(set(my_list)), though it doesn't preserve order; use list(dict.fromkeys(my_list)) to preserve order.

A concise syntax for creating a list from an iterable in one line, e.g. [x*2 for x in range(5)].

Similar to list comprehension but for dictionaries, e.g. {x: x*2 for x in range(5)}.

append() adds a single element (even if it's a list) as one item; extend() adds each element of an iterable individually to the list.

Using .sort() to sort in place, or sorted() to return a new sorted list; both accept a key parameter for custom sort logic.

An immutable version of a set — once created, its elements can't be changed, added, or removed.

Extracting a portion of a sequence (list, string, tuple) using the syntax sequence[start:stop:step].

No. Strings are sequences of characters and are immutable — any operation that "changes" a string actually creates a new string object.

f-strings (f"{name}"), the .format() method, and the older % operator.

split() breaks a string into a list based on a delimiter; join() combines a list of strings into one string using a specified separator.

Using slicing: my_string[::-1].

strip() removes leading and trailing whitespace (or specified characters); lstrip() removes only from the left; rstrip() removes only from the right.

Using the in keyword, e.g. "sub" in my_string, or the .find()/.index() methods.

A Python 3.6+ feature letting you embed expressions directly inside string literals, e.g. f"Hello {name}".

str() returns a human-readable representation of an object; repr() returns an unambiguous representation useful for debugging, often valid Python code to recreate the object.

Compare the string to its reverse: s == s[::-1].

Using the .count() method, e.g. my_string.count("a").

A mechanism to gracefully handle runtime errors using try, except, else, and finally blocks instead of letting the program crash.

except runs only if an exception occurs, to handle it; finally runs regardless of whether an exception occurred, typically for cleanup.

Define a class inheriting from Exception, then use raise MyException("message") to trigger it.

BaseException is the root of all exceptions, including system-exiting ones like SystemExit; Exception is the base class for most user-handled errors and doesn't include those.

ValueError, TypeError, IndexError, KeyError, ZeroDivisionError, and FileNotFoundError are among the most frequently encountered.

Code in else runs only if the try block completes without raising an exception, useful for separating "risky" code from code that depends on its success.

By passing a tuple to except, e.g. except (ValueError, TypeError):.

Python prints a traceback and terminates the program (or the current thread) unless the exception is caught somewhere up the call stack.

assert checks a condition and raises AssertionError if it's False, mainly for debugging; raise explicitly triggers a specified exception.

Using raise NewException("msg") from original_exception to preserve and show the original exception's context alongside the new one.

Using open("file.txt", "r") combined with .read(), .readline(), or .readlines(), ideally within a with block for automatic closing.

It ensures the file is properly closed automatically once the block finishes, even if an exception occurs, without needing an explicit close() call.

"r" reads an existing file, "w" overwrites/creates a file, "a" appends to a file, and "rb" reads a file in binary mode.

A single .py file containing reusable functions, classes, or variables that can be imported into other scripts.

A module is a single file; a package is a directory of modules containing an __init__.py file, allowing hierarchical organization.

Using from module_name import function_name, rather than importing the entire module.

It lets a script detect whether it's being run directly or imported as a module, so code inside that block only executes when run directly.

Python's package installer, used to install and manage third-party libraries from the Python Package Index (PyPI).

An isolated Python environment with its own dependencies, used to avoid version conflicts between different projects on the same machine.

Using the built-in json module — json.load()/json.loads() to parse JSON into Python objects, and json.dump()/json.dumps() to convert Python objects into JSON.

A function that uses yield instead of return to produce a sequence of values lazily, one at a time, without storing the entire sequence in memory.

A normal function returns once and exits; a generator function pauses at each yield and resumes from that point on the next call, maintaining state between calls.

A mutex in CPython that allows only one thread to execute Python bytecode at a time, which limits true parallelism for CPU-bound multithreaded code.

Multithreading runs multiple threads within one process (limited by the GIL for CPU-bound tasks, useful for I/O-bound tasks); multiprocessing runs separate processes with their own memory and interpreter, achieving true parallelism for CPU-bound tasks.

An iterable is any object you can loop over (implements __iter__); an iterator is the object that actually produces values one at a time (implements __next__ and maintains state).

An object implementing __enter__ and __exit__ methods, used with the with statement to manage setup and teardown (like opening/closing files) automatically.

A shallow copy (copy.copy()) copies the outer object but shares references to nested objects; a deep copy (copy.deepcopy()) recursively copies nested objects too, so changes to one don't affect the other.

Special methods surrounded by double underscores (like __init__, __str__, __len__) that let custom classes integrate with Python's built-in syntax and functions.

Dynamically modifying or extending a class or module at runtime, typically used for testing or quick fixes, though it can make code harder to maintain if overused.

== calls the object's __eq__ method under the hood; overriding __eq__ in a custom class lets you define what "equality" means for instances of that class.