day8 函数

01函数的返回值

1.函数的返回值：

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

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

函数的调用

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

！！！函数的函数体只有在调用之后才会执行

2.renturn关键字

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

3.函数调用表达式：

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

def func1():
    print('aaa')

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

def my_sum(x, y):
    # x = 10. y = 20
    return x+y  # return 30
num =  my_sum(1,3)
print(num, my_sum(10, 20))

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

def is_adult(age):
    if age >= 18:
        return True
    else:
        return False
print(is_adult(25))

if is_adult(10):
    print('可以进网吧')
else:
    print('未成年人禁止进入')

person ={'name': '胡晨宇', 'is_adult': is_adult(23)}
print(person)

3.函数的结束

a.函数执行完
b.遇到return

def func2():
    print('123')
    return 10
    print('321')

print(func2())

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

def download(url):
    if 判断有没有网：
        return None

        
    写网络请求
    请求数据
    保存数据

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

def my_sum():
    sum1 = 0
    for item in range(10000):
        sum1 += item
        if sum1 >= 10000:
            print(sum1, item)
            break
    return item-1
print(my_sum())

def my_sum2():
    sum1 = 0
    number = 1
    while True:
        if sum1 + number >= 10000:
            return sum1, number-1
        #python中函数可以有多个返回值，在return后面返回多个值，每个值之间用逗号隔开。返回值是一个元祖
        sum1 += number
        number += 1

print(my_sum2())

02 作用域

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

全局变量：从声明开始，到文件结束都可以使用
局部变量：在函数(类)中声明的变量是局部变量。作用域是从声明开始到函数结束

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

def func1():
    print(a)

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

print('====', b)

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

2.局部变量

def func3():
    aaa = 100  #局部变量，作用域是函数

func3()
print('----------------------------------------')
# print(aaa)  # 会报错  没有定义

3.global 和 nonlocal

global：在函数中声明一个全局变量

格式：
global 变量名
变量名 = 值

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

    global bcd   # 说明bcd是一个全局变量
    bcd = 200
    print(bcd)

func4()
print(abc)
print(bcd)

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

count = 0
def my_func():
    global count
    count += 1
    print('===========')

my_func()
my_func()
my_func()
print(count)

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

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

    # python中函数里面可以声明函数
    def func12():
        nonlocal a_11  # 修改外部函数的局部变量
        a_11 = 100
        print('内部', a_11)
        print('内部函数')

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

func11()
# print(a_11)

03匿名函数

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

匿名函数的声明：
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))

例：
funcs = []
for i in range(5):
    funcs.append(lambda x: x*i)

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

输出 8 8

04函数作为变量

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

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

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

# 将函数func1赋给变量a，这个时候a就是一个函数
a = func1
b = func1(10) + 100
a('aaa')
print(b)
print('------------------------------------------')
# ***加括号拿的是返回值，不加括号就是函数本身

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

1.将函数作为参数

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

# 求10+20
result = operation(my_sum, 10, 20)

# 求10*20
result2 = operation(my_mul, 10, 20)

# 判断10是否大于20
result3 = operation(lambda x, y: x < y, 10, 20)

# 找出两个数中的最大值
result4 = operation(lambda x, y: x if x > y else y, 10, 20)

a = 10 if 10 > 20 else 20
print('-------111111111111------------')

print(result, result2, result3, result4)

python 中三目运算符( ?: )
表达式？值1：值2
值1 if 表达式 else 值2 ----->判断表达式是否为True，为True整个表达式的结果是‘值1’，否则是‘值2’

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
    elif char == '<':
        return lambda x, y: x')(10, 20))

05 递归函数

这个函数就是递归函数

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

 func1()

1.什么是递归
递归函数： 在函数的函数体重调用本身

理论上循环能做的事情，递归都可以做

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

2.怎么写一个递归函数

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

1+2+3+4+...+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) = my_sum2(n-1)+n
    
    # 3.使用my_sum2(n-1)去实现my_sum2(n)的关系：
    return my_sum2(n-1) + n
print(my_sum2(5))

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

def my_mul3(n):
    # 1.找临界值
    if n == 2:
        return 2
    return my_mul3(n-2) * n
print(my_mul3(8))

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

n=4
****
***
**
*
'''

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

    # 2.找关系
    '''
    关系:先打印n个* 然后f（n-1）
    '''
    print('*'* n)
    return print_star(n-1)

print_star(4)
print('=============================')

n = 4
****
***
**
*

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

    # 2.找关系
    '''
    关系:先打印n个* 然后f（n-1）
    '''
    print_star(n-1)
    print('*'* n)

print_star(4)