Come verificare se la stringa è vuota?


1421

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.


2
Come ""non è buono?
NoName

Risposte:


2117

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.


183
Fai attenzione, poiché anche molte altre cose sono false.
Ignacio Vazquez-Abrams,

9
Non avevo mai sentito parlare del termine falsa prima. Significa che restituisce false?
Joan Venge,

41
@Joan: valuta falso in un contesto booleano.
Ignacio Vazquez-Abrams,

54
OP vuole sapere se la variabile è una stringa vuota, ma si sarebbe anche entrare nel if not myString:blocco se myStringerano None, 0, Falseecc Quindi, se non si è sicuri di che tipo myStringsia, è necessario utilizzare if myString == "":per determinare se si tratta di una stringa vuota al contrario di qualche altro valore falso.
Andrew Clark,

15
@AndrewClark, per un caso del genere, invece di una catena di if myString == ...espressioni, potremmo usare if myString in (None, '')o per @Bartek,if myString in (None, '') or not myString.strip()
Stew

414

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.


24
Fantastico che tu abbia incluso riferimenti al PEP!
Felix,

3
PS: A difesa del PEP, si potrebbe sostenere che dire " x è falso " (minuscolo falso ) significa già questo, piuttosto che significato x == False. Ma IMHO il chiarimento è ancora ben accetto dato il pubblico destinatario.
MestreLion,

234

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.


88

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

perchè no if mystring and not mystring.strip()?
Migol,

1
Come è diverso da string and not string.isspace()?
Andrea Corbellini,

7
Più conciso per coloro che hanno a cuore queste cose: def isBlank(s): return not (s and s.strip())e def isNotBlank(s): return s and s.strip().
Carl,

49

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

Perché non soloreturn bool(s.strip())
anilbey

1
AttributeError: 'NoneType' object has no attribute 'strip'
caveau

28

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.


2
@simpleuser hai ovviamente ragione. Nel mondo reale è del tutto ok usare la falsità della stringa o confrontarla con una stringa vuota. Questa risposta qui è eccessiva di proposito.
Dakkaron,

davvero, usa eq_ ?
scialuppa il

funziona benissimo, grazie!
eugene.polschikov

14

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

7
Se myString = None, genererà un'eccezione. Meglio usare la risposta di
Dominik,

9

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.


Non so perché vorresti evitare di utilizzare "", a meno che non influisca in qualche modo sulle prestazioni, ma preferisco la tua risposta a quella con miliardi di voti positivi, poiché è meno confusa. Tuttavia, volevo sottolineare che una lista vuota è anche falsa, a quanto pare.
Brōtsyorfuzthrāx,

7

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


7

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.


1
Bisogna davvero andare così tanto nei guai per evitare un ""? Nel contesto del confronto, cos'altro potrebbe significare una stringa vuota?

Mentre scrivo nella mia risposta, CSV non può rappresentare null senza usare una stringa. Se sei libero dal contesto, allora congratulazioni! La maggior parte del codice non lo è.
firelynx,

2
dici che "not_filled_in" è più descrittivo di "empty_string"? Dico che sei alta.
Tuncay Göncüoğlu,

@ TuncayGöncüoğlu "Stringa vuota" non descrive a cosa serve l'istruzione if.
firelynx,

5
Non sarei d'accordo con quella risposta. I numeri magici sono cattivi, questo ha senso. Valori magici anche in generale. Ma ""non è un valore magico, uguale True, Falseo Nonenon sono valori magici.
Dakkaron,

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

1
Davvero non capisco cosa guadagna questa soluzione. La domanda riguarda il test se una stringa è vuota. Se imposti , a='a'otterrai a.isspace() -> False, ma su aquell'account non sarebbe una stringa vuota.
Adrian Keister l'

5

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

Per la maggior parte degli scopi, una stringa contenente spazi vuoti non è "vuota".
Chris Johnson,

Suppongo che non intendi altro che uno spazio bianco? Ti riferisci al mio uso di strip ()? Per la maggior parte che è vuoto! È ridicolmente comune mescolare qualcosa come s.trim (). IsEmpty ()
BuvinJ

Ehi @ Chris Johnson, hai visto che la maggior parte delle risposte qui usa anche strip ()? Hai votato in giù tutti noi o solo io?
BuvinJ,

4

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.


python -c "if (str(None) == 'None'): print ('OMG, WHY ??')"
Yordan Georgiev,

3

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

Attenzione, le asserzioni sono intese come uno strumento di debug e vengono ottimizzate se passi il -Oflag o imposti la PYTHONOPTIMIZEvariabile env.
SilentVoid

2

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

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

3
la risposta del cardamomo è più completa se vogliamo verificare se l'input è una stringa o no
tanzil

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




0

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

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

0

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

0

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


-1

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.


-3

Come prmatta pubblicato sopra, ma con errore.

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

Appena testato: Le sue restituisce il codice di True per ""e " "e False per "a"(proprio come previsto). Il codice restituisce lo stesso, ad eccezione della stringa vuota che restituisce True, cosa non dovrebbe.
AbcAeffchen,

sry troppo stanco: il tuo codice restituisce False per la stringa vuota.
AbcAeffchen,

Questo codice è sbagliato Restituisci False se una stringa è vuota o nessuna.
rublo,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.