07-元组&字典&集合

1.元组

1.1元组基本介绍

（1）元组表现形式tuple
（2）元组是一个不可变序列（一般当我们希望数据不改变是，我们使用元组，其他情况下基本都用列表）
（3）使用()创建元素
（4）元组不是空元组至少有一个逗号（，），当元组不是空元组时逗号可以省略。
（5）元组解包指将元组当中的每一个元素都赋值给一个变量。
示例1-1：

>>> x=(1,2,3)  #直接把元组赋值给一个变量
>>> type(x)   #使用type()函数查看变量的类型
<class 'tuple'>
>>> x[0]      #元组支持使用下标访问特定位置的元素
1
>>> x[-1]     #最后一个元素，元素支持双向索引
3
>>> x[1]=4    #元组是不可变的
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> x=(3)   #如果元组中只有一个元素，必须在后面多写一个逗号
>>> x
3
>>> x=(3,)
>>> x
(3,)
>>> x=()    #空元组
>>> x=tuple()   #空元组
>>> x
()
>>> tuple(range(5))     #将其他迭代对象转换为元组
(0, 1, 2, 3, 4)
>>>

除了上面的方法可以直接创建元组外，很多内置函数的返回值也是包含了若干元组的可迭代对象，如enumerate(),zip()等。

>>> list(enumerate(range(5)))
[(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]
>>> list(zip(range(3),'abcdefg'))
[(0, 'a'), (1, 'b'), (2, 'c')]

1.2元组和列表的异同点

列表和元组都属于有序序列，都支持使用双向索引访问其中的元素，以及使用count()方法同级元素的出现次数和Index()方法获取元素的索引，len(),map(),filter()等大量内置函数和+,*,+=,in等运算符都可以作用于列表和元组。虽然列表和元组有着一定的相似之处，但在本质上和内部实现上都有着很大的不同。
元组属于不可变序列，不可以直接修改元组中元素的值，也无法为元组增加或删除元素。所以，元组没有提供append()，extend()和insert()等方法，无法向元素进行del操作，不能从元组中删除元素，而只能使用del命令删除整个元组。元组也支持切片操作，但是只能通过切片来访问元组中的元素，而不允许使用切片来修改元组中元素的值，也不支持使用切片操作来作为元组增加或删除元素。从一定程度上讲，可以认定为元组是轻量级列表，或者是“常量列表”。
最后，作为不可变序列，与整数，字符串一样，元组可用作字典的键，也可以作为集合的元素。而列表则永远不能当做字典使用，也不能作为集合中的元素，因为列表是可变的。内置函数hash()可以用来测试一个对象可否哈希。一般来说，并不需要关心该函数的返回具体指是什么，重点对象是否可哈希，如果对象不可哈希会抛出异常。

3430019387558
>>> hash(3)
3
>>> hash('hello world.')
4668373805177389937
>>> hash([1,2])       #列表不可哈希
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
>>>

1.3生成器推导式

生成器推导式也称为生成器表达式，用法和列表推导式非常相似，在形式上生成器推导式使用圆括号作为界定符，而不是列表推导式所使用的方括号。与列表推导式最大的不同是，生成器推导式的结果是一个生成器对象。生成器对象类似于迭代对象，具有惰性求值的特点，只在需要时生成新元素，比列表推导式具有更高的效率，空间占用非常少，尤其适合大数据处理的场合。
使用生成器对象的元素时，可以将其转化为列表或元组，也可以使用生成器对象的__next__()方法或者内置函数next()进行遍历，或者是直接使用for循环来遍历其中的元素。但是不管用哪种形式，只能从前往后正向访问其中的元素，没有任何方法可以再次访问已访问过的元素，也不支持使用下标访问其中的元素。当所有元素访问结束以后，如果需要重新访问其中的元素，必须重新创建该生成器对象。Enumerate,filter,map,zip等对想也具有同样的特点。最后，包含yield语句的函数也可以用来创建生成器对象。

>>> g = ((i+2)**2 for i in range(10))  #创建生成器对象
>>> g
<generator object <genexpr> at 0x000001C1AC7D5AF0>
>>> tuple(g)    #将生成器对象转换为元组
(4, 9, 16, 25, 36, 49, 64, 81, 100, 121)
>>> list(g)   #生成器对象已遍历结束，没有元素了
[]
>>> g=((i+2)**2 for i in range(10))   #重新创建生成器对象
>>> g.__next__()   #使用生成器对象的__next__()方法获取元素
4
>>> g.__next__()    #获取下一个元素
9
>>> next(g)  #使用函数next()获取生成器对象中的元素
16
>>> g=((i+2)**2 for i in range(10))
>>> for item  in g:    #使用循环直接遍历生成器对象中的元素
...     print(item,end=' ')
...
4 9 16 25 36 49 64 81 100 121 >>>
>>> x = filter(None,range(20))   #filter对象也具有类似的特点
>>> 1 in x
True
>>> 5 in x
True
>>> 2 in x    #不可再次访问已访问过的元素
False
>>> x=map(str,range(20))    #map对象也具有类似的特点
>>> '0' in x
True
>>> '0' in x    #不可再次访问已访问过的元素
False
>>>

1.4元组和记录

1.5元组拆包

1.6 嵌套元组拆包

1.7具名元组

1.8作为不可变列表的元组

2.字典简介

2.1泛映射类型

2.2字典的基本介绍

2.3字典的使用

2.4copye()

2.5字典推导

2.6常见的映射方法

2.7映射的弹性键查询

2.7.1 default:处理不到的键的一个选择

2.7.2 特殊方法__missing__

2.8字典的变种

2.9 子类化UserDict

2.10 不可变映射类型

3.集合

3.1集合简介

3.2集合的运算

3.3集合应用案例

3.4集合的推导

3.5集合的操作

4.dict和set的背后

4.1一个关于效率的实验

4.2字典中的散列表

4.2.1 散列值和相等性

4.2.2 散列表算法

4.3 dict的实现及其导致的后果

4.3.1键必须是可散列的

4.3.2字典在内存上的开销巨大

4.3.3键查询模块

4.3.4键的次序取决于添加顺序

4.3.5往字典里添加新键可能会改变已有键的次序

4.4 set的实现以及导致的结果