小白的 Python 修煉手冊：入門篇

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() 方法的實現見“示例：定義一個貓的類”

結語

終於肝完了~

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

交流區

微信公眾號：驚卻一目
個人博客：驚卻一目