Foros del Web » Programando para Internet » Python »

Pilas y colas

 Estas en el tema de Pilas y colas en el foro de Python en Foros del Web. Estoy haciendo un ejercicio para clase sobre pilas y colas, os pongo todo el código pero principalmente quiero que me ayudéis con el constructor de ...
  #1 (permalink)  
Antiguo 28/03/2012, 11:03
Avatar de bichomen  
Fecha de Ingreso: junio-2003
Ubicación: Barcelona y alrededores, España
Mensajes: 877
Antigüedad: 20 años, 11 meses
Puntos: 2
Pilas y colas
Estoy haciendo un ejercicio para clase sobre pilas y colas, os pongo todo el código pero principalmente quiero que me ayudéis con el constructor de la clase Stack (pila) que creo que me estoy liando, cualquier ayuda sera bienvenida, gracias de antemano:

Código: 
import random

#################################
#Movie

#Creamos la clase Movie
class Movie:
        
        def __init__(self,title="emptyTitle",
                                          director=["emptyDirector"],
                                          cast = ["emptyCast"],
                                          producer = ["emptyProducer"],
                                          writer = ["emptyWriter"],
                                          country = ["emptyCountry"],
                                          language = ["emptyLanguage"],
                                          year = "emptyYear",
                                          genres = ["emptyGenres"],
                                          votes = "emptyVotes",
                                          rating = "emptyRating",
                                          runtime = ["emptyRuntime"],
                                          plot = ["emptyPlot"],
                                          cover_url = "emptyCorver"):
                
                self.title = title
                self.director = director
                self.cast = cast
                self.producer = producer
                self.writer = writer
                self.country = country
                self.language = language
                self.year = year
                self.genres = genres
                self.votes = votes
                self.rating = rating
                self.runtime = runtime
                self.plot = plot
                self.cover_url = cover_url

        def GetTitle(self):
                return self.title




#################################
#función loadMovieList

def loadMovieList(filename):
        peliculas = abrirarchivo(filename)
        movieList = []
        
        for peli in range(len(peliculas)):
                pelicula = peliculas[peli].split("|")
            
                p = Movie(pelicula[0],pelicula[1],pelicula[2],pelicula[3],pelicula[4],pelicula[5],pelicula[6],pelicula[7],pelicula[8],pelicula[9],pelicula[10],pelicula[11],pelicula[12],pelicula[13])
                movieList.append(p)

        movieList.sort()

        return movieList

#################################
#Abrimos el archivo

def abrirarchivo(db):
    file = open(db,"r")
    peliculas = file.readlines()
    file.close()

    return peliculas

movieList = loadMovieList('peliculas100.dat')

#Reducimos la lista de peliculas a 21 elementos
movieList = movieList[0:20]


#################################
#Nodo
        
#Creamos la clase Nodo
class Node:

        def __init__(self,data,root="none"):
                data = data
                self.root = "none"
                
#################################
#Stack
        
#Creamos la clase Stack
class Stack:

        #El constructor de la clase Stack
        def __init__(self):
                tmp = 0
                self.data =  movieList
                head = Node(tmp, len(data))
                
        #Si la pila esta vacia, que apunte a None
        def isEmpty(head):
                head.data = "none"
                
        #Imprimimos el titulo de la pelicula actual
        def printStack(self):
                #Meto el nodo actual en una variable temporal
                tmp = head.data
                #Guado en una variable a traves del metodo de la clase Movie, el titulo de la pelicula
                titulo = tmp.GetTitle()
                #Hago que la variable temporal, apunte a la siguiente pelicula
                tmp = tmp.next

                return titulo
                        
        #Añadimos un nodo
        def push(self,node):
                #Metemos el nuevo nodo en la variable temporal
                tmp = newNode
                #Hacemos que la variable temporal, su siguiente enlace sea el ultimo elemento de la pila
                tmp.next = head.data
                #Hacemos que head, apunte al nuevo nodo
                head = tmp

                return head.data
                                
        #Quitamos un nodo
        def pop(self):
                #Meto el ultimo nodo en una variable temporal
                tmp = head.data
                #Hago que head apunte al siguiente nodo
                head = head.next
                #Hago que el ultimo nodo apunte none
                tmp.next = "none"
                #Guardo el ultimo nodo, en otra variable
                output = tmp.data
                #Vacio la variable temporal
                tmp = "none"
                
                return output

#################################
#Queure
        
#Creamos la clase Queure
#class Queure:

 #       def __init__(self):

  #      def isEmpty(self):

   #     def printQ(self):

    #    def enqueue(self,node):

     #   def dequeue(self):
            


#################################
#Test de la clase Stack()

newStack = Stack()
newStack.printStack()

newNode = Node(movieList[0])
newStack.push(newNode)
newStack.printStack()

newStack.push(Node(movieList[1]))
newStack.printStack()

newStack.push(Node(movieList[2]))
newStack.printStack()

m1 = newStack.pop()
newStack.printStack()

m2 = newStack.pop()
newStack.printStack()

m3 = newStack.pop()
newStack.printStack()

m4 = newStack.pop()
newStack.printStack()

print m1.GetTitle()
print m2.GetTitle()
print m3.GetTitle()
##print m4.GetTitle()  GUESS WHAT HAPPENS...

#################################
#Test de la clase Queure()

#newQ = Queue()
#newQ.printQ()

#newNode = Node(movieList[0])
#newQ.enqueue(newNode)
#newQ.printQ()

#newQ.enqueue(Node(movieList[1]))
#newQ.printQ()

#newQ.enqueue(Node(movieList[2]))
#newQ.printQ()

#m1 = newQ.dequeue()
#newQ.printQ()

#m2 = newQ.dequeue()
#newQ.printQ()

#m3 = newQ.dequeue()
#newQ.printQ()

#m4 = newQ.dequeue()
#newQ.printQ()

#print m1.GetTitle()
#print m2.GetTitle()
#print m3.GetTitle()
#print m4.GetTitle()  GUESS WHAT HAPPENS...

bichomen
__________________
"Se sabe con exactitud, con cuanta imprecisión, se sabe algo"
Linux Registered User #320332
  #2 (permalink)  
Antiguo 28/03/2012, 11:12
Avatar de Carlangueitor
Moderador ლ(ಠ益ಠლ)
  
Fecha de Ingreso: marzo-2008
Ubicación: México
Mensajes: 10.037
Antigüedad: 16 años, 1 mes
Puntos: 1329
Respuesta: Pilas y colas
Solo le dí un vistazo al código, y no se si es tu problema, pero creo que asignas la variable movielist y no está dentro del alcance de la clase.

Saludos
__________________
Grupo Telegram Docker en Español
  #3 (permalink)  
Antiguo 28/03/2012, 11:58
Avatar de razpeitia
Moderador
  
