day8-函数续

01-函数的返回值

• 1.函数的返回值：
  a.函数返回给调用者的值
  b.就是return关键字后面的表达式的值
  c.就是函数调用表达式的值
  python中每个函数都是有返回值的，返回值就是return后面的值。如果函数中没有return，那么函数的返回值就是none

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

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

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

def func1():
    print('aaaa')
func1()  #函数调用表达式

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

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

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

def adult(age):
    if age >= 18:
        return '已成年'
    else:
        return '未成年'
print(adult(15))

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

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

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

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

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

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

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

02-作用域

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

• 全局变量：从声明开始，到文件结束，都可以使用

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

• 1.全局变量

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

print(a)

def func1():
    print(a)

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

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

• 2.局部变量

def func3():
    aaa = 100  #局部变量，作用域是函数
    print(aaa)
func3()
# print(aaa)  报错NameError: name 'aaa' is not defined

• 3.global和nonlocal

global:在函数中创建一个全局变量
格式：
global 变量名
变量名 = 值
"""
abc = 'abc'
bcd = 'bcd'
def func4():
    abc = 'aaa'  #局部变量，如果全局变量名和局部变量名相同，在函数中使用的是局部变量
    print(abc)
    global bcd  #说明bcd是一个全局变量
    bcd =100
    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)
    # python中函数里面可以声明函数
    def func12():
        nonlocal a_11
        a_11 = 100
        print('内部:',a_11)
        print('内部函数')
    func12()
    print('外部:',a_11)

func11()

03-匿名函数

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

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

#
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]
"""

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

04-函数作为变量

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

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

def func1(a):
    print(a)
    return 10
print(func1,type(func1))

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

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

• 将函数作为列表的元素

functions = [func1,func1(10)]
functions[0]('123')

• 1.将函数作为参数

def my_sum(*num):
    """num = ((10,20,30))"""
    sum1 = 0
    for item in num:
        sum1 += item
    return sum1
def my_mul(*num):
    sum1 = 1
    for item in num:
        sum1 *= item
    return sum1
def operation(method,x,y):
    """

    method = my_sum
    num = (10,20,30)
    return my_sum(numbe)

    """
    return method(x,y)

result = operation(my_sum,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)

• python中三目运算符(?:)

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

a = 10 if 10 > 20 else 20
print(a)
print(result,result2,result3,result4)

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

 写一个函数有一个参数，要求传入一个运算符号（+ - * > <）,返回符号对应的功能
# +  - - - >求和功能
# -  - - - >求差功能
# ....
def get_method(char):
    if char == '+':
        return lambda x,y:x+y
    elif char =='-':
        def func(m,n):
            return m - n
    elif char =='*':
        return lambda x,y:x*y
    elif char == '<':
        return lambda x,y : x<y
    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))

05-递归函数

• 1.什么是递归

• 递归函数：在函数的函数体中调用本身,理论上循环能做的事情，递归都可以

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

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

• 这个函数就是递归函数

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

• 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(10))
# 递归函数
def my_sum2(n):
    # 1.找到临界值
    if n == 1:
        return 1
    # 2.找my_sum2(n)和my_sum2(n-1)
    """
    my_sum(n):1+2+3...+n
    my_sum(n-1):1+2+3+...+n-1
    #3.关系：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(10))
"""
my_sum2(5)
my_sum2(5)    n = 5 return my_sum2(4)+5
my_sum2(4)    n = 4 return my_sum2(3)+4
my_sum2(3)    n = 3 return my_sum2(2)+3
my_sum2(2)    n = 2 return my_sum2(1)+2
my_sum2(1)    n = 1 return 1
"""

• 用递归求246..n(n是偶数）

def my_mul(n):
    if n % 2:
        print('参数有误')
        return None
    if n  == 2:
        return 2
    return my_mul(n-2)*n
print(my_mul(6))

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

n = 4
****
***
**
*
"""
def star(n):
    if n == 1:
        print('*' )
        return

    print('*'*n)
    star(n-1)

star(4)

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

    star1(n - 1)
    print('*'*n)

star1(4)