Python-函数

Python 中可以使用def关键字来定义函数。

函数定义规则：

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
• 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
• 函数内容以冒号 : 起始，并且缩进。
• return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None。

def greet(name):
    """这是一个简单的问候函数"""
    print(f"Hello, {name}!")

# 示例调用
greet("Alice")  # 输出: Hello, Alice!

函数的参数

写一个函数，根据给出的三条边的长度判断是否可以构成三角形，如果可以构成三角形则返回True，否则返回False

def make_judgement(a, b, c):
    """判断三条边的长度能否构成三角形"""
    return a + b > c and b + c > a and a + c > b

print(make_judgement(1, 2, 3))  # False
print(make_judgement(4, 5, 6))  # True

如果不想按照从左到右的顺序依次给出a、b、c 三个参数的值，也可以使用关键字参数，通过“参数名=参数值”的形式为函数传入参数。

print(make_judgement(b=2, c=3, a=1))  # False
print(make_judgement(c=6, b=4, a=5))  # True

在定义函数时，我们可以在参数列表中用/设置强制位置参数（positional-only arguments），用*设置命名关键字参数。所谓强制位置参数，就是调用函数时只能按照参数位置来接收参数值的参数；而命名关键字参数只能通过“参数名=参数值”的方式来传递和接收参数

# /前面的参数是强制位置参数
def make_judgement(a, b, c, /):
    """判断三条边的长度能否构成三角形"""
    return a + b > c and b + c > a and a + c > b


# 下面的代码会产生TypeError错误，错误信息提示“强制位置参数是不允许给出参数名的”
# TypeError: make_judgement() got some positional-only arguments passed as keyword arguments
# print(make_judgement(b=2, c=3, a=1))

说明：强制位置参数是 Python 3.8 引入的新特性，在使用低版本的 Python 解释器时需要注意。

# *后面的参数是命名关键字参数
def make_judgement(*, a, b, c):
    """判断三条边的长度能否构成三角形"""
    return a + b > c and b + c > a and a + c > b


# 下面的代码会产生TypeError错误，错误信息提示“函数没有位置参数但却给了3个位置参数”
# TypeError: make_judgement() takes 0 positional arguments but 3 were given
# print(make_judgement(1, 2, 3))

参数的默认值

Python 中允许函数的参数拥有默认值，带默认值的参数必须放在不带默认值的参数之后

from random import randrange

# 定义摇色子的函数
# 函数的自变量（参数）n表示色子的个数，默认值为2
# 函数的因变量（返回值）表示摇n颗色子得到的点数
def roll_dice(n=2):
    total = 0
    for _ in range(n):
        total += randrange(1, 7)
    return total

# 如果没有指定参数，那么n使用默认值2，表示摇两颗色子
print(roll_dice())
# 传入参数3，变量n被赋值为3，表示摇三颗色子获得点数
print(roll_dice(3))

def add(a=0, b=0, c=0):
    """三个数相加求和"""
    return a + b + c


# 调用add函数，没有传入参数，那么a、b、c都使用默认值0
print(add())         # 0
# 调用add函数，传入一个参数，该参数赋值给变量a, 变量b和c使用默认值0
print(add(1))        # 1
# 调用add函数，传入两个参数，分别赋值给变量a和b，变量c使用默认值0
print(add(1, 2))     # 3
# 调用add函数，传入三个参数，分别赋值给a、b、c三个变量
print(add(1, 2, 3))  # 6

可变参数

Python 语言中可以通过星号表达式语法让函数支持可变参数。所谓可变参数指的是在调用函数时，可以向函数传入0个或任意多个参数。

# 用星号表达式来表示args可以接收0个或任意多个参数
# 调用函数时传入的n个参数会组装成一个n元组赋给args
# 如果一个参数都没有传入，那么args会是一个空元组
def add(*args):
    total = 0
    # 对保存可变参数的元组进行循环遍历
    for val in args:
        # 对参数进行了类型检查（数值型的才能求和）
        if type(val) in (int, float):
            total += val
    return total


# 在调用add函数时可以传入0个或任意多个参数
print(add())         # 0
print(add(1))        # 1
print(add(1, 2, 3))  # 6
print(add(1, 2, 'hello', 3.45, 6))  # 12.45

如果我们希望通过“参数名=参数值”的形式传入若干个参数，具体有多少个参数也是不确定的，我们还可以给函数添加可变关键字参数，把传入的关键字参数组装到一个字典中，

# 参数列表中的**kwargs可以接收0个或任意多个关键字参数
# 调用函数时传入的关键字参数会组装成一个字典（参数名是字典中的键，参数值是字典中的值）
# 如果一个关键字参数都没有传入，那么kwargs会是一个空字典
def foo(*args, **kwargs):
    print(args)
    print(kwargs)

foo(3, 2.1, True, name='测试', age=43, gpa=4.95)

用模块管理函数

import关键字导入指定的模块再使用完全限定名（模块名.函数名）的调用方式

module1.py

def foo():
    print('hello, world!')

module2.py

def foo():
    print('goodbye, world!')

test.py

import module1
import module2

# 用“模块名.函数名”的方式（完全限定名）调用函数，
module1.foo()  # hello, world!
module2.foo()  # goodbye, world!

在导入模块时，还可以使用as关键字对模块进行别名，这样我们可以使用更为简短的完全限定名。

test.py

import module1 as m1
import module2 as m2

m1.foo()  # hello, world!
m2.foo()  # goodbye, world!

标准库中的模块和函数

Python 标准库中提供了大量的模块和函数来简化我们的开发工作，我们之前用过的random模块就为我们提供了生成随机数和进行随机抽样的函数；而time模块则提供了和时间操作相关的函数；我们之前用到过的math模块中还包括了计算正弦、余弦、指数、对数等一系列的数学函数。随着我们深入学习 Python 语言，我们还会用到更多的模块和函数。

