Python基本练习四（函数，递归）

向右看齐 2022-02-19 09:10 485阅读 0赞

### 文章目录 ###

*   *  函数练习
     *  递归练习
     *  函数练习
     *  递归，函数练习

## 函数练习 ##

1.  编写一个函数，能接受至少两个参数，返回最大值和最小值
2.  完成一个函数，可以接收输入的多个数，每一次都能返回到目前为止的最大值、最小值

#编写一个函数，能接受至少两个参数，返回最大值和最小值
    def getMaxMin(x,y,*iterable):
        minval = None
        maxval = None
        if not isinstance(x,int) or not isinstance(x,int): return
        if x>y:
            minval,maxval = y,x
        else:
            minval,maxval = x,y
        for i in iterable:
            if i>maxval:
                maxval = i
            elif i<minval:
                minval = i
        return maxval,minval
    
    #getMaxMin(3,6,12,1212,1)
    
    ##完成一个函数，可以接收输入的多个数，每一次都能返回到目前为止的最大值、最小值
    def maxminPing():
        minarr = None
        maxarr = None
        while True:
            x = input(">>>")
            if x.upper()=="Q": return
            arr = (int(_) for _ in x.replace(","," ").split())
            if minarr==None : minarr = maxarr = next(arr)
            maxarr,minarr = getMaxMin(minarr,maxarr,*arr)
            print("最大值：{}，最小值:{}".format(minarr,maxarr))
    maxminPing()

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMwMDg3OTU_size_16_color_FFFFFF_t_70]

*  第二小题，第二种思路实现

##完成一个函数，可以接收输入的多个数，每一次都能返回到目前为止的最大值、最小值
    def maxminPing():
        minarr = None
        maxarr = None
        while True:
            x = input(">>>")
            if x.upper()=="Q": return
            arr = x.replace(","," ").split()
            if minarr==None and maxarr==None and len(arr) == 1:
    # print(minarr)
                minarr = maxarr = arr[0]
            else:
    # print(arr)
                minarr = min(*arr,minarr)
                maxarr = max(*arr,maxarr)
            print("最大值：{}，最小值:{}".format(minarr,maxarr))
    maxminPing()

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMwMDg3OTU_size_16_color_FFFFFF_t_70 1]

## 递归练习 ##

1.  求n的阶乘
2.  将一个数逆序放入列表中，例如1234 ==》 \[4,3,2,1\]
3.  解决猴子吃桃问题
    
     *  猴子第一天摘下若干个桃子，当即吃了一半，还不过瘾，又多吃了一个，第二天早上又将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩下的一半零一个。到第10天早上想吃时，只剩下一个桃子了。求第一天共摘多少个桃子

*  第一题解法

#第一题：n的阶乘
    #第一种实现
    def factorial(n):
        return n if n==1 else n*factorial(n-1)
    
    #第二种实现
    def factorial2(n,face=1):
        if n==1:
            return face
        else:
            return factorial2(n-1,n*face)
    print(factorial(5),factorial2(5))

*  第二题解法

