python协程函数、递归、匿名函数与内置函数使用、模块与包

 1 # def read_file(fpath):
 2 #     BLOCK_SIZE = 1024
 3 #     with open(fpath, ‘rb‘) as f:
 4 #         while True:
 5 #             block = f.read(BLOCK_SIZE)
 6 #             if block:
 7 #                 yield block
 8 #             else:
 9 #                 return
10 
11 ‘‘‘
12 结果：
13     以上传入参数就可以按1024字符，以迭代的方式，返回读取内容，内存只占1024字符
14 ‘‘‘

 1 ‘‘‘
 2 b.加强的生成器特性
 3 除了可以使用 next() 方法来获取下一个生成的值，用户还可以使用 send() 方法将一个新
 4 的或者是被修改的值返回给生成器。除此之外，还可以使用 close() 方法来随时退出生成器。 
 5 ‘‘‘
 6 # def eater(name):
 7 #     print(‘%s ready to eat!!!‘ % (name))
 8 #     count = 1
 9 #     while True:
10 #         yield count
11 #         count += 1
12 #         print(‘%s eating‘ % (name))
13 # 
14 # g = eater(‘Tom‘)
15 # print(next(g))
16 # print(next(g))
17 ‘‘‘
18 直接运行g.send()报错，为生成器没有初始化,所以使用.send()，第一个值必须初始化
19 Traceback (most recent call last):
20   File "D:/old_boy/old_boy_17_05/yield_ex1.py", line 66, in <module>
21     print(g.send(‘shuyang‘))
22 TypeError: can‘t send non-None value to a just-started generator
23 # print(g.send(‘shuyang‘)) 
24 ‘‘‘
25 # print(g.send(None))  # .send(None) == next(g)
26 # print(g.send(None))
27 # g.close()  # 退出生成器
28 # next(g)
29 ‘‘‘
30 结果：
31 Tom ready to eat!!!
32 1
33 Tom eating
34 2
35 Tom eating
36 3
37 Tom eating
38 4
39 Traceback (most recent call last):
40   File "D:/old_boy/old_boy_17_05/yield_ex1.py", line 62, in <module>
41     next(g)
42 StopIteration
43 ‘‘‘

 1 # # 装饰器，执行生成器第一次初始化
 2 # def deco(func):
 3 #     def wrapper(*args,**kwargs):
 4 #         res=func(*args,**kwargs)
 5 #         next(res)
 6 #         return res
 7 #     return wrapper
 8 #
 9 # @deco
10 # def eater(name):
11 #     print(‘%s ready to eat!!!‘ % name)
12 #     while True:
13 #         food = yield
14 #         print(‘%s eating %s‘ % (name, food))
15 #
16 # g = eater(‘alex11‘)
17 # # next(g) # g.send(None)
18 # g.send(‘面条‘)
19 # g.send(‘馒头‘)
20 # g.send(‘包子‘)
21 
22 ‘‘‘
23 结果:
24 alex11 ready to eat!!!
25 alex11 eating 面条
26 alex11 eating 馒头
27 alex11 eating 包子
28 ‘‘‘

 1 # 列表写法
 2 l = [‘egg%s‘ %i for i in range(10)]
 3 print(l)
 4 # 生成器写法
 5 g = (‘egg%s‘ %i for i in range(10))
 6 # print(g)
 7 # print(next(g))
 8 # print(next(g))
 9 # for i in g:
10 #     print(i)
11 print(list(g))
12 ‘‘‘
13 结果：
14 [‘egg0‘, ‘egg1‘, ‘egg2‘, ‘egg3‘, ‘egg4‘, ‘egg5‘, ‘egg6‘, ‘egg7‘, ‘egg8‘, ‘egg9‘]
15 [‘egg0‘, ‘egg1‘, ‘egg2‘, ‘egg3‘, ‘egg4‘, ‘egg5‘, ‘egg6‘, ‘egg7‘, ‘egg8‘, ‘egg9‘]
16 ‘‘‘

 1 # 文件写法
 2 # 列表存值写法
 3 # f = open(‘FILENAME‘, ‘r‘)
 4 # allLinesLen = [line(x.strip()) for x in f]
 5 # f.close()
 6 # return max(allLinesLen)   # 返回列表中最大的数值
 7 # 生成器存值写法
 8 # f = open(‘FILENAME‘, ‘r‘)
 9 # allLinesLen = (line(x.strip()) for x in f)   # 这里的 x 相当于 yield x
10 # f.close()
11 # return max(allLinesLen)

 1 ‘‘‘
 2 3、协程函数
 3   协程函数就是使用了yield表达式形式的生成器
 4 ‘‘‘
 5 def deco(func):
 6     def warrper(*args, **kwargs):
 7         res = func(*args, **kwargs)
 8         res.send(None)  # 初始化生成器
 9         return res
