本文以 Eric Matthes 的《Python編程：從入門到實踐》為基礎，以有一定其他語言經(jīng)驗的程序員視角，對書中內(nèi)容提煉總結(jié)，化繁為簡，將這本書的精髓融合成一篇10分鐘能讀完的文章。

讀完本篇文章后，可對 Python 語言特性、編碼風格有一定了解，并可寫出簡單的 Python 程序。

100 多位經(jīng)驗豐富的開發(fā)者參與，在 Github 上獲得了近 1000 個 star 的開源項目想了解下嗎？
項目地址：https://github.com/cachecats/coderiver

一、安裝與運行

各個系統(tǒng)的 Python 安裝教程請自行查閱資料，這里不再贅述。

檢查 Python 版本，在命令行輸入 python 即可，同時會進入命令行交互模式，可以在這里執(zhí)行 python 命令。

如果電腦中安裝了 python2.x 和 python3.x 兩個版本，輸入 python 運行的是 2.x 版本。想運行 3.x，則需輸入 python3。

在命令行輸入 python ：

Solo-mac:~ solo$ python
Python 2.7.10 (default, Aug 17 2018, 19:45:58)
[GCC 4.2.1 Compatible Apple LLVM 10.0.0 (clang-1000.0.42)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>>

在命令行輸入 python3 ：

Solo-mac:~ solo$ python3
Python 3.7.0 (v3.7.0:1bf9cc5093, Jun 26 2018, 23:26:24)
[Clang 6.0 (clang-600.0.57)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>>

輸入 exit() 即可退出命令行模式。

命令行運行 python 文件

如果是寫好了一個 python 文件，想通過命令行運行它，進入這個目錄，在命令行輸入 python 文件名.py 即可。

比如桌面上有個文件 hello.py，內(nèi)容是打印一句話：

print("Hello, Python")

想運行它，先進入 Desktop 目錄，再在命令行輸入 python hello.py 就能運行：

Solo-mac:Desktop solo$ python hello.py
Hello, Python

二、變量和簡單數(shù)據(jù)類型

2.1 變量命名規(guī)則

• 變量名只能包含字母、數(shù)字和下劃線。變量名可以字母或下劃線打頭，但不能以數(shù)字打 頭，例如，可將變量命名為message_1，但不能將其命名為1_message。
• 變量名不能包含空格，但可使用下劃線來分隔其中的單詞。例如，變量名greeting_message 可行，但變量名greeting message會引發(fā)錯誤。
• 不要將Python關鍵字和函數(shù)名用作變量名，即不要使用Python保留用于特殊用途的單詞， 如print。
• 變量名應既簡短又具有描述性。例如，name比n好，student_name比s_n好，name_length比length_of_persons_name好。
• 慎用小寫字母l和大寫字母O，因為它們可能被人錯看成數(shù)字1和0。

變量名應該是小寫的，雖然沒有強制規(guī)定，但是約定俗稱的規(guī)則。

2.2 字符串

字符串就是一系列字符。在Python中，用引號括起的都是字符串，其中的引號可以是單引號，也可以是雙引號，還可以同時使用。如：

"This is a string." 
'This is also a string.'
"I love 'python'"

2.2.1 字符串的簡單運算

下面介紹字符串的簡單運算。

title()

title()以首字母大寫的方式顯示每個單詞，即將每個單詞的首字母都改為大寫。

>>> name = 'solo coder'
>>> name.title()
'Solo Coder'

upper()、lower()

將字符串改為全部大寫或全部小寫。

>>> name
'solo coder'
>>> name.upper()
'SOLO CODER'
>>> name.lower()
'solo coder'
>>> name
'solo coder'

注意：title()、upper()、lower() 均不改變原字符串，只是輸出了一個新的字符串。

2.2.2 合并（拼接）字符串

Python使用加號(+)來合并字符串。

>>> first = 'solo'
>>> last = 'coder'
>>> full = first + ' ' + last
>>> full
'solo coder'

2.2.3 使用制表符或換行符來添加空白

在編程中，空白泛指任何非打印字符，如空格、制表符和換行符。

要在字符串中添加制表符，可使用字符組合 \t，要在字符串中添加換行符，可使用字符組合 \n 。

>>> print('\tPython')
	Python
>>> print('Hello,\nPython')
Hello,
Python

2.2.4 刪除空白

rstrip() 刪除右側(cè)空白，lstrip() 刪除左側(cè)空白，strip() 刪除兩端空白。

>>> msg = ' Python '
>>> msg
' Python '
>>> msg.rstrip()
' Python'
>>> msg.lstrip()
'Python '
>>> msg.strip()
'Python'
>>> msg
' Python '

注意執(zhí)行完去空格命令后，再打印出 msg，還是原來的字符串，這說明 strip() 也不改變原來的字符串。

2.2.5 Python 2 中的 print 語句

在Python 2中，print語句的語法稍有不同:

>>> python2.7
>>> print "Hello Python 2.7 world!" 
Hello Python 2.7 world!

在Python 2中，無需將要打印的內(nèi)容放在括號內(nèi)。從技術(shù)上說，Python 3中的print是一個函數(shù)，因此括號必不可少。有些Python 2 print語句也包含括號，但其行為與Python 3中稍有不同。簡單地說，在Python 2代碼中，有些print語句包含括號，有些不包含。

2.3 數(shù)字

2.3.1 整數(shù)

在Python中，可對整數(shù)執(zhí)行加(+)減(-)乘(*)除(/)運算。

>>> 2 + 3 
5
>>> 3 - 2 
1
>>> 2 * 3 
6
>>> 3 / 2 
1.5

Python還支持運算次序，因此你可在同一個表達式中使用多種運算。你還可以使用括號來修 改運算次序，讓Python按你指定的次序執(zhí)行運算，如下所示:

>>> 2 + 3*4
14
>>> (2 + 3) * 4 20

2.3.2 浮點數(shù)

Python將帶小數(shù)點的數(shù)字都稱為浮點數(shù)。大多數(shù)編程語言都使用了這個術(shù)語，它指出了這樣一個事實:小數(shù)點可出現(xiàn)在數(shù)字的任何位置。

從很大程度上說，使用浮點數(shù)時都無需考慮其行為。你只需輸入要使用的數(shù)字，Python通常都會按你期望的方式處理它們:

>>> 0.1 + 0.1
0.2
>>> 0.2 + 0.2 9 0.4
>>>2 * 0.1
0.2
>>>2 * 0.2
0.4

但需要注意的是，結(jié)果包含的小數(shù)位數(shù)可能是不確定的:

>>> 0.2 + 0.1 
0.30000000000000004 
>>> 3 * 0.1 
0.30000000000000004

所有語言都存在這種問題，沒有什么可擔心的。Python會盡力找到一種方式，以盡可能精確地表示結(jié)果，但鑒于計算機內(nèi)部表示數(shù)字的方式，這在有些情況下很難。后面將會學習更多的處理方式。

2.3.3 使用函數(shù)str()避免類型錯誤

如果用數(shù)字跟字符串拼接，就會出現(xiàn)類型錯誤。為避免這個問題，可以使用 str() 將數(shù)字轉(zhuǎn)換為字符串再進行操作。

>>> age = 18
>>> print('my age is ' + age)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only concatenate str (not "int") to str
>>> print('my age is ' + str(age))
my age is 18

2.3.4 Python 2 中的整數(shù)

在Python 2中，將兩個整數(shù)相除得到的結(jié)果稍有不同:

>>> python2.7 
>>> 3 / 2
1

Python返回的結(jié)果為1，而不是1.5。在Python 2中，整數(shù)除法的結(jié)果只包含整數(shù)部分，小數(shù)部 分被刪除。請注意，計算整數(shù)結(jié)果時，采取的方式不是四舍五入，而是將小數(shù)部分直接刪除。

在Python 2中，若要避免這種情況，務必確保至少有一個操作數(shù)為浮點數(shù)，這樣結(jié)果也將為 浮點數(shù):

>>> 3 / 2
1
>>> 3.0 / 2
1.5
>>> 3 / 2.0 
1.5
>>> 3.0 / 2.0 
1.5

從Python 3轉(zhuǎn)而用Python 2或從Python 2轉(zhuǎn)而用Python 3時，這種除法行為常常會令人迷惑。使用或編寫同時使用浮點數(shù)和整數(shù)的代碼時，一定要注意這種異常行為。

2.3.5 注釋

在Python中，注釋用井號(#)標識。井號后面的內(nèi)容都會被Python解釋器忽略。如

# 向大家問好
print("Hello Python people!")

三、列表

列表由一系列按特定順序排列的元素組成。

在Python中，用方括號([])來表示列表，并用逗號來分隔其中的元素。

>>> list = []
>>> list.append('haha')
>>> list.append('heihei')
>>> list.append('hehe')
>>> list
['haha', 'heihei', 'hehe']
>>> list[0]
'haha'

獲取最后一個元素可以用 -1，如 list[-1] 是獲取最后一個元素，list[-2] 是獲取倒數(shù)第二個元素。

3.1 列表的增刪改查

3.1.1 修改元素

修改元素直接用索引修改

>>> list[0] = 'nihao'
>>> list
['nihao', 'heihei', 'hehe']

3.1.2 添加元素

可以在末尾添加，也可以在任意位置插入。

在末尾添加：append

>>> list.append('wa')
>>> list
['nihao', 'heihei', 'hehe', 'wa']

插入：insert

>>> list.insert(1, 'hello')
>>> list
['nihao', 'hello', 'heihei', 'hehe', 'wa']

3.1.3 刪除元素

刪除有三種方式：

• del：按索引刪除
• pop()：刪除列表最后一個元素并返回最后一個元素的值。也可以傳索引刪除任意位置的值。
• remove()：按值刪除

>>> list
['nihao', 'hello', 'heihei', 'hehe', 'wa']
>>> del list[1]
>>> list
['nihao', 'heihei', 'hehe', 'wa']
>>> list.pop()
'wa'
>>> list.remove('hehe')
>>> list
['nihao', 'heihei']

給 pop() 傳索引刪除其他位置的值

>>> list
['nihao', 'heihei']
>>> list.pop(0)
'nihao'
>>> list
['heihei']

注意：

方法remove()只刪除第一個指定的值。如果要刪除的值可能在列表中出現(xiàn)多次，就需要使用循環(huán)來判斷是否刪除了所有這樣的值。

如果你不確定該使用del語句還是pop()方法，下面是一個簡單的判斷標準:如果你要從列表中刪除一個元素，且不再以任何方式使用它，就使用del語句;如果你要在刪除元素后還能繼續(xù)使用它，就使用方法pop()。

3.2 組織列表

本節(jié)將介紹列表的排序、反轉(zhuǎn)、計算長度等操作。

列表的排序主要有兩種方式：

• 使用方法sort()對列表進行永久性排序
• 使用函數(shù)sorted()對列表進行臨時排序

3.2.1 使用方法sort()對列表進行永久性排序

使用 sort() 方法將改變原列表。如果要反轉(zhuǎn)排序，只需向sort()方法傳遞參數(shù) reverse=True。

>>> list
['zhangsan', 'lisi', 'bob', 'alex']
>>> list.sort()
>>> list
['alex', 'bob', 'lisi', 'zhangsan']
>>> list.sort(reverse=True)
>>> list
['zhangsan', 'lisi', 'bob', 'alex']

3.2.2 使用函數(shù)sorted()對列表進行臨時排序

函數(shù) sorted() 讓你能夠按特定順序顯示列表元素，同時不影響它們在列表中的原始排列順序。

如果要反轉(zhuǎn)排序，只需向 sorted() 傳遞參數(shù) reverse=True。

>>> list = ['douglas','alex','solo','super']
>>> sorted(list)
['alex', 'douglas', 'solo', 'super']
>>> list
['douglas', 'alex', 'solo', 'super']
>>> sorted(list, reverse=True)
['super', 'solo', 'douglas', 'alex']
>>> list
['douglas', 'alex', 'solo', 'super']

3.2.3 反轉(zhuǎn)列表

要反轉(zhuǎn)列表元素的排列順序，可使用方法 reverse()。 reverse() 也會改變原始列表。

reverse() 只會按原來的順序反轉(zhuǎn)，不會進行額外的按字母排序。

>>> list
['douglas', 'alex', 'solo', 'super']
>>> list.reverse()
>>> list
['super', 'solo', 'alex', 'douglas']

3.2.4 確定列表的長度

使用函數(shù)len()可快速獲悉列表的長度。

>>> list
['super', 'solo', 'alex', 'douglas']
>>> len(list)
4

3.3 操作列表

3.3.1 循環(huán)

使用 for…in 循環(huán)。

python 以縮進來區(qū)分代碼塊，所以需要正確的縮進

>>> cats
['super', 'solo', 'alex', 'douglas']
>>> for cat in cats:
...     print(cat)
...
super
solo
alex
douglas

3.3.2 range()

Python函數(shù)range()讓你能夠輕松地生成一系列的數(shù)字。

>>> for value in range(1,5):
...     print(value)
...
1
2
3
4

注意：range() 會產(chǎn)生包含第一個參數(shù)但不包含第二個參數(shù)的一系列數(shù)值。

使用 range() 創(chuàng)建列表

>>> numbers = list(range(1,6))
>>> numbers
[1, 2, 3, 4, 5]

range() 還可以指定步長。下面的例子生成了從0開始，到11的偶數(shù)：

>>> nums = list(range(0,11,2))
>>> nums
[0, 2, 4, 6, 8, 10]

3.3.3 對列表簡單的計算

有幾個專門用于處理數(shù)字列表的Python函數(shù)。

• min()：計算最小值
• max()：計算最大值
• sum()：計算總和

>>> numbers
[1, 2, 3, 4, 5]
>>> min(numbers)
1
>>> max(numbers)
5
>>> sum(numbers)
15

3.3.4 列表解析

列表解析將for循環(huán)和創(chuàng)建新元素的代碼合并成一行，并自動附加新元素。

>>> squares = [value**2 for value in range(1,11)]
>>> squares
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

要使用這種語法，首先指定一個描述性的列表名，如squares;然后，指定一個左方括號， 并定義一個表達式，用于生成你要存儲到列表中的值。在這個示例中，表達式為 value ** 2，它計 算平方值。接下來，編寫一個for循環(huán)，用于給表達式提供值，再加上右方括號。在這個示例中， for循環(huán)為for value in range(1,11)，它將值1~10提供給表達式 value ** 2。請注意，這里的for 語句末尾沒有冒號。

3.4 切片

要創(chuàng)建切片，可指定要使用的第一個元素和最后一個元素的索引。與函數(shù)range()一樣，Python在到達你指定的第二個索引前面的元素后停止。要輸出列表中的前三個元素，需要指定索引0~3，這將輸出分別為0、1和2的元素。

>>> names = ['aa','bb','cc','dd']
>>> print(names[1:4])
['bb', 'cc', 'dd']

如果你沒有指定第一個索引，Python將自動從列表開頭開始:

>>> print(names[:4])
['aa', 'bb', 'cc', 'dd']

如果沒有指定終止索引，將自動取到列表末尾

>>> print(names[2:])
['cc', 'dd']

也可以使用負數(shù)索引，比如返回最后三個元素

>>> print(names[-3:])
['bb', 'cc', 'dd']

遍歷切片

>>> for name in names[1:3]:
...     print(name)
...
bb
cc

3.5 復制列表

可以使用切片來快速復制列表，不指定開始索引和結(jié)束索引。

>>> names
['aa', 'bb', 'cc', 'dd']
>>> names2 = names[:]
>>> names2
['aa', 'bb', 'cc', 'dd']

用切片復制出來的新列表，跟原來的列表是完全不同的列表，改變其實一個不會影響另一個列表。

>>> names.append('ee')
>>> names
['aa', 'bb', 'cc', 'dd', 'ee']
>>> names2
['aa', 'bb', 'cc', 'dd']

而如果簡單的通過賦值將 names 賦值給 names2，就不能得到兩個列表，實際上它們都指向了同一個列表。如果改變其中一個，另一個也將被改變。

>>> names
['aa', 'bb', 'cc', 'dd']
>>> names2 = names
>>> names2
['aa', 'bb', 'cc', 'dd']
>>> names.append('ee')
>>> names
['aa', 'bb', 'cc', 'dd', 'ee']
>>> names2
['aa', 'bb', 'cc', 'dd', 'ee']

3.6 元組

Python將不能修改的值稱為不可變的，而不可變的列表被稱為元組。

元組看起來猶如列表，但使用圓括號而不是方括號來標識。定義元組后，就可以使用索引來訪問其元素，就像訪問列表元素一樣。

>>> food = ('apple', 'orange')
>>> food[0]
'apple'
>>> food[1]
'orange'
>>> food[1] = 'banana'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

遍歷用法跟列表一致。

四、條件判斷

每條if語句的核心都是一個值為True或False的表達式，這種表達式被稱為條件測試。

• 檢查是否相等，用 ==

• 檢查是否不相等，用 !=

• 數(shù)字比較 >、 <、 >=、 <=

• 多個條件與 and

• 多個條件或 or

• 判斷列表是否包含某元素 in

  >>> names
  ['aa', 'bb', 'cc', 'dd', 'ee']
  >>> 'bb' in names
  True
  

• 判斷列表是否不包含某元素

  >>> names
  ['aa', 'bb', 'cc', 'dd', 'ee']
  >>> 'ff' not in names
  True
  

if 語句

簡單的 if-else

>>> a = 10
>>> if a > 10:
...     print('hello')
... else:
...     print('bye')
...
bye

if-elif-else

>>> if a<5:
...     print(a<5)
... elif 5<a<10:
...     print('5<a<10')
... else:
...     print('a>10')
...
a>10

五、字典

在Python中，字典是一系列鍵-值對。每個鍵都與一個值相關聯(lián)，你可以使用鍵來訪問與之相關聯(lián)的值。與鍵相關聯(lián)的值可以是數(shù)字、字符串、列表乃至字典。事實上，可將任何Python對象用作字典中的值。

5.1 字典的增刪改查

使用字典

在Python中，字典用放在花括號{}中的一系列鍵-值對表示。

>>> user = {'name':'bob', 'sex':'male', 'age':20}
>>> user
{'name': 'bob', 'sex': 'male', 'age': 20}

訪問字典中的值

要獲取與鍵相關聯(lián)的值，可依次指定字典名和放在方括號內(nèi)的鍵。

>>> user
{'name': 'bob', 'sex': 'male', 'age': 20}
>>> user['name']
'bob'
>>> user['age']
20

添加鍵值對

字典是一種動態(tài)結(jié)構(gòu)，可隨時在其中添加鍵—值對。

>>> user['city']='beijing'
>>> user
{'name': 'bob', 'sex': 'male', 'age': 20, 'city': 'beijing'}

修改字典中的值

要修改字典中的值，可依次指定字典名、用方括號括起的鍵以及與該鍵相關聯(lián)的新值。

>>> cat = {}
>>> cat['color'] = 'white'
>>> cat['age'] = 4
>>> cat
{'color': 'white', 'age': 4}
>>> cat['age'] = 6
>>> cat
{'color': 'white', 'age': 6}

刪除鍵值對

對于字典中不再需要的信息，可使用del語句將相應的鍵—值對徹底刪除。使用del語句時，必須指定字典名和要刪除的鍵。

>>> del cat['color']
>>> cat
{'age': 6}

5.2 遍歷字典

字典可用于以各種方式存儲信息，因此有多種遍歷字典的方式:可遍歷字典的所有鍵—值對、鍵或值。

遍歷所有鍵值對 items()

>>> cat
{'age': 6, 'color': 'white', 'city': 'beijing'}
>>> for k,v in cat.items():
...     print(k + '-' + str(v))
...
age-6
color-white
city-beijing

通過 for k,v in cat.items() 的方式遍歷所有的鍵值對，k 代表鍵，v 代表值。

注意：即便遍歷字典時，鍵—值對的返回順序也與存儲順序不同。Python不關心鍵—值對的存儲順序，而只跟蹤鍵和值之間的關聯(lián)關系。

遍歷所有鍵 keys()

如果不需要用值，可以用 keys() 遍歷出所有的鍵。

>>> cat
{'age': 6, 'color': 'white', 'city': 'beijing'}
>>> for k in cat.keys():
...     print(k.title())
...
Age
Color
City

上面的例子打印出了 cat 的所有鍵，用字符串的 title() 方法使每個單詞的首字母大寫。

遍歷字典時會默認遍歷所有的鍵，for k in cat.keys() 和 for k in cat 的效果一樣。

按順序遍歷所有鍵，可用 sorted() 排序，這讓Python列出字典中的所有鍵，并在遍歷前對這個列表進行排序。

>>> for k in sorted(cat.keys()):
...     print(k.title())
...
Age
City
Color

遍歷所有值 values()

>>> for value in cat.values():
...     print(str(value))
...
6
white
beijing

如果需要剔除重復項，可以使用 set()

>>> cat
{'age': 6, 'color': 'white', 'city': 'beijing', 'city2': 'beijing'}
>>> for value in cat.values():
...     print(str(value))
...
6
white
beijing
beijing
>>> for value in set(cat.values()):
...     print(str(value))
...
beijing
white
6

5.3 嵌套

可以在列表中嵌套字典、在字典中嵌套列表以及在字典中嵌套字典。這里就不演示了。

六、用戶輸入和while循環(huán)

6.1 用戶輸入

函數(shù)input()讓程序暫停運行，等待用戶輸入一些文本。獲取用戶輸入后，Python將其存儲在一個變量中，以方便你使用。

>>> msg = input('Please input your name: ')
Please input your name: solo
>>> msg
'solo'

如果你使用的是Python 2.7，應使用函數(shù)raw_input()來提示用戶輸入。這個函數(shù)與Python 3中的input()一樣，也將輸入解讀為字符串。

Python 2.7也包含函數(shù)input()，但它將用戶輸入解讀為Python代碼，并嘗試運行它們。如果你使用的是Python 2.7，請使用raw_input()而不是input()來獲取輸入。

如果想將輸入的內(nèi)容轉(zhuǎn)換為數(shù)字，可以用 int() 來轉(zhuǎn)換。

6.2 while 循環(huán)

for循環(huán)用于針對集合中的每個元素都一個代碼塊，而while循環(huán)不斷地運行，直到指定的條件不滿足為止。

>>> num = 1
>>> while num <= 5:
...     print(str(num))
...     num += 1
...
1
2
3
4
5

break

要立即退出while循環(huán)，不再運行循環(huán)中余下的代碼，也不管條件測試的結(jié)果如何，可使用break語句。break語句用于控制程序流程，可使用它來控制哪些代碼行將執(zhí)行，哪些代碼行不執(zhí)行，從而讓程序按你的要求執(zhí)行你要執(zhí)行的代碼。

continue

要返回到循環(huán)開頭，并根據(jù)條件測試結(jié)果決定是否繼續(xù)執(zhí)行循環(huán)，可使用continue語句，它不像 break 語句那樣不再執(zhí)行余下的代碼并退出整個循環(huán)。

七、函數(shù)

Python 用關鍵字 def 來定義函數(shù)，函數(shù)名以冒號 : 結(jié)尾，冒號之后的縮進里的內(nèi)容都是函數(shù)體。

>>> def greet():
...     print('Hello World!')
...
>>> greet()
Hello World!

7.1 函數(shù)參數(shù)

可以向函數(shù)傳遞參數(shù)。下面的例子向函數(shù) greet() 傳遞了個參數(shù) name。其中 name 是形參，solo 是實參。

>>> def greet(name):
...     print('Hello,' + name)
...
>>> greet('solo')
Hello,solo

向函數(shù)傳遞實參的方式很多，可使用位置實參，這要求實參的順序與形參的順序相同;也可使用關鍵字實參，其
中每個實參都由變量名和值組成;還可使用列表和字典。

位置實參

你調(diào)用函數(shù)時，Python必須將函數(shù)調(diào)用中的每個實參都關聯(lián)到函數(shù)定義中的一個形參。為此，最簡單的關聯(lián)方式是基于實參的順序。這種關聯(lián)方式被稱為位置實參。

>>> def student(name, age):
...     print('Hello, My name is ' + name + ', I am ' + str(age) + ' years old')
...
>>> student('solo', 18)
Hello, My name is solo, I am 18 years old

按照形參定義的順序傳遞的實參就稱為位置實參。

關鍵字實參

關鍵字實參是傳遞給函數(shù)的名稱—值對。關鍵字實參讓你無需考慮函數(shù)調(diào)用中的實參順序，還清楚地指出了函數(shù)調(diào)用中各個值的用途。

>>> student(age=18, name='solo')
Hello, My name is solo, I am 18 years old

接著位置實參中的例子，student(name, age) 方法第一個參數(shù)是 name，第二個參數(shù)是 age 。我們用關鍵字實參指明傳遞的是哪一個，即使順序?qū)憗y了得到的結(jié)果也不會亂。

默認值

編寫函數(shù)時，可給每個形參指定默認值。在調(diào)用函數(shù)中給形參提供了實參時，Python將使用指定的實參值;否則，將使用形參的默認值。因此，給形參指定默認值后，可在函數(shù)調(diào)用中省略相應的實參。使用默認值可簡化函數(shù)調(diào)用，還可清楚地指出函數(shù)的典型用法。

>>> def student(name, age=18):
...     print('Hello, My name is ' + name + ', I am ' + str(age) + ' years old')
...
>>> student('bob')
Hello, My name is bob, I am 18 years old
>>> student('nicole')
Hello, My name is nicole, I am 18 years old
>>> student('bob', 20)
Hello, My name is bob, I am 20 years old

如上，給 student() 函數(shù)定義的第二個參數(shù) age 設置了默認值 18，如果調(diào)用時只傳一個參數(shù)，無論傳的是什么 age 都是 18。當傳兩個參數(shù)時，傳遞的實參就會覆蓋掉默認值。

注意：使用默認值時，在形參列表中必須先列出沒有默認值的形參，再列出有默認值的實參。這讓Python依然能夠正確地解讀位置實參。

7.2 返回值

函數(shù)并非總是直接顯示輸出，相反，它可以處理一些數(shù)據(jù)，并返回一個或一組值。函數(shù)返回 的值被稱為返回值。在函數(shù)中，可使用return語句將值返回到調(diào)用函數(shù)的代碼行。返回值讓你能夠?qū)⒊绦虻拇蟛糠址敝毓ぷ饕频胶瘮?shù)中去完成，從而簡化主程序。

