Introduktion til programmering

Introduktion til programmering

Programmeringssprog

Uge 44 Computer Science, kap 6. Learning Python: kap 13, 14.

Plan

Programmeringsparadigmer Funktionel programmering i Python Pause Scope: ”referencekonteksten” Oversættelse og kompilering

Generel udviklingstendens

Repræsentation af maskinelle processer repræsentation af processer i problemområdet

Portabilitet Væk fra maskinafhængighed (python, java etc.)

Abstraktion, aggregering og indkapsling Menneske tilpasser sig maskine maskine

tilpasser sig menneske

Naturlige og formelle sprog

Naturlige sprog Udvikler sig gradvist Distribueret udvikling Interpretanten til forhandling

Formelle sprog Udvikler sig i spring

Python 2.3 Python 2.4 Centraliseret udvikling Interpretanten ikke til forhandling

SYNTAX ERROR Fælles træk

Syntaks, semantik, pragmatik Udvikling afspejler praktiske udtryksbehov

Programmeringsparadigmer

Programmeringsparadigmer

Imperative / procedurelle Python, C, FORTRAN, ALGOL

Objektorienterede python, C++, smalltalk, java

Funktionelle lisp, ML

Deklarative / logiske prolog

Programmeringsparadigmer

Et paradigme udtrykker et syn på problemområdet

Interpretant paradigmets syn på verden

Repræsentation program

Objekt problemområde

ITs påvirkning af vores tænkemåde

Når vi konsumerer et medieprodukt er vi nødt til at acceptere interpretanten –præmissen - under konsumprocessen

Den er en forudsætning for konsum Vi kan ikke se en amerikansk mainstream

film med fornøjelse uden i en halvanden time at acceptere den amerikanske fortolkning af verden

Og vi kan ikke bruge et IT-system uden i brugsperioden at acceptere dets syn på verden

Imperative/procedurelle

Interpretant: Verden består af aktive processer og passive ting Tingene flyder mellem processerne og skifter tilstand

Programmering Udform en algoritme der omdanner ting En algoritme er en sekvens af tilstandsændringer

Ontologi Subjekt Objekt

Tekstgenre: narrativ

Objektorienterede

Interpretant: Verden består af aktive objekter samt af kommunikation mellem disse

objekter Objekterne har metoder tilknyttet >>> x = ['a','b','c'] >>> x.extend([1,2,3])

Programmering: lav en struktur af objekter hvis vekselvirkning resulterer i det ønskede

resultat Simuler problemområdet

Ontologi Subjekt/Objekt ↔ Subjekt/Objekt

Note Indeholder normalt en procedural komponent (C++, Python)

Understøtter indkapsling og genbrug Tekstgenre: deskriptiv.

Funktionelle

Interpretant Verden består af afhængigheder Inspireret af matematikken

Programmering Lav et hierarki af funktioner der kalder andre funktioner Funktion(funktion(funktion(data)))

Ontologi Input-output

Python har et funktionelt subset (apply, map, reduce, listcomprehension)

Deklarative

Interpretant Verden består af sande eller falske

sætninger samt af logiske slutningsprocesser

Ontologi Logisk positivisme

Tekstgenre: argumentativ

Prolog 1: påstande

far(peter,jeppe). far(peter,lotte). mor(else,jeppe). mor(else,lotte). far(jeppe,estrid). mor(lotte,erik). mor(lotte,ida).

han(peter). han(jeppe). han(erik). hun(else). hun(estrid). hun(ida). hun(lotte).

Prologg 2: slutningsregler

farfar(Aeldre,Yngre) :- far(Aeldre,Mellem),far(Mellem,Yngre). farmor(Aeldre,Yngre) :-

mor(Aeldre,Mellem),far(Mellem,Yngre). morfar(Aeldre,Yngre) :-

far(Aeldre,Mellem),mor(Mellem,Yngre). mormor(Aeldre,Yngre) :-

mor(Aeldre,Mellem),mor(Mellem,Yngre).

soen(Yngre,Aeldre) :- han(Yngre),far(Aeldre,Yngre). soen(Yngre,Aeldre) :- han(Yngre),mor(Aeldre,Yngre).

datter(Yngre,Aeldre) :- hun(Yngre),far(Aeldre,Yngre). datter(Yngre,Aeldre) :- hun(Yngre),mor(Aeldre,Yngre).

Prolog 3: slutningsregler

bedstemor(Aeldre,Yngre) :- mormor(Aeldre,Yngre). bedstemor(Aeldre,Yngre) :- farmor(Aeldre,Yngre). bedstefar(Aeldre,Yngre) :- morfar(Aeldre,Yngre). bedstefar(Aeldre,Yngre) :- farfar(Aeldre,Yngre).

barnebarn(Yngre,Aeldre) :- bedstemor(Aeldre,Yngre). barnebarn(Yngre,Aeldre) :- bedstefar(Aeldre,Yngre).

soennesoen(Yngre,Aeldre) :- soen(Yngre,Mellem), soen(Mellem,Aeldre).

datterdatter(Yngre,Aeldre) :- datter(Yngre,Mellem), datter(Mellem,Aeldre).

soeskende(A,B) :- far(X,A), far(X,B), not(A = B). soeskende(A,B) :- mor(X,A), mor(X,B), not(A = B).

Prolog 4: forespørgsler

1 ?- barnebarn(X,peter). X = erik ; X = ida ; X = estrid ;

2 ?- farfar(peter,X). X = estrid ;

3 ?- morfar(peter,X). X = erik ; X = ida ;

4 ?- soeskende(erik,X). X = ida ;

Python

Objektorienteret (kommer næste gang)

Proceduralt (Det vi har programmeret indtil videre)

Men med elementer af funktionel programmering. Kommer nu

Funktionelle træk i Python

Lambda: anonyme funktioner Et udtryk, ikke en række sætninger Kan stå steder hvor def ikke kan bruges, f.eks. inline i dictonaries

og lister lambda arg1… argn : hvad skal der gøres Implementering af kommandointerface kommando =

{ 'plus':(lambda x, y: x+y), 'minus': (lambda x, y: x-y), ’gange': (lambda x,y: x*y)}

>>> kommando['plus'](3,4) 7 >>> kommando[’gange'](30,50) 1500 >>>

En lommeregner

def Lommeregner(): kommando = {'plus':(lambda x, y: x+y),\ 'minus': (lambda x, y: x-y),\ 'gange': (lambda x,y: x*y)} inp = raw_input('tast et udtryk: ') inp = inp.split() if inp[0] == 'slut': return 'slut' else: x = int(inp[0]) op = inp[1] y = int(inp[2]) return kommando[op](x,y)

while True: resultat = Lommeregner() if resultat == 'slut': break else: print resultat >>> Lommeregner() tast et udtryk: 4 plus 78 82

Output

tast et udtryk: 2 plus 5 7 tast et udtryk: 5 minus 57 -52 tast et udtryk: slut >>>

Apply

Matcher en funktion med argumenter i form af en tupel

>>> def plus(x,y): return x+y >>> apply(plus,(3,4)) 7

Map

map( funktion, sekvens ) →[] Map: anvender en funktion på hvert medlem af en sekvens og

returnerer de enkelte resultater i form af en liste

>>> ordliste =('peTer','anDERS','KARL') >>> def lavnavne(etnavn): return etnavn.title()

>>> map(lavnavne,ordliste) ['Peter', 'Anders', 'Karl'] >>>

Reduce

reduce(...) reduce(function, sequence[, initial]) -> value Apply a function of two arguments cumulatively to the items

of a sequence, from left to right, so as to reduce the sequence to a single

value. For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5])

calculates ((((1+2)+3)+4)+5). If initial is present, it is placed before the

items of the sequence in the calculation, and serves as a default

when the sequence is empty.

Filter

filter ( boolsk funktion , sekvens ) →[] Anvender en boolsk funktion på hvert medlem af en

sekvens og returnerer de medlemmer for hvilken funktionen bliver sand

>>> ordliste =('peTer','anDERS','KARL','poul','anni') >>> def checknavne(etnavn): return etnavn.startswith('p')

>>> filter(checknavne,ordliste) ('peTer', 'poul') >>>

List comprehensions

[udtryk for var in sekvens ] →[] Syntaks:

[Udtryk for variabel in sekvens if betingelse] Beregner udtryk, hvis betingelse er sand, for

en variabel der sættes til at referere til alle medlemmer af sekvensen. >>> [x*2 for x in [1,2,-3,0,-4] if x > 0] [2, 4]

Effektivt, kort, men uforståeligt!

Pause

Pause

Scope

Scope

Scope = samtalekontekst Namespace = interpretant der angiver

hvad navne står for I Python: en slags dictionary hvor navne

