1.append方法:在列表的末尾添加1个元素,可包含任何数据类型,该方法无返回值(返回值为None),但是会修改原来的列表
(1)list.append(x) 等同于 list[len(list):]=[x],如:
b = ['A', 'b', '从', '对方身份', '问过', 'abd', [1, 2, 3]]
a1 = [1, 2, 3]
b.append(a1)
print(b) # ['A', 'b', '从', '对方身份', '问过', 'abd', [1, 2, 3], [1, 2, 3]]
b = ['A', 'b', '从', '对方身份', '问过', 'abd', [1, 2, 3]]
b[len(b):] = [a1]
print(b) # ['A', 'b', '从', '对方身份', '问过', 'abd', [1, 2, 3], [1, 2, 3]]
(2)添加的元素,可为任何的类型
b = ['A', 'b', '从', '对方身份', '问过', 'abd', [1, 2, 3]]
print(b) # ['A', 'b', '从', '对方身份', '问过', 'abd', [1, 2, 3]]
a2 = (5, 6)
b.append(a2)
print(b) # ['A', 'b', '从', '对方身份', '问过', 'abd', [1, 2, 3], (5, 6)]
b = ['A', 'b', '从', '对方身份', '问过', 'abd', [1, 2, 3]]
print(b) # ['A', 'b', '从', '对方身份', '问过', 'abd', [1, 2, 3]]
a2 = "hahaha"
b.append(a2)
print(b) # ['A', 'b', '从', '对方身份', '问过', 'abd', [1, 2, 3], 'hahaha']
b = ['A', 'b', '从', '对方身份', '问过', 'abd', [1, 2, 3]]
print(b) # ['A', 'b', '从', '对方身份', '问过', 'abd', [1, 2, 3]]
a2 = 12345
b.append(a2)
print(b) # ['A', 'b', '从', '对方身份', '问过', 'abd', [1, 2, 3], 12345]
b = ['A', 'b', '从', '对方身份', '问过', 'abd', [1, 2, 3]]
print(b) # ['A', 'b', '从', '对方身份', '问过', 'abd', [1, 2, 3]]
a2 = {"aa": 11}
b.append(a2)
print(b) # ['A', 'b', '从', '对方身份', '问过', 'abd', [1, 2, 3], {'aa': 11}]
(3)再看个额外的情况:
c1 = ["a"]
c2 = [1, 2]
c1.append(c2)
print(c1) # ['a', [1, 2]]
print(c2) # [1, 2]
print(c1 == c2) # False
print(c1[1] == c2) # True
print(id(c1[1]) == id(c2)) # True
print(c1[1] is c2) # True
可以发现,通过id()方法,c1[1]和c2的内存地址是一样的,因此改变这两者任何一个的值,都会受影响:
c1 = ["a"]
c2 = [1, 2]
c1.append(c2)
print(c1) # ['a', [1, 2]]
print(c2) # [1, 2]
c2[0] = 3
print(c1) # ['a', [3, 2]]
print(c2) # [3, 2]
c1 = ["a"]
c2 = [1, 2]
c1.append(c2)
print(c1) # ['a', [1, 2]]
print(c2) # [1, 2]
c1[1].append(66)
print(c1) # ['a', [1, 2, 66]]
print(c2) # [1, 2, 66]
c1 = ["a"]
c2 = [1, 2]
c1.append(c2)
print(c1) # ['a', [1, 2]]
print(c2) # [1, 2]
c1[1][0] = 111
print(c1) # ['a', [111, 2]]
print(c2) # [111, 2]
(4)继(3),要想不受互相的影响,可引入copy模块:
import copy
c1 = ["A"]
c2 = [1, 2]
c1.append(copy.deepcopy(c2))
print(c1) # ['A', [1, 2]]
print(c2) # [1, 2]
c2[0] = 3
print(c1) # ['A', [1, 2]]
print(c2) # [3, 2]
因此,很有必要了解下,Python的赋值和拷贝的区别,可以明白,append操作是对对象的引用
2.extend方法:list.extend(iterable)使用可迭代对象中的所有元素来扩展列表,即,用于在列表末尾一次性追加另一个序列中的多个值,该方法无返回值(返回值为None)
(1)对象可为多种数据类型;如果是列表、元组类型,会将里面的元素拆出追加到末尾;如果是字典类型,只取key值,同样也是将所有的Key值拆出追加到末尾
a = ['A', 'b', '从', '的', '额']
a1 = [1, 2, 3] #列表
# a.extend(a1)
print(a.extend(a1)) # None
print(a) # ['A', 'b', '从', '的', '额', 1, 2, 3]
a2 = (4, 5, 6) #元组
a.extend(a2)
print(a) # ['A', 'b', '从', '的', '额', 1, 2, 3, 4, 5, 6]
a3 = {"aa": 11, "bb": 22} #字典
a.extend(a3)
print(a) # ['A', 'b', '从', '的', '额', 1, 2, 3, 4, 5, 6, 'aa', 'bb']
a4 = {"aaa", "bbb"} #集合
a.extend(a4)
print(a) # ['A', 'b', '从', '的', '额', 1, 2, 3, 4, 5, 6, 'aa', 'bb', 'bbb', 'aaa']
(2)扩展引申下:
a = ['A', 'b', '从', '的', '额']
a1 = [1, 2, 3]
# a.extend(a1)
print(a.extend(a1)) # None
print(a) # ['A', 'b', '从', '的', '额', 1, 2, 3]
a1.append(0)
print(a) # ['A', 'b', '从', '的', '额', 1, 2, 3]
a2 = (4, 5, 6)
a.extend(a2)
print(a) # ['A', 'b', '从', '的', '额', 1, 2, 3, 4, 5, 6]
a2 = a2 + (7, 77)
print(a) # ['A', 'b', '从', '的', '额', 1, 2, 3, 4, 5, 6]
a3 = {"aa": 11, "bb": 22}
a.extend(a3)
print(a) # ['A', 'b', '从', '的', '额', 1, 2, 3, 4, 5, 6, 'aa', 'bb']
a3["cc"] = 33
print(a) # ['A', 'b', '从', '的', '额', 1, 2, 3, 4, 5, 6, 'aa', 'bb']
a4 = {"aaa", "bbb"}
a.extend(a4)
print(a) # ['A', 'b', '从', '的', '额', 1, 2, 3, 4, 5, 6, 'aa', 'bb', 'bbb', 'aaa']
a4.add("ccc")
print(a) # ['A', 'b', '从', '的', '额', 1, 2, 3, 4, 5, 6, 'aa', 'bb', 'bbb', 'aaa']
可见,extend操作不是对对象的引用
3.insert方法:list.insert(i, x)在给定的位置i插入一个元素x,第一个参数是要插入的元素的索引,第二个参数是要插入的对象,该方法无返回值(返回值为None)
a = ['A', 'b', '从', '的', '额']
print(a.insert(0, "插入第一个值")) # None
print(a) # ['插入第一个值', 'A', 'b', '从', '的', '额']
a.insert(3, "插入第2个值") # ['插入第一个值', 'A', 'b', '插入第2个值', '从', '的', '额']
print(a)
(1)该方法也是对对象的引用:
b = [1, 2, 3]
a.insert(2, b) # ['插入第一个值', 'A', 'b', '插入第2个值', '从', '的', '额']
print(a) # ['插入第一个值', 'A', [1, 2, 3], 'b', '插入第2个值', '从', '的', '额']
b[0] = 5
print(a) # ['插入第一个值', 'A', [5, 2, 3], 'b', '插入第2个值', '从', '的', '额']
a[2][1] = 6
print(a) # ['插入第一个值', 'A', [5, 6, 3], 'b', '插入第2个值', '从', '的', '额']
print(b) # [5,6,3]
(2)继(1),要想b不受a的影响,需把a[2]重新定义:
a[2] = [7, 8, 9]
print(a) # ['插入第一个值', 'A', [7, 8, 9], 'b', '插入第2个值', '从', '的', '额']
print(b) # [5,6,3]
4.remove方法:list.remove(x)删除第一个值为x的元素,该方法无返回值(返回值为None)
a = ['A', 'b', '从', '的', 'A', '额']
d={"aa":a}
print(a.remove("A")) # None
print(a) # ['b', '从', '的', 'A', '额']
print(d) #{'aa': ['b', '从', '的', 'A', '额']}
若列表a赋值给其他变量,其删除操作也会影响到其他变量
5.pop方法:list.pop(i)删除列表中给定位置 i 的元素并返回它,如果没有给定位置,a.pop() 将会删除并返回列表中的最后一个元素
(1)list.pop()=list.pop(i=-1)
a = ['A', 'b', '从', '的', 'A', '额']
d={"aa":a}
print(a.pop(0)) # A
print(a) # ['b', '从', '的', 'A', '额']
a.pop()
print(a) # ['b', '从', '的', 'A']
print(d) #{'aa': ['b', '从', '的', 'A']}
若列表a赋值给其他变量,其删除也会影响到其他变量
6.clear方法:删除列表中的所有的元素,该方法无返回值(返回值为None)
a = ['A', 'b', '从', '的', 'A', '额']
d = {"aa": a}
print(a.clear()) # None
print(d) #{'aa': []}
(1)a.clear()等同于del a[:]
a = ['A', 'b', '从', '的', 'A', '额']
a.clear()
print(a) # []
a = ['A', 'b', '从', '的', 'A', '额']
del a[:]
print(a) # []
(2)若列表a赋值给其他变量,其清空也会影响到其他变量:
a = ['A', 'b', '从', '的', 'A', '额']
d = {"aa": a}
print(a.clear()) # None
print(d) # {'aa': []}
print(a) # []
7.index方法:list.index(x[, start[, end]]),若只有参数x,返回列表中第一个值为 x 的元素的从零开始的索引;若给出start,则从下标为index开始查找第一个值为x的元素;若start和end都给出,则从下标index开始,从列表的头开始,长度为end的切片中找第一个值为x的元素;
a = ["A", "b", "从", "A", "对方身份", "问过"]
print(a.index("A")) # 0
print(a.index("A", 1)) # 3
# print(a.index("A", 2, 3)) # 报错 ValueError: 'A' is not in list
print(a.index("A", 2, 4)) # 3
a = ["A", "b", "从", "A", 1, "A", "对方身份", "问过"]
print(a.index("A", 2, 4)) # 3
8.count方法:list.count(x)统计元素 x 在列表中出现的次数
a = ["A", "b", "从", "A", "对方身份", "问过"]
print(a.count("A")) # 2
(1)只统计列表的元素,不能查询列表的列表的元素:
members = [['北斗阳明贪狼星', '北斗阴精巨门星'], ['北斗真人禄存星', '北斗玄冥文曲星'],
['北斗丹元廉贞星', '北斗北极武曲星', '北斗天关破军星']]
# 列表扩充,变为原来的三倍
members *= 3
print(members)
# print(members.index('北斗天关破军星')) # 报错: ValueError: '北斗天关破军星' is not in list
改下:
members = [['北斗阳明贪狼星', '北斗阴精巨门星'], ['北斗真人禄存星', '北斗玄冥文曲星'],
['北斗丹元廉贞星', '北斗北极武曲星', '北斗天关破军星']]
# 列表扩充,变为原来的三倍
members *= 3
print(members)
print(members.index(['北斗丹元廉贞星', '北斗北极武曲星', '北斗天关破军星'])) # 2
print(members[2].index('北斗天关破军星')) # 2
print(members.count('北斗天关破军星')) # 0
print(members[2].count('北斗天关破军星')) # 1
9.sort方法:list.sort( key=None, reverse=False)用于排序列表中的元素,会改变list自身的顺序,没有返回值,即原地排序
(1)reverse=False为默认值,表示升序
a = ["A", "b", "从", "A", "对方身份", "问过"]
print(a.sort()) # None
print(a) # ['A', 'A', 'b', '从', '对方身份', '问过']
a = ["A", "b", "从", "A", "对方身份", "问过"]
a.sort(reverse=False)
print(a) # ['A', 'A', 'b', '从', '对方身份', '问过']
(2)reverse=True为表示降序
a = ["A", "b", "从", "A", "对方身份", "问过"]
a.sort(reverse=True)
print(a) # ['问过', '对方身份', '从', 'b', 'A', 'A']
(3)key值的使用:当列表中的元素不再单一,比如,列表中包含元组或字典
#按元组的第3个值排序
stu=[("winnie","A",12),("lucy","C",16),("john","B",14)]
stu.sort(key=lambda x:x[2])
print(stu) # [('winnie', 'A', 12), ('john', 'B', 14), ('lucy', 'C', 16)]
# s=sorted(stu,key=lambda x:x[1],reverse=True) #默认false ,升序
# print(s)
#按字典的age值排序
stu=[{'name0':'李丽','age':40}, {'name0':'张那','age':30},{'name0':'王原','age':50},{'name0':'王丽萍','age':50}]
stu.sort(key=lambda x:x['age'])
print(stu) # [{'name0': '张那', 'age': 30}, {'name0': '李丽', 'age': 40}, {'name0': '王原', 'age': 50}, {'name0': '王丽 萍', 'age': 50}]
#按tuple的第1个和3个元素进行排序
a = [('mac', 3, 'b'), ('linux', 2, 'a'), ('mac', 1, 'c')]
a.sort(key=lambda x: (x[0], x[2]))
print(a) # [('linux', 2, 'a'), ('mac', 3, 'b'), ('mac', 1, 'c')]
10.reverse方法:list.reverse()用于反转列表中的元素顺序
a = ["A", "b", "从", "A", "对方身份", "问过"]
print(a.reverse()) # None
print(a) # ['问过', '对方身份', 'A', '从', 'b', 'A']
a = [(1, 2), (3, 4)]
a.reverse()
print(a) # [(3, 4), (1, 2)]
a = [[1, 2], [2, 3], [4, 5]]
a.reverse()
print(a) # [[4, 5], [2, 3], [1, 2]]
a = [{"a": 1}, {"b": 2}, {"c": 3}]
a.reverse()
print(a) # [{'c': 3}, {'b': 2}, {'a': 1}]
a = [('mac', 3, 'b'), ('linux', 2, 'a'), ('mac', 1, 'c')]
a.reverse()
print(a) # [('mac', 1, 'c'), ('linux', 2, 'a'), ('mac', 3, 'b')]
11.copy方法:list.copy()返回列表的一个浅拷贝,关于深拷贝和浅拷贝的区别请点击链接
a = [[1, 2], [2, 3], [4, 5]]
b = a.copy()
print(b) # [[1, 2], [2, 3], [4, 5]]
print(id(a)) # 2450533420552
print(id(b)) # 2450532041800
print(id(a[0])) # 2450532041928
print(id(b[0])) # 2450532041928
print(id(a[0][0])) # 140732562986016
print(id(b[0][0])) # 140732562986016
print(id(a[0][1])) # 140732562986048
print(id(b[0][1])) # 140732562986048
print(id(a[1])) # 2450533878664
print(id(b[1])) # 2450533878664
print(id(a[1][0])) # 140732562986048
print(id(b[1][0])) # 140732562986048
print(id(a[1][1])) # 140732562986080
print(id(b[1][1])) # 140732562986080
a[0][1] = 9
print(a) # [[1, 9], [2, 3], [4, 5]]
print(b) # [[1, 9], [2, 3], [4, 5]]
a[1] = [3, 6]
print(a) # [[1, 9], [3, 6], [4, 5]]
print(b) # [[1, 9], [2, 3], [4, 5]]
a = [(1, 2), (3, 4)]
b = a.copy()
print(b) # [(1, 2), (3, 4)]
print(id(a)) # 1921713801544
print(id(b)) # 1921713803080
print(id(a[0])) # 1921673852552
print(id(b[0])) # 1921673852552
print(id(a[0][0])) # 140732562986016
print(id(b[0][0])) # 140732562986016
print(id(a[0][1])) # 140732562986048
print(id(b[0][1])) # 140732562986048
print(id(a[1])) # 1921705723528
print(id(b[1])) # 1921705723528
print(id(a[1][0])) # 140732562986080
print(id(b[1][0])) # 140732562986080
print(id(a[1][1])) # 140732562986112
print(id(b[1][1])) # 140732562986112
a = [{"a": [1, 2]}, {"b": [2, 3]}, {"c": 3}]
b = a.copy()
print(b) # [{'a': [1, 2]}, {'b': [2, 3]}, {'c': 3}]
print(id(a)) # 1449752230920
print(id(b)) # 1449751775880
print(id(a[0])) # 1449711789544
print(id(b[0])) # 1449711789544
print(id(a[1])) # 1449711789616
print(id(b[1])) # 1449711789616
12.len/max/min方法:len(list)表示列表的个数,max(list)返回列表的最大值,min(list)返回列表的最小值:
a = [1, 2, 3]
print(max(a)) # 3
print(min(a)) # 1
print(len(a)) # 3
a = [[1, 9], [3, 6], [4, 5]]
print(max(a)) # [4, 5]
print(min(a)) # [1, 9]
print(len(a)) # 3
a = [(1, 9), (3, 6), (4, 5)]
print(max(a)) # (4, 5)
print(min(a)) # (1, 9)
print(len(a)) # 3
a = ["A", "b", "从", "A", "对方身份", "问过"]
print(max(a)) # 问过
print(min(a)) # A
print(len(a)) # 6
a = ['我', '爱', 'python']
print(max(a)) # 爱
print(min(a)) # python
print(len(a)) # 3
13.可作为栈使用,栈的原理是“后进先出”,用append方法实现“后进”,用pop方法实现“先出”:
stack = [1, 2, 3]
stack.append(4)
stack.append(5)
print(stack) # [1, 2, 3, 4, 5]
stack.pop()
print(stack) # [1, 2, 3, 4]
stack.pop()
print(stack) # [1, 2, 3]
14.作为队列使用,队列的原理是“先进先出”,用append方法实现“后进”,用pop(0)实现“先出”,即,只能在队首执行插入操作,在队尾执行删除操作:
stack = [1, 2, 3]
stack.append(4)
stack.append(5)
print(stack) # [1, 2, 3, 4, 5]
stack.pop(0)
print(stack) # [2, 3, 4, 5]
stack.pop(0)
print(stack) # [3, 4, 5]
然而,列表用作这个目的相当低效,因为在列表的末尾添加和弹出元素非常快,但是在列表的开头插入或弹出元素却很慢 (因为所有的其他元素都必须移动一位);
若要实现一个队列, collections.deque 被设计用于快速地从两端操作。例如:
from collections import deque
print("Start time : %s" % ctime())
queue = deque([1, 2, 3])
queue.append(4)
queue.append(5)
print(queue) # deque([1, 2, 3, 4, 5])
queue.popleft()
print(queue) # deque([2, 3, 4, 5])
queue.popleft()
print(queue) # deque([3, 4, 5])
print("End time : %s" % ctime())