Baixe Introdução à Programação Python: Algumas Dicas e Exemplos e outras Notas de estudo em PDF para Programação em Windows, somente na Docsity!
Aprenda a Programar
Release 1.
Luciano Ramalho
August 11, 2011
Contents
1 Para ler na tela ii
1.1 Capítulo 0: Porque aprender a programar?................................ ii
Material necessário............................................ ii
Porquê Python............................................... iii
1.2 Capítulo 1: Abrindo e fechando o console................................ iii
Uma calculadora melhor......................................... iv
Conversor de dólares........................................... vi
Tabela de preços em dólares e reais.................................... vii
1.3 Capítulo 2: Criando uma tabela...................................... ix
Quatro tipos de dados........................................... ix
Enfeitando a tabela............................................ xi
Entendendo melhor o for......................................... xiii
A outra face do %............................................. xiv
1.4 Capítulo 3: Do console para o editor de programas........................... xv
Rodando programas no IDLE....................................... xv
Navegando pela linha de comando.................................... xvi
Testando no sistema............................................ xvi
ASCII art................................................. xvii
Seu primeiro programa interativo..................................... xvii
Dissecando o código........................................... xviii
Um programa mais esperto........................................ xix
Tudo sobre o if.............................................. xx
1.5 Capítulo 4: Orçamentos, pousos lunares e tratamento de erros...................... xxii
Somadora infinita............................................. xxii
Mais sobre o while............................................ xxiii
Loops (quase) infinitos.......................................... xxiv
Um programa mais tolerante....................................... xxv
Como tratar um erro de verdade..................................... xxvi
Associação de nomes a valores...................................... xxvii
Resolvendo o Orçamento da República.................................. xxviii
Nossa primeira simulação......................................... xxx
1.6 Capítulo 5: O segredo dos objetos-função................................ xxxii
Dividir para conquistar.......................................... xxxii
Programação estruturada......................................... xxxii
Funções como objetos........................................... xxxiii
Argumentos default............................................ xxxv
Usando módulos............................................. xxxv
1.7 Capítulo 6: Perca o medo do servidor Apache e do protocolo CGI................... xxxix
Páginas dinâmicas............................................. xl
Configurando o seu HTTPd........................................ xl
Seu primeiro CGI............................................. xli
Instalar e testar o CGI........................................... xli
Afinal, um CGI dinâmico......................................... xliii
Um relógio que se atualiza........................................ xliv
Calendário Dinâmico........................................... xlv
Protótipo melhorado........................................... xlvii
Próximas paradas............................................. xlix
2 Pendências xlix
3 Indices and tables xlix
Downloads
PDF: http://ramalho.pro.br/aprendaprog/aprendaprog.pdf
EPUB: http://ramalho.pro.br/aprendaprog/aprendaprog.pdf
1 Para ler na tela
1.1 Capítulo 0: Porque aprender a programar?
A razão fundamental, que nos motivou a produzir este tutorial, é uma só: programar é divertido. É claro que nem
todo mundo vai concordar com isso, assim como muita gente não acha graça nenhuma em jogar xadrez ou explorar
cavernas. Ao contrário do xadrez e da espeleologia, a programação também é uma habilidade que tem forte demanda
no mercado de trabalho.
Mas a dura realidade é que somente com centenas ou milhares de horas de experiência programando é que você estará
apto a incluir essa disciplina em seu currículo e se dar bem em uma entrevista de emprego. Portanto nosso objetivo
aqui é bem mais modesto do que transformar você em um programador profissional. O que estamos te oferecendo é
uma introdução suave a esse tópico fascinante. Ao final, esperamos que você descubra se tem a vocação e a motivação
necessárias para criar softwares, como hobby ou profissão.
Antes de começar, apenas um aviso: o prazer de construir um programa pode causar dependência psicológica. Não é
apenas por dinheiro que programadores do mundo inteiro varam noites escrevendo código.
Material necessário
Para acompanhar esse tutorial você precisará de um computador qualquer onde tenha instalado um interpretador da
linguagem Python. Em quase todas as versões modernas de Linux e Mac OS X o interpretador Python já vem instalado
(experimente abrir um console e digitar “python”). Na página http://www.python.org/download/ você encontra links
para baixar o interpretador adequado para o seu computador. No caso do Windows, o instalador .msi da versão atual
do Python tem cerca de 11 MB. OBS. Este tutorial foi escrito em 1998.
Todo
2. usar o IDLE, que é um ambiente baseado em janelas.
Se você usa Windows, escolha o IDLE para começar a acompanhar esse tutorial. O IDLE também está disponível para
a plataforma Linux (algumas distribuições colocam o IDLE em um pacote separado do pacote do Python).
Seja qual for o interpretador que você escolheu, ao executá-lo você verá uma mensagem com informações de copyright
mais ou menos como essa:
Python 2.5.1 (r251:54863, Oct 5 2007, 13:50:07) [GCC 4.1.3 20070929 (prerelease) (Ubuntu 4.1.2-16ubuntu2)] on linux Type "help", "copyright", "credits" or "license" for more information.
O símbolo >>> exibido pelo interpretador é o que os americanos chamam de “prompt”, que alguns traduzem por
“aviso”, mas nós vamos chamar de “deixa” (em teatro, o termo “prompt” é a deixa que indica ao ator a hora de
dizer ou fazer algo; em computação, o “prompt” informa o usuário que o sistema está pronto para receber um novo
comando).
Para sair do interpretador você pode fechar a janela do IDLE, ou teclar [CTRL]+[D] (no IDLE ou no interpretador
em UNIX) ou [CTRL]+[Z] e então [ENTER] (no interpretador DOS).
Uma calculadora melhor
Vamos então aproveitar a deixa e escrever algo. Experimente escrever uma expressão aritmética bem simples, como
A resposta é reconfortante: para Python, 2+2 é igual a 4. Você pode experimentar outras expressões mais complexas,
mas é bom saber que os quatro operadores básicos em Python (e em quase todas as linguagens modernas) são esses:
- (^) * multiplicação
- / divisão
Em Python, assim como na linguagem C, os números inteiros têm um tratamento especial. Isso fica evidente quando
fazemos uma divisão:
Em vez de 3,5, o resultado foi 3. Isso acontece sempre que todos os números de uma expressão são inteiros. Neste
caso, Python imagina que se deseja um resultado inteiro também (esse comportamento estranho às vezes é conveniente
em programação).
Se você quiser operar com números decimais, deve usar o ponto e não a vírgula como separador decimal:
Note que basta digitar um ponto após o número. O computador não consegue lidar com números do conjunto dos reais,
mas apenas com uma aproximação chamada “número de ponto-flutuante” (porque o ponto decimal pode aperecer em
qualquer posição do número). Ao lidar com ponto-flutuante, às vezes vemos resultados estranhos:
O resultado não deveria ser 4.8? Deveria, mas antes de ficar revoltado note que a diferença foi muito pequena.
Acontece que o sistema de “ponto-flutuante” padrão IEEE-754 usado em quase todos os computadores atuais tem uma
precisão limitada, e Python não esconde este fato de você, programador. O problema não está na conta, mas na própria
representação interna do valor 2.4:
Para exibir valores de ponto-flutuante para um usuário sem assustá-lo, use o comando print:
>>> print 2.4 * 2
Você pode digitar espaços entre os números e operadores para fazer uma expressão longa ficar mais legível. Veja esse
exemplo:
Note que o interpretador Python é mais esperto que uma calculadora comum. Ele sabe que a multiplicação deve ser
efetuada antes da adição. Se você teclar a mesma expressão em uma calculadora qualquer obterá o resultado 9, que é
incorreto. Em Python, se você realmente deseja efetuar a soma antes da multiplicação, precisa usar parênteses:
Ao contrário do que você aprendeu na escola, aqui os símbolos [] e {} não servem para agrupar expressões dentro de
outras expressões. Apenas parênteses são usados:
Note: Dica
Se você escrever algo que o interpretador não reconhece, verá na tela uma mensagem de erro. Não crie o mau hábito
de ignorar essas mensagens, mesmo que elas pareçam difíceis de entender num primeiro momento. A única vantagem
de cometer erros é aprender com eles, e se a preguiça o impedir de ler as mensagens, seu aprendizado será bem mais
lento.
Como decifrar as mensagens de erro do Python
A dura realidade é que um programador profissional passa boa parte de sua vida caçando erros, e por isso é fundamental
saber extrair o máximo de informações das mensagens resultantes.
No último caso, convertemos de uma vez só os valores 5, 7 e 9 em dólares. Para um resultado mais apresentável, use
o comando print:
>>> print (^5) * d, (^7) * d, 9 * d 8.43 11.802 15.
E se a cotação do dólar mudou para 1.61? Basta armazenar o novo número e refazer os cálculos:
>>> d = 1. >>> print (^5) * d, (^7) * d, 9 * d 8.05 11.27 14.
Você precisa digitar a linha mais longa de novo. No IDLE, clique sobre a linha que digitamos no exemplo anterior e
tecle [ENTER]. A linha será reproduzida na última deixa, e bastará um novo [ENTER] para processá-la. No console,
teclando a seta para cima você acessa o histórico de comandos.
Tabela de preços em dólares e reais
Agora vamos mostrar como o interpretador Python é muito mais poderoso que uma calculadora. Imagine que em sua
loja de discos importados você tem um balcão de ofertas com discos de $4 até $9. Se quisesse fazer uma tabela de
preços em reais você poderia digitar:
>>> print 4d, 5d, 6d, 7d, 9*d 6.44 8.05 9.66 11.27 14.
Mas isso é um tanto chato e repetitivo. Em programação, sempre que você fizer algo repetitivo é porque não encontrou
ainda a melhor solução. Lidar com séries de números é uma atividade comum, e Python pode ajudar muito nesses
casos. Digite o seguinte:
>>> lista = [5,6,7,8,9]
Aqui nós criamos uma lista de preços na memória do computador e associamos o nome “lista” a esses dados. Em
seguida, digite o seguinte (você terá que teclar [ENTER] duas vezes ao final dessa linha; depois saberá porque).
>>> for p in lista: print p (^) * d
Aqui nós instruímos o interpretador a fazer os seguintes passos:
- para cada item sucessivo da lista :
- associe o nome p ao item da vez
- exiba o valor de p * d
Agora digamos que você tem discos com valores de 4 a 15 dólares. Você poderia digitar a lista de novo, mas a coisa
começa a ficar repetitiva novamente. Há uma forma melhor. A linguagem Python possui uma palavra chamada range
que serve para gerar faixas de números. Vamos usar essa palavra. Digite:
>>> range <built-in function range>
Quando você digita o nome de uma função sem fornecer dados, Python limita-se a dizer a que se refere o nome.
Nesse caso: built-in function range, ou função embutida range. Isso quer dizer que a palavra range
é o nome de uma função, um tipo de comando que produz resultados a partir de dados fornecidos. E trata-se ainda
de uma função embutida, ou seja, incluída no próprio interpretador (a maioria das funções da linguagem Python não
são embutidas, mas fazem parte de módulos que o programador precisa chamar explicitamente; isso será explicado
depois).
Acabamos de dizer que uma função “produz resultados a partir de dados fornecidos”, então vamos fornecer algum
dado para ver que resultados a função range produz. Digite range(5) e veja o que acontece:
>>> range(5) [0, 1, 2, 3, 4]
Quando apenas um dado N é fornecido, range gera uma lista de N números, de zero até N-1. É um comportamento
um pouco estranho, mas útil em programação (o primeiro item de uma série, em Python e na maioria das linguagens,
é o item número zero; isso será discutido mais profundamente quando aprendermos mais sobre listas).
Agora digamos que eu queira uma sequência a partir de 2, e não zero. Digite:
>>> range(2,5) [2, 3, 4]
Agora para obter a lista de valores de discos podemos digitar:
>>> range(4,16) [4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
E usando o comando for, calcular de uma só vez todos os valores convertidos:
>>> for p in range(4,16): print p (^) * d ...
Mas o ideal mesmo era ter os valores em dólares e reais lado a lado. Isso é fácil:
>>> for p in range(4,16): print p, p * d ... 4 6.
Você tem que digitar as aspas para evitar um erro. As aspas podem ser ‘simples’ ou “duplas”. Python guardará uma
cópia do seu nome na memória do computador, e associará o identificador eu a esse dado. Agora basta digitar eu para
ver o seu nome.
>>> eu ’Fulano’
Antes havíamos criado a variável d referindo-se à cotação do dólar, e no capítulo anterior também criamos uma
variável chamada lista, contendo uma lista de valores. Agora criamos a variável eu para se referir ao seu nome.
Estes são exemplos de três tipos de dados que Python é capaz de processar: número de ponto flutuante, lista de valores,
e texto.
Você pode saber o tipo de uma variável ou estrutura de dados usando a função type. Veja estes exemplos:
>>> eu = ’Luciano’ >>> d = 1. >>> type(eu) <type ’str’> >>> type(d) <type ’float’>
Python acaba de nos dizer que a variável eu refere-se a um objeto do tipo str, uma abreviatura de “string” (basica-
mente o computador encara um texto como uma cadeia de caracteres). E a variável d aponta para um objeto do tipo
float, ou “número de ponto-flutuante”, como já vimos antes.
Vejamos mais alguns tipos de dados:
>>> type(1) <type ’int’> >>> type(1.) <type ’float’> >>> type([1,2,3]) <type ’list’>
Observe que o número 1 não é float, mas int. Já o número 1. (“um” seguido de um ponto decimal) é considerado
um float. Como já dissemos no primeiro capítulo, inteiros e ‘’floats” têm tratamento diferente em Python. Uma
divisão de inteiros (como 7/2), sempre fornece um resultado inteiro (3, nesse exemplo). O próximo dado testado é
uma lista, [1,2,3], que Python chama de list.
Agora, experimente fazer esses dois testes:
>>> type(range) <type ’builtin_function_or_method’> >>> type(range(3)) <type ’list’>
Ao perguntarmos qual é o tipo associado ao nome range, Python responde: builtin_function_or_method.
Também já vimos isso no capítulo anterior: o nome range refere-se a uma função embutida no próprio interpretador.
No teste seguinte, fornecemos um argumento para a função range, e assim produzimos um resultado (neste caso,
a lista [0,1,2], que foi criada na memória do seu computador, mas não foi exibida). É sobre este resultado que
a função type foi aplicada, retornando a informação de que se trata de um dado do tipo list. Ou seja, range é
uma expressão do tipo builtin_function_or_method, mas range(3) é uma expressão do tipo list. Faz
sentido? Se não faz, escreva reclamando!
Cada tipo de dados suporta operações diferentes. Faça algumas experiências e analise os resultados:
>>> n1 = 10 >>> n2 = 20 >>> n1 + n 30 >>> n1 = ’abacate’ >>> n2 = ’banana’ >>> n1 + n ’abacatebanana’ >>> n2 + n ’bananaabacate’
Por exemplo, o operador + realiza uma soma quando aplicado a dados numéricos, mas quando aplicado a dados do
tipo ‘string‘, o sinal + faz uma operação de concatenação (junção de duas seqüências). Agora experimente isto:
>>> x = 3. >>> x (^) * 5
>>> ’x’ (^) * 5 ’xxxxx’
Note que x e ‘x’ são coisas totalmente diferentes. x é o nome de uma variável que neste momento se refere ao valor 3.
(um ‘float‘). O resultado de x * 5 é 15.0 (outro ‘float‘, como era de se esperar). Já x é uma ‘string‘ com
um caractere. Quando o sinal * é aplicado entre uma ‘string‘ e um número inteiro, Python realiza uma operação
de repetição. Como você pode notar, os operadores + e * fazem coisas diferentes dependendo dos tipos de dados
fornecidos na expressão.
É um prazer trabalhar com Python porque é uma linguagem muito coerente. Observe:
>>> [1,2] + [3,4]
[1, 2, 3, 4]
>>> [1,2] * 3
[1, 2, 1, 2, 1, 2]
No primeiro exemplo, vemos o operador + concatenando duas listas. Os outros dois exemplos mostram a operação
de repetição. Note que 12 não é um número, mas uma ‘string‘ composta pelos caracteres 1 e 2. Para Python,
‘strings‘ e listas têm muito em comum: ambas são seqüências de itens. Enquanto ‘strings‘ são seqüências de
caracteres, listas são seqüências de itens quaisquer. Nos dois casos, concatenação e repetição funcionam de forma
logicamente idêntica.
Enfeitando a tabela
Agora que sabemos sobre alguns tipos de dados, e que os operadores funcionam de forma diferente conforme os
dados da expressão, estamos prontos para aperfeiçoar nosso gerador de tabelas usando o poderoso operador ‘%’, que
em Python não tem nada a ver com porcentagens. Para ver como ele funciona, vamos criar uma ‘string‘ como esta:
>>> msg = ’um dólar vale %f real.’
Agora vamos ver o que acontece quando chamamos a variável msg:
>>> msg ’um d\363lar vale %f real.’
faixa de preços de 4 a 15, os maiores valores tem cinco caracteres de comprimento (incluindo o ponto decimal), por
isso vamos usar %5.2f. Agora podemos fazer uma versão bem melhor da tabela:
>>> for p in range(4,16): print ’US$ %5.2f = R$ %5.2f’ % (p,p*d)
US$ 4.00 = R$ 6. US$ 5.00 = R$ 8. US$ 6.00 = R$ 10. US$ 7.00 = R$ 11. US$ 8.00 = R$ 13. US$ 9.00 = R$ 15. US$ 10.00 = R$ 16. US$ 11.00 = R$ 18. US$ 12.00 = R$ 20. US$ 13.00 = R$ 21. US$ 14.00 = R$ 23. US$ 15.00 = R$ 25.
Entendendo melhor o for
Como você percebeu, no comando for tudo aquilo que aparece após os sinal ”:” é repetido várias vezes, uma vez
para cada item da lista de valores indicada após a palavra in. Mas os comandos a serem repetidos podem ser vários, e
na maioria das vezes não são escritos na mesma linha que o for, como temos feito, mas sim em linhas subseqüentes.
O comando for é algo que chamamos de “estrutura de controle”, que serve para determinar a forma de execução de
um comando ou de uma seqüência de comandos, às vezes chamada de um “bloco”. Em outras linguagens, os blocos
são delimitados por marcadores especiais. Java, Perl e C++ usam os sinais { e } para este fim. Pascal e Delphi usam as
palavras BEGIN e END. Além desses marcadores exigidos pelas linguagens, os programadores usam também o recurso
da endentação, ou seja, o recuo em relação à margem esquerda, para tornar mais fácil a visualização da estrutura do
programa. Veja este exemplo em Perl:
for ($i = 0; $i < 5; $i++) { # Atenção: isto é Perl, e não Python. $v = $i (^) * 3; print "$v\n"; }
Aqui, os comandos $v = $i * 3; e print "$v\n"; formam o bloco que está sobre o controle do comando
for, ou seja, os dois comandos serão executados repetidamente. O programa equivalente em Python é escrito assim:
for i in range(5): v = i * 3 print v
Na minha opinião, o código em Python é bem mais legível. Para sinalizar quais comandos fazem parte do bloco
que está sob o controle do for, apenas a endentação é utilizada. Se você está usando o IDLE, esse recuo acontece
automaticamente quando uma linha de comando termina com o sinal ‘:’, que em Python sempre indica o início de
um bloco. No interpretador Python invocado a partir da linha de comando no DOS ou em UNIX, a endentação não é
automática. Você precisa digitar ao menos um espaço em branco para evitar uma mensagem de erro como essa:
>>> for i in range(5): ... print i File "", line 2 print i ^ SyntaxError: invalid syntax
Note que o interpretador está reclamando de sintaxe inválida, e apontando (^) para a primeira palavra do bloco que
deveria estar recuado. Veja a mesma coisa, com a segunda linha recuada com a tecla [TAB]:
>>> for i in range(5): ... print i ... 0 1 2 3 4
Já deve ter ficado claro porque era preciso teclar [ENTER] duas vezes depois do for nos exemplos anteriores: é que,
no modo interativo, o interpretador Python espera uma linha em branco para sinalizar o final de uma série de comandos
que formam um bloco dentro de uma estrutura de controle.
Agora que entendemos o conceito de bloco, podemos enfeitar ainda mais a nossa tabela colocando um segundo co-
mando print dentro do nosso for.
Veja este exemplo:
>>> for p in range(9,13): ... print ’US$ %5.2f = R$ %5.2f’ % (p, p * d) ... print ’-’ * 20 ... US$ 9.00 = R$ 15.
US$ 10.00 = R$ 16.
US$ 11.00 = R$ 18.
US$ 12.00 = R$ 20.
A outra face do %
Antes de encerrar este capítulo, vale a pena contar que, assim como o + e o *, o operador % também tem dupla
personalidade. Quando aplicado sobre dois números, que podem ser inteiros ou ‘floats‘, o % retorna o resto da
divisão inteira do primeiro pelo segundo. Veja só:
Explicando: 6 / 3 dá 2, e o resto é 0; a divisão inteira de 7 / 3 também dá 2, mas o resto é 1. Esta operação
é chamada de “modulo” em inglês. Sua principal utilidade é determinar se um número é múltiplo de outro. Nos
exemplos acima, o resultado de 6 % 3 e 9 % 3 é zero, porque 6 e 9 são múltiplos de 3.
No próximo capítulo vamos começar a elaborar programas mais extensos. O modo interativo, que temos usado até
agora, vai continuar sendo útil para testarmos novas idéias e observar o comportamento de funções e módulos do
Python rapidamente. Mas, a partir da próxima sessão, vamos começar a gravar nossos programas para uso posterior,
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:. .. 25/10/99 20: .. 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
- [ ] (seta para cima) para repetir o comando ..\python egotrip.py
- [ENTER] para executar o comando.
10 entre 10 programadores que usam a plataforma Windows têm muita prática com a sequência [ALT]+[TAB], [
], [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,
Linha 1 O sinal # indica comentário. Tudo o que aparece em uma linha a partir desse sinal é ignorado pelo inter-
pretador 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. Gastos por pessoa: R$ 15. Ana deve pagar: R$ 5.
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.
1 # despdom2.py - Calculadora de despesas domesticas - versao 2 2 3 print ’Balanco de despesas domesticas’ 4 ana = float(raw_input(’Quanto gastou Ana? ’)) 5 bia = float(raw_input(’Quanto gastou Bia? ’)) 6 print 7 total = ana + bia 8 print ’Total de gastos: R$ %s’ % total 9 media = total/
10 print ’Gastos por pessoa: R$ %s’ % media 11 if ana < media: 12 diferenca = media - ana 13 print ’Ana deve pagar: R$ %s’ %diferenca 14 else : 15 diferenca = media - bia 16 print ’Bia deve pagar: R$ %s’ % diferenca
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++:
