四种简化的表达与生成方式

三元表达式

三元表达式，主要的作用就是将一大串，分为很多行的代码浓缩到一行中。所谓浓缩就是精华。这么做可以很大的节省代码的运行空间

三元表达式只支持双分支结构

接下来的一段代码是一个较为普通的双分支结构的代码

    fronts = [1,2,4,4,7]
    backs = [1,3,4,1,3]
    a = set(fronts + backs)
    for i, j in zip(fronts, backs):
        if i == j:
            a -= {i}
            if a == set():
                return 0
    else:
        return min(a)

如果用三元表达式的话，这段代码就会变得非常简单：

fronts = [1,2,4,4,7]
backs = [1,3,4,1,3]
return min(set(fronts+backs)-{i for i, j in zip(fronts, backs) if i == j} or [0])

是不是感觉满脸问号？

但是其实三元表达式只是让你的代码更少了，逻辑本身却没有什么变化。而且别人理解你的代码也会变得非常的困难，所以并不是很建议使用

列表推导式

列表推导式可以使用非常简洁的方式对列表或其他可迭代对象的元素进行遍历和过滤，快速生成满足特定需求的列表，代码具有非常强的可读性，是Python程序开发时应用最多的技术之一。Python的内部实现对列表推导式做了大量优化，可以保证很快的运行速度，也是推荐使用的一种技术。

列表推导式在逻辑上等价于一个循环语句，只是形式上更加简洁

aList = [x*x for x in range(10)]

# 等价于：
aList = []
for x in range(10):
aList.append(x*x)

字典生成式

字典生成式一般与zip(拉链函数--》列表里面包了元组)连用

它类似于列表推导式，也是为了简化字典的生成

new_dic = {k * 2: v ** 2 for k, v in dic.items()}
print(new_dic)

z = zip(['a', 'b', 'c', 'd'], [1, 2, 3, 4])  # 压缩方法，Python解释器的内置方法
for k,v in z:
    print(k,v)

生成器

生成器是自定义迭代器，是自己造出来的迭代器

yield

yield的英文单词意思是生产，在函数中但凡出现yield关键字，再调用函数，就不会继续执行函数体代码，而是会返回一个值

def func():
print(1)
yield
print(2)
yield
g = func()
print(g)

yield的主要作用是截断，但是f放在这里就可以实现很多的功能，生成器的本质就是迭代器，同时也并不仅仅是迭代器

yield的三个特性

1. yield可以把函数变成生成器（自定制的迭代器对象，具有___iter__和__next__方法）
2. yield可以停止函数，再下一次next再次运行yield下面的代码
3. 有n个yield生成器就有n个元素，就可以next n次， 第n+1次next会报错

return的特性

1.返回值

2.终止函数

def func():
    yield [1,1,23]  # yield会使函数func()变成生成器对象，因此他就具有__iter__方法
    # print(789) # yield会停止函数，当运行下一次next才会继续运行下面的代码
    yield 101112 # 一个yield对应一个next
    # print(131415)

g = func()
for i in g:
    print(i)

我们还可以在试着用生成器自己制定一个range(10)

def range(x):
    count = 0
    while count < x:
        yield count
        count += 1

配合之前的可变长参数一个完整的range也不在话下

def range(*args, step=1):
    args = list(args)
    if len(args) == 1:
        count = 0
        while count < args[0]:
            yield count
            count += step
    elif len(args) == 2:
        while args[0] < args[1]:
            yield args[0]
            args[0] += step

生成器表达式

# 把列表推导式的[]换成()
lt = [i for i in range(10000000)]
print(lt)
g = (i for i in range(10000000))
print(g)
print(g.__next__())

列表和元组的区别 ：列表就是一筐鸡蛋,元组是一只老母鸡(节省空间)

匿名函数

匿名函数，顾名思义，就是没有名字的函数

匿名需要关键字lambda

# lambda 参数:<代码块>

f = lambda x: x+1
res = f(1)
print(res)

匿名函数一般不单独使用，,和 filter()/map()/sorted()/列表的sort()内置方法联用

salary_dict = {
    'nick': 3000,
    'jason': 100000,
    'tank': 5000,
    'sean': 2000
}
salary_list = list(salary_dict.items())
print(salary_list)  # [('nick', 3000), ('jason', 100000), ('tank', 5000), ('sean', 2000)]

有这样一段代码，如果用内置方法进行排序的话，只能通过key来排序

如果用有名函数的话，可以办到对value值进行排序，但会比较麻烦

如果用匿名函数的话就会简单许多

def func(i):  # i = ('sean', 2000), ('nick', 3000),('tank', 5000),('jason', 100000)
    return i[1]  # 2000,3000,5000,100000
    
salary_list.sort(key=lambda i: i[1])  # 内置方法是对原值排序
# 按照func的规则取出一堆元素2000,3000,5000,100000
# 然后按照取出的元素排序
print(salary_list)