@Include { landscapecslides }
@OverheadTransparencies
	@Title { Innføring i Python }
	@Author { Steinar Knutsen }
	@DateLine { No }
	@InitialLanguage { Norsk }
	@PageHeaders { Simple }
	@InitialSpace { tex }
	@OptimizePages { No }
//
@Overhead
	@Title { Historikk }
@Begin
@BulletList
	@ListItem { Først implementert av Guido van Rossum i 1991. }
	@ListItem { Spin-off frå Amoeba, eit forskningsprosjekt innafor
		distribuerte system. }
	@ListItem { Meint å fylle gapet mellom C og bash. }
	@ListItem { Først implementert på Macintosh. }
	@ListItem { Oppkalt etter Monty Python. @F spam og @F bacon er meir
		vanlege enn @F foo og @F { bar }. }
	@ListItem { Stammer frå ABC, eit programmeringsspråk utvikla etter
		ein operasjonsanalyse av programmeringsprosessen. ABC var primært
		utvikla som undervisningsspråk. }
	@ListItem { Påverka av Modula-3, C, etc. }
	@ListItem { Finst tilgjengeleg på dei fleste plattformer. }
	@ListItem { Vert i dag vedlikehalde av Guido van Rossum med fleire. }
	@ListItem { Grunnkonsept:
		@IndentedList
			@ListItem { Objektorientert. Alt er objekt. Arv, inkludert multippel
				arv, er støtta i ein enkel modell. }
			@ListItem { Dynamisk typa. Ein referanse har ikkje bunden type. }
			@ListItem { Utvidbart. Veldokumentert, brukarvennleg API til C. }
		@EndList }
	@ListItem { Nyttige URLar:
		@IndentedList
			@ListItem { http:"//"www.python.org"/" }
			@ListItem { http:"//"starship.python.net"/" }
			@ListItem { http:"//"www.stone-dead.asn.au"/" }
		@EndList }
@EndList
@End @Overhead

@Overhead
	@Title { Lister, for-løkker og if-setningar }
@Begin
@CP {
languages = ["C", "Simula", "BCPL", "Intercal"]
OOlanguages = ["Simula", "Python", "Eiffel"]
nonOOlanguages = ["C", "Fortran-IV", "Algol-60"]
for lang in languages:
	if lang in OOlanguages:
		print lang, "er objektorientert."
	elif lang in nonOOlanguages:
		print lang, "er ikkje objektorientert."
	else:
		print lang, "er uklassifisert her."
}

@LP @I Merk:
@IndentedList
	@ListItem { Innrykk markerer blokker. Lineskift er vanlegvis signifikant.
		Ein kan overstyre lineskift med @F { "\\" }. }
	@ListItem { @F for itererer over ei liste, ikkje ein indeks. }
	@ListItem { @F { case }, som i td C, finst ikkje i Python. }
	@ListItem { Ein kan slette referansar med @F { del }. }
@EndList
@End @Overhead

@Overhead
	@Title { Dictionaries, while og kommentarar. }
@Begin
@CP {
langdict = {
	"Python": "Kjekt programmeringsspråk.",
	"Rexx": "Skripting på Amiga og stormaskiner frå IBM.",
	"Perl": "Programmeringsspråk oppfunne av ein SIL-lingvist."
}
aksess = 0
while aksess < 3:
	aksess = aksess + 1
	oppslag = raw_input()
	if oppslag == "avslutt":
		break
	elif oppslag == "Intercal": # Vi overser at folk vil lære om Intercal
		continue
	if langdict.has_key(oppslag):
		print langdict[oppslag]
	else:
		print "Ukjent språk."
else:
	print "Ein får maksimalt gjera tre oppslag i ordlista."
}

@LP @I Merk:
@IndentedList
	@ListItem { @F for og @F while kan begge ha ein @F { else } som vert
		eksekvert om løkka ikkje vert avbrote vha @F { break }. }
	@ListItem { Python har ikkje kortformer av typen @F { i++ }. }
	@ListItem { Liner har implisitt kontinuasjon om ein @F { "{" },
		@F ( eller @F [ enno ikkje har vorte lukka. }
	@ListItem { Alle hashbare, eller statiske, objekt kan nyttast som nøkler i
		dictionaries. }
	@ListItem { @F "#" er kommentarmarkør. }
@EndList
@End @Overhead

@Overhead
	@Title { Grunnleggande datatypar }
@Begin
@TaggedList
	@DropTagItem { Integer } { Heiltalsobjekt.  Divisjon er avrunda mot
		{ @Sym minus }{ @Sym infinity }. @F { -3"/"2 } er mao @F { -2 }. }
	@DropTagItem { Lange integer } { Som integer, men kan vera vilkårleg
		store. Dvs, ikkje avgrensa av MAXINT på systemet. }
	@DropTagItem { Flyttal } { Vanlegvis direkte implementert på toppen
		av double precision floats i C på den aktuelle plattforma. }
	@DropTagItem { Komplekse tal } { (x+yj) }
	@DropTagItem { Strengar } { Kan innehalde @F { "\\"000 }. Strengar
		er statiske objekt, ein kan @I ikkje endre
		ein streng i Python, slike effektar oppnår ein ved å konstruere
		nye strengar. }
	@DropTagItem { Lister } { «Dynamiske arrays.» Kan innehalde alle slags
		objekt. Treng ikkje innehalde berre ein type objekt i ei liste. }
	@DropTagItem { Tuples } { «Statiske arrays.» Fungerer på same måte som
		lister, men kan i likskap med strengar ikkje endrast. }
	@DropTagItem { Dictionaries } { Assosiative arrays. Kan nytte alle slags
		statiske, dvs hashbare, objekt som nøkkel. Tilsvarer ein «hash» i
		Perl. }
@EndList
@End @Overhead

@Overhead
	@Title { Slice-notasjon }
@Begin
I strengar, lister og tuples, eller mao sekvensobjekt, starter nummereringa
frå 0. Eit element vert adressert ved @F { objekt[indeks] }. Td:
@F { "\""abc"\""[1] } returnerer @F { b }. Negative tal vert tolka slik at
indeksen @F { -1 } referer til det øvste elementet i sekvensen, ein tel
baklengs nedover i sekvensen.  @F { "\""abc"\""[-2] } returnerer @F { b }.

@PP Alle sekvensobjekt stør slicenotasjon. Ein slice er ein subsekvens av ein
sekvens. Notasjonen er @F { objekt[start:slutt] }. Ein nyttig måte å
visualisere slices på er å sjå for seg at dei er mellom elementene i
sekvensen, da dei fungerer som følger: 0 refererer til eit punkt før
det første elementet i lista, 1 til eit punkt mellom det første og det
andre, etc. Utelét ein @F start eller @F slutt vert dei henhaldsvis
tolka som før starten på lista eller etter slutten av lista. Eksempelvis
@F { "\""abcdef"\""[:3] } returnerer @F { "\""abc"\"" }, medan
@F { "\""abcdef"\""[2:4] } returnerer @F { "\""cd"\"" }.
@End @Overhead

@Overhead
	@Title { «Mutability» og referansar }
@Begin
Spissformulert har ikkje Python variablar, berre referansar. (Om ein tenker
C kan ein sjå på som alt i Python er peikarar som alltid vert dereferert.)
Python skil skarpt mellom «statiske» og «variable» objekt, om ein utfører
ein operasjon på eit statisk objekt vil referansen verte endra til å peike
på eit nytt objekt som svarer til den utførte operasjonen.
@BulletList
	@ListItem { Alle taltypar, strengar, funksjonar og tuples er statiske. }
	@ListItem { Lister og dictionaries er variable. }
	@ListItem { Brukardefinerte objekt kan fungere både som statiske og
		variable. }
	@ListItem { Strengkonkatenering, som i @F { "\""SNOBOL"\"" + "\""-IV"\"" }
		vil dermed @I ikkje legge til @F -IV til @F { SNOBOL }, men derimot
		generere ein heilt ny streng. Tuples vil oppføre seg tilsvarande. }
@EndList
@End @Overhead

@Overhead
	@Title { Viktige metodar for lister og dictionaries }
@Begin
Det viktigaste einskildpoenget er funksjonen @F { dir() }. @F { dir(x) }
vil syne kva for metodar objekt gjer synlege for brukaren. Lister
og dictionaries støre mange fleire metodar enn nemnt her, men her er
nokre av dei aller viktigaste.
@BulletList
	@ListItem { @F liste.append(x) plasserer @F x på slutten av lista. }
	@ListItem { @F liste.sort() sorterer lista. }
	@ListItem { @F liste.reverse() reverserer lista. }
	@ListItem { @F liste.index(x) returnerer indeksen til første instans
		av @F x i lista. }
	@ListItem { @F dictionary.has_key(x) returner sant eller usant om
		@F dictionary henhaldsvis har eller ikkje har nøkkelen @F { x }. }
	@ListItem { @F dictionary.keys() returnerer nøklane til
		@F { dictionary }. }
	@ListItem { @F dictionary.values() returnerer verdiane lagra i
		@F { dictionary }. }
	@ListItem { @F dictionary.items() returnerer parvis alle
		nøklar og verdiar i @F { dictionary }. }
	@ListItem { @F dictionary.get(key, x) prøver å returnere
		@F { dictionary[key] }, om denne ikkje eksisterer vert
		@F x returnert. }
@EndList
@End @Overhead

@Overhead
	@Title { Funksjonar og intervall og funksjonsmapping }
@Begin
@CP {
def fact(n):
	if n == 0 or n == 1:
		return 1
	else:
		return n*fact(n-1)

print map(fact, range(10))
}
@LP @I Merk:
@IndentedList
	@ListItem { @F map returnerer ei liste der @F fact har vorte køyrt med
		kvart element i lista generert av @F range som argument. }
@EndList

@NP
@CP {
def fact2(n):
	if n == 0:
		return 1
	else:
		return reduce(lambda x,y: x*y, range(1, n+1))

print filter(lambda x: x > 5000, map(fact2, range(10)))
}
@LP @I Merk:
@IndentedList
	@ListItem { @F lambda er kun syntaktisk sukker for å opprette
		funksjonsobjekt i Python. }
@EndList
@End @Overhead


@Overhead
	@Title { Klasser, objekt og metodar }
@Begin
@CP {
class eksempel:
	fotpistol = []
	def __init__(self, data):
		self.data = data
	def skyt(self):
		print self.fotpistol
	def lad(self, kule):
		self.fotpistol.append(kule)
ammunisjon = eksempel("Det meste går.")
fot = eksempel(42)
ammunisjon.lad(1)
fot.lad(2)
fot.skyt()
}
@LP @I Merk:
@IndentedList
	@ListItem { @F fot.skyt sist i eksempelet vil skrive ut @F { [1, 2] }
		sia lister er variable objekt og metoden lad kun har aksessert
		klasse-attributten @F { fotpistol }. Hadde definisjonen av
		@F { fotpistol } vorte flytta til @F __init__ ville problemet
		ha vorte unngått. }
	@ListItem { Ein kan diverre ikkje arve frå typar i Python. (Det finst
		løysningar for dette, og problemet vil ikkje lenger vera aktuelt
		i Python 2.0.) }
	@ListItem { Ønsker ein å definere ei klasse som arver frå andre klasser:
		@F { class namn(Base1[, Base2, ...]): }. Søkerekkefølgen er
		«depth firsth, left to right.» }
	@ListItem { Operatoroverloading skjer ved å definere metodar med gitte
		namn, td @F { __add__ }. }
@EndList
@End @Overhead

@Overhead
	@Title { Namnerom og scoping }
@Begin
Python er «statisk skopa.» Alle symboloppslag vert gjort i følgande
rekkefølge:
@NumberedList
	@ListItem { Lokalt namnerom. Symbol definert innafor same metode
		eller funksjon. }
	@ListItem { Globalt namnerom for den aktuelle modulen. }
	@ListItem { Innebygde funksjonar. }
@EndList

@CP {
# Denne koden vil ikkje fungere
a = 12
def nokon_liker_basic():
	print a
	a = 0
}
@LP Eksempelet ovanfor fungerer ikkje av di Python ser tilordninga i
funksjonsdefinisjonen og går ut i frå at @F a er ein lokal variabel. Når
funksjonen så prøver å skrive ut @F a før han er tilordna fører dette til
ein feil. I tillegg vil heller ikkje den globale referansen @F a verte
oppdatert til 0, sjølv om ein ikkje hadde hatt ein funksjon som førte
til at funksjonen ikkje vart ferdig utført før ein kom til tilordninga.
Om ein faktisk @I vil gjera slike ting, må ein gjera som
følgande:
@LLP
@CP {
a = 12
def nokon_liker_basic():
	global a
	print a
	a = 0 
}
@LP Derimot vil det følgande eksemplet oppføre seg som venta:
@LLP
@CP {
a = 12
def nokon_liker_basic():
	print a
}
@LLP Dvs, det skriv ut talet 12.
@End @Overhead

@Overhead
	@Title { Exceptions }
@Begin
@CP {
TeitException = "Brukardefinert meta-unntak."
try: # Det er lov å nøste try-statements.
	try:
		raise TeitException
	finally:
		# Dette vert eksekvert uansett
		print "Her sett ein ofte clean-up kode."
except TeitException:
	# Dette vert eksekvert om det vert aktivert ein exception
	print "Denne teksten vil alltid verte skrive ut."
else:
	# Koden i else vert utfør om det ikkje vart aktivert
	# ein exception
	print "Denne teksten vert aldri skrive ut her."
}
@NP
@LP @I Merk:
@IndentedList
	@ListItem { Ein kan spesifisere fleire ulike «exception handlers» i serie.
		Om ein ikkje opplyser nokon spesifikk exception, dvs @F { except: },
		vil @I alle moglege exceptions verte fanga av den handleren. Om ein
		spesifiserer fleire ulike handlere, må difor ein slik settast sist. }
@End @Overhead

@Overhead
	@Title { Modular }
@Begin
@CP {
import string
from sys import version
# version er ein streng som til dømes kan sjå slik ut:
# 1.5.2 (#1, Jun 11 1999, 02:41:53)  [GCC 2.7.2.2+myc2]

print "Dette er Python, versjon", string.split(version)[0]
}
@LP @I Merk:
@IndentedList
	@ListItem { @F { from modul import * } vil importere alle symbol frå
		@F modul inn i namnerommet der ein køyrer importeringa. Dette er
		ein effektiv måte å lage vanskeleg vedlikehaldbar kode. }
	@ListItem { Ein gjer ikkje noko spesielt for å lage ein modul. Ei fil
		med funksjonsdefinisjonar er allereie ein modul. @F { import
		kjekkefunksjonar } vil søke gjennom ein sti definert i
		@F sys.path på jakt etter fila @F { kjekkefunksjonar.py }. }
@End @Overhead

@Overhead
	@Title { I praksis? }
@Begin
@BulletList
	@ListItem { @F { open("\""filnamn"\"", "\""modi"\"") } opner filobjekt. }
	@ListItem { @F string inneheld strengtenster. }
	@ListItem { @F re inneheld Perl5-liknande regexp-funksjonalitet. }
	@ListItem { @F os inneheld os-tenster som @F fork og @F { listdir }. }
	@ListItem { @F sys inneheld systemavhengige data og ein del grensesnitt.
		mellom anna til systemvariablar. }
	@ListItem { Denne lista bør avsluttast så fort som råd, da ho er
		@I { lang }. }
@EndList
@End @Overhead