一.返回值的作用：

（1）返回值的作用，函数里面的数据传递到外面。
（2）要不要返回值：
就看产生了新的数据没有，函数里面产生新的值，就需要返回值。
（3）初学着怎么确定需不需要返回值：
实现函数的功能完成后会不会产生新的数据。
（4）怎么确定返回值：
声明函数的时候哦，return后面的值就是函数的返回值。默认值是None
（5）return 是关键值，只能出现在函数体中，
（6）return 作用：确定函数的返回值，结束函数。执行函数体的时候，如果遇到return函数直接结束，同时将return后面的值作为返回值。
(7)实例：

def pr():
    print(111)
    print(2222)
    return #这个返回了值，函数结束，后面就不执行了。
    print(333)

（8）怎么获取函数的返回值：
获取函数调用的表达式就是函数的返回值。
函数调用的语句就叫函数表达式。
普通数据能做的事情，函数调用表达式都是可以做的。
（9）获取函数的返回值
函数调用的表达式可以把值赋给变量。
（10）完整的函数的调用的过程：
执行的过程：
1.先回到函数声明的位置，
2.传参，保证每个参数都有值，
3.执行函数体，
4.确定返回值：执行完函数体后有没有遇到return,如果遇到了后面就是返回值，没有遇到都是None
5.回到函数调用表达式的值才是返回值。
（11）内存的变化：函数的调用的过程中系统会在栈中开辟一个独立的内存区间，专门用来保存在函数中声明的变量和数据，形参也是保存在栈的专用区间，单函数结束的时候内存的空间会销毁。
销毁之前返回，返回值。

def hanshu(a, b):
    c = a + b
    return c


value_sum = hanshu(12, 13)
print(value_sum)

def hanshu(b):
    print(b)
    return b*2
a=hanshu(3)#这个函数会调用函数这种打印3，在打印返回值6
print(a)

def hanshu(a):
    b=a
    return b

print(hanshu([12].copy()))#copy这个函数就是有返回值的，而append()是没有返回值的。如果是.append()就没有返回值。
print(hanshu([12].append(12)))#copy这个函数就是有返回值的，而append()是没有返回值的。如果是.append()就没有返回值None
函数对列表，字典，字符串进行操作的时候，如果这个函数本身是有返回值的，那么就是有返值

二。

1.变量的作用域，变量可以使用的范围。
2根据变量声明后使用的。范围不一样，分为全局，和局部。
(1)全局变量
没有声明在函数中的和列中的变量都是全局变量。
作用域：从声明开始到文件结束任何地方都是可以使用的。
声明在函数和类外面的都是全局变量。

a = 10
for x in range(a):
    print(a)


def hanshu():
    print(a)


hanshu()
for b in range(4):  # b也是全局变量。
    pass

(2)局部变量：声明在函数中的变量就是局部变量。
作用域：声明开始到函数结束（形参，声明在函数中的变量）
（3）global和nonlocal
注意：这两个关键字只能用于函数体中。
1.global 用于全局
如果在外面定义一个变量，在函数更改后，使用后，再出函数使用还是原来的变量
原因是：函数中那个并没有改变外面的而是创建了一个和外面那个一样的变量。
使用：在函数中给变量赋值前加： global 变量名 （然后 换行） 变量=值
作用：在函数声明全局变量。

a1=100

def func():
    a1=200
    print(a1)----这个打印的是200
    
func()
print(a1)---这个打印的是100
```python
a1 = 100
def func():
    global a1
    a1 = 200
    print(a1) #- ---这个时候是200


func()
print(a1) #- --这个也是200，global使用后就是全局的了。

a1 = 100


def func():
    global a1
    a1 = 200
    print(a1)  # - ---这个时候是200


func()
print(a1)  # - --这个也是200，global使用后就是全局的了。

（2）nonlocal
使用的方法：在函数中变量赋值前加：nonlocal 变量名
作用：在函数的局部中修改局部的变量的值。

def func5():
    a2=200
    def func6():
        #这里的a2必须在上层声明过的
        # nonlocal a2
        a2=100
        print(a2)#---这个还是打印的是
    func6()
    print(a2)
func5()

def outer():
    num = 10
    def inner():
        nonlocal num   # nonlocal关键字声明
        num = 100
        print(num)
    inner()
    print(num)
outer()

三。匿名函数

匿名函数还是函数，除了声明的语法以外其他语法基本都适用于匿名函数
(1)声明匿名函数
就相当于
lambda 参数列表 ：返回值
def (参数列表)：
return 返回值

（2）说明
lambda-关键字，固定的写法
--形参：参数名1，参数名2
：---不产生缩进。
返回值--相当于普通函数中的return语句。
（3）用处 -- 功能简单就用
匿名函数的调用和普通的没有区别。
func1 = lambda num1, num2: num2 + num1
print(func1(12, 23))
func2 = lambda a, b, c: print(a, b, c)
fun3 = lambda *nums: sum(nums)
print(fun3(4))
注意不支持类型的说明。
练习：写一个匿名函数判断的是否是闰年

func5 = lambda year: (year % 400 == 0) or (year % 400 == 0 and year % 100 != 0)
print(func5(2018))

四。

声明函数的时候调用函数本身，这样的函数就是递归函数
递归可以使用循环的效果。
原则上除了死循环，其他的循环递归都可以实现

ef func1():
    print("=========")
    func1()

func1()

2.递归怎么用：
"""
递归的套路：
a.设置临界值--循环结束的条件（保证函数结束）

b.找关系-----找f(n)和f(n-1)的关系。
c.假设函数的功能已经实现，通过f(n-1)去实现f(n)的功能。
"""

递归函数计算1+2+3..100
def ytsum(n):
    if n==1:
        return 1
    # 找关系
    #用f(n-1)实现f(n)的功能。
    # f(n)1+2+3....100
    # f(n-1)1+2+3+....(n-1)
    return ytsum(n-1)+n
print(ytsum(900))
递归求斐波那契：
def fibo(n):
   """递归函数
   输出斐波那契数列"""
   if n == 1 or n==2  :
       return n
   else:
       return(fibo(n-1) + fibo(n-2))
print(fibo(9))
练习
def f(n):
    if n==1:
       print("*")
       return
    #关系：实现f(n-1)的功能后再打印N颗星
    else:
        f(n-1)
        print(n*"*")