10     return warrper
11 
12 @deco
13 def eater(name):
14     print(‘%s ready to eat!!!‘ % name)
15     food_list = []
16     while True:
17         food = yield food_list
18         # 因yield，程序在这里停顿，所以，要添加yield返回值操作，必须在yield后
19         food_list.append(food)
20         print(‘%s eating %s‘ % (name, food))
21 
22 g = eater(‘alex‘)
23 #next(g)  # g.send(None)
24 print(g.send(‘面条‘))
25 print(g.send(‘馒头‘))
26 print(g.send(‘包子‘))
27 
28 ‘‘‘
29 结果:
30 alex ready to eat!!!
31 alex eating 面条
32 [‘面条‘]
33 alex eating 馒头
34 [‘面条‘, ‘馒头‘]
35 alex eating 包子
36 [‘面条‘, ‘馒头‘, ‘包子‘]
37 ‘‘‘

  1 #!/usr/bin/env python
  2 # -*- coding:utf-8 -*-
  3 # Author:Shu Yang Wang
  4 # Date: 2017/5/30
  5 
  6 ‘‘‘
  7 yield的应用场景
  8 grep -rl ‘python‘ /root
  9 ‘‘‘
 10 import os
 11 
 12 def init(func):
 13     def wrapper(*args, **kwargs):
 14         res = func(*args, **kwargs)
 15         next(res)
 16         return res
 17     return wrapper
 18 
 19 # 第一个@init必须写,否则生成器无法完成全部代码的初始化
 20 @init
 21 def search(target):
 22     ‘‘‘
 23     拼接字符串
 24     :param target: 生成器内存地址
 25     :return: 
 26     ‘‘‘
 27     while True:
 28         search_path = yield
 29         # os.walk() 方法用于通过在目录树种游走输出在目录中的文件名，向上或者向下
 30         # 结果:(‘a‘, [‘b‘], [‘a.txt‘, ‘__init__.py‘])(目录名，子目录，文件)
 31         g = os.walk(search_path)
 32         for par_dir, _, files in g:
 33             for file in files:
 34                 # r‘‘为原生字符串，不经过python解释器编译（windows下路径表示尤为有用）
 35                 file_abs_path = r‘%s\%s‘ %(par_dir, file)
 36                 # print(file_abs_path)
 37                 # 下一层生成器
 38                 target.send(file_abs_path)
 39 @init
 40 def opener(target):
 41     ‘‘‘
 42     打开文件
 43     :param target: 生成器内存地址
 44     :return: 查看文件内容生成器发送文件地址，文件句柄
 45     ‘‘‘
 46     while True:
 47         file_abs_path = yield  # 接收search传递的路径
 48         with open(file_abs_path, encoding=‘utf-8‘) as f:
 49             #print(f)
 50             target.send((file_abs_path, f))  # send多个用元组的方式，为了把文件的路径传递下去
 51 
 52 # g = search(opener())
 53 # g.send(‘a‘)
 54 ‘‘‘
 55 结果:
 56 <_io.TextIOWrapper name=‘a/a.txt‘ mode=‘r‘ encoding=‘utf-8‘>
 57 <_io.TextIOWrapper name=‘a/__init__.py‘ mode=‘r‘ encoding=‘utf-8‘>
 58 <_io.TextIOWrapper name=‘a\\b/b.txt‘ mode=‘r‘ encoding=‘utf-8‘>
 59 <_io.TextIOWrapper name=‘a\\b/__init__.py‘ mode=‘r‘ encoding=‘utf-8‘>
 60 <_io.TextIOWrapper name=‘a\\b\\c/c.txt‘ mode=‘r‘ encoding=‘utf-8‘>
 61 <_io.TextIOWrapper name=‘a\\b\\c/__init__.py‘ mode=‘r‘ encoding=‘utf-8‘>
 62 <_io.TextIOWrapper name=‘a\\b\\c\\d/d.txt‘ mode=‘r‘ encoding=‘utf-8‘>
 63 <_io.TextIOWrapper name=‘a\\b\\c\\d/__init__.py‘ mode=‘r‘ encoding=‘utf-8‘>
 64 ‘‘‘
 65 
 66 @init
 67 def cat(target):
 68     ‘‘‘
 69     查看文件内容
 70     :param target: 生成器内存地址
 71     :return: 查找匹配line生成器，文件地址和一行内容
 72     ‘‘‘
 73     while True:
 74         file_abs_path, f = yield
 75         for line in f:
 76             tag = target.send((file_abs_path, line))
 77             # 优化函数，文件找到关键字则返回文件，tag为此标记
 78             if tag:
 79                 break
 80 
 81 @init
 82 def grep(target, pattern):
 83     ‘‘‘
 84     查找匹配line
 85     :param target: 生成器内存地址
 86     :param pattern: 查询的关键字
 87     :return: 打印行生成器，发送文件地址
 88     ‘‘‘
 89     # 优化函数，文件找到关键字则返回文件，tag为此标记
 90     tag = False
 91     while True:
 92         file_abs_path, line = yield tag
 93         # tag此标记，初始化写在yield之后
 94         tag = False
 95         if pattern in line:
 96             tag = True
 97             target.send(file_abs_path)
 98 
 99 @init
100 def printer():
101     ‘‘‘
102     打印行
103     :return: 
104     ‘‘‘
105     while True:
106         file_abs_path = yield
107         print(file_abs_path)
108 
109 
110 x = r‘D:\old_boy\old_boy_17_05\a‘
111 g = search(opener(cat(grep(printer(),‘python‘))))
112 print(g)
113 g.send(x)
114 
115 ‘‘‘
116 结果：
117 <generator object search at 0x0000004FFDCCB780>
118 D:\old_boy\old_boy_17_05\a\a.txt
119 D:\old_boy\old_boy_17_05\a\__init__.py
120 D:\old_boy\old_boy_17_05\a\b\b.txt
121 D:\old_boy\old_boy_17_05\a\b\__init__.py
122 D:\old_boy\old_boy_17_05\a\b\c\__init__.py
123 D:\old_boy\old_boy_17_05\a\b\c\d\d.txt
124 D:\old_boy\old_boy_17_05\a\b\c\d\__init__.py
125 ‘‘‘

 1 # 书写方式1：
 2 def f1():
 3     print(‘from f1‘)
 4     f1()
 5 f1()
 6 ‘‘‘
 7 结果：
 8 from f1
 9 from f1
10 from f1
11 from f1    f1()
12   File "D:/old_boy/old_boy_17_05/递归调用.py", line 32, in f1
13     f1()
14   [Previous line repeated 993 more times]
15   File "D:/old_boy/old_boy_17_05/递归调用.py", line 31, in f1
16     print(‘from f1‘)
17 RecursionError: maximum recursion depth exceeded while calling a Python object
18 递归超过文件最大限制
19 ‘‘‘

 1 # 书写方式2：
 2 def f1():
 3     print(‘f1‘)
 4     f2()
 5 
 6 def f2():
 7     print(‘f2‘)
 8     f1()
 9 
