ylab color python

python - color - plotly layout



Comprobando si una variable es un entero o no (30)

¿Cómo verifico si una variable es un entero?

Puedo verificar si el número es entero incluye un número como 7.0

def is_int(x): if x - round(x) == 0 : return True else: return False

¿Por qué no probar algo como:

if x%1 == 0:

¿por qué no solo comprobar si el valor que desea verificar es igual a él mismo como un entero como se muestra a continuación?

def isInt(val): return val == int(val)

Aquí hay un ejemplo simple de cómo puedes determinar un entero

def is_int(x): print round(x), if x == round(x): print ''True'', else: print ''False'' is_int(7.0) # True is_int(7.5) # False is_int(-1) # True

Aquí hay un resumen de los diferentes métodos mencionados aquí:

  • int(x) == x
  • try x = operator.index(x)
  • isinstance(x, int)
  • isinstance(x, numbers.Integral)

y aquí es cómo se aplican a una variedad de tipos numéricos que tienen valor entero:

Puedes ver que no son 100% consistentes. Fraction y Rational son conceptualmente iguales, pero uno proporciona un método .index() y el otro no. A los tipos complejos no les gusta convertir a int, incluso si la parte real es integral y la parte imaginaria es 0.

( np.int8|16|32|64(5) significa que np.int8(5) , np.int32(5) , etc. se comportan de manera idéntica)

Considere el caso x = n ** (1.0 / m), donde n = 10 ** 5, m = 5. En Python, x será 10.000000000000002, que no es entero debido a las operaciones aritméticas de punto flotante.

Así que yo revisaría

if str(float(x)).endswith(''.0''): print "It''s an integer."

Lo he probado con este código:

for a in range(2,100): for b in range(2,100): x = (a**b)**(1.0/b) print a,b, x, str(float(x)).endswith(''.0'')

Da salida True para todos a y b.

En lugar de complicar las cosas, ¿por qué no solo un simple

if type(var) is int:

En presencia de la comprobación numpy como ..

isinstance(var, numbers.Integral)

.. (lento) o ..

isinstance(var, (int, long, np.integer))

.. para coincidir con todas las variantes de tipo como np.int8 , np.uint16 , ...

(Caída long en PY3)

Reconocer CUALQUIER objeto de tipo entero desde cualquier lugar es un juego de adivinanzas complicado. Comprobación

var & 0 == 0

Porque la verdad y la no excepción pueden ser una buena apuesta. Del mismo modo, comprobando el tipo entero con signo exclusivamente :

var ^ -1 == -var - 1

Encontré una pregunta relacionada aquí en SO en sí.

Los desarrolladores de Python prefieren no verificar tipos, pero realizan una operación específica de tipo y TypeError una excepción TypeError . Pero si no sabes el tipo, tienes lo siguiente.

>>> i = 12345 >>> type(i) <type ''int''> >>> type(i) is int True

Estaba escribiendo un programa para verificar si un número era cuadrado y encontré este problema, el código que usé fue:

import math print ("this program will tell you if a number is square") print ("enter an integer") num = float(input()) if num > 0: print ("ok!") num = (math.sqrt(num)) inter = int(num) if num == inter: print ("It''s a square number, and its root is") print (num) else: print ("It''s not a square number, but its root is") print (num) else: print ("That''s not a positive number!")

Para saber si el número era un número entero, convertí el número flotante que obtienes del enraizamiento cuadrado de la entrada del usuario a un número entero redondeado (almacenado como valor), si esos dos números eran iguales, entonces el primer número debe haber sido un número entero, permitiendo que programa para responder. Puede que esta no sea la forma más corta de hacer esto, pero funcionó para mí.

Hay otra opción para hacer la verificación de tipo.

Por ejemplo:

n = 14 if type(n)==int: return "this is an int"

Puedes hacerlo.

if type(x) is int:

Si realmente necesita verificar, es mejor usar clases base abstractas en lugar de clases concretas. Para un entero que significaría:

>>> import numbers >>> isinstance(3, numbers.Integral) True

Esto no restringe la comprobación a solo int , o solo int y long , sino que también permite que funcionen otros tipos definidos por el usuario que se comportan como enteros.

Si desea consultar sin tener en cuenta la versión de Python (2.x vs 3.x), use six ( PyPI ) y su atributo integer_types :

import six if isinstance(obj, six.integer_types): print(''obj is an integer!'')

Dentro de six (un módulo de un solo archivo muy ligero), simplemente está haciendo esto:

import sys PY3 = sys.version_info[0] == 3 if PY3: integer_types = int, else: integer_types = (int, long)

Si desea verificar que una cadena se compone solo de dígitos, pero la conversión a un int no ayudará, siempre puede usar expresiones regulares.

