函数（四）

三元表达式

条件成立的时候返回值if条件else条件不成立时的返回值

x = 10
y = 20
print(x) if x > y else print(y)

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

列表推导式

可以快速的建立列表，对列表做一些算数运算

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

print(lt)

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

可以把字典的元素以键值对的形式取出来，并以元组的形式存储在列表里

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

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

字典生成式

可以快速的建立一个字典

dic = {i: i ** 2 for i in range(10)}
print(dic)

# {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}

字典生成式一般是与zip(拉链函数 --> 列表里包含元组)方法连用

zip是压缩方法，是python解释器的内置方法，

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

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

总结：三元表达式/列表推导式/字典生成式，只是让代码减少了，但是实际逻辑没有变化，而且这三个方式并不想原来的代码那么一目了然，所以最好不要使用这三个方式

生成器

生成器：自定义的迭代器，就是我们自己造出来的迭代器

只要在函数中出现了yield关键字，那么这个函数就是生成器，yield关键字不会继续执行函数体代码，而是返回一个值。

def func():
    yield 123
    yield 456

f = func()
f_iter = f.__iter__()
print(f_iter.__next__())
print(f_iter.__next__())
print(f_iter.__next__())

# 123
# 456
# StopIteration # 报错

yield关键字有三个特性：

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

我们可以自定义一个range()方法

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

for i in range(10):
    print(i)

总结

yield:

1. 提供一种自定义迭代器的方式
2. yield可以暂停住函数，并提供当前的返回值

yield和return比较:

1. 相同点：两者都是在函数内部使用，都可以返回值，并且返回值没有类型和个数的限制
2. 不同点：return只能返回一次值；yield可以返回多次值

生成器的表达式：

• 把列表推导式的[]换成()就是生成器表达式
• 优点：省内存，一次只产生一个值在内存中

匿名函数

匿名函数就是没有函数名的函数，匿名需要lambda关键字。

语法：lambda 参数: <代码块>

匿名函数一般不单独使用，和max()、filter()、map()、sorted()、列表中的sort()内置方法连用

1. max()

   max()方法可以取出最大的值，同理可以使用min()方法取出最小的值

salary_dict = {
    'zhangsan': 10000,
    'lisi': 50000,
    'wangwu': 30000,
    'zhaoliu': 70000
}
salary_list = list(salary_dict.items())
print(salary_list)
print(max(salary_list,key=lambda i:i[1]))

# [('zhangsan', 10000), ('lisi', 40000), ('wangwu', 30000), ('zhaoliu', 60000)]
# ('zhaoliu', 60000)

2. filter()

   filter()是筛选的作用，比如我们可以筛选薪资大于3w的

salary_dict = {
    'zhangsan': 10000,
    'lisi': 50000,
    'wangwu': 30000,
    'zhaoliu': 70000
}
salary_list = list(salary_dict.items())
print(salary_list)
print(list(filter(lambda i: i[1] > 30000, salary_list)))

# [('zhangsan', 10000), ('lisi', 50000), ('wangwu', 30000), ('zhaoliu', 70000)]
# [('lisi', 50000), ('zhaoliu', 70000)]

3. map()

   map()可以进行批量操作，比如我们给每个人的薪资＋5000

salary_dict = {
    'zhangsan': 10000,
    'lisi': 50000,
    'wangwu': 30000,
    'zhaoliu': 70000
}
salary_list = list(salary_dict.items())
print(salary_list)
print(list(map(lambda i: i[1] + 5000, salary_list)))

# [('zhangsan', 10000), ('lisi', 50000), ('wangwu', 30000), ('zhaoliu', 70000)]
# [15000, 55000, 35000, 75000]

4. sorted()

   sorted()方法有排序的作用，比如我们把薪资从大到小排序

salary_dict = {
    'zhangsan': 10000,
    'lisi': 50000,
    'wangwu': 30000,
    'zhaoliu': 70000
}
salary_list = list(salary_dict.items())
print(salary_list)
print(sorted(salary_list, key=lambda i: i[1], reverse=True))

# [('zhangsan', 10000), ('lisi', 50000), ('wangwu', 30000), ('zhaoliu', 70000)]
# [('zhaoliu', 70000), ('lisi', 50000), ('wangwu', 30000), ('zhangsan', 10000)]