10 f1()
11 ‘‘‘
12 结果:
13 f1
14 f2
15 f1
16 f2
17 f1
18 f2
19 f1
20 f2
21 RecursionError: maximum recursion depth exceeded while calling a Python object
22 递归超过文件最大限制
23 ‘‘‘

 1 import sys
 2 # 查看当前递归最大值，默认为1000
 3 print(sys.getrecursionlimit())
 4 # 修改当前递归最大值
 5 print(sys.setrecursionlimit(1000000))
 6 print(sys.getrecursionlimit())
 7 ‘‘‘
 8 结果:
 9 1000
10 None
11 1000000
12 ‘‘‘

 1 #递归应用之二分法：
 2 # l = range(0,400000)
 3 l = [1, 2, 10,33,53,71,73,75,77,85,101,201,202,999,11111]
 4 
 5 def search(find_num,seq):
 6     if len(seq) == 0:
 7         print(‘not exists‘)
 8         return
 9     mid_index=len(seq)//2
10     mid_num=seq[mid_index]
11     print(seq,mid_num)
12     if find_num > mid_num:
13         #in the right
14         seq=seq[mid_index+1:]
15         search(find_num,seq)
16     elif find_num < mid_num:
17         #in the left
18         seq=seq[:mid_index]
19         search(find_num,seq)
20     else:
21         print(‘find it‘)
22 
23 search(77,l)
24 ‘‘‘
25 结果：
26 [1, 2, 10, 33, 53, 71, 73, 75, 77, 85, 101, 201, 202, 999, 11111] 75
27 [77, 85, 101, 201, 202, 999, 11111] 201
28 [77, 85, 101] 85
29 [77] 77
30 find it
31 ‘‘‘
32 # search(72,l)
33 ‘‘‘
34 结果：
35 [1, 2, 10, 33, 53, 71, 73, 75, 77, 85, 101, 201, 202, 999, 11111] 75
36 [1, 2, 10, 33, 53, 71, 73] 33
37 [53, 71, 73] 71
38 [73] 73
39 not exists
40 ‘‘‘

 1 # 正常函数
 2 def func(x,y):
 3     return x+y
 4 print(func(1,2))
 5 ‘‘‘
 6 结果：
 7 3
 8 ‘‘‘
 9 
10 
11 # 匿名函数
12 f=lambda x,y:x+y
13 print(f)
14 print(f(1,2))
15 ‘‘‘
16 结果：
17 <function <lambda> at 0x0000001C641BC8C8>
18 3
19 ‘‘‘

 1 #max,min,zip,sorted的用法
 2 # 字典的运算：最小值，最大值，排序方法一:
 3 # salaries={
 4 # ‘egon‘:3000,
 5 # ‘alex‘:100000000,
 6 # ‘wupeiqi‘:10000,
 7 # ‘yuanhao‘:2000
 8 # }
 9 # 迭代字典,key值，默认的key值是不对的
10 salaries={
11 ‘egon‘:3000,
12 ‘alex‘:100000000,
13 ‘wupeiqi‘:10000,
14 ‘yuanhao‘:2000
15 }
16 # print(max(salaries))
17 ‘‘‘
18 结果：
19 yuanhao
20 ‘‘‘
21 # print(min(salaries))
22 ‘‘‘
23 结果：
24 alex
25 ‘‘‘
26 
27 # 迭代字典,取得指定key，因而比较的是key的最大和最小值
28 salaries={
29 ‘egon‘:3000,
30 ‘alex‘:100000000,
31 ‘wupeiqi‘:10000,
32 ‘yuanhao‘:2000
33 }
34 # print(max(salaries,key=lambda k:salaries[k]))
35 ‘‘‘
36 结果：
37 alex
38 ‘‘‘
39 # print(min(salaries,key=lambda k:salaries[k]))
40 ‘‘‘
41 结果：
42 yuanhao
43 ‘‘‘
44 
45 # 也可以通过zip的方式实现
46 # salaries={
47 # ‘egon‘:3000,
48 # ‘alex‘:100000000,
49 # ‘wupeiqi‘:10000,
50 # ‘yuanhao‘:2000
51 # }
52 # res=zip(salaries.values(),salaries.keys())
53 # # print(list(res))
54 # print(max(res))
55 ‘‘‘
56 结果：
57 (100000000, ‘alex‘)
58 ‘‘‘
59 
60 # 相当于
61 # salaries={
62 # ‘egon‘:3000,
63 # ‘alex‘:100000000,
64 # ‘wupeiqi‘:10000,
65 # ‘yuanhao‘:2000
66 # }
67 # def func(k):
68 #     return salaries[k]
69 
70 # print(max(salaries,key=func))
71 
72 # sorted排序
73 # salaries={
74 # ‘egon‘:3000,
75 # ‘alex‘:100000000,
76 # ‘wupeiqi‘:10000,
77 # ‘yuanhao‘:2000
78 # }
79 # print(sorted(salaries)) #默认的排序结果是从小到大
80 # print(sorted(salaries,key=lambda x:salaries[x])) #默认的金钱排序结果是从小到大
81 # print(sorted(salaries,key=lambda x:salaries[x],reverse=True)) #默认的金钱排序结果是从大到小
82 ‘‘‘
83 结果：
84 [‘alex‘, ‘egon‘, ‘wupeiqi‘, ‘yuanhao‘]
85 [‘yuanhao‘, ‘egon‘, ‘wupeiqi‘, ‘alex‘]
86 [‘alex‘, ‘wupeiqi‘, ‘egon‘, ‘yuanhao‘]
87 ‘‘‘

 1 >>> map(str, range(5))           #对range(5)各项进行str操作
 2 [‘0‘, ‘1‘, ‘2‘, ‘3‘, ‘4‘]        #返回列表
 3 >>> def add(n):return n+n
 4 ... 
 5 >>> map(add, range(5))           #对range(5)各项进行add操作
 6 [0, 2, 4, 6, 8]
 7 >>> map(lambda x:x+x,range(5))   #lambda 函数，各项+本身
 8 [0, 2, 4, 6, 8]
 9 >>> map(lambda x:x+1,range(10))  #lambda 函数，各项+1
