Есть ли в Python что-то вроде пустой строковой переменной, где вы можете сделать:

if myString == string.empty:

Независимо от того, какой самый элегантный способ проверить наличие пустых строковых значений? Я нахожу жесткое кодирование ""каждый раз для проверки пустой строки не таким хорошим.

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

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

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

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

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

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

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

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 ""и "" is myStringэквивалентны. Они оба потерпят неудачу, если на myStringсамом деле это не строка, а подкласс строки (оба вернутся False). Кроме того, поскольку они являются проверками идентичности, единственная причина, по которой они работают, заключается в том, что Python использует String Pooling (также называемый String Internment), который использует один и тот же экземпляр строки, если он интернирован (см. Здесь: Почему при сравнении строк используется либо '= = 'или' is 'иногда дают другой результат? ). И ""стажируется с самого начала в 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как говорили другие. Тем не менее, предостережение о строках, заполненных пробелами, остается в силе, так что не забывайте strip.

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

Я нахожу жесткое кодирование (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 полностью основан на тексте, он не может быть представлен Noneбез использования предопределенных ключевых слов)

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

Это облегчает изменение и адаптацию кода, если у вас есть новый файл CSV, представляющий Noneдругую строку, чем""

if csvfield == CSV_NONE:
    csvfield = None

Там нет вопросов о том, если этот кусок кода является правильным. Довольно ясно, что он делает то, что должен делать.

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

if csvfield == EMPTY_STRING:
    csvfield = None

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

Это скажет будущим кодировщикам, что пустая строка всегда должна рассматриваться как None.

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

Должно быть разделение проблем между ними.

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

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

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

Отвечая на @ 1290. Извините, нет возможности форматировать блоки в комментариях. NoneЗначение не пустая строка в Python, и ни один (пространства). Ответ от Эндрю Кларка правильный if not myString. Ответ @rouble зависит от приложения и не отвечает на вопрос ОП. У вас будут проблемы, если вы примете своеобразное определение «пустой» строки. В частности, стандартное поведение является то , что str(None)производит '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 str(myString)

Это выражение верно для пустых строк. Непустые строки, None и не строковые объекты будут создавать False с оговоркой, что объекты могут переопределять __str__, чтобы помешать этой логике, возвращая ложное значение.

Вы можете взглянуть на это Назначение пустого значения или строки в Python

Речь идет о сравнении пустых строк. Таким образом, вместо проверки на пустоту not, вы можете проверить, равна ли ваша строка пустой строке с ""пустой строкой ...

для тех, кто ожидает такого поведения, как 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

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

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

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 в схеме. В моем случае это произошло из-за составного первичного ключа).

Я провел некоторые эксперименты со строками, такими как '', '', '\ n' и т. Д. Я хочу, чтобы isNotWhitespace был True, если и только если переменная foo является строкой, по крайней мере, с одним непробельным символом. Я использую Python 3.6. Вот чем я закончил:

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

Оберните это в определение метода, если хотите.

Как написано выше, но с ошибкой.

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