Python模块学习--shutil和hashlib和json

不念不忘少年蓝@ 2022-06-05 23:46 244阅读 0赞

shutil模块用于执行高级的文件操作，如复制，移动重命名等。  
  
>>> shutil.  
shutil.Error             shutil.\_samefile  
shutil.\_\_all\_\_           shutil.abspath  
shutil.\_\_class\_\_         shutil.copy  
shutil.\_\_delattr\_\_       shutil.copy2  
shutil.\_\_dict\_\_          shutil.copyfile  
shutil.\_\_doc\_\_           shutil.copyfileobj  
shutil.\_\_file\_\_          shutil.copymode  
shutil.\_\_getattribute\_\_  shutil.copystat  
shutil.\_\_hash\_\_          shutil.copytree  
shutil.\_\_init\_\_          shutil.destinsrc  
shutil.\_\_name\_\_          shutil.exceptions  
shutil.\_\_new\_\_           shutil.move  
shutil.\_\_reduce\_\_        shutil.os  
shutil.\_\_reduce\_ex\_\_     shutil.rmtree  
shutil.\_\_repr\_\_          shutil.stat  
shutil.\_\_setattr\_\_       shutil.sys  
shutil.\_\_str\_\_  
  
copy(src, dst)：复制文件  
  
>>> shutil.copy('/root/zhu.txt','/root/tao.txt')  
  
>>> shutil.copy('/root/zhu.txt','/root/zhuzhu')  
  
copy(src, dst) ：\#对文件进行复制，src必须是文件，而dst可以是目录。  
  
copy2(src, dst)：连同权限一起复制，相当于cp -p src dst  
  
>>> shutil.copy2('/root/zhu.txt','/root/zhuzhu')  
  
copyfile(src, dst):dst只能是文件，  
  
>>> shutil.copyfile('/root/zhu.txt','/root/zhuzhu')  
  
Traceback (most recent call last):  
  File "<stdin>", line 1, in ?  
  File "/usr/lib/python2.4/shutil.py", line 48, in copyfile  
    fdst = open(dst, 'wb')  
IOError: \[Errno 21\] Is a directory: '/root/zhuzhu'  
  
move(src, dst) ：移动     
  
>>>  shutil.move('/root/zhu.txt','/root/zhuzhu')  
  
>>> help(shutil.move)  
>>> help(shutil.move)  
  
>>>  shutil.move('/root/1.txt','/root/zhuzhu/gg.txt')  
  
rmtree（path):删除整个目录  
  
>>> shutil.rmtree('/root/zhuzhu')  
  
  
shutil.copyfileobj(fsrc, fdst\[, length\])      将文件内容拷贝到另一个文件中  
  
>>> import shutil  
\# 循环读取old.txt文件内容并写入到new.txt文件当中  
  
>>>  shutil.copyfileobj(open('old.txt','r'), open('new.txt', 'w'))  
  
>>> import os  
  
\# 查看复制过去的文件内容  
  
>>>  os.system("cat old.txt new.txt")   
old  
old  
0  
shutil.copyfile(src, dst, \*, follow\_symlinks=True)    拷贝整个文件，没有第二个文件就创建，有就覆盖  
  
>>> os.system("cat old.txt new.txt")  
old  
new  
0  
>> > shutil.copyfile('old.txt', 'new.txt')     \# 把第二个文件内容给覆盖了  
  
>>> os.system("cat old.txt new.txt")       
old  
old  
0  
shutil.copymode(src, dst, \*, follow\_symlinks=True)   仅拷贝文件权限，文件的内容、组、用户均不变  
  
>>>  os.system("ls -l old.txt new.txt")      
  
\-rw-rw-rw- 1 ansheng ansheng 4 5月  26 15:54 new.txt  
\-rw-rw-r-- 1 ansheng ansheng 4 5月  26 15:52 old.txt  
0  
>>>  shutil.copymode('old.txt', 'new.txt')  
  
\# 文件权限都变成644了  
  
>>>  os.system("ls -l old.txt new.txt")     
  
\-rw-rw-r-- 1 ansheng ansheng 4 5月  26 15:54 new.txt  
\-rw-rw-r-- 1 ansheng ansheng 4 5月  26 15:52 old.txt  
0  
  
