内容正文:
项目2
定义数据结构存储数据
2023年12月
1
定义字符串
目录
Content
1
定义列表
2
定义元组
3
定义字典
4
定义集合
5
项目导言
零
在使用Python编写一个程序完成指定任务时,使用基础的语法、数据类型和变量定义是远不能满足需求的,当遇到需要保存一组数据时,根据数据量创建与数据量一致的变量显示是不现实的,不但耗时费力,还会使程序运行占用大量内存,影响程序运行速度,在这种情况下,可通过使用Python中的字符串、列表、元组、字典和集合去解决,本项目主要通过对数据结构存储数据的知识进行讲解,解决存储一组数据的问题。
3
学习目标
零
知识目标
了解Python中的数据机构;
熟悉数据结构存储的数据类型;
掌握各数据结构创建和操作方法;
掌握使用个数据结构存储数据的应用场景。
能力目标
具备根据不同场景选择数据结构的能力;
具备创建和管理数据结构的能力;
具备使用数据结构存储数据的能力。
素养目标
具有良好的人际沟通能和交往能力;
具有较强的适应能力;
具有吃苦耐劳的精神;
具备良好的心里素质。
4
任务2-1:定义字符串
壹
1
字符串内置方法
在Python中,字符串是一种常用的数据类型,可通过多种创建字符串的方式,包括单引号、双引号或三引号方式,其中,单引号和双引号只能对单行字符串进行定义,而三引号可以创建多行字符串,语法格式如下所示。
s1 = 'Hello World!'
s2 = "Python is easy to learn."
s3 = '''This is a multiline string.
You can use three single quotes or three double quotes to create it.'''
5
任务2-1:定义字符串
壹
在字符串定义后,即可通过Python提供的多种字符串内置方法对字符串进行操作,包括字符串查找、替换、分割等,常用字符串内置方法见表所示。
方法 描述
find() 查找字符串
count() 统计字符串
replace() 替换字符串
split() 分割字符串
join() / + 连接字符串
strip() 去除字符串指定字符
isalpha() 判断字符串是否只包含字母字符
isdigit() 判断字符串是否只包含数字字符
isalnum() 判断字符串是否只包含字母和数字字符
lower() 将字符串中的所有字母转换为小写字母
upper() 将字符串中的所有字母转换为大写字母
capitalize() 将字符串第一个字符转换为大写字母,其余字符转换为小写字母
title() 将字符串中每个单词的首字母都转换为大写字母
6
任务2-1:定义字符串
壹
(1)字符串查找
在Python中,使用find()方法可以在字符串中从开头到结尾查找指定子字符串的位置,如果存在,则返回子字符串第一次出现的索引位置(下标),如果没有找到则返回-1,语法格式如下所示。
str.find(sub[, start[, end]])
参数说明见表所示。
参数 描述
str 要搜索的字符串
sub 要查找的子字符串
start 查找子字符串的起始位置
end 查找子字符串的结束位置
7
任务2-1:定义字符串
壹
例如,使用find()方法在“Hello, World!”中查找字符串“o”、“World”、“Python”等,代码如下。
s = 'Hello, World!'
print(s.find('o')) # 输出:4
print(s.find('World')) # 输出:7
print(s.find('Python')) # 输出:-1
print(s.find('o', 5, 10)) # 输出:7
(2)字符串统计
字符串统计指在字符串中区分大小写(大写字母和小写字母被认为是不同的字符)统计指定子字符串出现的次数。Python中,可使用count()方法实现,接受参数与find()方法基本相同,语法格式如下所示。
str.count(sub[, start[, end]])
8
任务2-1:定义字符串
壹
例如,使用count()方法统计字母o在字符串“Hello, World!”中出现的次数,代码如下。
s = 'Hello, World!'
print(s.count('o')) # 输出:2
(3)字符串替换
Python提供了一个replace()方法,可以将字符串中某个子字符串替换成另一个字符串,并返回替换后的完整字符串,而原始字符串并没有被修改,语法格式如下所示。
str.replace(old, new[, count])
参数说明见表所示。
参数 描述
str 要搜索的字符串
old 要被替换的子字符串
new 替换后的新字符串
count 最多替换的次数,如果省略,则会将所有的旧字符串都替换为新字符串
9
任务2-1:定义字符串
壹
例如,使用replace()方法将字符串“Hello, World!”中的子字符串“World”替换为“Python”,代码如下。
s = 'Hello, World!'
new_s = s.replace('World', 'Python')
print(new_s) # 输出:Hello, Python!
10
任务2-1:定义字符串
壹
(4)字符串分割
str.split([sep[, maxsplit]])
Python字符串类型中提供了一个split()方法用于分割字符串,会将一个字符串按指定分隔符分割成多个子串,并以列表的形式返回所有子字符串,语法格式如下所示。
参数说明见表所示。
参数 描述
str 要分割的字符串
sep 分隔符,默认是空格字符
maxsplit 最多分割的次数,默认是 -1,表示分割所有子字符串
11
任务2-1:定义字符串
壹
例如,使用split()方法指定分隔符为逗号、字母o实现字符串“Hello, World!”的分割操作,代码如下。
s = 'Hello,World!'
# 无分割符,返回原始字符串的列表形式
print(s.split()) # 输出:['Hello,World!']
# 分隔符为逗号
print(s.split(',')) # 输出:['Hello', 'World!']
# 分隔符为字母o
print(s.split('o')) # 输出:['Hell', ',W', 'rld!']
# 分隔符为字母o,并且限定最大分割次数为1
print(s.split('o', 1)) # 输出:['Hell', ',World!']
12
任务2-1:定义字符串
壹
(5)字符串连接
在Python,字符串的连接操作有两种方式,分别是使用加号(+)和join()方法。其中,使用加号(+)方式可以将两个或多个字符串连接起来成为一个新的字符串。例如,使用加号(+)将字符串“Hello”和“World”连接起来,代码如下。
a = 'Hello'
b = 'World'
c = a + ' ' + b
print(c) # 输出:'Hello World'
13
任务2-1:定义字符串
壹
需要注意的是,使用加号(+)连接字符串对于少量的字符串无伤大雅,但对于大量的字符串连接操作,会导致大量的临时变量和内存开销。因此,在需要进行大量字符串连接操作时,通常使用join()方法将多个字符串连接成一个新的字符串,并返回连接后的字符串,语法格式如下所示。
sep.join(iterable)
参数说明见表所示。
参数 描述
sep 分隔符,默认是空格字符
iterable 表示要连接的序列或者可迭代对象,如列表、元组等
14
任务2-1:定义字符串
壹
例如,使用join()方法将字符串“apple”、“banana”和“orange”以逗号和空格(“, ”)为分隔符连接起来,代码如下。
lst = ['apple', 'banana', 'orange']
s = ', '.join(lst)
print(s) # 输出:'apple, banana, orange'
需要注意的是,join()方法只能用于字符串之间的连接,如果需要将其他类型的数据转换成字符串并连接,需要先使用相应的转换函数(例如str()函数)将其转换成字符串类型。
15
任务2-1:定义字符串
壹
2
字符串操作符
在Python中,字符串操作符是一种用于对字符串进行操作的特殊语法,如加号(+)可以连接两个字符串,返回一个新的字符串,除此之外,Python还支持其他多种操作符,见表所示。
操作符 描述
* 将一个字符串重复多次,返回一个新的字符串
[] 通过下标获取字符串中指定位置的字符或者子串,返回一个单个字符或子串的新字符串
[:] 切片操作符,用于提取子串,返回一个新的子串字符串
in 判断一个字符串是否包含另一个子串,返回True或False
not in 判断一个字符串是否不包含另一个子串,返回True或False
16
任务2-1:定义字符串
壹
2
字符串操作符
在Python中,字符串操作符是一种用于对字符串进行操作的特殊语法,如加号(+)可以连接两个字符串,返回一个新的字符串,除此之外,Python还支持其他多种操作符,见表所示。
操作符 描述
* 将一个字符串重复多次,返回一个新的字符串
[] 通过下标获取字符串中指定位置的字符或者子串,返回一个单个字符或子串的新字符串
[:] 切片操作符,用于提取子串,返回一个新的子串字符串
in 判断一个字符串是否包含另一个子串,返回True或False
not in 判断一个字符串是否不包含另一个子串,返回True或False
17
任务2-1:定义字符串
壹
例如,使用字符串操作符来连接和重复字符串,代码如下。
str1 = "Hello"
str2 = "World"
# 使用 + 连接两个字符串
result1 = str1 + " " + str2
print(result1) # 输出: "Hello World"
# 使用 * 重复字符串
result2 = str1 * 3
print(result2) # 输出: "HelloHelloHello"
18
任务2-1:定义字符串
壹
3
字符串操作符
Python字符串格式化是一种将值插入到字符串中的方法。字符串格式化可以将各种数据类型插入到字符串中,例如数字、字符串、列表等。Python中支持多种字符串格式化的方式,如使用百分号(%)进行字符串格式化、使用format()方法进行字符串格式化、使用f-string进行字符串格式化等。
(1)使用百分号(%)进行字符串格式化
该方式常被称为“旧式字符串格式化”,它使用百分号(%)作为占位符,将要插入的变量放在字符串中的占位符位置,语法格式如下所示。
print("格式字符串" % 值)
19
任务2-1:定义字符串
壹
其中,格式字符串包含一个或多个占位符,代表需要插入值的位置,常用占位符见表所示。
占位符 描述
%s 字符串 (无论是字符串对象还是其他类型的对象)
%d 有符号整数
%f 浮点数
%e 科学计数法表示的浮点数
%x 十六进制整数 (字母小写)
%X 十六进制整数 (字母大写)
%% 输出%字符本身
%.Mf 格式化为浮点数,保留M位小数
%.Me 或 %.ME 格式化为科学计数法(e表示小写字母,E表示大写字母),保留M位小数
%.Nm 格式化为整数,至少占N位,不足部分使用0填充
20
任务2-1:定义字符串
壹
例如,使用百分号(%)将整数和浮点数插入到字符串中,代码如下。
my_int = 42
my_float = 3.14
result = "The int value is %d, the float value is %.2f" % (my_int, my_float)
print(result) # 输出:'The int value is 42, the float value is 3.14'
(2)使用format()方法进行字符串格式化
Python中的format()方法用于格式化字符串,它使用大括号{}作为占位符来指示将要插入值的位置,然后在format()方法中传递相应的参数来填充这些占位符,语法格式如下所示。
'{} {}'.format(arg1, arg2)
21
任务2-1:定义字符串
壹
其中,{}表示要插入到字符串中的参数的位置,arg1和arg2表示要插入的参数,可以是任意类型的变量,包括字符串、数字、布尔类型等。需要注意的是,arg1和arg2的个数可以是任意多个,可以按照顺序依次插入到字符串中。
除了使用上述的方法按照顺序进行插入,也可以通过指定位置进行插入,语法格式如下所示。
'{0} {1}, {2}'.format(arg1, arg2, arg3)
其中,{0} 表示要插入的第一个参数,{1} 表示要插入的第二个参数,{2} 表示要插入的第三个参数,对应的参数是arg1、arg2和arg3。
除了按照位置进行插入,也可以按照关键字进行插入,语法格式如下所示。
'{key1}{key2}'.format(key1=value1, key2=value2)
22
任务2-1:定义字符串
壹
其中,{key1} 表示要插入的关键字参数key1,{key2} 表示要插入的关键字参数key2。
并且,在进行格式化输出时,还可以使用一些常用的类型选项,例如 {:d} 表示要将参数作为整数进行格式化,{:f} 表示要将参数作为浮点数进行格式化,需要注意的是,这些类型选项可以和其他修饰符一起使用,常用格式化输出类型选项见表所示。
选项 描述
{} 默认类型,表示自动根据变量类型进行转换
{:<N} 左对齐,并且占N个字符的位置
{:>N} 右对齐,并且占N个字符的位置
{:^N} 居中对齐,并且占N个字符的位置
{:.Mf} 格式化为浮点数,保留M位小数
{:.Me} 或 {:.ME} 格式化为科学计数法(e表示小写字母,E表示大写字母),保留M位小数
{:.Nm} 格式化为整数,至少占N位,不足部分使用0填充(例如{:.2d}表示至少占2位的整数,不足部分使用0填充)
{:X} 和 {:x} 将整数转换为十六进制数(大写或小写)
23
任务2-1:定义字符串
壹
除了上述类型选项外,还有一些修饰符可以用来指定输出的格式,常用输出格式修饰符见表所示。
修饰符 描述
: 是类型选项的分隔符,将类型选项和修饰符分开
, 在整数中使用逗号作为千位分隔符(例如{:,d}表示将整数格式化为千位分隔数字)
_ 在浮点数中使用下划线作为千位分隔符(例如{:_f}表示使用下划线作为千位分隔符显示浮点数)
24
任务2-1:定义字符串
壹
例如,使用format()将整数和浮点数插入到字符串中,代码如下。
my_int = 42
my_float = 3.14
result = "The int value is {}, the float value is {:.2f}".format(my_int, my_float)
print(result) # 输出:'The int value is 42, the float value is 3.14'
(3)使用f-string进行字符串格式化
相比于前两种字符串格式化方法,使用f-string进行字符串格式化的方式仅适用于Python 3.6及以上版本,是一种非常方便和直观的字符串格式化方式,使用f-string标记(在字符串前添加字母f)以及大括号{}表示占位符。例如,使用f-string将整数和浮点数插入到字符串中,代码如下。
my_int = 42
my_float = 3.14
result = f"The int value is {my_int}, the float value is {my_float:.2f}"
print(result) # 输出:'The int value is 42, the float value is 3.14'
25
任务2-1:定义字符串
壹
4
字符串编码转换
在Python中,除了使用注释对编码格式进行指定外,还可以使用内置的encode()和decode()方法来进行Python中字符串编码的转换。
(1)encode()
encode()是Python中用于将字符串编码为字节序列的方法,能够将Unicode字符串转换为指定编码格式(如UTF-8)的字节序列,以便在网络传输或文件存储等场景下使用,语法格式如下所示。
str.encode(encoding='UTF-8', errors='strict')
参数说明见表所示。
参数 描述
encoding 可选,指定要使用的字符编码,默认值为“UTF-8”
errors 可选,指定编码错误时的处理方式,默认值为“strict”,表示抛出一个 UnicodeError 异常,其他可选值如下:ignore:在忽略无法编码的字符时不抛出异常replace:在无法编码的字符处使用“?”替代原字符xmlcharrefreplace:使用 XML 实体替换无法编码的字符
26
任务2-1:定义字符串
壹
例如,使用encode()方法将字符串“你好,世界!”转换为“UTF-8”格式,代码如下。
text = "你好,世界!"
byte_text = text.encode("UTF-8")
print(byte_text) # 输出: b'\xe4\xbd\xa0\xe5\xa5\xbd\xef\xbc\x8c\xe4\xb8\x96\xe7\x95\x8c\xef\xbc\x81'
(2)decode()
ecode()方法功能与encode()方法功能相反,是Python中内置的用于将字节串解码为Unicode字符串的方法,语法格式如下所示。
bytes.decode(encoding='UTF-8', errors='strict')
例如,使用decode()方法将字符串转换为Unicode字符串,代码如下。
byte_text = b'\xe4\xbd\xa0\xe5\xa5\xbd\xef\xbc\x8c\xe4\xb8\x96\xe7\x95\x8c\xef\xbc\x81'
text = byte_text.decode("UTF-8")
print(text) # 输出: 你好,世界!
27
任务2-2 定义列表
贰
1
列表创建和访问
1、列表创建
目前,列表的创建方式有多种,如使用方括号[]、使用内置函数list()。其中,最常见的方式是使用方括号[]将元素括起来,并用逗号“,”分割。例如,创建一个包含整数、字符串和布尔值的列表,代码如下。
my_list = [1, 2, 3, "hello", True]
而使用内置函数list()则可以将其他可迭代对象(如列表、元组、集合、字典(返回键值对的列表)和字符串等)转换为列表并返回,如果传递的参数不可迭代,将会出现TypeError错误;并且,list()函数不带参数,则返回一个空的列表。例如,将元组转换为列表,代码如下。
my_list = list((1, 2, 3))
28
任务2-2 定义列表
贰
2、列表访问
在Python中,由于列表是有序集合,每个元素都有一个对应的索引,因此可以使用索引来访问列表中的元素。目前,根据列表中访问元素的数量不同,有单个元素访问和多个元素访问两种。
my_list[index]
(1)单个元素访问
Python中单个元素访问通过中括号“[]”结合索引实现,索引从0开始,也就是第一个元素的索引是0,第二个元素的索引是1,以此类推。并且,除了正向索引之外,Python 还支持负向索引,表示从列表末尾开始计算的位置,即从后往前计数,例如-1表示最后一个元素。Python中单个元素访问语法格式如下所示。
29
任务2-2 定义列表
贰
(2)多个元素访问
其中,index是要访问的元素的索引值;如果index超出了列表的范围,将会抛出IndexError异常。
例如,创建列表mylist并访问单个元素,代码如下。
mylist = ['apple', 'banana', 'orange']
print(mylist[0]) # 输出 'apple'
print(mylist[-1]) # 输出 'orange'
除了单个元素之外,Python还支持通过(slice)操作访问列表中的多个元素,并返回一个新的列表,其中包含了原始列表中指定范围内的元素。在实现切片时,使用冒号“:”分隔起始位置和结束位置,表示取出从起始位置到结束位置之间的所有元素(不包括结束位置),语法格式如下所示。
my_list[start:end:step]
30
任务2-2 定义列表
贰
参数说明见表所示。
参数 描述
start 表示开始的索引值(包含在结果中),如果省略,则默认从列表头开始
end 表示结束的索引值(不包含在结果中),如果省略,则默认到列表尾结束
step 表示步长,如果省略,则默认为1
例如,创建列表mylist并使用切片操作访问多个元素,代码如下。
mylist = ['apple', 'banana', 'orange', 'grape', 'pear']
print(mylist[1:3]) # 输出 ['banana', 'orange']
print(mylist[:3]) # 输出 ['apple', 'banana', 'orange']
print(mylist[3:]) # 输出 ['grape', 'pear']
print(mylist[::2]) # 输出 ['apple', 'orange', 'pear']
31
任务2-2 定义列表
贰
2
列表元素修改
在Python中,列表是可变的(Mutable),即列表中的元素可以被修改。要修改列表中的某个元素,可以使用索引或切片操作来定位该元素,然后直接赋值即可,语法格式如下所示。
my_list[index] = new_value
参数说明见表所示。
参数 描述
my_list 要修改的列表
index 要修改的元素的索引位置
new_value 要用来替换原始值的新值
32
任务2-2 定义列表
贰
例如,使用索引方式修改列表my_list的第1个元素(即索引为0的元素)并将其替换为字符串“pear”,以及使用切片操作选取了多个元素并赋值,代码如下。
my_list = ['apple', 'banana', 'orange', 'grape', 'pear']
my_list[0] = 'pear'
print(my_list) # 输出 ['pear', 'banana', 'orange', 'grape', 'pear']
my_list[1:4] = ['watermelon', 'kiwi']
print(my_list) # 输出 ['pear', 'watermelon', 'kiwi', 'pear']
33
任务2-2 定义列表
贰
3
列表内置方法
目前,除了list()方法外,Python还内置了许多与列表相关的方法,这些方法能够方便地对列表进行操作,如添加、删除、查找、统计等,常用方法见表所示。
方法 描述
len(list) 返回给定列表中元素的数量(或长度)。它通常用于确定列表的大小以及在循环过程中使用
list.append(item) 可以在不知道列表的长度的情况下,动态地向列表中添加元素。该方法接受一个参数,即要添加的元素。并且,该方法会修改原始列表,而且只能一次添加一个元素,如果需要添加多个元素,则需要多次调用该方法
list.extend(iterable) 用于将可迭代对象iterable中的所有元素一次性地添加到列表的末尾
list.insert(index, item) 用于在指定索引处向列表中插入一个新元素,其中:index为要插入新元素的索引,item为要插入的新元素
list.pop([index]) 可以从列表中任意位置移除一个元素,并返回被移除的元素。其中,index表示要移除元素的索引,如果省略,则默认移除并返回列表中的最后一个元素
list.remove(item) 用于从列表中移除指定的元素。其中,item表示要从列表中移除的元素值
34
任务2-2 定义列表
贰
方法 描述
list.index(item) 用于获取列表中指定元素的索引,如果找不到索引,则会引发ValueError异常。其中,item表示要查找的元素值
max(list) 用于获取列表中的最大值,如果列表中的元素类型不同,则会根据默认规则进行比较。例如,数字会优先于字符串进行比较,字符串会根据字母表顺序进行比较
min(list) 用于获取列表中的最小值
sum(list[,start]) 用于计算列表中所有元素的和。其中,list为计算和的列表,start为可选参数,表示求和的初始值,如果不提供默认为0
list.count(item) 用于统计列表中指定元素出现的次数。其中,item为要统计出现次数的元素值
sorted(list,reverse=False) 按照升序或降序对列表进行排序,并返回新的已排序的列表。其中,list为计算列表;reverse为排序方式,默认为False,表示升序排列
list.sort(key=None,reverse=False) 按照升序或降序对列表进行排序,并对原列表进行修改。其中,key表示用于排序的函数,而reverse表示是否按照降序排列
list.reverse() 仅对列表中的元素顺序进行反转,并对原列表进行修改,而不会在元素上执行任何排序操作
35
任务2-2 定义列表
贰
例如,分别使用不同的内置方法对列表进行操作,代码如下。
numbers = [1, 2, 3]
print(len(numbers)) # 输出 3
print(numbers.append(4)) # 输出 [1, 2, 3, 4]
print(numbers.extend([5, 6])) # 输出 [1, 2, 3, 4, 5, 6]
print(numbers.insert(3, 7)) # 输出 [1, 2, 3, 7, 4, 5, 6]
print(numbers.pop([0])) # 输出 [2, 3, 7, 4, 5, 6]
print(numbers.remove(6)) # 输出 [2, 3, 7, 4, 5]
print(numbers.index(3)) # 输出 1
print(max(numbers)) # 输出 7
print(min(numbers)) # 输出 2
print(sum(numbers)) # 输出 21
print(numbers.count(7)) # 输出 1
print(sorted(numbers,reverse=False)) # 输出 [2, 3, 4, 5, 7]
print(numbers.sort(reverse=True)) # 输出 [7, 6, 4, 3, 2]
print(numbers.reverse()) # 输出 [5, 4, 7, 3, 2]
36
任务2-3 定义元组
叁
1
元组创建和访问
在Python中,元组(tuple)是一种有序、不可变的数据类型,可以用来存储一组数据。尽管元组跟列表非常类似,并且都是Python中的序列类型,它们共同点是可以存储多个元素,并且支持索引和切片操作。但是,列表和元组也有一些重要的区别,如下:
由于列表是可变序列,因此在对其进行操作时会重新分配内存空间,而元组则不需要重新分配内存空间。因此,在只需要读取元素时,使用元组可能会更加高效。
最显著的区别是,列表是可变的序列,而元组是不可变的序列,这意味着列表中的元素可以随意添加、删除或更改,而元组中的元素则不能更改。
列表具有各种内置方法(例如append()和remove()),可以方便地对其进行修改,而元组则没有这些方法。
37
任务2-3 定义元组
叁
元组的定义方式与列表类似,使用逗号“,”分隔不同的元素,并使用圆括号将元素括起来进行定义。并且,元 组中的元素可以是不同类型的,比如整数、浮点数、字符串、列表、元组等。例如,创建一个包含三个整数的元组,代码如下。
1、元组创建
tup = (1, 2, 3)
需要注意的是,如果定义只包含一个元素的元组,需要在元素后加一个逗号,否则 Python 会将其视为一个单独的值,而非元组。例如,创建一个包含一个整数的元组,代码如下。
tup = (1,3)
在Python中,除了使用圆括号外,还可以使用tuple()方法来创建元组,该方法会将一个可迭代对象(如列表、字符串等)转换为元组,语法格式如下所示。
tuple(iterable)
38
任务2-3 定义元组
叁
其中,iterable即为可迭代对象。例如,将列表转换为元组,代码如下。
lst = [1, 2, 3]
tup = tuple(lst)
2、元组访问
与列表中元素访问相同,Python中元组中元素的访问同样通过索引和切片操作实现。例如,创建元组并访问第一个元素、最后一个元素以及第二个元素到第四个元素,代码如下。
tup = (1, 2, 3, 4, 5)
print(tup[0]) # 输出1
print(tup[-1]) # 输出5
print(tup[1:3]) # 输出 (2, 3, 4)
39
任务2-3 定义元组
叁
2
元组删除
相比于列表,元组中元素不能直接被删除,只能通过“del”关键字将整个元组从内存中删除,语法格式如下所示。
del tup
但是需要注意的是,删除元组后,再尝试访问该元组会导致NameError错误。因此,在删除元组之前,需要确保不再需要访问该元组中的任何元素。
另外,如果需要删除元组中的一个或多个元素,可以先将元组转换为列表,然后在列表中删除对应的元素,最后将列表转换回元组,代码如下。
tup = ('apple', 'banana', 'cherry')
lst = list(tup) # 将元组转换为列表
lst.remove('banana') # 删除列表中的元素
tup = tuple(lst) # 将列表转换回元组
print(tup) # 输出:('apple', 'cherry')
40
任务2-3 定义元组
叁
3
元组内置方法
在Python中,元组是一个不可变的数据类型,因此它只提供少量的内置方法进行元素的操作,如索引的查看、元素个数统计等,常用方法见表所示。
方法 描述
len(tup) 返回给定元组中元素的数量(或长度)
max(tup) 获取元组中的最大值
min(tup) 获取元组中的最小值
tup.count(item) 获取指定元素在元组中第一次出现时的索引值,如果元素不存在,会抛出ValueError异常
tup.index(item) 用于统计指定元素在元组中出现的次数
41
任务2-3 定义元组
叁
需要注意的是,上述方法不会修改元组本身,而是返回一个新的结果。因为元组是不可变的数据类型,一旦创建了元组,其中的元素就不能被修改,只能通过替换整个元组的方式进行更新。
例如,分别使用不同的内置方法对元组进行操作,代码如下。
tup = (10, 20, 30)
print(len(tup)) # 输出:3
print(max(tup)) # 输出:30
print(min(tup)) # 输出:10
print(tup.count(10)) # 输出:1
print(tup.index(20)) # 输出:1
42
任务2-4 定义列表
肆
1
字典简介
在Python中,字典是一种可变的、无序的数据类型,用于存储键值对。字典中的每个元素都是一个键值对,通常用于需要快速查找和访问数据的场景,是Python中非常重要和常用的数据类型,它具有灵活性、可变性、快速访问等特点,如下:
键值对
字典是由一系列键值对组成的,每个键值对都包含一个唯一的键和与之相关联的值。
可变性
字典是可变的,可以向其添加、删除或修改键值对。
灵活性
字典可以容纳不同类型和不同大小的数据,可以存储任意类型的对象作为值。
无序性
字典中的键值对是无序的,即它们没有固定的顺序。
长度可变性
字典的长度是可变的,它可以根据需要动态地增加或减少大小。
快速访问
由于字典使用哈希表实现,因此可以快速查找和访问其中的键值对,这使其在大型数据集中非常有用。
43
任务2-4 定义字典
肆
2
字典创建和访问
1、字典创建
与列表和元组创建不同,字典使用花括号“{ }”来创建,每个键值对之间使用冒号“:”分隔,不同的键值对之间使用逗号“,”分隔,语法格式如下所示。
my_dict = {key1: value1, key2: value2, ...}
参数说明见表所示。
参数 描述
my_dict 要创建的字典变量名
key1、key2 字典中的键
value1、value2 相应键的值
44
任务2-4 定义字典
肆
例如,创建一个包含三个键值对的字典,其中的键分别是“apple”、“banana”和“cherry”,对应的值分别是1、2和3,代码如下。
my_dict = {'apple': 1, 'banana': 2, 'cherry': 3}
另外,还可以直接使用花括号“{}”,先创建一个空字典,然后再向其中添加键值对,语法格式如下所示。
my_dict = {} # 创建空字典
my_dict[key1] = value1 # 添加键值对
my_dict[key2] = value2
例如,直接使用花括号“{}”创建字典,代码如下。
my_dict = {}
my_dict['apple'] = 1
my_dict['banana'] = 2
my_dict['cherry'] = 3
45
任务2-4 定义字典
肆
除了使用花括号“{}”进行自定的创建外,Python也可以通过dict()方法,从包含键值对的序列或者关键字参数创建字典,语法格式如下所示。
# 从序列创建
my_dict = dict([(key1, value1), (key2, value2), ...])
# 从关键字参数创建
my_dict = dict(key1=value1, key2=value2, ...)
例如,从包含键值对的序列创建字典,代码如下。
my_dict = dict([('apple', 1), ('banana', 2), ('cherry', 3)])
这里直接使用元组列表作为输入,其中每个元组由一个键和一个值组成。dict()方法将此列表转换为一个字典,并将每个元组的第一个元素(即键)作为新字典中的每个键,将该元组的第二个元素(即值)作为每个键的值。
46
任务2-4 定义字典
肆
目前,字典中元素的访问均通过键实现,这是由于字典中键的唯一性决定的,可以分别通过中括号“[]”、get()方法以及运算符in实现。
2、字典访问
(1)中括号“[]”访问字典元素
使用中括号“[]”访问字典中的键值对时,只需将所需键作为索引传递给中括号“[]”,即可获取该键对应的值,语法格式如下所示。
my_dict[key]
如果尝试访问不存在的键,则会引发KeyError异常。因此,在访问字典之前,最好先检查该键是否存在。
例如,使用中括号“[]”和键来访问字典元素,代码如下。
my_dict = {'apple': 1, 'banana': 2, 'cherry': 3}
print(my_dict['apple']) # 输出 1
47
任务2-4 定义字典
肆
(2)get()方法访问字典元素
my_dict.get(key)
例如,使用get()方法访问字典元素,代码如下。
my_dict = {'apple': 1, 'banana': 2, 'cherry': 3}
print(my_dict.get('apple')) # 输出 1
Python的字典中,还可以使用get()方法来获取指定键对应的值。与直接使用中括号“[]”访问字典元素不同,如果使用get()方法获取一个不存在的键,不会抛出KeyError异常,而是返回一个默认值(如果已指定)或者None(如果未指定默认值),语法格式如下所示。
48
任务2-4 定义字典
肆
(3)运算符in访问字典元素
除了上述两种方式能够访问字典元素外,还可以使用运算符in检查字典中是否存在指定的键,返回值为True或False,语法格式如下所示。
key in my_dict
49
任务2-4 定义字典
肆
3
字典元素操作
在 Python 中,可以使用字典的索引操作和相关方法来操作字典的元素,包括添加、修改、删除等操作。
1、添加元素
my_dict = {'apple': 1, 'banana': 2}
my_dict['cherry'] = 3
在上面创建字典时,可以先创建空字典,然后通过赋值的方式添加键值对的操作即为元素添加。其中,这个字典不仅可以为空,也可以存在键值对。
例如,创建一个键分别是“apple”和“banana”,对应的值分别是1和2的字典,之后向字典中添加键为“cherry”,值为3的键值对,代码如下。
50
任务2-4 定义字典
肆
my_dict1.update(my_dict2)
除此之外,Python中针对字典元素还提供了update()方法,可以将一个字典中的键值对添加到另一个字典中,语法格式如下所示。
例如,使用update()方法向字典my_dict中添加了一个键值对“'cherry': 3”,代码如下。
my_dict = {'apple': 1, 'banana': 2}
my_dict.update({'cherry': 3})
51
任务2-4 定义字典
肆
2、修改元素
my_dict = {'apple': 1, 'banana': 2, 'cherry': 3}
my_dict['apple'] = 4
update()方法不仅可以实现元素的添加操作,还可以通过指定的键修改字典中已有键对应的值。例如,使用update()方法修改字典中指定键对应的值,代码如下。
3、删除元素
目前,删除字典中指定的元素可以有多种方法,根据删除量的不同,可以分为删除单个元素、随机删除单个元素、删除全部元素。
52
任务2-4 定义字典
肆
(1)删除单个元素
删除单个元素主要通过字典中的键实现,不仅可以通过del关键字删除指定键对应的键值对,如果该键不存在,则会引发KeyError异常,语法格式如下所示。
del my_dict[key]
例如,使用del删除键值对,代码如下。
my_dict = {'apple': 1, 'banana': 2}
del my_dict['apple']
还可以使用pop()方法删除指定键对应的键值对,并返回与之关联的值。如果指定的键不存在,则pop()方法将引发KeyError异常,语法格式如下所示。
my_dict.pop(key)
53
任务2-4 定义字典
肆
例如,使用pop()方法删除键值对,代码如下。
my_dict = {'apple': 1, 'banana': 2}
my_dict.pop('apple')
(2)随机删除单个元素
除了删除指定键对应的键值对外,Python针对字典中的元素,还提供了popitem()方法,可以随机删除一个键值对,并返回已删除的键值对,如果字典为空,则popitem()方法将引发KeyError异常,语法格式如下所示。
my_dict.pop(key)
例如,使用popitem()方法随机删除my_dict字典中的一个键值对,并返回已删除的键和值,代码如下。
my_dict = {'apple': 1, 'banana': 2}
key, value = my_dict.popitem()
54
任务2-4 定义字典
肆
(3)删除全部元素
当字典中的元素不被需要,这时可以通过clear()方法将字典中所有的元素清空,使其变为空字典,语法格式如下所示。
my_dict.clear()
需要注意的是,clear()方法只会删除字典中的元素,而不会删除字典本身。因此,清空后的字典仍然存在并可以继续使用。
55
任务2-4 定义字典
肆
4、其他元素操作
在Python的字典中,除了元素的添加、修改、删除等基础操作外,Python还提供了多个其他内置方法对元素进行操作,包括键查询、值查询等,常用方法见表所示。
方法 描述
dict.copy() 返回一个字典的副本
dict.items() 返回包含所有(键,值)对元组的列表
dict.keys() 返回包含所有键的列表
dict.values() 返回包含所有值的列表
56
任务2-4 定义字典
肆
例如,分别使用不同的内置方法对字典进行操作,代码如下。
my_dict = {'apple': 1, 'banana': 2, 'cherry': 3}
print(my_dict.items()) # 输出:dict_items([('apple', 1), ('cherry', 3)])
print(my_dict.keys()) # 输出:dict_keys(['apple', 'cherry'])
print(my_dict.values()) # 输出:dict_values([1, 3])
# 创建一个新字典
new_dict = my_dict.copy()
# 清空字典
my_dict.clear()
57
任务2-5 定义集合
伍
1
集合创建和访问
1、集合创建
my_set = {1, 2, 3}
与字典的创建类似,集合的创建同样通过花括号“{ }”实现,并使用逗号“,”分隔集合中的元素。例如,创建一个包含三个整数的集合,代码如下。
除此之外,Python还提供了set()方法,可以接收一个可迭代对象(如列表、元组、字符串等),并返回一个包含该可迭代对象中所有唯一元素的集合。语法格式如下所示。
set(iterable)
其中,iterable是一个可迭代对象,如列表、元组或字符串等。
例如,创建一个包含整数1、2、3的集合,代码如下。
my_set = set([1, 2, 3])
58
任务2-5 定义集合
伍
2、集合访问
my_set = {1, 2, 3, 'apple', 'banana'}
if 2 in my_set:
print('2 is in the set')
else:
print('2 is not in the set')
与列表和元组不同,集合是无序的,因此无法通过索引来访问集合中的元素,但可以使用in和not in运算符来判断一个元素是否存在于集合中。例如,判断集合中是否包含数字2,代码如下。
59
任务2-5 定义集合
伍
2
集合内置方法
在Python中,针对集合元素的操作,提供了多个内置方法,包括集合元素的添加、删除等,常用方法见表所示。
方法 描述
set.add(elem) 用于向集合中添加新的元素。如果该元素已经存在于集合中,那么将不会被添加到集合中。其中:set:指要添加元素的集合elem:指要添加的元素
set.update(iterable) 用于向集合中添加多个元素,包括列表、元组、集合等其他可迭代对象
set.remove(elem) 用于从集合中删除指定元素。如果指定的元素不存在于集合中,将会引发KeyError异常。因此,在使用remove()方法之前,最好先检查要删除的元素是否存在于集合中,可以使用in关键字来判断。
set.discard(elem) 用于从集合中删除指定元素。如果指定的元素不存在于集合中,则不会引发异常。
set.pop() 用于随机删除集合中的一个元素,并返回该元素的值。如果集合为空,会引发 KeyError 异常
set.clear() 用于清空集合中的所有元素,但不会删除集合本身,因此,该方法执行后仍然可以对该集合进行操作
len(set) 用于返回集合中元素的数量
60
任务2-5 定义集合
伍
例如,分别使用不同的内置方法对集合进行操作,代码如下。
s = {1, 2, 3}
s.add(4)
print(s) # 输出 {1, 2, 3, 4}
s.update([4, 5, 6])
print(s) # 输出 {1, 2, 3, 4, 5, 6}
s.remove(2)
print(s) # 输出 {1, 3, 4, 5, 6}
s.discard(3)
print(s) # 输出 {1, 4, 5, 6}
s.clear()
print(s) # 输出 set()
61
任务2-5 定义集合
伍
3
集合合并
在Python中,集合的合并操作与数学运算中的集合合并操作基本相同,包括并集、交集、差集、对称差集等。
(1)并集
Python中并集计算可以通过union()方法或运算符“|”实现,能够获取两个集合中的所有元素,并且元素不重复,语法格式如下所示。
set1.union(set2)
set1 | set2
例如,创建两个集合并合并这两个集合,代码如下。
set1 = {1, 2, 3}
set2 = {2, 3, 4}
print(set1.union(set2)) # 输出 {1, 2, 3, 4}
print(set1 | set2) # 输出 {1, 2, 3, 4}
62
任务2-5 定义集合
伍
(2)交集
Python中交集计算可以通过intersection()方法或运算符“&”实现,能够获取两个集合中公共的元素,语法格式如下所示。
set1.intersection(set2)
set1 & set2
例如,创建两个集合并进行交集计算,代码如下。
set1 = {1, 2, 3}
set2 = {2, 3, 4}
print(set1.intersection(set2)) # 输出 {2, 3}
print(set1 & set2) # 输出 {2, 3}
63
任务2-5 定义集合
伍
(3)差集
Python中差集计算可以通过difference()方法或运算符“-”实现,能够获取只在一个集合中出现且不在另一个集合中出现的元素,语法格式如下所示。
set1.difference(set2)
set1 - set2
例如,创建两个集合并进行差集计算,代码如下。
set1 = {1, 2, 3}
set2 = {2, 3, 4}
print(set1.difference(set2)) # 输出 {1}
print(set1 - set2) # 输出 {1}
64
任务2-5 定义集合
伍
(4)对称差集
Python中对称差集计算可以通过symmetric_difference()方法或运算符“^”实现,能够获取只在两个集合之一中出现的所有元素,与交集相反,语法格式如下所示。
set1.symmetric_difference(set2)
set1 ^ set2
例如,创建两个集合并进行对称差集计算,代码如下。
set1 = {1, 2, 3}
set2 = {2, 3, 4}
print(set1.symmetric_difference(set2)) # 输出 {1, 4}
print(set1 ^ set2) # 输出 {1, 4}
65
$$