列表推导式到匿名函数

今天早上六点多起来妙妙，然后继续睡，眼睛一闭一睁八点零六，炸毛了，弹射起步，十分钟全部搞定，滑滑板来到教室，太赶了，让我一天的状态都是懵的，这种感觉真的太难受了，困，不必说，站起来也听不进去，这导致了我今天的听课效率比国家人均GDP都低。然后老师讲课的时候会问，这个听懂的举手

即使我没听懂，我还是举手了

根本没跟上啊。。。。

好了 今天的打气流程 。。。。。

今日洗脑金句：加油，最后悔的事不是失败，而是“你本可以”。

三元表达式

dog_name = 'crazy_dog1'
print('疯狂舔🐕') if dog_name == 'crazy_dog' else print('666')

这个是什么意思，其实和原来的逻辑判断一样，只不过，这个逼格更高，但是不推荐，因为用的人少，而且大家都看不懂，公司就会把你开了，找一个写代码让人看的懂的程序员来。

那么这句的意思是什么，就是如果 dog_name == ‘crazy_dog' ,就打印疯狂舔狗，不然的话就打印666。

不过你们可以别听我的，尽管去用，要知道，你写的代码如果只有你自己看的懂，你就是公司不可或缺的员工，如果你的bug很多，不停地改，公司就会觉得你很牛逼，很能改bug。

所以放手去做吧，工作可以再找，被磨平的棱角一去不复返！

列表推导式

别去管这个原理，根本就是找罪受。没必要，也不用。

lt = []
for i in range(10):
     lt.append(i**2)

print(lt)

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

这是我们原始把列表打印出来的方法，对吧

现在教你们用一种花哨的方式，就是列表推导式。

lt = [i ** 2 for i in range(10)]
print(lt)

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

这个的结果和上面一样，屌就屌在他可以直接在过程中就对每个元素进行操作。

dic = {'a': 1, 'b': 2}

lt = [(k, v) for (k, v) in dic.items()]
print(lt)

[('a', 1), ('b', 2)]

他就打印形式就是上面这个，列表套元组的形式。

字典生成式

dic = {'a': 1, 'b': 2}

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

{'aa': 1, 'bb': 4}

字典生成式就和列表推导式看起来差不多对吧，都是在括号里面，先写好最后表达的形式，然后开始for循环，

同样的，你也可以在表达形式那里，直接对最后的元素进行操作，所以最后会输出aa和bb了，不加*2的话就是a和b。

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

a 1
b 2
c 3
d 4

zip方法是一个解释器的内置方法，他会返回一个zip对象，zip对象是什么类型的？

你管他什么类型？你是太平洋警察吗？知道怎么用就行了。

zip方法的参数可以传无数个，而且必须是可变类型的，你传个整型，他就肯定报错了。

zip对象有 __next__方法这说明什么？他就一定有 __iter__方法，说明了他是可迭代对象，那么就直接用for循环给他全打印出来了，每个参数的第一个都会被打印出来，循环的次数取决于最短的那个参数。

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

dic = {k: v ** 2 for k, v in zip(['a', 'b', 'c', 'd'], [1, 2, 3, 4])}  
print(dic)

{'a': 1, 'b': 4, 'c': 9, 'd': 16}

这样就生成了一个字典了，最好别去用它，你自己想想啊，你开发的时候会用这几把玩意儿写？

别杠，杠就打死你

生成器表达式

首先我们来搞清楚一下，什么是生成器，不和你们多bb，生成器就是一个自定义的迭代器。迭代器对象有什么作用啊，有next 和 iter方法嘛，可以迭代嘛。那怎么让生成器变成迭代器呢，就是要用yield关键字了。

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

f = func()  # 生成器
print(f)  # <generator object func at 0x000001F0E44237D8>
f_iter = f.__iter__()
print(f_iter.__next__())
print(f_iter.__next__())
print(f_iter.__next__())

来我们好好研究研究这个玩意儿，首先，这个打印结果一定是会报错的。先看函数func，第一行是 yield 456

我们是不是讲过yield可以让他变成可迭代对象，所以在打印这里的next就会让他输出456，注意，yield的时候，相当于是一个暂停键，这个时候如果不写下一个next，就不会往下走，那么print也不会执行了，也不会有789输出，所以要加next，加了之后又遇到了yield 再次输出101112，又卡住了，是不是还需要一个next，对，但是这个时候print131415确实会打印，但是也会报错，因为他的迭代对象已经迭代完了，没有yield了，而你却next了，所以会报错。

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

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

这个函数就是通过yield实现了range方法，这就是range的原理。有精力的看一下没精力的就不要看了

生成器表达式

什么是生成器表达式？

贼几把简单

贼：“ ？”

只需要把列表推导式的[ ]换成（）就好了

lt = [i for i in range(10000000)]
print(lt)
————————————————————————————————————————
g = (i for i in range(10000000))
print(g)
print(g.__next__())

用虚线划分了两个，还记得我们讲过的一筐鸡蛋和一直老母鸡的栗子吗？ 不记得很正常，因为我没讲过

列表就是一筐鸡蛋，也就是虚线上方的列表推导式，他会一次性所有元素都拿出来，很占内存，把鸡蛋放了一筐。

而元组更像是一只老母鸡，你要几个元素，老母鸡就给你下几个蛋，非常节省空间。

匿名函数

匿名函数，顾名思义就是匿名函数。

就是没有名字的函数啊。

def max2(x, y):
     if x > y:
         return x
     return y

这个是有名字的函数

# 匿名需要关键字lambda


# lambda 参数:<代码块>

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

这个就是匿名函数了。

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

讲解一下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)]


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)

[('nick', 3000), ('jason', 100000), ('tank', 5000), ('sean', 2000)]
[('sean', 2000), ('nick', 3000), ('tank', 5000), ('jason', 100000)]
[('sean', 2000), ('nick', 3000), ('tank', 5000), ('jason', 100000)]

不要管为什么，key=lambda i: i[1] 他就是能把salary_dict里的元素都取出来。然后自己看吧，以元组的形式存在列表里面，排好序，这个方法是用C语言写的，所以我们不用去管他到底怎么实现的，只要知道他的过程就好了。

下面还有一些其他的东西，我还没有搞懂，等我先搞懂了，然后再来更新这篇博客

了解我的朋友大概知道这就是一辈子也不更新这篇博客的意思了。