精通Python自動化腳本-運維人員寶典完整目錄：

第一章 Python腳本概述
第二章 Python腳本調(diào)試和性能測試
第三章 單元測試-單元測試框架的介紹
第四章 自動化常規(guī)運維活動
第五章 文件、目錄和數(shù)據(jù)處理
第六章 文件存檔、加密和解密
第七章 文本處理和正則表達式
第八章 文檔和報告
第九章 操作各類文件
第十章 網(wǎng)絡基礎 - Socket編程
第十一章 使用Python腳本處理郵件
第十二章 使用Telnet和SSH遠程監(jiān)控主機
第十三章 創(chuàng)建圖形化用戶界面
第十四章 處理Apache和其它的日志文件
第十五章 SOAP和REST API通訊
第十六章 網(wǎng)絡抓取 - 從網(wǎng)站上提取有用的信息
第十七章 數(shù)據(jù)收集及報表
第十八章 MySQL和SQLite數(shù)據(jù)庫管理

技術要求

在學習本書前，你應該了解一些 Python 編程的基礎知識，比如基礎語法、變量類型、元組數(shù)據(jù)類型、列表字典、函數(shù)、字符串和方法。在python.org/downloads/上有3.7.2和2.7.15兩個版本可供下載。本書中我們將使用3.7這一版本來作為代表示例和包的安裝。

譯者注：預計 Python 3.7還會發(fā)展較長時間，而 Python2則長期止步于 Python2.7了，但小版本號都在不斷變化

本章的示例和源代碼可通過 GitHub 倉庫進行獲取。

為什么選擇Python？

Python有非常豐富的開源庫用于數(shù)據(jù)分析工具、網(wǎng)站框架、測試等等。Python是一種可在不同平臺上使用的編程語言（Windows, Mac, Linux和Linux嵌入式硬件，如樹莓派Raspberry Pi）。它也用于開發(fā)桌面應用和網(wǎng)頁應用。

開發(fā)人員如果使用Python可以編寫更少行數(shù)的代碼。原型制作非?？焖伲驗樵诮忉屍飨到y(tǒng)中運行。Python可被看成是面向?qū)ο?、面向過程或函數(shù)式編程。

Python可以完成各種任務，比如創(chuàng)建網(wǎng)頁應用。它和軟件一起使用來創(chuàng)建工作流，它連接數(shù)據(jù)庫系統(tǒng)、處理文件、處理大數(shù)據(jù)并執(zhí)行復雜數(shù)學運算。

Python語法與其它編程語言的對比

Python編寫的代碼可讀性很強，因為它和英語本身非常相近。要完成一個命令，Python使用新的一行來完成。

Python有一個很棒的特性：縮進。使用縮進我們可以定義決策語句作用域，for循環(huán)和while循環(huán)、函數(shù)和類。

Python安裝

這一部分中我們將學習在不同平臺上Python的安裝，比如Linux和Windows。

Linux平臺上的安裝

大部分Linux發(fā)行版本都默認安裝了Python 2。有些則直接包含了Python 3。

譯者注：目前大部分 CentOS 中默認安裝的是 Python 2，而 Ubuntu 中則內(nèi)置了 Python 3

要在Debian系Linux系統(tǒng)中安裝Python 3，在命令行終端中可運行如下命令：

sudo apt install python3

要在CentOS 系統(tǒng)中安裝Python 3，在命令行終端中可運行如下命令：

sudo yum install python3

如無法使用以上命令安裝Python，請從官方網(wǎng)站上下載Python并按照指示進行安裝。

譯者注：本博客有一篇如何安裝Python3.7也可供參考

Windows平臺上的安裝

在Microsoft Windows上安裝Python，我們需要從python.org上下載可執(zhí)行安裝包并執(zhí)行安裝。從官網(wǎng)下載頁面下載python.exe文件并選擇想要在電腦了安裝的Python版本。然后雙擊所下載的 exe 文件來安裝Python。有安裝引導頁面中，有一個Add Python to the path的復選框，勾選并按照提示一步一步的安裝Python 3。

Pip安裝以及使用pip安裝Python包

在 Linux 中安裝pip命令如下：

sudo apt install python-pip # 安裝 Python 2的 pip
sudo apt install python3-pip # 安裝 Python 3的 pip

譯者注：以上為 Ubuntu 中的命令，原書作者使用的均為 Ubuntu，CentOS 中將 apt 修改為 yum 即可

Windows中, 使用如下命令安裝：

python -m pip install pip

Mac上的安裝

要安裝 Python 3，我們要在系統(tǒng)中安裝brew。運行如下命令來在系統(tǒng)中安裝brew：

/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

通過運行以上命令，brew就安裝好了?，F(xiàn)在使用brew來安裝 Python 3：

brew install python3

安裝Jupyter notebook

要安裝Jupyter Notebook，先下載Anaconda。

安裝所下載的Anaconda版本，按照向?qū)е械闹甘具M行安裝即可。

使用pip安裝Jupyter：

pip install jupyter

在 Linux 中，pip install jupyter安裝的是Python 2 的Jupyter。如果想要安裝Python 3 的Jupyter，運行如下命令：

pip3 install jupyter

安裝和使用虛擬環(huán)境

下面我們就來看如何安裝虛擬環(huán)境以及如何進行激活。

在Linux中安裝虛擬環(huán)境，執(zhí)行步驟如下：

1、首先檢查是否安裝了pip。我們來安裝Python 3的pip

sudo apt install python3-pip

2、使用pip3安裝虛擬環(huán)境：

sudo pip3 install virtualenv

3、現(xiàn)在我們來創(chuàng)建虛擬環(huán)境。你可以選擇任意名稱，這里我們使用pythonenv：

virtualenv pythonenv

4、激活虛擬環(huán)境：

source pythonenv/bin/activate

5、在完成操作之后，還可通過以下命令來關閉virtualenv：

deactivate

在Windows中， 運行pip install virtualenv命令來安裝虛擬環(huán)境。virtualenv的安裝步驟與Linux相同。

譯者注：在安裝了virtualenv之后，還可安裝 Virtualenv Wrapper來更方便管理虛擬環(huán)境，關于環(huán)境搭建還可參見本博客Django環(huán)境搭建及開發(fā)

