Python开发【第五篇】：模块

递归的案例：阶乘

1*2*3*4*5*6*7…

1. def func(num):
2.     if num == 1:
3.         return 1
4.     return num * func(num - 1)
5.  
6. ret = func(7)
7. print(ret)

反射

1. def f1():
2.    print('f1')

f1：函数名

'f1'：字符串

commons：

1. def login():
2.     print('登录页面')
3.  
4. def logout():
5.     print('退出页面')
6.  
7. def home():
8.     print('主页面')

index：

1. import commons
2.  
3. def run():
4.     inp = input('请输入要访问的url:')
5.     if inp == 'login':
6.         commons.login()
7.     elif inp == 'logout':
8.         commons.logout()
9.     elif inp == 'home':
10.         commons.home()
11.     else:
12.         print('404')
13.  
14. if __name__ == '__main__':
15.     run()

用反射进行优化，利用字符串的形式去对象（模块）中操作（寻找）成员。

index：

1. import commons
2.  
3. def run():
4.     inp = input('请输入要访问的url:')
5.     #反射：利用字符串的形式去对象（模块）中操作（寻找/检查/删除/设置）成员
6.     #hasattr查看inp是否存在（返回True or False）
7.     if hasattr(commons,inp):
8.         func = getattr(commons,inp)
9.         func()
10.     else:
11.         print('404')
12. if __name__ == '__main__':
13.     run()

hasattr()：寻找

getattr()：检查

delattr()：删除

setattr()：设置

进一步优化，字符串导入。

index：

1. def run():
2.     inp = input('请输入要访问的url:')
3.     m,f = inp.split('/')
4.     obj = __import__(m)
5.     if hasattr(obj,f):
6.         func = getattr(obj,f)
7.         func()
8.     else:
9.         print('404')
10.  
11. if __name__ == '__main__':
12.     run()

补充，当需要导入文件夹下面的：

1. obj = __import__('lib.account')
2. print(obj)
3. 输出：<module 'lib' from 'D:\\work_software\\PycharmProjects\\oldboy_python\\day6\\lib\\__init__.py'>
4. obj = __import__('lib.account',fromlist=True)
5. print(obj)
6. 输出：<module 'lib.account' from 'D:\\work_software\\PycharmProjects\\oldboy_python\\day6\\lib\\account.py'>

web框架的路由系统。

特殊变量__file__

1. import os
2.  
3. print(__file__)
4.  
5. #abspath()获取绝对路径
6. print(os.path.abspath(__file__))
7.  
8. #获取上级目录dirname()
9. ret = os.path.dirname(os.path.abspath(__file__))
10. ret_1 = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
11. print(ret)
12. print(ret_1)
13. 输出：
14. D:/work_software/PycharmProjects/oldboy_python/day6/bin/admin.py
15. D:\work_software\PycharmProjects\oldboy_python\day6\bin\admin.py
16. D:\work_software\PycharmProjects\oldboy_python\day6\bin
17. D:\work_software\PycharmProjects\oldboy_python\day6

特殊变量__name__

1. #只有执行当前文件的时候，当前文件的特殊变量__name__ == '__main__'
2.  
3. def run():
4.     print('rum')
5.  
6. if __name__ == "__main__":
7.     run()

sys模块

用于提供python解释器相关的操作。

sys.argv：命令行参数list，第一个元素是程序本身路径

sys.exit(n)：退出程序，正常退出时exit(0)

sys.version：获取python解释程序的版本信息

sys.maxint：最大的int值

sys.path：返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值

sys.platform：返回操作系统平台名称

sys.stdin：输入相关

sys.stdout：输出相关

sys.stderror：错误相关

进度百分比：

1. import time
2. import sys
3.  
4. def view_bar(num,total):
5.     rate = float(num)/float(total)
6.     rate_num = int(rate * 100)
7.  
8.     #数字进度显示
9.     #\r回到当前行的首位置
10.     r = '\r%d%%'%(rate_num)
11.     #输出不换行
12.     sys.stdout.write(r)
13.  
14.     #进度条显示
15.     """
16.     r1 = '\r%s>%d%%'%("="*num,rate_num)
17.     sys.stdout.write(r1)
18.     """
19.  
20.     sys.stdout.flush()
21.  
22. if __name__ == '__main__':
23.     for i in range(0,101):
24.         time.sleep(0.1)
25.         view_bar(i,100)

