列表、元組、字典、集合

列表、元組、字典、集合

---

1. 列表

• 序列是Python中最基本的數據結構。序列中的每一個元素都分配一個數字- 它的位置，或索引，第一個索引是0，第二個索引是1，依此類推。
• Python有6個序列的內置類型，但最多見的是列表和元組。
• 序列均可以進行的操做包括索引，切片，加，乘，檢查成員。
• 此外，Python已經內置肯定序列的長度以及肯定最大和最小的元素的方法。
• 列表是最經常使用的Python數據類型，它能夠做爲一個方括號內的逗號分隔值出現。
• 列表的數據項不須要具備相同的類型
• 建立一個列表，只要把逗號分隔的不一樣的數據項使用方括號括起來便可。

列表的通常用法：

list1 = ['frui','male',1989,'python',[2016,2017],'c'] #list內元素的數據類型能夠不一樣,也能夠是另一個list
list2 = ['']
print (list1)

#使用下標索引來訪問列表中的值，一樣你也可使用方括號的形式截取字符，以下所示：
print (list1[:])
print (list1[0],list1[1])
print (list1[-1],list1[-2])
print (list1[0:3]) #切片,此操做顧頭不顧尾
print (list1[:3])
print (list1[-3:]) #切片，從後向前數索引，也只能從左往右切片，一樣是顧頭不顧尾。（這樣會沒法取到最後一個元素，思考怎麼辦？）
print (list1[0:-1:2]) #按步長切片
print (list1[::2]) #按步長切片

list1.append("linux") #在列表末尾追加元素
list1.insert(1,"linux") #直接把元素插入的指定位置
list1[0] = "jay" #（改）直接替換某個位置元素

#delete
list1.pop() #刪除list末尾的元素
list1.pop(1) #刪除指定位置的元素
del list1[0]
list1.remove("python") #此種方法和前兩種的區別是什麼？

print (list1)
print (list1.index(1989)) #查找已知元素的索引
print (list1[list1.index(1989)])

print (list1.count(1989)) #打印某元素在列表中的數量
list1.clear() #清除整個列表
list1.reverse() #反轉整個列表
list1.sort() #排序 按ASCII碼順序排序,若元素中有list類型，則沒法排序，爲何？

list2 = [1,2,3,4]
list1.extend(list2) #列表合併
print (list1)
del list2 #刪除整個變量

#列表的深淺copy
#淺拷貝只能拷貝最外層，修改內層則原列表和新列表都會變化。
#深拷貝是指將原列表徹底克隆一份新的。
import copy
list1 = ['frui','male',1989,'python',[2016,2017],'c'] 
list2 = list1.copy() #淺copy
list3 = copy.copy(list1) #淺copy，同list1.copy()效果相同
list4 = copy.deepcopy(list1) #深copy，會和list1佔用一樣大小的內存空間
list1[0] = '自由'
list1[4][0] = 2015
print (list1,'\n',list2,'\n',list3,'\n',list4)

#列表的循環：逐個打印列表元素
list1 = ['frui','male',1989,'python',[2016,2017],'c'] 
for i in list1:
    print (i)

---

2. 元組

元組也是存一組數據，只是一旦建立，便不能修改，因此又叫只讀列表。元組建立很簡單，只須要在括號中添加元素，並使用逗號隔開便可。

tup1 = (1,2,3,4,5)
tup2 = ('frui', 27)
tup3 = "a", "b", "c", "d";
tup4 = () #建立空元組

元組中只包含一個元素時，須要在元素後面添加逗號

tuple5 = (50,) #元組中只包含一個元素時，須要在元素後面添加逗號
tuple6 = (50)
#若是不加逗號，則定義的不是tuple，是50這個數！這是由於括號()既能夠表示tuple，又能夠表示數學公式中的小括號，這就產生了歧義，所以，Python規定，這種狀況下，按小括號進行計算。

元組只有兩個方法：count和index
不可變的tuple有什麼意義？由於tuple不可變，因此代碼更安全。若是可能，能用tuple代替list就儘可能用tuple。

---

3. 字典

3.1 字典的使用

字典是另外一種可變容器模型，且可存儲任意類型對象。
字典的每一個鍵值對()用冒號(:)分割，每一個對之間用逗號(,)分割，整個字典包括在花括號({})中 ,格式以下所示：

d = {key1 : value1, key2 : value2 }

鍵必須是惟一的，但值則沒必要。值能夠取任何數據類型，但鍵必須是不可變的，如字符串，數字或元組。

info = {
    'stu1':"Xiao Ming",
    'stu2':"Xiao Liang",
    'stu3':"Xiao Hong",
    'stu4':"Xiao Rui",
}
print (info)
#修改
info['stu2'] = "Xiao Hu" 
#增長
info['stu5'] = "Xiao Fang"

#刪除
info.pop('stu2')
del info['stu1']
info.popitem() #隨機刪一個
print (info)
info.clear() #清空字典全部條目

#查找
print ('stu2' in info) #判斷是否存在，存在則返回True，不然返回False
print (info['stu1']) #若是一個key不存在，就報錯，get不會，不存在只返回None

#dict.get(key, default=None)
#返回指定鍵的值，若是值不在字典中返回default值
#比較安全的查找方法
print (info.get('stu6')) 


#其餘
print (info.values()) #打印全部的值(即除了key)
print (info.keys()) #打印全部的key
print (info.items()) #把字典轉化爲列表


# dict.setdefault(key, default=None)
# 和get()相似, 但若是鍵不存在於字典中，將會添加鍵並將值設爲default
info.setdefault ('class3',{'Xiao Rui', 15})
print (info)
info.setdefault ('class1',{'Xiao Hong', 16})
print (info)

#循環打印
for i in info:
    print (i,info[i])

for k,v in info.items():
    print (k, v)

#多級字典嵌套及操做
info = {
    'class1':{
        'stu1':["Xiao Ming",16]
    },

    'class2':{
        'stu2':["Xiao Liang",17]
    }
}
info['class1']['stu1'][1] = 18
print (info)

#dict.fromkeys(seq[, val]))
# 建立一個新字典，以序列 seq 中元素作字典的鍵，val 爲字典全部鍵對應的初始值
eg:
print (dict.fromkeys([6,7,8],'test'))
c = dict.fromkeys([6,7,8],[1,{'name':'frui'}])
c[6][1]['name'] = 'sorui'
print (c)

#update方法
info = {
    'stu1':"Xiao Ming",
    'stu2':"Xiao Liang",
    'stu3':"Xiao Hong",
    'stu4':"Xiao Rui",
}
b = {
    'stu1': "Xiao Dong",
    1:3,
    2:4
}
print (info)
info.update(b)

• 爲何dict查找速度這麼快？
  由於dict的實現原理和查字典是同樣的。假設字典包含了1萬個漢字，咱們要查某一個字，一個辦法是把字典從第一頁日後翻，直到找到咱們想要的字爲止，這種方法就是在list中查找元素的方法，list越大，查找越慢。
  第二種方法是先在字典的索引表裏（好比部首表）查這個字對應的頁碼，而後直接翻到該頁，找到這個字。不管找哪一個字，這種查找速度都很是快，不會隨着字典大小的增長而變慢。dict就是第二種實現方式。

• 和list比較，dict有如下幾個特色：
  無序
  查找和插入的速度極快，不會隨着key的增長而變慢；
  須要佔用大量的內存，內存浪費多。
  而list相反：
  查找和插入的時間隨着元素的增長而增長；
  佔用空間小，浪費內存不多。
  因此，dict是用空間來換取時間的一種方法。

• dict能夠用在須要高速查找的不少地方，在Python代碼中幾乎無處不在，正確使用dict很是重要，須要牢記的第一條就是dict的key必須是不可變對象。這是由於dict根據key來計算value的存儲位置，若是每次計算相同的key得出的結果不一樣，那dict內部就徹底混亂了。這個經過key計算位置的算法稱爲哈希算法（Hash）。
• 要保證hash的正確性，做爲key的對象就不能變。在Python中，字符串、整數等都是不可變的，所以，能夠放心地做爲key。而list是可變的，就不能做爲key：

---

3. 集合

集合是一個無序的，不重複的數據組合，它的主要做用以下：

• 去重，把一個列表變成集合，就自動去重了
• 關係測試，測試兩組數據以前的交集、差集、並集等關係

經常使用操做

#去重
list1 = [3,2,1,4,5,6,5,4,3,2,1]
print (list1, type(list1))
list1 = set(list1)
print (list1, type(list1))

list2 = set([4,5,6,7,8,9])

#交集
print (list1.intersection(list2))

#並集
print (list1.union(list2))

#差集
print (list1.difference(list2))
print (list2.difference(list1))

#子集、父集
print (list1.issubset(list2))
print (list1.issuperset(list2))

list3 = set([4,5,6])
print (list3.issubset(list2))
print (list2.issuperset(list3))

#對稱差集
print (list1.symmetric_difference(list2))

#Return True if two sets have a null intersection
list4 = set([1,2,3])
print (list3.isdisjoint(list4))

#交集
print (list1 & list2)
#union
print (list2 | list1)
#difference
print (list1 - list2)
#對稱差集
print (list1 ^ list2)

#添加
list1.add(999) #添加一項
print (list1)
list1.update([66,77,88]) #添加多項
print (list1)
print (list1.add(999)) #猜猜打印什麼？爲何

#刪除
list1.remove(999)
print (list1)

#remove and return arbitrary set element
print (list1.pop()) 

#Remove an element from a set if it is a member.If the element is not a member, do nothing.
print (list1.discard(888))