Пустые строки являются "falsy", что означает, что они считаются ложными в булевом контексте, поэтому вы можете просто сделать это:

if not myString:

Этот способ предпочтителен, если вы знаете, что ваша переменная является строкой. Если ваша переменная может быть и другого типа, то вам следует использовать myString == "". О других значениях, которые являются ложными в булевых контекстах, см. документацию по Проверке истинности значения.

Из PEP 8, в разделе "Рекомендации по программированию":

Для последовательностей (строк, списков, кортежей) используйте тот факт, что пустые последовательности ложны.

Поэтому вы должны использовать:

if not some_string:

или:

if some_string:

Чтобы уточнить, последовательности оцениваются в False или True в булевом контексте, если они пусты или нет. Они не равны False или True.

Наиболее элегантным способом, вероятно, будет просто проверить, является ли он истинным или ложным, например:

if not my_string:

Однако, возможно, вы захотите убрать пробелы, потому что:

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

Однако, вероятно, вам следует быть немного более явным, если только вы не знаете наверняка, что эта строка прошла некоторую проверку и может быть проверена таким образом.

Я бы проверил небытие перед тем, как раздеться. Кроме того, я бы использовал тот факт, что пустые строки являются ложными (или фальси). Этот подход аналогичен StringUtils.isBlank Apache или Strings.isNullOrEmpty Гуавы

Это то, что я бы использовал для проверки, если строка либо None ИЛИ Empty ИЛИ 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

И полная противоположность тесту, если строка не 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

Более краткие формы вышеуказанного кода:

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

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

Однажды я написал нечто похожее на ответ Бартека и вдохновленный JavaScript:

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

Тест:

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

Единственный действительно надежный способ сделать это - следующее:

if "".__eq__(myString):

Все другие решения имеют возможные проблемы и крайние случаи, когда проверка может не пройти.

len (myString) == 0 может завершиться ошибкой, если myString является объектом класса, который наследует от str и переопределяет метод __len__ ().

Аналогично myString == ""и myString.__eq__ ("")может завершиться ошибкой, если myString переопределяет __eq__ () и __ne__ ().

По какой-то причине " "== myString также одурачен, если myString переопределяет __eq__ ().

