python如何调用定义的函数

Python调用定义的函数的方法有：使用函数名和括号、传递参数、返回值等。

例如，如果你定义了一个函数greet()，可以通过在代码中写greet()来调用它。若函数需要参数，只需在调用时传递相应的参数。函数可以返回值，使用return关键字。下面详细介绍这些方法。

一、定义和调用函数

在Python中，定义函数使用def关键字，后跟函数名和括号。函数体缩进显示。

def greet():
    print("Hello, world!")

定义函数后，通过调用函数名和括号来执行函数的代码：

greet()  # 输出：Hello, world!

二、传递参数

函数可以接受参数，参数在函数定义时的括号中列出。调用函数时，传递实际的参数值。

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

可以定义多个参数：

def add(a, b):
    return a + b
result = add(3, 4)  # result 为 7

三、返回值

函数可以返回一个值，用return关键字。返回值可以在调用函数时接收。

def square(x):
    return x * x
result = square(5)  # result 为 25

四、默认参数值

在函数定义时，可以给参数设置默认值，这样在调用函数时可以省略这些参数。

def greet(name="World"):
    print(f"Hello, {name}!")
greet()        # 输出：Hello, World!
greet("Alice") # 输出：Hello, Alice!

五、关键字参数

在调用函数时，可以使用关键字参数，即在传递参数时明确指定参数名，这样可以不按顺序传递参数。

def greet(name, message):
    print(f"{message}, {name}!")
greet(name="Alice", message="Good morning")  # 输出：Good morning, Alice!
greet(message="Good evening", name="Bob")    # 输出：Good evening, Bob!

六、可变参数

有时函数需要接受不定数量的参数，可以使用*args和kwargs。

*args用于接收任意数量的位置参数，参数在函数内部作为元组处理。
kwargs用于接收任意数量的关键字参数，参数在函数内部作为字典处理。

def greet(*names):
    for name in names:
        print(f"Hello, {name}!")
greet("Alice", "Bob", "Charlie")  # 输出：Hello, Alice! Hello, Bob! Hello, Charlie!
def greet_with_message(kwargs):
    for name, message in kwargs.items():
        print(f"{message}, {name}!")
greet_with_message(Alice="Good morning", Bob="Good evening")  
输出：Good morning, Alice! Good evening, Bob!

七、嵌套函数

在Python中，可以在一个函数内部定义另一个函数，这称为嵌套函数。

def outer_function(text):
    def inner_function():
        print(text)
    inner_function()
outer_function("Hello from outer function!")  # 输出：Hello from outer function!

八、匿名函数（Lambda函数）

Python还支持匿名函数，即没有名字的函数，使用lambda关键字。

square = lambda x: x * x
result = square(5)  # result 为 25
add = lambda a, b: a + b
result = add(3, 4)  # result 为 7

九、递归函数

递归函数是指在函数内部调用自身的函数。需要注意递归的终止条件以避免无限递归。

def factorial(n):
    if n == 1:
        return 1
    else:
        return n * factorial(n-1)
result = factorial(5)  # result 为 120

十、文档字符串

可以为函数添加文档字符串，用于说明函数的功能、参数和返回值。文档字符串放在函数定义的第一行，使用三引号。

def greet(name):
    """Greets a person with their name.
    Args:
        name (str): The name of the person to greet.
    Returns:
        None
    """
    print(f"Hello, {name}!")
print(greet.__doc__)

十一、作用域

函数内部的变量被称为局部变量，只在函数内部可见。函数外部的变量被称为全局变量，可以在整个程序中访问。

x = "global"
def foo():
    x = "local"
    print(x)  # 输出：local
foo()
print(x)  # 输出：global

使用global关键字可以在函数内部修改全局变量：

x = "global"
def foo():
    global x
    x = "modified global"
    print(x)  # 输出：modified global
foo()
print(x)  # 输出：modified global

十二、装饰器

装饰器是一个函数，接受另一个函数作为参数，并返回一个新的函数。装饰器用于修改或增强函数的行为。

def decorator_function(original_function):
    def wrapper_function():
        print("Wrapper executed this before {}".format(original_function.__name__))
        return original_function()
    return wrapper_function
