Python Fila.enfileirar方法代码示例

# 需要导入模块: from aula5.fila import Fila [as 别名]
# 或者: from aula5.fila.Fila import enfileirar [as 别名]
def analise_sintatica(fila):
    token = R"-+/*(){}[]"
    if fila.__len__():
        fila_sintatica = Fila()
        num = ''
        num2 = '.'
        for lex in range(fila.__len__()):
            if fila._deque[lex] in token:
                if num:
                    if num2 in num:
                        fila_sintatica.enfileirar(float(num))
                    else:
                        fila_sintatica.enfileirar(int(num))
                num = ''
                fila_sintatica.enfileirar(fila._deque[lex])
            else:
                num = num + fila._deque[lex]
        if num:
            if num2 in num:
                fila_sintatica.enfileirar(float(num))
            else:
                fila_sintatica.enfileirar(int(num))
        return fila_sintatica
    else:
        raise ErroSintatico

# 需要导入模块: from aula5.fila import Fila [as 别名]
# 或者: from aula5.fila.Fila import enfileirar [as 别名]
def analise_sintatica(expressao):
    """
    Função que realiza analise sintática de tokens produzidos por analise léxica.
    Executa validações sintáticas e se não houver erro retorn fila_sintatica para avaliacao

    :param fila: fila proveniente de análise lexica
    :return: fila_sintatica com elementos tokens de numeros
    """
    expressao=analise_lexica(expressao)

    fila2=Fila()
    if len(expressao)!=0:
        for i in expressao:
            if i in set("{}[]()/+-*") or i in set("0123456789") :

                fila2.enfileirar(i)
            #elif i not in set("."):
             #   fila2.enfileirar(float(i))
            else:
                fila2.enfileirar(i)


        return fila2
    else:
        raise ErroSintatico()

# 需要导入模块: from aula5.fila import Fila [as 别名]
# 或者: from aula5.fila.Fila import enfileirar [as 别名]
def analise_sintatica(fila):
    """
    Analisa a fila e diz se está sintatica ou nao.
    Tempo de execução O(n)
    Espaço de memoria O(n)
    :param expressao: fila a ser analisada
    :return: fila
    """

    if len(fila):
        fila_sintetica = Fila()
        valor = ''
        for n in range(len(fila)):
            if fila._deque[n] in '-+/*(){}[]':
                if valor:
                    if '.' in valor:
                        fila_sintetica.enfileirar(float(valor))
                    else:
                        fila_sintetica.enfileirar(int(valor))
                valor = ''
                fila_sintetica.enfileirar(fila._deque[n])
            else:
                valor = valor + fila._deque[n]
        if valor:
            if '.' in valor:
                fila_sintetica.enfileirar(float(valor))
            else:
                fila_sintetica.enfileirar(int(valor))
        return fila_sintetica
    else:
        raise ErroSintatico

# 需要导入模块: from aula5.fila import Fila [as 别名]
# 或者: from aula5.fila.Fila import enfileirar [as 别名]
 def test_float(self):
     fila = Fila()
     fila.enfileirar('1234567890')
     fila.enfileirar('.')
     fila.enfileirar('4')
     fila_sintatica = analise_sintatica(fila)
     self.assertEqual(1234567890.4, fila_sintatica.desenfileirar())
     self.assertTrue(fila_sintatica.vazia())

# 需要导入模块: from aula5.fila import Fila [as 别名]
# 或者: from aula5.fila.Fila import enfileirar [as 别名]
def analise_sintatica(fila):
    """
    Função que realiza analise sintática de tokens produzidos por analise léxica.
    Executa validações sintáticas e se não houver erro retorn fila_sintatica para avaliacao
    :param fila: fila proveniente de análise lexica
    :return: fila_sintatica com elementos tokens de numeros
    """
    fil = Fila()
    char = ""
    if len(fila) == 0:
        raise ErroSintatico("erro")
    while (len(fila) != 0):
        df = fila.desenfileirar()
        if df in set("-+*/()[]{}"):
            if len(char) > 0:
                if "." in char:
                    fil.enfileirar(float(char))
                    char = ""
                else:
                    fil.enfileirar(int(char))
                    char = ""
            fil.enfileirar(df)
        else:
            char = char + df
    if len(char) != 0:
        if "." in char:
            char = float(char)
        else:
            char = int(char)
        fil.enfileirar(char)

    return fil

    pass

