万字【Python基础】保姆式教学，零基础快速入门Python
前言
又是爆肝干文的日子，繼上次說要出一期Python新手入門教程系列文章后，就在不停地整理和碼字，終于是把【基礎入門】這一塊給寫出來了。
高級編程的【正則表達式】和【面向對象編程】內容我在之前已經出過了，感興趣可以去看看我的專欄，今天的內容是【基礎入門】。
【Python新手入門教程專欄】
不積跬步無以至千里，不積小流無以成江海，一個一個板塊的知識積累，早晚你也會成為你羨慕的那種人，接下來就是正式的內容了。
今日內容預覽
文章目錄
-
- 前言
- 今日內容預覽
-
- 一、初識Python
-
- 1.什么是Python
- 2.Python 的歷史
- 3. Python的特點
- 4.Python 運行機制
- 5.軟件安裝
-
- （1）Python的安裝步驟
- （2）Pycharm
- 6.你的第一行代碼
- 二、基礎知識
-
-
- 1.輸入輸出
- 2.變量
- 3.數據類型
- 4.表達式
- 5.運算符
-
- 三、流程控制
-
-
- 1.條件分支流程
- 2.循環流程
-
- 四、列表(List)
-
-
- 1.列表的創建
- 2.添加元素
- 3.刪除元素
- 4. 修改元素
- 5.列表高級特性的
-
- 五、元組（tuple）
-
-
- 1.元組的創建及訪問
- 2.修改和刪除
- 3.元組的操作符
- 4.元組的方法
-
- 六、字符串
-
-
- 1.字符串的特點
- 2.字符串的方法
- 3.格式化輸出
- 4.轉義字符
-
- 七、字典（dict）
-
-
- 1.字典的特點
- 2.創建字典
- 3.字典訪問的
- 4.字典的方法
- 5.補充
-
- 八、函數
-
-
- 1.創建和使用
- 2.函數的運行機制
- 3.函數的使用
- 4.函數的特點
- 5.函數的參數
- 6.函數的文檔
- 7.函數的返回值
- 8.函數的變量的作用域
- 9.內嵌函數
- 10.閉包
- 11. lambda表達式
-
- 九、綜合性練手項目
-
-
- （一）系統需求
- （二）效果預覽
-
一、初識Python
1.什么是Python
Python是1門程序設計語言。在開發者眼里，語言可以分為3類：
- 自然語言：人能聽懂的語言，例如漢語，英語，法語等等。
- 機器語言：機器能聽懂的語言，機器只能聽懂0和1。
- 程序設計語言：機器能夠聽懂，人能聽懂的語言，例如Python，C，C++ 、C# 、Java等等。
同樣的，在開發者眼里還可以分為高級程序設計語言和低級程序設計語言。越接近于人類的語言越高級
，例如Python；越接近于機器語言越低級，例如匯編就屬于低級程序員設計語言。
2.Python 的歷史
喝水不忘挖井人，在正式學習Python之前我們很有必要了解一下Python的過去和大家的祖師爺。
Python是1989年由Guido van Rossum 在圣誕節期間創建的，國內程序員比較喜歡簡單但的名字，所以
取他名字的前三個字母gui，人送外號龜叔。Python名字的由來也是源于龜叔的喜好，因為當時的龜叔比較喜歡《蒙提·派森的飛行馬戲團》這個小品，所以就把他創建的這門語言叫做Python。
龜叔今年才65歲，頭發還是很多的，所以學Python的小伙伴也不用太擔心禿頭。龜叔我記得去年時候還加入了微軟的開發部，一把年紀了還在一線寫代碼，著實讓人佩服。
我私藏了很多技術干貨，粉絲可白嫖（點這里）
3. Python的特點
Python的特點主要有語法簡潔、類庫強大、膠水語言（調用其他語言的類庫）、代碼量較少等特點，這個簡單了解一下就可以了，后面用到了你就會明白的。
（誰用誰知道）
4.Python 運行機制
程序運行主要有兩種機制：編譯型和解釋型。編譯型是將代碼（源文件）通過編譯器，編譯成機器碼文件，當運行的時候直接執行機器碼文件，例如C語言；解釋型是將源文件通過解釋器，逐行進行翻譯并運行。
Python則屬于解釋型的語言。
編譯型和解釋型語言各有優缺點：
- 解釋型：
缺點：執行慢
優點：可以跨平臺（操作系統）
- 編譯型：
缺點：不能跨平臺
優點：執行快
5.軟件安裝
新手學Python我建議裝一下Python和Pycharm，在以后寫代碼的時候會經常用到這兩款軟件，這兩款軟件都可以在官網下載，如果你不想去官網下載，我這邊也有下好的安裝包，自取之后按照安裝流程開始即可。
軟件包下載鏈接：https://pan.baidu.com/s/1BtnMGsfYNFIkmJ26wuGjCw
提取碼：al6e
（1）Python的安裝步驟
Python的安裝可以去官網直接下載，由于是國外的網站，可能響應和下載速度都會有點慢，如果你不著急就等著就行，想快一點的話用迅雷來下載就很快。
- 下載Python
下載地址是 ttps://www.python.org/downloads/ ，也可以從官網點Downloads 進入下載頁面，選擇你的電腦對應的版本，我的是Windows電腦，所以就直接點擊 Windows 。
Python目前是出到了3.9.7版本，你可以看到有很多版本的選擇可下載，我用的是3.9.5這個版本，然后根據電腦挑選型號，我的電腦是64位的，所以就下載64位的軟件。
- 安裝Python
雙擊下載好的文件，進入安裝界面。
選擇自定義安裝，把兩個選擇都勾選就能將Python安裝到PATH中。
這個界面不變動，直接點 Next 。
選擇一個你要安裝的路徑，不然它會把你裝到C盤，我把它安裝到了D盤，然后點擊 Install 。
安裝完成，點擊 Close 。
- Python測試
測試一下你的Python是否安裝成功，WIN + R 鍵調出命令窗口，輸入 cmd 。
在黑窗口輸入 Python ,然后回車，如果提示Python 3.9.6 等信息就說明已經安裝成功了，如果沒有提示，那就回去看看哪個環境你出錯了。
（2）Pycharm
Pycharm官網下載，選擇一下系統，我是Windows系統所以默認不變，然后下載社區版的就可以了，等你變強大以后再用專業版的。
下載好之后，雙擊開始安裝。
點擊Next 。
自定義安裝路徑，建議裝在C盤之外的其他盤，點擊 Next 。
全部都勾選。
到了這里之后，默認即可，點擊 Install 開始安裝。
等待安裝按成后，點擊finish就裝好了。
我私藏了很多技術干貨，粉絲可白嫖（點這里）
6.你的第一行代碼
萬事俱備，接下來我們開始寫我們的第一行代碼，鼎鼎大名的 hello world 。
打開Pycharm，點擊New Project 創建新項目，以后新建項目都可以這么操作，中間的Open 是打開項目，如果你有寫好的項目就可以從這里打開。
接下就是設置一下項目的存在位置，如果你的安裝Pycharm的時候是按照我的步驟來的，Base interpreter 那里會自動檢測出來Python，可以不做改到，直接點擊左下角的Create 創建就可以了。
然后點擊左邊的。
進入頁面會彈出一個彈框，點擊Close關閉就行。
前面我們創建的是項目，是一個文件夾，來存放源碼的，這里我們開始創建代碼源文件。（我的電腦之前有過一些項目，所以底下有很多文件夾，可能跟你們不太一樣。）
點擊在創建好的項目python_learn，郵件彈出選項，選擇New 來新建，選擇Python File ，即創建Python源文件。
然后會提示你給你的文件取個名字，然后敲一下回車就完成了代碼源文件的創建了。
開始寫代碼，這里需要用到的1個最常用的函數print() ，它是用來專門輸出內容的，函數有它的語法，只要遵循語法來寫代碼，軟件才會知道你要干什么。
print的語法如下，默認自帶換行。
print(要輸出的內容)
接下來我們就是要輸出我們第一行代碼了，hello world 是1串字符串，需要加上" "才是正確的格式，不然會報錯，關于字符串在后面我們會詳細來講，這里你只要知道得按照這個格式寫代碼才能達到我們想要的結果。
print("hello world")
寫完代碼之后需要運行才出結果，可以右鍵彈出選項框，選擇 Run’learn_1’ 開始運行，Run是運行的意思，learn_1 是剛才我給這個源文件取的名字。
除了右鍵來運行，還可以直接用快捷鍵 Ctrl+Shift+F10，執行結果：
恭喜你，輸出了你的第一行代碼，正式開始Python之旅！
二、基礎知識
在用Python寫代碼的之前，對Python的基礎知識是必須要會的，不然你可能會寸步難行。基礎知識包括輸入輸出、變量、數據類型、表達式、運算符這5個方面。
1.輸入輸出
Python有很多函數，后面我們會細講，但這里先將兩個最基本的函數：輸入和輸出。
輸出函數print()，在前面我們已經用過了，語法就是：
print(要輸出的內容)
輸入函數是 input()，功能是接收用戶輸入的內容，語法是：
input（輸出的內容）
舉例：接收用戶輸入的密碼并打印
n = input("請輸入密碼：") #把輸入內容賦給n，用 n 接收一下
print(n) #打印n
在Python里，“#” 表示注釋，“#”后面的東西不會被執行。代碼運行之后首先出現了“請輸入密碼：”，然后隨意輸入，比如輸入123，執行結果：
提示信息
請輸入密碼：123
123
成功接收用戶輸入的內容并打印出來。
2.變量
變量就是一個名字，需要先賦值在使用，變量要符合標識符(名字)的命名規范，這是硬性要求，標識符相當于名字，包括變量名、函數名、類名等等，
- 標識符的命名規范
- 合法的標識符:字母，數字(不能開頭),下劃線，py3可以用中文（不建議），py2不可以。
- 大小寫敏感。
- 不能使用關鍵字和保留字。
關鍵字： if while for as import
保留字：input，print range
- 沒有長度限制。
- 望文生義，看到名字就知道要表達的意思。
- 大小寫：
1. 包名：全小寫，例如 time ;2. 類名：每個單詞的首字母大寫，其他的小寫，簡稱大駝峰命名，例如 HelloWorld ；3. 變量名/函數名:第一個單詞的首字母小寫，后面的單詞的首字母大寫，簡稱小駝峰命名，例如 helloWorld ；4. 常量：全大寫，例如 HELLO 。
- 其他命名方式，比如 hello_world 。
3.數據類型
- 數據類型分類
數據類型可分為以下6類：
（1） 整型：整數，英文名 int ，例如 5 的數據類型就是整型。
（2） 浮點型：小數，英文名 float ，例如 0.5 就是1個浮點型數據。科學計數法，e表示乘以10幾次方，例如 b=1e10 表示1*10的10次方。
（3） 字符串：英文str表現形式有4種：'xs' 、 "xs" 、 """xsxs""" 、 ''''xxx''' 三引號有個特殊功能，表示注釋，跟 # 一樣的功能，例如：
"""
xsx
xs
這里面的都是注釋內容
"""
（4）布爾類型：英文bool，True為真，False為假；1表示真，0表示假。
（5）None 是一個單獨的數據類型。
（6）列表、元組、字典、集合也是常見的數據類型。
- 類型轉換
在寫代碼的時候我們經常需要將不同的數據類型進行轉換，主要的數據類型轉換方法如下：
（1） 字符串轉整型
方法是 int(str) ，字符串必須是數字，例如：
user = int('304200780')
print(user)
執行結果：
304200780
(2)浮點型轉整型
方法是 int(float) ，例如：
f = 20.1
ff = int(f) #直接抹去小數部分
print(ff)
運行結果：
20
(3)字符串轉浮點型
方法是 float(str) ，字符串必須是數字和，例如：
f = "203.4"
ff = float(f)
print(ff)
運行結果：
203.4
(4)整型轉浮點型
方法是 float(int) ，例如：
f = 30
ff = float(f) # 30.0
print(ff)
運行結果：
30.0
(5)浮點型轉字符串
方法是 str(float) ，例如：
f = 30.5
ff = str(f)
print(type(ff).__name__) #type()是獲取數據類型函數
這里先不管print()和type（）函數的嵌套，后面會將，只要知道它們是在輸出 ff 的數據類型，運行結果：
str
(6)整型轉字符串
方法是 str(int) ，例如：
f = 30
ff = str(f)
print(type(ff).__name__) #type()是獲取數據類型函數
- 獲取類型信息
常用的獲取數據類型信息的函數有type()和isinstance()兩個。
（1）type()
語法是 type(對象) ，返回的是對象的類型，前面我們也有用過，但是它是在內部返回的，如果你不輸出它你是看不到的，所以經常會和輸出函數print()嵌套使用。
例子：獲取數據類型并輸出。
f = 30
print(type(f))
運行結果：
<class 'int'>
class的意思是種類，可以看出 f 是 int 型的數據。
（2）isinstance()
isinstance() 常用來判斷數據類型，它返回的是布爾值（True或False），語法是 isinstance(對象,class) 。
例子：判斷30.5是不是整型。
f = 30.5
n = isinstance(f,int) #用n來接收一下結果
print(n)
運行結果：
False
4.表達式
在Python當中，表達式是由數字、算符、數字分組符號（括號）、變量等對象的組合叫做表達式，表達式均有固定字面值，例如 “10+20”這個表達式的值為30，表達式 “10>30” 的值為 False 。
5.運算符
運算符可以分為很多4類。
（1）一般運算符
+，-，*，/（真除法）,//（地板除，舍去小數部分）,%（取余數）,**（冪運算）
（2） 賦值運算符
常用賦值運算符是 = ，等號右邊的值賦值等號左邊
增強賦值運算符：+=，-=，*=，/=,%=,**=
例子：
a = 30
a+=10
print(a)
執行結果：
40
連續賦值：a=b=c=d=10
（3）布爾運算法
== （等于），！=（不等于） >= <= > <
（4） 邏輯運算符
主要有not、and和or三類，又稱非、與和或
and：前后都為真則為真
or：有一個為真則為真
not:非真，非假
例子：
a = 10
b = 20
c = 30
d = 40
n1 = a > b and a < c #a>b為假，a<c為真，假與真為假
n2 = not a < c #a<c為真，非真則為假
n3 = a > b or a < c #a>b為假，a<c為真，假或真為真
print(n1,n2,n3)
執行結果：
False False True
我私藏了很多技術干貨，粉絲可白嫖（點這里）
三、流程控制
流程控制常用的是條件分支流程的if/else語句和循環控制的while語句。
1.條件分支流程
當達到某種條件的時候才會觸發的代碼。
（1）語法1
if 布爾表達式: #如果為真則執行內部的代碼塊代碼塊
布爾表達式的結果只有兩個，要么真，要么假，如果是真的，那么就執行if語句里面的代碼塊，否則就跳過不執行。
例子：
a = 10
b = 20
if a < b:print("真的")
if a > b:print("假的")執行結果：
真的
從這里可以看出第一個if語句里面的布爾表達式（a<b）為真，所以執行了里面的代碼塊print(“真的”)，而第二個if語句里面的布爾表達式（a>b）是假的，所以里面的代碼塊沒有被執行，所以不輸出“假的”兩字。
（2）語法2
常用的if/else語句，語法如下：
if 布爾表達式：代碼塊
else:代碼塊
判斷的邏輯是如果布爾表達式為真，則執行if內部的代碼塊,如果為假則執行else內部的代碼。
例子：
a = 10
b = 20
if a > b:a = 30print(a)else:print(1111)
執行結果：
1111
（3）語法3
if 布爾表達式1：代碼塊
elif 布爾表達式2：代碼塊
elif 布爾表達式3：代碼塊
....
else:代碼塊
邏輯是如果布爾表達式為真，則執行if內部的代碼塊,如果為假則執行else內部的代碼，這個語法適用于多個連續條件判斷。
例子：
s = int(input("請輸入分數:"))if 80 >= s >= 60:print("及格")
elif 80 < s <= 90:print("優秀")elif 90 < s <= 100:print("非常優秀")else:print("不及格")
隨意輸入100以內的數字，不同區間內的數字結果是不一樣的，例如92，執行結果為：
請輸入分數:92
非常優秀
10
（4）語法4
這里可以將前面所講的if/elif/else進行嵌套使用，來達到我們想要的目的。
例子
s = int(input("請輸入分數:"))
if 80 >= s >= 60:print("及格")
elif 80 < s <= 90:print("優秀")
elif 90 < s <= 100:print("非常優秀")
else:print("不及格")if s > 50:print("你的分數在60分左右")else:print("你的分數低于50分")
隨意輸入數字，比如說55，執行結果：
請輸入分數:55
不及格
你的分數在60分左右
2.循環流程
在前面我們講過的流程控制語句的功能還是比較有限，比如說只能執行1次，要執行多次就得多寫幾個，有點麻煩，所以我們需要學習循環流程里面的循環語句，它的作用就是重復運行某些代碼。
（1）while循環
語法：
while 布爾表達式: 代碼塊
只要條件(布爾表達式)為真就執行里面的代碼塊。
舉例：
while 4 < 5:s = int(input("請輸入分數:"))if 80 >= s >= 60:print("及格")elif 80 < s <= 90:print("優秀")elif 90 < s <= 100:print("非常優秀")else:print("不及格")if s > 50:print("你的分數在60分左右")else:print("你的分數低于50分")
運行之后可以多次輸入分數，并且永不停息：
請輸入分數:56
不及格
你的分數在60分左右
請輸入分數:70
及格
請輸入分數:
當然這里有1個弊端，代碼執行后陷入了死循環,while里面的代碼被一直執行，因為4<5永遠為真。
所以這里我們可以改善一下代碼，不讓它永遠執行，讓它循環執行幾次就可以了，這里可以用個變量來作為條件判斷，把4<5改成a<5，同時讓在while里面實現自加的功能，在while里面代碼每執行1次，執行到它那行的時候它加1，這樣執行2次while就會跳出來。
a = 3
while a < 5:s = int(input("請輸入分數:"))if 80 >= s >= 60:print("及格")elif 80 < s <= 90:print("優秀")elif 90 < s <= 100:print("非常優秀")else:print("不及格")if s > 50:print("你的分數在60分左右")else:print("你的分數低于50分")a += 1
print(a)
print("while執行結束了")
執行結果：
請輸入分數:55
不及格
你的分數在60分左右
請輸入分數:65
及格
5
while執行結束了
這里我再給大家舉個例子來理解while循環的運用。比如說輸入一個整數并計算各個位和，例如輸入321，那么各個位之和則為6。
# 請輸入一個整數，并計算各個位和 如：321=6n = int(input("請輸入一個整數:")) # 將字符串轉為整型# sums累加器：m=10 m=10+5sums = 0while n != 0: # 32 #3sums = sums + n % 10 # sums=1+2=3+3=6n = n // 10 # 32
print(sums)
我輸入的2345，執行結果：
請輸入一個整數:2345
14
（2）for循環
for循環和while循環都是循環語句，但不一樣的點在于for循環是技術循環。
語法：
l=[3,2,1]
for 變量 in 可迭代對象:代碼塊
例子：
l=[3,2,1]
for n in l:print("1")
執行：
1
1
1
l是個列表，后面我們會講，列表里面有3個元素，每執行一次for循環，列表里面的元素就會被賦值給n，直到列表里面沒有了元素可賦值，則n就跳出了列表，此時的for循環就不成立了，不執行for里面的代碼塊。
（3）range
for循環經常會搭配range來使用，range是一個可迭代對象，range的語法如下：
range(start=0,stop,step=1)
start值的是開始下標。range序列里面的所有元素都有下標，第一個元素的下標是0，所以，默認是從0開始。
stop是結束位置。結束的位置下標為（元素個數-1），例如range里面有4個元素，那么結束下標最大為3,大于3則跳出range。
step是步長，如果step是2，那么每次會隔開1個元素，默認步長為1，即每個元素都會取到。
舉例：
for i in range(8): #可以不寫star和step，但結束位置一定要寫的print(i)
print("---------")
for i in range(10, 2, -2):print(i)
執行結果：
0
1
2
3
4
5
6
7
---------
10
8
6
4
通過第一個for循環可以看出，range()的第一個元素的下標是從0開始，而不是從1開始；range()可以不寫開始下標和步長，但一定得有結束位置；第二個for循環可以看出步長可以為負數，用于遞減。
（4）continue
continue的作用是跳過本次循環，后面的循環繼續執行，例如：
for i in range(1, 10):if i == 5:continueprint(i)
執行結果：
1
2
3
4
6
7
8
9
很明顯，i等于5的時候，for循環就跳過去了，本次不再執行里面的代碼，重新回到了新的循環。
同樣的，還有終止所有循環的功能，就是break，和continue是一樣的用法，但效果是不一樣的，我這里就不做舉例了，大家可以去試一下就知道了。
四、列表(List)
列表是可以存放任何數據，包括整型，浮點型，字符串，布爾型等等，是常用的數據類型之一。
1.列表的創建
列表也是一個可迭代對象
1. 普通形式l = [1,2,3,4,5] ---整型列表l = ["a","b","c"] ---字符串列表l = [True,False,1>2,5<6]---布爾列表
2. 混合列表l = [1,2.5,"a",True]
3. 空列表l = []
- 從列表中如何獲取數據(元素)
列表是有下標的，并且下標從0開始，元素是指列表中每個數據，例如l = [5,4,3,2,1] 里面有5個元素，但5的下標為0,1的下標為4。
1.獲取當個數據(元素)語法：變量[下標] #獲取下標所對應的值
例如獲取l列表中下標為1的元素：
l = [1, 2, 3] # 下標/索引：0開始
print(l[1])
執行結果為：
2
2. 列表的遍歷
列表的遍歷是把列表里面的所有元素都獲取1遍。
例如把[1,2,3,4,5]里面的元素都獲取并輸出一遍：
l = [1,2,3,4,5]
for i in l:print(i, end=" ")
執行結果為：
1 2 3 4 5
3. 交換數據
對指定下標的元素進行數據交換。
例如把[1, 2, 3, 4, 5]里面的下標為第2和第3的元素進行數據交換：
l = [1, 2, 3, 4, 5] # 下標/索引：0開始
l[2], l[3] = l[3], l[2]
print(l)
執行結果：
[1, 2, 4, 3, 5]
2.添加元素
添加元素的方法常用的有以下3個：
統一用法是：
變量.函數
#例如 n. append(對象)
例子:講列表[6,7]添加到另一個列表[1,2,3,4,5]中
l = [1, 2, 3, 4, 5]
l.extend([6, 7])
print(l)
執行結果：
[1, 2, 3, 4, 5, 6, 7]
3.刪除元素
刪除列表中的元素的常用方法主要有：
例子：刪除列表[1, 2, 3, 4, 5]中4這個元素。
l = [1, 2, 3, 4, 5]
l.remove(4)
print(l)
執行結果為：
[1, 2, 3, 5]
4. 修改元素
修改列表中的元素方法其實很簡單，直接用這個方式就可以了：
變量[下標]=新值
例如：
l = [1, 2, 3, 4, 5]
l[2]=6
print(l)
執行結果：
[1, 2, 6, 4, 5]
5.列表高級特性的
- 切片操作
切片，顧名思義就是把1個列表切分為多個列表，語法如下：
變量[起始下標:結束下標] #結束下標取不到
例如
l = [1, 2, 3, 4, 5]
print(l[0:4])
執行結果：
[1, 2, 3, 4]
做切片操作時要注意以下幾個點：
①如果下標從0開始可以省略不寫，例如 n = l[:4]
②如果結束下標取的是最后一個元素，可以省略不寫，例如 n = l[3:]
③如果列表中的元素都要，開始和結束下標都可以省略，例如 n = l[:]
④n = l[:-1] 表示從0開始 - 到數二個元素
- 列表的進階操作
方法是 n = l[開始:結束:步長] ，這個方法既可以正向去操作列表，也可以反向去操作列表,例如:
l = [1, 2, 3, 4, 5]
n = l[-1:-3:-1]
print(n)
執行結果：
[5, 4]
- 列表的一些操作符
- 比較運算符
列表之間進行比較，以相同下標進行比較，從小到大進行比較，如果值相同則比較下一組元素，如果不同直接出結果，例如：
l = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] # 下標/索引：0開始
l2 = [2, 3, 4, 6]
print(l < l2) # True
執行結果：
True
- 邏輯運算符
邏輯運算符and not or 跟比較運算符相似，返回結果都是布爾值（True/False），這里可以去自己嘗試一下。
- 拼接運算符
拼接運算符是 + ，常用來進行兩個列表拼接，例如：
l = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] # 下標/索引：0開始
l2 = [2, 3, 4, 6]
print(l + l2)
執行結果：
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 2, 3, 4, 6]
- 重復操作符
重復操作符為 * ，后面常跟數字，表示將列表里面的元素重復復制幾遍,例如：
l2 = [2, 3, 4, 6]
print(l2*2)
執行結果：
[2, 3, 4, 6, 2, 3, 4, 6]
- 成員關系操作符
成員關系操作符主要有 in和not in，用來判斷元素是否在列表中，返回結果是布爾值，例如：
l = [2, 3, 4, 6]
print(5 not in l) #輸出“5不在列表l中”這句話的真假
執行結果：
True
- 列表的其他方法
列表常用的其他方法還有以下幾個：
例如：將列表里面的所有元素進行翻轉
l = [2, 3, 4, 6]
l.reverse()
print(l)
執行結果：
[6, 4, 3, 2]
- 冒泡排序法
冒泡排序是列表里面比較有名的排序方法之一，例如將列表[5,4,3,2,1]里面的所有元素用冒泡排序的思想進行從小到大排序。
l = [6, 5, 4, 3, 2, 1]
for i in range(1, len(l)): # 1,5 #循環4大次 4for j in range(len(l) - i):if l[j] > l[j + 1]:l[j], l[j + 1] = l[j + 1], l[j]print(l)
執行結果：
[1, 2, 3, 4, 5, 6]
- 選擇排序
選擇排序是讓列表中的元素，固定一個元素和其他元素進行比較，不符合條件互換位置。
l = [6, 5, 4, 3, 2, 1]
for i in range(0, len(l) - 1): # 0,4for j in range(i + 1, len(l)): # 1,5if l[i] > l[j]:l[i], l[j] = l[j], l[i]print(l)
執行結果：
[1, 2, 3, 4, 5, 6]
- 二維列表
列表里面還能存放多個列表，由比如列表 [[1,2,3],[4,5,6],[7,8,9]] ，它是由兩個維度的列表組成，1個維度是它本身，另一個維度是[1,2,3],[4,5,6],[7,8,9] 這三個列表，所以構成了二位列表。
對于二位列表，語法是：
變量[外層列表下標][內層列表的下標]
例如輸出二位列表中的第一個列表里面的下標為1的元素:
l = [[1,2,3],[4,5,6],[7,8,9]]
print(l[0][1]) #2
執行結果為:
2
在這里我們可以看得出來，二位列表里面的外層列表也有下標，下標也是從開始。
我們再來對二位列表進行遍歷：
l = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
for i in l:for j in i:print(j)
執行結果：
1
2
3
4
5
6
7
8
9
粉絲福利，點擊可查看
五、元組（tuple）
元祖也是Python中常見的數據類型之一，它可以用來存放任何數據類型，但它也有它的特點：
1. 不能修改，不可變類型
2. 用（）的形式
3. 元組也是可迭代對象
4. 元組是有序的，下標操作,支持切面操作[:]
1.元組的創建及訪問
1. 創建：直接創建，例如 t = (1,2,3,4,5)
2. 訪問：t[下標] #獲取元素
3. 切片操作：t[:] 返回元組
例子創建元組并對元組進行元素訪問和切片操作：
t = (1, 2, 3, 4, 5)
print(t[2]) #輸出下標為2的元組元素
n = t[2:4] #切片，范圍是下標2~4
print(n)
執行結果為：
3
(3, 4)
2.修改和刪除
前面有說過元組是不可變類型，不能修改，但是可以通過將元組轉換成列表的形式進行修改和刪除等操作，最后再將列表轉換成元組，完成元組的修改和刪除。
例如：修改元組中的元素
t = (1, 2, 3, 4, 5)
l = list(t) #將元組轉換成列表
print(l) #輸出列表
l[2] = 6 #列表指定元素的修改
print(l) #輸出新列表
t = tuple(l) #列表轉換成元組
print(t)
執行結果：
[1, 2, 3, 4, 5]
[1, 2, 6, 4, 5]
(1, 2, 6, 4, 5)
刪除元組中的元素可用 del t[下標] 方法，前提還是一樣的先將元組轉換成列表，例如：
t = (1, 2, 3, 4, 5)
l = list(t) #將元組轉換成列表
print(l) #輸出列表
del l[2] #列表指定元素的刪除
print(l) #輸出新列表
t = tuple(l) #列表轉換成元組
print(t)
執行結果：
[1, 2, 3, 4, 5]
[1, 2, 4, 5]
(1, 2, 4, 5)
3.元組的操作符
元組同樣也有著操作符，方法跟列表的操作符是一樣的。
1. 比較運算符< > >= <= == !=
2. 邏輯運算符 and not or
3. 拼接運算符+
4. 重復操作符*
5. 成員關系操作符in not in判斷元素是否在列表中print(5 not in l)
例子：判斷5在不在元組里面。
t = (1, 2, 3, 4, 5)
print(5 not in t) #5不在元組里面
執行結果：
False
4.元組的方法
元組的方法和前面所介紹的列表的方法是一樣的，這里給大家回顧一下列表的常用方法：
這些方法的使用還是遵循列表的方法時所講的 變量名.方法 。除了上面的這些，還有2個方法值得新增：
1. count(value)
統計某個值出現的次數，value是指定的值2. index(value,[start],[stop])
返回value在元組中出現的下標位置（第一次出現的下標）
例子：統計3在元組（1,2,3,4,5,3）中第一次出現的下標。
t = (1, 2, 3, 4, 5,3)
l1 = t.index(3, 0, 6)
print(l1)
執行結果：
2
六、字符串
在Python中，字符和字符串沒有區別。可能有些同學學過其他的語言，例如Java，在Java中，單引號’a’表示字符’a’，雙引號"abc"表示字符串"abc"，但在Python當中，它們沒有區別，都統稱字符串。
1.字符串的特點
字符串擁有以下特點：
1. 字符串不可變類型
2. 字符串是可迭代對象
3. 字符串支持索引和切片操作
4. 支持操作符;拼接：+重復操作符：*比較運算符： > < <= >= == !=邏輯運算符：not and or成員關系： in not in
2.字符串的方法
字符串的常用方法有以下這些：
例子：將字符串 “hello world” 的第一個字母大寫。
a = "hello world"
b = a.capitalize()
print(b)
執行結果：
Hello world
3.格式化輸出
格式化輸出是指將字符串按照某種格式進行輸出,常用的方法有 format 和 $% 。
1. format 語法1：用數字占位（下標）
例子:
"{0} 嘿嘿".format("Python")
a = 100
s = "{0}{1}{2} 嘿嘿"
s2 = s.format(a, "JAVA", "C++")
print(s2)
2.format 語法2：{} 占位
例子：
a = 100
s = "{}{}{} 嘿嘿"
s2 = s.format(a, "JAVA", "C++", "C# ")
print(s2)
執行結果：
100JAVAC++ 嘿嘿
3.format 語法3：{} 占位用字母占位
例子：
s = "{a}{b}{c} 嘿嘿"
s2 = s.format(b="JAVA", a="C++", c="C# ")
print(s2)
執行結果：
C++JAVAC# 嘿嘿
4.%s
語法為 “%s”%（值） ，最常用的參數可以是任意值。
例子：用%s 結合循環語句輸出九九乘法表
for i in range(1, 10):for j in range(1, i + 1):print("%s * %s = %s" % (i, j, i * j), end="\t")print()執行結果：
1 * 1 = 1
2 * 1 = 2 2 * 2 = 4
3 * 1 = 3 3 * 2 = 6 3 * 3 = 9
4 * 1 = 4 4 * 2 = 8 4 * 3 = 12 4 * 4 = 16
5 * 1 = 5 5 * 2 = 10 5 * 3 = 15 5 * 4 = 20 5 * 5 = 25
6 * 1 = 6 6 * 2 = 12 6 * 3 = 18 6 * 4 = 24 6 * 5 = 30 6 * 6 = 36
7 * 1 = 7 7 * 2 = 14 7 * 3 = 21 7 * 4 = 28 7 * 5 = 35 7 * 6 = 42 7 * 7 = 49
8 * 1 = 8 8 * 2 = 16 8 * 3 = 24 8 * 4 = 32 8 * 5 = 40 8 * 6 = 48 8 * 7 = 56 8 * 8 = 64
9 * 1 = 9 9 * 2 = 18 9 * 3 = 27 9 * 4 = 36 9 * 5 = 45 9 * 6 = 54 9 * 7 = 63 9 * 8 = 72 9 * 9 = 81
4.轉義字符
1. “\n” ：換行符
2. “\'”:單引號
3. “\“”:雙引號
4. "\\" : \
在這里值得注意的是 \ ，它有很多比較巧的運用，比如說當你在同一行要寫的東西比較多的時候，視覺上不是很好看,可以用反斜杠來進行視覺上的換行，但上一行和下一行在邏輯上是一樣的，例如：
a = "sxsxsxsxsxsxsxs\xsxsxsxs\xsx"
print(a)a = 1 + 2 + 3 \+ 4
print(a)
執行結果：
sxsxsxsxsxsxsxs xsxsxsxs xsx
10
粉絲福利，點擊可查看
七、字典（dict）
字典是用來存儲數據的，字典中的數據以映射關系存儲。
1.字典的特點
1. 字典是Python中唯一的映射類型
2. 字典是無序的
3. 字典是可迭代對象
4. 字典的構成鍵：key值：value映射：鍵映射值鍵-值：鍵值對，又叫 項
2.創建字典
1. 直接創建語法： d = {} #空字典例如： d = {"name":"不良人","apple":"蘋果"}
2. dict()例如：d = dict() #空字典
3. dict(可迭代對象)
例如：
d3 = dict([("one",1),("two",2)])print(d3)
執行結果：
{'one': 1, 'two': 2}
這就是一個元組，one是鍵，1是值， ‘one’ : 1 是鍵值對。
4. dict(**kwargs)
例如：
d4 = dict(a=3, b=4)
print(d4)
執行結果：
{'a': 3, 'b': 4}
3.字典訪問的
1. 基本形式：變量名[鍵名] #鍵所對應的值
例如：
d = {"name": "小黑"}
print(d["name"])
執行結果：
小黑
2. 添加一個鍵值對變量名[鍵名]=值
3. 修改一個鍵值對的值變量名[鍵名]=值
4.字典的方法
字典常用的方法主要有以上一些：
例子：返回指定字典中的所有值
d2 = {'c': 3, 'hehe': 100, 'b': 2, 'a': 1}
c = d2.values()
print(list(c))
執行結果：
[3, 100, 2, 1]
5.補充
關于字典，有一些小點給大家做個補充：
1. 字典可以使用for循環for i in d2:print(i) #鍵，不包含值
2. 輸出一個鍵值對for i in d2.items():print(i)
3. 成員關系操作符in/not in只能查詢鍵
八、函數
函數是由一組代碼組成，完成某個特定的功能。
1.創建和使用
創建函數的語法如下：
def 函數名(參數): 代碼塊（函數的實現/函數體）
參數相當于變量,參數可以為1個或者多個，用逗號隔開，還可以沒有參數，等于無參；代碼塊是函數的實現，又叫函數體。
函數的調用
函數名(參數)
2.函數的運行機制
函數的運行遵循以下機制：
1. 從函數調用開始執行
2. 通過函數名字找到函數定義的位置（創建函數的位置）
3. 執行函數體
4. 執行完畢之后，返回到函數的調用處
3.函數的使用
舉例：用函數對古詩《登鸛雀樓》進行逐行打印，并對每一行下面增加由多個相同符號組成的分割線。
def fun2(a, n):print(a * n)# 打印古詩
print("白日依山盡")
fun2("+", 5)
print("黃河入海流")
fun2("-", 10)
print("欲窮千里目")
fun2("*", 15)
print("更上一層樓")
fun2("/", 20)
執行結果：
白日依山盡
+++++
黃河入海流
----------
欲窮千里目
***************
更上一層樓
////////////////////
4.函數的特點
通過上面的例子可以發現，函數具有以下特點：
1. 避免了代碼的冗余
2. 提高了代碼的可維護性
3. 提高了代碼的可重用性
4. 提高了代碼的靈活性
5.函數的參數
函數的參數首先要明白以下三個概念：
1. 形式參數：形參在定義函數的時候傳遞的參數
2. 實際參數：實參 在調用函數時傳遞的參數
3. 無參沒有任何參數
位置參數：實參的位置和形參一一對應，不能多也不能少。
關鍵字參數：用形參的名字作為關鍵字來指定具體傳遞的值，則在函數調用時，前后順序將不受影響。
位置參數和關鍵字參數混用：當位置參數和關鍵字參數混用時，位置參數在前
默認參數：給了默認值的參數--形參如果傳遞了新的值，那么默認值就被覆蓋了
可變成參數：def 函數名(*a)本質上封裝成了元組
可變成參數：def 函數名(**kwargs)將參數封裝成了字典
可變成參數和位置參數混用的時候：可變參數優先
6.函數的文檔
寫代碼的時候我們經常需要寫文檔，前面有提過#和三引號可以進行代碼的注釋，但在這里要介紹一種新的方法，也是寫代碼時常用的函數文檔書寫格式：在函數體的第一行用 “”" “”" 進行文檔說明，這是標準化的函數文檔書寫。
例如：
擁有函數說明文檔之后，就可以獲取函數的文檔內容，方法是：
函數名.__doc__
例如：
除此之外，還可以用 help(函數名) 的方式進行函數文檔的查看，例如：
7.函數的返回值
關鍵字：return
返回值誰調用就返回給誰
1. 任何函數都有返回值
2. 如果不寫return ，也會默認加一個return None
3. 如果寫return ，不寫返回值 也會默認加一個None
4. 可以返回任何數據類型
5. return后面的代碼不在執行，代表著函數的結束
8.函數的變量的作用域
首先需要明白兩個概念：局部變量和全局變量。
1. 局部變量定義在函數內部的變量先賦值在使用從定義開始到包含他的代碼結束在外部無法訪問
2. 全局變量1. 定義在源文件的開頭2. 作用范圍：整個文件3. 局部變量和全局變量發生命名沖突時，以局部變量優先
3.global聲明全局變量
4. nonlocal聲明的是局部變量
9.內嵌函數
定義在函數內部的函數叫做內嵌函數（或者叫內部函數），內部函數的作用范圍：從定義開始到包含給他的代碼塊結束在內部函數中不能進行a+=1,a=a+1這樣的操作，解決方案是nonlocal 和global。
例如：
10.閉包
閉包是函數式編程的重要語法結構。
編程范式：一種編程范式，對代碼進行提煉和抽象概括，使得重用性更高
如果內部函數調用了外部函數的局部變量，并外部函數返回內部函數的函數對象（函數名），例如：
這就形成了閉包，閉包的作用是可以傳遞更少的形參，可以傳遞更多的實參—更加安全，間接性的訪問內部函數，例如：
當然了，閉包是有條件的：
1. 必須是一個內嵌函數
2. 外部函數必須返回內部函數的函數對象
3. 內部函數必須使用外部函數的局部變量
11. lambda表達式
1. 匿名函數沒有名字的函數
2. 使用時機：只使用一次的時候
3. 語法：關鍵字： lambdalambda 參數1，參數2:返回值
4. lambda的書寫形式更加的簡潔，優雅l = lambda x:xprint(l(100))
5. lambda的優先級最低
九、綜合性練手項目
學完了這些基礎你覺得你的水平怎么樣？是不是就這么飄過來的？說實話，學完這些基礎你能做的東西沒有多少的，好玩的東西都是入門之后才能做出來的。
但是在龍叔這里，綜合性項目還是有的，就根據我上面所講的循環語句、列表、函數等基礎知識，可以嘗試寫一個綜合性的項目來檢驗你的知識，可以嘗試寫1個簡單的名片管理系統。
（一）系統需求
1.程序啟動，顯示名片管理系統歡迎界面，并顯示功能菜單
**************************************************
歡迎使用【名片管理系統】V1.01. 新建名片
2. 顯示全部
3. 查詢名片0. 退出系統
**************************************************
2.用戶用數字選擇不同的功能
3.根據功能選擇，執行不同的功能
4.用戶名片需要記錄用戶的 姓名、電話、QQ、郵件
5.如果查詢到指定的名片，用戶可以選擇 修改 或者 刪除 名片
（二）效果預覽
大概了解了這個操作系統的需求之后，我們先不忙著看代碼，我們先來看看代碼運行后的效果，這就是我們要做的東西：
這里我不放視頻了，放視頻的文章一點開就會自動播放，這點有點無語，尤其是我這種長篇文章，你找半天找不到視頻在哪？哈哈哈…所以還是給大家放視頻演示的鏈接吧！
視頻效果鏈接：https://www.bilibili.com/video/BV1aZ4y1F7n6/
下次我會專門出一篇講這個名片管理系統項目的文章，現在你們先暫時自己嘗試著寫寫吧，源碼私聊找我要也可以的。
【Python新手入門教程專欄】
總結
以上是生活随笔為你收集整理的万字【Python基础】保姆式教学，零基础快速入门Python的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： Sky Garden
- 下一篇： AcWing 253. 普通平衡树