接下来的python序列是个重要的内容，Python 序列（Sequence）是指按特定顺序依次排列的一组数据，它们可以占用一块连续的内存，也可以分散到多块内存中。Python 中的序列类型包括列表（list）、元组（tuple）、字典（dict）和集合（set）。我们需要变量来存放独立数据也需要用序列来存放连续数据。
列表（list）和元组（tuple）比较相似，它们都按顺序保存元素，所有的元素占用一块连续的内存，每个元素都有自己的索引，因此列表和元组的元素都可以通过索引（index）来访问。它们的区别在于：列表是可以修改的，而元组是不可修改的。
字典（dict）和集合（set）存储的数据都是无序的，每份元素占用不同的内存，其中字典元素以 key-value 的形式保存。
python序列
所谓序列，指的是一块可存放多个值的连续内存空间，这些值按一定顺序排列，可通过每个值所在位置的编号（称为索引）访问它们。序列类型包括字符串、列表、元组、集合和字典，这些序列支持以下几种通用的操作，但比较特殊的是，集合和字典不支持索引、切片、相加和相乘操作。
python的索引跟其他语言的集合啊数组啊都差不多，下表从0开始到N-1,除此之外，Python 还支持索引值是负数，此类索引是从右向左计数，换句话说，从最后一个元素开始计数，从索引值 -1 开始。而不是从0开始。但是访问都是一样的。
序列切片切片之后会生成一个新的序列。
序列实现切片操作的语法格式：
sname[start : end : step]
其中，各个参数的含义分别是：
sname：表示序列的名称；
start：表示切片的开始索引位置（包括该位置），此参数也可以不指定，会默认为 0，也就是从序列的开头进行切片；
end：表示切片的结束索引位置（不包括该位置），如果不指定，则默认为序列的长度；
step：表示在切片过程中，隔几个存储位置（包含当前位置）取一次元素，也就是说，如果 step 的值大于 1，则在进行切片去序列元素时，会“跳跃式”的取元素。如果省略设置 step 的值，则最后一个冒号就可以省略。
例如，对字符串“C语言中文网”进行切片：
str=“C语言中文网”
#取索引区间为[0,2]之间（不包括索引2处的字符）的字符串
print(str[:2])
#隔 1 个字符取一个字符，区间是整个字符串
print(str[::2])
#取整个字符串，此时 [] 中只需一个冒号即可
print(str[:])
运行结果为：
C语
C言文
C语言中文网
序列相加（拼接）
Python 中，支持两种类型相同的序列使用“+”运算符做相加操作，它会将两个序列进行连接，但不会去除重复的元素。
序列相乘（重复）
Python 中，使用数字 n 乘以一个序列会生成新的序列，其内容为原来序列被重复 n 次的结果。比较特殊的是，列表类型在进行乘法运算时，还可以实现初始化指定长度列表的功能。比如说一个空列表*2就会创建两个空列表。
in和not in关键字 用来检测某元素是否在序列之中。
格式：value in sequence
输出结果为布尔类型。
和序列相关的一些内置函数
函数 | 功能 |
len() | 计算序列的长度，即返回序列中包含多少个元素。 |
max() | 找出序列中的最大元素。注意，对序列使用 sum() 函数时，做加和操作的必须都是数字，不能是字符或字符串，否则该函数将抛出异常，因为解释器无法判定是要做连接操作（+ 运算符可以连接两个序列），还是做加和操作。 |
min() | 找出序列中的最小元素。 |
list() | 将序列转换为列表。 |
str() | 将序列转换为字符串。 |
sum() | 计算元素和。 |
sorted() | 对元素进行排序。 |
reversed() | 反向序列中的元素。 |
enumerate() | 将序列组合为一个索引序列，多用在 for 循环中。 |
列表list
相信大家都听那个说过数组，大部分语言也都支持数组，但是python有列表类型，列表更加方便，格式上来讲，个数没有限制，只要是 Python 支持的数据类型就可以。从内容上看，列表可以存储整数、小数、字符串、列表、元组等任何类型的数据，并且同一个列表中元素的类型也可以不同。虽然可以将不同类型的数据放入到同一个列表中，但通常情况下不这么做，同一列表中只放入同一类型的数据，这样可以提高程序的可读性。
创建列表
listname = [element1 , element2 , element3 , … , elementn]
这种方式一般用于创建且赋值变量给列表时候用。使用此方式创建列表时，列表中元素可以有多个，也可以一个都没有。
Python 还提供了一个内置的函数 list()，使用它可以将其它数据类型转换为列表类型。如下：
#将字符串转换成列表
list1 = list(“hello”)
print(list1)
#将元组转换成列表
tuple1 = (‘Python’, ‘Java’, ‘C++’, ‘JavaScript’)
list2 = list(tuple1)
print(list2)
#将字典转换成列表
dict1 = {‘a’:100, ‘b’:42, ‘c’:9}
list3 = list(dict1)
print(list3)
#将区间转换成列表
range1 = range(1, 6)
list4 = list(range1)
print(list4)
#创建空列表
print(list())
运行结果：
[‘h’, ‘e’, ‘l’, ‘l’, ‘o’]
[‘Python’, ‘Java’, ‘C++’, ‘JavaScript’]
[‘a’, ‘b’, ‘c’]
[1, 2, 3, 4, 5]
[]
访问列表元素，可以通过索引访问到某个元素的值，也可以通过切片方式来访问切片后的列表序列。
删除列表，对于已经创建的列表，如果不再使用，可以使用del关键字将其删除。实际开发中并不经常使用 del 来删除列表，因为 Python 自带的垃圾回收机制会自动销毁无用的列表，即使开发者不手动删除，Python 也会自动将其回收。所以，开发过程中基本上不会手动去删除列表。
列表添加元素
append() 方法用于在列表的末尾追加元素：
listname.append(obj)。其中，listname 表示要添加元素的列表；obj 表示到添加到列表末尾的数据，它可以是单个元素，也可以是列表、元组等。比如：
l = [‘Python’, ‘C++’, ‘Java’]
#追加元素
l.append(‘PHP’)
print(l)
#追加元组，整个元组被当成一个元素
t = (‘JavaScript’, ‘C#’, ‘Go’)
l.append(t)
print(l)
#追加列表，整个列表也被当成一个元素
l.append([‘Ruby’, ‘SQL’])
print(l)
运行结果为：
[‘Python’, ‘C++’, ‘Java’, ‘PHP’]
[‘Python’, ‘C++’, ‘Java’, ‘PHP’, (‘JavaScript’, ‘C#’, ‘Go’)]
[‘Python’, ‘C++’, ‘Java’, ‘PHP’, (‘JavaScript’, ‘C#’, ‘Go’), [‘Ruby’, ‘SQL’]]
可以看到，当给 append() 方法传递列表或者元组时，此方法会将它们视为一个整体，作为一个元素添加到列表中，从而形成包含列表和元组的新列表。
Python extend()方法添加元素：她的格式和append一样，也是添加到末尾，数据类型也一样，只不过不能是单个数字。此外，extend() 不会把列表或者元祖视为一个整体，而是把它们包含的元素逐个添加到列表中。
l = [‘Python’, ‘C++’, ‘Java’]
#追加元素
l.extend(‘C’)
print(l)
#追加元组，元祖被拆分成多个元素
t = (‘JavaScript’, ‘C#’, ‘Go’)
l.extend(t)
print(l)
#追加列表，列表也被拆分成多个元素
l.extend([‘Ruby’, ‘SQL’])
print(l)
运行结果：
[‘Python’, ‘C++’, ‘Java’, ‘C’]
[‘Python’, ‘C++’, ‘Java’, ‘C’, ‘JavaScript’, ‘C#’, ‘Go’]
[‘Python’, ‘C++’, ‘Java’, ‘C’, ‘JavaScript’, ‘C#’, ‘Go’, ‘Ruby’, ‘SQL’]
Python insert()方法插入元素
相对于以上两种方法，insert方法可以在任意位置添加元素。
格式：listname.insert(index , obj)。其中，index 表示指定位置的索引值。insert() 会将 obj 插入到 listname 列表第 index 个元素的位置。当插入列表或者元祖时，insert() 也会将它们视为一个整体，作为一个元素插入到列表中，这一点和 append() 是一样的。
l = [‘Python’, ‘C++’, ‘Java’]
#插入元素
l.insert(1, ‘C’)
print(l)
#插入元组，整个元祖被当成一个元素
t = (‘C#’, ‘Go’)
l.insert(2, t)
print(l)
#插入列表，整个列表被当成一个元素
l.insert(3, [‘Ruby’, ‘SQL’])
print(l)
#插入字符串，整个字符串被当成一个元素
l.insert(0, “http://c.biancheng.net”)
print(l)
输出结果为：
[‘Python’, ‘C’, ‘C++’, ‘Java’]
[‘Python’, ‘C’, (‘C#’, ‘Go’), ‘C++’, ‘Java’]
[‘Python’, ‘C’, (‘C#’, ‘Go’), [‘Ruby’, ‘SQL’], ‘C++’, ‘Java’]
[‘http://c.biancheng.net’, ‘Python’, ‘C’, (‘C#’, ‘Go’), [‘Ruby’, ‘SQL’], ‘C++’, ‘Java’]
列表删除
主要有以下三种应用场景：
根据目标元素所在位置的索引进行删除，可以使用 del 关键字或者 pop() 方法；
根据元素本身的值进行删除，可使用列表（list类型）提供的 remove() 方法；
将列表中所有元素全部删除，可使用列表（list类型）提供的 clear() 方法。
这里直接举用例子说明：
1.del删除索引单个元素，
lang = [“Python”, “C++”, “Java”, “PHP”, “Ruby”, “MATLAB”]
#使用正数索引
del lang[2]
print(lang)
#使用负数索引
del lang[-2]
print(lang)
运行结果：
[‘Python’, ‘C++’, ‘PHP’, ‘Ruby’, ‘MATLAB’]
[‘Python’, ‘C++’, ‘PHP’, ‘MATLAB’]
2.del删除一段索引值代表元素，
lang = [“Python”, “C++”, “Java”, “PHP”, “Ruby”, “MATLAB”]
del lang[1: 4]
print(lang)
lang.extend([“SQL”, “C#”, “Go”])
del lang[-5: -2]
print(lang)
运行结果：
[‘Python’, ‘Ruby’, ‘MATLAB’]
[‘Python’, ‘C#’, ‘Go’]
pop删除索引代表元素
如果不写 index 参数，默认会删除列表中的最后一个元素，类似于数据结构中的“出栈”操作。
nums = [40, 36, 89, 2, 36, 100, 7]
nums.pop(3)
print(nums)
nums.pop()
print(nums)
运行结果：
[40, 36, 89, 36, 100, 7]
[40, 36, 89, 36, 100]
remove()：根据元素值进行删除
remove() 方法只会删除第一个和指定值相同的元素，而且必须保证该元素是存在的，否则会引发 ValueError 错误。
nums = [40, 36, 89, 2, 36, 100, 7]
#第一次删除36
nums.remove(36)
print(nums)
#第二次删除36
nums.remove(36)
print(nums)
#删除78
nums.remove(78)
print(nums)
运行结果：
[40, 89, 2, 36, 100, 7]
[40, 89, 2, 100, 7]
Traceback (most recent call last):
File “C:\Users\mozhiyan\Desktop\demo.py”, line 9, in
nums.remove(78)
ValueError: list.remove(x): x not in list
clear()：删除列表所有元素
clear即清空操作，删除所有元素剩下一个空列表。
Python list列表修改元素
修改即给元素重新赋值。单个元素就通过索引对元素重新赋值即可。
多个元素可以用切片方法进行操作：
nums = [40, 36, 89, 2, 36, 100, 7]
#修改第 1~4 个元素的值（不包括第4个元素）
nums[1: 4] = [45.25, -77, -52.5]
print(nums)
运行结果：
[40, 45.25, -77, -52.5, 36, 100, 7]
如果对空切片（slice）赋值，就相当于插入一组新的元素：
nums = [40, 36, 89, 2, 36, 100, 7]
#在4个位置插入元素 nums[4: 4] = [-77, -52.5, 999] print(nums)
运行结果： [40, 36, 89, 2, -77, -52.5, 999, 36, 100, 7]
使用切片语法赋值时，Python 不支持单个值，例如下面的写法就是错误的：
nums[4: 4] = -77
但是如果使用字符串赋值，Python 会自动把字符串转换成序列，其中的每个字符都是一个元素，请看下面的代码：
s = list(“Hello”) s[2:4] = “XYZ” print(s)
运行结果： [‘H’, ‘e’, ‘X’, ‘Y’,‘Z’, ‘o’]
使用切片语法时也可以指定步长（step 参数），但这个时候就要求所赋值的新元素的个数与原有元素的个数相同，例如：
nums = [40, 36, 89, 2, 36, 100, 7]
#步长为2，为第1、3、5个元素赋值 nums[1: 6: 2] = [0.025, -99, 20.5] print(nums)
运行结果： [40, 0.025, 89, -99, 36, 20.5, 7]
Python tuple元组详解
元组和列表（list）的不同之处在于：
列表的元素是可以更改的，包括修改元素值，删除和插入元素，所以列表是可变序列；
而元组一旦被创建，它的元素就不可更改了，所以元组是不可变序列。
元组也可以看做是不可变的列表，通常情况下，元组用于保存无需修改的内容。
从形式上看，元组的所有元素都放在一对小括号( )中，相邻元素之间用逗号,分隔。
从存储内容上看，元组可以存储整数、实数、字符串、列表、元组等任何类型的数据，并且在同一个元组中，元素的类型可以不同。
创建元组
1.和创建列表相似，创建元组也是直接用（）赋值创建即可。
在 Python 中，元组通常都是使用一对小括号将所有元素包围起来的，但小括号不是必须的，只要将各元素用逗号隔开，Python 就会将其视为元组。但是，需要注意的一点是，当创建的元组中只有一个字符串类型的元素时，该元素后面必须要加一个逗号,，否则 Python 解释器会将它视为字符串。
2.除了使用( )创建元组外，Python 还提供了一个内置的函数 tuple()，用来将其它数据类型转换为元组类型：tuple(data)。其中data格式可以为：字符串、元组、range 对象等。
#将字符串转换成元组
tup1 = tuple(“hello”)
print(tup1)
#将列表转换成元组
list1 = [‘Python’, ‘Java’, ‘C++’, ‘JavaScript’]
tup2 = tuple(list1)
print(tup2)
#将字典转换成元组
dict1 = {‘a’:100, ‘b’:42, ‘c’:9}
tup3 = tuple(dict1)
print(tup3)
#将区间转换成元组
range1 = range(1, 6)
tup4 = tuple(range1)
print(tup4)
#创建空元组
print(tuple())
运行结果为：
(‘h’, ‘e’, ‘l’, ‘l’, ‘o’)
(‘Python’, ‘Java’, ‘C++’, ‘JavaScript’)
(‘a’, ‘b’, ‘c’)
(1, 2, 3, 4, 5)
()
访问元组数据元素
和列表一样，我们可以使用索引（Index）访问元组中的某个元素（得到的是一个元素的值），也可以使用切片访问元组中的一组元素（得到的是一个新的子元组）。
url = tuple(“http://c.biancheng.net/shell/”)
#使用索引访问元组中的某个元素
print(url[3]) #使用正数索引
print(url[-4]) #使用负数索引
#使用切片访问元组中的一组元素
print(url[9: 18]) #使用正数切片
print(url[9: 18: 3]) #指定步长
print(url[-6: -1]) #使用负数切片
运行结果：
p
e
(‘b’, ‘i’, ‘a’, ‘n’, ‘c’, ‘h’, ‘e’, ‘n’, ‘g’)
(‘b’, ‘n’, ‘e’)
(‘s’, ‘h’, ‘e’, ‘l’, ‘l’)
元组内容无法被修改，所以只能通过重新赋值或者+拼接来修改内容，实际上是重新创建了一个新的元组。之前的元组还是原来的元组。
删除元组
跟列表一样都可以通过del关键字 实现，但是Python 自带垃圾回收功能，会自动销毁不用的元组，所以一般不需要通过 del 来手动删除。
字典类型
Python 字典（dict）是一种无序的、可变的序列，它的元素以“键值对（key-value）”的形式存储。相对地，列表（list）和元组（tuple）都是有序的序列，它们的元素在底层是挨着存放的。
Python 中的字典类型相当于 Java 或者 C++ 中的 Map 对象。
下面直接用例子解释：
用{}方法创建字典：需要注意的是，同一字典中的各个键必须唯一，不能重复。
#使用字符串作为key
scores = {‘数学’: 95, ‘英语’: 92, ‘语文’: 84}
print(scores)
#使用元组和数字作为key
dict1 = {(20, 30): ‘great’, 30: [1,2,3]}
print(dict1)
#创建空元组
dict2 = {}
print(dict2)
运行结果为：
{‘数学’: 95, ‘英语’: 92, ‘语文’: 84}
{(20, 30): ‘great’, 30: [1, 2, 3]}
{}
可以看到，字典的键可以是整数、字符串或者元组，只要符合唯一和不可变的特性就行；字典的值可以是 Python 支持的任意数据类型。
用 fromkeys() 方法创建字典
knowledge = [‘语文’, ‘数学’, ‘英语’]
scores = dict.fromkeys(knowledge, 60)
print(scores)
运行结果为：
{‘语文’: 60, ‘英语’: 60, ‘数学’: 60}
可以看到，knowledge 列表中的元素全部作为了 scores 字典的键，而各个键对应的值都是 60。这种创建方式通常用于初始化字典，设置 value 的默认值。
通过dict函数创造字典
a = dict(str1=value1, str2=value2, str3=value3) str 表示字符串类型的键，value 表示键对应的值。使用此方式创建字典时，字符串不能带引号。
#方式1
demo = [(‘two’,2), (‘one’,1), (‘three’,3)]
#方式2
demo = [[‘two’,2], [‘one’,1], [‘three’,3]]
#方式3
demo = ((‘two’,2), (‘one’,1), (‘three’,3))
#方式4
demo = ([‘two’,2], [‘one’,1], [‘three’,3])
a = dict(demo) 向 dict() 函数传入列表或元组，而它们中的元素又各自是包含 2 个元素的列表或元组，其中第一个元素作为键，第二个元素作为值。
keys = [‘one’, ‘two’, ‘three’] #还可以是字符串或元组
values = [1, 2, 3] #还可以是字符串或元组
a = dict( zip(keys, values) )
通过应用 dict() 函数和 zip() 函数，可将前两个列表转换为对应的字典。
无论采用以上哪种方式创建字典，字典中各元素的键都只能是字符串、元组或数字，不能是列表。列表是可变的，不能作为键。字典也可以创建为空。
访问字典的值，与Java的map类似都是通过key来访问值，但是键值不能为空。否则会报异常：
tup = ([‘two’,26], [‘one’,88], [‘three’,100], [‘four’,-59])
dic = dict(tup)
print(dic[‘one’]) #键存在
print(dic[‘five’]) #键不存在
运行结果：
88
Traceback (most recent call last):
File “C:\Users\mozhiyan\Desktop\demo.py”, line 4, in
print(dic[‘five’]) #键不存在
KeyError: ‘five’
除了上面这种方式外，Python 更推荐使用 dict 类型提供的 get() 方法来获取指定键对应的值。当指定的键不存在时，get() 方法不会抛出异常。
a = dict(two=0.65, one=88, three=100, four=-59)
print( a.get(‘one’) )
运行结果：
88
注意，当键不存在时，get() 返回空值 None，如果想明确地提示用户该键不存在，那么可以手动设置 get() 的第二个参数：
a = dict(two=0.65, one=88, three=100, four=-59)
print( a.get(‘five’, ‘该键不存在’) )
运行结果：
该键不存在。
和列表元组一样，字典也可以通过del关键字来删除，python的回收机制也可以不用手动删除。
Python字典添加键值对
为字典添加新的键值对很简单，直接给不存在的 key 赋值即可，具体语法格式如下：
dictname[key] = value
对各个部分的说明：
dictname 表示字典名称。
key 表示新的键。
value 表示新的值，只要是 Python 支持的数据类型都可以。
下面代码演示了在现有字典基础上添加新元素的过程：
a = {‘数学’:95}
print(a)
#添加新键值对
a[‘语文’] = 89 print(a)
#再次添加新键值对
a[‘英语’] = 90 print(a)
运行结果：
{‘数学’: 95}
{‘数学’: 95, ‘语文’: 89}
{‘数学’: 95, ‘语文’: 89, ‘英语’: 90}
修改键值对也是一样的，重新给key对应的value赋值即可。
如果要删除字典中的键值对，还是可以使用 del 语句。例如：
删除键值对可以用del关键字：
a = {‘数学’: 95, ‘语文’: 89, ‘英语’: 90}
del a[‘语文’]
del a[‘数学’]
print(a)
运行结果为：
{‘英语’: 90}
判断是否存在键值对和列表判断一样：
如果要判断字典中是否存在指定键值对，首先应判断字典中是否有对应的键。判断字典是否包含指定键值对的键，可以使用 in 或 not in 运算符
a = {‘数学’: 95, ‘语文’: 89, ‘英语’: 90}
判断 a 中是否包含名为’数学’的key
print(‘数学’ in a) # True
判断 a 是否包含名为’物理’的key
print(‘物理’ in a) # False
运行结果为：
True
False
需要指出的是，对于 dict 而言，in 或 not in 运算符都是基于 key 来判断的。通过 in（或 not in）运算符，我们可以很轻易地判断出现有字典中是否包含某个键，如果存在，由于通过键可以很轻易的获取对应的值，因此很容易就能判断出字典中是否有指定的键值对。
Python dict字典方法
dict有许多常用到的方法，上面创建和访问字典的时候用到了fromkey和get方法，此外还包括
dir(dict)
[‘clear’, ‘copy’, ‘fromkeys’, ‘get’, ‘items’, ‘keys’, ‘pop’, ‘popitem’, ‘setdefault’, ‘update’, ‘values’]
keys()、values() 和 items() 方法
将这三个方法放在一起介绍，是因为它们都用来获取字典中的特定数据：
keys() 方法用于返回字典中的所有键（key）；
values() 方法用于返回字典中所有键对应的值（value）；
items() 用于返回字典中所有的键值对（key-value）。
请看下面的例子：
scores = {‘数学’: 95, ‘语文’: 89, ‘英语’: 90}
print(scores.keys())
print(scores.values()) print(scores.items())
运行结果：
dict_keys([‘数学’,‘语文’, ‘英语’])
dict_values([95, 89, 90])
dict_items([(‘数学’, 95), (‘语文’,89), (‘英语’, 90)])
可以发现，keys()、values() 和 items() 返回值的类型分别为 dict_keys、dict_values 和 dict_items。
需要注意的是，在 Python 2.x 中，上面三个方法的返回值都是列表（list）类型。但在 Python 3.x 中，它们的返回值并不是我们常见的列表或者元组类型，因为 Python 3.x 不希望用户直接操作这几个方法的返回值。
copy() 方法
注意，copy() 方法所遵循的拷贝原理，既有深拷贝，也有浅拷贝。拿拷贝字典 a 为例，copy() 方法只会对最表层的键值对进行深拷贝，也就是说，它会再申请一块内存用来存放 {‘one’: 1, ‘two’: 2, ‘three’: []}；而对于某些列表类型的值来说，此方法对其做的是浅拷贝，也就是说，b 中的 [1,2,3] 的值不是自己独有，而是和 a 共有。
请看下面的例子：
a = {‘one’: 1, ‘two’: 2, ‘three’: [1,2,3]}
b = a.copy()
#向 a 中添加新键值对，由于b已经提前将 a 所有键值对都深拷贝过来，因此 a 添加新键值对，不会影响 b。
a[‘four’]=100
print(a)
print(b)
#由于 b 和 a 共享[1,2,3]（浅拷贝），因此移除 a 中列表中的元素，也会影响 b。
a[‘three’].remove(1)
print(a)
print(b)
运行结果为：
{‘one’: 1, ‘two’: 2, ‘three’: [1, 2, 3], ‘four’: 100}
{‘one’: 1, ‘two’: 2, ‘three’: [1, 2, 3]}
{‘one’: 1, ‘two’: 2, ‘three’: [2, 3],‘four’:100}
{‘one’: 1, ‘two’: 2, ‘three’:[2, 3]}
从运行结果不难看出，对 a 增加新键值对，b 不变；而修改 a 某键值对中列表内的元素，b也会相应改变。
update更新字典
a = {‘one’: 1, ‘two’: 2, ‘three’: 3}
a.update({‘one’:4.5, ‘four’: 9.3})
print(a)
运行结果为：
{‘one’: 4.5, ‘two’: 2, ‘three’: 3, ‘four’: 9.3}
从运行结果可以看出，由于被更新的字典中已包含 key 为“one”的键值对，因此更新时该键值对的 value 将被改写；而被更新的字典中不包含 key 为“four”的键值对，所以更新时会为原字典增加一个新的键值对。
pop和popitem
pop() 和 popitem() 都用来删除字典中的键值对，不同的是，pop() 用来删除指定的键值对，而 popitem() 用来随机删除一个键值对，它们的语法格式如下：
dictname.pop(key)
dictname.popitem()
其中，dictname 表示字典名称，key 表示键。
下面的代码演示了两个函数的用法：
a = {‘数学’: 95, ‘语文’: 89, ‘英语’: 90, ‘化学’: 83, ‘生物’: 98, ‘物理’: 89}
print(a)
a.pop(‘化学’)
print(a)
a.popitem()
print(a)
运行结果：
{‘数学’: 95, ‘语文’: 89, ‘英语’: 90, ‘化学’: 83, ‘生物’: 98, ‘物理’: 89}
{‘数学’: 95, ‘语文’: 89, ‘英语’: 90, ‘生物’: 98, ‘物理’: 89}
{‘数学’: 95, ‘语文’: 89, ‘英语’: 90, ‘生物’: 98}
对 popitem() 的说明
其实，说 popitem() 随机删除字典中的一个键值对是不准确的，虽然字典是一种无须的列表，但键值对在底层也是有存储顺序的，popitem() 总是弹出底层中的最后一个 key-value，这和列表的 pop() 方法类似，都实现了数据结构中“出栈”的操作。
set集合
Python 中的集合，和数学中的集合概念一样，用来保存不重复的元素，即集合中的元素都是唯一的，互不相同。
从形式上看，和字典类似，Python 集合会将所有元素放在一对大括号 {} 中，相邻元素之间用“,”分隔。
从内容上看，同一集合中，只能存储不可变的数据类型，包括整形、浮点型、字符串、元组，无法存储列表、字典、集合这些可变的数据类型，否则 Python 解释器会抛出 TypeError 错误。
并且需要注意的是，数据必须保证是唯一的，因为集合对于每种数据元素，只会保留一份。
太饿了，下午打球没吃饭，我要先回去吃饭睡觉了。。。
