Qual é a utilidade de "assert" em Python?

Respostas:

1085

A assertdeclaração existe em quase todas as linguagens de programação. Ajuda a detectar problemas no início do seu programa, onde a causa é clara, e não mais tarde, como efeito colateral de alguma outra operação.

Quando você faz...

assert condition

... você está dizendo ao programa para testar essa condição e acionar imediatamente um erro se a condição for falsa.

No Python, é aproximadamente equivalente a isso:

if not condition:
    raise AssertionError()

Experimente no shell Python:

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

As asserções podem incluir uma mensagem opcional e você pode desabilitá-las ao executar o intérprete.

Para imprimir uma mensagem se a asserção falhar:

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

Você não usar parêntesis para chamar assertcomo uma função. É uma afirmação. Se você o fizer, assert(condition, message)estará executando o assertcom uma (condition, message)tupla como primeiro parâmetro.

Quanto à desativação deles, quando executados pythonno modo otimizado, onde __debug__estão False, as declarações de asserção serão ignoradas. Apenas passe a -Obandeira:

python -O script.py

Veja aqui a documentação relevante.

slezica
fonte
92
Nit: assert é uma declaração e não uma função. E, diferentemente da impressão , no Python 3 ainda é uma declaração .
Bob Stein
2
@Chaine assert significa "certifique-se de que * algo" seja Verdadeiro ". Portanto, afirme que a == 3 garantirá que a seja igual a 3; se a não for igual a 3 (por exemplo, a == 3 é False), será gerar um erro
Ant
5
Se eu posso apenas usar o if not condition: raise AssertError(), por que devo usar assert? Existem condições sob as quais a afirmação é melhor do que apenas ser uma forma mais curta de if not conditionafirmação?
alpha_989
6
@ alpha_989 a) é mais curto e mais legível, b) você pode desativar as declarações de afirmação ao executar o intérprete (o mesmo não ocorre com o manual if). Leia os documentos para obter mais informações :)
slezica
9
totalmente não consigo entender como essa resposta recebe tantos votos, na verdade outras respostas também. a pergunta é "Qual é a utilidade de" assert "em Python?", por isso pergunta: quando usar, ou mais exatamente: qual é o cenário de uso assert, mas depois de ler todas as respostas, não tenho absolutamente nada que eu queira!
Lnshi
424

Cuidado com os parênteses. Como foi apontado acima, no Python 3, assertainda é uma afirmação ; portanto, por analogia com print(..), pode-se extrapolar o mesmo para assert(..)ou raise(..)mas você não deveria.

Isso é importante porque:

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

não vai funcionar, ao contrário

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

A razão pela qual o primeiro não funcionará é que ele é bool( (False, "Houston we've got a problem") )avaliado True.

Na declaração assert(False), esses são apenas parênteses redundantes False, que avaliam seu conteúdo. Mas com assert(False,)os parênteses agora são uma tupla, e uma tupla não vazia é avaliada Trueem um contexto booleano.

Evgeni Sergeev
fonte
18
Eu vim aqui procurando esta informação exata sobre parens e a mensagem a seguir. Obrigado.
112916 superbeck
6
Mas assert (2 + 2 = 5), "Houston we've got a problem"deve ficar bem, sim?
precisa saber é o seguinte
4
@SherylHohman você também pode tentar executar esse si mesmo e ver se funciona ou não
DarkCygnus
2
Não se esqueça de que as pessoas costumam usar parênteses para a continuação implícita de linha compatível com PEP 8. operador precedente).
cowbert
4
assert (2 + 2 = 5), "Houston we've got a problem"não funcionará ... mas não tem nada a ver com a declaração assert, o que é bom. Sua condição não funcionará porque não é uma condição. Faltando um segundo =.
N1k31t4 20/10
133

Como outras respostas observaram, asserté semelhante a lançar uma exceção se uma determinada condição não for verdadeira. Uma diferença importante é que as instruções assert são ignoradas se você compilar seu código com a opção de otimização -O. A documentação diz que assert expressionpode ser melhor descrito como sendo equivalente a

