5.组合数据类型

序列

序列类型的基本操作

列表

• 有序，长度可变，元素可为多种数据类型。
• 是可变数据类型

创建列表

列表的常⽤操作

列表的作⽤是⼀次性存储多个数据，程序员可以对这些数据进⾏的操作有：增、删、改、查。

查找

根据下标查找

name_list = ['张三', '李四', '王五','赵六']
print(name_list[0])
print(name_list[1])
print(name_list[2])

---

函数

• index()：返回指定数据所在位置的下标 。

语法

# 列表序列.index(数据, 开始位置下标, 结束位置下标)
name_list = ['张三', '李四', '王五','赵六']
print(name_list.index('张三', 0, 2))

注意：如果查找的数据不存在则报错。

• count()：统计指定数据在当前列表中出现的次数。

name_list = ['张三', '李四', '王五','张三']
print(name_list.count('张三'))

• len()：访问列表⻓度，即列表中数据的个数。

name_list = ['张三', '李四', '王五','赵六']
print(name_list.count('Tom'))

---

in与not in

in：判断指定数据在某个列表序列，如果在返回True，否则返回False

not in：判断指定数据不在某个列表序列，如果不在返回True，否则返回False

name_list = ['张三', '李四', '王五','赵六']
name = input('请输⼊您要搜索的名字：')
if name in name_list:
    print(f'您输⼊的名字是{name}, 名字已经存在')
else:
    print(f'您输⼊的名字是{name}, 名字不存在')

---

增加

作⽤：增加指定数据到列表中。

函数

• append()：

列表结尾追加数据。

语法

# 列表序列.append(数据)
name_list = ['张三', '李四', '王五','赵六']
name_list.append('阿坤')
print(name_list)

如果append()追加的数据是⼀个序列，则将整个序列作为一个元素加入到列表

name_list = ['张三', '李四', '王五','赵六']
alist = ["唱","跳","rap","篮球"]
name_list.append(alist)
print(name_list)
# ['张三', '李四', '王五', '赵六', ['唱', '跳', 'rap', '篮球']]

• extend():

列表结尾追加数据，如果数据是⼀个序列，则将这个序列的数据逐⼀添加到列表。

name_list = ['张三', '李四', '王五','赵六']
name_list.extend('阿坤')
print(name_list)
# ['张三', '李四', '王五', '赵六', '阿', '坤']

如果添加一个序列，则会将序列里面每一个元素添加进去

name_list = ['张三', '李四', '王五','赵六']
alist = ["唱","跳","rap","篮球"]
name_list.extend(alist)
print(name_list)

• insert()：

指定位置新增数据。

语法

# 列表序列.insert(位置下标, 数据)
name_list = ['张三', '李四', '王五','赵六']
name_list.insert(1, '阿坤')
# 结果：['张三','阿坤', '李四', '王五','赵六']
print(name_list)

---

删除

删除列表当中的数据

• del

删除整个列表

name_list = ['张三', '李四', '王五','赵六']
del name_list
print(name_list)

删除指定数据（根据索引删除）

name_list = ['张三', '李四', '王五','赵六']
del name_list[1]
print(name_list)
# ['张三', '王五', '赵六']

• pop()：

删除指定下标的数据(默认为最后⼀个)，并返回该数据。

name_list = ['张三', '李四', '王五','赵六']
name_list.pop(1)
print(name_list)
# ['张三', '王五', '赵六']

• remove()：

移除列表中某个数据的第⼀个匹配项。

# 列表序列.remove(数据)
name_list = ['张三', '李四', '王五','赵六']
name_list.remove("张三")
print(name_list)
# ['李四', '王五', '赵六']

• clear()：

清空列表

name_list = ['张三', '李四', '王五','赵六']
name_list.clear()
print(name_list)
# []

修改

修改指定下标数据

直接修改

name_list = ['张三', '李四', '王五','赵六']
name_list[0] = '阿坤'
print(name_list)

• reverse()

逆置

num_list = [1, 5, 2, 3, 6, 8]
num_list.reverse()
print(num_list)
# [8, 6, 3, 2, 5, 1]

排序

---

复制

• copy()
  复制一个新列表，返回给调用者，复制过程为浅拷贝
  

name_list = ['张三', '李四', '王五','赵六']
name_li2 = name_list.copy()
print(name_li2)
# ['张三', '李四', '王五','赵六']

其他一些操作

