zip函数
打包
解包

打包
zip()函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同
list1 = [1,2,3,4,5]
list2 = ["hello","good","nice","haha"]
set3 = {True,False,None,0}
zipobj = zip(list1,list2,set3)  # 打包

print(zipobj) # 这是一个包,显示的是包所在的地址 <zip object at 0x00000149CFFFAB48>

print(list(zipobj)) #可以将包转化为列表,查看包中的内容 

# 打印结果为 [(1, 'hello', False), (2, 'good', True), (3, 'nice', None)]

对于打印的结果，或许多多少少都会有一些疑惑，这里逐一进行解释
1、为什么列表中的元组只有3个？
首先看一下 set3，这是一个set集合，set集合有两个特点：去重、无序。
打印一下 set3，会发现，得到的结果是{False, True, None}，因为在这里，0=False，所以 set3里，其实只有三个元素。

虽然set集合是无序的，但是底层代码逻辑，还是以某种规则对元素内容进行了排序，False就排到了True前面，这一点就不再详细进行说明。
2、打包的具体过程

首先在list1中取出元素1，在list2中取出元素hello，在set3中取出元素False,组成了第一个元组(1, 'hello', False)；
然后在list1中取出元素2，在list2中取出元素good，在set3中取出元素True,组成了第二个元组(2, 'good', True)；
在list1中取出元素3，在list2中取出元素nice，在set3中取出元素None,组成了第三个元组(3, 'nice', None)；
set3里只有三个元素，所以，list1和list2中剩余的元素就被舍弃，最后，将三个元组放入列表中，[(1, 'hello', False), (2, 'good', True), (3, 'nice', None)]，最终打包完成。


解包
zip()函数可以对 zip对象进行解包处理
语法：zip(*zipobj)
list1 = [1,2,3,4,5]
list2 = ["hello","good","nice","haha"]
set3  = {True,False,None,0}

zipobj = zip(list1,list2,set3 ) # 打包

print(zip(*zipobj)) #解包 显示的也是一串地址 <zip object at 0x000001B34E5FAB88>

# 若想查看解包的内容,可使用for循环打印(需将上一步print注释,因为上一步中已经解包)
for i in zip(*zipobj):
    print(i)
    
# 打印结果
(1, 2, 3)
('hello', 'good', 'nice')
(False, True, None)

上面已经详细描述了打包的过程，而解包，其实就是将打包的过程逆转。最终打包的结果是[(1, 'hello', False), (2, 'good', True), (3, 'nice', None)]

列表中有三个元组，第一个元组(1, 'hello', False)，第二个元组(2, 'good', True)，第三个元组(3, 'nice', None)。
将第一个元组中的1取出，第二个元组中的2取出，第三个元组中的3取出，重新组成第一个新的元组(1, 2, 3)；
将第一个元组中的hello取出，第二个元组中的good取出，第三个元组中的nice取出，重新组成第二个新的元组('hello', 'good', 'nice')；
将第一个元组中的False取出，第二个元组中的True取出，第三个元组中的None取出，重新组成第三个新的元组(1, 2, 3)；
最后，通过for循环，将三个新的元组打印出来

zip函数接受任意多个序列作为参数，将所有序列按相同的索引组合成一个元素是各个序列合并成的tuple的新序列，新的序列的长度以参数中最短的序列为准。另外(*)操作符与zip函数配合可以实现与zip相反的功能，即将合并的序列拆成多个tuple。

①tuple的新序列
>>>>x=[1,2,3],y=['a','b','c']
>>>zip(x,y)
[(1,'a'),(2,'b'),(3,'c')]

②新的序列的长度以参数中最短的序列为准.
>>>>x=[1,2],y=['a','b','c']
>>>zip(x,y)
[(1,'a'),(2,'b')]

③(*)操作符与zip函数配合可以实现与zip相反的功能,即将合并的序列拆成多个tuple。
>>>>x=[1,2,3],y=['a','b','c']
>>>>zip(*zip(x,y))
[(1,2,3),('a','b','c')]

 

zip函数详解
zip() 函数创建的是一个只能访问一次的迭代器。
prices = {
    'ACME': 45.23,
    'AAPL': 612.78,
    'IBM': 205.55,
    'HPQ': 37.20,
    'FB': 10.75
}
p = zip(prices.values(), prices.keys())
print(max(p))
print('==============')
print(min(p))


输出
(612.78, 'AAPL')
Traceback (most recent call last):
==============
  File "C:/Users/Administrator/Desktop/hzw/app/tests.py", line 10, in <module>
    print(min(p))
ValueError: min() arg is an empty sequence

zip对象的排序方式，是按照第一个参数排序的

使用场景

求字典某个字段的最小值

例子

翻转prices并使用zip函数封装成zip对象再培训
prices = {
    'ACME': 45.23,
    'AAPL': 612.78,
    'IBM': 205.55,
    'HPQ': 37.20,
    'FB': 10.75
}
p = zip(prices.values(), prices.keys())
#print(max(p))
print(min(p))

转载自：http://www.cnblogs.com/frydsh/archive/2012/07/10/2585370.html
Python的zip函数
zip函数接受任意多个（包括0个和1个）序列作为参数，返回一个tuple列表。具体意思不好用文字来表述，直接看示例：
1.示例1：
x = [1, 2, 3]

y = [4, 5, 6]

z = [7, 8, 9]

xyz = zip(x, y, z)

print xyz
运行的结果是：
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
从这个结果可以看出zip函数的基本运作方式。
2.示例2：
x = [1, 2, 3]
y = [4, 5, 6, 7]
xy = zip(x, y)
print xy
运行的结果是：
[(1, 4), (2, 5), (3, 6)]
从这个结果可以看出zip函数的长度处理方式。
3.示例3：
x = [1, 2, 3]
x = zip(x)
print x
运行的结果是：
[(1,), (2,), (3,)]
从这个结果可以看出zip函数在只有一个参数时运作的方式。
4.示例4：
x = zip()
print x
运行的结果是：
[]
从这个结果可以看出zip函数在没有参数时运作的方式。
5.示例5：
x = [1, 2, 3]

y = [4, 5, 6]

z = [7, 8, 9]

xyz = zip(x, y, z)

u = zip(*xyz)

print u
运行的结果是：
[(1, 2, 3), (4, 5, 6), (7, 8, 9)]
一般认为这是一个unzip的过程，它的运行机制是这样的：
在运行zip(*xyz)之前，xyz的值是：[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
那么，zip(*xyz) 等价于 zip((1, 4, 7), (2, 5, 8), (3, 6, 9))
所以，运行结果是：[(1, 2, 3), (4, 5, 6), (7, 8, 9)]
注：在函数调用中使用*list/tuple的方式表示将list/tuple分开，作为位置参数传递给对应函数（前提是对应函数支持不定个数的位置参数）
6.示例6：
x = [1, 2, 3]
r = zip(* [x] * 3)
print r
运行的结果是：
[(1, 1, 1), (2, 2, 2), (3, 3, 3)]
它的运行机制是这样的：
[x]生成一个列表的列表，它只有一个元素x
[x] * 3生成一个列表的列表，它有3个元素，[x, x, x]
zip(* [x] * 3)的意思就明确了，zip(x, x, x)