重点：递归函数，数学模块，随机模块---day14

1.递归函数

自己调用自己的函数是递归函数

递：去

归：回

一去一回叫作递归

简单递归
def digui(n):
    print(n,'<==1==>')
    if n > 0：
        digui(n-1)
    print(n,'<==2==>')

digui(5)
解析：
'''
去的过程：
n = 5 print(5,"<===1===>") 5 > 0 digui(5-1) <=> digui(4) <=> 当前代码在第14行，代码暂停阻塞
n = 4 print(4,"<===1===>") 4 > 0 digui(4-1) <=> digui(3) <=> 当前代码在第14行，代码暂停阻塞
n = 3 print(3,"<===1===>") 3 > 0 digui(3-1) <=> digui(2) <=> 当前代码在第14行，代码暂停阻塞
n = 2 print(2,"<===1===>") 2 > 0 digui(2-1) <=> digui(1) <=> 当前代码在第14行，代码暂停阻塞
n = 1 print(1,"<===1===>") 1 > 0 digui(1-1) <=> digui(0) <=> 当前代码在第14行，代码暂停阻塞
n = 0 print(0,"<===1===>") 0 > 0 条件不满足，返回False，不执行调用，print(0,"<===2===>")

回的过程：
n = 1 从阻塞位置14行继续向下执行 print(1,"<===2===>")
n = 2 从阻塞位置14行继续向下执行 print(1,"<===2===>")
n = 3 从阻塞位置14行继续向下执行 print(1,"<===2===>")
n = 4 从阻塞位置14行继续向下执行 print(1,"<===2===>")
n = 5 从阻塞位置14行继续向下执行 print(1,"<===2===>")
到此代码全部执行结束  543210012345
'''



'''
递归函数有回的过程，有两种情况可以触发：
(1)当最后一层函数全部执行结束的时候，有触底反弹的过程(回马枪)，回到上层函数空间的调用处
(2)遇到return返回值，直接返回上层空间的调用处

函数在运行的时候，需要内存开辟空间才可以，这个空间叫做栈帧空间
递归：
(1)去的过程就是不停的开辟栈帧空间，在回的时候，就是不停的释放栈帧空间，
递归函数就是不停的开辟和释放栈帧空间的一个完整的过程
(2)回的时候有两种触发的机制，要么是最后一层函数空间全部执行完毕，要么是遇到return，都会触底反弹(回马枪)
(3)写递归函数的时候，必须给与跳出的条件，如果递归的层数过多，不推荐使用，容易内存溢出或者蓝屏
(4)递归调用每一层空间都是独立的个体，独立的副本，资源不共享，可以通过return来完成值的传递。
'''

#官方说法，递归最大深度是1000层，具体按照机器来看
def deepfunc():
    deepfunc()

deepfunc() #996

　　

# 求任意数n的阶乘：5!= 5*4*3*2*1

#普通方法
def func(n):
    total = 1
    for i in range(1,n+1):
        total *= i
        '''
        total = total * i => 1 * 1
		total = total * i => 1 * 1 * 2
		total = total * i => 1 * 1 * 2 * 3
		total = total * i => 1 * 1 * 2 * 3 * 4 
		total = total * i => 1 * 1 * 2 * 3 * 4 * 5
        '''
    return total
res = func(5)
print(res)


#递归写法
def jiecheng(n):
    if n <= 1:
        return 1
    return n*jiecheng(n-1)
res = jiecheng(5)
print(res)
#jiecheng(1) =>1
'''
#代码解析：
#去的过程
n = 5  return 5 * jiecheng(5 - 1) => 5*jiecheng(4)
n = 4  return 4 * jiecheng(4 - 1) => 4*jiecheng(3)
n = 3  return 3 * jiecheng(3 - 1) => 3*jiecheng(2)
n = 2  return 2 * jiecheng(2 - 1) => 2*jiecheng(1)
n = 1  return 1

#回的过程
n = 2 return 2 * jiecheng(1) => 2*1   [jiecheng(2)]
n = 3 return 3 * jiecheng(2) => 3*2*1 [jiecheng(3)]
n = 4  return 4*jiecheng(3) => 4*3*2*1   [jiecheng(4)]
n = 5  return 5*jiecheng(4) => 5*4*3*2*1 [jiecheng(5)]
res = jiecheng(5) <==> 5*4*3*2*1 = 120
'''


# 尾递归(自己调用自己，并且非表达式)[把值放到参数中运算](推荐)
'''
无论调用多少次函数，都只占用一份空间
好处，只需要考虑最后一层空间的结果是多少，就不用额外考虑回的过程了
cpython解释器目前不支持
'''

def jiecheng(n,endval):
    if n <= 1:
        return endval
    return jiecheng(n-1,endval*n)
    
res = jiecheng(5,1)
print(res)

#优化一(防止用户乱传参数)
def outer(n):
    def jiecheng(n,endval):
        if n <= 1:
            return endval
        return jiecheng(n-1,endval*n)
    return jiecheng(n,1)
print(outer(5))

#优化二(防止用户乱传参数)
def jiecheng(n,endval =1)
    if n <=1:
        return endval
    return jiecheng(n-1,endval*n)
