python常用模块

内置模块

2.1 数学模块 math

import math
​
math.ceil(-3.9)              # 向大取整   -3
math.floor(-3.9)             # 向小取整   -4
​
# # 结果都是浮点型
math.pow(3,2)                # 幂运算   9.0
math.sqrt(9)                 # 开平方   3.0
math.fabs(-3)                # 绝对值   3.0
math.fsum([1,2,3])           # 序列和   6.0
math.modf(16.3)              # 拆分为元祖 (0.3000000000000007, 16.0)
math.copysign(-3,-3)         # 将第二个参数的标志给第一个值    -3.0

　　

2.2 随机数模块 random

import random
​
random.random()           # 随机生成 0 到 1 的16位小数 
random.uniform()          # 指定范围生成随机16位小数
​
random.randrange()        # 随机生成一个，同range
random.choice()           # 从序列中随机取一值
random.sample()           # 从序列中随机取多值
random.shuffle()          # 随机打乱原来的序列

　　

2.3 序列化模块 pickle & json

# pickle
import pickle
pickle.dumps()            # 序列化(二进制字节流)
pickle.loads()            # 反序列化
​
pickle.dump()             # 将数据序列化后，写入文件
pickle.load()             # 将文件反序列化后读取出来
​
# json 
import json
# 可序列化类型 (int,float,bool,str,list,tuple,dict,None)
json.dumps()             # 序列化(字符串)
# 参数(序列化数据，ensure_ascii = False ,sort_keys=True)
json.loads()             # 反序列化
​
json.dump()              # 将数据序列化后，写入文件
json.load()              # 将文件反序列化后读取出来
​
# 不同点
"""
1、pickle 对于Python可以序列化一切，功能强大；json 对于其他语言来说，互通性较强,应用广泛。
2、pickle 存储，读取数据，可以连续（有标识符），而json 可以连续储存，但不能连读取
    解决json不能连续读取的方法：
    dic1 = {"a":1,"b":2}
    dic2 = {"c":3,"d":4}
    # 连续储存
    with open("a1.json",mode="w",encoding="utf-8") as f:
        json.dump(dic1,f)
        f.write("
")
        json.dump(dic2,f)
        f.write("
")
    # 读取
    with open("a1.json",mode="r",encoding="utf-8") as f:
    for i in f:
        res = json.loads(i)
        print(i)
"""

　　

2.4 时间模块 time 

import time
​
time.time()                                            # 获取时间戳                            
time.ctime()                                           # 将时间戳转化为时间字符串，默认为当前时间
time.localtime()                                       # 将时间直戳，转换为时间元组，默认为当前时间                      
time.strftime("%Y-%m-%d %H:%M:%S")                     # 格式化时间元组为字符串     
res = "1997年11月22日，19点22分61秒"                        
res1 = time.strptime(res,"%Y年%m月%d日，%H点%M分%S秒")   # 将字符串带有的时间元素提取出来    

2.5 压缩模块 zipfile & tarfile

import zipfile
# 创建chishi压缩文件夹
z = zipfile.ZipFile("chishi.zip","w",zipfile.ZIP_DEFLATED)
​
# 将/home/bajie/路径下的 笔记.py 压缩
z.write("/home/bajie/笔记.py","笔记.py")
​
# 将/home/bajie/路径下的 笔记.py 压缩至chisi.zip/python 下
z.write("/home/bajie/笔记.py","/python/笔记.py")
​
# 关闭文件
z.close()
​
# with 语句 打开chishi压缩文件
with zipfile.ZipFile("chishi.zip","r") as z :
    # 将当前目录的 笔记.py 解压至  /home/bajie/hahaha
    z.extract("笔记.py","/home/bajie/hahaha")
    # 解压所有文件 至 /home/bajie/hahaha
    z.extractall("/home/bajie/hahaha")
​
# 追加文件
with zipfile.ZipFile("chishi.zip","a",zipfile.ZIP_DEFLATED) as z :
    z.write("/home/bajie/job.py")
​
# 查看所有文件名，返回列表
    print(z.namelist())
    
################################################################################################  
​
import tarfile
with tarfile.open("文件名","模式",encoding = "utf-8") as tf:
    """模式
    w          单纯打包        文件名后缀   .tar
    w:gz       gz算法打包      文件名后缀   .tar.gz
    w:bz2      bz2算法打包     文件名后缀   .tar.bz2 
    """
# 压缩
with tarfile.open("ceshi1.tar.bz2","w:bz2",encoding = "utf-8") as tf:
    tf.add("路径/文件名","别名")
# 解压
with tarfile.open("ceshi1.tar.bz2","w:bz2",encoding = "utf-8") as tf:
    tf.extract("路径/文件名","路径")      # 单个文件
    tf.extractall("路径")                # 所有文件
# 追加(只能追加单纯打包的tar文件)
​
# 查看
with tarfile.open("ceshi1.tar.bz2","w:bz2",encoding = "utf-8") as tf:
    tf.gatnames()

　　

2.6 os 系统操作模块

import os
# 方法
os.system()                           # 执行系统命令
os.popen() + read()                   # 执行系统命令接收返回值，防止字符串乱码，配合read()读取数据。
"""
res = os.popen()
print(res.read())
""" 
os.listdir()                          # 获取文件夹目录   . 当前目录    .. 上一级目录
os.getcwd()                           # 获取该文件的路径
__file__                              # 获取该文件的路径+文件名
os.chdir()                            # 修改工作路径
# 属性
os.environ                            # 获取系统环境变量
# 添加环境变量
os.environ["PATH"] += "需要添加的路径" # 命令行执行可执行文件
os.name                               # 获取系统标识符
os.sep                                # 获取系统路径分割符
os.linesep                            # 获取系统换行符
​
################################################################################################
os.mknod ()                           # 创建文件
os.remove()                           # 删除文件            
os.mkdir()                            # 创建文件夹
os.rmdir()                            # 删除文件夹
os.rename()                           # 重命名
os.makedirs()                         # 批量创建文件夹
os.removedirs()                       # 批量删除文件夹（为空的时候删除）
################################################################################################
​
# os.path
os.path.basename()                    # 获取完整路径中的文件名部分
os.path.dirname()                     # 获取完整路径中的路径部分
os.path.split()                       # 将路径拆分成单独的文件部分和路径部分，组合成一个元组
os.path.join()                        # 路径的拼接
os.path.isdir()                       # 判断是否是文件夹
os.path.isfile()                      # 判断是否是文件
os.path.link()                        # 判断是否是链接
os.path.getctime()                    # 获取创建时间
os.path.getmtime()                    # 获取修改时间
os.path.getatime()                    # 获取访问时间
os.path.getsize()                     # 获取文件大小
os.path.exists()                      # 检测路径是否存在
os.path.isabs()                       # 判断是否是绝对路径
os.path.abspath()                     # 将相对路径转化为绝对路径
​

　　

2.7 shutil 文件操作模块

import shutil
​
# shutil 模块
shutil.copyfileobj("文件句柄1"，"文件句柄2")    # 复制文件，需要提前拿到文件句柄
shutil.copyfile("文件名1"，"文件名2")          # 复制文件内容，文件2可以不存在
shutil.copymode("文件名1"，"文件名2")          # 复制文件权限位
shutil.stat("文件名1"，"文件名2")              # 复制文件所有状态,不包括内容
shutil.copy("文件名1"，"文件名2")              # 复制文件权限和内容，不复制状态
shutil.copy2("文件名1"，"文件名2")             # 复制文件一切
shutil.copytree("文件夹1"，"文件夹2")          # 复制文件夹
shutil.retree("文件夹")                       # 删除文件夹(有内容也删除)
shutil.move("path1","path2")                 # 移动

　　

