python基础复习10

  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  # 注:本文是根据老男孩课程内容整理而成的,本文仅供个人笔记使用,如果有侵犯,请联系我,我立即撤销。

 

posted @ 2019-01-02 09:23  牧羊世界  阅读(173)  评论(0编辑  收藏  举报