在Python中，函数是一种用于封装可重复使用代码的工具。函数可以接受输入参数，并通过返回值来输出结果。它们被广泛用于模块化程序和提高代码的可读性和可维护性。本文将介绍Python中带参函数的基本概念、定义和部分使用方法。

一、函数定义

在Python中，我们可以使用def关键字定义一个函数。函数定义的一般语法如下：

def function_name(parameters):
    # 函数体
    # 可以包含一系列语句
    return value

让我们进一步地详细介绍Python函数的相关内容。

• 函数名：函数名是标识符，它应该具有描述性，以便在代码中易于理解。命名规则与变量名相同，可以由字母、数字和下划线组成，但不能以数字开头。
• 参数：函数可以接受零个或多个参数。参数是函数定义中的占位符，用于接受外部传递进来的值。参数可以是必需的（必须传递）或可选的（可以省略）。在函数体内部，我们可以使用这些参数来执行特定的操作。
• 函数体：函数体是由一系列代码语句组成的块。它定义了函数的操作和逻辑。在函数体中，我们可以使用任何Python语句和表达式来完成特定的任务。
• 返回值：函数可以使用return语句返回一个值。返回值是函数执行结果的输出。如果函数没有返回值，它将返回None。下面是一个简单的例子，展示了如何定义和调用一个函数：

def greet(name):
     #  打印问候语
    print("Hello, " + name + "!")

# 调用函数
greet("Alice")

上述例子中，我们定义了一个名为greet的函数，它接受一个参数name。在函数体内，我们使用print语句打印出问候语。最后，我们调用这个函数并传递一个名为"Alice"的参数。

二、函数的参数

函数的参数是指函数定义时声明的变量，用于接收传递给函数的值。函数的参数可以是任何类型的值，包括数字、字符串、列表、元组、字典、函数等等。在调用函数时，我们可以传递任意数量和类型的参数，函数会根据这些参数执行相应的操作。函数的参数可以分为以下几类：

2.1 位置参数

位置参数是指在函数定义时声明的变量，它们按照定义的顺序依次接收传递给函数的值。例如：

def my_function(a, b, c):
   #  函数定义
    print(a)
    print(b)
    print(c)

# 调用函数
my_function(1, 2, 3) `

在上述例子中，a、b和c就是位置参数。当我们调用my_function函数时，可以按照任意顺序传递这些参数。

2.2 默认参数

默认参数是指在函数定义时声明的变量，它们的值在函数调用时被赋予。如果在函数调用时没有提供相应的参数，则使用默认值。例如：

def my_function(a=1, b=2, c=3):
     #  函数定义
    print(a)
    print(b)
    print(c)

# 调用函数
my_function(b=4)     # 输出：1 4 3

在上述例子中，a、b和c就是默认参数。当我们调用my_function函数时，可以只传递其中的一些参数，而其他参数将使用默认值.

2.3 不定长参数

不定长参数是函数定义中用于接收不确定数量参数的一种方式，它可以接收任意数量的参数。

在Python中，有两种不定长参数的基本形式：*args 和 **kwargs。

2.3.1 *args

*args：使用 *args 可以接收任意数量的位置参数，它将这些参数作为一个元组传递给函数。在函数定义时，在参数名前加上 * 号表示该参数可以接收多个位置参数。例如：

def my_function(*args):
     #  函数定义
    for arg in args:
        print(arg)

# 调用函数
my_function(1, 2, 3, 4)     # 输出：1，2，3，4

在上述例子中，函数 myfunction 使用 *args 接收任意数量的位置参数。当我们调用 myfunction 函数时，传递了 4 个位置参数，输出结果为：1，2，3，4.

2.3.2 **kwargs

**kwargs：使用**kwargs可以接收任意数量的关键字参数，它将这些参数作为一个字典传递给函数。在函数定义时，在参数名前加上 *号表示该参数可以接收多个关键字参数。例如：

def my_function(**kwargs):
    """
    函数定义
    """
    for key, value in kwargs.items():
        print(key + ": " + value)

# 调用函数
my_function(name="Alice", age="25", city="New York") `

