Does Python have something like an empty string variable where you can do:
if myString == string.empty:
Regardless, what’s the most elegant way to check for empty string values? I find hard coding
"" every time for checking an empty string not as good.
if not myString:
This is the preferred way if you know that your variable is a string. If your variable could also be some other type then you should use:
if myString == "":
See the documentation on Truth Value Testing for other values that are false in Boolean contexts.
The most elegant way would probably be to simply check if its true or falsy, e.g.:
if not my_string:
However, you may want to strip white space because:
>>> bool("") False >>> bool(" ") True >>> bool(" ".strip()) False
You should probably be a bit more explicit in this however, unless you know for sure that this string has passed some kind of validation and is a string that can be tested this way.
For sequences, (strings, lists, tuples), use the fact that empty sequences are false.
So you should use:
if not some_string:
Just to clarify, sequences are evaluated to
True in a Boolean context if they are empty or not. They are not equal to
if stringname: gives a
false when the string is empty. I guess it can’t be simpler than this.
If you want to differentiate between empty and null strings, I would suggest using
if len(string), otherwise, I’d suggest using simply
if string as others have said. The caveat about strings full of whitespace still applies though, so don’t forget to
a = '' b = ' ' a.isspace() -> False b.isspace() -> True
You may have a look at this Assigning empty value or string in Python
This is about comparing strings that are empty. So instead of testing for emptiness with
not, you may test is your string is equal to empty string with
"" the empty string…
This is what I would use to test if a string is either None OR Empty OR Blank:
def isBlank (myString): if myString and myString.strip(): #myString is not None AND myString is not empty or blank return False #myString is None OR myString is empty or blank return True
And, the exact opposite to test if a string is not None NOR Empty NOR Blank:
def isNotBlank (myString): if myString and myString.strip(): #myString is not None AND myString is not empty or blank return True #myString is None OR myString is empty or blank return False
More concise forms of the above code:
def isBlank (myString): return not (myString and myString.strip()) def isNotBlank (myString): return bool(myString and myString.strip())
As prmatta posted above, but with mistake.
def isNoneOrEmptyOrBlankString (myString): if myString: if not myString.strip(): return True else: return False return False
def is_not_blank(s): return bool(s and not s.isspace())
print is_not_blank("") # False print is_not_blank(" ") # False print is_not_blank("ok") # True print is_not_blank(None) # False
Test empty or blank string (shorter way):
if myString.strip(): print("it's not an empty or blank string") else: print("it's an empty or blank string")
How about this? Perhaps it’s not “the most elegant”, but it seems pretty complete and clear:
if (s is None) or (str(s).strip()==""): // STRING s IS "EMPTY"...
When you are reading file by lines and want to determine, which line is empty, make sure you will use
.strip(), because there is new line character in “empty” line:
lines = open("my_file.log", "r").readlines() for line in lines: if not line.strip(): continue # your code for non-empty lines
I find hardcoding(sic) "" every time for checking an empty string not as good.
foo == "" is very bad practice.
"" is a magical value. You should never check against magical values (more commonly known as magical numbers)
What you should do is compare to a descriptive variable name.
One may think that "empty_string" is a descriptive variable name. It isn’t.
Before you go and do
empty_string = "" and think you have a great variable name to compare to. This is not what "descriptive variable name" means.
A good descriptive variable name is based on its context.
You have to think about what the empty string is.
You are building a form where a user can enter values. You want to check if the user wrote something or not.
A good variable name may be
This makes the code very readable
if formfields.name == not_filled_in: raise ValueError("We need your name")
You are parsing CSV files and want the empty string to be parsed as
(Since CSV is entirely text based, it cannot represent
None without using predefined keywords)
A good variable name may be
This makes the code easy to change and adapt if you have a new CSV file that represents
None with another string than
if csvfield == CSV_NONE: csvfield = None
There are no questions about if this piece of code is correct. It is pretty clear that it does what it should do.
Compare this to
if csvfield == EMPTY_STRING: csvfield = None
The first question here is, Why does the empty string deserve special treatment?
This would tell future coders that an empty string should always be considered as
This is because it mixes business logic (What CSV value should be
None) with code implementation (What are we actually comparing to)
There needs to be a separation of concern between the two.
Responding to @1290. Sorry, no way to format blocks in comments. The
None value is not an empty string in Python, and neither is (spaces). The answer from Andrew Clark is the correct one:
if not myString. The answer from @rouble is application-specific and does not answer the OP’s question. You will get in trouble if you adopt a peculiar definition of what is a “blank” string. In particular, the standard behavior is that
'None', a non-blank string.
However if you must treat
None and (spaces) as “blank” strings, here is a better way:
class weirdstr(str): def __new__(cls, content): return str.__new__(cls, content if content is not None else '') def __nonzero__(self): return bool(self.strip())
>>> normal = weirdstr('word') >>> print normal, bool(normal) word True >>> spaces = weirdstr(' ') >>> print spaces, bool(spaces) False >>> blank = weirdstr('') >>> print blank, bool(blank) False >>> none = weirdstr(None) >>> print none, bool(none) False >>> if not spaces: ... print 'This is a so-called blank string' ... This is a so-called blank string
Meets the @rouble requirements while not breaking the expected
bool behavior of strings.
This expression is True for strings that are empty. Non-empty strings, None and non-string objects will all produce False, with the caveat that objects may override __str__ to thwart this logic by returning a falsy value.
If you just use
it is not possible to difference a variable which is boolean
False from an empty string
var1 = '' not var1 > True var1 = False not var1 > True
However, if you add a simple condition to your script, the difference is made:
var1 = False not var1 and var1 != '' > True var1 = '' not var1 and var1 != '' > False
In case this is useful to someone, here is a quick function i built out to replace blank strings with N/A’s in lists of lists (python 2).
y = [["1","2",""],["1","4",""]] def replace_blank_strings_in_lists_of_lists(list_of_lists): new_list =  for one_list in list_of_lists: new_one_list =  for element in one_list: if element: new_one_list.append(element) else: new_one_list.append("N/A") new_list.append(new_one_list) return new_list x= replace_blank_strings_in_lists_of_lists(y) print x
This is useful for posting lists of lists to a mysql database that does not accept blanks for certain fields (fields marked as NN in schema. in my case, this was due to a composite primary key).
The only really solid way of doing this is the following:
All other solutions have possible problems and edge cases where the check can fail.
len(myString) == 0 can fail if
myString is an object of a class that inherits from
str and overrides the
myString == "" and
myString.__eq__("") can fail if
"" == myString also gets fooled if
myString is "" and
"" is myString are equivalent. They will both fail if
myString is not actually a string but a subclass of string (both will return
False). Also, since they are identity checks, the only reason why they work is because Python uses String Pooling (also called String Internment) which uses the same instance of a string if it is interned (see here: Why does comparing strings using either '==' or 'is' sometimes produce a different result?). And
"" is interned from the start in CPython
The big problem with the identity check is that String Internment is (as far as I could find) that it is not standardised which strings are interned. That means, theoretically
"" is not necessary interned and that is implementation dependant.
Also, comparing strings using
is in general is a pretty evil trap since it will work correctly sometimes, but not at other times, since string pooling follows pretty strange rules.
Relying on the falsyness of a string may not work if the object overrides
The only way of doing this that really cannot be fooled is the one mentioned in the beginning:
"".__eq__(myString). Since this explicitly calls the
__eq__() method of the empty string it cannot be fooled by overriding any methods in myString and solidly works with subclasses of
This is not only theoretical work but might actually be relevant in real usage since I have seen frameworks and libraries subclassing
str before and using
myString is "" might return a wrong output there.
That said, in most cases all of the mentioned solutions will work correctly. This is post is mostly academic work.
I did some experimentation with strings like ”, ‘ ‘, ‘n’, etc. I want isNotWhitespace to be True if and only if the variable foo is a string with at least one non-whitespace character. I’m using Python 3.6. Here’s what I ended up with:
isWhitespace = str is type(foo) and not foo.strip() isNotWhitespace = str is type(foo) and not not foo.strip()
Wrap this in a method definition if desired.
If you are not totally sure, that your input is really a string, I would recommend to use
isinstance(object, classinfo) link in addition, as shown in the example.
If not, lists or a
True bool value could also be evaluated as
Below is an elegant solution for any number of spaces.
def str_empty(s: str) -> bool: """Strip white space and count remaining characters.""" return len(s.strip()) < 1 >>> str_empty(' ') True
The clearest approach is:
if s == "":
""is not "hard-coding" a magic value any more than
x == 0is.
x % 2to check for even numbers.
) is an empty string.
Consider how one checks if an integer is 0:
if x == 0:
One certainly should not do:
if not x:
Both integers and strings are primitive value types. Why treat them differently?
if you want to check if a string is completely empty
if not mystring
which works because empty strings are false
but if a string is only whitespace it will be true so you might want to
if not mystring.strip()