安裝Installing Geany和PyCharm

通過https://www.geany.org/download/releases下載Geany并下載所需的二進行文件。根據(jù)指示來進行安裝。

通過https://www.jetbrains.com/pycharm/download/下載PyCharm并根據(jù)指示來進行安裝。

Python 解釋器

Python是一種解釋性語言。有一個稱為Python解釋器或Python shell的交互式終端。這個shell可供我們無需創(chuàng)建腳本來逐行執(zhí)行程序。

我們可以在這個Python交互式終端中訪問Python的內(nèi)置函數(shù)和庫、安裝模塊和命令執(zhí)行歷史。這個終端為我們提供了研究Python的機會。你可以將準備好的代碼拷貝到腳本中。

Python和Bash腳本的區(qū)別

這一部分中，我們將學習Python和Bash腳本的區(qū)別。它們的區(qū)別如下：

• Python是一種腳本語言，而Bash是一種用于進入和執(zhí)行命令的shell
• 使用Python更易于處理更大的程序
• Python中大部的事通過導入模塊來使用一行代碼調(diào)用函數(shù)

開啟交互終端

我們可以在已安裝了Python的電腦上訪問Python交互終端。運行如下命令來開啟Python交互終端：

$ python

譯者注：在 Linux 中#號提示符為 root 用戶，其它用戶為$

以上命令將啟動默認的Python交互終端。

Linux中如查在終端中寫入 python，開啟的是python2.7的終端。如果你想要啟動python3的終端，則在終端中輸入python3并按下 Enter 鍵。

在Windows中，我們可以在Command命令行中輸入 python，就會在終端中啟動所下載的Python版本。

使用Python交互終端編寫腳本

Python交互終端的起始提示符為>>>。在該終端中可輸入Python命令，在>>>之后進行編寫。如以下截圖所示：

Python 3命令行

現(xiàn)在，我們來看如何為變量賦值，示例如下：

>>> name = 'John'

這時我們?yōu)閚ame變量賦了一個字符串值John。按下Enter進入了一個以>>>提示符開頭的新行：

>>> name = 'John'
>>>

現(xiàn)在，我們來看一個為變量賦值的示例并執(zhí)行數(shù)學運算來獲取值：

>>> num1 = 5000
>>> num2 = 3500
>>> num3 = num1 + num2
>>> print(num3)
8500
>>> num4 = num3 - 2575
>>> print(num4)
5925
>>>

這里我們對不同的變量進行賦值，對兩個變量進行相加，并將和存儲在了第三個變量中，還在終端(Terminal)中打印出了和。然后，我們對結果變量進行了求減運算，將輸入存到了第四個變量中。接著我們將差在終端中進行了打印。這告訴我們可以使用 Python 解釋器作為計算器來進行使用。

>>> 509 / 22
23.136363636363637
>>>

以上，我們執(zhí)行了除法運算。509除以22并得到了商23.136363636363637。

多行模式

在Python解釋器中編寫多行代碼時（比如 if 語句、 for循環(huán)、while 循環(huán)和函數(shù)），解釋器會使用三個點(...) 作為二級提示符來延續(xù)代碼行。要退出這些行，我們需要連續(xù)按下兩次 Enter 鍵。我們來看看如下的示例：

>>> val1 = 2500
>>> val2 = 2400
>>> if val1 > val2:
...     print("val1大于val2")
... else:
...     print("val2大于val1")
...
val1大于val2
>>>

本例中，我們對兩個變量val1和val2進行了整數(shù)值的賦值，并檢查val1是否大于val2。上例中val1大于val2，因此 if 代碼塊中的語句執(zhí)行了打印。注意 if 和 else 代碼塊中的語句需要進行縮進。如果不使用縮進，就會得到如下報錯：

>>> if val1 > val2:
... print("val1大于val2")
  File "<stdin>", line 2
    print("val1大于val2")
        ^
IndentationError: expected an indented block

通過Python解釋器導入模塊

如果你導入任何模塊，Python解釋器會檢查該模塊是否存在。我們可通過 import 語句來進行實現(xiàn)。如果該模塊存在，在按下 Enter 鍵之后就可以看到>>> 前置提示符。這表示執(zhí)行成功。如果該模塊不存在，則會在Python解釋器中顯示報錯。

>>> import time
>>>

在導入time模塊之后，我們獲得了>>> 前置提示符，這表示該模塊存在并且這條命令成功執(zhí)行了：

<pre class="lang:default decode:true">>>> import matplotlib</pre>

如果模塊不存在，就會返回Traceback的報錯：

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ImportError: No module named 'matplotlib'

這里matplotlib不可用，因此給出了報錯：ImportError: No module named 'matplotlib'。

要解決這一報錯，我們需要安裝matplotlib（譯者注：pip3 install matplotlib）然后再次導入matplotlib。在安裝matplotlib之后，就能夠?qū)脒@一模塊了，如下：

>>> import matplotlib
>>>

退出Python終端

在Python終端有兩種方式可以退出：

• 快捷鍵: Ctrl + D
• 使用quit()或exit()函數(shù)

快捷鍵

使用快捷鍵Ctrl + D將會得到如下代碼：

>>> val1 = 5000
>>> val2 = 2500
>>>
>>> val3 = val1 - val2
>>> print (val3)
2500
>>>
vagrant@ubuntu-xenial:~$

使用quit()或exit() 函數(shù)

使用quit()可退出Python交互終端，會回到原來的命令終端：

>>> Lion = 'Simba'
>>> quit()
vagrant@ubuntu-xenial:~$

縮進和制表符Tab

在Python中編寫代碼塊必須使用縮進?？s進有助于編寫函數(shù)、決策語句、循環(huán)語句和類。這讓Python程序的讀取更為容易。

我們使用縮進來表示Python程序的代碼塊。對代碼塊的縮進，可以使用空格或制表符（tab）。參見如下示例：

if val1 > val2:
    print ("val1大于val2")
print("這部分代碼沒有進行縮進")

在上例中，我們對print語句進行了縮進，因為它位于 if 代碼塊中。第二個print語句不在 if 代碼塊中，所以沒有對其進行縮進。

