Introduktion til programmering

Uge 43 Computer Science, kap 5 + 8 (minus kap 8.6).

Sidste gang

Funktioner som metode til at skrive anvendelsesorienterede programmer Metoderne i et modul kan tolkes som teknisk

implementering når vi læser modulet Men de kan tolkes som beskrivelser af

anvendelsesområdet når vi blot bruger modulet Indkapsling af implementeringsdetaljer.

Netværk og netværksopbygning Protokoller, smtp, http, ftp, pop3 osv. Netværksprogrammering i Python, smtp, http Operativsystemer (nåede vi ikke), styring af

filsystem, multiple processer osv.

Opgaver mm

Når I afleverer opgaver skal jeg have jeres tilrettede databasemodul. I skal aflevere så meget at jeg kan køre

jeres program. Jeg ved godt at der er problemer med

serveren, men det skulle gerne virke nu (håber vi, det gjorde det i går)

Plan Algoritmer

Definition Opbygning

Pseudokode (teoretisk) Analyse

Kompleksitet Eksempler

Binær søgning Øvelse 1 Rekursion (algoritmisk løsningsmodel)

Eksempler Binær søgning Generering af tekster

Datastrukturer Userdefined ADT (abstract data type) Eksempler Enkeltkædede lister, dobbeltkædede lister Stakke, køer Træer

Øvelse 2

Algoritmer 1 Der er forskellige definitioner Stort set konsensus om at: En algoritme genererer en ordnet, entydig og endelig sekvens af operationer der med garanti slutter Ordnet

Skridt efter hinanden, evt repetitioner Entydig

Ingen valgfrihed (deterministisk) Ingen flertydighed

Endelig Den vil slutte

... men måske først om 1000 år ... Kogebøger, strikkeopskrifter, how-to etc.

Muslingeprogrammet er en algoritme

Algoritmer 2 En algoritme i datalogien er en generel metode til at løse et

bestemt problemtype Eks. søge i en liste, sortere en liste.

“Et program = en algoritme” er noget sludder Programmer repræsenterer mange algoritmer der virker

sammen. Der findes mange algoritmer til at løse det samme problem

Lineær og binær søgning er to forskellige algoritmer De løser problemet at finde et element i en liste

Forskellige karakteristika Tid, plads Forskellige datatyper

træer, lister

Algoritmer, opbygning Algoritmer er sproguafhængige

Kan beskrives i mange forskellige sprog rettet mod mange forskellige fortolkere

Kan beskrives på en stiliseret sprogform, pseudokode Pseudokode er

en notationsform skrevet for en menneskelig fortolker men orienteret mod omskrivning i et programmeringssprog der

kan læses af maskiner Pseudokode kan Implementeres på mange måder så den kan

køre på en maskine Pseudokode beskriver generel struktur, ikke detailjer

Muslingeeksemplet

Så længe der er muslinger i spanden: Tag en musling op af spanden Hvis muslingen er lukket så:

Smid den i gryden Ellers:

Smid den i affaldsposen Struktureret dansk

Viser struktur men ingen detaljer Vælger danske konstruktioner der har en analog

til programmeringssprog Når vi forklarer hvordan et loop

fungerer er det også seudokode

Muslingeeksemplet 2

CS’s notation Ligner et programmeringssprog lidt mere () markerer afsnit der skal beskrives mere nøjagtigt Angiver hvilket input og output algoritmen skal have

Fordel (A, B, C) Input: en liste A af ting og to tomme lister B og C Output: A er tom. Tingene er fordelt på B og C while (der er ting i A) do:

(Tag en ting op af A) Hvis (tingen er lukket) så:

(Læg den i B) Ellers:

(Læg den i C)

I Python def fordel(A,B,C): while A <> []: enTing = A[0] del A[0] if enTing == 0: B.append(enTing) else: C.append(enTing) >>> A = [1,0,1,0,1,1,0] >>> B = [] >>> C = [] >>> fordel(A,B,C) >>> A [] >>> B [0, 0, 0] >>> C [1, 1, 1, 1]

I Java

