高阶函数

---

map( )

map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。（Iterator是一个可迭代对象）

再简单点说：从可迭代对象中取出第一个值，作为参数传递给x，执行函数体，作为生成对象中第一个数据，之后再第二个、第三个。。。

map(）：最终返回一个可迭代对象（可迭代对象不是列表）

可迭代对象：可以通过for循环迭代出来的

例：

>>> def f(x):
... return x * x
...
>>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])   
>>> list(r)    #相当于list([...]) ===>print(list([...]))
[1, 4, 9, 16, 25, 36, 49, 64, 81]

map(函数本身，数据)：由于结果r是Iterator惰性序列（仅仅在迭代至某个元素时才计算该元素，而在这之前或之后，元素可以不存在或者被销毁。），所以用list（）函数让把整个序列都计算出来并返回一个list

或者例二：

a = map(lambda x : x*x,[1,2,3,4])
print(a)    #打印map()的返回
for i in a:   #for遍历可迭代对象
    print(i)



结果：
<map object at 0x000001EA7316BEB0>   #可迭代对象的地址
1
4
9
16

扩展例三：

b = map(lambda x,y:x+y,[1,2,3,4],[5,6,7,8])
for i in b:
    print(i)

b = map(lambda x,y:x+y,[1,2,3,4],(5,6,7,8))  #证明元组也可以
for i in b:
    print(i)

b = map(lambda x,y:x+y,(1,2,3,4),(5,6,7,8))  #元组也属于可迭代对象
for i in b:
    print(i)

#依次传入x = 1,y = 5,x+y=6   x = 2,y = 6,x+y=8

结果：
6
8
10
12
6
8
10
12
6
8
10
12
# map(将来可以被调用的，可迭代数据)

事实上它把运算规则抽象了
map()可以计算复杂的函数

例:
#将所有list里边的元素转换为字符
print(list(map(str,[1,2,3,4,5])))


结果：
['1', '2', '3', '4', '5']

filter( )

过滤序列：
和map()类似，filter()也接收一个函数和一个序列。和map()不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。

例：
def is_odd(s):
    return n%2==1

list(filter(is_odd,[1,2,3,4,5,6]))


结果：
>>>1,3,5

或者：

a = filter(lambda x: x % 2, [1, 2, 3, 4])
for i in a:
    print(i)


结果；
1
3

reduce( )

reduce把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算

即：以上一次执行的结果座位下一次x的值传入，如果指定了额外值，则第一次会将额外值作为x传入

注：使用前必须导入 from functools import reduce，因为方法是在这个模块里的

例：
from functools import reduce

a = reduce(lambda x, y: x + y, [1, 2, 3, 4, 5])
print(a)

#计算过程：x = 1, y = 2,x+y = 3(将这个3传入下一个x)
#     即：x = 3, y = 3(列表里的3)，x+y = 6(将这个6传入下一个x)
#     即：x = 6, y = 4(列表里的4)，x+y = 10(将这个10传入下一个x)
#...


b = reduce(lambda x, y: x + y, [1, 2, 3, 4, 5], 6)
print(b)
#计算过程：x = 6(额外值先传入), y = 1,x+y = 7(将这个7传入下一个x)
#     即：x = 7, y = 2(列表里的2)，x+y = 9(将这个9传入下一个x)
#     即：x = 9, y = 3(列表里的3)，x+y = 12(将这个12传入下一个x)
#...



结果：
15
21

 即：

from functools import reduce
reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

>>> from functools import reduce
>>> def add(x, y):
... return x + y
...
>>> reduce(add, [1, 3, 5, 7, 9])
25

模块

模块：

一般而言，在python中，xxxx.py文件就是一个模块

一个模块一般只用来存贮和管理一类功能的一个文件

包

包：文件夹，用来管理和存放模块的，将功能相关的模块放在一个文件夹
注意：普通文件夹可以称为一个包，但是真正的包，存在__init__.py文件

导包

导包方法：

1. import model_name（包名）
2. import model_name（包名） as  别名（自己起）
3. import model_name（包名） import   方法（前面那个包里的方法）
4. from model_name（包名） import  *

举例1：

import random  #导入random包

a =random.random()   #作用：获取一个[0-1)的随机数
print(a)


结果：
0.08402123649462256

举例2：

import random as r

# random.random()   #嫌每次使用random太麻烦，使用别名
a = r.random()
print(a)


结果：
0.6053232042710952

举例3：

from random import random   #只能使用random包里的random方法
a = r.random()
print(a)


结果：
0.1067221247244563

举例4：

from random import *   #可以使用random包里所有方法
a = random()           #并且调用不需要加包名，直接写方法
print(a)


结果：
0.8487887772496069

from model_name（包名） import  *  的缺点：

1. 导的包太多，浪费资源
2. 如果包里没有__init__  与 __all__，就无法成功导入

扩展：

如何查看包里面内容？

按住ctrl并且点击包名

如下图：

进入后会另打一个xxx.py文件

里面会有__init__  与 __all__

__all__就是为了让你 * 出所有方法