@decorator_function
def display():
    print("Display function ran")
display()
输出：
Wrapper executed this before display
Display function ran

装饰器可以接受参数并返回一个新的装饰器：

def decorator_function(original_function):
    def wrapper_function(*args, kwargs):
        print("Wrapper executed this before {}".format(original_function.__name__))
        return original_function(*args, kwargs)
    return wrapper_function
@decorator_function
def display_info(name, age):
    print("Display_info ran with arguments ({}, {})".format(name, age))
display_info('John', 25)
输出：
Wrapper executed this before display_info
Display_info ran with arguments (John, 25)

十三、内置函数和自定义函数

Python有许多内置函数，如print(), len(), type()等，可以直接使用。我们也可以定义自己的函数来实现特定功能。

# 内置函数使用
print(len("Hello, world!"))  # 输出：13
自定义函数
def multiply(a, b):
    return a * b
print(multiply(3, 4))  # 输出：12

十四、函数注解

Python允许为函数的参数和返回值添加注解，这样可以为函数的使用提供更多信息。这些注解不会影响函数的行为，只是用作元数据。

def greet(name: str) -> str:
    return f"Hello, {name}!"
print(greet("Alice"))  # 输出：Hello, Alice!

十五、异步函数

异步函数使用async和await关键字，可以在等待I/O操作时不阻塞程序的执行。这在处理网络请求或文件操作时非常有用。

import asyncio
async def fetch_data():
    print("Start fetching")
    await asyncio.sleep(2)  # 模拟I/O操作
    print("Done fetching")
    return {"data": 123}
async def main():
    result = await fetch_data()
    print(result)
asyncio.run(main())
输出：
Start fetching
Done fetching
{'data': 123}

十六、生成器函数

生成器函数使用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

十七、函数的高阶函数

高阶函数是指接受一个或多个函数作为参数，或者返回一个函数的函数。常见的高阶函数有map(), filter(), reduce()等。

def add_one(x):
    return x + 1
numbers = [1, 2, 3, 4]
result = map(add_one, numbers)
print(list(result))  # 输出：[2, 3, 4, 5]
def is_even(x):
    return x % 2 == 0
result = filter(is_even, numbers)
print(list(result))  # 输出：[2, 4]
from functools import reduce
def add(a, b):
    return a + b
result = reduce(add, numbers)
print(result)  # 输出：10

十八、函数的柯里化

柯里化（Currying）是指将一个接受多个参数的函数转换为一系列接受单个参数的函数。可以使用嵌套函数或偏函数来实现柯里化。

def add(a):
    def add_b(b):
        return a + b
    return add_b
add_five = add(5)
print(add_five(3))  # 输出：8
from functools import partial
add = lambda a, b: a + b
add_five = partial(add, 5)
print(add_five(3))  # 输出：8

十九、函数的闭包

闭包是指函数内部的函数引用了外部函数的变量，并且外部函数返回这个内部函数。闭包可以用于创建具有私有数据的函数。

def make_counter():
    count = 0
    def counter():
        nonlocal count
        count += 1
        return count
    return counter
counter = make_counter()
print(counter())  # 输出：1
print(counter())  # 输出：2

二十、函数的命名空间和作用域

函数的命名空间是指函数内部定义的变量和函数。作用域是指变量和函数的可见范围。Python有四种作用域：局部作用域、嵌套作用域、全局作用域和内置作用域。

x = "global"
def outer():
    x = "outer"
    def inner():
        x = "inner"
        print(x)  # 输出：inner
    inner()
    print(x)  # 输出：outer
outer()
print(x)  # 输出：global

总结，Python调用定义的函数的方式多种多样，包括基本的调用、传递参数、返回值、使用默认参数、关键字参数、可变参数、嵌套函数、匿名函数、递归函数、装饰器、内置函数、自定义函数、函数注解、异步函数、生成器函数、高阶函数、函数柯里化、闭包以及命名空间和作用域等。掌握这些方法可以帮助你更灵活地编写和调用函数，提高代码的可读性和可维护性。