PYTHON常用模块

1.OS模块

import os
os.getcwd() # 获取当前工作目录（当前文件加所在目录）
os.chdir('home/py') # 改变当前目录到home/py
os.listdir('home/py') # 获取home/py下所有内容的名称列表
os.mkdir('boy') # 创建boy文件夹
os.makedirs('/home/sy/a/b/c/d') # 递归创建文件夹
os.rmdir('boy') # 删除空目录
os.removedirs('/home/sy/a/b/c/d') # 递归删除文件夹，必须都是空目录
os.renanme('02.txt','002.txt') # 文件或者文件加夹重命名
os.chmod() # 改变目录权限
os.path.basename(‘path/filename’) # 去掉目录路径，返回文件名
os.path.dirname(‘path/filename’) # 去掉文件名，返回目录路径
os.path.join(path1[,path2[,...]]) # 将分离的各部分组合成一个路径名
os.path.split('path') # 将文件路径和文件名分割(会将最后一个目录作为文件名而分离)，返回( dirname(), basename())元组
os.path.splitext() # 将文件路径和文件扩展名分割成一个元组，返回 (filename, extension) 元组
os.path.getatime\ctime\mtime() # 分别返回最近访问、创建、修改时间
os.path.getsize() # 返回文件大小
os.path.exists() # 是否存在
os.path.isabs() # 是否为绝对路径
os.path.abspath(name) # 获得绝对路径
os.path.isdir() # 是否为目录
os.path.isfile() # 是否为文件
os.path.islink() # 判断文件是否连接文件,返回boolea
os.path.realpath(path) # 返回path的真实路径
os.path.relpath(path[, start]) # 从start开始计算相对路径 
os.path.normcase(path) # 转换path的大小写和斜杠
os.path.join(dirname,basename) # 将文件路径和文件名凑成完整文件路径
os.path.ismount() # 指定路径是否存在且为一个挂载点，返回boolean
os.path.samefile() # 是否相同路径的文件，返回boolean
os.path.commonprefix(list) # 返回list(多个路径)中，所有path共有的最长的路径
os.path.lexists() # 路径存在则返回True,路径损坏也返回True
os.path.expanduser(path) # 把path中包含的”~”和”~user”转换成用户目录
os.path.expandvars(path) # 根据环境变量的值替换path中包含的”$name”和”${name}”
os.path.sameopenfile(fp1, fp2) # 判断fp1和fp2是否指向同一文件
os.path.samestat(stat1, stat2) # 判断stat tuple stat1和stat2是否指向同一个文件
os.path.splitdrive(path) # 一般用在windows下，返回驱动器名和路径组成的元组
os.path.walk(path, visit, arg) # 遍历path，给每个path执行一个函数详细见手册
os.path.supports_unicode_filenames() # 设置是否支持unicode路径名

2.sys模块

import sys
sys.argv # 命令行参数List，第一个元素是程序本身路径 
sys.path # 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值 
sys.modules.keys() # 返回所有已经导入的模块列表
sys.modules # 返回系统导入的模块字段，key是模块名，value是模块 
sys.exc_info() # 获取当前正在处理的异常类,exc_type、exc_value、exc_traceback当前处理的异常详细信息
sys.exit(n) # 退出程序，正常退出时exit(0)
sys.hexversion # 获取Python解释程序的版本值，16进制格式如：0x020403F0
sys.version # 获取Python解释程序的版本信息
sys.platform # 返回操作系统平台名称
sys.maxint # 最大的Int值
sys.maxunicode # 最大的Unicode值
sys.stdout # 标准输出
sys.stdout.write(‘aaa‘) # 标准输出内容
sys.stdout.writelines() #　无换行输出
sys.stdin # 标准输入
sys.stdin.read() # 输入一行
sys.stderr # 错误输出
sys.exc_clear() # 用来清除当前线程所出现的当前的或最近的错误信息 
sys.exec_prefix # 返回平台独立的python文件安装的位置 
sys.byteorder # 本地字节规则的指示器，big-endian平台的值是‘big‘,little-endian平台的值是‘little‘ 
sys.copyright # 记录python版权相关的东西 
sys.api_version # 解释器的C的API版本 
sys.version_info # ‘final‘表示最终,也有‘candidate‘表示候选，表示版本级别，是否有后继的发行 
sys.getdefaultencoding() # 返回当前你所用的默认的字符编码格式 
sys.getfilesystemencoding() # 返回将Unicode文件名转换成系统文件名的编码的名字 
sys.builtin_module_names # Python解释器导入的内建模块列表 
sys.executable # Python解释程序路径 
sys.getwindowsversion() # 获取Windows的版本 
sys.stdin.readline() # 从标准输入读一行，sys.stdout.write(“a”) 屏幕输出a

3.time模块

import time
time.time() # 生成timestamp，时间戳
time.localtime() 
""" 
timestamp to struct_time 本地时间 time.struct_time(tm_year=2019, tm_mon=12, tm_mday=10, tm_hour=1, tm_min=20, tm_sec=24, tm_wday=1, tm_yday=344, tm_isdst=0)：tm_year（年）                  比如2011 
tm_mon（月）                   1 - 12
tm_mday（日）                  1 - 31
tm_hour（时）                  0 - 23
tm_min（分）                   0 - 59
tm_sec（秒）                   0 - 61
tm_wday（weekday）             0 - 6（0表示周日）
tm_yday（一年中的第几天）        1 - 366
tm_isdst（是否是夏令时）        默认为-1
"""
time.gmtime() # timestamp to struct_time 格林威治时间
time.strftime("%Y-%m-%d %X",time.localtime()) # 生成格式化时间 2019-12-10 09:52:16
"""
%a       本地（locale）简化星期名称
%A       本地完整星期名称
%b       本地简化月份名称
%B       本地完整月份名称
%c       本地相应的日期和时间表示
%d       一个月中的第几天（01 - 31）
%H       一天中的第几个小时（24小时制，00 - 23）
%I       第几个小时（12小时制，01 - 12）
%j       一年中的第几天（001 - 366）
%m       月份（01 - 12）
%M       分钟数（00 - 59）
%p       本地am或者pm的相应符
%S       秒（01 - 61）
%U       一年中的星期数。（00 - 53星期天是一个星期的开始。）第一个星期天之前的所有天数都放在第0周。
%w       一个星期中的第几天（0 - 6，0是星期天）
%W      和%U基本相同，不同的是%W以星期一为一个星期的开始。
%x      本地相应日期
%X      本地相应时间
%y      去掉世纪的年份（00 - 99）
%Y      完整的年份
%Z      时区的名字（如果不存在为空字符）
%%      ‘%’字符
"""
time.asctime(time.localtime()) # Tue Dec 10 01:54:05 2019 生成固定的时间表示格式
time.ctime(time.time()) # Tue Dec 10 01:54:05 2019 生成固定的时间表示格式

4.datetime模块

import datetime
datetime.date.today() # 本地日期对象,(用str函数可得到它的字面表示(2019-12-10))
datetime.date.isoformat(obj) # 当前[年-月-日]字符串表示(2019-12-10)
datetime.date.fromtimestamp() # 返回一个日期对象，参数是时间戳,返回 [年-月-日]
datetime.date.weekday(obj) # 返回一个日期对象的星期数,周一是0
datetime.date.isoweekday(obj) # 返回一个日期对象的星期数,周一是1
datetime.date.isocalendar(obj) # 把日期对象返回一个带有年月日的元组
datetime.datetime.today() # 返回一个包含本地时间(含微秒数)的datetime对象 2019-12-10 23:31:50.419000
datetime.datetime.now([tz]) # 返回指定时区的datetime对象 2019-12-10 23:31:50.419000
datetime.datetime.utcnow() # 返回一个零时区的datetime对象
datetime.fromtimestamp(timestamp[,tz]) # 按时间戳返回一个datetime对象，可指定时区,可用于strftime转换为日期表示 
datetime.utcfromtimestamp(timestamp) # 按时间戳返回一个UTC-datetime对象
datetime.datetime.strptime(‘2019-12-10 12:21:21‘,”%Y-%m-%d %H:%M:%S”) # 将字符串转为datetime对象
datetime.datetime.strftime(datetime.datetime.now(), ‘%Y%m%d %H%M%S‘) # 将datetime对象转换为str表示形式
datetime.date.today().timetuple() # 转换为时间戳datetime元组对象，可用于转换时间戳

5.hashlib模块

import hashlib
string = "beyondsoft"
md5 = hashlib.md5()
md5.update(string.encode('utf-8'))     #注意转码
res = md5.hexdigest()
print("md5加密结果:",res) # 2f1f78c880f22ae92c0f30be0e9165a7

sha1 = hashlib.sha1()
sha1.update(string.encode('utf-8'))
res = sha1.hexdigest()
print("sha1加密结果:",res) # 292f40cb92d1d55b932ddb46eb0cd59539824993

sha256 = hashlib.sha256()
sha256.update(string.encode('utf-8'))
res = sha256.hexdigest()
print("sha256加密结果:",res) # d60cc4c6a0cb586f74d89add99608e53a6b516f750fa1778d8936ee153eeaa4a

sha384 = hashlib.sha384()
sha384.update(string.encode('utf-8'))
res = sha384.hexdigest()
print("sha384加密结果:",res) # 22d721be68af8ad0dc4b4406005b2cf627a6247b294b497ab36c3512185e5cfeb7869131e3ff8243a59489a1daa7c617

sha512= hashlib.sha512()
sha512.update(string.encode('utf-8'))
res = sha512.hexdigest()
print("sha512加密结果:",res) # 9ffe6a74f559c283a8f3275e681328b0dd45957c9c7fe6ad9b006605af4e59c455a98d561d13a7bd2419f9ba97d57f113b06486cca951af4ec995c47e711bbc2

high = hashlib.md5(b'beyondjie')
high.update(string.encode('utf-8'))
res = high.hexdigest()
print("采用key加密:",res) # 26ff8e8d1fc83ceeb0cddd16c004bbd5

6.random模块

random.random() # 产生0-1的随机浮点数
random.uniform(a, b) # 产生指定范围内的随机浮点数
random.randint(a, b) # 产生指定范围内的随机整数
random.randrange([start], stop[, step]) # 从一个指定步长的集合中产生随机数
random.choice(sequence) # 从序列中产生一个随机数
random.shuffle(x[, random]) # 将一个列表中的元素打乱
random.sample(sequence, k) # 从序列中随机获取指定长度的片断

7.string

str.capitalize() # 把字符串的第一个字符大写
str.center(width) # 返回一个原字符串居中，并使用空格填充到width长度的新字符串
str.ljust(width) # 返回一个原字符串左对齐，用空格填充到指定长度的新字符串
str.rjust(width) # 返回一个原字符串右对齐，用空格填充到指定长度的新字符串
str.zfill(width) # 返回字符串右对齐，前面用0填充到指定长度的新字符串
str.count(str,[beg,len]) # 返回子字符串在原字符串出现次数，beg,len是范围
str.decode(encodeing[,replace]) # 解码string,出错引发ValueError异常
str.encode(encodeing[,replace]) # 解码string
str.endswith(substr[,beg,end]) # 字符串是否以substr结束，beg,end是范围
str.startswith(substr[,beg,end]) # 字符串是否以substr开头，beg,end是范围
str.expandtabs(tabsize = 8) #　把字符串的tab转为空格，默认为8个
str.find(str,[stat,end]) # 查找子字符串在字符串第一次出现的位置，否则返回-1
str.index(str,[beg,end]) # 查找子字符串在指定字符中的位置，不存在报异常
str.isalnum() # 检查字符串是否以字母和数字组成，是返回true否则False
str.isalpha() # 检查字符串是否以纯字母组成，是返回true,否则false
str.isdecimal() # 检查字符串是否以纯十进制数字组成，返回布尔值
str.isdigit()#  检查字符串是否以纯数字组成，返回布尔值
str.islower() # 检查字符串是否全是小写，返回布尔值
str.isupper() # 检查字符串是否全是大写，返回布尔值
str.isnumeric() # 检查字符串是否只包含数字字符，返回布尔值
str.isspace() # 如果str中只包含空格，则返回true,否则FALSE
str.title() # 返回标题化的字符串（所有单词首字母大写，其余小写）
str.istitle() # 如果字符串是标题化的(参见title())则返回true,否则false
str.join(seq) # 以str作为连接符，将一个序列中的元素连接成字符串
str.split(str=‘‘,num) # 以str作为分隔符，将一个字符串分隔成一个序列，num是被分隔的字符串
str.splitlines(num) # 以行分隔，返回各行内容作为元素的列表
str.lower() # 将大写转为小写
str.upper() # 转换字符串的小写为大写
str.swapcase() # 翻换字符串的大小写
str.lstrip() # 去掉字符左边的空格和回车换行符
str.rstrip() # 去掉字符右边的空格和回车换行符
str.strip() # 去掉字符两边的空格和回车换行符
str.partition(substr) # 从substr出现的第一个位置起，将str分割成一个3元组。
str.replace(str1,str2,num) # 查找str1替换成str2，num是替换次数
str.rfind(str[,beg,end]) # 从右边开始查询子字符串
str.rindex(str,[beg,end]) # 从右边开始查找子字符串位置 
str.rpartition(str) # 类似partition函数，不过从右边开始查找
str.translate(str,del=‘‘) # 按str给出的表转换string的字符，del是要过虑的字符