變量

類似一些其它編程語言，Python 中無需事先聲明變量。Python 中可以想一個任意名稱來作為變量名并進行賦值（譯者注：僅能使用字母、數(shù)字和下劃線且不能以數(shù)學開頭）?？梢栽谖覀兊某绦蛑惺褂迷撟兞?。因此，Python 中我們可以在任何需使用的時候聲明變量。

Python 中變量的值以及類型都可以在程序的執(zhí)行過程中進行修改。以下代碼中我們對變量賦值100：

>>> n = 100 # 這里我們對變量 n 賦值100，并在下面對n 的值加1
>>> n = n + 1
>>> print(n)
101
>>>

以下為在執(zhí)行過程中變量類型可進行改變的示例：

>>> a = 50 # 數(shù)據(jù)類型被隱式地設置為整型
>>> a = 50 + 9.50 # 數(shù)據(jù)類型被修改為浮點型
>>> a = "Seventy" # 現(xiàn)在變成了字符串類型

Python處理不同數(shù)據(jù)類型的展現(xiàn)，也即不同類型的值會存儲在不同的內(nèi)存空間中。變量是我們用于賦值的名稱：

>>> msg = 'And now for something completely different'
>>> a = 20
>>> pi = 3.1415926535897932

上例中進行了三次賦值。第一次將一個字符串賦值為名為msg的變量。第二次將一個整型賦值為名為a的變量，最后一次是一個圓周率pi值的賦值。

變量的類型為它所引用的值的類型，查看以下代碼：

>>> type(msg)
<class 'str'>
>>> type(a)
<class 'int'>
>>> type(pi)
<class 'float'>

創(chuàng)建變量和賦值

在Python中，變量無需顯式的進行聲明來保留內(nèi)存空間。在對變量進行賦值即會自動完成聲明。Python中單個等號=用于為變量賦值。

思考如下示例的執(zhí)行：

#!/usr/bin/python3
name = 'John'
age = 25
address = 'USA'
percentage = 85.5
print(name)
print(age)
print(address)
print(percentage)

輸出如下：
John
25
USA
85.5

在上例中，我們將John賦值給變量name、25賦值給變量age、USA賦值給變量address以及將85.5賦值給變量percentage。

我們無需像在其它編程語言中那樣事先聲明變量。因此，查看值的解釋器可獲得變量的類型。在前例中，name和address是字符串類型，age是整型，percentage是浮點類型。

使用同一值進行多個變量的賦值可以這樣做：

x = y = z = 1

上例中我們創(chuàng)建了三個變量并使用整數(shù)1為它們賦值，會為這三個變量分配同一個內(nèi)存地址。

在Python中，我們還可以在同一行中對多個變量賦多個值：

x, y, z = 10, 'John', 80

這里我們聲明一個字符串變量y，將John賦值給它，以及兩個整型變量x和z，分別用10和80為它們賦值。

數(shù)值

Python解釋器也可發(fā)揮計算器的作用。只需輸入表達式，它就會返回值。括號( )用于進行分組，如下例如所示：

>>> 5 + 5
10
>>> 100 - 5*5
75
>>> (100 - 5*5) / 15
5.0
>>> 8 / 5
1.6

整型數(shù)值是int類型，小數(shù)部分是float類型。

