Hjelp til Python

Kjøring av pythonprogrammer

Python startes fra startmenyen ved å søke opp Spyder. Det er også mulig å bruke andre tilgjengelige program som f.eks Pycharm eller IDLE.

Python sin console kan startes fra terminalen ved å skrive inn følgende:

 python3

Da er man inne på python sin terminal. Hvis man vil gå ut av python terminalen skriver man

 exit()

Hvis man vil kjøre en fil rett fra terminalen, skriver man følgende:

 python3 filnavn.py

For å redigere filen skriver man:

 vi filename.py

For å gjøre endringer trykker man på i (som står for insert). Etter at en har gjort de nødvendige endringer trykker man på Esc og så taster inn

  :wq //for å gå ut og lagre
  :q! //for å gå ut uten å lagre

Hvis man velger å kjøre scriptet i terminalen og scriptet skal produsere plots, er måten å gjøre det på å skrive

  plt.savefig('filename.png')

Lange beregninger

Hvis man har program som tar lang tid å kjøre kan man bruke Markov (se mer i menyen til venstre under 'Markov'). Hvis man ønsker å lagre plot fra scriptet som kjører i tmux må man skrive en ekstra linje med kode før man importerer pyplot men etter å ha importert matplotlib.

     matplotlib.use('Agg')
     

Man kan lese mer om dette her.

Filbehandling

Informasjonen er i bunn og grunn remser av heltall, som i seg selv kan representere så mangt. Vi trenger et tegnsett (eng: encoding) for å angi hvordan informasjonen skal tolkes, og det er viktig at tekstdataen leses med samme tegnsett som det ble skrevet med. For å sikre at programmet vårt kommuniserer på riktig vis bruker programmeringsspråkene såkalte fil-strømmer/fil-håndtak. (eng: file stream / file handle). Stdin, stdout og stderr er eksempler på disse:

  • Stdin brukes når vi ønsker å gi input til programmet fra tastaturet.
  • Stdout brukes når vi ønsker å skrive fra programmet til skjerm.
  • Stderr brukes når vi ønsker å skrive feilmeldinger fra programmet.

Stderr og stdout skriver gjerne begge til terminalen, men ved å ha to separate strømmer har vi større handlefrihet i å skille mellom feilmeldinger og vanlig output.

Disse overføringskanalene skriver til faste mottakere hver gang, og er gjerne automatisk åpne ettersom det å skrive til/fra skjerm er noe man gjør forholdsvis ofte. I python kan de også fås tilgang til gjennom sys-modulen. I python3 vil input() automatisk ta imot data fra sys.stdin, mens print som default skriver til sys.stdout. Her kunne vi imidlertid godt ha oppgitt en alternativ strøm ved f.eks.

 print(*objects, file=sys.stderr).

Hvis man ønsker å kommunisere med noe annet enn de faste strømmene, som f.eks. en fil, så må denne overføringskanalen åpnes manuelt. I python3 gjøres dette typisk ved

 f=open('filename','w')

Her returnerer open() et filhåndtak som vi tilegner f. 'w' angir modusen vi ønsker å håndtere filen under. I dette tilfellet vil vi skrive til filen med plassering angitt av 'filename'. Dette er en relativ eller absolutt filsti. Hvis vi bare skriver filnavnet tolker python det som at filen ligger i samme mappe som programmet. Om vi gir hele stien leter python relativt det aktuelle hjemmeområdet.

På Windows skrives filstier med \ som seperator, mens Unixsystemer bruker /. Hvis du ønsker at programmet ditt skal virke på begge typer systemer kan du bruke os.path.join()for å bruke systemspesifikk seperator:

 import os
 >>> os.path.join('usr', 'bin', 'spam')
 'usr/bin/spam'

Hvis filen ikke eksisterer fra før vil den lages under kallet til open(), og hvert kall med 'w' vil overskrive tidligere informasjon. Hvis vi heller ønsker å tilføye informasjon under hvert funksjonskall bruker vi 'a' i stedet. Om vi ikke spesifiserer modusen tolker open() det som at vi ønsker lese-modus 'r'. Til slutt kan vi åpne for både lesing og skriving med 'r+'.