if __debug__:
   if not expression: raise AssertionError

Isso pode ser útil se você quiser testar completamente seu código e liberar uma versão otimizada quando estiver feliz que nenhum dos seus casos de afirmação falhe - quando a otimização estiver ativada, a __debug__variável se tornará False e as condições deixarão de ser avaliadas. Esse recurso também pode capturá-lo se você confiar nas declarações e não perceber que elas desapareceram.

Neil Vass
fonte
Isso significa que, se uma determinada variável ou entrada correta (de acordo com o contrato pelo qual o programa é gravado) pode levar ao travamento do programa, quando executado pelo usuário (assumindo que o sinalizador -O seja usado quando o usuário executa o programa), você deve usar o if Not Error: raise Exception(“ this is a error”)? Dessa forma, o programa ainda vai mostrar a origem do erro, quando o usuário executa-lo ..
alpha_989
Por outro lado, se você espera que o programa possa errar devido à lógica / implementação incorreta do código (mas não devido a uma entrada que esteja de acordo com o contrato para o usuário do programa), você deve usar a assertinstrução? A suposição aqui é que, quando o programa é lançado para o usuário final, você está usando o sinalizador -O, assumindo que todos os erros foram removidos. Portanto, qualquer erro ou falha no programa deve-se à entrada no programa que é válida de acordo com o contrato, mas não pode ser tratada pelo programa. Portanto, ele deve alertar o usuário como tal.
alpha_989
@ alpha_989 exatamente isso. Eu gosto de pensar em asserções como verificações de sanidade, que são apenas para ajudá-lo como desenvolvedor a garantir que o que você pensa ser verdadeiro seja realmente verdadeiro enquanto você desenvolve.
Christopher Shroba 20/0318
52

O objetivo de uma asserção no Python é informar os desenvolvedores sobre erros irrecuperáveis em um programa.

As asserções não pretendem sinalizar as condições de erro esperadas, como “arquivo não encontrado”, em que um usuário pode executar uma ação corretiva (ou apenas tentar novamente).

Outra maneira de ver isso é dizer que as asserções são auto-verificações internas no seu código. Eles funcionam declarando algumas condições como impossíveis no seu código. Se essas condições não se mantiverem, isso significa que há um erro no programa.

Se o seu programa estiver livre de erros, essas condições nunca ocorrerão. Mas se um deles faz ocorrer o programa irá falhar com um erro de declaração dizendo exatamente qual condição “impossível” foi acionado. Isso torna muito mais fácil rastrear e corrigir erros em seus programas.

Aqui está um resumo de um tutorial sobre as afirmações de Python que escrevi:

A declaração assertiva do Python é um auxiliar de depuração, não um mecanismo para lidar com erros em tempo de execução. O objetivo do uso de asserções é permitir que os desenvolvedores encontrem a causa raiz provável de um bug mais rapidamente. Um erro de declaração nunca deve ser gerado, a menos que haja um erro no seu programa.

dbader
fonte
Obrigado pelo artigo. Muito útil para entender a assertdeclaração e quando usá-la. Estou tentando entender vários termos que você introduziu no artigo.
alpha_989
Eu pensei em publicar os comentários aqui para que muito mais pessoas possam se beneficiar dos esclarecimentos. Desculpe se as perguntas são muito ingênuas.
alpha_989
No seu blog que você vinculou, você deu um exemplo em que mencionou que `assert 0 <= price <= product ['price']` está correto, mas usando `assert user.is_admin (), 'deve ter privilégios de administrador para excluir '' e assert store.product_exists(product_id), 'Unknown product id'não é uma boa prática, porque se a depuração for desativada, o usermesmo se não adminfor capaz de excluir o produto. Você considera assert user.is_admin()um unrecoverableerro? Por que isso não é um self-check?
alpha_989
Se você considera que 'user.is_admin () `é uma entrada do usuário e, portanto, não deve ser usada em uma assert statement, pricetambém não pode ser considerada uma entrada do usuário? Por que você considera assert user.is_admin()validação de dados, mas não assert price?
alpha_989
1
@ LarryDecidua Não, você pode simplesmente lê-lo no meu site, o tutorial está disponível ao público. Basta pressionar Escape ou clicar no pequeno símbolo "x" se você não estiver interessado no boletim. Espero que isso ajude :-)
dbader
51

