三元表达式 列表，字典，集合生成式 生成器表达式 函数的递归调用 二分法 匿名函数 面向过程编程思想

三元表达式：

取代双分支的if
 def max(x, y):
     if x > y:
         return x
     else:
         return y
 x = 11
 y = 22
 print(x if x > y else y)
 print("yes" if x > y else "no")

列表生成式

 案例1
 l = []
 for i in range(10):
     l.append(i)
 print(l)

 l = [i for i in range(10)]
 print(l)

 案例2
 l = []
 for i in range(10):
     if i > 5：
         l.append(i)
 print(l)

 l = [i for i in range(10) if i > 5]
 print(l)

 案例3：
 names = ["LXX", "HXX", "WXX", "LILI"]
 l = []
 for i in names:
     l.append(i + "_sb")
 print(l)

 l = [i + "_sb" for i in names]
 print(l)

 案例4:
 方法1:
 l = []
 names = ["egon", "lxx_sb", "hxx_sb", "wxx_sb"]
 for i in names:
     if "_sb" in i:
         l.append(i)
 print(l)

 l = [i for i in names if "_sb" in i]
 print(l)
 
 方法2:
 for i in names:
     if i.endswith("sb"):
         l.append(i)
 print(l)

 l = [i for i in names if i.endswith("sb")]
 print(l)

字典生成式

 res = {i: i ** 2 for i in range(5)}
 print(res)   0-4的平方，生成字典

 items = [("k1", 111), ("k2", 222), ("k3", 333)]
 print(dict(items))
 res = {k: v for k, v in items}

集合生成式

 res = {i for i in range(5)}
 print(res)
 
# 没有元组生成式，生成列表后直接tuple会自动生成元组

生成器表达式：

 res  = (i for i in range(3))	# 可迭代对象加括号的得到的res，res就是生成器对象
 print(res)		
 print(next(res))
 print(next(res))
 print(next(res))

 with open("a.txt", mode="rt", encoding="utf-8") as f:
	 res = f.read()
	 print(len(res))

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

 with open("a.txt", mode="rt", encoding="utf-8") as f:
     res = sum(len(i) for i in f)   # sum()表示把（）内所有值的和
     print(res)

函数的递归调用

在调用一个函数的内部又调用自己，所有递归调用的本质就是一个循环的过程

 def func():
     print("func")
     func()

 func()

import sys
print(sys.getrecursionlimit())     # 这两行代码查看递归调用深度，最高是1000层

import sys
sys.getrecursionlimit()      # 设置递归调用的深度，递归调用到一定深度后会结束，如果递归调用设置到很深的程度，会有内存溢出的风险

递归调用的前提：递归调用一定要在某一层结束
递归调用的两个阶段：
回溯:指的是向下一层一层挖井
递推:指的是向上一层一层返回
 
案例:
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 i in l:		# 先取1，依次往列表里面取值，取完7后nums = None
        if type(i) is list:
            get(i)
        else:
            print(i)
get(nums)

基本算法：二分法

 nums = [-3, -2, 1, 2, 5, 8, 9, 65, 458, 558, 689]
 find_num = 64

 def find(nums, find_num):
     print(nums)
     if len(nums) == 0:
         print("not exists")
         return
     mid_index = len(nums) // 2           # len(nums)//2的结果就是计算机的中间值索引
     if  find_num > nums[mid_index]:
         # in the right
         find(nums[mid_index + 1:], find_num)  # 通过切分的方式，如果取右边的值，取值顾头不顾尾，第一个值已经比较过了，索引直接+1
     elif  find_num < nums[mid_index]:
         # in the left
         find(nums[:mid_index], find_num)
     else:
         print("you got it")

 find(nums, find_num)

匿名函数

 什么是匿名函数
 没有名字的函数
 特点:临时用一次,lambda自带return。
 lambda体现了函数式编程的思想 
 def func():
     print("func")

 func()
 func()
 func()

 res = (lambda x, y: x + y)(1, 2)	# 传入x,y  res = x+y
 print(res)

 匿名函数案例(dict改变比较参数的用法):
 salaries = {
     "egon": 3000,
     "tom": 1000000,
     "zxx": 1000
 }
 
 print(max([1, 2, 3]))		# 比较列表里面值的大小 
 print(max(salaries.values()))

 def func(k):
     return salaries[k]
     
 print(max(salaries, key=func))    # 遍历的参数都是salaries,key主要是为了改变比较依据,这样比较依据变成了函数func
 print(max(salaries, key=lambda k:salaries[k]))   # max内置函数取最大值
 print(min(salaries, key=lambda k:salaries[k]))      # min内置函数取最小值
 print(sorted(salaries, key=lambda k:salaries[k]))     # sorted按照从小到大排序
 print(sorted(salaries, key=lambda k:salaries[k], reverse=True))    # sorted加上reverse=True变成从大到小排序

了解即可

 map:把一个列表映射成一个新列表
 names = ["LXX", "HXX", "WXX", "LILI"]
 l = [name + "_sb" for name in names]
 res = map(lambda name: name + "_sb", names)      # map括号里面的开头是一个函数,后面的是用来传值的.用逗号隔开,会把后面的值用迭代的方式把值传给前面的值，把map的结果赋值给res,res会直接变成一个迭代器
 print(list(res))

 filter
 names = ["lxx_sb", "egon", "wxx_sb", "lili_sb"]
 print([name for name in names if name.endswith("sb")])
 res = filter(lambda name: name.endswith("sb"), names)      # filiter会把布尔值为True的结果留下,把filter的结果赋值给res,res会直接变成一个迭代器
 print(list(res))

 reduce
 from functools import reduce
 res = reduce(lambda x, y: x + y, [1,2,3])       # reduce会把所有的值合并成一个值
 res = reduce(lambda x, y: x + y, ["aa", "bb", "cc"])      # reduce会把所有的值合并成一个值
 print(res)
 
 pow
 res = pow(10, 2, 3)            # 10**2 % 3
 print(res)

面向过程编程

面向过程编程:
	核心是"过程"二字, 过程就是解决问题的步骤, 即: 先做什么, 再做什么.
	所以基于该思想编写程序就好比设计一条一条流水线
	优点: 复杂的问题流程化, 进而就简单化
	缺点: 牵一发而动全身,扩展性差