Python 之模块导入

5534

Python之所以应用越来越广泛，在一定程度上也依赖于其为程序员提供了大量的模块以供使用，如果想要使用模块，则需要导入。导入模块有一下几种方法：

1 2 3 4

import module from module.xx.xx import xx from module.xx.xx import xx as rename   from module.xx.xx import *

导入模块其实就是告诉Python解释器去解释那个py文件

• 导入一个py文件，解释器解释该py文件
  
• 导入一个包，解释器解释该包下的 __init__.py 文件
  
  

那么问题来了，导入模块时是根据那个路径作为基准来进行的呢？即：sys.path

1 2 3

>>> import sys >>> print sys.path ['', 'C:\\WINDOWS\\SYSTEM32\\python27.zip', 'd:\\Python27\\DLLs', 'd:\\Python27\\lib', 'd:\\Python27\\lib\\plat-win', 'd:\\Python27\\lib\\lib-tk', 'd:\\Python27', 'd:\\Python27\\lib\\site-packages']

  如果sys.path路径列表没有你想要的路径，可以通过 sys.path.append('路径') 添加。
通过os模块可以获取各种目录，例如：

1 2 3 4

import sys import os pre_path = os.path.abspath('../') sys.path.append(pre_path)

开源模块

下载安装有两种方式：

1 2 3 4

yum pip apt-get ...

1 2 3 4 5

下载源码 解压源码 进入目录 编译源码    python setup.py build 安装源码    python setup.py install

注：在使用源码安装时，需要使用到gcc编译和python开发环境，所以，需要先执行：

1 2 3 4

yum install gcc yum install python-devel 或 apt-get python-dev

安装成功后，模块会自动安装到 sys.path 中的某个目录中，如：

/usr/lib/python2.7/site-packages/

二、导入模块

同自定义模块中导入的方式

三、模块 paramiko

paramiko是一个用于做远程控制的模块，使用该模块可以对远程服务器进行命令或文件操作，值得一说的是，fabric和ansible内部的远程管理就是使用的paramiko来现实。

1、下载安装
# pycrypto，由于 paramiko 模块内部依赖pycrypto，所以先下载安装pycrypto

# 下载安装 pycrypto

1 2 3 4 5

wget http://files.cnblogs.com/files/ryan/pycrypto-2.6.1.tar.gz tar -xvf pycrypto-2.6.1.tar.gz cd pycrypto-2.6.1 python setup.py build python setup.py install

# 进入python环境，导入Crypto检查是否安装成功

# 下载安装 paramiko

1 2 3 4 5

wget http://files.cnblogs.com/files/ryan/paramiko-1.10.1.tar.gz tar -xvf paramiko-1.10.1.tar.gz cd paramiko-1.10.1 python setup.py build python setup.py install

# 进入python环境，导入paramiko检查是否安装成功

2、使用模块

1 2 3 4 5 6 7 8 9

#!/usr/bin/env python #coding:utf-8 import paramiko ssh = paramiko.SSHClient() ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) ssh.connect('192.168.1.108', 22, 'alex', '123') stdin, stdout, stderr = ssh.exec_command('df') print stdout.read() ssh.close();

1 2 3 4 5 6 7 8 9

import paramiko private_key_path = '/home/auto/.ssh/id_rsa' key = paramiko.RSAKey.from_private_key_file(private_key_path) ssh = paramiko.SSHClient() ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) ssh.connect('主机名 ', 端口, '用户名', key) stdin, stdout, stderr = ssh.exec_command('df') print stdout.read() ssh.close()

执行命令 - 过密钥链接服务器

1 2 3 4 5 6 7

import os,sys import paramiko t = paramiko.Transport(('182.92.219.86',22)) t.connect(username='ryan',password='123') sftp = paramiko.SFTPClient.from_transport(t) sftp.put('/tmp/test.py','/tmp/test.py') t.close()

1 2 3 4 5 6 7

import os,sys import paramiko t = paramiko.Transport(('182.92.219.86',22)) t.connect(username='ryan',password='123') sftp = paramiko.SFTPClient.from_transport(t) sftp.get('/tmp/test.py','/tmp/test2.py') t.close()

上传或者下载文件 - 通过用户名和密码

1 2 3 4 5 6 7 8

import paramiko pravie_key_path = '/home/auto/.ssh/id_rsa' key = paramiko.RSAKey.from_private_key_file(pravie_key_path) t = paramiko.Transport(('182.92.219.86',22)) t.connect(username='ryan',pkey=key) sftp = paramiko.SFTPClient.from_transport(t) sftp.put('/tmp/test3.py','/tmp/test3.py') t.close()

1 2 3 4 5 6 7 8

import paramiko pravie_key_path = '/home/auto/.ssh/id_rsa' key = paramiko.RSAKey.from_private_key_file(pravie_key_path) t = paramiko.Transport(('182.92.219.86',22)) t.connect(username='ryan',pkey=key) sftp = paramiko.SFTPClient.from_transport(t) sftp.get('/tmp/test3.py','/tmp/test4.py') t.close()

上传或下载文件 - 通过密钥

内置模块
一、os

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

用于提供系统级别的操作 os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径 os.chdir("dirname")  改变当前脚本工作目录；相当于shell下cd os.curdir  返回当前目录: ('.') os.pardir  获取当前目录的父目录字符串名：('..') os.makedirs('dirname1/dirname2')    可生成多层递归目录 os.removedirs('dirname1')    若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推 os.mkdir('dirname')    生成单级目录；相当于shell中mkdir dirname os.rmdir('dirname')    删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname os.listdir('dirname')    列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印 os.remove()  删除一个文件 os.rename("oldname","newname")  重命名文件/目录 os.stat('path/filename')  获取文件/目录信息 os.sep    输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/" os.linesep    输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n" os.pathsep    输出用于分割文件路径的字符串 os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix' os.system("bash command")  运行shell命令，直接显示 os.environ  获取系统环境变量 os.path.abspath(path)  返回path规范化的绝对路径 os.path.split(path)  将path分割成目录和文件名二元组返回 os.path.dirname(path)  返回path的目录。其实就是os.path.split(path)的第一个元素 os.path.basename(path)  返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素 os.path.exists(path)  如果path存在，返回True；如果path不存在，返回False os.path.isabs(path)  如果path是绝对路径，返回True os.path.isfile(path)  如果path是一个存在的文件，返回True。否则返回False os.path.isdir(path)  如果path是一个存在的目录，则返回True。否则返回False os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略 os.path.getatime(path)  返回path所指向的文件或者目录的最后存取时间 os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间

二、sys
用于提供对解释器相关的操作

1 2 3 4 5 6 7 8

sys.argv           命令行参数List，第一个元素是程序本身路径 sys.exit(n)        退出程序，正常退出时exit(0) sys.version        获取Python解释程序的版本信息 sys.maxint         最大的Int值 sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值 sys.platform       返回操作系统平台名称 sys.stdout.write('please:') val = sys.stdin.readline()[:-1]

三、hashlib
用于加密相关的操作，代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法

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()
以上加密算法虽然依然非常厉害，但时候存在缺陷，即：通过撞库可以反解。所以，有必要对加密算法中添加自定义key再来做加密。

import hashlib

# ######## md5 ########

hash = hashlib.md5('898oaFs09f')
hash.update('admin')
print hash.hexdigest()

还不够吊？python 还有一个 hmac 模块，它内部对我们创建 key 和 内容 再进行处理然后再加密

1 2 3 4 5

import hmac h = hmac.new('wueiqi') h.update('hellowo') print h.hexdigest() 不能再牛逼了！！！

四、json 和 pickle

用于序列化的两个模块

• json，用于字符串 和 python数据类型间进行转换
  
• pickle，用于python特有的类型 和 python的数据类型间进行转换
  
  

Json模块提供了四个功能：dumps、dump、loads、load

pickle模块提供了四个功能：dumps、dump、loads、load

1 2	>>> import pickle >>> data = {'k1':123,'k2':'Hello'}

