python 序列类型list示例详解

更新时间：2024年04月17日 10:00:07 作者：小吉猫

列表（List）是一种有序的集合,可以包含任意类型的对象：数字、字符串甚至其他列表等,列表是可变的,这意味着我们可以添加、删除或更改列表中的元素,这篇文章主要介绍了python 序列类型list示例详解,需要的朋友可以参考下

列表定义

列表（List）是一种有序的集合，可以包含任意类型的对象：数字、字符串甚至其他列表等。列表是可变的，这意味着我们可以添加、删除或更改列表中的元素。

列表 list 构建

list 构建方法

使用一对方括号来表示空列表: []

使用方括号，其中的项以逗号分隔: [a], [a, b, c]

使用列表推导式: [x for x in iterable]

使用类型的构造器: list() 或 list(iterable)

示例

# 创建一个空列表
my_list = []
# 创建一个包含整数的列表
number_list = [1, 2, 3, 4, 5]
# 创建一个包含字符串的列表
string_list = ["apple", "banana", "orange"]
# 创建一个包含不同类型元素的列表
mixed_list = [1, "hello", True, 3.14 , [1, 2, 3]]

列表索引访问

索引说明

使用append(object)方法在列表末尾添加一个元素，返回None。返回None就意味着没有新的列表产生，就地修改。时间复杂度是O(1)。因为它只是在列表的末尾添加一个元素，不会受到列表长度的影响。
使用insert(index, object)方法在指定位置添加一个元素，返回None。返回None就意味着没有新的列表产生，就地修改。时间复杂度是O(n)。其中n是列表的长度。因为在插入元素后，后面的元素需要向后移动以腾出空间。
使用extend(iteratable) 方法，将可迭代对象的元素追加进来，返回None。可以将一个列表中的元素逐个添加到另一个列表的末尾。就地修改。时间复杂度为O(k)，其中k是要添加到列表的元素数量。由于它需要逐个添加元素，时间复杂度取决于要添加的元素数量。
使用加号(+)运算符，连接操作，将两个列表连接起来。产生新的列表，原列表不变。本质上调用的是__add__()方法。时间复杂度为O(m+n)，其中m和n分别是两个列表的长度。因为它需要创建一个新的列表，并将原列表的元素逐个复制到新列表中。
使用列表解析，可以使用列表解析来添加元素到列表中。通常为O(n)，其中n是生成的新列表的长度。

示例

my_list = ['apple', 'banana', 'cherry', 'date']
# 使用正数索引获取第二个元素
print(my_list[1])  # 输出: banana
# 使用负数索引获取倒数第二个元素
print(my_list[-2]) # 输出: cherry

列表元素修改

可以通过索引直接修改列表中的元素。

示例

my_list = ['apple', 'banana', 'cherry', 'date']
# 修改列表中的第一个元素
my_list[0] = 'apricot'
print(my_list)  # 输出: ['apricot', 'banana', 'cherry', 'date']

列表添加元素

示例

my_list = [1, 20, 3]
my_list.append(4)
print(my_list)  # 输出 [1, 20, 3, 4]
my_list.insert(1, 15)
print(my_list)  # 输出 [1, 15, 20, 3, 4]
list1 = [1, 2, 3]
list2 = [4, 5, 6]
list1.extend(list2)
print(list1)  # 输出：[1, 2, 3, 4, 5, 6]
list1 = [1, 2, 3]
list2 = [4, 5, 6]
concatenated_list = list1 + list2
print(concatenated_list)  # 输出：[1, 2, 3, 4, 5, 6]
my_list = [x for x in range(5)]
print(my_list)  # 输出：[0, 1, 2, 3, 4]

列表元素重复次数

在Python中，使用乘号*可以将列表中的元素重复指定次数。这种操作会复制列表中的元素，然后按照指定次数进行重复。对于列表乘法操作，时间复杂度取决于乘法操作符左侧列表的长度和乘数。因此，如果原始列表长度为n，重复次数为m，则列表乘法的时间复杂度为O(n * m)。

修改重复后的列表不会影响原始列表。例如，对重复列表进行修改不会改变原始列表中的元素。

乘法操作符只是复制列表中的引用，而不是复制对象本身。如果列表中的元素是可变对象（如列表或字典），修改其中一个列表的元素也会影响到另一个列表。这种浅拷贝行为可能会导致意外结果。

示例

