2024.1.16 Python学习笔记3

列表常用函数

1. list.append(x)：把元素x插入到列表list末尾，list[len(list):]=[x]同样可以实现该功能。
2. list.extend(L)：把列表L中所有元素依次插入列表list末尾，list[len(list):]=L同样可以实现该功能。
3. list.insert(i, x)：将元素x插入到原list中第i个元素前。list.insert(len(list),x)与list.append(x)等价，而list.insert(0,x)可将元素x插入到列表最前面。
4. list.remove(x)：将列表中的第一个值为x的元素删除，如果列表中没有该值的元素，将会返回错误。
5. list.pop([i])：将列表list中第i个元素删除，并返回删除的元素值；如果i缺省，则删除列表尾部元素。（方法中 i 两边的方括号表示这个参数是可选的，而不是要求你输入一对方括号，你会经常在 Python 库参考手册中遇到这样的标记。）
6. list.clear()：将列表list清空。
7. list.index(x)：返回list中第一个值为x的索引，如果列表中没有该值的元素，将会返回错误。
8. list.sort()：对列表元素排序，默认从小到大。
9. list.reverse()：使列表元素倒序。
10. list.copy()：返回列表复制。

list=[1,2,3,4,5]
list.append(6)  #在列表尾部增加元素6
print(list)
#[1, 2, 3, 4, 5, 6]
L=[7,8,9,10]
list.extend(L)  #将L中全部元素依次添加进入list尾部
print(list)
#[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
list.insert(0,0)    #将元素0插入列表队首
print(list)
#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
list.remove(7)  #移除列表list中元素7
print(list)
#[0, 1, 2, 3, 4, 5, 6, 8, 9, 10]
b=list.pop()    #移除列表list尾部元素
print(b,list)
#10 [0, 1, 2, 3, 4, 5, 6, 8, 9]
list.clear()    #清空列表
print(list)
#[]
list.extend(L)  #list=[7,8,9,10]
c=list.index(8) #获取列表中元素8的索引
print(c)
#1
list=[0,1,1,3,3,3,3,4,4,2,2,2]
d=list.count(2) #统计列表中元素2出现个数
print(d)
#3
list.sort() #对列表list排序，顺序为从小到大
print(list)
#[0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4]
list.reverse()  #列表list倒序
print(list)
#[4, 4, 3, 3, 3, 3, 2, 2, 2, 1, 1, 0]
print(L)
L=list.copy()   #获取列表list的复制
print(L)
#[4, 4, 3, 3, 3, 3, 2, 2, 2, 1, 1, 0]

栈、队列

列表借助于append()、pop()函数，可以分别代替进栈、出栈操作。append()使元素进栈，pop()函数使元素出栈，返回出栈元素值，实现后进先出的栈。

l=[]
l.append(2) #[2]
l.append(4) #[2,4]
l.append(9) #[2,4,9]
a=l.pop()   #a=9,l=[2,4]
a=l.pop()   #a=4,l=[2]

而如果使用list.pop(0)，则相当于将列表首部元素取出，此时列表为先进先出，可以视为队列。使用deque函数创建队列型数据，popleft()函数同样可以实现相同的功能。需要注意，实际由于pop(0)会使列表所有元素向前移动，时间复杂度为O(n)，效率较低，注意使用。

l=[]
l.append(2) #[2]
l.append(4) #[2,4]
l.append(9) #[2,4,9]
a=l.pop(0)   #a=2,l=[4,9]
a=l.pop(0)   #a=4,l=[9]

列表推导式

列表推导式是一种简洁的语法，用于快速创建列表。它可以通过在方括号内使用for循环和可选的if条件语句来生成列表元素。通常的原则是，只用列表推导来创建新的列表，并且尽量保持简短。

列表推导式语法如下：

[expression for target1 in iterable1 if condition1
            for target2 in iterable2 if condition2
               ......
            for targetN in iterableN if conditionN]

以下是常见列表推导式范例： 