er knyttet til objekter {’A’:integerobjekt, ’B’: funktionsobjekt,…}

Namespaces er knyttet til kontekster – lige som i naturlige sprog

Hvad betyder et navn?

Samtalekonteksten og tidsforløbet afgør hvad en repræsentation (et navn) repræsenterer.

Det danske samfund: ”Anders Fogh” betegner statsministeren (desværre stadigt) Vi kan bruge ”Fogh” som henvisning til statsministeren: ”Fogh”

statsministeren Familiesammenkomst (del af det danske samfund):

Hvis intet andet er sagt gælder reglen stadig. ”Fogh har en del bøvl med sine ministre i øjeblikket”

Men hvis der kommer en replik ”Kan I huske Købmand Fogh” ”Ja, ja” ”Fogh har lige solgt sin forretning”

Så etableres referencen ”Fogh” købmanden

I naturlige sprog

Referencen afgøres af Egenskaber ved objektet (han/hunkøn, andre egenskaber) Hvornår objektet sidste blev omtalt og hvor vigtigt det er Om der er nævnt andre kvalificerede objekter imellem

taletidspunktet og sidste omtale Eksempel

”Prøv at se den mand derovre ”Ja, han (manden derovre) er noget nervøs” ”Men se så ham bagved” ”Han (manden bagved) ser mere ud til at have kontrol

over tingene”.

Scope i Python

Lokale navne bruges i funktioner De forsvinder når funktionen er kørt færdig Der er 4 samtalekontekster Indbyggede navne (open, range, etc)

Modulet (globale): navne der er blevet tilskrevet (A = 9) en reference i modulet eller er blevet erklæret globale Lokale navne i omgivende funktioner

Lokale navn i funktionen: navne der er blevet tilskrevet en reference i modulet

Fastlæggelse af reference i Python

Har navnet fået en værdi i denne funktion Ja: navnet refererer til denne værdi Nej: Har navnet fået en værdi i en indesluttende

funktion: Ja: navnet refererer til denne værdi Nej: har navnet fået en værdi i modulet eller er det

blevet erklæret global? Ja: navnets værdi er denne værdi Nej: findes navnet som indbygget navn?

Ja: navnet har det indbyggede navns værdi Nej: fejl.

def laegentil(x):x = x+1return x

Eksempel

>>> x = 10 >>> def laegentil(x): x = x+1 return x >>> laegentil(x) 11 >>> x 10 >>> def laegentil(y): global x x = y+1 return x

>>> laegentil(x) 11 >>> x 11

Global

lokal

Global

Call by value, call by reference

Python: call by reference er default Call by value kræver at parametren eksplicit er en kopi

>>> def FjernFoerste(enListe): del enListe[0] return enListe

>>> minListe = [1,2,3] >>> from copy import * >>> resultat1 = FjernFoerste(copy(minListe)) >>> resultat1 [2, 3] >>> minListe [1, 2, 3] >>> resultat1 = FjernFoerste(minListe) >>> minListe [2, 3] >>>

Aktuelle og formelle parametre

Eksemplet igen def FjernFoerste(enListe): del enListe[0] return enListe Nyliste = FjernFoerste(minListe)

Ved kaldet sættes de formelle parametre til at repræsentere den værdi de aktuelle parametre repræsenterer

Formel parameter = aktuel parameter EnListe = minListe

Forskellen

R: enListeR:minListe

O: [1,2,3] O: [1,2,3]

R: enListeR: minListe

O [1,2,3]

Call by value: i Python må man eksplicit kopiere

Call by reference: default i Python

Oversættelse og kompilering

Oversættelse og kompilering

Oversættelse fra et sprog til et andet Transformation af program

Eks. fra C++ til maskinkode Fra python kildekode til python bytecode

Først lexikalsk analyse Så syntaktisk analyse Resultat: parsetræ Så kodegenerering ud fra parsetræet

Leksikalsk analyse

Leksikalsk analyse. Opdeling af kildekode-tekstfilen i en række

tokens Tokens er reserverede ord og variable samt

funktioner/operatorer Eks

‘=’ ‘print’ ‘minVariabel’ -> ASSIGN, PRINT, VAR Variabelnavne må ikke starte på et tal

>>> 1bil = 'Volvo' SyntaxError: invalid syntax >>> enbil = 'volvo'

Leksikalsk analyse

Nøgleord (if, then,…) >>> if = 'peter' SyntaxError: invalid syntax

