# How can I check if a string represents an int, without using try/except?

## Question:

Is there any way to tell whether a string represents an integer (e.g., `'3'`, `'-17'` but not `'3.14'` or `'asfasfas'`) Without using a try/except mechanism?

``````is_int('3.14') == False
is_int('-7')   == True
``````

with positive integers you could use `.isdigit`:

``````>>> '16'.isdigit()
True
``````

it doesn’t work with negative integers though. suppose you could try the following:

``````>>> s = '-17'
>>> s.startswith('-') and s[1:].isdigit()
True
``````

it won’t work with `'16.0'` format, which is similar to `int` casting in this sense.

edit:

``````def check_int(s):
if s[0] in ('-', '+'):
return s[1:].isdigit()
return s.isdigit()
``````

Use a regular expression:

``````import re
def RepresentsInt(s):
return re.match(r"[-+]?d+\$", s) is not None
``````

If you must accept decimal fractions also:

``````def RepresentsInt(s):
return re.match(r"[-+]?d+(.0*)?\$", s) is not None
``````

For improved performance if you’re doing this often, compile the regular expression only once using `re.compile()`.

Greg Hewgill’s approach was missing a few components: the leading “^” to only match the start of the string, and compiling the re beforehand. But this approach will allow you to avoid a try: exept:

``````import re
INT_RE = re.compile(r"^[-]?d+\$")
def RepresentsInt(s):
return INT_RE.match(str(s)) is not None
``````

I would be interested why you are trying to avoid try: except?

If you’re really just annoyed at using `try/except`s all over the place, please just write a helper function:

``````def represents_int(s):
try:
int(s)
except ValueError:
return False
else:
return True
``````
``````>>> print(represents_int("+123"))
True
>>> print(represents_int("10.0"))
False
``````

It’s going to be WAY more code to exactly cover all the strings that Python considers integers. I say just be pythonic on this one.

The proper RegEx solution would combine the ideas of Greg Hewgill and Nowell, but not use a global variable. You can accomplish this by attaching an attribute to the method. Also, I know that it is frowned upon to put imports in a method, but what I’m going for is a “lazy module” effect like http://peak.telecommunity.com/DevCenter/Importing#lazy-imports

edit: My favorite technique so far is to use exclusively methods of the String object.

``````#!/usr/bin/env python

# Uses exclusively methods of the String object
def isInteger(i):
i = str(i)
return i=='0' or (i if i.find('..') > -1 else i.lstrip('-+').rstrip('0').rstrip('.')).isdigit()

# Uses re module for regex
def isIntegre(i):
import re
if not hasattr(isIntegre, '_re'):
print("I compile only once. Remove this line when you are confident in that.")
isIntegre._re = re.compile(r"[-+]?d+(.0*)?\$")
return isIntegre._re.match(str(i)) is not None

# When executed directly run Unit Tests
if __name__ == '__main__':
for obj in [
# integers
0, 1, -1, 1.0, -1.0,
'0', '0.','0.0', '1', '-1', '+1', '1.0', '-1.0', '+1.0',
# non-integers
1.1, -1.1, '1.1', '-1.1', '+1.1',
'1.1.1', '1.1.0', '1.0.1', '1.0.0',
'1.0.', '1..0', '1..',
'0.0.', '0..0', '0..',
'one', object(), (1,2,3), [1,2,3], {'one':'two'}
]:
# Notice the integre uses 're' (intended to be humorous)
integer = ('an integer' if isInteger(obj) else 'NOT an integer')
integre = ('an integre' if isIntegre(obj) else 'NOT an integre')
# Make strings look like strings in the output
if isinstance(obj, str):
obj = ("'%s'" % (obj,))
print("%30s is %14s is %14s" % (obj, integer, integre))
``````

And for the less adventurous members of the class, here is the output:

