Какая польза от «assert» в Python?

Ответы:

1085

assertУтверждение существует практически в каждом языке программирования. Это помогает обнаруживать проблемы в начале вашей программы, где причина ясна, а не позже, как побочный эффект какой-либо другой операции.

Когда вы делаете ...

assert condition

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

В Python это примерно эквивалентно этому:

if not condition:
    raise AssertionError()

Попробуйте это в оболочке Python:

>>> assert True # nothing happens
>>> assert False
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError

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

Чтобы напечатать сообщение, если утверждение не выполнено:

assert False, "Oh no! This assertion failed!"

Вы не использовать скобки для вызова assertкак функции. Это утверждение. Если вы это сделаете, assert(condition, message)вы будете запускать assertс (condition, message)кортежем в качестве первого параметра.

Что касается их отключения, то при работе pythonв оптимизированном режиме, где __debug__есть False, утверждения assert будут игнорироваться. Просто передайте -Oфлаг:

python -O script.py

Смотрите здесь для соответствующей документации.

slezica
источник
92
Nit: assert - это утверждение, а не функция. И в отличие от печати , в Python 3 это все еще утверждение .
Боб Стейн
2
@Chaine assert означает «убедитесь, что * что-то« истинно ». Поэтому assert a == 3 будет гарантировать, что a равно 3; если a не равно 3 (то есть a == 3 равно False), тогда оно будет поднять ошибку
Муравей
5
Если я могу просто использовать if not condition: raise AssertError(), почему я должен использовать assert? Существуют ли условия, при которых утверждение лучше, чем просто более короткая форма if not conditionзаявления?
alpha_989
6
@ alpha_989 a) это короче и более читабельно, b) вы можете отключить операторы assert при запуске интерпретатора (не так с руководством if). Прочитайте документы для получения дополнительной информации :)
slezica
9
совершенно не могу понять, как этот ответ набирает столько голосов, на самом деле другие тоже отвечают. Вопрос в том, «Как использовать« assert »в Python?», поэтому он задает вопрос: когда использовать, или, точнее, каков сценарий использования assert, но после прочтения всех ответов я полностью ничего не получил!
lnshi
424

Остерегайтесь скобок. Как уже было отмечено выше, в Python 3, assertпо - прежнему является утверждение , поэтому по аналогии с print(..), можно экстраполировать то же самое assert(..)или , raise(..)но вы не должны.

Это важно, потому что:

assert(2 + 2 == 5, "Houston we've got a problem")

не будет работать, в отличие от

assert 2 + 2 == 5, "Houston we've got a problem"

Причина, по которой первый не будет работать, состоит в том, что он bool( (False, "Houston we've got a problem") )оценивается как True.

В заявлении assert(False)это просто лишние круглые скобки False, которые оценивают их содержимое. Но с assert(False,)круглыми скобками теперь есть кортеж, а непустой кортеж оценивается Trueв логическом контексте.

Евгений Сергеев
источник
18
Я пришел сюда в поисках точной информации о паренсе и последующем сообщении. Спасибо.
Супербек
6
Но assert (2 + 2 = 5), "Houston we've got a problem"должно быть хорошо, да?
SherylHohman
4
@SherylHohman, вы также можете попробовать запустить его самостоятельно и посмотреть, работает ли он или нет
DarkCygnus
2
Не забывайте, что люди часто используют круглые скобки для неявного продолжения строки в соответствии с PEP 8. Также не забывайте, что кортежи определяются не круглыми скобками, а наличием запятой (кортежи не имеют ничего общего с паренами, кроме как в целях приоритет оператора).
Cowbert
4
assert (2 + 2 = 5), "Houston we've got a problem"не сработает ... но это не имеет ничего общего с утверждением assert, что нормально. Ваше состояние не будет работать, потому что это не условие. Пропустить секунду =.
n1k31t4
133

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

if __debug__:
   if not expression: raise AssertionError

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

