一、三元运算符
就是if.....else..... 语法糖
前提：if和else只有一条语句
#原始版
cmd=input('cmd'）
if cmd.isdigit():
print('1')
else:
print('2') 简化版：
cmd=input('cmd')
print('1') if cmd.isdigit() else print('2') #求两个数的最大值
a=20
b=30
res=a if a>b else b
print(res)
二 、推导式
#列表推导式
dic={'a':1,'b':2,'c':3}
res=[(k,v) for k,v in dic.items()]
print(res)
#[('a',1),('b',2),('c',3)] #元组推导式
res=((k,v) for k,v in dic.items())
print(tuple(res)) #字典推导式
ls=[('a',1),('b',2),('c',3)]
res={k:v for k,v in ls}
print(res)
#{'a':1,'b':2,'c':3}
#案例
#将range()推导为列表
res_ls=[arg for arg in range(10)]
print(res_ls)
#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] #将range()推导为字典
res_dic={'a'；arg for arg in range(10)}
print(res_dic）
#{‘a’:9} #key值具有唯一性，所以只生产最后一个key值 res_dic={arg:1 for arg in range(10)}
print(res_dic,type(res_dic))
#{0: 1, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1, 6: 1, 7: 1, 8: 1, 9: 1} <class 'dict'>
#在此，需要纠正一下，key值不一定是字符串，存在字符串是用来对value起描述作用 #迭代出可解压为的单列容器可以推导出字典
res-dic={v:k for k,v in enumerate('abc')}
print(res）
#{'a': 0, 'b': 1, 'c': 2}
案列
三、递归
前提：
回溯到一个有具体结果的值，开始递推
回溯与递归的条件要有规律 递归的本质：函数的自我调用 import sys
sys.setrecursionlimit(200) #手动设置递归深度
print(sys.getrecursionlimit()) #默认1000
# 询问第一个人年龄，回溯条件 小两岁，第五个人说出自己的年龄，推导出第一个人年龄
# 条件：下一个人的年龄比这个人年纪大两岁
def age(num):
if num==1：
return 58
temp=age(num-1)-2
return temp
res=age(5)
print(res) #求一个数的阶乘
def factorial(num):
if num==1:
return 1
temp=num*factorial(num-1)
return temp
res=factorial(5)
print(res)
#
递归案例
四、匿名函数
匿名函数：没有函数名的函数
语法组成：lambda 参数列表：一个返回值表达式 没有函数名，没有函数体，只有一个返回值
关键字：lambda
参数列表省略（）
返回值return关键字也被省略 f=lambda x,y:(x+y,x-y) # 参数列表：返回值（只能返回一个值）
print(f(10,20)) #（30,-10） #应用场景
# 1.匿名函数函数地址可以被一个变量接受，该变量就可以作为函数名来使用，但就违背了匿名初衷
# 2.结合内置函数来使用: 内置函数某些参数需要一个函数地址，
# -- 可以赋值一个有名函数名，也可以直接赋值匿名函数 res=max(10,20,30,40)
print(res) #40 res=max({10,20,30,40})
print(res) #40
匿名函数与内置函数的简单配合
#lambda 单独使用
res=(lambda i:i*2) #给i传值，返回值为i*2
print(res(10)) #20 #max与函数配合使用
def fn(i):
return i
res=max((1,2,3,4,5),key=fn) #将前面可迭代对象解压给后面的函数使用，比较i的大小，最后返回元组里面最大的一个元素
print(res) #5 #max与lambda配合使用
res=max([5,4,7,6],key=lambda i:i%5) #将列表里的元素依次取出给lambda 里的i传值，取i%5的最大值，最后返回i给res
print(res) #4
五、内置函数的使用
#1、min max 与lambda的搭配使用
iterable = {
'Bob': 12000,
'Tom': 37000,
'Jerry': 76000,
'Zero': 120,
}
#求工资最低的那位
res=min(iterable,key=lambda x:iterable[x])
print(res) #Zero
#求工资最低的金额
res=min(iterable.values(),key=lambda x:x) #加上了.values(),代表从字典里的值中判断最小的元素，然后将该元素返回
print(res) #120
iterable = {
'Bob': {'no': 100, 'salary': 12000},
'Tom': {'no': 200, 'salary': 37000},
'Jerry': {'no': 50, 'salary': 76000},
'Zero': {'no': 150, 'salary': 120},
}
#求编号最小的那位
res=min(iterable,key=lambda k:iterable[k]['no'])
print(res) #Jerry
#求薪水最低的那位
res=min(iterable,key=lambda k:iterable[k]['salary'])
print(res) #Zero
#2、sorted的使用 排序 tup=(1,3,4,5,6)
res=sorted(tup,key=lambda X:X%5 ) #将tup解压取值，X对5取余，默认按从小到大对tup里的元素排序，返回
print(res) #[5, 1, 6, 3, 4] res=sorted(tup,key=lambda x:x%5,reverse=True)#改变默认值，从大到小进行排序
print(res) #[4, 3, 1, 6, 5]
iterable = {
'Bob': [100, 12000],
'Tom': [200, 37000],
'Jerry': [50, 76000],
'Zero': [150, 120],
}
res = sorted(iterable, key=lambda x: iterable[x][0]) #从小到大
print(res) # ['Jerry', 'Bob', 'Zero', 'Tom']
#3.map的使用 映射 map的语法：map(function, iterable, ...) map() 会根据提供的函数对指定序列做映射。
第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。 def fn(x):
return x*x
res=map(fn,[1,2,3,4]) #将列表里的元素解压赋值给fn,返回x*x
print(list(res)) #[1, 4, 9, 16] #与lambda搭配使用
res=map(lambda x: x ** 2, [1, 2, 3, 4, 5]) # 第一个x为参数，x**2为返回值，[.....]列表里的元素解压给返回值，生成一个新的列表
print(list(res)) #[1, 4, 9, 16, 25] #稍复杂
res=map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10,11])
# 将两个列表里的相同位置解压给返回值x+y，后面的列表多出的一个元素虽然会解压，但是不会去赋值给y,最终得到一个新的列表
print(list(res)) #[3, 7, 11, 15, 19]
4. reduce 合并 语法： reduce(function, sequence, initial=None)
function:有两个参数的函数，必需参数
sequence:tuple,list,dictonary,str等可以迭代物，必需参数
initial:初始值，可选参数 关于initial,如果传入了initial值，那么首先传的就不是sequence的第一第二个元素，而是initial的值和第一个元素。最后合并序列得到的是一个单一的返回值 解释：reduce()函数会将数据集合（列表，元组等）中的所有数据进行下列操作：用传给reduce（)中的函数先对集合中的第一第二个元素进行操作，得到的结果再与第三个数据用function()函数运算，最后得到一个结果
from functools import reduce
#基础使用
def fn(x,y):
return x+y
res=reduce(fn,(1,2,3,4,5))
print(res) #15 #与lambda搭配使用
res = reduce(lambda f, n: f * n, [1, 2, 3, 4, 5])
print(res) #120 #改变了默认值：
res=reduce(lambda f,n:f*n,[1,2,3,4,5],10) #不需要给定initial=10这种，直接给值就行
print(res) #1200
#小点：
# 运算
print(abs(-1)) # 绝对值
print(pow(2, 3, 3)) # 2 ** 3 % 3
print(sum([1, 2, 3])) # 求和
print(divmod(100, 30)) # 100与30形成商与余数 # 集合判断操作
print(all([1, 2, 'abc'])) # 元素全真为真
print(any([1, "", None])) # 元素有真则真
filter(lambda x: x % 2 == 0, [1, 2, 3, 4, 5]) # 偶数才能通过过滤 #过滤 filter filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。
语法：filter(function or None, iterable)
注意：python2.7返回列表，python3.x返回迭代器对象
需要接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，
然后返回 True 或 False，最后将返回 True 的元素放到新列表中。 #基础用法
def is_odd(n):
return n%2==0
newlist=filter(is_odd,range(1,11)) #过滤掉奇数
print(list(newlist)) #[2, 4, 6, 8, 10] #结合lambda使用
newlist=filter(lambda x:x%2==1,range(1,11)) #过滤掉偶数
print(list(newlist)) #[1, 3, 5, 7, 9]
#还有一些算法处理，进制转换，类型装换的内置方法待续