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

前言

聽說現(xiàn)在是全民 Python 的時代，雖然不知道事實如何，但學(xué)會 Python 的確可以做很多事。據(jù)我了解，Python 目前主要有五大用途：網(wǎng)站開發(fā)、網(wǎng)絡(luò)爬蟲、人工智能、數(shù)據(jù)分析、自動化運維。而對于職場人士來說，Python 則可以用來進(jìn)行自動化辦公。除此之外，如果你想自己開發(fā)一些小游戲、小工具，Python 也是一個不錯的選擇。

私信小編01即可獲取大量python學(xué)習(xí)資源

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

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

正文

從小白的日常說起

在學(xué)習(xí) Python 編程之前，我們先來看一個現(xiàn)實生活中可能出現(xiàn)的場景——

某天，小白下班回到家里，想起今天的《斗羅大陸》更新了。于是趕緊興沖沖地跑到電腦桌前，打開筆記本電腦，然后登錄騰訊視頻觀看最新一集的《斗羅大陸》。但是，看視頻怎么能少得了瓜子呢？于是，小白又從柜子里拿出了一包瓜子，磕著瓜子看著《斗羅大陸》，小白露出了滿意的笑容。

看到這里，你可能會一臉懵逼——這傻逼作者在講什么，這跟 Python 編程有什么關(guān)系嗎？但我要說的是，上述場景其實就是一個程序的執(zhí)行過程，它和計算機內(nèi)的程序執(zhí)行類似，只不過這個程序的執(zhí)行，是發(fā)生在我們所處的現(xiàn)實世界當(dāng)中。至于為什么這么說，我們下面就來看看——

一、現(xiàn)實世界 VS 計算機世界

在計算機的世界里，一個程序的執(zhí)行過程可以簡單地理解為：計算機從內(nèi)存中的指定地址獲取到所需數(shù)據(jù)，然后對該數(shù)據(jù)進(jìn)行某種操作，如此循環(huán)往復(fù)。

現(xiàn)在我們把小白回家日常的場景描述稍微改造一下：小白從家里的電腦桌上獲取到筆記本電腦，然后打開筆記本電腦觀看《斗羅大陸》。再從柜子里獲取到瓜子，開始邊嗑瓜子邊看《斗羅大陸》。

怎么樣？是不是跟計算機內(nèi)程序的執(zhí)行過程很相似。其實計算機從內(nèi)存中的指定地址獲取數(shù)據(jù)，就相當(dāng)于小白從家里的某個位置獲取某個物品。而計算機對數(shù)據(jù)的操作，就相當(dāng)于小白對物品的操作。

二、小白執(zhí)行手冊 VS Python 程序代碼

現(xiàn)在，假設(shè)小白是一個聽話的小白，無論你讓他做什么，他都會按你的要求一絲不茍的照做。于是你嘿嘿一笑，立馬給小白安排了 10 套暑假作業(yè)、20 套網(wǎng)絡(luò)課程、30 套健身計劃。小白很開心，并對你表示萬分感謝。

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

三、執(zhí)行手冊書寫格式 VS Python 編程語法

假設(shè)你是一個強迫癥患者，為了寫出一份美觀、簡潔的執(zhí)行手冊，你規(guī)定了一些書寫格式——

1、給物品取別名

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

別名 = 某個位置的物品

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

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

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

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

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

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

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

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

4、條件判斷的寫法

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

如果 某種條件:
    某種操作

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

5、重復(fù)操作的寫法

對于當(dāng)滿足某種條件時，需要一直重復(fù)進(jìn)行某種操作的情況，使用以下書寫格式：

當(dāng) 某種條件:
    某種操作

注意：這里的“當(dāng)”，是固定寫法。

規(guī)定好了執(zhí)行手冊的書寫格式后，只要讓小白學(xué)會怎么看懂這些書寫格式，那他就能根據(jù)你的執(zhí)行手冊自己去執(zhí)行了。

這些書寫格式就相當(dāng)于 Python 編程語言的語法。我們在編寫 Python 程序時，只要嚴(yán)格按照 Python 語法去編寫程序代碼，計算機就能理解并按你的要求去執(zhí)行了。

四、編寫小白執(zhí)行手冊 VS 編寫 Python 程序代碼

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

當(dāng) 暑假作業(yè)沒寫完10套:
    寫暑假作業(yè)()

當(dāng) 網(wǎng)絡(luò)課程沒學(xué)完20套:
    觀看網(wǎng)絡(luò)課程()

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

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

觀看網(wǎng)絡(luò)課程():
    筆記本電腦 = 電腦桌上的ThinkPad筆記本電腦
    打開筆記本電腦
    登錄網(wǎng)易云課堂
    觀看Python課程

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

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

看到如此簡單、優(yōu)雅的執(zhí)行手冊，是不是很令人身心舒暢？我們接下來要學(xué)習(xí)的 Python 編程語言就是一門簡單、優(yōu)雅的編程語言。

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

現(xiàn)在開始學(xué) Python

我們已經(jīng)知道了編寫 Python 程序的過程，其實就是給計算機編寫執(zhí)行手冊的過程。也知道了一個程序的執(zhí)行過程，就是不斷地根據(jù)地址從內(nèi)存中取數(shù)據(jù)，然后操作數(shù)據(jù)的過程。而 Python 程序在執(zhí)行過程中所涉及的東西，有些是計算機本身已有的，有些則是需要我們通過 Python 語言告訴計算機的。

1、程序執(zhí)行涉及的東西

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

（1）內(nèi)存

內(nèi)存是計算機內(nèi)用于存放程序運行時所需數(shù)據(jù)的地方，我們在編寫 Python 程序時涉及到的數(shù)據(jù)，在使用前都會存放在內(nèi)存中。

內(nèi)存由計算機自己管理，我們無法直接控制（可以通過一些優(yōu)化技巧來間接控制，但我們目前先不考慮這個），因此我們在編寫 Python 程序時不用管這個。

其實計算機會將內(nèi)存分配給 Python 虛擬機，然后由 Python 虛擬機負(fù)責(zé)管理內(nèi)存，但我們可以把 Python 虛擬機簡單地理解為計算機的一部分。

（2）數(shù)據(jù)

數(shù)據(jù)可以簡單地理解為存儲在計算機內(nèi)的東西。

