常用模块学习

本节大纲

模块介绍
Time&datetime
Random
Os
Sys
Shutil
Json & picle
Shelve
Xml处理
Yaml处理
Configparser
Hashlib
Subprocess
Logging
Re正则表达式

模块介绍：

模块：

用来从逻辑上组织python代码（变量，函数，类，逻辑：实现一个功能），本质就是.py结尾的python文件（文件名：文件名为test.py，模块名:test）

程序包：

         用来从逻辑上组织模块，本质是一个目录（必须带有一个__init__.py文件）。

使用方法：

        Import  module_name
    From module_name import *
    From module_name import m1,m2,m3
    From module_name import logger as logger_xxx  #如果在改文件下有相同函数，重命名再调用。

Import本质：

Import module_name 相当于将module_name中module_name.py所有的代码赋值给module_name调用；
From module_name import m1相当于已经定义了某个函数或者变量，直接使用。
    导入模块的本质就是把python文件解释一遍。
    导入一个程序包import 文件夹的本质就是执行该包下的__init__.py文件
    导入不通目录时添加路径：
    base = os.path.dirname(os.path.abspath(__file__))
sys.path.append(base)

导入优化：

每次会去寻找mud.name，怎么优化呢？
    import mud

def all():
    mud.name()
    print("这是number")

def search():
    mud.name()
    print("这是search")

优化方案：

from mud import name

def all1():
        name()
        print("这是number")

def search2():
        name()
        print("这是search")

 

Time&datetime

Time：import time  

 

在Python中，通常有这几种方式来表示时间：
    1.时间戳
    2.格式化的时间字符串
    3.元组（struct_time）
共九个元素。由于Python的time模块实现主要调用C库，所以各个平台可能有所不同。
UTC(Coordinated Universal Time,世界协调时)亦即格林威治天问世间，世界标准时间。在
中国为UTC+8。DST（Daylight Saving Time）中国夏令时。
    时间戳（timestamp）的方式：通常来说，时间戳表示的是从1970年1月1日00：00：00开始按秒计算的偏移量。我们运行“type（time.time（））”，返回float类型。返回时间戳方式的函数主要有time（），clock（）等。
    元组（struct_time）方式：struct_time元组共有9个元素，返回struct_time的函数主要有gmtime(),localtime(),strptime().下面列出这种方式元组中的几个元素：
gmtime：

>>> time.gmtime(31536000)

time.struct_time(tm_year=1971, tm_mon=1, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=

0, tm_wday=4, tm_yday=1, tm_isdst=0)

time.localtime和time.mktime(x)间的转换：

>>> time.localtime()

time.struct_time(tm_year=2017, tm_mon=10, tm_mday=27, tm_hour=10, tm_min=59, tm_

sec=41, tm_wday=4, tm_yday=300, tm_isdst=0)

 

>>> x = time.localtime()

>>> time.mktime(x)

1509073402.0

strftime：

>>> x = time.localtime()

>>> time.strftime("%Y-%m-%d %H:%M:%S",x) 解释%Y == x.tm_year

'2017-10-27 11:03:22'


strptime：

>>> time.strptime('2017-10-27 11:03:22',"%Y-%m-%d %H:%M:%S")

time.struct_time(tm_year=2017, tm_mon=10, tm_mday=27, tm_hour=11, tm_min=3, tm_s

ec=22, tm_wday=4, tm_yday=300, tm_isdst=-1)

asctime：

>>> time.asctime()

'Fri Oct 27 14:52:02 2017'

>>> time.asctime((2017,12,10,14,12,10,10,3,10))

'Thu Dec 10 14:12:10 2017'

Ctime：

>>> time.ctime()

'Fri Oct 27 14:56:55 2017'

>>> time.ctime(100)

'Thu Jan  1 08:01:40 1970'

 

Datetime：import datetime

>>> datetime.datetime.now()
datetime.datetime(2017, 10, 27, 15, 0, 56, 32101) #当前时间

>>> datetime.datetime.now()+datetime.timedelta(3) #修改时间到3天后
datetime.datetime(2017, 10, 30, 15, 1, 55, 331101)

