5

我正在尝试 elementwise & 和 elementwise | 2 个 8 个 6 个二进制数字列表的列表，它的工作非常奇怪。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])

排序：

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 的其他输入可能会比第一个子列表更混乱。

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

4

5 回答 5

22

你可以只使用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
于 2013-04-16T18:25:17.153 回答
11

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

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)])
于 2013-04-16T18:27:07.797 回答
2

你总是可以推出自己的课程：

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)]
于 2013-04-16T19:11:29.187 回答
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))
>>> 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]]
>>>

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

于 2013-04-16T18:23:30.250 回答
0 
def bitwise(a, b, core): 
  return [int(core(pred, true)) for pred, true in zip(pred_list, true_list)]


pred_list = [1, 1, 0, 0]   # prediction
true_list = [1, 0, 1, 0]   # true

print("| true pos")
true_positive = bitwise(pred_list, true_list, lambda pred, true: pred==1 and true==1) 
print(true_positive)

这是我的 F_Score 的一部分。

于 2022-01-07T20:23:00.397 回答