``````I compile only once. Remove this line when you are confident in that.
0 is     an integer is     an integre
1 is     an integer is     an integre
-1 is     an integer is     an integre
1.0 is     an integer is     an integre
-1.0 is     an integer is     an integre
'0' is     an integer is     an integre
'0.' is     an integer is     an integre
'0.0' is     an integer is     an integre
'1' is     an integer is     an integre
'-1' is     an integer is     an integre
'+1' is     an integer is     an integre
'1.0' is     an integer is     an integre
'-1.0' is     an integer is     an integre
'+1.0' is     an integer is     an integre
1.1 is NOT an integer is NOT an integre
-1.1 is NOT an integer is NOT an integre
'1.1' is NOT an integer is NOT an integre
'-1.1' is NOT an integer is NOT an integre
'+1.1' is NOT an integer is NOT an integre
'1.1.1' is NOT an integer is NOT an integre
'1.1.0' is NOT an integer is NOT an integre
'1.0.1' is NOT an integer is NOT an integre
'1.0.0' is NOT an integer is NOT an integre
'1.0.' is NOT an integer is NOT an integre
'1..0' is NOT an integer is NOT an integre
'1..' is NOT an integer is NOT an integre
'0.0.' is NOT an integer is NOT an integre
'0..0' is NOT an integer is NOT an integre
'0..' is NOT an integer is NOT an integre
'one' is NOT an integer is NOT an integre
<object object at 0x103b7d0a0> is NOT an integer is NOT an integre
(1, 2, 3) is NOT an integer is NOT an integre
[1, 2, 3] is NOT an integer is NOT an integre
{'one': 'two'} is NOT an integer is NOT an integre
``````

Uh.. Try this:

``````def int_check(a):
if int(a) == a:
return True
else:
return False
``````

This works if you don’t put a string that’s not a number.

And also (I forgot to put the number check part. ), there is a function checking if the string is a number or not. It is str.isdigit(). Here’s an example:

``````a = 2
a.isdigit()
``````

If you call a.isdigit(), it will return True.

You know, I’ve found (and I’ve tested this over and over) that try/except does not perform all that well, for whatever reason. I frequently try several ways of doing things, and I don’t think I’ve ever found a method that uses try/except to perform the best of those tested, in fact it seems to me those methods have usually come out close to the worst, if not the worst. Not in every case, but in many cases. I know a lot of people say it’s the "Pythonic" way, but that’s one area where I part ways with them. To me, it’s neither very performant nor very elegant, so, I tend to only use it for error trapping and reporting.

I was going to gripe that PHP, perl, ruby, C, and even the freaking shell have simple functions for testing a string for integer-hood, but due diligence in verifying those assumptions tripped me up! Apparently this lack is a common sickness.

Here’s a quick and dirty edit of Bruno’s post:

``````import sys, time, re

g_intRegex = re.compile(r"^([+-]?[1-9]d*|0)\$")

testvals = [
# integers
0, 1, -1, 1.0, -1.0,
'0', '0.','0.0', '1', '-1', '+1', '1.0', '-1.0', '+1.0', '06',
# non-integers
'abc 123',
1.1, -1.1, '1.1', '-1.1', '+1.1',
'1.1.1', '1.1.0', '1.0.1', '1.0.0',
'1.0.', '1..0', '1..',
'0.0.', '0..0', '0..',
'one', object(), (1,2,3), [1,2,3], {'one':'two'},
# with spaces
' 0 ', ' 0.', ' .0','.01 '
]

def isInt_try(v):
try:     i = int(v)
except:  return False
return True

def isInt_str(v):
v = str(v).strip()
return v=='0' or (v if v.find('..') > -1 else v.lstrip('-+').rstrip('0').rstrip('.')).isdigit()

def isInt_re(v):
import re
if not hasattr(isInt_re, 'intRegex'):
isInt_re.intRegex = re.compile(r"^([+-]?[1-9]d*|0)\$")
return isInt_re.intRegex.match(str(v).strip()) is not None

def isInt_re2(v):
return g_intRegex.match(str(v).strip()) is not None

def check_int(s):
s = str(s)
if s[0] in ('-', '+'):
return s[1:].isdigit()
return s.isdigit()

def timeFunc(func, times):
t1 = time.time()
for n in range(times):
for v in testvals:
r = func(v)
t2 = time.time()
return t2 - t1

def testFuncs(funcs):
for func in funcs:
sys.stdout.write( "t%st|" % func.__name__)
print()
for v in testvals:
if type(v) == type(''):
sys.stdout.write("'%s'" % v)
else:
sys.stdout.write("%s" % str(v))
for func in funcs:
sys.stdout.write( "tt%st|" % func(v))
sys.stdout.write("rn")

if __name__ == '__main__':
print()
print("tests..")
testFuncs((isInt_try, isInt_str, isInt_re, isInt_re2, check_int))
print()

