| Python |
Python et et intepretert språk med klar og enkel syntaks og mange ferdige moduler med stor slagkraft. Ved kjøring kompileres først python-kode til bytekode som deretter eksikveres raskt av pyhton-virtual-maskin. Har python skrivetilgang lagres bytekoden i .pyc-fil, hvis ikke lagres bytekoden kun i RAM og forsvinner når programmet avsluttes. Python lagrer automatisk kun moduler som blir importert ikke selve hoved-programmet. Ved oppstart av et program sjekker python om det eksisterer en .pyc-fil med samme navn. Hvis det ikke gjort endringer i python-koden siden .pyc-filen ble generert, eller det ikke eksisterer python-kode-fil, brukes .pyc-filen. Python-kode og tilhørende bytekode er portabel til de fleste operativsystemer. Nedenfor er eksempel på et lite python program
#! /usr/local/bin/python
print "<html>"
print "<head>"
print "<title>python.cgi</title>"
print "</head>"
print "<body>"
print "Dette er skrevet av python-skriptet \"python.cgi\""
print "</body>"
print "</html>"
|
Dette skriptet blir aksessert av apache-serveren i Barken om det legges i web-katalogen og du gir det kjørerettigheter. I eksemplet over har python-programmet ekstensjon .cgi. Apache tolker .cgi-filer som skript. Alle andre python-programmer bør ha ekstensjon .py. Python-moduler som skal importeres må ha ekstensjon .py.
Er du ssh-innlogget i Barken kan du også kjøre python-skriptet ved direkte kall på intepreteren.
Ved å starte intepreteren uten å angi programfil kommer man inn i en interaktiv modus der man direkte kan skrive programlinjer. I den følgende generelle introduksjonen til python benytter vi stort sette denne modusen.
python
>>>print "hello world!"; print "hello world2!"
hello world!
hello world2!
>>>
|
Statment avsluttes automatisk ved linjeskift. Flere statment på samme linje kan separeres med semikolon
|
| Datatyper |
|
Som i de fleste skriptspråk predefinerer en aldri variablenavn til en bestemt datatype, men samme variablernavn kan på ulike steder bli tilordnet ulike verdier. Følgende regler gjelder variabelnavn:
Lovlig variabel-navn starter med lav-bindestrek eller bokstav og kan deretter innholde tall, bokstaver og lav-bindestrek.
Variable-navn må være forskjellig fra reserverte nøkkel ord som: do, while, for ..
Variabelnavn som begynner med en lav bindestrek (_X) importeres ikke.
Variablenavn som begynner og slutter med doble lave bindstreker (__X__) er system definerte navn, som har spesiell betydning for intepreteren.
Navn som begynner med doble lave bindestreker (__X) er lokale i tilhørende klasse
Kun enkel lav bindestrek innholder returverdi til siste utrykk når befinner seg i interaktiv modus til intepreteren.
Figuren under viser med blå skrift hvilke standard datatyper variabler kan ha:
|
| Numbers (is-statement) |
|
Tall lagres i 5 ulike datastrukturer.
Integer Lagres i C-long (minst 32 bit, vanligvis 64 bit). Instanser av klassen int
Long Lagres i så mange byte som det trengs (begrenset av tilgjengelig memory). Instans av klassen long
Boolean Lagres i Integer, men kun verdi True og False. Instans av bool som er subklasse av int
Float Lagres i C-double (64 bit). Instans av klassen float
Complex Lagres som et par av Float. Instans av klassen complex
Tilordning av konstanter
1234, -69, 0, 02322, 0x4d2, 0X4d2 Integer oppgitt desimalt (3 første), oktalt, heksidesimalt
9999999999999999999999L, -99999999999999999999999999999L Long prefikset L kan alternativt skrives som med bokstav l
1, 0 Boolean
123.456, 1.23456e+2, 1.23456e2, 123456e-3 Float
2+3j, 2,2+3,3j 3,3j Complex
Python utfører automatisk konvertering mellom typer. Ganger man sammen to integer der produkt blir for stort for lagres i en integer blir de plassert i en long. Tilsvarende blir addisjona av float og integer en float. Tilsvarende er det ikke lenger nødvindig å spesifisere at konstant er long med prefikset "L". En bør være oppmerksom på at deler en to integer blir resultat en integer.
Python bruker vanlige operatorer for tall. Nedenfor brukes tupler for å skrive flere regnestykker på samme linje
>>>#multiplikasjon binder sterkere enn addisjon og subtraksjon,
>>>#divisjon binder sterkere enn multiplikasjon
>>>(-4+7*5),((-4+7)*5),(2**8), (3/3*4)
(31, 15, 256,4)
>>>#Divisjon % rest etter divisjon, // avrunder nedover, %rest
>>>(5/2), (5%2), (5/2.0),(5/-2.0),(5/-2),(5//-2.0)
(2, 1, 2.5, -2.5, -3, -3.0)
>>>#skifte en plass til venstre, skift en plass til høre, bitvis or,
>>>#bitvis or, bitvis and, bitvis kompliment, negering av tallet
>>>(2<<1),(2>>1),(2|8),(2|6),(~0),(~1),(-1)
(4, 1, 10, 6, -1, -2, -1)
>>>#Forkortet skrivemåte for operasjoner (augmented tilodning
>>>x=1; y=2; x+=y; x*=y; x%=y; x&=y; x^=y; x<<=y; x-=y; x/=y;
>>>x**=y; x|=y; x>>=y; x//=y
>>>#Sammenlignings operatorer
>>>(2<2),(2<=2),(2>2),(2>=2),(2==2),(2<>2),(2!=2)
(False, True, False, True, True, False, False)
>>>#Logisk operatorer. Kun 0 er false
>>> (2 or 2), (2 or 0), (0 or 0), (2 and 2), (2 and 0), (2 and 0))
(2, 2, 0, 2, 0, 0)
>>>0.000001 or 0
9.9999999999999995e-07
>>> #Identitet test
>>>(2 is 2), (2 is 3), (2 is not 2), (2 is not 3), (2.000001 is 2.000001)
(True, False, False, True, True)
|
Numbers er instanser av klasser. For å finne hvilke atributter en klasse har kan skrive:
>>>dir(int)
['__abs__', '__add__', '__and__', '__class__', '__cmp__',
'__coerce__', '__delattr__', '__div__', '__divmod__', '__doc__',
'__float__', '__floordiv__', '__getattribute__', '
__getnewargs__', '__hash__', '__hex__', '__init__', '__int__',
'__invert__', '__long__', '__lshift__', '__mod__', '__mul__',
'__neg__', '__new__', '__nonzero__', '__oct__', '__or__',
'__pos__', '__pow__', '__radd__', '__rand__', '__rdiv__',
'__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__',
'__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__',
'__ror__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__',
'__rtruediv__', '__rxor__', '__setattr__', '__str__', '__sub__',
'__truediv__', '__xor__']
|
Operatorene omtalt over har en leksikalsk navn som tilsvarer en methode i klassen. Følgende er ekvivalent.
>>>1+2
3
>>>int.__add__(1,2)
3
|
Numbervariabler er likevel ikke referanser på lik linje som tekst-variabler.
|
| String, Unicode (in statement) |
|
Tekst lagres i instanser av klassene str eller unicode. Str-klassen bruker ascii-koding og 1 byte pr tegn. Unicode-klassen bruker flere byte pr tegn. Innholdet i en tekst-streng kan ikke endres (imutable).
Tilordning av konstanter
>>>#Tom streng
>>>a=''; b=""
>>>#Variblene a,b og c blir tilordnet verdien 'abc'.
>>>#Enkle og doble anførsel-tegn er helt ekvivalent.
>>>a='abc'; b = "abc"
>>>c="""\
>>>a\
>>>b\
>>>c"""
>>>#Tilordning av raw-tekst. Ignore escape-tegn
>>>a=r'\tmp\new'; b='\tmp\new'
>>>print a; print b
\tmp\new
mp
ew
>>>#Tilordning av unicode-tekst
>>>a=u'min tekst'
|
Escape-tegn
\newline Overse resten av linjen
\\ Beholder \
\' Beholder enkelt anførsel-tegn
\" Beholder enkelt anførsel-tegn
\a Pip
\b Slett siste tegn
\f En side fram
\n Ny linje
\r Til begynnelse av linjen
\t Tab
\v Vertikal tab
\N{id} Unicode dbase id
\uhhhh Unicode 16-bit hex
\Uhhhhhhhh Unicode 32 bit hex
\xhh Der hh er hex verdi
\ooo Der ooo er octal verdi
\O Ascii verdi 0
Eksempler på operatorer og metoder i klassen. For oversikt over alle metoder gi kommandoen dir(str) til intepreteren.
>>>#Konkatinering
>>>'abc'+'def'
'abcdef'
>>>#Repitisjon
>>>'abc'*3
'abcabcabc'
>>>"Lese ut enkelt tegn
>>>s='abc';s[2]
'c'
>>>"Lese ut en bit av teksten (fra og med : fram til)
>>>s[1:3]
'bc'
>>>"Lese ut resten av teksten
>>>s[1:]
'bc'
>>>"Lese ut hele teksten
>>>s[:]
'abc'
>>>#Indeks of tekst, returner null om ikke finnes
>>>s.find('bc')
1
>>>#Sjekke om tekstreng finnes i tekstrengen
>>>'bc' in s
True
>>>#Lager ny tekststreng der noe tegn er byttet ut
>>>s.replace('bc','ef');
'aef'
>>>#Leger en liste elementer i teksten med til angitt delestreng
>>>s.split('b')
['a', 'c']
>>>#Formatering (tilsvarende printf i C)
>>>x=23; "lengen er %s meter" % x
'lengen er 23 meter'
>>>x=1.23; " %d | %e | %E | %f | %g | %x | %X " % (x,x,x,x,x,x,x)
' 1 | 1.230000e+00 | 1.230000E+00 | 1.230000 | 1.23 | 1 | 1 '
>>>#Presisjon i tall, null fylling
>>>i=123; x=1.23456; '%d | %010d | %+d | %.2f | %010f | %+f ' % (i,i,i,x,x,x)
'123 | 0000000123 | +123 | 1.23 | 001.234560 | +1.234560 '
>>>s='bc'; 'a%sef' %(s)
'abcef'
>>>#Hvis en vil skrive % en format streng
>>>x=-10; '%u%%' % x
'-10%'
>>>#Lese ut fra en dictonary
>>>'tall %(n)d og tekst %(t)s' % {"n":2, "t":"hei"}
'tall 2 og tekst hei'
|
|
| List (in, del statement) |
|
Lister består av sekvensielle, indekserte elementer. Hvert element kan, tilsvarende variabelnavn, tilordnes verdier og tilhørende datatyper. Listen har lengde lik antall elementer, men kan ved hjelp av append- og extend-methoden i klassen vokse.
Tilordning av konstanter
>>>#Tom liste, liste med 4 tall, liste med str- og liste-element
>>>L1=[]; L2=[0,1,2,3]; L3=['abc',['def','ghi']]
|
Eksempler på operatorer og metoder i klassen. For oversikt over alle metoder gi kommandoen dir(list) til intepreteren.
>>>#Lese ut enkelt element og lister av elementer.
>>>#Indekseringen begynner på 0
>>>s=L2[0],L2[-1], L2[2:], L3[0],L3[1][0],L2[1:3]
( 0, 3, [2, 3], 'abc', 'def', [1, 2])
>>>#Konkatinering
>>>L2+L3,
[0,1,2,3,'def',['ghi','jkl']]
>>>#Konkatinering av ikke list-datatype blir til tekst streng
>>>L2+4
'[0,1,2,3]4'
>>>#Repitisjon
>>>L2*2
[0, 2, 3, 0, 2, 3]
>>>#Endre et elementer eller flere elementer i listen
>>>L2[0]=10; L[1,4]=[9,8,7]; L2
[10,9, 8, 7]
>>>"Lengden til listen
>>>len.L2
4
>>>#Legger til ett element (push) og flere elementer til slutt i listen
>>>L2.append(6); L3.extend(['a','b','c']); L2, L3
>>>#Fjerne siste element i listen (pop)
>>>L2.pop();
6
>>>#Fjerne indeksert område
>>>L2=[10,9, 8, 7]; del L2[1:3]; L2; L2=[10,9, 8, 7]; L2[1:3]=[]; L2
[10, 7]
[10, 7]
>>>#Fjerne indeksert element.
>>>#Tilordning av tom liste fjerner ikke element
>>>L2=[10,9, 8, 7]; del L2[1]; L2; L2=[10,9, 8, 7]; L2[1]=[]; L2
[10,8,7]
[10,[],8,7]
>>>#Finne indeks til element
>>>L2=[10,9, 8, 7]; L2.index(8)
2
>>>#Sjekke om element er i listen
>>>8 in L2
True
>>>#Sortere stigende
>>>L2.sort(); L2;
[7, 8, 9, 10]
>>>#Sortere synkende
>>>L2.reverse(); L2;
[10,9, 8, 7]
|
|
| Dictonary (in, del statement) |
|
Dictonary tilsvarer hashtable i java. Dictonary er en to-kolonne tabell der kolonnenene kalles key og value. En finner raskt record ved søk på key. Key-verdier er unike og kan være instanser av immutable-klassene. Value-kolonnen kan innholde alle datatyper. Det er ikke mulig å søke i value-kolonnen.
Tilordning av konstanter
>>>#Tom dictonary, dictonary med 2 elementer, dictonary med dictonary-element
>>>D1={}; D2={'fornavn': 'dag', 'etternavn': 'rolfsen'}
>>>D3={'registrar':{'poststed':'forsknigsparken', 'postnummer': 3049}}
>>>L1=['fornavn','etternavn']; L2=['dag','rolfsen']; D4=dict(zip(L1,L2))
>>>D5={1: 'verdi1', 49: 'verdi2'}
|
I dictonary D5 brukes integer som key. Dictonary kan på denne måten benyttes til å erstatte og komprimere lange lister med få elementer. Dictonary D4 initsieres at liste bestånde tupler [('fornavn','dag'),('etternavn','rolfsen')]. Tuple-listen lages ved å zip's sammen lister.
Eksempler på operatorer og metoder i klassen. For oversikt over alle metoder gi kommandoen dir(dict) til intepreteren.
>>>#Lese ut alle recorder, returnere dictonary
>>>s=D2
{'fornavn': 'dag', 'etternavn': 'rolfsen'}
>>>#Lister alle verdier i key-kolonnen og value-kolonnen
>>>#D2.keys(); D2.values()
['fornavn','etternavn']
['dag','rolfsen']
>>>#Lese ut enkelt record
>>>D2['fornavn'];D2.get('etternavn'); D2.get('mellomnavn','øivind');
'dag'
'rolfsen'
'øivind'
>>>D3['registrar']; D3['registrar']['postnummer']
{'poststed':'forsknigsparken', 'postnummer': 3049}
3049
>>>#Konkatinering. Rekkefølgen til recordene er tilfeldig.
>>>D2.update(D3); D2
{'fornavn': 'dag', 'etternavn': 'rolfsen',
'registrar':{'poststed':'forsknigsparken', 'postnummer': 3049}}
>>>"Antall recor i dictonary
>>>len.D2
3
>>>#Legger til element
gt;>>L2.['mellomnavn']='oivind'
>>>#Endre verdi til element
gt;>>L2.['mellomnavn']='olav'
>>>#Fjerne record
>>>del D2['mellomnavn']
>>>#Sjekke om key eksistere i dictonary
>>>d2.has_key('etternavn')
True
>>>'etternavn' in d2
True
|
|
| Tuple (in statement) |
|
Tupler består av sekvensielle, indekserte elementer. Hvert element kan, tilsvarende variabelnavn, tilordnes verdier og tilhørende datatyper. Tupler kan til forskjell til lister ikke endres (immutable).
Tilordning av konstanter
>>>#Tom liste, liste med 4 tall, liste med str-, tuple, og liste-element
>>>T1=(); L2=(0,1,2,3); L3=('abc',('def','ghi'),['jkl','mnq'])
|
Eksempler på operatorer. Tuple-klassen er ingen metoder i klassen utover operatore-funksjonene. For oversikt over tuple-operatorer skriv kommandoen dir(tuple) i intepreteren.
>>>#Lese ut enkelt element og liste av elementer. Indekseringen begynner på 0
>>>s=T2[0],T2[-1], T2[2:], T3[0],T3[1][0],T2[1:3],T3[3]
( 0, 3, (2, 3), 'abc', 'def', (1, 2),['jkl','mnq'])
>>>#Konkatinering
>>>T2+T3,
(0,1,2,3,'abc', ('def','ghi'),['jkl','mnq])
>>>#Repitisjon
>>>T2*2
(0, 2, 3, 0, 2, 3)
>>>"Lengden til til tuple
>>>len.T2
4
>>>#Finne indeks til element
>>>T2=(10,9, 8, 7); T2.index(8)
2
>>>#Sjekke om element finnes i tuple
>>>9 in T2
True
>>>var1, var2 = var2, var1
|
Forklaring på swap'n. Komma-separerte lister blir automatisk gjort om til tupler (implisit parantes rundt). Ved den initsieringen av tupler blir dermed variable-verdiene kopiert.
|
| File |
File-klassen inneholder metoder for &arign; les fra og skrive til fil. "open" og "file" er synome navn på klassen.
>>>"Instanserer klassen for lesing av fil
>>>input=open('infil.txt','r')
>>>"Les hele filen til variablen S
>>>S=input.read()
>>>"Les N byte til variablen S
>>>S=input.read(N)
>>>"Leser neste linje
>>>S=input.readline()
>>>"Les alle linjer i filen til liste med linjer
>>>L=input.readlines()
>>>"Skriver ut strengen S til fil
>>>output.write(S)
>>>"Skriv linje i liste liste L til filen
>>>output.writelines(L)
>>>"Lukk fil, flusher hva som er memory
>>>output.close()
|
|
| bultin funksjoner |
|
Python har mange ferdig standard funksjoner. For listing bruk følgende kommando:
dir(<objectnavn>) liste generelt sett atributter til objektet. Vanlig å bruke for oversikt over funksjoner til moduler. For mer informasjon om enkelt objekt kan "docstringen" (for nærmere forklaring se kapitell om flytkontroll) leses ut. I eksemplet nedenfor lese docstring til dir-funksjonen.
For mer informasjon om funsjoner og moduler kan også standard-funksjonen help-benyttes. Benyttes help på moduler, må modulen først importeres, og help skriver ut en rapport tilsvarend man-page for unix-kommandoer. I interaktiv modus vil kommandoen help() sette en over i en hjelp-modus. Hjelp-modus avsluttes med quit. Alle ord en skriver inn vil help prøpve å skrive ut informasjon om. Skriv kommandoen "topic" for velge tema.
Noen nummeriske funksjoner
int(x) Konverterer x til desimalt heltall
long(x) Konverterer x til long
hex(x) Konverterer x til heksadesimalt heltall
oct(x) Konverterer x til oktalt heltall
float(x) Konverterer x til float
abs(x) Absolutt verdien til tallet
pow(x,y) Opphøyer tallet x i y-potens
Noen streng funksjoner
len(s) Antall tegn i strengen
list(s) Lager en liste, der hver element innholder et tegn.
ord('a') Returner ascii-nummeret til tegnet, i dette eksemplet 97
chr(97) Returner ascii-tegnet til tallet, i dette eksemplet 'a'
Noen list funksjoner
len(l) Antall elementer i listen
del(L[i]) Sletter i-element i listen
range(x,y,z) Lager en liste med tall fra og med x til y der hver element er økes med z
zip(L1,L2) Lager en ny liste bestående av tupler. Hver tuple har to verdier en fra hver av listen. Antall elementer i ny liste er lik antall elementer i den korteste listen.
map(None,L1,L2)Lager en ny liste bestående av tupler. Hver tuple har to verdier en fra hver av listen. Antall elementer i ny liste er lik antall elementer i den lengste listen. Korteste listen paddes med None verdier.
map(funksjon,L1)Returnere en ny liste der funksjon utføres på hvert element i listen L1. Funksjonen kan være både def- og lamda-type.
filter(lamda x: x>0,range(-10,10)Returner en ny liste bestånde av elemente som tilfredstiller lamda-betingelsen altså: [1,2,3,4,5,6,7,8,9].
reduce(lamda x,y: x+y,range(1,4)Returner 6 som er summen av tallene i listen. Iteres listen [1,2,3], der lamda funskjonen i eksemplet første kan kalles med x=1 og y=2 og neste gang kalles med x=3 (summen av forrige kall) og y=3
Noen tuple funksjoner
len(l) Antall elementer i tuple
xrange(x,y,z) Lager tuple med tall fra og med x til y der hver element er økes med z
Noen modul funksjoner
reload(modulnavn)Kjører modulen en gang til (initsiere modulen på nytt).
Datattype sjekk funksjoner
isinstance(L1,list) Sjekker om variablen L1 innholder datatypen list
type([L1])==list Ditto over
type([L1])==type([]) Ditto over
type([L1])==type.ListType Ditto over
|
| Flytkontroll (and, or, not, if, elif, else, while, for, in, break, continue og yield statment) |
|
Statement avsluttes med linjeskift eller semikolon (;), med unntak av:
Ved initsiering av tupler, lister og dictonary, eller mer generelt noe som begynner med (,[ og { kan gå over flerer linjer til neste ),] og }.
Linjer som du du avslutter med \ (bedre å bruke parantes rundt lange utrykk)
Tegnstrenger med tre ansførselstegn rundt kan strekke seg over flere linjer.
Statement i Python utføres vanligvis en etter, med unntak av
Linjer som starte med #-tegn tolkes som kommentarer og oversees.
Python har også annen kommentar-type som kalles "docstring". Tekststregn som skrives helt i begynnelsen av moduler (etter #!-direktetivet), eller rett etter def- og class-statement (helt i begynnelsen av funksjoner og klasser). Docstring til model sys kan lese ut etter import ved følgende utrykk: sys.__doc__
Sammensatte statement har en hodelinje avsluttet med kolon (:) og etterfulgt av indenterte statement. Python bruker indentering (rykke teksten inn en eller flere plasser)(blanke tegn i begynnelsen av linjen) for å markere programkode-blokker.
Flytkontroll baser seg på True og False til logiske-utrykk. Number er True om ikke lik 0 og alle andre objekter er True hvis de er forskjellig fra tomt-object. Logiske utrykk settes sammen med "and", "or", "not" og paranteser.
Eksempler på sannhetsverdier
"absc True
1 True
"" False
[] False
{} False
0.0 False
None False
if-statement
if-statement ser ut som følger
>>>x=1
>>>if x=2:
... print 'to';
...elif x==1:
... print 'en'
...else:
... print 'ingen av delene'
...
en
>>>print 'etter if-statement'
etter if-statement
|
Legg merke til at promt fra intepreteren endres fra >>> til tre punktumer for å vise et statementet forsetter. Blank linje avslutter statementet. If-statement i programfil ser ut som følger:
#! /usr/local/bin/python
x=1
if x=2:
print 'to';
elif x==1:
print 'en'
else:
print 'ingen av delene'
print 'etter if-statement'
|
while-statement
Generell form til while-statement:
while <test1>
<statement1>
if <test2>
break
if <test3>
continue
else
<statement2>
|
Break-statement vil stoppe løkken og hoppe over else-grenen til while (statement2). Continue-statement vil gå til toppen av løkken igjen.
Det er viktig å merke seg at i Python er det ikke lov med statement i test-betingelsen slik at følgende java/C-kode må omskrives slik at tilordningen skjer utenfor test-betingelsen: while ( (x=next()) != null){}
for-statement
Generell form for-statement er tilsvarende while med break, continue og else-gren. Her følger eksempel:
>>>sum=0
>>>for x in range(0,5):
... sum+=x
>>>sum
10
>>>#Skrive ut alle linjer i en fil, men leses først til listeobjekt
>>>for linje in open.('tull.txt').readlines: print linje
>>>#Skrive ut alle linjer i en fil, men leser linjer etter behov
>>>for linje in open.('tull.txt').xreadlines: print linje
>>>#Skrive ut alle linjer i en fil. Bruker iterator til file-objektet
>>>for linje in open.('tull.txt'): print linje
|
| Function (def, return og lamda statement) |
def-statement lager funsjoner:
>>>def leggesammen(x,y):
... return x + y
...
>>>leggesammen(1,2)
3
>>>leggesammen('ab','cd')
'abcd'
|
Her bør en merke seg at parementerene ikke er type-bestemt og samme funsjon kan opperere flere datatyper.
Alle variablnavn som tilordnes verdier innenfor funksjoner betraktes som lokale. Variabelnavn må prefikses med "global" for at tilordningen skjer til variab med angitt navn på utsiden.
>>>x=1;
>>>y=2;
>>>def skrivut(y):
... print x
... x=3
... y=4
... print x, y
...
>>>skrivut(2)
1
3 4
>>>print x, y
1 2
>>>def skrivut(y):
... global x
... global y
... x=3
... x=4
... print x, y
...
>>>skrivut(y)
3 4
>>>print x, y
3 4
|
"Unqualified" variabelnavn resolving ved referanse etter LEGB-reglen: Local funskjon, Enclosing funksjon, Global, Builtin. Global betyr her modulen (filen kodelinjene er skrevet i). Ved tilordning lages en ny local-variabel, hvis ikke variablavnet er deklart global.
"Qualified" variabelnavn referer til atributter i objekter, som moduler og klasser. Ved referanse til atributte til klasse-objekter til en først leter i navnerommet til instansen og deretter navnerom fra super-klasser den arver. Ved tilordning vil det lages en lokal variabel i navnerommet til instansen.
Det er ikke mulig å definere ulike funksjoner med samme funksjonnavn der kun antall parameter er forskjell. Det er mulig å definere default verdier til argumenter. Argumenter med defautl verdi er ikke nødvendig å oppgi ved kall. Vanligs matcher argumenter ved kall med hensyn til posisjon, men en kan også eksplesitt tilordne argumentnavn verdi
>>>#Eksempel 1
>>>def skrivut(a, b, c='ku', d='hest'):
... print a, b, c,
...
>>>skrivut('hund', d='katt', b='kanin')
hund kanin ku katt
>>>#Eksempel 2
>>>def skrivut(*mineparametere):
... print mineparemtere, mineparemetere[0]
...
>>>skrivut('mus')
mus mus
>>>skrivut('bie','bille')
bie bille bie
>>>#Eksempel 3
>>>def skrivut(**mineparametere):
... print mineparemtere, bie
...
>>>skrivut('bie=111','bille=222')
{'bie':111, 'bille'=222} 111
|
I eksemepel 1 må de to første parametere oppgis. I eksempel 2 kan hvilkålig antall parameter angis (liste, tupel). I eksempel 3 oppgis dictonary med verdier. (eksempel 2 og 3 fikk jeg ikke til å fungere ved bruke av liste eller dictonary istedet)
En bør merke seg at funksjoner er runtime-statement, slik at ulike definisjoner til en et funksjonnavn kan eventuelt plassers i if-tester.
lamda-funksjoner
I tillegg til def-statement har python lamda-utrykk for lage funksjoner. Lamda funksjoner innholder et enkelt utrykk (tilsvarende hva en kan plassere i return statement til def-funksjoner). Siden lamda er utrykk og ikke statement kan de lagres i lister og oppgis som parameterverdier til funksjoner.
>>>u=lamda x, y: x+y
>>>u(1,2)
3
>>>u=lamda x=1, y=2: x+y
>>>u(3)
5
|
generator og iterator
Til forskjell fra vanlige funksjon som returnerer (stopper) etter kall vil en generator suspendere. Gjentatte kall på next() vil hente ut neste verdi.
>>>def mingenerator(n):
... for i in range(n):
... yield i
...
>>>g=mingenerator(10)
>>>g,next()
0
>>>g,next()
1
>>>g,next()
2
>>>for i in mingenerator(10)
... print i,
...
1 2 3 4 5 6 7 8 9
|
For-løkken kaller mingenerator-funksjonen som igjen lager et generator-objekt. For-løkken kaller deretter next()-methoden ved hvert gjennomløp. Hvis objektet det itereres over ikke støtter iterator-protokollen benyttes den vanlig indeks-protokollen.
Standard datatyper blir iterator-objekter ved kall på builtin funsjonen iter
>>>#eksempel 1
>>>d=['a':1,'b':2,'c':3]
>>>g=iter(d)
>>>g.next()
'a'
>>>g.next()
'b'
>>>g.next()
'c'
>>>#eksempel 2
>>>for key in d:
... print key, d[key]
...
a 1
b 2
c 3
>>>#eksempel 3
>>>[ord(x) for x in 'dag']
[100,97,103]
|
For-løkker, zip, map, filter, liste-forkorting... er designet slik at de automatisk prøver å kalle iter-funksjonen til objektet og sjekker dermed om iterator-protokollen er støttet. Eksempel 3 eksempel på liste-forkning. ord-funskjonen er en innebygd funsksjon som skriver ut ascii-nummeret til et tegn. For-løkken kaller iter-funksjonen til tekststrengen 'dag'. Omsluttende hakeparenteser er en forkortet skrivemåte for genering av ny liste.
|
| Module (import, from og print statement) |
Alle filer med python-kode som har filekstensjon .py er modul. Lag filen mod1.py som innholder:
x=3
print
def inc(y)
return x+y
|
Modul kan importeres i andre python-programmer. Ved import blir koden i modulen kjørt. Dette er nyttig for initsiering av modulen. Ved gjentatt import av samme modul blir ikke koden kjørt på nytt, da må modulen reload's.
>>>import mod1
3
>>>import mod1
>>>reload(mod1)
3
>>>print mod1.inc(4)
7
|
>>>import mod1
>>>inc=mod1.inc
>>>print inc(y)
7
|
>>>from mod1 import inc
>>>print inc(y)
7
|
>>>from mod1 import *
>>>print inc(y)
7
|
Modul navnerom laget med import av import-statement er dictonary som kan aksessers med builtin funksjonen __dict__
>>>mod1.__dict__.keys()
['__file__', '__name__','__doc__','__builtins__','inc']
|
File er her navnet på filen modulen er lastet fra. Name er navnet som ble importert (uten .py og directory struktur)
Det er også mulig importere hele pakker med moduler, da katalog-navn oppgis i import-statment i stedet for bare fil-navn. Katalog-navn oppgis med dot-notasjon tilsvarende import-statement i java. Hjemmekatalogen til katalog-navn som oppgis må være i søkestien for moduler til python. Alle kataloger nevnt i import statment må innholde __init__.py fil. Filen innholde python-kode for initsiering av pakken.
>>>from dir1.dir2 import mod1
>>>mod1.inc(5)
8
>>>import dir1.dir2.mod1 as mod1
>>>mod1.inc(5)
8
|
Python kommer med en stor menge standard moduler, kalt Standard libary. Standard libary består av over 200 moduler. Når python skal laste inn moduler søkes det i følgende rekkefølge.
Hjemme katalogen: Den katalogen en koden-filen befinner seg i eller en har startet python intepreteren for interaktiv koding.
PYTHONPATH kataloger som en ønsker at python skal lete etter moduler kan settes i environment variablen PYTHONPATH.
Standard libary katalog
.pth fil.
sys.path lister hvilke kataloger python søker etter moduler. Import statment innholder kun selve navnet på filen uten ekstensjon. Dette kommer av import kan laste inn
mod1.py kildekoden
mod1.pyc bytekoden
mod1 katalog med navn mod1
mod1.so c-bibliotek
mod1.zip en zipimport modul
sys-modul og print-statement
print-statement skriver ut objekter til stdout-stream. Stream'en stdout kan en få tak i ved import sys-modul. Programmet nedenfor innholder print- og sys.stdout.write-setninger som skriver ut samme resultat.
#! /usr/local/bin/python
import sys
x='abc'; y='edf';
print x, y
sys.stdout.write(x+' '+ y+'\n')
print x, y,
sys.stdout.write(x+' '+ y)
|
Her det viktig å merke seg at sys.stdout.write er utrykk som kan benyttes i if- og for-betingelser, men print-setningene representerer statement som ikke kan benyttes der.
Både print- og stdout- kan viderekobles til fil (redirect).
#! /usr/local/bin/python
import sys
x='abc'; y='edf';
print >>tull.txt x, y
sys.stdout.open('tull.txt','a')
sys.stdout.write(x+' '+ y+'\n')
print x,y
|
Etter stdout er koblet til filen 'tull.txt' vil også print-statement skrives til denne filen.
sys.path lister hvilke kataloger python søker etter moduler.
re modul
Regularer utrykk kan utføre avanserte operasjoner på strenger.
>>>import re
>>>a='Her aa, ae, oe byttes til aa, ae, oe'
>>>restr=re.compile(r"\b(aa|ae|oe)(\s+|,)
>>>b=matchstr.sub(r'å\2,a)
>>>print b
|
Utrykke som som skal matches er delt i to forste del bestå av to bokstaver og siste del etterfølgere med blanke-tegn eller komma. I Selve substitusjon byttes matchet utrykk med å pluss siste del av matchet.
Forklaring på noen vanlige spesial tegn i regulare utrykk
. Matcher alle tegn bortsett fra linjeskift
^ Matcher starten på strengen
$ Matcher slutten på strengen
* Ingen eller flere av hva som står til venstre for meg
+ En eller flere av hva som står til venstre for meg
| Enten det som står til venstre eller høre for meg
\w Matcher alle alfanummmeriske tegn
\d Matcher alle heltall
?! Ikke hva som følgere etter meg
?= matcher hva som følger etter meg, men skal ikke bli brukt opp
os modul
Omtren enhver funksjon i POSIX standarden har sin make i os-modul. Her en noe vanlige funksjoner
getcwd() tilsvarer unix: pwd
listdir(sti) returnere en liste over innholdet i katalogen
chown(sti, uid, gid) endrer bruker og gruppe til angitt fil/katalog
chmod(sti, mod) endrer filbeskyttelse, eks chmod('tull.txt,0764)
rename(src,dest) endrer navn/flytter fil
remove(sti) eller unlink(sti) Fjerne fil
rmdir(sti) fjerner katalog
mkdir(sti[,mod])
makedirs(sti[,mod])
system(kommando)
symlink(src,dst)
link(src,dst)
stat(sti) mer informasjon om en fil
Noe atributter
os.name angir operativsystem: posix, nt, dos, mac. sys.platform er detaljert
os.error definere exception klasse som kastes av funskjoner i modulen. Ved raise sende med ekstra informasjon i et liste element som innholder to verdier: errno og forklaring.
>>>try:
... os.rmdir("ikkedir")
...except os.error, merinfo
... print merinfo[0], merinfo[1]
...
2 No such file or directory
|
curdir string som angir current directory '.' på unix og Dos, ':' på mac
pardir string som angir parent directory '..' på unix og Dos, '::' på mac
sep tegn som separer sti-labler. '/' på unix, '\' på Dos og ':' på mac
pathsep tegn som separer verdier i environment variabler. ':' på unix og ';' på Dos
os.path modul
Innholder en del funskjoner for å splitte stier i del-kompontere og sjekke om stien peker på fil, katalog, link, samt kan hente ut informasjon om størrelse og tidspunkt for sist endret.
shutil modul
Siden os-modulen ikke inneholder funskjoner for å kopiere filer er dette noe shutil-modulen tar seg av. P&arign; Dos er kopiering enkelt der binary-leser man filen og skriver den til ny lokasjon. På unix må en også kopiere eier, grupper og rettigheter. På mac må en også kopiere icon og dialogboks.
copyfile(src,dist) Kopierer innhold
copymod(src,dist) Kopierer rettighet informasjon
copystat(src,dist) Kopierer alle stat-informasjon, som tidspuntk for sist endret og rettigheter
copy(src,dist) Kopierer innhold og rettigheter
tempfile modul
tempfile.TemporaryFile() Opprette en midlertidig fil. På unix plasseres filen i /tmp
Internett relaterte moduler
base64 Kode og dekode BASE64
binascii Kode og dekode ulike ASCII representasjoner
binhex Kode og dekode binhex4
cgi Lese ut environment variabler (querystring) som settes av webserver
cgib Lese ut environment variabler (querystring) som settes av webserver
formatter
htmllib Parsere html-filer
mail Parser og lage e-postmeldinger
mailbox Lese ulike mailboks format
mailcap
mimetools Parsere MIME-style e-postmeldinger med vedlegg
mimetypes Oversetter ekstensjon til mimetype
mimify Konverter e-postmeldinger til og fra MIME-format
multifile
quopri Kode og dekode MIME quoted-printable encoding
rfc822 Parsere RFC-822 hodefelt
sgmllib Parsere sgml-filer
urllib Innholder funskjoner for opprette klient http og https forbindelser
urlparse Innholder funksjoner for å parsere url
uu Kode og dekode files uuencode format
xdrlib Kode og dekode XDR
random og math modulene
|
| Class (class og pass statement) |
class-statement generer en ny klasse og tilordner det et navn. Tilsvarende def-statement blir class-statement ofte kjørt ved import av filen det er definert i.
>>>class MinKlasse:
... x=1
... def lagreverdi(self, verdi):
... self.lokalverdi=verdi
... def endrex(self,verdi):
... MinKlasse.x=verdi
... def skrivverdier(self):
... print selv.lokalverdi, MinKlasse.x
...
>>>min=MinKlasse()
>>>din=MinKlasse()
>>>min.lagreverdi(1)
>>>#ekvivalent med
>>>MinKlasse.lagreverdi(min,1)
>>>din.lagreverdi(2)
>>>min.skrivverdi();
1 1
>>>din.skrivverdi();
2 1
>>>min.x=5
>>>print min.x
5
>>>min.skrivverdi()
1 1
>>>min.endrex(10)
>>>din.skrivverdi()
1 10
>>>din.skrivverdi()
2 10
>>>MinKlasse.x=20
>>>min.skrivverdi()
1 20
>>>din.skrivverdi()
2 20
|
Hver instans av klassen har eget navnerom. Første parameter i methoder referer til instansen (korrekt navnerom), og pr konvensjon kalles den self (kan hete hva du ønsker). Tilordning av verdier til instans-atributter endrer kun instansen, men tilordning til klasse-atributter endrer verdi for alle instanser.
Klasser kan arve egeneskaper fra en eller flere klasser ved angi superklassene i parantes etter klassenavnet
>>>class MinSubKlasse(MinKlasse):
... x=100
... def __init__(self, verdi):
... MinSubKlasse.x=verdi
... def skrivsuperverdi(self):
... print self.lokalverdi, MinKlasse.x
... def __add__(self, z):
... MinSubKlasse.x+z
...
>>>minsub=MinSubKlasse('300')
>>>print minsub.y
abc
>>>minsub lagreverdi(3)
>>>print skrivverdi()
3 300
>>>print skrivsuperverdi()
3 10
>>>minsub + 200
>>>print skrivverdi()
3 500
|
Overskriving av operator metoder
Python har en rekke standard operatormetoder som kan overskrives, noen er nærmere behandlet nedenfor:
__init__, __del__
Constructor metoden heter i python alltid __init__. Metoden kalles automatisk når det lages en ny instans av klassen. Metoden blir i eksempelt over, i MinSubKlasse overskrevet. Hvis superklassen MinKlasse, i eksemplet over, hadde hatt en constuctor metode kunne en ha kalt på denne i _init__ metoden i MinSubKlasse ved (husk self-parameter): MinKlasse.__init__(self,verdi). Når en instans fjernes kalles automatisk __del__.
>>>class Test:
... def __init__(self, verdi):
... print 'Ny test: ', verdi
... def __del__(self):
... print 'Fjernet test'
...
>>>t=Test('hei')
Ny test: hei
>>>t=1
Fjernet test
|
__add__, __radd__
Vanlig pluss-operator kan implementeres ved overskriving av __add__ og __radd__. __radd__ metoden kalles automatisk i instansen nå instansenen er på høyre side av operatoren og objektet til venstre er standard-datatype. I alle andre tilfeller kalles __add__.
>>>class Test:
... def __init__(self,verdi):
... print 'add', self.verdi, verdi
... def __add__(self,verdi):
... print 'radd', verdi, self.verdi
...
>>>t1=Test(1)
>>>t2=Test(2)
>>>t1+10
add 1 10
>>>20+t2
radd 20 2
>>>t1+t2
add 1
|
I det siste tilfellet kan ikke generelt angi hvilket atributt i t2 som skal legges til siden en better en metode i t1.
__or__
__repr__, __str__
print, str() og repr() kaller på metoden __repr__. print og str() kaller først metoden __str__, hvis ikke kalles __repr__.
>>>class Test:
... def __init__(self):
... self.verdi=3
... def __repr__(self):
... return 'Repr-streng: %s' %(self.s)
... def __str__(self):
... return 'Str-streng: %s' %(self.s)
...
>>>t=Test()
>>>print t; str(t); repr(t)
Str-streng: 3
Str-streng: 3
Repr-streng: 3
|
__call__
Det er mulig kalle på en instans tilsvarende en funskjon. Metoden __call__ er default metode som kalles om en ikke angir hvilken metode som skal kalles.
>>>class Test:
... def __init__(self,verdi):
... self.x=verdi
... def __call__(self,verdi):
... return self.x+verdi
...
>>>t=Test(2)
>>>t(3)
5
|
__getattr__
__setattr__
__getitem__
Ved indeksert av en variabel kalles __getitem__. Også for-løkker, in statement for sjekke om medlemskap, og liste forkortelse utrykk kaller automatisk på metoden
>>>class Test:
... def __getitem__(self,i):
... return i*i
...
>>>t=Test()
>>>t[2]
4
>>>class Test:
... def __getitem__(self,i):
... return verdi[i]
...
>>>t=Test()
>>>t.verdi='abc'
>>>t[1]
b
>>>'a' in t
True
>>>for x in t
... print x,
...
a b c
>>>[x for x in t]; map(None, t); list(t); tuple(t)
['a','b','c']
['a','b','c']
['a','b','c']
('a','b','c')
|
__setitem__
__len__
__cmp__
__lt__
__eq__
__iadd__
__iter__
Ved å overskrive __iter__ metoden vil klassen støtte iterator-protokollen som automatisk benyttes i bl.a. for-løkker
>>>class Test:
... def __init__(self,start, stopp):
... self.verdi=start
... self.stopp=stopp
... def __iter(self):
... return self
... def next(self):
... if self.verdi == self.stopp:
... raise StopIteration
... self.value+=1
... return self.value*10
...
>>>for i in Test(1,10)
... print i,
10 20 30 40 50 60 70 80 90
|
Navnerommet til klasser
Navnrommet er implementert som dictonary og kan leses ut __dict__ atributtet. En instans referanse til selve klassen er lagret i __class__ atributtet og __bases__ innholder referanse til super-klasse
>>>class MinKlasse:
... x=1
... def setverdi(self, verdi):
... self.verdi=verdi
...
>>>class MinSubKlasse:
... y=1
... def setsubverdi(self, verdi):
... self.subverdi=verdi
...
>>>s=MinsSubKlasse()
>>>s.__dict__
{}
>>>s.__class__
>>>MinSubKlasse.__base__
(,)
>>>MinKlasse.__base__
()
>>>s.setsubverdi(10)
>>>s.__dict__
{'subverdi':10}
>>>MinSubKlasse.__dict__
{}
|
|
| Exception (try, except, finally, raise og assert statement) |
Exception er streng eller klasse-object. Raise og assert kaster exceptiion (nærmest goto statement) til dit hvor exception blir fanget. except er definer hvor og hvilke exceptions som blir fanget.
>>>s=minexception='fanget minexception'
>>>try:
... raise minexception
...except minexception:
... print minexception
...
fanget min exception
>>>try:
... raise minexception, 'info mer'
...except minexception, merinfo:
... print minexception, ': ', merinfo
...
fanget min exception : mer info
>>>class MinException: pass
...
>>>import sys
>>>try:
... raise MinException()
...except MinException:
... print 'fanget: ', sys.exc_type
...
fanget __main__.MinException
>>>try:
... raise MinException()
...except MinException:
... print 'fanget: ', sys.exc_type
... raise
...
>>>class MinSubException(MinException: pass
>>>try:
... raise MinSubException()
...except MinException:
... print 'fanget: ', sys.exc_type
...
fanget __main__.MinSubException
fanget MinException
|
Det er kun lov å sende med tilleggsinformasjon om exception-datatype er string. I nest siste eksemplet sende exception som raise't videre. Siste eksemplet viser at except fanger alle subklasser av oppgitt klasse. Ved å overskrive __repr__ metoden kan bestemme hvilken feilmeldingen exception-klassen skriver ut.
Det er mulig bruke else-statement slik at koden i else-blokken bare utføres hvis det ikke kastes noen exception. Det mulgi å bruke finally-statement for utføring av kode uansett om exception kastes eller ikke. Finally må matche try-statement uten noe except-(else-)statement i mellom.
>>>s=minexception='fanget min exception'
>>>try:
... a=100
...except minexception
... print minexception
...else
... print a*2
200
>>>def bad():
... raise s
...
>>>try:
... bad()
...finally:
... print 'kommer alltid hit'
kommer alltid hit
|
assert
assert kaster AssertionError hvis test-betingelse ikke er oppfylt.
>>>s=minexception='fanget min exception'
>>>assert 1<0, 'Dette er aldri sant'
AssertionError: Dette er aldri sant
|
assert kan tolkes som følgende
if __debugg__:
if not
raise AssertionError,
|
debugg flagget er default satt, ved gi opsjonen -0 (stor O for oppdatimalisering) til intepreteren vil aldri assert kaste exception.
built-in exception
Exception er superklassen til alle built-in exception.
StandardError er superklassen til built-in error exception
ArithmeticError er superklassen til nummeriske errors
Mer informasjon kan lese ved
>>>import exceptions
>>>help(exceptions)
|
|
|
|