Есть ли в Python что-то вроде пустой строковой переменной, где можно сделать:
if myString == string.empty:
Независимо от этого, какой самый элегантный способ проверки пустой строки? Я считаю, что жесткое кодирование `""" каждый раз для проверки пустой строки не так хорошо.
Пустые строки являются "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
, как говорили другие. Предостережение о струнах, полных пробелов, все еще применимо, поэтому не забудьте «полосать».
a = ''
b = ' '
a.isspace() -> False
b.isspace() -> True
Я нахожу hardcoding (sic) "" каждый раз для проверки пустой строки не так хорошо.
Делать это: foo == ""
это очень плохая практика. " "
- магическая ценность. Вы никогда не должны проверять магические значения (более известные как магические числа)
Что вам нужно сделать, это сравнить с именем описательной переменной.
Можно подумать, что «empty_string» - это описательное имя переменной. Это не .
Прежде чем идти и делать empty_string = ""
и думать, что у вас есть отличное имя переменной для сравнения. Это не то, что означает «имя описательной переменной».
Хорошее описательное имя переменной основано на ее контексте. Вы должны подумать о том, что пустая строка есть .
Вы создаете форму, в которой пользователь может вводить значения. Вы хотите проверить, написал ли пользователь что-то или нет.
Хорошее имя переменной может быть not_filled_in
Это делает код очень читабельным
if formfields.name == not_filled_in:
raise ValueError("We need your name")
Вы анализируете файлы 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 isStringEmpty(inputString):
if len(inputString) == 0:
return True
else:
return False
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 в схеме. в моем случае это было связано с составным первичным ключом).
для тех, кто ожидает такого поведения, как 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