Fecha de Ingreso: marzo-2005
Ubicación: Monterrey, México
Mensajes: 7.321
Antigüedad: 19 años, 1 mes
Puntos: 1360
Respuesta: Pilas y colas
Código Python: 
Ver original
  1. #coding: utf-8
  2. import random
  3.  
  4. #################################
  5. #Movie
  6.  
  7. #Creamos la clase Movie
  8. class Movie:
  9.         
  10.         def __init__(self,title="emptyTitle",
  11.                                           director=["emptyDirector"],
  12.                                           cast = ["emptyCast"],
  13.                                           producer = ["emptyProducer"],
  14.                                           writer = ["emptyWriter"],
  15.                                           country = ["emptyCountry"],
  16.                                           language = ["emptyLanguage"],
  17.                                           year = "emptyYear",
  18.                                           genres = ["emptyGenres"],
  19.                                           votes = "emptyVotes",
  20.                                           rating = "emptyRating",
  21.                                           runtime = ["emptyRuntime"],
  22.                                           plot = ["emptyPlot"],
  23.                                           cover_url = "emptyCorver"):
  24.                 
  25.                 self.title = title
  26.                 self.director = director
  27.                 self.cast = cast
  28.                 self.producer = producer
  29.                 self.writer = writer
  30.                 self.country = country
  31.                 self.language = language
  32.                 self.year = year
  33.                 self.genres = genres
  34.                 self.votes = votes
  35.                 self.rating = rating
  36.                 self.runtime = runtime
  37.                 self.plot = plot
  38.                 self.cover_url = cover_url
  39.  
  40.         def GetTitle(self):
  41.                 return self.title
  42.  
  43.  
  44.  
  45.  
  46. #################################
  47. #función loadMovieList
  48.  
  49. def loadMovieList(filename):
  50.         peliculas = abrirarchivo(filename)
  51.         movieList = []
  52.         
  53.         for peli in range(len(peliculas)):
  54.                 pelicula = peliculas[peli].split("|")
  55.             
  56.                 p = Movie(pelicula[0],pelicula[1],pelicula[2],pelicula[3],pelicula[4],pelicula[5],pelicula[6],pelicula[7],pelicula[8],pelicula[9],pelicula[10],pelicula[11],pelicula[12],pelicula[13])
  57.                 movieList.append(p)
  58.  
  59.         movieList.sort()
  60.  
  61.         return movieList
  62.  
  63. #################################
  64. #Abrimos el archivo
  65.  
  66. def abrirarchivo(db):
  67.     file = open(db,"r")
  68.     peliculas = file.readlines()
  69.     file.close()
  70.  
  71.     return peliculas
  72.  
  73. movieList = loadMovieList('peliculas100.dat')
  74.  
  75. #Reducimos la lista de peliculas a 21 elementos
  76. movieList = movieList[0:20]
  77.  
  78.  
  79. #################################
  80. #Nodo
  81.         
  82. #Creamos la clase Nodo
  83. class Node:
  84.  
  85.         def __init__(self,data,root="none"):
  86.                 data = data
  87.                 self.root = "none"
  88.                 
  89. #################################
  90. #Stack
  91.         
  92. #Creamos la clase Stack
  93. class Stack:
  94.  
  95.         #El constructor de la clase Stack
  96.         def __init__(self):
  97.                 tmp = 0
  98.                 self.data =  movieList
  99.                 self.head = Node(tmp, len(self.data))
  100.                 
  101.         #Si la pila esta vacia, que apunte a None
  102.         def isEmpty(self, head):
  103.                 head.data = "none"
  104.                 
  105.         #Imprimimos el titulo de la pelicula actual
  106.         def printStack(self):
  107.                 #Meto el nodo actual en una variable temporal
  108.                 tmp = self.head.data
  109.                 #Guado en una variable a traves del metodo de la clase Movie, el titulo de la pelicula
  110.                 titulo = tmp.GetTitle()
  111.                 #Hago que la variable temporal, apunte a la siguiente pelicula
  112.                 tmp = tmp.next
  113.  
  114.                 return titulo
  115.                         
  116.         #Añadimos un nodo
  117.         def push(self,node):
  118.                 #Metemos el nuevo nodo en la variable temporal
  119.                 tmp = newNode
  120.                 #Hacemos que la variable temporal, su siguiente enlace sea el ultimo elemento de la pila
  121.                 tmp.next = self.head.data
  122.                 #Hacemos que head, apunte al nuevo nodo
  123.                 head = tmp
  124.  
  125.                 return head.data
  126.                                 
  127.         #Quitamos un nodo
  128.         def pop(self):
  129.                 #Meto el ultimo nodo en una variable temporal
  130.                 tmp = self.head.data
  131.                 #Hago que head apunte al siguiente nodo
  132.                 head = self.head.next
  133.                 #Hago que el ultimo nodo apunte none
  134.                 tmp.next = "none"
  135.                 #Guardo el ultimo nodo, en otra variable
  136.                 output = tmp.data
  137.                 #Vacio la variable temporal
  138.                 tmp = "none"
  139.                 
  140.                 return output
  141.  
  142. #################################
  143. #Queure
  144.         
  145. #Creamos la clase Queure
  146. #class Queure:
  147.  
  148.  #       def __init__(self):
  149.  
  150.   #      def isEmpty(self):
  151.  
  152.    #     def printQ(self):
  153.  
  154.     #    def enqueue(self,node):
  155.  
  156.      #   def dequeue(self):
  157.             
  158.  
  159.  
  160. #################################
  161. #Test de la clase Stack()
  162.  
  163. newStack = Stack()
  164. newStack.printStack()
  165.  
  166. newNode = Node(movieList[0])
  167. newStack.push(newNode)
  168. newStack.printStack()
  169.  
  170. newStack.push(Node(movieList[1]))
  171. newStack.printStack()
  172.  
  173. newStack.push(Node(movieList[2]))
  174. newStack.printStack()
  175.  
  176. m1 = newStack.pop()
  177. newStack.printStack()
  178.  
  179. m2 = newStack.pop()
  180. newStack.printStack()
  181.  
  182. m3 = newStack.pop()
  183. newStack.printStack()
  184.  
  185. m4 = newStack.pop()
  186. newStack.printStack()
  187.  
  188. print m1.GetTitle()
  189. print m2.GetTitle()
  190. print m3.GetTitle()
  191. ##print m4.GetTitle()  GUESS WHAT HAPPENS...
  192.  
  193. #################################
  194. #Test de la clase Queure()
  195.  
  196. #newQ = Queue()
  197. #newQ.printQ()
  198.  
  199. #newNode = Node(movieList[0])
  200. #newQ.enqueue(newNode)
  201. #newQ.printQ()
  202.  
  203. #newQ.enqueue(Node(movieList[1]))
  204. #newQ.printQ()
  205.  
  206. #newQ.enqueue(Node(movieList[2]))
  207. #newQ.printQ()
  208.  
  209. #m1 = newQ.dequeue()
  210. #newQ.printQ()
  211.  
  212. #m2 = newQ.dequeue()
  213. #newQ.printQ()
  214.  
  215. #m3 = newQ.dequeue()
  216. #newQ.printQ()
  217.  
  218. #m4 = newQ.dequeue()
  219. #newQ.printQ()
  220.  
  221. #print m1.GetTitle()
  222. #print m2.GetTitle()
  223. #print m3.GetTitle()
  224. #print m4.GetTitle()  GUESS WHAT HAPPENS...
