三元表达式，列表、字典、集合生成式，生成器表达式，函数递归，匿名函数，面向过程编程

一、三元表达式，列表、字典、集合生成式，生成器表达式

1、三元表达式

三元表达式是python为我们提供的一种简化代码的解决方案，优雅的取代双分支if。语法如下

res = 条件成立时返回的值 if 条件 else 条件不成立时返回的值

针对下述场景

def max2(x,y):
    if x > y:
        return x
    else:
        return y
res = max2(1,2)

用三元表达式可以一行解决

x=1
y=2
res = x if x > y else y # 三元表达式

2、列表生成式

列表生成式是python为我们提供的一种简化代码的解决方案，用来快速生成列表，语法如下

案例一
l = []
for i in range(10):
    l.append(i)
print(l)
用列表生成式可以一行解决
l = [i for i in range(10)]

案例二
l = []
for i in range(10):
    if i > 5:
        l.append(i)
print(l)
用列表生成式可以一行解决
l = [i for i in range(10) if i > 5]

案例三
names = ["lxx",'hxx',"wxx",'lili']   #如果每个人的名字后面加'_sb'
l = [name + "_sb" for name in names]

案例四
names = ["egon","lxx_sb","hxx_sb","wxx_sb"]    #取有'_sb'的值
res = [name for name in names if name.endswith("sb")]

3、字典生成式

res = {i: i ** 2 for i in range(5)}
print(res)  #生成字典

items = [('k1',111),('k2',222),('k3',333)]
   print(dict(items))
或 print({k:v for k,v in items}) #生成字典

4、集合生成式

res = {i for i in range(5)}
print(res)

5、生成器表达式

创建一个生成器对象有两种方式，一种是调用带yield关键字的函数，另一种就是生成器表达式，与列表生成式的语法格式相同，只需要将[]换成()，即：

res = (i for i in range(3))

如果我们要读取一个大文件的字节数，应该基于生成器表达式的方式完成
with open('db.txt','rb') as f:
    nums=(len(line) for line in f)
    total_size=sum(nums) # 依次执行next(nums)，然后累加到一起得到结果=

with open('a.txt',mode='rt',encoding='utf-8') as f:
    res = f.read()
    print(len(res))
    
    res = 0
    for line in f:
        res += len(line)
        
    res = sum((len(line) for line in f))
    res = sum(len(line) for line in f)
 
    print(res)

二、函数递归

1、函数递归调用

是函数嵌套调用的一种特殊形式，函数在调用时，直接或间接调用了自身，就是递归调用，本质就是一个循环的过程

#1、递归调用应该包含两个明确的阶段：回溯，递推
    回溯就是从外向里一层一层递归调用下去，
        回溯阶段必须要有一个明确地结束条件，每进入下一次递归时，问题的规模都应该有所减少（否则，单纯地重复调用自身是毫无意义的）
     递推就是从里向外一层一层结束递归
大前提：递归调用一定要在某一层结束

2、示例
age(5) = age(4) + 10
age(4) = age(3) + 10
age(3) = age(2) + 10
age(2) = age(1) + 10
age(1) = 18

def age(n):
    if n == 1:
        return 18
    return age(n-1) + 10

res = age(5)
print(res)

函数递归取值
nums = [1,[2,[3,[4,[5,[6,[7,]]]]]]]
def get(l):   
	for num in l:      
    	if type(num) is list:       
    		get(num)       
   		 else:            
  		  print(num)
get(nums)

python中的递归效率低且没有尾递归优化

#python中的递归
python中的递归效率低，需要在进入下一次递归时保留当前的状态，在其他语言中可以有解决方法：尾递归优化，即在函数的最后一步（而非最后一行)调用自己，尾递归优化：http://egon09.blog.51cto.com/9161406/1842475
但是python又没有尾递归，且对递归层级做了限制

#总结递归的使用：
1. 必须有一个明确的结束条件
2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少
3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

2、二分法

想从一个按照从小到大排列的数字列表中找到指定的数字，遍历的效率太低，用二分法（算法的一种，算法是解决问题的方法）可以极大低缩小问题规模

nums = [-3,1,3,7,13,23,37,43,57,63,77,91,103]  #从小到大排列
find_num = 64
def find(nums,find_num):
    print(nums)
    if len(nums) == 0:
        print("not exists")
        return
    mid_index = len(nums) // 2
    if find_num > nums[mid_index]:
        # in the right
        find(nums[mid_index+1:],find_num)
    elif find_num < nums[mid_index]:
        # in the left
        find(nums[:mid_index], find_num)
    else:
        print('you got it')
find(nums,find_num)

三、匿名函数

概念

匿名就是没有名字的函数。特点：临时用一次
def func(x,y,z=1):
    return x+y+z

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

有名字的函数与匿名函数的对比

#有名函数与匿名函数的对比
有名函数：循环使用，保存了名字，通过名字就可以重复引用函数功能

匿名函数：一次性使用，随时随时定义

应用：max，min，sorted,map,reduce,filter

四、面向过程编程

#1、首先强调：面向过程编程绝对不是用函数编程这么简单，面向过程是一种编程思路、思想，而编程思路是不依赖于具体的语言或语法的。言外之意是即使我们不依赖于函数，也可以基于面向过程的思想编写程序

#2、定义
面向过程的核心是过程二字，过程指的是解决问题的步骤，即先干什么再干什么

基于面向过程设计程序就好比在设计一条流水线，是一种机械式的思维方式

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

#4、缺点：可扩展性差，修改流水线的任意一个阶段，都会牵一发而动全身

#5、应用：扩展性要求不高的场景，典型案例如linux内核，git，httpd

#6、举例
流水线1：
用户输入用户名、密码--->用户验证--->欢迎界面

流水线2：
用户输入sql--->sql解析--->执行功能