list and tuple in python difference

May 29, 2026 - Lists and tuples both store collections of data, but differ in mutability, performance and memory usage. Lists are mutable, allowing modifications, while tuples are immutable.

Real Python

realpython.com › python-lists-tuples

Lists vs Tuples in Python – Real Python

April 17, 2026 - The key difference between lists and tuples is that lists are mutable, allowing you to modify them after creation, while tuples are immutable so you can’t change them once defined.

Discussions

What is the difference between a tuple and a list?

I have decided to overwrite my comments. More on reddit.com

r/learnpython

12

15

August 27, 2018

Tuples vs Lists, when do you decide which one you use?

I believe that some other answers comes from people much more experienced than me. That said, I’ll share how I approach your question. Use lists where you have a mutable number of items (if you need to add, remove or modify items from a list and use the list itself afterwards). Use tuples if you have a fixed number of items at the time of the creation of the tuple. You won’t be able to modify and use it again later, though (that would require creating a new tuple, which would probably defeat the optimization effort) Use generators when you need a “list” with items that are the result of a function and that should only be iterated over once. For example, let’s say you have a list of files. Let’s say you need to pass an iterable of files names to a function. This is a good place to use a Generator: create a generator function to iterate over the files list and yield each file’s name. Generator are a very good tool to optimize RAM usage =]. More on reddit.com

r/learnpython

61

96

August 26, 2022

python - What's the difference between lists and tuples? - Stack Overflow

What are the differences between lists and tuples, and what are their respective advantages and disadvantages? ... The others answered below, but I'd like to point out, that, imho, python has a totally unintuitive data type names. I don't think any other language has tuples (by that name), and whats worse as a word I can't even translate it in ... More on stackoverflow.com

stackoverflow.com

tuples vs lists

Not really relevant to your question, but Are tuples more efficient than lists? is a good SO question if you want to dive into the weeds at all. More on reddit.com

r/learnpython

11

40

January 31, 2021

Top answer

1 of 5

19

I have decided to overwrite my comments.

2 of 5

16

Technically there's not much difference. Only that a list includes a few extra methods that make it mutable, and a tuple include some extra code to make it hashable. Semantically, we use a list when you have a group of things that are alike, and a tuple for groups of things that aren't alike but logically go together. Or put another way, an element's position in a list is usually random, while in a tuple it's fixed. # I know the number of cylinders is always at index 1 car_description = ('red', 6, 'Mazda') # The order may be important, but the index does not give information about the element type my_cars = ['Nissan Leaf', 'Toyota Pickup']

Sunstone

sunstone.in › blog › difference-between-list-and-tuple-python

Difference Between List and Tuple in Python | Sunstone Blog

In Python, a tuple is similar to a list in that it is a collection of ordered elements, but there are some key differences between them. A tuple is an immutable sequence, which means that once it is created, its contents cannot be changed.

Find elsewhere

Google Bing Mojeek

Medium

medium.com › @datasciencejourney100_83560 › difference-between-list-and-tuple-8398bfd22667

Difference between List and Tuple: | by Rina Mondal | Medium

September 3, 2025 - # List creation using square brackets my_list = [1, 2, 3, 4, 5] print("List:", my_list) # Tuple creation using parentheses my_tuple = (1, 2, 3, 4, 5) print("Tuple:", my_tuple) List: Lists are mutable, which means you can modify, add, or remove elements after the list is created. You can use methods like append(), extend(), insert(), remove(), and pop() to modify a list.

reddit.com › r/learnpython › tuples vs lists, when do you decide which one you use?

r/learnpython on Reddit: Tuples vs Lists, when do you decide which one you use?

August 26, 2022 -

Hey r/learnpython, I have noticed I often default to lists in the expectation I will need them to be mutable but not sure what the common practice is.
If you are unsure if you will need it to be mutable, do you start with a tuple just for efficiency's sake and go back and make it a list if you find later you need it to be mutable?
Or start with a list and make it a tuple if you later realize you never needed to actually change it?
What is the common practice here? I think I am underusing tuples and overusing lists.

Top answer

1 of 22

42

I believe that some other answers comes from people much more experienced than me. That said, I’ll share how I approach your question. Use lists where you have a mutable number of items (if you need to add, remove or modify items from a list and use the list itself afterwards). Use tuples if you have a fixed number of items at the time of the creation of the tuple. You won’t be able to modify and use it again later, though (that would require creating a new tuple, which would probably defeat the optimization effort) Use generators when you need a “list” with items that are the result of a function and that should only be iterated over once. For example, let’s say you have a list of files. Let’s say you need to pass an iterable of files names to a function. This is a good place to use a Generator: create a generator function to iterate over the files list and yield each file’s name. Generator are a very good tool to optimize RAM usage =].

