Python基础---List（列表）

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())