tabla - graficas pandas python
¿Cómo determinar el tipo de una variable de Python? (14)
¿Cómo determinar el tipo de variable en Python?
Así que si tienes 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:
Usar type
>>> type(one)
<type ''int''>
Puede usar el atributo __name__ para obtener el nombre del objeto. (Este es uno de los pocos atributos especiales que necesita para usar el nombre __dunder__ - no hay siquiera un método para ello en el módulo de inspect ).
>>> type(one).__name__
''int''
No uses __class__
En Python, los nombres que comienzan con guiones bajos no forman parte semánticamente de la API pública, y es una buena práctica para los usuarios evitar usarlos. (Excepto cuando sea absolutamente necesario).
Dado que el type nos da la clase del objeto, debemos evitar obtener esto directamente. :
>>> one.__class__
Esta suele ser la primera idea que tienen las personas al acceder 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 su lugar, escribe (self):
class Foo(object):
def foo(self):
type(self)
Detalles de implementación de ints y flotadores.
¿Cómo veo el tipo de una variable si es sin signo de 32 bits, con signo de 16 bits, etc.?
En Python, estos detalles son detalles de implementación. Entonces, en general, no nos preocupamos por esto en Python. Sin embargo, para saciar tu curiosidad ...
En Python 2, int suele ser un entero con signo igual al ancho de word la implementación (limitado por el sistema). Por lo general se implementa como un largo en C. Cuando los enteros se vuelven más grandes que esto, generalmente los convertimos a largos de Python (con una precisión ilimitada, que no deben 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 antiguo int desaparece, y solo usamos (Python''s) mientras int, que tiene una precisión ilimitada.
También podemos obtener información sobre los flotadores 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 __class__ , para obtener el tipo de variable. Utilice el type lugar.
Y no te preocupes demasiado por los detalles de implementación de Python. No he tenido que lidiar con problemas alrededor de esto yo mismo. Probablemente tampoco lo harás, y si realmente lo haces, debes saber lo suficiente como para no estar buscando esta respuesta para saber qué hacer.
¿Cómo veo el tipo de una variable si es sin signo de 32 bits, con signo de 16 bits, etc.?
¿Cómo lo veo?
¿Quieres decir en Python o usando ctypes ?
En el primer caso, simplemente no puede, porque Python no tiene enteros de 16/32 bit con signo / sin signo.
En el segundo caso, puede 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 .
Ejemplos de verificación de tipo simple en Python:
assert type(variable_name) == int
assert type(variable_name) == bool
assert type(variable_name) == list
Es tan simple. Lo haces así.
print(type(variable_name))
La pregunta es algo ambigua: no estoy seguro de lo que quieres decir con "ver". Si está intentando consultar el tipo de un objeto Python nativo, la respuesta de @atzz en la dirección correcta.
Sin embargo, si está intentando generar objetos de Python que tienen la semántica de los tipos C primitivos (como uint32_t , int16_t ), use el módulo struct . Por lo tanto, 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 módulo de array , que puede hacer matrices de estos tipos de nivel inferior:
>>> array.array(''c'').itemsize # char
1
El entero máximo admitido ( int Python 2) lo proporciona 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)
Para python2.x, use
print type(variable_name)
Para python3.x, use
print(type(variable_name))
Puede que estés buscando la función type() .
Vea los ejemplos a continuación, pero no hay un 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''>
Punto flotante entero:
>>> v = 3.14159
>>> type(v)
<type ''float''>
Puede ser poco irrelevante. pero puede verificar los tipos de un objeto con isinstance(object, type) como se menciona here .
Python no tiene los mismos tipos que C / C ++, que parece ser tu 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
Sin embargo, la distinción entre int y long desaparece en Python 3.0.
Python no tiene los tipos que describe. Hay dos tipos utilizados para representar valores integrales: int , que corresponde al tipo int de la plataforma en C, y long , que es un entero de precisión arbitraria (es decir, crece según sea necesario y no tiene un límite superior). int s se convierte silenciosamente a long si una expresión produce un resultado que no se puede almacenar en int .
Realmente depende de a qué nivel te refieres. En Python 2.x, hay dos tipos de enteros, int (restringido a sys.maxint ) y long (precisión ilimitada), por razones históricas. En el código Python, esto no debería hacer una pequeña diferencia porque el intérprete se convierte automáticamente en largo cuando un número es demasiado grande. Si desea conocer 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 averiguar sobre los tipos de sistemas, consulte la respuesta cdleary para usar el módulo struct.
Simple, para python 3.4 y superior
print (type(variable_name))
Python 2.7 y superior
print type(variable_name)
Una forma más usando __class__ :
>>> a = [1, 2, 3, 4]
>>> a.__class__
<type ''list''>
>>> b = {''key1'': ''val1''}
>>> b.__class__
<type ''dict''>
>>> c = 12
>>> c.__class__
<type ''int''>
print type(variable_name)
También recomiendo altamente al intérprete interactivo de IPython 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 del 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 punto flotante se truncará hacia cero (¡esto no incluye una representación de cadena de un número de punto 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 de enteros, se devolverá un objeto largo.