# 需要导入模块: from aula5.fila import Fila [as 别名]
# 或者: from aula5.fila.Fila import enfileirar [as 别名]
def analise_sintatica(fila):
    """
    Função que realiza analise sintática de tokens produzidos por analise léxica.
    Executa validações sintáticas e se não houver erro retorn fila_sintatica para avaliacao

    :param fila: fila proveniente de análise lexica
    :return: fila_sintatica com elementos tokens de numeros
    """
    novafila = Fila()
    if fila.vazia():
        raise ErroSintatico;
    save = ''
    while not fila.vazia():
        item = fila.desenfileirar()
        if num(item):
            save = int(item)
            if fila.vazia():
                novafila.enfileirar(save)
                return novafila
            if fila.primeiro() != '.':
                novafila.enfileirar(save)
        elif item == '.':
            item = fila.desenfileirar()
            save = float(save)
            save += (float(item)) / (10 ** (len(item)))
            novafila.enfileirar(save)
        else:
            novafila.enfileirar(item)
    return novafila

# 需要导入模块: from aula5.fila import Fila [as 别名]
# 或者: from aula5.fila.Fila import enfileirar [as 别名]
def analise_sintatica(fila): #PRONTO PORÉM GRANDE
    """
    Função que realiza analise sintática de tokens produzidos por analise léxica.
    Executa validações sintáticas e se não houver erro retorn fila_sintatica para avaliacao
    :param fila: fila proveniente de análise lexica
    :return: fila_sintatica com elementos tokens de numeros
    """
    fila2 = Fila()
    car=''
    if (len(fila) == 0):
        raise ErroSintatico('erro')
    while (len(fila)!=0):
        c = fila.desenfileirar()
        if c in ('+-*/(){}[]'):
            if len(car)!=0:
                if '.' in car:
                    fila2.enfileirar(float(car))
                    car = ''
                else:
                    fila2.enfileirar(int(car))
                    car = ''
            fila2.enfileirar(c)
        else:
            car = car + c
    if len(car)>0:
        if '.' in car:
            car = float(car)
        else:
            car = int(car)
        fila2.enfileirar(car)

    return fila2

# 需要导入模块: from aula5.fila import Fila [as 别名]
# 或者: from aula5.fila.Fila import enfileirar [as 别名]
def analise_lexica(expressao):
    fila=Fila()
    num=""
    if len(expressao):
        for t in expressao:
            if t in set("0123456789"):
                num=num+t
            else:
                if len(num)>0:
                    fila.enfileirar(num)
                    num=""
                if t in set("{}[]()/+-*."):
                    fila.enfileirar(t)
                else:
                    raise ErroLexico("Erro Léxico")
                
        if not len(num)==0:
            fila.enfileirar(num)
    return fila

        
            
        
    """
    Executa análise lexica transformando a expressao em fila de objetos:
    Transforma inteiros em ints
    Flutuantes em floats
    e verificar se demais caracteres são validos: +-*/(){}[]
    :param expressao: string com expressao a ser analisada
    :return: fila com tokens
    """
    pass

# 需要导入模块: from aula5.fila import Fila [as 别名]
# 或者: from aula5.fila.Fila import enfileirar [as 别名]
def analise_lexica(expressao): #PRONTO PORÉM FEIO
    """
    Executa análise lexica transformando a expressao em fila de objetos:
    Transforma inteiros em ints
    Flutuantes em floats
    e verificar se demais caracteres são validos: +-*/(){}[]
    :param expressao: string com expressao a ser analisada
    :return: fila com tokens
    """

    car = ''
    fila = Fila()
    if len(expressao):
        for c in expressao:
            if c in ('1234567890'):
                car = car+c
            elif c in ("+-*/(){}[]."):
                if len(car)!=0:
                    fila.enfileirar(car)
                    car = ''
                fila.enfileirar(c)
            else:
                raise ErroLexico('erro')
        if len(car)>0:
            fila.enfileirar(car)


    return fila

# 需要导入模块: from aula5.fila import Fila [as 别名]
# 或者: from aula5.fila.Fila import enfileirar [as 别名]
def analise_sintatica(fila):

    tokens = Fila ()
    numValor = 0
    point = False
    if len(fila) > 0:
        for elemento in fila:
            if elemento in set('{[()]}+-*/'):
                if not numValor == 0:
                    tokens.enfileirar(numValor)
                numValor = 0
                tokens.enfileirar(elemento)
                point = False
            else:
                if elemento == '.':
                    point = True
                else:
                    valor = float(elemento)
                    if point:
                        numValor += (valor / 10 ** len (elemento))
                    else:
                        numValor += valor
        if not numValor == 0:
            tokens.enfileirar(numValor)
        return tokens
    else:
         raise ErroSintatico ('')

