Python函数、参数变量详细介绍

Python函数概述

在Python中，函数是组织好的、可重复使用的代码块，用于实现单一或相关联功能。函数能提高应用的模块性和代码的重复利用率。除了内建函数外，Python还支持用户自定义函数。

定义函数

自定义函数使用 def 关键字开始定义。函数的基本语法如下：

def function_name(parameters):
    """docstring"""
    # 函数体
    # ...
    return value

• function_name 是函数的名称。
• parameters 是传递给函数的参数。
• docstring 是一个可选的字符串，用于描述函数的作用。
• return 语句用于从函数返回一个值。

示例代码

下面是一个简单的函数定义和调用的例子：

# 定义一个函数
def greet():
    return "Hello, World!"

# 调用函数并打印返回值
print(greet())  # 输出: Hello, World!

参数和返回值

函数可以接受参数，这些参数可以在函数内部使用。函数还可以返回值。

# 定义一个带参数的函数
def add(a, b):
    """返回两个数的和"""
    return a + b

# 调用函数并打印返回值
print(add(5, 3))  # 输出: 8

默认参数

函数还可以有默认参数，这意味着在调用函数时可以省略具有默认值的参数。

def say_hello(name="Guest"):
    print("Hello, " + name)

say_hello()  # 输出: Hello, Guest
say_hello("Alice")  # 输出: Hello, Alice

关键字参数

函数还可以接受关键字参数，这意味着在调用函数时可以通过参数名指定参数。

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

print_info(age=25, name="Alice")  # 输出: Name: Alice Age: 25

在Python中，*args和**kwargs是两种特殊的参数，它们允许函数接收任意数量的位置参数和关键字参数。这种特性在函数定义中非常有用，因为它使得函数能够灵活地处理不同数量和类型的参数。

*args（可变位置参数）和 **kwargs（可变关键字参数）

*args

*args用于函数定义中，允许函数接收任意数量的位置参数。这些参数在函数内部作为一个元组（tuple）处理。使用*args可以使得函数调用时传入的参数数量更加灵活。

例如，下面的函数使用了*args来接收任意数量的参数，并打印它们：

def print_args(*args):
    for arg in args:
        print(arg)

print_args(1, 2, 3)  # 输出 1 2 3
print_args('a', 'b')  # 输出 a b

在这个例子中，*args收集了所有未命名的位置参数，并在函数内部遍历打印它们。

**kwargs

**kwargs同样用于函数定义中，但它允许函数接收任意数量的关键字参数。这些参数在函数内部作为一个字典（dict）处理。使用**kwargs可以使得函数能够接收任意数量的命名参数，而不需要在函数定义时明确指定。

例如，下面的函数使用了**kwargs来接收任意数量的关键字参数，并打印它们：

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

print_kwargs(a=1, b=2)  # 输出 a: 1 b: 2
print_kwargs(name='Alice', age=25)  # 输出 name: Alice age: 25

在这个例子中，**kwargs收集了所有命名的关键字参数，并在函数内部遍历打印它们的键和值。

同时使用*args和**kwargs

在同一个函数定义中同时使用*args和**kwargs，但*args必须位于**kwargs之前。这是因为*args用于收集位置参数，而**kwargs用于收集关键字参数。

def print_all_args_kwargs(*args, **kwargs):
    print("Positional arguments:")
    for arg in args:
        print(arg)
    print("Keyword arguments:")
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_all_args_kwargs(1, 2, 3, a=4, b=5)  # 输出 1 2 3 和 a: 4 b: 5

在这个例子中，*args收集了位置参数1, 2, 3，而**kwargs收集了关键字参数a=4和b=5。

匿名函数

Python还提供了匿名函数，也称为lambda函数。这种函数的特点是它们没有名称。

# 定义一个匿名函数
add = lambda x, y: x + y

# 使用匿名函数
print(add(5, 3))  # 输出: 8

函数注解

Python 3引入了函数注解，允许指定参数和返回值的类型。但是不一定要强制遵守。

def add(a: int, b: int) -> int:
    return a + b

print(add(5, 3))  # 输出: 8

在Python中，变量的命名空间和作用域是两个相关的概念，它们共同决定了在特定的代码块中如何访问和修改变量。

命名空间（Namespace）

命名空间是Python用来存储变量名和其对应值的一种映射。每个变量都存在于某个特定的命名空间中。Python中有几种不同的命名空间：

1. 局部命名空间（Local Namespace）：在函数或类内部定义的变量存在于局部命名空间中。它们只能被该函数或类内部的代码访问。

2. 全局命名空间（Global Namespace）：在模块级别定义的变量存在于全局命名空间中。它们可以被模块内的所有函数和类访问。

3. 内置命名空间（Built-in Namespace）：包含Python解释器提供的内置函数和变量，如print()、len()等。

作用域（Scope）

作用域是指代码中可以访问特定变量的区域。Python的作用域遵循LEGB规则：

1. Local（L）：最内层的作用域，即函数内部或类的方法内部。

2. Enclosing（E）：包含局部作用域的作用域，通常是函数所在的模块。

3. Global（G）：全局作用域，即模块级别的命名空间。

