長文預警！

Python基礎系列會將基礎內容大致分為三到五個板塊，每塊著重講一方面，知識不會很難，主要是以小例子的形式解讀，如果你已經入門Python，希望可以幫你溫習一下；如果你想入門Python，希望可以幫你越過這個門檻。

Python原生數據類型主要有Number、String、Byte、Boolean、None、List、Tuple、Set、Dict這九種，下面先講一下字符串、列表、元祖、集合、字典這五種，剩下的四種大家可以自己了解一下。

字符串

初始化一個字符串，方便后面在字符串上做一些操作。

In?[5]:?s1?=?'naitangmao'
In?[6]:?s1
Out[6]:?'naitangmao'

字符串的索引，需要注意的是索引下標從0開始。

In?[9]:?s1[2]
Out[9]:?'i'

字符串的切片，以冒號分隔首尾索引位置，是[start:end]結構，注意不包含end對應元素；冒號左邊不寫入索引表示從頭開始，同理右邊不寫入索引表示截取到字符串末尾。

In?[8]:?s1[:3]#從0開始，0,1,2三個索引
Out[8]:?'nai'

還可以利用切片結合負索引實現翻轉字符串。

In?[35]:?s1[::-1]
Out[35]:?'oamgnatian'

利用加法實現合并字符串。

In?[49]:?print('ab'+'%'+'cd')
ab%cd

查找，利用find方法查詢元素時，會返回在字符串第一次出現的下標，未找到會返回-1。

In?[11]:?s1.find('a')
Out[11]:?1

替換，replace可以實現字符串中元素的替換，比如將'tang'替換成空格。

In?[13]:?s1.replace('tang','?')
Out[13]:?'nai?mao'

去空格，使用strip方法可以刪除一個字符串首尾的空格，然后也支持指定要刪除內容。

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方法可以根據元素切割字符串，并存入列表；如果不輸入參數，會直接將原字符串存入列表。

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!'

利用%向字符串中傳入參數，%s傳入字符串、%d傳入整數、%f傳入浮點數，且可以控制小數點后的位數。

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向字符串中傳入參數，且不需要在意參數類型。

In?[46]:?'{0}ai{1}ang{2}ao'.format('n','66','3.14')
Out[46]:?'nai66ang3.14ao'

利用反斜杠對字符串進行轉義。

In?[47]:?print('\t')
In?[48]:?print('\\t')
\t

列表

同樣初始化一個列表，然后方便對列表做一系列操作。

In?[52]:?list1
Out[52]:?[1,?3,?5,?7,?9,?11]

首先同樣是列表的索引，列表也支持負索引。

In?[53]:?list1[2]
Out[53]:?5
In?[55]:?list1[-2]#負索引
Out[55]:?9

再拓展一下帶有間隔的切片，字符串同樣適用，就是在end之后再加上一個雙引號，用來寫入切片的間隔，這才是切片最完整的結構。

In?[58]:?list1[0:6:2]
Out[58]:?[1,?5,?9]

利用index方法可以獲取某個元素在列表中的位置索引，未找到的則會報錯。

In?[60]:?list1.index(3)
Out[60]:?1

利用join方法將列表中的各個元素合并為字符串。

In?[121]:?list1?=?['a','b','c']
In?[122]:?''.join(list1)
Out[122]:?'abc'

count方法可以統計一個元素在列表中出現的次數。

In?[63]:?list1.count(5)
Out[63]:?1

enumerate可以直接獲取列表的索引和對應元素。

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)]]

擴大列表的四種方法：

• 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：從列表中刪去指定元素，沒有則會報錯。
• 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]

翻轉列表的三種方式：

• 1、reverse:就地倒排列表中的元素。
• 2、reversed:函數對列表進行反轉，并返回一個新的迭代器，需要用list轉換
• 3、切片結合負索引

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]

實現列表排序的兩種方式：

• 1、sort:對列表中的元素就地進行排序。
• 2、sorted:函數對列表進行排序，形成一個新列表
• 3、利用lambda自定義函數

這兩種方法默認為升序，通過參數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)

深拷貝和淺拷貝的區別因為涉及到數據結構，口頭敘述不容易理解，網上有很多圖例講解的博客，大家可以了解一下。

元組

元組和列表是非常相似的，有一種類似近親的關系，也就是說列表中很多操作同樣適用于元組，比如索引、切片等等，但也有一部分不同，這里主要來說一下元組的特別之處。