>>> def student(name):
...     return name
...
>>> name = student('solo')
>>> name
'solo'

返回字典

函數(shù)可返回任何類型的值，包括列表和字典等較復雜的數(shù)據(jù)結(jié)構(gòu)。例如，下面的函數(shù)接受姓名和年齡，并返回一個表示人的字典:

>>> def build_person(name,age):
...     person = {'name':name, 'age':age}
...     return person
...
>>> p = build_person('solo',18)
>>> p
{'name': 'solo', 'age': 18}

7.3 傳遞任意數(shù)量的實參

有時候，你預先不知道函數(shù)需要接受多少個實參，好在Python允許函數(shù)從調(diào)用語句中收集任意數(shù)量的實參。

>>> def person(*args):
...     print(args)
...
>>> person('name','age','address')
('name', 'age', 'address')

上面定義了一個函數(shù) person() ，只有一個形參 *args 。形參名 *args 中的星號讓 Python 創(chuàng)建一個名為 args 的空元組，并將收到的所有值都封裝到這個元組中。

結(jié)合使用位置實參和任意數(shù)量實參

如果要讓函數(shù)接受不同類型的實參，必須在函數(shù)定義中將接納任意數(shù)量實參的形參放在最后。Python 先匹配位置實參和關鍵字實參，再將余下的實參都收集到最后一個形參中。

