If you do not want to depend on external libs, this works both for Python 2.7+ and Python 3 (http://ideone.com/uB4Kdc):
# your code goes here
s = ["test"];
#s = "test";
isString = False;
if(isinstance(s, str)):
isString = True;
try:
if(isinstance(s, basestring)):
isString = True;
except NameError:
pass;
if(isString):
print("String");
else:
print("Not String");
a = '1000' # also tested for 'abc100', 'a100bc', '100abc'
isinstance(a, str) or isinstance(a, unicode)
returns True
type(a) in [str, unicode]
returns True
Python 2 / 3 including unicode
from __future__ import unicode_literals
from builtins import str # pip install future
isinstance('asdf', str) # True
isinstance(u'asdf', str) # True
Lots of good suggestions provided by others here, but I don't see a good cross-platform summary. The following should be a good drop in for any Python program:
def isstring(s):
# if we use Python 3
if (sys.version_info[0] >= 3):
return isinstance(s, str)
# we use Python 2
return isinstance(s, basestring)
In this function, we use isinstance(object, classinfo)
to see if our input is a str
in Python 3 or a basestring
in Python 2.
Also I want notice that if you want to check whether the type of a variable is a specific kind, you can compare the type of the variable to the type of a known object.
For string you can use this
type(s) == type('')
I've seen:
hasattr(s, 'endswith')
>>> thing = 'foo'
>>> type(thing).__name__ == 'str' or type(thing).__name__ == 'unicode'
True
Here is my answer to support both Python 2 and Python 3 along with these requirements:
six
or similar compat module as they tend to hide away what
is trying to be achieved.import sys
PY2 = sys.version_info.major == 2
# Check if string (lenient for byte-strings on Py2):
isinstance('abc', basestring if PY2 else str)
# Check if strictly a string (unicode-string):
isinstance('abc', unicode if PY2 else str)
# Check if either string (unicode-string) or byte-string:
isinstance('abc', basestring if PY2 else (str, bytes))
# Check for byte-string (Py3 and Py2.7):
isinstance('abc', bytes)
Edit based on better answer below. Go down about 3 answers and find out about the coolness of basestring.
Old answer: Watch out for unicode strings, which you can get from several places, including all COM calls in Windows.
if isinstance(target, str) or isinstance(target, unicode):
In Python 3.x or Python 2.7.6
if type(x) == str:
The type module also exists if you are checking more than ints and strings. http://docs.python.org/library/types.html
since basestring
isn't defined in Python3, this little trick might help to make the code compatible:
try: # check whether python knows about 'basestring'
basestring
except NameError: # no, it doesn't (it's Python3); use 'str' instead
basestring=str
after that you can run the following test on both Python2 and Python3
isinstance(myvar, basestring)
s = '123'
issubclass(s.__class__, str)
You can simply use the isinstance function to make sure that the input data is of format string or unicode. Below examples will help you to understand easily.
>>> isinstance('my string', str)
True
>>> isinstance(12, str)
False
>>> isinstance('my string', unicode)
False
>>> isinstance(u'my string', unicode)
True
I know this is an old topic, but being the first one shown on google and given that I don't find any of the answers satisfactory, I'll leave this here for future reference:
six is a Python 2 and 3 compatibility library which already covers this issue. You can then do something like this:
import six
if isinstance(value, six.string_types):
pass # It's a string !!
Inspecting the code, this is what you find:
import sys
PY3 = sys.version_info[0] == 3
if PY3:
string_types = str,
else:
string_types = basestring,
Alternative way for Python 2, without using basestring:
isinstance(s, (str, unicode))
But still won't work in Python 3 since unicode
isn't defined (in Python 3).
So,
You have plenty of options to check whether your variable is string or not:
a = "my string"
type(a) == str # first
a.__class__ == str # second
isinstance(a, str) # third
str(a) == a # forth
type(a) == type('') # fifth
This order is for purpose.
In Python 2.x, you would do
isinstance(s, basestring)
basestring
is the abstract superclass of str
and unicode
. It can be used to test whether an object is an instance of str
or unicode
.
In Python 3.x, the correct test is
isinstance(s, str)
The bytes
class isn't considered a string type in Python 3.
This is how I do it:
if type(x) == type(str()):
you can do:
var = 1
if type(var) == int:
print('your variable is an integer')
or:
var2 = 'this is variable #2'
if type(var2) == str:
print('your variable is a string')
else:
print('your variable IS NOT a string')
hope this helps!
Source: Stackoverflow.com