my_list = [1, 2, 3]
repeated_list = my_list * 3
print(repeated_list)  # 输出：[1, 2, 3, 1, 2, 3, 1, 2, 3]
repeated_list = my_list * 3
repeated_list[0] = 5
print(repeated_list)  # 输出：[5, 2, 3, 5, 2, 3, 5, 2, 3]
print(my_list)  # 输出：[1, 2, 3]

my_list = [[1, 2], [3, 4]]
repeated_list = my_list * 2
repeated_list[0][0] = 5
print(repeated_list)  # 输出：[[5, 2], [3, 4], [5, 2], [3, 4]]
print(my_list)  # 输出：[[5, 2], [3, 4]]

列表合并

使用加号操作符 (+)

这种方法最直观，适用于少量列表的快速合并。

list1 = [1, 2, 3]
list2 = [4, 5, 6]
merged_list = list1 + list2
print(merged_list)  # 输出: [1, 2, 3, 4, 5, 6]

使用 extend() 方法

原地（in-place）修改列表，可以使用 extend() 方法，它会将一个列表的所有元素添加到另一个列表的末尾。

list1 = [1, 2, 3]
list2 = [4, 5, 6]
list1.extend(list2)
print(list1)  # 输出: [1, 2, 3, 4, 5, 6]

使用列表推导式

需要在合并时对元素进行某些操作时，可以使用列表推导式来连接列表。

list1 = [1, 2, 3]
list2 = [4, 5, 6]
merged_list = [item for sublist in [list1, list2] for item in sublist]
print(merged_list)  # 输出: [1, 2, 3, 4, 5, 6]

使用 itertools.chain()

itertools.chain() 方法可以用于更高效地合并大量列表，它返回一个迭代器。这个方法在处理大量数据时很有帮助，因为它不会立即创建一个新列表，而是通过迭代器按需生成元素。

import itertools
list1 = [1, 2, 3]
list2 = [4, 5, 6]
merged_list = list(itertools.chain(list1, list2))
print(merged_list)  # 输出: [1, 2, 3, 4, 5, 6]

使用星号操作符 (*)

这种方式不仅可以用于列表合并，还可以用于合并元组、集合等可迭代对象，提供很好的灵活性和可读性。

list1 = [1, 2, 3]
list2 = [4, 5, 6]
merged_list = [*list1, *list2]
print(merged_list)  # 输出: [1, 2, 3, 4, 5, 6]

列表删除元素

使用del语句通过索引删除元素。
使用pop([index])方法删除元素。不指定索引index，就从列表尾部弹出一个元素。指定索引index，就从索引处弹出一个元素，索引超界抛出IndexError错误。
使用remove(value)方法从左至右查找第一个匹配value的值，移除该元素，返回None。就地修改。
使用clear()方法删除所有元素。清除列表所有元素，剩下一个空列表。

my_list = [1, 15, 20, 3, 4]
del my_list[1]
print(my_list)  # 输出 [1, 20, 3, 4]
popped_item = my_list.pop(2)
print(popped_item)  # 输出 3
print(my_list)  # 输出 [1, 20, 4]
my_list.remove(20)
print(my_list)  # 输出 [1, 4]
my_list.clear()
print(my_list)  # 输出 []

列表切片

切片（slice）：切片允许你获取列表中的一个子集。切片使用起始索引和结束索引来指定要提取的元素范围，但不包括结束索引所指向的元素。你可以使用list[start:end]的形式来获取从start到end-1索引范围内的元素。如果省略起始索引，Python会从列表的开头开始。如果省略结束索引，Python会一直取到列表末尾。

my_list = ['apple', 'banana', 'cherry', 'date']
# 使用切片获取列表中的前两个元素
print(my_list[:2])  # 输出: ['apple', 'banana']
# 使用切片获取列表中的最后两个元素
print(my_list[-2:]) # 输出: ['cherry', 'date']
# 使用切片获取列表中的第二个到倒数第二个元素
print(my_list[1:-1])# 输出: ['banana', 'cherry']
# 使用步长为2获取列表中的奇数索引元素
print(my_list[::2])  # 输出: ['apple', 'cherry']
# 使用步长为2获取列表中的偶数索引元素
print(my_list[1::2]) # 输出: ['banana', 'date']
# 使用负步长翻转列表
print(my_list[::-1]) # 输出: ['date', 'cherry', 'banana', 'apple']

列表循环