>>> def person(city, *args):
...     print('city: ' + city + ', other args:')
...     for value in args:
...             print(value)
...
>>> person('beijing', 'name', 'age', 'tel')
city: beijing, other args:
name
age
tel

函數(shù) person() 有兩個形參，第一個 city 是普通的位置實參，第二個 *args 是可變參數(shù)。

使用任意數(shù)量的關鍵字實參

有時候，需要接受任意數(shù)量的實參，但預先不知道傳遞給函數(shù)的會是什么樣的信息。在這種情況下，可將函數(shù)編寫成能夠接受任意數(shù)量的鍵—值對——調(diào)用語句提供了多少就接受多少。一個這樣的示例是創(chuàng)建用戶簡介:你知道你將收到有關用戶的信息，但不確定會是什么樣的信息。

def build_profile(first, last, **user_info):
	profile = {}
	profile['first_name'] = first
	profile['last_name'] = last

	for key,value in user_info.items():
		profile[key] = value

	return profile

user = build_profile('steven', 'bob', city='beijing', age=18)

print(user)

執(zhí)行代碼，輸出結(jié)果是：

{'first_name': 'steven', 'last_name': 'bob', 'city': 'beijing', 'age': 18}

7.4 導入導出

可以將函數(shù)存儲在被稱為模塊的獨立文件中，再將模塊導入到主程序中。import語句允許在當前運行的程序文件中使用模塊中的代碼。

