day 14 三元运算符，列表字典推导式，递归，匿名函数，内置函数（排序，映射，过滤，合并）

一、三元运算符

就是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]

　　

#还有一些算法处理，进制转换，类型装换的内置方法待续