Python中哪些常用列表方法总结？

本文共计3737个文字，预计阅读时间需要15分钟。

一、创建列表使用方括号[]将不同的数据项用逗号分隔，即可创建列表；下标（角标，索引）从0开始；最后一个元素的下标可以是-1；list=['1', '2', '3']list=[]list=list()

一、创建列表

① 只要把逗号分隔的不同的数据项使用方括号[ ]括起来即可；

下标（角标，索引）从0开始；最后一个元素的下标可以是-1;

list = ['1'，‘2，‘3’]

list = []

list = list()

list2 = list()
print(list2, type(list2)) # [] <class 'list'>

list1 = list('stysyahsh') # 将一个可序列化的对象转换为列表对象
print(list1) # ['s', 't', 'y', 's', 'y', 'a', 'h', 's', 'h']

②list()方法将元组转换为列表；但是元组变成列表后的对象内存地址没变。

a_tuple = ('123', 'abc', 123)
print(a_tuple, id(a_tuple)) # ('123', 'abc', 123) 2374451842688

a_list = list(a_tuple)
print(a_list, id(a_list)) # ['123', 'abc', 123] 2374451917888

二、列表添加新元素

①list.append()默认在列表的末尾增加一个元素。

②list.insert(4,'a')在指定位置添加元素；①如果指定的下标对应的元素不存在，那么就是默认在列表的末尾添加新的元素；②如果传入的指定下标不存在即超出了该列表的索引值，同样也会插入成功而不报错；③insert之后的列表对象不变，即不会产生一个新的列表对象

list1 = ['1', '2', '3']
print(id(list1)) # 3019052845760

list1.insert(1, 'a')
print(list1, id(list1)) # ['1', 'a', '2', '3'] 3019052845760

list1.insert(100, 'b')
print(list1, id(list1)) # ['1', 'a', '2', '3', 'b'] 3019052845760

list1.insert(-1, 'c')
print(list1, id(list1)) # ['1', 'a', '2', '3', 'c', 'b'] 3019052845760

list1.insert(-2, 'd')
print(list1, id(list1)) # ['1', 'a', '2', '3', 'd', 'c', 'b'] 3019052845760

list1.insert(-100, 'fg')
print(list1, id(list1)) # ['fg', '1', 'a', '2', '3', 'd', 'c', 'b'] 3019052845760

list1.insert('e')
# # Traceback (most recent call last):
# # File "C:\Users\liangshu.hu\PycharmProjects\practice\kkkk.py", line 16, in <module>
# # list1.insert('e')
# # TypeError: insert expected 2 arguments, got 1

③list1.extend(list2)合并两个两个列表（合并list1和list2）；合并后没有产生新的列表对象，且被合并的列表对象依旧存在于内存中。

list1 = ['1', '2', '3']
list2 = ['a', 'b', 'c']

print(list1, id(list1)) # ['1', '2', '3'] 2568023542464

list1.extend(list2)

print(list1, id(list1)) # ['1', '2', '3', 'a', 'b', 'c'] 2568023542464
print(list2, id(list2)) # ['a', 'b', 'c'] 2568023576896

④list1+list2：组合列表：产生一个新的列表对象

list1 = ['1', '2', '3', '4']
print(list1, id(list1)) # ['1', '2', '3', '4'] 2912099470144
list2 = ['a', 'b', 'c', 'd']
print(list2, id(list2)) # ['a', 'b', 'c', 'd'] 2912099504768
print(list1+list2, id(list1+list2)) # ['1', '2', '3', '4', 'a', 'b', 'c', 'd'] 2912099787264

⑤list1*n：重复列表：产生一个新的列表对象

list1 = ['1', '2', '3', '4']
print(list1, id(list1)) # ['1', '2', '3', '4'] 2912099470144
list2 = list1 * 3
print(list2, id(list2)) # ['1', '2', '3', '4', '1', '2', '3', '4', '1', '2', '3', '4'] 3037215854784

三、获取列表中的值

①print(list)：返回列表

②for i in list: print i：遍历列表

③print(list[n])：使用下标索引来获取列表中的某个指定值；同样也可以使用list[n:m]方式截取字符

④print(list.count(xx))：查看某个元素在该列表里的数量；如果该元素不存在，那么返回0

list1 = ['1', '2', '2', '4', 'a', 'b']
print(list1.count('2')) # 2
print(list1.count('q')) # 0

⑤print(list.index(xx))：在该列表中找到某个元素的下标索引值；如果该列表中某个元素有多个，则只返回某个元素第一次出现的下标索引值；如果在该列表中查找一个不存在的元素的下标索引值则会报错。（根据列表中的值获取该值所在列表中的下标索引）

a=[72, 56, 76, 84, 80, 88]
print(a.index(76)) # 2

但是，list.index(xx)方法仅仅能获取都第一个匹配value的下标索引值，此时，我们可以使用第二种方案来获取列表元素的下标索引值：利用enumerate函数（可以获取列表中所有重复值的下标索引）

list1 = ['a', 'b', 'c', 'a', 'd', '1', '2', '3', 'a']

print(enumerate(list1)) # <enumerate object at 0x000001AEE37D8080>

# enumerate的输出类型是元组
print(list(
enumerate(list1))) # [(0, 'a'), (1, 'b'), (2, 'c'), (3, 'a'), (4, 'd'), (5, '1'), (6, '2'), (7, '3'), (8, 'a')]

# 获取列表中所有的元素为'a'元素的下标索引值-->返回值是一个包含所有元素为'a'的下标索引值的列表
print([i for i, x in enumerate(list1) if x == 'a']) # [0, 3, 8]

四、删除列表中的元素

①list.pop()：默认删除列表的最后一个元素；且返回已经删除的元素值

list1 = ['1', '2', '2', '4', 'a', 'b']
a = list1.pop()
print(list1) # ['1', '2', '2', '4', 'a']
print(a) # b

②list.pop(n)：删除列表的指定下标索引位置的元素；如果删除列表中的一个不存在的元素则会报错

list1 = ['1', '2', '2', '4', 'a', 'b']
a = list1.pop(0)
print(list1) # ['1', '2', '2', '4', 'a']
print(a) # 1

b = list1.pop(100)
print(b)
# Traceback (most recent call last):
# File "C:\Users\liangshu.hu\PycharmProjects\practice\pksjjdj.py", line 14, in <module>
# b = list1.pop(100)
# IndexError: pop index out of range

③list.remove(xx)：删除列表中里面的某个指定元素；如果列表中有多个相同的元素，默认删除第一个出现的元素 ；每一次只能删除一个列表中的指定元素；

list1 = ['1', '2', '2', '4', 'a', 'b']

list1.remove('a')
print(list1) # ['1', '2', '2', '4', 'b']

list1.remove('2')
print(list1) # ['1', '2', '4', 'b']

④print(list.pop())：有返回值，返回列表中已经被删除的元素

list1 = ['1', '2', '2', '4', 'a', 'b']
print(list1.pop()) # b

⑤print(list.remove()) 无返回值

list1 = ['1', '2', '2', '4', 'a', 'b']
print(list1.remove('2')) # None

⑥del list[n]：删除列表指定下标索引对应的元素

list1 = ['1', '2', '2', '4', 'a', 'b']
print(list1, id(list1)) # ['1', '2', '2', '4', 'a', 'b'] 2727783140096

del list1[0]
print(list1, id(list1)) # ['2', '2', '4', 'a', 'b'] 2727783140096

⑦del list：删除整个列表，列表删除后无法访问

list1 = ['1', '2', '2', '4', 'a', 'b']
del list1
print(list1, id(list1))
# Traceback (most recent call last):
# File "C:\Users\liangshu.hu\PycharmProjects\practice\pksjjdj.py", line 11, in <module>
# print(list1, id(list1))
# NameError: name 'list1' is not defined

