This question already has answers here:
What's the canonical way to check for type in Python?
(15 answers)
Closed 3 years ago.
The community reviewed whether to reopen this question last year and left it closed:
Original close reason(s) were not resolved
How do I check whether a variable is an integer?
If you need to do this, do
isinstance(<var>, int)
unless you are in Python 2.x in which case you want
isinstance(<var>, (int, long))
Do not use type. It is almost never the right answer in Python, since it blocks all the flexibility of polymorphism. For instance, if you subclass int, your new class should register as an int, which type will not do:
class Spam(int): pass
x = Spam(0)
type(x) == int # False
isinstance(x, int) # True
This adheres to Python's strong polymorphism: you should allow any object that behaves like an int, instead of mandating that it be one.
BUT
The classical Python mentality, though, is that it's easier to ask forgiveness than permission. In other words, don't check whether x is an integer; assume that it is and catch the exception results if it isn't:
try:
x += 1
except TypeError:
...
This mentality is slowly being overtaken by the use of abstract base classes, which let you register exactly what properties your object should have (adding? multiplying? doubling?) by making it inherit from a specially-constructed class. That would be the best solution, since it will permit exactly those objects with the necessary and sufficient attributes, but you will have to read the docs on how to use it.
All proposed answers so far seem to miss the fact that a double (floats in python are actually doubles) can also be an integer (if it has nothing after the decimal point). I use the built-in is_integer() method on doubles to check this.
Example (to do something every xth time in a for loop):
for index in range(y):
# do something
if (index/x.).is_integer():
# do something special
Edit:
You can always convert to a float before calling this method. The three possibilities:
>>> float(5).is_integer()
True
>>> float(5.1).is_integer()
False
>>> float(5.0).is_integer()
True
Otherwise, you could check if it is an int first like Agostino said:
def is_int(val):
if type(val) == int:
return True
else:
if val.is_integer():
return True
else:
return False
Here's a summary of the different methods mentioned here:
int(x) == x
try x = operator.index(x)
isinstance(x, int)
isinstance(x, numbers.Integral)
and here's how they apply to a variety of numerical types that have integer value:
You can see they aren't 100% consistent. Fraction and Rational are conceptually the same, but one supplies a .index() method and the other doesn't. Complex types don't like to convert to int even if the real part is integral and imaginary part is 0.
(np.int8|16|32|64(5) means that np.int8(5), np.int32(5), etc. all behave identically)
If you really need to check then it's better to use abstract base classes rather than concrete classes. For an integer that would mean:
>>> import numbers
>>> isinstance(3, numbers.Integral)
True
This doesn't restrict the check to just int, or just int and long, but also allows other user-defined types that behave as integers to work.
>>> isinstance(3, int)
True
See here for more.
Note that this does not help if you're looking for int-like attributes. In this case you may also want to check for long:
>>> isinstance(3L, (long, int))
True
I've seen checks of this kind against an array/index type in the Python source, but I don't think that's visible outside of C.
Token SO reply: Are you sure you should be checking its type? Either don't pass a type you can't handle, or don't try to outsmart your potential code reusers, they may have a good reason not to pass an int to your function.
Why not try something like:
if x%1 == 0:
Rather than over complicate things, why not just a simple
if type(var) is int:
A simple method I use in all my software is this. It checks whether the variable is made up of numbers.
test = input("Enter some text here: ")
if test.isdigit() == True:
print("This is a number.")
else:
print("This is not a number.")
You can also use str.isdigit. Try looking up help(str.isdigit)
def is_digit(str):
return str.isdigit()
Found a related question here on SO itself.
Python developers prefer to not check types but do a type specific operation and catch a TypeError exception. But if you don't know the type then you have the following.
>>> i = 12345
>>> type(i)
<type 'int'>
>>> type(i) is int
True
it's really astounding to see such a heated discussion coming up when such a basic, valid and, i believe, mundane question is being asked.
some people have pointed out that type-checking against int (and long) might loose cases where a big decimal number is encountered. quite right.
some people have pointed out that you should 'just do x + 1 and see whether that fails. well, for one thing, this works on floats too, and, on the other hand, it's easy to construct a class that is definitely not very numeric, yet defines the + operator in some way.
i am at odds with many posts vigorously declaring that you should not check for types. well, GvR once said something to the effect that in pure theory, that may be right, but in practice, isinstance often serves a useful purpose (that's a while ago, don't have the link; you can read what GvR says about related issues in posts like this one).
what is funny is how many people seem to assume that the OP's intent was to check whether the type of a given x is a numerical integer type—what i understood is what i normally mean when using the OP's words: whether x represents an integer number. and this can be very important: like ask someone how many items they'd want to pick, you may want to check you get a non-negative integer number back. use cases like this abound.
it's also, in my opinion, important to see that (1) type checking is but ONE—and often quite coarse—measure of program correctness, because (2) it is often bounded values that make sense, and out-of-bounds values that make nonsense. sometimes just some intermittent values make sense—like considering all numbers, only those real (non-complex), integer numbers might be possible in a given case.
funny non-one seems to mention checking for x == math.floor( x ). if that should give an error with some big decimal class, well, then maybe it's time to re-think OOP paradigms. there is also PEP 357 that considers how to use not-so-obviously-int-but-certainly-integer-like values to be used as list indices. not sure whether i like the solution.
If you want to check that a string consists of only digits, but converting to an int won't help, you can always just use regex.
import re
x = "01234"
match = re.search("^\d+$", x)
try: x = match.group(0)
except AttributeError: print("not a valid number")
Result: x == "01234"
In this case, if x were "hello", converting it to a numeric type would throw a ValueError, but data would also be lost in the process. Using a regex and catching an AttributeError would allow you to confirm numeric characters in a string with, for instance, leading 0's.
If you didn't want it to throw an AttributeError, but instead just wanted to look for more specific problems, you could vary the regex and just check the match:
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"
That actually shows you where the problem occurred without the use of exceptions. Again, this is not for testing the type, but rather the characters themselves. This gives you much more flexibility than simply checking for types, especially when converting between types can lose important string data, like leading 0's.
why not just check if the value you want to check is equal to itself cast as an integer as shown below?
def isInt(val):
return val == int(val)
It is very simple to check in python. You can do like this:
Suppose you want to check a variable is integer or not!
## For checking a variable is integer or not in python
if type(variable) is int:
print("This line will be executed")
else:
print("Not an integer")
If you are reading from a file and you have an array or dictionary with values of multiple datatypes, the following will be useful.
Just check whether the variable can be type casted to int(or any other datatype you want to enforce) or not.
try :
int(a);
#Variable a is int
except ValueError :
# Variable a is not an int
In the presence of numpy check like ..
isinstance(var, numbers.Integral)
.. (slow) or ..
isinstance(var, (int, long, np.integer))
.. in order to match all type variants like np.int8, np.uint16, ...
(Drop long in PY3)
Recognizing ANY integer-like object from anywhere is a tricky guessing game. Checking
var & 0 == 0
for truth and non-exception may be a good bet. Similarly, checking for signed integer type exclusively:
var ^ -1 == -var - 1
If the variable is entered like a string (e.g. '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.
Before using this I worked it out with try/except and checking for (int(variable)), but it was longer code. I wonder if there's any difference in use of resources or speed.
A simple way to do this is to directly check if the remainder on division by 1 is 0 or not.
if this_variable % 1 == 0:
list.append(this_variable)
else:
print 'Not an Integer!'
Here is a simple example how you can determine an integer
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
If you just need the value, operator.index (__index__ special method) is the way to go in my opinion. Since it should work for all types that can be safely cast to an integer. I.e. floats fail, integers, even fancy integer classes that do not implement the Integral abstract class work by duck typing.
operator.index is what is used for list indexing, etc. And in my opinion it should be used for much more/promoted.
In fact I would argue it is the only correct way to get integer values if you want to be certain that floating points, due to truncating problems, etc. are rejected and it works with all integral types (i.e. numpy, etc.) even if they may not (yet) support the abstract class.
This is what __index__ was introduced for!
If you want to check with no regard for Python version (2.x vs 3.x), use six (PyPI) and it's integer_types attribute:
import six
if isinstance(obj, six.integer_types):
print('obj is an integer!')
Within six (a very light-weight single-file module), it's simply doing this:
import sys
PY3 = sys.version_info[0] == 3
if PY3:
integer_types = int,
else:
integer_types = (int, long)
use the int function to help
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')
I was writing a program to check if a number was square and I encountered this issue, the
code I used was:
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!")
To tell if the number was an integer I converted the float number you get from square rooting the user input to a rounded integer (stored as the value ), if those two numbers were equal then the first number must have been an integer, allowing the program to respond. This may not be the shortest way of doing this but it worked for me.
You can do this.
if type(x) is int:
#!/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)
If you have not int you can do just this:
var = 15.4
if(var - int(var) != 0):
print "Value is not integer"
If you want to write a Python 2-3 compatible code
To test whether a value is an integer (of any kind), you can to do this :
# Python 2 and 3:
import sys
if sys.version_info < (3,):
integer_types = (int, long,)
else:
integer_types = (int,)
>>> isinstance(1, integer_types)
True
# Python 2 only:
if isinstance(x, (int, long)):
...
# Python 3 only:
if isinstance(x, int):
...
source : http://python3porting.com/differences.html
A more general approach that will attempt to check for both integers and integers given as strings will be
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
you can do this by:
name = 'Bob'
if type(name) == str:
print 'this works'
else:
print 'this does not work'
and it will return 'this works'... but if you change name to int(1) then it will return 'this does not work' because it is now a string...
you can also try:
name = int(5)
if type(name) == int:
print 'this works'
else:
print 'this does not work'
and the same thing will happen
There is another option to do the type check.
For example:
n = 14
if type(n)==int:
return "this is an int"
Related
I'm making a very basic calculator as my first project (I'm learning Python and want something to show what i've learned so far) and as it is right now, the program works fine.
As it is right now, I have a function to validate user inputs so that the code only accepts numbers and decimal points, and returns the input as a float value to be calculated.
However, I would like to make it so that the code can recognize if the user is entering an Integer or a Float value, so that a simple operation such as "2+2" doesn't return a float "4.0" result, and just a "4".
The function that I have working right now is the following:
def valid_num():
number = ''
valid = True
while valid:
try:
number = float(input('───→ '))
break
except ValueError:
print('')
print('Invalid input (numbers and decimal points only).')
return number
To be able to diferentiate between integers and float values, I looked up methods and found the isinstance() function, which I may not be applying correctly... This is the function that I'm trying to make work:
def valid_num():
number = ''
valid = True
while valid:
number = input('───→ ')
check_int = isinstance(number, int)
if check_int:
number = int(number)
break
check_float = isinstance(number, float)
if check_float:
number = float(number)
break
if not check_int and not check_float:
print('Invalid input (numbers and decimal points only).')
return number
Sorry if there's an obvious error I'm not seeing, I'm just starting to code... Thanks in advance for any help you can provide =D
As pointed out by #tim-roberts, isinstance(number, int) checks the type of number, which is a string.
To distinguish ints and floats, you have a couple of options:
Try to convert it to int, if that fails try to convert to float; this would use a pair of try/except clauses.
Validate the input as text, checking that it follows the rules you set for your calculator, probably using regular expressions; this would let you positively assert that it matches what you expect, rather than whatever the int and float functions accept.
You could also work throughout in float (or Decimal), then convert 4.0 to 4 on output; that would mean that you'd also get "4" for "0.5 * 8" (which may be better or worse than getting "4.0"; that's up to your UX design).
I'm a beginner trying to learn Python and decided to try an exercise where I would take an input, and distinguish its type; whether its an integer, floating point or a string.
As I understand it, Python treats all inputs as strings, so even when I enter a number/decimal point, the input is considered a string. I have overcome the first step in differentiating whether the input is a string or otherwise via this:
def get():
prompt = 'Give a number or a word.\n'
x = input(prompt)
try:
float(x)
print('You entered a number.')
except:
print('You entered a string.')
I take advantage of 'try' and 'except', as float(x) will return an error if x is a string and not a number/floating point. Next, I deduce that I can use a similar method to distinguish between integers and floating point numbers, but I don't know what can cause an error for an integer that wouldn't for a floating point, vice versa. (since float(x) where x is an integer works fine)
Is there such a thing so that I can use a similar method to distinguish between decimal number inputs and integers?
There are two questions within your question.
To handle the string > int/float, you could take advantage of ast.literal_eval first:
>>> import ast
>>> print(type(ast.literal_eval("2"))
int
>>> print(type(ast.literal_eval("3.4"))
float
>>> print(ast.literal_eval("3e2"))
300.0
To check for type, you're looking for isinstance I think.
>>> x = 2
>>> print(isinstance(x, int))
True
>>> y = 3.4
>>> print(isinstance(y, int))
False
>>> print(isinstance(y, float))
True
So, putting these two together you could use an if statement like that:
if isinstance(ast.literal_eval(x), int):
# do whatever you want if it's an int
elif isinstance(ast.literal_eval(x), float):
# do whatever you want if it's a float
It depends on what your definition of an integer is. Is "3.0" an integer? Or just "3"? The former is most commonly represented as a floating point number whose value happens to be a mathematical integer (but not of int type).
If you mean to include "3.0", then you can do a test which catches both "3.0" and "3":
f = float(x)
if f==int(f):
print("really an integer value")
Otherwise you can use isinstance(f, int).
(Caveat: this is easier in Python3. In Python2 there are two kinds of integers -- int and long which you have to test for separately).
The input is alway a string.
You just want to know if that string can be converted to an int or a float value. You can easily convince yourself that most(*) integer representation can be converted to float values while the symetric is not true.
So you should
try to convert to an int
if it failed try to convert to a float
if it still failed process input as a string
The rationale is that if the user typed 3.0 they probably intended that it should be a float value, else they would have typed 3.
Python integers are only limited by the available memory while float are 64 bits iEEE-754 floating point numbers. But Python is kind enough to convert integers greater to the max float values to inf. So even an integer that cannot be represented as a float would be converted with no exception
This question already has answers here:
Asking the user for input until they give a valid response
(22 answers)
Closed 7 years ago.
I have to create a calculator for a small piece of schoolwork and I ask for inputs for the numbers and the symbol that will be used:
number1=int(input("\nWhat is your first number?"))
number2=int(input("\nWhat is your second number?"))
symbol=input("\nWhat is the symbol you will use?")
I want to know if there is any way I can make the int(input()) be asked again if they enter anything apart from an integer.
I'm not really good with Python atm so apologies if I missed something obvious.
Also sorry if this thread is a duplicate.
The canonical method in python would be something like:
def get_integer_or_retry(mesg)
while True:
val = input(mesg) # or raw_input for python 2
try:
val = int(val)
return val
except ValueError: #trying to cast string as int failed
pass # or you could let the user know their input was invalid
Note that if the user inputs 1.0 (or some other decimal that is also an integer), this will still throw ValueError (thanks Robᵩ ); if you need to handle floats that happen to be integers, you could do val = int(float(val)), but that will also accept (and silently round down) floating numbers ...
To know a variables type do type(var).
So, basically what you need to do:
if type(variable)==int:
do_something
Try isinstance method (https://docs.python.org/3/library/functions.html#isinstance)
>>> isinstance(5, int)
True
>>> isinstance("a", int)
False
in your case write a conditional, like,
if isinstance(number1, int):
#do something
The isinstance() built-in function is recommended for testing the type
of an object, because it takes subclasses into account.
I'm going to assume Python 2.7 for this answer.
I suggest first getting the input as a string, using raw_input, and
then trying to convert that to an integer. Python will raise an
exception if the conversion fails, which you can catch and prompt the
user to try again.
Here's an example:
while True:
try:
s1 = raw_input('Enter integer: ')
n1 = int(s1)
# if we get here, conversion succeeded
break
except ValueError:
print('"%s" is not an integer' % s1)
print('integer doubled is %d' % (2*n1))
and here's a sample execution, with inputs:
$ python 33107568.py
Enter integer: foo
"foo" is not an integer
Enter integer: 1.1
"1.1" is not an integer
Enter integer: 0x23123
"0x23123" is not an integer
Enter integer: 123
integer doubled is 246
On Python 3, you'd need to use input instead of raw_input; in
Python 2, input evaluates the user input as a Python expression,
which is rarely what is desired.
Part of my homework assignment is to write a function that will parse a string such as '-.4e-4' and identify any problems that would prevent it from being cast to a float. For example, in '10e4.5' I would need to detect the decimal in the exponent and provide a relevant error message.
I have attempted many things. The first and, of course, most basic is the try: except:. Attempt to cast it to a float and let Python do the heavy lifting. However, as far as I can see, the errors it can return are not descriptive enough for this assignment.
The second thing I tried was to normalize the string, replacing all digits with n, signs with s, decimals with d, exponents with e (the maketrans function from C made this very fast). Then, I cut down any repeated n's to a single n. I made a list of all valid float formats and checked if the normalized string was in that list. AKA, I white-listed it. It worked perfectly and rather time-efficiently, but again, no error checking. That code is posted below.
import string,time
check_float_trans = string.maketrans("nsd0123456789-+.","???nnnnnnnnnnssd")
check_float_valids = 'n sn sndn ndn ndnen dn sdn sdnen sdnesn dnesn dnen nen nesn snesn sn snen sndnen sndnesn ndnesn'.split()
def check_float( test ):
"""Check if string <test> could be cast as a float, returns boolean."""
test = test.translate(check_float_trans)
test = ''.join([a for a,b in zip(test, ' '+test) if a != b])
return test in check_float_valids
I was hoping someone here could give me some pointers. I don't want this handed to me, but I am relatively stuck. I tried guardian-coding it, trying to identify reasons why the string might not be castable as a float, but I could never put up enough walls to ensure that no bad strings got a false positive.
Thanks.
Here's what I would do... (also this is untested)
def isValid(expression):
if 'e' in expression:
number, exponent = expression.split('e')
else:
print "not a valid format, no 'e' in expression"
return False
# a bunch of other if statments here to check for
#certain conditions like '.' in the exponent component
return float(number) ** float(exponent)
if __name__ == '__main__':
print isValid('-.4e-4')
print isValid('10e4.5')
I couldn't find another answer when I wanted this, so I thought I would post my own solution for anyone else and also get corrections if I've done something wrong.
I had to make an automatic config file parser and I preferred to make numbers int if possible and float if not. The usual try/except conversion doesn't work by itself since any float will just be coerced to an int.
To clarify as someone asked, the case is basically to convert numbers as the person writing the config file data intended them to be. So anything with decimals would probably be intended to be a float. Also, I believe that float can be dangerous for some operators (e.g. ==, <, >) due to the nature of floating point numbers, and int will be converted to float when necessary. Therefore I prefer numbers to stay in int when possible. Not a big thing, just as a kind of convention for myself.
def int_or_float(s):
try:
return int(s)
except ValueError:
return float(s)
If you want something like "10.0000" converted to int, try this:
def int_dammit_else_float(s):
f = float(s)
i = int(f)
return i if i == f else f
What result do you want for input like "1e25"?
This is one time where it's probably better to get permission first than ask for forgiveness later which is usually considered the 'Pythonic' way to do things and usually involves try/except. So something simple like this might be good enough:
v = float(s) if '.' in s or 'e' in s.lower() else int(s)
Since there's more than one character that can signal a floating point number, you could also check for one of them these following other ways:
import re
pattern = re.compile(r'[.eE]')
v = float(s) if pattern.findall(s) else int(s)
or
chars = set('.eE')
v = float(s) if any((c in chars) for c in s) else int(s)
Lastly, on a slightly different track, if you wanted floating point whole numbers to become integers, you could do the following, which is similar to #John Machin's "_dammit_" function:
v = int(float(s)) if int(float(s)) == float(s) else float(s)
eval(s)
eval() is a function that accepts a string and processes it as Python code. When given any kind of literal as a string, it will return a Python object containing that value.
However, from a security standpoint, this is a bad idea, as someone could potentially feed instructions that crash or tamper with your program. You could require it to be a certain set of characters before processing, i.e.:
eval(s) if not set(s).difference('0123456789.') else None
This still probably isn't worth the headache, though. That said, you can get fancy, and allow expressions with calculations as well... and that might be worth trying!
num = lambda s: eval(s) if not set(s).difference('0123456789. *+-/e') else None
>>> num('10')
10
>>> num('10.0')
10.0
>>> num('1e3')
1000.0
>>> num('4.8 * 10**34')
4.8e+34
>>> num('1+2/3')
1.6666666666666665
def int_float_none(x):
# it may be already int or float
if isinstance(x, (int, float)):
return x
# all int like strings can be converted to float so int tries first
try:
return int(x)
except (TypeError, ValueError):
pass
try:
return float(x)
except (TypeError, ValueError):
return None
Function above for any object passed will return int or float conversion or None.
Trying to detect a float isn't easy, but detecting a possible integer is easier.
I would try to check if the string contains only digits (disregarding possible leading spaces or sign) and convert to float or integer accordingly:
lst = ['1' , '2.2' , ' -3','+5']
result = [int(x) if x.lstrip(" -+").isdigit() else float(x) for x in lst]
print(result)
prints:
[1, 2.2, -3, 5]