Нил Васс
источник
Означает ли это, что если определенная переменная или правильный ввод (в соответствии с контрактом, по которому написана программа) может привести к сбою программы при ее запуске пользователем (при условии, что при запуске пользователя используется флаг -O программа), вы должны вместо этого использовать if Not Error: raise Exception(“ this is a error”)? Таким образом, программа все равно покажет источник ошибки, когда пользователь ее запустит ..
alpha_989
С другой стороны, если вы ожидаете, что программа может выдать ошибку из-за неправильной логики / реализации кода (но не из-за ввода, соответствующего договору с пользователем программы), вам следует использовать assertоператор? Здесь предполагается, что когда программа выпущена для конечного пользователя, вы используете флаг -O, таким образом, предполагая, что все ошибки были удалены. Следовательно, любая ошибка или сбой программы происходят из-за ввода в программу, которая действительна в соответствии с контрактом, но не может быть обработана программой. Так что это должно предупредить пользователя как такового.
alpha_989
@ alpha_989 это точно. Мне нравится думать об утверждениях как о проверках работоспособности, которые помогают вам как разработчику убедиться, что то, что вы считаете правдой, действительно верно во время разработки.
Кристофер Шроба
52

Цель утверждения в Python - информировать разработчиков о неисправимых ошибках в программе.

Утверждения не предназначены для оповещения об ожидаемых ошибках, например, «файл не найден», где пользователь может предпринять корректирующие действия (или просто повторить попытку).

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

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

Вот краткое изложение учебника по утверждениям Python, которые я написал:

Инструкция assert Python является средством отладки, а не механизмом обработки ошибок во время выполнения. Цель использования утверждений состоит в том, чтобы позволить разработчикам быстрее находить основную причину ошибки. Ошибка утверждения никогда не должна возникать, если в вашей программе нет ошибки.

dbader
источник
Спасибо за статью. Очень полезно понять assertзаявление и когда использовать это. Я пытаюсь понять ряд терминов, которые вы ввели в статье.
alpha_989
Я думал, что я опубликую комментарии здесь, чтобы гораздо больше людей могли получить пользу от разъяснений. Извините, если вопросы слишком наивные.
alpha_989
В своем блоге, на который вы ссылаетесь, вы приводите пример, в котором вы упомянули, что `assert 0 <= цена <= product ['price']` является правильным, но с использованием `assert user.is_admin (), 'должны иметь права администратора для удаления '`и assert store.product_exists(product_id), 'Unknown product id'это не очень хорошая практика, потому что если отладка отключена, то userдаже если нет admin, удастся удалить продукт. Считаете ли вы , assert user.is_admin()как unrecoverableошибка? Почему это не так self-check?
alpha_989
Если вы считаете, что 'user.is_admin () `является пользовательским вводом и, следовательно, не должны использоваться в assert statement, не может ли priceтакже считаться пользовательским вводом? Почему вы рассматриваете assert user.is_admin()как проверку данных, а не как assert price?
alpha_989
1
@LaryxDecidua Нет, вы можете просто прочитать его на моем сайте, учебник общедоступен. Просто нажмите Escape или нажмите маленький символ «х», если вы не заинтересованы в рассылке. Надеюсь, что это поможет :-)
dbader
51

Другие уже дали вам ссылки на документацию.

Вы можете попробовать следующее в интерактивной оболочке:

>>> assert 5 > 2
>>> assert 2 > 5
Traceback (most recent call last):
  File "<string>", line 1, in <fragment>
builtins.AssertionError:

Первое утверждение ничего не делает, а второе вызывает исключение. Это первая подсказка: утверждения полезны для проверки условий, которые должны быть истинными в данной позиции вашего кода (обычно начало (предусловия) и конец функции (постусловия)).

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

http://en.wikipedia.org/wiki/Design_by_contract .

Baltasarq
источник
Значит ли это, что мы можем проверить код в ситуации, подобной assert (2> 5), и вызвать ошибку, иначе продолжить?
20
Потерять паренсы, отстаивать не функция.
pillmuncher
2
Потеря паренса важнее, чем кажется. Смотри ниже .
Евгений Сергеев
6
Фактически, Assert восходит (задолго до «контрактов») к Тьюрингу, когда он написал одну из самых ранних работ о том, как программисты могут решить довольно сложную задачу создания правильных программ. Нахождение этой статьи оставлено читателю в качестве упражнения, поскольку все программисты могут извлечь пользу из знакомства с его работой. :-) turingarchive.org
Рон Берк
17

Из документов:

Assert statements are a convenient way to insert debugging assertions into a program

