Lists and Tuples in Python

A list keeps values in a chosen order. Write the items between square brackets, with commas between them. Each item has a position, so repeated values still occupy separate places.

Build and measure a list

scores = [88, 92, 75]
print(scores)
print(len(scores))

Output:

[88, 92, 75]
3

len() counts items, not the largest value or the final position. Lists can contain mixed types, as in [3, "three", 3.0, True], although keeping related data together usually makes processing easier. [] and list() both create an empty list. Its length is 0, and it can grow as the program collects values.

list() can also collect the items of an iterable, an object a for loop can walk through. list(range(4)) gives [0, 1, 2, 3]. list("cat") gives ['c', 'a', 't']: the string supplies one character at a time. The result is a new list.

Count positions from zero

An index identifies one position. Python starts at 0, so the three scores have indices 0, 1 and 2.

Negative indices count backward from the end. For a list of length n, the valid indices run from -n through n - 1. The last item is scores[len(scores) - 1], or more simply scores[-1]. -0 is still 0; it does not mean the last position.

Recognize an invalid index

scores[3] raises IndexError because no fourth item exists. scores[len(scores)] makes the same mistake: the count is one greater than the last nonnegative index. An empty list has no valid item index, including -1.

A list index must be an integer, not a float. scores[1.0] raises TypeError, even though 1.0 has a whole-number value. / produces a float, so scores[len(scores) / 2] also fails. With this three-item list, len(scores) // 2 produces the integer 1, and scores[1] is 92.

Ask whether a value occurs

Membership checks values, not positions:

colors = ["red", "green"]
print("green" in colors)
print("Green" in colors)
print("blue" not in colors)

Output:

True
False
True

in and not in return Boolean values and work on empty lists too. String comparisons are case-sensitive, so "Green" and "green" do not match. A membership test is useful before an operation that requires a value to be present, such as removing it or finding its position.

A slice selects a sequence of items and returns a new sequence. For a list, the result is another list, even when it contains only one item or no items.

Include the start and leave out the stop

letters = ["a", "b", "c", "d", "e", "f"]
print(letters[1:4])

Output:

['b', 'c', 'd']

The positions selected are 1, 2 and 3. Position 4 is the stopping boundary, so 'e' is left out. With a step of 1 and bounds satisfying 0 <= start <= stop <= len(letters), the number of selected items is stop - start. Here it is 3. letters[4:2] gives [] because a forward slice cannot reach an earlier stop.

Leave out a boundary

Negative bounds count from the end just as negative indices do. letters[:n] and letters[n:] divide the list at one boundary. Joining those two slices rebuilds its contents in their original order.

Control the step

The full form is values[start:stop:step]. A step of 2 selects a position, skips one and selects the next. letters[::2] gives ['a', 'c', 'e'], while letters[1::2] gives ['b', 'd', 'f'].

A negative step moves backward. letters[::-1] starts at the last item and produces ['f', 'e', 'd', 'c', 'b', 'a']. For a bounded backward slice, letters[4:1:-1] visits indices 4, 3 and 2, giving ['e', 'd', 'c']; the stop is still excluded. A step of 0 raises ValueError because it cannot move to another position.

Separate a boundary from a position

Slice bounds may extend past either end. Python cuts them back: letters[4:100] is ['e', 'f'], and letters[10:] is []. These slices do not raise IndexError. Reading the single item letters[10] does.

letters[2] is the string 'c'. letters[2:3] is the list ['c']. The colon changes the kind of result, which matters when later code expects a string or a list.

Work with the result

After first_three = letters[:3], assigning first_three[0] = "z" changes only that new outer list; letters[0] stays 'a'. A full slice is a shallow copy, so nested mutable items can still be shared.

Strings and tuples follow the same boundary and step rules. The result keeps the original sequence type: "python"[1:4] gives 'yth', and (10, 20, 30)[1:] gives (20, 30).

Lists support operators for building sequences and functions for summarizing their values. Check whether an operation creates a new list, produces a number or returns text: those results serve different jobs.

Join or repeat lists

