学习python第六天-白红宇

学习python第六天

阅读量：5299 次

发布时间：2019-06-14

本文共 16457 字，大约阅读时间需要 54 分钟。

常用模块

一.loging模块

日志的等级：

CRITICAL = 50 #FATAL = CRITICALERROR = 40WARNING = 30 #WARN = WARNINGINFO = 20DEBUG = 10NOTSET = 0 #不设置

二、系统的默认等级为warning，loging模块会默认将打印的信息打印到终端上

import logging

logging.debug('调试debug')

logging.info('消息info')

logging.warning('警告warn')

logging.error('错误error')

logging.critical('严重critical')

'''

WARNING:root:警告warn

ERROR:root:错误error

CRITICAL:root:严重critical

'''

三、指定参数，打印到文件中

可在logging.basicConfig()函数中通过具体参数来更改logging模块默认行为，可用参数有

filename：用指定的文件名创建FiledHandler（后边会具体讲解handler的概念），这样日志会被存储在指定的文件中。

filemode：文件打开方式，在指定了filename时使用这个参数，默认值为“a”还可指定为“w”。

format：指定handler使用的日志显示格式。

datefmt：指定日期时间格式。

level：设置rootlogger（后边会讲解具体概念）的日志级别

stream：用指定的stream创建StreamHandler。可以指定输出到sys.stderr,sys.stdout或者文件，默认为sys.stderr。若同时列出了filename和stream两个参数，则stream参数会被忽略。

#格式

