❶ python如何从zip压缩包内过滤出指后缀文件

解决方案
import os
import fnmatch
import zipfile
import re
def iterfindfiles(path, fnexp):
for root, dirs, files in os.walk(path):
for filename in fnmatch.filter(files, fnexp):
yield os.path.join(root, filename)
result=""
for filelist in iterfindfiles("D:Temporary", "*.zip"):
z = zipfile.ZipFile(filelist, "r")
for file in z.namelist():
result=result+file+"n"
print "以下内容是压缩包所包含文件："
print result+"rn"
unicodepage=result.decode("utf-8")
myItems=re.findall("([wd]*?.txt)",unicodepage,re.S)
items=[]
print "以下是获取所有以.txt结束的文本"
for item in myItems:
items.append(item.replace("rn",""))
print items

❷ Python for 取ZIP函数值

zip() 方法返回的是一个zip对象不能使用迭代遍历，你把它改成 for i in list(k) 就可以了

❸ 如何通过Python压缩解压缩zip文件

解压缩

importzipfile
importos
defun_zip(file_name):
"""unzipzipfile"""
zip_file=zipfile.ZipFile(file_name)
ifos.path.isdir(file_name+"_files"):
pass
else:
os.mkdir(file_name+"_files")
fornamesinzip_file.namelist():
zip_file.extract(names,file_name+"_files/")
zip_file.close()

打包

zipfile.ZipFile('xxx.zip','a/w/x').write('xxx.txt')

'w'以截断并写入新文件'a'以附加到现有文件，或'x'以专门创建和写入新文件。

❹ python中zip函数有哪些高级用法

zip() 功能是从参数的多个迭代器中选取元素组合成一个新的迭代器。顾名思义，它就是一个将对象进行打包和解包的函数。

它可以传入的参数包括；元组、列表、字典等迭代器

它返回一个zip对象，其内部元素为元组，一组一组的，可以转化为列表或元组，这里要强调一下，Python2和Python3中返回的zip对象有所不同。

Python3中zip()函数再不再返回list对象，但是可以通过list强行转换。（类似的函数变化还有dictionary关联的keys()、values()、items()，map()，filter()）。

打包zip(iterables)

上面的代码使用的环境是Python3.6，其中list (z)操作就是强制转换。注意一个问题，a和b这两个列表是不同长短的，这时候zip函数就会匹配完最短的那个便结束。

当zip函数的参数只有一个时，它将从iterable中依次取一个元素，组成一个元组。

解包zip(*iterables)

解包，zip 相反，可理解为解压，返回多维矩阵形式，有几个组元素就返回几维的。

比如，下面我是用三个列表组合起来的迭代式，那么解压后就返回三维的矩阵

zip高级用法

讲完了基本的再来说一下该函数的高级用法。高级用法离不开一个词：Pythonic，就是将代码写的更优雅美观，看起来有逼格！

1. 列表推导

例如：

a = [1,2,3,4]
b = [5,6,7,8]

我们要同时遍历a、b，且要对它们进行操作，那就要放在同一个for循环内，zip函数正好合适

注意：如果是Python2环境中，要使用izip才能提高效率。

当然，如果你需要对下标进行操作，那么还需要加上enumerate函数

2. 使用zip创建键值对，zip方法返回的是一个元组，用它来创建键值对，简单明了。

❺ python怎样压缩和解压缩ZIP文件

1、说明

python使用zipfile模块来压缩和解压zip文件

2、代码

importos,os.path
importzipfile

defzip_dir(dirname,zipfilename):
filelist=[]
ifos.path.isfile(dirname):
filelist.append(dirname)
else:
forroot,dirs,filesinos.walk(dirname):
fornameinfiles:
filelist.append(os.path.join(root,name))

zf=zipfile.ZipFile(zipfilename,"w",zipfile.zlib.DEFLATED)
fortarinfilelist:
arcname=tar[len(dirname):]
#printarcname
zf.write(tar,arcname)
zf.close()


