List Methods & Functions

Methods versus functions

nums = [3, 1, 2]
nums.sort()          # correct: sorts nums in place
print(nums)          # [1, 2, 3]

nums = nums.sort()   # wrong: nums is now None!
print(nums)          # None

Two questions to ask about any tool

1. Does it change the list? (append, insert, remove, pop, sort, reverse, extend, clear, del)
2. Does it give something back? (len, min, max, sum, sorted, index, count, and pop)

Most tools do only one of these. pop() is special: it does both. It removes an item and hands it back to you.

Why do changing methods return None? It is a deliberate reminder from Python's designers. If sort() returned the list, you might think it made a new copy. Returning None makes it clear that the original list is the one that changed.

.append(x): add to the end

cart = []                # start empty
cart.append("apple")     # ['apple']
cart.append("bread")     # ['apple', 'bread']

The "build a list in a loop" pattern

squares = []                 # 1. start empty
for n in range(1, 6):
    squares.append(n * n)    # 2. add one item each time
print(squares)               # 3. use it after the loop
# [1, 4, 9, 16, 25]

This is the list version of the accumulator pattern. The empty list goes before the loop; if it were inside, it would be emptied every time.

Collecting user input: the same pattern can gather several answers: names.append(input("Name: ")) inside a loop.

.insert(i, x): add at a position

What happens to the other items?

When you insert, every item from that position onward shifts one place to the right, and their indexes go up by 1. Starting from ["Ava", "Ben", "Cy"], after seats.insert(1, "Dee"):

index:   0      1      2      3
before: Ava    Ben    Cy
after:  Ava    Dee    Ben    Cy

Ben moved from index 1 to index 2. If your program saved "Ben is at index 1" earlier, that information is now out of date.

.index(x) and .count(x): find items

planets = ["Venus", "Earth", "Mars", "Earth"]
print(planets.index("Earth"))   # 1  (the first one)
print(planets.count("Earth"))   # 2
print(planets.index("Pluto"))   # ValueError: 'Pluto' is not in list

Using in as a safety check

if "Pluto" in planets:
    print(planets.index("Pluto"))
else:
    print("Pluto is not in the list")

This "look before you leap" pattern means index() is only called when it is sure to work.

count() is also a quick yes/no check: planets.count("Earth") > 0 is True when Earth appears at least once, though in reads more clearly for that.

Only the first match: with duplicates, index() always reports the earliest one. Earth is at both 1 and 3, but index("Earth") gives 1.

Removing: .remove(), .pop(), and del

Using the item pop() gives back

to_do = ["wash dishes", "homework", "walk dog"]
task = to_do.pop(0)          # take the first task off the list
print("Now doing:", task)    # Now doing: wash dishes
print(to_do)                 # ['homework', 'walk dog']

This is how a waiting line works in a program: take the first item off, handle it, and repeat.

remove() only removes the first match. With [10, 30, 20, 30], remove(30) leaves the second 30. To remove every 30, build a new list: [n for n in nums if n != 30].

len(), min(), max(), and sum()

Computing the average safely

An average divides by the length, so an empty list would cause ZeroDivisionError. Check first:

if len(scores) > 0:
    average = sum(scores) / len(scores)
    print("Average:", round(average, 1))
else:
    print("No scores yet.")

sum() only works on numbers. sum(["a", "b"]) is a TypeError. To join strings, use "".join(...) instead.

These are functions, not methods: write len(scores), not scores.len().

.sort() versus sorted()

Sorting words without the capital-letter problem

Because capitals come before lowercase, sorted(["kiwi", "apple", "Banana"]) gives ['Banana', 'apple', 'kiwi']. To sort the way a dictionary does, tell Python to compare lowercase versions:

sorted(["kiwi", "apple", "Banana"], key=str.lower)
# ['apple', 'Banana', 'kiwi']

The key= option means "compare using this," but the original words (with their capitals) are kept in the result.

Picking the right one: a high-score table that should always stay in order? .sort(). Showing a sorted view but keeping the order players joined? sorted().

Reversing: .reverse() versus reversed()

Three ways, one decision

