三元表达式 ,递归。

一  三元表达式：

name=input('姓名>>: ')
res='SB' if name == 'alex' else 'NB'
print(res)

如果输入的为‘alex’，那么输出为‘SB’，否则输入其他任何值输出都为为‘NB’。
那么三元表达式的，其实是一个if判断语句。
def max(x,y):
   if x>y:
      return x
    else:
      return y

二 列表生成式：

egg_list=[]
方式一：for i in range(10):
    egg_list.append('鸡蛋%s' %i)

方式二：egg_list=['鸡蛋%s' %i for i in range(10)]
print（egg_list）

输出为鸡蛋加上数字，为一个列表。
首先定义一个空列表，然后往列表里面加元素，在for循环下。

格式1：
[变量（加工过的变量） for 变量 in 可迭代对象]

   格式2：

   [变量（加工过的变量） for 变量 in 可迭代对象 if（判断条件）]

 三  递归：

函数的递归调用，在函数调用过程中，直接或间接的调用函数本身。

直接引用：
def foo():
     print()
     foo()
foo() 
 调用foo（）函数就会一直在foo（）函数里面执行，这本身是没有意义的。

间接引用：
def foo():
     print()
     bar()
def bar():
     print()
     foo()
调用：foo（）会去执行foo函数，间接调用bar（），然后再通过bar()调用foo（）

递归的应用：

def age(n):
     if n=='1':
          return 18return age(n-1)+2
age(5)
这个就是递归的应用，当我们想要拿到age(5),必须通过age(4)+2,以此类推，先回溯到age(1)。

列表嵌套列表：

def search(l):
    for item in l:
        if type(item) is not list:
            print(item)
        else:
            search(item)

search([1,[2,[3,[4,[5,[6,[7]]]]]]])

递归分为两个部分：回溯和递推：

回溯的过程一定要满足某种条件下结束回溯，否则就会无限循环。

对于递归的总结：

1 递归一定要有一个明确的结束条件。

2 每进入下一次的递归，问题的规模都应该减少。

四  匿名函数：

1 匿名函数顾名思义就是没有函数名：lambda x,n:x**n。

2 也就是说：匿名函数与有名函数参数规则及作用域关系其实是一样的。

3 lambda 后冒号的函数体，一般为一个表达式，且该表达式必须为由返回值。

 那么对于lambda的应用：max，min,sort.

names={1,2,3,4,5,}
salaries={name:'egon',pwd:'123'}
对于
       
max（salaries,key=匿名函数）
res=max(salaries,key=lambda key:salaries[key])
print(list(res))
res=min(salaries,key=lambda key:salaries[key])
print(list(res))
list=['feng','zheng','alex','egon']
sort()   用法
map（）
ruduce（）
filter（）
nums=[1,2,3,4,4,78,5,3]

映射
res=map(lambda x:x**2,nums)
将x转化成x**2输出。
reduce合并
res=reduce(lambda x,y:x+y,range(1,101),初始值)
filter筛选：只留下结果为True的
res=filter（lambda x：x.endswith('sb'),names）
或者：res=filter(lambda x: x>5,nums)
也就是说只留下满足条件的。

内置函数：

 bytes（） :那么我们之前转换bytes一般用encode，现在可以直接用bytes(23344)

ord（）与chr（）:那么ord()是将一个字符放到括号中，转化成数字。而chr与ord想反。

，divmod(),：那么divmode（x，y）将x%y所得的结果以及余数（a，b）

res=abs(-0.22)
print(res)#输入一个数字不管是小数还是整数都回返回他的绝对值
res=all([])
print(res)#如果（）为可迭代对象那么就为真。
res=any([])
print(res)#对于（）内部的可迭代对象，如果都为True则返回真，否则返回为false.
# 
res=bytes('dff',encoding='utf-8')
print(type(res))#将其他形式转化成bytes通过encode
res=chr(65)
print(res)#将数字转化成字母
ord('r')#将字母转化成对应的数字，根据assci
divmod(10,3)
print(divmod(10,3))#输出的为除数和余数。
for x,y in enumerate(['a','s','r']):
     print(x,y)#为可迭代的对象加上索引。
结果为（
0 a
1 s
2 r）
赛选
l=[1,2,3,4,3,3,5,6,67,]
res=filter(lambda x:x>5 ,l)
print(list(res))
起到赛选作用，将满足条件的赛选出
names = ['alex', 'wupeiqi', 'egon']
res=map(lambda x:x+'_nb' if x=='egon'else x+'_db',names)
print(list(res))
# 
min与max
names = ['alex', 'wupeiqi', 'egon']
res=max(names,key=lambda name:len(name))
print(res)
# 
合并
from functools import reduce#使用reduce要先调用。
res=reduce(lambda x,y:x+' '+y+' ',names,)#reduce 里面有三个参数，匿名函数，变量名，初始值
print(res)
salaries={'a':11,'c':2,'e':4}
sorted(salaries)按照key
salari=sorted(salaries,key=lambda  x:salaries[x],reverse=True)