Здесь вы можете прочитать больше: http://docs.python.org/release/2.5.2/ref/assert.html

gruszczy
источник
Мне нравится этот комментарий, так как он просто объясняет, что это очень просто. мой вопрос "если я написал правильный модульный тест, зачем мне нужно утверждение"? этот материал не работает в любом случае.
DTC
17

Утверждение assert имеет две формы.

Простая форма, assert <expression>эквивалентна

if __debug__:
    if not <expression>: raise AssertionError

Расширенная форма, assert <expression1>, <expression2>эквивалентна

if __debug__:
    if not <expression1>: raise AssertionError, <expression2>
Богдана
источник
16

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

>>> number = input('Enter a positive number:')
Enter a positive number:-1
>>> assert (number > 0), 'Only positive numbers are allowed!'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError: Only positive numbers are allowed!
>>> 
Джейкоб Абрахам
источник
1
Кроме того, утверждения могут часто использоваться в программах модульного тестирования. stackoverflow.com/questions/1383/what-is-unit-testing
Панофиш
7

Вот простой пример, сохраните это в файле (скажем, b.py)

def chkassert(num):
    assert type(num) == int


chkassert('a')

и результат, когда $python b.py

Traceback (most recent call last):
  File "b.py", line 5, in <module>
    chkassert('a')
  File "b.py", line 2, in chkassert
    assert type(num) == int
AssertionError
Гаурав Агарвал
источник
6

если оператор после assert равен true, то программа продолжается, но если оператор после assert равен false, программа выдает ошибку. Просто как тот.

например:

assert 1>0   #normal execution
assert 0>1   #Traceback (most recent call last):
             #File "<pyshell#11>", line 1, in <module>
             #assert 0>1
             #AssertionError
abe312
источник
4

assertУтверждение существует практически в каждом языке программирования. Это помогает обнаруживать проблемы в начале вашей программы, где причина ясна, а не позже, как побочный эффект какой-либо другой операции. Они всегда ожидаютTrue условия.

Когда вы делаете что-то вроде:

assert condition

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

В Python assertвыражение эквивалентно:

if __debug__:
    if not <expression>: raise AssertionError

Вы можете использовать расширенное выражение для передачи необязательного сообщения :

if __debug__:
    if not (expression_1): raise AssertionError(expression_2)

Попробуйте это в интерпретаторе Python:

>>> assert True # Nothing happens because the condition returns a True value.
>>> assert False # A traceback is triggered because this evaluation did not yield an expected value.
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError

Есть некоторые предостережения видели перед их использованием в основном для тех , кто посчитает переключение между assertи ifотчетностью. Целью assertявляется использование в случаях, когда программа проверяет условие и возвращает значение, которое должно немедленно остановить программу, вместо того, чтобы использовать какой-либо альтернативный способ обойти ошибку:

1. Скобки

Как вы могли заметить, в этом assertутверждении используются два условия. Следовательно, не используйте скобки, чтобы использовать их как очевидный совет. Если вы делаете такие как:

assert (condition, message)

Пример:

>>> assert (1==2, 1==1)
<stdin>:1: SyntaxWarning: assertion is always true, perhaps remove parentheses?

Вы будете запускать assertс, (condition, message)который представляет кортеж в качестве первого параметра, и это происходит потому, что непустой кортеж в Python всегдаTrue . Тем не менее, вы можете сделать отдельно без проблем:

assert (condition), "message"

Пример:

>>> assert (1==2), ("This condition returns a %s value.") % "False"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError: This condition returns a False value.

2. Цель отладки

Если вам интересно, когда использовать assertзаявление. Возьмите пример, используемый в реальной жизни:

* Когда ваша программа стремится контролировать каждый параметр, введенный пользователем или что-то еще:

def loremipsum(**kwargs):
    kwargs.pop('bar') # return 0 if "bar" isn't in parameter
    kwargs.setdefault('foo', type(self)) # returns `type(self)` value by default
    assert (len(kwargs) == 0), "unrecognized parameter passed in %s" % ', '.join(kwargs.keys())

* Другой случай по математике, когда 0 или не положительный, как коэффициент или константа для определенного уравнения:

