python 实现两个list列表逐元素相减，实现合并两个列表，以及zip() 函数介绍

约定不等于承诺〃 2022-01-24 00:11 2529阅读 0赞

### python 实现两个list列表逐元素相减，实现合并两个列表，以及zip() 函数介绍 ###

### （1）python 两个相同长度得list列表逐个对应元素相减 ###

Python中的列表中的元素不能直接相加减，但是可以采用如下方法实现目的：

1）循环相减：

> a = \[1,2,3,4,5\]
> 
> b = \[5,4,3,2,1\]
> 
> c = \[a\[i\]+b\[i\] for i in range(0,len(a))\] \#range后还可以加if条件筛选
> 
> print(c)
> 
> \# print: \[-4, -2, 0, 2, 4\]

2）最佳的方式是将列表转换成Python中的科学计算包numpy包的array类型，再进行加减。

> >>> import numpy
> 
> >>> a = \[1, 2, 3, 4\]
> 
> >>> b = \[5, 6, 7, 8\]
> 
> >>> a\_array = numpy.array(a)
> 
> >>> b\_array = numpy.array(b)
> 
> >>> c\_array = a\_array + b\_array
> 
> >>> d\_array = a\_array - b\_array
> 
> >>> c\_array
> 
> array(\[ 6, 8, 10, 12\])
> 
> >>> d\_array
> 
> array(\[-4, -4, -4, -4\])

3）通过zip函数实现相加，打包和解压

> Help on built-in function zip in module \_\_builtin\_\_:
> 
> zip(...)
> 
> zip(seq1 \[, seq2 \[...\]\]) -> \[(seq1\[0\], seq2\[0\] ...), (...)\]
> 
> Return a list of tuples, where each tuple contains the i-th element
> 
> from each of the argument sequences. The returned list is truncated
> 
> in length to the length of the shortest argument sequence.

例子：

> >>> v1 = \[21, 34, 45\]
> 
> >>> v2 = \[55, 25, 77\]
> 
> >>> v = list(map(lambda x: x\[0\]-x\[1\], zip(v2, v1)))
> 
> >>> v
> 
> \[34, -9, 32\]
> 
> >>> print("%s\\n%s\\n%s" %(v1, v2, v))
> 
> \[21, 34, 45\]
> 
> \[55, 25, 77\]
> 
> \[34, -9, 32\]

实现打包和解压的例子：

> >>> a = \[1,2,3\]
> 
> >>> b = \[4,5,6\]
> 
> >>> zipped = zip(a,b)  \# 打包为元组的列表
> 
> >>> zipped
> 
> \[(1, 4), (2, 5), (3, 6)\]
> 
> >>> zip(\*zipped) \# 与 zip 相反，可理解为解压
> 
> \[(1, 2, 3), (4, 5, 6)\]

### （2）python合并两个列表得方法： ###

python 列表相加可以有两种方法实现：

1 利用操作符+

比如：

> a = \[1,2,3\]
> 
> b = \[4,5,6\]
> 
> c = a+b
> 
> c的结果：\[1,2,3,4,5,6\]

2 利用extend

比如：

> a = \[1,2,3\]
> 
> b = \[4,5,6\]
> 
> a.extend(b)
> 
> a的结果：\[1,2,3,4,5,6\]

结果是一样的，但是+号生成的是一个新的对象，而extend则是在原地的修改a对象。

另外注意：列表的append方法，是往列表中添加新元素

比如：

a = \[1,2,3\]

a.append(4) \#后面跟的是元素类型

a的结果为：\[1,2,3,4\]

### （3）python zip函数介绍 ###

zip() 函数用于将可迭代对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象。

如果各个可迭代对象的元素个数不一致，则返回的对象长度与最短的可迭代对象相同。

利用 \* 号操作符，与zip相反，进行解压。

zip() 函数语法：

> zip(iterable1,iterable2, ...)
> 
> 参数说明： iterable -- 一个或多个可迭代对象（字符串、列表、元祖、字典）

以下实例展示了 zip() 函数的使用方法：

> Python2中：
> 
> >>>a = \[1,2,3\] \#此处可迭代对象为列表  
> >>> b = \[4,5,6\]  
> >>> c = \[4,5,6,7,8\]  
> >>> zipped = zip(a,b)     \# 打包为元组的列表  
> >>> zipped  
> \[(1, 4), (2, 5), (3, 6)\]  
> >>> zip(a,c)              \# 元素个数与最短的列表一致  
> \[(1, 4), (2, 5), (3, 6)\]  
> >>> zip(\*zipped)          \# 与 zip 相反，可理解为解压  
> \[(1, 2, 3), (4, 5, 6)\]
> 
> Python3中：
> 
> >>> a = \[1,2,3\] \#此处可迭代对象为列表  
> >>> b = \[4,5,6\]  
> >>> c = \[4,5,6,7,8\]  
> >>> zipped = zip(a,b)  
> >>> zipped  
> <zip object at 0x02B01B48> \#返回的是一个对象  
> >>> list(zipped)  
> \[(1, 4), (2, 5), (3, 6)\] \#使用list()函数转换为列表  
> >>> list(zip(a,c))  
> \[(1, 4), (2, 5), (3, 6)\]  
> >>> zipped = zip(a,b)  
> >>> list(zip(\*zipped)) \#解压也使用list进行转换  
> \[(1, 2, 3), (4, 5, 6)\]  
>  
> 
> \#!/usr/bin/python3  
> \#v1,v2,v3可是是任何可迭代对象，如：字符串、列表、元祖、字典  
> v1 = \{1:11,2:22\} \#此处可迭代对象为字典  
> v2 = \{3:33,4:44\}  
> v3 = \{5:55,6:66\}  
>    
> v = zip(v1,v2,v3)   \#压缩  
> print(list(v))  
>    
> w = zip(\*zip(v1,v2,v3)) \#解压  
> print(list(w))
> 
> 结果：  
> \[(1, 3, 5), (2, 4, 6)\]  
> \[(1, 2), (3, 4), (5, 6)\]
> 
>   
> 搭配for循环支持并行迭代：  
> \#!/usr/bin/python3  
> list1 = \[2,3,4\]  
> list2 = \[4,5,6\]  
>    
> for x,y in zip(list1,list2):  
>     print(x,y,'--',x\*y)
> 
> 结果：  
> 2 4 -- 8  
> 3 5 -- 15  
> 4 6 -- 24

原文：https://blog.csdn.net/weixin\_42350212/article/details/80628539                      
           https://www.cnblogs.com/wushuaishuai/p/7766470.html