三元表达式：

x=20
y=15

 res= "yes" if x>y else "no"

条件：x>y 一元
条件成立：yes 一元
条件不成立：no 一元

生成式：列表生成式
l = [i for i in range(10)]#一行代码生成10以内的列表

衍生：l = [i for i in range(10) if i>5] #生成大于五的列表

列表生成式可以套多个for循环但不建议，套多个降低了代码可读性

例：

names = [lxx,hxx,wxx]
l= [name+"_sb"for name in names]
print(l)

例：

names =["egon","lxx_sb","hxx_sb","wxx_sb"]
l = [name,for i in names ifname.endswith("sb")]
print l

字典生成式：
例：res = {i:i**2 for i in range(10)}
print(res)

集合生成式：
例：res = {i for i in range(10)}

生成器表达式：
例：res = (i for i in range(3))
print(res)
上面是生成一个0到3生成器，括号里可以加判断

综上所述：
[]生成的是列表，{}生成的是字典和集合，（）是生成的生成器

函数的递归调用：
再调用函数的内部又调用自己，所以递归调用的本质就是一个循环的过程
不终止的话，会无限循环，将内存空间占满
默认递归深度为1000次
递归两个阶段：优点：基于函数的循环，如果想重复执行某段函数，将它加入它自己函数体内即可
1、回溯：向下层一层一层调用
2、递推：向上层一层一层返回
例：

import sys
sys.getrecursionlimit()
sys.setrecursionlimit(10)
def f1(n):
print('from f1',n)
f1(n+1)
f1(1)

 #import sys
#sys.setrecursionlimit()    #更改递归深度

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)

用递归调用实现二分法：

 nums = [-3,1,3,7,13,23,37,43,57,63,77,91,103]
i=33
def find(nums,i):
    print(nums)
    if len(nums) ==0:
        print("not num")
        return
    mid_index= len(nums)//2
    if i>nums[mid_index]:
        find(nums[mid_index+1:],i)
    elif i<nums[mid_index]:
        find(nums[:mid_index],i)
    elif i==nums[mid_index]:
        print("you got it")

匿名函数：没有名字的函数
特点：临时只能用一次
lambda 不用跟代码块，匿名函数一行即可

例：
res=(lambda x,y:x+y)(1,5)
print(res)

内置函数：
max,min 比大小
sort 排序
map

面向过程编程：主要就是一种面向过程的编程思想
核心在过程二字，过程就是解决问的步骤，即先干啥，在干啥，后干啥
所以基于该思想编写程序就好比设计一条条的流水线
优点：复杂的问题流程化、进而简单化
缺点：牵一发而动全身，扩展性差，