前言：

作為 Python 初學(xué)者，掌握函數(shù)、列表、元組是從 “寫代碼” 到 “寫好代碼” 的關(guān)鍵一步。它們不僅是 Python 語法的核心，更是后續(xù)處理復(fù)雜數(shù)據(jù)、構(gòu)建高效程序的基礎(chǔ)。今天這篇文章，就結(jié)合入門實(shí)戰(zhàn)案例，把這三個知識點(diǎn)講透，新手也能一看就會、一用就通。

一. 函數(shù)：告別重復(fù)代碼的 “代碼工廠”

1.1 為什么需要函數(shù)？

寫代碼最忌諱的就是 “復(fù)制粘貼”。比如計算不同區(qū)間的數(shù)列和（1-100、300-400、1-1000），如果不使用函數(shù)，需要重復(fù)寫多組幾乎一樣的循環(huán)代碼：

# 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)

一旦需要修改計算邏輯（比如改成求平方和），所有重復(fù)代碼都要改，效率極低。而函數(shù)的核心作用，就是提取重復(fù)代碼，實(shí)現(xiàn)代碼復(fù)用，讓程序更簡潔、更好維護(hù)。

簡單理解：函數(shù)就像一個 “工廠”，輸入 “原材料”（參數(shù)），經(jīng)過內(nèi)部加工（函數(shù)體），輸出 “產(chǎn)品”（返回值），一次定義，多次調(diào)用。

函數(shù)版本代碼：

# 使用函數(shù)的方式來解決剛剛的問題

# 定義一個求和函數(shù)
def calcSum(begin,end):
    theSum = 0
    for i in range(begin,end+1):
        theSum = theSum + i
    print(theSum)

# 使用函數(shù)
# 求 1-100 的和
calcSum(1,100)
# 求 300-400 的和
calcSum(300,400)
# 求 1-1000 的和
calcSum(1,1000)

1.2 函數(shù)的核心語法(重點(diǎn))

（1）函數(shù)定義與調(diào)用

# 1. 定義函數(shù)：def 函數(shù)名(形參列表): 函數(shù)體 return 返回值
def calcsum(beg, end):  # beg、end是“形式參數(shù)”（形參），相當(dāng)于工廠的“原材料入口”
    sum = 0
    for i in range(beg, end + 1):
        sum += i
    return sum  # return 輸出結(jié)果，相當(dāng)于工廠的“產(chǎn)品出口”

# 2. 調(diào)用函數(shù)：函數(shù)名(實(shí)參列表)
result1 = calcsum(1, 100)  # 1、100是“實(shí)際參數(shù)”（實(shí)參），是真正傳入的原材料
result2 = calcsum(300, 400)
print(result1, result2)  # 輸出：5050 35150

def test(a,b,c):
    print(a,b,c)

# 實(shí)參個數(shù)不能多也不能少,除非形參有默認(rèn)參數(shù)
test(10,20,30)

?? 關(guān)鍵注意點(diǎn)：

• 函數(shù)必須先定義，再調(diào)用(就像動漫里“先喊招式名，再釋放技能”)，否則會報 NameError；
• 定義函數(shù)時不會執(zhí)行函數(shù)體，只要調(diào)用時才會執(zhí)行，調(diào)用幾次就執(zhí)行幾次；
• 形參和實(shí)參的個數(shù)必須匹配(比如定義時 2 個形參，調(diào)用時就必須傳 2 個實(shí)參)，否則報 TypeError；

(2) 函數(shù)參數(shù)的靈活用法
Python 的函數(shù)參數(shù)比C++，Java更靈活，核心有 3 個特性：

1. 動態(tài)類型：形參無需指定類型，一個函數(shù)可接收多種類型參數(shù)

def print_param(a):
    print(a)
print_param(10)    # 整數(shù)
print_param("hello")# 字符串
print_param(True)   # 布爾值（均能正常執(zhí)行）

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

print(add(10,20))
print(add(1.5,2.5))
print(add('hello','world'))
# # 這個就肯定不行了.不符合函數(shù)體內(nèi)執(zhí)行邏輯
# print(add(10,'hello'))

