Python学习（十二）—— 常见模块

常见内置模块

time模块

时间戳（单位是秒，代表由1970年元旦凌晨至今过去的时间），常用于计算 .time()：

import time
#时间戳，单位是s
print(time.time())
# 1583246063.46606

结构化时间 

（显示当地当前的精确时间 年月日...）.localtime()

print(time.localtime())
# time.struct_time(tm_year=2020, tm_mon=3, tm_mday=3, tm_hour=22, tm_min=36, tm_sec=33, tm_wday=1, tm_yday=63, tm_isdst=0)

　　可以取出想要的时间信息

t = time.localtime()
print(t.tm_wday) #周几是从周0开始算的
# 1
print(t.tm_year)
# 2020

（显示当前格林威治的精确时间 年月日...）.gmtime()：

g = time.gmtime()
print(g)
# time.struct_time(tm_year=2020, tm_mon=3, tm_mday=3, tm_hour=14, tm_min=41, tm_sec=47, tm_wday=1, tm_yday=63, tm_isdst=0)
print(g.tm_wday) #周几是从周0开始算的
# 1
print(g.tm_year)
# 2020

将结构化时间转化成对应的时间戳 .mktime()

print(time.mktime(time.localtime()))
# 1583246793.0

将结构化时间转换成字符串时间 .strftime()

print(time.strftime("%Y-%m_%d %X",time.localtime()))
# 2020-03_03 22:52:02

将字符串时间转换成结构化时间 .strptime()

print(time.strptime("2020:1:1:20:8:30","%Y:%m:%d:%X"))
# time.struct_time(tm_year=2020, tm_mon=1, tm_mday=1, tm_hour=20, tm_min=8, tm_sec=30, tm_wday=2, tm_yday=1, tm_isdst=-1)

将结构化时间转换成给定格式的时间，不得修改 .asctime() 

print(time.asctime())
# Tue Mar  3 22:57:48 2020

将时间戳转换成给定格式的时间，不得修改 .ctime()

print(time.ctime(time.time()))
# Tue Mar  3 23:00:18 2020

字符串时间

补充一个关于时间的模块 datetime

import datetime
print(datetime.datetime.now())
# 2020-03-03 23:02:47.361912

random模块

随机浮点型、浮点型范围、随机整型、随机整型的范围

import random
print(random.random())
# 0.3947431257812979
print(random.uniform(1,5))#指定范围
# 4.521865000424089
print(random.randint(4,10)) #指定范围
# 8
print(random.randrange(4,1000))
# 384

在可迭代对象内随机取一个

print(random.choice([11,33,44,66]))
# 44

在可迭代对象内随机取多个

print(random.sample([11,33,44,66],3))
# [66, 11, 44]

打乱次序（洗牌）

l = [11,33,44,66]
random.shuffle(l)
print(l)
# [11, 66, 33, 44]

举例：做验证码

import random
def v_code():
    ret = ""
    for i in range(5):
        num = random.randint(0,9)
        alf = chr(random.randint(65,122))
        s = str(random.choice([num,alf]))
        ret += s
      return ret

print(v_code())
# sj232

os模块

os.getcwd() 获取当前工作的目录

os.chdir("dirname") 改变当前工作目录

import os
print(os.getcwd())
# D:PythonStudyPython全栈day22
os.chdir("test")
print(os.getcwd())
# D:PythonStudyPython全栈day22	est
os.chdir("..") #返回上一层
print(os.getcwd())
# D:PythonStudyPython全栈day22

os.curdir 返回当前目录

os.pardir 返回当前目录的父目录字符串名

os.curdir#返回当前目录
print(os.getcwd())
os.pardir #返回当前目录的父目录字符串名
print(os.getcwd())

os.makedirs("dirname1/dirname2") 生成多层递归目录

os.removedirs("dirname1") 若为空目录，则删除，并递归到上一级目录，如若也为空，则删除，依此类推