• Want the list itself flipped for good? nums.reverse()
• Want to loop backward once without changing anything? for n in reversed(nums):
• Want a new reversed list to keep? nums[::-1] or list(reversed(nums))

An iterator gets used up. If you save r = reversed(nums), then list(r) works the first time but gives [] the second time. Call reversed() again when you need it again.

reverse is not sort: .reverse() just flips the current order. To get largest-first, use sort(reverse=True).

Merging two lists: + versus .extend()

See the difference

a = [1, 2]
a.append([3, 4])
print(a, len(a))     # [1, 2, [3, 4]] 3

a = [1, 2]
a.extend([3, 4])
print(a, len(a))     # [1, 2, 3, 4] 4

The length tells the story: append added one item (a whole list), while extend added each item separately.

When to use +: when you need both original lists unchanged, for example combining two class rosters into a school list while keeping each class list as it was.

List Lab: try every method

Pick a method, fill in the value or index, and click Run. Each line runs on the same list, so you can build up a history. Put text in quotes, like "kiwi". Nothing is recorded.

Questions to answer in the lab

• After insert(0, ...), what happened to every other item's index?
• Which methods showed a value when you ran them, and which showed None?
• What error do you get if you remove something that is not there? How would you prevent it?
• Can you get the list back to its original order using only sort and reverse?

List comprehensions: a new list in one line

doubled = []
for n in nums:
    doubled.append(n * 2)

doubled = [n * 2 for n in nums]

How to read a comprehension

Start in the middle, then go to the front:

1. for n in nums: "take each n from nums..."
2. n * 2: "...and put n × 2 in the new list."

The square brackets on the outside tell you the result is a list.

More examples

The original list is never changed. A comprehension always makes a new list.

Adding an if to filter

passing = []
for s in scores:
    if s >= 70:
        passing.append(s)

passing = [s for s in scores if s >= 70]

Two different "if"s

An if at the end filters: it decides which items get in. To change every item based on a condition, put an if/else at the front instead:

[s for s in scores if s >= 70]                    # keep only passing scores
["pass" if s >= 70 else "fail" for s in scores]   # label every score

The first can give a shorter list. The second always gives a list the same length as scores.

When to skip comprehensions: if the logic needs several steps or is hard to read in one line, a normal loop with append is perfectly good code.

Comprehension Builder

Fill in the parts and click Build. You will see your comprehension, the loop it replaces, and the result of both. Try the challenges below the builder. Nothing is recorded.

Hints for the challenges

• Squares of 1 to 10: the source is range(1, 11); the expression is the item times itself.
• Words longer than 3 letters: the expression is just the word; the filter uses len().
• Even numbers only: the filter uses %. An even number has a remainder of 0 when divided by 2.

Common mistakes

The two silent bugs

• nums = nums.sort() throws away your list and leaves None. You will find out later, when something like len(nums) fails with TypeError: object of type 'NoneType' has no len(). If you ever see NoneType in an error, look for a saved result of a changing method.
• nums.sort without parentheses only names the method; it does not call it. Always include ().

"Look before you leap" prevents most of the other errors: check in before remove/index, and len() before pop/min/max.

Check yourself

Choose an answer, then click Check. This is practice only. Nothing is graded or recorded.

Cheat sheet

nums.append(5)      # add to end
nums.insert(0, 9)   # add at index
nums.remove(9)      # by value
nums.extend([6, 7]) # merge in
nums.sort()         # in place
nums.reverse()      # in place
del nums[0]         # by index

len(nums)         # how many
min(nums)         # smallest
max(nums)         # largest
sum(nums)         # total
nums.index(5)     # where
nums.count(5)     # how many 5s
sorted(nums)      # new sorted list
list(reversed(nums))
a + b             # new merged list

[n * 2 for n in nums]
[s for s in scores if s >= 70]
[w.upper() for w in words]

Remember:

• Never write nums = nums.sort(); methods that change a list return None
• Check with in before remove() or index(), and with len() before pop(), min(), or max()
• extend merges; append adds one item
• Wrap reversed() in list() to see the items

Key words to know

method · function · in place · return value · None · append / extend · remove / pop / del · sort / sorted · iterator · list comprehension · filter