??萬字【Python基礎】保姆式教學??，小白快速入門Python！

前言

又是爆肝干文的日子，繼上次說要出一期Python新手入門教程系列文章后，就在不停地整理和碼字，終于是把【基礎入門】這一塊給寫出來了，

高級編程的【正則運算式】和【面向物件編程】內容我在之前已經出過了，感興趣可以去看看我的專欄，今天的內容是【基礎入門】，

【Python新手入門教程專欄】

不積跬步無以至千里，不積小流無以成江海，一個一個板塊的知識積累，早晚你也會成為你羨慕的那種人，接下來就是正式的內容了，

---

今日內容預覽

---

一、初識Python

1.什么是Python

Python是1門程式設計語言，在開發者眼里，語言可以分為3類：

1. 自然語言：人能聽懂的語言，例如漢語，英語，法語等等，
2. 機器語言：機器能聽懂的語言，機器只能聽懂0和1，
3. 程式設計語言：機器能夠聽懂，人能聽懂的語言，例如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.變數

變數就是一個名字，需要先賦值在使用，變數要符合識別符號(名字)的命名規范，這是硬性要求，識別符號相當于名字，包括變數名、函式名、類名等等，

• 識別符號的命名規范

1. 合法的識別符號:字母，數字(不能開頭),下劃線，py3可以用中文（不建議），py2不可以，
2. 大小寫敏感，
3. 不能使用關鍵字和保留字，

關鍵字： if while for as import
保留字：input，print range

4. 沒有長度限制，
5. 望文生義，看到名字就知道要表達的意思，
6. 大小寫：

  1. 包名：全小寫，例如 time ;
  2. 類名：每個單詞的首字母大寫，其他的小寫，簡稱大駝峰命名，例如 HelloWorld ；
  3. 變數名/函式名:第一個單詞的首字母小寫，后面的單詞的首字母大寫，簡稱小駝峰命名，例如 helloWorld ；
  4. 常量：全大寫，例如 HELLO ，

7. 其他命名方式，比如 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 = 30
    print(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=6

n = int(input("請輸入一個整數:"))  # 將字串轉為整型

# sums累加器：m=10 m=10+5

sums = 0

while n != 0:  # 32 #3
    sums = sums + n % 10  # sums=1+2=3+3=6
    n = 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:
        continue
    print(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]

• 串列的一些運算子

1. 比較運算子
   串列之間進行比較，以相同下標進行比較，從小到大進行比較，如果值相同則比較下一組元素，如果不同直接出結果，例如：

l = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]  # 下標/索引：0開始
l2 = [2, 3, 4, 6]
print(l < l2)  # True

執行結果：

True

2. 邏輯運算子

邏輯運算子and not or 跟比較運算子相似，回傳結果都是布林值（True/False），這里可以去自己嘗試一下，

3. 拼接運算子

拼接運算子是 + ，常用來進行兩個串列拼接，例如：

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]

4. 重復運算子

重復運算子為 * ，后面常跟數字，表示將串列里面的元素重復復制幾遍,例如：

l2 = [2, 3, 4, 6]
print(l2*2)

執行結果：

[2, 3, 4, 6, 2, 3, 4, 6]

5. 成員關系運算子

成員關系運算子主要有 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大次  4
    for 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,4
    for j in range(i + 1, len(l)):  # 1,5
        if 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. 語法：
		關鍵字： lambda
		lambda 引數1，引數2:回傳值
4. lambda的書寫形式更加的簡潔，優雅
		l = lambda x:x
		print(l(100))
5. lambda的優先級最低

---

九、綜合性練手專案

學完了這些基礎你覺得你的水平怎么樣？是不是就這么飄過來的？說實話，學完這些基礎你能做的東西沒有多少的，好玩的東西都是入門之后才能做出來的，

但是在龍叔這里，綜合性專案還是有的，就根據我上面所講的回圈陳述句、串列、函式等基礎知識，可以嘗試寫一個綜合性的專案來檢驗你的知識，可以嘗試寫1個簡單的名片管理系統，

（一）系統需求

1.程式啟動，顯示名片管理系統歡迎界面，并顯示功能選單

**************************************************
歡迎使用【名片管理系統】V1.0

1. 新建名片
2. 顯示全部
3. 查詢名片

0. 退出系統
**************************************************

2.用戶用數字選擇不同的功能
3.根據功能選擇，執行不同的功能
4.用戶名片需要記錄用戶的 姓名、電話、QQ、郵件
5.如果查詢到指定的名片，用戶可以選擇 修改 或者 洗掉 名片

（二）效果預覽

大概了解了這個作業系統的需求之后，我們先不忙著看代碼，我們先來看看代碼運行后的效果，這就是我們要做的東西：

這里我不放視頻了，放視頻的文章一點開就會自動播放，這點有點無語，尤其是我這種長篇文章，你找半天找不到視頻在哪？哈哈哈…所以還是給大家放視頻演示的鏈接吧！

視頻效果鏈接：https://www.bilibili.com/video/BV1aZ4y1F7n6/

下次我會專門出一篇講這個名片管理系統專案的文章，現在你們先暫時自己嘗試著寫寫吧，原始碼私聊找我要也可以的，

【Python新手入門教程專欄】