Python interview questions

Python is a high-level, easy-to-read programming language used in web development, scripting, automation, data work, testing, and many other areas. Its syntax is simple, so developers can express ideas quickly without too much boilerplate.

In interviews, the best answer is to connect readability with productivity and ecosystem. Python is popular because it is easy to learn, has a huge standard library and community, and helps teams build working solutions fast.

Dynamic typing means you do not declare the variable type in advance. The type is associated with the object at runtime, and the same variable name can later refer to a different type of object.

A strong interview point is that dynamic typing gives flexibility, but it also means some type-related mistakes are seen only when the code runs. Python is dynamic, but it is still strongly typed because it does not freely mix incompatible types without complaint.

The interview-safe answer is that Python is generally described as an interpreted language because code is usually executed by the Python interpreter. Internally, Python source is first compiled to bytecode and then executed by the Python virtual machine.

So the full answer is not just 'interpreted' or just 'compiled'. A simple way to say it is: Python source becomes bytecode, and the interpreter executes that bytecode, which is why Python is usually grouped with interpreted languages.

A list is mutable, which means its contents can be changed after creation, while a tuple is immutable, which means its contents stay fixed. Both can store multiple values, but their use cases are different.

In interviews, say that lists are used when data needs to change, and tuples are useful when data should remain fixed and safe from accidental modification. Tuples can also be used as dictionary keys if their contents are hashable, while lists cannot.

A list keeps insertion order and allows duplicate values, while a set stores only unique values and is designed for fast membership testing. A set does not support indexing like a list.

A simple interview way to answer is: use a list when order and duplicates matter, and use a set when uniqueness and fast lookups matter. Sets are very useful for removing duplicates or checking whether an item exists.

A dictionary is a key-value data structure where each key maps to a value. It is one of the most important built-in Python types because it gives fast access to data by key instead of by position.

In interviews, mention that dictionary keys must be hashable, which usually means immutable types like strings, numbers, or tuples with hashable contents. Dictionaries are widely used for configuration, counting, grouping, and representing structured data.

`==` checks whether two objects have equal values, while `is` checks whether both names point to the exact same object in memory. So one compares equality of content, and the other compares identity.

This is a very common interview trap because sometimes both give the same result for small or shared objects. The safe interview rule is: use `==` for value comparison and use `is` mainly for identity checks such as `value is None`.

Mutable objects can be changed after creation, while immutable objects cannot be modified once they are created. For example, lists and dictionaries are mutable, while strings, integers, and tuples are usually immutable.

In interviews, connect this idea to side effects and safe sharing. Mutable objects are flexible but can change unexpectedly if shared, while immutable objects are safer to reuse and can often be used as dictionary keys.

A shallow copy creates a new outer object, but nested objects inside it are still shared with the original. A deep copy creates a new outer object and also copies the nested objects, so changes inside do not affect the original structure.

The main interview point is that shallow copy is often enough for flat data, but deep copy matters when nested mutable objects are involved. If inner lists or dictionaries are shared, changing one place can unexpectedly affect another.

Default argument values are evaluated only once when the function is defined, not every time the function is called. If that default value is mutable, like a list or dictionary, later calls can keep using the same old object by mistake.

This leads to surprising bugs because data from one call can leak into another call. The standard interview fix is to use `None` as the default and create a new list or dictionary inside the function when needed.

`*args` lets a function accept a variable number of positional arguments, and `**kwargs` lets it accept a variable number of keyword arguments. They make functions more flexible when the exact number of inputs is not fixed.

In interviews, explain them as packing tools: `*args` packs extra positional values into a tuple, while `**kwargs` packs extra named values into a dictionary. They are common in wrappers, utility functions, and framework code.

A lambda function is a small anonymous function written in a single expression. It is useful when a short function is needed only once or passed directly to another function.

A good interview point is that lambda is best for simple logic, not large business rules. When the logic becomes complex, a normal `def` function is clearer and easier to maintain.