• 切片操作

a = list( (1,2,3,4,5) )
a[0:4:2]=[1 3]
a[-3:1]=[]
a[-3:3]=[3]
a[-1:-6:-1]=[5,4,3,2,1]

• 连接操作

[1,2,3]+[4,5]为[1,2,3,4,5]

• 重复操作

3*[1,2]和[1,2]*3一样，结果为[1,2,1,2,1,2]

• 比较操作
  列表可通过关系运算符进行比较，比较过程类似字符串比较
  返回布尔类型

• 布尔操作
  

• 拆封操作（元组也支持）
  

• 列表解析
  

• 当有多个for循环时，前方的为外层循环

列表的循环遍历

依次打印列表中的各个数据

for循环

name_list = ['张三', '李四', '王五','赵六']
for i in name_list:
    print(i)

while循环

i = 0
name_list = ['Tom', 'Lily', 'Rose']
while i < len(name_list):
    print(name_list[i])
    i += 1

列表的嵌套

所谓列表嵌套指的就是⼀个列表⾥⾯包含了其他的⼦列表

# 找到篮球
name_list = [['张三', '李四', '阿坤'], ['唱', '跳', '篮球'], ['甲', '乙', '丙']]
# 第⼀步：按下标查找到篮球所在的列表
print(name_list[1])
# 第⼆步：从李四所在的列表⾥⾯，再按下标找到数据李四
print(name_list[1][2])

---

元组

0个或多个数据的有序序列，与列表类似，但它是不可变数据类型

定义元组

定义元组使⽤⼩括号，且逗号隔开各个数据，数据可以是不同的数据类型。

# 多个数据元组
t1 = (10, 20, 30)

# 单个数据元组
t2 = (10,)

注意：如果定义的元组只有⼀个数据，那么这个数据后⾯也要添加逗号，否则数据类型为唯⼀的这个数据的数据类型

元组的常⻅操作

元组数据不⽀持修改，只⽀持查找，具体如下

• 根据下标查找

tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1[0])

• index()：

查找某个数据，如果数据存在返回对应的下标，否则报错，语法和列表、字符串的index⽅法相同。

tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1.index('aa'))

• count()：

统计某个数据在当前元组出现的次数。

tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1.count('bb'))

• len()：

统计元组中数据的个数。

tuple1 = ('aa', 'bb', 'cc', 'bb')
print(len(tuple1))

元组内的直接数据如果修改则⽴即报错

但是如果元组⾥⾯有列表，修改列表⾥⾯的数据则是⽀持的。

tuple2 = (10, 20, ['aa', 'bb', 'cc'], 50, 30)
print(tuple2[2]) # 访问到列表
# ['aa', 'bb', 'cc']
tuple2[2][0] = 'aaaaa'
print(tuple2)
# (10, 20, ['aaaaa', 'bb', 'cc'], 50, 30)

• 其他操作

• 元组列表可相互转换
  

• 切片操作，连接操作，重复操作（同列表）

• 求极值max(list3),min(list3)

集合

创建集合

创建集合使⽤ {} 或 set() ， 但是如果要创建空集合只能使⽤ set() ，因为 {} ⽤来创建空字典。

集合的各数据项必须为可哈希对象，且不可重复。分为可变集合和不可变集合两种。

s1 = {10, 20, 30, 40, 50}
print(s1)

s2 = {10, 30, 20, 10, 30, 40, 30, 50}
print(s2)

s3 = set('abcdefg')
print(s3)

s4 = set()
print(type(s4)) # set

s5 = {}
print(type(s5)) # dict

• 集合可以去掉重复数据；
• 集合数据是⽆序的，故不⽀持下标
• 集合可以列表、元组之间进行转换list(), set(), tuple()

集合常⻅操作⽅法

增加数据

• add()

s1 = {10, 20}
s1.add(100)
s1.add(10)
print(s1)

因为集合有去重功能，所以，当向集合内追加的数据是当前集合已有数据的话，则不进⾏任何操作

• update()

追加的数据是序列。

s1 = {10, 20}
# s1.update(100) # 报错
s1.update([100, 200])
s1.update('abc')
print(s1)

删除数据

• remove()

删除集合中的指定数据，如果数据不存在则报错。

s1 = {10, 20}
s1.remove(10)
print(s1)

s1.remove(10) # 报错
print(s1)

• discard()

