{"id":619,"date":"2018-04-18T05:20:37","date_gmt":"2018-04-18T05:20:37","guid":{"rendered":"http:\/\/www.afternerd.com\/blog\/?p=619"},"modified":"2020-04-12T17:04:47","modified_gmt":"2020-04-12T17:04:47","slug":"difference-between-list-tuple","status":"publish","type":"post","link":"https:\/\/www.afternerd.com\/blog\/difference-between-list-tuple\/","title":{"rendered":"Python: What is the Difference between a List and a Tuple?"},"content":{"rendered":"

So you just learned about lists<\/a> and tuples<\/a> and you’re wondering how they differ?<\/p>\n

This is a surprisingly common question.<\/p>\n

They both behave in a very similar way.<\/p>\n

Both lists and tuples are sequence data types that can store a collection of items.<\/p>\n

Each item stored in a list or a tuple can be of any data type.<\/p>\n

And you can also access any item by its index.<\/p>\n

So the question is, are they different at all?<\/p>\n

And if not, why do we have two data types that behave pretty much in the same way?<\/p>\n

Can’t we just live with either lists or tuples?<\/p>\n

Well, let’s try to find the answer.<\/p>\n

The Key Difference between a List and a Tuple<\/h2>\n

The main difference between lists and tuples is the fact that lists are mutable<\/strong> whereas tuples are immutable<\/strong>.<\/p>\n

What does that even mean, you say?<\/p>\n

A mutable data type means that a python object of this type can be modified.<\/p>\n

An immutable object can’t.<\/p>\n

Let’s see what this means in action.<\/p>\n

Let’s create a list and assign it to a variable.<\/p>\n

>>> a = [\"apples\", \"bananas\", \"oranges\"]<\/code><\/pre>\n
Now let’s see what happens when we try to modify the first item of the list.<\/p>\n
Let’s change “apples”<\/span> to “berries”<\/span>.<\/p>\n
>>> a[0] = \"berries\"\r\n>>> a\r\n['berries', 'bananas', 'oranges']<\/code><\/pre>\n
Perfect! the first item of a<\/span> has changed.<\/p>\n
Now, what if we want to try the same thing with a tuple instead of a list? Let’s see.<\/p>\n
>>> a = (\"apples\", \"bananas\", \"oranges\")\r\n>>> a[0] = \"berries\"\r\nTraceback (most recent call last):\r\n  File \"\", line 1, in \r\nTypeError: 'tuple' object does not support item assignment<\/code><\/pre>\n
We get an error saying that a tuple object doesn’t support item assignment.<\/p>\n
The reason we get this error is because tuple objects, unlike lists, are immutable which means you can’t modify a tuple object after it’s created.<\/p>\n
But you might be thinking, Karim, my man, I know you say you can’t do assignments the way you wrote it but how about this, doesn’t the following code modify a<\/span>?<\/p>\n
>>> a = (\"apples\", \"bananas\", \"oranges\")\r\n>>> a = (\"berries\", \"bananas\", \"oranges\")\r\n>>> a\r\n('berries', 'bananas', 'oranges')<\/code><\/pre>\n
Fair question!<\/p>\n
Let’s see, are we actually modifying the first item in tuple a<\/span> with the code above?<\/p>\n
The answer is No<\/strong>, absolutely not.<\/p>\n
To understand why, you first have to understand the difference between a variable and a python object.<\/p>\n
The Difference Between a Variable and an Object<\/h2>\n
You are probably confusing variables with objects. This is a very common misconception among beginners.<\/p>\n
Remember that a variable is nothing but a reference to the actual python object in memory.<\/p>\n
The variable itself is not the object.<\/p>\n
For example, let’s try to visualize what happens when you assign a list to a variable a<\/span>.<\/p>\n
>>> a = [\"apples\", \"bananas\", \"oranges\"]<\/code><\/pre>\n
When you do this, a python object of type list is created in the memory and the variable a<\/span> refers to this object by holding its location in memory<\/strong>.<\/p>\n
\"\"<\/p>\n
In fact, you can actually retrieve the location of the list object in memory by inspecting a<\/span> using the id()<\/span> function.<\/p>\n
>>> a = [\"apples\", \"bananas\", \"oranges\"]\r\n>>> id(a)\r\n4340729544<\/code><\/pre>\n
Now if you modify the first index of the list, and check the id()<\/span> again, you will get the same exact value because a<\/span> is still referring to the same object.<\/p>\n
>>> a[0] = \"berries\"\r\n>>> id(a)\r\n4340729544<\/code><\/pre>\n
The following figure shows exactly what happened after the modification.<\/p>\n
\"\"<\/p>\n
Now, let’s see what happens if we perform the same thing on tuples.<\/p>\n
>>> a = (\"apples\", \"bananas\", \"oranges\")\r\n>>> id(a)\r\n4340765824\r\n>>> a = (\"berries\", \"bananas\", \"oranges\")\r\n>>> id(a)\r\n4340765464<\/code><\/pre>\n
As you can see, the two addresses are different.<\/p>\n
This means that after the second assignment, a is referring to an entirely new object.<\/p>\n
This figure shows exactly what happened.<\/p>\n
\"\"<\/p>\n
Moreover, if no other variables in your program is referring to the older tuple then python’s garbage collector will delete the older tuple from the memory completely.<\/p>\n
So there you have it, this concept of mutability is the key difference between lists and tuples.<\/p>\n
Mutability is not just a python concept, it is a programming language concept that you will encounter in various programming languages<\/a>.<\/p>\n
But now maybe this whole discussion evokes another question in your head.<\/p>\n
Why do we have mutable and immutable objects?<\/p>\n
Why Do we need Mutable and Immutable Objects?<\/h2>\n
Well actually, they both serve different purposes.<\/p>\n
Let’s discuss some of the aspects that differentiate between mutable and immutable objects\/<\/p>\n
1. Appending Performance<\/h3>\n
\"\"<\/p>\n
Mutability is more efficient when you know you will be frequently modifying an object.<\/p>\n
For example, assume you have some iterable object<\/a> (say x), and you want to append each element of x to a list.<\/p>\n
Of course you can just do L = list(x)<\/span> but under the hood this transforms into a loop that looks like this:<\/p>\n
L  = []\r\nfor item in x:\r\n    L.append(item)<\/code><\/pre>\n
This works alright. You keep modifying the list object in place until all the elements of x<\/span> exist in the list L<\/span>.<\/p>\n
But can you even imagine what would happen if we had used a tuple instead?<\/p>\n
T  = ()\r\nfor item in x:\r\n    T = T + (item,)<\/code><\/pre>\n
Can you visualize what is happening in the memory?<\/p>\n
Since tuples are immutable, you are basically copying the contents of the tuple T<\/span> to a new tuple object at EACH<\/strong> iteration.<\/p>\n
If the for loop is big, this is a huge performance problem.<\/p>\n
Actually, let’s use python to measure the performance of appending to a list vs appending to a tuple when x = range(10000).<\/p>\n
This article<\/a> teaches you how to use the timeit module to measure the execution time of multiple lines of python<\/a>.<\/p>\n
$ python3 -m timeit \\\r\n-s \"L = []\" \\\r\n-s \"x = range(10000)\" \\\r\n\"for item in x:\" \"    L.append(item)\"\r\n1000 loops, best of 3: 1.08 msec per loop<\/code><\/pre>\n
Cool, 1.08 milliseconds<\/strong>.<\/p>\n
How about if we do the same thing with tuples?<\/p>\n
$ python3 -m timeit \\\r\n-s \"T = ()\" -s \"x = range(10000)\" \\\r\n\"for item in x:\" \"    T = T + (item,)\"\r\n10 loops, best of 3: 1.63 sec per loop<\/code><\/pre>\n
A whopping 1.63 seconds<\/strong>!<\/p>\n
This is a huge performance difference between lists and tuples.<\/p>\n
If you want to test your patience, try x = range(1000000).<\/span><\/p>\n
Now when someone tells you multiple appending to a string<\/strong> object is inefficient, you will understand exactly why (string objects are immutable too in python).<\/p>\n
Appending performance: Mutability Wins!<\/strong><\/p><\/blockquote>\n
2. Easiness of Debugging<\/h3>\n
\"\"<\/p>\n
Mutability is cool and all but one thing that can be really annoying with mutable objects is debugging.<\/p>\n
What do I mean by that?<\/p>\n
Let’s take a look at this very simple example.<\/p>\n
>>> a = [1, 3, 5, 7]\r\n>>> b = a\r\n>>> b[0] = -10\r\n>>> a\r\n[-10, 3, 5, 7]<\/code><\/pre>\n
Notice that when we do b = a<\/span>, we are not copying the list<\/a> object from b<\/span> to a<\/span>.<\/p>\n
We are actually telling python that the two variables a<\/span> and b<\/span> should reference the same list object.<\/p>\n
Because a<\/span> effectively holds the location of the Python object in memory, when you say b = a<\/span> you copy that address location (not the actual object) to b<\/span>.<\/p>\n
This results in having two references (a and b) to the same list object.<\/p>\n
In other words when we do b[0] = -10<\/span>, it has the same effect as a[0] = -10<\/span>.<\/p>\n
Of course you can look at the code and rightfully think that it is easy to debug.<\/p>\n
Well, you are right for small snippets of code like this, but imagine if you have a big project with many references to the same mutable object.<\/p>\n
It will be very challenging to track all the changes to this object because any modification by any of those references will modify the object.<\/p>\n
This is not the case with immutable objects even if you have multiple references to them.<\/p>\n
Once an immutable object is created, its content will never change.<\/p>\n
Easiness of debugging: Immutability Wins!<\/strong><\/p><\/blockquote>\n
3. Memory Efficiency<\/h3>\n
\"\"<\/p>\n
Another benefit of immutability is that it allows the implementation of the language to be more memory efficient.<\/p>\n
Let me explain what I mean by that.<\/p>\n
In CPython<\/a>\u00a0(the most popular implementation of Python) if you create immutable objects that hold the same value, python (under certain conditions) might bundle these different objects into one.<\/p>\n
For example, take a look at this code:<\/p>\n
>>> a = \"Karim\"\r\n>>> b = \"Karim\"\r\n>>> id(a)\r\n4364823608\r\n>>> id(b)\r\n4364823608<\/code><\/pre>\n
Remember that Strings (as well as Integers, Floats, and Bools) are all examples of immutable objects as well.<\/p>\n
As you can see, even though in our python program we explicitly created two different string objects, python internally bundled them into one.<\/p>\n
How did we know that?<\/p>\n
Well because the identity of a<\/span> is exactly the same as the identity of b<\/span>.<\/p>\n
Python was able to do that because the immutability of strings makes it safe to perform this bundling.<\/p>\n
Not only that this will save us some memory (by not storing the string multiple times in memory), but also every time you want to create a new object with the same value, python will just create a reference to the object that already exists in memory which is definitely more efficient.<\/p>\n
This concept is called String Interning<\/a>, and this is an excellent article if you want to dive in deeper<\/a>.<\/p>\n
Not only strings. This also applies to integers (under certain conditions).<\/p>\n
>>> a = 1\r\n>>> b = 1\r\n>>> id(a)\r\n4305324416\r\n>>> id(b)\r\n4305324416<\/code><\/pre>\n
That’s pretty cool, isn’t it?<\/p>\n
What about tuples though?<\/p>\n
CPython until python 3.6 has made the design decision not to automatically bundle two equivalent tuples into one.<\/p>\n
>>> a = (1, 2)\r\n>>> b = (1, 2)\r\n>>> id(a)\r\n4364806856\r\n>>> id(b)\r\n4364806920<\/code><\/pre>\n
As you can see, a<\/span> has a different identity than b<\/span>.<\/p>\n
This design decision makes sense because performing interning for tuples requires making sure that all the tuple items are themselves immutable.<\/p>\n
Memory efficiency: Immutability Wins<\/strong><\/p><\/blockquote>\n
Conclusion<\/h2>\n
To understand the difference between python lists and tuples, you must understand the concept of mutability\/immutability first.<\/p>\n
Lists are mutable objects which means you can modify a list object after it has been created.<\/p>\n
Tuples, on the other hand, are immutable objects which means you can’t modify a tuple object after it’s been created.<\/p>\n
Both Mutability and Immutability have their own advantages and disadvantages.<\/p>\n
Learning Python?<\/h3>\n
Check out the Courses section!<\/a><\/p>\n\n
Featured Posts<\/h2>\n