List Methods and Operations in Python (Class 12 Computer Science)

Understand List Methods and Operations

List Methods and Operations: key facts

Methods that change the list (all return None)

append(x)	adds x as one item at the end
extend(seq)	adds every item of seq at the end
insert(i, x)	puts x before position i; past the end it appends
remove(x)	deletes the first x; ValueError if x is absent
sort()	ascending in place; sort(reverse=True) for descending
reverse()	reverses the order in place

Never write L = L.sort(): L becomes None.

Methods and functions that return something

pop(i)	removes and returns item i; the last item if i is omitted
count(x)	how many times x occurs
index(x)	position of the first x; ValueError if absent
sorted(L)	a new sorted list; L is unchanged
len(L), min(L), max(L), sum(L)	size, smallest, largest, total
list(seq)	a new list from any sequence

[].pop() raises IndexError: pop from empty list.

Operators on lists

• •L1 + L2: a new joined list
• •L * n: a new list repeated n times
• •x in L: True if x is an item
• •L[i:j:k]: a new list from i up to j - 1 in steps of k
• •L[::-1]: a reversed copy

Slicing never raises IndexError; indexing does.

Copy or alias?

M = L	alias; one list with two names
	M = L[:]: a separate copy
M = list(L)	a separate copy
M += [x]	extends the same list, so an alias sees it

For a function argument, changing items changes the caller's list; assigning a new list does not.

Tuple for contrast

t = (1, 2, 3) is immutable: t[0] = 5 raises TypeError; t + [4] raises TypeError; t + (4,) gives (1, 2, 3, 4)

Tuples have only count() and index() as methods.

How to answer List Methods and Operations questions

1. 1Write the list with index numbers under each item (0, 1, 2 ... and -1, -2 ... if negatives are used).
2. 2For each method call, ask two questions: does it change the list, and what does it return? append, extend, insert, remove, sort and reverse return None.
3. 3When a list is appended to another, it goes in as one item; count it as one when finding len().
4. 4For slices, list the indexes the slice visits (start, start + step, ...) and stop before stop; for a negative step, move leftwards.
5. 5Check names: after M = L, every change through M is a change to L.
6. 6For error questions, look for the usual culprits: missing colon, Print, round brackets used for indexing, range going one past the end, remove or index of a missing value.
7. 7Write the final output exactly as Python prints it: square brackets, commas followed by a space, quotes around strings inside a list.

List Methods and Operations in real life

The idea, met in an everyday situation. Answer the question in your own words, then compare with the model answer. The one-line hook is what to remember.

Tricks to remember List Methods and Operations

Short memory aids. Say each one aloud once, then use it on a question the same day.

• Append swallows, extend spills

  append([1, 2]) swallows the list whole (one new item); extend([1, 2]) spills its items in one by one (two new items).

  Use it when: len() and output questions after append/extend.

• Doers return None

  Methods that do something to the list (append, extend, insert, remove, sort, reverse) give back nothing; only pop hands you the item it removed.

  Use it when: Questions like print(L.reverse()) or X = L.sort().

• Equals is a nickname

  M = L gives the same list a nickname; [:] makes a twin.

  Use it when: Aliasing traps in output questions.

• Slice: start in, stop out

  The start index is included and the stop index is left out, whichever direction the step goes.

  Use it when: Slicing with positive and negative steps.

List Methods and Operations: solved examples

Ordered from board level to HOTS. Try each one before you open the solution.

L = [10, 20, 30]
L.insert(1, 15)
L.append([5, 6])
print(L, len(L))

L = [3, 6, 9]
M = L
M += [12]
L.append([15, 18])
print(L)
print(M.pop(), len(L))

nums = [4, 7, 1, 9]
total = 0
for i in range(1, len(nums) + 1)
    total += nums(i)
Print(total / len(nums))

L = [10, 20, 30, 40, 50, 60]
print(L[-2:0:-2])
L[1:3] = [5]
print(L, L[::3])

Where students lose marks in List Methods and Operations

The slips examiners see most often, and what to write instead.

• ✗Mistake: Counting an appended list as several items

  append() adds its argument as a single item, even when the argument is a list.

  Wrong working

  L = [1, 2]; L.append([3, 4]) → [1, 2, 3, 4], len 4

  Right working

  L = [1, 2]; L.append([3, 4]) → [1, 2, [3, 4]], len 3

  ✓Do this: Use extend() to add the items separately; with append() expect a nested list.

  Usually costs: The full mark of a 1-mark output question.

• ✗Mistake: Assigning the result of sort() or reverse()

  These methods change the list and return None.

  Wrong working

  L = L.sort()
  print(L) # prints None

  Right working

  L.sort()
  print(L)

  ✓Do this: Call the method on its own line, or use sorted(L) when a new list is needed.

  Usually costs: Half to 1 mark in a program.

• ✗Mistake: Treating M = L as a copy

  Both names refer to the same list, so changes through one show through the other.

  Wrong working

  M = L
  M.remove(66) # 'L is unchanged'

  Right working

  M = L[:] # or list(L)
  M.remove(66) # L is unchanged

  ✓Do this: Copy with [:] or list() whenever the original must stay as it is.

  Usually costs: 1 mark in output and case questions.

• ✗Mistake: Including the stop index of a slice

  A slice stops just before the stop index, in either direction.

  Wrong working

  [10, 20, 30, 40][1:3] → [20, 30, 40]

  Right working

  [10, 20, 30, 40][1:3] → [20, 30]

  ✓Do this: List the indexes visited and cross out the stop index before writing the answer.

  Usually costs: 1 mark.

Practice questions on List Methods and Operations

Write each answer on paper first. Open the hint only if you are stuck, and the answer only when you have finished.

1. Q1 · 1 mark · MCQBoard level

   Which list method adds each element of another sequence to the end of a list as separate items?
   (a) append() (b) insert() (c) extend() (d) add()

   Hint

   One method swallows, the other spills.

   Answer

   (c) extend()

2. Q2 · 1 mark · Very short answerBoard level

   Write the output:

   L = [2, 4, 6, 8]
   print(L[1:3] * 2, 6 in L)

   Hint

   The slice stops before index 3.

   Answer

   [4, 6, 4, 6] True

3. Q3 · 1 mark · Very short answerBoard level

   Write the output:

   L = [5, 2, 8]
   X = L.sort()
   print(X, L)

   Hint

   What does sort() return?

   Answer

   None [2, 5, 8]

4. Q4 · 1 mark · Very short answerHarder board level

   Write the output:

   L = [1, 2, 3, 2]
   L.remove(2)
   print(L, L.index(2))

   Hint

   remove() deletes only the first match.

   Answer

   [1, 3, 2] 2

5. Q5 · 3 marks · Short answerHarder board level

   Write a function split_even_odd(L) that returns two new lists, the even numbers and the odd numbers of L, in their original order. Show the output of print(split_even_odd([7, 12, 5, 8, 3])).

   Hint

   Two empty lists, one loop, one if-else; return both.

   Answer

   def split_even_odd(L):
       ev, od = [], []
       for x in L:
           if x % 2 == 0:
               ev.append(x)
           else:
               od.append(x)
       return ev, od
   print(split_even_odd([7, 12, 5, 8, 3]))

   Output: ([12, 8], [7, 5, 3]) (two returned values come back as a tuple).

6. Q6 · 1 mark · Assertion-reasonHarder board level

   Assertion (A): After M = L, the statement M.append(5) also changes L.
   Reason (R): The assignment M = L creates a separate copy of the list L.
   (a) Both A and R are true and R is the correct explanation of A. (b) Both A and R are true but R is not the correct explanation of A. (c) A is true but R is false. (d) A is false but R is true.

   Hint

   Is it a copy or a second name?

   Answer

   (c) A is true but R is false: M = L makes an alias (one list, two names), which is exactly why L changes.

7. Q7 · 2 marks · Short answerHOTS / competency

   Predict the output and explain the second item:

   def change(L):
       L[0] = 99
       L = [1, 2]
       L.append(3)
   A = [5, 6]
   change(A)
   print(A)

   Hint

   After L = [1, 2], whose list does L refer to?

   Answer

   [99, 6]. L[0] = 99 changes the caller's list. Then L = [1, 2] makes the local name refer to a new list, so append(3) changes only that new list, not A.

Test your recall

Answer in your head or on paper first, then open the card. Pulling an answer out of memory makes it stick far better than re-reading.

1. 1.What does L.append([7, 8]) add to L?Show answer

   One item, the list [7, 8].

2. 2.Which list method returns the item it removes?Show answer

   pop().

3. 3.What is the difference between sort() and sorted()?Show answer

   L.sort() changes L and returns None; sorted(L) returns a new sorted list and leaves L unchanged.

4. 4.What does [1, 2] + (3,) give?Show answer

   TypeError: can only concatenate list (not "tuple") to list. A list can be joined only to another list.

5. 5.How do you make an independent copy of L?Show answer

   M = L[:] or M = list(L).

6. 6.What does [5, 6, 7].index(9) do?Show answer

   Raises ValueError, because 9 is not in the list.

List Methods and Operations: frequently asked questions