Creating a List

A list can be created by enclosing items in square brackets [], separated by commas:

1
empty_list = []
2
numbers = [1, 2, 3, 4]
3
mixed = [1, 1.2, True, None, "hello"]
4
repetition = ["ABC", "ABC", "ABC"]
5
nested = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

A list can also be created using the list() constructor which takes an iterable and converts it into a list.

1
chars = list("hello")  # ['h', 'e', 'l', 'l', 'o']
2
numbers = list(range(5))  # [0, 1, 2, 3, 4]

Common Sequence Operations

Lists are sequences, which means they support common sequence operations that work with other sequence types like strings and tuples. These operations include:

• Membership: Check if an element exists
• Length: Get the number of elements
• Minimum and Maximum: Find the smallest and largest elements
• Counting: Count the number of occurrences of an element
• Searching: Find the index of an element
• Indexing: Access elements by their position
• Slicing: Extract portions of the list
• Concatenation: Combine lists
• Repetition: Repeat lists

Accessing Elements at Specific Index

Individual elements in a list can be accessed using their index. In Python, indices start at 0, so the first element is at index 0, the second at index 1, and so on.

1
fruits = ["A", "B", "C", "D"]
2

3
print(fruits[0])  # A
4
print(fruits[1])  # B
5
print(fruits[2])  # C
6
print(fruits[3])  # D

Negative indices count from the end of the list. -1 refers to the last element, -2 to the second-to-last, and so on.

1
fruits = ["A", "B", "C", "D"]
2

3
print(fruits[-1])  # D
4
print(fruits[-2])  # C
5
print(fruits[-3])  # B
6
print(fruits[-4])  # A

Warning

Accessing an index that doesn’t exist will raise an IndexError:

1
fruits = ["apple", "banana"]
2
print(fruits[5])  # IndexError: list index out of range

Mutability

Lists are mutable, which means their contents can be changed after they are created. This is one of the key differences between lists and tuples.

Changing Elements at Specific Index

The value of an element can be changed at a specific index by assigning a new value to it:

1
numbers = [1, 2, 3, 4, 5]
2
print(numbers)  # [1, 2, 3, 4, 5]
3

4
numbers[0] = 10
5
print(numbers)  # [10, 2, 3, 4, 5]

Slicing

Slicing allows a portion of a list to be extracted. The syntax is list[start:stop:step] where start is the index of the first item to include (inclusive), stop is the index of the first item to exclude (exclusive), and step is the number of items to skip between each item which defaults to 1.

1
x = ["A", "B", "C", "D"]
2

3
print(x[0:2]) #["A", "B"]
4
print(x[1:2]) #["B"]
5
print(x[1:4]) #["B", "C", "D"]
6
print(x[0:4:2]) #["A", "C"]
7
print(x[-1:0:-2]) #["D", "B"]
8
print(x[-1:0:1]) #[]
9
print(x[-4:4]) #["A", "B", "C", "D"]

The start, end and step indices can be omitted. If start is omitted, it defaults to 0. If end is omitted, it defaults to the length of the list. If step is omitted, it defaults to 1.

1
x = ["A", "B", "C", "D"]
2

3
print(x[:2]) #["A", "B"]
4
print(x[1:]) #["B", "C", "D"]
5
print(x[:]) #["A", "B", "C", "D"]
6
print(x[-1::]) #["D"]
7
print(x[:-1:]) #["A", "B", "C"]

Tip

Slicing creates a new list, so modifying a slice doesn’t affect the original list unless you assign it back.

Range Update

Instead of changing individual items, a range of items can be changed by assigning it to a new iterable.

1
x = ["A", "B", "C", "D"]
2
x[0] = "E"
3
print(x) #["E", "B", "C", "D"]
4

5
x[-1] = "F"
6
print(x) #["E", "B", "C", "F"]
7

8
x[::2] = ["G", "H"]
9
print(x) #["G", "B", "H", "F"]
10

11
x[1:2] = ["X", "Y", "Z"]
12
print(x) #["G", "X", "Y", "Z", "H", "F"]
13

14
x[::2] = "Hey"
15
print(x) #["H", "X", "e", "Z", "y", "F"]

Adding elements to a list

To add elements to a list, the methods append(), extend(), and insert() can be used.

