🚀一、列表

• 列表是一个能够存储多个同一或不同元素的序列
• 列表：list ---- []
• 列表属于序列类型（容器序列）
• 列表属于可变类型(可直接改变原数据–可变序列)
• 序列: 指的是一块可存放多个值的连续内存空间，这些值按一定顺序排列，可通过每个值所在位置的编号（称为索引）访问它们。-----序列是有序集的通用术语

# 列表中的元素是指列表中每个单独的数据项，一个列表是由一系列元素组成的。

list1 = [1, 'hahah', ['asd', 123]]

# 其中['asd', 123]为list1的其中一个元素
# ['asd', 123]在list1里面的下标为2

列表是序列类型，因此可以进行索引下标操作

🌈二、常规操作

💥增

• append: 向列表末端添加变量

append 方法是列表（List）类的一个内置方法，用于在列表的末尾添加一个元素。这个方法只接受一个参数，即你要添加到列表中的项。该方法不会返回任何值，而是直接修改原列表。

list1 = ['快乐', '忧伤', 'hahah']
list1.append('kuai')
print(list1)  # ['快乐', '忧伤', 'hahah', 'kuai']

• extend: 将数据添加到指定列表中

extend 方法是列表（list）的一个内置方法，用于将一个可迭代对象（如列表、元组、字符串等）的所有元素添加到列表的末端，从而扩展原列表。与 append 方法不同，append 是向列表添加单个元素，而 extend 是添加另一个集合中的多个元素。

• list：这是你要扩展的列表。
• iterable：一个可迭代对象，其元素将逐个添加到列表的末尾。

# 将数据中元素逐一加入指定列表

list3 = ['快乐', '忧伤', 'hahah']
list3.extend('帅12345')
print(list3)  # ['快乐', '忧伤', 'hahah', '帅', '1', '2', '3', '4', '5']


list4 = ['快乐', '忧伤', 'hahah']
list4.extend(['帅12345', 1, 2])
print(list4)  # ['快乐', '忧伤', 'hahah', '帅12345', 1, 2]

• insert: 指定位置插入元素

insert 方法是列表（list）的一个内置方法，用于在列表的指定位置插入一个元素。此操作会将指定索引位置之后的元素向右移动一个位置，以腾出空间给新插入的元素。

语法：

list.insert(index, element)

• list：这是你要插入元素的列表。
• index：这是你想在列表中插入新元素的索引位置。如果索引是0，则新元素会成为列表的第一个元素。如果索引等于列表长度，则新元素会追加到列表的末尾。
• element：你要插入到列表中的元素。

list2 = ['快乐', '忧伤', 'hahah']
list2.insert(0, '帅')
print(list2)  # ['帅', '快乐', '忧伤', 'hahah']

💥删

• clear: 清空列表中的数据

clear 方法是列表（list）的一个内置方法，用于清空列表中的所有元素，使其变成一个空列表。调用这个方法后，列表的长度变为0，且不再包含任何元素。

语法:

list.clear()

• list：这是你想要清空的列表。

list5 = ['快乐', '忧伤', 'hahah']
list5.clear()
print(list5)  # []

• pop: 删除指定索引位置的元素，默认删除最后一个

pop 方法是列表（list）的一个内置方法，用于移除列表中的一个元素，并且可以返回这个被移除的元素。如果不指定索引，pop 方法默认移除并返回列表的最后一个元素。如果指定了索引，就移除并返回该索引位置上的元素。

语法：

list.pop([index])

• list：这是你想要从中移除元素的列表。
• [index]：这是可选参数，指定要移除元素的索引位置。如果不提供，默认为-1，即最后一个元素。

list6 = ['快乐', '忧伤', 'hahah']
list6.pop()
print(list6)  # ['快乐', '忧伤']


list7 = ['快乐', '忧伤', 'hahah']
list7.pop(1)
print(list7)  # ['快乐', 'hahah']

• remove: 删除指定元素

remove 方法是列表（list）的一个内置方法，用于移除列表中第一个匹配给定值的元素。这个方法只移除第一个找到的匹配项，并且在原列表上进行修改，不会返回任何值。如果列表中不存在给定的值，remove 方法会抛出一个 ValueError 异常。

语法：

list.remove(value)

• list：这是你要从中移除元素的列表。
• value：这是你希望从列表中移除的元素的值。

list8 = ['快乐', '忧伤', 'hahah']
list8.remove('快乐')
print(list8)  # ['忧伤', 'hahah']

• del: 删除

del 语句是一种用来删除对象（包括列表中的元素、整个列表、变量等）的方式，它不是列表的一个方法，而是一个Python语句。当你使用 del 删除列表中的元素时，可以通过索引或切片指定要删除的部分，这会直接修改原列表。

list9 = ['快乐', '忧伤', 'hahah']
del list9[0] # 单独删除
print(list9)  # ['忧伤', 'hahah']

list10 = ['快乐', '忧伤', 'hahah']
del list10[0:2]  # 范围删除，还可以进行步长操作
print(list10)  # ['hahah']

list11 = ['快乐', '忧伤', 'hahah']
del list11
print(list11)

💥改

直接索引操作，重新赋值

