前言：

1. Python是一個高層次的結(jié)合了解釋性、編譯性、互動性和面向?qū)ο蟮哪_本語言。
2. 本博文主要涉及Python基礎(chǔ)入門、流程控制（條件語句、循環(huán)語句）、數(shù)據(jù)序列等知識。
3. 本博文若存在任何知識錯誤，請讀者第一時間在評論區(qū)指出，方便我修正內(nèi)容！
4. 獲取更多內(nèi)容，請關(guān)注博主，在主頁進(jìn)行閱讀，感謝您的支持！

一、Python簡介

1. 了解Python

Python是一種解釋型（這意味著開發(fā)過程中沒有了編譯這個環(huán)節(jié)）、面向?qū)ο螅ㄖС置嫦驅(qū)ο蟮娘L(fēng)格或代碼封裝在對象的編程技術(shù)）、動態(tài)數(shù)據(jù)類型的交互式（可在命令行中通過Python提示符及直接代碼執(zhí)行程序）高級程序設(shè)計語言。

2. Python介紹

Python是時下最流行、最火爆的編程語言，具體原因：

• 簡單、易學(xué)，適應(yīng)人群廣泛
  
• 免費、開源
• 應(yīng)用領(lǐng)域廣泛
  

備注：以下知名框架均是Python語言開發(fā)。

1. Google開源機(jī)器學(xué)習(xí)框架：TensorFlow
2. 開源社區(qū)主推學(xué)習(xí)框架：Scikit-learn
3. 百度開源深度學(xué)習(xí)框架：Paddle

3. Python特點

1. 易于學(xué)習(xí)：Python有相對較少的關(guān)鍵字，結(jié)構(gòu)簡單，和一個明確定義的語法，學(xué)習(xí)起來更加簡單。
2. 易于閱讀：Python代碼定義的更清晰。
3. 易于維護(hù)：Python的成功在于它的源代碼是相當(dāng)容易維護(hù)的。
4. 一個廣泛的標(biāo)準(zhǔn)庫：Python的最大的優(yōu)勢之一是豐富的庫，跨平臺的，在UNIX，Windows和Macintosh兼容很好。
5. 互動模式：互動模式的支持，您可以從終端輸入執(zhí)行代碼并獲得結(jié)果的語言，互動的測試和調(diào)試代碼片斷。
6. 可移植：基于其開放源代碼的特性，Python已經(jīng)被移植（也就是使其工作）到許多平臺。
7. 可擴(kuò)展：如果你需要一段運行很快的關(guān)鍵代碼，或者是想要編寫一些不愿開放的算法，你可以使用C或C++完成那部分程序，然后從你的Python程序中調(diào)用。
8. 數(shù)據(jù)庫：Python提供所有主要的商業(yè)數(shù)據(jù)庫的接口。
9. GUI編程：Python支持GUI可以創(chuàng)建和移植到許多系統(tǒng)調(diào)用。
10. 可嵌入: 你可以將Python嵌入到C/C++程序，讓你的程序的用戶獲得'腳本化'的能力。

4. Python發(fā)展歷史

Python發(fā)展歷史：https://baike.baidu.com/item/Python/407313?fr=aladdin

5. Python版本

• Python 2.X
• Python 3.X

二、Python解釋器

1. 解釋器的作用

• Python解釋器作用：運行文件

• Python解釋器種類

  1. CPython，C語言開發(fā)的解釋器[官方]，應(yīng)用廣泛的解釋器。
  2. IPython，基于CPython的一種交互式解釋器。
  3. 其他解釋器
     • PyPy，基于Python語言開發(fā)的解釋器。
     • Jython，運行在Java平臺的解釋器，直接把Python代碼編譯成Java字節(jié)碼執(zhí)行。
     • IronPython，運行在微軟.Net平臺上的Python解釋器，可以直接把Python代碼編譯成.Net的字節(jié)碼。

2. 解釋器的安裝

Python解釋器的安裝：https://blog.csdn.net/weixin_43495473/article/details/103559812

三、PyCharm安裝與使用

1. PyCharm的作用

PyCharm是一種Python IDE（集成開發(fā)環(huán)境），帶有一整套可以幫助用戶在使用Python語言開發(fā)時提高其效率的工具，內(nèi)部集成的功能如下：

• Project管理
• 智能提示
• 語法高亮
• 代碼跳轉(zhuǎn)
• 調(diào)試代碼
• 解釋代碼(解釋器)
• 框架和庫
• …

2. PyCharm安裝與使用

PyCharm的安裝：https://blog.csdn.net/weixin_43495473/article/details/103560198

四、注釋

1. 注釋的作用

通過用自己熟悉的語言，在程序中對某些代碼進(jìn)行標(biāo)注說明，這就是注釋的作用，能夠大大增強(qiáng)程序的可讀性。

2. 注釋的分類及語法

注釋分為兩類：單行注釋 和 多行注釋。

• 單行注釋

只能注釋一行內(nèi)容，語法如下：

• 多行注釋

可以注釋多行內(nèi)容，一般用在注釋一段代碼的情況， 語法如下：

'''	第一行注釋	第二行注釋	第三行注釋''''''	注釋1	注釋2	注釋3'''
1
2
3
4
5
6
7
8
9
10
11

快捷鍵： ctrl + /

注意：解釋器不執(zhí)行任何的注釋內(nèi)容。

五、變量

1. 變量的作用

變量，簡單來說，其實就是計算機(jī)內(nèi)存中的一塊儲存空間，用來存儲CPU需要使用的數(shù)據(jù)。 而這個儲存空間需要一個名字，這個名字的統(tǒng)稱就叫變量。

作用：

1. 用來臨時保存數(shù)據(jù)
2. 便于項目的后期升級維護(hù)
3. 節(jié)約內(nèi)存

2. 定義變量

變量名自定義，要滿足標(biāo)識符命名規(guī)則。

2.1 標(biāo)識符

標(biāo)識符命名規(guī)則是Python中定義各種名字的時候的統(tǒng)一規(guī)范，具體如下：

• 由數(shù)字、字母、下劃線組成
• 不能數(shù)字開頭
• 不能使用內(nèi)置關(guān)鍵字
• 嚴(yán)格區(qū)分大小寫

2.2 命名習(xí)慣

• 見名知義。
• 大駝峰：即每個單詞首字母都大寫，例如：MyName。
• 小駝峰：第二個（含）以后的單詞首字母大寫，例如：myName。
• 下劃線：例如：my_name。

2.3 使用變量

my_name = '張三'print(my_name)myAge = 23print(myAge)
1
2
3
4
5

