Pythonfuncties

Een functie is een benoemd codeblok dat één taak uitvoert. Ingebouwde functies zoals print() en input() bieden al nuttige taken die je kunt aanroepen; met def maak je je eigen functies. Een goede naam maakt van meerdere regels werk een aanroep die zegt wat je wilt laten doen.

Schrijf de kop en de inhoud

def greet():
    print("Hello!")
    print("Welcome to Python.")

greet()
greet()

De kop begint met def, gevolgd door de naam, ronde haakjes en een dubbele punt. De ingesprongen regels vormen de functie-inhoud. Gebruik vier spaties per inspringingsniveau. De niet-ingesprongen regels met greet() staan buiten de functie en zijn dus aanroepen in het hoofdprogramma.

Wanneer Python de definitie bereikt, maakt het de functie en geeft haar de naam greet. Het drukt nog geen van beide berichten af. De eerste aanroep begint bij de eerste regel van de functie-inhoud en drukt “Hello!” af, gevolgd door “Welcome to Python.” De tweede aanroep begint de inhoud opnieuw en drukt dezelfde twee regels af. In totaal zijn er vier uitvoerregels.

Een naam en een aanroep zijn verschillend

De ronde haakjes in greet() maken er een aanroep van, ook al heeft deze functie geen invoer nodig. Een regel met alleen greet verwijst naar de functie en voert niets uit. print(greet) toont een beschrijving van het functieobject, inclusief een geheugenadres; de begroeting wordt niet uitgevoerd.

Python moet een definitie hebben uitgevoerd voordat een aanroep de naam gebruikt. Als een bestand begint met greet() en greet daarna definieert, werpt de eerste regel NameError: name 'greet' is not defined op. Zet de definitie boven de aanroep op moduleniveau.

Kies namen die de taak beschrijven

Gebruik woorden in kleine letters, verbonden door onderstrepingstekens, zoals print_receipt of convert_to_miles. Namen mogen letters, cijfers en onderstrepingstekens bevatten, maar mogen niet met een cijfer beginnen of een gereserveerd woord zoals return zijn. Namen zijn hoofdlettergevoelig: greet en Greet zijn verschillende namen.

Houd ingebouwde namen beschikbaar. Na input = "yes" verwijst de naam input naar tekst, dus werpt input("Name? ") de fout TypeError: 'str' object is not callable op. Als je de variabele answer noemt, blijft de ingebouwde functie bereikbaar.

Herstel eerst de structuur

Een ontbrekende dubbele punt in de kop geeft SyntaxError: expected ':'. Een lege inhoud of een inhoud zonder inspringing geeft een IndentationError. Een geplande functie heeft nog steeds een instructie nodig; pass is een tijdelijke invulling die niets doet:

def print_receipt():
    pass

print_receipt()

Dit programma wordt zonder uitvoer uitgevoerd. De aanroep bereikt pass en daarna het einde van de inhoud. Vervang de tijdelijke invulling door de echte taak wanneer je klaar bent om die te implementeren. Als een regel bij de inhoud hoort maar op het verkeerde moment wordt uitgevoerd, controleer dan de inspringing voordat je de aanroep wijzigt.

Een programma met functies voert niet elke functie-inhoud uit in de volgorde waarin die op de pagina staat. Een aanroep verandert het uitvoeringsverloop: Python gaat de aangeroepen functie binnen, maakt haar werk af en hervat de aanroepende code direct na die aanroep.

Volg een aanroep binnen een andere aanroep

def line():
    print("----------")

def banner():
    line()
    print("  REPORT")
    line()

print("Start")
banner()
print("End")

Eerst definieert Python line en banner. Geen van beide functies wordt uitgevoerd. De volgende instructie drukt “Start” af. De aanroep van banner() gaat de functie-inhoud binnen, waarvan de eerste instructie line() aanroept.

Python gaat nu line binnen, drukt “----------” af en bereikt het einde. De uitvoering keert terug naar de volgende instructie in banner, die “ REPORT” afdrukt. De tweede aanroep van line() drukt nog een streepjeslijn af. Ten slotte eindigt banner, zodat het hoofdprogramma verdergaat en “End” afdrukt.

De uitvoer is:

Start
----------
  REPORT
----------
End

Houd niet-voltooide aanroepen bij

Terwijl line wordt uitgevoerd, wacht banner tot die functie klaar is. Het hoofdprogramma wacht ook op banner. Python houdt deze niet-voltooide aanroepen bij op de aanroepstapel. De binnenste actieve aanroep eindigt het eerst en elke aanroepende functie gaat verder bij haar eigen volgende instructie.

Nummer de regels van het programma om het op papier te volgen. Noteer een regel uit een functie-inhoud alleen wanneer de uitvoering die via een aanroep bereikt. Markeer bij elke aanroep waar de uitvoering verdergaat. Schrijf uitvoer op wanneer de bijbehorende print wordt uitgevoerd en behoud spaties en regelafbrekingen. Zo onderscheid je de route door de code van de uitvoer die deze oplevert.

