函数的递归，面向过程编程

一、什么是函数递归

函数的嵌套调用是：函数嵌套函数。函数的递归调用：它是一种特殊的嵌套调用，但是它在调用一个函数的过程中，又直接或间接地调用了它自身

def foo():
    print('hello hello')
    foo()
foo() #会进入死循环

如果递归函数不断地调用函数自身，那么这个递归函数将会进入一个死循环，因此我们应该递归函数一个明确的结束条件

1.1直接调用

直接在函数内部调用函数自身

import sys
print(f'最大递归层数：{sys.getrecursionlimit()}')
##最大递归层数：3000

import sys
##修改递归层数
sys.setercursionlimit(10000)
def foo(n):
    print('from foo',n)
foo(0)

1.2间接调用

不在原函数体内调用函数自身，而是通过其他的方法间接调用函数自身

def bar():
    print('hello hello')
    foo()
def foo():
    print('hello lzs')
    bar()
bar()

递归必须要有两个明确的阶段：

1、递归：一层一层递归下去，进入下一层递归的问题规模将会减小

2、回溯：递归必须有一个明确的结束条件，在满足该条件开始一层一层回溯，递归的精髓在于通过不断地重复逼近一个最终的结果

def age(n):
    if n==1:
        return 26
    res=age(n-1)+2
    return res
print(f'age(5):{age(5)}')
##age(5):34

二、为什么要用递归

递归的本质就是干重复的活，但是仅仅是普通的重复，我们使用while循环就可以了

lis=[1,[2,[3,[4,[5,[6]]]]]]
def tell(lis):
    for i in lis:
        if type(i) is list:
            tell(i)
        else:
            print(i)
tell(lis) 
'''
1
2
3
4
5
6
'''

三、如何用递归

用二分法在数组里查找某一个数

def search(serch_num,nums):
    mid_index=len(nums)//2
    print(nums)
    if not nums:
        print('没找到')
        return
    if serch_num>nums[mid_index]:
        nums=nums[mid_index+1]
        search(search_num,nums)
    elif search_num<nums[mid_index]:
        nums=nums[:mid_index]
        search(search_num,nums)
     else:
        print('找到了')
search(7,nums)

面向过程编程

面向过程编程，核心就是编程二字，过程指的是解决问题的步骤，即先干什么，后干什么，再干什么，然后干什么

基于该思想编写程序就好比在设计一条一条流水线，面向对称编程其实是一种机械式的思维方式

当我们写登陆功能，我们首先需要输入账号，密码，然后认证两次密码是否相同，然后从数据库中读取密码验证用户密码输入是否正确，然后输入验证码，之后，我们就能够实现登陆功能，这样把登陆功能问题流程化，进而是解决问题的思路非常清晰

优点：复杂的问题流程化，进而简单化

缺点：扩展性差

一、注册功能

##接受用户输入用户名，进行合法性校验，拿到合法的用户名
def check_username():
    username=input('username>>>>').strip()
    if username.isalpha():
        return username
    else:
        print('用户名必须为字母')

##接受用户输入密码，进行合法性校验，拿到合法的密码
def check_pwd():
    while True:
        pwd=input('password>>>').strip()
        if len(pwd)<5：
        	print('密码长度至少5位')
            continue
        re_pwd=input('re_password>>>').strip()
        if pwd==re_pwd:
            rerurn pwd
        else:
            print('两次输入密码不一致')      

##将合法的用户名和密码写入文件
def insert(username,pwd,path='text.txt')
	with open(path,'a',encoding='utf8')as fa:
        fa.write(f'{username}:{pwd}\n')

2、封装文件读写功能

##数据处理层
def select(username):
    with open('text','r',encoding='utf8')as fr:
        for line in fr:
            info=line.strip('\n').split(':')
            if username==info[0]
            	return info
def tell_info():
    username=input('username>>>>').strip()
    info=select(username)
    print(info)

##用户功能层
def register():
    while True():
        username=input('username>>>>').strip()
        ##检测用户是否重复，如果重复则重新输入
        res=select(username)
        if res:
            print('用户名已经存在')
        else:
            break
    while True:
        pwd=input('password>>>>').strip()
        re_pwd=input('re_password').strip()
        if pwd!=re_pwd:
            print('两次输入密码不一致，请重新输入')
        else:
            break
##把注册功能分开之后，功能与功能直接解耦合，复杂的问题流程化，更加清晰           

3、分层实现功能

用户功能层：实现用户具体的功能

接口层：连接数据处理层和用户功能层

数据处理层：处理数据后把结果交给接口层

分层实现功能的好处：当我们需要实现web端和app端的软件，我们只要把数据处理层和接口层写好，然后实现不同的用户功能层即可，web端使用web端的用户功能层，app端使用app端的用户功能层，但是接口层数据处理层是通用的