10 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
11 >>> map(add,‘zhoujy‘)            
12 [‘zz‘, ‘hh‘, ‘oo‘, ‘uu‘, ‘jj‘, ‘yy‘]
13 
14 #想要输入多个序列，需要支持多个参数的函数，注意的是各序列的长度必须一样，否则报错：
15 >>> def add(x,y):return x+y
16 ... 
17 >>> map(add,‘zhoujy‘,‘Python‘)
18 [‘zP‘, ‘hy‘, ‘ot‘, ‘uh‘, ‘jo‘, ‘yn‘]
19 >>> def add(x,y,z):return x+y+z
20 ... 
21 >>> map(add,‘zhoujy‘,‘Python‘,‘test‘)     #‘test‘的长度比其他2个小
22 Traceback (most recent call last):
23   File "<stdin>", line 1, in <module>
24 TypeError: add() takes exactly 2 arguments (3 given)
25 
26 >>> map(add,‘zhoujy‘,‘Python‘,‘testop‘)
27 [‘zPt‘, ‘hye‘, ‘ots‘, ‘uht‘, ‘joo‘, ‘ynp‘]

 1 >>> def add(x,y):return x+y
 2 ... 
 3 >>> reduce(add,range(10))        #1+2+3+...+9
 4 45
 5 >>> reduce(add,range(11))        #1+2+3+...+10
 6 55
 7 >>> reduce(lambda x,y:x*y,range(1,3),5)           #lambda 函数，5是初始值， 1*2*5
 8 10
 9 >>> reduce(lambda x,y:x*y,range(1,6))             #阶乘，1*2*3*4*5
10 120
11 >>> reduce(lambda x,y:x*y,range(1,6),3)           #初始值3，结果再*3
12 360
13 >>> reduce(lambda x,y:x+y,[1,2,3,4,5,6])          #1+2+3+4+5+6
14 21 

 1 >>> def div(n):return n%2
 2 ... 
 3 >>> filter(div,range(5))                    #返回div输出的不等于0的真值
 4 [1, 3]
 5 >>> filter(div,range(10))
 6 [1, 3, 5, 7, 9]
 7 >>> filter(lambda x : x%2,range(10))        #lambda 函数返回奇数，返回列表
 8 [1, 3, 5, 7, 9]
 9 >>> filter(lambda x : not x%2,range(10))
10 [0, 2, 4, 6, 8]
11 >>> def fin(n):return n!=‘z‘                #过滤‘z‘ 函数，出现z则返回False
12 ... 
13 >>> filter(fin,‘zhoujy‘)                    #‘z‘被过滤
14 ‘houjy‘
15 >>> filter(lambda x : x !=‘z‘,‘zhoujy‘)     #labmda返回True值
16 ‘houjy‘
17 >>> filter(lambda x : not x==‘z‘,‘zhoujy‘)  #返回：字符串
18 ‘houjy‘

 1 #!/usr/bin/env python
 2 #-*- coding:utf-8 -*-
 3 def add_factorial(n):
 4     empty_list=[]           #声明一个空列表，存各个阶乘的结果，方便这些结果相加
 5     for i in map(lambda x:x+1,range(n)):    #用传进来的变量(n)来生成一个列表，用map让列表都+1，eg：range(5) => [1,2,3,4,5]
 6         a=reduce(lambda x,y:x*y,map(lambda x:x+1,range(i)))   #生成阶乘，用map去掉列表中的0
 7         empty_list.append(a)            #把阶乘结果append到空的列表中
 8     return empty_list
 9 if __name__ == ‘__main__‘:
10     import sys
11 #2选1
12 #(一)
13     try:
14         n = input("Enter a Number(int) : ")
15         result=add_factorial(n)   #传入变量
16         print reduce(lambda x,y:x+y,result)      #阶乘结果相加
17     except (NameError,TypeError):
18         print "That‘s not a Number!"
19 #(二)
20 #    result = add_factorial(int(sys.argv[1]))   #传入变量
21 #    print reduce(lambda x,y:x+y,result)      #阶乘结果相加

 1 ‘‘‘
 2 思路：
 3 
 4 质数是指：只有1和它本身两个因数，如2、3、5、7都是质数，即能被1和本身整除，1不是质数。
 5 比如一个数字N，看它是否质数的话，就要看：有没有能整除【2，N】之间的数X（不包含本身），即N%X是否为0，要是没有就为质数。
 6 所以我们要实现的算法是：拿一个数字N，去除以【2，N】之间的数X，来得到质数，即：N/2，N/3，……，N/N-2，N/N-1   ===> N/range(2，N）
 7 ‘‘‘
 8 #!/usr/bin/env python
 9 #-*- coding:utf-8 -*-
10 def is_prime(start,stop):
11     stop  = stop+1     #包含列表右边的值
12     prime = filter(lambda x : not [x%i for i in range(2,x) if x%i == 0],range(start,stop))   #取出质数,x从range(start,stop) 取的数
13     print prime
14 
15 if __name__ == ‘__main__‘:
16     try :
17         start = input("Enter a start Number :")
18     except :
19         start = 2   #开始值默认2
20     try :
21         stop  = input("Enter a stop  Number :")
22     except :
23         stop  = 0   #停止数，默认0，即不返回任何值
24     is_prime(start,stop)
25 ‘‘‘
26 结果：
27 Enter a start Number :10
28 Enter a stop  Number :20
29 [11, 13, 17, 19]
30 ‘‘‘

 1 print(‘from the spam.py‘)
 2 money = 1000
 3 
 4 def read1():
 5     print(‘spam->read1->money‘, money)
 6 
 7 def read2():
 8     print(‘spam->read2->calling read1‘)
 9     read1()
10 
11 def change():
12     global money
13     money = 0

 1 # 只在第一次导入时才执行spam.py内代码,此处的显式效果是只打印一次‘from the spam.py‘,当然其他的顶级代码也都被执行了,只不过没有显示效果.
 2 # import spam_mod
 3 # import spam_mod
 4 # import spam_mod
 5 # import spam_mod
 6 ‘‘‘
 7 结果：
 8 from the spam_moy.py
 9 ‘‘‘
10 
11 #测试一:money与spam.money不冲突
12 # import spam_mod
13 # money=10
14 # print(spam_mod.money)
15 ‘‘‘
16 结果：
17 from the spam_mod.py
18 1000
19 ‘‘‘
20 
21 # 测试二：read1与spam.read1不冲突
22 # import spam_mod
23 # def read1():
24 #     print(‘========‘)
25 # spam_mod.read1()
26 ‘‘‘
27 结果:
28 from the spam_mod.py
29 spam_mod->read1->money 1000
30 ‘‘‘
31 
32 # 测试三：执行spam.change()操作的全局变量money仍然是spam中的
33 # import spam_mod
34 # money=1
35 # spam_mod.change()
36 # print(money)
37 
38 ‘‘‘
39 执行结果：
40 from the spam_mod.py
41 1
42 ‘‘‘

 1 # from spam import read1,read2
 2 
 3 # 测试一：导入的函数read1，执行时仍然回到spam.py中寻找全局变量money
 4 # from spam_mod import read1
 5 # money=1000
 6 # read1()
 7 ‘‘‘
 8 执行结果:
 9 from the spam.py
10 spam_mod->read1->money 1000
11 ‘‘‘
12 
13 #测试二:导入的函数read2，执行时需要调用read1(),仍然回到spam.py中找read1()
14 # from spam_mod import read2
15 # def read1():
16 #     print(‘==========‘)
17 # read2()
18 
19 ‘‘‘
20 执行结果:
21 from the spam.py
22 spam_mod->read2->calling read1
23 spam_mod->read1->money 1000
24 ‘‘‘
25 
26 # 测试三:导入的函数read1，被当前位置定义的read1覆盖掉了
27 # from spam_mod import read1
28 # def read1():
29 #     print(‘==========‘)
30 # read1()
31 ‘‘‘
32 执行结果:
33 from the spam.py
34 ==========
35 ‘‘‘

 1 # from spam import * 
 2 from spam_mod import * #将模块spam中所有的名字都导入到当前名称空间
 3 print(money)
 4 print(read1)
 5 print(read2)
 6 print(change)
 7 
 8 ‘‘‘
 9 执行结果:
10 from the spam_mod.py
11 1000
12 <function read1 at 0x1012e8158>
13 <function read2 at 0x1012e81e0>
14 <function change at 0x1012e8268>
15 ‘‘‘

 1 from spam_mod import *
 2 print(money) # 加入的可以执行
 3 read1()  # 没有加入__all__的执行报错
 4 
 5 ‘‘‘
 6 结果：
 7 from the spam_mod.py
 8 1000
 9 Traceback (most recent call last):
10   File "D:/old_boy/old_boy_17_05/模块/mod_py.py", line 167, in <module>
11     read1()
12 NameError: name ‘read1‘ is not defined
13 ‘‘‘

 1 def fib(n):    # write Fibonacci series up to n
 2     a, b = 0, 1
 3     while b < n:
 4         print(b, end=‘ ‘)
 5         a, b = b, a+b
 6     print()
 7 
 8 def fib2(n):   # return Fibonacci series up to n
 9     result = []
10     a, b = 0, 1
11     while b < n:
12         result.append(b)
13         a, b = b, a+b
14     return result
15 
16 if __name__ == "__main__":
17     import sys
18     fib(int(5))

 1 # #policy.py
 2 # def get():
 3 #     print(‘from policy.py‘)
 4 #
 5 # #versions.py
 6 # def create_resource(conf):
 7 #     print(‘from version.py: ‘,conf)
 8 #
 9 # #manage.py
10 # def main():
11 #     print(‘from manage.py‘)
12 #
13 # #models.py
14 # def register_models(engine):
15 #     print(‘from models.py: ‘,engine)

1 # import glance.db.models
2 # glance.db.models.register_models(‘mysql‘)
3 ‘‘‘
4 结果:
5 from models.py:  mysql
6 ‘‘‘

 1 ‘‘‘
 2 from... import...
 3 ‘‘‘
 4 from glance.db import models
 5 models.register_models(‘mysql‘)
 6 
 7 from glance.db.models import register_models
 8 register_models(‘mysql‘)
 9 ‘‘‘
10 结果：
11 from models.py:  mysql
12 from models.py:  mysql
13 ‘‘‘

1 #在__init__.py中定义
2 x=10
3 
4 def func():
5     print(‘from api.__init.py‘)
6 
7 __all__=[‘x‘,‘func‘,‘policy‘]

 1 # from glance.api import *
 2 # print(x)      # 在__init__中写了，可调用
 3 # print(func)   # 在__init__中写了，可执行
 4 # print(policy.get()) # __all__ 中写了，所以ok
 5 # print(versions.create_resource)  # 找不到
 6 ‘‘‘
 7 10
 8 <function func at 0x000000717E09C9D8>
 9 from policy.py
10 None
11 Traceback (most recent call last):
12   File "D:/old_boy/old_boy_17_05/包/packer.py", line 86, in <module>
13     print(versions.create_resource)
14 NameError: name ‘versions‘ is not defined
15 ‘‘‘

1 # 绝对导入
2 from glance.cmd import manage
3 manage.main()
4 
5 #相对导入
6 from ..db import models
7 models.register_models(‘mysql‘)

1 from glance.api import versions
2 ‘‘‘
3 结果：
4 from manage.py
5 from models.py:  mysql
6 ‘‘‘

 1 # =================================匹配模式=================================
 2 #一对一的匹配
 3 # ‘hello‘.replace(old,new)
 4 # ‘hello‘.find(‘pattern‘)
 5 
 6 #正则匹配
 7 import re
 8 #\w与\W
 9 print(re.findall(‘\w‘,‘hello egon 123‘)) #[‘h‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘, ‘e‘, ‘g‘, ‘o‘, ‘n‘, ‘1‘, ‘2‘, ‘3‘]
10 print(re.findall(‘\W‘,‘hello egon 123‘)) #[‘ ‘, ‘ ‘]
11 
12 #\s与\S
13 print(re.findall(‘\s‘,‘hello  egon  123‘)) #[‘ ‘, ‘ ‘, ‘ ‘, ‘ ‘]
14 print(re.findall(‘\S‘,‘hello  egon  123‘)) #[‘h‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘, ‘e‘, ‘g‘, ‘o‘, ‘n‘, ‘1‘, ‘2‘, ‘3‘]
15 
16 #\d与\D
17 print(re.findall(‘\d‘,‘hello egon 123‘)) #[‘1‘, ‘2‘, ‘3‘]
18 print(re.findall(‘\D‘,‘hello egon 123‘)) #[‘h‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘, ‘ ‘, ‘e‘, ‘g‘, ‘o‘, ‘n‘, ‘ ‘]
19 
20 #\A与\D
21 print(re.findall(‘\Ahe‘,‘hello egon 123‘)) #[‘he‘],\A==>^
22 print(re.findall(‘123\Z‘,‘hello egon 123‘)) #[‘he‘],\Z==>$
23 
24 #\n与\t
25 print(re.findall(r‘\n‘,‘hello egon \n123‘)) #[‘\n‘]
26 print(re.findall(r‘\t‘,‘hello egon\t123‘)) #[‘\n‘]
27 
28 #^与$
29 print(re.findall(‘^h‘,‘hello egon 123‘)) #[‘h‘]
30 print(re.findall(‘3$‘,‘hello egon 123‘)) #[‘3‘]
31 
32 # 重复匹配：| . | * | ? | .* | .*? | + | {n,m} |
33 #.
34 print(re.findall(‘a.b‘,‘a1b‘)) #[‘a1b‘]
35 print(re.findall(‘a.b‘,‘a\nb‘)) #[]
36 print(re.findall(‘a.b‘,‘a\nb‘,re.S)) #[‘a\nb‘]
37 print(re.findall(‘a.b‘,‘a\nb‘,re.DOTALL)) #[‘a\nb‘]同上一条意思一样
38 
39 #*
40 print(re.findall(‘ab*‘,‘bbbbbbb‘)) #[]
41 print(re.findall(‘ab*‘,‘a‘)) #[‘a‘]
42 print(re.findall(‘ab*‘,‘abbbb‘)) #[‘abbbb‘]
43 
44 #?
45 print(re.findall(‘ab?‘,‘a‘)) #[‘a‘]
46 print(re.findall(‘ab?‘,‘abbb‘)) #[‘ab‘]
47 #匹配所有包含小数在内的数字
48 print(re.findall(‘\d+\.?\d*‘,"asdfasdf123as1.13dfa12adsf1asdf3")) #[‘123‘, ‘1.13‘, ‘12‘, ‘1‘, ‘3‘]
49 
50 #.*默认为贪婪匹配
51 print(re.findall(‘a.*b‘,‘a1b22222222b‘)) #[‘a1b22222222b‘]
52 
53 #.*?为非贪婪匹配：推荐使用
54 print(re.findall(‘a.*?b‘,‘a1b22222222b‘)) #[‘a1b‘]
55 
56 #+
57 print(re.findall(‘ab+‘,‘a‘)) #[]
58 print(re.findall(‘ab+‘,‘abbb‘)) #[‘abbb‘]
59 
60 #{n,m}
61 print(re.findall(‘ab{2}‘,‘abbb‘)) #[‘abb‘]
62 print(re.findall(‘ab{2,4}‘,‘abbb‘)) #[‘abb‘]
63 print(re.findall(‘ab{1,}‘,‘abbb‘)) #‘ab{1,}‘ ===> ‘ab+‘
64 print(re.findall(‘ab{0,}‘,‘abbb‘)) #‘ab{0,}‘ ===> ‘ab*‘
65 
66 #[]
67 print(re.findall(‘a[1*-]b‘,‘a1b a*b a-b‘)) #[]内的都为普通字符了，且如果-没有被转意的话，应该放到[]的开头或结尾
68 print(re.findall(‘a[^1*-]b‘,‘a1b a*b a-b a=b‘)) #[]内的^代表的意思是取反，所以结果为[‘a=b‘]
69 print(re.findall(‘a[0-9]b‘,‘a1b a*b a-b a=b‘)) #[]内的^代表的意思是取反，所以结果为[‘a=b‘]
70 print(re.findall(‘a[a-z]b‘,‘a1b a*b a-b a=b aeb‘)) #[]内的^代表的意思是取反，所以结果为[‘a=b‘]
71 print(re.findall(‘a[a-zA-Z]b‘,‘a1b a*b a-b a=b aeb aEb‘)) #[]内的^代表的意思是取反，所以结果为[‘a=b‘]
72 
73 #\# print(re.findall(‘a\\c‘,‘a\c‘)) #对于正则来说a\\c确实可以匹配到a\c,但是在python解释器读取a\\c时，会发生转义，然后交给re去执行，所以抛出异常
74 print(re.findall(r‘a\\c‘,‘a\c‘)) #r代表告诉解释器使用rawstring，即原生字符串，把我们正则内的所有符号都当普通字符处理，不要转义
75 print(re.findall(‘a\\\\c‘,‘a\c‘)) #同上面的意思一样，和上面的结果一样都是[‘a\\c‘]
76 
77 #():分组
78 print(re.findall(‘ab+‘,‘ababab123‘)) #[‘ab‘, ‘ab‘, ‘ab‘]
79 print(re.findall(‘(ab)+123‘,‘ababab123‘)) #[‘ab‘]，匹配到末尾的ab123中的ab
80 print(re.findall(‘(?:ab)+123‘,‘ababab123‘)) #findall的结果不是匹配的全部内容，而是组内的内容,?:可以让结果为匹配的全部内容
81 
82 #|
83 print(re.findall(‘compan(?:y|ies)‘,‘Too many companies have gone bankrupt, and the next one is my company‘))
84 #[‘companies‘, ‘company‘]

 1 # ===========================re模块提供的方法介绍===========================
 2 import re
 3 #1 findall
 4 print(re.findall(‘e‘,‘alex make love‘) )   #[‘e‘, ‘e‘, ‘e‘],返回所有满足匹配条件的结果,放在列表里
 5 #2 search
 6 print(re.search(‘e‘,‘alex make love‘).group()) #e,只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以通过调用group()方法得到匹配的字符串,如果字符串没有匹配，则返回None。
 7 
 8 #3 match
 9 print(re.match(‘e‘,‘alex make love‘))    #None,同search,不过在字符串开始处进行匹配,完全可以用search+^代替match
10 
11 #4 split
12 print(re.split(‘[ab]‘,‘abcd‘))     #[‘‘, ‘‘, ‘cd‘]，先按‘a‘分割得到‘‘和‘bcd‘,再对‘‘和‘bcd‘分别按‘b‘分割
13 
14 #5 sub
15 print(‘===>‘,re.sub(‘a‘,‘A‘,‘alex make love‘)) #===> Alex mAke love，不指定n，默认替换所有
16 print(‘===>‘,re.sub(‘a‘,‘A‘,‘alex make love‘,1)) #===> Alex make love
17 print(‘===>‘,re.sub(‘a‘,‘A‘,‘alex make love‘,2)) #===> Alex mAke love
18 print(‘===>‘,re.sub(‘^(\w+)(.*?\s)(\w+)(.*?\s)(\w+)(.*?)$‘,r‘\5\2\3\4\1‘,‘alex make love‘)) #===> love make alex
19 
20 print(‘===>‘,re.subn(‘a‘,‘A‘,‘alex make love‘)) #===> (‘Alex mAke love‘, 2),结果带有总共替换的个数
21 
22 
23 #6 compile
24 obj=re.compile(‘\d{2}‘)
25 
26 print(obj.search(‘abc123eeee‘).group()) #12
27 print(obj.findall(‘abc123eeee‘)) #[‘12‘],重用了obj
28 
29 # 7 应用
30 print(re.findall("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>")) #[‘h1‘]
31 print(re.search("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>").group()) #<h1>hello</h1>
32 print(re.search("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>").groupdict()) #<h1>hello</h1>
33 
34 print(re.search(r"<(\w+)>\w+</(\w+)>","<h1>hello</h1>").group())
35 print(re.search(r"<(\w+)>\w+</\1>","<h1>hello</h1>").group())
36 
37 print(re.findall(r‘-?\d+\.?\d*‘,"1-12*(60+(-40.35/5)-(-4*3))")) #找出所有数字[‘1‘, ‘-12‘, ‘60‘, ‘-40.35‘, ‘5‘, ‘-4‘, ‘3‘]
38 
39 #使用|，先匹配的先生效，|左边是匹配小数，而findall最终结果是查看分组，所有即使匹配成功小数也不会存入结果
40 #而不是小数时，就去匹配(-?\d+)，匹配到的自然就是，非小数的数，在此处即整数
41 print(re.findall(r"-?\d+\.\d*|(-?\d+)","1-2*(60+(-40.35/5)-(-4*3))")) #找出所有整数[‘1‘, ‘-2‘, ‘60‘, ‘‘, ‘5‘, ‘-4‘, ‘3‘]

  1 #########################应用练习###############################################
  2 
  3 
  4 #_*_coding:utf-8_*_
  5 #在线调试工具:tool.oschina.net/regex/#
  6 import re
  7 
  8 s=‘‘‘
  9 http://www.baidu.com
 10 egon@oldboyedu.com
 11 你好
 12 010-3141
 13 ‘‘‘
 14 
 15 #最常规匹配
 16 # content=‘Hello 123 456 World_This is a Regex Demo‘
 17 # res=re.match(‘Hello\s\d\d\d\s\d{3}\s\w{10}.*Demo‘,content)
 18 # print(res)
 19 # print(res.group())
 20 # #  返回一个tuple表示(m.start(), m.end())
 21 # print(res.span())
 22 ‘‘‘
 23 结果：
 24 <_sre.SRE_Match object; span=(0, 40), match=‘Hello 123 456 World_This is a Regex Demo‘>
 25 Hello 123 456 World_This is a Regex Demo
 26 (0, 40)
 27 ‘‘‘
 28 
 29 #泛匹配
 30 # content=‘Hello 123 456 World_This is a Regex Demo‘
 31 # res=re.match(‘^Hello.*Demo‘,content)
 32 # print(res.group())
 33 ‘‘‘
 34 结果：
 35 Hello 123 456 World_This is a Regex Demo
 36 ‘‘‘
 37 
 38 
 39 #匹配目标,获得指定数据
 40 
 41 # content=‘Hello 123 456 World_This is a Regex Demo‘
 42 # res=re.match(‘^Hello\s(\d+)\s(\d+)\s.*Demo‘,content)
 43 # print(res.group()) #取所有匹配的内容
 44 # print(res.group(1)) #取匹配的第一个括号内的内容
 45 # print(res.group(2)) #去陪陪的第二个括号内的内容
 46 ‘‘‘
 47 结果：
 48 Hello 123 456 World_This is a Regex Demo
 49 123
 50 456
 51 ‘‘‘
 52 
 53 
 54 
 55 #贪婪匹配:.*代表匹配尽可能多的字符
 56 # import re
 57 # content=‘Hello 123 456 World_This is a Regex Demo‘
 58 #
 59 # res=re.match(‘^He.*(\d+).*Demo$‘,content)
 60 # print(res.group(1)) #只打印6,因为.*会尽可能多的匹配,然后后面跟至少一个数字
 61 ‘‘‘
 62 结果：
 63 6
 64 ‘‘‘
 65 
 66 
 67 #非贪婪匹配:?匹配尽可能少的字符
 68 # import re
 69 # content=‘Hello 123 456 World_This is a Regex Demo‘
 70 #
 71 # res=re.match(‘^He.*?(\d+).*Demo$‘,content)
 72 # print(res.group(1)) #只打印6,因为.*会尽可能多的匹配,然后后面跟至少一个数字
 73 ‘‘‘
 74 结果：
 75 123
 76 ‘‘‘
 77 
 78 #匹配模式:.不能匹配换行符
 79 content=‘‘‘Hello 123456 World_This
 80 is a Regex Demo
 81 ‘‘‘
 82 # res=re.match(‘He.*?(\d+).*?Demo$‘,content)
 83 # print(res) #输出None
 84 #
 85 # res=re.match(‘He.*?(\d+).*?Demo$‘,content,re.S) #re.S让.可以匹配换行符
 86 # print(res)
 87 # print(res.group(1))
 88 ‘‘‘
 89 结果：
 90 None
 91 <_sre.SRE_Match object; span=(0, 39), match=‘Hello 123456 World_This\nis a Regex Demo‘>
 92 123456
 93 ‘‘‘
 94 
 95 #转义: 96 
 97 # content=‘price is $5.00‘
 98 # res=re.match(‘price is $5.00‘,content)
 99 # print(res)
100 #
101 # res=re.match(‘price is \$5\.00‘,content)
102 # print(res)
103 ‘‘‘
104 结果：
105 None
106 <_sre.SRE_Match object; span=(0, 14), match=‘price is $5.00‘>
107 ‘‘‘
108 
109 #总结:尽量精简,详细的如下
110     # 尽量使用泛匹配模式.*
111     # 尽量使用非贪婪模式:.*?
112     # 使用括号得到匹配目标:用group(n)去取得结果
113     # 有换行符就用re.S:修改模式
114 
115 
116 #re.search:会扫描整个字符串,不会从头开始,找到第一个匹配的结果就会返回
117 
118 # import re
119 # content=‘Extra strings Hello 123 456 World_This is a Regex Demo Extra strings‘
120 #
121 # res=re.match(‘Hello.*?(\d+).*?Demo‘,content)
122 # print(res) #输出结果为None
123 
124 #
125 # import re
126 # content=‘Extra strings Hello 123 456 World_This is a Regex Demo Extra strings‘
127 #
128 # res=re.search(‘Hello.*?(\d+).*?Demo‘,content) #
129 # print(res.group(1)) #输出结果为123
130 
131 
132 
133 #re.search:只要一个结果,匹配演练,
134 # import re
135 # content=‘‘‘
136 # <tbody>
137 # <tr id="4766303201494371851675" class="even "><td><div class="hd"><span class="num">1</span><div class="rk "><span class="u-icn u-icn-75"></span></div></div></td><td class="rank"><div class="f-cb"><div class="tt"><a href="/song?id=476630320"><img class="rpic" src="http://p1.music.126.net/Wl7T1LBRhZFg0O26nnR2iQ==/19217264230385030.jpg?param=50y50&amp;quality=100"></a><span data-res-id="476630320" ‘‘‘
138 # res=re.search(‘<a\shref=.*?<b\stitle="(.*?)".*?b>‘,content)
139 # print(res.group(1))
140 ‘‘‘
141 结果：
142 Traceback (most recent call last):
143   File "D:/old_boy/old_boy_17_05/re_mod.py", line 281, in <module>
144     print(res.group(1))
145 AttributeError: ‘NoneType‘ object has no attribute ‘group‘
146 ‘‘‘
147 
148 
149 # re.findall:找到符合条件的所有结果
150 # res=re.findall(‘<a\shref=.*?<b\stitle="(.*?)".*?b>‘,content)
151 # for i in res:
152 #     print(i)
153 ‘‘‘
154 结果：
155 空
156 ‘‘‘
157 
158 
159 
160 #re.sub:字符串替换
161 # import re
162 # content=‘Extra strings Hello 123 456 World_This is a Regex Demo Extra strings‘
163 #
164 # content=re.sub(‘\d+‘,‘‘,content)
165 # print(content)
166 ‘‘‘
167 结果：
168 Extra strings Hello   World_This is a Regex Demo Extra strings
169 ‘‘‘
170 
171 #用\1取得第一个括号的内容
172 #用法:将123与456换位置
173 # import re
174 # content=‘Extra strings Hello 123 456 World_This is a Regex Demo Extra strings‘
175 #
176 # # content=re.sub(‘(Extra.*?)(\d+)(\s)(\d+)(.*?strings)‘,r‘\1\4\3\2\5‘,content)
177 # content=re.sub(‘(\d+)(\s)(\d+)‘,r‘\3\2\1‘,content)
178 # print(content)
179 ‘‘‘
180 结果：
181 Extra strings Hello 456 123 World_This is a Regex Demo Extra strings
182 ‘‘‘
183 
184 # import re
185 # content=‘Extra strings Hello 123 456 World_This is a Regex Demo Extra strings‘
186 #
187 # res=re.search(‘Extra.*?(\d+).*strings‘,content)
188 # print(res.group(1))
189 ‘‘‘
190 结果：
191 123
192 ‘‘‘
193 
194 
195 # import requests,re
196 # respone=requests.get(‘https://book.douban.com/‘).text
197 #
198 # print(respone)
199 # print(‘======‘*1000)
200 # print(‘======‘*1000)
201 # print(‘======‘*1000)
202 # print(‘======‘*1000)
203 # res=re.findall(‘<li.*?cover.*?href="(.*?)".*?title="(.*?)">.*?more-meta.*?author">(.*?)</span.*?year">(.*?)</span.*?publisher">(.*?)</span.*?</li>‘,respone,re.S)
204 # # res=re.findall(‘<li.*?cover.*?href="(.*?)".*?more-meta.*?author">(.*?)</span.*?year">(.*?)</span.*?publisher">(.*?)</span>.*?</li>‘,respone,re.S)
205 #
206 #
207 # for i in res:
208 #     print(‘%s    %s    %s   %s‘ %(i[0].strip(),i[1].strip(),i[2].strip(),i[3].strip()))