Python · Beginner interview

Python is a high-level, interpreted, dynamically typed language with automatic memory management. You don't declare types and you don't compile to a binary; the interpreter runs your code. Its strengths are readability, a huge standard library and ecosystem, and being multi-paradigm (procedural, OOP, functional). The trade-off is raw speed, which it makes up for with C-backed libraries.

Mutable objects can be changed in place — lists, dicts, sets. Immutable ones can't — int, float, str, tuple, frozenset; 'changing' them actually creates a new object. This matters for sharing (mutating a list seen by two names affects both), for dict keys (only immutable, hashable types can be keys), and for the mutable-default-argument bug.

== compares values — whether two objects are equal. is compares identity — whether they're the exact same object in memory. You use == for almost everything and reserve is for singletons like None (if x is None). Small ints and short strings may be cached so is sometimes appears to work on them, but relying on that is a bug.

A list is an ordered, mutable sequence for collections you'll change. A tuple is an ordered, immutable sequence — good for fixed records and as dict keys. A set is an unordered collection of unique items with fast membership tests and set operations. A dict is a key→value mapping with fast lookup by key. Pick by whether you need order, mutability, uniqueness, or key lookup.

It's a concise way to build a list by transforming and/or filtering an iterable in one expression. It's usually more readable and a bit faster than the equivalent for-loop with append. The same syntax works for dicts and sets.

squares = [n*n for n in range(10) if n % 2 == 0]

Slicing extracts a subsequence with [start:stop:step], where stop is exclusive and any part is optional. Negative indices count from the end, and a negative step reverses. It works on lists, tuples, and strings and returns a new object, so it's a quick way to copy (a[:]) or reverse (a[::-1]).

a = [0,1,2,3,4]
a[1:4]    # [1,2,3]
a[::-1]   # [4,3,2,1,0]

*args collects extra positional arguments into a tuple, and **kwargs collects extra keyword arguments into a dict. They let a function accept a variable number of arguments, and at the call site the same syntax unpacks a sequence or dict into arguments. They're common in wrappers and decorators that forward arguments along.

def log(*args, **kwargs):
    print(args, kwargs)

Default arguments are evaluated once when the function is defined, not on each call. So a default like def f(items=[]) shares the same list across all calls, and appending to it leaks between calls. The fix is to default to None and create a fresh list inside the function.

def f(items=None):
    if items is None:
        items = []

A lambda is a small anonymous function written inline, e.g. lambda x: x*2. map applies a function over an iterable and filter keeps elements matching a predicate. They overlap with comprehensions; in modern Python a comprehension is usually preferred for readability, with map/filter reserved for passing an existing named function.

self is the conventional name for the first parameter of instance methods, referring to the specific instance the method was called on. Python passes it automatically when you call obj.method(), so you use self to read and set per-instance attributes. It's explicit in Python where other languages hide it as 'this'.

__init__ is the initializer, run automatically right after a new instance is created, to set up its initial attributes from the arguments. It's not strictly the 'constructor' (that's __new__, which actually creates the object), but it's where you put setup code. You assign instance state on self there.

class User:
    def __init__(self, name):
        self.name = name

A class can inherit from a parent to reuse and extend its behaviour, and override methods by redefining them. You call the parent's version with super(). Python also supports multiple inheritance, resolved by a defined method-resolution order. Inheritance models an 'is-a' relationship; for reuse without that relationship, composition is often better.

class Admin(User):
    def __init__(self, name, level):
        super().__init__(name)
        self.level = level