def discount(item, percent):
    price = int(item['price'] * (1.0 - percent))
    print(price)
    assert (0 <= price <= item['price']),\
            "Discounted prices cannot be lower than 0 "\
            "and they cannot be higher than the original price."

    return price

* или даже простой пример логической реализации:

def true(a, b):
    assert (a == b), "False"
    return 1

def false(a, b):
    assert (a != b), "True"
    return 0

3. Обработка данных или проверка данных

Крайне важно не полагаться на assertоператор для выполнения обработки данных или проверки данных, поскольку этот оператор можно отключить при инициализации Python с помощью -Oили -OOфлага (означающего соответственно значения 1, 2 и 0 (по умолчанию)) или PYTHONOPTIMIZEпеременной среды ,

Значение 1:

* утверждения отключены;

* файлы байт-кода генерируются с использованием .pyoрасширения вместо .pyc;

* sys.flags.optimizeустановлено в 1 ( True);

* и, __debug__установлен в False;

Значение 2: отключает еще один материал

* строки документов отключены;

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

убийца
источник
3

Как кратко изложено на C2 Wiki :

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

Вы можете использовать assertоператор для документирования вашего понимания кода в конкретной точке программы. Например, вы можете задокументировать предположения или гарантии относительно входных данных (предварительных условий), состояния программы (инвариантов) или выходных данных (постусловий).

Если ваше утверждение когда-либо окажется неудачным, это предупреждение для вас (или вашего преемника), что вы неправильно поняли программу, когда вы ее написали, и что она, вероятно, содержит ошибку.

Для получения дополнительной информации у Джона Регера есть замечательное сообщение в блоге об использовании утверждений , которое также применимо к assertвыражению Python .

avandeursen
источник
2

Если вы хотите точно знать, что зарезервированная функция делает в python, введите help(enter_keyword)

Убедитесь, что при вводе зарезервированного ключевого слова вы вводите его в виде строки.

ytpillai
источник
2

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

Допустим, есть функция для расчета цены товара после скидки:

def calculate_discount(price, discount):
    discounted_price = price - [discount*price]
    assert 0 <= discounted_price <= price
    return discounted_price

Здесь discounts_price никогда не может быть меньше 0 и больше фактической цены. Таким образом, в случае нарушения вышеуказанного условия assert вызывает ошибку утверждения, которая помогает разработчику определить, что произошло нечто невозможное.

Надеюсь, поможет :)

Нитиш Чаухан
источник
2
assertполезен в контексте отладки, но не следует полагаться вне контекста отладки.
FluxIX,
2

Мое краткое объяснение:

  • assertВозникает, AssertionErrorесли выражение ложно, в противном случае просто продолжает код, и если есть запятая, какой бы она ни была AssertionError: whatever after comma, и код будет выглядеть так:raise AssertionError(whatever after comma)

Связанный учебник об этом:

https://www.tutorialspoint.com/python/assertions_in_python.htm

U10-Forward
источник
Ответ предоставляет, как использовать assert, но не когда использовать (или не использовать) assert; также отмечая, что assertможно отключить, если__debug__ это Falseбыло бы полезно.
FluxIX,
1

В Pycharm, если вы используете assertвместе с isinstanceобъявлением типа объекта, он позволит вам получить доступ к методам и атрибутам родительского объекта во время кодирования, он автоматически завершится автоматически.

Например, скажем self.object1.object2, это MyClassобъект.

import MyClasss

def code_it(self):
    testObject = self.object1.object2 # at this point, program doesn't know that testObject  is a MyClass object yet
    assert isinstance(testObject , MyClasss) # now the program knows testObject is a MyClass object
    testObject.do_it() # from this point on, PyCharm will be able to auto-complete when you are working on testObject
alwbtc
источник
0

Как написано в других ответах, assert операторы используются для проверки состояния программы на данный момент.

Я не буду повторять то, что было сказано о связанном сообщении, скобках или -Oопции и __debug__константе. Проверьте также документ для получения информации из первых рук. Я сосредоточусь на вашем вопросе: какая польза assert? Точнее, когда (а когда нет) следует использовать assert?