在上述例子中，函数 my_function使用**kwargs 接收任意数量的关键字参数。当我们调用my_function 函数时，传递了三个关键字参数，输出结果为：

name: Alice
age: 25
city: New York

在上述例子中，kwargs是关键字参数。当我们调用my_function函数时，可以使用参数名来指定参数的值。

注意

使用不定长参数的好处在于可以根据需要传递不确定数量的参数，提高函数的灵活性。不过需要注意的是，不定长参数必须放在其他参数的最后，否则会导致参数数量不匹配的错误。

三、函数的返回值

函数的返回值是指函数执行完毕后返回给调用者的值。在Python中，函数可以返回任何类型的值，包括数字、字符串、列表、元组、字典、函数等等。函数的返回值通常用于实现函数的功能，例如计算、判断、处理数据等。函数的返回值可以通过多种方式进行传递，包括直接返回、返回值赋值、返回元组、返回列表等等。下面是一些常见的返回值传递方式：

3.1 直接返回

在函数中使用return语句返回一个值，该值将成为函数的返回值。例如：

def my_function(x, y):
    """
    函数定义
    """
    result = x + y
    return result

在上述例子中，函数my_function接收两个参数x和y，并计算它们的和。然后通过return语句将结果返回给调用者。

3.2 返回值赋值

可以将函数的返回值赋给一个变量，并在需要的时候使用该变量。例如：

def my_function(x, y):
    """
    函数定义
    """
    result = x + y
    return result

sum = my_function(3, 4)
print(sum)        # 输出：7

在上述例子中，函数my_function的返回值被赋给变量sum，然后通过print函数打印出来。

3.3 函数返回多个数据的方式

在Python中，可以使用元组（tuple）、列表（list）或字典（dictionary）等数据结构来实现一个函数返回多个数据的方式。

3.3.1 返回元组

使用元组（tuple）：可以将多个值打包成一个元组，并将这个元组作为函数的返回值。调用函数后，可以使用解包（unpacking）的方式将返回的元组中的每个值分别赋值给不同的变量。

def get_user_info():
    name = "Alice"
    age = 25
    city = "New York"
    return name, age, city

user_info = get_user_info()
print(user_info)            # 输出: ('Alice', 25, 'New York')
print(user_info[0])         # 输出: 'Alice'
print(user_info[1])         # 输出: 25
print(user_info[2])         # 输出: 'New York'

name, age, city = get_user_info()
print(name)                # 输出: 'Alice'
print(age)                 # 输出: 25
print(city)                # 输出: 'New York'

3.3.2 返回列表

使用列表（list）：可以将多个值存储在一个列表中，并将这个列表作为函数的返回值。

def get_numbers():
    numbers = [1, 2, 3, 4, 5]
    return numbers

numbers_list = get_numbers()
print(numbers_list)         # 输出: [1, 2, 3, 4, 5]

3.3.3 返回字典

使用字典（dictionary）：可以将多个值存储在一个字典中，并将这个字典作为函数的返回值。字典中的键（key）可以表示数据的不同属性，而对应的值（value）则表示属性对应的数据。

def get_user_info():
    user_info = {"name": "Alice", "age": 25, "city": "New York"}
    return user_info

user_info_dict = get_user_info()
print(user_info_dict)       # 输出: {'name':Alice', 'age': 25, 'city': 'New York'}
print(user_info_dict["name"])   # 输出: 'Alice'
print(user_info_dict["age"])    # 输出: 25
print(user_info_dict["city"])   # 输出: 'New York'

无论使用元组、列表还是字典，都可以实现一个函数返回多个数据的方式。选择使用哪种方式取决于具体的需求和使用场景。

3.4 多个返回值

在Python中，函数可以返回多个值。实际上，这些多个返回值被打包成了一个元组，并可以通过解包的方式获取其中的每个值。例如：

def get_user_info():
    name = "Alice"
    age = 25
    city = "New York"
    return name, age, city

user_info = get_user_info()
print(user_info)
print(user_info[0])
print(user_info[1])
print(user_info[2])