os模块

用于提供系统级别的操作。

os.getcwd()：获取当前工作目录，即当前python脚本工作的目录路径。

os.chdir("dirname")：改变当前脚本工作目录，相当于shell下cd。

os.curdir：返回当前目录（'.'）。

os.pardir：获取当前目录的父目录字符串名（'..'）。

os.makedirs('dir1/dir2')：可生成多层递归目录。

os.removedirs('dirname1')：若目录为空，则删除，并递归到上一级目录，若也为空，则删除，依次类推。

os.mkdir('dirname')：生成单级目录，相当于shell中mkdir、dirname。

os.rmdir('dirname')：删除单级目录，若目录不为空则无法删除，报错，相当于shell中rmdir dirname。

os.listdir('dirname')：列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印。

os.remove()：删除一个文件。

os.rename("oldname","newname")：重命名文件/目录

os.stat('path/filename')：获取文件/目录信息。

os.sep：操作系统特定的路径分隔符，win下为"\\"，linux下为"/"。

os.linesep：当前平台使用的行终止符，win下为"\t\n"，linux下为"\n"。

os.pathsep：用于分割文件路径的字符串";"。

os.name：字符串指示当前使用平台，win下为"nt"，linux下为"posix"。

os.system("bash command")：运行shell命令，直接显示。

os.environ：获取系统环境变量。

os.path.abspath(path)：返回path规范化的绝对路径。

os.path.split(path)：将path分割成目录和文件名二元组返回。

os.path.dirname(path)：返回path的目录，其实就是os.path.split(path)的第一个元素。

os.path.basename(path)：返回path最后的文件名，如果path以/或\结尾，那么就返回空值。即os.path.split(path)的第二个元素。

os.path.exists(path)：如果path存在，返回True，如果path不存在，返回False。

os.path.isabs(path)：如果path是绝对路径，返回True。

os.path.isfile(path)：如果path是一个存在的文件，返回True，否则返回False。

os.path.isdir(path)：如果path是一个存在的目录，返回True，否则返回False。

os.path.join(path1[,path2[,…]])：将多个路径组合后返回，第一个绝对路径之前的参数将被忽略。

os.path.getatime(path)：返回path所指向的文件或者目录的最后获取时间。

os.path.getmtime(path)：返回path所指向的文件或者目录的最后修改时间。

hashlib

用于加密相关的操作，代替了md5模块和sha模块，主要提供SHA1，SHA224，SHA256，SHA512，MD5算法。

MD5加密：

1. import hashlib
2.  
3. #添加自定义key再来做加密
4. obj = hashlib.md5(bytes('shisjajlj131424rdt5t6577ueuewmz',encoding='utf-8'))
5. obj.update(bytes('123',encoding='utf-8'))
6. result = obj.hexdigest()
7. print(result)

正则表达式

字符匹配：普通字符、元字符。

普通字符匹配

1. import re
2.  
3. ret = re.findall('alex','adasjkalex78272hshdsjhds')
4. print(ret)
5. 输出：['alex']

元字符匹配

.：除换行符以外的任何一个字符

1. import re
2.  
3. ret = re.findall('al.x','uiiu9alaxuialbx798alcx21oalaaxiwq2al\nxjk')
4. print(ret)
5. 输出：['alax', 'albx', 'alcx']

^：以什么开头

1. import re
2.  
3. ret = re.findall('^al.x','al@xjkasjalexk')
4. print(ret)
5. 输出：['al@x']

$：以什么结尾

1. import re
2.  
3. ret = re.findall('al.x$','al@xhhalexuieuial#x')
4. print(ret)
5. 输出：['al#x']

*：重复*前面的字符0次到n次

