O Python tem algo como uma variável de cadeia vazia, onde você pode fazer:

if myString == string.empty:

Independentemente disso, qual é a maneira mais elegante de verificar valores de string vazios? Acho sempre difícil codificar ""sempre que checar uma string vazia não é tão boa.

Seqüências de caracteres vazias são "falsas", o que significa que são consideradas falsas em um contexto booleano; portanto, você pode fazer isso:

if not myString:

Essa é a maneira preferida se você souber que sua variável é uma sequência. Se a sua variável também puder ser de outro tipo, você deve usar myString == "". Consulte a documentação em Truth Value Testing para outros valores que são falsos em contextos booleanos.

No PEP 8 , na seção "Recomendações de programação" :

Para seqüências (strings, listas, tuplas), use o fato de que sequências vazias são falsas.

Então você deve usar:

if not some_string:

ou:

if some_string:

Apenas para esclarecer, as seqüências são avaliadas para Falseou Trueem um contexto booleano se estiverem vazias ou não. Eles não são iguais a Falseou True.

A maneira mais elegante provavelmente seria simplesmente verificar se é verdadeiro ou falso, por exemplo:

if not my_string:

No entanto, convém remover o espaço em branco porque:

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

No entanto, você provavelmente deve ser um pouco mais explícito, a menos que saiba com certeza que essa sequência passou por algum tipo de validação e é uma sequência que pode ser testada dessa maneira.

Eu testaria a não-união antes de me despir. Além disso, eu usaria o fato de que cadeias vazias são falsas (ou falsas). Essa abordagem é semelhante à StringUtils.isBlank do Apache ou à Strings.isNullOrEmpty do Guava

Isto é o que eu usaria para testar se uma string é None OR Empty OR Blank:

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, exatamente o oposto para testar se uma string não é 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

Formas mais concisas do código acima:

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

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

Certa vez, escrevi algo semelhante à resposta de Bartek e o javascript inspirou:

def is_not_blank(s):
    return bool(s and s.strip())

Teste:

print is_not_blank("")    # False
print is_not_blank("   ") # False
print is_not_blank("ok")  # True
print is_not_blank(None)  # False

A única maneira realmente sólida de fazer isso é a seguinte:

if "".__eq__(myString):

Todas as outras soluções têm possíveis problemas e casos extremos onde a verificação pode falhar.

len(myString)==0pode falhar se myStringfor um objeto de uma classe que herda stre substitui o __len__()método

Da mesma forma myString == ""e myString.__eq__("")pode falhar se myStringsubstituir __eq__()e __ne__().

Por alguma razão, "" == myStringtambém é enganado se for myStringsubstituído __eq__().

myString is ""e "" is myStringsão equivalentes. Ambos falharão se myStringnão for realmente uma string, mas uma subclasse de string (ambos retornarão False). Além disso, como são verificações de identidade, a única razão pela qual eles funcionam é porque o Python usa String Pooling (também chamado String Internment), que usa a mesma instância de uma string se for internada (veja aqui: Por que comparar cadeias usando '= = 'ou' é 'às vezes produz um resultado diferente? ). E"" é internado desde o início no CPython

O grande problema com a verificação de identidade é que o String Internment é (até onde eu pude encontrar) que não está padronizado quais strings são internadas. Isso significa que, teoricamente"" não é necessário internado e isso depende da implementação.

A única maneira de fazer isso que realmente não pode ser enganado é o mencionado no início: "".__eq__(myString). Como isso chama explicitamente o __eq__()método da string vazia, não pode ser enganado substituindo nenhum método em myString e trabalhando solidamente com subclasses de str.

Também depender da falsidade de uma string pode não funcionar se o objeto substituir o __bool__()método.

Este não é apenas um trabalho teórico, mas pode realmente ser relevante em uso real, já que eu vi estruturas e bibliotecas subclassificando strantes e usando, myString is ""podendo retornar uma saída errada lá.

Além disso, comparar seqüências de caracteres usando isem geral é uma armadilha bastante ruim, pois funcionará corretamente algumas vezes, mas não em outras, porque o pool de strings segue regras bastante estranhas.

Dito isto, na maioria dos casos, todas as soluções mencionadas funcionarão corretamente. Este post é principalmente um trabalho acadêmico.

Teste a cadeia vazia ou em branco (maneira mais curta):

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

Se você quiser diferenciar entre cadeias vazias e nulas, sugiro usar if len(string), caso contrário, sugiro usar simplesmente if stringcomo já foi dito. A ressalva sobre strings cheias de espaço em branco ainda se aplica, portanto, não esqueça strip.

if stringname:dá a falsequando a string está vazia. Eu acho que não pode ser mais simples que isso.

Eu acho que "" (sic) codificado permanentemente sempre que checar uma string vazia não é tão bom.