7.4.1 導入整個模塊

模塊是擴展名為.py的文件，包含要導入到程序中的代碼。

def eat(food):
    print('I am cat, I eat ' + food)

import cat

cat.eat('fish')

控制臺輸出

I am cat, I eat fish

7.4.2 導入特定的函數(shù)

你還可以導入模塊中的特定函數(shù)，這種導入方法的語法如下:

from module_name import function_name 

通過用逗號分隔函數(shù)名，可根據(jù)需要從模塊中導入任意數(shù)量的函數(shù):

from module_name import function_0, function_1, function_2 

上面的例子只導入 中的 eat() 方法

from cat import eat

eat('fish')

得到相同的結(jié)果。

7.4.3 使用 as 給函數(shù)指定別名

如果要導入的函數(shù)的名稱可能與程序中現(xiàn)有的名稱沖突，或者函數(shù)的名稱太長，可指定簡短而獨一無二的別名——函數(shù)的另一個名稱，類似于外號。要給函數(shù)指定這種特殊外號，需要在導入它時這樣做。

from cat import eat as cat_eat

cat_eat('fish')

將 中的 eat() 方法導入并指定了別名 cat_eat，使用時可以直接用別名使用。

7.4.4 使用 as 給模塊指定別名

你還可以給模塊指定別名。通過給模塊指定簡短的別名，讓你 能夠更輕松地調(diào)用模塊中的函數(shù)。

