Life is short, you need Python。（人生苦短，我用 Python。）

——Bruce Eckel

前言

聽說現在是全民 Python 的時代，雖然不知道事實如何，但學會 Python 的確可以做很多事。據我瞭解，Python 目前主要有五大用途：網站開發、網路爬蟲、人工智慧、資料分析、自動化運維。而對於職場人士來說，Python 則可以用來進行自動化辦公。除此之外，如果你想自己開發一些小遊戲、小工具，Python 也是一個不錯的選擇。

相較於其他程式語言，Python 不僅上手容易，而且由於程式碼庫（就是別人已經寫好的程式碼，我們可以直接拿來用）豐富，我們在實現功能時需要寫的程式碼也更少。

目前，Python 有 2.x 和 3.x 兩個版本，且兩個版本不相容。本文主要針對 3.x 版本。

正文

從小白的日常說起

在學習 Python 程式設計之前，我們先來看一個現實生活中可能出現的場景——

某天，小白下班回到家裡，想起今天的《斗羅大陸》更新了。於是趕緊興沖沖地跑到電腦桌前，開啟膝上型電腦，然後登入騰訊視訊觀看最新一集的《斗羅大陸》。但是，看視訊怎麼能少得了瓜子呢？於是，小白又從櫃子裡拿出了一包瓜子，磕著瓜子看著《斗羅大陸》，小白露出了滿意的笑容。

看到這裡，你可能會一臉懵逼——這傻逼作者在講什麼，這跟 Python 程式設計有什麼關係嗎？但我要說的是，上述場景其實就是一個程式的執行過程，它和計算機內的程式執行類似，只不過這個程式的執行，是發生在我們所處的現實世界當中。至於為什麼這麼說，我們下面就來看看——

一、現實世界 VS 計算機世界

在計算機的世界裡，一個程式的執行過程可以簡單地理解為：計算機從記憶體中的指定地址獲取到所需資料，然後對該資料進行某種操作，如此迴圈往復。

現在我們把小白回家日常的場景描述稍微改造一下：小白從家裡的電腦桌上獲取到膝上型電腦，然後開啟膝上型電腦觀看《斗羅大陸》。再從櫃子裡獲取到瓜子，開始邊嗑瓜子邊看《斗羅大陸》。

怎麼樣？是不是跟計算機內程式的執行過程很相似。其實計算機從記憶體中的指定地址獲取資料，就相當於小白從家裡的某個位置獲取某個物品。而計算機對資料的操作，就相當於小白對物品的操作。

計算機世界	現實世界
計算機	小白
計算機記憶體	小白的家
記憶體地址	家裡的位置
資料	物品
從記憶體中指定地址獲取資料	從家裡的某個位置獲取物品
對資料的操作	對物品的操作

二、小白執行手冊 VS Python 程式程式碼

現在，假設小白是一個聽話的小白，無論你讓他做什麼，他都會按你的要求一絲不苟的照做。於是你嘿嘿一笑，立馬給小白安排了 10 套暑假作業、20 套網路課程、30 套健身計劃。小白很開心，並對你表示萬分感謝。

但是，你不可能一直呆在小白身邊，給他講解每個步驟。於是，你想到可以寫一份執行手冊，然後讓小白按照上面的步驟去執行。這份執行手冊其實就相當於 Python 程式程式碼。只不過你的執行手冊是寫給小白看的，而 Python 程式程式碼是寫給計算機看的。換句話說，Python 程式程式碼就是寫給計算機的執行手冊。

三、執行手冊書寫格式 VS Python 程式設計語法

假設你是一個強迫症患者，為了寫出一份美觀、簡潔的執行手冊，你規定了一些書寫格式——

1、給物品取別名

可以給某個位置的物品取一個獨一無二的別名。當需要用到該物品時，可以使用別名代替。其書寫格式為：

別名 = 某個位置的物品

2、給一系列步驟取行為名

在給小白寫某個行為的具體步驟時，可以給這一系列步驟取個名稱，該名稱我們稱為行為名。當需要用到這些步驟時，可以使用行為名代替。其書寫格式為：

行為名():
    步驟1
    步驟2
    ...
    步驟n

注意：行為名後面帶了括號和冒號。

3、使用行為名代替一系列步驟

由於一些步驟可能被多次用到，如果每次都要寫一大堆步驟就太麻煩了。因此，我們可以在給這些步驟取完行為名後，用行為名來代替這些步驟。其書寫格式為：

步驟1
步驟2
行為名()
...
步驟n

注意：使用行為名代替一系列步驟時，要在行為名後面加括號，以表明這是一個行為名。

4、條件判斷的寫法

當需要根據具體情況（即滿足某種條件）來決定是否進行某種操作時，使用以下書寫格式：

如果 某種條件:
    某種操作

注意：這裡的“如果”，是固定寫法。

5、重複操作的寫法

對於當滿足某種條件時，需要一直重複進行某種操作的情況，使用以下書寫格式：

當 某種條件:
    某種操作

注意：這裡的“當”，是固定寫法。

規定好了執行手冊的書寫格式後，只要讓小白學會怎麼看懂這些書寫格式，那他就能根據你的執行手冊自己去執行了。

這些書寫格式就相當於 Python 程式語言的語法。我們在編寫 Python 程式時，只要嚴格按照 Python 語法去編寫程式程式碼，計算機就能理解並按你的要求去執行了。

四、編寫小白執行手冊 VS 編寫 Python 程式程式碼

現在，你懷著激動而又忐忑的心情開始給小白編寫執行手冊了。最終你的《小白執行手冊》是這樣的——

當 暑假作業沒寫完10套:
    寫暑假作業()

當 網路課程沒學完20套:
    觀看網路課程()

當 健身不足30套:
    健身()
    喝水()

寫暑假作業():
    暑假作業 = 書桌抽屜裡的白色封面暑假作業
    鉛筆 = 書桌上筆筒裡的黑色鉛筆
    開啟暑假作業
    如果 鉛筆尖鈍了:
        削鉛筆
    用鉛筆寫暑假作業

觀看網路課程():
    膝上型電腦 = 電腦桌上的ThinkPad膝上型電腦
    開啟膝上型電腦
    登入網易雲課堂
    觀看Python課程

健身():
    啞鈴 = 南邊牆角下的15公斤啞鈴
    啞鈴彎舉100下
    啞鈴划船100下
    啞鈴臥推100下

喝水():
    礦泉水 = 冰箱裡的娃哈哈礦泉水
    開啟礦泉水瓶蓋
    喝礦泉水

看到如此簡單、優雅的執行手冊，是不是很令人身心舒暢？我們接下來要學習的 Python 程式語言就是一門簡單、優雅的程式語言。

而且，編寫 Python 程式程式碼的過程，與編寫《小白執行手冊》的過程也很類似。只不過，編寫 Python 程式程式碼時，涉及到語法會更加豐富，對一些格式的要求也更加嚴格。

現在開始學 Python

我們已經知道了編寫 Python 程式的過程，其實就是給計算機編寫執行手冊的過程。也知道了一個程式的執行過程，就是不斷地根據地址從記憶體中取資料，然後操作資料的過程。而 Python 程式在執行過程中所涉及的東西，有些是計算機本身已有的，有些則是需要我們通過 Python 語言告訴計算機的。

1、程式執行涉及的東西

接下來，我們就來簡單地瞭解一下 Python 程式執行過程中所涉及到的一些東西。同時明確一下哪些是計算機本身已有的，哪些我們需要告訴計算機的——

（1）記憶體

記憶體是計算機內用於存放程式執行時所需資料的地方，我們在編寫 Python 程式時涉及到的資料，在使用前都會存放在記憶體中。

記憶體由計算機自己管理，我們無法直接控制（可以通過一些優化技巧來間接控制，但我們目前先不考慮這個），因此我們在編寫 Python 程式時不用管這個。

其實計算機會將記憶體分配給 Python 虛擬機器，然後由 Python 虛擬機器負責管理記憶體，但我們可以把 Python 虛擬機器簡單地理解為計算機的一部分。

（2）資料

資料可以簡單地理解為儲存在計算機內的東西。

計算機儲存資料的地方有磁碟和記憶體：磁碟就是我們平常在 Windows 電腦上看到的 C 盤、D 盤等，可永久儲存資料；記憶體則負責臨時儲存程式執行時所需要的資料，它無法永久儲存資料。我們後面提到資料時，如果沒有特殊說明就是指記憶體中的資料。

程式執行時，計算機會給這個程式分配一個記憶體塊，這塊記憶體一開始是沒有任何資料的。這就跟小白哪天搬了新家一樣，一開始家裡是沒有任何東西的。因此我們在編寫 Python 程式時，就需要告訴計算機如何在記憶體中生成資料，一般有以下三種生成資料的方式——