Reserverede ord If er et reserveret ord Int er ikke et reserveret ord (data type)

>>> int = 1 >>> int 1 Nu virker int(’10’) ikke mere! Så pas på! Hvis ordene bliver lilla i IDLE er det et

indbygget ord som kan ændres, men som ikke bør ændres uden en specifik grund. Reserverede bliver orange

Syntaktisk analyse

BNF - Backus-Naur-form Samme udtrykskraft som Chomsky’s

kontekst-frie grammatik S ::= N VP NP ::= N | N som VP | at S VP ::= VT NP | VI N ::= Anders | Bent | Christina VT ::= så | hørte VI ::= løb | sov | lo

Fragment af Python

stmt::= simple_stmt | compound_stmt simple_stmt::= small_stmt (';' small_stmt)* [';'] NEWLINE small_stmt::= expr_stmt | print_stmt | del_stmt | pass_stmt |

flow_stmt | import_stmt | global_stmt | exec_stmt | assert_stmt print_stmt::= 'print' ( [ test (',' test)* [','] ] | '>>' test [ (',' test)+ [','] ] ) del_stmt::= 'del' exprlist pass_stmt::= 'pass' flow_stmt::= break_stmt | continue_stmt | return_stmt | raise_stmt |

yield_stmt break_stmt::= 'break' continue_stmt::= 'continue' return_stmt::= 'return' [testlist]

BNF og syntaksdiagrammer

Expr ::= Term [Op Expression] Op ::= +|- Syntaxregler er ofte rekursive

Term ExpressionOp

Expression

+

-

Op

BNF og syntaksdiagrammer

S ::= N VP NP ::= N | N som VP | at S VP ::= VT NP | VI N ::= Anders | Bent | Christina VT ::= så | hørte VI ::= løb | sov | lo

NP

N

VP

Sat

som

Parsning

Analyse af om tokensekvensen overholder sprogets syntax Assign ::= Var ‘=’ Expression Expression ::= Var | Var ‘+’ Var | Var ‘+’ Digit |

Digit ‘+’ Digit Var ::= a|b|c|...|z Digit ::= 0|1|2|...|9 a = a+4 a = 3+4 b = 3+5

Opbygning af parsetræer

Syntakstræ formelt sprog

Assign

Var

a

Expression

Var + Digit

a 3a = a+3

=

Syntakstræ dansk

S ::= N VP NP ::= N | N som VP | at S VP ::= VT NP | VI N ::= Anders | Bent | Christina VT ::= så | hørte VI ::= løb | sov | lo

S

N

VP

VT

NP

N

AnderssåBent

Syntakstræer

Fjern denne flertydighed If (Boolean1): If (Boolean2): Statement1

else: Statement2 Skal statement2 udføres når Boolean1 er

falsk eller når Boolean1 er sand og Boolean2 er falsk?

Fast og frit format

Formatfrie sprog (de fleste) Problemet løses med forskellige former

for paranteser If (Boolean1): {If (Boolean2): Statement1}

else: Statement2 If (Boolean1): {If (Boolean2): Statement1

else: Statement2 } Sprog med fast format

Problemet løses med indentering

Python

fast format. Bruger indentering >>> def syntakstest(navn): if navn[0] == 'peter': if navn[1] == 'andersen': print 'det var peter andersen' else: print 'fornavnet var ikke peter’ >>> def syntakstest1(navn): if navn[0] == 'peter': if navn[1] == 'andersen': print 'det var peter andersen' else: 'fornavnet var ikke peter'

Semantisk analyse

Er alle variable synlige? Check scope og namespace

Er typen af variablen forenelig med de operationer der skal udføres på den? I stærkt typede sprog: kan gøres nu Utypede sprog som Python: kan først

checkes under udførelsen

Kode generering

Højniveaukode X ← y + z W ← x + z

Maskininstruktioner (optimering) Load y i R1 Load z i R2 Add R2 til R1 (R1 = y + z) Store R1 i x Load x i R1 Load z i R2 Add R2 til R1 Store R1 i w

Overflødigt

Adgang til MySQL serveren

Hvis i logger på nettet med det login og password i har fået til MySQL-serveren skulle i gerne blive opfattet som ansatte i stedet for studerende og vil derfor have adgang til MySQL-serveren

Næste gang

UML distilled kapitel 3 (4 i 2nd ed.)

Opgave

Valgfri opgave med rekursion