8.urllib模块

import urllib.request
import urllib.parse
import json
url = "http://www.baidu.com"
parsed = urllib.parse.urlparse(url) # 将urlstr解析成各个组件
print(parsed) # ParseResult(scheme='http', netloc='www.baidu.com', path='', params='', query='', fragment='')

url = "http://www.baidu.com"
new_path = urllib.parse.urljoin(url,"index.html") # 将url的根域名和新url拼合成一个完整的url
print(new_path) # http://www.baidu.com/index.html

req = urllib.request.urlopen('http://www.baidu.com') # 打开一个url的方法，返回一个文件对象，然后可以进行类似文件对象的操作
print(req.read())

file_name = urllib.request.urlretrieve('http://www.baidu.com','%s/baidu.html'%BASE_DIR) # 下载url定位到的html文件,不写路径filename则会被存为临时文件可以用 urllib.urlcleanup() 来清理缓存

dic = {'name':'melon','age':18}
data = urllib.parse.urlencode(dic) # 将dict中的键值对以连接符&划分
print(data)  # age=18&name=melon

dic = {'name':'melon','age':18}
data = urllib.parse.urlencode(dic)
req = urllib.request.urlopen('http://127.0.0.1:8000/index?%s'%data) #get请求
content = req.read()

dic = {'name':'melon','age':18}
data = urllib.parse.urlencode(dic)
req = urllib.request.Request('http://127.0.0.1:8000/index', data.encode()) # POST请求
opener = urllib.request.urlopen(req)
content = json.loads(opener.read().decode())

9.re模块

'.'  # 匹配所有字符串，除\n以外
‘-’  # 表示范围[0-9]
'*'  # 匹配前面的子表达式零次或多次。要匹配 * 字符，请使用 \*。
'+'  # 匹配前面的子表达式一次或多次。要匹配 + 字符，请使用 \+
'^'  # 匹配字符串开头
‘$’  # 匹配字符串结尾 re
'\'  # 转义字符， 使后一个字符改变原来的意思，如果字符串中有字符*需要匹配，可以\*或者字符集[*] re.findall(r'3\*','3*ds')结['3*']
'*'  # 匹配前面的字符0次或多次 re.findall("ab*","cabc3abcbbac")结果：['ab', 'ab', 'a']
‘?’  # 匹配前一个字符串0次或1次 re.findall('ab?','abcabcabcadf')结果['ab', 'ab', 'ab', 'a']
'{m}'  # 匹配前一个字符m次 re.findall('cb{1}','bchbchcbfbcbb')结果['cb', 'cb']
'{n,m}'  # 匹配前一个字符n到m次 re.findall('cb{2,3}','bchbchcbfbcbb')结果['cbb']
'\d'  # 匹配数字，等于[0-9] re.findall('\d','电话:10086')结果['1', '0', '0', '8', '6']
'\D'  # 匹配非数字，等于[^0-9] re.findall('\D','电话:10086')结果['电', '话', ':']
'\w'  # 匹配字母和数字，等于[A-Za-z0-9] re.findall('\w','alex123,./;;;')结果['a', 'l', 'e', 'x', '1', '2', '3']
'\W'  # 匹配非英文字母和数字,等于[^A-Za-z0-9] re.findall('\W','alex123,./;;;')结果[',', '.', '/', ';', ';', ';']
'\s'  # 匹配空白字符 re.findall('\s','3*ds \t\n')结果[' ', '\t', '\n']
'\S'  # 匹配非空白字符 re.findall('\s','3*ds \t\n')结果['3', '*', 'd', 's']
'\A'  # 匹配字符串开头
'\Z'  # 匹配字符串结尾
'\b'  # 匹配单词的词首和词尾，单词被定义为一个字母数字序列，因此词尾是用空白符或非字母数字符来表示的
'\B'  # 与\b相反，只在当前位置不在单词边界时匹配
'(?P<name>...)' # 分组，除了原有编号外在指定一个额外的别名 re.search("(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birthday>[0-9]{8})","371481199306143242").groupdict("city") 结果{'province': '3714', 'city': '81', 'birthday': '19930614'}
[]  # 是定义匹配的字符范围。比如 [a-zA-Z0-9] 表示相应位置的字符要匹配英文字符和数字。[\s*]表示空格或者*号。