1. import re
2.  
3. ret = re.findall('al.*x','yiuial3278hcxuxewualeexo')
4. print(ret)
5. 输出：['al3278hcxuxewualeex']

+：重复+前面一个字符的1次到n次

?：重复?前面一个字符的0次或1次

{}：指定重复的次数，{1,5}重复1次到5次，{5}重复5次，{,5}重复0次到5次，{5,}重复5次到n次。

[]：或，[a-z]匹配a到z的任何一个，[ab]匹配a或b。

[]里面的特殊含义

-：表示范围，例如[0-9]表示0到9。

^：表示非、排除，例如[^d]表示排除d；

\：反斜杠后边跟元字符去除特殊功能；反斜杠后边跟普通字符实现特殊功能；引用序号对应的字组所匹配的字符串，例如re.search(r"(alex)(eric)com\2","alexericcomeric")。

\d：匹配任何十进制数，相当于[0-9]。

\D：匹配任何非数字字符，相当于[^0-9]。

\s：匹配任何空白字符，相当于[ \t\n\r\f\v]。

\S：匹配任何非空白字符，相当于[^ \t\n\r\f\v]。

\w：匹配任何字母数字字符，相当于[a-zA-Z0-9_]。

\W：匹配任何非字母数字字符，相当于[^a-zA-Z0-9_]。

\b：匹配一个字符串的边界，也就是指单词和空格间的位置。字符串是指连续的字母、数字和下划线组成的。注意，\b的定义是\w和\W的交界。

1. import re
2.  
3. ret = re.findall(r'I\b','I am aaIbbb')
4. print(ret)
5. 输出：['I']

零宽界定符（zero-width assertions）只用以匹配字符串的头部和尾部。尾部用空白符或非字母数字符来标识。

()：指定匹配的组。

函数

match

re.match(pattern,string,flags=0)，match只匹配起始位置。

flags编译标志位，用于修改正则表达式的匹配方式，如是否区分大小写，多行匹配等。

1. import re
2.  
3. ret = re.match('com','comwww.runcomoob')
4. print(ret)
5.  
6. ret = re.match('com','comwww.runcomoob').group()
7. print(ret)
8.  
9. ret = re.match('com','comwww.runcomoob').span()
10. print(ret)
11.  
12. 输出：
13. <_sre.SRE_Match object; span=(0, 3), match='com'>
14. com
15. (0, 3)

search

一旦匹配成功，就是一个match object对象。

1. import re
2.  
3. ret = re.search('\dcom','www.4comrunco.5com')
4. print(ret)
5.  
6. 输出：<_sre.SRE_Match object; span=(4, 8), match='4com'>

match object对象拥有以下方法：

group()返回被RE匹配的字符串。

group()返回re整体匹配的字符串，可以一次输入多个组号，对应组号匹配的字符串。

1、group()返回re整体匹配的字符串。

2、group(n,m)返回组号为n，m所匹配的字符串，如果组号不存在，则返回indexError异常。

3、groups()返回一个包含正则表达式中所有小组字符串的元组，从1到所含的小组号，通常groups()不需要参数，返回一个元组，元组中的元就是正则表达式中定义的组。

start()返回匹配开始的位置。

end()返回匹配结束的位置。

span()返回一个元组包含匹配（开始，结束）的位置。

findall

re.findall以列表形式返回所有匹配的字符串。

sub

匹配替换。

re.sub(pattern,repl,string,max=0)

1. import re
2.  
3. ret = re.sub("g.t","have",'I get A,I got B,I gut C')
4. print(ret)
5. 输出：I have A,I have B,I have C

设置最大替换次数

1. import re
2.  
3. ret = re.sub("g.t","have",'I get A,I got B,I gut C',2)
4. print(ret)
5. 输出：I have A,I have B,I gut C

subn

1. import re
2.  
3. ret = re.subn("g.t","have",'I get A,I got B,I gut C')
4. print(ret)
5. 输出：('I have A,I have B,I have C', 3)

split

1. import re
2.  
3. ret = re.split('\d+','0one1two2three3four4')
4. print(ret)
5. 输出：['', 'one', 'two', 'three', 'four', '']

