.. highlight:: python
:linenothreshold: 5
==================================================
Capítulo 3: Do console para o editor de programas
==================================================
Depois de dois capítulos bem básicos, é hora de engatar uma segunda e começar a criar programas mais dignos desse nome. Não vamos desprezar o que fizemos até aqui, digitando diretamente na deixa do interpretador Python. Ao contrário: tenha sempre em mente que você pode usá-lo para esclarecer aquela dúvida rápida ou mesmo localizar um bug escondido em um sistema complexo. A maioria das outras linguagens não oferece um ambiente para execução imediata de comandos como o Python. Uma exceção famosa é a linguagem Logo, onde o interpretador interativo serve justamente para facilitar a aprendizagem da programação através da exploração e experimentos.
Mas a partir de agora vamos atacar programas mais extensos, e não vamos querer digitá-los linha por linha no modo interativo. Em vez disso, vamos escrever os comandos em um editor de textos, salvar o arquivo, e mandar o interpretador Python ler o programa salvo.
Rodando programas no IDLE
==========================
A versão Windows do Python traz o IDLE, um interpretador interativo em modo gráfico que já apresentamos no primeiro capítulo. Se você não usa essa versão do Python, vá direto para a próxima seção: Testando no sistema. O IDLE inclui um editor de programas simplório, mas útil para quem está aprendendo a linguagem. O editor do IDLE exibe com cores diferentes as palavras da linguagem, de acordo com sua função sintática (lembra da aula de português onde o verbo era verde, o sujeito vermelho etc?). Para abrir o editor, rode o IDLE e acione o comando ``File > New window``. A janela que se abrirá, com o título ``untitled``, é um editor. Experimente digitar um programinha como esse::
for i in range(100):
print 'Fulano ',
print 'e seus Sicranos'
Note que o editor pinta algumas palavras de laranja. São as chamadas palavras-chave, peças tão importantes em Python como os verbos em português. Outras cores indicaom funções e variáveis. E os textos entre aspas aparecem em verde: dessa forma, fica difícil esquecer de fechar aspas. Outra coisa que acontece magicamente é a endentação. O editor "sabe" que após os ":" do comando for, deve vir um bloco endentado. Para encerrar o bloco endentado, você pode teclar ``[ENTER]`` duas vezes para pular uma linha, como ocorre também na deixa do interpretador, ou então teclar ``[BackSpace]`` para apagar de uma vez só os quatro espaços à esquerda da linha.
Uma vez digitado esse programinha você pode executá-lo de duas maneiras: diretamente de dentro do IDLE ou no console do sistema operacional. Para fazer o IDLE rodar o seu programa é só teclar ``[F5]``. Se você ainda não salvou o código do seu programa, o IDLE vai exibir uma mensagem pedindo para que você o faça. Basta usar o comando File > Save, ou melhor ainda, ``[CTRL]+[S]``. Se você não sabe onde salvar, sugiro que crie uma pasta chamada Curso dentro da pasta onde está o seu interpretador Python e salve ali (provavelmente a pasta ficará sendo ``C:\Python25\Curso``, no caso do Python 2.5). Assim fica fácil encontrá-lo depois. Use o nome ``egotrip.py``.
O programinha ``egotrip.py`` faz o nome do autor aparecer 100 vezes, seguinda do nome de sua banda. No tempo dos computadores de 8 bits, programinhas como esse eram invariavelmente os primeiros exercícios de qualquer estudante de programação. No IDLE, a "saída" do programa (aquilo que ele exibe ao rodar), aparece dentro de uma janela intitulada ``Python Shell``. Você pode fechar essa janela quando o programa parar.
Você talvez tenha notado que o programa é meio lento. Em meu velho ''notebook'' Pentium 133 o programa levava 10 segundos para escrever as 101 linhas. É muito. Mas a culpa não é do Python, e sim do IDLE, como veremos a seguir.
Navegando pela linha de comando
================================
No Linux a linha de comando está em toda parte, mas no Windows fica um pouco escondida. Para encontrá-la, clique na barra de tarefas do Windows XP em ``Iniciar > Executar...``. Na janelinha que se abre, digite apenas ``cmd``. Isso executa o interpretador de comandos do Windows, equivalente ao velho MS-DOS nos Windows mais antigos. Para quem nunca navegou pelo sistema via prompt, eis aqui o mínimo que você precisa saber. Veja o que aparece na janela do Prompt:
À esquerda do cursor, você tem a informação mais importante para se orientar: a letra do drive e o nome da pasta onde você se encontra. Se o seu Windows está com a configuração de fábrica, você estará em ``C:\Windows``. O sinal > é apenas a deixa do sistema, equivalente ao ``>>>`` usado pelo Python para indicar que está pronto para receber um comando. Antes de mais nada, vamos acionar um programinha que nos poupará muita digitação posteriormente.
Agora, vamos ver o que existe na pasta onde estamos (a pasta Windows). Digite::
C:\Windows>dir [ENTER]
Você verá uma longa listagem de arquivos, com seus nomes abreviados, extensões, tamanhos, datas e nomes longos. Em meu ''notebook'' aparecem 236 arquivos na pasta Windows. Não estamos interessados neles agora, o objetivo era apenas mostrar que o comando dir produz uma listagem dos arquivos da pasta, ou diretório, atual.
Agora vamos navegar até o diretório onde foi gravado o programa ``egotrip.py``. Digite::
C:\Windows>cd \ [ENTER]
Agora você está no chamado diretório raiz do seu disco. Digite ``dir`` e veja como a maioria dos itens dentro dessa pasta são outras pastas, como a própria pasta Windows. Agora vamos entrar na pasta do Python::
C:\>cd pythonXX [ENTER]
E, em seguida, na pasta Curso, que você deve ter criado quando salvou o arquivo ``egotrip.py``.
::
C:\PythonXX>cd curso
C:\PythonXX\Curso>dir
Você deverá ver uma listagem como essa::
O volume da unidade C é XXX
O número de série do volume é XXXX-XXXX
Pasta de C:\PythonXX\Curso
.
25/10/99 20:57 .
.. 25/10/99 20:57 ..
EGOTRIP PY 89 25/10/99 20:32 egotrip.py
1 arquivo(s) 89 bytes
2 pasta(s) 21.331.968 bytes disponíveis
C:\PythonXX\Curso>
Agora você está no ponto certo para digitar o comando que causará a execução do seu programa ``egotrip.py``.
Testando no sistema
====================
Meu ambiente favorito para rodar programas em Python é a própria linha de comando do sistema operacional. Não costumo usar o editor do IDLE, mas sim o NotePad++, um excelente editor de textos livre e gratuito para Windows. Seja qual for o editor que você usa, o importante é salvar o arquivo como texto puro, sem marcas de formatação. O Notepad é melhor que Word para esse fim, mas o NotePad++ é muito melhor. No Linux, Gedit, Kate, Pico, Vi e Emacs são alguns editores de texto puro bastante comuns. Entre esses, prefiro Gedit e Kate, que têm interfaces mais modernas. Uma vez digitado e salvo o arquivo, você precisa executá-lo a partir da linha de comando do seu sistema.
Quem usa Linux ou já está habituado ao DOS, pode seguir até a próxima seção, ASCII art.
ASCII art
==========
No Windows, para executar o programa, digite esse encantamento (supondo que você fez tudo conforme descrito na seção acima, ou fez tudo diferente mas sabia o que estava fazendo)::
C:\PythonXX\Curso>..\python egotrip.py
Os sinais ``..\`` na frente do comando python servem para dizer ao DOS para executar um programa que está no diretório anterior no caminho atual. Assim, acionamos o programa ``python.exe`` que está na pasta ``C:\PythonXX``.
No Linux, você precisará chegar até o diretório que contém o exemplo, e digitar::
$ python egotrip.py
Ou, se isso não funcionar, tente algo como segue (o comando exato vai depender da sua instalação)::
$ /usr/local/bin/python egotrip.py
$ /usr/bin/python egtrip.py
Bom, deu trabalho mas chegamos. E como você deve ter notado, a execução do programinha foi bem mais veloz que no IDLE (em meu computador, menos de 1 segundo, em vez de 10).
Agora vamos fazer uma pequena mudança no programa egotrip que terá um grande efeito. Para fazer essa alteração, no Windows o modo mais rápido é segurar a tecla ``[ALT]`` e pressionar ``[TAB]`` até que o ícone do editor do IDLE identificado pelo nome do arquivo ``egotrip.py`` esteja selecionado. Então solte a tecla ``[ALT]``, que o editor aparecerá sobrepondo-se às demais janelas. Agora vamos modificar o programa egotrip. Ao final da segunda linha, digite uma vírgula. O seu programa deverá ficar assim::
for i in range(100):
print 'Luciano ',
print 'e seus Camargos'
Salve com ``[CTRL]+[S]`` e rode o programa novamente. Tecle ``[F5]`` para rodar no IDLE, ou siga esses passos para testar no DOS:
* ``[ALT]+[TAB]`` até voltar ao ''prompt'' do DOS
* ``[`` |uparrow| ``]`` (seta para cima) para repetir o comando ``..\python egotrip.py``
* ``[ENTER]`` para executar o comando.
.. |uparrow| image:: _static/uparrow.png
10 entre 10 programadores que usam a plataforma Windows têm muita prática com a sequência ``[ALT]+[TAB]``, ``[`` |uparrow| ``]``, ``[ENTER]``. Logo, logo, em sua primeira sessão de caça a um bug, você terá oportunidade de praticar bastante.
Nesse caso, é interessante testar o programa tanto no IDLE quanto na linha de comando. Você verá que os resultados são bem diferentes. Experimente e tente explicar porquê.
Como exercício final, substitua o argumento 100 da função range pelo número 1000, e rode o programa novamente (não recomendo usar o ``[F5]`` do IDLE dessa vez; será bem demorado). Tente acrescentar ou retirar letras dos nomes. O efeito será diferente. Bem vindo ao mundo da expressão artística com caracteres de computador.
Seu primeiro programa interativo
=================================
Até agora, todos os programas que mostramos não são interativos, ou seja, uma vez rodando, eles não aceitam a entrada de dados de um usuário ou do sistema. Programas não interativos são usados em muitas situações comuns. O programa que emite os cheques da folha de pagamentos de uma grande empresa provavelmente não é interativo, mas recebe todos os dados necessários em um único lote, antes de sua execução. Mas os programas mais interessantes, como um processador de textos, um ''game'' ou o piloto automático de um avião são todos interativos. Esse é o tipo de programa que passaremos a desenvolver agora.
Nosso passeio pela ASCII art não teve apenas objetivos estéticos. Quisemos mostrar como rodar um programa em Python a partir da linha de comando porque, a partir de agora, vamos usar um comando da linguagem Python que não funciona na atual versão do IDLE. O comando chama-se ``raw_input``, e sua função é receber uma entrada de dados do usuário (input quer dizer entrada de dados; cuidado porque você deve ter sido condicionado a acreditar que "antes de P e B sempre vem a letra M", mas input é inglês, e se escreve com N mesmo; eu perdi uma hora com isso quando aprendia BASIC).
Vejamos um primeiro exemplo. Observe que não estamos acentuando o texto no programa porque o DOS não reproduz corretamente os acentos do Windows, e precisamos do DOS para testar esse programa. Deve haver uma forma de convencer o DOS a exibir os acentos corretos do Windows, mas ainda não descobrimos como.
De qualquer forma, isso não quer dizer que não dá para fazer programas com acentuação correta em Python; quando aprendermos a criar softwares gráficos esse problema desaparecerá.
Digite o programinha abaixo, salve como ``despdom1.py`` e execute na linha de comando.
.. todo:: Mostrar como usar encoding para fazer mensagens acentuadas
.. literalinclude:: codigo/despdom1.py
Os números que aparecem à esquerda na listagem acima não fazem parte do programa e não devem ser digitados. Eles estão aí para facilitar a explicação que vem logo a seguir.
Antes de esmiuçar o programa, vale a pena executá-lo para ver o que acontece. Você será solicitado a digitar um valor para Ana e outro para Bia. Note que os valores deverão ser apenas números. Se quiser usar centavos, use o ponto decimal em vez de vírgula, como já vínhamos fazendo antes. E nada de $ ou R$. Vejamos um exemplo de execução::
C:\PythonXX\Curso>..\python despdom1.py
Balanco de despesas domesticas
Quanto gastou Ana? 10
Quanto gastou Bia? 20
Total de gastos = 30.0
Gastos por pessoa = 15.0
C:\PythonXX\Curso>
Dissecando o código
====================
Agora vamos acompanhar, linha por linha, como o interpretador executou o programa. Essa é a atividade mais importante para desenvolver você como programador ou programadora. Você precisa aprender a ler um programa e simular mentalmente que acontece dentro do computador. "Quando você aprender a se colocar no lugar do computador ao ler um programa, estará pronto, Gafanhoto".
Linha 1
O sinal # indica comentário. Tudo o que aparece em uma linha a partir desse sinal é ignorado pelo interpretador Python. Neste caso, o comentário explica para nós, humanos, o propósito do programa. Note que o comentário não aparece para o usuário final quando o programa é executado. Comentários servem apenas para ser lidos por outros programadores.
Linha 3
O velho comando ``print`` é usado para escrever o título "Balanco de despesas domesticas" na tela do usuário.
Linha 4
O comando ``raw_input`` exibe a pergunta "Quanto gastou Ana?", aguarda uma resposta e armazena na varíavel ana.
Linha 5
O mesmo comando é usado para guardar os gastos de Bia na variável bia.
Linha 6
Aqui é calculado o total. Note o uso da função ''float''. Acontece que a função ``raw_input`` não retorna números, e sim ''strings''. Como vimos no capítulo anterior, o operador "+" tem efeitos diferentes quando aplicado a ''strings''; em vez de somar, ele concatena ou junta os textos. Nesse caso, se ``ana`` é ``'10'`` e ``bia`` é ``'20'``, ``ana + bia`` seria ``'1020'``. Para realizar a soma, precisamos antes transformar as ''strings'' em números, o que é feito pelas funções ``float`` ou ``int``. Nesse caso, usamos ``float`` porque não vamos nos limitar a aceitar números inteiros.
Linha 7
O total é exibido, com o auxílio do operador % que insere o valor na posição assinalada pelos caracteres %s dentro da mensagem. O código %s faz com que Python transforme o número em ''string''.
Linha 8
Cálculo da média. Como ambos os valores são float, o resultado será preciso (se fossem inteiros, o resultado também seria forçado a ser inteiro, o que nesse caso levaria a erros do tipo).
Linha 9
Mostramos a média, usando a mesma técnica da linha 7.
Experimente rodar o programa algumas vezes. Note que não é um programa muito robusto: se você não digitar coisa alguma e teclar [ENTER] após uma das perguntas, ou responder com letras em vez de números, o programa "quebra". No próximo capítulo aprenderemos a lidar com entradas inesperadas.
Um programa mais esperto
=========================
O programa acima é quase útil. Ele calcula a despesa total e a média, mas não responde à pergunta fundamental: quanto Ana tem que pagar a Bia, ou vice-versa? A aritmética envolvida é simples: se Ana gastou menos, ela precisa pagar a Bia um valor igual à diferença entre o que gastou e a média. Gostaríamos que nosso programa funcionasse assim::
Balanco de despesas domesticas
Quanto gastou Ana? 10
Quanto gastou Bia? 20
Total de gastos: R$ 30.0
Gastos por pessoa: R$ 15.0
Ana deve pagar: R$ 5.0
Utilize o comando ``File > Save As...`` para salvar o programa ``despdom1.py`` como ``despdom2.py``. Agora vamos modificá-lo para fazer o que queremos. Abaixo, o programa final, e a seguir, a explicação de cada mudança que foi feita.
.. literalinclude:: codigo/despdom2.py
O que mudou:
Linha 1
Acrescentamos "versao 2" ao comentário
Linhas 4 e 5
Aqui fazemos a conversão dos resultados de raw_input para float imediatamente, de modo que os valores armazenados na variáveis ana e bia são números, e não ''strings'' como antes.
Linha 6
Uma mudança cosmética apenas: acrescentamos uma linha com apenas um print, para deixar na tela uma linha em branco entre as perguntas e os resultados.
Linhas 7
Agora podemos simplesmente somar os valores de ana e bia, que já foram convertidos para float nas linhas 4 e 5.
Linhas 8 a 10
Exibimos o total e processamos a média, como antes.
Linha 11
Apresentamos um novo comando de bloco, o comando ``if``, que pode ser traduzido exatamente como "se". Essa linha diz, literalmente: "se ana < media:". Ou seja, se o valor de Ana for menor que o valor da média, execute o bloco endentado a seguir (linhas 12 e 13). Caso contrário, não execute essas linhas, e passe direto para a linha 14.
Linhas 12 e 13
Calculamos e exibimos quanto Ana deve pagar.
Linha 14
Aqui vemos outro comando de bloco, o ``else``, que pode ser traduzido como "senão". O ``else`` só pode existir após um bloco iniciado por ``if``. O bloco que segue o ``else`` só é executado quando a condição prevista no ``if`` não ocorre. Isso significa que, quando temos um bloco ``if`` e um bloco ``else``, é garantido que apenas um dos dois será executado. Nesse caso, as linhas 15 e 16 só serão executadas se o valor de ``ana`` não for menor que a média.
Linhas 15 e 16
Calculamos e exibimos quanto Bia deve pagar.
Experimente um pouco com o programa ``despdom2.py``. O que acontece quando os gastos de Ana e Bia são iguais? Tente responder essa pergunta sem rodar o programa. A chave está na linha 11. Qual é a média quando os gastos são iguais? Tente simular mentalmente o comportamento do computador na execução passo a passo do programa. Dedique alguns minutos a esse desafio, e só então rode o programa com valores iguais para ver se acontece o que você imaginou.
Tudo sobre o ``if``
===================
O comando ``if``, que acabamos de conhecer através de um exemplo, é uma peça fundamental da linguagem Python, e de quase todas as linguagens de programação existentes. Sua função é descrita como "comando de execução condicional de bloco", ou seja, é um comando que determina a execução ou não de um bloco de comandos, de acordo com uma condição lógica. No exemplo, a condição lógica é ``ana < media``. O operador < serve para comparar dois números e determinar se o primeiro é menor que o segundo (ele também funciona com ''strings'', mas aí a comparação segue uma regra parecida com a ordem usada dos dicionários). Os operadores de comparação de Python são os mesmos usados em Java e C++:
======== ================ ==========
Operador Descrição Exemplo
======== ================ ==========
== igual a ``a == b``
!= diferente de ``a != b``
< menor que ``a < b``
> maior que ``a > b``
>= maior ou igual a ``a >= b``
<= menor ou igual a ``a <= b``
======== ================ ==========
Para sentir o funcionamento desses operadores, abra o interpretador interativo do Python e digite esses testes (não vamos mostrar os resultados aqui; faça você mesmo).
.. highlight:: python
:linenothreshold: 500
::
>>> a = 1
>>> b = 2
>>> a == 1
>>> a == 2
>>> a == b
>>> 2 == b
>>> a != b
>>> a != 1
>>> a < b
>>> a >= b
As linhas 1 e 2 não produzem nenhum resultado, como já vimos antes. Elas apenas atribuem valor às variáveis a e b. A linha 3 parece um pouco com a linha 1, mas significa algo completamente diferente. Aqui não acontece nenhuma atribuição, apenas uma comparação, que vai gerar um resultado. Um erro bastante comum cometido por quem está aprendendo Python, C ou Java é usar = no lugar de == ao fazer uma comparação (em Basic, por exemplo, o = é usado nos dois casos). Após cada as linhas a partir da linha 3, o interpretador mostrará um número 1 ou 0, para indicar que a comparação é verdadeira (1) ou falsa (0).
Voltando ao comando ``if``, não existe nenhuma lei que obrigue a presença de um operador de comparação na condição do ``if``. A única coisa que interessa é que a expressão que estiver no lugar da condição será considerada falsa se for igual a 0 (zero), uma ''string'' vazia, uma lista vazia ou o valor especial ``None``, sobre o qual voltaremos a falar depois. Qualquer valor que não seja um desses será considerado "verdadeiro", e provocará a execução do bloco subordinado ao ``if``. É por isso que os operadores de comparação retornam 0 ou 1 para representar falso ou verdadeiro.
Não é obrigatória a presença de um bloco ``else`` após um ``if``. Mas um ``else`` só pode existir após um ``if``. E um ``if`` pode conter, no máximo, um ``else``. Existe um terceiro comando de bloco relacionado a esses, chamado ``elif``. Ele corresponde à combinação ``else-if`` existente em outras linguagens. Assim como o ``if``, cada ``elif`` deve ser acompanhado de uma condição que determinará a execução do bloco subordinado. Como todo comando de bloco, a primeira linha do ``elif`` deve ser terminada por um sinal de ``:``.
Um ``if`` pode ser seguido de qualquer quantidade de blocos ``elif``, e se houver um bloco ``else`` ele deverá vir depois de todos os ``elif``. Veja esse fragmento de código, parte de um jogo simples que criaremos no próximo capítulo::
if vf == 0:
print 'Alunissagem perfeita!'
elif vf <= 2:
print 'Alunissagem dentro do padrao.'
elif vf <= 10:
print 'Alunissagem com avarias leves.'
elif vf <= 20:
print 'Alunissagem com avarias severas.'
else:
print 'Modulo lunar destruido no impacto.'
Numa sequencia de ``if/elif/elif/.../else`` é garantido que um, e apenas um dos blocos será executado. Fica como desafio para o leitor descobrir como usar o comando elif para corrigir o bug dos gastos iguais, que aparece no programa ``despdom2.py``.