本文详细介绍了Python中的各种模块，包括自定义模块、内置标准模块及开源模块等。涵盖了时间日期处理、随机数生成、文件系统操作等功能模块的具体用法。
基础知识
1. 定义
模块：用来从逻辑上组织python代码（变量，函数，类，逻辑----实现一个功能），本质就是.py结尾的python文件（文件名：test.py，对应的模块就是test）
包：用来从逻辑上组织模块的，本质就是一个目录（必须带有一个__init__.py文件）
2. 导入方法
module_cc文件里有很多函数&变量：
import module1_name
import module1_name，module2_name
from module_cc import * #把其他模块的东西全部导入过来执行一遍
from module_cc import m1,m2,m3
from module_alex import logger as logger_alex#若导入的模块名与当前的函数名相同，则可用as对导入的模块名重命名
3. import本质
导入模块的本质就是把python文件解释一遍；
导入包的本质就是执行该包下的__init__.py文件；
4. 模块分类
python的模块又分为以下三种：
- 自定义模块
- 内置标准模块（标准库）
- 开源模块
自定义模块
1.获取当前文件的绝对路径：
|
1
2
3
4
|
#如目前路径为d:\python\new\read.py;获取当前文件的绝对路径：
>>>
import
os
#导入os模块
>>>
dir
=
os.path.abspath(__file__)
>>>
print
(
dir
)
|
2.获取当前文件的父级目录绝对路径：
|
1
2
3
4
|
#如目前路径为d:\python\new\read.py;获取new的绝对路径：
>>>
import
os
#导入os模块
>>>
dir
=
os.path.dirname(os.path.abspath(__file__))
>>>
print
(
dir
)
|
3.当前文件的父级目录的父级目录绝对路径：
|
1
2
3
4
|
#如目前路径为d:\python\new\read.py;获取python的绝对路径：
>>>
import
os
#导入os模块
>>>
dir
=
os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
>>>
print
(
dir
)
|
4.对于模块和自己写的程序不在同一个目录下，可以把模块的路径通过sys.path.append(路径)添加到程序中。
在程序开头加上：
|
1
2
3
4
5
6
7
8
9
10
|
#如目前路径为d:\python\new\read.py;想要导入d:\python\old\read_new.py下的程序模块：
>>>
import
os,sys
>>>
dir
=
os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
#获取python目录的绝对路径
>>> sys.path.append(
dir
)
#讲python目录的路径添加到程序中
#-----想要快速找到该路径，则可使用insert将要添加的目录路径插入到path前面
# sys.path.insert(dir)
>>>
import
old
from
read_new
#导入read_new.py文件
#在当前路径下调用read_new.py里的某个函数，如user()
>>> read_new.user()
|
内置模块
1. time & datetime
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
|
import
time
import
datetime
# time模块
print
(time.clock())
# 输出=>3.110193534902903e-07
print
(time.process_time())
# 输出=>0.031200199999999997
# 返回当前时间戳,即1970.1.1至今的秒数
print
(time.time())
# 输出=>1454239454.328046
# 当前系统时间
print
(time.ctime())
# 输出=>Sun Jan 31 19:24:14 2016
# 将当前时间戳转换成字符串格式的时间
print
(time.ctime(time.time()))
# 输出=>Sun Jan 31 19:24:14 2016
# 将时间戳转换成struct_time格式
print
(time.gmtime(time.time()))
# time.struct_time(tm_year=2016, tm_mon=1, tm_mday=31, tm_hour=11, tm_min=24, tm_sec=14, tm_wday=6, tm_yday=31, tm_isdst=0)
# 将本地时间的时间戳转换成struct_time格式
print
(time.localtime(time.time()))
# time.struct_time(tm_year=2016, tm_mon=1, tm_mday=31, tm_hour=19, tm_min=24, tm_sec=14, tm_wday=6, tm_yday=31, tm_isdst=0)
# 与上面的相反,将struct_time格式转回成时间戳格式。
print
(time.mktime(time.localtime()))
# 输出=>1454239454.0
# sleep
# time.sleep(4)
# 将struct_time格式转成指定的字符串格式
print
(time.strftime(
"%Y-%m-%d %H:%M:%S"
, time.localtime(time.time())))
# 输出=>2016-02-01 13:53:22
# 将字符串格式转成struct_time格式
print
(time.strptime(
"2016-02-01"
,
"%Y-%m-%d"
))
# time.struct_time(tm_year=2016, tm_mon=2, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=0, tm_yday=32, tm_isdst=-1)
# datetime 模块
print
(datetime.date.today())
# 输出=>2016-02-01
print
(datetime.date.fromtimestamp(time.time()
-
86640
))
# 输出=>2016-01-31
current_time
=
datetime.datetime.now()
print
(current_time)
# 输出=>2016-02-01 14:01:02.428880
# 返回struct_time格式的时间
print
(current_time.timetuple())
# time.struct_time(tm_year=2016, tm_mon=2, tm_mday=1, tm_hour=14, tm_min=1, tm_sec=41, tm_wday=0, tm_yday=32, tm_isdst=-1)
# 指定替换
# datetime.replace([year[, month[, day[, hour[, minute[, second[, microsecond[, tzinfo]]]]]]]])
print
(current_time.replace(
2008
,
8
,
8
))
# 输出=>2008-08-08 14:03:53.901093
# 将字符串转换成日期格式
str_to_date
=
datetime.datetime.strptime(
"2016-02-01"
,
"%Y-%m-%d"
)
print
(str_to_date)
# 输出=>2016-02-01 00:00:00
# 比现在+10d
new_date
=
datetime.datetime.now()
+
datetime.timedelta(days
=
10
)
print
(new_date)
# 输出=>2016-02-11 14:46:49.158138
# 比现在-10d
new_date
=
datetime.datetime.now()
-
datetime.timedelta(days
=
10
)
print
(new_date)
# 输出=>2016-01-22 14:53:03.712109
# 比现在+10h
new_date
=
datetime.datetime.now()
+
datetime.timedelta(hours
=
10
)
print
(new_date)
# 输出=>2016-02-02 00:53:03.712109
# 比现在+120s
new_date
=
datetime.datetime.now()
+
datetime.timedelta(seconds
=
120
)
print
(new_date)
# 输出=>2016-02-01 14:55:03.712109
|
2. random
Python中的random模块用于生成随机数.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
import
random
#导入random模块
print
(random.random())
#生成一个0到1的随机浮点数 0<=n<1<br>
print
(random.randint(
1
,
7
))
#random.randint()的函数原型为：random.randint(a, b)，用于生成一个指定范围内的整数。
# 其中参数a是下限，参数b是上限，生成的随机数n的范围: a <= n <= b<br>
print
(random.randrange(
1
,
10
,
2
))
#random.randrange的函数原型为：random.randrange([start], stop[, step])，
# 从指定范围内，按指定基数递增的集合中 获取一个随机数。如：random.randrange(1,10,2)，
# 结果相当于从[1, 3, 5, 7, 9]序列中获取一个随机数。<br>
print
(random.choice(
'liukuni'
))
#i
#random.choice从序列中获取一个随机元素。
# 其函数原型为：random.choice(sequence)。参数sequence表示一个有序类型。
# 这里要说明一下：sequence在python不是一种特定的类型，而是泛指一系列的类型。
# list, tuple, 字符串都属于sequence。有关sequence可以查看python手册数据模型这一章。
# 下面是使用choice的一些例子：
print
(random.choice(
"学习Python"
))
#学
print
(random.choice([
"JGood"
,
"is"
,
"a"
,
"handsome"
,
"boy"
]))
#List
print
(random.choice((
"Tuple"
,
"List"
,
"Dict"
)))
#List
print
(random.sample([
1
,
2
,
3
,
4
,
5
],
3
))
#[1, 2, 5]
#random.sample的函数原型为：random.sample(sequence, k)，从指定序列中随机获取指定长度的片断。sample函数不会修改原有序列。
|
|
1
2
3
4
5
6
7
8
9
10
11
|
# 生成4位随机验证码
check_code
=
""
for
i
in
range
(
4
):
current
=
random.randrange(
0
,
4
)
if
current !
=
i:
temp
=
chr
(random.randint(
97
,
122
))
else
:
temp
=
random.randint(
0
,
9
)
check_code
=
"{}{}"
.
format
(check_code, temp)
print
(check_code)
# 输出=>oovf
|
3. os
Python os模块包含普遍的操作系统功能。如果你希望你的程序能够与平台无关的话，这个模块是尤为重要的。
常用方法：
1. os.name #输出字符串指示正在使用的平台。如果是window 则用'nt'表示，对于Linux/Unix用户，它是'posix'。
|
1
2
3
4
|
import
os
print
(os.name)
-
-
-
-
-
-
打印输出
-
-
-
-
-
-
nt
|
2. os.getcwd() #函数得到当前工作目录，即当前Python脚本工作的目录路径。
|
1
2
3
4
|
import
os
print
(os.getcwd())
-
-
-
-
-
-
打印输出
-
-
-
-
-
-
E:\python\old
|
3. os.listdir() #列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印。
|
1
2
3
4
5
|
import
os
print
(os.listdir())
-
-
-
-
-
-
打印输出
-
-
-
-
-
-
-
[
'dd.json'
,
'eg.txt'
,
'read.py'
,
'__init__.py'
,
'__pycache__'
]
|
4. os.chdir("dirname") #更改当前文件脚本目录，相当于shell下的cd
|
1
2
3
4
5
6
7
|
print
(os.getcwd())
os.chdir(r
'E:\python\new'
)
print
(os.getcwd())
-
-
-
-
打印输出
-
-
-
-
-
E:\python\old
E:\python\new
|
5. os.curdir #返回当前目录（.）
6. os.pardir #返回当前目录的父级目录（..）
7. os.makedirs('dirname1\dirname2') #可生成多层递归目录
|
1
2
3
4
|
import
os
os.makedirs(r
"E:\A\B\C"
)
#可看到E盘下生成了A文件夹，A文件夹里有B文件夹，B文件夹下有C文件夹
|
8. os.removedirs('dirnames') #若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
|
1
2
3
4
|
import
os
os.removedirs(r
"E:\A\B\C"
)
#可看到E盘下的A文件夹都被删除了
|
9. os.mkdir('dirname') #生成单级目录；相当于shell中mkdir dirname
|
1
2
|
import
os
os.mkdir(r
"E:\A"
)
|
10. os.rmdir('dirname') #删除单级空目录，若目录不为空则报错
11. os.remove("filename") #删除一个文件
|
1
2
|
import
os
os.remove(r
"E:\A\1.txt"
)
|
12. os.rename("oldname","newname") #重命名文件/目录
|
1
2
|
import
os
os.rename(r
"E:\A"
,r
"E:\B"
)
|
13. os.stat('path/filename') #获取指定文件/目录信息
|
1
2
3
4
5
|
import
os
print
(os.stat(
"E:\B"
))
-
-
-
-
-
-
打印输出
-
-
-
-
-
-
-
os.stat_result(st_mode
=
16895
, st_ino
=
62205969853149254
, st_dev
=
1526633361
, st_nlink
=
1
, st_uid
=
0
, st_gid
=
0
, st_size
=
0
, st_atime
=
1471857944
, st_mtime
=
1471857944
, st_ctime
=
1471857604
)
|
14. os.sep #输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
15. os.pathsep #输出用于分割文件路径的字符串
16. os.system("bash command") 运行shell命令，直接显示
|
1
2
|
import
os
os.system(
'ipconfig'
)
|
17. os.environ #获取系统环境变量
18. os.path.abspath(path) #返回path规范化的绝对路径
|
1
2
3
4
5
|
import
os
print
(os.path.abspath(
'python'
))
-
-
-
-
-
-
打印输出
-
-
-
-
-
-
-
-
E:\python\old\python
|
19. os.path.split(path) #将path分割成目录和文件二元组返回
|
1
2
3
4
5
|
import
os
print
(os.path.split(r
'E:\python\old\eg.txt'
))
-
-
-
-
-
打印输出
-
-
-
-
-
(
'E:\\python\\old'
,
'eg.txt'
)
|
20. os.path.basename(path) #返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
|
1
2
3
4
5
|
import
os
print
(os.path.basename(r
'E:\python\old\eg.txt'
))
-
-
-
-
-
-
打印输出
-
-
-
-
-
eg.txt
|
21. os.path.exists(path) #如果path存在，返回True；如果path不存在，返回False
22. os.path.isabs(path) #如果path是绝对路径则返回True
23. os.path.isfile(path) #如果path是一个存在的文件，返回True。否则返回False
24. os.path.isdir(path) #如果path是一个存在的目录，则返回True。否则返回False
25. os.path.join(path1[, path2[, ...]]) #将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
|
1
2
|
import
os
print
(os.path.join(r
'E:\python\new'
,r
'eg.txt'
))
|
26. os.path.getatime(path) #返回path所指向的文件或者目录的最后存取时间
|
1
2
3
4
5
6
7
|
import
os,time
time1
=
os.path.getatime(r
'E:\python\new'
)
x
=
time.localtime(time1)
print
(time.strftime(
'%Y-%m-%d %H:%M:%S'
,x))
-
-
-
-
-
打印时间
-
-
-
-
-
2016
-
08
-
17
19
:
09
:
32
|
27. os.path.getmtime(path) #返回path所指向的文件或者目录的最后修改时间
|
1
2
3
4
|
import
os,time
time1
=
os.path.getmtime(r
'E:\B'
)
x
=
time.localtime(time1)
print
(time.strftime(
'%Y-%m-%d %H:%M:%S'
,x))
|
4. sys
sys模块包括了一组非常实用的服务，内含很多函数方法和变量，用来处理Python运行时配置以及资源，从而可以与前当程序之外的系统环境交互
1. 导入模块
|
1
|
import
sys
|
2.重要函数变量
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
print
(sys.argv)
#命令行参数List，第一个元素是程序本身路径
# -----打印输出------
# ['E:/python/old/read.py']
sys.exit(status)
#退出程序，正常退出时exit(0)
print
(sys.version)
#获取Python解释程序的版本信息
#----打印输出-----
# 3.5.2 (v3.5.2:4def2a2901a5, Jun 25 2016, 22:01:18) [MSC v.1900 32 bit (Intel)]
sys.path
#返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
print
(sys.platform)
#返回操作系统平台名称
sys.stdin()
#标准输入流
sys.stdout
#标准输出流。
sys.stderr
#标准错误流。
|
5. shutil
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
|
#! /usr/bin/env python
# -*- coding: utf-8 -*-
# __author__ = "Q1mi"
"""
高级的 文件、文件夹、压缩包 处理模块
"""
import
shutil
import
os
# 将文件内容(文件对象)拷贝到另一个文件中，可以指定部分拷贝
# with open("D:\qimi_WorkSpace\S12\day6\\test1.txt", "rt") as f1, open("D:\qimi_WorkSpace\S12\day6\\test2.txt", "at")as f2:
# shutil.copyfileobj(fsrc=f1, fdst=f2)
# 拷贝文件
# shutil.copyfile(src="D:\qimi_WorkSpace\S12\day6\\test1.txt",dst="D:\qimi_WorkSpace\S12\day6\\test2.txt")
# 仅拷贝权限。内容、组、用户均不变
# print(os.stat("D:\qimi_WorkSpace\S12\day6\\test2.txt"))
# shutil.copymode(src="D:\qimi_WorkSpace\S12\day6\\test1.txt", dst="D:\qimi_WorkSpace\S12\day6\\test2.txt")
# print(os.stat("D:\qimi_WorkSpace\S12\day6\\test2.txt"))
# # 拷贝状态的信息，包括：mode bits, atime, mtime, flags
# shutil.copystat(src=,dst=)
#
# # 拷贝文件和权限
# shutil.copy(src, dst)
# 拷贝文件和状态信息
# shutil.copy2(src,dst)
# 递归的去拷贝文件
# shutil.ignore_patterns(*patterns)
# shutil.copytree(src, dst, symlinks=False, ignore=None)
# 递归的去删除文件
# shutil.rmtree(path[, ignore_errors[, onerror]])
# 递归的去移动文件
# shutil.move(src, dst)
# 创建压缩包并返回文件路径，例如：zip、tar
# shutil.make_archive(base_name, format,...)
#
# base_name： 压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径，
# 如：www =>保存至当前路径
# 如：/Users/wupeiqi/www =>保存至/Users/wupeiqi/
# format： 压缩包种类，“zip”, “tar”, “bztar”，“gztar”
# root_dir： 要压缩的文件夹路径（默认当前目录）
# owner： 用户，默认当前用户
# group： 组，默认当前组
# logger： 用于记录日志，通常是logging.Logger对象
# 将D:\qimi_WorkSpace\S12\day6目录下的文件打包成test.tar.gz，放置在当前目录
et
=
shutil.make_archive(
"test"
,
'gztar'
, root_dir
=
'D:\\qimi_WorkSpace\\S12\\day6'
)
# shutil模块对压缩包的处理是调用ZipFile和TarFile两个模块来进行的
# zipfile模块
import
zipfile
# 压缩
z
=
zipfile.ZipFile(
'test.zip'
,
'w'
)
z.write(
'a.log'
)
z.write(
'a.data'
)
z.close()
# 解压
z
=
zipfile.ZipFile(
'test.zip'
,
'r'
)
z.extractall()
z.close()
# tarfile模块
import
tarfile
# 压缩
tar
=
tarfile.
open
(
'test.tar'
,
'w'
)
tar.add(
'D:\\qimi_WorkSpace\\S12\\day6\\test1.tar'
, arcname
=
'test1.tar'
)
tar.add(
'D:\\qimi_WorkSpace\\S12\\day6\\test2.tar'
, arcname
=
'test2.tar'
)
tar.close()
# 解压
tar
=
tarfile.
open
(
'test.tar'
,
'r'
)
tar.extractall()
# 可设置解压地址
tar.close()
|
6. json & picle
见上篇文章，这里不再概述
7. shelve
shelve模块是一个简单的k,v将内存数据通过文件持久化的模块，可以持久化任何pickle可支持的python数据格式
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
import
shelve
d
=
shelve.
open
(
'shelve_test'
)
#打开一个文件
class
Test(
object
):
def
__init__(
self
,n):
self
.n
=
n
t
=
Test(
123
)
t2
=
Test(
123334
)
name
=
[
"alex"
,
"rain"
,
"test"
]
d[
"test"
]
=
name
#持久化列表
d[
"t1"
]
=
t
#持久化类
d[
"t2"
]
=
t2
d.close()
|
8. xml处理
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
#! /usr/bin/env python
# -*- coding: utf-8 -*-
# __author__ = "Q1mi"
"""
xml模块的练习
"""
import
xml.etree.ElementTree as ET
# 解析xml文件
tree
=
ET.parse(
"test.xml"
)
# 获取根
root
=
tree.getroot()
print
(root.tag)
# 遍历xml文档
for
child
in
root:
print
(child.tag, child.attrib)
for
i
in
child:
print
(i.tag, i.text)
# 只遍历year节点
for
i
in
root.
iter
(
"year"
):
print
(i.tag, i.text)
# 修改和删除xml文件
tree
=
ET.parse(
"test2.xml"
)
root
=
tree.getroot()
|
9. yaml处理
略。。。
10. configparser
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
|
#! /usr/bin/env python
# -*- coding: utf-8 -*-
# __author__ = "Q1mi"
"""
configparser 练习
"""
import
configparser
# 写一个配置文件
config
=
configparser.ConfigParser()
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)
# 读配置文件
config
=
configparser.ConfigParser()
print
(config.sections())
a
=
config.read(
"test.cfg"
)
print
(a)
print
(config.sections())
print
(
"bitbucket.org"
in
config.sections())
print
(config[
"bitbucket.org"
][
"user"
])
for
key
in
config[
"bitbucket.org"
]:
print
(key, config[
"bitbucket.org"
][key])
# 增删改查
config
=
configparser.ConfigParser()
config.read(
"test.cfg"
)
sec
=
config.sections()
print
(sec)
options
=
config.options(
"bitbucket.org"
)
print
(options)
item_list
=
config.items(
"bitbucket.org"
)
print
(item_list)
val
=
config.get(
"bitbucket.org"
,
"compressionlevel"
)
print
(val)
val
=
config.getint(
"bitbucket.org"
,
"compressionlevel"
)
print
(val)
# 改写
config.remove_section(
"bitbucket.org"
)
config.write(
open
(
"test2.cfg"
,
"w"
))
sec
=
config.has_section(
"bitbuckrt.org"
)
print
(sec)
config.add_section(
"bitbucket.org"
)
sec
=
config.has_section(
"bitbuckrt.org"
)
print
(sec)
config.write(
open
(
"test2.cfg"
,
"w"
))
config.
set
(
"bitbucket.org"
,
'k1'
,
"11111"
)
config.write(
open
(
"test2.cfg"
,
"w"
))
config.remove_option(
"topsecret.server.com"
,
"port"
)
config.write(
open
(
"test2.cfg"
,
"w"
))
|
11. hashlib
用于加密相关的操作，3.x里代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
|
import
hashlib
m
=
hashlib.md5()
m.update(b
"Hello"
)
m.update(b
"It's me"
)
print
(m.digest())
m.update(b
"It's been a long time since last time we ..."
)
print
(m.digest())
#2进制格式hash
print
(
len
(m.hexdigest()))
#16进制格式hash
'''
def digest(self, *args, **kwargs): # real signature unknown
""" Return the digest value as a string of binary data. """
pass
def hexdigest(self, *args, **kwargs): # real signature unknown
""" Return the digest value as a string of hexadecimal digits. """
pass
'''
import
hashlib
# ######## md5 ########
hash
=
hashlib.md5()
hash
.update(
'admin'
)
print
(
hash
.hexdigest())
# ######## sha1 ########
hash
=
hashlib.sha1()
hash
.update(
'admin'
)
print
(
hash
.hexdigest())
# ######## sha256 ########
hash
=
hashlib.sha256()
hash
.update(
'admin'
)
print
(
hash
.hexdigest())
# ######## sha384 ########
hash
=
hashlib.sha384()
hash
.update(
'admin'
)
print
(
hash
.hexdigest())
# ######## sha512 ########
hash
=
hashlib.sha512()
hash
.update(
'admin'
)
print
(
hash
.hexdigest())
|
12. re正则表达式
开源模块
暂略
扫一扫
5038
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