A list comprehension is a compact way to build a list using a loop-like expression inside square brackets. It often replaces a short loop used only to create a new list.

In interviews, say that list comprehensions are concise and Pythonic, but they should stay readable. They are great for simple filtering or transformation, but nested or very complex comprehensions can hurt clarity.

An iterable is any object you can loop over, such as a list, tuple, or string. An iterator is the object that actually gives the next value one at a time during iteration.

A simple interview summary is: iterable is the collection-like object, iterator is the stateful object doing the step-by-step traversal. Calling `iter()` on an iterable usually gives an iterator, and `next()` works on the iterator.

A generator is a special kind of iterator that produces values one by one instead of storing them all at once in memory. It is useful when working with large data or streaming values lazily.

Interviewers like this question because it checks whether you understand memory efficiency. A generator helps when you want values on demand, while a list creates the full result immediately.

`return` ends the function and gives back one final result, while `yield` pauses the function and gives back a value while keeping its state for the next step. That is why `yield` is used to build generators.

In interviews, say that `return` finishes the function, but `yield` makes the function resume later from where it stopped. This lets Python generate values lazily instead of building everything at once.

The interview-safe explanation is that Python passes object references by value. The function receives its own local name, but that name refers to the same object until it is rebound.

Because of this, a function can modify a mutable object that was passed in, but rebinding the parameter itself does not change the caller's variable. A simple way to say it is: Python shares the object, not the variable name.

A decorator is a function that takes another function and adds extra behavior to it without changing the original function code directly. It is commonly used for logging, validation, caching, permission checks, and timing.

In interviews, say that decorators are a clean way to wrap behavior around existing functions. The `@name` syntax is just a readable shortcut for applying that wrapper function.

It means functions can be treated like other values in Python. They can be assigned to variables, passed as arguments, returned from other functions, and stored in data structures.

This idea is important because many Python features depend on it, including decorators, callbacks, and functional-style patterns. In interviews, keep the answer practical: functions can be passed around like data.

`global` is used when you want to modify a variable defined at the module level, while `nonlocal` is used inside nested functions to modify a variable from the nearest enclosing function scope. They both affect name binding, but in different outer scopes.

A simple memory trick is: `global` goes all the way out to the module, and `nonlocal` goes one level outward to an enclosing function scope. Interviewers ask this to test whether you understand Python's scope rules clearly.

`self` refers to the current object instance inside an instance method. It allows the method to read or modify that object's data and call other methods on the same object.

In interviews, mention that `self` is not a keyword like `this` in some other languages, but it is the standard naming convention. It is written explicitly in the method definition so Python knows which object the method is working with.

`__init__()` is the initializer method that runs automatically after a new object is created. It is mainly used to set up the initial state of the object, such as assigning attribute values.

A good interview answer is that `__init__()` initializes the object, while object creation itself happens before that. It is often compared with a constructor, even though Python's object creation model is technically a little more detailed.

An instance method works with a specific object and uses `self`. A class method works with the class itself and uses `cls`, while a static method is just a function placed inside the class namespace without automatic access to either object or class state.

In interviews, explain them using what they receive automatically: object, class, or nothing. Instance methods are most common, class methods are useful for alternative constructors or class-level logic, and static methods are utility helpers related to the class.

Inheritance allows one class to reuse and extend the behavior of another class. The class being inherited from is the parent or base class, and the new class is the child or derived class.

This supports code reuse and helps represent natural relationships such as 'Dog is an Animal'. In interviews, add that inheritance is useful when the child class truly specializes the base class rather than just reusing code mechanically.

Method overriding happens when a child class provides its own implementation of a method already defined in the parent class. This lets the child keep the same interface but change the behavior.

In interviews, connect overriding with polymorphism and extensibility. A common example is a base class defining a method like `speak()`, and each child class providing its own version of that behavior.

Yes, Python supports multiple inheritance, which means one class can inherit from more than one parent class. This can be useful, but it also requires care because method lookup can become harder to reason about.

The main interview point is not just that Python supports it, but that Python also uses a method resolution order to decide which parent method should run first. Multiple inheritance is powerful, but it should be used thoughtfully.

MRO stands for Method Resolution Order, which is the order Python follows when searching for methods in a class hierarchy. `super()` helps call the next method in that resolution order without hardcoding the parent class name.

In interviews, say that `super()` is especially useful in inheritance chains and multiple inheritance because it keeps code more maintainable. It lets classes cooperate cleanly instead of manually naming parent classes everywhere.

Duck typing means Python focuses on what an object can do rather than what exact class it belongs to. If an object provides the required methods or behavior, Python code often treats it as suitable.

The usual interview phrase is: 'If it walks like a duck and quacks like a duck, Python treats it like a duck.' This is one reason Python code can be flexible and expressive without strict interface declarations everywhere.

Encapsulation means keeping data and the related behavior together inside a class and controlling how that data is accessed. Python supports this by convention more than by strict enforcement.

In interviews, mention that names starting with `_` suggest internal use, and double underscore name mangling offers limited protection against accidental access. The bigger idea is design clarity, not absolute hiding.

Abstraction means exposing only the important behavior of an object while hiding unnecessary implementation details. It helps users of a class focus on what the object does instead of how it works internally.

A good interview answer is that abstraction simplifies code usage and reduces mental load. In Python, abstraction is often achieved through class design, clear method interfaces, and sometimes abstract base classes when needed.

Python handles exceptions using `try`, `except`, `else`, and `finally`. Code that may fail goes in `try`, matching errors are handled in `except`, `else` runs when no exception occurs, and `finally` is used for cleanup work.

In interviews, keep the explanation practical: exceptions let you separate normal flow from error-handling flow. The most important parts to remember are how to catch specific exceptions and how `finally` helps cleanup even when an error happens.

`raise` is used to explicitly throw an exception when your code detects a real error condition. `assert` is mainly used during development to check assumptions and can be disabled in optimized runs.

In interviews, the safe rule is: use `raise` for application logic and error reporting, and use `assert` for debugging or internal sanity checks. They are not interchangeable in production design.

A context manager is an object that manages setup and cleanup around a block of code, usually used with the `with` statement. It is commonly used for files, locks, and database-style resources.

The interview value of this question is resource safety. A context manager makes cleanup automatic and reliable, even if an exception happens inside the block.

The `with` statement automatically handles cleanup, so files are closed properly even if an exception occurs while reading or writing. This makes file code shorter, safer, and less error-prone than manual open-close handling.

In interviews, say that `with` reduces resource-leak bugs and improves readability. It is a common example of using a context manager correctly in real Python code.

The GIL, or Global Interpreter Lock, is a lock in the standard CPython implementation that allows only one thread to execute Python bytecode at a time. This affects how CPU-bound multi-threaded Python code behaves.

In interviews, the best answer is balanced: the GIL does not mean Python has no threads, but it does limit true parallel execution of Python bytecode in CPython. Threads still help for many I/O-bound tasks, while multiprocessing is often better for CPU-bound work.

Multithreading uses multiple threads inside one process, so threads share memory and are lighter to create. Multiprocessing uses separate processes, so each process has its own memory space and can better use multiple CPU cores.

A simple interview summary is: threads are usually better for I/O-bound tasks, while processes are often better for CPU-bound tasks in CPython because of the GIL. The trade-off is that processes are heavier and communication between them is more costly.

Python mainly manages memory automatically, so objects are cleaned up when they are no longer needed. In CPython, reference counting plays a major role, and an additional garbage collector helps handle cycles that reference counting alone cannot free.

In interviews, do not oversimplify it to 'Python has garbage collection' and stop there. A better answer is that Python uses automatic memory management, with reference counting plus cycle detection in common implementations like CPython.

Reference counting means Python keeps track of how many references point to an object. When that count drops to zero, the object can usually be cleaned up immediately.