+ joins two lists and creates a new list. [1, 2] + [3] gives [1, 2, 3] without changing either input. Both operands must be lists: [1, 2] + 3 raises TypeError. Put a single extra value in a one-item list when using +.

* repeats the sequence. [0] * 4 gives [0, 0, 0, 0], and ["ab", "cd"] * 2 gives ['ab', 'cd', 'ab', 'cd']. It repeats items, not the characters inside each string. A zero or negative repetition count gives []. counts = [0] * 7 provides seven starting counters. Repeating an inner list shares it across positions, which matters when those rows are changed later.

Total, extremes and average

sum() adds numbers. It does not join strings; sum(["a", "b"]) raises TypeError. min() and max() find the smallest and largest items, so the items must support comparison with each other. All-string lists work: max(["pear", "apple"]) gives 'pear' through character-by-character ordering. An empty list has no minimum or maximum and raises ValueError for either call.

The mean is the total divided by the number of items:

temps = [18.5, 21.0, 19.5, 23.0]
if temps:
    total = sum(temps)
    mean = total / len(temps)
    print(total, mean)

Output:

82.0 20.5

The condition works because empty lists count as false and nonempty lists as true. Without the guard, averaging [] would divide by zero and raise ZeroDivisionError. Choose what the program should do when no readings exist, such as return None.

Compare sequences in order

== checks matching items in matching positions. [1, 2, 3] == [1, 2, 3] is True; [1, 2, 3] == [3, 2, 1] is False.

For < and >, compare from the left and stop at the first unequal pair. [2, 9] < [3, 0] is True because 2 is less than 3. The 9 and 0 do not decide anything. When one list is the beginning of another, the shorter one comes first: [2] < [2, 0] is True.

Move between text and lists

colors = "red,green,blue".split(",")
print(colors)
print(", ".join(["red", "green"]))

Output:

['red', 'green', 'blue']
red, green

split() divides a string at its separator. join() is called on the separator and places it between the strings supplied. Every item must be a string. To join numbers, first build a list of their str() results; passing [1, 2] directly to join() raises TypeError.

Lists are mutable: a program can change their contents after creating them. A method belongs to an object and is called with a dot, as in cart.append("eggs"). Its effect on the list and its return value are two separate things.

Add one item or several

cart = ["milk"]
cart.append("eggs")
cart.extend(["tea", "jam"])
print(cart)

Output:

['milk', 'eggs', 'tea', 'jam']

append(x) adds exactly one item at the end. If x is a list, that whole list becomes one nested item. Starting with ['milk', 'eggs'], cart.append(["tea", "jam"]) produces ['milk', 'eggs', ['tea', 'jam']], of length 3.

extend(iterable) adds the items supplied by the iterable separately. Extending with ["tea", "jam"] makes the cart length 4. Extending with "ab" adds 'a' and 'b' separately; append the string to keep 'ab' as one item.

insert(i, x) adds an item before the current position i. After nums = [10, 30] and nums.insert(1, 20), the list is [10, 20, 30]. Later items shift right. insert(0, x) adds at the front; an index past the end adds at the end without an index error.

Remove by position or value

With nums = [10, 20, 30], last = nums.pop() saves 30 and leaves [10, 20]. nums.pop(0) then returns 10 and leaves [20]. An empty list or invalid position makes pop() raise IndexError.

remove() takes a value. With pets = ["cat", "dog", "cat"], pets.remove("cat") leaves ['dog', 'cat']. Only the first match disappears. If the value is missing, remove() raises ValueError. Use a membership check when it may be absent. To remove every 'cat', use:

while "cat" in pets:
    pets.remove("cat")

With [5, 0, 7], remove(0) removes the value 0 and leaves [5, 7]; pop(0) removes the value at position 0, giving [0, 7]. The argument's meaning determines the method.

del can delete a range: from [5, 6, 7, 8], del nums[1] leaves [5, 7, 8], and del nums[0:2] then leaves [8]. clear() leaves the existing list empty.

Keep the return value straight

append, extend, insert, remove and clear return None. Write cart.append("tea") on its own line. Writing cart = cart.append("tea") makes cart refer to None; a later cart.append("jam") raises AttributeError. Save a method result only when it provides a value the program needs, as last = cart.pop() does.