#使用for循环创建列表
list_a = [a for a in range(5)]
print(list_a)  # 输出：[0, 1, 2, 3, 4]
#如果有if条件语句,for遍历后紧跟着进行条件判断
list_b = [b for b in range(6) if b % 2 != 0]
print(list_b)  # 输出：[1, 3, 5]
#如果有多个for循环,则最终的数据数量为多个for循环的笛卡尔积
list_c = [(c, d) for c in range(3) for d in range(5, 15, 5)]
print(list_c)  # 输出：[(0, 5), (0, 10), (1, 5), (1, 10), (2, 5), (2, 10)]
#嵌套列表推导式和多个并列条件
list_d = [[x for x in range(g - 3, g)] for g in range(22) if g % 3 == 0 and g != 0]
print(list_d)  # 输出：[[-3, -2, -1], [0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11], [12, 13, 14], [15, 16, 17], [18, 19, 20]]
#借助于列表推导式将3X4的矩阵列表转换为4X3列表
matrix = [
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12],
]
list_e=[[row[i] for row in matrix] for i in range(4)]
print(list_e)  # 输出：[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

遍历技巧

遍历字典可借助于items()函数，同时获取关键字与对应的值：

dict={"小明":100,"小红":98,"小芳":110}
for name,score in dict.items():
    print(name,score)
'''
输出:
小明 100
小红 98
小芳 110
'''

遍历列表则可以借助于enumerate() 函数，同时获取元素及其索引：

list=[100,200,300]
for k,v in enumerate(list):
    print(k,v)
'''
输出:
0 100
1 200
2 300
'''  

同时遍历多个序列，则可以借助于函数zip():

list_a=[1,2,3,4]
list_b=[10,20,30,40]
for a,b in zip(list_a,list_b):
    print("{}*10={}".format(a,b))
"""
输出:
1*10=10
2*10=20
3*10=30
4*10=40
"""

需要注意，zip函数实际上是生成一个可迭代对象，其中每个元素为包含各个列表中的相同索引值元素组成的元组。当处理的列表长度不统一时，生成的结果以最短列表长度为准。 

如果想要生成结果以最长列表为准，可以调用itertools模块中的zip_longest函数，此时若遍历超出某列表长度，则使用None代替。

from itertools import zip_longest
list_a=[1,2,3]
string_b='4567'
tuple_c=(8,9,0,1,2)
for i,j,k in zip_longest(list_a,string_b,tuple_c):
    print(i,j,k)
'''
1 4 8
2 5 9
3 6 0
None 7 1
None None 2
'''

 sort()、sorted()辨析

sorted是一个内置函数，它接受一个可迭代对象作为参数，并返回一个新的已排序的列表，而不会修改原始列表。sorted函数可以接受一个关键字参数key，用于指定排序的规则。例如，可以使用lambda函数作为key来指定按照列表中元素的某个属性进行排序。sorted函数语法：

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

其中参数说明：
iterable：可迭代对象
key：通过这个参数，可以借助于函数自定义排序逻辑
reverse：指定排序规则，True为降序，False为升序（默认）。

sorted函数使用实例：

# 列表
random = [(2, 2), (3, 4), (4, 1), (1, 3)]
# 指定第二个元素排序
b=sorted(random,key=lambda x:x[1],reverse=True)
print("排序列表：",b)
#排序列表： [(3, 4), (1, 3), (2, 2), (4, 1)]

sort是列表对象的方法，它会直接修改原始列表，而不会返回一个新的列表。sort方法也可以接受一个关键字参数key，用于指定排序的规则。与sorted不同的是，sort方法没有返回值，它只是在原始列表上进行排序操作。sort函数语法：

sort(key=None,reverse=False)

其中参数说明：
key：通过这个参数，可以借助于函数自定义排序逻辑
reverse：指定排序规则，True为降序，False为升序（默认）。

sort函数使用实例：

# 列表
random = [(2, 2), (3, 4), (4, 1), (1, 3)]
# 指定第二个元素排序
random.sort(key=lambda x:x[1],reverse=False)
print('排序列表：', random)
#排序列表： [(4, 1), (2, 2), (1, 3), (3, 4)]