常见模块（续上次）

时间 2019-11-11

标签常见模块上次繁體版

原文原文链接

一.time模块

　　经常使用方法：
node

time.time() 获取当前时间戳
python

time.sleep(t) 推迟指定的时间运行算法

　　1.表示时间的三种方式：shell

　　时间戳，格式化的时间字符串，时间元组json

 1 #时间戳：
 2 print(time.time())
 3 #1502176744.8150175
 4 
 5 #格式化时间字符串
 6 print(time.strftime('%Y/%m/%d %H:%M:%S'))
 7 2017/08/08 15:27:19
 8 
 9 #时间元组
10 #localtime将一个时间戳转换为当前时区的struct_time
11 t = time.local()
12 #time.struct_time(tm_year=2017, tm_mon=8, tm_mday=8, tm_hour=15, tm_min=30, tm_sec=45, tm_wday=1, tm_yday=220, tm_isdst=0)

　　总结：小结：时间戳是计算机可以识别的时间；时间字符串是人可以看懂的时间；元组则是用来操做时间的安全

#几种格式之间的转换

#时间戳-->结构化时间
#time.gmtime()  #英国伦敦当地时间 UTC
#time.localtime() #当地时间

#结构化时间-->时间戳
#time_tuple = time.localtime(1500000000)
#time.mktime(time_tuple)
#1500000000.0

#结构化时间-->字符串格式化时间
#time.strftime("%Y-%m-%d",time.localtime(1500000000))
#'2017-07-14'

#字符串格式化时间-->结构化时间
#time.strptime("07/24/2017","%m/%d/%Y")
#time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=0, tm_yday=205, tm_isdst=-1)

#结构化时间-->%a %d %d %H:%M:%S %Y串
#time.asctime(time.localtime(1500000000))
#'Fri Jul 14 10:40:00 2017'
#time.asctime()
#'Mon Jul 24 15:18:33 2017'

#%a %d %d %H:%M:%S %Y串 --> 结构化时间
#time.ctime(时间戳)  若是不传参数，直接返回当前时间的格式化串
#time.ctime()
#'Tue Aug  8 15:56:20 2017'
#time.ctime(1500000000)
#'Fri Jul 14 10:40:00 2017'

二.random模块

#import time

#随机小数
#random.random()     (0-1小数)
#0.9167746266539144
#random.uniform(1,3)  (1-3小数)
#1.9542609515193614

#随机整数
#random. randint(1,5)  (1-5间随机整数，可取到5)
#2

#随机选择一个或者多个返回
#random.choice(1,5,[5,6])
#random.sample([[4,5],[89,58],99,66],2)
#2为返回的个数

#打乱列表顺序
#li = [4,5,6,8,2,7]
#random.shuffle(li)  (返回值为None)
#print(li)
#[5, 6, 2, 7, 8, 4]  (每次返回结果顺序不同)

三.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的大小

# stat 结构:
# 
# st_mode: inode 保护模式
# st_ino: inode 节点号。
# st_dev: inode 驻留的设备。
# st_nlink: inode 的连接数。
# st_uid: 全部者的用户ID。
# st_gid: 全部者的组ID。
# st_size: 普通文件以字节为单位的大小；包含等待某些特殊文件的数据。
# st_atime: 上次访问的时间。
# st_mtime: 最后一次修改的时间。
# st_ctime: 由操做系统报告的"ctime"。在某些系统上（如Unix）是最新的元数据更改的时间，在其它系统上（如Windows）是建立时间（详细信息参见平台的文档）。

四.sys模块

　　sys模块是与python解释器交互的一个接口bash

#sys.argv           命令行参数List，第一个元素是程序自己路径
#sys.exit(n)        退出程序，正常退出时exit(0)
#sys.version        获取Python解释程序的版本信息
#sys.maxint         最大的Int值
#sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
#sys.platform       返回操做系统平台名称

五.序列化模块

　　序列化定义:将本来列表、字典等内容专户为字符串的过程数据结构

　　eval():将字符串str当成有效的表达式来求值并返回计算结果dom

　　缺点：虽然eval()也能实现此功能，可是安全性差函数

　　一、以某种存储形式使自定义对象持久化；

