Python 入门 06 —— 序列：列表、元组、字典、集合

一、列表
1、创建列表
方式一，用中括号[]直接定义。例如：x=[1,2,3,4,5,6]

方式二，用list()将元组、字符串、字典、集合range对象等其它可迭代对象转换成列表。例如:
x=list((1,2,3,3,4,5,6))

2、访问
用下标的方法可以访问列表中的每一个元素。Python支持双向索引，即除了常见的用正整数做下标，还可以用负整数做下标，[-1]表示最后一个元素，[-2]表示倒数第二个元素，以些类推。例如：
x=[1,2,3,4,5,6]
print([x[0],x[1],x[-1],x[-2]]) # [1,2,6,5]

3、常用操作
lst.append(x) ———— 将单个元素x添加至列表lst的尾部，返回None
lst.extend(Lst) ———— 列表Lst列表到列表lst的尾部，返回None
lst.insert(ind,x) ———— 在下标ind处插入单个x，原下标为ind的元素及其后的元素依序后移一位，返回None
lst.pop(ind) ———— 删除并返回下标为ind的元素，ind缺省为-1，取缺省删除并返回最后一个元素
lst.remove(x) ———— 将第一个与x相等的元素，其后的元素依序前移一位，返回None
lst.index(x) ———— 返回第一个与x相等的元素的下标，没有与x相等的元素将抛出异常
lst.count(x) ———— 返回与x相等的元素的个数
lst.reverse() ———— 逆序
lst.sort() ———— 排序
lst.copy() ———— 复制
lst.clear() ———— 清空所有元素，保留列表对象（空列表）,返回None

举例：
lst=[1,2,3,4,5,6]

print(lst.append(77),lst) # None [1, 2, 3, 4, 5, 6, 77]

print(lst.extend([8,9,10]),lst) # None [1, 2, 3, 4, 5, 6, 77, 8, 9, 10]

print(lst.insert(3,33),lst) # None [1, 2, 3, 33, 4, 5, 6, 77, 8, 9, 10]

print(lst.pop(5),lst) # 5 [1, 2, 3, 33, 4, 6, 77, 8, 9, 10]

print(lst.remove(33),lst) # None [1, 2, 3, 4, 6, 77, 8, 9, 10]

print(lst.index(8),lst) # 6 [1, 2, 3, 4, 6, 77, 8, 9, 10]

print(lst.count(9),lst) # 1 [1, 2, 3, 4, 6, 77, 8, 9, 10]

print(lst.reverse(),lst) # None [10, 9, 8, 77, 6, 4, 3, 2, 1]

print(lst.sort(),lst) # None [1, 2, 3, 4, 6, 8, 9, 10, 77]

print(exec(‘lst2=lst.copy()’),lst.clear(),lst,lst2) # None None [] [1, 2, 3, 4, 6, 8, 9, 10, 77]

4、切片
切片就是从列表中取出一段小列表。

lst2 = lst[start🔚step]

以上就是从列表lst中的下标为start元素开始(从0开始数，含下标为start元素)，取到下标为end元素为止(不含下标为end元素)，步长为step。start、end、step的缺省值分别为：0、len(lst)、1。例如：

lst=[1,2,3,4,5,6,7,8,9,10]
print(exec(‘lst2 = lst[::]’),lst2) # None [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(exec(‘lst2 = lst[5::]’),lst2) # None [6, 7, 8, 9, 10]
print(exec(‘lst2 = lst[:5:]’),lst2) # None [1, 2, 3, 4, 5]
print(exec(‘lst2 = lst[::3]’),lst2) # None [1, 4, 7, 10]
print(exec(‘lst2 = lst[:len(lst):3]’),len(lst),lst2) # None 10 [1, 4, 7, 10]

二、元组
1、创建元组
方式一，用小括号()直接定义。例如：x=(1,2,3,4,5,6)
如果元组中仅有一个元素，则必须在后面多加一个逗号。例如：
x = (3) # 赋给x的不是元组，而是整数3
x = (3,) # 赋给x的是一个仅一个元素3的元组

方式二，用tuple()将列表等转变成元组。例如:
x=tuple((1,2,3,3,4,5,6))

2、访问
元组支持用下标访问元素，也支持双向索引。例如：
x=(1,2,3,4,5,6)
print([x[0],x[1],x[-1],x[-2]]) # [1,2,6,5]

3、常用操作
元组一旦创建就不可修改，即不可添加、修改、删除元素，也不可以清空和copy。

tpl.index(x) ———— 返回第一个与x相等的元素的下标，没有与x相等的元素将抛出异常
tpl.count(x) ———— 返回与x相等的元素的个数

