python定义了函数如何执行

Python定义了函数如何执行：使用函数名加括号来调用、可以传递参数、返回值可以通过return语句获得。 Python中的函数是通过def关键字定义的，执行函数时只需要通过函数名加上括号来调用它。函数可以接受输入参数，并且可以返回值。接下来，详细描述其中的一点——使用函数名加括号来调用：

在Python中，定义一个函数之后，你可以通过函数名加上括号的方式来调用这个函数。如果函数定义中接受参数，你还需要在括号内传入相应的参数。例如，假设你定义了一个名为my_function的函数，那么你可以通过my_function()来调用它。如果这个函数接受两个参数，你可以通过my_function(arg1, arg2)来调用它。

一、定义和调用函数

定义函数

在Python中，函数是通过def关键字来定义的。函数的定义包括函数名、参数列表和函数体。函数体是由若干条语句组成的代码块，定义函数的基本语法如下：

def function_name(parameters):
    """docstring"""
    statement(s)

例如，定义一个简单的函数greet，它接受一个参数并打印一条问候语：

def greet(name):
    """This function greets to the person passed in as parameter"""
    print("Hello, " + name + "!")

调用函数

定义了函数之后，就可以通过函数名和参数来调用它。调用函数的语法如下：

function_name(arguments)

例如，调用前面定义的greet函数：

greet("Alice")

这将输出：

Hello, Alice!

二、传递参数

函数可以通过参数接受外部数据。参数在定义函数时指定，在调用函数时传递。参数可以有默认值，这使得在调用函数时可以省略某些参数。

位置参数

位置参数是最常见的参数类型，传递参数时，参数值按照位置顺序传递给函数。例如：

def add(a, b):
    return a + b
result = add(3, 5)
print(result)

这将输出：

8

关键字参数

关键字参数通过参数名传递，可以不按照位置顺序。例如：

def greet(first_name, last_name):
    print("Hello, " + first_name + " " + last_name + "!")
greet(last_name="Smith", first_name="John")

这将输出：

Hello, John Smith!

默认参数

默认参数在定义函数时指定，如果调用函数时没有传递该参数，则使用默认值。例如：

def greet(name="Guest"):
    print("Hello, " + name + "!")
greet()
greet("Alice")

这将输出：

Hello, Guest! Hello, Alice!

可变参数

Python允许函数接受可变数量的参数，可以使用*args和<strong>kwargs来实现。*args用于传递非关键字可变参数，</strong>kwargs用于传递关键字可变参数。例如：

def greet_multiple(*names):
    for name in names:
        print("Hello, " + name + "!")
greet_multiple("Alice", "Bob", "Charlie")

这将输出：

Hello, Alice! Hello, Bob! Hello, Charlie!

def greet_with_titles(kwargs):
    for title, name in kwargs.items():
        print("Hello, " + title + " " + name + "!")
greet_with_titles(Mr="Smith", Dr="Jones")

这将输出：

Hello, Mr Smith! Hello, Dr Jones!

三、返回值

函数可以使用return语句返回值。return语句可以返回单个值、多个值或None（如果没有return语句，函数默认返回None）。

返回单个值

例如：

def add(a, b):
    return a + b
result = add(3, 5)
print(result)

这将输出：

8

返回多个值

例如：

def swap(a, b):
    return b, a
x, y = swap(3, 5)
print(x, y)

这将输出：

5 3

返回None

如果函数没有return语句或return语句没有返回值，函数将返回None。例如：

def greet(name):
    print("Hello, " + name + "!")
result = greet("Alice")
print(result)

这将输出：

Hello, Alice! None

四、局部变量和全局变量

在函数内部定义的变量是局部变量，只在函数内部有效。在函数外部定义的变量是全局变量，在整个程序中有效。如果在函数内部需要修改全局变量，可以使用global关键字。

局部变量

例如：

def my_function():
    x = 10
    print("Inside function:", x)
my_function()
print("Outside function:", x)

这将输出：

Inside function: 10 NameError: name 'x' is not defined

全局变量

例如：

x = 10
def my_function():
    global x
    x = 20
    print("Inside function:", x)
my_function()
print("Outside function:", x)

这将输出：

Inside function: 20 Outside function: 20

五、嵌套函数和闭包

Python允许在函数内部定义函数，这种函数称为嵌套函数。嵌套函数可以访问外部函数的变量，形成闭包。

嵌套函数

例如：

def outer_function():
    def inner_function():
        print("Hello from inner function!")
    inner_function()
outer_function()

这将输出：

Hello from inner function!

闭包

闭包是指嵌套函数引用了外部函数的变量，并且外部函数返回了嵌套函数。例如：

def make_multiplier(factor):
    def multiplier(x):
        return x * factor
    return multiplier
times2 = make_multiplier(2)
times3 = make_multiplier(3)
print(times2(5))
print(times3(5))

这将输出：

10 15

