Python flashcards, generated for you.

`==` compares values (content equality), while `is` compares object identity (whether they're the same object in memory). Example: `[1,2] == [1,2]` is True, but `[1,2] is [1,2]` is False.

Lists are mutable and passed by reference. `y = x` makes y point to the same list object, not a copy. To create a copy, use `y = x.copy()` or `y = x[:]`.

It persists across function calls. Example: `def f(lst=[]):` creates one list object reused every call. Fix: use `def f(lst=None):` and initialize inside. This is a common gotcha.

`range(5)` is a lazy range object (doesn't store all values). `list(range(5))` converts it to `[0, 1, 2, 3, 4]`. Use range in loops for efficiency.

Variable lookup order: Local → Enclosing (closure) → Global → Built-in. Use `global` or `nonlocal` keywords to modify variables from outer scopes inside a function.

All are falsy, but they're distinct objects. `None is None` is True, `None == False` is False, `0 == False` is True. Use `is None` to check for None specifically.

`*args` collects positional arguments into a tuple. `**kwargs` collects keyword arguments into a dict. Example: `def f(*args, **kwargs):` accepts any arguments.

Prefer `for item in lst:` for simple iteration or `for i, item in enumerate(lst):` if you need the index. Direct iteration is cleaner and faster.

List comprehension variables are scoped locally in Python 3 (unlike loops). Also, comprehensions evaluate conditions left-to-right: `[x for x in range(5) if x > 2]` creates a fresh scope, not overwriting outer `x`.

`lambda` creates anonymous, single-expression functions. Cannot contain statements, docstrings, or multiple lines. Use for short callbacks: `sorted(lst, key=lambda x: x[1])`.