举例：
tpl=(1,2,3,3,3,3,5,6,7)
print(tpl.index(3)) # 2
print(tpl.count(3)) # 4

4、元组支持切片

三、字典
1、创建元组
方式一，用大括号{}直接定义。例如：
print(exec(“dct={1:61, 2:62, 5:65}”),dct) # None {1: 61, 2: 62, 5: 65}

print(exec(“dct={‘a’:1, ‘b’:2, ‘c’:3, ‘d’:4, ‘e’:5, ‘f’:6}”),dct) # None {‘a’: 1, ‘b’: 2, ‘c’: 3, ‘d’: 4, ‘e’: 5, ‘f’: 6}

方式二，用dict()将zip对象等转变成字典。例如:
print(exec(“dct=dict(zip([‘a’,‘b’,‘c’],[1,2,3]))”),dct) # None {‘a’: 1, ‘b’: 2, ‘c’: 3}

方式三，用赋值的方式创建字典。例如：
print(exec(“dct=dict(a=1,b=2,c=‘three’)”),dct) # None {‘a’: 1, ‘b’: 2, ‘c’: ‘three’}

方式四，用dict.fromkeys(lst)，依据给定的键名列表，建立一个空字典，例如：
print(dict.fromkeys([11, 12,‘ax’, ‘bx’])) # {11: None, 12: None, ‘ax’: None, ‘bx’: None}

2、访问，访问字典一般都是通过以键值为下标访问相应的值。例如：
x={1:61, 2:62, 5:65,‘a’:71, ‘b’:72, ‘c’:73}
print([x[1],x[2],x[5],x[‘a’],x[‘b’]]) # [61, 62, 65, 71, 72]

特别要注意的是，当使用的键值不存在时，会抛出异常“KeyError”。

3、常用操作
dct.copy() ———— 复制
dct.clear() ———— 清空

dct.update(dct2) ———— 将dct2合并到dct中去，合并过程会已有键名则更新、没有键名则添加，返回None
dct.get(k,def) ———— 返回键名为k的元素的值，没有键名为k的元素则返回def(缺省为None)
dct.setdefault(k,v) ———— 如果有键名为k的元素的值，则返回该值(这时v不起任何作用),如果没有键名为k的元素就添加一个键名为k、值为v的新元素，返回v

dct.pop(k) ———— 弹出(删除)键名为k的元素，返回弹出元素的值
dct.popitem() ———— 随机弹出(删除)一个元素，返回弹出元素的键值对，通常是弹出最后一个，但字典是无序序列，所以不能确保每次都是弹出最后一个。

dct.items() ———— 返回由字典所有键值对组成的列表构成的dict_items对象
dct.keys() ———— 返回由字典所有键名组成的列表构成的dict_keys对象
dct.values() ———— 返回由字典所有值组成的列表构成的dict_values对象

举例：
dct={1:61, 2:62, 5:65,‘a’:71}
dct.update({2:88, ‘a’:100, ‘c’:73})

print(dct) # {1: 61, 2: 88, 5: 65, ‘a’: 100, ‘c’: 73}

print(dct.get(‘a’)) # 100
print(dct.get(‘b’,200)) # 200

print(dct.setdefault(1,77),dct) # 61 {1: 61, 2: 88, 5: 65, ‘a’: 100, ‘c’: 73}
print(dct.setdefault(11,99),dct) # 99 {1: 61, 2: 88, 5: 65, ‘a’: 100, ‘c’: 73, 11: 99}

print(dct.popitem(),dct) # (11, 99) {1: 61, 2: 88, 5: 65, ‘a’: 100, ‘c’: 73}
print(dct.pop(5),dct) # 65 {1: 61, 2: 88, ‘a’: 100, ‘c’: 73}

print(list(dct.items())) # [(1, 61), (2, 88), (‘a’, 100), (‘c’, 73)]
print(list(dct.keys())) # [1, 2, ‘a’, ‘c’]
print(list(dct.values())) # [61, 88, 100, 73]

四、集合
1、创建元组
方式一，用大括号{}直接定义，集合中的元素不允许重复，定义时的重复元素在实际生成集合时会被删除。例如：
x = {1,2,3,3,3,‘a’,‘ab’,‘cc’}
print(x) # {‘a’, 1, 2, 3, ‘ab’, ‘cc’}

方式二，用set()函数，将列表、元组、字典等转换为集合，转换过程中，重复的元素会被删除。例如：
print(set([1,2,3,3,3,3,5])) # {1, 2, 3, 5}

print(set((1,2,3,3,3,3,5))) # {1, 2, 3, 5}

print(set({11:61, 22:62, ‘dd’:65, ‘aa’:66})) # {‘aa’, ‘dd’, 11, 22}

