Python
Python开发
Python语言
Python语法速查: 2. 列表、元组、字典、集合操作
(1)通用序列操作
“序列”表示索引为非负整数的有序对象集合,列表、元组、字符串都属于序列。区别在于:列表是可变的,而元组和字符串是不可变的。序列的通用操作他们都可以用。
操作或方法简述举例或说明s[i]
返回序列第 i 个元素
-1为最后一个元素,-2为最后第二个元素,依此类推
s[i:j:k]
返回第 i 到 j-1 个元素的新序列,k为可选步长
s1 + s2
操作符,将2个序列拼接生成一个新序列
(1,2) + ('a','b') # 结果为 (1,2,'a','b')
'ab' + 'c' # 结果为 'abc'
s * n
操作符,将序列s重复n次生成新序列
('a') * 3 # 结果为 ('a', 'a', 'a')
'py' * 3 # 结果为 'pypypy'
in / not in
操作符,检查一个值是否在序列中
'a' in 'abc' # 结果为 True
'a' not in ['a','b'] # 结果为 False
s.index(x[, i[, j]])
返回序列中第一次出现x的索引值,i,j 为可选范围
'abc'.index('b') # 结果为 1
'abc'.index('e') # 找不到,引起ValueError错误
s.count(x)
返回序列中x出现的次数
'abab'.count('a') # 结果为 2
'abab'.count('e') # 结果为 0
len(s)
内置函数,返回s中元素个数
len('数123') # 结果为 5(字符串中汉字算2个元素)
● s[i:j:k]
切片规则:
(1) 切片左数字必须小于右数字,否则输出为空
(2) 若 i 或 j 缺省,则表示向这个方向取到尽头
(3) 步长默认为1。若步长为负数,则表示从右向左方向取出元素,此时切片左数字必须大于右数字,否则输出为空。
举例:
>>> 'abcde'[1:3] # 结果为 'bc'
>>> 'abcde'[3:1] # 结果为 ''
>>> 'abcde'[:3] # 结果为 'abc'
>>> 'abcde'[-2:] # 结果为 'de' (含义为从倒数第2个元素开始取到最后一个元素)
>>> 'abcde'[1:-2] # 结果为 'bc' (含义为从正索引第1个元素('b')取到倒数第2个元素的前一个元素('c'))
>>> 'abcde'[:] # 结果为 'abcde' (含义为取出所有元素)
>>> 'abcde'[::-1] # 结果为 'edcba' (含义为从右向左依次取出所有元素)
>>> 'abcde'[::-2] # 结果为 'eca'
>>> 'abcde'[0:2:-1] # 结果为 '' (当步长为负数时,切片左数字必须大于右数字,否则输出为空)
>>> 'abcde'[-1:-3:-1] # 结果为 'ed'
>>> 'abcde'[1::-1] # 结果为 'ba' (步长为负数表示从右向左取,左数字为1表示从'b'开始取,右数字为空表示向左取到尽头)
(2)列表操作
操作或方法简述举例或说明简单操作
s[i] = v
元素赋值
[1,2,3][1]=20 # 结果为 [1,20,3]
s[i:j:k] = t
切片赋值
用法较灵活,详见下述
del s[i]
元素删除
del [1,2,3][1] # 结果为 [1,3]
del s[i:j:k]
切片删除第 i 到 j-1 个元素,步长为k。切片规则见上。
a=[1,2,3,4,5]
del a[1:3] # 结果为 a=[1,4,5]
也可写成 a[1:3]=[] # 结果同上
列表专用方法
list([iter])
内置函数,根据入参可迭代对象iter生成一个浅复制列表实例。若入参为字符串,则将其拆分成由个单字符组成的列表。
s=list() # 生成一个空列表,也可写成 s=[]
s=list([1,2,3]) # 生成一个浅复制新列表
s=list('abc') # 结果为 ['a','b','c']
s.append(x)
将一个新元素x追加到列表末尾
[1,2,3].append(4) # 结果为 [1,2,3,4]
s.extend(t)
将一个新列表t追加到列表末尾
[1,2,3].extend([4,5]) # 结果为 [1,2,3,4,5]
s.insert(i, x)
在索引 i 处插入元素x,若 i 超出索引范围,则元素x添加到最后。
[1,2,3].insert(-1,4) # 结果为 [1,2,4,3]
[1,2,3].insert(10,5) # 结果为 [1,2,3,5]
s.pop([i])
返回索引 i 处的元素并从列表中移除它。若省略 i,则返回列表中最后一个元素并移除它。若 i 超出索引范围,则引发IndexError。
[1,2,3].pop(-2) # 返回2,列表结果为 [1,3]
[1,2,3].pop() # 返回3,列表结果为 [1,2]
s.remove(x)
在列表中搜索x并移除第1个发现的x,若未发现x则引发ValueError。
[1,2,1,2].remove(2) # 结果为 [1,1,2]
s.reverse()
颠倒列表中所有元素的位置顺序
[1,3,2,4].reverse() # 结果为 [4,2,3,1]
s.sort(*, key=None, reverse=False)
对s中所有元素按自定义规则进行排序,返回值为空,不会生成新的列表
s.index(x[, i[, j]])
返回序列中第一次出现x的索引值(通用序列方法已述,此处仅为索引方便)
s.count(x)
返回序列中x出现的次数(通用序列方法已述,此处仅为索引方便)
● s[i:j:k] = t
说明:
分片赋值可以使用与原列表不等长的列表进行赋值,这就使得其用法非常灵活。其赋值规则是:移除等号左边分片划定范围内的元素,并在此位置用等号右边新的列表中的元素替代。
举例:
>>> [1,2,3,4,5][2:4] = [30,40] # 结果为 [1,2,30,40,5] (切片长度等于等号右边列表长度)
>>> [1,2,3,4,5][2:4] = [30] # 结果为 [1,2,30,5] (移除原列表中切片的2个元素,并用新的1个元素进行替换)
>>> [1,2,3,4,5][2:4] = [30,31,32] # 结果为 [1,2,30,31,32,4,5] (移除原列表中切片的2个元素,并用新的3个元素进行替换)
>>> [1,2,3,4,5][2:4] = []# 结果为 [1,2,5] (相当于将切片元素删除)
>>> [1,2,3,4,5][2:2] = [10,11] # 结果为 [1,2,10,11,3,4,5] (由于切片[1:1]切不到移除元素,故此句相当于在位置2插入等号右边的列表元素)
● s.sort(*,key=None, reverse=False)
说明:
sort()方法会对原列表进行排序,返回值为空,不会生成新的列表。入参key可以指定一个函数对每个将要被排序的元素进行预处理,使得某些原本不能比较大小的元素,也能进行大小排序(原理和上一篇内置函数sorted()相同)。reverse为True时表示逆向排序。
举例:
>>> [1,3,4,2].sort() # 结果为 [1,2,3,4]
>>> [1,3,4,2].sort(reverse=True) # 结果为 [4,3,2,1]
>>> [('b',2),('a',1)].sort(key=lambda x:x[1]) # 结果为 [('a',1),('b',2)]
>>> # 说明:上例中,使用匿名函数lambda对列表元素进行了预处理,将原本的元组('a',1)预处理为:取出元组中后一个元素(即:1),所以能够进行排序。
(3)元组操作
元组为不可变序列,故元组只能使用开头所述的通用序列方法,而上面列表的方法元组都不可用。
操作或方法简述举例或说明tuple([iter])
内置函数,生成入参可迭代对象iter的一个浅复制元组实例。
t=tuple() # 生成一个空元组,也可写成 t=()
t=tuple([1,2,3]) # 生成 (1,2,3)
t=tuple('abc') # 生成 ('a','b','c')
(4)字典操作
字典是“映射”类型,它是无序的,不能通过元素位置进行索引,只能通过键值进行索引。
操作或方法简述举例或说明简单操作
d[k] = x
将已定义的字典d中键为k的值设为x,若k不存在,则建立k,v“键值对”
d = {}
d['a']=1 # 结果为 d={'a':1}
del d[k]
从字典d中删除d[k],若键k不存在,则引发KeyError错误
d={'a':1}
del d['a'] # 结果为 d={}
k in d
若k是字典d中的键,则返回Tru,否则返回False
'a' in {'a':1} # 结果为 True
字典专用方法
dict([m])
生成字典实例,有多种初始化方法,详见右例
d=dict() # 生成一个空字典,同 d={}
d=dict({'a':1}) # 浅复制生成字典,d={'a':1}
d=dict([('a',1),('b',2)]) # 用元组列表生成字典,d={'a':1,'b':2}
d=dict(a=1,b=2) # 用入参变量名生成字典,d={'a':1,'b':2}
d.clear()
将字典内的所有内容清空
d.clear() # 结果为 d={}
d.copy()
返回d的一个浅复制副本
d2=d.copy() # d2为d的一个副本,并不指向d
dict.fromkeys(s [,v])
这是个类方法。创建返回一个新字典并将序列s中的所有元素作为新字典的键,这些键对应的值均为v;若缺省v,则这些值为None。
d=dict.fromkeys(['a','b'])
# 结果为 d={'a':None, 'b':None}
d.get(k [,v])
返回d[k],若找不到键k,则返回v;若找不到键k且未指定v,则返回None
{'a':1}.get('a') # 结果为 1
{'a':1}.get('b',2) # 结果为 2
d.items()
返回由d中的“键值对”元组组成的可迭代对象。
{'a':1,'b':2}.items()
# 结果为 dict_items([('a',1),('b',2)])
d.keys()
返回由d中的键组成的可迭代对象。
{'a':1,'b':2}.keys()
# 结果为 dict_keys(['a','b'])
d.values()
返回有d中的值组成的可迭代对象。
{'a':1,'b':2}.values()
# 结果为 dict_values([1,2])
d.pop(k [,default])
如果找到d[k],则返回它,并从d中删除它;否则,若提供了default值,则返回这个值,若没有则引发KeyError错误
{'a':1}.pop('a') # 返回值为 1
{'a':1}.pop('b',2) # 返回值为 2
d.popitem()
从字典d中随机返回一个“键值对”元组,并把它从d中删除
d={'a':1,'b':2}
d.popitem() # 返回值为('b':2)
d.setdefault(k [,v])
如果找到d[k],则返回它并无视v;若没找到,则返回v,并将d[k]设为v
d={'a':1,'b':2}
d.setdefault('c',3) # 返回值为3,并且改变d
#结果 d={'a':1,'b':2,'c':3}
d.update(b)
将入参字典b中所有的“键值对”添加到d中,若b与d中有键重复,则原d中的“键值对”被新值覆盖。
d={'a':1,'b':2}
d.update({'b':20,'c':3})
# 结果为 d={'a':1,'b':20,'c':3}
(5)集合操作
集合同样也是无序的,分为可变集合(set)和不可变集合(frozenset)两种,可变集合用大括号“{}”表示。
操作或方法简述举例或说明通用集合操作
s.copy()
返回s的一个浅复制副本
s2=s.copy() # s2为s的一个浅复制副本,并不指向s
s.issubset(t)
如果s是t的一个子集,则返回True
{1}.issubset({1,2}) # 结果为 True
s.issuperset(t)
如果s是t的一个超集,则返回True
{1,2}.issuperset{{1}} # 结果为 True
s.union(t)
求s和t的并集
{1,2}.union({2,3}) # 结果为 {1,2,3}
s.intersection(t)
求s和t的交集
{1,2}.intersection({2,3}) # 结果为 {1,2,3}
s.isdisjoint(t)
如果s和t没有交集,则返回True
{1,2}.isdisjoint({3}) # 结果为 True
s.difference(t)
求差集s-t
{1,2,3}.difference({1,2}) # 结果为 {3}
s.symmetric_difference(t)
返回所有在s或t中,但又不同时属于这两个集合中的项的集合(对称差集)
{1,2}.symmetric_difference({2,3})
# 结果为 {1,3}
可变集合专用方法
set([iter])
可以用任何可迭代对象来生成一个集合
s = set() # 结果为 {},效果同 s={}
s = set([1,2]) # 结果为 {1,2}
s = set({'a':1}) # 结果为 {'a'}
s.clear()
删除集合s中的所有项
s.clear() # 结果为 {}
s.add(x)
将x添加到集合s中,若x已在集合中,则无任何效果
{1,2}.add(3) # 结果为 {1,2,3}
s.discard(x)
从s中删除成员x,若x不在集合中,则无任何效果
{1,2,3}.discard({3}) # 结果为 {1,2}
s.remove(x)
从s中删除成员x,若x不在集合中,则引发KeyError错误
{1,2}.remove({3}) # 结果引发KeyError错误
s.pop()
随机从s中返回一个元素,并将其从s中删除
{1,2,3}.pop() # 返回值为2,结果为{1,3}
s.update(iter)
将iter中所有对象添加到s中,iter可以是任何可迭代对象
{1}.update([1,2,3]) # 结果为 {1,2,3}
s.intersection_update(t)
将s更新为:s与t的交集
{1,2}.intersection_update({2,3})# 结果为 {2}
s.dirrerence_update(t)
从s中删除同时也在t中的项
{1,2,3}.difference_update({1})# 结果为 {2,3}
s.symmetric_difference_update(t)
将s更新为:所有在s或t中,但又不同时在这两个集合中的项(对称差集)
{1,2}.symmetric_difference_update({2,3})
# 结果为 {1,3}
不可变集合专用方法
frozenset([iter])
可以用任何可迭代对象来生成一个不可变集合
f = frozenset() # 结果为 frozenset()
f = frozenset([1]) # 结果为 frozenset({1})
内容来源于网络,如有侵权请联系客服删除