2016年5月14日 星期六

Python 研究-元祖,列表,字典,集合的比較

Python元祖,列表,字典,集合的比較
1. 元組
可以包含不同類型的物件,但是是不可變的,不可以在增減元素,用()來定義.
元組的操作: tuple(obj),切片,in,for in,del,cmp,len,max,min
1.    #定義一個元組
2.    tuple1 =()
3.    tuple1 = tuple({1,2,3,4,5,'6'})
4.    tuple1 = (1, 2, '3', 4, '5')
5.    # 定義了一個元組之後就無法再增加或修改元組中的元素,但是可以重新賦值
6.   
7.    print tuple1[0]    # 元組的元素都有確定的順序。元組的索引也是以0為基點的
8.    print tuple1[-1]   # 負的索引從元組的尾部開始計數
9.    print tuple1[1:3]  # 元組也可以進行切片操作。對元組切片可以得到新的元組。
10.   
11.    # 可以使用 in 運算子檢查某元素是否存在於元組中。
12.    print 1 in tuple1   # True
13.   
14.    #使用for in 進行迭代元組
15.    for item in tuple1:
16.        print item
17.   
18.    # 如果需要獲取item的序號 可以使用下面的迭代方法:
19.    for index in range(len(tuple1)):
20.        print tuple1[index]
21.   
22.    # 還可以使用內置的enumerate函數
23.    for index, item in enumerate(tuple1):
24.        print '%i, %s' % (index, item)
25.   
26.    print max(tuple1)
27.    print min(tuple1)
28.    print len(tuple1)
2. 列表
        列表是Python中最具靈活性的有序集合物件類型,與字串不同的是,列表可以包含任何種類的物件:數字,字串,甚至是其他列表. 並且列表都是可變物件,它支持在原處修改的操作.也可以通過指定的索引和分片獲取元素.列表就可元組的可變版本,用[]來定義.
列表的操作: list(obj),切片,in,for in,del,cmp,len,max,min
額外的操作:
list.append(),list.insert(index,obj),list.extend(seq),list.remove(obj),list.pop(index=-1),list.count(obj),sorted(list),reversed(list),list.index(obj)
1.    #定義一個列表
2.    listA = ['a', 'b', 'c', 1, 2]
3.   
4.    list(obj)
5.    #把物件轉換成列表,obj可以是元組,字典,字串等
6.    print list((1,2,3,4,5,6,8,6))
7.    #[1,2,3,4,5,6,8,6]
8.    haloword = list('halo word')
9.    print haloword
10.    #['h', 'a', 'l', 'o', ' ', 'w', 'o', 'r', 'd']
11.   
12.    #元素計數
13.    print haloword.count('o')
14.    #2
15.   
16.    #元素查找(返回第一次出現索引,沒有則報錯)
17.    print haloword.index('o')
18.    #3
19.    #haloword[3]='o'
20.   
21.    #元素排序,倒置位置
22.    numbers = [1,2,3,'4',5,'6']
23.    print sorted(numbers)
24.    #[1, 2, 3, 5, '4', '6']
25.    print list(reversed(numbers))
26.    #['6', 5, '4', 3, 2, 1]
27.   
28.    # 向 list 中增加元素
29.   
30.    # 1.使用append   向 list 的末尾追加單個元素。
31.    listA.append(3)
32.   
33.    # 2.使用 insert  將單個元素插入到 list 中。數值參數是插入點的索引
34.    listA.insert(3, 'd') # 在下標為3處增加一個元素
35.   
36.    # 3.使用 extend 用來連接 list
37.    listA.extend([7, 8])
38.   
39.    # extend 和 append 看起來類似,但實際上完全不同。
40.    # extend 接受一個參數,這個參數總是一個 list,
41.    # 並且把這個 list 中的每個元素增加到原 list 中。
42.    # 另一方面,append 接受一個參數,這個參數可以是任何資料類型,並且簡單地追加到 list 的尾部。
43.   
44.    # 獲取列表的長度
45.    print len(listA)  # 9
46.   
47.    # 在 list 中搜索
48.    listA.index(3)  # index 在 list 中查找一個值的首次出現並返回索引值。
49.   
50.    listA.index('100')  # 如果在 list 中沒有找到值,Python 會引發一個異常。
51.   
52.    # 要測試一個值是否在 list 內,使用 in。如果值存在,它返回 True,否則返為 False 。
53.    print 5 in listA 
54.   
55.    # 從 list 中刪除元素
56.    # remove 從 list 中 僅僅 刪除一個值的首次出現。如果在 list 中沒有找到值,Python 會引發一個異常
57.    listA.remove(3) 
58.   
59.    # pop 它會做兩件事:刪除 list 的最後一個元素,然後返回刪除元素的值。
60.    print listA.pop() 
61.   
62.    # 迭代list
63.    for item in listA:
64.        print item
3. 字典
        字典(Dictionary) 是 Python 的內置資料類型之一,它定義了鍵和值之間一對一的關係,但它們是以無序的方式儲存的。
        定義 Dictionary 使用一對大(花)括號」 { } 」。
