Python学习笔记(2)之元组、字典&集合
0.写在前面
快开学了琐事比较多，就更新的慢了一些。开学以后也会边学边写，不定时更新，灰常感谢大家的支持和鼓励！也希望大佬们不吝赐教，多提提意见or建议，有什么好的学习资源的话也希望能分享一下，感激不尽！
这篇文章第一版中字典的BIF部分还没写完，我会尽快写完补上，因为刚刚被小伙伴提醒发现自己的wiki还没有写。。。
1. 元组（tuple）——一个上了锁的列表
“一切有权力的人都容易滥用权利。“ ——孟德斯鸠
在学完列表之后，发现列表真的是很强大。这种极大的灵活性无疑带来了很多便利，但是站在安全的角度上讲， 却不利于保护数据。于是元组应运而生。
元组是一种不可改变的类型，一旦定义了元组，里面的任何一个元素都无法再更改。元组（tuple）和列表（list）在使用上十分相似，因此我只是简记一下它们不同之处。关于列表的相关内容可参见文末的上一篇文章。
1.1 建立元组
在建立列表时，只需要中括号[ ]来创建。对应的，建立元组一般只需用小括号( )即可，元素之间用逗号分隔。
>>> tuple1 = (1 , '嘻嘻嘻' , [1,2,3] , int)
>>> type(tuple1)
<class 'tuple'>
注意！小括号( )不是元组的特征，逗号才是！！
>>> temp = ( 1 )
>>> type(temp)
<class 'int'>
会发现，即使加上了小括号，temp仍然是整型！
>>> temp = 1 , int , '嘻嘻嘻' , int
>>> type(temp)
<class 'tuple'>
因此，逗号才是元组的标志！However，中括号[]确是list的标志！
>>> temp = [ 1 ]
>>> type(temp)
<class 'list'>
不过用小括号创建空元组是可行的。
>>> temp = ()
>>> type(temp)
<class 'tuple'>
那么问题来了，要建立只有一个元素的元组怎么办呢？可以这样：
>>> temp = (1,)
>>> type(temp)
<class 'tuple'>
>>> len(temp)
1
甚至可以进一步简化为
>>> temp = 1,
>>> type(temp)
<class 'tuple'>
1.2 元组切片（slice）
这部分元组和列表是完全一样的，因此不多赘述。Python处理元组仍然是“贴标签”的方式。
>>> tuple1 = (1 , '嘻嘻嘻' , [1,2,3] , int)
>>> tuple1[3]
<class 'int'>
>>> tuple1[2:]
([1, 2, 3], <class 'int'>)
>>> tuple2 = tuple1[:] #copy a tuple
>>> print(tuple2)
(1, '嘻嘻嘻', [1, 2, 3], <class 'int'>)
1.3 元组不可添加、删除、修改元素
若按列表的方式去试图修改元组会报错。
>>> tuple1 = (1 , '嘻嘻嘻' , [1,2,3] , int)
>>> tuple1.append('可以添加吗？')
Traceback (most recent call last):
File "<pyshell#30>", line 1, in <module>
tuple1.append('可以添加吗？')
AttributeError: 'tuple' object has no attribute 'append'
>>> tuple1[1] = '可以修改吗？'
Traceback (most recent call last):
File "<pyshell#31>", line 1, in <module>
tuple1[1] = '可以修改吗？'
TypeError: 'tuple' object does not support item assignment
1.4 操作符&比较大小
这部分和列表是完全相同的，+,*,in等操作符可用于元组，元组之间可比较大小，比较的方法和列表相同。
>>> temp = 1 , 2
>>> temp * 3
(1, 2, 1, 2, 1, 2)
>>> 1 in temp
True
Tips: 变相"修改"元组中元素
>>> tuple1 = (1 , '嘻嘻嘻' , [1,2,3] , int)
>>> tuple1 = tuple1[:2] + ('加一个元素',) + tuple1[2:]
>>> print(tuple1)
(1, '嘻嘻嘻', '加一个元素', [1, 2, 3], <class 'int'>)
这样，我们就在tuple1里加了一个元素进去。这是怎么做到的呢？事实上，只是巧妙的运用了元组的拼接。看似是tuple1中多了一个元素，其实是我们创建了一个新的元组，再把tuple1这个标签贴到了新元组上而已。类似地，可用切片间接地“删除”元组里的元素。
无论如何元组是不可改变的！
也可以利用函数list()将元组转换成列表，再对其进行修改。
2. 字典 （dictionary）—— A kind of mapping
列表中的元素是有序的，并且有属于自己的索引值。调取列表中的元素只能通过其索引值来实现。而“字典”提供了一种key+value的方式，给每个元素一个标签，这样我们便可以通过该表现来调取元素。
2.1 创建字典
创建字典最简单的方式是用大括号{ }，格式为｛key1: value1 , key2: value2 , ...｝，调取时直接通过object[key]的方式。
>>> dict1 = {'目标':'减肥！减肥！' , '口号':'燃烧我的卡路里！'}
>>> print('我们的口号是：' + dict1['口号'])
我们的口号是：燃烧我的卡路里！
利用dict()函数
dict()函数有两种用法，一种是dict(mapping)，其中mapping可以用元组或着列表的形式给出。
>>> dict1 = dict((('目标','减肥！减肥！') , ('口号','燃烧我的卡路里！')))
>>> print(dict1)
{'目标': '减肥！减肥！', '口号': '燃烧我的卡路里！'}
hhh看上去好多括号，主要原因是用这种方式的话dict只能有一个参数，所以必须用()或者[]给括起来喏。
另一种方式是用关键字参数dect(key1=value1, key2=value2, ...)，注意key是不能加引号的！
>>> dict2 = dict(目标='减肥！减肥！' , 口号='燃烧我的卡路里！')
>>> print(dict2)
{'目标': '减肥！减肥！', '口号': '燃烧我的卡路里！'}
2.2 常用操作
在字典中添加元素可以直接采用object[a new key]=value的方式。
>>> dict2['方式'] = '每天跑步十公里！'
>>> dict2
{'目标': '减肥！减肥！', '口号': '燃烧我的卡路里！', '方式': '每天跑步十公里！'}
删除元素的话采用del object[key]的方式即可。
>>> dict2 = {'目标': '减肥！减肥！', '口号': '燃烧我的卡路里！', '方式': '每天跑步十公里！'}
>>> del dict2['目标']
>>> dict2
{'口号': '燃烧我的卡路里！', '方式': '每天跑步十公里！'}
2.3 常用的BIF
占个位置先，日后补上。。。
3. 集合（set）
Python中的集合和数学中的集合的性质是相同的，即无序性和互异性。
3.1 建立集合
创立集合也有两种方式。一是用大括号{}，当大括号里只有value而没有key时，所创建的数据类型即为集合。
>>> set1 = {1 , 2 , int , '嘻嘻嘻'}
>>> type(set1)
<class 'set'>
另一种方式是利用set()函数，将列表或元组转换成集合。
>>> set([1 , 1 , 2 , '嘻嘻嘻' , int])
{1, 2, '嘻嘻嘻', <class 'int'>}
有趣的是，原来列表中的两个"1"变成集合后只剩一个了。
问：如何删除列表中重复的值？
>>> num1 = [1,2,3,4,5,4,3,2,1]
>>> num1 = list(set(num1))
>>> print(num1)
[1, 2, 3, 4, 5]
3.2 访问集合中的值
集合中的元素是无序的，因此若试图通过索引值来访问集合中的值会报错。
>>> set1 = {1 , 2 , int , '嘻嘻嘻'}
>>> set1[1]
Traceback (most recent call last):
File "<pyshell#85>", line 1, in <module>
set1[1]
TypeError: 'set' object does not support indexing
可以利用for循环来读取集合中的值，举个简单的例子：
>>> set1 = {1 , 2 , int , '嘻嘻嘻'}
>>> for i in set1:
print(i , end=' ')
1 2 嘻嘻嘻 <class 'int'>
3.3 集合的运算
设A、B是两个集合，则集合的运算可以通过以下方式进行：
| 运算符 | 意义 |
|---|---|
| A <= B | 子集测试 ：A 是B的子集 |
| A < B | 子集测试 ：A 是B的真子集 |
| A >= B | 超集测试 ：B 中所有的元素都是 A 的成员 |
| A > B | 等价于 B < A |
| A | B | 取并集 |
| A & B | 取交集 |
| A - B | 差分操作：在 A 中存在，在 B 中不存在的元素 |
| A ^ B | 对称差分操作：A "或" B 中的元素，但不是 A 和 B 共有的元素 |
例如
>>> a={1,2,3}
>>> b={1,3,4}
>>> c={1,2,3,4}
>>> a & b
{1, 3}
>>> a | b
{1, 2, 3, 4}
>>> a - b
{2}
>>> a<c
True
3.4 向集合中添加、删除元素
添加或删除集合中的元素可分别使用.add()和.remove()函数。
>>> set1 = {1 , 2 , int , '嘻嘻嘻'}
>>> set1.add(1e5)
>>> print(set1)
{100000.0, 1, 2, '嘻嘻嘻', <class 'int'>}
>>> set1.remove('嘻嘻嘻')
>>> print(set1)
{100000.0, 1, 2, <class 'int'>}
3.5 不可变集合（frozen set）
若想定义一个类似与元组一样不可变的集合，可以利用frozenset()函数。顾名思义，不可变集合的元素是无法进行修改的。
>>> set2 = frozenset([1 , int , '嘻嘻嘻'])
>>> set2.add(0)
Traceback (most recent call last):
File "<pyshell#97>", line 1, in <module>
set2.add(0)
AttributeError: 'frozenset' object has no attribute 'add'
3.6 关于可哈希（hashable）
如果一个对象在自己的生命周期中有一哈希值（hash value）是不可改变的，那么它就是可哈希的（hashable）的，因为这些数据结构内置了哈希值，每个可哈希的对象都内置了hash方法，所以可哈希的对象可以通过哈希值进行对比，也可以作为字典的键值和作为set函数的参数。所有python中所有不可改变的的对象（imutable objects）都是可哈希的，比如字符串，元组，也就是说可改变的容器如字典，列表不可哈希（unhashable）。我们用户所定义的类的实例对象默认是可哈希的（hashable），它们都是唯一的，而hash值也就是它们的id()。
简单来讲，Python中有些数据类型是不可变的，比如字符串str、元组tuple、对象集objects、不可变集合frozenset，称为可哈希(hashable)的数据类型；也有些数据类型是可变的，比如字典dict，列表list，集合set，称为不可哈希(unhashable)的数据类型。
集合和字典的存储方式都是保存元素的哈希值，因此集合和字典都是无序的，并且集合中哈希值相同的元素（相同元素）便保存为一个，这也便是集合的互异性（或者叫唯一性）。因此，集合无法储存不可哈希的数据类型。举个例子：
>>> { [1,2] , int , '嘻嘻嘻'}
Traceback (most recent call last):
File "<pyshell#105>", line 1, in <module>
{ [1,2] , int , '嘻嘻嘻'}
TypeError: unhashable type: 'list'
这样创建的集合会报错，提示列表list是不可哈希的。同样集合中的元素不能是集合，但是可以是不可变集合frozenset。
>>> set1 = set([1,2,3,4]) #创建一个集合
>>> set2 = frozenset([1,2,3,4]) #创建一个不可变集合
>>> {set1}
Traceback (most recent call last):
File "<pyshell#111>", line 1, in <module>
{set1}
TypeError: unhashable type: 'set'
>>> {set2}
{frozenset({1, 2, 3, 4})}