首先元組又被稱作帶鎖的列表，就是元組內的元素是不能隨意更改的，比如你不能給元組中的一個元素隨意賦值。

In?[2]:?tuple1?=?(1,2,3)
In?[3]:?tuple1[2]?=?4#會發生報錯，告訴你不支持這樣的操作
TypeError:?'tuple'?object?does?not?support?item?assignment

元組的標志并不是單純的小括號，而是逗號，或者小括號與逗號的結合，看下面這個例子。

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這類的操作。元組中增添可以利用"+"實現，刪除則可以利用del，因為這是python自帶的回收機制。

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

"*"在數值型之間為乘積運算符，而在列表和元組之間可以表示為重復運算符。

In?[53]:?tuple5?=?(1,2)
In?[54]:?tuple5?*?3
Out[54]:?(1,?2,?1,?2,?1,?2)

集合

集合是一個無序不重復元素的集?；竟δ馨P系測試和消除重復元素。集合對象還支持聯合、交、差和對稱差集等數學運算。

首先可以利用大括號或set()函數創建集合，如果想要創建空集合，你必須使用set()而不是{}，{}用來創建字典。

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}

將集合轉化為列表時，會自動排序。

In?[74]:?set2?=?{5,5,4,2,2,0}
In?[75]:?list_?=?list(set2)
In?[76]:?list_
Out[76]:?[0,?2,?4,?5]

集合之間的一些運算操作。

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中一個非常有用的原生數據類型，一般序列是用連續的整數作為索引，而字典是以關鍵字作為索引，且關鍵字要是任意不可變類型。理解字典時可以把它看做無序的鍵：值對(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}

而如果這個鍵已經存在于字典中了，就表示為這個鍵賦值。

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)]

元組形式或者列表中嵌套的元組的形式都可以轉換成字典，因為要保持不可變性。

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}

當然也可以通過'='賦值的形式創建一個字典。

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

根據鍵查詢對應值的兩種方式：

• 1、直接利用鍵的名字索引，不足的是如果字典中沒有這個鍵則會發生報錯。
• 2、利用get方法，可以設置不存在鍵名的情況下的返回值，默認返回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()方法，與列表不同的是必須要傳入一個字典中已有鍵的參數。
• 2、popitem()，類似于列表中的pop()，隨機刪除一組鍵值對而非刪除最后一個，因為字典本身無序。
• 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()方法可以傳入一組鍵值對，如果字典中已有同名鍵，則返回鍵在字典中對應的值，否則將傳入的鍵值對存入字典中。

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()方法可以用來更新字典：

• 如果字典中已有傳入的鍵，則更新鍵對應的值。
• 如果沒有，則將傳入的鍵值對存入字典中。

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}

總結

上面就是五種數據類型基本操作的一個概括，其中比較常用的三種就是字符串、列表和字典，應該重點掌握。

接下來是幾個語法表達式：

流程控制是python語法很重要的一個分支，主要包括我們經常用到的判斷語句、循環語句以及各種表達式。

判斷語句(if)

判斷語句中最有名的應該就是if-else的組合，并且很多語言都通用這種格式，但是對于elif而言，不同語言表達形式可能會不同：

In?[1]:?x?=?5
In?[2]:?if?x>0:
???...:?????print('正整數')
???...:?elif?x<0:
???...:?????print('負整數')
???...:?else:
???...:?????print('零')
???...:
正整數

一組判斷語句可能會有零到多個 elif 部分，else 是可選的。關鍵字 elif ?是 else if 的縮寫，由于python對縮進的要求很嚴格，而這種寫法恰巧可以有效地避免過深的縮進。if ... elif ... elif ... 序列用于替代其它語言中的 switch 或 case 語句。

循環語句

1、for循環

如果C語言是你最熟悉的需要，要注意python和C語言中的for語句表達形式完全不同。Python 的 for 語句依據任意序列(字符串、列表)中的子項，按照它們在序列中的順序來進行迭代。

In?[3]:?str1?=?'mao'
In?[4]:?for?i?in?str1:
???...:?????print(i)
???...:
m
a
o

對列表的循環與字符串幾乎一致，只是子項不同。

In?[5]:?list1?=?['a','aa','aaa']
In?[6]:?for?i?in?list1:
???...:?????print(i,len(i))
???...:
a?1
aa?2
aaa?3

for語句與range函數結合是一種很常見的組合，range函數主要提供一個數值序列。

In?[8]:?for?j?in?range(len(list1)):
???...:?????print(j,list1[j])
???...:0?a1?aa2?aaa

