Python學習筆記(三)

組合數據類型

5種內置的序列類型：bytearray,bytes,list,str,tuple

元組

元組：固定，有序，索引從0開始，分片，步距語法支持

不能替換或者刪除其中的任意數據項，使用list()元組能夠轉換爲list,以後就能夠修改了

tuple在不指定參數時返回一個空元組

可使用()建立空元組

在元組做爲參數傳遞時必須加()避免歧義

元組提方法

t.count(x)返回x在元組中出現的次數；

t.index(x)返回x在元組t中出現的最左邊位置，若是元組中不包含x，那麼拋出ValueError異常

元組使用的操做符

+，*，[]，in ,not in ，+=,*=,(實際上建立了新元組)

<,<=,==,!=,>=,>  逐項進行比較

序列拆分

左邊是元組，右邊是序列，稱爲右邊拆分，拆分用於交換值

>>> a,b=(1,2)
>>> a
1
>>> b
2
>>> a,b
(1, 2)
>>> a,b=(b,a)
>>> a,b
(2, 1)

　for ...in...

>>> for x,y in ((1,2),(2,3),(3,4)):
	print(x,y)

1 2
2 3
3 4

　命名的元組

和普通元組同樣，能夠根據名稱來引用元組中的項

collections.namedtuple(n,s)函數，該函數用於建立自定義的元組數據類型

第一個參數是想要建立的字符串元組名稱

第二個參數是字符串，其中包含使用空格分隔的名稱，每一個名稱表明該元組數據類型中的一項

 

列表

列表是包含0個或多個對象引用的有序序列，支持分片，步距

列表是可變的，能夠進行刪除，替換，插入

list()不帶參數調用時返回一個空列表，帶一個list參數時，返回該參數的淺拷貝，對任意多個參數，則嘗試將給定的對象轉換爲列表。

列表可使用[]建立

列表中全部數據項實際上都是對象引用，所以和元組同樣。列表也能夠存聽任意類型的數據項。

列表可使用比較操做符<,<=,==,!=,>=,> 逐項處理

列表方法

l.append(x) 將數據項x追加到列表l的尾部

l.count(x) 數據項x在列表中出現的次數

l.extend(x),l+=x  將迭代x追加到l尾部

l.index(x,start,end) 返回數據項x在列表中最左邊出現的索引位置

l.insert(i,x)在索引位置int i處將數據項 x插入列表l

l.pop()返回並移除l中索引位置int i處的數據項

l.pop(i)返回並移除l中索引位置i處的數據項

l.remove(x)從list中移除最左邊的數據項x，若是找不到x，產生ValueError異常

l.sort()對列表l進行排序，與內置的sorted()函數同樣，這個方法能夠接受可選的key與reverse

序列拆分

用於賦值操做符左邊有兩個或者多個變量時，其中的一個使用*進行引導，數據項賦值給該變量，而全部剩下的數據項賦值給帶*的變量

>>> first,*second=[1,2,3,4,5]
>>> first
1
>>> second
[2, 3, 4, 5]

 

函數調用使用帶*的參數

>>> def getadd(a,b,c):
	return a+b+c

>>> getadd(1,2,3)
6
>>> L=[1,2,3]
>>> getadd(*L)
6

　　

del操做

del的做用是取消變量的引用

>>> a=1
>>> del a

　*操做符是用做複製操做符仍是拆分操做符並不會產生二義性，

當*出如今賦值操做的左邊是，用做拆分操做符，若用做單值操做符，則表明拆分操做符，若用做二進制操做符，則表明複製操做

　　

 列表內涵

小列表一般使用列表字面值直接建立，但長一些的列表，對一系列係數咱們可使用 list(range(10)),或者若是隻須要一個整數迭代，使用range()足夠完成任務，但對更復雜一些的列表使用for...in...循環建立是一種常見的作法。

　　列表內涵是一個表達式，也是一個循環，該循環有一個可選的，包含在方括號中的條件，做用是爲列表生成數據項，

而且可使用條件過濾不須要的數據項

　　[item for item in iterable]

可使用表達式，能夠附加條件

　　[expression for item in iterable]

　　[expression for item in iterable if condition]

 

　range(n)

>>> a=list(range(10))
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> leaps=[y for y in range(1900,1940) if y%4==0]
>>> leaps
[1900, 1904, 1908, 1912, 1916, 1920, 1924, 1928, 1932, 1936]

集合類型

set也是一種組合數據類型

支持成員關係操做符in，對象大小計算操做符len()，支持比較，支持邏輯操做

set分兩種：可變的set，固定的frozenset

只有可哈希運算的對象能夠增長到集合中，可哈希運算的對象包含一個__hash__()方法，返回值在某個對象的聲明週期中都是相同的

而且可使用__eq__()方法進行相等性比較

　　全部內置的固定數據類型都是可hash運算的(float,fozenset,int,str,tuple)

　　內置可變的數據類型都是不可hash運算的（dict,list,set）

集合是0個或多個對象引用的無序組合，集合是可變的，沒有索引位置的概念，也不能分片或按步距分片

 

set() 不帶參數進行調用返回一個空的set，帶一個set參數時返回該對象的淺拷貝，對任意其餘數據類型嘗試進行轉換

空集合必須使用set()建立

集合中包含的數據項都是獨一無二的，增長重複的數據項固定不會引起問題，可是毫無心義

>>> s=set("apple")
>>> s1=set("aple")
>>> s==s1
True

　　集合經常使用語刪除重複項

>>> x=list(set("apple"))
>>> x
['p', 'a', 'e', 'l']

　　集合支持 len(),也支持in，not in

s.add(x) 將數據項x增長到集合s中，若果s中還沒有包含x

