1. Toy模板网首页
  2. > Toy博客

Python列表：灵活多变的数据结构

9月前 作者：xiaobuding_QAQ 分类：Toy博客 阅读(41) 违法举报

这篇具有很好参考价值的文章主要介绍了Python列表：灵活多变的数据结构。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

一、列表

在Python 3中，列表是一种有序的集合，它包含了多个元素并且每个元素可以是任意类型的数据。列表使用方括号 [ ] 来表示，其中的元素由逗号 , 分隔开。

1.创建列表

首先，我们可以创建一个空的列表：

# 创建一个空列表
my_list = []

然后，我们创建一个包含多个元素的列表

# 创建一个列表
my_list = [1, 2, 3, 'apple', 'banana']

2.访问列表元素

序列中的每个值都有对应的位置值，称之为索引，第一个索引是 0，第二个索引是 1，依此类推。我们可以使用 [] 运算符来访问列表中的元素。在 [] 中指定索引值，例如：

# 创建一个列表
my_list = [1, 2, 3, 'apple', 'banana']

# 访问列表元素
print(my_list[0])  # 输出：1
print(my_list[1])  # 输出：2

索引也可以从尾部开始，最后一个元素的索引为 -1，往前一位为 -2，以此类推。

# 创建一个列表
my_list = [1, 2, 3, 'apple', 'banana']

# 访问列表元素
print(my_list[-1])  # 输出：banana
print(my_list[-2])  # 输出：apple

如果索引值超出了列表的范围，将引发一个 IndexError 异常。

# 创建一个列表
my_list = [1, 2, 3, 'apple', 'banana']

# 访问列表元素
print(my_list[-8])

输出结果：

Python列表：灵活多变的数据结构,Python学习,python,开发语言,学习
我们还可以采用列表切片来检索一个范围的元素，使用 : 运算符来定位要检索的开始索引（包含）和结束索引（不包含）。

# 创建一个列表
my_list = [1, 2, 3, 'apple', 'banana']

# 访问列表元素
print(my_list[1:3])  # 输出：[2, 3]

这里需要注意：切片操作包括从开始索引所指示的元素开始，一直到结束索引所指示的元素，但不包括最终索引所指示的元素。如果没有指定开始索引，将使用列表的第一个元素作为默认开始索引；如果没有指定结束索引，则将使用列表中的最后一个元素作为默认结束索引。

我们还可以使用负数索引来访问列表中的元素。

my_list = [1, 2, 3, 'apple', 'banana']

# 访问列表元素
print(my_list[:-2])  # 输出：[1, 2, 3]

3.修改列表元素

列表中的元素是可变的，可以通过赋值运算符 = 来更改。

# 创建一个列表
my_list = [1, 2, 3, 'apple', 'banana']

# 修改列表元素
my_list[0] = '4'
print(my_list)  # 输出：[4, 2, 3, 'orange', 'banana']

我们也可以使用切片操作将多个元素同时更改：

# 创建一个列表
my_list = [1, 2, 3, 'apple', 'banana']

# 修改列表元素
my_list[0:2] = [4,5]
print(my_list)  # 输出：[4, 5, 3, 'orange', 'banana']

4.添加元素

在列表的末尾添加一个元素，可以使用 append() 方法：

# 创建一个列表
my_list = [1, 2, 3, 'apple', 'banana']

# 添加元素
my_list.append(4)
print(my_list) # 输出：[1, 2, 3, 'apple', 'banana', 4]

如果你想在列表的任意位置添加元素，可以使用 insert() 方法。

# 创建一个列表
my_list = [1, 2, 3, 'apple', 'banana']

# 添加元素
my_list.insert(1, 4)
print(my_list) # 输出：[1, 4, 2, 3, 'apple', 'banana']

insert() 方法用于将指定元素插入到列表的指定位置，语法如下：

list.insert(index, element)
# index 表示要插入的位置索引。
# element 表示要插入的元素。

5.删除元素

如果是删除指定位置的元素，可以采用del关键字或者pop()方法

del关键字

# 创建一个列表
my_list = [1, 2, 3, 'apple', 'banana']

# 删除元素
del my_list[1]
print(my_list) # 输出：[1, 3, 'apple', 'banana']

pop()方法

# 创建一个列表
my_list = [1, 2, 3, 'apple', 'banana']

# 删除元素
my_list.pop(1)
print(my_list) # 输出：[1, 3, 'apple', 'banana']

如果是删除列表中的指定元素，还可以使用remove() 方法

# 创建一个列表
my_list = [1, 2, 3, 'apple', 'banana']

# 删除元素
my_list.remove(1)
print(my_list) # 输出：[2, 3, 'apple', 'banana']

