Question

我正在尝试元素和＆amp;和elementwise | 2个列表中有8个二进制数字的8个列表，它的工作非常奇怪。 c1和c2以长度为8的元组开头，元素为长度为6的元组，res以c1的列表形式开始。

安定：

for x in range(8):
    for y in range(6):
        res[x][y] = (c1[:][x][y])*(c2[:][x][y])

O形环：

for x in range(8):
    for y in range(6):
        res[x][y] = int(c1[:][x][y] or c2[:][x][y])

一个例子：

c1:        ((1, 0, 0, 0, 1, 1), (1, 1, 0, 0, 0, 1), (1, 1, 1, 0, 0, 0), (0, 1, 1, 1, 1, 0), (1, 0, 0, 0, 1, 1), (0, 1, 1, 0, 0, 0), (1, 1, 0, 1, 0, 0), (0, 1, 0, 0, 1, 0))
c2:        ((1, 0, 1, 1, 0, 0), (0, 1, 0, 1, 1, 0), (0, 1, 1, 0, 1, 0), (0, 0, 0, 0, 1, 1), (1, 1, 0, 0, 1, 0), (1, 0, 1, 0, 1, 0), (0, 0, 0, 1, 0, 1), (0, 0, 1, 0, 1, 0))
anding res:[[1, 0, 0, 0, 1, 0], [0, 1, 0, 0, 0, 0], [0, 1, 1, 0, 0, 0], [0, 0, 0, 0, 1, 0], [1, 0, 0, 0, 1, 0], [0, 0, 1, 0, 0, 0], [0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 1, 0]]
oring res: [[1, 1, 0, 0, 1, 1], [1, 1, 0, 1, 1, 1], [1, 1, 1, 0, 1, 0], [0, 1, 1, 1, 1, 1], [1, 1, 0, 0, 1, 1], [1, 1, 1, 0, 1, 0], [1, 1, 0, 1, 0, 1], [0, 1, 1, 0, 1, 0]]

c1的其他输入可以比第一个子列表更加混乱。

编辑：这已经解决了。这很可能是代码其他部分的别名问题，我最后使用了列表推导。

Answer 1

您可以使用NumPy：

In [7]: import numpy as np
In [8]: c1 = np.array(c1)    
In [9]: c2 = np.array(c2)

In [10]: c1 & c2
In [11]: c1 | c2

Answer 2

为什么不使用列表推导来简单地尝试这样的事情：

c1 = ((1, 0, 0, 0, 1, 1), (1, 1, 0, 0, 0, 1), (1, 1, 1, 0, 0, 0))
c2 = ((1, 0, 1, 1, 0, 0), (0, 1, 0, 1, 1, 0), (0, 1, 1, 0, 1, 0))

print('Bitwise or:  ', [[k | l for k, l in zip(i, j)] for i, j in zip(c1, c2)])
print('Bitwise and: ', [[k & l for k, l in zip(i, j)] for i, j in zip(c1, c2)])

Answer 3

对我来说似乎没问题：

>>> c1 =  ((1, 0, 0, 0, 1, 1), (1, 1, 0, 0, 0, 1), (1, 1, 1, 0, 0, 0), (0, 1, 1, 1, 1, 0), (1, 0, 0, 0, 1, 1), (0, 1, 1, 0, 0, 0), (1, 1, 0, 1, 0, 0), (0, 1, 0, 0, 1, 0))
>>> c2 =  ((1, 0, 1, 1, 0, 0), (0, 1, 0, 1, 1, 0), (0, 1, 1, 0, 1, 0), (0, 0, 0, 0, 1, 1), (1, 1, 0, 0, 1, 0), (1, 0, 1, 0, 1, 0), (0, 0, 0, 1, 0, 1), (0, 0, 1, 0, 1, 0))
>>> res = [[None]*6 for _ in range(8)]
>>> for x in range(8):
...     for y in range(6):
...         res[x][y] = c1[x][y] & c2[x][y]
... 
>>> print res
[[1, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0], [0, 1, 1, 0, 0, 0], [0, 0, 0, 0, 1, 0], [1, 0, 0, 0, 1, 0], [0, 0, 1, 0, 0, 0], [0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 1, 0]]
>>> for x in range(8):
...     for y in range(6):
...         res[x][y] = c1[x][y] | c2[x][y]
... 
>>> print res
[[1, 0, 1, 1, 1, 1], [1, 1, 0, 1, 1, 1], [1, 1, 1, 0, 1, 0], [0, 1, 1, 1, 1, 1], [1, 1, 0, 0, 1, 1], [1, 1, 1, 0, 1, 0], [1, 1, 0, 1, 0, 1], [0, 1, 1, 0, 1, 0]]
>>>

我使用&和|作为按位运算符，但它确实不应该有所不同，因为你只是使用1和0。我怀疑您初始化了res = [[None]*6]*8（或类似），导致您的某些子列表引用相同的列表。

Answer 4

你总是可以自己上课：

class BitList(list):
    def anditems(self,other):
        return [se & so for se,so in zip(self,other)]

    def oritems(self,other):
        return [se | so for se,so in zip(self,other)]    

    def xoritems(self,other):
        return [se ^ so for se,so in zip(self,other)]    

print BitList([1,1,0,0,1,1]).xoritems([1,1,1,1,1,1])
    # [0, 0, 1, 1, 0, 0]
print BitList([1,1,0,0,1,1]).oritems([1,1,1,1,1,1])
    # [1, 1, 1, 1, 1, 1]
print BitList([1,1,0,0,1,1]).anditems([1,1,1,1,1,1]) 
    # [1, 1, 0, 0, 1, 1]

然后单独处理嵌套的子列表：

c1=((1, 0, 0, 0, 1, 1), (1, 1, 0, 0, 0, 1), (1, 1, 1, 0, 0, 0), (0, 1, 1, 1, 1, 0), (1, 0, 0, 0, 1, 1), (0, 1, 1, 0, 0, 0), (1, 1, 0, 1, 0, 0), (0, 1, 0, 0, 1, 0))
c2=((1, 0, 1, 1, 0, 0), (0, 1, 0, 1, 1, 0), (0, 1, 1, 0, 1, 0), (0, 0, 0, 0, 1, 1), (1, 1, 0, 0, 1, 0), (1, 0, 1, 0, 1, 0), (0, 0, 0, 1, 0, 1), (0, 0, 1, 0, 1, 0))


print [BitList(t1).anditems(t2) for t1,t2 in zip(c1,c2)]
print [BitList(t1).oritems(t2) for t1,t2 in zip(c1,c2)]

Python：类似Bitwise的列表操作

4 个答案: