two - python plot beschriftung




Der eleganteste Weg, um zu überprüfen, ob die Zeichenfolge in Python leer ist? (13)

Ich finde Hardcoding (sic) "" jedes Mal für die Überprüfung einer leeren Zeichenfolge nicht so gut.

Clean-Code-Ansatz

Doing this: foo == "" ist eine sehr schlechte Übung. "" ist ein magischer Wert. Du solltest niemals gegen magische Werte (besser bekannt als magische Zahlen ) nachsehen.

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

Beschreibende Variablennamen

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

Bevor du gehst und empty_string = "" und du denkst, dass du einen großen Variablennamen hast, mit dem du vergleichen kannst. Dies ist nicht was "beschreibender Variablenname" bedeutet.

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 musst du nachsehen?

Beispiel für ein einfaches Formularfeld

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

Ein guter Variablenname kann not_filled_in

Dies macht den Code sehr lesbar

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

Ausführliches CSV-Parsing-Beispiel

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

(Da CSV vollständig textbasiert ist, kann es None ohne vordefinierte Schlüsselwörter darstellen.)

Ein guter Variablenname kann CSV_NONE

Dadurch kann der Code leicht geändert und angepasst werden, wenn Sie eine neue CSV-Datei haben, die None mit einer anderen Zeichenfolge als ""

if csvfield == CSV_NONE:
    csvfield = None

Es gibt keine Fragen darüber, ob dieser Code richtig ist. Es ist ziemlich klar, dass es tut, was es tun soll.

Vergleichen Sie das mit

if csvfield == EMPTY_STRING:
    csvfield = None

Die erste Frage hier ist: Warum verdient die leere Saite eine spezielle Behandlung?

Dies würde zukünftigen Kodierern sagen, dass eine leere Zeichenkette immer als None .

Dies liegt daran, dass es die Geschäftslogik (welcher CSV-Wert sollte None ) mit der Code-Implementierung mischt (womit wir eigentlich vergleichen)

Es muss eine Trennung der Bedenken zwischen den beiden geben.

Hat Python so etwas wie eine leere String-Variable?

if myString == string.empty:

Was ist die eleganteste Art, nach leeren String-Werten zu suchen? Ich finde hartes Codieren "" jedes Mal zum Überprüfen einer leeren Zeichenkette nicht so gut.


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

Um dies zu verdeutlichen, werden Sequenzen im Booleschen Kontext zu False oder True ausgewertet , wenn sie leer sind oder nicht. Sie sind nicht gleich False oder True .


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

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

Prüfung:

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

Ich würde die Nichtigkeit vor dem Strippen testen. Außerdem würde ich die Tatsache verwenden, dass leere Zeichenfolgen False (oder Falsy) sind. Dieser Ansatz ähnelt Apache StringUtils.isBlank oder Guava Strings.isNullOrEmpty

Dies würde ich verwenden, um zu testen, ob eine Zeichenfolge entweder Keine ODER Leer oder 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 das genaue Gegenteil, um zu testen, ob eine Zeichenkette 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

Weitere prägnante Formen des obigen Codes:

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

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

Leere oder leere Zeichenfolge 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")

Nach meiner Erfahrung funktioniert das Testen für "" nicht immer. Dieser einfache Test hat immer für mich funktioniert:

if MyString == 'None'

oder

if MyString != 'None'

Ein Excel-Arbeitsblatt lesen Ich möchte aufhören, wenn eine Spalte mit der folgenden while-Schleife leer wird:

while str(MyString) != 'None':

Sie können sich dies ansehen. Einen leeren Wert oder eine leere Zeichenfolge in Python zuweisen

Es geht darum, Strings zu vergleichen, die leer sind. Anstatt also auf Leerheit mit not testen, können Sie testen, ob Ihre Zeichenkette gleich leer ist mit "" der leeren Zeichenkette ...


Wenn Sie Datei für Zeile lesen und ermitteln möchten, welche Zeile leer ist, stellen Sie sicher, dass Sie .strip() , da in der "leeren" Zeile ein neues .strip() steht:

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

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

    # your code for non-empty lines

Wie Prmatta oben geschrieben, aber mit Fehler.

def isNoneOrEmptyOrBlankString (myString):
    if myString:
        if not myString.strip():
            return True
        else:
            return False
    return False

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

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

Gibt es eine Möglichkeit für eine Ausnahme oder ein falsches positives dabei?


if stringname: gibt einen false wenn der String leer ist. Ich denke, es kann nicht einfacher sein.


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

not str(myString)

Dieser Ausdruck ist True für Strings, die leer sind. 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 vereiteln, indem ein falscher Wert zurückgegeben wird.





comparison-operators