Python Interview Questions and Answers for Data and Automation Roles

A list is mutable — you can add, remove, and change elements — and uses square brackets. A tuple is immutable and uses parentheses, making it slightly faster and usable as a dictionary key. Use tuples for fixed collections.

A list is an ordered, indexable collection that allows duplicates. A set is an unordered collection of unique elements with fast membership tests (O(1) on average). Use a set to deduplicate or check existence quickly.

Mutable objects (list, dict, set) can change in place; immutable objects (int, str, tuple, frozenset) cannot. Immutability matters for hashability, safe sharing, and avoiding surprising side effects when passing objects to functions.

'==' compares values for equality; 'is' compares identity — whether two references point to the same object in memory. Use '==' for value checks and 'is' mainly for comparisons with None.

A concise way to build a list from an iterable in one expression, e.g. [x*x for x in range(10) if x % 2 == 0]. It's more readable and often faster than an equivalent for-loop with append.

*args lets a function accept any number of positional arguments as a tuple; **kwargs accepts any number of keyword arguments as a dictionary. They make functions flexible and are used to forward arguments to other functions.

Python uses automatic memory management with reference counting plus a cyclic garbage collector to reclaim objects with circular references. An object is freed when its reference count drops to zero.

A list holds all its elements in memory at once. A generator (using yield or a generator expression) produces items lazily, one at a time, so it's memory-efficient for large or streaming data. Generators can only be iterated once.

A decorator is a function that wraps another function to extend its behavior without changing its code, applied with the @ syntax. Common uses include logging, timing, caching (@lru_cache), and access control.

The GIL is a mutex in CPython that lets only one thread execute Python bytecode at a time, so threads don't speed up CPU-bound work. Use multiprocessing for CPU-bound parallelism; threads still help for I/O-bound tasks.

A shallow copy (copy.copy) copies the outer object but shares references to nested objects, so changing a nested item affects both. A deep copy (copy.deepcopy) recursively copies everything, producing a fully independent object.

Wrap risky code in try, catch specific exceptions with except, run cleanup in finally, and use else for code that runs only when no exception occurred. Catch specific exception types rather than a bare except.

A context manager defines setup and teardown via __enter__ and __exit__ (or @contextmanager), and the with statement guarantees the teardown runs even on error. It's commonly used to open and reliably close files or connections.

Default arguments are evaluated once at definition time, so a mutable default like def f(x=[]) is shared across calls and accumulates state. The fix is to default to None and create the list inside the function.

Lists and dicts for general use, sets for uniqueness and membership, tuples for fixed records, and collections types like Counter, defaultdict, and deque. For tabular data, pandas DataFrames and NumPy arrays are standard.

map applies a function to each item, filter keeps items passing a predicate, and both return lazy iterators. A list comprehension can do both in one readable expression and is usually preferred in modern Python.

In Python 3.9+ use dict1 | dict2. Earlier you can use {**dict1, **dict2} or dict1.update(dict2). Keys in the second dictionary overwrite duplicates from the first.

An iterable is any object you can loop over (it implements __iter__); an iterator is the object that produces values one at a time via __next__ and remembers its position. iter() turns an iterable into an iterator.

Process it lazily: iterate the file object line by line, read in fixed-size chunks, or use generators so only a small portion is in memory at once. For tabular data, use pandas' chunksize or move to Dask/PySpark.

A closure is a nested function that remembers variables from its enclosing scope even after that scope has returned. They power factory functions, decorators, and lightweight stateful callbacks without a full class.

Use vectorized operations instead of row-wise apply or loops, choose efficient dtypes (category, downcast numerics), filter early, avoid chained indexing, and use groupby/merge instead of manual iteration. For very large data, move to Dask or PySpark.

Multithreading shares memory but is limited by the GIL for CPU-bound work, so it mainly helps I/O-bound tasks. Multiprocessing spawns separate processes with their own memory, giving true parallelism for CPU-bound work at higher overhead.