Start Learning for Free

Join over 1,000,000 other Data Science learners and start one of our interactive tutorials today!

Topic python small

18 Most Common Python List Questions

September 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:

  1. When To Use Lists And When To Use Tuples, Dictionaries Or Sets
  2. How To Select An Element From A List
  3. How To Transform Lists Into Other Data Structures
  4. How To Determine The Size Of Your List
  5. What’s The Difference Between The Python append() and extend() Methods?
  6. How To Concatenate Lists
  7. How To Sort a List
  8. How To Clone Or Copy A List
  9. How Does List Comprehension Work In Python?
  10. How To Count Occurrences Of A List Item In Python
  11. How To Split A List Into Evenly Sized Chunks
  12. How To Loop over A List
  13. How To Create Flat Lists Out Of Lists
  14. How To Get An Intersection Of Two Lists
  15. How To Remove Duplicates From A List
  16. Why NumPy Instead Of Lists?
  17. How To Create Empty NumPy Arrays
  18. 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.

If you are a regular visitor to forums to answer or ask questions about Python programming, such as Stack Overflow, Quora or Reddit, you might know the reason behind it.

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:

1. When To Use Python Lists And When To Use Tuples, Dictionaries Or Sets

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 append() or extend() method for tuples,
  • You can’t remove elements from a tuple. Tuples have no remove() or pop() method,
  • You can find elements in a tuple since this doesn’t change the tuple.
  • You can also use the in operator 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:

Hashable Non-Hashable
Floats Dictionaries
Integers Sets
Tuples Lists

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.

2. How To Select An Element From A List

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 biggerZoo list!


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 bear and 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 panda entry.

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 random package:


If you also want to select a random list element through the indices of your list, you can work with randrange method from the random library:


Tip: you should consider checking out the random library, as it will come in handy when you’re programming in Python!

3. How To Transform Python Lists Into Other Data Structures

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().

zip() actually works like expected: it zips elements together. In this case, when you zip the helloWorld elements helloWorld[0::2] and helloWorld[1::2], your output will be:


Note that you need to use list() to print out the result of the zip() function.

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 world and 2 elements are selected. Likewise, the first element uses the step value to select hello and 1.

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.

4. How To Determine The Size Of Your List in Python

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.

5. What’s The Difference Between The Python append() and extend() Methods?

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.

6. How To Concatenate Lists in Python

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 append() and 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:


7. How To Sort a List in Python

There are two very simple ways to get the values in your lists sorted in ascending or descending order:

  • You use the sort() method

  • Or you use the sorted() function and pass a list to it

The 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, rooms, and 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.

8. How To Clone Or Copy A List in Python

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 list() function: newList = list(oldList)
  • You can use the copy library:
    • With the copy() method: newList = copy.copy(oldList)
    • If your list contains objects and you want to copy those as well, you can use copy.deepcopy(): copy.deepcopy(oldList)

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!

9. How Does List Comprehension Work In Python?

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 x*x.

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!

10. How To Count Occurrences Of A List Item In 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 count() method:


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 count()

To count the occurrences of items in a list, you can also use list comprehension in combination with the count() method:


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 a and b. Then you say that for each set item, you want to take that item and pass it to a count() method

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 Counter()

Alternatively, there’s the faster Counter() method from the collections library:


Note that Counter() is generally faster when you want to count all list items.

11. How To Split A Python List Into Evenly Sized Chunks

To split your list up into parts of the same size, you can resort to the zip() function in combination with iter():


The code above works as follows:

  • iter() is an iterator over a sequence.
  • [iter(x)] * 3 produces a list with three listiterator objects: each list iterator is an iterator of x.
  • the * 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:

  1. 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]

  1. 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!

  1. 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]

  1. The last time, you follow the same procedure, and you end up with:

[1, 4, 7], [2, 5, 8], [3, 6, 9]

  1. 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:


Your 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 chunks() method).

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 chunks().

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:


12. How To Loop over A List in Python

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, [1,2,3] and [8, 9,10], only these will be printed out.

Note how x in the code chunk above can be changed to element, 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 print():


13. How To Create Flat Lists Out Of Lists

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 list or [1, 2], [3, 4], [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:

14. How To Get An Intersection Of Two Python Lists

List Intersection Using List Comprehension

If you want to obtain the intersection of two lists, you can use the filter() function.

This is illustrated in the exercise below. We have already defined two lists for you, list1 and 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 list2.

Note that, since filter() returns an iterable instead of a list, you need to wrap all you put into your filter() with 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 set()

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 intersection().

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!

15. How To Remove Duplicates From A List in Python

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 list() function.

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.

16. Why NumPy Instead Of Python Lists?

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.

17. How To Create Empty NumPy Arrays

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.

18. How To Do Math With Lists in Python

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 zip() function.

Tip: make a variable costAndCases to which you just assign the zip() function, with the cost and 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.


Remember what 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 map() function.

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!


why i cant see the examples of code in the editor?
10/20/16 7:25 PM |
Very informative article. There are a lot of things I learned for the first time. For e.g. I did not know that I can convert any blog or website to an interactive learning platform using datacamp-light.
09/09/16 2:30 PM |
Thank you, I'm very happy to hear this! It's definitely worth checking out DataCamp Light and its capabilities. It can really change your tutorial drastically and make it, as you say, an interactive learning platform.
10/17/16 9:22 PM |