shutil.copystat(src, dst, \*, follow\_symlinks=True)   拷贝文件状态的信息，文件必须存在，不copy改动时间  
  
>>> os.system("stat old.txt new.txt")    
  
  文件：'old.txt'  
  
  大小：4               块：8          IO 块：4096   普通文件  
  
设备：801h/2049d        Inode：1835014     硬链接：1  
权限：(0664/-rw-rw-r--)  Uid：( 1000/ ansheng)   Gid：( 1000/ ansheng)  
最近访问：2016-05-26 15:53:09.813612241 +0800  
最近更改：2016-05-26 15:52:54.830640166 +0800  
最近改动：2016-05-26 15:52:54.830640166 +0800  
创建时间：-  
  
  文件：'new.txt'  
  大小：4               块：8          IO 块：4096   普通文件  
设备：801h/2049d        Inode：1835024     硬链接：1  
权限：(0664/-rw-rw-r--)  Uid：( 1000/ ansheng)   Gid：( 1000/ ansheng)  
最近访问：2016-05-26 15:56:22.540041783 +0800  
最近更改：2016-05-26 15:54:24.244922722 +0800  
最近改动：2016-05-26 15:55:38.353967649 +0800  
创建时间：-  
0  
>>>  shutil.copystat('old.txt', 'new.txt')  
  
>>>  os.system("stat old.txt new.txt")      
  文件：'old.txt'  
  大小：4               块：8          IO 块：4096   普通文件  
设备：801h/2049d        Inode：1835014     硬链接：1  
权限：(0664/-rw-rw-r--)  Uid：( 1000/ ansheng)   Gid：( 1000/ ansheng)  
最近访问：2016-05-26 15:53:09.813612241 +0800  
最近更改：2016-05-26 15:52:54.830640166 +0800  
最近改动：2016-05-26 15:52:54.830640166 +0800  
创建时间：-  
  文件：'new.txt'  
  大小：4               块：8          IO 块：4096   普通文件  
设备：801h/2049d        Inode：1835024     硬链接：1  
权限：(0664/-rw-rw-r--)  Uid：( 1000/ ansheng)   Gid：( 1000/ ansheng)  
最近访问：2016-05-26 15:53:09.813612000 +0800  
最近更改：2016-05-26 15:52:54.830640000 +0800  
最近改动：2016-05-26 15:56:48.765143115 +0800  
创建时间：-  
0  
shutil.copy(src, dst, \*, follow\_symlinks=True)  拷贝文件和状态信息，同样不copy改动时间  
  
>>> os.system("stat old.txt new.txt")    
  文件：'old.txt'  
  大小：4               块：8          IO 块：4096   普通文件  
设备：801h/2049d        Inode：1835014     硬链接：1  
权限：(0664/-rw-rw-r--)  Uid：( 1000/ ansheng)   Gid：( 1000/ ansheng)  
最近访问：2016-05-26 15:53:09.813612241 +0800  
最近更改：2016-05-26 15:52:54.830640166 +0800  
最近改动：2016-05-26 15:52:54.830640166 +0800  
创建时间：-  
  文件：'new.txt'  
  大小：0               块：0          IO 块：4096   普通空文件  
设备：801h/2049d        Inode：1835023     硬链接：1  
权限：(0664/-rw-rw-r--)  Uid：( 1000/ ansheng)   Gid：( 1000/ ansheng)  
最近访问：2016-05-26 15:57:53.448632439 +0800  
最近更改：2016-05-26 15:57:53.448632439 +0800  
最近改动：2016-05-26 15:57:53.448632439 +0800  
创建时间：-  
0  
>>>  shutil.copy2('old.txt', 'new.txt')  
  
>>>  os.system("stat old.txt new.txt")    
  
  文件：'old.txt'  
  大小：4               块：8          IO 块：4096   普通文件  
设备：801h/2049d        Inode：1835014     硬链接：1  
权限：(0664/-rw-rw-r--)  Uid：( 1000/ ansheng)   Gid：( 1000/ ansheng)  
最近访问：2016-05-26 15:53:09.813612241 +0800  
最近更改：2016-05-26 15:52:54.830640166 +0800  
最近改动：2016-05-26 15:52:54.830640166 +0800  
创建时间：-  
  文件：'new.txt'  
  大小：4               块：8          IO 块：4096   普通文件  
