Hat Python so etwas wie eine leere String-Variable, für die Sie Folgendes tun können:
if myString == string.empty:
Was ist der eleganteste Weg, um nach leeren String-Werten zu suchen? Ich finde die Kodierung ""
jedes Mal für die Überprüfung einer leeren Zeichenfolge nicht so gut.
Leere Zeichenfolgen sind "falsy" , was bedeutet, dass sie in einem booleschen Kontext als falsch betrachtet werden.
if not myString:
Dies ist der bevorzugte Weg, wenn Sie wissen, dass Ihre Variable eine Zeichenfolge ist. Wenn Ihre Variable auch einen anderen Typ haben könnte, sollten Sie myString == ""
verwenden. In der Dokumentation zu Wahrheitswertprüfung finden Sie andere Werte, die in booleschen Kontexten falsch sind.
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.
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.
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.
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")
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