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

Question

Не могли бы вы помочь понять, каковы основные отличия (если они есть) между собственным типом int и типами numpy.int32 или numpy.int64?

Answer 1

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

В IPython можно использовать вкладку полный, чтобы посмотреть на методы:

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 во многом так же, как 0дн массив. Не тождественно, но близко.

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] «родной» 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 показывает мне же DataBuffer с различными интерпретациями:

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 объекты, где в памяти. Аналогично для массива dtype = object.

Answer 2

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

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

Answer 3

Я думаю, что наибольшая разница заключается в том, что типы numpy совместимы со своими аналогами C. С одной стороны, это означает, что Numpy Интс может переполниться ...

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

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

>>> sys.getsizeof(1) 
24 

np.int32 ничем не меньше:

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

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

Answer 4

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

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

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

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

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