模块的介绍

python中的一个.py文件就是一个模块，一个package也是一个模块，模块有内置模块，第三方模块，自定义模块3种。

def my_sum(*args): 
    return sum(args) 

定义一个util.py模块

import util 
 
print(util.my_sum(45, 63)) 
 
from util import my_sum 
 
print(my_sum(3, 5)) 

另一个模块导入这个模块。

import sys 
 
for val in sys.path: 
    print(val) 

D:\python\projects\python_first\first\day5 
C:\Users\xxx\AppData\Local\Programs\Python\Python38\python38.zip 
C:\Users\xxx\AppData\Local\Programs\Python\Python38\DLLs 
C:\Users\xxx\AppData\Local\Programs\Python\Python38\lib 
C:\Users\xxx\AppData\Local\Programs\Python\Python38 
C:\Users\xxx\AppData\Local\Programs\Python\Python38\lib\site-packages 

python的import会从sys模块的path所包含的所有路径中查询模块

def my_sum(*args): 
    return sum(args) 
 
if __name__ == "__main__": 
    print(__name__) 

name__在当前文件执行时为__main，被其他模块导入时为模块名，加上这个判断表示只有在当前文件中执行才执行print函数。

内置模块

time

import time 
 
print(time.time())  # 时间戳，获取从1970年开始的当前秒值 
print(time.localtime())  # 结构化时间，当前时间的年月日，时分秒 时区为当前所在时区 将时间戳转换成结构化时间，默认为当前时间 
print(time.localtime().tm_year) 
print(time.gmtime())  # 结构化时间，当前时间的年月日，时分秒 格林威治时间 
print(time.mktime(time.localtime()))  # 将结构化时间转换成时间戳 
print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))  # 结构化时间格式化为字符串 
print(time.strptime("2019-02-05 13:51:25", "%Y-%m-%d %H:%M:%S"))  # 字符串解析为结构化时间 
print(time.asctime(time.localtime()))  # 结构化时间格式化为字符串 固定的格式 
print(time.ctime(time.time()))  # 时间戳格式化为字符串 固定的格式 
time.sleep(0.2)  # 线程延迟执行时间 

time模块提供时间的一些基本操作。

datetime

import datetime 
 
current = datetime.datetime.now()  # 获取当前时间 
print(current.strftime("%Y-%m-%d %H:%M:%S"))  # 时间格式化 
print(current - datetime.timedelta(hours=5))  # 获取当前时间之前5个小时的时间 

datetime模块提供更多的对时间日期操作的功能，如时间日期的加减。

random

import random 
 
print(random.random())  # [0,1)之间的随机小数值 
print(random.randint(1, 5))  # [1,5]之间的随机整数值 等于randrange(1,5+1) 
print(random.randrange(1, 5))  # [1,5)之间的随机整数值 
print(random.choice([1, 2, 3]))  # 获取序列中的随机值 先获取随机索引，再通过索引取值 
print(random.sample({1, 2, 3, 4, 5}, 3))  # 序列或集合中随机去K个值 
print(random.uniform(1, 3))  # [1,3)之间的随机小数值 
nums = [1, 2, 3, 4, 5] 
random.shuffle(nums)  # 对列表随机洗牌 
print(nums) 

random提供了获取随机值的功能。

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下为"\r\n",Linux下为"\n" 
os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为: 
os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix' 
os.system("bash command")  运行shell命令，直接显示 
os.environ  获取系统环境变量 
 
print(os.path.abspath(__file__))  # 返回path规范化的绝对路径 
print(os.path.split(__file__))  # 将path分割成目录和文件名二元组返回 
print(os.path.dirname(__file__))  # 返回path的目录。其实就是os.path.split(path)的第一个元素 
print(os.path.basename(__file__))  # #      返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素 
print(os.path.exists(__file__))  # 如果path存在，返回True；如果path不存在，返回False 
print(os.path.isabs(__file__))  # 如果path是绝对路径，返回True 
print(os.path.isfile(__file__))  # 如果path是一个存在的文件，返回True。否则返回False 
print(os.path.isdir(__file__))  # 如果path是一个存在的目录，则返回True。否则返回False 
print(os.path.join(__file__))  # 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略 
print(os.path.getatime(__file__))  # 返回path所指向的文件或者目录的最后存取时间 
print(os.path.getmtime(__file__))  # 返回path所指向的文件或者目录的最后修改时间 

os模块可以调用操作系统的一些功能

sys

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

sys模块表示python解释器的一些功能。

json

import json 
 
person_dict = { 
    "name": "lisi", 
    "age": 23, 
    "address": { 
        "province": "beijing", 
        "city": "beijing" 
    } 
} 
person_str = json.dumps(person_dict)  # 将对象转成json字符串 
json.dump(person_dict, open("person_dict.json", "w"))  # 将对象转成字符串并写入文件中 
print(person_str) 
person = json.loads(person_str)  # 将字符串转成对象 
print(person, type(person)) 
print(json.load(open("person_dict.json", "r")))  # 从文件中读出字符串并转成对象 

json模块提供了格式化json和解析json的功能。

pickle

import pickle 
 
person_dict = { 
    "name": "lisi", 
    "age": 23, 
    "address": { 
        "province": "beijing", 
        "city": "beijing" 
    } 
} 
person_bytes = pickle.dumps(person_dict)  # 将对象转成字节数组 
print(person_bytes, type(person_bytes)) 
person = pickle.loads(person_bytes)  # 将字节数组转成对象 
print(person) 

pickle模块提供了序列化和反序列化的功能。

shelve

import shelve 
 
person_dict = { 
    "name": "lisi", 
    "age": 23, 
    "address": { 
        "province": "beijing", 
        "city": "beijing" 
    } 
} 
f = shelve.open("shelve") 
print(f, type(f)) 
f["person"] = person_dict  # 将对象序列化并保持到文件中 
person = f.get("person")  # 读取文件并反序列化成对象 
print(person) 

shelve模块封装了pickle模块，提供了操作字典类似的功能，将对象反序列化后保存到文件中，读取字典就是读取文件。

xml

import xml.etree.ElementTree as ET 
 
# 读取和修改xml文件 
person_doc = ET.parse("person.xml")  # 解析xml文件 
person_tag = person_doc.getroot()  # 获取xml的根元素 
print(person_tag.tag)  # 获取元素标签名 
print(person_tag.get("id"))  # 获取元素属性 
print(person_tag.set("id", "p2"))  # 修改元素属性 
person_children = list(person_tag)  # 获取元素子元素列表 
print(person_children[0].text)  # 获取元素文本内容 
print(person_children[1].text) 
address_children = list(person_children[2]) 
print(address_children[0].text) 
print(address_children[1].text) 
address_children[0].text = "shanghai"  # 修改元素内容 
person_tag.remove(person_children[1])  # 删除子元素 
 
person_doc.write("persn_new.xml")  # 将新的xml文档写入文件 
 
# 创建xml文件 
user_tag = ET.Element("user")  # 创建一个新元素 
user_tag.set("id", "u1")  # 设置属性 
name_tag = ET.SubElement(user_tag, "name")  # 创建子元素 
name_tag.text = "lisi"  # 设置内容 
 
user_doc = ET.ElementTree(user_tag)  # 创建文档 
user_doc.write("user.xml")  # 文件写入 

ElementTree模块提供了解析及操作xml文件的功能。

re

import re 
 
mobile_re_str = r"^1[3578|]\d{9}$"  # r表示去除转义 
mobile_re = re.compile(mobile_re_str)  # 创建一个正则表达式对象 手机号 
print(mobile_re, type(mobile_re)) 
print(mobile_re.match("18925517692"))  # 如果匹配返回匹配对象，不匹配返回None 
print(re.match(mobile_re_str, "3mmsmevm"))  # 等于先compile再match 
 
print(re.findall("\d{4}", "asdf236bsndm3335nsndns4444"))  # 获取所有匹配结果 
for m in re.finditer("\d{4}", "asdf236bsndm3335nsndns4444"):  # 获取所有匹配对象 
    print(m.group())  # 获取匹配值 
 
print(re.search("\d{4}", "asdf236bsndm3335nsndns4444").group())  # 获取第一个匹配结果 
 
print(re.split("\s+", "abc d  \n dd \t s"))  # 字符串分割 
 

re模块提供了操作正则表达式的功能。

logging

import logging 
 
# 日志配置 文件和控制台输出只能有一个 
logging.basicConfig( 
    level=logging.DEBUG, 
    filename="logging.log", 
    filemode="w", 
    format="%(asctime)s [%(lineno)s] %(message)s" 
) 
 
logging.debug("this is debug msg") 
logging.info("this is debug msg") 
logging.error("this is debug msg") 
logging.warning("this is debug msg") 
logging.critical("this is debug msg") 

使用这种方式，文件和控制台只能输出一种。

import logging 
 
 
def getLogger(): 
    logger = logging.getLogger() 
    fh = logging.FileHandler("logging2.log", mode="w") 
    sh = logging.StreamHandler() 
    fm = logging.Formatter("[%(asctime)s] %(message)s") 
    fh.setFormatter(fm) 
    sh.setFormatter(fm) 
    logger.addHandler(fh) 
    logger.addHandler(sh) 
    logger.setLevel(logging.DEBUG) 
    return logger 
 
 
logger = getLogger() 
logging.debug("this is debug msg") 
logging.info("this is debug msg") 
logging.error("this is debug msg") 
logging.warning("this is debug msg") 
logging.critical("this is debug msg") 

文件和控制台都可以输出，更加的灵活。

configparser

import configparser 
 
# 创建一个配置文件 
parser = configparser.ConfigParser() 
parser["DEFAULT"] = { 
    "username": "lisi", 
    "pwd": "123456" 
} 
parser["JDBC"] = { 
    "version": "8.0" 
} 
with open("mysql.ini", "w") as f: 
    parser.write(f) 
 
# 读取配置文件及修改配置文件 
parser = configparser.ConfigParser() 
 
parser.read("mysql.ini", "utf-8") 
print(parser.sections()) 
print(parser.defaults()) 
 
parser["ODBC"] = { 
    "version": "5.7" 
} 
parser.remove_section("JDBC") 
 
with open("mysql.ini", "w") as f: 
    parser.write(f) 

configparser模块提供了一种操作字典的方式来操作配置文件。

hashlib

import hashlib 
 
# md5加密 
print(hashlib.algorithms_available) 
algorithm_md5 = hashlib.md5() 
algorithm_md5.update("hello".encode("utf-8")) 
print(algorithm_md5.hexdigest()) 
# sha256加密 
algorithm_sha256 = hashlib.sha3_256() 
algorithm_sha256.update("hello".encode("utf-8")) 
print(algorithm_sha256.hexdigest()) 

hashlib模块提供了多种加密方法，如md5,sha256等。