示例#1
0
    def usuario(self):
        email = str(input("Ingrese E-mail: "))
        password = str(input("Ingrese contraseña: "))  # Usuario se loguea
        posible_User = None  #User.autenticarUsuario(email,password)   # validacion de usuario logueado
        if (posible_User == None):
            print("Usuario no encontrado")
        else:
            break_while = True
            while (break_while):
                print("""
            CHEAPY Menu Usuario
              1. Crear playlist
              2. Eliminar playlist
              3. Agrega comentario
              4. Eliminar comentario
              5. Salir
              
              """)

                op = int(input("ingrese opcion: "))

                if (op == 1):
                    Lista.crearLista()
                elif (op == 2):
                    Lista.eliminarLista()
                elif (op == 3):
                    Comentarios.agregarComentario()
                elif (op == 4):
                    comentarios.eliminarComentario()
                elif (op == 5):
                    break_while = False
示例#2
0
文件: Grafo.py 项目: hugouraga/grafos
class Matriz:
    def __init__(self, quantVertices=0):
        self.quantVertices = quantVertices
        self.listaVertices = Lista()

        for elemento in range(quantVertices):
            self.listaVertices.inserir([])

    def vazia(self):
        return self.quantVertices == 0

    def inserirAresta(self, verticeA, verticeB, grafoDirecionado=True):
        self.listaVertices.inserirAres(verticeA, verticeB)

    def __str__(self):
        #return self.listaVertices.__str__()
        aux = 0
        tamanhoLista = self.listaVertices.__len__()
        objeto = self.listaVertices.primeiro.proximo
        s = ""
        while aux < tamanhoLista:
            s += str(aux) + " = " + str(objeto.item)
            s += "\n"
            aux += 1
            objeto = objeto.proximo
        return s
示例#3
0
 def __init__(self,quantVertices = 0,grafoDirecionado=False,pesoAresta=None):
     self.quantVertices = quantVertices
     self.listaVertices = Lista()
     self.grafoDirecionado = grafoDirecionado
     self.pesoAresta = pesoAresta
     for elemento in range(quantVertices):
         self.listaVertices.inserir([])
    def crearParticiones(self):
        #llamar al metodo agregarProcesoFijoMismoTamnio
        self.lista = Lista()
        # print(self.seleccionarDivisionDeMemoria.currentText())
        self.tablaBitacora.clearContents()
        particiones=int(self.seleccionarDivisionDeMemoria.currentText())
        self.lista.hacerParticionesMismoTamanioFijo(particiones)
        self.tablaBitacora.setRowCount(particiones)
        for h in range(0,self.tablaBitacora.rowCount()):
            if self.tablaBitacora.rowCount() == 8:
                self.tablaBitacora.setRowHeight(h,36)
            elif self.tablaBitacora.rowCount() == 7:
                self.tablaBitacora.setRowHeight(h,42)
            elif self.tablaBitacora.rowCount() == 4:
                self.tablaBitacora.setRowHeight(h,73)
            elif self.tablaBitacora.rowCount() == 2:
                self.tablaBitacora.setRowHeight(h,145)
            elif self.tablaBitacora.rowCount() == 1:
                self.tablaBitacora.setRowHeight(h,300)

            self.tablaBitacora.setItem(h, 0, QTableWidgetItem("%d MB"%(56/particiones)))
            self.tablaBitacora.item(h,0).setTextAlignment(Qt.AlignCenter)
            # self.tablaBitacora.item(0,0).setText("Hola")

        self.lista.listar()
示例#5
0
    def exibeEmOrdem(self, criterio, ordem):
        '''
    exibeEmOrdem(criterio, ordem)
      Ordena a lista de candidatos e imprime ordenado.

    criterio:
      - alfabetica (Nome dos candidatos)
      - bens (Valor total dos bens)
      - partido (Nome do partido)
      - data (Data de nascimento)
    ordem:
      - crescente
      - decrescente
    '''
        if criterio == 'alfabetica': criterio = 'alfa'
        elif criterio in ['bens', 'partido', 'data']: pass
        else: criterio = 'alfa'
        if ordem == 'crescente': ordem = 'cres'
        elif ordem == 'decrescente': ordem = 'dec'
        else: ordem = 'cres'
        criterio += ordem
        nova = Lista()
        for candidato in self.__listaDeCandidatos:
            nova.insereOrdenado(candidato, criterio)
        self.__listaDeCandidatos = nova
        print(self)
