Le moyen le plus élégant de vérifier si la chaîne est vide en Python?
Python a-t-il quelque chose comme une variable de chaîne vide où vous pouvez faire:
if myString == string.empty:
Quoi qu'il en soit, quel est le moyen le plus élégant de vérifier les valeurs de chaînes vides? Je trouve le codage dur "" à chaque fois pour vérifier une chaîne vide pas aussi bonne.
Les chaînes vides sont "falsy" ce qui signifie qu'elles sont considérées comme fausses dans un contexte booléen, vous pouvez donc faire ceci:
if not myString:
C'est la méthode préférée si vous savez que votre variable est une chaîne. Si votre variable peut également être d'un autre type, vous devez utiliser myString == "". Reportez-vous à la documentation sur Vérification des valeurs de vérité pour les autres valeurs qui sont fausses dans les contextes booléens.
De PEP 8 , dans la section «Recommandations de programmation» :
Pour les séquences (chaînes, listes, tuples), utilisez le fait que les séquences vides sont fausses.
Donc, vous devriez utiliser:
if not some_string:
ou:
if some_string:
Juste pour clarifier, les séquences sont évaluées en False ou True dans un contexte booléen si elles sont vides ou non. Ils sont pas égaux à False ou True.
La manière la plus élégante serait probablement de simplement vérifier si c'est vrai ou faux, par exemple:
if not my_string:
Cependant, vous voudrez peut-être supprimer les espaces blancs pour les raisons suivantes:
>>> bool("")
False
>>> bool(" ")
True
>>> bool(" ".strip())
False
Cependant, vous devriez probablement être un peu plus explicite à moins que vous ne soyez certain que cette chaîne a passé une sorte de validation et qu'elle peut être testée de cette façon.
Je testerais noneness avant de décaper. En outre, j'utiliserais le fait que les chaînes vides sont False (ou Falsy). Cette approche est similaire à Apache's StringUtils.isBlank ou Guava's Strings.isNullOrEmpty
C'est ce que je voudrais utiliser pour tester si une chaîne est soit Aucun OR Vide OR Vierge:
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
Et, l'exact opposé pour tester si une chaîne n'est pas None NOR Vide NOR Vierge:
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
Des formes plus concises du code ci-dessus:
def isBlank (myString):
return not (myString and myString.strip())
def isNotBlank (myString):
return bool(myString and myString.strip())
J'ai une fois écrit quelque chose de similaire à la réponse de Bartek et inspiré par javascript:
def is_not_blank(s):
return bool(s and s.strip())
Tester:
print is_not_blank("") # False
print is_not_blank(" ") # False
print is_not_blank("ok") # True
print is_not_blank(None) # False
Testez une chaîne vide ou vide (moyen plus court):
if myString.strip():
print("it's not an empty or blank string")
else:
print("it's an empty or blank string")
Si vous voulez différencier les chaînes vides des chaînes vides, je vous suggérerais d'utiliser if len(string), sinon, je suggérerais d'utiliser simplement if string comme d'autres l'ont déjà dit. La mise en garde concernant les chaînes pleines d'espaces s'applique toujours, alors n'oubliez pas de strip.
if my_string is '':
Je n'ai pas remarqué cette combinaison particulière dans aucune des réponses. J'ai cherché
is ''
dans les réponses avant de poster.
if my_string is '': print ('My string is EMPTY') # **footnote
Je pense que c’est ce à quoi l’affiche originale tentait de parvenir… quelque chose qui se lit le plus près possible de l’anglais et qui respecte de solides pratiques de programmation.
if my_string is '':
print('My string is EMPTY')
else:
print(f'My string is {my_string}')
Caractère pour caractère Je pense que cette solution est bonne.
J'ai noté que None est entré dans la discussion, donc en ajoutant cela et en compactant davantage, nous obtenons:
if my_string is '': print('My string is Empty')
Elif my_string is None : print('My string.... isn\'t')
else: print(f'My string is {my_string}')
a = ''
b = ' '
a.isspace() -> False
b.isspace() -> True
if stringname: donne une false lorsque la chaîne est vide. Je suppose que cela ne peut pas être plus simple que cela.
Je trouve le "" codage en dur "à chaque fois pour vérifier une chaîne vide moins bonne.
Approche de code propre
Faire ceci: foo == "" est une très mauvaise pratique. "" est une valeur magique. Vous ne devriez jamais vérifier contre des valeurs magiques (plus communément appelé nombres magiques )
Ce que vous devez faire est de comparer à un nom de variable descriptif.
Noms descriptifs des variables
On peut penser que "chaîne_ vide" est un nom de variable descriptif. Ce n'est pas.
Avant de vous lancer, faites empty_string = "" et pensez que vous avez un bon nom de variable à comparer. Ce n'est pas ce que "nom descriptif de variable" signifie.
Un bon nom de variable descriptive est basé sur son contexte . Vous devez penser à ce que la chaîne vide est.
- D'où est ce que ça vient.
- Pourquoi est-ce là.
- Pourquoi avez-vous besoin de vérifier pour cela.
Exemple de champ de formulaire simple
Vous construisez un formulaire où un utilisateur peut entrer des valeurs. Vous voulez vérifier si l'utilisateur a écrit quelque chose ou non.
Un bon nom de variable peut être not_filled_in
Cela rend le code très lisible
if formfields.name == not_filled_in:
raise ValueError("We need your name")
Exemple d'analyse approfondie au format CSV
Vous analysez des fichiers CSV et souhaitez que la chaîne vide soit analysée sous la forme None
(Le format CSV étant entièrement basé sur du texte, il ne peut pas représenter None sans utiliser de mots-clés prédéfinis.)
Un bon nom de variable peut être CSV_NONE
Cela rend le code facile à modifier et à adapter si vous avez un nouveau fichier CSV qui représente None avec une autre chaîne que ""
if csvfield == CSV_NONE:
csvfield = None
Il n'y a aucune question quant à savoir si ce morceau de code est correct. Il est clair qu’il fait ce qu’il devrait faire.
Comparez ceci à
if csvfield == EMPTY_STRING:
csvfield = None
La première question est la suivante: pourquoi la chaîne vide mérite-t-elle un traitement spécial?
Cela indiquerait aux futurs codeurs qu'une chaîne vide doit toujours être considérée comme None.
En effet, il mélange la logique métier (quelle valeur CSV doit être None) avec la mise en oeuvre du code (à quoi nous comparons-nous)
Il doit y avoir une séparation des préoccupations entre les deux.
Soit le suivant
foo is ''
ou même
empty = ''
foo is empty
Que dis-tu de ça? Ce n'est peut-être pas "le plus élégant", mais cela semble assez complet et clair
if (s is None) or (str(s).strip()==""): // STRING s IS "EMPTY"...
En réponse à @ 1290. Désolé, aucun moyen de formater des blocs dans les commentaires. La valeur None n'est pas une chaîne vide en Python, pas plus que (espaces). La réponse d'Andrew Clark est la bonne: if not myString. La réponse de @rouble est spécifique à l'application et ne répond pas à la question du PO. Vous aurez des problèmes si vous adoptez une définition particulière de ce qui est une chaîne "vide". En particulier, le comportement standard est que str(None) génère 'None', une chaîne non vide.
Cependant, si vous devez traiter None et (espaces) comme des chaînes "vides", voici une meilleure solution:
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())
Exemples:
>>> 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
Répond aux exigences @rouble sans rompre le comportement bool attendu des chaînes.
La seule façon vraiment solide de faire cela est la suivante:
if "".__eq__(myString):
Toutes les autres solutions ont des problèmes possibles et des cas Edge où la vérification peut échouer.
len(myString)==0 peut échouer si myString est un objet d'une classe qui hérite de str et remplace la méthode __len__().
De même, myString == "" et myString.__eq__("") peuvent échouer si myString remplace __eq__() et __ne__().
Pour une raison quelconque, "" == myString est également trompé si myString remplace __eq__().
myString is "" et "" is myString sont équivalents. Ils échoueront tous les deux si myString n'est pas réellement une chaîne mais une sous-classe de chaîne (les deux renverront False). De plus, comme il s’agit de contrôles d’identité, leur fonctionnement s’explique uniquement par le fait que Python utilise le regroupement de chaînes (également appelé internement de chaînes), qui utilise la même instance d’une chaîne si elle est internée (voir ici: Pourquoi la comparaison de chaînes à l’aide de '==' ou 'est' produit parfois un résultat différent? ). Et "" est interné dès le début dans CPython
Le gros problème avec le contrôle d'identité est que String Internment est (autant que j'ai pu le trouver) qu'il n'est pas standardisé les chaînes qui sont internées. Cela signifie que, théoriquement, "" n'est pas nécessaire interné et que cela dépend de la mise en œuvre.
La seule façon de le faire qui ne puisse vraiment pas être dupe est celle mentionnée au début: "".__eq__(myString). Puisque ceci appelle explicitement la méthode __eq__() de la chaîne vide, il est impossible de tromper en surchargeant les méthodes de myString et de travailler de manière solide avec les sous-classes de str.
S'appuyer également sur la fausseté d'une chaîne peut ne pas fonctionner si l'objet remplace sa méthode __bool__().
C’est non seulement un travail théorique, mais il pourrait aussi s’avérer pertinent dans l’usage réel, car j’ai vu des sous-classes et des bibliothèques sous-classer str avant et utiliser myString is "" pourrait y retourner une sortie erronée.
En outre, comparer des chaînes à l'aide de is en général est un piège assez diabolique puisqu'il fonctionnera parfois correctement, mais pas à d'autres moments, car le regroupement de chaînes suit des règles assez étranges.
Cela dit, dans la plupart des cas, toutes les solutions mentionnées fonctionneront correctement. C'est post est principalement un travail académique.
not str(myString)
Cette expression est vraie pour les chaînes qui sont vides. Les chaînes non vides, les objets None et les non-chaînes produiront toutes la valeur False, mais les objets peuvent remplacer __str__ pour déjouer cette logique en renvoyant une valeur falsy.
str = ""
if not str:
print "Empty String"
if(len(str)==0):
print "Empty String"
Un autre moyen simple pourrait être de définir une fonction simple:
def isStringEmpty(inputString):
if len(inputString) == 0:
return True
else:
return False
Si vous venez d'utiliser
not var1
il n'est pas possible de différencier une variable booléenne False d'une chaîne vide '':
var1 = ''
not var1
> True
var1 = False
not var1
> True
Cependant, si vous ajoutez une condition simple à votre script, la différence est faite:
var1 = False
not var1 and var1 != ''
> True
var1 = ''
not var1 and var1 != ''
> False
Vous pouvez jeter un oeil à ceci Assigner une valeur vide ou une chaîne en Python
Il s’agit de comparer des chaînes vides. Donc, au lieu de tester le vide avec not, vous pouvez tester si votre chaîne est égale à chaîne vide avec "" la chaîne vide ...
Au cas où cela serait utile à quelqu'un, voici une fonction rapide que j'ai créée pour remplacer les chaînes vides par des N/A dans les listes de listes (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
Ceci est utile pour poster des listes de listes dans une base de données mysql qui n'accepte pas les blancs pour certains champs (les champs marqués NN dans le schéma. Dans mon cas, cela était dû à une clé primaire composite).
pour ceux qui s'attendent à un comportement comme Apache StringUtils.isBlank ou Guava Strings.isNullOrEmpty :
if mystring and mystring.strip():
print "not blank string"
else:
print "blank string"
Je trouve cela élégant car il s'assure que c'est une chaîne et vérifie sa longueur:
def empty(mystring):
assert isinstance(mystring, str)
if len(mystring) == 0:
return True
else:
return False
Lorsque vous lisez fichier par lignes et que vous souhaitez déterminer quelle ligne est vide, assurez-vous d'utiliser .strip(), car il y a un nouveau caractère de ligne dans la ligne "vide":
lines = open("my_file.log", "r").readlines()
for line in lines:
if not line.strip():
continue
# your code for non-empty lines