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 報錯
< <= 表示 子集，> >=表示超集
| 表示聯合 & 表示交集 - 表示差集 ^ 差分集裡啊
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 報錯
< <= 表示 子集，> >=表示超集
| 表示聯合 & 表示交集 - 表示差集 ^ 差分集裡啊
留言
張貼留言