python——序列 & 集合 & 映射

时间:2023-03-08 16:08:05
python——序列 &  集合 & 映射

容器(列表 & 元组 & 字典 & 集合)

序列

序列:
每个元素可以是任何类型(也可以是序列),每个元素被分配一个序号(从0开始)(序号,也叫索引,表示元素的位置)

Python中的序列: 元组,列表,字符串,Unicode字符串,buffer对象,range对象

  • 元组和列表的本质区别是:列表是可以修改的而元组则不能。

序列的基本操作:

索引(类似于数学中集合的元素):返回序列中的元素

使用方法:$$序列[编号]$$

示例:

a=[1,2,3,4]
a[0]
1
a[-2]
3

切片(类似数学中集合的子集):返回子序列

使用方法:$$序列[开始编号:结束编号后一个:步长(默认为1)]$$

示例:

a=[1,2,3,4,5]
a[1:3]
[2, 3]
a[1:-1]
[2, 3, 4]
a[1:]
[2, 3, 4, 5]
a[:-1]
[1, 2, 3, 4]
a[:]
[1, 2, 3, 4, 5]

序列加(同类型的序列的拼接)

类似于$$一篮苹果+一篮香蕉=两篮水果$$

使用方法:$$序列+序列$$

示例:

a=[1,2,3]
b=[2,3,4]
a+b
[1, 2, 3, 2, 3, 4]

+ 不会改变原有的序列

a
[1, 2, 3]

序列乘

类似于$$一个苹果n=n个苹果$$

使用方法:$$序列
n(n表示重复次数)$$

示例:

a=[1,2,3]
a*3
[1, 2, 3, 1, 2, 3, 1, 2, 3]

in(类似于某个元素是否属于某个集合的判断)

使用方法:

a in 序列A

若\(a\in A\),则返回True,否则返回False。

len,max,min分别返回序列的长度,最大值,最小值

使用方法:

len(序列)
max(序列)
min(序列)

列表

列表的修改

示例:

a=[1,2,3,4]
a[0]=2
a
[2, 2, 3, 4]
a[1:3]=[5,6]
a
[2, 5, 6, 4]
a[1:3]=''
a
[2, 4]
a[0:0]=[99,88]
a
[99, 88, 2, 4]
a[1:3]=list('hello')
a
[99, 'h', 'e', 'l', 'l', 'o', 4]
del a[0]
a
['h', 'e', 'l', 'l', 'o', 4]
del a[0:3]
a
['l', 'o', 4]

列表方法

调用对象的方法:\(对象.方法(参数)\)

append方法

可以在列表的末尾追加新的元素:

a=[1,2,3]
a.append(4)
a
[1, 2, 3, 4]
a.append([1,5,'fr'])
a
[1, 2, 3, 4, [1, 5, 'fr']]
count方法

查看某个元素在列表中出现的次数:

a=[1,2,3,4,1,2]
a.count(1)
2
extend方法

使用其他列表拓展原有列表,其他列表的元素被添加到原有列表的末尾:

a=[1,2,3]
a.extend([4,5,6])
a
[1, 2, 3, 4, 5, 6]
index方法

返回某个元素的索引,如若此元素不存在,则会引发异常。

a=[1,2,3,45,5,45,7,84]
a.index(45)
3
insert方法

在序列的某个位置插入一个元素:

a=[1,2,3,4]
a.insert(2,'hello')
a
[1, 2, 'hello', 3, 4]
a.insert(20,'world')     #20号位置不存在,直接插到列表末尾
a
[1, 2, 'hello', 3, 4, 'world']
pop方法

移除列表某个位置的元素并返回该元素,如若没有指定要移除元素的位置,则默认移除末项。

a=[1,2,3,4]
a.pop()
4
a.pop(0)
1
remove方法

移除序列中第一个与参数匹配的元素:

a=[1,2,88,3,4,88,2]
a.remove(88)
a
[1, 2, 3, 4, 88, 2]
reverse方法

将列表改为倒序:

a=[1,2,3,4,2,5,3]
a.reverse()
a
[3, 5, 2, 4, 3, 2, 1]
sort方法
  1. 默认为升序:
a=[4,6,2,1,7,9,6]
a.sort()
a
[1, 2, 4, 6, 6, 7, 9]
  1. 参数:
key用来为每个元素提取比较值(默认值为None);
reverse为True时是反序(默认值为False)。
names=['Judy','Perter','Perkins']
names.sort(key=len)
names
['Judy', 'Perter', 'Perkins']

元组

"元组的不可修改"是指元组的每个元素指向永远不变:

b=('python','20150101',['a','b'])
b
('python', '20150101', ['a', 'b'])
b[2][0]='c'
b
('python', '20150101', ['c', 'b'])
b[2].append('d')
b
('python', '20150101', ['c', 'b', 'd'])

字典(dict/map)

形式:

{key:value,...}

字典的创建

以例子说明:

d={'wang':'111','U':'123'}
d
{'U': '123', 'wang': '111'}
d1=dict([('A',1),('B',2)])
d1
{'A': 1, 'B': 2}
d2=dict(A=1,B=2)
d2
{'A': 1, 'B': 2}
d3=dict(d2)
d3
{'A': 1, 'B': 2}

字典的操作

(通过键)查找,修改

示例:

d={'wang':'111','U':'123'}
d['U']
'123'
d['wang']=111
d
{'U': '123', 'wang': 111}

删除:del语句

del  字典[键]

len(字典)返回字典的项数

in(类似于序列的用法)

字典的方法

clear()

清除字典中所有的项

