python函数基础

一，函数

1.1，函数的定义

在Python中，使用 def 关键字定义函数。函数可以包含多个语句，当函数被调用时，这些语句将依次执行。函数的基本语法结构如下：

def 函数名(参数):
    # 函数体
    return 返回值

 举例：

def greet(name):
    print(f"Hello, {name}!")

 在这个例子中，greet 是函数名，name 是参数，print 语句是函数体，负责输出信息。

函数三要素：功能，参数，返回值

1.2，函数的调用

无返回值：函数名()

def f():
    print('a')

f()

有返回值：方法一：print(函数名())

方法二：变量名=函数名

def f(a):
    return a

b=f(a)
print(b)
print(f(a))

1.3，函数的传参

Python的函数支持多种参数传递方式，包括：

• 位置参数：按参数的顺序传递。
• 关键字参数：指定参数名称传递值，避免顺序错误。
• 默认参数：为某些参数设定默认值。
• 位置不定长参数：参数名前加 *，通过 *args 实现。将参数打包成——元组。
• 关键字不定长参数：参数名前加 **，通过  **kwargs 实现。将参数打包成——字典。

 实例：

#位置参数
def fun(a, b, c):
    print(a, b, c)
fun(1, 2, 3)

#关键字参数
def fun(name, age, sex):
    print(name, age, sex)
# 关键字参数
fun(name='张三', age=18, sex='男')
fun(age=18, sex='男', name='张三')

#默认参数 
def fun(name='张三', age=18, sex='男'):
    print(name, age, sex)
# 默认参数
fun()
fun('李四')
fun(age=66)
fun('小明', 30)
fun('小华', 23, '女')

#位置不定长参数
def fun(*num):
    print(num)
fun(1)
fun(1,2)
fun(1,2,3,4,5,6)

注意：在一个函数中，位置不定长参数，不可以有两个；一旦定义了位置不定参参数，也还可以定义，但是传参时必须是关键字参数

#关键字不定长参数
def fun(**kwargs):
    print(kwargs)

fun(a=12, b=13, c=15)
fun(姓名='张三', 年龄=18, 性别='男')

1.4，函数的返回值

函数的运行结果想在函数外使用时，需要设置返回值，函数可以通过 return 关键字返回一个或多个值，其中返回多个值时可以打包成一个元组。如果不写 return，则默认返回 None。返回值可以是任意数据类型，甚至是另一个函数。return返回值后结束函数。

例子：

def sum_and_product(a, b):
    return a + b, a * b

# 调用
s, p = sum_and_product(2, 3)
print(s, p)  # 输出：5 6

二，递归函数

递归函数是指调用自身的函数。在编写递归函数时，需设置终止条件，否则会陷入无限递归，导致栈溢出错误。

举例一个计算阶乘的递归函数示例：

def factorial(n):
    if n <= 1:  
        return 1  #终止 
    else:
        return n * factorial(n - 1)

# 调用
print(factorial(5))  # 输出：120

 在上述例子中，factorial(5) 调用了 factorial(4)，以此类推，直到调用 factorial(1) 时返回 1，逐层计算出结果。

循环和递归很相似，基本上他们两个可以相互转换。但是也有其区别：

1. 大多数情况下，循环的效率、性能更好一些
2. 循环代码容易书写，阅读性差
3. 递归代码写起来稍难，阅读性好

递归函数有三要素：

1. 边界条件/基线条件               跳出/结束递归的条件
2. 递归返回段                           满足结束条件时，返回
3. 递归前进段                           不满足结束条件时，前进/继续递归

三，函数中的变量作用域

Python中的变量作用域分为局部作用域和全局作用域。局部变量只在函数内部有效，而全局变量在整个程序中有效。

• 局部变量：在函数内部定义，只在函数内部有效，函数执行结束时局部变量生命周期结束。
• 全局变量：在函数外部定义，在整个程序范围内都可以访问，程序结束时全局变量声明周期结束。

 例子：

x=10        #全局变量
def f():
    x=20    #局部变量
    print(x)
f()         #输出20
print(x)    #输出10

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

x=10        #全局变量
def f():
    global x   #全局变量
    x=20
    print(x)
f()         #输出20
print(x)    #输出20

四，函数嵌套

函数嵌套是指在一个函数中定义另一个函数。嵌套函数可以访问外层函数的变量，从而实现更细致的封装。

def outer():
    x = 1
    y = 2

    def inner():
        nonlocal x
        x=11
        y=22
        print(f"x为{x},y为{y}")
    inner()   #输出 x为11,y为22
    print(f"x为{x},y为{y}")
    
outer()  #输出 x为11,y为2

 在这个例子中，inner 是 outer 函数内部的嵌套函数，能够访问 outer 中的局部变量 x，y。nonlocal 则是修饰该函数上一层的局部变量

通过上面的例子可以发现：

1.内函数局部变量 > 外函数局部变量 > 全局变量

2.global与nonlocal：

① global 修饰全局变量

② nonlocal 修饰该函数上一层的局部变量

五，闭包函数

闭包是一种特殊的嵌套函数。它在外层函数执行完毕后，仍然可以记住并访问外层函数的变量。这种特性使闭包在需要持久化状态的数据处理中非常有用。而并且外函数把内函数返回的过程就叫闭包

形成闭包的条件：

1. 函数嵌套
2. 将内函数作为返回值返回
3. 内函数必须使用外函数的局部变量

def multiplier(factor):
    def multiply(number):
        return number * factor
    return multiply

# 创建一个闭包函数
double = multiplier(2)
print(double(5))  # 输出：10
print(multiplier(2)(5))  # 输出：10

def multiplier(factor):
    def multiply(number):
        return number * factor
    return multiply(2)

# 创建一个闭包函数
print(multiplier(5))  # 输出：10

 在这个例子中，multiplier 函数返回了 multiply 函数，而 multiply 函数能够记住 factor 的值，即便 multiplier 已经结束执行。