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

¿Cómo lo veo?

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.

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

Es muy simple Lo haces así

print(type(variable_name))

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

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.

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.

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

Ejemplos de comprobación de tipo simple en Python:

assert type(variable_name) == int

assert type(variable_name) == bool

assert type(variable_name) == list

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

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)

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

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.

Simple, para python 3.4 y superior

print (type(variable_name))

Python 2.7 y superior

print type(variable_name)

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.

Para python2.x, use

print type(variable_name)

Para python3.x, use

print(type(variable_name))

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.