A list is a mutable collection of ordered items.
Items in the list can be of any type, including mixed types within the same list: strings, numbers, dictionaries, lists, objects, ...
List allow duplicates and elements can be added or removed dynamically.

Creating basic lists:

Use square brackets ([]) to create a list.
Use commas to separate items in the list. # empty list print([]) # Output: [] print(list()) # Output: [] # default values print(['a', 'b', 'c']) # Output: ['a', 'b', 'c'] print(["a", "b", "c"]) # Output: ['a', 'b', 'c'] # mixed types print([['a', 'b'], ['c', 'd'], 1]) # Output: [['a', 'b'], ['c', 'd'], 1] # type/isinstance methods print(type([])) # Output: <class 'list'> print(isinstance([], list)) # Output: True

Accessing items in a list:

To access an item in a list, you use square brackets ([]) with the index of that item in the list.
The index of the first item in the list is 0, and the next one is 1, ...
You can access items in a list from the last index using negative numbers.
The index of the last item is -1, and the one before the last one is -2, ... x = ['a', 'b', 'c'] print(x[0]) # Output: a print(x[1]) # Output: b print(x[-1]) # Output: c print(x[-2]) # Output: b
If the list is empty, using any index to access an item in the list will return an error.
Using an index that's higher than the list size will return an error.
y = [] y[0] # Raises IndexError: list index out of range y[1] # Raises IndexError: list index out of range y[-1] # Raises IndexError: list index out of range z = ["a"] z[1] # Raises IndexError: list index out of range z[-2] # Raises IndexError: list index out of range

Appending items to the end of a list:

x = ['a', 'b', 'c'] x.append('d') print(x) # Output: ['a', 'b', 'c', 'd']

Inserting items into a list at specific position:

x.insert(0, 'x') print(x) # Output: ['x', 'a', 'b', 'c', 'd']

Adding items from list:

x.extend(['y', 'z']) print(x) # Output: ['x', 'a', 'b', 'c', 'd', 'y', 'z']

Adding lists (new list created):

print(['a', 'b'] + ['c', 'd']) # Output: ['a', 'b', 'c', 'd']

Modifying items in a list:

x = ['a', 'b', 'c', 'd'] # you can modify an item from any position in the list x[0] = 'A' print(x) # Output: ['A', 'b', 'c', 'd']

Modifying multiple items with slicing:

x = ['a', 'b', 'c', 'd'] x[1:3] = ['B', 'C'] print(x) # Output: ['a', 'B', 'C', 'd']

Inserting multiple items with slicing:

x = ['a', 'b', 'c', 'd'] x[2:2] = ['X', 'Y'] print(x) # Output: ['a', 'b', 'X', 'Y', 'c', 'd']

Removing an item using the del method:

x = ['a', 'b', 'c', 'd'] # you can remove an item from any position in the list del x[0] print(x) # Output: ['b', 'c', 'd']

Removing item using the del method and slicing:

x = ['a', 'b', 'c', 'd'] # you can remove an item from any position in the list del x[1:3] print(x) # Output: ['a', 'd']

Removing the last item in a list:

x = ['a', 'b', 'c', 'd'] # the item removed can be assigned or printed if needed last = x.pop() print(last) # Output: d print(x) # Output: ['a', 'b', 'c']

Removing an item from a specific position in a list:

x = ['a', 'b', 'c', 'd'] # the item removed can be assigned or printed if needed second = x.pop(1) print(second) # Output: b print(x) # Output: ['a', 'c', 'd']

Removing an item by its value from a list:

x = ['a', 'b', 'c', 'c'] # the function remove deletes only the first occurrence of the value x.remove('c') print(x) # Output: ['a', 'b', 'c']

Removing all items:

x = ['a', 'b', 'c', 'd'] x.clear() print(x) # Output: []

Sorting permanently a list: sort()

x = ['b', 'd', 'a', 'c'] x.sort() print(x) # Output: ['a', 'b', 'c', 'd'] x.sort(reverse=True) print(x) # Output: ['d', 'c', 'b', 'a']

Sorting temporarily a list: sorted()

x = ['b', 'd', 'a', 'c'] print(sorted(x)) # Output: ['a', 'b', 'c', 'd'] print(sorted(x, reverse=True)) # Output: ['d', 'c', 'b', 'a'] print(x) # Output: ['b', 'd', 'a', 'c']

Sorting with key function:

# sort by length x = ['a', 'ab', 'abc', 'abcd'] x.sort(key=len, reverse=True) print(x) # Output: ['abcd', 'abc', 'ab', 'a'] # case-insensitive sorting x = ['Abcd', 'abC', 'aB', 'A'] x.sort(key=str.lower) print(x) # Output: ['A', 'aB', 'abC', 'Abcd'] # using lambda x = ['a', 'ab', 'abc', 'abcd'] x.sort(key=lambda i: len(i), reverse=True) print(x) # Output: ['abcd', 'abc', 'ab', 'a']

Reversing items of a list (no sorting):

x = ['b', 'd', 'a', 'c'] x.reverse() print(x) # Output: ['c', 'a', 'd', 'b'] x.reverse() print(x) # Output: ['b', 'd', 'a', 'c']

Reversing items of a list using slicing (no sorting):

x = ['b', 'd', 'a', 'c'] y = x[::-1] # new list created print(y) # Output: ['c', 'a', 'd', 'b'] print(x) # Output: ['b', 'd', 'a', 'c']

Finding first occurrence of an element:

# index(ITEM) - returns first index of item x = ['a', 'a', 'b'] print(x.index('a')) # Output: 0 # index(ITEM, START_INDEX) - returns first index of item starting from START_INDEX print(x.index('a', 1)) # Output: 1 # index(ITEM, START_INDEX, END_INDEX) - returns first index of item between START_INDEX and END_INDEX print(x.index('a', 1, 2)) # Output: 1

Membership:

print('A' in ['A', 'B']) # Output: True print('A' not in ['A', 'B']) # Output: False

Looping through a list:

x = ['b', 'd', 'a', 'c'] for y in x: print(y) print(y) # Output: c Output:
b d a c c
Note that the variable "y" will be accessible after the loop finishes.
Note that the indentation is very important to limit the block of the instructions that are part of the loop.

Using the range() function:

The range function has two parameters.
The value of the first parameter is inclusive in the range.
The value of the second parameter is exclusive from the range.

for x in range(1, 3): # in language C, this is similar to: for (int i=1, i < 3, i++) ... print(x) Output:
1 2

Making a list of numbers using range() function:

x = list(range(0, 4)) print(x) # Output: [0, 1, 2, 3] x = list(range(1, 4)) print(x) # Output: [1, 2, 3]

Returning the min, max, and sum of items of a list:

x = list(range(1, 4)) print(f"min:{min(x)} | max:{max(x)} | sum:{sum(x)}") # Output: min:1 | max:3 | sum:6

The enumerate() function:

The enumerate() function returns a key-value pair for each item in a list.
the key is the index of the item in the list and the value is the item. x = ["a", "b", "c"] for index, item in enumerate(x): print(f"{index}:{item}") Output:
0:a 1:b 2:c

Starting enumerate from a specific number:

x = ["a", "b", "c"] for index, item in enumerate(x, start=1): print(f"{index}:{item}") Output:
1:a 2:b 3:c

Using zip() to iterate over multiple lists:

x = [1, 2] y = ["a", "b"] z = ["A", "B"] for i, j, k in zip(x, y, z): print(f"{i}:{j}:{k}") Output:
1:a:A 2:b:B

List comprehensions:

# traditional approach y = [] for x in range(1, 3): y.append(x ** 2) print(y) # Output: [1, 4] # list comprehension z = [(x ** 2) for x in range(1, 3)] print(z) # Output: [1, 4]

List comprehension with conditional filtering:

w = [(x ** 2) for x in range(1, 3) if x % 2 == 0] print(w) # Output: [4]

List comprehension with conditional expression:

w = [1, -2] z = [x if x >=0 else -x for x in w] print(z) # Output: [1, 2]

List comprehension with string methods:

w = ['a', 'b'] z = [x.upper() for x in w] print(z) # Output: ['A', 'B']

Nested list comprehension:

x = [[1, 2], [3, 4]] y = [row for row in x] print(y) # Output: [[1, 2], [3, 4]] flattened = [num for row in x for num in row] print(flattened) # Output: [1, 2, 3, 4]

Slicing a list ([start:end:step]):

x = [0, 1, 2, 3, 4, 5]
You can specify the index of the first item (inclusive) and the last item (exclusive):
print(x[1:3]) # Output: [1, 2]
You can skip the index of the first item (defaults to 0) print(x[:4]) # Output: [0, 1, 2, 3]
You can skip the index of the last item (defaults to the length of the list):
print(x[3:]) # Output: [3, 4, 5]
You can skip the index of the first and last item (useful to copy a list): index of the first item default to 0 and the last defaults to the length of the list print(x[:]) # Output: [0, 1, 2, 3, 4, 5]
To get the slice of the last items, you can use a negative index:
print(x[-3:]) # Output: [3, 4, 5] print(x[:-3]) # Output: [0, 1, 2]
You can decide how many items to skip between items in the specified range by setting a third index in the brackets:
print(x[0:6:2]) # Output: [0, 2, 4] # first:last:step=2 print(x[::2]) # Output: [0, 2, 4] # reverse slicing print(x[::-2]) # Output: [5, 3, 1]

Looping through a slice:

for y in x[0:6:2]: print(y) Output:
0 2 4

Copying lists:

x = [1, 2, [3, 4]] # copy by reference y = x # both x and y reference the same list y[0] = 0 print(x[0]) # Output: 0 # copy by value: basic types don't affect the original values y = x[:] # new copy but nested objects are still references to the items in the original list z = x.copy() # new copy but nested objects are still references to the items in the original list w = list(x) # new copy but nested objects are still references to the items in the original list y[0] = 'a' z[0] = 'b' w[0] = 'c' print(x[0]) # Output: 0 print(y[0]) # Output: a print(z[0]) # Output: b print(w[0]) # Output: c # replacing the entire nested object reference does NOT affect the original object y[2] = [6, 7] print(x[2]) # Output: [3, 4] # nested objects are references and hence updates affect the original value z[2][1] = 5 print(x[2]) # Output: [3, 5] # deep copy: create complete new list including nested objects import copy y = copy.deepcopy(x) y[2] = ['a', 'b'] print(x[2]) # Output: [3, 5] print(y[2]) # Output: ['a', 'b']

Lists functions:

x = [1, 2, 0, 9, 8, 7] # length print(len(x)) # Output: 6 # min print(min(x)) # Output: 0 # max print(max(x)) # Output: 9 # sum print(sum(x)) # Output: 27 # counting occurrences of an element print(x.count(9)) # Output: 1 # check if all elements are true (0 isn't) print(all(x)) # Output: False # check if all elements are true with conditions print(all(i > 1 for i in x)) # Output: False # check if any element is true print(any(x)) # Output: True # check if any element is true with conditions print(any(i > 1 for i in x)) # Output: True