Операторы assertполезны для отладки программы, но не рекомендуется проверять ввод пользователя. Я использую следующее эмпирическое правило: сохраняйте утверждения, чтобы обнаружить, что это не должно случиться . Пользовательский ввод может быть неправильным, например, пароль слишком короткий, но это не так . Если диаметр круга не в два раза больше его радиуса, то у вас такого не должно быть .

Самое интересное, на мой взгляд, использование assertвдохновлено программированием по контракту, как описано Б. Мейером в [Создание объектно-ориентированного программного обеспечения] ( https://www.eiffel.org/doc/eiffel/Object-Oriented_Software_Construction% 2C_2nd_Edition ) и реализован на [языке программирования Eiffel] ( https://en.wikipedia.org/wiki/Eiffel_(programming_language) ). Вы не можете полностью эмулировать программирование по контракту, используя assertоператор, но интересно сохранить намерение.

Вот пример. Представьте, что вам нужно написать headфункцию (например, [ headфункция в Haskell] ( http://www.zvon.org/other/haskell/Outputprelude/head_f.html )). Вам дана следующая спецификация: «если список не пустой, вернуть первый элемент списка». Посмотрите на следующие реализации:

>>> def head1(xs): return xs[0]

А также

>>> def head2(xs):
...     if len(xs) > 0:
...         return xs[0]
...     else:
...         return None

(Да, это можно записать как return xs[0] if xs else None, но это не главное) .

Если список не пустой, обе функции имеют одинаковый результат, и этот результат является правильным:

>>> head1([1, 2, 3]) == head2([1, 2, 3]) == 1
True

Следовательно, обе реализации являются (я надеюсь) правильными. Они отличаются, когда вы пытаетесь взять заголовок пустого списка:

>>> head1([])
Traceback (most recent call last):
...
IndexError: list index out of range

Но:

>>> head2([]) is None
True

Опять же, обе реализации верны, потому что никто не должен передавать пустой список этим функциям (мы не в спецификации ). Это неправильный вызов, но если вы сделаете такой вызов, все может произойти. Одна функция вызывает исключение, другая возвращает специальное значение. Самое главное: мы не можем полагаться на это поведение . Если xsпусто, это будет работать:

print(head2(xs))

Но это приведет к сбою программы:

print(head1(xs))

Чтобы избежать неожиданностей, я хотел бы знать, когда я передаю какой-то неожиданный аргумент в функцию. Другими словами: я хотел бы знать, когда наблюдаемое поведение ненадежно, потому что оно зависит от реализации, а не от спецификации. Конечно, я могу прочитать спецификацию, но программисты не всегда внимательно читают документы.

Представьте, если бы у меня был способ вставить спецификацию в код, чтобы получить следующий эффект: когда я нарушаю спецификацию, например, передавая пустой список head, я получаю предупреждение. Это было бы очень полезно для написания правильной (то есть соответствующей спецификации) программы. И вот где assert на сцене появляется:

>>> def head1(xs):
...     assert len(xs) > 0, "The list must not be empty"
...     return xs[0]

А также

>>> def head2(xs):
...     assert len(xs) > 0, "The list must not be empty"
...     if len(xs) > 0:
...         return xs[0]
...     else:
...         return None

Теперь у нас есть:

>>> head1([])
Traceback (most recent call last):
...
AssertionError: The list must not be empty

А также:

>>> head2([])
Traceback (most recent call last):
...
AssertionError: The list must not be empty

Обратите внимание, что head1бросает AssertionError, а не IndexError. Это важно, потому что это AssertionErrorне какая-либо ошибка во время выполнения: она сигнализирует о нарушении спецификации. Я хотел предупреждение, но я получаю ошибку. К счастью, я могу отключить проверку (используя -Oопцию), но на свой страх и риск. Я сделаю это, крушение действительно дорого, и надеюсь на лучшее. Представьте, что моя программа встроена в космический корабль, который путешествует через черную дыру. Я отключу утверждения и надеюсь, что программа достаточно надежна, чтобы не зависать как можно дольше.

Этот пример касался только предварительных условий, которые можно использовать assertдля проверки постусловий (возвращаемое значение и / или состояние) и инвариантов (состояние класса). Обратите внимание, что проверка постусловий и инвариантов с помощью assertможет быть громоздкой:

  • для постусловий вам необходимо присвоить возвращаемое значение переменной и, возможно, сохранить начальное состояние объекта, если вы имеете дело с методом;
  • для инвариантов вы должны проверить состояние до и после вызова метода.

У вас не будет чего-то более сложного, чем у Eiffel, но вы можете улучшить общее качество программы.


Подводя итог, assertможно сказать , что это удобный способ обнаружения ситуации, которая не должна возникать . Нарушения спецификации (например, передача пустого списка head) являются первоклассными, это не должно происходить в ситуациях. Следовательно, хотя assertоператор может использоваться для обнаружения любой непредвиденной ситуации, это привилегированный способ обеспечить выполнение спецификации. После того, как вы вставили assertоператоры в код для представления спецификации, мы можем надеяться, что вы улучшили качество программы, потому что будут сообщаться неверные аргументы, неправильные возвращаемые значения, неправильные состояния класса ....

jferard
источник
-2

format: assert Expression [, arguments] Когда assert встречает оператор, Python оценивает выражение. Если оператор не равен true, возникает исключение (assertionError). Если утверждение не выполняется, Python использует ArgumentExpression в качестве аргумента для AssertionError. Исключения AssertionError могут быть перехвачены и обработаны, как и любое другое исключение, с помощью оператора try-exception, но если не обработано, они завершат программу и произведут трассировку. Пример:

def KelvinToFahrenheit(Temperature):    
    assert (Temperature >= 0),"Colder than absolute zero!"    
    return ((Temperature-273)*1.8)+32    
print KelvinToFahrenheit(273)    
print int(KelvinToFahrenheit(505.78))    
print KelvinToFahrenheit(-5)    

Когда приведенный выше код выполняется, он дает следующий результат:

32.0
451
Traceback (most recent call last):    
  File "test.py", line 9, in <module>    
    print KelvinToFahrenheit(-5)    
  File "test.py", line 4, in KelvinToFahrenheit    
    assert (Temperature >= 0),"Colder than absolute zero!"    
AssertionError: Colder than absolute zero!    
бхавья джоши
источник
-2
def getUser(self, id, Email):

    user_key = id and id or Email

    assert user_key

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

user2725012
источник
1
Это будет работать, но, насколько я понимаю, утверждения не должны использоваться для проверки ввода пользователя, потому что они могут быть отключены во время выполнения. Если вы действительно хотите применить или проверить вводимые пользователем данные, воспользуйтесь проверкойif not user_key: raise ValueError() последних двух абзацев здесь: wiki.python.org/moin/UsingAssertionsEffectively
alpha_989
assertНе следует использовать для проверки входных данных , поскольку либо проверки будут удалены, если __debug__естьFalse . Кроме того, использование утверждений в целях, не связанных с отладкой, может привести к тому AssertionError, что люди поймут получающиеся s, что может сделать отладку более сложной, а не меньшей.
FluxIX
-4
>>>this_is_very_complex_function_result = 9
>>>c = this_is_very_complex_function_result
>>>test_us = (c < 4)

>>> #first we try without assert
>>>if test_us == True:
    print("YES! I am right!")
else:
    print("I am Wrong, but the program still RUNS!")

I am Wrong, but the program still RUNS!


>>> #now we try with assert
>>> assert test_us
Traceback (most recent call last):
  File "<pyshell#52>", line 1, in <module>
    assert test_us
AssertionError
>>> 
rianhariadi.com
источник
-4

По сути, ключевое слово assert означает, что если условие не истинно, то оно через ошибку assertionerror, иначе оно продолжается, например, в python.

код-1

a=5

b=6

assert a==b

ВЫВОД:

assert a==b

AssertionError

код-2

a=5

b=5

assert a==b

ВЫВОД:

Process finished with exit code 0
ujjwal_bansal
источник
2
пожалуйста, отформатируйте ваш код правильно. Кроме того, как это улучшает предыдущие ответы?
c2huc2hu
есть ли проблема в моем объяснении?
ujjwal_bansal
Ваше объяснение ничего не добавляет к существующим ответам, а плохая грамматика затрудняет чтение. Если вы ищете ответы на вопросы, попробуйте просмотреть новую ленту вопросов.
c2huc2hu
Предоставленный ответ действительно отвечает, как использовать assert, но не отвечает, когда использовать (или не использовать) assert.
FluxIX