python内置常用模块

1.time模块

import time
#时间戳
print(time.time())
#时间结构
print(time.localtime())#本地时间
print(time.gmtime())#世界时间
#字符串时间
print(time.asctime())
# 直接显示字符串时间
import datetime
print(datetime.datetime.now())
#结构时间转化为自定义字符串时间
print(time.strftime("%Y-%m-%d %X",time.localtime()))
#字符串时间转化为结构时间
print(time.strptime("2019-12-12 15:15:15","%Y-%m-%d %X"))
#结构时间转化为时间戳
print(time.mktime(time.localtime()))
结果：
时间戳：1544097660.9399388
时间结构：本地——>time.struct_time(tm_year=2018, tm_mon=12, tm_mday=6, tm_hour=20, tm_min=1, tm_sec=0, tm_wday=3, tm_yday=340, tm_isdst=0)
世界时间——>time.struct_time(tm_year=2018, tm_mon=12, tm_mday=6, tm_hour=12, tm_min=1, tm_sec=0, tm_wday=3, tm_yday=340, tm_isdst=0)
字符串时间：Thu Dec  6 20:01:00 2018
直接显示字符串时间：2018-12-06 20:01:00.941933
结构时间转化为自定义字符串时间：2018-12-06 20:01:00
字符串时间转化为结构时间：time.struct_time(tm_year=2019, tm_mon=12, tm_mday=12, tm_hour=15, tm_min=15, tm_sec=15, tm_wday=3, tm_yday=346, tm_isdst=-1)
结构时间转化为时间戳：1544097660.0

 2.random模块

import random
#(0,1)随机浮点数
res = random.random()
print(res)
#[1,2]指定范围的随机浮点数
res = random.uniform(1,2)
print(res)
#[1,2]随机整形
res = random.randint(1,2)
print(res)
#[1,2)随机整形
res = random.randrange(1,2)
print(res)
#列表中的元素随机取一个值
res = random.choice([11,22,33,44,55])
print(res)
#列表中的元素随机取几个值
res = random.sample([11,22,33,44,55],3)
print(res)

3.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下为"	
",Linux下为"
"
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所指向的文件或者目录的最后修改时间

4.sys模块

import time
import sys
# sys.argv   在python解释器上执行py文件时直接输入参数可以用列表方式取值

for i in range(0,10):
    sys.stdout.write("#")#不是直接显示，先放在缓存，放完之后显示
    time.sleep(0.1)
    sys.stdout.flush()#刷新缓存
print(sys.exit(1))#返回0时表示文件正常结

5.json模块

import json
dic = {"name":"ailadi"}
f = open("new.txt","w")
dic=json.dumps(dic)
f.write(dic)    #将数据转化为字符串模式——————>   s = json.dump(dic,f)    只适用于文件

f = open("new.txt","r")
s = f.read()
s = json.loads(s)    #将读出的数据提取格式  ————>  s = json.load(f)    只适用于文件
print(type(s))

6.pickle模块

"""以字节的方式读写，支持类和函数"""
dic = {"name":"ailadi"}
import pickle
with open("new_pickle","wb") as f:
    dic = pickle.dumps(dic)
    f.write(dic)     #------->pickle.dump(dic,f)
with open("new_pickle","rb") as f:
    s = f.read()
    print(s)
    s = pickle.loads(s)    #----->s = pickle.load(f)
    print(s)

7.shelve模块

"""存取字典"""
import shelve
f = shelve.open(r"shelve.txt")

#存
# f["name"] = "ailadi"
# f.close()

#取
# print(f["name"])
# f.close()

8.XML模块

"""
XML
teg：对象
attrib：属性
text：内容
"""
#遍历
import xml.etree.ElementTree as ET
tree = ET.parse("xml_text")
root = tree.getroot()
for i in root:
    print(i.tag)  #查看根节点的对象
    print(i.attrib)  #查看根节点的对象属性
    print(i.text)  #查看根节点的对象内容
    for j in i:
        print(j.tag)  #查看对象中的对象
        print(j.attrib)  #查看属性
        print(j.text)  #查看内容


