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, quelle est la façon la plus élégante de vérifier les valeurs de chaîne vides? Je trouve que le codage dur à ""chaque fois pour vérifier une chaîne vide n'est pas aussi bon.

Les chaînes vides sont "fausses", ce qui signifie qu'elles sont considérées comme fausses dans un contexte booléen, vous pouvez donc simplement faire ceci:

if not myString:

C'est le moyen préféré si vous savez que votre variable est une chaîne. Si votre variable peut également être d'un autre type, vous devez l'utiliser myString == "". Consultez la documentation sur le test de valeur de vérité pour d'autres valeurs fausses dans des contextes booléens.

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

Vous devez donc utiliser:

if not some_string:

ou:

if some_string:

Juste pour clarifier, les séquences sont évaluées vers Falseou Truedans un contexte booléen si elles sont vides ou non. Ils ne sont pas égaux à Falseou True.

La façon la plus élégante serait probablement de simplement vérifier si c'est vrai ou faux, par exemple:

if not my_string:

Cependant, vous souhaiterez peut-être supprimer les espaces blancs car:

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

Cependant, vous devriez probablement être un peu plus explicite à ce sujet, sauf si vous savez avec certitude que cette chaîne a passé une sorte de validation et est une chaîne qui peut être testée de cette façon.

Je testerais la nonité avant de me déshabiller. En outre, j'utiliserais le fait que les chaînes vides sont fausses (ou fausses). Cette approche est similaire à StringUtils.isBlank d' Apache ou à Strings.isNullOrEmpty de Guava

Voici ce que j'utiliserais pour tester si une chaîne est soit Aucune OU Vide OU Vide:

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, exactement le contraire pour tester si une chaîne n'est pas None NOR Empty NOR Blank:

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

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 écrit une fois 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

La seule façon vraiment solide de procéder est la suivante:

if "".__eq__(myString):

Toutes les autres solutions ont des problèmes possibles et des cas limites où la vérification peut échouer.

len(myString)==0peut échouer si myStringest un objet d'une classe qui hérite de strla __len__()méthode et la remplace .

De même myString == ""et myString.__eq__("")peut échouer en cas de myStringsubstitution __eq__()et __ne__().

Pour une raison quelconque, "" == myStringil est également dupe en cas de myStringsubstitution __eq__().

myString is ""et "" is myStringsont équivalents. Ils échoueront tous les deux s'il myStringne s'agit pas réellement d'une chaîne mais d'une sous-classe de chaîne (les deux renverront False). De plus, comme il s'agit de contrôles d'identité, la seule raison pour laquelle ils fonctionnent est 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 comparer des chaînes en utilisant soit '= = 'ou' est 'produit parfois un résultat différent? ). Et ""est interné depuis le début dans CPython

Le gros problème avec le contrôle d'identité est que l'internement de chaînes est (pour autant que je puisse trouver) qu'il n'est pas standardisé quelles chaînes sont internées. Cela signifie, théoriquement, ""n'est pas nécessaire interné et cela dépend de la mise en œuvre.

La seule façon de faire ce qui ne peut vraiment pas être dupé est celui mentionné au début: "".__eq__(myString). Étant donné que cela appelle explicitement la __eq__()méthode de la chaîne vide, elle ne peut pas être dupe en remplaçant les méthodes dans myString et fonctionne solidement avec les sous-classes destr .

S'appuyer également sur la fausseté d'une chaîne peut ne pas fonctionner si l'objet remplace sa __bool__() méthode.

Ce n'est pas seulement un travail théorique, mais il pourrait en fait être pertinent dans l'utilisation réelle, car j'ai vu des cadres et des bibliothèques sous-classer stravant et utilisermyString is "" pourrait y retourner une sortie erronée.

De plus, comparer des chaînes en utilisant is en général est un piège assez mauvais car cela fonctionnera correctement parfois, 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. Ce poste est principalement un travail académique.

Testez une chaîne vide ou vide (méthode plus courte):

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

Si vous voulez faire la différence entre des chaînes vides et nulles, je suggère d'utiliser if len(string), sinon, je suggère d'utiliser simplement if stringcomme d'autres l'ont dit. La mise en garde concernant les chaînes pleines d'espaces s'applique toujours, alors n'oubliez pas strip.