4. Built-in（B）：最外层的作用域，包含内置的Python函数和变量。

代码示例

局部作用域

def my_function():
    local_var = "I am local"
    print(local_var)  # 输出: I am local

my_function()
# print(local_var)  # 报错: NameError, name 'local_var' is not defined

在这个例子中，local_var是局部变量，只能在my_function函数内部访问。

全局作用域

global_var = "I am global"

def my_function():
    print(global_var)  # 输出: I am global

my_function()

# 也可以在函数内部修改全局变量
def modify_global():
    global global_var
    global_var = "Modified global"
print(global_var)  # 输出: I am global
modify_global()
print(global_var)  # 输出: Modified global

global_var是全局变量，可以在模块的任何地方访问和修改。使用global关键字，在函数内部使用global关键字可以声明一个变量为全局变量，这样就可以在函数内部访问和修改全局命名空间中的变量。

嵌套作用域

def outer_function():
    var_in_outer = "Outer"
    def inner_function():
        print(var_in_outer)  # 输出: Outer
        local_var = "I am local in inner"
        print(local_var)  # 输出: I am local in inner
    inner_function()

outer_function()
# print(var_in_outer)  # 报错: NameError, name 'var_in_outer' is not defined

在这个例子中，inner_function可以访问其外部函数outer_function的局部变量var_in_outer，但var_in_outer不能在inner_function外部访问。

闭包和非局部（Nonlocal）

闭包是一个函数，它记住了创建它的环境。在嵌套函数中，如果内部函数想要访问外部函数的局部变量（但不是全局或内置变量），可以使用nonlocal关键字。

def outer_function():
    var_in_outer = "Outer"
    def inner_function(nonlocal_var):
        nonlocal_var += " and inner"
        print(nonlocal_var)
    inner_function(var_in_outer)
    print(var_in_outer)  # 输出: Outer and inner

outer_function()

在这个例子中，inner_function通过nonlocal关键字修改了外部函数outer_function的局部变量var_in_outer。

闭包的概念

闭包（Closure）是Python中一个重要的概念，它指的是一个函数能够记住并访问其创建时所在的作用域内的变量和状态，即使这个函数在其原始定义的作用域之外被调用。闭包常用于创建带有特定状态的函数，或者用来封装函数式编程中的数据。

闭包的作用主要体现在以下几个方面：

1. 封装状态：闭包允许创建一个函数，这个函数不仅封装了行为（即要执行的操作），还封装了状态（即数据）。这对于创建不可变函数或者创建具有持久状态的函数非常有用。

2. 数据隐藏：闭包可以隐藏内部状态，这些状态对于外部代码是不可见的。这有助于实现数据的封装和隐私保护。

3. 创建装饰器：闭包是实现装饰器（Decorator）的基础。装饰器是一种设计模式，它允许在不修改原始函数代码的情况下，增加函数的新功能。

4. 延迟计算：闭包可以用来实现延迟计算，即只有在需要时才计算某些值，这可以提高程序的效率。

代码示例

下面是一个简单的闭包示例，它展示了如何使用闭包来封装状态：

def make_counter():
    count = 0  # 这是闭包将访问的外部变量
    def counter():
        nonlocal count  # 声明count为非局部变量
        count += 1
        return count
    return counter  # 返回闭包函数

# 创建一个计数器
my_counter = make_counter()

# 使用计数器
print(my_counter())  # 输出: 1
print(my_counter())  # 输出: 2
print(my_counter())  # 输出: 3

在这个例子中，make_counter函数内部定义了一个变量count，并且定义了一个counter函数。counter函数是一个闭包，因为它引用了外部函数make_counter中的变量count。每次调用my_counter()时，它都会增加count的值并返回新的计数。

装饰器示例

闭包也常用于创建装饰器，下面是使用闭包实现装饰器的一个例子：

def my_decorator(func):
    def wrapper(*args, **kwargs):
        print("Something is happening before the function is called.")
        result = func(*args, **kwargs)
        print("Something is happening after the function is called.")
        return result
    return wrapper

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

# 调用被装饰的函数
say_hello()

在这个例子中，my_decorator是一个装饰器工厂函数，它返回一个wrapper闭包函数。wrapper函数封装了对func的调用，并在其前后添加了额外的行为。当我们使用@my_decorator装饰say_hello函数时，实际上是在调用wrapper函数。这样，我们就可以在不修改say_hello函数的情况下，为其添加新的功能。

闭包是Python中一个强大的特性，它使得函数式编程在Python中成为可能，并且提供了一种灵活的方式来处理数据和状态。

魔法函数

在Python中，魔法函数（Magic Methods），也称为双下方法（Dunder Methods），是一些特殊的方法，它们以双下划线（__）开头和结尾。这些方法通常是Python内置的，用于实现特定的操作，比如对象的创建、访问、修改和销毁等。魔法方法通常是不能被直接调用的，而是在特定的操作中被Python解释器自动调用。

以下是一些常见的魔法方法及其用途：基本上魔法函数其形参必须要加上self。

1. __new__(cls, [...])：创建对象时调用，通常用于控制对象的创建过程。