import re x = "01234" match = re.search("^/d+$", x) try: x = match.group(0) except AttributeError: print("not a valid number") Result: x == "01234"

En este caso, si x fuera "hola", convertirlo a un tipo numérico arrojaría un ValueError, pero los datos también se perderían en el proceso. El uso de una expresión regular y la captura de un AttributeError le permitiría confirmar caracteres numéricos en una cadena, por ejemplo, con 0 iniciales.

Si no quería que lanzara un AttributeError, sino que solo deseaba buscar problemas más específicos, podía variar la expresión regular y simplemente verificar la coincidencia:

import re x = "h01234" match = re.search("/D", x) if not match: print("x is a number") else: print("encountered a problem at character:", match.group(0)) Result: "encountered a problem at character: h"

Eso realmente le muestra dónde ocurrió el problema sin el uso de excepciones. Nuevamente, esto no es para probar el tipo, sino más bien para los personajes. Esto le brinda mucha más flexibilidad que la simple comprobación de tipos, especialmente cuando la conversión entre tipos puede perder datos importantes de cadenas, como los 0 primeros.

Si está leyendo un archivo y tiene una matriz o diccionario con valores de varios tipos de datos, lo siguiente será útil. Solo verifique si la variable puede ser convertida en tipo int (o cualquier otro tipo de datos que quiera aplicar) o no.

try : int(a); #Variable a is int except ValueError : # Variable a is not an int

Si la variable se ingresa como una cadena (por ejemplo, ''2010'' ):

if variable and variable.isdigit(): return variable #or whatever you want to do with it. else: return "Error" #or whatever you want to do with it.

Antes de usar esto, lo resolví con try/except y revisé (int(variable)) , pero era un código más largo. Me pregunto si hay alguna diferencia en el uso de los recursos o la velocidad.

Si necesitas hacer esto, hazlo.

isinstance(<var>, int)

a menos que estés en Python 2.x en el caso que quieras

isinstance(<var>, (int, long))

No utilice el type . Casi nunca es la respuesta correcta en Python, ya que bloquea toda la flexibilidad del polimorfismo. Por ejemplo, si subclasifica int , su nueva clase debería registrarse como un int , qué type no hará:

class Spam(int): pass x = Spam(0) type(x) == int # False isinstance(x, int) # True

Esto se adhiere al fuerte polimorfismo de Python: debe permitir cualquier objeto que se comporte como un int , en lugar de exigir que sea uno.

PERO

La mentalidad clásica de Python, sin embargo, es que es más fácil pedir perdón que permiso . En otras palabras, no compruebe si x es un número entero; asume que es y captura los resultados de la excepción si no lo es:

try: x += 1 except TypeError: ...

Esta mentalidad está siendo superada lentamente por el uso de clases base abstractas , que le permiten registrar exactamente qué propiedades debe tener su objeto (¿agregar? ¿Multiplicar? ¿Duplicar?) Haciéndolo heredar de una clase especialmente construida. Esa sería la mejor solución, ya que permitirá exactamente esos objetos con los atributos necesarios y suficientes, pero tendrá que leer los documentos sobre cómo usarlos.

Si no tienes int , puedes hacer esto:

var = 15.4 if(var - int(var) != 0): print "Value is not integer"

Si solo necesita el valor , operator.index ( __index__ special method) es el camino a seguir en mi opinión. Ya que debería funcionar para todos los tipos que se pueden convertir de forma segura a un entero. Es decir, los flotadores fallan, los enteros, incluso las clases enteras extravagantes que no implementan el trabajo de la clase abstracta integral mediante la tipificación duck.

operator.index es lo que se usa para indexar listas, etc. Y, en mi opinión, debería usarse para mucho más / promovido

De hecho, diría que es la única forma correcta de obtener valores enteros si quiere estar seguro de que los puntos flotantes, debido a problemas de truncamiento, etc. se rechazan y funcionan con todos los tipos integrales (es decir, numpy, etc.) incluso si pueden no (todavía) apoyar la clase abstracta.

¡Esto es para lo que se introdujo __index__ !

Todas las respuestas propuestas hasta ahora parecen pasar por alto el hecho de que un doble (las flotaciones en python en realidad son dobles) también puede ser un entero (si no tiene nada después del punto decimal). Utilizo el método is_integer() en dobles para verificar esto.

Ejemplo (para hacer algo cada xth vez en un bucle for):

for index in range(y): # do something if (index/x.).is_integer(): # do something special

Editar:

Siempre puedes convertir a un flotador antes de llamar a este método. Las tres posibilidades:

>>> float(5).is_integer() True >>> float(5.1).is_integer() False >>> float(5.0).is_integer() True

De lo contrario, puedes verificar si es un int primero, como dijo Agostino:

def is_int(val): if type(val) == int: return True else: if val.is_integer(): return True else: return False

