【Python笔记】可迭代对象的常用操作函数

列表

remove() -> None

按值删除元素，删除==第一个匹配对象==，没有返回，列表原地操作。

lis = [1,2,3,1]
lis.remove(1)
print(lis) // [2,3,1]

pop(i) -> None

按序号删除元素，没有返回，列表原地操作。

lis = [1,2,3]
lis.pop(2)
print(lis) # 1 2

reverse() -> None

列表倒转，不返回任何东西，而lis[::-1]切片本身是一个对象。

lis = [1,2,3]
print(lis[::-1]) # [3,2,1]
print(lis) # [1,2,3] 切片不改变原列表
print(lis.reverse()) # None 此操作没有返回值
print(lis) # [3,2,1] 但是上一步操作会改变列表

count() -> int

匹配元素个数，返回整形

lis = [1,2,3]
print(lis.count(3)) # 1

index(x,start,stop) -> int

按值返回下标（第一个），可选参数制定范围。start和stop是python经典，前闭后开。

lis = [1,2,3,4,5]
print(lis.index(3)) # 2
print(lis.index(3,2,2)) # ValueError: 3 is not in list
print(lis.index(3,2,3)) # 2
print(lis.index(3,3,4)) # ValueError: 3 is not in list

insert(i,value) -> None

把元素插入到位置i之前==，没有返回值，列表原地操作。可用负值作为地址，视为从后往前（-1开始）

lis = [0,0,0,0,0]
lis.insert(2,1)
print(lis) # 0 0 1 0 0 0
lis.insert(-1,1)
print(lis) # 0 0 1 0 0 1 0

sort(*,key = None,reverse = False) -> None

此方法会对列表进行原地排序，只使用 < 来进行各项间比较。 异常不会被屏蔽 —— 如果有任何比较操作失败，整个排序操作将失败（而列表可能会处于被部分修改的状态）。

key 指定带有一个参数的函数，用于从每个列表元素中提取比较键 (例如 key=str.lower)。 对应于列表中每一项的键会被计算一次，然后在整个排序过程中使用。 默认值 None 表示直接对列表项排序而不计算一个单独的键值。

reverse 为一个布尔值。 如果设为 True，则每个列表元素将按反向顺序比较进行排序。

lis = [1,2,4,3]
lis.sort()
print(lis) # [1,2,3,4]


lis.sort(reverse = True)
print(lis) # [4,3,2,1]


lis = [1,'3']
lis.sort() # TypeError: '<' not supported between instances of 'str' and 'int'


lis = ['4','3','a']
lis.sort()
print(lis) # ['3', '4', 'a'] ascii 值分别为 51 52 97


lis = [[1,3],[2,4],[4,3]]
lis.sort(key = lambda x:x[1])
print(lis) # [[1, 3], [4, 3], [2, 4]] 按第二个排序

元组

和列表相同的函数

1. count()
2. index()

元组类似只读列表，所以很多修改的函数没有，只剩下查询函数

字符串

和列表相同的函数

count()

casefold() -> None & lower() -> None

在英语中没有区别，将区分大小写的字符统一转为小写

my_string = "AbcdEfg"
print(my_string.lower()) # abcdefg
my_string = "AbcdEfg"
print(my_string.casefold()) # abcdefg

类似的还有upper()

center(width,fillchar = ’ ') -> str

返回长度为width的字符串，原字符串在正中，用fillchar来填充空余位置，如果长度小于原字符串，返回原字符串。

my_string = "a"
print(my_string.center(3,'*')) # *a*
print(my_string.center(4,'*')) # *a**
print("abcd".center(2,'*')) # abcd
print("abcd".center(6,'**')) # TypeError: The fill character must be exactly one character long

find(sub,start = None, end = None) & index()

查找子字符串的最小索引，start和end会被解读为切片表示法，找不到返回-1.index()方法类似，但是找不到会引发ValueError

print("abcd".find('b')) # 1
print("abcd".find('2')) # -1
print("abcd".index('bc')) # 1
print("abcd".index('e')) # ValueError: substring not found

种类判定

isalpha() -> Bool

如果字符串中的所有字符都是字母，并且至少有一个字符，返回 True ，否则返回 False

print('abc'.isalpha()) # True
print('ab123'.isalpha()) # False

相似的，有以下列表

函数名	匹配对象
isdigit()	数字
islower()	小写字母
isupper()	大写字母

join(iterator) -> str

返回一个由可迭代对象拼接得到的字符串，如果 iterable 中存在任何非字符串值对象则会引发 TypeError。 调用该方法的字符串将作为元素之间的分隔。

print("*".join(['1', '22', '321']))  # 1*22*321
print("*".join(('1', '2', 3)))  # TypeError: sequence item 2: expected str instance, int found
print("abc".join("1234567")) # 1abc2abc3abc4abc5abc6abc7

replace(old,new,count = INF)

替换old为new，默认替换所有，可选参数替换制定次数

print("aaabbb".replace('a','b')) # bbbbbb
print("aaabbb".replace('a','b',2)) # bbabbb

split(sep = None,maxsplit = -1)

将字符串分割成列表，当指定sep的时候，以sep作为依据分割，maxsplit标定分割次数，默认全部分割，若规定分割次数，会有maxsplit + 1个元素

print("a,b,c,d,e,f,g".split(',')) # ['a', 'b', 'c', 'd', 'e', 'f', 'g']
print("abcd,ef,asfsdf,12312,1asd,3".split(',')) # ['abcd', 'ef', 'asfsdf', '12312', '1asd', '3']
print("a,b,c,d,e,f,g".split(',',2)) # ['a', 'b', 'c,d,e,f,g']

如果 sep 未指定或为 None，则会应用另一种拆分算法：连续的空格会被视为单个分隔符，其结果将不包含开头或末尾的空字符串，如果字符串包含前缀或后缀空格的话。 因此，使用 None 拆分空字符串或仅包含空格的字符串将返回 []。

print("a,c,d".split()) # ['a,c,d']
print("a c d".split()) # ['a', 'c', 'd']

字典

clear()

清空字典

dic = {'A':1,'B':2,3:'c'}
dic.clear()
print(dic) # {}

get(key,default)

如果 key 存在于字典中则返回其值，否则返回 default。 如果 default 未给出且 key 不存在于字典中，则返回None

dic = {'A':1,'B':2,3:'c'}
print(dic.get(3)) # c
print(dic.get(4,0)) # 0
print(dic.get(4)) # None

pop(key,default)

如果 key 存在于字典中则将其移除并返回其值，否则返回 default。 如果 default 未给出且 key 不存在于字典中，则会引发 KeyError。

dic = {'A':1,'B':2,3:'c'}
dic.pop(3)
print(dic) # {'A': 1, 'B': 2}
print(dic.pop(4,2)) # 找不到4 返回2
print(dic) # {'A': 1, 'B': 2} dic 没变
dic.pop(4) # KeyError: 4

pop(key,defa)

items() -> list

返回键值对组成的元组列表

dic = {'A':1,'B':2,3:'c'}
print(dic.items()) # dict_items([('A', 1), ('B', 2), (3, 'c')])

参考资料

Python 文档目录 — Python 3.10.10 文档