fourth_week_assignment

Recursion

阶乘

1、fac函数的第一个参数n作为计数使用；
2、每进行一次相乘，返回函数fac，第一个参数n-1,第二个参数传入实参factorial，代入下一次函数计数
3、设置递归边界条件 n == 1,返回factorial。

def fac(n,factorial=1):
    if n == 1:
        return factorial

    factorial *= n
    return fac(n-1,factorial)

猴子吃桃

** 1、n为天数，缺省值为第十天，剩余一个桃子；
2、桃子前一天的数量为2 * (peach_number + 1)；
3、边界条件n == 1，递归9次，返回桃子数量。**

def peach(n=10,peach_number=1):
    if n == 1:
        return peach_number
    
    peach_number = 2 * (peach_number + 1)
    return peach(n-1,peach_number)

数字逆序放入列表中

1、整体思路：判断int，将int转为str，每次递归切片取最后一个字符串，追加到lst中。
2、易错点：a、lst需要设置缺省值空列表[],不能在函数内赋值，否则每次递归都会重新赋值成空列表。b、函数递归调用，第一个形参传参，是整除10，每进入一次，低位减一；c、缺省值为列表，复杂类型的默认作用域放在了int_reverse.__default__中，这个属性会伴随函数的整个声明周期，每次调用函数，列表里面的元素会不端增加，为了复用且不影响输出，返回值为清空缺省值列表
3、边界条件：当 num == 0时，说明num没有值可用，递归结束

def int_reverse(num,lst=[]):
    if not isinstance(num,int):
        return 'TypeError'
    
    if num == 0:
        print(lst)
        return lst.clear()
    
    num_str = str(num)
    lst.append(num_str[-1:])
    return int_reverse(num//10,lst)  

格式输出

1、整体思路：将接收的参数n，使用generator(节省内存空间)，倒序依次打印数字并且转为字符串，使用’ '.join方法转为字符串num_str，使用切片依次取子串。上三角从尾部到头取子串，下三角从头部到尾部取子串。
2、易错点：a、步长step的确定：当i为1~9时，加空格长度位17，当i为10，加空格长度为20.故i为个位数步长2，两位数步长3，阈值为i为10。b、每次切片取完子串，start加一次步长，解决a的难点；c、循环8次，步长为16，start=-1-16，符合边界条件，故2 if i < 8 else 3。d、下三角的步长边界，num - i 为当前取值的位数，两位步长为3，一位步长为2.
3、尝试使用递归。

上三角

def format_out (num):
    if not isinstance(num,int):
        return "TypeError"
    num_str = ' '.join((str(i) for i in range(num,0,-1)))
    start = -1 # 切片范围起始位-1
    length = len(num_str)
    
    for i in range(num):
        print(num_str[start:].rjust(length))
        step = 2 if i < 8 else 3   # i < 8,每次两步，i > 8，每次三步
        start -= step    # 堆切片起始位置

下三角

def format_out1 (num):
    if not isinstance(num,int):
        return "TypeError"
    num_str = ' '.join((str(i) for i in range(num,0,-1)))
    start = 0
    step = 3  
    length = len(num_str)
    
    for i in range(num):
        print(num_str[start:].rjust(length))
        step = 3 if num - i > 10 else 2 # num - i 求当前数值，与10进行比较
        start += step

字典扁平化

1、整体思路：使用递归，循环字典，获得k,v，如果v不为dict，则进入返回target的kv对；如果v为dict,则进入递归，且key = key + k，得到’a’。使用’.’.join(key+k)连结，得到’a.b’作为key,非dict的value作为值。
2、易错点：a、如果将’a.c’,'a.c’连结作为key，key的实参，不能在函数条件语句中key = key + k。b、边界条件，关键点在于传入key的实参。

def flatten(n={'c':9,'a':{'b':1,'c':2},'d':{'e':3,'f':{'g':4}}},key='',target={}):
    for k,v in n.items():  # 函数语句中不能key += k,会将k全部连起来
        if isinstance(v,dict):
            flatten(v,key=key+k)   # 此处不能使用return语言，函数终止运行，不会再迭代后面的元素；
                                   # 此处不能使用key += k，语法错误
                                   # 不能单独使用k,会导致字典的最后一个元素'd.f.g':4变为'f.g':4
        else:
            target.setdefault('.'.join(key+k),v)    # 将字典的key连结起来的关键点
    return target