通用語法：import module_name as mn

import cat as c

c.eat('fish')

7.4.5 導入模塊中的所有函數(shù)

使用星號(*)運算符可讓Python導入模塊中的所有函數(shù):

def eat(food):
    print('I am cat, I eat ' + food)


def run():
    print('cat run')

from cat import *

eat('fish')
run()

輸出結(jié)果

I am cat, I eat fish
cat run

由于導入 了每個函數(shù)，可通過名稱來調(diào)用每個函數(shù)，而無需使用句點表示法。然而，使用并非自己編寫的 大型模塊時，最好不要采用這種導入方法:如果模塊中有函數(shù)的名稱與你的項目中使用的名稱相 同，可能導致意想不到的結(jié)果: Python 可能遇到多個名稱相同的函數(shù)或變量，進而覆蓋函數(shù)，而 不是分別導入所有的函數(shù)。

最佳的做法是，要么只導入你需要使用的函數(shù)，要么導入整個模塊并使用句點表示法。這能 讓代碼更清晰，更容易閱讀和理解。

7.5 函數(shù)編寫指南

• 應給函數(shù)指定描述性名稱

• 函數(shù)名應只包含小寫字母和下劃線

• 每個函數(shù)都應包含簡要地闡述其功能的注釋，該注釋應緊跟在函數(shù)定義后面，并采用文檔字符串格式。

