day06.2-Python中常用的内置模块

一. time模块：import time

import time

"1. 查看系统的时间戳信息"
t=time.time()
print(t)      #1559136108.672717

"2. 显示系统的结构化当地时间(年 月 日 时 分 秒 一周中第几天 一年中第几天)"
t=time.localtime()
print(t)#time.struct_time(tm_year=2019, tm_mon=5, tm_mday=29, tm_hour=21, tm_min=23, tm_sec=56, tm_wday=2, tm_yday=149, tm_isdst=0)
print(t.tm_year)      #2019
print(t.tm_wday)      #2

"3. 显示系统的结构化世界时间"
t=time.gmtime()
print(t)#time.struct_time(tm_year=2019, tm_mon=5, tm_mday=29, tm_hour=13, tm_min=28, tm_sec=4, tm_wday=2, tm_yday=149, tm_isdst=0)

"4. 将结构化时间转换成时间戳"
t=time.mktime(time.localtime())
print(t)      #1559136597.0

"5. 将结构化时间转换成字符串时间"
t=time.strftime("%Y-%m-%d %X",time.localtime())
print(t)      #2019-05-29 21:32:16

"6. 将字符串时间转换成结构化时间"
t=time.strptime("2019:5:29:21:34:45","%Y:%m:%d:%X")
print(t)#time.struct_time(tm_year=2019, tm_mon=5, tm_mday=29, tm_hour=21, tm_min=34, tm_sec=45, tm_wday=2, tm_yday=149, tm_isdst=-1)

"7. 将结构化时间转换成固定格式的字符串时间"
t=time.asctime()
print(t)      #Wed May 29 21:37:51 2019

"8. 将时间戳转换成固定格式的字符串时间"
t=time.ctime()
print(t)      #Wed May 29 21:40:03 2019

"9. 线程运行推迟指定的时间，单位为秒"
time.sleep(1)

二. datetime模块：import datetime

import datetime

"1. 显示系统当前的字符串时间"
t=datetime.datetime.now()
print(t)      #2019-06-04 20:56:31.669967

三. rand模块：import random

import random

"1. 在0~1之间随机生成一个浮点数"
n=random.random()
print(n)      #0.07605310040756674

"2. 在指定范围内随机生成一个浮点数"
n=random.uniform(1,4)
print(n)     #1.5884677589720386

"3. 在指定范围内随机生成一个整数"
n=random.randint(1,4)
print(n)     #4

"4. 在序列中随机选取一个元素"
n=random.choice([1,'23',[4,5],'you'])
print(n)    #23

"5. 随机从序列中选取指定个数的元素"
n=random.sample([1,'23',[4,5],'you'],2)
print(n)    #[1, [4, 5]]

"6. 随机打乱序列的顺序"
ret=[1,'23',[4,5],"you"]
random.shuffle(ret)
print(ret)   #[[4, 5], 1, 'you', '23']

四. os模块：import os

import os

"1. 获取当前Python脚本工作的目录"
p=os.getcwd()
print(p)      #H:\MyPython\my_module

"2. 切换当前脚本的工作目录"
os.chdir('H:\MyPython')
print(os.getcwd())     #H:\MyPython

"3. 生成多层递归目录"
os.makedirs('H:\MyPython\my_module\makedirs1\makedirs2\makedirs3')

"4. 若当前目录为空，则删除当前目录并递归到上层目录，如上层目录也为空，则执行相同操作直至找到非空目录"
os.removedirs('H:\MyPython\my_module\makedirs1\makedirs2\makedirs3')

"5. 在当前路径下生成单层目录"
os.mkdir("makedir")

"6. 删除单级目录，若目标目录不为空则无法删除"
os.rmdir("makedir")

"7. 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印"
p=os.listdir(os.getcwd())
print(p)     #['my_module', 'run.py', 'test.py', '生成器']

"8. 在当前目录下删除一个文件"
os.remove('run.py')

"9. 重命名当前目录下的文件/子目录"
os.rename('生成器','Builder')

"10. 查看文件信息，包括文件大小、上次查看时间、上次修改时间、创建时间"
p=os.stat('Builder')
print(p)#os.stat_result(st_mode=16895, st_ino=2251799813728966, st_dev=476857607, st_nlink=1, st_uid=0, st_gid=0, st_size=4096, st_atime=1556611563, st_mtime=1556611563, st_ctime=1554034077)

"11. 输出操作系统的路径的分隔符，Windows下为'\\'，Linux下为'/'"
print(os.sep)         #\

"12. 输出当前平台使用的行终止符，Windows下为'\r\n'，Linux下为'\n'"
print(os.linesep)     #' '

"13. 输出当前平台用于分割文件路径的字符串，Windows下为';'，Linux下为':'"
print(os.pathsep)     #;

"14. 返回文件/子目录的规范化路径"
p=os.path.abspath('test.py')
print(p)      #H:\MyPython\test.py

"15. 返回文件/子目录的目录"
p=os.path.dirname('H:\MyPython\Bulider\bin.py')
print(p)      #H:\MyPython

"16. 将路径分割成目录和文件名二元组返回"
p=os.path.split('H:\MyPython\Bulider\bin.py')
print(p)      #('H:\\MyPython', 'Bulider\bin.py')

"17. 返回路径最后的文件名"
p=os.path.basename('H:\MyPython\Bulider\info.py')
print(p)      #info.py

"18. 查看路径是否存在，若路径存在返回true，否则返回false"
p=os.path.exists(r'H:\MyPython\Builder\bin.py')
print(p)      #True

"19. 查看路径是否为绝对路径，若是返回true，否则返回false"
p=os.path.isabs('H:\MyPython\Builder\bin.py')
print(p)      #True

"20. 如果路径是一个已经存在的文件，返回true，否则返回false"
p=os.path.isfile(r'H:\MyPython\Builder\bin.py')
print(p)      #True

"21. 如果路径是一个已经存在的目录，返回true，否则返回false"
p=os.path.isdir('H:\MyPython\Builder')
print(p)      #True

"22. 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略"
p=os.path.join('H:\MyPython','Builder\web1','web2\web3')
print(p)      #H:\MyPython\Builder\web1\web2\web3

"23. 返回目录所指路径/文件的最后存取时间"
p=os.path.getatime(r'H:\MyPython\Builder\bin.py')
print(p)      #1556610936.0599964

"24. 返回目录所指路径/文件的最后修改时间"
p=os.path.getmtime(r'H:\MyPython\Builder\bin.py')
print(p)      #1556610936.0609713

五. sys模块：import sys

import sys

"1. 命令行参数list，第一个元素是执行文件本身的路径，其余元素为程序执行时的输入元素"
p=sys.argv
print(p)      #['H:/MyPython/my_module/bin.py']

"2. 退出程序，正常退出时exit(0)"
sys.exit(n)

"3. 获取Python解释器的版本信息"
n=sys.version
print(n)     #3.7.1 (v3.7.1:260ec2c36a, Oct 20 2018, 14:57:15) [MSC v.1915 64 bit (AMD64)]

"4. 返回操作系统平台"
n=sys.platform
print(n)     #win32

"5. 继续上次终端输出的位置刷新显示"
sys.stdout.write('@@')
print('zzzz')    #@@zzzz

"6. 清空输出缓存"
sys.stdout.flush()

六. json模块：import json

         json模块可用于跨开发语言间的序列化与反序列化。

    把对象（变量）从内存中变成可存储或传输的过程称之为序列化，在Pyhton中叫做pickling，在其他语言中也被称之为serialization、marshalling、flattening等。数据经过序列化之后，就可以写入磁盘或者通过网络传输；把变量内容从序列化后的对象中重新读到内存的过程称为反序列化，即unpickling。

import json

"1. 输入数据转换成json字符串（pickling)"
data=[11,22,33,44,55]
string=json.dumps(data)
file=open('JSON.txt','w')
file.write(string)

"2. 提取json字符串中的数据（unpickling)"
file=open('JSON.txt','r')
string=file.read()
data=json.loads(string)
print(data)       #[11, 22, 33, 44, 55]

七. xml模块：import xml.etree.ElementTree as ET

         xml也是用于实现不同语言或程序之间进行数据交换的协议，与json差不多。

    1. xml文件的遍历、修改与删除

       city.html文件内容：

<?xml version="1.0"?>
<data>
    <country name="Liechtenstein">
        <rank updated="yes">2</rank>
        <year>2008</year>
        <gdppc>141100</gdppc>
        <neighbor name="Austria" direction="E"/>
        <neighbor name="Switzerland" direction="W"/>
    </country>
    <country name="Singapore">
        <rank updated="yes">5</rank>
        <year>2011</year>
        <gdppc>59900</gdppc>
        <neighbor name="Malaysia" direction="N"/>
    </country>
    <country name="Panama">
        <rank updated="yes">69</rank>
        <year>2011</year>
        <gdppc>13600</gdppc>
        <neighbor name="Costa Rica" direction="W"/>
        <neighbor name="Colombia" direction="E"/>
    </country>
</data>

#bin.py文件内容

import xml.etree.ElementTree as ET

