函数02

函数的返回值

a.就是函数返回给调用者值
b.就是return关键字后面的表达式的值
c.就是函数调用表达式的值

• python中每个函数都有返回值，返回值就是return后面的值。如果函数中没有return，那么函数的返回值就是None
• 函数的调用：
  a.先回到函数调用的位置
  b.用实参给形参赋值（传参）
  c.执行函数体
  d.执行完函数体，将返回值返回给函数表达式
  e.回到函数调用的位置
  f.函数的函数体只有在调用后才会执行
  2.return关键字
  a.将renturn后面的值，返回给函数调用表达式
  b.结束函数
  3.函数调用表达式
  python每个函数调用表达式的都是有值

def my_age(m):
    if m>18:
        return True
        print('成年')
    else:
        return  False
        print('未成年')
print(my_age(19))

3.函数的结束
a.函数体执行完
b.遇到return

def my_age():
        print('123')
        return 10
print(my_age())

练习：写一个函数，求1+2+3+4，和不能大于10000

def my_sum():
    sum=0
    i=1
    while True:
        sum+=i
        i += 1
        if sum+i>10000:
            return sum,i#可以有多个返回值，返回值放在元组里
结果：(9870, 141)

作用域

一个变量可以使用的范围，就是这个变量的作用域（函数和类可以影响变量的作用域）

• 全局变量：从声明开始，到文件结束都可以使用
• 局部变量：在函数（类）中声明的变量是局部变量。作用域是从声明开始到函数结束
  1.global和nonlocal
  global:在函数中创建一个全局变量
  格式:
  global 变量名
  变量名=值

abc='abc' #全局变量
bcd="bcd"
def my_stu():
    abc=1#局部变量，如果全局变量和局部变量名字相同，函数里使用局部变量
    print(abc)
my_stu()
print(bcd)

2.nonloal 在函数中声明函数时，才需要使用

def fun11():
    a_11=10
    print('外部',a_11)
    def  fun12():
        nonlocal a_11
        a_11=100
        print('内部：',a_11)
    fun12()
    print('外部',a_11)
fun11()
结果:外部 10
内部： 100
外部 100

python中函数里可以声明函数

匿名函数：本质是函数，以另外一种简单的方式声明

匿名函数的声明：
函数名=lambda 参数列表:返回值------>结果是一个函数变量
lamdba: 声明匿名函数的关键字

my_sum2=lambda x,y:x+y
print(my_sum2(10,20))

函数作为变量

声明一个函数就是在声明一个变量。函数名可以当做变量来使用，可以打印，可以赋值，可以查看类型，可以作为函数的参数，可以作为函数的返回值
1.将函数作为参数

def my_sum1(*numbers):
    sum1=0
    for item in numbers:
        sum1+=item
    return sum1
def my_mul(*numbers):
    sum1=1
    for item in numbers:
        sum1*=item
    return sum1
def operation(method,x,y):
    return method(x,y)
result=operation(my_sum1(),10,50)
print(result)

• python中的三目运算符

def my_sum1(*numbers):
    sum1=0
    for item in numbers:
        sum1+=item
    return sum1
def my_mul(*numbers):
    sum1=1
    for item in numbers:
        sum1*=item
    return sum1
def operation(method,x,y):
    return method(x,y)
#求10+50的和
result1=operation(my_sum1,10,50)
#求10*20
result2=operation(my_mul,10,50)
#判断10是否大于20
result3=operation(lambda x,y:xy else y,10,50)
print(result1)
结果：60

值1 if 表达式else 值2---->判断表达式是否为True，为True整个表达式的结果是值1，否则是值2

a=10 if 10>20 else 20

3.将函数作为函数的返回值

def get_method(char):
    if char=='+':
        return lambda x,y:x+y
    elif char=='-':
        def func(x,y):
            return x-y
        return func
    elif char=='*':
        return lambda x,y:x*y
    elif char=='/':
        return lambda x,y:x/y
# 返回函数=lambda x,y:x+y,函数再调用(7,8)
print(get_method('+')(7,8))
print(get_method('-')(7,8))
结果：
15
-1

递归函数

1.在函数的函数体中，调用函数本身

def my_1():
    print("==")
    my_1()
my_1()

理论上循环能做的事情，递归都能做
2.怎样写一个递归函数
a.找临界值（跳出循环--->return）
b.找关系：假设当前函数对应的功能已经实现，找到f(n)和f(n-1)的关系
c.使用f(n-1)与前面找到的关系去实现f(n)的功能
对递归的要求：能不用就不用

写一个递归函数实现：1+2+3...+n
def my_sum2(n):
    # 1.找到临界值
    if n == 1:
        return 1
    # 2.找my_sum2(n)和my_sum2(n-1)的关系：
    """
    my_sum2(n): 1+2+3+...+n-1+n
    my_sum2(n-1): 1+2+3+...+n-1
    关系: my_sum2(n) = my_sum2(n-1)+n
    """
    # 3.使用my_sum2(n-1)去实现my_sum2(n)的功能
    return my_sum2(n-1)+n

print(my_sum2(5))
"""
my_sum2(5)
my_sum2(5) n = 5   return 1+2+3+4+5
my_sum2(4) n = 4   return 1+2+3+4
my_sum2(3) n = 3   return 1+2+3
my_sum2(2) n = 2   return 1+2
my_sum2(1) n = 1   return 1
"""

用递归求2*4*6(n是偶数)
def mul(x):
    # 1.找临界值
    if x == 2:
        return 2

    # 2.找关系
    """
    f(x) = f(x-2)*x
    """
    return mul(x-2)*x

print(mul(6))

def prin_star(n):
    # 1.找临界值
    if n == 1:
        print('*')
        return
    prin_star(n - 1)
    print('*' * n)
prin_star(3)
结果:
*
**
***

函数调用的过程是一个压栈的过程（每调用一次函数，系统都要为其分配空间，用来存储函数中声明变量和参数，这个内训在函数调用结束后会自动销毁）