I java ser det noget anderledes ud men det er den samme algoritme vi har implementeret.

Javaprogram

Et endnu mere formelt eks

Finder det største element i en liste Algorithm listMax (A, n):

Input: en liste A med n ≥1 tal Output: det største element i A currentMax ←A[0] for i ←1 to n-1 do

if currentMax < A[i] then currentMax ←A[i]

return currentMax

I Python

def listMax(A): currentMax = A[0] for i in range(1, len(A)): if currentMax < A[i]: currentMax = A[i] return currentMax

>>> listMax([1,3,2,4,9,4]) 9 >>>

Guideline

Udvikl algoritmen i struktureret dansk eller en lidt mere formel pseudokode

Check at logikken er OK Oversæt til programmeringssprog og

test algoritmen på eksempler Ret fejl

i logik i implementering

Publicer!

Algoritmer, analyse

Væsentligt område af datalogien Analyse af korrekthed og udførselstid Kræver følgende:

Sprog til at beskrive algoritmer Pseudokode eller struktureret dansk

En model for beregninger “Primitive operationer” (f.eks. en sammenligning)

En metrik Store Θ

Hvorfor? For at være maskinuafhængig

Primitive operationer

Tildelingsoperation currentMax = A[0]

Metodekald / funktionskald listMax([1,3,2,4,9,4])

Aritmetisk operation A = A+1

Sammenligning currentMax < A[i]:

Indeksering A[i]

Returnere fra en metode return currentMax

Eksempel ListMax initialisering : i= 1

1 operation initialisering: currentMax = A[0]

2 operationer Sammenligning i<=n

n operationer Løkken udføres n-1 gange:

currentMax < A[i] 2 operationer

Muligvis: currentMax = A[i] 2 operationer

i = i+1 2 operationer

Løkken indeholder 4 eller 6 operationer Returnering af værdi: return currentMax

1 operation

def listMax(A,n): i = 1 currentMax = A[i] while i <= n: if currentMax < A[i]: currentMax = A[i] i = i+1 return currentMax

X = [1,4,3,5,7,9,10]print listMax(X,len(X)-1)

Kompleksitet

For input n Best case: Hvis der aldrig sker noget med

currentMax 2+1+n+4(n-1) +1 = 5n Worst case: Hvis der altid sker noget med

CurrentMax 2+1+n+6(n-1)+1 = 7n-2

Konstanter smides væk O(n) Lineær udførelsestid, tiden vokser med inputtet

Store O

Store O betyder: En funktion er “mindre end eller lig med” en

anden funktion der udvikler sig på en bestemt måde

O(n): den anden funktion er lineær Logaritmisk: O(log n) - binær søgning Lineær: O(n) - sekventiel søgning Kvadratisk: O(n2)

Vi ser kun på den generelle kurve

Lineær: n Kvadratisk: n2

Logaritmisk: log2 n

Tid

Antal genstande

lineærparabolsk

Her vinder den logaritmiske metoder over

den parabolske

logaritmisk

Eksempel: Søgning

Problem: Givet en mængde data, søg efter et element der opfylder et kriterie Eks: find største element i en liste

Algoritmevalg afhænger af egenskaber ved mængden af data Usorteret: sekventiel søgning Sorteret: Binær søgning

Sekventiel søgning

Gennemløber hele mængden (listen) en efter en

Skal se på alle elementer i det værste tilfælde

Lineær Eks: givet en liste, findes elementet

med værdien ‘88’ i listen? O(n)

Binær søgning

Forudsætter at listen er sorteret!!! Forudsætter man kan indeksere alle

indgange direkte (ikke linked lists) Halvering af søgeområdet i hvert skridt O(log n) antal søgninger hvis der er 1024 elementer

er max log2(1024) = 10 fordi 210 = 1024 1024, 512, 256, 128, 64, 32, 16, 8, 4, 2