range提供的數值索引方式可以參考列表的切片，同樣默認以0開始，且不包括最后一位，上面這種場合利用enumerate()函數表達會更加簡單。

In?[9]:?for?i,v?in?enumerate(list1):
???...:?????print(i,v)
???...:0?a1?aa2?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循環。

In?[15]:?for?i?in?range(0,5):
????...:?????if?i?==?3:
????...:?????????break
????...:?????else:
????...:?????????print(i)012

可以看到在for循環中加了一個判斷語句，當i等于3時會跳出for循環，不再繼續執行，輸出與語義符合。

continue語句的作用就是表示繼續執行下一次迭代，可以結合判斷語句使用，在什么條件下繼續執行，或者什么條件下跳出循環。

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占位，不會發生報錯。

In?[1]:?while?True:
???...:?????pass

迭代器、生成器

我們通常接觸到的迭代器有序列，比如字符串、列表等等，利用iter()方法可以構建一個迭代器，與之匹配的next()方法可以迭代返回迭代器內的值，并將返回值彈出迭代器。

In?[1]:?it?=?iter('python')
In?[2]:?print(it)0x00000187ADA75A00>
In?[3]:?next(it)
Out[3]:?'p'
In?[4]:?next(it)
Out[4]:?'y'

當next方法迭代到最后一個值時，繼續調用next方法會彈出報錯。當然也可以利用for循環迭代輸出：

In?[6]:?for?i?in?it:
???...:?????print(i)
t
h
o
n

如果你深入了解Python之后會發現生成器用起來會更加方便，結合函數即可。生成器的關鍵字為yield，生成器也具有next()方法，并且可以利用for循環迭代輸出。

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)0x00000187AD99FDD0>
In?[11]:?next(gen)
Out[11]:?'o'
In?[12]:?for?i?in?gen:
????...:?????print(i)
a
m

用小括號括起來的一個表達式可以用來創建一個生成器，下面將講述如何來書寫各種的表達式。

In?[14]:?gen2?=?(i?for?i?in?range(0,5))
In?[15]:?print(gen2)?at?0x00000187ADA18D60>

表達式

列表表達式

各種表達式為我們創建相關數據類型提供了一種更加簡單的方法，首先是列表表達式，普通的方法是通過將一些操作應用于序列的每個成員并通過返回的元素創建列表，或者通過滿足特定條件的元素創建子序列。比如我們想獲取10以內的平方數，利用普通方法如下：

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]

但一行語句就足以囊括上面的內容，可見列表表達式的簡潔性。

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]

上面這個列表表達式應該是比較簡單的，我們還可以在表達式中加入判斷語句作為篩選條件。

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]

進一步可以結合兩個列表的元素組成一個列表表達式:

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)]

在復雜一點的列表表達式就是嵌套類型的，但是這樣的表達式缺點就是可讀性不太好，因為你需要去思考他的一些細節，比如將一個23的矩陣轉變為32的矩陣。

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]]

集合表達式

集合表達式與列表表達式有兩處不同：

• 1、集合表達式需要用{}
• 2、集合表達式返回的是集合，所以會對元素去重

In?[32]:?set1?=?{i?for?i?in?'abcdddddd'?if?i?not?in?'abc'}
In?[33]:?set1
Out[33]:?{'d'}

可以看到for語句中的字符串原本有很多d，經過條件過濾和集合去重最后只剩下了一個。

當然也可以通過set()方法將一個列表表達式轉換為集合的形式。

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)}

字典表達式

字典是python中很常用的一種數據類型，所以字典表達式也顯得尤為重要。字典表達式同樣也用{}構建，只不過表達式還要用(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}

字典表達式也可以結合一些方法、語句實現更多的功能。

In?[38]:?dict2?=?{x:len(x)?for?x?in?['aa','bb','ccc']}
In?[39]:?dict2
Out[39]:?{'aa':?2,?'bb':?2,?'ccc':?3}

利用items()方法很容易實現鍵值對轉換，不過需要注意字典的鍵需要唯一。

In?[40]:?dict3?=?{v:k?for?k,v?in?dict2.items()}
In?[41]:?dict3
Out[41]:?{2:?'bb',?3:?'ccc'}

通過上面幾個例子可以看到，表達式是由包含一個表達式的括號組成，表達式后面會跟一個for語句，之后還可以跟零或者多個for或if語句，結果最終會返回一個指定的數據類型，其中的元素是通過表達式依據后面的for和if語句計算而得出的。