⑧ 无论是list.pop()方法还是list.remove()方法删除元素后的列表内存地址不变，即列表删除元素操作不会产生一个新列表

list1 = ['1', '2', '2', '4', 'a', 'b']
print(list1, id(list1)) # ['1', '2', '2', '4', 'a', 'b'] 2118284184320
list1.pop()
print(list1, id(list1)) # ['1', '2', '2', '4', 'a'] 2118284184320

list1.remove('2')
print(list1, id(list1)) # ['1', '2', '4', 'a'] 2118284184320

⑨list.clear()：清空列表中的元素；但是列表对象仍然存在于内存中。

a = ['Google', 'Runoob', 'Taobao', 'Baidu']

b = [1, 2, 3, 4]

print("a=", a)

print("b=", b)

a.clear()

b.clear()

print("a=", a)

print("b=", b)

五、其他

1、判断元素是否存在于列表中

xx in []：只能判断元素对象是否存在于列表中；不能判断列表的子列表是否存在于列表中。

list1 = ['1', '2', '3', '4', 'a', 'b', 'c']
print('1' in list1) # True

print(['1', 'a'] in list1) # False

2、比较两个列表的元素

operator.eq(list1,list2)：实现两个列表的比较功能；需要引入operator 模块，适合于任何对象。

具体查看Python内置模块operator模块（python中内置的操作符函数接口）请查看博客：​

import operator

print(operator.eq('hello', 'name')) # False

print(operator.eq('hello', 'hello')) # True

六、排序和反转

①list.reverse()：将列表反转；反转后的列表内存地址不变，既没有产生新的列表对象

list1 = ['1', '2', '2', '4', 'a', 'b']
print(list1, id(list1)) # ['1', '2', '2', '4', 'a', 'b'] 2881397492416

list1.reverse()
print(list1, id(list1)) # ['b', 'a', '4', '2', '2', '1'] 2881397492416

②list.sort()：将列表中的元素排序；默认升序排序；排序后没有产生新的列表对象

list1 = ['1', '2', '2', '4', 'a', 'b']
print(list1, id(list1)) # ['1', '2', '2', '4', 'a', 'b'] 2541629901568

list1.sort()
print(list1, id(list1)) # ['1', '2', '2', '4', 'a', 'b'] 2541629901568

③list.sort(reverse=True)：将列表中的元素排序；降序排列；排序后没有新的列表对象

list1 = ['1', '2', '2', '4', 'a', 'b']
print(list1, id(list1)) # ['1', '2', '2', '4', 'a', 'b'] 1998451280640

list1.sort(reverse=True)
print(list1, id(list1)) # ['b', 'a', '4', '2', '2', '1'] 1998451280640

：一个列表中同时存在字符串和数字时不能排序；列表的排序是针对某一列表中的同类型数据。

1、sort函数

如果对python中的列表进行排序，可以使用List类的成员函数sort；该函数会在原空间上进行操作，对列表本身进行修改，不返回副本即不返回新的列表对象。

语法如下：

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

2、sorted函数

sorted函数就比sort函数要强大太多；

sort只能对列表进行排序，sorted可以对所有可迭代类型进行排序；并且返回新的已排序的列表对象。语法如下：

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

可接受4个参数，含义分别如下：

①iterable：可迭代类型，例如字典、列表

②cmp：比较函数，cmp是带两个参数的比较函数；key 是带一个参数的函数

③key：可迭代类型中某个属性，对给定元素的每一项进行排序

④reverse：降序或升序

3、结合使用

与sorted函数经常结合使用的有：

①比较函数经常会用到lambda匿名函数。

示例：对数个元组组成的列表，以元组中的某一项进行排序。

students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

sorted(students, key=lambda student : student[2]) # sort by age

# [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

②比较函数经常会用到operator.itemgetter函数

operator模块提供的itemgetter函数用于获取对象的哪些维的数据，参数为一些序号。

operator.itemgetter函数获取的不是值，而是定义了一个函数，通过该函数作用到对象上才能获取值。

