Introduction to Python lists — creation, indexing, slicing, iteration, input reading, built-in methods, and common operations used in competitive programming.
Introduction to tuples as immutable sequences, covering creation, indexing, unpacking, variable swapping, and guidance on when to use tuples over lists.
In the previous module we used range() to loop over sequences of numbers. But what if you need to store a collection of values, work with them, modify them, or pass them around your program? That's what lists are for.
A list is an ordered collection of values stored under a single variable name. You can think of it as a row of boxes — each box holds a value and has a numbered position.
Python lists:
Each element has an index — its position in the list. Indices start at 0:
Negative Indices
Python also supports negative indices — they count from the end of the list:
This is very convenient — numbers[-1] always gives you the last element without needing to know the length.
Modifying Elements
You can assign a new value to any index:
Index Out of Range
Accessing an index that doesn't exist raises an IndexError:
Always make sure your index is between 0 and len(numbers) - 1.
Function len() returns the number of elements:
This is especially useful in loops:
Slicing lets you extract a portion of a list. The syntax is list[start:stop] — returns elements from index start up to but not including stop:
Omitting Start or Stop
If you omit start, it defaults to 0. If you omit stop, it defaults to the end of the list:
Slice with Step
Just like range(), slices support a step:
numbers[::-1] is the most common Python idiom for reversing a list.
Simple iteration — values only
This is the cleanest way when you only need the values.
Iteration with index using range(len(...))
Use this when you need the index to modify elements or reference their position.
Iteration with enumerate()
enumerate() gives you both the index and the value at the same time:
Output:
You can also set a custom starting index:
In competitive programming, input is usually read from stdin. Common patterns:
Note: The
list(map(...))pattern uses concepts that will be covered in more detail in a later module. For now, treat it as a standard recipe for reading a list of numbers on one line.
Lists come with many built-in methods. Here are the ones you will use most often.
append(x) — add to the end
insert(i, x) — insert at position
pop() — remove and return last element
You can also pop by index:
remove(x) — remove first occurrence of value
sort() — sort in place
sort() modifies the list directly. If you need a sorted copy without changing the original, use sorted():
reverse() — reverse in place
index(x) — find index of first occurrence
count(x) — count occurrences
extend(other) — append all elements of another list
Alternatively, you can use + to concatenate two lists into a new one:
clear() — remove all elements
Use the in operator:
Note that in on a list checks every element one by one — it is O(n). For large lists where you need fast lookups, use a set instead (covered in a later module).
Finding minimum and maximum
Sum of all elements
Creating a list filled with a default value
This is the standard way to initialize a list of a given size in Python.
By default, print(a) shows the list with brackets and commas:
In competitive programming, output usually requires elements separated by spaces with no brackets. Use the * (unpack) operator for this:
*a unpacks the list — it passes each element as a separate argument to print(), which then separates them with spaces by default. You can control the separator:
Sum of elements
Finding the minimum and its index
Counting a specific value
Copying a list in reverse order
Checking if a list is sorted
| Method / Operation | Description |
|---|---|
a[i] | Access element at index i |
a[i] = x | Modify element at index i |
a[i:j] | Slice from i to j (exclusive) |
len(a) | Number of elements |
a.append(x) | Add x to the end |
a.insert(i, x) | Insert x at index i |
a.pop() | Remove and return last element |
a.remove(x) | Remove first occurrence of x |
a.sort() | Sort in place |
sorted(a)| Return sorted copy |
a.reverse() | Reverse in place |
a[::-1] | Return reversed copy |
a.index(x) | Index of first occurrence of x |
a.count(x) | Count occurrences of x |
a.extend(b) | Append all elements of b |
x in a | Check if x is in the list |
sum(a) | Sum of all elements |
min(a) / max(a) | Minimum / maximum value |
[x] * n | Create list of n copies of x |
numbers = [10, 20, 30, 40, 50]
# List of integers
numbers = [1, 2, 3, 4, 5]
# List of strings
names = ["Alice", "Bob", "Charlie"]
# Mixed types (uncommon but valid)
mixed = [42, "hello", True, 3.14]
# Empty list
empty = []
# List from range
squares = list(range(1, 6)) # [1, 2, 3, 4, 5]
numbers = [10, 20, 30, 40, 50]
# 0 1 2 3 4
print(numbers[0]) # 10
print(numbers[2]) # 30
print(numbers[4]) # 50
numbers = [10, 20, 30, 40, 50]
# -5 -4 -3 -2 -1
print(numbers[-1]) # 50 — last element
print(numbers[-2]) # 40 — second to last
print(numbers[-5]) # 10 — same as numbers[0]
numbers = [10, 20, 30, 40, 50]
numbers[2] = 99
print(numbers) # [10, 20, 99, 40, 50]
numbers = [1, 2, 3]
print(numbers[5]) # IndexError: list index out of range
numbers = [10, 20, 30, 40, 50]
print(len(numbers)) # 5
for i in range(len(numbers)):
print(numbers[i])
numbers = [10, 20, 30, 40, 50]
print(numbers[1:4]) # [20, 30, 40]
print(numbers[0:3]) # [10, 20, 30]
print(numbers[2:5]) # [30, 40, 50]
print(numbers[:3]) # [10, 20, 30] — first 3 elements
print(numbers[2:]) # [30, 40, 50] — from index 2 to end
print(numbers[:]) # [10, 20, 30, 40, 50] — full copy
print(numbers[::2]) # [10, 30, 50] — every second element
print(numbers[1::2]) # [20, 40] — every second starting from index 1
print(numbers[::-1]) # [50, 40, 30, 20, 10] — reversed list
names = ["Alice", "Bob", "Charlie"]
for name in names:
print(name)
for i in range(len(names)):
print(i, names[i])
0 Alice
1 Bob
2 Charlie
for i, name in enumerate(names):
print(i, name)
for i, name in enumerate(names, start=1):
print(i, name)
# 1 Alice
# 2 Bob
# 3 Charlie
# Read n, then n integers on separate lines
n = int(input())
a = []
for i in range(n):
a.append(int(input()))
# Read all n integers on one line (most common in CP)
n = int(input())
a = list(map(int, input().split()))
# Read without knowing n in advance
a = list(map(int, input().split()))
a = [1, 2, 3]
a.append(4)
print(a) # [1, 2, 3, 4]
a = [1, 2, 4, 5]
a.insert(2, 3) # insert 3 at index 2
print(a) # [1, 2, 3, 4, 5]
a = [1, 2, 3, 4, 5]
last = a.pop()
print(last) # 5
print(a) # [1, 2, 3, 4]
a = [1, 2, 3, 4, 5]
second = a.pop(1)
print(second) # 2
print(a) # [1, 3, 4, 5]
a = [1, 2, 3, 2, 4]
a.remove(2)
print(a) # [1, 3, 2, 4] — only the first 2 is removed
a = [5, 2, 8, 1, 9]
a.sort()
print(a) # [1, 2, 5, 8, 9]
a.sort(reverse=True)
print(a) # [9, 8, 5, 2, 1]
a = [5, 2, 8, 1, 9]
b = sorted(a)
print(a) # [5, 2, 8, 1, 9] — unchanged
print(b) # [1, 2, 5, 8, 9] — sorted copy
a = [1, 2, 3, 4, 5]
a.reverse()
print(a) # [5, 4, 3, 2, 1]
a = [10, 20, 30, 20, 40]
print(a.index(20)) # 1 — index of first 20
a = [1, 2, 2, 3, 2, 4]
print(a.count(2)) # 3
a = [1, 2, 3]
b = [4, 5, 6]
a.extend(b)
print(a) # [1, 2, 3, 4, 5, 6]
a = [1, 2, 3]
b = [4, 5, 6]
c = a + b
print(c) # [1, 2, 3, 4, 5, 6]
a = [1, 2, 3]
a.clear()
print(a) # []
a = [10, 20, 30, 40]
print(20 in a) # True
print(99 in a) # False
print(99 not in a) # True
a = [3, 1, 4, 1, 5, 9, 2, 6]
print(min(a)) # 1
print(max(a)) # 9
print(sum(a)) # 31
zeros = [0] * 10 # [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
fives = [5] * 5 # [5, 5, 5, 5, 5]
a = [1, 2, 3, 4, 5]
print(a) # [1, 2, 3, 4, 5]
print(*a) # 1 2 3 4 5
print(*a, sep='\n') # each element on its own line
print(*a, sep=', ') # 1, 2, 3, 4, 5
a = [4, 7, 2, 9, 1]
total = 0
for x in a:
total += x
print(total) # 23
a = [4, 7, 2, 9, 1]
min_val = a[0]
min_idx = 0
for i in range(len(a)):
if a[i] < min_val:
min_val = a[i]
min_idx = i
print(min_val, min_idx) # 1 4
a = [1, 3, 2, 3, 4, 3]
target = 3
count = 0
for x in a:
if x == target:
count += 1
print(count) # 3
a = [1, 2, 3, 4, 5]
reversed_a = []
for i in range(len(a) - 1, -1, -1):
reversed_a.append(a[i])
print(*reversed_a) # 5 4 3 2 1
a = [1, 2, 3, 4, 5]
is_sorted = True
for i in range(len(a) - 1):
if a[i] > a[i + 1]:
is_sorted = False
break
print(is_sorted) # True