# why implement two so similar data structures like list and tuple [duplicate]

• Last Update :
• Techknowledgy :

Immutable types are hashable, and can be used as dictionary keys. This works:

```key = (1, 2, 3)
d = {
key: 1
}```

But this doesn't:

```key = [1, 2, 3]
d = {
key: 1
}```

If it did, what would you expect this to do?

```key[0] = 2
print d[key] # id(key) hasn 't changed, so surely the lookup should still work
print d[[1, 2, 3]] # but also, we stored a piece of data at[1, 2, 3], didn 't we?
print d[[2, 2, 3]] # but
if d[key] works, surely we can expand key to its value```

Suggestion : 2

Differences and Applications of List, Tuple, Set and Dictionary in Python,List, Tuple, Set, and Dictionary are the data structures in python that are used to store and organize the data in an efficient manner.,Below is the program for implementation of List, tuple, set, and dictionary:,Set: A Set is an unordered collection data type that is iterable, mutable, and has no duplicate elements. Python’s set class represents the mathematical notion of a set.

```Adding 5 and 10 in list[5, 10]
Popped one element from list[5]

Adding 5 and 10 in set {
10,
5
}
Removing 5 from set {
10
}

Tuple(5, )

Dictionary {
5: 'Five',
10: 'Ten'
}
Dictionary {
5: 'Five'
}```

Suggestion : 3

2 days ago The syntax for lists and tuple s look very similar but have some key differences. The list uses square brackets (i.e., [1, 2, 3] is a list) while a tuple uses parentheses (i.e., (1, 2, 3) is a tuple ). They both have 3 elements that store 1, then 2, then … , This Python Data Structure is like a, like a list in Python, is a heterogeneous container for items. But the major difference between the two (tuple and list) is that a list is mutable, but a tuple is immutable. This means that while you can reassign or delete an entire tuple, you cannot do the same to a single item or a slice. , 2 days ago The first thing you need to decide is whether the data structure needs to be mutable or not. As has been mentioned, lists are mutable, tuples are not. This also means that tuples can be used for dictionary keys, wheres lists cannot. In my experience, tuples are generally used where order and position is meaningful and consistant. , These are the data structures similar to lists. The only difference is that these are homogeneous, that is, have the elements of the same data type. There is a type of array called Matrix which is a 2 dimensional array, with all the elements having the same size.

```key = (1, 2, 3) d = {
key: 1
}```
```key = (1, 2, 3) d = {
key: 1
}```
```key = [1, 2, 3] d = {
key: 1
}```
```key[0] = 2 print d[key] # id(key) hasn 't changed, so surely the lookup should still work print d[[1, 2, 3]]  # but also, we stored a piece of data at [1, 2, 3], didn'
t we ? print d[[2, 2, 3]] # but
if d[key] works, surely we can expand key to its value```

Suggestion : 4

Tuple is a collection which is ordered and unchangeable. Allows duplicate members. Use normal brackets () for tuples.,List is a collection which is ordered and changeable. Allows duplicate members. Use square brackets [] for lists.,Set is a collection which is unordered and unindexed. No duplicate members. Use curly brackets {} for sets.,Dictionary is a collection which is unordered, changeable and indexed. No duplicate members. Use curly brackets {} for dictionaries (see section 8).

```myList = [5, 3, 56, 13, 33]
myList```
```myList = list(range(10))
myList```
```myList = list(range(3, 12))
myList```
```myList = list(range(1, 12, 2))
myList```
```myList = [] # Create an empty list
myList.append(5) # Add a single value to the back of the list
myList```
```myList.insert(0, 9) # Insert a value in the list at index(element position) 0
myList```