s.clear() 移除集合s中的全部項

s.copy() 返回集合s的淺拷貝

s.difference(t)s-t 返回一個新集合，其中包含在s中但不在集合t中的全部數據項

s.differecnce_update(t)s-=t 移除每個在集合t但不在集合s中的項

s.discard(x)若是數據項x存在於集合s中，就移除該數據項

s.intersection(t)s&t返回一個新集合，其中包含全部同時包含在集合t與s中的數據項

s.intersection_update(t)s&=t使得集合s包含自身與集合t的交集

s.isdisjoint(t)若是s與t沒有相同項，返回true

s.issubset(t)s<=t若是集合s與集合t相同，或者是t的本身，就返回true,使用s<t能夠測試 s是不是t的真子集

s.issuperset(t)s>=t若是集合s與集合t相同，或者是t的超集,返回true，使用s>t能夠測試t是不是s的真子集

s.pop（）返回並移除集合s中一個隨即項，若是s爲空集，就產生KeyError異常

s.remove(x) 從集合s中移除數據項x，若是s中不包含x就產生KeyError異常

s.symmetric_difference（t）s^t返回一個新集合，其中包含s與t中的每個數據項，但不包含相同項

s.symmetric_difference_update（t）s^=t使得集合s只包含其自身與集合t的對稱差

s.union(t) s|t返回一個新集合，其中包含集合s中的全部數據項一級在t中而不在s中的數據項

s.update(t) s|=t 將集合t中每一個s中不包含的數據項都增長到集合s中

集合類型的一個經常使用場景是進行快速的成員關係測試。

>>> x={"192.168.1.1","192.168.1.2"}
>>> x
{'192.168.1.1', '192.168.1.2'}
>>> '192.168.1.1' in x
True

　　

>>> s=sorted(set("apple"))
>>> s
['a', 'e', 'l', 'p']

　　

 集合的內涵

 除調用set()建立集合，或使用集合字面值建立集合外，咱們可使用集合內涵來建立集合。

集合內涵是一個表達式，也是一個帶有條件的循環，與列表內涵相似

{expression for item in iterable}

{expression for item in iterable if condition}

咱們可使用上面的語法來過濾

html={x for x in files if x.lower().endswith((".html",".htm"))}

固定集合

固定集合是指一旦建立就不能改變的集合，固定集合智能使用frozenset()數據類型函數進行建立

不帶參數建立換一個空的固定集合，帶一個forzenset參數，返回參數的淺拷貝，對任意其餘數據項都嘗試將給定的數據項轉換爲一個frozenset.該函數智能接受一個參數

因爲固定集合是固定不變的，所以其支持的方法與操做符所產生的結果都不能影響固定集合自己

frozenset.copy()，frozenset.difference(),forzenset.intersection(),frozenset.union()

frozenset.symmetric_difference()

若是將二元運算符應用於集合與固定集合，那麼產生結果的數據類型與左邊操做數的數據類型一直。

因爲固定集合的固定不變性，使得其知足集合項的可哈希運算的標準，所以，集合與固定集合均可以包含固定集合

映射類型

映射是鍵值數據項的組合，而且提供了存取數據項及其鍵，值的方法。進行迭代時，映射類型以任意順序提供其數據項。

兩種無序的映射：內置的dict類型，collections.defaultdict，collections.OrderedDict（有序字典）

只有可hash的對象可用作字典的鍵（float,frozenset,int,str,tuple）均可以用做字典的鍵

字典

dict是一種無序的組合數據類型，包含0或多個鍵值對。

鍵可hash，值可任意類型

字典是可變的

字典是無序的

空的{會建立空字典}

>>> d=dict({"name":"hiuyeung","age":18})

>>> d={"name":"hiuyeung","age":18}

>>> d=dict(name="hiuyeung",age=18)

>>> d=dict([("name","hiuyeung"),("age",18)])

>>> d=dict(zip(("name","age"),("hiuyeung",18)))

　　del

>>> del d['age']
>>> d
{'name': 'hiuyeung'}

　　d.clear()從dict d中移除全部項

d.copy()返回dict d的淺拷貝

d.fromkeys(s,v),返回一個dict該字典的鍵爲序列s中的項，值爲None或者v

d.get(k)返回鍵k相關聯的值，若是k不在dict d中就返回None

d.get(k,v)返回k相關聯的值，若是k不在dict d中就返回v

d.items()返回dict d中全部（key,value）對的視圖

d.keys()返回d中全部鍵的視圖

d.pop(k) 返回k關聯的值，並移除鍵爲k的項，若是k不包含在d中就產生keyError異常

d.pop(k,v)返回k關聯的值，並移除鍵爲k的項，若是k不包含在d中就返回v

d.pop(item)返回並移除dict d中一個任意的(key,value)，若是d爲空就產生keyError異常

d.setdefault(k,v)與dict.get()方法同樣，不一樣在於，若是k沒有包含在dict d中就插入一個鍵爲k的新鄉，其值爲v或None

d.update(a)將a中每一個還沒有包含在dict d中的key，value對增長到d，對同事包含在d與a中的每一個鍵，使用a中對應的值d中對應的值，a能夠是字典，能夠是（key,value）對的一個iterable

d.values() 返回dict d中全部的值視圖

字典的內涵

字典的內涵是一個表達式，同時也是一個循環，該循環帶有一個可選的條件，與集合內涵很是相似。

{keyexpression:valueexpression for key,value in iterable}

{keyexpression:valueexpression for key,value in iterable if condition}

有序字典

collections.OrderedDict 有序字典以數據項插入的順序進行存儲

 

建立有序字典時使用了無序字典，那麼有序字典的順序是任意的