Python常用模块总结，附实例

（1）os模块

import os

f = open("d:/111/1.txt","w")  #如果目录不存在也是不能创建的


#（1）重命名文件，删除文件
try:
    os.remove("123.txt")    #删除文件，特别要注意，不要删错了
    os.rename("123.txt","456.txt")  #重命名
except Exception as e:
    print(e)

#（2）返回.py文件所在工作目录   不带\
path = os.getcwd()   #返回.py文件所在工作目录   不带\


#(3)  os.path模块

path = r"c:\demo\test\abc.txt"   #注意这里不加r会出错 ，带上r  \自动变成了\\

path1 = "c:\\demo\\test\\abc.txt"   #这样就需要两个斜线  因为字符串里面，右斜的是转义字符

#\r\n   换行符

path2 = "c:/demo/test/abc.txt"

path3 = "c:\111.txt"
path4 = 'c:\111.txt'

print(path3)  #打印出错了，因为他把\1  当成转义字符了
print(path4)  #单双引号，都会转义  这点跟php不一样

a = os.path.split(path)   #将目录和文件名分隔开来   文件名带后缀  保存到元祖里面
b = os.path.split(path1)
c = os.path.split(path2)

print(c[1])   #通过下标访问元祖

print(a,b,c)

d = os.path.splitext(path2)

print(d)    #返回   ('c:/demo/test/abc', '.txt')  带点的扩展名


d = os.path.dirname(path2)  #其实就是  文件路径   split分隔的第一部分
print(d)

d = os.path.basename(path2)   #其实就是  文件名   split分隔的第二部分
print(d)


e = os.path.abspath("456.txt")   #相对路径  求出绝对路径  
print(e)

print(os.path.getatime(e)) #返回最近访问时间 浮点型时间戳
print(os.path.getmtime(e)) #返回上一次修改时间 浮点型时间戳
print(os.path.getctime(e)) #返回文件创建时间 浮点型时间戳


print(os.path.exists(e))   #文件是否存在

print(os.path.isdir(e))     #是否是一个目录
print(os.path.isfile(e))     #是否是一个文件

print(os.path.join(e[0],e[1]))


#创建目录

try:
    os.mkdir("d:/111")  # 文件存在就无法创建了
except Exception as e:
    print(e)


print(os.path.expanduser("~"))   #Administrator的路径   这个是内置的？

print(os.path.join(os.path.expanduser("~"),"Desktop"))

（2）sys模块

import sys

a = sys.argv   #当前文件的绝对路径 a[0]
a = sys.path   #各种系统文件的目录

print(sys.version)   #这个是python的版本
print(sys.platform)   #返回操作系统平台名称   win32
print(sys.executable)   #Python解释程序路径
print(sys.modules.keys())   #显示系统导入的模块
print(sys.exc_info())   #获取当前正在处理的异常类
print(sys.copyright)   #获取当前正在处理的异常类


sys.exit(0)  #退出当前的程序

print(a)

（3）random模块

import random

a = random.random()   #产生0-1之间随机小数
a1 = random.uniform(1,10)    #产生m-n之间的随机小数
print(a,a1)


b = random.randint(1,2)   #全闭合的   [1,2]区间一个整数，不是列表  一般列表都是左闭右开
print(b)

---------------------------------------------------
print(list(range(0,10)))   #生成0-10   左闭右开的列表

************************为什么要左闭右开
抛开冗长的分析过程，总结一下，选择第一种表示法（左闭右开区间）有以下几个原因

1.上下界之差等于元素的数量
2.易于表示两个相邻子序列，一个子序列的上界就是另一个子序列的下界
3.序列从零（最小自然数）开始计数时，下界的下标不是 -1（非自然数）
4.表达空集时，不会使得上界小于下界
***********************************

a = range(0,11)   #a是一个range类型  要转化为list
print(type(a))

for i in range(0,11):
    if i == 5:
        continue    #5不会打印出来
    print(i)
---------------------------------------------------

c = random.choice("abcdefg")   #选择字符串里面随机一个字符
c1 = random.sample("abcdefghijk",3)   #产生一个3个字符的列表
c2 = ''.join(c1)   #这个意思是直接将列表c1拼接起来

e = ["te1","te2","te3"]
f = random.choice(e)   #列表则选择列表中的一个元素
print(f)


lst = ["1","2","3","4"]

random.shuffle(lst)   #shuffle   洗牌   重新排序   这个没有返回值
print(lst)

（4）math模块

import math

PI = math.pi

print(math.ceil(1.1))   #ceil  天花板   向上取整

print(math.floor(1.1))  #floor 地板   向下取整

print(math.pi)    #  π圆周率

print(math.sqrt(2))   #开平方

print(math.sin(PI/2))   #sin,cos,tan,这里的都是弧度

print(math.pow(2,4))     #返回  x的y次方  浮点数



保留多少位小数
from _pydecimal import Decimal,Context,ROUND_HALF_UP   #四舍五入
print(Context(prec=3, rounding=ROUND_HALF_UP).create_decimal('1.3255'))  #总共3位，保留2位

from decimal import Decimal

a = Decimal(1.325)
b = Decimal(1.32500000000000000000000000000000000001)
print(a==b)   #这个居然相等

（5）re模块

import re
'''
None是一个对象，而NULL是一个类型。
Python中没有NULL，只有None，None有自己的特殊类型NoneType。
None不等于0、任何空字符串、False等。
在Python中，None、False、0、""(空字符串)、[](空列表)、()(空元组)、{}(空字典)都相当于False。

'''
#---------------（1）re.match  必须是开头就得匹配，否则返回None
pattern = re.compile("([\w]+)\s([\w]+)!")