示例#6
0
 def __init__(self, ano, ufEleicao, codigoCargo, descricaoCargo, nome, idCandidato, numero, 
              cpf, urna, numPartido, partido, siglaPartido, codigoOcupacao, 
              descricaoOcupacao, nascimento, sexo, escolaridade, estadoCivil, ufNascimento,
              municipio, situacaoPleito, situacaoCandidatura, listaDeBens):
   self.__ano = ano
   self.__ufEleicao = ufEleicao
   self.__codigoCargo = codigoCargo
   self.__descricaoCargo = descricaoCargo
   self.__nome = nome
   self.__idCandidato = idCandidato
   self.__numero = numero
   self.__cpf = cpf
   self.__urna = urna
   self.__numPartido = numPartido
   self.__partido = partido
   self.__siglaPartido = siglaPartido
   self.__codigoOcupacao = codigoOcupacao
   self.__descricaoOcupacao = descricaoOcupacao
   self.__nascimento = nascimento
   self.__sexo = sexo
   self.__escolaridade = escolaridade
   self.__estadoCivil = estadoCivil
   self.__ufNascimento = ufNascimento
   self.__municipio = municipio
   self.__situacaoPleito = situacaoPleito
   self.__situacaoCandidatura = situacaoCandidatura
   self.__listaDeBens = Lista()
    def __init__(self, sql=None):
        QMainWindow.__init__(self)
        QMainWindow.setWindowFlags(self, Qt.MSWindowsFixedSizeDialogHint)
        self.setWindowIcon(QIcon("ram.png"))
        self.setWindowTitle("Simulador de memoria")
        self.resize(400, 350)
        self.lista = Lista()
        self.centralwidget = QWidget(self)
        self.setCentralWidget(self.centralwidget)
        self.setStyleSheet("QGroupBox {background:rgba(245, 246, 250,.95)}")

        pixmap = QPixmap("fondoMain1.png")
        self.label = QLabel(self.centralwidget)
        self.label.setGeometry(QRect(0, 0, 400, 370))
        self.label.setPixmap(pixmap)
        self.label.setScaledContents(True)

        #    self.showTable()
        self.groupMainWindow()

        # self.seleccionarDivisionDeMemoria.currentIndexChanged.connect(self.crearParticiones)
        self.ptCargar.clicked.connect(self.agregarProceso)
        self.ptLiberar.clicked.connect(self.liberarProceso)
        self.crearParticiones()

        self.seleccionarDivisionDeMemoriaLC.currentTextChanged.connect(
            self.prueba2)
def xml_client():
    data = request.get_data()
    str = data.decode("utf-8")

    e = xml.etree.ElementTree.fromstring(str)
    for child in e.findall('usuarios'):
        for usuario in child:
            usr = Usuario()
            usr.cola = Lista()
            usr.username = usuario.find("nombre").text
            usr.password = usuario.find("pass").text
            users.add(usr)

    for artistas in e.findall('artistas'):
        for artista in artistas:

            for albums in artista.findall('albumes'):
                for album in albums:
                    node_album = Album()
                    node_album.año = album.find("annioo").text
                    node_album.genero = album.find("genero").text
                    node_album.nombre = album.find("nombre").text
                    node_album.canciones = Lista()
                    year_data = songs_directory.add_year(node_album.año).data
                    genere = songs_directory.add_genere(
                        year_data, node_album.genero).data
                    node_artist = Artista()
                    node_artist.nombre = artista.find("nombre").text
                    node_artist.b_year = year_data.year
                    node_artist.b_genere = genere.genere
                    artist_b_genere = genere.arbol.search(node_artist)
                    if artist_b_genere is None:
                        node_artist.albums = None
                        artist_b_genere = genere.arbol.insert(node_artist)
                    if artist_b_genere.albums is None:
                        artist_b_genere.albums = ABB()

                    for canciones in album.findall('canciones'):
                        for cancion in canciones:
                            node_cancion = Cancion()
                            node_cancion.nombre = cancion.find("nombre").text
                            node_cancion.path = cancion.find("path").text
                            node_cancion.artist = node_artist.nombre
                            node_cancion.year = node_album.año
                            node_cancion.genere = node_album.genero
                            node_cancion.album = node_album.nombre
                            node_album.canciones.add(node_cancion)
                    artist_b_genere.albums.raiz = artist_b_genere.albums.insert(
                        artist_b_genere.albums.raiz, node_album)

                    artist_albums.add(node_album)
            artists.add(artist_albums)
    g.songs_directory = songs_directory

    #e =
    return ""
示例#9
0
 def criaLista(self):
     nome = input("Informe o nome da Lista: ")
     today = date.today()
     status = 'Open'
     lista = Lista(None, nome, today, status)
     lista.id = self.listaDao.insertLista(lista)
     option = int(input("Deseja inserir produtos na lista agora? 1-Sim|0-Não "))
     if option == 1:
         self.putItemLista(lista.id)
     else:
         print("Lista criada com sucesso!!!")
示例#10
0
 def test_eliminar_list(self):
     nombre = 'Nombre Lista'
     publica = False
     descripcion = 'Descripcion del Lista'
     creador = 'usuario'
     lista = Lista(nombre=nombre,
                   publica=publica,
                   descripcion=descripcion,
                   creador=creador)
     # lista.crearLista()
     lista.eliminarLista()
     lista_file = pd.read_csv('listas.csv', index_col=0)
     self.assertEqual(lista_file.empty, True)
def new_tokenize(text):
    data_list = Lista()
    new_text = ''
    for dados in text:
        if dados != ';':
            new_text += dados
        else:
            data_list.anexar(new_text)
            new_text = ''
    for i in range(data_list.size):
        data_list[i] = remove_par(data_list[i])

    return data_list
示例#12
0
 def test_crear_lista(self):
     nombre = 'Nombre Lista'
     publica = False
     descripcion = 'Descripcion del Lista'
     creador = 'usuario'
     lista = Lista(nombre=nombre,
                   publica=publica,
                   descripcion=descripcion,
                   creador=creador)
     lista.crearLista()
     lista_file = pd.read_csv('listas.csv', index_col=0).iloc[0]
     self.assertEqual(lista_file.nombre, nombre)
     self.assertEqual(lista_file.publica, publica)
     self.assertEqual(lista_file.descripcion, descripcion)