Definieer hulpfuncties voordat ze nodig zijn

De definitie van een hulpfunctie mag onder de definitie van de aanroepende functie staan:

def show_report():
    draw_line()
    print("Ready")

def draw_line():
    print("====")

show_report()

Dit werkt omdat beide definities zijn uitgevoerd voordat de laatste aanroep show_report binnengaat. Python zoekt draw_line op wanneer de functie-inhoud die daadwerkelijk aanroept. Als je show_report() boven def draw_line(): zet, mislukt de aanroep wanneer die de ontbrekende hulpfunctie probeert te gebruiken.

Herhaalde aanroepen beginnen opnieuw

Een aanroep binnen een lus gaat bij elke herhaling de functie-inhoud binnen:

for i in range(3):
    line()

Met de eerste definitie van line drukt dit de streepjeslijn drie keer af. De functie begint bij elke aanroep bij haar eerste instructie.

Als een aanroep mislukt, toont Python een stacktrace. De laatste regel geeft het fouttype en de melding. De aanroepen daarboven lopen van de buitenste niet-voltooide aanroep tot de regel waar de fout optrad. Door eerst de laatste fout te lezen en daarna de binnenste regel en de aanroepende code te controleren, vind je zowel de mislukte bewerking als de route waarlangs de gegevens zijn aangeleverd.

Een functie wordt herbruikbaar voor verschillende invoer als haar kop de benodigde waarden benoemt. Deze namen zijn parameters. De aanroepende code levert argumenten: de werkelijke waarden die bij een bepaalde aanroep worden gebruikt.

Koppel waarden aan namen

def rectangle_area(width, height):
    print("Area:", width * height)

rectangle_area(4, 2.5)
rectangle_area(3, 7)

De parameters zijn width en height. Bij de eerste aanroep zijn de argumenten 4 en 2.5. Positionele argumenten worden van links naar rechts gekoppeld: width krijgt 4 en height krijgt 2,5. De functie-inhoud drukt “Area: 10.0” af. De volgende aanroep geeft dezelfde parameternamen nieuwe waarden en drukt “Area: 21” af.

Elke parameter werkt als een variabele binnen die aanroep. Je hoeft width en height niet vooraf een waarde toe te kennen; de aanroep levert die. Een functie zonder parameters heeft nog steeds lege ronde haakjes nodig, zowel in haar definitie als bij haar aanroepen.

De volgorde kan de betekenis veranderen

def describe_pet(animal, name):
    print(name, "is a", animal)

describe_pet("cat", "Milo")
describe_pet("Milo", "cat")

De eerste aanroep drukt “Milo is a cat” af. De tweede drukt “cat is a Milo” af. Beide aanroepen zijn geldige Python, dus geen foutmelding wijst op de verwisselde betekenis. Lees de volgorde in de kop voordat je positionele argumenten kiest, vooral wanneer meerdere parameters dezelfde soort waarde accepteren.

Argumenten kunnen expressies zijn

Python evalueert elke argumentexpressie voordat de functie-inhoud begint. Met side = 6 geeft de aanroep rectangle_area(side, side) twee keer 6 door en drukt “Area: 36” af. De variabelenaam in de aanroepende code hoeft niet overeen te komen met een van de parameternamen. De aanroep rectangle_area(side + 1, 2) geeft 7 en 2 door; die geeft niet de tekst “side + 1” door.

Lees een fout over het aantal argumenten

Elke parameter zonder standaardwaarde heeft een argument nodig. Met de bovenstaande oppervlaktefunctie:

De eerste werpt TypeError: rectangle_area() missing 1 required positional argument: 'height' op. De tweede werpt TypeError: rectangle_area() takes 2 positional arguments but 3 were given op. Controleer de kop van de genoemde functie en tel vervolgens hoe de aanroep haar parameters invult.

Geef de soort waarde door die de taak nodig heeft

Python dwingt een type niet af alleen omdat een parameter width heet. rectangle_area("4", 2) drukt “Area: 44” af, omdat tekst vermenigvuldigen met een geheel getal die tekst herhaalt. Omdat input() tekst teruggeeft, zet je numerieke invoer om voordat je die doorgeeft:

width = float(input("Width: "))
rectangle_area(width, 2)

Hier zet float() de ingevoerde tekst om in een getal voordat de oppervlaktefunctie die ontvangt.

Een benoemd argument noemt in de aanroep de parameter waarvoor het bedoeld is. Dat maakt een aanroep leesbaarder wanneer meerdere waarden met elkaar kunnen worden verward. Python koppelt de naam van het argument aan de naam in de kop in plaats van de positie te gebruiken.

Koppel op naam

def describe_pet(animal, name):
    print(name, "is a", animal)

describe_pet(name="Milo", animal="cat")
describe_pet(animal="cat", name="Milo")

Beide aanroepen drukken “Milo is a cat” af. De volgorde van benoemde argumenten kan veranderen omdat bij elke waarde de parameter staat die ze invult. Op dezelfde manier is rectangle_area(width=4, height=2.5) leesbaar zonder te controleren welke afmeting eerst kwam.

De naam van een benoemd argument is geen nieuwe variabele in de aanroepende code. In describe_pet(name="Milo", animal="cat") leidt name= de waarde “Milo” naar de parameter. Dit kent “Milo” niet toe aan een variabele op moduleniveau met de naam name. Schrijf benoemde argumenten zonder spaties rond =, volgens de gebruikelijke Pythonstijl.

Combineer positionele en benoemde argumenten

describe_pet("cat", name="Milo")

Het eerste argument vult animal op positie in. Het benoemde argument vult name in, zodat elke parameter precies één waarde krijgt. Positionele argumenten moeten eerst komen. De aanroep describe_pet(name="Milo", "cat") wordt afgewezen met SyntaxError: positional argument follows keyword argument.

Vul om een gemengde aanroep te onderzoeken de positionele plaatsen van links naar rechts in en koppel daarna de benoemde argumenten. Controleer of geen plaats twee keer is ingevuld en geen verplichte plaats leeg blijft.

Herstel dubbele of onbekende namen

De dubbele waarde werpt TypeError: describe_pet() got multiple values for argument 'animal' op. De spelfout werpt TypeError: describe_pet() got an unexpected keyword argument 'nmae' op. Vergelijk namen teken voor teken; ook hoofdletters en kleine letters zijn van belang. Een andere volgorde van argumenten herstelt een dubbele toekenning aan één parameter niet.

Herken benoemde argumenten in ingebouwde functies

print("a", "b", "c", sep="-")
print("Loading", end="...")
print("done")

De eerste regel drukt “a-b-c” af. sep levert de tekst tussen de weergegeven waarden. De volgende twee aanroepen produceren “Loading...done” op één regel: end vervangt de gebruikelijke nieuwe regel na “Loading”.

Sommige ingebouwde functies accepteren ook benoemde argumenten; round(3.14159, ndigits=2) geeft bijvoorbeeld 3,14. Gebruik de parameternamen die zijn gedocumenteerd voor de functie die je aanroept. Een beschrijvend woord dat je zelf bedenkt, wordt niet herkend alleen omdat het bij de taak lijkt te passen.

Dankzij een standaardwaarde kan een aanroep een argument weglaten wanneer een gebruikelijke keuze geschikt is. Schrijf de standaardwaarde naast de parameter in de kop. Als je een argument opgeeft, vervangt dat de standaardwaarde voor die aanroep.

Maak een parameter optioneel

def greet(name, greeting="Hello"):
    print(greeting + ",", name + "!")

greet("Ana")
greet("Ana", "Welcome")
greet("Ana", greeting="Hi")

De uitvoer is “Hello, Ana!”, “Welcome, Ana!” en “Hi, Ana!”. name is verplicht omdat die parameter geen standaardwaarde heeft. greet() werpt daarom een TypeError op, ook al is de andere parameter optioneel.

In deze koppen staan verplichte parameters vóór parameters met standaardwaarden. def greet(greeting="Hello", name): is ongeldig. Python meldt een syntaxisfout over een parameter zonder standaardwaarde die volgt op een parameter met een standaardwaarde. Zet name vóór greeting om die verplicht te houden.

Wijzig één optionele keuze

def order_coffee(size, shots=1, milk="none"):
    print(size, "coffee,", shots, "shot(s), milk:", milk)

order_coffee("large", milk="oat")

Dit drukt “large coffee, 1 shot(s), milk: oat” af. Het benoemde argument bereikt milk, terwijl shots de waarde 1 behoudt. Een positionele aanroep order_coffee("medium", 2) wijzigt shots en laat milk op “none” staan. Bij koppeling op positie wordt een optionele parameter niet overgeslagen om de volgende te bereiken.

Ingebouwde functies bieden ook standaardwaarden: gewone print() scheidt waarden met een spatie en eindigt met een nieuwe regel. round(3.7) geeft het gehele getal 4; round(3.14159, 2) vraagt om twee decimalen en geeft 3,14.

Standaardwaarden worden aangemaakt wanneer de definitie wordt uitgevoerd

rate = 0.05

def price_with_tax(price, tax_rate=rate):
    return price * (1 + tax_rate)

rate = 0.08
print(price_with_tax(100))
print(price_with_tax(100, rate))

De standaardwaarde slaat de waarde 0,05 op wanneer def wordt uitgevoerd. Als je rate later wijzigt, verandert die opgeslagen standaardwaarde niet. De aanroepen drukken “105.0” en “108.0” af: alleen de tweede geeft het nieuwe tarief expliciet door.

Voorkom dat je per ongeluk een lijst deelt

Een lijst bevat elementen en append voegt een element toe aan diezelfde lijst. Bij een lijst als standaardwaarde delen alle aanroepen die het argument weglaten die lijst:

def add_item(item, basket=[]):
    basket.append(item)
    print(basket)

add_item("apple")
add_item("pear")

Dit drukt ['apple'] af en daarna ['apple', 'pear']. De standaardlijst is één keer gemaakt, niet één keer per aanroep. Gebruik None als signaal om voor elk weggelaten argument een nieuwe lijst te maken:

def add_item(item, basket=None):
    if basket is None:
        basket = []
    basket.append(item)
    print(basket)

Nu drukken die twee aanroepen ['apple'] en ['pear'] af. Een expliciet doorgegeven lijst wordt nog steeds gebruikt zoals die is. Beschrijf optionele parameters en hun standaardwaarden in de docstring, zodat gebruikers weten welke waarden gelden als ze argumenten weglaten.

Een functie kan een resultaat teruggeven dat de aanroepende code kan gebruiken. De return-instructie beëindigt de aanroep en geeft haar waarde terug. Op het punt van de aanroep staat de aanroep voor die retourwaarde.

Sla resultaten op en combineer ze

def rectangle_area(width, height):
    return width * height

area = rectangle_area(4, 2.5)
print(area)
print(rectangle_area(3, 4) + rectangle_area(2, 5))

De eerste aanroep geeft 10,0 terug, dat aan area wordt toegekend; de eerste print toont die waarde. Op de laatste regel geven de twee aanroepen 12 en 10 terug. Python telt die resultaten op en drukt “22” af. De functie zelf bevat geen print, zodat ze een resultaat kan leveren om op te slaan of als onderdeel van een grotere berekening.

Een retourwaarde kan ook in een voorwaarde worden getest of aan een andere functie worden doorgegeven. Zo staat de taak van de berekening los van de beslissing van de aanroepende code over het gebruik van het antwoord.

Afdrukken en teruggeven hebben verschillende taken

def double_print(n):
    print(n * 2)

result = double_print(5)
print(result)

De aanroep toont “10”, maar dat weergegeven getal wordt niet als resultaat teruggegeven. double_print bereikt het einde van haar inhoud en geeft dus None terug. De laatste regel drukt daarom “None” af.

double_print(5) + 1 drukt eerst “10” af en werpt daarna TypeError: unsupported operand type(s) for +: 'NoneType' and 'int' op. Vervang de inhoud door return n * 2 wanneer de aanroepende code het dubbele getal nodig heeft. Een functie die alleen bedoeld is om een effect te hebben, zoals een bericht tonen, kan terecht None teruggeven; zulke functies worden soms functies zonder bruikbare retourwaarde genoemd. Een functie met een bruikbaar teruggegeven resultaat wordt soms een functie met een bruikbare retourwaarde genoemd.

Stop bij de eerste uitgevoerde return

def to_fahrenheit(celsius):
    return celsius * 9 / 5 + 32
    print("Converted")

print(to_fahrenheit(20))

Dit drukt “68.0” af. De print binnen de inhoud wordt nooit bereikt omdat return de aanroep al heeft beëindigd. Verwijder die onbereikbare instructie of zet een noodzakelijke actie vóór de return. De omzetting geeft zwevendekommagetallen terug omdat / een zwevendekommagetal oplevert. De invoerwaarden 100 en -40 geven 212,0 en -40,0.

Een kale return zonder expressie beëindigt ook een aanroep en geeft None terug. Elke functieaanroep heeft een resultaat, ook wanneer geen bruikbare waarde is opgegeven.

Maak resultaten zichtbaar in een programmabestand

Een losse rectangle_area(3, 4) berekent in een bestand 12 en gooit het ongebruikte resultaat daarna weg. Gebruik print(rectangle_area(3, 4)) om het te tonen of ken het toe aan een variabele. De interactieve shell toont expressieresultaten behalve None, zodat een geslaagde proef in de shell er anders uit kan zien dan dezelfde regel uitvoeren in een bestand.

Verschillende invoerwaarden kunnen verschillende antwoorden vereisen. Een functie kan meerdere return-instructies hebben, maar een aanroep stopt bij de eerste die wordt uitgevoerd. Volg het werkelijke pad door de takken en lussen om het resultaat te vinden.

Zet overlappende tests in de juiste volgorde

def letter_grade(score):
    if score >= 90:
        return "A"
    if score >= 80:
        return "B"
    if score >= 70:
        return "C"
    return "F"

Voor 85 is de eerste test onwaar en de tweede waar. De functie geeft “B” terug zonder de overige voorwaarden te testen. Voor 42 zijn alle drie de tests onwaar, dus levert de laatste return “F”. Afzonderlijke if-instructies werken omdat elke geslaagde tak de aanroep beëindigt.

De hoogste drempelwaarde moet hier eerst worden gecontroleerd. Als score >= 70 eerst kwam, zou een score van 95 “C” teruggeven. Bij overlappende bereiken kan een vroege brede overeenkomst een later, specifieker antwoord verhullen.

Dek het pad zonder passende tak af

def sign(n):
    if n > 0:
        return "positive"
    elif n < 0:
        return "negative"
    return "zero"

De laatste regel verwerkt nul. Zonder die regel zou sign(0) het einde bereiken en None teruggeven. Volg een invoerwaarde uit elke tak en elk overblijvend geval; als je alleen positieve en negatieve invoer test, mis je deze leemte.

Geef een booleaanse vergelijking terug

def is_even(n):
    return n % 2 == 0

if is_even(10):
    print("Even")

De vergelijking levert al True of False op. is_even(10) geeft True terug, terwijl is_even(7) False teruggeeft. Gebruik het resultaat rechtstreeks in een voorwaarde. Een extra == True helpt de test niet.

Rond een zoekactie af voordat je meldt dat er geen overeenkomst is

def smallest_divisor(n):
    for d in range(2, n):
        if n % d == 0:
            return d
    return n

Voor 91 voldoen de kandidaten 2 tot en met 6 niet, waarna 7 het getal zonder rest deelt. De return van 7 beëindigt zowel de lus als de functie. Voor 13 vindt de lus geen deler, dus geeft de laatste return 13 terug.

Een test op priemgetallen moet de zoekactie laten doorgaan nadat een kandidaat niet voldoet:

def is_prime(n):
    if n < 2:
        return False
    for d in range(2, n):
        if n % d == 0:
            return False
    return True

De laatste True staat buiten de lus. Als je die in een else binnen de lus zou zetten, zou de functie al na controle van de eerste kandidaat terugkeren: 9 zou ten onrechte worden aanvaard omdat het niet deelbaar is door 2. Met de gecorrigeerde functie geven 9 en 1 False terug; 2, 7 en 97 geven True terug. Voor 2 heeft de lus geen kandidaten en bereikt de uitvoering de laatste True.

Geef twee waarden terug

def share(total, people):
    return total // people, total % people

each, left = share(17, 5)
print(each, left)

De aanroep geeft één tuple terug, een gegroepeerd resultaat met 3 en 2. De toekenning pakt die uit in twee namen, zodat de uitvoer “3 2” is. Als je de aanroep rechtstreeks afdrukt, verschijnt “(3, 2)”. Het aantal namen moet overeenkomen met het aantal waarden dat wordt uitgepakt.

Combineer aanroepen van binnen naar buiten

def add(a, b):
    return a + b

def to_fahrenheit(celsius):
    return celsius * 9 / 5 + 32

print(to_fahrenheit(add(10, 15)))

add geeft eerst 25 terug. Dat wordt het argument voor to_fahrenheit, die 77,0 teruggeeft. Ten slotte toont print “77.0”. Elke binnenste aanroep moet de waarde teruggeven die de volgende functie nodig heeft.

Geldigheidsbereik beschrijft waar een naam kan worden gebruikt. Parameters en namen waaraan binnen een functie een waarde wordt toegekend, zijn lokaal voor de aanroep van die functie. Aanroepende code en een functie kunnen vergelijkbare namen gebruiken zonder dezelfde lokale variabelen te delen.

Houd lokale namen binnen hun aanroep

def make_greeting():
    message = "Hi"
    print(message)

make_greeting()

Dit drukt “Hi” af. Als je print(message) na de aanroep toevoegt, wordt NameError: name 'message' is not defined opgeworpen: de lokale naam is daar niet beschikbaar. Geef de waarde terug en sla die op om haar beschikbaar te maken voor de aanroepende code:

def make_greeting():
    return "Hi"

message = make_greeting()
print(message)

De message op moduleniveau is een nieuwe variabele in de aanroepende code die de retourwaarde ontvangt. De functie maakt haar eigen lokale namen niet buiten de functie zichtbaar.

Elke aanroep krijgt nieuwe lokale variabelen. Als een functie-inhoud count = 0 instelt, er 1 bij optelt en die afdrukt, drukken twee aanroepen “1” en “1” af. De tweede aanroep gaat niet verder met de teller van de eerste aanroep. Verschillende functies kunnen ook onafhankelijk van elkaar lokale namen zoals total gebruiken.

Volg naamverhulling en het opzoeken van namen

x = 10

def show():
    x = 5
    print(x)

show()
print(x)

De uitvoer is eerst “5” en dan “10”. De lokale x verhult de globale x binnen show; de toekenning wijzigt de waarde op moduleniveau niet. Een globale variabele hoort bij het globale bereik van het bestand. Gewone toekenningen buiten functies maken globale variabelen aan.

