从给定列表开始a：
a = [1, 2, 3, 4, 5]
append(value) –将新元素追加到列表的末尾。
# 将值6、7和7追加到列表中
a.append(6)
a.append(7)
a.append(7)
# a：[1、2、3、4、5、6、7、7]
# 追加另一个清单
b = [8, 9]
a.append(b)
# a：[1、2、3、4、5、6、7、7，[8、9]]
# 追加其他类型的元素，因为列表元素不需要具有相同的类型
my_string = "hello world"
a.append(my_string)
# a: [1, 2, 3, 4, 5, 6, 7, 7, [8, 9], "hello world"]
请注意，该append()方法仅将一个新元素附加到列表的末尾。如果将列表追加到另一个列表，则追加的列表将成为第一个列表末尾的单个元素。
# 将列表追加到另一个列表
a = [1, 2, 3, 4, 5, 6, 7, 7]
b = [8, 9]
a.append(b)
# a：[1、2、3、4、5、6、7、7，[8、9]]
a[8]
# 返回：[8,9]
extend(enumerable) –通过附加另一个可枚举的元素来扩展列表。
a = [1, 2, 3, 4, 5, 6, 7, 7]
b = [8, 9, 10]
# 通过附加b中的所有元素来扩展列表
a.extend(b)
# a：[1、2、3、4、5、6、7、7、8、9、10]
# 用非列表可枚举的元素扩展列表：
a.extend(range(3))
# a：[1、2、3、4、5、6、7、7、8、9、10、0、1、2]
列表也可以与+运算符连接在一起。请注意，这不会修改任何原始列表：
a = [1, 2, 3, 4, 5, 6] + [7, 7] + b
# a：[1、2、3、4、5、6、7、7、8、9、10]
index(value, [startIndex])–获取输入值首次出现的索引。如果输入值不在列表中，ValueError则会引发异常。如果提供了第二个参数，则从该指定的索引开始搜索。
a.index(7)
# 返回：6
a.index(49) # ValueError，因为a中没有49。
a.index(7, 7)
# 返回：7
a.index(7, 8) # ValueError，因为从索引8开始没有7
insert(index, value)–value在指定的之前插入index。因此，在插入之后，新元素将占据位置index。
a.insert(0, 0) # 在位置0插入0
a.insert(2, 5) # 在位置2插入5
# a：[0、1、5、2、3、4、5、6、7、7、8、9、10]
pop([index])–删除并返回项目index。如果不带参数，它将删除并返回列表的最后一个元素。
a.pop(2)
# 返回：5
# a：[0、1、2、3、4、5、6、7、7、8、9、10]
a.pop(8)
# 返回：7
# a：[0、1、2、3、4、5、6、7、8、9、10]
# 不带参数：
a.pop()
# 返回：10
# a：[0、1、2、3、4、5、6、7、8、9]
remove(value)–删除第一次出现的指定值。如果找不到提供的值，ValueError则引发a。
a.remove(0)
a.remove(9)
# a：[1、2、3、4、5、6、7、8]
a.remove(10)
# ValueError，因为10不在
reverse()–就地反转列表并返回None。
a.reverse()
# a：[8、7、6、5、4、3、2、1]
还有其他方法可以反转列表。
count(value) –计算列表中某个值的出现次数。
a.count(7)
# 返回：2
sort()–按数字和字典顺序对列表进行排序并返回None。
a.sort()
# a = [1、2、3、4、5、6、7、8]
# 按数字顺序对列表进行排序
使用方法中的reverse=True标志进行排序时，列表也可以反向sort()。
a.sort(reverse=True)
# a = [8、7、6、5、4、3、2、1]
如果要按项目的属性排序，可以使用key关键字参数：
import datetime
class Person(object):
def __init__(self, name, birthday, height):
self.name= name
self.birthday= birthday
self.height= height
def __repr__(self):
return self.name
l = [Person("John Cena", datetime.date(1992, 9, 12), 175),
Person("Chuck Norris", datetime.date(1990, 8, 28), 180),
Person("Jon Skeet", datetime.date(1991, 7, 6), 185)]
l.sort(key=lambda item: item.name)
# l：[查克·诺里斯，约翰·塞纳，乔恩·斯基特]
l.sort(key=lambda item: item.birthday)
# l：[Chuck Norris，Jon Skeet，John Cena]
l.sort(key=lambda item: item.height)
# l：[约翰·塞纳，查克·诺里斯，乔恩·斯基特]
在命令列表的情况下，概念是相同的：
import datetime
l = [{'name':'John Cena', 'birthday': datetime.date(1992, 9, 12),'height': 175},
{'name': 'Chuck Norris', 'birthday': datetime.date(1990, 8, 28),'height': 180},
{'name': 'Jon Skeet', 'birthday': datetime.date(1991, 7, 6), 'height': 185}]
l.sort(key=lambda item: item['name'])
# l：[查克·诺里斯，约翰·塞纳，乔恩·斯基特]
l.sort(key=lambda item: item['birthday'])
# l：[Chuck Norris，Jon Skeet，John Cena]
l.sort(key=lambda item: item['height'])
# l：[约翰·塞纳，查克·诺里斯，乔恩·斯基特]
按主题排序：
import datetime
l = [{'name':'John Cena', 'birthday': datetime.date(1992, 9, 12),'size': {'height': 175, 'weight': 100}},
{'name': 'Chuck Norris', 'birthday': datetime.date(1990, 8, 28),'size' : {'height': 180, 'weight': 90}},
{'name': 'Jon Skeet', 'birthday': datetime.date(1991, 7, 6), 'size': {'height': 185, 'weight': 110}}]
l.sort(key=lambda item: item['size']['height'])
# l：[约翰·塞纳，查克·诺里斯，乔恩·斯基特]
使用attrgetter和排序的更好方法itemgetter
也可以使用运算符模块中的attrgetter和itemgetter功能对列表进行排序。这些可以帮助提高可读性和可重用性。这里有些例子，
from operator import itemgetter,attrgetter
people = [{'name':'chandan','age':20,'salary':2000},
{'name':'chetan','age':18,'salary':5000},
{'name':'guru','age':30,'salary':3000}]
by_age = itemgetter('age')
by_salary = itemgetter('salary')
people.sort(key=by_age) #按年龄就地分类
people.sort(key=by_salary) #按薪水就地分类itemgetter也可以给一个索引。如果要基于元组的索引进行排序，这将很有帮助。
list_of_tuples = [(1,2), (3,4), (5,0)] list_of_tuples.sort(key=itemgetter(1)) print(list_of_tuples) #[(5,0)，（1、2），（3、4）]
attrgetter如果要按对象的属性排序，请使用，
persons = [Person("John Cena", datetime.date(1992, 9, 12), 175),
Person("Chuck Norris", datetime.date(1990, 8, 28), 180),
Person("Jon Skeet", datetime.date(1991, 7, 6), 185)] #重用上面示例中的Person类
person.sort(key=attrgetter('name')) #按名称分类
by_birthday = attrgetter('birthday')
person.sort(key=by_birthday) #按生日排序clear() –从列表中删除所有项目
a.clear()
# a = []
复制–将现有列表乘以整数将产生一个较大的列表，其中包含原始副本的多个副本。例如，这对于列表初始化很有用：
b = ["blah"] * 3
# b = ["blah", "blah", "blah"]
b = [1, 3, 5] * 5
# [1、3、5、1、3、5、1、3、5、1、3、5、1、3、5]
如果您的列表包含对对象的引用（例如，列表列表），请务必小心，请参阅常见陷阱-列表乘法和常见引用。
元素删除–可以使用del关键字和切片符号删除列表中的多个元素：
a = list(range(10))
del a[::2]
# a = [1、3、5、7、9]
del a[-1]
# a = [1、3、5、7]
del a[:]
# a = []
复制中
默认分配“ =”将原始列表的引用分配给新名称。也就是说，原始名称和新名称都指向同一列表对象。通过它们中的任何一个所做的更改将反映在另一个中。这通常不是您想要的。
b = a
a.append(6)
# b：[1、2、3、4、5、6]
如果要创建列表的副本，则可以使用以下选项。
您可以将其切片：
new_list = old_list[:]
您可以使用内置list()函数：
new_list = list(old_list)
您可以使用generic ：copy.copy()
import copy
new_list = copy.copy(old_list) #插入对原始文档中找到的对象的引用。
这比要慢一些，list()因为它必须先找出old_list的数据类型。
如果列表包含对象，并且您也想复制它们，请使用generic ：copy.deepcopy()
import copy
new_list = copy.deepcopy(old_list) #插入原始文档中找到的对象的副本。
显然，这是最慢且最需要内存的方法，但有时是不可避免的。
copy() –返回列表的浅表副本
aa = a.copy() # aa = [1、2、3、4、5]