05_Python数据类型_列表的相关运算

Python的基础数据类型

• 数值类型：整数、浮点数、复数、布尔
• 字符串
• 容器类型：列表、元祖、字典、集合

列表运算符

列表支持多种运算符和操作，这些运算符可以用来执行各种操作，如合并列表、重复列表、检查元素是否在列表中等。

• 索引运算符 [] 索引运算符用于访问列表中的元素。
• 切片运算符 [:] 切片运算符用于获取列表的一部分。
• 乘法运算符 * 乘法运算符用于重复列表。
• 加法运算符 + 加法运算符用于合并两个列表。
• 成员运算符 in 和 not in 成员运算符用于检查一个元素是否存在于列表中。
• 身份运算符 is 和 is not 身份运算符用于比较两个对象的内存地址是否相同。

# 索引 切片
my_list = [2024, 0, 9, 1 ,5 ,1, 6, 1, 5]
print(my_list[0]) # 2024
print(my_list[0:5]) # [2024, 0, 9, 1, 5]

# 乘法运算符 * 乘法运算符用于重复列表。
my_list = [1, 2]
repeated_list = my_list * 3  # 结果是 [1, 2, 1, 2, 1, 2]
print(repeated_list)

# + 加法运算符用于合并两个列表。
l1 = [1, 2, 3, 4, 5]
l2 = [6, 7, 8, 9, 10]
l3 = l1 + l2 # 结果：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(l3)

# in 和 not in 成员运算符用于检查一个元素是否存在于列表中。
my_list = [1, 2, 3, 4, 5]
is_two_in_list = 2 in my_list  # 结果是 True
is_six_in_list = 6 in my_list  # 结果是 False
is_six_not_in_list = 6 not in my_list  # 结果是 True
print(is_two_in_list)
print(is_six_in_list)
print(is_six_not_in_list)

# is 和 is not 身份运算符用于比较两个对象的内存地址是否相同。
list1 = [1, 2, 3]
list2 = list1
list3 = [1, 2, 3]

is_same_object = list1 is list2  # 结果是 True
is_different_object = list1 is list3  # 结果是 False
print(is_same_object)
print(is_different_object)

l1 = [1, 'abc', [2, 3]]
l2 = [1, 'abc', [2, 3]]
print(l1 == l2) # 结果：True
print(l1 is l2) # 结果：False
print(id(l1[1]) == id(l2[1])) # 结果：True
#对于不可变元素（字符串、数值、布尔）在内存中只存储一份（即id一样）。

赋值和深浅拷贝

赋值、浅拷贝（shallow copy）和深拷贝（deep copy）是处理可变对象（如列表和字典）时常用的概念。

• 赋值：其实就是对同一个对象的引用。
• 浅拷贝（cpoy）：创建一个新对象，拷贝父对象，不会拷贝对象内部的子对象。子对象直接引用。
• 深拷贝（deepcopy）：创建一个新对象，copy模块的deepcopy方法，完全拷贝了父对象及其子对象。

赋值

直接赋值意味着将一个对象的引用（内存地址）赋给另一个变量。这意味着两个变量将指向内存中的同一个对象。

# 赋值，如果修改 list2，list1 也会受到影响，因为它们指向同一个列表。
list1 = [1, 2, 3]
list2 = list1  # list2 是 list1 的引用

浅拷贝

浅拷贝会创建一个新对象，但不会递归地复制内部对象。这意味着原始对象和浅拷贝对象共享内部对象的引用。

• 在Python中，可以使用 copy 模块的 copy() 函数来实现浅拷贝。

import copy

# 浅拷贝示例
list1 = [1, 2, [3, 4]]
list2 = copy.copy(list1)  # list2 是 list1 的浅拷贝

# 修改 list2 的内部列表，list1 也会受到影响
list2[2][0] = 5
print(list1)  # 输出 [1, 2, [5, 4]]

深拷贝

深拷贝会创建一个新对象，并递归地复制内部对象。这意味着原始对象和深拷贝对象不共享任何内部对象的引用。

