Wie überprüfe ich, ob die Zeichenfolge leer ist?

Hat Python so etwas wie eine leere String-Variable, wo Sie Folgendes tun können:

if myString == string.empty:

Unabhängig davon, was ist der eleganteste Weg, um nach leeren Zeichenfolgenwerten zu suchen? Ich finde Hardcoding "" jedes Mal zum Überprüfen einer leeren Zeichenfolge nicht so gut.

Leere Strings sind “falsch” (Python 2 oder Python 3 Referenz), was bedeutet, dass sie in einem booleschen Kontext als falsch betrachtet werden, also können Sie einfach Folgendes tun:

if not myString:

Dies ist der bevorzugte Weg, wenn Sie wissen, dass Ihre Variable ein String ist. Wenn Ihre Variable auch einen anderen Typ haben könnte, sollten Sie verwenden myString == "". Siehe die Dokumentation auf Wahrheitswertprüfung für andere Werte, die in booleschen Kontexten falsch sind.

Von PEP 8, in dem Abschnitt „Programmierempfehlungen“.:

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

Sie sollten also verwenden:

if not some_string:

oder:

if some_string:

Nur zur Verdeutlichung, Sequenzen sind ausgewertet zu False oder True in einem booleschen Kontext, ob sie leer sind oder nicht. Sie sind nicht gleich zu False oder True.

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

if not my_string:

Möglicherweise möchten Sie jedoch Leerzeichen entfernen, weil:

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

Sie sollten dies jedoch wahrscheinlich etwas expliziter machen, es sei denn, Sie wissen sicher, dass diese Zeichenfolge eine Art Validierung bestanden hat und eine Zeichenfolge ist, die auf diese Weise getestet werden kann.

Ich würde das Nichts vor dem Strippen testen. Außerdem würde ich die Tatsache nutzen, dass leere Zeichenfolgen False (oder Falsy) sind. Dieser Ansatz ist ähnlich wie Apaches StringUtils.isBlank oder Guavas Strings.isNullOrEmpty

Dies ist, was ich verwenden würde, um zu testen, ob eine Zeichenfolge entweder None ODER Empty OR Blank 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 das genaue Gegenteil zum Testen, ob eine Zeichenfolge nicht None NOR Empty NOR Blank ist:

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

Kürzere Formen des obigen Codes:

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

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

Ich habe einmal etwas Ähnliches wie Barteks Antwort geschrieben und von Javascript inspiriert:

def is_not_blank(s):
    return bool(s and not s.isspace())

Prüfen:

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

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

if "".__eq__(myString):

Alle anderen Lösungen haben mögliche Probleme und Grenzfälle, in denen die Prüfung fehlschlagen kann.

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

Ähnlich myString == "" und myString.__eq__("") kann scheitern, wenn myString überschreibt __eq__() und __ne__().

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

myString is "" und "" is myString sind gleichwertig. Sie werden beide scheitern, wenn myString ist eigentlich keine Zeichenfolge, sondern eine Unterklasse von Zeichenfolge (beide werden zurückgegeben False). Da es sich um Identitätsprüfungen handelt, funktionieren sie nur deshalb, weil Python String Pooling (auch als String Internment bezeichnet) verwendet, das dieselbe Instanz eines Strings verwendet, wenn es interniert ist (siehe hier: Warum funktioniert der Vergleich von Strings entweder mit ‘= =’ oder ‘ist’ führen manchmal zu einem anderen 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 feststellen konnte) nicht standardisiert ist, welche Strings interniert werden. Das heißt, theoretisch "" ist nicht notwendigerweise interniert und das ist implementierungsabhängig.

Die einzige Möglichkeit, dies wirklich nicht zu täuschen, ist die eingangs erwähnte: "".__eq__(myString). Da dies explizit die ruft __eq__() Methode des leeren Strings kann nicht durch Überschreiben von Methoden in myString getäuscht werden und arbeitet solide mit Unterklassen von str.

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

Dies ist nicht nur theoretische Arbeit, sondern könnte tatsächlich in der realen Verwendung relevant sein, da ich gesehen habe, wie Frameworks und Bibliotheken Unterklassen erstellt haben str vor und Verwendung myString is "" könnte dort eine falsche Ausgabe zurückgeben.

Auch das Vergleichen von Zeichenfolgen mit is Im Allgemeinen ist es eine ziemlich böse Falle, da es manchmal richtig funktioniert, aber manchmal nicht, da das String-Pooling ziemlich seltsamen Regeln folgt.

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

Leeren oder leeren String testen (kürzerer Weg):

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