删除集合中的指定数据，如果数据不存在也不会报错。

s1 = {10, 20}
s1.discard(10)
print(s1)

s1.discard(10)
print(s1)

• pop()

随机删除集合中的一个数据，并返回这个数据。

s1 = {10, 20, 30, 40, 50}
del_num = s1.pop()
print(del_num)
print(s1)

查找数据

in：判断数据在集合序列
not in：判断数据不在集合序列

---

集合运算

其他一些操作

字典

字典是一种映射类型，每项数据为键-值对，键不可重复，且必须是可hash对象，对值无要求。
字典⾥⾯的数据是以键值对形式出现，字典数据和数据顺序没有关系，即字典不⽀持下标，后期⽆论数据如何变化，只需要按照对应的键的名字查找数据即可。

姓名：张三，年龄：22，性别：男
姓名：李四，年龄：21，性别：男
姓名：王五，年龄：24，性别：男
姓名：阿坤，年龄：25，性别：男

创建字典

• 符号为⼤括号
• 数据为键值对形式出现
• 各个键值对之间⽤逗号隔开

# 有数据字典
dict1 = {'name': '张三', 'age': 20, 'gender': '男'}
#用列表对象产生字典
dict4 = dict([(1,'John'),(2,'Hello')])
# 空字典
dict2 = {}
dict3 = dict()

注意：⼀般称冒号前⾯的为键(key)，简称k；冒号后⾯的为值(value)，简称v。

字典常⻅操作

增加数据

写法：字典序列[key] = 值

注意：如果key存在则修改这个key对应的值；如果key不存在则新增此键值对。

dict1 = {'name': '张三', 'age': 20, 'gender': '男'}
dict1['name'] = '李四'
print(dict1)
# 结果：{'name': '李四', 'age': 20, 'gender': '男'}

dict1['id'] = 110
print(dict1)
# {'name': '李四', 'age': 20, 'gender': '男', 'id': 110}

注意：字典为可变类型。

删除数据

• del() / del：

删除字典或删除字典中指定键值对

dict1 = {'name': '张三', 'age': 20, 'gender': '男'}
del dict1['gender']
print(dict1)
# {'name': '张三', 'age': 20}

del(dict1)
print(dict1)
# NameError: name 'dict1' is not defined

• clear()

清空字典

dict1 = {'name': '张三', 'age': 20, 'gender': '男'}
dict1.clear()
print(dict1) # {}

修改数据

写法：字典序列[key] = 值

注意：如果key存在则修改这个key对应的值 ；如果key不存在则新增此键值对。

dict1 = {'name': '张三', 'age': 20, 'gender': '男'}
dict1['name'] = '李四'
print(dict1)
# 结果：{'name': '李四', 'age': 20, 'gender': '男'}

查找数据

key根据键查找值，键不存在则报错

dict1 = {'name': '张三', 'age': 20, 'gender': '男'}
print(dict1['name']) # 张三
print(dict1['id']) # 报错

• get()

# 字典序列.get(key, 默认值)
dict1 = {'name': '张三', 'age': 20, 'gender': '男'}
print(dict1.get('name')) # 张三
print(dict1.get('id', 110)) # 110
print(dict1.get('id')) # None

• 更多
  

• keys()

查找所有的键

dict1 = {'name': '张三', 'age': 20, 'gender': '男'}
print(dict1.keys()) # dict_keys(['name', 'age', 'gender'])

• values()

查找所有的值

dict1 = {'name': '张三', 'age': 20, 'gender': '男'}
print(dict1.values()) # dict_values(['张三', 20, '男'])

• items()

dict1 = {'name': '张三', 'age': 20, 'gender': '男'}
print(dict1.items()) # dict_items([('name', '张三'), ('age', 20), ('gender','男')])

字典内涵

字典的循环遍历

for循环

遍历字典的key

dict1 = {'name': '张三', 'age': 20, 'gender': '男'}
for key in dict1.keys():
    print(key)
# name
# age
# gender

遍历字典的value

dict1 = {'name': '张三', 'age': 20, 'gender': '男'}
for value in dict1.values():
    print(value)
# 张三
# 20
# 男

遍历字典的元素

dict1 = {'name': '张三', 'age': 20, 'gender': '男'}
for value in dict1.items():
    print(value)
    
# ('name', '张三')
# ('age', 20)
# ('gender', '男')

---

python中不存在switch，可通过字典实现多路分支