#第二题
    #思路一，取模递归调用
    def numtolist(num,arr = []):
        if num<10:
            arr.append(num)
        else:
            arr.append(num%10)
            numtolist(num//10)
        return arr
    
    #思路二 利用列表的加法，保存返回值
    def numtolist2(num):
        if num<10:
            return [num]
        else:
            return [num%10] + numtolist2(num//10)
    
    #思路三： 使用str类型递归实现
    def numtolist3(num,arr = []):
        if isinstance(num,int):
            num = str(num)
        if len(num)==1:
            arr.append(int(num))
            return
        else:
            arr.append(int(num[-1]))
            numtolist3(num[:-1])
        return arr
    #思路四，参数限定为一个
    def numtolist4(num):
        if isinstance(num,int):
            num = str(num)
        if len(num)==1:
            return [int(num)]
        else:
            return [int(num[-1])] + numtolist4(num[:-1])
        
    #思路五，使用闭包
    def numtolist5(num):
        arr = []
        def numto(num):
            if num<10:
                arr.append(num)
            else:
                arr.append(num%10)
                numto(num//10)
        numto(num)
        return arr
    
    #思路六 使用devmod
    def numtolist6(num):
        if num<10:
            return [num]
        else:
            tmp = divmod(num,10)
            return [tmp[1]] + numtolist6(tmp[0])
    print(numtolist(123),numtolist2(123),numtolist3(123),numtolist4(123),numtolist5(123),numtolist6(123),sep="\n")

*  第三题解法

#第三题
    #思路一
    def ectpeach(day,num):
        print("第{}天有{}个桃子".format(day,num))
        return num if day==1 else ectpeach(day-1,(num+1)*2)
    #思路二
    def ectpeach2(day):
        return 1 if day==1 else (ectpeach2(day-1)+1)*2
    print(ectpeach(10,1),ectpeach2(10))

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMwMDg3OTU_size_16_color_FFFFFF_t_70 2]

## 函数练习 ##

1.  格式输出，编写一个函数，接受一个参数n,n为正整数，上下三角两种打印方式。要求数字必须对齐  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMwMDg3OTU_size_16_color_FFFFFF_t_70 3]

#格式输出，编写一个函数，接受一个参数n,n为正整数，上下三角两种打印方式。要求数字必须对齐
    ##第一种思路
    def printNum(n,top=True):
        pprint = [] #存储字符容器
        for i in range(1,n+1):##组织好字符
            pprint.append(" ".join([str(_) for _ in range(i,0,-1)]))
        lengs = len(pprint[-1])
        for k in range(len(pprint)):#打印字符
            if top:
                print("{:>{}}".format(pprint[-k-1],lengs))
            else:
                print("{:>{}}".format(pprint[k],lengs))
    ##第二种思路
    def printNum2(n,top=True):
        stt = " ".join([str(_) for _ in range(n,0,-1)]) # 获取最长字符
        lengs = len(stt) # 获取最长字符长度
        arr = range(n,0,-1)  # 默认最长字符打印在上面
        if top==False: # 改变top集合，使最长字符在下面
            arr = range(1,n+1)
        for i in arr: #打印
            print("{:>{}}".format(" ".join([str(_) for _ in range(i,0,-1)]),lengs))
    ##思路三,根据最大长度，切片输出。节约空间和时间
    def printNum3(n,top=True):
        stt = " ".join([str(_) for _ in range(n,0,-1)]) # 获取最长字符
        lengs = len(stt)
        g = 0
        arr = range(n,0,-1)  # 默认最长字符打印在上面
        if top==False: # 改变top集合，使最长字符在下面
            arr = range(1,n+1)
        for i in arr:
            hh = len(str(i))
            print("{:>{}}".format(stt[g:] if top else stt[-g-hh:],lengs))
            g += hh+1  
    
    ##思路四，根据空格下标，可以直接得到要打印的空格数量
    def printNum4(n,top=True):
        stt = " ".join((str(_) for _ in range(n,0,-1)))
        lencount = len(stt)
        if top == True:
            print(stt)
            for i in range(lencount):
                if stt[i] == " ":
                    print(" "* i,stt[i:],sep = "")
        else:
            for i in range(-1,-lencount-1,-1):
                if stt[i] == " ":
                    print(" "*(lencount+i),stt[i:],sep="")
            print(stt)
        
    #printNum2(12)
    #printNum2(12,False)
    #printNum(12)
    #printNum(12,False)
    #printNum3(12)
    #printNum3(12,False)
    printNum4(12)
    printNum4(12,False)

![在这里插入图片描述][20190416102706913.png]

## 递归，函数练习 ##

1.  第二题：扁平化字典![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMwMDg3OTU_size_16_color_FFFFFF_t_70 4]

*  递归解法

arr = { 'a':{ 'b':1,'c':2},'d':{ 'e':3,'f':{ 'g':4}},'h':5}
    print(arr)
    #思路一 递归实现
    def delayering(arr,key,newdict ={ }):
        for k,v in arr.items():
            if isinstance(v,dict):
                delayering(v,key+"."+k)
            else:
                newdict[(key+"."+k)[1:]] = v
        return newdict
    print(delayering(arr,""))

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMwMDg3OTU_size_16_color_FFFFFF_t_70 5]

*  思路二：循环实现

arr = { 'a':{ 'b':1,'c':2},'d':{ 'e':3,'f':{ 'g':4}},'h':5}
    #思路二，循环实现
    def delayering2(arr):
        retarr = { }
        temp2 = [arr] #帮助记录所有需要迭代的字典
        key = [""] # 帮助记录每层对应的key起始值
        i = 0
        while True:
            for k,v in temp2[i].items():
                if not isinstance(v,dict):
                    retarr[(key[i]+"."+k)[1:]] = v
                else:
                    temp2.append(v)
                    key.append(key[i]+"."+k)
            else:
                i += 1
            if i>= len(key):
                break               
        return retarr
    print(delayering2(arr))

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMwMDg3OTU_size_16_color_FFFFFF_t_70 6]

*  思路三，循环实现

arr = { 'a':{ 'b':1,'c':2},'d':{ 'e':3,'f':{ 'g':4}},'h':5}
    #思路三，循环实现，使用join方法，以及直接遍历集合
    def delayering3(arr):
        retarr = { }
        temp2 = [arr] #帮助记录所有需要迭代的字典
        key = [""] # 帮助记录每层对应的key起始值
        i = 0
        for h in temp2:
            for k,v in h.items():
                if not isinstance(v,dict):
                    retarr[".".join(key[i]+k)] = v
                else:
                    temp2.append(v)
                    key.append(key[i]+k)
            i += 1             
        return retarr
    
    print(delayering3(arr))

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMwMDg3OTU_size_16_color_FFFFFF_t_70 7]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMwMDg3OTU_size_16_color_FFFFFF_t_70]: /images/20220219/75fb7bebe7454b548e1f87135589786e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMwMDg3OTU_size_16_color_FFFFFF_t_70 1]: /images/20220219/f3e552c83fa4453484c4f379548a7267.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMwMDg3OTU_size_16_color_FFFFFF_t_70 2]: /images/20220219/44e12dd7c7d14843919954748bca041a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMwMDg3OTU_size_16_color_FFFFFF_t_70 3]: /images/20220219/d611407b590a448e8263816225d1ee70.png
[20190416102706913.png]: /images/20220219/88ad81b0ac4b4b0aa1efd5fa338836d9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMwMDg3OTU_size_16_color_FFFFFF_t_70 4]: /images/20220219/32b8e1158b844da89ee184fab001926a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMwMDg3OTU_size_16_color_FFFFFF_t_70 5]: /images/20220219/bf6cdaf54bd14a2eaddb8a612bcada9f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMwMDg3OTU_size_16_color_FFFFFF_t_70 6]: /images/20220219/f8c22eaae6404bbf8a3cdd4bccc48566.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMwMDg3OTU_size_16_color_FFFFFF_t_70 7]: /images/20220219/11aef35220b2476caef195305368eb19.png