Python开发【第五篇】：模块

递归的案例：阶乘

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

def func(num):

if num == 1:

return 1

return num * func(num - 1)

ret = func(7)

print(ret)

反射

def f1():

print('f1')

f1：函数名

'f1'：字符串

commons：

def login():

print('登录页面')

def logout():

print('退出页面')

def home():

print('主页面')

index：

import commons

def run():

inp = input('请输入要访问的url:')

if inp == 'login':

commons.login()

elif inp == 'logout':

commons.logout()

elif inp == 'home':

commons.home()

else:

print('404')

if __name__ == '__main__':

run()

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

index：

import commons

def run():

inp = input('请输入要访问的url:')

#反射：利用字符串的形式去对象（模块）中操作（寻找/检查/删除/设置）成员

#hasattr查看inp是否存在（返回True or False）

if hasattr(commons,inp):

func = getattr(commons,inp)

func()

else:

print('404')

if __name__ == '__main__':

run()

hasattr()：寻找

getattr()：检查

delattr()：删除

setattr()：设置

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

index：

def run():

inp = input('请输入要访问的url:')

m,f = inp.split('/')

obj = __import__(m)

if hasattr(obj,f):

func = getattr(obj,f)

func()

else:

print('404')

if __name__ == '__main__':

run()

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

obj = __import__('lib.account')

print(obj)

输出：<module 'lib' from 'D:\\work_software\\PycharmProjects\\oldboy_python\\day6\\lib\\__init__.py'>

obj = __import__('lib.account',fromlist=True)

print(obj)

输出：<module 'lib.account' from 'D:\\work_software\\PycharmProjects\\oldboy_python\\day6\\lib\\account.py'>

web框架的路由系统。

特殊变量__file__

import os

print(__file__)

#abspath()获取绝对路径

print(os.path.abspath(__file__))

#获取上级目录dirname()

ret = os.path.dirname(os.path.abspath(__file__))

ret_1 = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

print(ret)

print(ret_1)

输出：

D:/work_software/PycharmProjects/oldboy_python/day6/bin/admin.py

D:\work_software\PycharmProjects\oldboy_python\day6\bin\admin.py

D:\work_software\PycharmProjects\oldboy_python\day6\bin

D:\work_software\PycharmProjects\oldboy_python\day6

特殊变量__name__

#只有执行当前文件的时候，当前文件的特殊变量__name__ == '__main__'

def run():

print('rum')

if __name__ == "__main__":

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：错误相关

进度百分比：

import time

import sys

def view_bar(num,total):

rate = float(num)/float(total)

rate_num = int(rate * 100)

#数字进度显示

#\r回到当前行的首位置

r = '\r%d%%'%(rate_num)

#输出不换行

sys.stdout.write(r)

#进度条显示

"""

r1 = '\r%s>%d%%'%("="*num,rate_num)

sys.stdout.write(r1)

"""

sys.stdout.flush()

if __name__ == '__main__':

for i in range(0,101):

time.sleep(0.1)

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加密：

import hashlib

#添加自定义key再来做加密

obj = hashlib.md5(bytes('shisjajlj131424rdt5t6577ueuewmz',encoding='utf-8'))

obj.update(bytes('123',encoding='utf-8'))

result = obj.hexdigest()

print(result)

正则表达式

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

普通字符匹配

import re

ret = re.findall('alex','adasjkalex78272hshdsjhds')

print(ret)

输出：['alex']

元字符匹配

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

import re

ret = re.findall('al.x','uiiu9alaxuialbx798alcx21oalaaxiwq2al\nxjk')

print(ret)

输出：['alax', 'albx', 'alcx']

^：以什么开头

import re

ret = re.findall('^al.x','al@xjkasjalexk')

print(ret)

输出：['al@x']

$：以什么结尾

import re

ret = re.findall('al.x$','al@xhhalexuieuial#x')

print(ret)

输出：['al#x']

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

import re

ret = re.findall('al.*x','yiuial3278hcxuxewualeexo')

print(ret)

输出：['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的交界。

import re

ret = re.findall(r'I\b','I am aaIbbb')

print(ret)

输出：['I']

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

()：指定匹配的组。

函数

match

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

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

import re

ret = re.match('com','comwww.runcomoob')

print(ret)

ret = re.match('com','comwww.runcomoob').group()

print(ret)

ret = re.match('com','comwww.runcomoob').span()

print(ret)

输出：

<_sre.SRE_Match object; span=(0, 3), match='com'>

com

(0, 3)

search

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

import re

ret = re.search('\dcom','www.4comrunco.5com')

print(ret)

输出：<_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)

import re

ret = re.sub("g.t","have",'I get A,I got B,I gut C')

print(ret)

输出：I have A,I have B,I have C

设置最大替换次数

import re

ret = re.sub("g.t","have",'I get A,I got B,I gut C',2)

print(ret)

输出：I have A,I have B,I gut C

subn

import re

ret = re.subn("g.t","have",'I get A,I got B,I gut C')

print(ret)

输出：('I have A,I have B,I have C', 3)

split

import re

ret = re.split('\d+','0one1two2three3four4')

print(ret)

输出：['', 'one', 'two', 'three', 'four', '']

compile

re.compile(strPattern[,flag])

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

import re

text = "JGood is a handsome boy,he is cool,clever,and so on..."

regex = re.compile(r'\w*oo\w*')

ret = regex.findall(text)

print(ret)

输出：['JGood', 'cool']

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

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

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

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

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

正则分组

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

match的分组匹配

import re

origin = "has dhjdahk29832"

r = re.match("h\w+",origin)

#获取匹配到的所有结果

print(r.group())

#获取模型中匹配到的分组结果

print(r.groups())

#获取模型中匹配到的分组结果

print(r.groupdict())

输出：

has

()

{}

import re

origin = "has dhjdahk29832"

r = re.match("h(\w+)",origin)

#获取匹配到的所有结果

print(r.group())

#获取模型中匹配到的分组结果

print(r.groups())

#获取模型中匹配到的分组结果

print(r.groupdict())

输出：

has

('as',)

{}

import re

origin = "has dhjdahk29832"

r = re.match("h(?P<name>\w+)",origin)

#获取匹配到的所有结果

print(r.group())

#获取模型中匹配到的分组结果

print(r.groups())

#获取模型中匹配到的分组结果

print(r.groupdict())

输出：

has

('as',)

{'name': 'as'}

findall的分组匹配

import re

origin = "has sajkd hjda hk2983ds wqw2"

r = re.findall("h(\w+)",origin)

print(r)

输出：['as', 'jda', 'k2983ds']

import re

origin = "hasaabc sajkd hjdaabc hk2983dsaabc wqw2"

r = re.findall("h(\w+)a(ab)c",origin)

print(r)

输出：[('as', 'ab'), ('jd', 'ab'), ('k2983ds', 'ab')]

split的分组匹配

import re

origin = "hello alex bcd alex lgc alex acd 19"

r = re.split("alex",origin,1)

print(r)

输出：['hello ', ' bcd alex lgc alex acd 19']

import re

origin = "hello alex bcd alex lgc alex acd 19"

#匹配值中()的内容需要输出

r = re.split("(alex)",origin,1)

print(r)

输出：['hello ', 'alex', ' bcd alex lgc alex acd 19']

import re

origin = "hello alex bcd alex lgc alex acd 19"

r = re.split("a(le)x",origin,1)

print(r)

输出：['hello ', 'le', ' bcd alex lgc alex acd 19']

import re

origin = "hello alex bcd alex lgc alex acd 19"

r = re.split("(a(le)x)",origin,1)

print(r)

输出：['hello ', 'alex', 'le', ' bcd alex lgc alex acd 19']

import re

origin = "hello alex bcd alex lgc alex acd 19"

r = re.split("(a(l(e))x)",origin,1)

print(r)

输出：['hello ', 'alex', 'le', 'e', ' bcd alex lgc alex acd 19']