Python Interview Questions: 50 Essential Questions for Developers

Python is a high-level, interpreted programming language. Main features include dynamic typing, automatic memory management, extensive standard library, multiple programming paradigms (OOP, functional, procedural), simple syntax, and cross-platform compatibility.

Lists are mutable (can be modified), use square brackets [], slower for large data. Tuples are immutable (cannot be modified), use parentheses (), faster, can be used as dictionary keys. Use lists for dynamic data, tuples for fixed data.

Dictionary is unordered collection of key-value pairs. Keys must be immutable (strings, numbers, tuples). Access values by key. Fast lookups O(1). Created with {} or dict(). Methods: get(), keys(), values(), items().

List comprehension is concise way to create lists. Syntax: [expression for item in iterable if condition]. More readable and faster than loops. Can be nested. Alternative to map() and filter().

== compares values (equality). is compares object identity (same object in memory). Use == for value comparison, is for checking if variables point to same object. Small integers and strings may be interned.

Decorators are functions that modify other functions. Use @decorator syntax. Wraps function, adds functionality before/after execution. Used for logging, timing, authentication, caching. Can accept arguments.

Generator is function that yields values instead of returning. Uses yield keyword. Lazy evaluation - produces values on demand. Memory efficient for large sequences. Returns generator object. Can be iterated once.

append() adds single element to end of list. extend() adds all elements from iterable to list. append() increases length by 1, extend() increases by length of iterable.

*args collects positional arguments into tuple. **kwargs collects keyword arguments into dictionary. Allows functions to accept variable number of arguments. *args before **kwargs. Useful for wrapper functions.

Lambda is anonymous function defined with lambda keyword. Syntax: lambda arguments: expression. Single expression only. Used for short functions, map(), filter(), sorted(). More concise than def.

range() (Python 3) returns range object (lazy), memory efficient. xrange() (Python 2) was similar. In Python 3, xrange() removed, range() behaves like old xrange(). Both generate numbers on demand.

__init__ is constructor method called when object is created. Initializes object attributes. First parameter is self (instance). Can accept arguments. Not required but commonly used. Called automatically.

Class method takes cls (class) as first parameter, can access/modify class state. Static method takes no special first parameter, cannot access class/instance. Use @classmethod and @staticmethod decorators.

Inheritance allows class to inherit attributes and methods from parent class. Child class extends parent. Use super() to call parent methods. Supports multiple inheritance. Method Resolution Order (MRO) determines method lookup.

Shallow copy creates new object but references nested objects. Deep copy creates new object and recursively copies nested objects. Use copy.copy() for shallow, copy.deepcopy() for deep. Shallow is faster.

Context manager manages resources with __enter__ and __exit__ methods. Used with with statement. Ensures cleanup even if exception occurs. Examples: file operations, database connections. Can use @contextmanager decorator.

__str__ returns human-readable string, used by str() and print(). __repr__ returns unambiguous string, used by repr(). __repr__ should be valid Python code. __str__ calls __repr__ if not defined.

GIL is mutex that allows only one thread to execute Python bytecode at a time. Prevents true parallelism in multi-threading for CPU-bound tasks. I/O-bound tasks can benefit from threads. Use multiprocessing for CPU parallelism.

Module is single Python file (.py) containing code. Package is directory containing modules and __init__.py file. Packages organize related modules. Import modules with import, packages with dot notation.

Set is unordered collection of unique elements. No duplicates allowed. Mutable. Fast membership testing O(1). Created with {} or set(). Methods: add(), remove(), union(), intersection(). Use for unique values.

remove() raises KeyError if element not found. discard() does nothing if element not found. Use remove() when you want to know if element exists, discard() when you don't care.

Dictionary comprehension creates dictionaries concisely. Syntax: {key: value for item in iterable if condition}. Similar to list comprehension but creates key-value pairs. More readable than dict() with loops.

pass does nothing, placeholder for empty blocks. continue skips to next iteration in loop. break exits loop immediately. pass for syntax, continue for skipping, break for exiting.

__name__ is special variable. When script runs directly, __name__ is "__main__". When imported as module, __name__ is module name. Used to execute code only when script is run directly, not when imported.

Iterable is object that can be iterated (has __iter__). Iterator is object with __next__ method. Iterators are iterables. iter() converts iterable to iterator. Generators are iterators.

