python学习笔记整理(二)

  2 # 迭代
  3 '''
  4 # 能够通过for循环来遍历的对象，是可迭代对象Iterable。包括两类：
  5 # 1、集合数据类型：list，tuple，dict，set，str
  6 # 2、生成器和带 yield 的generator function。
  7 
  8 # 可以使用 isinstance() 判断一个对象是否是 Iterable 对象：
  9 
 10 from collections import Iterable
 11 a = isinstance([666],Iterable)
 12 print(a) # True
 13 
 14 # 字典的迭代
 15 d = {'a':1,'b':2,'c':3}
 16 for key in d:
 17     print(key) # a b c
 18 
 19 for value in d.values():
 20     print(value) # 1 2 3
 21 
 22 for x,y in [('a',1),('b',2),('c',3)]:
 23     print(x,y)
 24 
 25 # a 1
 26 # b 2
 27 # c 3
 28 
 29 # 练习：使用迭代查找一个list中最小和最大值，并返回一个tuple：
 30 l = [2,4,3,6,9]
 31 
 32 def findMinAndMax(L):
 33   if len(L) == 0:
 34     return (None, None)
 35   
 36   minValue = L[0]
 37   maxValue = L[0]
 38 
 39   for x in L:
 40     if x < minValue:
 41       minValue = x
 42     elif x > maxValue:
 43       maxValue = x
 44   return (minValue, maxValue)
 45 
 46 
 47 print(findMinAndMax(l))
 48 
 49 # ------------------------------------------------------------------------
 50 # 生成器 generator
 51 
 52 # 需要的时候才生成数据，不要的时候不需要生成数据。这种一边循环一边计算的机制称为生成器。
 53 # 创建生成器的方法：
 54 # 1、把列表生成式的[]改成() :
 55 
 56 g = (x*x for x in range(10))
 57 # 通过next()函数获得generator的下一个返回值
 58 print(next(g)) #0
 59 print(next(g)) #1
 60 print(next(g)) #4
 61 # 生成器是可迭代对象，可用for循环取值
 62 for i in g:
 63     print(i)
 64 # 2、通过yield关键字创建generator
 65 
 66 def fib(max):
 67     n, a, b = 0, 0, 1
 68     while n < max:
 69         print(b)
 70         a, b = b, a + b  # 后面是个元组
 71         n = n + 1
 72     return 'done'
 73 fib(6) # 112358
 74 
 75 
 76 # 把上面的fib()函数print(b)改为yield(b),就变成了生成器函数。
 77 def fib(max):
 78     n, a, b = 0, 0, 1
 79     while n < max:
 80         yield b
 81         a, b = b, a + b  # 后面是个元组
 82         n = n + 1
 83     return 'done'
 84 
 85 # 每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。
 86 f = fib(6) # 调用一个生成器函数，返回的是一个迭代器对象。
 87 print(next(f)) # 1
 88 print(next(f)) # 1
 89 print(next(f)
 90 print(next(f)) # 3
 91 # 直接for遍历
 92 for i in f:
 93     print(i) # 112358
 94 
 95 
 96 
 97 练习：通过生成器用列表的形式输出杨辉三角中的每一行
 98 #  1
 99 # 1 1
100 # 121
101 # 1331
102 '''
103 
104 def tri():
105     arr = [1]
106     n=0
107     while n<=5:
108         yield arr
109         arr = [1] + [arr[i] + arr[i + 1] for i in range(len(arr) - 1)] + [1]
110         n+=1
111         
112 print(next(tri()))    # [1]
113 print(next(tri()))    # [1]
114 print(next(tri()))    # [1]
115 print(next(tri()))    # [1]
116 # 很奇怪，这里用next()函数为什么总是输出[1]
117 print(list(tri()))
118 for i in tri():
119     print(i)
120 
121 # [1]
122 # [1, 1]
123 # [1, 2, 1]
124 # [1, 3, 3, 1]
125 # [1, 4, 6, 4, 1]
126 # [1, 5, 10, 10, 5, 1]
127 
128 
129 # 生成器不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值，
130 # 直到最后抛出StopIteration错误表示无法继续返回下一个值了。
131 
132 from collections import Iterator,Iterable
133 print(isinstance(tri(),Iterator)) # True
134 print(isinstance([],Iterator)) # False
135 print(isinstance('abcd',Iterator)) # False
136 print(isinstance(iter('abcd'),Iterator)) # True
137 
138 # ------------------------------------------------------------------------
139 # send()函数
140 def test():
141     i=1
142     while i<5:
143         temp = yield i
144         print(temp)
145         i+=1
146 t=test()
147 print("-------------------------------")
148 print(next(t)) # 1
149 print(next(t)) # None 2
150 print(next(t)) # None 3
151 t.send("666") # 把值666替换程序停止的位置，即temp=666
152 
153 # print(next(t)) #  None，StopIteration
154 # 注意：send()在生成器函数创建完后在next之前就调用，此时只能传值None，否则报错；
155 
156 #  yield要配合循环使用才有意义
157 def test():
158     i=1
159     yield i
160     i+=1
161     print(i)
162 t=test()
163 print(next(t)) # 1
164 # print(next(t)) # 2 StopIteration
165 
166 
167 
168 # 总结：
169 # 1、生成器都是可迭代对象；
170 # 2、生成器都是迭代器对象；
171 # 3、凡是可作用于for循环的对象都是Iterable可迭代对象；
172 # 4、凡是可作用于 next()函数的对象都是Iterator迭代器对象；
173 # 5、list，dict，str等数据类型可通过 iter()函数变为迭代器对象；
174 
175 
176 
177 # ------------------------------------------------------------------------
178 # 循环实现阶乘
179 
180 def jie(n):
181     s=1
182     for i in range(1,n+1):
183         s = s*i
184     print(s)
185 jie(5) # 120
186 
187 #递归实现阶乘
188 def jie2(n):
189     if n==1:
190         return 1
191     else:
192         return n*jie2(n-1)
193 print(jie2(6)) # 720
194 
195 
196 # 1,1,2,3,5,8,13递归实现斐波那契数列
197 def fib(n):
198     if n==1 or n==2:
199         return 1
200     else:
201         return fib(n-1)+fib(n-2)
202 
203 print(fib(6)) # 8
204 
205 
206 # 100元买100本书，A书5/本，B书3/本，C书0.5/本，共有几种买法？
207 def exa1():
208     for i in range(21):
209         for j in range(34):
210             if 5*i+3*j+0.5*(100-i-j)== 100:
211                 print('%s,%s,%s'%(i,j,100-i-j))
212 
213 exa1()
214 # 0,20,80
215 # 5,11,84
216 # 10,2,88
217 
218 
219 # ------------------------------------------------------------------------
220 
221 # 内置函数：
222 
223 # filter(函数,可迭代对象)：根据函数返回的布尔值决定是否将可迭代对象中的元素
224 # 添加到新的列表
225 def fun1(n):
226     return n<5
227 li = [1,2,3,4,5,6,7,8,9]
228 a = filter(fun1,li)
229 print(list(a)) # [1, 2, 3, 4]
230 
231 # map(函数,可迭代对象)：对可迭代对象中的元素做处理后放到新列表
232 def fun2(n):
233     return n*n
234 a=map(fun2,li)
235 print(list(a)) #[1, 4, 9, 16, 25, 36, 49, 64, 81]
236 
237 # zip() 函数用于将可迭代的对象作为参数，
238 # 将对象中对应的元素打包成一个个元组，然后返回一个迭代器对象。
239 a = zip([1,2,3],['a','b','c'])
240 print(type(a))
241 print(isinstance(a,Iterator)) # True
242 print(isinstance(a,Iterable)) # True
243 print(list(a))
244 for i in a:
245     print(i)
246 
247 
248 def fun(x):
249     a=x
250 
251 # print(fun(3).a)
252 
253 class test(object):
254     def __init__(self):
255         num = 1
256     def haha(self):
257         print("haha")
258 
259 print(id(test))
260 print(type(test))
261 print(id(test()))
262 print(type(test()))
263 
264 
265 # python中的type和object
266 # 注意：我们通常在python中称对象为object，但是python中有个基类也叫object
267 # 这两个东西不能混淆。当然，基类object也是一个对象，即python中一切皆对象，
268 # 它是type的实例对象。type是谁呢？type继承自object这个基类，它也是一个类。
269 # 这就让人有点糊涂了，
270 
271 class nt(object):
272     print("haha")
273 
274 i = int('1')
275 
276 print(i)
277 
278 # ------------------------------------------------------------------------
279 
280 # 闭包
281 # 在函数内部再定义一个函数，并且这个函数用到了外边函数的变量，
282 # 那么将这个函数以及用到的一些变量称之为闭包
283 def fun(num1):
284      def fun_in(num2):
285          return num1+num2
286      return fun_in
287 
288 a = fun(100)
289 print(a(200)) # 300
290 print(a(1)) # 101 
291 
292 # ------------------------------------------------------------------------
293 
294 # 装饰器
295 # 假如有个需求，用户在调用登陆函数之前要验证用户信息是否正确，
296 # 验证通过后才能登陆。这用装饰器可以实现，在调用登陆函数的时候
297 # 自行调用验证函数。
298 # 
299 def check(fun):
300     ''' 验证函数 '''
301     def check_in():
302         print("正在验证用户信息。。。")
303         if True:
304             print("验证通过！")
305             return fun()
306         else:
307             print("验证失败！")
308     return check_in
309 
310 @check # 相当于: fun = check(fun)
311 def fun():
312     ''' 登陆函数 '''
313     print("正在登陆。。。")
314 
315 fun()
316 # 正在验证用户信息。。。
317 # 验证通过！
318 # 正在登陆。。。
319 
320 
321 # 注意：在调用被装饰函数之前，装饰器函数就已经执行了。
322 
323 
324 def check(fun):
325     ''' 验证函数 '''
326     print("这是一个装饰器函数！")
327     def check_in():
328         print("正在验证用户信息。。。")
329         if True:
330             print("验证通过！")
331             return fun()
332         else:
333             print("验证失败！")
334     return check_in
335 
336 @check # python解释器在执行到这里时，就会执行check(fun)，打印上面那句话
337 def fun():
338     ''' 登陆函数 '''
339     print("正在登陆。。。")
340 
341 # 结果：
342 # 这是一个装饰器函数！
343 
344 
345 
346 # 多个装饰器嵌套
347 
348 def d1(f):
349     print("==============d1===============")
350     def inner1():
351         print("------inner1-------")
352         return "<d1>" + f() + "<d1>"
353     return inner1
354 
355 
356 def d2(f):
357     print("==============d2===============")
358 
359     def inner2():
360         print("------inner2-------")
361         return "<d2>" + f() + "<d2>"
362     return inner2
363 
364 @d1 # f = d1(f)
365 @d2 # f = d2(f)
366 def f():
367     print("------3-------")
368     return 'haha'
369 
370 print(f())
371 
372 '''
373 结果是：
374 ==============d2===============
375 ==============d1===============
376 ------inner1-------
377 ------inner2-------
378 ------3-------
379 <d1><d2>haha<d2><d1>
380 '''
381 
382 # 相当于：把下层装饰器的结果作为参数传给上层装饰器
383 # f=d1(d2(f))
384 # f()
385 # 就像淘宝卖家寄快递一样，比如买了个水杯，装饰器装饰的过程就是打包水杯的过程，先给水杯套上一个
386 # 纸盒子，再将纸盒子外面包一层泡沫，然后放到一个大快递盒子里，贴上发件信息。
387 # 对应的是：先打印d2，再打印d1；
388 
389 # 调用函数的时候就如同买家收到包裹后，先撕开外面的盒子，再扯掉泡沫，再撕掉里面的纸盒子，取出水杯。
390 # 对应的是：-------inner1------、-------inner2-------、-----3-------
391 
392 
393 
394 # 定长参函数：
395 def d(func):
396     def d_in(a,b):
397         func(a,b)
398     return d_in
399 
400 @d
401 def func(a,b):
402     print("a+b的值是：%d"%(a+b))
403 
404 
405 func(1,2)
406 
407 # a+b的值是：3
408 
409 
410 # 不定长参函数：
411 def d(func):
412     def d_in(a,b,*c,**d): #1、把3,4,5放在元组c里,此时c=(3,4,5)
413         print("c =",c)
414         print("haha")
415         func(a,b,*c,**d)  #2、给c解包成3,4,5后传到func里
416     return d_in
417 
418 @d
419 def func(a,b,*tun,**dic):  #3、 将收到的3,4,5放到元组tun里
420     print("a=%d"%a)
421     print("b =",b)
422     print("tun={0}".format(tun))
423     print("dic={0}".format(dic))
424 
425 
426 func(1,2,3,4,5,name="wy",age=18)
427 
428 '''
429 结果：
430 c = (3, 4, 5)
431 haha
432 a=1
433 b = 2
434 tun=(3, 4, 5)
435 dic={'name': 'wy', 'age': 18}
436 
437 '''
438 
439 # 有返回值函数装饰：
440 
441 def d(func):
442     def d_in(a,b):
443         print("该干嘛干嘛1")
444         result = func(a,b)
445         print("该干嘛干嘛2")
446         return result
447     return d_in
448 
449 @d
450 def func(a,b):
451     print("该干嘛干嘛3")
452     return "a+b的值是：%d"%(a+b)
453 
454 a = func(1,2)
455 print(a)
456 
457 '''
458 结果：
459 该干嘛干嘛1
460 该干嘛干嘛3
461 该干嘛干嘛2
462 a+b的值是：3
463 '''
464 
465 # 装饰器带参数：
466 # 装饰器如果带参数，则先执行@后面的函数，返回得到真正的装饰器函数
467 def func1(a):
468     def func2(func):
469         def func3():
470             print("a =",a)
471             func()
472         return func3
473 
474     return func2
475 
476 @func1("666") # 等价于 @func2
477 def func():
478     print("haha")
479 
480 func()
481 
482 # a = 666
483 # haha
484 
485 # 类装饰器
486 
487 class Test(object):
488     def __init__(self,func):
489         print("---正在初始化---")
490         print("func name is %s"%func.__name__)
491         self.__func = func
492     def __call__(self):
493         print("---装饰器中的功能---")
494         self.__func()
495 
496 @Test  # 等价于 test = Test(test)
497 def test():
498     print("---test---")
499 
500 test()
501 
502 '''
503 结果：
504 ---正在初始化---
505 func name is test
506 ---装饰器中的功能---
507 ---test---
508 '''
509 
510 # 注意：在类里面写上__call__方法，则在调用类的对象时直接调用call方法。
511 # 类装饰器的原理跟函数装饰器完全一样。
512 
513 
514 
515 # ------------------------------------------------------------------------
516 # python给类动态添加方法
517 class Person(object):
518     def __init__(self,name,age):
519         self.name = name 
520         self.age = age
521 
522     def eat(self): # 这里的self自动传入p对象
523         print("======%s正在吃======="%self.name)
524 
525 def run(self):
526     print("======%s正在跑======="%self.name)
527 
528 p = Person("wy",18)
529 p.eat()
530 p.run = run 
531 # p.run() 报错，给类添加方法时并未将对象p传给run中的self
532 # 成功调用run的两种方式：
533 # 1：直接传入对象参数
534 p.run(p)
535 # 2：绑定方法到对象
536 import types
537 p.run = types.MethodType(run,p)
538 p.run()
539 
540 
541 
542 # 给类添加类方法和静态方法
543 # 给类添加方法就比给对象添加方法简单些，直接 类名.方法名=方法名
544 @classmethod
545 def fun1(cls):
546     print("=======class method ========")
547 
548 @staticmethod
549 def fun2():
550     print("=======static method ========")
551 
552 
553 Person.fun1 = fun1
554 Person.fun1() #=======class method ========
555 
556 Person.fun2 = fun2
557 Person.fun2() #=======static method ========
558 
559 
560 # __slots__变量
561 # 如上，python允许动态的给类添加属性，但如果要限制实例的属性怎么办，只允许
562 # 添加指定的属性。
563 
564 class P(object):
565     __slots__ = ("name")
566 
567 
568 p = P()
569 p.name = "wy"
570 print(p.name) # wy
571 
572 # p.age = 18 
573 # print(p.age) # AttributeError
574 
575 
576 
577 # 元类
578 
579 # 常规方法创建类：
580 class Test:
581     num = 100
582     def __init__(self):
583         self.name = "wy"
584     def pri(self):
585         print(self.num)
586 t=Test()
587 t.pri() # 100
588 
589 print(t.name)  # wy
590 
591 # 在这里，实例对象t是由类Test创建的，而类Test是由类type创建的。
592 # 如下，类type创建了继承自Test的、拥有属性num2的实例对象————类Test2。
593 
594 Test2 = type("Test2",(Test,),{"num2":200})
595 print(Test2.num2) # 200
596 Test2().pri()  # 100 继承了pri方法，通过实例对象调用
597 print(type(Test2)) # <class 'type'>
598 print(type(t))     # <class '__main__.Test'>
599 print(type(Test))  # <class 'type'>
600 
601 # 这里的type类就是元类。
602 
603 
604 # GC垃圾回收机制
605 # 以引用计数为主，以隔代回收为辅
606 
607 # 引用计数
608 # 当一个对象的引用计数为0时，该对象在系统中所占的内存就会被释放。
609 # 当出现循环引用的时候，两个对象相互引用对方，引用计数都为1，此时
610 # 会使用隔代回收机制将引用计数减去1变为0后再释放内存。
611 # sys.getrefcount()查看引用计数，引用计数+1后又被-1
612 class Ref(object):
613     def __init__(self,value):
614         self.value = value
615 
616 
617 r1 = Ref("liudehua")
618 r2 = Ref("gutianle")
619 import sys
620 print(sys.getrefcount(r1)) # 2
621 r1.next = r2
622 r2.pre = r1
623 print(sys.getrefcount(r1)) # 3
624 
625 r1 = None
626 r2 = None
627 
628 
629 import gc
630 print(gc.get_threshold()) # (700, 10, 10)
631 # 700：当新创建的对象个数减去新释放的对象数后存在的个数大于700则启动零代回收。
632 # 10：每清理10次零代链表就清理一次一代链表；
633 print(gc.get_count()) #(331, 3, 1) 目前的清理情况
634 
635 # gc.gisable() 关闭垃圾回收机制
636 # gc.enable() 打开垃圾回收机制
637 # gc.colletc() 手动调用垃圾回收机制
638 # 
639 # 导致引用计数+1的情况：
640 # 1、对象被创建,a="zhangwenwen"; 
641 # 2、对象被引用，如b=a；
642 # 3、对象作为实参传入到函数中，如func(a)。函数执行完毕后-1
643 # 4、对象作为一个元素存储在容器中，如list=[a]。列表销毁或元素被删除则-1