??在Python中，除法(/) 運算符總是返回浮點值。向下取整運算符(//)獲取的是整型結果。%運算符用于計算余數(shù)。

思考如下示例：

>>> 14/3
4.666666666666667
>>> 14//3
4
>>> 14%3
2
>>> 4*3+2
14

計算冪值（指數(shù)運算），Python使用**運算符，如下例所示：

>>> 8**3
512
>>> 5**7
78125

等號(=)用于對變量賦值：

>>> m = 50
>>> n = 8 * 8
>>> m * n
3200

如果變量不存在，而我們還是使用該變量，那么解釋器會顯示錯誤：

>>> k
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'k' is not defined
>>>

如果運算符連接不同類型的操作數(shù)，那么得到的值將會是浮點數(shù)：

>>> 5 * 4.75 - 1
22.75

在Python交互終端中，_包含上一次打印過的表達式值，如下例所示：

>>> a = 18.5 / 100
>>> b = 150.50
>>> a * b
27.8425
>>> b + _
178.3425
>>> round(_, 2)
178.34

數(shù)值數(shù)據(jù)類型存儲數(shù)字，這是一種不可變的數(shù)據(jù)類型。如果進行改變，Python會為修改的數(shù)據(jù)類型分別一個新的對象。

我們可以通過賦值來創(chuàng)建數(shù)值對象，示例如下：

>>> num1 = 50
>>> num2 = 25

del語句用于刪除單個或多個變量。參考如下示例：

>>> num = num_a = num_b = 1
>>> del num
>>> del num_a, num_b

數(shù)值類型轉(zhuǎn)換

在一些情況下，我們需要顯式地將數(shù)字從一個類型轉(zhuǎn)換為另一種類型來滿足一些要求。Python在一個表達式中內(nèi)部實現(xiàn)。

• 輸入int(a)來將a轉(zhuǎn)換為整型
• 輸入float(a)來將a轉(zhuǎn)換為浮點數(shù)
• 輸入complex(a)來將a轉(zhuǎn)換復數(shù)，實部為a，虛部為0
• 輸入complex(a, b)來將a和 b轉(zhuǎn)換為實部為a，虛部為b 的復數(shù)。a和 b為數(shù)字表達式

字符串

和數(shù)值類型，字符串也是Python中一種數(shù)據(jù)結構。Python可以操作字符串。字符串可通過如下方式表示：

• 包含在單引號('...')中
• 包含在雙引號("...")中

參見如下示例：

>>> 'Hello Python'
'Hello Python'
>>> "Hello Python"
'Hello Python'

字符串是一組字符。我們可以像下面這樣一次訪問一個字符：

>>> city = 'delhi'
>>> letter = city[1]
>>> letter = city[-3]

在第二個語句中，我們從city中選擇數(shù)字為1的字符并將其賦值給letter。方括號中的數(shù)字為索引。索引表示要訪問的字符，它從0開始。因此在前例中執(zhí)行在賦值后輸入 letter，將得到如下輸出：

city    d  e  l  h  i 
索引  0  1  2  3  4
    -5 -4 -3 -2 -1

輸出：
e
l

字符串拼接(+)和重復(*)

下一步我們來進行字符串的拼接和重復。參照如下代碼：

>>> 3 * 'hi' + 'hello'
'hihihihello'

上例中，我們進行字符串拼接和重復。3 * 'hi'表示打印hi三次，使用+符號，我們在hi之后連接了字符串hello。

我們可以通過把字符串連續(xù)放在一起自動拼接兩個字符串。這兩個字符串必須包含在引號之間，如下所示：

>>> 'he' 'llo'
'hello'

這一特性在字符串很長又想要分開輸入時非常有用，示例如下：

>>> str = ('Several strings'
... ' joining them together.')
>>> str
'Several strings joining them together.'

字符串切片

字符串支持切片(slice)操作，這表示從字符串獲取指定范圍的字符。我來看看下面的例子。注意起始的索引值是包含在內(nèi)的，而結束值則排除在外。

假設字符串為str = "Programming"：

>>> str[0:2]
'Pr'
>>> str[2:5]
'ogr'

默認省略不寫的第一個索引為0（省略第二個索引默認獲取第一個索引到最后的所有字符），如下例所示：

>>> str = "Python"
>>> str[:2] + str[2:]
'Python'
>>> str[:4] + str[4:]
'Python'
>>> str[:2]
'Py'
>>> str[4:]
'on'
>>> str[-2:]
'on'

訪問字符串中的值

我們可以通過方括號使用切片來訪問字符串中的字符。我們還可以訪問字符串中指定范圍內(nèi)的字符。參照如下示例：

#!/usr/bin/python3
str1 = 'Hello Python!'
str2 = "Object Oriented Programming"
print("str1[0]: ", str1[0])
print("str2[1:5]: ", str2[1:5])

輸出：
str1[0]:  H
str2[1:5]:  bjec

更新字符串

我們可以對一個指定索引重新賦新值來更新字符串。參照如下示例：

#!/usr/bin/python3
str1 = 'Hello Python!'
print("Updated String: - ", str1[:6] + 'John')

輸出：
Updated String: -  Hello John

轉(zhuǎn)義字符

Python 支持不可打印的轉(zhuǎn)義字符（escape character），可通反斜線標記來進行展示。轉(zhuǎn)義字符在單引號和雙引號字符串中均可進行解釋：

| 標記 | 十六進制字符 | 描述 |
| a | 0x07 | 響鈴或警告 |
| b | 0x08 | 退格（Backspace） |
| cx | | Control-x |
| n | 0x0a | 新起一行 |
| C-x | | Control-x |
| e | 0x1b | 轉(zhuǎn)義 |
| f | 0x0c | 換頁 |
| s | 0x20 | 空格 |
| M-C-x | | Meta-control-x |
| x | | 字符x |
| nnn | | 八進行標記，n為0到7范圍內(nèi)的值 |
| r | 0x0d | 回車 |
| xnn | | 十六進制標記，n為0-9, a-f或A-F范圍內(nèi)的值 |
| t | 0x09 | Tab制表符 |
| v | 0x0b | 垂直制表符 |

特殊的字符串運算符

下表中顯示了字符串的特殊運算符，假定a為Hello，b為World：

| 運算符 | 描述 | 示例 |
| + | 拼接：將運算符兩邊的值相加 | a + b將得到HelloWorld |
| [] | 切片：得到給定索引的字符串 | a[7]將得到r |
| [ : ] | 范圍切片：得到指定范圍內(nèi)的字符 | a[1:4]將得到ell |
| * | 重復：創(chuàng)建新的字符串，將相同字符串的多個拷貝進行拼接 | a*2將得到HelloHello |
| not in | 成員：如果字符不在字符串中返回true | Z not in a將得到1 |
| in | 成員：如果字符在字符串中返回true | H in a將得到1 |
| % | 格式化：執(zhí)行字符串格式化 | |

%字符串格式化運算符

%是Python中的一個字符串格式化運算符。參照如下示例：

#!/usr/bin/python3
print("Hello this is %s and my age is %d !" % ('John', 25))

輸出：
Hello this is John and my age is 25 !

下表顯示了配合%使用的符號列表：

| 序號 | Format symbol and conversion |
| 1 | %c – 字符 |
| 2 | %s – 在格式化之前通過str()轉(zhuǎn)換的字符串 |
| 3 | %i – 有符號十進制整數(shù) |
| 4 | %d – 有符號十進制整數(shù) |
| 5 | %u – 無符號十進制整數(shù) |
| 6 | %o – 八進制整數(shù) |
| 7 | %x – 十六進制整數(shù)（小寫字母） |
| 8 | %X –十六進制整數(shù)（大寫字母） |
| 9 | %e – 指數(shù)標記（使用小寫 e） |
| 10 | %E –指數(shù)標記（使用大寫 E） |
| 11 | %f – 浮點實數(shù) |

Python中的三引號

Python對字符串使用三引號的表示可跨越多行，包括新行和制表符。三引號的語法包含三個連續(xù)的單引號或雙引號。參照如下代碼：

#!/usr/bin/python3
para_str = """Python is a scripting language which was created by
Guido van Rossum in 1991, t which is used in various sectors such as Game
Development, GIS Programming, Software Development, web development,
Data Analytics and Machine learning, System Scripting etc.
"""
print (para_str)

輸出內(nèi)容：
Python is a scripting language which was created by
Guido van Rossum in 1991, t which is used in various sectors such as Game
Development, GIS Programming, Software Development, web development,
Data Analytics and Machine learning, System Scripting etc.<

字符串是不可變的

字符串是不可變的，表示我們修改它的值。參照如下示例：

>>> welcome = 'Hello, John!'
>>> welcome[0] = 'Y'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

因為字符串是不可變的（immutable），我們不能修改現(xiàn)有字符串。但我們可以創(chuàng)建一個與原來不同的新字符串：

>>> str1 = 'Hello John'
>>> new_str = 'Welcome' + str1[5:]
>>> print(str1)
Hello John
>>> print(new_str)
Welcome John
>>>

理解列表

Python支持一種稱為列表（list）的數(shù)據(jù)結構，它是一個可變和有序的元素序列。列表中的每個元素稱為列表項。列表通過在方括號[ ]之間插入值定義。列中的每個元素都會給定一個數(shù)值，稱們稱之為位置或索引。索引從0開始，也即，第一個索引為0，第二個索引為1，以此類推。我們可對列表進行如下運算：索引、切片、相加、相乘以及檢查是否為列表成員。

Python內(nèi)置的length函數(shù)返回列表的長度。Python還有查找列表中最大項和最小項的函數(shù)。列表可以是數(shù)值列表、字符串列表或混合列表。

以下是創(chuàng)建列表的代碼：

>>> l = list()
>>> numbers = [10, 20, 30, 40]
>>> animals = ['Dog', 'Tiger', 'Lion']
>>> list1 = ['John', 5.5, 500, [100, 450]]

這里我們創(chuàng)建了三個列表：第一個是numbers，第二是animals，第三個是list1。列表中有另一個列表稱為嵌套列表。list1是一個嵌套列表。不包含任何元素的列表稱為空列表，可通過空的中括號[]來創(chuàng)建空列表。

你可能已經(jīng)猜，可將列表賦值給變量：

>>> cities = ['Mumbai', 'Pune', 'Chennai']
>>> numbers_list = [75, 857]
>>> empty_list = []
>>> print(cities, numbers_list, empty_list)
['Mumbai', 'Pune', 'Chennai'] [75, 857] []

訪問列表中的值

我們可以使用索引值來訪問列表中的值。我們將索引數(shù)字放在[ 和 ]之間。索引從0開始。參見如下示例：

#!/usr/bin/python3
cities = ['Mumbai', 'Bangalore', 'Chennai', 'Pune']
numbers = [1, 2, 3, 4, 5, 6, 7]
print(cities[0])
print(numbers[1:5])

輸出結果：
Mumbai
[2, 3, 4, 5]

更新列表

可以更新列表中的元素，如以下代碼所示：

#!/usr/bin/python3
cities = ['Mumbai', 'Bangalore', 'Chennai', 'Pune']
print('Original Value: ', cities[3])
cities[3] = 'Delhi'
print('New value: ', cities[3])

輸出結果：
Original Value:  Pune
New value:  Delhi

刪除列表元素

要刪除列表中元素，如果知道要具體刪除的元素可使用del語句。如果不知道具體要刪除的列表項索引可使用remove()。參見如下示例：

#/usr/bin/python3
cities = ['Mumbai', 'Bangalore', 'Chennai', 'Pune']
print("Before deleting: ", cities)
del cities[2]
# cities.remove("Chennai") # 相同效果的補充
print("After deleting: ", cities)

輸出結果：
Before deleting:  ['Mumbai', 'Bangalore', 'Chennai', 'Pune']
After deleting:  ['Mumbai', 'Bangalore', 'Pune']

基本列表運算

有五種基本列表運算：

• 拼接
• 重復
• 取長度
• 成員關系
• 迭代

| 描述 | 表達式 | 結果 |
| 拼接 | [30, 50, 60] + ['Hello', 75, 66] | [30, 50, 60, 'Hello', 75, 66] |
| 成員 | 45 in [45, 58, 99, 65] | True |
| 迭代 | for x in [45, 58, 99]:
print(x, end=' ') | 45 58 99 |
| 重復 | ['Python'] * 3 | ['Python', 'Python', 'Python'] |
| 取長度 | len([45, 58, 99, 65]) | 4 |

列表運算

在這一部分中，我們將學習基本列表運算：拼接和重復。

+運算符將列表進行拼接：

>>> a = [30, 50, 60]
>>> b = ['Hello', 75, 66]
>>> c = a + b
>>> print(c)
[30, 50, 60, 'Hello', 75, 66]

相似地，*運算符以給定次數(shù)重復列表：

>>> [0] * 4
[0, 0, 0, 0]
>>> ['Python'] * 3
['Python', 'Python', 'Python']

索引、切片和矩陣

列表索引與字符串索引的運作方式相同。列表值可通過索引來訪問。如果嘗試將不存在的元素寫入列表，會得到IndexError。如果索引為負值，會從列表的最后開始倒數(shù)。

現(xiàn)在我們創(chuàng)建一個名為cities的列表并查看列表的索引運算：

cities = ['Mumbai', 'Bangalore', 'Chennai', 'Pune']

| 描述 | 表達式 | 結果 |
| 索引從0開始 | cities[2] | 'Chennai' |
| 切片：獲取一個片段 | cities[1:] | ['Bangalore', 'Chennai', 'Pune'] |
| 負數(shù)：從右開始數(shù) | cities[-3] | 'Bangalore' |

元組

Python 的元組(tuple)數(shù)據(jù)結構是不可變的，這表示不能修改元組中的元素。 基本上，元組是一個以逗號分隔的值的序列，以括號( )進行包裹。和列表類似，元組是一個有序的元素序列：

t1 = 'h', 'e', 'l', 'l', 'o'

元組以括號( )進行包裹：

t1 = ('h', 'e', 'l', 'l', 'o')

我們還可以創(chuàng)建一個只有一個元素的元組，僅需在元組的最后加一個逗號：

>>> t1 = 'h',
>>> type(t1)
<class 'tuple'>

把值放到括號中并不是元組：

>>> t1 = ('a')
>>> type(t1)
<class 'str'>

我們可以使用tuple()函數(shù)來創(chuàng)建空的元組：

>>> t1 = tuple()
>>> print(t1)
()

如果該函數(shù)的參數(shù)是一個序列（字符串、列表或元組），結果是這個序列元素組成的元組：

<pre class="lang:default decode:true ">>>> t = tuple('mumbai')

print(t)
('m', 'u', 'm', 'b', 'a', 'i')</pre>

元組的值在括號( ) 中以逗號分隔：

>>> t = ('a', 'b', 'c', 'd', 'e')
>>> print(t[0])
a

切片運算符選取一個范圍內(nèi)的元素。

>>> print(t[1:3])
('b', 'c')

訪問元組中的值

要訪問元組中的值，使用方括號切片與單個或多個索引結合來獲取對應索引的值，如下例所示：

#!/usr/bin/python3
cities = ('Mumbai', 'Bangalore', 'Chennai', 'Pune')
numbers = (1, 2, 3, 4, 5, 6, 7)
print(cities[3])
print(numbers[1:6])

輸出結果：
Pune
(2, 3, 4, 5, 6)

更新元組

在Python中元組是不可更新的，因為元組是不可變的。但是我們通過現(xiàn)在元組來新建一個元組，如下例如下：

#!/usr/bin/python3
cities = ('Mumbai', 'Bangalore', 'Chennai', 'Pune')
numbers = (1, 2, 3, 4, 5, 6, 7)
tuple1 = cities + numbers
print(tuple1)

輸出結果：
('Mumbai', 'Bangalore', 'Chennai', 'Pune', 1, 2, 3, 4, 5, 6, 7)

刪除元組元素

我們不能刪除單個數(shù)據(jù)元組。因此要顯式地刪除整個元組，使用del語句。參照如下示例：

#!/usr/bin/python3
cities = ('Mumbai', 'Bangalore', 'Chennai', 'Pune')
print("Before deleting: ", cities)
del cities
print("After deleting: ", cities)

輸出結果：
Before deleting:  ('Mumbai', 'Bangalore', 'Chennai', 'Pune')
Traceback (most recent call last):
  File "test.py", line 5, in <module>
    print("After deleting: ", cities)
NameError: name 'cities' is not defined

基本元組運算

和列表相似，有五種基本元組運算：

• 拼接
• 重復
• 取長度
• 成員關系
• 迭代

| 描述 | 表達式 | 結果 |
| 拼接 | (30, 50, 60) + ('Hello', 75, 66) | (30,50,60,'Hello',75,66) |
| 成員 | 45 in (45, 58, 99, 65) | True |
| 迭代 | for x in (45, 58, 99):
print(x, end=' ') | 45 58 99 |
| 重復 | ('Python') * 3 | ('Python', 'Python', 'Python') |
| 取長度 | len((45, 58, 99, 65)) | 4 |

索引、切片和矩陣

元組索引的運作方式和列表相同。使用索引可訪問元組的值。如果嘗試讀取或?qū)懭氩淮嬖诘脑?，會報出IndexError。如果索引為負值，則從元組的最后向前數(shù)。