This is an important interview topic because it explains why many objects are freed quickly in CPython. The limitation is that reference counting alone cannot handle cycles, which is why Python also needs cycle-detecting garbage collection.

A module is usually a single Python file containing code such as functions, classes, or variables. A package is a way to organize multiple related modules into a directory structure.

In interviews, explain them as one-file unit versus multi-module collection. Packages help keep larger applications organized and make imports more structured and manageable.

This condition is used to run certain code only when the file is executed directly, not when it is imported as a module into another file. It helps keep test code, demo code, or script entry logic separate from reusable definitions.

A strong interview summary is: it protects top-level execution from running during import. That makes the file reusable as both a script and a module.

Unpacking means taking elements from an iterable and assigning them to multiple variables in a single step. Python also uses `*` and `**` for unpacking values into function calls, lists, tuples, and dictionaries.

In interviews, the best answer is that unpacking improves readability and removes manual indexing in many cases. It is a very Pythonic feature and appears often in clean real-world code.

Slicing is a concise way to access a part of a sequence such as a list, tuple, or string using start, stop, and step. It is one of the most common and expressive Python features for working with sequence data.

In interviews, mention that slicing usually creates a new sequence object instead of changing the original one directly. A simple example is `items[1:4]`, which returns a portion of the sequence without manual looping.

A dataclass is a Python feature that automatically generates common methods such as `__init__()`, `__repr__()`, and comparison helpers for classes that mainly store data. It reduces boilerplate and makes data-focused classes cleaner.

In interviews, say that dataclasses are useful when the class is mostly about holding structured data rather than complex behavior. They make code shorter and easier to read compared with writing repetitive setup code manually.

The `@property` decorator lets a method be accessed like an attribute. It is commonly used to add validation or computed behavior while keeping a clean attribute-style interface for the caller.

A good interview answer is that `@property` helps preserve encapsulation without forcing users of the class to switch from attribute access to method-call syntax. It is useful when internal logic may grow over time.

`append()` adds one item to the end of the list, while `extend()` adds each element from another iterable to the list one by one. So `append()` adds a single object, but `extend()` merges items into the list.

In interviews, use a quick example: appending `[3, 4]` adds that full list as one element, while extending with `[3, 4]` adds `3` and `4` separately. This is a very common beginner-to-intermediate Python question.

`sort()` changes the original list in place and returns `None`, while `sorted()` returns a new sorted result and leaves the original iterable unchanged. Both can sort data, but they behave differently with original state.

The easiest interview answer is: `sort()` mutates, `sorted()` creates a new result. `sorted()` also works with more iterable types, while `sort()` is a method only on lists.

`__str__()` is meant to provide a human-friendly string representation, while `__repr__()` is meant to provide a more detailed and developer-oriented representation. When `__str__()` is missing, Python may fall back to `__repr__()`.

In interviews, say that `__str__()` is for readable display and `__repr__()` is for debugging and clearer object representation. That simple distinction is usually enough unless the interviewer asks for more depth.

A closure is a function that remembers values from its enclosing scope even after the outer function has finished running. This allows the inner function to keep using captured data later.

Closures matter in interviews because they show how Python treats functions as first-class objects. They are often used in decorators, function factories, and situations where behavior must carry hidden state with it.

A list comprehension creates the full list immediately in memory, while a generator expression produces values one at a time when needed. This means generator expressions are usually more memory-efficient for large data.

In interviews, the short answer is eager versus lazy evaluation. If you need all results at once, a list may be fine, but if you want to stream values gradually, a generator expression is often the better choice.

EAFP means 'Easier to Ask Forgiveness than Permission', where you try the operation and handle exceptions if it fails. LBYL means 'Look Before You Leap', where you check conditions first before doing the operation.

Python is often said to lean toward EAFP because exception handling can make code more direct and readable in many cases. In interviews, the balanced answer is that both styles can be useful, but Python culture often prefers EAFP when it keeps code cleaner.