Come posso vedere il tipo di una variabile se è senza segno a 32 bit, con segno a 16 bit, ecc.?

Come lo vedo?

Usa la type()funzione integrata:

>>> i = 123
>>> type(i)
<type 'int'>
>>> type(i) is int
True
>>> i = 123.456
>>> type(i)
<type 'float'>
>>> type(i) is float
True

Per verificare se una variabile è di un determinato tipo, utilizzare isinstance:

>>> i = 123
>>> isinstance(i, int)
True
>>> isinstance(i, (float, str, set, dict))
False

Nota che Python non ha gli stessi tipi di C / C ++, che sembra essere la tua domanda.

È possibile che tu stia cercando la funzione integrata .type()

Vedi gli esempi seguenti, ma non esiste un tipo "senza segno" in Python proprio come Java.

Intero positivo:

>>> v = 10
>>> type(v)
<type 'int'>

Grande numero intero positivo:

>>> v = 100000000000000
>>> type(v)
<type 'long'>

Numero intero negativo:

>>> v = -10
>>> type(v)
<type 'int'>

Sequenza letterale di caratteri:

>>> v = 'hi'
>>> type(v)
<type 'str'>

Numero intero a virgola mobile:

>>> v = 3.14159
>>> type(v)
<type 'float'>

È così semplice Lo fai così.

print(type(variable_name))

Come determinare il tipo di variabile in Python?

Quindi se hai una variabile, ad esempio:

one = 1

Vuoi sapere il suo tipo?

Ci sono modi giusti e modi sbagliati per fare praticamente tutto in Python. Ecco il modo giusto:

Uso type

>>> type(one)
<type 'int'>