Python 标准库中还有一类函数是不需要import就能够直接使用的，我们将其称之为内置函数，这些内置函数不仅有用而且还很常用，下面的表格列出了一部分的内置函数。

# 内置函数综合案例：学生成绩管理系统

def student_grade_system():
    """学生成绩管理系统演示各种内置函数的使用"""

    print("=== 学生成绩管理系统 ===")

    # 1. abs - 计算成绩差值的绝对值
    score1 = 85
    score2 = 92
    diff = abs(score1 - score2)
    print(f"\n1. 两位学生成绩差值的绝对值: {diff}")

    # 2. bin/hex/oct - 显示学生ID的不同进制表示
    student_id = 123
    print(f"\n2. 学生ID {student_id} 的不同表示:")
    print(f"二进制: {bin(student_id)}")
    print(f"十六进制: {hex(student_id)}")
    print(f"八进制: {oct(student_id)}")

    # 3. chr/ord - 处理特殊字符
    grade_symbol = 'A'
    print(f"\n3. 等级符号 '{grade_symbol}' 的Unicode码: {ord(grade_symbol)}")
    print(f"Unicode码65对应的字符: {chr(65)}")

    # 4. input - 获取学生姓名
    name = input("\n4. 请输入学生姓名: ")

    # 5. len - 计算姓名长度
    print(f"姓名长度: {len(name)}")

    # 6. max/min/sum - 计算成绩统计
    grades = [85, 92, 78, 90, 88]
    print(f"\n5. 成绩统计 - 班级成绩: {grades}")
    print(f"最高分: {max(grades)}")
    print(f"最低分: {min(grades)}")
    print(f"平均分: {sum(grades) / len(grades):.2f}")

    # 7. pow - 计算加权成绩
    base_score = 80
    weight = 1.2
    weighted_score = pow(base_score, weight)
    print(f"\n6. 基础分 {base_score} 的加权分(权重1.2): {weighted_score:.2f}")

    # 8. range - 生成学号序列
    print("\n7. 生成的学号序列:")
    for id in range(2023001, 2023006):
        print(id, end=' ')

    # 9. round - 四舍五入平均分
    avg = sum(grades) / len(grades)
    print(f"\n\n8. 精确到小数点后2位的平均分: {round(avg, 2)}")

    # 10. type - 检查数据类型
    print("\n9. 数据类型检查:")
    print(f"grades的类型: {type(grades)}")
    print(f"name的类型: {type(name)}")

    # 11. open - 写入学生数据到文件
    print("\n10. 将学生数据写入文件...")
    with open('student_data.txt', 'w', encoding='utf-8') as f:
        f.write(f"学生姓名: {name}\n")
        f.write(f"学生成绩: {grades}\n")
        f.write(f"平均分: {avg:.2f}\n")
    print("数据已写入student_data.txt文件")


# 运行学生成绩管理系统
student_grade_system()

函数应用实战

例子1：随机验证码

设计一个生成随机验证码的函数，验证码由数字和英文大小写字母构成，长度可以通过参数设置。

import random
import string

# 生成一个随机字符串 ，长度为10 ，由数字和字母组成
ALL_CHAR = string.digits + string.ascii_letters;

def generate_code(*,code_len=4):
    """
        生成指定长度的验证码
        :param code_len: 验证码的长度(默认4个字符)
        :return: 由大小写英文字母和数字构成的随机验证码字符串
        random.choice(ALL_CHAR,k=code_len) 从ALL_CHAR中随机选择k个字符
    """
    return ''.join(random.choices(ALL_CHAR,k=code_len))

for _ in range(5):
    print(generate_code(code_len=10))

例子2：判断素数

设计一个判断给定的大于1的正整数是不是质数的函数。质数是只能被1和自身整除的正整数（大于1），如果一个大于 1 的正整数 N 是质数，那就意味着在 2 到 N-1 之间都没有它的因子。

def is_prime(num: int) -> bool:
    """
    判断一个正整数是不是质数
    :param num: 大于1的正整数
    :return: 如果num是质数返回True，否则返回False
    """
    for i in range(2, int(num ** 0.5) + 1):
        if num % i == 0:
            return False
    return True

说明1：上面is_prime函数的参数num后面的: int用来标注参数的类型，虽然它对代码的执行结果不产生任何影响，但是很好的增强了代码的可读性。同理，参数列表后面的-> bool用来标注函数返回值的类型，它也不会对代码的执行结果产生影响，但是却让我们清楚的知道，调用函数会得到一个布尔值，要么是True，要么是False。

说明2：上面的循环并不需要从 2 循环到 N-1 ，因为如果循环进行到 N 时，还没有找到$\small{N}$的因子，那么 N 之后也不会出现 N 的因子，大家可以自己想一想这是为什么。

例子3：最大公约数和最小公倍数

设计计算两个正整数最大公约数和最小公倍数的函数。 x 和 y 的最大公约数是能够同时整除 x 和 y 的最大整数，如果 x 和 y 互质，那么它们的最大公约数为 1； x 和 y 的最小公倍数是能够同时被 x 和 y 整除的最小正整数，如果 x 和 y 互质，那么它们的最小公倍数为 x×y 。需要提醒大家注意的是，计算最大公约数和最小公倍数是两个不同的功能，应该设计成两个函数，而不是把两个功能放到同一个函数中。

def lcm(x: int, y: int) -> int:
    """求最小公倍数"""
    return x * y // gcd(x, y)


def gcd(x: int, y: int) -> int:
    """求最大公约数"""
    while y % x != 0:
        x, y = y % x, x
    return x