• 自己建立：後面我們會學到如何建立基本型別的資料以及自定義型別的資料。基本型別是 Python 本身提供的資料型別，而自定義型別則通過類和物件來建立（類和物件是面向物件程式設計中的概念，這個我們後面會學到）。
• 從計算機本地磁碟讀取：後面我們要學的檔案讀寫，就是用來處理來自計算機本地磁碟的資料的。
• 從網路中讀取：由於本文只是帶大家入門的，因此我們不講如何處理來自網路中的資料，有興趣的可以自己百度下“Python 網路程式設計”。

無論是自己建立的、從磁碟讀取的、還是從網路中讀取的資料，最終都會存放在記憶體中。

（3）資料在記憶體中的地址

Python 程式在執行過程中，所涉及到的資料都會在記憶體中有一個對應的地址。一旦需要這個資料，就能根據這個地址從記憶體中獲取該資料。

也就是說，我們在編寫 Python 程式時，如果需要某個資料的話，只需要告訴計算機這個資料所在的地址就行了。但由於我們不像計算機一樣，可以根據地址就能知道里面存的是什麼資料，因此，為了方便編寫 Python 程式，我們可以給這個地址取個別名，這個別名在程式語言中稱為變數名，而取別名則稱為賦值。

• 變數：本質上是一小塊記憶體空間。在 Python 中，變數裡儲存的是地址，而變數具有變數名，這個變數名就是地址的別名。由於計算機會自動將地址轉換成資料（從地址中獲取資料），因此，我們可以簡單地理解為變數裡儲存的是資料，而變數名就是資料的別名。
• 賦值：將某一數值賦給某個變數的過程。在 Python 中，就是將地址值賦給某個變數的過程，這個過程相當於給地址取別名。由於計算機會自動將地址轉換成資料（從地址中獲取資料），因此，我們可以把賦值簡單理解為給資料取別名。

（4）如何根據地址從記憶體中獲取資料

計算機會自動根據變數名找到對應的地址，再從該地址獲取資料。我們在編寫 Python 程式時不用管這個。

（5）對資料進行何種操作

由於對資料進行什麼操作，是由我們的意願決定的。因此，我們在編寫 Python 程式時，就必須告訴計算機如何操作資料。

一般操作資料有兩種方式——

• 運算子：也叫操作符，其實就跟數學裡的加、減、乘、除等運算子一樣。
• 函式：函式中封裝了一系列程式碼片段，該程式碼片段一般用於實現特定功能。跟我們前面說的給一系列步驟取一個行為名類似，函式就相當於給一系列程式碼片段取一個名稱（函式名）。

（6）當存在多個操作時，如何控制操作的流程

當存在多個操作時，我們必須告訴計算機哪個操作先執行，哪個後執行。否則，計算機將無法正常執行程式。

在程式語言中，一般有三種控制流程的方式——

• 順序控制：從上往下依次執行程式碼。程式執行時，預設就是順序執行。
• 選擇控制：根據不同條件，執行不同程式碼。後面我們要學的條件語句，就是用來進行選擇控制的。
• 迴圈控制：根據指定條件，重複執行某段程式碼。後面我們要學的迴圈語句，就是用來進行迴圈控制的。

2、編寫 Python 程式需要做的事

現在，我們來總結一下，在編寫 Python 程式時，一般需要做哪些事情——

1. 生成資料：建立基本型別資料、建立自定義資料（類、物件）、從磁碟中讀取、從網路中讀取。
2. 給資料取別名：變數、賦值。
3. 操作資料：運算子（操作符）、函式。
4. 控制操作資料的流程：順序、選擇、迴圈。

一、Python 安裝與執行

1、Python 安裝

由於本人只有 Windows 電腦，因此這裡只介紹 Windows 上安裝 Python 的過程。

（1）下載 Python 安裝包

我們這邊下載 Python 3.9.6 版本——

• 32 位 Windows 系統：https://www.python.org/ftp/python/3.9.6/python-3.9.6.exe
• 64 位 Windows 系統：https://www.python.org/ftp/python/3.9.6/python-3.9.6-amd64.exe

如果要下載其他平臺或者其他版本的 Python 安裝包，可以自己到官網去下載。官網下載地址：https://www.python.org/downloads/

（2）安裝 Python

下載完安裝包後，雙擊執行，勾選上“Add Python 3.9 to PATH”，然後點選“Install Now”即可。

如果不想使用預設安裝，也可以選擇“Customize installation”進行自定義安裝。

（3）檢查是否安裝成功

安裝完成後，開啟命令提示符（按下 Windows 鍵 + R 鍵，在彈出的輸入框內輸入“cmd”，敲回車，即可開啟命令提示符），輸入 python 後，敲回車，如果出現類似以下內容，則說明安裝成功。

Microsoft Windows [版本 10.0.19042.1110]
(c) Microsoft Corporation。保留所有權利。

