暑假Python基础整理 -- 元组和列表-CSDN博客

序列概述

序列是一块用于存储多个值的连续内存空间，并且按一定顺序排序，每个元素都被分配一个数字，称为索引或位置。序列结构主要有：列表、元组、集合、字典和字符串，其中集合和字典不支持索引、切片、相加和相乘操作

索引（index）

每个元素都有一个编号，称为索引，索引是从0开始编号的，即下标为0表示第一个元素，而下标为1表示第二个元素，以此类推，第n个元素的下标为n-1

索引可以为负数，当下标为负数时表示从右往左计数，它将从-1开始编号。即最后一个元素索引为-1，而倒数第二个元素索引为-2，以此类推，倒数第n个元素索引为-n

切片（slice）

切片操作是访问序列中元素的另一种方法，它可以访问一定范围的元素，切片操作可以生成一个新的序列，实现切片的语法如下：

sname[start : end : step]

sname：表示序列名称
start：指定切片的开始位置（包含此位置），若省略，默认为0
end：指定切片的截止位置(不包含此位置)，若省略，默认为序列的长度
step：指定切片的步长，若省略，默认步长为1，当省略该步长时，最后一个冒号可以同时省略

若想复制整个序列，则可以将start和end的参数省略，只保留中间的冒号。如 lis[:] 表示复制整个名称为lis的序列。

序列相加（addition）

Python支持多个同类型的序列进行加法运算。即将各个相同类型的序列进行连接，而不会去除重复元素（去重），例如：

a = [1,2,3,4,5]
b = [3,4,5,6,7]
c = a + b
print(c)
'''运行结果为：[1,2,3,4,5,3,4,5,6,7]'''

同类型的序列只需序列类型相同即可，与元素类型无关

乘法（multiplication）

数字n乘以一个序列会生成一个新的序列，新序列的内容为原来序列被重复n次的结果。例如：

lis = ["Hello","World"]
print(lis * 3)
'''输出结果为：["Hello","World","Hello","World","Hello","World"]'''

检查某个元素是否是序列的成员（元素）

使用 in 关键字检查某个元素是否是序列成员，也可以使用 not in 关键字实现检查某个元素是否未被包含在指定序列中。示例如下：

lis = ["小明","小兰","小刘"]
print("小张" in lis)          # 输出为 False
print("小张" not in lis)      # 输出为 True

序列常见的内置函数

函数	说明
len(序列名)	计算序列的长度
max(序列名)	计算序列中的最大元素
min(序列名)	计算序列中的最小元素
list(序列名)	将序列转换为列表
str(序列名)	将序列转换为字符串
sum(序列名)	计算元素和
sorted(序列名)	对元素进行排序
reversed(序列名)	反向序列中的元素
enumerate(序列名)	将序列组成为一个索引序列，多用在for循环

列表（list）

列表是由一系列按照特定顺序排序的元素组成的。它是可变序列，列表的元素都放在一对“[]”内，相邻元素之间使用逗号,间隔，同一列表中，元素的类型可以不同。

创建列表

使用赋值运算符直接创建列表：使用赋值运算符=直接将一个列表赋值给变量，语法格式如下：

listname = [element_1, element_2, element_3,...,element_n]

创建空列表：通常有两种方式

'''创建空列表'''
listname_1 = []
listname_2 = list()

创建数值列表：可以使用list函数直接将range()函数循环出来的结果转为列表。例如：创建一个10-20的所有偶数的列表，代码如下：

lis = list(range(10,21,2))
print(lis)
'''代码运行结果为：[10, 12, 14, 16, 18, 20]'''

删除列表：可以使用语句del listname删除列表。

Python自带垃圾回收机制，会自动销毁不用的列表，所以即使不用del删除，它也会自动回收它们

访问列表元素

若要输出列表的内容，直接使用print()函数

print(listname)   # listname 为列表名

也可以通过列表的索引获取指定的元素，例如：

lis = [10,20,30,40,50]
print(lis[3])   # 输出结果为 40

在执行输出的结果中可以看出，在输出单个列表元素时不包括中括号，如果是字符串，还不包括引号

