文章目錄 前言：

一. 函數：告別重複代碼的 “代碼工廠”

1.1 為什麼需要函數？

1.2 函數的核心語法(重點)

1.3 函數的進階用法（嵌套 + 遞歸）

1.4 函數核心小結

二. 列表和元組：批量存儲數據的 “容器”

2.1 列表（list）：最常用的可變容器

2.2 元組（tuple）：不可變的序列容器

2.3 列表的元組小結

結尾：

前言： 作為 Python 初學者，掌握函數、列表、元組是從 “寫代碼” 到 “寫好代碼” 的關鍵一步。它們不僅是 Python 語法的核心，更是後續處理複雜數據、構建高效程序的基礎。今天這篇文章，就結合入門實戰案例，把這三個知識點講透，新手也能一看就會、一用就通。

一. 函數：告別重複代碼的 “代碼工廠”

1.1 為什麼需要函數？ 寫代碼最忌諱的就是 “複製粘貼”。比如計算不同區間的數列和（1-100、300-400、1-1000），如果不使用函數，需要重複寫多組幾乎一樣的循環代碼：

1. 計算 1-100 的和

theSum = 0 for i in range(1,101): theSum = theSum + i print(theSum)

2. 計算 300-400 的求和

theSum = 0 for i in range(300,401): theSum = theSum + i print(theSum)

計算 1-1000 的和

theSum = 0 for i in range(1,1001): theSum = theSum + i print(theSum) 運行項目並下載源碼 python 運行 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 一旦需要修改計算邏輯（比如改成求平方和），所有重複代碼都要改，效率極低。而函數的核心作用，就是提取重複代碼，實現代碼複用，讓程序更簡潔、更好維護。

簡單理解：函數就像一個 “工廠”，輸入 “原材料”（參數），經過內部加工（函數體），輸出 “產品”（返回值），一次定義，多次調用。

函數版本代碼：

使用函數的方式來解決剛剛的問題

定義一個求和函數

def calcSum(begin,end): theSum = 0 for i in range(begin,end+1): theSum = theSum + i print(theSum)

使用函數

求 1-100 的和

calcSum(1,100)

求 300-400 的和

calcSum(300,400)

求 1-1000 的和

calcSum(1,1000) 運行項目並下載源碼 python 運行 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

1.2 函數的核心語法(重點) （1）函數定義與調用

1. 定義函數：def 函數名(形參列表): 函數體 return 返回值

def calcsum(beg, end): # beg、end是“形式參數”（形參），相當於工廠的“原材料入口” sum = 0 for i in range(beg, end + 1): sum += i return sum # return 輸出結果，相當於工廠的“產品出口”

2. 調用函數：函數名(實參列表)

result1 = calcsum(1, 100) # 1、100是“實際參數”（實參），是真正傳入的原材料 result2 = calcsum(300, 400) print(result1, result2) # 輸出：5050 35150 運行項目並下載源碼 python 運行 1 2 3 4 5 6 7 8 9 10 11 def test(a,b,c): print(a,b,c)

實參個數不能多也不能少,除非形參有默認參數

test(10,20,30) 運行項目並下載源碼 python 運行 1 2 3 4 5 ⚠️ 關鍵注意點：

函數必須先定義，再調用(就像動漫裏“先喊招式名，再釋放技能”)，否則會報 NameError； 定義函數時不會執行函數體，只要調用時才會執行，調用幾次就執行幾次； 形參和實參的個數必須匹配(比如定義時 2 個形參，調用時就必須傳 2 個實參)，否則報 TypeError； (2) 函數參數的靈活用法 Python 的函數參數比C++，Java更靈活，核心有 3 個特性：

1. 動態類型：形參無需指定類型，一個函數可接收多種類型參數

def print_param(a): print(a) print_param(10) # 整數 print_param("hello")# 字符串 print_param(True) # 布爾值（均能正常執行） 運行項目並下載源碼 python 運行 1 2 3 4 5 def add(x,y): return x+y

print(add(10,20)) print(add(1.5,2.5)) print(add('hello','world'))

