python课整理 2021.10.11

reduce

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

语法

reduce(function, iterable[, initializer])

• function – 函数，有两个参数

• iterable – 可迭代对象

• initializer – 可选，初始参数

• 返回值：返回函数计算结果

实例

from functools import reduce
def add(x, y):  #两数相加
    return x + y
sum1 = reduce(add, [1,2,3,4,5]) #计算列表和
sum2 = reduce(lambda x,y:x + y, [1,2,3,4,5]) #使用lambda匿名函数
print(sum1)
print(sum2)

输出

15
15

解释一下过程，reduce是首先把前两个元素传给函数参数，函数加工后，然后把得到的结果和第三个元素作为两个参数传到函数参数，函数进行加工后又会和第四个元素作为两个参数传给函数参数，依次类推，经过这样的累计计算之后合并序列到一个单一返回值。这样我们就可以省略写for、while循环。

如果按照老师的想法，想要计算某一个部分的和，我可能会趋向于先切片再计算

filter

filter()函数是用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素的组成的新迭代器对象（对于python3.X来说）。

本质上来说，我觉得就是一个过滤器，类似spring的过滤器

语法

filter(function, iterable)

参数

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

返回值

返回列表

实例

def is_odd(n):
    return n % 2 == 1
newlist = filter(is_odd, [1,2,3,4,5,6,7,8,9,10])
print(newlist) #可迭代对象
newlist1=[x for x in newlist] #列表解析
print(newlist1) #输出

输出

<filter object at 0x000001710E462430>
[1, 3, 5, 7, 9]

忘了之前有没有讲过列表解析，现在就说一遍，实际上列表解析就是把一个循环浓缩成一句话，使之变得更加简洁,还能优化性能

[x for x in newlist] 

• 第一个x是我们列表里的结果
• 第二个x是来源，从newlist里面遍历的数

当然还有其它形式，也有更加复杂的

例：

a=[x for x in range(51) if x%2==0]
print(a)

输出

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50]

• 第一个x是我们需要的列表里面的结果
• for x in range(51) ：x来源（表示x从0遍历到50）
• if x %2 == 0:表示x成立的条件，如果不成立就不放在列表里

还有各种各样的形式，在此就不解释了，还有除了一维，也有二维的形式，这里就不详细讲啦。

闭包（难点）

在一个函数中定义了另外一个函数，这里重点要讲下的就是函数本质上就是一个引用，它的函数头指向了一个所开辟的空间。

首先我们要了解一下函数调用的时候发生了什么。在我们以前学到的c语言中，当运行主函数时，在堆中会生成一个栈，当主函数里面调用其它函数时，它会在主函数上面压入一个栈。

但闭包不一样，如果外函数在结束的时候发现有自己的临时变量将来会在内部函数中用到，就把这个临时变量绑定给内部函数，然后自己再结束。

实例

#闭包函数的实例
# outer是外部函数 a和b都是外函数的临时变量
def outer( a ):
    b = 10
    # inner是内函数
    def inner():
        #在内函数中 用到了外函数的临时变量
        print(a+b)
    # 外函数的返回值是内函数的引用
    return inner

if __name__ == '__main__':
    # 在这里我们调用外函数传入参数5
    #此时外函数两个临时变量 a是5 b是10 ，并创建了内函数，然后把内函数的引用返回存给了demo
    # 外函数结束的时候发现内部函数将会用到自己的临时变量，这两个临时变量就不会释放，会绑定给这个内部函数
    demo = outer(5)
    # 我们调用内部函数，看一看内部函数是不是能使用外部函数的临时变量
    # demo存了外函数的返回值，也就是inner函数的引用，这里相当于执行inner函数
    demo() # 15
    demo2 = outer(7)
    demo2()#17

这个是从网上找的例子，实际上已经讲的很清晰了，就是要注意函数的引用。

在闭包问题上，笔者也不是很懂，所以尽量能够以理解的角度上讲述

老师也曾说过，闭包的概念使用在javascript上也经常用。以上例子也只是简单的构建，还希望可以多去了解装饰层，还有著名的设计模式–单例模式，这些都应用到了闭包，闭包，我觉得就是让用户能够方便调用，就是类似一种包装

然后顺便讲解一下global、nonlocal的区别

global、nonlocal区别

第一，两者的功能不同。global关键字修饰变量后标识该变量是全局变量，对该变量进行修改就是修改全局变量，而nonlocal关键字修饰变量后标识该变量是上一级函数中的局部变量，如果上一级函数中不存在该局部变量，nonlocal位置会发生错误（最上层的函数使用nonlocal修饰变量必定会报错）。

第二，两者使用的范围不同。global关键字可以用在任何地方，包括最上层函数中和嵌套函数中，即使之前未定义该变量，global修饰后也可以直接使用，而nonlocal关键字只能用于嵌套函数中，并且外层函数中定义了相应的局部变量，否则会发生错误（见第一）。

再再简单的说，就是global是全局变量，会直接提升全局作用域，这可能跟其它局部变量产生冲突，但是nonlocal只是提升一级的作用域，这样降低危险性，也不会对其它变量的影响小，你影响的只是你上一级的作用域。

以下请判断区别：以及是否会报错，报错得到原因是什么，你也可以自己运行一下

def counter():
    count = 0
    def inc():
        count += 1
        return count
    return inc #f返回函数引用
foo = count()
foo()
foo()

def counter():
    count = 0
    def inc():
        global count 
        count += 1
        return count
    return inc #f返回函数引用
foo = counter()
foo()
foo()

def counter():
    count = 0
    def inc():
        nonlocal count 
        count += 1
        return count
    return inc #f返回函数引用
foo = counter()
foo()
foo()

参考文章如下：