在向uint8添加int时奇怪的类型转换？

Question

I am somewhat confused by the way python/numpy work when typecasting unsigned integers.

Example:

import numpy as np
x = np.array([255], dtype=np.uint8)
y = x + 1

This gives the result:

In[0]: y
Out[0]: array([0], dtype=uint8)

I understand that uint8 cannot store an integer with a larger value than 255 so it cycles back to zero. I kind of expected this.

Now I try:

z = x + 256

Which gives:

In[1]: z
Out[1]: array([511], dtype=uint16)

So in this case the type has changed to one with more bytes to hold the larger number, but only when the integer being added would itself not fit into the smaller type. (Interestingly x + 255 does not give a uint16 result)

This strikes me as somewhat odd behaviour. Is there any logic behind it? I would have thought a more consistent thing to do is to have the type change to uint16 in the first example case too.

Answer 1

This behaviour seems to stem from an understandable desire to keep array casting to an absolute minimum.

Consider

z = np.uint8(255)
z + 1
# 256
type(z+1)
# numpy.int64

where the literal 1 has type int . It seems in that case both operands are cast to np.int64. But this has nothing to do with the result!

zz = np.uint8(1)
type(zz + 1)
# numpy.int64

The casting is however different if we use an array instead of a simple integer.

x = np.array([255], dtype=np.uint8)
x + 1
# array([0], dtype=uint8)

Seems to me this is probably the case as it would be a large computational effort to cast an entire array from one type to another, so this is only done if it knows 100% sure this will be necessary before looking at all the array elements, ie only if the other operand itself does not fit in the current type. In fact, even if we take

b = np.int16(1)
x+b
# array([0], dtype=uint8)

so it actually casts the right hand operand into a smaller type, all to save the array's type. On the other hand, when adding two np.arrays, the type conversion is always made to the larger type.

Long story short: - simple integer addition always casts to the larger type of the operands - addition of a numpy array and an integer casts to the type of the array if this is sufficient to represent the integer, else to the type of the integer - addition of two numpy arrays casts to the larger type of the operands (as with two integer)