数据容器入门
为什么学习数据容器？
思考一个问题：如果我想要在程序中，记录5个人的信息，如姓名。改如何做？
一、定义5个变量
name1 = '王太利'
name2 = '肖央'
name3 = '林俊杰'
name4 = '刘德华'
name5 = '张学友'
二、一个变量完成
name_list = [ '王太利', '肖央', '林俊杰', '刘德华', '张学友' ]
print(name_list)
这就是数据容器，一个容器可以容纳多份数据。
数据容器的定义
Python中的数据容器：一种可以容纳多份数据的数据类型，容纳的每一份数据称之为元素；每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。
数据容器根据特点不同，如：
- 是否支持重复元素
- 是否可以修改
- 是否有序，等
分为5类，分别是：
- 列表(list)
- 元组(tuple)
- 字符串(str)
- 集合(set)
- 字典(dict)
总结
什么事容器？
一种可以存储多个元素的Python数据类型。
Python有哪些数据容器？
列表(list)、元组(tuple)、字符串(str)、集合(set)、字典(dict)，它们各有特点，但都满足可容纳多个元素的特性。
数据容器：list(列表)
列表的定义
为什么需要列表？
思考：有一个人的姓名(TOM)怎么在程序中存储？
答：字符串变量。
思考：如果一个班级100为学生，每个人的姓名都要存储，应该如何书写程序？声明100个变量吗？
答：不是，使用列表，列表一次可以存储多个数据。
列表(list)类型，是数据容器的一类。
基本语法
# 字面量
[ 元素1, 元素2, 元素3, 元素4, ... ]
# 定义变量
变量名称 = [ 元素1, 元素2, 元素3, 元素4, ... ]
# 定义空列表
变量名称 = []
变量名称 = list()
列表内的每一个数据，称之为元素：
- 以[]作为标识
- 列表内每一个元素之间用, 逗号隔开
列表的定义方式：
案例演示：使用[]的方式定义列表
name_list = [ 'itcainiao', 'itcast', 'python' ]
print(name_list)
print(type(name_list))
my_list = [ 'itcainiao', 666, True ]
print(my_list)
print(type(my_list))
注意事项：
列表可以一次存储多个数据，且可以为不同的数据类型，支持嵌套。
嵌套列表的定义
my_list = [ [ 1, 2, 3 ], [ 4, 5, 6 ] ]
print(my_list)
print(type(my_list))
总结
列表的定义语法
[ 元素1, 元素2, 元素3, 元素4, ... ]
什么是元素？
数据容器内的每一份数据，都称之为元素。
元素的类型有限制吗？
元素的类型没有任何限制，甚至元素也可以是列表，这样就定义了嵌套列表。
列表的下标索引
列表的下标索引是什么
如何从列表中取出特定位置的数据呢？
可以使用：下标索引
如图，列表中的每一个元素，都有其位置下表索引，从前向后的方向，从0开始，依次递增。
如何通过下表索引取出对应位置的元素
我们只需要按照下表索引，即可取得对应位置的元素。
# 语法，列表[下表索引]
name_list = [ 'Tom', 'Lily', 'Rose' ]
print(name_list[0]) #结果，Tom
print(name_list[1]) #结果，Lily
print(name_list[2]) #结果，Rose
或者，可以反向索引，也就是从后向前，从-1开始，一次递减（-1，-2，-3，……）。
如图，反向，从后向前，下标索引为：-1、-2、-3、-4、-5、-6，依次递减。
# 语法，列表[下表索引]
name_list = [ 'Tom', 'Lily', 'Rose' ]
print(name_list[-3]) #结果，Tom
print(name_list[-2]) #结果，Lily
print(name_list[-1]) #结果，Rose
如果列表是嵌套的列表，同样支持下标索引。
my_list = [['Tom', 'Lily', 'Rose'],[22,33,44]]
print(my_list[0][1])
总结
列表的下标索引是什么？
列表的每一个元素，都有编号称之为下标索引。
从前向后的方向，编号从0开始递增。
从后向前的方向，编号从-1开始递减。
如何通过下标索引取出对应位置的元素呢？
列表[下标]，即可取出。
下标索引的注意事项
要注意下标索引的取值范围，超出范围无法取出元素，并且会报错。
列表的常用操作
列表的常用操作（方法）
列表除了可以：定义、使用下表索引获取值，以外，列表也提供了一系列功能：
- 插入元素
- 删除元素
- 清空列表
- 修改元素
- 统计元素个数
等等功能，这些功能我门都称之为：列表的方法。
列表的查询功能（方法）
方法与函数的格式区别
回忆：函数是一个封装的代码单元，可以提供特定功能。
在Python中，如果将函数定义为class（类）的成员，那么函数会称之为：方法。
示例，函数：
def add(x, y):
return x + y
示例，方法：
class Student:
def add(self, x , y):
return x + y
方法和函数功能一样，有传入参数，有返回值，只是方法的使用格式不同。
函数的使用：num = add(1, 2)
方法的使用：
student = Student()
num = student.add(1, 2)
查找某元素的下标
功能：查找指定元素在列表的下标，如果找不到，报错ValueError。
语法：列表.index(元素)
index就是列表对象（变量）内置的方法（函数）。
my_list = ['itcainiao', 'itcast', 'python']
index = my_list.index('itcainiao')
print(index)
查找某下标的元素
语法：列表[下标]
my_list = ['itcainiao', 'itcast', 'python']
print(my_list[1])
列表的修改功能（方法）
修改特定位置（索引）的元素值
语法：列表[下标] = 值
可以使用如上语法，直接对指定下标（正向、反向下标均可）的值进行：重新赋值（修改）。
# 正向下表索引
my_list = [1, 2, 3, 4, 5]
my_list[1] = 6
print(my_list)
# 反向下表索引
my_list = [1, 2, 3, 4, 5]
my_list[-1] = 7
print(my_list)
插入元素
语法：列表.insert(下标, 元素)，在指定的下标位置，插入指定的元素。
my_list = [1, 2, 3, 4, 5]
my_list.insert(1, 'itcast')
print(my_list)
追加元素方法一
语法：列表.append(元素)，将指定元素，追加到列表的尾部。
my_list = [1, 2, 3, 4, 5]
my_list.append('python')
print(my_list)
my_list = [1, 2, 3, 4, 5]
my_list.append([5, 6, 7, 8, 9])
print(my_list) # 输出结果[1, 2, 3, 4, 5, [5, 6, 7, 8, 9]]
追加元素方法二
语法：列表.extend(其他数据容器)，将其他数据容器的内容取出，依次追加到列表尾部。
my_list = [1, 2, 3]
my_list.extend([4, 5, 6])
print(my_list)
删除元素
语法1：del 列表[下标]
my_list = [1, 2, 3]
del my_list[1]
print(my_list)
语法2：列表.pop(下标)
.pop语法是将列表中的元素取出，可以重新赋值给其他变量使用。
my_list = [1, 2, 3]
receive = my_list.pop(2)
print(my_list)
print(receive)
删除某元素在列表中中的第一个匹配项
语法：列表.remove(元素)
my_list = [1, 2, 3, 1, 2, 3]
my_list.remove(1)
print(my_list)
清空列表内容
语法：列表.clear()
my_list = [1, 2, 3, 1, 2, 3]
my_list.clear()
print(my_list)
统计某元素在列表内的数量
语法：列表.count(元素)
my_list = [1, 2, 3, 1, 3, 3]
count = my_list.count(3)
print(count)
my_list = [1, 2, 3, 1, 3, 3]
print(my_list.count(3))
统计列表内，有多少元素
语法：len(列表)
可以得到一个int数字，表示列表内的元素数量。
my_list = [1, 2, 3, 4, 5]
print(len(my_list))
my_list = [1, 2, 3, 4, 5]
count = len(my_list)
print(count)
列表的方法 - 纵览
编号 | 使用方法 | 作用 |
1 | 列表.append(元素) | 向列表中追加一个元素，追加到列表尾部 |
2 | 列表.extend(容器) | 将数据容器的内容依次取出，追加到列表尾部 |
3 | 列表.insert(下标, 元素) | 在指定下标处，插入指定的元素 |
4 | del 列表[下标] | 删除列表指定下标元素 |
5 | 列表.pop(下标) | 删除列表指定下标元素（取出指定下标元素，可以赋值给指定变量） |
6 | 列表.remove(元素) | 从前向后，删除此元素第一个匹配项 |
7 | 列表.clear() | 清空列表 |
8 | 列表.count(元素) | 统计此元素在列表中出现的次数 |
9 | 列表.index(元素) | 查找指定元素在列表的下标 找不到报错ValueError |
10 | len(列表) | 统计容器内有多少元素 |
列表的特点
列表有如下特点：
- 可以容纳多个元素（上限2**63-1、9223372036854775807个）
- 可以容纳不同类型的元素（混装）
- 数据是有序存储的（有下标序号）
- 允许重复数据存在
- 可以修改（增加或删除元素等）
总结
列表的常见方法
编号 | 使用方法 | 作用 |
1 | 列表.append(元素) | 向列表中追加一个元素，追加到列表尾部 |
2 | 列表.extend(容器) | 将数据容器的内容依次取出，追加到列表尾部 |
3 | 列表.insert(下标, 元素) | 在指定下标处，插入指定的元素 |
4 | del 列表[下标] | 删除列表指定下标元素 |
5 | 列表.pop(下标) | 删除列表指定下标元素（取出指定下标元素，可以赋值给指定变量） |
6 | 列表.remove(元素) | 从前向后，删除此元素第一个匹配项 |
7 | 列表.clear() | 清空列表 |
8 | 列表.count(元素) | 统计此元素在列表中出现的次数 |
9 | 列表.index(元素) | 查找指定元素在列表的下标 找不到报错ValueError |
10 | len(列表) | 统计容器内有多少元素 |
列表有哪些特点
列表有如下特点：
- 可以容纳多个元素（上限2**63-1、9223372036854775807个）
- 可以容纳不同类型的元素（混装）
- 数据是有序存储的（有下标序号）
- 允许重复数据存在
- 可以修改（增加或删除元素等）
练习题 - 常用功能练习
有一个列表，内容是：[21, 25, 21, 23, 22, 20]，记录的是一批学生的年龄。
请通过列表的功能（方法），对其进行
1、定义这个列表，并用变量接收它
2、追加一个数字31，到列表的尾部
3、追加一个新列表[29, 33, 30]，到列表的尾部
4、取出第一个元素（应是：21）
5、取出最后一个元素（应是：30）
6、查找元素31，在列表中的下标位置
"""
练习题-记录学生年龄
"""
# 定义学生年龄列表，并用变量接收
age = [21, 25, 21, 23, 22, 20]
# 追加一个数字31到列表尾部
age.append(31)
print(f"追加一个数字31到列表的尾部：{age}")
# 追加一个新的列表到列表尾部
age.extend([29, 33, 30])
print(f"追加一个新的列表到列表的尾部：{age}")
# 取出第一个元素
num1 = age[0]
print(f"取出第一个元素的方法一：{num1}")
print(f"取出第一个元素的方法二：{age[0]}")
# 取出最后一个数字
num2 = age[-1]
print(f"取出最后一个元素的方法一：{num2}")
print(f"取出最后一个元素的方法二：{age[-1]}")
# 查找31在列表的下标位置
num3 = age.index(31)
print(f"查找31在列表的下标位置方法一：{num3}")
print(f"查找31在列表的下标位置方法二：{age.index(31)}")
list(列表)的遍历
列表的遍历 - while循环
既然数据容器可以存储多个元素，那么，就会有需求从容器内依次取出元素进行操作。
将容器内的元素依次取出进行处理的行为，称之为：遍历、迭代。
如何遍历列表的数据呢？
- 可以使用while循环
如何在循环中取出列表的元素呢？
- 使用列表[下标]的方式取出
循环条件如何控制？
- 定义一个变量表示下标，从0开始
- 循环条件为 下标值 < 列表元素数量
# 定义while循环练习函数
def list_while_func():
"""
使用while循环遍历列表的函数演示
:return: None
"""
# 定义一个列表
my_list = ['cainiao', 'itcat', 66, True]
# 循环控制变量通过下表索引来控制，默认0
# 每一次循环将下表索引变量+1
# 循环条件 下标索引 < 列表的元素数量
# 定义控制变量
index = 0
# while循环遍历列表元素
while index < len(my_list):
element = my_list[index]
print(f"while循环遍历my_list列表的结果是：{element}")
index += 1
list_while_func()
列表遍历 - for循环
除了while循环外，Python中还有另外一种循环形式：for循环。
对比while循环，for循环更加适合对列表等数据容器进行遍历。
语法：
for 临时变量 in 数据容器:
对临时变量进行处理
表示，从容器内，依次取出元素并赋值到临时变量上。
在每一次的循环中，我们可以对临时变量(元素)进行处理。
# 定义for循环练习函数
def list_for_func():
"""
使用for循环遍历列表的函数演示
:return: None
"""
# 定义列表
my_list = [111, "itcainiao", False, 13.14]
# for循环遍历列表元素
for i in my_list:
print(f"while循环遍历my_list列表的结果是：{i}")
list_for_func()
while循环和for循环的对比
while循环和for循环，都是循环语句，但细节不同：
- 在循环控制上：
- while循环可以自定义循环条件，并进行控制
- for循环不可以自定义变量条件，只可以一个个从容器内取出数据
- 在无限循环上：
- while循环可以通过条件控制做到无限循环
- for循环理论上不可以，因为被遍历的容器容量不是无限的
- 在使用场景上：
- while循环适用于任何想要循环的场景
- for循环适用于，遍历数据容器的场景或简单的固定次数循环场景
总结
什么是遍历
将容器内的元素依次取出，并处理，称之为遍历操作。
如何遍历列表的元素
可以使用while或for循环。
for循环的语法
for 临时变量 in 数据容器:
对临时变量进行处理
for循环和while循环对比
- for循环更简单，while更灵活。
- for循环用于从容器内依次取出元素并处理，while循环用以任何需要循环的场景
练习题 - 取出列表内的偶数
定义一个列表，内容是：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
- 遍历列表，取出列表内的偶数，并存入一个新的列表对象中
- 使用while循环和for循环各操作一次
提示：
- 通过if判断来确认偶数
- 通过列表的append方法，来增加元素
"""
取出列表内的偶数
"""
# 定义while循环函数
def list_while_func():
"""
使用while循环遍历列表并取出偶数赋值到新容器中
:return:
"""
# 定义列表
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 定义接收遍历取出的元素列表
user_list = []
# 定义循环变量
index = 0
# while循环遍历列表并将取出偶数增加到user_list列表中
while index < len(my_list):
if my_list[index] % 2 == 0:
user_list.append(my_list[index])
index += 1
print(f"while遍历{my_list}列表，并将取出偶数增加到user_list的结果是：{user_list}")
list_while_func()
# 定义for循环函数
def list_for_func():
"""
使用for循环遍历列表并取出偶数赋值到新容器中
:return:
"""
# 定义数据容器（列表）
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
user_list = []
# for循环遍历列表并将取出偶数增加到user_list列表中
for i in my_list:
if i % 2 == 0:
user_list.append(i)
print(f"for循环遍历{my_list}列表，取出偶数增加到user_list列表的结果是：{user_list}")
list_for_func()
数据容器：tuple(元组)
为什么需要元组
思考：列表是可以修改的。
如果想要传递的信息，不能被篡改，列表就不合适了。
元组同列表一样，都是可以封装多个、不同类型的元素在内。
但最大的不同点在于：
元组一旦定义完成，就不可修改；所以，当我们需要在程序内封装数据，又不希望封装的数据被篡改，那么元组就非常合适了。
定义元组
元组定义：定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型。
# 定义元组字面量
(元素, 元素, ……, 元素)
# 定义元组变量
变量名称 = (元素, 元素, ……, 元素)
# 定义空元组
变量名称 = ()
变量名称 = tuple()
# 定义元组
t1 = (1, "hellp", True)
t2 = ()
t3 = tuple()
print(f"t1的类型是：{type(t1)}，内容是：{t1}")
print(f"t2的类型是：{type(t2)}，内容是：{t2}")
print(f"t3的类型是：{type(t3)}，内容是：{t3}")
注意事项
元组只有一个数据，这个数据后面要添加逗号。
# 定义3个元素的元组
t1 = (1, "hellp", True)
print(f"t1的类型是：{type(t1)}，内容是：{t1}")
# 定义一个元素的元组
t2 = ('hello', )
print(f"t2的类型是：{type(t2)}，内容是：{t2}")
元组的嵌套
# 元组的嵌套
t1 = ((1, 2, 3), (4, 5, 6))
print(f"t1的类型是：{type(t1)}，内容是：{t1}")
# 元组中可以嵌套列表，嵌套的列表中的数据可以修改
t2 = ((1, 2, 3), [4, 5, 6])
print(f"t2的类型是：{type(t2)}，内容是：{t2}")
下标索引取数据
# 下标索引取数据
t1 = ((1, 2, 3), (4, 5, 6))
num = t1[1][1]
print(f"从嵌套元组中取出的数据是：{num}")
元组的相关操作
编号 | 方法 | 作用 |
1 | index() | 查找某个数据，如果数据存在返回对应的下标，否则报错 |
2 | count() | 统计某个数据在当前元组出现的次数 |
3 | len(元组) | 统计元组内的元素个数 |
# 下标索引取数据
t1 = ((1, 2, 3), (4, 5, 6))
num = t1[1][1]
print(f"从嵌套元组中取出的数据是：{num}")
# 根据index()，查找特定元素的第一个匹配项
t1 = (1, "hellp", True, 1, "hellp", True)
print(f"查找元素1在元组中的下标位置是：{t1.index(1)}")
# 根据count()，查找特定元素在元组中出现的次数
t1 = (2, 'hello', True, 2, 'hello', True)
print(f"查找t1元素True在元组中的出现的次数是：{t1.count(True)}")
# len()统计元组中元素的个数
t1 = (2, 'hello', True, 2, 'hello', True)
print(f"统计t1中元素的个数是：{len(t1)}")
元组的遍历
# while循环实现元组遍历
t1 = (1, 2, 3, 'heihei', 'itcainiao', 'itcast', True, False, 'Python')
count = 0
while count < len(t1):
element = t1[count]
print(f"hile循环实现元组遍历的结果是：{element}")
count += 1
# for循环实现元组的遍历
t1 = (1, 2, 3, 'heihei', 'itcainiao', 'itcast', True, False, 'Python')
for i in t1:
print(f"for循环实现元组的遍历的结果是：{i}")
元组的相关操作 - 注意事项
- 不可以修改元组的内容，否则会直接报错
# 尝试修改元组内容
t1 = (1, 2, 3)
t1[1] = 'itcainiao'
执行后报错：
TypeError: 'tuple' object does not support item assignment
- 可以修改元组内的list的内容（修改元素、增加、删除、反转等）
# 尝试修改元组内容
t1 = (1, 2, ['Python', 5, 6])
t1[2][1] = 'itcainiao'
print(f"t1元组中list数据修改后的结果是：{t1}")
元组的特点
经过以上对元组的学习，可以总结元组有如下特点：
- 可以容纳多个数据
- 可以容纳不同类型的数据（混装）
- 数据是有序存储的（下表索引）
- 允许重复数据存在
- 不可以修改（增加或删除元素等）
- 支持for循环
多数特性和list一致，不同点在于不可修改的特性。
总结
元组的定义方式
(元素, 元素, ……, 元素)
元组的操作方法
编号 | 方法 | 作用 |
1 | index() | 查找某个数据，如果数据存在返回对应的下标，否则报错 |
2 | count() | 统计某个数据在当前元组出现的次数 |
3 | len(元组) | 统计元组内的元素个数 |
元组的注意事项
不可以修改内容（可以修改内部list的内部元素）
元组的特点
- 和list基本相同（有序、任意数量元素、允许重复元素、支持不同类型数据），唯一不同在于不可修改。
- 支持for循环
练习题 - 元组的基本操作
定义一个元组，内容是：('周杰伦', 11, ['football', 'music'])，记录的是一个学生的信息（姓名、年龄、爱好）。
请通过元组的功能（方法），对其进行
1、查询其年龄所在的下标位置
2、查询学生的姓名
3、删除学生爱好中的football
4、增加爱好：coding到爱好list内
# 定义元组
age = ('周杰伦', 11, ['football', 'music'])
# 查询其年龄所在的下标位置
print(f"学生年龄对应的下标索引是：{age.index(11)}")
# 查询学生的姓名
print(f"元组中学生的名字是：{age[0]}")
# 删除学生爱好中的football
del age[2][0]
print(f"删除学生爱好中的football后的结果是：{age}")
# 增加爱好：coding到爱好list内
age[2].append('coding')
print(f"增加爱好：coding到爱好list内的结果是：{age}")
数据容器：str(字符串)
再识字符串
尽管字符串看起来并不像：列表、元组那样，一看就是存放了许多数据的容器。
但不可否认的是，字符串同样也是数据容器的一元
字符串是字符的容器，一个字符串可以存放任意数量的字符。
如，字符串："itcain"
字符串的下表（索引）
和其他容器如：列表、元组一样，字符串也可以通过下表进行访问：
- 从前向后，下标从0开始
- 从后向前，下标从-1开始
# 通过下标获取特定位置字符
name = "itcain"
print(f"{name}字符串按从前向后的下标位置找出c元素：{name[2]}。按从后向前的下标位置找出c元素：{name[-4]}")
同元组一样，字符串是一个：无法修改的数据容器。
所以：
- 修改指定下标的字符 （如：字符串[0] = "a"）
- 移除特定下标的字符 （如：del 字符串[0]、字符串.remove()、字符串.pop()等）
- 追加字符等 （如：字符串.append()）
均无法完成。如必须要做，只能得到一个新的字符串，旧的字符串是无法修改。
字符串的常用操作
查找特定字符串的额下标引值
语法：字符串.index(字符串)
my_str = "itcainiao in cainiaojizhongying"
value = my_str.index("in")
print(f"{my_str}中的in其起始下标值是：{value}")
字符串的替换
语法：字符串.replace(字符串1, 字符串2)
功能：将字符串内的全部：字符串1，替换为字符串2
注意：不是修改字符串本身，而是得到了一个新字符串。
my_str = "itcainiao in cainiaojizhongying"
new_my_str = my_str.replace('it', '叮叮噹')
print(f"{my_str}最后的结果是：{new_my_str}")
结果是：
itcainiao in cainiaojizhongying最后的结果是：叮叮噹cainiao in cainiaojizhongying
字符串的分割
语法：字符串.split(分隔字符串)
功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中。
注意：字符串本身不变，而是得到了一个列表对象
name = "itcainiao in cainiaojizhongying 我是 大大的 菜鸟"
name_list = name.split(" ")
print(f"name字符串使用空格分隔符后的结果是：{name_list}")
输出结果是：
name字符串使用空格分隔符后的结果是：['itcainiao', 'in', 'cainiaojizhongying', '我是', '大大的', '菜鸟']
可以看到，字符串按照给定的<空格>进行了分割，变成多个子字符串，并存入一个列表对象中。
字符串的规整操作（去前后空格）
语法：字符串.strip()
my_str = " itcainiao in cainiaojizhongying 我是 大大的 菜鸟 "
print(f"my_str规整前的结果是：{my_str}")
new_my_str = my_str.strip()
print(f"my_str规整后的结果是：{new_my_str}")
字符串的规整操作（去前后指定字符串）
my_str = "123itcainiao in cainiaojizhongying 我是 大大的 菜鸟321"
print(f"my_str规整前的结果是：{my_str}")
new_my_str = my_str.strip('123')
print(f"my_str规整后的结果是：{new_my_str}")
注意，传入的是“123”其实就是：“1”、“2”和“3”都会移除，是按照单个字符。
统计字符串内某字符串的出现次数功能
my_str = "123itcainiao in cainiaojizhongying 我是 大大的 菜鸟321"
count = my_str.count('cainiao')
print(f"cainiao在字符串中出现的次数是：{count}")
统计字符串的字符个数
my_str = "123itcainiao in cainiaojizhongying 我是 大大的 菜鸟321"
num = len(my_str)
print(f"my_str字符串的字符个数是：{num}")
字符串常用操作汇总
编号 | 操作 | 说明 |
1 | 字符串[下标] | 根据下表索引取出特定位置字符 |
2 | 字符串.index(字符串) | 查找给定字符串的第一个匹配项的下标 |
3 | 字符串.replace(字符串1, 字符串2) | 将字符串内的全部字符串1，替换为字符串2 不会修改原字符串，而是得到一个新的 |
4 | 字符串.split(字符串) | 按照给定字符串，对字符串进行分隔不会修改原字符串，而是得到一个新的列表 |
5 | 字符串.strip() 字符串.strip(字符串) | 移除首尾的空格和换行符或指定字符串 |
6 | 字符串.count(字符串) | 统计字符串内某字符串的出现次数 |
7 | len(字符串) | 统计字符串的字符个数 |
字符串的遍历
同列表、元组一样，字符串也支持while循环和for循环进行遍历。
my_str = "cainiaojizhongying"
index = 0
while index < len(my_str):
count = my_str[index]
print(f"while遍历字符串的结果是：{count}")
index += 1
my_str = "cainiaojizhongying"
for i in my_str:
print(f"while遍历字符串的结果是：{i}")
字符串的特点
作为数据容器，字符串有如下特点：
- 只可以存储字符串
- 长度任意（取决于内存大小）
- 支持下表索引
- 允许重复字符串存在
- 不可以修改（增加或删除元素等）
- 支持for循环
总结
字符串为什么被称之为数据容器呢？
字符串可以看做是字符串的容器，支持下表索引等特性。
字符串有哪些常用操作方法？
编号 | 操作 | 说明 |
1 | 字符串[下标] | 根据下表索引取出特定位置字符 |
2 | 字符串.index(字符串) | 查找给定字符串的第一个匹配项的下标 |
3 | 字符串.replace(字符串1, 字符串2) | 将字符串内的全部字符串1，替换为字符串2 不会修改原字符串，而是得到一个新的 |
4 | 字符串.split(字符串) | 按照给定字符串，对字符串进行分隔不会修改原字符串，而是得到一个新的列表 |
5 | 字符串.strip() 字符串.strip(字符串) | 移除首尾的空格和换行符或指定字符串 |
6 | 字符串.count(字符串) | 统计字符串内某字符串的出现次数 |
7 | len(字符串) | 统计字符串的字符个数 |
字符串有哪些特点
- 只可以存储字符串
- 长度任意（取决于内存大小）
- 支持下表索引
- 允许重复字符串存在
- 不可以修改（增加或删除元素等）
- 支持for循环
练习题 - 分割字符串
给定一个字符串：“123itcainiao in cainiaojizhongying 我是 大大的 菜鸟321”
- 统计字符串内有多少个“cainiao”字符
- 将字符串内的空格，全部替换为字符：“|”
- 并按照"|"进行字符串分割，得到列表
提示：
- count、replace、split
"""
练习题 - 分割字符串
123itcainiao in cainiaojizhongying 我是 大大的 菜鸟321
"""
# 定义字符串
my_str = "123itcainiao in cainiaojizhongying 我是 大大的 菜鸟321"
# 统计字符串内有多少个“cainiao”字符
count = my_str.count('cainiao')
print(f"my_str字符串中的cainiao字符个数是：{count}")
# 将字符串内的空格，全部替换为字符：“|”
spt = my_str.replace(" ", "|")
print(f"my_str字符串将空格更换为 | 结果是：{spt}")
# 并按照"|"进行字符串分割，得到列表
my_str1 = "123itcainiao|in|cainiaojizhongying|我是|大大的|菜鸟321"
new_my_str = my_str1.split("|")
print(f"按照|进行字符串分割，得到的列表是：{new_my_str}")
数据容器的切片
序列
序列是指：内容连接、有序，可使用下表索引的一类数据容器。
列表、元组、字符串，均可以视为序列。
序列的常用操作 - 切片
序列支持切片，即：列表、元组、字符串，均支持进行切片操作。
切片：从一个序列中，取出一个子序列。
语法：序列[起始下标:结束下标:步长]
表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列：
- 起始下标表示从何处开始，可以留空，留空视作从头开始。
- 结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾。
- 步长表示，依次取出元素的间隔：
- 步长1表示，一个个取元素
- 步长2表示，每次跳过一个元素取
- 步长N表示，每次跳过N - 1个元素取
- 步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）
注意：此操作不会影响序列本身，而是会得到一个新的序列（列表、元组、字符串）。
"""
数据容器-切片练习
"""
# 对list进行切片，从1开始，4结束，步长1
my_list = [1, 2, 3, 4, 5, 6]
result1 = my_list[1:3:]
print(f"result1的切片结果是：{result1}")
# 对tuple进行切片，从头开始，到最后结束，步长1
my_tuple = (1, 2, 3, 4, 5, 6)
result2 = my_tuple[::]
print(f"result2的切片结果是：{result2}")
# 对str进行切片，从头开始，到最后结束，步长2
my_str = "0123456789"
result3 = my_str[::2]
print(f"result3的切片结果是：{result3}")
# 对str进行切片，从头开始，到最后结束，步长-1
my_str = "0123456789"
result4 = my_str[::-1]
print(f"result4的切片结果是：{result4}")
# 对列表进行切片，从3开始，到1结束，步长-1
my_list = [1, 2, 3, 4, 5, 6]
result5 = my_list[3:1:-1]
print(f"result5的切片结果是：{result5}")
# 对元组进行切片，从头开始，到最后结束，步长-2
my_tuple = (1, 2, 3, 4, 5, 6)
result6 = my_tuple[::-2]
print(f"result6的切片结果是：{result6}")
总结
什么是序列
内容连接、有序，可使用下表索引的一类数据容器。
哪些数据容器可以视为序列？
列表、元组、字符串
序列如何做切片
语法：序列[起始下标:结束下标:步长]
表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列：
- 起始下标表示从何处开始，可以留空，留空视作从头开始。
- 结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾。
- 步长表示，依次取出元素的间隔：
- 步长1表示，一个个取元素
- 步长2表示，每次跳过一个元素取
- 步长N表示，每次跳过N - 1个元素取
- 步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）
练习案例 - 序列的切片实践
有字符串："月薪过万, 员序程鸟菜来, nohtyp学"
- 请使用学过的任何方式，得到“菜鸟程序员”
可用方式参考：
- 倒序字符串，切片取出；或切片取出，然后倒序
- split分隔", " replace替换“来”为空，倒序字符串
"""
切片练习题
"月薪过万, 员序程鸟菜来, nohtyp学"
"""
# 定义字符串
my_str = "月薪过万, 员序程鸟菜来, nohtyp学"
# 倒序字符串，切片取出
result1 = my_str[10:5:-1]
print(f"倒序字符串，切片取出的结果是：{result1}")
# 切片取出，然后倒序
result2 = my_str[5:11:][::-1]
print(f"切片取出，然后倒序的结果是：{result2}")
# split分隔", " replace替换“来”为空，倒序字符串
result3 = my_str.split(",")[1].replace("来", "")[::-1]
print(f"split分隔’, ‘ replace替换“来”为空，倒序字符串的结果是：{result3}")
数据容器：set(集合)
为什么使用集合
我们目前接触到了列表、元组、字符串三个数据容器了。基本满足大多数的使用场景。
为何又需要学习新的集合类型呢？
通过特性来分析：
- 列表 可修改、支持重复元素且有序
- 元组、字符串 不可修改、支持重复元素且有序
由上，可以看出列表、元组、字符串存在局限性，就是“支持重复元素且有序“。
如果场景需要对内容做去重处理，列表、元组、字符串就不方便了。而集合，最主要的特点就是不支持元素的重复（自带去重功能）、并且内容无序。
集合的定义
基本语法：
# 定义集合字面量
{元素, 元素, ……, 元素}
# 定义集合变量
变量名称 = {元素, 元素, ……, 元素}
# 定义空集合
变量名称 = set()
和列表、元组、字符串等定义基本相同：
- 列表使用：[]
- 元组使用：()
- 字符串使用：""
- 集合使用：{}
# 定义集合
my_set1 = {"Hello", "world", "itcainiao", "数据容器", "学习Python"}
print(f"my_set1集合的内容是：{my_set1}，类型是：{type(my_set1)}")
输出结果：
my_set1集合的内容是：{'学习Python', 'Hello', '数据容器', 'itcainiao', 'world'}，类型是：
# 定义空集合
my_set2 = set()
print(f"my_set2集合的内容是：{my_set2}，类型是：{type(my_set2)}")
输出结果：
my_set2集合的内容是：set()，类型是：
集合的常用操作 - 修改
首先，因为集合是无序的，所以集合不支持：下表索引访问；但是集合和列表一样，是允许修改的，所以我们来看看集合的修改方法。
添加新元素
语法：集合.add(元素) 将制定元素添加到集合内。
结果：集合本身被修改，添加了新元素。
my_set = {"Hello", "world"}
my_set.add("itcainiao")
print(my_set) # 结果{"Hello", "world", "itcainiao"}
# 添加元素
my_set3 = {"Hello", "world", "itcainiao"}
my_set3.add("数据容器")
print(f"my_set3集合的内容是：{my_set3}")
输出结果：
my_set3集合的内容是：{'itcainiao', '数据容器', 'Hello', 'world'}
移除元素
语法：集合.remove(元素)，将指定元素从集合内移除。
结果：集合本身被修改，移除了元素
my_set = {"Hello", "world", "itcainiao"}
my_set.remove("Hello")
print(my_set) # 结果{"world", "itcainiao"}
# 删除元素
my_set4 = {"Hello", "world", "itcainiao", "数据容器", "学习Python"}
my_set4.remove("学习Python")
print(f"my_set4集合的内容是：{my_set4}")
输出结果：
my_set4集合的内容是：{'Hello', '数据容器', 'itcainiao', 'world'}
从集合中随机取出元素
语法：集合.pop()
功能：从集合中随机取出一个元素。
结果：会得到一个元素的结果。同时集合本身被修改，元素被移除。
# 随机取出一个元素
my_set5 = {"Hello", "world", "itcainiao", "数据容器", "学习Python"}
element = my_set5.pop()
print(f"my_set5集合随机取出一个元素的结果是：{element}")
输出结果：
my_set5集合随机取出一个元素的结果是：学习Python
清空集合
语法：集合.clear()
功能：清空集合
结果：集合本身被清空。
# 清空集合
my_set6 = {"Hello", "world", "itcainiao", "数据容器", "学习Python"}
my_set6.clear()
print(f"my_set6集合清空的结果是：{my_set6}")
输出结果：
my_set6集合清空的结果是：set()
取出2个集合的差集
语法：集合1.difference(集合2)
功能：取出集合1和集合2的差集（集合1有而集合2没有的）
结果：得到一个新集合，集合1和集合2不变。
# 取2个集合的差集
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.difference(set2)
print(f"取出差集后的结果是：{set3}")
print(f"取出差集后，原有set1的结果是：{set1}")
print(f"取出差集后，原有set2的结果是：{set2}")
输出结果：
取出差集后的结果是：{2, 3}
取出差集后，原有set1的结果是：{1, 2, 3}
取出差集后，原有set2的结果是：{1, 5, 6}
消除2个集合的差集
语法：集合1.difference_update(集合2)
功能：对比集合1和集合2，在集合1内，删除和集合2相同的元素
结果：集合1被修改，集合2不变。
# 清除2个集合的差集
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set1.difference_update(set2)
print(f"消除差集后，set1的结果是：{set1}")
print(f"消除差集后，set2的结果是：{set2}")
输出结果：
消除差集后，set1的结果是：{2, 3}
消除差集后，set2的结果是：{1, 5, 6}
2个集合合并
语法：集合1.union(集合2)
功能：将集合1和集合2组合成新集合
结果：得到新集合，集合1和集合2不变
# 2个集合合并成1个
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.union(set2)
print(f"2个集合合并的结果是：{set3}")
print(f"2个集合合并后，原有set1的结果是：{set1}")
print(f"2个集合合并后，原有set2的结果是：{set2}")
输出结果：
2个集合合并的结果是：{1, 2, 3, 5, 6}
2个集合合并后，原有set1的结果是：{1, 2, 3}
2个集合合并后，原有set2的结果是：{1, 5, 6}
统计集合元素数量
语法：len(集合)
功能：统计集合内元素的个数
结果：输出统计集合元素个数的结果。
# 统计集合元素数量
set = {1, 2, 3, 4, 5, 6, 7, 8, 9}
count = len(set)
print(f"集合内元素数量是：{count}")
输出结果：
集合内元素数量是：9
集合的遍历
注意：集合不支持下标索引，不能使用while循环。
可以使用for循环：
# 集合的遍历
set = {1, 2, 3, 4, 5,}
for i in set:
print(f"集合遍历的结果是：{i}")
输出结果：
集合遍历的结果是：1
集合遍历的结果是：2
集合遍历的结果是：3
集合遍历的结果是：4
集合遍历的结果是：5
集合常用功能总结
编号 | 操作 | 说明 |
1 | 集合.add(元素) | 集合内添加一个元素 |
2 | 集合.remove(元素) | 移除集合内指定的元素 |
3 | 集合.pop() | 从集合中随机取出一个元素 |
4 | 集合.clear() | 将集合清空 |
5 | 集合1.difference(集合2) | 得到一个新集合，内含2个集合的差集，原有的2个集合内容不变。 |
6 | 集合1.difference_update(集合2) | 在集合1中，删除集合2中存在的元素，集合1被修改，集合2不变。 |
7 | 集合1.union(集合2) | 得到1个新集合，内含2个集合的全部元素，原有的2个集合内容不变。 |
8 | len(集合) | 得到一个整数，记录了集合的元素数量。 |
集合的特点
经过上述对集合的学习，可以总结出集合有如下特点：
- 可以容纳多个数据
- 可以容纳不同类型的数据（混装）
- 数据是无序存储的（不支持下标索引）
- 不允许重复数据存在
- 可以修改（增加或删除元素等）
- 支持for循环
总结
集合有哪些特点
- 集合内不允许重复元素（去重）
- 集合内元素是无序的（不支持下标索引）
集合的定义方式
{元素, 元素, ……, 元素}
集合的常用操作
编号 | 操作 | 说明 |
1 | 集合.add(元素) | 集合内添加一个元素 |
2 | 集合.remove(元素) | 移除集合内指定的元素 |
3 | 集合.pop() | 从集合中随机取出一个元素 |
4 | 集合.clear() | 将集合清空 |
5 | 集合1.difference(集合2) | 得到一个新集合，内含2个集合的差集，原有的2个集合内容不变。 |
6 | 集合1.difference_update(集合2) | 在集合1中，删除集合2中存在的元素，集合1被修改，集合2不变。 |
7 | 集合1.union(集合2) | 得到1个新集合，内含2个集合的全部元素，原有的2个集合内容不变。 |
8 | len(集合) | 得到一个整数，记录了集合的元素数量。 |
如何遍历集合元素
- 可以使用for循环进行遍历
- 不可以使用while循环，因为不支持下标索引
集合的特点
- 可以容纳多个数据
- 可以容纳不同类型的数据（混装）
- 数据是无序存储的（不支持下标索引）
- 不允许重复数据存在
- 可以修改（增加或删除元素等）
- 支持for循环
练习题 - 信息去重
有如下列表对象：
my_list = ["Hello", "world", "itcainiao", "数据容器", "学习Python", "itcast", "itcast", "Hello", "world", "itcainiao"]
请：
- 定义一个空集合
- 通过for循环遍历列表
- 在for循环中将列表的元素添加到集合
- 最终得到元素去重后的集合对象，并打印输出
"""
信息去重
"""
# 定义集合
my_list = ["Hello", "world", "itcainiao", "数据容器", "学习Python", "itcast", "itcast", "Hello", "world", "itcainiao"]
# 定义空集合
my_set = set()
# for循环遍历列表，并添加到集合中
for i in my_list:
my_set.add(i)
print(f"列表的内容是：{my_list}")
print(f"通过for循环后，得到的集合对象是：{my_set}")
数据容器：dict(字典、映射)
字典的定义
为什么使用字典？
生活中的字典，如新华字典，可以通过【字】就能找到对应的【含义】；所以，我们可以认为，生活中的字典就是记录的一堆：
【字】：【含义】
【字】：【含义】
……
【字】：【含义】
Python中的字典和生活中的字典十分相像：
Key:Value
Key:Value
可以按【Key】找出对应的【Value】
示例
老师有一份名单，记录了学生的姓名和考试总成绩。
姓名 | 成绩 |
王力哄 | 77 |
周杰抡 | 88 |
林俊结 | 99 |
现在需要将其通过Python录入至程序中，并可以通过学生姓名检索学生的成绩。
使用字典最为合适：
{ Key Value
"王力哄":77
"周杰抡":88
"林俊结":99
}
可以通过Key（学生姓名），取到对应的Value（考试成绩）；所以，为什么使用字典？因为可以使用字典，实现用Key取出Value的操作。
字典的定义
字典的定义，同样适用{}，不过存储的元素是一个个的健值对，如下语法：
# 定义字典字面量
{key:value, key:value, ……, key:value}
# 定义字典变量
my_dict = {key:value, key:value, ……, key:value}
# 定义空字典
my_dict = {}
my_dict = dict()
# 定义字典字面量
my_dict1 = {"王力哄":77, "周杰抡":88, "林俊结":99}
# 定义空字典
my_dict2 = {}
my_dict3 = dict()
print(f"字典1的内容是：{my_dict1}，类型是：{type(my_dict1)}")
print(f"字典2的内容是：{my_dict2}，类型是：{type(my_dict2)}")
print(f"字典3的内容是：{my_dict3}，类型是：{type(my_dict3)}")
# 定义重复key的字典
my_dict4 = {"王力哄":77, "王力哄":88, "林俊结":99}
print(f"重复key的字典内容是：{my_dict4}")
输出结果：
重复key的字典内容是：{'王力哄': 88, '林俊结': 99}
有重复key的字典，新的key会刷新前面的key。
字典数据的获取
字典同集合一样，不可以使用下标索引，但是字典可以通过key值来取得对应的value。
语法：字典[key]可以取到对应的value
# 通过key取对应的value
my_dict5 = {"王力哄":77, "周杰抡":88, "林俊结":99}
print(my_dict5["王力哄"])
print(my_dict5["周杰抡"])
print(my_dict5["林俊结"])
输出结果：
77
88
99
字典的嵌套
字典的key和value可以是任意数据类型（key不可为字典），那么，就表明，字典是可以嵌套的。
需求如下：记录学生各科的考试信息。
姓名 | 语文 | 数学 | 英语 |
王力哄 | 77 | 66 | 88 |
周杰抡 | 88 | 55 | 77 |
林俊结 | 99 | 44 | 66 |
# 使用字典的嵌套，记录学生各科成绩
stu_score_dict = {
"王力哄":{
"语文":77,
"数学":66,
"英语":88
},
"周杰抡":{
"语文":88,
"数学":55,
"英语":77
},
"林俊结": {
"语文":99,
"数学":44,
"英语":66
}
}
print(f"学生的考试信息：{stu_score_dict}")
# 从嵌套字典中取数据
print(stu_score_dict["周杰抡"]["语文"])
score = stu_score_dict["林俊结"]["英语"]
print(f"林俊结的英语成绩是：{score}")
输出结果是：
学生的考试信息：{'王力哄': {'语文': 77, '数学': 66, '英语': 88}, '周杰抡': {'语文': 88, '数学': 55, '英语': 77}, '林俊结': {'语文': 99, '数学': 44, '英语': 66}}
88
林俊结的英语成绩是：66
总结
为什么使用字典？
字典可以提供基于key检索value的场景实现；就像查字典一样。
字典的定义语法
# 定义字典字面量
{key:value, key:value, ……, key:value}
# 定义字典变量
my_dict = {key:value, key:value, ……, key:value}
# 定义空字典
my_dict = {}
my_dict = dict()
字典的注意事项
- 健值对的Key和Value可以是任意类型（Key不可为字典）
- 字典内Key不允许重复，重复添加等同于覆盖原有数据
- 字典不可用下标索引，而是通过Key检索Value
字典的常用操作
新增元素
语法：字典[Key] = Value
结果：字典被修改，新增了元素
# 定义学生成绩字典
stu_score = {
"王力哄": 77,
"周杰抡": 88,
"林俊结": 99
}
print(f"学生的成绩是：{stu_score}")
# 新增元素
stu_score["张雪友"] = 100
print(f"新增张雪友后stu_score字典的内容是：{stu_score}")
输出结果：
学生的成绩是：{'王力哄': 77, '周杰抡': 88, '林俊结': 99}
新增张雪友后stu_score字典的内容是：{'王力哄': 77, '周杰抡': 88, '林俊结': 99, '张雪友': 100}
更新元素
语法：字典[Key] = Value
结果：字典被修改，元素被更新。
注意：字典Key不可以重复，所以对已存在的Key执行上述操作，就是更新Value值。
# 定义学生成绩字典
stu_score = {
"王力哄": 77,
"周杰抡": 88,
"林俊结": 99
}
print(f"学生的成绩是：{stu_score}")
# 更新元素
stu_score["王力哄"] = 96
print(f"更新王力哄成绩后stu_score字典的内容是：{stu_score}")
输出结果：
学生的成绩是：{'王力哄': 77, '周杰抡': 88, '林俊结': 99}
更新王力哄成绩后stu_score字典的内容是：{'王力哄': 96, '周杰抡': 88, '林俊结': 99, '张雪友': 100}
删除元素
语法：字典.pop(Key)
结果：获得指定Key的Value，同时字典被修改，指定Key的数据被删除。
# 定义学生成绩字典
stu_score = {
"王力哄": 77,
"周杰抡": 88,
"林俊结": 99
}
print(f"学生的成绩是：{stu_score}")
# 删除元素
stu_score.pop("周杰抡")
print(f"字典stu_score删除周杰抡后的结果是：{stu_score}")
输出结果：
学生的成绩是：{'王力哄': 77, '周杰抡': 88, '林俊结': 99}
字典stu_score删除周杰抡后的结果是：{'王力哄': 96, '林俊结': 99, '张雪友': 100}
清空字典
语法：字典.clear()
结果：字典被修改，元素被清空。
# 定义学生成绩字典
stu_score = {
"王力哄": 77,
"周杰抡": 88,
"林俊结": 99
}
print(f"学生的成绩是：{stu_score}")
# 清空字典
stu_score.clear()
print(f"字典stu_score清空后的结果是：{stu_score}")
输出结果：
学生的成绩是：{'王力哄': 77, '周杰抡': 88, '林俊结': 99}
字典stu_score清空后的结果是：{}
获取全部的Key
语法：字典.keys()
结果：得到字典中的全部Key。
# 获取字典中全部的Key
stu_score = {
"王力哄": 77,
"周杰抡": 88,
"林俊结": 99,
"张雪友": 100
}
keys1 = stu_score.keys()
print(f"字典str_score全部的Key是：{keys1}")
输出结果：
字典str_score全部的Key是：dict_keys(['王力哄', '周杰抡', '林俊结', '张雪友'])
遍历字典
使用for循环进行遍历，因为字典中元素是无序的，所以无法使用while循环进行遍历。
方式1：通过获取全部的Key，来完成遍历。
# 通过获取全部的Key，来遍历字典
stu_score = {
"王力哄": 77,
"周杰抡": 88,
"林俊结": 99,
"张雪友": 100
}
keys = stu_score.keys()
for key in keys:
print(f"字典stu_score的Key是：{key}")
print(f"字典stu_score的Value是：{stu_score[key]}")
输出结果：
字典stu_score的Key是：王力哄
字典stu_score的Value是：77
字典stu_score的Key是：周杰抡
字典stu_score的Value是：88
字典stu_score的Key是：林俊结
字典stu_score的Value是：99
字典stu_score的Key是：张雪友
字典stu_score的Value是：100
方式2：直接对字典进行for循环，每一次循环就是直接得到Key。
# 对字典直接进行for循环，每一次循环都是直接得到Key
stu_score = {
"王力哄": 77,
"周杰抡": 88,
"林俊结": 99,
"张雪友": 100
}
for key in stu_score:
print(f"字典stu_score的Key是：{key}")
print(f"字典stu_score的Value是：{stu_score[key]}")
输出结果：
字典stu_score的Key是：王力哄
字典stu_score的Value是：77
字典stu_score的Key是：周杰抡
字典stu_score的Value是：88
字典stu_score的Key是：林俊结
字典stu_score的Value是：99
字典stu_score的Key是：张雪友
字典stu_score的Value是：100
获取字典中元素数量
语法：len(字典)
结果：获得字典元素数量。
# 统计字典中元素的数量
stu_score = {
"王力哄": 77,
"周杰抡": 88,
"林俊结": 99,
"张雪友": 100
}
count = len(stu_score)
print(f"字典stu_score中元素的个数是：{count}")
输出结果：
字典stu_score中元素的个数是：4
字典的常用操作总结
编号 | 操作 | 说明 |
1 | 字典[Key] | 获取指定Key对应的Value值 |
2 | 字典[Key] = Value | 添加或更新健值对 |
3 | 字典.pop(Key) | 取出Key对应的Value并在字典内删除此Key的健值对 |
4 | 字典.clear() | 清空字典 |
5 | 字典.keys() | 获取字典的全部Key，可用于for循环遍历字典 |
6 | len(字典) | 计算字典内的元素数量 |
字典的特点
经过上述对字典的学习，可以总结出字典有如下特点：
- 可以容纳多个数据
- 可以容纳不同类型的数据
- 每一份数据是Key Value健值对
- 可以通过Key获取到Value，Key不可重复（重复会覆盖）
- 不支持下标索引
- 可以修改（增加、删除或更新元素等）
- 支持for循环，不支持while循环
总结
字典的常用操作
编号 | 操作 | 说明 |
1 | 字典[Key] | 获取指定Key对应的Value值 |
2 | 字典[Key] = Value | 添加或更新健值对 |
3 | 字典.pop(Key) | 取出Key对应的Value并在字典内删除此Key的健值对 |
4 | 字典.clear() | 清空字典 |
5 | 字典.keys() | 获取字典的全部Key，可用于for循环遍历字典 |
6 | len(字典) | 计算字典内的元素数量 |
操作注意
新增和更新元素的语法一致，如果Key不存在即新增，如果Key存在即更新（Key不可重复）
字典特点
- 可以容纳多个数据
- 可以容纳不同类型的数据
- 每一份数据是Key Value健值对
- 可以通过Key获取到Value，Key不可重复（重复会覆盖）
- 不支持下标索引
- 可以修改（增加、删除或更新元素等）
- 支持for循环，不支持while循环
练习题 - 升职加薪
有如下员工信息，请使用字典完成数据的记录。
姓名 | 部门 | 工资 | 级别 |
王力哄 | 科技部 | 3000 | 1 |
周杰抡 | 市场部 | 5000 | 2 |
林俊结 | 市场部 | 7000 | 3 |
张雪友 | 科技部 | 4000 | 1 |
刘德花 | 市场部 | 6000 | 2 |
并通过for循环，对所有级别为1级的员工，级别上升1级，薪水增加1000元。
方法1：循环获取满足条件员工信息，定义新字典接受员工信息，升职加薪后再将员工信息更新到原字典中。
"""
某公司对员工进行升级加薪
"""
# 员工信息
personnel_dict = {
"王力哄": {
"部门": "科技部",
"工资": 3000,
"级别": 1
},
"周杰抡": {
"部门": "市场部",
"工资": 5000,
"级别": 2
},
"林俊结": {
"部门": "市场部",
"工资": 7000,
"级别": 3
},
"张雪友": {
"部门": "科技部",
"工资": 4000,
"级别": 1
},
"刘德花": {
"部门": "市场部",
"工资": 6000,
"级别": 2
}
}
print(f"全体员工当前信息：{personnel_dict}")
# 遍历员工，判断是否满足升职加薪，满足的进行升职加薪
for name in personnel_dict:
if personnel_dict[name]["级别"] == 1:
# 获取满足条件员工的信息字典
employee_personnel_dict = personnel_dict[name]
# 对满足条件的员工进行升职加薪
employee_personnel_dict["级别"] += 1
employee_personnel_dict["工资"] += 1000
# 将员工信息更新回personnel_dict
personnel_dict[name] = employee_personnel_dict
print(f"全体员工级别为1的员工升职加薪后的结果是：{personnel_dict}")
输出结果：
全体员工当前信息：{'王力哄': {'部门': '科技部', '工资': 3000, '级别': 1}, '周杰抡': {'部门': '市场部', '工资': 5000, '级别': 2}, '林俊结': {'部门': '市场部', '工资': 7000, '级别': 3}, '张雪友': {'部门': '科技部', '工资': 4000, '级别': 1}, '刘德花': {'部门': '市场部', '工资': 6000, '级别': 2}}
全体员工级别为1的员工升职加薪后的结果是：{'王力哄': {'部门': '科技部', '工资': 4000, '级别': 2}, '周杰抡': {'部门': '市场部', '工资': 5000, '级别': 2}, '林俊结': {'部门': '市场部', '工资': 7000, '级别': 3}, '张雪友': {'部门': '科技部', '工资': 5000, '级别': 2}, '刘德花': {'部门': '市场部', '工资': 6000, '级别': 2}}
方法2：直接对原字典进行修改
"""
某公司对员工进行升级加薪
"""
# 员工信息
personnel_dict = {
"王力哄": {
"部门": "科技部",
"工资": 3000,
"级别": 1
},
"周杰抡": {
"部门": "市场部",
"工资": 5000,
"级别": 2
},
"林俊结": {
"部门": "市场部",
"工资": 7000,
"级别": 3
},
"张雪友": {
"部门": "科技部",
"工资": 4000,
"级别": 1
},
"刘德花": {
"部门": "市场部",
"工资": 6000,
"级别": 2
}
}
print(f"全体员工当前信息：{personnel_dict}")
# 遍历员工，判断是否满足升职加薪，满足的进行升职加薪
for name in personnel_dict:
if personnel_dict[name]["级别"] == 1:
personnel_dict[name]["级别"] += 1
personnel_dict[name]["工资"] += 1000
print(f"全体员工级别为1的员工升职加薪后的结果是：{personnel_dict}")
输出结果：
全体员工当前信息：{'王力哄': {'部门': '科技部', '工资': 3000, '级别': 1}, '周杰抡': {'部门': '市场部', '工资': 5000, '级别': 2}, '林俊结': {'部门': '市场部', '工资': 7000, '级别': 3}, '张雪友': {'部门': '科技部', '工资': 4000, '级别': 1}, '刘德花': {'部门': '市场部', '工资': 6000, '级别': 2}}
全体员工级别为1的员工升职加薪后的结果是：{'王力哄': {'部门': '科技部', '工资': 4000, '级别': 2}, '周杰抡': {'部门': '市场部', '工资': 5000, '级别': 2}, '林俊结': {'部门': '市场部', '工资': 7000, '级别': 3}, '张雪友': {'部门': '科技部', '工资': 5000, '级别': 2}, '刘德花': {'部门': '市场部', '工资': 6000, '级别': 2}}
数据容器的总结对比
数据容器分类
数据容器可以从以下视角进行简单的分类：
- 是否支持下标索引
- 支持（序列类型）：列表、元组、字符串
- 不支持（非序列类型）：集合、字典
- 是否支持重复元素
- 支持（序列类型）：列表、元组、字符串
- 不支持（非序列类型）：集合、字典
- 是否可以修改
- 支持：列表、集合、字典
- 不支持：元组、字符串
数据容器特点对比
列表 | 元组 | 字符串 | 集合 | 字典 | |
元素数量 | 支持多个 | 支持多个 | 支持多个 | 支持多个 | 支持多个 |
元素类型 | 任意 | 任意 | 仅字符 | 任意 | Key: Value Key:除字典外任意类型 Value:任意类型 |
下标索引 | 支持 | 支持 | 支持 | 不支持 | 不支持 |
重复元素 | 支持 | 支持 | 支持 | 不支持 | 不支持 |
可修改性 | 支持 | 不支持 | 不支持 | 支持 | 支持 |
数据有序 | 是 | 是 | 是 | 否 | 否 |
使用场景 | 可修改，可重复的一批数据记录场景 | 不可修改，可重复的一批数据记录场景 | 一串字符的记录场景 | 不可重复的数据记录场景 | 以Key检索Value的数据记录场景 |
总结
基于各类数据容器的特点，它们的应用场景如下：
- 列表：一批数据，可修改，可重复的存储场景
- 元组：一批数据，不可修改，可重复的存储场景
- 字符串：一串字符串的存储场景
- 集合：一批数据，去重存储场景
- 字典：一批数据，可用Key检索Value的存储场景
数据容器的通用操作
数据容器的通用操作 - 遍历
数据容器尽管各自有各自的特点，但是他们也有通用的一些操作。
首先，在遍历上：
- 5类数据容器都支持for循环遍历
- 列表、元组、字符串支持while循环，集合、字典不支持（无法下标索引）
尽管遍历的形式各有不同，但是，它们都支持遍历操作。
数据容器的通用操作 - 统计功能
统计容器的元素个数
语法：len(容器)
# len统计元素数量
my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
my_str = "itcainiao"
my_set = {1, 2, 3, 4, 5}
my_dict = {"key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5}
print(f"列表 元素的个数有：{len(my_list)}")
print(f"元组 元素的个数有：{len(my_tuple)}")
print(f"字符 串元素的个数有：{len(my_str)}")
print(f"集合 元素的个数有：{len(my_set)}")
print(f"字典 元素的个数有：{len(my_dict)}")
输出结果：
列表 元素的个数有：5
元组 元素的个数有：5
字符串 元素的个数有：9
集合 元素的个数有：5
字典 元素的个数有：5
统计容器的最大元素
语法：max(容器)
# max取最大值
my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
my_str = "itcainiao"
my_set = {1, 2, 3, 4, 5}
my_dict = {"key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5}
print(f"列表 最大的元素是：{max(my_list)}")
print(f"元组 最大的元素是：{max(my_tuple)}")
print(f"字符串 最大的元素是：{max(my_str)}")
print(f"集合 最大的元素是：{max(my_set)}")
print(f"字典 最大的元素是：{max(my_dict)}")
输出结果：
列表 最大的元素是：5
元组 最大的元素是：5
字符串 最大的元素是：t
集合 最大的元素是：5
字典 最大的元素是：key5
统计容器的最小元素
语法：min(容器)
# min取最小值
my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
my_str = "itcainiao"
my_set = {1, 2, 3, 4, 5}
my_dict = {"key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5}
print(f"列表 最小的元素是：{min(my_list)}")
print(f"元组 最小的元素是：{min(my_tuple)}")
print(f"字符串 最小的元素是：{min(my_str)}")
print(f"集合 最小的元素是：{min(my_set)}")
print(f"字典 最小的元素是：{min(my_dict)}")
输出结果：
列表 最小的元素是：1
元组 最小的元素是：1
字符串 最小的元素是：a
集合 最小的元素是：1
字典 最小的元素是：key1
容器的通用操作 - 转换功能
将给定容器转换为列表
语法：list(容器)
my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
my_str = "itcainiao"
my_set = {1, 2, 3, 4, 5}
my_dict = {"key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5}
print(f"列表 转换为列表的结果是：{list(my_list)}")
print(f"元组 转换为列表的结果是：{list(my_tuple)}")
print(f"字符串 转换为列表的结果是：{list(my_str)}")
print(f"集合 转换为列表的结果是：{list(my_set)}")
print(f"字典 转换为列表的结果是：{list(my_dict)}")
输出结果：
列表 转换为列表的结果是：[1, 2, 3, 4, 5]
元组 转换为列表的结果是：[1, 2, 3, 4, 5]
字符串 转换为列表的结果是：['i', 't', 'c', 'a', 'i', 'n', 'i', 'a', 'o']
集合 转换为列表的结果是：[1, 2, 3, 4, 5]
字典 转换为列表的结果是：['key1', 'key2', 'key3', 'key4', 'key5']
将给定容器转换为元组
语法：tuple(容器)
# 将给定容器转换为元组
my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
my_str = "itcainiao"
my_set = {1, 2, 3, 4, 5}
my_dict = {"key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5}
print(f"列表 转换为元组的结果是：{tuple(my_list)}")
print(f"元组 转换为元组的结果是：{tuple(my_tuple)}")
print(f"字符串 转换为元组的结果是：{tuple(my_str)}")
print(f"集合 转换为元组的结果是：{tuple(my_set)}")
print(f"字典 转换为元组的结果是：{tuple(my_dict)}")
输出结果：
列表 转换为元组的结果是：(1, 2, 3, 4, 5)
元组 转换为元组的结果是：(1, 2, 3, 4, 5)
字符串 转换为元组的结果是：('i', 't', 'c', 'a', 'i', 'n', 'i', 'a', 'o')
集合 转换为元组的结果是：(1, 2, 3, 4, 5)
字典 转换为元组的结果是：('key1', 'key2', 'key3', 'key4', 'key5')
将给定容器转换为字符串
语法：str(容器)
# 将给定容器转换为字符串
my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
my_str = "itcainiao"
my_set = {1, 2, 3, 4, 5}
my_dict = {"key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5}
print(f"列表 转换为字符串的结果是：{str(my_list)}")
print(f"元组 转换为字符串的结果是：{str(my_tuple)}")
print(f"字符串 转换为字符串的结果是：{str(my_str)}")
print(f"集合 转换为字符串的结果是：{str(my_set)}")
print(f"字典 转换为字符串的结果是：{str(my_dict)}")
输出结果：
列表 转换为字符串的结果是：[1, 2, 3, 4, 5]
元组 转换为字符串的结果是：(1, 2, 3, 4, 5)
字符串 转换为字符串的结果是：itcainiao
集合 转换为字符串的结果是：{1, 2, 3, 4, 5}
字典 转换为字符串的结果是：{'key1': 1, 'key2': 2, 'key3': 3, 'key4': 4, 'key5': 5}
将给定容器转换为集合
语法：set(容器)
# 将给定容器转换为集合
my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
my_str = "itcainiao"
my_set = {1, 2, 3, 4, 5}
my_dict = {"key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5}
print(f"列表 转换为集合的结果是：{set(my_list)}")
print(f"元组 转换为集合的结果是：{set(my_tuple)}")
print(f"字符串 转换为集合的结果是：{set(my_str)}")
print(f"集合 转换为集合的结果是：{set(my_set)}")
print(f"字典 转换为集合的结果是：{set(my_dict)}")
输出结果：
列表 转换为集合的结果是：{1, 2, 3, 4, 5}
元组 转换为集合的结果是：{1, 2, 3, 4, 5}
字符串 转换为集合的结果是：{'i', 'a', 'c', 'n', 'o', 't'}
集合 转换为集合的结果是：{1, 2, 3, 4, 5}
字典 转换为集合的结果是：{'key1', 'key3', 'key2', 'key4', 'key5'}
容器通用排序功能
语法：sorted(容器, [reverse=True])
将给定的容器进行排序。
# 将给定的容器进行排序
my_list = [3, 1, 4, 2, 5]
my_tuple = (5, 3, 1, 2, 4)
my_str = "itcainiao"
my_set = {2, 5, 3, 1, 4}
my_dict = {"key5": 1, "key3": 2, "key2": 3, "key1": 4, "key4": 5}
print(f"列表 排序后的结果是：{sorted(my_list)}")
print(f"元组 排序后的结果是：{sorted(my_tuple)}")
print(f"字符串 排序后的结果是：{sorted(my_str)}")
print(f"集合 排序后的结果是：{sorted(my_set)}")
print(f"字典 排序后的结果是：{sorted(my_dict)}")
输出结果：
列表 排序后的结果是：[1, 2, 3, 4, 5]
元组 排序后的结果是：[1, 2, 3, 4, 5]
字符串 排序后的结果是：['a', 'a', 'c', 'i', 'i', 'i', 'n', 'o', 't']
集合 排序后的结果是：[1, 2, 3, 4, 5]
字典 排序后的结果是：['key1', 'key2', 'key3', 'key4', 'key5']
# 将给定的容器进行降序排序
my_list = [3, 1, 4, 2, 5]
my_tuple = (5, 3, 1, 2, 4)
my_str = "itcainiao"
my_set = {2, 5, 3, 1, 4}
my_dict = {"key5": 1, "key3": 2, "key2": 3, "key1": 4, "key4": 5}
print(f"列表 降序排序后的结果是：{sorted(my_list, reverse=True)}")
print(f"元组 降序排序后的结果是：{sorted(my_tuple, reverse=True)}")
print(f"字符串 降序排序后的结果是：{sorted(my_str, reverse=True)}")
print(f"集合 降序排序后的结果是：{sorted(my_set, reverse=True)}")
print(f"字典 降序排序后的结果是：{sorted(my_dict, reverse=True)}")
输出结果：
列表 降序排序后的结果是：[5, 4, 3, 2, 1]
元组 降序排序后的结果是：[5, 4, 3, 2, 1]
字符串 降序排序后的结果是：['t', 'o', 'n', 'i', 'i', 'i', 'c', 'a', 'a']
集合 降序排序后的结果是：[5, 4, 3, 2, 1]
字典 降序排序后的结果是：['key5', 'key4', 'key3', 'key2', 'key1']
容器通用功能总览
功能 | 描述 |
通用for循环 | 遍历容器（字典是遍历key） |
max() | 容器内最大的元素 |
min() | 容器内最小的元素 |
len() | 容器元素个数 |
list() | 转换为列表 |
tuple() | 转换为元组 |
str() | 转换为字符串 |
set() | 转换为集合 |
sorte(序列, [reverse=True]) | 排序，reverse=True表示降序 得到一个排好序的列表 |
字符串大小比较
ASCII码表
在程序中，字符串所有的所有字符如：
- 大小写英文单词
- 数字
- 特殊符号(!、\、|、@、#、空格等)
都有其对应的ASCII码表值。
每一个字符都能对应上一个：数字的码值。
字符串进行比较就是基于数字的码值大小进行比较的。
ASCII编码即美国信息交换标准代码（American Standard Code for Information Interchange）是一套共有128个字符的编码，它基于阿拉丁字母，主要作用是用来表示英语和西欧语言字符。ASCII规范编码第一次公布于1967年，ascii码在1986年完成最后一次更新。ASCII码对照表等同于国际标准 ISO/IEC 646，ASCII码对照表是世界最通用的信息交换标准。
ASCII控制字符对照表
0 - 31，共32个。ASCII码对照表0~31之间的ASCII码常用于控制像打印机一样的外围设备。
十进制 | 八进制 | 十六进制 | 二进制 | 符号 | HTML实体 | 说明 |
0 | 000 | 00 | 00000000 | NUL | � | 空字符 |
1 | 001 | 01 | 00000001 | SOH | 标题开始 | |
2 | 002 | 02 | 00000010 | STX | 正文开始 | |
3 | 003 | 03 | 00000011 | ETX | 正文结束 | |
4 | 004 | 04 | 00000100 | EOT | 传输结束 | |
5 | 005 | 05 | 00000101 | ENQ | 询问 | |
6 | 006 | 06 | 00000110 | ACK | 收到通知 | |
7 | 007 | 07 | 00000111 | BEL | 铃 | |
8 | 010 | 08 | 00001000 | BS | 退格 | |
9 | 011 | 09 | 00001001 | HT | 水平制表符 | |
10 | 012 | 0A | 00001010 | LF | 换行键 | |
11 | 013 | 0B | 00001011 | VT | 垂直制表符 | |
12 | 014 | 0C | 00001100 | FF | 换页键 | |
13 | 015 | 0D | 00001101 | CR | 回车键 | |
14 | 016 | 0E | 00001110 | SO | 移出 | |
15 | 017 | 0F | 00001111 | SI | 移入 | |
16 | 020 | 10 | 00010000 | DLE | 数据链路转义 | |
17 | 021 | 11 | 00010001 | DC1 | 设备控制 1 | |
18 | 022 | 12 | 00010010 | DC2 | 设备控制 2 | |
19 | 023 | 13 | 00010011 | DC3 | 设备控制 3 | |
20 | 024 | 14 | 00010100 | DC4 | 设备控制 4 | |
21 | 025 | 15 | 00010101 | NAK | 拒绝接收 | |
22 | 026 | 16 | 00010110 | SYN | 同步空闲 | |
23 | 027 | 17 | 00010111 | ETB | 传输块结束 | |
24 | 030 | 18 | 00011000 | CAN | 取消 | |
25 | 031 | 19 | 00011001 | EM | 介质中断 | |
26 | 032 | 1A | 00011010 | SUB | 替换 | |
27 | 033 | 1B | 00011011 | ESC | 换码符 | |
28 | 034 | 1C | 00011100 | FS |
| 文件分隔符 |
29 | 035 | 1D | 00011101 | GS |
| 组分隔符 |
30 | 036 | 1E | 00011110 | RS |
| 记录分离符 |
31 | 037 | 1F | 00011111 | US |
| 单元分隔符 |
ASCII可显示字符对照表
32 - 127，共96个。ASCII码对照表32~127之间的ASCII码表示的符号，在我们的键盘上都可以被找到。其中：32表示空格，127表示删除命令。
十进制 | 八进制 | 十六进制 | 二进制 | 符号 | HTML实体 | 说明 |
128 | 200 | 80 | 10000000 | € | € | 欧盟符号 |
129 | 201 | 81 | 10000001 | |||
130 | 202 | 82 | 10000010 | ‚ | ‚ | 单低 9 引号 |
131 | 203 | 83 | 10000011 | ƒ | ƒ | 带钩的 拉丁小写字母f |
132 | 204 | 84 | 10000100 | „ | „ | 双低 9 引号 |
133 | 205 | 85 | 10000101 | … | … | 水平省略号 |
134 | 206 | 86 | 10000110 | † | † | 剑号 |
135 | 207 | 87 | 10000111 | ‡ | ‡ | 双剑号 |
136 | 210 | 88 | 10001000 | ˆ | ˆ | 修正字符 抑扬音符号 |
137 | 211 | 89 | 10001001 | ‰ | ‰ | 千分号 |
138 | 212 | 8A | 10001010 | Š | Š | 带弯音号的 拉丁大写字母 S |
139 | 213 | 8B | 10001011 | ‹ | ‹ | 左单书名号 |
140 | 214 | 8C | 10001100 | Œ | Œ | 拉丁大写组合 OE |
141 | 215 | 8D | 10001101 | |||
142 | 216 | 8E | 10001110 | Ž | Ž | 带弯音号的 拉丁大写字母 z |
143 | 217 | 8F | 10001111 | |||
144 | 220 | 90 | 10010000 | |||
145 | 221 | 91 | 10010001 | ‘ | ‘ | 左单引号 |
146 | 222 | 92 | 10010010 | ’ | ’ | 右单引号 |
147 | 223 | 93 | 10010011 | “ | “ | 左双引号 |
148 | 224 | 94 | 10010100 | ” | ” | 右双引号 |
149 | 225 | 95 | 10010101 | • | • | |
150 | 226 | 96 | 10010110 | – | – | 半长破折号 |
151 | 227 | 97 | 10010111 | — | — | 全长破折号 |
152 | 230 | 98 | 10011000 | ˜ | ˜ | 小波浪线 |
153 | 231 | 99 | 10011001 | ™ | ™ | |
154 | 232 | 9A | 10011010 | š | š | 带弯音号的 拉丁小写字母 s |
155 | 233 | 9B | 10011011 | › | › | 右单书名号 |
156 | 234 | 9C | 10011100 | œ | œ | 拉丁小写组合 oe |
157 | 235 | 9D | 10011101 | |||
158 | 236 | 9E | 10011110 | ž | ž | 带弯音号的 拉丁小写字母 z |
159 | 237 | 9F | 10011111 | Ÿ | Ÿ | 带弯音号的 拉丁大写字母 Y |
160 | 240 | A0 | 10100000 | |||
161 | 241 | A1 | 10100001 | ¡ | ¡ | 反向感叹号 |
162 | 242 | A2 | 10100010 | ¢ | ¢ | 分币符号 |
163 | 243 | A3 | 10100011 | £ | £ | 英磅符号 |
164 | 244 | A4 | 10100100 | ¤ | ¤ | |
165 | 245 | A5 | 10100101 | ¥ | ¥ | 人民币符号 |
166 | 246 | A6 | 10100110 | ¦ | ¦ | |
167 | 247 | A7 | 10100111 | § | § | 章节符号 |
168 | 250 | A8 | 10101000 | ¨ | ¨ | 通用货币符号 |
169 | 251 | A9 | 10101001 | © | © | 版权符号 |
170 | 252 | AA | 10101010 | ª | ª | 阴性顺序 指示符号 |
171 | 253 | AB | 10101011 | « | « | 左角引号 |
172 | 254 | AC | 10101100 | ¬ | ¬ | |
173 | 255 | AD | 10101101 | | | |
174 | 256 | AE | 10101110 | ® | ® | |
175 | 257 | AF | 10101111 | ¯ | ¯ | |
176 | 260 | B0 | 10110000 | ° | ° | 温度符号 |
177 | 261 | B1 | 10110001 | ± | ± | 加/减号 |
178 | 262 | B2 | 10110010 | ² | ² | 上标 2 |
179 | 263 | B3 | 10110011 | ³ | ³ | 上标 3 |
180 | 264 | B4 | 10110100 | ´ | ´ | |
181 | 265 | B5 | 10110101 | µ | µ | 微符号 |
182 | 266 | B6 | 10110110 | ¶ | ¶ | 段落符号， pilcrow |
183 | 267 | B7 | 10110111 | · | · | 中点 |
184 | 270 | B8 | 10111000 | ¸ | ¸ | |
185 | 271 | B9 | 10111001 | ¹ | ¹ | 上标 1 |
186 | 272 | BA | 10111010 | º | º | 阳性顺序 指示符 |
187 | 273 | BB | 10111011 | » | » | 右角引号 |
188 | 274 | BC | 10111100 | ¼ | ¼ | 分数四分之一 |
189 | 275 | BD | 10111101 | ½ | ½ | 分数二分之一 |
190 | 276 | BE | 10111110 | ¾ | ¾ | |
191 | 277 | BF | 10111111 | ¿ | ¿ | 反向问号 |
192 | 300 | C0 | 11000000 | À | À | 带重音符 的大写字母 A |
193 | 301 | C1 | 11000001 | Á | Á | 带尖锐重音 的大写字母 A |
194 | 302 | C2 | 11000010 | Â | Â | 带音调符号 的大写字母 A |
195 | 303 | C3 | 11000011 | Ã | Ã | 带代字号 的大写字母 A |
196 | 304 | C4 | 11000100 | Ä | Ä | 带元音变音 (分音符号) 的大写字母 A |
197 | 305 | C5 | 11000101 | Å | Å | 带铃声 的大写字母 A |
198 | 306 | C6 | 11000110 | Æ | Æ | 大写字母 AE 双重元音 |
199 | 307 | C7 | 11000111 | Ç | Ç | 带变音符号 的大写字母 C |
200 | 310 | C8 | 11001000 | È | È | 带重音符 的大写字母 E |
201 | 311 | C9 | 11001001 | É | É | 带尖锐重音 的大写字母 E |
202 | 312 | CA | 11001010 | Ê | Ê | 带音调符号 的大写字母 E |
203 | 313 | CB | 11001011 | Ë | Ë | 带元音变音 (分音符号) 的大写字母 E |
204 | 314 | CC | 11001100 | Ì | Ì | 带重音符 的大写字母 I |
205 | 315 | CD | 11001101 | Í | Í | 带尖锐重音 的大写字母 I |
206 | 316 | CE | 11001110 | Î | Î | 带音调符号 的大写字母 I |
207 | 317 | CF | 11001111 | Ï | Ï | 带元音变音 (分音符号) 的大写字母 I |
208 | 320 | D0 | 11010000 | Ð | Ð | |
209 | 321 | D1 | 11010001 | Ñ | Ñ | 带代字号 的大写字母 N |
210 | 322 | D2 | 11010010 | Ò | Ò | 带重音符 的大写字母 O |
211 | 323 | D3 | 11010011 | Ó | Ó | 带尖锐重音 的大写字母 O |
212 | 324 | D4 | 11010100 | Ô | Ô | 带音调符号 的大写字母 O |
213 | 325 | D5 | 11010101 | Õ | Õ | 带代字号 的大写字母 O |
214 | 326 | D6 | 11010110 | Ö | Ö | 带元音变音 (分音符号) 的大写字母 O |
215 | 327 | D7 | 11010111 | × | × | 大写字母 OE 连字 |
216 | 330 | D8 | 11011000 | Ø | Ø | 带斜杠 的大写字母 O |
217 | 331 | D9 | 11011001 | Ù | Ù | 带重音符 的大写字母 U |
218 | 332 | DA | 11011010 | Ú | Ú | 带尖锐重音 的大写字母 U |
219 | 333 | DB | 11011011 | Û | Û | 带音调符号 的大写字母 U |
220 | 334 | DC | 11011100 | Ü | Ü | 带元音变音 (分音符号) 的大写字母 U |
221 | 335 | DD | 11011101 | Ý | Ý | 带元音变音 (分音符号) 的大写字母 Y |
222 | 336 | DE | 11011110 | Þ | Þ | |
223 | 337 | DF | 11011111 | ß | ß | 德语高调 小写字母 s |
224 | 340 | E0 | 11100000 | à | à | 带重音符 的小写字母 a |
225 | 341 | E1 | 11100001 | á | á | 带尖锐重音 的小写字母 a |
226 | 342 | E2 | 11100010 | â | â | 带音调符号 的小写字母 a |
227 | 343 | E3 | 11100011 | ã | ã | 带代字号 的小写字母 a |
228 | 344 | E4 | 11100100 | ä | ä | 带元音变音 (分音符号) 的小写字母 a |
229 | 345 | E5 | 11100101 | å | å | 带铃声的 小写字母 a |
230 | 346 | E6 | 11100110 | æ | æ | 小写字母 ae 双重元音 |
231 | 347 | E7 | 11100111 | ç | ç | 带变音符号 的小写字母 c |
232 | 350 | E8 | 11101000 | è | è | 带重音符 的小写字母 e |
233 | 351 | E9 | 11101001 | é | é | 带尖锐重音 的小写字母 e |
234 | 352 | EA | 11101010 | ê | ê | 带音调符号 的小写字母 e |
235 | 353 | EB | 11101011 | ë | ë | 带元音变音 (分音符号) 的小写字母 e |
236 | 354 | EC | 11101100 | ì | ì | 带重音符 的小写字母 i |
237 | 355 | ED | 11101101 | í | í | 带尖锐重音 的小写字母 i |
238 | 356 | EE | 11101110 | î | î | 带音调符号 的小写字母 i |
239 | 357 | EF | 11101111 | ï | ï | 带元音变音 (分音符号) 的小写字母 i |
240 | 360 | F0 | 11110000 | ð | ð | |
241 | 361 | F1 | 11110001 | ñ | ñ | 带代字号 的小写字母 n |
242 | 362 | F2 | 11110010 | ò | ò | 带重音符 的小写字母 o |
243 | 363 | F3 | 11110011 | ó | ó | 带尖锐重音 的小写字母 o |
244 | 364 | F4 | 11110100 | ô | ô | 带音调符号 的小写字母 o |
245 | 365 | F5 | 11110101 | õ | õ | 带代字号 的小写字母 o |
246 | 366 | F6 | 11110110 | ö | ö | 带元音变音 (分音符号) 的小写字母 o |
247 | 367 | F7 | 11110111 | ÷ | ÷ | 小写字母 oe 连字 |
248 | 370 | F8 | 11111000 | ø | ø | 带斜杠 的小写字母 o |
249 | 371 | F9 | 11111001 | ù | ù | 带重音符 的小写字母 u |
250 | 372 | FA | 11111010 | ú | ú | 带尖锐重音 的小写字母 u |
251 | 373 | FB | 11111011 | û | û | 带音调符号 的小写字母 u |
252 | 374 | FC | 11111100 | ü | ü | 带元音变音 (分音符号) 的小写字母 u |
253 | 375 | FD | 11111101 | ý | ý | 带元音变音 (分音符号) 的小写字母 y2 |
254 | 376 | FE | 11111110 | þ | þ | |
255 | 377 | FF | 11111111 | ÿ | ÿ |
ASCII码对照表的ASCII编码范围0x00-0x7F，即十进制的0-127，定义了128个字符。ASCII码对照表包含了33个控制字符（具有某些特殊功能但是无法显示的字符）和 95 个可显示字符（数字、字母、符号）。国标码 GB18030、国际码Unicode均兼容ASCII编码。
字符串比较
字符串是按位比较，也就是一位位进行对比，只要有一位大，那么整体就大。
案例1:
字符串：abc
字符串：abd
比较结果：abd > abc
案例2:
字符串：a
字符串：ab
比较结果：ab > a
# ab与a比较大小
print(f"ab 与 a 的比较结果是：{'ab' > 'a'}")
# a与A比较大小
print(f"a 与 A 的比较结果是：{'a' > 'A'}")
# key2与key1比较大小
print(f"key2 与 key1 的比较结果是：{'key2' > 'key1'}")
输出结果：
ab 与 a 的比较结果是：True
a 与 A 的比较结果是：True
key2 与 key1 的比较结果是：True
总结
字符串如何比较
从头到尾，一位位进行比较，其中一位大，后面就无需比较了。
单个字符之间如何确定大小？
通过ASCII码表，确定字符对应的码值数字来确定大小。