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


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

¿Cómo lo veo?


1031
2017-12-31 07:58


origen


Respuestas:


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

Prueba esto:

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

La distinción entre int y long desaparece en Python 3.0, sin embargo.


948
2017-12-31 10:43



Usted puede estar buscando el type() función.

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

Entero positivo:

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

Grande entero positivo:

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

Entero negativo

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

Secuencia literal de personajes:

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

Número entero flotante:

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

306
2017-10-01 11:02



Es tan simple Lo haces así.

print(type(variable_name))

133
2017-10-07 16:02



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

Entonces, si tienes una variable, por ejemplo:

one = 1

¿Quieres saber su tipo?

Hay formas correctas y formas incorrectas de hacer casi todo en Python. Esta es la manera correcta:

Utilizar type

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

Puedes 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 llegar a - no hay ni siquiera un método para ello en el inspect mó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 que los usuarios eviten su uso. (Excepto cuando sea absolutamente necesario)

Ya que type nos da la clase del objeto, debemos evitar obtener esto directamente. :

>>> one.__class__

Esta suele ser la primera idea que tienen las personas cuando acceden al tipo de 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 flotadores

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

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

En Python 2, int suele ser un entero con signo igual a la implementación palabra ancho (limitado por el sistema). Por lo general se implementa como una largo en C. Cuando los números enteros se hacen más grandes, usualmente los convertimos a longs de Python (con precisión ilimitada, que no debe confundirse con longitudes 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 antiguo int se va, y usamos (Python) long como int, que tiene precisión ilimitada.

También podemos obtener información sobre los flotadores de Python, que generalmente se implementan como doble 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 usar __class__, una API semánticamente no pública, para obtener el tipo de una variable. Utilizar type en lugar.

Y no se preocupe demasiado por los detalles de implementación de Python. No he tenido que lidiar con problemas yo mismo. Probablemente tampoco lo hará, y si realmente lo hace, debería saber lo suficiente como para no estar atento a esta respuesta sobre qué hacer.


77
2018-03-18 02:48



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

36
2017-12-31 08:08



La pregunta es algo ambigua: no estoy seguro de lo que quiere decir con "ver". Si estás tratando de consulta el tipo de un objeto nativo de Python, @atzzLa respuesta te guiará en la dirección correcta.

Sin embargo, si estás tratando de generar Objetos de Python que tienen la semántica de los tipos C primitivos (como uint32_t, int16_t), utilizar el struct módulo. Puede determinar el número de bits en una primitiva de tipo C dada por lo tanto:

>>> 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 array módulo, que puede hacer matrices de estos tipos de nivel inferior:

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

El entero máximo admitido (Python 2's int) es 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 Pitón objeto 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)

25
2017-12-31 08:02



print type(variable_name)

También recomiendo mucho IPython intérprete interactivo cuando se trata de preguntas como esta. Te permite escribir variable_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 en un entero, si es posible. Un argumento de punto flotante se truncará hacia cero (esto no incluye una cadena representación de un número de punto flotante!) Al convertir una cadena, use la base opcional. Es un error proporcionar una base al convertir un         sin cuerda. Si el argumento está fuera del rango entero, un objeto largo         será devuelto en su lugar.


20
2017-08-14 06:39



Puede ser poco irrelevante. pero puedes verificar los tipos de un objeto con isinstance(object, type) como se mencionó aquí.


19
2017-12-31 08:10



¿Quieres decir en Pitón o usando ctypes?

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

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.


18
2018-01-12 01:08



Ejemplos de verificación de tipo simple en Python:

assert type(variable_name) == int

assert type(variable_name) == bool

assert type(variable_name) == list

18
2017-12-31 08:12



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


15
2018-04-09 09:39