【Python】入门到放弃之第七章《列表》

已于 2024-08-15 01:17:51 修改
阅读量1.1k 收藏 16
点赞数 36
分类专栏： Python 文章标签： python windows 网络
于 2024-08-14 21:07:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MP13537560060/article/details/141197713
版权

上一篇：【Python】入门到放弃之第六章《字符串》
下一篇：【Python】入门到放弃之第八章《元组》

文章目录

前言

这是本系列的第七章节内容，《列表》。

一、定义

  • “列表”（List）是计算机科学和数据结构中常用的一个概念，它用于存储一系列的元素，这些元素可以是数字、字符、字符串、对象等，并且这些元素之间是有序的，即它们按照插入的顺序排列。不同的编程语言提供了不同的实现方式和语法来创建和操作列表。
  • 在Python中，列表是一种内置的数据类型，用方括号[]表示。

二、创建列表

1.[ ] 创建

  • 使用一对空的方括号[]来创建一个空列表。
  • 在方括号内，使用逗号（,）分隔的元素来创建一个包含这些元素的列表。

代码如下（示例）：

my_list = [1, 2, 3, 4, 5]  # 包含整数的列表  
mixed_list = [1, 'a', 3.14]  # 包含不同类型元素的列表  
nested_list = [[1, 2], [3, 4], [5, 6]]  # 嵌套列表

2.列表推导式创建

  • 列表推导式提供了一种更简洁的方式来创建列表，特别是根据现有列表或其他可迭代对象生成新列表。

代码如下（示例）：

# 创建一个包含0到9的平方的列表  
squares = [x**2 for x in range(10)]  
print(squares)  # 输出: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]  
  
# 创建一个包含0到9之间偶数的列表  
evens = [x for x in range(10) if x % 2 == 0]  
print(evens)  # 输出: [0, 2, 4, 6, 8]

3.list() 函数创建

  • 虽然 list() 函数通常用于将其他可迭代对象（如元组、字符串、集合等）转换为列表，但也可以通过传递一个空的迭代器给它来创建一个空列表。

代码如下（示例）：

# 创建一个空列表
another_empty_list = list()

# 实际上，这更多用于将其他可迭代对象转换为列表
tuple_to_list = list((1, 2, 3))
print(tuple_to_list)  # 输出: [1, 2, 3]

string_to_list = list("hello")
print(string_to_list)  # 输出: ['h', 'e', 'l', 'l', 'o']

三、访问列表元素

  • 列表的元素索引号从零开始，如果尝试访问的索引超出了列表的范围，Python将抛出一个IndexError异常。
  • 负索引用于从列表的末尾开始计数。例如，-1表示最后一个元素，-2表示倒数第二个元素，依此类推。

1.访问单个元素

  • 通过指定索引来访问列表中的单个元素。

代码如下（示例）：

my_list = [1, 2, 3, 'a', 'b', 'c']  
  
# 访问索引为0的元素  
print(my_list[0])  # 输出: 1  
  
# 访问索引为3的元素  
print(my_list[3])  # 输出: a

2.访问多个元素（切片）

  • 使用切片（Slicing）来访问列表中的一段元素，即过指定起始索引和结束索引（不包括结束索引）来完成。

代码如下（示例）：

# 访问索引从1到4（不包括4）的元素  
print(my_list[1:4])  # 输出: [2, 3, 'a']  
  
# 如果省略起始索引，则默认为0  
print(my_list[:3])  # 输出: [1, 2, 3]  
  
# 如果省略结束索引，则默认为列表的长度  
print(my_list[3:])  # 输出: ['a', 'b', 'c']  
  
# 还可以指定步长（Step），用于跳过某些元素  
print(my_list[::2])  # 输出: [1, 3, 'b']，跳过了索引为偶数的元素

3.访问嵌套列表的元素

  • 如果列表中包含其他列表（即嵌套列表），则可以通过组合索引来访问嵌套列表中的元素。

代码如下（示例）：

nested_list = [[1, 2], [3, 4], [5, 6]]  
  
# 访问外层列表的第一个子列表的第一个元素  
print(nested_list[0][0])  # 输出: 1  
  