# 這個就肯定不行了.不符合函數體內執行邏輯

print(add(10,'hello'))

運行項目並下載源碼 python 運行 1 2 3 4 5 6 7 8 2. 參數默認值：給形參指針默認值，調用時可省略該參數(默認值參數必須在無默認值參數後面)

計算兩數之和，默認不打印調試信息

def add(x, y, debug=False): if debug: print(f"調試：x={x}, y={y}") return x + y print(add(10, 20)) # 省略debug，使用默認值False print(add(10, 20, True)) # 顯式傳參，打印調試信息 運行項目並下載源碼 python 運行 1 2 3 4 5 6 7 3. 關鍵字參數：調用時顯示指定“實參對應哪個形參”，可打亂傳參順序

def test(x,y): print(f"x = {x}") print(f"y = {y}")

關鍵字參數，順序無關，輸出: x = 10,y = 20;

test(x = 10,y = 20) test(y = 100,x = 200) test(100,y = 200)

這樣寫就不行了

test(x = 100,200)

運行項目並下載源碼 python 運行 1 2 3 4 5 6 7 8 9 10 11 (3) 函數返回值 返回值是函數的 “輸出”，核心用法有兩點：

1. 一個函數可以有多個 return 語句，執行到 return 時函數立刻結束(後續代碼不執行)

這種情況不算是有多個 return 語句

def tes():

return 1

return 2

一般情況下多個 return 語句是搭配 分支語句/循環語句 的

用來判斷 num 是不是奇數

def isOdd(num): if num % 2 == 0: return False else: return True

print(isOdd(10)) print(isOdd(19)) 運行項目並下載源碼 python 運行 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 2. 一次返回多個值：用逗號分隔，接收時用多個變量接收(無需接收的用 _ 忽略)

寫一個函數, 返回平面上的一個點

橫座標,縱座標

def getPoint(): x = 10 y = 20 return x,y

可以返回兩個值

a,b = getPoint() # 接收所有返回值

如果只想用其中一個可以使用 _ 佔位

_,b=getPoint() # 忽略x,只接收y

運行項目並下載源碼 python 運行 1 2 3 4 5 6 7 8 9 10 11 (4) 變量作用域

變量的作用域決定了 “變量能在哪些地方使用”，核心規則：

局部變量：函數內部定義的變量，僅在函數內部生效(出了函數就失效)； 全局變量：函數外部定義的變量，函數內部可訪問，但 修改時需要用global 聲明； 同名變量：不同作用域可存在同名變量(本質是不同變量，互不影響) x = 10

def test(): x = 20 print(f'函數內部:{x}')

test() print(f'函數外部:{x}') 運行項目並下載源碼 python 運行 1 2 3 4 5 6 7 8 x = 10

全局變量在函數裏也可以使用

def test():

print(f'x = {x}')

test()

使用這個函數,把全局變量 x 給改成 20!

def test(): global x x = 20

test() print(f'x = {x}') 運行項目並下載源碼 python 運行 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 1.3 函數的進階用法（嵌套 + 遞歸） （1）鏈式調用：把一個函數的返回值，作為另一個函數的參數

def isOdd(num): if num % 2 == 0: return False return True

def add(x,y): return x+y

result = isOdd(10)

print(result)

print(isOdd((add(5,5)))) 運行項目並下載源碼 python 運行 1 2 3 4 5 6 7 8 9 10 11 12 13 （2）嵌套調用：函數內部調用其他函數（包括自身）

def test(): print("hello")

test()

嵌套調用可以有很多層

def a(): num = 10 print("函數 a")

def b(): num = 20 a() print("函數 b")

def c(): num = 30 b() print("函數 c")

def d(): num = 40 c() print("函數 d")

d() 運行項目並下載源碼 python 運行 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 函數之間的調用關係，在Python中會使用一個特定的數據結構來表示，稱為 函數調用棧，每次函數調用，都會在調用棧裏新增一個元素，稱為 棧幀。

可以通過 PyCharm 調試器看到函數調用棧和棧幀。 在調試狀態下，PyCharm 左下角一般就會顯示出函數調用棧。