• 給形參指定默認值時，等號兩邊不要有空格:

  def function_name(parameter_0, parameter_1='default value')
  

  對于函數(shù)調(diào)用中的關鍵字實參，也應遵循這種約定:

  function_name(value_0, parameter_1='value')
  

• 如果程序或模塊包含多個函數(shù)，可使用兩個空行將相鄰的函數(shù)分開，這樣將更容易知道前一個函數(shù)在什么地方結(jié)束，下一個函數(shù)從什么地方開始。

• 所有的import語句都應放在文件開頭，唯一例外的情形是，在文件開頭使用了注釋來描述整個程序。

八、類

8.1 創(chuàng)建和使用類

class Cat():
    def __init__(self, name, color):
        self.name = name
        self.color = color

    def eat(self):
        print('cat ' + self.name + ' color ' + self.color + ', now eat')

    def run(self):
        print('cat ' + self.name + ' color ' + self.color + ', now run')


my_cat = Cat('Spring', 'white')
print(my_cat.name)
print(my_cat.color)
my_cat.eat()
my_cat.run()

上面創(chuàng)建了類 Cat ，并實例化了 my_cat，然后調(diào)用了類的方法 eat() 和 run()。輸出結(jié)果：

Spring
white
cat Spring color white, now eat
cat Spring color white, now run

類中的函數(shù)稱為方法。__init__() 是函數(shù)的構(gòu)造方法，每檔創(chuàng)建新實例時 Python 都會自動運行它。注意構(gòu)造方法名字必須是這個，是規(guī)定好的。

上面的例子中__init__(self, name, color) 有三個形參，第一個形參 self 必不可少，還必須位于其他形參的前面。其他的形參可以根據(jù)需要調(diào)整。self 是一個指向?qū)嵗旧淼囊茫寣嵗軌蛟L問類中的屬性和方法。

還可以通過實例直接訪問屬性：my_cat.name。但在其他語言中并不建議這樣做。