字典的操作: dict(obj),in,for key in dict,del,cmp,len,max,min
額外的操作:
dict[key],dict.keys(),dict.fromkeys(seq,value),dict.has_key(key),dict.get(key,default),dict.items(),dict.values():,dict.update(dict2),dict.pop(key),dict.setdefault(key ,defaultvalue),dict.clear(),dict.copy()
1.    # 定義一個字典
2.    # Dictionary 不只是用於存儲字串。Dictionary 的值可以是任意資料類型,
3.    # 包括字串、整數、物件,甚至其它的 dictionary。
4.    # 在單個 dictionary 裡,dictionary 的值並不需要全都是同一資料類型,可以根據需要混用和匹配。
5.    dict1 = {'name' : 'LiuZhichao', 'age' : 24, 'sex' : 'Male'}
6.   
7.    dict1['name'] = 'Liuzc' # 為一個已經存在的 dictionary key 賦值,將簡單覆蓋原有的值。
8.   
9.    dict1['Age'] = 25 # 在 Python 中是區分大小寫的  age和Age是完全不同的兩個key
10.   
11.    #使用dict()新增字典
12.    dict_test = dict((['x',1],['y',2]))
13.    #{'y': 2, 'x': 1}
14.   
15.    #使用dict.fromkeys()新增字典
16.    #新增並返回一個新字典,以序列seq中元素做字典的鍵,val為字典所有鍵對應的初始值(預設為None)
17.    dict.fromkeys(seq,val=None)
18.   
19.    #迭代陣列 form key in dict_test (不可以更改字典長度,報錯)
20.    # 方法 1.報錯
21.    form key in dict_test:
22.        if(key=='x'):
23.            del dict_test[key]
24.    # 方法 2.正常
25.    from key in dict_test.keys()
26.        if(key=='x'):
27.            del dict_test[key]
28.   
29.    #dict.has_key(key)判斷key是否存在
30.    dict_test.has_key('x')
31.    #True
32.   
33.    #dict.get(key,default) 返回鍵值key的值,若是key不存在,返回default的值
34.    dict_test.get('x',0)
35.    #1
36.   
37.    #dict.update(dict2) 將dict2的鍵值對列表增加到字典dict中去
38.    dict_test.update({
39.        'name':'rming',
40.        'age':100,
41.    })
42.    #{'y': 2, 'x': 1,'name':'rming','age':100}
43.   
44.    #dict.pop(key)返回鍵值key的value ,刪除原字典該減值
45.    print dict_test.pop('name')
46.    print dict_test
47.    #rming
48.    #{'y': 2, 'x': 1,'age':100}
49.   
50.    #dict.setdefault(key ,defaultvalue) 類似get方法,能夠獲得給定key的value,此外setdefault還能在自動重不含有給定key的情況下設定相應的key-value
51.    dict_test.setdefault('sex','male')
52.    #male
53.    #{'y': 2, 'x': 1,'age':100,'sex','male'}
54.   
55.    #dict.copy():返回具有相同key-value的新字典,為淺複製(shallow copy)
56.    new_dict = dict_test.copy()
57.   
58.    #key in dict 是否有該鍵,同 dict.has_key(key)
59.    'x' in new_dict
60.    #True
61.   
62.    # 從字典中刪除元素
63.    del dict1['sex']  # del 允許您使用 key 從一個 dictionary 中刪除獨立的元素
64.   
65.    dict1.clear()  # clear 從一個 dictionary 中清除所有元素
4. 集合
        Python的集合(set)和其他語言類似, 是一個無序不重複元素集, 基本功能包括關係測試和消除重複元素. 集合物件還支持union(聯合), intersection(交), difference(差)和sysmmetric difference(對稱差集)等數學運算.由於集合是無序的,所以,sets 不支持 索引, 分片, 或其它類序列(sequence-like)的操作。
