Der eleganteste Weg, um zu überprüfen, ob der String in Python leer ist?

Von PEP 8 , im Abschnitt "Programmierungsempfehlungen" :

Verwenden Sie für Sequenzen (Strings, Listen, Tupel) die Tatsache, dass leere Sequenzen falsch sind.

Sie sollten also Folgendes verwenden:

if not some_string:

oder:

if some_string:

Zur Klarstellung werden Sequenzen in einem booleschen Kontext evaluiert bis False oder True, falls sie leer sind oder nicht. Sie sind ungleich zu False oder True.

Der eleganteste Weg wäre wahrscheinlich, einfach zu prüfen, ob es richtig oder falsch ist, z.

if not my_string:

Sie können jedoch Leerzeichen entfernen, weil:

 >>> bool("")
 False
 >>> bool("   ")
 True
 >>> bool("   ".strip())
 False

Sie sollten diesbezüglich jedoch etwas expliziter sein, es sei denn, Sie wissen genau, dass diese Zeichenfolge eine Art Validierung bestanden hat und eine Zeichenfolge ist, die auf diese Weise getestet werden kann.

Ich würde vor dem Strippen Unstimmigkeiten testen. Ich würde auch die Tatsache nutzen, dass leere Zeichenketten False (oder Falsy) sind. Dieser Ansatz ist ähnlich wie Apache's StringUtils.isBlank oder Guavas Strings.isNullOrEmpty

Dies würde ich zum Testen verwenden, wenn eine Zeichenfolge entweder Keine OR leer OR leer ist:

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

Und genau das Gegenteil von test, wenn eine Zeichenfolge keine ist. NOR Leer NOR Leer:

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

Kurzere Formen des obigen Codes:

def isBlank (myString):
    return not (myString and myString.strip())

def isNotBlank (myString):
    return bool(myString and myString.strip())

Ich schrieb einmal etwas Ähnliches wie Barteks Antwort und Javascript inspiriert:

def is_not_blank(s):
    return bool(s and s.strip())

Prüfung:

print is_not_blank("")    # False
print is_not_blank("   ") # False
print is_not_blank("ok")  # True
print is_not_blank(None)  # False

Leere oder leere Zeichenfolge testen (kürzer):

if myString.strip():
    print("it's not an empty or blank string")
else:
    print("it's an empty or blank string")

Wenn Sie zwischen leeren und Null-Strings unterscheiden möchten, würde ich vorschlagen, if len(string) zu verwenden, andernfalls würde ich einfach if string verwenden, wie andere bereits gesagt haben. Die Einschränkung bei Whitespace-Zeichenfolgen gilt jedoch immer noch, vergessen Sie also nicht strip.

if my_string is '':

Ich habe diese Kombination in keiner der Antworten bemerkt. Ich habe gesucht 

is ''

in den Antworten vor dem Posten. 

 if my_string is '': print ('My string is EMPTY') # **footnote

Ich denke, das war es, was das ursprüngliche Poster zu erreichen versuchte ... etwas, das dem Englischen so nahe wie möglich kommt und soliden Programmierpraktiken folgt. 

if my_string is '':
    print('My string is EMPTY')
else:
    print(f'My string is {my_string}')

Charakter für Charakter Ich denke, dass diese Lösung eine gute ist.

Ich habe bemerkt, dass None in die Diskussion eingetreten ist. Wenn wir das hinzufügen und weiter komprimieren, erhalten wir:

if my_string is '': print('My string is Empty')
Elif my_string is None : print('My string.... isn\'t')
else: print(f'My string is {my_string}')

a = ''
b = '   '
a.isspace() -> False
b.isspace() -> True

if stringname: gibt eine false, wenn die Zeichenfolge leer ist. Einfacher geht es nicht.

Hardcoding (sic) "" finde ich jedes Mal, wenn Sie eine leere Zeichenfolge überprüfen, nicht so gut.

Sauberer Code-Ansatz

Tun Sie dies: foo == "" ist eine sehr schlechte Praxis. "" ist ein magischer Wert. Sie sollten niemals auf magische Werte (allgemeiner bekannt als magische Zahlen ) prüfen.

Was Sie tun sollten, ist mit einem beschreibenden Variablennamen zu vergleichen.

Beschreibende Variablennamen

Man könnte denken, dass "empty_string" ein beschreibender Variablenname ist. Es ist nicht.

