Python第四章序列

持键写浮生

已于 2022-10-12 09:14:48 修改

阅读量894

点赞数 2

分类专栏： Python学习文章标签： python 开发语言开源

于 2022-09-21 13:17:01 首次发布

本文链接：https://blog.csdn.net/m0_46652188/article/details/126968934

版权

Python学习专栏收录该内容

3 篇文章 0 订阅

订阅专栏

列表

4.1.1 列表的创建与删除

列表就相当于java语言中的数组。

使用赋值运算符直接创建列表
student = [‘小明’, ‘男’, 2010,10]
num = [1, 2, 3, 4, 5]
motto = [“自强不息”,“止于至善”]
list = [‘hadoop’, ‘年度畅销书’,[2020,12000]]

尽管一个列表中可以放入不同类型的数据，但是，为了提高程序的可读性，一般建议在一个列表中只出现一种数据类型。

创建空列表
在Python中创建新的空列表的方法如下：
empty_list = []
这时生成的empty_list就是一个空列表，如果使用内置函数len()去获取
它的长度，结果会返回0，如下所示：

empty_list = []
print(type(empty_list))
<class ‘list’>
print(len(empty_list))
0

创建数值列表
Python中的数值列表很常用，用于存储数值集合。Python提供了list()函
数，它可以将range()对象、字符串、元组或其他可迭代类型的数据转
换为列表。例如，创建一个包含1到5的整数列表：

num_list = list(range(1,6))
print(num_list)
[1, 2, 3, 4, 5]
下面创建一个包含1到10中的奇数的列表：
num_list = list(range(1,10,2))
print(num_list)
[1, 3, 5, 7, 9]

列表的删除
当列表不再使用时，可以使用del命令删除整个列表，如果列表对象所指向的值不
再有其他对象指向，Python将同时删除该值。

在这里插入图片描述

从上面代码的执行结果可以看出，删除列表对象motto以后，该对象就不存在了，
再次访问时就会抛出异常。

访问列表元素

在这里插入图片描述

添加、删除、修改列表元素

列表元素的添加（五种方法）

append()
列表对象的append()方法用于在列表的末尾追加元素
insert()
列表对象的insert()方法用于将元素添加至列表的指定位置。
num_list.insert(2,9)表示向列表的第2个元素后面添加一个新的元素9。这样会让插入位置后面所有的元素进行移动，如果列表元素较多，这样操作会影响处理速度。
extend()
使用列表对象的extend()方法可以将另一个迭代对象的所有元素添加至该列表对象尾部
extend()方法将目标列表的所有元素添加到本列表的尾部，属于原地操作（内存地址没有发生变化），不创建新的列表对象
“+”运算符
可以使用“+”运算符来把元素添加到列表中。内存地址发生了变化，这是因为，添加新元素时，创建了一个新的列表，并把原列表中的元素和新元素依次复制到新列表的内存空间。当列表中的元素较多时，该操作速度会比较慢。
“*”运算符
可以将列表与整数相乘，生成一个新列表，新列表是原列表中元素的重复

实例：

# 添加 删除 修改列表元素

num2=["aa","bb","cc"]
num2.append("yjk")
print(num2)

# num_list.insert(2,9)表示向列表的第2个元素后面添加一个新的元素9。这样会让插入位置后面所有的元素进行移动，如果列表元素较多，这样操作会影响处理速度。

num2.insert(2,100)
print(num2)

# extend()方法将目标列表的所有元素添加到本列表的尾部，属于原地操作（内存地址没有发生变化），不创建新的列表对象
print(id(num2))
num2.extend([6,7,8,9])
print(id(num2))
print(num2)

# 原地址变化，创建新地址拼接。速度比较慢。
num2 = num2+["加号拼接"]
print(num2)

列表元素的删除

使用del语句删除指定位置的元素
使用pop()删除元素
pop()可删除列表末尾的元素，实例如下：
使用remove()根据值删除元素
可以使用remove()方法删除首次出现的指定元素，如果列表中不存在要删
除的元素，则抛出异常。

列表元素的修改

在这里插入图片描述

对列表进行统计计算

获取指定元素出现的次数
可以使用列表对象的count()方法来获取指定元素在列表中的出现次数
获取指定元素首次出现的下标
使用列表对象的index()方法可以获取指定元素首次出现的下标，语法格式为：
index(value,[start,[stop]])
其中，start和stop用来指定搜索范围，start默认为0，stop默认为列表长度。
如果列表对象中不存在指定元素，则会抛出异常。
统计数值列表的元素和
sum()函数用于统计数值列表中各个元素的和，语法格式如下：
sum(aList[,start])
其中，aList表示要统计的列表，start表示统计结果是从哪个数开始累加，如果没有指定，默认值为0。

对列表进行排序

使用列表对象的sort()方法排序
具体语法格式如下：
aList.sort(key=None,reverse=False)
其中，aList表示要排序的列表，key参数来指定一个函数，此函数将在每个元
素比较前被调用，例如，可以设置“key=str.lower”来忽略字符串的大小写；
reverse是一个可选参数，如果值为True，则表示降序排序，如果值为False，
则表示升序排序，默认为升序排序
当列表中的元素类型是字符串时，sort()函数排序的规则是，先对大写字
母进行排序，然后再对小写字母进行排序。如果在排序时不考虑字母大
小写，则需要设置“key=str.lower”。
使用内置的sorted()函数排序
Python提供了一个内置的全局sorted()方法，可以用来对列表排序生成新的列表，原列表的元素顺序保持不变，语法格式如下：
sorted(aList,key=None,reverse=False)
其中，aList表示要排序的列表，key参数来指定一个函数，此函数将在每
个元素比较前被调用，例如，可以设置“key=str.lower”来忽略字符串
的大小写；reverse是一个可选参数，如果值为True，则表示降序排序，
如果值为False，则表示升序排序，默认为升序排序。

成员资格判断

如果需要判断列表中是否存在指定的值，可以采用四种不同的方式：in、
not in、count()、index()。

可以使用in操作符判断一个值是否存在于列表中
可以使用not in操作符判断一个值是否不在列表中
可以使用列表对象的count()方法，如果指定的值存在，则返回大于0的数，
如果返回0，则表示不存在
可以使用index()方法查看指定值在列表中的位置，如果列表中存在指定
值，则会返回该值第一次出现的位置，否则会抛出错误

切片操作

Python中的有序序列（如字符串、元组）都支持切片操作。切片的返回结果类型和切片对象类型一致，返回的是切片对象的子序列，比如，对一个列表切片返回一个列表，对一个字符串切片返回字符串。
通过切片操作可以生成一个新的列表（不会改变原列表），切片操作的语法格式如下：
listname[start : end : step]
其中，listname表示列表名称；start是切片起点的索引，如果不指定，默认值为0；end是切片终点的索引（但是切片结果不包括终点索引的值），如果不指定，默认为列表的长度；step是步长，默认值是1（也就是一个一个依次遍历列表中的元素），当省略步长时，最后一个冒号也可以省略。
在这里插入图片描述

可以结合使用del命令与切片操作来删除列

列表推导式

列表推导式可以利用range对象、元组、列表、字典和集合等数据类型，快速生成一个满足指定需求的列表。列表推导式的语法格式如下：
[表达式 for 迭代变量 in 可迭代对象 [if 条件表达式] ]
其中，[if 条件表达式]不是必须的，可以使用，也可以省略。例如，利用0到9的平方生成一个整数列表。
在这里插入图片描述
还可以在列表推导式中添加if条件语句，这样列表推导式将只迭代那些符合条件的元素，实例如下：

Python还支持类似于三层嵌套的for表达式，实例如下：

二维列表

所谓的“二维列表”，是指列表中的每个元素仍然是列表。和java中的二维数组差不多。

以通过for循环来为二维列表赋值

该程序的执行结果如下：
[[0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3]]
可以使用列表推导式来创建二维列表，代码如下：

在这里插入图片描述
访问二维数组时，可以使用下标来定位，实例如下：

元组

1.创建元组

元组的创建和列表的创建很相似，不同之处在于，创建列表时使用的是方括号，而创建元组时则需要使用圆括号。

>>> tuple1 = ('hadoop','spark',2008,2009)
>>> tuple2 = (1,2,3,4,5)
>>> tuple3 = ('hadoop',2008,("大数据","分布式计算"),["spark","flink","storm"])
创建空元组的方法如下：
>>> tuple1 = ()

需要注意的是，当元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用

>>> tuple1 = (20)
>>> type(tuple1)
<class 'int'>
>>> tuple1 = (50,)
>>> type(tuple1)
<class 'tuple'>

也可以使用tuple()函数和range()函数来生成数值元组，实例如下：

>>> tuple1 = tuple(range(1,10,2))
>>> tuple1
(1, 3, 5, 7, 9)

2.访问元组

使用下标索引来访问元组中的元素：

>>> tuple1 = ("hadoop", "spark", "flink", "storm")
>>> tuple1[0]
'hadoop'
>>> tuple1[1]
'spark‘

采用切片的方式来获取指定的元素：

>>> tuple1 = (1,2,3,4,5,6,7,8,9)
>>> tuple1[2:5]
(3, 4, 5)

使用for循环实现元组的遍历：

01 # for_tuple.py
02 tuple1 = ("hadoop", "spark", "flink", "storm")
03 for element in tuple1:
04 print(element)

该程序的执行结果如下：
hadoop
spark
flink
storm

3.修改元组

虽然元组中的元素值是不允许修改的，但是我们可以对元组进行连接组合

>>> tuple1 = ("hadoop", "spark", "flink")
>>> tuple2 = ("java","python","scala")
>>> tuple3 = tuple1 + tuple2
>>> tuple3
('hadoop', 'spark', 'flink', 'java', 'python', 'scala')

此外，也可以对元组进行重新赋值来改变元组的值

>>> tuple1 = (1,2,3)
>>> tuple1
(1, 2, 3)
>>> tuple1 = (4,5,6)
>>> tuple1
(4, 5, 6)

4.删除元组

元组属于不可变序列，无法删除元组中的部分元素，只能使用del命令删除整个元组对象，具体语法格式如下：

>>> tuple1 = ("hadoop", "spark", "flink", "storm")
>>> del tuple1
>>> tuple1
Traceback (most recent call last):
File "<pyshell#79>", line 1, in <module>
tuple1
NameError: name 'tuple1' is not defined

5.元组推导式

元组推导式的语法格式如下：
(表达式 for 迭代变量 in 可迭代对象 [if 条件表达式] )
其中，[if 条件表达式]不是必须的，可以使用，也可以省略。

生成一个包含数字1到9的元组：

>>> tuple1 = (x for x in range(1,10))
>>> tuple1
<generator object <genexpr> at 0x0000000002C7FC80>

使用元组推导式生成的结果并不是一个元组，而是一个生成器对象，这一点和列表推导式是不同的。
如果我们想要使用元组推导式获得新元组或新元组中的元素，可以使用如下方式：

>>> tuple1 = (x for x in range(1,10))
>>> tuple(tuple1)
(1, 2, 3, 4, 5, 6, 7, 8, 9)

6.元组的常用内置函数

•len(tuple)：计算元组大小，即元组中的元素个数；
•max(tuple) ：返回元组中的元素最大值；
•min(tuple) ：返回元组中元素最小值；
•tuple(seq)：将序列转为元组。

01 # tuple_function.py
02 tuple1 = ("hadoop", "spark", "flink", "storm")
03 #计算元组的大小
04 len_size = len(tuple1)
05 print("元组大小是：",len_size)
06 # 返回元组元素最大值和最小值
07 tuple_number = (1,2,3,4,5)
08 max_number = max(tuple_number)
09 min_number = min(tuple_number)
10 print("元组最大值是：",max_number)
11 print("元组最小值是：",min_number)
12 # 将列表转为元组
13 list1 = ["hadoop", "spark", "flink", "storm"]
14 tuple2 = tuple(list1)
15 # 打印tuple2数据类型
16 print("tuple2的数据类型是：",type(tuple2))

该程序的执行结果如下：
元组大小是： 4
元组最大值是： 5
元组最小值是： 1
tuple2的数据类型是： <class ‘tuple’>

7.元组与列表的区别

（1）列表属于可变序列，可以随时修改或删除列表中的元素，比如使用append()、extend()、insert()向列表添加元素，使用del、remove()和pop()删除列表中的元素。元组属于不可变序列，没有append()、extend()和insert()等方法，不能修改其中的元素，也没有remove()和pop()方法，不能从元组中删除元素，更无法对元组元素进行del操作。
（2）元组和列表都支持切片操作，但是，列表可以使用切片方式来修改其中的元素，而元组则不支持使用切片方式来修改其中的元素。
（3）元组的访问和处理速度比列表快。如果只是对元素进行遍历，而不需要对元素进行任何修改，那么一般建议使用元组而非列表。
（4）作为不可变序列，与整数、字符串一样，元组可以作为字典的键，而列表则不可以。

元组和列表之间进行转换，具体方法如下：
（1）tuple()函数可以接受一个列表作为参数，返回同样元素的元组；
（2）list()函数可以接受一个元组作为参数，返回同样元素的列表。

8.序列封包和序列解包

程序把多个值赋给一个变量时，Python会自动将多个值封装成元组，这种功能被称为“序列封包”。

>>> values = 1, 2, 3
>>> values
(1, 2, 3)
>>> type(values)
<class 'tuple'>

程序允许将序列（元组或列表等）直接赋值给多个变量，此时序列的各元素会被依次赋值给每个变量（要求序列的元素个数和变量的个数相等），这种功能被称为“序列解包”。可以使用序列解包功能对多个变量同时赋值。

下面是一个关于列表的序列解包的实例：

>>> a, b, c = 1, 2, 3
>>> print(a, b, c)
1 2 3

>>> a_list = [1, 2, 3]
>>> x, y, z = a_list
>>> print(x, y, z)
1 2 3

字典

用于存放具有映射关系的数据。
比如有一份学生成绩表数据，语文67分，数学91分，英语
78分，如果使用列表保存这些数据，则需要两个列表，即[“语文”,“数学”,“英语”]和[67,91,78]。但是，使用两个列表来保存这组数据以后，就无法记录两组数据之间的关联关系。为了保存这种具有映射关系的数据，Python 提供了字典，字典相当于保存了两组数据，其中一组数据是关键数据，被称为“键”（key）；另一组数据可通过键来访问，被称为“值”（value）。
字典具有如下特性：
（1）字典的元素是“键值对”，字典中的键不允许重复，必须是唯一值，而且键必须不可变；
（2）字典不支持索引和切片，但可以通过“键”查询“值”；
（3）字典是无序的对象集合，列表是有序的对象集合，两者之间的区别在于，字典当中的元素是通过键来存取的，而不是通过偏移量存取；
（4）字典是可变的，并且可以任意嵌套。

1.字典的创建与删除

字典用大括号{}标识。

>>> grade = {"语文":67, "数学":91, "英语":78} #键是字符串
>>> grade
{'语文': 67, '数学': 91, '英语': 78}
>>> empty_dict = {} #创建一个空字典
>>> empty_dict
{}
>>> dict1 = {(1,2):"male",(1,3):"female"} #键是元组
>>> dict1
{(1, 2): 'male', (1, 3): 'female'}

元组可以作为字典的键，但列表不能作为字典的键，因为字典要求键必须是不可变类型，但列表是可变类型，因此列表不能作为字典的键。
Python还提供了内置函数dict()来创建字典

>>> books = [('hadoop', 132), ('spark', 563), ('flink', 211)]
>>> dict1 = dict(books)
>>> dict1
{'hadoop': 132, 'spark': 563, 'flink': 211}
>>> scores = [['计算机', 85], ['大数据', 88], ['Spark编程', 89]]
>>> dict2 = dict(scores)
>>> dict2
{'计算机': 85, '大数据': 88, 'Spark编程': 89}
>>> dict3 = dict(curriculum='计算机',grade=87) #通过指定参数创建字典
>>> dict3
{'curriculum': '计算机', 'grade': 87}
>>> keys = ["语文","数学","英语"]
>>> values = [67,91,78]
>>> dict4 = dict(zip(keys,values))
>>> dict4
{'语文': 67, '数学': 91, '英语': 78}
>>> dict5 = dict() #创建空字典
>>> dict5
{}

zip()函数用于将可迭代的对象作为参数，将对象中对应的
元素打包成一个个元组，然后返回由这些元组组成的列表

>>> x = [1,2,3]
>>> y = ["a","b","c"]
>>> zipped = zip(x,y)
>>> zipped
<zip object at 0x0000000002CC9D40>
>>> list(zipped)
[(1, 'a'), (2, 'b'), (3, 'c')]

对于不再需要的字典，可以使用del命令删除

>>> grade = {"语文":67, "数学":91, "英语":78}
>>> del grade

使用字典对象的clear()方法清空字典中的所有元素，让字典变成一个空字典

>>> grade = {"语文":67, "数学":91, "英语":78}
>>> grade.clear()
>>> grade
{}

2.访问字典

•通过键访问值；
•通过键添加键值对；
•通过键删除键值对；
•通过键修改键值对；
•通过键判断指定键值对是否存在。

>>> grade = {"语文":67, "数学":91, "英语":78}
>>> grade["语文"]
67

1.Python中推荐的方法是使用字典对象的get()方法获取指定键的值，格式如下：
dictname.get(key[,default])
dictname表示字典对象，key表示指定的键，default是可选项，用于当指定的键不存在时返回一个默认值，如果省略，则返回None。

>>> grade = {"语文":67, "数学":91, "英语":78}
>>> grade.get("数学")
91
>>> grade.get("英语","不存在该课程")
78
>>> grade.get("计算机","不存在该课程")
'不存在该课程'
>>> grade.get("计算机")
>>> #执行结果返回None，屏幕上不可见

2.可以使用字典对象的items()方法获取“键值对”列表，使用字典对象的keys()方法获取“键”列表，使用字典对象的values()方法获取“值”列表

>>> grade = {"语文":67, "数学":91, "英语":78}
>>> items = grade.items()
>>> type(items)
<class 'dict_items'>
>>> items
dict_items([('语文', 67), ('数学', 91), ('英语', 78)])
>>> keys = grade.keys()
>>> type(keys)
<class 'dict_keys'>
>>> keys
dict_keys(['语文', '数学', '英语'])
>>> values = grade.values()
>>> type(values)
<class 'dict_values'>
>>> values
dict_values([67, 91, 78])

可通过list()函数把它们转换成列表

>>> grade = {"语文":67, "数学":91, "英语":78}
>>> items = grade.items()
>>> list(items)
[('语文', 67), ('数学', 91), ('英语', 78)]
>>> keys = grade.keys()
>>> list(keys)
['语文', '数学', '英语']
>>> values = grade.values()
>>> list(values)
[67, 91, 78]

3.通过for循环对items()方法返回的结果进行遍历

>>> grade = {"语文":67, "数学":91, "英语":78}
>>> for item in grade.items():
print(item)
('语文', 67)
('数学', 91)
('英语', 78)
>>> for key,value in grade.items():
print(key,value)
语文 67
数学 91
英语 78

4.Python还提供了pop()方法用于获取指定键对应的值，并删除这个键值对

>>> grade = {"语文":67, "数学":91, "英语":78}
>>> grade.pop("英语")
78
>>> grade
{'语文': 67, '数学': 91}

3.添加、修改和删除字典元素

>>> grade = {"语文":67, "数学":91, "英语":78}
>>> grade["计算机"] = 93
>>> grade
{'语文': 67, '数学': 91, '英语': 78, '计算机': 93}

>>> grade = {"语文":67, "数学":91, "英语":78}
>>> grade
{'语文': 67, '数学': 91, '英语': 78}
>>> grade["语文"] = 88
>>> grade
{'语文': 88, '数学': 91, '英语': 78}

>>> grade = {"语文":67, "数学":91, "英语":78}
>>> del grade["英语"]
>>> grade
{'语文': 67, '数学': 91}

可以使用字典对象的update()方法，用一个字典所包含的键值对来更新己有的字典。在执行update()方法时，如果被更新的字典中己包含对应的键值对，那么原值会被覆盖；如果被更新的字典中不包含对应的键值对，则该键值对被添加进去。具体实例如下：