• 在Python中，可以使用 copy 模块的 deepcopy() 函数来实现深拷贝。

import copy

# 深拷贝示例
list1 = [1, 2, [3, 4]]
list3 = copy.deepcopy(list1)  # list3 是 list1 的深拷贝

# 修改 list3 的内部列表，list1 不会受到影响
list3[2][0] = 5
print(list1)  # 输出 [1, 2, [3, 4]]

使用深拷贝和浅拷贝时需要小心，因为它们可能会产生意想不到的副作用，尤其是在处理包含可变对象的复合对象时。

列表推导式

• 列表推导式（List Comprehensions）是Python中一种优雅且简洁的方式来创建列表。它基于现有的列表，通过某种操作来生成新的列表。
• 列表推导式：[expression for item in iterable] 翻译一下：[输出的内容 for 每一个元素的名字 in 可迭代的元素]
  • expression 是针对每个 item 执行的操作，item 是 iterable 中的每个元素。
• 带条件的列表推导式：[expression for item in iterable if condition] 翻译一下：[输出的内容 for 每一个元素的名字 in 可迭代的元素 if 条件]

列表推导式基本用法

列表推导式

l = [1, 2, 3, 4, 5]
[i for i in l] # 结果：[1, 2, 3, 4, 5]

创建一个包含0-9每个数字的列表。

# 创建一个包含0-9每个数字的列表：
numbers = [x for x in range(10)]
print(numbers)  # 结果: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

创建一个包含0-9每个数字平方的列表

# 创建一个包含0-9每个数字平方的列表：
squared = [x**2 for x in range(10)]
print(squared)
# 结果: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

创建一个包含原列表中每个字符串首字母大写的列表

# 创建一个包含原列表中每个字符串首字母大写的列表：
words = ['hello', 'world', 'python']
capitalized_words = [word.capitalize() for word in words]
print(capitalized_words)
# 结果: ['Hello', 'World', 'Python']

带条件的列表推导式

列表推导式可以包含一个或多个 if 条件，以筛选出满足条件的元素。

创建一个包含0-9中偶数的列表

even_numbers = [x for x in range(10) if x % 2 == 0]
print(even_numbers)
# 结果: [0, 2, 4, 6, 8]

创建一个包含0-9中奇数平方的列表

# 创建一个包含0-9中奇数平方的列表
odd_squares = [x**2 for x in range(10) if x % 2 != 0]
print(odd_squares)  # 结果: [1, 9, 25, 49, 81]

需求：将列表 l1 （list）中的元素取出来，放到另一个列表 l2 中。可以用for循环实现。

# 将l1中不等于5的元素取出，放到l2中。
l1 = [1, 2, 3, 4, 5, "a", "b", 5, "c", "d"]
l2 = []
for i in l1:
    if i != 5:
        l2.append(i)
l2

可以用列表推导式快速实现上面的功能

# 列表推导式快速取出元素，将l1中不等于5的元素取出，放到l2中。
l3 = [i for i in l1 if i != 5]
print(l3) # 结果 [1, 2, 3, 4, 'a', 'b', 'c', 'd']

嵌套的列表推导式

列表推导式可以嵌套，即内部列表推导式可以作为外部列表推导式的 expression。

# 创建一个二维列表，每个子列表包含两个数字的乘积：
matrix = [[x * y for x in range(1, 4)] for y in range(1, 4)]
print(matrix)  # 结果: [[1, 2, 3], [2, 4, 6], [3, 6, 9]]

注意事项

• 尽管列表推导式非常强大和方便，但过度的嵌套或复杂的表达式可能会导致代码难以阅读。
• 列表推导式在执行时是顺序的，如果 iterable 很大，它可能会消耗较多内存和时间。

使用列表推导式可以使代码更加简洁，并且通常比等效的循环更加高效。然而，保持代码的可读性也非常重要，因此在使用列表推导式时，应确保它们不会使代码变得难以理解。

附件

本文对应的jupyter notebook源码链接，欢迎下载练习：https://download.csdn.net/download/fx_yzjy101/89757831

如有问题请留言。