Czy Python ma coś w rodzaju pustej zmiennej łańcuchowej, w której możesz:

if myString == string.empty:

Niezależnie od tego, jaki jest najbardziej elegancki sposób sprawdzania pustych wartości ciągu? Za ""każdym razem znajduję stałe kodowanie, aby sprawdzić pusty ciąg znaków nie tak dobry.

Puste ciągi znaków są „fałszowane”, co oznacza, że ​​są uważane za fałszywe w kontekście logicznym, więc możesz to po prostu zrobić:

if not myString:

Jest to preferowany sposób, jeśli wiesz, że twoja zmienna jest łańcuchem. Jeśli twoja zmienna może być również innego typu, powinieneś użyć myString == "". Zobacz dokumentację dotyczącą testowania wartości prawdy, aby znaleźć inne wartości, które są fałszywe w kontekście boolowskim.

Z PEP 8 w sekcji „Zalecenia dotyczące programowania” :

W przypadku sekwencji (ciągów, list, krotek) użyj faktu, że puste sekwencje są fałszywe.

Więc powinieneś użyć:

if not some_string:

lub:

if some_string:

Aby wyjaśnić, sekwencje są oceniane w Falselub Truew kontekście logicznym, jeśli są puste, czy nie. Są nie równa się Falselub True.

Najbardziej eleganckim sposobem byłoby prawdopodobnie sprawdzenie, czy jest to prawda czy fałsz, np .:

if not my_string:

Możesz jednak usunąć białe znaki, ponieważ:

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

Prawdopodobnie powinieneś być w tym nieco bardziej wyraźny, chyba że wiesz na pewno, że ten łańcuch przeszedł pewną walidację i jest łańcuchem, który można przetestować w ten sposób.

Chciałbym przetestować jedność przed rozbiórką. Wykorzystałbym również fakt, że puste ciągi znaków są fałszywe (lub Falsy). To podejście jest podobne do StringUtils.isBlank Apache lub Strings.isNullOrEmpty Guava

Oto, czego użyłbym do przetestowania, jeśli łańcuch ma wartość Brak LUB Pusty LUB Pusty:

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

I dokładnie odwrotnie niż w przypadku testu, jeśli ciąg znaków nie jest Brak NOR Pusty NOR Pusty:

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

Bardziej zwięzłe formy powyższego kodu:

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

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

Kiedyś napisałem coś podobnego do odpowiedzi Bartka i inspirowałem się javascript:

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

Test:

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

Jedyny naprawdę solidny sposób to zrobić:

if "".__eq__(myString):

Wszystkie inne rozwiązania mają możliwe problemy i przypadki brzegowe, w których sprawdzenie może się nie powieść.

len(myString)==0może zawieść, jeśli myStringjest obiektem klasy, która dziedziczy stri zastępuje __len__()metodę.

Podobnie myString == ""i myString.__eq__("")może zawieść, jeśli myStringzastąpi __eq__()i __ne__().

Z jakiegoś powodu "" == myStringdaje się również zwieść, jeśli myStringzastąpi __eq__().

myString is ""i "" is myStringsą równoważne. Oba zawiodą, jeśli w myStringrzeczywistości nie jest łańcuchem, ale podklasą łańcucha (oba zwrócą False). Ponadto, ponieważ są to kontrole tożsamości, jedynym powodem, dla którego działają, jest to, że Python używa String Pooling (zwanego również internacjonalizacją ciągu), który korzysta z tej samej instancji ciągu, jeśli jest internowany (patrz tutaj: Dlaczego porównywanie ciągów za pomocą albo '= = ”lub„ is ”czasami dają inny wynik? ). I ""jest internowany od samego początku w CPython

Dużym problemem związanym z kontrolą tożsamości jest to, że internowanie ciągów jest (o ile mogłem znaleźć) tym, że nie jest ustandaryzowane, które ciągi są internowane. Oznacza to, że teoretycznie ""nie jest konieczne internowanie i zależy to od implementacji.

Jedynym sposobem na osiągnięcie tego, że tak naprawdę nie da się oszukać jedną wspomniałem na początku: "".__eq__(myString). Ponieważ to jawnie wywołuje __eq__()metodę pustego ciągu, nie można go oszukać przez przesłanianie jakichkolwiek metod w myString i solidnie działa z podklasamistr .

Również poleganie na falsyniczności łańcucha może nie działać, jeśli obiekt go przesłoni __bool__() metodę.

Jest to nie tylko praca teoretyczna, ale może być istotna w rzeczywistym użyciu, ponieważ widziałem podklasy bibliotek i bibliotek strprzed użyciemmyString is "" może zwrócić tam niepoprawne dane wyjściowe.

Również porównywanie ciągów za pomocą is ogólnie jest dość złą pułapką, ponieważ czasami działa poprawnie, ale nie w innym czasie, ponieważ pula ciągów znaków jest dość dziwna.

To powiedziawszy, w większości przypadków wszystkie wymienione rozwiązania będą działać poprawnie. Ten post jest głównie pracą akademicką.

Przetestuj pusty lub pusty ciąg (krócej):

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

Jeśli chcesz rozróżnić puste i puste ciągi, sugerowałbym użycie if len(string), w przeciwnym razie sugerowałbym użycie if stringtak, jak powiedzieli inni. Zastrzeżenie dotyczące ciągów pełnych białych znaków ma jednak zastosowanie, więc nie zapomnij o tym strip.

if stringname:daje, falsegdy ciąg jest pusty. Myślę, że to nie może być prostsze niż to.

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

Za każdym razem uważam, że kodowanie „sic” nie jest tak dobre.

Podejście do czystego kodu

Robienie tego: foo == ""jest bardzo złą praktyką. ""jest magiczną wartością. Nigdy nie powinieneś sprawdzać wartości magicznych (bardziej znanych jako liczby magiczne) )