2.4 認(rèn)識bug

所謂bug，就是程序中的錯誤。如果程序有錯誤，需要程序員排查問題，糾正錯誤。

2.5 Debug工具

Debug工具是PyCharm IDE中集成的用來調(diào)試程序的工具，在這里程序員可以查看程序的執(zhí)行細(xì)節(jié)和流程或者調(diào)解bug。

Debug工具使用步驟：

1. 打斷點
2. Debug調(diào)試

六、數(shù)據(jù)類型

在 Python 里為了應(yīng)對不同的業(yè)務(wù)需求，也把數(shù)據(jù)分為不同的類型。

檢測數(shù)據(jù)類型的方法：type(變量名或者數(shù)值)

思考：

1. 為什么Python會提出這么多種的數(shù)據(jù)類型?

有限的內(nèi)存, 無限的變量, 合理的使用內(nèi)存

2. Python中，程序員定義變量需要關(guān)心變量的類型嗎?

• Python弱類型語言
• 程序員不需要關(guān)心變量的類型, 只需要把數(shù)據(jù)書寫正確即可，python會通過自動推到出您變量的類型。

七、輸出

作用：程序輸出內(nèi)容給用戶。

print('hello Python')age = 18print(age)# 需求：輸出“今年我的年齡是18歲”
1
2
3
4
5
6

1. 格式化輸出

• %06d，表示輸出的整數(shù)顯示位數(shù)，不足以0補(bǔ)全，超出當(dāng)前位數(shù)則原樣輸出。
• %.2f，表示小數(shù)點后顯示的小數(shù)位數(shù)。

2. 內(nèi)置函數(shù)format

format()用于字符串格式化，功能非常強(qiáng)大，格式是str.format()，format函數(shù)可以接受不限個參數(shù)，位置可以不按順序。

3. f-格式化字符串

f-string是格式化字符串的一種很好的新方法。與其他格式化方式相比，它不僅更易讀，更簡潔，不易出錯，而且速度更快！格式為：f'{表達(dá)式}'。

4. 體驗格式化字符串

5. 補(bǔ)充知識

字符串輸出的本質(zhì)其實就是拼接字符串，那么我們都用%s完全也是可以的。很多時候，我們不用區(qū)分整型、浮點型等，直接用%s輸出就可以了。

print('我的名字是%s，今年%s歲了，我的體重是%s公斤' % (name, age ,weight))
1

6. 轉(zhuǎn)義字符

• \n：換行。
• \t：制表符，一個tab鍵（4個空格）的距離。

7. 結(jié)束符

在Python中，print()， 默認(rèn)自帶end='\n'這個換行結(jié)束符，所以導(dǎo)致每兩個print直接會換行展示，用戶可以按需求更改結(jié)束符。

# 改變Python換行輸出print('內(nèi)容', end=' ')print('內(nèi)容', end='···')
1
2
3

八、輸入

在Python中，程序接收用戶輸入的數(shù)據(jù)的功能即是輸入。

1. 輸入的語法

2. 輸入的特點

• 當(dāng)程序執(zhí)行到input，等待用戶輸入，輸入完成之后才繼續(xù)向下執(zhí)行。
• 在Python中，input接收用戶輸入后，一般存儲到變量，方便使用。
• 在Python中，input會把接收到的任意用戶輸入的數(shù)據(jù)都當(dāng)做字符串處理。

password = input('請輸入您的密碼：')print(f'您輸入的密碼是{password}')# <class 'str'>print(type(password))
1
2
3
4
5

九、轉(zhuǎn)換數(shù)據(jù)類型

1. 轉(zhuǎn)換數(shù)據(jù)類型的作用

問：input()接收用戶輸入的數(shù)據(jù)都是字符串類型，如果用戶輸入1，想得到整型該如何操作？

答：轉(zhuǎn)換數(shù)據(jù)類型即可，即將字符串類型轉(zhuǎn)換成整型。

2. 轉(zhuǎn)換數(shù)據(jù)類型的函數(shù)

3. 體驗轉(zhuǎn)換數(shù)據(jù)類型

需求：input接收用戶輸入，用戶輸入“1”，將這個數(shù)據(jù)1轉(zhuǎn)換成整型。

# 1. float() -- 轉(zhuǎn)換成浮點型num1 = 1print(float(num1))print(type(float(num1)))# 2. str() -- 轉(zhuǎn)換成字符串類型num2 = 10print(type(str(num2)))# 3. tuple() -- 將一個序列轉(zhuǎn)換成元組list1 = [10, 20, 30]print(tuple(list1))print(type(tuple(list1)))# 4. list() -- 將一個序列轉(zhuǎn)換成列表t1 = (100, 200, 300)print(list(t1))print(type(list(t1)))# 5. eval() -- 將字符串中的數(shù)據(jù)轉(zhuǎn)換成Python表達(dá)式原本類型str1 = '10'str2 = '[1, 2, 3]'str3 = '(1000, 2000, 3000)'print(type(eval(str1)))print(type(eval(str2)))print(type(eval(str3)))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

十、運算符

1. 運算符的分類

• 算數(shù)運算符
• 賦值運算符
• 復(fù)合賦值運算符
• 比較運算符
• 邏輯運算符

2. 算數(shù)運算符

混合運算優(yōu)先級順序：()高于 ** 高于 * / // % 高于 + -

3. 賦值運算符

1. 單個變量賦值

2. 多個變量賦值

num1, float1, str1 = 10, 0.5, 'hello world'print(num1)print(float1)print(str1)
1
2
3
4

3. 多變量賦相同值

4. 復(fù)合賦值運算符

a = 100a += 1# 輸出101  a = a + 1,最終a = 100 + 1print(a)b = 2b *= 3# 輸出6  b = b * 3,最終b = 2 * 3print(b)c = 10c += 1 + 2# 輸出13, 先算運算符右側(cè)1 + 2 = 3， c += 3 , 推導(dǎo)出c = 10 + 3print(c)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

5. 比較運算符

比較運算符也叫關(guān)系運算符， 通常用來判斷。

6. 邏輯運算符

a = 1b = 2c = 3print((a < b) and (b < c))  # Trueprint((a > b) and (b < c))  # Falseprint((a > b) or (b < c))   # Trueprint(not (a > b))          # True
1
2
3
4
5
6
7

7. 補(bǔ)充知識

數(shù)字之間的邏輯運算

十一、條件語句

1. 了解條件語句

Python條件語句是通過一條或多條語句的執(zhí)行結(jié)果（True或者False）來決定執(zhí)行的代碼塊。

