1 #直接调用本身
 2 def f1():
 3     print('from f1')
 4     f1()
 5 f1()
 6
 7 #间接调用本身
 8 def f1():
 9     print('from f1')
10     f2()
11
12 def f2():
13     print('from f2')
14     f1()
15 f1()
16
17 # 调用函数会产生局部的名称空间，占用内存，因为上述这种调用会无需调用本身，python解释器的内存管理机制为了防止其无限制占用内存，对函数的递归调用做了最大的层级限制
18 四 可以修改递归最大深度
19
20 import sys
21 sys.getrecursionlimit()
22 sys.setrecursionlimit(2000)
23
24 def f1(n):
25     print('from f1',n)
26     f1(n+1)
27 f1(1)
28
29 虽然可以设置，但是因为不是尾递归，仍然要保存栈，内存大小一定，不可能无限递归，而且无限制地递归调用本身是毫无意义的，递归应该分为两个明确的阶段，回溯与递推

 1 示例+图解。。。
 2 # salary(5)=salary(4)+300
 3 # salary(4)=salary(3)+300
 4 # salary(3)=salary(2)+300
 5 # salary(2)=salary(1)+300
 6 # salary(1)=100
 7 #
 8 # salary(n)=salary(n-1)+300     n>1
 9 # salary(1) =100                n=1
10
11 def salary(n):
12     if n == 1:
13         return 100
14     return salary(n-1)+300
15
16 print(salary(5)) 

 1 l=[1,2,10,30,33,99,101,200,301,311,402,403,500,900,1000] #从小到大排列的数字列表
 2
 3 def search(n,l):
 4     print(l)
 5     if len(l) == 0:
 6         print('not exists')
 7         return
 8     mid_index=len(l) // 2
 9     if n > l[mid_index]:
10         #in the right
11         l=l[mid_index+1:]
12         search(n,l)
13     elif n < l[mid_index]:
14         #in the left
15         l=l[:mid_index]
16         search(n,l)
17     else:
18         print('find it')
19
20
21 search(3,l)

 1 l=[1,2,10,30,33,99,101,200,301,402]
 2
 3 def search(num,l,start=0,stop=len(l)-1):
 4     if start <= stop:
 5         mid=start+(stop-start)//2
 6         print('start:[%s] stop:[%s] mid:[%s] mid_val:[%s]' %(start,stop,mid,l[mid]))
 7         if num > l[mid]:
 8             start=mid+1
 9         elif num < l[mid]:
10             stop=mid-1
11         else:
12             print('find it',mid)
13             return
14         search(num,l,start,stop)
15     else: #如果stop > start则意味着列表实际上已经全部切完，即切为空
16         print('not exists')
17         return
18
19 search(301,l)

1 匿名就是没有名字
2 def func(x,y,z=1):
3     return x+y+z
4
5 匿名
6 lambda x,y,z=1:x+y+z #与函数有相同的作用域，但是匿名意味着引用计数为0，使用一次就释放，除非让其有名字
7 func=lambda x,y,z=1:x+y+z
8 func(1,2,3)
9 #让其有名字就没有意义

 1 字典的运算：最小值，最大值，排序
 2 salaries={
 3     'egon':3000,
 4     'alex':100000000,
 5     'wupeiqi':10000,
 6     'yuanhao':2000
 7 }
 8
 9 迭代字典，取得是key，因而比较的是key的最大和最小值
10 >>> max(salaries)
11 'yuanhao'
12 >>> min(salaries)
13 'alex'
14
15 可以取values，来比较
16 >>> max(salaries.values())
17 >>> min(salaries.values())
18 但通常我们都是想取出，工资最高的那个人名，即比较的是salaries的值，得到的是键
19 >>> max(salaries,key=lambda k:salary[k])
20 'alex'
21 >>> min(salaries,key=lambda k:salary[k])
22 'yuanhao'
23
24
25 也可以通过zip的方式实现
26 salaries_and_names=zip(salaries.values(),salaries.keys())
27
28 先比较值，值相同则比较键
29 >>> max(salaries_and_names)
30 (100000000, 'alex')
31
32
33 salaries_and_names是迭代器，因而只能访问一次
34 >>> min(salaries_and_names)
35 Traceback (most recent call last):
36   File "<stdin>", line 1, in <module>
37 ValueError: min() arg is an empty sequence
38
39
40 sorted(iterable，key=None,reverse=False)

 1 #1、语法
 2 # eval(str,[,globasl[,locals]])
 3 # exec(str,[,globasl[,locals]])
 4
 5 #2、区别
 6 #示例一：
 7 s='1+2+3'
 8 print(eval(s)) #eval用来执行表达式，并返回表达式执行的结果
 9 print(exec(s)) #exec用来执行语句，不会返回任何值