Tienes muchos problemas con el uso del self y también de None.
  #4 (permalink)  
Antiguo 02/04/2012, 02:46
Avatar de bichomen  
Fecha de Ingreso: junio-2003
Ubicación: Barcelona y alrededores, España
Mensajes: 877
Antigüedad: 20 años, 11 meses
Puntos: 2
Respuesta: Pilas y colas
Pues si hice unas cuantas modificaciones, pero sigue fallando:

Código Python: 
Ver original
  1. import random
  2.  
  3. #################################
  4. #Movie
  5.  
  6. #Creamos la clase Movie
  7. class Movie:
  8.         
  9.         def __init__(self,title="emptyTitle",
  10.                                           director=["emptyDirector"],
  11.                                           cast = ["emptyCast"],
  12.                                           producer = ["emptyProducer"],
  13.                                           writer = ["emptyWriter"],
  14.                                           country = ["emptyCountry"],
  15.                                           language = ["emptyLanguage"],
  16.                                           year = "emptyYear",
  17.                                           genres = ["emptyGenres"],
  18.                                           votes = "emptyVotes",
  19.                                           rating = "emptyRating",
  20.                                           runtime = ["emptyRuntime"],
  21.                                           plot = ["emptyPlot"],
  22.                                           cover_url = "emptyCorver"):
  23.                 
  24.                 self.title = title
  25.                 self.director = director
  26.                 self.cast = cast
  27.                 self.producer = producer
  28.                 self.writer = writer
  29.                 self.country = country
  30.                 self.language = language
  31.                 self.year = year
  32.                 self.genres = genres
  33.                 self.votes = votes
  34.                 self.rating = rating
  35.                 self.runtime = runtime
  36.                 self.plot = plot
  37.                 self.cover_url = cover_url
  38.  
  39.         def GetTitle(self):
  40.                 return self.title
  41.  
  42.  
  43.  
  44.  
  45. #################################
  46. #función loadMovieList
  47.  
  48. def loadMovieList(filename):
  49.         peliculas = abrirarchivo(filename)
  50.         movieList = []
  51.         
  52.         for peli in range(len(peliculas)):
  53.                 pelicula = peliculas[peli].split("|")
  54.             
  55.                 p = Movie(pelicula[0],pelicula[1],pelicula[2],pelicula[3],pelicula[4],pelicula[5],pelicula[6],pelicula[7],pelicula[8],pelicula[9],pelicula[10],pelicula[11],pelicula[12],pelicula[13])
  56.                 movieList.append(p)
  57.  
  58.         movieList.sort()
  59.  
  60.         return movieList
  61.  
  62. #################################
  63. #Abrimos el archivo
  64.  
  65. def abrirarchivo(db):
  66.     file = open(db,"r")
  67.     peliculas = file.readlines()
  68.     file.close()
  69.  
  70.     return peliculas
  71.  
  72. movieList = loadMovieList('peliculas100.dat')
  73.  
  74. #Reducimos la lista de peliculas a 21 elementos
  75. movieList = movieList[0:20]
  76.  
  77.  
  78. #################################
  79. #Nodo
  80.         
  81. #Creamos la clase Nodo
  82. class Node:
  83.         m = Movie()
  84.         lista = m.GetTitle()
  85.  
  86.         def __init__(self,data=None):
  87.                 self.lista = None
  88.                 self.data = data
  89.                 
  90. #################################
  91. #Stack
  92.         
  93. #Creamos la clase Stack
  94. class Stack:
  95.  
  96.         def __init__(self):
  97.                 pila = []
  98.                 self.sList = pila
  99.          
  100.         def push(self,node):
  101.                 n = Node()
  102.                 self.sList.append(n.data)
  103.                 return True
  104.  
  105.         def pop(self):
  106.                 if self.isEmpty():
  107.                     return "La pila esta vacia"
  108.                 else:
  109.                     return self.sList.pop()
  110.      
  111.         def isEmpty(self):
  112.                 return len(self.sList) == 0
  113.      
  114.         def printStack(self):
  115.                 print self.sList
  116.                 return True
  117.         
  118.  
  119. #################################
  120. #Queure
  121.         
  122. #Creamos la clase Queure
  123. class Queure:
  124.         
  125.         def __init__(self):
  126.                 cola = []
  127.                 self.qList = cola
  128.          
  129.         def enqueue(self,node):
  130.                 self.qList.append(node)
  131.                 return True
  132.              
  133.         def dequeue(self):
  134.                 if(self.isEmpty()):
  135.                         return "La cola esta vacia"
  136.                 else:
  137.                         node = self.qList[0]
  138.                         self.qList = self.qList[1:]
  139.                 return node
  140.      
  141.         def isEmpty(self):
  142.                 return len(self.qList) == 0
  143.      
  144.         def printQ(self):
  145.                 print self.qList
  146.                 return True
  147.  
  148.  
  149. #################################
  150. #Test de la clase Stack()
  151.  
  152. newStack = Stack()
  153. newStack.printStack()
  154.  
  155. newNode = Node(movieList[0])
  156. newStack.push(newNode)
  157. newStack.printStack()
  158.  
  159. newStack.push(Node(movieList[1]))
  160. newStack.printStack()
  161.  
  162. newStack.push(Node(movieList[2]))
  163. newStack.printStack()
  164.  
  165. m1 = newStack.pop()
  166. newStack.printStack()
  167.  
  168. m2 = newStack.pop()
  169. newStack.printStack()
  170.  
  171. m3 = newStack.pop()
  172. newStack.printStack()
  173.  
  174. m4 = newStack.pop()
  175. newStack.printStack()
  176.  
  177. print m1.GetTitle()
  178. print m2.GetTitle()
  179. print m3.GetTitle()
  180. ##print m4.GetTitle()  GUESS WHAT HAPPENS...
  181.  
  182. #################################
  183. #Test de la clase Queure()
  184.  
  185. #newQ = Queue()
  186. #newQ.printQ()
  187.  
  188. #newNode = Node(movieList[0])
  189. #newQ.enqueue(newNode)
  190. #newQ.printQ()
  191.  
  192. #newQ.enqueue(Node(movieList[1]))
  193. #newQ.printQ()
  194.  
  195. #newQ.enqueue(Node(movieList[2]))
  196. #newQ.printQ()
  197.  
  198. #m1 = newQ.dequeue()
  199. #newQ.printQ()
  200.  
  201. #m2 = newQ.dequeue()
  202. #newQ.printQ()
  203.  
  204. #m3 = newQ.dequeue()
  205. #newQ.printQ()
  206.  
  207. #m4 = newQ.dequeue()
  208. #newQ.printQ()
  209.  
  210. #print m1.GetTitle()
  211. #print m2.GetTitle()
  212. #print m3.GetTitle()
  213. #print m4.GetTitle()  GUESS WHAT HAPPENS...