re.match(pattern, string, flags=0) # 从字符串的起始位置匹配，如果起始位置匹配不成功的话，match()就返回none
re.search(pattern, string, flags=0) # 扫描整个字符串并返回第一个成功的匹配
re.findall(pattern, string, flags=0) # 找到RE匹配的所有字符串，并把他们作为一个列表返回
re.finditer(pattern, string, flags=0) # 找到RE匹配的所有字符串，并把他们作为一个迭代器返回
re.sub(pattern, repl, string, count=0, flags=0) # 替换匹配到的字符串
re.sub('(blue|white|red)','colour', 'blue socks and red shoes') # 'colour socks and colour shoes'
y = re.split(r'\W+','This is a test, short and sweet, of split().') # 通过正则表达式的匹配拆分字符串
print(y) # ['This', 'is', 'a', 'test', 'short', 'and', 'sweet', 'of', 'split', '']

10.math模块

函数	使用说明
ceil(x)	取大于等于x的最小的整数值，如果x是一个整数，则返回x
copysign(x,y)	把y的正负号加到x前面，可以使用0
fabs(x)	返回x的绝对值（float类型）
factorial(x)	取x阶乘的值
floor(x)	取小于等于x的最大整数值，如果x是一个整数，返回自身
fmod(x,y)	得到x/y的余数，返回float类型
frexp(x)	返回一个元组(m,e)，其计算方式为：x分别除以0.5和1，得到一个值的范围
fsum(iterable)	对迭代器里的每个元素进行求和操作
gcd(x,y)	返回x和y的最大公约数
isclose(a,b,*,rel_tol=1e-09,abs_tol=0.0)	如果值a和彼此接近，则返回True，否则返回False；rel_tol是相对容差-它是a和b之间允许的最大差值。abs_tol是最小绝对容差—对于接近0的比较有用
isfinite(x)	如果x既不是无穷也不是NAN,则返回True；否则返回False
isinf(x)	如果x是正无穷大或负无穷大，则返回True,否则返回False
isnan(x)	如果x不是数字，返回True
modf(x)	返回由x的小数部分和整数部分组成的元组
trunc(x)	返回x的整数部分
exp(x）	返回e**x
expm1(x)	返回e**(x-1)
log(x[,base])	返回x的自然对数，默认以e为基数；base参数给定时，将x的对数返回给定的base
log1p(x)	返回1+x的自然对数（基数e)。计算结果的方式对于接近零的x是准确的
log2(x)	返回x基数为2的对数。通常比log(x,2)更准确
log10(x)	返回x基数为10的对数。通常比log(x,10)更准确
pow(x,y)	返回x的y次方，即x**y
sqrt(x)	返回x的平方根
pi	数学常量Π=3.1415926…，可用精度
e	数学常量e=2.718281…，可用精度
tau	数学常量\tau=6.283185···,可用精度。Tau是一个等于2\pi的圆常量，即圆的周长与其半径之比

11.json模块

import json
json.dumps()    # dumps可以格式化所有的基本数据类型为字符串
dict = {"name":"Tom", "age":23}  
print(json.dumps(dict)) # '{"name": "Tom", "age": 23}'

with open("test.json", "w", encoding='utf-8') as f:
    # indent 超级好用，格式化保存字典，默认为None，小于0为零个空格
    f.write(json.dumps(a, indent=4))
    # json.dump(a,f,indent=4)   # 和上面的效果一样，dump必须是文件操作
    f.close()
json.loads('{"name":"Tom", "age":23}') # 只完成了反序列化  {'age': 23, 'name': 'Tom'}
with open("test.json", "r", encoding='utf-8') as f:
    aa = json.loads(f.read())
    f.seek(0)
    bb = json.load(f)    # 与 json.loads(f.read()) 只接收文件描述符，完成了读取文件和反序列化
print(aa) # {'name': 'Tom', 'age': 23}
print(bb) # {'name': 'Tom', 'age': 23}

+---------------------------+-------------------------------+
    | Python            | JSON          |
    +===================+===============+
    | dict              | object        |
    +-------------------+---------------+
    | list, tuple       | array         |
    +-------------------+---------------+
    | str               | string        |
    +-------------------+---------------+
    | int, float        | number        |
    +-------------------+---------------+
    | True              | true          |
    +-------------------+---------------+
    | False             | false         |
    +-------------------+---------------+
    | None              | null          |
    +-------------------+---------------+