示例#13
0
 def __init__(self,
              eleicao=None,
              uf=None,
              cod_cargo=None,
              desc_cargo=None,
              nome=None,
              num_seq=None,
              num_urna=None,
              cpf=None,
              nome_urna=None,
              num_partido=None,
              nome_partido=None,
              sigla_partido=None,
              cod_profissao=None,
              profissao=None,
              data_nasc=None,
              sexo=None,
              instrucao=None,
              estado_civil=None,
              uf_nasc=None,
              nome_municipio=None,
              sit_pleito=None,
              sit_cand=None):
     '''
     Constructor
     '''
     self.__eleicao = int(eleicao)
     self.__uf = uf
     self.__cod_cargo = int(cod_cargo)
     self.__desc_cargo = desc_cargo
     self.__nome = nome
     self.__num_seq = num_seq
     self.__num_urna = num_urna
     self.__cpf = cpf
     self.__nome_urna = nome_urna
     self.__num_partido = int(num_partido)
     self.__nome_partido = nome_partido
     self.__sigla_partido = sigla_partido
     self.__cod_profissao = int(cod_profissao)
     self.__profissao = profissao
     self.__data_nasc = Data.to_data(data_nasc)
     self.__sexo = sexo
     self.__instrucao = instrucao
     self.__estado_civil = estado_civil
     self.__uf_nasc = uf_nasc
     self.__nome_municipio = nome_municipio
     self.__sit_pleito = sit_pleito
     self.__sit_cand = sit_cand
     self.__bens = Lista()
示例#14
0
class ProbarLista(unittest.TestCase):
    def setUp(self):
        self.clase = Lista([10, 14, 50, 32, 50, 89, 90])

    def test_SumarNumeros(self):
        self.assertEqual(4, self.clase.sumarDosNumeros(2, 2))

    def test_BuscaNumero(self):
        self.assertEqual("Yes", self.clase.encontrarEnLista(10))

    def test_NoEncuentra(self):
        self.assertNotEqual("Yes", self.clase.encontrarEnLista(100))

    def tearDown(self):
        print("Se han terminado las pruebas")
示例#15
0
    def loadBens(self, folder):
        '''
    loadBens(folder)
      Insere os bens dos candidatos.

    folder: Nome da pasta onde está todos os csv's
    '''
        colecaoBens = {}
        nomes = os.listdir(folder)
        for archive in nomes:
            if archive not in ['leiame.pdf', 'bem_candidato_2014_BRASIL']:
                arquivo = open(folder + '/' + archive, 'r', errors='ignore')
                bens = arquivo.readlines()
                arquivo.close()
                bens = [x.strip().replace('"', "").split(";") for x in bens]
                for informacoes in bens:
                    if 'DT_GERACAO' not in informacoes:
                        if informacoes[11] not in colecaoBens:
                            colecaoBens[informacoes[11]] = Lista()
                        bem = Bem(informacoes[13], informacoes[14],
                                  informacoes[15], informacoes[16])
                        if bem not in colecaoBens[informacoes[11]]:
                            colecaoBens[informacoes[11]].append(bem)
        for candidato in self.__listaDeCandidatos:
            if candidato.getIdDoCandidato() in colecaoBens:
                candidato.setListaDeBens(
                    colecaoBens[candidato.getIdDoCandidato()])
示例#16
0
 def test_crear_nombre_publica(self):
     nombre = 'Nombre Lista'
     creador = 'usuario'
     lista = Lista(nombre, publica=True, creador=creador)
     assert lista is not None
     self.assertEqual(lista.nombre, nombre)
     self.assertEqual(lista.publica, True)
     self.assertEqual(lista.descripcion, None)
示例#17
0
 def test_eq(self):
     self.assertNotEqual(self.lista, None)
     l = Lista()
     self.assertEqual(self.lista, l)
     i = self.numero_aleatorio()
     c = 0
     while (c < i):
         nuevo_numero = self.numero_aleatorio()
         l.agrega_final(nuevo_numero)
         self.lista.agrega_final(nuevo_numero)
         c += 1
     self.assertEqual(self.lista, l)
     ultimo = l.elimina_ultimo()
     self.assertNotEqual(self.lista, l)
     self.lista.agrega_final(ultimo)
     self.assertNotEqual(self.lista, l)
     self.assertNotEqual(self.lista, None)
示例#18
0
class Estructuras:
    mi_lista = Lista()

    def agregar_lista(self, dato):
        self.mi_lista.insertar_ordenado(dato)

    def eliminar_lista(self, dato):
        self.mi_lista.eliminar_elem(dato)
示例#19
0
    def administrador(self):
        break_while = True
        while (break_while):
            print("""
         CHEAPY Menu Administrador
            1. Ver usuarios
            2. Crear usuario
            3. Eliminar Usuario
            4. Crear playlist
            5. Eliminar playlist
            6. Crear albúm
            7. Eliminar albúm
            8. Crear artista
            9. Eliminar artista
            10. Agregar comentario
            11. Eliminar comentario
            12. Salir

            """)

            op = int(input("ingrese opcion: "))
            if (op == 1):
                print("La cantidad de usarios registrados es: \n",
                      User.CONTADOR_USERS)
            elif (op == 2):
                User.registrar_usuario()
            elif (op == 3):
                User.eliminarUsuario()
            elif (op == 4):
                Lista.crearLista()
            elif (op == 5):
                Lista.eliminarLista()
            elif (op == 6):
                Album.rearAlbum()
            elif (op == 7):
                Album.eliminarAlbum()
            elif (op == 8):
                Artista.crearArtista()
            elif (op == 9):
                Artista.eliminarArtista()
            elif (op == 10):
                Comentarios.agregarComentario()
            elif (op == 11):
                Comentarios.eliminarComentario()
            elif (op == 12):
                break_while = False
示例#20
0
    def invitado(self):
        break_while = True
        while (break_while):
            print("""
         CHEAPY Menu Usuario
           1. Registrase
           2. Ver playlist
           3. Salir

           """)

            op = int(input("Ingrese opcion: "))
            if (op == 1):
                User.registrar_usuario()
            elif (op == 2):
                Lista.verlistas()
            elif (op == 3):
                break_while = False
