python中list ,tuple,dict,set的关系以及不可变对象解释（图文详解）

list

1.list可以放进tuple (易知）

2.list可以放入dict作为value，但不可以作为key

>>> key = [1, 2, 3]
>>> d[key] = 'a list'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

3.list不可以放入set，如：

>>> l = [1,2,3]
>>> s = set([2,3,4])
>>> s.add(l)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

但是可以用为输入集合如:

>>> s = set([1, 2, 3])
>>> s
{1, 2, 3}

4.list可以放入list（易知）

tuple

1.tuple可以放入list （易知）

2.tuple可以放入dict作为key，同时可以作为value（只有不含list，tuple，set，dict的tuple可以当为key）

 

>>> t = (1,2,3)
>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> d[t] = 90
>>> d
{'Tracy': 85, 'Bob': 75, 'Michael': 95, (1, 2, 3): 90}

3.tuple可以放入set （只有不含list，tuple，set，dict的tuple可以放进set）

 

>>> c = (1,[2,3])
>>> s = set([2,3,4])

>>> s.add(c)

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

4.tuple可以放入tuple（易知）

dict

1.dict可以放入tuple

>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> t = (1,2,d)
>>> t
(1, 2, {'Tracy': 85, 'Bob': 75, 'Michael': 95})

2.dict可以放入list

>>> d = {'Michael': 95, 'Bob': 75}
>>> l =[1,2,d]
>>> l
[1, 2, {'Bob': 75, 'Michael': 95}]

3.dict不可放入set  

>>> d = {'Michael': 95, 'Bob': 75}
>>> s = set([1,2,3])
>>> s.add(d)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'dict'

4.dict可以放入dict作为value，但不可以作为key

>>> d = {'Michael': 95, 'Bob': 75}
>>> di = {'chael': 45, 'ob': 5}
>>> di['chael'] = d
>>> di
{'chael': {'Bob': 75, 'Michael': 95}, 'ob': 5}
>>> di[d] = 40
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'dict'

set

1.set可以放入tuple

>>> s = set([1,2,3])
>>> t = (3,4,s)
>>> t
(3, 4, {1, 2, 3})

2.set可以放入list(易知)

3.set可以放入dict作为value，但不可以作为key

>>> s = set([1,2,3])
>>> di = {'chael': 45, 'ob': 5}
>>> di[s] = 67
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'set'

4.set不可以放入set

>>> s = set([1,2,3])
>>> s1 = set([5,6])
>>> s.add(s1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'set'

conclusion

总结一下：

1.list可存放：tuple、dict、set、list

2.tuple可存放：list、dict、set、tuple

3.set可存放：tuple (不含list，tuple，set，dict的tuple)

4.dict的key可存放：tuple (不含list，tuple，set，dict的tuple)

5.dict的value可存放：list、tuple、set、dict

几个概念

• tuple的“不变”

  看一个“可变的”tuple：

  >>> t = ('a', 'b', ['A', 'B'])
  >>> t[2][0] = 'X'
  >>> t[2][1] = 'Y'
  >>> t
  ('a', 'b', ['X', 'Y'])
  

  这个tuple定义的时候有3个元素，分别是'a'，'b'和一个list。不是说tuple一旦定义后就不可变了吗？怎么后来又变了？

  我们先看看定义的时候tuple包含的3个元素：

  

  当我们把list的元素'A'和'B'修改为'X'和'Y'后，tuple变为：

  

  表面上看，tuple的元素确实变了，但其实变的不是tuple的元素，而是list的元素。tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向'a'，就不能改成指向'b'，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！

  理解了“指向不变”后，要创建一个内容也不变的tuple怎么做？那就必须保证tuple的每一个元素本身也不能变

• 不可变对象

  str是不变对象，而list是可变对象。要记住：dict和set中的key都是不可变对象！

  对于可变对象，比如list，对list进行操作，list内部的内容是会变化的，比如：

  >>> a = ['c', 'b', 'a']
  >>> a.sort()
  >>> a
  ['a', 'b', 'c']
  

  而对于不可变对象，比如str，对str进行操作呢：

  >>> a = 'abc'
  >>> a.replace('a', 'A')
  'Abc'
  >>> a
  'abc'
  

  虽然字符串有个replace()方法，也确实变出了'Abc'，但变量a最后仍是'abc'，应该怎么理解呢？

  我们先把代码改成下面这样：

  >>> a = 'abc'
  >>> b = a.replace('a', 'A')
  >>> b
  'Abc'
  >>> a
  'abc'
  

  要始终牢记的是，a是变量，而'abc'才是字符串对象！有些时候，我们经常说，对象a的内容是'abc'，但其实是指，a本身是一个变量，它指向的对象的内容才是'abc'：

  ┌───┐                  ┌───────┐
  │ a │─────────────────>│ 'abc' │
  └───┘                  └───────┘
  

  当我们调用a.replace('a', 'A')时，实际上调用方法replace是作用在字符串对象'abc'上的，而这个方法虽然名字叫replace，但却没有改变字符串'abc'的内容。相反，replace方法创建了一个新字符串'Abc'并返回，如果我们用变量b指向该新字符串，就容易理解了，变量a仍指向原有的字符串'abc'，但变量b却指向新字符串'Abc'了：

  ┌───┐                  ┌───────┐
  │ a │─────────────────>│ 'abc' │
  └───┘                  └───────┘
  ┌───┐                  ┌───────┐
  │ b │─────────────────>│ 'Abc' │
  └───┘                  └───────┘
  

  所以，对于不变对象来说，调用对象自身的任意方法，也不会改变该对象自身的内容。相反，这些方法会创建新的对象并返回，这样，就保证了不可变对象本身永远是不可变的。