python函数一

# python函数一

## 函数的基础定义
Python是一门函数式编程语言，函数在Python中扮演着非常重要的角色。在Python中，函数可以接收输入参数并返回输出结果，可以作为参数传递给其他函数，也可以定义在类中作为方法。

Python中定义函数的语法如下：
```python
def function_name(parameters):
    """函数文档字符串"""
    # 函数体
    return expression
```
其中，function_name为函数的名称，parameters是函数的输入参数列表，可以为空。函数体内的代码是实现函数功能的语句，可以包含一些控制流语句、变量定义、其他函数调用等等。函数可以返回一个表达式的值作为输出结果，也可以没有返回值。

函数的定义可以包含文档字符串，用于描述函数的功能、输入输出参数、使用方法等等。文档字符串以三个引号（'''或"""）开头和结尾，位于函数定义的第一行。

下面是一个简单的函数示例，实现对两个数进行求和的功能：

```python
def add(x, y):
    """将两个数相加并返回结果"""
    result = x + y
    return result
```
在调用该函数时，可以传递两个数作为输入参数，获取返回结果：

```python
a = 2
b = 3
c = add(a, b)
print(c)  # 输出：5
```
除了使用def语句定义函数外，Python还提供了lambda表达式用于定义匿名函数。lambda表达式的语法如下：

```python
lambda arguments: expression
```
其中，arguments是函数的输入参数列表，expression是一个表达式，表示函数的输出结果。例如，下面的lambda表达式实现了对两个数相加的功能：

```python
add = lambda x, y: x + y
c = add(2, 3)
print(c)  # 输出：5
```
函数是Python中的重要概念，掌握函数的使用方法对于编写高质量的Python代码非常重要。

## 函数的参数

在 Python 函数中，形参是在定义函数时指定的参数，而实参是在调用函数时传递给函数的参数。

形参是函数定义时使用的占位符，用来表示函数接收的参数。形参在函数调用时不占用内存空间，只有在函数调用时才会创建。

实参是函数调用时传递给函数的参数。实参会占用内存空间，它们的值会传递给函数内部的形参，函数可以使用这些值来完成特定的任务。

Python 中的参数传递方式有两种：位置参数和关键字参数。位置参数是按照参数定义的顺序进行传递，而关键字参数是按照参数名进行传递。同时，Python 还支持使用默认参数值和可变参数列表来扩展函数的功能。

### 位置参数

Python函数的位置参数是指在函数定义中，按照顺序声明的参数，调用函数时需要按照定义的顺序传入参数。例如，下面的函数中，a和b就是位置参数：

```python
Copy code
def add_numbers(a, b):
    return a + b
```
在调用函数时，需要按照定义的顺序传入参数：

```python
result = add_numbers(2, 3)
print(result) # 输出 5
```
在调用函数时，可以直接传入参数的值，也可以使用变量来传入参数的值：

```python
x = 4
y = 5
result = add_numbers(x, y)
print(result) # 输出 9
```
需要注意的是，调用函数时传入的参数数量必须与函数定义中参数数量一致，否则会抛出TypeError异常。

### 关键字参数
Python函数中的关键字参数是指通过指定形参名称来传递实参值的一种方式。关键字参数可以通过形参名称将值传递给函数，因此不需要按照特定的顺序传递参数。

例如，下面的函数定义中包含了两个关键字参数：

```python
Copy code
def greeting(name, message):
    print(f"{name}, {message}")
```
使用关键字参数时，可以按照以下方式将实参传递给该函数：

```python
greeting(name="John", message="Hello")
```

在这个例子中，我们将实参 "John" 通过关键字参数 name 传递给了 greeting() 函数，并将实参 "Hello" 通过关键字参数 message 传递给了函数。

使用关键字参数时，参数的顺序并不重要，只要指定了形参名称，函数就能正确地获取对应的实参值。

### 默认参数
Python函数的默认参数是指在定义函数时，为函数的参数设置一个默认值。在函数调用时，如果没有为该参数传入实参，则使用默认值作为该参数的值。

默认参数的定义方式为在函数定义时，在形参后面添加"="和默认值。例如：

```python
def greet(name, message="Hello"):
    print(message, name)

greet("Alice")  # 输出: Hello Alice
greet("Bob", "Hi")  # 输出: Hi Bob
```
在上面的例子中，函数greet有两个参数，其中message参数有一个默认值"Hello"。在调用函数时，可以不传递message参数，这样会自动使用默认值；也可以传递一个新的值来覆盖默认值。

### 可变参数

Python函数的可变参数指的是可以接受任意数量参数的函数，包括位置参数、关键字参数或混合参数。

在Python中，定义可变参数有两种方式：

args：使用args，可以接收任意数量的位置参数，参数将以元组(tuple)的形式传入函数中。
下面是一个使用*args的例子：

```python
def add(*args):
    sum = 0
    for arg in args:
        sum += arg
    return sum

print(add(1, 2, 3, 4, 5))  # 15
print(add(1, 2, 3))  # 6
```

kwargs：使用kwargs，可以接收任意数量的关键字参数，参数将以字典(dict)的形式传入函数中。
下面是一个使用**kwargs的例子：

```python
def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f'{key}: {value}')

print_info(name='Tom', age=20, sex='male')
# 输出：
# name: Tom
# age: 20
# sex: male
```
可以使用args和**kwargs组合来接受任意数量的参数，但是必须保证args参数在**kwargs参数之前。

下面是一个使用*args和**kwargs的例子：

```python
def print_info(*args, **kwargs):
    for arg in args:
        print(arg)
    for key, value in kwargs.items():
        print(f'{key}: {value}')

print_info('Tom', 20, 'male', city='Beijing', school='Tsinghua University')
# 输出：
# Tom
# 20
# male
# city: Beijing
# school: Tsinghua University
```
这个函数可以接受任意数量的位置参数和关键字参数。

总结：
- 位置参数（Positional Arguments）：在函数定义时，根据参数位置来确定其意义和取值。

- 关键字参数（Keyword Arguments）：在函数调用时，通过参数名来传递参数值，可以不按照参数位置顺序传递参数。

- 默认参数（Default Arguments）：在函数定义时，为参数指定默认值，调用函数时，如果不传递该参数，则使用默认值。

- 可变参数（Variable-length Arguments）：可变参数允许传递任意数量的参数，分为两种：*args和**kwargs。*args用于传递任意数量的位置参数，**kwargs用于传递任意数量的关键字参数。

下面是一个函数参数类型的示例代码：

```python
# 位置参数
def func1(a, b, c):
    print(a, b, c)

# 关键字参数
def func2(a, b, c):
    print(a, b, c)

# 默认参数
def func3(a, b, c=0):
    print(a, b, c)

# 可变位置参数
def func4(*args):
    for arg in args:
        print(arg)

# 可变关键字参数
def func5(**kwargs):
    for key, value in kwargs.items():
        print(key, value)

# 调用函数
func1(1, 2, 3)  # 输出：1 2 3
func2(c=3, a=1, b=2)  # 输出：1 2 3
func3(1, 2)  # 输出：1 2 0
func4(1, 2, 3)  # 输出：1 2 3
func5(a=1, b=2, c=3)  # 输出：a 1  b 2  c 3
```

## 函数的返回值

函数可以通过return语句返回值。return语句可以返回任何类型的数据，包括数字、字符串、列表、元组、字典、集合等等。如果函数没有指定返回值，则默认返回None。

函数返回值的作用主要有以下两点：

- 将计算结果返回给调用者，使其能够继续进行操作或者输出结果；
- 在函数内部使用返回值进行逻辑判断，从而实现某些特定的功能。
函数可以返回单个值，也可以返回多个值。如果返回多个值，则返回的值被封装在一个元组中，可以使用元组解包的方式获取其中的值。

以下是一个返回单个值的函数的示例：

```python
def add(x, y):
    return x + y

result = add(2, 3)
print(result) # 输出：5
```
以下是一个返回多个值的函数的示例：
```python
Copy code
def get_user_info(user_id):
    # 从数据库中获取用户信息
    name = "张三"
    age = 28
    gender = "男"
    return name, age, gender

name, age, gender = get_user_info(1001)
print(name)   # 输出：张三
print(age)    # 输出：28
print(gender) # 输出：男
```
需要注意的是，在函数内部使用return语句时，如果有多个return语句，则只会执行第一个return语句，后面的return语句不会被执行。如果函数没有return语句，则默认返回None。

## 函数变量的作用域

变量的作用域是指变量可以被访问的范围，可以分为全局作用域和局部作用域。

全局作用域是指在程序的任何地方都可以访问的变量。在函数外定义的变量默认具有全局作用域，可以通过在函数内使用global关键字来在函数内部访问和修改全局变量。

局部作用域是指在函数内部定义的变量，只能在函数内部访问。当函数执行结束后，局部变量会被销毁。

在Python中，变量的作用域遵循LEGB规则，即：

- Local（局部）：函数内部的作用域
- Enclosing（嵌套）：嵌套函数内部的作用域
- Global（全局）：模块级别的作用域
- Built-in（内置）：Python内置函数的作用域

在使用变量时，Python会按照LEGB的顺序查找变量。如果在当前作用域内找不到变量，则会向上一级作用域查找，直到找到该变量或者查找到全局作用域。如果还没有找到，则会引发NameError异常。