¿Cómo determinar el tipo de variable de Python?

Respuestas:

1381

Use la type()función integrada:

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

Para verificar si una variable es de un tipo dado, use isinstance:

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

Tenga en cuenta que Python no tiene los mismos tipos que C / C ++, que parece ser su pregunta.

Gregreg
fuente
437

Es posible que esté buscando la función incorporada .type()

Vea los ejemplos a continuación, pero no hay ningún tipo "sin signo" en Python como Java.

Entero positivo:

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

Entero positivo grande :

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

Entero negativo:

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

Secuencia literal de caracteres:

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

Entero de coma flotante:

>>> v = 3.14159
>>> type(v)
<type 'float'>
Srikanth
fuente
Tuve que tomar dos veces cuando vi esto. Java SE8 ahora contiene enteros sin signo, y he desarrollado tanto con él que parece pecaminoso que Java nunca haya tenido enteros sin signo antes de SE8.
dddJewelsbbb
172

Es muy simple Lo haces así

print(type(variable_name))
Vaibhav
fuente
110

¿Cómo determinar el tipo de variable en Python?

Entonces, si tiene una variable, por ejemplo:

one = 1

¿Quieres saber su tipo?

Hay formas correctas y formas incorrectas de hacer casi todo en Python. Aquí está la manera correcta:

Utilizar type

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

Puede usar el __name__atributo para obtener el nombre del objeto. (Este es uno de los pocos atributos especiales que necesita para usar el __dunder__nombre para acceder; ni siquiera hay un método para ello en el inspectmódulo).

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

No usar __class__

En Python, los nombres que comienzan con guiones bajos no son semánticamente parte de la API pública, y es una buena práctica para los usuarios evitar usarlos. (Excepto cuando sea absolutamente necesario).

Como typenos da la clase del objeto, debemos evitar obtener esto directamente. :

>>> one.__class__

Esta suele ser la primera idea que las personas tienen al acceder al tipo de un objeto en un método: ya están buscando atributos, por lo que el tipo parece extraño. Por ejemplo:

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

No lo hagas En cambio, escriba (self):

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

Detalles de implementación de ints y flotantes

¿Cómo veo el tipo de variable si es de 32 bits sin signo, 16 bits con signo, etc.?

En Python, estos detalles son detalles de implementación. Entonces, en general, no nos preocupamos de esto en Python. Sin embargo, para saciar tu curiosidad ...

En Python 2, int suele ser un entero con signo igual al ancho de palabra de la implementación (limitado por el sistema). Por lo general, se implementa como largo en C . Cuando los enteros se hacen más grandes que esto, generalmente los convertimos en largos de Python (con precisión ilimitada, que no debe confundirse con largos de C).

Por ejemplo, en un Python 2 de 32 bits, podemos deducir que int es un entero de 32 bits con signo:

>>> import sys

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

En Python 3, el int viejo desaparece, y solo usamos (Python) largo como int, que tiene una precisión ilimitada.

También podemos obtener información sobre las carrozas de Python, que generalmente se implementan como un doble en 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)

Conclusión

No use __class__una API semánticamente no pública para obtener el tipo de una variable. Usar en su typelugar.

Y no se preocupe demasiado por los detalles de implementación de Python. No he tenido que lidiar con problemas relacionados con esto. Probablemente tampoco lo hará, y si realmente lo hace, debe saber lo suficiente como para no estar buscando esta respuesta para saber qué hacer.

Aaron Hall
fuente
el tipo sale como <type instance>pero __class__da email.message.Message- ¿qué estoy haciendo mal?
Jasen
@Jasen ¿Estás usando Python 2 y no heredas de object?
Aaron Hall
sí, simplemente import email no uso clases de mi propio invento.
Jasen
65
print type(variable_name)

También recomiendo encarecidamente el intérprete interactivo de IPython cuando se trata de preguntas como esta. Te permite escribirvariable_name? y devolverá una lista completa de información sobre el objeto, incluido el tipo y la cadena de documentación para el tipo.

p.ej

In [9]: var = 123

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

Convierta una cadena o número a un entero, si es posible. Un argumento de coma flotante se truncará hacia cero (¡esto no incluye una representación de cadena de un número de coma flotante!) Al convertir una cadena, use la base opcional. Es un error proporcionar una base al convertir una no cadena. Si el argumento está fuera del rango entero, se devolverá un objeto largo.

Lawrence Johnston
fuente
2
Pedí int sin firmar, int firmado, etc.
user46646
3
print type(str)devuelve un error en Python 3.6. Usotype(str)
Kolob Canyon
44
@KolobCanyon es porque en 3.x, la impresión necesita paréntesis:print(type(str))
jcoppens
1
Realmente deberías modificar el print type(var)código erróneo.
Han XIAO
54
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.
lilhamad
fuente
40

Una forma más de usar __class__:

>>> a = [1, 2, 3, 4]
>>> a.__class__
<type 'list'>
>>> b = {'key1': 'val1'}
>>> b.__class__
<type 'dict'>
>>> c = 12
>>> c.__class__
<type 'int'>
ア レ ッ ク ス
fuente
1
re: comente "los nombres que comienzan con guiones bajos ..." (simples) los guiones bajos son muy diferentes a los guiones bajos ("dunders") y definitivamente son parte de la API pública y ciertamente está bien usarlos. Esto puede ser de ayuda ... youtu.be/wf-BqAjZb8M
michael
31

Ejemplos de comprobación de tipo simple en Python:

assert type(variable_name) == int

assert type(variable_name) == bool

assert type(variable_name) == list
anh_ng8
fuente
29

Puede ser poco irrelevante. pero puede verificar los tipos de un objeto isinstance(object, type)como se menciona aquí .

skjoshi
fuente
1
Creo que esta es mucho mejor que la función de tipo para usar en el proceso de verificación. Si desea verificar y actuar con el resultado, debe usar try catch with type pero isinstance devuelve verdadero o falso
alkanschtein
24

La pregunta es algo ambigua: no estoy seguro de qué quieres decir con "vista". Si está intentando consultar el tipo de un objeto nativo de Python, @atzz la respuesta de en la dirección correcta.

Sin embargo, si estás intentando generar objetos de Python que tengan la semántica de los tipos C primitivos (como uint32_t, por ejemplo int16_t), use el structmódulo. De este modo, puede determinar el número de bits en una primitiva de tipo C dada:

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

Esto también se refleja en el arraymódulo, que puede hacer matrices de estos tipos de nivel inferior:

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

El número entero máximo admitido (Python 2 int) viene dado por sys.maxint .

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

También hay sys.getsizeof , que devuelve el tamaño real del objeto Python en la memoria residual:

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

Para datos flotantes y datos de precisión, use 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)
cdleary
fuente
77
La pregunta, según tengo entendido, se refiere a consultar el tipo de "variable" en Python. Su respuesta es generalmente correcta pero fuera de tema.
tzot
19

¿Te refieres a Python o al uso de ctypes ?

En el primer caso, simplemente no puede, porque Python no tiene enteros de 16/32 bits con signo / sin signo.

En el segundo caso, puedes usar type() :

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

Para obtener más referencias sobre ctypes, y su tipo, consulte la documentación oficial .

robar
fuente
15

Python no tiene los tipos que usted describe. Hay dos tipos utilizados para representar valores integrales: intque corresponde al tipo int de la plataforma en C y longque es un número entero de precisión arbitraria (es decir, crece según sea necesario y no tiene un límite superior). ints se convierten silenciosamente a longsi una expresión produce un resultado que no se puede almacenar int.

atzz
fuente
11

Simple, para python 3.4 y superior

print (type(variable_name))

Python 2.7 y superior

print type(variable_name)
Priyansh
fuente
10

Realmente depende de a qué nivel te refieres. En Python 2.x, hay dos tipos enteros, int(restringidos a sys.maxint) y long(precisión ilimitada), por razones históricas. En el código Python, esto no debería hacer un poco de diferencia porque el intérprete se convierte automáticamente en largo cuando un número es demasiado grande. Si desea saber acerca de los tipos de datos reales utilizados en el intérprete subyacente, eso depende de la implementación. (Los CPython se encuentran en Objects / intobject.c y Objects / longobject.c.) Para obtener información sobre los tipos de sistemas, consulte la respuesta cdleary para usar el módulo struct.

Benjamin Peterson
fuente
7

Para python2.x, use

print type(variable_name)

Para python3.x, use

print(type(variable_name))
Príncipe Dhadwal
fuente
-29

Solo no lo hagas. Pedir el tipo de algo está mal en sí mismo. En su lugar, use el polimorfismo. Encuentre o, si es necesario, defina usted mismo el método que hace lo que desea para cualquier posible tipo de entrada y simplemente llámelo sin preguntar nada. Si necesita trabajar con tipos incorporados o tipos definidos por una biblioteca de terceros, siempre puede heredar de ellos y utilizar sus propios derivados. O puedes envolverlos dentro de tu propia clase. Esta es la forma orientada a objetos para resolver tales problemas.

Si insiste en verificar el tipo exacto y colocar algunos mensajes sucios ifaquí y allá, puede usar __class__propiedades o typefunciones para hacerlo, pero pronto se encontrará actualizando todos estos ifmensajes con casos adicionales cada dos o tres confirmaciones. Hacerlo de la manera OO evita eso y solo le permite definir una nueva clase para un nuevo tipo de entrada.

Sventimir
fuente
44
Realmente no sé qué agregó esta respuesta a las existentes (¿quizás más allá de la primera oración?)
user2305193