【Python】DS的基础学习笔记3：组合数据类型

组合数据类型

3.1 列表

3.1.1 列表的表达

• 序列类型：内部元素有位置关系，能通过位置序号访问其中元素
• 列表是一个可以使用多种类型元素，支持元素的增、删、查、改操作的序列类型

ls = ["Python", 1989, True, {"version": 3.7}]
print(ls)

[‘Python’, 1989, True, {‘version’: 3.7}]

• 另一种产生方式：list(可迭代对象)
• 可迭代对象包括：字符串、元组、集合、range()等

字符串转列表

print(list("人工智能是未来的趋势"))

[‘人’, ‘工’, ‘智’, ‘能’, ‘是’, ‘未’, ‘来’, ‘的’, ‘趋’, ‘势’]

元组转列表

print(list(("我", "们", "很", "像")))

[‘我’, ‘们’, ‘很’, ‘像’]

集合转列表

print(list({"李雷", "韩梅梅", "Jim", "Green"}))

[‘韩梅梅’, ‘李雷’, ‘Green’, ‘Jim’]

特殊的range()

for i in range(6):
    print(i)

0
1
2
3
4
5

• range(起始数字,中止数字,数字间隔)

如果起始数字缺省，默认为0
不包含中止数字
如果数字间隔缺省，默认为1

for i in range(1, 11, 2):
    print(i)

1
3
5
7
9

• range()转列表

print(list(range(1, 11, 2)))

[1, 3, 5, 7, 9]

3.1.2 列表的性质

• 列表的长度——len(列表)

ls = [1, 2, 3, 4, 5]
print(len(ls))

5

• 列表的索引——与同为序列类型的字符串完全相同

变量名[位置编号]
正向索引从0开始
反向索引从-1开始

cars = ["BYD", "BMW", "AUDI", "TOYOTA"]
print(cars[0])
print(cars[-1])

BYD
TOYOTA

• 列表的切片

变量名[开始位置:结束位置:切片间隔]

• 正向切片

print(cars[:3])  # 前三个元素，开始位置缺省默认为0，切片间隔缺省默认为1
print(cars[1:4:2])  # 第二个到第四个元素，前后索引差为2
print(cars[:])  # 获取整个列表，结束位置缺省，默认取值到最后
print(cars[-4:-2])  # 获取前两个元素

[‘BYD’, ‘BMW’, ‘AUDI’]
[‘BMW’, ‘TOYOTA’]
[‘BYD’, ‘BMW’, ‘AUDI’, ‘TOYOTA’]
[‘BYD’, ‘BMW’]

• 反向切片

print(cars[:-4:-1])  # 开始位置缺省默认为1
print(cars[::-1])  # 获得反向列表

[‘TOYOTA’, ‘AUDI’, ‘BMW’]
[‘TOYOTA’, ‘AUDI’, ‘BMW’, ‘BYD’]

3.1.3 列表的操作符

• 用list1+list2的形式实现列表的拼接

a = [1, 2]
b = [3, 4]
print(a+b)

[1, 2, 3, 4]

• 用 n*list 或 list*n 实现列表的成倍复制

初始化列表的一种方式

print([0]*10)

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

3.1.4 列表的操作方法

1 增加元素

• 在末尾增加元素

languages = ["Python", "C++", "R"]
languages.append("Java")
print(languages)

[‘Python’, ‘C++’, ‘R’, ‘Java’]

• 在任意位置插入元素——列表.insert(位置编号, 待增元素)
  在位置编号对应元素前插入待增元素

languages.insert(1, "C")
print(languages)

[‘Python’, ‘C’, ‘C++’, ‘R’, ‘Java’]

• 在末尾整体并入另一列表——列表1.extend(列表2)

注意：append是将列表2整体作为一个元素添加到列表1中

languages.append(["Ruby", "PHP"])
print(languages)

[‘Python’, ‘C’, ‘C++’, ‘R’, ‘Java’, [‘Ruby’, ‘PHP’]]

而extend将列表2内元素逐个添加到列表1中

languages.extend(["Ruby", "PHP"])
print(languages)

[‘Python’, ‘C’, ‘C++’, ‘R’, ‘Java’, ‘Ruby’, ‘PHP’]

2 删除元素

• 删除列表i位置元素 列表.pop(位置)

languages = ["Python", "C", "C++", "R", "Java"]
languages.pop(1)
print(languages)

[‘Python’, ‘C++’, ‘R’, ‘Java’]

• 不写位置信息，默认删除最后一个元素

languages.pop()
print(languages)

[‘Python’, ‘C++’, ‘R’]

• 删除列表中第一次出现的待删元素 列表.remove(待删元素)

languages = ["Python", "C", "R", "C", "Java"]
languages.remove("C")
print(languages)

[‘Python’, ‘R’, ‘C’, ‘Java’]

3 查找元素

• 列表中第一次出现待查元素的位置 列表.index(待查元素)

languages = ["Python", "C", "R", "Java"]
index = languages.index("R")
print(index)

2

4 修改元素

