用python解压图片并打印代码

import zipfile

# 传入压缩文件zfile.zip获取相关信息

zip_file = zipfile.ZipFile('zfile.zip')

# 获取压缩文件中的内容

f_content = zip_file.namelist()

# 压缩前的大小

f_size = zip_file.getinfo('zfile/a.txt').file_size

# 压缩后的大小

c_size = zip_file.getinfo('zfile/a.txt'贺销).compress_size

ZipFile 对象有一个 namelist()方法，返回 ZIP 文件中包含的所有文件和文件夹 的字符串的列表。这些字符串可以传递给 ZipFile 对象的 getinfo()方法，返回一个关 于特定文件的 ZipInfo 对象。ZipInfo 对象有自己的属性，诸如表示字节数的 file_size 和 compress_size，它们分别表示原来文件大小和压缩后文件大小。ZipFile 对象表示 整个归档文件，而 ZipInfo 对象则保存该归档文件中每个文件的有用信息。

从 ZIP 文件中解压缩

ZipFile 对象的 extractall()方法从 ZIP 文件中解压缩所有文件和文件夹，放到当 前工作目录中。

import zipfile

zip_file = zipfile.ZipFile('zfile.zip')

# 解压

zip_extract = zip_file.extractall()

zip_extract.close()

运行这段代码后， example.zip 的内容将被解压缩到 C:\。 或者， 你可以向 extractall()传递的一个文件夹名称，它将文件解压缩到那个文件夹，而不是当前工作 目录。如果传递给 extractall()方法的文件夹不存在，它会被创建。例如，如果你用 exampleZip.extractall('C:\ delicious')取代处的调用，代码就会从 example.zip 中解压 缩文件，放到段腔新创建的 C:\delicious 文件夹中。

ZipFile 对象的 extract()方法从 ZIP 文件中解压缩单个文件。

创建和添加到 ZIP 文件

要创建你自己的压缩 ZIP 文件，必须以“写模式”打开 ZipFile 对象，即传握拍衫入'w' 作为第二个参数(这类似于向 open()函数传入'w'，以写模式打开一个文本文件)。

如果向 ZipFile 对象的 write()方法传入一个路径，Python 就会压缩该路径所指 的文件，将它加到 ZIP 文件中。write()方法的第一个参数是一个字符串，代表要添 加的文件名。第二个参数是“压缩类型”参数，它告诉计算机使用怎样的算法来压 缩文件。可以总是将这个值设置为 zipfile.ZIP_DEFLATED(这指定了 deflate 压缩 算法，它对各种类型的数据都很有效)。

import zipfile

zip_file = zipfile.ZipFile('new.zip','w')

# 把zfile整个目录下所有内容，压缩为new.zip文件

zip_file.write('zfile',compress_type=zipfile.ZIP_DEFLATED)

# 把c.txt文件压缩成一个压缩文件

# zip_file.write('c.txt',compress_type=zipfile.ZIP_DEFLATED)

zip_file.close()

这段代码将创建一个新的 ZIP 文件，名为 new.zip，它包含 spam.txt 压缩后的内容。

要记住，就像写入文件一样，写模式将擦除 ZIP 文件中所有原有的内容。如果 只是希望将文件添加到原有的 ZIP 文件中，就要向 zipfile.ZipFile()传入'a'作为第二 个参数，以追加模式打开 ZIP 文件。

有时我们需要在 Python 中使用 zip 文件，而在1.6版中，Python 就已经提供了 zipfile 模块可以进行这样的 *** 作。不过 Python 中的 zipfile 模块不能处理多卷的情况，不过这种情况并不多见，因此在通常情况下已经足够使用了。下面我只是对一些基本的 zipfile *** 作进行了记录，足以应付大部分的情况了。

zipfile 模块可以让你打开或写入一个 zip 文件。比如：

import zipfile

z = zipfile.ZipFile('zipfilename', mode='r')

这样就打开了一个 zip 文件，如果mode为'w'或'a'则表示要写入一个 zip 文件。如果是写入，则还可以跟上第三个参数：

compression=zipfile.ZIP_DEFLATED 或

compression=zipfile.ZIP_STORED ZIP_DEFLATED是压缩标志，如果使用它需要编译了zlib模块。而后一个只是用zip进行打包，并不压缩。

在打开了zip文件之后就可以根据需要是读出zip文件的内容还是将内容保存到 zip 文件中。

读出zip中的内容

很简单，zipfile 对象提供了一个read(name)的方法。name为 zip文件中的一个文件入口，执行完成之后，将返回读出的内容，你把它保存到想到的文件中即可。

写入zip文件

有两种方式，一种是直接写入一个已经存在的文件，另一种是写入一个字符串。