print("timings..")
print("isInt_try:   %6.4f" % timeFunc(isInt_try, 10000))
print("isInt_str:   %6.4f" % timeFunc(isInt_str, 10000))
print("isInt_re:    %6.4f" % timeFunc(isInt_re, 10000))
print("isInt_re2:   %6.4f" % timeFunc(isInt_re2, 10000))
print("check_int:   %6.4f" % timeFunc(check_int, 10000))
``````

Here are the performance comparison results:

``````timings..
isInt_try:   0.6426
isInt_str:   0.7382
isInt_re:    1.1156
isInt_re2:   0.5344
check_int:   0.3452
``````

A C method could scan it Once Through, and be done. A C method that scans the string once through would be the Right Thing to do, I think.

EDIT:

I’ve updated the code above to work in Python 3.5, and to include the check_int function from the currently most voted up answer, and to use the current most popular regex that I can find for testing for integer-hood. This regex rejects strings like ‘abc 123’. I’ve added ‘abc 123’ as a test value.

It is Very Interesting to me to note, at this point, that NONE of the functions tested, including the try method, the popular check_int function, and the most popular regex for testing for integer-hood, return the correct answers for all of the test values (well, depending on what you think the correct answers are; see the test results below).

The built-in int() function silently truncates the fractional part of a floating point number and returns the integer part before the decimal, unless the floating point number is first converted to a string.

The check_int() function returns false for values like 0.0 and 1.0 (which technically are integers) and returns true for values like ’06’.

Here are the current (Python 3.5) test results:

``````              isInt_try |       isInt_str       |       isInt_re        |       isInt_re2       |   check_int   |
0               True    |               True    |               True    |               True    |       True    |
1               True    |               True    |               True    |               True    |       True    |
-1              True    |               True    |               True    |               True    |       True    |
1.0             True    |               True    |               False   |               False   |       False   |
-1.0            True    |               True    |               False   |               False   |       False   |
'0'             True    |               True    |               True    |               True    |       True    |
'0.'            False   |               True    |               False   |               False   |       False   |
'0.0'           False   |               True    |               False   |               False   |       False   |
'1'             True    |               True    |               True    |               True    |       True    |
'-1'            True    |               True    |               True    |               True    |       True    |
'+1'            True    |               True    |               True    |               True    |       True    |
'1.0'           False   |               True    |               False   |               False   |       False   |
'-1.0'          False   |               True    |               False   |               False   |       False   |
'+1.0'          False   |               True    |               False   |               False   |       False   |
'06'            True    |               True    |               False   |               False   |       True    |
'abc 123'       False   |               False   |               False   |               False   |       False   |
1.1             True    |               False   |               False   |               False   |       False   |
-1.1            True    |               False   |               False   |               False   |       False   |
'1.1'           False   |               False   |               False   |               False   |       False   |
'-1.1'          False   |               False   |               False   |               False   |       False   |
'+1.1'          False   |               False   |               False   |               False   |       False   |
'1.1.1'         False   |               False   |               False   |               False   |       False   |
'1.1.0'         False   |               False   |               False   |               False   |       False   |
'1.0.1'         False   |               False   |               False   |               False   |       False   |
'1.0.0'         False   |               False   |               False   |               False   |       False   |
'1.0.'          False   |               False   |               False   |               False   |       False   |
'1..0'          False   |               False   |               False   |               False   |       False   |
'1..'           False   |               False   |               False   |               False   |       False   |
'0.0.'          False   |               False   |               False   |               False   |       False   |
'0..0'          False   |               False   |               False   |               False   |       False   |
'0..'           False   |               False   |               False   |               False   |       False   |
'one'           False   |               False   |               False   |               False   |       False   |
<obj..>         False   |               False   |               False   |               False   |       False   |
(1, 2, 3)       False   |               False   |               False   |               False   |       False   |
[1, 2, 3]       False   |               False   |               False   |               False   |       False   |
{'one': 'two'}  False   |               False   |               False   |               False   |       False   |
' 0 '           True    |               True    |               True    |               True    |       False   |
' 0.'           False   |               True    |               False   |               False   |       False   |
' .0'           False   |               False   |               False   |               False   |       False   |
'.01 '          False   |               False   |               False   |               False   |       False   |
``````

Just now I tried adding this function:

``````def isInt_float(s):
try:
return float(str(s)).is_integer()
except:
return False
``````

