元組住诸，創(chuàng)建方式一組以逗號隔開的值

a = 3,4,5
print a
#所以明顯print加上逗號隔開的值并不是元組驾胆，而只是打印分隔符
print 3,4,5```
#創(chuàng)建元組的元組

nested_tup = (1,2,3),(4,6)
print nested_tup

調(diào)用tuple()函數(shù)將所有序列或者迭代器轉(zhuǎn)換成元組

print tuple([3,4,2])
print tuple('strings')```

索引元組

print nested_tup[1][1]
#元組是不可變的，但是如果在元組插槽中的元素是可變的贱呐，也可以修改其中的可變對象丧诺，比如這樣
tup = tuple(['foo',[1,2],True])
print tup
#第2個元素是個列表可變，所以可以修改列表中的元素奄薇，比如這樣
tup[1].append(3)
print tup```
#元組通過加號進行產(chǎn)生更長的元組

對于只有一個元素的元組驳阎，必須在該元素后面加上逗號，明確表示是元組，否則就可能按其本身的數(shù)據(jù)類型進行處理了

print (3,None,'foo')+(6,0)+('bar',)

對元組乘以以個整數(shù)呵晚，相當于連接該元組的多個副本

print (3,None,'foo')*3```

元組拆包

tup = (4,5,6)
a,b,c=tup
print a,b,c
#嵌套元組也能解包
tup = (4,5,(6,7))
a,b,(c,d)=tup
print a,b,c,d
#利用解包實現(xiàn)數(shù)據(jù)交換
a = 5;b = 4;print a,b
a,b = b,a;print a,b
#利用解包進行迭代,對由元組或者列表組成的序列進行迭代
seq = ((1,2,3),(4,5,6),(7,8,9))
for a,b,c in seq:
    print a,b,c
#元組方法蜘腌，count(),計算參數(shù)的出現(xiàn)次數(shù),只能統(tǒng)計第一層元素出現(xiàn)多少次，不能具體到底層
print seq.count(1)```

#列表饵隙，序列包括撮珠，列表，元組金矛，還有字符串芯急，只有列表是可變的

list()函數(shù)將序列類型轉(zhuǎn)換成列表

a_list = [2,3,4,None]
print a_list,list(tup),list("strings")

append()方法

a_list.append("love")

insert()方法把元素插入到指定位置

a_list.insert(4,"i")

pop()方法移除并且返回指定索引處的元素

a_list.pop(3)

remove()方法找到第一個符合要求的值并從列表刪除

a_list.remove(4)

in操作符判斷列表中是否含有某個值

print 4 in a_list
print a_list```

列表的合并+和extend()方法

b_list = [7,8,(2,3)]
x = [4,None,'foo']
#a.extend()調(diào)用后返回值是一個None，所以必須調(diào)用a才能顯示extend()方法執(zhí)行后的效果
a_list.extend([4,None,'foo'])
print a_list + b_list,a_list
#+代表的列表合并是新建一個新列表然后賦值的操作驶俊，而extend()方法是原地進行操作的娶耍，效率會好一點
#排序，sort()方法
a = [1,4,3,5,(8,6)]
#利用reverse參數(shù)饼酿，指明反向排序
a.sort(reverse=True)
#sort()方法是原地排序操作伺绽，直接改變原始的序列
print a
b = ["love","i",'you']
b.sort(key=len)
print b```

#序列的切片操作

確定傳入[]的start和stop

seq = [7,2,4,5,32,6,4,7]

沒有傳入start或者stop的就默認從序列起始或者結(jié)束算起

print seq[1:3],seq[:5],seq[3:]
print seq[-4:],seq[-6:-2]

如果左側(cè)元素出現(xiàn)比右邊元素晚的話，返回空序列

print seq[-4:-5]

加上步長,實現(xiàn)反序

print seq[::-1],seq[3::-1]```

內(nèi)置序列函數(shù)

#enumerate()函數(shù)返回序列的索引和對應索引的值
some = ["a","b","c"]
for i,value in enumerate(some):
    print "It's ",str(i),"and the value is ",value
#enumerate()還可以求取一個將序列值映射到其所在位置的字典(假定序列值是唯一的嗜湃，這樣字典的鍵才能是唯一的)
some_list = ["foo","bar","baz"]
#一個推導式
mapping = dict((v,i) for i,v in enumerate(some_list))
print mapping```

#sorted()函數(shù)

將任何序列返回一個新的有序列表奈应，但是原列表不發(fā)生變化，但是列表的sort()方法會原地對列表進行排序

sort_some_list = sorted(some_list)
print sort_some_list,some_list,sorted("horse race")

使用sorted()函數(shù)與set結(jié)合起來得到一個由序列中唯一元素組成的有序列表

print sorted(set("this is just some string"))```

zip()函數(shù)將多個序列的元素進行配對购披，產(chǎn)生一個新序列

seq1 = ['foo','bar','baz']
seq2 = ['one','two','three']
print zip(seq1,seq2)
#zip()可以接受任意數(shù)量的序列杖挣，最終得到的元組數(shù)量由最短的序列決定
#常見用法是同時迭代多個序列，結(jié)合enumerate()函數(shù)使用,典型的序列解包的應用
for i,(a,b) in enumerate(zip(seq1,seq2)):
    print ('%d: %s %s' %(i,a,b))
#對已經(jīng)壓縮的序列刚陡，zip()對該序列進行解壓惩妇，其實是將一組行轉(zhuǎn)換為一組列
pitcher = zip(seq1,seq2)
#*說明參數(shù)要傳入一個元組，元組包含兩個元素筐乳，因此就是把pitcher[1]作為參數(shù)傳入zip了歌殃，然后zip的作用是結(jié)合產(chǎn)生新序列，與first和last相對應
first,last = zip(*pitcher)
print first,last```

#reversed()函數(shù)用于得到一個序列的逆序蝙云，返回一個迭代器

使用list()函數(shù)將迭代器類型轉(zhuǎn)換為列表

xiter = reversed(range(10))
for i in xiter:
print "it's ",str(i)
print type(xiter)

為什么迭代之后就變成空列表了,迭代迭代器的作用就是延遲生成值氓皱，

使用for已經(jīng)把迭代器迭代完了，所以肯定之后再使用這個迭代器,list()的話勃刨，就是空的

print list(xiter)```

字典

#創(chuàng)建字典
d1 = {'a':'some value','b':[1,2,3,4]}
#使用鍵來索引字典對應的值
d1[7] = 'use integer as key'
print d1,d1['a'],d1['b'],d1[7]
#判斷字典中是否存在某個鍵
print 'b' in d1,d1.has_key('b')
#使用del關鍵字或者pop方法(刪除指定值后把值返回)
d1['dummy'] = "it's fun"
del(d1['dummy'])
d1['pop'] = 'testing pop'
ret = d1.pop('pop')
print d1,ret
#keys()和values()方法分別按對應順序返回鍵和值
print d1.keys()," and ",d1.values()
#使用update()方法將一個字典合并到另外一個字典上,原來如果有相同的鍵將其覆蓋波材，若沒有建立新的鍵值對
d1.update({'b':'it is b','c':"it is c"})
print d1```

#從序列類型創(chuàng)建字典

mapping = {}
for key,value in zip(range(10),reversed(range(10))):
mapping[key] = value
print mapping

使用更加簡單的方法創(chuàng)建字典，dict()函數(shù),接受一個二元的列表或者元組作為鍵值對

mapping = dict(zip(range(5),reversed(range(5))))
print mapping```

字典的get()方法和pop()方法

