青少年编程与数学 02-008 Pyhon语言编程基础 14课题、创建函数

课题摘要:本文介绍了Python中创建函数的方法，包括基本格式、参数类型和返回值。使用def关键字定义函数，后跟函数名和参数列表。函数可以有位置参数、默认参数、可变数量参数和关键字参数。函数通过return语句返回值，可以返回多个值，且可以早返回以提高代码效率。函数调用时可以传递位置参数、关键字参数，也可以解包序列或字典作为参数。文章最后提供了一个示例程序，展示了如何定义一个计算两数之和的函数，并以不同方式调用该函数。理解函数的创建和调用对于编写模块化和可重用的代码至关重要。

一、创建函数

在Python中创建函数非常简单，使用def关键字后跟函数名和一对圆括号，圆括号内可以包含零个或多个参数。然后，在冒号后面跟着缩进的代码块，即函数体。以下是创建函数的基本步骤：

1. 定义函数：使用def关键字开始定义一个函数。
2. 指定函数名：def之后是函数名，函数名后面跟着一对圆括号。
3. 添加参数：圆括号内可以包含零个或多个参数，参数之间用逗号分隔。
4. 编写函数体：在圆括号后面加上冒号，然后换行开始编写函数体，函数体的代码需要缩进。
5. 返回值：可以使用return语句从函数返回值。

下面是一个简单的函数定义示例：

def greet(name):
    ""“简单的问候函数”""
    return f"Hello, {name}!"

# 调用函数
print(greet("Alice"))  # 输出：Hello, Alice!

在这个例子中，greet是一个函数，它接受一个参数name，并返回一个问候语。函数体只包含一个return语句，它返回一个格式化的字符串。

你也可以定义不接受任何参数的函数：

def say_hello():
    print("Hello!")

# 调用函数
say_hello()  # 输出：Hello!

此外，函数还可以接受任意数量的参数，使用*args和**kwargs：

def make_greeting(*args):
    return " ".join(args)

# 调用函数
print(make_greeting("Hello", "world", "from", "Python"))  # 输出：Hello world from Python

在这个例子中，make_greeting函数可以接受任意数量的参数，并将它们连接成一个字符串返回。

使用**kwargs可以传递任意数量的关键字参数：