It performs almost as well as check_int (0.3486) and it returns true for values like 1.0 and 0.0 and +1.0 and 0. and .0 and so on. But it also returns true for ’06’, so. Pick your poison, I guess.

``````>>> "+7".lstrip("-+").isdigit()
True
>>> "-7".lstrip("-+").isdigit()
True
>>> "7".lstrip("-+").isdigit()
True
>>> "13.4".lstrip("-+").isdigit()
False
``````

``````def is_int(val):
return val.lstrip("-+").isdigit()
``````

This is probably the most straightforward and pythonic way to approach it in my opinion. I didn’t see this solution and it’s basically the same as the regex one, but without the regex.

``````def is_int(test):
import string
return not (set(test) - set(string.digits))
``````

I think

``````s.startswith('-') and s[1:].isdigit()
``````

would be better to rewrite to:

``````s.replace('-', '').isdigit()
``````

because s[1:] also creates a new string

But much better solution is

``````s.lstrip('+-').isdigit()
``````

I have one possibility that doesn’t use int at all, and should not raise an exception unless the string does not represent a number

``````float(number)==float(number)//1
``````

It should work for any kind of string that float accepts, positive, negative, engineering notation…

Here is a function that parses without raising errors. It handles obvious cases returns `None` on failure (handles up to 2000 ‘-/+’ signs by default on CPython!):

``````#!/usr/bin/env python

def get_int(number):
splits = number.split('.')
if len(splits) > 2:
# too many splits
return None
if len(splits) == 2 and splits[1]:
# handle decimal part recursively :-)
if get_int(splits[1]) != 0:
return None

int_part = splits[0].lstrip("+")
if int_part.startswith('-'):
# handle minus sign recursively :-)
return get_int(int_part[1:]) * -1
# successful 'and' returns last truth-y value (cast is always valid)
return int_part.isdigit() and int(int_part)
``````

Some tests:

``````tests = ["0", "0.0", "0.1", "1", "1.1", "1.0", "-1", "-1.1", "-1.0", "-0", "--0", "---3", '.3', '--3.', "+13", "+-1.00", "--+123", "-0.000"]

for t in tests:
print "get_int(%s) = %s" % (t, get_int(str(t)))
``````

Results:

``````get_int(0) = 0
get_int(0.0) = 0
get_int(0.1) = None
get_int(1) = 1
get_int(1.1) = None
get_int(1.0) = 1
get_int(-1) = -1
get_int(-1.1) = None
get_int(-1.0) = -1
get_int(-0) = 0
get_int(--0) = 0
get_int(---3) = -3
get_int(.3) = None
get_int(--3.) = 3
get_int(+13) = 13
get_int(+-1.00) = -1
get_int(--+123) = 123
get_int(-0.000) = 0
``````

For your needs you can use:

``````def int_predicate(number):
return get_int(number) is not None
``````

I really liked Shavais’ post, but I added one more test case ( & the built in isdigit() function):

``````def isInt_loop(v):
v = str(v).strip()
# swapping '0123456789' for '9876543210' makes nominal difference (might have because '1' is toward the beginning of the string)
numbers = '0123456789'
for i in v:
if i not in numbers:
return False
return True

def isInt_Digit(v):
v = str(v).strip()
return v.isdigit()
``````

and it significantly consistently beats the times of the rest:

``````timings..
isInt_try:   0.4628
isInt_str:   0.3556
isInt_re:    0.4889
isInt_re2:   0.2726
isInt_loop:   0.1842
isInt_Digit:   0.1577
``````

using normal 2.7 python:

``````\$ python --version
Python 2.7.10
``````

Both the two test cases I added (isInt_loop and isInt_digit) pass the exact same test cases (they both only accept unsigned integers), but I thought that people could be more clever with modifying the string implementation (isInt_loop) opposed to the built in isdigit() function, so I included it, even though there’s a slight difference in execution time. (and both methods beat everything else by a lot, but don’t handle the extra stuff: “./+/-” )

Also, I did find it interesting to note that the regex (isInt_re2 method) beat the string comparison in the same test that was performed by Shavais in 2012 (currently 2018). Maybe the regex libraries have been improved?

I guess the question is related with speed since the try/except has a time penalty:

# test data

First, I created a list of 200 strings, 100 failing strings and 100 numeric strings.