Binær søgning, Pseudokode procedure binSearch(x, nums): Input: sorteret liste nums plus et tal x som vi vil søge på Output: tallets position i listen hvis det findes, ellers -1 low = 0 high = (nummeret på listens sidste element) while (der stadig er noget at søge i) do: mid (midten af listen afgrænset ved low og high) item (elementet der ligger i midlten) if x= item then: return mid else if x < item: high mid – 1 (første halvdel af listen) else: low mid + 1 (sidste halvdel af listen) return -1

Binær Søgning, Python def binSearch(x, nums): low = 0 high = len(nums)-1 while low <= high: mid = (low + high)/2 item = nums[mid] if x == item: return mid elif x < item: high = mid - 1 else: low = mid + 1 return -1 aList = [1,2,5,7,10, 12, 67, 100] print binSearch(12,aList) print binSearch(234,aList) --- >>> 5 -1 >>>

Binær søgning

Søgning efter 12 [1, 2, 5, 7, 10, 12, 67, 100] 0 3 7 7 [1, 2, 5, 7, 10, 12, 67, 100] 4 5 12 7 5

Søgning efter 234 [1, 2, 5, 7, 10, 12, 67, 100] 0 3 7 7 [1, 2, 5, 7, 10, 12, 67, 100] 4 5 12 7 [1, 2, 5, 7, 10, 12, 67, 100] 6 6 67 7 [1, 2, 5, 7, 10, 12, 67, 100] 7 7 100 7 -1

def binSearch(x, nums): low = 0 high = len(nums)-1 while low <= high: mid = (low + high)/2 item = nums[mid] #dump variables print nums, low, mid, item, high if x == item: return mid elif x < item: high = mid - 1 else: low = mid + 1 return -1

nums, low, mid, item, high

position værdiposition position

Forskellen mellem lineær og binær søgning

Viser sig først ved store datamængder En liste på 12 000 000 ord Lineær søgning:

I snit 6 000 000 sammenligninger Worst case: 12 000 000!

Binær søgning Worst case: 24 sammenligninger!

Algoritmer tommelfingerregler

Heldigvis er mange af de algoritmer vi skal bruge såsom sortering osv. implementeret i Python så vi ikke selv behøves at gøre det. Eller også er der rig mulighed for at finde eksempler på nettet, så vi ikke skal begynde helt fra bunden

Når vi skal lave vores egne algoritmer skal vi ikke i første omgang tænke på hastighed, men bare at få det til at virke. Vi kan altid erstatte en algoritme med en anden, hvis vi finder ud af at den er for langsom eller at der findes andre til at erstatte den med

Det er typisk kun i arbejdet med store data-sæt vi skal være opmærksomme

Øvelse 1

Implementer database i MySQL

Rekursion

Det at løse en delopgave efter samme metode som hovedopgaven

Del og hersk Rejse fra Århus til København

Rejse fra Århus til Æbeltoft Rejse fra Æbeltoft til Odden Rejse fra Odden til København

Fortælle en historie Fortælle om miljø og personer Fortælle om hovedpersonernes strid Fortælle om udfaldet

Meget elegant måde at løse et problem på

Syntaktisk specifikation af programmeringssprog Uddrag fra Pythons specifikation

compound_stmt ::= if_stmt | while_stmt | … if_stmt ::=

"if" expression ":" suite ( "elif" expression ":" suite )* ["else" ":" suite] suite ::= … |NEWLINE INDENT statement+ DEDENT statement ::= … |compound_stmt

Notation ::= betyder ’består af’. | betyder ’eller’ [] betyder frivilligt ()* betyder ’nul eller flere gange’ ()+ betyder ’en eller flere gange’

Effektiv rekursion

Fremgangsmåde Basis tilfældet:

Involverer ikke rekursion men kun primitive operationer der umiddelbart kan udføres

Det rekursive tilfælde: Involverer rekursion men for et simplere

problem

Rekursiv binær søgning def binSearchStart(x, nums): print 'binary recursive search after ' + str(x) + ' in ' + str(nums) return binSearchRec(x, nums, 0,len(nums)-1) def binSearchRec(x, nums,low,high): if low <= high: mid = (low + high)/2 item = nums[mid] if x == item: #base case return mid elif x < item: #recursive case return binSearchRec(x, nums, low, mid - 1 ) else: #recursive case return binSearchRec(x, nums, mid+1, high) else: #base case return -1