2.8 正则表达式 re模块

2.8.1 正则表达式元字符

预定字符集(单个字符)	匹配内容
.	除换行之外的所有字符
d	数字
D	非数字
w	数字字母下划线(py支持中文)
W	非数字字母下划线(py支持中文)
s	空白( , , ," ")
S	非空白( , , ," ")
	换行
	制表符
|	或
[]	字符组
[^+-*/]	^在字符组里表示非，除了+-*/
(a|b)	分组，一个整体，优先显示括号内的匹配结果
(?:a)	b取消有限显示，显示全部匹配结果
(?P<组名>)	命名分组
(?P = 组名)	引用分组
边界符(以 'regex' 为例)
r	左边界 r
x	右边界 x
^r	以 r 开头
x$	以 x 结尾
量词
？	0 或1次
+	1或多次
*	0或多次
{x,y}	大于等于x，小于等于y次
{x}	x次

# 贪婪匹配（向更多次匹配）
# 语法: ------> 量词  修饰 .
# 示例
import re
print(re.findall(".*a","15da la"))              # ['15da \la']
​
# 非贪婪匹配（向更少次匹配）
# 语法: ------>  ？ 修饰 .量词
print(re.findall(".*?a","15dala"))              # ['15da', 'la']
# 命名分组
"""
(?P<组名>) 给这个组起一个名字
(?P=组名) 引用之前组的名字,把该组名匹配到的内容放到当前位置
"""
​
strvar = "<div>今天天气不错~</div>"
re.findall("<(.*?)>(.*?)<(.*?)>",strvar)        # [('div', '今天天气不错~', '/div')]
​
# 反向引用 （    1 == 第一个分组内容     ）
re.findall(r"<(.*?)>(.*?)<(/1)>",strvar)       # [('div', '今天天气不错~', '/div')]
​
# 引用分组
strvar = "a1b2cab"
obj = re.search(r"(?P<tag1>.*?)d(?P<tag2>.*?)d(?P<tag3>.*?)(?P=tag1)(?P=tag2)",strvar)

　　

2.8.2 re模块

import re
re.findall("正则表达式","待匹配字符串")                  # 将所有配的结果加入到返回值列表当中
re.dinditer("正则表达式","待匹配字符串")                 # 将所有配的结果的对象加入到返回值迭代器中
​
obj = re.search("正则表达式","待匹配字符串")             # 将第一次匹配到的结果储存到返回值 obj 对象当中
obj.group()                                           # 显示匹配结果
obj.groups()                                          # 显示分组里的内容
​
re.split("[切割内容]","待切割字符串")                    # 切割
re.sub("[替换内容]","[替换内容]",次数)                   # 替换
re.sunb("[替换内容]","[替换内容]",次数)                  # 返回元组（"内容"，次数）
​
res = re.compile("正则表达式")                          # 定义匹配规则，终身使用
res.findall("待匹配字符串")
res.split("待切割字符串")
# 修饰符
​
re.I     #用法    res = re.compile("正则表达式",flags = re.I)   不区分大小写
# 示例
strvar = "abJDn15"
res = re.compile("[A-Z]",flags = re.I)
print(res.findall(strvar))            # ['a', 'b', 'J', 'D', 'n']
​
re.M     #用法    res = re.compile("正则表达式",flags = re.M )  多行匹配
strvar = """abJ
Dn15"""
res = re.compile("[A-Z]",flags = re.M)
print(res.findall(strvar))             # ['J', 'D']
​
re.S     #用法    res = re.compile("正则表达式",flags = re.S )  匹配一切（包括换行符）
strvar = """abJ
Dn15"""
res = re.compile("^A(?:.*?)5$",flags = re.S | re.I)
print(res.findall(strvar))             # ['abJ
Dn15']

　　

2.9 sys 系统模块

import sys
sys.path()                     # 获取所有环境变量路径，返回值是列表