``````from random import shuffle
numbers = [u'+1'] * 100
nonumbers = [u'1abc'] * 100
testlist = numbers + nonumbers
shuffle(testlist)
testlist = np.array(testlist)
``````

# numpy solution (only works with arrays and unicode)

np.core.defchararray.isnumeric can also work with unicode strings `np.core.defchararray.isnumeric(u'+12')` but it returns and array. So, it’s a good solution if you have to do thousands of conversions and have missing data or non numeric data.

``````import numpy as np
%timeit np.core.defchararray.isnumeric(testlist)
10000 loops, best of 3: 27.9 µs per loop # 200 numbers per loop
``````

# try/except

``````def check_num(s):
try:
int(s)
return True
except:
return False

def check_list(l):
return [check_num(e) for e in l]

%timeit check_list(testlist)
1000 loops, best of 3: 217 µs per loop # 200 numbers per loop
``````

Seems that numpy solution is much faster.

`str.isdigit()` should do the trick.

Examples:

``````str.isdigit("23") ## True
str.isdigit("abc") ## False
str.isdigit("23.4") ## False
``````

EDIT:
As @BuzzMoschetti pointed out, this way will fail for minus number (e.g, “-23”). In case your input_num can be less than 0, use re.sub(regex_search,regex_replace,contents) before applying str.isdigit(). For example:

``````import re
input_num = "-23"
input_num = re.sub("^-", "", input_num) ## "^" indicates to remove the first "-" only
str.isdigit(input_num) ## True
``````

If you want to accept lower-ascii digits only, here are tests to do so:

Python 3.7+: `(u.isdecimal() and u.isascii())`

Python <= 3.6: `(u.isdecimal() and u == str(int(u)))`

Other answers suggest using `.isdigit()` or `.isdecimal()` but these both include some upper-unicode characters such as `'٢'` (`u'u0662'`):

``````u = u'u0662'     # '٢'
u.isdigit()       # True
u.isdecimal()     # True
u.isascii()       # False (Python 3.7+ only)
u == str(int(u))  # False
``````

I suggest the following:

``````import ast

def is_int(s):
return isinstance(ast.literal_eval(s), int)
``````

From the docs:

Safely evaluate an expression node or a string containing a Python literal or container display. The string or node provided may only consist of the following Python literal structures: strings, bytes, numbers, tuples, lists, dicts, sets, booleans, and None.

I should note that this will raise a `ValueError` exception when called against anything that does not constitute a Python literal. Since the question asked for a solution without try/except, I have a Kobayashi-Maru type solution for that:

``````from ast import literal_eval
from contextlib import suppress

def is_int(s):
with suppress(ValueError):
return isinstance(literal_eval(s), int)
return False
``````

¯_(ツ)_/¯

I do this all the time b/c I have a mild but admittedly irrational aversion to using the try/except pattern. I use this:

``````all([xi in '1234567890' for xi in x])
``````

It doesn’t accommodate negative numbers, so you could strip out all minus signs on the left side, and then check if the result comprises digits from 0-9:

``````all([xi in '1234567890' for xi in x.lstrip('-')])
``````

You could also pass x to str() if you’re not sure the input is a string:

``````all([xi in '1234567890' for xi in str(x).lstrip('-')])
``````

There are some (edge?) cases where this falls apart:

1. It doesn’t work for various scientific and/or exponential notations (e.g. 1.2E3, 10^3, etc.) – both will return False. I don’t think other answers accommodated this either, and even Python 3.8 has inconsistent opinions, since `type(1E2)` gives `<class 'float'>` whereas `type(10^2)` gives `<class 'int'>`.
2. An empty string input gives True.
3. A leading plus sign (e.g. "+7") gives False.
4. Multiple minus signs are ignored so long as they’re leading characters. This behavior is similar to the python interpreter* in that `type(---1)` returns `<class int>`. However, it isn’t completely consistent with the interpreter in that `int('---1')` gives an error, but my solution returns `True` with the same input.

So it won’t work for every possible input, but if you can exclude those, it’s an OK one-line check that returns `False` if x is not an integer and `True` if x is an integer. But if you really want behavior that exactly models the `int()` built-in, you’re better off using try/except.

I don’t know if it’s pythonic, but it’s one line, and it’s relatively clear what the code does.