>>> datetime.datetime.now()+datetime.timedelta(-3) #修改时间到3天前
datetime.datetime(2017, 10, 24, 15, 2, 20, 788101)

>>> datetime.datetime.now()+datetime.timedelta(hours=3) #修改时间到3小时后
datetime.datetime(2017, 10, 27, 18, 2, 55, 763101)

>>> datetime.datetime.now()+datetime.timedelta(hours=-3) #修改时间到3小时前
datetime.datetime(2017, 10, 27, 12, 3, 13, 788101)

 

Random：import random

random.random()
#用于生成一个0到1的随机浮点数：0<= N <1.0

random.randint(1,4)
#函数原型为random.randint(a,b)，用于生成一个指定范围内的整数。结果指的是整数

random.randrange(10)
#函数原型为：random.randrange([start],stop[,step]);
#从指定范围内，按指定基数递增的集合中获取一个随机数。如random.randrange(10，100，2)。结果指的是范围
#random.randrange(10，100，2)在结果上与random.choice(range(10,100,2))等效。

random.choice('xxx')
#random.choice从序列中获取一个随机元素。
#其函数原型为：random.choice(sequence).参数sequence表示一个有序类型。
#这里要说明下：sequence在python不是一种特定的类型，二十泛指一系列的类型。
#list，tuple，字符串都属于sequence。有关sequence可以查看python手册数据模型一章。

random.sample([1,2,3],2)
#random.sample的函数原型为random.sample(sequence,k),从指定序列中随机获取指定长度的片段，K不能超过总长度。

items = [1,2,3,4,5,6]
#列表都是有顺序的，怎么让他无序呐
random.shuffle(items)
print(items)
#可以看见通过shuffle函数列表的顺序变了


#简单的随机数字游戏
#该列子加列表是为了突出字符是循环单个组成的

#check = ''

check = []

for i in range(5):
    num = random.randrange(5)
    if num == i:
        tmp = chr(random.randint(60,100))
    else:
        tmp = random.randint(0,9)
    check.append(str(tmp))
print(check)

 

os

import 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    #输出用于分割文件路径的字符串
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.join('e','目录名字')
os.path.getatime(path)  #返回path所指向的文件或者目录的最后存取时间
os.path.getmtime(path)  #返回path所指向的文件或者目录的最后修改时间os.path.exists()

 sys模块

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

等待进度条：

1 for i in  range(10):
2     sys.stdout.write('#')
3     sys.stdout.flush()
4     time.sleep(0.5)

shutil模块

shutil.copyfileobj(x,b) #复制文件x到b
example：
f11 = open('f1','r')
f22 = open('f2','w')
shutil.copyfileobj(f11,f22)
f11.close()
f22.close()


shutil.copyfile('f1','f2') #直接写入文件名字进行文件复制。

shutil.copymode('f1','f3') #根据当前用户的umask接受权限。内容、组、用户、均不变。

shutil.copystat('f1','f3') #使用copystat()只会复制与文件关联的权限和日期。

shutil.copy(src,dst) #复制一个文件到一个文件或一个目录。

shutil.copy2(src,dst)      #在copy上的基础上再复制文件最后访问时间与修改时间也复制过来了，类似于cp –p的东西。

shutil.copytree( olddir, newdir, True/Flase) #把olddir拷贝一份newdir，如果第3个参数是True，则复制目录时将保持文件夹下的符号连接，如果第3个参数是False，则将在复制的目录下生成物理副本来替代符号连接。

shutil.rmtree('src') #删除目录。

shutil.make_archive(base_name,format,..)
#shutil.make_archive('D:\\pythonl\\nn','zip','D:\\pythonl\\M') 将M这个目录打包到指定目录D:\\pythonl下，并起名为nn.zip压缩包
#创建压缩包并返回文件路径，例如：zip，tar
#base_name：压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径。
#如：www ==》 保存至当前路径
#如：/user/www ==》保存至/User/xxx
#format:压缩包种类，‘zip’，‘tar’，‘bztar’，‘gztar’
#root_dir:要压缩的文件夹路径（默认当前目录）
#owner：用户,默认当前用户
#group：组，默认当前组
#logger：用于记录日志，通常是logging.logger对象

 