C:\Users\10100>python
Python 3.9.6 (tags/v3.9.6:db3ff76, Jun 28 2021, 15:26:21) [MSC v.1929 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

否則，有可能是沒有勾選上“Add Python 3.9 to PATH”，這時候就需要修改環境變數，把 python.exe 所在路徑新增在 Path 中。如果不知道怎麼修改環境變數，可以直接解除安裝重灌。

2、Python 執行

下面介紹三種執行 Python 的方式——

（1）命令列模式執行 Python

按下 Windows 鍵 + R 鍵，在彈出的輸入框內輸入“cmd”，敲回車，即可進入命令列模式。

在命令列模式下，可進入 Python 檔案（.py 檔案）所在目錄，輸入 python 檔名.py 後敲回車，來執行 Python 檔案。

Microsoft Windows [版本 10.0.19042.1110]
(c) Microsoft Corporation。保留所有權利。

C:\Users\10100>cd /d D:\mypython

D:\mypython>python hello.py
hello world

也可以直接輸入 python 檔案完整路徑，而不用進入 Python 檔案所在目錄。

Microsoft Windows [版本 10.0.19042.1110]
(c) Microsoft Corporation。保留所有權利。

C:\Users\10100>python D:\mypython\hello.py
hello world

（2）互動模式執行 Python

進入命令列模式後，輸入 python，敲回車，即可進入互動模式。輸入 exit()，敲回車，即可退出互動模式。

在互動模式下，會有 >>> 提示符，>>> 後可直接編寫 Python 程式碼。編寫完後敲回車，即可執行程式碼。

Microsoft Windows [版本 10.0.19042.1110]
(c) Microsoft Corporation。保留所有權利。

C:\Users\10100>python
Python 3.9.6 (tags/v3.9.6:db3ff76, Jun 28 2021, 15:26:21) [MSC v.1929 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> print('hello world')
hello world
>>>

（3）整合開發環境（IDE）執行 Python

整合開發環境（IDE）可理解為用於編寫 Python 程式的一整套工具，只不過這些工具被集中放在一個軟體內。比如 PyCharm 或者裝了相關外掛的 Visual Studio Code（簡稱 VS Code）。

我們在實際編寫 Python 程式時，一般會使用 IDE。由於 IDE 自帶了執行 Python 的功能，因此前面兩種執行 Python 的方式，我們瞭解即可。

二、第一個 Python 程式

這裡推薦使用 VS Code 來編寫 Python 程式，推薦理由很簡單——它的介面清爽、乾淨，看起來賊舒服（一個不太正經的理由，勿噴，謝謝）！除此之外，VS Code 也可以通過安裝外掛來整合更多的功能。

1、安裝 VS Code

下載地址：https://code.visualstudio.com/

安裝過程中，注意勾選上“建立桌面快捷方式”的選項，其他按預設的來就行。

2、使用 VS Code 編寫程式

現在，我們來使用 VS Code 編寫一個列印“hello world”的 Python 程式——

（1）建立新檔案

點選左上角的 File -> New File（或者按 Ctrl + N）即可建立新檔案。

（2）編寫程式碼

在編輯欄內輸入 print('hello world')。

print() 函式用於在控制檯列印內容。

（3）儲存檔案

點選左上角的 File -> Save（或者按 Ctrl + S），在彈出框內選擇儲存路徑（圖例中儲存在 D:\mypython），並命名為 hello.py 後點擊儲存。

（4）執行程式檔案

點選 View -> Terminal（或者按 Ctrl + `（數字 1 左邊的鍵））開啟命令列終端，在命令列終端內輸入 python 檔案完整路徑（檔案完整路徑要與上一步的儲存路徑對應，圖例中為 python D:\mypython\hello.py）回車，即可執行程式。

3、給 VS Code 安裝 Python 外掛

如果每次執行 Python 程式，都要在命令列終端手動輸入命令就太麻煩了。因此，我們可以給 VS Code 安裝一個 Python 外掛，這個外掛不僅可以方便我們執行程式，也可以幫助我們進行程式碼提示、程式碼檢查等。

安裝步驟：

（1）開啟外掛市場

點選 View -> Extensions（或者按 Ctrl + Shift + X，又或者點選左側活動欄的第五個圖示）開啟外掛市場。

（2）搜尋外掛並安裝

在外掛市場的搜尋框內輸入“python”搜尋外掛，找到名為“Python”的外掛（一般在第一個），點選“Install”即可進行安裝。

安裝完 Python 外掛後，在編輯欄內點選右鍵 -> Run Python File in Terminal，即可執行 Python 檔案。

三、Python 基本程式碼結構

現在我們來看一下 Python 檔案的基本程式碼結構，先有個整體性的認識。看得懂最好，看不懂也沒關係，可以等學完後再回過頭來看。

#!/usr/bin/env python3                  # 指定直譯器，windows 系統下執行時可省略，但為了可移植性最好加上
# -*- coding: utf-8 -*-                 # 指定編碼格式，python 3.x 版本可省略，但為了可移植性最好加上

'''
該模組用於展示 Python 基本程式碼結構
'''
                                        # 模組說明

import sys, os                          # 匯入模組

debug = True                            # 定義全域性變數

class ClassName(object):                # 定義類，(object) 表示繼承 object 類，可以不寫 (object)
    pass

def func():                             # 定義函式
    pass

if __name__ == '__main__':              # 是否主函式，只有該檔案作為執行入口時，下面程式碼才會執行，一般用於測試本模組
    c = ClassName()
    func()

• pass 是空語句，可以起佔位作用。當你還沒寫業務程式碼時，可以使用 pass 來保持語法結構的完整性。
• if __name__ == '__main__' 用於判斷當前檔案是不是程式的執行入口。當通過當前檔案執行程式時，下面的程式碼就會被執行，一般用於測試本模組中的程式碼。

四、基礎語法

1、變數與賦值

變數用於儲存資料，而賦值就是將資料存到變數的過程（給資料取別名）。

Python 中，可以使用任意資料給變數重新賦值，此時新的資料會替換舊的資料。

賦值寫法：變數名 = 變數值。

• 變數名可以隨便取，但是必須符合識別符號規則（下面會講到）。
• 變數值可以是一個數據值、表示式（由運算子和運算元構成）或函式。
• 這裡的 =，不是我們在數學中理解的“等於”，它的含義是“賦值”。

示例：

# 將數字資料賦值給變數 a
a = 1
# 將列表資料賦值給變數 a
a = [1, 2, 3]

# 將表示式 1 + 2 的結果值賦值給變數 b
b = 1 + 2
# 將表示式 b + 1 的結果值賦值給變數 b
b = b + 1

# 將函式的返回值賦值給變數 c
c = abs(-1)

全域性變數與區域性變數：

• 全域性變數：定義在函式外的變數。全域性變數在任何地方都能使用。
• 區域性變數：定義在函式內的變數。區域性變數只能在函式內使用。

2、識別符號

識別符號用於給變數、函式等命名。換句話說，我們給變數、函式等取的名稱，就是識別符號。

識別符號組成規則：

• 由字母、數字、下劃線組成。
• 第一個字元必須是字母或下劃線。
• 區分大小寫。

3、關鍵字

關鍵字又稱保留字，是被 Python 語言賦予了特殊含義的單詞。

不能使用關鍵字作為識別符號。

我們使用的 Python 3.9.6 版本有 36 個關鍵字：False，None，True，__peg_parser__，and，as，assert，async，await，break，class，continue，def，del，elif，else，except，finally，for，from，global，if，import，in，is，lambda，nonlocal，not，or，pass，raise，return，try，while，with，yield。

4、註釋

註釋是用來解釋程式碼的。

為了防止自己以後或者別人看不懂程式碼，我們可以使用註釋來解釋你的程式碼是用來幹嘛的或者為什麼要這麼寫。計算機在執行 Python 程式碼時，會自動忽略註釋內容。

其實負責執行 Python 程式碼的是 Python 直譯器，它會將 Python 語言翻譯成計算機能看得懂的機器語言。但我們可以把 Python 直譯器簡單地理解為計算機的一部分。

（1）單行註釋

單行註釋以 # 開頭，# 後為註釋內容。

示例：

# 向世界問好
print('hello world')  # 向世界問好

（2）多行註釋

多行註釋以成對的 '''（3 個英文單引號）或 """（3 個英文雙引號）包裹。

示例：

'''
向世界問好
向世界問好
'''

"""
向世界問好
向世界問好
"""
print('hello world')

5、縮排

Python 中使用縮排來表示程式碼塊。同一層級（包含子層級）的程式碼堆疊在一起，就是程式碼塊。縮排可以使用 Tab 符號或空格，但同一程式碼塊內不能混用。一般使用 4 個空格作為 1 個縮排。

關於如何縮排，我們只需要記住以下兩點：

1. 同一程式碼塊的語句必須包含相同的縮排，簡單的說，就是要對齊。
2. 遇到某行程式碼結尾有 :（英文冒號）時，緊跟著的程式碼塊必須再次縮排。

示例：

a = -1
if a < 0:
    print('a 是負數')
    a = -a
else:
    print('a 不是負數')
print('a 的絕對值為:', a)

以上程式碼可以提取出 3 個程式碼塊：

• 程式碼塊 1：由所有程式碼構成，包含 0 個縮排。
• 程式碼塊 2：由 print('a 是負數') 和 a = -a 構成，包含 1 個縮排。
• 程式碼塊 3：由 print('a 不是負數') 單獨構成，包含 1 個縮排。

由於程式碼塊 2 和程式碼塊 3 緊跟在 : 後面，需要再次縮排，因此包含 1 個縮排。

五、基本資料型別

Python 提供了六種基本資料型別，用於給我們建立基本型別的資料，包括數字、字串、列表、元組、字典、集合。

根據資料建立完後可不可以被修改，可分為：

• 不可變資料：數字、字串、元組。
• 可變資料：列表、字典、集合。

可以使用 type() 函式來檢視資料的型別：

>>> type(1)
<class 'int'>

1、數字

Python 中的數字型別包含：整數、浮點數、布林型別、複數。

• 整數：這個沒什麼好說的，就是 1、2、-1 這種。
• 浮點數：其實就是小數，像 1.2、2.3 這種。
• 布林型別（布林值）：布林型別只有 True（真值，可理解為“是”）、False（假值，可理解為“否”） 兩種值，要麼 True，要麼 False。用於做非此即彼的判斷。
• 複數：形如 a + bj，a 為實部，b 為虛部，j 為虛數單位。這個瞭解即可，一般不會用到。

（1）建立數字

語法格式：

變數 = 數字值

示例：

# 建立整數，並賦值給變數 a
a = 1

# 建立浮點數，並賦值給變數 b
b = 1.2

# 建立布林型別資料，並賦值給變數 c
c = True

# 建立複數，並賦值給變數 d
d = 1 + 2j

（2）常見數字操作

表格中，x、x1、x2 為要操作的數字，r 為接收操作結果的變數。

操作	如何操作	操作說明	操作示例
加、減、乘、除	使用 +、-、*、/ 運算子	-	r = 1 + 2
將數字轉換為整數	使用 int(x) 函式	int() 也可以將數字字串轉換為整數	r = int(1.2)
將數字轉換為浮點數	使用 float(x) 函式	float() 也可以將數字字串轉換為浮點數	r = float(1)
獲取絕對值	使用 abs(x) 函式	-	r = abs(-1)
向上取整	使用 math.ceil(x) 函式	需要匯入 math 模組，操作結果為大於等於 x 的最小整數	r = math.ceil(4.5)
向下取整	使用 math.floor(x) 函式	需要匯入 math 模組，操作結果為小於等於 x 的最大整數	r = math.floor(4.5)
獲取多個數字的最大值	使用 max(x1, x2, ...) 函式	-	r = max(1, 2, 3)
獲取多個數字的最小值	使用 min(x1, x2, ...) 函式	-	r = min(1, 2, 3)
四捨五入保留 n 位小數	使用 round(x, n) 函式	n 為保留小數位	r = round(4.543, 2)

示例：

import math

# 加、減、乘、除、求餘
r = 1 + 2
print('1 加 2 結果為', r)  # 輸出：1 加 2 結果為 3
r = 2 - 1
print('2 減 1 結果為', r)  # 輸出：2 減 1 結果為 1
r = 2 * 3
print('2 乘 3 結果為', r)  # 輸出：2 乘 3 結果為 6
r = 3 / 2
print('3 除 2 結果為', r)  # 輸出：3 除 2 結果為 1.5

# 將數字轉換為整數
r = int(1.2)
print('1.2 轉換為整數的結果為', r)  # 輸出：1.2 轉換為整數的結果為 1

# 將數字轉換為浮點數
r = float(1)
print('1 轉換為浮點數的結果為', r)  # 輸出：1 轉換為浮點數的結果為 1.0

# 獲取絕對值
r = abs(-1)
print('-1 的絕對值為', r)  # 輸出：-1 的絕對值為 1

# 向上取整
r = math.ceil(4.5)
print('4.5 向上取整的結果為', r)  # 輸出：4.5 向上取整的結果為 5

# 向下取整
r = math.floor(4.5)
print('4.5 向下取整的結果為', r)  # 輸出：4.5 向下取整的結果為 4

# 獲取多個數字的最大值
r = max(1, 2, 3)
print('數字 1、2、3 的最大值為', r)  # 輸出：數字 1、2、3 的最大值為 3

# 獲取多個數字的最小值
r = min(1, 2, 3)
print('數字 1、2、3 的最小值為', r)  # 輸出：數字 1、2、3 的最小值為 1

# 四捨五入保留 n 位小數
r = round(4.543, 2)
print('4.543 四捨五入保留 2 位小數的結果為', r)  # 輸出：4.543 四捨五入保留 2 位小數的結果為 4.54

2、字串

字串可理解為文字。

（1）建立字串

Python 中使用成對的 '（英文單引號）或 "（英文雙引號）來建立字串。

• 由於 '、" 用於建立字串，因此不能隨意出現在字串內容中，此時，我們可以用 \'、\" 來代替。\ 稱為轉義符，可以將某個符號的含義轉成另一種含義。（也可以交替使用 '、" 或者使用三引號（'''、"""），這個我們不細講。）
• 注意字串中的內容哪怕跟程式碼再像，它也不是程式碼。因此，如果看到字串中出現了跟變數、表示式等一樣的內容，那它們也不是變數或表示式。
• 注意不要混淆數字字串與數字，數字字串形如 '123'，數字形如 123。

語法格式：

變數 = '字串內容'
變數 = "字串內容"

示例：

# 建立字串，並賦值給變數 s
s = '在學 Python，很忙！'
s = "在學 Python，很忙！"

# 建立包含單引號的字串，並賦值給變數 s
s = '在學 \'Python\'，很忙！'
s = "在學 'Python'，很忙！"

# 建立包含雙引號的字串，並賦值給變數 s
s = "在學 \"Python\"，很忙！"
s = '在學 "Python"，很忙！'

# 建立內容與程式碼相似的字串，並賦值給變數 s
s = 'a + 1'  # 這裡的 a + 1 不是表示式程式碼，只是長得像而已

# 建立數字字串，並賦值給變數 s
s = '123'

# 建立空字串，並賦值給變數 s
s = ''
s = ""

（2）常見字串操作

表格中，x、x1、x2 為要操作的字串，r 為接收操作結果的變數。

操作	如何操作	操作說明	操作示例
字串拼接	使用 + 運算子	將多個字串拼接成一個新的字串	r = x1 + x2
字串擷取	使用 [:] 運算子	擷取字串一部分，冒號兩邊為開始、結束索引，遵循左閉右開（包含開始索引的字元，不包含結束索引的字元）	r = x[0:4]
字串格式化	使用 % 運算子	用右邊資料依次替換左邊字串內的佔位符（常用 %s），右邊有多個數據時要用 () 包起來，並用逗號分隔	r = 'hello,%s' % 'world'
獲取字串長度	使用 len(x) 函式	字串內的字元個數	r = len(x)
去除字串兩端空格	使用 x.strip() 函式	-	r = x.strip()
根據分隔符分割字串	使用 x.split(s) 函式	s 為分隔符	r = x.split(',')
在字串中查詢某一字串	使用 x.find(s) 函式	s 為要查詢的字串，結果為索引值，找不到則為 -1	r = x.find('hello')
判斷字串是否以某一字串開頭	使用 x.startswith(s) 函式	s 為開頭字串	r = x.startswith('http')
判斷字串是否以某一字串結尾	使用 x.endswith(s) 函式	s 為結尾字串	r = x.endswith('.jpg')
大寫字母轉小寫	使用 x.lower() 函式	-	r = x.lower()
小寫字母轉大寫	使用 x.upper() 函式	-	r = x.upper()
字串替換	使用 x.replace(s1, s2) 函式	將 x 字串中的 s1 字串替換為 s2 字串	r = x.replace('hello', 'hi')

示例：

# 字串拼接
r = 'hello' + 'world'
print('字串拼接結果為', r)  # 輸出：字串拼接結果為 helloworld

# 字串擷取
x = 'hello,world'
r = x[0:4]
print('從索引 0 到 4 擷取字串，結果為', r)  # 輸出：從索引 0 到 4 擷取字串，結果為 hell

# 字串格式化
r = 'hello,%s' % 'world'  # 替換一個數據
print('字串格式化結果為', r)  # 輸出：字串格式化結果為 hello,world
r = 'hello,%s! hello,%s!' % ('world', 'python')  # 替換多個數據
print('字串格式化結果為', r)  # 輸出：字串格式化結果為 hello,world! hello,python!

# 獲取字串長度
x = 'hello,world'
r = len(x)
print('字串長度為', r)  # 輸出：字串長度為 11

# 去除字串兩端空格
r = '  hello,world  '.strip()
print('去除兩端空格的結果為', r)  # 輸出：去除兩端空格的結果為 hello,world

# 根據分隔符分割字串
x = 'hello,world'
r = x.split(',')
print('根據逗號分割字串，結果為', r)  # 輸出：根據逗號分割字串，結果為 ['hello', 'world']

# 在字串中查詢某一字串
x = 'hello,world'
r = x.find('ello')
print('字串中查詢 ello，結果為', r)  # 輸出：字串中查詢 ello，結果為 1

# 判斷字串是否以某一字串開頭
x = 'hello,world'
r = x.startswith('hello')
print('判斷字串是否以 hello 開頭，結果為', r)  # 輸出：判斷字串是否以 hello 開頭，結果為 True

# 判斷字串是否以某一字串結尾
x = 'hello,world'
r = x.endswith('world')
print('判斷字串是否以 world 結尾，結果為', r)  # 輸出：判斷字串是否以 world 結尾，結果為 True

# 大寫字母轉小寫
x = 'HELLO,world'
r = x.lower()
print('大寫字母轉小寫，結果為', r)  # 輸出：大寫字母轉小寫，結果為 hello,world

# 小寫字母轉大寫
x = 'HELLO,world'
r = x.upper()
print('小寫字母轉大寫，結果為', r)  # 輸出：小寫字母轉大寫，結果為 HELLO,WORLD

# 字串替換
x = 'hello,world'
r = x.replace('hello', 'hi')
print('字串替換後，結果為', r)  # 輸出：字串替換後，結果為 hi,world

3、列表

Python 中的列表可理解為 Excel 表格中的某一列，列中每個單元格帶有序號，我們可以根據序號找到某個單元格，從而操作單元格的資料。

列表的每個位置也帶有序號，序號從 0 開始，依次遞增，這個序號被稱為索引，每個位置儲存的資料被稱為元素。列表中可存放不同型別的資料，並且可以隨時新增、刪除裡面的資料。

（1）建立列表

Python 中使用 [] 來建立列表，並使用 ,（英文逗號）分隔各個資料。

語法格式：

變數 = [資料1, 資料2, ..., 資料n]

示例：

# 建立名字列表，並賦值給變數 names
names = ['小白', '小黑', 'Tom', 'Jerry']

# 建立分數列表，並賦值給變數 scores
scores = [90, 80, 85, 85]

# 建立包含名字和分數的列表，並賦值給變數 data
data = ['小白', '小黑', 'Tom', 'Jerry', 90, 80, 85, 85]

# 建立空列表，並賦值給變數 data
data = []

（2）常見列表操作

表格中，x、x1、x2 為要操作的列表，r 為接收操作結果的變數。

操作	如何操作	操作說明	操作示例
根據索引獲取列表中的資料	使用 [] 運算子	方括號內為索引	r = x[1]
根據索引修改列表中的資料	使用 []、= 運算子	[] 運算子用於定位資料，= 運算子用於修改資料	x[1] = 2
根據索引刪除列表中的資料	使用 []、del 運算子	[] 運算子用於定位資料，del 運算子用於刪除資料	del x[1]
列表拼接	使用 + 運算子	將兩個列表拼接成一個新的列表	r = x1 + x2
列表擷取	使用 [:] 運算子	擷取列表的一部分，冒號兩邊為開始、結束索引，遵循左閉右開	r = x[0:4]
判斷資料是否在列表中	使用 in 運算子	操作結果為布林值，True 表示在，False 表示不在	r = 2 in x
獲取列表長度	使用 len(x) 函式	列表中的資料個數	r = len(x)
獲取列表中資料最大值	使用 max(x) 函式	列表中的資料必須是相同型別	r = max(x)
獲取列表中資料最小值	使用 min(x) 函式	列表中的資料必須是相同型別	r = min(x)
在列表末尾新增新資料	使用 x.append(d) 函式	d 為要新增的資料	x.append(3)
刪除列表中第一個匹配資料	使用 x.remove(d) 函式	d 為要刪除的資料	x.remove(3)
列表排序	使用 x.sort() 函式	預設升序，降序則使用 x.sort(reverse=True)	x.sort()
清空列表	使用 x.clear() 函式	清空列表中的所有資料	x.clear()

示例：

# 根據索引獲取列表中的資料
x = [0, 1, 2, 3, 4, 5]
r = x[1]
print('索引 1 的資料為', r)  # 輸出：索引 1 的資料為 1

# 根據索引修改列表中的資料
x = [0, 1, 2, 3, 4, 5]
x[1] = 3
print('索引 1 的資料修改後為', x[1])  # 輸出：索引 1 的資料修改後為 3

# 根據索引刪除列表中的資料
x = [0, 1, 2, 3, 4, 5]
del x[1]
print('刪除索引 1 的資料後，列表為', x)  # 輸出：刪除索引 1 的資料後，列表為 [0, 2, 3, 4, 5]

# 列表拼接
r = [0, 1, 2] + [3, 4, 5]
print('列表拼接結果為', r)  # 輸出：列表拼接結果為 [0, 1, 2, 3, 4, 5]

# 列表擷取
x = [0, 1, 2, 3, 4, 5]
r = x[0:4]
print('從索引 0 到 4 擷取列表，結果為', r)  # 輸出：從索引 0 到 4 擷取列表，結果為 [0, 1, 2, 3]

# 判斷資料是否在列表中
x = [0, 1, 2, 3, 4, 5]
r = 2 in x
print('判斷 2 是否在列表中，結果為', r)  # 輸出：判斷 2 是否在列表中，結果為 True

# 獲取列表長度
x = [0, 1, 2, 3, 4, 5]
r = len(x)
print('列表長度為', r)  # 輸出：列表長度為 6

# 獲取列表中資料最大值
x = [0, 1, 2, 3, 4, 5]
r = max(x)
print('列表中資料最大值為', r)  # 輸出：列表中資料最大值為 5

# 獲取列表中資料最小值
x = [0, 1, 2, 3, 4, 5]
r = min(x)
print('列表中資料最小值為', r)  # 輸出：列表中資料最小值為 0

# 在列表末尾新增新資料
x = [0, 1, 2, 3, 4, 5]
x.append(6)
print('在列表末尾新增新資料後，列表為', x)  # 輸出：在列表末尾新增新資料後，列表為 [0, 1, 2, 3, 4, 5, 6]

# 刪除列表中第一個匹配資料
x = [0, 1, 2, 3, 4, 5]
x.remove(2)
print('刪除列表中第一個匹配資料後，列表為', x)  # 輸出：刪除列表中第一個匹配資料後，列表為 [0, 1, 3, 4, 5]

# 列表排序
x = [3, 1, 4, 2, 5, 0]
x.sort()
print('排序後的列表為', x)  # 輸出：排序後的列表為 [0, 1, 2, 3, 4, 5]

# 清空列表
x = [0, 1, 2, 3, 4, 5]
x.clear()
print('清空後的列表為', x)  # 輸出：清空後的列表為 []

4、元組

元組與列表基本類似，不同之處在於元組內的資料不能被修改。

（1）建立元組

Python 中使用 () 來建立元組，並使用 ,（英文逗號）分隔各個資料。

語法格式：

變數 = (資料1, 資料2, ..., 資料n)

建立只有一個數據的元組時，必須在資料後面加 ,，否則 () 會被當做運算子，此時建立的將不是一個元組。

示例：

# 建立名字元組，並賦值給變數 names
names = ('小白', '小黑', 'Tom', 'Jerry')

# 建立分數元組，並賦值給變數 scores
scores = (90, 80, 85, 85)

# 建立包含名字和分數的元組，並賦值給變數 data
data = ('小白', '小黑', 'Tom', 'Jerry', 90, 80, 85, 85)

# 建立只有一個數據的元組，並賦值給變數 data
data = (90,)

# 建立空元組，並賦值給變數 data
data = ()

（2）常見元組操作

表格中，x、x1、x2 為要操作的元組，r 為接收操作結果的變數。

操作	如何操作	操作說明	操作示例
根據索引獲取元組中的資料	使用 [] 運算子	方括號內為索引	r = x[1]
元組拼接	使用 + 運算子	將兩個元組拼接成一個新的元組	r = x1 + x2
元組擷取	使用 [:] 運算子	擷取元組的一部分，冒號兩邊為開始、結束索引，遵循左閉右開	r = x[0:4]
判斷資料是否在元組中	使用 in 運算子	操作結果為布林值，True 表示在，False 表示不在	r = 2 in x
獲取元組長度（資料個數）	使用 len(x) 函式	元組中的資料個數	r = len(x)
獲取元組中資料最大值	使用 max(x) 函式	元組中的資料必須是相同型別	r = max(x)
獲取元組中資料最小值	使用 min(x) 函式	元組中的資料必須是相同型別	r = min(x)

示例：

# 根據索引獲取元組中的資料
x = (0, 1, 2, 3, 4, 5)
r = x[1]
print('索引 1 的資料為', r)  # 輸出：索引 1 的資料為 1

# 元組拼接
r = (0, 1, 2) + (3, 4, 5)
print('元組拼接結果為', r)  # 輸出：元組拼接結果為 (0, 1, 2, 3, 4, 5)

# 元組擷取
x = (0, 1, 2, 3, 4, 5)
r = x[0:4]
print('從索引 0 到 4 擷取元組，結果為', r)  # 輸出：從索引 0 到 4 擷取元組，結果為 (0, 1, 2, 3)

# 判斷資料是否在元組中
x = (0, 1, 2, 3, 4, 5)
r = 2 in x
print('判斷 2 是否在元組中，結果為', r)  # 輸出：判斷 2 是否在元組中，結果為 True

# 獲取元組長度
x = (0, 1, 2, 3, 4, 5)
r = len(x)
print('元組長度為', r)  # 輸出：元組長度為 6

# 獲取元組中資料最大值
x = (0, 1, 2, 3, 4, 5)
r = max(x)
print('元組中資料最大值為', r)  # 輸出：元組中資料最大值為 5

# 獲取元組中資料最小值
x = (0, 1, 2, 3, 4, 5)
r = min(x)
print('元組中資料最小值為', r)  # 輸出：元組中資料最小值為 0

5、字典

Python 中的字典就像我們上學時經常用的《新華字典》，《新華字典》中儲存了漢字以及對應的漢字解釋，我們可以通過某個漢字找到對應的漢字解釋。

字典中儲存了鍵值對（鍵和值），鍵對應《新華字典》中的漢字，值對應《新華字典》中的漢字解釋。鍵可理解為別名，值為對應的資料，我們可以根據鍵從字典中找到對應的值。

字典中的鍵必須唯一，而值則不用。另外，鍵必須是不可變的（比如數字、字串），而值可以是任何資料型別。

（1）建立字典

Python 中使用 {:} 來建立字典，:（英文冒號）用於建立鍵值對，並使用 ,（英文逗號）分隔各個鍵值對。

語法格式：

變數 = {鍵1: 值1, 鍵2: 值2, ..., 鍵n: 值n}

示例：

# 建立儲存學生資訊的字典，並賦值給變數 student
student = {'名字': '小白', '分數': 90}

# 建立儲存座位號及對應學生名字的字典，並賦值給變數 seats
seats = {1: '小白', 2: '小黑', 3: 'Tom', 4: 'Jerry'}

# 建立儲存名字及對應分數的字典，並賦值給變數 data
data = {'小白': 90, '小黑': 80, 'Tom': 85, 'Jerry': 85}

# 建立空字典，並賦值給變數 data
data = {}

（2）常見字典操作

表格中，x 為要操作的元組，r 為接收操作結果的變數。

操作	如何操作	操作說明	操作示例
根據鍵獲取資料	使用 [] 運算子	方括號內為鍵	r = x['name']
新增或修改資料	使用 []、= 運算子	[] 運算子用於定位資料，= 運算子用於修改資料	x['name'] = 'tom'
根據鍵刪除資料	使用 []、del 運算子	[] 運算子用於定位資料，del 運算子用於刪除資料	del x['name']
判斷某個鍵是否在字典中	使用 in 運算子	操作結果為布林值，True 表示在，False 表示不在	r = 'name' in x
獲取字典長度	使用 len(x) 函式	字典中的鍵值對個數	r = len(x)
獲取字典的所有鍵	使用 x.keys() 函式	獲取到的不是一個列表，可以使用 list() 函式轉換為列表	r = x.keys()
獲取字典的所有值	使用 x.values() 函式	獲取到的不是一個列表，可以使用 list() 函式轉換為列表	r = x.values()
獲取字典的所有鍵值對	使用 x.items() 函式	獲取到的不是一個列表，可以使用 list() 函式轉換為列表	r = x.items()
清空字典	使用 x.clear() 函式	清空字典中的所有鍵值對	x.clear()

示例：

# 根據鍵獲取資料
x = {'name': '小白', 'age': 17}
r = x['name']
print('鍵為 name 的資料為', r)  # 輸出：鍵為 name 的資料為 小白

# 新增資料
x = {'name': '小白', 'age': 17}
x['country'] = '中國'
print('新增資料後字典為', x)  # 輸出：增資料後字典為 {'name': '小白', 'age': 17, 'country': '中國'}

# 修改資料
x = {'name': '小白', 'age': 17}
x['age'] = 27
print('鍵為 age 的資料修改後為', x['age'])  # 輸出：鍵為 age 的資料修改後為 27

# 根據鍵刪除資料
x = {'name': '小白', 'age': 17}
del x['age']
print('刪除鍵為 age 的資料後，字典為', x)  # 輸出：刪除鍵為 age 的資料後，字典為 {'name': '小白'}

# 判斷某個鍵是否在字典中
x = {'name': '小白', 'age': 17}
r = 'age' in x
print('判斷鍵 age 是否在字典中，結果為', r)  # 輸出：判斷鍵 age 是否在字典中，結果為 True

# 獲取字典長度
x = {'name': '小白', 'age': 17}
r = len(x)
print('字典長度為', r)  # 輸出：字典長度為 2

# 獲取字典的所有鍵
x = {'name': '小白', 'age': 17}
r = x.keys()
print('獲取字典的所有鍵，結果為', r)  # 輸出：獲取字典的所有鍵，結果為 dict_keys(['name', 'age'])

# 獲取字典的所有值
x = {'name': '小白', 'age': 17}
r = x.values()
print('獲取字典的所有值，結果為', r)  # 輸出：獲取字典的所有值，結果為 dict_values(['小白', 17])

# 獲取字典的所有鍵值對
x = {'name': '小白', 'age': 17}
r = x.items()
print('獲取字典的所有鍵值對，結果為', r)  # 輸出：獲取字典的所有鍵值對，結果為 dict_items([('name', '小白'), ('age', 17)])

# 清空字典
x = {'name': '小白', 'age': 17}
x.clear()
print('清空後的字典為', x)  # 輸出：清空後的字典為 {}

6、集合

Python 中的集合可理解為無序的、不重複的列表，集合中儲存的資料是無序的、不重複的。集合中可存放不同型別的資料。

• 由於集合是無序的，因此沒有索引，我們不能根據索引獲取資料。
• 由於集合是不重複的，因此即使我們儲存了重複的資料，最終也只會保留一個。

（1）建立集合

Python 中使用 {} 建立集合，並使用 ,（英文逗號）分隔各個資料。

語法格式：

變數 = {資料1, 資料2, ..., 資料n}

示例：

# 建立名字列表，並賦值給變數 names
names = {'小白', '小黑', 'Tom', 'Jerry'}

# 建立分數列表，並賦值給變數 scores
scores = {90, 80, 85, 85}  # 兩個 85，最終只會保留一個

# 建立包含名字和分數的列表，並賦值給變數 data
data = {'小白', '小黑', 'Tom', 'Jerry', 90, 80, 85, 85}  # 兩個 85，最終只會保留一個

# 建立空集合，並賦值給變數 data
data = set()  # 注意：{} 用於建立空字典，因此建立空集合不能用 {}

（2）常見集合操作

表格中，x 為要操作的元組，r 為接收操作結果的變數。

操作	如何操作	操作說明	操作示例
新增資料	使用 x.add(d)	d 為要新增的資料	x.add(2)
刪除資料	使用 x.remove(d)	d 為要刪除的資料	x.remove(2)
判斷資料是否在集合中	使用 in 運算子	操作結果為布林值，True 表示在，False 表示不在	r = 2 in x
獲取集合長度	使用 len(x) 函式	集合中的資料個數	r = len(x)
獲取集合中資料最大值	使用 max(x) 函式	集合中的資料必須是相同型別	r = max(x)
獲取集合中資料最小值	使用 min(x) 函式	集合中的資料必須是相同型別	r = min(x)
清空集合	使用 x.clear() 函式	清空集合中的所有資料	x.clear()

示例：

# 新增資料
x = {0, 1, 2, 3, 4, 5}
x.add(6)
print('新增資料後集合為', x)  # 輸出：新增資料後集合為 {0, 1, 2, 3, 4, 5, 6}

# 刪除資料
x = {0, 1, 2, 3, 4, 5}
x.remove(3)
print('刪除資料集合為', x)  # 輸出：刪除資料集合為 {0, 1, 2, 4, 5}

# 判斷資料是否在集合中
x = {0, 1, 2, 3, 4, 5}
r = 2 in x
print('判斷 2 是否在集合中，結果為', r)  # 輸出：判斷 2 是否在集合中，結果為 True

# 獲取集合長度
x = {0, 1, 2, 3, 4, 5}
r = len(x)
print('集合長度為', r)  # 輸出：集合長度為 6

# 獲取集合中資料最大值
x = {0, 1, 2, 3, 4, 5}
r = max(x)
print('集合中資料最大值為', r)  # 輸出：集合中資料最大值為 5

# 獲取集合中資料最小值
x = {0, 1, 2, 3, 4, 5}
r = min(x)
print('集合中資料最小值為', r)  # 輸出：集合中資料最小值為 0

# 清空集合
x = {0, 1, 2, 3, 4, 5}
x.clear()
print('清空後的集合為', x)  # 輸出：清空後的集合為 set()

六、運算子

Python 提供了七種型別的運算子，用於給我們操作資料。

1、算術運算子

算術運算子用於對資料進行算術運算。

運算子	描述	示例
+	加	a + b
-	減	a - b
*	乘	a * b
/	除	a / b
%	取模（求餘）	a % b
**	冪（乘方）	a ** b
//	向下整除（小於等於相除結果的最大整數）	a // b

示例：

a = 1 + 2
print('a 的結果為', a)  # 輸出：a 的結果為 3

b = 2 - 1
print('b 的結果為', b)  # 輸出：b 的結果為 1

c = 2 * 3
print('c 的結果為', c)  # 輸出：c 的結果為 6

d = 3 / 2
print('d 的結果為', d)  # 輸出：d 的結果為 1.5

e = 3 % 2
print('e 的結果為', e)  # 輸出：e 的結果為 1

f = 2 ** 2
print('f 的結果為', f)  # 輸出：f 的結果為 4

g = 3 // 2
print('g 的結果為', g)  # 輸出：g 的結果為 1

2、比較（關係）運算子

比較運算子用於比較兩個資料的關係，操作結果是一個布林值。

運算子	描述	示例
==	等於	a == b
!=	不等於	a != b
>	大於	a > b
<	小於	a < b
>=	大於等於	a >= b
<=	小於等於	a <= b

示例：

a = 1 == 1
print('判斷 1 是否等於 1，結果為', a)  # 輸出：判斷 1 是否等於 1，結果為 True
a = 1 == 2
print('判斷 1 是否等於 2，結果為', a)  # 輸出：判斷 1 是否等於 2，結果為 False

b = 1 != 2
print('判斷 1 是否不等於 2，結果為', b)  # 輸出：判斷 1 是否不等於 2，結果為 True
b = 1 != 1
print('判斷 1 是否不等於 1，結果為', b)  # 輸出：判斷 1 是否不等於 1，結果為 False

c = 2 > 1
print('判斷 2 是否大於 1，結果為', c)  # 輸出：判斷 2 是否大於 1，結果為 True
c = 2 > 2
print('判斷 2 是否大於 2，結果為', c)  # 輸出：判斷 2 是否大於 2，結果為 False

d = 1 < 2
print('判斷 1 是否小於 2，結果為', d)  # 輸出：判斷 1 是否小於 2，結果為 True
d = 1 < 1
print('判斷 1 是否小於 1，結果為', d)  # 輸出：判斷 1 是否小於 1，結果為 False

e = 1 >= 1
print('判斷 1 是否大於等於 1，結果為', e)  # 輸出：判斷 1 是否大於等於 1，結果為 True
e = 1 >= 2
print('判斷 1 是否大於等於 2，結果為', e)  # 輸出：判斷 1 是否大於等於 2，結果為 False

f = 1 <= 1
print('判斷 1 是否小於等於 1，結果為', f)  # 輸出：判斷 1 是否小於等於 1，結果為 True
f = 2 <= 1
print('判斷 2 是否小於等於 1，結果為', f)  # 輸出：判斷 2 是否小於等於 1，結果為 False

3、賦值運算子

賦值運算子用於給變數賦值。最常用的賦值運算子為 =（簡單賦值），對於剛入門的小夥伴，只需要會用這個就足夠了。

除此之外，還包括 +=（加法賦值）、-=（減法賦值）、*=（乘法賦值）、/=（除法賦值）、%=（取模賦值）、**=（冪賦值）、//=（整除賦值） 等。

示例：

a = 2
print('a 的結果為', a)  # 輸出：a 的結果為 2

4、邏輯運算子

邏輯運算子用於根據已有的一個或多個條件計算出最終結果，操作結果是一個布林值。

運算子	描述	示例
and	與（如果 and 左邊的值為 False，則結果為左邊的值，否則為右邊的值）	a and b
or	或（如果 or 左邊的值為 True，則結果為左邊的值，否則為右邊的值）	a or b
not	非（如果值為 True，則結果為 False，如果值為 Flase，則結果為 True）	not a

示例：

a = False and 1
print('a 的結果為', a)  # 輸出：a 的結果為 False

b = True and 1
print('b 的結果為', b)  # 輸出：b 的結果為 1

c = True or 1
print('c 的結果為', c)  # 輸出：c 的結果為 True

d = False or 1
print('d 的結果為', d)  # 輸出：d 的結果為 1

e = not True
print('e 的結果為', e)  # 輸出：e 的結果為 False

f = not False
print('f 的結果為', f)  # 輸出：f 的結果為 True

5、位運算子

位運算子把數字看作二進位制來進行操作，包括 &（按位與）、|（按位或）、^（按位異或）、~（按位取反）、<<（左移）、>>（右移）。對於剛入門的小夥伴，知道有這個東西就行了。

6、成員運算子

成員運算子用於判斷某個資料是否屬於序列中資料的一員（是否在序列中），操作結果是一個布林值。

運算子	描述	示例
in	判斷資料是否在序列中	2 in a
not in	判斷資料是否不在序列中	2 not in a

序列包括字串、列表、元組、字典、集合。

示例：

data = [1, 2, 3, 4]

a = 2 in data
print('判斷 2 是否在列表中，結果為', a)  # 輸出：判斷 2 是否在列表中，結果為 True

b = 5 in data
print('判斷 5 是否在列表中，結果為', b)  # 輸出：判斷 5 是否在列表中，結果為 False

c = 2 not in data
print('判斷 2 是否不在列表中，結果為', c)  # 輸出：判斷 2 是否不在列表中，結果為 False

d = 5 not in data
print('判斷 5 是否不在列表中，結果為', d)  # 輸出：判斷 5 是否不在列表中，結果為 True

7、身份運算子

身份運算子用於判斷兩個資料的記憶體地址是否一樣，操作結果是一個布林值。

運算子	描述	示例
is	判斷兩個資料的記憶體地址是否一樣	a is b
is not	判斷兩個資料的記憶體地址是否不一樣	a is not b

身份運算子也用於比較資料，但比較資料時一般用 ==、!= 比較多，兩者的區別在於比較的內容不同。對於剛入門的小夥伴，只要會用 ==、!= 比較資料就足夠了，這個瞭解即可。

七、條件語句

條件語句用於控制根據不同的條件，執行不同操作的情況。

1、if 語句

語法格式：

if 條件1:
    執行操作1
elif 條件2:
    執行操作2
else:
    執行操作3

語句含義：如果滿足條件1，則執行操作1；否則如果滿足條件2，則執行操作2；否則，執行操作3。

• if 語句中的條件，必須是一個布林值，或者執行結果為布林值的表示式或函式。如果為 True，則執行相應操作，為 False 則不執行。
• if 語句中，if 子句必須要有，elif 子句可以 0 到多個，else 子句則可以沒有。
• elif 子句只有在前面的條件都不滿足，但是當前條件滿足時，才會執行相應的操作。
• else 子句是在所有條件都不滿足時，才會執行操作。

示例：根據分數判斷對應等級。

# 儲存分數的變數
score = 85
if score >= 85:
    print('優秀')
elif score >= 75:
    print('良好')
elif score >= 60:
    print('及格')
else:
    print('不及格')

2、if 語句變種

（1）if...else

語法格式：

if 條件:
    執行操作1
else:
    執行操作2

示例：

score = 85
if score >= 85:
    print('優秀')
else:
    print('不優秀')

（2）if...elif

語法格式：

if 條件1:
    執行操作1
elif 條件2:
    執行操作2

示例：

score = 85
if score >= 85:
    print('優秀')
elif score >= 75:
    print('良好')
elif score >= 60:
    print('及格')
elif score < 60:
    print('不及格')

（3）if...

語法格式：

if 條件:
    執行操作

示例：

score = 85
if score >= 85:
    print('優秀')

八、迴圈語句

迴圈語句用於控制當滿足條件時，重複執行某種操作的情況。

1、while 迴圈語句

語法格式：

while 條件:
    執行操作

語句含義：當滿足條件時，重複執行操作。

示例：計算 1 到 10 所有整數之和。

# 儲存總數的變數
sum = 0
# 儲存當前整數的變數
n = 1
# 噹噹前整數小於等於 10 時
while n <= 10:
    # 將當前整數加到總數裡面
    sum = sum + n
    # 將當前整數值加 1（即下一整數值）
    n = n + 1
print(sum)

2、for 迴圈語句

語法格式：

for 變數 in 可迭代物件:
    執行操作

語句含義：當可迭代物件中存在未迭代資料（未獲取過的資料）時，不斷地從裡面獲取資料，並把資料賦值給變數，然後執行操作，直到所有資料都獲取過一遍。

• 可迭代物件可以理解為一個數據包，裡面包含了許多資料，我們可以不斷地從裡面獲取資料。
• 基本資料型別中，字串、列表、元組、集合、字典都是可迭代物件。

示例：計算 1 到 10 所有整數之和。

# 儲存總數的變數
sum = 0
# 儲存所有整數的列表
nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 逐個獲取列表裡的整數，並賦值給變數 n
for n in nums:
    # 將變數 n 的值（即當前整數）加到總數裡面
    sum = sum + n
print(sum)

3、break 與 continue 語句

（1）break 語句

break 語句用於提前結束迴圈，此時不會執行剩餘的迴圈。

示例：列印 1 到 10 所有整數，如果碰到 7，則提前結束列印。

n = 1
while n <= 10:
    print(n)
    # 當 n 等於 7 時，結束迴圈
    if n == 7:
        break
    n = n + 1

（2）continue 語句

continue 語句用於跳過當前該次迴圈，直接執行下次迴圈。

示例：列印 1 到 10 所有整數，如果碰到 7，則不列印。

n = 0
while n < 10:
    n = n + 1
    # 當 n 等於 7 時，跳過該次迴圈
    if n == 7:
        continue
    print(n)

九、函式

前面我們已經知道，函式是對一系列實現特定功能的程式碼片段的封裝，相當於給一系列程式碼片段取名。

1、定義函式

語法格式：

def 函式名(引數1, 引數2, ..., 引數n):
    執行操作
    return 返回值

• 引數用於將資料傳入函式中，給函式內要執行的操作使用。
• return 返回值 用於返回一個執行結果，它可以放在函式內任何可能需要返回執行結果的地方。
• 如果函式不需要返回一個執行結果，那麼可以不用 return 返回值。

示例：

# 定義不帶返回值的函式
def max1(a, b):
    if a >= b:
        print('最大值：%s' % a)
    else:
        print('最大值：%s' % b)

# 定義帶返回值的函式
def max2(a, b):
    if a >= b:
        return a
    else:
        return b

2、呼叫函式

呼叫函式時，只需要使用函式名，並傳入需要的引數就行了。傳入的引數可以是值、變數、表示式、函式等，只要結果是一個數據就行。對於有返回值的函式，我們可以使用一個變數去接收返回值（即將返回值賦值給變數）。

語法格式：

函式名(引數1, 引數2, ..., 引數n)

示例：

# 呼叫不帶返回值的函式
max1(1, 2)

# 呼叫帶返回值的函式，並使用變數 r 接收返回值
r = max2(1, 2)

# 呼叫帶返回值的函式，但不接收返回值
max2(1, 2)

十、模組

在 Python 中，一個 Python 檔案（.py 檔案）就稱為一個模組。模組可以被其他程式引入，以使用模組中的函式等功能。

Python 中自帶了很多模組（稱為內建模組），這些模組可以幫助我們實現特定的功能。我們在編寫 Python 程式時，只需要匯入相應的模組，即可使用模組中的功能。也就是說，有些程式碼我們完全可以不用自己寫，直接匯入相應的模組白嫖就好了，省時又省力（白嫖黨理直氣壯）。

1、匯入模組

匯入模組的操作，一般放在檔案頂部（不考慮註釋）。

模組內的內容包含變數、函式、類。我們在編寫 Python 程式時，一般有三種匯入模組的方式（下面我們以函式為例）——

（1）匯入整個模組

可理解為把整個 Python 檔案都拿過來。匯入整個模組時，呼叫函式要使用 模組名.函式名() 的方式。

語法格式：

import 模組名

示例：

import math

a = math.ceil(3.5)
print(a)

（2）匯入模組內的指定函式

可理解為只把我們需要的函式拿過來，包含在我們的程式內。呼叫函式時直接使用 函式名() 即可。

語法格式：

from 模組名 import 函式名1, 函式名2, ..., 函式名n

示例：

from math import ceil, floor

a = ceil(3.5)
print(a)
b = floor(3.5)
print(b)

（3）匯入模組內的所有函式

相當於無論需不需要，先把所有函式都拿過來再說。呼叫函式時直接使用 函式名() 即可。

語法格式：

from 模組名 import *

一般不建議使用該方式。因為使用 import * 時，其實會將模組內的所有內容都導過來，除了會匯入很多不需要的內容外，還有可能會與自己的程式碼發生命名衝突。

示例：

from math import *

a = ceil(3.5)
print(a)

2、安裝第三方模組

如果 Python 自帶的模組滿足不了我們的需求，也可以使用別人提供的模組（稱為第三方模組）。使用別人提供的模組時，需要我們另外安裝——直接開啟命令列模式，輸入 pip install 模組名 回車，即可開始下載並安裝第三方模組。

示例：安裝 Pillow，Pillow 是一個影象處理工具庫。

Microsoft Windows [版本 10.0.19042.1110]
(c) Microsoft Corporation。保留所有權利。

C:\Users\10100>pip install Pillow
Collecting Pillow
  Downloading Pillow-8.3.1-1-cp39-cp39-win_amd64.whl (3.2 MB)
     |████████████████████████████████| 3.2 MB 6.8 MB/s
Installing collected packages: Pillow
Successfully installed Pillow-8.3.1

十一、異常處理

程式在執行時，有可能會出現各種異常，一旦出現了異常，程式將不會再往下執行。

但是有些異常其實無關緊要，即使發生了也不應該影響程式的正常執行。這時候我們就可以主動將異常捕獲，並進行異常處理，使其不影響程式的執行。除此之外，我們也可以根據具體情況，主動丟擲異常，來中斷程式的執行。

1、捕獲異常

語法格式：

try:
    執行業務操作
except 異常1 as 異常變數1:
    執行異常處理操作1
except 異常2 as 異常變數2:
    執行異常處理操作2
finally:
    執行必須操作

• try 子句用於執行我們自己的業務操作。
• except 子句用於在 try 子句發生指定異常時，執行對應的異常處理操作。可以有 0 至多個。
• finally 子句用於執行一些必須要執行的操作，無論 try 子句有沒有發生異常都不會影響 finally 子句的執行。
• except 子句與 finally 子句不是必須的，但是至少得有一個。
• 如果不知道 except 子句應該捕獲什麼異常，可以直接捕獲 Exception 異常，即 except Exception as 異常變數。

示例：

try:
    print('try 子句開始執行')
    r = 10 / 0
except Exception as e:
    print('except 子句捕獲到異常：', e)
finally:
    print('finally 子句開始執行')

2、丟擲異常

語法格式：

raise 異常

最簡單的寫法是直接丟擲一個 Exception 異常，即 raise Exception('異常提示資訊') 。

示例：

a = -1
if a < 1:
    raise Exception('a 的值不能小於 1')

十二、檔案讀寫

操作檔案前，我們要先使用 open() 函式開啟檔案，然後才可以對檔案進行讀寫操作。由於開啟檔案會佔用計算機資源，因此，讀寫操作完成後，要使用 close() 函式關閉檔案。

1、操作檔案寫法

（1）操作檔案一般寫法

# 開啟檔案
f = open('檔案路徑', '開啟模式', encoding='編碼格式')
# 操作檔案
...
# 操作檔案完成後，關閉檔案
f.close()

• 檔案路徑用於指定要操作的檔案。
• 開啟模式用於指定開啟檔案後，後續要以什麼模式來操作檔案。常用模式有 r、rb、w、wb 等。
  • r：只讀模式，用於從檔案中讀取內容，檔案必須事先存在。
  • rb：二進位制只讀模式，用於從二進位制檔案中讀取內容，檔案必須事先存在。一般用於圖片、視訊等非文字檔案。
  • w：只寫模式，用於往檔案中寫入內容，檔案不存在時會自動建立。
  • wb：二進位制只寫模式，用於往二進位制檔案中寫入內容，檔案不存在時會自動建立。一般用於圖片、視訊等非文字檔案。
• 編碼格式用於指定以哪種編碼字符集來開啟文字檔案。文字檔案儲存時會選擇一種編碼字符集來儲存內容，我們在開啟文字檔案時也要使用相同的編碼字符集，否則可能會導致內容錯亂。一般使用 utf-8 編碼字符集。
• 操作二進位制檔案時，不用指定編碼格式，只有文字檔案需要。

（2）操作檔案增強寫法

如果操作檔案過程中發生了異常，會導致 close() 函式不被執行。因此為了保證 close() 函式被執行，可以使用 try ... finally 語句。

try:
    # 開啟檔案
    f = open('檔案路徑', '開啟模式', encoding='編碼格式')
    # 操作檔案
    ...
finally:
    if f:
        # 操作檔案完成後，關閉檔案
        f.close()

（3）操作檔案優雅寫法（推薦）

使用 try ... finally 的寫法每次都要呼叫 close() 函式太麻煩了，Python 提供了 with 語句來幫我們自動呼叫 close() 函式。

with open('檔案路徑', '開啟模式', encoding='編碼格式') as f:
    # 操作檔案
    ...

2、讀檔案

開啟檔案後，可以使用 read()函式來從檔案中的讀取內容。

示例：讀取 D 盤 mypython 目錄下的 test.txt 檔案內容（事先要建立好檔案）。

try:
    # 以只寫模式開啟文字檔案
    f = open('D:\\mypython\\test.txt', 'r', encoding='utf-8')
    # 讀取內容
    print(f.read())
finally:  
    if f:
        # 操作檔案完成後，關閉檔案
        f.close()

3、寫檔案

開啟檔案後，可以使用 write()函式往檔案中寫入內容。

示例：

try:
    # 以只寫模式開啟文字檔案，指定編碼格式為 utf-8
    f = open('D:\\mypython\\test.txt', 'w', encoding='utf-8')
    # 寫入內容
    f.write('今天你學 Python 了嗎？')
finally:  
    if f:
        # 操作檔案完成後，關閉檔案
        f.close()

十三、面向物件

面向物件是一種程式設計思想，它把程式中涉及到的所有東西都看作一種物件——萬物皆物件。物件的含義是指具體的某一事物，即我們現實生活中看得見摸得著的事物。

現實生活中，所有事物都具有屬性和行為，比如貓具有品種、顏色、重量等屬性，以及吃飯、睡覺、賣萌等行為。因此，每個事物都可以用屬性和行為來描述。

Python 中的物件也具有屬性和行為（一般稱為方法），屬性通過變數來體現，而行為則通過函式來體現。也就是說，物件中包含了資料（儲存在變數中）和操作資料的函式。也可以把物件理解為帶有函式的資料。實際上，Python 中的所有資料都是物件。

對於面向物件，我們這裡只講如何建立一個簡單的物件，以及如何操作物件中的資料。如果有小夥伴打算深入學習，那麼建議一定要掌握面向物件的三大特性：封裝、繼承、多型。

1、如何建立物件

物件基於類建立，類是物件的模板。通過類這個模板，我們可以創建出各式各樣屬於同一個類，但是屬性和方法又有所不同的物件。

可以把類理解為事物的種類，同一種類下的事物雖然同屬一個種類，但是可能在某些屬性或行為上又有所不同。比如所有的貓都屬於貓這一種類，但是每隻貓的品種、毛色、重量都會有所不同。

（1）定義類

語法格式：

class 類名:

    def __init__(self, 屬性1, 屬性2, ...):
        self.屬性1 = 屬性1
        self.屬性2 = 屬性2
        ...

    def 方法1(self, 引數1, 引數2, ...):
        執行操作

    def 方法2(self, 引數1, 引數2, ...):
        執行操作

    ...

• 類中方法的第一個引數必須是 self，它代表物件本身。
• 我們可以通過方法的 self 引數，來操作物件資料或者呼叫物件內部的其他方法。

示例：定義一個貓的類

class Cat:

    def __init__(self, breed, color, weight):
        # 品種
        self.breed = breed
        # 毛色
        self.color = color
        # 重量（斤）
        self.weight = weight

    # 吃飯
    def eat(self):
        print('這隻%s開始吃魚了，都已經%s斤了還吃...' % (self.breed, self.weight))
        # 每次吃完魚後，重量增加1斤（太能吃了...）
        self.weight = self.weight + 1

    # 睡覺
    def sleep(self):
        print('這隻%s開始睡覺了...' % self.breed)

    # 賣萌
    def act_cute(self, toy):
        print('你給了%s一個%s，它開始賣萌了...' % (self.breed, toy))

（2）通過類建立物件

語法格式：

物件變數 = 類名(屬性1, 屬性2, ...)

示例：建立一隻貓的物件

cat = Cat('布偶貓', '白色', 10)

2、如何操作物件資料

我們可以通過物件的屬性和方法來操作物件的資料。

（1）通過屬性操作

建立完物件後，可以通過 物件.屬性名 的方式來操作物件的資料。

示例：

cat = Cat('布偶貓', '白色', 10)
# 獲取重量資料
w = cat.weight
# 更新重量資料
cat.weight = 15
# 新增暱稱資料
cat.nickname = '小白'

（2）通過方法操作

建立完物件後，可以通過 物件.方法名() 的方式來操作物件的資料。其實本質上是在方法內部通過物件的屬性操作資料。

示例：

cat = Cat('布偶貓', '白色', 10)
# 通過吃飯方法，更新重量資料
cat.eat()  # eat() 方法的實現見“示例：定義一個貓的類”

結語

終於肝完了~

本來打算儘量用最簡潔的語言來寫清楚的，但是又怕自己表述不清楚，結果不知不覺越寫越多，難搞。。。果然，我的語文都還給體育老師了！之前買的《寫作這回事》估計也等我很久了吧，是時候拿起來看一看了~

交流區

微信公眾號：驚卻一目
個人部落格：驚卻一目