#pickle.dumps将数据通过特殊的形式转换为只有python语言人事id字符串

1 2 3 4 5 6 7 8 9 10 11 12

>>> p_str = pickle.dumps(data) >>> print p_str (dp0 S'k2' p1 S'Hello' p2 sS'k1' p3 I123 s. >>>

#pickle.dump将数据通过特殊的形式转换为只有Python语言认识的字符串，并写入文件

1 2 3

>>> with open('/server/scripts/day005/result.pk','w') as fp: ...      pickle.dump(data,fp) ...

import json
#json.dumps 将数据通过特殊的形式转换为所有程序语言都认识的字符串

1 2 3 4 5

>>> import json >>> j_str = json.dumps(data) >>> print j_str {"k2": "Hello", "k1": 123} >>>

#json.dump将数据通过特殊的形式转换为所有程序语言都能认识的字符串，并写入文件

1 2 3 4

>>> with open('/server/scripts/day005/result.json','w') as fp: ...      json.dump(data,fp) ... >>>

五、执行系统命令

可以执行shell命令的相关模块和函数有：

• os.system
  
• os.spawn*
  
• os.popen*          --废弃
  
• popen2.*           --废弃
  
• commands.*      --废弃，3.x中被移除
  
  

import commandsresult = commands.getoutput('cmd')result = commands.getstatus('cmd')result = commands.getstatusoutput('cmd'以上执行shell命令的相关的模块和函数的功能均在 subprocess 模块中实现，并提供了更丰富的功能。

call

执行命令，返回状态码

执行命令，如果执行状态码是 0 ，则返回0，否则抛异常

1 2	ret =subprocess.check_call(["ls", "-l"]) ret =subprocess.check_call("exit 1", shell=True)

shell = True ，允许 shell 命令是字符串形式

check_call
执行命令，如果状态码是 0 ，则返回执行结果，否则抛异常

1 2 3

subprocess.check_output(["echo", "Hello World!"]) subprocess.check_output("exit 1", shell=True) subprocess.Popen(...)

check_output
执行命令，如果状态码是 0 ，则返回执行结果，否则抛异常

1 2	subprocess.check_output(["echo", "Hello World!"]) subprocess.check_output("exit 1", shell=True)

subprocess.Popen(...)

用于执行复杂的系统命令

参数：

• args：shell命令，可以是字符串或者序列类型（如：list，元组）
  
• bufsize：指定缓冲。0 无缓冲,1 行缓冲,其他 缓冲区大小,负值 系统缓冲
  
• stdin, stdout, stderr：分别表示程序的标准输入、输出、错误句柄
  
• preexec_fn：只在Unix平台下有效，用于指定一个可执行对象（callable object），它将在子进程运行之前被调用
  
• close_sfs：在windows平台下，如果close_fds被设置为True，则新创建的子进程将不会继承父进程的输入、输出、错误管道。
  
  

所以不能将close_fds设置为True同时重定向子进程的标准输入、输出与错误(stdin, stdout, stderr)。

• shell：同上
  
• cwd：用于设置子进程的当前目录
  
• env：用于指定子进程的环境变量。如果env = None，子进程的环境变量将从父进程中继承。
  
• universal_newlines：不同系统的换行符不同，True -> 同意使用 \n
  
• startupinfo与createionflags只在windows下有效
  
  

将被传递给底层的CreateProcess()函数，用于设置子进程的一些属性，如：主窗口的外观，进程的优先级等等

1 2 3

import subprocess ret1 = subprocess.Popen(["mkdir","t1"]) ret2 = subprocess.Popen("mkdir t2", shell=True)

终端输入的命令分为两种：

• 输入即可得到输出，如：ifconfig
  
• 输入进行某环境，依赖再输入，如：python
  
  

1 2	import subprocess obj = subprocess.Popen("mkdir t3", shell=True, cwd='/home/dev',)

1 2 3 4 5 6 7 8 9 10 11 12 13

import subprocess obj = subprocess.Popen(["python"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE) obj.stdin.write('print 1 \n ') obj.stdin.write('print 2 \n ') obj.stdin.write('print 3 \n ') obj.stdin.write('print 4 \n ') obj.stdin.close() cmd_out = obj.stdout.read() obj.stdout.close() cmd_error = obj.stderr.read() obj.stderr.close() print cmd_out print cmd_error

1 2 3 4 5 6 7 8

import subprocess obj = subprocess.Popen(["python"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE) obj.stdin.write('print 1 \n ') obj.stdin.write('print 2 \n ') obj.stdin.write('print 3 \n ') obj.stdin.write('print 4 \n ') out_error_list = obj.communicate() print out_error_list

1 2 3 4

import subprocess obj = subprocess.Popen(["python"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE) out_error_list = obj.communicate('print "hello"') print out_error_list

六、shutil


高级的 文件、文件夹、压缩包 处理模块

shutil.copyfileobj(fsrc, fdst[, length])
将文件内容拷贝到另一个文件中，可以部分内容

1 2 3 4 5 6 7

def copyfileobj(fsrc, fdst, length=16*1024):     """copy data from file-like object fsrc to file-like object fdst"""     while 1:         buf = fsrc.read(length)         if not buf:             break         fdst.write(buf)

shutil.copyfile(src, dst)
拷贝文件

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

def copyfile(src, dst):     """Copy data from src to dst"""     if _samefile(src, dst):         raise Error("`%s` and `%s` are the same file" % (src, dst))     for fn in [src, dst]:         try:             st = os.stat(fn)         except OSError:             # File most likely does not exist             pass         else:             # XXX What about other special files? (sockets, devices...)             if stat.S_ISFIFO(st.st_mode):                 raise SpecialFileError("`%s` is a named pipe" % fn)     with open(src, 'rb') as fsrc:         with open(dst, 'wb') as fdst:             copyfileobj(fsrc, fdst)

shutil.copymode(src, dst)
仅拷贝权限。内容、组、用户均不变

1 2 3 4 5 6

def copymode(src, dst):     """Copy mode bits from src to dst"""     if hasattr(os, 'chmod'):         st = os.stat(src)         mode = stat.S_IMODE(st.st_mode)         os.chmod(dst, mode)

shutil.copystat(src, dst)
拷贝状态的信息，包括：mode bits, atime, mtime, flags

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

def copystat(src, dst):     """Copy all stat info (mode bits, atime, mtime, flags) from src to dst"""     st = os.stat(src)     mode = stat.S_IMODE(st.st_mode)     if hasattr(os, 'utime'):         os.utime(dst, (st.st_atime, st.st_mtime))     if hasattr(os, 'chmod'):         os.chmod(dst, mode)     if hasattr(os, 'chflags') and hasattr(st, 'st_flags'):         try:             os.chflags(dst, st.st_flags)         except OSError, why:             for err in 'EOPNOTSUPP', 'ENOTSUP':                 if hasattr(errno, err) and why.errno == getattr(errno, err):                     break             else:                 raise

shutil.copy(src, dst)
拷贝文件和权限

1 2 3 4 5 6 7 8

def copy(src, dst):     """Copy data and mode bits ("cp src dst").     The destination may be a directory.     """     if os.path.isdir(dst):         dst = os.path.join(dst, os.path.basename(src))     copyfile(src, dst)     copymode(src, dst)

shutil.copy2(src, dst)
拷贝文件和状态信息

1 2 3 4 5 6 7 8

def copy2(src, dst):     """Copy data and all stat info ("cp -p src dst").     The destination may be a directory.     """     if os.path.isdir(dst):         dst = os.path.join(dst, os.path.basename(src))     copyfile(src, dst)     copystat(src, dst)

shutil.ignore_patterns(*patterns)
shutil.copytree(src, dst, symlinks=False, ignore=None)
递归的去拷贝文件

例如：copytree(source, destination, ignore=ignore_patterns('*.pyc', 'tmp*'))

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

def ignore_patterns(*patterns):     """Function that can be used as copytree() ignore parameter.     Patterns is a sequence of glob-style patterns     that are used to exclude files"""     def _ignore_patterns(path, names):         ignored_names = []         for pattern in patterns:             ignored_names.extend(fnmatch.filter(names, pattern))         return set(ignored_names)     return _ignore_patterns def copytree(src, dst, symlinks=False, ignore=None):     """Recursively copy a directory tree using copy2().     The destination directory must not already exist.     If exception(s) occur, an Error is raised with a list of reasons.     If the optional symlinks flag is true, symbolic links in the     source tree result in symbolic links in the destination tree; if     it is false, the contents of the files pointed to by symbolic     links are copied.     The optional ignore argument is a callable. If given, it     is called with the `src` parameter, which is the directory     being visited by copytree(), and `names` which is the list of     `src` contents, as returned by os.listdir():         callable(src, names) -> ignored_names     Since copytree() is called recursively, the callable will be     called once for each directory that is copied. It returns a     list of names relative to the `src` directory that should     not be copied.     XXX Consider this example code rather than the ultimate tool.     """     names = os.listdir(src)     if ignore is not None:         ignored_names = ignore(src, names)     else:         ignored_names = set()     os.makedirs(dst)     errors = []     for name in names:         if name in ignored_names:             continue         srcname = os.path.join(src, name)         dstname = os.path.join(dst, name)         try:             if symlinks and os.path.islink(srcname):                 linkto = os.readlink(srcname)                 os.symlink(linkto, dstname)             elif os.path.isdir(srcname):                 copytree(srcname, dstname, symlinks, ignore)             else:                 # Will raise a SpecialFileError for unsupported file types                 copy2(srcname, dstname)         # catch the Error from the recursive copytree so that we can         # continue with other files         except Error, err:             errors.extend(err.args[0])         except EnvironmentError, why:             errors.append((srcname, dstname, str(why)))     try:         copystat(src, dst)     except OSError, why:         if WindowsError is not None and isinstance(why, WindowsError):             # Copying file access times may fail on Windows             pass         else:             errors.append((src, dst, str(why)))     if errors:         raise Error, errors

shutil.rmtree(path[, ignore_errors[, onerror]])
递归的去删除文件

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

def rmtree(path, ignore_errors=False, onerror=None):     """Recursively delete a directory tree.     If ignore_errors is set, errors are ignored; otherwise, if onerror     is set, it is called to handle the error with arguments (func,     path, exc_info) where func is os.listdir, os.remove, or os.rmdir;     path is the argument to that function that caused it to fail; and     exc_info is a tuple returned by sys.exc_info().  If ignore_errors     is false and onerror is None, an exception is raised.     """     if ignore_errors:         def onerror(*args):             pass     elif onerror is None:         def onerror(*args):             raise     try:         if os.path.islink(path):             # symlinks to directories are forbidden, see bug #1669             raise OSError("Cannot call rmtree on a symbolic link")     except OSError:         onerror(os.path.islink, path, sys.exc_info())         # can't continue even if onerror hook returns         return     names = []     try:         names = os.listdir(path)     except os.error, err:         onerror(os.listdir, path, sys.exc_info())     for name in names:         fullname = os.path.join(path, name)         try:             mode = os.lstat(fullname).st_mode         except os.error:             mode = 0         if stat.S_ISDIR(mode):             rmtree(fullname, ignore_errors, onerror)         else:             try:                 os.remove(fullname)             except os.error, err:                 onerror(os.remove, fullname, sys.exc_info())     try:         os.rmdir(path)     except os.error:         onerror(os.rmdir, path, sys.exc_info())

shutil.move(src, dst)
递归的去移动文件

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

def move(src, dst):     """Recursively move a file or directory to another location. This is     similar to the Unix "mv" command.     If the destination is a directory or a symlink to a directory, the source     is moved inside the directory. The destination path must not already     exist.     If the destination already exists but is not a directory, it may be     overwritten depending on os.rename() semantics.     If the destination is on our current filesystem, then rename() is used.     Otherwise, src is copied to the destination and then removed.     A lot more could be done here...  A look at a mv.c shows a lot of     the issues this implementation glosses over.     """     real_dst = dst     if os.path.isdir(dst):         if _samefile(src, dst):             # We might be on a case insensitive filesystem,             # perform the rename anyway.             os.rename(src, dst)             return         real_dst = os.path.join(dst, _basename(src))         if os.path.exists(real_dst):             raise Error, "Destination path '%s' already exists" % real_dst     try:         os.rename(src, real_dst)     except OSError:         if os.path.isdir(src):             if _destinsrc(src, dst):                 raise Error, "Cannot move a directory '%s' into itself '%s'." % (src, dst)             copytree(src, real_dst, symlinks=True)             rmtree(src)         else:             copy2(src, real_dst)             os.unlink(src)

shutil.make_archive(base_name, format,...)

创建压缩包并返回文件路径，例如：zip、tar

• base_name： 压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径，
  
  

如：www                        =>保存至当前路径
如：/Users/ryan/www =>保存至/Users/ryan/

• format：压缩包种类，“zip”, “tar”, “bztar”，“gztar”
  
• root_dir：要压缩的文件夹路径（默认当前目录）
  
• owner：用户，默认当前用户
  
• group：组，默认当前组
  
• logger：用于记录日志，通常是logging.Logger对象
  
  

#将 /Users/ryan/Downloads/test 下的文件打包放置当前程序目录

1 2	import shutil ret = shutil.make_archive("wwwwwwwwww", 'gztar', root_dir='/Users/ryan/Downloads/test')

#将 /Users/ryan/Downloads/test 下的文件打包放置 /Users/ryan/目录

1 2	import shutil ret = shutil.make_archive("/Users/ryan/wwwwwwwwww", 'gztar', root_dir='/Users/ryan/Downloads/test')

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

def make_archive(base_name, format, root_dir=None, base_dir=None, verbose=0,                  dry_run=0, owner=None, group=None, logger=None):     """Create an archive file (eg. zip or tar).     'base_name' is the name of the file to create, minus any format-specific     extension; 'format' is the archive format: one of "zip", "tar", "bztar"     or "gztar".     'root_dir' is a directory that will be the root directory of the     archive; ie. we typically chdir into 'root_dir' before creating the     archive.  'base_dir' is the directory where we start archiving from;     ie. 'base_dir' will be the common prefix of all files and     directories in the archive.  'root_dir' and 'base_dir' both default     to the current directory.  Returns the name of the archive file.     'owner' and 'group' are used when creating a tar archive. By default,     uses the current owner and group.     """     save_cwd = os.getcwd()     if root_dir is not None:         if logger is not None:             logger.debug("changing into '%s'", root_dir)         base_name = os.path.abspath(base_name)         if not dry_run:             os.chdir(root_dir)     if base_dir is None:         base_dir = os.curdir     kwargs = {'dry_run': dry_run, 'logger': logger}     try:         format_info = _ARCHIVE_FORMATS[format]     except KeyError:         raise ValueError, "unknown archive format '%s'" % format     func = format_info[0]     for arg, val in format_info[1]:         kwargs[arg] = val     if format != 'zip':         kwargs['owner'] = owner         kwargs['group'] = group     try:         filename = func(base_name, base_dir, **kwargs)     finally:         if root_dir is not None:             if logger is not None:                 logger.debug("changing back to '%s'", save_cwd)             os.chdir(save_cwd)     return filename

shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的，详细：

1	import zipfile

# 压缩

1 2 3 4

z = zipfile.ZipFile('laxi.zip', 'w') z.write('a.log') z.write('data.data') z.close()

# 解压

1 2 3

z = zipfile.ZipFile('laxi.zip', 'r') z.extractall() z.close()

zipfile 压缩解压

1	import tarfile

# 压缩

1 2 3 4

tar = tarfile.open('your.tar','w') tar.add('/Users/ryan/PycharmProjects/bbs2.zip', arcname='bbs2.zip') tar.add('/Users/ryan/PycharmProjects/cmdb.zip', arcname='cmdb.zip') tar.close()

# 解压

1 2 3

tar = tarfile.open('your.tar','r') tar.extractall()  # 可设置解压地址 tar.close()