Outros já lhe deram links para a documentação.

Você pode tentar o seguinte em um shell interativo:

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

A primeira declaração não faz nada, enquanto a segunda gera uma exceção. Esta é a primeira dica: asserts são úteis para verificar condições que devem ser verdadeiras em uma determinada posição do seu código (geralmente, o início (pré-condições) e o final de uma função (pós-condições)).

Afirmações são realmente altamente ligadas à programação por contrato, o que é uma prática de engenharia muito útil:

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

Baltasarq
fonte
Então, isso significa que podemos verificar o código em uma situação como assert (2> 5) e aumentar o erro?
20
Perder os parênteses, afirmar não é uma função.
Pillmuncher
2
Perder os parênteses é mais importante do que parece. Veja abaixo .
Evgeni Sergeev
6
Afirmar, na verdade, remonta (muito antes de "contratos") a Turing, quando ele escreveu um dos primeiros artigos sobre como os programadores podem enfrentar a tarefa bastante assustadora de criar programas corretos. Descobrir esse papel é deixado como um exercício para o leitor, pois todos os programadores podem se beneficiar ao se familiarizar com seu trabalho. :-) turingarchive.org
Ron Burk
17

Dos documentos:

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

Aqui você pode ler mais: http://docs.python.org/release/2.5.2/ref/assert.html

gruszczy
fonte
Eu gosto deste comentário, uma vez que apenas explica claramente o que é. minha pergunta é "se eu escrevi um teste de unidade adequado, por que precisaria de uma afirmação"? esse material não funciona de qualquer maneira na produção.
dtc 10/02
17

A declaração assert possui duas formas.

A forma simples,, assert <expression>é equivalente a

if __debug__:
    if not <expression>: raise AssertionError

O formulário estendido,, assert <expression1>, <expression2>é equivalente a

if __debug__:
    if not <expression1>: raise AssertionError, <expression2>
Bohdan
fonte
16

As asserções são uma maneira sistemática de verificar se o estado interno de um programa é o esperado pelo programador, com o objetivo de detectar bugs. Veja o exemplo abaixo.

>>> 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!
>>> 
Jacob Abraham
fonte
1
Além disso, asserções geralmente podem ser usadas em programas de teste de unidade. stackoverflow.com/questions/1383/what-is-unit-testing
panofish
7

Aqui está um exemplo simples, salve-o no arquivo (digamos b.py)

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


chkassert('a')

e o resultado quando $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
Gaurav Agarwal
fonte
6

se a declaração após a afirmação for verdadeira, o programa continuará, mas se a declaração após a afirmação for falsa, o programa emitirá um erro. Simples assim.

por exemplo:

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

A assertdeclaração existe em quase todas as linguagens de programação. Ajuda a detectar problemas no início do seu programa, onde a causa é clara, e não mais tarde, como efeito colateral de alguma outra operação. Eles sempre esperam uma Truecondição.

Quando você faz algo como:

assert condition

Você está dizendo ao programa para testar essa condição e acionar imediatamente um erro, se for falso.

Em Python, assertexpressão é equivalente a:

if __debug__:
    if not <expression>: raise AssertionError

Você pode usar a expressão estendida para passar uma mensagem opcional :

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

Experimente no intérprete 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

Existem algumas ressalvas a serem vistas antes de usá-las principalmente para aqueles que consideram alternar entre as declarações asserte if. O objetivo a ser usado asserté em ocasiões em que o programa verifica uma condição e retorna um valor que deve interromper o programa imediatamente, em vez de usar uma maneira alternativa de contornar o erro:

1. Parênteses

Como você deve ter notado, a assertdeclaração usa duas condições. Portanto, não use parênteses para incluí-los como um conselho óbvio. Se você faz como:

assert (condition, message)

Exemplo:

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

Você estará executando o assertcom a (condition, message)que representa uma tupla como o primeiro parâmetro, e isso acontece porque a tupla não vazia no Python é sempreTrue . No entanto, você pode fazer separadamente sem problemas:

assert (condition), "message"

Exemplo:

>>> 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. Finalidade de depuração

Se você está se perguntando sobre quando usar a assertdeclaração. Veja um exemplo usado na vida real:

* Quando seu programa tende a controlar cada parâmetro inserido pelo usuário ou qualquer outra coisa:

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

* Outro caso é na matemática quando 0 ou não positivo como coeficiente ou constante em uma determinada equação:

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

* ou mesmo um exemplo simples de implementação booleana:

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

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

3. Processamento ou validação de dados

A maior importância é não confiar na assertinstrução para executar o processamento ou a validação de dados, pois essa instrução pode ser desativada na inicialização do Python com -Oou -OOflag - ou seja, valores 1, 2 e 0 (como padrão), respectivamente - ou PYTHONOPTIMIZEvariável de ambiente .

Valor 1:

* afirmações estão desativadas;

* arquivos de bytecode são gerados usando .pyo extensão em vez de .pyc;

* sys.flags.optimize está definido como 1 ( True);

* e, __debug__está definido comoFalse ;

Valor 2: desativa mais uma coisa

* docstrings estão desabilitadas;

Portanto, o uso da assertinstrução para validar um tipo de dado esperado é extremamente perigoso, implicando até alguns problemas de segurança. Então, se você precisar validar alguma permissão, recomendo raise AuthError. Como efetivo pré-condicional, um asserté comumente usado por programadores em bibliotecas ou módulos que não têm um usuário para interagir diretamente.

assassino
fonte
3

Como resumido de forma concisa no C2 Wiki :

Uma asserção é uma expressão booleana em um ponto específico de um programa que será verdadeiro, a menos que haja um erro no programa.

Você pode usar uma assertinstrução para documentar sua compreensão do código em um ponto específico do programa. Por exemplo, você pode documentar suposições ou garantias sobre entradas (pré-condições), estado do programa (invariantes) ou saídas (pós-condições).

Se sua afirmação falhar, este é um alerta para você (ou seu sucessor) de que seu entendimento do programa estava errado quando você o escreveu e que provavelmente contém um bug.

Para obter mais informações, John Regehr tem um maravilhoso post sobre o uso de asserções , que também se aplica à assertdeclaração Python .

avandeursen
fonte
2

Se você quiser saber exatamente o que uma função reservada faz no python, digite help(enter_keyword)

Certifique-se de digitar uma palavra-chave reservada como uma sequência de caracteres.

ytpillai
fonte
2

O Python assert é basicamente um auxiliar de depuração que testa a condição de autoverificação interna do seu código. A declaração torna a depuração realmente fácil quando o seu código entra em casos extremos impossíveis. Afirme verificar esses casos impossíveis.

Digamos que haja uma função para calcular o preço do item após o desconto:

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

aqui, o preço com desconto nunca pode ser menor que 0 e maior que o preço real. Portanto, caso a condição acima seja violada, a declaração gera um erro de declaração, que ajuda o desenvolvedor a identificar que algo impossível aconteceu.

Espero que ajude :)

Nitish Chauhan
fonte
2
asserté útil em um contexto de depuração, mas não deve ser invocado fora de um contexto de depuração.
FluxIX 27/09/18
2

Minha breve explicação é:

  • assertaumenta AssertionErrorse a expressão for falsa, caso contrário, apenas continua o código, e se houver uma vírgula, seja como for AssertionError: whatever after comma, e o código é como:raise AssertionError(whatever after comma)

