2016年5月14日 星期六

Python 研究-List、Tuple、String、Dict、Set分析

python的基礎資料結構有:列表(list), 元祖(tuple), 字典(dict), 字串(string), 集合(set)

1)列表(list)

列表是Python中最具靈活性的有序集合物件類型,與字串不同的是,列表可以包含任何種類的物件:數字,字串,甚至是其他列表.並且列表都是可變物件,它支持在原處修改的操作.也可以通過指定的索引和分片獲取元素.列表就可元組的可變版本.

定義一個列表使用一對中(方)括號」 [ ] 「.與元組不同的是, 列表有一些內置的函數對列表進行增加,修改和刪除等操作.可以通過list(seq)函數把一個序列類型轉換成一個列表。

   
#定義一個列表
listA = ['a', 'b', 'c', 1, 2]

# 向 list 中增加元素

# 1.使用append   向 list 的末尾追加單個元素。
listA.append(3)

# 2.使用 insert  將單個元素插入到 list 中。數值參數是插入點的索引
listA.insert(3, 'd') # 在下標為3處增加一個元素

# 3.使用 extend 用來連接 list
listA.extend([7, 8])

###  extend 和 append 看起來類似,但實際上完全不同。
### extend 接受一個參數,這個參數總是一個 list,
### 並且把這個 list 中的每個元素增加到原 list 中。
### 另一方面,append 接受一個參數,這個參數可以是任何資料類型,並且簡單地追加到 list 的尾部。

# 獲取列表的長度
print len(listA)  # 9

# 在 list 中搜索
listA.index(3)  # index 在 list 中查找一個值的首次出現並返回索引值。

listA.index('100')  # 如果在 list 中沒有找到值,Python 會引發一個異常。

print 5 in listA  # 要測試一個值是否在 list 內,使用 in。如果值存在,它返回 True,否則返為 False 。

# 從 list 中刪除元素

listA.remove(3)  # remove 從 list 中 僅僅 刪除一個值的首次出現。如果在 list 中沒有找到值,Python 會引發一個異常

print listA.pop()  # pop 它會做兩件事:刪除 list 的最後一個元素,然後返回刪除元素的值。

del listA[0]  # 刪除列表中第一個元素

del listA[0:2] # 刪除列表中第一和第二個元素

# 迭代list
for item in listA:
    print item

其他方法

append(x) 在列表尾部追加單個物件x。使用多個參數會引起異常。
count(x) 返回物件x在列表中出現的次數。
extend(L) 將列表L中的表項增加到列表中。返回None。
Index(x) 返回列表中匹配物件x的第一個列表項的索引。無匹配元素時產生異常。
insert(i,x) 在索引為i的元素前插入物件x。如list.insert(0,x)在第一項前插入物件。返回None。
pop(x) 刪除列表中索引為x的表項,並返回該表項的值。若未指定索引,pop返回列表最後一項。
remove(x) 刪除列表中匹配物件x的第一個元素。匹配元素時產生異常。返回None。
reverse() 顛倒列表元素的順序。
sort() 對列表排序,返回none。bisect模組可用於排序列表項的增加和刪除。

2)元組(tuple)

Python中的元組(Tuple)類似於Java中的陣列,一旦新增了一個 tuple,就不能以任何方式改變它。這點與Python中的字串類似,所以我們說元組和字串都是不可變的序列.元組也支持索引和分片操作.

定義一個元組使用一對小(圓)括號」 ( ) 「.

#元組和列表十分類似,只不過元組和字串一樣是

#不可變的 即你不能修改元組

   
#定義一個元組
tuple1 = (1, 2, '3', 4, '5')

# 定義了一個元組之後就無法再增加或修改元組中的元素

print tuple1[0]    # 元組的元素都有確定的順序。元組的索引也是以0為基點的
print tuple1[-1]   # 負的索引從元組的尾部開始計數
print tuple1[1:3]  # 元組也可以進行切片操作。對元組切片可以得到新的元組。

# 可以使用 in 運算子檢查某元素是否存在於元組中。
print 1 in tuple1   # True

#使用for in 進行迭代元組
for item in tuple1:
    print item

# 如果需要獲取item的序號 可以使用下面的迭代方法:
for index in range(len(tuple1)):
    print tuple1[index]

# 還可以使用內置的enumerate函數
for index, item in enumerate(tuple1):
    print '%i, %s' % (index, item)

其他

tuple=(1,),這是單個元素的元組表示,需加額外的逗號。
tuple=1,2,3,4,這也可以是一個元組,在不使用圓括號而不會導致混淆時,Python允許不使用圓括號的元組。
和列表一樣,可對元組進行索引、分片、連接和重複。也可用len()求元組長度。 
元組的索引用tuple[i]的形式,而不是tuple(i)。
和列表類似,使用tuple(seq)可把其它序列類型轉換成元組。

3)字典(dict)

字典(Dictionary) 是 Python 的內置資料類型之一,它定義了鍵和值之間一對一的關係,但它們是以無序的方式儲存的。 Python 中的 dictionary 像 Java 中的 Hashtable 類的範例。

