前言：

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

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

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

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

# 1. 計(jì)算 1-100 的和
theSum = 0
for i in range(1,101):
    theSum = theSum + i
print(theSum)

# 2. 計(jì)算 300-400 的求和
theSum = 0
for i in range(300,401):
    theSum = theSum + i
print(theSum)

# 計(jì)算 1-1000 的和
theSum = 0
for i in range(1,1001):
    theSum = theSum + i
print(theSum)

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

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

函數(shù)版本代碼：

# 使用函數(shù)的方式來(lái)解決剛剛的問(wèn)題

# 定義一個(gè)求和函數(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ù)的核心語(yǔ)法(重點(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í)參個(gè)數(shù)不能多也不能少,除非形參有默認(rèn)參數(shù)
test(10,20,30)

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

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

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

1. 動(dòng)態(tài)類型：形參無(wú)需指定類型，一個(gè)函數(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'))
# # 這個(gè)就肯定不行了.不符合函數(shù)體內(nèi)執(zhí)行邏輯
# print(add(10,'hello'))

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

# 計(jì)算兩數(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í)顯示指定“實(shí)參對(duì)應(yīng)哪個(gè)形參”，可打亂傳參順序

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

 # 關(guān)鍵字參數(shù)，順序無(wú)關(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. 一個(gè)函數(shù)可以有多個(gè) return 語(yǔ)句，執(zhí)行到 return 時(shí)函數(shù)立刻結(jié)束(后續(xù)代碼不執(zhí)行)

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

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

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

2. 一次返回多個(gè)值：用逗號(hào)分隔，接收時(shí)用多個(gè)變量接收(無(wú)需接收的用 _ 忽略)

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

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

(4) 變量作用域

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

• 局部變量：函數(shù)內(nèi)部定義的變量，僅在函數(shù)內(nèi)部生效(出了函數(shù)就失效)；
• 全局變量：函數(shù)外部定義的變量，函數(shù)內(nèi)部可訪問(wèn)，但 修改時(shí)需要用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()

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

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

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

（1）鏈?zhǔn)秸{(diào)用：把一個(gè)函數(shù)的返回值，作為另一個(gè)函數(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中會(huì)使用一個(gè)特定的數(shù)據(jù)結(jié)構(gòu)來(lái)表示，稱為 函數(shù)調(diào)用棧，每次函數(shù)調(diào)用，都會(huì)在調(diào)用棧里新增一個(gè)元素，稱為 棧幀。

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

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

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

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

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

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

# 寫一個(gè)函數(shù),來(lái)求 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 的時(shí)候，遞歸就結(jié)束了。
• 每次遞歸的時(shí)候，要保證函數(shù)的實(shí)參是逐漸逼近結(jié)束條件的。

?? 注意：遞歸代碼簡(jiǎn)潔但難理解，易棧溢出，實(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ù)；
• 核心價(jià)值：復(fù)用代碼，拆分邏輯，讓程序更容易維護(hù)。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

操作目的	代碼示例	說(shuō)明
訪問(wèn)元素	list3[2]	訪問(wèn)下標(biāo) 2 的元素（list3 [2] = 3），下標(biāo)越界報(bà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)，不存在報(bào)異常）
連接列表	list3 + list4	拼接兩個(gè)列表（生成新列表）；list3.extend(list4)（拼接到 list3 末尾，修改原列表）
遍歷元素	for elem in list3:	直接遍歷元素（推薦）；也可按下標(biāo)遍歷（for i in range(len(list3))）

• 下標(biāo)訪問(wèn)：

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

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

# 7. 超出下標(biāo)有效范圍,就會(huì)出現(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 來(lái)獲取列表的長(zhǎng)度(元素個(gè)數(shù)),和字符串類似
a = [1,2,3,4]
print(len(a))

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

• 循環(huán)遍歷：

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

# print(a)

# 2. 使用 for 循環(huán)遍歷,通過(guò)下標(biāo)的方式
# 會(huì)改變?cè)瓉?lái)的數(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),通過(guò)下標(biāo)遍歷這個(gè)列表
a = [1,2,3,4,5]
i = 0
while i < len(a):
    print(a[i])
    i += 1

• 增刪查改 && 連接等：

# 1. 使用 append 往列表末尾新增一個(gè)元素
# 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 方法，往列表的任意位置來(lái)新增元素
a = [1,2,3,4]
a.insert(1,"hello")
a.insert(100,"hello") # 會(huì)在最后插入一個(gè) hello
print(a)

# 1. 使用 in 來(lái)判定某個(gè)元素是否在列表中存在
# 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 方法,來(lái)判定當(dāng)前元素在列表中的位置,得到一個(gè)下標(biāo)
a = [1,2,3,4]
print(a.index(2))
print(a.index(3))
# print(a.index(10)) # 會(huì)報(bào)錯(cuò)

# 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 方法,可以按照值來(lái)進(jìn)行刪除
a = ["aa","bb","cc","dd"]
a.remove("cc")
print(a)

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

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

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

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

# 2. 使用切片的時(shí)候,可以省略邊界
a = [1,2,3,4]
# 省略右邊界,意思是從指定的開始位置,一直取到整個(gè)列表結(jié)束
print(a[1:])
# 省略左邊界,意思是從列表的 0 號(hào)元素開始取,一直取到指定的結(jié)束位置
print(a[:2])
# 此處切邊中的下標(biāo)也可以寫成負(fù)數(shù)
print(a[:-1])
# 還可以把開始邊界和結(jié)束邊界都省掉,得到的就還是列表本身
print(a[:])

# 3. 帶有步長(zhǎng)的切片操作
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. 步長(zhǎng)的數(shù)值還可以是負(fù)數(shù),當(dāng)步長(zhǎng)為負(fù)數(shù)的時(shí)候,意思是從后往前來(lái)取元素
a = [1,2,3,4,5,6,7,8,9,0]
print(a[::-1])
print(a[::-2])

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

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

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

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

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

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

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

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

（2）元組的核心操作

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

# 4. 通過(guò)下標(biāo)來(lái)訪問(wèn)元組中的元素,下標(biāo)也是從 0 開始,到 len - 1 結(jié)束
a = (1,2,3,4)
print(a[1])
print(a[-1])
# print(a[100]) # 錯(cuò)誤

# 5. 通過(guò)切片來(lái)獲取元組的一部分
a = [1,2,3,4]
print(a[1:3])

# 6. 也同樣可以使用 for 循環(huán)等方式來(lái)進(jìn)行遍歷元素
a = (1,2,3,4)
for elem in a:
    print(elem)

# 7. 可以使用 in 來(lái)判斷元素是否存在,使用 index 查找元素的下標(biāo)
a = (1,2,3,4)
print(3 in a)
print(a.index(3))

# 8. 可以使用 + 來(lái)拼接兩個(gè)元組
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í)候,其實(shí)本質(zhì)上是按照元組的方式來(lái)進(jìn)行工作的，
def getPoint():
    x = 10
    y = 20
    return x,y

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