六、递归函数

递归函数是指在函数内部调用自身的函数。递归函数通常用于解决分解问题，如计算阶乘、斐波那契数列等。

递归函数示例

例如，计算阶乘的递归函数：

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

这将输出：

120

七、lambda函数

lambda函数是一种匿名函数，使用lambda关键字定义。lambda函数可以接受任意数量的参数，但只能有一个表达式。lambda函数常用于需要短小函数的场景，如排序、过滤等。

lambda函数示例

例如，定义一个简单的lambda函数并调用：

add = lambda x, y: x + y
print(add(3, 5))

这将输出：

8

lambda函数与内置函数结合使用

lambda函数常与Python内置的高阶函数如map、filter、sorted等结合使用。例如，使用lambda函数对列表进行排序：

points = [(1, 2), (3, 1), (5, 4), (2, 3)]
sorted_points = sorted(points, key=lambda point: point[1])
print(sorted_points)

这将输出：

[(3, 1), (1, 2), (2, 3), (5, 4)]

八、装饰器

装饰器是一种高级函数，用于在不改变原函数代码的情况下，扩展或修改函数的功能。装饰器本质上是一个函数，它接受一个函数作为参数，并返回一个新的函数。

定义装饰器

例如，定义一个简单的装饰器：

def my_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()
        print("Something is happening after the function is called.")
    return wrapper

使用装饰器

使用装饰器有两种方式：显式调用和使用@语法糖。显式调用：

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

这将输出：

Something is happening before the function is called.
Hello!
Something is happening after the function is called.

使用@语法糖：

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

这将输出相同的结果：

Something is happening before the function is called.
Hello!
Something is happening after the function is called.

带参数的装饰器

装饰器还可以接受参数。例如，定义一个带参数的装饰器：

def repeat(num_times):
    def decorator_repeat(func):
        def wrapper(*args, kwargs):
            for _ in range(num_times):
                func(*args, kwargs)
        return wrapper
    return decorator_repeat
@repeat(num_times=3)
def say_hello(name):
    print(f"Hello, {name}!")
say_hello("Alice")

这将输出：

Hello, Alice! Hello, Alice! Hello, Alice!

九、函数注解

函数注解用于为函数的参数和返回值添加元数据。注解本身不会影响函数的行为，但可以用于文档生成、类型检查等。使用注解时，参数注解放在参数名后，返回值注解放在函数定义的->后。

函数注解示例

例如，定义一个带注解的函数：

def add(a: int, b: int) -> int:
    return a + b
print(add(3, 5))
print(add.__annotations__)

这将输出：

8
{'a': <class 'int'>, 'b': <class 'int'>, 'return': <class 'int'>}

十、文档字符串

文档字符串（Docstring）是用于描述函数、类、模块等的字符串，通常放在定义的第一行。文档字符串有助于生成文档和提高代码可读性。文档字符串使用三重引号（'''或"""）包围。

定义文档字符串

例如，定义一个带文档字符串的函数：

def greet(name: str) -> None:
    """This function greets to the person passed in as parameter.
    Args:
        name (str): The name of the person to greet.
    Returns:
        None
    """
    print("Hello, " + name + "!")
print(greet.__doc__)

这将输出：

This function greets to the person passed in as parameter.
Args:
    name (str): The name of the person to greet.
Returns:
    None

十一、生成器

生成器是一种特殊的迭代器，使用yield关键字返回值。生成器在每次调用时保存状态，可以在下一次调用时恢复执行。生成器常用于处理大数据集或流式数据。

定义生成器

例如，定义一个简单的生成器：

def count_up_to(max):
    count = 1
    while count <= max:
        yield count
        count += 1
counter = count_up_to(5)
for num in counter:
    print(num)

这将输出：

1 2 3 4 5

使用生成器表达式

生成器表达式类似于列表推导式，但使用圆括号而不是方括号。生成器表达式在需要时生成值，而不是一次性生成所有值。

例如，定义一个简单的生成器表达式：

squares = (x * x for x in range(5))
for square in squares:
    print(square)

这将输出：

0 1 2 4 9 16

十二、协程

协程是一种高级的生成器，可以在函数内部暂停和恢复执行。协程使用async def定义，并使用await关键字暂停执行。协程常用于异步编程。

定义协程

例如，定义一个简单的协程：

import asyncio
async def say_hello():
    print("Hello!")
    await asyncio.sleep(1)
    print("Goodbye!")
asyncio.run(say_hello())

这将输出：

Hello! （等待一秒钟） Goodbye!

使用异步生成器

异步生成器类似于生成器，但使用async def定义，并使用yield和await关键字。

例如，定义一个简单的异步生成器：

async def async_count_up_to(max):
    count = 1
    while count <= max:
        yield count
        count += 1
        await asyncio.sleep(1)
async def main():
    async for num in async_count_up_to(5):
        print(num)
asyncio.run(main())