sorted函数用来排序，sorted(iterable[, cmp[, key[, reverse]]])

key的参数为一个函数或者lambda函数。所以itemgetter可以用来当key的参数。

# 例如根据第二个域和第三个域进行排序
a = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

sorted(students, key=operator.itemgetter(1,2))

③可迭代元素经常会用到items

items是字典中的一个方法，返回由元组组成的列表。

dict={'a':1,'b':2}

ans = sorted(dict.items(), key=lambda x:x[1], reverse=True)

七、列表操作的函数

①len(list)：返回列表元素个数

②max(list)：返回列表元素最大值

③min(list)：返回列表元素最小值

④list(tuple)：将元组转换为列表

⑤enumerate ：打印元素对应的下标

list_ = [1, 2, 3, 44, 'abc', 'lkj']
for i, v in enumerate(list_):
print("value:{},index:{}".format(v, i))

结果如下：

value:1,index:0
value:2,index:1
value:3,index:2
value:44,index:3
value:abc,index:4
value:lkj,index:5

八、列表切片（列表取值的一种方法）

①name[n:m]：切片是不包含后面那个元素的值（顾头不顾尾）

②name[:m]：如果切片前面一个值缺省的话，从开头开始取

③name[n:]： 如果切片后面的值缺省的话，取到末尾

④name[:] ：如果全部缺省，取全部

⑤name[n:m:s]：

s表示步长，表示每隔多少个元素取一次列表中的值

步长是正数，从左往右取

步长是负数，从右往左取

：切片同样适用于字符串，因为字符串也有下标

九、列表生成式

概述：

①列表生成式即List Comprehensions，是Python内置的非常简单却强大的可以用来创建列表的生成式。

②列表生成式的结构是在一个中括号里包含一个表达式，然后是一个for语句，然后是0个或多个for或者if语句。

③列表表达式可以是任意的，可以在列表中放入任意类型的对象。返回结果将是一个新的列表。

variable = [out_exp for out_exp in input_list if out_exp == 2]

举例：

1. 生成一个列表，列表元素分别为 [1*1,2*2,3*3……n*n]，假设n=10。

①若用一般方法实现代码如下：

list1 = []
for i in range(1, 11):
list1.append(i * i)

②若用列表生成式：

list2 = [i * i for i in range(1, 11)]

2.字符串s1 ='ABC'，字符串 s2 = '123'，要求：生成一个列表[A1, A2, A3, B1, B2, B3]

①若用一般方法实现代码如下：

list1 = []
for i in 'ABC':
for j in '123':
list1.append(i+j)

②若用列表生成式：

list2 = [i+j for i in 'ABC' for j in '123']

小总结：

①列表是一个有序的对象集合；且列表可变；在对列表进行一系列操作之后不会创建新的列表，可用id()函数对比查看列表的内存地址。

②一个对象在另外一个对象中吗可以用in来检查。

③从列表中删除对象使用remove函数

remove：取一个对象值作为唯一参数。remove方法会从列表中删除指定第一次出现的数据值。

④从列表中弹出对象使用pop函数
pop：取一个可选的下标索引值（indexof）作为参数。pop函数根据对象的下标索引值从现有列表删除并返回一个对象。

⑤用对象扩展列表使用extend函数

⑥在列表中插入一个元素对象insert/append
insert：取一个索引值和一个对象作为参数。insert 方法将一个对象插入到现有列表中指定下标索引值的前面。这样就可以将元素对象插入到现有列表的开头，或者插入到列表中的任何位置。
append：默认插入元素对象到列表末尾。

⑦如何复制一个列表数据结构？

不要使用赋值操作符复制列表；应当使用copy方法。因为赋值操作都指向同一个数据（并没有产生一个新的列表对象），如果修改复制后的列表，另一个当然也会改变（因为他们是同一个列表对象）；

copy:list2 = list1.copy()：如果想建立现有列表中对象的副本，初始化一个新列表，就一定要使用copy方法

去期待陌生，去拥抱惊喜。