函数的进阶 局部变量和全局变量 匿名函数 递归函数

函数的进阶

1.函数的返回值

1. 什么是返回值

返回值是从函数里面传递到到函数外面的数据

1. 怎么返回数据

返回值就是return 关键字后面的表达式

语法：

return 表达式1，表达式2，。。。

说明：

return – 关键字，只能在函数体中

​ 将数据从函数内传到函数外部 结束函数（执行函数的时候只要遇到return函数直接结束）

表达式 – 可以一个都没有（相当于None），可以由一个（返回值就是指定数据）或多个（本质返回的是一个元组）

2. 怎么在外部使用返回值返回的数据

返回值就是函数调用的表达式的值

2.什么时候需要返回值（初学者）

看函数的功能会不会产生新的数据，如果产生了新的数据，就将这个数据作为返回值返回

def yt_sum(n):
    # n = 5
    sum1 = 0
    for x in range(n+1):
        sum1 += x
    # print(sum1)
    # return None
    return sum1
print(yt_sum(10))    # 55

普通函数能做的事情函数调用表达式都能做

a = yt_sum(10)
print('a:', a)  # a：55
print(yt_sum(10))  # 55

# print(10 * 2)
print(yt_sum(10) * 2)  # 110

# list1 = [10, 20, 30]
list1 = [yt_sum(10), 20, 30]
print(list1)   # [55,20,30]

def fun1():
    return [1, 2, 3]


print(fun1()[1])   # 2

3.函数调用的过程（非常重要！）

第一步：回到函数定义的位置

第二部：传参（用实参给形参赋值；传参的时候必须保证每个参数都有值）

第三步：执行函数体

第四步：执行完函数体（1.执行完函数体中的最后一条语句 2.遇到了return），确定函数返回值（看执行完函数体有没有遇到return，遇到了函数的返回值就是return后面表达式的值，否者就是None）

第五步：回到函数调用的位置接着往后执行（这个时候函数调用表达式得到的值就是函数的返回值）

print(yt_sum(5))    # 15

2.全局变量和局部变量

1. 函数调用的过程中内存的变化

每次再调用函数的时候，系统会自动为这个函数创建一个独立的栈区间，用来保存函数运行过程中产生的数据（函数的参数；函数中声明的变量）；当函数结束后这个栈区间会自动销毁（压栈）。

2.全局变量和局部变量

1. 全局变量

没有定义在函数里面或者类里面的变量就是全局变量

作用域： 从定义开始到程序结束的任何位置都可使用

# 变量 a 是全局变量
a = 10

print(a)  # 10

for _ in range(5):
    print('循环中：', a)   
"""
循环中： 10
循环中： 10
循环中： 10
循环中： 10
循环中： 10
"""

def func1():
    print('函数中:', a)  

func1()  # 函数中： 10

# 变量b、c都是全局变量
for b in range(5):
    c = 10
    print('b循环中', b, c)
"""
b循环中 0 10
b循环中 1 10
b循环中 2 10
b循环中 3 10
b循环中 4 10
"""

print('b循环外:', b, c)   # b循环外: 4 10

def func2():
    print('b函数中:', b, c)

func2()   #  b函数中: 4 10

2. 局部变量

定义在函数中的变量就是局部变量（形参是局部变量，注意：定义函数的时候给形参夫的默认值其实是保存在堆里面的）

作用域: 从定义函数开始到函数结束的任何位置都可以使用

def func3():
    # 变量x是局部变量
    x = 100
    print(x)
    for _ in range(3):
        print('x2:', x)


func3()
# print(x)    # NameError: name 'x' is not defined

面试题：问以下程序结束后打印结果是多少

def func3(list1=[10, 20, 30]):
    # list1 = [10, 20, 30]
    list1.append(100)    #  list1 = [10, 20, 30, 100]
    return list1


scores = func3()   #  scores = [10, 20, 30, 100]
scores = func3()   #  scores = [10, 20, 30, 100]
print(scores)      #  [10, 20, 30, 100, 100]

3.global和nonlocal