list12 = ['快乐', '忧伤', 'hahah', [1,2,3]]
# 直接改
list12[0] = '你不得努力一下'
print(list12)


list13 = ['快乐', '忧伤', 'hahah', [1,2,3]]
# 直接操作可变数据
list13[3].append('哈沙给')
print(list13)  # ['快乐', '忧伤', 'hahah', [1, 2, 3, '哈沙给']]

💥查

• index 查看指定元素第一次出现的下标位置（可指定范围）

list14 = ['快乐', '忧伤', 'hahah', [1, 2, 3], 1, 2, 3, 4, 2]
print(list14.index(1))  # 4
# 因为下标为3为[1, 2, 3]，所以往后找，下标为4是指定元素

• count 统计指定元素在列表中出现次数

list15 = ['快乐', '忧伤', 'hahah', [1, 2, 3], 1, 2, 3, 4, 2]
print(list15.count(2))  # 2次

⭐三、补充操作

• copy 浅复制

列表（list）的复制可以通过多种方式实现，但直接提到的“copy方法”通常指的是使用列表的 copy() 内置方法来创建原列表的一个浅复制。这意味着新列表与原列表包含相同的元素，但两个列表是不同的对象，修改其中一个列表不会直接影响另一个。

语法：

new_list = original_list.copy()

• original_list：原始列表，你想要复制的那个列表。
• new_list：通过 copy() 方法创建的原始列表的副本。

list_1 = [123, 345, 'hahg']
list_2 = list_1.copy()

print(list_2)  # [123, 345, 'hahg']

print(id(list_1))  # 2563097618248
print(id(list_2))  # 2563097618312

• reverse 序列反向

reverse 方法是列表（list）的一个内置方法，用于就地（in-place）地反转列表中元素的顺序。这意味着它会直接修改原列表，而不是返回一个新的、反转后的列表。

语法：

list.reverse()

• list：你想要反转元素顺序的列表。

list_3 = [1, 3, 0, 34, 35, 23, 26]
list_3.reverse()
print(list_3)  # [26, 23, 35, 34, 0, 3, 1]

• sort 排序（同类型数据）

sort() 方法是列表（list）的一个内置方法，用于就地（in-place）对列表元素进行排序。这意味着该方法会直接修改原列表，根据元素的值重新排列列表中的元素，而不返回一个新的排序后的列表。

语法：

list.sort(key=None, reverse=False)

• list：你想要排序的列表。
• key：可选参数，是一个函数，该函数会被用来计算列表中每个元素的排序键值。默认情况下，元素本身会被用作键值进行比较。
• reverse：可选参数，默认为False，表示按升序排序。如果设置为True，则按降序排序。

# sort 排序（同类型数据）
list_4 = [1, 3, 0, 34, 35, 23, 26]
list_4.sort()
print(list_4)  # [0, 1, 3, 23, 26, 34, 35]

# sort(reverse=True) 反向排序
list_5 = [1, 3, 0, 34, 35, 23, 26]
list_5.sort(reverse=True)
print(list_5)  # [35, 34, 26, 23, 3, 1, 0]

• sorted 临时排序（不改变原列表数据）

sorted() 函数是一个内置的高阶函数，用于对任何可迭代对象（不仅仅是列表）进行排序，返回一个新的排序后的列表，原对象保持不变。这与列表的 sort() 方法不同，sort() 方法是就地排序，直接修改原列表。

语法：

sorted(iterable, key=None, reverse=False)

• iterable：任何可迭代对象，比如列表、元组、字符串等。
• key：可选参数，是一个函数，该函数会被用于确定列表中每个元素的排序依据。默认为None，表示直接比较元素。
• reverse：可选参数，默认为False，表示升序排序。如果设置为True，则进行降序排序。

# sorted 临时排序
list_6 = [1, 3, 0, 34, 35, 23, 26]
data = sorted(list_6)

print(list_6)  # [1, 3, 0, 34, 35, 23, 26]
print(data)  # [0, 1, 3, 23, 26, 34, 35]

# 临时反向排序
list_7 = [1, 3, 0, 34, 35, 23, 26]
data_1 = sorted(list_7, reverse=True)

print(list_7)  # [1, 3, 0, 34, 35, 23, 26]
print(data_1)  # [35, 34, 26, 23, 3, 1, 0]

• reversed 临时反向（不改变原列表数据）

reversed() 函数是一个内置函数，它不直接作用于列表，而是作用于任何可迭代对象，返回一个迭代器，该迭代器提供输入序列元素的逆序视图。对于列表，虽然它不直接修改原列表，但你可以通过将返回的迭代器转换为列表或其他容器来获得逆序的副本。

语法：

reversed(iterable)

• iterable：任何可迭代对象，如列表、元组、字符串等。

list_8 = [1, 3, 0, 34, 35, 23, 26]
data_2 = reversed(list_8)  # 返回的是一个对象

print(list_8)  # [1, 3, 0, 34, 35, 23, 26]
print(data_2)  # <list_reverseiterator object at 0x000001C88644FB38>

# 将对象数据转类型, 可获取其内部数据
data = list(data_2)
print(data)  # [26, 23, 35, 34, 0, 3, 1]