• 通过“先索引后赋值”的方式，对元素进行修改 列表名[位置]=新值

languages = ["Python", "C", "R", "Java"]
languages[1] = "C++"
print(languages)

[‘Python’, ‘C++’, ‘R’, ‘Java’]

5 列表的复制

• 错误的方式

languages = ["Python", "C", "R", "Java"]
languages_2 = languages
languages.pop()
print(languages_2)

[‘Python’, ‘C’, ‘R’]

• 正确的方式——浅拷贝
• 方法一：列表.copy()

languages = ["Python", "C", "R", "Java"]
languages_2 = languages.copy()
languages.pop()
print(languages)
print(languages_2)

[‘Python’, ‘C’, ‘R’]
[‘Python’, ‘C’, ‘R’, ‘Java’]

• 方法二：列表[ : ]

languages = ["Python", "C", "R", "Java"]
languages_2 = languages[:]
languages.pop()
print(languages)
print(languages_2)

[‘Python’, ‘C’, ‘R’]
[‘Python’, ‘C’, ‘R’, ‘Java’]

6 列表的排序

• 使用列表.sort()对列表进行永久排序
• 直接在列表上进行操作，无返回值

ls = [2, 5, 2, 8, 19, 3, 7]
ls.sort()
print(ls)

[2, 2, 3, 5, 7, 8, 19]

• 递减排列

ls.sort(reverse=True)
print(ls)

[19, 8, 7, 5, 3, 2, 2]

• 使用sorted(列表)对列表进行临时排序
• 原列表保持不变，返回排序后的列表

ls = [2, 5, 2, 8, 19, 3, 7]
ls_2 = sorted(ls)
print(ls)
print(ls_2)

[2, 5, 2, 8, 19, 3, 7]
[2, 2, 3, 5, 7, 8, 19]

print(sorted(ls, reverse=True))

[19, 8, 7, 5, 3, 2, 2]

7 列表的翻转

• 使用列表.reverse()对列表进行永久翻转
• 直接在列表上进行操作，无返回值

ls = [1, 2, 3, 4, 5]
print(ls[::-1])
ls.reverse()
print(ls)

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

8 使用for循环对列表进行遍历

for i in ls:
    print(i)

5
4
3
2
1

3.2 元组

3.2.1 元组的表达

• 元组是一个可以使用多种类型元素，一旦定义，内部元素不支持增、删和修改操作的序列类型
  通俗地讲，可以将元组视作“不可变地列表”

names = ("Peter", "Pual", "Mary")

3.2.2 元组的操作

• 不支持元素增加、元素删除、元素修改操作
• 其他操作与列表操作完全一致

3.2.3 元组的常见用处

打包与解包

• 例1

def f1(x):  # 返回x的平方和立方
    return x ** 2, x ** 3  # 实现打包返回


print(f1(3))
print(type(f1(3)))  # 元组类型

(9, 27)
<class ‘tuple’>

a, b =f1(3)  # 实现解包赋值
print(a)
print(b)

9
27

• 例2

numbers = [201901, 201902, 201903]
names = ["小明", "小红", "小强"]
print(list(zip(numbers, names)))
for number, name in zip(numbers, names):  # 每次取到一个元组，立刻进行解包赋值
    print(number, name)

[(201901, ‘小明’), (201902, ‘小红’), (201903, ‘小强’)]
201901 小明
201902 小红
201903 小强

3.3 字典

3.3.1 字典的表达

• 映射类型：通过“键”-“值”的映射实现数据存储和查找
• 常规的字典是无序的

students = {201901: "小明", 201902: "小红", 201903: "小强"}
print(students)

{201901: ‘小明’, 201902: ‘小红’, 201903: ‘小强’}

字典键的要求

• 字典的键不能重复

students = {201901: "小明", 201901: "小红", 201903: "小强"}
print(students)  # 前面的键被覆盖

{201901: ‘小红’, 201903: ‘小强’}

• 字典的键必须是不可变类型，如果键可变，就找不到对应存储的值了
• 不可变类型：数字、字符串、元组。一旦确定，它自己就是它自己，变了就不是它了。
• 可变类型：列表、字典、集合。一旦确定，还可以随意增删改。

d = {[1, 2]: 3}

d = {[1, 2]: 3}
TypeError: unhashable type: ‘list’

3.3.2 字典的性质

• 字典的长度——键值对的个数

students = {201901: "小明", 201902: "小红", 201903: "小强"}
print(len(students))

3

• 字典的索引
  通过 字典[键] 的形式来获取对应的值

students = {201901: "小明", 201902: "小红", 201903: "小强"}
print(students[201902])

小红

3.3.3 字典的操作方法

1 增加键值对

• 变量名[新建] = 新值

students = {201901: "小明", 201902: "小红", 201903: "小强"}
students[201904] = "小雪"
print(students)

{201901: ‘小明’, 201902: ‘小红’, 201903: ‘小强’, 201904: ‘小雪’}

2 删除键值对

• 通过del 变量名[待删除键]