Finding a value, counting it and replacing it are different operations. Use a membership test when you need a yes-or-no result, a search method when you need a position, and assignment when you want the list to change.

Find the first matching position

days = ["Mon", "Tue", "Wed", "Tue"]
print(days.index("Tue"))
print(days.index("Tue", 2))
print(days.count("Tue"))
print(days.count("Sun"))

Output:

1
3
2
0

index(x) returns the first position containing a value equal to x. Its optional start argument tells Python where to begin searching. days.index("Tue", 2) skips the match at position 1 and finds the one at position 3. The answer remains an index into the whole list, not a count from the new starting point.

index() raises ValueError when the value is absent. Lists have no find() method that returns -1. If a missing value is expected, test membership first:

if "Sun" in days:
    position = days.index("Sun")
    print(position)

This code prints nothing because 'Sun' is absent. count(x) can be used without that guard: it returns 0 when there are no matches. These operations use equality, so [1, 2.0].count(2) is 1. Text still respects case: 'tue' does not equal 'Tue'.

Replace one existing item

prices = [4.5, 3.0, 7.25]
prices[1] = 3.5
print(prices)

Output:

[4.5, 3.5, 7.25]

The old second value is overwritten and the length stays 3. The index must exist: prices[3] = 1.0 raises IndexError. To add at the end, use append().

Replacement uses an existing slot. Insertion creates an extra slot before the selected position.

Replace a range with slice assignment

nums = [1, 2, 3, 4, 5]
nums[1:3] = [20, 30, 40]
print(nums)
nums[0:2] = []
print(nums)

Output:

[1, 20, 30, 40, 4, 5]
[30, 40, 4, 5]

The first assignment replaces the two items at indices 1 and 2 with three new items, growing the list by one. An ordinary contiguous slice can be replaced with a shorter or longer sequence. Assigning [] deletes the selected range. This changes the original list; it is different from reading a slice into a new variable.

Edit text by building new text

A string is immutable, so word = "cat" followed by word[0] = "b" raises TypeError. Build a new string with word = "b" + word[1:], or make a list of characters, change it and join it:

letters = list("cat")
letters[0] = "b"
word = "".join(letters)
print(word)

Output:

bat

A loop can use a list's values, its positions or both. Pick the form that supplies what the loop body needs. For a change to the list, also check whether the statement changes an item or only rebinds a local name.

Use items directly

for name in ["Ana", "Ben"]:
    print("Hi", name)

Output:

Hi Ana
Hi Ben

The loop visits each item in order. On each pass, name refers to the current item. Assigning a different value to name does not replace that item in the list. In for r in readings: r = 0, only the name r changes.

Use positions to replace items

readings = [3, -1, 4, -5]
for i in range(len(readings)):
    if readings[i] < 0:
        readings[i] = 0
print(readings)

Output:

[3, 0, 4, 0]

range(len(readings)) supplies 0, 1, 2 and 3. At index 1, the condition is true, so item assignment replaces -1. At index 3, it replaces -5. Positive readings keep their values. Using range(len(readings) + 1) would also reach index 4, which does not exist.

Obtain a position and an item together

enumerate() supplies pairs. Unpack each pair in the loop header:

for i, name in enumerate(["Ana", "Ben"]):
    print(i, name)

Output:

0 Ana
1 Ben

enumerate(names, start=1) supplies labels starting at 1 for a numbered display. Those labels are no longer the list's zero-based indices. To visit from last to first without changing the list, use for item in reversed(names):. For backward indices, use range(len(names) - 1, -1, -1); a three-item list gives 2, 1, 0.

Pair two lists

names = ["Ana", "Ben"]
scores = [90, 85]
for name, score in zip(names, scores):
    print(name, score)

Output:

Ana 90
Ben 85

zip() pairs items at matching positions and stops at the shorter input. If every record matters, check the lengths before relying on it; an unmatched final name will otherwise be skipped.

Control an index with while

A while loop needs a starting index, a boundary check and a step:

i = 0
while i < len(readings):
    print(readings[i])
    i += 1