open() antar i utgangspunktet at vi jobber med tekstfiler. Om vi arbeider med binærfiler må vi oppgi dette ved å legge til en 'b' i modusen som brukes.

Når vi er ferdig med å behandle filen er det god praksis å kalle f.close() for å frigi allokerte ressurser. Allokering/deallokering kan imidlertid automatiseres ved å utnytte at klassen til filhåndtaket definerer context-manager-protokollen. Dette betyr simpelten at f har tilgjengelig metodene f.enter() og f.exit(), som kalles ved henholdsvis inngang og utgang av en with-kodeblokk.

 with open('filename', 'w') as f:
   pass
 f.closed()

I det aktuelle tilfellet vil f.closed() returnere true, ettersom with-kallet sørger for automatisk allokering/deallokering.

Nyttige metoder for arbeid med tekstfiler:

  • Lese fra fil:
    • f.read(size):
      • Leser size karakterer og returnerer en tekststreng. Hvis size ikke spesifiseres leses hele filen.
      • Hvis man har nådd enden av filen returnerer read() en tom streng ""
    • list(f) eller f.readlines():
      • Returnerer en liste av linjene i filen.
    • f.readline():
      • Leser en enkelt linje fra tekstfilen inklusive newline '\n'.
    • Man kan også iterere gjennom hver linje i en fil:
 for line in f:
    print(line, end='')
  • Skrive til fil:
    • f.write(string):
      • Skriver string til filen, og returner det skrevne antallet karakterer.
      • Objekter av andre typer enn string må konverteres før de kan skrives til en tekstfil, likedans må de konverteres til bytes-objekter før de kan skrives til en binærfil.

Pickle-modulen og objektorientering

Hvis man ønsker å skrive kompliserte datastrukturer til en fil kan dette gjøres ved å serialisere objektet, som betyr å representere objektet som en binerstreng. Denne kan lagres som et eget bytes-objekt i python, eller skrives til en fil. I begge tilfeller behandles serealiseringen ved hjelp av pickle-modulen, som sørger for binærkonverteringen. Å skrive en binærrepresentasjonen av et objekt til en fil kan gjøres ved

pickle.dump(obj, file)

Her er file et filhåndtak som f.eks. er åpnet i 'wb'

Hvis du heller ønsker det serialiserte objektet som et eget bytes-objekt kan du bruke

bytes_obj=pickle.dumps(obj)

For å konvertere en lagret binærrepresentasjon tilbake til et objekt, brukes henholdsvis

 pickle.load(file)
 

og

 pickle.loads(bytes_obj). 
 

Her må file være åpnet med 'rb'.

Den foregående diskusjonen antar at objektene du prøver å pickle kan serialiseres. Brukerdefinerte klasser og funksjoner vil være pickable, så lenge de defineres i top-scopet, dvs. ikke nestet i andre funksjoner eller klasser. I python regnes både funksjoner og klassedefinisjoner som objekter som kan ha state, dvs. at selve "definisjonene" A og func regnes som egne objekter som henholdsvis har en A.dict og en func.dict. Pickle kopierer imidlertid ikke disse definisjonsobjektene by value, men kun by reference, hvilket innebærer at pickle i virkeligheten lagrer en peker til disse objektene. Dette innebærer at dicten som assosieres med disse definisjonsobjektene ikke kopieres. Hvis du har statiske variabler som alle instanser av en klasse har tilgang til, så vil dermed ikke disse kopieres, og du vil være avhengig av at de er tilgjengelig i scopet det serialiserte objektet unpickles i. En god regel, som nok de fleste følger, er å definere funksjoner og klasser som skal pickles i top-scopet av koden din. På denne måten har alle scopes i koden din tilgang til definisjonsobjektene og deres dictionaries. Hvis du vil unpickle et serialisert objekt i en annen modul, må du sørge for å importere modulen som definerer funksjonen/klassene du har serialisert, slik at A.dict eller func.dict også er tilgjengelig i den nye koden.

import module importerer som standard alle funksjoner definert i top-scopet, men man kan selvfølgelig også bruke from module import A, func

Vi ser nærmere på

 a=A(*args, **kwargs) 

Dette utfører implisitt

 a==object.__new__(A).__init(*args, **kwargs)

A er i dette tilfellet klassedefinisjonsobjektet, og A(*args, * *kwargs) gjennomfører først av et konstruksjonskall og siden et initialiseringskall. Føst kalles object.new(cls), der A gis som parameter. Her returnerer funksjonen en anonym instans av A, som det automatisk kalles A.init(self, *args, kwargs) på. object representerer den globale superklassen i python som definerer defaultmetodene som alle brukerdefinerte klasser arver. En brukerdefinert klasse redefinerer sjeldent new(), siden metoden i utgangspunktet returnerer instanser av klassen, som jo typisk er det man er interessert i. self-parameteren som gis til init() refererer til den nye anonyme instansen, mens *args og kwargs er argumentene du ønsker å initialisere instansen med.

Når man ønsker å pickle instanser av en klasse, (det vi generelt refererer til som objekter av en klasse, og som ikke må forveksles med selve klassedefinisjonsobjektet), er situasjonen litt annerledes. Ettersom instanser typisk har state som ikke er ment å være tilgjengelig globalt/bare gir mening for det aktuelle objektet er det hensiktsmessig at disse kopieres by value, ettersom det kan være at vi ønsker å endre på objectets dictionary uten å uten å endre state i alle andre instanser. For å pickle instanser er vi derfor avhengig av at objektene inneholder pickable state som pickle-modulen vet å serialisere. Generelt initialiseres instansers state i A.init(self, *args, **kwargs), og denne staten lagres i a.dict.

Det vil heves exceptions som PicklingError og UnpicklingError hvis man prøver å dumpe/loade ugyldige objekter/pickles. Det er verdt å merke seg at built-in types/funksjoner er pickable, og built-in beholdere som inneholder pickable objects vil også være pickable. Videre vil objekter som bruker andre brukerdefinerte klasser/funksjoner være pickable så lenge disse klassene/funksjonene som brukes er definert i top-scopet, dvs. kan refereres til.

Objekter som inneholder andre klasseinstanser vil være pickable så lenge disse instansene igjen er pickable. Det er klart at hvis man pickler en rekursiv datastruktur som inneholder referanser til seg selv, eller en datastruktur med objekt sharing, der det å kopiere et objekt innebærer å kopiere et objekt som videre må kopiere et objekt som videre må kopiere et objekt.., så må man passe på at dette ikke fører til en RecursionError eller lignende, dvs. vi må kreve at rekken av objekter som kopieres terminerer. Pickle holder styr på hvilke objekter som allerede er kopiert, slik at objektene ikke kopieres mer enn nødvendig.

Det er verdt å merke seg at ved å pickle en instans, og siden unpickle denne til en ny variabel, vil vi effektivt ha en ny instans, uten referanser til det forrige objektet. Pickle kan altså brukes til å ta deep copies av objekter, selv om det nok er bedre å bruke copy-modulen til dette. Når en serialisert instans unpickles vil ikke init() kalles på den nye instansen. Pickle vil først gjøre et implisitt kall til A.new() som returnerer en ikke-initialisert klasseinstans. Videre vil pickle direkte oppdatere det anonyme objektet med staten som ble lagret i den serialiserte instansen, dvs. det som lå i a.dict() når vi brukte pickle.dumps(a). Dette vil typisk være behandlet state som gjerne er forskjellig fra det du ville initialisere a med.

Hvis du ønsker å pickle en instans som inneholder unpickable state kan du spesifisere hvilken state som skal lagres ved å definere getstate() i klassedefinisjonen. Dette vil override default oppførsel, som er å kopiere hele a.dict. En kan f.eks. skrive

class A: …

def __getstate__(self):
	del self.__dict__['b']          
	return self.__dict__

hvis a.b er unpickable for alle a av typen A.

2018-10-26, Simen Nygard