设备：801h/2049d        Inode：1835023     硬链接：1  
权限：(0664/-rw-rw-r--)  Uid：( 1000/ ansheng)   Gid：( 1000/ ansheng)  
最近访问：2016-05-26 15:53:09.813612000 +0800  
最近更改：2016-05-26 15:52:54.830640000 +0800  
最近改动：2016-05-26 15:58:07.938760974 +0800  
创建时间：-  
0  
shutil.ignore\_patterns(\*patterns)  
  
This factory function creates a function that can be used as a callable for copytree()‘s ignore argument, ignoring files and directories that match one of the glob-style patterns provided. See the example below.  
  
shutil.copytree(src, dst, symlinks=False, ignore=None, copy\_function=copy2, ignore\_dangling\_symlinks=False)  
  
递归的去拷贝文件夹  
  
>>  os.system("tree folder1")  
folder1  
├── dir  
├── file.txt  
├── sc.pyc  
├── tmp  
└── vgauthsvclog.txt.0 -> /tmp/vgauthsvclog.txt.0  
2 directories, 3 files  
0  
\# folder2目录必须不存在，symlinks=True只copy链接文件，如果等于False就copy源文件，ignore等于不copy的文件或者目录  
  
>>>  shutil.copytree ('folder1', 'folder2', symlinks=False, ignore=shutil.ignore\_patterns('\*.pyc', 'tmp\*'))     
  
>>> os.system( "tree folder2" )  
  
folder2  
├── dir  
├── file.txt  
└── vgauthsvclog.txt.0  
1 directory, 2 files  
0  
  
shutil.rmtree(path, ignore\_errors=False, οnerrοr=None)   递归的去删除文件  
  
>>> os.system("ls -d folder2")  
folder2  
0  
>>> shutil.rmtree('folder2')  
  
>>> os.system("ls -d folder2")  
  
ls: 无法访问'folder2': 没有那个文件或目录  
512  
  
shutil.move(src, dst, copy\_function=copy2)   递归的去移动文件，它类似mv命令，其实就是重命名。  
  
>>> os.system("ls -ld folder1")  
drwxrwxr-x 4 ansheng ansheng 4096 5月  26 16:09 folder1  
0  
>>>  shutil.move('folder1', 'folder3')  
  
>>> os.system("ls -ld folder1")        
ls: 无法访问'folder1': 没有那个文件或目录  
512  
>>> os.system("ls -ld folder3")  
drwxrwxr-x 4 ansheng ansheng 4096 5月  26 16:09 folder3  
0  
shutil.make\_archive(base\_name, format\[, root\_dir\[, base\_dir\[, verbose\[, dry\_run\[, owner\[, group\[, logger\]\]\]\]\]\]\])  
  
  
Create an archive file (such as zip or tar) and return its name.  
  
>>> os.system("ls -dl folder3")  
drwxrwxr-x 4 ansheng ansheng 4096 5月  26 16:21 folder3  
0  
\# /home/ansheng/folder3是保存的文件，gztar是后缀名，/home/ansheng/folder3是要打包的路径  
>>> shutil.make\_archive("/home/ansheng/folder3", 'gztar', root\_dir='/home/ansheng/folder3')  
\# 返回文件打包放在那儿了  
'/home/ansheng/folder3.tar.gz'  
>>> os.system("ls -dl /home/ansheng/folder3.tar.gz")  
\-rw-rw-r-- 1 ansheng ansheng 263 5月  26 16:22 /home/ansheng/folder3.tar.gz  
0  
可选参数如下：  
  
  
参数  说明  
base\_name  压缩包的文件名，也可以是压缩包的路径。  
format  压缩包种类，“zip”, “tar”, “bztar”，“gztar”  
root\_dir  要压缩的文件夹路径（默认当前目录）  
owner  用户，默认当前用户  
group  组，默认当前组  
  