È possibile utilizzare l' __name__attributo per ottenere il nome dell'oggetto. (Questo è uno dei pochi attributi speciali di cui hai bisogno per usare il __dunder__nome per arrivare a - non c'è nemmeno un metodo per farlo nel inspectmodulo.)

>>> type(one).__name__
'int'

Non usare __class__

In Python, i nomi che iniziano con i trattini bassi non fanno parte semanticamente dell'API pubblica ed è una buona pratica per gli utenti evitare di usarli. (Tranne quando assolutamente necessario.)

Dal momento che typeci dà la classe dell'oggetto, dovremmo evitare di ottenerlo direttamente. :

>>> one.__class__

Questa è di solito la prima idea che le persone hanno quando accedono al tipo di un oggetto in un metodo: stanno già cercando degli attributi, quindi il tipo sembra strano. Per esempio:

class Foo(object):
    def foo(self):
        self.__class__

Non farlo. Invece, digita (self):

class Foo(object):
    def foo(self):
        type(self)

Dettagli di implementazione di ints e float

Come posso vedere il tipo di una variabile se è senza segno a 32 bit, con segno a 16 bit, ecc.?

In Python, questi dettagli sono dettagli di implementazione. Quindi, in generale, di solito non ci preoccupiamo di questo in Python. Tuttavia, per soddisfare la tua curiosità ...

In Python 2, int è di solito un numero intero con segno uguale alla larghezza della parola dell'implementazione (limitata dal sistema). Di solito è implementato come un tempo in C . Quando gli interi diventano più grandi di questo, di solito li convertiamo in long di Python (con precisione illimitata, da non confondere con i long di C).

Ad esempio, in un Python 2 a 32 bit, possiamo dedurre che int è un numero intero a 32 bit con segno:

>>> import sys

>>> format(sys.maxint, '032b')
'01111111111111111111111111111111'
>>> format(-sys.maxint - 1, '032b') # minimum value, see docs.
'-10000000000000000000000000000000'

In Python 3, il vecchio int scompare e usiamo solo (Python) come int, che ha una precisione illimitata.

Possiamo anche ottenere alcune informazioni sui float di Python, che di solito sono implementati come doppio in C:

>>> sys.float_info
sys.floatinfo(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, 
min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, 
mant_dig=53, epsilon=2.2204460492503131e-16, radix=2, rounds=1)

Conclusione

Non utilizzare __class__, un'API semanticamente non pubblica, per ottenere il tipo di una variabile. Usa typeinvece.

E non preoccuparti troppo dei dettagli di implementazione di Python. Non ho dovuto affrontare da solo i problemi relativi a questo. Probabilmente non lo farai nemmeno tu, e se lo fai davvero, dovresti sapere abbastanza per non cercare questa risposta per cosa fare.

print type(variable_name)

Consiglio vivamente anche l' interprete interattivo IPython quando si affrontano domande come questa. Ti consente di digitare variable_name?e restituirà un intero elenco di informazioni sull'oggetto, incluso il tipo e la stringa del documento per il tipo.

per esempio

In [9]: var = 123

In [10]: var?
Type:       int
Base Class: <type 'int'>
String Form:    123
Namespace:  Interactive
Docstring:
    int(x[, base]) -> integer

Converti una stringa o un numero in un numero intero, se possibile. Un argomento in virgola mobile verrà troncato verso zero (ciò non include una rappresentazione in stringa di un numero in virgola mobile!) Quando si converte una stringa, utilizzare la base opzionale. È un errore fornire una base quando si converte una non stringa. Se l'argomento è al di fuori dell'intervallo intero verrà restituito un oggetto lungo.

a = "cool"
type(a)

//result 'str'
<class 'str'>
or 
do 
`dir(a)` 
to see the list of inbuilt methods you can have on the variable.

Un altro modo usando __class__:

>>> a = [1, 2, 3, 4]
>>> a.__class__
<type 'list'>
>>> b = {'key1': 'val1'}
>>> b.__class__
<type 'dict'>
>>> c = 12
>>> c.__class__
<type 'int'>

Esempi di semplice controllo del tipo in Python:

assert type(variable_name) == int

assert type(variable_name) == bool

assert type(variable_name) == list

Potrebbe essere poco irrilevante. ma puoi controllare i tipi di un oggetto con isinstance(object, type)come menzionato qui .

La domanda è alquanto ambigua: non sono sicuro di cosa intendi per "vista". Se stai cercando di interrogare il tipo di un oggetto Python nativo, la risposta di @atzz ti guiderà nella giusta direzione.

Tuttavia, se stai provando a generare oggetti Python che hanno la semantica dei tipi C primitivi (come uint32_t, ad esempio int16_t), usa il structmodulo. È possibile determinare il numero di bit in una data primitiva di tipo C in questo modo:

>>> struct.calcsize('c') # char
1
>>> struct.calcsize('h') # short
2
>>> struct.calcsize('i') # int
4
>>> struct.calcsize('l') # long
4

Ciò si riflette anche nel arraymodulo, che può creare array di questi tipi di livello inferiore:

>>> array.array('c').itemsize # char
1

Il numero intero massimo supportato (Python 2's int) è dato da sys.maxint .

>>> import sys, math
>>> math.ceil(math.log(sys.maxint, 2)) + 1 # Signedness
32.0

C'è anche sys.getsizeof , che restituisce la dimensione effettiva dell'oggetto Python nella memoria residua:

>>> a = 5
>>> sys.getsizeof(a) # Residual memory.
12

Per dati float e dati di precisione, utilizzare sys.float_info :

>>> sys.float_info
sys.floatinfo(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.2204460492503131e-16, radix=2, rounds=1)

Intendi in Python o usando i tipi ?

Nel primo caso, semplicemente non è possibile, poiché Python non ha numeri interi a 16/32 bit con segno / non firmato.

Nel secondo caso, puoi usare type():

>>> import ctypes
>>> a = ctypes.c_uint() # unsigned int
>>> type(a)
<class 'ctypes.c_ulong'>

Per ulteriori riferimenti sui tipi, un tipo, consultare la documentazione ufficiale .

Python non ha i tipi che descrivi. Esistono due tipi usati per rappresentare i valori integrali:, intche corrisponde al tipo int della piattaforma in C, e longche è un numero intero di precisione arbitraria (ovvero cresce all'occorrenza e non ha un limite superiore). ints vengono convertiti silenziosamente longse un'espressione produce risultati in cui non è possibile archiviare int.

Semplice, per Python 3.4 e versioni successive

print (type(variable_name))

Python 2.7 e versioni successive

print type(variable_name)

Dipende davvero dal livello che intendi. In Python 2.x, ci sono due tipi interi, int(vincolati a sys.maxint) e long(precisione illimitata), per ragioni storiche. Nel codice Python, ciò non dovrebbe fare la differenza perché l'interprete si converte automaticamente in long quando un numero è troppo grande. Se si desidera conoscere i tipi di dati effettivi utilizzati nell'interprete sottostante, dipende dall'implementazione. (I CPython si trovano in Oggetti / intobject.c e Oggetti / longobject.c.) Per scoprire i tipi di sistema, guarda la risposta cdleary per l'utilizzo del modulo struct.

Per python2.x, utilizzare

print type(variable_name)

Per python3.x, utilizzare

print(type(variable_name))

Basta non farlo. Chiedere il tipo di qualcosa è sbagliato in sé. Usa invece il polimorfismo. Trova o, se necessario, definisci da solo il metodo che fa quello che vuoi per ogni possibile tipo di input e chiamalo semplicemente senza chiedere nulla. Se devi lavorare con tipi o tipi predefiniti definiti da una libreria di terze parti, puoi sempre ereditare da essi e utilizzare invece i tuoi derivati. Oppure puoi avvolgerli nella tua classe. Questo è il modo orientato agli oggetti per risolvere tali problemi.

Se insisti a verificare il tipo esatto e a posizionare alcuni sporchi ifqua e là, puoi usare la __class__proprietà o la typefunzione per farlo, ma presto ti ritroverai ad aggiornare tutti questi messaggi ifcon casi aggiuntivi ogni due o tre commit. Farlo nel modo OO lo impedisce e ti consente di definire solo una nuova classe per un nuovo tipo di input.