二、列表脚本操作符

1.连接运算符 +

连接运算符 + 用于将两个列表连接成一个新的列表。

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

2.重复运算符 *

重复运算符 * 用于将列表的元素重复多次。

list1 = [1, 2, 3]
result = list1 * 2
print(result)  # 输出：[1, 2, 3, 1, 2, 3]

三、列表函数&方法

1.函数

1.1 len() 函数

len()函数的作用是返回列表中元素的个数。

# 创建一个列表
my_list = [10, 20, 30, 40, 50]

# 使用 len() 函数获取列表中元素的个数
length = len(my_list)
print(length)  # 输出：5

1.2 max() 函数

max() 函数的作用是返回列表中元素的最大值。

# 创建一个列表
my_list = [10, 20, 30, 40, 50]

# 使用 max() 函数获取列表中的最大值
max_value = max(my_list)
print(max_value)  # 输出：50

1.3 min() 函数

min() 函数的作用是返回列表中元素的最小值。

# 创建一个列表
my_list = [10, 20, 30, 40, 50]

# 使用 min() 函数获取列表中的最小值
min_value = min(my_list)
print(min_value)  # 输出：10

1.4 sum() 函数

sum函数的作用是返回列表中所有元素的总和。

# 创建一个列表
my_list = [10, 20, 30, 40, 50]

# 使用 sum() 函数计算列表中所有元素的总和
total = sum(my_list)
print(total)  # 输出：150

1.5 list() 函数

list() 函数的作用是可以用来将一个可迭代对象（如元组、字符串、集合等）转换为列表。

# 将元组转换为列表
tuple_data = (1, 2, 3, 4, 5)
list_from_tuple = list(tuple_data)
print(list_from_tuple)  # 输出：[1, 2, 3, 4, 5]

# 将字符串转换为列表
string_data = "hello"
list_from_string = list(string_data)
print(list_from_string)  # 输出：['h', 'e', 'l', 'l', 'o']

# 将集合转换为列表
set_data = {1, 2, 3, 4, 5}
list_from_set = list(set_data)
print(list_from_set)  # 输出：[1, 2, 3, 4, 5]

2.方法

2.1 append() 方法

append() 方法的作用是在列表末尾添加一个元素。

# 创建一个列表
my_list = [10, 20, 30, 40, 50]

# 使用 append() 方法在列表末尾添加元素
my_list.append(100)
my_list.append('six')
my_list.append([7, 8, 9])
print(my_list)  # 输出：[10, 20, 30, 40, 50, 100, 'six', [7, 8, 9]]

2.2 extend() 方法

extend() 方法的作用是将可迭代对象中的元素添加到列表末尾。

# 创建一个列表
my_list = [10, 20, 30, 40, 50]

# 使用 extend() 方法将可迭代对象中的元素添加到列表末尾
my_list.extend([7, 8, 9])
print(my_list)  # 输出：[10, 20, 30, 40, 50, 7, 8, 9]

2.3 count() 方法

count() 方法的作用是统计列表中某个元素出现的次数。

# 示例 1 – 确定项在列表中出现的次数。
my_list = [1, 2, 2, 2, 3, 4, 5, 5, 6]
count = my_list.count(2)
print("数量: ", count) # 输出 数量:  3

# 示例 2 – 使用计数结果在列表中移除元素。
my_list = [1, 2, 2, 2, 3, 4, 5, 5, 6]
count = my_list.count(2)
for i in range(count):
    my_list.remove(2)
print(my_list) # 输出 [1, 3, 4, 5, 5, 6]

# 示例 3 – 查找列表中唯一元素的数量。
my_list = [1, 2, 3, 4, 5, 6]
unique_count = len(set(my_list))
print("唯一元素数量: ", unique_count) # 输出 唯一元素数量:  6

2.4 index() 方法

index() 方法的作用是返回列表中某个元素的第一个匹配项的索引。

# 例1：查找列表中特定元素的索引
fruits = ['apple', 'banana', 'cherry']
print(fruits.index('banana')) # 输出1

# 例2：查找列表中特定元素的索引，指定起始位置
fruits = ['apple', 'banana', 'cherry']
print(fruits.index('banana', 1)) # 输出1

# 例3：查找列表中特定元素的索引，指定起始位置和结束位置
fruits = ['apple', 'banana', 'cherry']
print(fruits.index('banana', 1, 3)) # 输出1

# 例4：查找不存在的元素
fruits = ['apple', 'banana', 'cherry']
print(fruits.index('orange')) # 会引发ValueError异常

