Lists: Beginner

Store multiple values in order

The empty list prints as [] with nothing inside. The built-in len() function tells us how many items are in the list. An empty list has a length of 0.

The len() function is one of Python's most frequently used tools. When you pass a list to len(), it returns the number of items in that list. This is called the list's length or size. Knowing the length is essential for many operations, such as iterating through items or checking if a list is empty.

The fruits list has 5 items, so len(fruits) returns 5. In the second example, we check if the tasks list is empty before deciding what message to display. This is a common pattern in real programs where you need to handle the case of an empty list differently from a list with items.

Retrieve any item by its position

To access an item, write the list name followed by the index in square brackets. The expression fruits[0] means "give me the item at index 0 of the fruits list," which is "apple". The expression fruits[3] gives us "date", the item at index 3.

A key relationship to remember: for a list with N items, the valid indices range from 0 to N-1. If a list has 4 items, the indices are 0, 1, 2, and 3. The last valid index is always the length minus one. This is why fruits[4] would cause an error for a 4-item list: index 4 does not exist.

Negative indexing is especially useful when you want the last item but do not know how long the list is. Instead of calculating len(colors) - 1, you can simply use colors[-1]. This makes your code cleaner and less error-prone.

colors = ["red", "green", "blue", "yellow"]
print(colors[___02-1-2])

Grow your collections with new data

Lists would be far less useful if they could not grow. Python provides two primary methods for adding items: append() adds an item to the end, and insert() adds an item at a specific position. Understanding when to use each method is essential for writing efficient code.

The .append() method adds exactly one item to the end of a list. It is the most common way to add items because adding to the end is fast and does not require moving other items around. The syntax is list_name.append(item).

Each call to append() adds one item to the end of the list. The list grows from 2 items to 5 items. Notice that append() does not require you to specify where to add the item; it always goes at the end.

append() adds to the end

New items always go after the last existing item in the list.

Returns None, not the list

append() modifies the list in place. Do not assign its result.

Called on the list object

Use dot notation: my_list.append(item), not append(my_list).

A common pattern in Python is to start with an empty list and use append() inside a loop to build it up. This is useful when you need to process data and collect results, or when the items you want to add depend on some calculation.

We start with an empty list called squares. The loop runs for numbers 1 through 5 (range(1, 6) includes 1 and excludes 6). For each number, we calculate its square and append the result. After the loop completes, squares contains all five squared values.

This example filters a list to keep only even numbers. The modulo operator % returns the remainder after division. If number % 2 equals 0, the number is even. We append only those even numbers to our new list.

The .insert() method lets you add an item at any position in the list, not just the end. It takes two arguments: the index where you want the new item, and the item itself. The syntax is list_name.insert(index, item).

When the index exceeds the list length, Python simply adds the item at the end. This means insert(100, "z") on a 2-item list is equivalent to append("z"). Similarly, inserting at the exact length of the list adds to the end.

The notation O(1) means the operation takes the same amount of time regardless of list size. O(n) means the time grows with the list size because items must be shifted. For large lists, preferring append() over insert() can significantly improve performance.

tasks = ["clean", "cook"]
tasks.___(["shop", "pack"])
print(___(tasks))
print(tasks[-1])

append() and extend() are the two most common ways to grow a list. Knowing which to use depends on whether you are adding a single item or merging a whole collection of items.

insert() is useful when position matters, but use it sparingly. Since it must shift every element after the insertion point, it becomes slower as the list grows longer.

All three methods modify the list in place and return None. If you try to assign the result of tasks.append("x") to a variable, you will get None, not the updated list.

Delete items by value or position

Just as you can add items to lists, you can remove them. Python provides several ways to remove items, each suited for different situations. The remove() method deletes by value, while pop() deletes by position. The del statement offers another approach. Understanding the differences helps you choose the right tool.

The .remove() method finds and removes the first occurrence of a specific value. You tell Python what value to remove, and it searches the list to find it. The syntax is list_name.remove(value).

Notice that "eggs" appears twice in the original list. The remove() method only removes the first occurrence: the "eggs" at index 1. The second "eggs" (originally at index 3, now at index 2 after the first one is removed) remains in the list.

The in operator checks if a value exists in a list and returns True or False. By checking first, we avoid the ValueError and can handle the "not found" case gracefully.

The .pop() method removes an item at a specific index and returns that item. Unlike remove(), which works with values, pop() works with positions. If you call pop() without an argument, it removes and returns the last item.

The key difference from remove() is that pop() gives you back the removed item. This is useful when you need to use that item for something, like processing tasks from a to-do list. You remove the task and immediately have access to it.

Choose remove() when you know the value you want to remove but not necessarily its position. Choose pop() when you know the position, or when you need the last item. Use pop() without arguments when processing items from the end of a list, like emptying a stack.

Python also provides the del statement for removing items. Unlike pop(), del does not return the removed item. It simply deletes whatever you specify.

del removes the item at the specified index. After deleting index 2 (which was 30), the remaining items shift left. Then deleting index 0 (which was 10 after the shift) removes another item. Use del when you do not need the removed value.

The in operator is one of Python's most readable features. It checks whether a value exists in a list and returns True or False. You can also use not in to check for absence. This is especially useful before calling remove() to avoid ValueError.

"banana" is in the list, so the first check returns True. "mango" is not in the list, so the second check returns False. The third expression uses not in and returns True because "mango" is indeed not in the list.

colors = ["red", "green", "blue"]
removed = colors.___(1)
print(removed)
print(___(colors))

pop() is especially useful when you need to process and remove items from a list one at a time, such as reading tasks off a to-do list or undoing actions in reverse order.

remove() searches through the list until it finds the first matching value. If the same value appears multiple times, only the first occurrence is removed. Call remove() in a loop to delete all occurrences.

del is the most flexible: it can remove a single item by index or a whole slice of items at once. Unlike pop(), it does not return the removed value, so use pop() when you need to use what you removed.

Handle missing items without crashing

A very common mistake is writing new_list = old_list.append(item). The .append() method modifies the list in place and returns None. If you assign its result to a variable, that variable will be None, not the updated list.

Notice that result is None, but numbers was correctly modified. The fix is simple: do not assign the result of append(). Just call the method on its own.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

fruits = ["apple", "banana"]
fruits = fruits.append("cherry")
print(fruits)

Both variables show [1, 2, 3, 4] because they point to the same list. To create an independent copy, use the .copy() method or slice notation.