100+ Python Interview Questions
& Subject Masterclass

Python is a high-level, interpreted, general-purpose programming language known for readable syntax and a large ecosystem of libraries and frameworks.

• Simple and readable syntax
• Large standard library ("batteries included")
• Cross-platform support
• Supports object-oriented, functional, and procedural paradigms

Python source code is compiled to bytecode (`.pyc`) and then executed by the Python Virtual Machine (PVM). Thus, it is both compiled to bytecode and interpreted at runtime.

A variable is a name/reference that points to an object in memory. Python uses dynamic typing so variable types are determined at runtime.

Numeric (`int`, `float`, `complex`), Text (`str`), Sequence (`list`, `tuple`, `range`), Mapping (`dict`), Set (`set`, `frozenset`), Boolean (`bool`), Binary (`bytes`, `bytearray`), and `NoneType`.

Lists (`[1, 2]`) are mutable and can be modified in-place. Tuples (`(1, 2)`) are immutable, making them faster, memory-efficient, and suitable for fixed records and dictionary keys.

A list is an ordered collection allowing duplicate elements. A set (`{1, 2}`) contains unique elements, provides O(1) membership lookups, and supports mathematical set operations.

A dictionary (`{"key": "value"}`) is a hash-map structure of key-value pairs where keys must be hashable and unique. Dict lookups operate in average O(1) time complexity.

Mutable objects can have their content updated after instantiation without creating a new memory object (`list`, `dict`, `set`). Immutable objects (`int`, `str`, `tuple`) cannot be changed after creation.

`==` tests for value equality by comparing underlying contents (`__eq__`). `is` tests for object identity by checking if both variables share the exact same memory address (`id(a) == id(b)`).

None represents the absence of a value or a null value singleton object (NoneType). Always compare with if x is None: rather than ==.

A function is a reusable block of code defined with `def` that executes when invoked and can optionally take parameters and return values.

Parameters are variable names in the function declaration (`def greet(name)`). Arguments are the actual concrete values passed when invoking the function (`greet("Dilshad")`).

`*args` collects arbitrary positional arguments into a tuple. `**kwargs` collects arbitrary keyword arguments into a dictionary.

Default parameter values are evaluated once when the function is defined. Passing a mutable default (e.g. `def add(item, lst=[])`) retains modifications across all function calls. Always use `None` as sentinel default.

A lambda (`square = lambda x: x * x`) is a inline anonymous function restricted to a single expression whose return value is implicitly evaluated.

A concise construct (`[x*2 for x in range(5)]`) to build a list dynamically, replacing boilerplate for-loops with faster bytecode execution.

Creates a dictionary inline from an iterable: `{x: x**2 for x in range(5)}`.

An object representing a stream of data that implements `__iter__()` and `__next__()`, raising `StopIteration` when exhausted.

A generator function produces values lazily using `yield`. It preserves state between iterations without allocating all values in RAM.

return terminates function execution immediately. yield returns a value, suspends execution state, and allows resumption on the next next() call.

A higher-order function `@decorator` that wraps another function to modify or extend its behavior without altering its source code.

OOP organizes code into objects encapsulating data (attributes) and behavior (methods). Core pillars: Encapsulation, Inheritance, Polymorphism, Abstraction.

A blueprint or template for instantiating objects with shared attributes and methods.

A concrete instance created from a class structure (`user = User()`).

`self` explicitly references the active object instance calling the method.

The class constructor/initializer invoked when a new object instance is allocated.

Allows a subclass (`class Dog(Animal)`) to reuse and override behavior from parent classes.

The ability for different object classes to implement the exact same method signature with distinct internal logic.

Bundling state and methods together while restricting direct external access to internal state using private/protected naming conventions (`_protected`, `__private`).

Hiding internal execution complexity and revealing only clean public interfaces using Abstract Base Classes (`abc.ABC`).

Catching and recovering from runtime errors (`try...except...finally`) to prevent process crash.

`try` wraps code; `except` handles exceptions; `else` executes only when NO exception occurred; `finally` runs unconditionally.

`raise` explicitly triggers an exception. `assert condition` raises `AssertionError` if false (used in debugging/tests).

Checks if the script is executed directly from CLI vs imported as a module in another script.

An isolated Python directory environment that keeps project dependencies isolated from global system packages.

A mutex in CPython ensuring only one native thread executes Python bytecode at a time, limiting multi-core CPU parallelism while permitting I/O concurrency.

Threading runs within a single process (ideal for I/O bounds). Multiprocessing spawns separate OS processes bypassing GIL (ideal for CPU bounds).

Syntax for asynchronous coroutines managed by an event loop (`asyncio`), pausing I/O tasks with `await` to yield control to other tasks.

Special methods surrounded by double underscores (`__str__`, `__len__`, `__eq__`) customizing operator overloading and object behavior.

The order Python traverses class hierarchies (determined by C3 Linearization algorithm) to find attributes/methods during multiple inheritance (`Class.mro()`).

A inner function retaining scope references to variables from its outer enclosing function after the outer function has returned.

A tool (like SQLAlchemy or Django ORM) mapping database tables to Python classes, allowing database interactions without raw SQL queries.

A security vulnerability where malicious SQL code is executed via user input. Prevented by using parameterized queries and ORM abstractions.

Django = full-featured monolithic batteries-included; Flask = lightweight flexible micro-framework; FastAPI = modern async API framework with Pydantic validation.

Testing code functions in isolation using `unittest`/`pytest`. Mocking (`unittest.mock`) replaces external dependencies like databases or APIs with fakes.

Never store plaintext passwords. Hash passwords with strong adaptive algorithms like Argon2, bcrypt, or PBKDF2 with salted hashes.

Authentication verifies identity ("Who are you?"). Authorization verifies permissions ("What are you allowed to access?").

def reverse_string(s: str) -> str:
    return s[::-1]

def is_palindrome(s: str) -> bool:
    cleaned = "".join(c.lower() for c in s if c.isalnum())
    return cleaned == cleaned[::-1]

def find_duplicates(items: list) -> set:
    seen, dupes = set(), set()
    for x in items:
        if x in seen: dupes.add(x)
        else: seen.add(x)
    return dupes

def fibonacci(n: int):
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b

def is_prime(n: int) -> bool:
    if n < 2: return False
    d = 2
    while d * d <= n:
        if n % d == 0: return False
        d += 1
    return True