目录
频道首页
7_python函数定义
收藏
0
ProgramLight 最近修改于 2024-04-15 11:37:24

在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

在上述例子中,变量ab是全局变量,它们可以在函数内部被访问和修改。在函数内部,通过使用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!
内容大纲
批注笔记
7_python函数定义
ArticleBot
z
z
z
z
主页
会议室
Git管理
文章
云文档
看板