第五周学习笔记
python 软件目录开发规范
为什么要设计好目录结构?
"设计项目目录结构",就和"代码编码风格"一样,属于个人风格问题。对于这种风格上的规范,一直都存在两种态度:
- 一类同学认为,这种个人风格问题"无关紧要"。理由是能让程序work就好,风格问题根本不是问题。
- 另一类同学认为,规范化能更好的控制程序结构,让程序具有更高的可读性。
我是比较偏向于后者的,因为我是前一类同学思想行为下的直接受害者。我曾经维护过一个非常不好读的项目,其实现的逻辑并不复杂,但是却耗费了我非常长的时间去理解它想表达的意思。从此我个人对于提高项目可读性、可维护性的要求就很高了。"项目目录结构"其实也是属于"可读性和可维护性"的范畴,我们设计一个层次清晰的目录结构,就是为了达到以下两点:
- 可读性高: 不熟悉这个项目的代码的人,一眼就能看懂目录结构,知道程序启动脚本是哪个,测试目录在哪儿,配置文件在哪儿等等。从而非常快速的了解这个项目。
- 可维护性高: 定义好组织规则后,维护者就能很明确地知道,新增的哪个文件和代码应该放在什么目录之下。这个好处是,随着时间的推移,代码/配置的规模增加,项目结构不会混乱,仍然能够组织良好。
所以,我认为,保持一个层次清晰的目录结构是有必要的。更何况组织一个良好的工程目录,其实是一件很简单的事儿。
目录组织方式
关于如何组织一个较好的Python工程目录结构,已经有一些得到了共识的目录结构。在Stackoverflow的这个问题上,能看到大家对Python目录结构的讨论。
这里面说的已经很好了,我也不打算重新造轮子列举各种不同的方式,这里面我说一下我的理解和体会。
假设你的项目名为foo, 我比较建议的最方便快捷目录结构这样就足够了:
Foo/
|-- bin/
| |-- foo
|
|-- foo/
| |-- tests/
| | |-- __init__.py
| | |-- test_main.py
| |
| |-- __init__.py
| |-- main.py
|
|-- docs/
| |-- conf.py
| |-- abc.rst
|
|-- setup.py
|-- requirements.txt
|-- README
简要解释一下:
bin/
: 存放项目的一些可执行文件,当然你可以起名script/
之类的也行。foo/
: 存放项目的所有源代码。(1) 源代码中的所有模块、包都应该放在此目录。不要置于顶层目录。(2) 其子目录tests/
存放单元测试代码; (3) 程序的入口最好命名为main.py
。docs/
: 存放一些文档。setup.py
: 安装、部署、打包的脚本。requirements.txt
: 存放软件依赖的外部Python包列表。README
: 项目说明文件。
除此之外,有一些方案给出了更加多的内容。比如LICENSE.txt
,ChangeLog.txt
文件等,我没有列在这里,因为这些东西主要是项目开源的时候需要用到。
下面,再简单讲一下我对这些目录的理解和个人要求吧。
关于README的内容
这个我觉得是每个项目都应该有的一个文件,目的是能简要描述该项目的信息,让读者快速了解这个项目。
它需要说明以下几个事项:
- 软件定位,软件的基本功能。
- 运行代码的方法: 安装环境、启动命令等。
- 简要的使用说明。
- 代码目录结构说明,更详细点可以说明软件的基本原理。
- 常见问题说明。
我觉得有以上几点是比较好的一个README
。在软件开发初期,由于开发过程中以上内容可能不明确或者发生变化,并不是一定要在一开始就将所有信息都补全。但是在项目完结的时候,是需要撰写这样的一个文档的。
可以参考Redis源码中Readme的写法,这里面简洁但是清晰的描述了Redis功能和源码结构。
关于requirements.txt和setup.py
setup.py
一般来说,用setup.py
来管理代码的打包、安装、部署问题。业界标准的写法是用Python流行的打包工具setuptools来管理这些事情。这种方式普遍应用于开源项目中。不过这里的核心思想不是用标准化的工具来解决这些问题,而是说,一个项目一定要有一个安装部署工具,能快速便捷的在一台新机器上将环境装好、代码部署好和将程序运行起来。
这个我是踩过坑的。
我刚开始接触Python写项目的时候,安装环境、部署代码、运行程序这个过程全是手动完成,遇到过以下问题:
- 安装环境时经常忘了最近又添加了一个新的Python包,结果一到线上运行,程序就出错了。
- Python包的版本依赖问题,有时候我们程序中使用的是一个版本的Python包,但是官方的已经是最新的包了,通过手动安装就可能装错了。
- 如果依赖的包很多的话,一个一个安装这些依赖是很费时的事情。
- 新同学开始写项目的时候,将程序跑起来非常麻烦,因为可能经常忘了要怎么安装各种依赖。
setup.py
可以将这些事情自动化起来,提高效率、减少出错的概率。"复杂的东西自动化,能自动化的东西一定要自动化。"是一个非常好的习惯。
setuptools的文档比较庞大,刚接触的话,可能不太好找到切入点。学习技术的方式就是看他人是怎么用的,可以参考一下Python的一个Web框架,flask是如何写的: setup.py
当然,简单点自己写个安装脚本(deploy.sh
)替代setup.py
也未尝不可。
requirements.txt
这个文件存在的目的是:
- 方便开发者维护软件的包依赖。将开发过程中新增的包添加进这个列表中,避免在
setup.py
安装依赖时漏掉软件包。 - 方便读者明确项目使用了哪些Python包。
这个文件的格式是每一行包含一个包依赖的说明,通常是flask>=0.10
这种格式,要求是这个格式能被pip
识别,这样就可以简单的通过 pip install -r requirements.txt
来把所有Python包依赖都装好了。具体格式说明: 点这里。
关于配置文件的使用方法
注意,在上面的目录结构中,没有将conf.py
放在源码目录下,而是放在docs/
目录下。
很多项目对配置文件的使用做法是:
- 配置文件写在一个或多个python文件中,比如此处的conf.py。
- 项目中哪个模块用到这个配置文件就直接通过
import conf
这种形式来在代码中使用配置。
这种做法我不太赞同:
- 这让单元测试变得困难(因为模块内部依赖了外部配置)
- 另一方面配置文件作为用户控制程序的接口,应当可以由用户自由指定该文件的路径。
- 程序组件可复用性太差,因为这种贯穿所有模块的代码硬编码方式,使得大部分模块都依赖
conf.py
这个文件。
所以,我认为配置的使用,更好的方式是,
- 模块的配置都是可以灵活配置的,不受外部配置文件的影响。
- 程序的配置也是可以灵活控制的。
能够佐证这个思想的是,用过nginx和mysql的同学都知道,nginx、mysql这些程序都可以自由的指定用户配置。
所以,不应当在代码中直接import conf
来使用配置文件。上面目录结构中的conf.py
,是给出的一个配置样例,不是在写死在程序中直接引用的配置文件。可以通过给main.py
启动参数指定配置路径的方式来让程序读取配置内容。当然,这里的conf.py
你可以换个类似的名字,比如settings.py
。或者你也可以使用其他格式的内容来编写配置文件,比如settings.yaml
之类的。
使用python进行程序编写时,经常会使用第三方模块包。这种包我们可以通过python setup install 进行安装后,通过import XXX或from XXX import yyy 进行导入。不过如果是自己遍写的依赖包,又不想安装到python的相应目录,可以放到本目录里进行import进行调用;为了更清晰的理清程序之间的关系,例如我们会把这种包放到lib目录再调用。本篇就针对常见的模块调用方法汇总下。
一、同级目录下的调有
程序结构如下:
-- src
|-- mod1.py
|-- test1.py
若在程序test1.py中导入模块mod1, 则直接使用
import mod1
或
from mod1 import *;
二、调用子目录下的模块
程序结构如下:
-- src
|-- mod1.py
|-- lib
| |-- mod2.py
|-- test1.py
这时看到test1.py和lib目录(即mod2.py的父级目录),如果想在程序test1.py中导入模块mod2.py ,可以在lib件夹中建立空文件__init__.py文件(也可以在该文件中自定义输出模块接口),然后使用:
from lib.mod2 import *
或
import lib.mod2.
三、调用上级目录下的文件
程序结构如下:
-- src
|-- mod1.py
|-- lib
| |-- mod2.py
|-- sub
| |-- test2.py
这里想要实现test2.py调用mod1.py和mod2.py ,做法是我们先跳到src目录下面,直接可以调用mod1,然后在lib上当下建一个空文件__init__.py ,就可以像第二步调用子目录下的模块一样,通过import lib.mod2进行调用了。具体代码如下:
import sys sys.path.append("..") import mod1 import mod2.mod2
从一个目录调用另一个目录下文件
找到文件根目录
import os,sys BASE_DIR = os.path.dirname(os.path.abspath(__file__)) #os.path.abspath(__file__)为文件绝对路径 #os.path.dirname为文件目录。再上级目录再加一次os.path.dirname,依此类推。。。 sys.path.append(BASE_DIR) #添加环境变量
python import及模块本质
模块的定义:
用来从逻辑上组织python代码(变量,函数,类,逻辑:实现一个功能),本质上就是.py结尾的python文件。
包的定义:
用来从逻辑上组织模块的,本质上就是一个目录。(必须有一个__init__.py文件)
导入模块方法:
1、创建模块
比如创建一个 module_name.py ,里面可以定义函数和变量。
2、导入模块
导入一个:
import module_name
导入多个:
import module_name,import module_name1
导入一个模块所有的方法或变量:
from module_name import *
from module_name import 方法名 [ as 别名]
from module_name import 方法名1 [ as 别名1],方法名2 [ as 别名2].。。。
from..import.. 这种方法比 直接import 模块 要执行的快,因为不需要点语法调用方法,所以也不需要每次调用每次都去找那个模块文件。
3、使用模块的变量或方法
1、直接 import module_name 导入进来的
module_name.变量名 或 module_name.方法名 。这种相当于把 module_name.py中的代码解释一遍统一赋值给一个变量。
2、from module_name import 方法名 [ as 别名] 这种方法导入进来的
可以直接使用。变量名、方法名、 别名。这个相当于把代码复制一份到新文件里面。所以不需要点语法调用。
导入包方法:
import package_name
导入这个包实际上在执行包里面的__init__.py文件
import本质(路径搜索)
模块导入:
import module_name -->找到module_name.py文件 --->找到module_name.py的路径 --->sys.path中(第一个空的是当前目录)依次寻找。
如果sys.path中没有要找的路径,意思是要导入的模块文件不再同一个目录,需要通过sys和os模块把要导入的模块的路径加入到sys.path中
1、通过os.path.abspath(__file__) 获取当前文件路径。
2、通过os.path.dirname(os.path.abspath(__file__)) 找到上级路径。直到找到模块所在的路径下。
3、追加到sys.path路径下 sys.path.append(要添加的路径)。
包导入:
1、首先导入一个包 也是import ,那么实际执行的动作是执行包里的__init__.py这个文件。
2、包里面肯定定义了很多模块,不然只执行这个文件没有意义。这个文件的作用就是把模块的导入写到这个文件里面。from . import module_name 导入当前路径下的哪个模块。
3、调用某个包下的某个模块下的某个方法:package_name.module_name.方法
4、如果包的目录和程序的目录不一致,可以先加载包的最外层目录到sys.path,然后 from dir_name import package_name
模块分类
1、模块:
定义:其实模块简单说就是一堆代码实现某个功能,它们是已经写好的.py文件。只需要用import应用即可。
分类:
1、自定义模块
2、内置标准模块(又称标准库)
3、开源模块
1、自定义模块,就是自己写的.py文件为了实现某个功能。
2、内置模块,就是python自身已经写好的某个功能,例如经常用的sys、os等模块都是内置模块。
3、开源模块,开源大家都明白吧,就是不收费的别人写好的模块,一般也称第三方模块。
模块的引用:
1、import modules
2、from modules import 函数
3、如果有多个模块,可以用逗号隔开,如果想把某个模块里面的所有功能都导入,可以用*,这样的话功能都加载道内存里面,占用内存资源,不建议用。
time &datetime模块
import time import datetime time print(time.clock()) #返回处理器时间,3.3以后废弃 4.444098792316153e-07 print(time.process_time()) #返回处理器时间 0.031200199999999997 print(time.time()) #返回当前系统时间戳 1463472071.3892002 print(time.ctime()) #返回当前系统时间 Tue May 17 16:01:11 2016 print(time.ctime(time.time()-86400)) #转换成字符串格式 Mon May 16 16:01:11 2016 print(time.gmtime(time.time()-86400)) #将时间戳转换成struct_time格式 time.struct_time(tm_year=2016, tm_mon=5, tm_mday=16, tm_hour=8, tm_min=1, tm_sec=11, tm_wday=0, tm_yday=137, tm_isdst=0) print(time.localtime(time.time()-86400)) #将时间戳转换成struct_time格式,本地时间。 time.struct_time(tm_year=2016, tm_mon=5, tm_mday=16, tm_hour=16, tm_min=13, tm_sec=25, tm_wday=0, tm_yday=137, tm_isdst=0) print(time.mktime(time.localtime())) #与time.localtime()功能相反,将struct_time格式转回成时间戳格式 1463472904.0 time.sleep(4) #sleep 每隔四秒以执行 print(time.strftime("%Y-%m-%d %H:%M:%S",time.gmtime()) ) #将struct_time格式转成指定的字符串格式 2016-05-17 08:16:22 datetime print(datetime.date.today()) #输出格式 2016-05-17 print(datetime.date.fromtimestamp(time.time()-86400) ) # 将时间戳转成日期格式 2016-05-16 current_time = datetime.datetime.now() # print(current_time) #输出2016-05-17 16:17:59.863200 print(current_time.timetuple()) #返回struct_time格式 time.struct_time(tm_year=2016, tm_mon=5, tm_mday=17, tm_hour=16, tm_min=17, tm_sec=59, tm_wday=1, tm_yday=138, tm_isdst=-1) #datetime.replace([year[, month[, day[, hour[, minute[, second[, microsecond[, tzinfo]]]]]]]]) print(current_time.replace(2016,5,17)) #输出2016-05-17 16:19:33.753200,返回当前时间,但指定的值将被替换 str_to_date = datetime.datetime.strptime("21/11/06 16:30", "%d/%m/%y %H:%M") #将字符串转换成日期格式 new_date1 = datetime.datetime.now() + datetime.timedelta(days=10) #比现在加10天 2016-05-27 16:21:16.279200 new_date2 = datetime.datetime.now() + datetime.timedelta(days=-10) #比现在减10天 2016-05-07 16:21:44.459200 new_date3 = datetime.datetime.now() + datetime.timedelta(hours=-10) #比现在减10小时 2016-05-17 06:22:01.299200 new_date4 = datetime.datetime.now() + datetime.timedelta(seconds=120) #比现在+120s 2016-05-17 16:24:10.917200 new_date5 = datetime.datetime.now() + datetime.timedelta(weeks=20) #比现在+10周 2016-10-04 16:23:02.904200 print(new_date5)
random
#!/usr/bin/env python #—*—coding:utf-8—*— import random #随机数 # print(random.random())#0到的随机数,是一个float浮点数 # print(random.randint(1,9))#一到九随机 # print(random.randrange(1,10))#一到十随机(记得range只有头没有尾巴) 原型random.randrange([start], stop[, step]) # # 生成随机验证码 # # checkcode='' # for i in range(5): # current = random.randrange(0,5) # if current == i: # tmp = chr(random.randint(65,90))#chr是ascii码表,65,90是(A-Z) # else: # tmp = random.randint(0,9) # checkcode +=str(tmp) # print(checkcode) #二般 import string # print(''.join(random.sample(string.ascii_lowercase+string.digits,5)))#随机验证码可用(5位含数字和密码) # # print(''.join(random.sample(string.ascii_lowercase+string.digits,5)))#随机验证码可用(5位含数字和密码) # # #打印a-z # print(string.ascii_lowercase)#一 # #打印A-Z # print(string.ascii_letters)#二
os模块
#!/usr/bin/env python # import os # # print(os.getcwd())#打印当前目录 # os.getcwd() 获取当前工作目录,即当前python脚本工作的目录路径 # os.chdir("dirname") 改变当前脚本工作目录;相当于shell下cd # os.curdir 返回当前目录: ('.') # os.pardir 获取当前目录的父目录字符串名:('..') # os.makedirs('dirname1/dirname2') 可生成多层递归目录 # 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所指向的文件或者目录的最后修改时间 #更多 #https://docs.python.org/2/library/os.html?highlight=os#module-os
sys
#!/usr/bin/env python #—*—coding:utf-8—*— import sys # print(sys.argv ) #命令行参数List,第一个元素是程序本身路径 #>>>['E:/python/day5/sys(1).py'] # sys.exit(n) #退出程序,正常退出时exit(0) # print(sys.version ) #获取Python解释程序的版本信息 # >>>3.5.1 (v3.5.1:37a07cee5969, Dec 6 2015, 01:38:48) [MSC v.1900 32 bit (Intel)] # print(sys.maxint) #最大的Int值 # sys.path #返回模块的搜索路径,初始化时使用PYTHONPATH环境变量的值 # print(sys.platform) #返回操作系统平台名称 # >>>win32 # print(sys.stdout.write('please:')) # >>>please:7 # val = sys.stdin.readline()[:-1]
shutil
高级的文件文件夹压缩包处理模块
#!/usr/bin/env python import shutil # shutil.copyfileobj(fsrc, fdst[, length]) # 将文件内容拷贝到另一个文件中,可以部分内容 # shutil.copyfile(src, dst) # 拷贝文件 # shutil.copymode(src, dst) # 仅拷贝权限。内容、组、用户均不变 # shutil.copystat(src, dst) # 拷贝状态的信息,包括:mode bits, atime, mtime, flags # shutil.copy(src, dst) # 拷贝文件和权限 # shutil.copy2(src, dst) # 拷贝文件和状态信息 # shutil.rmtree(path[, ignore_errors[, onerror]]) # 递归的去删除文件 # shutil.move(src, dst) # 递归的去移动文件(删除文件) shutil.make_archive(base_name, format,...) 创建压缩包并返回文件路径,例如:zip、tar base_name: 压缩包的文件名,也可以是压缩包的路径。只是文件名时,则保存至当前目录,否则保存至指定路径, 如:www =>保存至当前路径 如:/Users/wupeiqi/www =>保存至/Users/wupeiqi/ format: 压缩包种类,“zip”, “tar”, “bztar”,“gztar” root_dir: 要压缩的文件夹路径(默认当前目录) owner: 用户,默认当前用户 group: 组,默认当前组 logger: 用于记录日志,通常是logging.Logger对象 #将 /Users/wupeiqi/Downloads/test 下的文件打包放置当前程序目录 import shutil ret = shutil.make_archive("wwwwwwwwww", 'gztar', root_dir='/Users/wupeiqi/Downloads/test') #将 /Users/wupeiqi/Downloads/test 下的文件打包放置 /Users/wupeiqi/目录 import shutil ret = shutil.make_archive("/Users/wupeiqi/wwwwwwwwww", 'gztar', root_dir='/Users/wupeiqi/Downloads/test')
shelve
import shelve d = shelve.open('shelve_test') #写 # name = {"zhangsan","lisi","wanger"} # info = {"age":25,"job":"IT"} # d["name"] = name # d["info"] = info # d.close() #写完以后,它会自动生成三个文件,.dat和.dir和.bak #读 # print(d.get("name")) # print(d.get("info"))
xml处理
<?xml version="1.0"?> <data> <country name="Liechtenstein"> <rank updated="yes">2</rank> <year>2008</year> <gdppc>141100</gdppc> <neighbor name="Austria" direction="E"/> <neighbor name="Switzerland" direction="W"/> </country> <country name="Singapore"> <rank updated="yes">5</rank> <year>2011</year> <gdppc>59900</gdppc> <neighbor name="Malaysia" direction="N"/> </country> <country name="Panama"> <rank updated="yes">69</rank> <year>2011</year> <gdppc>13600</gdppc> <neighbor name="Costa Rica" direction="W"/> <neighbor name="Colombia" direction="E"/> </country> </data>
#!/usr/bin/env python #—*—coding:utf-8—*— import xml.etree.ElementTree as ET tree = ET.parse("xml.xml") root = tree.getroot() print(root.tag) #遍历xml文档 # for child in root: # print(child.tag, child.attrib) # for i in child: # print(i.tag,i.text) #>>>结果 # data # country {'name': 'Liechtenstein'} # rank 2 # year 2008 # gdppc 141100 # neighbor None # neighbor None # country {'name': 'Singapore'} # rank 5 # year 2011 # gdppc 59900 # neighbor None # country {'name': 'Panama'} # rank 69 # year 2011 # gdppc 13600 # neighbor None # neighbor None #只遍历year 节点 # for node in root.iter('year'): # print(node.tag,node.text) # >>>data # >>>year2008 # >>>year 2011 # >>>year 2011
yaml处理
yaml和xml差不多,只是需要自己安装一个模块,参考链接:参考文档:http://pyyaml.org/wiki/PyYAMLDocumentation
configparser
这个比较好玩一点,大家多知道mysql配置文件my.cnf文件的格式吧
#类似这样的配置文件,一块一块的分类 [DEFAULT] ServerAliveInterval = 45 Compression = yes CompressionLevel = 9 ForwardX11 = yes [bitbucket.org] User = hg [topsecret.server.com] Port = 50022 ForwardX11 = no
#生成类似格式的文件 import configparser config = configparser.ConfigParser() config["DEFAULT"] = {'ServerAliveInterval': '45', 'Compression': 'yes', 'CompressionLevel': '9'} config['bitbucket.org'] = {} config['bitbucket.org']['User'] = 'hg' config['topsecret.server.com'] = {} topsecret = config['topsecret.server.com'] topsecret['Host Port'] = '50022' # mutates the parser topsecret['ForwardX11'] = 'no' # same here config['DEFAULT']['ForwardX11'] = 'yes' with open('example.ini', 'w') as configfile: config.write(configfile)
#读 # import configparser # config = configparser.ConfigParser() # config.sections() # # config.read('example.ini') # # print(config.defaults()) # >>>OrderedDict([('compressionlevel', '9'), ('compression', 'yes'), ('serveraliveinterval', '45'), ('forwardx11', 'yes')]) # print(config['bitbucket.org']["User"]) # >>>hg # print(config["topsecret.server.com"]["host port"]) # 50022
#删除(创建一个新文件,并删除bitbucket.org) import configparser config = configparser.ConfigParser() config.sections() config.read('example.ini') rec = config.remove_section("bitbucket.org")#删除该项 config.write(open("example.cfg","w")) [DEFAULT] compressionlevel = 9 compression = yes serveraliveinterval = 45 forwardx11 = yes [topsecret.server.com] host port = 50022 forwardx11 = no
hashlib
用于加密相关的操作
#!/usr/bin/env python import hashlib # m = hashlib.md5() # m.update(b"hello") # print(m.digest())#进行二进制加密 # print(len(m.hexdigest())) #16进制长度 # print(m.hexdigest())#16进制格式hash # >>>b']A@*\xbcK*v\xb9q\x9d\x91\x10\x17\xc5\x92' # >>>32 # >>>5d41402abc4b2a76b9719d911017c592 #md5 # hash = hashlib.md5() # hash.update(('admin').encode()) # print(hash.hexdigest()) # >>>21232f297a57a5a743894a0e4a801fc3 #sha1 # hash = hashlib.sha1() # hash.update(('admin').encode()) # print(hash.hexdigest()) # >>>d033e22ae348aeb5660fc2140aec35850c4da997 #sha256 # hash = hashlib.sha256() # hash.update(('admin').encode()) # print(hash.hexdigest()) # >>>8c6976e5b5410415bde908bd4dee15dfb167a9c873fc4bb8a81f6f2ab448a918 #sha384 # hash = hashlib.sha384() # hash.update(('admin').encode()) # print(hash.hexdigest()) # >>>9ca694a90285c034432c9550421b7b9dbd5c0f4b6673f05f6dbce58052ba20e4248041956ee8c9a2ec9f10290cdc0782 #sha512 # hash = hashlib.sha512() # hash.update(('admin').encode()) # print(hash.hexdigest()) # >>>c7ad44cbad762a5da0a452f9e854fdc1e0e7a52a38015f23f3eab1d80b931dd472634dfac71cd34ebc35d16ab7fb8a90c81f975113d6c7538dc69dd8de9077ec #更吊的 import hmac h = hmac.new(('wueiqi').encode()) h.update(('hellowo').encode()) print(h.hexdigest()) #更多关于md5,sha1,sha256等介绍的文章看这里https://www.tbs-certificates.co.uk/FAQ/en/sha256.html
subprocess
调用shell
对os.system
os.spawm的替换
logging模块简介
Python的logging模块提供了通用的日志系统,可以方便第三方模块或者是应用使用。这个模块提供不同的日志级别,并可以采用不同的方式记录日志,比如文件,HTTP GET/POST,SMTP,Socket等,甚至可以自己实现具体的日志记录方式。
logging模块与log4j的机制是一样的,只是具体的实现细节不同。模块提供logger,handler,filter,formatter。
- logger:提供日志接口,供应用代码使用。logger最长用的操作有两类:配置和发送日志消息。可以通过logging.getLogger(name)获取logger对象,如果不指定name则返回root对象,多次使用相同的name调用getLogger方法返回同一个logger对象。
- handler:将日志记录(log record)发送到合适的目的地(destination),比如文件,socket等。一个logger对象可以通过addHandler方法添加0到多个handler,每个handler又可以定义不同日志级别,以实现日志分级过滤显示。
- filter:提供一种优雅的方式决定一个日志记录是否发送到handler。
- formatter:指定日志记录输出的具体格式。formatter的构造方法需要两个参数:消息的格式字符串和日期字符串,这两个参数都是可选的。
与log4j类似,logger,handler和日志消息的调用可以有具体的日志级别(Level),只有在日志消息的级别大于logger和handler的级别。
logging用法解析
1. 初始化 logger = logging.getLogger("endlesscode"),getLogger()方法后面最好加上所要日志记录的模块名字,后面的日志格式中的%(name)s 对应的是这里的模块名字
2. 设置级别 logger.setLevel(logging.DEBUG),Logging中有NOTSET < DEBUG < INFO < WARNING < ERROR < CRITICAL这几种级别,日志会记录设置级别以上的日志
3. Handler,常用的是StreamHandler和FileHandler,windows下你可以简单理解为一个是console和文件日志,一个打印在CMD窗口上,一个记录在一个文件上
4. formatter,定义了最终log信息的顺序,结构和内容,我喜欢用这样的格式 '[%(asctime)s] [%(levelname)s] %(message)s', '%Y-%m-%d %H:%M:%S',
%(name)s Logger的名字
%(levelname)s 文本形式的日志级别
%(message)s 用户输出的消息
%(asctime)s 字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒
%(levelno)s 数字形式的日志级别
%(pathname)s 调用日志输出函数的模块的完整路径名,可能没有
%(filename)s 调用日志输出函数的模块的文件名
%(module)s 调用日志输出函数的模块名
%(funcName)s 调用日志输出函数的函数名
%(lineno)d 调用日志输出函数的语句所在的代码行
%(created)f 当前时间,用UNIX标准的表示时间的浮 点数表示
%(relativeCreated)d 输出日志信息时的,自Logger创建以 来的毫秒数
%(thread)d 线程ID。可能没有
%(threadName)s 线程名。可能没有
%(process)d 进程ID。可能没有
5. 记录 使用object.debug(message)来记录日志
下面来写一个实例,在CMD窗口上只打出error以上级别的日志,但是在日志中打出debug以上的信息
import logging logger = logging.getLogger("simple_example") logger.setLevel(logging.DEBUG) # 建立一个filehandler来把日志记录在文件里,级别为debug以上 fh = logging.FileHandler("spam.log") fh.setLevel(logging.DEBUG) # 建立一个streamhandler来把日志打在CMD窗口上,级别为error以上 ch = logging.StreamHandler() ch.setLevel(logging.ERROR) # 设置日志格式 formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s") ch.setFormatter(formatter) fh.setFormatter(formatter) #将相应的handler添加在logger对象中 logger.addHandler(ch) logger.addHandler(fh) # 开始打日志 logger.debug("debug message") logger.info("info message") logger.warn("warn message") logger.error("error message") logger.critical("critical message")
运行一下将会看到CMD窗口只记录两条,spam.log中记录了五条日志
除了这些基本用法,还有一些常见的小技巧可以分享一下。
# 格式化输出 service_name = "Booking" logger.error('%s service is down!' % service_name) # 使用python自带的字符串格式化,不推荐 logger.error('%s service is down!', service_name) # 使用logger的格式化,推荐 logger.error('%s service is %s!', service_name, 'down') # 多参数格式化 logger.error('{} service is {}'.format(service_name, 'down')) # 使用format函数,推荐 # 2016-10-08 21:59:19,493 ERROR : Booking service is down!
记录异常信息
当你使用logging模块记录异常信息时,不需要传入该异常对象,只要你直接调用logger.error()
或者 logger.exception()
就可以将当前异常记录下来。
# 记录异常信息 try: 1 / 0 except: # 等同于error级别,但是会额外记录当前抛出的异常堆栈信息 logger.exception('this is an exception message') # 2016-10-08 21:59:19,493 ERROR : this is an exception message # Traceback (most recent call last): # File "D:/Git/py_labs/demo/use_logging.py", line 45, in # 1 / 0 # ZeroDivisionError: integer division or modulo by zero
logging配置要点
GetLogger()方法
这是最基本的入口,该方法参数可以为空,默认的logger名称是root,如果在同一个程序中一直都使用同名的logger,其实会拿到同一个实例,使用这个技巧就可以跨模块调用同样的logger来记录日志。
另外你也可以通过日志名称来区分同一程序的不同模块,比如这个例子。
logger = logging.getLogger("App.UI") logger = logging.getLogger("App.Service")
Formatter日志格式
Formatter对象定义了log信息的结构和内容,构造时需要带两个参数:
- 一个是格式化的模板
fmt
,默认会包含最基本的level
和message
信息 - 一个是格式化的时间样式
datefmt
,默认为2003-07-08 16:49:45,896 (%Y-%m-%d %H:%M:%S)
fmt
中允许使用的变量可以参考下表。
- %(name)s Logger的名字
- %(levelno)s 数字形式的日志级别
- %(levelname)s 文本形式的日志级别
- %(pathname)s 调用日志输出函数的模块的完整路径名,可能没有
- %(filename)s 调用日志输出函数的模块的文件名
- %(module)s 调用日志输出函数的模块名|
- %(funcName)s 调用日志输出函数的函数名|
- %(lineno)d 调用日志输出函数的语句所在的代码行
- %(created)f 当前时间,用UNIX标准的表示时间的浮点数表示|
- %(relativeCreated)d 输出日志信息时的,自Logger创建以来的毫秒数|
- %(asctime)s 字符串形式的当前时间。默认格式是“2003-07-08 16:49:45,896”。逗号后面的是毫秒
- %(thread)d 线程ID。可能没有
- %(threadName)s 线程名。可能没有
- %(process)d 进程ID。可能没有
- %(message)s 用户输出的消息
SetLevel 日志级别
Logging有如下级别: DEBUG,INFO,WARNING,ERROR,CRITICAL
默认级别是WARNING,logging模块只会输出指定level以上的log。这样的好处, 就是在项目开发时debug用的log,在产品release阶段不用一一注释,只需要调整logger的级别就可以了,很方便。
Handler 日志处理器
最常用的是StreamHandler和FileHandler, Handler用于向不同的输出端打log。
Logging包含很多handler, 可能用到的有下面几种
- StreamHandler instances send error messages to streams (file-like objects).
- FileHandler instances send error messages to disk files.
- RotatingFileHandler instances send error messages to disk files, with support for maximum log file sizes and log file rotation.
- TimedRotatingFileHandler instances send error messages to disk files, rotating the log file at certain timed intervals.
- SocketHandler instances send error messages to TCP/IP sockets.
- DatagramHandler instances send error messages to UDP sockets.
- SMTPHandler instances send error messages to a designated email address.
Configuration 配置方法
logging的配置大致有下面几种方式。
- 通过代码进行完整配置,参考开头的例子,主要是通过getLogger方法实现。
- 通过代码进行简单配置,下面有例子,主要是通过basicConfig方法实现。
- 通过配置文件,下面有例子,主要是通过
logging.config.fileConfig(filepath)
logging.basicConfig
basicConfig()
提供了非常便捷的方式让你配置logging模块并马上开始使用,可以参考下面的例子。具体可以配置的项目请查阅官方文档。
import logging logging.basicConfig(filename='example.log',level=logging.DEBUG) logging.debug('This message should go to the log file') logging.basicConfig(format='%(levelname)s:%(message)s', level=logging.DEBUG) logging.debug('This message should appear on the console') logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %I:%M:%S %p') logging.warning('is when this event was logged.')
备注: 其实你甚至可以什么都不配置直接使用默认值在控制台中打log,用这样的方式替换print语句对日后项目维护会有很大帮助。
通过文件配置logging
如果你希望通过配置文件来管理logging,可以参考这个官方文档。在log4net或者log4j中这是很常见的方式。
# logging.conf [loggers] keys=root [logger_root] level=DEBUG handlers=consoleHandler #,timedRotateFileHandler,errorTimedRotateFileHandler ################################################# [handlers] keys=consoleHandler,timedRotateFileHandler,errorTimedRotateFileHandler [handler_consoleHandler] class=StreamHandler level=DEBUG formatter=simpleFormatter args=(sys.stdout,) [handler_timedRotateFileHandler] class=handlers.TimedRotatingFileHandler level=DEBUG formatter=simpleFormatter args=('debug.log', 'H') [handler_errorTimedRotateFileHandler] class=handlers.TimedRotatingFileHandler level=WARN formatter=simpleFormatter args=('error.log', 'H') ################################################# [formatters] keys=simpleFormatter, multiLineFormatter [formatter_simpleFormatter] format= %(levelname)s %(threadName)s %(asctime)s: %(message)s datefmt=%H:%M:%S [formatter_multiLineFormatter] format= ------------------------- %(levelname)s ------------------------- Time: %(asctime)s Thread: %(threadName)s File: %(filename)s(line %(lineno)d) Message: %(message)s datefmt=%Y-%m-%d %H:%M:%S
假设以上的配置文件放在和模块相同的目录,代码中的调用如下。
import os filepath = os.path.join(os.path.dirname(__file__), 'logging.conf') logging.config.fileConfig(filepath) return logging.getLogger()
Python之re模块 —— 正则表达式操作[原创]
这个模块提供了与 Perl 相似l的正则表达式匹配操作。Unicode字符串也同样适用。
正则表达式使用反斜杠" \ "来代表特殊形式或用作转义字符,这里跟Python的语法冲突,因此,Python用" \\\\ "表示正则表达式中的" \ ",因为正则表达式中如果要匹配" \ ",需要用\来转义,变成" \\ ",而Python语法中又需要对字符串中每一个\进行转义,所以就变成了" \\\\ "。
上面的写法是不是觉得很麻烦,为了使正则表达式具有更好的可读性,Python特别设计了原始字符串(raw string),需要提醒你的是,在写文件路径的时候就不要使用raw string了,这里存在陷阱。raw string就是用'r'作为字符串的前缀,如 r"\n":表示两个字符"\"和"n",而不是换行符了。Python中写正则表达式时推荐使用这种形式。
绝大多数正则表达式操作与 模块级函数或RegexObject方法 一样都能达到同样的目的。而且不需要你一开始就编译正则表达式对象,但是不能使用一些实用的微调参数。
1.正则表达式语法
为了节省篇幅,这里不再叙述了。
2.martch和search的区别
Python提供了两种不同的原始操作:match和search。match是从字符串的起点开始做匹配,而search(perl默认)是从字符串做任意匹配。
注意:当正则表达式是' ^ '开头时,match与search是相同的。match只有当且仅当被匹配的字符串开头就能匹配 或 从pos参数的位置开始就能匹配 时才会成功。如下:
>>> import re
>>> re.match("c", "abcdef")
>>> re.search("c","abcdef")
<_sre.SRE_Match object at 0x00A9A988>
>>> re.match("c", "cabcdef")
<_sre.SRE_Match object at 0x00A9AB80>
>>> re.search("c","cabcdef")
<_sre.SRE_Match object at 0x00AF1720>
>>> patterm = re.compile("c")
>>> patterm.match("abcdef")
>>> patterm.match("abcdef",1)
>>> patterm.match("abcdef",2)
<_sre.SRE_Match object at 0x00A9AB80>
3.模块内容
re.compile(pattern, flags=0)
编译正则表达式,返回RegexObject对象,然后可以通过RegexObject对象调用match()和search()方法。
prog = re.compile(pattern)
result = prog.match(string)
跟
result = re.match(pattern, string)
是等价的。
第一种方式能实现正则表达式的重用。
re.search(pattern, string, flags=0)
在字符串中查找,是否能匹配正则表达式。返回_sre.SRE_Match对象,如果不能匹配返回None。
re.match(pattern, string, flags=0)
字符串的开头是否能匹配正则表达式。返回_sre.SRE_Match对象,如果不能匹配返回None。
re.split(pattern, string, maxsplit=0)
通过正则表达式将字符串分离。如果用括号将正则表达式括起来,那么匹配的字符串也会被列入到list中返回。maxsplit是分离的次数,maxsplit=1分离一次,默认为0,不限制次数。
>>> re.split('\W+', 'Words, words, words.')
['Words', 'words', 'words', '']
>>> re.split('(\W+)', 'Words, words, words.')
['Words', ', ', 'words', ', ', 'words', '.', '']
>>> re.split('\W+', 'Words, words, words.', 1)
['Words', 'words, words.']
>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
注意:我使用的Python是2.6,查看源代码发现split()并没有flags的参数,2.7才增加。这种问题我发现不止一次了,官方的文档 跟 源码不一致的现象,如果发现异常,应该去源码中找找原因。
如果在字符串的开始或结尾就匹配,返回的list将会以空串开始或结尾。
>>> re.split('(\W+)', '...words, words...')
['', '...', 'words', ', ', 'words', '...', '']
如果字符串不能匹配,将会返回整个字符串的list。
>>> re.split("a","bbb")
['bbb']
re.findall(pattern, string, flags=0)
找到 RE 匹配的所有子串,并把它们作为一个列表返回。这个匹配是从左到右有序地返回。如果无匹配,返回空列表。
>>> re.findall("a","bcdef")
[]
>>> re.findall(r"\d+","12a32bc43jf3")
['12', '32', '43', '3']
re.finditer(pattern, string, flags=0)
找到 RE 匹配的所有子串,并把它们作为一个迭代器返回。这个匹配是从左到右有序地返回。如果无匹配,返回空列表。
>>> it = re.finditer(r"\d+","12a32bc43jf3")
>>> for match in it:
print match.group()
12
32
43
3
re.sub(pattern, repl, string, count=0, flags=0)
找到 RE 匹配的所有子串,并将其用一个不同的字符串替换。可选参数 count 是模式匹配後替换的最大次数;count 必须是非负整数。缺省值是 0 表示替换所有的匹配。如果无匹配,字符串将会无改变地返回。
re.subn(pattern, repl, string, count=0, flags=0)
与re.sub方法作用一样,但返回的是包含新字符串和替换执行次数的两元组。
re.escape(string)
对字符串中的非字母数字进行转义
re.purge()
清空缓存中的正则表达式
4.正则表达式对象
re.RegexObject
re.compile()返回RegexObject对象
re.MatchObject
group()返回被 RE 匹配的字符串
start()返回匹配开始的位置
end()返回匹配结束的位置
span()返回一个元组包含匹配 (开始,结束) 的位置
5.编译标志
编译标志让你可以修改正则表达式的一些运行方式。在 re 模块中标志可以使用两个名字,一个是全名如 IGNORECASE,一个是缩写,一字母形式如 I。(如果你熟悉 Perl 的模式修改,一字母形式使用同样的字母;例如 re.VERBOSE的缩写形式是 re.X。)多个标志可以通过按位 OR-ing 它们来指定。如 re.I | re.M 被设置成 I 和 M 标志:
I
IGNORECASE
使匹配对大小写不敏感;字符类和字符串匹配字母时忽略大小写。举个例子,[A-Z]也可以匹配小写字母,Spam 可以匹配 "Spam", "spam", 或 "spAM"。这个小写字母并不考虑当前位置。
L
LOCALE
影响 "w, "W, "b, 和 "B,这取决于当前的本地化设置。
locales 是 C 语言库中的一项功能,是用来为需要考虑不同语言的编程提供帮助的。举个例子,如果你正在处理法文文本,你想用 "w+ 来匹配文字,但 "w 只匹配字符类 [A-Za-z];它并不能匹配 "é" 或 "?"。如果你的系统配置适当且本地化设置为法语,那么内部的 C 函数将告诉程序 "é" 也应该被认为是一个字母。当在编译正则表达式时使用 LOCALE 标志会得到用这些 C 函数来处理 "w 後的编译对象;这会更慢,但也会象你希望的那样可以用 "w+ 来匹配法文文本。
M
MULTILINE
(此时 ^ 和 $ 不会被解释; 它们将在 4.1 节被介绍.)
使用 "^" 只匹配字符串的开始,而 $ 则只匹配字符串的结尾和直接在换行前(如果有的话)的字符串结尾。当本标志指定後, "^" 匹配字符串的开始和字符串中每行的开始。同样的, $ 元字符匹配字符串结尾和字符串中每行的结尾(直接在每个换行之前)。
S
DOTALL
使 "." 特殊字符完全匹配任何字符,包括换行;没有这个标志, "." 匹配除了换行外的任何字符。
X
VERBOSE
该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。当该标志被指定时,在 RE 字符串中的空白符被忽略,除非该空白符在字符类中或在反斜杠之後;这可以让你更清晰地组织和缩进 RE。它也可以允许你将注释写入 RE,这些注释会被引擎忽略;注释用 "#"号 来标识,不过该符号不能在字符串或反斜杠之後。
最后:如果能用字符串的方法,就不要选择正则表达式,因为字符串方法更简单快速。