Python 有人能解释一下这个leetcode解决方案是如何处理负数的吗？

这是一个解决方案，

计算两个整数a和b的和，但不允许使用运算符+和-。

为什么我们需要

MOD

和

MAX_INT

以及这部分在做什么<代码>~（a&MAX\u INT）^MAX\u INT

def getSum( a, b):
    """
    :type a: int
    :type b: int
    :rtype: int
    """
    MOD     = 0xFFFFFFFF
    MAX_INT = 0x7FFFFFFF
    while b != 0:
        a, b = (a ^ b) & MOD, ((a & b) << 1) & MOD
    return a if a <= MAX_INT else ~(a & MAX_INT) ^ MAX_INT

print getSum4(-4,2)
-2

def getSum（a，b）：
"""
：类型a:int
：类型b:int
：rtype:int
"""
MOD=0xFFFFFF
MAX_INT=0x7FFFFFFF
而b！=0:
a、 b=（a^b）&MOD，（（a&b）之所以使用
MOD
、
MAX\u INT
和
~（a&MAX\u INT）^MAX\u INT
是为了模拟32位整数。这是必要的，因为在Python中整数是没有边界的

在进行计算后，
&MOD
仅用于保留结果的32位最低有效位。在整数仅为32位的系统中，这实际上就是发生的情况；多余的位只需丢弃

MAX_INT
的用法是正确处理32位整数的整数溢出。如果您添加
0x40000000
和
0x40000000
，您将得到
0x80000000
，在Python中它只是一个正整数。对于32位整数，这将是一个溢出，其值等于
-0x80000000

a&MAX\u INT
用于删除最高有效位，该位在32位整数中基本上用作符号^MAX_INT

是一种将31位数字扩展到实际使用位数的方法。例如，如果Python只使用42位，

-0x8000000

将表示为

0xFF8000000

。换句话说，只需将最低有效31位以外的每一位设置为

1

。（执行

~x

与执行

x^0xff…ff

相同，因此

~x^MAX_INT

与

x^（0xff..ff MAX_INT）

和

x^0xff…FF8000000

甚至

x^0xff…FF8000000

相同，如果

x

仅使用31位）

当然，Python在概念上并没有使用固定数量的位，但您可以将其视为将有无限数量的位设置为1。它只是不存储所有这些位，就像它不以正数（例如0x00…001）存储所有0位一样

---

另一种方法是执行

~x^MOD

，其中第32位已经正确设置。

MOD、

MAX_INT

和

~（a&MAX_INT）^MAX_INT

的原因是模拟32位整数。这是必需的，因为在Python中整数是没有边界的

在进行计算后，

&MOD

仅用于保留结果的32位最低有效位。在整数仅为32位的系统中，这实际上就是发生的情况；多余的位只需丢弃

MAX_INT

的用法是正确处理32位整数的整数溢出。如果您添加

0x40000000

和

0x40000000

，您将得到

0x80000000

，在Python中它只是一个正整数。对于32位整数，这将是一个溢出，其值等于

-0x80000000

a&MAX\u INT

用于删除最高有效位，该位在32位整数中基本上用作符号^MAX_INT是一种将31位数字扩展到实际使用位数的方法。例如，如果Python只使用42位，

-0x8000000

将表示为

0xFF8000000

。换句话说，只需将最低有效31位以外的每一位设置为

1

。（执行

~x

与执行

x^0xff…ff

相同，因此

~x^MAX_INT

与

x^（0xff..ff MAX_INT）

和

x^0xff…FF8000000

甚至

x^0xff…FF8000000

相同，如果

x

仅使用31位）

当然，Python在概念上并没有使用固定数量的位，但您可以将其视为将有无限数量的位设置为1。它只是不存储所有这些位，就像它不以正数（例如0x00…001）存储所有0位一样

---

另一种方法是执行

~x^MOD

，您使用的是第32位已经正确设置。

我并不奇怪您在试图理解该代码时遇到了困难，当然它工作正常，但我建议您从头开始。首先确保您掌握位运算符、数字运算符和负数运算符。然后通过两个测试尝试理解这两个更简单的函数：

def add_32bits_buggy(a, b):
    MOD = 0xFFFFFFFF

    while (a != 0):
        c = (b & a) & MOD
        b = (b ^ a) & MOD
        a = (c << 1) & MOD

    return b


def add_32bits(a, b):
    MOD = 0xFFFFFFFF
    MAX_INT = 0x7FFFFFFF

    while (a != 0):
        c = (b & a) & MOD
        b = (b ^ a) & MOD
        a = (c << 1) & MOD

    if b <= MAX_INT:
        return b
    else:
        return ~(b & MAX_INT) ^ MAX_INT

# value to test edge_cases
max_v = 0xFFFFFFFF

# Positive integers
i = 1
while i <= max_v:
    i *= 2
    a, b = max_v + 1, i
    print "{0:10d}\t{1:10d}".format(
        add_32bits(a, b), add_32bits_buggy(a, b),
    )

print '-'*80

# Negative integers
i = 1
while i <= max_v:
    i *= 2
    a, b = max_v + 1, i
    print "{0:10d}\t{1:10d}".format(
        add_32bits(a, -b), add_32bits_buggy(a, -b),
    )

def add_32bits_buggy（a，b）：
MOD=0xFFFFFF
而（a！=0）：
c=（b&a）和MOD
b=（b^a）和MOD
a=（c我并不奇怪您在理解该代码时遇到了困难，它确实可以正常工作，但我建议您从头开始。首先确保您掌握位运算符、数字运算符和负数运算符。然后通过两个测试尝试理解这两个更简单的函数：

def add_32bits_buggy(a, b):
    MOD = 0xFFFFFFFF

    while (a != 0):
        c = (b & a) & MOD
        b = (b ^ a) & MOD
        a = (c << 1) & MOD

    return b


def add_32bits(a, b):
    MOD = 0xFFFFFFFF
    MAX_INT = 0x7FFFFFFF

    while (a != 0):
        c = (b & a) & MOD
        b = (b ^ a) & MOD
        a = (c << 1) & MOD

    if b <= MAX_INT:
        return b
    else:
        return ~(b & MAX_INT) ^ MAX_INT

# value to test edge_cases
max_v = 0xFFFFFFFF

# Positive integers
i = 1
while i <= max_v:
    i *= 2
    a, b = max_v + 1, i
    print "{0:10d}\t{1:10d}".format(
        add_32bits(a, b), add_32bits_buggy(a, b),
    )

print '-'*80

# Negative integers
i = 1
while i <= max_v:
    i *= 2
    a, b = max_v + 1, i
    print "{0:10d}\t{1:10d}".format(
        add_32bits(a, -b), add_32bits_buggy(a, -b),
    )

def add_32bits_buggy（a，b）：
MOD=0xFFFFFF
而（a！=0）：
c=（b&a）和MOD
b=（b^a）和MOD
a=（c）位屏蔽。你了解了吗？检查整数表示。位屏蔽。你了解了吗？检查整数表示。