List is one of the compound data types in Python. Lists can group together elements.
A list is written as a comma-separated
, elements (values or items) between square brackets
. Lists might contain elements of different types, but usually the elements all have the same type.
# empty list my_list =  # list of integers my_list = [1, 2, 3, 4] # list of strings my_list = ['Krakow', 'Warsaw', 'Poznan', 'Wroclaw'] # list with mixed datatypes my_list = ['Krakow', 2, 3.86, True]
Python lists are:
- Lists can be empty
- Lists can have any elements
- Lists are ordered
- List elements can be accessed by index
- Lists can be nested to any arbitrary depth
- Lists are mutable, i.e. they can be modified after they are created
An empty list can be created by assigning empty square brackets to an identifier.
# empty list my_list = 
Lists can contain a single datatype or a mixture of datatypes.
# list of integers my_list = [1, 2, 3, 4] # list of floats my_list = [1.2, 2.4, 3.6, 4.8] # list of strings my_cities = ['Krakow', 'Warsaw', 'Poznan', 'Wroclaw'] # list with mixed datatypes my_list = ['Krakow', 2, 3.86, True]
The order of elements in a list is important. Two lists are not the same if the elements within a list are same but in a different order.
list_01 = [1, 2, 3, 4] list_02 = [4, 3, 2, 1]
These two lists have the same elements but in different order
list_01 == list_02
You can use is keyword too.
list_01 is list_02
You can use the index operator of square brackets
 to access an element in a list. In Python, index starts from 0.
Index number should be an integer, otherwise, it raises
TypeError. Python will raise an
IndexError if the index element is outside of the length of the list minus one.
my_cities = ['Krakow', 'Warsaw', 'Poznan', 'Wroclaw']
The indices for the elements are as follow:
You can access each element by writing the name of the
listfollowed by square brackets
index numberof the element.
#my_cities 'Krakow' #my_cities 'Wroclaw'
Python allows negative indexing for elements in a list. Negative index counts from the end of the list. -1 is the index of last element, -2 is the index of second from last element, so on.
You can access elements in a list using negative index.
#my_cities[-1] 'Wroclaw' #my_cities[-3] 'Warsaw'
Slicing of a list needs two indices:
start index and
end index separated by a colon
All slice operations return a new list containing the requested elements. This means that the following slice returns a shallow copy of the list.
my_list = [2, 3, 4, 5, 5, 7, 8, 1,5, 6, 2, 9, 0]
You create a new list using slice operations. Square brackets
 with colon
: will select all elements in the list and assign it to a new list
new_list = my_list[:]
#== comparison my_list == new_list
#is keyword comparison my_list is new_list
==, Python returns
True but comparison with Python keyword
== compares the orders of elements in the
new_list but Python
is keyword is referencing memory locations of the
new_list which are different and returns
Let’s say you want to get the 2nd to 7th elements. Our start index is 1 and end index is 7 (End index returns the index before index 7, so in this case until index 6).
# value 2nd to 7th start_index = 1 end_index = 7 my_list[start_index:end_index] my_list[1:7] # you can write it this way too.
[3, 4, 5, 5, 7, 8]
Lists usually start counting from left to right. Empty start index location means select/filter elements from the start.
# value beginning to 6th my_list[:6]
[2, 3, 4, 5, 5, 7]
Empty end index location means select/filter the elements from the start index to the last element in the list.
# value 6th to the end my_list[5:]
[7, 8, 1, 5, 6, 2, 9, 0]
You can use a mixture of index and negative index together. For example; let’s select the 2nd element from start until the 3rd element from the end. 2nd element has an index of 1 (Python starts at zero index) and 3rd element from the end has an index of -2, end index returns the (index – 1), meaning the index is bigger by one number.
# value 2nd from start until 2nd from the end my_list[1:-2]
[3, 4, 5, 5, 7, 8, 1, 5, 6, 2]
You can specify a stride—either positive or negative. Stride is added to the square bracket as a second colon
:, the stride form will be
[start_index : end_index : step]. Step control defines how many elements to skip before selecting the next element.
my_list = [2, 3, 4, 5, 5, 7, 8, 1,5, 6, 2, 9, 0] my_list[1:7:2] # this will select elements 2nd to 7th every two steps
[3, 5, 7]
Python lets you to easily reverse lists
my_list = [2, 3, 4, 5, 5, 7, 8, 1,5, 6, 2, 9, 0] my_list[::-1]
[0, 9, 2, 6, 5, 1, 8, 7, 5, 5, 4, 3, 2]
A list can contain sublists, which in turn can contain sublists themselves.
Each element in list or its sublists can be accessed with element index.
my_list = ['a', ['b', 'c', 'd'], 'e', [['f', 'g'], 'h'], 'i', 'j'] my_list # Returns all sublists in the index number 3
[['f', 'g'], 'h']
Each sublist adds another square bracket to access its elements.
my_list returns index 3 of the main list and an element at index 1 of the sublist
Simply append another square bracket. All operations of slicing can also be performed on the second square bracket, etc.
my_list = ['a', ['b', 'c', 'd'], 'e', [['f', 'g'], 'h'], 'i', 'j'] my_list # It returns index 3 of the main list and elements at index 1 of the sublist