Abordagem de código limpo

Fazer isso: foo == ""é uma prática muito ruim. ""é um valor mágico. Você nunca deve verificar valores mágicos (mais conhecidos como números mágicos )

O que você deve fazer é comparar com um nome descritivo de variável.

Nomes de variáveis ​​descritivos

Pode-se pensar que "empty_string" é um nome de variável descritivo. Não é .

Antes de você ir e fazer empty_string = ""e achar que tem um ótimo nome de variável para comparar. Não é isso que "nome descritivo da variável" significa.

Um bom nome de variável descritiva é baseado em seu contexto. Você tem que pensar sobre o que a cadeia vazia é .

• De onde isso vem.
• Por que está aí?
• Por que você precisa verificar isso?

Exemplo de campo de formulário simples

Você está criando um formulário em que um usuário pode inserir valores. Você deseja verificar se o usuário escreveu algo ou não.

Um bom nome de variável pode ser not_filled_in

Isso torna o código muito legível

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

Exemplo completo de análise de CSV

Você está analisando arquivos CSV e deseja que a sequência vazia seja analisada como None

Como o CSV é inteiramente baseado em texto, ele não pode ser representado Nonesem o uso de palavras-chave predefinidas.

Um bom nome de variável pode ser CSV_NONE

Isso facilita a alteração e a adaptação do código se você tiver um novo arquivo CSV que represente Noneoutra string que não""

if csvfield == CSV_NONE:
    csvfield = None

Não há dúvidas sobre se esse trecho de código está correto. É bastante claro que ele faz o que deve fazer.

Compare isso com

if csvfield == EMPTY_STRING:
    csvfield = None

A primeira pergunta aqui é: por que a string vazia merece tratamento especial?

Isso diria aos futuros codificadores que uma string vazia sempre deve ser considerada como None.

Isso ocorre porque ele combina a lógica de negócios (que valor CSV deve ser None ) com a implementação do código (com o que estamos realmente comparando)

É preciso haver uma separação de preocupações entre os dois.

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

Que tal agora? Talvez não seja "o mais elegante", mas parece bastante completo e claro:

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

Respondendo a @ 1290. Desculpe, não há como formatar blocos nos comentários. O Nonevalor não é uma string vazia no Python e nem é (espaços). A resposta de Andrew Clark é a correta: if not myString. A resposta de @rouble é específica do aplicativo e não responde à pergunta do OP. Você terá problemas se adotar uma definição peculiar do que é uma string "em branco". Em particular, o comportamento padrão é que str(None)produz'None' uma string não em branco.

No entanto, se você deve tratar Nonee (espaços) como seqüências de caracteres "em branco", aqui está uma maneira melhor:

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

Exemplos:

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

Atende aos requisitos @rouble, sem quebrar o boolcomportamento esperado das strings.

Acho isso elegante, pois garante que seja uma string e verifique seu comprimento:

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

Outra maneira fácil seria definir uma função simples:

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

not str(myString)

Essa expressão é verdadeira para cadeias vazias. Seqüências de caracteres não vazias, Nenhum e objetos que não sejam de seqüência de caracteres produzirão Falso, com a ressalva de que os objetos podem substituir __str__ para impedir essa lógica, retornando um valor falso.

Você pode dar uma olhada neste Atribuindo valor ou sequência vazia em Python

Trata-se de comparar cadeias que estão vazias. Então, em vez de testar o vazio not, você pode testar se sua string é igual a uma string vazia com ""a string vazia ...

para quem espera um comportamento como o apache StringUtils.isBlank ou Guava Strings.isNullOrEmpty :

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

Quando você estiver lendo o arquivo por linhas e quiser determinar qual linha está vazia, verifique se você usará .strip(), pois há um novo caractere de linha na linha "vazia":

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 você apenas usar

not var1 

não é possível diferenciar uma variável que é booleana Falsede uma string vazia '':

var1 = ''
not var1
> True

var1 = False
not var1
> True

No entanto, se você adicionar uma condição simples ao seu script, a diferença será feita:

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

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

Caso isso seja útil para alguém, aqui está uma função rápida criada para substituir cadeias de caracteres em branco por N / A em listas de listas (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

Isso é útil para postar listas de listas em um banco de dados mysql que não aceita espaços em branco para determinados campos (campos marcados como NN no esquema. No meu caso, isso ocorreu devido a uma chave primária composta).

Eu fiz algumas experiências com seqüências de caracteres como '', '', '\ n' etc. etc. Quero que isNotWhitespace seja True se e somente se a variável foo for uma string com pelo menos um caractere que não seja um espaço em branco. Estou usando o Python 3.6. Aqui está o que eu acabei com:

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

Embrulhe isso em uma definição de método, se desejar.

Como prmatta postado acima, mas com erro.

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