Nu Python ceva ca un șir gol variabilă în cazul în care puteți face:
if myString == string.empty:
Indiferent, ceea ce's cel mai elegant mod de a verifica șir gol valori? Mi se pare greu de codificare `"" de fiecare data pentru a verifica un șir gol nu la fel de bun.
Siruri de caractere goale sunt "falsy" ceea ce înseamnă că ele sunt considerate false într-un Boolean context, astfel încât să puteți face doar asta:
if not myString:
Aceasta este metoda preferată, dacă știi că variabila este un șir de caractere. Dacă variabila poate fi, de asemenea, un alt tip, atunci ar trebui să utilizați myString == ""
. Consultați documentația pe Valoare de Adevăr Testarea pentru alte valori care sunt false în Boolean contexte.
De PEP 8, în "Recomandări de Programare" secțiune:
Pentru secvențe, (siruri de caractere, liste, tupluri), utilizați faptul că gol secvențe sunt false.
Deci, ar trebui să utilizați:
if not some_string:
sau:
if some_string:
Doar pentru a clarifica, secvențe sunt evaluat a "False" sau "Adevărat" într-un Boolean context, dacă acestea sunt goale sau nu. Acestea sunt nuegal** a "False" sau "Adevărat".
Modul cel mai elegant ar fi, probabil, pur și simplu pentru a verifica dacă e adevărat sau falsy, de exemplu:
if not my_string:
Cu toate acestea, poate doriți să se dezbrace spațiu alb, deoarece:
>>> bool("")
False
>>> bool(" ")
True
>>> bool(" ".strip())
False
Probabil că ar trebui să fii un pic mai explicit în această cu toate acestea, dacă nu știi sigur că acest șir a trecut un fel de validare și este un șir de caractere care pot fi testate în acest fel.
Mi-ar testa noneness înainte de stripare. De asemenea, mi-ar folosi faptul că siruri de caractere goale sunt False (sau Falsy). Această abordare este similară cu Apache's StringUtils.isBlank sau Guava's Siruri de caractere.isNullOrEmpty
Aceasta este ceea ce mi-ar folosi pentru a testa dacă un șir este fie Nici unul SAU Gol SAU Gol:
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, exact opusul a testa dacă un șir nu este Nici unul, NICI Gol, NICI Gol:
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
Mai concis forme de codul de mai sus:
def isBlank (myString):
return not (myString and myString.strip())
def isNotBlank (myString):
return bool(myString and myString.strip())
Am scris mai demult ceva similar cu Bartek's a răspunde și javascript inspirat:
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
Singurul cu adevărat solid mod de a face acest lucru este urmatoarea:
if "".__eq__(myString):
Toate celelalte soluții au posibile probleme și cazuri de margine în cazul în care cecul poate eșua.
len(myString)==0
poate eșua dacă myString
este un obiect dintr-o clasă care moștenește de la str
și suprascrie `len () metodă.
În mod similar myString == "" " și " myString.__eq__("")
poate eșua dacă myString
anulează __eq__ () " și " __ne__()
.
Pentru unii motiv "" == myString, de asemenea, devine păcălit dacă
myStringanulează
eq()`.
myString este "" " și " "" este myString
sunt echivalente. Ele vor eșua în cazul myString
nu este de fapt un șir de caractere, dar o subclasă de coarde (atât va reveni "False"). De asemenea, deoarece acestea sunt controale de identitate, singurul motiv pentru care ei lucrează deoarece Python folosește un Șir Comun (de asemenea, numit Șir de Internare), care utilizează aceeași instanță de un șir cazul în care este internat (a se vedea aici: https://stackoverflow.com/questions/1504717/why-does-comparing-strings-using-either-or-is-sometimes-produce-a-differe). Și"" este internat de la început în CPython
Problema mare cu verificarea identității este acel Șir de Internare este (în măsura în care am putut găsi), care nu este standardizat care siruri de caractere sunt internați. Asta înseamnă că, teoretic, `"" nu este necesar internați și care este dependent de implementare.
Singurul mod de a face asta într-adevăr nu poate fi păcălit este cel mentionat la inceput: "".__eq__(myString)
. Deoarece acest mod explicit numește __eq__()
metoda de șir gol nu poate fi păcălit prin imperative orice metode în myString și solid functioneaza cu subclase de str
.
De asemenea, bazându-se pe falsyness de un șir ar putea să nu funcționeze în cazul în care obiectul suprascrie-l's `bool () metodă.
Acest lucru nu este numai teoretică, dar ar putea fi de fapt relevante în timp real de utilizare, deoarece am văzut cadre și biblioteci subclasarea str
înainte și folosirea myString este ""` s-ar putea reveni o ieșire greșit acolo.
De asemenea, compararea de siruri de caractere folosind "este" în general, este o destul de rău capcană, deoarece acesta va funcționa corect uneori, dar nu în alte momente, când string comun cum urmează destul de ciudat reguli.
Asta a spus, în cele mai multe cazuri de menționat soluții va funcționa corect. Acest lucru este post este cea mai mare parte a activității academice.
Dacă doriți să diferențieze între gol și siruri de caractere null, aș sugera folosind dacă len(string)
, în caz contrar, am'd sugerăm să utilizați pur și simplu dacă șirul` cum au spus și alții. Avertismentul despre siruri de caractere plin de spațiu se aplică în continuare, deși, așa că don't uitați să "bandă".
am găsi hardcoding(sic) "" de fiecare data pentru a verifica un șir gol nu la fel de bun.
Face acest lucru: foo == "" este foarte rău practică.
"" este o valoare magică. Tu nu ar trebui să verificați împotriva magice valori (mai cunoscut sub numele de [magic numere][1])
Ce trebuie să faceți este de a compara la o descriptive nume de variabilă.
Una ar putea crede că "empty_string" este un descriptiv nume de variabilă. E't.
Înainte de a merge și de a face `empty_string = "" și cred că aveți o mare de nume de variabilă pentru a compara. Acest lucru nu este ceea ce "descriptiv nume de variabilă" înseamnă.
Un bun descriptive nume de variabilă se bazează pe contextul său. Trebuie să te gândești la ce șir gol este.
Sunteți construirea o formă în cazul în care utilizatorul poate introduce valori. Vrei pentru a verifica dacă utilizatorul a scris ceva sau nu.
Un bun nume de variabilă poate fi not_filled_in
Acest lucru face codul foarte ușor de citit
if formfields.name == not_filled_in:
raise ValueError("We need your name")
Ești parsarea fișierelor CSV și vreau șir gol pentru a fi analizate ca "Nici unul"
(Din CSV este în întregime bazat pe text, nu poate reprezenta "Nici unul" fără a utiliza cuvinte cheie predefinite)
Un bun nume de variabilă poate fi CSV_NONE
Acest lucru face codul ușor de a schimba și adapta, dacă aveți un nou fișier CSV, care reprezintă "Nici unul" cu un alt șir de ""
if csvfield == CSV_NONE:
csvfield = None
Nu există întrebări despre dacă această bucată de cod este corect. Este destul de clar că ea face ceea ce ar trebui să facă.
Compara asta
if csvfield == EMPTY_STRING:
csvfield = None
Prima întrebare este, de Ce șir gol merită un tratament special?
Acest lucru o va spune viitorul programatori care un șir gol ar trebui să fie întotdeauna considerată ca "Nici unul".
Acest lucru este pentru că amestecă logica de afaceri (Ce CSV valoare ar trebui să fie "Nici unul"), cu codul de punere în aplicare (Ce suntem noi de fapt compararea a)
Acolo trebuie să fie o separare de îngrijorare]2 între cele două.
[1]: https://en.wikipedia.org/wiki/Magic_number_(de programare)
Răspunzând la @1290. Îmi pare rău, nici o modalitate de a formata blocurile în comentarii. "Nici unul" valoarea nu este un șir gol în Python, și nici nu este (spatii). Răspunsul la Andrew Clark este cel corect: dacă nu myString
. Răspunsul de la @rublei este specifică aplicației și nu răspunde la OP's întrebare. Vei avea probleme dacă vei adopta o definiție aparte a ceea ce este un "gol" string. În special, standard de comportament este că str(Nici unul)
produce 'Nu'
, un non-gol șir.
Cu toate acestea, dacă trebuie să trateze "Nici unul" și (spatii) ca "gol" siruri de caractere, aici este o modalitate mai bună:
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())
Exemple:
>>> 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
Îndeplinește @rublei cerințele în timp ce nu rupe așteptat `bool comportamentul de siruri de caractere.
Dacă utilizați doar
not var1
nu este posibil să diferenta o variabilă care este boolean "False" de un șir gol''
:
var1 = ''
not var1
> True
var1 = False
not var1
> True
Cu toate acestea, dacă adăugați o condiție simplă pentru a script-ul dvs., diferența se face:
var1 = False
not var1 and var1 != ''
> True
var1 = ''
not var1 and var1 != ''
> False
În cazul în care acest lucru este util pentru cineva, aici este o scurtă funcția-am construit pentru a înlocui gol siruri cu N/O's, în listele de liste (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
Acest lucru este util pentru a posta liste de liste pentru o baza de date mysql care nu acceptă spații pentru anumite câmpuri (câmpurile marcate ca NN în schemă. în cazul meu, acest lucru s-a datorat unui compozit cheie primară).
pentru cei care se așteaptă la un comportament de genul apache StringUtils.isBlank sau Guava Siruri de caractere.isNullOrEmpty :
if mystring and mystring.strip():
print "not blank string"
else:
print "blank string"
Când sunteți de lectură fișier de linii și doresc să stabilească, în care linia este în gol, asigurați-vă că veți folosi.strip()`, pentru că nu există linie nouă de caractere din "gol" linia:
lines = open("my_file.log", "r").readlines()
for line in lines:
if not line.strip():
continue
# your code for non-empty lines