defunzip_file(zipfilename,unziptodir):
ifnotos.path.exists(unziptodir):os.mkdir(unziptodir)
zfobj=zipfile.ZipFile(zipfilename)
fornameinzfobj.namelist():
name=name.replace('\','/')

ifname.endswith('/'):
os.mkdir(os.path.join(unziptodir,name))
else:
ext_filename=os.path.join(unziptodir,name)
ext_dir=os.path.dirname(ext_filename)
ifnotos.path.exists(ext_dir):os.mkdir(ext_dir)
outfile=open(ext_filename,'wb')
outfile.write(zfobj.read(name))
outfile.close()

if__name__=='__main__':
zip_dir(r'd:/python/test',r'd:/python/test.zip')
unzip_file(r'd:/python/test.zip',r'd:/python/test2')

执行结果

顺利生成相应文件

3、备注

zip文件格式是通用的文档压缩标准，在zipfile模块中，使用ZipFile类来操作zip文件，下面具体介绍一下：
class zipfile.ZipFile(file[, mode[, compression[, allowZip64]]])

创建一个ZipFile对象，表示一个zip文件。参数file表示文件的路径或类文件对象(file-like object)；参数mode指示打开zip文件的模式，默认值为'r'，表示读已经存在的zip文件，也可以为'w'或'a'，'w'表示新建一个zip文档或覆盖一个已经存在的zip文档，'a'表示将数据附加到一个现存的zip文档中。参数compression表示在写zip文档时使用的压缩方法，它的值可以是zipfile. ZIP_STORED 或zipfile. ZIP_DEFLATED。如果要操作的zip文件大小超过2G，应该将allowZip64设置为True。

ZipFile还提供了如下常用的方法和属性：
ZipFile.getinfo(name):

获取zip文档内指定文件的信息。返回一个zipfile.ZipInfo对象，它包括文件的详细信息。将在下面 具体介绍该对象。
ZipFile.infolist()

获取zip文档内所有文件的信息，返回一个zipfile.ZipInfo的列表。
ZipFile.namelist()

获取zip文档内所有文件的名称列表。
ZipFile.extract(member[, path[, pwd]])

❻ python zip 变成元组数组之后如何解压

解压缩

import zipfile import osdef un_zip(file_name): """unzip zip file""" zip_file = zipfile.ZipFile(file_name) if os.path.isdir(file_name + "_files"): pass else: os.mkdir(file_name + "_files") for names in zip_file.namelist(): zip_file.extract(names,file_name + "_files/") zip_file.close()

打包

1

zipfile.ZipFile('xxx.zip','a/w/x').write('xxx.txt')

'w'以截断并写入新文件'a'以附加到现有文件，或'x'以专门创建和写入新文件。

❼ python zip函数的用法

定义：zip([iterable, ...])
zip()是Python的一个内建函数，它接受一系列可迭代的对象作为参数，将对象中对应的元素打包成一个个tuple（元组），然后返回由这些 tuples组成的list（列表）。若传入参数的长度不等，则返回list的长度和参数中长度最短的对象相同。利用*号操作符，可以将list unzip（解压），看下面的例子就明白了：
1 2 3 4 5 6 7 8 9
>>> a = [1,2,3] >>> b = [4,5,6] >>> c = [4,5,6,7,8] >>> zipped = zip(a,b) [(1, 4), (2, 5), (3, 6)] >>> zip(a,c) [(1, 4), (2, 5), (3, 6)] >>> zip(*zipped) [(1, 2, 3), (4, 5, 6)]

对于这个并不是很常用函数，下面举几个例子说明它的用法：

* 二维矩阵变换（矩阵的行列互换）
比如我们有一个由列表描述的二维矩阵
a = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
通过python列表推导的方法，我们也能轻易完成这个任务
1 2
print [ [row[col] for row in a] for col in range(len(a[0]))] [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

另外一种让人困惑的方法就是利用zip函数：
1 2 3 4 5
>>> a = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] >>> zip(*a) [(1, 4, 7), (2, 5, 8), (3, 6, 9)] >>> map(list,zip(*a)) [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

这种方法速度更快但也更难以理解，将list看成tuple解压，恰好得到我们“行列互换”的效果，再通过对每个元素应用list()函数，将tuple转换为list
* 以指定概率获取元素
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
>>> import random >>> def random_pick(seq,probabilities): x = random.uniform(0, 1) cumulative_probability = 0.0 for item, item_probability in zip(seq, probabilities): cumulative_probability += item_probability if x < cumulative_probability: break return item >>> for i in range(15): random_pick("abc",[0.1,0.3,0.6]) 'c' 'b' 'c' 'c' 'a' 'b' 'c' 'c' 'c' 'a' 'b' 'b' 'c' 'a' 'c'

这个函数有个限制，指定概率的列表必须和元素一一对应，而且和为1，否则这个函数可能不能像预想的那样工作。
稍微解释下，先利用random.uniform()函数生成一个0-1之间的随机数并复制给x，利用zip()函数将元素和他对应的概率打包成tuple，然后将每个元素的概率进行叠加，直到和大于x终止循环
这样，”a”被选中的概率就是x取值位于0-0.1的概率，同理”b”为0.1-0.4，”c”为0.4-1.0，假设x是在0-1之间平均取值的，显然我们的目的已经达到

❽ Python版本3.3有zip这个用法吗

当然是有的！下面具体分析不同：

zip方法在Python 2 和Python 3中的不同

为何有这种不同
更多注解

问题一：zip方法在Python 2 和Python 3中的不同
Python 2 的代码演示：
$ python2
>>> a = zip((1, 2), (3, 4))
>>> a
[(1, 2), (3, 4)]
# 可以看到这里返回的是一个list

Python 3 的代码演示：
$ python3
>>> a = zip((1, 2), (3, 4))
>>> a
<zip object at 0x1007096c8>
# 可以看到这里返回的是一个对象，这里就是2和3的不同点
>>> dir(a) # 查看a的相关属性
['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__lt__', '__ne__', '__new__', '__next__', '__rece__', '__rece_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
# 这里值得注意的是 '__iter__' 和 '__next__' 方法，说明a是一个支持遍历的对象
# 既然知道了a是一个支持遍历的对象，我们也就基本明白了a的用法了
### 和Python2的区别（一）：返回的是一个支持遍历的对象，而不是一个list本身
>>> for i in a: print i # in 方法
...
(1, 3)
(2, 4)
>>> next(a) # 我们测试__next__方法
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
StopIteration # 说明next方法是支持的，但是这里也说明了对象只能遍历一次
>>> a = zip((1, 2), (3, 4)) # 这里需要重新赋值，因为这个对象只能遍历一次
>>> next(a)
(1, 3) # 运行良好
### 返回的对象支持遍历的操作

问题二：为何有这种不同
我想最重要的原因是节约了不少的内存吧。Python的运行效率和编译类型的语言自然是没法比，但是能优化就优化一点吧~谁不想有更高的追求呢。
问题三：更多注解
这个zip在不同版本的不同反应了python的一个演变：大部分返回list的函数不在返回list，而是返回一个支持遍历的对象，比如map、fiter之类的，基本的例子如下：
$ python3
>>> a = map(abs, [1, 2, -3])
>>> a
<map object at 0x100707ed0>
>>> list(a) # 如果不习惯，可以自己手动转化为list，也是写兼容代码需要注意的地方
[1, 2, 3]

$ python2
>>> a = map(abs, [1, 2, -3])
>>> a
[1, 2, 3]

❾ 如何通过python代码解压zip包

defunzip_file(zip_src,dst_dir):
r=zipfile.is_zipfile(zip_src)
ifr:
fz=zipfile.ZipFile(zip_src,'r')
forfileinfz.namelist():
fz.extract(file,dst_dir)
else:
print('Thisisnotzip')
#zip_src:是zip文件的全路径

#dst_dir：是要解压到的目的文件夹

以上代码是Python3中的内实现方容式,谢谢