Forgetting the increment prevents this loop from finishing. Using <= reaches len(readings) and causes IndexError.

Avoid shifting items during a for loop

Removing items changes the positions of those that follow. With [1, 2, 2, 3], removing each encountered 2 while looping over that same list leaves [1, 2, 3]: the second 2 shifts into the position just visited. Loop over nums[:] if removals must affect the original, or build a new list of items to keep. Adding items to the list being visited can also make the loop behave unexpectedly.

Many list problems use a few reusable loop patterns. Decide what result the program needs, set up that result before the loop and update it as each item arrives.

Accumulate a total or a count

sales = [120, 75, 205, 50]
total = 0
for sale in sales:
    total += sale
print(total)

Output:

450

The running total becomes 120, 195, 400 and 450. Setting total = 0 inside the loop would erase previous work on every pass. sum(sales) performs this total directly.

A counter adds 1 for each qualifying item, not the item's value:

scores = [72, 45, 60, 88, 59]
passed = 0
for score in scores:
    if score >= 60:
        passed += 1
print(passed)

The output is 3: 72, 60 and 88 qualify. > 60 would give 2 because it excludes exactly 60. Keep the threshold's wording and comparison in agreement.

Find an extreme

For a nonempty list, initialize a running maximum from a real item:

temps = [-3, -8, -1, -5]
highest = temps[0]
for temp in temps[1:]:
    if temp > highest:
        highest = temp
print(highest)

Output is -1. Starting at 0 would wrongly keep 0 because all readings are lower. Use < to find the minimum, or use the built-ins min() and max(). Check for an empty list before accessing its first item.

Stop at the first match

values = [4, 0, -2, 5, -7]
position = -1
for i, value in enumerate(values):
    if value < 0:
        position = i
        break
print(position)

The output is 2. -1 is a chosen signal for no match; do not use it as an index unless the search succeeded, because it is also a valid last-item index. break preserves the first matching position. Without it, later matches would overwrite the result.

x in values tests for one exact value, and values.index(x) finds its first position. A condition such as “is negative” needs a condition-based search like the loop above.

Filter or transform

A filter keeps selected original items:

passing = []
for score in scores:
    if score >= 60:
        passing.append(score)
print(passing)

Output is [72, 60, 88]; scores keeps all five items. A transformation computes one new item from each original:

nums = []
for text in ["3", "14", "15"]:
    nums.append(int(text))
print(nums, sum(nums))

Output is [3, 14, 15] 32. The conversion happens before addition; summing the original strings fails.

Return a reusable result

def average(values):
    if not values:
        return None
    return sum(values) / len(values)

average([18.5, 21.0, 19.5, 23.0]) returns 20.5. The empty case returns None without dividing by zero, and the function leaves the input list unchanged.

A nested list is a list that contains other lists. A table commonly uses one inner list per row. Each lookup selects one level, so reading a cell takes two indices.

Select the row, then the cell

grid = [[1, 2, 3], [4, 5, 6]]
print(grid[1])
print(grid[1][2])
print(len(grid), len(grid[0]))

Output:

[4, 5, 6]
6
2 3

grid[1] selects the second row; [2] then selects that row's third item. len(grid) counts rows, while len(grid[0]) counts cells in the first row. This rectangular table has six cells. grid[2][1] fails at the first lookup because row 2 does not exist. Swapping row and column positions can select the wrong cell or raise IndexError.

Change a cell or a whole row

grid[0][1] = 20 changes the second cell in the first row, giving [[1, 20, 3], [4, 5, 6]]. grid[0] = [0, 0, 0] replaces the entire first row. The number of lookups shows which level is being replaced.

Visit every value

grid = [[1, 2, 3], [4, 5, 6]]
total = 0
for row in grid:
    for value in row:
        total += value
print(total)

Output:

21

The inner loop completes the first row before the outer loop supplies the second row. It adds 1, 2, 3, then 4, 5, 6. A column total uses one fixed position from each row:

column_total = 0
for row in grid:
    column_total += row[1]
print(column_total)

The output is 7, from 2 and 5. This code requires each row to have a second item.