os.mkdirs('dirname") 生成单级目录

os.rmdir("dirname") 删除单级空目录，若目录非空则无法删除且报错

# os.makedirs("dir1/dir2") 创建多级目录
os.rmdir("dir1/dir2")  #删除单级空目录

os.listdir("dirname") 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印

os.remove() 删除一个文件

os.rename("oldname","newname") 重命名文件/目录

os.stat("path/filename") 获取文件/目录信息(创建时间、修改时间、节点数、设备、用户名、字节数...)

os.sep 输出操作系统特定的路径分隔符，win下为“\”，Linux为“/”

os.linesep 输出当前平台使用的行终止符，win下为“ ”，Linux为“ ”

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以/或结尾，那么就会返回空值。即os.path.split(path)的第二个元素

print(os.path.split(r"D:PythonStudyPython全栈day22lesson1.py"))
# ('D:\PythonStudy\Python全栈\day22', 'lesson1.py')
print(os.path.dirname(r"D:PythonStudyPython全栈day22lesson1.py"))
# D:PythonStudyPython全栈day22
print(os.path.basename(r"D:PythonStudyPython全栈day22lesson1.py"))
# lesson1.py

os.path.exists(path) 如果path存在，返回True，否则False

os.path.isabs(path) 如果path是绝对路径，返回True，否则False

os.path.isfile(path) 如果path是一个存在的文件，返回True，否则False

os.path.isdir(path) 如果path是一个存在的目录，返回True，否则False

os.path.join(path[,path[,...]]) 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略

a = "D:PythonStudyPython全栈"
b = "day22lesson1.py"
print(os.path.join(a,b))
# D:PythonStudyPython全栈day22lesson1.py

os.path.getatime(path) 返回path所指向的文件或者目录的最后存取时间

os.path.getmtime(path) 返回path所指向的文件或者目录的最后修改时间

system模块

sys.argv 命令行参数List，第一个元素是程序本身路径

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

sys.version() 获取Python解释程序的版本信息

sys.maxint 最大的Int值

sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值

sys.platform 返回操作系统平台名称

进度条的例子

import time,sys
for i in range(10):
    sys.stdout.write("*")
    time.sleep(0.4)
    sys.stdout.flush #刷新，立刻显示
# **********

json模块   

可以进行任何数据类型的转换（能够跨语言）

使用eval转换，但有局限性。

f = open("hello","r")
data = f.read()
print(data,type(data))
# {"name":"alex"} <class 'str'>
data = eval(data)
print(data["name"],type(data))
# alex <class 'dict'>

json.dumps() 任何输入类型都会变成字符串，字符串存在时，单引号会变成双引号

import  json
dic = {"alex":"18"}
l = [11,22,33]
num = 89
tu= (1,"w")
dic = json.dumps(dic)
print(dic,type(dic))
l = json.dumps(l)
print(l,type(l))
num = json.dumps(num)
print(num,type(num))
tu = json.dumps(tu)
print(tu,type(tu))
# {"alex": "18"} <class 'str'>
# [11, 22, 33] <class 'str'>
# 89 <class 'str'>
# [1, "w"] <class 'str'>

写入字符串（使用json.dumps(data）)

import json
f = open("new_hello","w")
data = json.dumps({'name':'alex'})
f.write(data) # json.dump({'name':'alex'},f)

print(data,type(data)) 
# new_hello {"name": "alex"}

json.loads() 变换为原来的数据类型

f = open("new_hello","r")
data = f.read()
print(data,type(data))
# {"name": "alex"} <class 'str'>
new_data = json.loads(data) # new_data = json.load(f)

print(new_data,type(new_data)) 
# {'name': 'alex'} <class 'dict'>

pickle模块

和json模块使用完全一样，结果转换为字节“bytes”，功能有局限性。

序列化：把对象（变量）从内存中变成可存储或传输的过程称为序列化。在Python中称为pickling，在其他语言上称为serialization，marshalling，flattening等。

序列化之后，可以把序列化后的内容写入磁盘，或者通过网络传输到其他机器上。

相反的过程称为反序列化，即unpickling。

shelve模块

类似pickle，使用更简单，有局限性。

import shelve
f = shelve.open(r"text1")
f["name"] = "alex"
f["internships"] = {1:"babycare",2:"assistance",3:"worker"}
#会写出三个名为text1的文件，内容肉眼不可识别
print(f.get("internships")[2])
# assistance

XML模块 xml.etree.ElementTree 

实现不同语言或程序之间进行数据交换的协议，类似json，但json使用更加简单。

查询功能：

#!/usr/bin/env python 
# -*- coding:utf-8 -*-
import xml.etree.ElementTree as ET #简写

tree = ET.parse("xml_lesson")
root = tree.getroot()
print(root.tag)
# data
#遍历标签
for i in root:
    print(i)
# <Element 'country' at 0x0000020DF9496B38>
# <Element 'country' at 0x0000020D8864EA48>
# <Element 'country' at 0x0000020D8864EBD8>
for i in root:
    print(i.tag)
    # country
    # country
    # country
# 遍历标签
for i in root:
    for j in i:
        print(j.attrib)
        # {'updated': 'yes'}
        # {'updated': 'yes'}
        # {}
        # {'direction': 'E', 'name': 'Austria'}
        # {'direction': 'W', 'name': 'Switzerland'}
        # {'updated': 'yes'}
        # {'updated': 'yes'}
        # {}
        # {'direction': 'N', 'name': 'Malaysia'}
        # {'updated': 'yes'}
        # {'updated': 'yes'}
        # {}
        # {'direction': 'W', 'name': 'Costa Rica'}
        # {'direction': 'E', 'name': 'Colombia'}
#遍历标签包裹的内容
for i in root:
    for j in i:
        print(j.text)
        # 2
        # 2010
        # 141100
        # None
        # None
        # 5
        # 2013
        # 59900
        # None
        # 69
        # 2013
        # 13600
        # None
        # None
#只遍历year节点
for node in root.iter("year"):
    print(node.tag,node.text)
    # year 2010
    # year 2013
    # year 2013

修改功能：

import xml.etree.ElementTree as ET #简写

tree = ET.parse("xml_lesson")
root = tree.getroot()
print(root.tag)

for node in root.iter("year"):
    new_year = int(node.text)+1
    node.text = str(new_year) #修改属性值
    node.set("updated","yes") #修改标签
tree.write("abc.xml")

删除功能：

import xml.etree.ElementTree as ET #简写

tree = ET.parse("xml_lesson")
root = tree.getroot()
for country in root.findall("country"):
    rank = int(country.find("rank").text)
    if rank > 50:
        root.remove(country)
tree.write("aaa.xml")

创建xml文件

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")
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)  # 打印生成的格式
# <namelist><name enrolled="yes"><age checked="no" /><sex>33</sex></name><name enrolled="no"><age>19</age></name></namelist>

re模块

究其本质，正则表达式（或RE）是一种小型的高度专业化的编程语言。它内嵌在Python中，并通过re模块实现。re表达式模式被编译成一系列的字节码，然后由C编写的匹配引擎执行。

用途：实现模糊匹配

字符匹配：
1、普通字符：大多数字符和字母都和本身匹配

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

　　　　

. 通配符，除 以外任何字符都可以匹配，一个.代表一个字符

^  放在字符串的开头，代表必须从字符串的开头匹配

$ 放在字符串的结尾，代表必须从字符串的结尾匹配

* 按照左侧紧挨着的字符重复，重复0~∞次，贪婪匹配，在后面加？可以变为惰性匹配

+ 按照左侧紧挨着的字符重复，重复1~∞次，贪婪匹配，在后面加？可以变为惰性匹配

 ? 按照左侧紧挨着的字符重复，重复0~1次，贪婪匹配，在后面加？可以变为惰性匹配

import re

# . 通配符
ret = re.findall("a..x","wqawlxweg")
print(ret)
# ['awlx']

# ^ 放在字符串的开头，代表必须从字符串的开头匹配
ret = re.findall("^a..x","wqawlxweg")
print(ret)
# []
ret = re.findall("^a..x","acwxwqawlxweg")
print(ret)
# ['acwx']

# $ 放在字符串的结尾，代表必须从字符串的结尾匹配
ret = re.findall("a..x$","acwxwqawlawex")
print(ret)
# ['awex']

# * 按照左侧紧挨着的字符重复，重复0~∞次
ret = re.findall("a*$","qaawxwqawlawexaaa")
print(ret)
# ['aaa', ''] #没匹配到也算"
ret = re.findall("alex*","wxwqawlawexale")
print(ret)
# ['ale'] #没匹配到也算"

# + 按照左侧紧挨着的字符重复，重复1~∞次
ret = re.findall("a+$","qaawxwqawlawexaaa")
print(ret)
# ['aaa']

# ? 按照左侧紧挨着的字符重复，重复0~1次
ret = re.findall("alex?","wxwqawlawexalexxxx")
print(ret)
# ['alex']
ret = re.findall("alex??","wxwqawlawexalexxxx")
print(ret)
# ['ale']

{ } 任意方式重复匹配

　　--{0,} == *

　　--{1,} == +

　　--{0,1} == ?

 | 代表或的意思，符号的左边、右边都进行匹配

ret = re.findall(r"ka|b","lwakawnngeowngbc")
print(ret)
# ['ka', 'b']
ret = re.findall(r"ka|bcd","lwakawnn|geowngbc")
print(ret)
# ['ka']

  转义符号 

　　用加元字符，可以把元字符变成普通字符

　　用加普通字符，可以让普通字符实现特殊功能：

　　　　d 匹配任何十进制数

　　　　D 匹配任何非数字字符

　　　　s 匹配任何空白符号

　　　　S 匹配任何非空白符号

　　　　w 匹配任何字母数字字符

　　　　W 匹配任何非字母数字字符

　　　　 匹配一个特殊字符边界，比如空格，&，#等

ret = re.findall("I","www I am Iist")
print(ret)
# []
ret = re.findall(r"I","www I am Iist")
print(ret) #由于Python自身具有转义功能，导致传到re时符号已经改变，加r表示Python不进行转义
# ['I']
ret = re.findall("I\b","www I am Iist")
print(ret) #一个/代表转义，两个//表示转回原义
# ['I']

[ ] 是字符集，内部除了三个符号以外都是普通字符

　　1、 -代表范围

　　2、 ^代表非

　　3、 转义符号

 re模块的分组功能：

 使用（）分组，一旦分组以后，Python默认关注（）内的内容

可以使用（？：）来降低优先级，从而得到全部结果

ret = re.findall("www.(baidu).com","awenwww.baidu.comwe")
print(ret)
# ['baidu']
ret = re.findall("www.(baidu|163).com","aw163enwww.baidu.comwe")
print(ret)
# ['baidu']
ret = re.findall("www.(?:baidu).com","awenwww.baidu.comwe")
print(ret)
# ['www.baidu.com']

有名分组

ret = re.search("(?P<name>[a-z]+)d+","alex25cindy55")
print(ret.group())
# alex25
print(ret.group("name"))
# alex
ret = re.search("(?P<name>[a-z]+)(?P<age>d+)","alex25cindy55")
print(ret.group("age"))
# 25

注意：

search 匹配成功，返回对象，匹配失败，返回空。search只找第一次满足条件的，一旦找到不再继续。

ret = re.search("(?P<name>w+)","abcdee")
print(ret)
print(ret.group())
# <re.Match object; span=(0, 6), match='abcdee'>
# abcdee
ret = re.search(r"d+","abc15dee34")
print(ret)
print(ret.group())
# <re.Match object; span=(3, 5), match='15'>
# 15

match 匹配成功，返回对象，匹配失败，返回空。但match只从开始匹配，相当于在search里加^

split 分割

 

sub 替换

ret = re.sub("d+","A","sd12ne345nnie56")
print(ret)
# sdAneAnnieA
ret = re.sub("d+","A","sd12ne345nnie56",2)
print(ret)
# sdAneAnnie56

subn 替换且返回一个元组，包含替换的结果和替换的次数

ret = re.subn("d+","A","sd12ne345nnie56")
print(ret)
# ('sdAneAnnieA', 3)

compile 用于给定规则

com = re.compile("d+")
ret = com.findall("12nasw335eng23")
print(ret)
# ['12', '335', '23']

finditer 结果拿到一个迭代器

logging模块  日志模块 

basicConfig()模式

 日志级别：

debug

info

warning

error

critical

import logging
logging.debug("debug message")
logging.info("info message")
logging.warning("warning message")
logging.error("error message")
logging.critical("critical message")
# WARNING:root:warning message
# ERROR:root:error message
# CRITICAL:root:critical message

 通过调节参数来控制级别

import logging
logging.basicConfig(
    level = logging.DEBUG
)
logging.debug("debug message")
logging.info("info message")
logging.warning("warning message")
logging.error("error message")
logging.critical("critical message")
# DEBUG:root:debug message
# INFO:root:info message
# WARNING:root:warning message
# ERROR:root:error message
# CRITICAL:root:critical message

也可以存储到文件中，默认是追加模式

import logging
logging.basicConfig(
    level = logging.DEBUG,
    filename = "logging.log"
)
logging.debug("debug message")
logging.info("info message")
logging.warning("warning message")
logging.error("error message")
logging.critical("critical message")
# logging.log
# DEBUG:root:debug message
# INFO:root:info message
# WARNING:root:warning message
# ERROR:root:error message
# CRITICAL:root:critical message

可以更改为修改模式

import logging
logging.basicConfig(
    level = logging.DEBUG,
    filename = "logging.log",
    filemode = "w"
)

用format指定handler使用的日志显示格式

import logging
logging.basicConfig(
    level = logging.DEBUG,
    format = "%(asctime)s [%(lineno)s] %(filename)s %(message)s"
)
logging.debug("debug message")
logging.info("info message")
logging.warning("warning message")
logging.error("error message")
logging.critical("critical message")
# 2020-03-06 11:53:05,762 [8] logging test.py debug message
# 2020-03-06 11:53:05,762 [9] logging test.py info message
# 2020-03-06 11:53:05,763 [10] logging test.py warning message
# 2020-03-06 11:53:05,763 [11] logging test.py error message
# 2020-03-06 11:53:05,763 [12] logging test.py critical message

logger()对象模式  ☆

import logging
logger = logging.getLogger()
fh = logging.FileHandler("test_log") #存到文件里
ch = logging.StreamHandler() #输出到屏幕上
fm = logging.Formatter("%(asctime)s [%(lineno)s] %(filename)s %(message)s")

fh.setFormatter(fm)
ch.setFormatter(fm)
logger.addHandler(fh)
logger.addHandler(ch)
logger.setLevel("DEBUG")
logger.debug("debug message")
logger.info("info message")
logger.warning("warning message")
logger.error("error message")
logger.critical("critical message")
# 2020-03-06 12:47:42,772 [12] logging test.py debug message
# 2020-03-06 12:47:42,773 [13] logging test.py info message
# 2020-03-06 12:47:42,773 [14] logging test.py warning message
# 2020-03-06 12:47:42,773 [15] logging test.py error message
# 2020-03-06 12:47:42,773 [16] logging test.py critical message

configparser模块

目的是配置文件的解析

 生成： 

#!/usr/bin/env python 
# -*- coding:utf-8 -*-
import configparser

config = configparser.ConfigParser() #config = {}
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)
    # [DEFAULT]
    # serveraliveinterval = 45
    # compression = yes
    # compressionlevel = 9
    # forwardx11 = yes
    # 
    # [bitbucket.org]
    # user = hg
    # 
    # [topsecret.server.com]
    # host
    # port = 50022
    # forwardx11 = no

修改功能：

　　查询

import configparser
config = configparser.ConfigParser()

config.read("example.ini")
print(config.sections()) #只打印非[DEFAULT]
# ['bitbucket.org', 'topsecret.server.com']
print("byte.org" in config) #判断是否在块内
# False
print(config["bitbucket.org"]["User"]) #大小写不敏感
# hg
for key in config["bitbucket.org"]: #会加上DEFAULT的key
    print(key)
    # user
    # serveraliveinterval
    # compression
    # compressionlevel
    # forwardx11
print(config.options("bitbucket.org")) #输出成列表格式
#['user', 'serveraliveinterval', 'compression', 'compressionlevel', 'forwardx11']
print(config.items("bitbucket.org")) #拿出键值对，以元组格式
#[('serveraliveinterval', '45'), ('compression', 'yes'), ('compressionlevel', '9'), ('forwardx11', 'yes'), ('user', 'hg')]
print(config.get("bitbucket.org","compression")) #DEFAULT相当于在任何块里
# yes

　　增删改

import configparser
config = configparser.ConfigParser()
config.read("example.ini")
config.add_section("yuan") #加块
config.set("yuan","k1","1111")#加键值对
config.remove_section("bitbucket.org") #删除块
config.remove_option("yuan","k1")#删除键值对
config.write(open("i.cfg","w")) #写在新文件里

hashlib模块

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

md5 加密

import hashlib
obj = hashlib.md5() #加密，不能反解
obj.update("hello".encode("utf8"))
print(obj.hexdigest())
# 5d41402abc4b2a76b9719d911017c592
# 比较的时候只能密文对密文

在一个程序中，第一次加密的结果会影响第二次加密的结果

obj = hashlib.md5() #加密，不能反解
obj.update("hello".encode("utf8"))
print(obj.hexdigest())
# 5d41402abc4b2a76b9719d911017c592
# 比较的时候只能密文对密文
obj.update("root".encode("utf8"))
print(obj.hexdigest())
# e206121dbbe984f3bc6c6448846ed8cd

  

import hashlib
obj = hashlib.md5() #加密，不能反解
obj.update("helloroot".encode("utf8"))
print(obj.hexdigest())
# e206121dbbe984f3bc6c6448846ed8cd

SHA256使用与MD5一致，只是需要花费更多时间