>>> grade = {"语文":67, "数学":91, "英语":78}
>>> grade.update({"语文":59,"数学":91,"英语":78,"计算机":98})
>>> grade
{'语文': 59, '数学': 91, '英语': 78, '计算机': 98}

4.字典推导式

字典推导式的语法格式如下：
{表达式 for 迭代变量 in 可迭代对象 [if 条件表达式]}

>>> word_list = ["hadoop","spark","hdfs"]
>>> word_dict = {key:len(key) for key in word_list}
>>> word_dict
{'hadoop': 6, 'spark': 5, 'hdfs': 4}

还可以根据列表生成字典，实例如下：

>>> name = ["张三", "李四", "王五", "李六"] #名字列表
>>> title = ["教授", "副教授", "讲师", "助教"] #职称列表
>>> dict1 = {i : j for i, j in zip(name, title)} #字典推导式
>>> dict1
{'张三': '教授', '李四': '副教授', '王五': '讲师', '李六': '助教'}

集合

集合（set）是一个无序的不重复元素序列。集合中的元素必须是不可变类型。

>>> dayset = {'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday',
'Saturday', 'Sunday'}
>>> dayset
{'Tuesday', 'Monday', 'Wednesday', 'Saturday', 'Thursday', 'Sunday',
'Friday'}

在创建集合时，如果存在重复元素，Python只会自动保留一个，实例如下：

>>> numset = {2,5,7,8,5,9}
>>> numset
{2, 5, 7, 8, 9}

集合推导式

>>> squared = {x**2 for x in [1, 2, 3]}
>>> squared
{1, 4, 9}

1.集合的创建与删除

使用set()函数将列表、元组、range对象等其他可迭代对象转换为集合，语法格式如下：
setname = set(iteration)

>>> set1 = set([1,2,3,4,5]) #从列表转换得到集合
>>> set1
{1, 2, 3, 4, 5}
>>> set2 = set((2,4,6,8,10)) #从元组转换得到集合
>>> set2
{2, 4, 6, 8, 10}
>>> set3 = set(range(1,5)) #从range对象转换得到集合
>>> set3
{1, 2, 3, 4}
>>> set4 = set("自强不息，止于至善") #从字符串转换得到字符集合
>>> set4
{'于', '息', '善', '强', '至', '不', '止', '自', '，'}

创建一个空集合必须用set()而不是{}，因为{}是用来创建
一个空字典。

当不再使用某个集合时，可以使用del命令删除整个集合。实例如下：

>>> numset = {1,2,3,4,5}
>>> del numset

2.集合元素的添加与删除

可以使用add()方法向集合中添加元素，被添加的元素只能是字符串、数字及布尔类型的True或者False等，不能是列表、元组等可迭代对象。如果被添加的元素已经在集合中存在，则不进行任何操作。实例如下：

>>> bookset = {"hadoop","spark"}
>>> bookset
{'spark', 'hadoop'}
>>> bookset.add("flink")
>>> bookset
{'flink', 'spark', 'hadoop'}
>>> bookset.add("spark")
>>> bookset
{'flink', 'spark', 'hadoop'}

可以使用pop()、remove()方法删除集合中的一个元素，使用clear()方法清空集合中的所有元素。

>>> numset = {1,2,3,4,5}
>>> numset.pop()
1
>>> numset
{2, 3, 4, 5}
>>> numset.remove(4)
>>> numset
{2, 3, 5}
>>> numset.clear()
>>> numset
set()

3.集合的并集、交集与差集操作

集合包括并集、交集、差集等操作。所谓并集是指把两个集合中的元素合并在一起，并且去除重复的元素。所谓交集是指取出两个集合中相同的元素。所谓差集是指，对于集合A和B，集合A中的元素在集合B中有重复时，去掉重复元素后集合A中剩余的元素就是A与B的差集。

>>> a = set('abc')
>>> b = set('cdef')
>>> a | b #并集
{'e', 'f', 'c', 'b', 'd', 'a'}
>>> a & b #交集
{'c'}
>>> a - b #差集
{'b', 'a'}
>>> a.intersection(b) #交集
{'c'}
>>> a.difference(b) #差集
{'b', 'a'}