1. 函数的返回值

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

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

函数的调用：
a. 先回到函数声明的位置
b. 用实参给形参赋值（传参）
c. 执行函数体
d. 执行完函数体，将返回值返回给函数调用表达式
e. 返回到函数调用的位置

2. return关键字
   a. 将return后面的值返回给函数调用表达式
   b. 结束函数
3. 函数调用表达式：
   Python中每个函数调用表达式都是有值的

def func1():
    print('aaa')

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

def my_sum(x, y):
    return x + y    # return 30
print(my_sum(10, 20))

运行结果：
aaa
aaa
None None
30

练习1：写一个含函数，判断指定的年龄是否属于成年人（返回结果）

def age(a):
    if 0< a <= 18:
        return True
    else:
        return False
if age(20):
    print('未成年')
else:
    print("成年")
运行结果：
成年

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

def func2():
    print('123')
    return 12
    print('321')    # 这句不执行
print(func2())

123
12

写一个函数，下载指定地址对应的数据

def download(url):
    判断有没有网
    if 没有网：
        return None
    写网络请求
    请求数据
    保存数据

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

def sum1():
    sum2 = 0
    n = 1
    while True:
        if sum2 + n >= 10000:
            return sum2, n - 1  # python中函数可以有多个返回值，在return后面返回多个值，每个值之间用逗号隔开，返回值是一个元组
        sum2 += n
        n += 1
print(sum1())
运行结果：
(9870, 140)

2. 作用域
   作用域：一个变量可以使用的范围，就是这个变量的作用域（函数和类可以影响变量的作用域）
   全局变量：从声明开始，到文件结束都可以使用
   局部变量：在函数（类）中声明的变量是局部变量。作用域是从声明开始到函数结束
3. 全局变量

a = 10  # 这是一个全局变量
print(a)

def func1():
    print(a)

for i in range(10):
    b = 100     # 这是全局变量
    print(a)

print('===', b)

def func2():
    print(b)
func2()

10
10
10
10
10
10
10
10
10
10
10
=== 100
100

2.局部变量

def func3():
    aa = 20     # 局部变量，作用域是函数
    print(aa)
func3()
运行结果：
20

3. global和nonlocal
   global:在函数中创建一个全局变量
   格式：
   global 变量名
   变量名 = 值

abc = 'abc'  # 全局变量
bcd = 'bcd'
def func4():
    abc = '111' # 局部变量，如果全局变量名和局部变量名相同，在函数中使用的是局部变量
    print(abc)

    global bcd  # 说明这个bcd是一个全局变量
    bcd = 222
    print(bcd)
func4()
print(abc)
print(bcd)

111
222
abc
222

练习：声明一个变量，统计一个函数调用的次数

count = 0
def my_func():
    global count
    count += 1
    print('-------')
my_func()
my_func()
print('123213')
a = 10
my_func()
print(count)

-------
-------
123213
-------
3

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

def func11():
    b = 10
    print('外部', b)

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

func11()
print(b)

外部 10
内部 100
内部函数
外部 100
100

3. 匿名函数

匿名函数：本质还是函数，以另外一种简单的方式来声明
匿名函数声明：
函数名 = lambda 参数列表：返回值 ---> 结果是一个函数变量

lambda：声明匿名函数的关键字

写一个函数计算两个数的和

# 一般算法
def my_sum1(x, y):
    return x + y

print(my_sum1(10, 20))

# 匿名函数
my_sum2 = lambda x, y: x+y
print(my_sum2(10, 20))

30
30

练习

# 分析输出什么
funcs = []
for i in range(5):
    funcs.append(lambda x: x * i)   # 函数没有调用，所以i没有变，循环执行完i为4


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))

8
8

4. 函数作为变量

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

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

print(func1, type(func1))

a
<function func1 at 0x0000028A27F3A510> <class 'function'>
10

将函数func1赋给变量a,这个时候a就是一个函数

a = func1
b = func1(10) + 100
a('aaa')

aaa

将函数func1作为列表的元素

functions = [func1, func1(20)]
functions[0]('abc')

20
abc

2. 将函数作为参数

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
    numbers = (1,2,3)

    return my_sum((1,2,3))
    """
    return method(x, y)
# 求1+2
result1 = operation(my_sum, 1, 2)
# 求1*2
result2 = operation(my_mul, 1, 2)
# 判断10是否大于20
result3 = 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(result1, result2, result3, result4)

3 2 True 20

3. 将函数作为函数的返回值
   写一个函数有个参数，要求传入一个运算符号（+，-，*，>，<），返回符号对应的功能

def get_method(char):
    if char == '+':
        return lambda x, y: x + y
    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))
print(get_method('>')(10, 20))
print(get_method('<')(10, 20))

30
-10
200
False
True

5. 递归函数

1. 什么是递归
   递归函数：在函数的函数体中调用函数本身
   理论上循环能做的事情，递归都可以

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

这个函数就是递归函数

def func1():
    print('===')
    func1()

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

练习1：写一个递归函数实现：1+2+3+...+n

# 一般算法
def my_sum(n):
    sum1 = 0
    for x in range(1, n+1):
        sum1 += x
    return sum1

print(my_sum(10))

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

55
55

练习2：用递归求246...n(n是偶数)

def sum22(n):
    if n == 2:
        return 2
    return sum22(n-2) * n
print(sum22(10))

3840

练习3：用递归函数实现：

"""
n = 3
***
**
*

n = 4
****
***
**
*
"""
def star(n):
    # 1.找临界值
    if n == 1:
        print('*')
        return None
    # 2.找关系
    """
    关系：先打印n个*，然后f(n-1)
    """
    print('*' * n)
    star(n-1)
star(5)

# 实现：
"""
*
**
***
"""
def star1(n):
    if n == 1:
        print('*')
        return None
    star1(n-1)
    print('*' * n)
star1(5)

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

作业：

1. 写⼀个函数将⼀个指定的列表中的元素逆序(例如[1, 2, 3] -> [3, 2, 1])(注意：不要使⽤列表⾃带的逆序函数)

def inverse(li):
    list2 = []
    for index in range(len(li)):
        list2.append(li[len(li) - index - 1])
    return list2
list1 = [1, 2, 3, 4]
list1 = inverse(list1)
print(list1)

[4, 3, 2, 1]

2. 写一个函数，提取出字符串中所有奇数位上的字符

str1 = 'l2o3vre4 5Phy2t&h5omn'
def get_odd(st):
    str2 = ''
    for i in range(0, len(st)):
        if i % 2 == 0:
            str2 += st[i]
    print(str2)
    # print(str1[::2])
get_odd(str1)

love Python

3. 写一个匿名函数，判断指定的年是否是闰年

x = int(input('请输入一个年份：'))
leep_year = lambda x: (x % 4 == 0 and x % 100 != 0) or (x % 400 == 0)
print(leep_year(x))

请输入一个年份：2000
True

请输入一个年份：2001
False

4. 使用递归打印

"""
n = 3的时候
  @
 @@@
@@@@@
n = 4的时候:
   @
  @@@
 @@@@@
@@@@@@@
"""
def shape(n, m=0):
    if n == 1:
        print(' ' * m + '@')
        return None
    shape(n - 1, m+1)
    print(' ' * m + '@' * (2*n-1))

shape(5)

    @
   @@@
  @@@@@
 @@@@@@@
@@@@@@@@@

5.写函数，检查传入列表的长度，如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。

def list_len(lis):
    list2 = []
    if len(list1) > 2:
        list2 = [list1[0], list1[1]]
    return list2
list1 = [1, 2, 3, 4]

list1 = list_len(list1)
print(list1)

[1, 2]

6. 写函数，利⽤递归获取斐波那契数列中的第 10 个数，并将该值返回给调⽤者。

"""1,1,2,3,5,8,13,21..."""
def get_number(n):
    if n ==1 or n ==2:
        return 1
    return get_number(n-1) + get_number(n-2)

print(get_number(10))

55

7. 写一个函数，获取列表中的成绩的平均值，和最高分

def get_score(scores):
    return sum(scores)/len(scores),max(scores)

average,max1 = get_score([1,2,3,4])
print(average, max1)

2.5 4

8. 写函数，检查获取传入列表或元组对象的所有奇数位索引对应的元素，并将其作为新的列表返回给调用者

def get_st(li):
    list2 = []
    for index in range(0, len(li)):
        if index % 2 != 0:
            list2.append(list1[index])
    return list2
list1 = [1, 2, 3, 4, 5]
print(get_st(list1))

[2, 4]