Question

我正在阅读以下Python文档：

https://docs.scipy.org/doc/numpy-1.15.0/reference/generated/numpy.prod.html

注释

使用整数类型时算术是模块化的，并且不会引发错误   在溢出。这意味着在32位平台上：
>>> x = np.array([536870910, 536870910, 536870910, 536870910])
>>> np.prod(x)  # random 
16

有人可以解释使用整数类型时算术是模块化的意思吗？如果我有32位或64位平台，这又有什么关系？

Answer 1

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

numpy整数可以使用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]

由8位> 127表示的数字为负。

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

numpy：刺，什么才是真正的溢出？

注释

1 个答案: