第一章 計算機基礎知識
1.1 課程介紹
課程名稱：Python 基礎視頻教程
講師：尚硅谷教育，李立超（lichao.li@foxmail.com）
面向的層次：From Zero to Hero（從入門到精通）
學習方法：認真聽講，多敲代碼
必備技能：
① 計算機基本操作
② 打字的速度
③ 英語（能閱讀基本的英文文檔）
1.2 計算機是什么
在現實生活中，越來越無法離開計算機了
電腦、筆記本、手機、游戲機、汽車導航、智能電視、……
計算機就是一個用來計算的機器！！！
目前來講，計算機只能根據人類的指令來完成各種操作，人讓它干嘛他就得干嘛。
所以我們學習計算機，就是學習如何控制計算機！！！
1.3 計算機的組成
計算機由兩部分組成：硬件 和 軟件
硬件包含：鍵盤、鼠標、顯示器、CPU、主板、內存、硬盤、……
硬件是看的見摸得着的。
軟件包含：系統軟件（Windows、MacOS、Linux）和應用軟件（Office 、QQ、絕地求生）
軟件是看的見摸不着的，軟件負責控制計算機中的硬件。
1.4 計算機的使用方式
我們必須要通過軟件來對計算機完成各種操作，但是注意，軟件中並不是所有的功能都會對用戶開放，用戶需要調用軟件提供的接口（Interface 交互界面）來操作計算機。
用戶界面分成兩種：TUI（文本交互界面）和 GUI（圖形化交互界面）
1.5 windows 的命令行
命令行就是文本交互界面，通過命令行可以使用一個一個的指令來操作計算機。
任何的計算機的操作系統中都包含有命令行（windows、linux、macOS）
命令行有多個不同的名字：
命令行、命令行窗口、DOS 窗口、命令提示符、CMD 窗口、Shell、終端、Terminal
• 練習1：通過搜索引擎來搜索一下，各個操作系統當中的命令行窗口的樣式。
• 練習2：嘗試使用多種方式進入到你的系統的命令行，並且觀察你的和我的有什么區別？
• 練習3：通過搜索引擎搜索一下其他的一些常用 DOS 命令，並嘗試使用一些命令的選項。
1.如何進入到命令行
win鍵 + R 出現運行窗口，輸入cmd，然后回車
2.命令行的結構
- 版本及版權聲明（一般沒有什么用）
Microsoft Windows [版本 10.0.17763.475]
(c) 2018 Microsoft Corporation。保留所有權利。
- 命令提示符
C:\Users\bruce>
C:
- 當前所在的磁盤根目錄
- 可以通過 x: 來切換盤符（x表示你的盤符）
\Users\bruce
- 所在磁盤的路徑，當前所在的文件夾
- cd 來切換目錄
>
- 命令提示符，在大於號后邊可以直接輸入指令
3.常用的 dos 命令
dir 查看當前目錄下的所有文件（夾）
cd 進入到指定的目錄
. 表示當前目錄
.. 表示上一級目錄
md 創建一個目錄
rd 刪除一個目錄
del 刪除一個文件
cls 清除屏幕
命令的語法：
命令 [參數] [選項]
4.小技巧
- 方向鍵上下，查看命令的歷史記錄
- tab 鍵自動補全命令
1.6 環境變量（environment variable）
環境變量指的就是操作系統當中的一些變量。
可以通過修改環境變量，來對計算機進行配置（主要是來配置一些路徑的）。
1.查看環境變量
> 右鍵 -> 計算機（此電腦） -> 選擇屬性
> 系統界面左側選擇 -> 高級系統設置
> 選擇環境變量
環境變量界面分成了兩個部分，上邊是用戶環境變量，下邊是系統環境變量
建議：只修改用戶的環境變量，不要修改系統的環境變量。
2.添加環境變量
> 通過新建按鈕添加環境變量
> 一個環境變量可以由多個值，值與值之間使用;（英文）隔開
3.修改環境變量
> 通過編輯按鈕來修改環境變量
4.刪除環境變量
> 通過刪除按鈕來刪除環境變量
• 練習4：進入到環境變量的界面，創建一個 USERNAME 環境變量，修改 USERNAME 環境變量，並嘗試添加多個值，然后刪除 USERNAME 環境變量。
1.7 path 環境變量
path 環境變量中保存的是一個一個的路徑。
當我們在命令行中輸入一個命令（或訪問一個文件時），
• 系統會首先在當前目錄下尋找，如果找到了則直接執行或打開。
• 如果沒有找到，則會依次去 path 環境變量的路徑中去尋找，直到找到為止。
• 如果 path 環境變量中的路徑都沒有找到，則報錯。如下：
• 'xxx' 不是內部或外部命令，也不是可運行的程序或批處理文件。
我們可以將一些經常需要訪問到的文件會程序的路徑，添加到path環境變量中，
這樣我們就可以在任意的位置訪問到這些文件了
注意事項：
1.如果環境變量中沒有path，可以手動添加
2.path 環境變量不區分大小寫，PATH Path path 均可
3.修改完環境變量必須重新啟動命令行窗口
4.多個路徑之間使用;隔開
• 練習5：在桌面創建一個 hello 文件夾，文件中創建一個 abc.txt 輸入隨意的內容，然后將 hello 的路徑添加到 path 環境變量中，嘗試在任意位置訪問 abc.txt，最后將 hello 路徑從 path 環境變量中刪除。
1.8 進制
- 十進制（最常用的進制）
- 十進制就是滿十進一的進制
- 十進制當中一共有 10 個數字
0 1 2 3 4 5 6 7 8 9
- 十進制如何計數
0 1 2 3 4 5 6 7 8 9 10 11 12 。。。 19 20 。。。29 30
- 二進制（計算機底層使用的進制）
- 滿二進一
- 二進制中一共有 2 個數字
0 1
- 二進制如何計數
0 1 10 11 100 101 110 111 1000
- 所有的數據在計算機底層都是以二進制的形式保存的，計算機只認二進制。
- 可以將內存想象為一個一個的小格子，小格子中可以存儲一個0或一個1。
- 內存中的每一個小格子，我們稱為 1bit（位）。
bit 是計算機中的最小的單位
byte 是我們最小的可操作的單位
8bit = 1byte（字節）
1024byte = 1kb（千字節）
1024kb = 1mb（兆字節）
1024mb = 1gb（吉字節）
1024gb = 1tb（太字節）
。。。
- 八進制（一般不用）
- 滿八進一
- 八進制中一共有 8 個數字
0 1 2 3 4 5 6 7
- 八進制如何計數
0 1 2 3 4 5 6 7 10 11 。。。 17 20 。。。27 30
- 十六進制
- 滿十六進一
- 十六進制中一共有 16 個數字
由於十六進制是滿 16 才進位，所以十六進制中引入了a b c d e f來表示 10 11 12 13 14 15
0 1 2 3 4 5 6 7 8 9 a b c d e f
- 十六進制如何計數
0 1 2 3 4 5 6 7 8 9 a b c d e f 10 11 12 。。。 1a 1b 1c 1d 1e 1f
20 21 22 。。。 2a 2b 2c 2d 2e 2f 30
- 我們在查看二進制數據時，一般會以十六進制的形式顯示。
1.9 文本文件和字符集
- 文本分成兩種，一種叫做純文本，還有一種叫做富文本。
- 純文本中只能保存單一的文本內容，無法保存內容無關的東西（字體、顏色、圖片、......）
- 富文本中可以保存文本以外的內容（word 文檔）
- 在開發時，編寫程序使用的全都是純文本！
- 純文本在計算機底層也會轉換為二進制保存，
將字符轉換為二進制碼的過程，我們稱為 編碼
將二進制碼轉換為字符的過程，我們稱為 解碼
編碼和解碼時所采用的規則，我們稱為 字符集
- 常見的字符集：
ASCII
- 美國人編碼，使用 7 位來對美國常用的字符進行編碼。
- 包含 128 個字符
ISO-8859-1
- 歐洲的編碼，使用 8 位。
- 包含 256 個字符
GB2312
GBK
國標碼，中國的編碼。
Unicode
萬國碼，包含世界上所有的語言和符號，編寫程序時一般都會使用 Unicode 編碼。
Unicode 編碼有多種實現：UTF-8、UTF-16、UTF-32
最常用的就是 UTF-8
- 亂碼
編寫程序時，如果發現程序代碼出現亂碼的情況，就要馬上去檢查字符集是否正確。
1.10 Sublime Text 3
- 純文本編輯器
- Package Control（Sublime 的包管理器）
- Sublime Text3 中的插件，通過該插件可以向 Sublime 中安裝新的包。
• 練習6：
1、安裝 Sublime Text3
2、在 Sublime 中安裝 Package Control
3、通過 Package Control 安裝 Sublime 的中文語言包
4、嘗試為你的 Sublime 安裝新的主題（通過搜索引擎搜索） 注意：由於 packagecontrol.io 被牆了，需要使用全局的梯子可以解決問題（推薦使用全局的梯子），或者可以離線安裝 Package。
第二章 Python 入門
2.1 什么是計算機語言
計算機就是一台用來計算機的機器，人讓計算機干什么計算機就得干什么！
需要通過計算機的語言來控制計算機（編程語言）！
計算機語言其實和人類的語言沒有本質的區別，不同點就是交流的主體不同！
計算機語言發展經歷了三個階段：
機器語言
- 機器語言通過二進制編碼來編寫程序。
- 執行效率好，編寫起來太麻煩。
符號語言（匯編）
- 使用符號來代替機器碼。
- 編寫程序時，不需要使用二進制，而是直接編寫符號。
- 編寫完成后，需要將符號轉換為機器碼，然后再由計算機執行。
符號轉換為機器碼的過程，稱為匯編。
將機器碼轉換為符號的過程，稱為反匯編。
- 匯編語言一般只適用於某些硬件，兼容性比較差。
高級語言
- 高級語言的語法基本和現在英語語法類似，並且和硬件的關系沒有那么緊密了。
- 也就是說我們通過高級語言開發程序可以在不同的硬件系統中執行。
- 並且高級語言學習起來也更加的容易，現在我們知道的語言基本都是高級語言。
- C、C++、C#、Java、JavaScript、Python、Scala、Go、PHP、......
2.2 編譯型語言和解釋型語言
計算機只能識別二進制編碼（機器碼），所以任何的語言在交由計算機執行時必須要先轉換為機器碼，也就是像 print('hello') 必需要轉換為類似 1010101 這樣的機器碼。
根據轉換時機的不同，語言分成了兩大類：
編譯型語言
- C語言
- 編譯型語言，會在代碼執行前將代碼編譯為機器碼，然后將機器碼交由計算機執行。
- a(源碼) --> 編譯器 --> b(編譯后的機器碼)
- 特點：
執行速度特別快
跨平台性比較差
解釋型語言
- Python JS Java
- 解釋型語言，不會在執行前對代碼進行編譯，而是在執行的同時一邊執行一邊編譯。
- a（源碼）--> 解釋器 --> 解釋執行
- 特點：
執行速度比較慢
跨平台性比較好
2.3 Python 的介紹
Python 是解釋型語言。
Python（英國發音：/ˈpaɪθən/ 美國發音：/ˈpaɪθɑːn/），是一種廣泛使用的高級編程語言，屬於通用型編程語言，由 【吉多·范羅蘇姆(龜叔)】 創造，第一版發布於 1991 年。
可以視之為一種改良（加入一些其他編程語言的優點，如面向對象）的 LISP。作為一種解釋型語言，Python 的設計哲學強調代碼的可讀性和簡潔的語法（尤其是使用空格縮進划分代碼塊，而非使用大括號或者關鍵詞）。
相比於 C++ 或 Java，Python 讓開發者能夠用更少的代碼表達想法。不管是小型還是大型程序，該語言都試圖讓程序的結構清晰明了。
Life is short, you need Python. （人生苦短，我用 Python。）
Python 的用途：
WEB應用(網站)，不突出應用
Facebook、豆瓣、谷歌后台、......
爬蟲程序，突出應用
科學計算，突出應用
計算能力強，精度高
自動化運維
Linux 服務器，腳本
大數據
ETL
雲計算
阿里雲、騰訊雲、京東雲、....
桌面軟件/游戲
人工智能，突出應用
阿爾法狗、...
......
2.4 Python 開發環境搭建
開發環境搭建就是安裝 Python 的解釋器。
Python 的解釋器分類：
CPython（官方）
用 C 語言編寫的 Python 解釋器
PyPy
用 Python 語言編寫的 Python 解釋器
IronPython
用 .net 編寫的 Python 解釋器
Jython
用 Java 編寫的 Python 解釋器
步驟：
1. 下載安裝包 python-3.7.2.exe，是用 C 語言編寫的 Python 解釋器
- 3.x
- 2.x
3.x 與 2.x 不兼容
2. 安裝（傻瓜式安裝）
3. 打開命令行窗口，輸入 python 出現如下內容：
Python 3.7.2 (tags/v3.7.2:9a3ffc0492, Dec 23 2018, 23:09:28) [MSC v.1916 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>
2.5 Python 的交互界面
當我們通過命令行來輸入 Python，所進入到的界面就是 Python 的交互界面。
結構：
版本和版權聲明：
Python 3.7.2 (tags/v3.7.2:9a3ffc0492, Dec 23 2018, 23:09:28) [MSC v.1916 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>
命令提示符：
>>>
在命令提示符后可以直接輸入 Python 的指令！輸入完的指令將會被 Python 的解釋器立即執行！
安裝 Python 的同時，會自動安裝一個 Python 的開發工具 IDLE，通過 IDLE 也可以進入到交互模式。如下圖所示：
但是不同的是，在 IDLE 中可以通過 TAB 鍵來查看語句的提示。
IDLE 實際上就是一個交互界面，但是他可以有一些簡單的提示，並且可以將代碼保存。
交互模式只能你輸入一行代碼，它就是執行一行，所以他並不適用於我們日常的開發！ 僅可以用來做一些日常的簡單的測試！
我們一般會將 Python 代碼編寫到一個 py 文件中，然后通過 python 指令來執行文件中的代碼。如下圖所示：
• 練習7：
自己嘗試創建一個py文件，並向文件中寫入python打印語句（print…），然后執行該文件。如果你的系統的擴展名無法修改，請嘗試自行 baidu！答：因為 windows 系統中默認是隱藏文件擴展名和類型。需要我們設置打開。
Python 的開發工具 IDLE
簡單演示使用
2.6 Python 和 Sublime 的整合
1.在 Sublime 中執行 Python 代碼，使用 Ctrl + b 自動會在 Sublime 內置的控制台中執行
注意：這種執行方式，在某些版本的 Sublime 中對中文支持不好，並且不能使用 input() 函數。
2.使用 SublimeREPL 來運行 python 代碼
先安裝 SublimeREPL，安裝完成后，設置快捷鍵，按 f5 則自動執行當前的 Python 代碼。
首選項 --> 快捷設置 --> 在 用戶配置(User) --> 輸入以下內容：
{ "keys": ["f5"], "caption": "SublimeREPL:Python","command": "run_existing_window_command", "args":{"id": "repl_python_run","file": "config/Python/Main.sublime-menu"}},
2.7 幾個概念區分
1.表達式（expression）
表達式就是一個類似於數學公式的東西。
比如：10 + 5 8-4
表達式一般僅僅用了計算一些結果，不會對程序產生實質性的影響。
如果在交互模式中輸入一個表達式，解釋器會自動將表達式的結果輸出。
2.語句（statement）
在程序中語句一般需要完成某種功能，比如：打印信息、獲取信息、為變量賦值、.......。
比如：
print()
input()
a = 10
語句的執行一般會對程序產生一定的影響。
在交互模式中不一定會輸出語句的執行結果。
3.程序（program）
程序就是由一條一條的語句和一條一條的表達式構成的。
4.函數（function）
函數就是一種語句，函數專門用來完成特定的功能。
函數長的形如：xxx()
函數的分類：
內置函數
- 由 Python 解釋器提供的函數，可以在 Python 中直接使用。
自定義函數
- 由程序員自主創建的函數。
當我們需要完成某個功能時，就可以去調用內置函數，或者自定義函數。
函數的兩個要素：
參數
- () 中的內容就是函數的參數。
- 函數中可以沒有參數，也可以有多個參數，多個參數之間使用 , 隔開。
返回值
- 返回值是函數的返回結果，不是所有的函數都有返回值。
2.8 基本語法
• 1.在 Python 中嚴格區分大小寫。
• 2.Python中 的每一行就是一條語句，每條語句以換行結束。
• 3.Python 中每一行語句不要過長（規范中建議每行不要超過 80 個字符）。
Sublime Text 中設置："rulers":[80],
• 4.一條語句可以分多行編寫，多行編寫時語句后邊以 \ 結尾。
• 5.Python 是縮進嚴格的語言，所以在 Python 中不要隨便寫縮進。（Python 中縮進表示代碼塊）
• 6.在 Python 中使用 # 來表示注釋，# 后的內容都屬於注釋，注釋的內容將會被解釋器所忽略。
我們可以通過注釋來對程序進行解釋說明，一定要養成良好的編寫注釋的習慣。
注釋要求簡單明了，一般習慣上 # 后邊會跟着一個空格。好習慣！！！
注釋快捷鍵 Ctrl + /
換行快捷鍵 Ctrl + Enter
2.9 字面量和變量
字面量就是一個一個的值，比如：1,2,3,4,5,6,'HELLO'
字面量所表示的意思就是它的字面的值，在程序中可以直接使用字面量。
變量（variable）變量可以用來保存字面量，並且變量中保存的字面量是不定的。
變量本身沒有任何意思，它會根據不同的字面量表示不同的意思。
一般我們在開發時，很少直接使用字面量，都是將字面量保存到變量中，通過變量來引用字面量。
2.10 變量和標識符
# Python 中使用變量，不需要聲明，直接為變量賦值即可。
a = 10
print(a)
# 不能使用沒有進行過賦值的變量。
# 如果使用沒有賦值過的變量，會報錯 NameError: name 'b' is not defined
# print(b)
# Python 是一個動態類型的語言，可以為變量賦任意類型的值，也可以任意修改變量的值。
a = 'hello'
print(a)
# 標識符：在 Python 中所有可以自主命名的內容都屬於標識符。
# 比如：變量名、函數名、類名
# 標識符必須遵循標識符的規范
# 1. 標識符中可以含有字母、數字、_，但是不能使用數字開頭。
# 例子：a_1 _a1 _1a
# 2. 標識符不能是 Python 中的關鍵字和保留字。
# 也不建議使用 Python 中的函數名作為標識符，因為這樣會導致函數被覆蓋。
# 3. 命名規范：
# 在 Python 中注意遵循兩種命名規范：
# 1) 下划線命名法（Python 中常用此法）
# 所有字母小寫，單詞之間使用_分割
# 示例：max_length、min_length、hello_world、xxx_yyy_zzz
# 2) 帕斯卡命名法（大駝峰命名法）（Python 中寫類名時常用此法）
# 首字母大寫，每個單詞開頭字母大寫，其余字母小寫
# 示例：MaxLength、MinLength、HelloWorld、XxxYyyZzz
#
# 如果使用不符合標准的標識符，將會報錯 SyntaxError: invalid syntax
# 練習：嘗試自己定義幾個變量（復雜一些，嘗試不同的命名法），然后打印一些變量。通過搜索引擎搜索還有哪些其他的命名規范。
_b123 = 20
# print(_b123)
# print = 123
# print(print)
關鍵字
2.11 數據類型
數據類型指的就是變量的值的類型，也就是可以為變量賦哪些值。
1.數值類型
整型
布爾值
浮點型
復數（后面講解）
2.字符串類型
3.空值類型
2.11.1 數值類型
數值類型--示例代碼：
# 在 Python 中，數值分成了三種：整數、浮點數（小數）、復數
# 在 Python 中所有的整數都是 int 類型
a = 10
b = 20
# Python 中的整數的大小沒有限制，可以是一個無限大的整數
# c = 999999999999999999999999999999999999999999999 ** 100 # 1個 * 表示乘法，2個 * 表示多少次冪
# 如果數字的長度過大，可以使用下划線作為分隔符
c = 123_456_789
# d = 0123 十進制的數字不能以0開頭
# 其他進制的整數，注意：只要是數字打印時一定是以十進制的形式顯示的。
# 二進制 0b開頭
c = 0b10 # 二進制的10
# 八進制 0o開頭
c = 0o10
# 十六進制 0x開頭
c = 0x10
# 也可以通過運算符來對數字進行運算，並且可以保證整數運算的精確。
c = -100
c = c + 3 # 表達式
# 浮點數（小數），在 Python 中所有的小數都是 float 類型。
c = 1.23
c = 4.56
# 對浮點數進行運算時，可能會得到一個不精確的結果
c = 0.1 + 0.2 # 0.30000000000000004
print(c)
2.11.2 字符串類型
字符串類型--示例代碼：
# 字符串(str)
# 字符串用來表示一段文本信息，字符串是程序中使用的最多的數據類型。
# 在 Python 中字符串需要使用引號引起來。
s = 'hello'
# s = abc # 字符串必須使用引號引起來，不使用引號引起來則不是字符串。
# 引號可以是雙引號，也可以是單引號，但是注意不要混着用。
s = 'hello'
s = "hello"
# s = 'hello" # 引號不能混合使用，否則報錯：SyntaxError: EOL while scanning string literal
# 相同的引號之間不能嵌套
# s = "子曰:"學而時習之，樂呵樂呵！""
s = '子曰:"學而時習之，樂呵樂呵！"'
# 長字符串
# 單引號和雙引號不能跨行使用。
s = '鋤禾日當午，\
汗滴禾下土，\
誰知盤中餐，\
粒粒皆辛苦'
# 使用三重引號來表示一個長字符串 ''' """
# 三重引號可以換行，並且會保留字符串中的格式。
s = '''鋤禾日當午，
汗滴禾下土，
誰知盤中餐，
粒粒皆辛苦'''
# 轉義字符
# 可以使用 \ 作為轉義字符，通過轉義字符，可以在字符串中使用一些特殊的內容。
# 例子：
# \' 表示 '
# \" 表示 "
# \t 表示 制表符
# \n 表示 換行符
# \\ 表示 反斜杠
# \uxxxx 表示 Unicode編碼
s = "子曰:\"學而時習之，\\\\n樂呵樂呵！\""
print(s) # 子曰:"學而時習之，\\n樂呵樂呵！"
s = '\u0040'
print(s) # @
2.11.3 4 種格式化字符串的方式
格式化字符串--示例代碼：
# 格式化字符串
a = 'hello'
# 字符串之間也可以進行加法運算。
# 如果將兩個字符串進行相加，則會自動將兩個字符串拼接為一個字符串。
a = 'abc' + 'haha' + '哈哈'
# a = 123
# 字符串不能和其他的類型進行加法運算，如果做了會出現異常：TypeError: must be str, not int
# print("a = " + a) # 方式一：a = 123 使用字符串拼接的方式，這種寫法在 Python 中不常見！！！
a = 123
# print('a =', a) # 方式二：a = 123 使用 print() 函數的打印多個參數的方式，輸出的多個參數之間使用空格隔開！
# 在創建字符串時，可以在字符串中指定占位符
# %s 在字符串中表示任意字符
# %f 浮點數占位符
# %d 整數占位符
b = 'hello %s' %'孫悟空' # hello 孫悟空
b = 'hello %s 你好 %s' %('tom', '孫悟空') # hello tom 你好 孫悟空
b = 'hello %3.5s' %'abcdefg' # %3.5s 字符串的長度限制在3-5之間，如果不夠，前頭用空格補
b = 'hello %s' %123.456 # hello 123.456
b = 'hello %.2f' %123.456 # hello 123.46
b = 'hello %d' %123.95 # hello 123
b = '呵呵'
# print('a = %s' %a) # 方式三：a = 123 使用占位符的方式
# 格式化字符串，可以通過在字符串前添加一個f(或F)來創建一個格式化字符串。
# 在格式化字符串中可以直接嵌入變量
c = f'hello {a} {b}'
print(f'a = {a}') # 方式四：a = 123 使用格式化字符串的方式
練習8、創建一個變量保存你的名字，然后通過四種格式化字符串的方式，在命令行中顯示，歡迎 xxx 光臨
name = '悟空'
# 1、字符串拼接的方式
print('歡迎 ' + name + ' 光臨')
# 2、print() 函數的打印多個參數
print('歡迎', name, '光臨')
# 3、占位符
print('歡迎 %s 光臨' %name)
# 4、格式化字符串
print(f'歡迎 {name} 光臨')
輸出結果如下：
歡迎 悟空 光臨
歡迎 悟空 光臨
歡迎 悟空 光臨
歡迎 悟空 光臨
2.11.4 字符串復制
字符串復制--示例代碼：
# 字符串的復制（將字符串和數字相乘）
a = 'abc'
# * 在語言中表示乘法
# 如果將字符串和數字相乘，則解釋器會將字符串重復指定的次數並返回
a = a * 3
print(a) # abcabcabc
2.11.5 布爾值 和 空值
布爾值 和 空值--示例代碼：
# 布爾值（bool）
# 布爾值主要用來做邏輯判斷
# 布爾值一共有兩個 True 和 False
# True 表示真 False 表示假
a = True
a = False
# print('a =', a) # a = False
# 布爾值實際上也屬於整型，True 就相當於 1，False 就相當於 0
# print(1 + False)
# None（空值）
# None 專門用來表示不存在
b = None
print(b) # None
2.12 類型檢查
類型檢查--示例代碼：
# 通過類型檢查，可以檢查指定值（變量）的類型
a = 123 # 數值
b = '123' # 字符串
# print('a =', a)
# print('b =', b)
# type() 函數用來檢查值的類型。
# 該函數會將檢查的結果作為返回值返回，可以通過變量來接收函數的返回值。
c = type('123')
c = type(a)
# print(c)
# print(type(b))
print(type(1)) # <class 'int'>
print(type(1.5)) # <class 'float'>
print(type(True)) # <class 'bool'>
print(type('hello')) # <class 'str'>
print(type(None)) # <class 'NoneType'>
2.13 對象（object）
- Python 是一門面向對象的語言。
- 一切皆對象！
- 程序運行當中，所有的數據都是存儲到內存當中然后再運行的！
- 對象就是內存中專門用來存儲指定數據的一塊區域。
- 對象實際上就是一個容器，專門用來存儲數據。
- 像我們之前學習的數值、字符串、布爾值、None 都是對象。
2.14 對象的結構
- 每個對象中都要保存三種數據
- id（標識）
> id 用來標識對象的唯一性，每一個對象都有唯一的 id
> 對象的 id 就相當於人的身份證號一樣
> 可以通過 id() 函數來查看對象的 id
> id 是由解析器生成的，在 CPython 中，id 就是對象的內存地址
> 對象一旦創建，則它的 id 永遠不能再改變
- type（類型）
> 類型用來標識當前對象所屬的類型
> 比如：int、str、float、bool、......
> 類型決定了對象有哪些功能
> 通過 type() 函數來查看對象的類型
> Python 是一門強類型的語言，對象一旦創建類型便不能修改
- value（值）
> 值就是對象中存儲的具體的數據
> 對於有些對象值是可以改變的
> 對象分成兩大類，可變對象 和 不可變對象
可變對象的值可以改變
不可變對象的值不能改變，之前學習的對象都是不可變對象
內存小圖解：
2.15 變量和對象
- 對象並沒有直接存儲到變量中，在 Python 中變量更像是給對象起了一個別名
- 變量中存儲的不是對象的值，而是對象的 id（內存地址）
當我們使用變量時，實際上就是在通過對象 id 在查找對象
- 變量中保存的對象，只有在為變量重新賦值時才會改變
- 變量和變量之間是相互獨立的，修改一個變量不會影響另一個變量
變量和對象的圖解：
2.16 類型轉換
- 所謂的類型轉換，將一個類型的對象轉換為其他對象。
- 類型轉換不是改變對象本身的類型，而是根據當前對象的值創建一個新對象！！！
類型轉換--示例代碼：
# 類型轉換的四個函數 int() float() str() bool()
# int() 可以用來將其他的對象轉換為整型
# 規則：
# 布爾值：True -> 1 False -> 0
# 浮點數：直接取整，省略小數點后的內容
# 字符串：合法的整數字符串，直接轉換為對應的數字
# 如果不是一個合法的整數字符串，則報錯 ValueError: invalid literal for int() with base 10: '11.5'
# 對於其他不可轉換為整型的對象，直接拋出異常 ValueError
# float() 和 int() 基本一致，不同的是它會將對象轉換為浮點數
# str() 可以將對象轉換為字符串
# True -> 'True'
# False -> 'False'
# 123 -> '123'
# bool() 可以將對象轉換為布爾值，任何對象都可以轉換為布爾值
# 規則：對於所有表示空性的對象都會轉換為 False，其余的轉換為 True
# 有哪些表示的空性：0 、 None 、 '' 、...
a = True
# 調用 int() 來將 a 轉換為整型
# int() 函數不會對原來的變量產生影響，它是將對象轉換為指定的類型並將其作為返回值返回
# 如果希望修改原來的變量，則需要對原來的變量進行重新賦值
a = int(a) # 1
a = False
a = int(a) # 0
a = '123'
a = int(a) # 123
a = 11.6
a = int(a) # 11
a = '11.5'
# a = int(a) # 報錯，如果不是一個合法的整數字符串，則報錯
a = None
# a = int(a) # 報錯，如果是一個NoneType，則報錯
a = 1
a = float(a) # 1.0
a = False
a = float(a) # 0.0
a = 123
a = str(a) # '123'
a = None
a = bool(a) # False
print('a =', a)
print('a的類型是', type(a))
# b = 456
print('hello' + str(b)) # 'hello456'
2.17 運算符(操作符)
- 運算符可以對一個值或多個值進行運算或各種操作
- 比如 + 、-、= 都屬於運算符
- 運算符的分類：
1.算術運算符
2.賦值運算符
3.比較運算符（關系運算符）
4.邏輯運算符
5.條件運算符（三元運算符）
2.17.1 算術運算符
算術運算符--示例代碼：
# 算術運算符
# + 加法運算符（如果是兩個字符串之間進行加法運算，則會進行拼串操作）
# - 減法運算符
# * 乘法運算符（如果將字符串和數字相乘，則會對字符串進行復制操作，將字符串重復指定次數）
# / 除法運算符，運算時結果總會返回一個浮點類型
# // 整除，只會保留計算后的整數位，總會返回一個整型
# ** 冪運算，求一個值的幾次冪
# % 取模，求兩個數相除的余數
a = 10 + 5 # 計算
a = 'hello' + ' ' + 'world' # 拼串
a = 10 - 5 # 計算
a = 5 - True
a = a - 2 # 用變量 a 的值減去 2，然后再賦值給 a
# a = 'hello' - 'h' # 報錯：TypeError
a = 5 * 5
a = 10 / 5 # 2.0
a = 5 / 2 # 2.5
# a = 5 / 0 # 報錯：ZeroDivisionError: division by zero
a = 10 / 3 # a = 3.3333333333333335
a = 10 // 3 # a = 3 即取商
a = 5 // 2 # a = 2
a = 2 ** 2 # 2^2 = 4
a = 10 ** 5 # 10^5 = 100000
a = 16 ** 0.5 # 16^0.5 = 4.0 即求16的平方根
a = 10 % 5 # 0 即取余
a = 10 % 4 # 2 即取余
a = 10 % 3 # 1 即取余
a = 10 % 2 # 0 即取余
print("a =", a)
2.17.2 賦值運算符
賦值運算符--示例代碼：
# 賦值運算符
# = 可以將等號右側的值賦值給等號左側的變量
# += a += 5 相當於 a = a + 5
# -= a -= 5 相當於 a = a - 5
# *= a *= 5 相當於 a = a * 5
# **= a **= 5 相當於 a = a ** 5
# /= a /= 5 相當於 a = a / 5
# //= a //= 5 相當於 a = a // 5
# %= a %= 5 相當於 a = a % 5
a = 25.0 # 在對浮點數做算術運算時，結果也會返回一個浮點數
a //= 5 # 5.0
a = 5
a %= 4 # 1
print('a =', a)
2.17.3 比較運算符（關系運算符）
比較運算符（關系運算符）--示例代碼：
# 關系運算符
# 用來比較兩個值之間的關系，總會返回一個布爾值
# 如果關系成立，返回 True，否則返回 False
# > 比較左側值是否大於右側值
# >= 比較左側的值是否大於或等於右側的值
# < 比較左側值是否小於右側值
# <= 比較左側的值是否小於或等於右側的值
# == 比較兩個對象的值是否相等
# != 比較兩個對象的值是否不相等
# 相等和不等比較的是對象的值，而不是 id
# is 比較兩個對象是否是同一個對象，比較的是對象的 id
# is not 比較兩個對象是否不是同一個對象，比較的是對象的 id
result = 10 > 20 # False
result = 30 > 20 # True
result = 30 < 20 # False
result = 10 >= 10 # True
result = 2 > True # True
# result = 2 > '1' # TypeError: '>' not supported between instances of 'int' and 'str'
# 0032 > 0031
result = '2' > '1' # True 逐位比較
result = '2' > '11' # True 逐位比較
# 在 Python 中可以對兩個字符串進行大於（等於）或小於（等於）的運算
# 當對字符串進行比較時，實際上比較的是字符串的 Unicode 編碼
# 比較兩個字符串的 Unicode 編碼時，是【逐位比較】的
# 利用該特性可以對字符串按照字母順序進行排序，但是對於中文來說意義不是特別大
# 注意：如果不希望比較兩個字符串的 Unicode 編碼，則需要將其轉換為數字然后再比較
# 0061 > 0062
result = 'a' > 'b' # False 逐位比較
result = 'c' < 'd' # True 逐位比較
result = 'ab' > 'b' # False 逐位比較
# print(int('2') > int('11')) # False
result = 1 == 1 # True 比較兩個對象的值是否相等
result = 'hello' == 'hello' # True
result = 'abc' == 'bcd' # False
result = 'abc' != 'bcd' # True
result = 1 == True # True
result = 1 is True # False 比較兩個對象是否是同一個對象，比較的是對象的 id
result = 1 is not True # True
print('result =', result)
print(id(1), id(True)) # 140714389791568 140714389260624
2.17.4 邏輯運算符
比邏輯運算符--示例代碼：
# 邏輯運算符
# 邏輯運算符主要用來做一些邏輯判斷
# not 邏輯非
# not 可以對符號右側的值進行非運算
# 對於布爾值，非運算會對其進行取反操作，True 變 False，False 變 True
# 對於非布爾值，非運算會先將其轉換為布爾值，然后再取反
#
# and 邏輯與
# and 可以對符號兩側的值進行與運算
# 只有在符號兩側的值都為 True 時，才會返回 True，只要有一個 False 就返回 False
# 【與運算是找 False 的】
# Python 中的與運算是【短路的與】，如果第一個值為 False，則不再看第二個值
#
# or 邏輯或
# or 可以對符號兩側的值進行或運算
# 或運算兩個值中只要有一個 True，就會返回 True
# 【或運算是找 True 的】
# Python 中的或運算是【短路的或】，如果第一個值為 True，則不再看第二個值
#
# 練習：
# 嘗試一下對布爾值進行三種邏輯運算
# 嘗試對非布爾值進行三種邏輯運算，並觀察返回的結果
a = True
a = not a # False 對 a 進行非運算
a = 1
a = not a
# print('a =', a) # False
a = ''
a = not a
# print('a =', a) # True
result = True and True # True
result = True and False # False
result = False and True # False
result = False and False # False
# print(result)
# True and print('你猜我出來嗎？') 第一個值是 True，會看第二個值，所以 print() 會執行
# False and print('你猜我出來嗎？') 第一個值是 False，不會看第二個值，所以 print() 不會執行
result = True or True # True
result = True or False # True
result = False or True # True
result = False or False # False
# print(result)
# False or print('你猜我出來嗎？') 第一個值為 False，繼續看第二個，所以打印語句執行
# True or print('你猜我出來嗎？') 第一個值為 True，不看第二個，所以打印語句不執行
# 非布爾值的與或運算
# 當我們對非布爾值進行與或運算時，Python 會將其當做布爾值運算，最終會返回原值！！！
# 與運算的規則：
# 【與運算是找 False 的】，如果第一個值是 False，則不看第二個值
# 如果第一個值是 False，則直接返回第一個值，否則返回第二個值
# 或運算的規則：
# 【或運算是找 True 的】，如果第一個值是 True，則不看第二個值
# 如果第一個值是 True，則直接返回第一個值，否則返回第二個值
# True and True
result = 1 and 2 # 2
# True and False
result = 1 and 0 # 0
# False and True
result = 0 and 1 # 0
# False and False
result = 0 and None # 0
# True or True
result = 1 or 2 # 1
# True or False
result = 1 or 0 # 1
# False or True
result = 0 or 1 # 1
# False or False
result = 0 or None # None
print(result)
2.17.4 條件運算符（三元運算符）
條件運算符（三元運算符）--示例代碼：
# 條件運算符（三元運算符）
# 語法： 語句1 if 條件表達式 else 語句2
# 執行流程：
# 條件運算符在執行時，會先對條件表達式進行求值判斷：
# 如果判斷結果為 True，則執行語句 1，並返回執行結果
# 如果判斷結果為 False，則執行語句 2，並返回執行結果
# 練習：
# 現在有 a b c 三個變量，三個變量中分別保存有三個數值，
# 請通過條件運算符獲取三個值中的最大值
# print('你好') if False else print('Hello')
a = 30
b = 50
# print('a的值比較大！') if a > b else print('b的值比較大！')
# 獲取a和b之間的較大值
max = a if a > b else b
print(max)
a = 40
b = 50
c = 30
# 通過條件運算符獲取三個值中的最大值
# max = a if a > b else b
# max = max if max > c else c
max = a if (a > b and a > c) else (b if b > c else c) # 開發中不推薦這么使用
# max = a if (b < a > c) else (b if b > c else c) # 邏輯運算符可以連着使用
# print(max)
2.17.5 運算符的優先級
# 運算符的優先級 # 和數學中一樣，在 Python 運算也有優先級，比如：先乘除后加減 # 運算符的優先級可以根據優先級的表格來查詢 # 在表格中位置越靠下的運算符優先級越高，優先級越高的越優先計算 # 如果優先級一樣則自左向右計算 # 關於優先級的表格，你知道有這么一個東西就夠了，千萬不要去記 # 在開發中如果遇到優先級不清楚的，則可以通過小括號來改變運算順序 a = 1 + 2 * 3 # 三種情況：一樣高、and 高、or 高 # 如果 or 的優先級高，或者兩個運算符的優先級一樣高 # 則需要先進行 或運算，則運算結果是 3 # 如果 and 的優先級高，則應該先計算 與運算 # 則運算結果是 1 a = 1 or 2 and 3 print(a) # 1 # 邏輯運算符（補充） # 邏輯運算符可以連着使用 result = 1 < 2 < 3 # 相當於 1 < 2 and 2 < 3 result = 10 < 20 > 15 # 詳當於 10 < 20 and 20 > 15 print(result)
第三章 流程控制語句
3.1 簡介
Python 代碼在執行時是按照自上向下順序執行的。
通過流程控制語句，可以改變程序的執行順序，也可以讓指定的程序反復執行多次。
流程控制語句分成兩大類：條件判斷語句 + 循環語句
3.2 條件判斷語句（if 語句）
3.2.1 if 語句
if 語句--示例代碼：
# 條件判斷語句（if語句）
# 語法：if 條件表達式 :
# 代碼塊
# 執行的流程：if 語句在執行時，會先對條件表達式進行求值判斷：
# 如果為 True，則執行 if 后的語句
# 如果為 False，則不執行
# 默認情況下，if 語句只會控制緊隨其后的那條語句，如果希望 if 可以控制多條語句，則可以在 if 后跟着一個代碼塊。
# 代碼塊：
# 代碼塊中保存着一組代碼，同一個代碼塊中的代碼，要么都執行要么都不執行。
# 代碼塊就是一種為代碼分組的機制。
# 如果要編寫代碼塊，語句就不能緊隨在:后邊，而是要寫在下一行。
# 代碼塊以縮進開始，直到代碼恢復到之前的縮進級別時結束。
# 魯迅說過：
# 世上本來沒有路，走的人多了自然就有了！
# xxxx...
# yyyy...
# 縮進有兩種方式，一種是使用 tab 鍵，一種是使用空格（四個）
# Python 的官方文檔中推薦我們使用空格來縮進
# Python 代碼中使用的縮進方式必須統一
# sublime Text 3 中設置將 tab 鍵轉換成空格："translate_tabs_to_spaces": true,
# if False : print('你猜我出來么？')
num = 10
# if num > 10 : print('num比10大！')
# print('誰也管不了我')
if False :
print(123)
print(456)
print(789)
print(101112)
# print('hello')
# 可以使用【邏輯運算符】來連接多個條件：
# 如果希望所有條件同時滿足，則需要使用 and
# 如果希望只要有一個條件滿足即可，則需要使用 or
num = 28
# if num > 10 and num < 20 :
# print('num比10大，num比20小！')
# if 10 < num < 20 :
# print('num比10大，num比20小！')
# 在命令行讓用戶輸入一個用戶名，獲取用戶輸入，並進行判斷：
# 如果用戶輸入的用戶名是 admin，則顯示歡迎管理員光臨
# 如果用戶輸入的是其他的用戶名，則什么也不做
3.2.2 input 函數
input 函數--示例代碼：
# input() 函數
# 該函數用來獲取用戶的輸入
# 也可以用於暫時阻止程序結束
# input() 調用后，程序會立即暫停，等待用戶輸入
# 用戶輸入完內容以后，點擊回車程序才會繼續向下執行
# 用戶輸入完成以后，其所輸入的的內容會以返回值的形式返回
# 注意：input() 返回值是一個字符串
# input() 函數中可以設置一個字符串作為參數，這個字符串將會作為提示文字顯示
# a = input('請輸入任意內容：')
# print('用戶輸入的內容是:', a)
# 獲取用戶輸入的用戶名
username = input('請輸入你的用戶名:')
# 判斷用戶名是否是 admin
if username == 'admin' :
print('歡迎管理員光臨！')
3.2.3 if-else 語句
if-else 語句--示例代碼：
# 讓用戶在控制台中輸入一個年齡
# age = int(input('請輸入你的年齡：'))
# 如果用戶的年齡大於18歲，則顯示你已經成年了
# if age >= 18 :
# print('你已經成年了~~~')
# if-else 語句
# 語法：
# if 條件表達式 :
# 代碼塊
# else :
# 代碼塊
# 執行流程：
# if-else 語句在執行時，先對 if 后的條件表達式進行求值判斷
# 如果為 True，則執行 if 后的代碼塊
# 如果為 False，則執行 else 后的代碼塊
age = 7
if age > 17 :
print('你已經成年了~~~')
else :
print('你還未成年~~~')
3.2.4 if-elif-else 語句
if-elif-else 語句--示例代碼：
# if-elif-else 語句
# 語法：
# if 條件表達式 :
# 代碼塊
# elif 條件表達式 :
# 代碼塊
# elif 條件表達式 :
# 代碼塊
# elif 條件表達式 :
# 代碼塊
# else :
# 代碼塊
#
# 執行流程：
# if-elif-else 語句在執行時，會自上向下依次對條件表達式進行求值判斷：
# 如果表達式的結果為 True，則執行當前代碼塊，然后語句結束
# 如果表達式的結果為 False，則繼續向下判斷，直到找到 True 為止
# 如果所有的表達式都是 False，則執行 else 后的代碼塊
# if-elif-else 中只會有一個代碼塊會執行！！！
# 最后一個 else 可以省略。
age = 210
# if age > 200 :
# print('活着可真沒勁呢！') # 只執行這一個代碼塊
# elif age > 100 :
# print('你也是老大不小了！')
# elif age >= 60 :
# print('你已經退休了！')
# elif age >= 30 :
# print('你已經是中年了！')
# elif age >= 18 :
# print('你已經成年了！')
# else :
# print('你還是個小孩！')
age = 68
if age >= 18 and age < 30 :
print('你已經成年了！')
elif age >= 30 and age < 60 :
print('你已經中年了！')
elif age >= 60 :
print('你已經退休了！')
3.2.5 if 練習
練習1：
編寫一個程序，獲取一個用戶輸入的整數。然后通過程序顯示這個數是奇數還是偶數。
# 獲取用戶輸入的整數
num = int(input('請輸入一個任意的整數：'))
# # 顯示num是奇數還是偶數
if num % 2 == 0 :
print(num, "是偶數")
else :
print(num, '是奇數')
練習2：
編寫一個程序，檢查任意一個年份是否是閏年。
如果一個年份可以被4整除不能被100整除，或者可以被400整除，這個年份就是閏年。
year = int(input('請輸入一個任意的年份:'))
# 檢查這個年份是否是閏年
if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0) :
print('是閏年')
else :
print('不是閏年')
練習3：
我家的狗5歲了，5歲的狗相當於多大年齡的人呢？
其實非常簡單，狗的前兩年每一年相當於人類的10.5歲，然后每增加一年就增加四歲。
那么5歲的狗相等於人類的年齡就應該是 10.5 + 10.5 + 4 + 4 + 4 = 33 歲
編寫一個程序，獲取用戶輸入的狗的年齡，然后通過程序顯示其相當於人類的年齡。
如果用戶輸入負數，請顯示一個提示信息。
# 檢查用戶輸入的是否是負數
if dog_age < 0 :
print('你的輸入不合法！')
# 如果狗的年齡在兩歲以下（包含兩歲）
elif dog_age <= 2 :
# 直接將當前的年齡乘以10.5
like_person_age = dog_age * 10.5
# 如果狗的年齡在兩歲以上
else :
# 計算前兩歲相當於人類的年紀
like_person_age = 2 * 10.5
# 計算超過兩歲的部分相當於人類的年紀，並進行相加
like_person_age += ( dog_age - 2 ) * 4
if dog_age > 0 :
print(dog_age, '歲的狗，年紀相當於', like_person_age, '歲的人')
# --------------------改進版本--------------------
dog_age = float(input('請輸入狗的年齡：'))
like_person_age = 0
# 在if也可以嵌套if，代碼塊是可以嵌套的，每增加一個縮進的級別，代碼塊就低一級
# 檢查用戶的輸入是否合法
if dog_age > 0 :
# 如果狗的年齡在兩歲以下（包含兩歲）
if dog_age <= 2 :
# 直接將當前的年齡乘以10.5
like_person_age = dog_age * 10.5
# 如果狗的年齡在兩歲以上
else :
# 計算前兩歲相當於人類的年紀
like_person_age = 2 * 10.5
# 計算超過兩歲的部分相當於人類的年紀，並進行相加
like_person_age += ( dog_age - 2 ) * 4
print(dog_age, '歲的狗，年紀相當於', like_person_age, '歲的人')
else :
print('請輸入一個合法的年齡！')
# --------------------只使用 if 語句--------------------
dog_age = float(input('請輸入狗的年齡：'))
like_person_age = 0
if 0 <= dog_age <= 2 :
like_person_age = dog_age * 10.5
print(dog_age, '歲的狗，年紀相當於', like_person_age, '歲的人')
if dog_age > 2 :
like_person_age = 2 * 10.5
like_person_age += ( dog_age - 2 ) * 4
print(dog_age, '歲的狗，年紀相當於', like_person_age, '歲的人')
if dog_age < 0 :
print('請輸入一個合法的年齡！')
練習4：
從鍵盤輸入小明的期末成績:
當成績為 100 時，'獎勵一輛 BMW'
當成績為 [80-99] 時，'獎勵一台 iphone'
當成績為 [60-79] 時，'獎勵一本參考書'
其他時，什么獎勵也沒有
# 獲取小明的成績
score = float(input('請輸入你的期末成績(0-100)：'))
# 打印分割線
print("="*40)
# 檢查用戶的輸入是否合法
if 0 <= score <= 100 :
# 判斷發給的獎勵
if score == 100 :
print('寶馬，拿去玩！')
elif score >= 80 :
print('蘋果手機，拿去玩！')
elif score >= 60 :
print('參考書，拿去玩！')
else :
print('棍子一根！')
else :
# 用戶輸入的不合法，彈出一個友好提示
print('你輸入的內容不合法，拉出去斃了！')
練習5：
大家都知道，男大當婚，女大當嫁。那么女方家長要嫁女兒，當然要提出一定的條件：
高：180cm 以上; 富:1000 萬以上; 帥:500 以上;
如果這三個條件同時滿足，則:'我一定要嫁給他'
如果三個條件有為真的情況，則:'嫁吧，比上不足，比下有余。'
如果三個條件都不滿足，則:'不嫁！'
height = float(input('請輸入你的身高(厘米):'))
money = float(input('請輸入你的財富(萬):'))
face = float(input('請輸入你的顏值(平方厘米):'))
# 判斷到底嫁不嫁
# 如果這三個條件同時滿足，則:'我一定要嫁給他'
if height > 180 and money > 1000 and face > 500 :
print('我一定要嫁給他！')
# 如果三個條件有為真的情況，則:'嫁吧，比上不足，比下有余。'
elif height > 180 or money > 1000 or face > 500 :
print('嫁吧，比上不足，比下有余。')
# 如果三個條件都不滿足，則:'不嫁！'
else :
print('不嫁！')
3.3 循環語句（while 語句 + for 語句）
3.3.1 while 循環
# 循環語句
# 循環語句可以使指定的代碼塊重復指定的次數
# 循環語句分成兩種，while 循環 和 for 循環
# while 循環
# 語法：
# while 條件表達式 :
# 代碼塊
# else :
# 代碼塊
# 執行流程：
# while 語句在執行時，會先對 while 后的條件表達式進行求值判斷：
# 如果判斷結果為 True，則執行循環體（代碼塊），
# 循環體執行完畢，繼續對條件表達式進行求值判斷，以此類推，
# 直到判斷結果為 False，則循環終止，如果循環有對應的 else，則執行 else 后的代碼塊。
# 條件表達式恆為 True 的循環語句，稱為死循環，它會一直運行，慎用！
# while True :
# print('hello')
# 循環的三個要件（表達式）：
# 初始化表達式：通過初始化表達式初始化一個變量
# i = 0
# 條件表達式：條件表達式用來設置循環執行的條件
# while i < 10 :
# print(i)
# # 更新表達式：修改初始化變量的值
# i += 1
# 創建一個執行十次的循環
i = 0
while i < 10 :
i += 1
print(i, 'hello')
else :
print('else 中的代碼塊')
3.2.2 while 練習
練習1：
求 100 以內所有的奇數之和。
# 求 100 以內所有的奇數之和。
i = 0
# 創建一個變量，用來保存結果
result = 0
while i < 100 :
i += 1
# 判斷i是否是奇數
if i % 2 != 0 :
result += i
print('result =', result)
練習2：
求 100 以內所有 7 的倍數之和，以及個數。
# 求 100 以內所有7的倍數之和，以及個數。
i = 7
# 創建一個變量，來保存結果
result = 0
# 創建一個計數器，用來記錄循環執行的次數，計數器就是一個變量，專門用來記錄次數的變量
count = 0
while i < 100 :
# 為計數器加 1
count += 1
result += i
i += 7
print('總和為：', result, '總數量為：', count)
練習3：
水仙花數是指一個 n 位數（n ≥ 3），它的每個位上的數字的 n 次冪之和等於它本身（例如：13 + 53 + 3**3 = 153）。
求 1000 以內所有的水仙花數。
# 獲取 1000 以內的三位數
i = 100
while i < 1000:
# 假設：i的百位數是a，十位數是b，個位數是c
# 求i的百位數
a = i // 100 # 首位：取商
# 求i的十位數
# b = i // 10 % 10 # 中間位：先取商再取余
b = (i - a * 100) // 10
# 求i的個位數字
c = i % 10 # 末位：取余
# print(i, a, b, c)
# 判斷 i 是否是水仙花數
if a**3 + b**3 + c**3 == i :
print(i)
i += 1
練習4：
獲取用戶輸入的任意數，判斷其是否是質數。質數是只能被 1 和它自身整除的數，1 不是質數也不是合數。--使用逆向思維的方式。
# 獲取用戶輸入的任意數，判斷其是否是質數。
num = int(input('輸入一個任意的大於1的整數：'))
# 判斷 num 是否是質數，只能被1和它自身整除的數就是質數。1 不是質數也不是合數。
# 獲取到所有的可能整除 num 的整數
i = 2
# 創建一個變量，用來記錄 num 是否是質數，默認認為 num 是質數
flag = True
while i < num :
# 判斷 num 能否被 i 整除
# 如果 num 能被 i 整除，則說明 num 一定不是質數
if num % i == 0 :
# 一旦進入判斷，則證明 num 不是質數，則需要將 flag 修改為 False
flag = False
i += 1
if flag :
print(num, '是質數')
else :
print(num, '不是質數')
3.4 循環嵌套
# 在控制台中打印如下圖形
# *****
# *****
# *****
# *****
# *****
# 創建一個循環來控制圖形的高度
# 循環嵌套時，外層循環沒執行一次，內存循環就要執行一圈
# i = 0
# while i < 5 :
# # 創建一個內層循環來控制圖形的寬度
# j = 0
# while j < 5 :
# print("* ", end = '') # 不換行
# j += 1
# print()
# i += 1
#
# * j < 1 i = 0
# ** j < 2 i = 1
# *** j < 3 i = 2
# **** j < 4 i = 3
# ***** j < 5 i = 4
#
# *****
# ****
# ***
# **
#
i = 0
while i < 5 :
j = 0
while j < i + 1 :
print("* ", end = '')
j += 1
print()
i += 1
i = 0
while i < 5 :
j = 0
while j < 5 - i :
print("* ", end = '')
j += 1
print()
i += 1
練習1：
打印 99 乘法表。
i = 0
while i < 9 :
i += 1
j = 0
while j < i :
j += 1
print(f"{j} * {i} = {i * j}\t", end = '')
print()
升級版：
print ('\n'.join( ' '.join( "%d*%d=%-2s" %(y,x,x*y) for y in range(1,x+1)) for x in range(1,10)))
輸出結果如下：
1 * 1 = 1
1 * 2 = 2 2 * 2 = 4
1 * 3 = 3 2 * 3 = 6 3 * 3 = 9
1 * 4 = 4 2 * 4 = 8 3 * 4 = 12 4 * 4 = 16
1 * 5 = 5 2 * 5 = 10 3 * 5 = 15 4 * 5 = 20 5 * 5 = 25
1 * 6 = 6 2 * 6 = 12 3 * 6 = 18 4 * 6 = 24 5 * 6 = 30 6 * 6 = 36
1 * 7 = 7 2 * 7 = 14 3 * 7 = 21 4 * 7 = 28 5 * 7 = 35 6 * 7 = 42 7 * 7 = 49
1 * 8 = 8 2 * 8 = 16 3 * 8 = 24 4 * 8 = 32 5 * 8 = 40 6 * 8 = 48 7 * 8 = 56 8 * 8 = 64
1 * 9 = 9 2 * 9 = 18 3 * 9 = 27 4 * 9 = 36 5 * 9 = 45 6 * 9 = 54 7 * 9 = 63 8 * 9 = 72 9 * 9 = 81
練習2：
求 100 以內所有的質數。
打印 99 乘法表。
# 求100以內所有的質數
# 創建一個循環，求 1-100 以內所有的數
i = 2
while i <= 100 :
# 創建一個變量，記錄 i 的狀態，默認認為 i 是質數
flag = True
# 判斷 i 是否是質數
# 獲取所有可能成為 i 的因數的數
j = 2
while j < i :
# 判斷 i 能否被 j 整除
if i % j == 0:
# i 能被 j 整除，證明 i 不是質數，修改 flag 為 False
flag = False
j += 1
# 驗證結果並輸出
if flag :
print(i)
i += 1
3.5 break 和 continue
# break
# break 可以用來立即退出整個循環語句（包括 else）
# continue
# continue 可以用來跳過當次循環
# break 和 continue 都是只對離他最近的循環起作用
# pass
# pass 是用來在判斷或循環語句中占位的
# i = 0
# while i < 5 :
# if i == 3 :
# break
# print(i)
# i += 1
# else :
# print('循環結束')
# i = 0
# while i < 5 :
# i += 1
# if i == 2 :
# continue
# print(i)
# else :
# print('循環結束')
i = 0
if i < 5 :
pass
3.6 質數練習的優化
# 模塊，通過模塊可以對 Python 進行擴展
# 引入一個 time 模塊，來統計程序執行的時間
from time import *
# time() 函數可以用來獲取當前的時間，返回的單位是秒
# 優化前：
# 10000個數 12.298秒
# 100000個數 沒有結果
# 第一次優化
# 10000個數 1.577秒
# 100000個數 170.645秒
# 第二次優化
# 10000個數 0.068秒
# 100000個數 1.646秒
# 和數36的因數
# 2 18
# 3 12
# 4 9
# 6 6
#
# 求 100 以內所有的質數。
# 獲取程序開始的時間
begin = time()
i = 2
while i <= 100000 :
flag = True
j = 2
while j <= i ** 0.5 : # 第二次優化，因為因數都是成對出現的，此時需要帶上等號
if i % j == 0 :
flag = False
# 一旦進入判斷，則證明 i 一定不是質數，此時內層循環沒有繼續執行的必要(即只要有一個(除了1和它自身外)數能被i整除，那么 i 一定不是質數)
# 使用 break 來退出內層的循環
break # 第一次優化
j += 1
if flag :
# print(i)
pass
i += 1
# 獲取程序結束的時間
end = time()
# 計算程序執行的時間
print("程序執行花費了："end - begin , "秒")
3.7 小游戲 《唐僧大戰白骨精》
1、身份選擇
① 顯示提示信息
歡迎光臨 xxx 游戲！
請選擇你的身份：
1.xxx
2.xxx
請選擇：x
② 根據用戶選擇來分配身份（顯示不同的提示消息）
1.---
2.---
3.---
2、游戲進行
① 顯示玩家的基本信息（攻擊力 生命值）
② 顯示玩家可以進行的操作：
1、練級
- 提升玩家的攻擊力和生命值
2、打 BOSS
- 玩家對 BOSS 進行攻擊，玩家要攻擊 BOSS，BOSS 對玩家進行反擊
- 計算 BOSS 是否被玩家消滅，玩家是否被 BOSS 消滅
- 游戲結束
3、逃跑
- 退出游戲，顯示提示信息，游戲結束！
版本1.0 代碼：
# 顯示歡迎信息
print('-'*20, '歡迎光臨《唐僧大戰白骨精》', '-'*20)
# 顯示身份選擇的信息
print('請選擇你的身份：')
print('\t1.唐僧')
print('\t2.白骨精')
# 游戲的身份選擇
player_choose = input('請選擇[1-2]：') # input 函數返回的字符串
# 打印一條分割線
print('-'*66)
# 根據用戶的選擇來顯示不同的提示信息
if player_choose == '1':
# 選擇 1
print('你已經選擇了1，你將以->唐僧<-的身份來進行游戲！')
elif player_choose == '2':
# 選擇 2
print('你竟然選擇了白骨精，太不要臉了，你將以->唐僧<-的身份來進行游戲！')
else :
# 選擇 3
print('你的輸入有誤，系統將自動分配身份，你將以->唐僧<-的身份來進行游戲！')
# 進入游戲
# 創建變量，來保存玩家的生命值和攻擊力
player_life = 2 # 生命值
player_attack = 2 # 攻擊力
# 創建變量，保存 boss 的生命值和攻擊力
boss_life = 10
boss_attack = 10
# 打印一條分割線
print('-'*66)
# 顯示玩家的信息（攻擊力、生命值）
print(f'唐僧，你的生命值是 {player_life}，你的攻擊力是 {player_attack}')
# 由於游戲選項是需要反復顯示的，所以必須將其編寫到一個循環中
while True :
# 打印一條分割線
print('-'*66)
# 顯示游戲選項，游戲正式開始
print('請選擇你要進行的操作：')
print('\t1.練級')
print('\t2.打BOSS')
print('\t3.逃跑')
game_choose = input('請選擇要做的操作[1-3]：')
# 處理用戶的選擇
if game_choose == '1' :
# 增加玩家的生命值和攻擊力
player_life += 2
player_attack += 2
# 顯示玩家的最新信息
# 打印一條分割線
print('-'*66)
# 顯示玩家的信息（攻擊力、生命值）
print(f'恭喜你升級了！你現在的生命值是 {player_life}，你的攻擊力是 {player_attack}')
elif game_choose == '2' :
# 玩家攻擊 boss
# 減去 boss 的生命值，減去的生命值應該等於玩家的攻擊力
boss_life -= player_attack
# 打印一條分割線
print('-'*66)
print('->唐僧<- 攻擊了 ->白骨精<-')
# 檢查 boss 是否死亡
if boss_life <= 0 :
# boss 死亡，player 勝利，游戲結束
print(f'->白骨精<-受到了 {player_attack} 點傷害，重傷不治死了，->唐僧<-贏得了勝利！')
# 游戲結束
break
# boss 要反擊玩家
# 減去玩家的生命值，減去的玩家生命值應該等於 boss 的攻擊力
player_life -= boss_attack
print(' ->白骨精<- 攻擊了 ->唐僧<-')
# 檢查玩家是否死亡
if player_life <= 0 :
# 玩家死亡
print(f'你受到了 {boss_attack} 點傷害，重傷不治死了！GAME OVER')
# 游戲結束
break
elif game_choose == '3' :
# 打印一條分割線
print('-'*66)
# 逃跑，退出游戲
print('->唐僧<-一扭頭，撒腿就跑！GAME OVER')
break
else :
# 打印一條分割線
print('-'*66)
print('你的輸入有誤，請重新輸入！')
第四章 序列
4.1 列表（list）的簡介
- 列表是 Python 中的一個對象
對象（object）就是內存中專門用來存儲數據的一塊區域
- 之前我們學習的對象，像數值，它只能保存一個單一的數據
- 列表中可以保存多個有序的數據（元素可重復，順序指的是 添加的順序）
- 列表是用來存儲對象的對象
- 列表的使用：
1.列表的創建
2.操作列表中的數據
列表--示例代碼：
# 創建列表，通過[]來創建列表
my_list = [] # 創建了一個空列表
# print(my_list, type(my_list)) # [] <class 'list'>
# 列表存儲的數據，我們稱為元素
# 一個列表中可以存儲多個元素，也可以在創建列表時，來指定列表中的元素
my_list = [10] # 創建一個只包含一個元素的列表
# 當向列表中添加多個元素時，多個元素之間使用,隔開
my_list = [10, 20, 90, 40, 50] # 創建了一個包含有5個元素的列表
# 列表中可以保存任意的對象
my_list = [10, 'hello', True, None, [1, 2, 3], print]
print(my_list) # [10, 'hello', True, None, [1, 2, 3], <built-in function print>]
# 列表中的對象都會按照插入的順序存儲到列表中：
# 即第一個插入的對象保存到第一個位置，第二個保存到第二個位置
# 我們可以通過索引（index）來獲取列表中的元素：
# 索引是元素在列表中的位置，列表中的每一個元素都有一個索引
# 索引是從 0 開始的整數，列表第一個位置索引為 0，第二個位置索引為 1，第三個位置索引為 2，以此類推
my_list = [10, 20, 90, 40, 50]
# 通過索引獲取列表中的元素
# 語法：my_list[索引] my_list[0]
# print(my_list[4])
# 如果使用的索引超過了最大的范圍，會拋出異常，如下：
# print(my_list[5]) # IndexError: list index out of range
# 獲取列表的長度，列表中元素的個數
# len()函數，通過該函數可以獲取列表的長度
# 獲取到的長度的值，是列表的最大索引 + 1
print(len(my_list)) # 5
4.2 列表的切片
# 切片
# 切片指從現有列表中，獲取一個子列表
# 創建一個列表，一般創建列表時，變量的名字會使用復數
stus = ['孫悟空', '豬八戒', '沙和尚', '唐僧', '蜘蛛精', '白骨精']
# 列表的索引可以是負數
# 如果索引是負數，則從后向前獲取元素，-1 表示倒數第一個，-2 表示倒數第二個，以此類推
# print(stus[-2])
# 通過切片來獲取指定的元素
# 語法：列表[起始:結束]
# 通過切片獲取元素時，會包括起始位置的元素，不會包括結束位置的元素
# 做切片操作時，總會返回一個新的列表，不會影響原來的列表
# 起始和結束位置的索引都可以省略不寫
# 如果省略結束位置，則會一直截取到最后
# 如果省略起始位置，則會從第一個元素開始截取
# 如果起始位置和結束位置全部省略，則相當於創建了一個列表的副本
# print(stus[1:2]) # 包頭不包尾
# print(stus[1:])
# print(stus[:3])
# print(stus[:])
# print(stus)
# 語法：列表[起始:結束:步長]
# 步長表示，每次獲取元素的間隔，默認值是1
# print(stus[0:5:3])
# 步長不能是 0，但是可以是負數
# print(stus[::0]) # ValueError: slice step cannot be zero
# 如果是負數，則會從列表的后部向前邊取元素
print(stus[::-1])
正數和負數索引：
4.3 通用操作
# + 和 *
# + 可以將兩個列表拼接為一個列表
my_list = [1, 2, 3] + [4, 5, 6] # [1, 2, 3, 4, 5, 6]
# * 可以將列表重復指定的次數
my_list = [1, 2, 3] * 3 # [1, 2, 3, 1, 2, 3, 1, 2, 3]
# print(my_list)
# 創建一個列表
stus = ['孫悟空', '豬八戒', '沙和尚', '唐僧', '蜘蛛精', '白骨精', '沙和尚', '沙和尚']
# in 和 not in
# in 用來檢查指定元素是否存在於列表中
# 如果存在，返回 True，否則返回 False
# not in 用來檢查指定元素是否不在列表中
# 如果不在，返回 True，否則返回 False
# print('牛魔王' not in stus)
# print('牛魔王' in stus)
# len() 獲取列表中的元素的個數
# min() 獲取列表中的最小值
# max() 獲取列表中的最大值
arr = [10, 1, 2, 5, 100, 77]
# print(min(arr), max(arr))
# 兩個方法（method），方法和函數基本上是一樣，只不過方法必須通過 對象.方法() 的形式調用
# xxx.print() 方法實際上就是和對象關系緊密的函數
# s.index() 獲取指定元素在列表中的第一次出現時索引
# print(stus.index('沙和尚'))
# index() 的第二個參數，表示查找的起始位置，第三個參數，表示查找的結束位置（包頭不包尾）
# print(stus.index('沙和尚', 3, 7))
# 如果要獲取列表中沒有的元素，會拋出異常
# print(stus.index('牛魔王')) # ValueError: '牛魔王' is not in list
# s.count() 統計指定元素在列表中出現的次數
print(stus.count('牛魔王'))
4.4 序列（sequence）
- 序列是 Python 中最基本的一種數據結構
數據結構指計算機中數據存儲的方式
- 序列用於保存一組有序的數據，所有的數據在序列當中都有一個唯一的位置（索引）
並且序列中的數據會按照添加的順序來分配索引
- 序列的分類：
可變序列（序列中的元素可以改變）：
> 列表（list）
不可變序列（序列中的元素不能改變）：
> 字符串（str）
> 元組（tuple）
上面所講的所有操作都是序列的通用操作。
4.5 修改列表的元素
# 創建一個列表
stus = ['孫悟空', '豬八戒', '沙和尚', '唐僧', '蜘蛛精', '白骨精']
# print("修改前：", stus)
# 修改列表中的元素
# 直接通過索引來修改元素
stus[0] = 'sunwukong'
stus[2] = '哈哈'
# 通過 del 來刪除元素
del stus[2] # 刪除索引為2的元素
# print('修改后：', stus)
stus = ['孫悟空', '豬八戒', '沙和尚', '唐僧', '蜘蛛精', '白骨精']
# print("修改前：", stus)
# 通過切片來修改列表
# 在給切片進行賦值時，只能使用序列
# stus[0:2] = ['牛魔王', '紅孩兒'] # 使用新的元素替換舊元素
# stus[0:2] = ['牛魔王', '紅孩兒', '二郎神'] # 可以傳多個
# stus[0:0] = ['牛魔王'] # 向索引為0的位置插入新的元素
# 當設置了步長時，要替換的序列中元素的個數必須和切片中切出來的元素的個數一致
# stus[::2] = ['牛魔王', '紅孩兒'] # 報錯：切片中切出來的元素的個數是3個元素，而要替換的元素的個數是2個
# stus[::2] = ['牛魔王', '紅孩兒', '二郎神'] # 正確
# 通過切片來刪除元素
# del stus[0:2]
# del stus[::2]
# stus[1:3] = []
# print('修改后：', stus)
# 以上操作，只適用於可變序列
s = 'hello'
# s[1] = 'a' # 報錯：不可變序列，無法通過索引來修改
# 可以通過 list() 函數將其他的序列轉換為list
s = list(s)
print(s)
4.6 列表中的方法
# 列表的方法
stus = ['孫悟空', '豬八戒', '沙和尚']
# print('原列表：', stus)
# append()
# 向列表的最后添加一個元素
# stus.append('唐僧')
# insert()
# 向列表的指定位置插入一個元素
# 參數：
# 1.要插入的位置
# 2.要插入的元素
# stus.insert(2, '唐僧')
# extend()
# 使用新的序列來擴展當前序列
# 需要一個序列作為參數，它會將該序列中的元素添加到當前列表中
# stus.extend(['唐僧', '白骨精'])
# stus += ['唐僧', '白骨精']
# clear()
# 清空序列（可變序列）
# stus.clear()
stus = ['孫悟空', '豬八戒', '沙和尚', '唐僧']
# pop()
# 根據索引刪除並返回被刪除的元素
# result = stus.pop(2) # 刪除序列索引為2的元素
# result = stus.pop() # 刪除序列最后一個元素
# print('result =', result)
# remove()
# 刪除指定值的元素，如果相同值的元素有多個，則只會刪除第一個元素
# stus.remove('豬八戒')
# reverse()
# 用來反轉列表
# stus.reverse()
# sort()
# 用來對列表中的元素進行排序，默認是升序排列（從小到大）
# 如果需要降序排列，則需要傳遞一個 reverse=True 作為參數
my_list = list('asnbdnbasdabd')
my_list = [10, 1, 20, 3, 4, 5, 0, -2]
print('排序前', my_list)
my_list.sort(reverse=True)
print('排序后', my_list)
4.7 遍歷列表（list）
# 遍歷列表：指的就是將列表中的所有元素取出來
# 創建列表
stus = ['孫悟空', '豬八戒', '沙和尚', '唐僧', '白骨精', '蜘蛛精']
# 遍歷列表
# print(stus[0])
# print(stus[1])
# print(stus[2])
# print(stus[3])
# 通過 while 循環來遍歷列表
# i = 0
# while i < len(stus) :
# print(stus[i])
# i += 1
# 通過 for 循環來遍歷列表
# 語法：
# for 變量 in 序列 :
# 代碼塊
# for 循環的代碼塊會執行多次，即序列中有幾個元素就會執行幾次
# 每執行一次就會將序列中的一個元素的值賦值給變量
# 所以我們可以通過變量，來獲取列表中的元素
for s in stus :
print(s)
4.8 EMS 項目練習
- 做命令行版本的員工管理系統
- 功能：
四個：
1.查詢
- 顯示當前系統當中的所有員工
2.添加
- 將員工添加到當前系統中
3.刪除
- 將員工從系統當中刪除
4.退出
- 退出系統
- 員工信息要保存到哪里？ 列表，在系統中應該有一個列表，專門用來保存所有員工信息的。
示例代碼：
# 顯示系統的歡迎信息
print('-'*20, '歡迎使用員工管理系統', '-'*20)
# 創建一個列表，用來保存員工信息，員工的信息以字符串的形式統一保存到列表
emps = ['孫悟空\t18\t男\t花果山', '豬八戒\t28\t男\t高老庄']
while True :
# 顯示用戶的選項
print(' 請選擇要做的操作：')
print('\t1.查詢員工')
print('\t2.添加員工')
print('\t3.刪除員工')
print('\t4.退出系統')
user_choose = input('請選擇要做的操作[1-4]：')
# 為了好看，打印分割線
print('-'*62)
# 根據用戶的選擇來做相關的操作
if user_choose == '1' :
# 查詢員工
# 打印表頭
print('\t序號\t姓名\t年齡\t性別\t地址')
# 創建一個變量，來表示員工的序號
n = 1
# 顯示員工信息
for emp in emps :
print(f'\t{n}\t{emp}')
n += 1
elif user_choose == '2' :
# 添加員工
# 獲取要添加員工的信息：姓名、年齡、性別、住址
emp_name = input('請輸入員工姓名：')
emp_age = input('請輸入員工年齡：')
emp_gender = input('請輸入員工性別：')
emp_address = input('請輸入員工住址：')
# 創建員工信息
emp = f'{emp_name}\t{emp_age}\t{emp_gender}\t{emp_address}'
# 顯示提示信息
print('以下員工將會被添加到系統中')
print('-'*62)
print('\t姓名\t年齡\t性別\t地址')
print(f'\t{emp}')
print('-'*62)
# 確認信息
user_confirm = input('是否確認該操作[Y/N]：')
if user_confirm == 'y' or user_confirm == 'Y' or user_confirm == 'yes' :
# 拼接字符串，插入列表中
emps.append(emp)
print('插入員工成功！')
else :
print('插入員工已取消！')
elif user_choose == '3' :
# 刪除員工，根據員工的序號來刪除員工
del_num = int(input('請輸入要刪除的員工序號：'))
del_index = del_num - 1
# 判斷
if 0 <= del_index <= len(emps) - 1 :
# 顯示提示信息
print('以下員工將會被刪除')
print('-'*62)
print('\t序號\t姓名\t年齡\t性別\t地址')
print(f'\t{del_num}\t{emps[del_index]}')
print('-'*62)
# 確認信息
user_confirm = input('該操作不可恢復，是否確認[Y/N]：')
if user_confirm == 'y' or user_confirm == 'Y' or user_confirm == 'yes' :
# 拼接字符串，插入列表中
emps.pop(del_index)
print('刪除員工成功！')
else :
print('刪除員工已取消！')
else :
print('您的輸入有誤，請重新操作！')
elif user_choose == '4' :
print('歡迎使用，再見！')
input('點擊回車鍵退出系統！')
break
else :
print('您的輸入有誤，請重新輸入！')
# 為了好看，打印分割線
print('-'*62)
4.9 range() 函數
# range() 是一個函數，可以用來生成一個自然數的序列
r = range(5) # 生成一個這樣的序列：[0, 1, 2, 3, 4]
r = range(0, 10, 2) # [0, 2, 4, 6, 8]
r = range(10, 0, -1) # [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
# 該函數需要三個參數
# 1.起始位置（可以省略，默認是 0）
# 2.結束位置
# 3.步長（可以省略，默認是 1）
# print(list(r))
# 通過 range() 可以創建一個執行指定次數的 for 循環
# for() 循環除了創建方式以外，其余的都和 while 一樣，
# 包括 else、包括 break、continue 都可以在 for 循環中使用
# 並且 for 循環使用也更加簡單
# 將之前使用 while 循環做的練習，再使用 for 循環完成一次！
for i in range(30) :
print(i)
# for s in 'hello' :
print(s)
4.10 元組（tuple）
# 元組 tuple
# 元組是一個不可變的序列
# 它的操作的方式基本上和列表是一致的
# 所以你在操作元組時，就把元組當成是一個不可變的列表就ok了
# 一般當我們希望數據不改變時，就使用元組，其余情況都使用列表
# 創建元組
# 使用()來創建元組
my_tuple = () # 創建了一個空元組
# print(my_tuple, type(my_tuple)) # () <class 'tuple'>
my_tuple = (1, 2, 3, 4, 5) # 創建了一個5個元素的元組
# 元組是不可變對象，不能嘗試為元組中的元素重新賦值
# my_tuple[3] = 10 # 報錯：TypeError: 'tuple' object does not support item assignment
# print(my_tuple[3])
# 當元組不是空元組時，括號可以省略
# 如果元組不是空元組，它里邊至少要有一個元素，且該元素后面要有一個逗號
my_tuple = 10, 20, 30, 40
my_tuple = 40, # 注意逗號的存在
# print(my_tuple, type(my_tuple))
# 元組的解包（解構）
# 解包指就是將元組當中每一個元素都賦值給一個變量
my_tuple = 10, 20, 30, 40
a, b, c, d = my_tuple
# print("a =", a)
# print("b =", b)
# print("c =", c)
# print("d =", d)
a = 100
b = 300
print(a, b)
# 交換 a 和 b 的值，這時我們就可以利用元組的解包
a, b = b, a # b, a 等價於 (b, a)
print(a, b)
my_tuple = 10, 20, 30, 40
# 在對一個元組進行解包時，變量的數量必須和元組中的元素的數量一致
# 也可以在變量前邊添加一個*，這樣變量將會獲取元組中所有剩余的元素
a, b, *c = my_tuple
a, *b, c = my_tuple
*a, b, c = my_tuple
# 不能同時出現兩個或以上的*變量
# *a, *b, c = my_tuple # 報錯：SyntaxError: two starred expressions in assignment
print('a =', a)
print('b =', b)
print('c =', c)
練習：
a, b, *c = [1, 2, 3, 4, 5, 6, 7]
a, b, *c = 'hello world'
print('a =', a)
print('b =', b)
print('c =', c)
4.11 可變對象--可變的是對象的值
- 每個對象中都保存了三個數據：
id（標識）
type（類型）
value（值）
- 列表就是一個可變對象
a = [1, 2, 3]
- a[0] = 10 （改對象）
- 這個操作是在通過變量去修改對象的值
- 這種操作不會改變變量所指向的對象
- 當我們去修改對象時，如果有其他變量也指向了該對象，則修改也會在其他的變量中體現
- a = [4, 5, 6] （改變量）
- 這個操作是在給變量重新賦值
- 這種操作會改變變量所指向的對象
- 為一個變量重新賦值時，不會影響其他的變量
- 一般只有在為變量賦值時才是修改變量，其余的都是修改對象。
圖解如下：
示例代碼：
# 可變對象
# a = [1, 2, 3]
# print('修改前：', a, id(a))
# # 通過索引修改列表對象的值
# a[0] = 10
# print('修改后：', a, id(a))
# 為變量重新賦值
# a = [4,5,6]
# print('修改后：', a , id(a))
a = [1, 2, 3]
b = a
# b[0] = 10
b = [10, 2, 3]
# print("a", a, id(a))
# print("b", b, id(b))
# == != 比較的是對象的值是否相等
# is 和 is not 比較的是對象的 id 是否相等（比較兩個對象是否是同一個對象）
a = [1, 2, 3]
b = [1, 2, 3]
print(a, b)
print(id(a), id(b)) # 2133622547080 2133622547144
print(a == b) # True，a和b的值相等，使用 == 會返回 True
print(a is b) # False，a和b不是同一個對象，內存地址不同，使用 is 會返回 False
圖解如下：
改對象的值會影響所有指向該對象的變量
4.12 字典
字典簡介：
- 字典屬於一種新的數據結構，稱為映射（mapping）
- 字典的作用和列表類似，都是用來存儲對象的容器
- 列表存儲數據的性能很好，但是查詢數據的性能的很差
- 在字典中每一個元素都有一個唯一的名字，通過這個唯一的名字可以快速的查找到指定的元素
- 在查詢元素時，字典的效率是非常快的
- 在字典中可以保存多個對象，每個對象都會有一個唯一的名字
這個唯一的名字，我們稱其為鍵（key），通過 key 可以快速的查詢 value
這個對象，我們稱其為值（value）
所以字典，我們也稱為叫做 鍵值對（key-value）結構
每個字典中都可以有多個鍵值對，而每一個鍵值對我們稱其為一項（item）
字典--示例代碼：
# 字典
# 使用 {} 來創建字典
d = {} # 創建了一個空字典
# print(d, type(d)) # {} <class 'dict'>
# 創建一個包含有數據的字典
# 語法：
# {key:value, key:value, key:value}
# 字典的值可以是任意對象
# 字典的鍵可以是任意的不可變對象（int、str、bool、tuple、...），但是一般我們都會使用 str
# 字典的鍵是不能重復的，如果出現重復的鍵，那么后邊的鍵的值會替換前邊的鍵的值
# d = {'name':'孫悟空', 'age':18, 'gender':'男', 'name':'sunwukong'}
d = {
'name':'孫悟空',
'age':18,
'gender':'男',
'name':'sunwukong'
}
# print(d, type(d))
# 需要根據鍵來獲取值
# print(d['name'], d['age'], d['gender'])
# 如果使用了字典中不存在的鍵，會報錯
# print(d['hello']) # KeyError: 'hello'
4.12.1 字典的使用
# 創建字典
# 使用 {}
# 語法：{k1:v1, k2:v2, k3:v3}
# 使用 dict() 函數來創建字典
# 每一個參數都是一個鍵值對，參數名就是鍵，參數值就是值（這種方式創建的字典，key 都是字符串）
d = dict(name='孫悟空', age=18, gender='男')
# 也可以將一個包含有雙值子序列的序列轉換為字典
# 雙值序列，序列中只有兩個值，比如：[1, 2] ('a', 3) 'ab'
# 子序列，如果序列中的元素也是序列，那么我們就稱這個元素為子序列，比如：[(1, 2), (3, 5)]
d = dict([('name', '孫悟飯'), ('age', 18)])
# print(d, type(d))
# len() 獲取字典中鍵值對的個數
# print(len(d))
# in 檢查字典中是否包含指定的鍵
# not in 檢查字典中是否不包含指定的鍵
# print('hello' in d)
# 獲取字典中的值，根據鍵來獲取值
# 語法：d[key]
# print(d['age'])
# n = 'name'
# print(d[n])
# 通過 [] 來獲取值時，如果鍵不存在，會拋出異常 KeyError
# get(key[, default]) 該方法用來根據鍵來獲取字典中的值
# 如果獲取的鍵在字典中不存在，會返回 None
# 也可以指定一個默認值，來作為第二個參數，這樣獲取不到值時將會返回默認值
# print(d.get('name'))
# print(d.get('hello', '默認值'))
# 修改字典
# d[key] = value #如果 key 存在則覆蓋，不存在則添加
d['name'] = 'sunwukong' # 修改字典的 key-value
d['address'] = '花果山' # 向字典中添加 key-value
# print(d)
# setdefault(key[, default]) # 可以用來向字典中添加 key-value
# 如果 key 已經存在於字典中，則返回 key 的值，不會對字典做任何操作
# 如果 key 不存在，則向字典中添加這個 key，並設置 value
result = d.setdefault('name', '豬八戒')
result = d.setdefault('hello', '豬八戒')
# print('result =', result)
# print(d)
# update([other])
# 將其他的字典中的 key-value 添加到當前字典中
# 如果有重復的 key，則后邊的會替換到當前的
d1 = {'a':1, 'b':2, 'c':3}
d2 = {'d':4, 'e':5, 'f':6, 'a':7}
d1.update(d2)
# print(d1) # {'a': 7, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
------------------------------------------------------------------
# 刪除，可以使用 del 來刪除字典中的 key-value
del d1['a']
del d1['b']
# popitem()
# 隨機刪除字典中的一個鍵值對，一般都會刪除最后一個鍵值對
# 刪除之后，它會將刪除的 key-value 作為返回值返回
# 返回的是一個元組，元組中有兩個元素，第一個元素是刪除的 key，第二個是刪除的 value
# 當使用 popitem() 刪除一個空字典時，會拋出異常 KeyError: 'popitem(): dictionary is empty'
# d1.popitem()
# result = d1.popitem()
# pop(key[, default])
# 根據 key 刪除字典中的 key-value
# 會將被刪除的 value 返回！
# 如果刪除不存在的 key，會拋出異常
# 如果指定了默認值，再刪除不存在的 key 時，不會報錯，而是直接返回默認值
result = d1.pop('d')
result = d1.pop('z', '這是默認值')
# del d1['z']
# z 不存在時，也會報錯
# result = d1.popitem()
# result = d1.popitem()
# result = d1.popitem()
# result = d1.popitem()
# clear() 用來清空字典
d1.clear()
# print('result =', result)
# print(d1)
# copy()
# 該方法用於對字典進行淺復制
# 復制以后的對象，和原對象是獨立的，修改一個不會影響另一個
# 注意：淺復制會簡單復制對象內部的值，如果值也是一個可變對象，這個可變對象不會被復制
d1 = {'a':1, 'b':2, 'c':3}
d2 = d1.copy()
# d1['a'] = 100
d1 = {'a':{'name':'孫悟空', 'age':18}, 'b':2, 'c':3}
d2 = d1.copy()
d2['a']['name'] = '豬八戒'
print('d1 =', d1, id(d1))
print('d2 =', d2, id(d2))
4.12.2 字典的遍歷
# 遍歷字典
# keys()
該方法會返回字典的所有的 key
# 該方法會返回一個序列，序列中保存字典的所有的鍵
d = {'name':'孫悟空', 'age':18, 'gender':'男'}
# 通過遍歷 keys() 來獲取所有的鍵
# for k in d.keys() :
# print(k, d[k])
# values()
# 該方法會返回一個序列，序列中保存字典的所有的值
# for v in d.values():
# print(v)
# items()
# 該方法會返回字典中所有的項
# 它會返回一個序列，序列中包含有雙值子序列
# 雙值分別是：字典中的 key 和 value
# print(d.items()) # dict_items([('name', '孫悟空'), ('age', 18), ('gender', '男')])
for k, v in d.items() :
print(k, '=', v)
# 元組的解包（解構）
# 解包指就是將元組當中每一個元素都賦值給一個變量
4.13 集合
集合的介紹：
- 集合和列表非常相似
- 不同點：
1.集合中只能存儲不可變對象
2.集合中存儲的對象是無序（不是按照元素的插入順序保存的）
3.集合中不能出現重復的元素
集合--示例代碼：
# 集合
# 使用 {} 來創建集合
s = {10, 3, 5, 1, 2, 1, 2, 3, 1, 1, 1, 1} # <class 'set'>
# s = {[1, 2, 3], [4, 6, 7]} # TypeError: unhashable type: 'list'
# 使用 set() 函數來創建集合
s = set() # 空集合
# 可以通過 set() 來將序列和字典轉換為集合
s = set([1, 2, 3, 4, 5, 1, 1, 2, 3, 4, 5])
s = set('hello')
s = set({'a':1, 'b':2, 'c':3}) # 使用 set() 將字典轉換為集合時，只會包含字典中的鍵
# 創建集合
s = {'a', 'b', 1, 2, 3, 1}
# 使用 in 和 not in 來檢查集合中的元素
# print('c' in s)
# 使用 len() 來獲取集合中元素的數量
# print(len(s))
# add() 向集合中添加元素
s.add(10)
s.add(30)
# update() 將一個集合中的元素添加到當前集合中
# update() 可以傳遞序列或字典作為參數，字典只會使用鍵
s2 = set('hello')
s.update(s2)
s.update((10, 20, 30, 40, 50)) # 參數是元組
s.update({10:'ab', 20:'bc', 100:'cd', 1000:'ef'}) # 參數是字典
# {1, 2, 3, 100, 40, 'o', 10, 1000, 'a', 'h', 'b', 'l', 20, 50, 'e', 30}
# pop() 隨機刪除並返回一個集合中的元素
# result = s.pop()
# remove() 刪除集合中的指定元素
s.remove(100)
s.remove(1000)
# clear() 清空集合
s.clear()
# copy() 對集合進行淺復制
# print(result)
print(s, type(s))
4.14 集合的運算
# 在對集合做運算時，不會影響原來的集合，而是返回一個運算結果
# 創建兩個集合
s1 = {1, 2, 3, 4, 5}
s2 = {3, 4, 5, 6, 7}
# & 交集運算
result = s1 & s2 # {3, 4, 5}
# | 並集運算
result = s1 | s2 # {1, 2, 3, 4, 5, 6, 7}
# - 差集
result = s1 - s2 # {1, 2}
# ^ 異或集：獲取只在一個集合中出現的元素
result = s1 ^ s2 # {1, 2, 6, 7}
# <= 檢查一個集合是否是另一個集合的子集
# 如果 a 集合中的元素全部都在 b 集合中出現，那么 a 集合就是 b 集合的子集，b 集合是 a 集合的超集
a = {1, 2, 3}
b = {1, 2, 3, 4, 5}
result = a <= b # True
result = {1, 2, 3} <= {1, 2, 3} # True
result = {1, 2, 3, 4, 5} <= {1, 2, 3} # False
# < 檢查一個集合是否是另一個集合的真子集
# 如果超集 b 中含有子集 a 中所有元素，並且 b 中還有 a 中沒有的元素，則 b 就是 a 的真超集，a 是 b 的真子集
result = {1, 2, 3} < {1, 2, 3} # False
result = {1, 2, 3} < {1, 2, 3, 4, 5} # True
# >= 檢查一個集合是否是另一個的超集
# > 檢查一個集合是否是另一個的真超集
print('result =', result)第五章 函數
5.1 函數的簡介
- 函數也是一個對象
- 對象是內存中專門用來存儲數據的一塊區域
- 函數可以用來保存一些可執行的代碼，並且可以在需要時，對這些語句進行多次的調用
- 創建函數（定義函數）：
def 函數名([形參1, 形參2, ..., 形參n]) :
代碼塊
- 函數名必須要符和標識符的規范
（可以包含字母、數字、下划線、但是不能以數字開頭）
- 函數中保存的代碼不會立即執行，需要調用函數代碼才會執行
- 調用函數：
函數對象()
- 定義函數一般都是要實現某種功能的
函數的簡介--示例代碼：
# 比如有如下三行代碼，這三行代碼是一個完整的功能：
# print('hello')
# print('你好')
# print('再見')
# 定義一個函數
def fn() :
print('這是我的第一個函數！')
print('hello')
print('今天天氣真不錯！')
# 打印 fn
# print(fn) # <function fn at 0x03D2B618>
# print(type(fn)) # <class 'function'>
# fn 是函數對象 fn() 是調用函數
# print 是函數對象 print() 是調用函數
# fn()
# 定義一個函數，可以用來求任意兩個數的和
# def sum() :
# a = 123
# b = 456
# print(a + b)
# sum()
# 定義函數時指定形參
def fn2(a, b) :
# print('a =', a)
# print('b =', b)
print(a, "+", b, "=", a + b)
# 調用函數時，來傳遞實參
fn2(10, 20)
fn2(123, 456)
5.2 函數的參數
- 在定義函數時，可以在函數名后的()中定義數量不等的形參。
多個形參之間使用,隔開
- 形參（形式參數），定義形參就相當於在函數內部聲明了變量，但是並不賦值
- 實參（實際參數）
- 如果函數定義時，指定了形參，那么在調用函數時也必須傳遞實參，實參將會賦值給對應的形參，簡單來說，有幾個形參就得傳幾個實參。
練習1:
定義一個函數，可以用來求任意三個數的乘積。
練習2：
定義一個函數，可以根據不同的用戶名顯示不同的歡迎信息。
示例代碼：
# 求任意三個數的乘積
def mul(a, b, c) :
print(a * b * c)
# 根據不同的用戶名顯示不同的歡迎信息
def welcome(username) :
print('歡迎', username, '光臨')
# mul(1, 2, 3)
# welcome('孫悟空')
5.3 函數參數傳遞的方式
# 定義一個函數
# 定義形參時，可以為形參指定默認值
# 指定了默認值以后，如果用戶傳遞了參數則形參默認值沒有任何作用，如果用戶沒有傳遞參數，則形參默認值就會生效。
def fn(a = 5, b = 10, c = 20) :
print('a =', a)
print('b =', b)
print('c =', c)
# fn(1, 2, 3)
# fn(1, 2)
# fn()
# 實參的傳遞方式
# 位置參數
# 位置參數：就是將對應位置的實參賦值給對應位置的形參
# 第一個實參賦值給第一個形參，第二個實參賦值給第二個形參，......
# fn(1, 2, 3)
# 關鍵字參數
# 關鍵字參數：可以不按照形參定義的順序去傳遞，而直接根據參數名去傳遞參數
# fn(b=1, c=2, a=3)
# print('hello', end='') # end 就是關鍵字參數
# 位置參數和關鍵字參數可以混合使用
# 混合使用位置參數和關鍵字參數時，必須將位置參數寫到前面，且位置參數和關鍵字參數指定的位置不能相同。
# fn(1, c=30) # a = 1, b = 10, c = 30
# fn(1, a=30) # 報錯
def fn2(a) :
print('a =', a)
# 函數在調用時，解析器不會檢查實參的類型
# 實參可以傳遞任意類型的對象
b = 123
b = True
b = 'hello'
b = None
b = [1, 2, 3]
# fn2(b)
# fn2(fn) # 沒問題，實參可以是函數對象
def fn3(a , b) :
print(a + b)
# fn3(123, "456") # 報錯
def fn4(a) :
# 在函數中對形參進行重新賦值，不會影響其他的變量
# a = 20
# a 是一個列表，我們嘗試修改列表中的元素
# 如果形參執行的是一個對象，當我們通過形參去修改對象的值時，會影響到所有指向該對象的變量。
a[0] = 30
print('a =', a, id(a))
c = 10
c = [1, 2, 3]
# fn4(c)
# fn4(c.copy()) # 列表副本，新的對象
# fn4(c[:]) # 列表副本，新的對象
# print('c =', c, id(c))
5.4 函數的不定長參數
# 不定長的參數
# 定義一個函數，可以求任意個數字的和
def sum(*nums) :
# 定義一個變量，來保存結果
result = 0
# 遍歷元組，並將元組中的數進行累加
for n in nums :
result += n
print(result)
# sum(123, 456, 789, 10, 20, 30, 40)
# 在定義函數時，可以在形參前邊加上一個*，這樣這個形參將會獲取到所有的實參
# 它將會將所有的實參保存到一個元組中
# a, b, *c = (1, 2, 3, 4, 5, 6) # 元組的解包（解構）
# *a 會接受所有的位置實參，並且會將這些實參統一保存到一個元組中（參數的裝包）
def fn(*a) :
print("a =", a, type(a)) # a = (1, 2, 3, 4, 5) <class 'tuple'>
fn(1, 2, 3, 4, 5)
# 帶星號的形參只能有一個
# 帶星號的參數，可以和其他參數配合使用
# 第一個參數給 a，第二個參數給 b，剩下的都保存到 c 的元組中
def fn2(a, b, *c) :
print('a =', a) # a = 1
print('b =', b) # b = 2
print('c =', c) # c = (3, 4, 5)
fn2(1, 2, 3, 4, 5)
# 可變參數不是必須寫在最后，但是注意，帶*的參數后的所有參數，必須以關鍵字參數的形式傳遞
# 第一個參數給 a，剩下的位置參數給 b 的元組，c 必須使用關鍵字參數
def fn2(a, *b, c) :
print('a =', a) # a = 1
print('b =', b) # b = (2, 3, 4)
print('c =', c) # c = 5
fn2(1, 2, 3, 4, c=5)
# 所有的位置參數都給a，b 和 c 必須使用關鍵字參數
def fn2(*a, b, c) :
print('a =',a) # a = (1, 2, 3)
print('b =',b) # b = 4
print('c =',c) # c = 5
fn2(1, 2, 3, b=4, c=5)
# 如果在形參的開頭直接寫一個*，則要求我們的所有的參數必須以關鍵字參數的形式傳遞
def fn2(*, a, b, c) :
print('a =', a) # a = 3
print('b =', b) # b = 4
print('c =', c) # c = 5
fn2(a=3, b=4, c=5)
# *形參只能接收位置參數，而不能接收關鍵字參數
def fn3(*a) :
print('a =', a) # a = (1, 2, 3, 4, 5)
fn3(1, 2, 3, 4, 5)
# **形參可以接收其他的關鍵字參數，它會將這些參數統一保存到一個字典中
# 字典的 key 就是參數的名字，字典的 value 就是參數的值
# **形參只能有一個，並且必須寫在所有參數的最后
def fn3(b, c, **a) :
print('a =', a, type(a)) # a = {'d': 2, 'e': 10, 'f': 20} <class 'dict'>
print('b =', b) # b = 1
print('c =', c) # c = 3
fn3(b=1, d=2, c=3, e=10, f=20)
# 參數的解包（拆包）
def fn4(a, b, c) :
print('a =', a)
print('b =', b)
print('c =', c)
# 創建一個元組
t = (10, 20, 30)
# 創建一個列表
# t = [10, 20, 30]
# 傳遞實參時，也可以在序列類型的參數前添加星號，這樣它會自動將序列中的元素依次作為參數傳遞
# 這里要求序列中元素的個數必須和形參的個數的一致
# fn4(t[0], t[1], t[2]) # 此種方式太麻煩了
fn4(*t) # 解包的方式
# 創建一個字典
d = {'a':100, 'b':200, 'c':300}
# 通過 ** 來對一個字典進行解包操作
fn4(**d)
5.5 函數的返回值
# 返回值，返回值就是函數執行以后返回的結果
# 可以通過 return 來指定函數的返回值
# 可以直接使用函數的返回值，也可以通過一個變量來接收函數的返回值
def sum(*nums) :
# 定義一個變量，來保存結果
result = 0
# 遍歷元組，並將元組中的數進行累加
for n in nums :
result += n
print(result)
# sum(123, 456, 789)
# return 后邊跟什么值，函數就會返回什么值
# return 后邊可以跟任意的對象，返回值甚至可以是一個函數
def fn() :
# return 'hello'
# return [1, 2, 3]
# return {'k':'v'}
def fn2() :
print('hello')
return fn2 # 返回值也可以是一個函數
r = fn() # 這個函數的執行結果就是它的返回值
# r()
# print(fn())
# print(r)
# 如果僅僅寫一個 return 或者不寫 return，則相當於 return None
def fn2() :
a = 10
return
# 在函數中，return 后的代碼都不會執行，return 一旦執行，則函數自動結束
def fn3():
print('hello')
return
print('abc')
# r = fn3()
# print(r)
def fn4() :
for i in range(5) : # 生成一個這樣的自然數序列：[0, 1, 2, 3, 4]
if i == 3 :
# break 用來退出當前循環
# continue 用來跳過當次循環
return # 用來結束函數
print(i)
print('循環執行完畢！')
# fn4()
def sum(*nums) :
# 定義一個變量，來保存結果
result = 0
# 遍歷元組，並將元組中的數進行累加
for n in nums :
result += n
return result
r = sum(123, 456, 789)
# print(r + 778)
def fn5():
return 10
# fn5 和 fn5() 的區別
print(fn5) # fn5 是函數對象，打印 fn5 實際是在打印函數對象：<function fn5 at 0x05771BB8>
print(fn5()) # fn5() 是在調用函數，打印 fn5() 實際上是在打印 fn5() 函數的返回值：10
5.6 函數的文檔字符串--函數的說明
# help() 是 Python 中的內置函數
# 通過 help() 函數可以查詢 python 中的函數的用法
# 語法：help(函數對象)
# help(print) # 獲取 print() 函數的使用說明
# 文檔字符串（doc str）
# 在自定義函數時，可以在函數內部編寫文檔字符串，文檔字符串就是【函數的說明】，建議使用英文編寫，哈哈！
# 當我們編寫了文檔字符串時，就可以通過 help() 函數來查看自定義函數的說明
# 文檔字符串非常簡單，其實直接在函數的第一行寫一個字符串就是文檔字符串，單引號和雙引號均可，但是一般使用 三重引號，因為三重引號可以換行，並且會保留字符串中的格式。
def fn(a: int, b: bool, c: str='hello') -> int :
'''
這是一個文檔字符串的示例
函數的作用：......
函數的參數：
a，作用，類型，默認值......
b，作用，類型，默認值......
c，作用，類型，默認值......
'''
return 10
help(fn)
5.7 變量的作用域與命名空間
# 作用域（scope）
# 作用域指的是變量生效的區域
b = 20 # 全局變量
def fn() :
a = 10 # a定義在了函數內部，所以它的作用域就是函數內部，函數外部無法訪問
print('函數內部：', 'a =', a)
print('函數內部：', 'b =', b)
# fn()
print('函數外部：', 'a =', a)
print('函數外部：', 'b =', b)
# 在 Python 中一共有兩種作用域：
# 全局作用域
# - 全局作用域在程序執行時創建，在程序執行結束時銷毀
# - 所有函數以外的區域都是全局作用域
# - 在全局作用域中定義的變量，都屬於全局變量，全局變量可以在程序的任意位置被訪問
# 函數作用域
# - 函數作用域在函數調用時創建，在調用結束時銷毀
# - 函數每調用一次就會產生一個新的函數作用域
# - 在函數作用域中定義的變量，都是局部變量，它只能在函數內部被訪問
#
# 變量的查找--就近原則
# - 當我們使用變量時，會優先在當前作用域中尋找該變量，如果有則使用，
# 如果沒有，則繼續去上一級作用域中尋找，如果有則使用，
# 如果依然沒有，則繼續去上一級作用域中尋找，以此類推
# 直到找到全局作用域，依然沒有找到，則會拋出異常：NameError: name 'a' is not defined
def fn2() :
def fn3() :
print('fn3中:', 'a =', a)
fn3()
# fn2()
a = 20
def fn3() :
# a = 10 # 在函數中為變量賦值時，默認都是為局部變量賦值
# 如果希望在函數內部修改全局變量，則需要使用 global 關鍵字，來聲明變量
global a # 聲明在函數內部使用的 a 是全局變量，此時再去修改 a 時，就是在修改全局的 a
a = 10 # 修改全局變量
print('函數內部：', 'a =', a)
# fn3()
# print('函數外部：', 'a =', a)
-------------------------------------------------------------------------------------
# 命名空間（namespace）
# 命名空間指的是變量存儲的位置，每一個變量都需要存儲到指定的命名空間當中
# 每一個作用域都會有一個它對應的命名空間
# 全局的命名空間，用來保存全局變量
# 函數的命名空間，用來保存函數中的變量（局部變量）
# 命名空間實際上就是一個字典，是一個專門用來存儲變量的字典
# locals() 用來獲取當前作用域的命名空間
# 如果在全局作用域中調用 locals()，則獲取的是全局命名空間
# 如果在函數作用域中調用 locals()，則獲取的是函數的命名空間
# 返回的是一個字典
a = 10
scope = locals() # 獲取當前命名空間
print(scope)
print(type(scope)) # <class 'dict'>
# print(a) # 10
# print(scope['a']) # 10
# 向 scope 中添加一個 key-value
scope['c'] = 1000 # 向字典中添加 key-value 就相當於在全局中創建了一個全局變量（一般不建議這么做）
print(c)
def fn4() :
a = 10
# scope = locals() # 在函數內部調用 locals()，則會獲取到函數的命名空間
# scope['b'] = 20 # 通過函數的命名空間創建一個局部變量，但是也是不建議這么做，這樣做的不清晰，閱讀起來費勁
# print(scope) # {'a' : 10, 'b' : 20}
global_scope = globals() # globals() 函數可以用來在任意位置獲取全局命名空間
print(global_scope['a']) # 獲取全局變量的值
global_scope['a'] = 30 # 修改全局變量的值
fn4()
5.8 函數的遞歸
# 嘗試求10的階乘（10!）
# 1! = 1
# 2! = 1*2 = 2
# 3! = 1*2*3 = 6
# 4! = 1*2*3*4 = 24
# print(1*2*3*4*5*6*7*8*9*10)
# 創建一個變量保存結果
# n = 10
# for i in range(1, 10) : # 生成一個這樣的自然數序列：[1, 2, 3, 4, 5, 6, 7, 8, 9]
# n *= i # n = n * i # 第一次：10 = 10 * 1，第二次：20 = 10 * 2，第三次：60 = 20 * 3，......
# print(n)
# 創建一個函數，可以用來求任意數的階乘
def factorial(n) :
'''
該函數用來求任意數的階乘
參數：
n 要求階乘的數字
'''
# 創建一個變量，來保存結果
result = n
for i in range(1, n) :
result *= i
return result
# 求10的階乘
# print(factorial(10))
-------------------------------------------------------------------------------------
# 遞歸式的函數
# 從前有座山，山里有座廟，廟里有個老和尚講故事，講的什么故事呢？
# 從前有座山，山里有座廟，廟里有個老和尚講故事，講的什么故事呢？
# 從前有座山，山里有座廟，廟里有個老和尚講故事，講的什么故事呢？
# ....
# 遞歸簡單理解就是自己去引用自己！
# 遞歸式函數：在函數中自己調用自己！
# 無窮遞歸：如果這個函數被調用，程序的內存會溢出，效果類似於死循環
# def fn() :
# fn()
# fn()
# 遞歸是解決問題的一種方式，它和循環很像
# 它的整體思想是：將一個大問題分解為一個個的小問題，直到問題無法分解時，再去解決問題
# 遞歸式函數的兩個必要條件：
# 1.基線條件
# - 問題可以被分解為的最小問題，當滿足基線條件時，遞歸就不在執行了
# 2.遞歸條件
# - 將問題繼續分解的條件
# 遞歸和循環類似，基本是可以互相代替的
# 循環編寫起來比較容易，閱讀起來稍難
# 遞歸編寫起來難，但是方便閱讀
# 10! = 10 * 9!
# 9! = 9 * 8!
# 8! = 8 * 7!
# ......
# 1! = 1
def factorial(n) :
'''
該函數用來求任意數的階乘
參數：
n 要求階乘的數字
'''
# 基線條件：判斷n是否為1，如果為1，則此時不能再繼續遞歸
if n == 1 :
# 1的階乘就是1，直接返回1
return 1
# 遞歸條件：
return n * factorial(n-1) # n * (n - 1)!
print(factorial(10))
# 遞歸練習1：
# 創建一個函數 power 來為任意數字做冪運算 n ** i
# 10 ** 5 = 10 * 10 ** 4
# 10 ** 4 = 10 * 10 ** 3
# ...
# 10 ** 1 = 10
def power(n, i) :
'''
power() 用來為任意的數字做冪運算
參數：
n 要做冪運算的數字
i 做冪運算的次數
'''
# 基線條件
if i == 1 :
# 求1次冪
return n
# 遞歸條件
return n * power(n, i-1) # n * (n ** (i-1))
# print(power(8, 6))
# 遞歸練習2：
# 創建一個函數，用來檢查一個任意的字符串是否是回文字符串，如果是返回 True，否則返回 False
# 回文字符串，字符串從前往后念和從后往前念是一樣的
# abcba
# abcdefgfedcba
# 先檢查第一個字符和最后一個字符是否一致：
# 如果不一致，則不是回文字符串
# 如果一致，則看剩余的部分是否是回文字符串
# 檢查 abcdefgfedcba 是不是回文
# 檢查 bcdefgfedcb 是不是回文
# 檢查 cdefgfedc 是不是回文
# 檢查 defgfed 是不是回文
# 檢查 efgfe 是不是回文
# 檢查 fgf 是不是回文
# 檢查 g 是不是回文
def hui_wen(s) :
'''
該函數用來檢查指定的字符串是否回文字符串，如果是返回True，否則返回False
參數：
s：就是要檢查的字符串
'''
# 基線條件
if len(s) < 2 :
# 字符串的長度小於2，則字符串一定是回文
return True
elif s[0] != s[-1] :
# 第一個字符和最后一個字符不相等，則不是回文字符串
return False
# 遞歸條件
return hui_wen(s[1: -1]) # [1: -1] 包頭不包尾
# def hui_wen(s) :
# '''
# 該函數用來檢查指定的字符串是否回文字符串，如果是返回 True，否則返回 False
# 參數：
# s：就是要檢查的字符串
# '''
# # 基線條件
# if len(s) < 2 :
# # 字符串的長度小於2，則字符串一定是回文
# return True
# # 遞歸條件
# return s[0] == s[-1] and hui_wen(s[1: -1])
print(hui_wen('abcdefgfedcba'))
回文字符串圖解如下：
5.9 高階函數
函數式編程：Python 支持函數式編程，但是 Python 不是函數式編程語言，Scala 是函數式編程。
- 在 Python 中，函數是一等對象
- 一等對象一般都會具有如下特點：
① 對象是在運行時創建的
② 能賦值給變量或作為數據結構中的元素
③ 能作為參數傳遞
④ 能作為返回值返回
- 高階函數
- 高階函數至少要符合以下兩個特點中的一個
① 接收一個或多個函數作為參數
② 將函數作為返回值返回
- 裝飾器
高階函數--示例代碼：
# 高階函數
# 接收一個或多個函數作為參數，或者將函數作為返回值的函數是高階函數。
# 當我們使用一個函數作為參數時，實際上是將指定的代碼傳遞進了目標函數。
# 創建一個列表
l = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 定義一個函數：可以將指定列表中的所有的偶數，保存到一個新的列表中返回
# 定義一個函數：這個函用來檢查一個任意的數字是否是偶數
def fn2(i) :
if i % 2 == 0 :
return True
return False
# 定義一個函數：這個函數用來檢查指定的數字是否大於5
def fn3(i) :
if i > 5 :
return True
return False
# 定義一個函數：這個函數用來檢查指定的數字是否是3個倍數
def fn4(i) :
return i % 3 == 0
def fn(func, lst) :
'''
fn() 函數可以將指定列表中的所有偶數獲取出來，並保存到一個新列表中返回
參數：
lst：要進行篩選的列表
'''
# 創建一個新列表
new_list = []
# 對列表進行篩選
for n in lst :
# 功能
if func(n) :
new_list.append(n)
# 返回新列表
return new_list
# print(fn(fn2, l))
# print(fn(fn3, l))
# print(fn(fn4, l))
-------------------------------------------------------------------------------------
# filter()
# filter() 可以從序列中過濾出符合條件的元素，保存到一個新的序列中
# 參數：
# 1.函數，根據該函數來過濾序列（可迭代的結構）
# 2.需要過濾的序列（可迭代的結構）
# 返回值：
# 過濾后的新序列（可迭代的結構）
# print(filter(fn4, l)) # <filter object at 0x0000017CAC9E0390>
# print(list(filter(fn4, l))) # [3, 6, 9]
# fn4 是作為參數傳遞進 filter() 函數中
# 而 fn4 實際上只有一個作用，就是作為 filter() 的參數
# filter() 調用完畢以后，fn4 就已經沒用
-------------------------------------------------------------------------------------
# 匿名函數 = lambda 函數表達式 （語法糖：簡寫）
# lambda 函數表達式專門用來創建一些簡單的函數，它是函數創建的又一種方式
# 語法：lambda 參數列表 : 返回值
# 匿名函數一般都是作為參數使用，其它地方一般不會使用，功能復雜時，就不要再使用匿名函數了！
def fn5(a, b) :
return a + b
lambda a, b : a + b
# (lambda a, b : a + b)(10, 30) # 調用匿名函數，但一般不會這么做
# 也可以將匿名函數賦值給一個變量，但一般不會這么做，相當於給函數起名字了
fn6 = lambda a, b : a + b
# print(fn6(10, 30))
r = filter(lambda i : i > 5, l)
# print(list(r))
-------------------------------------------------------------------------------------
# map()
# map() 函數可以對可迭代的對象中的所有元素做指定的操作，然后將其添加到一個新的對象中返回
l = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
r = map(lambda i : i ** 2, l)
# print(list(r)) # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
-------------------------------------------------------------------------------------
# sort()
# 該方法用來對列表中的元素進行排序
# sort() 方法默認是直接比較列表中的元素的大小
# 在 sort() 中可以接收一個關鍵字參數 key
# key 需要一個函數作為參數，當設置了函數作為參數，每次都會以列表中的一個元素作為參數來調用函數，並且使用函數的返回值來比較元素的大小
l = ['bb', 'aaaa', 'c', 'ddddddddd', 'fff']
# l.sort(key=len) # 高階函數示例：len 是函數對象，作為了 sort() 函數的參數，是一個高階函數的例子
# print(l) # ['c', 'bb', 'fff', 'aaaa', 'ddddddddd']
l = [2, 5, '1', 3, '6', '4']
l.sort(key=int) # 高階函數示例
# print(l)
# 把列表中的元素轉換為 int 類型的數值，然后進行比較
-------------------------------------------------------------------------------------
# sorted()
# 這個函數和 sort() 的用法基本一致，但是 sorted() 可以對任意的序列進行排序
# 並且使用 sorted() 排序不會影響原來的對象，而是返回一個新對象
l = [2, 5, '1', 3, '6', '4']
# l = "123765816742634781"
print('排序前:', l)
print(sorted(l, key=int)) # 高階函數示例
print('排序后:', l)
5.10 函數的閉包
# 閉包
# 將函數作為返回值返回，也是一種高階函數
# 這種高階函數我們也稱為叫做【閉包】，通過閉包可以創建一些只有當前函數能訪問的變量
# 我們可以將一些私有的數據藏到的閉包中
def fn() :
a = 10
# 在函數內部再定義一個函數
def inner() :
print('我是fn2', a)
# 將內部函數 inner 作為返回值返回
return inner
r = fn()
r()
# r 是一個函數，是調用 fn() 后返回的函數，該函數沒有參數
# 這個函數是在 fn() 內部定義，並不是全局函數
# 所以這個函數總是能訪問到 fn() 函數內的變量，比如：a，而外部不能訪問 a。
注意：
在全局位置不能訪問局部位置的變量。
如果希望在函數內部（局部位置）來修改全局變量，則需要使用 global 關鍵字，聲明在函數內部使用的局部變量是全局變量。
-------------------------------------------------------------------------------------
# 求多個數的平均值
# nums = [50, 30, 20, 10, 77]
# sum() 用來求一個列表中所有元素的和
# print(sum(nums)/len(nums))
# 形成閉包的必要條件：
# ① 有函數嵌套
# ② 外部函數將內部函數作為返回值返回
# ③ 內部函數必須要使用到外部函數中的變量，這樣閉包才有意義！
def make_averager() :
# 創建一個列表，用來保存數值
nums = []
# 創建一個函數，用來計算平均值
def averager(n) :
# 將n添加到列表中
nums.append(n)
# 求平均值
return sum(nums)/len(nums)
return averager
averager = make_averager() # averager 是一個函數，是調用 make_averager() 后返回的函數，該函數有一個參數，即該函數調用時需要傳入參數
print(averager(10)) # 調用 averager 函數：averager(10)
print(averager(20))
print(averager(30))
print(averager(40))
5.11 裝飾器--擴展函數的功能
# 創建幾個函數
def add(a, b) :
'''
求任意兩個數的和
'''
r = a + b
return r
def mul(a, b) :
'''
求任意兩個數的積
'''
r = a * b
return r
# r = add(123, 456)
# print(r)
# 希望函數可以在計算前打印開始計算；計算結束后打印計算完畢
# 我們可以直接通過修改函數中的代碼來完成這個需求，但是會產生以下一些問題
# ① 如果要修改的函數過多，修改起來會比較麻煩
# ② 並且不方便后期的維護
# ③ 並且這樣做會違反開閉原則（OCP）
# 程序的設計：要求開放對程序的擴展，要關閉對程序的修改
# 我們希望在不修改原函數的情況下，來對函數進行擴展：
def fn() :
print('我是fn函數......')
# 只需要根據現有的函數，來創建一個新的函數
def fn2() :
print('函數開始執行~~~')
fn()
print('函數執行結束~~~')
fn2()
def new_add(a, b) :
print('計算開始~~~')
r = add(a, b)
print('計算結束~~~')
return r
r = new_add(111, 222)
print(r)
-------------------------------------------------------------------------------------
# 上邊的方式，已經可以在不修改源代碼的情況下對函數進行擴展了
# 但是，這種方式要求我們每擴展一個函數就要手動創建一個新的函數，實在是太麻煩了
# 為了解決這個問題，我們創建一個函數，讓這個函數可以自動的幫助我們生產函數
def begin_end(old) :
'''
用來對其他函數進行擴展，使其他函數可以在執行前打印開始執行，執行后打印執行結束
參數：
old 要擴展的函數對象
'''
# 創建一個新函數
def new_function(*args, **kwargs) : # 所有的位置參數都給 args，所有的關鍵字參數都給 kwargs
print('開始執行~~~')
# 調用被擴展的函數
result = old(*args, **kwargs) # 把要擴展的函數作為函數的參數傳遞進來，參數變化就是函數變化
print('執行結束~~~')
# 返回函數的執行結果
return result
# 返回新函數
return new_function
f1 = begin_end(fn)
f2 = begin_end(add)
f3 = begin_end(mul)
# r = f1()
# r = f2(123, 456)
# r = f3(123, 456)
# print(r)
# 向 begin_end() 這種函數我們就稱它為裝飾器（器=函數）
# 通過裝飾器，可以在不修改原來函數的情況下來對函數進行擴展
# 在開發中，我們都是通過裝飾器來擴展函數的功能
# 1.在定義函數時，可以通過@裝飾器，來使用指定的裝飾器，來裝飾當前的函數
# 2.可以同時為一個函數指定多個裝飾器，這樣函數將會按照【從內向外】的順序被裝飾
def fn(old) :
'''
用來對其他函數進行擴展，使其他函數可以在執行前打印開始執行，執行后打印執行結束
參數：
old 要擴展的函數對象
'''
# 創建一個新函數
def new_function(*args, **kwargs) :
print('fn裝飾~開始執行~~~')
# 調用被擴展的函數
result = old(*args, **kwargs)
print('fn裝飾~執行結束~~~')
# 返回函數的執行結果
return result
# 返回新函數
return new_function
@fn
@begin_end
def say_hello() :
print('大家好~~~')
say_hello()
第六章 對象
6.1 面向對象
什么是對象？
- 對象是內存中專門用來存儲數據的一塊區域。
- 對象中可以存放各種數據（比如：數字、布爾值、代碼）
- 對象由三部分組成：
1.對象的標識（id）
2.對象的類型（type）
3.對象的值（value）
面向對象（oop）
- Python 是一門面向對象的編程語言
- 所謂的面向對象的語言：簡單理解就是語言中的所有操作都是通過對象來進行的
- 面向過程的編程語言（員工的思維--執行者）
- 面向過程指將我們的程序的邏輯分解為一個一個的步驟
通過對每個步驟的抽象，來完成程序
- 例子：
- 孩子上學
1.媽媽起床
2.媽媽上廁所
3.媽媽洗漱
4.媽媽做早飯
5.媽媽叫孩子起床
6.孩子上廁所
7.孩子洗漱
8.孩子吃飯
9.孩子背着書包上學校
- 面向過程的編程思想將一個功能分解為一個一個小的步驟（細節都在“平面”上，暴露了更多的程序細節）
我們通過完成一個一個的小的步驟來完成一個程序
- 這種編程方式，符合我們人類的思維，編寫起來相對比較簡單
- 但是這種方式編寫代碼的往往只適用於一個功能，
如果要在實現別的功能，即使功能相差極小，也往往要重新編寫代碼
所以它可復用性比較低，並且難於維護
- 面向對象的編程語言（領導的思維--決策者）
- 面向對象的編程語言，關注的是對象，而不關注過程
- 對於面向對象的語言來說：一切都是對象
- 例子：
1.孩子他媽起床叫孩子上學
- 面向對象的編程思想，將所有的功能統一保存到對應的對象中（細節都在對象中）
比如，媽媽功能保存到媽媽的對象中，孩子的功能保存到孩子對象中
要使用某個功能，直接找到對應的對象調用功能即可
- 這種方式編寫的代碼，比較容易閱讀，並且比較易於維護，容易復用
- 但是這種方式編寫，不太符合常規的思維，編寫起來稍微麻煩一點
- 簡單歸納一下，面向對象的思想就是：
0.寫對象（准備階段）
1.找對象
2.調對象
面向過程是一件事“該怎么做”；
面向對象是一件事“該讓誰來做”，然后那個“誰”就是對象，他要怎么做是他自己的事，反正最后一群對象合力能把事做好就行了。
6.2 類的簡介
類(class)
- 我們目前所學習的對象都是 Python 內置的對象
- 但是內置對象並不能滿足所有的需求，所以我們在開發中經常需要自定義一些對象
- 類，簡單理解它就相當於一個圖紙。在程序中我們需要根據類來創建對象。
- 類就是對象的圖紙！
- 我們也稱對象是類的實例（instance）
- 如果多個對象是通過一個類創建的，我們稱這些對象是一類對象
- 像 int() float() bool() str() list() dict() ...... 這些都是類，是 Python 的內置類，使用的是小寫字母開頭
- a = int(10) # 創建一個 int 類的實例 等價於 a = 10
- 我們自定義的類都需要使用大寫字母開頭，使用大駝峰命名法（帕斯卡命名法）來對類命名
- 類也是一個對象！
- 類就是一個用來創建對象的對象！
- 類是 type 類型的對象，定義類實際上就是定義了一個 type 類型的對象。
類的簡介--示例代碼：
a = int(10) # 創建一個 int 類的實例
b = str('hello') # 創建一個 str 類的實例
# print(a, type(a))
# print(b, type(b))
# 定義一個簡單的類
# 使用 class 關鍵字來定義類，語法和函數很像！
# class 類名([父類]) :
# 代碼塊
# 定義一個自定義的類，括號可寫可不寫！！！
class MyClass() :
pass
print(MyClass) # <class '__main__.MyClass'>
# 使用 MyClass 創建一個對象
# 使用類來創建對象，就像調用一個函數一樣
mc_1 = MyClass() # mc_1 就是通過 MyClass 創建的對象，mc_1 是 MyClass 的實例
mc_2 = MyClass()
mc_3 = MyClass()
mc_4 = MyClass()
# mc_1 mc_2 mc_3 mc_4 都是 MyClass 的實例，他們都是一類對象
# isinstance() 用來檢查一個對象是否是一個類的實例
result = isinstance(mc_2, MyClass)
result = isinstance(mc_2, str)
# print(mc_1, type(mc_1)) # <__main__.MyClass object at 0x000001740ADB0278> <class '__main__.MyClass'>
# print('result =', result)
# print(id(MyClass), type(MyClass)) # 1597876961928 <class 'type'>
# 現在我們通過 MyClass 這個類創建的對象都是一個空對象
# 也就是對象中實際上什么都沒有，就相當於是一個空的盒子
# 可以向對象中添加變量，對象中的變量稱為屬性
# 語法：對象.屬性名 = 屬性值
mc_1.name = '孫悟空'
mc_2.name = '豬八戒'
print(mc_2.name)
自定義的類的內存圖解：
6.3 類的定義+類的屬性和方法
類的定義
- 類和對象都是對現實生活中的事物或程序中的內容的抽象
- 實際上所有的事物都由兩部分構成：
1.數據（屬性）
2.行為（方法）
- 在類的代碼塊中，我們可以定義變量和函數（方法）：
變量會成為該類實例的公共屬性，所有的該類實例都可以通過 對象.屬性名 的形式訪問
函數會成為該類實例的公共方法，所有的該類實例都可以通過 對象.方法名() 的形式調用方法
- 注意：
對象中的方法調用時，第一個參數由解析器自動傳遞，所以在定義方法時，至少要定義一個形參！！！
- 實例為什么能訪問到類中的屬性和方法？
類中定義的屬性和方法都是公共的，任何該類實例都可以訪問。
- 屬性和方法查找的流程：
當我們調用一個對象的屬性時，解析器會先在當前對象中尋找是否含有該屬性：
如果有，則直接返回當前對象的屬性值；
如果沒有，則去當前對象的類對象中去尋找，如果有，則返回類對象的屬性值；
如果類對象中依然沒有，則報錯！
調用一個對象的方法的流程同理！
- 類對象和實例對象中都可以保存屬性（方法）：
- 如果這個屬性（方法）是所有的實例共享的，則應該將其保存到類對象中（共性的東西）
- 如果這個屬性（方法）是某個實例獨有的，則應該保存到實例對象中（特性的東西）
- 一般情況下：屬性保存到實例對象中，而方法需要保存到類對象中。
類的定義--示例代碼：
# 嘗試定義一個表示人的類
class Person :
# 在類的代碼塊中，我們可以定義變量和函數
# 在類中我們所定義的變量，將會成為所有的實例的公共屬性
# 所有實例都可以訪問這些變量
name = 'swk' # 公共屬性，所有實例都可以訪問
# 在類中也可以定義函數，類中的定義的函數，我們稱為【方法】
# 這些方法可以通過該類的所有實例來訪問
def say_hello(self) :
# 方法每次被調用時，解析器都會自動傳遞第一個實參
# 第一個參數：就是調用該方法的對象本身：
# 如果是 p1 調的，則第一個參數就是 p1 對象
# 如果是 p2 調的，則第一個參數就是 p2 對象
# 一般我們都會將這個參數命名為 self
# 對於 say_hello() 這個方法，假如讓其顯示如下格式的數據：
# 你好！我是 xxx
# 注意：在類中的方法中我們不能直接訪問類中的屬性，那么該如何辦呢？
print('你好！我是 %s' %self.name)
# 創建 Person 的實例
p1 = Person()
p2 = Person()
# print(p2.name)
# 調用方法：對象.方法名()
# 方法調用和函數調用的區別：
# 1.如果是函數調用，則調用時傳幾個參數，就會有幾個實參
# 2.如果是方法調用，則默認傳遞一個參數，所以方法中至少要定義一個形參
# 修改 p1 的 name 屬性
p1.name = '豬八戒'
p2.name = '沙和尚'
p1.say_hello() # '你好！我是 豬八戒'
p2.say_hello() # '你好！我是 沙和尚'
# del p2.name # 刪除 p2 的 name 屬性
# print(p1.name)
# print(p2.name)
類的定義+類的屬性和方法的圖解：
6.4 類的特殊方法
class Person :
# 在類中可以定義一些特殊方法（或者魔術方法）
# 特殊方法都是以__開頭，__結尾的方法
# 特殊方法不需要我們自己調用，不要嘗試去調用特殊方法
# 特殊方法將會在特殊的時刻自動調用
# 學習特殊方法：
# 1.特殊方法什么時候調用
# 2.特殊方法有什么作用
# 創建對象的流程：即 p1 = Person() 的運行流程：
# 1.創建一個變量
# 2.在內存中創建一個新對象
# 3.__init__(self) 方法執行
# 4.將對象的 id 賦值給變量
# init 會在對象創建以后立刻執行
# init 可以用來向新創建的對象中初始化屬性
# 調用類創建對象的實例時，類后邊的所有參數都會依次傳遞到 init() 中
def __init__(self, name) :
# print(self)
# 通過 self 向新建的對象中初始化屬性
self.name = name
def say_hello(self) :
print('大家好，我是 %s' %self.name)
# 目前來講，對於 Person 類來說 name 是必須的，並且每一個對象中的 name 屬性的值基本上都是不同
# 而我們現在是將 name 屬性在定義完對象以后，手動添加到對象中，這種方式很容易出現錯誤
# 我們希望，在創建對象時，必須設置 name 屬性，如果不設置則對象將無法創建
# 並且屬性的創建應該是自動完成的，而不是在創建對象以后手動添加完成
# p1 = Person()
# 手動向對象添加 name 屬性
# p1.name = '孫悟空'
# p2 = Person()
# 手動向對象添加 name 屬性
# p2.name = '豬八戒'
# p3 = Person()
# 手動向對象添加 name 屬性
# p3.name = '沙和尚'
# p3.say_hello()
p1 = Person('孫悟空')
p2 = Person('豬八戒')
p3 = Person('沙和尚')
p4 = Person('唐僧')
# p1.__init__() # 特殊方法不需要我們自己調用，不要嘗試去調用特殊方法
# print(p1.name)
# print(p2.name)
# print(p3.name)
# print(p4.name)
p4.say_hello()
練習--示例代碼：
創建對象的流程
p1 = Person() 的運行流程
1.創建一個變量
2.在內存中創建一個新對象
3.__init__(self) 方法執行
4.將對象的 id 賦值給變量
類的基本結構：
class 類名([父類]) :
公共的屬性...
# 對象的初始化方法
def __init__(self, ...) :
...
# 其他的方法
def method_1(self, ...) :
...
def method_2(self, ...) :
...
...
練習：
嘗試自定義一個表示狗的類（Dog）
屬性：
name
age
gender
height
…
方法：
jiao()
yao()
run()
…
class Dog():
'''
表示狗的類
'''
def __init__(self, name, age, gender, height):
self.name = name
self.age = age
self.gender = gender
self.height = height
def jiao(self):
'''
狗叫的方法
'''
print('汪汪汪~~~')
def yao(self):
'''
狗咬的方法
'''
print('咬你~~~')
def run(self):
'''
狗跑的方法
'''
print('%s 快樂的奔跑~~~' %self.name)
d = Dog('旺財', 10, 'mele', 30)
print(d.name, d.age, d.gender, d.height)
d.jiao()
d.yao()
d.run()
# 目前我們可以直接通過 對象.屬性 的方式來修改屬性的值，這種方式導致對象中的屬性可以隨意修改
# 非常的不安全，屬性的值可以任意修改，不論對錯
# 現在我們就需要一種方式來增強數據的安全性：
# 1.屬性不能隨意修改（我讓你改你才能改，不讓你改你就不能改）
# 2.屬性不能修改為任意的值（年齡不能是負數）
d.name = '阿黃'
d.age = -10
6.5 封裝
# 封裝是面向對象的三大特性之一
# 封裝指的是隱藏對象中一些不希望被外部所訪問到的屬性或方法
# 如何隱藏一個對象中的屬性？
# - 將對象的屬性名，修改為一個外部不知道的名字，例如 將 name 修改為 hidden_name
# 如何獲取（修改）對象中的屬性？
# - 需要提供一個 getter 和 setter 方法使外部可以訪問到屬性
# - getter 獲取對象中的指定屬性（get_屬性名），沒有參數且有返回值
# - setter 用來設置對象的指定屬性（set_屬性名），有一個參數且沒有返回值
# 使用封裝，確實增加了類的定義的復雜程度，但是它也確保了數據的安全性：
# 1.隱藏了屬性名，使調用者無法隨意的修改對象中的屬性
# 2.增加了 getter 和 setter 方法，很好的控制了屬性是否是只讀的
# 如果希望屬性是只讀的，則可以直接去掉 setter 方法
# 如果希望屬性不能被外部訪問，則可以直接去掉 getter 方法
# 3.使用 setter 方法設置屬性，可以增加數據的驗證，確保數據的值是正確的
# 4.使用 getter 方法獲取屬性，使用 setter 方法設置屬性
# 可以在讀取屬性和修改屬性的同時做一些其他的處理
# 5.使用 getter 方法可以表示一些計算的屬性
class Dog:
'''
表示狗的類
'''
def __init__(self, name, age):
self.hidden_name = name
self.hidden_age = age
def say_hello(self):
print('大家好，我是 %s' %self.hidden_name)
def get_name(self):
'''
get_name() 用來獲取對象的 name 屬性
'''
# print('用戶讀取了屬性')
return self.hidden_name
def set_name(self, name):
# print('用戶修改了屬性')
self.hidden_name = name
def get_age(self):
return self.hidden_age
def set_age(self, age):
if age > 0 :
self.hidden_age = age
d = Dog('旺財', 8)
# d.say_hello()
print(d.get_name())
# 調用 setter 來修改 name 屬性
d.set_name('小黑')
d.set_age(-10)
# d.say_hello()
print(d.get_age())
6.5.1 隱藏類中的屬性
class Rectangle:
'''
表示矩形的類
'''
def __init__(self, width, height):
self.hidden_width = width
self.hidden_height = height
def get_width(self):
return self.hidden_width
def get_height(self):
return self.hidden_height
def set_width(self, width):
self.hidden_width = width
def set_height(self, height):
self.hidden_height = height
def get_area(self):
return self.hidden_width * self.hidden_height
# r = Rectangle(5, 2)
# r.set_width(10)
# r.set_height(20)
# print(r.get_area())
-------------------------------------------------------------------------------------
# 可以為對象的屬性使用雙下划線開頭，__xxx
# 雙下划線開頭的屬性，是對象的隱藏屬性，隱藏屬性只能在類的內部訪問，無法通過對象訪問
# 其實隱藏屬性只不過是 Python 自動為屬性改了一個名字
# 實際上是將名字修改為了，_類名__屬性名 比如 __name -> _Person__name
# class Person:
# def __init__(self, name):
# self.__name = name
# def get_name(self):
# return self.__name
# def set_name(self, name):
# self.__name = name
# p = Person('孫悟空')
# print(p.__name) # __開頭的屬性是隱藏屬性，無法通過對象訪問
# p.__name = '豬八戒' # __開頭的屬性是隱藏屬性，無法通過對象修改
# print(p._Person__name) # 可以訪問
# p._Person__name = '豬八戒' # 可以修改
# print(p.get_name())
-------------------------------------------------------------------------------------
# 使用__開頭的屬性，實際上依然可以在外部訪問，所以這種方式我們一般不用
# 推薦方式：
# 一般我們會將一些私有屬性（不希望被外部訪問的屬性）以_開頭
# 一般情況下，使用_開頭的屬性都是私有屬性，沒有特殊需要不要修改私有屬性（盡管可以修改）
class Person:
def __init__(self, name):
self._name = name
def get_name(self):
return self._name
def set_name(self, name):
self._name = name
p = Person('孫悟空')
p._name = '豬八戒'
print(p._name)
6.5.2 property 裝飾器
class Person:
def __init__(self, name, age):
self._name = name
self._age = age
# property 裝飾器，用來將一個 get 方法，轉換為對象的屬性
# 添加為 property 裝飾器以后，我們就可以像調用屬性一樣使用 get 方法
# 使用 property 裝飾的方法的方法名必須和屬性名是一樣的
@property
def name(self):
print('get方法執行了~~~')
return self._name
# setter 方法的裝飾器：@屬性名.setter
@name.setter
def name(self, name):
print('setter方法調用了')
self._name = name
@property
def age(self):
return self._age
# setter 方法的裝飾器：@屬性名.setter
@age.setter
def age(self, age):
self._age = age
p = Person('豬八戒', 18)
p.name = '孫悟空'
p.age = 28
print(p.name, p.age)
6.6 繼承
6.6.1 繼承的簡介
# 繼承
# 定義一個類 Animal（動物）
# 這個類中需要兩個方法：run() sleep()
class Animal:
def run(self):
print('動物會跑~~~')
def sleep(self):
print('動物睡覺~~~')
# def bark(self):
# print('動物嚎叫~~~')
# 定義一個類 Dog（狗）
# 這個類中需要三個方法：run() sleep() bark()
# class Dog:
# def run(self):
# print('狗會跑~~~')
# def sleep(self):
# print('狗睡覺~~~')
# def bark(self):
# print('汪汪汪~~~')
# 有一個類，能夠實現我們需要的大部分功能，但是不能實現全部功能
# 如何能讓這個類來實現全部的功能呢？
# ① 直接修改這個類，在這個類中添加我們需要的功能
# - 修改起來會比較麻煩，並且會違反 OCP 原則（開閉原則）
# ② 直接創建一個新的類
# - 創建一個新的類比較麻煩，並且需要大量的進行復制粘貼，會出現大量的重復性代碼
# ③ 直接從 Animal 類中來繼承它的屬性和方法
# - 繼承是面向對象三大特性之一
# - 通過繼承我們可以使一個類獲取到其他類中的屬性和方法
# - 在定義類時，可以在類名后的括號中指定當前類的父類（超類、基類、super）
# 子類（衍生類）可以直接繼承父類中的所有的屬性和方法
#
# 通過繼承可以直接讓子類獲取到父類的方法或屬性，避免編寫重復性的代碼，並且也符合 OCP 原則
# 所以我們經常需要通過繼承來對一個類進行擴展
class Dog(Animal):
# 子類特有的方法
def bark(self):
print('汪汪汪~~~')
# 重寫父類的方法
def run(self):
print('狗跑~~~')
# 其余的方法繼承父類的
class Hashiqi(Dog):
def fan_sha(self):
print('我是一只傻傻的哈士奇')
d = Dog()
h = Hashiqi()
# d.run()
# d.sleep()
# d.bark()
# r = isinstance(d, Dog)
# r = isinstance(d, Animal)
# print(r)
-------------------------------------------------------------------------------------
# 在創建類時，如果省略了父類，則默認父類為 object
# object 是所有類的父類，所有類都繼承自 object
class Person(object):
pass
# issubclass() 檢查一個類是否是另一個類的子類
# print(issubclass(Animal, Dog)) # True
# print(issubclass(Animal, object)) # True
# print(issubclass(Person, object)) # True
# isinstance() 用來檢查一個對象是否是一個類的實例
# 如果這個類是這個對象的父類，也會返回 True
# 所有的對象都是 object 的實例
print(isinstance(print, object)) # True
6.6.2 方法的重寫
# 定義一個類 Animal（動物）
# 這個類中需要兩個方法：run() sleep()
class Animal:
def run(self):
print('動物會跑~~~')
def sleep(self):
print('動物睡覺~~~')
class Dog(Animal):
def bark(self):
print('汪汪汪~~~')
def run(self):
print('狗跑~~~~')
# 如果在子類中有和父類同名的方法，則通過子類實例去調用方法時：
# 會調用子類的方法而不是父類的方法，這個特點我們成為叫做方法的重寫（覆寫，覆蓋，override）
# 創建 Dog 類的實例
# d = Dog()
# d.run()
# 當我們調用一個對象的方法時：（就近原則）
# 會優先去當前對象中尋找是否具有該方法，如果有則直接調用；
# 如果沒有，則去當前對象的父類中尋找，如果父類中有則直接調用父類中的方法；
# 如果沒有，則去父類的父類中尋找，以此類推，直到找到 object，如果依然沒有找到，則報錯。
class A(object):
def test(self):
print('AAA')
class B(A):
def test(self):
print('BBB')
class C(B):
def test(self):
print('CCC')
# 創建一個 c 的實例
c = C()
c.test()
6.6.3 super()
class Animal:
def __init__(self, name):
self._name = name
def run(self):
print('動物會跑~~~')
def sleep(self):
print('動物睡覺~~~')
@property
def name(self):
return self._name
@name.setter
def name(self ,name):
self._name = name
# 父類中的所有方法都會被子類繼承，包括特殊方法，也可以重寫特殊方法
class Dog(Animal):
def __init__(self, name, age):
# 希望可以直接調用父類的 __init__ 來初始化父類中定義的屬性
# Animal.__init__(self, name) # 這種方式不是動態獲取父類的，耦合性太強
# super() 可以用來獲取當前類的父類，並且通過 super() 返回對象調用父類方法時，不需要傳遞 self
super().__init__(name)
self._age = age
def bark(self):
print('汪汪汪~~~')
def run(self):
print('狗跑~~~~')
@property
def age(self):
return self._age
@age.setter
def age(self,age):
self._age = name
d = Dog('旺財', 18)
print(d.name)
print(d.age)
6.6.4 多重繼承
class A(object):
def test(self):
print('AAA')
class B(object):
def test(self):
print('B中的test()方法~~')
def test2(self):
print('BBB')
# 在 Python 中是支持多重繼承的，也就是我們可以為一個類同時指定多個父類（Java 只支持單繼承）
# 可以在類名的()后邊添加多個類，來實現多重繼承
# 多重繼承，會使子類同時擁有多個父類，並且會獲取到所有父類中的方法
# 在開發中沒有特殊的情況，應該盡量避免使用多重繼承，因為【多重繼承會讓我們的代碼過於復雜】
# 如果多個父類中有同名的方法，則會現在第一個父類中尋找（包括第一個父類的父類），然后找第二個（包括第二個父類的父類），然后找第三個（包括第三個父類的父類），...，找過的父類不會再找，以此類推
# 會出現前邊父類的方法會覆蓋后邊父類的方法
class C(A, B):
pass
# 類名.__bases__ 這個屬性可以用來獲取當前類的所有父類
# print(C.__bases__) # (<class '__main__.B'>,)
# print(B.__bases__) # (<class 'object'>,)
# print(C.__bases__) # (<class '__main__.A'>, <class '__main__.B'>)
c = C()
c.test()
多重繼承小圖解：
6.7 多態
# 多態是面向對象的三大特征之一
# 多態從字面上理解是多種形態
# 狗（狼狗、藏獒、哈士奇、古牧 、...）
# 一個對象可以以不同的形態去呈現
# 定義兩個類
class A:
def __init__(self, name):
self._name = name
@property
def name(self):
return self._name
@name.setter
def name(self, name):
self._name = name
class B:
def __init__(self, name):
self._name = name
def __len__(self):
return 10
@property
def name(self):
return self._name
@name.setter
def name(self, name):
self._name = name
class C:
pass
a = A('孫悟空')
b = B('豬八戒')
c = C()
# 定義一個函數
# 對於 say_hello() 這個函數來說，只要對象中含有 name 屬性，它就可以作為參數傳遞
# 這個函數並不會考慮對象的類型，只要有 name 屬性即可，即多態函數：可以適用多種對象的類型
def say_hello(obj):
print('你好 %s' %obj.name)
say_hello(a)
say_hello(b)
# say_hello(c) # 報錯，因為 c 對象中沒有 name 屬性
-------------------------------------------------------------------------------------
# 在 say_hello_2 中我們做了一個類型檢查，也就是只有 obj 是 A 類型的對象時，才可以正常使用，
# 其他類型的對象都無法使用該函數，這個函數就違反了多態
# 違反了多態的函數，只適用於一種類型的對象，無法處理其他類型對象，這樣導致函數的適應性非常的差！
# 注意：向 isinstance() 這種函數，在開發中一般是不會使用的！！！
def say_hello_2(obj):
# 做類型檢查
if isinstance(obj, A):
print('你好 %s' %obj.name)
say_hello_2(a)
# say_hello_2(b)
-------------------------------------------------------------------------------------
# 多態名言：鴨子類型
# 如果一個東西，走路像鴨子，叫聲像鴨子，那么它就是鴨子
# len()
# 之所以一個對象能通過 len() 來獲取長度，是因為對象中具有一個特殊方法 __len__
# 換句話說，只要對象中具有 __len__ 特殊方法，就可以通過 len() 來獲取它的長度
l = [1, 2, 3]
s = 'hello'
# print(len(l))
# print(len(s))
print(len(b)) # 可以調用
print(len(c)) # 報錯
-------------------------------------------------------------------------------------
# 面向對象的三大特征：
# 封裝
# - 確保對象中的數據安全
# 繼承
# - 保證了對象的可擴展性
# 多態
# - 保證了程序的靈活性
6.8 類中的屬性和方法
# 定義一個類
class A(object):
# 類屬性
# 實例屬性
# 類方法
# 實例方法
# 靜態方法
# 類屬性：直接在類中定義的屬性是類屬性
# 類屬性可以通過類對象或類的實例對象訪問到，比如：A.count 或者 A().count
# 但是類屬性只能通過類對象來修改，無法通過實例對象修改
count = 0
def __init__(self):
# 實例屬性：通過實例對象添加的屬性屬於實例屬性
# 實例屬性只能通過實例對象來訪問和修改，類對象無法訪問修改
self.name = '孫悟空'
# 實例方法：在類中定義的，且以 self 為第一個參數的方法都是實例方法
# 實例方法在調用時，Python 會將調用的實例對象作為 self 傳入
# 實例方法可以通過實例對象和類對象去調用
# 當通過實例對象調用時，會自動將當前調用對象作為 self 傳入
# 當通過類對象調用時，不會自動傳遞 self，此時我們必須手動傳遞 self ，即手動傳遞實例對象！
def test(self):
print('這是test方法，它是一個實例方法~~~', self)
# 類方法：在類內部使用 @classmethod 來修飾的方法屬於類方法
# 類方法的第一個參數是 cls，也會被自動傳遞，cls 就是當前的類對象
# 類方法和實例方法的區別：實例方法的第一個參數是 self，而類方法的第一個參數是 cls
# 類方法可以通過類對象去調用，也可以通過實例對象去調用，二中方式沒有區別！
@classmethod
def test_2(cls):
print('這是test_2方法，它是一個類方法~~~ ', cls)
print(cls.count)
# 靜態方法：在類中使用 @staticmethod 來修飾的方法屬於靜態方法
# 靜態方法不需要指定任何的默認參數，靜態方法可以通過類對象和實例對象去調用
# 靜態方法：基本上是一個和當前類無關的方法，它只是一個保存到當前類中的函數，說白了就是保存了一個內存地址！！！
# 靜態方法一般都是一些工具方法，和當前類無關
@staticmethod
def test_3():
print('test_3執行了~~~')
a = A()
# 實例屬性：通過實例對象添加的屬性屬於實例屬性
# a.count = 10
# A.count = 100
# print('A ,', A.count)
# print('a ,', a.count)
# print('A ,', A.name)
# print('a ,', a.name)
# a.test() # 等價於 A.test(a)
# A.test_2() # 等價於 a.test_2()
A.test_3()
a.test_3()
6.9 垃圾回收
# 就像我們生活中會產生垃圾一樣，程序在運行過程當中也會產生垃圾
# 程序運行過程中產生的垃圾會影響到程序的運行的運行性能，所以這些垃圾必須被及時清理
# 沒用的東西就是垃圾
# 在程序中沒有被引用的對象就是垃圾，這種垃圾對象過多以后會影響到程序的運行的性能，注意：垃圾對象：沒有被引用的對象，與該對象是否引用了其他對象無關！
# 所以我們必須進行及時的垃圾回收，所謂的垃圾回收就是講垃圾對象從內存中刪除。
# 在 Python 中有自動的垃圾回收機制，它會自動將這些沒有被引用的對象刪除，所以我們不用手動處理垃圾回收。
class A:
def __init__(self):
self.name = 'A類'
# __del__ 是一個特殊方法，它會在對象被垃圾回收前調用
def __del__(self):
print('A()對象被刪除了~~~', self)
a = A()
b = a # 又使用一個變量 b，來引用 a 對應的對象
print(a.name)
# a = None # 將 a 設置為了 None，此時沒有任何的變量對 A() 對象進行引用，它就是變成了垃圾
# b = None
# 或者
# del a
# del b
input('按回車鍵退出...')
6.10 特殊方法（魔術方法）
# 特殊方法，也稱為魔術方法
# 特殊方法都是使用__開頭和結尾的
# 特殊方法一般不需要我們手動調用，需要在一些特殊情況下自動執行
# 定義一個 Person 類
class Person(object):
"""人類"""
def __init__(self, name, age):
self.name = name
self.age = age
# __str__() 這個特殊方法會在嘗試將當前對象轉換為字符串的時候調用
# 它的作用可以用來指定對象轉換為字符串的結果（print 函數）
def __str__(self):
return 'Person [name=%s, age=%d]' %(self.name, self.age)
# __repr__() 這個特殊方法會在對當前對象使用 repr() 函數時調用
# 它的作用是指定對象在 ‘交互模式’ 中直接輸出的結果
def __repr__(self):
return 'Hello'
# object.__add__(self, other)
# object.__sub__(self, other)
# object.__mul__(self, other)
# object.__matmul__(self, other)
# object.__truediv__(self, other)
# object.__floordiv__(self, other)
# object.__mod__(self, other)
# object.__divmod__(self, other)
# object.__pow__(self, other[, modulo])
# object.__lshift__(self, other)
# object.__rshift__(self, other)
# object.__and__(self, other)
# object.__xor__(self, other)
# object.__or__(self, other)
# object.__lt__(self, other) 小於 <
# object.__le__(self, other) 小於等於 <=
# object.__eq__(self, other) 等於 ==
# object.__ne__(self, other) 不等於 !=
# object.__gt__(self, other) 大於 >
# object.__ge__(self, other) 大於等於 >=
# __len__() 獲取對象的長度
# object.__bool__(self)
# 可以通過 bool 來指定對象轉換為布爾值的情況
def __bool__(self):
return self.age > 17
# __gt__ 會在對象做大於比較的時候調用，該方法的返回值將會作為比較的結果
# 它需要兩個參數，一個 self 表示當前對象，other 表示和當前對象比較的對象
# self > other
def __gt__(self, other):
return self.age > other.age
# 創建兩個 Person 類的實例
p1 = Person('孫悟空', 18)
p2 = Person('豬八戒', 28)
# 打印 p1
# 當我們打印一個對象時，實際上打印的是對象的中特殊方法 __str__() 的返回值
# print(p1) # <__main__.Person object at 0x04E95090>
# print(p1) # Person [name=孫悟空, age=18]
# print(p2) # Person [name=豬八戒, age=28]
# print(str(p1)) # Person [name=孫悟空, age=18]
# print(str(p2)) # Person [name=豬八戒, age=28]
# print(p2) 等價於 print(str(p2))
# print(repr(p1))
# t = 1, 2, 3
# print(t) # (1, 2, 3)
# print(p1 > p2)
# print(p2 > p1)
# print(bool(p1))
# if p1 :
# print(p1.name, '已經成年了')
# else :
# print(p1.name, '還未成年了')
str__() 和 __repr() 魔術方法交互界面輸出：
6.11 模塊化
6.11.1 模塊的創建
# 模塊（module）
# 模塊化：模塊化指將一個完整的程序分解為一個一個小的模塊
# 通過將模塊組合，來搭建出一個完整的程序
# 不采用模塊化，統一將所有的代碼編寫到一個文件中
# 采用模塊化，將程序分別編寫到多個文件中
# 模塊化的優點：
# ① 方便開發
# ② 方便維護
# ③ 模塊可以復用
# 在 Python 中一個 py 文件就是一個模塊，要想創建模塊，實際上就是創建一個 python 文件
# 注意：模塊名要符號標識符的規范！！！
# 在一個模塊中引入外部模塊：
# ① import 模塊名（模塊名，就是 python 文件的名字，注意不要 .py）
# ② import 模塊名 as 模塊別名
# - 可以引入同一個模塊多次，但是模塊的實例只會創建一個
# - import 可以在程序的任意位置調用，但是一般情況下，import 語句都會統一寫在程序的開頭
# - 在每一個模塊內部都有一個 __name__ 屬性，通過這個屬性可以獲取到模塊的名字
# - __name__ 屬性值為 __main__ 的模塊是主模塊，一個程序中只會有一個主模塊
# 主模塊就是我們直接通過 python 執行的模塊
import test_module as test
print(test_module) # <module 'test_module' from 'C:\\Users\\bruce\\Desktop\\py_learn\\lesson_06_對象\\code\\test_module.py'>
print(test.__name__) # test_module
print(__name__) # __main__ 主模塊就是我們直接通過 python 執行的模塊
6.11.2 模塊的使用
# 可以引入這整個模塊中的內容
# import 模塊名（模塊名，就是 python 文件的名字，注意不要 .py）
# import 模塊名 as 模塊別名
# import m
# 訪問模塊中的變量：模塊名.變量名
# print(m.a, m.b)
# 訪問模塊中的函數：模塊名.函數名()
# m.test()
# m.test2()
# 訪問模塊中的類：模塊名.類名()
# p = m.Person()
# print(p.name)
-------------------------------------------------------------------------------------
# 也可以只引入模塊中的部分內容
# 語法：from 模塊名 import 變量,變量....
# from m import Person
# from m import test
# from m import Person,test
# from m import * # 引入模塊中所有內容，一般不會這樣使用！！！原因1：導致模塊過大，原因2：模塊中的內容會覆蓋主模塊中的內容
def test2():
print('這是主模塊中的test2')
# p1 = Person()
# print(p1)
# test()
# test2()
-------------------------------------------------------------------------------------
# 也可以為引入的變量使用別名
# 語法：from 模塊名 import 變量 as 別名
# from m import test2 as new_test2
# test2()
# new_test2()
from m import *
# print(_c) # 不能訪問到
# import xxx
# import xxx as yyy
# from xxx import yyy,zzz,fff
# from xxx import *
# from xxx import yyy as zz
模塊示例代碼 m.py ：
# 可以在模塊中定義變量，在模塊中定義的變量，在引入模塊后，就可以直接使用了
a = 10
b = 20
# 添加了_的變量，只能在模塊內部訪問，在通過 import * 引入時，不會引入_開頭的變量
_c = 30
# 可以在模塊中定義函數，同樣可以通過模塊訪問到
def test():
print('test')
def test2():
print('test2')
# 也可以在模塊中定義類，同樣可以通過模塊訪問到
class Person:
def __init__(self):
self.name = '孫悟空'
# 編寫測試代碼，這部分代碼，只要在當前文件作為主模塊的時候才需要執行，而當模塊被其他模塊引入時，則不需要執行，即此時我們就必須要檢查當前模塊是否是主模塊
if __name__ == '__main__':
test()
test2()
p = Person()
print(p.name)
6.11.3 包
# 包 Package
# 包也是一個模塊
# 當我們模塊中代碼過多時，或者一個模塊需要被分解為多個模塊時，這時就需要使用到包
# 普通的模塊就是一個 py 文件，而包是一個文件夾
# 包中必須要有一個 __init__.py 這個文件，這個文件中可以包含有包中的主要內容
from hello import a,b
print(a.a)
print(b.b)
# __pycache__ 是模塊的緩存文件
# py 代碼在執行前，需要被解析器先轉換為機器碼，然后再執行
# 所以我們在使用模塊（包）時，也需要將模塊（包）的代碼先轉換為機器碼然后再交由計算機執行
# 而為了提高程序運行的性能，python 會在編譯過一次以后，將代碼保存到一個緩存文件中
# 這樣在下次加載這個模塊（包）時，就可以不再重新編譯而是直接加載緩存中編譯好的代碼即可
6.11.4 Python 標准庫
# 開箱即用
# 為了實現開箱即用的思想，Python 中為我們提供了一個模塊的標准庫
# 在這個標准庫中，有很多很強大的模塊我們可以直接使用
# 並且標准庫會隨 Python 的安裝一同安裝
# 比如：sys 模塊，pprint 模塊
# 引入 sys 模塊，它里面提供了一些變量和函數，使我們可以獲取到 Python 解析器的信息，或者通過函數來操作 Python 解析器
import sys
# 引入 pprint 模塊，它給我們提供了一個方法 pprint() 該方法可以用來對打印的數據做簡單的格式化
import pprint
# sys.argv
# 獲取執行代碼時的命令行中所包含的參數
# 該屬性返回的是一個列表，列表中保存了當前命令的所有參數
# print(sys.argv)
# sys.modules
# 獲取當前程序中引入的所有模塊
# modules 是一個字典，字典的 key 是模塊名字，字典的 value 是模塊對象
# pprint.pprint(sys.modules)
# sys.path
# 它是一個列表，列表中保存的是模塊的搜索路徑
['C:\\Users\\bruce\\Desktop\\py_learn\\lesson_06_對象\\code',
'D:\\learn\\Python\\Python37\\Python37\\python37.zip',
'D:\\learn\\Python\\Python37\\Python37\\DLLs',
'D:\\learn\\Python\\Python37\\Python37\\lib',
'D:\\learn\\Python\\Python37\\Python37',
'D:\\learn\\Python\\Python37\\Python37\\lib\\site-packages']
# pprint.pprint(sys.path)
# sys.platform
# 表示當前 Python 運行的平台
# print(sys.platform) # win32
System platform value
Linux 'linux'
Windows 'win32'
Windows/Cygwin 'cygwin'
Mac OS X 'darwin'
# sys.exit()
# 用來退出程序
# sys.exit('程序出現異常，結束！')
# print('hello')
# os 模塊讓我們可以對操作系統進行訪問
import os
# os.environ
# 通過這個屬性可以獲取到當前系統的環境變量
# pprint.pprint(os.environ['path'])
('D:\\learn\\Java\\jdk\\jdk1.8.0_192\\bin;D:\\learn\\Java\\jdk\\jdk1.8.0_192\\jre\\bin;D:\\learn\\Scala\\scala-2.11.8\\bin;D:\\learn\\Maven\\apache-maven-3.3.9\\bin;D:\\work\\Hadoop\\hadoop-2.7.2\\bin;C:\\Windows\\system32;C:\\Windows;C:\\Windows\\System32\\Wbem;C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\;C:\\Windows\\System32\\OpenSSH\\;D:\\work\\Git\\Git\\cmd;D:\\work\\MySQL\\MySQL '
'Server '
'5.5\\bin;D:\\work\\MongoDB\\Server\\3.2\\bin;D:\\learn\\Python\\Python37\\Python37\\Scripts\\;D:\\learn\\Python\\Python37\\Python37\\;C:\\Users\\bruce\\AppData\\Local\\Microsoft\\WindowsApps;')
# os.system()
# 可以用來執行當前操作系統的命令
# os.system('dir')
os.system('notepad')第七章 異常
7.1 異常的簡介和異常的處理
異常
程序在運行過程當中，不可避免的會出現一些錯誤，比如：
使用了沒有賦值過的變量
使用了不存在的索引
除0
...
這些錯誤在程序中，我們稱其為異常。
程序運行過程中，一旦出現異常將會導致程序立即終止，異常以后的代碼全部都不會執行！！！
-------------------------------------------------------------------------------------
處理異常
程序運行時出現異常，目的並不是讓我們的程序直接終止！
Python 是希望在出現異常時，我們可以編寫代碼來對異常進行處理！
try 語句
try:
代碼塊（可能出現錯誤的語句）
except 異常類型 as 異常名:
代碼塊（出現錯誤以后的處理方式）
except 異常類型 as 異常名:
代碼塊（出現錯誤以后的處理方式）
except 異常類型 as 異常名:
代碼塊（出現錯誤以后的處理方式）
else:
代碼塊（沒出錯時要執行的語句）
finally:
代碼塊（該代碼塊總會執行）
try 是必須的，else 語句有沒有都行
except 和 finally 至少有一個
可以將可能出錯的代碼放入到 try 語句，
如果代碼沒有錯誤，則會正常執行，
如果出現錯誤，則會執行 expect 子句中的代碼，
這樣我們就可以通過代碼來處理異常，避免因為一個異常而導致整個程序的運行終止
異常--示例代碼：
# print('hello')
# try:
# # try 中放置的是有可能出現錯誤的代碼
# print(10/0)
# except:
# # except 中放置的是出錯以后的處理方式
# print('哈哈哈，出錯了~~~')
# else:
# print('程序正常執行沒有錯誤')
# print('你好')
7.2 異常的傳播
異常的傳播
當在函數中出現異常時，如果在函數中對異常進行了處理，則異常不會再繼續傳播，
如果函數中沒有對異常進行處理，則異常會繼續向函數調用處傳播，
如果函數調用處處理了異常，則不再傳播，如果沒有處理則繼續向調用處傳播，
直到傳遞到全局作用域（主模塊），如果依然沒有處理，則程序終止，並且顯示異常信息。
當程序運行過程中出現異常以后，所有的異常信息會被保存一個專門的異常對象中：
而異常傳播時，實際上就是將異常對象拋給了調用處
比如 ： ZeroDivisionError 類，該類的對象專門用來表示除0的異常
NameError 類，該類的對象專門用來處理變量錯誤的異常
......
在 Python 為我們提供了多個異常對象！
示例代碼：
# print(10/0) # 異常出現在全局
def fn1():
print('hello fn1')
print(10/0) # 異常出現在函數，不調用該函數，則異常不會出現
def fn2():
print('hello fn2')
fn1()
def fn3():
print('hello fn3')
fn2()
fn3()
輸出結果如下：
hello fn3
hello fn2
hello fn1
Traceback (most recent call last):
File "demo.py", line 15, in <module>
fn3()
File "demo.py", line 13, in fn3
fn2()
File "demo.py", line 9, in fn2
fn1()
File "demo.py", line 5, in fn1
print(10/0) # 異常出現在函數，不調用該函數，則異常不會出現
ZeroDivisionError: division by zero
7.3 異常對象
print('異常出現前~~~')
l = []
try:
# print(c)
# l[10]
# 1 + 'hello'
print(10/0)
except NameError:
# 如果 except 后不跟任何的內容，則此時它會捕獲到所有的異常
# 如果在 except 后跟着一個異常的類型，那么此時它只會捕獲該類型的異常
print('出現 NameError 異常')
except ZeroDivisionError:
print('出現 ZeroDivisionError 異常')
except IndexError:
print('出現 IndexError 異常')
except Exception as e :
# Exception 是所有異常類的父類，所以如果 except 后跟的是 Exception，它也會捕獲到所有的異常
# 可以在異常類后邊跟着一個 as xx ， 此時 xx 就是異常對象
print('未知異常', e, type(e))
finally :
print('無論是否出現異常，該子句都會執行')
print('異常出現后~~~')
7.4 自定義異常對象
拋出異常
- 可以使用 raise 語句來拋出異常，
raise語句后需要跟一個異常類 或 異常的實例。
# 也可以自定義異常類，只需要創建一個類繼承 Exception 即可
class MyError(Exception):
pass
def add(a, b):
# 如果 a 和 b 中有負數，就向調用處拋出異常
if a < 0 or b < 0:
# raise 用於向外部拋出異常，后邊可以跟一個異常類，或異常類的實例
# raise Exception # 拋出異常類
# raise Exception('兩個參數中不能有負數！') # 拋出異常類的實例
# 拋出異常的目的：告訴調用者這里調用時出現問題，希望你自己處理一下
raise MyError('自定義的異常')
# 也可以通過 if else 來代替異常的處理
# return None
r = a + b
return r
print(add(-123, 456))
第八章 文件
- 通過 Python 程序來對計算機中的各種文件進行增刪改查的操作
- I/O(Input/Output)
- 操作文件的步驟：
① 打開文件
② 對文件進行各種操作（讀、寫），然后保存
③ 關閉文件
8.1 文件--打開
# open(file, mode='r', buffering=-1, encoding_=None, errors=None, newline=None, closefd=True, opener=None)
# 使用 open 函數來打開一個文件
# 參數：
# file 表示要打開的文件的名字（即路徑）
# 返回值：
# 返回一個對象，這個對象就代表了當前打開的文件
# 創建一個變量，來保存文件的名字
# 如果目標文件和當前文件在同一級目錄下，則直接使用文件名即可
file_name = 'demo.txt'
# 在 windows 系統使用路徑時，可以使用 / 來代替 \ ，或者可以使用 \\ 來代替 \
# 或者也可以使用原始字符串，但需要在字符串前面加一個 r
file_name = 'hello\\demo.txt'
file_name = r'hello\demo.txt'
# 表示路徑，可以使用 .. 來返回一級目錄
file_name = '../hello/demo.txt'
# 如果目標文件距離當前文件比較遠，此時可以使用絕對路徑
# 絕對路徑應該從磁盤的根目錄開始書寫
file_name = r'C:\Users\bruce\Desktop\hello.txt'
# file_obj = open(file_name) # 打開 file_name 對應的文件
# print(file_obj)
8.2 文件--關閉
# 打開文件
file_name = 'demo.txt'
# 調用 open() 來打開文件
# file_obj = open(file_name)
# 當我們獲取了文件對象以后，所有的對文件的操作都應該通過對象來進行
# read() 方法
# 用來讀取文件中的內容，它會將內容全部保存為一個字符串返回
# content = file_obj.read()
# print(content)
# 調用 close() 方法來關閉文件
# file_obj.close()
# with ... as 語句
# with open(file_name) as file_obj :
# 在 with 語句中可以直接使用 file_obj 來做文件操作
# 此時這個文件只能在 with 中使用，一旦 with 結束則文件會自動 close()
print(file_obj.read())
file_name = 'hello'
try:
with open(file_name) as file_obj :
print(file_obj.read())
except FileNotFoundError :
print(f'{file_name} 文件不存在~~~')
8.3 文件--簡單讀取
file_name = 'demo2.txt'
try:
# 調用 open() 來打開一個文件，可以將文件分成兩種類型：
# 一種是純文本文件（使用 utf-8 等編碼編寫的文本文件）
# 一種是二進制文件（圖片、mp3、ppt 等這些文件）
# open() 打開文件時，默認是以文本文件的形式打開的，但是 open() 默認的編碼為 None，為 ASCII 編碼
# 所以處理文本文件時，必須要指定文件的編碼
with open(file_name, encoding='utf-8') as file_obj :
# 通過 read() 來讀取文件中的內容
# 如果直接調用 read() 它會將文本文件的所有內容全部都讀取出來
# 如果要讀取的文件較大的話，會一次性將文件的內容加載到內存中，容易導致內存泄漏
# 所以對於較大的文件，不要直接調用 read()
# help(file_obj.read)
# read() 可以接收一個 size 作為參數，該參數用來指定要讀取的字符的數量
# 默認值為 -1，它會讀取文件中的所有字符
# 可以為 size 指定一個值，這樣 read() 會讀取指定數量的字符，（單位是字符）
# 每一次讀取都是從上次讀取到位置開始讀取的
# 如果字符的數量小於 size，則會讀取剩余所有的
# 如果已經讀取到了文件的最后了，則會返回空串
# content = file_obj.read(-1)
content = file_obj.read(6)
content = file_obj.read(6)
content = file_obj.read(6)
content = file_obj.read(6)
# print(content)
# print(len(content))
except FileNotFoundError :
print(f'{file_name} 這個文件不存在！')
8.4 文件--讀取大文件
# 讀取大文件的方式
file_name = 'demo.txt'
try:
with open(file_name, encoding='utf-8') as file_obj :
# 定義一個變量，來保存文件的內容
file_content = ''
# 定義一個變量，來指定每次讀取的大小
chunk = 100
# 創建一個循環來讀取文件內容
while True :
# 讀取 chunk 大小的內容
content = file_obj.read(chunk)
# 檢查是否讀取到了內容
if not content :
# 內容讀取完畢，則退出循環
break
# 輸出內容
# print(content, end='')
# 或者如下輸出內容
file_content += content
except FileNotFoundError :
print(f'{file_name} 這個文件不存在！')
print(file_content)
8.5 文件--readline
import pprint
import os
file_name = 'demo.txt'
with open(file_name, encoding='utf-8') as file_obj :
# readline()
# 該方法可以用來讀取一行內容
# print(file_obj.readline(), end='')
# print(file_obj.readline())
# print(file_obj.readline())
# readlines()
# 該方法用於一行一行的讀取內容，它會一次性將讀取到的內容封裝到一個列表中返回
# r = file_obj.readlines()
# pprint.pprint(r[0])
# pprint.pprint(r[1])
# pprint.pprint(r[2])
for t in file_obj :
print(t)
8.6 文件--寫入
file_name = 'demo5.txt'
# 使用 open() 打開文件時必須要指定打開文件所要做的操作（讀、寫、追加）：
# 如果不指定操作類型，則默認是讀取文件，而讀取文件時是不能向文件中寫入的
# r 表示只讀的
# w 表示是可寫的，使用 w 來寫入文件時，如果文件不存在會創建文件，如果文件存在則會截斷文件，截斷文件指刪除原來文件中的所有內容
# a 表示追加內容，如果文件不存在會創建文件，如果文件存在則會向文件中追加內容
# x 用來新建文件，如果文件不存在則創建，如果文件存在則報錯
# + 為操作符增加功能
# r+ 即可讀又可寫，文件不存在會報錯
# w+
# a+
# with open(file_name, 'w', encoding='utf-8') as file_obj :
# with open(file_name, 'r+', encoding='utf-8') as file_obj :
with open(file_name, 'x', encoding='utf-8') as file_obj :
# write() 來向文件中寫入內容
# 如果操作的是一個文本文件的話，則 write() 需要傳遞一個字符串作為參數
# 該方法會可以分多次向文件中寫入內容
# 寫入完成以后，該方法會返回寫入的字符的個數
file_obj.write('aaa\n')
file_obj.write('bbb\n')
file_obj.write('ccc\n')
r = file_obj.write(str(123) + '123123\n')
r = file_obj.write('今天天氣真不錯')
print(r)
8.7 文件--二進制文件
file_name = 'c:/Users/bruce/Desktop/告白氣球.flac'
# 讀取模式：
# t 讀取文本文件（默認值）
# b 讀取二進制文件
with open(file_name, 'rb') as file_obj :
# 讀取文本文件時，size 是以字符為單位的
# 讀取二進制文件時，size 是以字節為單位的
# print(file_obj.read(100))
# 將讀取到的內容寫出來
# 定義一個新的文件
new_name = 'aa.flac'
with open(new_name, 'wb') as new_file_obj :
# 定義每次讀取的大小
chunk = 1024 * 100
while True :
# 從已有的對象中讀取數據
content = file_obj.read(chunk)
# 內容讀取完畢，終止循環
if not content :
break
# 將讀取到的數據寫入到新對象中
new_file_obj.write(content)
8.8 文件--seek() 和 tell()
# 讀取二進制文件
# with open('demo.txt','rb') as file_obj :
print(file_obj.read(100))
print(file_obj.read(30))
# tell() 方法用來查看當前讀取的位置
print('當前讀取到了 -->', file_obj.tell())
# seek() 可以修改當前讀取的位置
file_obj.seek(55) # 修改當前讀取的位置為第 55 個字節
file_obj.seek(80, 0) # 從頭位置開始計算，讀 80 個字節
file_obj.seek(70, 1) # 從當前位置開始計算，讀 70 個字節
file_obj.seek(-10, 2) # 從最后位置開始計算，讀 10 個字節
print(file_obj.read())
# seek() 需要兩個參數
# 第一個參數：是要切換到的位置
# 第二個參數：計算位置方式
# 可選值：
# 0 從頭位置開始計算，默認值
# 1 從當前位置開始計算
# 2 從最后位置開始計算
-------------------------------------------------------------------------------------
# 讀取文本文件
# with open('demo2.txt','rt', encoding='utf-8') as file_obj :
print(file_obj.read(100))
print(file_obj.read(30))
# tell() 方法用來查看當前讀取的位置
print('當前讀取到了 -->', file_obj.tell())
# seek() 可以修改當前讀取的位置
file_obj.seek(9) # 修改當前讀取的位置為第 9 個字節，特別注意：在 UTF-8 編碼中，1個中文 = 3個字節
print(file_obj.read())
8.9 文件--其他操作
import os
from pprint import pprint
# os.listdir() 獲取指定目錄的目錄結構
# 需要一個路徑作為參數，會獲取到該路徑下的目錄結構，默認路徑為 . 當前目錄
# 該方法會返回一個列表，目錄中的每一個文件（夾）的名字都是列表中的一個元素
r = os.listdir()
pprint(r)
# os.getcwd() 獲取當前所在的目錄
r = os.getcwd()
pprint(r)
# os.chdir() 切換當前所在的目錄，作用相當於 cd
# os.chdir('c:/')
# 創建目錄
# os.mkdir("aaa") 在當前目錄下創建一個名字為 aaa 的目錄
# 刪除目錄
# os.rmdir('abc')
# 創建文件
# open('aa.txt', 'w')
# 刪除文件
# os.remove('aa.txt')
# os.rename('舊文件名字', '新文件名字') # 對一個文件進行重命名並移動（本質上都是移動）
# os.rename('aa.txt', 'bb.txt') # 對一個文件進行重命名並移動（只是移動到當前的目錄）
os.rename('bb.txt', 'c:/users/bruce/Desktop/bb.txt') # 對一個文件進行重命名並移動（移動到指定的目錄）
# 運算符的優先級
# 和數學中一樣，在 Python 運算也有優先級，比如：先乘除后加減
# 運算符的優先級可以根據優先級的表格來查詢
# 在表格中位置越靠下的運算符優先級越高，優先級越高的越優先計算
# 如果優先級一樣則自左向右計算
# 關於優先級的表格，你知道有這么一個東西就夠了，千萬不要去記
# 在開發中如果遇到優先級不清楚的，則可以通過小括號來改變運算順序
a = 1 + 2 * 3
# 三種情況：一樣高、and 高、or 高
# 如果 or 的優先級高，或者兩個運算符的優先級一樣高
# 則需要先進行 或運算，則運算結果是 3
# 如果 and 的優先級高，則應該先計算 與運算
# 則運算結果是 1
a = 1 or 2 and 3
print(a) # 1
# 邏輯運算符（補充）
# 邏輯運算符可以連着使用
result = 1 < 2 < 3 # 相當於 1 < 2 and 2 < 3
result = 10 < 20 > 15 # 詳當於 10 < 20 and 20 > 15
print(result)