python中遍历结构可以是哪些数据类型_全！Python基础之原生数据类型、判断和循环、函数和文件操作合集...
長文預(yù)警！
Python基礎(chǔ)系列會將基礎(chǔ)內(nèi)容大致分為三到五個板塊，每塊著重講一方面，知識不會很難，主要是以小例子的形式解讀，如果你已經(jīng)入門Python，希望可以幫你溫習(xí)一下；如果你想入門Python，希望可以幫你越過這個門檻。
Python原生數(shù)據(jù)類型主要有Number、String、Byte、Boolean、None、List、Tuple、Set、Dict這九種，下面先講一下字符串、列表、元祖、集合、字典這五種，剩下的四種大家可以自己了解一下。
字符串
初始化一個字符串，方便后面在字符串上做一些操作。
In [5]: s1 = 'naitangmao'
In [6]: s1
Out[6]: 'naitangmao'
字符串的索引，需要注意的是索引下標(biāo)從0開始。
In [9]: s1[2]
Out[9]: 'i'
字符串的切片，以冒號分隔首尾索引位置，是[start:end]結(jié)構(gòu)，注意不包含end對應(yīng)元素；冒號左邊不寫入索引表示從頭開始，同理右邊不寫入索引表示截取到字符串末尾。
In [8]: s1[:3]#從0開始，0,1,2三個索引
Out[8]: 'nai'
還可以利用切片結(jié)合負(fù)索引實(shí)現(xiàn)翻轉(zhuǎn)字符串。
In [35]: s1[::-1]
Out[35]: 'oamgnatian'
利用加法實(shí)現(xiàn)合并字符串。
In [49]: print('ab'+'%'+'cd')
ab%cd
查找，利用find方法查詢元素時，會返回在字符串第一次出現(xiàn)的下標(biāo)，未找到會返回-1。
In [11]: s1.find('a')
Out[11]: 1
替換，replace可以實(shí)現(xiàn)字符串中元素的替換，比如將'tang'替換成空格。
In [13]: s1.replace('tang',' ')
Out[13]: 'nai mao'
去空格，使用strip方法可以刪除一個字符串首尾的空格，然后也支持指定要刪除內(nèi)容。
In [23]: s2 = ' aaabbbccc '
In [24]: s2
Out[24]: ' aaabbbccc '
In [25]: s2.strip()
Out[25]: 'aaabbbccc'
In [26]: s2 = s2.strip()
In [27]: s2.strip('a')#可以指定刪除首尾的元素
Out[27]: 'bbbccc'
切割，split方法可以根據(jù)元素切割字符串，并存入列表；如果不輸入?yún)?shù)，會直接將原字符串存入列表。
In [30]: s1 = 'naitangmao'
In [31]: s1.split('t')
Out[31]: ['nai', 'angmao']
In [32]: s1.split()
Out[32]: ['naitangmao']
判斷一個元素是否存在于字符串中。
In [37]: 'nai' in s1
Out[37]: True
分隔，利用join方法可以將一個字符串作為分隔符，分隔另一個字符串。
In [38]: s1.join('!!!')
Out[38]: '!naitangmao!naitangmao!'
利用%向字符串中傳入?yún)?shù)，%s傳入字符串、%d傳入整數(shù)、%f傳入浮點(diǎn)數(shù)，且可以控制小數(shù)點(diǎn)后的位數(shù)。
In [40]: print('naitangmao是%s！' % '靚仔')
naitangmao是靚仔！
In [41]: print('naitangmao %d '% 66)
naitangmao 66
In [44]: print('naitangmao %.2f'% 3.1415)
naitangmao 3.14
也可以利用format向字符串中傳入?yún)?shù)，且不需要在意參數(shù)類型。
In [46]: '{0}ai{1}ang{2}ao'.format('n','66','3.14')
Out[46]: 'nai66ang3.14ao'
利用反斜杠對字符串進(jìn)行轉(zhuǎn)義。
In [47]: print('\t')
In [48]: print('\\t')
\t
列表
同樣初始化一個列表，然后方便對列表做一系列操作。
In [52]: list1
Out[52]: [1, 3, 5, 7, 9, 11]
首先同樣是列表的索引，列表也支持負(fù)索引。
In [53]: list1[2]
Out[53]: 5
In [55]: list1[-2]#負(fù)索引
Out[55]: 9
再拓展一下帶有間隔的切片，字符串同樣適用，就是在end之后再加上一個雙引號，用來寫入切片的間隔，這才是切片最完整的結(jié)構(gòu)。
In [58]: list1[0:6:2]
Out[58]: [1, 5, 9]
利用index方法可以獲取某個元素在列表中的位置索引，未找到的則會報(bào)錯。
In [60]: list1.index(3)
Out[60]: 1
利用join方法將列表中的各個元素合并為字符串。
In [121]: list1 = ['a','b','c']
In [122]: ''.join(list1)
Out[122]: 'abc'
count方法可以統(tǒng)計(jì)一個元素在列表中出現(xiàn)的次數(shù)。
In [63]: list1.count(5)
Out[63]: 1
enumerate可以直接獲取列表的索引和對應(yīng)元素。
In [133]: index_ = []
In [134]: value_ = []
In [135]: for i,v in enumerate(list1):
...: index_.append(i)
...: value_.append(v)
In [136]: index_
Out[136]: [0, 1, 2, 3, 4]
In [137]: value_
Out[137]: [3, 1, 4, 2, 5]
利用zip方法合并兩個列表。
In [139]: list3 = list(zip(index_,value_))
In [140]: list3
Out[140]: [(0, 3), (1, 1), (2, 4), (3, 2), (4, 5)]]
擴(kuò)大列表的四種方法：
1、append：將一個元素添至列表尾部2、insert：將一個元素插入至指定位置3、extend：將一個列表的所有元素都添加至另一個列表中4、+：將兩個列表合并成一個新列表
In [68]: list1.append(12)
In [69]: list1
[1, 3, 5, 7, 9, 11, 12]
In [78]: list1.insert(0,0)
In [79]: list1
Out[79]: [0, 1, 3, 5, 7, 9, 11, 12]
In [80]: list1.extend([2,4])
In [81]: list1
Out[81]: [0, 1, 3, 5, 7, 9, 11, 12, 2, 4]
In [82]: list2 = [6,8]
In [83]: list3 = list1+list2
In [84]: list3
Out[84]: [0, 1, 3, 5, 7, 9, 11, 12, 2, 4, 6, 8]
刪除列表元素的三種方法：
1、pop:從列表指定位置刪除元素，并將其返回。如果沒有指定索引，pop()返回最后一個元素，并從列表中刪去。2、remove：從列表中刪去指定元素，沒有則會報(bào)錯。3、del：也是利用索引刪去列表中的某部分。
In [91]: list1.pop(3)
Out[91]: 7
In [92]: list1
Out[92]: [1, 3, 5, 9, 11]
In [94]: list1.remove(5)
In [95]: list1
Out[95]: [1, 3, 9, 11]
In [96]: del list1[1:3]
In [97]: list1
Out[97]: [1, 11]
翻轉(zhuǎn)列表的三種方式：
1、reverse:就地倒排列表中的元素。2、reversed:函數(shù)對列表進(jìn)行反轉(zhuǎn)，并返回一個新的迭代器，需要用list轉(zhuǎn)換3、切片結(jié)合負(fù)索引
In [99]: list1 = [1,3,5,7,9,11]
In [100]: print(list1.reverse())
[11, 9, 7, 5, 3, 1]
In [102]: list2 = list(reversed(list1))
In [103]: print(list2)
[11, 9, 7, 5, 3, 1]
In [105]: list1[::-1]
Out[105]: [11, 9, 7, 5, 3, 1]
實(shí)現(xiàn)列表排序的兩種方式：
1、sort:對列表中的元素就地進(jìn)行排序。2、sorted:函數(shù)對列表進(jìn)行排序，形成一個新列表3、利用lambda自定義函數(shù)這兩種方法默認(rèn)為升序，通過參數(shù)reverse可以更改排序方式。
In [106]: list2 = [3,5,2,7,1]
In [108]: list2.sort()
In [109]: list2
Out[109]: [1, 2, 3, 5, 7]
In [116]: list3 = sorted(list2,reverse = True)
In [117]: list3
Out[117]: [7, 5, 3, 2, 1]
#按照元祖中第二個元素的大小排序
In [141]: list4 = [(0, 3), (1, 1), (2, 4), (3, 2), (4, 5)]
In [142]: print(sorted(list4,key = lambda x: x[1]))
[(1, 1), (3, 2), (0, 3), (2, 4), (4, 5)]
sort和reverse這類就地處理列表的操作，針對可變的列表是可以的，但如果是不可變的元祖，只能用sorted和reversed這兩種方式。
拷貝列表的三種方式：
1、利用切片直接賦值，淺拷貝2、copy方法，淺拷貝3、deepcopy方法，深拷貝
In [25]: list2 = list1[:]
In [26]: list3 = list1.copy()
In [27]: import copy
In [29]: list4 = copy.deepcopy(list1)
深拷貝和淺拷貝的區(qū)別因?yàn)樯婕暗綌?shù)據(jù)結(jié)構(gòu)，口頭敘述不容易理解，網(wǎng)上有很多圖例講解的博客，大家可以了解一下。
元組
元組和列表是非常相似的，有一種類似近親的關(guān)系，也就是說列表中很多操作同樣適用于元組，比如索引、切片等等，但也有一部分不同，這里主要來說一下元組的特別之處。
首先元組又被稱作帶鎖的列表，就是元組內(nèi)的元素是不能隨意更改的，比如你不能給元組中的一個元素隨意賦值。
In [2]: tuple1 = (1,2,3)
In [3]: tuple1[2] = 4
#會發(fā)生報(bào)錯，告訴你不支持這樣的操作
TypeError: 'tuple' object does not support item assignment
元組的標(biāo)志并不是單純的小括號，而是逗號，或者小括號與逗號的結(jié)合，看下面這個例子。
In [31]: tuple2 = (1)
In [32]: type(tuple2)
Out[32]: int
In [33]: tuple3 = (1,)
In [34]: type(tuple3)
Out[34]: tuple
In [35]: tuple4 = 1,2,
In [36]: type(tuple4)
Out[36]: tuple
那如何初始化一個空元組呢？
In [39]: tuple5 = ()
In [40]: type(tuple5)
Out[40]: tuple
上面剛剛說過元組是不可變對象，自然也不會有append、insert、pop這類的操作。元組中增添可以利用"+"實(shí)現(xiàn)，刪除則可以利用del，因?yàn)檫@是python自帶的回收機(jī)制。
In [42]: tuple5 = tuple5[:] + (1,2,3,4,)
In [43]: tuple5
Out[47]: (1, 2, 3, 4)
In [50]: del tuple5 #不支持切片
In [51]: tuple5
NameError: name 'tuple5' is not defined
"*"在數(shù)值型之間為乘積運(yùn)算符，而在列表和元組之間可以表示為重復(fù)運(yùn)算符。
In [53]: tuple5 = (1,2)
In [54]: tuple5 * 3
Out[54]: (1, 2, 1, 2, 1, 2)
集合
集合是一個無序不重復(fù)元素的集?；竟δ馨P(guān)系測試和消除重復(fù)元素。集合對象還支持聯(lián)合、交、差和對稱差集等數(shù)學(xué)運(yùn)算。
首先可以利用大括號或set()函數(shù)創(chuàng)建集合，如果想要創(chuàng)建空集合，你必須使用set()而不是{}，{}用來創(chuàng)建字典。
In [57]: set1 = set()
In [58]: type(set1)
Out[58]: set
集合會本身會帶有去重功能。
In [55]: set1 = {1,1,2,2,3,3,4}
In [56]: set1
Out[56]: {1, 2, 3, 4}
將集合轉(zhuǎn)化為列表時，會自動排序。
In [74]: set2 = {5,5,4,2,2,0}
In [75]: list_ = list(set2)
In [76]: list_
Out[76]: [0, 2, 4, 5]
集合之間的一些運(yùn)算操作。
In [60]: set1 = {1,2,3,4}
In [61]: set2 = {3,4,5}
#差
In [62]: set1 - set2
Out[62]: {1, 2}
#并
In [63]: set1 | set2
Out[63]: {1, 2, 3, 4, 5}
#交
In [64]: set1 & set2
Out[64]: {3, 4}
#只在set1或只在set2中
In [65]: set1 ^ set2
Out[65]: {1, 2, 5}
利用add向集合中增添元素,利用remove刪除元素。
In [69]: set1 = {1,2,3}
In [70]: set1.add(5)
In [71]: set1
Out[71]: {1, 2, 3, 5}
In [72]: set1.remove(2)
In [73]: set1
Out[73]: {1, 3, 5}
字典
字典是Python中一個非常有用的原生數(shù)據(jù)類型，一般序列是用連續(xù)的整數(shù)作為索引，而字典是以關(guān)鍵字作為索引，且關(guān)鍵字要是任意不可變類型。理解字典時可以把它看做無序的鍵：值對(key:value對)集合，同一個字典中鍵必須互不相同，利用{}可以初始化一個空的字典。
In [77]: dict1 = {}
In [78]: type(dict1)
Out[78]: dict
如果確保一個鍵不在字典中，可以利用下面的方法向字典中添加元素。
In [81]: dict1 = {'a':1,'b':2}
In [82]: dict1['c'] = 3
In [83]: dict1
Out[83]: {'a': 1, 'b': 2, 'c': 3}
而如果這個鍵已經(jīng)存在于字典中了，就表示為這個鍵賦值。
In [84]: dict1['b']=4
In [85]: dict1
Out[85]: {'a': 1, 'b': 4, 'c': 3}
keys()方法能夠一次性獲得字典中所有的鍵，values()方法則用來獲取值，items()則是獲取鍵值對的元組形式。
In [86]: list(dict1.keys())
Out[86]: ['a', 'b', 'c']
In [87]: list(dict1.values())
Out[87]: [1, 4, 3]
In [88]: list(dict1.items())
Out[88]: [('a', 1), ('b', 4), ('c', 3)]
元組形式或者列表中嵌套的元組的形式都可以轉(zhuǎn)換成字典，因?yàn)橐３植豢勺冃浴?/p>
In [89]: dict2 = dict([('e',5),('f',6)])
In [90]: dict2
Out[90]: {'e': 5, 'f': 6}
In [91]: dict3 = dict((('g',7),('h',8)))
In [92]: dict3
Out[92]: {'g': 7, 'h': 8}
當(dāng)然也可以通過'='賦值的形式創(chuàng)建一個字典。
In [93]: dict5 = dict(i = 8,j = 9)
In [94]: dict5
Out[94]: {'i': 8, 'j': 9}
查詢一個鍵是否存在一個列表中。
In [96]: 'i' in dict5
Out[96]: True
In [97]: 'a' in dict5
Out[97]: False
根據(jù)鍵查詢對應(yīng)值的兩種方式：
1、直接利用鍵的名字索引，不足的是如果字典中沒有這個鍵則會發(fā)生報(bào)錯。2、利用get方法，可以設(shè)置不存在鍵名的情況下的返回值，默認(rèn)返回None。
In [98]: dict5['i']
Out[98]: 8
In [99]: dict5['a']
KeyError: 'a'
In [101]: dict5.get('i')
Out[101]: 8
In [103]: dict5.get('a',"沒有")
Out[103]: '沒有'
字典中的幾種刪除方式：
1、pop()方法，與列表不同的是必須要傳入一個字典中已有鍵的參數(shù)。2、popitem()，類似于列表中的pop()，隨機(jī)刪除一組鍵值對而非刪除最后一個，因?yàn)樽值浔旧頍o序。3、del方法，用于刪除整個字典
In [107]: dict3
Out[107]: {'g': 7, 'h': 8}
In [109]: dict3.pop('g')
Out[109]: 7
In [110]: dict3.popitem()
Out[110]: ('h', 8)
clear()方法可以清楚字典中所有的鍵值對。
In [104]: dict5.clear()
In [105]: dict5
Out[105]: {}
setdefault()方法可以傳入一組鍵值對，如果字典中已有同名鍵，則返回鍵在字典中對應(yīng)的值，否則將傳入的鍵值對存入字典中。
In [115]: dict2
Out[115]: {'e': 5, 'f': 6}
In [117]: dict2.setdefault('e',1)
Out[117]: 5
In [118]: dict2.setdefault('g',7)
Out[118]: 7
In [119]: dict2
Out[119]: {'e': 5, 'f': 6, 'g': 7}
update()方法可以用來更新字典：
如果字典中已有傳入的鍵，則更新鍵對應(yīng)的值。如果沒有，則將傳入的鍵值對存入字典中。
In [121]: dict2.update({'g':10})
In [122]: dict2
Out[122]: {'e': 5, 'f': 6, 'g': 10}
In [123]: dict2.update(dict1)
In [124]: dict2
Out[124]: {'e': 5, 'f': 6, 'g': 10, 'a': 1, 'b': 4, 'c': 3}
總結(jié)
上面就是五種數(shù)據(jù)類型基本操作的一個概括，其中比較常用的三種就是字符串、列表和字典，應(yīng)該重點(diǎn)掌握。
接下來是幾個語法表達(dá)式：
流程控制是python語法很重要的一個分支，主要包括我們經(jīng)常用到的判斷語句、循環(huán)語句以及各種表達(dá)式。
判斷語句(if)
判斷語句中最有名的應(yīng)該就是if-else的組合，并且很多語言都通用這種格式，但是對于elif而言，不同語言表達(dá)形式可能會不同：
In [1]: x = 5
In [2]: if x>0:
...: print('正整數(shù)')
...: elif x<0:
...: print('負(fù)整數(shù)')
...: else:
...: print('零')
...:
正整數(shù)
一組判斷語句可能會有零到多個 elif 部分，else 是可選的。關(guān)鍵字 elif 是 else if 的縮寫，由于python對縮進(jìn)的要求很嚴(yán)格，而這種寫法恰巧可以有效地避免過深的縮進(jìn)。if ... elif ... elif ... 序列用于替代其它語言中的 switch 或 case 語句。
循環(huán)語句
1、for循環(huán)
如果C語言是你最熟悉的需要，要注意python和C語言中的for語句表達(dá)形式完全不同。Python 的 for 語句依據(jù)任意序列(字符串、列表)中的子項(xiàng)，按照它們在序列中的順序來進(jìn)行迭代。
In [3]: str1 = 'mao'
In [4]: for i in str1:
...: print(i)
...:
m
a
o
對列表的循環(huán)與字符串幾乎一致，只是子項(xiàng)不同。
In [5]: list1 = ['a','aa','aaa']
In [6]: for i in list1:
...: print(i,len(i))
...:
a 1
aa 2
aaa 3
for語句與range函數(shù)結(jié)合是一種很常見的組合，range函數(shù)主要提供一個數(shù)值序列。
In [8]: for j in range(len(list1)):
...: print(j,list1[j])
...:
0 a
1 aa
2 aaa
range提供的數(shù)值索引方式可以參考列表的切片，同樣默認(rèn)以0開始，且不包括最后一位，上面這種場合利用enumerate()函數(shù)表達(dá)會更加簡單。
In [9]: for i,v in enumerate(list1):
...: print(i,v)
...:
0 a
1 aa
2 aaa
2、while語句
In [10]: i = 1
In [11]: list2 = []
In [12]: while i<=5:
...: list2.append(i)
...: i+=1
In [14]: list2
Out[14]: [1, 2, 3, 4, 5]
3、break、continue、pass
break語句的作用就是用來跳出一個for或while循環(huán)。
In [15]: for i in range(0,5):
...: if i == 3:
...: break
...: else:
...: print(i)
1
2
可以看到在for循環(huán)中加了一個判斷語句，當(dāng)i等于3時會跳出for循環(huán)，不再繼續(xù)執(zhí)行，輸出與語義符合。
continue語句的作用就是表示繼續(xù)執(zhí)行下一次迭代，可以結(jié)合判斷語句使用，在什么條件下繼續(xù)執(zhí)行，或者什么條件下跳出循環(huán)。
In [20]: for i in range(2,7):
...: if i%2==0:
...: print('An even number',i)
...: continue
...: if i>4:
...: print('beyond 4')
...: break
...:
An even number 2
An even number 4
beyond 4
pass語句主要起到一個占位的作用，而有的語句后面是不能為空的，比如if、for、while，可以利用pass占位，不會發(fā)生報(bào)錯。
In [1]: while True:
...: pass
迭代器、生成器
我們通常接觸到的迭代器有序列，比如字符串、列表等等，利用iter()方法可以構(gòu)建一個迭代器，與之匹配的next()方法可以迭代返回迭代器內(nèi)的值，并將返回值彈出迭代器。
In [1]: it = iter('python')
In [2]: print(it)
In [3]: next(it)
Out[3]: 'p'
In [4]: next(it)
Out[4]: 'y'
當(dāng)next方法迭代到最后一個值時，繼續(xù)調(diào)用next方法會彈出報(bào)錯。當(dāng)然也可以利用for循環(huán)迭代輸出：
In [6]: for i in it:
...: print(i)
t
h
o
n
如果你深入了解Python之后會發(fā)現(xiàn)生成器用起來會更加方便，結(jié)合函數(shù)即可。生成器的關(guān)鍵字為yield，生成器也具有next()方法，并且可以利用for循環(huán)迭代輸出。
In [8]: def reverse(data):
...: for i in range(len(data)-1,-1,-1):
...: yield data[i]
In [9]: gen = reverse('mao')
In [10]: print(gen)
In [11]: next(gen)
Out[11]: 'o'
In [12]: for i in gen:
...: print(i)
a
m
用小括號括起來的一個表達(dá)式可以用來創(chuàng)建一個生成器，下面將講述如何來書寫各種的表達(dá)式。
In [14]: gen2 = (i for i in range(0,5))
In [15]: print(gen2)
at 0x00000187ADA18D60>
表達(dá)式
列表表達(dá)式
各種表達(dá)式為我們創(chuàng)建相關(guān)數(shù)據(jù)類型提供了一種更加簡單的方法，首先是列表表達(dá)式，普通的方法是通過將一些操作應(yīng)用于序列的每個成員并通過返回的元素創(chuàng)建列表，或者通過滿足特定條件的元素創(chuàng)建子序列。比如我們想獲取10以內(nèi)的平方數(shù)，利用普通方法如下：
In [16]: squares = []
In [17]: for i in range(10):
...: squares.append(i ** 2)
In [18]: squares
Out[18]: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
但一行語句就足以囊括上面的內(nèi)容，可見列表表達(dá)式的簡潔性。
In [20]: squares = [x**2 for x in range(10)]
In [21]: squares
Out[21]: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
上面這個列表表達(dá)式應(yīng)該是比較簡單的，我們還可以在表達(dá)式中加入判斷語句作為篩選條件。
In [22]: list2 = [x*2 for x in range(10) if x*2>3]
In [23]: list2#0和2被過濾掉了
Out[23]: [4, 6, 8, 10, 12, 14, 16, 18]
進(jìn)一步可以結(jié)合兩個列表的元素組成一個列表表達(dá)式:
In [24]: list3 = [(x,y) for x in [1,2] for y in [2,3]if x!=y]
In [25]: list3
Out[25]: [(1, 2), (1, 3), (2, 3)]
在復(fù)雜一點(diǎn)的列表表達(dá)式就是嵌套類型的，但是這樣的表達(dá)式缺點(diǎn)就是可讀性不太好，因?yàn)槟阈枰ニ伎妓囊恍┘?xì)節(jié)，比如將一個23的矩陣轉(zhuǎn)變?yōu)?2的矩陣。
In [28]: mat = [[1,2,3],[4,5,6]]
In [29]: list3 = [[row[i] for row in mat] for i in range(3)]
In [31]: list3
Out[31]: [[1, 4], [2, 5], [3, 6]]
集合表達(dá)式
集合表達(dá)式與列表表達(dá)式有兩處不同：
1、集合表達(dá)式需要用{}2、集合表達(dá)式返回的是集合，所以會對元素去重
In [32]: set1 = {i for i in 'abcdddddd' if i not in 'abc'}
In [33]: set1
Out[33]: {'d'}
可以看到for語句中的字符串原本有很多d，經(jīng)過條件過濾和集合去重最后只剩下了一個。
當(dāng)然也可以通過set()方法將一個列表表達(dá)式轉(zhuǎn)換為集合的形式。
In [34]: set2 = set([(x,y) for x in range(2) for y in range(2)])
In [35]: set2
Out[35]: {(0, 0), (0, 1), (1, 0), (1, 1)}
字典表達(dá)式
字典是python中很常用的一種數(shù)據(jù)類型，所以字典表達(dá)式也顯得尤為重要。字典表達(dá)式同樣也用{}構(gòu)建，只不過表達(dá)式還要用(key:value對)的形式。
In [36]: dict1 = {x:x**2 for x in range(1,4)}
In [37]: dict1
Out[37]: {1: 1, 2: 4, 3: 9}
字典表達(dá)式也可以結(jié)合一些方法、語句實(shí)現(xiàn)更多的功能。
In [38]: dict2 = {x:len(x) for x in ['aa','bb','ccc']}
In [39]: dict2
Out[39]: {'aa': 2, 'bb': 2, 'ccc': 3}
利用items()方法很容易實(shí)現(xiàn)鍵值對轉(zhuǎn)換，不過需要注意字典的鍵需要唯一。
In [40]: dict3 = {v:k for k,v in dict2.items()}
In [41]: dict3
Out[41]: {2: 'bb', 3: 'ccc'}
通過上面幾個例子可以看到，表達(dá)式是由包含一個表達(dá)式的括號組成，表達(dá)式后面會跟一個for語句，之后還可以跟零或者多個for或if語句，結(jié)果最終會返回一個指定的數(shù)據(jù)類型，其中的元素是通過表達(dá)式依據(jù)后面的for和if語句計(jì)算而得出的。
最后是函數(shù)和文件：
函數(shù)在編程中是一個很重要的角色，我們可以將若干個語句組合形成一個函數(shù)，它可以接受傳入?yún)?shù)，并在內(nèi)部進(jìn)行相關(guān)計(jì)算后產(chǎn)生輸出，將語句封裝成函數(shù)是為了避免重復(fù)使用幾個語句造成代碼冗雜，讓代碼更簡潔可觀性更強(qiáng)。
文件的操作主要是介紹一些關(guān)于文件的讀取及寫入的方法，以及每個方法的不同點(diǎn)和需要注意的事項(xiàng)，最后會介紹一下利用pickle模塊存儲復(fù)雜數(shù)據(jù)的方式。
函數(shù)
函數(shù)主要包括兩個方面：
內(nèi)置函數(shù)自定義函數(shù)內(nèi)置函數(shù)就是python自帶的一些函數(shù)，我們只需要給函數(shù)傳入相關(guān)參數(shù)就可以進(jìn)行調(diào)用，print就是最基礎(chǔ)、最典型的一個內(nèi)置函數(shù)；而自定義函數(shù)是需要我們自己按照需求，封裝若干個語句形成一個新的函數(shù)。
自定義函數(shù)
1.創(chuàng)建函數(shù)
下面通過自定義一個計(jì)算長方體體積的函數(shù)來介紹一些屬性詞：
In [1]: def vol(length,width,height):
...: volume = length*width*height
...: return volume
上面三行代碼中你需要了解：
def:定義函數(shù)的關(guān)鍵字length,width,height:函數(shù)的形參return:函數(shù)的返回值2.調(diào)用函數(shù)
建好一個自定義函數(shù)后，可以通過函數(shù)名(實(shí)參)的方式調(diào)用函數(shù)：
In [2]: vol(2,2,3)
Out[2]: 12
在傳入?yún)?shù)時需要注意的是，實(shí)參與形參必須完全對應(yīng)，比如位置、個數(shù)等等，否則會出現(xiàn)報(bào)錯。
In [4]: vol(2,2)
TypeError: vol() missing 1 required positional argument: 'height'
如果想改變傳參順序，那么你需要指定為哪一個形參傳值：
In [8]: vol(width=3,length=4,height=5)
Out[8]: 60
3.函數(shù)默認(rèn)值
函數(shù)的形參還可以指定默認(rèn)值，假如我們將上面的vol函數(shù)中height參數(shù)默認(rèn)值設(shè)為2：
In [6]: def vol(length,width,height=2):
...: volume = length*width*height
...: return volume
...:
In [7]: vol(2,2)
Out[7]: 8
這時只向vol函數(shù)中傳入兩個實(shí)參，可以發(fā)現(xiàn)沒有報(bào)錯，并且得到返回值為8。也就是說如果一個形參有默認(rèn)值，而調(diào)用函數(shù)時沒有為這個形參傳值，那么這個參數(shù)就取默認(rèn)值。
4.收集函數(shù)(可變函數(shù))
對于一個函數(shù)的形參我們也可以將其設(shè)置為可以變化的：
In [9]: def test(*params):
...: print('參數(shù)的長度為%d'%len(params))
...: print('第三個參數(shù)為%s'%params[2])
...:
In [10]: test(1,2,'mao',3.14,'pp')
參數(shù)的長度為5
第三個參數(shù)為mao
這里需要將形參用*標(biāo)識，然后在調(diào)用參數(shù)的時候可以傳入若干個實(shí)參。
5.全局與局部
在函數(shù)中定義的常量被稱為局部變量，也就是僅限在這個函數(shù)中可以調(diào)用，不接受在函數(shù)之外使用：
In [12]: def test(a,b):
...: c = 2
...: return a*b*c
In [13]: test(2,2)
Out[13]: 8
In [14]: print(c)
NameError: name 'c' is not defined
6.匿名函數(shù)lambda
如果一個函數(shù)內(nèi)部的語句不是很復(fù)雜，代碼量很少，我們就可以利用匿名函數(shù)，比如上面計(jì)算體積的函數(shù)：
In [20]: vol = lambda a,b,c:a*b*c
In [21]: vol(2,2,3)
Out[21]: 12
lambda表達(dá)式常常嵌套的語句中，結(jié)合相關(guān)函數(shù)使用會很簡便，后面會給出例子。
7.內(nèi)嵌函數(shù)
在定義函數(shù)時還支持幾個函數(shù)嵌套，但用的時候需要注意邏輯關(guān)系：
In [24]: def fun1(a):
...: b = 2
...: def fun2():
...: return a*b
...: return fun2()
...:
In [25]: fun1(4)
Out[25]: 8
常用內(nèi)置函數(shù)
內(nèi)置函數(shù)前兩篇文章就有涉及過，比如常用的len、sorted、reversed、sum等等，除此之外再介紹幾個比較基礎(chǔ)的內(nèi)置函數(shù)。
1.max和min
求一個序列中最大值和最小值：
In [28]: min(1,2,3)
Out[28]: 1
In [29]: max(1,2,3)
Out[29]: 3
2.abs
求一個數(shù)的絕對值：
In [31]: abs(-1)
Out[31]: 1
3.round
四舍五入保留小數(shù)點(diǎn)后幾位：
In [32]: round(3.555,2)
Out[32]: 3.56
4.pow
計(jì)算一個數(shù)的冪次方，或者再取余：
In [33]: pow(2,3)#2*2*2
Out[33]: 8
In [34]: pow(2,3,3)#(2*2*2)%3
Out[34]: 2
5.divmod
計(jì)算一個數(shù)的商和余數(shù)：
In [36]: divmod(10,3)
Out[36]: (3, 1)
6.help
用來查詢一個函數(shù)的幫助文檔：
In [37]: help(abs)
Help on built-in function abs in module builtins:
abs(x, /)
Return the absolute value of the argument.
7.filter
filter()函數(shù)接收兩個參數(shù)，第一個參數(shù)可以是一個函數(shù)或者None，第二個參數(shù)是序列。作用是對每個元素進(jìn)行判斷，返回 True或 False，filter()根據(jù)判斷結(jié)果自動過濾掉序列中為False的元素，留下為True的元素，可以結(jié)合lambda表達(dá)式使用：
In [38]: list(filter(lambda x:x%2,range(10)))
Out[38]: [1, 3, 5, 7, 9]
8.map
map()函數(shù)接收兩個參數(shù)，一個是函數(shù)，一個是序列。作用是將函數(shù)應(yīng)用于序列中每一個元素上，同樣可以結(jié)合lambda表達(dá)式使用：
In [42]: list(map(lambda x: x*2,range(10)))
Out[42]: [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
文件
關(guān)于文件讀寫操作，open()函數(shù)是一定遇到的，如果文件已經(jīng)存在則會打開文件，若不存在則會創(chuàng)建一個文件，通常的用法需要兩個參數(shù)：open(filename,mode)。
第一個參數(shù)就是文件名字，第二個參數(shù)就指定文件將會被如何使用，可選模式常用的有以下幾種：
'r':以只讀的方式打開文件(默認(rèn))'w':以寫入模式打開文件，會覆蓋已存在的文件'a':以寫入模式打開文件，如果文件存在，則在末尾追加寫入'b':以二進(jìn)制模式打開文件，進(jìn)而會有rb、wb等模式組合1.read()方法讀取
read()方法可傳入一個參數(shù)size，也就是讀取內(nèi)容的長度。size是一個可選參數(shù)，如果不傳入或者傳入一個負(fù)數(shù)，那么會讀取文件全部內(nèi)容：
In [52]: fb = open('E:/Python基礎(chǔ)/test.txt','r')
In [53]: fb.read(10)
Out[53]: 'nai\nniatan'
In [54]: fb.read()
Out[54]: 'g\nnaitangmao'
In [55]: fb.read()
Out[55]: ''
需要注意的有三點(diǎn)：
1、原文件中換行的地方在讀取時以換行符'\n'表示，并且也占有一個單位長度2、已經(jīng)被讀取的內(nèi)容不能被重復(fù)讀取3、如果讀取內(nèi)容返回為空字符串，表示已經(jīng)到了文件末尾2.readline()方法
readline()方法是從文件中讀取單獨(dú)一行，并且在這一行數(shù)據(jù)的末尾處會有一個換行符'\n'，如果其中一行沒有數(shù)據(jù)，則會只返回一個'\n'，同樣當(dāng)返回空字符串時表示到達(dá)文件末尾。
In [59]: fb1 = open('E:/Python基礎(chǔ)/test.txt','r')
In [60]: fb1.readline()
Out[60]: 'nai\n'
3.readlines()方法
readlines()方法也是用來讀取全部文件，與read()不同之處在于前者是按行讀取，并且最后返回的是一個列表，每一行數(shù)據(jù)作為一個列表元素：
In [72]: fb3 = open('E:/Python基礎(chǔ)/test.txt','r')
In [73]: fb3.readlines()
Out[73]: ['nai\n', 'niatang\n', 'naitangmao']
4.遍歷文件對象讀取
這種方式讀取出的內(nèi)容看起來會比較規(guī)范一些：
In [81]: for i in fb4:
...: print(i,end = '')
...:
nai
niatang
naitangmao
5.文件的寫入
在進(jìn)行寫入操作的時候，我們需要注意的兩個點(diǎn)：
寫入的數(shù)據(jù)如果是非字符串內(nèi)容，需要轉(zhuǎn)換為字符串寫入的方式要注意是覆蓋還是追加
In [85]: fb5 = open('E:/Python基礎(chǔ)/test1.txt','w')
In [89]: list1 = [1,2]
In [91]: fb5.write(str(list1))
Out[91]: 6
用write寫入后會返回寫入字符串的長度。
6.文件關(guān)閉
切記切記切記！如果你用open()的方式打開一個文件，在操作完成之后一定要用close()方法關(guān)閉文件。
In [92]: fb5.close()
7.with方式
如果你感覺自己的記性不好，總是忘記用close()方法關(guān)閉文件，那么就要習(xí)慣利用with處理文件對象，它可以在文件用完之后自動關(guān)閉文件。
In [93]: with open('E:/Python基礎(chǔ)/test.txt','r') as fb:
...: data = fb.read()
In [95]: fb.closed
Out[95]: True
8.pickle
上面說了將一個非字符串寫入文件是不允許的，如果有沒有辦法保存一份字典或者列表形式的數(shù)據(jù)呢？pickle模塊就可以實(shí)現(xiàn)這種序列化的存儲與讀取：
In [96]: import pickle
In [97]: list1 = ['nai','tang','mao',1,2,3]
In [98]: pic_f = open('E:/Python基礎(chǔ)/list.pkl','wb')
In [99]: pickle.dump(list1,pic_f)
In [100]: pic_f.close()
dump()方法接收兩個參數(shù)，第一個是要存儲的內(nèi)容，第二個是存儲的文件對象，操作之后也需要用close()關(guān)閉文件對象，存儲之后可以利用load()方法加載文件中的內(nèi)容。
In [102]: pic_f = open('E:/Python基礎(chǔ)/list.pkl','rb')
In [103]: list2 = pickle.load(pic_f)
In [104]: list2
Out[104]: ['nai', 'tang', 'mao', 1, 2, 3]
In [105]: pic_f.close()
利用pickle在存儲或者讀取的時候要注意以二進(jìn)制的形式操作文件對象，也就是'wb'和'rb'，pickle很適合用來存儲數(shù)據(jù)類型比較復(fù)雜并且數(shù)據(jù)量又很大的數(shù)據(jù)。
總結(jié)
以上是生活随笔為你收集整理的python中遍历结构可以是哪些数据类型_全！Python基础之原生数据类型、判断和循环、函数和文件操作合集...的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 所有受限制的应用程序包_【译】使用Bla
- 下一篇： data transformation