在上述例子中，get_user_info()函数返回了三个值：name、age 和 city。使用return关键字，将这些值作为一个元组返回。在函数调用时，将返回的元组赋值给了user_info变量。

输出结果为：

('Alice', 25, 'New York')
Alice
25
New York

可以通过索引或解包的方式获取元组中的每个返回值。例如，user_info[0]获取到了元组的第一个值，即 ‘Alice’。

此外，还可以使用解包的方式将返回的多个值分别赋值给多个变量，例如：

name, age, city = get_user_info()
print(name)
print(age)
print(city)

输出结果为：

Alice
25
New York

通过解包的方式，可以将元组中的每个返回值分别赋值给对应的变量，以方便使用。

需要注意的是，返回多个值时，实际上是将这些值打包成了一个元组返回的。如果只需要其中的部分值，可以通过索引或解包的方式获取。

3.5 多个return

在Python中，函数可以有多个 return 语句，即可以在函数的不同位置使用 return来返回不同的值。当函数执行到 return语句时，会立即结束函数的执行，并将指定的值作为返回值返回给函数调用者。

以下是一个示例：

def get_user_info(user_id):
    if user_id == 1:
        name = "Alice"
        age = 25
        return name, age
    elif user_id == 2:
        name = "Bob"
        age = 30
        return name, age
    else:
        return "User not found"

user1_info = get_user_info(1)
print(user1_info)  # 输出: ('Alice', 25)

user2_info = get_user_info(2)
print(user2_info)  # 输出: ('Bob', 30)

user3_info = get_user_info(3)
print(user3_info)  # 输出: User not found

可以通过多个 return 语句，在函数的不同位置返回不同的值，以满足不同的需求。需要注意的是，在函数执行到第一个 return 语句时，函数的执行将立即结束，后续的代码将不再执行。因此，如果有多个return语句，确保每个分支都有返回值或有默认的返回值，以避免出现意外的错误。

四、局部变量与全局变量

在Python中，变量分为局部变量和全局变量两种类型。

4.1 局部变量

局部变量是指在函数内部定义的变量，只能在该函数内部使用。当函数执行完毕后，局部变量的值也会被销毁。例如：

def my_function():

    """
    函数定义
    """
    x = 1
    y = 2
    z = x + y
    return z

print(my_function())

在上述例子中，函数my_function定义了三个局部变量x、y和z。在函数执行完毕后，局部变量的值也会被销毁。因此，当我们调用my_function函数时，输出的结果为3。

4.2 全局变量

全局变量是指在函数外部定义的变量，可以在整个程序中使用。当函数执行完毕后，全局变量的值仍然存在。例如：

a = 1
b = 2

def my_function():
    """
    函数定义
    """
    global a, b
    a += 1
    b += 1
    print(a)    # 输出：2
    print(b)    # 输出：3

在上述例子中，变量a和b是全局变量，它们可以在函数内部被访问和修改。在函数内部，通过使用global关键字声明变量是全局变量，这样就可以在函数内部修改全局变量的值。当我们调用my_function函数时，输出的结果为：2，3。

在函数内部，通过使用global关键字，我们可以修改全局变量的值，使得其在函数外部也发生变化。需要注意的是，如果在函数内部声明了与全局变量同名的局部变量，则在函数内部访问的是局部变量，而不是全局变量。例如：

a = 1

def my_function():
    """
    函数定义
    """
    a = 2
    print(a)

my_function()
print(a)

在上述例子中，虽然函数中存在一个与全局变量a同名的局部变量，但是在函数内部访问的是局部变量a，而不是全局变量。因此，当我们调用my_function函数时，输出的结果为2，而在函数外部输出全局变量a的值为1。

总结

• 局部变量和全局变量的区别在于作用域的范围。
• 局部变量只能在函数内部使用，函数执行完毕后会被销毁；
• 而全局变量可以在整个程序中使用，其值在函数执行完毕后仍然存在。
• 需要注意的是，在函数内部如果要修改全局变量的值，需要使用global关键字进行声明。

五、函数的调用

函数的调用是指通过函数名和传入的实参来执行函数体内的代码。要调用一个函数，可以按照以下方式进行：