if stringname:donne un falselorsque la chaîne est vide. Je suppose que cela ne peut pas être plus simple que cela.

Je trouve que le "hardcoding (sic)" "à chaque fois pour vérifier une chaîne vide n'est pas aussi bon.

Approche de code propre

Faire ceci: foo == ""est une très mauvaise pratique. ""est une valeur magique. Vous ne devriez jamais vérifier les valeurs magiques (plus communément appelées nombres magiques )

Ce que vous devez faire, c'est comparer à un nom de variable descriptive.

Noms de variables descriptives

On peut penser que "empty_string" est un nom de variable descriptive. Ça ne l'est pas .

Avant de partir et empty_string = ""pensez que vous avez un excellent nom de variable à comparer. Ce n'est pas ce que signifie "nom de variable descriptive".

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-il là?
• Pourquoi avez-vous besoin de le vérifier?

Exemple de champ de formulaire simple

Vous créez 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 CSV approfondie

Vous analysez des fichiers CSV et souhaitez que la chaîne vide soit analysée comme None

(Étant donné que CSV est entièrement basé sur du texte, il ne peut pas représenter Nonesans 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 Noneavec 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 assez clair qu'il fait ce qu'il devrait faire.

Comparez cela à

if csvfield == EMPTY_STRING:
    csvfield = None

La première question ici est: pourquoi la chaîne vide mérite-t-elle un traitement spécial?

Cela indiquerait aux futurs codeurs qu'une chaîne vide devrait toujours être considérée comme None.

En effet, il mélange la logique métier (quelle valeur CSV doit être None ) avec l'implémentation du code (à quoi est-ce que nous comparons réellement)

Il doit y avoir une séparation des préoccupations entre les deux.

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

Que dis-tu de ça? Ce n'est peut-être pas "le plus élégant", mais il semble assez complet et clair:

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

Répondant à @ 1290. Désolé, aucun moyen de formater les blocs dans les commentaires. La Nonevaleur n'est pas une chaîne vide en Python, et ni l'un ni l'autre (espaces). La réponse d'Andrew Clark est le bon: 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 ennuis si vous adoptez une définition particulière de ce qu'est une chaîne "vierge". En particulier, le comportement standard est celui qui str(None)produit 'None'une chaîne non vide.

Cependant, si vous devez traiter Noneand (espaces) comme des chaînes "vides", voici une meilleure façon:

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 casser le boolcomportement attendu des chaînes.

Je trouve cela élégant car il s'assure qu'il s'agit d'une chaîne et vérifie sa longueur:

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

Un autre moyen simple pourrait être de définir une fonction simple:

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

not str(myString)

Cette expression est vraie pour les chaînes vides. Les chaînes non vides, les objets None et non-string produiront tous False, avec la mise en garde que les objets peuvent remplacer __str__ pour contrecarrer cette logique en renvoyant une valeur falsifiée.

Vous pouvez jeter un œil à cette Affectation d'une valeur ou d'une chaîne vide 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 à une chaîne vide avec ""la chaîne vide ...

pour ceux qui s'attendent à un comportement comme l'apache StringUtils.isBlank ou Guava Strings.isNullOrEmpty :

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

Lorsque vous lisez un fichier par lignes et que vous voulez déterminer quelle ligne est vide, assurez-vous que vous l'utiliserez .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

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

Si vous utilisez simplement

not var1 

il n'est pas possible de différencier une variable booléenne Falsed'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

Dans le cas où cela serait utile à quelqu'un, voici une fonction rapide que j'ai construite pour remplacer les chaînes vides par des N / A dans des 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 publier des listes de listes dans une base de données mysql qui n'accepte pas les blancs pour certains champs (champs marqués comme NN dans le schéma. Dans mon cas, cela était dû à une clé primaire composite).

J'ai fait quelques expériences avec des chaînes comme '', '', '\ n', etc. Je veux que isNotWhitespace soit True si et seulement si la variable foo est une chaîne avec au moins un caractère non blanc. J'utilise Python 3.6. Voici ce que j'ai fini avec:

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

Enveloppez-le dans une définition de méthode si vous le souhaitez.

Comme prmatta l'a indiqué ci-dessus, mais avec erreur.

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