Voor een functie die op moduleniveau is gedefinieerd, zoekt Python een naam eerst onder haar lokale namen, dan onder de globale namen van het bestand en daarna onder ingebouwde namen zoals print. De eerste overeenkomst wordt gebruikt. Lokale en globale namen zijn dus verschillende plaatsen om te controleren wanneer een waarde verkeerd lijkt.

Een parameter opnieuw toekennen laat de naam van de aanroepende code ongemoeid

def add_bonus(points):
    points = points + 10
    print(points)

score = 50
add_bonus(score)
print(score)

points begint met de waarde 50. Door de lokale hernieuwde toekenning wordt die 60, dus is de eerste uitvoer “60”. De score van de aanroepende code is nog steeds 50. Gebruik een functie die points + 10 teruggeeft en schrijf daarna score = add_bonus(score) om die naam expliciet bij te werken.

Een lijst wijzigen is een andere bewerking

Een lijst kan via twee namen worden gedeeld:

def add_guest(guests, name):
    guests.append(name)

party = ["Ana"]
add_guest(party, "Ben")
print(party)

De parameter guests en de variabele party van de aanroepende code verwijzen naar dezelfde lijst. append wijzigt de inhoud van die lijst, dus is de uitvoer “['Ana', 'Ben']”. Met guests = [] binnen de functie zou daarentegen alleen de lokale naam naar een nieuwe lijst verwijzen; party zou nog steeds naar de oorspronkelijke lijst verwijzen. Vraag je bij het volgen van een lijstargument af of de regel het gedeelde object wijzigt of alleen opnieuw een waarde aan een lokale naam toekent.

Een functie kan een globale naam lezen zonder declaratie. Voor toekenning aan een naam in haar inhoud geldt een andere regel; deze bewerkingen verwarren is een veelvoorkomende oorzaak van UnboundLocalError.

Lees een vaste instelling

TAX_RATE = 0.25

def tax(amount):
    return amount * TAX_RATE

print(tax(80))

De uitvoer is “20.0”. amount is lokaal; TAX_RATE wordt gelezen uit de globale namen van het bestand. Hoofdletters duiden volgens afspraak een constante aan en geven aan dat het programma de instelling vast moet laten. Python dwingt die afspraak niet af.

Toekenning maakt een naam lokaal in de hele inhoud

total = 0

def add_to_total(amount):
    total = total + amount

add_to_total(5)

Door de toekenning is total in heel add_to_total lokaal. Om de rechterkant te berekenen, probeert Python die lokale naam te lezen voordat deze een waarde heeft. Het valt niet terug op de globale total. De aanroep werpt UnboundLocalError: cannot access local variable 'total' where it is not associated with a value op.

De beslissing is gebaseerd op de hele inhoud, niet alleen op regels die al zijn uitgevoerd. Een inhoud met print(count) gevolgd door count = 10 behandelt count ook op de printregel als lokaal. Een globale count kan de ontbrekende lokale waarde niet leveren.

Declareer een bewuste globale toekenning

total = 0

def add_to_total(amount):
    global total
    total = total + amount

add_to_total(5)
add_to_total(7)
print(total)

Nu verwijzen zowel het lezen als de toekenning naar de globale naam, dus is de uitvoer “12”. Zet global total vóór elk gebruik van total in de functie. De naam vóór de declaratie gebruiken is een syntaxisfout.

Een declaratie alleen maakt geen waarde aan. Een daaropvolgende toekenning kan een globale variabele aanmaken die nog niet bestond: een functie-inhoud met global level en daarna level = 1 maakt bij aanroep de globale level aan.

Toon de verandering via invoer en een resultaat

Je kunt hetzelfde lopende totaal schrijven met een expliciete interface:

def add_to_total(total, amount):
    return total + amount

total = 0
total = add_to_total(total, 5)
total = add_to_total(total, 7)
print(total)

Dit drukt ook “12” af. Elke aanroep laat zien dat de oude waarde wordt doorgegeven en de toekenning laat zien waar de nieuwe waarde naartoe gaat. Je kunt add_to_total(10, 3) afzonderlijk controleren zonder eerst een verborgen globale toestand in te stellen. Als meerdere functies dezelfde globale variabele wijzigen, hangt hun gedrag af van de volgorde waarin ze worden uitgevoerd.

Bij het lezen van een gedeelde lijst en het wijzigen van haar inhoud gebruik je de bestaande referentie. Als je die globale naam naar een andere lijst laat verwijzen, is dat een toekenning en geldt dus de toekenningsregel.

Wie een functie aanroept, moet weten wat haar taak is zonder de volledige implementatie te lezen. Een docstring geeft die beschrijving. Python herkent een string als de docstring van de functie wanneer die de eerste instructie in de functie-inhoud is.

Schrijf eerst een korte beschrijving

