Python小白学习教程从入门到入坑------第十六课 函数进阶 [作用域、匿名函数]（语法基础）

一、作用域

在Python中，作用域（Scope）指的是变量、函数和类等标识符可以被访问的代码区域。Python主要有四种作用域，分别是：局部作用域、全局作用域、嵌套作用域

注意：

1、函数间不能共享内部定义的变量格式

2、函数内可以使用全局变量

1.1 局部作用域

• 定义在函数或方法内部的变量和函数
• 局部作用域内的变量只能在该函数或方法内部访问，外部无法直接访问

作用：在函数体内部，临时保存数据，即当函数调用完成之后，就销毁局部变量

注意：函数内部定义的变量从定义位置开始到函数定义结束位置有效

eg:

def funa():
    num = 10  # 局部变量
    print("num:",num)  # 输出结果：num: 10
funa()
# print("num:",num)  # 报错，局部变量只能在被定义的函数中使用，函数外部不能使用
# 作用：在函数体内部，临时保存数据，即当函数调用完成之后，就销毁局部变量

1.2 全局作用域

• 定义在模块级别的变量和函数
• 全局作用域内的变量可以在整个模块中访问
• 在函数内部使用 global 关键字可以访问和修改全局变量

注意：函数外边定义的变量在整个文件中有效

eg：

a = 100  # 全局变量
def test():
    print("这是test1中a的值：",a)
def test2():
    a = 120  # 局部变量
    print("这是test1中a的值：",a)
print("调用函数前a的值",a)
test()
test2()
print("调用函数后a的值",a)
# 调用函数前a的值 100
# 这是test1中a的值： 100
# 这是test1中a的值： 120
# 调用函数后a的值 100

# a的值没有被覆盖是因为函数内部如果要使用变量，会先从函数内部找，有的话就直接使用，没有会到函数外边找

小tips（global关键字的使用）：

#  全局变量和局部变量命名相同时，在函数内部修改全局变量的值，可以使用global关键字，将变量声明为全局变量 

语法格式：global  变量名

eg1：

a = 100  # 全局变量
def test():
    print("这是test1中a的值：",a)
def test2():
    global a  # 声明全局变量
    a = 120
    print("这是test1中a的值：",a)
print("调用函数前a的值",a)
test()
test2()
print("调用函数后a的值",a)
# 调用函数前a的值 100
# 这是test1中a的值： 100
# 这是test1中a的值： 120
# 调用函数后a的值 120

eg2： 

def study():
    global name,age          # 将多个局部变量name声明为全局变量
    age = 18  # 局部变量
    name = "python基础"  # 局部变量
    print(f"{age}的我们在学习{name}")
study()       # 18的我们在学习python基础
print(name)   # python基础

总结： global 关键字可以对全局变量进行修改，也可以在局部作用域中声明一个全局变量

1.3 嵌套作用域

• 定义在嵌套函数（内部函数）中，但外部函数（封闭函数）的变量可以被内部函数访问
• 使用 nonlocal 关键字可以在嵌套函数中修改外部函数的变量

注意：nonlocal关键字用来声明外层的局部变量，只能在嵌套函数中使用，在外边函数先进行声明，内部函数进行nonlocal声明（了解即可）

eg： 

def outer_func():  
    x = 10  # 定义外层函数的局部变量x，并赋值为10  
  
    def inner_func():  
        nonlocal x  # 声明x为非全局变量，而是外层函数的局部变量  
        x = 20  # 修改外层函数的局部变量x的值为20  
  
    inner_func()  # 调用内层函数  
    print(x)  # 输出外层函数的局部变量x的值  
  
outer_func()  # 调用外层函数，输出结果为20

解释：

1. 定义外层函数：outer_func是一个外层函数，它定义了一个局部变量x，并赋值为10
2. 定义内层函数：在外层函数内部，定义了一个嵌套的内层函数inner_func
3. 使用nonlocal关键字：在内层函数中，使用nonlocal关键字声明变量x为非全局变量，而是外层函数的局部变量。这意味着内层函数可以修改外层函数中定义的变量x的值
4. 修改外层变量的值：内层函数中，将外层函数的局部变量x的值修改为20
5. 调用内层函数：在外层函数中，调用内层函数inner_func
6. 输出结果：在外层函数中，打印变量x的值，由于内层函数已经修改了外层函数的局部变量x的值，因此输出结果为20