在Python 2.7中創(chuàng)建類

在Python 2.7中創(chuàng)建類時，需要做細微的修改——在括號內(nèi)包含單詞object:

class ClassName(object):

8.2 類的屬性

8.2.1 給屬性設置默認值

類中的每個屬性都必須有初始值，哪怕這個值是0或空字符串。在有些情況下，如設置默認值時，在方法__init__() 內(nèi)指定這種初始值是可行的;如果你對某個屬性這樣做了，就無需包含為它提供初始值的形參。

重新定義 Cat ，在構(gòu)造方法中給屬性 age 設置默認值。

class Cat():
    def __init__(self, name, color):
        self.name = name
        self.color = color
        self.age = 3

    def eat(self):
        print('cat ' + self.name + ' color ' + self.color + ', now eat')

    def run(self):
        print('cat ' + self.name + ' color ' + self.color + ', now run')

    def print_age(self):
        print('cat`s age is ' + str(self.age))

8.2.2 修改屬性的值

可以以三種不同的方式修改屬性的值：直接通過實例進行修改，通過方法進行設置。

1. 直接修改屬性的值

要修改屬性的值，最簡單的方式是通過實例直接訪問它。

class Cat():
    def __init__(self, name, color):
        self.name = name
        self.color = color
        self.age = 3

    def eat(self):
        print('cat ' + self.name + ' color ' + self.color + ', now eat')

    def run(self):
        print('cat ' + self.name + ' color ' + self.color + ', now run')

    def print_age(self):
        print('cat`s age is ' + str(self.age))


my_cat = Cat('Spring', 'white')

my_cat.print_age()
my_cat.age = 4
my_cat.print_age()

輸出結(jié)果為

cat`s age is 3
cat`s age is 4

上例直接通過 my_cat.age = 4 修改了 age 屬性的值。

2. 通過方法修改屬性的值

再來更新代碼，加入 update_age() 方法來修改 age 的屬性。

class Cat():
    def __init__(self, name, color):
        self.name = name
        self.color = color
        self.age = 3

    def eat(self):
        print('cat ' + self.name + ' color ' + self.color + ', now eat')

    def run(self):
        print('cat ' + self.name + ' color ' + self.color + ', now run')

    def print_age(self):
        print('cat`s age is ' + str(self.age))

    def update_age(self, age):
        self.age = age


my_cat = Cat('Spring', 'white')
my_cat.print_age()
my_cat.update_age(10)
my_cat.print_age()

運行代碼輸出：

cat`s age is 3
cat`s age is 10

8.3 繼承

一個類繼承另一個類時，它將自動獲得另一個類的所有屬性和方法;原有的類稱為父類，而新類稱為子類。子類繼承了其父類的所有屬性和方法，同時還可以定義自己的屬性和方法。

class Animal():
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def run(self):
        print('Animal ' + self.name + ' run')


class Cat(Animal):
    def __init__(self, name, age):
        super().__init__(name, age)


cat = Cat('Tony', 2)
cat.run()

運行程序，輸出：

Animal Tony run

先定義了類 Animal，又定義了 Cat 繼承自 Animal。 Animal稱為父類， Cat 稱為子類。通過輸出可以驗證，子類繼承了父類的方法。

在子類的構(gòu)造方法中要先實現(xiàn)父類的構(gòu)造方法：super().__init__(name, age)。

還可以給子類定義自己的方法，或者重寫父類的方法。

class Animal():
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def run(self):
        print('Animal ' + self.name + ' run')


class Cat(Animal):
    def __init__(self, name, age):
        super().__init__(name, age)

    def play(self):
        print('Cat ' + self.name + ' play')

    def run(self):
        print('Cat ' + self.name + ' run')


cat = Cat('Tony', 2)
cat.run()
cat.play()

我們來修改下程序，Animal 類不變，Cat 類還是繼承了 Animal ，但定義了自己的方法 play() 并重寫了父類方法 run() 。運行程序，得到輸出：

Cat Tony run
Cat Tony play

Python2.7 中的繼承

在Python 2.7中，繼承語法稍有不同，ElectricCar類的定義類似于下面這樣:

class Car(object):
	def __init__(self, make, model, year):
    	--snip--
    
class ElectricCar(Car):
	def __init__(self, make, model, year):
		super(ElectricCar, self).__init__(make, model, year)
		--snip--

函數(shù)super()需要兩個實參:子類名和對象self。為幫助Python將父類和子類關聯(lián)起來，這些實參必不可少。另外，在Python 2.7中使用繼承時，務必在定義父類時在括號內(nèi)指定object。

8.4 導入類

當一個文件過長時，可以將其中一部分代碼抽離出去，然后導入到主文件中。

導入方式有多種：

• 導入單個類

  假如 car.py 里定義了類 Car

  from car import Car
  

• 從一個模塊中導入多個類

  假如 car.py 包含了三個類 Car ， Battery 和 ElectricCar 。

  只導入一個類：

  from car import ElectricCar
  

  導入多個類，中間用逗號隔開：

  from car import Car, ElectricCar
  

• 導入整個模塊

  還可以導入整個模塊，再使用句點表示法訪問需要的類。這種導入方法很簡單，代碼也易于閱讀。由于創(chuàng)建類實例的代碼都包含模塊名，因此不會與當前文件使用的任何名稱發(fā)生沖突。

  import car
  my_car = car.Car()
  