compile

re.compile(strPattern[,flag])

这个方法是Pattern类的工厂方法，用于将字符串形式的正则表达式编译为Pattern对象。第二个参数flag是匹配模式，取值可以使用按位或运算符'|'，表示同时生效，例如re.I|re.M，可以把经常使用的正则表达式编译成正则表达式对象，这样可以提高一定的效率。

1. import re
2.  
3. text = "JGood is a handsome boy,he is cool,clever,and so on..."
4. regex = re.compile(r'\w*oo\w*')
5. ret = regex.findall(text)
6. print(ret)
7. 输出：['JGood', 'cool']

re.I：使匹配对大小写不敏感。

re.L：做本地化识别（locale-aware）匹配。

re.M：多行匹配，影响^和$。

re.S：使"."匹配包括换行在内的所有字符。

re.U：根据Unicode字符集解析字符。这个标识影响\w，\W，\b，\B。

正则分组

在已经匹配到的数据中再提取数据。

match的分组匹配

1. import re
2.  
3. origin = "has dhjdahk29832"
4. r = re.match("h\w+",origin)
5. #获取匹配到的所有结果
6. print(r.group())
7. #获取模型中匹配到的分组结果
8. print(r.groups())
9. #获取模型中匹配到的分组结果
10. print(r.groupdict())
11. 输出：
12. has
13. ()
14. {}
15.  
16. import re
17.  
18. origin = "has dhjdahk29832"
19. r = re.match("h(\w+)",origin)
20. #获取匹配到的所有结果
21. print(r.group())
22. #获取模型中匹配到的分组结果
23. print(r.groups())
24. #获取模型中匹配到的分组结果
25. print(r.groupdict())
26. 输出：
27. has
28. ('as',)
29. {}
30.  
31. import re
32.  
33. origin = "has dhjdahk29832"
34. r = re.match("h(?P<name>\w+)",origin)
35. #获取匹配到的所有结果
36. print(r.group())
37. #获取模型中匹配到的分组结果
38. print(r.groups())
39. #获取模型中匹配到的分组结果
40. print(r.groupdict())
41. 输出：
42. has
43. ('as',)
44. {'name': 'as'}

findall的分组匹配

1. import re
2.  
3. origin = "has sajkd hjda hk2983ds wqw2"
4. r = re.findall("h(\w+)",origin)
5. print(r)
6. 输出：['as', 'jda', 'k2983ds']
7.  
8. import re
9.  
10. origin = "hasaabc sajkd hjdaabc hk2983dsaabc wqw2"
11. r = re.findall("h(\w+)a(ab)c",origin)
12. print(r)
13. 输出：[('as', 'ab'), ('jd', 'ab'), ('k2983ds', 'ab')]

 

split的分组匹配

1. import re
2.  
3. origin = "hello alex bcd alex lgc alex acd 19"
4. r = re.split("alex",origin,1)
5. print(r)
6. 输出：['hello ', ' bcd alex lgc alex acd 19']
7.  
8. import re
9.  
10. origin = "hello alex bcd alex lgc alex acd 19"
11. #匹配值中()的内容需要输出
12. r = re.split("(alex)",origin,1)
13. print(r)
14. 输出：['hello ', 'alex', ' bcd alex lgc alex acd 19']
15.  
16. import re
17.  
18. origin = "hello alex bcd alex lgc alex acd 19"
19. r = re.split("a(le)x",origin,1)
20. print(r)
21. 输出：['hello ', 'le', ' bcd alex lgc alex acd 19']
22.  
23. import re
24.  
25. origin = "hello alex bcd alex lgc alex acd 19"
26. r = re.split("(a(le)x)",origin,1)
27. print(r)
28. 输出：['hello ', 'alex', 'le', ' bcd alex lgc alex acd 19']
29.  
30. import re
31.  
32. origin = "hello alex bcd alex lgc alex acd 19"
33. r = re.split("(a(l(e))x)",origin,1)
34. print(r)
35. 输出：['hello ', 'alex', 'le', 'e', ' bcd alex lgc alex acd 19']