三元表达式、列表推导式、生成器表达式、lambda表达式（匿名函数）

目录：

• 三元表达式

• 各种推导式

• 生成器表达式

• lamda表达式

一、三元表达式

　　语法：为真时的结果 if 判定条件 else 为假时的结果

　　实例：

>>> a = "zjk"
>>> print("666") if a == "zjk" else print("888")
666

二、各种推导式

　　说明：推导式又称解析式，是python的一种独有特性。推导式是可以从一个数据序列构建另一个新的数据序列的结构体，共有三种推导；

　　列表推导式、字典推导式、集合推导式；

1.列表推导式

　　说明：使用 [ ] 生成list

　　格式：

variable = [out_exp_res for out_exp in input_list if out_exp == 2]
  out_exp_res:　　列表生成元素表达式，可以是有返回值的函数。
  for out_exp in input_list：　　迭代input_list将out_exp传入out_exp_res表达式中。
  if out_exp == 2：　　根据条件过滤哪些值可以。

　　实例：

#实例一：计算30内可以被3整除的数
>>> li = [i for i in range(30) if i % 3 == 0]
>>> print(li)
[0, 3, 6, 9, 12, 15, 18, 21, 24, 27]


#实例二：计算30内可以被3整除的数的平方
>>> li = [i**2 for i in range(30) if i % 3 == 0]
>>> print(li)
[0, 9, 36, 81, 144, 225, 324, 441, 576, 729]

2.字典推导式

　　说明：字典推导和列表推导的使用方法是类似的，只不中括号该改成大括号；

　　实例：

#实例一：将key变为小写，并合并所有相同key以及key对应的value
>>> dic = {"a":10,"b":34,"A":7,"Z":56}
>>> dic_zjk = {n.lower():dic.get(n.lower(),0) + dic.get(n.upper(),0) for n in dic if n.lower() in ["a","b","z"]}
>>> print(dic_zjk)
{'a': 17, 'b': 34, 'z': 56}


#实例二：快速更换key和value
>>> print(dic_zjk)
{'a': 17, 'b': 34, 'z': 56}
>>> dic = { v:k for k,v in dic_zjk.items()}
>>> print(dic)
{17: 'a', 34: 'b', 56: 'z'}

3.集合推导式

　　说明：它们跟列表推导式也是类似的。 唯一的区别在于它使用大括号{}；

>>> se = {n**2 for n in [1,-1,2,3]}
>>> print(se)
{1, 4, 9}

三、生成器表达式

　　说明：生成器表达式可以创建一个生成器；

>>> gener = (i for i in range(5))
>>> print(gener)
<generator object <genexpr> at 0x7f9b7123d8b8>
>>> print(gener.__next__())
0
>>> print(gener.__next__())
1
>>> print(gener.__next__())
2
#可以看出由生成器表达式生成了一个gener生成器；

　　与生成器相关的两道面试题：

#面试题1：
def demo():
    for i in range(4):
        yield i

g=demo()

g1=(i for i in g)
g2=(i for i in g1)

print(list(g1))
print(list(g2))
#说出最后的打印结果；
#分析：demo生成器函数生成一个g生成器；然后由生成器表达式生成了g1和g2；
#当打印print(list(g1))时，程序先去运算g1，g1是由(i for i in g)生成器表达式创建出来的，所以要再先计算(i for i in g)，这个表达式又会去找g生成器，所以g1就是0123，此时已经将g的生成器里的值运算完毕了，里面没有值了；
#当打印g2时，g2会去找g1，g1去找g，因为g生成器已经没有值了，所以g2会得到空；
--------------------- 输出结果-----------------------------
>>> def demo():
...     for i in range(4):
...         yield i
... 
>>> g=demo()
>>> 
>>> g1=(i for i in g)
>>> g2=(i for i in g1)
>>> 
>>> print(list(g1))
[0, 1, 2, 3]
>>> print(list(g2))
[]

def add(n,i):
    return n+i

def test():
    for i in range(4):
        yield i

g=test()
for n in [1,10]:
    g=(add(n,i) for i in g)

