lambda filter map reduce apply zip all sort sorted

1. lambda 匿名函数

lambda para: func(para)

lambda 函数是一个可以接收任意多个参数(包括可选参数)并且返回单个表达式值的函数
1.lambda函数比较轻便，即用即仍，很适合需要完成一项功能，但是此功能只在此一处使用，连名字都很随意的情况下
2.匿名函数，一般用来给filter，map这样的函数式编程服务
3.作为回调函数，传递给某些应用，比如消息处理

2. filter()

功能：

过滤掉序列中不符合函数条件的元素，当序列中要删除的元素可以用某些函数描述时，就可以使用filter函数。返回一个迭代器

类似一个for循环，但它是一个内置函数，并且更快

filter(func,seq).func

可以是匿名函数或者自定义函数，他会被后面的seq的每个元素判定是否符合函数条件，返回True False 只留下True的元素。

  1. seq = range(1, 10)
  2. print(type(seq))    # <class 'range'>
  3. res = filter(lambda x: x % 2 == 0, seq)
  4. print(type(res))    # <class 'filter'>
  5. print(res)    # <filter object at 0x0000022015652FD0>
  6. print(list(res))    # [2, 4, 6, 8]
  7. l = [i for i in res] # [2, 4, 6, 8]

逻辑实现

def filter(func,seq):
    f_seq = []                    # 建一个空序列，用于存储过滤后的元素 
    for item in seq:              # 对序列中的每个元素进行迭代 
        if func(item):            # 如果为真的话 
            f_seq.append(item)    # 满足条件者，则加入 
    return f_seq                  # 返回过滤后的元素

3. map()

功能：

求一个序列或者多个序列进行函数映射之后的值。返回的是迭代器。需要同filter一样就行list转换。

map(func,iterable1,iterable2)

func有几个参数，iterable就有几个，按iterable中最短的序列计算。

i1 = [_ for _ in range(1, 10)]
i2 = [_ for _ in range(10, 0,-1)]
i3 = [0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1]
res = map(lambda x, y, z: x - y + z, i1, i2, i3)
print(res)    # <map object at 0x00000284AC7B7940>
print(type(res))    # <class 'map'>
print(list(res))    # [-8.9, -6.9, -4.9, -2.9, -0.9, 1.1, 3.1]
map(list, i)

4. reduce()

描述

reduce() 函数会对参数序列中元素进行累积。
函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。

语法

reduce() 函数语法：
reduce(function, iterable[, initializer])

参数

  • function — 函数，有两个参数
  • iterable — 可迭代对象
  • initializer — 可选，初始参数

    返回值

    返回函数计算结果。
>>>def add(x, y) :            # 两数相加
...     return x + y
... 
>>> reduce(add, [1,2,3,4,5])   # 计算列表和：1+2+3+4+5
15
>>> reduce(lambda x, y: x+y, [1,2,3,4,5])  # 使用 lambda 匿名函数
15

i2 = [1 for _ in range(10, 0,-1)]
from functools import reduce
res = reduce(lambda x,y: x+y,i2)
print(res)    # 10
print(type(res)) # <class 'int'>

res = reduce(lambda res, c: res * 10 + eval(f'{c}*1'), '123', 0)
>>> 123

计算过程

先计算res = i2[0]+i2[1]

res = res + i2[2]

res = res + i2[3]

…

res = res + i2[9]

5. apply

功能pandas 内置

对象为DataFrame 或者Series。一是直接对DataFrame或者Series应用函数，二是对pandas中的groupby之后的聚合对象apply函数

apply(func, axis)

import numpy as np
import pandas as pd
a = np.random.randint(low=0, high=4, size=(2, 4))
data = pd.DataFrame(a)
print(data)
data = data.apply(lambda x: x*10)
print(data)

'''
   0  1  2  3
0  0  1  0  3
1  2  3  0  2

    0   1  2   3
0   0  10  0  30
1  20  30  0  20
''''

6. zip()

功能

zip()是Python的一个内建函数，它接受一系列可迭代的对象作为参数，将对象中对应的元素打包成一个个tuple（元组），然后返回由这些tuples组成的list（列表）。若传入参数的长度不等，则返回list的长度等于参数中长度最短的对象的长度

zip([iterable,…]) zip( * zipped)

print([_ for _ in zipped])    # [(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]
a,b = zip(*zip(range(5), range(6,10)))
>>>(0, 1, 2, 3)
>>>(6, 7, 8, 9)
res = zip(*[(0,1),(1,2),(2,3),(3,4)])
for i in res:
    print(list(i))
>>> [0, 1, 2, 3]
>>> [1, 2, 3, 4]

7. all()

功能

用于判断给定的可迭代参数中所有元素是否为True。
元素除了0、None、False、空外，都是True。
等价于

def all(iterable):
    for elem in iterable:
        if not elem:
            return False
    return True

all(iterable)

如果iterable的所有元素不为0、’’、False或者iterable为空，all(iterable)返回True，否则返回False；

>>> all(['a', 'b', 'c', 'd'])  # 列表list，元素都不为空或0
True
>>> all(['a', 'b', '', 'd'])   # 列表list，存在一个为空的元素
False
>>> all([0, 1，2, 3])          # 列表list，存在一个为0的元素
False

>>> all(('a', 'b', 'c', 'd'))  # 元组tuple，元素都不为空或0
True
>>> all(('a', 'b', '', 'd'))   # 元组tuple，存在一个为空的元素
False
>>> all((0, 1, 2, 3))          # 元组tuple，存在一个为0的元素
False

>>> all([])             # 空列表
True
>>> all(())             # 空元组
True

8. sort()和sorted()

sort()描述

sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。

语法

sort() 方法语法：
list.sort( key=None, reverse=False)

参数

  • key — 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
  • reverse — 排序规则，reverse = True 降序， reverse = False 升序（默认）。

    返回值

    该方法没有返回值，但是会对列表的对象进行排序。

    sorted()描述

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

    sort 与 sorted 区别： sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。 list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

语法

sorted 语法：
sorted(iterable, key=None, reverse=False)
参数说明：

  • iterable — 可迭代对象。
  • key — 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
  • reverse — 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

    返回值

    返回重新排序的列表。 ```python alist = [{“name”: “a”, “age”: 20}, {
    "name": "b", "age": 30}, {"name": "c", "age": 25}]
    alist.sort(key=lambda it: it[‘age’], reverse=True)

    [{‘name’: ‘b’, ‘age’: 30}, {‘name’: ‘c’, ‘age’: 25}, {‘name’: ‘a’, ‘age’: 20}]
    alist = sorted(alist, key=lambda it: it[‘age’]) [{‘name’: ‘a’, ‘age’: 20}, {‘name’: ‘c’, ‘age’: 25}, {‘name’: ‘b’, ‘age’: 30}]

```