#只遍历yesr节点
import xml.etree.ElementTree as ET
tree = ET.parse("xml_text")
root = tree.getroot()
for i in root.iter("year"):
    print(i.attrib,i.text)

#修改
import xml.etree.ElementTree as ET
tree = ET.parse("xml_text")
root = tree.getroot()
for i in root.iter("year"):  #在内存中修改
    i.text = "2018"
    i.attrib = {"updated":"no"}
tree.write("xml_text")  #写入硬盘

#删除
import xml.etree.ElementTree as ET
tree = ET.parse("xml_text")
root = tree.getroot()
for country in root.findall("country"):
    ret = int(country.find('year').text)
    print(ret)
    if ret == 2019:
        root.remove(country)
tree.write("xxxxxxxxxxxxxxxxxx")



import xml.etree.ElementTree as ET

new_xml = ET.Element("namelist")  #创建根节点

name = ET.SubElement(new_xml, "name", attrib={"enrolled": "yes"})  #在根节点下创建子节点
age = ET.SubElement(name, "age", attrib={"checked": "no"})  #在子节点下创建
sex = ET.SubElement(name, "sex")
age.text = "18"  #进行文本赋值
sex.text = '33'
name2 = ET.SubElement(new_xml, "name", attrib={"enrolled": "no"})
age = ET.SubElement(name2, "age")
age.text = '19'

et = ET.ElementTree(new_xml)  # 生成文档对象
et.write("test.xml", encoding="utf-8", xml_declaration=True)

ET.dump(new_xml)  # 打印生成的格式

9.re模块

元字符之. ^ $ * + ? { }

. ^ $ * + ? { }

元字符之字符集［］：

ret=re.findall('a[bc]d','acd')
print(ret)#['acd']
 
ret=re.findall('[a-z]','acd')
print(ret)#['a', 'c', 'd']
 
ret=re.findall('[.*+]','a.cd+')
print(ret)#['.', '+']
 
#在字符集里有功能的符号: - ^ 
 
ret=re.findall('[1-9]','45dha3')
print(ret)#['4', '5', '3']
 
ret=re.findall('[^ab]','45bdha3')
print(ret)#['4', '5', 'd', 'h', '3']
 
ret=re.findall('[d]','45bdha3')
print(ret)#['4', '5', '3']

元字符之转义符

　　反斜杠后边跟元字符去除特殊功能,比如.
　　反斜杠后边跟普通字符实现特殊功能,比如d

　　d  匹配任何十进制数；它相当于类 [0-9]。
　　D 匹配任何非数字字符；它相当于类 [^0-9]。
　　s  匹配任何空白字符；它相当于类 [ fv]。
　　S 匹配任何非空白字符；它相当于类 [^ fv]。
　　w 匹配任何字母数字字符；它相当于类 [a-zA-Z0-9_]。
　　W 匹配任何非字母数字字符；它相当于类 [^a-zA-Z0-9_]
　　  匹配一个特殊字符边界，比如空格 ，&，＃等

元字符之分组()

m = re.findall(r'(ad)+', 'add')
print(m)
 
ret=re.search('(?P<id>d{2})/(?P<name>w{3})','23/com')
print(ret.group())#23/com
print(ret.group('id'))#23

元字符之｜

#或（|）
ret=re.search('(ab)|d','rabhdg8sd')
print(ret.group())#ab

ret = re.findall(r"(ab)|(cd)","abcdxxxabxxxcd")
print(ret)  #[('ab', ''), ('', 'cd'), ('ab', ''), ('', 'cd')]
ret = re.findall(r"(ab)|cd","abcdxxxabxxxcd")
print(ret)  #['ab', '', 'ab', '']
ret = re.findall(r"ab|(cd)","abcdxxxabxxxcd")
print(ret)  #['', 'cd', '', 'cd']
ret = re.findall(r"ab|cd","abcdxxxabxxxcd")
print(ret)  #['ab', 'cd', 'ab', 'cd']
ret = re.findall(r"(ab|cd)","abcdxxxabxxxcd")
print(ret)  #['ab', 'cd', 'ab', 'cd']