对 于第一种使用 zipfile 对象的 write(filename, arcname, compress_type)，后两个参数是可以忽略的。第一个参数是文件名，第二个参数是表示在 zip 文件中的名字，如果没有给出，表示使用与filename一样的名字。compress_type是压缩标志，它可以覆盖创建 zipfile 时的参数。第二种是使用 zipfile 对象的 writestr(zinfo_or_arcname, bytes)，第一个参数是zipinfo 对象或写到压缩文件坦举中的压缩名，第二个参数是字符串。使用这个方法可以动态的组织文件的内容。

需要注羡信敬意的是在读出时，因为只能读出内容兄慎，因此如果想实现按目录结构展开 zip 文件的话，这些 *** 作需要自已来完成，比如创建目录，创建文件并写入。而写入时，则可以根据需要动态组织在 zip 文件中的目录结构，这样可以不按照原来的目录结构来生成 zip 文件。

于是我为了方便使用，创建了自已的一个 ZFile 类，主要是实现象 winrar 的右键菜单中的压缩到的功能--即将一个zip文件压缩到指定目录，自动创建相应的子目录。再有就是方便生成 zip 文件。类源码为：

# coding:cp936

# Zfile.py

# xxteach.com

import zipfile

import os.path

import os

class ZFile(object):

def __init__(self, filename, mode='r', basedir=''):

self.filename = filename

self.mode = mode

if self.mode in ('w', 'a'):

self.zfile = zipfile.ZipFile(filename, self.mode, compression=zipfile.ZIP_DEFLATED)

else:

self.zfile = zipfile.ZipFile(filename, self.mode)

self.basedir = basedir

if not self.basedir:

self.basedir = os.path.dirname(filename)

def addfile(self, path, arcname=None):

path = path.replace('//', '/')

if not arcname:

if path.startswith(self.basedir):

arcname = path[len(self.basedir):]

else:

arcname = ''

self.zfile.write(path, arcname)

def addfiles(self, paths):

for path in paths:

if isinstance(path, tuple):

self.addfile(*path)

else:

self.addfile(path)

def close(self):

self.zfile.close()

def extract_to(self, path):

for p in self.zfile.namelist():

self.extract(p, path)

def extract(self, filename, path):

if not filename.endswith('/'):

f = os.path.join(path, filename)

dir = os.path.dirname(f)

if not os.path.exists(dir):

os.makedirs(dir)

file(f, 'wb').write(self.zfile.read(filename))

def create(zfile, files):

z = ZFile(zfile, 'w')

z.addfiles(files)

z.close()

def extract(zfile, path):

z = ZFile(zfile)

z.extract_to(path)

z.close()

import java.io.BufferedInputStream

import java.io.BufferedReader

import java.io.File

import java.io.FileInputStream

import java.io.FileNotFoundException

import java.io.FileOutputStream

import java.io.IOException

import java.io.InputStreamReader

import java.io.OutputStream

import java.util.ArrayList

import java.util.List

import java.util.zip.ZipEntry

import java.util.zip.ZipInputStream

import java.util.zip.ZipOutputStream