以下是一些关于index()方法的注意事项：

  1. 如果要查找的元素在列表中多次出现，则index()方法只会返回第一个匹配元素的索引。
  2. 如果要查找的元素不存在于列表中，则index方法将引发ValueError异常。
  3. 如果指定了start参数，将从指定的索引处开始查找元素。如果元素不存在，则引发ValueError异常。
  4. 如果指定了end参数，则index()方法将在指定的索引处之前停止查找元素。如果元素不存在，则引发ValueError异常。
  5. 如果省略start和end参数，则index()方法将在列表的起始位置查找元素。

2.5 insert()方法

insert()方法的作用是在指定位置插入一个元素。

# 示例 1 – 插入一个元素
fruits = ["apple", "banana", "cherry"]
fruits.insert(1, "orange")
print(fruits) # 输出['apple', 'orange', 'banana', 'cherry']

# 示例 2 – 插入多个元素
fruits = ["apple", "banana", "cherry"]
fruits.insert(1, ["orange", "watermelon"])
print(fruits) # 输出['apple', ['orange', 'watermelon'], 'banana', 'cherry']
# 需要注意的是，这种方式插入的元素是一个列表。如果想要在列表中插入多个独立的元素，需要将它们逐一插入。

# 插入多个独立的元素
fruits = ["apple", "banana", "cherry"]
fruits.insert(1, "orange")
fruits.insert(2, "watermelon")
print(fruits) # 输出 ['apple', 'orange', 'watermelon', 'banana', 'cherry']

# 示例 3 – 在列表的长度范围外插入元素，引发IndexError异常
fruits = ["apple", "banana", "cherry"]
fruits.insert(5, "orange")

2.6 pop() 方法

pop() 方法的作用是移除列表中指定位置的元素，并返回该元素的值。如果未指定位置，则默认移除并返回最后一个元素。

# 示例 1 – 默认移除最后一个元素
fruits = ['apple', 'banana', 'cherry']
fruits.pop()
print(fruits) # 输出 ['apple', 'banana']

# 示例 2 – 移除指定位置的元素
fruits = ['apple', 'banana', 'cherry']
fruits.pop(1)
print(fruits) # 输出 ['apple', 'cherry']

# 示例 3 – 异常案例
fruits = ['apple', 'banana', 'cherry']
fruits.pop(3) # 输出 IndexError: pop index out of range

2.7 remove() 方法

remove() 方法的作用是移除列表中某个值的第一个匹配项。

# 示例 1 – 删除元素
fruits = ['apple', 'banana', 'orange']
fruits.remove('orange')
print(fruits) # 输出 ['apple', 'banana']

# 示例 2 – 删除第一个匹配项
fruits = ['apple', 'banana', 'orange', 'apple']
fruits.remove('apple')
print(fruits) # 输出 ['banana', 'orange', 'apple']

# 示例 3 – 删除不存在的元素
fruits = ['banana', 'orange']
fruits.remove('apple')
print(fruits) # 输出 ValueError: list.remove(x): x not in list

2.8 reverse() 方法

reverse() 方法的作用是将列表中的元素反向排列。

# 创建一个列表
numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]

# 使用 reverse() 方法将列表中的元素反向排列
numbers.reverse()
print(numbers)  # 输出：[5, 3, 5, 6, 2, 9, 5, 1, 4, 1, 3]

2.9 sort() 方法

sort() 方法的作用是对列表进行排序。sort(key=None, reverse=False)：可选参数 key 指定排序的方式，reverse=True 则表示降序排序。默认为升序。

# 创建一个列表
numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]

# 使用 sort() 方法对列表进行排序
# 默认升序
numbers.sort()
print(numbers)  # 输出：[1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

# 降序
numbers.sort(reverse=True)
print(numbers)  # 输出：[9, 6, 5, 5, 5, 4, 3, 3, 2, 1, 1]

注意事项：

  1. sort()方法直接修改原始列表，而不是返回一个新的列表。
  2. 不能对含有数字和字符串的列表进行排序，如[“apple”, 1, “banana”, 2]。
  3. 如果需要倒序排序，请使用reverse()方法，如list.reverse()。

四、总结

今天主要讲了Python的列表的相关内容。

感谢你的观看！

Python列表：灵活多变的数据结构,Python学习,python,开发语言,学习文章来源地址https://www.toymoban.com/news/detail-833015.html

