Upload
alisa-frazier
View
41
Download
6
Embed Size (px)
DESCRIPTION
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 k ompilering. Generel udviklingstendens. - PowerPoint PPT Presentation
Citation preview
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