定義 Dictionary 使用一對大(花)括號」 { } 」
   
# 定義一個字典
# Dictionary 不只是用於存儲字串。Dictionary 的值可以是任意資料類型,
# 包括字串、整數、物件,甚至其它的 dictionary。
# 在單個 dictionary 裡,dictionary 的值並不需要全都是同一資料類型,可以根據需要混用和匹配。
dict1 = {'name' : 'LiuZhichao', 'age' : 24, 'sex' : 'Male'}

dict1['name'] = 'Liuzc' # 為一個已經存在的 dictionary key 賦值,將簡單覆蓋原有的值。

dict1['Age'] = 25 # 在 Python 中是區分大小寫的  age和Age是完全不同的兩個key

# 從字典中刪除元素
del dict1['sex']  # del 允許您使用 key 從一個 dictionary 中刪除獨立的元素

dict1.clear()  # clear 從一個 dictionary 中清除所有元素

# ----------------------------------------
#1)基本
d = {} #空字典
d = {'name':'tom', 'age':22}
   #等價
d = {}
d['name'] = 'tom'
d['age'] = 22
2)dict
d = dict() #空
d = dict(name='tom', age=22)

d = dict([('name','tom'), ('age',22)])
  #等價
keys = ['name','age']
values = ['tom', 22]
d = dict(zip(keys,values))

#3) fromkeys
>>> dict.fromkeys(['name','age'],'default_value')
{'age': 'default_value', 'name': 'default_value'}

#判斷key是否存在
if k in d:   #k not in
    dosomething()

#讀取
print d['name'] #存在得到結果,但是若鍵不存在,將引發異常KeyError。慎用,建議不使用
print d.get('name', 'jack') #存在得到,若鍵不存在,返回第二個參數default_value.若是沒有設default_value返回None

  #使用用例
if k in d:
    print d[k]

try:
    print d[k]
except KeyError:
    dosomething()

print d.get(k, default)
#等價 d[k] if k in d else default


#迭代
for key in d:
    print key, d[key]
    #等價 for key in d.keys()

for key,value in d.items():
    print key, value

#修改
d['name'] = 'tom'

d.update({'name':'tom'})  #這裡支持一整組值
d.update( [ ('name','tom'), ('age',2) ] ) #每個元組兩個元素,(key,value)
d.update('name'='tom', 'age'=4)

#刪除
del d['key']
value = d.pop('key') #刪除並返回值
d.clear() #清空

#排序
d = {'a':10, 'c':8, 'b':9, 'd':7}
#1)字典排序 按照key排序
keys = d.keys()
keys.sort()
for key in keys:
    print d.get(key)
結果為:
10
9
8
7

#2) 按照value進行排序
sorted(d.items(), lambda x,y: cmp(x[1],y[1]))
結果為:
[('d', 7), ('c', 8), ('b', 9), ('a', 10)]

#3) 另一種排序方法
sorted(d)
>>> print d
{'a': 10, 'c': 8, 'b': 9, 'd': 7}

#其他
dictionary的方法
D.get(key, 0)       #同dict[key],多了個沒有則返回缺省值,0。[]沒有則拋異常
D.has_key(key)      #有該鍵返回TRUE,否則FALSE
D.keys()            #返回字典鍵的列表
D.values()          #以列表的形式返回字典中的值,返回值的列表中可包含重複元素
D.items()           #將所有的字典項以列表方式返回,這些列表中的每一項都來自於(鍵,值),但是項在返回時並沒有特殊的順序        

D.update(dict2)     #增加合併字典
D.popitem()         #得到一個pair,並從字典中刪除它。已空則拋異常
D.clear()           #清空字典,同del dict
D.copy()            #拷貝字典
D.cmp(dict1,dict2)  #比較字典,(優先級為元素個數、鍵大小、鍵值大小)
                    #第一個大返回1,小返回-1,一樣返回0
            
dictionary的複製
dict1 = dict        #別名
dict2=dict.copy()   #克隆,即另一個拷貝。

Dict特點:

1:查找速度快

2:浪費空間

3:key不可以重複,且不可變

4:資料無序排放

其他

dict.keys(),dict.values(),dict.items()
hash(obj)返回obj的哈希值,如果返回表示可以作為dict的key
del 或 dict.pop可以刪除一個item,clear清除所有的內容
sorted(dict)可以吧dict排序
dict.get()可以查找沒存在的key,dict.[]不可以
dict.setdefault() 檢查字典中是否含有某鍵。 如果字典中這個鍵存在,你可以取到它的值。 如果所找的鍵在字典中不存在,你可以給這個鍵賦預設值並返回此值。
{}.fromkeys()新增一個dict,例如: {}.fromkeys((『love', 『honor'), True) =>{『love': True, 『honor': True}
不允許一個鍵對應多個值
鍵值必須是哈希的,用hash()測試
一個物件,如果實現_hash()_方法可以作為鍵值使用

4)字串(string)
   
string = "Hello My friend"
>>> print string[0]
H
>>> print string[0:5]
Hello