最后还可以通过切片的方式访问列表元素，语法格式及示例如下：

lis = [1,2,3,4,5,6,7,8,9]
print(lis[::-1])         # 输出结果为：[9, 8, 7, 6, 5, 4, 3, 2, 1]
print(lis[2:8:2])        # 输出结果为：[3, 5, 7]

遍历列表

直接使用for循环实现遍历列表，只能输出元素的值。例如：

for item in listname:
	print(item)

使用for循环和enumerate()函数实现同时输出索引值和元素内容。其语法格式如下：

for index,item in enumerate(listname):
	  print(index,item)

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

添加元素：通过“+”将两个序列进行拼接，执行速度要比直接使用列表对象的append()方法慢。语法格式如下：

'''列表对象.append(对象)'''
listname.append(obj)

Python提供了insert()方法向列表中指定位置添加元素，但是insert()方法效率没有append()方法高。其insert()方法如下：

'''列表对象.insert(索引位置,元素)'''
listname.insert(index,obj)

若要将一个列表的所有元素添加到另一个列表中，可以使用extend()方法实现，extend()的语法格式如下：

'''列表对象1.extend(列表对象2)'''
listname_1.extend(listname_2)

修改元素：可以通过索引获取元素，再对该元素进行重新赋值即可。如下示例：

'''列表对象[索引] = 修改元素'''
lis = [1,2,3,4,5]
lis[2] = -3
print(lis)          # 输出结果为：[1,2,-3,4,5]

删除元素：若已知所需删除元素的索引位置，则可以根据索引进行删除，则可以使用del方法或者pop方法，语法格式如下：

'''列表对象.pop(索引)'''
listname.pop(index)

'''del 列表对象[索引]'''
del listname[index]

若需删除元素的索引位置未知，则可以根据元素值进行删除，其语法格式如下：

'''列表对象.remove(元素值)'''
listname.remove(value)

对列表进行统计计算

listname.count(obj) ：统计元素obj在列表对象listname中出现的次数，count()方法只能进行精确匹配，所以obj不能是元素的一部分。如下示例：

lis = [1,2,3,4,2,5,2,6]
print(lis.count(2))      # 输出结果为3

listname.index(obj)：查询元素obj在列表对象listname中首次出现的位置索引。示例如下：

lis = list(range(1,10))
print(lis.index(5))     # 执行结果为4

当使用index(obj)方法查找索引时，若该元素不存在于列表，将会抛出如下异常：

Traceback (most recent call last):
  File ".\test.py", line 3, in <module>
    print(lis.index(-5))
          ~~~~~~~~~^^^^
ValueError: -5 is not in list

sum(listname[,start])：统计数值列表listname的元素和，从start开始计数，start默认为0，示例如下：

lis = [1,2,3,4,5]
print(sum(lis))     # 输出结果为15
print(sum(lis,5))   # 输出结果为20

这里sum(lis,5)中的5表示它从5开始计数，等同于sum(lis)+5，而并非从第5个元素开始计数

对列表进行排序

Python提供了两种对列表的排序方法：

使用列表对象的sort()方法
使用内置的sorted()函数

列表提供的sort()方法是在原列表上进行排序，排序后元素的顺序将发生改变，其语法格式如下：

listname.sort(key=None, reverse=False)
"""
lsitname：需要排序的列表名称
key：（可选参数）表示指定一个从每个列表元素中提取一个比较键
reverse：（可选参数）True表示降序，False表示升序，默认为升序排序
"""

注意：若列表中存在中文，则不能直接使用sort方法

Python提供的内置的sorted()函数也可以实现排序，但是sorted()方法不修改源列表的排序，它会建立一个副本进行排序，所以排序后用一个变量来接收副本。语法如下：

sort_name = listname.sorted(key=None, reverse=False)
print(sort_name)
"""
listname：需要排序的列表名称
sort_name：接收排序后的副本的列表名
key：（可选参数）表示指定一个从每个列表元素中提取一个比较键
reverse：（可选参数）True表示降序，False表示升序，默认为升序排序
"""

列表推导式

生成指定范围的数值列表，语法格式如下：