print(list(g))
---------------------- 输出结果 ----------------------------------
>>> def add(n,i):
...     return n+i
... 
>>> def test():
...     for i in range(4):
...         yield i
... 
>>> g=test()
>>> for n in [1,10]:
...     g=(add(n,i) for i in g)
... 
>>> print(list(g))
[20, 21, 22, 23]
#此例子我们下面画图解

　　面试2例题图解：

　　　 

　　那么，我们在对面试2题进行升级：

#说出程序执行过程中的打印输出结果以及最后的打印结果
def add(n,i):
    return n+i

def test():
    for i in range(4):
        yield i

g=test()

for n in [1,10,5,8]:
    g=(add(n,i) for i in g)
    print(g.__next__())

print(list(g))

------------------ 打印输出 --------------------------------
1
21
17
35
[]

#同样，我们在下面进行图解：

　　面试2升级图解：

四、lambda表达式（又称匿名函数）

1.说明：

　　lambda函数是一种快速定义单行你的最小函数，也是一种匿名函数，是从Lisp借用来的，可以用在任何需要函数的地方；需要注意的是lambda只能写一行；不能多行；

2.格式：

　　lambda 参数:返回值

3.实例：

#1.我们用普通函数计算一下两个数的和；
>>> def sum(x,y):
...     return x+y
... 
>>> sum(5,6)
11


#2.我们使用lambda函数进行计算；
>>> sum1 = lambda x,y:x+y
>>> sum1(5,6)
11

　　可以看到，两个函数得到的结果一样，而对于实现简单功能的函数来说，使用lambda函数来定义更加精简灵活，还可以直接把函数赋值给一个变量，用变量名来表示函数名。；

　　其实lambda函数在很多时候都是不需要赋值给一个变量的。

　　注意事项：  lambda 函数可以接收任意多个参数 (包括可选参数) 并且返回单个表达式的值。  lambda 函数不能包含命令，包含的表达式不能超过一个；

 4.查看函数名称：

　　很多时候，在我们进行调用函数时不一定就是我们自己写的函数，可能是别人写的，那么我们如何查看被调用的函数是什么函数呢？

　　__name__：这个方法是用来查看函数名的，比如：

>>> def zjk():
...     pass
... 
>>> a = lambda x:x
>>> print(zjk.__name__)
zjk
>>> print(a.__name__)
<lambda>

#注意，凡是由匿名函数定义的函数。名称都是匿名函数；

5.关于lambda的多个返回值留下的“坑”：

　　下面看一个例子，请说出打印结果：

>>> zjk = lambda x,y:x,y
>>> print(zjk(10,20))
#请问打印结果是什么？
#
#可能很多同学立马回答，这不就是lambda表达式返回多个值吗，打印结果当然是10和20了，
#那么我们来看一下实际情况是什么
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'y' is not defined
#what？报错了，提示y没有定义，神马情况，这怎么和普通的函数不一样啊，普通的函数返回多个值的时候不是将这多个值用逗号隔开，然后组成元组返回吗，为什么在匿名函数这里就报错了呢？
#解释：
#原因是这样的，我们拆分来看一下，zjk =  lambda x,y:x  ，  y
#也就是说等号右边在系统的定义中，是由两部分元素组成的，一个是匿名函数，一个是y，系统不会认为这里的x，y是匿名函数的返回值，而是把lambda和y组成成元组传递给zjk，由于y没有定义，所以就报错了；
#那么，我想要x，y是一体的该怎么办呢？
#我们可以用元组或列表将其添加，组成一个整体，这样的话就成为一个整体了；具体如下：
>>> zjk = lambda x,y:(x,y)
>>> print(zjk(10,20))
(10, 20)

6.lambda函数例子：

#用户随意输入数字，求最大值；
>>> ma = lambda *args,**kwargs:max(*args,*kwargs.values())
>>> print(ma(1,3,4,2,*[7,8,9],z=444,**{"k":555}))
555
>>> print(ma(1,3,4,2,*[7,8,9],z=444))
444
>>> print(ma(1,3,4,2,*[7,8,9]))
9