計算機存儲數(shù)據(jù)的地方有磁盤和內(nèi)存：磁盤就是我們平常在 Windows 電腦上看到的 C 盤、D 盤等，可永久保存數(shù)據(jù)；內(nèi)存則負(fù)責(zé)臨時保存程序運行時所需要的數(shù)據(jù)，它無法永久保存數(shù)據(jù)。我們后面提到數(shù)據(jù)時，如果沒有特殊說明就是指內(nèi)存中的數(shù)據(jù)。

程序運行時，計算機會給這個程序分配一個內(nèi)存塊，這塊內(nèi)存一開始是沒有任何數(shù)據(jù)的。這就跟小白哪天搬了新家一樣，一開始家里是沒有任何東西的。因此我們在編寫 Python 程序時，就需要告訴計算機如何在內(nèi)存中生成數(shù)據(jù)，一般有以下三種生成數(shù)據(jù)的方式——

• 自己創(chuàng)建：后面我們會學(xué)到如何創(chuàng)建基本類型的數(shù)據(jù)以及自定義類型的數(shù)據(jù)。基本類型是 Python 本身提供的數(shù)據(jù)類型，而自定義類型則通過類和對象來創(chuàng)建（類和對象是面向?qū)ο缶幊讨械母拍睿@個我們后面會學(xué)到）。
• 從計算機本地磁盤讀取：后面我們要學(xué)的文件讀寫，就是用來處理來自計算機本地磁盤的數(shù)據(jù)的。
• 從網(wǎng)絡(luò)中讀?。河捎诒疚闹皇菐Т蠹胰腴T的，因此我們不講如何處理來自網(wǎng)絡(luò)中的數(shù)據(jù)，有興趣的可以自己百度下“Python 網(wǎng)絡(luò)編程”。

無論是自己創(chuàng)建的、從磁盤讀取的、還是從網(wǎng)絡(luò)中讀取的數(shù)據(jù)，最終都會存放在內(nèi)存中。

（3）數(shù)據(jù)在內(nèi)存中的地址

Python 程序在執(zhí)行過程中，所涉及到的數(shù)據(jù)都會在內(nèi)存中有一個對應(yīng)的地址。一旦需要這個數(shù)據(jù)，就能根據(jù)這個地址從內(nèi)存中獲取該數(shù)據(jù)。

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

• 變量：本質(zhì)上是一小塊內(nèi)存空間。在 Python 中，變量里存儲的是地址，而變量具有變量名，這個變量名就是地址的別名。由于計算機會自動將地址轉(zhuǎn)換成數(shù)據(jù)（從地址中獲取數(shù)據(jù)），因此，我們可以簡單地理解為變量里存儲的是數(shù)據(jù)，而變量名就是數(shù)據(jù)的別名。
• 賦值：將某一數(shù)值賦給某個變量的過程。在 Python 中，就是將地址值賦給某個變量的過程，這個過程相當(dāng)于給地址取別名。由于計算機會自動將地址轉(zhuǎn)換成數(shù)據(jù)（從地址中獲取數(shù)據(jù)），因此，我們可以把賦值簡單理解為給數(shù)據(jù)取別名。

（4）如何根據(jù)地址從內(nèi)存中獲取數(shù)據(jù)

計算機會自動根據(jù)變量名找到對應(yīng)的地址，再從該地址獲取數(shù)據(jù)。我們在編寫 Python 程序時不用管這個。

（5）對數(shù)據(jù)進(jìn)行何種操作

由于對數(shù)據(jù)進(jìn)行什么操作，是由我們的意愿決定的。因此，我們在編寫 Python 程序時，就必須告訴計算機如何操作數(shù)據(jù)。

一般操作數(shù)據(jù)有兩種方式——

• 運算符：也叫操作符，其實就跟數(shù)學(xué)里的加、減、乘、除等運算符一樣。
• 函數(shù)：函數(shù)中封裝了一系列代碼片段，該代碼片段一般用于實現(xiàn)特定功能。跟我們前面說的給一系列步驟取一個行為名類似，函數(shù)就相當(dāng)于給一系列代碼片段取一個名稱（函數(shù)名）。

（6）當(dāng)存在多個操作時，如何控制操作的流程

當(dāng)存在多個操作時，我們必須告訴計算機哪個操作先執(zhí)行，哪個后執(zhí)行。否則，計算機將無法正常執(zhí)行程序。

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

• 順序控制：從上往下依次執(zhí)行代碼。程序執(zhí)行時，默認(rèn)就是順序執(zhí)行。
• 選擇控制：根據(jù)不同條件，執(zhí)行不同代碼。后面我們要學(xué)的條件語句，就是用來進(jìn)行選擇控制的。
• 循環(huán)控制：根據(jù)指定條件，重復(fù)執(zhí)行某段代碼。后面我們要學(xué)的循環(huán)語句，就是用來進(jìn)行循環(huán)控制的。

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

現(xiàn)在，我們來總結(jié)一下，在編寫 Python 程序時，一般需要做哪些事情——

1. 生成數(shù)據(jù)：創(chuàng)建基本類型數(shù)據(jù)、創(chuàng)建自定義數(shù)據(jù)（類、對象）、從磁盤中讀取、從網(wǎng)絡(luò)中讀取。
2. 給數(shù)據(jù)取別名：變量、賦值。
3. 操作數(shù)據(jù)：運算符（操作符）、函數(shù)。
4. 控制操作數(shù)據(jù)的流程：順序、選擇、循環(huán)。

一、Python 安裝與運行

1、Python 安裝

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

（1）下載 Python 安裝包

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

• 32 位 Windows 系統(tǒng)： https://www./ftp/python/3.9.6/python-3.9.6.exe
• 64 位 Windows 系統(tǒng)： https://www./ftp/python/3.9.6/python-3.9.6-amd64.exe

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

（2）安裝 Python

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

如果不想使用默認(rèn)安裝，也可以選擇“Customize installation”進(jìn)行自定義安裝。

（3）檢查是否安裝成功

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

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

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”，這時候就需要修改環(huán)境變量，把 python.exe 所在路徑添加在 Path 中。如果不知道怎么修改環(huán)境變量，可以直接卸載重裝。

2、Python 運行

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

（1）命令行模式運行 Python

