Laborator 9 - Paradigme de Programare Aplicații ale modelelor de proiectare utilizând Python Problema 1: Având în vedere că metodele de a realiza logg

Transcriere

1 Laborator 9 - Paradigme de Programare Aplicații ale modelelor de proiectare utilizând Python Problema 1: Având în vedere că metodele de a realiza logging-ul vor fi discutate mai în detaliu la cursul 11 în această problemă se va prezenta o manieră pentru gestiunea acestuia bazată pe modelul burlac și utilizând paradigma orientată obiect. Datorită simplității problemei dar și modelului utilizat se va utiliza o singură clasă prezentată în figura de mai jos. Scopul final este de a crea un serializator simplu uneori numit și logger. Programul este prezentat mai jos. import os class Log: instanta = None name = None def init (self, fname): if not Log.instanta: Log.name = os.path.dirname(os.path.realpath( file )) + '\\' + fname print('log : [' + Log.name + ']') Log.instanta = self if os.path.isfile(log.name): os.remove(log.name) else: raise Exception('Clasa este un singleton') def Write(self, line): f = open(self.name, "a+") try: f.write(line) f.write('\n') finally: f.close()

2 #mecanism Python de a construi metode statice într-o clasă (nu utilizează def GetInstanta(): if not Log.instanta: return Log() return Log.instanta def main(): #aceasta operație este permisă o singură dată în aplicație (de ce?) log = Log('test.log') print(log) #de oriunde din altă parte, aplicația poate accesa log-ul prin funcția GetInstanta() log1 = Log.GetInstanta() print(log1) log2 = Log.GetInstanta() print(log2) log.getinstanta().write('prima linie') log.write('test: ' + str(123)) log.write(str(['13', 145, 34.87])) log.write(str(5001)) #daca decomentăm următoarea linie, se generează excepția de la linia 15 #log3 = Log('test2.txt') if name == ' main ': main() La laborator: se pornește de la problema ceasului (fie din tema de acasă) fie din versiunea mai simplă de laborator și se utilizează acest serializator pentru a realiza jurnalizarea execuției operațiilor. Se începe prin a realiza diagrama de clase modificată și apoi o propunere de diagramă de obiecte apoi se trece la implementare.

3 Problema 2 Se pornește de la problema insectelor din grădină prezentată la curs și care are următoarea diagramă: Codul asociat este următorul: import random class Flower(object): def accept(self, visitor): visitor.visit(self) def pollinate(self, pollinator): print(self, "polenizata de ", pollinator) def eat(self, eater): print(self, "mancata de ", eater) def str (self): return self. class. name #intorc numele clasei class Gladiolus(Flower): pass class Runuculus(Flower): pass class Chrysanthemum(Flower): pass class Visitor: def str (self): return self. class. name class Bug(Visitor): pass class Pollinator(Bug): pass class Predator(Bug): pass class Bee(Pollinator): # ce face o albina def visit(self, flower): flower.pollinate(self) class Fly(Pollinator): #ce face o musca def visit(self, flower): flower.pollinate(self) class Worm(Predator): # ce face un vierme def visit(self, flower): flower.eat(self) def flowergen(n): flwrs = Flower. subclasses () for i in range(n): yield random.choice(flwrs)() bee = Bee()