1.    #定義一個集合
2.    set1 = {1, 2, 3, 4, 5}
3.   
4.    # 或者使用 set 函數
5.   
6.    list1 = [6, 7, 7, 8, 8, 9]
7.   
8.    set2 = set(list1)
9.   
10.    set2.add(10)  # 增加新元素
11.   
12.    print set2  # set([8, 9, 6, 7])  去掉重複內容,而且是無序的
13.   
14.    set3 = frozenset(list1)
15.   
16.    set3.add(10)  # 固定集合不能增加元素
17.   
18.    #方法(所有的集合方法):
19.    s.issubset(t)  #如果s是t的子集,返回True,否則返回False
20.    s.issuperset(t)  #如果s是t的超集,返回True,否則返回False
21.    s.union(t)   #返回一個新集合, 該集合是s和t的並集
22.    s.intersection(t)  #返回一個新集合, 該集合是s和t的交集
23.    s.difference(t)  #返回一個新集合, 該集合是s的成員, 但不是t的成員, 即返回s不同於t的元素
24.    s.symmetric_defference(t)  #返回所有s和t獨有的(非共同擁有)元素集合
25.    s.copy()  #返回一個s的淺拷貝, 效率比工廠要好
26.   
27.    #方法(僅適用於可變集合):以下方法參數必須是可哈希的
28.    s.update(t) #用t中的元素 修改s,即s現在包含s或t的成員
29.    s.intersection_update(t) #s中的成員是共同屬於s和t的元素
30.    s.difference_update(t) #s中的成員是屬於s但不包含在t中的元素
31.    s.symmetric_difference_update(t) #s中的成員更新為那些包含在s或t中,但不是s和t共有的元素
32.    s.add(obj) #在集合s中增加物件obj
33.    s.remove(obj) #從集合s中刪除物件obj,如果obj不是集合s中的元素(obj not in s),將引發keyError錯誤
34.    s.discard(obj) #如果obj是集合s中的元素,從集合s中刪除物件obj
35.    s.pop() #刪除集合s中得任意一個物件,並返回它
36.    s.clear() #刪除集合s中的所有元素
37.   
38.    ## 集合有並集,交集,求差操作
39.    ## 並集:intersection() 方法返回一個新集合,包含在兩個集合中同時出現的所有元素。
40.    ## 交集:union() 方法返回一個新集合,包含在兩個 集合中出現的元素。
41.    ## 差集:difference() 方法返回的新集合中,包含所有在 集合A出現但未在集合B中的元素。
42.    ## symmetric_difference() 方法返回一個新集合,包含所有只在其中一個集合中出現的元素。
43.   
44.    # 刪除元素
45.    set2.discard(6)   # 當元素不存在時,不會引發異常
46.    set2.remove(6)    # 與discard的區別在於,如果沒有要刪除的元素,remove會引發一個異常
47.    set2.pop()  # 因為set是無序的,所以pop會隨機的從set中刪除一個元素

沒有留言:

張貼留言