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

时间:2022-01-26 22:37:45

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, onerror=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'))
print(hash.hexdigest())
4 21232f297a57a5a743894a0e4a801fc3

2. sha1加密

1 hash = hashlib.sha1()
2 hash.update('admin'.encode('utf-8'))
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'))
print(hash.hexdigest())
4 9ca694a90285c034432c9550421b7b9dbd5c0f4b6673f05f6dbce58052ba20e4248041956ee8c9a2ec9f10290cdc0782

5. sha512加密

1 hash = hashlib.sha512()
2 hash.update('admin'.encode('utf-8'))
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)