Python MCQs

`[]` 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.

Run python hello.py from the folder containing the saved file. Python executes print('Hello, World!') and displays Hello, World! in the terminal. Depending on your installation, use python3 hello.py or py hello.py instead.