Co powinieneś zrobić, to porównać do opisowej nazwy zmiennej.

Opisowe nazwy zmiennych

Ktoś może pomyśleć, że „empty_string” to opisowa nazwa zmiennej. To nie jest .

Zanim pójdziesz i zrobisz empty_string = "" pomyślisz, że masz świetną nazwę zmiennej do porównania. Nie to znaczy „nazwa zmiennej opisowej”.

Dobra nazwa zmiennej opisowej oparta jest na jej kontekście. Trzeba myśleć o tym, co pusty łańcuch jest .

• Skąd to pochodzi.
• Dlaczego tam jest
• Dlaczego musisz to sprawdzić?

Prosty przykład pola formularza

Budujesz formularz, w którym użytkownik może wprowadzać wartości. Chcesz sprawdzić, czy użytkownik coś napisał, czy nie.

Dobra nazwa zmiennej może być not_filled_in

Dzięki temu kod jest bardzo czytelny

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

Dokładny przykład analizy CSV

Analizujesz pliki CSV i chcesz, aby pusty ciąg był analizowany jako None

(Ponieważ CSV jest w całości oparty na tekście, nie może reprezentować None bez użycia wstępnie zdefiniowanych słów kluczowych)

Dobra nazwa zmiennej może być CSV_NONE

Ułatwia to zmianę i dostosowanie kodu, jeśli masz nowy plik CSV, który reprezentuje Noneinny ciąg niż""

if csvfield == CSV_NONE:
    csvfield = None

Nie ma pytań, czy ten fragment kodu jest poprawny. Jest całkiem jasne, że robi to, co powinien.

Porównaj to z

if csvfield == EMPTY_STRING:
    csvfield = None

Pierwsze pytanie brzmi: dlaczego pusty ciąg zasługuje na specjalne traktowanie?

Oznaczałoby to przyszłym programistom, że pusty ciąg powinien być zawsze uważany za None .

Jest tak, ponieważ łączy logikę biznesową (jaka powinna być wartość CSV None ) z implementacją kodu (z czym tak naprawdę porównujemy)

Trzeba między nimi rozdzielić obawy .

Co powiesz na to? Być może nie jest to „najbardziej elegancki”, ale wydaje się dość kompletny i jasny:

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

Odpowiadanie na @ 1290. Przepraszamy, nie ma możliwości sformatowania bloków w komentarzach. NoneWartość nie jest pusty ciąg znaków w Pythonie, i nie jest (ze spacjami). Odpowiedź z Andrew Clark jest prawidłowa: if not myString. Odpowiedź @rouble jest specyficzna dla aplikacji i nie odpowiada na pytanie PO. Wpadniesz w kłopoty, jeśli przyjmiesz osobliwą definicję „pustego” ciągu. W szczególności, średnia zachowanie jest, że str(None)produkuje'None' niepustego łańcucha.

Jeśli jednak musisz traktować Nonei (spacje) jako „puste” ciągi, oto lepszy sposób:

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

Przykłady:

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

Spełnia wymagania @rouble, nie przerywając oczekiwanego boolzachowania ciągów.

Uważam to za eleganckie, ponieważ upewnia się, że jest to sznurek i sprawdza jego długość:

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

Innym łatwym sposobem może być zdefiniowanie prostej funkcji:

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

not str(myString)

To wyrażenie ma wartość True dla ciągów, które są puste. Niepuste łańcuchy, Żaden i obiekty nie łańcuchowe będą generować False, z zastrzeżeniem, że obiekty mogą nadpisać __str__, aby udaremnić tę logikę, zwracając wartość fałszowania.

Możesz na to spojrzeć Przypisywanie pustej wartości lub łańcucha w Pythonie

Chodzi o porównywanie pustych ciągów. Zamiast testować pustkę not, możesz sprawdzić, czy łańcuch jest równy pustemu łańcuchowi z ""pustym łańcuchem ...

dla tych, którzy oczekują zachowania jak apache StringUtils.isBlank lub Guava Strings.isNullOrEmpty :

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

Gdy czytasz plik po liniach i chcesz ustalić, która linia jest pusta, upewnij się, że użyjesz .strip(), ponieważ w wierszu „pustym” jest nowy znak linii:

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

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

    # your code for non-empty lines

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

Jeśli tylko użyjesz

not var1 

nie można odróżnić zmiennej boolean Falseod pustego łańcucha '':

var1 = ''
not var1
> True

var1 = False
not var1
> True

Jeśli jednak dodasz prosty warunek do skryptu, różnica będzie następująca:

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

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

Jeśli jest to przydatne dla kogoś, oto szybka funkcja, którą zbudowałem, aby zastąpić puste ciągi znakami N / A na listach list (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

Jest to przydatne do wysyłania list list do bazy danych mysql, która nie przyjmuje pustych pól dla niektórych pól (pola oznaczone w schemacie jako NN. W moim przypadku było to spowodowane złożonym kluczem podstawowym).

Przeprowadziłem pewne eksperymenty z ciągami takimi jak „”, „”, „\ n” itd. Chcę, aby właściwość NotNhitespace miała wartość True tylko wtedy, gdy zmienna foo jest łańcuchem z co najmniej jednym znakiem spacji. Używam Pythona 3.6. Oto, z czym skończyłem:

isWhitespace = str is type(foo) and not foo.strip()
isNotWhitespace = str is type(foo) and not not foo.strip()

W razie potrzeby zawiń to w definicji metody.

Jak napisano powyżej, ale z pomyłką.

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