字串包含判斷運算子:in,not in
>>> print 'He' in string
True
>>> print 'sHe' in string
False

*後面跟數字表示字串重複的次數,比如
print 'hello'*5
>>> hellohellohellohellohello

string模組,還提供了很多方法,如
S.find(substring, [start [,end]]) #可指範圍查找子串,返回索引值,否則返回-1
S.rfind(substring,[start [,end]]) #反向查找
S.index(substring,[start [,end]]) #同find,只是找不到產生ValueError異常
S.rindex(substring,[start [,end]])#同上反向查找
S.count(substring,[start [,end]]) #返回找到子串的個數

S.lowercase()
S.capitalize()      #首字母大寫
S.lower()           #轉小寫
S.upper()           #轉大寫
S.swapcase()        #大小寫互換

S.split(str, ' ')   #將string轉list,以空格切分
S.join(list, ' ')   #將list轉string,以空格連接

處理字串的內置函數
len(str)                #串長度
cmp("my friend", str)   #字串比較。第一個大,返回1
max('abcxyz')           #尋找字串中最大的字符
min('abcxyz')           #尋找字串中最小的字符

string的轉換
            
float(str) #變成浮點數,float("1e-1")  結果為0.1
int(str)        #變成整型,  int("12")  結果為12
int(str,base)   #變成base進制整型數,int("11",2) 結果為2
long(str)       #變成長整型,
long(str,base)  #變成base進制長整型,

字串的格式化(注意其轉義字符,大多如C語言的,略)
str_format % (參數列表) #參數列表是以tuple的形式定義的,即不可執行中改變
>>>print ""%s's height is %dcm" % ("My brother", 180)
#結果顯示為 My brother's height is 180cm

5)集合(set)

Python的集合(set)和其他語言類似, 是一個無序不重複元素集, 基本功能包括關係測試和消除重複元素. 集合物件還支持union(聯合), intersection(交), difference(差)和sysmmetric difference(對稱差集)等數學運算.由於集合是無序的,所以,sets 不支持 索引, 分片, 或其它類序列(sequence-like)的操作。

集合也存在不可變形式,frozenset為固定集合.
   
#定義一個集合
set1 = {1, 2, 3, 4, 5}

# 或者使用 set 函數

list1 = [6, 7, 7, 8, 8, 9]

set2 = set(list1)

set2.add(10)  # 增加新元素

print set2  # set([8, 9, 6, 7])  去掉重複內容,而且是無序的

set3 = frozenset(list1)

set3.add(10)  # 固定集合不能增加元素

### 集合有並集,交集,求差操作
### 並集:intersection() 方法返回一個新集合,包含在兩個集合中同時出現的所有元素。
### 交集:union() 方法返回一個新集合,包含在兩個 集合中出現的元素。
### 差集:difference() 方法返回的新集合中,包含所有在 集合A出現但未在集合B中的元素。
### symmetric_difference() 方法返回一個新集合,包含所有只在其中一個集合中出現的元素。

# 刪除元素
set2.discard(6)   # 當元素不存在時,不會引發異常
set2.remove(6)    # 與discard的區別在於,如果沒有要刪除的元素,remove會引發一個異常
set2.pop()  # 因為set是無序的,所以pop會隨機的從set中刪除一個元素
   
#新增
a = [2,3,4,2,1]
seta = set(a)
>>> print seta
set([1, 2, 3, 4]) #重複的2被刪除掉了

setb = set('abracadabra')
setc = set('alacazam')
>>> print setc
set(['a', 'c', 'z', 'm', 'l'])

#操作
#1)in or not in
x in seta
x not in seta

#2)測試集合是否完全包含
s.issubset(t) #測試是否 s 中的每一個元素都在 t 中
s <= t

s.issuperset(t) #測試是否 t 中的每一個元素都在 s 中
s >= t

#3)其他運算子
s.union(t) # 合併
s | t

s.intersection(t) #求交
s & t

s.difference(t) #返回一個新的 set 包含 s 中有但是 t 中沒有的元素
s - t

s.symmetric_difference(t) # 返回一個新的 set 包含 s 和 t 中不重複的元素
s ^ t

s.copy() # 返回 set 「s」的一個淺複製


s.update(t)
s |= t

s.intersection_update(t)
s &= t

s.difference_update(t)
s -= t

s.symmetric_difference_update(t)
s ^= t

s.add(x) #向 set 「s」中增加元素 x
s.remove(x) #從 set 「s」中刪除元素 x, 如果不存在則引發 KeyError
s.discard(x) #如果在 set 「s」中存在元素 x, 則刪除
s.pop() #刪除並且返回 set 「s」中的一個不確定的元素, 如果為空則引發 KeyError
s.clear() #刪除 set 「s」中的所有元素

其他
set.add(),set.update.set.remove,增加更新刪除,-= 可以做set減法
 set.discard 和 set.remove不同在於如果刪除的元素不在集合內,discard不報錯,remove 報錯
 < <= 表示 子集,> >=表示超集
 | 表示聯合 & 表示交集 - 表示差集 ^ 差分集裡啊

沒有留言:

張貼留言