理解zip函数的工作流程

栏目: Python · 发布时间: 5年前

内容简介:本文试图对看下面的操作。

zip 函数是 Python 的内置函数,在拙作《 跟老齐学Python:轻松入门 》有一定的介绍,但是,考虑到那本书属于Python的入门读物,并没有讲太深。但是,并不意味着这个函数不能应用的很深入,特别是结合迭代器来理解此函数,会让人有豁然开朗的感觉。同时,能够巧妙地解决某些问题。

本文试图对 zip 进行深入探讨,同时兼顾对迭代器的理解。

一、理解zip函数

看下面的操作。

>>> list(zip([1, 2, 3], ['a', 'b', 'c']))
[(1, 'a'), (2, 'b'), (3, 'c')]
复制代码

[1, 2, 3]['a', 'b', 'c'] 是列表,所有列表都是可迭代的。这意味着可以一次返回一个元素。

zip函数最终得到一个zip对象——一个迭代器对象。而这个迭代器对象是由若干个元组组成的。

那么这些元组是如何生成的呢?

对照上面的代码,从开始算起。按照Python中的技术习惯,开始的那个元组是用0来计数的,即第0个。

  1. 第0个元组中索引为0的元素,来自于zip函数第0个参数( [1,2,3] )当前指针所指的值,刚开始读取,那就是1;
  2. 第0个元组中索引为1的元素,来自于zip函数中第1个参数( ['a', 'b', 'c'] )当前指针所指的值,也是刚刚开始读取,应该是a;于是组成了zip对象的第0个元组 (1, 'a')
  3. 第0个元组中索引为2的元素,来自于zip函数中第2个参数——没有第二个,上面的参数总共有0、1两个。那么这个元组就组建完毕了,也就没有索引为2的元素。接下来再组建下一个元组,按照这里的计数顺序应该是第1个元组。
  4. zip对象第1个元组中索引为0的元素,来自于zip函数第0个参数当前指针所指的值。注意,因为上次已经度去过1了,这时候对应的值是2。
  5. 同上面的道理,这时候指针所指的值是'b'。于是组成了zip对象第1个元组 (2, 'b')
  6. 如此重复,就得到了最终的结果。

请注意上面的叙述,如果把元组中的组成对象来源概括一句话,那就是: 元组中的第i个元素就来自于第i个参数中指针在当前所指的元素对象 ——请细细品味这句话的含义,后面有大用途。

对于 zip 函数,上面的过程,貌似“压缩”一样,那么,是否有反过程——解压缩。例如从上面示例的结果中分别恢复出来原来的两个对象。

有。一般认为是这这么做:

>>> result = zip([1, 2, 3], ["a", "b", "c"])
>>> c, v = zip(*result)
>>> print(c, v)
(1, 2, 3) ('a', 'b', 'c')
复制代码

这是什么原理。

result 应用的是一个迭代器对象,不过为了能够显示的明白,也可以理解为是 [(1, 'a'), (2, 'b'), (3, 'c')] 。接下来使用了 zip(*result) ,这里的符号 * 的作用是收集参数,在函数的参数中,有对此详细阐述(请参阅《跟老齐学Python:轻松入门》)。

>>> def foo(*a): print(a)
...
>>> lst = [(1,2), (3,4)]
>>> foo(*lst)
((1, 2), (3, 4))
>>> foo((1,2), (3,4))
((1, 2), (3, 4))
复制代码

仿照这个示例,就能明晰下面两个操作是等效的。

>>> lst = [(1, 'a'), (2, 'b'), (3, 'c')]
>>> zip(*lst)
<zip object at 0x104c8fb48>
>>> zip((1, 'a'), (2, 'b'), (3, 'c'))
<zip object at 0x104f27308>
复制代码

从返回的对象内存编码也可以看出,两个是同样的对象。

