Qual é o uso de" afirmar " em Python?

Isto é importante porque:

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

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

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

Na declaração assert(False), Estes são apenas parênteses redundantes em torno de False, que avaliam o conteúdo deles. Mas com assert(False,) os parênteses são agora uma tupla, e uma tupla não-vazia avalia True num contexto booleano.

Como outras respostas observaram, assert é semelhante a abrir uma excepção se uma dada condição não for verdadeira. Uma diferença importante é que afirmar afirmações são ignoradas se você compilar seu código com a opção de otimização. A documentação diz que {[2] } pode ser melhor descrita como sendo equivalente a

if __debug__:
   if not expression: raise AssertionError

Isto pode ser útil se você quiser testar cuidadosamente o seu código, em seguida, libere uma versão otimizada quando você está feliz que nenhum dos seus casos de asserção falhar - quando a otimização está ligada, a variável __debug__ torna-se falsa e as condições deixarão de ser avaliadas. Este recurso também pode te pegar se você está confiando nas afirmações e não percebe que eles desapareceram.

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

Pode tentar o seguinte numa linha de comandos interactiva:

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

O objectivo de uma afirmação em Python é informar os programadores sobre erros irrecuperáveis num programa.

As afirmações não se destinam a sinalizar as condições de erro esperadas, como "ficheiro não encontrado", onde um utilizador pode tomar medidas correctivas (ou apenas tentar de novo).

Outra Maneira de olhar para ele é dizer que as afirmações são auto-verificações internas no seu código. Eles trabalham declarando algumas condições como impossível em seu código. Se estas condições não espera, isso significa que há um erro no programa.

Se o seu programa estiver livre de erros, estas condições nunca irão ocorrer. Mas se um deles {[[10]}ocorrer o programa irá estoirar com um erro de asserção dizendo-lhe exatamente qual condição" impossível " foi disparada. Isso torna muito mais fácil de rastrear e corrigir bugs em seus programas.

Aqui está um resumo de um tutorial sobre as afirmações do Python {[19] } Eu escrevi:

A afirmação do Python é uma depuração ajuda, não um mecanismo para lidar com erros de tempo de execução. O objectivo de usar afirmações é deixar os programadores encontrar a causa raiz provável de um erro mais rapidamente. Um erro de asserção nunca deve ser levantado a menos que haja um bug em seu programa.

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

if __​debug__:
    if not <expression>: raise AssertionError

A forma estendida, assert <expression1>, <expression2>, é equivalente a

if __​debug__:
    if not <expression1>: raise AssertionError, <expression2>

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

De documentos:

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

Aqui está um exemplo simples, Salve isto em Arquivo (vamos dizer 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

Se a declaração após assert for verdadeira, então o programa continua, mas se a declaração após assert for falsa, então o programa dá um erro. Tão simples quanto isso.

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

Se alguma vez quiser saber exactamente o que uma função reservada faz em python, escreva em help(enter_keyword)

Certifique-se de que, se estiver a introduzir uma palavra-chave reservada, a introduza como um texto.

Python assert é basicamente uma ajuda de depuração que testa a condição para auto-verificação interna do seu código. Afirmar torna a depuração muito fácil quando o seu código entra em casos extremos impossíveis. Confirmar esses casos impossíveis.

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

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

Um tutorial relacionado sobre isto:

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

def getUser(self, id, Email):

    user_key = id and id or Email

    assert user_key

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

Formato : afirmar a expressão [, argumentos] Quando assert encontra uma declaração, Python avalia a expressão.Se a declaração não for verdadeira, uma exceção é levantada (assertionError). Se a afirmação falhar, Python usa ArgumentExpression como argumento para o erro de AssertionError. As exceções do erro de AssertionError podem ser capturadas e tratadas como qualquer outra exceção usando a declaração try-except, mas se não forem tratadas, elas terminarão o programa e produzirão um Traco. 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, 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!    

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

Basicamente a palavra-chave assertiva significa que se a condição não é verdadeira, então ela através de um erro assertionerror ou então ela continua, 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