Programming in Python · Quiz 1 · May 2026

**Answer: `0009`.** `int("07")` is `7`, while `len("07")` is `2`, so `y = 7 + 2 = 9`. The format specifier `04d` prints an integer in a field of at least four digits, padding on the left with zeros. Therefore `9` is printed as `0009`. A: Correct. Four-digit zero padding changes 9 to `0009`. B: Incorrect. `009` has only three digits; the requested width is four. C: Incorrect. `9` is the numeric value, but this omits the formatting zeros. D: Incorrect. The code formats `y = 9`, not the original value 7.

**Answer: `[2, 8, 6] [2, 4, 6, 6]`.** `M = L` makes `M` and `L` refer to the same list. `N = L[:]` creates a separate list.

The appended value is `8 - 2 = 6`. `print(L, N)` displays the two lists separated by a space. A: Correct. Updating `M[1]` also updates `L[1]`, and 6 is appended only to `N`. B: Incorrect. The appended value is `M[1] - L[0] = 8 - 2 = 6`, not 8. C: Incorrect. `M` aliases `L`, so `L[1]` changes from 4 to 8. D: Incorrect. `append` is called on the separate list `N`, not on `L`.

**Answer: `B = [1, 4, 5]` and `A = [5, 4, 1]`.** `sorted(A)` creates a new list in ascending order, which is assigned to `B`. It does not change `A`. Then `A.sort(reverse=True)` sorts `A` itself in descending order. Because `B` is a separate list, it stays `[1, 4, 5]`. A: Incorrect. `B` remains ascending; sorting `A` later does not change `B`. B: Incorrect. `sorted(A)` returns a new list and leaves the original list unchanged. C: Correct. `B` is the ascending copy, and `A` is sorted in place in descending order. D: Incorrect. `list.sort()` modifies the existing list and returns `None`; it does not return a new sorted list.

**Answer: `DC`.** A vowel causes `continue`, so that character is skipped. The letter `t` causes `break`, which ends the loop before `t` can be appended.

The remaining characters are never processed. A: Correct. Only `d` and `c` are appended before the loop stops. B: Incorrect. `break` runs before the append statement for `t`, so `T` is not added. C: Incorrect. The loop stops at `t`, so it never reaches `n`. D: Incorrect. The initial `e` is a vowel and is skipped.

**Answer: the first and second expressions are true.** For `s = "PyThOn2026"`, string comparisons are case-sensitive and slicing excludes the ending index.

A: Correct. `Th` occurs exactly, with the same case, in `PyThOn2026`. B: Correct. `.lower()` produces `python2026`. C: Incorrect. `s[2:6]` is `ThOn`, with uppercase O; it is not `Thon`. D: Incorrect. Reversing the string puts its final character, `6`, at index 0.

**Answer: the first, second and fourth statements run without error.** The outer tuple cannot have its elements reassigned, but mutable objects stored inside it can still be changed.

Thus the set can receive 7, the list can be edited or appended to, but assigning to an element of the inner tuple raises `TypeError`. A: Correct. `data[0]` is a mutable set, so `.add(7)` is valid. B: Correct. `data[1]` is a mutable list, so changing its first item to 10 is valid. C: Incorrect. `data[2]` is a tuple, so `data[2][1] = 9` raises `TypeError`. D: Correct. `data[2][0]` reads 5, and appending it to the mutable list `data[1]` is valid.

**Answer: 28.** The list comprehension adds 1 to each even number and doubles each odd number.

So `new = [6, 10, 3, 9]`, and `sum(new) = 6 + 10 + 3 + 9 = 28`.

**Answer: 0.**

Therefore `A + B - C = 2 + 2 - 4 = 0`. The quotes in `len('text')` matter: it does not take the length of the variable `text`.

**Answer: 9.** `num % 10` extracts the last digit, and `num //= 10` removes it. Only odd digits are added.

After removing 5, `num` becomes 0 and the loop stops. The printed value is `9`.

**Answer: 7.** For each `i`, the inner loop starts at `j = 0`. If `j == 2`, `break` exits the inner loop before `count += 1` runs.

Only the inner loop ends at a `break`; the outer loop continues. Final count is `1 + 2 + 2 + 2 = 7`.

**Answer: `['OG', 9, 'TAC', 8, 4]`.** `enumerate(items)` starts at index 0. Strings are uppercased and reversed. For integers, the code checks the parity of the index `i`.

Appending these values in order gives the first option. A: Correct. This follows both the string transformation and the zero-based index rule for integers. B: Incorrect. Strings must be reversed after uppercasing, and the integer at index 3 becomes 8. C: Incorrect. Integers use index parity: index 1 gives 9, index 3 gives 8, and index 4 gives 4. D: Incorrect. `go` must become `OG`; the final integer 2 is at even index 4 and becomes 4.

**Answer: the first and third statements are true.** Replacing `i % 2 == 0` with `val % 2 == 0` makes the integer branch depend on the value rather than its position. The string branch remains unchanged.

The result is `['OG', 8, 'TAC', 8, 4]`. A: Correct. The complete result is `['OG', 8, 'TAC', 8, 4]`. B: Incorrect. The string branch still uppercases and reverses, so `go` becomes `OG`, not `GO`. C: Correct. The integer 3 is odd, so it becomes `3 + 5 = 8`. D: Incorrect. The integer 4 is even, so it becomes `4 * 2 = 8`, not 9.

**Answer: 14.** A word shorter than 5 adds its length. Otherwise, a word containing `a` adds 2; all other words add 1. Only one branch runs for each word.

Therefore `ans = 3 + 2 + 4 + 2 + 3 = 14`. A length of exactly 5 does not satisfy `< 5`. A: Incorrect. Adding the five branch contributions gives 14, not 13. B: Incorrect. The contributions are 3, 2, 4, 2 and 3, totaling 14. C: Incorrect. The function returns 14 after all five words are processed. D: Correct. `3 + 2 + 4 + 2 + 3 = 14`.

**Answer: 5.** The loop visits all five words: `pen`, `scale`, `book`, `eraser` and `ink`. At the start of each iteration it evaluates `len(word) < 5` once. The condition is true for three words and false for two, but both true and false checks count as evaluations. Hence it is evaluated **5 times**.