A ver si me podéis guiar un poco.


bichomen
__________________
"Se sabe con exactitud, con cuanta imprecisión, se sabe algo"
Linux Registered User #320332
  #5 (permalink)  
Antiguo 02/04/2012, 11:11
Avatar de razpeitia
Moderador
  
Fecha de Ingreso: marzo-2005
Ubicación: Monterrey, México
Mensajes: 7.321
Antigüedad: 19 años, 1 mes
Puntos: 1360
Respuesta: Pilas y colas
Realmente dudo que hayas escrito el código, mas bien creo que estas copiando y pegando de diferentes partes. Se puede notar fácilmente que el código no esta escrito por una sola persona.

De hecho ni siquiera estas haciendo un uso correcto de la clase nodo. Ya que implementas el stack y el queue con listas y no con la clase nodo. Ademas que el código tienes bien escrito queue mientras en los comentarios escribes Queure casi siempre.

Otra cosa es que no incluiste el archivo peliculas100.dat, así que hice uno, en base en los parámetros del constructor Movies, de hecho también tienes errores ahí y haces mucha duplicación de codigo, movies[0], movies[1] ... movies[13]. Y los parámetros por default son listas en vez de strings. Todo eso nada mas en el costructor de Movies, no quiero hablar sobre el resto.

Bueno aqui dejo peliculas100.dat y el código.
Código: 
title01|director|cast|producer|writer|country|language|year|genres|votes|rating|runtime|plot|cover_url
title02|director|cast|producer|writer|country|language|year|genres|votes|rating|runtime|plot|cover_url
title03|director|cast|producer|writer|country|language|year|genres|votes|rating|runtime|plot|cover_url
title04|director|cast|producer|writer|country|language|year|genres|votes|rating|runtime|plot|cover_url
title05|director|cast|producer|writer|country|language|year|genres|votes|rating|runtime|plot|cover_url
title06|director|cast|producer|writer|country|language|year|genres|votes|rating|runtime|plot|cover_url
title07|director|cast|producer|writer|country|language|year|genres|votes|rating|runtime|plot|cover_url
title08|director|cast|producer|writer|country|language|year|genres|votes|rating|runtime|plot|cover_url
title09|director|cast|producer|writer|country|language|year|genres|votes|rating|runtime|plot|cover_url
title10|director|cast|producer|writer|country|language|year|genres|votes|rating|runtime|plot|cover_url
title11|director|cast|producer|writer|country|language|year|genres|votes|rating|runtime|plot|cover_url
title12|director|cast|producer|writer|country|language|year|genres|votes|rating|runtime|plot|cover_url
title13|director|cast|producer|writer|country|language|year|genres|votes|rating|runtime|plot|cover_url
title14|director|cast|producer|writer|country|language|year|genres|votes|rating|runtime|plot|cover_url
title15|director|cast|producer|writer|country|language|year|genres|votes|rating|runtime|plot|cover_url
title16|director|cast|producer|writer|country|language|year|genres|votes|rating|runtime|plot|cover_url
title17|director|cast|producer|writer|country|language|year|genres|votes|rating|runtime|plot|cover_url
title18|director|cast|producer|writer|country|language|year|genres|votes|rating|runtime|plot|cover_url
title19|director|cast|producer|writer|country|language|year|genres|votes|rating|runtime|plot|cover_url
title20|director|cast|producer|writer|country|language|year|genres|votes|rating|runtime|plot|cover_url
title21|director|cast|producer|writer|country|language|year|genres|votes|rating|runtime|plot|cover_url
Código Python: 
Ver original
  1. #coding: utf-8
  2. import random
  3.  
  4. #################################
  5. #Movie
  6.  
  7. #Creamos la clase Movie
  8. class Movie:
  9.         
  10.         def __init__(self,title="emptyTitle",
  11.                                           director=["emptyDirector"],
  12.                                           cast = ["emptyCast"],
  13.                                           producer = ["emptyProducer"],
  14.                                           writer = ["emptyWriter"],
  15.                                           country = ["emptyCountry"],
  16.                                           language = ["emptyLanguage"],
  17.                                           year = "emptyYear",
  18.                                           genres = ["emptyGenres"],
  19.                                           votes = "emptyVotes",
  20.                                           rating = "emptyRating",
  21.                                           runtime = ["emptyRuntime"],
  22.                                           plot = ["emptyPlot"],
  23.                                           cover_url = "emptyCorver"):
  24.                 
  25.                 self.title = title
  26.                 self.director = director
  27.                 self.cast = cast
  28.                 self.producer = producer
  29.                 self.writer = writer
  30.                 self.country = country
  31.                 self.language = language
  32.                 self.year = year
  33.                 self.genres = genres
  34.                 self.votes = votes
  35.                 self.rating = rating
  36.                 self.runtime = runtime
  37.                 self.plot = plot
  38.                 self.cover_url = cover_url
  39.  
  40.         def GetTitle(self):
  41.                 return self.title
  42.             
  43.         def __str__(self):
  44.             return self.title
  45.         
  46.         def __repr__(self):
  47.             return self.__str__()
  48.  
  49.  
  50.  
  51.  
  52. #################################
  53. #función loadMovieList
  54.  
  55. def loadMovieList(filename):
  56.         peliculas = abrirarchivo(filename)
  57.         movieList = []
  58.         
  59.         for peli in range(len(peliculas)):
  60.                 pelicula = peliculas[peli].split("|")
  61.             
  62.                 p = Movie(pelicula[0],pelicula[1],pelicula[2],pelicula[3],pelicula[4],pelicula[5],pelicula[6],pelicula[7],pelicula[8],pelicula[9],pelicula[10],pelicula[11],pelicula[12],pelicula[13])
  63.                 movieList.append(p)
  64.  
  65.         movieList.sort()
  66.  
  67.         return movieList
  68.  
  69. #################################
  70. #Abrimos el archivo
  71.  
  72. def abrirarchivo(db):
  73.     file = open(db,"r")
  74.     peliculas = file.readlines()
  75.     file.close()
  76.  
  77.     return peliculas
  78.  
  79. movieList = loadMovieList('peliculas100.dat')
  80.  
  81. #Reducimos la lista de peliculas a 21 elementos
  82. movieList = movieList[0:20]
  83.  
  84.                 
  85. #################################
  86. #Stack
  87.         
  88. #Creamos la clase Stack
  89. class Stack:
  90.  
  91.         def __init__(self):
  92.                 pila = []
  93.                 self.sList = pila
  94.          
  95.         def push(self,node):
  96.                 self.sList.append(node)
  97.                 return True
  98.  
  99.         def pop(self):
  100.                 if self.isEmpty():
  101.                     return "La pila esta vacia"
  102.                 else:
  103.                     return self.sList.pop()
  104.      
  105.         def isEmpty(self):
  106.                 return len(self.sList) == 0
  107.      
  108.         def printStack(self):
  109.                 print self.sList
  110.                 return True
  111.         
  112.  
  113. #################################
  114. #Queure
  115.         
  116. #Creamos la clase Queure
  117. class Queure:
  118.         
  119.         def __init__(self):
  120.                 cola = []
  121.                 self.qList = cola
  122.          
  123.         def enqueue(self,node):
  124.                 self.qList.append(node)
  125.                 return True
  126.              
  127.         def dequeue(self):
  128.                 if(self.isEmpty()):
  129.                         return "La cola esta vacia"
  130.                 else:
  131.                         node = self.qList[0]
  132.                         self.qList = self.qList[1:]
  133.                 return node
  134.      
  135.         def isEmpty(self):
  136.                 return len(self.qList) == 0
  137.      
  138.         def printQ(self):
  139.                 print self.qList
  140.                 return True
  141.  
  142.  
  143. #################################
  144. #Test de la clase Stack()
  145.  
  146. newStack = Stack()
  147. newStack.printStack()
  148.  
  149. newNode = movieList[0]
  150. newStack.push(newNode)
  151. newStack.printStack()
  152.  
  153. newStack.push(movieList[1])
  154. newStack.printStack()
  155.  
  156. newStack.push(movieList[2])
  157. newStack.printStack()
  158.  
  159. m1 = newStack.pop()
  160. newStack.printStack()
  161.  
  162. m2 = newStack.pop()
  163. newStack.printStack()
  164.  
  165. m3 = newStack.pop()
  166. newStack.printStack()
  167.  
  168. m4 = newStack.pop()
  169. newStack.printStack()
  170.  
  171. print m1.GetTitle()
  172. print m2.GetTitle()
  173. print m3.GetTitle()
  174. ##print m4.GetTitle()  GUESS WHAT HAPPENS...
  175.  
  176. #################################
  177. #Test de la clase Queure()
  178.  
  179. #newQ = Queue()
  180. #newQ.printQ()
  181.  
  182. #newNode = Node(movieList[0])
  183. #newQ.enqueue(newNode)
  184. #newQ.printQ()
  185.  
  186. #newQ.enqueue(Node(movieList[1]))
  187. #newQ.printQ()
  188.  
  189. #newQ.enqueue(Node(movieList[2]))
  190. #newQ.printQ()
  191.  
  192. #m1 = newQ.dequeue()
  193. #newQ.printQ()
  194.  
  195. #m2 = newQ.dequeue()
  196. #newQ.printQ()
  197.  
  198. #m3 = newQ.dequeue()
  199. #newQ.printQ()
  200.  
  201. #m4 = newQ.dequeue()
  202. #newQ.printQ()
  203.  
  204. #print m1.GetTitle()
  205. #print m2.GetTitle()
  206. #print m3.GetTitle()
  207. #print m4.GetTitle()  GUESS WHAT HAPPENS...
  #6 (permalink)  
Antiguo 03/04/2012, 05:49
Avatar de bichomen  
Fecha de Ingreso: junio-2003
Ubicación: Barcelona y alrededores, España
Mensajes: 877
Antigüedad: 20 años, 11 meses
Puntos: 2
Respuesta: Pilas y colas
Cita:
Iniciado por razpeitia Ver Mensaje
Realmente dudo que hayas escrito el código, mas bien creo que estas copiando y pegando de diferentes partes. Se puede notar fácilmente que el código no esta escrito por una sola persona.

De hecho ni siquiera estas haciendo un uso correcto de la clase nodo. Ya que implementas el stack y el queue con listas y no con la clase nodo. Ademas que el código tienes bien escrito queue mientras en los comentarios escribes Queure casi siempre.

Otra cosa es que no incluiste el archivo peliculas100.dat, así que hice uno, en base en los parámetros del constructor Movies, de hecho también tienes errores ahí y haces mucha duplicación de codigo, movies[0], movies[1] ... movies[13]. Y los parámetros por default son listas en vez de strings. Todo eso nada mas en el costructor de Movies, no quiero hablar sobre el resto.

Bueno aqui dejo peliculas100.dat y el código.
Tienes razón, tenia que presentar la practica, se me acababa el tiempo y anduve buscando el código y encontré cosas similares, pero has de entender que yo soy un novato en python y con las clases y los métodos me lió, osea entiendo el concepto de pila y cola y como funcionan los nodos como hacer que apunte al siguiente, etc.

Pero en el código me pierdo, sobre todo como e dicho a la hora de utilizar las clases, ya en java me cuesta, pues en python ni te digo.

La base de datos no la adjunte, por el tamaño de la misma y más o menos se entendía que lo que estaba utilizando eran los títulos de las películas.


bichomen
__________________
"Se sabe con exactitud, con cuanta imprecisión, se sabe algo"
Linux Registered User #320332

Etiquetas: colas, gui, pilas
Atención: Estás leyendo un tema que no tiene actividad desde hace más de 6 MESES, te recomendamos abrir un Nuevo tema en lugar de responder al actual.
Respuesta


« Tema Anterior | Próximo Tema »


La zona horaria es GMT -6. Ahora son las 09:08.