1 # 函数进阶
2 """
3 命名空间和作用域
4
5 *内置命名空间 -----python解释器
6 # 就是Python解释器一启动就可以使用的名字存储在内置命名空间中
7 内置的名字在启动解释器的时候被加载进内存里
8
9 *全局命名空间 -----我们写的代码，但不是函数中的代码
10 # 是在程序从上到下被执行的过程中依次加载进内存的
11 放置了我们设置的所有变量名和函数名
12
13 *局部命名空间 ----函数
14 # 就是函数内部定义的名字
15 当调用函数的时候，才会产生这个命名空间 随着函数执行的结束 这个命名空间就有消失了
16
17 在局部：可以使用全局、内置命名空间中的名字
18 在全局：可以使用内置命名空间中的名字，但不能使用局部的命名空间
19
20 在内置： 不可以使用全局、局部的命名空间
21
22 可以这样想像：内置就是一个大盒子，它包含了全局，全局又是一个中盒子，它包含了局部这个小盒子
23 局部找不到可以向上（全局）中找，没有还可以再向上（内置）中找，但不能向下去找
24
25 依赖倒置原则
26 """
27
28 # 作用域 两种
29 # 全局作用域 --作用在全局 -- 内置和全局名字空间中的名字都属于全局作用域
30
31 # 局部作用域 -- 作用在局部 -- 函数
32
33 # 例子：
34
35 # a = 1
36 # def func():
37 # global a
38 # a += 1
39 #
40 # func()
41 # print(a)
42 # 局部变量不能修改全局变量
43 # 如果想要修改，需要在程序的一开始添加global声明
44
45
46 # def max1(a,b):
47 # return a if a > b else b
48
49 # def the_max(x,y,z): # 函数的嵌套调用
50 # c = max(x,y)
51 # return max(c,z)
52 #
53 # print(the_max(3,5,3))
54
55
56
57 # def outer():
58 # a = 1
59 # def inner():
60 # print(a)
61 # print("inner")
62 #
63 # def inner2():
64 # print(a)
65 # print('inner2')
66 # inner2()
67 # inner()
68 #
69 # outer()
70
71
72
73
74 # 闭包：嵌套函数，内部函数调用外部函数的变量
75 # def outer():
76 # a = 1
77 # def inner():
78 # print(a)
79 # print(inner.__closure__) # 返回值里有cell 就是闭包函数
80 #
81 # outer()
82
83
84
85
86 # def outer():
87 # a = 1
88 # def inner():
89 # print(a)
90 # return inner
91 #
92 # inn = outer() # 先看outer 先调用 然后执行outer这个函数，会有返回值inner，然后用inn去接收它
93 # inn()
94
95
96
97 # def qqxing(l = []):
98 # l.append(1)
99 # print(l)
100 #
101 # qqxing()
102 # qqxing()
103 # qqxing()
104
105
106 # 练习题
107 # 写函数，接收n个数字，求这些参数数字的和。
108 # def sum_func(*args):
109 # total = 0
110 # for i in args:
111 # total += i
112 # return total
113 # print(sum_func(1,2,4,6,3,1225))
114
115 # 读代码，回答，代码中，打印出来的值a,b,c 分别是什么？为什么？
116 # a = 10
117 # b = 20
118 # def test5(a,b):
119 # print(a,b)
120 # c = test5(b,a)
121 # print(c) a = 20 b = 10 c = None(因为没有返回值)
122
123 # 读代码，回答，代码中，打印出来的值a,b,c 分别是什么？为什么？
124 # a = 10
125 # b = 20
126 # def test5(a,b):
127 # a = 3
128 # b = 5
129 # print(a,b)
130 # c = test5(b,a)
131 # print(c)
132
133 # 写函数，检查获取传入列表或元祖对象的所有奇数位索引对应的元素，
134 # 将其作为新的列表返回给调用者。
135
136 # def func(l):
137 # return l[1::2]
138 # a = func([1,2,3,4,5,6,7,8,9])
139 # print(a)
140
141 # 写函数，判断用户传入的对象（字符串、列表、元祖）长度是否大于5。
142
143 # def func(l):
144 # return len(l) > 5
145 # print(func("123455"))
146
147 # 写函数，检查传入列表的长度，如果大于2，
148 # 那么仅保留前两个长度的内容，并将新内容返回给调用者。
149
150 # def func(l):
151 # return l[:2] #if len(l) > 2: 切片 ：你切的长度列表中没有，它是不会报错的，所以不用判断
152 # print(func([1,2,3,4,5]))
153
154 # 写函数，计算传入字符串中[数字]、[字母]、[空格]、[其他]的个数，并返回结果。
155 # def func(s):
156 # num = 0 #计算数字的个数
157 # space = 0 # 空格
158 # alpha = 0 # 字母
159 # other = 0 # 其它
160 # dic = {'num': 0,'alpha': 0,'space': 0,'other': 0}
161 # for i in s:
162 # if i.isdigit():
163 # dic['num'] += 1
164 # elif i.isalpha():
165 # dic['alpha'] += 1
166 # elif i.isspace():
167 # dic['space'] += 1
168 # else:
169 # dic['other'] += 1
170 # return dic
171 # print(func("qa12wedc f efdc32ec+++"))
172
173
174 # 写函数，检查传入字典的每一个value的长度，如果大于2，
175 # 那么仅保留前两个长度的内容，并将新内容返回给调用者。
176 # dic = {'k1':'v1v2', 'k2':[11,22,33,44]}
177 # PS:字典中的value只能是字符串或列表
178
179 # def func(dic):
180 # for k in dic:
181 # if len(dic[k]) > 2:
182 # dic[k] = dic[k][:2]
183 # return dic
184 # dic = {'k1':'v1v2', 'k2':[11,22,33,44]}
185 # print(func(dic))
186
187
188
189 # 写函数，接收两个数字参数，返回比较大的那个数字。
190 # def func(a,b):
191 # if a > b:
192 # return a
193 # else:
194 # return b
195 # print(func(3,5))
196
197
198
199 # 三元运算
200 # a = 1
201 # b = 5
202 # c = a if a > b else b # 三元运算
203 # print(c)
204
205 # def func(a,b):
206 # return a if a > b else b
207 # print(func(3,6))
208
209
210
211 # import time
212 # def func():
213 # start = time.time() # 获取当前时间
214 # print('good moring')
215 # time.sleep(2)
216 # end = time.time()
217 # return end - start
218 #
219 # print(func())
220
221
222
223 # 装饰器
224 # import time
225 # def func():
226 # time.sleep(0.01)
227 # print('good moring')
228 #
229 # def timmer(f): # 装饰器函数
230 # def inner():
231 # start = time.time()
232 # f() # 被装饰的函数
233 # end = time.time()
234 # print(end - start)
235 # return inner
236 # func = timmer(func) -----> 这句话相当于语法糖 @timmer
237 # func()
238 # 不想修改函数的调用方式，但是还想在原来的函数前后添加功能
239 # timmer就是一个装饰器函数，只是对一个函数 有一些装饰作用
240
241
242
243 # 装饰器的最终形成和固定格式
244 # import time
245 # def timmer(f):
246 # def inner():
247 # start = time.time()
248 # f()
249 # end = time.time()
250 # print(end - start)
251 # return inner
252
253 # @timmer # 语法糖 在被装饰的函数上面加上@装饰器的名字(必须紧挨着)
254 # def func(): # 被装饰的函数
255 # time.sleep(0.01)
256 # print('Happy New Year!')
257 #
258 # # func = timmer(func)
259 # func()
260
261
262
263 # 带返回值的装饰器函数
264 # import time
265 # def timmer(f):
266 # def inner():
267 # start = time.time()
268 # ret = f()
269 # end = time.time()
270 # print(end - start)
271 # return ret
272 # return inner
273 #
274 # @timmer
275 # def func():
276 # time.sleep(0.01)
277 # print('Happy New Year!')
278 # return '新年好！'
279 #
280 # ret = func()
281 # print(ret)
282
283
284
285 # 带参数的装饰器函数
286 # import time
287 # def timmer(f):
288 # def inner(*args,**kwargs):
289 # start = time.time()
290 # ret = f(*args,**kwargs)
291 # end = time.time()
292 # print(end - start)
293 # return ret
294 # return inner
295 #
296 # @timmer
297 # def func():
298 # time.sleep(0.01)
299 # print('Happy New Year!')
300 # return '新年好！'
301 #
302 # ret = func()
303 # print(ret)
304
305
306
307 # import time
308 # def wrapper(f):
309 # def inner(*args,**kwargs):
310 # """再被装饰的函数之前要做的事"""
311 # ret = f(*args,**kwargs)
312 # """在被装饰的函数之后要做的事"""
313 # return ret
314 # return inner
315 #
316 # @wrapper
317 # def func():
318 # time.sleep(0.01)
319 # print('Happy New Year!')
320 # return '新年好！'
321
322
323
324 # 装饰器的固定模式
325 # def wrapper(func):
326 # def inner(*args,**kwargs):
327 # ret = func(*args,**kwargs)
328 # return ret
329 # return inner
330 #
331 # @wrapper
332 # def qqxing():
333 # print(1225)
334 #
335 # ret = qqxing()
336 # print(ret)
337
338 # 注：本文是根据老男孩课程内容整理而成的，本文仅供个人笔记使用，如果有侵犯，请联系我，我立即撤销。