4 fly = Fly() worm = Worm() for flower in flowergen(10): flower.accept(bee) flower.accept(fly) flower.accept(worm) La laborator: 1. Realizați diagrama de obiecte 2. Mai adăugați și flori carnivore care pot manca albina sau plante otrăvitoare care pot omorî un vierme care le vizitează. Problema 3: Se pornește de la utilizarea modelului vizitator pentru expresii aritmetice în format AST. class Token: def init (self, token, term): self.token = token self.term = term #suprascrisa de Operator si Operand def IsNonTerm(self): pass def GetData(self): return self.token class Operator(Token): def init (self, token): super(). init (token, False) def IsNonTerm(self): intermediare) return True #operatorii intr-un arbore AST sunt NON-TERMINALI (noduri class Operand(Token): def init (self, token): super(). init (token, True) def IsNonTerm(self): return False class AST: def init (self): self.left = None self.right = None self.data = None #operanzii intr-un arbore AST sunt TERMINALI (noduri frunza) #membru de tip AST #membru de tip AST #membru de tip Token #aceasta functie trebuie modificata pentru a permite prioritati intre operatori #hint: daca un operator cu prioritate mai mare (*) este mai aproape de radacina in AST fata de un operator nou cu prioritate mai mica, se inverseaza sub-arborii def AddASTNode(self, token): if token.isnonterm(): if self.left == None and self.right == None and self.data == None: print('expresia nu poate sa inceapa cu un operator!!!') return elif self.left == None and self.right == None: self.left = AST()

5 self.left.data = self.data self.data = token elif self.left!= None and self.right == None: print('eroare de sintaxa: Aveti 2 operatori consecutivi!') return elif self.left!= None and self.right!= None: self.right.addastnode(token) else: if self.left == None and self.right == None and self.data == None: self.data = token elif self.left == None and self.right == None: print('eroare de sintaxa: Aveti 2 operanzi consecutivi!') elif self.left!= None and self.right!= None: self.right.addastnode(token) elif self.left!= None and self.right == None: self.right = AST() self.right.data = token #suport pentru a accepta visitatori def AcceptVisitor(self, printvisitor): printvisitor.visit(self) class ASTBuilder: Left = None Right = None def init (self, expresie, ast): self.expresie = expresie self.sym = [] self.parse() self.listsymbols() self.ast = ast for tok in self.sym: self.ast.addastnode(tok) def Parse(self): nr = 0 was_nr = False for chr in self.expresie: if chr >= '0' and chr <= '9': nr *= 10 nr += int(chr) was_nr = True elif chr in ['+','-']: if was_nr: self.sym += [Operand(nr)] was_nr = False nr = 0 self.sym += [Operator(chr)] if was_nr: self.sym += [Operand(nr)] was_nr = False nr = 0 def ListSymbols(self): print('din expresia data am extras urmatoarele elemente:') for item in self.sym: if item.isnonterm(): print(item.getdata(), '\t->\toperator') else: print(item.getdata(), '\t->\toperand')

6 class PrintVisitor: def visit(self, ast): pass class VisitPreOrdine(PrintVisitor): def visit(self, ast): print(ast.data.getdata()) if ast.left!= None: self.visit(ast.left) if ast.right!= None: self.visit(ast.right) def main(): ast = AST() a = ASTBuilder(' ', ast) pre = VisitPreOrdine() ast.acceptvisitor(pre) if name == " main ": main() Codul, transformă o expresie simplă care folosește operatori + și -, într-un arbore AST. În el există implementat și un suport pentru un observator pretty-print (vezi prezentarea de la Tel- Aviv) cu scopul de a afișa expresia în format pre-ordine. La laborator: 1. Adăugați doi vizitatori adiționali, cu care să se poată afișa expresia și în formele în-ordine, post-ordine. 2. Adăugați un vizitator care face calculele necesare. 3. Adăugați suport pentru înmulțire și împărțire (trebuie să se implementeze prioritatea în AST atunci când se introduc noduri noi) 4. Utilizați logger-ul din prima problemă pentru a efectua jurnalizarea execuției 5. Dacă clasele AST, ASTBuilder sunt transformate în Singleton se modifică maniera de funcționare?

7 Temă pe acasă 1. Terminați ultima problemă (dacă nu ați putut în laborator) 2. Propuneți o versiune recursivă pentru problema 3. Materiale ajutătoare pentru AST wcc06%2ft5-ast.ppt&usg=aovvaw3dpi0-7qd7tmcqezfuso2n