精华内容
下载资源
问答
  • PYTHON 递归函数 详解

    2019-01-05 20:50:29
    Python 递归函数 详解 在函数内调用当前函数本身的函数就是递归函数 下面是一个递归函数的实例: 第一次接触递归函数的人,都会被它调用本身而搞得晕头转向,而且看上面的函数调用,得到的结果会是: 为什么会...

    Python 递归函数 详解
    在函数内调用当前函数本身的函数就是递归函数

    下面是一个递归函数的实例:
    在这里插入图片描述

        第一次接触递归函数的人,都会被它调用本身而搞得晕头转向,而且看上面的函数调用,得到的结果会是:
    

    在这里插入图片描述

        为什么会得出上面的结果呢?因为都把调用函数本身之后的代码给忘记了,就是else之后的python 代码。
    
        实际此递归函数输出的是以下结果:
        3
        2
        1
        0
        ------
        0
        1
        2
        3
    
       相信大家看到这里都有点蒙,小编也一样,我第一次看到这个递归函数时,只能理解到第一个结果。那是因为,大部分人在做事情的时候,中断第一件事,被安排去做第二件事的时候,就会把第一件事后续的事情给忘记,如果在做第二件事的时候,又被中断,被安排去做第三件事,就会把第一件、第二件要做的后续的事情给忘记......,这就是不理解递归函数的原因。
    
       下面我把此递归函数做了一个分解,希望能够帮到大家。 
    
       详解递归函数,当调用递归函数digui(3)时,执行过程如下:
    

    在这里插入图片描述

         在调用函数本身时,它之后的代码并没有结束,而是在等待条件为False 时,再接着执行之后的代码,同一个颜色的print()语句等待对应颜色的函数。
    
    展开全文
  • 递归函数的概念:直接或间接的调用自身的函数,称为递归函数。每调用一次自身,相当于复制一份该函数,只不过参数有变化,参数的变化,就是重要的结束条件下面是一个递归函数的实例:#coding=utf-8defcalc(n):print...

    递归函数的概念:

    直接或间接的调用自身的函数,称为递归函数。

    每调用一次自身,相当于复制一份该函数,只不过参数有变化,参数的变化,就是重要的结束条件

    下面是一个递归函数的实例:

    #coding=utf-8

    defcalc(n):print(n)if int(n/2) >0:

    calc(int(n/2))else:print('------')print(n)

    calc(10)

    打印结果:

    10

    5

    2

    1

    ------

    1

    2

    5

    10

    第一次接触递归函数的人,都会被它调用本身而搞得晕头转向,而且看上面的函数调用,以为得到的结果会是:

    10

    5

    2

    1

    ------

    1

    为什么以为会得出上面的结果呢?因为都把调用函数本身之后的代码给忘记了,就是else之后的python 代码。

    实际此递归函数输出的是以下结果:

    10

    5

    2

    1

    ------

    1

    2

    5

    10

    相信大家看到这里都有点蒙,我也一样,我第一次看到这个递归函数时,只能理解到第一个结果。那是因为,大部分人在做事情的时候,中断第一件事,被安排去做第二件事的时候,就会把第一件事后续的事情给忘记,如果在做第二件事的时候,又被中断,被安排去做第三件事,就会把第一件、第二件要做的后续的事情给忘记......,这就是不理解递归函数的原因。

    下面我把此递归函数做了一个分解,希望能够帮到大家。

    详解递归函数,当调用递归函数calc(10)时,执行过程如下:

    #coding=utf-8

    def calc(10):

    print(10)

    if int(10/2) > 0:def calc(5):

    print(5)

    if int(5/2) > 0:def calc(2):

    print(2)

    if int(2/2) > 0:def calc(1):

    print(1)

    print('------')

    print(1)print(2)print(5)print(10)

    在调用函数本身时,它之后的代码并没有结束,而是在等待条件为False 时,再接着执行之后的代码,同一个颜色的print()语句等待对应颜色的函数。

    如果看到这里还不理解,那请看下面过程

    #coding=utf-8

    def calc(10):print(10)if int(10/2) >0:

    calc(int(10/2))else:print('------')print(10)|

    |vdef calc(5):print(5)if int(5/2) >0:

    calc(int(5/2))else:print('------')print(5)|

    |vdef calc(2):print(2)if int(2/2) >0:

    calc(int(2/2))else:print('------')print(2)|

    |vdef calc(1):print(1)if int(1/2) > 0: #此时条件不成立,走else

    calc(int(1/2))else:print('------')print(1)

    可以看到,每次条件成立都会调用函数本身,那函数本身最后是有一个print的,所以才会出现对称的那种结果。

    展开全文
  • 主要介绍了Python 递归函数详解及实例的相关资料,需要的朋友可以参考下
  • python递归函数详解

    2020-04-27 23:32:11
    大家好我是致力于让每个人都能够轻松学会编程的小梁,...什么是递归: 递归是指一种通过重复将问题分解为同类的子问题而解决问题的方法,在python中间接或直接调用自身的函数被称为递归函数。 间接: def func(): ...

    大家好我是致力于让每个人都能够轻松学会编程的小梁,在这条路上任重道远,关注我,每天让您获取来自编程的乐趣。
    关注公众号“轻松学编程”。了解更多。
    今天就给大家分享一下关于使用递归函数求解一些数学问题时需要注意的事。
    在这里插入图片描述

    什么是递归

    什么是递归: 递归是指一种通过重复将问题分解为同类的子问题而解决问题的方法,在python中间接或直接调用自身的函数被称为递归函数。

    间接:
     def func():
         otherfunc()
     
     def otherfunc():
         func()
     
     直接:
     def func():
         func()
    

    递归函数的优点定义简单,逻辑清晰,理论上所有的递归函数都可以写成循环的方式(这个已经被伟大的科学家证明了的),但是循环的逻辑不如递归清晰。

    递归函数必须要有收敛条件和递归公式。

    注意:使用递归函数需要注意防止栈溢出,在计算机中函数是通过栈(stack)这种数据结构实现的,每当进入一个函数调用,就会增加一层栈帧,每当函数返回,栈就会减一层栈帧,栈的大小不是有限制的,所以当调用的次数过多的时候,会导致栈溢出。

    使用递归比较占内存。
    在这里插入图片描述
    下面介绍一些可以用得到递归的场景。

    在这里插入图片描述

    1、递归求和

    def my_sum(n):
        '''
       递归求和
       1+2+3+...+n
       :param n: int型
       :return: int型
       '''
        # 收敛条件
        if n == 1:
            print('第1层递归结束,返回结果1给上一层')
            return 1# 递归公式
        next_level = my_sum(n - 1)
        ret = n + next_level
        print('第{0}层递归结果是:{0} + {1} = {2}'.format(n, next_level, ret))
        return ret
    ​
    ​
    if __name__ == '__main__':
        ret = my_sum(10)
        print('递归结果', ret)
    
    第1层递归结束,返回结果1给上一层
    第2层递归结果是:2 + 1 = 3
    第3层递归结果是:3 + 3 = 6
    第4层递归结果是:4 + 6 = 10
    第5层递归结果是:5 + 10 = 15
    第6层递归结果是:6 + 15 = 21
    第7层递归结果是:7 + 21 = 28
    第8层递归结果是:8 + 28 = 36
    第9层递归结果是:9 + 36 = 45
    第10层递归结果是:10 + 45 = 55
    递归结果 55
    

    当发生函数调用时 需要做保存现场和恢复现场的工作。当遇到收敛条件后,递归才会正式结束,然后把结果1(即my_sum(1)=1)返回第二层,第二层得到第一层的结果才会计算2+my_sum(1)=2+1=3,第二层得到结果后会传给第三层,以此类推,到最后一层得到最终结果,整个递归结束。

    保存现场和恢复现场的工作都是利用栈(stack)来实现的。

    栈是一个FILO的结构 - 栈非常的快但是它很小。

    python默认栈的层数为1000层,可以使用以下方法来增加层数(不推荐)

     import sys
     # 设置递归层数最大值为9999层
     sys.setrecursionlimit(9999)
    

    这样的递归不好,因为递归使用的是栈,需要用栈来保护现场和恢复现场,很耗费资源,可以使用尾递归来解决这个问题,即不回溯,直接使用最后一次的结果作为最终的结果。

    在这里插入图片描述

    2、尾递归

    import sys
    # 设置递归层数最大值为100000层
    sys.setrecursionlimit(100000)
    '''
    使用递归求和
    '''
    ​
    ​
    def my_sum(n, result=0):
       '''
      递归求和
      1+2+3+...+n
      :param n: int型
      :param result: int型,上一层求得的结果,第一层递归时为0
      :return: int型
      '''
       # 收敛条件if n == 1:
           print('第1层递归结束,直接返回计算结果{}'.format(result + 1))
           return result + 1
       # 递归公式
       print('第{}层递归,当前求值结果是:{}'.format(n, result))
       return my_sum(n - 1, result=result + n)
    ​
    ​
    if __name__ == '__main__':
       my_sum(10)
    
    第10层递归,当前求值结果是:0
    第9层递归,当前求值结果是:10
    第8层递归,当前求值结果是:19
    第7层递归,当前求值结果是:27
    第6层递归,当前求值结果是:34
    第5层递归,当前求值结果是:40
    第4层递归,当前求值结果是:45
    第3层递归,当前求值结果是:49
    第2层递归,当前求值结果是:52
    第1层递归结束,直接返回计算结果55
    

    这样做有什么好处呢?第一,result代表上一次调用函数求得的结果,有了这个结果我就可以直接做运算,而不需要再去回溯函数获取上次调用函数的值。

    3、递归求斐波那契数列

    斐波那契数列(Fibonacci sequence),又称黄金分割数列、因数学家列昂纳多·斐波那契(Leonardoda Fibonacci)以兔子繁殖为例子而引入,故又称为“兔子数列”,指的是这样一个数列:1、1、2、3、5、8、13、21、34、……

    在数学上,斐波那契数列以如下被以递推的方法定义:F(1)=1,F(2)=1, F(n)=F(n - 1)+F(n - 2)(n ≥ 3,n ∈ N*)。

    斐波那契数列:
    当n = 1, 2时 f(n) = 1
    当n > 2时  f(n) = f(n - 1) + f(n - 2)
    比如:[1, 1, 2, 3, 5, 8, 13, 21, 34, 55...]
    
    import sys
    # 设置递归层数最大值为100000层
    sys.setrecursionlimit(100000)
    ​
    ​
    def fibonacci(n):
        # 收敛条件
        if n <= 2:
            return 1
        # 递归公式
        return fibonacci(n - 1) + fibonacci(n - 2)
    ​
    ​
    if __name__ == '__main__':
        n = 12
        print('当下标为{}时,对应的数值是{}'.format(n, fibonacci(n)))
    

    当下标为12时,对应的数值是144
    这样的递归是不好的,因为每求一层递归都要重新计算前面(n-1)层递归,开销很大,比如:

    求f(9)
    要先求f(8) + f(7)
    而f(8)= f(7) + f(6)
    f(7)=f(6) + f(5)

    你可以测试一下,使用n=120,你会发现需要跑很久才会得出结果。

    为了节省这部分重复的开销,可以使用动态规划来解决这个问题。

    4、动态规划实现递归

    **动态规划(**dynamic programming)是运筹学的一个分支,是求解决策过程(decision process)最优化的数学方法。

    20世纪50年代初美国数学家R.E.Bellman等人在研究多阶段决策过程(multistep decision process)的优化问题时,提出了著名的最优化原理(principle of optimality),把多阶段过程转化为一系列单阶段问题,利用各阶段之间的关系,逐个求解,创立了解决这类过程优化问题的新方法——动态规划。

    其基本思想就是将待求解问题分解成若干个子问题,先求解子问题,然后从这些子问题的解得到原问题的解。

    如果我们能够保存已解决的子问题的答案,而在需要时再找出已求得的答案,这样就可以避免大量的重复计算,节省时间。

    我们可以用一个表来记录所有已解的子问题的答案。不管该子问题以后是否被用到,只要它被计算过,就将其结果填入表中。这就是动态规划法的基本思路。具体的动态规划算法多种多样,但它们具有相同的填表格式。

    在python中的递归,可以使用字典来代替这个表。

    '''
    斐波那契数列:
    当n = 1, 2时 f(n) = 1
    当n > 2时  f(n) = f(n - 1) + f(n - 2)
    比如:[1, 1, 2, 3, 5, 8, 13, 21, 34, 55...]
    '''
    import sys
    ​
    # 设置递归层数最大值为100000层
    sys.setrecursionlimit(100000)
    ​
    ​
    def fibonacci(n, temp={}):
        # 收敛条件
        if n <= 2:
            return 1
        # 首先先从字典中取值
        try:
            return temp[n]
        except KeyError:
            # 如果字典中没有就先把值存进字典
            temp[n] = fibonacci(n - 1) + fibonacci(n - 2)
            return temp[n]
    ​
    ​
    if __name__ == '__main__':
        # 使用动态规划后,不到1秒就得出结果了
        n = 120
        print('当下标为{}时,对应的数值是{}'.format(n, fibonacci(n)))
    
    

    当下标为120时,对应的数值是5358359254990966640871840

    使用动态规划解决:

    一个小孩爬阶梯,一次有3种走法:一次走1个阶梯,一次走2个阶梯,一次走3个阶梯,问如果有10个阶梯总共有多少中走法?

    import sys
    ​
    # 递归层数为100000
    sys.setrecursionlimit(100000)
    ​
    ​
    def walk(steps, temp={}):
        if steps < 0:
            return 0
        elif steps == 0:
            return 1
        try:
            return temp[steps]
        except KeyError:
            temp[steps] = walk(steps - 1) + walk(steps - 2) + walk(steps - 3)
            return temp[steps]
    ​
    ​
    if __name__ == '__main__':
        print('一共有{}种走法'.format(walk(10)))
    

    一共有274种走法

    5、使用装饰器测试递归函数消耗时间

    '''
    斐波那契数列:
    当n = 1, 2时 f(n) = 1
    当n > 2时  f(n) = f(n - 1) + f(n - 2)
    比如:[1, 1, 2, 3, 5, 8, 13, 21, 34, 55...]
    '''
    import sys
    import time
    ​
    # 设置递归层数最大值为100000层
    sys.setrecursionlimit(100000)
    from functools import wraps
    ​
    ​
    def func_time(func):
        # 使用@wraps后可以还原原来的函数
        # 即可以使用func.__wrapped__()来去掉装饰器,直接执行原函数的功能
        @wraps(func)
        def wrapper(*arg, **kwargs):
            # 第一层递归才输出时间
            if kwargs['level'] == 0:
                start = time.perf_counter()
                result = func(*arg, **kwargs)
                end = time.perf_counter()
                print(f'执行时间:{end-start}s')
                return result
            else:
                return func(*arg, **kwargs)return wrapper
    ​
    ​
    @func_time
    def fibonacci(n, temp={}, *, level):
        # 收敛条件
        if n <= 2:
            return 1
        # 首先先从字典中取值
        try:
            return temp[n]
        except KeyError:
            level += 1
            # 如果字典中没有就先把值存进字典
            temp[n] = fibonacci(n - 1, level=level) + fibonacci(n - 2, level=level)
            return temp[n]
    ​
    ​
    def main():
        n = 121
        print(f'当下标为{n}时,对应的数值是{fibonacci(n, level=0)}')
    ​
        fib_19 = fibonacci.__wrapped__(19, level=0)
        fib_20 = fibonacci.__wrapped__(20, level=0)print(f'黄金比例:{fib_19/fib_20}')if __name__ == '__main__':
        main()
    
    执行时间:0.0009382s
    当下标为121时,对应的数值是8670007398507948658051921
    黄金比例:0.6180339985218034
    黄金比例:0.6180339887498949
    

    注意1:能用循环写的代码最好不要使用递归,因为递归有可能造成栈溢出。

    注意2:如果用递归也尽量使用尾递归(只需要递归不需要回溯)和动态规划。

    后记

    【后记】为了让大家能够轻松学编程,我创建了一个公众号【轻松学编程】,里面有让你快速学会编程的文章,当然也有一些干货提高你的编程水平,也有一些编程项目适合做一些课程设计等课题。

    也可加我微信【1257309054】,拉你进群,大家一起交流学习。
    如果文章对您有帮助,请我喝杯咖啡吧!

    公众号

    公众号

    赞赏码

    关注我,我们一起成长~~

    展开全文
  • Python 递归函数详解及实例这篇文章主要介绍了 Python 递归函数详解及实例的相关资料, 需要的朋友可以参考下Python 是一种面向对象、解释型计算机程序设计语言,由 Guido van Rossum 于 1989 年底发明,第一个公开...

    Python 递归函数详解及实例

    这篇文章主要介绍了 Python 递归函数详解及实例的相关资料, 需要的朋友可以参考下

    Python 是一种面向对象、解释型计算机程序设计语言,由 Guido van Rossum 于 1989 年底发明,第一个公开发行版发行于 1991 年。Python 语法简洁而清晰,具有丰富和强大的类库。它常被昵称为胶水语言,它能够把用其他语言制作的各种模块(尤其是 C/C++)很轻松地联结在一起。

    Python 递归函数

    如果一个函数体直接或者间接调用自己,那么这个函数就称为递归函数.也就是说,递归函数体的执行过程中可能会返回去再次调用该函数.在python里,递归函数不需要任何特殊的语法,但是它需要付出一定的努力去理解和创建.

    我们会以一个简单的例子开始:写一个函数求一个自然数中所有数字的和.在设计递归函数的时候,我们会寻找能把问题分解成简单的问题的方法.在这道题中,运算符 % 和 // 可以用来把一个数分成两部分:最低位和不包含最低位数字两部分.

    60185.html

    18117的数字和为:1+8+1+1+7=18.这样我们就可以分割这个数.把这个数分割成最低位7和不包含最低位数字的和1+8+1+1=11.这种分割方法给我们提供了一个算法:通过最低位n%10与n//10的数字之和相加来计算数n的数字之和.这种方法存在特殊情况:如果一个数只有一位,那么它的数字之和就是它本身.这个算法可以用递归函数实现.defsum_digit(n):

    """return the sum of the digit of positive integer n."""

    ifn<10:

    returnn

    else:

    last=n%10

    all_but_last=n// 10

    returnsum_digit(all_but_last)+last

    函数sum_digit 的定义是完整和正确的,即使sum_digit 函数在自身的函数体里被调用.

    这样求一个数的数字之和的问题就被分解成了两部分:求除去最低位部分数字之和,然后加上最低位.这两个步骤全都比原问题要简单.这个函数是递归的,因为第一步的问题和原问题是相同类型的.也就是说, sum_digit 的确实是我们需要去实现自然数数字求和的函数.

    60185.html

    我们可以理解这个递归函数是怎样使用计算环境模型成功应用的.它不需要任何新的规范.

    来源: http://www.phperz.com/article/17/0316/319075.html

    展开全文
  • 移动宽带检查显示 CRM,...Python 递归函数基例2. 关于递归函数基例的说明,以下选项中错误的是 A 递归函数的基例决定所谓基例就是不需要递归就能CSS布局HTML小编今天和大家分享解的,一般来说是问题的最小规模下的解...
  • Python 递归函数详解

    2019-04-16 14:59:00
    递归函数的概念: 直接或间接的调用自身的函数,称为递归函数。 每调用一次自身,相当于复制一份该函数,只不过参数有变化,参数的变化,就是重要的结束条件 下面是一个递归函数的实例: #coding=utf-8def ...
  • 参考链接: Python递归 移动宽带检查显示 CRM,radius状态不一致是怎么回事啊?您可以把电信宽带猫等设备重启试一下,如果仍然不行,可以拨打10000号请工作人员帮您查看、处理。 电信宽带诊断显示AAA带宽寓CRM带宽不...
  • Python 递归函数如果一个函数体直接或者间接调用自己,那么这个函数就称为递归函数.也就是说,递归函数体的执行过程中可能会返回去再次调用该函数.在python里,递归函数不需要任何特殊的语法,但是它需要...
  • Python 递归函数如果一个函数体直接或者间接调用自己,那么这个函数就称为递归函数.也就是说,递归函数体的执行过程中可能会返回去再次调用该函数.在python里,递归函数不需要任何特殊的语法,但是它需要...
  • 如果一个函数在内部调用自身本身,这个函数就是递归函数。举个例子,我们来计算阶乘n! = 1 x 2 x 3 x ... x n,用函数fact(n)表示,可以看出:?1fact(n)= n!= 1 x2 x3 x ... x (n-1) x n= (n-1)! x n= fact(n-1) x n...
  • 上期我们介绍了函数式编程,这期内容就是关于递归函数内容,本期还是按照老规矩,给大家进行核心整理,内容通俗易懂,搭配实际应用,以供大家理解。关于递归:百度解释:是指函数/过程/子程序在运行过程序中直接或...
  • 上期我们介绍了函数式编程,这期内容就是关于递归函数内容,本期还是按照老规矩,给大家进行核心整理,内容通俗易懂,搭配实际应用,以供大家理解。关于递归:百度解释:是指函数/过程/子程序在运行过程序中直接或...
  • 文章内容主要介绍了Python递归函数特点及原理解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下!!!1. 递归函数的特点特点一个函数 内部 调用自己函数内部...
  • 递归,就是在函数运行中自己调用自己代码示例:def recursion(n): # 定义递归函数print(n) # 打印nrecursion(n+1) # 在函数的运行种调用递归recursion(1) # 调用函数这个函数在不断的自己调用自己,每次调用n+1,看下...
  • 上期我们介绍了函数式编程,这期内容就是关于递归函数内容,本期还是按照老规矩,给大家进行核心整理,内容通俗易懂,搭配实际应用,以供大家理解。 关于递归: 百度解释:是指函数/过程/子程序在运行过程序中直接...
  • 上期我们介绍了函数式编程,这期内容就是关于递归函数内容,本期还是按照老规矩,给大家进行核心整理,内容通俗易懂,搭配实际应用,以供大家理解。关于递归:百度解释:是指函数/过程/子程序在运行过程序中直接或...
  • 在函数内部,可以调用其他函数。如果一个函数在内部调用自身本身,这个函数就是递归函数
  • 如果一个函数在内部调用自身本身,这个函数就是递归函数。举个例子,我们来计算阶乘n! = 1 x 2 x 3 x ... x n,用函数fact(n)表示,可以看出:fact(n) = n! = 1 x 2 x 3 x ... x (n-1) x n = (n-1)! x n = fact(n-1)...

空空如也

空空如也

1 2 3 4 5 ... 14
收藏数 264
精华内容 105
关键字:

python递归函数详解

python 订阅