students = {201901: "小明", 201902: "小红", 201903: "小强"}
del students[201903]
print(students)

{201901: ‘小明’, 201902: ‘小红’}

• 通过变量名.pop(待删除键)

students = {201901: "小明", 201902: "小红", 201903: "小强"}
value = students.pop(201903)  # 删除键值对，同时获得删除键值对的值
print(value)
print(students)

小强
{201901: ‘小明’, 201902: ‘小红’}

• 变量名.popitem() 随机删除一个键值对，并以元组返回删除键值对

students = {201901: "小明", 201902: "小红", 201903: "小强"}
key, value = students.popitem()
print(key, value)
print(students)

201903 小强
{201901: ‘小明’, 201902: ‘小红’}

3 修改值

• 通过先索引后赋值的方式对相应的值进行修改

students = {201901: "小明", 201902: "小红", 201903: "小强"}
students[201902] = "小雪"
print(students)

{201901: ‘小明’, 201902: ‘小雪’, 201903: ‘小强’}

4 d.get()方法

d.get(key, default) 从字典d中获取键key对应的值，如果没有那个键，则返回default

• 小例子：统计“牛奶奶找刘奶奶买牛奶”中字符的出现频率

s = "牛奶奶找刘奶奶买牛奶"
d = {}
for i in s:
    d[i] = d.get(i, 0) + 1
print(d)

{‘牛’: 2, ‘奶’: 5, ‘找’: 1, ‘刘’: 1, ‘买’: 1}

5 d.key() d.values()方法

students = {201901: "小明", 201902: "小红", 201903: "小强"}
print(list(students.keys()))
print(list(students.values()))

[201901, 201902, 201903]
[‘小明’, ‘小红’, ‘小强’]

6 d.items()方法及字典的遍历

students = {201901: "小明", 201902: "小红", 201903: "小强"}
print(list(students.items()))
for k, v in students.items():
    print(k, v)

[(201901, ‘小明’), (201902, ‘小红’), (201903, ‘小强’)]
201901 小明
201902 小红
201903 小强

3.4 集合

3.4.1 集合的表达

• 一系列互不相等元素的无序集合
• 元素必须是不可变类型：数字、字符串或元组，可视作字典的键
• 可以看作没有值，或者值为None的字典

students = {"小明", "小红", "小强", "小明"}  # 可用于去重
print(students)

{‘小强’, ‘小明’, ‘小红’}

3.4.2 集合的运算

• 小例子 通过集合进行交集并集的计算

Chinese_A = {"刘德华", "张学友", "张曼玉", "钟楚红", "古天乐", "林青霞"}
print(Chinese_A)
Math_A = {"林青霞", "郭富城", "王祖贤", "刘德华", "张曼玉", "黎明"}
print(Math_A)

{‘古天乐’, ‘张曼玉’, ‘刘德华’, ‘钟楚红’, ‘张学友’, ‘林青霞’}
{‘张曼玉’, ‘刘德华’, ‘王祖贤’, ‘郭富城’, ‘黎明’, ‘林青霞’}

• 语文和数学两门均为A的学员
• S & T 返回一个新集合，包括同时在集合S和T中的元素

print(Chinese_A & Math_A)

{‘林青霞’, ‘刘德华’, ‘张曼玉’}

• 语文或数学至少一门为A的学员
• S | T 返回一个新集合，包括集合S和T的所有元素

print(Chinese_A | Math_A)

{‘黎明’, ‘刘德华’, ‘张曼玉’, ‘古天乐’, ‘林青霞’, ‘郭富城’, ‘钟楚红’, ‘王祖贤’, ‘张学友’}

• 语文数学只有一门为A的学员
• S ^ T返回一个新集合，包括集合S和T中的非共同元素

print(Chinese_A ^ Math_A)

{‘王祖贤’, ‘钟楚红’, ‘张学友’, ‘黎明’, ‘郭富城’, ‘古天乐’}

• 语文为A，数学不为A的学员
• S - T 返回一个新集合，包括在集合S但不在集合T中的元素

print(Chinese_A - Math_A)

{‘古天乐’, ‘张学友’, ‘钟楚红’}

• 数学为A，语文不为A的学员

print(Math_A - Chinese_A)

{‘黎明’, ‘郭富城’, ‘王祖贤’}

3.4.3 集合的操作方法

• 增加元素——S.add(x)

stars = {"刘德华", "张学友", "张曼玉"}
stars.add("王祖贤")
print(stars)

{‘张曼玉’, ‘王祖贤’, ‘刘德华’, ‘张学友’}

• 移除元素——S.remove(x)

stars.remove("王祖贤")
print(stars)

{‘刘德华’, ‘张学友’, ‘张曼玉’}

• 集合的长度——len(S)

print(len(stars))

3

• 集合的遍历——借助for循环

for star in stars:
    print(star)

张学友
刘德华
张曼玉

以上，便是第三节深入探索内容，包含列表、元组、字典、集合四个部分。
下一节将深入理解控制结构：分支、遍历循环、无限循环。