%(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：用户输出的消息

logging.basicConfig()

具体使用：

#======介绍

可在logging.basicConfig()函数中可通过具体参数来更改logging模块默认行为，可用参数有

filename：用指定的文件名创建FiledHandler（后边会具体讲解handler的概念），这样日志会被存储在指定的文件中。

filemode：文件打开方式，在指定了filename时使用这个参数，默认值为“a”还可指定为“w”。

format：指定handler使用的日志显示格式。

datefmt：指定日期时间格式。

level：设置rootlogger（后边会讲解具体概念）的日志级别

format参数中可能用到的格式化串：

%(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用户输出的消息

#========使用

import logging

logging.basicConfig(filename='access.log',

format='%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s',

datefmt='%Y-%m-%d %H:%M:%S %p',

level=10)

logging.debug('调试debug')

logging.info('消息info')

logging.warning('警告warn')

logging.error('错误error')

logging.critical('严重critical')

#========结果

access.log内容:

2017-07-28 20:32:17 PM - root - DEBUG -test: 调试debug

2017-07-28 20:32:17 PM - root - INFO -test: 消息info

2017-07-28 20:32:17 PM - root - WARNING -test: 警告warn

2017-07-28 20:32:17 PM - root - ERROR -test: 错误error

2017-07-28 20:32:17 PM - root - CRITICAL -test: 严重critical

part2: 可以为logging模块指定模块级的配置,即所有logger的配置

loging模块的Formatter，Handler，Logger，Filter对象

formatter：用来定义打印文件的格式

handler：用来定义打印文件的位置，终端或者是文件里

logger:为总的日志文件，可以设置名称等

具体实现方式：

'''

critical=50

error =40

warning =30

info = 20

debug =10

'''

import logging

#1、logger对象：负责产生日志，然后交给Filter过滤，然后交给不同的Handler输出

logger=logging.getLogger(__file__)

#2、Filter对象：不常用，略

#3、Handler对象：接收logger传来的日志，然后控制输出

h1=logging.FileHandler('t1.log') #打印到文件

h2=logging.FileHandler('t2.log') #打印到文件

h3=logging.StreamHandler() #打印到终端

#4、Formatter对象：日志格式

formmater1=logging.Formatter('%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s',

datefmt='%Y-%m-%d %H:%M:%S %p',)

formmater2=logging.Formatter('%(asctime)s : %(message)s',

datefmt='%Y-%m-%d %H:%M:%S %p',)

formmater3=logging.Formatter('%(name)s %(message)s',)

#5、为Handler对象绑定格式

h1.setFormatter(formmater1)

h2.setFormatter(formmater2)

h3.setFormatter(formmater3)

#6、将Handler添加给logger并设置日志级别

logger.addHandler(h1)

logger.addHandler(h2)

logger.addHandler(h3)

logger.setLevel(10)

#7、测试

logger.debug('debug')

logger.info('info')

logger.warning('warning')

logger.error('error')

logger.critical('critical')

五、logger和handle,logger设置日志级别，如果匹配不出成功便不会打印日志，匹配成功后会匹配handle的日志级别。如果都满足上述的日志级别才会开始打印日志。

六、logger继承

import logging

formatter=logging.Formatter('%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s',

datefmt='%Y-%m-%d %H:%M:%S %p',) #设置formatter打印的日志格式

ch=logging.StreamHandler() #设置handle，streamhandle是将日志打印到终端中

ch.setFormatter(formatter) #设置将日志的格式传给handle

logger1=logging.getLogger('root') #开始得到日志

logger2=logging.getLogger('root.child1')

logger3=logging.getLogger('root.child1.child2')#Child是Child2的父级

logger1.addHandler(ch)#将handle添加至logger

logger2.addHandler(ch)

logger3.addHandler(ch)

logger1.setLevel(10)#设置logger的日志级别

logger2.setLevel(10)

logger3.setLevel(10)

logger1.debug('log1 debug')#打印debug的日志

logger2.debug('log2 debug')

logger3.debug('log3 debug')

'''

2017-07-28 22:22:05 PM - root - DEBUG -test: log1 debug

2017-07-28 22:22:05 PM - root.child1 - DEBUG -test: log2 debug

2017-07-28 22:22:05 PM - root.child1.child2 - DEBUG -test: log3 debug

'''

七、实际应用

"""

logging配置

"""

import os

import logging.config

# 定义三种日志输出格式开始

standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]' \

'[%(levelname)s][%(message)s]' #其中name为getlogger指定的名字

simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'

id_simple_format = '[%(levelname)s][%(asctime)s] %(message)s'

# 定义日志输出格式结束

logfile_dir = os.path.dirname(os.path.abspath(__file__)) # log文件的目录

logfile_name = 'all2.log' # log文件名

# 如果不存在定义的日志目录就创建一个

if not os.path.isdir(logfile_dir):

os.mkdir(logfile_dir)

# log文件的全路径

logfile_path = os.path.join(logfile_dir, logfile_name)

# log配置字典

LOGGING_DIC = {

'version': 1,

'disable_existing_loggers': False,

'formatters': {

'standard': {

'format': standard_format

'simple': {

'format': simple_format

'filters': {},

'handlers': {

#打印到终端的日志

'console': {

'level': 'DEBUG',

'class': 'logging.StreamHandler', # 打印到屏幕

'formatter': 'simple'

#打印到文件的日志,收集info及以上的日志

'default': {

'level': 'DEBUG',

'class': 'logging.handlers.RotatingFileHandler', # 保存到文件

'formatter': 'standard',

'filename': logfile_path, # 日志文件

'maxBytes': 1024*1024*5, # 日志大小 5M

'backupCount': 5,

'encoding': 'utf-8', # 日志文件的编码，再也不用担心中文log乱码了

'loggers': {

#logging.getLogger(__name__)拿到的logger配置

'': {

'handlers': ['default', 'console'], # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕

'level': 'DEBUG',

'propagate': True, # 向上（更高level的logger）传递

}

def load_my_logging_cfg():

logging.config.dictConfig(LOGGING_DIC) # 导入上面定义的logging配置

logger = logging.getLogger(__name__) # 生成一个log实例

logger.info('It works!') # 记录该文件的运行状态

if __name__ == '__main__':

load_my_logging_cfg()

logging配置文件

--------------------------------------------------------------------------------------------------------------

"""

MyLogging Test

"""

import time

import logging

import my_logging # 导入自定义的logging配置

logger = logging.getLogger(__name__) # 生成logger实例

def demo():

logger.debug("start range... time:{}".format(time.time()))

logger.info("中文测试开始。。。")

for i in range(10):

logger.debug("i:{}".format(i))

time.sleep(0.2)

else:

logger.debug("over range... time:{}".format(time.time()))

logger.info("中文测试结束。。。")

if __name__ == "__main__":

my_logging.load_my_logging_cfg() # 在你程序文件的入口加载自定义logging配置

demo()

---------------------------------------------------------------------------------------------------------------

注意注意注意：

#1、有了上述方式我们的好处是：所有与logging模块有关的配置都写到字典中就可以了，更加清晰，方便管理

#2、我们需要解决的问题是：

1、从字典加载配置：logging.config.dictConfig(settings.LOGGING_DIC)

2、拿到logger对象来产生日志

logger对象都是配置到字典的loggers 键对应的子字典中的

按照我们对logging模块的理解，要想获取某个东西都是通过名字，也就是key来获取的

于是我们要获取不同的logger对象就是

logger=logging.getLogger('loggers子字典的key名')

但问题是：如果我们想要不同logger名的logger对象都共用一段配置，那么肯定不能在loggers子字典中定义n个key

'loggers': {

'l1': {

'handlers': ['default', 'console'], #

'level': 'DEBUG',

'propagate': True, # 向上（更高level的logger）传递

'l2: {

'handlers': ['default', 'console' ],

'level': 'DEBUG',

'propagate': False, # 向上（更高level的logger）传递

'l3': {

'handlers': ['default', 'console'], #

'level': 'DEBUG',

'propagate': True, # 向上（更高level的logger）传递

}

#我们的解决方式是，定义一个空的key

'loggers': {

'': {

'handlers': ['default', 'console'],

'level': 'DEBUG',

'propagate': True,

}

这样我们再取logger对象时

logging.getLogger(__name__)，不同的文件__name__不同，这保证了打印日志时标识信息不同，但是拿着该名字去loggers里找key名时却发现找不到，于是默认使用key=''的配置

!!!关于如何拿到logger对象的详细解释！！！

二、re模块（正则）

# =================================匹配模式=================================

#一对一的匹配

# 'hello'.replace(old,new)

# 'hello'.find('pattern')

#正则匹配

import re

#\w与\W

print(re.findall('\w','hello egon 123')) #['h', 'e', 'l', 'l', 'o', 'e', 'g', 'o', 'n', '1', '2', '3']

print(re.findall('\W','hello egon 123')) #[' ', ' ']

#\s与\S

print(re.findall('\s','hello egon 123')) #[' ', ' ', ' ', ' ']

print(re.findall('\S','hello egon 123')) #['h', 'e', 'l', 'l', 'o', 'e', 'g', 'o', 'n', '1', '2', '3']

#\n \t都是空,都可以被\s匹配

print(re.findall('\s','hello \n egon \t 123')) #[' ', '\n', ' ', ' ', '\t', ' ']

#\n与\t

print(re.findall(r'\n','hello egon \n123')) #['\n']

print(re.findall(r'\t','hello egon\t123')) #['\n']

#\d与\D

print(re.findall('\d','hello egon 123')) #['1', '2', '3']

print(re.findall('\D','hello egon 123')) #['h', 'e', 'l', 'l', 'o', ' ', 'e', 'g', 'o', 'n', ' ']

#\A与\Z

print(re.findall('\Ahe','hello egon 123')) #['he'],\A==>^

print(re.findall('123\Z','hello egon 123')) #['he'],\Z==>$

#^与$

print(re.findall('^h','hello egon 123')) #['h']

print(re.findall('3$','hello egon 123')) #['3']

# 重复匹配：| . | * | ? | .* | .*? | + | {n,m} |

print(re.findall('a.b','a1b')) #['a1b']

print(re.findall('a.b','a1b a*b a b aaab')) #['a1b', 'a*b', 'a b', 'aab']

print(re.findall('a.b','a\nb')) #[]

print(re.findall('a.b','a\nb',re.S)) #['a\nb']

print(re.findall('a.b','a\nb',re.DOTALL)) #['a\nb']同上一条意思一样

print(re.findall('ab*','bbbbbbb')) #[]

print(re.findall('ab*','a')) #['a']

print(re.findall('ab*','abbbb')) #['abbbb']

print(re.findall('ab?','a')) #['a']

print(re.findall('ab?','abbb')) #['ab']

#匹配所有包含小数在内的数字

print(re.findall('\d+\.?\d*',"asdfasdf123as1.13dfa12adsf1asdf3")) #['123', '1.13', '12', '1', '3']

#.*默认为贪婪匹配

print(re.findall('a.*b','a1b22222222b')) #['a1b22222222b']

#.*?为非贪婪匹配：推荐使用

print(re.findall('a.*?b','a1b22222222b')) #['a1b']

print(re.findall('ab+','a')) #[]

print(re.findall('ab+','abbb')) #['abbb']

#{n,m}

print(re.findall('ab{2}','abbb')) #['abb']

print(re.findall('ab{2,4}','abbb')) #['abb']

print(re.findall('ab{1,}','abbb')) #'ab{1,}' ===> 'ab+'

print(re.findall('ab{0,}','abbb')) #'ab{0,}' ===> 'ab*'

#[]

print(re.findall('a[1*-]b','a1b a*b a-b')) #[]内的都为普通字符了，且如果-没有被转意的话，应该放到[]的开头或结尾

print(re.findall('a[^1*-]b','a1b a*b a-b a=b')) #[]内的^代表的意思是取反，所以结果为['a=b']

print(re.findall('a[0-9]b','a1b a*b a-b a=b')) #[]内的^代表的意思是取反，所以结果为['a=b']

print(re.findall('a[a-z]b','a1b a*b a-b a=b aeb')) #[]内的^代表的意思是取反，所以结果为['a=b']

print(re.findall('a[a-zA-Z]b','a1b a*b a-b a=b aeb aEb')) #[]内的^代表的意思是取反，所以结果为['a=b']

#\# print(re.findall('a\\c','a\c')) #对于正则来说a\\c确实可以匹配到a\c,但是在python解释器读取a\\c时，会发生转义，然后交给re去执行，所以抛出异常

print(re.findall(r'a\\c','a\c')) #r代表告诉解释器使用rawstring，即原生字符串，把我们正则内的所有符号都当普通字符处理，不要转义

print(re.findall('a\\\\c','a\c')) #同上面的意思一样，和上面的结果一样都是['a\\c']

#():分组

print(re.findall('ab+','ababab123')) #['ab', 'ab', 'ab']

print(re.findall('(ab)+123','ababab123')) #['ab']，匹配到末尾的ab123中的ab

print(re.findall('(?:ab)+123','ababab123')) #findall的结果不是匹配的全部内容，而是组内的内容,?:可以让结果为匹配的全部内容

print(re.findall('compan(?:y|ies)','Too many companies have gone bankrupt, and the next one is my company'))

re模块的使用方法：

# ===========================re模块提供的方法介绍===========================

import re

print(re.findall('e','alex make love') ) #['e', 'e', 'e'],返回所有满足匹配条件的结果,放在列表里

print(re.search('e','alex make love').group()) #e,只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以通过调用group()方法得到匹配的字符串,如果字符串没有匹配，则返回None。

print(re.match('e','alex make love')) #None,同search,不过在字符串开始处进行匹配,完全可以用search+^代替match

print(re.split('[ab]','abcd')) #['', '', 'cd']，先按'a'分割得到''和'bcd',再对''和'bcd'分别按'b'分割

print('===>',re.sub('a','A','alex make love')) #===> Alex mAke love，不指定n，默认替换所有

print('===>',re.sub('a','A','alex make love',1)) #===> Alex make love

print('===>',re.sub('a','A','alex make love',2)) #===> Alex mAke love

print('===>',re.sub('^(\w+)(.*?\s)(\w+)(.*?\s)(\w+)(.*?)$',r'\5\2\3\4\1','alex make love')) #===> love make alex

print('===>',re.subn('a','A','alex make love')) #===> ('Alex mAke love', 2),结果带有总共替换的个数

obj=re.compile('\d{2}')

print(obj.search('abc123eeee').group()) #12

print(obj.findall('abc123eeee')) #['12'],重用了obj

三、random模块

使用方式：

import random

print(random.random())#(0,1)----float 大于0且小于1之间的小数

print(random.randint(1,3)) #[1,3] 大于等于1且小于等于3之间的整数

print(random.randrange(1,3)) #[1,3) 大于等于1且小于3之间的整数

print(random.choice([1,'23',[4,5]]))#1或者23或者[4,5]

print(random.sample([1,'23',[4,5]],2))#列表元素任意2个组合

print(random.uniform(1,3))#大于1小于3的小数，如1.927109612082716

item=[1,3,5,7,9]

random.shuffle(item) #打乱item的顺序,相当于"洗牌"

print(item)

随机生成验证码：

def make_code(n):    res=''    for i in range(n):        s1=chr(random.randint(65,90))        s2=str(random.randint(0,9))        res+=random.choice([s1,s2])    return resprint(make_code(9))

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 输出用于分割文件路径的字符串 win下为;,Linux下为:

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所指向的文件或者目录的最后修改时间

os.path.getsize(path) 返回path的大小

----------------------------------------------------------------------------------------------------------------------------------------------------------------

在Linux和Mac平台上，该函数会原样返回path，在windows平台上会将路径中所有字符转换为小写，并将所有斜杠转换为饭斜杠。

>>> os.path.normcase('c:/windows\\system32\\')

'c:\\windows\\system32\\'

规范化路径，如..和/

>>> os.path.normpath('c://windows\\System32\\../Temp/')

'c:\\windows\\Temp'

>>> a='/Users/jieli/test1/\\\a1/\\\\aa.py/../..'

>>> print(os.path.normpath(a))

/Users/jieli/test1

----------------------------------------------------------------------------------------------------------------------------------------------------------------------

os路径处理

#方式一：推荐使用

import os

#具体应用

import os,sys

possible_topdir = os.path.normpath(os.path.join(

os.path.abspath(__file__),

os.pardir, #上一级

os.pardir,

os.pardir

))

sys.path.insert(0,possible_topdir)

#方式二：不推荐使用

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

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       返回操作系统平台名称

爱的发的

hashlib模块

import hashlib

m=hashlib.md5()# m=hashlib.sha256()

m.update('hello'.encode('utf8'))

print(m.hexdigest()) #5d41402abc4b2a76b9719d911017c592

m.update('alvin'.encode('utf8'))

print(m.hexdigest()) #92a7e713c30abbb0319fa07da2a5c4af

m2=hashlib.md5()

m2.update('helloalvin'.encode('utf8'))

print(m2.hexdigest()) #92a7e713c30abbb0319fa07da2a5c4af

'''