Un enfoque más general que intentará verificar tanto los enteros como los enteros dados como cadenas será

def isInt(anyNumberOrString): try: int(anyNumberOrString) #to check float and int use "float(anyNumberOrString)" return True except ValueError : return False isInt("A") #False isInt("5") #True isInt(8) #True isInt("5.88") #False *see comment above on how to make this True

Un método simple que utilizo en todo mi software es este. Comprueba si la variable está formada por números.

test = input("Enter some text here: ") if test.isdigit() == True: print("This is a number.") else: print("This is not a number.")

Una forma sencilla de hacer esto es verificar directamente si el resto de la división por 1 es 0 o no.

if this_variable % 1 == 0: list.append(this_variable) else: print ''Not an Integer!''

es realmente asombroso ver que se avecina una discusión tan acalorada cuando se formula una pregunta tan básica, válida y, creo, mundana.

algunas personas han señalado que la comprobación de tipo contra int (y long ) puede perder casos en los que se encuentra un gran número decimal. Muy bien.

algunas personas han señalado que deberías "hacer x + 1 y ver si eso falla". Bueno, por un lado, esto también funciona con flotadores, y, por otro lado, es fácil construir una clase que definitivamente no es muy numérica, pero que define el operador + de alguna manera.

Estoy en desacuerdo con muchas publicaciones y declaro enérgicamente que no debe verificar los tipos. bueno, una vez GvR dijo algo en el sentido de que, en teoría pura, eso puede ser correcto, pero en la práctica, la isinstance menudo sirve para un propósito útil (eso es hace un tiempo, no tiene el enlace; puede leer lo que dice GvR acerca de temas en publicaciones como esta ).

lo que es divertido es la cantidad de personas que parecen asumir que la intención del OP era verificar si el tipo de una x dada es un tipo entero numérico; lo que entendí es lo que normalmente quiero decir cuando uso las palabras del OP: si x representa un número entero . y esto puede ser muy importante: al igual que preguntar a alguien cuántos elementos querrían elegir, es posible que desee verificar si obtiene un número entero no negativo. Los casos de uso como este abundan.

también es, en mi opinión, importante ver que (1) la comprobación de tipos es solo UNA (y, a menudo, bastante) medida de la corrección del programa, porque (2) a menudo son valores limitados que tienen sentido y valores fuera de límites que hacen tonterias a veces, solo algunos valores intermitentes tienen sentido; como considerar todos los números, solo los números enteros reales (no complejos) podrían ser posibles en un caso determinado.

divertido no-uno parece mencionar la comprobación de x == math.floor( x ) . Si eso da un error con alguna clase decimal grande, bueno, entonces tal vez sea hora de repensar los paradigmas OOP. también hay PEP 357 que considera cómo usar valores no tan obvios como int -but-ciertamente-integer-like para ser usados ​​como índices de lista. No estoy seguro de si me gusta la solución.

puedes hacer esto por

name = ''Bob'' if type(name) == str: print ''this works'' else: print ''this does not work''

y devolverá ''esto funciona'' ... pero si cambia el nombre a int (1), devolverá ''esto no funciona'' porque ahora es una cadena ... también puede probar:

name = int(5) if type(name) == int: print ''this works'' else: print ''this does not work''

y lo mismo pasara

usa la función int para ayudar

intchecker = float(input(''Please enter a integer: '')) intcheck = 0 while intcheck != 1: if intchecker - int(intchecker) > 0: intchecker = float(input("You didn''t enter a integer. " "Please enter a integer: ")) else: intcheck = 1 print(''you have entered a integer'')

#!/usr/bin/env python import re def is_int(x): if(isinstance(x,(int,long))): return True matchObj = re.match(r''^-?/d+/.(/d+)'',str(x)) if matchObj: x = matchObj.group(1) if int(x)-0==0: return True return False print is_int(6) print is_int(1.0) print is_int(1.1) print is_int(0.1) print is_int(-956.0)

####################################### # Value_Is_Int ####################################### def value_is_int(value): try: tempVal = int(value) return True except: return False

Llame a esta función:

if value_is_int(value): print "Integer" else: print "Not integer"

>>> isinstance(3, int) True

Vea here para más.

Tenga en cuenta que esto no ayuda si está buscando atributos como int . En este caso es posible que también desee comprobar por long :

>>> isinstance(3L, (long, int)) True

He visto verificaciones de este tipo contra un tipo de matriz / índice en la fuente de Python, pero no creo que sea visible fuera de C.

Token Respuesta SO: ¿Está seguro de que debería estar comprobando su tipo? O no pase un tipo que no pueda manejar, o no intente ser más astuto que sus posibles reutilizadores de código, pueden tener una buena razón para no pasar un int a su función.