x%(1e9 + 7) 和 x%(10**9 + 7) 在 Python 中是否不同？如果是，为什么？

Question

对于整数 x，x % (10 ** 9 + 7) 和 x % (1e9 + 7) 在几次迭代后给出不同的结果。为了重现这个结果，我分享了 LeetCode #576. Out of Boundary Paths 的解决方案。如果我将 return ans % (10 ** 9 + 7) 更改为 return ans % (1e9 + 7)，我的解决方案不会通过 94 个测试用例中的 5 个（意识到这花了我一个小时）。

请注意，此解决方案比某个天才 here 提出的单行代码要长得多。但是，如果我们将 % (10 ** 9 + 7) 更改为 % (1e9 + 7).

，他的解决方案会出现同样的问题

我玩了一下 python 编译器，注意到 1e9 给出了一个浮点数。所以在我看来，这种特殊性是由浮点运算的 'weirdness' 引起的。但我仍然不明白小数点后的零如何导致差异。为什么会出现这种差异？

无需复制，差异可以在这里找到：https://www.diffchecker.com/PyKQCElB

要重现，这是我的解决方案：


class Solution:
    def findPaths(self, m: int, n: int, maxMove: int, startRow: int, startColumn: int) -> int:
        if maxMove == 0:
            return 0
        current_state = [[0 for _ in range(n)] for _ in range(m)]
        next_state = [[0 for _ in range(n)] for _ in range(m)]
        current_state[startRow][startColumn] = 1
        ans = self.count_ways(m, n, current_state)
        
        k = 1
        while k < maxMove:
            # print("CS:", current_state)
            for i in range(m):
                for j in range(n):
                    next_state[i][j] = 0
                    if i != 0:
                        next_state[i][j] += current_state[i-1][j]
                    if i!= m-1:
                         next_state[i][j] += current_state[i+1][j]
                    if j != 0:
                        next_state[i][j] += current_state[i][j-1]
                    if j != n-1:
                        next_state[i][j] += current_state[i][j+1]
            
            current_state, next_state = next_state, current_state
            ans += self.count_ways(m, n, current_state)
            
            # print("NS:", current_state)
            # print("k:{},ans:{}".format(k, int(ans % 10 ** 9 + 7)))            
            # print("k:{},ans:{}".format(k, int(ans % 1e9 + 7)))            

            k += 1
            
        # return ans % (1e9 + 7)  # This is giving incorrect results.
        return ans % (10 ** 9 + 7)  # This works fine.
        
    def count_ways(self, m, n, grid):
        ways = 0
        for i in range(m):
            for j in [0, n-1]: # Checking left and right strips of a grid.
                ways += grid[i][j]
                 
        for j in range(n):
            for i in [0, m-1]: # Checking top and bottom strips of a grid.
                ways += grid[i][j]
                
        # This will automatically add corner boxes twice.
        
        return ways

编辑：使用此测试用例（按顺序 findPaths 的参数）：

Answer 1

But I still don't understand how a zero after decimal point can cause difference.

其中小数点不重要。它在漂浮！

Why is this difference arising?

因为 Python 中的浮点数是通常的硬件数字，这意味着它们的存储空间和精度有限：

>>> int(123123123123123123123.0)
123123123123123126272
#                ^^^^ different!

但是 Python 中的整数具有无限的存储空间和精度（“bignum”）：

>>> int(123123123123123123123)
123123123123123123123

所以：

>>> 123123123123123123123 % 10**9
123123123

>>> 123123123123123123123 % 1e9
123126272.0

在第二种情况下，两边都转换为浮点数，因为其中之一是。

x%(1e9 + 7) 和 x%(10**9 + 7) 在 Python 中是否不同？如果是，为什么？

Is x%(1e9 + 7) and x%(10**9 + 7) different in Python? If yes, why?

python

floating-point

python-3.x