res = re.match(pattern,"！！！hello world! hello111!!!")   #match 必须是开头就得匹配，否则返回None

print(res)   #如果匹配返回  obj   不匹配返回None

if res:
    print(res.group(0,1,2))    #只匹配了第一次出现的  这是一个元祖
    # group(0)表示整个匹配结果的第一个（全额）匹配   group(1) 表示第一个小括号匹配  以此类推
else:
    print("Not Match")

#---------------（2）re.search   搜索到即可

pattern = re.compile("([\w]+)\s([\w]+)!")

res = re.search(pattern,"!!!hello world! hello111!!!")   #match 必须是开头就得匹配，否则返回None

print(res)   #如果匹配返回  obj   不匹配返回None

if res:
    print(res.group(0,1,2))    #只匹配了第一次出现的  这是一个元祖
    # group(0)表示整个匹配结果的第一个（全额）匹配   group(1) 表示第一个小括号匹配  以此类推
else:
    print("Not Match")


#---------------（3）re.findall   找到所有符合条件的
pattern = re.compile("([\w]+)\s+([\w]+)!+")   #注意[abc]只匹配一个字符哦！
#比如   [123abc]  匹配"abcde"   返回  a b c  3中匹配结果
#ab+  跟[ab]+  就不一样了    ab+只能匹配ab开头的   [ab]+可以匹配 aaabbb等

res = re.findall(pattern,"hello world! hello  world!!!!")   # 注意返回结果list 只匹配（）里面的，这点跟易语言不同。

print(res)   #如果匹配返回返回一个列表  里面装的是元祖  不匹配返回一个空list

if res:

    for items in res:
        for i in items:
            print(i)
else:
    print("Not Match")


num = len(res)   #获取匹配的结果数
print(num)
#---------------（4）re.finditer   返回一个obj 迭代器   跟list不太一样  但也是搜索全部结果
pattern = re.compile("([\w]+)\s+([\w]+)!+")   #注意[abc]只匹配一个字符哦！

res = re.finditer(pattern,"hello world! hello  world!!")

print(res)

for m in res:
    print(m.group())

#---------------（5）re.sub    re.sub(pattern, repl, string[, count])
# 使用repl替换string中每一个匹配的子串后返回替换后的字符串。

pattern = re.compile("([\w]+)\s+([\w]+)(!+)")   #注意[abc]只匹配一个字符哦！

res = re.sub(pattern,r'\1\2ni yaya','hello world! heeello  world!!!',count=1)   #\1表示第一个匹配项目
#\2 表示第二个匹配项     count替换的次数  默认count 替换掉所有的

aaa = "nihai"

print(aaa.upper())


def func1(m):
    return m.group(1).title() + " " + m.group(2).upper()

res1 = re.sub(pattern,func1,'hello world! heeello  world!!!')   # 通过函数  进行模型替换，全部转化为大写
# 或者标题化 首字母大写

print(res1)

#比较一下  str.replace()

ss = "akakak"
ss = ss.replace('k','8')   #这个是有返回结果的   正则替换比这个字符串固定替换更加厉害

print(ss + "1111")



#---------------（6）re.subn    re.subn(pattern, repl, string[, count])

#多返回一个  替换的次数统计
pattern = re.compile("([\w]+)\s+([\w]+)(!+)")   #注意[abc]只匹配一个字符哦！

res = re.subn(pattern,r'\1\2ni yaya','hello world! heeello  world!!!')   #\1表示第一个匹配项目
#\2 表示第二个匹配项     count替换的次数  默认count 替换掉所有的

print(res)   #替换次数为2


# ---------------（7）re.split   re.split(pattern, string[, maxsplit])
#按照能够匹配的子串将string分割后返回列表。maxsplit用于指定最大分割次数，不指定将全部分割

pattern = re.compile(r"\d")

res = re.split(pattern,"one1two2three3for")  #按照数字分割成一个列表

print(res)

#---------比较一下   比str.split()  更加强大

ss = "a1b1c1d1"

print(ss.split("1"))
#但是   正则更厉害

pattern = re.compile("\d")

res = re.split(pattern,"a2b3c4d5")

print(res)    #['a', 'b', 'c', 'd', '']   最后多出一个''

（6）datetime，date，time模块

import datetime,time

a = datetime.date.today()   #返回日期
a = datetime.datetime.today()  #返回日期，时间精确到毫秒...

a = time.time()   #返回时间戳
a = time.localtime()   #

# a = time.gmtime()   #返回时间戳

print(time.strftime("%Y-%m-%d %H:%M:%S",time.gmtime()))   #gmt

print(time.strftime("%Y-%m-%d %H:%M:%S",time.localtime()))  #本地时间

（7）hashlib，md5加密模块

import hashlib

#md5str = hashlib.md5('jsphp.net'.encode(encoding='UTF-8')).hexdigest()

md5str = hashlib.md5("111".encode(encoding="UTF-8"))   #这是1个地址，保存了md5值
print(md5str)
md5str = md5str.hexdigest()  #转化为16进制
print(md5str)


sha1 = hashlib.sha1("222".encode(encoding="UTF-8")).hexdigest()

print(sha1)

（8）json模块

import json

a = '{"a":"hahahah","b":"sdjskdj"}'
b = {"d":"hahahah","b":"sdjskdj"}
c = [{"d":"hahahah","b":"sdjskdj"}]

print(a,b)

print(type(b),type(c))

print(json.dumps(b,sort_keys=True))    #dict转化为字符串,并排序   按照字段排序

print(json.dumps(c))    #list转化为字符串   dumps  转储


jsonData = '{"a":"hahahah","b":"sdjskdj"}'

print(json.loads(jsonData))    #将字符串  转化为dict

print(eval(jsonData))    #通过eval函数转化