public class JZip {

public static int iCompressLevel//压缩比 取值范围为0~9

public static boolean bOverWrite//是否覆盖同名文件 取值范旁袜围为True和False

@SuppressWarnings("unchecked")

private static ArrayList AllFiles = new ArrayList()

public static String sErrorMessage

private String zipFilePath

public List<File>srcMap

public JZip () {

iCompressLevel = 9

//bOverWrite=true

}

public JZip(String zipFilePath) throws FileNotFoundException, IOException {

this.zipFilePath = zipFilePath

}

@SuppressWarnings("unchecked")

public static ArrayList extract (String sZipPathFile , String sDestPath) {

ArrayList AllFileName = new ArrayList()

try {

//先指定压缩档的雹启判位置和档名,建立FileInputStream对象

FileInputStream fins = new FileInputStream(sZipPathFile)

//将源改fins传入ZipInputStream中

ZipInputStream zins = new ZipInputStream(fins)

ZipEntry ze = null

byte ch[] = new byte[256]

while ((ze = zins.getNextEntry()) != null) {

File zfile = new File(sDestPath + ze.getName())

File fpath = new File(zfile.getParentFile().getPath())

if (ze.isDirectory()) {

if (!zfile.exists())

zfile.mkdirs()

zins.closeEntry()

} else {

if (!fpath.exists())

fpath.mkdirs()

FileOutputStream fouts = new FileOutputStream(zfile)

int i

AllFileName.add(zfile.getAbsolutePath())

while ((i = zins.read(ch)) != -1)

fouts.write(ch, 0, i)

zins.closeEntry()

fouts.close()

}

}

fins.close()

zins.close()

sErrorMessage = "OK"

} catch (Exception e) {

System.err.println("Extract error:" + e.getMessage())

sErrorMessage = e.getMessage()

}

AllFiles.clear()

return AllFileName

}

@SuppressWarnings({ "unchecked", "static-access" })

public static void compress (String sPathFile , boolean bIsPath , String sZipPathFile) {

try {

String sPath

//先指定压缩档的位置及档名，建立一个FileOutputStream

FileOutputStream fos = new FileOutputStream(sZipPathFile)

//建立ZipOutputStream并将fos传入

ZipOutputStream zos = new ZipOutputStream(fos)

//设置压缩比

zos.setLevel(iCompressLevel)

if (bIsPath == true) {

searchFiles(sPathFile)

sPath = sPathFile

} else {

File myfile = new File(sPathFile)

sPath = sPathFile.substring(0, sPathFile.lastIndexOf(myfile.separator) + 1)

AllFiles.add(myfile)

}

Object[] myobject = AllFiles.toArray()

ZipEntry ze = null

//每个档案要压缩，都要透过ZipEntry来处理

FileInputStream fis = null

BufferedReader in = null

//byte[] ch = new byte[256]

for (int i = 0 i <myobject.length i++) {

File myfile = (File) myobject[i]

if (myfile.isFile()) {

in = new BufferedReader(new InputStreamReader(new FileInputStream(myfile.getPath()),"iso8859-1"))

//以档案的名字当Entry，也可以自己再加上额外的路径

//例如　ze=new ZipEntry("test\\"+myfiles[i].getName())

//如此压缩档内的每个档案都会加test这个路径

ze = new ZipEntry(myfile.getPath().substring((sPath).length()))

//将ZipEntry透过ZipOutputStream的putNextEntry的方式送进去处理

fis = new FileInputStream(myfile)

zos.putNextEntry(ze)

int len = 0

//开始将原始档案读进ZipOutputStream

while ((len = in.read()) != -1) {

zos.write(len)

}

fis.close()

zos.closeEntry()

}

}

zos.close()

fos.close()

AllFiles.clear()

sErrorMessage = "OK"

} catch (Exception e) {

System.err.println("Compress error:" + e.getMessage())

sErrorMessage = e.getMessage()

}

}

/*

这是一个递归过程，功能是检索出所有的文件名称

dirstr:目录名称

*/

@SuppressWarnings("unchecked")

private static void searchFiles (String dirstr) {

File tempdir = new File(dirstr)

if (tempdir.exists()) {

if (tempdir.isDirectory()) {

File[] tempfiles = tempdir.listFiles()

for (int i = 0 i <tempfiles.length i++) {

if (tempfiles[i].isDirectory())

searchFiles(tempfiles[i].getPath())

else {

AllFiles.add(tempfiles[i])

}

}

} else {

AllFiles.add(tempdir)

}

}

}

public String getZipFilePath() {

return zipFilePath

}

public void setZipFilePath(String zipFilePath) {

this.zipFilePath = zipFilePath

}

/**

* 解析zip文件得到文件名

* @return

* @throws FileNotFoundException

* @throws IOException

*/

public boolean parserZip() throws FileNotFoundException, IOException {

FileInputStream fis = new FileInputStream(zipFilePath)

ZipInputStream zis = new ZipInputStream(new BufferedInputStream(fis))

ZipEntry entry

try {

srcMap = new ArrayList<File>()

while ((entry = zis.getNextEntry()) != null) {

File file = new File(zipFilePath + File.separator + entry.getName())

srcMap.add(file)

}

zis.close()

fis.close()

return true

} catch (IOException e) {

return false

}

}

/**

*

* @param zipFileName 待解压缩的ZIP文件

* @param extPlace 解压后的文件夹

*/

public static void extZipFileList(String zipFileName, String extPlace) {

try {

ZipInputStream in = new ZipInputStream(new FileInputStream(

zipFileName))

File files = new File(extPlace)

files.mkdirs()

ZipEntry entry = null

while ((entry = in.getNextEntry()) != null) {

String entryName = entry.getName()

if (entry.isDirectory()) {

File file = new File(files + entryName)

file.mkdirs()

System.out.println("创建文件夹:" + entryName)

} else {

OutputStream os = new FileOutputStream(files+File.separator + entryName)

// Transfer bytes from the ZIP file to the output file

byte[] buf = new byte[1024]

int len

while ((len = in.read(buf)) >0) {

os.write(buf, 0, len)

}

os.close()

in.closeEntry()

System.out.println("解压文件:" + entryName)

}

}

} catch (IOException e) {

}

}

@SuppressWarnings("static-access")

public static void main(String args[]){

}

}

---