#如果可以得到key為a的值身隐，則返回該值廷区，否則返回None這個自定義默認值
value = mapping.get("a",None)
popvalue = mapping.pop("a",None)
print value,popvalue
#根據(jù)首字母對一組單詞進行分類并且最終產(chǎn)生一個由列表組成的字典
words = ['apple','bat','bar','atom','book']
by_letter = {}
for word in words:
    letter = word[0]
    #如果by_letter中含有Letter這個鍵
    if letter in by_letter:
        by_letter[letter].append(word)
    else:
        #每個鍵對應的是一個列表
        by_letter[letter] = [word]
print by_letter```

#上述程序代碼可以使用setdefault()方法實現(xiàn)

by_letters = {}

#這樣不可以，必須得給第一次出現(xiàn)的鍵對應一個默認列表贾铝，要不無法append()

for word in words:

by_letters[word[0]].append(word)

print by_letters

所以就可以這樣干,創(chuàng)建新鍵的時候賦予一個默認列表隙轻，同時將word埠帕，append()進去，

然后如果是已經(jīng)存在的鍵玖绿，就返回對應的值敛瓷，也是個列表，將最新的word用append()

for word in words:
by_letters.setdefault(word[0],[]).append(word)
print words

字典的鍵必須是不可變對象镰矿，利用是否可哈希來檢測是否可以當成字典的鍵

hash("string")#可哈希琐驴，成功

hash([1,2,3])#不可哈希，失敗

如果要把列表當成鍵秤标，那么可以將其轉(zhuǎn)化為元組

by_letters[tuple([1,3,2])] = "list transferred to tuple"
print by_letters```

集合绝淡，是由唯一元素組成的無序集

#創(chuàng)建方法
a = set("strings is a sequence")
# or a = set([1,2,3,4])
b = {1,2,3,4,5}
print a,b
#判斷是否子集或者超集
print {1,3,4}.issubset(b), "and ",b.issuperset({1,3,4})
#如果兩個集合的內(nèi)容相等，那么集合就是相等的
print {1,3,4} == {1,4,3}```

#列表推導式

一個經(jīng)典的例子

strings = ['a','as','bat','car','dove','python']
print [string.upper() for string in strings if len(string) > 2]

集合推導式苍姜，建立上述字符串的字符串長度的集合

print {len(string) for string in strings}

字典推導式牢酵，為字符串建立一個指向其列表索引位置的映射關系

print {val:index for index,val in enumerate(strings)}

另外一個實現(xiàn)版本,dict()函數(shù)接受參數(shù)為一個(key,value)的鍵值對，無論是元組還是列表還是字典

print dict((val,idx) for idx,val in enumerate(strings))```

嵌套的列表推導式

all_data = [['Tom','Billy','Jefferson','Andrew','Wesley','Steven','Joe'],
            ['Susie','Casey','Jill','Ana','Eva','Jennifer','Stephanie']]
#將名字中含有兩個e的名字找出來
#初始化存儲找到名字的列表
name_interested = []
for names in all_data:
    #因為是嵌套列表衙猪，所以嵌套循環(huán)馍乙，分別處理兩個列表
    for name in names:
        if name.count('e') >= 2:
            name_interested.append(name)
print name_interested
#使用一個列表推導式
name_interested = []
for names in all_data:
    need_name = [name for name in names if name.count('e') >= 2]
    # name_interested.append(need_name)
    #使用extend而不是append是因為extend擴展列表去掉嵌套列表，從而使生成的列表扁平化
    name_interested.extend(need_name)
print name_interested
#使用嵌套的列表推導式
#太精簡了垫释！
result = [name for names in all_data for name in names if name.count('e') >= 2]
print result
#扁平化一個嵌套的元組列表
some_tuples = [(1,2,3),(4,5,6),(7,8,9)]
flattened = [x for tuple in some_tuples for x in tuple]
print flattened

flattened = []
for tup in some_tuples:
    result = [x for x in tup]
    flattened.extend(result)
print flattened
#下面這種寫法只能是把嵌套的元組變成了嵌套的列表
print [[x for x in tup] for tup in some_tuples]```