美文网首页
08函数进阶

08函数进阶

作者: 剑眉星目cz | 来源:发表于2018-07-25 19:50 被阅读0次

    函数的返回值

    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())
    # aaa
    # aaa
    # None None
    
    def my_sum(x, y):
        # x=10, y=20
        print(x+y) #  30
    print(my_sum(10, 20)) # None
    
    def my_sum(x, y):
        # x=10, y=20
        return x+y # return 30
    print(my_sum(10, 20)) # 30
    

    练习:写一个函数,判断指定的年龄是否属于成年人(返回结果)

    def is_adult(age):
        if age >= 18:
            return True
        else:
            return False
    
    if is_adult(10):
        print('可以进网吧')
    else:
        print('未成年禁止进入')
    
    person = {'name': '陈酌', 'is_adult':is_adult(18)}
    print(person)
    
    结果
    {'name': '陈酌', 'is_adult': True}
    

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

    def func2():
        print('123') # 123
        return  10 # 返回10
        print('321')
    
    print(func2()) # 10
    

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

    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())  # (9870, 140)
    

    作用域

    作用域:一个变量可以使用的范围,就是这个变量的作用域(函数和类可影响变量的作用域)
    全局变量:从声明开始,到文件结束都可以使用
    局部变量:在函数(类)中声明的变量是局部变量。作用域是从声明开始到函数结束

    1.全局变量
    a = 10  # 这是一个全局变量
    
    print(a)  # 10
    
    for x in range(2):
        b = 100 # 这个变量是全局变量
        print(b)
        print(a)
    #100
    #10
    #100
    #10
    
    def func2():
        print(b)  # 100
    func2()
    
    2.局部变量
    def func3():
        aaa = 10 #局部变量,作用域是函数
        print(aaa)  # 10
    
    func3()
    # print(aaa) # 报错:NameError:mame 'aaa' is not defind
    
    3.global和nonlocal

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

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

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

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

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

    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()
    # print(a_11) 这是个局部变量,在外部不能打印。
    
    结果
    外部 10
    内部 100
    内部函数
    外部 100
    

    匿名函数

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

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

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

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

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

    匿名函数

    my_sum2 = lambda x,y:x+y
    print(my_sum2(10, 20))  # 30
    
    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))  # 8
    print(funcs[3](2))  # 8
    print(i)  # 4
    

    函数作为变量

    1.声明一个函数就是在声明一个变量,函数名可以当成变量来使用。类型:function

    可以打印、赋值、产看类型、作为函数参数、作为函数的返回值
    函数名func1可以当成变量使用

    def func1(a):
        print(a)
        return 10
    print(func1, type(func1))
    
    结果
    <function func1 at 0x000000B6978E8048> <class 'function'>
    

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

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

    将函数func1作为列表的元素

    functions = [func1, func1(10)]
    functions[0]('abc')
    
    结果
    10
    abc
    
    2.将函数作为参数
    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
        numbers = (10, 20, 30)
    
        return my_sum((10, 20, 30))
        """
        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)
    
    print(result, result2, result3,result4)
    
    结果
    30 200 True 20
    

    python中三目运算符
    值1 if 表达式 else 值2 ---> 判断表达式是否为True,为True整个表达式的结果是“值1”,否则是“值2”

    a = 10 if 10 > 20 else 20
    print(a)  # 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))
    
    结果
    20
    30
    200
    None
    -10
    

    递归函数

    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))
    
    结果
    15
    

    递归函数

    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+n
        关系: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  my_sum2(4)+5  1+2+3+4+5
    my_sum2(4)      n = 4   return  my_sum2(3)+4  1+2+3+4
    my_sum2(3)      n = 3   return  my_sum2(2)+3  1+2+3
    my_sum2(2)      n = 2   return  my_sum2(1)+2  1+2
    my_sum2(1)      n = 1   return  1
    """
    
    结果
    15
    

    用递归求2 * 4 * 6... n(n是偶数)

    def my_mul(n):
        # 1.找到临界值
        if n % 2:
            print('参数有误')
            return None
        if n == 2:
            return 2
        # 2.找关系
        """
        f(x) = f(x-2)*x
        """
        return my_mul(n-2)*n
    
    print(my_mul(7))
    print(my_mul(8))
    
    结果
    参数有误
    None
    384
    

    n = 3
    (*****
    (**
    (*

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

    def prin_star(n):
        # 1.找临界值
        if n == 1:
            print('*')
            return
        # 2.找关系
        """
        关系:先打印n个*,然后f(n-1)
        """
        print('*'*n)
        prin_star(n-1)
    
    prin_star(7)
    
    结果
    *******
    ******
    *****
    ****
    ***
    **
    *
    

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

    def prin_star(n):
        # 1.找临界值
        if n == 1:
            print('*')
            return
        # 2.找关系
        prin_star(n - 1)
        print('*'*n)
    
    prin_star(7)
    
    结果
    *
    **
    ***
    ****
    *****
    ******
    *******
    

    相关文章

      网友评论

          本文标题:08函数进阶

          本文链接:https://www.haomeiwen.com/subject/egfmmftx.html