一、返回值

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

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

• 函数的调用:
  a.先回到函数声明的位置
  b.用实参给形参赋值(传参)
  c.执行函数体
  d.执行完函数体，将返回值返回给函数调用表达式
  e.回到函数调用的位置
  函数的函数体只有在调用后才会执行

• return关键字:
  a.将return后面的值返回给函数调用表达式
  b.结束函数

• 函数的结束：
  a.函数体执行完成
  b.遇到return

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

# 声明函数
def func1():
    print('lkjf')

# 调用函数  函数表达式
value1 = func1()
print(value1)

def func2(a, b):
    return a + b

print(func2(1, 2))

示例：

# 练习：写一个函数，判断指定的年龄是否属于成年

def adult_tell(age):
    if age<0:
        return '请输入正确的年龄!'
    if age>=18:
        return '成年人'
    if age<18:
        return '未成年'

age = int(input('请输入年龄：'))

print(adult_tell(age))

结果：

请输入年龄：20
成年人

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

def func3():
    sum1 = 0
    num1 = 1
    while True:
        if sum1 + num1 >= 10000:
            # python中函数可以有多个返回值,返回多个值时值为元组
            return sum1, num1-1
        sum1 += num1
        num1 += 1

print(func3())

结果：

(9870, 140)

二、作用域

• 作用域：一个变量可以使用的范围，就是这个变量的作用域(函数和类可以影响作用域)

• 全局变量：从声明开始，到文件结束都可以使用
  特殊的，在Python中的for循环中声明的变量也是全局变量

• 局部变量：在函数和类中声明的变量。作用域是从声明开始到函数结束

全局变量

# 全局变量
a = 10

print(a)

def func1():
    print(a)

func1()

for _ in range(4):
    # 特殊的，在Python中的for循环中声明的变量也是全局变量
    b = 100
    print(a)

print('-'*20)
print(b)

def func2():
    print(b)

func2()
print('-'*20)

结果：

10
10
10
10
10
10
--------------------
100
100
--------------------

局部变量

# 局部变量
def func3():
    # 局部变量，作用域在函数内
    c = 200

global

"""
global 变量1:在函数中声明 变量1 是一个全局变量
格式：
global 变量名
变量名 = 值
"""

# 全局变量
d = 'd'
e = 'e'
def func4():
    # 局部变量
    d = 'b'
    print(d)

    # 说明e是一个全局变量
    global e
    e = 'E'
    print(e)

func4()
print(d)
print(e)
print('-'*20)

结果：

b
E
d
E

nonlocal

"""
nonlocal:在函数中声明函数的时候，才需要使用
"""

def func11():
    a_11 = 10

    print('外部',a_11)

    # python中函数里面可以声明函数
    def func12():
        nonlocal a_11
        a_11 = 100
        print('内部', a_11)

    func12()
    print('外部', a_11)

func11()

结果：

外部 10
内部 100
外部 100

三、匿名参数

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

• 匿名函数的声明：
  变量名 = lambda 参数列表：返回值 ---- 结果是一个函数变量

• lambda: 声明匿名函数的关键字

# 写一个函数，计算2个数的和
# 一般函数
def my_sum1(a, b):
    return a+b

print(my_sum1(10, 20))

# 匿名函数
my_sum2 = lambda a, b: a+b

print(my_sum2(10, 20))

结果：

30
30

示例：

"""
i = (0, 1, 2, 3, 4)
i = 0
funcs = [lambda x:x*0]
i = 1
funcs = [lambda x:x*1, lambda x:x*1]
···
i = 4
funcs = [lambda x:x*4, lambda x:x*4, lambda x:x*4, lambda x:x*4]
"""
#
funcs = []
for i in range(5):
    # i是全局变量
    funcs.append(lambda x:x*i)

print(funcs[2](2))
print(funcs[4](2))
print(i)

结果：

8
8
4

四、函数变量

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

a = 10
a = 'a'
print(a)

def func1(a):
    print(a)
    return 100

print(func1, type(func1))
print('-'*20)

结果：

a
<function func1 at 0x000002002C5AD1E0> <class 'function'>

将函数func1赋给b，这个时候b就是一个函数了

b = func1
b(10)
print(b)

print('-'*20)

c = func1(10)
print(func1(10))

结果：

10
<function func1 at 0x000002002C5AD1E0>
--------------------
10
10
100

将函数func1作为列表的元素

functions = [func1]
functions[0]('啊啊啊')

结果：

啊啊啊

将函数作为参数

def my_sum(*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):
    """
    method = my_sum
    x, y = 1, 2
    return = my_sum(numbers)
    :param method: function
    :param numers: tuple
    :return:
    """
    return method(x, y)

result1 = operation(my_sum, 1, 2)
print(result1)
result2 = operation(my_mul, 2, 3)
print(result2)
result3 = operation(lambda x,y:x>y, 10, 11)
print(result3)

结果：

3
6
False
20

在c中有三目运算符：
表达式？值1：值2
在Python中相同功能的方法是：
值1 if 表达式 else 值2 ---- 判断表达式是否为True，为True整个表达式是值1，否则为值2

print(10 if 10>20 else 20)

结果:

20

将函数作为函数的返回值

def get_method(char):
    if char == '+':
        return lambda x,y:x+y
    elif char == '*':
        return lambda x,y:x*y
    elif char == '>':
        def func1(x, y):
            return x > y
        return func1
    else:
        def func(x, y):
            return None
        return func


print(get_method('+')(2, 3))
print(get_method('*')(2, 3))

结果：

5
6

五、递归

• 递归函数：在函数的函数体中调用自己

• 循环能做的事情递归都可以做。

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

• 对递归的要求：能不用就不用

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

写一个函数实现：1+2+3+···+n

def recursion_sum(n):
    # 找到临界值
    if n == 1:
        return 1
    # 找到my_sum1(n)和my_sum1(n-1)的关系
    """
    my_sum(n) = 1+2+3+···+n-1+n
    my_sum(n-1) = 1+2+3+···+n-1
    my_sum(n) = my_sum(n-1)+n
    
    """
    return recursion_sum(n-1)+n

print(recursion_sum(10))

结果：

55

用递归求246···n(n是偶数)

def recursion_mul(n):
    if n%2:
        print('参数错误！')
        return
    if n==2:
        return 2
    else:
        return recursion_mul(n-2)*n

print(recursion_mul(6))

结果：

48

用递归实现以下功能
n = 3

***
**
*

n = 4

****
***
**
*

关系：先打印n个*，在打印f(n-1)

def recursion_print(n):
    if n == 1:
        print('*')
        return
    else:
        print('*'*n)
        return recursion_print(n-1)

recursion_print(5)

结果：

*****
****
***
**
*

反向的

def print_star(n):
    if n == 1:
        print('*')
        return
    print_star(n-1)
    print('*'*n)

print_star(5)

结果：

*
**
***
****
*****