Basistilfældet: primitiv operation: return True

Rekursion 1: en mindre liste

Rekursion 2: en mindre liste

Endnu et rekursivt eksempel

Er det givne ord et palindrom? def palindrome(string): if(len(string) <= 1): #er længden nul eller én så sandt return True elif string[0] == string[len(string)-1]: #ellers, er den første og sidste karakter ens? return palindrome(string[1:-1]) #hvis ja skær dem fra og kald funktionen igen else: return False

if __name__ == "__main__": print palindrome("aibohphobia")

>>>True

Saippuakivikauppias, Finnish for "soap-stone vendor"

Rekursiv generering af sætninger S ::= N VP NP ::= N | N som VP | at S VP ::= VT NP | VI N ::= Anders | Bent | Christina VT ::= så | hørte | forstod VI ::= løb | sov | lo

Kommer som opgave i uge 45

S

NP

VPOrdbog: basistilfælde

Syntaks: rekursivt tilfælde

Eksempler

Anders lo Anders så Bent som forstod at Anders lo Anders forstod Bent Bent opdagede Anders Bent forstod Anders Anders hørte at Bent løb Anders løb Bent hørte Christina som løb Bent forstod Anders som løb Anders opdagede Anders som sov Anders hørte Christina som forstod Bent Anders forstod Christina som løb Bent forstod Christina som sov

Anders så Bent Christina løb Bent hørte Bent Anders så Bent som hørte Bent Anders sov Christina lo Christina forstod Christina som lo Bent så Bent Christina sov Christina opdagede Bent som så Anders Bent sov Anders så at Anders forstod at Christina sov

Mulig implementering

kategori ::= mulighed1 | mulighed2 | … mulighedn def kategori(): choice = random.randint(1,n) if choice == 1: return mulighed1 elif choice == 2: return mulighed2 … else: return mulighedn

Eksempel Regel:

NP ::= N | N som VP | at S Implementering:

def NP(): choice = random.randint(1,3) if choice == 1: return N() elif choice == 2: return N()+ ' som' + VP() else: return ' at' + S()

Eksempler Anders løb Christina så at Christina løb Anders opdagede Bent som sov Anders løb Bent så Anders

Basistilfælde

Rekursivt tilfælde

Rekursivt tilfælde

import randomRandom tilbyder en række funktioner der har med tilfældighed at gøre

Datatyper

Datatyper Datatyper er

Mulige værdier, samt relaterede operationer

Eks. Integers (heltal) Værdier: alle hele tal fra -∞ til ∞ Reelt: begrænset af maskinen Operationer: +, -, *, / etc.

Typesystemet kan udvides Brugerdefinerede typer: sammensatte værdier (og operatoroverloading)

Konto: ejer, indestående, renteprocent ADT, Abstrakte Data Typer: brugerdefinerede typer + operationer

Konto: ejer, indestående, renteprocent (og) hæve, indsætte, rentetilskrivning Klasser og objekter: ADT + nedarvning

I python ligner typer klasser Moduler indeholder ofte klasser man kan bruge

Definition af klasser class Konto: def __init__(self,navn, indestaaende, rentesats): self.navn = navn self.indestaaende = indestaaende self.rentesats = rentesats

def indsaet(self,beloeb): self.indestaaende += beloeb

def haev(self,beloeb): self.indestaaende -= beloeb

def tilSkrivRenter(self): self.indestaaende += self.indestaaende * self.rentesats/100

def udSkrivSaldo(self): print 'Saldo for ' + self.navn print self.indestaaende

Brug af klasser >>> minKonto = Konto('Peter Vahlstrup',1000,5) >>> minKonto.udSkrivSaldo() Saldo for Peter Vahlstrup 1000 >>> minKonto.indsaet(200) >>> minKonto.udSkrivSaldo() Saldo for Peter Vahlstrup 1200 >>> minKonto.haev(100) >>> minKonto.udSkrivSaldo() Saldo for Peter Vahlstrup 1100 >>> minKonto.tilSkrivRenter() >>> minKonto.udSkrivSaldo() Saldo for Peter Vahlstrup 1155 >>>

minKonto UML

minKonto.indestaaende

minKonto.indsaet()

+indsaet()+haev()+tilSkrivRenter()+udSkrivSaldo()

-navn-indestaaende-rentesats

Konto Navn

Attributter

Metoder

Lister Værdi:

nul eller flere elementer Operationer:

append(...) count(...) extend(...) index(...) insert(...) pop(...) remove(...) Reverse (...) sort(...)

Man skriver navnet på objektet, ’.’, plus operationen x.append(7)

Objekt

listeelementer

operationer

Repræsentamen

X

x.operation()

Typer og instanser Eksperiment

>>> type(1) <type 'int'>

>>> type(int) <type 'type‘>

>>> type(type) <type 'type'>

>>> type(Konto) <type 'classobj'>

>>> type(minKonto) <type 'instance'>

Typer og deres medlemmer er forskellige objekter. Forskellen mellem en kageform og en kage.

1 er en instans (er medlem) af typen int. Int er ikke selv en instans of int men af typen type. (men Type er selv en instans of typen Type!)

Bruger-definerede typer

Eksempler Enkelt-trådede lister Dobbelt-trådede lister Stakke Køer Træer

Skal implementeres ved hjælp af eksisterende operationer

Disse skjules for brugeren af typen

Enkelt-trådede lister Skal ikke forveksles med python lister [] En liste er en række elemeter der er kædet sammen. Hvert

element indeholder en variabel, next, der peger på næste element i listen, og vil desuden ofte indeholde en anden værdi med data

Vi har “adgang” til det første element i listen, og derigennem det næste (Egon Olesen fører til James Bond, der fører til Rambo)

Men vi kan ikke gå baglæns (Dirty Harry fører ikke til noget)

Head Nil

Egon Olsen

James Bond Rambo Dirty Harry

nextdata

Dobbelt-trådede lister

Data, next og prev Her kan vi gå begge vejeHead Tail

Egon Olsen

James Bond Rambo Dirty Harry

Stak LIFO Har følgende metoder: push(elem) -> nil: påtag dig ny opgave og udsæt den nuværende pop() -> elem (sletter): afslut nuværende og genoptag afbrudt opgave top() -> elem (sletter ikke): hvad var det jeg var i gang med isEmpty() -> boolean: er jeg færdig for i dag? size() -> integer: hvor mange ting venter?

Stakpointer

Stakkens basis

Skrive under

Arrangere konference

Møde med specialestuderende

Kø

En kø er FIFO Har følgende metoder:

enqueue(elem) -> nil: stil dig i kø dequeue() -> elem at front: betal ved kassen size() -> integer: hvor mange kunder venter? isEmpty() -> boolean: er køen tom?

Tail Head: kasseapparatet

Jensen Olsen Hansen Karlsen

Træer En datastruktur bestående af en række knuder (noder)

En node kan have nul eller flere børn og nul eller én forælder En node uden børn kaldes et blad.

Direktør

Mellemleder Mellemleder Mellemleder

Arbejder Arbejder Arbejder Arbejder Arbejder Arbejder

Rod

Arbejder

Knude

Blad

Tolkning af abstrakte datastrukturer

RepræsentamenAbstrakte datastruktuerer

ObjektProblemområdet

Interpretant1. Python

2. Tolkningsregler

Repræsentation Objekt

Lister Associationer

Stakke Web-browser (LIFO)

Køer Køer i supermarkedet (FIFO)Trafikpropper

Træer Helheder og deleOverordnet og underordnet

I Python

Igen er de fleste af disse strukturer implementeret i python så før man begynder at lave en stak eller en kø (collections modulet) slår man lige op i dokumentationen

Næste gang XHTML og CSS

Ved godt det er mange sider Læs overfladisk, det skal mest bruges

som opslagsværk

Øvelse 2

Lav de 8 forskellige kald til databasen