*I don’t mean to say that the interpreter ignores leading minus signs, just that any number of leading minus signs does not change that the result is an integer. `int(--1)` is actually interpreted as `-(-1)`, or 1. `int(---1)` is interpreted as `-(-(-1))`, or -1. So an even number of leading minus signs gives a positive integer, and an odd number of minus signs gives a negative integer, but the result is always an integer.

The easiest way, which I use

``````def is_int(item: str) -> bool:
return item.lstrip('-+').isdigit()
``````

Preconditions:

• we are talking about integers (not decimals/floats);
• behavior of built-in `int()` is a standard for us (sometimes it’s strange: "-00" is correct input for it)

Use the following code. It is simple, correct (while many variants in this thread aren’t) and nearly twice outperforms both `try/except` and `regex` variants.

``````def is_int_str(string):
return (
string.startswith(('-', '+')) and string[1:].isdigit()
) or string.isdigit()
``````

I’ve tested 3 main variants (1) try/except, (2) re.match() and (3) string operations (see above). The third variant is about twice faster then both `try/except` and `re.match()`. BTW: regex variant is the slowest! See test script below.

``````import re
import time

def test(func, test_suite):
for test_case in test_suite:
actual_result = func(*test_case[0])
expected_result = test_case[1]
assert (
actual_result == expected_result
), f'Expected: {expected_result} but actual: {actual_result}'

def perf(func, test_suite):
start = time.time()

for _ in range(0, 1_000_000):
test(func, test_suite)

return time.time() - start

def is_int_str_1(string):
try:
int(string)
return True
except ValueError:
return False

def is_int_str_2(string):
return re.match(r'^[-+]?d+\$', string) is not None

def is_int_str_3(string):
return (
string.startswith(('-', '+')) and string[1:].isdigit()
) or string.isdigit()

# Behavior of built-in int() function is a standard for the following tests
test_suite = [
[['1'], True],  # func('1') -> True
[['-1'], True],
[['+1'], True],
[['--1'], False],
[['++1'], False],
[['001'], True],  # because int() can read it
[['-00'], True],  # because of quite strange behavior of int()
[['-'], False],
[['57938759283475928347592347598357098458405834957984755200000000'], True],
]

time_span_1 = perf(is_int_str_1, test_suite)
time_span_2 = perf(is_int_str_2, test_suite)
time_span_3 = perf(is_int_str_3, test_suite)

print(f'{is_int_str_1.__name__}: {time_span_1} seconds')
print(f'{is_int_str_2.__name__}: {time_span_2} seconds')
print(f'{is_int_str_3.__name__}: {time_span_3} seconds')

``````

Output was:

``````is_int_str_1: 4.314162969589233 seconds
is_int_str_2: 5.7216269969940186 seconds
is_int_str_3: 2.5828163623809814 seconds
``````

Can use the below method to check.

``````def check_if_string_is_int(string1):
for character in string1:
if not character.isdigit():
return "Not a number"
else:
return "Is a number"
``````

Cast value to string after checking is integer, then check string first character value is `-` or `+` and rest of string `isdigit`. Finally just check `isdigit`.

`test = ['1', '12015', '1..2', 'a2kk78', '1.5', 2, 1.24, '-8.5', '+88751.71', '-1', '+7']`

Check

``````for k,v in enumerate(test):
print(k, v, 'test: ', True if isinstance(v, int) is not False else True if str(v)[0] in ['-', '+'] and str(v)[1:].isdigit() else str(v).isdigit())
``````

Result

``````0 1 test:  True
1 12015 test:  True
2 1..2 test:  False
3 a2kk78 test:  False
4 1.5 test:  False
5 2 test:  True
6 1.24 test:  False
7 -8.5 test:  False
8 +88751.71 test:  False
9 -1 test:  True
10 +7 test:  True
``````

As I understand you want to check string convertability in int. To do that you can:

1. Replace ‘-‘ to nothing, cos ‘-‘ not digit and ‘-7’ can also be converted in int.
2. Check is it digit.
``````def is_string_convertable_to_int(value: str) -> bool:
return value.replace('-', '').isdigit()
``````

P.S. You can easy modify this def for checking string convertability in float, just add replace(‘.’, ”) and check one ‘.’ existance using value.count(‘.’) = 1.

Categories: questions Tags: , ,
Answers are sorted by their score. The answer accepted by the question owner as the best is marked with
at the top-right corner.