# 访问外层列表的第二个子列表的第二个元素  
print(nested_list[1][1])  # 输出: 4

四、列表长度

  • 使用内置的len()函数来获取列表（List）的长度，即列表中元素的数量。

代码如下（示例）：

# 定义一个列表  
my_list = [1, 2, 3, 4, 5]  
  
# 使用len()函数获取列表的长度  
list_length = len(my_list)  
  
# 打印列表的长度  
print(list_length)  # 输出: 5

五、列表元素的添加

1.append() 方法

  • append() 方法用于在列表的末尾添加一个元素。但是，只能添加一个元素。

代码如下（示例）：

my_list = [1, 2, 3]  
my_list.append(4)  # 现在 my_list 变成了 [1, 2, 3, 4]

2.insert() 方法

  • insert() 方法用于在列表的指定位置插入一个元素。它接收两个参数：第一个是索引（即位置），第二个是要插入的元素。

代码如下（示例）：

my_list = [1, 2, 4]  
my_list.insert(2, 3)  # 现在 my_list 变成了 [1, 2, 3, 4]

3. + 操作符（或 extend() 方法）

  • 虽然直接使用 + 操作符来“添加”列表，实际上是创建了一个新的列表。

代码如下（示例）：

list1 = [1, 2, 3]
list2 = [4, 5, 6]

# 合并列表，等同 list1.extend(list2)
combined_list = list1 + list2  # 得到 [1, 2, 3, 4, 5, 6]

六、列表元素的删除

1.remove() 方法

  • remove()方法用于删除列表中第一个出现的指定元素。如果元素不存在，则抛出ValueError异常。

代码如下（示例）：

my_list = [1, 2, 3, 4, 5, 4]  
my_list.remove(4)  # 删除第一个出现的4  
print(my_list)  # 输出: [1, 2, 3, 4, 5]  
  
# 如果尝试删除不存在的元素，会抛出异常  
# my_list.remove(6)  # ValueError: list.remove(x): x not in list

2.pop() 方法

  • pop()方法用于删除列表中的指定索引位置的元素（默认为最后一个元素），并返回该元素的值。

代码如下（示例）：

my_list = [1, 2, 3, 4, 5]  
last_element = my_list.pop()  # 删除并返回最后一个元素  
print(last_element)  # 输出: 5  
print(my_list)  # 输出: [1, 2, 3, 4]  
  
# 删除指定索引的元素  
second_element = my_list.pop(1)  # 删除索引为1的元素（即2）  
print(second_element)  # 输出: 2  
print(my_list)  # 输出: [1, 3, 4]

3.del 语句

  • del 语句可以用于删除列表中的元素，可以通过索引或切片来指定要删除的元素或元素范围。

代码如下（示例）：

my_list = [1, 2, 3, 4, 5]  
del my_list[2]  # 删除索引为2的元素（即3）  
print(my_list)  # 输出: [1, 2, 4, 5]  
  
# 删除一个范围的元素  
del my_list[1:3]  # 删除索引1到2的元素（不包括索引3的元素）  
print(my_list)  # 输出: [1, 5]  
  
# 也可以删除整个列表  
del my_list  # 现在my_list不再存在，尝试访问会引发NameError  
# print(my_list)  # NameError: name 'my_list' is not defined

七、列表的切片

1.基本切片

代码如下（示例）：

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 获取列表的前三个元素
print(my_list[:3])  # 输出: [1, 2, 3]

# 获取列表从索引3到索引7（不包含索引7）的元素
print(my_list[3:7])  # 输出: [4, 5, 6, 7]

2.省略起始索引或结束索引

代码如下（示例）：

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 省略起始索引，从列表开头开始切片
print(my_list[:5])  # 输出: [1, 2, 3, 4, 5]

# 省略结束索引，切片到列表末尾
print(my_list[5:])  # 输出: [6, 7, 8, 9]

3.使用步长

代码如下（示例）：

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 每隔一个元素取一个元素
print(my_list[::2])  # 输出: [1, 3, 5, 7, 9]

# 逆序切片（结合步长为-1）
print(my_list[::-1])  # 输出: [9, 8, 7, 6, 5, 4, 3, 2, 1]