• 導入模塊中的所有類

  要導入模塊中的每個類，可使用下面的語法:

  from module_name import *
  

  不推薦使用這種導入方式，其原因有二。

  首先，如果只要看一下文件開頭的import語句，就 能清楚地知道程序使用了哪些類，將大有裨益;但這種導入方式?jīng)]有明確地指出你使用了模塊中 的哪些類。這種導入方式還可能引發(fā)名稱方面的困惑。如果你不小心導入了一個與程序文件中其 他東西同名的類，將引發(fā)難以診斷的錯誤。這里之所以介紹這種導入方式，是因為雖然不推薦使 用這種方式，但你可能會在別人編寫的代碼中見到它。

  需要從一個模塊中導入很多類時，最好導入整個模塊，并使用module_name.class_name語法 來訪問類。這樣做時，雖然文件開頭并沒有列出用到的所有類，但你清楚地知道在程序的哪些地 方使用了導入的模塊;你還避免了導入模塊中的每個類可能引發(fā)的名稱沖突。

九、文件和異常

9.1 從文件中讀取數(shù)據(jù)

要使用文本文件中的信息，首先需要將信息讀取到內(nèi)存中。為此，你可以一次性讀取文件的全部內(nèi)容，也可以以每次一行的方式逐步讀取。

9.1.1 讀取整個文件

with open('test.txt') as file_obj:
    contents = file_obj.read()
    print(contents)

open() 用于打開一個文件，參數(shù)為文件的路徑。

關鍵字 with 在不再需要訪問文件后將其關閉。有了 with 你只管打開文件，并在需要時使用它，Python自會
在合適的時候自動將其關閉。

相比于原始文件，該輸出唯一不同的地方是末尾多了一個空行。為何會多出這個空行呢?因為 read() 到達文件末尾時返回一個空字符串，而將這個空字符串顯示出來時就是一個空行。要刪除多出來的空行，可在print語句中使用 rstrip()。

文件路徑可以是相對路徑，也可以是絕對路徑。

9.1.2 逐行讀取

with open('test.txt') as file_obj:
    for line in file_obj:
        print(line.rstrip())

要以每次一行的方式檢查文件，可對文件對象使用for循環(huán)。

9.2 寫入文件

with open('test.txt', 'w') as file_obj:
    file_obj.write("I love python")

在這個示例中，調(diào)用open()時提供了兩個實參，第一個實參也是要打開的文件的名稱；第二個實參(‘w’)告訴Python，我們要以寫入模式打開這個文件。

可選模式：

• r ：只讀。
• w : 只寫。如果文件不存在則創(chuàng)建，如果文件存在則先清空，再寫入。
• a ：附加模式，寫入的內(nèi)容追加到原始文件后面。如果文件不存在則創(chuàng)建。
• r+ ：可讀可寫。

如果你省略了模式實參，Python將以默認的只讀模式打開文件。

9.3 異常

異常是使用try-except代碼塊處理的。try-except代碼塊讓Python執(zhí)行指定的操作，同時告訴Python發(fā)生異常時怎么辦。

try:
    print(5/0)
except ZeroDivisionError:
    print("You can't divide by zero!")

else 代碼塊

try:
    print(5/0)
except ZeroDivisionError:
    print("You can't divide by zero!")
else:
	print("no exception")

如果 try 中的代碼運行成功，沒有出現(xiàn)異常，則執(zhí)行 else 代碼塊中的代碼。

9.4 用 json 存儲數(shù)據(jù)

Python 中使用 json.dump() 和 json.load() 來存儲和讀取 json 文件。

import json

userInfo = {'username': 'jack', 'age': 18}

with open('test.txt', 'w') as obj:
    json.dump(userInfo, obj)


with open('test.txt') as obj:
    content = json.load(obj)
    print(content)

上例中用 json.dump() 把數(shù)據(jù)存入到了 test.txt 中，又用 json.load() 把數(shù)據(jù)從文件中取出并打印。

注意使用前先導入 json 模塊。

十、單元測試

先定義一個拼接名字的函數(shù) name_function.py

def get_formatted_name(first, last):
    full_name = first + ' ' + last
    return full_name.title()

再寫測試類來測試這個函數(shù)

import unittest
from name_function import get_formatted_name


class NamesTestCase(unittest.TestCase):

    def test_name_function(self):
        full_name = get_formatted_name('david', 'alex')
        self.assertEqual(full_name, 'David Alex')


unittest.main()

測試類要繼承 unittest.TestCase ，通過 self.assertEqual 斷言是否得到的結(jié)果和預期相等。

常見的斷言方法

setUp() 方法

如果你在TestCase類中包含了方法 setUp() ，Python將先運行它，再運行各個以test_打頭的方法。

通常用于做一些初始化操作。

全棧全平臺開源項目 CodeRiver

CodeRiver 是一個免費的項目協(xié)作平臺，愿景是打通 IT 產(chǎn)業(yè)上下游，無論你是產(chǎn)品經(jīng)理、設計師、程序員或是測試，還是其他行業(yè)人員，只要有好的創(chuàng)意、想法，都可以來 CodeRiver 免費發(fā)布項目，召集志同道合的隊友一起將夢想變?yōu)楝F(xiàn)實！

CodeRiver 本身還是一個大型開源項目，致力于打造全棧全平臺企業(yè)級精品開源項目。涵蓋了 React、Vue、Angular、小程序、ReactNative、Android、Flutter、Java、Node 等幾乎所有主流技術(shù)棧，主打代碼質(zhì)量。

目前已經(jīng)有近 100 名優(yōu)秀開發(fā)者參與，github 上的 star 數(shù)量將近 1000 個。每個技術(shù)棧都有多位經(jīng)驗豐富的大佬坐鎮(zhèn)，更有兩位架構(gòu)師指導項目架構(gòu)。無論你想學什么語言處于什么技術(shù)水平，相信都能在這里學有所獲。

通過 高質(zhì)量源碼 + 博客 + 視頻，幫助每一位開發(fā)者快速成長。

項目地址：https://github.com/cachecats/coderiver

您的鼓勵是我們前行最大的動力，歡迎點贊，歡迎送小星星? ~