列表推导式、生成器表达式以及zip()max()max()/min()sum()sort()map()filter()的用法

列表推导式：

基本格式：

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整除的数

multiples = [i for i in range(30) if i % 3 is 0]
print(multiples)
# Output: [0, 3, 6, 9, 12, 15, 18, 21, 24, 27]　　

推导式迭代嵌套：

names = [['Tom', 'Billy', 'Jefferson', 'Andrew', 'Wesley', 'Steven', 'Joe'],
         ['Alice', 'Jill', 'Ana', 'Wendy', 'Jennifer', 'Sherry', 'Eva']]

print([name for lst in names for name in lst if name.count('e') >= 2])  # 注意遍历顺序，这是实现的关键

几个有意思的内置函数：

zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

如果各个迭代对象的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

语法：

    zip([iterable, ...])

举例：

>>>a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b)     # 打包为元组的列表。过程：统一遍历每个可迭代对象，遍历到每个对象的第一个元素，
#把它们取出来，组成一个元组，然后遍历到第二个，取出来组成元祖，依次类推。
[(1, 4), (2, 5), (3, 6)]
>>> zip(a,c)              # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
>>> zip(*zipped)          # 与 zip 相反，可理解为解压，返回二维矩阵式
[(1, 2, 3), (4, 5, 6)]

sorted() 函数对所有可迭代的对象进行排序操作。

sorted 语法：

sorted(iterable, key=None, reverse=False)

>>>example_list = [5, 0, 6, 1, 2, 7, 3, 4]
>>> result_list = sorted(example_list, key=lambda x: x*-1)#把可迭代对象的每一个元素传入key函数，key的返回值按从小到大排序，再将原对象的对应值组成列表返回。
>>> print(result_list)
[7, 6, 5, 4, 3, 2, 1, 0]

max()/min()求一个可迭代对象的最大值、最小值

语法：

max(iterable, key, default) 　

d1 = {'name': 'egon', 'price': 100}
d2 = {'name': 'rdw', 'price': 666}
d3 = {'name': 'zat', 'price': 1}
l1 = [d1, d2, d3]
a = max(l1, key=lambda x: x['name'])  #遍历迭代对象，每个元素传入key函数，然后按照key得出的结果，找到最大值，并返回原对象中的对应值。
print(a)
b = max(l1, key=lambda x: x['price'])
print(b)
#执行结果

#{'name': 'zat', 'price': 1}
#{'name': 'rdw', 'price': 666}

sum() 方法对系列进行求和计算。

以下是 sum() 方法的语法:

sum(iterable[, start])

• iterable -- 可迭代对象，如列表。
• start -- 指定相加的参数，如果没有设置这个值，默认为0

>>>sum([0,1,2])  
3  
>>> sum((2, 3, 4), 1)        # 元组计算总和后再加 1
10
>>> sum([0,1,2,3,4], 2)      # 列表计算总和后再加 2
12

　　

map() 会根据提供的函数对指定序列做映射。

第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

map() 函数语法：

map(function, iterable, ...)

>>>def square(x) :            # 计算平方数
...     return x ** 2
... 
>>> map(square, [1,2,3,4,5])   # 计算列表各个元素的平方
[1, 4, 9, 16, 25]
>>> map(lambda x: x ** 2, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函数 把可迭代对象每个元素传给函数，函数得到的返回值组成列表就是map函数的返回值
[1, 4, 9, 16, 25]
 
# 提供了两个列表，对相同位置的列表数据进行相加
>>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
[3, 7, 11, 15, 19]

　　

filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。

该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

 filter() 语法:

filter(function, iterable)

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
import math
def is_sqr(x):
    return math.sqrt(x) % 1 == 0
 
newlist = filter(is_sqr, range(1, 101)) #把可迭代对象的每个元素传给函数，返回值如果为真，那么把这个这个元素放入列表返回。
print(newlist)

　　

注意前四个函数的可迭代对象是第一个参数，后两个函数的则是第二个参数。