Python Programming - MCQ Practice Questions

A lambda function in Python is an anonymous function defined with the lambda keyword. It can accept multiple arguments but its body can only be a single expression (not multiple statements). It does not use a return statement; the expression is implicitly returned. Lambda functions can also be used inline without assigning to a variable.

The nonlocal keyword allows the inner function to modify the variable x from the enclosing (outer) function's scope. Initially x = 10. After inner() runs, x becomes 10 + 5 = 15. outer() then returns 15, so the output is 15.

__init__.py marks a directory as a Python package, making it importable. When a package is imported, Python executes __init__.py. It can be empty or contain initialization code, define __all__ to control exports, or import submodules. Without it (in Python 2 and some Python 3 contexts), the directory would not be recognized as a package.

In Python, functions are first-class objects. Assigning result = add makes result reference the same function object as add. Calling result(3, 4) is identical to calling add(3, 4), which returns 3 + 4 = 7. So the output is 7.

The correct syntax to import a specific name from a module is: from module_name import name. So from math import sqrt imports only the sqrt function into the current namespace, allowing it to be used directly as sqrt() without the math. prefix. The other options are syntactically incorrect.

counter() returns the inner function increment, which is a closure that retains access to the count variable in the enclosing scope. Each call to c() increments count by 1 and returns the new value. First call: count becomes 1, returns 1. Second call: count becomes 2, returns 2. Third call: count becomes 3, returns 3. Output: 1, 2, 3.

math.floor(4.7) returns the largest integer less than or equal to 4.7, which is 4. math.ceil(4.2) returns the smallest integer greater than or equal to 4.2, which is 5. The module is aliased as m using import math as m. So the output is:

4

5

The apply() function takes a function and a value as arguments and returns func(value). A lambda function lambda x: x 2 is passed as func and 5 as value. Inside apply(), func(5) evaluates to 5 2 = 25. The result is 25, which is printed.

The `^` anchor asserts the start of the string and `$` asserts the end. `\d{3}` matches exactly three digits, `-` matches a literal hyphen, and `\d{4}` matches exactly four digits. Together, the pattern matches a complete string of the form `123-4567` and nothing else.

`re.findall()` scans the string from left to right and returns all non-overlapping matches as a list. `re.match()` only checks at the beginning, `re.search()` returns only the first match object, and `re.fullmatch()` requires the entire string to match.

`re.sub(r'\s+', '-', ...)` replaces every sequence of one or more whitespace characters with a single hyphen. `'Hello World Python'` has two groups of spaces, so both are replaced by `-`, giving `Hello-World-Python`.

`re.IGNORECASE` makes the regex engine perform case-insensitive matching, so patterns like `[a-z]` will also match uppercase letters. The flag that makes `.` match newlines is `re.DOTALL`, and `re.VERBOSE` allows whitespace/comments in patterns.

`re.match()` only attempts to match the pattern at the start of the string (position 0), while `re.search()` scans through the entire string looking for any location where the pattern matches. Both return a match object on success and `None` on failure.

The pattern has two capturing groups: `(\w+)` before `@` and `(\w+)` before `.com`. `m.group(1)` returns the first captured group `user` and `m.group(2)` returns the second captured group `example`. So the output is `user example`.

`^[a-zA-Z]+$` uses `+` to require at least one character and `[a-zA-Z]` to allow only letters. Option B uses `*` which also matches an empty string. Option C (`\w`) also matches digits and underscores. Option D only matches lowercase letters.

The `?` quantifier makes the preceding element optional, matching it zero or one time. So `colou?r` matches both `color` (without `u`) and `colour` (with `u`). It does not mean zero-or-more (`*`) or one-or-more (`+`).

The character class `[cbr]` matches only `c`, `b`, or `r`. So `cat` (matches `c`) and `bat` (matches `b`) are found. `sat` does not match because `s` is not in `[cbr]`. The result is `['cat', 'bat']`.

In a regular Python string, `\d` would be interpreted as an escape sequence (which is just `d` since `\d` is not a recognised Python escape). Using a raw string `r'\d+'` ensures the backslash is passed literally to the regex engine, which then correctly interprets `\d` as the digit shorthand. This avoids the need to double-escape patterns like `'\\d+'`.

Python lists are implemented as dynamic arrays. Accessing an element by index is a constant-time operation O(1) because the memory address of any element can be computed directly using the base address and the index.

From Python 3.7 onwards, dictionaries maintain insertion order. The keys() method returns a view of keys and values() returns a view of values. Wrapping them in list() converts them to lists, producing ['a', 'b', 'c'] and [1, 2, 3] respectively.