九python沉淀之路--递归全局变量局部变量作用域

Posted 2020-11-01 遥望那月

一、递归

1、递归函数，同时使用嵌套，并且是将别的函数作用于调用函数里面

例1

 1 num = [1,2,3,4,5]
 2 def add_one(i):
 3     return i+1
 4 def reduce(i):
 5     return i - 1
 6 def map_test(func,array):      #此处为重点
 7     ret = [ ]
 8     for n in array:
 9         re = func(n)
10         ret.append(re)
11     return ret
12 
13 print(map_test(add_one,num))
14 print(map_test(lambda x :x**2,num))
15 print(list(map(lambda x:x-1,num)))

1 [2, 3, 4, 5, 6]
2 [1, 4, 9, 16, 25]
3 [0, 1, 2, 3, 4]

例2

 1 ms = ‘ajfklasf‘
 2 print(list(map(lambda x :x.upper(),ms)))  #map后面可传进去的可以是列表字典集合定
 3 
 4 lis2 = [‘bjgugong‘,‘bjtiananmen‘,‘bjxiangshan‘,‘motianlun‘]
 5 def filter_test(func,array):
 6     li = []
 7     for n in array:
 8         if not func(n):
 9             li.append(n)
10     return li
11 def show_bj(ss):
12     return ss.startswith(‘bj‘)
13 
14 print(list(filter_test(show_bj,lis2)))
15 
16 li = [2,2,3,100]
17 def mult(x,y):
18     return x * y
19 def reduce_test(func,array,init=None):
20     if init is None:
21         rr = array.pop(0)
22     else:
23         rr =init
24     for i in array:
25         rr = func(rr,i)
26     return rr
27 
28 print(reduce_test(mult,li,2))
29 
30 #注：map  filter  reduce 三者的区别
31 from functools import reduce
32 print(reduce(lambda x,y:x * y,li,3))

1 [‘A‘, ‘J‘, ‘F‘, ‘K‘, ‘L‘, ‘A‘, ‘S‘, ‘F‘]
2 [‘motianlun‘]
3 2400
4 3600

递归示例

 1 name=‘地球‘
 2 def china():
 3     name = "中国"
 4     print(name)
 5     def beijing():
 6         name = "北京"
 7         print(name)
 8         def haidian():
 9             name = ‘海淀‘
10             print(name)
11         haidian()
12         print(name)
13     beijing()
14     print(name)
15 
16 print(‘*‘,name)
17 china()
18 print(‘**‘,name)

1 * 地球
2 中国
3 北京
4 海淀
5 北京
6 中国
7 ** 地球

二、函数的作用域只跟函数声明时定义的作用域有关，跟函数的调用位置无任何关系

三、全局变量与局部变量

1、全局变量：关键字global

例1、

 1 name = ‘地球‘
 2 print(name)
 3 
 4 def change_name():
 5     global name       #在函数里面的name本身是局部变量的，由于经过了global的声明，函数内部的name变成了全局变量
 6     name = ‘中国‘      #也就是说原来的作用域是函数内部，现在声明以后的作用域变成了全部
 7     print(‘change_name:‘,name)
 8 
 9 change_name()
10 print(name)

1 地球
2 change_name: 中国
3 中国

对比下面的

1 name = ‘地球‘
2 print(name)
3 
4 def change_name():
5     name = ‘中国‘
6     print(‘change_name:‘,name)
7 
8 change_name()
9 print(name)

1 地球
2 change_name: 中国
3 地球

错误示例如下

 1 name = ‘地球‘
 2 print(name)
 3 
 4 def change_name():
 5     name = ‘中国‘
 6     global name        #既然要声明，就必须放在被声明变量的上面，，如果放在下面，没意义，运行会出错
 7     print(‘change_name:‘,name)
 8 
 9 change_name()
10 print(name)

例2：局部可以读取全局变量

1 NAME = ‘地球‘
2 print(NAME)
3 
4 def change_name():
5     name = ‘中国‘     #在局部不可以对全局变量进行修改、赋值等，因为没有关键字global
6     print(‘change_name:‘,name ,NAME)  #此处在局部读取了全局变量
7 
8 change_name()

1 地球
2 change_name: 中国 地球

 

#############关于全局变量和局部变量的一些规则##############

全局变量变量名大写
局部变量变量名小写

在局部里面，优先读取局部变量；如果没有关键字global声明，局部也能读取全局变量，但是在局部无法修改全局变量
但是对于可变类型，如局部变量，可以在内部对其进行修改。即可以对内部元素进行操作

如果函数内部有global关键字，变量本质上就是全局的那个变量，也就是在局部可以对其读取，也可以对其进行修改。

2、局部变量：关键字nonlocal

例1：没有关键字nonlocal的情况

 1 NAME = ‘地球‘
 2 print(‘第一次:‘,NAME)
 3 def outward():
 4     name = ‘中国‘
 5     def inward():
 6         name1 = ‘北京‘    #此处是关键，注意细节
 7         print(‘inward:‘,name1)
 8     inward()
 9     print(name)
10 
11 outward()

1 第一次: 地球
2 inward: 北京
3 中国

例2：有nonlocal的情况

 1 NAME = ‘地球‘
 2 print(‘第一次:‘,NAME)
 3 def outward():
 4     name = ‘中国‘
 5     def inward():
 6         nonlocal name  #nonlocal可以作用到上一层，但是，如果只有一层函数，那么nonlocal不能作用到最外层
 7         name = ‘北京‘                                    #下面还有一个例子
 8         print(‘inward:‘,name)
 9     inward()
10     print(‘outward:‘,name)
11 
12 outward()

1 第一次: 地球
2 inward: 北京
3 outward: 北京

例3：错误示例

1 name = ‘地球‘
2 print(‘第一次:‘,name)
3 def outward():
4     nonlocal name   #报错。nonlocal不能作用到全局变量的作用域，它只能在局部向上次一层作用
5     name = ‘中国‘
6     print(name)
7 
8 outward()