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'})