Python MCQ — Basics to Advanced

`[]` creates an empty list. `type([])` returns `<class 'list'>` in Python 3.

Tuples are immutable — they cannot be changed after creation. Lists, dicts, and sets are all mutable.

`len()` on a dict returns the number of key-value pairs, which is 3.

Slicing `[1:2]` starts at index 1 (inclusive) and ends at index 2 (exclusive), returning `[2]`.

`yield` turns a function into a generator. When called, it returns a generator object and produces values lazily.

An empty list `[]` is falsy in Python. `bool([])` returns `False`. Non-empty containers are truthy.

`*args` collects any number of extra positional arguments into a **tuple**. `**kwargs` collects keyword arguments into a dict.

`//` is floor division — it divides and rounds down to the nearest integer. `10 // 3 = 3`.

`lst.copy()`, `lst[:]`, and `list(lst)` all create shallow copies. `copy.deepcopy()` creates a deep copy.

Negative indexing counts from the end. Index `-1` refers to the last character, which is `'c'`.

`@classmethod` passes the class (`cls`) as the first argument instead of the instance. Commonly used for alternative constructors.

`__init__` is the constructor — it is called automatically when a new instance is created and sets up initial state.

The GIL (Global Interpreter Lock) is a mutex in CPython that allows only one thread to execute Python bytecode at a time, limiting true multi-core parallelism for CPU-bound tasks.

The `copy` module provides both `copy()` (shallow) and `deepcopy()` (deep) functions for copying Python objects.

`range(0, 10, 3)` starts at 0, stops before 10, with step 3: 0, 3, 6, 9.

The `&` operator on sets performs intersection — elements common to both sets. `{1,2,3} & {2,3,4} = {2, 3}`.

`@functools.wraps(func)` copies the wrapped function's `__name__`, `__doc__`, `__module__`, etc. onto the wrapper so debugging tools see the original function's identity.

The `with` statement (context manager) automatically closes the file even if an exception occurs. The other approaches may leave the file open.

The `**` operator is right-associative: `3 ** 2 = 9` first, then `2 ** 9 = 512`.

`enumerate()` returns an iterator of `(index, value)` tuples. To get a list, wrap it: `list(enumerate(['a','b','c']))` → `[(0,'a'),(1,'b'),(2,'c')]`.

`is` compares object identity (same memory address). `==` compares values. Always use `is` for `None`, `True`, `False`; use `==` for value comparisons.

Once a generator is exhausted (all values have been yielded), calling `next()` raises `StopIteration`. `for` loops handle this automatically.

`int('42')` returns the integer `42`. `int('3.14')` would raise a ValueError — use `int(float('3.14'))` for floats.

`@property` allows you to define a method that is accessed like an attribute (without parentheses). You can add `@name.setter` and `@name.deleter` for full attribute control.

`__slots__` prevents `__dict__` creation per instance, reducing memory usage by 40-50% — especially beneficial when creating millions of objects.

`aiohttp` is an async HTTP client/server framework that works with `asyncio`. The `requests` library is synchronous and blocks the event loop.

`dict.get(key, default)` returns the value for `key` if it exists, or the `default` value if not — without raising a KeyError.

A `lambda` is an anonymous function defined with the `lambda` keyword. It can have any number of arguments but only one expression: `lambda x: x * 2`.

`Counter` counts occurrences. `most_common(2)` returns the 2 most frequent elements as `(element, count)` tuples sorted by count descending.

`asyncio.gather()` takes coroutine objects (not coroutine functions). Call the `async def` functions with `()` to get coroutines, then `await gather()` to run them concurrently.