logging模块-序列化-random

logging

日志模块

#日志等级:

logging.debug()           #程序排错的时候记录         10

logging.info()            #程序正常运行的时候记录      20

logging.warning()         #警告                     30 
 
logging.error()           #错误                     40

logging.critical()        #危险 严重 不能正常执行      50

也可以用数字显示级别    默认显示级别是warning  error  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用户输出的消息

函数版:

屏幕文件二选一,写入文件中的默然编码是GBK; 是python定义好的,直接拿来用就可以

import logging
logging.basicConfig(
    level = logging.WARNING,                                               #从warning级别开始显示
    format = '%(asctime)s - %(name)s - [%(lineno)d] - %(message)s',        #格式化输出 时间-姓名-行数-内容
    filename='test.log',                                                   #定义一个文件
    filemode='a+'                                                          #定义将日志内容写入文件的方式
)

logging.debug('你是风儿')
logging.info('你是风儿')
logging.warning('你是风儿')
logging.error('你是风儿')
logging.critical('你是风儿')

 

面向对象版:

屏幕文件都可以,支持多个输出方式,写入文件中的编码可以自己定义,自己制定的需要自己一步一步来操作

import logging
logger = logging.getLogger('日志名字')              #获取一个新日志,可以定义名字
formatter = logging.Formatter('%(asctime)s - %(name)s - [%(lineno)d] - %(message)s')    #定义一个模板
ch = logging.StreamHandler()                              #生成屏幕流  打印到屏幕
fh = logging.FileHandler('tt.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.setLevel(logging.DEBUG)      #设置日志的记录等级

logger.addHandler(ch)
logger.addHandler(fh)                #指定要输出的方式

logger.addHandler(boss)

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

 序列化

 json

dump   将对象转换成字符串存储在文件中

load     将文件中的字符串转换成对象

import json

列表:
lst = [1,3,45,67,88]
f = open('test.txt','w',encoding='utf-8')
json.dump(lst,f)

f = open('test.txt','r',encoding='utf-8')
s = json.load(f)
print(type(s),s)         

结果:
<class 'list'> [1, 3, 45, 67, 88]



字典:            
dic = {'name':'meet','age':18}
f = open('test.txt','w',encoding='utf-8')
json.dump(dic,f)

f = open('test.txt','r',encoding='utf-8')
s = json.load(f)
print(type(s),s)          

结果:
<class 'dict'> {'name':'meet','age':18}

dumps   将对象转换成字符串

loads     将字符串转换成对象

import json
lst = [1,2,3,4,5,6]
s = json.dumps(lst)
c = json.loads(s)
print(type(c),c)              


结果:
<class 'list'> [1, 2, 3, 4, 5, 6]

pickle

dump     将对象转换成字节存储到文件中

load       将文件中的字节转换成对象

import pickle
dic = {'1':2,'2':3}
f = open('test.txt','wb')
pickle.dump(dic,f)

f = open('test.txt','rb')
s = pickle.load(f)
print(type(s),s)


结果:
<class 'dict'> {'1': 2, '2': 3}

dumps   将对象转换成字节

loads     将字节转换成对象

import pickle

dic = {'1':2,'2':3}
s = pickle.dumps(dic)
c = pickle.loads(s)
print(type(c),c)

结果:
<class 'dict'> {'1': 2, '2': 3}

总结:

json序列化: 将一个对象转换成一个能够永久存储的内容

将一个对象转换成一个字符串的时候,是序列化   dumps(要转换的对象)

将一个字符串转换成一个对象的时候,是反序列化 loads(要转换的字符串)

将一个对象转换成一个文件的时候,是序列化    dump(要转换的对象,文件句柄)    文件是可见文件

将一个文件转换成一个对象的时候,是反序列化 load(文件句柄)

pickle 序列化: 将一个对象转换成一个能够永久存储的内容

将一个对象转换成字节的时候,是序列化 dumps(要转换的对象)

将字节转换成一个对象的时候,是反序列化 loads(要转换的字节)

将一个对象转换成一个文件的时候,是序列化 dump(要转换的对象,文件句柄)     文件会显示乱码,是不可见文件

将一个文件转换成一个对象的时候,是反序列化 load(文件句柄)

区别:

json        编程语言中是通用的,转一些简单的数据   将对象转换成字符串

pickle    python中内置的,可以将已知对象转换(lambda除外)    将对象转换成字节

random

import random

random.random()                0-1之间的小数
random.uniform(1,5)            1-5之间的小数   
random.randint(1,36)           1-36之间的随机整数
random.randrange(1,10,2)       1-9之间的随机奇数
random.randrange(0,10,2)       1-9之间的随机偶数

lst = [1,2,3,4,55,6,88]
random.choice(lst)               随机选择列表的数字

random.choice(可迭代对象)  

random.choices(lst,k=2)       随机选两个数字,有重复的情况
random.sample(lst,k=2)        随机选两个数字,没有重复的情况

random.shuffle(lst) 
print(lst)                          将列表顺序打乱,打印列表

chr(random.randrange(65,91))         字母A--Z之间随机抽取
chr(random.randrange(97,123)         字母a--z之间随机抽取