2、访问
因为集合是无序的且其中的元素没有键名，无法能用下标来访问集合中的元素，唯一的方法只能是用循环语句来遍历集合中的所有元素。
x = {1,2,3,3,3,‘a’,‘ab’,‘cc’}
for i in x:print(i,end=’ ') # 1 2 3 ab cc a

3、常用操作
s.copy() ———— 复制
s.clear() ———— 清空
s.pop() ———— 随机弹出(删除)集合中的一个元素，返回被弹出的元素
s.remove(x) ———— 删除集合中值为x的元素，x不存在，则抛出异常，返回None
s.discard(x) ———— 删除集合中值为x的元素，x不存在，则忽略该操作，返回None
s.update(s2) ———— 将s2合并到s中去，重复的元素会被删除，返回None

s.isdisjoint(s2) ———— 两个集合有没有相同的元素，没有，返回 True，有，返回 False
s.issubset(s2) ———— s是不是s2的子集(s中的元素s2中都有么)，是，返回 True，不是，返回 False
s.issuperset(s2) ———— s是不是s2的超集(s2中的元素s中都有么)，是，返回 True，不是，返回 False

s.add(x) ———— 添加一个元素x到集合中，返回None

s.union(s2) ———— 将s2合并到s，返回合并后的s

s.intersection(s2) ———— 返回s和s2中的交集(共同的元素)

s.difference(s2) ———— 返回s和s2的差集(s有、s2没有的元素)

s.symmetric_difference(s2) ———— 返回s和s2的对称差集，即在s和s2的并集中，去除s和s2中都有元素，比普通的差集多了s没有、s2有的元素。在这一操作中s与s2互换，结果一样，所以是对称的。

s.intersection_update(s2) ———— 在s中去除s2中没有的元素，只留下s2中也有的元素。也就是说，更新后的s变成了s和s2的交集

s.difference_update(s2) ———— 在s中去除s2中也有的元素。也就是说，更新后的s变成了s和s2的差集

s.symmetric_difference_update(s2) ———— 在s中去除s2中也有的元素，并把s2有、s中没有的元素也添加到s中。也就是说，更新后的s变成了s和s2的对称差集

举例：
s = {1,2,3,5,6,8,9,‘a’,‘ab’,‘cc’}
s2 = {30,50,60}
s3 = {3,5,30,50,60}

print(s.isdisjoint(s2),s,s2) # True {1, 2, 3, 5, 6, ‘ab’, 8, 9, ‘a’, ‘cc’} {50, 60, 30}
print(s.isdisjoint(s3),s3) # False {3, 5, 50, 60, 30}

print(s3.issubset(s),s3) # False {3, 5, 50, 60, 30}
print(s.issuperset(s3),s3) # False {3, 5, 50, 60, 30}

s4 = {3,5,6}
print(s4.issubset(s),s4) # True {3, 5, 6}
print(s.issuperset(s4),s4) # True {3, 5, 6}

s5 = {5,6,7,‘ab’,‘dd’}
print(s.add(88),s) # None {‘a’, 1, 2, 3, ‘cc’, 5, 6, 8, 9, 88, ‘ab’}

print(s.union(s5),s5) # {1,2,3,‘cc’,5,6,7,8,9,‘dd’,‘ab’,‘a’,88} {5,6,7,‘dd’,‘ab’}
print(s.intersection(s5),s5) # {‘ab’, 5, 6} {5, 6, 7, ‘dd’, ‘ab’}

print(s.difference(s5),s5) # {‘a’,1,2,3,‘cc’,8,9,88} {5,6,7,‘dd’,‘ab’}
print(s.symmetric_difference(s5),s5) # {1,2,3,7,8,9,‘dd’,‘cc’,88,‘a’} {5,6,7,‘dd’,‘ab’}

s1=s.copy()
s11=s.copy()
print(s.intersection_update(s5),s,s5) # None {5, 6, ‘ab’} {5, 6, 7, ‘dd’, ‘ab’}
print(s1.difference_update(s5),s1,s5) # None {1,2,3,8,9,‘a’,88,‘cc’} {5,6,7,‘dd’,‘ab’}
print(s11.symmetric_difference_update(s5),s11,s5) # None {1,2,3,7,8,9,‘a’,‘dd’,88,‘cc’} {5,6,7,‘dd’,‘ab’}

———————————————— 本篇完 ————————————————

看完之后，麻烦您顺手点击下方 “点赞” 两个字给我点个赞吧 ^-^ ， 谢谢您了。

如果您还能像我小学一年级班主任好老师那样，给我随心写上几句表扬或批评的话语，那真是感激不尽！

在我人生的道路上，有了您的鼓励和指导，我一定成长快快。