Rows do not have to be equally long. [[1], [2, 3]] is a valid nested list. Direct nested loops still visit every value because each inner loop follows its own row. Assuming all rows have len(grid[0]) items would miss values here. To count cells in such a table, add len(row) for every row.

Build independent rows

table = []
for r in range(3):
    table.append([0] * 4)
table[0][0] = 1
print(table)

Output:

[[1, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]

Each pass creates a new four-item list. The shortcut [[0] * 4] * 3 repeats a reference to one row; changing its first cell would appear in all three rows.

Store records

A row may describe one record instead of a row of numbers. With students = [["Ana", 90], ["Ben", 85]], students[1][0] is 'Ben' and students[1][1] is 85. When every record has two items, for name, score in students: unpacks them into useful names. Lists of tuples can represent the same kind of records.

A tuple stores items in order, like a list, but its positions cannot be replaced, added or removed. This is immutability. Tuples suit fixed groups such as coordinates, dates and records; lists suit collections that grow or change.

Create and read a tuple

point = (3, 4)
date = (2024, 7, 15)
print(date[0])
print(date[1:])
print(len(date))

Output:

2024
(7, 15)
3

Tuple indexing, negative indices, slicing and membership follow the same rules as lists. A tuple slice returns a tuple. You can loop through a tuple or use +, *, min, max, sum, count and index when its items suit the operation.

The comma creates a nonempty tuple. t = 3, 4 makes (3, 4) even without parentheses. A one-item tuple needs a trailing comma:

list(t) converts a tuple's items into a changeable list.

Understand what cannot change

point[0] = 5 raises TypeError because a tuple does not support item assignment. Tuples have no append, remove or sort methods; point.append(5) raises AttributeError.

A name can still be rebound to a new tuple:

point = (3, 4)
point = (5,) + point[1:]
print(point)

Output is (5, 4). The expression makes a new tuple; it does not edit the old one.

A tuple can hold a mutable item

t = ([1, 2], "x")
t[0].append(3)
print(t)

Output:

([1, 2, 3], 'x')

The first position still holds the same list. That list's contents changed. t[0] = [9] would replace the object in the position and is forbidden. Immutability of the outer tuple does not freeze an inner list.

Match the structure to its job

Use (x, y) for a coordinate, (255, 128, 0) for an RGB color or ("Ana", 90) for a two-field record. Each position has a particular meaning. Use a list for all the class's scores or a cart's items, which may grow and be reordered. A list of tuples, such as [("Ana", 90), ("Ben", 85)], combines a changeable collection with fixed record positions.

A tuple of numbers or strings can serve as a dictionary key, as in {(0, 0): "origin"}. Keys must be hashable, meaning they support Python's stable key lookup rules. A list is not hashable, and a tuple containing a list is not hashable either.

Compare tuples

Comparison starts on the left and stops at the first unequal pair. (1, 2, 5) < (1, 3, 0) is True: the first values tie, and 2 is less than 3. This same rule orders a list of tuple records when no key function is supplied.

Packing gathers values into a tuple. Unpacking assigns an iterable's items to names in order. Together they let code give clear names to the fields of a record and receive several results from one function.

Match names to values

record = "Ana", 34, "Lima"
name, age, city = record
print(name, age, city)

Output:

Ana 34 Lima

The first item becomes name, the second age and the third city. Unpacking also works on lists and strings: first, second = [10, 20] and a, b, c = "xyz" assign their items in order. user, domain = "ana@example.com".split("@") gives 'ana' and 'example.com' because the split produces two pieces.

Without a starred name, the counts must match exactly. x, y = (1, 2, 3) raises ValueError for too many values; x, y, z = (1, 2) raises ValueError for not enough. Python does not silently discard extra items.

Swap values safely

a = 1
b = 2
a, b = b, a
print(a, b)

Output is 2 1. Python evaluates the entire right side using the old values before assigning either name on the left. The two-statement attempt a = b followed by b = a loses the old value of a and makes both names 2.

Collect the remaining items

A starred name receives a list of the leftover values:

first, *rest = [5, 6, 7, 8]
print(first, rest)
*init, last = [5, 6, 7, 8]
print(init, last)

Output:

5 [6, 7, 8]
[5, 6, 7] 8

The star can also occur between unstarred names: first, *middle, last = (5, 6, 7, 8) gives middle the list [6, 7]. The collected object is always a list, even when unpacking a tuple. head, *rest = [5] leaves rest as []. There must be enough items for the unstarred names, and only one starred name is allowed in the same unpacking pattern.

Unpack during a loop

for name, score in [("Ana", 90), ("Ben", 85)]:
    print(name, score)

Output:

Ana 90
Ben 85

The header unpacks each record as it arrives. This is also how for i, item in enumerate(values): and for a, b in zip(left, right): work: each iteration supplies a pair.

Return several results

def min_max(values):
    return min(values), max(values)

low, high = min_max([7, 2, 9])
result = min_max([7, 2, 9])
print(low, high)
print(result)

Output:

2 9
(2, 9)

The function returns one tuple. The caller can unpack it or retain the whole object. An underscore conventionally names a value the code does not need: _, month, day = (2024, 7, 15) keeps the month and day under descriptive names. _ remains an ordinary variable, not a special discard operation.

A variable is a name that refers to an object. Assignment changes what a name refers to; it does not automatically copy the object. With a mutable list, two names can therefore observe the same changes.

Follow the references

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

Output:

[1, 2, 3, 4]
[1, 2, 3, 4]

There is one list and two names for it. b is an alias of a. The append changes the shared object, so reading it through either name shows the added item. Draw two arrows, one from each name, to the same list when tracing this code.

Separate equality from identity

a = [1, 2]
b = a
c = [1, 2]
print(a == b, a == c)
print(a is b, a is c)

Output:

True True
True False

== compares contents; is tests whether the objects are the same object. c has equal contents but is a separate list. id(x) gives an object's identity number, so id(a) == id(b) agrees with a is b. Identity numbers do not tell you which items a list contains.

Use == when asking whether contents match. Use is when checking sharing or a special object such as None. A fresh list literal creates a separate list, so a is [1, 2] is false for an existing list a, even if its contents match.

Mutation and rebinding have different reach

After the last statement, b points at a new list. a continues to refer to the original object. Rebinding one name does not redirect every name that once referred to that object.

Trace += and + separately

For lists, += extends the existing list:

a = [1]
b = a
a += [2]
print(a, b)

Output is [1, 2] [1, 2]. In contrast:

a = [1]
b = a
a = a + [2]
print(a, b)

Output is [1, 2] [1]. + creates a new list, and assignment makes a refer to it. b still refers to the original one-item list.

Look for less visible aliases

row = [0, 0] followed by table = [row, row] stores the same row twice. table[0][0] = 5 produces [[5, 0], [5, 0]] because both positions reach the same inner list.

Numbers and strings cannot change in place. After x = 5, y = x, x += 1, y stays 5; x has been rebound. A tuple's item positions also stay fixed, but an inner list can change. After t = ([1], 2), u = t and t[0].append(3), u shows ([1, 3], 2): both names still reach the same tuple and its same mutable list.

Copying creates a new object, but the depth of that copy matters. A new outer list can still hold references to the original inner lists.

Make a new outer list

a = [1, 2, 3]
b = a.copy()
b.append(4)
print(a)
print(b)
print(a is b)

Output:

[1, 2, 3]
[1, 2, 3, 4]
False

a[:], list(a) and a.copy() all make a shallow copy of a list. Its outer container is new, and its item references are copied. With immutable numbers or strings, replacing or adding an item in one outer list leaves the other alone.

See what a shallow copy shares

a = [[1, 2], [3, 4]]
b = a.copy()
b[0].append(99)
print(a)
print(b is a, b[0] is a[0])

Output:

[[1, 2, 99], [3, 4]]
False True

The two outer lists differ, but their first items refer to the same inner list. append() changes that inner object.

Replacing a position in b is different. After b[1] = [0], b has a different second row while a[1] remains [3, 4]. Assignment changes one reference in b's outer list; it does not mutate the old second row.

Copy nested lists too

import copy

a = [[1, 2], [3, 4]]
b = copy.deepcopy(a)
b[0].append(99)
print(a)
print(b)

Output:

[[1, 2], [3, 4]]
[[1, 2, 99], [3, 4]]

import copy makes the copying module available. copy.deepcopy() recursively copies the nested list structure, so edits to copied inner lists do not reach the original. Use it when changes at those inner levels must be independent. A shallow copy is enough if only the outer list's order or item references will change.

Avoid repeated references when building rows

table = [[0] * 3] * 2
table[0][0] = 7
print(table)

Output is [[7, 0, 0], [7, 0, 0]]. Multiplication repeated the reference to one row. It did not construct two rows.

Build each row inside the loop:

table = []
for r in range(2):
    table.append([0] * 3)
table[0][0] = 7
print(table)

Output is [[7, 0, 0], [0, 0, 0]]. [0] * 3 itself is safe for independent counters: integers cannot be mutated, and item assignment replaces just one position.

Choose a copy for a reason

Preserving the original order before sorting requires a new outer list. Preserving original nested measurements while changing copied cells requires independent inner lists too. Read-only processing needs no copy, and intentional shared editing can use aliases. To investigate a nested bug, check both b is a and b[0] is a[0]; testing only the outer lists misses inner sharing.

A function parameter is another name for the object supplied by the caller. A list argument is not automatically copied. The function can mutate that object, rebind its local parameter or return a new result; these actions affect the caller in different ways.

Mutation reaches the caller

def add_bonus(scores):
    scores.append(5)

marks = [80]
result = add_bonus(marks)
print(marks)
print(result)

Output:

[80, 5]
None

scores and marks initially refer to the same list. Appending through scores changes it. Because the function has no explicit return statement, its result is None.

By contrast, def reset(scores): scores = [] rebinds only the local parameter. The caller's marks still refers to its old list. Use scores.clear() to empty that actual shared list.

Keep a returned list when needed

Two common designs are changing a list in place and returning None, or leaving it alone and returning a new list:

def drop_first(values):
    del values[0]

def tail(values):
    return values[1:]

For nums = [1, 2, 3], calling drop_first(nums) leaves nums as [2, 3]. Writing nums = drop_first(nums) would instead bind nums to None. Starting again from [1, 2, 3], shorter = tail(nums) gives shorter the list [2, 3] while nums stays unchanged. Calling tail(nums) without keeping its result discards the new list.

Other designs are useful too: sum() returns a summary, and pop() both changes a list and returns an item. Make the effect and return value clear in a function's name or docstring.

Build a result without changing the input

def without_negatives(values):
    kept = []
    for value in values:
        if value >= 0:
            kept.append(value)
    return kept

original = [3, -2, 0, 7]
print(without_negatives(original))
print(original)

Output:

[3, 0, 7]
[3, -2, 0, 7]

A caller can also protect its outer list by passing a shallow copy, such as drop_first(original[:]). An operation that edits inner lists would need copying at those levels too.

Avoid a shared mutable default

def add_item(item, basket=[]):
    basket.append(item)
    return basket

The default list is created when the def statement runs, once. add_item("a") returns ['a'], and the next default call add_item("b") returns ['a', 'b']. Use None to request a fresh list:

def add_item(item, basket=None):
    if basket is None:
        basket = []
    basket.append(item)
    return basket

Each call without a basket now creates its own list. Passing an existing basket still allows intentional shared changes. A function cannot mutate a number or string, or replace a tuple's positions, but it can mutate a list stored in a tuple, such as by calling pair[0].append(9).

Sorting puts items in comparison order. Reversing flips their current order. Also decide whether the program should change the existing list or keep it and receive a new list.

Sort in place or keep a new list

nums = [3, 1, 2]
new = sorted(nums)
print(nums)
print(new)
nums.sort()
print(nums)

Output:

[3, 1, 2]
[1, 2, 3]
[1, 2, 3]

sorted() creates a new list. sort() is a list method that rearranges the existing list and returns None. nums = nums.sort() loses the name's reference to the list and binds it to None. Write nums.sort() on its own line or use nums = sorted(nums). print(nums.sort()) prints None even though the list has been reordered.

sorted() accepts any iterable and always returns a list. sorted((3, 1, 2)) gives [1, 2, 3], and sorted("cab") gives ['a', 'b', 'c']. Strings and tuples have no in-place sort() method.

Descending order and reversed order

Each row starts from the original list. reverse=True requests descending comparison order and must be given by name; sorted(nums, True) raises TypeError. Reversing simply visits the existing positions backward, so it does not necessarily produce descending values.

Check the values being compared

Numbers sort by numerical value, including mixed integers and floats: sorted([2.5, -1, 2]) gives [-1, 2, 2.5].

Text is compared character by character. sorted(["10", "9", "100"]) gives ['10', '100', '9']. The first character '1' sorts before '9', and a string prefix comes before a longer string beginning with it. Convert numeric strings with int() or float() when numerical ordering is wanted.

The capital letters A–Z sort before the lowercase letters a–z. sorted(["b", "B", "a"]) gives ['B', 'a', 'b']. Default string order is based on character codes; it is not a case-insensitive dictionary order.

All items compared must support < with one another. sorted([3, "two", 1]) raises TypeError. Clean or convert the data before sorting.

Use sorted positions

For an odd number of scores, sorting makes the middle value easy to read:

scores = [72, 95, 64, 88, 79]
ordered = sorted(scores)
median = ordered[len(ordered) // 2]
print(ordered)
print(median)

Output is [64, 72, 79, 88, 95] followed by 79. The original list still records the order the scores arrived. This single-middle-item calculation applies to odd-length nonempty lists.

A key function computes the comparison value for each item. The original items remain intact in the sorted result. This lets a program sort text by length or records by a selected field.

Pass a function, not a function call

words = ["kiwi", "fig", "banana"]
print(sorted(words, key=len))

Output:

['fig', 'kiwi', 'banana']

Python calls len once for each item and compares the resulting lengths, 4, 3 and 6. Pass key=len, without parentheses. key=len() tries to call len immediately with no argument and fails.

For lowercase comparison, use key=str.lower. With ["banana", "apple", "Cherry"], the default order is ['Cherry', 'apple', 'banana']. With key=str.lower, the result is ['apple', 'banana', 'Cherry']. The original capital C remains in the result; only the comparison keys are lowercase.

Select a record field

results = [("Ana", 90), ("Ben", 72), ("Cy", 85)]

def by_score(record):
    return record[1]

print(sorted(results, key=by_score))

Output:

[('Ben', 72), ('Cy', 85), ('Ana', 90)]

The function receives one record at a time. record[1] selects its score. Add reverse=True to put the highest score first. results.sort(key=by_score, reverse=True) uses the same rule but changes results itself.

key=by_score(results) is different: it calls the function on the whole list and passes its result as the key argument. Here that result is the tuple ('Ben', 72), which cannot be called as a function, so sorting raises TypeError.

Use several fields

Without a key, tuples compare their first items, then their second items to break first-item ties. Sorting [("Ben", 72), ("Ana", 90), ("Ana", 85)] gives [('Ana', 85), ('Ana', 90), ('Ben', 72)].

A key can return a tuple to choose a different field order:

def rank_key(record):
    return (-record[1], record[0])

results = [("Dee", 85), ("Ana", 90), ("Cy", 85)]
print(sorted(results, key=rank_key))

Output:

[('Ana', 90), ('Cy', 85), ('Dee', 85)]

Negating the score makes larger scores have smaller keys. Names then break score ties in ascending order. reverse=True on a positive (score, name) key would reverse both fields, including the names, so it would not meet this mixed-direction rule.

Keep equal-key items in order

Python's sorting is stable: items with equal keys keep their input order. Sorting ["bb", "a", "cc", "d"] by len gives ['a', 'd', 'bb', 'cc']. The tie between the two one-letter words keeps 'a' first; the two-letter tie keeps 'bb' first. Stability also permits sorting by a secondary field first, then by the main field.

min() and max() accept key functions too. max(words, key=len) returns 'banana', not its length. When keys tie, these functions return the first matching item encountered.