按下 Windows 鍵 + R 鍵，在彈出的輸入框內(nèi)輸入“cmd”，敲回車，即可進(jìn)入命令行模式。

在命令行模式下，可進(jìn)入 Python 文件（.py 文件）所在目錄，輸入 python 文件名.py 后敲回車，來運行 Python 文件。

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

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

D:\mypython>python hello.py
hello world

也可以直接輸入 python 文件完整路徑 ，而不用進(jìn)入 Python 文件所在目錄。

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

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

（2）交互模式運行 Python

進(jìn)入命令行模式后，輸入 python ，敲回車，即可進(jìn)入交互模式。輸入 exit() ，敲回車，即可退出交互模式。

在交互模式下，會有 >>> 提示符， >>> 后可直接編寫 Python 代碼。編寫完后敲回車，即可執(zhí)行代碼。

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

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）集成開發(fā)環(huán)境（IDE）運行 Python

集成開發(fā)環(huán)境（IDE）可理解為用于編寫 Python 程序的一整套工具，只不過這些工具被集中放在一個軟件內(nèi)。比如 PyCharm 或者裝了相關(guān)插件的 Visual Studio Code（簡稱 VS Code）。

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

二、第一個 Python 程序

這里推薦使用 VS Code 來編寫 Python 程序，推薦理由很簡單——它的界面清爽、干凈，看起來賊舒服（一個不太正經(jīng)的理由，勿噴，謝謝）！除此之外，VS Code 也可以通過安裝插件來集成更多的功能。

1、安裝 VS Code

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

安裝過程中，注意勾選上“創(chuàng)建桌面快捷方式”的選項，其他按默認(rèn)的來就行。

2、使用 VS Code 編寫程序

現(xiàn)在，我們來使用 VS Code 編寫一個打印“hello world”的 Python 程序——

（1）創(chuàng)建新文件

點擊左上角的 File -> New File（或者按 Ctrl + N）即可創(chuàng)建新文件。

（2）編寫代碼

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

print() 函數(shù)用于在控制臺打印內(nèi)容。

（3）保存文件

點擊左上角的 File -> Save（或者按 Ctrl + S），在彈出框內(nèi)選擇保存路徑（圖例中保存在 D:\mypython），并命名為 hello.py 后點擊保存。

（4）執(zhí)行程序文件

