19文件IO_io_pathlib_shutil

在柞水等地区，都构建了全面的区域性战略布局，加强发展的系统性、市场前瞻性、产品创新能力，以专注、极致的服务理念，为客户提供网站设计、成都网站制作 网站设计制作按需求定制制作,公司网站建设,企业网站建设,成都品牌网站建设,网络营销推广,外贸网站制作,柞水网站建设费用合理。

目录

StringIO、BytesIO：...1

路径操作，pathlib：...2

OS模块：...10

shutil模块：...13

文件拷贝：...13

rm..14

mv.14

StringIO、BytesIO：

StringIO：

io模块中的类；

from io import StringIO；

内存中，开辟的一个文本模式的buffer，可以像文件对象一样操作它（仅在内存中，在内存中构建文件）；

当close()方法被调用的时候，这个buffer会被释放；

sio=StringIO();sio.getvalue()，获取全部内容，跟文件指针没有关系，无视指针，输出全部内容；

好处，一般来说，磁盘的操作比内存的操作要慢得多，内存足够的情况下，一般的优化思路是少落地，减少磁盘IO的过程，可以大大提高程序的运行效率；

通常解决方案，单机用StringIO，多机分布式用redis；

BytesIO：

io模块中的类；

from io import BytesIO；

内存中，开辟的一个二进制模式的buffer，可以像文件对象一样操作它；

当close()方法被调用的时候，这个buffer会被释放；

file-like对象：

类文件对象，可以像文件对象一样操作；

socket对象、输入输出对象（stdin，stdout），都是类文件对象；

与unixOS一样，一切皆文件；

例：

In [63]: from io import StringIO

In [64]: sio = StringIO()

In [65]: print(sio.readable(),sio.writable(),sio.seekable())

True True True

In [66]: sio.write('magedu\npython')

Out[66]: 13

In [67]: sio.seek(0)

Out[67]: 0

In [68]: sio.readline()

Out[68]: 'magedu\n'

In [69]: sio.readline()

Out[69]: 'python'

In [70]: sio.getvalue()   #无视指针，输出全部内容，相当于sio.seek(0);sio.read()

Out[70]: 'magedu\npython'

In [71]: sio.close()

例：

In [72]: from io import BytesIO

In [73]: bio=BytesIO()

In [74]: print(bio.readable(),bio.writable(),bio.seekable())

True True True

In [75]: bio.write('magedu\npython'.encode())

Out[75]: 13

In [76]: bio.seek(0)

Out[76]: 0

In [77]: bio.readlines()

Out[77]: [b'magedu\n', b'python']

In [78]: bio.getvalue()

Out[78]: b'magedu\npython'

In [79]: bio.close()

例：

In [80]: from sys import stdout

In [81]: f=stdout

In [82]: type(f)

Out[82]: _io.TextIOWrapper

In [83]: f

Out[83]: <_io.TextIOWrapper name='' mode='w' encoding='UTF-8'>

In [84]: f.write('magedu.com')   #同import sys;sys.stdout.write('magedu.com')，print('magedu.com)，print也是调用控制台（标准输出）打印

Out[84]: magedu.com

路径操作，pathlib：

3.4版本之前用os.path，from os import path；

os.path.join('/etc/','sysconfig','network')

os.path.exists(p)

os.path.abspath(p)

os.path.dirname(p)

os.path.basename(p)

os.path.split(p)-->(head,tail)，返回二元组，head为dirname，tail为basename；

os.path.splitdrive(p)-->(head,tail)，仅win下用，取驱动器；

例：

In [1]: from os import path

In [2]: p=path.join('/etc','sysconfig','network')   #os.path后的方法是操作字符串

In [3]: p

Out[3]: '/etc/sysconfig/network'

In [4]: type(p)   #字符串对象

Out[4]: str

In [5]: path.exists(p)

Out[5]: True

In [6]: path.split(p)

Out[6]: ('/etc/sysconfig', 'network')

In [7]: path.abspath('.')

Out[7]: '/home/python/magedu/projects/cmdb'

win下：

注：

win下识别/和\，最好用r'c:\nt'；

linux下仅识别/；

3.4版本开始，更加的面向对象：

pathlib模块，建议使用；

from pathlib import Path   #提供Path对象，来操作目录和文件，第一个字母大写（大驼峰）；

p=Path()

p.absolute()

p.joinpath('subpath2','subpath3')

p /= 'subpath2' / 'subpath3'

p.exists()

路径拼接：

方一：

操作符/；

Path对象 / Path对象；