4.切片赋值

  • 切片不仅用于获取列表的一部分，还可以用于修改列表的这一部分。

代码如下（示例）：

my_list[2:5] = [10, 11, 12]  # 替换索引2到4的元素  
print(my_list)  # 输出: [1, 2, 10, 11, 12, 6, 7, 8, 9]

5.切片与列表推导式结合

  • 切片可以与列表推导式结合使用，以进行更复杂的操作，如筛选或转换元素。

代码如下（示例）：

# 将列表中的偶数元素加倍  
doubled_evens = [x * 2 for x in my_list if x % 2 == 0]  
print(doubled_evens)  # 输出: [2, 12, 14, 16, 18]（注意：基于原始my_list的修改）  
  
# 或者，如果只想在切片上操作  
sliced_and_doubled = [x * 2 for x in my_list[::2]]  # 只考虑索引为偶数的元素  
print(sliced_and_doubled)  # 输出: [2, 6, 12, 18]（基于原始my_list的索引为偶数的元素）

八、列表的遍历

1.for 循环遍历

  • 最直接的方式是使用for循环直接遍历列表中的每个元素。

代码如下（示例）：

my_list = [1, 2, 3, 4, 5]
for item in my_list:
    print(item)

输出如下（示例）：

1
2
3
4
5

2.索引遍历

  • 使用索引来遍历列表，这在需要同时访问元素和它们的索引时特别有用。

代码如下（示例）：

my_list = ['a', 'b', 'c', 'd', 'e']  
for i in range(len(my_list)):  
    print(f"Index: {i}, Item: {my_list[i]}")

输出如下（示例）：

Index: 0, Item: a
Index: 1, Item: b
Index: 2, Item: c
Index: 3, Item: d
Index: 4, Item: e

3.enumerate() 函数

  • enumerate() 函数可以同时获取索引和元素。

代码如下（示例）：

my_list = ['花', '凝', '雨']
for index, item in enumerate(my_list):
    print(f"Index: {index}, Item: {item}")

输出如下（示例）：

Index: 0, Item: 花
Index: 1, Item: 凝
Index: 2, Item: 雨

4.map() 函数

  • map() 函数可以对列表中的每个元素应用一个函数。虽然它主要用于映射操作，但也可以看作是一种遍历列表的方式。

代码如下（示例）：

my_list = [1, 2, 3, 4, 5]  
def square(x):  
    return x ** 2  
  
squared_list = list(map(square, my_list))  
print(squared_list)  # 输出: [1, 4, 9, 16, 25]

5.filter() 函数（筛选）

  • 虽然filter() 函数主要用于筛选列表中的元素，但它同样基于遍历列表中的每个元素。

代码如下（示例）：

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]  
def is_even(x):  
    return x % 2 == 0  
  
even_numbers = list(filter(is_even, my_list))  
print(even_numbers)  # 输出: [2, 4, 6, 8, 10]

九、列表的排序

1.sort() 方法

  • sort()方法是列表的一个内置方法，它会直接修改原列表，按照指定的规则进行排序。默认情况下，它会按照升序对列表中的元素进行排序。

代码如下（示例）：

my_list = [3, 1, 4, 1, 5, 9, 2]  
my_list.sort()  
print(my_list)  # 输出: [1, 1, 2, 3, 4, 5, 9]  
  
# 降序排序  
my_list.sort(reverse=True)  
print(my_list)  # 输出: [9, 5, 4, 3, 2, 1, 1]

2.sorted()函数

  • 与 sort() 方法不同，sorted() 函数会返回一个新的列表，原列表不会被修改。sorted() 函数同样可以接受 reverse 参数来控制排序顺序。

代码如下（示例）：

my_list = [3, 1, 4, 1, 5, 9, 2]  
sorted_list = sorted(my_list)  
print(sorted_list)  # 输出: [1, 1, 2, 3, 4, 5, 9]  
print(my_list)  # 输出: [3, 1, 4, 1, 5, 9, 2]，原列表未变  
  
# 降序排序  
sorted_list_desc = sorted(my_list, reverse=True)  
print(sorted_list_desc)  # 输出: [9, 5, 4, 3, 2, 1, 1]