Um tutorial relacionado sobre isso:

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

Sub-10
fonte
A resposta fornece como usar um assert, mas não quando usar (ou não usar) um assert; também observando que um assertpode ser desativado se __debug__for Falseseria útil.
FluxIX 27/09/18
1

No Pycharm, se você usar assertjunto com isinstancepara declarar o tipo de um objeto, ele permitirá que você acesse os métodos e atributos do objeto pai enquanto estiver codificando, ele será concluído automaticamente.

Por exemplo, digamos que self.object1.object2seja um MyClassobjeto.

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

Conforme escrito em outras respostas, as assertinstruções são usadas para verificar o estado do programa em um determinado momento.

Não repetirei o que foi dito sobre mensagens, parênteses ou -Oopção e __debug__constante associados . Consulte também o documento para obter informações em primeira mão. Vou me concentrar na sua pergunta: de que serve assert? Mais precisamente, quando (e quando não) deve-se usar assert?

As assertinstruções são úteis para depurar um programa, mas são desencorajadas a verificar a entrada do usuário. Eu uso a seguinte regra geral: mantenha asserções para detectar uma situação que isso não deve acontecer . Uma entrada do usuário pode estar incorreta, por exemplo, uma senha muito curta, mas essa não é uma isso não deve acontecer . Se o diâmetro de um círculo não for duas vezes maior que seu raio, você está nesse caso.

