文章目录
- 2.10 insert()函数
- 2.11 list()函数
- 2.12 pop() 函数
- 2.13 remove()函数
- 2.14 reverse()函数
- 2.15 sort()函数
- 2.16 sorted()函数
- 2.17 sum()函数
2.10 insert()函数
在Python中，list.insert()是一个列表方法，用于在指定索引位置插入一个元素。这个方法会改变原列表，插入新元素后，该位置及之后的元素都会向后移动一位。
list.insert()方法的语法如下：
list.insert(index, object)
- index：必需的参数，表示要插入元素的索引位置。
- object：必需的参数，表示要插入的元素。
下面是一个使用insert()方法的例子：
# 创建一个列表
my_list = ['apple', 'banana', 'cherry']
# 在索引1的位置插入元素'orange'
my_list.insert(1, 'orange')
# 打印修改后的列表
print(my_list) # 输出: ['apple', 'orange', 'banana', 'cherry']
在这个例子中，insert()方法在索引1的位置插入了元素’orange’。原本在索引1位置的元素’banana’及其之后的元素都向后移动了一位。
请注意，如果指定的索引超出了列表的范围（即索引大于或等于列表的长度），insert()方法会在列表的末尾添加元素。如果索引是负数，它表示从列表的末尾开始计数的位置。例如，-1表示列表的最后一个元素，-2表示倒数第二个元素，依此类推。
下面是一个使用负索引的例子：
# 创建一个列表
my_list = ['apple', 'banana', 'cherry']
# 在倒数第二个位置插入元素'orange'
my_list.insert(-2, 'orange')
# 打印修改后的列表
print(my_list) # 输出: ['apple', 'orange', 'banana', 'cherry']
在这个例子中，insert()方法在倒数第二个位置（即原列表中索引1的位置）插入了元素’orange’。
2.11 list()函数
在Python中，list()是一个内置函数，用于将可迭代对象（如元组、字符串、集合或任何实现了迭代协议的对象）转换成一个列表。如果传递给list()的参数本身就是一个列表，那么它会返回该列表的一个浅拷贝。
以下是list()函数的一些用法示例：
# 将一个元组转换为列表
tuple_example = (1, 2, 3)
list_from_tuple = list(tuple_example)
print(list_from_tuple) # 输出: [1, 2, 3]
# 将一个字符串转换为字符列表
string_example = "hello"
list_from_string = list(string_example)
print(list_from_string) # 输出: ['h', 'e', 'l', 'l', 'o']
# 将一个集合转换为列表
set_example = {4, 5, 6}
list_from_set = list(set_example)
print(list_from_set) # 输出可能是: [4, 5, 6]，但集合是无序的，所以顺序可能会有所不同
# 将一个字典的键转换为列表
dict_example = {'a': 1, 'b': 2, 'c': 3}
list_from_dict_keys = list(dict_example.keys())
print(list_from_dict_keys) # 输出: ['a', 'b', 'c']
# 将一个字典的值转换为列表
list_from_dict_values = list(dict_example.values())
print(list_from_dict_values) # 输出: [1, 2, 3]
# 将一个自定义可迭代对象转换为列表
class MyIterable:
def __iter__(self):
return iter([10, 20, 30])
my_iterable = MyIterable()
list_from_custom = list(my_iterable)
print(list_from_custom) # 输出: [10, 20, 30]
# 创建一个空列表
empty_list = list()
print(empty_list) # 输出: []
# 将一个列表复制（浅拷贝）
original_list = [1, 2, [3, 4]]
copied_list = list(original_list)
print(copied_list) # 输出: [1, 2, [3, 4]]
# 注意，这里的copied_list和original_list中的嵌套列表是同一个对象
在最后一个例子中，即使我们使用了list()函数来复制了一个列表，嵌套列表仍然是原始列表中的同一个对象。这是因为list()函数执行的是浅拷贝（shallow copy），它只复制了最外层的列表，而列表中的元素（如果它们是可变对象）则保持不变。
如果你想要进行深拷贝（deep copy），使得嵌套列表也是新的对象，你需要使用copy模块的deepcopy函数：
import copy
original_list = [1, 2, [3, 4]]
deep_copied_list = copy.deepcopy(original_list)
print(deep_copied_list) # 输出: [1, 2, [3, 4]]
# 注意，这里的deep_copied_list和original_list中的嵌套列表不是同一个对象
list()函数在需要将其他可迭代对象转换为列表时非常有用，因为它提供了一种简单且通用的方法来创建列表。
2.12 pop() 函数
在Python中，list.pop()是一个列表方法，用于移除列表中的一个元素，并返回该元素的值。默认情况下，pop()方法移除并返回列表中的最后一个元素（索引为-1的元素）。如果提供了索引参数，那么它会移除并返回该索引位置的元素。
以下是list.pop()方法的基本语法：
list.pop([index])
- index（可选）：要移除的元素的索引。如果不指定索引，默认为-1，即移除最后一个元素。
下面是一些使用pop()方法的例子：
# 创建一个列表
my_list = [10, 20, 30, 40, 50]
# 移除并返回列表中的最后一个元素
last_element = my_list.pop()
print(f"Removed element: {last_element}, List now: {my_list}")
# 输出: Removed element: 50, List now: [10, 20, 30, 40]
# 移除并返回索引为1的元素
element_at_index_1 = my_list.pop(1)
print(f"Removed element: {element_at_index_1}, List now: {my_list}")
# 输出: Removed element: 20, List now: [10, 30, 40]
# 尝试移除不存在的索引位置的元素会抛出IndexError
try:
my_list.pop(10)
except IndexError as e:
print(f"An error occurred: {e}")
# 输出: An error occurred: pop index out of range
在第一个例子中，pop()方法没有指定索引，所以它移除了列表中的最后一个元素（50）。在第二个例子中，我们指定了索引1，所以移除了该位置的元素（20）。在最后一个例子中，尝试移除一个不存在的索引（10）会抛出一个IndexError异常，因为列表中没有索引为10的元素。
pop()方法是一个就地操作（in-place operation），它会直接修改原列表，而不是返回一个新的列表。如果你想要保留原列表并创建一个不包含被移除元素的新列表，你可以先复制原列表，然后再对新列表调用pop()方法。
2.13 remove()函数
在Python中，list.remove() 是一个列表方法，用于移除列表中第一个匹配到的指定值的元素。如果列表中有多个相同的元素，remove() 只会移除第一个出现的元素。如果列表中不存在该元素，remove() 会引发一个 ValueError 异常。
以下是 list.remove() 方法的基本语法：
list.remove(value)
- value：必需参数，表示要移除的元素的值。
下面是一个使用 remove() 方法的例子：
# 创建一个列表
my_list = [1, 2, 3, 4, 3, 5]
# 移除第一个值为3的元素
my_list.remove(3)
# 打印修改后的列表
print(my_list) # 输出: [1, 2, 4, 3, 5]
在这个例子中，remove() 方法移除了列表中第一个值为3的元素。
如果你尝试移除一个不存在的元素，会抛出 ValueError：
# 创建一个列表
my_list = [1, 2, 3, 4, 5]
# 尝试移除一个不存在的元素
try:
my_list.remove(6)
except ValueError as e:
print(f"An error occurred: {e}")
# 输出: An error occurred: list.remove(x): x not in list
在这个例子中，因为6不在列表中，所以 remove() 方法抛出了一个 ValueError 异常。
如果你想移除列表中所有匹配的元素，而不是仅仅第一个，你需要使用循环来多次调用 remove() 方法，或者使用列表推导式来创建一个新的列表，其中不包含要移除的元素。例如：
# 创建一个列表
my_list = [1, 2, 3, 4, 3, 5]
# 移除所有值为3的元素
while 3 in my_list:
my_list.remove(3)
# 打印修改后的列表
print(my_list) # 输出: [1, 2, 4, 5]
或者使用列表推导式：
# 创建一个列表
my_list = [1, 2, 3, 4, 3, 5]
# 创建一个新列表，其中不包含值为3的元素
my_list = [x for x in my_list if x != 3]
# 打印修改后的列表
print(my_list) # 输出: [1, 2, 4, 5]
这两种方法都会移除列表中所有值为3的元素。
2.14 reverse()函数
在Python中，list.reverse()是一个列表方法，用于原地（in-place）反转列表中的元素顺序。这意味着它不会创建一个新的列表，而是直接修改原列表。调用reverse()方法后，原列表的元素顺序会被反转，而方法本身没有返回值（返回None）。
以下是如何使用list.reverse()的示例：
# 创建一个列表
my_list = [1, 2, 3, 4, 5]
# 打印原始列表
print("Original list:", my_list)
# 输出: Original list: [1, 2, 3, 4, 5]
# 反转列表
my_list.reverse()
# 打印反转后的列表
print("Reversed list:", my_list)
# 输出: Reversed list: [5, 4, 3, 2, 1]
# 注意：reverse()是原地操作，原列表被修改
在这个例子中，my_list.reverse()调用了reverse()方法，它直接修改了my_list，使其元素顺序颠倒。因此，在调用reverse()之后，my_list的内容发生了改变。
如果你想要得到一个反转后的新列表，而不改变原列表，你可以使用切片操作：
# 创建一个列表
my_list = [1, 2, 3, 4, 5]
# 使用切片操作来反转列表，并创建一个新列表
reversed_list = my_list[::-1]
# 打印原始列表和新列表
print("Original list:", my_list)
# 输出: Original list: [1, 2, 3, 4, 5]
print("New reversed list:", reversed_list)
# 输出: New reversed list: [5, 4, 3, 2, 1]
# 注意：原列表未发生改变
在这个例子中，my_list[::-1]创建了一个新列表，它是原列表my_list的反转副本。原列表my_list的内容保持不变。
2.15 sort()函数
在Python中，list.sort()是一个列表方法，用于对列表中的元素进行排序。该方法会按照升序（从小到大）对原列表进行就地（in-place）排序，即不返回新列表，而是直接修改原列表。
list.sort()方法的基本语法如下：
list.sort(key=None, reverse=False)
- key：可选参数，用于指定一个函数，该函数将被用于在比较元素时提取比较键（comparison key）。默认值为None，表示直接比较元素本身。
- reverse：可选参数，布尔值，默认为False。如果设置为True，则列表将按照降序（从大到小）排序。
下面是一些使用list.sort()方法的例子：
# 创建一个列表
my_list = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
# 对列表进行升序排序
my_list.sort()
print("Sorted list in ascending order:", my_list)
# 输出: Sorted list in ascending order: [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]
# 对列表进行降序排序
my_list.sort(reverse=True)
print("Sorted list in descending order:", my_list)
# 输出: Sorted list in descending order: [9, 6, 5, 5, 5, 4, 3, 3, 2, 1, 1]
# 使用key参数进行排序，例如按照字符串长度排序
words = ['apple', 'banana', 'cherry', 'date']
words.sort(key=len)
print("Words sorted by length:", words)
# 输出: Words sorted by length: ['date', 'apple', 'cherry', 'banana']
在第一个例子中，我们直接调用了sort()方法对列表进行升序排序，然后又用reverse=True参数进行了降序排序。在第二个例子中，我们使用了key参数来指定一个函数，该函数返回每个元素的长度，因此列表是按照字符串长度进行排序的。
需要注意的是，list.sort()是就地排序，这意味着它会直接修改原列表。如果你不想修改原列表，而是想保留原列表并创建一个新的已排序列表，你可以使用sorted()函数，该函数会返回一个新的已排序列表，原列表不会被修改。
# 创建一个列表
my_list = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
# 创建一个新的已排序列表，原列表不变
sorted_list = sorted(my_list)
print("Original list:", my_list)
# 输出: Original list: [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
print("New sorted list:", sorted_list)
# 输出: New sorted list: [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]
在这个例子中，sorted()函数返回了一个新的已排序列表，而原列表my_list保持不变
2.16 sorted()函数
在Python中，sorted() 是一个内置函数，用于对可迭代对象（如列表）进行排序，并返回一个新的已排序的列表。原始列表不会被修改，因为sorted()函数返回一个新的列表。
sorted()函数的基本语法如下：
sorted(iterable, key=None, reverse=False)
- iterable：必需参数，表示要进行排序的可迭代对象，如列表。
- key：可选参数，用于指定一个函数，该函数将被用于在比较元素时提取比较键（comparison key）。默认值为None，表示直接比较元素本身。
- reverse：可选参数，布尔值，默认为False。如果设置为True，则返回的列表将按照降序排序。
以下是一些使用sorted()函数的例子：
# 创建一个列表
my_list = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
# 对列表进行升序排序
sorted_list = sorted(my_list)
print("Sorted list in ascending order:", sorted_list)
# 输出: Sorted list in ascending order: [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]
# 对列表进行降序排序
sorted_list_descending = sorted(my_list, reverse=True)
print("Sorted list in descending order:", sorted_list_descending)
# 输出: Sorted list in descending order: [9, 6, 5, 5, 5, 4, 3, 3, 2, 1, 1]
# 使用key参数进行排序，例如按照字符串长度排序
words = ['apple', 'banana', 'cherry', 'date']
sorted_words = sorted(words, key=len)
print("Words sorted by length:", sorted_words)
# 输出: Words sorted by length: ['date', 'apple', 'cherry', 'banana']
在第一个例子中，我们使用了sorted()函数对列表进行升序排序，并打印了排序后的新列表。在第二个例子中，我们通过设置reverse=True参数来对列表进行降序排序。在第三个例子中，我们使用key参数来指定一个函数，该函数返回每个元素的长度，因此列表是按照字符串长度进行排序的。
需要注意的是，sorted()函数返回的是一个新的列表，而原始列表my_list保持不变。如果你想要在原地修改列表并排序，可以使用列表的sort()方法，如之前所提到的。
2.17 sum()函数
在Python中，sum()是一个内置函数，用于计算可迭代对象（如列表）中所有元素的和。当你对列表使用sum()函数时，它会返回列表中所有元素相加的结果。
以下是如何使用sum()函数来计算列表元素之和的示例：
# 创建一个数值列表
my_list = [1, 2, 3, 4, 5]
# 使用sum()函数计算列表中所有元素的和
total = sum(my_list)
# 打印结果
print("Sum of the list elements:", total)
# 输出: Sum of the list elements: 15
在这个例子中，sum(my_list)计算了列表my_list中所有数字的和，并将结果存储在变量total中。然后，我们打印了这个和。
sum()函数也可以与字符串列表一起使用，但在这种情况下，它将连接字符串而不是计算它们的和：
# 创建一个字符串列表
string_list = ["Hello", " ", "World"]
# 使用sum()函数连接字符串列表中的元素
combined_string = sum(string_list)
# 打印结果
print("Combined string:", combined_string)
# 输出: Combined string: Hello World
在这个例子中，sum(string_list)将列表string_list中的所有字符串连接起来，形成一个单一的字符串。
如果你想要对列表中的元素应用某种数学运算（如乘法）并求和，你可以使用列表推导式与sum()函数结合：
# 创建一个数值列表
my_list = [1, 2, 3, 4, 5]
# 使用列表推导式和sum()函数计算列表中每个元素的平方和
total_squared = sum(x**2 for x in my_list)
# 打印结果
print("Sum of squares:", total_squared)
# 输出: Sum of squares: 55
在这个例子中，列表推导式x**2 for x in my_list生成了一个新的列表，其中包含my_list中每个元素的平方。然后，sum()函数计算了这个新列表中所有元素的和。