2. if語法

if 條件:    條件成立執(zhí)行的代碼1    條件成立執(zhí)行的代碼2    ......
1
2
3
4

2.1 體驗if語句

2.2 簡單版：網(wǎng)吧上網(wǎng)

需求分析：如果用戶年齡大于等于18歲，即成年，輸出'已經(jīng)成年，可以上網(wǎng)'。

age = 20if age >= 18:    print('已經(jīng)成年，可以上網(wǎng)')print('系統(tǒng)關(guān)閉')
1
2
3
4
5

2.3 進(jìn)階版：網(wǎng)吧上網(wǎng)

新增需求：用戶可以輸出自己的年齡，然后系統(tǒng)進(jìn)行判斷是否成年，成年則輸出'您的年齡是’用戶輸入的年齡’，已經(jīng)成年，可以上網(wǎng)'。

3. if…else…

作用：條件成立執(zhí)行if下方的代碼; 條件不成立執(zhí)行else下方的代碼。

if 條件:    條件成立執(zhí)行的代碼1    條件成立執(zhí)行的代碼2    ......else:    條件不成立執(zhí)行的代碼1    條件不成立執(zhí)行的代碼2    ......
1
2
3
4
5
6
7
8

思考：網(wǎng)吧上網(wǎng)的實例，如果成年，允許上網(wǎng)，如果不成年呢？是不是應(yīng)該回復(fù)用戶不能上網(wǎng)？

3.1 實用版：網(wǎng)吧上網(wǎng)

注意：如果條件成立執(zhí)行了某些代碼，那么其他的情況的代碼將不會執(zhí)行。

4. 多重判斷

if 條件1:    條件1成立執(zhí)行的代碼1    條件1成立執(zhí)行的代碼2    ......elif 條件2：	條件2成立執(zhí)行的代碼1    條件2成立執(zhí)行的代碼2    ............else:    以上條件都不成立執(zhí)行執(zhí)行的代碼
1
2
3
4
5
6
7
8
9
10
11

多重判斷也可以和else配合使用。一般else放在整個if語句的最后，表示以上條件都不成立的時候執(zhí)行的代碼。

思考：中國合法工作年齡為18-60歲，即如果年齡小于18的情況為童工，不合法；如果年齡在18-60歲之間為合法工齡；大于60歲為法定退休年齡。

4.1 實例：工齡判斷

拓展：age >= 18 and age <= 60可以化簡為18 <= age <= 60。

5. if嵌套

if 條件1：	條件1成立執(zhí)行的代碼    條件1成立執(zhí)行的代碼        if 條件2：    	條件2成立執(zhí)行的代碼        條件2成立執(zhí)行的代碼
1
2
3
4
5
6
7

注意：條件2的if也是出于條件1的縮進(jìn)關(guān)系內(nèi)部。

思考：坐公交：如果有錢可以上車，沒錢不能上車；上車后如果有空座，則可以坐下；如果沒空座，就要站著。怎么書寫程序？

5.1 實例：坐公交

1. 判斷是否能上車

2. 判斷是否能坐下

'''	1. 如果有錢，則可以上車    2. 上車后，如果有空座，可以坐下    上車后，如果沒有空座，則站著等空座位	如果沒錢，不能上車'''# 假設(shè)用 money = 1 表示有錢, money = 0表示沒有錢; seat = 1 表示有空座，seat = 0 表示沒有空座money = 1seat = 0if money == 1:    print('土豪，不差錢，順利上車')    if seat == 1:        print('有空座，可以坐下')    else:        print('沒有空座，站等')else:    print('沒錢，不能上車，追著公交車跑')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

5.2 if嵌套執(zhí)行流程

6. 應(yīng)用：猜拳游戲

需求分析：

• 參與游戲的角色

  • 玩家
    • 手動出拳
  • 電腦
    • 隨機(jī)出拳

• 判斷輸贏

  • 玩家獲勝

  玩家	電腦
  石頭	剪刀
  剪刀	布
  布	石頭

  • 平局
    • 玩家出拳 和 電腦出拳相同
  • 電腦獲勝

隨機(jī)做法：

1. 導(dǎo)出random模塊

2. 使用random模塊中的隨機(jī)整數(shù)功能

random.randint(開始,結(jié)束)
1

6.1 初始版：猜拳游戲

6.2 進(jìn)階版：猜拳游戲

'''石頭剪刀布游戲玩家VS電腦站在玩家的角度，分析勝利、失敗、平局0-石頭，1-剪刀，2-布'''# 導(dǎo)入隨機(jī)數(shù)模塊import randomimport sysprint('-----歡迎來到人機(jī)對戰(zhàn)小游戲-----')name = input('請輸入您的游戲名：')while True:    stats = input('歡迎“%s”來到本游戲，開始游戲輸入Y，退出游戲輸入N，請您輸入：' % name)    if stats == 'Y' or stats == 'y':        print('游戲開始……')        print('石頭輸入0、剪刀輸入1、布輸入2')        break    elif stats == 'N' or stats == 'n':        print('游戲結(jié)束……')        sys.exit(0)    else:        print('請按照要求重新輸入！')print('-------------加載中-------------')def Game(user, comp):    if (user== 0 and comp== 1) or (user== 1 and comp== 2) or (user== 2 and comp== 0):        print('機(jī)器輸入%d，您贏了！' % comp)    elif user == comp:        print('機(jī)器輸入%d，平局了！' % comp)    else:        print('機(jī)器輸入%d，您輸了！' % comp)    res = input('重新游戲請輸入X，退出游戲按任意鍵')    if res == 'X' or res == 'x':        return    else:        sys.exit(0)while True:    user = int(input('請您出拳，輸入相應(yīng)數(shù)字！'))    if user == 0 or user == 1 or user == 2:        comp = random.randint(0, 2)        Game(user, comp)    else:        print('輸入數(shù)字有誤，請確認(rèn)后，重新輸入！')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

7. 三目運算符

三目運算符也叫三元運算符。

語法如下：

快速體驗：

a = 1b = 2c = a if a > b else bprint(c)
1
2
3
4
5

十二、循環(huán)簡介

1. 循環(huán)的作用

讓代碼更高效的重復(fù)執(zhí)行。

2. 循環(huán)的分類

在Python中，循環(huán)分為while和for兩種，最終實現(xiàn)效果相同。

3. while的語法

4. while循環(huán)快速體驗

需求：復(fù)現(xiàn)重復(fù)執(zhí)行10次print('Hello World')。