選擇不同的棧幀，可以看到各自棧幀中的局部變量。

思考：上述代碼，a,b,c,d 函數中的局部變量名各不相同，如果變量名是相同的，比如都是 num，那麼這四個函數中的 num 是屬於同一個變量，還是不同變量呢？ – 不同變量

（3）遞歸調用：函數調用自身(慎用!)

遞歸是嵌套調用的特使情況，核心是"有結束條件 + 每次逼近結束條件"，否則會無限遞歸導致 RecursionError

案例：遞歸計算 5 的階乘 (5! = 5 * 4 * 3 * 2 * 1)

寫一個函數,來求 n 的階乘(n是正整數)

def factor(n):

result = 1

for i in range(1,n+1):

result *= i

return result

遞歸

n! => n * (n-1)!

1! => 1

def factor(n): if n == 1: return 1 return n * factor(n - 1)

print(factor(5)) 運行項目並下載源碼 python 運行 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 務必存在遞歸結束條件，比如 if n == 1 就是結束條件。當 n 為 1 的時候，遞歸就結束了。 每次遞歸的時候，要保證函數的實參是逐漸逼近結束條件的。 ⚠️ 注意：遞歸代碼簡潔但難理解，易棧溢出，實際開發中優先用循環替代。

1.4 函數核心小結 掌握 3 點，搞定 Python 函數：

定義：def 函數名(形參)：函數體 return 返回值； 調用：函數名(實參)，支持默認值，關鍵字參數； 核心價值：複用代碼，拆分邏輯，讓程序更容易維護。 二. 列表和元組：批量存儲數據的 “容器” 當需要存儲多個數據（比如10個學生的成績，20個城市名）時，單獨定義多個變量不現實，此時就需要列表（list）和元組（tuple）—— 它們是 Python 中最常用的 “序列類型”，專門用來批量存儲數據。

核心區別（一句話記牢）：

列表（list）：可變容器（像 “散裝辣條”），元素可增刪改； 元組（tuple）：不可變容器（像 “包裝辣條”），元素創建後無法修改。 2.1 列表（list）：最常用的可變容器 （1）創建列表

兩種核心方式，推薦用 [  ] (更簡潔)

創建列表

1. 直接使用字面值來創建

[] 就表示一個 空的列表

a = [] print(type(a))

2. 使用 list() 來創建

b = list() print(type(b))

3. 可以在創建列表的時候,在[]中指定列表的初始值

元素之間使用 , 來分割

a = [1,2,3,4] print(a)

4. 可以在同一個列表裏放不同類型的變量

a = [1,'hello',True,[4,5,6]] print(a)

運行項目並下載源碼 python 運行 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 ⚠️ 注意：不要用 list 作為變量名(會覆蓋內置函數 list())，建議命名為 list1，alist 等。

（2）列表的核心操作(必練)

列表的操作都圍繞 “下標” 展開，下標從 0 開始（負數表示倒數，-1 是最後一個元素），核心操作如下：

操作目的 代碼示例 説明 訪問元素 list3[2] 訪問下標 2 的元素（list3 [2] = 3），下標越界報 IndexError 修改元素 list3[2] = 100 把下標 2 的元素改成 100，list3 變成 [1,2,100,4] 切片（取子列表） list3[1:3] 取下標 1 到 3（左閉右開）的元素，輸出 [2,100] 新增元素 list3.append(5) 尾插（添加到末尾）；list3.insert(1, "a")（插入到下標 1） 刪除元素 list3.pop() 刪除末尾元素；list3.pop(2)（刪除下標 2 元素）；list3.remove(2)（按值刪除） 查找元素 2 in list3 判斷元素是否存在（返回布爾值）；list3.index(2)（找下標，不存在報異常） 連接列表 list3 + list4 拼接兩個列表（生成新列表）；list3.extend(list4)（拼接到 list3 末尾，修改原列表） 遍歷元素 for elem in list3: 直接遍歷元素（推薦）；也可按下標遍歷（for i in range(len(list3))） 下標訪問：