shutil对压缩包的处理是调用ZipFile和TarFile两个模块来进行的，后面会介绍这两个模块的使用方法 。  
  
  
得到当前工作目录路径：os.getcwd()  
获取指定目录下的所有文件和目录名：os.listdir(dir)  
删除文件：os.remove(file)  
删除多个目录：os.removedirs(r"/home")  
检测路径是否为文件：os.path.isfile(path)  
检测路径是否为目录：os.path.isdir(path)  
判断是否为绝对路径：os.path.isabs(path)  
检测路径是否存在：os.path.exists(path)  
返回一个路径的目录名和文件名：os.path.split(path)  
分离扩展名：os.path.splitext(file)  
获取路径名：os.path.dirname(file)  
获取文件名：os.path.basename(file)  
运行shell命令：os.system(command)  
读取和设置环境变量：os.getenv()与os.putenv()  
给出当前平台的行终止符：os.linesep （windows为\\r\\n linux为\\n Mac为\\r）  
指示你正在使用的平台：os.name（windows为nt,linux为posix）  
重命名：os.rename(old,new)  
创建多级目录：os.makedirs(r"c:\\python\\test")  
创建单个目录：os.mkdir("test")  
获取文件属性：os.stat(file)  
修改文件权限与时间戳：os.chmod(file)  
终止当前进程：os.exit()  
获取文件大小：os.path.getsize(filename)  
  
  
文件操作：  
文件内容替换  
for line in fileinput.input("filepath",inplace=1):  
line = line.replace("oldtext","newtext")  
print line  
  
  
os.mknod("text.txt")创建空文件  
fp = open("text.txt",'w') 直接打开一个文件，如果不存在则创建文件  
关于open模式：  
w 以写的方式打开（如果文件存在会清空文件内容）  
a 以追加的模式打开（从EOF开始，必要时创建新文件）  
r+ 以读写模式打开  
w+ 以读写模式打开（参见w）  
a+ 以读写模式打开（参见a）  
rb 以二进制模式打开  
wb 以二进制模式打开（参见w）  
ab 以二进制追加模式打开（参见a）  
rb+ 以二进制读写模式打开（参见r+）  
wb+ 以二进制读写模式打开（参见w+）  
ab+ 以二进制读写模式打开（参见a+）  
  
  
fp.read(\[size\]) \#size读取长度，以byte为单位  
fp.readline(\[size\]) \#读一行，如果定义了size有可能返回的只是一行的一部分  
fp.readlines(\[size\]) \#把文件每一行作为一个list的一个成员，并返回这个list其实它的内容是通过循环调用readline()实现的，如果提供size参数，size表示读取内容的总长，也就是说可能只读到文件的一部分  
fp.write(str) \#把str写到文件中，write()并不会在str后加上一个换行符  
fp.writelines(seq) \#把seq的内容全部写到文件中（多行一次性写入），不会加任何东西  
fp.close() \#关闭文件。python会在一个文件不用后自动关闭，不过这一功能没有保证  
fp.flush() \#把缓冲区的内容写入磁盘  
fp.fileno() \#返回一个长整形的文件标签  
fp.isatty() \#文件是否是一个终端设备文件  
fp.tell() \#返回文件操作标记的当前位置，以文件的开头为原点  
fp.next() \#返回下一行，并将文件操作标记位移到下一行  
fp.seek(offset\[,whence\]) \#将文件操作标记位移到offset的位置，这个offset一般是相对于文件的开头来计算的，一般为正数，但如果提供了whence参数就不一定了，whence可以为0表示从头开始计算，1表示以当前位置为原点计算，2表示以文件末尾为原点计算。需要注意，如果文件以a或者a+模式打开，每次进行写操作时，文件操作标记会自动返回到文件末尾  
fp.truncate(\[size\]) \#把文件裁成规定大小，默认的是裁到当前文操作标记的位置  
  
  
目录操作：  
os.mkdir("file") \#创建目录  
shutil.copyfile("oldfile","newfile") \#oldfile和newfile只能是文件  
shutil.copy（"oldfile","newfile"）\#oldfile只能是文件夹，newfile可以是文件或者目标目录  
shutil.copytree("olddir","newdir") \#复制文件夹，newdir必须不存在  
os.rename("oldname","newname") \#重命名文件或目录  
shutil.move("oldpos","newpos") \#移动文件或目录  
os.remove("file") \#删除文件  
os.rmdir("dir") \#只能删除空目录  
shutil.retree("dir") \#有内容或空目录都可以删  
os.chdir("path") \#换路径  
  
  
shutil.copyfileobj(fsrc, fdst\[, length\])    将文件内容拷贝到另一个文件中  
  
  
import shutil  
   