既然如此,我们就可以通过理解 zip((1, 'a'), (2, 'b'), (3, 'c')) 的结果产生过程来理解 zip(*lst) 了。而前者生成结果的过程前面已经阐述过了,此处不再赘述。

原来,所谓的“解压缩”和“压缩”,计算的方法是一样的。豁然开朗。

其它常用函数

除了 zip 函数,还有一个内置函数 iter ,它以可迭代对象为参数,会返回迭代器对象。

>>> iter([1, 2, 3, 4])
<list_iterator object at 0x7fa80af0d898>
复制代码

本质上, iter 函数调用参数的每个元素,然后借助于 __next__ 函数返回迭代器对象,并把结果集成到一个元组中。

内置函数 map 是另外一个返回迭代器对象的函数,它以只有一个参数的函数对象为参数,这个函数每次从可迭代对象中取一个元素。

>>> list(map(len, ['abc', 'de', 'fghi']))
[3, 2, 4]
复制代码

map 函数的执行原理是:用 __iter__ 函数调用第二个参数,并用 __next__ 函数返回执行结果。在上面的例子中, len 函数要调用后面的列表中的每个元素,并返回一个迭代器对象。

既然迭代器是可迭代的,就可以把 zip 返回的迭代器对象用到 map 函数的参数中了。例如,用下面的方式计算两个列表中对应元素的和。

>>> list(map(sum, zip([1, 2, 3], [4, 5, 6])))
[5, 7, 9]
复制代码

迭代器对象有两个主要功效,一是节省内存,而是提高执行效率。

典型问题

有一个列表,由一些正整数组成,如 [1, 2, 3, 4, 5, 6] ,写一个函数,函数的一个参数 n 表示要将列表中几个元素划为一组,假设n=2,则将两个元素为一组,最终返回 [(1, 2), (3, 4), (5, 6)]

如果用简单的方式,可以这样写此函数:

def naive_grouper(inputs, n):
    num_groups = len(inputs) // n
    return [tuple(inputs[i*n:(i+1)*n]) for i in range(num_groups)]
复制代码

测试一下,此函数能够如我们所愿那样工作。

>>> nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> naive_grouper(nums, 2)
[(1, 2), (3, 4), (5, 6), (7, 8), (9, 10)]
复制代码

但是,在上面的测试中,所传入的列表元素个数是比较小的,如果列表元素个数很多,比如有100万个。这就需要有比较大的内存了,否则无法执行运算。

但是,如果这样执行此程序:

def naive_grouper(inputs, n):
    num_groups = len(inputs) // n
    return [tuple(inputs[i*n:(i+1)*n]) for i in range(num_groups)]
 
for _ in naive_grouper(range(100000000), 10):
    pass
复制代码

把上面的程序保存为文件 naive.py 。可以用下面的指令,测量运行程序时所占用的内存空间和耗费的时长。注意,要确保你本地机器的内存至少5G。

$ time -f "Memory used (kB): %M\nUser time (seconds): %U" python3 naive.py
Memory used (kB): 4551872
User time (seconds): 11.04
复制代码

注意:Ubuntu系统中,你可能要执行 /usr/bin/time

把列表或者元素传入 naïve_grouper 函数,需要计算机提供4.5GB的内存空间,才能执行 range(100000000) 的循环。

如果采用迭代器对象,就会有很大变化了。

def better_grouper(inputs, n):
    iters = [iter(inputs)] * n
    return zip(*iters)
复制代码

这个简短的函数中,内涵还是很丰富的。所以我们要逐行解释。

表达式 [iters(inputs)] * n 创建一个迭代器对象,它包含了n个同样的列表对象。

下面以 n=2 为例说明。

>>> nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> iters = [iter(nums)] * 2
>>> list(id(itr) for itr in iters)  # 内存地址是一样的
[139949748267160, 139949748267160]
复制代码

iters 中的两个迭代器对象是同一个对象——认识到这一点非常重要。