def to_fahrenheit(celsius):
    """Convert a temperature from degrees Celsius to degrees Fahrenheit."""
    return celsius * 9 / 5 + 32

print(to_fahrenheit.__doc__)

De uitvoer is de zin tussen de aanhalingstekens. Python slaat de docstring op in __doc__; de driedubbele aanhalingstekens maken geen deel uit van de opgeslagen zin. help(to_fahrenheit) toont de beschrijving samen met de signatuur to_fahrenheit(celsius). Geef de functienaam door aan help, zonder de functie aan te roepen.

De gebruikelijke conventie is driedubbele dubbele aanhalingstekens, ook voor een docstring van één regel. Begin met een opdracht zoals “Geef de oppervlakte van een rechthoek terug.” en eindig met een punt. Houd een korte beschrijving en de afsluitende aanhalingstekens op één regel. Je hoeft de functienaam en de parameterlijst niet te herhalen, omdat de helpweergave die al bevat.

Voeg details toe als de aanroepende code die nodig heeft

def split_bill(total, people, tip_rate=0.2):
    """Return each person's share of a bill, including the tip.

    total: the bill before the tip
    people: the number of people sharing the bill
    tip_rate: the tip as a fraction of the bill (default 0.2)
    """
    return total * (1 + tip_rate) / people

De eerste regel vermeldt het resultaat. Een lege regel scheidt die van details over de invoer. De standaardwaarde is gedocumenteerd als 0,2, een deel van de rekening; dit voorkomt dat iemand die de functie aanroept 20 als de bedoelde waarde voor een fooi van 20 procent ziet. De afsluitende aanhalingstekens van een docstring van meerdere regels staan op een eigen regel.

Bij split_bill(84, 4) past de functie de standaardfooi toe en geeft ze 25,2 terug. Wie de functie aanroept, kan zien wat de drie invoerwaarden betekenen voordat die argumenten kiest. Vermeld eenheden wanneer ze van belang zijn en beschrijf effecten zoals afdrukken, zodat zowel het resultaat als het zichtbare gedrag kan worden voorspeld.

Houd documentatie en commentaar uit elkaar

Een string na een toekenning of een andere instructie in de inhoud is niet de docstring van de functie. Het is een ongebruikte stringexpressie en __doc__ is None als er geen docstring als eerste instructie staat. Ook #-commentaar wordt niet de beschrijving in de helpweergave.

Schrijf de samenvatting terwijl je de taak van de functie bepaalt. Als de zin meerdere, niet-samenhangende acties nodig heeft, overweeg dan of de functie moet worden opgesplitst. Werk de docstring tegelijk bij wanneer je parameters, standaardwaarden, retourwaarden of afgedrukte uitvoer wijzigt; wie de functie aanroept, vertrouwt erop als onderdeel van de interface.

Decompositie betekent dat je een taak opdeelt in kleinere taken. Elke functie is verantwoordelijk voor één taak, met duidelijke invoer en een duidelijk resultaat of effect. Het hoofdprogramma kan dan lezen als een korte reeks benoemde stappen.

Plan de gegevens voordat je de functie-inhoud schrijft

Onderscheid voor een programma dat een gemiddelde toetsscore en een lettercijfer rapporteert drie soorten werk: scores lezen, een gemiddelde berekenen en een lettercijfer kiezen. Bepaal wat elke hulpfunctie ontvangt en teruggeeft. Houd de weergave in main, waar de resultaten samenkomen.

def get_score(prompt):
    return float(input(prompt))

def average(a, b, c):
    return (a + b + c) / 3

def letter_grade(score):
    if score >= 90:
        return "A"
    if score >= 80:
        return "B"
    if score >= 70:
        return "C"
    return "F"

def main():
    first = get_score("Test 1: ")
    second = get_score("Test 2: ")
    third = get_score("Test 3: ")
    avg = average(first, second, third)
    print("Average:", round(avg, 1), "Grade:", letter_grade(avg))

main()

Bij de scores 78, 92 en 85 geeft average 85,0 terug. Dat resultaat wordt het argument voor letter_grade, die “B” teruggeeft. De weergave is “Average: 85.0 Grade: B”.

main coördineert de volgorde; deze functie hoeft niet te weten hoe letter_grade haar antwoord kiest. Een functie gebruiken via haar taak en interface, zonder elke instructie in de inhoud te volgen, is procedurele abstractie. Je gebruikt print al op deze manier.

Geef de aanroepende code een duidelijke interface

De interface van een functie bestaat uit haar naam, parameters, retourwaarde en gedocumenteerde gedrag. average(a, b, c) vereist drie getallen en geeft hun gemiddelde terug. De aanroepende code hoeft geen invoervraag te lezen of afgedrukte tekst op te vangen om dat getal te krijgen. Je kunt de berekening herschrijven met behoud van de afgesproken invoer en uitvoer, en bestaande aanroepen blijven werken.

