【Python】基础语法入门（三）

Yue丶越

发布于 2025-12-17 16:35:03

1610

文章被收录于专栏：C语言C语言

前言

在上一篇基础语法（二）中，我们掌握了条件语句和循环语句，让程序具备了“做选择”和“重复执行”的能力。但随着编程场景变复杂，重复代码会越来越多，比如多次计算不同区间的和、反复校验数据格式，复制粘贴不仅繁琐，后续修改也麻烦。这一篇，我们聚焦Python的核心语法“函数”，从定义、调用到参数传递，一步步解锁代码的“复用与封装”能力，让代码更简洁、更易维护。

一、函数是什么？

在编程中，函数本质是一段可重复使用的代码片段，就像生活中的“工具”，比如锤子可以反复用来钉钉子，函数可以反复用来解决某类问题。

1.1 为什么需要函数？

我们举个例子：计算1-100、300-400、1-1000的和，不使用函数的写法是这样的：

# 计算1-100的和
sum1 = 0
for i in range(1, 101):
    sum1 += i
print(sum1)

# 计算300-400的和
sum2 = 0
for i in range(300, 401):
    sum2 += i
print(sum2)

# 计算1-1000的和
sum3 = 0
for i in range(1, 1001):
    sum3 += i
print(sum3)

可以看到，三段代码逻辑几乎一致，只是参数不同。但如果我们使用函数封装去写的话，我们只需写一次逻辑，后续则可直接调用：

# 定义函数：计算区间[beg, end]的和
def calcSum(beg, end):
    sum_total = 0
    for i in range(beg, end + 1):
        sum_total += i
    return sum_total

# 调用函数：传入不同参数，重复使用逻辑
print(calcSum(1, 100))   # 输出1-100的和
print(calcSum(300, 400)) # 输出300-400的和
print(calcSum(1, 1000))  # 输出1-1000的和

输出结果

5050 35350 500500

函数的核心价值的是：消除重复代码、简化维护、提升可读性，后续若要修改计算逻辑（比如改成求乘积），只需改函数内部，所有调用处都会生效。

1.2 函数的本质

我们可以把函数想象成一个“工厂” ：

输入：函数的参数（原材料）。
处理：函数体中的代码逻辑（加工过程）。
输出：函数的返回值（最终产品）。

二、函数的定义与调用

2.1 函数定义

Python中用def关键字定义函数，语法结构如下：

def 函数名(形参列表):
    函数体  # 缩进4个空格或1个Tab
    return 返回值  # 可选，无返回值可省略

def：固定开头，告诉Python“这里要定义函数了”。
函数名：遵循变量命名规则（字母、数字、下划线，数字不开头），见名知意（如calcSum表示“计算和”）。
形参列表：函数的“输入占位符”，可多个（用逗号分隔）或无（括号留空）。
函数体：核心逻辑，必须要缩进。
return：指定函数的“输出”，执行到return后函数立即结束，无返回值时可省略（默认返回None）。

2. 函数调用

定义函数后不会自动执行，必须“调用”才会触发函数体。调用格式：

# 不接收返回值
函数名(实参列表)

# 接收返回值
结果 = 函数名(实参列表)

关键注意点：

先定义后调用：函数必须在调用前定义，否则会报错。
实参形参匹配：形参有几个，实参就要传几个，个数不匹配也会报错。
动态类型特性：Python的形参无需指定类型，一个函数可接收不同类型的参数。

eg:

def printData(data):
    print(data)

printData(10)    # 传入整数，输出10
printData('hello')# 传入字符串，输出hello
printData(True)  # 传入布尔值，输出True

三、函数的参数与返回值

3.1 参数

形参是函数定义时的“占位符”，实参是调用时实际传入的“数据”，两者的关系就像签合同,“甲方、乙方”是形参，“具体人名”是实参，代入后合同才生效。

示例：多参数函数

# 定义函数：计算两个数的加减乘除
def calc(a, b):
    add = a + b
    sub = a - b
    mul = a * b
    div = a / b
    return add, sub, mul, div

# 调用函数：传入两个实参
add_res, sub_res, mul_res, div_res = calc(10, 2)
print(f"加：{add_res}，减：{sub_res}，乘：{mul_res}，除：{div_res}")

3.2 返回值

返回值是函数处理后的结果，用return语句返回，有3个实用技巧：

多个返回值：用逗号分隔，接收时用多个变量承接（本质返回元组）。
忽略返回值：用_表示不需要的返回值。
提前结束函数：执行到return后，后续代码不再执行。

示例：多返回值与提前结束

# 示例1：返回多个值，忽略不需要的结果
def getPoint():
    x = 10
    y = 20
    z = 30
    return x, y, z

x, _, z = getPoint()  # 忽略y值
print(x, z)  # 输出：10 30

# 示例2：提前结束函数
def isOdd(num):
    if num % 2 == 0:
        return False  # 偶数直接返回，后续代码不执行
    return True  # 奇数返回True

3.3 编程原则

