types numeri - Come determinare il tipo di una variabile Python?




lista comandi (13)

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

Come vedo il tipo di una variabile se è senza segno a 32 bit, firmata a 16 bit, ecc.?

Come lo vedo?


Python non ha tipi come quelli che descrivi. Ci sono due tipi usati per rappresentare i valori interi: int , che corrisponde al tipo int della piattaforma in C, e long , che è un numero intero di precisione arbitraria (cioè cresce al bisogno e non ha un limite superiore). int s viene convertito automaticamente in long se un'espressione produce un risultato che non può essere memorizzato in int .


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


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 di tipi C primitivi, (come uint32_t , int16_t ), usa il modulo struct . È 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 modulo array , che può creare array di questi tipi di livello inferiore:

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

Il numero intero massimo supportato ( int Python 2) è 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 sys.float_info e dati di precisione, usa 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)

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:

Usa il type

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

È possibile utilizzare l'attributo __name__ per ottenere il nome dell'oggetto. (Questo è uno dei pochi attributi speciali di cui hai bisogno per usare il nome __dunder__ per arrivare - non c'è nemmeno un metodo per questo nel modulo __dunder__ .)

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

Non usare __class__

In Python, i nomi che iniziano con caratteri di sottolineatura non fanno parte semanticamente dell'API pubblica ed è consigliabile che gli utenti evitino di utilizzarli. (Tranne quando assolutamente necessario).

Dal momento che il type ci fornisce la classe dell'oggetto, dovremmo evitare di farlo direttamente. :

>>> one.__class__

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

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

Non farlo. Invece, digita (auto):

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

Dettagli di implementazione di interi e galleggianti

Come vedo il tipo di una variabile se è senza segno a 32 bit, firmata a 16 bit, ecc.?

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

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

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

>>> import sys

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

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

Possiamo anche ottenere alcune informazioni sui float di Python, che di solito sono implementati come un 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 invece il type .

E non preoccuparti troppo dei dettagli di implementazione di Python. Non ho avuto a che fare con problemi di questo genere. Probabilmente neanche tu lo farai, e se lo fai davvero, dovresti sapere abbastanza per non essere in cerca di questa risposta su cosa fare.


Semplice, per Python 3.4 e versioni successive

print (type(variable_name))

Python 2.7 e versioni successive

print type(variable_name)

È così semplice Lo fai così.

print(type(variable_name))

Forse stai cercando la funzione type() .

Vedi gli esempi qui sotto, ma non esiste un tipo "non firmato" in Python come Java.

Intero positivo:

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

Grande numero intero positivo:

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

Intero negativo:

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

Sequenza letterale di personaggi:

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

Numero intero virgola mobile:

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

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

Prova questo:

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

Tuttavia, la distinzione tra int e long va via in Python 3.0.


Intendi in Python o usando i ctypes ?

Nel primo caso, semplicemente non è possibile - perché Python non ha interi firmati / non firmati, 16/32 bit.

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, di questo tipo, consultare la documentazione ufficiale .


Dipende davvero dal livello che intendi. In Python 2.x, ci sono due tipi interi, int (limitato a sys.maxint ) e long (precisione illimitata), per ragioni storiche. Nel codice Python, questo non dovrebbe fare un po 'di differenza perché l'interprete converte automaticamente a lungo 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 Objects / intobject.c e Objects / longobject.c.) Per trovare informazioni sui tipi di sistemi, consultare 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))

Operatore ternario in diversi linguaggi di programmazione

Qui cerco solo di mostrare alcune importanti differenze nell'operatore ternary operator tra un paio di linguaggi di programmazione.

Operatore ternario in Javascript

var a = true ? 1 : 0;
# 1
var b = false ? 1 : 0;
# 0

Operatore ternario in Ruby

a = true ? 1 : 0
# 1
b = false ? 1 : 0
# 0

Operatore ternario in Scala

val a = true ? 1 | 0
# 1
val b = false ? 1 | 0
# 0

Operatore ternario nella programmazione R

a <- if (TRUE) 1 else 0
# 1
b <- if (FALSE) 1 else 0
# 0

Operatore ternario in Python

a = 1 if True else 0
# 1
b = 1 if False else 0
# 0

Ora puoi vedere la bellezza del linguaggio Python. è altamente leggibile e mantenibile.





python types unsigned signed 16-bit