# 需要导入模块: from aula5.fila import Fila [as 别名]
# 或者: from aula5.fila.Fila import enfileirar [as 别名]
def analise_lexica(expressao):
    fila = Fila()
    char = ""
    if len(expressao):
        for k in expressao:
            if k in ("1234567890"):
                char = char + k
            elif k in ("()[]{}-+*/."):
                if len(char) != 0:
                    fila.enfileirar(char)
                    char = ""
                fila.enfileirar(k)
            else:
                raise ErroLexico("Erro")
        if len(char) > 0:
            fila.enfileirar(char)
    return fila

    """
    Executa análise lexica transformando a expressao em fila de objetos:
    Transforma inteiros em ints
    Flutuantes em floats
    e verificar se demais caracteres são validos: +-*/(){}[]
    :param expressao: string com expressao a ser analisada
    :return: fila com tokens
    """
    pass

# 需要导入模块: from aula5.fila import Fila [as 别名]
# 或者: from aula5.fila.Fila import enfileirar [as 别名]
def analise_sintatica(fila):
    """
    Função que realiza analise sintática de tokens produzidos por analise léxica.
    Executa validações sintáticas e se não houver erro retorn fila_sintatica para avaliacao

    :param fila: fila proveniente de análise lexica
    :return: fila_sintatica com elementos tokens de numeros
    """

    if fila.__len__():

        # Cria um novo objeto fila para adicionar os valores
        fila_sintetica = Fila()

        # Variavel de apoio para juntar a string
        valor = ""

        for i in range(fila.__len__()):

            if fila._deque[i] in "-+/*(){}[]":
                if valor:
                    if "." in valor:
                        fila_sintetica.enfileirar(float(valor))
                    else:
                        fila_sintetica.enfileirar(int(valor))

                valor = ""
                fila_sintetica.enfileirar(fila._deque[i])
            else:
                valor = valor + fila._deque[i]

        if valor:
            if "." in valor:
                fila_sintetica.enfileirar(float(valor))
            else:
                fila_sintetica.enfileirar(int(valor))

        return fila_sintetica
    else:
        raise ErroSintatico

# 需要导入模块: from aula5.fila import Fila [as 别名]
# 或者: from aula5.fila.Fila import enfileirar [as 别名]
def analise_lexica(expressao):
    def caracteres(param1):
        return param1 in "(){.}[]+-*/"

    fila=Fila()
    count=0
    pilha=Pilha()
    while count!=len(expressao):
        if not(caracteres(expressao[count]) or num(expressao[count])):
            raise ErroLexico
        else:
            if caracteres(expressao[count]):
                if not pilha.vazia():
                    fila.enfileirar(pilha.desempilhar())
                fila.enfileirar(expressao[count])
            if num(expressao[count]):
                if pilha.vazia():
                    pilha.empilhar(expressao[count])
                else:
                    final=pilha.desempilhar()
                    pilha.empilhar(final+expressao[count])
        count+=1
    if not pilha.vazia():
        fila.enfileirar(pilha.desempilhar())
    return fila

# 需要导入模块: from aula5.fila import Fila [as 别名]
# 或者: from aula5.fila.Fila import enfileirar [as 别名]
def analise_lexica(expressao):
    """
    Executa análise lexica transformando a expressao em fila de objetos:
    Transforma inteiros em ints
    Flutuantes em floats
    e verificar se demais caracteres são validos: +-*/(){}[]
    :param expressao: string com expressao a ser analisada
    :return: fila com tokens
    """
    fila = Fila()

    # numeros e tokens
    nt = r"0123456789.-+*/{}[]()"

    if expressao:

        valor = ""

        for i in expressao:
            if i in nt:
                if i in ".-+*/{}[]()":
                    if valor:
                        fila.enfileirar(valor)
                        valor = ""
                    fila.enfileirar(i)
                else:
                    valor = valor + i
            else:
                raise ErroLexico()

        if valor:
            fila.enfileirar(valor)

    return fila

# 需要导入模块: from aula5.fila import Fila [as 别名]
# 或者: from aula5.fila.Fila import enfileirar [as 别名]
def analise_lexica(expressao):
    """
    Executa análise lexica transformando a expressao em fila de objetos:
    Transforma inteiros em ints
    Flutuantes em floats
    e verificar se demais caracteres são validos: +-*/(){}[]
    :param expressao: string com expressao a ser analisada
    :return: fila com tokens
    """

    def caracteres(param1):
        return param1 in "(){.}[]+-*/"

    fila = Fila()
    count = 0
    pilha = Pilha()
    while count != len(expressao):
        if not (caracteres(expressao[count]) or num(expressao[count])):
            raise ErroLexico
        else:
            if caracteres(expressao[count]):
                if not pilha.vazia():
                    fila.enfileirar(pilha.desempilhar())
                fila.enfileirar(expressao[count])
            if num(expressao[count]):
                if pilha.vazia():
                    pilha.empilhar(expressao[count])
                else:
                    final = pilha.desempilhar()
                    pilha.empilhar(final + expressao[count])
        count += 1
    if not pilha.vazia():
        fila.enfileirar(pilha.desempilhar())
    return fila