def print_attributes(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

# 调用函数
print_attributes(name="Alice", age=25)  # 输出：
# name: Alice
# age: 25

在这个例子中，print_attributes函数可以接受任意数量的关键字参数，并打印它们。

以上就是在Python中创建函数的基本方法。函数是Python编程中非常重要的概念，它们可以帮助你模块化代码，提高代码的可读性和可维护性。

二、基本格式

Python中函数的基本格式遵循以下结构：

1. 定义关键字：使用def关键字来声明一个函数。

2. 函数名：紧随def关键字的是函数名，它是一个标识符，用于标识函数。

3. 参数列表：函数名后面是一对圆括号，圆括号内可以包含零个或多个参数，参数之间用逗号分隔。

4. 冒号：参数列表后面必须有一个冒号。

5. 函数体：冒号后面是函数体，必须缩进。函数体包含函数的执行语句。

6. 返回语句：可以使用return关键字从函数返回值。

以下是函数基本格式的示例：

def function_name(parameters):
    # 函数体
    # 可以包含一条或多条语句
    return value

具体来说：

• function_name：这是函数的名称，它应该是一个有效的标识符，并且遵循Python的命名规则。

• parameters：这是函数的参数列表，可以有零个或多个参数。如果函数不接受任何参数，圆括号内应该是空的。

• # 函数体：这是函数的主体部分，包含了函数的逻辑和操作。

• return value：这是返回语句，value是函数返回的值。如果函数不需要返回值，可以省略return语句。

下面是一个具体的函数定义示例：

def add_numbers(a, b):
    """返回两个数的和"""
    result = a + b
    return result

# 调用函数
sum = add_numbers(3, 4)
print(sum)  # 输出：7

在这个例子中，add_numbers是一个接受两个参数a和b的函数，它计算这两个数的和并返回结果。

三、函数的参数

在Python中，函数的参数是传递给函数的值，这些值可以被函数用来执行特定的任务。参数允许函数更加灵活和通用，因为它们可以接受外部数据并根据这些数据执行操作。以下是函数参数的详细解释：

1. 位置参数（Positional Arguments）

最基本的参数类型是位置参数，它们必须按顺序传递给函数，函数会根据参数的位置来接收它们。

def greet(first_name, last_name):
    print(f"Hello, {first_name} {last_name}!")

greet("John", "Doe")  # 输出：Hello, John Doe!

2. 关键字参数（Keyword Arguments）

关键字参数提供了一种更灵活的方式来传递参数，它们不需要按照定义的顺序，而是通过参数名来指定。

def greet(first_name, last_name):
    print(f"Hello, {first_name} {last_name}!")

greet(last_name="Doe", first_name="John")  # 输出：Hello, John Doe!

3. 默认参数值（Default Argument Values）

函数参数可以有默认值，如果在调用函数时没有提供某个参数的值，那么就会使用默认值。

def greet(first_name, last_name="Doe"):
    print(f"Hello, {first_name} {last_name}!")

greet("John")  # 输出：Hello, John Doe!

4. 可变数量的位置参数（Arbitrary Argument Lists）

使用星号（*）可以定义一个参数来接收任意数量的位置参数，这些参数被打包进一个元组。

def make_pizza(*toppings):
    print(toppings)

make_pizza("pepperoni")  # 输出：('pepperoni',)
make_pizza("mushrooms", "green peppers", "extra cheese")  # 输出：('mushrooms', 'green peppers', 'extra cheese')

5. 可变数量的关键字参数（Arbitrary Keyword Arguments）

使用两个星号（**）可以定义一个参数来接收任意数量的关键字参数，这些参数被打包进一个字典。

def make_pizza(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

make_pizza(cheese="extra", crust="thick")  # 输出：
# cheese: extra
# crust: thick

6. 参数组合（Combining Arguments）

在定义函数时，可以组合使用位置参数、默认参数、可变数量的位置参数和可变数量的关键字参数。

def build_profile(first_name, last_name, age=None, **kwargs):
    profile = {
        "first_name": first_name,
        "last_name": last_name,
        "age": age,
    }
    profile.update(kwargs)
    return profile

user_profile = build_profile("John", "Doe", 25, city="New York", country="USA")
print(user_profile)  # 输出：{'first_name': 'John', 'last_name': 'Doe', 'age': 25, 'city': 'New York', 'country': 'USA'}

7. 参数解包（Argument Unpacking）

在函数调用时，可以解包序列或字典，将元素作为独立的参数传递给函数。

def print_info(name, age):
    print(f"Name: {name}, Age: {age}")

info = ["Alice", 30]
print_info(*info)  # 输出：Name: Alice, Age: 30

info_kwargs = {"name": "Bob", "age": 25}
print_info(**info_kwargs)  # 输出：Name: Bob, Age: 25

理解函数参数的不同类型和用法可以让你编写更灵活和强大的函数，以适应各种不同的编程场景。

四、函数的返回值

在Python中，函数的返回值是指函数执行完毕后，将其结果传递给函数调用者的数据。返回值使得函数不仅可以执行某些操作，还可以提供有用的输出，这些输出可以被进一步处理或作为程序其他部分的输入。

以下是关于函数返回值的详细解释：

1. 使用 return 语句

函数通过 return 语句返回值。return 后面跟着的表达式就是函数的返回值。

def add(a, b):
    return a + b

result = add(3, 4)
print(result)  # 输出：7

2. 返回多个值

Python允许函数返回多个值，这实际上是返回一个元组。

def get_user_info():
    return "Alice", 30, "New York"

name, age, city = get_user_info()
print(name, age, city)  # 输出：Alice 30 New York

3. 没有返回值

如果函数没有 return 语句或者 return 语句后面没有值，函数默认返回 None。

def say_hello():
    print("Hello!")

result = say_hello()
print(result)  # 输出：None

4. 返回值类型

函数可以返回任何类型的值，包括数字、字符串、列表、字典等。

def get_data():
    return {"name": "Bob", "age": 25}

data = get_data()
print(data)  # 输出：{'name': 'Bob', 'age': 25}

5. 条件返回

函数可以根据条件语句来决定返回哪个值。

def is_adult(age):
    if age >= 18:
        return True
    else:
        return False

adult = is_adult(20)
print(adult)  # 输出：True

6. 早返回（Early Return）

在某些条件下提前退出函数，可以提高代码的可读性和效率。

def divide(a, b):
    if b == 0:
        return None  # 或者抛出异常
    return a / b

result = divide(10, 0)
print(result)  # 输出：None

7. 返回值和函数文档

函数的文档字符串（docstring）应该描述函数的返回值，这对于维护代码和编写文档非常有用。

def get_full_name(first_name, last_name):
    """返回完整的姓名"""
    return f"{first_name} {last_name}"

# 函数的文档字符串可以通过help()函数查看
help(get_full_name)

8. 返回值和异常处理

函数可以在遇到错误时返回错误代码或抛出异常，而不是返回正常的结果。

def divide(a, b):
    try:
        return a / b
    except ZeroDivisionError:
        return "Error: Division by zero"

result = divide(10, 0)
print(result)  # 输出：Error: Division by zero

9. 利用返回值进行函数链式调用

函数的返回值可以作为另一个函数的输入，实现链式调用。

def increment(x):
    return x + 1

def double(x):
    return x * 2

result = double(increment(5))
print(result)  # 输出：12

理解函数的返回值对于编写有效和可维护的代码至关重要。返回值使得函数更加强大，允许函数之间的数据流动和复杂程序逻辑的构建。

五、函数的调用

在Python中，函数调用是执行已定义函数的操作，它允许你运行函数体中的代码，并根据需要传递参数。以下是函数调用的详细解释：

1. 基本调用

当你定义了一个函数后，可以通过函数名后跟一对圆括号来调用它。如果函数不接受任何参数，圆括号内应该是空的。

def say_hello():
    print("Hello!")

say_hello()  # 输出：Hello!

2. 传递位置参数

你可以将参数按顺序传递给函数，这些参数会根据它们的位置赋值给函数的参数。

def greet(first_name, last_name):
    print(f"Hello, {first_name} {last_name}!")

greet("John", "Doe")  # 输出：Hello, John Doe!

3. 传递关键字参数

你也可以通过参数名来传递参数，这种方式称为关键字参数，它允许你明确指定每个参数的值，而不必依赖于参数的位置。

def greet(first_name, last_name):
    print(f"Hello, {first_name} {last_name}!")

greet(first_name="John", last_name="Doe")  # 输出：Hello, John Doe!

4. 组合使用位置参数和关键字参数

在同一个函数调用中，你可以同时使用位置参数和关键字参数，但所有的关键字参数必须放在位置参数的后面。

def greet(first_name, last_name):
    print(f"Hello, {first_name} {last_name}!")

greet("John", last_name="Doe")  # 正确的调用
# greet(last_name="Doe", "John")  # 错误的调用，会抛出SyntaxError

5. 传递可变数量的参数

如果函数定义中包含*args或**kwargs，你可以传递可变数量的参数。

def make_pizza(*toppings):
    print(toppings)

make_pizza("pepperoni", "蘑菇", "extra cheese")  # 输出：('pepperoni', '蘑菇', 'extra cheese')

6. 参数解包

你可以使用星号(*)或双星号(**)来解包序列或映射，并将它们作为独立的参数传递给函数。

def add(a, b):
    return a + b

numbers = [1, 2]
result = add(*numbers)  # 使用 * 解包列表
print(result)  # 输出：3

info = {'a': 1, 'b': 2}
result = add(**info)  # 使用 ** 解包字典
print(result)  # 输出：3

7. 返回值的使用

函数的返回值可以被赋值给变量，或者在表达式中直接使用。

def get_user_name():
    return "Alice"

name = get_user_name()
print(name)  # 输出：Alice

8. 函数嵌套调用

一个函数可以在另一个函数内部被调用。

def greet(name):
    print(f"Hello, {name}!")

def process_user_input():
    name = input("What is your name? ")
    greet(name)

process_user_input()

9. 递归调用

函数也可以调用自身，这种调用称为递归。

def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n - 1)

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

10. 调用时的异常处理

你可以捕捉函数调用时可能抛出的异常。

def divide(a, b):
    return a / b

try:
    result = divide(10, 0)
except ZeroDivisionError:
    print("Cannot divide by zero.")

函数调用是程序设计中的基本操作之一，它允许代码的模块化和重用。通过函数调用，你可以执行特定的任务，处理数据，并构建复杂的程序逻辑。

六、练习

以下是一个完整的Python代码示例，其中包含了一个函数的定义和对该函数的调用：

# 定义一个函数，用于计算两个数的和
def add_numbers(num1, num2):
    """
    返回两个数的和。
    
    参数:
    num1 (int/float): 第一个加数。
    num2 (int/float): 第二个加数。
    
    返回:
    int/float: 两数之和。
    """
    return num1 + num2

# 调用函数并打印结果
result = add_numbers(3, 4)
print("The sum of 3 and 4 is:", result)

# 再次调用函数，使用不同的参数
result = add_numbers(10.5, 20.3)
print("The sum of 10.5 and 20.3 is:", result)

# 调用函数，使用关键字参数
result = add_numbers(num2=7, num1=8)
print("The sum of 8 and 7 is:", result)

在这个示例中，我们定义了一个名为add_numbers的函数，它接受两个参数num1和num2，并返回它们的和。函数还包含了一个文档字符串（docstring），描述了函数的作用、参数和返回值。

然后，我们通过三种不同的方式调用了add_numbers函数：

1. 使用位置参数传递数字3和4。
2. 使用位置参数传递浮点数10.5和20.3。
3. 使用关键字参数传递数字8和7。

每次调用函数后，我们都打印出了返回的结果。这个简单的示例展示了如何定义函数、如何调用函数以及如何处理函数的返回值。