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

 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 = 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+1 return 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: enListe R:minListe O: [1,2,3] R: enListe R: 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 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 TermExpressionOp 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 S at 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 a3 a = 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