2. __init__(self, [...])：在创建对象后调用，用于初始化对象。

3. __del__(self)：在对象被销毁之前调用，用于执行清理工作。

4. __repr__(self)：返回一个官方的字符串表示，通常用于调试。

5. __str__(self)：返回一个非正式的字符串表示，通常用于用户输出。

6. __eq__(self, other)：定义等于操作符的行为。

7. __ne__(self, other)：定义不等于操作符的行为。

8. __lt__(self, other)：定义小于操作符的行为。

9. __le__(self, other)：定义小于等于操作符的行为。

10. __gt__(self, other)：定义大于操作符的行为。

11. __ge__(self, other)：定义大于等于操作符的行为。

12. __add__(self, other)：定义加法操作符的行为。

13. __sub__(self, other)：定义减法操作符的行为。

14. __mul__(self, other)：定义乘法操作符的行为。

15. __truediv__(self, other)：定义真除法操作符的行为。

16. __floordiv__(self, other)：定义地板除法操作符的行为。

17. __mod__(self, other)：定义取模操作符的行为。

18. __radd__(self, other)：定义反射加法操作符的行为。

19. __rsub__(self, other)：定义反射减法操作符的行为。

20. __rmul__(self, other)：定义反射乘法操作符的行为。

21. __repr__(self)：定义反引号操作符的行为。

22. __call__(self, [...])：允许一个对象像函数一样被调用。

23. __len__(self)：定义len()函数的行为。

24. __getitem__(self, key)：定义索引操作符[]的行为。

25. __setitem__(self, key, value)：定义索引赋值操作符[]的行为。

26. __delitem__(self, key)：定义删除操作符del的行为。

27. __iter__(self)：定义迭代器的获取。

28. __next__(self)：定义迭代器的下一个元素的获取。

29. __contains__(self, item)：定义in操作符的行为。

30. __call__(self, [...])：定义对象作为函数调用时的行为。

这些魔法方法使得Python对象的行为可以与内置类型的行为相匹配，甚至可以扩展到自定义类型。通过定义这些方法，可以扩展和定制对象的行为，使其更加符合的需求。

示例代码

下面是一个使用魔法方法的例子，我们定义一个简单的类，实现基本的创建、字符串表示和比较功能：

class MyClass:
    def __init__(self, value):
        self.value = value

    def __repr__(self):
        return f"MyClass({self.value})"

    def __str__(self):
        return f"Instance of MyClass with value {self.value}"

    def __eq__(self, other):
        if isinstance(other, MyClass):
            return self.value == other.value
        return NotImplemented

    def __lt__(self, other):
        if isinstance(other, MyClass):
            return self.value < other.value
        return NotImplemented

# 创建两个MyClass实例
a = MyClass(10)
b = MyClass(20)

# 使用魔法方法
print(a)  # 输出: Instance of MyClass with value 10
print(b)  # 输出: Instance of MyClass with value 20
print(a < b)  # 输出: True
print(a == b)  # 输出: False

在这个例子中，我们定义了MyClass类，并为其实现了__init__、__repr__、__str__、__eq__和__lt__等魔法方法。这些方法使得MyClass的实例可以被自然地使用，就像Python的内置类型一样。

在Python中，变量、函数和方法的注解是一种向代码添加元数据的方式，它提供了对变量、函数参数和返回值的类型信息以及其他额外信息的说明。注解本身不会影响代码的执行，但可以为代码的阅读和维护提供更多的信息。

变量、函数、方法注解

变量注解

变量注解可以在变量声明时使用，用于说明变量的类型或其他相关信息。变量注解通常使用冒号 : 后面跟着类型信息的形式。

x: int = 10  # 声明一个整数类型的变量 x

函数注解

函数注解可以在函数的参数列表和返回值上使用，用于说明参数的类型和返回值的类型，以及其他相关信息。函数注解需要在函数定义的冒号 : 后面使用箭头 -> 指定返回值类型。

def add(x: int, y: int) -> int:
    """返回两个整数的和"""
    return x + y

方法注解

方法注解与函数注解类似，可以在类中的方法定义时使用，用于说明方法的参数类型和返回值类型。

class MyClass:
    def __init__(self, value: int):
        self.value = value
    
    def double_value(self) -> int:
        """将对象的值加倍并返回"""
        return self.value * 2

示例代码

下面是一个包含变量、函数和方法注解的完整示例代码：

x: int = 10  # 变量注解

def add(x: int, y: int) -> int:  # 函数注解
    """返回两个整数的和"""
    return x + y

class MyClass:
    def __init__(self, value: int):
        self.value = value
    
    def double_value(self) -> int:  # 方法注解
        """将对象的值加倍并返回"""
        return self.value * 2

# 调用函数和方法
result = add(5, 3)
print("Result of addition:", result)

obj = MyClass(5)
double_result = obj.double_value()
print("Double value:", double_result)

在上述示例中，我们使用了变量、函数和方法的注解来说明它们的类型信息，包括参数的类型和返回值的类型。这样可以使代码更加清晰易懂，提高代码的可读性和可维护性。注意，注解本身不会影响代码的执行，它们仅仅是提供了额外的信息。