Python--模块之sys模块、logging模块、序列化json模块、序列化pickle模块

sys模块

sys.argv           命令行参数List，第一个元素是程序本身路径
sys.exit(n)        退出程序，正常退出时exit(0)
sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值

示例：

import sys
count = 1
while count <10:
    print(count)
    if count == 8:
        sys.exit()
    count += 1

print('ending')
结果：
1
2
3
4
5
6
7
8

import sys
print(sys.path)
结果：
['C:\\Users\\Administrator\\PycharmProjects\\untitled', 'C:\\Users\\Administrator\\PycharmProjects\\untitled4', 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python36\\python36.zip', 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python36\\DLLs', 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python36\\lib', 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python36', 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python36\\lib\\site-packages']

logging模块

函数式简单配置

import logging  
logging.debug('debug message')  
logging.info('info message')  
logging.warning('warning message')  
logging.error('error message')  
logging.critical('critical message')  

默认情况下Python的logging模块将日志打印到了标准输出中，且只显示了大于等于WARNING级别的日志，这说明默认的日志级别设置为WARNING（日志级别等级CRITICAL > ERROR > WARNING > INFO > DEBUG），默认的日志格式为日志级别：Logger名称：用户输出消息。

灵活配置日志级别，日志格式，输出位置:

import logging
logging.basicConfig(level=logging.DEBUG,
                    format='%(asctime)s %(name)s %(levelname)s %(message)s')
logging.debug('debug message')
logging.info('info message')
logging.warning('warning message')
logging.error('error message')
logging.critical('critical message')
结果：
2017-06-22 17:45:50,036 root DEBUG debug message
2017-06-22 17:45:50,036 root INFO info message
2017-06-22 17:45:50,037 root WARNING warning message
2017-06-22 17:45:50,037 root ERROR error message
2017-06-22 17:45:50,037 root CRITICAL critical message

配置参数：

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

filename：用指定的文件名创建FiledHandler，这样日志会被存储在指定的文件中。
filemode：文件打开方式，在指定了filename时使用这个参数，默认值为“a”还可指定为“w”。
format：指定handler使用的日志显示格式。
datefmt：指定日期时间格式。
level：设置rootlogger（后边会讲解具体概念）的日志级别
stream：用指定的stream创建StreamHandler。可以指定输出到sys.stderr,sys.stdout或者文件

format参数中可能用到的格式化串：
%(name)s Logger的名字
%(levelno)s 数字形式的日志级别
%(levelname)s 文本形式的日志级别
%(pathname)s 调用日志输出函数的模块的完整路径名，可能没有
%(filename)s 调用日志输出函数的模块的文件名
%(lineno)d 调用日志输出函数的语句所在的代码行
%(asctime)s 字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒
%(message)s用户输出的消息

logger对象配置

import logging
def get_logger():
    logger_obj=logging.getLogger()
    print(type(logger_obj)) #<class 'logging.RootLogger'>
    #创建一个handler，用于写入日志文件
    fh=logging.FileHandler('logger_file.txt')
    fh.setLevel(logging.ERROR)

    #再创建一个handler，用于输出到控制台
    ch=logging.StreamHandler()
    ch.setLevel(logging.CRITICAL)

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

    fh.setFormatter(formatter)
    ch.setFormatter(formatter)

    #logger对象可以添加多个fh和ch对象
    logger_obj.addHandler(fh)
    logger_obj.addHandler(ch)

    return logger_obj

logger_obj=get_logger()

logger_obj.info('info')
logger_obj.debug('debug')
logger_obj.warning('warning')
logger_obj.error('error')
logger_obj.critical('critical')
结果：
<class 'logging.RootLogger'>
2017-06-22 18:17:29,726 - root - CRITICAL - critical

logging库提供了多个组件：Logger、Handler、Filter、Formatter。Logger对象提供应用程序可直接使用的接口，Handler发送日志到适当的目的地，Filter提供了过滤日志信息的方法，Formatter指定日志显示格式。另外，可以通过：logger.setLevel(logging.Debug)设置级别。

序列化模块

       我们把对象(变量)从内存中变成可存储或传输的过程称之为序列化，在Python中叫pickling，在其他语言中也被称之为serialization，marshalling，flattening等等，都是一个意思。序列化之后，就可以把序列化后的内容写入磁盘，或者通过网络传输到别的机器上。反过来，把变量内容从序列化的对象重新读到内存里称之为反序列化，即unpickling。

json模块

       如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如XML，但更好的方法是序列化为JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。

JSON表示的对象就是标准的JavaScript语言的对象一个子集，JSON和Python内置的数据类型对应如下：

json类型                    Python类型
{}                          dict
[]                          list
"string"                    str
1234.56                     int或float
true/false                  True/False
null                        None

栗子：
import json
i=100
s='hello'
t=(1,4,6)
l=[3,5,7]
d={'name':'yuanhao'}

json_str1=json.dumps(i)
json_str2=json.dumps(s)
json_str3=json.dumps(t)
json_str4=json.dumps(l)
json_str5=json.dumps(d)

print(json_str1,type(json_str1)) #100 <class 'str'>
print(json_str2,type(json_str2)) #"hello" <class 'str'>
print(json_str3,type(json_str3)) #[1, 4, 6] <class 'str'>
print(json_str4,type(json_str4)) #[3, 5, 7] <class 'str'>
print(json_str5,type(json_str5)) #{"name": "yuanhao"} <class 'str'>

python在文本中的使用：

# 序列化
import json

dic={'name':'egon','age':23,'sex':"male"}
print(type(dic)) #<class 'dict'>

data=json.dumps(dic)
print('type',type(data)) #type <class 'str'>
print('data',data) #data {"name": "egon", "age": 23, "sex": "male"}


f=open(r'C:\Users\Administrator\PycharmProjects\untitled3\623周末大作业\作业2\序列化对象','w')
f.write(data)
f.close()

#反序列化
import json
f=open(r'C:\Users\Administrator\PycharmProjects\untitled3\623周末大作业\作业2\序列化对象','r')
new_data=json.loads(f.read())
print(new_data,type(new_data))

 pickle模块

##----------------------------序列化
import pickle
 
dic={'name':'alvin','age':23,'sex':'male'}
 
print(type(dic))#<class 'dict'>
 
j=pickle.dumps(dic)
print(type(j))#<class 'bytes'>
 
 
f=open('序列化对象_pickle','wb')#注意是w是写入str,wb是写入bytes,j是'bytes'
f.write(j)  #-------------------等价于pickle.dump(dic,f)
 
f.close()
#-------------------------反序列化
import pickle
f=open('序列化对象_pickle','rb')
 
data=pickle.loads(f.read())#  等价于data=pickle.load(f)
 

print(data)

print(data['age'])
运行结果：

<class 'dict'>
<class 'bytes'>
{'name': 'alvin', 'age': 23, 'sex': 'male'}
23

shelve模块

shelve模块比pickle模块简单，只有一个open函数，返回类似字典的对象，可读可写;key必须为字符串，而值可以是python所支持的数据类型

import shelve

f=shelve.open(r'shelve.txt')

f['stu1_info']={'name':'alex','age':'18'}
f['stu2_info']={'name':'alvin','age':'20'}
f['school_info']={'website':'oldboyedu.com','city':'beijing'}
#
# f.close()

print(f.get('stu1_info')['age'])
print(f.get('stu2_info')['name'])
print(f.get('school_info')['website'])

运行结果：
18
alvin
oldboyedu.com