Introduktion til programmering Uge 40 Python 2 Learning Python, kap 8-12.
Plan Sidste gang Sætninger og udtryk Kontrolstrukturer Selektion If : Gentagelse While : For : Funktioner Stand-up programmering Dokumentation Fjerde obligatoriske øvelse
Sidste gang Navne, værdier og typer Objekter Type(værdi) Id(variabel) Simple typer (scalarer) Tekst (string), index, slicing Tal (int, float) Sammensatte typer List [] Tuple () Dictionary () Udtryk
Repetition af udtryk 'Peter'[1:3][::-1] = 'te. Hvorfor?
Udtryk Udtryk (expression): noget der repræsenterer en værdi 1 repræsenterer et heltal Peter repræsenterer en tekst (string) Et sammensat udtryk er en kombination af andre udtryk og operatorer der repræsenterer og producerer en (ny) værdi 1 + 2 repræsenterer 3 et tal 'Peter'[1:3] repræsenterer 'et en tekst [1,2,3][1] repræsenterer 2 et tal [1,2,3][0:2] repræsenterer [1, 2] en liste [1:3] repræsenterer en operation
Semiotisk set Udtryk er repræsentationer Deres objekt er værdier De frembringer de værdier de repræsenterer Det gør de naturlige sprog ikke At sige en Peugeot 307 frembringer ingen bil Men at skrive 'Peter'[1:3] frembringer teksten 'et' Interpretant: en udførelse Repræsentamen: termer og udtryk Objekt: værdier, f.eks. tekster, tal, lister, tupler, dictionaries
'Peter'[1:3][::-1] = 'te. Hvorfor? Fortolkningen af udtryk består i at frembringe det objekt de repræsenterer Fortolkning Repræsentation Objekt
'Peter'[1:3][::-1] = 'te. Hvorfor? I te O R I et O R slicing O Repræsentati oner der er aflæselige for maskinen Peter O slicing O I I R R R 'Peter' [1:3] [::-1] Repræsentationer der er aflæselige for mennesker
Sætninger og udtryk Programmer består af et eller flere moduler Moduler består af sætninger (statements) Sætninger indeholder udtryk Udtryk repræsenterer og producerer værdier Sætninger Sætninger repræsenterer ikke værdier Sætninger regulerer hvordan værdierne produceres Eksempel >>> len('peter') 5 >>> x = 'peter >>> Udtryk: producerer 5 sætning: producerer ingenting men ændrer variables værdier
Sætninger og udtryk i naturlige sprog Udtryk svarer til navneord der henviser til ting eller handlinger Sætninger svarer til ytringer der udfører en sproghandling: ordrer, påstande, løfter, følelsesudbrud gryde.append(enmusling) Læg en musling i gryden
Påstande Boolske udtryk Udtryk der repræsenterer værdierne sand eller falsk. De repræsenterer værdierne 1 og 0 (i nyere versioner True og False) Naturlige sprog: påstande Bussen går kl. 9.13. Det er løgn! Nogle sproghandlinger som ordrer kan hverken være sande eller falske Gå nu op i bussen + Det er løgn lyder mærkeligt. >>> 1 + 3 == 4 True >>> 'Peter' == 'Karl False >>> 'Peter' <> 'Karl True
Sandhedsværdier Boolske operatorer And, or, not Boolske udtryk producerer nye sandhedsværdier af gamle sandhedsværdier >>> 1+2 == 3 and 4+5 == 9 True >>> not (1+2 == 3 and 4+5 == 9) False >>> (1+2 == 3 or 1+2 == 9) True
Sandhedstabeller p q p and q p q p or q false false false false false false false false false false false false p Not q false false
Nye operatorer kan defineres ved de gamle P implies Q = not(p and not(q)) = not(p) or Q Hvis P så Q p q Not p not (p) or q false false false false false false false
Naturlige sprog og logiske Naturlige sprog lægger en årsagsfortolkning ind i hvis-så Det gør logikken ikke p false q false Not p false false not (p) or q false Hvis 2 + 2 = 5, så vinder socialdemokraterne næste valg false false Logisk: altid sand fordi 2 + 3 = 5 er logisk falsk Naturligt sprog: nonsens (eller ironisk) fordi der ikke er nogen årsagssammenhæng
If-kontrolstruktur if <boolsk udtryk> : if <boolsk udtryk>: er en <handling1> selektionsstruktur <handling2> <boolsk udtryk> skal repræsentere en sandhedsværdi Handlingssætningerne udgør en blok Blokke er indenteret med tabulator eller mellemrum Brug tabulator
if if-sætninger kan indeholde mange forskellige betingelser if <noget> : <h1> <h2> <hn> elif <nogetandet> : <h1> <hn> else: <h1>
Porfyrs træ if raw_input('legemlig substans?') == 'ja': print 'Ja. Legemlig substans' if raw_input('levende?')== 'ja': print 'Ja.Levende organisme' if raw_input('ja. Sansende?')== 'ja': print'ja. Et dyr' if raw_input('rationelt?')== 'ja': print 'Ja. Rationelt dyr' if raw_input('doedelig?')== 'ja': print 'Ja. Et menneske' else: print 'Nej. Gud' else: print 'Nej. Et dyr' else: print 'Nej. En plante' else: print 'Nej. Doed natur (sten, jord)' else: print 'Nej. Et begreb'
Eksempler materialer\ifsætninger.py Eksempel 1 Legemlig substans? Ja. Kropslig levende? Ja.Levende organisme Sansende? Ja. Et dyr rationelt? Ja. Rationelt dyr doedelig? Nej. Gud Eksempel 2 Legemlig substans? Ja. Kropslig levende? Ja.Levende organisme Sansende? Nej. En plante
While While <boolsk udtryk>: Statement Statement Checker om <boolsk udtryk> er sandt. Hvis det er, udføres den efterfølgende blok. Ellers springes til det statement der følger efter blokken
While filename = raw_input('indtast navn på file: ') if filename == '': filename = 'entekst.txt' myfile = open(filename,'r') ##open the file aline = myfile.readline() ##read the next line from the file nol = 0 #number of lines now = 0 #number of words while aline <> '': #as long as aline is not empty nol += 1 #increase the linecounter thewords = aline.split(' ')#split the line into words now = now + len(thewords)#increase the word counter by the number of words aline = myfile.readline()#read the next line from the file print 'The number of lines is ' + str(nol) print 'The number of words is ' + str(now) Kør linjetæller med entekst.txt
For For <navn> in <sequence>: Statement Statement Navn kommer til at referere til medlemmerne af <sequence>, fra første til sidste Meget hyppigt brugt
Brug af for tabel = [{'fornavn':'peter','efternavn':'andersen','adresse':'vestergade'},\ {'fornavn':'karen','efternavn':'jensen','adresse':'oestergade'},\ {'fornavn':'hans','efternavn':'karlsen','adresse':'vestergade'}] kolonnenavne = ['fornavn','efternavn']#de kolonner vi oensker at faa udskrevet betingelse = {'adresse':'vestergade', 'efternavn':'jensen'}#de betingelser en raekke skal opfylde #opgave 1: Skriv en algoritme der udskriver #1. de oenskede kolonner i #2. alle raekker hvor en af betingelserne er opfyldt (en OR-betingelse) Kør database 2 #opgave 2: Skriv en algoritme der udskriver #1. de oenskede kolonner i #2. alle raekker hvor alle betingelser er opfyldt (en AND-betingelse) Kør database 3
Select med OR-betingelse betingelse = {'adresse':'vestergade', 'efternavn':'jensen'} resultat = [] #gennemloeb alle raekker i tabellen for raekke in tabel: #gaet paa at raekken ikke duer success = False #gennemloeb alle stikordord i betingelsen for stikord in betingelse.keys(): #hvis vaerdien af stikordet i betingelsen = vaerdien af stikordet i raekken if betingelse[stikord] == raekke[stikord]: #raekken duede alligevel success = True #hop ud af loekken break if success == True: #hvis raekken duede, tilfoej raekken til resultatet resultat.append(raekke) tabel = [{'fornavn':'peter','efternavn':'andersen','adresse':'vestergade'}, {'fornavn':'karen','efternavn':'jensen','adresse':'oestergade'}, {'fornavn':'hans','efternavn':'karlsen','adresse':'vestergade'}]
Afbrud af løkker Break: hopper ud af den inderste loop Continue: hopper op til loopens betingelse Pass: gør ingenting
Funktioner Funktioner er en måde at gruppere sætninger så de kan kaldes igen og igen Et funktionsnavn repræsenterer et funktionsobjekt (callable object) Det er en måde at strukturere et program i overskuelige enheder To keywords: Def : sætter et navn til at referere til et funktionsobjekt Return: får funktionen til at returnere en værdi (et objekt)
Funktioner def funktionsnavn ( param1, param2,..., paramn): sætning1 sætning2... sætningn return resultat
Eksempel Funktionens navn def udskrivomvendt(tekst): return tekst[::-1] >>>x = udskrivomvendt('peter') >>> x 'retep Parametrene Beskrivelse af selve funktionen (callable object) Interpretant udførelse Repræsentamen funktionsnavn Objekt Callable object
Pass by reference Parameternavne refererer til samme objekt som de aktuelle parametre Samme objekt hedder to forskellige ting Pas på! x = [1,2,3] def func(y): del(y[0]) x R O >>> func(x) [1,2,3] >>> x O [2, 3] y R
Naturlige sprog Hvis Anders Foghs vælgertilslutning er 40 % Og Anders Fogh refererer til samme person som Danmarks statsminister Så er det sandt at Danmarks statsministers vælgertilslutning også er 40 %
Scope Navne der oprettes inden i en funktion er forskellige fra identiske navne der bruges uden for funktionen Det område hvor et navn gælder kaldes dets scope Det er altid det mindste scope der gælder Deres reference er også forskellige Analogi: I familiens skød betyder Anders snothvalpen henne i sofaen I den politiske offentlighed betyder Anders Danmarks statsminister Sæt nuværende_scope til det omgrænsende scope af navnets forekomst Så længe vi ikke har fundet navnet: Findes navnet i nuværende_scope: Ja. Bruge dette navns reference Nej: sæt nuværende_scope til det omgrænsende scope af nuværende_scope Hvis vi ikke har fundet navnet Giv en fejlmeddelelse
Globale og lokale variable def func(): z =[] z = [1,2,3] func() z [1, 2, 3] def func() global z z = [] func() z [] [] 1,2,3
Læseøvelse #Hvad gør de to funktioner? def enfunktion (sekvens1, sekvens2): resultat = sekvens1[:] for x in sekvens2: if not(x in sekvens1): resultat.append(x) return resultat def enandenfunktion(sekvens1,sekvens2): resultat = sekvens1[:] for x in sekvens1: if not(x in sekvens2): resultat.remove(x) return resultat
To funktioner def union (sekvens1, sekvens2): resultat = sekvens1[:] for x in sekvens2: if not(x in sekvens1): return resultat resultat.append(x) def intersection(sekvens1,sekvens2): resultat = sekvens1[:] for x in sekvens1: if not(x in sekvens2): return resultat resultat.remove(x) Kør mængdeteori
Funktionsværdier Funktioner i Python er first-class citzens Et funktionsnavn refererer til en værdi med typen function >>> type(func) <type 'function'> >>> Derfor kan man tildele et andet navn funktionsobjektet som værdi
Funktionsnavne Man kan sætte et andet navn til at referere til funktionsobjektet >>> foreningsmængde = union >>> foreningsmængde([1,2,3],[4,6]) [1, 2, 3, 4, 6] Man kan også bruge et funktionsnavn som parameter i en anden funktion [1, 2, 3, 4, 5, 6] foreningsmængde funktion [1,2,3] [4,5,6] union
Funktioner som parametre def do(sekvens1,funktion, sekvens2): return funktion(sekvens1, sekvens2) I overskriften optræder funktionen som parameter - som data der flyttes I kroppen optræder funktionen som noget der kan kaldes Von Neumann igen!
Funktionsnavn og funktionsresultater Do er en metafunktion der sætter andre funktioner sammen med deres argumenter print do([1,2,3],union,[3,4,5]) [1, 2, 3, 4, 5] Funktionsnavnet union bruges som parameter og dets værdi udføres i do funktionen. Resultatet af funktionskald kan også også bruges som parameter print intersection( union([1,2,3],[3,4,5]),[1,4]) [1, 4] Resultatet af Union ([1,2,3],[3,4,5]), nemlig [1, 2, 3, 4, 5], gives som parameter til Intersection hvis anden parameter er [1,4] Union repræsenterer en funktion Union ([1,2,3],[3,4,5]) repræsenterer en liste.
Apply Apply er en generel indbygget metafunktion der knytter funktionsnavne til deres parametre. print apply(union, ([1,2,3], [3,4,5])) [1, 2, 3, 4, 5]
Kald af funktioner Et funktionskald repræsenterer en sammenstilling af en funktion og nogle værdier Disse repræsenterer og producerer funktionens resultat liste O R funktion O liste O liste O Apply R R R Union' [1,2,3] [3,4,5]
Naturlige sprog Kancellisprog foretrækker ofte metafunktioner og beskriver funktioner ved navneord Funktion Parameter Ransag (mistænktes hus) Metafunktion Funktions navn Parameter Foranstalt (en ransagelse af mistænktes hus)
Returnering af flere værdier fra en funktion Brug en tupel Brug tupel-unpacking def funktion(a,b): res1 = a+b res2 = a* b res3 = a-b return (res1,res2,res3) x,y,z = funktion(23,34)
if name == main : Hvordan undgår man at få udført eventuelle sætninger i et modul? def f1(): pass def f2(): print Morten if name == main : f1() f2()
Opsummering Store dele af Python kan forstås gennem følgende simple model: En repræsentation/udtryk står for et objekt/en værdi Fortolkningen af et udtryk producerer det objekt som repræsentationen står for Kombinationen af en funktion/operation plus andre værdier producerer en nye værdi Et funktionsnavn står for et funktionsobjekt print intersection <function intersection at 0x011851B0> Repræsentation Simpelt udtryk Operationer Sammensatte udtryk Funktionsnavn Funktionskald Sætning Objekt, Værdi Liste, tekst, tupel, boolsk værdi, dictionary, heltal Operation Værdien af udtrykket funktionsobjekt Værdien af det der returneres Ingenting Eksempel [1,2,3], peter, (2,3,4), True [1:3], and, + str((12+34))[1] == 6, 1 > 2 == False intersection repræsenterer 0x011851B0 der igen repræsenterer et funktionsobjekt intersection([1,2,3],[2]) repræsenterer en liste
Indkapsling og fortolkningsskift Funktionsnavne er også en metode til at skifte fortolkning Funktionens navn repræsenterer én del af verden f.eks. problemområdet Funktionens indre repræsenterer en anden del af verden f.eks. computeren. Repræsentation af begivenheder i computeren Repræsentation af begivenheder i problemområdet Husk første forelæsning!
Programtekstens to tolkninger Interpretant: programudførelse Interpretant: madlavning Objekt: Funktionsobjekt er, lister, etc. representamen: programtekst Objekt: (domæne) muslinger
Afsnit 2: madlavning #en verden af muslinger og koekkenredskaber (spand, gryde,affaldspose) = KoekkenUdstyr() FyldMed(spand,NogleMuslinger()) Toem(gryde) Toem(affaldspose) while DerErNogetI(spand): enmusling = TagOpAf(spand) if ErLukket(enmusling): LaegI(enmusling,gryde) else: LaegI(enmusling,affaldspose)
Afsnit 1: maskinen #en verden af lister og tal def KoekkenUdstyr(): return ([],[],[]) def NogleMuslinger(): return [1,0,0,1,0,1,0,] def TagOpAf(enKontainer): EtElement = enkontainer[0] del enkontainer[0] return EtElement def LaegI(etElement,enKontainer): enkontainer.append(etelement) def FyldMed(enKontainer, etindhold): enkontainer.extend(etindhold) def Toem(enKontainer): del(enkontainer[:]) def DerErNogetI(enKontainer): return enkontainer <> [] def ErLukket(etElement): return etelement == 0 def KoekkenTilstand(spand, gryde, affaldspose): print ''' spandens indhold: %s. Grydens indhold: %s. Affaldsposens indhold: %s''' % (spand, gryde, affaldspose)
Programmer Kør muslingemodul og muslingemodulbruger
Endnu tættere på domænefortolkning bucket = Container() pot = Container() wastebag = Container() you.fill(bucket,'with', Mussels()) while bucket.contains(mussel): you.take(it, 'from', bucket) if it.isclosed(): you.put(it,'into', pot) else: you.put(it,'into', wastebag)
Moduler Moduler er Pythonprogrammer der kan bruges fra andre Pythonprogrammer Læg jeres moduler i mappen Lib De importeres ved at bruge kommandoen import. Import <modulnavn> From <modulnavn> import * Moduler kan indkapsle en verden man ønsker at bruge men ikke at forstå. Modulet beskriver hvordan dets verden fungerer i detaljer men man behøver kun at vide hvordan man bruger dets verden Vi tager alle funktionerne ud af programmet og lægger dem i et modul. Når vi skal skrive programmer om muslinger, importerer vi modulet.
Et muslingemodul #en verden af lister og tal def KoekkenUdstyr(): return ([],[],[]) def NogleMuslinger(): return [1,0,0,1,0,1,0,] def TagOpAf(enKontainer): EtElement = enkontainer[0] del enkontainer[0] return EtElement def LaegI(etElement,enKontainer): enkontainer.append(etelement) def FyldMed(enKontainer, etindhold): enkontainer.extend(etindhold) def Toem(enKontainer): del(enkontainer[:]) def DerErNogetI(enKontainer): return enkontainer <> [] def ErLukket(etElement): return etelement == 0 def KoekkenTilstand(spand, gryde, affaldspose): print ''' spandens indhold: %s. Grydens indhold: %s. Affaldsposens indhold: %s''' % (spand, gryde, affaldspose)
Et program der bruger muslingemodulet from muslingemodul import * (spand, gryde,affaldspose) = KoekkenUdstyr() FyldMed(spand,NogleMuslinger()) Toem(gryde) Toem(affaldspose) KoekkenTilstand(spand, gryde, affaldspose) while DerErNogetI(spand): enmusling = TagOpAf(spand) Vi kan nu næsten skrive if ErLukket(enmusling): programmet i et sprog som LaegI(enmusling,gryde) hører til muslingetilberedning else: LaegI(enmusling,affaldspose) KoekkenTilstand(spand, gryde, affaldspose)
Hvad skete der? Vi fik skabt kohærens kohærens forekommer når teksten har et tema der kan arrangeres i simple symmetriske strukturerer med et begrænset sæt af dimensioner. Dimensionerne kaldes for tekstens isotopi fordi de er meninger som kommer igen i mange sætninger og ord. (tak til Ole Togeby: Praxt 1992) Symmetrier: Isotopier: TagOpAf(enKontainer) vs LaegI(etElement,enKontainer) FyldMed(enKontainer, etindhold) vs Toem(enKontainer) Ned i eller op af en kontainer Fyldt eller tom Ingen eller flere muslinger Åben eller lukket
Kommentarer & Docstring Kommentarer i pythonprogrammer starter med # Kommentarer ignoreres af fortolkeren Docstring er en kommentar der gemmes med koden def funktion(): Dette er en docstring pass
Docstring dir() an alphabetized list of names comprising (some of) the attributes of the given object, and of attributes reachable from it dir(str), dir(list) help(str.startswith) Dir(muslingemodul) Help(muslingemodul) Help(muslingemodul.LaegI)
Muslingemodulet '''Dette modul tilvejebringer metoder til tillavning af muslinger. Koekkenudstyr: Ingenting --> liste, liste, liste. Returnerer tre lister TagOpAf: Liste --> element LeagI: Element, Liste --> ingenting. Tilfoejer elementet til listen FyldMed: Liste1, Liste2 --> Ingenting. Tilføjer Liste2 til Liste 1 Toem: Liste --> ingenting. Toemmer listen DerErNogetI: Liste --> True eller False. Sand hvis listen ikke er tom ErLukket: Element --> True eller False. Sand hvis elementet er 0 KoekkenTilstand: Printer køkkentilstanden ud'''
Dir >>> dir(muslingemodul) ['DerErNogetI', 'ErLukket', 'FyldMed', 'KoekkenTilstand', 'KoekkenUdstyr', 'LaegI', 'TagOpAf', 'Toem', ' builtins ', ' doc ', ' file ', ' name ']
Help help(muslingemodul) Help on module muslingemodul: NAME muslingemodul FILE c:\documents and settings\imvpba\my documents\dokumenter\undervisning\underv. årh\e06\programmering\peters slides\muslingemodul.py DESCRIPTION Dette modul tilvejebringer metoder til tillavning af muslinge Koekkenudstyr: Ingenting --> liste, liste, liste. Returnerer tre lister TagOpAf: Liste --> element LeagI: Element, Liste --> ingenting. Tilfoejer elementet til listen FyldMed: Liste1, Liste2 --> Ingenting. Tilføjer Liste2 til Liste 1 Toem: Liste --> ingenting. Toemmer listen DerErNogetI: Liste --> True eller False. Sand hvis listen ikke er tom ErLukket: Element --> True eller False. Sand hvis elementet er 0 KoekkenTilstand: Printer køkkentilstanden ud FUNCTIONS DerErNogetI(enKontainer) ErLukket(etElement) FyldMed(enKontainer, etindhold) KoekkenTilstand(spand, gryde, affaldspose) KoekkenUdstyr() LaegI(etElement, enkontainer) TagOpAf(enKontainer) Toem(enKontainer)
Docstrings I muslingemodulet def LaegI(etElement,enKontainer): '''læg noget ned i kontainer''' enkontainer.append(etelement) >>> help(muslingemodul.laegi) Help on function LaegI in module muslingemodul: LaegI(etElement, enkontainer) læg noget ned i kontainer
Øvelse 4..\øvelser\øvelser\øvelse 4.doc