zipfile模块

 

import zipfile

#压缩文件
z = zipfile.ZipFile("11-1.zip","w")

z.write("f3")
z.write("f1")

z.close()

#解压文件
z = zipfile.ZipFile("11-1.zip","r")
z.extractall()
z.close()

configparser模块

configParser 模块用于操作配置文件，注：Parser汉译为“解析”之意。

import configparser

config = configparser.ConfigParser() #创建ConfigParser实例

#第一种写法
config['DEFAULT]'] = {'ServerAliveInterval':'45',
'Compression':'yes',
'CompressionLevel':'9',
'ForwardX11':'yes'
}

#第二种写法
config['bitbucket.org'] = {}
config['bitbucket.org']['User'] ='hg'

config['topsecret.server.com']={}
config['topsecret.server.com']['Port'] ='50022'
config['topsecret.server.com']['ForwardX11'] ='no'

#将上面内容写入文件中
with open('f2','w') as  configfile:
    config.write(configfile)

#生成文件内容如下

conf.read('f2') #读取配置文件  conf['bitbucket.org']['user'] #返回值hg

 hashlib模块

import hashlib

"""用于加密相关的操作，3.X里代替了md5模块和啥模块，主要提供SHA1,SHA224,SHA256,SHA384,SHA512,MD5算法"""

例子：
m = hashlib.md5()
m.update(b"hhhh")
print(m.hexdigest())
m.update(b'xxx')
print(m.hexdigest())

结果：

 

 logging模块

logging模块提供了标准的日志接口，你可以通过它存储各式格式的日志，logging的日志可以分为debug（），info（），warning（），error（）and critical（）5个级别
日志级别大小关系为：CRITICAL > ERROR > WARNING > INFO > DEBUG > NOTSET。

#日志级别从大到小

1  logging.critical("server is run")
2  logging.error("error...")
3  logging.warning("user ....login in")
4  logging.info("This is info.")
5  logging.debug("debug...")

#将日志输入文件

logging.basicConfig(filename='f3',level=logging.INFO,
                    format='%(name)s %(filename)s %(funcName)s %(module)s %(lineno)d %(created)f  %(relativeCreated)d %(asctime)s  %(message)s',
                    datefmt='%m/%d/%Y %I:%M:%S %p')
def run():
    logging.info("xxx")

run() #函数调用

#日志格式