Gebruik namen zoals calculate_total en print_receipt voor acties, en is_even of has_discount voor booleaanse vragen. Parameternamen zoals price en quantity leggen uit welke waarden op elke plaats horen. Namen van één letter kunnen geschikt zijn wanneer hun betekenis duidelijk is, zoals bij de drie invoerwaarden voor average.

Maak parameters van herhaalde onderdelen

Als verschillende delen van een programma verschillende titels tussen dezelfde regels met gelijktekens afdrukken, maak dan van de titel een parameter voor print_heading(title). De herhaalde structuur hoort in één functie-inhoud, terwijl de wisselende tekst in de aanroepen hoort. Een latere wijziging van de regellengte vraagt dan maar één aanpassing.

Kies functiegrenzen die taken gemakkelijker te begrijpen of opnieuw te gebruiken maken. Als je elke instructie in één lange main zet, verhul je de kleinere taken. Als je elke eenvoudige expressie opsplitst in een hulpfunctie die één keer wordt gebruikt, kun je namen toevoegen zonder de leesbaarheid te verbeteren. Een nuttige test is of een korte zin elke taak en haar invoer en uitvoer kan beschrijven.

Eindig het bestand na alle definities met de daadwerkelijke aanroep main(). Een programma dat alleen definities bevat, maakt zijn functies aan en eindigt zonder hun inhoud uit te voeren.

Als je meerdere functies bouwt voordat je er één uitvoert, is een fout moeilijker te lokaliseren. Incrementele ontwikkeling betekent dat je een klein onderdeel schrijft, het controleert en daarna het volgende onderdeel toevoegt. Je houdt een werkend programma en beperkt tegelijk de hoeveelheid nieuwe code die je moet onderzoeken.

Gebruik tijdens het plannen een functieskelet

Een functieskelet heeft de bedoelde kop en een tijdelijke inhoud. Een docstring en pass houden de definitie geldig, maar de functie geeft None terug totdat je haar implementeert. Een vaste retourwaarde kan helpen om de weergave van de aanroepende code te testen, zonder te stellen dat de echte berekening al werkt.

Begin met een rekenende hulpfunctie waarvan je het resultaat onafhankelijk kunt uitrekenen. Zodra die zich correct gedraagt, verbind je haar met de volgende hulpfunctie. Bewaar interactieve invoer voor later, wanneer de berekeningen met rechtstreekse aanroepen kunnen worden gecontroleerd.

Bepaal verwachte resultaten vóór de uitvoering

Met de functies average en letter_grade hebben de scores 70, 75 en 72 een gemiddelde van ongeveer 72,33, dus is hun verwachte lettercijfer “C”. Controleer beide stappen:

print(average(70, 75, 72))
print(letter_grade(average(70, 75, 72)) == "C")

De uitvoer is “72.33333333333333” en “True”. De vergelijking test het verwachte lettercijfer rechtstreeks; als je alleen naar de eigen uitvoer van een programma kijkt zonder een onafhankelijke verwachting, kan een aannemelijk verkeerd antwoord onopgemerkt blijven.

Test grenzen en gewone invoer

Test voor een drempelwaarde van 90 de waarden 90 en 89,9. De juiste functie voor lettercijfers geeft “A” en “B” terug. Als de eerste voorwaarde score > 90 was, zou alleen de controle precies op de grens laten zien dat 90 ten onrechte doorgaat naar de volgende test.

Neem een typische waarde, exacte grenzen, nabijgelegen waarden en extreme invoer op die de functie moet kunnen verwerken. Bij de functie voor lettercijfers testen 70 en 0 de laagste grens voor een voldoende en het laatste pad naar “F”. Een controle zoals print(letter_grade(85) == "B") is eenvoudig omdat de functie een waarde aanneemt en haar resultaat teruggeeft.

Lees de stacktrace en onderzoek de binnenkomende waarde

Stel dat main de functie letter_grade(input("Score: ")) aanroept. Als je “85” invoert, komt een string terecht in een vergelijking met een getal. De laatste fout is TypeError: '>=' not supported between instances of 'str' and 'int'. De stacktrace wijst naar de vergelijking binnen de hulpfunctie, terwijl een eerdere aanroepregel naar main wijst.

De fout treedt op bij de vergelijking, maar de oplossing hoort op de plaats waar de invoer wordt voorbereid: zet die om met float() voordat je haar doorgeeft. Een tijdelijke eerste regel print("letter_grade got", score) helpt onverwachte invoer zichtbaar te maken. Als het type onduidelijk is, onderzoek dan de aanroepende code en de conversie die daarin wordt gebruikt. Verwijder diagnostische uitvoerinstructies nadat de programmeerfout is hersteld.

Koppel verschijnselen aan waarschijnlijke oorzaken

Voer na het herstellen van een hulpfunctie opnieuw de controles uit die de betrokken paden testen, evenals de aanroepende code die haar met het programma verbindt.