分析：初始值是0次，終點是10次，重復(fù)做的事情輸出“Hello World”。

# 循環(huán)的計數(shù)器i = 0while i < 10:    print('Hello World')    i += 1print('任務(wù)結(jié)束')
1
2
3
4
5
6
7

5. while的應(yīng)用

5.1 應(yīng)用一：計算1-100累加和

分析：1-100的累加和，即1 + 2 + 3 + 4 +….，即前兩個數(shù)字的相加結(jié)果 + 下一個數(shù)字( 前一個數(shù)字 + 1)。

注意：為了驗證程序的準(zhǔn)確性，可以先改小數(shù)值，驗證結(jié)果正確后，再改成1-100做累加。

5.2 應(yīng)用二：計算1-100偶數(shù)累加和

分析：1-100的偶數(shù)和，即 2 + 4 + 6 + 8…，得到偶數(shù)的方法如下：

• 偶數(shù)即是和2取余結(jié)果為0的數(shù)字，可以加入條件語句判斷是否為偶數(shù)，為偶數(shù)則累加
• 初始值為0 / 2 , 計數(shù)器每次累加2

方法一：條件判斷和2取余數(shù)則累加

# 方法一：條件判斷和2取余數(shù)為0則累加計算i = 1result = 0while i <= 100:    if i % 2 == 0:        result += i    i += 1# 輸出2550print(result)
1
2
3
4
5
6
7
8
9
10

方法二：計數(shù)器控制

6. break和continue

break和continue是循環(huán)中滿足一定條件退出循環(huán)的兩種不同方式。

6.1 理解

舉例：一共吃5個蘋果，吃完第一個，吃第二個…，這里'吃蘋果'的動作是不是重復(fù)執(zhí)行？

情況一：如果吃的過程中，吃完第三個吃飽了，則不需要再吃第4個和第五個蘋果，即是吃蘋果的動作停止，這里就是break控制循環(huán)流程，即終止此循環(huán)。

情況二：如果吃的過程中，吃到第三個吃出一個大蟲子…,是不是這個蘋果就不吃了，開始吃第四個蘋果，這里就是continue控制循環(huán)流程，即退出當(dāng)前一次循環(huán)繼而執(zhí)行下一次循環(huán)代碼。

6.2 break實例

i = 1while i <= 5:    if i == 4:        print(f'吃飽了不吃了')        break    print(f'吃了第{i}個蘋果')    i += 1
1
2
3
4
5
6
7

6.3 continue實例

7. while循環(huán)嵌套

7.1 語法

while 條件1:    條件1成立執(zhí)行的代碼    ......    while 條件2:        條件2成立執(zhí)行的代碼        ......
1
2
3
4
5
6

總結(jié)：所謂while循環(huán)嵌套，就是一個while里面嵌套一個while的寫法，每個while和之前的基礎(chǔ)語法是相同的。

7.2 執(zhí)行過程

當(dāng)內(nèi)部循環(huán)執(zhí)行完成之后，再執(zhí)行下一次外部循環(huán)的條件判斷。

7.3 while循環(huán)嵌套應(yīng)用

應(yīng)用一：打印星號（正方形）

應(yīng)用二：打印星號（三角形）

# 重復(fù)打印5行星星# j表示行號j = 0while j <= 4:    # 一行星星的打印    i = 0    # i表示每行里面星星的個數(shù)，這個數(shù)字要和行號相等所以i要和j聯(lián)動    while i <= j:        print('*', end='')        i += 1    print()    j += 1
1
2
3
4
5
6
7
8
9
10
11
12

應(yīng)用二：九九乘法表

8. for循環(huán)

8.1 語法

for 臨時變量 in 序列:    重復(fù)執(zhí)行的代碼1    重復(fù)執(zhí)行的代碼2    ......
1
2
3
4

8.2 快速體驗

8.3 break

str1 = 'Hello World'for i in str1:    if i == 'e':        print('遇到e不打印')        break    print(i)
1
2
3
4
5
6

8.4 continue

十三、else

循環(huán)可以和else配合使用，else下方縮進(jìn)的代碼指的是當(dāng)循環(huán)正常結(jié)束之后要執(zhí)行的代碼。

1. while…else

1.1 語法

while 條件:    條件成立重復(fù)執(zhí)行的代碼else:    循環(huán)正常結(jié)束之后要執(zhí)行的代碼
1
2
3
4

1.2 示例

1.3 退出循環(huán)的方式

1. break終止循環(huán)

i = 1while i <= 5:    if i == 3:        print('提前結(jié)束')        break    print('Hello World')    i += 1else:    print('執(zhí)行完畢')
1
2
3
4
5
6
7
8
9

所謂else指的是循環(huán)正常結(jié)束之后要執(zhí)行的代碼，即如果是break終止循環(huán)的情況，else下方縮進(jìn)的代碼將不執(zhí)行。

2. continue控制循環(huán)

因為continue是退出當(dāng)前一次循環(huán)，繼續(xù)下一次循環(huán)，所以該循環(huán)在continue控制下是可以正常結(jié)束的，當(dāng)循環(huán)結(jié)束后，則執(zhí)行了else縮進(jìn)的代碼。

2. for…else

2.1 語法

for 臨時變量 in 序列:    重復(fù)執(zhí)行的代碼    ...else:    循環(huán)正常結(jié)束之后要執(zhí)行的代碼
1
2
3
4
5

所謂else指的是循環(huán)正常結(jié)束之后要執(zhí)行的代碼，即如果是break終止循環(huán)的情況，else下方縮進(jìn)的代碼將不執(zhí)行。

2.2 示例

2.3 退出循環(huán)的方式

1. break終止循環(huán)

str1 = 'Hello World'for i in str1:    if i == 'e':        print('遇到e不打印')        break    print(i)else:    print('循環(huán)正常結(jié)束之后執(zhí)行的代碼')
1
2
3
4
5
6
7
8

沒有執(zhí)行else縮進(jìn)的代碼。

2. continue控制循環(huán)

因為continue是退出當(dāng)前一次循環(huán)，繼續(xù)下一次循環(huán)，所以該循環(huán)在continue控制下是可以正常結(jié)束的，當(dāng)循環(huán)結(jié)束后，則執(zhí)行了else縮進(jìn)的代碼。

十四、字符串

1. 認(rèn)識字符串

字符串是 Python 中最常用的數(shù)據(jù)類型。我們一般使用引號來創(chuàng)建字符串。創(chuàng)建字符串很簡單，只要為變量分配一個值即可。

a = 'hello world'b = 'abcdefg'print(type(a))print(type(b))
1
2
3
4

