介绍： list 是 Python 中的一种内置数据类型，代表一个可变的有序序列。list 类型的目标能够运用多个办法来操作和修正其间的元素。 list: 列表 Built-in mutable sequence. 内置可变的序列 定义列表的时候运用的是[ ], 也能够包括多个不同类型的元素，多个元素之间也是用逗号分隔

一、创立一个列表

list_data = [1, 2, 3, 4, 5]             # 创立一个列表
print(list_data, type(list_data))       # 打印列表并输出它的类型

以上实例输出结果如下：

[1, 2, 3, 4, 5]
<class 'list'>

二、 拜访列表中的元素

python中list方法详解
编辑 例如，以下是如何获取 list 中的元素：

fruits = ['apple', 'banana', 'cherry']
# 取第一个元素
print(fruits[0])  # 'apple'
# 取第二个元素
print(fruits[1])  # 'banana'
# 从右边获取右边的第一个元素
print(fruits[-1])  # 'cherry'

能够运用切片操作符 : 来获取 list 的一个子序列。切片操作符承受两个参数，第一个参数是子序列的开始索引，第二个参数是子序列的完毕索引（不包括该索引对应的元素）。 假如省掉第一个参数，则默许从 list 的第一个元素开始。 假如省掉第二个参数，则默许到 list 的最终一个元素。 例如，以下是如何获取 list 的子序列

fruits = ['apple', 'banana', 'cherry', 'date', 'elderberry']
print(fruits[1:3])  # ['banana', 'cherry']
print(fruits[:2])   # ['apple', 'banana']
print(fruits[3:])   # ['date', 'elderberry']

假如想获取 list 中的最终一个元素，也能够运用 -1 索引：

# 回来列表的最终一个元素
print(fruits[-1])            # elderberry
# 回来一个列表的一部分，其间包括除最终两个元素之外的一切元素
print(fruits[:-2])           # ['apple', 'banana', 'cherry']
# 回来包括列表最终三个元素的列表切片
print(fruits[-3:])           # ['cherry', 'date', 'elderberry']

三、append 办法：

append() 办法用于在列表的结尾追加元素，该办法的标准语法格局如下：

list.append(obj)

  • obj — 添加到列表结尾的目标。

  • 该办法无回来值，可是会修正本来的列表

示例如下：列表的结尾追加元素

fruits = ['apple', 'banana', 'cherry']
fruits.append('orange')
print(fruits)  # ['apple', 'banana', 'cherry', 'orange']

定论:

  1. 列表可包括任何数据类型的元素，单个列表中的元素无须全为同一类型。

  2. append() 办法向列表的尾部添加一个新的元素。

  3. 列表是以类的方式完成的。“创立”列表实际上是将一个类实例化。因而，列表有多种办法能够操作。extend()办法只承受一个列表作为参数，并将该参数的每个元素都添加到原有的列表中

四、extend 办法：

extend() 函数用于在列表结尾一次性追加另一个序列中的多个值（用新列表扩展本来的列表）。 extend()办法语法：

list.extend(seq)

  • seq — 元素列表。

  • 该办法没有回来值，但会在已存在的列表中添加新的列表内容。

示例如下：

fruits = ['apple', 'banana', 'cherry']
more_fruits = ['orange', 'lemon']
fruits.extend(more_fruits)
print(fruits)  # ['apple', 'banana', 'cherry', 'orange', 'lemon']

五、insert 办法：

在指定方位刺进一个元素，append() 和 extend() 办法只能在列表结尾刺进元素，假如期望在列表中心某个方位刺进元素，那么能够运用 insert() 办法。 insert() 的语法格局如下：

listname.insert(index , obj)

  • index 表明指定方位的索引值。

  • obj — 要刺进列表中的目标。

  • insert() 会将 obj 刺进到 listname 列表第 index 个元素的方位。

  • 该办法没有回来值，但会在列表指定方位刺进目标。

示例如下：

fruits = ['apple', 'banana', 'cherry']
fruits.insert(1, 'orange')
print(fruits)  # ['apple', 'orange', 'banana', 'cherry']

定论：insert() 主要用来在列表的中心方位刺进元素，假如你只是期望在列表的结尾追加元素，那我更主张运用 append() 和 extend()。

六、remove 办法：

remove() 函数用于移除列表中某个值的第一个匹配项。 remove()办法语法：

list.remove(obj)

  • obj — 列表中要移除的目标。

  • 该办法没有回来值可是会移除列表中的某个值的第一个匹配项。

示例如下：删去列表中第一个匹配的元素。

fruits = ['apple', 'banana', 'cherry', 'banana']
fruits.remove('banana')
print(fruits)  # ['apple', 'cherry', 'banana']