shutil.copyfileobj(open('old.xml','r'), open('new.xml', 'w'))  
  
  
shutil.copyfile(src, dst)  
拷贝文件  
  
  
shutil.copyfile('f1.log', 'f2.log')  
  
  
shutil.copymode(src, dst)    仅拷贝权限。内容、组、用户均不变  
  
  
shutil.copymode('f1.log', 'f2.log')  
  
  
shutil.copystat(src, dst)  仅拷贝状态的信息，包括：mode bits, atime, mtime, flags  
  
  
shutil.copystat('f1.log', 'f2.log')  
  
  
shutil.copy(src, dst)  拷贝文件和权限  
  
  
shutil.copy('f1.log', 'f2.log')  
  
  
shutil.copy2(src, dst)  拷贝文件和状态信息  
  
  
shutil.copy2('f1.log', 'f2.log')  
  
  
shutil.ignore\_patterns(\*patterns)  
shutil.copytree(src, dst, symlinks=False, ignore=None)  递归的去拷贝文件夹  
  
  
shutil.copytree('folder1', 'folder2', ignore=shutil.ignore\_patterns('\*.pyc', 'tmp\*'))  
   
shutil.copytree('f1', 'f2', symlinks=True, ignore=shutil.ignore\_patterns('\*.pyc', 'tmp\*'))  
  
  
shutil.rmtree(path\[, ignore\_errors\[, onerror\]\])   递归的去删除文件  
  
  
shutil.rmtree('folder1')  
  
  
shutil.move(src, dst)   递归的去移动文件，它类似mv命令，其实就是重命名。  
  
  
shutil.move('folder1', 'folder3')  
  
  
shutil.make\_archive(base\_name, format,...)   创建压缩包并返回文件路径，例如：zip、tar  
  
·base\_name： 压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径，如：www      =>保存至当前路径 如：/Users/xxx/www =>保存至/Users/xxx/  
·format：  压缩包种类，“zip”, “tar”, “bztar”，“gztar”  
·root\_dir：  要压缩的文件夹路径（默认当前目录）  
·owner：  用户，默认当前用户  
·group：  组，默认当前组  
·logger：  用于记录日志，通常是logging.Logger对象  
  
  
\#将 /Users/wupeiqi/Downloads/test 下的文件打包放置当前程序目录  
import shutil  
   
ret = shutil.make\_archive("wwwwww", 'gztar', root\_dir='/Users/xx/Down/test')  
   
   
\#将 /Users/wupeiqi/Downloads/test 下的文件打包放置 /Users/xx/目录  
import shutil  
ret = shutil.make\_archive("/Users/xx/wwwwww", 'gztar', root\_dir='/Users/xx/Down/test')  
  
  
shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的，详细 ：  
  
  
zipfile解压缩  
  
  
import zipfile  
   
\# 压缩  
z =  zipfile.ZipFile('laxi.zip', 'w')  
z.write('a.log')  
z.write('data.data')  
z.close()  
   
   
\# 解压  
z = zipfile.ZipFile('laxi.zip', 'r')  
z.extractall()  
z.close()  
  
tarfile解压缩  
  
import tarfile  
   
\# 压缩  
tar = tarfile.open('your.tar','w')  
tar.add('/Users/wupeiqi/PycharmProjects/bbs2.log', arcname='bbs2.log')  
tar.add('/Users/wupeiqi/PycharmProjects/cmdb.log', arcname='cmdb.log')  
tar.close()  
   
\# 解压  
tar = tarfile.open('your.tar','r')  
tar.extractall()  \# 可设置解压地址  
tar.close()

hashlib  用于加密相关的操作，代替了md5模块和sha模块，主要提供SHA1，SHA224，SHA256，SHA384，SHA512,MD5算法。  
  
在python3中已经废弃了md5和sha模块，简单说明下md5和sha的使用。  
  
　　什么是摘要算法呢？  
  
　　摘要算法又称为哈希算法，散列算法。它通过一个函数，把任意长度的数据转换为一个长度固顶的数据串（通常用16进制的字符串表示）用于加密相关的操作。  
  
  
1. md5加密  
  
1 hash = hashlib.md5()  
2 hash.update('admin'.encode('utf-8'))  
3  print(hash.hexdigest())  
4 21232f297a57a5a743894a0e4a801fc3  
  
2. sha1加密  
  
1 hash = hashlib.sha1()  
2 hash.update('admin'.encode('utf-8'))  
3  print(hash.hexdigest())  
4 d033e22ae348aeb5660fc2140aec35850c4da997  
  
3. sha256加密  
  
1 hash = hashlib.sha256()  
2 hash.update('admin'.encode('utf-8'))  
3  print(hash.hexdigest())  
4 8c6976e5b5410415bde908bd4dee15dfb167a9c873fc4bb8a81f6f2ab448a918  
  
4. sha384加密  
  
1 hash = hashlib.sha384()  
2 hash.update('admin'.encode('utf-8'))  
3  print(hash.hexdigest())  
4 9ca694a90285c034432c9550421b7b9dbd5c0f4b6673f05f6dbce58052ba20e4248041956ee8c9a2ec9f10290cdc0782  
  
5. sha512加密  
  
1 hash = hashlib.sha512()  
2 hash.update('admin'.encode('utf-8'))  
3  print(hash.hexdigest())  
4 c7ad44cbad762a5da0a452f9e854fdc1e0e7a52a38015f23f3eab1d80b931dd472634dfac71cd34ebc35d16ab7fb8a90c81f975113d6c7538dc69dd8de9077ec  
  
6. ‘加盐’加密  
  
以上加密算法虽然很厉害，但仍然存在缺陷，通过撞库可以反解。所以必要对加密算法中添加自定义key再来做加密。  
  
  
1 \#\#\#\#\#\#  md5 加密 \#\#\#\#\#\#\#\#\#\#\#\#  
2 hash = hashlib.md5('python'.encode('utf-8'))  
3 hash.update('admin'.encode('utf-8'))  
4 print(hash.hexdigest())  
5 75b431c498b55557591f834af7856b9f  
  
为防止别人对我们的md5值进行撞库，我们可以给md5加个盐  
  
>>> import hashlib  
\# hashlib.md5括号内填写盐的内容  
>>>  hash = hashlib.md5(bytes('me', encoding='utf-8'))  
>>> hash.hexdigest()  
'ab86a1e1ef70dff97959067b723c5c24'  
  
另外一个加盐的模块  
  
>>> import hmac  
>>>  h = hmac.new(bytes('me', encoding='utf-8'))  
>>> h.update(bytes('me', encoding='utf-8'))  
>>> h.hexdigest()  
'1ad251aa7475610a2376d074cd79d22d'  
  
7. hmac加密  
  
hmac内部对我们创建的key和内容进行处理后在加密  
  
  
1 import hmac  
2  h = hmac.new('python'.encode('utf-8'))  
3 h.update('helloworld'.encode('utf-8'))  
4 print(h.hexdigest())  
5 b3b867248bb4cace835b59562c39fd55  
   
8. 获取文件的MD5  
  
import hashlib  
  
def md5sum(filename):  
        """  
        用于获取文件的md5值  
        :param filename: 文件名  
        :return: MD5码  
        """  
        if  not os.path.isfile(filename):  \# 如果校验md5的文件不是文件，返回空  
            return  
         myhash = hashlib.md5()  
        f = open(filename, 'rb')  
        while True:  
            b = f.read(8096)  
            if not b:  
                break  
            myhash.update(b)     
        f.close()  
        return myhash.hexdigest()   
  
  
import hashlib  
   
hash = hashlib.md5()\#md5对象，md5不能反解，但是加密是固定的，就是关系是一一对应，所以有缺陷，可以被对撞出来  
  
hash.update(bytes('admin',encoding='utf-8'))\#要对哪个字符串进行加密，就放这里  
  
print(hash.hexdigest())\#拿到加密字符串  
  
\# hash2=hashlib.sha384()\#不同算法，hashlib很多加密算法  
  
\# hash2.update(bytes('admin',encoding='utf-8'))  
  
\#  print(hash.hexdigest())  
   
   
hash3 = hashlib.md5(bytes('abd',encoding='utf-8'))  
  