%(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 　　　　　 #字符串形式的当前时间，默认格式“11/02/2017 04:32:51,98”.逗号后面是毫秒

%(message)s                #用户输出消息

%(thread)s                   #线程ID。可能没有

%(process)s                #进程ID。可能没有

%(threadName)s       #线程名。可能没有

# Python 使用logging模块记录日志涉及四个主要类，使用官方文档中的概括最为合适：
# 1.logger提供了应用程序可以直接使用的接口
# 2.handler将(logger创建的)日志记录发送到合适的目的输出
# 3.filter提供了细度设备来决定输出哪条日志记录
# 4.formatter决定日志记录的最终输出格式
#
# logger
# 每个程序在输出信息之前都要获得一个Logger。logger通常对应了程序的模块名。比如聊天工具的图形界面模块：
# LOG = logging.getLogger("chat.gui")
# 核心模块：
# LOG = logging.getLogger("chat.kernel")

Logger接口例子：

import logging 

#创建一个logger
logger = logging.getLogger('test')
logger.setLevel(logging.DEBUG)

#创建一个handler 和设置级别,屏幕上展示
ch = logging.StreamHandler()
ch.setLevel(logging.WARNING)

#创建一个handler和设置一个级别，写入到文件里面
fh = logging.FileHandler("access.log",encoding='utf-8') #如果不加，中文是乱码
fh.setLevel(logging.ERROR)

#定义一个日志格式
ch_format=logging.Formatter('%(name)s - %(filename)s  - %(asctime)s - %(message)s')
fh_format=logging.Formatter('%(name)s %(filename)s %(asctime)s %(message)s')

#结合起来
ch.setFormatter(ch_format)
fh.setFormatter(fh_format)

logger.addHandler(ch)
logger.addHandler(fh)

logger.warning("这是警告级别") #因为日志级别为WARNING，所以只有屏幕展示，不符合文件写入级别，所以文件无内容
logger.error("这是错误级别")       #符合文件和屏幕日志级别，都展示

日志自动截断 

import logging
import time
from logging import handlers

logger = logging.getLogger('test')

log_file ="timelog.log"

#定义日志大小最大10个字节，2个文件
#除了日志大小截断，还可以根据时间，when参数是一个字符串。表示时间间隔单位，不区分大小写，他以下取值：
#S秒,M分,H小时,D天,W每星期（interval＝＝0时代表星期一）,midnight每天凌晨

#fh = handlers.RotatingFileHandler(filename=log_file,maxBytes=10,backupCount=2)
fh = handlers.TimedRotatingFileHandler(filename=log_file,when='S',backupCount=2)




formatter = logging.Formatter('%(asctime)s %(module)s %(message)s')

fh.setFormatter(formatter)

logger.addHandler(fh)

#logging开始调用
logger.warning("1")
logger.warning("12")
logger.warning("123")
time.sleep(2)
logger.warning("12345")
logger.warning("13456789")

 re模块

常用正则表达式符号：

'.'     默认匹配除\n之外的任意一个字符，若指定flag DOTALL,则匹配任意字符，包括换行
'^'     匹配字符开头，若指定flags MULTILINE,这种也可以匹配上(r"^a","\nabc\neee",flags=re.MULTILINE)
'$'     匹配字符结尾，或e.search("foo$","bfoo\nsdfsf",flags=re.MULTILINE).group()也可以
'*'     匹配*号前的字符0次或多次，re.findall("ab*","cabb3abcbbac")  结果为['abb', 'ab', 'a']
'+'     匹配前一个字符1次或多次，re.findall("ab+","ab+cd+abb+bba") 结果['ab', 'abb']
'?'     匹配前一个字符1次或0次
'{m}'   匹配前一个字符m次
'{n,m}' 匹配前一个字符n到m次，re.findall("ab{1,3}","abb abc abbcbbb") 结果'abb', 'ab', 'abb']
'|'     匹配|左或|右的字符，re.search("abc|ABC","ABCBabcCD").group() 结果'ABC'
'(...)' 分组匹配，re.search("(abc){2}a(123|456)c", "abcabca456c").group() 结果 abcabca456c
 
 
'\A'    只从字符开头匹配，re.search("\Aabc","alexabc") 是匹配不到的
'\Z'    匹配字符结尾，同$
'\d'    匹配数字0-9
'\D'    匹配非数字
'\w'    匹配[A-Za-z0-9]
'\W'    匹配非[A-Za-z0-9]
's'     匹配空白字符、\t、\n、\r , re.search("\s+","ab\tc1\n3").group() 结果 '\t'
 
'(?P<name>...)' 分组匹配 re.search("(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birthday>[0-9]{4})","371481199306143242").groupdict("city") 结果{'province': '3714', 'city': '81', 'birthday': '1993'}

最常用的匹配语法

re.match 从头开始匹配
re.search 匹配包含
>>> a = re.search("(\d{1,3}\.){3}\d{1,3}","inet 192.168.15.111 netmask 0xffffff00
>>> a
<_sre.SRE_Match object; span=(5, 19), match='192.168.15.111'>
>>> a.group()
'192.168.15.111'


re.findall 把所有匹配到的字符放到以列表中的元素返回
>>> re.findall("\d+","asdasd1231zxc222")
['1231', '222']

re.splitall 以匹配到的字符当做列表分隔符
>>> re.split("\d+","asdasd1231zxc222dd")
['asdasd', 'zxc', 'dd']

re.sub      匹配字符并替换 
>>> re.sub("\d+","|","asdasd1231zxc222dd123vvgh",count=2)
'asdasd|zxc|dd123vvgh'