Arquivos que você deve utilizar
...............................

Você deve baixar e utilizar os seguintes arquivos:

    . `main.py <main.py>`__,

    . `operadores.py <operadores.py>`__,

    . `tokeniza.py <tokeniza.py>`__,

    . `pilha.py <pilha.py>`__, e o

    . `esqueleto_calculadora.py <esqueleto_calculadora.py>`__.

O módulo ``main.py`` contém a função ``main()`` que é a função principal desse
EP (= função que coordena o programa).  A função ``main()`` está completamente
escrita.  Nada do módulo ``main.py`` deve ser alterado.

O módulo ``operadores.py`` contém um dicionário com uma descrição dos
operadores aritméticos e parênteses e um dicionário ``PREC`` com a precedência
dos operadores.
O dicionário ``PREC`` pode ser útil na função ``infixa_para_posfixa()``.
Esse módulo é utilizado apenas pelo
módulo ``calculadora.py``.
Nada do módulo ``operadores.py`` deve ser alterado. 

O módulo ``tokeniza.py`` contém as funções ``tokeniza()``,
``tokens_para_str()`` e ``imprima_tokens()``, além da definição da classe
``Token``. Todas essas funções e classes estão completamente escritas.
Nada do módulo ``tokeniza.py`` deve ser alterado.

O módulo ``pilha.py`` contém a implementação de uma classe ``Pilha``.
Os métodos dessa classe são ``__init()__``, ``__str()__``, ``__len__()``,
``vazia()``, ``empilha()``, ``desempilha()`` e ``topo()``.
Todos esses métodos estão complemente  escritos.
Nada do módulo ``pilha.py`` deve ser alterado.

Após baixar o modulo ``esqueleto_calculadora.py``, altere o nome desse arquivo
para ``calculadora.py``.
Em seguida, copie a implementação da sua classe ``Calculadora`` feita no EP9
para o módulo ``calculadora.py`

Você deverá fazer pequenas alterações na sua classe ``Calculadora``,
possivelmente, apenas no método ``eval()``.

.. sourcecode:: python
                
    def eval(self, exp = ''):
        ''' (str) -> float ou None

        Recebe um string representado uma expressão em
        NOTAÇÃO INFIXA e retorna o valor da expressão.

        Se algum erro for detectado na expressão a função 
        retorna None.
        '''
    
Além disso, o esqueleto contem a única função que
você deve implementar neste EP9:

.. sourcecode:: python

    def infixa_para_posfixa(infixa):
        '''(list de Tokens) -> list de Tokens

        Recebe uma lista infixa de Tokens representando uma 
        expressão em notação infixa e retorna uma lista de 
        tokens representando uma expressão equivalente 
        na notação posfixa.

        Essa função utiliza uma pilha que contém apenas
        operadores e abre parênteses. Veja as notas de aula.

        Pode ser útil utilizar nessa função o dicionário PREC do
        modulo operadores.py. Nesse dicionário as chaves são os
        operadores (str) e os valores (int) representam a
        precedência dos operadores: quanto maior o valor, maior
        a precedência. 

        Exemplos:
        >>>
        >>> tokens = tokeniza("a = 2 * 31.4")
        >>> imprima_tokens(tokens)
        [V('a'), O('='), N(2), O('*'), N(31.4)]
        >>> posfixa = infixa_para_posfixa(tokens)
        >>> imprima_tokens(posfixa)
        [V('a'), N(2), N(31.4), O('*'), O('=')]
        >>>
        >>> tokens = tokeniza("2+3+4")
        >>> imprima_tokens(tokens)
        [N(2), O('+'), N(3), O('+'), N(4)]
        >>> posfixa = infixa_para_posfixa(tokens)
        >>> imprima_tokens(posfixa)
        [N(2), N(3), O('+'), N(4), O('+')]
        >>>
        >>> tokens = tokeniza("2^3^4")
        >>> imprima_tokens(tokens)
        [N(2), O('^'), N(3), O('^'), N(4)]
        >>> posfixa = infixa_para_posfixa(tokens)
        >>> imprima_tokens(posfixa)
        [N(2), N(3), N(4), O('^'), O('^')]
        >>> 
        >>> tokens = tokeniza("(2+3)*4")
        >>> imprima_tokens(tokens)
        [P('('), N(2), O('+'), N(3), P(')'), O('*'), N(4)]
        >>> posfixa = infixa_para_posfixa(tokens)
        >>> imprima_tokens(posfixa)
        [N(2), N(3), O('+'), N(4), O('*')]
        >>> 
        >>> tokens = tokeniza("22+33*4.4")
        >>> imprima_tokens(tokens)
        [N(22), O('+'), N(33), O('*'), N(4.4)]
        >>> posfixa = infixa_para_posfixa(tokens)
        >>> imprima_tokens(posfixa)
        [N(22), N(33), N(4.4), O('*'), O('+')]
        >>>
        '''
                        
                
Você deve entregar **apenas** o módulo ``calculadora.py``.