re模块下的常用方法

import re
#1
re.findall('a','alvin yuan')    #返回所有满足匹配条件的结果,放在列表里
#2
re.search('a','alvin yuan').group()  #函数会在字符串内查找模式匹配,只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以
                                     # 通过调用group()方法得到匹配的字符串,如果字符串没有匹配，则返回None。
 
#3
re.match('a','abc').group()     #同search,不过尽在字符串开始处进行匹配
 
#4
ret=re.split('[ab]','abcd')     #先按'a'分割得到''和'bcd',在对''和'bcd'分别按'b'分割
print(ret)#['', '', 'cd']
 
#5
ret=re.sub('d','abc','alvin5yuan6',1)
print(ret)#alvinabcyuan6
ret=re.subn('d','abc','alvin5yuan6')
print(ret)#('alvinabcyuanabc', 2)
 
#6
obj=re.compile('d{3}')
ret=obj.search('abc123eeee')
print(ret.group())#123

import re

ret=re.findall('www.(baidu|oldboy).com','www.oldboy.com')
print(ret)  #['oldboy']     这是因为findall会优先把匹配结果组里内容返回,如果想要匹配结果,取消权限即可

ret=re.findall('www.(?:baidu|oldboy).com','www.oldboy.com')  # ?: 取消权限符号
print(ret)  #['www.oldboy.com']

import re

print(re.findall("<(?P<tag_name>w+)>w+</(?P=tag_name)>","<h1>hello</h1>"))
#运行结果['h1']
print(re.search("<(?P<tag_name>w+)>w+</(?P=tag_name)>","<h1>hello</h1>").group('tag_name'))
#运行结果<re.Match object; span=(0, 14), match='<h1>hello</h1>'>
print(re.search("<(?P<tag_name>w+)>w+</(?P=tag_name)>","<h1>hello</h1>").group('tag_name'))
#运行结果h1
print(re.search(r"<(w+)>w+</1>","<h1>hello</h1>"))
#运行结果<re.Match object; span=(0, 14), match='<h1>hello</h1>'>

10.logging模块

"""定义一个logger函数"""
def logger():
    import logging
    logger = logging.getLogger()  #添加根

    fh = logging.FileHandler("message.txt")  #添加日志文件路径

    fm = logging.Formatter('%(asctime)s %(name)s %(message)s [%(lineno)d]')  #输出日志的格式和内容

    #添加信息
    fh.setFormatter(fm)
    logger.addHandler(fh)
    #设置日志输出的等级
    logger.setLevel(logging.DEBUG)
    return logger

#调用logger函数
logger = logger()

#添加日志输出的内容
logger.debug('bebug massage')
logger.info('info massage')
logger.warning('warning massage')
logger.error('error massage')
logger.critical('bebug massage')

11.configparse模块

import configparser
config = configparser.ConfigParser()
config["DEFAULT"] = {'ServerAliveInterval': '45',
                      'Compression': 'yes',
                     'CompressionLevel': '9'}
config['bitbucket.org'] = {}
config['bitbucket.org']['User'] = 'hg'
config['topsecret.server.com'] = {}
topsecret = config['topsecret.server.com']
topsecret['Host Port'] = '50022'     # mutates the parser
topsecret['ForwardX11'] = 'no'  # same here
config['DEFAULT']['ForwardX11'] = 'yes'
with open('example.ini', 'w') as configfile:
   config.write(configfile)  #写入文件

12.hashlib模块

import hashlib

s = hashlib.md5("alvin".encode('utf8'))  #加盐值
s.update("hello".encode('utf8'))  #加密
print(s.hexdigest())

import hmac

h = hmac.new('alvin'.encode('utf8'))
h.update('hello'.encode('utf8'))
print(h.hexdigest())