注意：控制臺顯示結(jié)果為<class 'str'>， 即數(shù)據(jù)類型為str(字符串)。

2. 字符串特征

• 一對引號字符串

• 三引號字符串

name3 = ''' Tom '''name4 = ''' Rose '''a = ''' i am Tom,         nice to meet you! '''b = ''' i am Rose,         nice to meet you! '''
1
2
3
4
5
6
7

注意：三引號形式的字符串支持換行。

思考：如果創(chuàng)建一個字符串I'm Tom?

3. 字符串輸出

print('hello world')name = 'Tom'print('我的名字是%s' % name)print(f'我的名字是{name}')
1
2
3
4
5

4. 字符串輸入

在Python中，使用input()接收用戶輸入。

5. 下標(biāo)

5.1 概念

“下標(biāo)”又叫“索引”，就是編號。比如火車座位號，座位號的作用：按照編號快速找到對應(yīng)的座位。同理，下標(biāo)的作用即是通過下標(biāo)快速找到對應(yīng)的數(shù)據(jù)。

5.2 快速體驗

需求：字符串name = 'abcdef'，取到不同下標(biāo)對應(yīng)的數(shù)據(jù)。

• 代碼

name = 'abcdef'print(name[1])print(name[0])print(name[2])
1
2
3
4
5

• 輸出結(jié)果
  

注意：下標(biāo)從0開始。

6. 切片

切片是指對操作的對象截取其中一部分的操作。字符串、列表、元組都支持切片操作。

6.1 語法

注意：

• 不包含結(jié)束位置下標(biāo)對應(yīng)的數(shù)據(jù)， 正負(fù)整數(shù)均可；
  步長是選取間隔，正負(fù)整數(shù)均可，默認(rèn)步長為1。

6.2 示例

name = 'abcdefg'print(name[2:5:1])  # cdeprint(name[2:5])  # cdeprint(name[:5])  # abcdeprint(name[1:])  # bcdefgprint(name[:])  # abcdefgprint(name[::2])  # acegprint(name[:-1])  # abcdef, 負(fù)1表示倒數(shù)第一個數(shù)據(jù)print(name[-4:-1])  # defprint(name[::-1])  # gfedcba
1
2
3
4
5
6
7
8
9
10
11

7. 常用操作方法

字符串的常用操作方法有查找、修改和判斷三大類。

7.1 查找

所謂字符串查找方法即是查找子串在字符串中的位置或出現(xiàn)的次數(shù)。

• find()：檢測某個子串是否包含在這個字符串中，如果在返回這個子串開始的位置下標(biāo)，否則則返回-1。

1. 語法

注意：開始和結(jié)束位置下標(biāo)可以省略，表示在整個字符串序列中查找。

2. 快速體驗

mystr = 'hello world and buran and list and Python'print(mystr.find('and'))  # 12print(mystr.find('and', 15, 30))  # 22print(mystr.find('ands'))  # -1
1
2
3
4
5

• index()：檢測某個子串是否包含在這個字符串中，如果在返回這個子串開始的位置下標(biāo)，否則則報異常。

1. 語法

注意：開始和結(jié)束位置下標(biāo)可以省略，表示在整個字符串序列中查找。

2. 快速體驗

mystr = 'hello world and buran and list and Python'print(mystr.index('and'))  # 12print(mystr.index('and', 15, 30))  # 22print(mystr.index('ands'))  # 報錯
1
2
3
4
5

• rfind()： 和find()功能相同，但查找方向為右側(cè)開始。
• rindex()：和index()功能相同，但查找方向為右側(cè)開始。
• count()：返回某個子串在字符串中出現(xiàn)的次數(shù)。

1. 語法

注意：開始和結(jié)束位置下標(biāo)可以省略，表示在整個字符串序列中查找。

2. 快速體驗

mystr = 'hello world and buran and list and Python'print(mystr.count('and'))  # 3print(mystr.count('ands'))  # 0print(mystr.count('and', 0, 20))  # 1
1
2
3
4
5

7.2 修改

所謂修改字符串，指的就是通過函數(shù)的形式修改字符串中的數(shù)據(jù)。

• replace()：替換字符串。

1. 語法

注意：替換次數(shù)如果查出子串出現(xiàn)次數(shù)，則替換次數(shù)為該子串出現(xiàn)次數(shù)。

2. 快速體驗

mystr = 'hello world and buran and list and Python'print(mystr.replace('and', 'he'))# 結(jié)果：hello world he buran he list he Pythonprint(mystr.replace('and', 'he', 10))# 結(jié)果：hello world he buran he list he Pythonprint(mystr)# 結(jié)果：hello world and buran and list and Python
1
2
3
4
5
6
7
8

注意：數(shù)據(jù)按照是否能直接修改分為可變類型和不可變類型兩種。字符串類型的數(shù)據(jù)修改的時候不能改變原有字符串，屬于不能直接修改數(shù)據(jù)的類型即是不可變類型。

• split()：按照指定字符分割字符串。

1. 語法

注意：num表示的是分割字符出現(xiàn)的次數(shù)，即將來返回數(shù)據(jù)個數(shù)為num+1個。

2. 快速體驗

mystr = 'hello world and buran and list and Python'print(mystr.split('and'))# 結(jié)果：['hello world ', ' buran ', ' list ', ' Python']print(mystr.split('and', 2))# 結(jié)果：['hello world ', ' buran ', ' list and Python']print(mystr.split(' '))# 結(jié)果：['hello', 'world', 'and', 'buran', 'and', 'list', 'and', 'Python']print(mystr.split(' ', 2))# 結(jié)果：['hello', 'world', 'and buran and list and Python']
1
2
3
4
5
6
7
8
9
10

注意：如果分割字符是原有字符串中的子串，分割后則丟失該子串。

• join()：用一個字符或子串合并字符串，即是將多個字符串合并為一個新的字符串。

1. 語法

2. 快速體驗

list1 = ['hello', 'buran', 'list']t1 = ('aa', 'b', 'cc', 'ddd')print('_'.join(list1))# hello_buran_listprint('...'.join(t1))# 結(jié)果：aa...b...cc...ddd
1
2
3
4
5
6
7

• capitalize()：將字符串第一個字符轉(zhuǎn)換成大寫。

注意：capitalize()函數(shù)轉(zhuǎn)換后，只字符串第一個字符大寫，其他的字符全都小寫。

• title()：將字符串每個單詞首字母轉(zhuǎn)換成大寫。

mystr = 'hello world and buran and list and Python'print(mystr.title())# 結(jié)果：Hello World And Buran And List And Python
1
2
3
4