关键点：

• nonlocal关键字用于嵌套函数中，以修改外层函数的局部变量
• 使用nonlocal关键字时，必须确保外层函数中已经定义了该变量，否则会导致错误
• nonlocal关键字不能用于修改全局变量，只能用于修改外层函数的局部变量

二、匿名函数

2.1 基本语法

语法：函数名 = lambda   形参：返回值（表达式）

lambda 是定义匿名函数的关键字，相当于函数的def

调用：结果 = 函数名（实参）、

eg：

# 普通函数
def add(a,b):
    return a + b
print(add(1,3))    # 输出结果：4

# 匿名函数
add = lambda a,b:a + b   # a,b就是匿名函数的形参，a+b是返回值的表达式
# lambda不需要写return来返回值，表达式本身结果就是返回
print(add(1,5))    # 输出结果：6

2.2 lambda的参数形式

语法：函数名 = lambda   形参：返回值（表达式）

1、无参数

eg：

funa = lambda :"一桶水果茶"
print(funa())
# 输出结果：一桶水果茶

2、一个参数

eg：

funb = lambda name:name
print(funb('xiao ming'))
# 输出结果：xiao ming

3、 默认参数

注意：默认参数必须写在非默认参数后面

eg:

func = lambda name,age=18:(name,age)  # 默认参数为age=18，返回值以元组形式输出
print(func('xiao ming'))      # 输出结果: ('xiao ming', 18)  无参数输入则用默认参数18
print(func('xiao ming',20))   # 输出结果：('xiao ming', 20)  有参数输入则用输入参数20

fune = lambda a,b,c=12:a+b+c
print(fune(1,2,4))   # 7，输入参数时，用输入参数计算1+2+4
print(fune(1,2))     # 15，无输入参数时，用默认参数计算1+2+12
# print(fune(1))  # 报错，参数数量不足

4、关键字参数（可变参数）

eg：

fund = lambda **kwargs:kwargs  # kwargs是约定的，可以更换为其他字母
print(fund(name='xiaoming',age=18))
# 输出结果: {'name': 'xiaoming', 'age': 18}

2.3 lambda结合if判断 

lambda 函数是一种简洁的匿名函数，通常用于定义简单的、一次性的函数。虽然 lambda 函数本身不支持 if-else 语句，但你可以使用三目运算符（也称为条件表达式）来实现类似的逻辑判断

三元运算符的语法是：

<value_if_true> if <condition> else <value_if_false>

eg:
a = 8
b = 5
# 为真结果 if 条件 else 为假结果
print("a比b小") if a<b else print("a大于等于b")
# 输出结果：a大于等于b

# 转为lambda
comp = lambda a,b:"a比b小" if a<b else "a大于等于b"
print(comp(1,5))
# 输出结果：a比b小

下面是一些结合 lambda 和三元运算符的示例：

eg1：判断奇偶性

定义一个 lambda 函数来判断一个数字是奇数还是偶数，并返回相应的字符串

is_even = lambda x: "even" if x % 2 == 0 else "odd"  
  
print(is_even(4))  # 输出: even  偶数
print(is_even(7))  # 输出: odd 单数

eg2：根据年龄分组

定义一个 lambda 函数来根据年龄将人分为“child”、“teenager”和“adult”

age_group = lambda age: "child" if age < 13 else ("teenager" if age < 20 else "adult")  
  
print(age_group(10))  # 输出: child  
print(age_group(15))  # 输出: teenager  
print(age_group(25))  # 输出: adult

eg3：判断数字的正负

定义一个 lambda 函数来判断一个数字是正数、负数还是零，并返回相应的字符串

number_status = lambda x: "positive" if x > 0 else ("negative" if x < 0 else "zero")  
  
print(number_status(5))   # 输出: positive  
print(number_status(-3))  # 输出: negative  
print(number_status(0))   # 输出: zero

注意：

1. 可读性：虽然 lambda 函数和三元运算符可以使代码更简洁，但过度使用可能会降低代码的可读性。在复杂逻辑中，建议使用完整的 def 函数和 if-else 语句
2. 功能限制：lambda 函数只能包含一个表达式，不能包含多个语句，因此，对于复杂的逻辑判断，lambda 可能不是最佳选择