我要评论第6篇：函数定义与使用
函数概述
函数是组织好的、可重复使用的、用来实现单一或相关联功能的代码段。函数能够提高应用的模块性，和代码的重复利用率。
函数的优点
- 代码重用：避免重复编写相同功能的代码
- 模块化：将复杂问题分解为更小的部分
- 可维护性：修改功能时只需修改函数定义
- 可读性：使代码结构更清晰，易于理解
函数定义
在python中使用def关键字定义函数。
基本语法
def 函数名(参数列表):
"""文档字符串（可选）"""
函数体
return 返回值 # 可选
简单函数示例
# 定义一个简单的函数
def greet():
"""打印问候语"""
print("hello, world!")
# 调用函数
greet() # 输出：hello, world!
# 带参数的函数
def greet_person(name):
"""向指定的人问好"""
print(f"hello, {name}!")
greet_person("张三") # 输出：hello, 张三!
greet_person("李四") # 输出：hello, 李四!函数调用
调用函数时需要使用函数名后跟圆括号，圆括号中可以包含传递给函数的参数。
基本调用
# 定义函数
def say_hello():
print("hello!")
# 调用函数
say_hello() # 输出：hello!
# 多次调用
say_hello() # 输出：hello!
say_hello() # 输出：hello!函数调用的过程
def calculate_sum(a, b):
"""计算两个数的和"""
result = a + b
return result
# 调用函数并保存返回值
sum_result = calculate_sum(10, 20)
print(sum_result) # 输出：30
# 直接使用函数返回值
print(calculate_sum(5, 15)) # 输出：20函数参数
函数参数允许我们向函数传递数据，使函数更加灵活。
位置参数
def introduce(name, age):
"""介绍一个人"""
print(f"我叫{name}，今年{age}岁")
# 按位置传递参数
introduce("张三", 25) # 输出：我叫张三，今年25岁
# 参数顺序很重要
introduce(25, "张三") # 输出：我叫25，今年张三岁（逻辑错误）关键字参数
def introduce(name, age):
"""介绍一个人"""
print(f"我叫{name}，今年{age}岁")
# 使用关键字参数，顺序可以改变
introduce(age=25, name="张三") # 输出：我叫张三，今年25岁
# 混合使用位置参数和关键字参数
introduce("李四", age=30) # 输出：我叫李四，今年30岁
# 注意：位置参数必须在关键字参数之前
# introduce(age=30, "李四") # 错误！默认参数
def greet(name, greeting="hello"):
"""问候函数，默认问候语为hello"""
print(f"{greeting}, {name}!")
# 使用默认参数
greet("张三") # 输出：hello, 张三!
# 覆盖默认参数
greet("李四", "你好") # 输出：你好, 李四!
greet("王五", greeting="hi") # 输出：hi, 王五!可变参数
# *args：接收任意数量的位置参数
def sum_all(*args):
"""计算所有参数的和"""
total = 0
for num in args:
total += num
return total
print(sum_all(1, 2, 3)) # 输出：6
print(sum_all(1, 2, 3, 4, 5)) # 输出：15
# **kwargs：接收任意数量的关键字参数
def print_info(**kwargs):
"""打印所有关键字参数"""
for key, value in kwargs.items():
print(f"{key}: {value}")
print_info(name="张三", age=25, city="北京")
# 输出：
# name: 张三
# age: 25
# city: 北京参数组合使用
def complex_function(a, b=10, *args, **kwargs):
"""复杂的参数组合示例"""
print(f"位置参数a: {a}")
print(f"默认参数b: {b}")
print(f"可变位置参数args: {args}")
print(f"可变关键字参数kwargs: {kwargs}")
# 调用函数
complex_function(1, 2, 3, 4, 5, name="张三", age=25)
# 输出：
# 位置参数a: 1
# 默认参数b: 2
# 可变位置参数args: (3, 4, 5)
# 可变关键字参数kwargs: {'name': '张三', 'age': 25}返回值
函数可以使用return语句返回值。
基本返回值
def add(a, b):
"""计算两个数的和"""
return a + b
result = add(10, 20)
print(result) # 输出：30
# 函数可以返回任意类型的值
def get_user_info():
"""返回用户信息"""
return {"name": "张三", "age": 25}
user = get_user_info()
print(user) # 输出：{'name': '张三', 'age': 25}返回多个值
def calculate(a, b):
"""计算两个数的和与积"""
sum_result = a + b
product_result = a * b
return sum_result, product_result
# 接收多个返回值
sum_val, product_val = calculate(3, 4)
print(f"和：{sum_val}，积：{product_val}") # 输出：和：7，积：12
# 也可以作为元组接收
result = calculate(3, 4)
print(result) # 输出：(7, 12)无返回值的函数
def print_message(message):
"""打印消息"""
print(message)
# 没有return语句，隐式返回none
result = print_message("hello")
print(result) # 输出：none变量作用域
变量的作用域决定了变量在程序中的可见范围。
局部变量
def my_function():
"""演示局部变量"""
local_var = "我是局部变量"
print(local_var)
my_function()
# print(local_var) # 错误：局部变量在函数外部不可访问全局变量
global_var = "我是全局变量"
def access_global():
"""访问全局变量"""
print(global_var) # 可以访问全局变量
access_global()
print(global_var) # 在全局作用域也可以访问
def modify_global():
"""修改全局变量"""
global global_var # 声明使用全局变量
global_var = "我被修改了"
print(global_var)
modify_global()
print(global_var) # 输出：我被修改了嵌套函数中的变量作用域
def outer_function():
"""外层函数"""
outer_var = "外层变量"
def inner_function():
"""内层函数"""
inner_var = "内层变量"
print(f"在内层函数中访问外层变量：{outer_var}")
print(f"内层变量：{inner_var}")
inner_function()
# print(inner_var) # 错误：内层变量在外层函数中不可访问
outer_function()nonlocal关键字
def outer_function():
"""演示nonlocal关键字"""
x = 10
def inner_function():
nonlocal x # 声明使用外层函数的变量
x += 5
print(f"内层函数中的x：{x}")
print(f"调用内层函数前的x：{x}")
inner_function()
print(f"调用内层函数后的x：{x}")
outer_function()
# 输出：
# 调用内层函数前的x：10
# 内层函数中的x：15
# 调用内层函数后的x：15匿名函数
匿名函数是不带名称的函数，使用lambda关键字定义。
基本语法
lambda 参数: 表达式
简单示例
# 定义匿名函数
square = lambda x: x ** 2
print(square(5)) # 输出：25
# 匿名函数用于简单计算
add = lambda x, y: x + y
print(add(3, 4)) # 输出：7
# 匿名函数用于字符串操作
upper_case = lambda s: s.upper()
print(upper_case("hello")) # 输出：hello匿名函数的应用
# 与内置函数结合使用
numbers = [1, 2, 3, 4, 5]
# 使用map函数和lambda
squared = list(map(lambda x: x ** 2, numbers))
print(squared) # 输出：[1, 4, 9, 16, 25]
# 使用filter函数和lambda
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers) # 输出：[2, 4]
# 使用sorted函数和lambda
students = [("张三", 85), ("李四", 90), ("王五", 78)]
sorted_students = sorted(students, key=lambda x: x[1])
print(sorted_students) # 输出：[('王五', 78), ('张三', 85), ('李四', 90)]高阶函数
高阶函数是接受函数作为参数或返回函数的函数。
函数作为参数
def apply_operation(a, b, operation):
"""应用指定的操作"""
return operation(a, b)
def add(x, y):
"""加法函数"""
return x + y
def multiply(x, y):
"""乘法函数"""
return x * y
# 将函数作为参数传递
result1 = apply_operation(5, 3, add)
result2 = apply_operation(5, 3, multiply)
print(result1) # 输出：8
print(result2) # 输出：15函数作为返回值
def create_multiplier(n):
"""创建乘法器函数"""
def multiplier(x):
return x * n
return multiplier
# 创建不同的乘法器
double = create_multiplier(2)
triple = create_multiplier(3)
print(double(5)) # 输出：10
print(triple(5)) # 输出：15递归函数
递归函数是调用自身的函数，必须有终止条件。
基本递归示例
def factorial(n):
"""计算阶乘"""
# 基础情况：递归终止条件
if n == 0 or n == 1:
return 1
# 递归情况
else:
return n * factorial(n - 1)
print(factorial(5)) # 输出：120
def fibonacci(n):
"""计算斐波那契数列"""
# 基础情况
if n <= 1:
return n
# 递归情况
else:
return fibonacci(n - 1) + fibonacci(n - 2)
print(fibonacci(6)) # 输出：8递归注意事项
import sys # 查看递归限制 print(sys.getrecursionlimit()) # 通常为1000 # 设置递归限制（谨慎使用） # sys.setrecursionlimit(2000)
函数文档字符串
文档字符串（docstring）用于描述函数的功能、参数和返回值。
基本格式
def calculate_area(length, width):
"""
计算矩形面积
参数:
length (float): 矩形的长度
width (float): 矩形的宽度
返回:
float: 矩形的面积
示例:
>>> calculate_area(5, 3)
15
"""
return length * width
# 查看函数文档
print(calculate_area.__doc__)
help(calculate_area)详细的文档字符串
def complex_calculation(x, y, operation="add"):
"""
执行复杂的数学计算
这个函数可以根据指定的操作对两个数进行计算。
参数:
x (float): 第一个操作数
y (float): 第二个操作数
operation (str, optional): 操作类型，可选值为"add", "subtract",
"multiply", "divide"。默认为"add"
返回:
float: 计算结果
异常:
valueerror: 当操作类型不支持时抛出
zerodivisionerror: 当除数为0时抛出
示例:
>>> complex_calculation(10, 5, "add")
15.0
>>> complex_calculation(10, 5, "multiply")
50.0
"""
operations = {
"add": lambda a, b: a + b,
"subtract": lambda a, b: a - b,
"multiply": lambda a, b: a * b,
"divide": lambda a, b: a / b
}
if operation not in operations:
raise valueerror(f"不支持的操作类型: {operation}")
if operation == "divide" and y == 0:
raise zerodivisionerror("除数不能为0")
return operations[operation](x, y)函数最佳实践
函数设计原则
# 1. 函数应该只做一件事，并且做好
def calculate_sum(numbers):
"""计算数字列表的和"""
return sum(numbers)
def find_maximum(numbers):
"""找出数字列表中的最大值"""
return max(numbers)
# 2. 函数名应该清晰表达函数的功能
def is_even(number):
"""判断数字是否为偶数"""
return number % 2 == 0
# 3. 参数应该有合理的默认值
def create_greeting(name, greeting="hello"):
"""创建问候语"""
return f"{greeting}, {name}!"
# 4. 函数应该有适当的文档字符串
def convert_temperature(temp, from_unit, to_unit):
"""
转换温度单位
参数:
temp (float): 温度值
from_unit (str): 源单位 ("c" 或 "f")
to_unit (str): 目标单位 ("c" 或 "f")
返回:
float: 转换后的温度值
"""
if from_unit == "c" and to_unit == "f":
return temp * 9/5 + 32
elif from_unit == "f" and to_unit == "c":
return (temp - 32) * 5/9
else:
return temp
# 5. 处理异常情况
def safe_divide(a, b):
"""安全除法，处理除零异常"""
try:
return a / b
except zerodivisionerror:
print("错误：除数不能为0")
return none函数测试
def test_functions():
"""测试函数功能"""
# 测试计算函数
assert calculate_sum([1, 2, 3, 4]) == 10
assert is_even(4) == true
assert is_even(5) == false
# 测试温度转换
assert abs(convert_temperature(0, "c", "f") - 32) < 0.01
assert abs(convert_temperature(32, "f", "c") - 0) < 0.01
print("所有测试通过！")
# 运行测试
test_functions()综合应用示例
# 学生成绩管理系统
class studentgrademanager:
"""学生成绩管理器"""
def __init__(self):
self.students = []
def add_student(self, name, scores):
"""添加学生"""
student = {
"name": name,
"scores": scores,
"average": self.calculate_average(scores)
}
self.students.append(student)
def calculate_average(self, scores):
"""计算平均分"""
if not scores:
return 0
return sum(scores) / len(scores)
def get_grade(self, average):
"""根据平均分获取等级"""
if average >= 90:
return "优秀"
elif average >= 80:
return "良好"
elif average >= 70:
return "中等"
elif average >= 60:
return "及格"
else:
return "不及格"
def display_report(self):
"""显示成绩报告"""
print("学生成绩报告")
print("-" * 40)
for student in self.students:
print(f"姓名: {student['name']}")
print(f"成绩: {student['scores']}")
print(f"平均分: {student['average']:.2f}")
print(f"等级: {self.get_grade(student['average'])}")
print("-" * 40)
# 使用示例
manager = studentgrademanager()
manager.add_student("张三", [85, 90, 78, 92])
manager.add_student("李四", [76, 88, 82, 79])
manager.display_report()总结
本篇教程详细介绍了python函数的定义与使用，包括函数参数、返回值、变量作用域、匿名函数、高阶函数、递归函数等重要概念。我们还学习了如何编写清晰的文档字符串和遵循函数设计的最佳实践。
函数是python编程的核心概念之一，掌握函数的使用对于编写模块化、可维护的代码至关重要。
到此这篇关于python 函数定义与使用实践记录的文章就介绍到这了,更多相关python 函数定义与使用内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！
发表评论