現(xiàn)在我們創(chuàng)建一個名為cities的元組并查看列表的索引運算：

cities = ('Mumbai', 'Bangalore', 'Chennai', 'Pune')

| 描述 | 表達式 | 結果 |
| 索引從0開始 | cities[2] | 'Chennai' |
| 切片：獲取一個片段 | cities[1:] | ('Bangalore', 'Chennai', 'Pune') |
| 負數(shù)：從右開始數(shù) | cities[-3] | 'Bangalore' |

max()和min()

使用max()和min()函數(shù)，我們可以查找元組中的最大值和最小值。這兩個函數(shù)讓我們可以找到量化數(shù)據(jù)的相關信息。我們來看看下面這個例子：

>>>> numbers = (50, 80, 98, 110.5, 75, 150.58)
>>> print(max(numbers))
150.58

使用max()可以獲取元組中的最大值。相似地，我們可以使用min()函數(shù)：

>>> numbers = (50, 80, 98, 110.5, 75, 150.58)
>>> print(min(numbers))
50

因此這里我們獲取到了最小值。

集合

集合（set）是一個無序且無重復值的元素集。集合的基本用法是檢查成員關系測試和刪除重復項。這些集合對象支持數(shù)學運算，如并集、交集、差集以及對等差分。我們可以使用大括號{}或函數(shù)set()來創(chuàng)建集合。如果想要創(chuàng)建一個空的集合，使用set()而不是{}。

以下是一個簡單的演示：

>>> fruits = {'Mango', 'Apple', 'Mango', 'Watermelon', 'Apple', 'Orange'}
>>> print(fruits)
{'Orange', 'Apple', 'Watermelon', 'Mango'}
>>> 'Orange' in fruits
True
>>> 'Onion' in fruits
False
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a
{'c', 'r', 'b', 'a', 'd'}
>>> a - b
{'r', 'b', 'd'}
>>> a | b
{'c', 'l', 'd', 'b', 'z', 'r', 'm', 'a'}
>>> a & b
{'c', 'a'}
>>> a ^ b
{'l', 'd', 'b', 'z', 'r', 'm'}

譯者注：因集合是無序的，所以讀者在執(zhí)行相同代碼時得到的結果順序可能會略有不同

Python 中還支持集合推導式(set comprehension)，參見如下代碼：

>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}

字典

字典（dictionary）是Python中的一種數(shù)據(jù)類型，它由鍵值對組成并包裹在大括號{}中。字典是無序的并通過鍵進行索引，且每個鍵必須是唯一的。這些鍵必須為不可變類型。元組在級包含字符串、數(shù)字或元組時可作為字典的鍵。

僅僅使用一對大括號{}會創(chuàng)建一個空的字典。字典的主要運算是使用某些鍵來存儲值并通過給定的鍵來提取值。同樣可以使用 del 來刪除一個鍵值對。如果使用了已有的鍵進行存儲，就會抹除該鍵原來關聯(lián)的值。使用不存在的鍵來提取值會報錯。以下是使用字典的一個小例子：

>>> student = {'Name':'John', 'Age':25}
>>> student['Address'] = 'Mumbai'
>>> student
{'Name': 'John', 'Address': 'Mumbai', 'Age': 25}
>>> student['Age']
25
>>> del student['Address']
>>> student
{'Name': 'John', 'Age': 25}
>>> list(student.keys())
['Name', 'Age']
>>> sorted(student.keys())
['Age', 'Name']
>>> 'Name' in student
True
>>> 'Age' not in student
False

自選的鍵值表達式配合字典推導式可用于創(chuàng)建字典：

>>> {x: x**2 for x in (4, 6, 8)}
{4: 16, 6: 36, 8: 64}