5.1 直接调用

使用函数名后跟一对括号，并在括号内传入相应的实参。例如：

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

greet("Alice")        # 输出：Hello, Alice!

5.2 使用关键字参数

通过指定参数名称和对应的值来传递参数，可以不按照函数定义时参数的顺序进行传递。例如：

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

greet(message="Hi", name="Bob")        # 输出：Hi, Bob!

5.3 默认参数

当函数定义时指定了参数的默认值，可以不传递该参数，函数会使用默认值。例如：

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

greet("Alice")       # 使用默认值
greet("Bob", "Hi")   # 传递实参
"""
输出：
Hello, Alice!
Hi, Bob!
"""

需要注意的是，函数调用时传入的实参要与函数定义时参数的类型和顺序相匹配，否则可能会导致错误。此外，函数调用可以将函数的返回值赋给一个变量，并在需要的地方使用。

例如，下面的示例将函数的返回值赋给变量，并在之后进行打印输出：

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

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

通过合理地调用函数，可以将代码模块化，提高代码的可重用性和可读性，使程序更加灵活和易于维护。

5.4 函数的调用函数

在Python中，函数是一等公民，可以像其他对象一样作为参数传递给其他函数，也可以作为返回值返回。

5.4.1 将函数作为参数传递给另一个函数

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

def call_func(func, name):
    func(name)

call_func(greet, "Alice")        # 输出：Hello, Alice!

在上述例子中，我们定义了一个greet函数，然后将其作为参数传递给call_func函数。call_func函数接受一个函数和一个名字作为参数，并在函数内部调用传递的函数。

5.4.2 将函数作为返回值

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

greet_func = greet()
result = greet_func("Alice")
print(result)        # 输出：Hello, Alice!

在上述例子中，我们定义了一个greet函数，该函数内部定义了一个say_hello函数，并将其作为返回值。通过调用greet函数，我们获得了一个函数对象greet_func，然后我们可以像调用普通函数一样调用greet_func。

这种在函数内部定义函数，并将其返回的方法称为闭包（closure）。闭包可以捕获其外部作用域中的变量，并保持对其的引用，从而实现了一种类似于私有变量的机制。

通过将函数作为参数传递给其他函数或将其作为返回值返回，我们可以实现更加灵活和高阶的函数功能，可以实现回调函数、函数组合、函数的延迟执行等一系列有用的功能。递归函数也可以通过将自身作为参数传递给其他函数来实现。

六、函数的文档说明

函数的文档说明是对函数的功能、使用方法、参数和返回值等进行描述和解释的文档。

在Python中，可以使用文档字符串（docstring）来编写函数的文档说明。文档字符串是在函数定义的第一行后面用三引号（‘’'）或双引号（“”"）括起来的字符串，可以跨越多行。

以下是一个函数的示例，包含了文档字符串的编写方式：

def greet(name):
    """
    函数用于打印问候语，并传入一个名字参数。

    参数：
    - name: 要问候的名字

    返回值：
    无

    示例：
    greet("Alice")
    输出: Hello, Alice!
    """
    print(f"Hello, {name}!")

在文档字符串中，可以描述函数的功能、用途、参数的含义、返回值的含义以及示例等信息。文档字符串应该简洁明了，描述准确，以便其他开发者能够理解和使用函数。

要访问函数的文档字符串，可以使用内置函数help()或通过__doc__属性来获取：

print('内置函数help()获取：')
help(greet)  # 输出函数的文档字符串

print('通过__doc__属性获取：')
print(greet.__doc__)  # 输出函数的文档字符串

输出结果：

内置函数help()获取：
Help on function greet in module __main__:
greet(name)
    函数用于打印问候语，并传入一个名字参数。

    参数：
    - name: 要问候的名字

    返回值：
    无

    示例：
    greet("Alice")
    输出: Hello, Alice!

通过__doc__属性获取：
    函数用于打印问候语，并传入一个名字参数。
    参数：
    - name: 要问候的名字
    返回值：
    无
    示例：
    greet("Alice")
    输出: Hello, Alice!