'''列表名 = [表达式 for 循环变量 in range(起始值,截止值,步长)]'''
listname = [expression for var in range(start,end,step)]

根据列表生成指定需求的列表，语法格式如下：

'''新列表名 = [表达式 for 循环变量 in 旧列表名]'''
newlist = [expression for var in oldlist]

从列表中选择符合条件的元素组成新的列表，语法格式如下：

'''新列表名 = [表达式 for 循环变量 in 旧列表名 if 条件]'''
newlist = [expression for var in oldlist if condition]

元组（tuple）

元组的所有元素都放在一对“()”中，两个相邻元素之间以,间隔。元组用于保存程序中不可修改的内容。

元组是不可变序列，而列表是可变序列，元组中的元素不可以单独修改，而列表则可以任意修改。

元组的创建与删除

可以使用赋值运算符直接创建元组，使用=直接将元组赋值给变量，语法格式如下：

tuplename = (element_1, element_2, element_3,...,element_n)
# "()" 并非必需，可以将其省略。如下：
tuplename = element_1, element_2, element_3,...,element_n

注意：若要创建的元组只包含一个元素，则需要在定义元组时，在元素后面添加一个逗号

verse_1 = ("2408",)
verse_2 = ("2408")
print("verse_1的类型为：",type(verse_1))
print("verse_2的类型为：",type(verse_2))
"""
输出结果为：
verse_1的类型为：<class 'tuple'>
verse_2的类型为：<class 'str'>
"""

创建空元组存在两种方式，如下所示：

tuple_1 = ()
tuple_2 = tuple()

创建数值元组：可以使用tuple函数直接将range()函数循环出来的结果转为元组。例如：创建一个10-20的所有偶数的元组，代码如下：

tuplename= tuple(range(10,21,2))
print(tuplename)
'''代码运行结果为：(10, 12, 14, 16, 18, 20)'''

删除元组：可以使用语句del tuplename删除元组。

Python自带垃圾回收机制，会自动销毁不用的元组，所以即使不用del删除，它也会自动回收它们

访问元组元素

若要输出元组的内容，直接使用print()函数

print(tuplename)   # tuplename 为元组名

也可以通过元组的索引获取指定的元素，例如：

tuplename = (10,20,30,40,50)
print(tuplename[3])   # 输出结果为 40

在执行输出的结果中可以看出，在输出单个元组元素时不包括小括号，如果是字符串，还不包括引号

最后还可以通过切片的方式访问元组元素，语法格式及示例如下：

tup = (1,2,3,4,5,6,7,8,9)
print(tup[::-1])         # 输出结果为：(9, 8, 7, 6, 5, 4, 3, 2, 1)
print(tup[2:8:2])        # 输出结果为：(3, 5, 7)

遍历元组

直接使用for循环实现遍历元组，只能输出元素的值。例如：

for item in tuplename:
	  print(item)

使用for循环和enumerate()函数实现同时输出索引值和元素内容。其语法格式如下：

for index,item in enumerate(tuplename):
	  print(index,item)

修改元组

元组是不可变序列，所以我们不能对元组的单个元素值进行修改，但是我们可以的使用对元组重新赋值的方式达到修改元组的目的。如下代码所示：

tup = (1,2,3,4)     # 定义元组
tup = (1,2,3,4,5)   # 对元组重新赋值

元组也支持连接组合，即在已定义的元组后面连接新的元组（连接对象必须为元组）。代码如下：

tup = (1,2,3,4)
tup = tup + (5,6,7)
print(tup)          # 输出为：(1,2,3,4,5,6,7)

元组推导式

元组推导式类似于列表推导式，但是元组推导式生成的结果并不是一个元组，而是一个生成器对象，若要使用该生成器对象，则需要将其转换为元组或者列表；也通过for循环遍历该生成器对象，或者直接使用__next__()方法进行遍历。示例代码如下：

serse = (i for i in range(5))
print(serse)
'''输出结果为：<generator object <genexpr> at 0x0000027FC7565B40>'''
tup = tuple(serse)
print(tup)
'''输出结果为：(0, 1, 2, 3, 4)'''