示例#21
0
 def add_year(self, data):
     year_to_insert = Year()
     year_to_insert.generes = Lista()
     year_to_insert.year = data
     row_year = self.years.search_year(year_to_insert.year)
     if  row_year is None:
         return self.years.add(year_to_insert)
     else:
         return row_year
 def crearParticiones(self):
     self.lista = Lista()
     self.lista.hacerParticionesDeDiferenteTamnio()
     self.lista.listar()
     particiones = [14, 11, 20, 4, 7]
     for h in range(0, self.tablaBitacora.rowCount()):
         if particiones[h] == 14:
             self.tablaBitacora.setRowHeight(h, 70)
         elif particiones[h] == 11:
             self.tablaBitacora.setRowHeight(h, 50)
         elif particiones[h] == 20:
             self.tablaBitacora.setRowHeight(h, 97)
         elif particiones[h] == 4:
             self.tablaBitacora.setRowHeight(h, 20)
         elif particiones[h] == 7:
             self.tablaBitacora.setRowHeight(h, 40)
         self.tablaBitacora.setItem(
             h, 0, QTableWidgetItem("%d MB" % (particiones[h])))
         self.tablaBitacora.item(h, 0).setTextAlignment(Qt.AlignCenter)
示例#23
0
    def __init__(self, caminho_panilha):
        self.__lista_candidatos = None
        self.__bens = {}
        self.__lista_candidatos = Lista()
        arquivo_2 = open(caminho_panilha+'\\bem_candidato_2014\\bem_candidato_2014_PE.csv', 'r')


        for linhas in arquivo_2:
            tokenizado = new_tokenize(linhas)
            try:
                self.__bens[tokenizado[11]].anexar(Bem(tokenizado[6], tokenizado[14], tokenizado[15], tokenizado[16]))
            except:
                self.__bens[tokenizado[11]] = Lista()
                self.__bens[tokenizado[11]].anexar(Bem(tokenizado[6], tokenizado[14], tokenizado[15], tokenizado[16]))
        arquivo_2.close()



        arquivo = open(caminho_panilha+'\\consulta_cand_2014\\consulta_cand_2014_PE.csv', 'r')
        for linhas in arquivo:
            tokenizado = new_tokenize(linhas)
            self.__lista_candidatos.anexar(Candidato(tokenizado[2], tokenizado[10], tokenizado[14], tokenizado[17], tokenizado[15], tokenizado[16], tokenizado[20], tokenizado[18], tokenizado[27], tokenizado[28], tokenizado[13], tokenizado[14], tokenizado[38], tokenizado[42], tokenizado[44], tokenizado[46], tokenizado[35], tokenizado[37], tokenizado[54], tokenizado[53], tokenizado[14], tokenizado[13]))
        self.__lista_candidatos.remover(0)



        for candidatos in self.__lista_candidatos:
            try:
                candidatos.alterarListaBens(self.__bens[candidatos.getID()])
            except:
                candidatos.alterarListaBens(None)

            if candidatos.getListaBens():
                for bens in candidatos.getListaBens():
                    if bens is not None:
                        try:
                            candidatos.alterarTotalDeclarado(float(remover_virgula(bens.getValorBem())))
                        except:
                            pass
                    else:
                        pass
示例#24
0
 def opcion6(self, lista):
     lista1 = Lista()
     for agente in lista:
         lista1.agregarElemento(agente)
     contar = lista.getTope()
     lista1.ordenar(contar, False)
     for agente in lista1:
         print("--------------------------")
         print("Apellido: {}\nNombre: {}".format(agente.getApellido(),
                                                 agente.getNombre()))
         print("Sueldo: {}".format(agente.Sueldo()))
示例#25
0
    def test_modificar_lista(self):
        nombre = 'Nombre Lista'
        publica = False
        descripcion = 'Descripcion del Lista'
        creador = 'usuario'
        lista = Lista(nombre=nombre,
                      publica=publica,
                      descripcion=descripcion,
                      creador=creador)

        lista.crearLista()
        lista_file = pd.read_csv('listas.csv', index_col=0).iloc[0]
        descripcion_modificado = 'Descripcion de la lista modificada'
        lista.descripcion = descripcion_modificado
        lista.modificarLista()
        lista_file = pd.read_csv('listas.csv', index_col=0).iloc[0]
        self.assertEqual(lista_file.nombre, nombre)
        self.assertEqual(lista_file.publica, publica)
        self.assertEqual(lista_file.descripcion, descripcion_modificado)

        lista.eliminarLista()
        lista_file = pd.read_csv('listas.csv', index_col=0)
        self.assertEqual(lista_file.empty, True)
示例#26
0
 def opcion4(self, lista):
     carrera = input("Ingrese carrera en la que buscar: ")
     contar = 0
     lista1 = Lista()
     for agente in lista:
         if type(agente) == DocenteInvestigador:
             carr = agente.getCarrera()
             if carr.lower() == carrera.lower():
                 contar += 1
                 lista1.agregarElemento(agente)
     lista1.ordenar(contar, True)
     for agente in lista1:
         agente.mostrar()