5. 使用下標來訪問列表元素

a = [1,2,3,4] print(a[2]) # 3

6. 使用下標來修改列表元素

a = [1,2,3,4] a[2] = 100 print(a)

7. 超出下標有效範圍,就會出現異常

a = [1,2,3,4]

a[100] = 0

print(a)

Traceback (most recent call last):

File "D:\Gitee.code\python-fundamentals-\PythonProject\2025--11--24\code42.py", line 33, in

a[100] = 0

~^^^^^

IndexError: list assignment index out of range

8. 可以使用內建函數 len 來獲取列表的長度(元素個數),和字符串類似

a = [1,2,3,4] print(len(a))

9. Python 中的下標,其實還可以寫成負數!!!

例如寫成 -1,其實等價於 len(a) - 1

a = [1,2,3,4] print(a[len(a) - 1])

-1 就是倒數第一個元素

print(a[-1]) 運行項目並下載源碼 python 運行 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 循環遍歷：

1. 使用 for 循環來遍歷列表

不會改變原來的數組

a = [1,2,3,4,5]

for elem in a:

elem = elem + 10

print(elem)

print(a)

2. 使用 for 循環遍歷,通過下標的方式

會改變原來的數組

a = [1,2,3,4,5]

for i in range(0,len(a)):

a[i] = a[i] + 10

print(a)

3. 使用 while 循環,通過下標遍歷這個列表

a = [1,2,3,4,5] i = 0 while i < len(a): print(a[i]) i += 1 運行項目並下載源碼 python 運行 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 增刪查改 && 連接等：

1. 使用 append 往列表末尾新增一個元素

a = [1,2,3,4]

a.append(5)

a.append("hello")

print(a)

b = [5,6,7,8]

b.append("world")

print(b)

2. 還可以使用 insert 方法，往列表的任意位置來新增元素

a = [1,2,3,4] a.insert(1,"hello") a.insert(100,"hello") # 會在最後插入一個 hello print(a)

運行項目並下載源碼 python 運行 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

1. 使用 in 來判定某個元素是否在列表中存在

a = [1,2,3,4]

print(1 in a)

print(10 in a)

print(1 not in a)

print(10 not in a)

2. 使用 index 方法,來判定當前元素在列表中的位置,得到一個下標

a = [1,2,3,4] print(a.index(2)) print(a.index(3))

print(a.index(10)) # 會報錯

運行項目並下載源碼 python 運行 1 2 3 4 5 6 7 8 9 10 11 12

1. 使用 pop 刪除列表中的最末尾的元素

a = [1,2,3,4] a.pop() print(a)

2. 使用 pop 還能刪除任意位置的元素,pop的參數

a = [1,2,3,4] a.pop(1) print(a)

3. 使用 remove 方法,可以按照值來進行刪除

a = ["aa","bb","cc","dd"] a.remove("cc") print(a) 運行項目並下載源碼 python 運行 1 2 3 4 5 6 7 8 9 10 11 12 13 14

1. 使用 + 針對兩個列表進行拼接

a = [1,2,3,4]

b = [5,6,7,8]

c = b + a

print(c)

c = a + b

print(c)

print(a)

print(b)

2. 使用 extend 來進行拼接

這個拼接是把後一個列表的內容拼接到前一個列表裏頭

a = [1,2,3,4]

b = [5,6,7,8]

c = a.extend(b) # extend 不返回任何內容

a.extend(b)

print(a) # a 這裏改變了

print(b)

3. 使用 += 來進行拼接

a = [1,2,3,4] b = [5,6,7,8] a += b # a = a + b print(a) print(b) 運行項目並下載源碼 python 運行 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 （3）切片操作的靈活用法(重點)

切片是列表的 “靈魂操作”，支持省略邊界、指定步長（正數從左到右，負數從右到左）：

1. 切片操作的基本使用

a = [1,2,3,4]

左閉右開區間

print(a[1:3])

2. 使用切片的時候,可以省略邊界

a = [1,2,3,4]

省略右邊界,意思是從指定的開始位置,一直取到整個列表結束

print(a[1:])