for item in my_list:
    print(item)

列表推导式

squares = [x**2 for x in range(10)]
print(squares)  # 输出 [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

列表复制

复制列表主要有两种方式：浅拷贝（Shallow Copy）和深拷贝（Deep Copy）。
浅拷贝的方法：直接赋值、列表的copy()方法、切片操作符[:]、或者list()构造函数。
深拷贝的方法：copy模块中的deepcopy()函数

示例

original_list = [1, 2, [3, 4]]
shallow_copied_list = original_list
print(original_list == shallow_copied_list)  # 输出 True
# 修改浅拷贝后的列表
shallow_copied_list[0] = 5
shallow_copied_list[2][0] = 6
print(original_list)  # 输出 [1, 2, [6, 4]]
print(shallow_copied_list)  # 输出 [5, 2, [6, 4]]

import copy
original_list = [1, 2, [3, 4]]
deep_copied_list = copy.deepcopy(original_list)
print(original_list == deep_copied_list)  # 输出 True
# 修改深复制后的列表
deep_copied_list[0] = 5
deep_copied_list[2][0] = 6
print(original_list)  # 输出 [1, 2, [3, 4]]
print(deep_copied_list)  # 输出 [5, 2, [6, 4]]

列表查询

列表查询通常指的是查找特定元素在列表中的索引或值。常见的列表查询方法包括使用index()方法或者遍历整个列表进行查找。使用count()方法用于计算列表中某个元素出现的次数。

index(value,[start,[stop]])

使用index()方法可以查找指定元素在列表中的索引。

这种方法的时间复杂度为O(n)，其中n为列表的长度。在最坏情况下，需要遍历整个列表才能找到目标元素，因此时间复杂度为O(n)。

my_list = [1, 2, 3, 4, 5]
index = my_list.index(3)
print(index)  # 输出：2

count(value)

列表查询中的count()方法用于计算列表中某个元素出现的次数。这个方法会遍历整个列表，并统计指定元素出现的次数。

count()方法的时间复杂度也为O(n)，其中n为列表的长度。因为该方法需要遍历整个列表来统计指定元素的数量，所以在最坏的情况下，需要对列表中的每个元素进行比较。

my_list = [1, 2, 2, 3, 3, 3]
count = my_list.count(3)
print(count)  # 输出：3

列表反转

可以使用reverse()方法对列表进行反转。将列表元素反转，返回None。就地修改。

示例

my_list = [1, 2, 3, 4, 5]
my_list.reverse()
print(my_list)  # 输出：[5, 4, 3, 2, 1]

列表排序

使用sort(key=None, reverse=False)方法可以对列表进行排序，就地修改，默认是升序排列。可以通过传递reverse=True参数进行降序排序。key一个函数，指定key如何排序。

对于包含字符串的列表，排序默认按照字母顺序排序，可以通过key参数传递自定义的排序函数。

如果想要在不改变原始列表的情况下返回一个新的有序列表，可以使用sorted()函数。

示例

my_list = [3, 1, 4, 1, 5, 9, 2, 6]
my_list.sort()
print(my_list)  # 输出：[1, 1, 2, 3, 4, 5, 6, 9]
my_list.sort(reverse=True)
print(my_list)  # 输出：[9, 6, 5, 4, 3, 2, 1, 1]
str_list = ['apple', 'banana', 'orange', 'grape']
str_list.sort(key=len)  # 按照字符串长度排序
print(str_list)  # 输出：['apple', 'grape', 'banana', 'orange']

my_list = [3, 1, 4, 1, 5, 9, 2, 6]
sorted_list = sorted(my_list)
print(my_list)      # 输出：[3, 1, 4, 1, 5, 9, 2, 6]
print(sorted_list)  # 输出：[1, 1, 2, 3, 4, 5, 6, 9]

列表的其它操作

运算	结果：	备注
`x in s`	如果 s 中的某项等于 x 则结果为 `True`，否则为 `False`
`x not in s`	如果 s 中的某项等于 x 则结果为 `False`，否则为 `True`
`s + t`	s 与 t 相拼接
`s * n` 或 `n * s`	相当于 s 与自身进行 n 次拼接
`s[i]`	s 的第 i 项，起始为 0
`s[i:j]`	s 从 i 到 j 的切片
`s[i:j:k]`	s 从 i 到 j 步长为 k 的切片
`len(s)`	s 的长度
`min(s)`	s 的最小项
`max(s)`	s 的最大项
`s.index(x[, i[, j]])`	x 在 s 中首次出现项的索引号（索引号在 i 或其后且在 j 之前）	(8)
`s.count(x)`	x 在 s 中出现的总次数