• lower()：將字符串中大寫轉(zhuǎn)小寫。

• upper()：將字符串中小寫轉(zhuǎn)大寫。

mystr = 'hello world and buran and list and Python'print(mystr.upper())# 結(jié)果：HELLO WORLD AND BURAN AND LIST AND PYTHON
1
2
3
4

• lstrip()：刪除字符串左側(cè)空白字符。
• rstrip()：刪除字符串右側(cè)空白字符。
• strip()：刪除字符串兩側(cè)空白字符。
• ljust()：返回一個原字符串左對齊,并使用指定字符(默認(rèn)空格)填充至對應(yīng)長度 的新字符串。
• rjust()：返回一個原字符串右對齊,并使用指定字符(默認(rèn)空格)填充至對應(yīng)長度 的新字符串，語法和ljust()相同。
• center()：返回一個原字符串居中對齊,并使用指定字符(默認(rèn)空格)填充至對應(yīng)長度 的新字符串，語法和ljust()相同。

7.3 判斷

所謂判斷即是判斷真假，返回的結(jié)果是布爾型數(shù)據(jù)類型：True 或 False。

• startswith()：檢查字符串是否是以指定子串開頭，是則返回 True，否則返回 False。如果設(shè)置開始和結(jié)束位置下標(biāo)，則在指定范圍內(nèi)檢查。

1. 語法

2. 快速體驗

mystr = 'hello world and buran and list and Python'print(mystr.startswith('hello'))# 結(jié)果：Trueprint(mystr.startswith('hello', 5, 20))# 結(jié)果：False
1
2
3
4
5
6

• endswith()：：檢查字符串是否是以指定子串結(jié)尾，是則返回 True，否則返回 False。如果設(shè)置開始和結(jié)束位置下標(biāo)，則在指定范圍內(nèi)檢查。

1. 語法

2. 快速體驗

mystr = 'hello world and buran and list and Python'print(mystr.endswith('Python'))# 結(jié)果：Trueprint(mystr.endswith('python'))# 結(jié)果：Falseprint(mystr.endswith('Python', 2, 20))# 結(jié)果：False
1
2
3
4
5
6
7
8

• isalpha()：如果字符串至少有一個字符并且所有字符都是字母則返回 True, 否則返回 False。

• isdigit()：如果字符串只包含數(shù)字則返回 True 否則返回 False。

mystr1 = 'aaa12345'mystr2 = '12345'print(mystr1.isdigit())# 結(jié)果： Falseprint(mystr2.isdigit())# 結(jié)果：False
1
2
3
4
5
6
7

• isalnum()：如果字符串至少有一個字符并且所有字符都是字母或數(shù)字則返 回 True,否則返回 False。

• isspace()：如果字符串中只包含空白，則返回 True，否則返回 False。

mystr1 = '1 2 3 4 5'mystr2 = '     'print(mystr1.isspace())# 結(jié)果：Falseprint(mystr2.isspace())# 結(jié)果：True
1
2
3
4
5
6
7

十五、列表

1. 列表的格式

列表可以一次性有序存儲多個不同類型的數(shù)據(jù)。

2. 列表的常用操作

列表的作用是一次性存儲多個數(shù)據(jù)，程序員可以對這些數(shù)據(jù)進(jìn)行的操作有：增、刪、改、查。

2.1 查找

1. 下標(biāo)

name_list = ['Tom', 'Lily', 'Rose']print(name_list[0])  # Tomprint(name_list[1])  # Lilyprint(name_list[2])  # Rose
1
2
3
4
5

2. 函數(shù)

• index()：返回指定數(shù)據(jù)所在位置的下標(biāo) 。

name_list = ['Tom', 'Lily', 'Rose']print(name_list.index('Lily', 0, 2))  # 1
1
2
3

注意：如果查找的數(shù)據(jù)不存在則報錯。

• count()：統(tǒng)計指定數(shù)據(jù)在當(dāng)前列表中出現(xiàn)的次數(shù)。

• len()：訪問列表長度，即列表中數(shù)據(jù)的個數(shù)。

name_list = ['Tom', 'Lily', 'Rose']print(len(name_list))  # 3
1
2
3

2.2 判斷是否存在

• in：判斷指定數(shù)據(jù)在某個列表序列，如果在返回True，否則返回False。

• not in：判斷指定數(shù)據(jù)不在某個列表序列，如果不在返回True，否則返回False。

name_list = ['Tom', 'Lily', 'Rose']# 結(jié)果：Falseprint('Lily' not in name_list)# 結(jié)果：Trueprint('Lilys' not in name_list)
1
2
3
4
5
6
7

2.2 增加

作用：增加指定數(shù)據(jù)到列表中。

• append()：列表結(jié)尾追加數(shù)據(jù)。

name_list = ['Tom', 'Lily', 'Rose']name_list.append('xiaoming')# 結(jié)果：['Tom', 'Lily', 'Rose', 'xiaoming']print(name_list)
1
2
3
4
5
6

列表追加數(shù)據(jù)的時候，直接在原列表里面追加了指定數(shù)據(jù)，即修改了原列表，故列表為可變類型數(shù)據(jù)。

注意點：如果append()追加的數(shù)據(jù)是一個序列，則追加整個序列到列表。

• extend()：列表結(jié)尾追加數(shù)據(jù)，如果數(shù)據(jù)是一個序列，則將這個序列的數(shù)據(jù)逐一添加到列表。

列表序列.extend(數(shù)據(jù))
1

單個數(shù)據(jù)：

序列數(shù)據(jù)：

name_list = ['Tom', 'Lily', 'Rose']name_list.extend(['xiaoming', 'xiaohong'])# 結(jié)果：['Tom', 'Lily', 'Rose', 'xiaoming', 'xiaohong']print(name_list)
1
2
3
4
5
6

• insert()：指定位置新增數(shù)據(jù)。

name_list = ['Tom', 'Lily', 'Rose']name_list.insert(1, 'xiaoming')# 結(jié)果：['Tom', 'xiaoming', 'Lily', 'Rose']print(name_list)
1
2
3
4
5
6

2.3 刪除

• del

刪除列表：

name_list = ['Tom', 'Lily', 'Rose']# 結(jié)果：報錯提示：name 'name_list' is not defineddel name_listprint(name_list)
1
2
3
4
5

刪除指定數(shù)據(jù)：

• pop()：刪除指定下標(biāo)的數(shù)據(jù)(默認(rèn)為最后一個)，并返回該數(shù)據(jù)。

