📋 List Manipulation Quiz

Lists are heterogeneous — one list can hold int, str, float and bool values together.

list() converts a sequence into a list of its items; a string gives its characters, and duplicates are kept.

eval(input()) evaluates the typed text [10, 20, 30] as a list.

L[0] = 10, L[3] = 40, L[-1] = 50 and L[-2] = 40.

Valid indices are 0 to 4, so L[5] is out of range.

Lists are mutable, so their elements can be changed in place.

L[0] = 99 works on a list, but s[0] = 'X' gives a TypeError on a string. Indexing and slicing rules are the same for both.

• repeats the list.

Both operands of + must be lists; write [1, 2] + [3].

Membership testing is case-sensitive; "Green" is not the same as "green".

Lists are compared element by element; at index 2, 5 > 3.

The first elements already differ (3 > 1), which decides the comparison.

Indices 1, 2 and 3 are included; 4 is excluded.

Going backwards from index 5 in steps of 2: indices 5 and 3 (1 is excluded).

Index -4 is 35 and -1 (65) is excluded, giving 35, 45, 55.

Start from the end and take every 2nd element going backwards.

Slicing beyond the end never raises an error; it returns an empty list.

The slice (indices 1-2) is replaced by three values, so the list grows.

To change the elements, loop over the indices and assign to marks[i].

Assigning to marks[i] changes each element in place.

B = A creates an alias — both names refer to the same list, so A also changes.

B = A only creates an alias; A.copy(), list(A) and A[:] create real copies.

B is an alias of A, so A shows the change to index 0; C is a separate copy, so its change does not affect A.

The largest element is 9, the smallest is 1, and the sum is 4 + 9 + 1 + 7 = 21.

Strings are compared alphabetically, and 'Zoya' is the largest.

sum() works on numbers only.

append() adds its argument as ONE element, so the length becomes 4.

extend() adds each element of the sequence separately.

extend() adds each item of a sequence, and a string's items are its characters.

insert(i, x) puts x at index i and shifts the rest right.

An index beyond the end adds at the end, giving [1, 2, 3, 4]; insert(-1, 5) then inserts before the last element.

append() changes the list in place and returns None, so L becomes None. Just write L.append(5).

pop() with no index removes and returns the last element.

remove() deletes only the FIRST occurrence of the value.

remove() raises a ValueError when the value is not in the list.

pop() with an invalid index raises an IndexError.

pop(i) works by index and returns the element; remove(x) works by value and returns None.

del L[1:3] deletes indices 1 and 2 (20 and 30).

clear() empties the list, while del L deletes the variable itself.

9 is first found at index 3, and 3 occurs three times.

find() belongs to strings only; use L.index(x) for lists.

reverse() only flips the current order; it does not sort.

L.sort(reverse=True) sorts in descending order in place.

sorted() returns a NEW sorted list and leaves L unchanged.

sort() is a list method that works in place; sorted() is a built-in function that works on any sequence.

'A' (65) comes before lowercase letters such as 'b' (98).

Row 1 is [4, 5, 6], and column 2 of that row is 6.

len(M) counts the rows (the inner lists), so it is 3.

The nested list [2, 3] counts as ONE element.

The total is 281 and 281 / 6 = 46.833…, which rounds to 46.83.

Initialising both with the first element gives a valid starting point for the comparisons.

Linear search checks elements one by one; it works on unsorted lists, and in the worst case it checks all n elements.

32 is at index 3 (34 is at 0, 7 at 1, 23 at 2).

break runs only when the key is found; if it never runs, the loop's else executes.

Each value is added the first time it appears, so the order is kept.

mid = 3; the second half [4, 5, 6] is placed before the first half [1, 2, 3].

remove(8) gives [3, 1, 6, 8, 2]; pop(1) removes 1, giving [3, 6, 8, 2]; insert(2, 2) gives [3, 6, 2, 8, 2].