Python全栈开发【第十篇】：函数式编程与内置函数

作用域

作用域在定义函数时就已经固定住了，不会随着调用位置的改变而改变

例一：
name='alex'

def foo():
    name='lhf'
    def bar():
        print(name)
    return bar

func=foo()
func()


例二：
name='alex'

def foo():
    name='lhf'
    def bar():
        name='wupeiqi'
        def tt():
            print(name)
        return tt
    return bar

func=foo()
func()()

匿名函数

匿名函数就是不需要显式的指定函数，格式如下：lambda 形参名：处理逻辑
（形参可以多个）

#这段代码
def calc(n):
    return n**n
print(calc(10))
 
#换成匿名函数
calc = lambda n:n**n
print(calc(10))

函数式编程

程序编程方式：面向过程、函数式编程、面向对象。

满足两个特性任意一个即为高阶函数：
1、函数的传入参数是一个函数名；
2、函数的返回值是一个函数名

内置函数：

map函数

描述

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

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

语法

map() 函数语法：

map(function, iterable, ...)

参数

• function – 函数
• iterable – 一个或多个序列

返回值

返回迭代器

实例

def add_one(x):
    '''
    x+1
    :param x:
    :return:
    '''
    return x+1

num=[1,3,5,6,7,12]
def map_test(func,array):
    set=[]
    for i in array:
        res = add_one(i)
        set.append(res)
    return set
print("匿名函数：",map_test(lambda x:x+1,num))
print("高阶函数：",map_test(add_one,num))
print("高阶函数、map()函数：",list(map(add_one,num)))

filter()函数

描述

filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。

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

语法

filter() 方法的语法:

filter(function, iterable)

参数

• function – 判断函数。
• iterable – 可迭代对象。

返回值

返回一个迭代器对象

实例

过滤出列表中的所有奇数：

def is_odd(n):
    """
    判断是否奇数
    :param n:
    :return:
    """
    return n % 2 == 1

tmplist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
newlist = list(tmplist)
print(newlist)

过滤出1~100中平方根是整数的数：

import math
def is_sqr(x):
    return math.sqrt(x) % 1 == 0
 
tmplist = filter(is_sqr, range(1, 101))
newlist = list(tmplist)
print(newlist)

reduce() 函数

描述

reduce() 函数会对参数序列中元素进行累积。

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

语法

reduce() 函数语法：

reduce(function, iterable[, initializer])

参数

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

返回值

返回函数计算结果

实例

from functools import reduce
list = [1,3,4,5,8]

def add(x,y):
    """
    两数相加
    :param x:
    :param y:
    :return:
    """
    return x + y
print(reduce(add,list))   # 计算列表和：1+2+3+4+5
print("lambda匿名函数：",reduce(lambda x,y:x+y,list))

zip() 函数

描述

zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。

我们可以使用 list() 转换来输出列表。

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

语法

zip([iterable, ...])

• iterabl – 一个或多个迭代器;

返回值

返回一个对象

实例

>>>a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b)     # 返回一个对象
>>> zipped
<zip object at 0x103abc288>
>>> list(zipped)  # list() 转换为列表
[(1, 4), (2, 5), (3, 6)]
>>> list(zip(a,c))              # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
 
>>> a1, a2 = zip(*zip(a,b))          # 与 zip 相反，zip(*) 可理解为解压，返回二维矩阵式
>>> list(a1)
[1, 2, 3]
>>> list(a2)
[4, 5, 6]

max() 函数

字典的运算：最小值，最大值，排序
salaries={
    'egon':3000,
    'alex':100000000,
    'wupeiqi':10000,
    'yuanhao':2000
}

迭代字典，取得是key，因而比较的是key的最大和最小值
>>> max(salaries)
'yuanhao'
>>> min(salaries)
'alex'

可以取values，来比较
>>> max(salaries.values())
100000000
>>> min(salaries.values())
2000
但通常我们都是想取出，工资最高的那个人名，即比较的是salaries的值，得到的是键
>>> max(salaries,key=lambda k:salary[k])
'alex'
>>> min(salaries,key=lambda k:salary[k])
'yuanhao'