d={'wang':'111','U':'123'}
d.clear()
d
{}

复制copy()

浅复制,得到一个键的指向完全相同原字典的副本。

d={'wang':'111','U':[1,2,3,4]}
d1=d.copy()
d1
{'U': [1, 2, 3, 4], 'wang': '111'}

原地修改原字典d,相应的d1也会被修改,反之亦然。

d1['U'].append('lr')
d1
{'U': [1, 2, 3, 4, 'lr'], 'wang': '111'}
d
{'U': [1, 2, 3, 4, 'lr'], 'wang': '111'}

如果使用deepcopy()函数则可以避免上述情况发生。

d={'wang':'111','U':[1,2,3,4]}
from copy import deepcopy
d1=deepcopy(d)
d1
{'U': [1, 2, 3, 4], 'wang': '111'}
d1['U'].append('lr')
d1
{'U': [1, 2, 3, 4, 'lr'], 'wang': '111'}
d
{'U': [1, 2, 3, 4], 'wang': '111'}

get方法,查找元素

如若元素不存在,可以自定义返回的内容(默认为None):

d={}
d.get('name')
d['name']='Tom'
d
{'name': 'Tom'}
d.get('name')
'Tom'
d.get('phone','Unknown')
'Unknown'

setdefault方法,查找元素

与get方法不同的是,当键不存在时,自定义的值和该键会组成一个新项被加入字典。

d
{'name': 'Tom'}
d.setdefault('phone','119')
'119'
d
{'name': 'Tom', 'phone': '119'}

items(),keys(),values()均以列表的形式返回 a set-like object,其中的元素分别为"项","键","值"。

d={'wang':'111','U':[1,2,3,4]}
d.items()
dict_items([('wang', '111'), ('U', [1, 2, 3, 4])])
d.keys()
dict_keys(['wang', 'U'])
d.values()
dict_values(['111', [1, 2, 3, 4]])

pop(键)返回键对应的值,并删除字典中这个键对应的项

d={'wang':'111','U':[1,2,3,4]}
d.pop('U')
[1, 2, 3, 4]
d
{'wang': '111'}

popitem()随机返回字典中的项,并从字典中m删除

d={'wang':'111','U':[1,2,3,4]}
d.popitem()
('U', [1, 2, 3, 4])
d
{'wang': '111'}

update 使用新字典更新旧字典

新字典中有而旧字典中没有的项会被加入到旧字典中;

新字典中有而旧字典中也有的值会被新字典的值所代替。

d1={'n':'xx','p':'110'}
d2={'p':'120','a':'A'}
d1.update(d2)
d1
{'a': 'A', 'n': 'xx', 'p': '120'}
d2
{'a': 'A', 'p': '120'}

集合(类似于数学中集合的概念)

  • set() 可变集合
  • frozen() 不可变集合

集合的元素必须是不可变对象(如字符串,元组等),且元素间有互异性。

set('Hello')
{'H', 'e', 'l', 'o'}

集合的基本操作

  • 与序列一样拥有len(),min(),max()函数

  • add方法,添加元素

s=set(['Python','is','a','magic','language'])
print(s)
{'a', 'magic', 'Python', 'language', 'is'}
s.add('!')
s
{'!', 'Python', 'a', 'is', 'language', 'magic'}

也支持更新(update)

a=set([1,2,3,4])
b=set([3,4,5,6])
a.update(b)
a
{1, 2, 3, 4, 5, 6}
  • remove方法删除集合中元素
s=set('hello')
s
{'e', 'h', 'l', 'o'}
s.remove('h')
s
{'e', 'l', 'o'}

使用remove方法,若元素不存在,则会引发错误,而discard则不会。

s.discard('om')

集合的特殊操作

等价(==) & 不等价(!=)

set('Python') == set('python')
False
set('Python') != set('python')
True

子集 & 超集

<,<=,>,>=   用来判断前面一个集合是否是后面一个集合的严格子集,子集,严格超集,超集
set('Hello') < set('HelloWorld')
True
set('Hello') <= set('Hello')
True
set('Hello') < set('Hello')
False

并(\(\bigcup\)) :使用 |

set('Hello') | set('world')
{'H', 'd', 'e', 'l', 'o', 'r', 'w'}

交(\(\bigcap\)):使用 &

set('Hello') & set('world')
{'l', 'o'}

差(-) :使用 -

set('Hello') - set('world')
{'H', 'e'}

对称差: 使用 ^

set([1,2,3,4])^set([3,4,5,6])
{1, 2, 5, 6}

Notes:

  • 如是可变集合(set)与不可变集合 (frozenset) 进行运算,得到的新集合的类型与左操作数相同。

    对于可变集合(set)可以进行就地修改:
    • 操作符为:|=,&=,-=,^=
  • 集合只能包含不可变的 (即可散列的) 对象类型。
a=set('Hello')
a |= set('Python')
a
{'H', 'P', 'e', 'h', 'l', 'n', 'o', 't', 'y'}
a=set('Hello')
a &= set('Python')
a
{'o'}
a=set('Hello')
a -= set('Python')
a
{'H', 'e', 'l'}
a=set('Hello')
a ^= set('Python')
a
{'H', 'P', 'e', 'h', 'l', 'n', 't', 'y'}
b=set('Hello')|frozenset('Python')
b
{'H', 'P', 'e', 'h', 'l', 'n', 'o', 't', 'y'}
c=frozenset('Python')|set('Hello')
c
frozenset({'H', 'P', 'e', 'h', 'l', 'n', 'o', 't', 'y'})