1. global：在函数中声明指定变量就是全局变量

作用：1. 在函数中修改全局变量的值 2.在函数中定义一个全局变量

注意：生命必须放在使用前

name = '张三'


def change():
    # 在函数中修改全局变量name的值
    global name

    print(name)   
    name = '李四'

    # 在函数中定义全局变量 age
    global age
    age = 18


change()     # 张三
print(name)   # 李四
print(age)    # 18

2. nonlocal（了解就行）

如果希望在局部的局部中去修改局部变量的值，就可以用nonlocal 进行说明

def func4():
    m = 100

    def func5():
        nonlocal m
        m = 200
        print('m1:', m)

    func5()
    print('m2:', m)


func4()  
"""
m1: 200
m2: 200
"""
# 如果没有  nonlocal  m   那么m2就为100

3.匿名函数

1. 什么是匿名函数

匿名函数本质还是函数，普通函数中除了定义的语法其他全部都是用于匿名函数

1. 定义函数的语法：

函数名 = lambda 形参列表：返回值

说明：

lambda – 关键字，固定写法

形参列表 – ‘形参1，形参2…’的形式存在

： – 固定写法

返回值 – 任何有结果的表达式

2. 调用匿名函数：函数变量（实参列表）

匿名函数的本质就是类型是function的数据，普通数据能做的他都可以做

定义一个匿名函数求两个数的和

x = lambda num1,num2:num1+num2
"""
相当于
def x(num1, num2):
    return num1 + num2
"""
# 调用匿名函数
print(x(100,200))  # 300

a = 10    # int
b = 'abc'  # str
c = [10, 20, 30]   # list
d= {'a': 230, 'b': 100}    # dict



list1 = [10, 'abc', lambda num1, num2: num1+num2]
print(list1[0] + 10 - 100)  # 80
print(list1[1].join(['10', '20', '30']))  # 10abc20abc30
print(list1[2](1, 3))       # 4

练习：写一个匿名函数来判断指定年龄是否成年，根据情况返回True/False

is_adult = lambda age: '成年' if age >= 18 else '未成年'
print(is_adult(20))

4. 递归函数

1. 什么是递归函数

在函数内调用函数本身的函数就是递归函数（自己调用自己）

循环能做的事递归都能做

# func1就是递归函数
def func1():
    print('函数1')
    func1()

2. 怎么使用递归函数

第一步：确定临界值（在临界值的位置结束函数）

第二部：找关系（档次循环（f（n））和上次循环（f（n-1））之间的关系

第三步：假设函数的功能已经实现。用f（n-1）去实现f(n)的功能

# 写一个递归函数：计算1+2+3+4+..+n
# f(n) = 1+2+3+4+..+n-1+n
# f(n-1) = 1+2+3+4+...+n-1
def yt_sum(n):
    # 1.找临界值
    if n == 1:
        return 1

    # 2.关系: yt_sum(n) = yt_sum(n-1)+n
    return yt_sum(n-1) + n


print(yt_sum(100))


def yt_sum(n):
    sum1 = 0
    for x in range(n+1):
        sum1 += x
    return sum1

# 2.用递归计算斐波那契数列第20个数：1，1，2，3，5，8，13，21，34，...
def series(n):
    # 1.找临界值
    if n == 1 or n == 2:
        return 1
    # 2.找关系： series(n) = series(n-1) + series(n-2)
    return series(n-1) + series(n-2)


print(series(5))   # print(5)

"""
运行过程
def series(n):
print(series(5))
series(5): n=5; if 5==1 or 5==2; return 3 + 2
series(4): n=4; if 4==1 or 4==2; return 2 + 1 == 3
series(3): n=3; if 3==1 or 3==2; return 1 + 1  -> return 2
series(2): n=2; if 2==1 or 2==2; return 1
series(1): n=1; if 1==1 or 1==2; return 1
series(2): n=2; if 1==1 or 2==2; return 1
series(3): n=3; if 3==1 or 3==2; 1 + 1 == 2
series(2): return 1
series(1): return 1
"""