容器(清單 & 元組 & 字典 & 集合)

序列

序列:  
    每個元素可以是任何類型(也可以是序列)，每個元素被配置設定一個序号(從0開始)（序号，也叫索引，表示元素的位置）

Python中的序列：元組，清單，字元串，Unicode字元串，buffer對象，range對象

元組和清單的本質差別是：清單是可以修改的而元組則不能。

序列的基本操作：

索引(類似于數學中集合的元素)：傳回序列中的元素

使用方法：\[序列[編号]\]

示例：

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

a[-2]

切片(類似數學中集合的子集)：傳回子序列

使用方法：\[序列[開始編号:結束編号後一個:步長(預設為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]

不會改變原有的序列

[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]

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

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)

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()

a.pop(0)

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方法

預設為升序：

a=[4,6,2,1,7,9,6]
a.sort()
a

[1, 2, 4, 6, 6, 7, 9]

參數:

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

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

{'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方法不同的是，當鍵不存在時，自定義的值和該鍵會組成一個新項被加入字典。

{'name': 'Tom'}

d.setdefault('phone','119')

'119'

{'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]

{'wang': '111'}

popitem()随機傳回字典中的項，并從字典中m删除

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

('U', [1, 2, 3, 4])

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

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

探尋有趣之事！

python——序列 &amp; 集合 &amp; 映射容器(清單 &amp; 元組 &amp; 字典 &amp; 集合)