　　二、将对象从一个地方传递到另外一个地方。

　　三、使程序更具维护性。

　　对象持久化(对象持久化是指将内存中的对象保存到可永久保存的存储设备中（如磁盘）的一种技术)

　　Json模块（dump，dumps,load,loads）

#dumps loads  
# import json
# dic = {'k1':56,'k2':85,'k3':'egon'}
# dic_str = json.dumps(dic)
# print(type(dic_str),dic_str) #序列化
# <class 'str'> {"k1": 56, "k2": 85, "k3": "egon"}
# str_dict = json.loads(dic_str)
# print(type(str_dict),str_dict) #反序列化
# <class 'dict'> {'k1': 56, 'k2': 85, 'k3': 'egon'}

#也可嵌套使用
# import json
# l = [1,[1,2,3],{'k1':'egon','k2':'alex'},5]
# l_str = json.dumps(l)
# print(type(l_str),l_str)
# # <class 'str'> [1, [1, 2, 3], {"k1": "egon", "k2": "alex"}, 5]
# str_l = json.loads(l_str)
# print(type(str_l),str_l)
 # <class 'list'> [1, [1, 2, 3], {'k1': 'egon', 'k2': 'alex'}, 5]

import json
# f1 = open('json_file','w')
# dic = {'k1':'zhiku','k2':'huawei','k3':'chuanqi'}
# json.dump(dic,f1)
# f.close()
 #dump方法接收一个文件句柄，直接将字典转换成json字符串写入文件

# f2 = open('json_file')
# dic1 = json.load(f2)
# print(type(dic1),dic1)
# <class 'dict'> {'k1': 'zhiku', 'k2': 'huawei', 'k3': 'chuanqi'}
 #load方法接收一个文件句柄，直接将文件中的json字符串转换成数据结构返回

　　json&pickle模块