2. 參數(shù)默認(rèn)值：給形參指針默認(rèn)值，調(diào)用時可省略該參數(shù)(默認(rèn)值參數(shù)必須在無默認(rèn)值參數(shù)后面)

# 計算兩數(shù)之和，默認(rèn)不打印調(diào)試信息
def add(x, y, debug=False):
    if debug:
        print(f"調(diào)試：x={x}, y={y}")
    return x + y
print(add(10, 20))        # 省略debug，使用默認(rèn)值False
print(add(10, 20, True))  # 顯式傳參，打印調(diào)試信息

3. 關(guān)鍵字參數(shù)：調(diào)用時顯示指定“實(shí)參對應(yīng)哪個形參”，可打亂傳參順序

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

 # 關(guān)鍵字參數(shù)，順序無關(guān)，輸出: x = 10,y = 20;
test(x = 10,y = 20) 
test(y = 100,x = 200)
test(100,y = 200)

# 這樣寫就不行了
# test(x = 100,200)

(3) 函數(shù)返回值

返回值是函數(shù)的 “輸出”，核心用法有兩點(diǎn)：

1. 一個函數(shù)可以有多個 return 語句，執(zhí)行到 return 時函數(shù)立刻結(jié)束(后續(xù)代碼不執(zhí)行)

# 這種情況不算是有多個 return 語句
# def tes():
#     return 1
#     return 2

# 一般情況下多個 return 語句是搭配 分支語句/循環(huán)語句 的
# 用來判斷 num 是不是奇數(shù)
def isOdd(num):
    if num % 2 == 0:
        return False
    else:
        return True

print(isOdd(10))
print(isOdd(19))

2. 一次返回多個值：用逗號分隔，接收時用多個變量接收(無需接收的用 _ 忽略)

# 寫一個函數(shù), 返回平面上的一個點(diǎn)
# 橫坐標(biāo),縱坐標(biāo)
def getPoint():
    x = 10
    y = 20
    return x,y

# 可以返回兩個值
# a,b = getPoint()  # 接收所有返回值
# 如果只想用其中一個可以使用 _ 占位
# _,b=getPoint()    # 忽略x,只接收y

(4) 變量作用域

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

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

x = 10

def test():
    x = 20
    print(f'函數(shù)內(nèi)部:{x}')

test()
print(f'函數(shù)外部:{x}')

x = 10

# 全局變量在函數(shù)里也可以使用
# def test():
#     print(f'x = {x}')
#
# test()

# 使用這個函數(shù),把全局變量 x 給改成 20!
def test():
    global x
    x = 20

test()
print(f'x = {x}')

1.3 函數(shù)的進(jìn)階用法（嵌套 + 遞歸）

（1）鏈?zhǔn)秸{(diào)用：把一個函數(shù)的返回值，作為另一個函數(shù)的參數(shù)

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))))

（2）嵌套調(diào)用：函數(shù)內(nèi)部調(diào)用其他函數(shù)（包括自身）

def test():
    print("hello")


test()

# 嵌套調(diào)用可以有很多層

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


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

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

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

d()

函數(shù)之間的調(diào)用關(guān)系，在Python中會使用一個特定的數(shù)據(jù)結(jié)構(gòu)來表示，稱為 函數(shù)調(diào)用棧，每次函數(shù)調(diào)用，都會在調(diào)用棧里新增一個元素，稱為 棧幀。

• 可以通過 PyCharm 調(diào)試器看到函數(shù)調(diào)用棧和棧幀。
• 在調(diào)試狀態(tài)下，PyCharm 左下角一般就會顯示出函數(shù)調(diào)用棧。

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

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

（3）遞歸調(diào)用：函數(shù)調(diào)用自身(慎用!)

遞歸是嵌套調(diào)用的特使情況，核心是"有結(jié)束條件 + 每次逼近結(jié)束條件"，否則會無限遞歸導(dǎo)致 RecursionError

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

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

# 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))

• 務(wù)必存在遞歸結(jié)束條件，比如 if n == 1 就是結(jié)束條件。當(dāng) n 為 1 的時候，遞歸就結(jié)束了。
• 每次遞歸的時候，要保證函數(shù)的實(shí)參是逐漸逼近結(jié)束條件的。

?? 注意：遞歸代碼簡潔但難理解，易棧溢出，實(shí)際開發(fā)中優(yōu)先用循環(huán)替代。

1.4 函數(shù)核心小結(jié)

掌握 3 點(diǎn)，搞定 Python 函數(shù)：

• 定義：def 函數(shù)名(形參)：函數(shù)體 return 返回值；
• 調(diào)用：函數(shù)名(實(shí)參)，支持默認(rèn)值，關(guān)鍵字參數(shù)；
• 核心價值：復(fù)用代碼，拆分邏輯，讓程序更容易維護(hù)。

二. 列表和元組：批量存儲數(shù)據(jù)的 “容器”

當(dāng)需要存儲多個數(shù)據(jù)（比如10個學(xué)生的成績，20個城市名）時，單獨(dú)定義多個變量不現(xiàn)實(shí)，此時就需要列表（list）和元組（tuple）—— 它們是 Python 中最常用的 “序列類型”，專門用來批量存儲數(shù)據(jù)。

核心區(qū)別（一句話記牢）：

• 列表（list）：可變?nèi)萜鳎ㄏ?“散裝辣條”），元素可增刪改；
• 元組（tuple）：不可變?nèi)萜鳎ㄏ?“包裝辣條”），元素創(chuàng)建后無法修改。

2.1 列表（list）：最常用的可變?nèi)萜?/h3>

（1）創(chuàng)建列表

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

# 創(chuàng)建列表
# 1. 直接使用字面值來創(chuàng)建
#    [] 就表示一個 空的列表
a = []
print(type(a))

# 2. 使用 list() 來創(chuàng)建
b = list()
print(type(b))

# 3. 可以在創(chuàng)建列表的時候,在[]中指定列表的初始值
# 元素之間使用 , 來分割
a = [1,2,3,4]
print(a)

# 4. 可以在同一個列表里放不同類型的變量
a = [1,'hello',True,[4,5,6]]
print(a)

?? 注意：不要用 list 作為變量名(會覆蓋內(nèi)置函數(shù) list())，建議命名為 list1，alist 等。

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

列表的操作都圍繞 “下標(biāo)” 展開，下標(biāo)從 0 開始（負(fù)數(shù)表示倒數(shù)，-1 是最后一個元素），核心操作如下：

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

• 下標(biāo)訪問：

# 5. 使用下標(biāo)來訪問列表元素
a = [1,2,3,4]
print(a[2]) # 3

# 6. 使用下標(biāo)來修改列表元素
a = [1,2,3,4]
a[2] = 100
print(a)

# 7. 超出下標(biāo)有效范圍,就會出現(xiàn)異常
# 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 <module>
#     a[100] = 0
#     ~^^^^^
# IndexError: list assignment index out of range


# 8. 可以使用內(nèi)建函數(shù) len 來獲取列表的長度(元素個數(shù)),和字符串類似
a = [1,2,3,4]
print(len(a))

# 9. Python 中的下標(biāo),其實(shí)還可以寫成負(fù)數(shù)!!!
# 例如寫成 -1,其實(shí)等價于 len(a) - 1
a = [1,2,3,4]
print(a[len(a) - 1])
# -1 就是倒數(shù)第一個元素
print(a[-1])

• 循環(huán)遍歷：

# 1. 使用 for 循環(huán)來遍歷列表
# 不會改變原來的數(shù)組
# a = [1,2,3,4,5]
# for elem in a:
#     elem = elem + 10
#     print(elem)

# print(a)

# 2. 使用 for 循環(huán)遍歷,通過下標(biāo)的方式
# 會改變原來的數(shù)組
# a = [1,2,3,4,5]
# for i in range(0,len(a)):
#     a[i] = a[i] + 10
#
# print(a)

# 3. 使用 while 循環(huán),通過下標(biāo)遍歷這個列表
a = [1,2,3,4,5]
i = 0
while i < len(a):
    print(a[i])
    i += 1

• 增刪查改 && 連接等：

# 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)

# 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 方法,來判定當(dāng)前元素在列表中的位置,得到一個下標(biāo)
a = [1,2,3,4]
print(a.index(2))
print(a.index(3))
# print(a.index(10)) # 會報錯

# 1. 使用 pop 刪除列表中的最末尾的元素
a = [1,2,3,4]
a.pop()
print(a)

# 2. 使用 pop 還能刪除任意位置的元素,pop的參數(shù)
a = [1,2,3,4]
a.pop(1)
print(a)

# 3. 使用 remove 方法,可以按照值來進(jìn)行刪除
a = ["aa","bb","cc","dd"]
a.remove("cc")
print(a)

# 1. 使用 + 針對兩個列表進(jìn)行拼接
# 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 來進(jìn)行拼接
#    這個拼接是把后一個列表的內(nèi)容拼接到前一個列表里頭
# a = [1,2,3,4]
# b = [5,6,7,8]
# c = a.extend(b) # extend 不返回任何內(nèi)容
# a.extend(b)
# print(a) # a 這里改變了
# print(b)

# 3. 使用 += 來進(jìn)行拼接
a = [1,2,3,4]
b = [5,6,7,8]
a += b  # a = a + b
print(a)
print(b)

（3）切片操作的靈活用法(重點(diǎn))

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

# 1. 切片操作的基本使用
a = [1,2,3,4]
# 左閉右開區(qū)間
print(a[1:3])

# 2. 使用切片的時候,可以省略邊界
a = [1,2,3,4]
# 省略右邊界,意思是從指定的開始位置,一直取到整個列表結(jié)束
print(a[1:])
# 省略左邊界,意思是從列表的 0 號元素開始取,一直取到指定的結(jié)束位置
print(a[:2])
# 此處切邊中的下標(biāo)也可以寫成負(fù)數(shù)
print(a[:-1])
# 還可以把開始邊界和結(jié)束邊界都省掉,得到的就還是列表本身
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. 步長的數(shù)值還可以是負(fù)數(shù),當(dāng)步長為負(fù)數(shù)的時候,意思是從后往前來取元素
a = [1,2,3,4,5,6,7,8,9,0]
print(a[::-1])
print(a[::-2])

# 5. 當(dāng)切片中的范圍超出有效下標(biāo)之后,不會出現(xiàn)異常!,而是盡可能的把符合要求的元素給獲取到
a = [1,2,3,4,5,6,7,8,9,0]
print(a[1:100])

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

元組的用法和列表幾乎一致，但核心區(qū)別是"不可變"(元素?zé)o法增刪改)，適合存儲不需要修改的數(shù)據(jù)(比如身份證號，坐標(biāo))。

（1）創(chuàng)建元組

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

# 1. 創(chuàng)建元組
a = ()
print(type(a))
b = tuple()
print(type(b))

# 2. 創(chuàng)建元組的時候,指定初始值
a = (1,2,3,4)
print(a)

# 3. 元組中的元素也可以是任意類型的
a = (1,2,'hello',True,[])
print(a)

（2）元組的核心操作

• 支持的操作（和列表一致）：訪問下標(biāo)、切片、遍歷、in判斷、index查找、+拼接；
• 不支持的操作（因?yàn)椴豢勺儯?/strong>：修改元素、append/insert/pop/remove/extend

# 4. 通過下標(biāo)來訪問元組中的元素,下標(biāo)也是從 0 開始,到 len - 1 結(jié)束
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 循環(huán)等方式來進(jìn)行遍歷元素
a = (1,2,3,4)
for elem in a:
    print(elem)

# 7. 可以使用 in 來判斷元素是否存在,使用 index 查找元素的下標(biāo)
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. 當(dāng)進(jìn)行多元賦值的時候,其實(shí)本質(zhì)上是按照元組的方式來進(jìn)行工作的，
def getPoint():
    x = 10
    y = 20
    return x,y

x,y = getPoint()
print(type(getPoint()))