Qual è la differenza tra il tipo nativo int e i tipi numpy.int?

Question

Puoi aiutare a capire quali sono le principali differenze (se esistono) tra il tipo nativo int ei tipi numpy.int32 o numpy.int64?

Answer 1

Un altro modo per vedere le differenze è chiedere quali metodi hanno i 2 tipi di oggetti.

In ipython posso utilizzare la scheda completa di guardare ai metodi:

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

int metodi e attributi:

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

int 'operatori'

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 metodi e attributi (o proprietà). Alcuni degli stessi, ma molto di più, praticamente tutti i ndarray quelli:

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 

i y.__ metodi assomigliano molto i int quelli. Possono fare la stessa matematica.

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 è per molti versi la stessa come una matrice 0d. Non identico, ma vicino.

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

np.int32 è quello che ottengo quando indice un array di questo tipo:

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

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

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

devo usare item per rimuovere tutto il numpy incarto.

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

Come utente numpy, un np.int32 è un int con numpy involucro. O al contrario un singolo elemento di un ndarray. Di solito non presta attenzione al fatto che lo A[0] mi dia il 'nativo' int o l'equivalente numpy. A differenza di alcuni nuovi utenti, utilizzo raramente lo np.int32(123); Vorrei usare np.array(123) invece.

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

non contiene 3 np.int32 oggetti. Piuttosto il suo buffer di dati è lungo 3 * 4 = 12 byte. È l'overhead dell'array che lo interpreta come 3 inte in 1d.E view mi mostra la stessa databuffer con diverse interpretazioni:

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') 

E 'solo quando ho indice di un unico elemento che ho un oggetto np.int32.

L'elenco L=[1, 123, 0] è diverso; è una lista di puntatori - puntatori su oggetti int in memoria. Allo stesso modo per un dtype = object array.

Answer 2

Non è una risposta completa, ma questo dovrebbe iniziare http://docs.scipy.org/doc/numpy-1.10.1/user/basics.types.html

Ci sono 5 tipi numerici di base che rappresentano booleani (bool), interi (int), interi senza segno (uint) punto (float) galleggianti e complessa . Quelli con i numeri nel loro nome indicano il bitize del tipo (cioè quanti bit sono necessari per rappresentare un singolo valore in memoria). Alcuni tipi, come int e intp, hanno bitsize differenti, dipendenti dalle piattaforme (ad esempio macchine a 32 bit e 64 bit). Questo dovrebbe essere tenuto in considerazione durante l'interfaccia con codice di basso livello (come C o Fortran) in cui viene indirizzata la memoria grezza.

Answer 3

Penso che la più grande differenza è che i tipi di numpy sono compatibili con le loro controparti C. Per prima cosa, questo significa che interi NumPy possono traboccare ...

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

Questo è il motivo per cui è possibile creare un array di interi e specificare il tipo di dati, come ad esempio np.int32. Numpy assegnerà quindi un array abbastanza grande da contenere il numero specificato di numeri interi a 32 bit e, quando saranno necessari i valori, convertirà gli interi C in np.int32 (che è molto veloce). I vantaggi di poter convertire avanti e indietro da np.int32 e C-int includono anche enormi risparmi di memoria. oggetti Python sono in genere piuttosto grande:

>>> sys.getsizeof(1) 
24 

Un np.int32 non è Any più piccoli:

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

ma ricordate, la maggior parte del tempo in cui stiamo lavorando con gli array NumPy, siamo solo a lavorare con i numeri interi C che richiedono solo 4 byte (anziché 24). Abbiamo solo bisogno di lavorare con lo np.int32 quando si tratta di valori scalari da una matrice.

Answer 4

Ci sono molte differenze importanti. Il primo è che gli interi python sono di dimensioni flessibili (almeno in python 3.x). Ciò significa che possono crescere per adattarsi a qualsiasi numero di qualsiasi dimensione (entro limiti di memoria, ovviamente). Gli interi numpy, d'altra parte, sono di dimensioni fisse. Questo significa che c'è un valore massimo che possono contenere. Questo è definito dal numero di byte nel numero intero (int32 vs. int64), con più byte che contengono numeri più grandi, nonché se il numero è firmato o non firmato (int32 rispetto a uint32), con non firmato in grado di contenere numeri più grandi ma non in grado di contenere un numero negativo.

Quindi, si potrebbe chiedere, perché utilizzare gli interi di dimensioni fisse? La ragione è che i processori moderni hanno strumenti integrati per fare matematica su interi a dimensione fissa, quindi i calcoli su quelli sono molto, molto, molto più veloci. Infatti, python utilizza numeri interi fissi dietro le quinte quando il numero è abbastanza piccolo, passando solo agli interi più lenti e flessibili quando il numero diventa troppo grande.

Un altro vantaggio dei valori di dimensione fissa è che possono essere inseriti in blocchi di memoria adiacenti di dimensioni coerenti dello stesso tipo. Questo è il formato utilizzato dagli array di numpy per memorizzare i dati. Le librerie su cui numpy si basa sono in grado di eseguire calcoli estremamente rapidi sui dati in questo formato, infatti le moderne CPU hanno funzionalità integrate per accelerare questo tipo di calcolo.Con gli interi python a dimensione variabile, questo tipo di calcolo è impossibile perché non c'è modo di dire quanto devono essere grandi i blocchi e non coerenti nel formato dei dati.

Detto questo, numpy è effettivamente in grado di creare matrici di interi python. Ma piuttosto che gli array che contengono i valori, invece sono array che contengono riferimenti ad altri pezzi di memoria che contengono gli interi effettivi del pitone. Questo non può essere accelerato allo stesso modo, quindi anche se tutti gli interi python si adattano alla dimensione intera fissa, non sarà ancora accelerato.

Niente di tutto ciò è il caso di Python 2. In Python 2, gli interi Python sono numeri interi fissi e quindi possono essere tradotti direttamente in interi numpy. Per gli interi a lunghezza variabile, Python 2 aveva il tipo long. Ma questo è stato fonte di confusione e si è deciso che questa confusione non valeva i guadagni in termini di prestazioni, specialmente quando le persone che hanno bisogno di prestazioni utilizzerebbero comunque numpy o qualcosa del genere.