python模块第二篇

　　众所周知,在我们每个软件中都存在日志,有时候出现错误时需要上传日志,在python语言中,有一个logging模块,这个就是日志模块,主要记录一些信息,在logging模块中,有两种方式,第一种是函数版,另外一种是面向对象版本,先来看看函数版的简写版

import logging
logging.debug("你好")
logging.info("你好")
logging.warning("你好")
logging.error("你好")
logging.critical("你好")

　　在logging模块中,级别为CRITICAL>ERROR>WARNING>INFO>DEBUG,对应在数字上就是:50.40.30.20.10,我们可以手动修改一下日志等级

logging.basicConfig(level = logging.DEBUG,或者level = 10)

　　在默认情况下,在输出界面输出的是warning及以上的级别的日志,写出来的这个简写版日志,可以用但是不够灵活,我们可以指定一个模板来使它变得更加灵活

函数版日志模板

logging.basicConfig(
    level=logging.大写 或者 level=10,20,30,40,50
    format='%(asctime)s - %(name)s - [%(lineno)d] - %(message)s',
    filename='test.log',
    filemode='a+')
logging.debug("你好")
logging.info("你好")
logging.warning("你好")
logging.error("你好")
logging.critical("你好")

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

　　filename：用指定的文件名创建FiledHandler，这样日志会被存储在指定的文件中。

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

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

　　datefmt：指定日期时间格式。

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

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

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
生成
logger = logging.getLogger('可以命名')    获取新的日志
formatter = logging.Formatter('%(asctime)s - %(name)s - [%(lineno)d] - %(message)S')定义一个模板:输出格式
ch = logging.StreamHandler()                                    生成一个屏幕流
fh = logging.FileHandler('.log','a',encoding='utf-8')           生成一个文件流
boss = logging.FileHandler('boss.log','a',encoding='utf-8')     生成一个新的日志
boss_formatter = logging.Formatter('%(asctime)s-%(message)s')
绑定
ch.setFormatter(formatter)         把自己定义的模板绑定给创建的存储日志的流
fh.setFormatter(formatter)
boss.setFormatter(boss_formatter)  写一个新的模板,绑定

logger.addHandler(ch),    将屏幕流加入日志绑定
logger.addHandler(fh),    将文件流加入日志绑定
logger.addHandler(boss),  将文件流加入日志绑定

logger.setLevel(logging,DEBUG) 修改等级 

logger.debug('你好') 
logger.info('你好') 
logger.warning('你好') 
logger.error('你好') 
logger.critical('你好')

函数版和面向对象版之间的区别:

　　函数版:写入屏幕和文件二选一,只能在一个地方显示结果,在文件中默认编码为GBK

　　　　　它是python中直接定义好的,可以直接拿来用

　　面向对象版:写入屏幕或文件中都可以,支持多个输出方式,写入文件中的编码方式可以自定义

　　　　　它是我们自己制定的,需要一步一步来操作

序列化模块

json模块,将一个对象转换成能永久存储的内容,它是多种语言通用的一个模块,

主要用于字符串和python数据类型之间的转换,通过dump,load.dumps,loads四个功能来实现

　　dump:对象转换成文件-->序列化-->dump(要转的内容,文件句柄)-->可见文件

　　load:文件转换成对象-->反序列化-->load(文件句柄)-->对象

import json
dic = {'name':'meet','age':'18'}
f = open('test.txt','w',encoding='utf-8')
s = json.dump(dic,f))
print(s)     　　　　　　　
n = json.load(f)
print(n)

lst = [1,2,3,4,5,6]
f = open('test.txt','w',encoding='utf-8')
s1 = json.dump(lst,f))
print(s1)
n1 = json.load(f)
print(n)

　　dumps:将对象转换成字符串-->序列化-->dumps(要转换的对象)-->字符串

　　loads:将字符串转换成对象-->反序列化-->loads(要转化的字符串)-->对象

import json
dic = {'name':'meet','age':18}
s = json.dumps(dic)
print(type(s),s)　　　　　　　　class:'str',{"name":"meet","age":18}

n = json.loads(s)
print(type(n),n)　　　　　　　　class:'dic',{'name':'meet','age':18}

json的格式化输出:

data = {'username':['李华',[1,2,3],'二愣子'],'sex':'male','age':16}
json_dic2=json.dumps(data,sort_keys=True,ensure_ascii=False,indent=2,separators=(',',':'))

 ps:

　　Skipkeys：默认值是False，如果dict的keys内的数据不是python的基本类型(str,unicode,int,long,float,bool,None)，设置为False时，就会报TypeError的错误。此时设置成True，则会跳过这类key 

　　keys:设置为False时,就会报TypeError错误,如果设置成True,就会跳过
　　sort_keys:根据keys的值进行排序
　　ensure_ascii:为True时,非ascii码字符显示为\u...,设置成False,中文就可以显示
　　indent,如果是0,就顶格分行显示,如果为空,就一行紧凑显示,否则就换行并按照indent的数值显示空格
　　separators：分隔符，实际上是(item_separator,dict_separator)的一个元组，默认的就是(',',':')；
　　　　这表示dictionary内keys之间用","隔开，而Key和value之间用":"隔开。

pickle模块

pickle模块,将一个对象转换成能永久存储的内容,它是python特有的模块类型,可以把目前所知(除lambda以外)的数据类型进行转换,

主要通过dump,load.dumps,loads四个功能来实现

　　dump:对象转成文件-->序列化-->dump(要转换的对象,文件句柄)-->文件(不可见)

　　load:文件转换为对象-->反序列化-->load(文件句柄)-->对象

f = open('文件名','wb')
dic = {1:2,2:3}
pickle.dump(dic,f)

 f = open('文件名','rb')
s = pickle.load(f)
print(type(s),s)

　　dumps:对象转换成字节-->序列化-->dumps(要转换的对象)-->字节

　　loads:字节转换成对象-->反序列化-->loads(要转换的字节)-->对象

dic = {'name':'yiyi','age':18}
s = pickle.dumps(dic)
print(type(s),s)　　　　　　class:bytes,b'\x80\x03}q\x00(X\x04\x00\x00\x00nameq\x01X\x04\x00\x00\x00yiyiq\x02X\x03\x00\x00\x00ageq\x03K\x12u.'

c = pickle.loads(s)
print(type(c),c)　　　　　　class:dic,{'name':'yiyi','age':18}

random模块

 random是一个随机模块,一般用来生成一些没有规律的内容

import random
0-1之间的小数:　　　　random.random()
指定数字之间随机小数: random.uniform(1,5)
随机整数:　　　　　　 random.randint(0,36),可以指定
随机偶数:　　　　　　 random.randrange(0,10,2)
随机奇数:　　　　　　 random,randrange(1,10,2)

 除了数字,我们还可以在可迭代对象中随机抽取

lst = [12,3,5,56,32,45]
random.choice(lst)         随机抽取一个
random.choices(lst,k= )    随机抽取多个,但有重复,可以指定k的值
random.sample(lst,k= )     随机抽取多个,没有重复,可以指定k的值
random.shuffle(lst)　　　　 打散顺序

 随机取字母:　　random.randrange(65,91)