myString is ""и " "myString эквивалентны. Они оба потерпят неудачу, если myString на самом деле не строка, а подкласс строки (оба вернут False). Кроме того, поскольку они являются проверками личности, единственная причина, по которой они работают, заключается в том, что Python использует String Pooling (также называемый String Internment), который использует тот же экземпляр строки, если она интернирована (см. Здесь: https://stackoverflow.com/questions / 1504717 / why-comparing-strings-using-using-y-is-is-is-is-is-is-is-is-a-differe). И " " интернирован с самого начала в CPython

Большая проблема с проверкой личности заключается в том, что String Internment (насколько я мог судить) не стандартизирует, какие строки интернированы. Это означает, что теоретически `" "" не является необходимым интернированным, и это зависит от реализации.

Единственный способ сделать это, который действительно нельзя одурачить, - это упомянутый в начале: " ".__eq__ (myString). Поскольку это явно вызывает метод __eq__ () пустой строки, его нельзя одурачить, переопределив любые методы в myString и прочно работает с подклассами str.

Также полагаться на ложность строки может не сработать, если объект переопределяет метод __bool__ ().

Это не только теоретическая работа, но на самом деле может иметь отношение к реальному использованию, поскольку я видел, что фреймворки и библиотеки, подклассифицирующие str до и использующие `myString is "", могут вернуть туда неправильный вывод.

Кроме того, сравнение строк с использованием is в целом является довольно злой ловушкой, поскольку иногда она будет работать правильно, но не в другое время, поскольку объединение строк следует довольно странным правилам.

Тем не менее, в большинстве случаев все упомянутые решения будут работать правильно. Это пост в основном академическая работа.

Проверьте пустую или пустую строку (более короткий путь):

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

Если вы хотите различать пустые и нулевые строки, я бы предложил использовать if len (string), в противном случае я бы предложил использовать просто if string, как говорили другие. Предостережение о струнах, полных пробелов, все еще применимо, поэтому не забудьте «полосать».

if stringname:имеетсяfalse, когда строка пуста. Я думаю, это не может быть проще, чем это.

Я нахожу hardcoding (sic) "" каждый раз для проверки пустой строки не так хорошо.

Чистый подход к коду

Делать это: foo == ""это очень плохая практика. " " - магическая ценность. Вы никогда не должны проверять магические значения (более известные как магические числа)

Что вам нужно сделать, это сравнить с именем описательной переменной.

Описательные имена переменных

Можно подумать, что «empty_string» - это описательное имя переменной. Это не .

Прежде чем идти и делать empty_string = ""и думать, что у вас есть отличное имя переменной для сравнения. Это не то, что означает «имя описательной переменной».

Хорошее описательное имя переменной основано на ее контексте. Вы должны подумать о том, что пустая строка есть .

• Откуда это.
• Почему это там.
• Зачем тебе это проверять.

Простой пример поля формы

Вы создаете форму, в которой пользователь может вводить значения. Вы хотите проверить, написал ли пользователь что-то или нет.

Хорошее имя переменной может быть not_filled_in

Это делает код очень читабельным

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

Пример тщательного анализа CSV

Вы анализируете файлы CSV и хотите, чтобы пустая строка была проанализирована как None

(Поскольку CSV полностью основан на тексте, он не может представлять «Нет» без использования предопределенных ключевых слов)

Хорошее имя переменной может быть CSV_NONE

Это позволяет легко изменять и адаптировать код, если у вас есть новый файл CSV, который представляет «Нет» с другой строкой, чем «»

if csvfield == CSV_NONE:
    csvfield = None

Нет вопросов о том, является ли этот фрагмент кода правильным. Совершенно очевидно, что он делает то, что должен делать.

Сравните это с

if csvfield == EMPTY_STRING:
    csvfield = None

Первый вопрос здесь: почему пустая строка заслуживает особого отношения??

Это скажет будущим кодировщикам, что пустую строку всегда следует рассматривать как «Нет».

Это связано с тем, что он смешивает бизнес-логику (какое значение CSV должно быть «Нет») с реализацией кода (с чем мы на самом деле сравниваем)

Между ними должно быть разделение беспокойства.

Как насчет этого? Возможно, это не «самый элегантный», но кажется довольно полным и ясным:

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

Отвечая на @ 1290. Извините, нет способа форматировать блоки в комментариях. Значение None не является пустой строкой в Python, равно как и (пробелы). Ответ Эндрю Кларка правильный: «если не myString». Ответ от @rouble зависит от приложения и не отвечает на вопрос OP. У вас будут проблемы, если вы примете своеобразное определение того, что такое «пустая» строка. В частности, стандартное поведение заключается в том, что str (None)производит'None', непустую строку.

Однако, если вы должны рассматривать «Нет» и (пробелы) как «пустые» строки, вот лучший способ:

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

Примеры:

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

Соответствует требованиям @rouble, не нарушая ожидаемого поведения строк bool.

Я нахожу это элегантным, так как он гарантирует, что это строка, и проверяет ее длину:

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

Другим простым способом может быть определение простой функции:

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

Если вы просто используете

not var1 

невозможно отличить переменную, которая является логической False, от пустой строки ':

var1 = ''
not var1
> True

var1 = False
not var1
> True

Однако, если вы добавите простое условие в свой скрипт, разница будет сделана:

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

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

Если это кому-то полезно, вот быстрая функция, которую я создал для замены пустых строк на N / A в списках списков (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

Это полезно для публикации списков списков в базе данных mysql, которая не принимает пробелы для определенных полей (поля, помеченные как NN в схеме. в моем случае это было связано с составным первичным ключом).

для тех, кто ожидает такого поведения, как apache StringUtils.isBlank или Guava Strings.isNullOrEmpty:

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

Когда вы читаете файл по строкам и хотите определить, какая строка пуста, убедитесь, что вы будете использовать .strip (), потому что в «пустой» строке есть новый символ строки:

lines = open("my_file.log", "r").readlines()

for line in lines:
    if not line.strip():
        continue

    # your code for non-empty lines