Python3之递归函数简单示例

系统 373 0

概述

递归函数即直接或间接调用自身的函数,且递归过程中必须有一个明确的递归结束条件,称为递归出口。递归极其强大一点就是能够遍历任意的,不可预知的程序的结构,比如遍历复杂的嵌套列表。

递归求和

我们可以利用递归函数实现一个Python内置函数 sum() 的递归版。

            
              
                # 递归
              
              
                def
              
              
                d_sum
              
              
                (
              
              L
              
                )
              
              
                :
              
              
                if
              
              
                not
              
               L
              
                :
              
              
                return
              
              
                0
              
              
                else
              
              
                :
              
              
                return
              
               L
              
                [
              
              
                0
              
              
                ]
              
              
                +
              
               d_sum
              
                (
              
              L
              
                [
              
              
                1
              
              
                :
              
              
                ]
              
              
                )
              
              

sum_l 
              
                =
              
               d_sum
              
                (
              
              
                range
              
              
                (
              
              
                10
              
              
                )
              
              
                )
              
              
                print
              
              
                (
              
              sum_l
              
                )
              
            
          

示例结果

            
              45

            
          

该递归函数怎么实现列表元素相加的呢? 我们知道函数是有本地作用域的,对函数调用的每一个打开的时候,在运行时调用堆栈上都有自己的一个本地作用域的副本,即L在每个层级都是不同的,比如我们可以通过每次调用时添加一个打印语句,更加直观展示每个层级L的情况

            
              
                # 递归
              
              
                def
              
              
                d_sum
              
              
                (
              
              L
              
                )
              
              
                :
              
              
                # 打印该层级L
              
              
                print
              
              
                (
              
              L
              
                )
              
              
                if
              
              
                not
              
               L
              
                :
              
              
                return
              
              
                0
              
              
                else
              
              
                :
              
              
                return
              
               L
              
                [
              
              
                0
              
              
                ]
              
              
                +
              
               d_sum
              
                (
              
              L
              
                [
              
              
                1
              
              
                :
              
              
                ]
              
              
                )
              
              
                # 构建 0-10 数字元素列表
              
              
L 
              
                =
              
              
                [
              
              i 
              
                for
              
               i 
              
                in
              
              
                range
              
              
                (
              
              
                10
              
              
                )
              
              
                ]
              
              
sum_l 
              
                =
              
               d_sum
              
                (
              
              L
              
                )
              
              
                print
              
              
                (
              
              sum_l
              
                )
              
            
          
            
              [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[2, 3, 4, 5, 6, 7, 8, 9]
[3, 4, 5, 6, 7, 8, 9]
[4, 5, 6, 7, 8, 9]
[5, 6, 7, 8, 9]
[6, 7, 8, 9]
[7, 8, 9]
[8, 9]
[9]
[]
45

            
          

处理任意结构

比如我们可以利用递归计算一个嵌套的子列表结构中所有数字的总和

            
              
                def
              
              
                dd_sum
              
              
                (
              
              L
              
                )
              
              
                :
              
              
    tot 
              
                =
              
              
                0
              
              
                for
              
               x 
              
                in
              
               L
              
                :
              
              
                if
              
              
                not
              
              
                isinstance
              
              
                (
              
              x
              
                ,
              
              
                list
              
              
                )
              
              
                :
              
              
            tot 
              
                +=
              
               x
        
              
                else
              
              
                :
              
              
            tot 
              
                +=
              
               dd_sum
              
                (
              
              x
              
                )
              
              
                return
              
               tot


              
                # 嵌套列表
              
              
L 
              
                =
              
              
                [
              
              
                1
              
              
                ,
              
              
                [
              
              
                2
              
              
                ,
              
              
                3
              
              
                ]
              
              
                ,
              
              
                [
              
              
                4
              
              
                ,
              
              
                [
              
              
                5
              
              
                ,
              
              
                6
              
              
                ,
              
              
                7
              
              
                ]
              
              
                ,
              
              
                8
              
              
                ]
              
              
                ,
              
              
                9
              
              
                ]
              
              
sum_l 
              
                =
              
               dd_sum
              
                (
              
              L
              
                )
              
              
                print
              
              
                (
              
              sum_l
              
                )
              
            
          

示例结果:

            
              45

            
          

这种处理方式看似复杂,我们可能更多会利用循环语句替代,但是使用递归函数逻辑简单清晰,这是使用的一大优点。


更多文章、技术交流、商务合作、联系博主

微信扫码或搜索:z360901061

微信扫一扫加我为好友

QQ号联系: 360901061

您的支持是博主写作最大的动力,如果您喜欢我的文章,感觉我的文章对您有帮助,请请扫描上面二维码支持博主1元、2元、5元等您想捐的金额吧,狠狠点击下面给点支持吧

发表我的评论
最新评论 总共0条评论