2 of 22

31

Tuples are One thing with many parts. Lists are Several things in a bag. If these don't fit, you probably shouldn't be using either of them. There is a false equivalence between lists and tuples--they aren't for the same things at all. If you are unsure if you will need it to be mutable You should know this up-front. I don't mean this in the "you're not doing it right" I mean you do know this, you're just second-guessing yourself. The data either represents something immutable, or it doesn't. You never ask yourself if the value "5" should be immutable because it's obvious--your data is this way too. Very likely, if you have doubts, it should be in a different data structure. Or start with a list and make it a tuple if you later realize you never needed to actually change it? No. They aren't for the same things. A tuple is for very specific uses that don't cross over with a list. Don't use a list for multiple properties of a single piece of data--a list is for a group of things. Don't use a tuple for a group of things--a tuple is for a single, multi-valued thing. Today, (with the occasional exception of returning multiple arguments from a function) you are probably better off using something more sophisticated rather than a tuple. Dataclasses and NamedTuples are both clearer alternatives that still represent a single object. I think I am underusing tuples and overusing lists. Probably not the first, but most beginners do overuse lists. Is it a group of things? Then it belongs in a list or a set. You should revisit this criteria for the "things" as well. Is it one thing with a trivial number of understandable properties? Then a tuple might work. Things like a coordinate, the dimensions of a square, or someone's names in order all make great examples of a tuple. A coordinate doesn't change--if the values are different it's a different coordinate. Otherwise use a structured type: dataclass, NamedTuple, or a class.

Uncodemy

uncodemy.com › blog › difference-between-list-and-tuple-in-python-with-examples

Difference Between List and Tuple in Python with Examples

Lists offer flexibility and extensive functionality, while Tuples provide security, speed, and hashability. If you’re looking to gain mastery over such Python concepts, enrolling in a Python Programming Course in Noida can be a game-changer.

AnalytixLabs

analytixlabs.co.in › home › blog › list vs tuple in python: understanding key differences

List vs Tuple in Python: Understanding Key Differences

March 26, 2026 - Lists can store mixed data types, including numbers, strings, dictionaries, tuples, and other lists, thereby making them a heterogeneous as well as a nestable data structure. Thanks to this feature, they are able to support real-world data modeling and structured records. For example, one can create a mixed list having different kinds of data types: mixed_list = [10, "Python", 3.14, None] mixed_list

Stack Overflow

stackoverflow.com › questions › 626759 › whats-the-difference-between-lists-and-tuples

python - What's the difference between lists and tuples? - Stack Overflow

Top answer

1 of 16

1123

Apart from tuples being immutable there is also a semantic distinction that should guide their usage. Tuples are heterogeneous data structures (i.e., their entries have different meanings), while lists are homogeneous sequences. Tuples have structure, lists have order.

Using this distinction makes code more explicit and understandable.

One example would be pairs of page and line number to reference locations in a book, e.g.:

my_location = (42, 11)  # page number, line number

You can then use this as a key in a dictionary to store notes on locations. A list on the other hand could be used to store multiple locations. Naturally one might want to add or remove locations from the list, so it makes sense that lists are mutable. On the other hand it doesn't make sense to add or remove items from an existing location - hence tuples are immutable.

There might be situations where you want to change items within an existing location tuple, for example when iterating through the lines of a page. But tuple immutability forces you to create a new location tuple for each new value. This seems inconvenient on the face of it, but using immutable data like this is a cornerstone of value types and functional programming techniques, which can have substantial advantages.

There are some interesting articles on this issue, e.g. "Python Tuples are Not Just Constant Lists" or "Understanding tuples vs. lists in Python". The official Python documentation also mentions this

"Tuples are immutable, and usually contain an heterogeneous sequence ...".

In a statically typed language like Haskell the values in a tuple generally have different types and the length of the tuple must be fixed. In a list the values all have the same type and the length is not fixed. So the difference is very obvious.

Finally there is the namedtuple in Python, which makes sense because a tuple is already supposed to have structure. This underlines the idea that tuples are a light-weight alternative to classes and instances.

2 of 16

417

Difference between list and tuple