''' 如果没有参数，所以md5遵守一个规则，生成同一个对应关系，如果加了参数，就是在原先加密的基础上再加密一层，这样的话参数只有自己知道，防止被撞库，因为别人永远拿不到这个参数 '''  
  
hash3.update(bytes('admin',encoding='utf-8'))  
  
print(hash3.hexdigest())  
  
  
  
\#hashlib简单使用  
  
def md5(arg):\#这是加密函数，将传进来的函数加密  
    md5\_pwd = hashlib.md5(bytes('abd',encoding='utf-8'))  
    md5\_pwd.update(bytes(arg,encoding='utf-8'))  
    return md5\_pwd.hexdigest()\#返回加密的数据  
  
def log(user,pwd):\#登陆时候时候的函数，由于md5不能反解，因此登陆的时候用正解  
    with open('db','r',encoding='utf-8') as f:  
        for line in f:  
            u,p=line.strip().split('|')  
            if u ==user and p == md5(pwd):\#登陆的时候验证用户名以及加密的密码跟之前保存的是否一样  
                return True  
def register(user,pwd):\#注册的时候把用户名和加密的密码写进文件，保存起来  
    with open('db','a',encoding='utf-8') as f:  
        temp = user+'|'+md5(pwd)  
        f.write(temp)  
   
i=input('1表示登陆，2表示注册：')  
if i=='2':  
    user = input('用户名：')  
    pwd =input('密码：')  
    register(user,pwd)  
elif i=='1':  
    user = user = input('用户名：')  
    pwd =input('密码：')  
    r=log(user,pwd)\#验证用户名和密码  
    if r ==True:  
        print('登陆成功')  
    else:  
        print('登陆失败')  
else:  
    print('账号不存在')  
  
  
  
import hashlib      
m = hashlib.md5()   \#创建hash对象，md5:(message-Digest Algorithm 5)消息摘要算法,得出一个128位的密文      
print m             \#<md5 HASH object @ 02B93250>      
m.update('python')  \#更新哈希对象,以字符串为参数      
print m.digest()    \#返回摘要，作为二进制数据字符串值      
print m.hexdigest() \#返回摘要，作为十六进制数据字符串值    23eeeb4347bdd26bfc6b7ee9a3b755dd     
print m.digest\_size \#16，结果hash的大小,产生的散列的字节大小      
print m.block\_size  \#64，hash内部块的大小,The internal block size of the hash algorithm in bytes      
      
print hashlib.md5('python').hexdigest()\#简略写法   23eeeb4347bdd26bfc6b7ee9a3b755dd    
      
m1=m.copy()\#复制     
print m    \#<md5 HASH object @ 02B93250>    
print m1   \#<md5 HASH object @ 02B93200>    
print m.hexdigest()==m1.hexdigest() \#True     
  
  
  
import hashlib      
h = hashlib.new('md5')      
print h     \#<md5 HASH object @ 029F3200>      
h.update('python')      
print h.hexdigest() \#23eeeb4347bdd26bfc6b7ee9a3b755dd     
print h.block\_size,h.digest\_size    
print hashlib.new('md5','python').hexdigest() \#简略写法 23eeeb4347bdd26bfc6b7ee9a3b755dd       
\#等效      
h1 = hashlib.md5()      
h1.update('python')      
print h1.hexdigest() \#23eeeb4347bdd26bfc6b7ee9a3b755dd      
print h1.block\_size,h1.digest\_size     
print hashlib.md5('python').hexdigest() \#简略写法 23eeeb4347bdd26bfc6b7ee9a3b755dd      
  
\#列出所有加密算法      
print hashlib.algorithms  \#('md5', 'sha1', 'sha224', 'sha256', 'sha384', 'sha512')    
  
  
  
import hashlib  
\#\#\#\#\#\#\#\#\#md5\#\#\#\#\#\#\#\#\#\#  
\#调用hashlib里的md5()生成md5哈希对象  
m = hashlib.md5()  
\#使用update（）方法对字符串进行md5加密的更新处理。  
m.update("admin")  
\#十六进制加密结果  
print m.hexdigest()  
   
\#\#\#\#\#\#\#\#\#\#\#\#\#sha1\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#  
m = hashlib.sha1()  
m.update("admin")  
print m.hexdigest()  
   