Path对象 / 字符串；

字符串 / Path对象；

方二：

p.joinpath(*other)，连接多个字符串到Path对象中；

方三：

p.absolute().joinpath('subpath2','subpath3') / 字符串或Path对象

路径分解：

p.parts   #parts属性，可以返回路径中的每一个部分；

p.absolute().parts

获取路径：

str(p)   #获取路径字符串；

bytes(p)   #获取路径字符串的bytes；

父目录：

p.parent   #目录的逻辑父目录，常用于获取某个文件的路径；相对路径的父目录要先转绝对路径，不转绝对路径父目录是其本身；

p.parent.parent   #到头后，不报错；

p.parents   #父目录序列，索引0是直接的父；逐级到根（从长到短）；

p.name，目录的最后一个部分；

p.stem，目录最后一个部分，没有后缀；

p.suffix，目录最后一个部分的扩展名；

p.suffixes，返回多个扩展名列表；

p.with_suffix(suffix)-->新路径，补充扩展名到路径尾部，返回新的路径，扩展名存在则无效；

p.with_name(name)-->新路径，替换目录最后一个部分，并返回一个新的路径；相当于p = p.parent / 'name'；

完整路径两种：

完整路径 = p.parent + p.name

完整路径 = p.parent + p.stem + p.suffix

p.cwd()，返回当前工作目录；

p.home()，返回当前用户目录；

p.is_dir()，是否是目录，OS上要有实体；

p.is_file()，是否是普通文件；

p.is_symlink()，是否是软链接；

p.is_socket()，是否是socket文件；

p.is_block_device()，是否是块设备文件；

p.is_char_device()，是否是字符设备文件；

p.is_absolute()，是否是绝对路径；

p.resolve()-->新路径，返回一个新路径，这个新路径就是当前Path对象的绝对路径，如果是软链接则直接被解析；

p.absolute()，获取绝对路径，推荐使用p.resolve()；

p.exists()，目录或文件是否存在；

p.rmdir()，删除空目录，没有提供判断目录为空的方法；

p.touch(mode=0o666,exist_ok=True)，创建一个文件，0o为八进制；

p.as_uri()，将路径返回成uri，如file:///etc/hosts；

p.mkdir(mode=0o777,parents=False,exist_ok=False)，

如p.mkdir(parents=True)相当于mkdir -p，若parents=False父目录不存在则抛FileNotFoundError；

exist_ok，3.5版本加入，False时路径存在抛FileExistsError，True时FileExistsError被忽略，一般不用此项，写前用if判断路径是否存在；

p.iterdir()，迭代当前目录；

p.glob(pattern)，通配给定的模式；

p.rglob(pattern)，通配给定的模式，recursion递归目录；

p.match(pattern)，匹配；

p.open(mode='r',buffering=-1,encoding=None,errors=None,newline=None)，使用方法同内建函数open()，返回一个文件对象；

3.5版增加的新函数：

p.read_text(encoding=None,errors=None)

p.read_bytes()，以rb方式读取路径对应文件，并返回二进制流；

p.write_bytes(data)，以wb方式写入数据到路径对应文件；

p.write_text(data,encoding=None,errors=None)，以wt方式写入字符串到路径对应文件；

例：

In [8]: from pathlib import Path

In [9]: p=Path()  #实例化，当前目录，同set(),dict(),list()等

In [10]: type(p)   #linux下为pathlib.PosixPath，win下为pathlib.WindowsPath

Out[10]: pathlib.PosixPath

In [11]: p

Out[11]: PosixPath('.')

In [12]: p.absolute()

Out[12]: PosixPath('/home/python/magedu/projects/cmdb')

In [13]: p=p.joinpath('a','b')   #同p=p / 'a' / 'b'

In [14]: p.absolute()

Out[14]: PosixPath('/home/python/magedu/projects/cmdb/a/b')

In [15]: p = p / 'c' / 'd'   #同p /= 'c' / 'd'，等号右边必须要有Path对象p

In [16]: p

Out[16]: PosixPath('a/b/c/d')

In [17]: p.absolute()

Out[17]: PosixPath('/home/python/magedu/projects/cmdb/a/b/c/d')

In [18]: p1=Path('/etctest')   #初始化绝对路径，实际不存在

In [19]: p1

Out[19]: PosixPath('/etctest')

In [20]: p1.exists()

Out[20]: False

In [21]: p2=Path()

In [22]: p2=p1 / 'sysconfig'   #等号右边必须要有Path对象，不可以p2='/etctest' / 'sysconfig'

In [23]: p2

Out[23]: PosixPath('/etctest/sysconfig')

In [24]: print(p2)   #与p2结果一样，但调用的函数不一样，p2作为字符串用时要强制类型转换str(p2)

/etctest/sysconfig

In [25]: p=Path('a','b','c/d')   #当前目录下的a/b/c/d

In [26]: p

Out[26]: PosixPath('a/b/c/d')

In [27]: p=Path('/a','/b','c')   #错误，当前路径要慎用

In [28]: p   #路径为/b/c

Out[28]: PosixPath('/b/c')

In [29]: p.parts

Out[29]: ('/', 'b', 'c')

In [30]: print(str(p),bytes(p))   #bytes(p)同str(p).encode()

/b/c b'/b/c'

例：

In [33]: p=Path('/etc/sysconfig/network')

In [34]: p.parent

Out[34]: PosixPath('/etc/sysconfig')

In [35]: p.parent

Out[35]: PosixPath('/etc/sysconfig')

In [36]: p.parent.parent

Out[36]: PosixPath('/etc')

In [37]: p.parent.parent.parent

Out[37]: PosixPath('/')

In [38]: p.parent.parent.parent.parent

Out[38]: PosixPath('/')

In [39]: list(p.parents)

Out[39]: [PosixPath('/etc/sysconfig'), PosixPath('/etc'), PosixPath('/')]

In [40]: list(p.parents)[0]

Out[40]: PosixPath('/etc/sysconfig')

In [41]: next(iter(p.parents))   #注意超界

Out[41]: PosixPath('/etc/sysconfig')

In [42]: for x in p.parents:

    ...:     print(x)

    ...:    

/etc/sysconfig

/etc

/

In [43]: p=Path()

In [44]: p.parent   #相对路径的父目录是其本身

Out[44]: PosixPath('.')

In [45]: p.absolute().parent   #相对路径的父目录先转绝对路径，再查看

Out[45]: PosixPath('/home/python/magedu/projects')

In [46]: p.absolute().parent.parent

Out[46]: PosixPath('/home/python/magedu')

In [48]: for x in p.absolute().parents:

    ...:     print(x)

    ...:    

/home/python/magedu/projects

/home/python/magedu

/home/python

/home

/

例：

In [49]: p=Path('/etc/sysconfig/test.txt')

In [50]: p.name

Out[50]: 'test.txt'

In [51]: p.stem

Out[51]: 'test'

In [52]: p.suffix

Out[52]: '.txt'

In [53]: p.suffixes

Out[53]: ['.txt']

In [54]: p2=Path('/etc/sysconfig/test.tar.gz')

In [55]: p2.suffixes

Out[55]: ['.tar', '.gz']

In [56]: p2.with_suffix('.bz2')  #修改扩展名一定要带点，原.gz-->.bz2，否则ValueError: Invalid suffix 'bz2'；若原扩展名没点，经此操作是加扩展名

Out[56]: PosixPath('/etc/sysconfig/test.tar.bz2')

In [57]: p2.with_suffix('.tgz')

Out[57]: PosixPath('/etc/sysconfig/test.tar.tgz')

In [58]: p3=Path('/etc/sysconfig/test')

In [59]: p3.with_suffix('.tgz')

Out[59]: PosixPath('/etc/sysconfig/test.tgz')

In [60]: p2.with_name('test')  #改文件名，同p2 = p2.parent / 'test'

Out[60]: PosixPath('/etc/sysconfig/test')

In [61]: p3.with_name('test.tar.gz')

Out[61]: PosixPath('/etc/sysconfig/test.tar.gz')

In [64]: p3

Out[64]: PosixPath('/etc/sysconfig/test')

In [65]: p3.with_suffix('.tgz')

Out[65]: PosixPath('/etc/sysconfig/test.tgz')

In [67]: p3=p3.parent / 'test.tgz'

In [68]: p3

Out[68]: PosixPath('/etc/sysconfig/test.tgz')

例：

In [69]: p=Path('a','b','c/d')

In [70]: p.mkdir(parents=True)

In [71]: p.exists()

Out[71]: True

例：

In [1]: from pathlib import Path

In [2]: p=Path()

In [3]: p.iterdir()

Out[3]:

In [4]: p.iterdir()

Out[4]:

In [5]: for x in p.iterdir():

   ...:     if x.is_dir():

   ...:         print(x)

   ...:        

a

In [6]: p

Out[6]: PosixPath('.')

In [7]: ls

a/  max-min.sh  test  test.txt