Bevor Sie empty_string = "" ausführen und denken, Sie haben einen großen Variablennamen, mit dem Sie vergleichen können. Dies bedeutet nicht "beschreibender Variablenname".

Ein guter beschreibender Variablenname basiert auf seinem Kontext . Sie müssen darüber nachdenken, was die leere Zeichenfolge ist.

• Woher kommt das. 
• Warum ist es da? 
• Warum müssen Sie das überprüfen?.

Beispiel für ein einfaches Formularfeld

Sie erstellen ein Formular, in das ein Benutzer Werte eingeben kann. Sie möchten prüfen, ob der Benutzer etwas geschrieben hat oder nicht.

Ein guter Variablenname kann not_filled_in sein.

Dies macht den Code sehr lesbar

if formfields.name == not_filled_in:
    raise ValueError("We need your name")

Gründliches CSV-Beispiel

Sie analysieren CSV-Dateien und möchten, dass die leere Zeichenfolge als None analysiert wird.

(Da CSV vollständig auf Text basiert, kann None nicht ohne vordefinierte Schlüsselwörter dargestellt werden.)

Ein guter Variablenname kann CSV_NONE sein.

Dadurch kann der Code leicht geändert und angepasst werden, wenn Sie über eine neue CSV-Datei verfügen, die None mit einer anderen Zeichenfolge als "" darstellt.

if csvfield == CSV_NONE:
    csvfield = None

Es gibt keine Fragen, ob dieser Code korrekt ist. Es ist ziemlich klar, dass es das tut, was es tun soll.

Vergleichen Sie das mit

if csvfield == EMPTY_STRING:
    csvfield = None

Die erste Frage hier lautet: Warum verdient die leere Saite eine besondere Behandlung?

Dies würde zukünftigen Codierern mitteilen, dass eine leere Zeichenfolge immer als None betrachtet werden sollte.

Dies liegt daran, dass Geschäftslogik (CSV-Wert sollte None sein) mit Codeimplementierung gemischt werden (Was vergleichen wir eigentlich mit).

Es muss ein Trennung der Sorge zwischen den beiden sein.

Entweder das Folgende

foo is ''

oder auch

empty = ''
foo is empty

Wie wäre es damit? Vielleicht ist es nicht "das eleganteste", aber es scheint ziemlich vollständig und klar zu sein:

if (s is None) or (str(s).strip()==""): // STRING s IS "EMPTY"...

Antwort auf @ 1290. Entschuldigung, keine Möglichkeit, Blöcke in Kommentaren zu formatieren. Der None-Wert ist in Python keine leere Zeichenfolge und auch keine (Leerzeichen). Die Antwort von Andrew Clark ist die richtige: if not myString. Die Antwort von @rouble ist anwendungsspezifisch und beantwortet nicht die Frage des OPs. Sie werden in Schwierigkeiten geraten, wenn Sie eine spezielle Definition einer "leeren" Zeichenfolge annehmen. Das Standardverhalten ist insbesondere, dass str(None)'None', eine nicht leere Zeichenfolge, erzeugt.

Wenn Sie jedoch None und (Leerzeichen) als "leere" Zeichenfolgen behandeln müssen, sollten Sie Folgendes tun:

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())

Beispiele:

>>> 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

Erfüllt die @rouble-Anforderungen, während das erwartete bool-Verhalten von Zeichenfolgen nicht verletzt wird.

Der einzig wirklich solide Weg, dies zu tun, ist der folgende:

if "".__eq__(myString):

Alle anderen Lösungen haben mögliche Probleme und Edge-Fälle, in denen die Überprüfung fehlschlagen kann.

len(myString)==0 kann fehlschlagen, wenn myString ein Objekt einer Klasse ist, die von str erbt und die Methode __len__() überschreibt.

Ebenso können myString == "" und myString.__eq__("") fehlschlagen, wenn myString__eq__() und __ne__() überschreibt.

Aus irgendeinem Grund wird "" == myString auch getäuscht, wenn myString__eq__() überschreibt.

myString is "" und "" is myString sind gleichwertig. Sie schlagen beide fehl, wenn myString keine Zeichenfolge, sondern eine Unterklasse von Zeichenfolge ist (beide geben False zurück). Da es sich um Identitätsprüfungen handelt, ist der einzige Grund, warum sie funktionieren, die Verwendung von String Pooling (auch als String Internment bezeichnet) in Python, das dieselbe Instanz eines Strings verwendet, wenn es interniert ist (siehe hier: Warum werden Strings mit beiden verglichen?) '==' oder 'ist' manchmal ein anderes Ergebnis? ). Und "" ist von Anfang an in CPython interniert