10 '''
11 6
12 None
13 '''
14
15 #示例二：
16 print(eval('1+2+x',{'x':3},{'x':30})) #返回33
17 print(exec('1+2+x',{'x':3},{'x':30})) #返回None
18
19 # print(eval('for i in range(10):print(i)')) #语法错误，eval不能执行表达式
20 print(exec('for i in range(10):print(i)'))

 1 max的工作原理
 2 1 首先将可迭代对象变成迭代器对象
 3 2 res=next(可迭代器对象),将res当作参数传给key指定的函数,然后将该函数的返回值当作判断依据
 4 salaries={
 5     'isetan':3000,
 6     'wcl':100000000,
 7     'wupeiqi':10000,
 8     'yuanhao':2000
 9 } #求年薪最高人的名字
10 print(max(salaries,key=lambda k:salaries[k])) #next(iter_s)
11 print(min(salaries,key=lambda k:salaries[k])) #next(iter_s)

 1 # map的工作原理
 2 #1 首先将可迭代对象变成迭代器对象
 3 #2 res=next(可迭代器对象),将res当作参数传给第一个参数指定的函数,然后将该函数的返回值当作map的结果之一
 4 names=['wcl','isetan','gelln','alex']
 5
 6 #列表生成式做法
 7 print([name+"_haha" for name in names])
 8
 9 #lambda做法
10 aaa=map(lambda x:x+"_haha",names)
11 print（aaa）

1 # filter的工作原理
2 #1 首先将可迭代对象变成迭代器对象
3 #2 res=next(可迭代器对象),将res当作参数传给第一个参数指定的函数,然后filter会判断函数的返回值的真假,如果为真则留下res
4 aaa=filter(lambda x:x.endswith('SB'),names)
5 print(aaa)

 1 #1、首先强调：面向过程编程绝对不是用函数编程这么简单，面向过程是一种编程思路、思想，而编程思路是不依赖于具体的语言或语法的。言外之意是即使我们不依赖于函数，也可以基于面向过程的思想编写程序
 2
 3 #2、定义
 4 面向过程的核心是过程二字，过程指的是解决问题的步骤，即先干什么再干什么
 5
 6 基于面向过程设计程序就好比在设计一条流水线，是一种机械式的思维方式
 7
 8 #3、优点：复杂的问题流程化，进而简单化
 9
10 #4、缺点：可扩展性差，修改流水线的任意一个阶段，都会牵一发而动全身
11
12 #5、应用：扩展性要求不高的场景，典型案例如linux内核，git，httpd
13
14 #6、举例
15 流水线1：
16 用户输入用户名、密码--->用户验证--->欢迎界面
17
18 流水线2：
19 用户输入sql--->sql解析--->执行功能

 1 # 接收用户输入用户名,进行用户名合法性校验，拿到合法的用户名
 2 def check_user():
 3     while True:
 4         name = input('username>>').strip()
 5         if name.isalpha():
 6            return name
 7         else:
 8             print('用户名必须为字母，傻叉')
 9
10 # 接收用户输入密码,进行密码合法性校验，拿到合法的密码
11 def check_pwd():
12     while True:
13         pwd1=input('password>>: ').strip()
14         if len(pwd1) < 5:
15             print('密码的长度至少5位')
16             continue
17         pwd2=input('again>>: ').strip()
18         if pwd1 == pwd2:
19             return pwd1
20         else:
21             print('两次输入的密码不一致')
22
23 def check_age():
24     pass
25
26 # pwd=check_pwd()
27 # print(pwd)
28 # 将合法的用户名与密码写入文件
29 def insert(user,pwd,age,path='db.txt'):
30     with open(path,mode='a',encoding='utf-8') as f:
31         f.write('%s:%s:%s\n' %(user,pwd,age))
32
33 def register():
34     user=check_user()
35     pwd=check_pwd()
36     age=check_age()
37     insert(user,pwd,age)
38     print('register successfull')
39
40 register()
41
42
43 #ps：将原先的复杂的代码分块写，清晰，易读