`s[i] = x`	将 s 的第 i 项替换为 x
`s[i:j] = t`	将 s 从 i 到 j 的切片替换为可迭代对象 t 的内容
`del s[i:j]`	等同于 `s[i:j] = []`
`s[i:j:k] = t`	将 `s[i:j:k]` 的元素替换为 t 的元素
`del s[i:j:k]`	从列表中移除 `s[i:j:k]` 的元素
`s.append(x)`	将 x 添加到序列的末尾 (等同于 `s[len(s):len(s)] = [x]`)
`s.clear()`	从 s 中移除所有项 (等同于 `del s[:]`)
`s.copy()`	创建 s 的浅拷贝 (等同于 `s[:]`)
`s.extend(t)` 或 `s += t`	用 t 的内容扩展 s (基本上等同于 `s[len(s):len(s)] = t`)
`s *= n`	使用 s 的内容重复 n 次来对其进行更新
`s.insert(i, x)`	在由 i 给出的索引位置将 x 插入 s (等同于 `s[i:i] = [x]`)
`s.pop()` 或 `s.pop(i)`	提取在 i 位置上的项，并将其从 s 中移除
`s.remove(x)`	删除 s 中第一个 `s[i]` 等于 x 的项目。
`s.reverse()`	就地将列表中的元素逆序。

常用方法

append(): 添加一个元素到列表的末尾。
extend(): 扩展列表，添加多个元素到末尾。
insert(): 在指定位置插入一个元素。
remove(): 删除列表中的一个元素。
pop(): 删除并返回列表中的一个元素。
clear(): 清空列表。
index(): 返回列表中第一个匹配元素的索引。
count(): 返回列表中匹配元素的数量。
sort(): 对列表进行排序。
reverse(): 反转列表。

参考文档

https://docs.python.org/zh-cn/3.12/library/stdtypes.html#/list

到此这篇关于python 序列类型list示例详解的文章就介绍到这了,更多相关python 序列类型内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

python实现ping的方法
这篇文章主要介绍了python实现ping的方法,以实例形式较为详细的分析了Python发送ICMP数据包实现ping功能的相关技巧,需要的朋友可以参考下
2015-07-07
Flask + MySQL如何实现用户注册,登录和登出的项目实践
本文主要介绍了Flask + MySQL 如何实现用户注册,登录和登出的项目实践,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2022-06-06
Python实现TCP协议下的端口映射功能的脚本程序示例
端口映射一个最基本的运作形态就是通过一个中间端口将一个端口发送的数据全部转给另一个端口,well,这里我们就来看一下Python实现TCP协议下的端口映射功能的脚本程序示例
2016-06-06
Python远程开发环境部署与调试过程图解
这篇文章主要介绍了Python远程开发环境部署与调试过程图解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
2019-12-12
Python实现随机生成手机号及正则验证手机号的方法
这篇文章主要介绍了Python实现随机生成手机号及正则验证手机号的方法,涉及Python基于random模块的随机数以及基于re模块的正则验证相关操作技巧,需要的朋友可以参考下
2018-04-04
Python中psutil的介绍与用法
这篇文章主要给大家介绍了关于Python中psutil的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用Python具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
2019-05-05
python学生信息管理系统
这篇文章主要为大家详细介绍了python学生信息管理系统，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2018-03-03
YOLOv5改进教程之添加注意力机制
注意力机制最先被用在NLP领域,Attention就是为了让模型认识到数据中哪一部分是最重要的,为它分配更大的权重,获得更多的注意力在一些特征上,让模型表现更好,这篇文章主要给大家介绍了关于YOLOv5改进教程之添加注意力机制的相关资料,需要的朋友可以参考下
2022-06-06
Python异步编程之协程任务的调度操作实例分析
这篇文章主要介绍了Python异步编程之协程任务的调度操作,结合实例形式分析了Python异步编程中协程任务的调度相关原理、实现方法与操作注意事项,需要的朋友可以参考下
2020-02-02
初步讲解Python中的元组概念
这篇文章主要介绍了初步讲解Python中的元组概念,是Python入门中的基础知识,需要的朋友可以参考下
2015-05-05