tree=ET.parse('city.html')
root=tree.getroot()
print(root.tag)        #data

#遍历xml文档
for child in root:
    print(child.tag,child.attrib)
    for rechild in child:
        print(' '*4,rechild.tag,rechild.text)

#只遍历year节点
for node in root.iter('year'):
    print(node.tag,node.text)

#修改：所有year节点值加1，并添加修改标识
for node in root.iter('year'):
    new_year=int(node.text)+1
    node.text=str(new_year)
    node.set('updated','yes')
tree.write('new_city1.html')

#删除：删除rank节点值大于50的城市
for node in root.findall('country'):
    rank=int(node.find('rank').text)
    if rank>50:
        root.remove(node)
tree.write('new_city2.html')

    2. 手动建立xml文件

import xml.etree.ElementTree as ET

new_xml=ET.Element('people_list')

people1=ET.SubElement(new_xml,'people',attrib={'enrolled':'yes'})
name=ET.SubElement(people1,'name',attrib={'checked':'no'})
name.text='alex'
age=ET.SubElement(people1,'age')
age.text='33'
sex=ET.SubElement(people1,'sex')

people2=ET.SubElement(new_xml,'people',attrib={'enrolled':'no'})
name=ET.SubElement(people2,'name',attrib={'checked':'no'})
name.text='bob'
age=ET.SubElement(people2,'age')
age.text='11'

tree=ET.ElementTree(new_xml)
tree.write('output.html')

八. re模块：import re

        就其本质而言，正则表达式（re模块）是一种小型的、高度专业化的编程语言，通过re模块内嵌在Python中。正则表达式模式被编译成一系列的字节码，然后由C编写的驱动引擎执行。

   1. 元字符：.^$*+?{}[]|()\

import re

"1. 通配符，可模糊匹配除换行符以外的所有字符"
ret=re.findall('a..x','abcxdefg')
print(ret)        #['abcx']

"2. 查找以指定字符串开头的子字符串"
ret=re.findall('^a..x','abcxdefg')
print(ret)        #['abcx']

"3. 查找以指定字符串结尾的子字符串"
ret=re.findall('d..g$','abcxdefg')
print(ret)        #['defg']

"4. 贪婪匹配就近重复出现多次（0~oo次）的字符"
ret=re.findall('alex*','abcdefalexxxx')
print(ret)        #['alexxxx']
ret=re.findall('alex*','abcdefale')
print(ret)        #['ale']

"5. 贪婪匹配就近重复出现多次（1~oo次）的字符"
ret=re.findall('alex+','abcdefalexxxx')
print(ret)        #['alexxxx']
ret=re.findall('alex+','abcdefale')
print(ret)        #[]

"6. 贪婪匹配就近重复出现0~1次的字符"
ret=re.findall('alex?','abcdefalexxxx')
print(ret)        #['alex']
ret=re.findall('alex?','abcdefale')
print(ret)        #['ale']

"注：前面的'*''+''?'等都是贪婪匹配，也就是尽可能多地匹配，后面加'？'可以使其变成惰性匹配"
ret=re.findall('alex*?','abcdefgalexxxx')
print(ret)        #['ale']
ret=re.findall('alex+?','abcdefgalexxxx')
print(ret)        #['alex']

"7. 贪婪匹配就近重复出现0~n次的字符（{0,}相当于*，{1,}相当于+，{0,,1}相当于？，{6}重复出现6次的字符）"
ret=re.findall('alex{6}','abcdefgalexxx')
print(ret)        #[]
ret=re.findall('alex{6}','abcdefgalexxxxxx')
print(ret)        #['alexxxxxx']
ret=re.findall('alex{0,6}','abcdefgalexxx')
print(ret)        #['alexxx']

"8. 字符集"
ret=re.findall('x[yz]p','xypuuxzpuu')
print(ret)        #['xyp', 'xzp']
ret=re.findall('x[y*z]p','xypuuxzpuux*p')
print(ret)        #['xyp', 'xzp', 'x*p']
ret=re.findall('[x-z]','xyabcz')
print(ret)        #['x', 'y', 'z']

"注：在字符集中有特殊功能的字符有'-'、'^'、'\'，分别为范围符号、非、转义符，除此之外，[]中所有内容都为普通字符没有特殊功能"
ret=re.findall('q[^a-z]','q123qxyzq5')
print(ret)         #['q1', 'q5']

