Python-beweringen in elke programmeertaal zijn de foutopsporingstools aanwezig die helpen bij een soepele codestroom. Beweringen zijn voornamelijk aannames waarvan een programmeur weet of altijd waar wil zijn en deze daarom in code plaatst, zodat het falen ervan de code niet verder kan uitvoeren.
Stel trefwoord in Python in
In eenvoudiger bewoordingen kunnen we zeggen dat bewering de Booleaanse expressie is die controleert of de bewering waar of onwaar is. Als de instructie waar is, doet deze niets en wordt de uitvoering voortgezet, maar als de instructie False is, stopt deze de uitvoering van het programma en genereert een fout.
Stroomdiagram van Python Assert-verklaring
Stroomdiagram van Python Assert-verklaring
Python beweert trefwoordsyntaxis
In Python wordt de beweren trefwoord helpt bij het bereiken van deze taak. Deze instructie neemt als invoer een Booleaanse voorwaarde, die bij het retourneren van waar niets doet en de normale uitvoeringsstroom voortzet, maar als wordt berekend dat deze onwaar is, genereert deze een AssertionError samen met het optionele bericht dat wordt verstrekt.
Syntaxis: voorwaarde bevestigen, error_message (optioneel)
Parameters:
- voorwaarde : De Booleaanse voorwaarde retourneert waar of onwaar.
- foutbericht: Het optionele argument dat in de console moet worden afgedrukt in het geval van AssertionError
Geeft terug: Retourneert AssertionError, in het geval dat de voorwaarde wordt geëvalueerd als false, samen met de foutmelding die wordt gegeven.
Python beweert trefwoord zonder foutmelding
Deze code probeert het gebruik van assert in Python te demonstreren door te controleren of de waarde van b 0 is voordat een delingsbewerking wordt uitgevoerd. a wordt geïnitialiseerd op de waarde 4, en b wordt geïnitialiseerd op de waarde 0. Het programma drukt het bericht af. De waarde van a / b is: . De assert-instructie controleert of b niet gelijk is aan 0. Omdat b 0 is, wordt de assert statement mislukt en veroorzaakt een AssertionError.
Omdat er een uitzondering wordt veroorzaakt door de mislukte assert-instructie, wordt het programma beëindigd en gaat het programma niet verder met het uitvoeren van de print-instructie op de volgende regel.
Python3
Java leest het bestand regel voor regel
# initializing number> a>=> 4> b>=> 0> # using assert to check for 0> print>(>'The value of a / b is : '>)> assert> b !>=> 0> print>(a>/> b)> |
>
>
Uitgang:
The value of a / b is : --------------------------------------------------------------------------- AssertionError Traceback (most recent call last) Input In [19], in () 8 # using assert to check for 0 9 print('The value of a / b is : ') --->10 assert b != 0 11 print(a / b) AssertionError:> Python beweert trefwoord met een foutmelding
Deze code probeert het gebruik van assert in Python te demonstreren door te controleren of de waarde van b 0 is voordat een delingsbewerking wordt uitgevoerd. a wordt geïnitialiseerd op de waarde 4, en b wordt geïnitialiseerd op de waarde 0. Het programma drukt het bericht af. De waarde van a / b is: . De assert-instructie controleert of b niet gelijk is aan 0. Omdat b 0 is, wordt de assert statement mislukt en genereert een AssertionError met het bericht Fout bij nulverdeling .
Sinds een uitzondering wordt veroorzaakt door de mislukte assert-instructie, wordt het programma beëindigd en gaat de print-instructie niet verder op de volgende regel.
Python3
# Python 3 code to demonstrate> # working of assert> # initializing number> a>=> 4> b>=> 0> # using assert to check for 0> print>(>'The value of a / b is : '>)> assert> b !>=> 0>,>'Zero Division Error'> print>(a>/> b)> |
>
>
Uitgang:
AssertionError: Zero Division Error>
Assert binnen een functie
De assert-instructie wordt in dit voorbeeld binnen een functie gebruikt om te verifiëren dat de lengte en breedte van een rechthoek positief zijn voordat de oppervlakte ervan wordt berekend. De bewering genereert een AssertionError met het bericht Lengte en breedte moeten positief zijn als deze onwaar zijn. Als de bewering waar is, retourneert de functie het gebied van de rechthoek; als het onwaar is, wordt het afgesloten met een fout. Om te laten zien hoe je assert in verschillende situaties kunt gebruiken, wordt de functie twee keer aangeroepen, één keer met positieve inputs en één keer met negatieve inputs.
Python3
# Function to calculate the area of a rectangle> def> calculate_rectangle_area(length, width):> ># Assertion to check that the length and width are positive> >assert> length>>0> and> width>>0>,>'Length and width'>+> > >'must be positive'> ># Calculation of the area> >area>=> length>*> width> ># Return statement> >return> area> # Calling the function with positive inputs> area1>=> calculate_rectangle_area(>5>,>6>)> print>(>'Area of rectangle with length 5 and width 6 is'>, area1)> # Calling the function with negative inputs> area2>=> calculate_rectangle_area(>->5>,>6>)> print>(>'Area of rectangle with length -5 and width 6 is'>, area2)> |
>
>
Uitgang:
AssertionError: Length and widthmust be positive>
Beweren met Booleaanse voorwaarde
In dit voorbeeld controleert de assert-instructie of aan de Booleaanse voorwaarde x wordt voldaan
Python3
# Initializing variables> x>=> 10> y>=> 20> # Asserting a boolean condition> assert> x # Printing the values of x and y print('x =', x) print('y =', y)> |
>
>
Uitgang:
x = 10 y = 20>
Bevestig het type variabele in Python
In dit voorbeeld controleren de assert-instructies of de typen variabelen a en b respectievelijk str en int zijn. Als een van de beweringen mislukt, wordt er een AssertionError gegenereerd. Als beide beweringen slagen, gaat het programma verder en worden de waarden van a en b afgedrukt.
Python3
# Initializing variables> a>=> 'hello'> b>=> 42> # Asserting the type of a variable> assert> type>(a)>=>=> str> assert> type>(b)>=>=> int> # Printing the values of a and b> print>(>'a ='>, a)> print>(>'b ='>, b)> |
>
>
Uitgang:
a = hello b = 42>
Woordenboekwaarden bevestigen
In dit voorbeeld controleren de assert-instructies of de waarden die zijn gekoppeld aan de toetsen appel, banaan en kers in het woordenboek my_dict respectievelijk 1, 2 en 3 zijn. Als een van de beweringen mislukt, wordt er een AssertionError gegenereerd. Als alle beweringen slagen, gaat het programma verder en drukt de inhoud van het woordenboek af.
Python3
# Initializing a dictionary> my_dict>=> {>'apple'>:>1>,>'banana'>:>2>,>'cherry'>:>3>}> # Asserting the contents of the dictionary> assert> my_dict[>'apple'>]>=>=> 1> assert> my_dict[>'banana'>]>=>=> 2> assert> my_dict[>'cherry'>]>=>=> 3> # Printing the dictionary> print>(>'My dictionary contains the following key-value pairs:'>, my_dict)> |
>
>
Uitgang:
My dictionary contains the following key-value pairs: {'apple': 1, 'banana': 2, 'cherry': 3}> Praktische toepassing
Dit heeft een veel groter nut in de rollen Testen en Kwaliteitsborging in elk ontwikkelingsdomein. Afhankelijk van de toepassing worden verschillende soorten beweringen gebruikt. Hieronder vindt u een eenvoudiger demonstratie van een programma dat alleen toestaat dat alleen de batch met alle warme gerechten wordt verzonden, anders wordt de hele batch afgewezen.
Python3
# Python 3 code to demonstrate> # working of assert> # Application> # initializing list of foods temperatures> batch>=> [>40>,>26>,>39>,>30>,>25>,>21>]> # initializing cut temperature> cut>=> 26> # using assert to check for temperature greater than cut> for> i>in> batch:> >assert> i>>=> 26>,>'Batch is Rejected'> >print> (>str>(i)>+> ' is O.K'> )> |
>
zaden versus sporen
>
Uitgang:
40 is O.K 26 is O.K 39 is O.K 30 is O.K>
Runtime-uitzondering:
AssertionError: Batch is Rejected>
Waarom Python Assert-verklaring gebruiken?
In Python is de assert-instructie een krachtige foutopsporingstool die kan helpen bij het identificeren van fouten en ervoor kan zorgen dat uw code werkt zoals bedoeld. Hier zijn verschillende redenen voor het gebruik van assert:
- Foutopsporing: Aannames die door uw code worden gedaan, kunnen worden geverifieerd met de assert-instructie. U kunt snel fouten ontdekken en fouten in uw programma opsporen door assert-instructies in uw code te plaatsen.
- Documentatie: Het gebruik van assert-instructies in uw code kan als documentatie fungeren. Beweringsverklaringen maken het voor anderen eenvoudiger om uw code te begrijpen en ermee te werken, omdat ze expliciet de aannames beschrijven die uw code maakt.
- Testen: Om ervoor te zorgen dat aan bepaalde vereisten wordt voldaan, worden bij het testen van eenheden vaak beweringen gebruikt. U kunt ervoor zorgen dat uw code goed werkt en dat eventuele wijzigingen die u aanbrengt de huidige functionaliteit niet beschadigen door assert-statements in uw tests op te nemen.
- Beveiliging: U kunt assert gebruiken om te controleren of programma-invoer aan de vereisten voldoet en deze te valideren. Door dit te doen kunnen beveiligingsfouten zoals bufferoverflows en SQL-injectieaanvallen worden vermeden.