print(jiecheng(5))
'''
#代码解析：
#去的过程
n = 5,endval = 1
    return jiecheng(5-1,endval*n) => return jiecheng(4,1*5)
n = 4,endval = 1*5
    return jiecheng(4-1,endval*n) => return jiecheng(3,1*5*4)
n = 3,endval = 1*5*4
	return jiecheng(3-1,endval*n ) => return jiecheng(2,1*5*4*3)
n = 2,endval = 1*5*4*3
	return jiecheng(2-1,endval*n ) => return jiecheng(1,1*5*4*3*2)
n = 1,endval = 1*5*4*3*2
	if 1 <= 1  条件满足 return endval => return 1*5*4*3*2

# 回的过程
n = 2  return 1*5*4*3*2
n = 3  return 1*5*4*3*2
n = 4  return 1*5*4*3*2
n = 5  return 1*5*4*3*2
到此程序全部结束;
'''

#2.斐波那契数列，用递归 1 1 2 3 5 8 13 ...
def feb(n):
    if n==1 or n==2:
        return 1
    #当前值n = 上一个值(n-1) + 上上个值(n-2)
    return feb(n-1) + feb(n-2)
res = feb(5)
print(res)
"""
#代码解析:
n = 5 return feb(4) + feb(3) <=> 3 + 2 => 5

		feb(4)          feb(3)
	feb(3) + feb(2)  feb(2) + feb(1)
feb(2)+feb(1)

		feb(4)          feb(3)
	feb(3) + feb(2)  feb(2) + feb(1)
    1+1

		feb(4)          feb(3)
	    2 + 1           1 + 1
		feb(4) = 3      feb(3) = 2
"""

　　

2.数学模块

math 数学模块
模块.方法()
import math

#ceil()  向上取整  *****
res = math.ceil(3.01)
print(res)

#floor() 向下取整操作 *****
res = math.floor(4.1)
print(res) 

#pow() 计算一个数值的N次方(结果为浮点数)(对比内置函数pow)
res = math.pow(2,3)
print(res)  #2**3

#sqrt()  开平方运算(结果浮点数) 参数= 某个数的平方
res = math.sqrt(9)
print(res)  #3.0

#fabs()  计算一个数值的绝对值(结果为浮点数)(对比内置abs)
res = math.fabs(-9)
print(res)

#modf() 将一个数值拆分为整数和小数两部分组成元组
res = math.modf(-19.8)
print(res)

#copysign()  将参数第二个数值的正负号拷贝给第一个(返回一个小数)
res = math.copysign(-90,-18)
print(res) #-90.0

#fsum() 将一个容器数据中的数据进行求和运算(结果浮点数)(对比内置sum)
lst = [1,2,3,4]
res = math.fsum(lst)
print(res)

#圆周率常数 pi
res = math.pi
print(res)

　　

3.随机模块 random

# ### 随机模块 random
import random

#random() 获取随机0-1之间的小数(左闭右开) 0<= x <1
res = random.random()
print(res)

#randrange() 随机获取指定范围内的整数(包含开始值，不包含结束值，间隔值) 同range *****
#一个参数的用法
res = random.randrange(3)  #0 1
#二个参数的用法
res - random.randrange(3,7) #3,4,5,6
#三个参数的用法
res = random.randrange(3,10,2) #3,5,7,9
print(res)

#randint()  随机产生指定范围内的随机整数(可以获取到最大值)[了解]
res = random.randint(1,3)  #1,2,3
print(res)

#uniform() 获取指定范围内的随机小数(左闭右开) 
res = random.uniform(1,3)   #1<= x <3
print(res)
res = random.uniform(3,1)  #3 >= x >0
print(res)
"""
"Get a random number in the range [a, b) or [a, b] depending on rounding."
return a + (b-a) * self.random()

a = 3 , b = 1
return a + (b-a) * 0~1
return 3 + (1-3) * 0~1
return 3 + -2 * (0~1)

最大值:3 + -2 * 0 = 3
最小值:3 + -2 * 1 = 1

1< x <=3
"""

#choice() 随机获取序列中的值(多选一)
lst = ["周杰伦","蔡徐坤","易烊千玺","神秘boy"]
res = random.choice(lst)
print(res)

#自定义choice函数
def mychoice(lst):
    #随机获取0~3的下标
    num = random.randrange(len(lst))
    #通过下标来获取列表的值
    return lst[num]
print(mychoice(lst))

#lambda表达式
mychoice = lambda lst : lst[random.randrange(len(lst)]
print(mychoice(lst))

#sample()  随机获取序列中的值(多对多) #返回列表
lst = ["周杰伦","蔡徐坤","易烊千玺","神秘boy"]
res = random.sample(lst,2) # 第二个参数为随机返回2个
print(res)

#shuffle() 随机打乱序列中的值(直接打乱原序列)
lst = ["周杰伦","蔡徐坤","易烊千玺","神秘boy"]
random.shuffle(lst)
print(lst)


#随机验证码 4位 大小写字母数字
#chr => 给ascii码返回对应的字符
'''
A~Z
a~z
0~9
'''
#A => 65
#a => 97
print(chr(65))

def yanzhengma():
    strvar = ''
    for i in range(4):
        # 大写字母 A-Z 65-90
        b_word = chr(random.randrange(65,91))
        # 小写字母 a-z 97-122
        s_word = chr(random.randrange(97,123))
        # 数字0-9
        num =  str(random.randrange(0,10))
        #把可能的字符都放在列表里，一次抽一个
        lst= [b_word,s_word,num]
        strvar += random.choice(lst)
    return strvar 
res = yanzhengma()
print(res)

　　

总结：今天主要讲了递归函数，数学模块math，随机模块random。

递归函数重点，目前还没完全弄明白，需继续研究