最后是函數和文件：函數在編程中是一個很重要的角色，我們可以將若干個語句組合形成一個函數，它可以接受傳入參數，并在內部進行相關計算后產生輸出，將語句封裝成函數是為了避免重復使用幾個語句造成代碼冗雜，讓代碼更簡潔可觀性更強。文件的操作主要是介紹一些關于文件的讀取及寫入的方法，以及每個方法的不同點和需要注意的事項，最后會介紹一下利用pickle模塊存儲復雜數據的方式。

函數

函數主要包括兩個方面：

• 內置函數

• 自定義函數

內置函數就是python自帶的一些函數，我們只需要給函數傳入相關參數就可以進行調用，print就是最基礎、最典型的一個內置函數；而自定義函數是需要我們自己按照需求，封裝若干個語句形成一個新的函數。

自定義函數

1.創建函數

下面通過自定義一個計算長方體體積的函數來介紹一些屬性詞：

In?[1]:?def??vol(length,width,height):
???...:?????volume?=?length*width*height
???...:?????return?volume

上面三行代碼中你需要了解：

• def:定義函數的關鍵字

• length,width,height:函數的形參

• return:函數的返回值

2.調用函數

建好一個自定義函數后，可以通過函數名(實參)的方式調用函數：

In?[2]:?vol(2,2,3)
Out[2]:?12

在傳入參數時需要注意的是，實參與形參必須完全對應，比如位置、個數等等，否則會出現報錯。

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.函數默認值

函數的形參還可以指定默認值，假如我們將上面的vol函數中height參數默認值設為2：

In?[6]:?def??vol(length,width,height=2):
???...:?????volume?=?length*width*height
???...:?????return?volume
???...:
In?[7]:?vol(2,2)
Out[7]:?8

這時只向vol函數中傳入兩個實參，可以發現沒有報錯，并且得到返回值為8。也就是說如果一個形參有默認值，而調用函數時沒有為這個形參傳值，那么這個參數就取默認值。

4.收集函數(可變函數)

對于一個函數的形參我們也可以將其設置為可以變化的：

In?[9]:?def?test(*params):
???...:?????print('參數的長度為%d'%len(params))
???...:?????print('第三個參數為%s'%params[2])
???...:
In?[10]:?test(1,2,'mao',3.14,'pp')
參數的長度為5
第三個參數為mao

這里需要將形參用*標識，然后在調用參數的時候可以傳入若干個實參。

5.全局與局部

在函數中定義的常量被稱為局部變量，也就是僅限在這個函數中可以調用，不接受在函數之外使用：

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.匿名函數lambda

如果一個函數內部的語句不是很復雜，代碼量很少，我們就可以利用匿名函數，比如上面計算體積的函數：

In?[20]:?vol?=?lambda?a,b,c:a*b*c
In?[21]:?vol(2,2,3)
Out[21]:?12

lambda表達式常常嵌套的語句中，結合相關函數使用會很簡便，后面會給出例子。

7.內嵌函數

在定義函數時還支持幾個函數嵌套，但用的時候需要注意邏輯關系：

In?[24]:?def?fun1(a):
????...:?????b?=?2
????...:?????def?fun2():
????...:?????????return?a*b
????...:?????return?fun2()
????...:
In?[25]:?fun1(4)
Out[25]:?8

常用內置函數

內置函數前兩篇文章就有涉及過，比如常用的len、sorted、reversed、sum等等，除此之外再介紹幾個比較基礎的內置函數。

1.max和min

求一個序列中最大值和最小值：

In?[28]:?min(1,2,3)
Out[28]:?1
In?[29]:?max(1,2,3)
Out[29]:?3

2.abs

求一個數的絕對值：

In?[31]:?abs(-1)
Out[31]:?1

3.round

四舍五入保留小數點后幾位：

In?[32]:?round(3.555,2)
Out[32]:?3.56

4.pow

計算一個數的冪次方，或者再取余：

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

計算一個數的商和余數：

In?[36]:?divmod(10,3)
Out[36]:?(3,?1)

6.help

用來查詢一個函數的幫助文檔：

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()函數接收兩個參數，第一個參數可以是一個函數或者None，第二個參數是序列。作用是對每個元素進行判斷，返回 True或 False，filter()根據判斷結果自動過濾掉序列中為False的元素，留下為True的元素，可以結合lambda表達式使用：

In?[38]:?list(filter(lambda?x:x%2,range(10)))
Out[38]:?[1,?3,?5,?7,?9]

8.map

