Numpy 普罗德，溢出到底是什么？

我正在阅读以下Python文档：

笔记 当使用整数类型时，算术是模块化的，不会产生错误 溢出。这意味着，在32位平台上：

>>> x = np.array([536870910, 536870910, 536870910, 536870910])
>>> np.prod(x)  # random 
16

---

有人能解释一下，当使用整数类型时，算术是模块化的意味着什么，以及这与我使用的是32位还是64位平台有什么关系吗？

wiki页面解释了模块化算术，但与numpy无关

numpy INT可以是8、16、32或64位的有符号或无符号整数

         Range signed        Range unsigned
 8 bit   -128 to 127         0 to 255        0 to 2**8-1
16 bit   -32768 to 32767     0 to 65535      0 to 2**16-1
32 bit   -2**31 to 2**31-1   0 to 2**32-1    Decimal 9 digits
64 bit   -2**64 to 2**64-1   0 to 2**64-1    Decimal 18/19 digits

np.int8最容易可视化。只有256个不同的可能值

import numpy as np
a=np.arange(256, dtype=np.int8)
print(a)

[   0    1    2    3    4    5    6    7    8    9   10   11   12   13   14
   15   16   17   18   19   20   21   22   23   24   25   26   27   28   29
   30   31   32   33   34   35   36   37   38   39   40   41   42   43   44
   45   46   47   48   49   50   51   52   53   54   55   56   57   58   59
   60   61   62   63   64   65   66   67   68   69   70   71   72   73   74
   75   76   77   78   79   80   81   82   83   84   85   86   87   88   89
   90   91   92   93   94   95   96   97   98   99  100  101  102  103  104
  105  106  107  108  109  110  111  112  113  114  115  116  117  118  119
  120  121  122  123  124  125  126  127 -128 -127 -126 -125 -124 -123 -122
 -121 -120 -119 -118 -117 -116 -115 -114 -113 -112 -111 -110 -109 -108 -107
 -106 -105 -104 -103 -102 -101 -100  -99  -98  -97  -96  -95  -94  -93  -92
  -91  -90  -89  -88  -87  -86  -85  -84  -83  -82  -81  -80  -79  -78  -77
  -76  -75  -74  -73  -72  -71  -70  -69  -68  -67  -66  -65  -64  -63  -62
  -61  -60  -59  -58  -57  -56  -55  -54  -53  -52  -51  -50  -49  -48  -47
  -46  -45  -44  -43  -42  -41  -40  -39  -38  -37  -36  -35  -34  -33  -32
  -31  -30  -29  -28  -27  -26  -25  -24  -23  -22  -21  -20  -19  -18  -17
  -16  -15  -14  -13  -12  -11  -10   -9   -8   -7  -6  -5  -4  -3  -2 -1]

由大于127的8位表示的数字显示为负数

np.binary_repr(127, 8)
Out[11]: '01111111'

np.binary_repr(-128, 8)
Out[12]: '10000000'

如果设置了位7，则表示为负整数

使用np.int8玩一些数字

np.int8(17*18)   # Out[29]: 50
17*18 % 256      # Out[30]: 50  (17*18=306) Mod 256 = 50

np.int8(17*180) # Out[31]: -12
17*180 % 256    # Out[32]: 244  
np.binary_repr(244, 8)   # Out[33]: '11110100'
np.binary_repr(-12, 8)   # Out[34]: '11110100'

文档中说，如果整数算术溢出，它只是环绕数字范围，不会引发异常。将“缠绕”替换为模块化

如果溢出确实发生，它只会产生令人惊讶的（可能是不正确的）结果

这给出了一个快速的概要。使用

np.int8（expr）

和

np.binary_repr（n，8）

进行游戏，看看发生了什么

编辑以解释第7位

Bit numbers  7 6 5 4 3 2 1 0
     127     0 1 1 1 1 1 1 1  Bit 7 not set 0 +127
    -128     1 0 0 0 0 0 0 0  Bit 7 set     1 -128
      -1     1 1 1 1 1 1 1 1  

---

太好了，谢谢你！你所说的“如果设置了第7位”是什么意思？@Erosennin我已经编辑了答案，并在最后给出了解释。对于每个整数大小，它是设置为指示负数的最高有效位。7、15、31或63。