例：

遍历，并判断文件类型，如果是目录并判断其是否为空；

from pathlib import Path

p = Path('a/b/c/d')

for x in p.parents[len(p.parents)-1].iterdir():

    print(x,end='\t\t\t\t')

    if x.is_dir():

        flag = False

        for _ in x.iterdir():

            flag = True

            break

        print('dir','Not Empty' if flag else 'Empty',sep='\t\t\t\t')

    elif x.is_file():

        print('file')

    else:

        print('other file')

例：

In [24]: p=Path()

In [25]: p

Out[25]: PosixPath('.')

In [27]: p.glob('t*')

Out[27]:

In [28]: list(p.glob('t*'))

Out[28]: [PosixPath('test'), PosixPath('test.txt')]

In [30]: list(p.glob('/*.py'))   #错误，p是当前路径，通配的是/下的文件

---------------------------------------------------------------------------

NotImplementedError                       Traceback (most recent call last)

in ()

----> 1 list(p.glob('/*.py'))

……

In [31]: list(p.glob('*/*.py'))

Out[31]: []

In [32]: list(p.glob('**/*.py'))   #**/相对当前的，之后任意级

Out[32]: [PosixPath('pathlib_Path_iterdir.py')]

In [33]: p.resolve()   #绝对路径，软链接会追踪

Out[33]: PosixPath('/home/python/magedu/projects/cmdb')

In [35]: list(p.rglob('*.py'))

Out[35]: [PosixPath('pathlib_Path_iterdir.py')]

In [38]: !touch e/test.py

In [42]: p=Path('e/test.py')

In [43]: p.match('*.py')

Out[43]: True

In [44]: Path('.py').match('*.py')

Out[44]: True

In [45]: Path('a/b/c.py').match('b/*.py')

Out[45]: True

In [46]: Path('a/b/c.py').match('a/*.py')

Out[46]: False

In [47]: Path('a/b/c.py').match('a/*/*.py')

Out[47]: True

In [48]: Path('a/b/c.py').match('a/**/*.py')

Out[48]: True

In [49]: Path('a/b/c.py').match('**/*.py')

Out[49]: True

In [50]: Path('a/c.py').match('a/*/*.py')

Out[50]: False

In [51]: Path('a/c.py').match('a/**/*.py')

Out[51]: False

例：

In [52]: p=Path('/tmp/test.txt')

In [53]: p.touch()

In [54]: p.open('w+')

Out[54]: <_io.TextIOWrapper name='/tmp/test.txt' mode='w+' encoding='UTF-8'>

In [55]: with p.open('w+') as f:   #建议使用with...as...

    ...:     f.write('test\ntest')

    ...:    

In [56]: f

Out[56]: <_io.TextIOWrapper name='/tmp/test.txt' mode='w+' encoding='UTF-8'>

In [57]: f.closed

Out[57]: True

In [58]: p.read_text()

Out[58]: 'test\ntest'

In [59]: p.write_text('abc')   #每次都会清空再写，不能传模式

Out[59]: 3

In [60]: p.read_text()

Out[60]: 'abc'

OS模块：

os.name，win显示nt，linux显示posix；

os.uname()，win不支持，linux支持；

os.listdir('/tmp')，返回目录内容列表，是立即返回；

sys.platform，win显示win32，linux显示linux；

os.stat(path, *, dir_fd=None, follow_symlinks=True)，

调用linux系统的stat，

path，路径的string或bytes或fd；

follow_symlinks=True默认追踪，返回文件本身信息，False如果是软链接则显示软链接本身；

os.chmod(path,mode,*,dir_fd=None,follow_symlinks=True)

os.chown(path,uid,gid)，改变文件的属主、属组、但需要有足够的权限；

注：

os也有open、read、write等方法，太低级（底层），建议使用内建函数open、read、write；

例：

In [61]: import os

In [62]: os.name

Out[62]: 'posix'

In [63]: os.uname

Out[63]:

In [64]: os.uname()

Out[64]: posix.uname_result(sysname='Linux', nodename='tmsapp', release='2.6.32-431.el6.x86_64', version='#1 SMP Sun Nov 10 22:19:54 EST 2013', machine='x86_64')

In [65]: os.listdir('/tmp')

Out[65]:

['keyring-c8Fi6u',

 '+~JF1728020691866336530.tmp',

 '.X11-unix',

……

In [66]: import sys

In [67]: sys.platform

Out[67]: 'linux'

例：

]$ ln -sv test.txt t1

