Wat is het nut van “beweren” in Python?

Ik heb wat broncode gelezen en op verschillende plaatsen heb ik het gebruik van assert gezien.

Wat betekent het precies? Wat is het gebruik ervan?

Antwoord 1, autoriteit 100%

De assert-instructie bestaat in bijna elke programmeertaal. Het helpt problemen vroeg in uw programma op te sporen, waar de oorzaak duidelijk is, in plaats van later wanneer een andere handeling mislukt.

Als je dat doet…

assert condition

… je vertelt het programma om die voorwaarde te testen en onmiddellijk een fout te activeren als de voorwaarde onwaar is.

In Python is het ongeveer gelijk aan dit:

if not condition:
    raise AssertionError()

Probeer het in de Python-shell:

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

Beweringen kunnen een optioneel bericht bevatten en u kunt ze uitschakelen wanneer u de tolk uitvoert.

Een bericht afdrukken als de bevestiging mislukt:

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

Gebruik geen haakjes om assert aan te roepen als een functie. Het is een verklaring. Als je assert(condition, message) doet, voer je de assert uit met een (condition, message) tuple als eerste parameter.

Wat betreft het uitschakelen ervan, wanneer python in geoptimaliseerde modus wordt uitgevoerd, waarbij __debug__ False is, worden assert-statements genegeerd. Geef gewoon de vlag -O door:

python -O script.py

Zie hier voor de relevante documentatie.

Antwoord 2, autoriteit 37%

Pas op voor de haakjes. Zoals hierboven is opgemerkt, in Python 3, assert is nog steeds een statement, dus naar analogie met print(..), kan men hetzelfde extrapoleren naar assert(..) of raise(..) maar dat zou je niet moeten doen.

Dit is fout:

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

Dit is correct:

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

De reden dat de eerste niet werkt, is dat bool( (False, "Houston we've got a problem") ) evalueert naar True.

In het statement assert(False) zijn dit gewoon overbodige haakjes rond False, die hun inhoud evalueren. Maar met assert(False,) zijn de haakjes nu een tuple, en een niet-lege tuple evalueert tot True in een Booleaanse context.

Antwoord 3, autoriteit 12%

Zoals andere antwoorden al hebben opgemerkt, is assert vergelijkbaar met het genereren van een uitzondering als een bepaalde voorwaarde niet waar is. Een belangrijk verschil is dat assert-statements worden genegeerd als je je code compileert met de optimalisatieoptie -O. De documentatie zegt dat assert expression kan beter worden omschreven als gelijkwaardig aan

if __debug__:
   if not expression: raise AssertionError

Dit kan handig zijn als u uw code grondig wilt testen en vervolgens een geoptimaliseerde versie wilt vrijgeven als u tevreden bent dat geen van uw beweringen faalt – wanneer optimalisatie is ingeschakeld, wordt de variabele __debug__ False en de voorwaarden worden niet meer geëvalueerd. Deze functie kan je ook betrappen als je op de beweringen vertrouwt en je niet realiseert dat ze verdwenen zijn.

Antwoord 4, autoriteit 6%

Het doel van een bewering in Python is om ontwikkelaars te informeren over onherstelbare fouten in een programma.

Beweringen zijn niet bedoeld om verwachte foutcondities te signaleren, zoals ‘bestand niet gevonden’, waar een gebruiker corrigerende maatregelen kan nemen (of gewoon opnieuw proberen).

Een andere manier om ernaar te kijken is door te zeggen dat beweringen interne zelfcontroles in je code zijn. Ze werken door sommige voorwaarden als onmogelijk in uw code te verklaren. Als deze voorwaarden niet gelden, betekent dit dat er een fout in het programma zit.

Als je programma geen fouten bevat, zullen deze voorwaarden nooit voorkomen. Maar als een van hen zich doet, zal het programma crashen met een bevestigingsfout die u precies vertelt welke “onmogelijke” toestand is geactiveerd. Dit maakt het veel gemakkelijker om bugs in uw programma’s op te sporen en op te lossen.

Hier is een samenvatting van een tutorial over de beweringen van Python die ik schreef:

Python’s assert-statement is een hulpmiddel bij het debuggen, niet een mechanisme voor het afhandelen van runtime-fouten. Het doel van het gebruik van assertions is om ontwikkelaars de waarschijnlijke hoofdoorzaak van een bug sneller te laten vinden. Er mag nooit een beweringfout worden gemaakt, tenzij er een bug in uw programma zit.

Antwoord 5, autoriteit 4%

Anderen hebben je al links naar documentatie gegeven.

Je kunt het volgende proberen in een interactieve shell:

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

De eerste instructie doet niets, terwijl de tweede een uitzondering oproept. Dit is de eerste hint: beweringen zijn handig om voorwaarden te controleren die waar zouden moeten zijn in een bepaalde positie van uw code (meestal het begin (precondities) en het einde van een functie (postconditions)).

Beweringen zijn in feite sterk gebonden aan programmeren op contract, wat een zeer nuttige technische praktijk is:

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

Antwoord 6, autoriteit 2%

Van documenten:

Bevestigingsinstructies zijn een handige manier om foutopsporingsbevestigingen in een programma in te voegen

Je kunt hier meer lezen: http://docs.python .org/release/2.5.2/ref/asset.html

Antwoord 7

Het assert-statement heeft twee vormen.

De eenvoudige vorm, assert <expression>, is gelijk aan

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

De uitgebreide vorm, assert <expression1>, <expression2>, is gelijk aan

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

Antwoord 8

Beweringen zijn een systematische manier om te controleren of de interne staat van een programma is zoals de programmeur had verwacht, met als doel bugs op te sporen. Zie het voorbeeld hieronder.

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

Antwoord 9

Hier is een eenvoudig voorbeeld, sla dit op in een bestand (laten we zeggen b.py)

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

en het resultaat wanneer $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

Antwoord 10

De assert-instructie bestaat in bijna elke programmeertaal. Het helpt om problemen vroeg in uw programma op te sporen, waar de oorzaak duidelijk is, in plaats van later als een neveneffect van een andere operatie. Ze verwachten altijd een True toestand.

Als je iets doet als:

assert condition

U vertelt het programma om die voorwaarde te testen en onmiddellijk een fout te activeren als deze onwaar is.

In Python, assert uitdrukking , is gelijk aan:

if __debug__:
    if not <expression>: raise AssertionError

U kunt de uitgebreide uitdrukking gebruiken om een ​​optioneel bericht door te geven:

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

Probeer het in de Python-interpreter:

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

Er zijn enkele kanttekeningen te plaatsen voordat ze worden gebruikt, voornamelijk voor degenen die menen te schakelen tussen de assert– en if-statements. Het doel om assert te gebruiken is wanneer het programma een voorwaarde verifieert en een waarde retourneert die het programma onmiddellijk zou moeten stoppen in plaats van een alternatieve manier te gebruiken om de fout te omzeilen:

1. Haakjes

Zoals je misschien hebt opgemerkt, gebruikt de assert-instructie twee voorwaarden. Gebruik daarom geen haakjes om ze als één geheel samen te vatten voor duidelijk advies. Als u het volgende doet:

assert (condition, message)

Voorbeeld:

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

Je voert de assert uit met een (condition, message) die een tuple vertegenwoordigt als de eerste parameter, en dit gebeurt omdat een niet-lege tuple in Python is altijd True. U kunt echter zonder problemen afzonderlijk het volgende doen:

assert (condition), "message"

Voorbeeld:

>>> 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. Doel van debuggen

Als je je afvraagt ​​wanneer je de assert-instructie moet gebruiken. Neem een ​​voorbeeld dat in het echte leven wordt gebruikt:

* Wanneer uw programma de neiging heeft om elke parameter te controleren die door de gebruiker is ingevoerd of wat dan ook:

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

* Een ander geval is wiskunde als 0 of niet-positief als coëfficiënt of constante op een bepaalde vergelijking:

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

* of zelfs een eenvoudig voorbeeld van een booleaanse implementatie:

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

3. Gegevensverwerking of gegevensvalidatie

Het is van het grootste belang om niet te vertrouwen op de assert-instructie om gegevensverwerking of gegevensvalidatie uit te voeren, omdat deze instructie kan worden uitgeschakeld bij de Python-initialisatie met -O of Vlag -OO betekent waarde 1, 2 en 0 (standaard), respectievelijk of PYTHONOPTIMIZE omgevingsvariabele.