"9. 转义符"
ret=re.findall('q[x\*]','qxxqxyuq*')
print(ret)         #['qx', 'qx', 'q*']
ret=re.findall('\*q','*qxxyup*qx')
print(ret)         #['*q', '*q']
ret=re.findall(r'I\b','I am LIST')
print(ret)         #['I']
ret=re.findall(r'c\\l','abc\le')
print(ret)        #['c\\l']

"10. 管道符，相当于逻辑或"
ret=re.findall('ka|bc','sdjkabcsf')
print(ret)         #['ka', 'bc']

"11. 字符分组"
ret=re.search('(?P<name>[a-z]+)(?P<age>\d+)','alex18bob23').group('age')
print(ret)         #18对匹配结果进行分组
ret=re.findall('(abc)+','abcabcabc')
print(ret)         #['abc']优先匹配分组内内容
ret=re.findall('(?:abc)+','abcabcabc')
print(ret)         #['abcabcabc']取消分组内内容的优先级 

   2. re模块下的常用方法

import re

"1. 返回所有满足匹配条件的结果，放在列表中"
ret=re.findall('o','klay thompson')
print(ret)         #['o', 'o']

"2. 在字符串中查找匹配模式，只要找到第一个匹配之后以包的形式返回"
ret=re.search('o','klay thompson').group()
print(ret)         #o

"3. 在字符串开头处查找匹配模式，若字符串开头符合匹配条件则以包的形式返回，否则报错"
ret=re.match('k','klay thompson').group()
print(ret)         #k

"4. 分割字符串"
ret=re.split('[ab]','abc')
print(ret)         #['', '', 'c']即先按'a'分割'abc'得到''和'bc'，再按'b'分割'bc'得到''和'c'

"5. 字符替换"
ret=re.sub('\d+','AGE','alex34bob56')
print(ret)         #alexAGEbobAGE

"6. 返回所有匹配的结果，放在迭代器中"
ret=re.finditer('\d','alex36bob38com42')
print(next(ret).group())        #3
print(next(ret).group())        #6
print(next(ret).group())        #3
print(next(ret).group())        #8

"注：re模块匹配完成后，优先显示分组内的内容"
ret=re.findall('www\.(baidu|google)\.com','1234www.google.com.5678')
print(ret)           #['google']优先显示分组内内容
ret=re.findall('www\.(?:baidu|google)\.com','1234www.google.com.5678')
print(ret)           #['www.google.com']取消分组的优先级

   3. re模块下常用的通配符

• \d 匹配任何十进制数，相当于类[0-9]；
• \D  匹配任何非数字字符，相当于类[^0-9]；
• \s 匹配任何空白字符，相当于类[\t\n\r\f\v]；
• \S 匹配任何非空白字符，相当于类[^\t\n\r\f\v]；
• \w 匹配任何字母数字字符，相当于类[a-zA-Z0-9]；
• \W 匹配任何非字母数字字符，相当于类[^a-zA-Z0-9]；
• \b 匹配一个特殊字符边界，比如空格、&、#等。

九. logging模块：import logging

   1. 日志文件的级别分类

       日志文件共设有5个级别，各级别等级从低到高依次为：

• logging.debug('debug message')；
• logging.info('info message')；
• logging.warning('warning message')；      #默认日志级别
• logging.error('error message')；
• logging.critical('critical message').

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

   2. 设置日志文件参数的两种方法

• 方法1

import logging

logging.basicConfig(
    level=logging.DEBUG,       #日志级别
    filename='logger.log',    #日志文件，默认按追加模式写入日志信息
    filemode='w',              #以覆盖方式写入日志信息
    format='%(asctime)s [%(lineno)d] %(message)s %(filename)s'    #设置日志信息的格式
)

logging.debug("debug")
logging.info("info")
logging.warning("warning")
logging.error("error")
logging.critical("critical")

#'logger.log'文件内容：

2019-06-19 21:19:42,167 [10] debug 1.py
2019-06-19 21:19:42,167 [11] info 1.py
2019-06-19 21:19:42,167 [12] warning 1.py
2019-06-19 21:19:42,167 [13] error 1.py
2019-06-19 21:19:42,167 [14] critical 1.py

• 方法2

import logging
def logger():
    logger=logging.getLogger()

    fh=logging.FileHandler('test_logger')
    ch=logging.StreamHandler()

    fm=logging.Formatter('%(asctime)s %(message)s')

    fh.setFormatter(fm)
    ch.setFormatter(fm)

    logger.addHandler(fh)
    logger.addHandler(ch)
    logger.setLevel(logging.DEBUG)

    return logger

logger=logger()

logger.debug("debug")
logger.info("info")
logger.warning("warning")
logger.error("error")
logger.critical("critical")

#'test_logger'文件内容：