點擊 View -> Terminal（或者按 Ctrl + `（數(shù)字 1 左邊的鍵））打開命令行終端，在命令行終端內(nèi)輸入 python 文件完整路徑 （文件完整路徑要與上一步的保存路徑對應(yīng)，圖例中為 python D:\mypython\hello.py ）回車，即可執(zhí)行程序。

3、給 VS Code 安裝 Python 插件

如果每次執(zhí)行 Python 程序，都要在命令行終端手動輸入命令就太麻煩了。因此，我們可以給 VS Code 安裝一個 Python 插件，這個插件不僅可以方便我們執(zhí)行程序，也可以幫助我們進(jìn)行代碼提示、代碼檢查等。

安裝步驟：

（1）打開插件市場

點擊 View -> Extensions（或者按 Ctrl + Shift + X，又或者點擊左側(cè)活動欄的第五個圖標(biāo)）打開插件市場。

（2）搜索插件并安裝

在插件市場的搜索框內(nèi)輸入“python”搜索插件，找到名為“Python”的插件（一般在第一個），點擊“Install”即可進(jìn)行安裝。

安裝完 Python 插件后，在編輯欄內(nèi)點擊右鍵 -> Run Python File in Terminal，即可執(zhí)行 Python 文件。

三、Python 基本代碼結(jié)構(gòu)

現(xiàn)在我們來看一下 Python 文件的基本代碼結(jié)構(gòu)，先有個整體性的認(rèn)識。看得懂最好，看不懂也沒關(guān)系，可以等學(xué)完后再回過頭來看。

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

'''
該模塊用于展示 Python 基本代碼結(jié)構(gòu)
'''
                                        # 模塊說明

import sys, os                          # 導(dǎo)入模塊

debug = True                            # 定義全局變量

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

def func():                             # 定義函數(shù)
    pass

if __name__ == '__main__':              # 是否主函數(shù)，只有該文件作為執(zhí)行入口時，下面代碼才會執(zhí)行，一般用于測試本模塊
    c = ClassName()
    func()

• pass 是空語句，可以起占位作用。當(dāng)你還沒寫業(yè)務(wù)代碼時，可以使用 pass 來保持語法結(jié)構(gòu)的完整性。
• if __name__ == '__main__' 用于判斷當(dāng)前文件是不是程序的執(zhí)行入口。當(dāng)通過當(dāng)前文件執(zhí)行程序時，下面的代碼就會被執(zhí)行，一般用于測試本模塊中的代碼。

四、基礎(chǔ)語法

1、變量與賦值

變量用于存儲數(shù)據(jù)，而賦值就是將數(shù)據(jù)存到變量的過程（給數(shù)據(jù)取別名）。

Python 中，可以使用任意數(shù)據(jù)給變量重新賦值，此時新的數(shù)據(jù)會替換舊的數(shù)據(jù)。

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

=

示例：

# 將數(shù)字?jǐn)?shù)據(jù)賦值給變量 a
a = 1
# 將列表數(shù)據(jù)賦值給變量 a
a = [1, 2, 3]

# 將表達(dá)式 1 + 2 的結(jié)果值賦值給變量 b
b = 1 + 2
# 將表達(dá)式 b + 1 的結(jié)果值賦值給變量 b
b = b + 1

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

全局變量與局部變量：

• 全局變量：定義在函數(shù)外的變量。全局變量在任何地方都能使用。
• 局部變量：定義在函數(shù)內(nèi)的變量。局部變量只能在函數(shù)內(nèi)使用。

2、標(biāo)識符

標(biāo)識符用于給變量、函數(shù)等命名。換句話說，我們給變量、函數(shù)等取的名稱，就是標(biāo)識符。

標(biāo)識符組成規(guī)則：

• 由字母、數(shù)字、下劃線組成。
• 第一個字符必須是字母或下劃線。
• 區(qū)分大小寫。

3、關(guān)鍵字

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

不能使用關(guān)鍵字作為標(biāo)識符。

我們使用的 Python 3.9.6 版本有 36 個關(guān)鍵字： 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、注釋

注釋是用來解釋代碼的。

為了防止自己以后或者別人看不懂代碼，我們可以使用注釋來解釋你的代碼是用來干嘛的或者為什么要這么寫。計算機在執(zhí)行 Python 代碼時，會自動忽略注釋內(nèi)容。

其實負(fù)責(zé)執(zhí)行 Python 代碼的是 Python 解釋器，它會將 Python 語言翻譯成計算機能看得懂的機器語言。但我們可以把 Python 解釋器簡單地理解為計算機的一部分。

（1）單行注釋

單行注釋以 # 開頭， # 后為注釋內(nèi)容。

示例：

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

（2）多行注釋

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

示例：

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

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

5、縮進(jìn)

Python 中使用縮進(jìn)來表示代碼塊。同一層級（包含子層級）的代碼堆疊在一起，就是代碼塊?？s進(jìn)可以使用 Tab 符號或空格，但同一代碼塊內(nèi)不能混用。一般使用 4 個空格作為 1 個縮進(jìn)。

關(guān)于如何縮進(jìn)，我們只需要記住以下兩點：

示例：

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

以上代碼可以提取出 3 個代碼塊：

• 代碼塊 1：由所有代碼構(gòu)成，包含 0 個縮進(jìn)。
• 代碼塊 2：由 print('a 是負(fù)數(shù)') 和 a = -a 構(gòu)成，包含 1 個縮進(jìn)。
• 代碼塊 3：由 print('a 不是負(fù)數(shù)') 單獨構(gòu)成，包含 1 個縮進(jìn)。

由于代碼塊 2 和代碼塊 3 緊跟在 : 后面，需要再次縮進(jìn)，因此包含 1 個縮進(jìn)。

五、基本數(shù)據(jù)類型

Python 提供了六種基本數(shù)據(jù)類型，用于給我們創(chuàng)建基本類型的數(shù)據(jù)，包括數(shù)字、字符串、列表、元組、字典、集合。

根據(jù)數(shù)據(jù)創(chuàng)建完后可不可以被修改，可分為：

• 不可變數(shù)據(jù)：數(shù)字、字符串、元組。
• 可變數(shù)據(jù)：列表、字典、集合。

可以使用 type() 函數(shù)來查看數(shù)據(jù)的類型：

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

1、數(shù)字

Python 中的數(shù)字類型包含：整數(shù)、浮點數(shù)、布爾類型、復(fù)數(shù)。

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

（1）創(chuàng)建數(shù)字

語法格式：

變量 = 數(shù)字值

示例：

# 創(chuàng)建整數(shù)，并賦值給變量 a
a = 1

# 創(chuàng)建浮點數(shù)，并賦值給變量 b
b = 1.2

# 創(chuàng)建布爾類型數(shù)據(jù)，并賦值給變量 c
c = True

# 創(chuàng)建復(fù)數(shù)，并賦值給變量 d
d = 1 + 2j

（2）常見數(shù)字操作

表格中， x 、 x1 、 x2 為要操作的數(shù)字， r 為接收操作結(jié)果的變量。

示例：

import math

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

# 將數(shù)字轉(zhuǎn)換為整數(shù)
r = int(1.2)
print('1.2 轉(zhuǎn)換為整數(shù)的結(jié)果為', r)  # 輸出：1.2 轉(zhuǎn)換為整數(shù)的結(jié)果為 1

# 將數(shù)字轉(zhuǎn)換為浮點數(shù)
r = float(1)
print('1 轉(zhuǎn)換為浮點數(shù)的結(jié)果為', r)  # 輸出：1 轉(zhuǎn)換為浮點數(shù)的結(jié)果為 1.0

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

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

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

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

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

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

2、字符串

字符串可理解為文本。

（1）創(chuàng)建字符串

Python 中使用成對的 ' （英文單引號）或 " （英文雙引號）來創(chuàng)建字符串。

• 由于 ' 、 " 用于創(chuàng)建字符串，因此不能隨意出現(xiàn)在字符串內(nèi)容中，此時，我們可以用 \' 、 \" 來代替。 \ 稱為轉(zhuǎn)義符，可以將某個符號的含義轉(zhuǎn)成另一種含義。（也可以交替使用 ' 、 " 或者使用三引號（ ''' 、 """ ），這個我們不細(xì)講。）
• 注意字符串中的內(nèi)容哪怕跟代碼再像，它也不是代碼。因此，如果看到字符串中出現(xiàn)了跟變量、表達(dá)式等一樣的內(nèi)容，那它們也不是變量或表達(dá)式。
• 注意不要混淆數(shù)字字符串與數(shù)字，數(shù)字字符串形如 '123' ，數(shù)字形如 123 。

語法格式：

變量 = '字符串內(nèi)容'
變量 = "字符串內(nèi)容"

示例：

# 創(chuàng)建字符串，并賦值給變量 s
s = '在學(xué) Python，很忙！'
s = "在學(xué) Python，很忙！"

# 創(chuàng)建包含單引號的字符串，并賦值給變量 s
s = '在學(xué) \'Python\'，很忙！'
s = "在學(xué) 'Python'，很忙！"

# 創(chuàng)建包含雙引號的字符串，并賦值給變量 s
s = "在學(xué) \"Python\"，很忙！"
s = '在學(xué) "Python"，很忙！'

# 創(chuàng)建內(nèi)容與代碼相似的字符串，并賦值給變量 s
s = 'a + 1'  # 這里的 a + 1 不是表達(dá)式代碼，只是長得像而已

# 創(chuàng)建數(shù)字字符串，并賦值給變量 s
s = '123'

# 創(chuàng)建空字符串，并賦值給變量 s
s = ''
s = ""

（2）常見字符串操作

表格中， x 、 x1 、 x2 為要操作的字符串， r 為接收操作結(jié)果的變量。

示例：

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

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

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

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

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

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

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

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

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

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

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

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

3、列表

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

列表的每個位置也帶有序號，序號從 0 開始，依次遞增，這個序號被稱為索引，每個位置存儲的數(shù)據(jù)被稱為元素。列表中可存放不同類型的數(shù)據(jù)，并且可以隨時添加、刪除里面的數(shù)據(jù)。

（1）創(chuàng)建列表

Python 中使用 [] 來創(chuàng)建列表，并使用 , （英文逗號）分隔各個數(shù)據(jù)。

語法格式：

變量 = [數(shù)據(jù)1, 數(shù)據(jù)2, ..., 數(shù)據(jù)n]

示例：

# 創(chuàng)建名字列表，并賦值給變量 names
names = ['小白', '小黑', 'Tom', 'Jerry']

# 創(chuàng)建分?jǐn)?shù)列表，并賦值給變量 scores
scores = [90, 80, 85, 85]

# 創(chuàng)建包含名字和分?jǐn)?shù)的列表，并賦值給變量 data
data = ['小白', '小黑', 'Tom', 'Jerry', 90, 80, 85, 85]

# 創(chuàng)建空列表，并賦值給變量 data
data = []

（2）常見列表操作

表格中， x 、 x1 、 x2 為要操作的列表， r 為接收操作結(jié)果的變量。

示例：

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

# 根據(jù)索引修改列表中的數(shù)據(jù)
x = [0, 1, 2, 3, 4, 5]
x[1] = 3
print('索引 1 的數(shù)據(jù)修改后為', x[1])  # 輸出：索引 1 的數(shù)據(jù)修改后為 3

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

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

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

# 判斷數(shù)據(jù)是否在列表中
x = [0, 1, 2, 3, 4, 5]
r = 2 in x
print('判斷 2 是否在列表中，結(jié)果為', r)  # 輸出：判斷 2 是否在列表中，結(jié)果為 True

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

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

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

# 在列表末尾添加新數(shù)據(jù)
x = [0, 1, 2, 3, 4, 5]
x.append(6)
print('在列表末尾添加新數(shù)據(jù)后，列表為', x)  # 輸出：在列表末尾添加新數(shù)據(jù)后，列表為 [0, 1, 2, 3, 4, 5, 6]

# 刪除列表中第一個匹配數(shù)據(jù)
x = [0, 1, 2, 3, 4, 5]
x.remove(2)
print('刪除列表中第一個匹配數(shù)據(jù)后，列表為', x)  # 輸出：刪除列表中第一個匹配數(shù)據(jù)后，列表為 [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、元組

元組與列表基本類似，不同之處在于元組內(nèi)的數(shù)據(jù)不能被修改。

（1）創(chuàng)建元組

Python 中使用 () 來創(chuàng)建元組，并使用 , （英文逗號）分隔各個數(shù)據(jù)。

語法格式：

變量 = (數(shù)據(jù)1, 數(shù)據(jù)2, ..., 數(shù)據(jù)n)

創(chuàng)建只有一個數(shù)據(jù)的元組時，必須在數(shù)據(jù)后面加 , ，否則 () 會被當(dāng)做運算符，此時創(chuàng)建的將不是一個元組。

示例：

# 創(chuàng)建名字元組，并賦值給變量 names
names = ('小白', '小黑', 'Tom', 'Jerry')

# 創(chuàng)建分?jǐn)?shù)元組，并賦值給變量 scores
scores = (90, 80, 85, 85)

# 創(chuàng)建包含名字和分?jǐn)?shù)的元組，并賦值給變量 data
data = ('小白', '小黑', 'Tom', 'Jerry', 90, 80, 85, 85)

# 創(chuàng)建只有一個數(shù)據(jù)的元組，并賦值給變量 data
data = (90,)

# 創(chuàng)建空元組，并賦值給變量 data
data = ()

（2）常見元組操作

表格中， x 、 x1 、 x2 為要操作的元組， r 為接收操作結(jié)果的變量。

示例：

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

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

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

# 判斷數(shù)據(jù)是否在元組中
x = (0, 1, 2, 3, 4, 5)
r = 2 in x
print('判斷 2 是否在元組中，結(jié)果為', r)  # 輸出：判斷 2 是否在元組中，結(jié)果為 True

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

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

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

5、字典

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

字典中存儲了鍵值對（鍵和值），鍵對應(yīng)《新華字典》中的漢字，值對應(yīng)《新華字典》中的漢字解釋。鍵可理解為別名，值為對應(yīng)的數(shù)據(jù)，我們可以根據(jù)鍵從字典中找到對應(yīng)的值。

字典中的鍵必須唯一，而值則不用。另外，鍵必須是不可變的（比如數(shù)字、字符串），而值可以是任何數(shù)據(jù)類型。

（1）創(chuàng)建字典

Python 中使用 {:} 來創(chuàng)建字典， : （英文冒號）用于創(chuàng)建鍵值對，并使用 , （英文逗號）分隔各個鍵值對。

語法格式：

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

示例：

# 創(chuàng)建保存學(xué)生信息的字典，并賦值給變量 student
student = {'名字': '小白', '分?jǐn)?shù)': 90}

# 創(chuàng)建保存座位號及對應(yīng)學(xué)生名字的字典，并賦值給變量 seats
seats = {1: '小白', 2: '小黑', 3: 'Tom', 4: 'Jerry'}

# 創(chuàng)建保存名字及對應(yīng)分?jǐn)?shù)的字典，并賦值給變量 data
data = {'小白': 90, '小黑': 80, 'Tom': 85, 'Jerry': 85}

# 創(chuàng)建空字典，并賦值給變量 data
data = {}

（2）常見字典操作

表格中， x 為要操作的元組， r 為接收操作結(jié)果的變量。

示例：

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

# 新增數(shù)據(jù)
x = {'name': '小白', 'age': 17}
x['country'] = '中國'
print('新增數(shù)據(jù)后字典為', x)  # 輸出：增數(shù)據(jù)后字典為 {'name': '小白', 'age': 17, 'country': '中國'}

# 修改數(shù)據(jù)
x = {'name': '小白', 'age': 17}
x['age'] = 27
print('鍵為 age 的數(shù)據(jù)修改后為', x['age'])  # 輸出：鍵為 age 的數(shù)據(jù)修改后為 27

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

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

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

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

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

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

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

6、集合

Python 中的集合可理解為無序的、不重復(fù)的列表，集合中存儲的數(shù)據(jù)是無序的、不重復(fù)的。集合中可存放不同類型的數(shù)據(jù)。

• 由于集合是無序的，因此沒有索引，我們不能根據(jù)索引獲取數(shù)據(jù)。
• 由于集合是不重復(fù)的，因此即使我們保存了重復(fù)的數(shù)據(jù)，最終也只會保留一個。

（1）創(chuàng)建集合

Python 中使用 {} 創(chuàng)建集合，并使用 , （英文逗號）分隔各個數(shù)據(jù)。

語法格式：

變量 = {數(shù)據(jù)1, 數(shù)據(jù)2, ..., 數(shù)據(jù)n}

示例：

# 創(chuàng)建名字列表，并賦值給變量 names
names = {'小白', '小黑', 'Tom', 'Jerry'}

# 創(chuàng)建分?jǐn)?shù)列表，并賦值給變量 scores
scores = {90, 80, 85, 85}  # 兩個 85，最終只會保留一個

# 創(chuàng)建包含名字和分?jǐn)?shù)的列表，并賦值給變量 data
data = {'小白', '小黑', 'Tom', 'Jerry', 90, 80, 85, 85}  # 兩個 85，最終只會保留一個

# 創(chuàng)建空集合，并賦值給變量 data
data = set()  # 注意：{} 用于創(chuàng)建空字典，因此創(chuàng)建空集合不能用 {}

（2）常見集合操作

表格中， x 為要操作的元組， r 為接收操作結(jié)果的變量。

示例：

# 添加數(shù)據(jù)
x = {0, 1, 2, 3, 4, 5}
x.add(6)
print('添加數(shù)據(jù)后集合為', x)  # 輸出：添加數(shù)據(jù)后集合為 {0, 1, 2, 3, 4, 5, 6}

# 刪除數(shù)據(jù)
x = {0, 1, 2, 3, 4, 5}
x.remove(3)
print('刪除數(shù)據(jù)集合為', x)  # 輸出：刪除數(shù)據(jù)集合為 {0, 1, 2, 4, 5}

# 判斷數(shù)據(jù)是否在集合中
x = {0, 1, 2, 3, 4, 5}
r = 2 in x
print('判斷 2 是否在集合中，結(jié)果為', r)  # 輸出：判斷 2 是否在集合中，結(jié)果為 True

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

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

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

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

六、運算符

Python 提供了七種類型的運算符，用于給我們操作數(shù)據(jù)。

1、算術(shù)運算符

算術(shù)運算符用于對數(shù)據(jù)進(jìn)行算術(shù)運算。

示例：

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

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

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

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

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

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

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

2、比較（關(guān)系）運算符

比較運算符用于比較兩個數(shù)據(jù)的關(guān)系，操作結(jié)果是一個布爾值。

示例：

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

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

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

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

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

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

3、賦值運算符

賦值運算符用于給變量賦值。最常用的賦值運算符為 = （簡單賦值），對于剛?cè)腴T的小伙伴，只需要會用這個就足夠了。

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

示例：

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

4、邏輯運算符

邏輯運算符用于根據(jù)已有的一個或多個條件計算出最終結(jié)果，操作結(jié)果是一個布爾值。

示例：

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

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

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

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

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

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

5、位運算符

位運算符把數(shù)字看作二進(jìn)制來進(jìn)行操作，包括 & （按位與）、 | （按位或）、 ^ （按位異或）、 ~ （按位取反）、 << （左移）、 >> （右移）。對于剛?cè)腴T的小伙伴，知道有這個東西就行了。

6、成員運算符

成員運算符用于判斷某個數(shù)據(jù)是否屬于序列中數(shù)據(jù)的一員（是否在序列中），操作結(jié)果是一個布爾值。

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

示例：

data = [1, 2, 3, 4]

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

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

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

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

7、身份運算符

身份運算符用于判斷兩個數(shù)據(jù)的內(nèi)存地址是否一樣，操作結(jié)果是一個布爾值。

身份運算符也用于比較數(shù)據(jù)，但比較數(shù)據(jù)時一般用 == 、 != 比較多，兩者的區(qū)別在于比較的內(nèi)容不同。對于剛?cè)腴T的小伙伴，只要會用 == 、 != 比較數(shù)據(jù)就足夠了，這個了解即可。

七、條件語句

條件語句用于控制根據(jù)不同的條件，執(zhí)行不同操作的情況。

1、if 語句

語法格式：

if 條件1:
    執(zhí)行操作1
elif 條件2:
    執(zhí)行操作2
else:
    執(zhí)行操作3

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

• if 語句中的條件，必須是一個布爾值，或者執(zhí)行結(jié)果為布爾值的表達(dá)式或函數(shù)。如果為 True ，則執(zhí)行相應(yīng)操作，為 False 則不執(zhí)行。
• if 語句中， if 子句必須要有， elif 子句可以 0 到多個， else 子句則可以沒有。
• elif 子句只有在前面的條件都不滿足，但是當(dāng)前條件滿足時，才會執(zhí)行相應(yīng)的操作。
• else 子句是在所有條件都不滿足時，才會執(zhí)行操作。

示例：根據(jù)分?jǐn)?shù)判斷對應(yīng)等級。

# 存儲分?jǐn)?shù)的變量
score = 85
if score >= 85:
    print('優(yōu)秀')
elif score >= 75:
    print('良好')
elif score >= 60:
    print('及格')
else:
    print('不及格')

2、if 語句變種

（1）if...else

語法格式：

if 條件:
    執(zhí)行操作1
else:
    執(zhí)行操作2

示例：

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

（2）if...elif

語法格式：

if 條件1:
    執(zhí)行操作1
elif 條件2:
    執(zhí)行操作2

示例：

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

（3）if...

語法格式：

if 條件:
    執(zhí)行操作

示例：

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

八、循環(huán)語句

循環(huán)語句用于控制當(dāng)滿足條件時，重復(fù)執(zhí)行某種操作的情況。

1、while 循環(huán)語句

語法格式：

while 條件:
    執(zhí)行操作

語句含義：當(dāng)滿足條件時，重復(fù)執(zhí)行操作。

示例：計算 1 到 10 所有整數(shù)之和。

# 存儲總數(shù)的變量
sum = 0
# 存儲當(dāng)前整數(shù)的變量
n = 1
# 當(dāng)當(dāng)前整數(shù)小于等于 10 時
while n <= 10:
    # 將當(dāng)前整數(shù)加到總數(shù)里面
    sum = sum + n
    # 將當(dāng)前整數(shù)值加 1（即下一整數(shù)值）
    n = n + 1
print(sum)

2、for 循環(huán)語句

語法格式：

for 變量 in 可迭代對象:
    執(zhí)行操作

語句含義：當(dāng)可迭代對象中存在未迭代數(shù)據(jù)（未獲取過的數(shù)據(jù)）時，不斷地從里面獲取數(shù)據(jù)，并把數(shù)據(jù)賦值給變量，然后執(zhí)行操作，直到所有數(shù)據(jù)都獲取過一遍。

• 可迭代對象可以理解為一個數(shù)據(jù)包，里面包含了許多數(shù)據(jù)，我們可以不斷地從里面獲取數(shù)據(jù)。
• 基本數(shù)據(jù)類型中，字符串、列表、元組、集合、字典都是可迭代對象。

示例：計算 1 到 10 所有整數(shù)之和。

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

3、break 與 continue 語句

（1）break 語句

break 語句用于提前結(jié)束循環(huán)，此時不會執(zhí)行剩余的循環(huán)。

示例：打印 1 到 10 所有整數(shù)，如果碰到 7，則提前結(jié)束打印。

n = 1
while n <= 10:
    print(n)
    # 當(dāng) n 等于 7 時，結(jié)束循環(huán)
    if n == 7:
        break
    n = n + 1

（2）continue 語句

continue 語句用于跳過當(dāng)前該次循環(huán)，直接執(zhí)行下次循環(huán)。

示例：打印 1 到 10 所有整數(shù)，如果碰到 7，則不打印。

n = 0
while n < 10:
    n = n + 1
    # 當(dāng) n 等于 7 時，跳過該次循環(huán)
    if n == 7:
        continue
    print(n)

九、函數(shù)

前面我們已經(jīng)知道，函數(shù)是對一系列實現(xiàn)特定功能的代碼片段的封裝，相當(dāng)于給一系列代碼片段取名。

1、定義函數(shù)

語法格式：

def 函數(shù)名(參數(shù)1, 參數(shù)2, ..., 參數(shù)n):
    執(zhí)行操作
    return 返回值

return 返回值
return 返回值

示例：

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

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

2、調(diào)用函數(shù)

調(diào)用函數(shù)時，只需要使用函數(shù)名，并傳入需要的參數(shù)就行了。傳入的參數(shù)可以是值、變量、表達(dá)式、函數(shù)等，只要結(jié)果是一個數(shù)據(jù)就行。對于有返回值的函數(shù)，我們可以使用一個變量去接收返回值（即將返回值賦值給變量）。

語法格式：

函數(shù)名(參數(shù)1, 參數(shù)2, ..., 參數(shù)n)

示例：

# 調(diào)用不帶返回值的函數(shù)
max1(1, 2)

# 調(diào)用帶返回值的函數(shù)，并使用變量 r 接收返回值
r = max2(1, 2)

# 調(diào)用帶返回值的函數(shù)，但不接收返回值
max2(1, 2)

十、模塊

在 Python 中，一個 Python 文件（.py 文件）就稱為一個模塊。模塊可以被其他程序引入，以使用模塊中的函數(shù)等功能。

Python 中自帶了很多模塊（稱為內(nèi)置模塊），這些模塊可以幫助我們實現(xiàn)特定的功能。我們在編寫 Python 程序時，只需要導(dǎo)入相應(yīng)的模塊，即可使用模塊中的功能。也就是說，有些代碼我們完全可以不用自己寫，直接導(dǎo)入相應(yīng)的模塊白嫖就好了，省時又省力（白嫖黨理直氣壯）。

1、導(dǎo)入模塊

導(dǎo)入模塊的操作，一般放在文件頂部（不考慮注釋）。

模塊內(nèi)的內(nèi)容包含變量、函數(shù)、類。我們在編寫 Python 程序時，一般有三種導(dǎo)入模塊的方式（下面我們以函數(shù)為例）——

（1）導(dǎo)入整個模塊

可理解為把整個 Python 文件都拿過來。導(dǎo)入整個模塊時，調(diào)用函數(shù)要使用 模塊名.函數(shù)名() 的方式。

語法格式：

import 模塊名

示例：

import math

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

（2）導(dǎo)入模塊內(nèi)的指定函數(shù)

可理解為只把我們需要的函數(shù)拿過來，包含在我們的程序內(nèi)。調(diào)用函數(shù)時直接使用 函數(shù)名() 即可。

語法格式：

from 模塊名 import 函數(shù)名1, 函數(shù)名2, ..., 函數(shù)名n

示例：

from math import ceil, floor

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

（3）導(dǎo)入模塊內(nèi)的所有函數(shù)

相當(dāng)于無論需不需要，先把所有函數(shù)都拿過來再說。調(diào)用函數(shù)時直接使用 函數(shù)名() 即可。

語法格式：

from 模塊名 import *

一般不建議使用該方式。因為使用 import * 時，其實會將模塊內(nèi)的所有內(nèi)容都導(dǎo)過來，除了會導(dǎo)入很多不需要的內(nèi)容外，還有可能會與自己的代碼發(fā)生命名沖突。

示例：

from math import *

a = ceil(3.5)
print(a)

2、安裝第三方模塊

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

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

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

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

十一、異常處理

程序在執(zhí)行時，有可能會出現(xiàn)各種異常，一旦出現(xiàn)了異常，程序?qū)⒉粫偻聢?zhí)行。

但是有些異常其實無關(guān)緊要，即使發(fā)生了也不應(yīng)該影響程序的正常執(zhí)行。這時候我們就可以主動將異常捕獲，并進(jìn)行異常處理，使其不影響程序的執(zhí)行。除此之外，我們也可以根據(jù)具體情況，主動拋出異常，來中斷程序的執(zhí)行。

1、捕獲異常

語法格式：

try:
    執(zhí)行業(yè)務(wù)操作
except 異常1 as 異常變量1:
    執(zhí)行異常處理操作1
except 異常2 as 異常變量2:
    執(zhí)行異常處理操作2
finally:
    執(zhí)行必須操作

• try 子句用于執(zhí)行我們自己的業(yè)務(wù)操作。
• except 子句用于在 try 子句發(fā)生指定異常時，執(zhí)行對應(yīng)的異常處理操作。可以有 0 至多個。
• finally 子句用于執(zhí)行一些必須要執(zhí)行的操作，無論 try 子句有沒有發(fā)生異常都不會影響 finally 子句的執(zhí)行。
• except 子句與 finally 子句不是必須的，但是至少得有一個。
• 如果不知道 except 子句應(yīng)該捕獲什么異常，可以直接捕獲 Exception 異常，即 except Exception as 異常變量 。

示例：

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

2、拋出異常

語法格式：

raise 異常

最簡單的寫法是直接拋出一個 Exception 異常，即 raise Exception('異常提示信息') 。

示例：

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

十二、文件讀寫

操作文件前，我們要先使用 open() 函數(shù)打開文件，然后才可以對文件進(jìn)行讀寫操作。由于打開文件會占用計算機資源，因此，讀寫操作完成后，要使用 close() 函數(shù)關(guān)閉文件。

1、操作文件寫法

（1）操作文件一般寫法

# 打開文件
f = open('文件路徑', '打開模式', encoding='編碼格式')
# 操作文件
...
# 操作文件完成后，關(guān)閉文件
f.close()

• 文件路徑用于指定要操作的文件。
• 打開模式用于指定打開文件后，后續(xù)要以什么模式來操作文件。常用模式有 r 、 rb 、 w 、 wb 等。r rb w wb
• 編碼格式用于指定以哪種編碼字符集來打開文本文件。文本文件保存時會選擇一種編碼字符集來保存內(nèi)容，我們在打開文本文件時也要使用相同的編碼字符集，否則可能會導(dǎo)致內(nèi)容錯亂。一般使用 utf-8 編碼字符集。
• 操作二進(jìn)制文件時，不用指定編碼格式，只有文本文件需要。

（2）操作文件增強寫法

如果操作文件過程中發(fā)生了異常，會導(dǎo)致 close() 函數(shù)不被執(zhí)行。因此為了保證 close() 函數(shù)被執(zhí)行，可以使用 try ... finally 語句。

try:
    # 打開文件
    f = open('文件路徑', '打開模式', encoding='編碼格式')
    # 操作文件
    ...
finally:
    if f:
        # 操作文件完成后，關(guān)閉文件
        f.close()

（3）操作文件優(yōu)雅寫法（推薦）

使用 try ... finally 的寫法每次都要調(diào)用 close() 函數(shù)太麻煩了，Python 提供了 with 語句來幫我們自動調(diào)用 close() 函數(shù)。

with open('文件路徑', '打開模式', encoding='編碼格式') as f:
    # 操作文件
    ...

2、讀文件

打開文件后，可以使用 read() 函數(shù)來從文件中的讀取內(nèi)容。

示例：讀取 D 盤 mypython 目錄下的 test.txt 文件內(nèi)容（事先要建立好文件）。

try:
    # 以只寫模式打開文本文件
    f = open('D:\\mypython\\test.txt', 'r', encoding='utf-8')
    # 讀取內(nèi)容
    print(f.read())
finally:  
    if f:
        # 操作文件完成后，關(guān)閉文件
        f.close()

3、寫文件

打開文件后，可以使用 write() 函數(shù)往文件中寫入內(nèi)容。

示例：

try:
    # 以只寫模式打開文本文件，指定編碼格式為 utf-8
    f = open('D:\\mypython\\test.txt', 'w', encoding='utf-8')
    # 寫入內(nèi)容
    f.write('今天你學(xué) Python 了嗎？')
finally:  
    if f:
        # 操作文件完成后，關(guān)閉文件
        f.close()

十三、面向?qū)ο?/h2>

面向?qū)ο笫且环N程序設(shè)計思想，它把程序中涉及到的所有東西都看作一種對象——萬物皆對象。對象的含義是指具體的某一事物，即我們現(xiàn)實生活中看得見摸得著的事物。

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

Python 中的對象也具有屬性和行為（一般稱為方法），屬性通過變量來體現(xiàn)，而行為則通過函數(shù)來體現(xiàn)。也就是說，對象中包含了數(shù)據(jù)（存儲在變量中）和操作數(shù)據(jù)的函數(shù)。也可以把對象理解為帶有函數(shù)的數(shù)據(jù)。實際上，Python 中的所有數(shù)據(jù)都是對象。

對于面向?qū)ο螅覀冞@里只講如何創(chuàng)建一個簡單的對象，以及如何操作對象中的數(shù)據(jù)。如果有小伙伴打算深入學(xué)習(xí)，那么建議一定要掌握面向?qū)ο蟮娜筇匦裕悍庋b、繼承、多態(tài)。

1、如何創(chuàng)建對象

對象基于類創(chuàng)建，類是對象的模板。通過類這個模板，我們可以創(chuàng)建出各式各樣屬于同一個類，但是屬性和方法又有所不同的對象。

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

（1）定義類

語法格式：

class 類名:

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

    def 方法1(self, 參數(shù)1, 參數(shù)2, ...):
        執(zhí)行操作

    def 方法2(self, 參數(shù)1, 參數(shù)2, ...):
        執(zhí)行操作

    ...

self
self

示例：定義一個貓的類

class Cat:

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

    # 吃飯
    def eat(self):
        print('這只%s開始吃魚了，都已經(jīng)%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）通過類創(chuàng)建對象

語法格式：

對象變量 = 類名(屬性1, 屬性2, ...)

示例：創(chuàng)建一只貓的對象

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

2、如何操作對象數(shù)據(jù)

我們可以通過對象的屬性和方法來操作對象的數(shù)據(jù)。

（1）通過屬性操作

創(chuàng)建完對象后，可以通過 對象.屬性名 的方式來操作對象的數(shù)據(jù)。

示例：

cat = Cat('布偶貓', '白色', 10)
# 獲取重量數(shù)據(jù)
w = cat.weight
# 更新重量數(shù)據(jù)
cat.weight = 15
# 新增昵稱數(shù)據(jù)
cat.nickname = '小白'

（2）通過方法操作

創(chuàng)建完對象后，可以通過 對象.方法名() 的方式來操作對象的數(shù)據(jù)。其實本質(zhì)上是在方法內(nèi)部通過對象的屬性操作數(shù)據(jù)。

示例：

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

結(jié)語

終于肝完了~