Ditt eget bibliotek

Valideraren, nu på riktigt

I Kraschsäkring byggde du en loop som frågade om tills svaret dög, med ett break sist i try-blocket. Den fungerade, men den satt fast där du skrev den. Skulle tre olika ställen i programmet läsa in ett tal fick du klistra in samma sex rader tre gånger.

Med return går det att paketera om.

Nu räcker en enda funktion. Kör den, inmatningsfönstret innehåller redan ett svar som inte duger följt av ett som gör det:

def läs_int(prompt="Ange ett heltal: "):
    while True:
        try:
            return int(input(prompt))
        except ValueError:
            print("Det är inte ett heltal. Försök igen.")

ålder = läs_int("Hur gammal är du? ")
print(f"Du är {ålder} år.")

Lägg till fler rader i inmatningsfönstret om du vill se den fråga om flera gånger. Tar raderna slut innan du gett ett giltigt tal har sandlådan inget mer att mata in, och då avbryts körningen. I terminalen finns ingen sådan gräns, där frågar den tills du svarar.

Läs vad som hände med break. Den behövs inte längre, för return gör två saker samtidigt: avslutar loopen och lämnar värdet vidare. Går inläsningen fel nås aldrig return, och loopen går ett varv till, precis som förut.

Anropet ser ut som vilken inläsning som helst, men kan aldrig krascha:

val = läs_int("Välj menyalternativ (1-3): ")

Det är först nu Valideraren blir det den utger sig för att vara: ett löfte till den som anropar. Funktionen garanterar att det som kommer tillbaka är ett heltal, oavsett vad användaren hittar på. Anroparen behöver inte kontrollera något.

Ditt första bibliotek

Det här är mer än lösningen på ett problem. Det är den första funktionen du skrivit som har nytta långt utanför koden den skrevs för.

def läs_int(prompt="Ange ett heltal: "):
    while True:
        try:
            return int(input(prompt))
        except ValueError:
            print("Det är inte ett heltal. Försök igen.")

def läs_float(prompt="Ange ett tal: "):
    while True:
        try:
            return float(input(prompt))
        except ValueError:
            print("Det är inte ett giltigt tal. Försök igen.")

Det är precis vad ett bibliotek är: funktioner du skriver en gång och använder många gånger. random och math är samma sak, byggda av någon annan. Skillnaden är att de här två är dina.

Att importera din egen fil

Skapa filen inmatning.py i samma mapp som programmet som ska använda den, och lägg de två funktionerna där. Filen ska innehålla funktionerna och ingenting annat, ingen kod som körs när filen laddas.

Överst i ditt program skriver du sedan:

from inmatning import läs_int, läs_float

Det är samma import som i Slump & moduler, med två skillnader. Modulen är din egen fil i stället för en av Pythons, och modulnamnet är filnamnet utan .py.

Formen from modul import namn plockar in enskilda funktioner så att du anropar dem direkt, läs_int(...), utan modulnamn framför. Skriver du i stället import inmatning heter anropet inmatning.läs_int(...), precis som random.randint(...). Båda fungerar, den första är bekvämare när du bara behöver ett par funktioner.

Python letar efter inmatning.py i samma mapp som filen du kör. Ligger de i olika mappar hittar Python inte modulen och du får ModuleNotFoundError med modulnamnet i meddelandet.

Det här är inte en parentes. I Milstolpe: Caesar-chiffret skriver du en caesar.py med funktioner som returnerar krypterad och dekrypterad text, och i Etik & brute force importerar du dem in i ett helt nytt program som försöker knäcka chiffret. Utan den här delen hade du fått klistra in koden en gång till.