python學習手冊17 作用域

點選(此處)折疊或打開

1. #!/usr/bin/env python
2. #-*- coding:utf8 -*-
3. #python對變量的操作都是在命名空間中（作用域），變量名被指派的位置決定了這個變量名能被通路到的範圍。
4. #變量指派的地方決定了命名空間，即語義作用域。
5. #一個函數所有變量名都與函數的命名空間相關。
6. '''
7. def内定義的變量名隻能在def内使用。
8. def内外的變量名不沖突。
9. 變量對應的作用域： 作用于可以防止程式變量名沖突。
10.     def内指派就是def内。
11.     嵌套def，對于嵌套函數是非本地。
12.     def外指派，是全局的。
14. X=99#全局變量
15. def func():
16.     X=88 #函數本地變量
17. #函數定義了本地作用哉，子產品定義了全局作用域。
19. 内嵌的子產品是全局作用域。
20. 全局作用域的範圍僅限單個檔案。（全局是相對一個子產品或檔案而言。）
21. 每次對函數的調用都建立了一個新的本地作用域。
22. 指派的變量名除非聲明為全局變量或本地變量，否則均為本地變量。
23. 所有其它的變量名都可以歸納為本地、全局、或都内置的。
24. 此外，原處改變對象并不會把變量劃分為本地變量，隻有對變量名指派才可以。即修改一個對象并不是對一個名稱指派。
26. print('變量名解析：LEGB原則')
28. 變量名按：本地（L）->上層函數（E）->全局（G）->内置（B）的順序查找
29. 預設變量名指派會建立或改變本地變量。（指派總是建立或改變變量名，除非聲明過類型。）
30. 全局聲明與非本地聲明将指派變量名映射到子產品内部的作用域。
32. #全局變量
33. X=99 #X與func在本子產品中是：全局變量
34. def func(Y): #Y與Z在函數中是本地變量
35.     #本地變量
36.     Z=X+Y #X是全局變量
37.     return Z
38. print(func(1))
39. #内置作用域 __builtin__ 内置子產品
40. #import __builtin__
41. #print(dir(__builtin__))
42. #global語句
44. 全局變量是位于子產品檔案内部頂層的變量
45. 全局變量在函數内必須經過聲明
46. 全局變量在函數内不用聲明可以引用
48. X=88 #全局變量
50.     global X #全局變量聲明
51.     X=99
52.     return X
53. print(func())
54. print(X)
55. a,b=1,2
56. def all_global():
57.     global x
58.     x=a+b
59.     print(x)
60. all_global()
61. print(x)
62. #最小化全局變量
63. #原因是：流程控制比較難，儲存狀态資訊過于複雜。
64. #最小化檔案間的修改
65. #隐性的跨檔案依賴性，在最好的情況下會導緻代碼不靈活，最壞的情況會引發bug。
66. import t17mod
67. t17mod.test()
68. #這個例子表明全局變量與子產品的屬性是等效的。但比global要多寫許多語句。
70. 作用域和嵌套函數
72. #按照LEGB法測，如果嵌套函數将一個變量聲明為全局變量，它将改變整個子產品作用域。如果我們隻想想必被嵌套函數同為此變量名的變量的作用域，可以使用nonlocal聲明，指派會修改最近的嵌套函數中的變量的作用域
73. print('作用域和嵌套函數')
74. TT=99 #全局作用
75. def f1():
76.     TT=88 #本地作用
77.     def f2(): #f2是f1函數的本地變量
78.         print(TT) #根據LEGB法則，X=88
79.     f2()
80. f1()
81. #工廠函數，一個能記住嵌套作用域的變量值的函數，雖然有可能那個作用域已經不存在了。但類是最适合做記憶狀态的。
82. #本地作用域中N被作為執行的狀态資訊保留下來。
83. def maker(N):
84.     def action(M):
85.         return N*M
86.     return action
87. f = maker(5) #N=5
88. print(f(2)) #M=2,N是被記憶的為5
89. #新建立的函數不影響原來的
90. g=maker(9)
91. print(g(2))
92. print(f(2))
94. 盡量避免在def中内嵌套def。隻要第二個函數定義在第一個函數調用前就可行。
95. 如此可以避免使用嵌套
98.     x=100
99.     f2(x)
100. def f2(x):
104. 嵌套作用域和lambda
105.     lambda是一個表達式，但類似def，會生成新的作用域，可以使用在def不能使用的地方，如一個清單或是字典中
107. def func(N):
108.     action=(lambda M : N ** M)
110. A=func(5)
111. print(A(2))
112. print(func(5)(3))
114. 作用域與帶有循環變量的預設參數相比較
115.     lambda或def函數在一個函數中定義，嵌套在一個循環中，并引用了上層函數的一個變量，變量在循環中被改變，但lambda或def函數最後值是最後一次循環後的值，不會受其它循環值影響
117. def makeAction():
118.     acts = []
119.     for i in range(5):
120.         acts.append(lambda n : i ** n )
121.     return acts
122. actss=makeAction()
123. print(actss[2](2))
124. #是以必須把嵌套函數的值傳遞給嵌套作用域的變量
125. def makeAction2():
128.         acts.append(lambda n, i=i: i ** n)
130. actsss=makeAction2()
131. print(actsss[3](2))
132. #actsss[i]i最大不能超過range(5)的最大值。
133. print(actsss[4](2))
135. 作用域可以被任意嵌套，但是隻有内嵌的函數會被搜尋。
136.     在python中，平坦優于嵌套。
139. nonlocal允許對嵌套函數作用域中的名稱指派，并且把這樣的名稱作用域查找限制在嵌套def.
141. def tester(start):
142.     state=start
143.     def nester(label):
144.         #預設不允許修改嵌套的def作用域中的名稱。
145.         #state +=1 #UnboundLocalError: local variable 'state' referenced before assignment
146.         #python3.0中使用nonlocal修改,前提是nonlocal的變量在上層函數中已經指派過。
147.         #nonlocal隻在上層函數的作用域中查找變量，不會去其它作用域查找。
148.         #nonlocal state
149.         #nonlocal nostate #SyntaxError: no binding for nonlocal 'nostate' found
150.         print(label,state)
151.         #state +=50
152.     return nester
153. F=tester(100)
154. F(111) #111 100
155. F(112) #112 150
156. #如果建立一個新的副本，不會影響原來的state
157. G=tester(10)
158. G('egg') #egg 10
159. G('egg2') #egg2 60
160. F('old') #old 200
161. states2 = 9
162. def tester2(start):
163.     def nester2(lable):
164.         global states2
165.         states2 = 99
166.         print(lable,states2)
167.     return nester2
168. H=tester2(1000)
169. H('new') #new 99
170. #nonlocal語句允許在内在保持可變狀态的多個副本，并且解決了在類無法保證的情況下的簡單的狀态保持。
171. #下面使用類實作存狀态保持。
172. class ctest:
173.     def __init__(self,A):
174.         self.state = A
175.     def funcA(self,label):
176.         print(label,self.state)
177.         self.state +=1
178. CL=ctest(88)
179. CL.funcA('egg') #('egg', 88)
180. CL.funcA('egg2') #('egg2', 89)
181. print(CL.state) #90
182. #使用__call__運算符重載工具擷取一個執行個體上的直接調用
183. class ct:
186.     def __call__(self,label):
188.         self.state +=11
189. CL1=ct(77)
190. CL1('python') #('python', 77)
191. CL1('ADD11') #('ADD11', 88)
192. #下面這個沒搞通，再研究了。
194. def Z(start):
195.     def Y(lable):
196.     print(lable,Y.state)
197.     Y.state += 1
198.     Y.state = start
199.     return Y
200. X=Z(188)
201. X('egg')
204. 全局、非本地、類、函數屬性都提供了狀态保持選項。
205. 全局隻支援共享資料，類要用OOP知識，類和函數屬性都允許嵌套自身之外通路狀态。最好的工具取決于程式的目的。

t17mod.py

點選(此處)折疊或打開

1. #!/usr/bin/env python
2. #coding:utf8
3. var=99 #全局變量=子產品屬性
4. def local():
5.     var = 0 #本地變量，不影響
6. def glob1():
7.     global var #全局變量
8.     var +=1 #修改全局var=100
9. def glob2():
10.     var =0
11.     import t17mod #導入子產品，變成子產品屬性
12.     t17mod.var +=1
13. def glob3():
14.     var = 0
15.     import sys
16.     glob = sys.modules['t17mod'] #對子產品屬性生新指派
17.     glob.var +=1
18. def test():
19.     print(var)
20.     local();glob1();glob2();glob3() #按照執行順序，第一個函數不影響全局變量

結果

1. /usr/bin/python2.7 /home/talen/PycharmProjects/untitled/t17.py
2. 變量名解析：LEGB原則
3. 100
4. 99
6. 3
9. 102
11. 88
12. 10
13. 18
16. 25
17. 125
18. 16
19. 9
21. (111, 100)
22. (112, 100)
23. ('egg', 10)
24. ('egg2', 10)
25. ('old', 100)
26. ('new', 99)
27. ('egg', 88)
28. ('egg2', 89)
29. 90
30. ('python', 77)
31. ('ADD11', 88)
32. Process finished with exit code 0