定论： remove() 办法只会删去第一个和指定值相同的元素，而且有必要确保该元素是存在的，否则会引发 ValueError 过错

七、pop 办法：

pop() 办法用来删去列表中指定索引处的元素，详细格局如下：

list.pop([index=-1])

  • list 表明列表名称

  • index 表明索引值

  • obj — 可选参数，要移除列表元素的索引值，不能超过列表总长度，默以为 index=-1，删去最终一个列表值，类似于数据结构中的“出栈”操作

  • 该办法回来从列表中移除的元素目标。

示例如下：删去并回来指定方位的元素，默以为列表结尾的元素

fruits = ['apple', 'banana', 'cherry']
last_fruit = fruits.pop()
print(last_fruit)  # 'cherry'
print(fruits)  # ['apple', 'banana']

定论：pop() 相对应的办法，便是 push()，该办法用来将元素添加到列表的尾部，类似于数据结构中的“入栈”操作。可是 Python 是个破例，Python 并没有提供 push() 办法，由于彻底能够运用 append() 来替代 push() 的功用。

八、del办法：

del 能够删去列表中的单个元素，格局为：

del listname[index]
  • listname 表明列表名称，index 表明元素的索引值

示例如下：

fruits = ['apple', 'banana', 'cherry']
del fruits[2]
print(fruits)  # 'apple', 'banana'

del 也能够删去中心一段接连的元素，格局为：

del listname[start : end]

  • start 表明开始索引

  • end 表明完毕索引

  • del 会删去从索引 start 到 end 之间的元素，不包括 end 方位的元素

示例如下：

fruits = ['apple', 'banana', 'cherry']
del fruits[0:2]
print(fruits)  # 'cherry'

九、clear（）办法：

clear()办法语法：

list.clear()

clear() 用来删去列表的一切元素，也即清空列表 示例如下：

fruits = ['apple', 'banana', 'cherry']
fruits.clear()
print(fruits)  # []

十、index( ) 办法：

index() 办法用来查找某个元素在列表中呈现的方位（也便是索引），假如该元素不存在，则会导致 ValueError 过错，所以在查找之前最好运用 count() 办法判别一下。 index()办法语法：

list.index(obj, start, end)

  • lobj– 表明要查找的元素

  • start– 可选，查找的开始方位。

  • end– 可选，查找的完毕方位。

  • index() 办法会回来元素地点列表中的索引值。

start 和 end 参数用来指定检索范围：

  • start 和 end 能够都不写，此时会检索整个列表；
  • 假如只写 start 不写 end，那么表明检索从 start 到结尾的元素；
  • 假如 start 和 end 都写，那么表明检索 start 和 end 之间的元素。

示例如下：回来第一个匹配的元素的索引。

fruits = ['apple', 'banana', 'cherry']
banana_index = fruits.index('banana')
print(banana_index)  # 1

定论：index() 办法只回来元素在列表中第一次呈现的方位索引，假如需求查找一切呈现方位的索引，能够运用列表解析或循环等办法完成。

十一、count 办法：

count() 办法用来计算某个元素在列表中呈现的次数，基本语法格局为：

list.count(obj)

  • obj — 列表中计算的目标。

  • 假如 count() 回来 0，就表明列表中不存在该元素，所以 count() 也能够用来判别列表中的某个元素是否存在

示例如下：：回来列表中指定元素的呈现次数

fruits = ['apple', 'banana', 'cherry', 'banana']
banana_count = fruits.count('banana')
print(banana_count)  # 2

定论：count() 办法只计算某个元素在列表中呈现的次数，而不会回来元素在列表中呈现的方位索引。假如需求查找元素在列表中的方位索引，能够运用 index() 办法。

十二、sort 办法：

sort() 函数用于对原列表进行排序，假如指定参数，则运用比较函数指定的比较函数。 sort()办法语法：

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

  • cmp — 可选参数, 假如指定了该参数会运用该参数的办法进行排序。

  • key — 主要是用来进行比较的元素，只要一个参数，详细的函数的参数便是取自于可迭代目标中，指定可迭代目标中的一个元素来进行排序。

  • reverse — 排序规矩，reverse = True 降序， reverse = False 升序（默许）。

示例如下：按升序排列列表中的元素。

# 升序排序
a = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
a.sort()
print(a)  # [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]
# 降序排序
a = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
a.sort(reverse=True)
print(a)  # [9, 6, 5, 5, 5, 4, 3, 3, 2, 1, 1]
# 根据字符串长度排序
fruits = ['apple', 'banana', 'cherry', 'durian', 'elderberry']
fruits.sort(key=len)
print(fruits)  # ['apple', 'banana', 'cherry', 'durian', 'elderberry']

