В чем разница между собственным типом типа и типами numpy.int?

Ответ 1

Другой способ взглянуть на различия состоит в том, чтобы спросить, какие методы имеют 2 типа объектов.

В Ipython я могу использовать вкладку complete, чтобы посмотреть на методы:

In [1277]: x=123; y=np.int32(123)

int методы и атрибуты:

In [1278]: x.<tab>
x.bit_length   x.denominator  x.imag         x.numerator    x.to_bytes
x.conjugate    x.from_bytes   x.real         

int 'Операторы'

In [1278]: x.__<tab>
x.__abs__           x.__init__          x.__rlshift__
x.__add__           x.__int__           x.__rmod__
x.__and__           x.__invert__        x.__rmul__
x.__bool__          x.__le__            x.__ror__
...
x.__gt__            x.__reduce_ex__     x.__xor__
x.__hash__          x.__repr__          
x.__index__         x.__rfloordiv__     

np.int32 методы и атрибуты (или свойства). Некоторые из них, но намного больше, в основном все ndarray:

In [1278]: y.<tab>
y.T             y.denominator   y.ndim          y.size
y.all           y.diagonal      y.newbyteorder  y.sort
y.any           y.dtype         y.nonzero       y.squeeze   
...
y.cumsum        y.min           y.setflags      
y.data          y.nbytes        y.shape   

методы y.__ очень похожи на теги int. Они могут выполнять ту же математику.

In [1278]: y.__<tab>
y.__abs__              y.__getitem__          y.__reduce_ex__
y.__add__              y.__gt__               y.__repr__
...
y.__format__           y.__rand__             y.__subclasshook__
y.__ge__               y.__rdivmod__          y.__truediv__
y.__getattribute__     y.__reduce__           y.__xor__

y во многом совпадает с массивом 0d. Не идентичны, но близки.

In [1281]: z=np.array(123,dtype=np.int32)

np.int32 - это то, что я получаю, когда я индексирую массив этого типа:

In [1300]: A=np.array([0,123,3])

In [1301]: A[1]
Out[1301]: 123

In [1302]: type(A[1])
Out[1302]: numpy.int32

Мне нужно использовать item для удаления всех оберток numpy.

In [1303]: type(A[1].item())
Out[1303]: int

Как пользователь numpy, np.int32 является int с оберткой numpy. Или, наоборот, один элемент ndarray. Обычно я не обращаю внимания на то, что A[0] дает мне "native" int или эквивалент numpy. В отличие от некоторых новых пользователей, я редко использую np.int32(123); Вместо этого я использовал бы np.array(123).

A = np.array([1,123,0], np.int32)

не содержит 3 np.int32 объектов. Скорее буфер данных составляет 3 * 4 = 12 байтов. Это накладные расходы массива, которые интерпретируют его как 3 ints в 1d. И view показывает мне тот же файл данных с различными интерпретациями:

In [1307]: A.view(np.int16)
Out[1307]: array([  1,   0, 123,   0,   0,   0], dtype=int16)

In [1310]: A.view('S4')
Out[1310]: array([b'\x01', b'{', b''],   dtype='|S4')

Только когда я индексирую один элемент, я получаю объект np.int32.

Список L=[1, 123, 0] отличается; это список указателей - указатели на int объекты else, где в памяти. Аналогично для массива dtype = object.

Ответ 2

Существует несколько основных отличий. Во-первых, целые числа python являются гибкими (по крайней мере, в python 3.x). Это означает, что они могут расти для размещения любого количества любого размера (конечно, в пределах ограничений памяти). Целочисленные числа numpy, с другой стороны, являются фиксированными. Это означает, что максимальное значение они могут удерживать. Это определяется количеством байтов в целых числах (int32 vs. int64), причем большее количество байтов содержит большие числа, а также независимо от того, подписано или не указано число (int32 vs. uint32), с unsigned, способным удерживать большие числа, но не в состоянии удерживать отрицательное число.

Итак, вы можете спросить, зачем использовать целые числа фиксированного размера? Причина в том, что современные процессоры имеют встроенные инструменты для выполнения математики с целыми числами фиксированного размера, поэтому расчеты на них намного, намного, намного быстрее. На самом деле, python использует целые числа фиксированного размера за кадром, когда число достаточно мало, и только переход на более медленные, гибкие целые числа, когда число становится слишком большим.

Другим преимуществом фиксированных значений является то, что они могут быть размещены в соседних блоках памяти одинакового размера того же типа. Это формат, используемый массивами numpy для хранения данных. Библиотеки, на которые опирается numpy, способны делать чрезвычайно быстрые вычисления по данным в этом формате, на самом деле современные процессоры имеют встроенные функции для ускорения такого рода вычислений. С целыми числами python с переменным размером такого рода вычисление невозможно, потому что нет способа сказать, насколько важны блоки и не согласуется в формате данных.

При этом numpy фактически может создавать массивы целых чисел python. Но вместо массивов, содержащих значения, вместо этого они представляют собой массивы, содержащие ссылки на другие части памяти, содержащие фактические целые числа python. Это невозможно ускорить таким же образом, поэтому даже если все целые числа python будут соответствовать фиксированному целочисленному размеру, он все равно не будет ускорен.

Все это не относится к Python 2. В Python 2 целые числа Python являются фиксированными целыми числами и поэтому могут быть непосредственно переведены в целые числа numpy. Для целых чисел переменной длины Python 2 имеет тип long. Но это было непонятно, и было решено, что эта путаница не стоит повышения производительности, особенно когда люди, которые нуждаются в производительности, будут использовать numpy или что-то в этом роде.

Ответ 3

Я думаю, что самая большая разница в том, что типы numpy совместимы со своими аналогами C. Во-первых, это означает, что numpy ints может переполняться...

>>> np.int32(2**32)
0

Вот почему вы можете создать массив целых чисел и указать тип данных как np.int32, например. Затем Numpy выделяет массив, который достаточно велик, чтобы удерживать указанное количество 32-битных целых чисел, а затем, когда вам нужны значения, он преобразует C-целые числа в np.int32 (что очень быстро). Преимущества преобразования взад и вперед от np.int32 и C-int также включают огромную экономию памяти. Объекты Python обычно довольно большие:

>>> sys.getsizeof(1)
24

A np.int32 не меньше:

>>> sys.getsizeof(np.int32(1))
28

но помните, что большую часть времени, когда мы работаем с массивами numpy, мы работаем только с целыми числами C, которые принимают только 4 байта (вместо 24). Нам нужно работать с np.int32 при работе со скалярными значениями из массива.

Ответ 4

Не полный ответ, но это должно заставить вас начать http://docs.scipy.org/doc/numpy-1.10.1/user/basics.types.html

Существует 5 основных числовых типов, представляющих booleans (bool), integers (int), целые числа без знака (uint) с плавающей запятой (float) и complex. Те, у кого есть номера в их названии, указывают битрейты типа (то есть сколько бит необходимо для представления одного значения в памяти). Некоторые типы, такие как int и intp, имеют разные биты, зависящие от платформ (например, 32-разрядные и 64-разрядные машины). Это следует учитывать при взаимодействии с низкоуровневым кодом (например, C или Fortran), в котором исправлена ​​необработанная память.