尽量让函数只负责核心逻辑（如计算、判断），不包含用户交互（如print），这样函数的复用性更强。比如计算和的函数，返回结果让调用者决定如何展示（打印、存文件、展示到界面）。

# 推荐：只负责计算，不负责交互
def calcSum(beg, end):
    sum_total = 0
    for i in range(beg, end + 1):
        sum_total += i
    return sum_total

# 调用者决定交互方式
result = calcSum(1, 100)
print(result)  # 打印到控制台
# 可后续扩展：保存到文件、网络传输等

四、变量的作用域

变量有“作用域”限制，即“变量能在哪里使用”，主要分为两种：

局部变量：函数内部定义的变量，仅在函数内生效，出函数后失效。
全局变量：函数外部定义的变量，可在整个文件中使用（函数内可访问，修改需用global声明）。

4.1 局部变量与全局变量的隔离

# 全局变量：函数外部定义
x = 20

def test():
    # 局部变量：函数内部定义，与全局变量同名但互不影响
    x = 10
    print(f"函数内部x：{x}")  # 输出：10

test()
print(f"函数外部x：{x}")  # 输出：20（全局变量未被修改）

4.2 函数内修改全局变量

如果想在函数内修改全局变量的值，必须用global关键字声明，否则会被视为定义局部变量：

x = 20

def test():
    global x  # 声明x是全局变量
    x = 10  # 修改全局变量的值
    print(f"函数内部x：{x}")  # 输出：10

test()
print(f"函数外部x：{x}")  # 输出：10（全局变量已修改）

4.3 注意：语句块不影响作用域

if、while、for等语句块不会隔离变量，块内定义的变量在块外仍可使用：

for i in range(1, 4):
    num = i  # 循环内定义的变量

print(num)  # 输出：3（变量在循环外仍生效）

五、函数的进阶用法：嵌套调用、链式调用与递归

5.1 嵌套调用：函数内部调用其他函数

函数内部可以调用另一个函数，这是编程中常见的逻辑组织方式：

# 定义函数A
def funcA():
    print("执行函数A")

# 定义函数B，内部调用A
def funcB():
    print("执行函数B")
    funcA()  # 嵌套调用funcA
    print("函数B执行完毕")

# 调用funcB
funcB()
# 输出顺序：执行函数B → 执行函数A → 函数B执行完毕

5.2 链式调用：函数返回值作为另一个函数的参数

把一个函数的返回值直接作为另一个函数的参数，简化代码：

# 定义判断奇数的函数
def isOdd(num):
    return num % 2 == 1

# 链式调用：isOdd的返回值作为print的参数
print(isOdd(10))  # 输出：False
print(isOdd(11))  # 输出：True

5.3 递归：函数调用自身（慎用！）

递归是嵌套调用的特殊情况，函数调用自己，适合解决“有明确终止条件、可拆分为子问题”的场景（如阶乘、斐波那契数列）。

示例：递归计算5的阶乘（5! = 5×4×3×2×1）

def factor(n):
    if n == 1:
        return 1  # 终止条件：n=1时返回1
    return n * factor(n - 1)  # 递归调用：n! = n × (n-1)!

print(factor(5))  # 输出：120

递归的注意事项：

必须有终止条件：否则会无限递归，导致栈溢出报错。
调用层数不宜过深：Python默认递归深度约1000层，超过会报错。
优先考虑循环：大部分递归可转换成循环，执行效率更高、更易维护。

六、参数默认值与关键字参数

6.1 参数默认值

定义函数时，可给形参指定默认值，调用时可省略该参数（使用默认值）。核心规则：带默认值的参数必须放在无默认值参数的后面。

示例：带默认值的函数

# 定义函数：计算两个数的和，debug参数默认False（不打印调试信息）
def add(x, y, debug=False):
    if debug:
        print(f"调试：x={x}, y={y}")
    return x + y

# 调用1：省略debug，使用默认值False
print(add(10, 20))  # 输出：30（无调试信息）

# 调用2：指定debug=True，打印调试信息
print(add(10, 20, debug=True))  # 输出：调试：x=10, y=20 → 30

6.2 关键字参数

默认情况下，调用函数时实参按形参顺序传递（位置参数）；也可以用“关键字参数”显式指定参数名，无需遵守顺序，更清晰。

示例：关键字参数的使用

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

# 位置参数：按顺序传递
test(10, 20)  # 输出：x=10, y=20

# 关键字参数：显式指定参数名，顺序可换
test(x=100, y=200)  # 输出：x=100, y=200
test(y=300, x=400)  # 输出：x=400, y=300

函数的核心是“复用与封装”，掌握这篇的知识点：函数的定义与调用、参数与返回值、作用域、默认值与关键字参数，就能大幅简化代码、提升开发效率。至此，我们已梳理完Python基础语法（三）的核心内容了。最后我们在文末来进行一个投个票，告诉我你对哪部分内容最感兴趣、收获最大，也欢迎在评论区聊聊你的学习感受。后续我们还将深入探索列表与元组、字典以及文件操作等内容，敬请关注 , 谢谢！