函数学习

1.函数的返回值:

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

python中每个函数都是有返回值的，返回值就是return后面的值。如果函数中没有return，那么函数的返回值就是None。

***函数的调用：

a.先回到函数调用的位置
b.用实参给形参赋值(传参)
c.执行函数体。
d.执行完函数体，将返回值返回给函数调用表达式。
c.回到函数调用的位置。

***函数的函数体只有在调用后才会执行。

2. return关键字：

a.将return后面的值，返回给函数调用表达式。
b. 结束函数。

3.函数调用表达式：

python中每个函数调用表达式的都是有值的。

二、作用域

作用域：一个变量可以使用的范围，就是变量的作用域，（函数和类可以影响作用域）
全局变量：从声明开始到文件执行结束的都能使用。
局部变量：只在函数和类中使用的变量。
global: 在函数中声明一个全局变量
格式:
global 变量名
变量名 = 值

abc = 'abc'  # 全局变量
def func4():
    abc = 'aaa'  # 局部变量，如果全局变量名和局部变量名相同，在函数中使用的是局部变量
    print(abc)
    global bcd   # 说明bcd是一个全局变量
    bcd = 266
    print(bcd)
func4()
print(abc)
print(bcd)
'''
结果：
aaa
266
abc
266
'''

def func11():
    a_11 = 10
    print('外部:', a_11)
    # python中函数里面可以声明函数
    def func12():
        nonlocal a_11  # 使用nonlocal修饰后的变量还是局部变量
        a_11 = 100
        print('内部:', a_11)
        print('内部函数')
    func12()
    print('外部:', a_11)
func11()
'''
结果：
def func11():
    a_11 = 10
    print('外部:', a_11)
    # python中函数里面可以声明函数
    def func12():
        nonlocal a_11  # 使用nonlocal修饰后的变量还是局部变量
        a_11 = 100
        print('内部:', a_11)
        print('内部函数')
    func12()
    print('外部:', a_11)
func11()
'''

三、匿名函数

a.匿名函数：本质还是函数，以另外一种简单的方式来声明。
b.匿名函数的声明：
函数名 = lambda 参数列表 ：返回值 ---> 结果是一个函数变量
列如：my_sum2 = lambda x, y=10: x+y
lambda：声明匿名函数的关键字

# 写一个函数计算两个数的和
def my_sum1(x, y):
    return x+y
print(my_sum1(10, 20))
# 匿名函数
my_sum2 = lambda x, y=10: x+y
print(my_sum2(10, 20))
#
funcs = []
for i in range(5):
    funcs.append(lambda x: x*i)
"""
i = (0, 1, 2, 3, 4)
i = 0
[lambda x:x*i,lambda x:x*i,lambda x:x*i,lambda x:x*i,lambda x:x*i]
"""
# lambda 2:2*4
print(funcs[2](2))
print(funcs[4](2))
print(i)
'''
结果：
8
8
'''

四、函数作为变量

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

# 函数名func1可以当成变量使用
def func1(a):
    print(a)
    return 10
print(func1, type(func1))

# 将函数func1赋给变量a,这个时候a就是一个函数
a = func1
b = func1(10) + 100
a('aaa')

# 将函数func1作为列表的元素
functions = [func1, func1(10)]
functions[0]('abc')

2.将函数作为参数

#求和
def my_sum(*numbers):
    """ numbers = (10, 20)  """
    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, *numbers):
    """
    method = my_sum
    numbers = (10,20)
    return my_sum((10, 20, 30))
    """
    a = ('1', 100, 'c')
    print(*a)
    print(*numbers)
    return method(*numbers)

# 求10和20的和
print('+++++')
result = operation(my_sum, 10, 20)
# 求10*20
result2 = operation(my_mul, 10, 20)
# 判断10是否大于20
reslut3 = operation(lambda x,y:x<y, 10, 20)
# 找出两个数中的最大值
result4 = operation(lambda x,y:x if x>y else y,10, 20)
"""
python中三目运算符(?:)
值1 if 表达式 else 值2 ---> 判断表达式是否为True,为True整个表达式的结果是'值1'，否则是'值2'
"""
a = 10 if 10 > 20 else 20

print(result, result2, reslut3, result4)

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

 # 写一个函数有个参数，要求传入一个运算符号(+,-,*,>,<),返回符号对应的功能
# + ——-> 求和功能
# - --->求差功能
# ....
funca = lambda x,y:x+y
def funb(x, y):
    return x+y

def get_method(char):
    """ char='-' """
    if char == '+':
        return funb
    elif char == '-':
        def func(m, n):
            return m - n
        return func
    elif 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
    else:
        def func(x, y):
            return None
        return func

print(get_method('+')(10, 20))
print(get_method('-')(10, 20))
print(get_method('%')(10, 20))

五、递归函数

1. 什么是递归
   递归函数:在函数的函数体中调用函数本身
   理论上循环能做的事情，递归都可以
   对递归的要求: 能不用就不用
   函数调用的过程是一个压栈的过程(没调用一次函数，系统都要为其分配内存空间，
   用来存储函数中声明变量和参数等，这个内存在函数调用结束后会自动销毁)

 这个函数就是递归函数
def fun1():
    print('===')
    fun1()

2. 怎么写一个递归函数
   a.找临界值(跳出循环 -> return)
   b.找关系:假设当前函数对应的功能已经实现，找到f(n)和f(n-1)的关系
   c.使用f(n-1)与前面找到关系去实现f(n)的功能

# 写一个递归函数实现:1+2+3+...n

# 普通函数
def my_sum(n):
    sum1 = 0
    for x in range(1, n+1):
        sum1 += x
    return sum1

print(my_sum(5))

# 递归函数
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(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))

"""
用递归函数实现以下功能
n = 3
***
**
*

n = 4
****
***
**
*
"""
def prin_star(n):
    # 1.找临界值
    if n == 1:
        print('*')
        return

    # 2.找关系
    """
    f(n)
    ****
    ***
    **
    *
    f(n-1)
    ***
    **
    *
    关系：先打印n个*,然后f(n-1)
    
    """
    prin_star(n - 1)
    print('*'*n)

print(prin_star(3))
"""
prin_star(3)  n = 3   None print('*'*3)
prin_star(2)  n = 2   None print('*'*2)
prin_star(1)  n = 1   print(*)