省略左邊界,意思是從列表的 0 號元素開始取,一直取到指定的結束位置

print(a[:2])

此處切邊中的下標也可以寫成負數

print(a[:-1])

還可以把開始邊界和結束邊界都省掉,得到的就還是列表本身

print(a[:])

3. 帶有步長的切片操作

a = [1,2,3,4,5,6,7,8,9,0] print(a[::1]) print(a[::2]) print(a[::3]) print(a[1:-1:2])

4. 步長的數值還可以是負數,當步長為負數的時候,意思是從後往前來取元素

a = [1,2,3,4,5,6,7,8,9,0] print(a[::-1]) print(a[::-2])

5. 當切片中的範圍超出有效下標之後,不會出現異常!,而是儘可能的把符合要求的元素給獲取到

a = [1,2,3,4,5,6,7,8,9,0] print(a[1:100]) 運行項目並下載源碼 python 運行 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 2.2 元組（tuple）：不可變的序列容器 元組的用法和列表幾乎一致，但核心區別是"不可變"(元素無法增刪改)，適合存儲不需要修改的數據(比如身份證號，座標)。

（1）創建元組

用()表示，空元組用()或tuple()，注意單個元素的元組要加逗號（避免被當作普通括號）：

1. 創建元組

a = () print(type(a)) b = tuple() print(type(b))

2. 創建元組的時候,指定初始值

a = (1,2,3,4) print(a)

3. 元組中的元素也可以是任意類型的

a = (1,2,'hello',True,[]) print(a) 運行項目並下載源碼 python 運行 1 2 3 4 5 6 7 8 9 10 11 12 13 （2）元組的核心操作

支持的操作（和列表一致）：訪問下標、切片、遍歷、in判斷、index查找、+拼接；

不支持的操作（因為不可變）：修改元素、append/insert/pop/remove/extend

4. 通過下標來訪問元組中的元素,下標也是從 0 開始,到 len - 1 結束

a = (1,2,3,4) print(a[1]) print(a[-1])

print(a[100]) # 錯誤

5. 通過切片來獲取元組的一部分

a = [1,2,3,4] print(a[1:3])

6. 也同樣可以使用 for 循環等方式來進行遍歷元素

a = (1,2,3,4) for elem in a: print(elem)

7. 可以使用 in 來判斷元素是否存在,使用 index 查找元素的下標

a = (1,2,3,4) print(3 in a) print(a.index(3))

8. 可以使用 + 來拼接兩個元組

a = (1,2,3) b = (4,5,6) print(a + b)

9. 元組只支持 “讀” 操作,不能支持 “修改” 操作

a = (1,2,3,4)

不支持以下修改的操作

a[0] = 100

a.append(5)

a.pop()

a.extend()

10. 當進行多元賦值的時候,其實本質上是按照元組的方式來進行工作的，

def getPoint(): x = 10 y = 20 return x,y

x,y = getPoint() print(type(getPoint())) 運行項目並下載源碼 python 運行 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

（3）為什麼有了列表，還需要元組？

安全性： 傳遞數據時，用元組可避免數據被意外修改（比如傳給一個未知函數，元組更安全）；

可作為字典的鍵： 後續要學的字典，鍵必須是 “可哈希對象”（不可變類型），元組可以，列表不行。

補充：

2.3 列表的元組小結

結語：不知不覺這篇 Python 相關的分享就到尾聲啦～ 作為一門靈活又實用的語言，Python 的魅力從來都藏在 “上手易、場景廣” 裏 —— 不管是入門時的語法摸索，還是實戰中的問題拆解，每一次代碼跑通的瞬間，都是對 “實踐出真知” 的最好印證。如果這篇內容幫你理清了某個知識點，或是給你的項目開發帶來了一點啓發，歡迎在評論區交流你的心得或疑問～ 後續會持續分享 Python 進階技巧、實戰案例等乾貨，從基礎夯實到場景落地，陪大家一起在編程路上少踩坑、多收穫！ 編程之路漫漫，但熱愛可抵歲月漫長～ 咱們下篇博客見！