列表序列.pop(下標(biāo))
1

• remove()：移除列表中某個數(shù)據(jù)的第一個匹配項。

列表序列.remove(數(shù)據(jù))
1

• clear()：清空列表

name_list = ['Tom', 'Lily', 'Rose']name_list.clear()print(name_list) # 結(jié)果： []
1
2
3
4

2.4 修改

• 修改指定下標(biāo)數(shù)據(jù)

• 逆置：reverse()

num_list = [1, 5, 2, 3, 6, 8]num_list.reverse()# 結(jié)果：[8, 6, 3, 2, 5, 1]print(num_list)
1
2
3
4
5
6

• 排序：sort()

num_list = [1, 5, 2, 3, 6, 8]num_list.sort()# 結(jié)果：[1, 2, 3, 5, 6, 8]print(num_list)
1
2
3
4
5
6

注意：reverse表示排序規(guī)則，reverse = True 降序， reverse = False 升序（默認(rèn)）

2.5 復(fù)制

• 函數(shù)：copy()

3. 列表的循環(huán)遍歷

需求：依次打印列表中的各個數(shù)據(jù)。

3.1 while

name_list = ['Tom', 'Lily', 'Rose']i = 0while i < len(name_list):    print(name_list[i])    i += 1
1
2
3
4
5
6

3.2 for

4. 列表嵌套

所謂列表嵌套指的就是一個列表里面包含了其他的子列表。

應(yīng)用場景：要存儲班級一、二、三三個班級學(xué)生姓名，且每個班級的學(xué)生姓名在一個列表。

name_list = [['小明', '小紅', '小綠'], ['Tom', 'Lily', 'Rose'], ['張三', '李四', '王五']]
1

思考： 如何查找到數(shù)據(jù)'李四'？

十六、元組

一個元組可以存儲多個數(shù)據(jù)，元組內(nèi)的數(shù)據(jù)是不能修改的。

1. 定義元組

元組特點：定義元組使用小括號，且逗號隔開各個數(shù)據(jù)，數(shù)據(jù)可以是不同的數(shù)據(jù)類型。

# 多個數(shù)據(jù)元組t1 = (10, 20, 30)# 單個數(shù)據(jù)元組t2 = (10,)
1
2
3
4
5

注意：如果定義的元組只有一個數(shù)據(jù)，那么這個數(shù)據(jù)后面也好添加逗號，否則數(shù)據(jù)類型為唯一的這個數(shù)據(jù)的數(shù)據(jù)類型。

2. 元組的常見操作

元組數(shù)據(jù)不支持修改，只支持查找，具體如下：

• 按下標(biāo)查找數(shù)據(jù)

tuple1 = ('aa', 'bb', 'cc', 'bb')print(tuple1[0])  # aa
1
2

• index()：查找某個數(shù)據(jù)，如果數(shù)據(jù)存在返回對應(yīng)的下標(biāo)，否則報錯，語法和列表、字符串的index方法相同。

• count()：統(tǒng)計某個數(shù)據(jù)在當(dāng)前元組出現(xiàn)的次數(shù)。

tuple1 = ('aa', 'bb', 'cc', 'bb')print(tuple1.count('bb'))  # 2
1
2

• len()：統(tǒng)計元組中數(shù)據(jù)的個數(shù)。

3. 元組的注意事項

元組內(nèi)的直接數(shù)據(jù)如果修改則立即報錯。

tuple1 = ('aa', 'bb', 'cc', 'bb')tuple1[0] = 'aaa'
1
2

但是如果元組里面有列表，修改列表里面的數(shù)據(jù)則是支持的，故自覺很重要。

十七、字典

字典里面的數(shù)據(jù)是以“鍵值對”形式出現(xiàn)，字典數(shù)據(jù)和數(shù)據(jù)順序沒有關(guān)系，即字典不支持下標(biāo)，后期無論數(shù)據(jù)如何變化，只需要按照對應(yīng)的鍵的名字查找數(shù)據(jù)即可。

1. 創(chuàng)建字典的語法

字典特點：

• 符號為大括號
• 數(shù)據(jù)為鍵值對形式出現(xiàn)
• 各個鍵值對之間用逗號隔開

# 有數(shù)據(jù)字典dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}# 空字典dict2 = {}dict3 = dict()
1
2
3
4
5
6
7

注意：一般稱冒號前面的為鍵(key)，簡稱k；冒號后面的為值(value)，簡稱v。

2. 字典常見操作

2.1 增

寫法：字典序列[key] = 值

注意：如果key存在則修改這個key對應(yīng)的值；如果key不存在則新增此鍵值對。

注意：字典為可變類型。

2.2 刪

• del() / del：刪除字典或刪除字典中指定鍵值對。

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}del dict1['gender']# 結(jié)果：{'name': 'Tom', 'age': 20}print(dict1)
1
2
3
4
5

• clear()：清空字典

2.3 改

寫法：字典序列[key] = 值

注意：如果key存在則修改這個key對應(yīng)的值 ；如果key不存在則新增此鍵值對。

2.4 查

1. key值查找

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}print(dict1['name'])  # Tomprint(dict1['id'])  # 報錯
1
2
3

如果當(dāng)前查找的key存在，則返回對應(yīng)的值；否則則報錯。

2. get()

注意：如果當(dāng)前查找的key不存在則返回第二個參數(shù)(默認(rèn)值)，如果省略第二個參數(shù)，則返回None。

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}print(dict1.get('name'))  # Tomprint(dict1.get('id', 110))  # 110print(dict1.get('id'))  # None
1
2
3
4

3. keys()

4. values()

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}print(dict1.values())  # dict_values(['Tom', 20, '男'])
1
2

5. items()

3. 字典的循環(huán)遍歷

3.1 遍歷字典的key

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}for key in dict1.keys():    print(key)
1
2
3

3.2 遍歷字典的value

3.3 遍歷字典的元素

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}for item in dict1.items():    print(item)
1
2
3

3.4 遍歷字典的鍵值對

十八、集合

集合具有確定性，無序性和去重性。

1. 創(chuàng)建集合

創(chuàng)建集合使用{}或set()， 但是如果要創(chuàng)建空集合只能使用set()，因為{}用來創(chuàng)建空字典。

s1 = {10, 20, 30, 40, 50}print(s1)s2 = {10, 30, 20, 10, 30, 40, 30, 50}print(s2)s3 = set('abcdefg')print(s3)s4 = set()print(type(s4))  # sets5 = {}print(type(s5))  # dict
1
2
3
4
5
6
7
8
9
10
11
12
13
14