map()函數接收兩個參數，一個是函數，一個是序列。作用是將函數應用于序列中每一個元素上，同樣可以結合lambda表達式使用：

In?[42]:?list(map(lambda?x:?x*2,range(10)))
Out[42]:?[0,?2,?4,?6,?8,?10,?12,?14,?16,?18]

文件

關于文件讀寫操作，open()函數是一定遇到的，如果文件已經存在則會打開文件，若不存在則會創建一個文件，通常的用法需要兩個參數：open(filename,mode)。

第一個參數就是文件名字，第二個參數就指定文件將會被如何使用，可選模式常用的有以下幾種：

• 'r':以只讀的方式打開文件(默認)

• 'w':以寫入模式打開文件，會覆蓋已存在的文件

• 'a':以寫入模式打開文件，如果文件存在，則在末尾追加寫入

• 'b':以二進制模式打開文件，進而會有rb、wb等模式組合

1.read()方法讀取

read()方法可傳入一個參數size，也就是讀取內容的長度。size是一個可選參數，如果不傳入或者傳入一個負數，那么會讀取文件全部內容：

In?[52]:?fb?=?open('E:/Python基礎/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]:?''

需要注意的有三點：

• 1、原文件中換行的地方在讀取時以換行符'\n'表示，并且也占有一個單位長度

• 2、已經被讀取的內容不能被重復讀取

• 3、如果讀取內容返回為空字符串，表示已經到了文件末尾

2.readline()方法

readline()方法是從文件中讀取單獨一行，并且在這一行數據的末尾處會有一個換行符'\n'，如果其中一行沒有數據，則會只返回一個'\n'，同樣當返回空字符串時表示到達文件末尾。

In?[59]:?fb1?=?open('E:/Python基礎/test.txt','r')
In?[60]:?fb1.readline()
Out[60]:?'nai\n'

3.readlines()方法

readlines()方法也是用來讀取全部文件，與read()不同之處在于前者是按行讀取，并且最后返回的是一個列表，每一行數據作為一個列表元素：

In?[72]:?fb3?=?open('E:/Python基礎/test.txt','r')
In?[73]:?fb3.readlines()
Out[73]:?['nai\n',?'niatang\n',?'naitangmao']

4.遍歷文件對象讀取

這種方式讀取出的內容看起來會比較規范一些：

In?[81]:?for?i?in?fb4:
????...:?????print(i,end?=?'')
????...:
nai
niatang
naitangmao

5.文件的寫入

在進行寫入操作的時候，我們需要注意的兩個點：

• 寫入的數據如果是非字符串內容，需要轉換為字符串

• 寫入的方式要注意是覆蓋還是追加

In?[85]:?fb5?=?open('E:/Python基礎/test1.txt','w')
In?[89]:?list1?=?[1,2]
In?[91]:?fb5.write(str(list1))
Out[91]:?6

用write寫入后會返回寫入字符串的長度。

6.文件關閉

切記切記切記！如果你用open()的方式打開一個文件，在操作完成之后一定要用close()方法關閉文件。

In?[92]:?fb5.close()

7.with方式

如果你感覺自己的記性不好，總是忘記用close()方法關閉文件，那么就要習慣利用with處理文件對象，它可以在文件用完之后自動關閉文件。

In?[93]:?with?open('E:/Python基礎/test.txt','r')?as?fb:
????...:?????data?=?fb.read()
In?[95]:?fb.closed
Out[95]:?True

8.pickle

上面說了將一個非字符串寫入文件是不允許的，如果有沒有辦法保存一份字典或者列表形式的數據呢？pickle模塊就可以實現這種序列化的存儲與讀取：

In?[96]:?import?pickle
In?[97]:?list1?=?['nai','tang','mao',1,2,3]
In?[98]:?pic_f?=?open('E:/Python基礎/list.pkl','wb')
In?[99]:?pickle.dump(list1,pic_f)
In?[100]:?pic_f.close()

dump()方法接收兩個參數，第一個是要存儲的內容，第二個是存儲的文件對象，操作之后也需要用close()關閉文件對象，存儲之后可以利用load()方法加載文件中的內容。

In?[102]:?pic_f?=?open('E:/Python基礎/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在存儲或者讀取的時候要注意以二進制的形式操作文件對象，也就是'wb'和'rb'，pickle很適合用來存儲數據類型比較復雜并且數據量又很大的數據。

總結

以上是生活随笔為你收集整理的python sorted下标_全！Python基础之原生数据类型、判断和循环、函数和文件操作合集...的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。