到了这里，关于Python列表：灵活多变的数据结构的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 探索数据结构：双向链表的灵活优势

    探索数据结构：双向链表的灵活优势

    ✨✨ 欢迎大家来到贝蒂大讲堂✨✨ 🎈🎈养成好习惯，先赞后看哦~🎈🎈 所属专栏：数据结构与算法 贝蒂的主页：Betty’s blog 前面我们学习了单链表，它解决了顺序表中插入删除需要挪动大量数据的缺点。但同时也有仍需改进的地方，比如说：我们有时候需要寻找某个节点

    2024年03月16日
    浏览(59)

  • python常见的数据类型与数据结构（一）数字类型 字符串类型 布尔类型 列表 集合 字典 的定义与常规操作方法

    数字类型有int(整数)，float(浮点数)和complex(复数型)，其中int与float被大家所常用并且可以使用int()和float()函数相互转换。如果字符串只包含数字和小数点也可以被这两种函数强制转换。复数型，则少被人们使用，大都是用在数学公式和物理公式的计算上。 字符串类型较为简单

    2024年02月21日
    浏览(50)
  • Java泛型：灵活多变的类型参数化工具

    Java泛型：灵活多变的类型参数化工具

    👑专栏内容：Java ⛪个人主页：子夜的星的主页 💕座右铭：前路未远，步履不停 在传统的编程方法中，类和方法通常被限定为使用特定的类型。这些类型可能是基础的数据类型（如整数、字符等），或者是由程序员自己定义的复杂类型。这种方式在处理单一类型数据时很有

    2024年02月01日
    浏览(61)

  • SQL ALTER TABLE 语句- 灵活修改表结构和数据类型

    SQL ALTER TABLE 语句用于在现有表中添加、删除或修改列，也可用于添加和删除各种约束。 要在表中添加列，请使用以下语法： 以下 SQL 向 \\\"Customers\\\" 表添加了一个 \\\"Email\\\" 列： 要在表中删除列，请使用以下语法（请注意，某些数据库系统不允许删除列）： 以下 SQL 从 \\\"Customers\\\" 表

    2024年02月05日
    浏览(49)
  • 【JavaSE专栏89】Java字符串和XML数据结构的转换，高效灵活转变数据

    【JavaSE专栏89】Java字符串和XML数据结构的转换，高效灵活转变数据

    作者主页 ：Designer 小郑 作者简介 ：3年JAVA全栈开发经验，专注JAVA技术、系统定制、远程指导，致力于企业数字化转型，CSDN学院、蓝桥云课认证讲师。 主打方向 ：Vue、SpringBoot、微信小程序 本文讲解了 XML 的概念，以及 Java 中 XML 和字符串的转换方法，并给出了样例代码。

    2024年02月09日
    浏览(57)

  • NSubstitute：一个简单易用、灵活多变的.NET单元测试模拟框架

    推荐一个简单易用、灵活多变的.NET单元测试模拟框架，让开发者能够更轻松地进行单元测试。 NSubstitute是一个开源的.NET单元测试模拟类库，该框架设计的主要目标是提供一个简单明了、易用性强、贴近自然语言的模拟测试框架。它使得开发者能够专注于测试工作，而不是纠

    2024年02月07日
    浏览(47)
  • 数据结构基础--散列表

    数据结构基础--散列表

    散列表，又叫 哈希表 （Hash Table），是能够通过给定的的值直接访问到具体对应的值的一个数据结构。也就是说，把映射到一个表中的位置来直接访问记录，以加快访问速度。 通常，把这个称为 Key，把对应的记录称为 Value，所以也可以说是通过 Key 访问

    2024年02月04日
    浏览(44)

  • R语言数据结构-----列表

    目录 （1）创建列表  （2）列表索引 （3）增加或删除列表元素 （4）访问列表元素和值 （5）apply()函数 （6）递归型列表 列表的基本操作 函数hist()中的数据，也是通过列表保存的 （1）创建列表  （2）列表索引 （3）增加或删除列表元素 添加新的组件 使用索引添加组件 删除

    2024年02月08日
    浏览(43)
  • 哈希表-散列表数据结构

    哈希表-散列表数据结构

    哈希表也叫散列表，哈希表是根据关键码值(key value)来直接访问的一种数据结构，也就是将关键码值(key value)通过一种映射关系映射到表中的一个位置来加快查找的速度，这种映射关系称之为哈希函数或者散列函数，存放记录的数组称之为哈希表。 哈希表采用的是一种转换思

    2024年01月21日
    浏览(55)
  • 数据结构—散列表的查找

    数据结构—散列表的查找

    7.4散列表的查找 7.4.1散列表的基本概念 基本思想：记录的存储位置域之间存在对应关系 ​ 对应关系——hash函数 ​ Loc（i）= H（keyi） 如何查找 ： 根据散列函数 H(key) = k 查找key=9，则访问H（4）= 18号地址，若内容为18则成功； 若查不到，则返回一个特殊值，如空指针或

    2024年02月12日
    浏览(44)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包