<jupyter_start><jupyter_text>User InputDet er utrolig mye man kan gjøre med user input, men vi skal her begrense oss til å ta inn enkle variabler fra bruker. Programmet skal være ferdig skrevet, men nye variabler kan gis hver gang man kjører programmet, uten å endre koden.**OBS!** All user input kommer inn som `String`. Hvis input er tall som skal brukes til beregninger, må disse gjøres om til riktig datatype, ofte `int` eller `float`. Dette gjøres slik som vist på eksempelet under. Merk at `int` og `str` ser like ut, uten at de er det. `a_int` kan brukes i utregninger, mens `a` kan ikke det.<jupyter_code>a = "5"     # This is the number 5 as type String
print(a, type(a))

a_int = int(a)  # casting a to int 
print(a_int, type(a_int))

a_float = float(a) # casting a to float
print(a_float, type(a_float))<jupyter_output>5 <class 'str'>
5 <class 'int'>
5.0 <class 'float'><jupyter_text>Spørre bruker om inputDu kan printe ut spørsmål i terminalvinduet ved å bruke `input()`. Programmet venter da til bruker skriver noe og trykker enter. Merk at funksjonen heter `input()` i Python 3 og `raw_input()` i Python 2. Under ligger et enkelt eksempel på hvordan `input()` fungerer. Legg merke til at dersom du bruker en `str` som argument i `input()`-funksjonen, vil denne printes ut i terminal før bruker skriver noe.<jupyter_code>word = input(">>")
print("You said '%s'" %word)<jupyter_output>>>spam
You said 'spam'<jupyter_text>Input gjennom kommandolinjenInput gjennom kommandolinjen er variabler som spesifiseres samtidig som du kjører programmet. Disse kalles argumenter. Dette gjøres ved å legge til tall eller ord etter filnavnet. Det kan legges til flere argumenter, disse separeres med mellomrom.Argumentene hentes ut ved å bruke `sys.argv`, som er en liste. Det første elementet i `argv`, altså på plass `[0]`, er filnavnet. Derfor begynner man å indeksere på plass `[1]` når argumentene hentes ut. Eksempelet under illustrerer enkelt hvordan argumenter kan hentes fra kommandolinjen.<jupyter_code>%%file cml.py
from sys import argv

filename = argv[0]
print("the filename is %s" %filename)

word = argv[1]
number = float(word)
print("The number you provided was %.2f" %number)
%run cml.py 3.14159265359<jupyter_output>the filename is cml.py
The number you provided was 3.14<jupyter_text>Håndtering av `Error`Feilmeldinger kan håndteres slik at programmet ikke kræsjer. Slik kan det gis flere sjanser til å fullføre hele programmet. Det kan også være bra med en egendefinert feilmelding. Hvis programmet skal avsluttes etter at feilen er fanget opp, kan `sys.exit()` brukes.Håndetering av feilmeldinger gjøres ved å bruke `try` og `except`. Som vist i eksempelet under, kan flere forskjellige typer `Error` fanges opp i samme `try`. En mer generell metode som fanger opp alle feil samtidig er `except Error`, men da behandles alle feil likt. Et eksempel på feil er at bruker gir uventet input, slik som å skrive `"to"` istedenfor `2`. Du får da en `TypeError`.```try:     write the code that may create Errorsexcept IndexError:     Handle this errorexcept ValueError:     Handle this error```  `raise`Du kan også tvinge frem dine egne feilmeldinger ved å bruke `rasie Error`. Et eksempel er gitt under.<jupyter_code>raise ValueError("Write your own message here")<jupyter_output><empty_output><jupyter_text>Lese og skrive fil i PythonFor å kunne lese og skrive til en tekstfil i Python, må filen først åpnes. I IN1900 blir det undervist to forskjellige måter å åpne tekstfiler på i Python. Under kommer jeg kun til å bruke `with open()`. Dette er en personlig preferanse. Denne måten krever indentering, men man slipper å tenke på å lukke filen etter den er åpnet. Begge måter som er forelest i IN1900 kan selvfølgelig brukes både på obliger og eksamen. Skrive til fil**`with open(filename, "w") as outfile:`**`"w"` står for write, og indikerer at du skal skrive til filen. Det er en konvensjon å kalle filer du skriver til for `outfile`.`outfile.write()` brukes til å skrive til fil. Du kan formatere det du skriver til fil på samme måte som du formatterer i `print()`, altså ved å bruke `\%`.Tegnet newline `"\n"` brukes for å markere en ny linje. Hvis du ikke bruker dette, kommer alt på én linje i tekstfilen du skriver!Under ligger et eksempel på skriving til en tekstfil i Python.<jupyter_code>with open('eksempel.txt', "w") as outfile:
    outfile.write("Paracetamol contains:\n")
    outfile.write("8 C, M is 12.011 g/mol\n")
    outfile.write("9 H, M is 1.0079 g/mol\n")
    outfile.write("1 N, M is 14.007 g/mol\n")
    outfile.write("2 O, M is 15.999 g/mol")<jupyter_output><empty_output><jupyter_text>Lese fil**`with open(filename, "r") as infile:`**Her står `"r"` for read, og indikerer at du skal lese filen. Det er en konvensjon å kalle filer du leser for `infile`.Under er det enkleste eksempelet av lesing av fil. Hver linje av filen som ble skrevet i forrige kodesnutt printes ut.<jupyter_code>with open('eksempel.txt', "r") as infile:
    for line in infile:
        print(line.strip())<jupyter_output>Paracetamol contains:
8 C, M is 12.011 g/mol
9 H, M is 1.0079 g/mol
1 N, M is 14.007 g/mol
2 O, M is 15.999 g/mol<jupyter_text>`infile.readline()` leser én linje i filen. Hver gang du bruker `readline()`, kommer det derfor en ny linje. **Filen leses fra første linje og nedover.** Alle linjer vil kun leses én gang. Dersom linjen skal brukes til noe, må den derfor lagres som en variabel. **Alle linjer er av typen `String`.****`strip()`** brukes til å ta bort `char`s i begynnelsen og enden av en `String`. Hvis ikke noe er spesifisert, tar den bort mellomrom, tabs og newlines (`\n`).**`split()`** tar en `String` og deler den opp i en liste. Hvis ingenting er spesifisert, deler den på mellomrom. Denne funksjonen brukes mye når filer leses i Python. Husk at alle elementene i en liste laget av `split()` også er av typen `String`. `infile` kan itereres gjennom på samme måte som en liste. På denne måten kan du få Pythonkoden til å si: for hver linje i filen: gjør følgende. **Merk at de linjene som allerede har blitt lest, ikke vil komme med i løkken.**Under ligger et eksempel på lesing av fil. Filen som blir lest, er den som ble generert i forrige avsnitt. Merk at den første linjen blir behandlet annerledes. Her printes det også mye. Dette er kun ment til å illustrere hva som skjer når du bruker `readline()`, `strip()` og `split()`. I løkken behandles linje 2 - 5 likt. Her regnes det ut den molare massen til molekylet beskrevet i filen. For hver linje hentes `n` og `this_M` ut. `n` er antall atomer spesifisert på linjen i molekylet, og er det første elementet på linjen og i listen (`[0]`). `this_M` er den molare massen til atomet på linjen, og ligger som nest siste elementet på linjen og i listen (`[-2]`). For å regne ut molekylmassebidraget til atomet på linjen, ganges den molare massen med antall atomer. Summen av bidraget fra alle atomene utgjør den molare massen til molekylet.<jupyter_code>with open('eksempel.txt', "r") as infile:
    first_line = infile.readline().strip()
    print("first line: ", first_line)
    first_line_list = first_line.split()
    print("list of the first line: ", first_line_list)
    name = first_line_list[0]
    M = 0
    for line in infile:
        this_line = line.strip().split()
        n = int(this_line[0])
        this_M = float(this_line[-2])
        M += n*this_M
        
print("The molas mass of %s is %.2f g/mol" %(name, M))<jupyter_output>first line:  Paracetamol contains:
list of the first line:  ['Paracetamol', 'contains:']
The molas mass of Paracetamol is 151.16 g/mol
{'fraction_non_alphanumeric': 0.08655495447948278, 'fraction_numerical': 0.013062409288824383, 'mean_word_length': 4.433691756272402, 'pattern_counts': {'":': 0, '<': 27, '<?xml version=': 0, '>': 31, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '7', 'dir': 'jupyter-structured-clean-dedup', 'id': '630292', 'license': 'BSD-2-Clause', 'n_tokens_mistral': 2792, 'n_tokens_neox': 2664, 'n_words': 1118, 'path': 'originals/Python_04_user_input.ipynb', 'repo_name': 'scriptotek/programming-for-librarians', 'size': '7579'}