Python Programming - MCQ Practice Questions

The primary difference is mutability. Lists are mutable, meaning elements can be added, removed, or changed after creation. Tuples are immutable; once created, their content cannot be modified. Both support heterogeneous data and indexing.

A deque (double-ended queue) allows appending to both ends. appendleft(0) inserts 0 at the front, making it [0, 1, 2, 3]. Then append(4) adds 4 at the rear, giving [0, 1, 2, 3, 4].

Python 3.9 introduced the | operator for merging dictionaries. d1 | d2 creates a new dictionary with d2's values overwriting d1's for common keys. While d1.update(d2) modifies d1 in place (not creating a new dict), and dict(d1, **d2) works but is less clean, the | operator is the idiomatic Python 3.9+ approach that also returns a new dictionary.

Sets do not allow duplicate elements. The set {3, 1, 4, 1, 5, 9, 2, 6, 5} contains duplicates: 1 appears twice and 5 appears twice. After removing duplicates, the unique elements are {1, 2, 3, 4, 5, 6, 9}, which gives a length of 7.

Counter counts the frequency of each element. Here apple appears 3 times, banana 2 times, and cherry 1 time. The most_common(2) method returns the top 2 elements as a list of (element, count) tuples sorted by frequency in descending order: [('apple', 3), ('banana', 2)].

List slicing my_list[1:4] extracts elements from index 1 up to (but not including) index 4, giving [2, 3, 4]. The slice my_list[::-1] uses a step of -1 to reverse the entire list, producing [5, 4, 3, 2, 1]. Both results together match option A.

Boolean indexing in NumPy: `a > 2` creates a boolean array `[False, False, True, True, True]`. When used as an index, it selects only the elements where the condition is True, resulting in `[3 4 5]`.

`np.dot(a, b)` computes the dot product: $1\times 4+2\times 5+3\times 6=4+10+18=\boxed{32}$. `np.multiply` returns element-wise product, `np.cross` gives the cross product, and `np.sum(a, b)` is invalid syntax.

`np.arange(12)` creates a 1-D array of 12 elements `[0, 1, ..., 11]`. `.reshape(3, 4)` reshapes it into a 2-D array with 3 rows and 4 columns. Therefore `a.shape` returns `(3, 4)`.

`df['A']` selects column A which contains `[1, 2, 3]`. The `.sum()` method computes $1+2+3=\boxed{6}$. Option A (15) would be the sum of column B (4+5+6=15), and option C (21) would be the total of both columns.

`iloc` uses integer-based indexing. `iloc[1:3, 0]` selects rows at positions 1 and 2 (indices 1 and 2) and the column at position 0 (column 'X'). This gives values 20 and 30 with their row labels 1 and 2.

`np.zeros((3, 3), dtype=int)` is the correct syntax to create a 3×3 array of integer zeros. Option B uses `np.zero` which does not exist. Option C uses `dtype=float` which gives floats, not integers. Option D uses `np.empty` which allocates memory without initializing to zero.

`df.isnull()` returns a DataFrame of boolean values where `True` indicates a missing value. `.sum()` counts `True` values per column. Column A has one `None` (at index 1), and column B has one `None` (at index 2), so the result is A: 1, B: 1.

`np.matmul` performs matrix multiplication. For $A =

$and$B =

$:

Result: $\boxed{

}$. Option B is element-wise multiplication.

`groupby('City')` groups rows by the City column. `.mean()` computes the average Sales per city. Delhi appears twice with values 100 and 150: $\frac{100+150}{2}=125.0$. Mumbai: 200.0. Chennai: 300.0. The result is sorted alphabetically by city name.

`np.concatenate((a, b))` joins the two 1-D arrays end-to-end producing `[ 1 2 3 10 20 30]` of shape `(6,)`. `np.stack((a, b))` stacks arrays along a new axis (default axis=0), creating a 2-D array of shape `(2, 3)` — 2 arrays each of length 3. So the shape is `(2, 3)`.

Binary search repeatedly divides the search space in half. At each step, the problem size reduces by half, giving a recurrence $T(n)=T(n/2)+O(1)$, which solves to $\boxed{O(\log n)}$.

Bubble sort repeatedly compares adjacent elements and swaps them if they are in the wrong order. After all passes over [64, 34, 25, 12, 22], the final sorted result is [12, 22, 25, 34, 64].

Quick Sort's worst case occurs when the pivot chosen is always the smallest or largest element (e.g., already sorted input with naive pivot selection), leading to $n$ recursive calls each of size $n-1$. This gives $T(n)=T(n-1)+O(n)$, which solves to $\boxed{O(n^2)}$.

The function performs binary search on [2, 5, 8, 12, 16, 23] looking for 12. The index of 12 in the list is 3 (0-based). The midpoints traced are index 2 (value 8), then index 4 (value 16), then index 3 (value 12) — match found at index 3.