json，用于字符串和 python数据类型间进行转换
pickle，用于python特有的类型和 python的数据类型间进行转换
pickle模块提供了四个功能：dumps、dump(序列化，存）、loads（反序列化，读）、load （不只能够序列化字典，列表...能够把python中任意的数据类型序列化）

import pickle
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = pickle.dumps(dic)
print(str_dic)  #一串二进制内容
#b'\x80\x03}q\x00(X\x02\x00\x00\x00k1q\x01X\x02\x00\x00\x00v1q\x02X\x02\x00\x00\x00k2q\x03X\x02\x00\x00\x00v2q\x04X\x02\x00\x00\x00k3q\x05X\x02\x00\x00\x00v3q\x06u.'

dic2 = pickle.loads(str_dic)
print(dic2)    #字典
#{'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}

import time
struct_time  = time.localtime(1000000000)
print(struct_time)
#time.struct_time(tm_year=2001, tm_mon=9, tm_mday=9, tm_hour=9, tm_min=46, tm_sec=40, tm_wday=6, tm_yday=252, tm_isdst=0)
f = open('pickle_file','wb')
pickle.dump(struct_time,f)
f.close()

f = open('pickle_file','rb')
struct_time2 = pickle.load(f)
print(struct_time.tm_year)
#2001

　　shelve模块

　　shelve只提供给咱们一个open方法，是用key来访问的，使用起来和字典相似。

#import shelve
# f = shelve.open('shelve_file')
# f['key'] ={'k1':'niucha','k2':'daoxiang','k3':'egon'}#若是k不存在则报错
# f.close()
# 
# f1 = shelve.open('shelve_file')
# existing = f1['key']
# f1.close()
# print(existing) 
# {'k1': 'niucha', 'k2': 'daoxiang', 'k3': 'egon'}

　　这个模块有个限制：不支持多个程序同一时间往同一个文件中进行写操做，若是只是读文件，能够用其打开。

　　shelve在默认状况下是不会记录待持久化对象的任何修改的，因此咱们在shelve.open()时候须要修改默认参数，不然对象的修改不会保存。

# import shelve
# f = shelve.open('shelve_file')
# print(f['key'])
# f['key']['new_value'] = 'this is a beautiful girl'
# print(f['key'])
# f.close()

# import shelve
# f1 = shelve.open('shelve_file',writeback=True)
# print(f1['key'])
# f1['key']['new_value'] = 'this is a beautiful girl'
# print(f1['key'])
# f1.close()
#{'k1': 'niucha', 'k2': 'daoxiang', 'k3': 'egon', 'new_value': 'this is a beautiful girl'}

六.经常使用模块二

　　1.hashlib模块(提供常见MD5，SHA1摘要算法)　

　　什么是摘要算法呢？摘要算法又称哈希算法、散列算法。它经过一个函数，把任意长度的数据转换为一个长度固定的数据串（一般用16进制的字符串表示）。

　　摘要算法就是经过摘要函数f()对任意长度的数据data计算出固定长度的摘要digest，目的是为了发现原始数据是否被人篡改过。

　　摘要算法之因此能指出数据是否被篡改过，就是由于摘要函数是一个单向函数，计算f(data)很容易，但经过digest反推data却很是困难。并且，对原始数据作一个bit的修改，都会致使计算出的摘要彻底不一样。

#计算MD5值
import hashlib
md5_obj = hashlib.md5()
md5_obj.update('iloveyou'.encode('utf-8'))
print(md5_obj.hexdigest())
# f25a2fc72690b780b2a14e140ef6a9e0


#计算SHA1值
import hashlib
sha1 = hashlib.sha1()
sha1.update('i care you '.encode('utf-8'))
sha1.update('are you know?'.encode('utf-8'))
print(sha1.hexdigest())
#64540be8d040c9b5502f431c40ae5354612838c8

#加盐
#因为经常使用口令的MD5值很容易被计算出来，因此，要确保存储的用户口令不是那些已经被计算出来的经常使用口令的MD5，这一方法经过对原始口令加一个复杂字符串来实现，俗称“加盐”：
#hashlib.md5("salt".encode("utf8"))

　　文件校验

# import os
# import hashlib
# md5_obj = hashlib.md5('egon'.encode('utf-8'))
# # md5_obj = hashlib.md5()
# f = open('filename','rb')
# filesize = os.path.getsize('filename')
# while filesize > 0:
#     if filesize > 1024:
#         content = f.read(1024)
#         filesize -= 1024
#     else:
#         content = f.read(filesize)
#         filesize -= filesize
#     # for line in f:
#     #     md5_obj.update(line.encode('utf-8'))
#     md5_obj.update(content)
#     print(md5_obj.hexdigest())
# import hashlib
# md5_obj = hashlib.md5()
# md5_obj.update('iloveyou'.encode('utf-8'))
# print(md5_obj.hexdigest())
# # f25a2fc72690b780b2a14e140ef6a9e0

　　2.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 %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',  
                    datefmt='%a, %d %b %Y %H:%M:%S',  
                    filename='/tmp/test.log',  
                    filemode='w')  
logging.debug('debug message')  
logging.info('info message')  
logging.warning('warning message')  
logging.error('error message')  
logging.critical('critical message')

　　参数详解：

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

　　logger对象配置

import logging

logger = logging.getLogger()
# 建立一个handler，用于写入日志文件
fh = logging.FileHandler('test.log')

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

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

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

logger.addHandler(fh) #logger对象能够添加多个fh和ch对象
logger.addHandler(ch)

logger.debug('logger debug message')
logger.info('logger info message')
logger.warning('logger warning message')
logger.error('logger error message')
logger.critical('logger critical message')

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

　　封装到函数里

import logging
def my_logger(filename,file=True,stream = True):
    logger = logging.getLogger()
    formatter = logging.Formatter(fmt='%(name)s %(asctime)s [%(lineno)d] --  %(message)s',
                                  datefmt='%d/%m/%y %H:%M:%S')
    logger.setLevel(logging.DEBUG) #指定日志打印的等级
    if file:
        file_handler = logging.FileHandler(filename,encoding='utf-8')
        file_handler.setFormatter(formatter)  # 文件流 文件操做符
        logger.addHandler(file_handler)
    if stream:
        stream_handler = logging.StreamHandler()
        stream_handler.setFormatter(formatter) #屏幕流 屏幕操做符
        logger.addHandler(stream_handler)
    return logger
logger = my_logger('logging',file=False)
logger.warning("出错了")