（~）为什么我的比特没有翻转？

Question

我认为~应该把1变成0，反之亦然。我在代码中使用了它，但是我得到了-2和-1

def inverse_graph(graph):
    # for each vertex in graph
    revg = list(graph)
    for i, line in enumerate(revg):
        for j, vertex in enumerate(line):
            if  i != j:
                # flip value
                graph[i][j] = ~ graph[i][j]
                #if vertex == 0:
                #    graph[i][j] = 1;
                #else:
                #    graph[i][j] = 0;
    return revg



def test():
        g1 = [[0, 1, 1, 0],
              [1, 0, 0, 1],
              [1, 0, 0, 1],
              [0, 1, 1, 0]]
        assert inverse_graph(g1) == [[0, 0, 0, 1],
                                     [0, 0, 1, 0],
                                     [0, 1, 0, 0],
                                     [1, 0, 0, 0]]
        g2 = [[0, 1, 1, 1],
              [1, 0, 1, 1],
              [1, 1, 0, 1],
              [1, 1, 1, 0]]
        assert inverse_graph(g2) == [[0, 0, 0, 0],
                                     [0, 0, 0, 0],
                                     [0, 0, 0, 0],
                                     [0, 0, 0, 0]]

是的。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。你知道吗

Answer 1

正如xtofl所指出的，Python的整数使用2的补码表示。这意味着0的位逆不是1，而是一个无限长的二进制1序列，它被解释为-1。1的倒数不是0，而是无穷多个1，后跟一个0（即-2）。你知道吗

当然，为每个整数存储的位数不是无限的。Python通常会使用系统定义的C整数类型long（它通常是32位或64位长），但是如果值太大而无法容纳，则会溢出的操作会自动切换到Python自己的任意精度long类型（这种转换在Python的int类型中透明地处理） 3). 你知道吗

无论如何，另一种解决方案是使用：

graph[i][j] = 1 - graph[i][j]

或者，如果您不介意这些值成为int子类型bool的实例：

graph[i][j] = not graph[i][j]

Python的bool值仍然可用作数字（False与0类似，而True与1类似）。唯一真正的区别是，他们将打印文本而不是数字。你知道吗

Answer 2

实际上，-2是~1。Two's complement，记得吗？你知道吗

>>> bin(1)
'0b1'
>>> bin(~1)
'-0b10'

问题是：你用的不是位，而是整数。所以，要么你想恢复到使用布尔型（读起来不太好），要么你想使用一些表达式，比如0 if x else 1来翻转你的元素。你知道吗

小贴士：你可以用理解来写得更优雅：

>>> flipped = lambda graph: [ [0 if x else 1  for x in row]  for row in graph]
>>> flipped( [ [1, 0], [0, 1] ] )
[[0, 1], [1, 0]]

Answer 3

有了numpy就容易多了。你知道吗

>>> import numpy as np
>>> g1=np.array([[0, 1, 1, 0],
...              [1, 0, 0, 1],
...              [1, 0, 0, 1],
...              [0, 1, 1, 0]])
>>> g2=1-g1
>>> g2
array([[1, 0, 0, 1],
       [0, 1, 1, 0],
       [0, 1, 1, 0],
       [1, 0, 0, 1]])

~将使用布尔数据类型：

>>> g1=np.array([[0, 1, 1, 0],   # 1 represents True and 0 represents False
...              [1, 0, 0, 1],
...              [1, 0, 0, 1],
...              [0, 1, 1, 0]], dtype=bool)
>>> ~g1
array([[ True, False, False,  True],
       [False,  True,  True, False],
       [False,  True,  True, False],
       [ True, False, False,  True]], dtype=bool)

如果希望complement(~)在0和1中，而不是在True和False中，这将实现以下技巧：

>>> ~g1+0
array([[1, 0, 0, 1],
       [0, 1, 1, 0],
       [0, 1, 1, 0],
       [1, 0, 0, 1]])