TDA Diccionario secuencia ordenada de “palabras” (identificadores que no se repiten) con “significados” (información asociada) con las sgtes operaciones: Operación Significado buscar(x) devolver significado de palabra x

excepción: NoExiste agregar(x,y) agregar palabra x con significado y

excepciones: YaExiste, Lleno borrar(x) borrar palabra x

excepción: NoExiste cambiar(x,y) cambiar significado de palabra x por y

excepción: NoExiste

Uso del TDA. Escribir un programa para manejar un diccionario:

v=Tk() f1=Frame(v); f2=Frame(v); f3=Frame(v) Label(f1,text="palabra:").pack(side=LEFT) palabra=Entry(f1);palabra.pack() Label(f2,text="significado:").pack(side=LEFT) significado=Entry(f2); significado.pack() Button(f3,text="buscar",command=buscar).pack(side=LEFT) Button(f3,text="agregar",command=agregar).pack(side=LEFT) Button(f3,text="borrar",command=borrar).pack(side=LEFT) Button(f3,text="cambiar",command=cambiar).pack(side=LEFT) respuesta=Label(v) f1.pack(); f2.pack(); f3.pack(); respuesta.pack() v.mainloop()

from Tkinter import * from archivo import * #Diccionario y excepciones D=Diccionario() def buscar(): try:significado.delete(0,END) significado.insert(0,D.buscar(palabra.get())) responder("encontrado") except NoExiste: responder("no existe") def agregar(): try:D.agregar(palabra.get(),significado.get()) responder("agregado") except YaExiste: responder("ya existe") except Lleno: responder("no hay espacio") def borrar(): try:D.borrar(palabra.get()) responder("borrado") except NoExiste: responder("no existe") def cambiar(): try:D.cambiar(palabra.get(),significado.get()) responder("cambiado") except NoExiste: responder("no existe") def responder(x): respuesta.config(text=x)

TDA Diccionario: Implementación con objeto de clase dict class NoExiste(Exception): def __init__(self): pass class YaExiste(Exception): def __init__(self): pass class Lleno(Exception): def __init__(self): pass class Diccionario: def __init__(self): self.D={} #self.D=dict() def buscar(self,x): try: return self.D[x] except KeyError: raise NoExiste #o NoExiste() def agregar(self,x,y): if x in self.D: raise YaExiste try: self.D[x]=y except MemoryError: raise Lleno def borrar(self,x): try: del self.D[x] except KeyError: raise NoExiste def cambiar(self,x,y): if x not in self.D: raise NoExiste self.D[x]=y

Diccionario: Implementación con lista ordenada de tuplas (palabra,significado) class Diccionario: def __init__(self): self.L=[] def buscar(self,x): i=indice(x,self.L) (pal,sig)=self.L[i] return sig def borrar(self,x): i=indice(x,self.L) self.L.pop(i) def cambiar(self,x,y): i=indice(x,self.L) self.L[i]=(x,y) global indice def indice(x,lista): #no se aplica a objetos ip=0; iu=len(lista)-1 while ip<=iu: im=(ip+iu)/2 (pal,sig)=lista[im] if x==pal: return im if x<pal: iu=im-1 else: ip=im+1 raise NoExiste #se propaga a métodos que la invocan

TDA Diccionario: Implementación con lista ordenada de palabras def agregar(self,x,y): try: for i in range(len(self.L)): (pal,sig)=self.L[i] if pal==x: raise YaExiste elif pal>x: self.L.insert(i,(x,y)) return #agregar al final self.L.append((x,y)) except MemoryError: raise Lleno

TDA Diccionario: Implementación con lista enlazada ordenada por palabra 1º X1 Y1 ... Xn Yn None palabra significado sgte palabra significado sgte X1 < X2 < ... < Xn class Nodo: def __init__(self,x,y,z=None): self.palabra=x self.significado=y self.sgte=z class Diccionario: def __init__(self): self.primero=None def buscar(self,x): r=referencia(x,self.primero) return r.significado def cambiar(self,x,y): r=referencia(x,self.primero) r.significado=y

