序列指的是一种能够包含多项数据的数据结构，这些数据项按顺序排列，可以通过索引来访问成员。Python中常见的序列类型为字符串，列表和元组。字符串前面介绍过，列表和元组的区别在于元组是不可变的，元组一旦构建出来，程序就不能修改元组的成员，但是列表是可以改变的，程序可以修改列表所包含的元素。
# 元组
元组的基本用法：
tuple1=(1,2,3,4,5,6)
# 按索引取元素
print(tuple1)
print(tuple1[1],tuple1[-1])
print(tuple1[1::2])
# 错误，不能修改值 tuple1[2]=10
print(tuple1)
# 加法
tuple2=(4,5,6,9,10)
tuple3 = tuple1+tuple2
print(tuple3)
# 乘法
print(tuple1*3)
print(1 in tuple1)
# 得到最大最小与长度
print(max(tuple1))
print(min(tuple1))
print(len(tuple1))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 列表
列表的基本用法：
list1=[1,2,3,4,5,6]
# 按索引取元素
print(list1)
print(list1[1],list1[-1])
print(list1[1::2])
list1[2]=10
print(list1)
# 加法
list2=[4,5,6,9,10]
print(list1+list2)
print(list1+["hi"])
# 乘法
print(list1*3)
print(10 in list1)
# 得到最大最小与长度
print(max(list1))
print(min(list1))
print(len(list1))
# 按一定规则生成列表
[i + 100 for i in range(10)]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 列表增删改查
列表不同于元组的地方是它能修改元素，现在看下这些示例：
# 元组转换成列表
tuple1=(1,2,3)
list1=list(tuple1)
print(list1)
# 列表转换成元组
list2=[4,5,6]
tuple2=tuple(list2)
print(tuple2)
# range转换成列表，元组
range1 = range(1,10,2)
print(type(range1))
print(type(list(range1)))
print(type(tuple(range1)))
# 列表追加元素
list1.append([9,10])
print(list1)
list1.append((11,12))
print(list1)
# 列表扩充元素
list1.extend([11,12])
print(list1)
list1.extend((13,14))
print(list1)
# 列表插入元素
list1.insert(3,15)
print(list1)
list1.insert(3,tuple('test'))
print(list1)
# 删除列表元素
del list1[0]
print(list1)
del list1[1::2]
print(list1)
# del还能删除普通变量
name="test"
# del name
print(name)
# 根据内容删除列表元素
list1.remove(tuple('test'))
print(list1)
#清空列表中的所有元素
list1.clear()
list2.clear()
print(list2)
# 修改列表中的元素
list1 = list(range(0,10))
print(list1)
list1[1:10:2]="hello"
print(list1)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
# 列表常用方法
list1=[1,2,3,5,[1,2],3]
#查看1出现的次数
print(list1.count(1))
print(list1.count([1,2]))
#查看3出现的位置
print(list1.index(3))
print(list1.index(3,3,6))
# 将列表的最后一个元素移出栈
list1.pop()
print(list1)
# 将所有元素顺序反转
list1.reverse()
print(list1)
# 将列表中的元素排序
list1 = list(range(10,1,-1))
print(list1)
list1.sort()
print(list1)
list1=["a","bb","ccc"]
list1.sort(key=len,reverse=True)
print(list1)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 序列封包和序列解包
序列封包：把多个值赋给一个变量时，Python自动将多个值封装成元组。 序列解包：把元组或列表直接赋给多个变量，元组或列表中的各元素会被依次赋值给每个变量。(序列的元素个数应该和变量个数相等)
tuple1 = 1,2,3
print(tuple1)
int1,int2,int3 = tuple1
print(int1)
print(int2)
print(int3)
# 同时封包和解包
var1,var2,var3=10,11,12
print(var1,var2,var3)
var1,var2,var3=var3,var1,var2
print(var1,var2,var3)
tuple2 = tuple(range(1,10,2))
print(tuple2)
tp1,tp2,*tp3 = tuple2
print(tp1,tp2,tp3)
*tp1,tp2,tp3 = tuple2
print(tp1,tp2,tp3)
tp1,*tp2,tp3 = tuple2
print(tp1,tp2,tp3)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 字典
字典可以用来存放有映射关系的数据，它存放都是{key:value}键值对。由于dict要求key必须是不可变类型，所以列表不能作为key，元组可以作为key。
字典的创建示例如下：
dict1={}
dict2={(1,2):100,3:102}
#dict3={[1,2]:100}
dict3 = dict([('name','li1'),('age',22)])
print(dict3)
dict4 = dict([['name','li2'],['age',23]])
print(dict4)
dict5 = dict(name='li3',age=24)
print(dict5)
1
2
3
4
5
6
7
8
9
2
3
4
5
6
7
8
9
使用默认值来创建字典：
dict1=dict.fromkeys(['a','b'])
print(dict1)
dict2=dict.fromkeys(['a','b'],"test")
print(dict2)
dict3=dict.fromkeys(("a","b"),"test2")
print(dict3)
1
2
3
4
5
6
2
3
4
5
6
字典的增删示例如下：
dict1={"math":100,"english":80,"chinese":90}
print(dict1)
del dict1["english"]
dict1["history"]=99
print(dict1)
# in 是只查找key值
print(99 in dict1)
print("math" in dict1)
# 清空字典
dict1.clear()
1
2
3
4
5
6
7
8
9
10
11
12
2
3
4
5
6
7
8
9
10
11
12
字典的常用方法：
dict1={"math":100,"english":80,"chinese":90}
# print(dict1["history"]) 发生错误
print(dict1.get("history"))
# 用一个字典去更新另一个字典，如果键存在则修改值，如果键不存在则添加该键
dict2={"math":98,"history":87}
dict1.update(dict2)
print(dict1)
print(dict1.items())
print(list(dict1.items()))
print(dict1.keys())
print(dict1.values())
# 获取相应字段并删除
print(dict1.pop("chinese"))
print(dict1)
# 弹出最后一个key-value对
k,v=dict1.popitem()
print(k,v)
print(dict1)
# 获取一个key的值，如果没有则设置一个默认值，并返回
print(dict1.setdefault("english",100))
print(dict1)
print(dict1.setdefault("test",101))
print(dict1)
# 拉锁函数
print(list(zip(["a","b","c"],[1,2,3])))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
# 枚举
python中的枚举由类实现的：
from enum import Enum, unique
from multiprocessing.pool import ApplyResult
Fruit = Enum('Fruit', ('Apple', 'Orange', 'Banana'))
for k, v in Fruit.__members__.items():
print(k, v.value)
#@unique
class Fruit2(Enum):
Apple=1
Orange=2
Banana=3
TempFruit = 1 #会被视为Apple的别名
for one in Fruit2:
print(one)
print(Fruit2(1))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
注意：
- 当枚举有值重复的成员，后面的会被认为成前面的别名。取值时只获取第一个成员。
- 如果不希望枚举有重复值，可以用unique来标注。
- 枚举成员不能比较大小。可进行等值比较与同一性比较。
# 练习
a=[1,2,3]
b = 1
c = (b in a)
type(c)
1
2
3
4
2
3
4
上面c的类型是什么？