To check if o
is an instance of str
or any subclass of str
, use isinstance (this would be the "canonical" way):
if isinstance(o, str):
To check if the type of o
is exactly str
(exclude subclasses):
if type(o) is str:
The following also works, and can be useful in some cases:
if issubclass(type(o), str):
See Built-in Functions in the Python Library Reference for relevant information.
One more note: in this case, if you're using Python 2, you may actually want to use:
if isinstance(o, basestring):
because this will also catch Unicode strings (unicode
is not a subclass of str
; both str
and unicode
are subclasses of basestring
). Note that basestring
no longer exists in Python 3, where there's a strict separation of strings (str
) and binary data (bytes
).
Alternatively, isinstance
accepts a tuple of classes. This will return True
if o
is an instance of any subclass of any of (str, unicode)
:
if isinstance(o, (str, unicode)):
It used to be a required part of a package (old, pre-3.3 "regular package", not newer 3.3+ "namespace package").
Here's the documentation.
Python defines two types of packages, regular packages and namespace packages. Regular packages are traditional packages as they existed in Python 3.2 and earlier. A regular package is typically implemented as a directory containing an __init__.py
file. When a regular package is imported, this __init__.py
file is implicitly executed, and the objects it defines are bound to names in the package’s namespace. The __init__.py
file can contain the same Python code that any other module can contain, and Python will add some additional attributes to the module when it is imported.
But just click the link, it contains an example, more information, and an explanation of namespace packages, the kind of packages without __init__.py
.
Best Answer
check out the assert functions in
numpy.testing
, e.g.assert_array_equal
for floating point arrays equality test might fail and
assert_almost_equal
is more reliable.update
A few versions ago numpy obtained
assert_allclose
which is now my favorite since it allows us to specify both absolute and relative error and doesn't require decimal rounding as the closeness criterion.