`t1' -> `test.txt'

]$ ln -sv test.txt t2

`t2' -> `test.txt'

]$ stat test.txt

  File: `test.txt'

  Size: 66                 Blocks: 8          IO Block: 4096   regular file

Device: fd00h/64768d     Inode: 1448511     Links: 1

Access: (0664/-rw-rw-r--)  Uid: (  504/  python)   Gid: (  504/  python)

Access: 2018-05-04 06:53:48.943903498 +0800

Modify: 2018-03-14 15:44:32.618152979 +0800

Change: 2018-03-14 15:44:32.628153003 +0800

]$ stat -L t1

  File: `t1'

  Size: 66                 Blocks: 8          IO Block: 4096   regular file

Device: fd00h/64768d     Inode: 1448511     Links: 1

Access: (0664/-rw-rw-r--)  Uid: (  504/  python)   Gid: (  504/  python)

Access: 2018-05-04 06:53:48.943903498 +0800

Modify: 2018-03-14 15:44:32.618152979 +0800

Change: 2018-03-14 15:44:32.628153003 +0800

]$ stat -L t2

  File: `t2'

  Size: 66                 Blocks: 8          IO Block: 4096   regular file

Device: fd00h/64768d     Inode: 1448511     Links: 1

Access: (0664/-rw-rw-r--)  Uid: (  504/  python)   Gid: (  504/  python)

Access: 2018-05-04 06:53:48.943903498 +0800

Modify: 2018-03-14 15:44:32.618152979 +0800

Change: 2018-03-14 15:44:32.628153003 +0800

In [1]: import os

In [2]: os.stat('test.txt')

Out[2]: os.stat_result(st_mode=33204, st_ino=1448511, st_dev=64768, st_nlink=1, st_uid=504, st_gid=504, st_size=66, st_atime=1525388028, st_mtime=1521013472, st_ctime=1521013472)

In [3]: os.stat('t1')

Out[3]: os.stat_result(st_mode=33204, st_ino=1448511, st_dev=64768, st_nlink=1, st_uid=504, st_gid=504, st_size=66, st_atime=1525388028, st_mtime=1521013472, st_ctime=1521013472)

In [4]: os.stat('t2')

Out[4]: os.stat_result(st_mode=33204, st_ino=1448511, st_dev=64768, st_nlink=1, st_uid=504, st_gid=504, st_size=66, st_atime=1525388028, st_mtime=1521013472, st_ctime=1521013472)

In [5]: os.stat('t1',follow_symlinks=False)

Out[5]: os.stat_result(st_mode=41471, st_ino=1444349, st_dev=64768, st_nlink=1, st_uid=504, st_gid=504, st_size=8, st_atime=1525415800, st_mtime=1525415780, st_ctime=1525415780)

In [6]: oct(33204)

Out[6]: '0o100664'   #八进制

In [7]: oct(41471)

Out[7]: '0o120777'

shutil模块：

高级文件操作；

文件拷贝：

打开2个文件对象，源文件读取内容，写入目标文件来完成拷贝过程（只内容一样），这样会丢失stat数据信息（元数据信息等，包括权限），因为根本没有复制过去；

import shutil

shutil.copyfileobj(fsrc,fdst[,length=16384])，文件对象的复制，fsrc和fdst是open打开的文件对象，复制内容，fdst要求可写，length表示buffer的大小；

shutil.copyfile(src,dst,*,follow_symlinks=True)，复制文件内容，不含元数据，src,dst为文件路径的字符串，本质上调用的是shutil.copyfileobj()不带元数据二进制内容复制；

shutil.copymode(src,dst,*,follow_symlinks=True)，仅复制权限；

shutil.copystat(src,dst,*,follow_symlinks=True)，复制元数据，stat中包含的所有东西，另ctime改不了或不会改；

shutil.copy(src,dst,*,follow_symlinks=True)，复制文件内容、权限和部分元数据，不包括创建时间和修改时间，本质上调用的是shutil.copyfile()和shutil.copymode()；

shutil.copy2(src,dst,*,follow_symlinks=True)，比shutil.copy()多了复制全部元数据，但需要平台支持，本质上调用的是shutil.copyfile()和shutil.copystat()；

shutil.copytree(src,dst,symlinks=False,ignore=None,copy_function=copy2,ignore_dangling_symlinks=False)，递归复制目录，默认使用copy2，即带更多的元数据复制，

src,dst必须是目录，src必须存在，dst必须不存在；

ignore=func，提供一个callable(src,names)-->ignored_names函数，它会被调用，src是源目录，names是os.listdir(src)的结果，即列出src中的文件名，返回值是要被过滤的文件名的set类型数据；

rm

shutil.rmtree(path,ignore_errors=False,onerror=None)，

同rm -rf，慎用，递归删除；

它不是原子操作，有可能删除错误就会中断，但已经删除的就删了；

ignore_errors为True，忽略错误，为False或Omitted时，onerror生效；

onerror为callable，接受函数function、path、execinfo；

mv

shutil.move(src,dst,copy_function=copy2)，

递归移动文件、目录到目标，返回目标；

本身使用的是os.rename方法；

如果不支持remove，如果是目录则是copytree再删除源目录；

默认使用copy2方法；

shutil还有打包功能，生成tar并压缩，支持zip、gz、bz2、xz；

例（理解copytree源码中ignore(src,names)，重要技巧）：

def ignore(src,names):

         return set(filter(lambda x:x.startswith('t'),names))

同

lambda src,names:set(filter(lambda x:x.startswith('t'),names))

def fn(x,file_names):

         return set(filter(lambda x:x.startswith('t'),file_names))

同

lambda x,file_names:set(filter(lambda x:x.startswith('t'),file_names))

注：

重要内建函数：

filter()，过滤；

sorted()；

map()或zip()，每个元素都动；

In [24]: zip(range(5),(1,)*len(range(5)))

Out[24]:

In [25]: for item in zip(range(5),(1,)*len(range(5))):

    ...:     print(item)

    ...:    

    ...:

(0, 1)

(1, 1)

(2, 1)

(3, 1)

(4, 1)

In [26]: map(lambda x:(x,1),range(5))

Out[26]:

In [27]: for item in map(lambda x:(x,1),range(5)):

    ...:     print(item)

    ...:    

(0, 1)

(1, 1)

(2, 1)

(3, 1)

(4, 1)

例：

In [18]: Path('test.txt').write_text('abcde')

Out[18]: 5

In [19]: Path('test.txt').read_text()

Out[19]: 'abcde'

In [20]: with open('test.txt') as f1:

    ...:     with open('test_copy.txt','w') as f2:

    ...:         shutil.copyfileobj(f1,f2)

    ...:        

In [21]: Path('test_copy.txt').read_text()

Out[21]: 'abcde'

In [22]: with open('test.txt','r+') as f1:   #错误，写完后文件指针在EOF，f2复制的内容为空，一般不在代码中写入

    ...:     f1.write('abcd\n1234')

    ...:     f1.flush()

    ...:     with open('test_copy.txt','w') as f2:

    ...:         shutil.copyfileobj(f1,f2)

    ...:        

In [23]: Path('test_copy.txt').read_text()

Out[23]: ''

In [3]: shutil.make_archive(r'c:\webproject\mysite\test','gztar','.')   #压缩文件名、压缩格式（bztar|gztar|tar|zip）、压缩目录

Out[3]: 'c:\\webproject\\mysite\\test.tar.gz'

In [8]: shutil.unpack_archive(r'c:\webproject\mysite\test.tar.gz','e:\\test\\')   #解压

tarfile

In [10]: with tarfile.open('test.tar.gz',mode='r:gz') as tf:   #tarfile.open()返回一个tarfile对象；mode指定压缩算法，’r:gz’或’r:bz2’，’w:gz’或’w:bz2’

    ...:     for member in tf.getmembers():   #获取tar包中的文件列表

    ...:         print(member)

    ...:

……

In [22]: with tarfile.open(r'c:\webproject\mysite\test.tar.gz',mode='w:gz') as tf:

    ...:     tf.add('c:/webproject/mysite')   #打包

In [26]: with tarfile.open('e:/test/test.tar.gz','r:gz') as tf:

...:     tf.extractall('e:/test/')   #解压，extractall解压所有文件，extract解压单个文件

zipfile

In [28]: import zipfile

In [37]: with zipfile.ZipFile('c:/webproject/mysite/tset.zip','w') as tf:

    ...:     tf.write('c:/webproject/mysite/db.sqlite3')

In [41]: shutil.copy2('c:/webproject/mysite/tset.zip','e:/test/')

Out[41]: 'e:/test/tset.zip'

In [42]: with zipfile.ZipFile('e:/test/tset.zip','r') as tf:

    ...:     print(tf.namelist())

    ...:

['webproject/mysite/db.sqlite3']

In [45]: with zipfile.ZipFile('e:/test/tset.zip','r') as tf:

    ...:     tf.extractall('e:/test/')

...: