Python ha qualcosa come una variabile stringa vuota in cui puoi fare:

if myString == string.empty:

Indipendentemente da ciò, qual è il modo più elegante per verificare la presenza di valori di stringa vuoti? Trovo ""ogni volta una codifica difficile per controllare una stringa vuota non altrettanto buona.

Le stringhe vuote sono "falsi", il che significa che sono considerate false in un contesto booleano, quindi puoi semplicemente farlo:

if not myString:

Questo è il modo preferito se sai che la tua variabile è una stringa. Se la tua variabile potrebbe anche essere di qualche altro tipo, allora dovresti usare myString == "". Vedere la documentazione sul Test del valore di verità per altri valori falsi in contesti booleani.

Da PEP 8 , nella sezione "Consigli per la programmazione" :

Per le sequenze (stringhe, elenchi, tuple), usa il fatto che le sequenze vuote sono false.

Quindi dovresti usare:

if not some_string:

o:

if some_string:

Giusto per chiarire, le sequenze vengono valutate in Falseo Truein un contesto booleano se sono vuote o meno. Non sono uguali a Falseo True.

Il modo più elegante sarebbe probabilmente quello di verificare se è vero o falso, ad esempio:

if not my_string:

Tuttavia, potresti voler eliminare gli spazi bianchi perché:

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

Probabilmente dovresti essere un po 'più esplicito in questo, a meno che tu non sappia per certo che questa stringa ha superato un qualche tipo di validazione ed è una stringa che può essere testata in questo modo.

Prima di mettere a nudo testerei la non-unità. Inoltre, vorrei usare il fatto che le stringhe vuote sono false (o falsi). Questo approccio è simile a StringUtils.isBlank di Apache o Strings.isNullOrEmpty di Guava

Questo è ciò che vorrei utilizzare per testare se una stringa è Nessuna O Vuota O Vuota:

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

E l'esatto contrario per verificare se una stringa non è None NOR Vuota NOR Vuota:

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

Forme più concise del codice sopra:

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

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

Una volta ho scritto qualcosa di simile alla risposta di Bartek e ispirato a 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

L'unico modo veramente solido per farlo è il seguente:

if "".__eq__(myString):

Tutte le altre soluzioni hanno possibili problemi e casi limite in cui il controllo può fallire.

len(myString)==0può fallire se myStringè un oggetto di una classe che eredita stre ignora il __len__()metodo.

Allo stesso modo myString == ""e myString.__eq__("")può fallire se myStringignora __eq__()e __ne__().

Per qualche motivo "" == myStringviene anche ingannato se si myStringsostituisce __eq__().

myString is ""e "" is myStringsono equivalenti. Entrambi falliranno se in myStringrealtà non è una stringa ma una sottoclasse di stringa (entrambi restituiranno False). Inoltre, poiché sono controlli di identità, l'unica ragione per cui funzionano è perché Python utilizza String Pooling (anche chiamato String Internment) che utilizza la stessa istanza di una stringa se è internata (vedi qui: Perché il confronto delle stringhe usando '= = = 'o' is 'a volte producono un risultato diverso? ). Ed ""è internato dall'inizio in CPython

Il grosso problema con il controllo dell'identità è che String Internment è (per quanto ho potuto trovare) che non è standardizzato quali stringhe sono internate. Ciò significa che teoricamente ""non è necessario internato e dipende dall'implementazione.

L'unico modo per farlo che in realtà non può essere ingannato è quello citato all'inizio: "".__eq__(myString). Dal momento che questo chiama esplicitamente il __eq__()metodo della stringa vuota, non può essere ingannato sovrascrivendo alcun metodo in myString e funziona solidamente con le sottoclassi di str.

Anche fare affidamento sulla falsità di una stringa potrebbe non funzionare se l'oggetto ignora il suo __bool__()metodo.

Questo non è solo un lavoro teorico, ma potrebbe effettivamente essere rilevante nell'uso reale poiché ho visto sottoclassare i framework e le librerie strprima e l'utilizzo myString is ""potrebbe restituire un output errato lì.

Inoltre, confrontare le stringhe usando isin generale è una trappola piuttosto malvagia poiché funzionerà correttamente a volte, ma non altre volte, poiché il pool di stringhe segue regole piuttosto strane.

Detto questo, nella maggior parte dei casi tutte le soluzioni menzionate funzioneranno correttamente. Questo post è principalmente un lavoro accademico.

Prova stringa vuota o vuota (modo più breve):

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

Se vuoi distinguere tra stringhe vuote e null, suggerirei di usare if len(string), altrimenti suggerirei di usare semplicemente if stringcome altri hanno già detto. Tuttavia, le avvertenze sulle stringhe piene di spazi bianchi sono ancora valide, quindi non dimenticare di farlo strip.

if stringname:dà un falsequando la stringa è vuota. Immagino che non possa essere più semplice di così.

Trovo hardcoding (sic) "" ogni volta che il controllo di una stringa vuota non è buono.

Approccio al codice pulito

Fare questo: foo == ""è una pessima pratica. ""è un valore magico. Non dovresti mai verificare i valori magici (più comunemente noti come numeri magici )

Quello che dovresti fare è confrontare con un nome di variabile descrittivo.

Nomi delle variabili descrittive

Si potrebbe pensare che "empty_string" sia un nome di variabile descrittivo. Non lo è .

Prima di andare e fare empty_string = ""e pensare di avere un grande nome di variabile da confrontare. Questo non significa "nome variabile descrittivo".

Un buon nome di variabile descrittivo si basa sul suo contesto. Bisogna pensare a ciò che la stringa vuota è .

• Da dove viene.
• Perché è lì?
• Perché è necessario verificarlo.

Esempio di campo modulo semplice

Stai creando un modulo in cui un utente può inserire valori. Vuoi verificare se l'utente ha scritto qualcosa o no.

Potrebbe essere un buon nome di variabile not_filled_in

Questo rende il codice molto leggibile

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

Esempio di analisi approfondita di CSV

Stai analizzando i file CSV e vuoi che la stringa vuota venga analizzata come None

(Poiché CSV è interamente basato su testo, non può rappresentare None senza l'utilizzo di parole chiave predefinite)

Potrebbe essere un buon nome di variabile CSV_NONE

Ciò semplifica la modifica e l'adattamento del codice se si dispone di un nuovo file CSV che rappresenta Nonecon un'altra stringa di""

if csvfield == CSV_NONE:
    csvfield = None

Non ci sono dubbi sul fatto che questo codice sia corretto. È abbastanza chiaro che fa quello che dovrebbe fare.

Confronta questo con

if csvfield == EMPTY_STRING:
    csvfield = None

La prima domanda qui è: perché la stringa vuota merita un trattamento speciale?

Ciò direbbe ai programmatori futuri che una stringa vuota dovrebbe essere sempre considerata come None .

Questo perché mescola la logica aziendale (quale valore CSV dovrebbe essere None ) con l'implementazione del codice (a cosa stiamo effettivamente confrontando)

Deve esserci una separazione di preoccupazione tra i due.

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

Cosa ne pensi di questo? Forse non è "il più elegante", ma sembra abbastanza completo e chiaro:

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

Risposta a @ 1290. Spiacenti, non è possibile formattare i blocchi nei commenti. Il Nonevalore non è una stringa vuota in Python e nemmeno lo è (spazi). La risposta da Andrew Clark è quella corretta: if not myString. La risposta di @rouble è specifica dell'applicazione e non risponde alla domanda del PO. Ti metterai nei guai se adotti una definizione peculiare di cos'è una stringa "vuota". In particolare, il comportamento standard è quello che str(None)produce 'None'una stringa non vuota.

Tuttavia, se devi trattare Nonee (spazi) come stringhe "vuote", ecco un modo migliore:

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

Esempi:

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

Soddisfa i requisiti di @rouble senza interrompere il boolcomportamento previsto delle stringhe.

Lo trovo elegante in quanto si assicura che sia una stringa e ne controlla la lunghezza:

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

Un altro modo semplice potrebbe essere quello di definire una funzione semplice:

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

not str(myString)

Questa espressione è vera per le stringhe che sono vuote. Stringhe non vuote, Nessuno e oggetti non stringa produrranno tutti False, con l'avvertenza che gli oggetti possono sovrascrivere __str__ per contrastare questa logica restituendo un valore errato.

Puoi dare un'occhiata a Assegnare un valore o una stringa vuoti in Python

Si tratta di confrontare stringhe vuote. Quindi, invece di testare il vuoto con not, è possibile verificare se la stringa è uguale a stringa vuota con ""la stringa vuota ...

per coloro che si aspettano un comportamento come l'apache StringUtils.isBlank o Guava Strings.isNullOrEmpty :

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

Quando stai leggendo il file per righe e vuoi determinare quale riga è vuota, assicurati di usare .strip(), perché c'è un nuovo carattere di riga nella riga "vuota":

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"

Se solo usi

not var1 

non è possibile differenziare una variabile che è booleana Falseda una stringa vuota '':

var1 = ''
not var1
> True

var1 = False
not var1
> True

Tuttavia, se aggiungi una semplice condizione al tuo script, la differenza viene fatta:

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

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

Nel caso in cui questo sia utile a qualcuno, ecco una funzione rapida che ho creato per sostituire le stringhe vuote con N / A negli elenchi di elenchi (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

Ciò è utile per pubblicare elenchi di elenchi in un database mysql che non accetta spazi vuoti per alcuni campi (campi contrassegnati come NN nello schema. Nel mio caso, ciò era dovuto a una chiave primaria composita).

Ho fatto qualche sperimentazione con stringhe come '', '', '\ n', ecc. Voglio che isNotWhitespace sia True se e solo se la variabile foo è una stringa con almeno un carattere non bianco. Sto usando Python 3.6. Ecco cosa ho finito con:

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

Se lo desideri, includilo nella definizione di un metodo.

Come prmatta pubblicato sopra, ma con errore.

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