Lists
Overview
Lists are one of the most commonly used data types in Python. Some of the additional functionality covered in the following sections on this page help to illustrate why lists are so commonly used. We emphasize that parentheses ( are associated with tuples, while square brackets [ are associated with lists:
my_list = [1,2,3,4,5.5, "some_text"]Lists are mutable, meaning that they can be changed, after the list has initially been declared. This is notably different from tuples, which are immutable (i.e., cannot be changed).
my_list = [1,2,3,"i_can_be_muted"]
my_list[3] = "still_not_the_right_word"
print(my_list)[1,2,3,'still_not_the_right_word']
Just like tuples, you can convert between the two types easily:
lex_listor = [1,2,3] # I am a list
super_tuple = tuple(lex_listor)
print(type(super_tuple))<class 'tuple'>
Indexing
R and Python are similar in a lot of ways. One key distinction to understand is how they index values. Python is 0-indexed whereas R is 1-indexed. What does this mean? In practice, this means that the placement of items in R always starts with 1. In comparison, Python starts numbering with a 0. It is a little easier to understand in an example:
my_r_list <- c("first", "second", "third", "fourth")In this case since we are looking at R code the list indexing is:
["first", "second", "third", "fourth"] [ 1, 2, 3, 4 ]
So if we wanted to access the "third" entry, we could run:
my_list[3]However, in Python, the same list is 0-indexed. An example is included below, for comparison:
my_list = ["first", "second", "third", "fourth"]["first", "second", "third", "fourth"] [ 0 1 2 3 ]
If we wanted to get the "third" entry in the list, we would use the code snippet below:
my_list[2]Thankfully, some of the syntax is the same between Python and R. For example, the colon : continues to hold the same functionality between both languages (as long as you remember the index difference):
In R:
my_list[1:4]"first", "second", "third", "fourth"
In Python, we emphasize that the last number in a range is not used. In other words, if we use 0:2 for a range of indices, then we only get entry 0 and 1 but not entry 2.
my_list[0:2]"first", "second"
Python also supports a second : that indicates a "jump". For instance, in this case, we jump indices by 2 each time, in other words, we use every other index and skip the ones in between:
my_list[0:3:2]"first", "third"
Sadly, Python and R do differ in other ways. One major difference is how the two languages handle negative indexes. In R, they remove a value at the given position:
my_list[c(-1,-2)]"third", "fourth"
In Python, negative indexes just mean "start from the back of the list" instead of "start from the front". For example:
my_list[-1]"fourth"
Negative indexes can be a little confusing in Python, because while positive indexes are 0-indexed, negative indexes are not (not sure what -0 is). This means that my_list[-4] is valid. In this case, it would return "first". However if you tried to print my_list[4], it would produce an IndexError, because the last list value is my_list[3]. Don’t worry if this is a bit confusing at first. It gets easier as you write more Python code and practice indexing.
List Methods
A method is a function for a particular object. When you hear or read method this is basically the same thing as a function. A list in this case is an example of an object that you can run methods on. In Python, the most common objects, like lists, dicts, tuples, sets, etc., all have extremely useful methods built right in!
The following is a table of list methods from w3schools.
| Method | Description |
|---|---|
append() |
Adds an element at the end of the list |
clear() |
Removes all the elements from the list |
copy() |
Returns a copy of the list |
count() |
Returns the number of elements with the specified value |
extend() |
Add the elements of a list (or any iterable), to the end of the current list |
index() |
Returns the index of the first element with the specified value |
insert() |
Adds an element at the specified position |
pop() |
Removes the element at the specified position |
remove() |
Removes the item with the specified value |
reverse() |
Reverses the order of the list |
sort() |
Sorts the list |
We can demonstrate some of these methods in the examples below. Let’s start by creating a few lists that we can use:
list_one = ["first", "second", "third", "fourth", "fifth"]
list_two = ["sixth", "seventh", "eighth", "ninth"]What if we wanted to add the string "tenth" to list_two?
list_two.append("tenth")
print(list_two)["sixth", "seventh", "eighth", "ninth", "tenth"]
Ok, but what if we wanted to remove fourth from list_one and then add it back?
list_one.remove("fourth") # First we can remove it.
print(list_one)
list_one.append("fourth") # Then we can add it back.
print(list_one)["first", "second", "third", "fifth"] ["first", "second", "third", "fifth", "fourth"]
Notice that adding fourth back to the list changes its index place. In this case it goes from an index of 3 in the original list to 4 in the new list.
What if we wanted to remove the first element and save it in a new variable?
new_variable = list_one.pop(0)
print(f'The new variable: {new_variable}')
print(f'The old list: {list_one}')The new variable: first The old list: ["second", "third", "fourth", "fifth"]
These are awesome, but what if I wanted to combine the two lists into one big list?
list_one.extend(list_two)
print(list_one)['second', 'third', 'fifth', 'fourth', 'sixth', 'seventh', 'eighth', 'ninth', 'tenth']
List Comprehensions
Another great feature of lists in Python is the idea of list comprehensions. These allow for the concise creation of list objects and can include logic such as for and if statements. Lists aren’t the only object type that has comprehensions in Python (dict comprehensions are very helpful), but they are the most common.
For the first example, let’s say that we wanted to create a list of all even numbers between 1 and 10. We could do this via a for loop:
blank_list=[]
for i in range(1, 11):
if i % 2 == 0:
blank_list.append(i)
print(blank_list)[2,4,6,8,10]
This works well and will give us the output that we wouldd expect. However, we could also write this with a list comprehension:
blank_list = [i for i in range(1,11) if i % 2 == 0]
print(blank_list)[2,4,6,8,10]
The list comprehension follows the same logic as our original for loop above, but it is much more concise. List comprehensions can get pretty complex and can allow for nesting and function calls. You will also see lots of code examples that utilize list comprehensions. List comprehensions are definitely worthwhile to know.