Z PEP 8 , w sekcji "zalecenia programowe" :

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

Dla wyjaśnienia, sekwencje są oceniane na False lub True w kontekście logicznym, jeśli są puste lub nie. Są nie równe False lub True.

Najbardziej eleganckim sposobem prawdopodobnie byłoby po prostu sprawdzić, czy to prawda czy fałsz, np.:

if not my_string:

Jednak możesz chcieć usunąć białą spację, ponieważ:

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

Prawdopodobnie powinieneś być nieco bardziej wyraźny w tym jednak, chyba że wiesz na pewno, że ten ciąg przeszedł jakiś rodzaj walidacji i jest ciągiem, który można przetestować w ten sposób.

Przed rozbieraniem testowałbym noneness. Użyłbym również faktu, że puste ciągi są FAŁSZYWE (lub fałszywe). To podejście jest podobne do StringUtils Apache ' a.Isblank lub isNullOrEmpty

To jest to, czego użyłbym do sprawdzenia, czy łańcuch jest albo None, albo 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, aby sprawdzić, czy ciąg nie jest None ani pusty ani 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 kod:

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

Jedynym naprawdę solidnym sposobem na to jest:

if "".__eq__(myString):

Wszystkie inne rozwiązania mają Możliwe problemy i skrajne przypadki, w których kontrola może się nie udać.

len(myString)==0 może się nie udać, jeśli {[2] } jest obiektem klasy, która dziedziczy z str i nadpisuje metodę __len__().

Podobnie myString == "" i myString.__eq__("") mogą się nie udać, jeśli myString nadpisują __eq__() i __ne__().

Z jakiegoś powodu "" == myString również daje się nabrać, jeśli myString nadpisuje __eq__().

myString is "" i "" is myString są równoważne. Obie strony zawiodą, jeśli {[2] } nie jest w rzeczywistości łańcuchem znaków, ale podklasą łańcuchów (obie zwrócą False). Ponadto, ponieważ są to kontrole tożsamości, jedynym powodem, dla którego działają, jest to, że Python używa poolingu łańcuchów (zwanego również Internmentem łańcuchów), który używa tej samej instancji łańcucha, jeśli jest internowany (zobacz tutaj: dlaczego porównywanie łańcuchów używając '==' lub 'is' czasami daje inny wynik?). I "" jest internowany od początku w CPython

Wielki problem przy sprawdzaniu tożsamości jest to, że internowanie ciągów jest (o ile mogłem znaleźć), że nie jest standaryzowane, które ciągi są internowane. Oznacza to, że teoretycznie "" nie jest konieczne internowanie, a to zależy od implementacji.

Jedynym sposobem na zrobienie tego, którego naprawdę nie da się oszukać, jest wspomniany na początku: "".__eq__(myString). Ponieważ to jawnie wywołuje metodę __eq__() pustego ciągu, nie można go oszukać przez nadpisanie jakichkolwiek metod w myString i solidnie działa z podklasy str.

Również poleganie na fałszywości łańcucha może nie działać, jeśli obiekt przesłania to metoda __bool__().

Jest to nie tylko praca teoretyczna, ale może być rzeczywiście istotne w rzeczywistym użyciu, ponieważ widziałem frameworków i bibliotek podklasowanie str przed i użycie myString is "" może zwrócić złe wyjście tam.

Porównywanie łańcuchów za pomocą is ogólnie jest dość złą pułapką, ponieważ czasami będzie działać poprawnie, ale nie w innych czasach, ponieważ łączenie ciągów przebiega według dość dziwnych zasad.

To powiedziawszy, w większości przypadków wszystkie wymienione rozwiązania będą działać poprawnie. Jest to głównie praca naukowa.

Test pusty lub pusty ciąg (Krótsza droga):

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

Jeśli chcesz odróżnić puste i null, sugerowałbym użycie if len(string), w przeciwnym razie sugerowałbym użycie po prostu if string, jak mówili inni. Zastrzeżenie dotyczące ciągów pełnych białych znaków nadal obowiązuje, więc nie zapomnij strip.

if stringname: daje false gdy łańcuch jest pusty. To chyba nie może być prostsze niż to.

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

Uważam, że hardcoding (sic) "" za każdym razem do sprawdzania pustego ciągu nie jest tak dobry.

Clean code approach

Należy porównać nazwę zmiennej opisowej.

Opisowe nazwy zmiennych

Można by pomyśleć ,że "empty_string" jest zmienną opisową nazwisko. nie jest.

Zanim pójdziesz i zrobisz empty_string = "" i myślisz, że masz świetną nazwę zmiennej do porównania. To nie jest to, co oznacza "nazwa zmiennej opisowej".

Dobra nazwa opisowa zmiennej jest oparta na jej kontekście. Musisz zastanowić się, czym jest pusty łańcuch .