特點：

1. 集合可以去掉重復(fù)數(shù)據(jù)；
2. 集合數(shù)據(jù)是無序的，故不支持下標(biāo)。

2. 集合常見操作方法

2.1 增加數(shù)據(jù)

• add()

因為集合有去重功能，所以，當(dāng)向集合內(nèi)追加的數(shù)據(jù)是當(dāng)前集合已有數(shù)據(jù)的話，則不進(jìn)行任何操作。

• update(), 追加的數(shù)據(jù)是序列。

s1 = {10, 20}# s1.update(100)  # 報錯s1.update([100, 200])s1.update('abc')print(s1)   # {'a', 100, 200, 10, 'b', 'c', 20}
1
2
3
4
5

2.2 刪除數(shù)據(jù)

• remove()，刪除集合中的指定數(shù)據(jù)，如果數(shù)據(jù)不存在則報錯。

• discard()，刪除集合中的指定數(shù)據(jù)，如果數(shù)據(jù)不存在也不會報錯。

s1 = {10, 20}s1.discard(10)print(s1)s1.discard(10)print(s1)
1
2
3
4
5
6
7

• pop()，隨機(jī)刪除集合中的某個數(shù)據(jù)，并返回這個數(shù)據(jù)。

2.3 查找數(shù)據(jù)

• in：判斷數(shù)據(jù)在集合序列
• not in：判斷數(shù)據(jù)不在集合序列

s1 = {10, 20, 30, 40, 50}print(10 in s1)print(10 not in s1)
1
2
3
4

十九、公共操作

1. 運算符

1.1 +

1.2 *

# 1. 字符串print('-' * 10)  # ----------# 2. 列表list1 = ['hello']print(list1 * 4)  # ['hello', 'hello', 'hello', 'hello']# 3. 元組t1 = ('world',)print(t1 * 4)  # ('world', 'world', 'world', 'world')
1
2
3
4
5
6
7
8
9
10

1.3 in或not in

2. 公共方法

2.1 len()

# 1. 字符串str1 = 'abcdefg'print(len(str1))  # 7# 2. 列表list1 = [10, 20, 30, 40]print(len(list1))  # 4# 3. 元組t1 = (10, 20, 30, 40, 50)print(len(t1))  # 5# 4. 集合s1 = {10, 20, 30}print(len(s1))  # 3# 5. 字典dict1 = {'name': 'Rose', 'age': 18}print(len(dict1))  # 2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

2.2 del()

2.3 max()

# 1. 字符串str1 = 'abcdefg'print(max(str1))  # g# 2. 列表list1 = [10, 20, 30, 40]print(max(list1))  # 40
1
2
3
4
5
6
7

2.4 min()

2.5 range()

# 1 2 3 4 5 6 7 8 9for i in range(1, 10, 1):    print(i)# 1 3 5 7 9for i in range(1, 10, 2):    print(i)# 0 1 2 3 4 5 6 7 8 9for i in range(10):    print(i)
1
2
3
4
5
6
7
8
9
10
11

注意：range()生成的序列不包含end數(shù)字。

2.6 enumerate()

注意：start參數(shù)用來設(shè)置遍歷數(shù)據(jù)的下標(biāo)的起始值，默認(rèn)為0。

list1 = ['a', 'b', 'c', 'd', 'e']for i in enumerate(list1):    print(i)for index, char in enumerate(list1, start=1):    print(f'下標(biāo)是{index}, 對應(yīng)的字符是{char}')
1
2
3
4
5
6
7

3. 容器類型轉(zhuǎn)換

3.1 tuple()

作用：將某個序列轉(zhuǎn)換成元組。

3.2 list()

作用：將某個序列轉(zhuǎn)換成列表。

t1 = ('a', 'b', 'c', 'd', 'e')s1 = {100, 200, 300, 400, 500}print(list(t1))print(list(s1))
1
2
3
4
5

3.3 set()

作用：將某個序列轉(zhuǎn)換成集合。

注意：

1. 集合可以快速完成列表去重。
2. 集合不支持下標(biāo)。

二十、推導(dǎo)式

1. 列表推導(dǎo)式

作用：用一個表達(dá)式創(chuàng)建一個有規(guī)律的列表或控制一個有規(guī)律列表。

列表推導(dǎo)式又叫列表生成式。

1.1 快速體驗

需求：創(chuàng)建一個0-10的列表。

• while循環(huán)實現(xiàn)

# 1. 準(zhǔn)備一個空列表list1 = []# 2. 書寫循環(huán)，依次追加數(shù)字到空列表list1中i = 0while i < 10:    list1.append(i)    i += 1print(list1)
1
2
3
4
5
6
7
8
9
10

• for循環(huán)實現(xiàn)

• 列表推導(dǎo)式實現(xiàn)

list1 = [i for i in range(10)]print(list1)
1
2

1.2 帶if的列表推導(dǎo)式

需求：創(chuàng)建0-10的偶數(shù)列表

• 方法一：range()步長實現(xiàn)

• 方法二：if實現(xiàn)

list1 = [i for i in range(10) if i % 2 == 0]print(list1)
1
2

1.3 多個for循環(huán)實現(xiàn)列表推導(dǎo)式

需求：創(chuàng)建列表如下：

• 代碼如下：

list1 = [(i, j) for i in range(1, 3) for j in range(3)]print(list1)
1
2

2. 字典推導(dǎo)式

字典推導(dǎo)式作用：快速合并列表為字典或提取字典中目標(biāo)數(shù)據(jù)。

2.1 快速體驗

1. 創(chuàng)建一個字典：字典key是1-5數(shù)字，value是這個數(shù)字的2次方。

2. 將兩個列表合并為一個字典

list1 = ['name', 'age', 'gender']list2 = ['Tom', 20, 'man']dict1 = {list1[i]: list2[i] for i in range(len(list1))}print(dict1)
1
2
3
4
5

3. 提取字典中目標(biāo)數(shù)據(jù)

3. 集合推導(dǎo)式

需求：創(chuàng)建一個集合，數(shù)據(jù)為下方列表的2次方。

list1 = [1, 1, 2]
1

代碼如下：

注意：集合有數(shù)據(jù)去重功能。

補(bǔ)充：接下來的Python高級語法：函數(shù)、文件操作、面向?qū)ο蟆⒛K、包、異常等知識，我將陸續(xù)更新在自己的博客之中。如果本博文的知識能幫助到您的Python學(xué)習(xí)，本博主實屬榮幸。更多后續(xù)知識，請關(guān)注博主，方便您第一時間查看，謝謝！