Python学习笔记-常用模块
1.python模块
如果你退出 Python 解释器并重新进入,你做的任何定义(变量和方法)都会丢失。因此,如果你想要编写一些更大的程序,为准备解释器输入使用一个文本编辑器会更好,并以那个文件替代作为输入执行。这就是传说中的 脚本。随着你的程序变得越来越长,你可能想要将它分割成几个更易于维护的文件。你也可能想在不同的程序中使用顺手的函数,而不是把代码在它们之间中拷来拷去。
为了满足这些需要,Python 提供了一个方法可以从文件中获取定义,在脚本或者解释器的一个交互式实例中使用。这样的文件被称为 模块;模块中的定义可以 导入 到另一个模块或 主模块 中(在脚本执行时可以调用的变量集位于最高级,并且处于计算器模式)。
模块是包括 Python 定义和声明的文件。文件名就是模块名加上 .py
后缀。模块的模块名(做为一个字符串)可以由全局变量 __name__
得到。例如,你可以用自己惯用的文件编辑器在当前目录下创建一个叫 fibo.py 的文件,录入如下内容:
# Fibonacci numbers module
def fib(n): # write Fibonacci series up to n
a, b = 0, 1
while b < n:
print(b, end=' ')
a, b = b, a+b
print()
def fib2(n): # return Fibonacci series up to n
result = []
a, b = 0, 1
while b < n:
result.append(b)
a, b = b, a+b
return result
2.python导入模块
为了加快加载模块的速度,Python 会在 __pycache__
目录下以 module.version.pyc
名字缓存每个模块编译后的版本,这里的版本编制了编译后文件的格式。它通常会包含 Python 的版本号。例如,在 CPython 3.3 版中,spam.py 编译后的版本将缓存为__pycache__/spam.cpython-33.pyc
。这种命名约定允许由不同发布和不同版本的 Python 编译的模块同时存在。
Python 会检查源文件与编译版的修改日期以确定它是否过期并需要重新编译。这是完全自动化的过程。同时,编译后的模块是跨平台的,所以同一个库可以在不同架构的系统之间共享。
Python 不检查在两个不同环境中的缓存。首先,它会永远重新编译而且不会存储直接从命令行加载的模块。其次,如果没有源模块它不会检查缓存。若要支持没有源文件(只有编译版)的发布,编译后的模块必须在源目录下,并且必须没有源文件的模块。
方式1:import fibo
方式2:from shutil import copy
方式3:from shutil import *
这样可以导入所有除了以下划线( _
)开头的命名。
需要注意的是在实践中往往不鼓励从一个模块或包中使用 *
导入所有,因为这样会让代码变得很难读。不过,在交互式会话中这样用很方便省力。
出于性能考虑,每个模块在每个解释器会话中只导入一遍。因此,
如果你修改了你的模块,需要重启解释器;或者,如果你就是想交互式的测试这么一个模块,
可以用 imp.reload() 重新加载,例如 import imp; imp.reload(modulename)。
部分高级技巧:
3.使用python模块
这样做不会直接把 fibo
中的函数导入当前的语义表;它只是引入了模块名 fibo
。你可以通过模块名按如下方式访问这个函数:
>>> fibo.fib(1000)
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
如果打算频繁使用一个函数,你可以将它赋予一个本地变量:
>>> fib = fibo.fib
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
4.python常用模块
Python 带有一个标准模块库,并发布有独立的文档,名为 Python 库参考手册(此后称其为“库参考手册”)。有一些模块内置于解释器之中,这些操作的访问接口不是语言内核的一部分,但是已经内置于解释器了。这既是为了提高效率,也是为了给系统调用等操作系统原生访问提供接口。这类模块集合是一个依赖于底层平台的配置选项。例如,winreg 模块只提供在 Windows 系统上才有。有一个具体的模块值得注意: sys ,这个模块内置于所有的 Python 解释器。变量 sys.ps1
和 sys.ps2
定义了主提示符和辅助提示符字符串:
>>> import sys
>>> sys.ps1
'>>> '
>>> sys.ps2
'... '
>>> sys.ps1 = 'C> '
C> print('Yuck!')
Yuck!
C>
4.1time模块
Python 中提供了对时间日期的多种多样的处理方式,主要是在 time 和 datetime 这两个模块里
在 Python 文档里,time
是归类在Generic Operating System Services
中,换句话说, 它提供的功能是更加接近于操作系统层面的。通读文档可知,time 模块是围绕着 Unix Timestamp 进行的。
该模块主要包括一个类 struct_time
,另外其他几个函数及相关常量。 需要注意的是在该模块中的大多数函数是调用了所在平台C library
的同名函数, 所以要特别注意有些函数是平台相关的,可能会在不同的平台有不同的效果。另外一点是,由于是基于Unix Timestamp,所以其所能表述的日期范围被限定在 1970 - 2038 之间,如果你写的代码需要处理在前面所述范围之外的日期,那可能需要考虑使用datetime
模块更好。文档解释比较费劲,具体看看怎么用:
In [1]: import time
In [2]: time.time()
Out[2]: 1414332433.345712
In [3]: timestamp = time.time()
In [4]: time.gmtime(timestamp)
Out[4]: time.struct_time(tm_year=2014, tm_mon=10, tm_mday=26, tm_hour=14, tm_min=7, tm_sec=13, tm_wday=6, tm_yday=299, tm_isdst=0)
In [5]: time.localtime(timestamp)
Out[5]: time.struct_time(tm_year=2014, tm_mon=10, tm_mday=26, tm_hour=22, tm_min=7, tm_sec=13, tm_wday=6, tm_yday=299, tm_isdst=0)
In [6]: struct_time = time.localtime(timestamp)
In [7]: time.ctime(timestamp)
Out[7]: 'Sun Oct 26 22:07:13 2014'
In [8]: time.asctime(struct_time)
Out[8]: 'Sun Oct 26 22:07:13 2014'
In [9]: time.mktime(struct_time)
Out[9]: 1414332433.0
In [10]: time.strftime("%a, %d %b %Y %H:%M:%S +0000", struct_time)
Out[10]: 'Sun, 26 Oct 2014 22:07:13 +0000'
In [11]: time.strptime("30 Nov 00", "%d %b %y")
Out[11]: time.struct_time(tm_year=2000, tm_mon=11, tm_mday=30, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=335, tm_isdst=-1)
>>> print(time.altzone)#返回与utc时间的时间差,以秒计算
>>> print(time.localtime())#返回本地时间的struct time对象格式
>>> print(time.time())#1970年(UNIX时间诞生日)至今的时间戳(秒)
>>> print(time.gmtime(time.time()))#返回utc时间的struct时间对象格式
>>> print(time.asctime(time.gmtime(time.time())))#返回时间格式"Fri Aug 19 11:14:16 2016",
time.time()获取时间戳
time.gmtime()返回utc时间struct时间对象格式
time.asctime()格式化struct时间对象:"Fri Aug 19 11:14:16 2016"
Python time.ctime()与time.asctime()区别
time.ctime() 函数把一个时间戳(按秒计算的浮点数)转化为time.asctime()的形式。 如果参数未给或者为None的时候,将会默认time.time()为参数。它的作用相当于 asctime(localtime(secs))
>>> print(time.strptime('2016-11-11','%Y-%m-%d'))#将日期字符串转成struct时间对象格式
第一个参数为时间字符串,第二参数为对应的时间格式
>>> print(time.mktime(time.gmtime(time.time())))#将struct时间对象转成时间戳
time.time()获取当前时间戳
time.gmtime()转换utc时间为struct时间对象
time.mktime()将struct时间对象转成时间戳
>>> print(time.strftime('%Y-%m-%d',time.gmtime()))#将utc struct_time格式转成指定的字符串格式
第一个参数为是时间格式化格式,第二个是struct时间对象
4.1.1 time模块时间字符串与struct时间对象及时间戳转化关系(鸭子图)
4.1.2datetime模块
datetime 比 time 高级了不少,可以理解为 datetime 基于 time 进行了封装,提供了更多实用的函数。在datetime 模块中包含了几个类,具体关系如下:
object
timedelta # 主要用于计算时间跨度
tzinfo # 时区相关
time # 只关注时间
date # 只关注日期
datetime # 同时有时间和日期
甚至两个 datetime 对象直接相减就能获得一个 timedelta 对象。如果有需要计算工作日的需求,可以使用 business_calendar这个库,不需要装其他依赖就可使用。
>>> print(datetime.datetime.now())#返回当前时间 2016-11-14 12:47:03.941925
>>> print(datetime.date.fromtimestamp(time.time()))#格式化时间戳直接为日期格式2016-11-14
>>> print(datetime.datetime.now()+datetime.timedelta(3))#当前时间+3天
datetime.timedelta对象代表两个时间之间的的时间差,两个date或datetime对象相减时可以返回一个timedelta对象
>>>print(datetime.datetime.now() + datetime.timedelta(-3)) #当前时间-3天
>>>print(datetime.datetime.now() + datetime.timedelta(hours=3)) #当前时间+3小时
>>>print(datetime.datetime.now() + datetime.timedelta(minutes=-30)) #当前时间-30分
>>> print(datetime.datetime.now())
2016-11-14 23:56:21.528586
>>> print(datetime.datetime.now().replace(minute=3,hour=2))#时间替换
2016-11-14 02:03:50.296517
Directive | Meaning | Example | Notes |
---|---|---|---|
%a |
Weekday as locale’s abbreviated name. |
Sun, Mon, ..., Sat (en_US);
So, Mo, ..., Sa (de_DE)
|
(1) |
%A |
Weekday as locale’s full name. |
Sunday, Monday, ..., Saturday (en_US);
Sonntag, Montag, ..., Samstag (de_DE)
|
(1) |
%w |
Weekday as a decimal number, where 0 is Sunday and 6 is Saturday. | 0, 1, ..., 6 | |
%d |
Day of the month as a zero-padded decimal number. | 01, 02, ..., 31 | |
%b |
Month as locale’s abbreviated name. |
Jan, Feb, ..., Dec (en_US);
Jan, Feb, ..., Dez (de_DE)
|
(1) |
%B |
Month as locale’s full name. |
January, February, ..., December (en_US);
Januar, Februar, ..., Dezember (de_DE)
|
(1) |
%m |
Month as a zero-padded decimal number. | 01, 02, ..., 12 | |
%y |
Year without century as a zero-padded decimal number. | 00, 01, ..., 99 | |
%Y |
Year with century as a decimal number. | 1970, 1988, 2001, 2013 | |
%H |
Hour (24-hour clock) as a zero-padded decimal number. | 00, 01, ..., 23 | |
%I |
Hour (12-hour clock) as a zero-padded decimal number. | 01, 02, ..., 12 | |
%p |
Locale’s equivalent of either AM or PM. |
AM, PM (en_US);
am, pm (de_DE)
|
(1), (2) |
%M |
Minute as a zero-padded decimal number. | 00, 01, ..., 59 | |
%S |
Second as a zero-padded decimal number. | 00, 01, ..., 59 | (3) |
%f |
Microsecond as a decimal number, zero-padded on the left. | 000000, 000001, ..., 999999 | (4) |
%z |
UTC offset in the form +HHMM or -HHMM (empty string if the the object is naive). | (empty), +0000, -0400, +1030 | (5) |
%Z |
Time zone name (empty string if the object is naive). | (empty), UTC, EST, CST | |
%j |
Day of the year as a zero-padded decimal number. | 001, 002, ..., 366 | |
%U |
Week number of the year (Sunday as the first day of the week) as a zero padded decimal number. All days in a new year preceding the first Sunday are considered to be in week 0. | 00, 01, ..., 53 | (6) |
%W |
Week number of the year (Monday as the first day of the week) as a decimal number. All days in a new year preceding the first Monday are considered to be in week 0. | 00, 01, ..., 53 | (6) |
%c |
Locale’s appropriate date and time representation. |
Tue Aug 16 21:30:00 1988 (en_US);
Di 16 Aug 21:30:00 1988 (de_DE)
|
(1) |
%x |
Locale’s appropriate date representation. |
08/16/88 (None);
08/16/1988 (en_US);
16.08.1988 (de_DE)
|
(1) |
%X |
Locale’s appropriate time representation. |
21:30:00 (en_US);
21:30:00 (de_DE)
|
(1) |
%% |
A literal '%' character. |
% | |
5.random模块
产生随机数
>>> import random#导入随机数模块
>>> print(random.random())
0.756638169409
>>> print(random.randint(1,2))#产生整型随机数(顾头顾尾)
1
>>> print(random.randint(1,2))
2
>>> print(random.randrange(1,2))#产生整型随机数(顾头不顾尾))
1
>>> print(random.randrange(1,2))
1
>>> print(random.randrange(1,2))
1
>>> print(random.randrange(1,2))
1
随机数生成函数
import random checkcode = '' for i in range(4): current = random.randrange(0,4) if current != i: temp = chr(random.randint(65,90)) else: temp = random.randint(0,9) checkcode += str(temp) print checkcode
6.os模块
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所指向的文件或者目录的最后修改时间
7.sys模块
1 sys.argv 命令行参数List,第一个元素是程序本身路径 2 sys.exit(n) 退出程序,正常退出时exit(0) 3 sys.version 获取Python解释程序的版本信息 4 sys.maxint 最大的Int值 5 sys.path 返回模块的搜索路径,初始化时使用PYTHONPATH环境变量的值 6 sys.platform 返回操作系统平台名称 7 sys.stdout.write('please:') 8 val = sys.stdin.readline()[:-1]
8.python序列化函数(json及pickle)
用于序列化的两个模块
- json,用于字符串 和 python数据类型间进行转换
- pickle,用于python特有的类型 和 python的数据类型间进行转换
Json模块提供了四个功能:dumps、dump、loads、load
pickle模块提供了四个功能:dumps、dump、loads、load
8.shelve模块
shelve模块是一个简单的k,v将内存数据通过文件持久化的模块,可以持久化任何pickle可支持的python数据格式
import shelve d = shelve.open('shelve_test') #打开一个文件 class Test(object): def __init__(self,n): self.n = n t = Test(123) t2 = Test(123334) name = ["alex","rain","test"] d["test"] = name #持久化列表 d["t1"] = t #持久化类 d["t2"] = t2 d.close()
9.xml模块
xml是实现不同语言或程序之间进行数据交换的协议,跟json差不多,但json使用起来更简单,不过,古时候,在json还没诞生的黑暗年代,大家只能选择用xml呀,至今很多传统公司如金融行业的很多系统的接口还主要是xml
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>
xml协议在各个语言里的都 是支持的,在python中可以用以下模块操作xml
1 import xml.etree.ElementTree as ET 2 3 tree = ET.parse("xmltest.xml") 4 root = tree.getroot() 5 print(root.tag) 6 7 #遍历xml文档 8 for child in root: 9 print(child.tag, child.attrib) 10 for i in child: 11 print(i.tag,i.text) 12 13 #只遍历year 节点 14 for node in root.iter('year'): 15 print(node.tag,node.text)
修改和删除xml文档内容
1 import xml.etree.ElementTree as ET 2 3 tree = ET.parse("xmltest.xml") 4 root = tree.getroot() 5 6 #修改 7 for node in root.iter('year'): 8 new_year = int(node.text) + 1 9 node.text = str(new_year) 10 node.set("updated","yes") 11 12 tree.write("xmltest.xml") 13 14 15 #删除node 16 for country in root.findall('country'): 17 rank = int(country.find('rank').text) 18 if rank > 50: 19 root.remove(country) 20 21 tree.write('output.xml')
自己创建xml文档
import xml.etree.ElementTree as ET new_xml = ET.Element("namelist") name = ET.SubElement(new_xml,"name",attrib={"enrolled":"yes"}) age = ET.SubElement(name,"age",attrib={"checked":"no"}) sex = ET.SubElement(name,"sex") sex.text = '33' name2 = ET.SubElement(new_xml,"name",attrib={"enrolled":"no"}) age = ET.SubElement(name2,"age") age.text = '19' et = ET.ElementTree(new_xml) #生成文档对象 et.write("test.xml", encoding="utf-8",xml_declaration=True) ET.dump(new_xml) #打印生成的格式
10.ConfigParser模块
用于生成和修改常见配置文档,当前模块的名称在 python 3.x 版本中变更为 configparser。
来看一个好多软件的常见文档格式如下:
[DEFAULT] ServerAliveInterval = 45 Compression = yes CompressionLevel = 9 ForwardX11 = yes [bitbucket.org] User = hg [topsecret.server.com] Port = 50022 ForwardX11 = no
如果想用python生成一个这样的文档怎么做呢?
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') ['example.ini'] >>> config.sections() ['bitbucket.org', 'topsecret.server.com'] >>> 'bitbucket.org' in config True >>> 'bytebong.com' in config False >>> config['bitbucket.org']['User'] 'hg' >>> config['DEFAULT']['Compression'] 'yes' >>> topsecret = config['topsecret.server.com'] >>> topsecret['ForwardX11'] 'no' >>> topsecret['Port'] '50022' >>> for key in config['bitbucket.org']: print(key) ... user compressionlevel serveraliveinterval compression forwardx11 >>> config['bitbucket.org']['ForwardX11'] 'yes'
configparser增删改查语法
[section1] k1 = v1 k2:v2 [section2] k1 = v1 import ConfigParser config = ConfigParser.ConfigParser() config.read('i.cfg') # ########## 读 ########## #secs = config.sections() #print secs #options = config.options('group2') #print options #item_list = config.items('group2') #print item_list #val = config.get('group1','key') #val = config.getint('group1','key') # ########## 改写 ########## #sec = config.remove_section('group1') #config.write(open('i.cfg', "w")) #sec = config.has_section('wupeiqi') #sec = config.add_section('wupeiqi') #config.write(open('i.cfg', "w")) #config.set('group2','k1',11111) #config.write(open('i.cfg', "w")) #config.remove_option('group2','age') #config.write(open('i.cfg', "w"))
11.hashlib模块
用于加密相关的操作,3.x里代替了md5模块和sha模块,主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ,MD5 算法
import hashlib m = hashlib.md5() m.update(b"Hello") m.update(b"It's me") print(m.digest()) m.update(b"It's been a long time since last time we ...") print(m.digest()) #2进制格式hash print(len(m.hexdigest())) #16进制格式hash ''' def digest(self, *args, **kwargs): # real signature unknown """ Return the digest value as a string of binary data. """ pass def hexdigest(self, *args, **kwargs): # real signature unknown """ Return the digest value as a string of hexadecimal digits. """ pass ''' import hashlib # ######## md5 ######## hash = hashlib.md5() hash.update('admin') print(hash.hexdigest()) # ######## sha1 ######## hash = hashlib.sha1() hash.update('admin') print(hash.hexdigest()) # ######## sha256 ######## hash = hashlib.sha256() hash.update('admin') print(hash.hexdigest()) # ######## sha384 ######## hash = hashlib.sha384() hash.update('admin') print(hash.hexdigest()) # ######## sha512 ######## hash = hashlib.sha512() hash.update('admin') print(hash.hexdigest())
还不够吊?python 还有一个 hmac 模块,它内部对我们创建 key 和 内容 再进行处理然后再加密
import hmac h = hmac.new('wueiqi') h.update('hellowo') print h.hexdigest()
更多关于md5,sha1,sha256等介绍的文章看这里https://www.tbs-certificates.co.uk/FAQ/en/sha256.html
12.logging模块
日志 模块自2.3版本开始便是Python标准库的一部分。它被简洁的描述在 PEP 282。众所周知,除了 基础日志指南 部分,该文档并不容易阅读。
日志的两个目的:
- 诊断日志 记录与应用程序操作相关的日志。例如,用户遇到的报错信息,可通过搜索诊断日志获得上下文信息。
- 审计日志 为商业分析而记录的日志。从审计日志中,可提取用户的交易信息,并结合其他用户资料构成用户报告或者用来优化商业目标
... 或者用打印(Print)?
当需要在命令行应用中显示帮助文档时, 打印
是一个相对于日志更好的选择。而在其他时候,日志总能优于 打印
,理由如下:
- 日志事件产生的 日志记录 ,包含清晰可用的诊断信息,如文件名称、路径、函数名和行数等。
- 包含日志模块的应用,默认可通过根记录器对应用的日志流进行访问,除非你将日志过滤了。
- 可通过 logging.Logger.setLevel 方法进行有选择的日志记录,或可通过设置
logging.Logger.disabled
属性为True
来屏蔽日志记录
应用程序中的日志
应用程序开发的权威指南, 应用的12要素 ,也在其中一节描述了 日志的作用 。它特别强调将日志视为事件流,并将其发送至由应用环境所处理的标准输出中。
- 配置日志至少有以下三种方式:
-
- 使用INI格式文件:
- 优点: 使用
logging.config.listen()
函数监听socket,可在运行过程中更新配置 - 缺点: 通过源码控制日志配置较少( 例如 子类化定制的过滤器或记录器)。
- 使用字典或JASON格式文件:
- 优点: 除了可在运行时动态更新,在Python 2.6之后,还可通过
json
模块从其它文件中导入配置。 - 缺点: 很难通过源码控制日志配置。
- 使用源码:
- 优点: 对配置绝对的控制。
- 缺点: 对配置的更改需要对源码进行修改。
通过INI文件进行配置的例子
我们假设文件名为 logging_config.ini
。关于文件格式的更多细节,请参见 日志指南中的 日志配置 部分
很多程序都有记录日志的需求,并且日志中包含的信息即有正常的程序访问日志,还可能有错误、警告等信息输出,python的logging模块提供了标准的日志接口,你可以通过它存储各种格式的日志,logging的日志可以分为 debug()
, info()
, warning()
, error()
and critical() 5个级别,
下面我们看一下怎么用:
[loggers] keys=root [handlers] keys=stream_handler [formatters] keys=formatter [logger_root] level=DEBUG handlers=stream_handler [handler_stream_handler] class=StreamHandler level=DEBUG formatter=formatter args=(sys.stderr,) [formatter_formatter] format=%(asctime)s %(name)-12s %(levelname)-8s %(message)s
然后在源码中调用 logging.config.fileConfig()
方法:
import logging from logging.config import fileConfig fileConfig('logging_config.ini') logger = logging.getLogger() logger.debug('often makes a very good meal of %s', 'visiting tourists')
通过字典进行配置的例子:
Python 2.7中,你可以使用字典实现详细配置。PEP 391 包含了一系列字典配置的强制和 非强制的元素。
import logging from logging.config import dictConfig logging_config = dict( version = 1, formatters = { 'f': {'format': '%(asctime)s %(name)-12s %(levelname)-8s %(message)s'} }, handlers = { 'h': {'class': 'logging.StreamHandler', 'formatter': 'f', 'level': logging.DEBUG} }, loggers = { 'root': {'handlers': ['h'], 'level': logging.DEBUG} } ) dictConfig(logging_config) logger = logging.getLogger() logger.debug('often makes a very good meal of %s', 'visiting tourists')
通过源码直接配置的例子:
import logging logger = logging.getLogger() handler = logging.StreamHandler() formatter = logging.Formatter( '%(asctime)s %(name)-12s %(levelname)-8s %(message)s') handler.setFormatter(formatter) logger.addHandler(handler) logger.setLevel(logging.DEBUG) logger.debug('often makes a very good meal of %s', 'visiting tourists')
很多程序都有记录日志的需求,并且日志中包含的信息即有正常的程序访问日志,还可能有错误、警告等信息输出,python的logging模块提供了标准的日志接口,你可以通过它存储各种格式的日志,logging的日志可以分为 debug()
, info()
, warning()
, error()
and critical() 5个级别,
下面我们看一下怎么用
import logging logging.warning("user [alex] attempted wrong password more than 3 times") logging.critical("server is down") #输出 WARNING:root:user [alex] attempted wrong password more than 3 times CRITICAL:root:server is down
Level | When it’s used |
---|---|
DEBUG |
Detailed information, typically of interest only when diagnosing problems. |
INFO |
Confirmation that things are working as expected. |
WARNING |
An indication that something unexpected happened, or indicative of some problem in the near future (e.g. ‘disk space low’). The software is still working as expected. |
ERROR |
Due to a more serious problem, the software has not been able to perform some function. |
CRITICAL |
A serious error, indicating that the program itself may be unable to continue running. |
如果想把日志写到文件里,也很简单
import logging logging.basicConfig(filename='example.log',level=logging.INFO) logging.debug('This message should go to the log file') logging.info('So should this') logging.warning('And this, too')
其中下面这句中的level=loggin.INFO意思是,把日志纪录级别设置为INFO,也就是说,只有比日志是INFO或比INFO级别更高的日志才会被纪录到文件里,在这个例子, 第一条日志是不会被纪录的,如果希望纪录debug的日志,那把日志级别改成DEBUG就行了
感觉上面的日志格式忘记加上时间啦,日志不知道时间怎么行呢,下面就来加上!
import logging logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %I:%M:%S %p') logging.warning('is when this event was logged.')
日志格式:
说明 | 属性名 | 格式 |
打印当前时间,默认会展示2003-07-08 16:49:45,896,精度会精确到千分之一秒。 | asctime | %(asctime)s |
打印当前的时间戳(time.time()函数的返回值) | created | %(created)f |
打印当前文件名。 | filename | %(filename)s |
打印当前函数名。 | funcName | %(funcName)s |
本条日志的日志级别 (‘DEBUG’, ‘INFO’, ‘WARNING’, ‘ERROR’,’CRITICAL’). | levelname | %(levelname)s |
日志级别的整型值 (DEBUG, INFO, WARNING, ERROR,CRITICAL). | levelno | %(levelno)s |
打印日志的代码在文件中的行号 (if available). | lineno | %(lineno)d |
打印当前的模块名。 | module | %(module)s |
打印当前时间的毫秒部分。 | msecs | %(msecs)d |
当前的日志内容。 | message | %(message)s |
当前日志的对象的name。 | name | %(name)s |
打印当前文件的完整路径名。 | pathname | %(pathname)s |
进程号 | process | %(process)d |
进程名 | processName | %(processName)s |
当前时间与日志对象创建的相对时间,显示为毫秒值 | relativeCreated | %(relativeCreated)d |
线程ID | thread | %(thread)d |
线程名 | threadName | %(threadName)s |
如果想同时把log打印在屏幕和文件日志里,就需要了解一点复杂的知识 了
1 Python 使用logging模块记录日志涉及四个主要类,使用官方文档中的概括最为合适: 2 3 logger提供了应用程序可以直接使用的接口; 4 5 handler将(logger创建的)日志记录发送到合适的目的输出; 6 7 filter提供了细度设备来决定输出哪条日志记录; 8 9 formatter决定日志记录的最终输出格式。 10 11 logger 12 每个程序在输出信息之前都要获得一个Logger。Logger通常对应了程序的模块名,比如聊天工具的图形界面模块可以这样获得它的Logger: 13 LOG=logging.getLogger(”chat.gui”) 14 而核心模块可以这样: 15 LOG=logging.getLogger(”chat.kernel”) 16 17 Logger.setLevel(lel):指定最低的日志级别,低于lel的级别将被忽略。debug是最低的内置级别,critical为最高 18 Logger.addFilter(filt)、Logger.removeFilter(filt):添加或删除指定的filter 19 Logger.addHandler(hdlr)、Logger.removeHandler(hdlr):增加或删除指定的handler 20 Logger.debug()、Logger.info()、Logger.warning()、Logger.error()、Logger.critical():可以设置的日志级别 21 22 23 handler 24 25 handler对象负责发送相关的信息到指定目的地。Python的日志系统有多种Handler可以使用。有些Handler可以把信息输出到控制台,有些Logger可以把信息输出到文件,还有些 Handler可以把信息发送到网络上。如果觉得不够用,还可以编写自己的Handler。可以通过addHandler()方法添加多个多handler 26 Handler.setLevel(lel):指定被处理的信息级别,低于lel级别的信息将被忽略 27 Handler.setFormatter():给这个handler选择一个格式 28 Handler.addFilter(filt)、Handler.removeFilter(filt):新增或删除一个filter对象 29 30 31 每个Logger可以附加多个Handler。接下来我们就来介绍一些常用的Handler: 32 1) logging.StreamHandler 33 使用这个Handler可以向类似与sys.stdout或者sys.stderr的任何文件对象(file object)输出信息。它的构造函数是: 34 StreamHandler([strm]) 35 其中strm参数是一个文件对象。默认是sys.stderr 36 37 38 2) logging.FileHandler 39 和StreamHandler类似,用于向一个文件输出日志信息。不过FileHandler会帮你打开这个文件。它的构造函数是: 40 FileHandler(filename[,mode]) 41 filename是文件名,必须指定一个文件名。 42 mode是文件的打开方式。参见Python内置函数open()的用法。默认是’a',即添加到文件末尾。 43 44 3) logging.handlers.RotatingFileHandler 45 这个Handler类似于上面的FileHandler,但是它可以管理文件大小。当文件达到一定大小之后,它会自动将当前日志文件改名,然后创建 一个新的同名日志文件继续输出。比如日志文件是chat.log。当chat.log达到指定的大小之后,RotatingFileHandler自动把 文件改名为chat.log.1。不过,如果chat.log.1已经存在,会先把chat.log.1重命名为chat.log.2。。。最后重新创建 chat.log,继续输出日志信息。它的构造函数是: 46 RotatingFileHandler( filename[, mode[, maxBytes[, backupCount]]]) 47 其中filename和mode两个参数和FileHandler一样。 48 maxBytes用于指定日志文件的最大文件大小。如果maxBytes为0,意味着日志文件可以无限大,这时上面描述的重命名过程就不会发生。 49 backupCount用于指定保留的备份文件的个数。比如,如果指定为2,当上面描述的重命名过程发生时,原有的chat.log.2并不会被更名,而是被删除。 50 51 52 4) logging.handlers.TimedRotatingFileHandler 53 这个Handler和RotatingFileHandler类似,不过,它没有通过判断文件大小来决定何时重新创建日志文件,而是间隔一定时间就 自动创建新的日志文件。重命名的过程与RotatingFileHandler类似,不过新的文件不是附加数字,而是当前时间。它的构造函数是: 54 TimedRotatingFileHandler( filename [,when [,interval [,backupCount]]]) 55 其中filename参数和backupCount参数和RotatingFileHandler具有相同的意义。 56 interval是时间间隔。 57 when参数是一个字符串。表示时间间隔的单位,不区分大小写。它有以下取值: 58 S 秒 59 M 分 60 H 小时 61 D 天 62 W 每星期(interval==0时代表星期一) 63 midnight 每天凌晨
import logging #create logger logger = logging.getLogger('TEST-LOG') logger.setLevel(logging.DEBUG) # create console handler and set level to debug ch = logging.StreamHandler()#屏幕输出 ch.setLevel(logging.DEBUG) # create file handler and set level to warning fh = logging.FileHandler("access.log")#文件输出 fh.setLevel(logging.WARNING) # create formatter formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')#日志格式 # add formatter to ch and fh ch.setFormatter(formatter)#绑定格式 fh.setFormatter(formatter) # add ch and fh to logger logger.addHandler(ch)#添加输出对象 logger.addHandler(fh) # 'application' code logger.debug('debug message') logger.info('info message') logger.warn('warn message') logger.error('error message') logger.critical('critical message')
文件自动截断例子:
import logging from logging import handlers logger = logging.getLogger(__name__) log_file = "timelog.log" #fh = handlers.RotatingFileHandler(filename=log_file,maxBytes=10,backupCount=3) fh = handlers.TimedRotatingFileHandler(filename=log_file,when="S",interval=5,backupCount=3) formatter = logging.Formatter('%(asctime)s %(module)s:%(lineno)d %(message)s') fh.setFormatter(formatter) logger.addHandler(fh) logger.warning("test1") logger.warning("test12") logger.warning("test13") logger.warning("test14")
13.re模块
常用正则表达式符号
'.' 默认匹配除\n之外的任意一个字符,若指定flag DOTALL,则匹配任意字符,包括换行 '^' 匹配字符开头,若指定flags MULTILINE,这种也可以匹配上(r"^a","\nabc\neee",flags=re.MULTILINE) '$' 匹配字符结尾,或e.search("foo$","bfoo\nsdfsf",flags=re.MULTILINE).group()也可以 '*' 匹配*号前的字符0次或多次,re.findall("ab*","cabb3abcbbac") 结果为['abb', 'ab', 'a'] '+' 匹配前一个字符1次或多次,re.findall("ab+","ab+cd+abb+bba") 结果['ab', 'abb'] '?' 匹配前一个字符1次或0次 '{m}' 匹配前一个字符m次 '{n,m}' 匹配前一个字符n到m次,re.findall("ab{1,3}","abb abc abbcbbb") 结果'abb', 'ab', 'abb'] '|' 匹配|左或|右的字符,re.search("abc|ABC","ABCBabcCD").group() 结果'ABC' '(...)' 分组匹配,re.search("(abc){2}a(123|456)c", "abcabca456c").group() 结果 abcabca456c '\A' 只从字符开头匹配,re.search("\Aabc","alexabc") 是匹配不到的 '\Z' 匹配字符结尾,同$ '\d' 匹配数字0-9 '\b' 定界符匹配\w和\W之间内容 '\D' 匹配非数字 '\w' 匹配[A-Za-z0-9] '\W' 匹配非[A-Za-z0-9] 's' 匹配空白字符、\t、\n、\r , re.search("\s+","ab\tc1\n3").group() 结果 '\t' '(?P<name>...)' 分组匹配 re.search("(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birthday>[0-9]{4})","371481199306143242").groupdict("city") 结果{'province': '3714', 'city': '81', 'birthday': '1993'}
正则表达式的语法规则
下面是Python中正则表达式的一些匹配规则,图片资料来自CSDN
正则表达式相关注解
(1)数量词的贪婪模式与非贪婪模式
正则表达式通常用于在文本中查找匹配的字符串。Python里数量词默认是贪婪的(在少数语言里也可能是默认非贪婪),总是尝试匹配尽可能多的字符;非贪婪的则相反,总是尝试匹配尽可能少的字符。例如:正则表达式”ab*”如果用于查找”abbbc”,将找到”abbb”。而如果使用非贪婪的数量词”ab*?”,将找到”a”。
注:我们一般使用非贪婪模式来提取。
(2)反斜杠问题
与大多数编程语言相同,正则表达式里使用”\”作为转义字符,这就可能造成反斜杠困扰。假如你需要匹配文本中的字符”\”,那么使用编程语言表示的正则表达式里将需要4个反斜杠”\\\\”:前两个和后两个分别用于在编程语言里转义成反斜杠,转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。
Python里的原生字符串很好地解决了这个问题,这个例子中的正则表达式可以使用r”\\”表示。同样,匹配一个数字的”\\d”可以写成r”\d”。有了原生字符串,妈妈也不用担心是不是漏写了反斜杠,写出来的表达式也更直观勒。
Python 自带了re模块,它提供了对正则表达式的支持。主要用到的方法列举如下
re.compile(string[,flag]) #以下为匹配所用函数 re.match(pattern, string[, flags]) re.search(pattern, string[, flags]) re.split(pattern, string[, maxsplit]) re.findall(pattern, string[, flags]) re.finditer(pattern, string[, flags]) re.sub(pattern, repl, string[, count]) re.subn(pattern, repl, string[, count])
在介绍这几个方法之前,我们先来介绍一下pattern的概念,pattern可以理解为一个匹配模式,那么我们怎么获得这个匹配模式呢?很简单,我们需要利用re.compile方法就可以。例如
pattern = re.compile(r'hello')
在参数中我们传入了原生字符串对象,通过compile方法编译生成一个pattern对象,然后我们利用这个对象来进行进一步的匹配。
另外大家可能注意到了另一个参数 flags,在这里解释一下这个参数的含义:
参数flag是匹配模式,取值可以使用按位或运算符’|’表示同时生效,比如re.I | re.M。
可选值有:
• re.I(全拼:IGNORECASE): 忽略大小写(括号内是完整写法,下同) • re.M(全拼:MULTILINE): 多行模式,改变'^'和'$'的行为(参见上图) • re.S(全拼:DOTALL): 点任意匹配模式,改变'.'的行为 • re.L(全拼:LOCALE): 使预定字符类 \w \W \b \B \s \S 取决于当前区域设定 • re.U(全拼:UNICODE): 使预定字符类 \w \W \b \B \s \S \d \D 取决于unicode定义的字符属性 • re.X(全拼:VERBOSE): 详细模式。这个模式下正则表达式可以是多行,忽略空白字符,并可以加入注释。
Match对象是一次匹配的结果,包含了很多关于此次匹配的信息,可以使用Match提供的可读属性或方法来获取这些信息
属性: 1.string: 匹配时使用的文本。 2.re: 匹配时使用的Pattern对象。 3.pos: 文本中正则表达式开始搜索的索引。值与Pattern.match()和Pattern.seach()方法的同名参数相同。 4.endpos: 文本中正则表达式结束搜索的索引。值与Pattern.match()和Pattern.seach()方法的同名参数相同。 5.lastindex: 最后一个被捕获的分组在文本中的索引。如果没有被捕获的分组,将为None。 6.lastgroup: 最后一个被捕获的分组的别名。如果这个分组没有别名或者没有被捕获的分组,将为None。 方法: 1.group([group1, …]): 获得一个或多个分组截获的字符串;指定多个参数时将以元组形式返回。group1可以使用编号也可以使用别名;编号0代表整个匹配的子串;不填写参数时,返回group(0);没有截获字符串的组返回None;截获了多次的组返回最后一次截获的子串。 2.groups([default]): 以元组形式返回全部分组截获的字符串。相当于调用group(1,2,…last)。default表示没有截获字符串的组以这个值替代,默认为None。 3.groupdict([default]): 返回以有别名的组的别名为键、以该组截获的子串为值的字典,没有别名的组不包含在内。default含义同上。 4.start([group]): 返回指定的组截获的子串在string中的起始索引(子串第一个字符的索引)。group默认值为0。 5.end([group]): 返回指定的组截获的子串在string中的结束索引(子串最后一个字符的索引+1)。group默认值为0。 6.span([group]): 返回(start(group), end(group))。 7.expand(template): 将匹配到的分组代入template中然后返回。template中可以使用\id或\g、\g引用分组,但不能使用编号0。\id与\g是等价的;但\10将被认为是第10个分组,如果你想表达\1之后是字符’0’,只能使用\g0。
下面我们用一个例子来体会一下
# -*- coding: utf-8 -*- #一个简单的match实例 import re # 匹配如下内容:单词+空格+单词+任意字符 m = re.match(r'(\w+) (\w+)(?P<sign>.*)', 'hello world!') print "m.string:", m.string print "m.re:", m.re print "m.pos:", m.pos print "m.endpos:", m.endpos print "m.lastindex:", m.lastindex print "m.lastgroup:", m.lastgroup print "m.group():", m.group() print "m.group(1,2):", m.group(1, 2) print "m.groups():", m.groups() print "m.groupdict():", m.groupdict() print "m.start(2):", m.start(2) print "m.end(2):", m.end(2) print "m.span(2):", m.span(2) print r"m.expand(r'\g \g\g'):", m.expand(r'\2 \1\3') ### output ### # m.string: hello world! # m.re: # m.pos: 0 # m.endpos: 12 # m.lastindex: 3 # m.lastgroup: sign # m.group(1,2): ('hello', 'world') # m.groups(): ('hello', 'world', '!') # m.groupdict(): {'sign': '!'} # m.start(2): 6 # m.end(2): 11 # m.span(2): (6, 11) # m.expand(r'\2 \1\3'): world hello!
re.search(pattern, string[, flags])
search方法与match方法极其类似,区别在于match()函数只检测re是不是在string的开始位置匹配,search()会扫描整个string查找匹配,match()只有在0位置匹配成功的话才有返回,如果不是开始位置匹配成功的话,match()就返回None。同样,search方法的返回对象同样match()返回对象的方法和属性。我们用一个例子感受一下
import re # 将正则表达式编译成Pattern对象 pattern = re.compile(r'world') # 使用search()查找匹配的子串,不存在能匹配的子串时将返回None # 这个例子中使用match()无法成功匹配 match = re.search(pattern,'hello world!') if match: # 使用Match获得分组信息 print match.group() ### 输出 ### # world
re.split(pattern, string[, maxsplit])
按照能够匹配的子串将string分割后返回列表。maxsplit用于指定最大分割次数,不指定将全部分割。我们通过下面的例子感受一下。
import re pattern = re.compile(r'\d+') print re.split(pattern,'one1two2three3four4') ### 输出 ### # ['one', 'two', 'three', 'four', '']
re.findall(pattern, string[, flags])
搜索string,以列表形式返回全部能匹配的子串。我们通过这个例子来感受一下
import re pattern = re.compile(r'\d+') print re.findall(pattern,'one1two2three3four4') ### 输出 ### # ['1', '2', '3', '4']
re.finditer(pattern, string[, flags])
搜索string,返回一个顺序访问每一个匹配结果(Match对象)的迭代器。我们通过下面的例子来感受一下
import re pattern = re.compile(r'\d+') for m in re.finditer(pattern,'one1two2three3four4'): print m.group(), ### 输出 ### # 1 2 3 4
re.sub(pattern, repl, string[, count])
使用repl替换string中每一个匹配的子串后返回替换后的字符串。
当repl是一个字符串时,可以使用\id或\g、\g引用分组,但不能使用编号0。
当repl是一个方法时,这个方法应当只接受一个参数(Match对象),并返回一个字符串用于替换(返回的字符串中不能再引用分组)。
count用于指定最多替换次数,不指定时全部替换
import re pattern = re.compile(r'(\w+) (\w+)') s = 'i say, hello world!' print re.sub(pattern,r'\2 \1', s) def func(m): return m.group(1).title() + ' ' + m.group(2).title() print re.sub(pattern,func, s) ### output ### # say i, world hello! # I Say, Hello World!
re.subn(pattern, repl, string[, count])
返回 (sub(repl, string[, count]), 替换次数)。
import re pattern = re.compile(r'(\w+) (\w+)') s = 'i say, hello world!' print re.subn(pattern,r'\2 \1', s) def func(m): return m.group(1).title() + ' ' + m.group(2).title() print re.subn(pattern,func, s) ### output ### # ('say i, world hello!', 2) # ('I Say, Hello World!', 2)
14.Python Re模块的另一种使用方式
在上面我们介绍了7个工具方法,例如match,search等等,不过调用方式都是 re.match,re.search的方式,其实还有另外一种调用方式,可以通过pattern.match,pattern.search调用,这样调用便不用将pattern作为第一个参数传入了,大家想怎样调用皆可。
函数API列表
match(string[, pos[, endpos]]) | re.match(pattern, string[, flags]) search(string[, pos[, endpos]]) | re.search(pattern, string[, flags]) split(string[, maxsplit]) | re.split(pattern, string[, maxsplit]) findall(string[, pos[, endpos]]) | re.findall(pattern, string[, flags]) finditer(string[, pos[, endpos]]) | re.finditer(pattern, string[, flags]) sub(repl, string[, count]) | re.sub(pattern, repl, string[, count]) subn(repl, string[, count]) |re.sub(pattern, repl, string[, count])
总结:
python模块较多,这里ctrl+c,ctrl+v复制了好多前辈的代码,用到时,能想起用那个模块。就行,能写出来就更好了。
这里就简单记录下。。。。。。
参考链接:
http://gracece.com/2014/10/the-distinction-between-date-and-datetime-in-python/
http://www.pythondoc.com/pythontutorial3/modules.html
http://www.cnblogs.com/alex3714/articles/5161349.html