3.自定义排序规则

  • 无论是sort()方法还是sorted()函数，都可以接受一个key参数来自定义排序规则。key参数应该是一个函数，该函数会在每个元素上调用，其返回值作为排序的依据。

代码如下（示例）：

# 根据字符串长度排序  
words = ['banana', 'pie', 'Washington', 'book']  
words.sort(key=len)  
print(words)  # 输出: ['pie', 'book', 'banana', 'Washington']  
  
# 使用lambda表达式作为key  
words.sort(key=lambda word: word[::-1])  # 按字符串逆序排序  
print(words)  # 输出: ['banana', 'Washington', 'pie', 'book']

4.复杂对象的排序

  • 对于包含复杂对象的列表，比如字典列表或自定义对象列表，可以通过在key参数中指定一个函数来访问对象的某个属性或调用某个方法来作为排序的依据。

代码如下（示例）：

# 字典列表，按值排序  
dict_list = [{'name': 'Tom', 'age': 20}, {'name': 'Jerry', 'age': 15}, {'name': 'Bob', 'age': 25}]  
dict_list.sort(key=lambda x: x['age'])  
print(dict_list)  # 按年龄升序排序  
  
# 自定义对象列表  
class Person:  
    def __init__(self, name, age):  
        self.name = name  
        self.age = age  
  
    def __repr__(self):  
        return f"{self.name}: {self.age}"  
  
people = [Person('Tom', 20), Person('Jerry', 15), Person('Bob', 25)]  
people.sort(key=lambda person: person.age)  
print(people)  # 按年龄升序输出

输出如下（示例）：

[{'name': 'Jerry', 'age': 15}, {'name': 'Tom', 'age': 20}, {'name': 'Bob', 'age': 25}]
[Jerry: 15, Tom: 20, Bob: 25]

十、列表的列表（嵌套列表）

  • Python的嵌套列表（Nested List）是指列表中包含其他列表的情况。这种结构允许用户以二维（或更多维）的方式来组织和访问数据。嵌套列表在处理表格数据、矩阵、图结构等方面非常有用。

1.创建嵌套列表

代码如下（示例）：

# 创建一个简单的嵌套列表  
nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]  
  
# 访问嵌套列表中的元素  
print(nested_list[0])  # 输出: [1, 2, 3] ， 访问第一个子列表  
print(nested_list[1][2])  # 输出: 6 ， 访问第二个子列表中的第三个元素

2.遍历嵌套列表

  • 遍历嵌套列表时，则需要使用嵌套的循环来访问每个子列表中的元素。

代码如下（示例）：

nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# 遍历嵌套列表  
for sublist in nested_list:
    for item in sublist:
        print(item, end=' ')
    print()  # 打印换行符以分隔每个子列表的输出

输出如下（示例）：

1 2 3 
4 5 6 
7 8 9

3.修改嵌套列表

代码如下（示例）：

nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]  
  
# 修改子列表中的元素  
nested_list[1][1] = 55  
print(nested_list)  # 输出: [[1, 2, 3], [4, 55, 6], [7, 8, 9]]  
  
# 添加新的子列表  
nested_list.append([10, 11, 12])  
print(nested_list)  # 输出: [[1, 2, 3], [4, 55, 6], [7, 8, 9], [10, 11, 12]]  
  
# 删除子列表  
del nested_list[0]  
print(nested_list)  # 输出: [[4, 55, 6], [7, 8, 9], [10, 11, 12]]

4.列表推导式与嵌套列表

代码如下（示例）：

# 使用列表推导式创建嵌套列表  
nested_list = [[x*y for y in range(1, 4)] for x in range(1, 4)]  
print(nested_list)  # 输出: [[1, 2, 3], [2, 4, 6], [3, 6, 9]]  
  
# 修改嵌套列表（创建一个新列表）  
modified_list = [[item*2 for item in sublist] for sublist in nested_list]  
print(modified_list)  # 输出: [[2, 4, 6], [4, 8, 12], [6, 12, 18]]

总结

以上，就是Python中列表的全部内容。Python的列表非常灵活和强大，支持多种操作来管理元素和子列表。好好学，好好做。

花凝雨
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值