示例#27
0
class TestLista(unittest.TestCase):
    def numero_aleatorio(self):
        return 10 + random.randint(0, 100)

    def setUp(self):
        self.lista = Lista()
        return self.lista

    def valida_lista(self, lista):
        if (not isinstance(lista, Lista)):
            return
        l = []
        contador = 0
        for elemento in lista:
            l.append(elemento)
            self.assertTrue(l[contador] == lista.get(contador))
            contador += 1
        self.assertTrue(len(lista) == contador)

    def test_constructor(self):
        self.assertTrue(self.lista != None)
        self.assertTrue(self.lista.es_vacia())
        self.assertTrue(len(self.lista) == 0)

    def test_get_longitud(self):
        self.assertTrue(len(self.lista) == 0)
        i = self.numero_aleatorio()
        contador = 0
        while (contador < (i / 2)):
            self.lista.agrega_final(random.randint(0, 100))
            contador += 1
            self.assertTrue(len(self.lista) == contador)
        while (contador < i):
            self.lista.agrega_final(random.randint(0, 100))
            contador += 1
            self.assertTrue(len(self.lista) == contador)
        self.assertTrue(len(self.lista) == contador)
        self.assertFalse(self.lista.es_vacia())

    def test_get_elementos(self):
        self.assertTrue(len(self.lista) == 0)
        self.assertTrue(self.lista.es_vacia())
        i = self.numero_aleatorio()
        contador = 0
        while (contador < (i / 2)):
            self.lista.agrega_final(random.randint(0, 100))
            contador += 1
            self.assertTrue(len(self.lista) == contador)
        while (contador < i):
            self.lista.agrega_final(random.randint(0, 100))
            contador += 1
            self.assertTrue(len(self.lista) == contador)
        self.assertTrue(len(self.lista) == contador)
        self.assertFalse(self.lista.es_vacia())

    def test_es_vacia(self):
        self.assertTrue(len(self.lista) == 0)
        self.assertTrue(self.lista.es_vacia())
        self.lista.agrega_final(random.randint(0, 100))
        self.assertFalse(self.lista.es_vacia())
        self.assertFalse(len(self.lista) == 0)
        self.lista.elimina_primero()
        self.assertTrue(self.lista.es_vacia())
        self.assertTrue(len(self.lista) == 0)

    def test_agrega(self):
        with self.assertRaises(TypeError):
            self.lista.agrega_final(None)
            self.fail()
        self.lista.agrega(random.randint(0, 100))
        n = self.lista.get_primero()
        self.assertEqual(self.lista.get_primero(), n)
        self.valida_lista(self.lista)
        self.lista.agrega_inicio(random.randint(0, 100))
        numero = self.lista.get_primero()
        while (numero == n):
            numero = random.randint(0, 100)
        self.assertNotEqual(n, numero)
        self.valida_lista(self.lista)
        self.assertNotEqual(self.lista.get_ultimo(), 2)
        i = self.numero_aleatorio()
        contador = 0
        while (contador < i):
            num = self.numero_aleatorio()
            self.lista.agrega(num)
            self.assertEqual(self.lista.get_ultimo(), num)
            contador += 1

    def test_agrega_final(self):
        with self.assertRaises(TypeError):
            self.lista.agrega_final(None)
            self.fail()
        numero = self.numero_aleatorio()
        self.lista.agrega_final(numero)
        self.assertEqual(numero, self.lista.get_primero())
        self.valida_lista(self.lista)
        n = self.numero_aleatorio()
        self.lista.agrega_inicio(n)
        self.assertNotEqual(n, self.lista.get_ultimo())
        num = self.numero_aleatorio()
        c = 0
        while (c < num):
            nuevo_numero = self.numero_aleatorio()
            self.lista.agrega_final(nuevo_numero)
            self.assertEqual(nuevo_numero, self.lista.get_ultimo())
            c += 1

    def test_agrega_inicio(self):
        with self.assertRaises(TypeError):
            self.lista.agrega_inicio(None)
            self.fail()
        numero = self.numero_aleatorio()
        self.lista.agrega_inicio(numero)
        self.valida_lista(self.lista)
        self.assertEqual(self.lista.get_primero(), numero)
        n = self.numero_aleatorio()
        while (n == numero):
            n = self.numero_aleatorio()
        self.lista.agrega_final(n)
        self.assertNotEqual(self.lista.get_primero(), n)
        self.valida_lista(self.lista)
        num = self.numero_aleatorio()
        c = 0
        while (c < num):
            nuevo_numero = self.numero_aleatorio()
            self.lista.agrega_inicio(nuevo_numero)
            self.assertEqual(self.lista.get_primero(), nuevo_numero)
            c += 1

    def test_inserta(self):
        with self.assertRaises(TypeError):
            self.lista.inserta(self.numero_aleatorio(), None)
            self.fail()
        l = Lista()
        total = self.numero_aleatorio()
        c = 0
        while (c < total):
            l.agrega_inicio(total + c)
            self.lista.inserta(-1, total + c)
            self.valida_lista(self.lista)
            self.assertEqual(self.lista, l)
            self.assertEqual(self.lista.get_primero(), total + c)
            c += 1
        with self.assertRaises(TypeError):
            c = -1
            while (c <= total):
                self.lista.inserta(c, None)
                self.fail()
                c += 1
        self.lista.limpia()
        self.assertTrue(self.lista.es_vacia())
        l.limpia()
        self.assertTrue(l.es_vacia())
        c = 0
        while (c < total):
            self.lista.inserta(0, total + c)
            l.agrega_inicio(total + c)
            self.valida_lista(self.lista)
            self.assertEqual(self.lista, l)
            self.assertEqual(self.lista.get_primero(), total + c)
            c += 1
        self.lista.limpia()
        self.assertTrue(self.lista.es_vacia())
        l.limpia()
        self.assertTrue(l.es_vacia())
        c = 0
        while (c < total):
            self.lista.inserta(len(self.lista), total + c)
            l.agrega_final(total + c)
            self.valida_lista(self.lista)
            self.assertEqual(self.lista.get_ultimo(), total + c)
            self.assertEqual(self.lista, l)
            c += 1
        self.lista.limpia()
        self.assertTrue(self.lista.es_vacia())
        l.limpia()
        self.assertTrue(l.es_vacia())
        c = 0
        while (c < total):
            indice = random.randint(1, total - 2)
            self.lista.limpia()
            self.assertTrue(self.lista.es_vacia())
            l.limpia()
            self.assertTrue(l.es_vacia())
            i = 0
            while (i < total):
                l.agrega_final(total + i)
                if (i != indice):
                    self.lista.agrega_final(total + i)
                self.valida_lista(l)
                self.valida_lista(self.lista)
                i += 1
            self.assertEqual(len(l), len(self.lista) + 1)
            self.lista.inserta(indice, total + indice)
            self.valida_lista(self.lista)
            self.assertEqual(self.lista, l)
            c += 1

    def test_elimina(self):
        self.lista.elimina(None)
        self.assertTrue(self.lista.es_vacia())
        self.assertTrue(len(self.lista) == 0)
        self.lista.elimina(self.numero_aleatorio())
        self.assertTrue(self.lista.es_vacia())
        self.assertTrue(len(self.lista) == 0)
        self.lista.agrega_final(self.numero_aleatorio())
        self.assertFalse(self.lista.es_vacia())
        self.assertFalse(len(self.lista) == 0)
        self.lista.elimina_ultimo()
        self.assertTrue(self.lista.es_vacia())
        i = self.numero_aleatorio()
        c = random.randint(1, i)
        j = 0
        m = 0
        while (j < i):
            self.lista.agrega_final(c)
            c += 1
            if (j == math.floor(i / 2)):
                m = c - 1
            j += 1
        p = self.lista.get_primero()
        u = self.lista.get_ultimo()
        self.assertTrue(self.lista.contiene(m))
        self.assertTrue(self.lista.contiene(p))
        self.assertTrue(self.lista.contiene(u))
        self.lista.elimina(p)
        self.valida_lista(self.lista)
        self.assertFalse(self.lista.contiene(p))
        j -= 1
        self.assertTrue(len(self.lista) == j)
        self.lista.elimina(u)
        self.valida_lista(self.lista)
        self.assertFalse(self.lista.contiene(u))
        j -= 1
        self.assertTrue(len(self.lista) == j)
        self.lista.elimina(m)
        self.valida_lista(self.lista)
        self.assertFalse(self.lista.contiene(m))
        j -= 1
        self.assertTrue(len(self.lista) == j)
        while (not (self.lista.es_vacia())):
            self.lista.elimina(self.lista.get_primero())
            j -= 1
            self.assertTrue(len(self.lista) == j)
            if (self.lista.es_vacia()):
                continue
            self.lista.elimina(self.lista.get_ultimo())
            j -= 1
            self.assertTrue(len(self.lista) == j)
        with self.assertRaises(Exception):
            self.lista.get_primero()
            self.fail()
        with self.assertRaises(Exception):
            self.lista.get_ultimo()
            self.fail()
        i = self.numero_aleatorio()
        j = self.numero_aleatorio()
        k = self.numero_aleatorio()
        self.lista.agrega_final(i)
        self.lista.agrega_final(j)
        self.lista.agrega_final(k)
        self.lista.agrega_final(j)
        self.assertTrue(self.lista.contiene(i))
        self.assertTrue(self.lista.contiene(j))
        self.assertTrue(self.lista.contiene(k))
        self.lista.elimina(j)
        self.assertEqual(self.lista.get(0), i)
        self.assertEqual(self.lista.get(1), k)
        self.assertEqual(self.lista.get(2), j)
        self.lista.elimina(j)
        self.assertFalse(self.lista.contiene(j))
        self.assertEqual(self.lista.get(0), i)
        self.assertEqual(self.lista.get(1), k)

    def test_elimina_primero(self):
        with self.assertRaises(Exception):
            self.lista.elimina_primero(1)
            self.fail()
        l = []
        i = self.numero_aleatorio()
        c = 0
        while (c < i):
            nuevo_numero = self.numero_aleatorio()
            self.lista.agrega_final(nuevo_numero)
            l.append(nuevo_numero)
            c += 1
        self.assertTrue(len(self.lista) == c)
        self.assertFalse(self.lista.es_vacia())
        indice = 0
        while (not (self.lista.es_vacia())):
            elemento_eliminado = self.lista.elimina_primero()
            self.assertEqual(elemento_eliminado, l[indice])
            c -= 1
            indice += 1
            self.assertTrue(len(self.lista) == c)
        with self.assertRaises(Exception):
            self.lista.elimina_primero()
            self.fail()

    def test_elimina_ultimo(self):
        with self.assertRaises(Exception):
            self.lista.elimina_ultimo()
            self.fail()
        self.assertTrue(len(self.lista) == 0)
        self.assertTrue(self.lista.es_vacia())
        l = []
        i = self.numero_aleatorio()
        c = 0
        while (c < i):
            nuevo_numero = self.numero_aleatorio()
            self.lista.agrega_final(nuevo_numero)
            l.append(nuevo_numero)
            c += 1
        self.assertTrue(len(self.lista) == c)
        while (not (self.lista.es_vacia())):
            elemento_eliminado = self.lista.elimina_ultimo()
            c -= 1
            self.assertEqual(elemento_eliminado, l[c])
            self.assertTrue(len(self.lista) == c)
        with self.assertRaises(Exception):
            self.lista.elimina_ultimo()
            self.fail()

    def test_contiene(self):
        self.assertTrue(self.lista.es_vacia())
        numero = self.numero_aleatorio()
        self.assertFalse(self.lista.contiene(numero))
        self.lista.agrega_final(numero)
        self.assertTrue(self.lista.contiene(numero))
        i = self.numero_aleatorio()
        c = 0
        while (c < i):
            numero_nuevo = self.numero_aleatorio()
            self.lista.agrega_final(numero_nuevo)
            self.assertTrue(self.lista.contiene(numero_nuevo))
            c += 1
        m = self.lista.get(random.randint(0, len(self.lista) - 1))
        self.assertTrue(self.lista.contiene(m))

    def test_reversa(self):
        reversa = self.lista.reversa()
        self.assertTrue(reversa.es_vacia())
        self.assertTrue(len(self.lista) == len(reversa))
        self.assertIsNot(self.lista, reversa)
        i = self.numero_aleatorio()
        c = 0
        while (c < i):
            self.lista.agrega_final(self.numero_aleatorio())
            c += 1
        reversa = self.lista.reversa()
        self.valida_lista(reversa)
        self.assertTrue(len(self.lista) == len(reversa))
        self.assertIsNot(self.lista, reversa)
        while (not (reversa.es_vacia())):
            elemento = reversa.elimina_ultimo()
            e = self.lista.elimina_primero()
            self.assertEqual(elemento, e)
        self.assertTrue(len(self.lista) == len(reversa))
        self.assertTrue(self.lista.es_vacia() and reversa.es_vacia())

    def test_copia(self):
        copia = self.lista.copia()
        self.assertTrue(copia.es_vacia())
        self.assertTrue(len(self.lista) == len(copia))
        self.assertIsNot(self.lista, copia)
        i = self.numero_aleatorio()
        c = 0
        while (c < i):
            self.lista.agrega_final(self.numero_aleatorio())
            c += 1
        copia = self.lista.copia()
        self.valida_lista(copia)
        self.assertTrue(len(self.lista) == len(copia))
        self.assertIsNot(self.lista, copia)
        while (not (copia.es_vacia())):
            elemento = copia.elimina_primero()
            e = self.lista.elimina_primero()
            self.assertEqual(elemento, e)
        self.assertTrue(len(self.lista) == len(copia))
        self.assertTrue(self.lista.es_vacia() and copia.es_vacia())

    def test_limpia(self):
        self.assertTrue(self.lista.es_vacia())
        primero = self.numero_aleatorio()
        self.lista.agrega_final(primero)
        self.assertFalse(self.lista.es_vacia())
        i = self.numero_aleatorio()
        c = 0
        while (c < i):
            self.lista.agrega_final(self.numero_aleatorio())
            c += 1
        self.assertFalse(self.lista.es_vacia())
        self.assertTrue(len(self.lista) != 0)
        ultimo = self.numero_aleatorio()
        self.lista.agrega_final(ultimo)
        self.assertEqual(self.lista.get_primero(), primero)
        self.assertEqual(self.lista.get_ultimo(), ultimo)
        self.assertFalse(self.lista.es_vacia())
        self.lista.limpia()
        self.assertTrue(len(self.lista) == 0)
        self.assertTrue(self.lista.es_vacia())

    def test_get_primero(self):
        with self.assertRaises(Exception):
            self.lista.get_primero()
            self.fail()
        self.assertTrue(self.lista.es_vacia())
        i = self.numero_aleatorio()
        c = 0
        while (c < i):
            elemento = self.numero_aleatorio()
            self.lista.agrega_inicio(elemento)
            self.assertEqual(elemento, self.lista.get_primero())
            c += 1
            self.assertTrue(len(self.lista) == c)
        self.assertFalse(self.lista.es_vacia())
        self.assertTrue(len(self.lista) == c)

    def test_get_ultimo(self):
        with self.assertRaises(Exception):
            self.lista.get_ultimo()
            self.fail()
        self.assertTrue(self.lista.es_vacia())
        i = self.numero_aleatorio()
        c = 0
        while (c < i):
            elemento = self.numero_aleatorio()
            self.lista.agrega_final(elemento)
            self.assertEqual(self.lista.get_ultimo(), elemento)
            c += 1
            self.assertTrue(len(self.lista) == c)
        self.assertFalse(self.lista.es_vacia())
        self.assertTrue(len(self.lista) == c)

    def test_get(self):
        self.assertTrue(self.lista.es_vacia())
        l = []
        i = self.numero_aleatorio()
        c = 0
        while (c < i):
            nuevo_numero = self.numero_aleatorio()
            l.append(nuevo_numero)
            self.lista.agrega_final(nuevo_numero)
            self.assertEqual(self.lista.get(c), l[c])
            c += 1
        with self.assertRaises(Exception):
            self.lista.get(-1)
            self.fail()
        with self.assertRaises(Exception):
            self.lista.get(-10)
            self.fail()
        with self.assertRaises(Exception):
            self.lista.get(len(self.lista))
            self.fail()
        with self.assertRaises(Exception):
            self.lista.get(len(self.lista) * 15)
            self.fail()

    def test_indice_de(self):
        self.assertTrue(self.lista.es_vacia())
        numero = self.numero_aleatorio()
        self.assertTrue(self.lista.indice_de(numero) == -1)
        i = self.numero_aleatorio()
        c = 0
        while (c < i):
            nuevo_numero = i + c
            self.lista.agrega_final(nuevo_numero)
            self.assertEqual(self.lista.indice_de(nuevo_numero), c)
            c += 1
            self.assertTrue(len(self.lista) == c)
        self.assertTrue(len(self.lista) == c)

    def test_str(self):
        self.assertEqual(self.lista.__str__(), "[]")
        l = []
        i = self.numero_aleatorio()
        c = 0
        while (c < i):
            nuevo_numero = self.numero_aleatorio()
            l.append(nuevo_numero)
            self.lista.agrega_final(nuevo_numero)
            c += 1
        cadena = "["
        c = 0
        while (c < len(l) - 1):
            cadena += str(l[c]) + ", "
            c += 1
        cadena += str(l[c]) + "]"
        self.assertEqual(cadena, self.lista.__str__())

    def test_eq(self):
        self.assertNotEqual(self.lista, None)
        l = Lista()
        self.assertEqual(self.lista, l)
        i = self.numero_aleatorio()
        c = 0
        while (c < i):
            nuevo_numero = self.numero_aleatorio()
            l.agrega_final(nuevo_numero)
            self.lista.agrega_final(nuevo_numero)
            c += 1
        self.assertEqual(self.lista, l)
        ultimo = l.elimina_ultimo()
        self.assertNotEqual(self.lista, l)
        self.lista.agrega_final(ultimo)
        self.assertNotEqual(self.lista, l)
        self.assertNotEqual(self.lista, None)
示例#28
0
def main():
    lista = Lista()


    for i in range(0,10):
        numero = random.randrange(0,30)
        if(numero < 14):
	        lista.insertarPrimero(numero)
        elif(numero%2 == 0):
	        lista.insertarUltimo(numero)
        else:
	        lista.insertarOrdenado(numero)

    print("-------------------------------------------")
    print("|           Probando la lista             |")
    print("-------------------------------------------\n")
    listSize = lista.longitud()
    print("Lista no ordenada con longitud ",listSize,"\n")
    lista.visualizar()
    print("\nPrueba aleatoria de borrado de 3 elementos\n")
    for i in range(3):
        borrado(lista)
    lista.ordenar()
    listSize2 = lista.longitud()
    if(listSize==listSize2):
        print("No se han borrado datos\n")
    else:
        print("Se borraron ",(listSize-listSize2)," elemento/s\n")
         
    print("Lista ordenada con longitud ",listSize2)
    lista.visualizar()
示例#29
0
 def test_inserta(self):
     with self.assertRaises(TypeError):
         self.lista.inserta(self.numero_aleatorio(), None)
         self.fail()
     l = Lista()
     total = self.numero_aleatorio()
     c = 0
     while (c < total):
         l.agrega_inicio(total + c)
         self.lista.inserta(-1, total + c)
         self.valida_lista(self.lista)
         self.assertEqual(self.lista, l)
         self.assertEqual(self.lista.get_primero(), total + c)
         c += 1
     with self.assertRaises(TypeError):
         c = -1
         while (c <= total):
             self.lista.inserta(c, None)
             self.fail()
             c += 1
     self.lista.limpia()
     self.assertTrue(self.lista.es_vacia())
     l.limpia()
     self.assertTrue(l.es_vacia())
     c = 0
     while (c < total):
         self.lista.inserta(0, total + c)
         l.agrega_inicio(total + c)
         self.valida_lista(self.lista)
         self.assertEqual(self.lista, l)
         self.assertEqual(self.lista.get_primero(), total + c)
         c += 1
     self.lista.limpia()
     self.assertTrue(self.lista.es_vacia())
     l.limpia()
     self.assertTrue(l.es_vacia())
     c = 0
     while (c < total):
         self.lista.inserta(len(self.lista), total + c)
         l.agrega_final(total + c)
         self.valida_lista(self.lista)
         self.assertEqual(self.lista.get_ultimo(), total + c)
         self.assertEqual(self.lista, l)
         c += 1
     self.lista.limpia()
     self.assertTrue(self.lista.es_vacia())
     l.limpia()
     self.assertTrue(l.es_vacia())
     c = 0
     while (c < total):
         indice = random.randint(1, total - 2)
         self.lista.limpia()
         self.assertTrue(self.lista.es_vacia())
         l.limpia()
         self.assertTrue(l.es_vacia())
         i = 0
         while (i < total):
             l.agrega_final(total + i)
             if (i != indice):
                 self.lista.agrega_final(total + i)
             self.valida_lista(l)
             self.valida_lista(self.lista)
             i += 1
         self.assertEqual(len(l), len(self.lista) + 1)
         self.lista.inserta(indice, total + indice)
         self.valida_lista(self.lista)
         self.assertEqual(self.lista, l)
         c += 1
示例#30
0
 def setUp(self):
     self.lista = Lista()
     return self.lista
示例#31
0
from Lista import Lista

lista = Lista()

while True:
    e = input('''
    0  - Finlizar
    01 - Adiconar valores
    02 - Imprimir valores
    03 - Imprimir valores ordenados 
    04 - Imprimir valores inversos
    05 - Remover valor
    Escolha: \n
    ''')
    if e == '0':
        break
    if e == '1':
        valor = input("Digite um valor: ")
        lista.adicionar(valor)
    if e == '2':
        lista.imprimir()
    if e == '3':
        lista.imprimirOrdenado(valor)
    if e == '4':
        lista.imprimirInverso()
    if e == '5':
        lista.remover()
示例#32
0
#-*- coding: utf-8 -*-
from Lista import Lista
from Nodo import Nodo

objLista = Lista()
objLista.insertarFinal('fido', 'golden', '2 años')

objLista.insertarFinal('otro', 'pitbul', '1 año')
objLista.insertarFinal('pipo', 'chihuahua', '11 años')
objLista.imprimirLista()