\#\#\#\#\#\#\#\#\#\#\#\#\#sha224\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#  
m = hashlib.sha224()  
m.update("admin")  
print m.hexdigest()  
   
\#\#\#\#\#\#\#\#\#\#\#\#\#sha256\#\#\#\#\#\#\#\#\#\#\#\#\#\#  
m = hashlib.sha256()  
m.update("admin")  
print m.hexdigest()  
   
\#\#\#\#\#\#\#\#\#\#\#sha384\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#  
m = hashlib.sha384()  
m.update("admin")  
print m.hexdigest()  
   
\#\#\#\#\#\#\#\#\#\#\#sha512\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#  
m = hashlib.sha512()  
m.update("admin")  
print m.hexdigest()  
以上的加密算法有时候会被通过撞车进行解密，这样就有必要进行自定义key来进行加密。  
  
  
  
  
\#\#\#\#\#\#\#\#\#\#进行自定义key进行加密  
m = hashlib.md5("ewerfefer")  
m.update("admin")  
print m.hexdigest()  
  
  
  
JSON(javascript object nonation)是一种轻量级的数据交换格式，是一种理想的数据交换语言，易于人的编写和阅读，主要用于和服务器进行数据交换。  
  
json用于字符串和python数据类型之间进行数据转换  
json的方法有dump、dumps、load、loads  
json.dumps对简单数据进行编码  
  
  
import  json  
   
print json.dumps(\['foo',\{'tom':12\}\])  
print json.dumps('\\\\')  
  
\#对字典进行排序  
print json.dumps(\{'d':0,'a':1,'c':1\},sort\_keys = True)  
\#json.dumps()将数据通过特殊的方法转换为所有语言都能认识的字符串  
  
print json.dumps(\{'name':'rain','sex':'F'\})  
\#json.dump()将数据通过特殊的方法转换为所有语言都能识别的字符串，并写入文件中  
  
with open('json\_dump.txt','w') as f:  
    json.dump(\{'name':'rain','sex':'F'\},f)  
json.loads对简单数据进行解码  
  
  
\#\#\#\#\#loads\#\#\#\#\#\#\#  
import json  
print json.loads('\["foo", \{"bar":\["baz", null, 1.0, 2\]\}\]')  
print json.loads('\{"name":"rain","sex":"F"\}')   
  
  
  
序列化（Serialization）：将对象的状态信息转换为可以存储或可以通过网络传输的过程，传输的格式可以是JSON，XML等。反序列化就是从存储区域（JSON，XML）读取反序列化对象的状态，重新创建该对象。  
  
  
　　JSON（Java Script Object Notation）：一种轻量级数据交互格式，相对于XML而言更简单，也易于阅读和编写，机器也方便解析和生成，Json是JavaScript中的一个子集。  
  
  
　　python2.6版本开始加入了JSON模块，python的json模块序列化与反序列化的过程分别是encoding和decoding。  
  
  
encoding：把一个python对象编码转换成Json字符串。  
decoding：把json格式字符串编码转换成python对象。  
  
  
json提供四个功能：dumps, dump, loads, load  
  
  
1 \# dumps功能  
2 \# 将数据通过特殊的形式转换为所有程序语言都认识的字符串  
3 >>> import json  
4 >>> data = \['aa', 'bb', 'cc'\]  
5 >>>  j\_str = json.dumps(data)  
6 >>> j\_str  
7 '\["aa", "bb", "cc"\]'  
  
  
  
1 \# loads功能  
2 \# 将json编码的字符串再转换为python的数据结构  
3 >>> j\_str  
4 '\["aa", "bb", "cc"\]'  
5 >>>  mes = json.loads(j\_str)  
6 >>> mes  
7 \['aa', 'bb', 'cc'\]  
  
  
1 \# dump功能  
2 \# 将数据通过特殊的形式转换为所有程序语言都认识的字符串，并写入文件  
3 with open('D:/tmp.json', 'w') as f:  
4     json.dump(data, f)  
1 \# load功能  
2 \# 从数据文件中读取数据,并将json编码的字符串转换为python的数据结构  
3 with open('D:/tmp.json', 'r') as f:  
4     data = json.load(f)