Waarde 1:

* beweringen zijn uitgeschakeld;

* bytecode-bestanden worden gegenereerd met .pyo extensie in plaats van .pyc;

* sys.flags.optimize is ingesteld op 1 (True);

* en, __debug__ is ingesteld op False;

Waarde 2: schakelt nog een ding uit

* docstrings zijn uitgeschakeld;

Daarom is het uiterst gevaarlijk om de instructie assert te gebruiken om een ​​soort verwachte gegevens te valideren, wat zelfs voor sommige beveiligingsproblemen kan zorgen. Als je dan toestemming moet valideren, raad ik je aan in plaats daarvan raise AuthError te verhogen. Als voorwaardelijk effect wordt een assert vaak gebruikt door programmeurs op bibliotheken of modules die niet rechtstreeks door een gebruiker kunnen worden gebruikt.

Antwoord 11

als het statement na assert waar is, gaat het programma verder, maar als het statement na assert false is, geeft het programma een fout. Zo simpel.

bijv.:

assert 1>0   #normal execution
assert 0>1   #Traceback (most recent call last):
             #File "<pyshell#11>", line 1, in <module>
             #assert 0>1
             #AssertionError

Antwoord 12

Zoals beknopt samengevat op de C2 Wiki:

Een bewering is een booleaanse uitdrukking op een specifiek punt in een programma die waar zal zijn tenzij er een fout in het programma zit.

U kunt een assert-statement gebruiken om uw begrip van de code op een bepaald programmapunt te documenteren. U kunt bijvoorbeeld aannames of garanties documenteren over inputs (randvoorwaarden), programmastatus (invarianten) of outputs (postvoorwaarden).

Mocht uw bewering ooit mislukken, dan is dit een waarschuwing voor u (of uw opvolger) dat uw begrip van het programma verkeerd was toen u het schreef, en dat het waarschijnlijk een bug bevat.

Voor meer informatie heeft John Regehr een prachtige blogpost over de Use of Assertions, die is ook van toepassing op de Python assert-instructie.

Antwoord 13

Als u in Pycharm assert samen met isinstance gebruikt om het type van een object te declareren, krijgt u tijdens het coderen toegang tot de methoden en attributen van het bovenliggende object , wordt het automatisch aangevuld.

Stel bijvoorbeeld dat self.object1.object2 een MyClass-object is.

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

Antwoord 14

Als je ooit precies wilt weten wat een gereserveerde functie doet in python, typ dan help(enter_keyword)

Zorg ervoor dat als u een gereserveerd trefwoord invoert, u dit als een tekenreeks invoert.

Antwoord 15

Python beweren is in feite een hulpmiddel bij het opsporen van fouten die testcondities voor interne zelfcontrole van uw code.
Assert maakt foutopsporing heel eenvoudig wanneer uw code in onmogelijke randgevallen terechtkomt. Controleer die onmogelijke gevallen.

Laten we zeggen dat er een functie is om de prijs van het artikel na korting te berekenen:

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

hier kan discounted_price nooit lager zijn dan 0 en hoger dan de werkelijke prijs. Dus, in het geval dat de bovenstaande voorwaarde wordt geschonden, roept assert een Assertion Error op, die de ontwikkelaar helpt te identificeren dat er iets onmogelijks is gebeurd.

Hopelijk helpt het 🙂

Antwoord 16

Mijn korte uitleg is:

• assert verhoogt AssertionError als de uitdrukking onwaar is, anders gaat u gewoon door met de code, en als er een komma staat, wat het ook is, dan is het AssertionError: whatever after comma, en coderen is als volgt: raise AssertionError(whatever after comma)

Een gerelateerde tutorial hierover:

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

Antwoord 17

Zoals in andere antwoorden geschreven, worden assert-statements gebruikt om de staat van . te controleren
het programma op een bepaald punt.

Ik zal niet herhalen wat er is gezegd over geassocieerde
bericht, haakjes of -O optie en __debug__ constante. Controleer ook de
doc voor eerst
hand informatie. Ik zal me concentreren op uw vraag: wat is het nut van assert?
Om precies te zijn, wanneer (en wanneer niet) moet je assert gebruiken?

De assert-statements zijn handig om een ​​programma te debuggen, maar worden afgeraden om de gebruiker te controleren
invoer. Ik gebruik de volgende vuistregel: houd beweringen om een ​​this . te detecteren
mag niet gebeuren situatie. Een gebruiker
invoer kan onjuist zijn, b.v. een wachtwoord te kort, maar dit is geen dit
mag niet gebeuren geval. Als de diameter van een cirkel niet twee keer zo groot is als zijn
radius, bevindt u zich in een dit zou niet mogen gebeuren geval.

Het meest interessante, naar mijn mening, gebruik van assert is geïnspireerd door de
programmeren per contract als
beschreven door B. Meyer in [Object-Oriented Software Construction](
https://www.eiffel.org/doc/eiffel/Object-Oriented_Software_Construction% 2C_2nd_Edition
) en geïmplementeerd in de [Eiffel programmeertaal](
https://en.wikipedia.org/wiki/Eiffel_(programming_language)) . Je kunt niet volledig
emuleer programmering per contract met behulp van de assert-instructie, maar het is
interessant om de intentie te behouden.

Hier is een voorbeeld. Stel je voor dat je een functie head moet schrijven (zoals de
[head-functie in Haskell](
http://www.zvon.org/other/haskell/Outputprelude/head_f. html)). De
specificatie die u krijgt is: “als de lijst niet leeg is, retourneer dan de
eerste item van een lijst”. Bekijk de volgende implementaties:

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

En

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

_{(Ja, dit kan worden geschreven als return xs[0] if xs else None, maar daar gaat het niet om)}.

Als de lijst niet leeg is, hebben beide functies hetzelfde resultaat en dit resultaat
klopt:

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

Daarom zijn beide implementaties (hoop ik) correct. Ze verschillen wanneer je probeert om
neem het hoofditem van een lege lijst:

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

Maar:

>>> head2([]) is None
True

Nogmaals, beide implementaties zijn correct, omdat niemand een lege mag doorgeven
lijst naar deze functies (we zijn buiten de specificatie). Dat is een
verkeerde oproep, maar als u zo’n oproep doet, kan er van alles gebeuren.
De ene functie genereert een uitzondering, de andere retourneert een speciale waarde.
Het belangrijkste is: we kunnen niet vertrouwen op dit gedrag. Als xs leeg is,
dit zal werken:

print(head2(xs))

Maar hierdoor crasht het programma:

print(head1(xs))

Om verrassingen te voorkomen, wil ik graag weten wanneer ik onverwachts passeer
argument naar een functie. Met andere woorden: ik zou graag willen weten wanneer de waarneembare
gedrag is niet betrouwbaar, omdat het afhangt van de implementatie, niet van de specificatie.
Natuurlijk kan ik de specificatie lezen, maar programmeurs lezen niet altijd zorgvuldig
de documenten.

Stel je voor dat ik een manier had om de specificatie in de code in te voegen om de
volgend effect: wanneer ik de specificatie overtreed, bijvoorbeeld door een lege . door te geven
lijst naar head, krijg ik een waarschuwing. Dat zou een grote hulp zijn om een ​​correcte te schrijven
(d.w.z. in overeenstemming met de specificatie) programma. En dat is waar assert
komt ter plaatse:

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

En

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

Nu hebben we:

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

En:

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

Merk op dat head1 een AssertionError genereert, niet een IndexError. dat is
belangrijk omdat een AssertionError geen een runtime-fout is: het signaleert een
overtreding van de specificatie. Ik wilde een waarschuwing, maar ik krijg een foutmelding.
Gelukkig kan ik de controle uitschakelen (met de optie -O),
maar op eigen risico. Ik zal het doen, een crash is erg duur, en ik hoop op de
het beste. Stel je voor dat mijn programma is ingebed in een ruimteschip dat reist door een
zwart gat. Ik zal beweringen uitschakelen en hoop dat het programma robuust genoeg is
om niet zo lang mogelijk te crashen.

Dit voorbeeld ging alleen over randvoorwaarden, of je kunt assert gebruiken om te controleren
postcondities (de retourwaarde en/of de toestand) en invarianten (toestand van a
klas). Merk op dat het controleren van postcondities en invarianten met assert kan zijn
omslachtig:

• voor postconditions moet je de retourwaarde toewijzen aan een variabele, en
  misschien om de beginstatus van het object op te slaan als je te maken hebt met een methode;
• voor invarianten moet je de status voor en na een methodeaanroep controleren.

Je zult niet zoiets verfijnds hebben als Eiffel, maar het kan wel
de algehele kwaliteit van een programma verbeteren.

Om samen te vatten, de assert-instructie is een handige manier om een ​​dit
mag niet gebeuren situatie. Overtredingen van de specificatie (bijv. passeren
een lege lijst naar head) zijn eersteklas dit zou niet moeten gebeuren situaties.
Hoewel de instructie assert kan worden gebruikt om elke onverwachte situatie te detecteren,
het is een bevoorrechte manier om ervoor te zorgen dat aan de specificatie wordt voldaan.
Nadat u assert-instructies in de code hebt ingevoegd om de
specificatie, kunnen we hopen dat u de kwaliteit van het programma hebt verbeterd, want
onjuiste argumenten, onjuiste retourwaarden, onjuiste toestanden van een klasse …,
zal worden gerapporteerd.

Antwoord 18

Beweringen zijn uitspraken die een feit met vertrouwen in ons programma vermelden.

Syntaxis: assert <condition> of assert <condition>,<error message>

Het heeft een voorwaarde/uitdrukking die verondersteld wordt altijd waar te zijn. Als de voorwaarde onwaar is, zal de assert-instructie het programma stoppen en een foutmelding geven met de melding AssertionError. Dus je beweringuitdrukking zal iets zijn dat je niet in je programma wilt hebben.

bijv.

1. assert <condition> — gebruik assert zonder <error message>

   var = int(input("Enter value 1-9 inclusive:"))                                 
   assert var!=0 
   print(var)
   

   Uitvoer:

   Als invoer 0 is:

   AssertionError
   

   Als invoer 1 is:

   1
   

2. assert <condition>,<error message> — gebruik assert met een <error message>

   var = int(input("Enter value 1-9 inclusive:"))                                 
   assert var!=0,"Input cannot be zero"
   print(var)
   

   Uitvoer:

   Als invoer 0 is:

   AssertionError: Input cannot be zero
   

   Als invoer 1 is:

   1
   

Belangrijkste punten:

1. Het wordt gebruikt als een foutopsporingstool.
2. Er is een uitdrukking en een optioneel bericht voor nodig.
3. Het bestaat in bijna elke programmeertaal

Antwoord 19

formaat :
bewering Uitdrukking[argumenten]
Wanneer assert een statement tegenkomt, evalueert Python de expressie. Als het statement niet waar is, wordt er een uitzondering gegenereerd (assertionError).
Als de bewering mislukt, gebruikt Python ArgumentExpression als argument voor de AssertionError. AssertionError-uitzonderingen kunnen worden opgevangen en afgehandeld zoals elke andere uitzondering met behulp van de try-behalve-instructie, maar als ze niet worden afgehandeld, zullen ze het programma beëindigen en een traceback produceren.
Voorbeeld:

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)    

Als de bovenstaande code wordt uitgevoerd, levert dit het volgende resultaat op:

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!    

Antwoord 20

def getUser(self, id, Email):
    user_key = id and id or Email
    assert user_key

Kan worden gebruikt om ervoor te zorgen dat parameters worden doorgegeven in de functieaanroep.

Antwoord 21

Het assert sleutelwoord in Python roept een AssertionError op als de code die volgt op het assert sleutelwoord False is. Zo niet, dan gaat het verder alsof er niets is gebeurd.

Voorbeeld 1:

a=5
b=6
assert a == b

UITGANG:

AssertionError

Dit komt omdat a uiteraard niet gelijk is aan b.
Dit is met name handig als u een Exception in uw code wilt opnemen.

def get_dict_key(d, k):
    try:
        assert k in d
        return d[k]
    except Exception:
        print("Key must be in dict.")

Dit bovenstaande voorbeeld is praktisch nutteloos, maar onthoud dat het meestal wordt gebruikt voor het opsporen van fouten, zodat u uw fouten kunt opsporen.

Antwoord 22

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