在鍵是簡單的字符串時，使用關鍵字參數(shù)的方式指定鍵值對很更為容易：

>>> dict(John=25, Nick=27, Jack=28)
{'Nick': 27, 'Jack': 28, 'John': 25}

解析命令行參數(shù)

在這一部分中，我們將學習參數(shù)的解析以及用于解析參數(shù)的模塊。

Python 中的命令行參數(shù)

我們可以在命令行中添加額外的參數(shù)來啟動程序。Python的程序可通過命令行參數(shù)來啟動。讓我們來看看下面這個例子：

$ python program_name.py img.jpg

這里program_name.py和img.jpg都是參數(shù)。我們將使用模塊來獲取這些參數(shù)：

| 模塊 | 用法 | Python版本 |
| optparse | 已淘汰 | < 2.7 |
| sys | 所有sys.argv中的參數(shù) (基本) | 所有版本 |
| argparse | 創(chuàng)建一個命令行接口 | >= 2.3 |
| fire | 自動生成命令行接口(CLI) | All |
| docopt | 創(chuàng)建CLI接口 | >= 2.5 |

Sys.argv

sys模塊用于訪問命令行參數(shù)。len(sys.argv) 函數(shù)包含參數(shù)的數(shù)量。要打印所有的參數(shù)，只需執(zhí)行str(sys.argv)。讓們來看看下面這個例子：

# 01.py
import sys
print('Number of arguments: ', len(sys.argv))
print('Argument list: ', str(sys.argv))

# 運行
python3 01.py img
# 執(zhí)行結果
Number of arguments:  2
Argument list:  ['01.py', 'img']

決策制定

當我們想要在條件為true時執(zhí)行一個代碼時，就需要使用到?jīng)Q策制定了。if...elif...else語句在Python中用于決策制定。

Python的if語句語法

以下是if語句的語法：

if test expression:
        statement(s)

這里，程序運行了test 表達式并僅在該表達式為true時才執(zhí)行下面的語句。如果表達式為false，則不會執(zhí)行語句。

Python中if語句的主體通過縮進來表示。語句主體通過縮進來表示第一行的開始，通過取消縮進表示主體的結束。我們來看看下面這個例子：

a = 10
if a > 0:
        print(a, "is a positive number.")
print("This statement is always printed.")

a = -10
if a > 0:
        print(a, "is a positive number.")

輸出結果：
10 is a positive number.
This statement is always printed.

Python的if...else語句語法

在這一部分，我們將學習if..else 語句。else代碼塊僅在if條件為false時執(zhí)行。參見如下代碼：

if test expression:
        if block
else:
        else block

if..else語句運行test表達式，僅在test條件為true時運行主體內(nèi)容。如果條件為false，else中的主體內(nèi)容會被執(zhí)行。縮進用于分割代碼塊。參見如下示例：

a = 10
if a > 0:
        print("Positive number")
else:
        print("Negative number")

輸出結果：
Positive number

Python的if...elif...else語句語法

elif語句從多條語句中檢查true值。只要運行的執(zhí)為 true 就執(zhí)行相應的代碼塊。參見如下代碼：

if test expression:
        if block statements
elif test expression:
        elif block statements
else:
        else block statements

elif是else if的簡寫，讓我們可以檢查多個表達式。如果if語句中的條件為false，它會檢查下一個elif代碼塊的條件，以此類推。如果所有條件均為false，else中的主體內(nèi)容會被執(zhí)行。

if...elif...else中僅會根據(jù)條件執(zhí)行其中一個代碼塊。if代碼塊僅能帶有一個else代碼塊，但可以有多個elif代碼塊。我們來看看以下的示例：

a = 10
if a > 50:
        print("a is greater than 50")
elif a == 10:
        print("a is equal to 10")
else:
        print("a is negative")

輸出結果：
a is equal to 10

循環(huán)

要處理腳本中的所有循環(huán)需求，Python支持兩類循環(huán)：

• for 循環(huán)
• while 循環(huán)

下面我們就來學習for 循環(huán)和while 循環(huán)。

for循環(huán)

for循環(huán)遍歷序列或其它可迭代對象中的每一項，并每次執(zhí)行for代碼塊中的語句。參照如下代碼：

for i in sequence:
        for loop body

此處i 為在每次迭代時獲取序列中各項值的變量。在到達序列最后一項之前循環(huán)會一直執(zhí)行。下圖中進行了描述：

for 循環(huán)的執(zhí)行

參見如下示例：

numbers = [6, 5, 3, 8, 4, 2, 5, 4, 11]
sum = 0
for i in numbers:
        sum = sum + i
        print("The sum is", sum)

輸出結果：
The sum is 6
The sum is 11
The sum is 14
The sum is 22
The sum is 26
The sum is 28
The sum is 33
The sum is 37
The sum is 48

range()函數(shù)

Python的range()函數(shù)會生成一個數(shù)字的序列。例如，range(10)會生成0到9的數(shù)字（共10個數(shù)字）。

我們還可以定義起始、結束和步長來作為參數(shù)，這時range()函數(shù)如下所示：

range(start, stop, step size).

如未設置步長默認為1。

使用range()函數(shù)的 for 循環(huán)示例如下：

for i in range(5):
        print("The number is", i)

輸出結果：
The number is 0
The number is 1
The number is 2
The number is 3
The number is 4

while循環(huán)

while是一個在測試表達式為true時不停遍歷代碼塊的循環(huán)語句。我們在不知道要迭代多少次時使用這一循環(huán)。參見如下代碼：

while test_expression:
        while body statements

在while循環(huán)中，我們首先檢查測試表達式。while僅在這個測試表達式為true時執(zhí)行。在一個迭代后，會重新對表達式進行檢查，并在表達式運行值為false前不停重復這一過程。下圖中進行了描述：

執(zhí)行 while 循環(huán)

以下為while循環(huán)的示例：

a = 10
sum = 0
i = 1
while i <= a:
        sum = sum + i
        i = i + 1
        print("The sum is", sum)

運行結果：
The sum is 1
The sum is 3
The sum is 6
The sum is 10
The sum is 15
The sum is 21
The sum is 28
The sum is 36
The sum is 45
The sum is 55