O uso mais interessante, em minha opinião, asserté inspirado na programação por contrato, conforme descrito por B. Meyer em [Construção de software orientada a objetos] ( https://www.eiffel.org/doc/eiffel/Object-Oriented_Software_Construction% 2C_2nd_Edition ) e implementado na [linguagem de programação Eiffel] ( https://en.wikipedia.org/wiki/Eiffel_(programming_language) ). Você não pode emular completamente a programação por contrato usando a assertdeclaração, mas é interessante manter a intenção.

Aqui está um exemplo. Imagine que você precise escrever uma headfunção (como a [ headfunção em Haskell] ( http://www.zvon.org/other/haskell/Outputprelude/head_f.html )). A especificação que você recebe é: "se a lista não estiver vazia, retorne o primeiro item de uma lista". Veja as seguintes implementações:

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

E

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

(Sim, isso pode ser escrito como return xs[0] if xs else None, mas esse não é o ponto) .

Se a lista não estiver vazia, ambas as funções terão o mesmo resultado e este resultado está correto:

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

Portanto, ambas as implementações estão (espero) corretas. Eles diferem quando você tenta obter o item principal de uma lista vazia:

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

Mas:

>>> head2([]) is None
True

Novamente, ambas as implementações estão corretas, porque ninguém deve passar uma lista vazia para essas funções (estamos fora da especificação ). Essa é uma ligação incorreta, mas se você fizer essa ligação, tudo poderá acontecer. Uma função gera uma exceção, a outra retorna um valor especial. O mais importante é: não podemos confiar nesse comportamento . Se xsestiver vazio, isso funcionará:

print(head2(xs))

Mas isso irá travar o programa:

print(head1(xs))

Para evitar algumas surpresas, gostaria de saber quando estou passando algum argumento inesperado para uma função. Em outras palavras: eu gostaria de saber quando o comportamento observável não é confiável, porque depende da implementação, não da especificação. Obviamente, eu posso ler a especificação, mas os programadores nem sempre leem com atenção os documentos.

Imagine se eu tivesse uma maneira de inserir a especificação no código para obter o seguinte efeito: quando eu viole a especificação, por exemplo, passando uma lista vazia para head, recebo um aviso. Isso seria uma grande ajuda para escrever um programa correto (ou seja, compatível com a especificação). E é aí que assert entra em cena:

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

E

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

Agora, temos:

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

E:

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

Observe que head1lança um AssertionError, não um IndexError. Isso é importante porque um AssertionErrornão é nenhum erro de execução: ele sinaliza uma violação da especificação. Eu queria um aviso, mas recebo um erro. Felizmente, posso desativar a verificação (usando a -Oopção), mas por minha conta e risco. Vou fazê-lo um acidente é realmente caro, e espero o melhor. Imagine que meu programa está incorporado em uma nave espacial que viaja através de um buraco negro. Desabilitarei as afirmações e espero que o programa seja robusto o suficiente para não travar o maior tempo possível.

Este exemplo foi apenas sobre pré-condições, você pode usar assertpara verificar pós-condições (o valor de retorno e / ou o estado) e invariantes (estado de uma classe). Observe que a verificação de pós-condições e invariantes assertpode ser complicada:

  • para pós-condições, você precisa atribuir o valor de retorno a uma variável e talvez armazenar o estado inicial do objeto se estiver lidando com um método;
  • para invariantes, é necessário verificar o estado antes e depois de uma chamada de método.

Você não terá algo tão sofisticado quanto o Eiffel, mas, no entanto, pode melhorar a qualidade geral de um programa.


Para resumir, a assertdeclaração é uma maneira conveniente de detectar uma situação que não deve acontecer . Violações da especificação (por exemplo, passar uma lista vazia para head) são de primeira classe; isso não deve ocorrer em situações. Portanto, embora a assertdeclaração possa ser usada para detectar qualquer situação inesperada, é uma maneira privilegiada de garantir que a especificação seja cumprida. Depois de inserir assertinstruções no código para representar a especificação, podemos esperar que você tenha melhorado a qualidade do programa, porque argumentos incorretos, valores de retorno incorretos, estados incorretos de uma classe ... serão relatados.

jferard
fonte
-2

formato: assert Expression [, argumentos] Quando assert encontra uma instrução, o Python avalia a expressão.Se a instrução não for verdadeira, uma exceção será gerada (assertionError). Se a asserção falhar, o Python usará ArgumentExpression como argumento para o AssertionError. As exceções AssertionError podem ser capturadas e manipuladas como qualquer outra exceção usando a instrução try-except, mas se não forem tratadas, elas encerrarão o programa e produzirão um retorno. Exemplo:

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)    

Quando o código acima é executado, ele produz o seguinte resultado:

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!    
bhavya joshi
fonte
-2
def getUser(self, id, Email):

    user_key = id and id or Email

    assert user_key

Pode ser usado para garantir que os parâmetros sejam passados ​​na chamada de função.

user2725012
fonte
1
Isso funcionará, mas, pelo que entendi, as afirmações não devem ser usadas para verificar a entrada do usuário, porque elas podem ser desativadas no tempo de execução. Se você realmente deseja impor ou usar validação de entrada do usuário do if not user_key: raise ValueError()check últimos 2 parágrafos aqui: wiki.python.org/moin/UsingAssertionsEffectively
alpha_989
assertnão deve ser usado para validação de entrada porque a validação será removida, se __debug__estiver False. Também usar asserções para fins de não depuração pode fazer com que as pessoas capturem os AssertionErrors resultantes , o que pode dificultar a depuração em vez de menos.
FluxIX 26/08/18
-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
fonte
-4

Basicamente, o significado da palavra-chave assert é que, se a condição não for verdadeira, ela será processada através de um erro de asserção, caso contrário, continuará, por exemplo, em python.

código-1

a=5

b=6

assert a==b

RESULTADO:

assert a==b

AssertionError

código-2

a=5

b=5

assert a==b

RESULTADO:

Process finished with exit code 0
ujjwal_bansal
fonte
2
formate seu código corretamente. Além disso, como isso melhora as respostas anteriores?
C2huc2hu
existe algum problema na minha explicação?
Ujjwal_bansal
sua explicação não adiciona nada às respostas existentes, e a gramática ruim dificulta a leitura. se você estiver procurando perguntas para responder, considere navegar no novo feed de perguntas.
C2huc2hu 3/17/17
A resposta fornecida responde como usar um assert, mas não responde quando usar (ou não usar) um assert.
FluxIX 27/09/18