Python中的变量作用域,这个主题来源于最近一个实际的需求,对于任意深度的字典进行解析。
初步一看,这个问题很明了,递归解析,直到最后一层结束。实际也确实是这么做的,但是在实现上却遇到了一些问题,所以正好就函数变量的作用域谈一下自己的理解,顺便再学习一下闭包。
问题引入
我们的问题是这样的,有两个家庭,一对异性恋TOM和JANE组成的家庭和一只单身狗DOG一个人组成的家庭。他们都有姓名和年龄的属性,现在我们需要对于他们的年龄和姓名进行解析。故事的主人公们长这样:
to_be_parsed_dict = {
"Couple": {
"Husband": {"name": "Tom", "age": 15},
"Wife": {"name": "Jane", "age": 43}
},
"Single": {"name": "Dog", "age": 34}
}
任意深度的字典的解析
- 第一个需求:解析这两个家庭的所有人的姓名组成列表
毫无疑问,递归,因为需求比较简单,所以就找到最后一层字典中有"name"结束即可。
def get_name(src_dict, result_list):
for key in src_dict:
if src_dict.__contains__("name"):
result_list.append(src_dict["name"])
break
else:
get_name(src_dict[key], result_list)
return result_list
解析一下故事的主人公们,得到了三位主角的名字,emmmm,一切看起来不错。
>>> result_list = []
>>> get_name(to_be_parsed_dict, result_list)
['Tom', 'Jane', 'Dog']
- 第二个需求:看一下这两个家庭的人加起来超没超过100岁
看起来和第一个需求完全一样,那我们直接重复一下代码,毕竟实现的时候copy yourself是最爽的(您的好友“维护”已经加入游戏)。
def get_age(src_dict, total_age):
for key in src_dict:
if src_dict.__contains__("age"):
total_age += src_dict["age"]
break
else:
get_age(src_dict[key], total_age)
return total_age
完全一样的思路,代码都几乎一样,应该可以安心拍胸脯了,作为一个负责的码农,还是假装测试一下吧。
>>> total_age = 0
>>> get_age(to_be_parsed_dict, total_age)
0
emmmm,肯定不是代码出问题了,肯定是操作系统有点问题,重启试试。
结果还是一样。
为什么?
好像要谈到函数变量的作用域的理解了。
第一个需求和第二个需求其唯一的差别就在于:第一个需求传了可变类型list
,第二个需求传了不可变类型int
。问题不在于变量类型本身,而是因为我们在二个函数中用到了total_age += src_dict["age"]
,这个句法其本质是total_age = total_age + src_dict["age"]
,这就相当于在函数的内部重新分配了变量,变量的作用域变成了函数内有效,自然就无法对于函数外部作用域的变量产生任何影响了。所以结果输出的还是函数外部在定义的时候的赋值0。
而在第一个函数中,写法是result_list.append(src_dict["name"])
,并没有在函数的内部重新非配变量。如果我们在函数的内部加上result_list = []
,那么其结果显然是无法正常工作的。
为了解决这个问题,我们可以引入全局变量,更新后的代码如下:
def get_age(src_dict):
global total_age
for key in src_dict:
if src_dict.__contains__("age"):
total_age += src_dict["age"]
break
else:
get_age(src_dict[key])
return total_age
这里在命令行里面并没有跑起来,不过通过了脚本内的测试(要在这里挖坑了,也许命令行里不能定义全局变量)
闭包
既然函数的变量是有作用域的,那么函数中函数的变量的作用域又怎么说呢?
- 第三个需求:我想要将这两个家庭的人的参数解析两遍
对于姓名的解析,我们可以将第一次解析得到的列表作为参数传递函数的第二次调用,对于年龄的解析,由于是全局变量,所以直接执行两次函数即可。
但是这样的做法是不安全的,服务端对于客户端产生了依赖,这破坏了服务端的封装,比如说不小心在函数的某处改变了全局变量的值,那么重复解析两次得到的结果是不准确的。
如此,便到了闭包出场的时候,直接上代码。
def name_getter():
result_list = []
def get_name(src_dict):
for key in src_dict:
if src_dict.__contains__("name"):
result_list.append(src_dict["name"])
return result_list
else:
get_name(src_dict[key])
return result_list
return get_name
def age_getter():
total_age = 0
def get_age(src_dict):
nonlocal total_age
for key in src_dict:
if src_dict.__contains__("age"):
total_age += src_dict["age"]
break
else:
get_age(src_dict[key])
return total_age
return get_age
这两个函数的核心是在实际的执行函数层外包了一层函数,用来维持数据的状态。
需要特别注意age_getter
中nonlocal total_age
这个声明,如同在第二个需求中讨论的,为了避免get_age
函数中重新声明变量造成外部声明的变量失效,需要用nonlocal
关键字来声明。相对于gobal
声明来说,有效控制了变量名的有效范围,是有助于保持数据不被污染的。
这两个函数的实际执行像这样。
>>> re_get_name = name_getter()
>>> re_get_name(to_be_parsed_dict)
['Tom', 'Jane', 'Dog']
>>> re_get_name(to_be_parsed_dict)
['Tom', 'Jane', 'Dog', 'Tom', 'Jane', 'Dog']
>>> re_get_age = age_getter()
>>> re_get_age(to_be_parsed_dict)
92
>>> re_get_age(to_be_parsed_dict)
184
为什么函数的上次执行结果可以保存。
一方面,因为外层函数返回的是内层函数,变量的初始化在外层函数的初始化过程中完成,以后每次调用外层函数,实质是调用了内层函数,所以类似totoal_age=0
的赋值只会被执行一次,不会被覆盖。
另一方面,外层函数一直存在(一个python对象),所以数据可以保持。
- 对于闭包的一点理解
从目前我写的代码的角度来看,闭包并不是非常有用的特性,所以对于概念本身也谈不上特别熟悉,但我认为闭包从本质来说还是函数变量作用域的问题。
从功能的角度来看。
第一点,闭包有效的减少了参数的数量,在实现第三个需求的时候,实际看到的只需要传递一个参数就可以实现解析了。
第二点,闭包可以维持内部状态,这也是为什么可以连续解析两次的原因。
从形式的角度来看。
这个写法非常非常像装饰器的写法,二者之间必然存在联系。不过现在我也说不出来联系在哪里。
从实用的角度来看。
这个找了资料,原文在这里 Python深入04 闭包
闭包有效的减少了函数所需定义的参数数目。这对于并行运算来说有重要的意义。在并行运算的环境下,我们可以让每台电脑负责一个函数,然后将一台电脑的输出和下一台电脑的输入串联起来。最终,我们像流水线一样工作,从串联的电脑集群一端输入数据,从另一端输出数据。这样的情境最适合只有一个参数输入的函数。闭包就可以实现这一目的。
并行运算正称为一个热点。这也是函数式编程又热起来的一个重要原因。函数式编程早在1950年代就已经存在,但应用并不广泛。然而,我们上面描述的流水线式的工作并行集群过程,正适合函数式编程。由于函数式编程这一天然优势,越来越多的语言也开始加入对函数式编程范式的支持。
网友评论