• append() adds a single element to the end of the list
• extend() adds all elements from an iterable to the end of the list
• insert() adds an element at a specific index

1
x = ["A", "B", "C", "D"]
2

3
x.append("E")
4
print(x) #["A", "B", "C", "D", "E"]
5

6
x.extend(["F", "G"])
7
print(x) #["A", "B", "C", "D", "E", "F", "G"]
8

9
x.insert(1, 0)
10
print(x) #["A", 0, "B", "C", "D", "E", "F", "G"]

Removing elements from a list

To remove elements from a list, the methods pop(), remove(), and clear() can be used.

• pop() removes and returns the element at a specific index. If no index is specified, it removes and returns the last element. If there is no element at the specified index or the list is empty, it raises an IndexError.
• remove() removes the first occurrence of a specified value. If the value doesn’t exist in the list, it raises a ValueError.
• clear() removes all elements from the list, making it empty.

1
x = ["A", "B", "C", "B", "D"]
2

3
x.remove("B")
4
print(x) #["A", "C", "B", "D"]
5

6
x.pop()
7
print(x) #["A", "C", "B"]
8

9
x.pop(0)
10
print(x) #["C", "B"]
11

12
x.clear()
13
print(x) #[]

Looping through a list

A list can be iterated using a for loop or a while loop.

1
fruits = ["apple", "banana", "orange"]
2

3
for fruit in fruits:
4
    print(fruit)

1
fruits = ["apple", "banana", "orange"]
2

3
for i in range(len(fruits)):
4
    print(i, ":", fruits[i])

1
fruits = ["apple", "banana", "orange"]
2
i = 0
3

4
while i < len(fruits):
5
    print(fruits[i])
6
    i += 1

in and not in operators

To check if an element exists in a list, the in and not in operators can be used:

1
fruits = ["apple", "banana", "orange"]
2

3
if "apple" in fruits:
4
    print("Apple is in the list")
5

6
if "grape" not in fruits:
7
    print("Grape is not in the list")
8

9
print("banana" in fruits)  # True
10
print("mango" not in fruits)   # True

Note

Notice how the not in operator is written, it is not two operators in and not, but a single operator not in.

The assignment operator (Revisited)

When we usually write x = y, we are binding the value of y to the variable x. Since every value in Python is basically an object, then knowing the mutability of y (if y is mutable or immutable) is important. If y is a mutable object, then both x and y will be able to change it (which may not be desirable). Consider the following example:

1
x = 3
2
y = x
3
x += 1
4
y -= 1
5
print(x) #4
6
print(y) #2

Since x and y are both integers, which are immutable, then x and y will change independently. Another example:

1
x = [1, 2, 3]
2
y = x
3
x.append(4)
4
print(x) # [1, 2, 3, 4]
5
print(y) # [1, 2, 3, 4]

Here we were intending on copying the list so that each variable would have its own copy of the list. Since x and y are both lists, which are mutable, then x and y will change together. This is not what we intended, so we need to use a different approach.

1
x = [1, 2, 3]
2
y = x.copy()
3
x.append(4)
4
print(x) # [1, 2, 3, 4]
5
print(y) # [1, 2, 3]

The Identity Operator (is) and (is not)

The identity operator is and is not are used to check if two variables refer to the same object in memory.

1
x = [1, 2, 3]
2
y = [1, 2, 3]
3
print(x == y) # True
4
print(x is y) # False

1
x = [1, 2, 3]
2
y = x
3
print(x == y) # True
4
print(x is y) # True
5
print(x is not y) # False

Note

The identity operator is is different from the equality operator ==. The equality operator == checks if two objects have the same value, while the identity operator is checks if two variables refer to the same object in memory.

Tip

For lists, use == to compare values and is to check if two variables point to the same list object. For immutable types like integers and strings, Python may reuse objects, so is might work, but it’s still better to use == for value comparison.

The del keyword

The del keyword is used to delete variables, elements, slices from a list, or to delete the entire list variable:

1
x = 1
2
y = [1, 2, 3, 4, 5]
3
z = [1, 2, 3, 4, 5]
4

5
del x
6
print(x) # NameError: name 'x' is not defined
7

8
del y
9
print(y) # NameError: name 'y' is not defined
10