Skąd to się bierze?
• 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

To sprawia, że kod jest bardzo czytelny

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

Dokładny przykład parsowania CSV

Analizujesz pliki CSV i chcesz, aby pusty łańcuch był parsowany jako None

(ponieważ plik CSV jest w całości tekstowy, nie może reprezentować None bez użycia predefiniowanych słów kluczowych)

Dobra nazwa zmiennej może być CSV_NONE

To sprawia, że kod łatwy do zmiany i dostosowania, jeśli masz nowy plik CSV, który reprezentuje {[7] } z innym łańcuchem niż ""

if csvfield == CSV_NONE:
    csvfield = None

Nie ma wątpliwości, 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?

To powie przyszłym koderom, że pusty łańcuch powinien być zawsze traktowany jako None.

To dlatego, że łączy logikę biznesową (Jaka powinna być wartość CSV None) z implementacją kodu (co właściwie porównujemy)

Musi istnieć oddzielenie troski między tymi dwoma.

Co ty na to? Może nie jest to "najbardziej eleganckie" , ale wydaje się całkiem kompletne i jasne: {]}

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

Odpowiadasz użytkownikowi @1290 Niestety, nie ma możliwości formatowania bloków w komentarzach. Wartość None nie jest pustym łańcuchem w Pythonie, podobnie jak (spacje). Odpowiedź Andrew Clarka jest prawidłowa: if not myString. Odpowiedź z @ Ruble jest specyficzna dla aplikacji i nie odpowiada na pytanie OP. Będziesz miał kłopoty, jeśli przyjmiesz osobliwą definicję tego, co jest "pustym" ciągiem. W szczególności standardowym zachowaniem jest to, że str(None) tworzy 'None', niepusty ciąg znaków.

Jednakże jeśli musisz traktuj None i (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 łamiąc przy tym oczekiwanego bool zachowania ciągów.

Uważam to za eleganckie, ponieważ upewnia się, że jest to ciąg 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

Poniżej znajduje się prosta metoda identyfikacji pustego łańcucha:

a="" #Empty string
if(len(a)==0): #len() is used to find the length of the string or variable inside its' brackets.
   print("Empty")
else:
   print("Filled")

Powyższa metoda len () jest wbudowaną funkcją, która pomaga nam znaleźć długość pewnego ciągu znaków lub zmiennej. Może być również stosowany w przypadku list .

Logika: jeżeli długość znaku lub zmiennej wynosi 0, to bezwzględnie oznacza to, że łańcuch lub zmienna jest pusta. ale pamiętaj, że będzie to działać tylko w przypadku łańcuchów i list, a nie z liczbami całkowitymi. Poniżej znajduje się kod, aby znaleźć Długość liczb całkowitych.

a=int(input())
if(len(str(a))==0):
   print(True)

W powyższym kodzie str () jest używany do konwersji int do formatu string, takiego jak z 123 na jego format string "123". W formacie string będzie on ważny.

not str(myString)

To wyrażenie jest prawdziwe dla ciągów, które są puste. Niepuste łańcuchy, None i non-string obiekty będą generować False, z zastrzeżeniem, że obiekty mogą nadpisać _ _ str__, aby pokrzyżować tę logikę przez zwrócenie wartości falsy.

Poeksperymentowałem ze strunami typu"","", "\n " itp. Chcę, aby isNotWhitespace było prawdziwe wtedy i tylko wtedy, gdy zmienna foo jest ciągiem znaków z co najmniej jednym Nie-białym znakiem. 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()

Owinąć to w definicji metody w razie potrzeby.

Możesz spojrzeć na to przypisując pustą wartość lub łańcuch w Pythonie

Chodzi o porównywanie pustych łańcuchów. Tak więc zamiast testowania pustki za pomocą not, Możesz sprawdzić, czy twój łańcuch jest równy pustemu łańcuchowi za pomocą "" pusty łańcuch...

Dla tych, którzy oczekują takiego 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 według linii i chcesz określić, która linia jest pusta, upewnij się, że użyjesz .strip(), ponieważ w linii "empty" znajduje się 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 użyjesz

not var1 

Nie jest możliwe odróżnienie zmiennej, która jest logiczna False od pustego ciągu '':

var1 = ''
not var1
> True

var1 = False
not var1
> True

Jednak, jeśli dodasz prosty warunek do skryptu, różnica jest:

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

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

W przypadku, gdy jest to przydatne dla kogoś, oto szybka funkcja, którą zbudowałem, aby zastąpić puste ciągi N / A w lists of lists (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 akceptuje spacji dla niektórych pól (pola oznaczone jako NN w schemacie. w moim przypadku było to spowodowane złożonym kluczem głównym).

Jak wyżej napisał prmatta, ale z błędem.

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