Das große Problem bei der Identitätsprüfung ist, dass String Internment (soweit ich das beurteilen konnte) nicht standardisiert ist, welche Strings interniert sind. Das heißt, theoretisch ist "" intern nicht notwendig und das ist implementierungsabhängig.

Der einzige Weg, dies zu tun, der wirklich nicht getäuscht werden kann, ist der eingangs erwähnte: "".__eq__(myString). Da dies explizit die Methode __eq__() der leeren Zeichenfolge aufruft, kann es nicht durch Überschreiben von Methoden in myString getäuscht werden und funktioniert solide mit Unterklassen von str.

Das Verlassen auf die Falschheit einer Zeichenfolge funktioniert möglicherweise nicht, wenn das Objekt die Methode __bool__() überschreibt.

Dies ist nicht nur eine theoretische Arbeit, sondern kann in der Praxis auch von Bedeutung sein, da ich gesehen habe, dass Frameworks und Bibliotheken, die zuvor str unterklassifiziert haben und myString is "" verwenden, dort möglicherweise eine falsche Ausgabe zurückgeben.

Außerdem ist das Vergleichen von Strings mit is im Allgemeinen eine ziemlich üble Falle, da es manchmal richtig funktioniert, aber nicht zu anderen Zeiten, da das Pooling von Strings ziemlich seltsamen Regeln folgt.

In den meisten Fällen funktionieren jedoch alle genannten Lösungen ordnungsgemäß. Dieser Beitrag ist hauptsächlich akademische Arbeit.

not str(myString)

Dieser Ausdruck ist wahr für leere Zeichenfolgen. Nicht leere Strings, None und Nicht-String-Objekte erzeugen alle False, mit der Einschränkung, dass Objekte __str__ überschreiben können, um diese Logik zu unterbinden, indem ein falscher Wert zurückgegeben wird.

str = ""
if not str:
   print "Empty String"
if(len(str)==0):
   print "Empty String"

Eine andere einfache Möglichkeit könnte darin bestehen, eine einfache Funktion zu definieren:

def isStringEmpty(inputString):
    if len(inputString) == 0:
        return True
    else:
        return False

Wenn Sie nur verwenden 

not var1 

es ist nicht möglich, eine boolesche Variable False von einer leeren Zeichenfolge '' zu unterscheiden:

var1 = ''
not var1
> True

var1 = False
not var1
> True

Wenn Sie Ihrem Skript jedoch eine einfache Bedingung hinzufügen, wird der Unterschied gemacht:

var1  = False
not var1 and var1 != ''
> True

var1 = ''
not var1 and var1 != ''
> False

Sie können einen Blick darauf werfen. Zuweisen eines leeren Werts oder einer Zeichenfolge in Python

Hierbei werden leere Zeichenfolgen verglichen. Anstatt also mit not auf Leerheit zu testen, können Sie testen, ob Ihre Zeichenfolge gleich der leeren Zeichenfolge mit "" der leeren Zeichenfolge ist.

Für den Fall, dass dies für jemanden nützlich ist, habe ich hier eine schnelle Funktion entwickelt, um leere Zeichenfolgen durch N/A in Listenlisten (Python 2) zu ersetzen.

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

Dies ist nützlich, um Listen mit Listen in eine MySQL-Datenbank zu senden, die für bestimmte Felder keine Leerzeichen akzeptiert (Felder, die im Schema als NN gekennzeichnet sind. In meinem Fall war dies auf einen zusammengesetzten Primärschlüssel zurückzuführen).

für diejenigen, die ein Verhalten wie Apache StringUtils.isBlank oder Guava Strings.isNullOrEmpty erwarten:

if mystring and mystring.strip():
    print "not blank string"
else:
    print "blank string"

Ich finde das elegant, da es sicher ist, dass es sich um eine Schnur handelt und die Länge überprüft:

def empty(mystring):
    assert isinstance(mystring, str)
    if len(mystring) == 0:
        return True
    else:
        return False

Wenn Sie Datei zeilenweise lesen und feststellen möchten, welche Zeile leer ist, müssen Sie .strip() verwenden, da in der "leeren" Zeile ein neues Zeilenzeichen vorhanden ist:

lines = open("my_file.log", "r").readlines()

for line in lines:
    if not line.strip():
        continue

    # your code for non-empty lines