11
del z[0]
12
print(z) # [2, 3, 4, 5]
13

14
del z[1:3]
15
print(z) # [2, 5]
16

17
del z[:]
18
print(z) # []

Notable List Methods

Notable list methods include:

• append(e): Inserts an element at the end of the list.
• pop(i=-1): Removes an element at the given index, default is -1 (last).
• remove(val): Searches for the first occurrence of the given value and deletes it.
• clear(): Clears the list.
• count(e): Returns the number of occurrence of val.
• index(value): Returns the first index of value.
• insert(index, val): Inserts an element in the specified index

List as a Sequence

Lists are sequences, so let’s see all the actions in one example:

1
x = [1,2,3,4,5]
2

3
print(x) #[1, 2, 3, 4, 5]
4
print(len(x)) #5
5
print(min(x)) #1
6
print(max(x)) #5
7
print(sum(x)) #15
8

9
print(3 in x) #True
10
print(10 in x) #False
11

12
print(x.count(3)) #1
13
x.insert(3, 0)
14

15
print(x) #[1, 2, 3, 0, 4, 5]
16
print(x[1::2]) #[2, 0, 5]
17
print(x * 2) #[1, 2, 3, 0, 4, 5, 1, 2, 3, 0, 4, 5]
18
print(x + [6, 7]) #[1, 2, 3, 0, 4, 5, 6, 7]

Exercises

1
k = [1, 2, 3, 4, 5, 6]
2
for i in range(len(k)):
3
    if i in k:
4
        print(i, end=" ")

1
my_list = [[1, 2, 3], [[4, 5, 6], [7, [8, 9]]]]
2
print(my_list[1][1][1][0])  # Output: 8

1
my_list = [1, 2, 3, 4, 5]
2
print(my_list)

1
size = int(input())
2
numbers = []
3
for i in range(size):
4
    numbers.append(int(input()))
5
total = 0
6
for num in numbers:
7
    total += num
8
print(total)

1
size = int(input())
2
numbers = []
3
for i in range(size):
4
    numbers.append(int(input()))
5
print(sum(numbers))

1
size = int(input())
2
numbers = []
3
for i in range(size):
4
    num = int(input())
5
    if num >= 0:
6
        numbers.append(num)
7
print(numbers)

1
size = int(input())
2
numbers = []
3
for i in range(size):
4
    numbers.append(int(input()))
5
minimum = numbers[0]
6
for num in numbers:
7
    if num < minimum:
8
        minimum = num
9
print(minimum)

1
size = int(input())
2
numbers = []
3
for i in range(size):
4
    numbers.append(int(input()))
5
target = int(input())
6
found = False
7
for num in numbers:
8
    if num == target:
9
        found = True
10
        break
11
if found:
12
    print("Found")
13
else:
14
    print("Not Found")

1
size = int(input())
2
numbers = []
3
for i in range(size):
4
    numbers.append(int(input()))
5
target = int(input())
6
for num in numbers:
7
    if num == target:
8
        print("Found")
9
        break
10
else:
11
    print("Not Found")

1
size = int(input())
2
numbers = []
3
for i in range(size):
4
    numbers.append(int(input()))
5
duplicates = []
6
seen = []
7
for num in numbers:
8
    if num in seen and num not in duplicates:
9
        duplicates.append(num)
10
    seen.append(num)
11
for dup in duplicates:
12
    print(dup)

1
size = int(input())
2
numbers = []
3
for i in range(size):
4
    numbers.append(int(input()))
5
even = []
6
odd = []
7
for num in numbers:
8
    if num % 2 == 0:
9
        even.append(num)
10
    else:
11
        odd.append(num)
12
print(even)
13
print(odd)

1
size = int(input())
2
numbers = []
3
for i in range(size):
4
    numbers.append(int(input()))
5
reversed_list = []
6
for i in range(len(numbers) - 1, -1, -1):
7
    reversed_list.append(numbers[i])
8
print(reversed_list)

1
n = int(input())
2
for i in range(n):
3
    size = int(input())
4
    inner_list = []
5
    for j in range(size):
6
        inner_list.append(int(input()))
7
    total = 0
8
    for num in inner_list:
9
        total += num
10
    print(total)