Method is function defined inside class, takes self as first parameter. Function is defined outside class, no self parameter. Methods belong to class/instance, functions are standalone.

Exception handling uses try, except, else, finally blocks. try contains code that might raise exception. except catches exceptions. else runs if no exception. finally always runs. Use for error handling.

del removes item by index, raises IndexError if invalid. remove() removes first occurrence by value, raises ValueError if not found. pop() removes and returns item by index, raises IndexError if invalid.

__getattr__ called only when attribute not found through normal lookup. __getattribute__ called for every attribute access. __getattribute__ must call super() or raise AttributeError. Use __getattr__ for fallback.

@staticmethod doesn't take self or cls, cannot access class/instance. @classmethod takes cls, can access class but not instance. Static for utility functions, classmethod for alternative constructors.

__slots__ restricts attributes that can be set on instance. Reduces memory usage by preventing __dict__ creation. Faster attribute access. Trade-off: cannot add new attributes dynamically. List of allowed attribute names.

map() applies function to each item, returns iterator. filter() returns items where function is True. reduce() (from functools) applies function cumulatively, returns single value. All take function and iterable.

__new__ creates instance (class method), called before __init__. __init__ initializes instance. __new__ returns instance. Use __new__ for immutable types, singletons. __init__ for normal initialization.

enumerate() adds counter to iterable. Returns (index, value) tuples. Useful when you need both index and value in loop. More Pythonic than range(len()). Can specify start index.

Use is for None comparison (identity check). == works but is preferred. None is singleton, all None references are same object. PEP 8 recommends "is None" and "is not None".

zip() combines multiple iterables element-wise. Returns iterator of tuples. Stops at shortest iterable. Useful for parallel iteration. Can unzip with * operator. Common in loops and data processing.

Mutable types can be changed after creation: list, dict, set. Immutable types cannot: int, float, str, tuple, frozenset. Immutable objects are hashable (can be dict keys). Mutable objects are not hashable.

collections provides specialized data structures. Counter (count elements), defaultdict (default values), OrderedDict (ordered dict), deque (double-ended queue), namedtuple (tuple with names). More efficient than built-ins for specific use cases.

import loads entire module, access with module.name. from import loads specific items, use directly. import preserves namespace, from import pollutes namespace. Use import for clarity, from for convenience.

__init__.py makes directory a Python package. Can be empty or contain initialization code. Python 3.3+ supports namespace packages without __init__.py, but it's still recommended. Used for package initialization.

append() adds element to end of list. insert() adds element at specific index. append() is O(1), insert() is O(n) due to shifting. Use append() when possible for better performance.

__all__ defines public API of module. List of names exported by "from module import *". Controls what gets imported. Good practice for modules. If not defined, all non-underscore names are exported.

Single underscore (_name) indicates "internal use" convention, not enforced. Double underscore (__name) triggers name mangling, makes attribute harder to access. Use _ for private convention, __name__ for special methods.

functools provides higher-order functions. lru_cache (memoization), partial (partial function application), wraps (preserve metadata), reduce (cumulative operation). Useful for functional programming and optimization.

str() calls __str__, returns human-readable string. repr() calls __repr__, returns unambiguous string (ideally valid Python code). repr() used in debugger, containers. str() used by print().

itertools provides iterator building blocks. Functions: count(), cycle(), repeat(), chain(), combinations(), permutations(), product(). Memory efficient, lazy evaluation. Useful for iteration patterns.

Tuple is immutable sequence. namedtuple (from collections) is tuple subclass with named fields. Access by index or name. More readable than regular tuples. Immutable like tuples. Lightweight alternative to class.

contextlib provides utilities for context managers. @contextmanager decorator creates context managers from generators. closing() for objects with close(). Useful for creating custom context managers easily.

threading uses threads (shared memory, limited by GIL for CPU tasks). multiprocessing uses processes (separate memory, true parallelism). Use threads for I/O-bound, processes for CPU-bound. Processes have overhead.

unittest is Python testing framework. Create test classes inheriting unittest.TestCase. Use assert methods (assertEqual, assertTrue, etc.). Run with unittest.main() or pytest. Supports fixtures, mocking. Standard library testing solution.