结合前面对 zip 的理解, zip(*iters)zip(iter(nums), iter(nums)) 是一样的。为了能够以更直观的方式进行说明,就可以认为是 zip((1, 2, 3, 4, 5, 6, 7, 8, 9, 10), (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)) 。按照前文所述的 zip 工作流程,其计算过程如下:

(1, 2)
>>> nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> list(better_grouper(nums, 2))
[(1, 2), (3, 4), (5, 6), (7, 8), (9, 10)]
复制代码

上面的函数 better_grouper() 的优点在于:

len()

把上述流程保存为文件 better.py

def better_grouper(inputs, n):
    iters = [iter(inputs)] * n
    return zip(*iters)
  
for _ in better_grouper(range(100000000), 10):
    pass
复制代码

然后使用 time 在终端执行。

$ time -f "Memory used (kB): %M\nUser time (seconds): %U" python3 better.py
Memory used (kB): 7224
User time (seconds): 2.48
复制代码

对比前面执行 naive.py ,不论在内存还是执行时间上,都表现非常优秀。

进一步研究

对于上面的 better_grouper 函数,深入分析一下,发现它还有问题。它只能分割能够被列表长度整除的列表中的数字,如果不能整除的话,就会有一些元素被舍弃。例如:

>>> nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> list(better_grouper(nums, 4))
[(1, 2, 3, 4), (5, 6, 7, 8)]
复制代码

如果要4个元素一组,就会有9和10不能分组了。之所以,还是因为 zip 函数。

>>> list(zip([1, 2, 3], ['a', 'b', 'c', 'd']))
[(1, 'a'), (2, 'b'), (3, 'c')]
复制代码

最终得到的zip对象中的元组数量,是参数中长度最小的对象决定。

如果你感觉这样做不爽,可以使用 itertools.zip_longest() ,这个函数是以最长的参数为基准,如果有不足的,默认用 None 填充,当然也可以通过参数 fillvalue 指定填充对象。

>>> import itertools
>>> x = [1, 2, 3]
>>> y = ["a", "b", "c", "d"]
>>> list(itertools.zip_longest(x, y))
[(1, 'a'), (2, 'b'), (3, 'c'), (None, 'd')]
复制代码

那么,就可以将 better_grouper 函数中的 zipzip_longest() 替代了。

import itertools as it
  
def grouper(inputs, n, fillvalue=None):
    iters = [iter(inputs)] * n
    return it.zip_longest(*iters, fillvalue=fillvalue)
复制代码

再跑一下,就是这样的结果了。

>>> nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> print(list(grouper(nums, 4)))
[(1, 2, 3, 4), (5, 6, 7, 8), (9, 10, None, None)]
复制代码

《跟老齐学Python:轻松入门》


以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持 码农网

查看所有标签

猜你喜欢:

本站部分资源来源于网络,本站转载出于传递更多信息之目的,版权归原作者或者来源机构所有,如转载稿涉及版权问题,请联系我们

Java语言精粹

Java语言精粹

Jim Waldo / 王江平 / 电子工业出版社 / 2011-6 / 39.00元

这是一本几乎只讲java优点的书。 Jim Waldo先生是原sun微系统公司实验室的杰出工程师,他亲历并参与了java从技术萌生、发展到崛起的整个过程。在这《java语言精粹》里,jim总结了他所认为的java语言及其环境的诸多精良部分,包括:类型系统、异常处理、包机制、垃圾回收、java虚拟机、javadoc、集合、远程方法调用和并发机制。另外,他还从开发者的角度分析了在java技术周围......一起来看看 《Java语言精粹》 这本书的介绍吧!

CSS 压缩/解压工具
CSS 压缩/解压工具

在线压缩/解压 CSS 代码

RGB CMYK 转换工具
RGB CMYK 转换工具

RGB CMYK 互转工具

HEX CMYK 转换工具
HEX CMYK 转换工具

HEX CMYK 互转工具