#devuelve referencia de Nodo con palabra x global referencia def referencia(x,primero): r=primero while r!=None: if r.palabra==x: return r r=r.sgte raise NoExiste #versión recursiva global referencia def referencia(x,primero): if primero==None: raise NoExiste elif primero.palabra==x: return primero else: return referencia(x,primero.sgte) Nota. Se podría optimizar parando cuando aparezca una palabra > x (levantado la excepción)

Operación borrar:borrar primer nodo

X

1º palabra significado sgte palabra significado sgte

borrar nodo intermedioant

X

palabra significado sgte palabra significado sgte

def borrar(self,x): #caso lista enlazada vacía if self.primero==None: raise NoExiste #caso borrar primer nodo elif self.primero.palabra==x: self.primero=self.primero.sgte #caso borrar otro nodo else: anterior=self.primero #buscar referencia al anterior while anterior.sgte!=None \ and anterior.sgte.palabra < x: anterior=anterior.sgte if anterior.sgte==None \ or anterior.sgte.palabra > x: raise NoExiste else: anterior.sgte=anterior.sgte.sgte

def borrar(self,x): self.primero=listaSinX(x,self.primero) #devuelve lista sin nodo que contiene a x

global listaSinX def listaSinX(x,primero): #si lista enlazada está vacía, x no existe if primero==None: raise NoExiste #si x está en el primer nodo elif primero.palabra==x: #devolver lista que comienza en 2° nodo return primero.sgte #si x no está en el primer nodo else: #borrarlo de lista que comienza en 2° nodo primero.sgte=listaSinX(x,primero.sgte) #primero de lista no cambia return primero

def agregar(self,x,y): self.primero=listaConX(x,y,self.primero)

#devuelve lista con nuevo nodo con x e y global listaConX def listaConX(x,y,primero):

try: #si lista está vacía, devolver lista con un nodo if primero==None: return Nodo(x,y,None) #si 1ª.palabra==x, levantar excepción yaExiste elif primero.palabra==x: raise YaExiste #si 1ª.palabra>x,devolver lista insertando nodo al comienzo elif primero.palabra>x: return Nodo(x,y,primero) #si 1ª.palabra<x, agregar a lista que comienza en 2°nodo else: primero.sgte=listaConX(x,y,primero.sgte) return primero except MemoryError: raise Lleno

Ejercicio def buscarPalabra(self,i): #entrega palabra en índice i del diccionario (ordenado) Nota. Produce la excepción NoExiste en caso que no exista palabra en ese índice Ejemplos: D.buscarPalabra(0) y D.buscarPalabra(1) entregan la 1ª y 2ª palabra Suponga la siguiente representación de un objeto de la clase diccionario

a) Lista: objeto de la clase list con tuplas (palabra,significado) ordenadas por palabra

b) Diccionario: objeto de la clase dict Indicación. Convertir a lista y ordenar

c) lista enlazada de nodos ordenados por palabra Indicación. Recorrer lista contando nodos

Diccionario: Implementación con lista ordenada de tuplas (palabra,significado) class Diccionario: def __init__(self): self.L=[] def buscarPalabra(self,i): try: (pal,sig)=self.L[i] return pal except IndexError: raise NoExiste

TDA Diccionario: Implementación con objeto de clase dict class Diccionario: def __init__(self): self.D={} #self.D=dict() def buscarPalabra(self,i): #entrega palabra en índice i L=[] for palabra in self.D: L.append(palabra) L.sort() try: return L[i] except IndexError: raise NoExiste Alternativas: def buscarPalabra(self,i): #entrega palabra en índice i L=D.items() #L=D.keys() L.sort() try: return L[i][0] # return L[i] except IndexError: raise NoExiste

class Nodo: def __init__(self,x,y,z=None): self.palabra=x self.significado=y self.sgte=z class Diccionario: def __init__(self): self.primero=None def buscarPalabra(self,i): n=0 r=self.primero while r!=None: if n==i: return r.palabra n=n+1 r=r.sgte raise NoExiste