python中print的本质_Python基础语法全解
一、Python簡介
1. 了解Python
Python是一種解釋型(這意味著開發(fā)過程中沒有了編譯這個環(huán)節(jié))、面向對象(支持面向對象的風格或代碼封裝在對象的編程技術)、動態(tài)數(shù)據(jù)類型的交互式(可在命令行中通過Python提示符及直接代碼執(zhí)行程序)高級程序設計語言。
2. Python介紹
Python是時下最流行、最火爆的編程語言，具體原因：
簡單、易學，適應人群廣泛
免費、開源
應用領域廣泛
備注：以下知名框架均是Python語言開發(fā)。
Google開源機器學習框架：TensorFlow
開源社區(qū)主推學習框架：Scikit-learn
百度開源深度學習框架：Paddle
3. Python特點
易于學習：Python有相對較少的關鍵字，結構簡單，和一個明確定義的語法，學習起來更加簡單。
易于閱讀：Python代碼定義的更清晰。
易于維護：Python的成功在于它的源代碼是相當容易維護的。
一個廣泛的標準庫：Python的最大的優(yōu)勢之一是豐富的庫，跨平臺的，在UNIX，Windows和Macintosh兼容很好。
互動模式：互動模式的支持，您可以從終端輸入執(zhí)行代碼并獲得結果的語言，互動的測試和調試代碼片斷。
可移植：基于其開放源代碼的特性，Python已經(jīng)被移植(也就是使其工作)到許多平臺。
可擴展：如果你需要一段運行很快的關鍵代碼，或者是想要編寫一些不愿開放的算法，你可以使用C或C++完成那部分程序，然后從你的Python程序中調用。
數(shù)據(jù)庫：Python提供所有主要的商業(yè)數(shù)據(jù)庫的接口。
GUI編程：Python支持GUI可以創(chuàng)建和移植到許多系統(tǒng)調用。
可嵌入: 你可以將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解釋器種類
PyPy，基于Python語言開發(fā)的解釋器。
Jython，運行在Java平臺的解釋器，直接把Python代碼編譯成Java字節(jié)碼執(zhí)行。
IronPython，運行在微軟.Net平臺上的Python解釋器，可以直接把Python代碼編譯成.Net的字節(jié)碼。
CPython，C語言開發(fā)的解釋器[官方]，應用廣泛的解釋器。
IPython，基于CPython的一種交互式解釋器。
其他解釋器
2. 解釋器的安裝
Python解釋器的安裝：https://blog.csdn.net/weixin_43495473/article/details/103559812
三、PyCharm安裝與使用
1. PyCharm的作用
PyCharm是一種Python?IDE(集成開發(fā)環(huán)境)，帶有一整套可以幫助用戶在使用Python語言開發(fā)時提高其效率的工具，內部集成的功能如下：
Project管理
智能提示
語法高亮
代碼跳轉
調試代碼
解釋代碼(解釋器)
框架和庫
…
2. PyCharm安裝與使用
PyCharm的安裝：https://blog.csdn.net/weixin_43495473/article/details/103560198
四、注釋
1. 注釋的作用
通過用自己熟悉的語言，在程序中對某些代碼進行標注說明，這就是注釋的作用，能夠大大增強程序的可讀性。
2. 注釋的分類及語法
注釋分為兩類：單行注釋?和?多行注釋。
單行注釋
只能注釋一行內容，語法如下：
#?注釋內容多行注釋
可以注釋多行內容，一般用在注釋一段代碼的情況， 語法如下：
""" 第一行注釋 第二行注釋 第三行注釋"""''' 注釋1 注釋2 注釋3'''快捷鍵：?ctrl + /
注意：解釋器不執(zhí)行任何的注釋內容。
五、變量
1. 變量的作用
變量，簡單來說，其實就是計算機內存中的一塊儲存空間，用來存儲CPU需要使用的數(shù)據(jù)。而這個儲存空間需要一個名字，這個名字的統(tǒng)稱就叫變量。
作用：
用來臨時保存數(shù)據(jù)
便于項目的后期升級維護
節(jié)約內存
2. 定義變量
變量名?=?值變量名自定義，要滿足標識符命名規(guī)則。
2.1 標識符
標識符命名規(guī)則是Python中定義各種名字的時候的統(tǒng)一規(guī)范，具體如下：
由數(shù)字、字母、下劃線組成
不能數(shù)字開頭
不能使用內置關鍵字
嚴格區(qū)分大小寫
2.2 命名習慣
見名知義。
大駝峰：即每個單詞首字母都大寫，例如：MyName。
小駝峰：第二個(含)以后的單詞首字母大寫，例如：myName。
下劃線：例如：my_name。
2.3 使用變量
my_name = "張三"print(my_name)myAge = 23print(myAge)2.4 認識bug
所謂bug，就是程序中的錯誤。如果程序有錯誤，需要程序員排查問題，糾正錯誤。
2.5 Debug工具
Debug工具是PyCharm IDE中集成的用來調試程序的工具，在這里程序員可以查看程序的執(zhí)行細節(jié)和流程或者調解bug。
Debug工具使用步驟：
打斷點
Debug調試
六、數(shù)據(jù)類型
在 Python 里為了應對不同的業(yè)務需求，也把數(shù)據(jù)分為不同的類型。
檢測數(shù)據(jù)類型的方法：type(變量名或者數(shù)值)
a = 1print(type(a)) # -- 整型b = 1.1print(type(b)) # -- 浮點型c = Trueprint(type(c)) # -- 布爾型d = "12345"print(type(d)) # -- 字符串e = [10, 20, 30]print(type(e)) # -- 列表f = (10, 20, 30)print(type(f)) # -- 元組h = {10, 20, 30}print(type(h)) # -- 集合g = {"name": "張三", "age": 20}print(type(g))??#??--?字典思考：
為什么Python會提出這么多種的數(shù)據(jù)類型?
有限的內存, 無限的變量, 合理的使用內存
Python中，程序員定義變量需要關心變量的類型嗎?
Python弱類型語言
程序員不需要關心變量的類型, 只需要把數(shù)據(jù)書寫正確即可，python會通過自動推到出您變量的類型。
七、輸出
作用：程序輸出內容給用戶。
print('hello Python')age = 18print(age)#?需求：輸出“今年我的年齡是18歲”1. 格式化輸出
%06d，表示輸出的整數(shù)顯示位數(shù)，不足以0補全，超出當前位數(shù)則原樣輸出。
%.2f，表示小數(shù)點后顯示的小數(shù)位數(shù)。
2. 內置函數(shù)format
format()用于字符串格式化，功能非常強大，格式是str.format()，format函數(shù)可以接受不限個參數(shù)，位置可以不按順序。
3. f-格式化字符串
f-string是格式化字符串的一種很好的新方法。與其他格式化方式相比，它不僅更易讀，更簡潔，不易出錯，而且速度更快！格式為：f'{表達式}'。
4. 體驗格式化字符串
name = "張三"age = 23weight = 75.5student_id = 1# 我的名字是張三print('我的名字是%s' % name)# 我的學號是0001print('我的學號是%04d' % student_id)# 我的體重是75.50公斤print('我的體重是%.2f公斤' % weight)# 我的名字是張三，今年23歲了print('我的名字是%s，今年%d歲了' % (name, age))# 我的名字是張三，明年24歲了print('我的名字是%s，明年%d歲了' % (name, age + 1))# 我的名字是張三，明年24歲了print('我的名字是{0}, 明年{1}歲了'.format(name, age+1))# 我的名字是李思，今年18歲了print('我的名字是{0}, 今年{1}歲了'.format("李思", 18))# 我的名字是張三，明年24歲了print(f'我的名字是{name},?明年{age?+?1}歲了')5. 補充知識
字符串輸出的本質其實就是拼接字符串，那么我們都用%s完全也是可以的。很多時候，我們不用區(qū)分整型、浮點型等，直接用%s輸出就可以了。
print('我的名字是%s，今年%s歲了，我的體重是%s公斤'?%?(name,?age?,weight))6. 轉義字符
\n：換行。
\t：制表符，一個tab鍵(4個空格)的距離。
7. 結束符
# print會默認換行輸出print('輸出的內容',?end="\n")在Python中，print()， 默認自帶end="\n"這個換行結束符，所以導致每兩個print直接會換行展示，用戶可以按需求更改結束符。
# 改變Python換行輸出print('內容', end=" ")print('內容',?end="···")八、輸入
在Python中，程序接收用戶輸入的數(shù)據(jù)的功能即是輸入。
1. 輸入的語法
input("提示信息")2. 輸入的特點
當程序執(zhí)行到input，等待用戶輸入，輸入完成之后才繼續(xù)向下執(zhí)行。
在Python中，input接收用戶輸入后，一般存儲到變量，方便使用。
在Python中，input會把接收到的任意用戶輸入的數(shù)據(jù)都當做字符串處理。
九、轉換數(shù)據(jù)類型
1. 轉換數(shù)據(jù)類型的作用
問：input()接收用戶輸入的數(shù)據(jù)都是字符串類型，如果用戶輸入1，想得到整型該如何操作？
答：轉換數(shù)據(jù)類型即可，即將字符串類型轉換成整型。
2. 轉換數(shù)據(jù)類型的函數(shù)
3. 體驗轉換數(shù)據(jù)類型
需求：input接收用戶輸入，用戶輸入“1”，將這個數(shù)據(jù)1轉換成整型。
# 1. 接收用戶輸入num = input('請輸入您的幸運數(shù)字：')# 2. 打印結果print(f"您的幸運數(shù)字是{num}")# 3. 檢測接收到的用戶輸入的數(shù)據(jù)類型 -- str類型print(type(num))# 4. 轉換數(shù)據(jù)類型為整型 -- int類型print(type(int(num)))# 1. float() -- 轉換成浮點型num1 = 1print(float(num1))print(type(float(num1)))# 2. str() -- 轉換成字符串類型num2 = 10print(type(str(num2)))# 3. tuple() -- 將一個序列轉換成元組list1 = [10, 20, 30]print(tuple(list1))print(type(tuple(list1)))# 4. list() -- 將一個序列轉換成列表t1 = (100, 200, 300)print(list(t1))print(type(list(t1)))# 5. eval() -- 將字符串中的數(shù)據(jù)轉換成Python表達式原本類型str1 = '10'str2 = '[1, 2, 3]'str3 = '(1000, 2000, 3000)'print(type(eval(str1)))print(type(eval(str2)))print(type(eval(str3)))十、運算符
1. 運算符的分類
算數(shù)運算符
賦值運算符
復合賦值運算符
比較運算符
邏輯運算符
2. 算數(shù)運算符
混合運算優(yōu)先級順序：()高于?**?高于?*?/?//?%?高于?+?-
3. 賦值運算符
1.單個變量賦值
num = 1print(num)2. 多個變量賦值
num1, float1, str1 = 10, 0.5, 'hello world'print(num1)print(float1)print(str1)3. 多變量賦相同值
a = b = 10print(a)print(b)4. 復合賦值運算符
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, 先算運算符右側1 + 2 = 3， c += 3 , 推導出c = 10 + 3print(c)5. 比較運算符
比較運算符也叫關系運算符， 通常用來判斷。
a = 7b = 5print(a == b) # Falseprint(a != b) # Trueprint(a < b) # Falseprint(a > b) # Trueprint(a <= b) # Falseprint(a?>=?b)??#?True6. 邏輯運算符
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))??????????#?True7. 補充知識
數(shù)字之間的邏輯運算
a = 0b = 1c = 2# and運算符，只要有一個值為0，則結果為0，否則結果為最后一個非0數(shù)字print(a and b) # 0print(b and a) # 0print(a and c) # 0print(c and a) # 0print(b and c) # 2print(c and b) # 1# or運算符，只有所有值為0結果才為0，否則結果為第一個非0數(shù)字print(a or b) # 1print(a or c) # 2print(b?or?c)??#?1十一、條件語句
1. 了解條件語句
Python條件語句是通過一條或多條語句的執(zhí)行結果(True或者False)來決定執(zhí)行的代碼塊。
2. if語法
if 條件: 條件成立執(zhí)行的代碼1 條件成立執(zhí)行的代碼2????......2.1 體驗if語句
if True: print('條件成立執(zhí)行的代碼1') print('條件成立執(zhí)行的代碼2')# 下方的代碼沒有縮進到if語句塊，所以和if條件無關print('我是無論條件是否成立都要執(zhí)行的代碼')2.2 簡單版：網(wǎng)吧上網(wǎng)
需求分析：如果用戶年齡大于等于18歲，即成年，輸出"已經(jīng)成年，可以上網(wǎng)"。
age = 20if age >= 18: print('已經(jīng)成年，可以上網(wǎng)')print('系統(tǒng)關閉')2.3 進階版：網(wǎng)吧上網(wǎng)
新增需求：用戶可以輸出自己的年齡，然后系統(tǒng)進行判斷是否成年，成年則輸出"您的年齡是’用戶輸入的年齡’，已經(jīng)成年，可以上網(wǎng)"。
# input接受用戶輸入的數(shù)據(jù)是字符串類型，條件是age和整型18做判斷，所以這里要int轉換數(shù)據(jù)類型age = int(input('請輸入您的年齡：'))if age >= 18: print(f'您的年齡是{age},已經(jīng)成年，可以上網(wǎng)')print('系統(tǒng)關閉')3. if…else…
作用：條件成立執(zhí)行if下方的代碼; 條件不成立執(zhí)行else下方的代碼。
if 條件: 條件成立執(zhí)行的代碼1 條件成立執(zhí)行的代碼2 ......else: 條件不成立執(zhí)行的代碼1 條件不成立執(zhí)行的代碼2????......思考：網(wǎng)吧上網(wǎng)的實例，如果成年，允許上網(wǎng)，如果不成年呢？是不是應該回復用戶不能上網(wǎng)？
3.1 實用版：網(wǎng)吧上網(wǎng)
age = int(input('請輸入您的年齡：'))if age >= 18: print(f'您的年齡是{age},已經(jīng)成年，可以上網(wǎng)')else: print(f'您的年齡是{age},未成年，請自行回家寫作業(yè)')print('系統(tǒng)關閉')注意：如果條件成立執(zhí)行了某些代碼，那么其他的情況的代碼將不會執(zhí)行。
4. 多重判斷
if 條件1: 條件1成立執(zhí)行的代碼1 條件1成立執(zhí)行的代碼2 ......elif 條件2： 條件2成立執(zhí)行的代碼1 條件2成立執(zhí)行的代碼2 ............else:????以上條件都不成立執(zhí)行執(zhí)行的代碼多重判斷也可以和else配合使用。一般else放在整個if語句的最后，表示以上條件都不成立的時候執(zhí)行的代碼。
思考：中國合法工作年齡為18-60歲，即如果年齡小于18的情況為童工，不合法；如果年齡在18-60歲之間為合法工齡；大于60歲為法定退休年齡。
4.1 實例：工齡判斷
age = int(input('請輸入您的年齡：'))if age < 18: print(f'您的年齡是{age},童工一枚')elif (age >= 18) and (age <= 60): print(f'您的年齡是{age},合法工齡')elif age > 60:????print(f'您的年齡是{age},可以退休')拓展：age >= 18 and age <= 60可以化簡為18 <= age <= 60。
5. if嵌套
if 條件1： 條件1成立執(zhí)行的代碼 條件1成立執(zhí)行的代碼 if 條件2： 條件2成立執(zhí)行的代碼????????條件2成立執(zhí)行的代碼注意：條件2的if也是出于條件1的縮進關系內部。
思考：坐公交：如果有錢可以上車，沒錢不能上車；上車后如果有空座，則可以坐下；如果沒空座，就要站著。怎么書寫程序？
5.1 實例：坐公交
1.判斷是否能上車
""" 1. 如果有錢，則可以上車 2. 上車后，如果有空座，可以坐下 上車后，如果沒有空座，則站著等空座位 如果沒錢，不能上車"""# 假設用 money = 1 表示有錢, money = 0表示沒有錢money = 1if money == 1: print('土豪，不差錢，順利上車')else:????print('沒錢，不能上車，追著公交車跑')2. 判斷是否能坐下
""" 1. 如果有錢，則可以上車 2. 上車后，如果有空座，可以坐下 上車后，如果沒有空座，則站著等空座位 如果沒錢，不能上車"""# 假設用 money = 1 表示有錢, money = 0表示沒有錢; seat = 1 表示有空座，seat = 0 表示沒有空座money = 1seat = 0if money == 1: print('土豪，不差錢，順利上車') if seat == 1: print('有空座，可以坐下') else: print('沒有空座，站等')else:????print('沒錢，不能上車，追著公交車跑')5.2 if嵌套執(zhí)行流程
6. 應用：猜拳游戲
需求分析：
參與游戲的角色
隨機出拳
手動出拳
玩家
電腦
判斷輸贏
玩家電腦 石頭 剪刀 剪刀 布 布 石頭 玩家出拳 和 電腦出拳相同
平局
電腦獲勝
玩家獲勝
隨機做法：
1.導出random模塊
import?模塊名2. 使用random模塊中的隨機整數(shù)功能
random.randint(開始,結束)6.1 初始版：猜拳游戲
"""提示：0-石頭，1-剪刀，2-布3. 出拳玩家輸入出拳電腦隨機出拳4. 判斷輸贏玩家獲勝平局電腦獲勝"""# 導入random模塊import random# 計算電腦出拳的隨機數(shù)字computer = random.randint(0, 2)print(computer)player = int(input('請出拳：0-石頭，1-剪刀，2-布：'))# 玩家勝利 p0:c1 或 p1:c2 或 p2:c0if (player == 0 and computer == 1) or (player == 1 and computer == 2) or (player == 2 and computer == 0): print('玩家獲勝')# 平局：玩家 == 電腦elif player == computer: print('平局')else:????print('電腦獲勝')6.2 進階版：猜拳游戲
"""石頭剪刀布游戲玩家VS電腦站在玩家的角度，分析勝利、失敗、平局0-石頭，1-剪刀，2-布"""# 導入隨機數(shù)模塊import randomimport sysprint("-----歡迎來到人機對戰(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("游戲結束……") 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("機器輸入%d，您贏了！" % comp) elif user == comp: print("機器輸入%d，平局了！" % comp) else: print("機器輸入%d，您輸了！" % comp) res = input("重新游戲請輸入X，退出游戲按任意鍵") if res == "X" or res == "x": return else: sys.exit(0)while True: user = int(input("請您出拳，輸入相應數(shù)字！")) if user == 0 or user == 1 or user == 2: comp = random.randint(0, 2) Game(user, comp) else: print("輸入數(shù)字有誤，請確認后，重新輸入！")7. 三目運算符
三目運算符也叫三元運算符。
語法如下：
值1?if?條件?else?值2快速體驗：
a = 1b = 2c = a if a > b else bprint(c)十二、循環(huán)簡介
1. 循環(huán)的作用
讓代碼更高效的重復執(zhí)行。
2. 循環(huán)的分類
在Python中，循環(huán)分為while和for兩種，最終實現(xiàn)效果相同。
3. while的語法
while 條件: 條件成立重復執(zhí)行的代碼1 條件成立重復執(zhí)行的代碼2????......4. while循環(huán)快速體驗
需求：復現(xiàn)重復執(zhí)行10次print('Hello World')。
分析：初始值是0次，終點是10次，重復做的事情輸出“Hello World”。
# 循環(huán)的計數(shù)器i = 0while i < 10: print('Hello World') i += 1print('任務結束')5. while的應用
5.1 應用一：計算1-100累加和
分析：1-100的累加和，即1 + 2 + 3 + 4 +….，即前兩個數(shù)字的相加結果 + 下一個數(shù)字( 前一個數(shù)字 + 1)。
i = 1result = 0while i <= 100: result += i i += 1# 輸出5050print(result)注意：為了驗證程序的準確性，可以先改小數(shù)值，驗證結果正確后，再改成1-100做累加。
5.2 應用二：計算1-100偶數(shù)累加和
分析：1-100的偶數(shù)和，即 2 + 4 + 6 + 8…，得到偶數(shù)的方法如下：
偶數(shù)即是和2取余結果為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)方法二：計數(shù)器控制
# 方法二：計數(shù)器控制增量為2i = 0result = 0while i <= 100: result += i i += 2# 輸出2550print(result)6. break和continue
break和continue是循環(huán)中滿足一定條件退出循環(huán)的兩種不同方式。
6.1 理解
舉例：一共吃5個蘋果，吃完第一個，吃第二個…，這里"吃蘋果"的動作是不是重復執(zhí)行？
情況一：如果吃的過程中，吃完第三個吃飽了，則不需要再吃第4個和第五個蘋果，即是吃蘋果的動作停止，這里就是break控制循環(huán)流程，即終止此循環(huán)。
情況二：如果吃的過程中，吃到第三個吃出一個大蟲子…,是不是這個蘋果就不吃了，開始吃第四個蘋果，這里就是continue控制循環(huán)流程，即退出當前一次循環(huán)繼而執(zhí)行下一次循環(huán)代碼。
6.2 break實例
i = 1while i <= 5: if i == 4: print(f'吃飽了不吃了') break print(f'吃了第{i}個蘋果')????i?+=?16.3 continue實例
i = 1while i <= 5: if i == 3: print(f'大蟲子，第{i}個不吃了') # 在continue之前一定要修改計數(shù)器，否則會陷入死循環(huán) i += 1 continue print(f'吃了第{i}個蘋果')????i?+=?17. while循環(huán)嵌套
7.1 語法
while 條件1: 條件1成立執(zhí)行的代碼 ...... while 條件2: 條件2成立執(zhí)行的代碼????????......總結：所謂while循環(huán)嵌套，就是一個while里面嵌套一個while的寫法，每個while和之前的基礎語法是相同的。
7.2 執(zhí)行過程
當內部循環(huán)執(zhí)行完成之后，再執(zhí)行下一次外部循環(huán)的條件判斷。
7.3 while循環(huán)嵌套應用
應用一：打印星號(正方形)
# 重復打印5行星星j = 0while j <= 4: # 一行星星的打印 i = 0 while i <= 4: # 一行內的星星不能換行，取消print默認結束符\n print('*', end='') i += 1 # 每行結束要換行，這里借助一個空的print，利用print默認結束符換行 print()????j?+=?1應用二：打印星號(三角形)
# 重復打印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應用二：九九乘法表
# 重復打印9行表達式j = 1while j <= 9: # 打印一行里面的表達式 a * b = a*b i = 1 while i <= j: print(f'{i}*{j}={j*i}', end='\t') i += 1 print()????j?+=?18. for循環(huán)
8.1 語法
for 臨時變量 in 序列: 重復執(zhí)行的代碼1 重復執(zhí)行的代碼2????......8.2 快速體驗
str1 = 'Hello World'for i in str1:????print(i)8.3 break
str1 = 'Hello World'for i in str1: if i == 'e': print('遇到e不打印') break????print(i)8.4 continue
str1 = 'Hello World'for i in str1: if i == 'e': print('遇到e不打印') continue????print(i)十三、else
循環(huán)可以和else配合使用，else下方縮進的代碼指的是當循環(huán)正常結束之后要執(zhí)行的代碼。
1. while…else
1.1 語法
while 條件: 條件成立重復執(zhí)行的代碼else:????循環(huán)正常結束之后要執(zhí)行的代碼1.2 示例
i = 1while i <= 5: print('Hello World') i += 1else:????print('執(zhí)行完畢')1.3 退出循環(huán)的方式
1.break終止循環(huán)
i = 1while i <= 5: if i == 3: print("提前結束") break print('Hello World') i += 1else:????print('執(zhí)行完畢')所謂else指的是循環(huán)正常結束之后要執(zhí)行的代碼，即如果是break終止循環(huán)的情況，else下方縮進的代碼將不執(zhí)行。
2.continue控制循環(huán)
i = 1while i <= 5: if i == 3: print("打斷一下") i += 1 continue print('Hello World') i += 1else:????print('執(zhí)行完畢')因為continue是退出當前一次循環(huán)，繼續(xù)下一次循環(huán)，所以該循環(huán)在continue控制下是可以正常結束的，當循環(huán)結束后，則執(zhí)行了else縮進的代碼。
2. for…else
2.1 語法
for 臨時變量 in 序列: 重復執(zhí)行的代碼 ...else:????循環(huán)正常結束之后要執(zhí)行的代碼所謂else指的是循環(huán)正常結束之后要執(zhí)行的代碼，即如果是break終止循環(huán)的情況，else下方縮進的代碼將不執(zhí)行。
2.2 示例
str1 = 'Hello World'for i in str1: print(i)else:????print('循環(huán)正常結束之后執(zhí)行的代碼')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)正常結束之后執(zhí)行的代碼')沒有執(zhí)行else縮進的代碼。
2.continue控制循環(huán)
str1 = 'Hello World'for i in str1: if i == 'e': print('遇到e不打印') continue print(i)else:????print('循環(huán)正常結束之后執(zhí)行的代碼')因為continue是退出當前一次循環(huán)，繼續(xù)下一次循環(huán)，所以該循環(huán)在continue控制下是可以正常結束的，當循環(huán)結束后，則執(zhí)行了else縮進的代碼。
十四、字符串
1. 認識字符串
字符串是 Python 中最常用的數(shù)據(jù)類型。我們一般使用引號來創(chuàng)建字符串。創(chuàng)建字符串很簡單，只要為變量分配一個值即可。
a = 'hello world'b = "abcdefg"print(type(a))print(type(b))注意：控制臺顯示結果為， 即數(shù)據(jù)類型為str(字符串)。
2. 字符串特征
一對引號字符串
三引號字符串
注意：三引號形式的字符串支持換行。
思考：如果創(chuàng)建一個字符串I'm Tom?
c = "I'm Tom"d?=?'I\'m?Tom'3. 字符串輸出
print('hello world')name = 'Tom'print('我的名字是%s' % name)print(f'我的名字是{name}')4. 字符串輸入
在Python中，使用input()接收用戶輸入。
name = input('請輸入您的名字：')print(f'您輸入的名字是{name}')print(type(name))password = input('請輸入您的密碼：')print(f'您輸入的密碼是{password}')print(type(password))5. 下標
5.1 概念
“下標”又叫“索引”，就是編號。比如火車座位號，座位號的作用：按照編號快速找到對應的座位。同理，下標的作用即是通過下標快速找到對應的數(shù)據(jù)。
5.2 快速體驗
需求：字符串name = "abcdef"，取到不同下標對應的數(shù)據(jù)。
代碼
輸出結果
注意：下標從0開始。
6. 切片
切片是指對操作的對象截取其中一部分的操作。字符串、列表、元組都支持切片操作。
6.1 語法
序列[開始位置下標:結束位置下標:步長]注意：
不包含結束位置下標對應的數(shù)據(jù)， 正負整數(shù)均可；
步長是選取間隔，正負整數(shù)均可，默認步長為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, 負1表示倒數(shù)第一個數(shù)據(jù)print(name[-4:-1]) # defprint(name[::-1])??#?gfedcba7. 常用操作方法
字符串的常用操作方法有查找、修改和判斷三大類。
7.1 查找
所謂字符串查找方法即是查找子串在字符串中的位置或出現(xiàn)的次數(shù)。
find()：檢測某個子串是否包含在這個字符串中，如果在返回這個子串開始的位置下標，否則則返回-1。
語法
注意：開始和結束位置下標可以省略，表示在整個字符串序列中查找。
快速體驗
index()：檢測某個子串是否包含在這個字符串中，如果在返回這個子串開始的位置下標，否則則報異常。
語法
注意：開始和結束位置下標可以省略，表示在整個字符串序列中查找。
快速體驗
rfind()：和find()功能相同，但查找方向為
右側開始。
rindex()：和index()功能相同，但查找方向為
右側開始。
count()：返回某個子串在字符串中出現(xiàn)的次數(shù)。
語法
注意：開始和結束位置下標可以省略，表示在整個字符串序列中查找。
快速體驗
7.2 修改
所謂修改字符串，指的就是通過函數(shù)的形式修改字符串中的數(shù)據(jù)。
replace()：替換字符串。
語法
注意：替換次數(shù)如果查出子串出現(xiàn)次數(shù)，則替換次數(shù)為該子串出現(xiàn)次數(shù)。
快速體驗
注意：數(shù)據(jù)按照是否能直接修改分為可變類型和不可變類型兩種。字符串類型的數(shù)據(jù)修改的時候不能改變原有字符串，屬于不能直接修改數(shù)據(jù)的類型即是不可變類型。
split()：按照指定字符分割字符串。
語法
注意：num表示的是分割字符出現(xiàn)的次數(shù)，即將來返回數(shù)據(jù)個數(shù)為num+1個。
快速體驗
注意：如果分割字符是原有字符串中的子串，分割后則丟失該子串。
join()：用一個字符或子串合并字符串，即是將多個字符串合并為一個新的字符串。
1.語法
字符或子串.join(多字符串組成的序列)2. 快速體驗
list1 = ['hello', 'buran', 'list']t1 = ('aa', 'b', 'cc', 'ddd')print('_'.join(list1))# hello_buran_listprint('...'.join(t1))#?結果：aa...b...cc...dddcapitalize()：將字符串第一個字符轉換成大寫。
mystr = "hello world and buran and list and Python"print(mystr.capitalize())#?結果：Hello world and?buran?and?list?and?python注意：capitalize()函數(shù)轉換后，只字符串第一個字符大寫，其他的字符全都小寫。
title()：將字符串每個單詞首字母轉換成大寫。
lower()：將字符串中大寫轉小寫。
upper()：將字符串中小寫轉大寫。
lstrip()：刪除字符串左側空白字符。
rstrip()：刪除字符串右側空白字符。
strip()：刪除字符串兩側空白字符。
ljust()：返回一個原字符串左對齊,并使用指定字符(默認空格)填充至對應長度 的新字符串。
rjust()：返回一個原字符串右對齊,并使用指定字符(默認空格)填充至對應長度 的新字符串，語法和ljust()相同。
center()：返回一個原字符串居中對齊,并使用指定字符(默認空格)填充至對應長度 的新字符串，語法和ljust()相同。
7.3 判斷
所謂判斷即是判斷真假，返回的結果是布爾型數(shù)據(jù)類型：True 或 False。
startswith()：檢查字符串是否是以指定子串開頭，是則返回 True，否則返回 False。如果設置開始和結束位置下標，則在指定范圍內檢查。
語法
快速體驗
endswith()：：檢查字符串是否是以指定子串結尾，是則返回 True，否則返回 False。如果設置開始和結束位置下標，則在指定范圍內檢查。
語法
快速體驗
isalpha()：如果字符串至少有一個字符并且所有字符都是字母則返回 True, 否則返回 False。
isdigit()：如果字符串只包含數(shù)字則返回 True 否則返回 False。
isalnum()：如果字符串至少有一個字符并且所有字符都是字母或數(shù)字則返 回 True,否則返回 False。
isspace()：如果字符串中只包含空白，則返回 True，否則返回 False。
十五、列表
1. 列表的格式
[數(shù)據(jù)1,?數(shù)據(jù)2,?數(shù)據(jù)3,?數(shù)據(jù)4......]列表可以一次性有序存儲多個不同類型的數(shù)據(jù)。
2. 列表的常用操作
列表的作用是一次性存儲多個數(shù)據(jù)，程序員可以對這些數(shù)據(jù)進行的操作有：增、刪、改、查。
2.1 查找
下標
函數(shù)
index()：返回指定數(shù)據(jù)所在位置的下標 。
注意：如果查找的數(shù)據(jù)不存在則報錯。
count()：統(tǒng)計指定數(shù)據(jù)在當前列表中出現(xiàn)的次數(shù)。
len()：訪問列表長度，即列表中數(shù)據(jù)的個數(shù)。
2.2 判斷是否存在
in：判斷指定數(shù)據(jù)在某個列表序列，如果在返回True，否則返回False。
not in：判斷指定數(shù)據(jù)不在某個列表序列，如果不在返回True，否則返回False。
2.2 增加
作用：增加指定數(shù)據(jù)到列表中。
append()：列表結尾追加數(shù)據(jù)。
列表追加數(shù)據(jù)的時候，直接在原列表里面追加了指定數(shù)據(jù)，即修改了原列表，故列表為可變類型數(shù)據(jù)。
注意點：如果append()追加的數(shù)據(jù)是一個序列，則追加整個序列到列表。
name_list = ['Tom', 'Lily', 'Rose']name_list.append(['xiaoming', 'xiaohong'])# 結果：['Tom', 'Lily', 'Rose', ['xiaoming', 'xiaohong']]print(name_list)extend()：列表結尾追加數(shù)據(jù)，如果數(shù)據(jù)是一個序列，則將這個序列的數(shù)據(jù)逐一添加到列表。
單個數(shù)據(jù)：
name_list = ['Tom', 'Lily', 'Rose']name_list.extend('xiaoming')# 結果：['Tom', 'Lily', 'Rose', 'x', 'i', 'a', 'o', 'm', 'i', 'n', 'g']print(name_list)序列數(shù)據(jù)：
name_list = ['Tom', 'Lily', 'Rose']name_list.extend(['xiaoming', 'xiaohong'])# 結果：['Tom', 'Lily', 'Rose', 'xiaoming', 'xiaohong']print(name_list)insert()：指定位置新增數(shù)據(jù)。
列表序列.insert(位置下標,?數(shù)據(jù))name_list = ['Tom', 'Lily', 'Rose']name_list.insert(1, 'xiaoming')# 結果：['Tom', 'xiaoming', 'Lily', 'Rose']print(name_list)2.3 刪除
del
刪除列表：
name_list = ['Tom', 'Lily', 'Rose']# 結果：報錯提示：name 'name_list' is not defineddel name_listprint(name_list)刪除指定數(shù)據(jù)：
name_list = ['Tom', 'Lily', 'Rose']del name_list[0]# 結果：['Lily', 'Rose']print(name_list)pop()：刪除指定下標的數(shù)據(jù)(默認為最后一個)，并返回該數(shù)據(jù)。
remove()：移除列表中某個數(shù)據(jù)的第一個匹配項。
clear()：清空列表
2.4 修改
修改指定下標數(shù)據(jù)
逆置：reverse()
排序：sort()
注意：reverse表示排序規(guī)則，reverse = True?降序，?reverse = False?升序(默認)
2.5 復制
函數(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?+=?13.2 for
name_list = ['Tom', 'Lily', 'Rose']for i in name_list:????print(i)4. 列表嵌套
所謂列表嵌套指的就是一個列表里面包含了其他的子列表。
應用場景：要存儲班級一、二、三三個班級學生姓名，且每個班級的學生姓名在一個列表。
name_list?=?[['小明',?'小紅',?'小綠'],?['Tom',?'Lily',?'Rose'],?['張三',?'李四',?'王五']]思考：如何查找到數(shù)據(jù)"李四"？
# 第一步：按下標查找到李四所在的列表print(name_list[2])# 第二步：從李四所在的列表里面，再按下標找到數(shù)據(jù)李四print(name_list[2][1])十六、元組
一個元組可以存儲多個數(shù)據(jù)，元組內的數(shù)據(jù)是不能修改的。
1. 定義元組
元組特點：定義元組使用小括號，且逗號隔開各個數(shù)據(jù)，數(shù)據(jù)可以是不同的數(shù)據(jù)類型。
# 多個數(shù)據(jù)元組t1 = (10, 20, 30)# 單個數(shù)據(jù)元組t2?=?(10,)注意：如果定義的元組只有一個數(shù)據(jù)，那么這個數(shù)據(jù)后面也好添加逗號，否則數(shù)據(jù)類型為唯一的這個數(shù)據(jù)的數(shù)據(jù)類型。
t2 = (10,)print(type(t2)) # tuplet3 = (20)print(type(t3)) # intt4 = ('hello')print(type(t4))??#?str2. 元組的常見操作
元組數(shù)據(jù)不支持修改，只支持查找，具體如下：
按下標查找數(shù)據(jù)
index()：查找某個數(shù)據(jù)，如果數(shù)據(jù)存在返回對應的下標，否則報錯，語法和列表、字符串的index方法相同。
count()：統(tǒng)計某個數(shù)據(jù)在當前元組出現(xiàn)的次數(shù)。
len()：統(tǒng)計元組中數(shù)據(jù)的個數(shù)。
3. 元組的注意事項
元組內的直接數(shù)據(jù)如果修改則立即報錯。
tuple1 = ('aa', 'bb', 'cc', 'bb')tuple1[0]?=?'aaa'但是如果元組里面有列表，修改列表里面的數(shù)據(jù)則是支持的，故自覺很重要。
tuple2 = (10, 20, ['aa', 'bb', 'cc'], 50, 30)print(tuple2[2]) # 訪問到列表# 結果：(10, 20, ['aaaaa', 'bb', 'cc'], 50, 30)tuple2[2][0] = 'aaaaa'print(tuple2)十七、字典
字典里面的數(shù)據(jù)是以“鍵值對”形式出現(xiàn)，字典數(shù)據(jù)和數(shù)據(jù)順序沒有關系，即字典不支持下標，后期無論數(shù)據(jù)如何變化，只需要按照對應的鍵的名字查找數(shù)據(jù)即可。
1. 創(chuàng)建字典的語法
字典特點：
符號為
大括號數(shù)據(jù)為
鍵值對形式出現(xiàn)
各個鍵值對之間用
逗號隔開
注意：一般稱冒號前面的為鍵(key)，簡稱k；冒號后面的為值(value)，簡稱v。
2. 字典常見操作
2.1 增
寫法：字典序列[key] = 值
注意：如果key存在則修改這個key對應的值；如果key不存在則新增此鍵值對。
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}dict1['name'] = 'Rose'# 結果：{'name': 'Rose', 'age': 20, 'gender': '男'}print(dict1)dict1['id'] = 110# {'name': 'Rose', 'age': 20, 'gender': '男', 'id': 110}print(dict1)注意：字典為可變類型。
2.2 刪
del() / del：刪除字典或刪除字典中指定鍵值對。
clear()：清空字典
2.3 改
寫法：字典序列[key] = 值
注意：如果key存在則修改這個key對應的值 ；如果key不存在則新增此鍵值對。
2.4 查
key值查找
如果當前查找的key存在，則返回對應的值；否則則報錯。
get()
注意：如果當前查找的key不存在則返回第二個參數(shù)(默認值)，如果省略第二個參數(shù)，則返回None。
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}print(dict1.get('name')) # Tomprint(dict1.get('id', 110)) # 110print(dict1.get('id'))??#?Nonekeys()
values()
items()
3. 字典的循環(huán)遍歷
3.1 遍歷字典的key
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}for key in dict1.keys():????print(key)3.2 遍歷字典的value
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}for value in dict1.values():????print(value)3.3 遍歷字典的元素
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}for item in dict1.items():????print(item)3.4 遍歷字典的鍵值對
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}for key, value in dict1.items():????print(f'{key}?=?{value}')十八、集合
集合具有確定性，無序性和去重性。
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特點：
集合可以去掉重復數(shù)據(jù)；
集合數(shù)據(jù)是無序的，故不支持下標。
2. 集合常見操作方法
2.1 增加數(shù)據(jù)
add()
因為集合有去重功能，所以，當向集合內追加的數(shù)據(jù)是當前集合已有數(shù)據(jù)的話，則不進行任何操作。
update(), 追加的數(shù)據(jù)是序列。
2.2 刪除數(shù)據(jù)
remove()，刪除集合中的指定數(shù)據(jù)，如果數(shù)據(jù)不存在則報錯。
discard()，刪除集合中的指定數(shù)據(jù)，如果數(shù)據(jù)不存在也不會報錯。
pop()，隨機刪除集合中的某個數(shù)據(jù)，并返回這個數(shù)據(jù)。
2.3 查找數(shù)據(jù)
in：判斷數(shù)據(jù)在集合序列
not in：判斷數(shù)據(jù)不在集合序列
十九、公共操作
1. 運算符
1.1 +
# 1. 字符串 str1 = 'aa'str2 = 'bb'str3 = str1 + str2print(str3) # aabb# 2. 列表 list1 = [1, 2]list2 = [10, 20]list3 = list1 + list2print(list3) # [1, 2, 10, 20]# 3. 元組 t1 = (1, 2)t2 = (10, 20)t3 = t1 + t2print(t3)??#?(10,?20,?100,?200)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.3 in或not in
# 1. 字符串print('a' in 'abcd') # Trueprint('a' not in 'abcd') # False# 2. 列表list1 = ['a', 'b', 'c', 'd']print('a' in list1) # Trueprint('a' not in list1) # False# 3. 元組t1 = ('a', 'b', 'c', 'd')print('aa' in t1) # Falseprint('aa'?not?in?t1)??#?True2. 公共方法
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))??#?22.2 del()
# 1. 字符串str1 = 'abcdefg'del str1print(str1)# 2. 列表list1 = [10, 20, 30, 40]del(list1[0])print(list1)??#?[20,?30,?40]2.3 max()
# 1. 字符串str1 = 'abcdefg'print(max(str1)) # g# 2. 列表list1 = [10, 20, 30, 40]print(max(list1))??#?402.4 min()
# 1. 字符串str1 = 'abcdefg'print(min(str1)) # a# 2. 列表list1 = [10, 20, 30, 40]print(min(list1))??#?102.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)注意：range()生成的序列不包含end數(shù)字。
2.6 enumerate()
enumerate(可遍歷對象,?start=0)注意：start參數(shù)用來設置遍歷數(shù)據(jù)的下標的起始值，默認為0。
list1 = ['a', 'b', 'c', 'd', 'e']for i in enumerate(list1): print(i)for index, char in enumerate(list1, start=1):????print(f'下標是{index},?對應的字符是{char}')3. 容器類型轉換
3.1 tuple()
作用：將某個序列轉換成元組。
list1 = [10, 20, 30, 40, 50, 20]s1 = {100, 200, 300, 400, 500}print(tuple(list1))print(tuple(s1))3.2 list()
作用：將某個序列轉換成列表。
t1 = ('a', 'b', 'c', 'd', 'e')s1 = {100, 200, 300, 400, 500}print(list(t1))print(list(s1))3.3 set()
作用：將某個序列轉換成集合。
list1 = [10, 20, 30, 40, 50, 20]t1 = ('a', 'b', 'c', 'd', 'e')print(set(list1))print(set(t1))注意：
集合可以快速完成列表去重。
集合不支持下標。
二十、推導式
1. 列表推導式
作用：用一個表達式創(chuàng)建一個有規(guī)律的列表或控制一個有規(guī)律列表。
列表推導式又叫列表生成式。
1.1 快速體驗
需求：創(chuàng)建一個0-10的列表。
while循環(huán)實現(xiàn)
for循環(huán)實現(xiàn)
列表推導式實現(xiàn)
1.2 帶if的列表推導式
需求：創(chuàng)建0-10的偶數(shù)列表
方法一：range()步長實現(xiàn)
1.3 多個for循環(huán)實現(xiàn)列表推導式
需求：創(chuàng)建列表如下：
[(1,?0),?(1,?1),?(1,?2),?(2,?0),?(2,?1),?(2,?2)]代碼如下：
2. 字典推導式
字典推導式作用：快速合并列表為字典或提取字典中目標數(shù)據(jù)。
2.1 快速體驗
創(chuàng)建一個字典：字典key是1-5數(shù)字，value是這個數(shù)字的2次方。
將兩個列表合并為一個字典
提取字典中目標數(shù)據(jù)
3. 集合推導式
需求：創(chuàng)建一個集合，數(shù)據(jù)為下方列表的2次方。
list1?=?[1,?1,?2]代碼如下：
list1 = [1, 1, 2]set1 = {i ** 2 for i in list1}print(set1)??#?{1,?4}注意：集合有數(shù)據(jù)去重功能。
總結
以上是生活随笔為你收集整理的python中print的本质_Python基础语法全解的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： uniapp中使用picker_unia
- 下一篇： python字符串类型_python字符