18 Most Common Python List QuestionsSeptember 7th, 2016 in Python
The post will offer simple solutions, easy-to-follow and straightforward explanations and some tips and tricks that you can practice on the spot with the help of some interactive exercises!
Here are the python list questions that we will answer in this tutorial:
- When To Use Lists And When To Use Tuples, Dictionaries Or Sets
- How To Select An Element From A List
- How To Transform Lists Into Other Data Structures
- How To Determine The Size Of Your List
- What’s The Difference Between The Python append() and extend() Methods?
- How To Concatenate Lists
- How To Sort a List
- How To Clone Or Copy A List
- How Does List Comprehension Work In Python?
- How To Count Occurrences Of A List Item In Python
- How To Split A List Into Evenly Sized Chunks
- How To Loop over A List
- How To Create Flat Lists Out Of Lists
- How To Get An Intersection Of Two Lists
- How To Remove Duplicates From A List
- Why NumPy Instead Of Lists?
- How To Create Empty NumPy Arrays
- How To Do Math With Lists
If you want to learn about lists in a course format, you should take a look at our free course Intro to Python for Data Science, which has a chapter on pythons lists.
Lists are an increasingly popular topic for those who are starting to learn Python as well as for those who are already experienced with the language. If we believe the search results in Google Trends, the search interest in this topic has been rising each and every year.
A lot of Python questions find their ways to these forums and continue to persist there, where users mark some as ‘duplicate’ or ‘sticky’, upvote them or discuss the right solution with others.
With this blog post, DataCamp wants to help you to tackle one topic, namely, the most frequently asked questions about lists in Python, and this in an interactive way!
What’s A Python List Exactly?
Lists are one of the four built-in data structures in Python, together with tuples, dictionaries, and sets. They are used to store an ordered collection of items, which might be of different types but usually they aren’t. The elements that are contained within a list are separated by commas and enclosed in square brackets. Just like in this example:
You see that the second variable
biggerZoo is a list that is similar to the
zoo variable. However, you also see that
biggerZoo contains another list with different types of monkeys within.
Since lists in Python store ordered collections of items or objects, we can say that they are sequence types, exactly because they behave like a sequence. Other types that are also considered to be sequence types are strings and tuples.
You might wonder what’s so special about sequence types. Well, in simple words, it means that the program can iterate over them! This is why lists, strings, tuples, and sets are called “iterables”.
Keep in mind that this concept is particularly important and that it could be that you see this concept returning in other programming languages that are used in data science, such as Scala!
Now we get to the real work! Let’s get deeper into which questions about lists that might have or could haunt you as a Python programmer. Here's a list of all the questions we will answer in this tutorial:
The introduction seems pretty straightforward when you’re just reading it, but when you’re actually working on a small python script or a whole project, the choice for a list or some other sequence type might not be as clear to you.
However, choosing the right data structure for your data is essential!
Keep on reading to find out more.
Lists Versus Tuples
Tuples are used to collect an immutable ordered list of elements. This means that:
- You can’t add elements to a tuple. There’s no
extend()method for tuples,
- You can’t remove elements from a tuple. Tuples have no
- You can find elements in a tuple since this doesn’t change the tuple.
- You can also use the
inoperator to check if an element exists in the tuple.
So, if you’re defining a constant set of values and all you’re going to do with it is iterate through it, use a tuple instead of a list. It will be faster than working with lists and also safer, as the tuples contain “write-protect” data.
Lists Versus Dictionaries
- A list stores an ordered collection of items, so it keeps some order. Dictionaries don’t have any order.
- Dictionaries are known to associate each key with a value, while lists just contain values.
Use a dictionary when you have an unordered set of unique keys that map to values.
Note that, because you have keys and values that link to each other, the performance will be better than lists in cases where you’re checking membership of an element.
Lists Versus Sets
- Just like dictionaries, sets have no order in their collection of items. Not like lists.
- Set requires the items contained in it to be hashable, lists store non-hashable items.
- Sets require your items to be unique and immutable. Duplicates are not allowed in sets, while lists allow for duplicates and are mutable.
You should make use of sets when you have an unordered set of unique, immutable values that are hashable.
You aren’t sure which values are hashable?
Take a look below just to be sure:
Tip: don’t believe us on our word! Try it out for yourself below and experiment in the IPython shell :)
Note that, as you’re working with hashable items, checking membership (testing whether a certain element is part of your sequence) will go faster with sets than with lists.
If you want who work properly with these lists, you will need to know how to access them.
You typically access lists to change certain values, to update or delete them, or to perform some other kind of operation on them. The way you access lists, and, by extension, all other sequence types, is by using the index operator
[ ]. Inside, you put an integer value.
Let me show you an example:
Run the code and see what you get back from this piece of code. You will see that the first element of the
biggerZoo variable is returned. It might be a bit confusing or surprising at first, but indices start from 0 and not 1.
How To Get The Last Element Of A List In Your List
The answer to this question is an addition to the explanation in the previous section.
Try putting a negative value, such as -1 or -2 to the index operator to retrieve the last element of our
Not too hard, is it?
What Does The Index Out Of Range Error Mean?
This error is one that you will see quite often, especially when you’re new to programming or new to Python.
The best way to understand what this error means is to try it out for yourself.
Use the interactive learning widget above and try passing excessively small negative or large positive numbers!
As you can see, you might get an “Index Out Of Range” error in cases where you pass an integer value to the index operator that is bigger or way smaller than your list! It means that you are assigning a value or referring to an index that does not exist (yet).
This piece is an example of code that will trigger an “Index Out Of Range” error. Let it run and see for yourself!
The Slice Notation In Lists
When you’re new to programming or Python, this can be one particularly confusing topic.
In general, you use the slice notation when you want to select more than one list element at a time. Much like when you select just one element from a list, you use the double brackets. What’s so special now is that instead of just an integer, you also put a
: in between the double brackets, just like this:
You see that now we get the
biggerZoo list, but only from the
panda entry at index 2 onwards. In other words, we start from index 2 and go to the end of the list, since no other integer is specified.
What happens now when we do the reverse, you think?
Find out if you’re right by running the code chunk above!
You see that now we only get back
lion. Now we start from index 0 and go to index 2. Contrary to what you might have expected, the result does not include the
In general, the following holds:
a[start:end] # items start through the end (but the end is not included!) a[start:] # items start through the rest of the array a[:end] # items from the beginning through the end (but the end is not included!)
Tip: by just passing a colon
:, you will just copy the list!
In addition to the simple slice notation, there is also the step value, which can be generalized like this:
a[start:end:step] # start through not past end, by step
So what does this step value exactly do?
Well, it allows you to literally step through your list and select only those elements that your step value includes. An example:
Note that if you don’t specify any step value, it is just set to 1. No elements will then be skipped when stepping through the list.
Remember that your result does not include the end value index that you specify in the slice notation!
How To Randomly Select An Element In A List
You can select a random element from your list with the
If you also want to select a random list element through the indices of your list, you can work with
randrange method from the
Tip: you should consider checking out the
random library, as it will come in handy when you’re programming in Python!
Sometimes, a list is not exactly what you need. In these cases, you might want to know how to transform your list to a more appropriate data structure. Below, we list some of the most common transformation questions and their answers.
How To Convert A List To A String
You convert a list to a string by using
''.join(). This operation allows you to glue together all strings in your list together and return them as a string. Read more here.
Note that if your list only contains integers, you should convert the elements to strings before performing the join on them. This is illustrated in the second example in the interactive code block above.
The conversion from an integer to a string is done by looping over the original
listOfNumbers list. If you want to know more about how to loop over a list, go to question 12 and its answer.
How To Convert A List To A Tuple
You can change a list to a tuple in Python by using the
tuple() function. Pass your list to this function and you will get a tuple back!
Remember: tuples are immutable. You can’t change them afterwards!
Tip: you can try transforming your
listOfStrings into a tuple in the interactive exercise of the next section.
How To Convert Your List To A Set In Python
As you will remember, a set is an unordered collection of unique items. That means not only means that any duplicates that you might have had in your original list will be lost once you convert it to a set, but also the order of the list elements.
You can change a list into a set with the
set() function. Just pass your list to it!
Now practice converting your list
listOfStrings into a tuple and a set here:
How To Convert Lists To A Dictionaries
A dictionary works with keys and values, so the conversion from a list to a dictionary might be less straightforward. Let’s say you have a list like this:
helloWorld = ['hello','world','1','2']
You will need to make sure that ‘hello’ and ‘world’ and ‘1’ and ‘2’ are interpreted as key-value pairs. The way to do this is to select them with the slice notation and pass them to
zip() actually works like expected: it zips elements together. In this case, when you zip the helloWorld elements
helloWorld[1::2], your output will be:
Note that you need to use
list() to print out the result of the
You will pass this to the
dict() function, which will interpret
hello as a key and
world as a value. Similarly,
1 will be interpreted as a key and
2 as a value.
Run the code below to confirm this:
Note that the second element that is passed to the
zip() function makes use of the step value to make sure that only the
2 elements are selected. Likewise, the first element uses the step value to select
If your list is large, you will probably want to do something like this:
Note that an iterable object can give you an iterator. The iterator, which has a
.__next__ method, holds information on where exactly you are in your iteration: it knows what is the next element in the iteration.
You can pass your list to the
len() function to get the length of your list back.
Test this out below! We have already made a list
justAList which you can use.
Note that the
len() function is not specifically to retrieve the lenght of your lists, but can also be used with other sequences or collections, such as dictionaries, sets, strings, etc. You can find more general built-in functions here.
Let’s begin to address this question by revisiting the concept of an iterable that we explained in the first section of this post:
Remember that we say that a certain value is iterable when your program can iterate over it. In other words, an iterable is a value that represents a sequence of one more values. As you probably read in the first section, lists are sequences and all instances of Python’s sequence types are iterables.
Tip: you check whether a variable is iterable when it has the
.__iter__ method, like in this piece of code:
Run the code above and try out some other simple examples in the IPython shell!
Now that the concept of an iterable is clear in our minds, we can begin to understand the difference between the two methods.
extend(), on the one hand, takes an iterable (that’s right, it takes a list, set, tuple or string!), and adds each element of the iterable to the list one at a time.
append(), on the other hand, adds its argument to the end of the list as a single item, which means that when the
append() function takes an iterable as its argument, it will treat it as a single object.
Study the code chunks below and play around with the code for yourself to understand the differences between these two methods:
You can see that
extend() is a more efficient version of calling
append() multiple times.
To concatenate lists, you use the
+ operator. It will give you a new list that is the concatenation of your two lists without modifying the original ones.
Note that concatenating and appending might be confusing.
append() is different from the
+ operator, which in its turn is very similar to the
extend() method, but not exactly the same… You see that with
extend(), you modify your original list, while with the
+ operator, you can make another list variable.
Test this out for yourself and compare with the examples from the previous code chunk:
There are two very simple ways to get the values in your lists sorted in ascending or descending order:
You use the
Or you use the
sorted()function and pass a list to it
sorted() function can be applied to any Iterable object, which means that it also accepts strings, sets, dictionaries when they are passed to it!
Tip: try this out for yourself! We have already made two lists,
orders, which you can sort for yourself using the two techniques described above :)
Note how your original list is changed after you have performed the sorting to it. It is advised to use this in cases where you have no use for your original list anymore.
There are a lot of ways of cloning or copying a list:
- You can slice your original list and store it into a new variable:
newList = oldList[:]
- You can use the built-in
newList = list(oldList)
- You can use the
- With the
newList = copy.copy(oldList)
- If your list contains objects and you want to copy those as well, you can use
- With the
Try it out below! We have already created a
groceries list for you to copy and share with your friends.
Note that when you use the ‘simple’ copy methods, your original lists will be modified. However, if you use the
deepcopy() method, this will be prevented. Run the code below to see what happens:
For those of you who have already taken lists in Python to the next level, the following section offers you some simple answers to your complex questions.
However, for those of you who wonder what is beyond lists, what advantages libraries might offer instead of the built-in list structure, the next section might certainly come in handy.
Continue to read to find out more!
List comprehension is, basically speaking, a way of elegantly constructing your lists. The best thing about this for those who love math is the fact that they look a lot like mathematical lists. Judge for yourself:
Now, what does this mean? You take all numbers from 0 to 10, where 10 is not included, and you multiple each and every one of those numbers by 2. Run the piece of code above to see if the result matches your expectations.
Not too hard, is it? Let’s take it up a notch!
Let’s say you want to make the same list as before, but you only want to multiply the numbers that can be divided by 2. Even this is easy with the help of list comprehension:
You just add a condition, indicated by
if, to your original statement. If that condition proves to be TRUE, the number will be considered for multiplication by 2. In this case, our condition is that the number can be divided by 2 (without having any remainder of the division operation).
Now, in a more general sense, you can also use list comprehension to transform your lists into other lists, which sounds a bit more difficult, doesn’t it?
Consider the next example:
In this example, you already have a list
myList that you’re transforming through list comprehension: you see that again
for x in myList, for every list element in
myList, some operation will be done.
Next, you see that
(lambda x: x*x) is included. To keep things simple for you, you should just know that lambda functions are anonymous functions that are constructed at runtime. Considering that that piece of code can just serve as an indication for you, you can just ignore it and focus on
You see that this function takes one element and multiplies it by itself. It’s an anonymous function, so you need to pass it your list element to make sure that the lambda function takes that one as input. That is why you see
(lambda x: x*x)(x).
In other words, you could rewrite the whole second line of the above chunk of code as:
f = lambda x: x*x [f(x) for x in range(10)]
In which you first define your lambda function that says that you want to multiply an element by itself, and then in the second line pass it your list element to make sure that each list element is multiplied by itself.
Note that besides list comprehensions, also set and dictionary comprehensions exist.
This was already quite something, but there is much more to discover about list comprehension.
Keep on reading through the following frequently asked questions to learn more about nested list comprehension and to see more practical examples of what list comprehension can mean for your programming with Python!
Since lists don’t have the item uniqueness criterium, like sets, you might want to know more about how not only many times one particular list item occurs in your list but also how many times each list item is encountered.
Below you will find the answers to both questions!
Counting the occurrences of one item in a list
To count the occurrences of just one list item you can use the
Counting the occurrences of all items in a list is also known as “tallying” a list, or creating a tally counter.
Counting all items in a list with
To count the occurrences of items in a list, you can also use list comprehension in combination with the
In this piece of code, you first see that your list is converted to a set. This will make sure that only the unique list items are kept, namely
b. Then you say that for each set item, you want to take that item and pass it to a
Remember that sets only contain unique items!
In this case, first
a will be passed to
list.count(x) and all occurrences of
a in your original list will be counted.
Counting all list items with
Alternatively, there’s the faster
Counter() method from the
Counter() is generally faster when you want to count all list items.
To split your list up into parts of the same size, you can resort to the
zip() function in combination with
The code above works as follows:
iter()is an iterator over a sequence.
[iter(x)] * 3produces a list with three
listiteratorobjects: each list iterator is an iterator of
*that is passed to the
zip()function before anything else unpacks the sequence into arguments so that you’re passing the same iterator three times to the
zip()function, and it pulls an item from the iterator each time.
Wait. That last step is totally not clear.
Let me guide you step by step:
- You will have three list iterator objects, which you can think of as:
[1,2,3,4,5,6,7,8,9], [1,2,3,4,5,6,7,8,9], [1,2,3,4,5,6,7,8,9]
- The first time,
zip()will take one element of the list sequentially, which leaves you with:
Note that the iterator objects will keep track for you which element is next in the iteration!
- The second time, elements will be added to the three lists you just created, and you will end up with:
[1, 4], [2, 5], [3, 6]
- The last time, you follow the same procedure, and you end up with:
[1, 4, 7], [2, 5, 8], [3, 6, 9]
- Zipping these three lists together will leave you with:
[1, 2, 3], [4, 5, 6], [7, 8, 9]
If, however, you decide to put this logic into a function, you can follow this approach:
chunks() function gets a list and a chunk size as input. It will then print: “Yield successive (your chunk size)-sized chunks from list” (i.e. the list that you give your
Then, you see
range(0, len(list), chunkSize): this list starts at 0 and ends at the integer that signals the length of your list. The step value is set equal to the
chunkSize value you pass to
For each element in this list constructed by
range(), you yield a chunk of the original list, starting at the index of the element that it is given and ends at the index + chunk size it is given.
For example, if you index 0 passes through the for loop, a list of [0:2] will be given. In the next iteration, index 2 gets passed through the for loop (remember the step value!) and a chunk of your original list, [2:4] will be outputted.
Note that you use
pprint() or pretty print to print your result.
You can also you can simply use list comprehension instead of writing a function:
You can easily loop through any list with a for loop. For those of you who haven’t worked much with for loops, it works as follows: the for loop allows you to perform an action for every element in your list.
In Python, a for loop looks like this:
You have a list
mylist and you tell Python that you should check if the length of each list element is equal to 3. Since our lists contain two lists that each have three elements in them, namely,
[8, 9,10], only these will be printed out.
x in the code chunk above can be changed to
listElement or whatever name you want to give it. Try it out in the console!
You see here that the result doesn’t show the indices of the elements. If you want to iterate over a list by making use of the index, you can do that as follows:
Since you want to print out not only the list elements but also their index, you of course have to show this in your for loop. This is why we use
enumerate(myList), which will return an index and a value. Naturally, we have to show this also in the beginning of our for statement: you see
i, val to make clear that we’re expecting an index and a value as a result.
Note that you can also use list comprehension to loop over a list. Here, the results are already printed out without you having to pass
To make a simple list out of a list of lists, you can use the
sum() function. Just don’t forget to pass your list and an empty list to it:
You can also use a two different approaches to flatten your lists:
You either use the
reduce()method, to which you pass a lambda function. Now, the
reduce()method is there to ensure that your iterable is reduced to a single value. How it is reduced, you determine with the function that you pass to it. In this case, you say that you want to sum the elements cumulatively: what happens, is that
[1,2]is added to
[3,4]and this result is added to
[5,6]. Represented visually, this gives:
Remember that the
+ operator concatenates lists.
- The second option to make flat lists out of lists of lists is to use list comprehension. This nested for loop statement doesn’t make it easy on you. What it comes down to is that you first take
sublist in listor
[5, 6]and then you want to consider
item for item in sublist, printing out each item from the sublist.
Another way of seeing this nested list comprehension is to rewrite it as a regular for loop:
list1 =  for sublist in list: for item in sublist: list1.append(item)
List Intersection Using List Comprehension
If you want to obtain the intersection of two lists, you can use the
This is illustrated in the exercise below. We have already defined two lists for you,
list2. Use the IPython shell if you want to check the contents of the lists.
In the piece of code above, the
filter() part takes each sublist’s item and checks to see if it is in the source list
list1. The list comprehension is executed for each sublist in
Note that, since
filter() returns an iterable instead of a list, you need to wrap all you put into your
list(). Try removing the
list() to test this out for yourself!
For better readability, you could also work with nested list comprehensions:
Intersecting Lists With
If the order of your elements is not important and if you don’t need to worry about duplicates then you can use set intersection:
In the first example, you convert both lists to sets, intersect them and then output them again as a list. The order in the outputted list will be arbitrary. You can also convert the larger of the two lists into a set, after which you can get the intersection of that set with any iterable using
Note that for these two approaches to work, your list should not contain other lists. That is why
list2 looks different. Print it out just to make sure!
As described in the first section of this blog post, it’s best to select a set if you want to store a unique collection of unordered items.
To create a set from any iterable, you can simply pass it to the built-in
set() function. If you later need a real list again, you can similarly pass the set to the
Remember that an iterable can be a list, dictionary, … Check whether a variable is an iterable by applying the method
.__iter__ to it.
The following example clearly demonstrates the use of
set() to delete all duplicates from your list:
As you can see from the last result, the original order of your list is not maintained after you detract the set elements of
smallNumbers. As you already know by now, sets themselves are unordered collections, so any order that you had in your list is lost. When you convert your set back to a list, an arbitrary order is created for you.
If the order of your elements is important to you, then you will have to use a different mechanism. This page covers that topic in more detail.
In general, there seem to be four reasons why Python programmers prefer NumPy arrays over lists in Python:
- because NumPy arrays are more compact than lists.
- because access in reading and writing items is faster with NumPy.
- because NumPy can be more convenient to work with, thanks to the fact that you get a lot of vector and matrix operations for free
- because NumPy can be more efficient to work with because they are implemented more efficiently.
If you just want to create an empty NumPy array, you can execute the following:
However, if your goal is to initialize a NumPy array, you can also follow one of the following approaches:
Make sure to check out this documentation if you’re looking for other ways to initialize your NumPy array.
A lot of the time, we not only use lists to store a collection of values, but we also use it to perform some mathematical operations on it. This section will cover some of the most frequently asked questions on doing math with lists.
How To Calculate the Weighted Average of a List
The weighted average is much like an average but is slightly different: a weighted average returns a number that depends on the variables of both value and weight.
This definition might seem a bit heavy at first. Let’s take a look at an example:
cost = [0.424, 0.4221, 0.4185, 0.4132, 0.413] cases = [10, 20, 30, 40, 50]
You can easily calculate the weighted average with the following pieces of code:
But, you can also go for one of these two other approaches. Firstly, you can use:
Or you can use this one:
Lastly, you can also you calculate the weighted average of your list with the help of the
Tip: make a variable
costAndCases to which you just assign the
zip() function, with the
case variables assigned to it. You will see how another list is created with only tuples. The first value of each tuple expresses the cost, while the second element expresses the cases that can be bought for that price.
zip() does to your lists? Easy, it zips your lists together, literally. For example,
zip(cost, cases) would output
[(0.424, 10), (0.4221, 20), (0.4185, 30), (0.4132, 40), (0.413, 50)].
How To Calculate the Quantile of a List in Python
Quantiles are essential to making a summary of your data set, next to the minimum and maximum of your set. You also have the 25th, 50th, and the 75th percentile, but they are also called first quartile, median and third quartile.
That means that in total, you need five numbers to summarize your entire data set: the minimum, maximum, the median and your two quartiles.
The minimum and the maximum of your data set are easy to find, but what about those percentiles?
It’s easy. Let’s say you have 25 instances, sorted from low to high, in your data set:
The 25th percentile or first quartile is calculated by multiplying 0.25 with 25. The resulting number, 6.25 or 7 if we round up, gives you an indication which number is the 25th percentile: the 7th instance in your sorted list of instances.
The third quartile or 75th percentile is calculated by multiplying 0.75 with 25. The resulting number, 18.75, 19 if we round up, tells you that the 19th instance in your sorted list of instances is your third percentile.
The median of your data set is calculated by multiplying 0.5 with 25. The 13th number will be the median since you round up 12.5.
But how do you program this to work for your list?
The easiest way to do this is by working with NumPy. Follow the instructions in the interactive exercise below to calculate the percentiles or your list:
How To Sum Lists Element-Wise
Let’s say you have two lists:
list1=[1, 2, 3] list2=[4, 5, 6]
And you want to make sure that you add the list element element-wise; That is, that 1 is added to 4, 2 to 5 and 3 to 6. You have two ways of accomplishing this.
Keep on reading to learn more!
… With Basic Python
You can use map with
operator.add to perform an element-wise addition:
This will result in a list
[5, 7, 9].
Note how you will need to make use of
list() to print the result of the
Or you can use the
zip() function with a list comprehension:
… With NumPy
The previous examples worked perfectly on these small lists, but when you’re working with slightly more data, you should probably use
numpy to make the process easier.
You should then make sure that you import the
numpy library and that your lists are converted into NumPy arrays:
What’s Up Next In Your Data Science Journey With Python?
You have reached the end of our interactive tutorial on lists in Python. It was quite a lot to process and a fair amount of work, but you made it!
Lists are only a small but essential element in your data science journey with Python. There’s so much more to explore! Our free interactive Intro to Python for Data Science course is perfect for those who want to learn If more about Python and how it is used in data science: it will start from the very basics of Python to gradually and gently bring you to an intermediate level by introducing NumPy to you. Perfect for those with little experience in (Python) programming!
If, however, you’re already a more advanced Python user, you might just consider checking out our Intermediate Python For Data Science course, tailored to those who are ready to take their data science and Python skills to the next level. This course will definitely bring you even further in your data science learning! The course introduces you to more libraries, such as matplotlib and pandas, concepts, such as logic, control flow, and filtering, and includes a data science case study in order to consolidate your skills.
Are you already using Python for data science but you want to go even further? You might be interested in our Importing Data Into Python course or consider reading our The importance of preprocessing in data science and the machine learning pipeline tutorial series!