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

函数练习

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()

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

##完成一个函数，可以接收输入的多个数，每一次都能返回到目前为止的最大值、最小值
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()

递归练习

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))

函数练习

1. 格式输出，编写一个函数，接受一个参数n,n为正整数，上下三角两种打印方式。要求数字必须对齐
   

#格式输出，编写一个函数，接受一个参数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)

递归，函数练习

1. 第二题：扁平化字典

• 递归解法

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,""))

• 思路二：循环实现

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))

• 思路三，循环实现

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))