迭代器

Python中的迭代器是可進行迭代的對象。這個對象會返回數(shù)據(jù)，每次返回一個元素。Python的迭代器對象實現(xiàn)了兩個方法：iter()和next()。大多數(shù)情況下迭代器在循環(huán)、生成器和推導式中實現(xiàn)。

下例中，我們使用了next()函數(shù)，它會遍歷所有的元素。在到達最后且沒有更多數(shù)據(jù)返回時，會拋出StopIteration，如下例所示：

numbers = [10, 20, 30, 40]

numbers_iter = iter(numbers)

print(next(numbers_iter))
print(next(numbers_iter))
print(numbers_iter.__next__())
print(numbers_iter.__next__())

next(numbers_iter)

輸出結果：
10
20
30
40
Traceback (most recent call last):
  File "test.py", line 10, in <module>
    next(numbers_iter)
StopIteration

生成器

我們可以使用Python生成器來創(chuàng)建迭代器。Python中生成器是返回一個可以迭代對象的函數(shù)。

如何在Python中創(chuàng)建生成器

在Python中創(chuàng)建生成器非常容易。我們可以定義一個函數(shù)，使用yield語句來代替return語句即可創(chuàng)建生成器。如果函數(shù)中至少包含一個yield語句，它就變成了一個生成器函數(shù)。yield和return語句會從函數(shù)中返回某些值。以下為示例：

def my_gen():
        n = 1
        print("This is printed first")
        yield n
        n += 1
        print("This is printed second")
        yield n
        n += 1
        print("This is printed at last")
        yield n

for item in my_gen():
        print(item)

輸出結果：
This is printed first
1
This is printed second
2
This is printed at last
3

函數(shù)

函數(shù)時執(zhí)行特定任務的一組語句。使用函數(shù)有助于將我們的程序分成更小的部分。函數(shù)可避免重復并讓代碼可以復用，因此讓程序組織得更好。來看下面的語法：

def function_name:
        statement(s)

參見如下示例：

def welcome(name):
        print("Hello " + name + ", Welcome to Python Programming!")

welcome("John")

輸出結果：
Hello John, Welcome to Python Programming!

return語句

return語句用于退出函數(shù)。參見如下的語法：

return [expression_list]

這個語句可能包含返回一個值的表達式。如果沒有表達式，函數(shù)會返回None對象，如下例所示：

def return_value(a):
        if a >= 0:
                return a
        else:
                return -a

print(return_value(2))
print(return_value(-4))

輸出結果：
2
4

Lambda函數(shù)

Python中匿名函數(shù)是未定義函數(shù)名的函數(shù)，稱為lambda函數(shù)，使用關鍵字lambda進行定義。在需要短暫使用一個函數(shù)時我們使用這類函數(shù)。

lambda函數(shù)與內(nèi)置的函數(shù)共同使用，如filter()和map()。

filter()函數(shù)返回一個元素列表，并僅接收一個迭代值。以下為使用filter()的示例：

numbers = [10, 25, 54, 86, 89, 11, 33, 22]
new_numbers = list(filter(lambda x: (x%2 == 0), numbers))

print(new_numbers)

輸出結果：
[10, 54, 86, 22]

在本例中，filter()接收一個lambda函數(shù)以及一個列表來作為參數(shù)。

map()函數(shù)在應用指定函數(shù)之后返回一個結果列表。下面我們來看看使用map()的示例：

my_list = [1, 5, 4, 6, 8, 11, 3, 12]
new_list = list(map(lambda x: x * 2, my_list))
print(new_list)

輸出結果：
[2, 10, 8, 12, 16, 22, 6, 24]

這里，map()函數(shù)接收一個lambda函數(shù)和一個列表。

模塊

模塊只是包含Python語句和定義的文件。一個包含Python代碼的文件（如sample.py）稱為一個模塊，并且模塊名應為sample。使用模塊，我們可以大型的程序分解成更小和有組織的程序。模塊的一個重要特性是復用性。我們無需在不同程序中拷貝經(jīng)常使用到的函數(shù)定義，而是將它們定義在一模塊中，然后需要使用時進行導入。

我們來創(chuàng)建一個模塊并導入。我們將創(chuàng)建兩個腳本：sample.py和add.py。然后在add.py中導入sample模塊?，F(xiàn)在將如下代碼保存到sample.py文件中。我們來看看下面這個示例：

# sample.py
def addition(num1, num2):
        result = num1 + num2
        return result

這里我們在名為sample的模塊中定義了一個函數(shù)addition()。該函數(shù)接收兩個數(shù)值并返回和。這樣我們就創(chuàng)建了一個模塊。我們可以在任意Python程序中導入該模塊。

導入模塊

在創(chuàng)建模塊后，我們來學習如何導入這一模塊。上例中我們創(chuàng)建了一個sample模塊?，F(xiàn)在我們就在add.py腳本中導入sample模塊：

# add.py
import sample
sum = sample.addition(10, 20)
print(sum)

輸出結果：
30

總結

在本章中，我們概覽了Python腳本語言。學習了如何安裝Python以及各種工具。我們還學習了Python解釋器以及如何使用它。我們學習了Python支持的數(shù)據(jù)類型、變量、數(shù)值和字符串、決策制定語句和Python中的循環(huán)語句。我們還學習了函數(shù)以及如何在腳本中使用函數(shù)，模塊以及如何創(chuàng)建和導入模塊。

在下一章Python腳本調(diào)試和性能測試中，我們將學習Python的調(diào)試技巧、錯誤處理（異常處理）、調(diào)試器工具、調(diào)試基本的程序崩潰、程序性能和用時測試以及加快程序運行。

??? 第二章 Python腳本調(diào)試和性能測試

問題

1. 什么是迭代器和生成器？
2. 列表是否可變？
3. Python中的數(shù)據(jù)結構是什么？
4. 如何說列表中的值？
5. 什么是模塊？

擴展閱讀

Python的所有文檔可通過官方網(wǎng)站獲取。

還可以閱讀如下圖書：Learn Python Hard Way和Byte of Python來學習 Python 的基礎知識。

本文首發(fā)地址：Alan Hou 的個人博客