Literal
```
someTuple = (1,2)
someList  = [1,2] 
```
Size
```
a = tuple(range(1000))
b = list(range(1000))

a.__sizeof__() # 8024
b.__sizeof__() # 9088
```
Due to the smaller size of a tuple operation, it becomes a bit faster, but not that much to mention about until you have a huge number of elements.
Permitted operations
```
b    = [1,2]   
b[0] = 3       # [3, 2]

a    = (1,2)
a[0] = 3       # Error
```
That also means that you can't delete an element or sort a tuple. However, you could add a new element to both list and tuple with the only difference that since the tuple is immutable, you are not really adding an element but you are creating a new tuple, so the id of will change
```
a     = (1,2)
b     = [1,2]  

id(a)          # 140230916716520
id(b)          # 748527696

a   += (3,)    # (1, 2, 3)
b   += [3]     # [1, 2, 3]

id(a)          # 140230916878160
id(b)          # 748527696
```
Usage

As a list is mutable, it can't be used as a key in a dictionary, whereas a tuple can be used.
```
a    = (1,2)
b    = [1,2] 

c = {a: 1}     # OK
c = {b: 1}     # Error
```

reddit.com › r/learnpython › tuples vs lists

r/learnpython on Reddit: tuples vs lists

January 31, 2021 -

So below i was wondering what the difference is in using a tuple vs a list in a dictionary below is the code. IK that lists are easier to modify and that tuples are immutable but like how does that actually come into effect in code. If someone could give an example that would be great. So ig you would use a list if you wanted to append or change the data?

course = { "language": ["French", "German"], "duration": "3 months" } print(course)

vs

course = { "language": ("French", "German"), "duration": "3 months" } print(course)

Top answer

1 of 5

24

Not really relevant to your question, but Are tuples more efficient than lists? is a good SO question if you want to dive into the weeds at all.

2 of 5

2

Although there is a performance benefit to using tuples, I rarely find myself reaching for them for that reason. My general rule is, if you have a bunch of items with a same type and arbitrary length and order I'll go with the list. If the ordering of the items means something especially if they are different types I'll go with the tuple. Although lately I tend to use a named tuple in that case. Typical usecase for me would be a row in a database/csv.

Programiz

programiz.com › python-programming › list-vs-tuples

Python Lists Vs Tuples (With Examples)

Note: As the tuple is immutable these are fixed in size and list are variable in size. Lists has more builtin function than that of tuple. We can use dir([object]) inbuilt function to get all the associated functions for list and tuple.

Wscube Tech

wscubetech.com › home › difference between list and tuple in python (with example)

Difference Between List and Tuple in Python (With Example)

January 22, 2025 - In Python, lists and tuples are two classes of data structures. A list is a dynamic container that stores multiple data types simultaneously and can be changed readily. It is used to hold a sequence of data and iterate over it.

Unstop

unstop.com › home › blog › 15 differences between list and tuple in python simplified

15 Differences Between List And Tuple In Python Simplified

February 4, 2025 - The key difference between list and tuple in Python is that lists are mutable, i.e., can be modified once created, while tuples are immutable and use less memory.

Codeling

codeling.dev › blog › python-lists-vs-tuples

Lists vs Tuples in Python: What You Need to Know

July 25, 2025 - If you want to create a tuple with just one item, you must include a trailing comma otherwise Python interprets it as a regular value wrapped in parentheses: not_a_tuple = (1) # This is just an integer a_real_tuple = (1,) # This is a tuple · You can also create empty sequences with their respective syntax: ... This is useful when you’re transforming or copying data from one structure to another. Despite their differences, lists and tuples share a lot of functionality.

Scaler

scaler.com › home › topics › difference between list and tuple in python

Difference Between List and Tuple in Python - Scaler Topics

September 5, 2023 - The major difference between list and tuple whereas lists are mutable, and tuples are immutable. The lists are mutable means that the Python object(list) can be modified after creation, whereas tuples can't be modified after creation.

DEV Community

dev.to › msnmongare › differences-between-list-and-tuple-in-python-4n1g

Differences Between List and Tuple in Python - DEV Community

March 12, 2025 - Lists are defined using square brackets [] and can store heterogeneous items (i.e., items of different data types). For example: ... Tuple: A tuple is an immutable, ordered sequence of elements.

Python Geeks

pythongeeks.org › python geeks › learn python › difference between tuple and list in python | tuples vs lists

Difference between Tuple and List in Python | Tuples vs Lists - Python Geeks

August 14, 2021 - Example of showing the difference in the syntax of a list and a tuple: list1=['a','e','i','o','u'] #list tup=('a','e','i','o','u') #tuple · In Python, tuples occupy a lesser amount of size compared to the lists. Dice tuples are immutable, larger blocks of memory with lower overhead are allocated for them.