定论：sort() 办法是 Python 列表中的一个办法，用于原地对列表进行排序，行将列表中的元素按必定的规矩重新排列。默许情况下，sort() 办法按升序对列表进行排序，也能够经过传递 reverse=True 参数来按降序排序。 sort() 办法是原地排序，即会修正原始列表。假如需求对列表进行排序但又不想修正原始列表，能够运用 sorted() 内置函数。

十三、reverse 办法：

reverse() 函数用于反向列表中元素。reverse()办法语法：

list.reverse()

示例如下：将列表中的元素倒序排列

fruits = ['apple', 'banana', 'cherry']
fruits.reverse()
print(fruits)  # ['cherry', 'banana', 'apple']

定论：reverse() 办法是原地回转，即会修正原始列表。假如需求对列表进行回转但又不想修正原始列表，能够运用切片操作来创立一个回转后的新列表，例如 fruits[::-1]。

十四、copy办法：

copy() 是 list 类的一个办法，用于创立一个列表的副本。copy() 办法不带参数，它回来一个新列表，该列表包括原始列表中一切元素的副本。 例如，以下是如何运用 copy() 办法创立一个列表的副本：

fruits = ['apple', 'banana', 'cherry']
fruits_copy = fruits.copy()
print(fruits_copy)  # ['apple', 'banana', 'cherry']

上面的比如中，copy() 办法创立了一个新的 list 目标 fruits_copy，其间包括与原始列表 fruits 相同的元素。修正 fruits_copy 不会影响原始列表 fruits。 需求注意的是，copy() 办法只仿制列表中元素的值，而不是元素本身。假如列表中包括可变目标（如列表或字典），则副本列表中的元素将包括与原始列表相同的可变目标的引用。这意味着假如修正了原始列表中的可变目标，副本列表中相应的元素也会受到影响。 在 Python 中，能够运用 = 运算符来仿制列表。可是，运用 = 运算符仿制列表只会创立原始列表的一个引用，而不是创立一个副本。这意味着修正一个列表会一起修正另一个列表。因而，假如需求仿制列表并保存其独立性，请运用 copy() 办法。 **浅仿制：**copy() 办法进行浅仿制的示例：

a = [1, 2, [1, 2]]
b = a.copy()
# 修正原始列表的第三个元素
a[2][0] = 5
print(a)  # [1, 2, [5, 2]]
print(b)  # [1, 2, [5, 2]]

在上面的比如中，a 是一个包括整数和嵌套列表的列表。运用 copy() 办法将 a 仿制到 b 中，然后修正了 a 中的嵌套列表中的第一个元素。在浅仿制后的 b 中，嵌套列表中的第一个元素也发生了改变。 **深仿制：**copy 模块中的 deepcopy() 函数进行深仿制的示例： 深仿制是指创立一个新的列表目标，并递归地仿制原始列表中的一切元素和嵌套的可变目标。这意味着假如修正原始列表中的嵌套目标，这些目标在深仿制后的新列表中不会发生改变

import copy
a = [1, 2, [1, 2]]
b = copy.deepcopy(a)
# 修正原始列表的第三个元素
a[2][0] = 5
print(a)  # [1, 2, [5, 2]]
print(b)  # [1, 2, [1, 2]]

运用 copy 模块中的 deepcopy() 函数将 a 深仿制到 b 中，然后修正了 a 中的嵌套列表中的第一个元素。在深仿制后的 b 中，嵌套列表中的第一个元素没有发生改变。 需求注意的是，深仿制比浅仿制更慢而且更耗费内存，由于它需求递归地仿制一切嵌套的目标。通常，只要在需求保存原始列表和新列表之间的独立性，而且原始列表包括嵌套的可变。 定论： 浅仿制(copy)：仿制父目标，不会仿制目标的内部的子目标。 深仿制(deepcopy)： copy 模块的deepcopy 办法，彻底仿制了父目标及其子目标。

python中list方法详解

十五、总结：

list 目标是可变的，即对 list 目标的操作会直接修正原列表，而不是回来一个新列表,Python 中的列表（list）是一种有序、可变的数据类型，能够容纳任何类型的元素，包括整数、浮点数、字符串、乃至其他列表。列表经过方括号 [ ] 来定义，能够运用索引来拜访或修正列表中的元素。需求注意的是列表是可变的，即能够修正它们的内容。假如需求在不修正原始列表的情况下进行操作，能够运用切片操作来创立一个新的列表，或许运用 copy() 办法来创立一个原始列表的副本。