2019-06-19 21:49:49,962 debug
2019-06-19 21:49:49,962 info
2019-06-19 21:49:49,962 warning
2019-06-19 21:49:49,962 error
2019-06-19 21:49:49,962 critical

   3. 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      #字符串形式的当前时间，默认格式是"2019-6-19 22:05:11,969"，逗号后面的是毫秒
%(thread)d       #线程ID，可能没有
%(threadName)s   #线程名，可能没有
%(process)d      #进程ID，可能没有
%(message)s      #用户输出的信息

   4. 一个日志文件的例子及分析

import logging

logger1=logging.getLogger('mylogger')
logger1.setLevel(logging.DEBUG)

logger2=logging.getLogger('mylogger')
logger2.setLevel(logging.INFO)

fh=logging.FileHandler('test_logger')
ch=logging.StreamHandler()

logger1.addHandler(fh)
logger1.addHandler(ch)

logger2.addHandler(fh)
logger2.addHandler(ch)

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

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

#'test_logger'文件内容：

logger1 info message
logger1 warning message
logger1 error message
logger1 critical message
logger2 info message
logger2 warning message
logger2 error message
logger2 critical message

      由代码输出结果可知，尽管设置了两个不同的日志句柄，但由于两个日志句柄具有相同的Logger名称，从而后面设置的句柄参数会覆盖前面已经设置的句柄参数（上例中logger2的日志级别覆盖了logger1的日志级别）。

十. configparser模块：import configparser

   1. 配置文件的创建

import configparser

config=configparser.ConfigParser()
config['DEFAULT']={'ServerAliveInterval':'45',
                   'Compress':'yes',
                   'CompressionLevel':'9'}

config['bitbucket.org']={}
config['bitbucket.org']['User']='hg'

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

config['DEFAULT']['ForwardX11']='yes'

with open('example.ini','w') as configfile:
    config.write(configfile)

'example.ini'文件内容：

[DEFAULT]
serveraliveinterval = 45
compress = yes
compressionlevel = 9
forwardx11 = yes

[bitbucket.org]
user = hg

[topsecret.server.com]
host port = 50022
forwardx11 = no

   2. 配置文件的查询、增加、删除与修改

import configparser

config=configparser.ConfigParser()

#--------------------------------查询-----------------------------------------#
print(config.sections())               #[]

config.read('example.ini')
print(config.sections())               #['bitbucket.org', 'topsecret.server.com']

print('bytebong.com' in config)       #False
print(config['bitbucket.org']['User'])           #hg
print(config['DEFAULT']['compress'])           #yes
print(config['topsecret.server.com']['ForwardX11'])         #no

for key in config:
    print(key)         #DEFAULT #bitbucket.org #topsecret.server.com

print(config.options('bitbucket.org'))    #['user', 'serveraliveinterval', 'compress', 'compressionlevel', 'forwardx11']
print(config.items('bitbucket.org'))     #[('serveraliveinterval', '45'), ('compress', 'yes'), ('compressionlevel', '9'), ('forwardx11', 'yes'), ('user', 'hg')]
print(config.get('bitbucket.org','compress'))      #yes

#-------------------------------修改、增加、删除-------------------------------#
config.add_section('yuan')

config.remove_section('topsecret.server.com')
config.remove_option('bitbucket.org','user')

config.set('yuan','name','KD')
config.set('bitbucket.org','k1','11111')

config.write(open('i.example','w'))

'i.example'文件内容：

[DEFAULT]
serveraliveinterval = 45
compress = yes
compressionlevel = 9
forwardx11 = yes

[bitbucket.org]
k1 = 11111

[yuan]
name = KD

   由代码输出结果可知，在遍历其他项中关键词的时候，DEFAULT中关键词会自动显示。这是因为DEFAULT的主要作用就是存放与其他项的共享关键词，从而在遍历的过程中DEFAULT中关键词也会显示。

十一. hashlib模块：import hashlib

   对于哈希运算，Python 3中代替了md5模块和sha模块，主要提供了SHA1、SHA224、SHA256、SHA384、SHA512、MD5算法。

import hashlib

m=hashlib.md5('2019/7/15'.encode('utf-8'))       #MD5算法加盐

m.update('hello'.encode('utf-8'))
print(m.hexdigest())       #5d41402abc4b2a76b9719d911017c592

m.update('alvin'.encode('utf-8'))
print(m.hexdigest())       #92a7e713c30abbb0319fa07da2a5c4af

m2=hashlib.md5()

m2.update('helloalvin'.encode('utf-8'))
print(m2.hexdigest())       #92a7e713c30abbb0319fa07da2a5c4af