Python

Sumário
I Sobre essa Apostila 2
II Informações Básicas 4
III Programação Python 9
1 O que é Programação Python 10
2 Plano de ensino 11
2.1 Objetivo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.2 Público Alvo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.3 Pré-requisitos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.4 Descrição . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.5 Metodologia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.6 Cronograma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.7 Programa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.8 Avaliação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.9 Bibliograﬁa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3 Visão Geral 14
3.1 O que é? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.2 Por que Python? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.3 Características da Linguagem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.4 Plataformas Disponíveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.5 Filosoﬁa da Linguagem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.6 Histórico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.7 Organização . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.8 Licença . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.9 Documentação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.10 Comparação de Linguagens de Programação . . . . . . . . . . . . . . . . . . . . . . 19
3.11 Adquirindo o Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.12 Instalando o Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3.13 Testando o Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.14 Interpretador . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
1

CDTC Centro de Difusão de Tecnologia e Conhecimento Brasil/DF
4 Introdução à Linguagem 23
4.1 Identação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
4.2 Comentando o código . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
4.3 Entrada de dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
4.4 Saída de dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
4.5 Tipos - Números . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
4.6 Tipos - Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
4.7 Operações sobre Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
4.8 Substituição em strings: o operador de porcentagem . . . . . . . . . . . . . . . . . . 35
4.9 Mais sobre Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
5 Operadores 38
5.1 Operadores de Atribuição . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
5.2 Operadores Aritméticos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
5.3 Operadores Relacionais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
5.4 Operadores Lógicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
5.5 Operadores Bit a Bit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
6 Estruturas de Controle 42
6.1 Introdução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
6.2 if, else e elif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
6.3 for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
6.4 while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
6.5 break e continue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
7 Estrutura de Dados 47
7.1 Listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
7.2 Outros métodos de Listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
7.3 Mais sobre listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
7.4 Tuplas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
7.5 Sets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
7.6 Dicionário . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
7.7 Mais sobre dicionários . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
7.8 Utilizando Listas como Pilhas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
7.9 Utilizando Listas como Fila . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
7.10 Trabalhando com arquivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
8 Funções 57
8.1 Introdução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
8.2 Criando e chamando uma Função . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
8.3 Variáveis locais x globais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
8.4 Argumentos padrões . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
8.5 Argumentos chaves . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
8.6 Retorno . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
8.7 DocStrings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
8.8 Módulos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
8.9 Introdução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
8.10 Criando um módulo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
8.11 Mais sobre módulos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
2

8.12 Módulos Padrões . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
8.13 Módulos independentes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
9 Erros e exceções 66
9.1 Introdução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
9.2 Erros de sintaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
9.3 Exceções . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
9.4 Tratamento e disparo(raise) de exceções . . . . . . . . . . . . . . . . . . . . . . . . 67
9.5 Ações de limpeza(clean-up) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
10 Python Orientado a Objetos 70
10.1 Introdução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
10.2 Conceitos OO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
10.3 Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
10.4 Objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
10.5 Instância . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
10.6 Atributos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
10.7 Métodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
10.8 Variáveis de classe vs objeto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
10.9 Variáveis privadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
10.10O método init . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
10.11O argumento self . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
10.12Herança . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
11 Expressões Regulares 78
11.1 Deﬁnindo expressões regulares . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
11.2 Sintaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
11.3 Utilizando RE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
11.4 Extraindo conteúdo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
11.5 Substituindo textos com RE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
12 Bibliotecas Gráﬁcas 86
12.1 TKinter para TK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
12.2 PyGTK para GTK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
12.3 PyQT para QT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
12.4 wxPython para wxWidgets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
3

Conteúdo
O conteúdo dessa apostila é fruto da compilação de diversos materiais livres publicados na in-
ternet, disponíveis em diversos sites ou originalmente produzido no CDTC em http://www.cdtc.org.br.
O formato original deste material bem como sua atualização está disponível dentro da licença
GNU Free Documentation License, cujo teor integral encontra-se aqui reproduzido na seção de
mesmo nome, tendo inclusive uma versão traduzida (não oﬁcial).
A revisão e alteração vem sendo realizada pelo CDTC (suporte@cdtc.org.br) desde outubro
de 2006. Críticas e sugestões construtivas são bem-vindas a qualquer tempo.
Autores
A autoria deste é de responsabilidade de Equipe CDTC.
O texto original faz parte do projeto Centro de Difusão de Tecnologia e Conhecimento, que
vem sendo realizado pelo ITI (Instituto Nacional de Tecnologia da Informação) em conjunto com
outros parceiros institucionais, atuando em conjunto com as universidades federais brasileiras
que tem produzido e utilizado Software Livre, apoiando inclusive a comunidade Free Software
junto a outras entidades no país.
Informações adicionais podem ser obtidas através do email ouvidoria@cdtc.org.br, ou da
home page da entidade, através da URL http://www.cdtc.org.br.
Garantias
O material contido nesta apostila é isento de garantias e o seu uso é de inteira responsabi-
lidade do usuário/leitor. Os autores, bem como o ITI e seus parceiros, não se responsabilizam
direta ou indiretamente por qualquer prejuízo oriundo da utilização do material aqui contido.
Licença
Copyright ©2006, Instituto Nacional de Tecnologia da Informação (cdtc@iti.gov.br) .
Permission is granted to copy, distribute and/or modify this document under the terms
of the GNU Free Documentation License, Version 1.1 or any later version published by
the Free Software Foundation; with the Invariant Chapter being SOBRE ESSA APOS-
TILA. A copy of the license is included in the section entitled GNU Free Documentation
License.
5

Parte II
Informações Básicas
6

Sobre o CDTC
Objetivo Geral
O Projeto CDTC visa a promoção e o desenvolvimento de ações que incentivem a dissemina-
ção de soluções que utilizem padrões abertos e não proprietários de tecnologia, em proveito do
desenvolvimento social, cultural, político, tecnológico e econômico da sociedade brasileira.
Objetivo Específico
Auxiliar o Governo Federal na implantação do plano nacional de software não-proprietário e
de código fonte aberto, identificando e mobilizando grupos de formadores de opinião dentre os
servidores públicos e agentes políticos da União Federal, estimulando e incentivando o mercado
nacional a adotar novos modelos de negócio da tecnologia da informação e de novos negócios
de comunicação com base em software não-proprietário e de código fonte aberto, oferecendo
treinamento específico para técnicos, profissionais de suporte e funcionários públicos usuários,
criando grupos de funcionários públicos que irão treinar outros funcionários públicos e atuar como
incentivadores e defensores de produtos de software não proprietários e código fonte aberto, ofe-
recendo conteúdo técnico on-line para serviços de suporte, ferramentas para desenvolvimento de
produtos de software não proprietários e de seu código fonte livre, articulando redes de terceiros
(dentro e fora do governo) fornecedoras de educação, pesquisa, desenvolvimento e teste de pro-
dutos de software livre.
Guia do aluno
Neste guia, você terá reunidas uma série de informações importantes para que você comece
seu curso. São elas:
• Licenças para cópia de material disponível
• Os 10 mandamentos do aluno de Educação a Distância
• Como participar dos foruns e da wikipédia
• Primeiros passos
É muito importante que você entre em contato com TODAS estas informações, seguindo o
roteiro acima.
Licença
Copyright ©2006, Instituto Nacional de Tecnologia da Informação (cdtc@iti.gov.br).
7

É dada permissão para copiar, distribuir e/ou modiﬁcar este documento sob os termos
da Licença de Documentação Livre GNU, Versão 1.1 ou qualquer versão posterior
públicada pela Free Software Foundation; com o Capitulo Invariante SOBRE ESSA
APOSTILA. Uma cópia da licença está inclusa na seção entitulada "Licença de Docu-
mentação Livre GNU".
Os 10 mandamentos do aluno de educação online
• 1. Acesso à Internet: ter endereço eletrônico, um provedor e um equipamento adequado é
pré-requisito para a participação nos cursos a distância.
• 2. Habilidade e disposição para operar programas: ter conhecimentos básicos de Informá-
tica é necessário para poder executar as tarefas.
• 3. Vontade para aprender colaborativamente: interagir, ser participativo no ensino a distân-
cia conta muitos pontos, pois irá colaborar para o processo ensino-aprendizagem pessoal,
dos colegas e dos professores.
• 4. Comportamentos compatíveis com a etiqueta: mostrar-se interessado em conhecer seus
colegas de turma respeitando-os e fazendo ser respeitado pelo mesmo.
• 5. Organização pessoal: planejar e organizar tudo é fundamental para facilitar a sua revisão
e a sua recuperação de materiais.
• 6. Vontade para realizar as atividades no tempo correto: anotar todas as suas obrigações e
realizá-las em tempo real.
• 7. Curiosidade e abertura para inovações: aceitar novas idéias e inovar sempre.
• 8. Flexibilidade e adaptação: requisitos necessário à mudança tecnológica, aprendizagens
e descobertas.
• 9. Objetividade em sua comunicação: comunicar-se de forma clara, breve e transparente é
ponto - chave na comunicação pela Internet.
• 10. Responsabilidade: ser responsável por seu próprio aprendizado. O ambiente virtual não
controla a sua dedicação, mas reﬂete os resultados do seu esforço e da sua colaboração.
Como participar dos fóruns e Wikipédia
Você tem um problema e precisa de ajuda?
Podemos te ajudar de 2 formas:
A primeira é o uso dos fóruns de notícias e de dúvidas gerais que se distinguem pelo uso:
. O fórum de notícias tem por objetivo disponibilizar um meio de acesso rápido a informações
que sejam pertinentes ao curso (avisos, notícias). As mensagens postadas nele são enviadas a
8

todos participantes. Assim, se o monitor ou algum outro participante tiver uma informação que
interesse ao grupo, favor postá-la aqui.
Porém, se o que você deseja é resolver alguma dúvida ou discutir algum tópico específico do
curso. É recomendado que você faça uso do Forum de dúvidas gerais que lhe dá recursos mais
efetivos para esta prática.
. O fórum de dúvidas gerais tem por objetivo disponibilizar um meio fácil, rápido e interativo
para solucionar suas dúvidas e trocar experiências. As mensagens postadas nele são enviadas
a todos participantes do curso. Assim, fica muito mais fácil obter respostas, já que todos podem
ajudar.
Se você receber uma mensagem com algum tópico que saiba responder, não se preocupe com a
formalização ou a gramática. Responda! E não se esqueça de que antes de abrir um novo tópico
é recomendável ver se a sua pergunta já foi feita por outro participante.
A segunda forma se dá pelas Wikis:
. Uma wiki é uma página web que pode ser editada colaborativamente, ou seja, qualquer par-
ticipante pode inserir, editar, apagar textos. As versões antigas vão sendo arquivadas e podem
ser recuperadas a qualquer momento que um dos participantes o desejar. Assim, ela oferece um
ótimo suporte a processos de aprendizagem colaborativa. A maior wiki na web é o site "Wikipé-
dia", uma experiência grandiosa de construção de uma enciclopédia de forma colaborativa, por
pessoas de todas as partes do mundo. Acesse-a em português pelos links:
• Página principal da Wiki - http://pt.wikipedia.org/wiki/
Agradecemos antecipadamente a sua colaboração com a aprendizagem do grupo!
Primeiros Passos
Para uma melhor aprendizagem é recomendável que você siga os seguintes passos:
• Ler o Plano de Ensino e entender a que seu curso se dispõe a ensinar;
• Ler a Ambientação do Moodle para aprender a navegar neste ambiente e se utilizar das
ferramentas básicas do mesmo;
• Entrar nas lições seguindo a seqüência descrita no Plano de Ensino;
• Qualquer dúvida, reporte ao Fórum de Dúvidas Gerais.
Perfil do Tutor
Segue-se uma descrição do tutor ideal, baseada no feedback de alunos e de tutores.
O tutor ideal é um modelo de excelência: é consistente, justo e profissional nos respectivos
valores e atitudes, incentiva mas é honesto, imparcial, amável, positivo, respeitador, aceita as
idéias dos estudantes, é paciente, pessoal, tolerante, apreciativo, compreensivo e pronto a ajudar.
9

A classificação por um tutor desta natureza proporciona o melhor feedback possível, é crucial, e,
para a maior parte dos alunos, constitui o ponto central do processo de aprendizagem.’ Este tutor
ou instrutor:
• fornece explicações claras acerca do que ele espera, e do estilo de classificação que irá
utilizar;
• gosta que lhe façam perguntas adicionais;
• identifica as nossas falhas, mas corrige-as amavelmente’, diz um estudante, ’e explica por-
que motivo a classificação foi ou não foi atribuída’;
• tece comentários completos e construtivos, mas de forma agradável (em contraste com um
reparo de um estudante: ’os comentários deixam-nos com uma sensação de crítica, de
ameaça e de nervossismo’)
• dá uma ajuda complementar para encorajar um estudante em dificuldade;
• esclarece pontos que não foram entendidos, ou corretamente aprendidos anteriormente;
• ajuda o estudante a alcançar os seus objetivos;
• é flexível quando necessário;
• mostra um interesse genuíno em motivar os alunos (mesmo os principiantes e, por isso,
talvez numa fase menos interessante para o tutor);
• escreve todas as correções de forma legível e com um nível de pormenorização adequado;
• acima de tudo, devolve os trabalhos rapidamente;
10

Parte III
Programação Python
11

Capítulo 1
O que é Programação Python
Python é uma descomplicada e robusta linguagem de programação orientada a objetos que
possui características poderosas que a tornam uma linguagem muito simples e eﬁciente. Sua
abstração sobre a orientação a objetos permite a criação rápida de softwares, bem como, a sua
integração à outras linguagens de programação como C/C++, JAVA e .NET, permitindo grande ﬂe-
xíbilidade. Python já é uma realidade no mundo do Software Livre e vem conquistando também
a cada dia o mundo do Software Proprietário, principalmente na área de jogos para computadores.
O curso, com base na distribuição Debian possui tres semanas, começa na Segunda-Feira da
primeira semana e termina no Domingo da ultima semana. Todo o conteúdo do curso estará
visível somente a partir da data de início. Para começar o curso você deve ler o Guia do aluno a
seguir.
12

Capítulo 2
Plano de ensino
2.1 Objetivo
Capacitar o usuário a reconhecer a linguagem de programação Python.
2.2 Público Alvo
Qualquer pessoa que utilize um computador.
2.3 Pré-requisitos
Os usuários deverão ser, necessariamente, funcionários públicos e ter conhecimentos básicos
para operar um computador, além de conhecimeto em Linux.
2.4 Descrição
O curso será realizado na modalidade Educação a Distância e utilizará a Plataforma Moodle
como ferramenta de aprendizagem. O curso tem duração de uma semana e possui um conjunto
de atividades (lições, fóruns, glossários, questionários e outros) que deverão ser executadas de
acordo com as instruções fornecidas. O material didático está disponível on-line de acordo com
as datas pré-estabelecidas em cada tópico.
2.5 Metodologia
O curso está dividido da seguinte maneira:
2.6 Cronograma
• Descrição das atividades
• Semana 1
13

• Visão Geral
• Introdução à Linguagem
• Operadores
• Estruturas de Controle
• Semana 2
• Estrutura de Dados
• Funções
• Módulos
• Erros e Exceções
• Semana 3
• Python Orientado a Objetos
• Expressões Regulares
• Bibliotecas Gráficas
Como mostrado na tabela acima, a cada semana será disponibilizado um conjunto de módulos.
É recomendável que o participante siga as datas estabelecidas.
As lições, disponíveis em cada módulo, contém o contéudo principal. Elas poderão ser acessa-
das quantas vezes forem necessárias, desde que esteja dentro da semana programada. Ao final
de uma lição, você receberá uma nota de acordo com o seu desempenho. Caso sua nota numa
determinada lição for menor do que 6.0, sugerimos que você faça novamente esta lição.
Ao final do curso serão disponibilizadas as avaliações referentes aos módulos estudados ante-
riormente. Somente as notas das avaliações serão consideradas para a nota final. Todos os
módulos ficarão visíveis para que possam ser consultados durante a avaliação final.
Para conhecer as demais atividades de cada módulo leia o tópico seguinte: "Ambientação do
Moodle".
Os instrutores estarão a sua disposição ao longo de todo curso. Qualquer dúvida deve ser envi-
ada ao fórum correspondente. Diariamente os monitores darão respostas e esclarecimentos.
2.7 Programa
O curso oferecerá o seguinte conteúdo:
• Introdução à linguagem Python
• Conceitos básicos
• Conceitos avançados
14

2.8 Avaliação
Toda a avaliação será feita on-line.
Aspectos a serem considerados na avaliação:
• Iniciativa e autonomia no processo de aprendizagem e de produção de conhecimento;
• Capacidade de pesquisa e abordagem criativa na solução dos problemas apresentados.
Instrumentos de avaliação:
• Participação ativa nas atividades programadas.
• Avaliação ao final do curso.
• O participante fará várias avaliações referente ao conteúdo do curso. Para a aprovação e
obtenção do certificado o participante deverá obter nota final maior ou igual a 6.0 de acordo
com a fórmula abaixo:
• Nota Final = ((ML x 7) + (AF x 3)) / 10 = Média aritmética das lições
• AF = Avaliações
2.9 Bibliografia
• Site oficial: http://www.python.org
• Guia em Português: http://www.pythonbrasil.com.br
• Python na Prática: Um curso objetivo de programação em Python:
• http://www.async.com.br/projects/python/pnp/
• Artigos de Fábio Rizzo: http://www.linhadecodigo.com.br/desenvolvimento/python.asp
15

Capítulo 3
Visão Geral
Conheça os benefícios desta poderosa linguagem de programação.
3.1 O que é?
Python é uma fácil e robusta linguagem de programação orientada a objetos. Ela possui ca-
racterísticas poderosas que a tornam uma linguagem muito simples e eficiente.
Sua abstração sobre a orientação a objetos a torna poderosa para criar softwares rapidamente
e a sua integração a outras linguagens de programação como C/C++ e JAVA (e agora também
.NET), a permite ser extremamente flexível. Python já é uma realidade no mundo do Software
Livre e vem conquistando também a cada dia o Software Proprietário (jogos de computador são
um exemplo forte).
Para vocês terem uma idéia, enquanto ASSEMBLY é uma linguagem de baixo nível, C uma
linguagem de nível intermediário e JAVA uma linguagem de alto nível, Python é uma linguagem
de altíssimo-nível.
Antes que alguém pergunte, Python é uma linguagem livre e você pode utiliza-la para desen-
volver seus softwares sem medo de patentes com relação ao Python.
A outra coisa que a torna extremamente interessante é o fato dela ser interpretada(independe
da arquitetura do computador) e multiplataforma, ou seja, um programa feito no GNU/Linux é
facilmente executada no Windows, MacOSX e até mesmo em portáteis como alguns celulares.
3.2 Por que Python?
Dado que existe uma grande diversidade de linguagens diferentes, por que aprender Python
é interessante ou mesmo importante? A linguagem combina um conjunto único de vantagens:
• Os conceitos fundamentais da linguagem são simples de entender.
• A sintaxe da linguagem é clara e fácil de aprender; o código produzido é normalmente curto
e legível.
• Os tipos pré-definidos incluídos em Python são poderosos, e ainda assim simples de usar.
16

• A linguagem possui um interpretador de comandos interativo que permite aprender e testar
rapidamente trechos de código.
• Python é expressivo, com abstrações de alto nível. Na grande maioria dos casos, um pro-
grama em Python será muito mais curto que seu correspondente escrito em outra lingua-
gem. Isto também faz com o ciclo de desenvolvimento seja rápido e apresente potencial de
defeitos reduzido - menos código, menos oportunidade para errar.
• Existe suporte para uma diversidade grande de bibliotecas externas. Ou seja, pode-se fazer
em Python qualquer tipo de programa, mesmo que utilize gráﬁcos, funções matemáticas
complexas, ou uma determinada base de dados SQL.
• É possível escrever extensões a Python em C e C++ quando é necessário desempenho má-
ximo, ou quando for desejável fazer interface com alguma ferramenta que possua biblioteca
apenas nestas linguagens.
• Python permite que o programa execute inalterado em múltiplas plataformas; em outras
palavras, a sua aplicação feita para Linux normalmente funcionará sem problemas em Win-
dows e em outros sistemas onde existir um interpretador Python.
• Python é pouco punitivo: em geral, ’tudo pode’e há poucas restrições arbitrárias. Esta
propriedade acaba por tornar prazeroso o aprendizado e uso da linguagem.
• Python é livre: além do interpretador ser distribuído como software livre (e portanto, gra-
tuitamente), pode ser usado para criar qualquer tipo de software – proprietário ou livre. O
projeto e implementação da linguagem é discutido aberta e diariamente em uma lista de cor-
reio eletrônico, e qualquer um é bem-vindo para propor alterações por meio de um processo
simples e pouco burocrático.
3.3 Características da Linguagem
Vamos ver alguns atributos que tornam a linguagem de programação Python tão atraente:
Fácil de aprender
Por possuir uma sintáxe simples, Python é considerada uma linguagem fácil de aprender, ideal(mas
não exclusivamente) para pessoas que estão aprendendo a programar.
Altíssimo Nível
O Python é uma linguagem de programação relativamente nova na industria de software .Pode-
mos utilizar o Python em muitos projetos, em muitas situações como gerenciamento de conteúdo,
documentos eletrônicos, servidores de aplicações, integração com o sistema legado, CORBA,
Telefonia Móvel.
Sua arquitetura é de simples e de fácil compreensão para o desenvolvimento de software, sem a
preocupação do programador com o controle de ponteiros por exemplo. O Python herda nuances
do FORTRAN, C, C++, ABC. Podemos compara-lo com ao C++ e ao Java quando falamos de
orientação a objetos.
17

Orientada a objetos
Python suporta tanto programação procedural quanto orientada a objetos. Na programação pro-
cedural, o programa é composto de procedimentos e funções. Na orientação a objetos, os pro-
gramas são compostos de objetos que combinam dados e funcionalidades. Python possui uma
maneira simples de lidar com orientação a objetos, especialmente quando comparado com as
grandes linguagens como C++ e Java.
Escalavel
A clareza do código encoraja a consistência, flexibilidade e rápido desenvolvimento necessá-
rio para projetos em expansão.
Extensivel
Se você deseja que uma parte do seu código seja escrito em outra linguagem, suponha C++,
você pode utilizar esse trecho de código apartir do seu programa Python.
Portável
Python esta acessível em uma variedades de plataformas, contribuindo para que engenheiros
e arquitetos de software escreverem seus códigos apenas uma vez e possam rodar o programa
em qualquer plataforma que suporte Python.
Robusta
Não há melhor poder para um engenheiro de software do que reconhecer condições de erro
e prover mecanismo dinâmicos de tratamentos de excessões e erros de "runtime"(tempo de exe-
cução) numa aplicacao.
Gerenciador de Memoria
O Python tira a responsabilidade do programador de lidar com o gerênciamento de memória,
como é feito através dos ponteiros em C/C++. Com isso, a chance de ocorrer erros críticos, co-
muns quando manipulamos a memória diretamente, se tornam menores, além de facilitar a vida
do programador.
Interpretada
Uma linguagem como C/C++ por exemplo, é classificada como compilada, pois o código fonte
é compilado diretamente para código de máquina (0’s e 1’s).
O Python pode ser classificado como uma linguagem interpretada, o que signifca que o código
fonte não é convertido diretamente para a linguagem da máquina. Para esta transição, existe um
meio termo, o interpretador.
Isso faz com que programas em linguagem interpretadas sejam bem mais portáveis, pois idepen-
dem da arquitetura do computador, bastanto para isso, que possuam suporte ao interpretador da
linguagem.
18

3.4 Plataformas Disponíveis
Está disponível para as mais diversas plataformas, desde Unix (Linux, FreeBSD, Solaris, Ma-
cOS X etc.), Windows, versões antigas de MacOS até consoles de videogames ou mesmo alguns
celulares, como a série 60 da Nokia e palmtops. O código fonte é traduzido pelo interpretador
para o formato bytecode, que é multiplataforma e pode ser executado e distribuído sem fonte
original.
3.5 Filosoﬁa da Linguagem
»> import this
The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren’t special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one– and preferably only one –obvious way to do it.
Although that way may not be obvious at ﬁrst unless you’re Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it’s a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea – let’s do more of those!
Tradução
The Zen of Python, por Tim Peters
Bonito é melhor que feio.
Explícito é melhor que implícito.
Simples é melhor que complexo.
Complexo é melhor que complicado.
Plano é melhor que aglomerado.
Esparso é melhor que denso.
Legibilidade faz diferença.
Casos especiais não são especiais o bastante para quebrar as regras.
Embora a praticidade vença a pureza.
19

Erros nunca devem passar silenciosamente.
A menos que sejam explicitamente silenciados.
Diante da ambigüidade, recuse a tentação de adivinhar.
Deve haver um – e preferencialmente só um – modo óbvio para fazer algo.
Embora esse modo possa não ser óbvio à primeira vista a menos que você seja holandês.
Agora é melhor que nunca.
Embora nunca freqüentemente seja melhor que *exatamente* agora.
Se a implementação é difícil de explicar, é uma má idéia.
Se a implementação é fácil de explicar, pode ser uma boa idéia.
Namespaces são uma grande idéia – vamos fazer mais dessas!
3.6 Histórico
O trabalho com o Python tem sido organizado desde 1989 por Guido Van Rossum, então
trabalhando na época para CWI na Holanda e em meados de 1991 publicou uma versão para
distribuição pública. Suas principais motivações foram a possibilidade de inovação no mundo
das linguagens de programação, falta de ferramenta similar e pesquisas. Nesta época Guido,
era pesquisador de diversas linguagens e teve a experiência de desenhar para a CWI também a
linguagem-interpretada ABC, contudo, foi a sua aproximação com o sistema operacional Amoeba
que lhe deu experiência, e foi justamente com suas pesquisas junto a especificação da linguagem
Amoeba, que alguns anos depois em 1989 lançou-se a primeira versão do Python.
3.7 Organização
Python é uma marca mantida pela Python Software Foundation. A PSF é uma instituição sem
fins lucrativos que é responsável por proteger a plataforma Python. É ela quem determina se uma
implementação de linguagem pode ser chamada de Python ou não.
A PSF é formada por vários desenvolvedores e é liderada por Guido van Rossum que é o criador
da linguagem. No universo pythonista existe um ditador benevolente (BDFL - Benevolent Dictator
for Life) que é o próprio GvR. Alguns podem dizer que isso é uma desvantagem do Python, mas
na verdade isso é que protege o Python e O GvR está nessa posição por mérito. A democracia
nem sempre é muito boa, principalmente quando envolve muito dinheiro pode ser corrompida e
tomar rumos inesperados.
O processo de proposição de mudanças na plataforma Python ocorre seguindo mais ou menos a
seguinte seqüência:
1. Alguma discussão surge na lista python-dev com alguma proposta.
2. Se a proposta já apresenta alguns bons argumentos é sugerido então que se crie uma
PEP (Python Enhancement Proposals) ([WWW] http://python.org/peps/) que deve seguir
algumas regras básicas. Neste documento a proposta é descrita em detalhes e algumas
das sugestões já coletadas na lista são anotadas.
3. A PEP então é colocada em Draft e é discutida na lista de discussões e modificações /
melhorias são feitas.
20

4. Terminada essa etapa pode-se pedir a implementação da funcionalidade proposta quando
isso se aplica.
5. Submete-se então essa PEP à uma votação informal (onde as pessoas votam com +1 / 0 /
-1) na própria lista de discussões. Essa votação serve para fundamentar o próximo passo.
6. Terminado tudo isso o BDFL (GvR) se pronuncia sobre a aprovação, a reprovação ou à
aprovação com mudanças da PEP.
A linguagem Python e a PSF oferecem uma implementação padrão da linguagem que é costu-
meiramente chamada de CPython (por ser implementada em C) que é conhecida como o padrão
*de fato* da linguagem.
Texto extraido do artigo Defesa do Python
3.8 Licença
Python possui uma licença Open Source certiﬁcada pela OSI compatível com a GPL, po-
rém menos restritiva. Sua licença prevê (entre outras coisas) que binários da linguagem sejam
distribuídos sem a necessidade de se haver o código-fonte junto. Para maiores detalhes, visite
http://www.python.org/2.4.1/license.html.
3.9 Documentação
A documentação do Python na sua última versão, a 2.4, pode ser encontrada na
URL: http://www.python.org/doc/
Temos também um site nacional muito indicado para os nós brasileiros:
http://www.pythonbrasil.com.br/
3.10 Comparação de Linguagens de Programação
Existe um site da comunidade Debian que compara diversas linguagens de programação e
dentre elas está o python.
Segue o link: http://shootout.alioth.debian.org/
Neste local existem benchmarks de diversas linguagens de programação.
3.11 Adquirindo o Python
Esta linguagem de programação esta disponível para várias plataformas, que seguem abaixo
:
• Unix
• Sun Solaris
21

• FreeBSD
• OpenBSD
• IBM-AIX
• HP/UX
• IRIX
• MS-Windows (NT/2000/2003/CE)
• Macintosh
• IBM-OS/2
• DOS
• PalmOS
• BeOS
• Amiga
• VMS/OpenVMS
• QNX
• VxWorks
Para obter o Python acesse o endereço eletrônico :
http://www.python.org
e procure por downloads.
3.12 Instalando o Python
Para usuários das mais diversas distribuições de GNU/Linux que possuem o APT, como o
Debian, basta apenas um:
$ apt-get install python
Você também pode acessar o site http://www.python.org e baixar a versão mais recente do
Python. Quando este curso foi escrito, estavamos na versão 2.4.2.
Não há problemas em baixar uma versão mais nova caso ela exista.
Entre na pasta onde foi baixado o arquivo, faça o logon como root e siga as instruções:
• Digite tar xzvf Python-2.4.2.tgz
• Acesse o diretório e execute ./conﬁgure
22

• Execute make
Neste momento, o Python já esta operacional, porém não está instalado em /usr/local no
system. Faça o seguinte:
• Para instalar execute: make install
O Python é normalmente instalado em locais padrão como em máquinas Unix e GNU/Linux
no /usr/bin quando que suas bibliotecas(lib) estao em /usr/lib/python2.x , já no caso do DOS ou
MS-Windows o Python é instalado em C:Python.
3.13 Testando o Python
Abra o terminal e digite o comando Python. Se tudo der certo, será aberto o interpretador
do Python. Ele permite que você execute todos os comandos da linguagem, sem que para isso
precise criar um arquivo com o código. Para sair do interpretador, aperte Ctrl + D.
Caso você queira jogar tudo em um arquivo, para depois executar, faça o seguinte:
Crie um arquivo com a extensão .py, por exemplo, primeiro.py
Adicione a seguinte linha no início do arquivo:
#!/usr/bin/env python
No caso da primeira linha temos algo comum em ambientes Unix, que são os comentários funci-
onais. Se na primeira linha de um arquivo existir #! seguido de um caminho para um executável,
este executável será chamado e o nome do arquivo será passado como argumento.
No nosso caso, o arquivo é primeiro.py e o Unix vai identiﬁcar a primeira linha como sendo um
comentário funcional e executar da seguinte forma:
/usr/bin/env python primeiro.py
Pronto, agora é só adicionar as outras linhas do programa, por exemplo:
print ’primeiro programa...’
O arquivo completo ﬁcaria da seguinte maneira:
print ’primeiro programa...’
Mande salvar o arquivo e rode no terminal da seguinte maneira:
python primeiro.py
Em todos os exemplos deste curso, estaremos utilizando o interpretador Python.
23

3.14 Interpretador
Existem duas maneiras de iniciar o Python. A mais simples é iniciar o interpretador intera-
tivamente, adicionando linhas a serem executados em tempo de execução. A outra maneira e
inicializando um script Python.
O primeiro modo pode ser feito no shell (terminal do GNU/Linux) ou no DOS com o comando:
$ python
Python 2.3.5 (#2, Sep 4 2005, 22:01:42)
[GCC3.3.5(Debian1 : 3.3.5 − 13)] on linux2
Type "help", "copyright", "credits"or "license"for more information.
Algo como a saída acima deve aparecer para você, e um cursor esperando suas entradas de-
vem ficar piscando após os »>.
Agora a outra forma é passando um script já previamente criado diretamente para o interpre-
trador, veja:
$ python exemplo.py
Observação : Todos os códigos fontes em Python tem extensão .py
Para sistemas Unix-like, temos mais uma outra forma específica de invocar o Python. Isso só
pode ser feito em scripts feitos em Python, veja um exemplo:
#-*- coding: iso8859-1 -*-
print "Ola mundo!"
No caso, o script deve possuir em seu cabeçalho as duas primeiras linhas deste exemplo. A
primeira invoca o ambiente python e a segunda define a codificação a ser utilizada, quando di-
zemos codificação, queremos dizer os caracteres que são conhecidos, ou seja, acentuação e
caracteres específicos de cada língua. A codificação iso8859-1 é a codificação utilizada no Bra-
sil, neste caso também poderíamos ter utilizado a codificação universal utf8.
Todos os exemplos deste curso, se forem utilizados em um arquivo (script), devem possuir o
cabeçalho acima para que possam rodar corretamente.
24

Capítulo 4
Introdução à Linguagem
Aprendendo os primeiros passos
4.1 Identação
Quando colocamos espaços em branco no início da linha de um código, estamos identando-o.
A identação serve para organizar melhor o código para que ele ﬁque visualmente mais agradável
e intuitivo. No Python estes espaços são bem importantes, pois os blocos de instruções devem
estar em um mesmo nível de identação, caso contrário, erros podem ocorrer.
Exemplo:
for x in range(1,10):
print x
File «stdin>", line 2
print x
^
IndentationError: expected an indented block
Exemplo:
for x in range(1,10):
print x
1
2
3
4
5
6
7
8
9
As identações podem ser feitas com espaços em brancos ou com tabulações. Recomenda-se
utilizar a tabulação em todos os casos. A obrigatoriedade da identação no Python é bem interes-
sante, pois "força"o programador a escrever um programa visualmente bem estruturado.
25

4.2 Comentando o código
Este é um item muito importante que as vezes é ignorado por muitos programadores. A im-
portância de comentar o código é enorme e isso deve ser feito sempre que possível.
Existem duas formas de comentário dentro do python, o comentário passivo e o comentário ativo.
Vejamos como podemos deﬁnir cada um deles:
• passivo - é o comentário feito utilizando o símbolo "#", conhecido também como tralha,
hash ou pound. Este comentário apenas aparece dentro do código onde foi escrito e é bom
quando temos diversos programadores desenvolvendo em cima de um mesmo código fonte,
isto ajuda na leitura do trecho de código em questão.
• ativo - são comentário feitos de uma forma especíﬁca dentro de funções e classes, estes
comentários geram uma documentação automaticamente e que pode ser acessada através
da função help().
Vamos dar uma olhada como funcionam estes dois tipos de comentários:
»> #Este e um comentario passivo e nao faz nada
...
Onde aparecerem as reticências poderia ser adicionado algum código ou mais comentário, no
nosso caso apenas apertamos enter para sair do comentário.
Um comentário passivo também pode ser feito após uma linha de código normalmente, veja:
»> print ’Ola!’ #o print vai retornar um ’Ola!’
’Ola1’
Agora, os comentários ativos são um tanto quanto mais interessantes. Não se preocupem se
não entenderem muito bem o código abaixo, prestem atenção apenas no código em negrito e
vejam a saída gerada pela função help().
»> def funcao():
... ”’Esta e uma funcao que nao faz nada”’
...
Acabamos de criar uma função que não faz nada, mas contém o nosso precioso comentário,
veja o que a função help() nos retorna(:
»> help(funcao)
Help on function funcao in module __main__:
funcao()
Esta e uma funcao que nao faz nada
*Para sair, aperte a tecla ’q’.
26

A função que acabamos de criar ganha no seu help() o comentário que foi feito. Um detalhe
importante é que este tipo de comentário é feito através das aspas triplas. Nas classes a saída é
muito mais interessante, veja:
»> class teste:
... ”’Esta e uma classe de teste”’
... def __init__(self):
... ”’O construtor”’
... pass
... def pinta(self):
... ”’Metodo que pinta”’
... pass
...
Com nossa classe de teste criada vamos chamar o help() com o nome da classe como parâmetro:
»> help(teste)
Help on class teste in module __main__:
class teste
| Esta e uma classe de teste
|
| Methods deﬁned here:
|
| __init__(self)
| O construtor
|
| pinta(self)
| Metodo que pinta
Como podemos ver, a classe ganhou o comentário e cada método da classe também recebeu o
comentário que ﬁzemos.
4.3 Entrada de dados
Nossos programas com certeza precisaram em algum momento de alguma interação com o
usuário. Já vimos como funcionam as impressões através da saída padrão do sistema, e agora
veremos como podemos realizar entradas de informações para nossos programas em Python.
Podemos dizer que existem duas grandes formas de realizar entradas de dados em Python, uma
é pela entrada padrão utilizando o teclado, scanner ou algum outro tipo de dispostivo de entrada
de dados no computador, ou através de arquivos, tópico que será visto mais tarde.
Vamos nos ater agora a entrada de dados pela entrada padrão, no caso, nosso teclado. Em
Python existe uma função chamada input() e outra chamada raw_input(). Veja abaixo uma pe-
27

quena definição de cada uma:
• input() - é equivalente a eval(raw_input()). Entenda isso como: você deve definir o que a
entrada é manualmente pela entrada padrão. Não se preocupe, vamos exemplificar mais
abaixo.
• raw_input() - lê um objeto do tipo string da entrada padrão. Ou seja, qualquer tipo que
for lido com o raw_input() será automaticamente convertido em um objeto do tipo string
(lembram-se do str()?).
Para não ficarmos apenas na teoria vejamos os exemplos a seguir:
»> user = raw_input("Entre com seu login: ")
Entre com seu login: root
»> user
’root’
»> numero = raw_input("Digite um numero: ")
Digite um numero: 10
»> numero
’10’
Veja no exemplo do número que o integer (inteiro) dez agora é um objeto do tipo string na variável
número. Isso é um fato importante, pois sendo ele uma string não podemos simplesmente, por
exemplo, adicionar mais 2 ao número, veja o que acontece se tentarmos isso:
»> numero + 2
Traceback (most recent call last):
File «stdin>", line 1, in ?
TypeError: cannot concatenate ’str’ and ’int’ objects
Viram? não podemos concatenar objetos de tipos diferentes. Para realizar tal operação tere-
mos mais uma vez utilizar uma função built-in para realizar a operação, veja:
»> int(numero) + 2
12
Neste caso, adicionamos o valor da saída gerada pela função int() com o número 2, como neste
caso, ambos os objetos são do tipo integer, então, a soma é efetuada sem erros.
É importante dizer que não existem apenas as funções str() e int(), existem outras que também
são definidas pela linguagem, vamos utiliza-las aos poucos para que o seu uso se torne natural.
Vamos mostrar agora a outra função de entrada padrão, o input(). Apenas para exemplificar o
que citamos, veja como realizaríamos o mesmo login feito acima:
»> user = input("Entre com seu login: ")
Entre com seu login: root
28

File «string>", line 0, in ?
NameError: name ’root’ is not defined
Estranho não? o python esta dizendo que a variável root não foi definida! Lembra do que foi
falado sobre definir manualmente o tipo? veja agora o exemplo corrigido:
»> user = input("Entre com seu login: ")
Entre com seu login: ’root’
»> user
’root’
Note que foi necessário informar que a entrada era um objeto do tipo string, podemos confirmar
que user realmente é uma string perguntando ao interpretador o tipo da variável com a função
type().
»> type(user)
<type ’str’>
E agora com o exemplo da entrada de um número:
»> numero = input("Digite um numero: ")
Digite um numero: 10
»> numero
10
»> type(numero)
<type ’int’>
Viu? essa é a grande diferença destas duas funções que são utilizadas para entrada padrão
no Python. Lembrem-se que é possível altera o tipo do objeto através daquelas funções built-in.
4.4 Saída de dados
Dando o pontapé inicial que todas as linguagens sempre tem, o nosso querido "Olá Mundo!",
agora com Python!
»> print ’ Ola Mundo Python! ’
Como podemos notar abaixo, a entrada da função print é direcionada para a saída padrão do
sistema, no caso a tela.
Em diversas situações você precisará saber o conteúdo que está em uma variável, sendo as-
sim, você poderá utilizar a função print para esta tarefa.
Além desta possibilidade de usar o print, dentro do interpretador do Python não é necessário
o seu uso, pois caso seja utilizado somente o nome da variável, o Python automaticamente en-
tenderá que você deseja mostrar o seu conteúdo e teremos a mesma saída de quando usamos
o print. Veja:
29

»> myString = ’Ola Mundo Python! ’
»> print myString
Ola Mundo Python!
»> myString
’Ola Mundo Python!’ ’Ola Mundo Python! ’
A utilização da função print não está restrita apenas ao objeto do tipo string, mas também a
outros objetos, veja:
»> print ?%s is number %d!? % (?Python?,1)
Python is number 1!
Na realidade, a função print possui uma abstração no campo dos objetos, ou seja, não importa o
tipo que for passado, ele será colocado na saída padrão, desde que uma regra seja respeitada,
todos os objetos devem ser do mesmo tipo. Por exemplo:
»> print 20
20
»> print 10+39
49
»> print "python"+ "= cobra"
python = cobra
Agora veja o que acontece se tentamos misturar objetos de tipos diferentes:
»> print "Python "+ 1938
TypeError: cannot concatenate ’str’ and ’int’ objects
Ou seja, um erro na tentativa de concatenar objetos do tipo string e integer. Para corrigirmos
o erro deste exemplo bastava transformarmos o ’1938’ em um objeto do tipo string:
»> print "Python "+ str(1938)
Python 1938
Preste atenção na função built-in str(), ela converte um objeto de entrada em um objeto string
de saída.
4.5 Tipos - Números
Python, assim como qualquer outra linguagem de programação tem tipos pré-deﬁnidos e va-
mos apresentá-los agora mesmo as vocês:
• numérico
• strings
30

• listas e tuplas
• dicionários
Vamos analisar cada um destes tipos separadamente a seguir. Vamos começar com os tipos
numéricos:
Os tipos numéricos em Python estão divididos em:
• integer (inteiros)
• long (inteiros longos)
• float (números reais, ou ponto flutuante)
• complex (números complexos)
Os inteiros são conhecidos na maioria das linguagens de programação e são a representação
numérica dos números inteiros N. O inteiro em Python é um pouco maior que o inteiro do C/C++.
Vejamos um pequeno exemplo de uso de inteiros em uma variável.
»> numero = 10
»> print numero
10
»> type(numero)
<type ’int’>
Como vocês devem estar lembrados de aulas anteriores, o type() retorna o tipo de uma variá-
vel. O uso de um inteiro tem a sua utilidade e é importante saber, mas não vamos nos aprofundar
em algo tão simples, vamos ver os outros tipos.
A existência do tipo long se deve principalmente pelo limite que o int possui, então quando seu
programa for utilizar um número muito maior que o limite de 2 mil casas, utilize então um inteiro
do tipo long, veja nosso exemplo apenas para saber como definir uma variável com um longo:
»> numero = 10L
»> type(numero)
<type ’long’>
Tudo o que precisamos fazer é colocar um L após o inteiro e isso já definirá que o nosso va-
lor é um inteiro longo.
Agora vamos adentrar no mundo dos números reais e suas representações com casas deci-
mais. Em Python os números reais são representados como números em ponto flutuante. Mas o
que isso quer dizer? quer dizer que o ’.’ que representa o início das casas decimais flutua dentro
do número. A representação para este tipo numérico é o que chamamos de float e para definir
que uma variável contém um tipo float apenas devemos colocar o ’.’ (ponto) seguido de alguma
quantidade de posições decimais, vejamos:
»> numero = 10.0
31

»> type(numero)
<type ’float’>
»> numero = 10.23
»> type(numero)
<type ’float’>
Apenas para que a brincadeira fique mais divertida note (se não notaram) que a variável nu-
mero esta tendo o seu tipo alterado toda hora, e é isso que torna Python uma linguagem mais
dinâmica que outras, mas vamos voltar ao assunto.
Veja que agora temos um número em float e com esse tipo podemos alcançar muito mais nú-
mero que com um int ou long. Além de podermos trabalhar com casas decimais. Agora vale um
aviso que vocês vão notar, existe um pequeno erro de precisão que é utilizado para manter a coe-
rência principalmente por causa do alto nível de abstração da linguagem, então não se assustem
se virem algo como isso:
»> 0.1
0.10000000000000001
Isso porque a impressão automática do Python converte automaticamente a saída do interpreta-
dor padrão em string usando a função str() já conhecida.
Mas não precisa ficar preocupado, isso não é realmente um problema.
Para ser considerado um float, o número deve possuir um ponto e uma casa decimal, mesmo
que seja zero. O fato de ser considerado um float é importante para a operação divisão, pois
dependendo do tipo dos operandos, a divisão é inteira ou em ponto flutuante.
»> 5 / 2 # divisão inteira, resultado inteiro
2
»> 5 / 2.0 # divisão em ponto flutuante
2.5
»> 5 * 2.13
10.649999999999999
Finalmente vamos ver os números complexos. Acredito nunca ter visto outra linguagem de pro-
gramação que tivesse este tipo nativamente sem alguma adição de biblioteca ou componente, e
Python faz isso.
O tipo complex representa o conjunto dos números complexos da matemática que conhecemos
e é facilmente representado em Python, veja:
»> numero = 10 + 3j
»> type(numero)
<type ’complex’>
Ao definir uma variável como complexa ela passa a ter principalmente 2 atributos muito importan-
tes, o imag e o real, veja:
32

»> numero.real
10.0
»> numero.imag
3.0
Com eles podemos acessar a parte real e imaginária do número complexo. Note uma coisa
importante, a parte imaginária é deﬁnida pela letra j.
Bem, até a próxima aula, onde veremos o que podemos fazer com uma string.
4.6 Tipos - Strings
Vamos começar este módulo dizendo o que é uma string. Em C/C++ temos dois conceitos
importantes que podem ser encaixados neste momento, o conceito de caractere e de conjunto de
caracteres. A diferença explícita nesse caso é o fato do segundo ser um agrupamento do primeiro.
Em Python, todo tipo de conjunto, incluíndo o unitário, de caracteres é dito como uma string,
e o que isso quer dizer?? a priori que tanto faz declararmos um conjunto de caracteres com
apenas aspas simples como usando aspas duplas. Exemplo:
variavel = ’Ola mundo!’
print variavel
Ola mundo!
E da mesma forma:
variavel = "Ola mundo!"
print variavel
Ola mundo!
com certeza você deve estar rindo dos desenvolvedores do Python, se perguntando o porque
de duas representações para uma mesma coisa, mas é ai que você se engana meu caro leitor,
e se a nossa string contivesse uma aspas simples para dar enfase a uma palavra por exemplo,
vejamos:
variavel = ’Estamos estudando ’Python”
^
SyntaxError: invalid syntax
Viu? o fato de colocar duas vezes as aspas é um problema, mas como soluciona-lo?
Bem, ai esta a função das aspas duplas. Veja como ﬁcaria o exemplo acima:
variavel = "Estamos estudando ’Python’"
print variavel
Estamos estudando ’Python’
e não teríamos mais a confusão das aspas simples duplicadas. Bem, para efeito de conheci-
mento existe outra forma de solucionar este problema, que é proteger as aspas do ’Python’ com
33

barras invertidas , não entendeu? veja:
print variavel
Estamos estudando ’Python’
contudo esta forma é um tanto quanto confusa dependendo do que você esta atribuindo a sua
variável. A limpeza de código é uma arte muito desejável em qualquer programador.
Assim como em C/C++, podemos usar os caracteres especiais de controle para que nossa saída
tenha a forma que quisermos. Por exemplo, poderíamos querer tabular ou adicionar uma linha em
branco a mais em uma saída e podemos faze-lo apenas adicionando estes caracteres. Abaixo
temos uma tabela com os caracteres de controle mais utilizados:
Caracter Função
a Emite um sinal sonoro
b Equivalente a um backspace
n Nova linha
t Uma tabulação
f Avança uma linha de texto
Imprime a ”
Temos outras, mas que não são tão importantes para nós agora.
Chegamos então a uma implementação especíﬁca de Python para as strings, as aspas triplas.
Quando um texto esta entre aspas triplas, Python entende como uma entrada de texto que não
deve ser formatada, o que quero dizer com isso? Que todo texto entre este tipo de aspas vai ser
impresso da forma como for digitada.
Exemplo:
var = ”’Programa Exemplo:
Para usar este programa:
exemplo.py <entrada> <saida> [opcional]
Onde:
entrada É um arquivo de entrada do programa
saida É um arquivo de saída do programa
opcional É um valor 0 ou 1 dependendo do objetivo
GNU/GPL”’
print var
Programa Exemplo:
Para usar este programa:
exemplo.py <enrtada> <saida> [opcional]
34

Onde:
entrada É um arquivo de entrada do programa
saida É um arquivo de saída do programa
opcional É um valor 0 ou 1 dependendo do objetivo
GNU/GPL
Como podemos ver, todos os espaços, tabulações, tudo foi impresso da forma como digitamos
dentro das aspas triplas na variável var.
E não é só isso, vamos brincar com o que as strings tem de melhor, as operações sobre strings.
4.7 Operações sobre Strings
Existem algumas operações que são suportadas quando trabalhamos com as strings, e duas
são muito interessantes, a soma e a multiplicação de strings. Quando uma variável é uma string,
um objeto do tipo string é atribuído então a esta variável. Isso quer dizer que temos métodos
neste objeto que podemos utilizar para manipular nossa string.
Vamos ver como funciona a concatenação (soma) de strings:
»>"Curso"+ "de "+ "Python"
’Curso de Python’
Esta operação é uma sobrecarga sobre a operação de soma, que em chamadas de métodos
ﬁcaria assim:
»>"Curso".__add__("de ".__add__("Python"))
’Curso de Python’
Como vimos, a operação de soma é uma sobrecarga sobre o método __add__(). Mas não é
só isso, o objeto string tem diversos outros métodos, e alguns são muito conhecidos dos progra-
madores em C/C++ contidos na biblioteca string.h. Antes que nós mostremos uma tabela com
alguns objetos interessantes, vamos ver mais alguns operações.
Como comentamos acima, a multiplicação também é uma operação muito divertida! Vejamos
como podemos utiliza-la:
»>print ’<’ + ’Python’ * 3 + ’>’
<PythonPythonPython>
O fato de multiplicarmos uma string por um número faz com que __mul__() seja sobrecarre-
gado gerando uma nova string que é n vezes a string original.
Mas não é só isso, uma das operações sobre strings que mais gosto é o split(), este método
’quebra’ a string original nas palavras que a string contém, veja:
35

»>"Curso de Python".split()
[ Curso , de , Python ]
Viu? nossa string foi quebrada em três palavras (que também são strings) em uma lista.
Poderiamos estar usando uma string como argumento dentro do método split, por exemplo:
»> "banana".split("a")
[ b , n , n , ]
Agora a operação final, aquela que vai acabar de vez com suas dúvidas, aquela que vai fazer
você amar Python! A operação de SLICE.
Variáveis que contém objetos do tipo string podem ter os seus textos cortados da forma que
o programador quiser, o que quero dizer quando falo em cortar? vejamos:
»> "Curso de Python"[1 : 6]
’urso ’
»> "Curso de Python"[9 :]
’Python’
»> "Curso de Python"[: 9]
’Curso de ’
Isso é muito legal, podemos ter nossa string quebrada ou cortada aonde quisermos, como isso
funciona? Entenda da seguinte forma:
Uma string pode ser cortada usando do seguinte princípio:
STRING [incio : fim]
Onde início é o número da posição do caractere onde o corte começa e fim é o número da
posição do último caractere. Apenas um detalhe, o caractere da posição fim é suprimido.
Quando um dos valores início ou fim é desconsiderado, o fim ou o início da string será o va-
lor adotado por padrão. Ou seja STRING[0 : len(STRING)]. Não tinhamos visto esse len()
antes, bem, ele retorna a quantidade de caracteres em uma string ou a quantidade de objetos em
uma lista.
Vamos finalmente a uma tabela com todos os métodos que podem ser utilizados sobre as strings,
para isso dentro do interpretador do Python, digite:
»> help(str)
36

4.8 Substituição em strings: o operador de porcentagem
Uma operação muito útil para processamento de texto é a substituição de símbolos em strings.
É particularmente adequada para gerarmos strings formatadas contendo algum valor variável,
como o clássico formulário: "Nome: Idade: anos".
1. Escreve-se a string normalmente, usando um símbolo especial no lugar da lacuna:
• %d: para substituir inteiros
• %f: para substituir ﬂoats
• %s: para substituir outra string
»> a = "Total de itens: %d"
»> b = "Custo: %f"
2. Para efetuar a substituição, aplica-se um operador % sobre a string contendo o símbolo de
formatação, seguido do valor ou variável a substituir:
»> print a % 10
Total de itens: 10
Como pode ser visto, o símbolo é substituído pelo valor fornecido. Podem ser utilizados tanto
valores explícitos quanto variáveis para a substituição:
»> custo = 5.50
»> print b % custo
Custo: 5.500000
Caso sejam múltiplos valores a substituir, use uma tupla:
»> print "Cliente: %s, Valor %f"% ("hungry.com", 40.30)
Fornecedor: hungry.com, Custo 40.300000
Este operador permite ainda utilizar um número junto ao símbolo porcentagem para reservar
um tamanho total à string:
»> a = "Quantidade: %4d"
»> print a % 3
»> print a % 53
»> print a % 120
Quantidade: 3
Quantidade: 53
Quantidade: 120
É possível controlar a formatação de tipos numéricos de maneira especial através de modiﬁ-
cadores nos símbolos no formato m.n. Como acima, m indica o total de caracteres reservados.
37

Para ﬂoats, n indica o número de casas decimais; para inteiros, indica o tamanho total do número,
preenchido com zeros à esquerda. Ambos os modiﬁcadores podem ser omitidos.
»> e = 2.7313
»> p = 3.1415
»> sete = 7
»> print "Euler: %.7f"% e # 7 casas decimais
Euler: 2.7313000
»> print "Pi: %10.3f"% p # 10 espaços, 3 casas
Pi: 3.142
»> print "Sete: %10.3d"% sete # 10 espaços, 3 dígitos
Sete: 007 # (é um inteiro)
38

4.9 Mais sobre Strings
Podemos utilizar alguns métodos sobre strings como os abaixo:
x.capitalize() Deixa a primeira inicial maiúscula.
x.count() Procura quantas ocorrências da busca existem na String.
x.startswith() Verifica se a String inicia com determinado caractere,
retornando verdadeiro ou falso.
x.endswith() Verifica se a String termina com determinado caractere,
retornando verdadeiro ou falso.
x.isalnum() Verifica se a String tem conteúdo alfa-numérico
x.isalpha() Verifica se a String tem o conteúdo apenas alfabético
x.islower() Verifica se a String tem o conteúdo minúsculo.
x.isupper() Verifica se a String tem o conteúdo em maiúsculo
x.lower() Converte o conteúdo da String para minúsculo.
x.upper() Converte o conteúdo da String para maiúsculo.
x.swapcase() Inverte a situação da String.
x.title() Converte para maiúscula todos os primeiros caracteres da
String.
? ?.join() Une duas ou mais strings utilizando um delimitador.
x.split() Corta a String em uma lista, utilizando o espaço como
delimitador.
x.split(?;?) Corta a String em uma lista, utilizando o ponto-e-vírgula
como delimitador.
x.ljust(tamanho) Ajusta a String para a esquerda utilizando um tamanho
determinado.
x.rjust(tamanho) Ajusta a String para a direita utilizando um tamanho
determinado.
x.center(tamanho) Ajusta a String para o centro utilizando um tamanho
determinado.
x.lstrip() Remove os espaços em branco do lado esquerdo de uma String.
x.rstrip() Remove os espaços em branco do lado direito de uma String.
x.strip() Remove todos os espaços em branco de uma String
x.find(parâmetro) Procura por uma ocorrência de determinado caractere em um
String, e retorna o seu endereço dentro da String. Retornando -1
indica que não existe tal caractere na String.
x.replace(busca,substitui) Procura por um caractere e substitui por outro.
Não se esqueça que você pode estar utilizando mais de um método por vez, por exemplo:
»> "EXEMPLO".lower().capitalize()
’Exemplo’
39

Capítulo 5
Operadores
Faça atribuições, operações lógicas e aritméticas, entre outras.
5.1 Operadores de Atribuição
Python é uma linguagem como qualquer outra neste ponto. Toda linguagem tem que possuir
operadores pois isto é, de certa forma, o coração da programação.
Temos cinco tipos principais de operadores, os aritméticos, os lógicos, os relacionais, o de atri-
buição e os bit-a-bit. Os aritméticos são os utilizados para realizar operações matemáticas com
objetos numéricos, os lógicos se utilizam destes objetos para conseguir relações que possam ser
conectadas e os relacionais referem-se à forma como os valores podem se relacionar.
O operador de Atribuição não requer grandes comentários, ele apenas atribui o valor mais a
direita de uma expressão para a variável ou variáveis a esquerda da expressao. Exemplo:
»> numero = 10
»> print numero
10
5.2 Operadores Aritméticos
Na tabela abaixo veremos como a precedência matemática é respeitada no python:
Operador Ação
- Subtração
+ Adição
* Multiplicação
/ Divisão
% Módulo da divisão
** Exponenciação
Estes são os principais operadores e são utilizados na mesma forma que o são na matemá-
tica. Vamos ver alguns exemplos:
40

»> 1 + 3
4
»> 4 - -2
6
»> soma = 1 + 1
»> soma + 7
9
»> soma / 2
1
»> soma % 2
0
»> soma += 1
»> soma % 2
1
»> 2**3
8
Estes exemplos demonstram bem o uso dos operadores aritméticos.
5.3 Operadores Relacionais
Agora vamos aos Operadores Relacionais.
Vamos ver então a tabela dos operadores relacionais reconhecidos pelo python:
Operador Ação
> Maior que
>= Maior que ou igual
< Menor que
<= Menor que ou igual
== Igual
<> Diferente
!= Diferente
Para facilitar a migração das mais diferentes linguagens, python aceita duas formas para o
operador de diferença. Podemos realizar alguns teste dentro do interpretador que retornará False
quando a operação for false ou True quando for verdadeira, veja:
»> 1 > 2
False
»> 2 >= 2
True
»> 3 == 4
False
»> 3 != 4
True
»> 3 <> 4
True
41

»> 3 > 2 > 1
True
As expressões são testadas em tempo real, sendo avaliadas da direita para a esquerda, e um
objeto do tipo boolean é retornado pelo interpretador.
5.4 Operadores Lógicos
Faltam nos apenas dois tipos de operadores, os lógicos e os bit-a-bit. Vejamos os lógicos.
Operações lógicas envolvem lógica matemática e tem 3 operadores importantes, veja na tabelas
quais são:
Operador Ação
and E lógico
or OU lógico
not NÃO lógico
Estes operadores são geralmente utilizados em expressões lógicas de testes de expressão,
vamos ver alguns exemplos:
»> a = 10
»> b = 20
»> c = 30
»> if a < b and c >= a:
... print "%d menor que %d e %d maior ou igual a %d"% (a,b,c,a)
...
10 menor que 20 e 30 maior ou igual a 10
»> if a > b or c >= a:
... print "entrei por que uma relacao ou outra foi verdadeira"
...
entrei por que uma relacao ou outra foi verdadeira
Não se preocupe com a sintaxe do if, veremos isso com mais calma, mais para frente. Veja
que as operações lógicas são muito importantes.
5.5 Operadores Bit a Bit
Finalmente as Operações Bit-a-Bit.
Operação bit-a-bit são utilizadas para, principalmente dois ﬁns: programação de hardware (in-
terface software-hardware) ou para otimização do código em operações mais rápidas.
Vejamos então a tabela dos operadores para este tipo de operação:
42

Operador Ação
& AND
~ OR
^ OR exclusivo (XOR)
Complemento de um
» Deslocamento à esquerda
« Deslocamento à direita
Lembrando que para operar com estes operadores devemos estar cientes que as operações
serão realizadas em cada bit dos números em questão. Vamos ver alguns exemplos:
# cada bit deslocado para à direita equivale à dividir por 2
»> 4 » 1
2
# cada bit deslocado à esquerda equivale à multiplicar por 2
»> 4 « 1
8
»> 4 & 1
0
»> 4 | 1
5
»> 4 ^1
5
»> ~4
-5
Como vemos nos exemplos, o deslocamento à esquerda signiﬁca divisão por 2n, onde n é o
valor que deve ser deslocado, ou seja, se queremos dividir por 2, devemos deslocar 1, se quere-
mos dividir por 4, devemos deslocar 2, pois 4 é 22, o mesmo vale para o deslocamento à direita,
que equivale a uma multiplicação por 2n pelo mesmo motivo do deslocamento à esquerda. Va-
mos então ver o porque dos outros resultados do exemplo, lembrando que o 4 em binário é 100,
quando realizamos a operação de &:
100
001 &
=000
Temos como resposta 0. Agora para o | e para o ^, que possuem a mesma resposta neste
caso, temos o seguinte:
100
001 |
=101
Que é igual a 5. Viu como operações bit-a-bit podem ser interessantes?
43

Capítulo 6
Estruturas de Controle
Controle o fluxo dos dados
6.1 Introdução
Estruturas de controle permitem diferentes tipos de fluxo durante a execução do seu programa.
Por exemplo, você pode desejar que seu programa imprima uma mensagem de "Bom dia"ou "Boa
noite"de acordo com o horário do dia. Pode querer também que o usuário digite uma palavra
secreta para utilizar seu programa, caso contrário é redirecionado para uma seção de erro.
6.2 if, else e elif
A instrução if é a mais básica estrutura de controle de fluxo quando se esta programando. Em
Python ficaria:
if condicao:
faça algo
O bloco faça algo pode conter qualquer instrução ou bloco de instrução válido no Python. A
parte de condição pode incluir um operador de comparação. Vamos iniciar mostrando o mais
básico dos operadores, o de igualdade: ==. Um uso comum desse operador é testar se uma
variável tem um determinado valor, como no exemplo:
if i == 1:
faça algo
Podemos testar se uma determinada variável é menor ou maior que um número, utilizando os
operadores > ou <
if i > 5:
faça algo
Podemos ter um controle maior da estrutura, utilizando opcionalmente as instruções elif e else
44

if condição :
faça algo
elif condição :
faça algo
elif condição :
faça algo
...
else :
faça algo
Exemplo:
x = int(raw_input("Entre com um inteiro:"))
if x < 0:
x = 0
print ’Negativo mudado para zero’
elif x == 0:
print ’Zero’
elif x == 1:
print ’Um’
else:
print ’Mais’
Neste caso, a instrução que satisfazer a condição será executada. Em último caso, se nenhuma
das instruções anteriores for executada, a instrução else sempre será executada.
Observação: No Python não existe o comando switch como nas linguagens Java e C/C++. Neste
caso, podemos ter o mesmo comportamento utilizando os comandos if, else e elif.
6.3 for
A estrutura for..in é uma estrutura de looping que itera sobre cada sequência de objeto, ou
seja, percorre cada item em sequência.
Exemplo:
for cadaNumero in [0, 1, 2, 3, 4, 5, 6, 7]:
print cadaNumero
0
1
2
3
4
5
6
7
Exemplo:
print ’Eu gosto de utilizar a internet para :’
45

Eu gosto de utilizar a internet para :
for item in [ e − mail , net − surfing , chat ]:
print item
email
net-surﬁng
chat
O Python tem um funcao built-in que gera uma lista, a funcao range().
Exemplo:
for i in range(1,5):
print i
else:
print ’Fim do looping...’
1
2
3
4
Fim do looping...
A função range()
Esta função é muito importante quando queremos gerar uma lista de números. Sua sintaxe é:
range(ni,nf,i) onde ni = número inicial, nf = número ﬁnal e i = incremento.
Exemplo:
»> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
»> range(1,10)
[1, 2, 3, 4, 5, 6, 7, 8, 9]
»> range(1,10,2)
[1, 3, 5, 7, 9]
Podemos utilizar o range dentro de um for da seguinte maneira:
Exemplo:
for numero in range(1,10):
print numero*2
2
4
6
8
10
12
14
16
18
46

6.4 while
A estrutura while permite executar um bloco de comandos enquanto a condição for verdadeira.
O padrao da instrucao de condicao while, pode-se considerar similar ao if.
while expressao:
instrução
Exemplo:
counter = 0
while counter < 5:
print ’loop #%d’ % (counter)
counter = counter + 1
loop #0
loop #1
loop #2
loop #3
loop #4
Opcionalmente, podemos ter uma condição else no looping while
Exemplo:
x = 0
while x < 5:
x = x + 1
print "Valor de x = ", x
else:
print "Saindo do looping..."
Valor de x = 1
Valor de x = 2
Valor de x = 3
Valor de x = 4
Valor de x = 5
Saindo do looping...
6.5 break e continue
O break quebra o laço mais interno de um for ou while.
Exemplo:
ss = 1
while True:
print ss,
if (ss == 9):
break
print ",",
ss = ss + 1
1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9
47

O continue continua o próximo passo do laço mais interno.
Exemplo:
for x in range(8):
if x%2 == 0:
continue
print x
1
3
5
7
48

Capítulo 7
Estrutura de Dados
7.1 Listas
Lista é uma seqüencia de valores que utilizamos no Python. Listas são dinâmicas, o que pos-
sibilita adicionarmos ou removermos valores uma vez que a lista for criada.
Uma lista possibilita conter valores inteiros(int), strings, ﬂoat ou qualquer outro tipo de objeto.
Podemos utilizar o mesmo método de mapeamento de endereços que utilizamos nas strings.
»> lista = [1, 2, 3]
»> lista
[1, 2, 3]
»> lista[0]
1
»> lista[−1]
3
Onde o endereço 0 (lista[0])da lista é 1. Podemos também pegar vários valores de uma lista
e concatena-los. Ex:
»> lista[0]+lista[1]
Nesse caso, somamos o valor do endereço 0 de lista para o valor do endereço 1 de lista. Se
adicionarmos um valor diretamente a lista, retornaremos um erro, pois não é possível adicionar
valores diretamente a lista, sendo necessário utilizarmos outro método.
»> lista+22
File «pyshell#134>", line 1, in -toplevel-
lista+22
TypeError: can only concatenate list (not "int") to list
Porém se ﬁzermos lista+[22] adicionaremos o valor a lista.
»> lista = lista+[22]
49

[1, 2, 3, 22]
Vamos ver os valores da lista:
»> lista
[1, 2, 3, 22]
Também podemos utilizar o endereçamento da lista ou o método append. Por exemplo, modi-
ﬁcar o endereço 0 que contém o valor 1 para fábio:
»> lista[0] = "Fabio"
»> lista
[ Fabio , 2, 3]
Se tentarmos adicionar outro endereço utilizando endereçamento, teremos um erro, pois devere-
mos utilizar o append para adionar itens a lista.
»> lista[3] = "Rizzo"
lista[3] = "Fabio"
IndexError: list assignment index out of range
Agora utilizando o método append:
»> lista.append("Matos")
»> lista
[ Fabio , 2, 3, Matos ]
7.2 Outros métodos de Listas
Existem outros métodos de adicionar valores a listas. Veja abaixo:
»> lista
[ Fabio , 2, 3, Matos ]
»> lista.insert(1,"Rizzo")
»> lista
[ Fabio , Rizzo , 2, 3, Matos ]
Utilizando a forma acima, podemos deﬁnir em qual endereço queremos adicionar o valor de-
sejado. No caso acima, inserimos Rizzo no endereço 1 da lista.
Outro método utilizado é o extend, que é utilizado para adicionarmos mais que 1 valor, ou princi-
palmente para adicionarmos uma lista inteira a outra lista. Veja:
»> lista = [”Fabio”, ”Rizzo”, ”Matos”]
»> lista2 = [”Azul”, ”Preto”]
50

»> lista.extend(lista2)
»> lista
[ Fabio , Rizzo , Matos , Azul , Preto ]
Se nós tivéssemos utilizado o método append nesse caso teriamos uma lista contendo outra
lista. Veja:
»> lista = [”Fabio”, ”Rizzo”, ”Matos”]
»> lista.append(lista2)
»> lista
[ Fabio , Rizzo , Matos ,[’Azul’, ’Preto’]]
E quando chamasse-mos o valor 3 lista, teriamos uma lista como resposta e não somente Azul:
»> lista[3]
[ Azul , Preto ]
»> len(lista)
4
Mais com o método extend, teriamos o azul como resposta.
»> lista[3]
’Azul’
»> len(lista)
5
Veja que o len nos mostrou valores diferentes, pois com o append a lista2 é apenas um valor
dentro de uma lista diferente do extend que adiciona a lista2 como vários valores.
Para removermos algum valor da lista temos alguns métodos. Veja:
»> lista
[ Fabio , Rizzo , Matos , Azul , Preto ]
»> lista.remove("Preto")
»> lista
[ Fabio , Rizzo , Matos , Azul ]
»> lista.pop()
’Azul’
Dessa forma removeremos um valor que existe em nossa lista. E o método lista.pop() por de-
fault remove o ultimo valor, porém é possível adicionar um endereço a ser removido:
»> lista
[ Fabio , Rizzo , Matos ]
»> lista.pop(1)
’Rizzo’
»> lista
[ Fabio , Matos ]
51

Se tentarmos remover um valor que não está na lista, teremos o seguinte retorno:
»> lista.remove("Amarelo")
lista.remove("Amarelo")
ValueError: list.remove(x): x not in list
Para saber se tal valor existe dentro de uma seqüencia, basta fazer o seguinte:
»> "Amarelo"in lista
False
Se o valor retornar True significa que temos o valor na lista, caso contrário teremos o valor False
como acima. Lembre-se que é diferenciado letras maiúsculas de minúsculas, de modo que se
você procurar por "Amarelo"será diferente que procurar por "amarelo".
Agora para achar o endereço do valor dentro da lista utilizamos o método index:
»> lista
[ Fabio , Rizzo , Matos , Azul ]
»> lista.index("Azul")
7.3 Mais sobre listas
Temos alguns outros métodos que também podem ser usados em listas:
Método Para que serve
lista.reverse() Reverte a ordem dos valores de uma lista.
lista.count(valor) Conta a quantidade de vezes que determinado valor esta dentro da lista.
lista.sort() Coloca em ordem uma lista que esteja com seus valores bagunçados.
x in lista Verifica se o valor x esta dentro de lista. Retorna True se estiver e False caso não.
len(lista) Conta a quantidade de valores de uma lista.
7.4 Tuplas
Tuplas são listas imutáveis, ou seja, não é possível modificá-la sem antes ter de criar uma
nova. Um exemplo de tupla:
»> tupla = ("fabio","rizzo","matos")
»> tupla
(’fabio’, ’rizzo’, ’matos’)
Tuplas são mais rápidas que listas, e se você pretende ter apenas uma sequência de valores
52

imutáveis, utilize tuplas ao invés de listas.
Tuplas não tem métodos atribuídos a ela, por isso não é possível utilizar nenhum dos métodos de
listas em tuplas.
7.5 Sets
Um set é uma coleção não-ordenada e que não contém duplicações de elementos. O uso
básico reside em eliminar entradas duplicadas e possibilitar operações matemáticas como união,
interseção e diferença.
»> frutas = [ banana , maca , laranja , banana , pera , laranja ]
»> resultado = set(frutas)
»> resultado
set([ pera , laranja , banana , maca ])
»> ’laranja’ in resultado
True
Podemos também eliminar duplicatas em uma palavra:
»> a = set(’asdadasdad’)
»> a #letras únicas em a
set([ a , s , d ])
»> b = set(’abcbcdyyx’)
»> b #letras únicas em b
set([ a , c , b , d , y , x ])
»> b - a #letras em b que não estão em a
set([ y , x , c , b ])
»> b | a #letras em b ou em a
set([ a , c , b , d , y , x , s ])
»> b & a #letras em b e em a
set([ a , d ])
»> b ^a #letras em a ou em b, mas não nos dois
set([ y , x , s , b , c ])
7.6 Dicionário
Dicionário é um tipo de dado que permite criar uma relação entre chaves e valores. O sistema
de localização dos valores ﬁca atribuido as chaves, e é por ela que devemos procurar os valores.
»> cadastro=’Nome’:’Fabio Rizzo’,’idade’:’22’
»> cadastro
’idade’: ’22’, ’Nome’: ’Fabio Rizzo’
53

No exemplo acima deﬁnimos a chave nome o valor Fabio Rizzo e a chave idade o valor 22.
»> cadastro[ idade ]
’22’
»> cadastro[ Nome ]
’Fabio Rizzo’
Vimos acima como ver os valores da chave idade e da chave Nome. Para adicionarmos uma
nova chave e um novo valor fazemos assim:
»> cadastro[ Signo ]="Leão"
»> cadastro
{’idade’: ’22’, ’Signo’: ’Lexe3o’, ’Nome’: ’Fabio Rizzo’}
Dessa forma adicionamos uma nova chave e valor ao dicionário cadastro. E para alterarmos
um valor de uma determinada chave:
»> cadastro
{’idade’: ’22’, ’Signo’: ’Lexe3o’, ’Nome’: ’Fabio Rizzo’}
»> cadastro[ Nome ]="Fabio Rizzo Matos"
»> cadastro
{’idade’: ’22’, ’Signo’: ’Lexe3o’, ’Nome’: ’Fabio Rizzo Matos’}
Atento ao detalhe que os dicionários são case-sensitive, ou seja, temos que perguntar exata-
mente pela sua chave, senão teremos um erro. Ex:
»> cadastro[ nome ]
cadastro[ nome ]
KeyError: ’nome’
Tivemos esse erro porque não existe chave nome e sim Nome.
Para removermos uma determinada chave devemos utilizar o método del. Veja:
»> cadastro
{’idade’: ’22’, ’Signo’: ’Lexe3o’, ’Nome’: ’Fabio Rizzo Matos’}
»> del cadastro[ Signo ]
»> cadastro
{’idade’: ’22’, ’Nome’: ’Fabio Rizzo Matos’}
Ou utilizar o método clear(), que elimina todas as chaves e valores de um dicionário.
»> cadastro
{’idade’: ’22’, ’Nome’: ’Fabio Rizzo Matos’}
»> cadastro.clear()
»> cadastro
54

{}
7.7 Mais sobre dicionários
Existem outros métodos que podem ser usados em dicionários. Veja abaixo:
Método Para que serve
dicionario.keys() Mostra quais chave o dicionário tem.
dicionario.has_key(chave) Verifica se o dicionário tem a chave procurada.
dicionario.itens() Retorna uma lista de tuplas contendo chave e valor.
7.8 Utilizando Listas como Pilhas
Os métodos de lista tornam muito fácil utilizar listas como pilhas, onde o item adicionado por
último é o primeiro a ser recuperado (LIFO: last-in, first-out -> ultimo a entrar, primeiro a sair).
Para adicionar um item ao topo da pilha, use append().
Para recuperar um item do topo da pilha use pop() sem nenhum índice. Por exemplo:
»> stack = [3, 4, 5]
»> stack.append(6)
»> stack.append(7)
»> stack
[3, 4, 5, 6, 7]
»> stack.pop()
7
»> stack
[3, 4, 5, 6]
»> stack.pop()
6
»> stack.pop()
5
»> stack
[3, 4]
7.9 Utilizando Listas como Fila
Você pode também utilizar uma lista como uma fila, onde o primeiro item adicionado é o pri-
meiro a ser recuperado (FIFO: first-in, first-out -> primeiro a entrar, primeiro a sair). Para adicionar
um elemento ao fim da fila utiliza append(). Para recuperar um elemento do início da fila use pop()
com 0 no índice. Por exemplo:
»> queue = [”Eric”, ”John”, ”Michael”]
»> queue.append("Terry") # Adicionando Terry
»> queue.append("Graham") # Adicionando Graham
»> queue.pop(0)
55

’Eric’
»> queue.pop(0)
’John’
»> queue
[ Michael , Terry , Graham ]
7.10 Trabalhando com arquivos
Manter dados gravados em arquivos é uma das formas de persistência de dados. Python
consegue lidar com arquivos de uma forma bem simples e sem complicações.
Como abrir um arquivo
f = open(file_name, access_mode)
»> f=open(’/tmp/workfile’, ’w’)
»> print f
<open file ’/tmp/workfile’, mode ’w’ at 80a0960>
file_name e uma variavel que contem uma string do nome do arquivo que desejar abrir, e ac-
cess_mode é o modo com que o arquivo será aberto.
access_mode Para que serve
w abre arquivo para escrita (cria um novo arquivo caso não exista)
w+ abre arquivo para escrita e leitura (cria um novo arquivo caso não exista)
r abre um arquivo para leitura (é o padrão, portanto não precisamos especificar
obrigatoriamente)
a abre um aquivo para escrita com o cursor no final do arquivo (serve para
concatenar conteudo)
a+ abre um aquivo para escrita e leitura com o cursor no final do arquivo (serve
para concatenar conteudo)
Para ler o conteúdo de um arquivo, chame a função read(tamanho), que le uma quantidade
de dados e retorna como uma string. tamanho é um argumento numérico opcional. Quando o
argumento tamanho é omitido ou negativo, é retornado o conteúdo inteiro do arquivo. Se o final
do arquivo for atingido, a função read() retorna uma string varia . Exemplo:
»> f.read()
’Arquivo inteiro.012’
»> f.read()
"
readline() le uma linha de um arquivo e retorna uma string com o caractére ’n’ no final. Caso
seja a última linha do arquivo, a string retornada é vazia, sem o ’n’ no final. Exemplo:
»> f.readline()
’Primeira linha do arquivo.012’
56

»> f.readline()
’Segunda linha do arquivo012’
»> f.readline()
readlines() utiliza readline() repetidamente, e retorna uma lista contendo o dado de cada todas as
linhas do arquivo.
»> f.readlines()
[Primeiralinhadoarquivo.012 , Segundalinhadoarquivo012 ]
write(string) escreve o conteudo de uma string no arquivo.
»> f.write(’Este e um testen’)
Quando você terminar de manipular o arquivo, utilize a função close() para fechar o arquivo e
liberar os recursos que foram utilizados ao se abrir o arquivo. Lembre-se que uma vez fechado o
arquivo, qualquer tentativa de usá-lo novamente irá falhar.
Exemplo:
»> f.close()
»> f.read()
Traceback (innermost last):
ValueError: I/O operation on closed file
Agora vamos ver alguns exemplos completos:
Exemplo:
filename = raw_input(’Entre com o nome do arquivo: ’)
file = open(filename, ’r’)
allLines = file.readlines()
file.close()
for eachLine in allLines
print eachLine
Exemplo:
# Copia o conteúdo de um arquivo para outro
# Abre arquivos para leitura e escrita
inp = open("entrada.txt","r")
outp = open("saida.txt","w")
# Le o arquivo e copia cada linha para o arquivo de saída
for line in inp:
outp.write(line)
print "Arquivo copiado..."
# Fecha os arquivos
57

inp.close()
outp.close()
58

Capítulo 8
Funções
Organizando o seu programa
8.1 Introdução
Funções são pedaços de programa reutilizáveis. Elas permitem que você de um nome para
um conjunto de instruções, e que você possa rodar este conjunto de instruções simplesmente
chamando o nome dado.
8.2 Criando e chamando uma Função
Como declarar uma Função
def nome_da_funcao([argumentos]):
"documentação opcional para a função"
bloco_da_funcao
Funções em Python são deﬁnidas utilizando se a palavra def, seguido do nome que irá identi-
ﬁcar a função, seguido de 0 ou mais argumentos que estarão entre chaves. Em seguida, temos o
bloco da função, que irá conter o código que aquela função executa.
def addMe(x):
"Aplicar a operacao com o argumento"
return (x + x)
Como chamar uma Função
»> addMe(4.25)
8.5
»> addMe(10)
20
59

»> addMe(’Python’)
’PythonPython’
»> addMe([−1, abc ])
[−1, abc , −1, abc ]
8.3 Variáveis locais x globais
Variáveis locais
Quando você declara variáveis dentro de uma função, elas não estão relacionadas com outras
variáveis que tenham o mesmo nome mas estejam fora da função. Ou seja, as variáveis são
locais à função. Isto também é conhecido como escopo da variável. Todas as variáveis tem o
escopo do bloco em que foi declarado, ou seja, só é visível para aquele trecho de código.
»> def func(x):
... print "Valor de x = ", x
... x = 10
... print "Valor de x local mudado para", x
...
»> x = 50
»> func(x)
Valor de x = 50
Valor de x local mudado para 10
»> print "valor de x externo = ", x
valor de x externo = 50
No exemplo acima, podemos ver que uma alteração da variável x dentro da função não teve
reflexos fora dela, pois o valor da variável x fora da função continuou o mesmo.
Na verdade, a função apenas utilizou o valor da variável passada como parâmetro, e nada mais.
Qualquer alteração da variável dentro da função seria limitada para aquele escopo.
Variáveis globais
Se você quiser que uma variável dentro da função possa modificar uma variável fora dela, você
deve dizer ao Python que esta variável não é local, mas sim, global. Isto é feito através do co-
mando global. É impossível modificar uma variável fora da função sem utilizar o comando global.
»> def func():
... global x
... print "x = ", x
... x = 10
... print "Valor de x global modificado para", x
...
»> x = 50
»> func()
x = 50
60

Valor de x global modiﬁcado para 10
»> print "Valor de x = ", x
Valor de x = 10
8.4 Argumentos padrões
Para algumas funções, você pode querer que alguns dos parâmetros se tornem opcionais e
possuam um valor padrão caso o usuário não entre com nenhum valor para este parâmetro.
Isto é feito através dos argumentos padrões, que nada mais são do que o nome do parâmetro,
seguido do sinal de ’=’, seguido do valor do parâmetro, que deve ser uma constante imutável (seu
valor não pode mudar dentro da função)
»> def msg(mensagem, numVezes = 2):
... print mensagem * numVezes
...
»> msg(’ola’)
olaola
»> msg(’mundo’, 5)
mundomundomundomundomundo
8.5 Argumentos chaves
Se você possui uma função com diversos parâmetros e gostaria de especiﬁcar apenas alguns
deles, então você pode dar valores a eles nomeando-os. Isto é conhecido como argumento chave.
Nós utilizamos o nome do argumento em vez de utilizar a posição dele.
Ao utilizar os argumentos chaves, temos algumas vantagens:
• Utilizar a função se torna mais fácil, já que não temos que nos preocupar com a ordem dos
argumentos
• Apenas damos valor aos parâmetros que achamos necessários, pois os outros podem con-
ter um valor padrão
»> def func(a, b = 5, c = 10):
... print "a =", a, "b =", b, "c =", c
...
»> func(1,2)
a = 1 b = 2 c = 10
»> func(10, c = 15)
a = 10 b = 5 c = 15
»> func(b = 50, a = 10)
a = 10 b = 50 c = 10
61

8.6 Retorno
O comando return é utilizado para retornar um valor, mas pode ser utilizado simplesmente
para sair dela sem retornar um valor. Na verdade, todas as funções que não retornam um valor
explícitamente, retornam o valor None.
»> def testandoRetorno():
... x = 0
... while (True):
... if x > 5:
... return
... print "x = ", x
... x = x + 1
...
»>
»> testandoRetorno()
x = 0
x = 1
x = 2
x = 3
x = 4
x = 5
Neste caso, utilizamos o comando return para sair da função imediatamente. Lembre-se que
caso utilizassemos o comando break, ele apenas sairia do laço mais interno, no caso, o while.
»> def imprime():
... print ’uma mensagem qualquer...’
...
»> print imprime()
uma mensagem qualquer...
None
No exemplo acima, quando imprimimos o nome da função, aparece a mensagem None, indi-
cando o retorno daquela função.
8.7 DocStrings
Python possui um mecanismo interessante para documentar as funções. Além de ser uma
boa forma de documentação e organização, tal documentação pode ser chamada em tempo de
execução através do nome da função seguido de .__doc__.
»> def soma(a, b):
... "Funcao que soma dois numeros"
... return a+b
...
62

»> soma(5,3)
8
»> print soma.__doc__
Funcao que soma dois numeros
8.8 Módulos
Dividindo e conquistando.
8.9 Introdução
Vimos que as funções permitem uma grande reusabilidade do mesmo trecho de código em
diversos pontos do mesmo arquivo.
A medida que seu programa cresce, é desejavel separá-lo em diversos arquivos para facilitar
a manutenção. Neste caso, como fariamos para utilizar uma função em um arquivo B, uma fun-
ção definida no arquivo A?
A resposta é, utilizando-se módulos. Um módulo nada mais é do que um arquivo Python con-
tendo funções e variáveis que poderão ser importadas por outro arquivo que deseje utilizar suas
funcionalidades.
8.10 Criando um módulo
Vamos criar um módulo que defina a função de Fibonacci. Abra o seu editor de texto favorito
e salve o código a seguir em um arquivo chamado ’fibo.py’:
def fib(n): # Imprime a sequencia de Fibonacci até n
"Imprime a sequência de Fibonacci até n"
a, b = 0, 1
while b < n:
print b,
a, b = b, a + b
Agora, entre no interpretador Python e digite:
»> import fibo
Isso faz com que o módulo fibo seja importado, mas não as suas funções. Portanto, para uti-
lizarmos a função definida no módulo, devemos proceder da seguinte maneira:
»> fibo.fib(1000)
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
63

»> fibo.__name__
’fibo’
Repare que o nome do módulo esta disponível ao utilizarmos como valor da variável global
’__name__’
Se você pretende usar a função regularmente, pode fazer o seguinte:
»> fibAux = fibo.fib
»> fibAux(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
Neste caso, estamos atribuindo a variável ’fibAux’ o valor de ’fibo.fib’, que é uma função.
8.11 Mais sobre módulos
Um módulo pode conter segmento executáveis e definições de funções. Essas unidades ser-
vem para inicializar o módulo, e são executadas apenas na primeira vez em que o módulo é
importado algum lugar.
Módulos podem importar outros módulos. Por convenção, geralmente importamos os Módulos
no início do arquivo, mas não é obrigatório.
Temos algumas variações na maneira com que podemos importar módulos. Por exemplo, po-
demos específicar diretamente as funções que iremos importar, isentando assim, a necessidade
de se botar o prefixo do nome do módulo para utilizá-las.
»> from fibo import fib
»> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
Neste caso, estamos apenas importanto uma função (fib) do módulo fibo
»> from fibo import *
»> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
Agora, importamos todos os nomes que o módulo define.
8.12 Módulos Padrões
O Python vem com uma série de módulos na sua biblioteca padrão, vamos mostrar alguns
deles.
Há um grande conjunto de módulos que se instalam juntamente com o interpretador Python;
64

são descritos nesta seção alguns dos mais interessantes.
• sys: oferece várias operações referentes ao próprio interpretador. Inclui: path, uma lista dos
diretórios de busca de módulos do python, argv, a lista de parâmetros passados na linha de
comando e exit(), uma função que termina o programa.
• time: oferece funções para manipular valores de tempo. Inclui: time(), uma função que
retorna o timestamp14 atual; sleep(n), que pausa a execução por n segundos; e strftime(n),
que formata um timestamp em uma string de acordo com um formato fornecido.
• os: oferece funções relacionadas ao ambiente de execução do sistema. Inclui: mkdir(), que
cria diretórios; rename(), que altera nomes e caminhos de arquivos; e system, que executa
comandos do sistema.
• os.path: oferece funções de manipulação do caminho independente de plataforma. Inclui:
isdir(p), que testa se d é um diretório; exists(p), que testa se p existe; join(p,m), que retorna
uma string com os dois caminhos p e m concatenados.
• string: oferece funções de manipulação de string (que também estão disponíveis como
métodos da string). Inclui: split(c, s, p), que divide a string c em até p partições separadas
pelo símbolo s, retornando-as em uma lista; lower(c), que retorna a string c convertida em
minúsculas; e strip(c), que retorna c removendo espaços e quebras de linha do seu início e
ﬁm.
• math: funções matemáticas gerais. Inclui funções como cos(x), que retorna o cosseno de
x; hypot(x, y); que retorna a distância euclidiana entre x e y; e exp(x); que retorna o expo-
nencial de x.
»> import math
»> math.sqrt(6)
2.4494897427831779
»> math.exp(6)
403.42879349273511
»> math.cos(0)
1.0
»> math.pi
3.1415926535897931
»> math.e
2.7182818284590451
»> math.sqrt(4)
2.0
• random: geração de números randômicos. Inclui: random(), que retorna um número randô-
mico entre 0 e 1; randrange(m,n), que retorna um randômico entre m e n; choice(s), que
retorna um elemento randômico de uma seqüência s.
»> import random
»> random.random()
0.50173099332233129
»> random.random()
65

0.79255214694297194
»> random.random()
0.99826060442548059
• getopt: processamento de argumentos de comando de linha; ou seja, os parâmetros que
passamos para o interpretador na linha de execução. Inclui: getopt(), que retorna duas
listas, uma com argumentos e outra com opções da linha de comando.
• Tkinter: um módulo que permite a criação de programas com interface gráﬁca, incluindo
janelas, botões e campos texto.
• urllib2: proporciona uma interface de conexão e tratamento de URLs
»> import urllib2
»> for line in
urllib2.urlopen(’http://www.google.com.br’):
... print line
...
<html><head><meta http-equiv="content-type"content="text/html;
charset=ISO-8859-1»<title>Google</title><style><!– # resto do código omitido
A documentação do Python inclui uma descrição detalhada (e muito boa) de cada um destes
módulos e de seus membros.
Visite também http://docs.python.org/lib/lib.html
8.13 Módulos independentes
Além dos módulos distribuídos com o Python, existem vários módulos auxiliares. Justamente
por serem numerosos e independentemente fornecidos, não é possível descrevê-los na sua tota-
lidade; vou apenas citá-los; podem ser obtidas maiores informações nos links providos.
win32pipe: permite, na plataforma Windows, executar programas win32 e capturar sua saída
em uma string para manipulação posterior. Acompanha a distrubuição Activestate Python:
http://www.activestate.com/Products/ActivePython/
PIL: Python Imaging Library, que oferece funções para processamento, manipulação e exibição
de imagens. http://www.pythonware.com/products/pil/ NumPy: provê mecanismos simples e de
alto desempenho para manipular matrizes multi-dimensionais; ideal para operações numéricas
de alto volume que necessitem de velocidade. http://numpy.sourceforge.net/
HTMLgen: uma biblioteca de classes que gera documentos HTML conforme padrões pré-deﬁnidos.
Oferece classes para manipular tabelas, listas, e outros elementos de formatação.
http://starship.python.net/crew/friedrich/HTMLgen/html/
DB-API: Database Application Programming Interface; na realidade, um conjunto de módulos
66

que acessam bases de dados de uma forma padronizada. A API especifica uma forma homogê-
nea de se fazer consultas e operações em bases de dados relacionais (SQL); diversos módulos
implementam esta API para bases de dados específicas.
http://www.python.org/topics/database/
mx: oferece uma série de extensões à linguagem, incluindo operações complexas de data e
hora, funções nativas estendidas, e ferramentas para processamento de texto.
http://www.egenix.com/files/python/
PyGTK: É outro pacote que permite construir aplicações gráficas com o Python; pode ser usado
em conjunto com o Glade, um construtor visual de interfaces.
http://www.pygtk.org/
wxPython: uma biblioteca de classes que permite construir aplicações gráficas multi-plataforma
usando Python. Há um construtor visual de interfaces disponível, o Boa Constructor.
http://www.wxpython.org/
Todos os módulos citados se comportam como módulos Python ’normais’; são utilizados por
meio da instrução import, e boa parte possui documentação e símbolos internos listáveis.
Esta não é uma lista exaustiva, e há muitos outros módulos úteis; há boas referências que listam
módulos externos,
incluindo o índice de pacotes oficial PyPI:
http://www.python.org/pypi
67

Capítulo 9
Erros e exceções
Mantendo o seu programa robusto
9.1 Introdução
Erros e exceções podem acontecer a qualquer momento no seu programa. Por exemplo, o
que aconteceria se seu programa lesse um arquivo mas ele não existisse, ou se você tivesse
excluído ele acidentalmente no meio do programa? Neste capítulo, veremos como o Python lida
com tais situações, dando chances para que você possa contornar os seus problemas.
9.2 Erros de sintaxe
Também são conhecidos como erros de parsing, e provavelmente são os erros mais frequên-
tes que você ira encontrar enquanto estiver aprendendo a linguagem.
»> while 1 print ’Ola Mundo’
while 1 print ’Ola Mundo’
^
O erro é causado pela instrução que esta imediatamente antes da seta. No exemplo acima, o
erro é detectado na palavra chave print, pois não temos os dois pontos ’:’ imediatamente antes
da instrução.
»> Print ’ola mundo’
Print ’ola mundo’
^
Neste caso, o erro esta no comando Print, que deveria ser print. Não se esqueça que o Python
diferencia maiúsculas de minúsculas (case sensitive).
68

9.3 Exceções
Erros que são detectados em tempo de execução são chamados de exceções. Com as ex-
ceções, programadores podem rapidamente debugar suas aplicacoes como uma boa pratica de
melhorar o aplicativo desenvolvido, podendo antecipar e simular erros que poderao acontecer. A
maioria das exceções não são tratadas, resultando em mensagens de erros como no exemplo a
seguir:
# Divisão por 0
»> 10 * (1/0)
ZeroDivisionError: integer division or modulo
# Tentativa de somar string com inteiro
»> ’2’ + 2
TypeError: illegal argument type for built-in operation
A ultima linha da mensagem de erro indica o que ocorreu. Exceções podem ser de diferentes
tipos (ZeroDivisionError e TypeError para os nossos exemplos). Vemos que logo após o tipo do
erro, temos uma mensagem indicando o que houve com maiores detalhes.
9.4 Tratamento e disparo(raise) de exceções
Podemos tratar as exceções utilizando as cláusulas try..except. Botamos nosso código na
cláusula try, e os comandos de tratamento de erro na cláusula except.
A sintaxe básica para o tratamento de exceções é a seguinte:
try:
código que pode lançar uma exceção
except someError:
ﬂuxo a ser executado caso uma exceção ocorra
»> numeros = [0.3333, 2.5, 0, 10]
»> for x in numeros:
... print x,
... try:
... print 1.0 / x
... except ZeroDivisionError:
... print ’*** trata exceção ***’
69

...
0.3333 3.00030003
2.5 0.4 0 *** trata exceção ***
10 0.1
A instrução try funciona da seguinte maneira:
• Primeiramente, o bloco contido dentro da cláusula try (até antes da cláusula except) é exe-
cutado.
• Se nenhuma exceção ocorrer, a cláusula except não é executada.
• Se alguma exceção ocorrer durante a execução da cláusula try, o resto do código na cláu-
sula try é ignorado. Caso a exceção ocorrida seja uma das declaradas na cláusula except,
o código desta cláusula é executado.
• Se uma exceção ocorrer mas nenhuma cláusula except contiver o nome do erro ocorrido,
será considerado uma exceção não tratada, e a execução do programa irá parar.
• A instrução try pode ter mais de uma cláusula except, para poder lidar com diferentes tipos
de exceções.
Disparando uma exceção (raise)
Permite ao programador forçar(lançar) a ocorrência de uma determinada exceção. Por exem-
plo:
»> raise NameError, ’Descricao’
NameError: Descricao
O primeiro argumento é o nome da exceção a ser lançada. O segundo argumento, é opcional e
especifica o argumento da exceção.
9.5 Ações de limpeza(clean-up)
A instrução try tem uma outra cláusula opcional o qual define ações de limpeza que devem
ser executados em qualquer circunstâncias.
A cláusula finally é executada com ou sem a ocorrência de uma exceção no bloco try. Quando
uma exceção ocorre, ela é re-lançada após a execução da cláusula finally. O código na cláusula
finally é útil para liberar recursos, como por exemplo, fechar arquivos ou conexão com banco de
dados.
Por exemplo:
»> try:
... raise KeyboardInterrupt
... finally:
70

... print ’Goodbye, world!’
...
Goodbye, world!
KeyboardInterrupt
A cláusula try pode ter uma ou mais cláusulas except ou uma cláusula ﬁnally, mas nunca am-
bas juntas.
71

Capítulo 10
Python Orientado a Objetos
Conhecendo um dos paradigmas de programação mais utilizados atualmente
10.1 Introdução
Todos os algoritmos que mostramos até agora, continham funções ou blocos de comandos.
Isto é conhecido como como programação procedural. Existe outro meio de organizar seu pro-
grama que é combinar dados e funcionalidades no que chamamos de objetos. Isto é conhecido
como programação orientada a objetos. Muitas vezes a programação procedural atende perfei-
tamente às nossas necessidades. Mas a medida que o programa cresce, é aconselhável utilizar
um paradigma orientado a objetos.
Vantagens:
• Desenvolvimento mais rápido;
• Fácil manutenção; e
• Reuso.
* Tais vantagens dependem da qualidade em que projetamos um software.
Objetos permitem:
• Criar modelos do mundo real em computador; e
• Usar esses modelos para simular o mundo real.
Possibilita ao desenvolvedor:
72

• Minimizar a lacuna existente entre o sistema real e sua representação em um sistema com-
putacional;
• Pensar, ao longo do processo de desenvolvimento, no domínio da aplicação e não em uma
linguagem de programação especíﬁca.
10.2 Conceitos OO
Nesta seção, vamos conhecer alguns dos conceitos básicos de OO, dando alguns exemplos
de como isto é aplicado para a linguagem Python.
10.3 Classes
Classes são agrupamentos de objetos (computacionais) que têm propriedades em comum e
podem realizar as mesmas ações. A classe pode ser vista como um molde para um objeto, ou
seja, ela não tem existência própria durante a execução do programa. Durante a execução são
manipulados os objetos instanciados a partir das classes.
Classes correspondem a abstrações de entidades do mundo real e que guardam alguma simila-
ridade entre si. Por exemplo, podemos abstrair das entidades do mundo real João, José e Maria
propriedades comuns, formando a classe Pessoa que agrega os dados (por exemplo, nome, en-
dereço) e as operações que se pode realizar sobre objetos da classe Pessoa.
Uma classe é composta por:
• Atributos (características do objeto); e
• Métodos (operações que podem ser realizadas esses atributos).
Atributos e Métodos são chamados membros da classe.
»> class Funcionario:
... pass # o comando pass nao faz nada
...
»> func = Funcionario()
»> print func
<__main__.Funcionario instance at 0xb7e0216c>
No exemplo acima, deﬁnimos uma classe chamada Funcionario que não contém nenhum ser-
viço. Logo em seguida, criamos uma instância da classe e imprimimos seu conteúdo. Iremos
aprender mais sobre instância nas próximas seções.
Repare que utilizamos a construção pass. Ela pode ser usada quando a sintaxe exige um co-
mando mas a semântica do programa não requer nenhuma ação, ou seja, nenhum código precisa
ser executado.
Por exemplo:
def f(arg): pass # uma função que não executa nada (ainda)
73

10.4 Objetos
Um objeto é a materialização da classe em um elemento real. Um objeto representa um ?ele-
mento? que pode ser identificado de maneira única. Desta forma, elementos específicos como
uma pessoa, organização, carro, eventos e etc. podem ser considerados um objeto. É um con-
ceito, uma abstração ou uma entidade, com limites e significados bem definidos, em relação ao
problema considerado.
Um Objeto possui:
• estado interno (Atributos)
• identificação
• comportamento (operações ou métodos)
Um objeto é a instância de uma classe, isto é possui a estrutura da classe (métodos e atribu-
tos), mas seu próprio estado (atributos possuem valores). Ao construir um objeto, a declaração
da classe é utilizada como um modelo informando como alocar o espaço de dados necessário
para o objeto, como inicializar todos os atributos (dados) do objeto e outras ações de inicialização.
Objetos comunicam-se através de mensagens.
Exemplos:
Classe GATO
Objetos Tom, Garfield, Fi-fi, etc.
Classe PESSOA
Objetos Rosiane, Ana, José, etc.
Classe DISCIPLINA
Objetos Matemática, Geografia, Português, etc.
»> class Cachorro:
... def late(self):
... print "au au..."
...
»> rex = Cachorro()
»> rex.late()
au au...
No exemplo acima, definimos uma classe Cachorro que contém um único método, chamado late.
Ele recebe como argumento, a palavra chave self. Entenderemos nas próximas seções do que
se trata.
O importante, é lembrar que ao fazer rex = Cachorro() estamos criando um objeto da classe Ca-
chorro e atribuindo a variável rex.
74

10.5 Instância
Instância é o mesmo que um objeto. Cada objeto é uma nova ocorrência ou uma instância de
alguma classe.
»> class Cachorro:
... def late(self):
... print "au au..."
...
»> rex = Cachorro()
»> rex.late()
au au...
Aproveitando o exemplo da seção anterior, ao fazermos rex = Cachorro() estamos criando uma
instância da classe Cachorro, ou seja, um objeto.
10.6 Atributos
Uma propriedade da classe que caracteriza um objeto através do seu valor (estado interno).
São os valores ou dados escondidos por um objeto em uma classe, definindo as características
específicas de um determinado objeto. Cada atributo possui um valor específico para cada ins-
tância da classe.
Exemplo:
Classe Professor
• Nome
• CPF
• Curso
• Disciplina
Classe Carro
• Cor
• Peso
• Ano
• Modelo
10.7 Métodos
As funções aplicáveis a objetos de uma classe são chamadas Funções-Membro ou Métodos
daquela classe.
75

Métodos são as operações ou comportamentos realizados por um objeto. São as funções ou
transformações que podem ser aplicadas (em/ou por) um objeto de uma classe, em resposta aos
estímulos do mundo externo e provocando possíveis mudanças de estados. São funções associ-
adas a objetos da classe em que elas foram declaradas.
Exemplo:
Classe Seguranca
• Autenticar Usuario
• Registrar Logon
• Criar Sessão
Classe Matricula
• Pesquisar Matricula
• Adicionar Matricula
• Excluir Matricula
10.8 Variáveis de classe vs objeto
Existem dois tipos de variáveis que criadas dentro da classe são visíveis para o "mundo exte-
rior". São elas, as variáveis de classe e as variáveis de objetos. Vamos as definições:
Variável de classe: São aquelas que são compartilhadas por todas as instâncias daquela classe.
Em outras palavras, se criarmos 2 objetos da mesma classe, e um deles modificar o valor da
variável, isto será refletido para o outro objeto. Uma analogia para quem programa em Java por
exemplo, seria o modificar static, que desempenha a mesma função. Em Python, utilizamos uma
variável de classe escrevendo: NomeDaClasse.variável.
»> class Pessoa:
... def setIdade(self, valor):
... Pessoa.idade = valor
... def getIdade(self):
... return Pessoa.idade
...
»> joao = Pessoa()
»> paulo = Pessoa()
»> joao.getIdade()
0
»> paulo.getIdade()
0
»> joao = setIdade(21)
»> joao.getIdade()
76

21
21
No exemplo acima, repare que ao mudarmos o valor da variável de classe do objeto joao, muda-
mos também o valor da idade para o objeto paulo.
Variável de objeto: São aquelas variáveis cujo escopo esta limitado ao objeto. Em outras pa-
lavras, se criarmos 2 objetos da mesma classe, e um deles modificar o valor da variável, isto não
será refletido para o outro objeto.
»> class Pessoa:
... def setIdade(self, valor):
... self.idade = valor
... def getIdade(self):
... return self.idade
...
»> joao = Pessoa()
»> paulo = Pessoa()
»> joao.getIdade()
0
0
»> joao = setIdade(21)
»> joao.getIdade()
21
0
10.9 Variáveis privadas
Variáveis privadas são aquelas que estão visíveis apenas no escopo da classe em que foram
declaradas, não podendo ser referênciadas por outra classe ou arquivo.
»> class Aluno:
... __nomePrivado = "Valor do nome"
Em Python, uma variável privada é identificada por dois sublinhados ’__’ seguido do nome da
variável. Isso permite que a visibilidade das variáveis sejam facilmente diferenciadas apartir do
nome delas.
10.10 O método init
Quando definido dentro de uma classe, o método __init__ é chamado toda vez que uma nova
instância daquela classe é criada. Isto permite que você possa inicializar o objeto da maneira que
deseja, antes dele utilizar os serviços que a classe provê.
77

»> class Cachorro:
... def __init__(self, nome):
... self.nome = nome
... def late(self):
... print self.nome, "fazendo auau..."
...
»> rex = Cachorro("rex")
»> rex.late()
rex fazendo auau...
10.11 O argumento self
Note que o método __init__ (assim como outros exemplos da lição) possui um argumento
extra, a palavra self.
Note que nós não especificamos self quando chamamos o método. Todos os métodos de Python
trabalham assim. Este argumento representa a instância, e o Python esconde ele por trás dos
panos.
Você precisa de self porque é o único jeito de acessar atributos de instância (objetos) e ou-
tros métodos. Dentro do método, self.nome significa o atributo de instância(objeto) nome, mas
apenas nome significaria a variável local nome. E como você sabe, variáveis locais deixam de
existir assim que o método encerra.
10.12 Herança
Na POO existem relações possíveis de serem estabelecidas entre as classes de modo a per-
mitir o compartilhamento de dados e de métodos, originando uma hierarquia entre elas.
Herança é uma relação entre duas ou mais classes, onde aparecem classes bases (superclasse)
e classes filhas (subclasse ou herdeira) especializadas e refinadas.
Podemos definir uma classe que herda informações de uma outra classe. Veja:
Superclasse (classe que será herdada)
»> class Inicial:
... def __init__(self,nome):
... self.nome = nome
... def mostra(self):
... print ’Classe Inicial - Nome: %s’ % (self.nome)
...
Subclasse (classe que herda a superclasse)
»> class Herdada(Inicial):
78

... def __init__(self, nome, idade):
... Inicial.__init__(self,nome)
... self.upper = nome.upper()
... self.idade = idade
... def mostra(self):
... Inicial.mostra(self)
... print ’Classe Herdada - Nome Maiusculo: %s’ % (self.upper)
... if self.idade >= 18:
... print "maior de idade"
... else:
... print "menor de idade"
... def idade(self):
... return self.idade
...
»> objInicial = Inicial("Fulano")
»> objInicial.mostra()
Classe Inicial - Nome: Fulano
»> objHerdada = Herdada("Fulano", 20)
»> objHerdada.mostra()
Classe Inicial - Nome: Fulano
Classe Herdada - Nome Maiusculo: FULANO
maior de idade
79

Capítulo 11
Expressões Regulares
Procure por qualquer padrão dentro de textos ou arquivos.
11.1 Definindo expressões regulares
O que é expressão regular?
Uma expressão regular (RE) é uma sequência de caracteres que denota um padrão de texto.
Dito de outra forma, uma expressão regular (RE) é uma maneira de reconhecer e extrair padrões
de textos em certas strings de dados (textos ou palavras).
A RE é definida por um sequência de caracteres (também chamados metacaracteres) com um
significado especial. Quando bem construídas, as RE nos permitem encontrar padrões de textos
em diferentes strings. Uma RE que reconhece um padrão de texto é chamada matched (compa-
tível).
11.2 Sintaxe
É mais fácil entender a sintaxe de RE através de exemplos. Abaixo um pequeno programa
que usa RE. Ele conta quantas linhas de um arquivo texto contém a palavra ’hello’. A linha que
contiver ’hello’ mais de uma vez, será contada apenas uma vez.
Exemplo:
»> import re
»> regexp = re.compile("hello")
»> count = 0
»> file = open("textfile", ’r’)
»> for line in file.readlines():
... if regexp.search(line):
... count = count + 1
...
»> file.close()
»> print count
80

O programa começa pela importação de um módulo python específico para uso em expressões
regulares, chamado ’re’. A seguir, o programa pega a string ’hello’ como uma expressão regular
textual e a compila, usando para isto a função re.compile. Isto não é estritamente necessário (o
módulo re guarda uma versão compilada para você), mas na maioria dos programas que utili-
zam RE, você verá que se usa compilar as expressões. Isto é porque quando se compila a RE,
aumenta-se a velocidade de execução do seu programa. Na linha que usamos para compilar a
expressão regular, criamos um objeto chamado ’regexp’. Como todo objeto, este também possui
alguns métodos. Assim, este novo objeto (vamos tratar mais sobre objetos nas próximas seções)
poderá ser usado para reconhecer outras ocorrências da palavra ’hello’ dentro de outras strings.
Para reconhecer a ocorrência da palavra ’hello’ (seguindo nosso exemplo), usamos o metodo
search. Este método retorna true se a linha lida contém a string correspondente ao objeto regexp
e false em caso negativo (nós vamos falar mais sobre o search na próxima seção). Portanto, se
a linha do ’if’ retornar true, adicionamos mais 1 (um) no contador. Ao final da leitura do arquivo
texto, nós o fechamos e imprimimos o valor de count.
Bem, até aqui contamos quantas vezes a palavra ’hello’ ocorre no arquivo. Mas note que es-
tamos ignorando as linhas que contém a palavra ’Hello’ (com a letra h em maiúsculo) pois não
estamos considerando a ocorrência de letras maiúsculas. A maneira como resolvemos isto é
usando o metacaratere ’|’ (pipe). Veja como ficaria a segunda linha do nosso programa:
regexp = re.compile("hello|Hello")
O uso de ", neste caso, significa dizer que queremos localizar a palavra ’hello’ ou ’Hello’. Uma
outra forma de fazer isto seria assim:
regexp = re.compile("(h|H)ello")
Neste último caso estamos usando outro metacaractere; o "(". Ele é usado para agrupar pa-
drões. Neste caso, o uso de "(", significa que "somente irá escolher entre a letra h (em minúscula)
e H (maiúscula). O resultado da RE irá ser compatível com qualquer das ocorrências da letra ’h’
em minúscula e em maiúscula e sempre seguida da string ’ello’.
No uso de RE, utilizamos vários metacaracteres. A seguir, a lista deles:
. ^$ * + ? [ ] | ( )
Bem, até aqui vimos o uso de ’|’ e ’()’.
O uso de ’[’ e ’]’ também é bem interessante. Ele nos permite agrupar caracteres, especificando
uma certa classe de caracteres. Por exemplo:
• [a − z] significa qualquer letra minúscula;
• [A − Z] qualquer letra maiúscula;
• [A−Z] qualquer caracter que NÃO seja nenhum caracter entre A e Z;
• [abcd] qualquer um destes caracteres;
81

• [0 − 9] qualquer digito entre 0 e 9;
• [0−9] qualquer caracter que NÃO seja nenhum dígito entre 0 e 9;
• [5] significa qualquer caracter diferente de 5.
Nestes casos, você percebeu o significado de ’^’ né? Ele está fazendo o papel de ’negativa’.
Mas veja outro uso do ’^’ :
regexp = re.compile("^cabral")
O que estamos querendo neste caso, é achar qualquer sequência de caracteres que comece
com "cabral".
O metacaractere ’$’ nos serve para buscar sequências na parte final de strings. Veja:
regexp = re.compile("cabral$")
Assim, se tivermos um nome como "pedro alvares cabral", por exemplo, teremos sucesso se
utilizarmos o objeto regexp.
O ” talvez seja um dos metacaracteres mais utilizados. Você pode usa-lo seguido de vários
caracteres para sinalizar sequências especiais. Ele tambem é usado para ’escapar’ todos os
outros metacaracteres. Por exemplo, se você precisar encontrar em uma string o caracter "["ou
o "?", pode usar a seguinte construção: [ e ? respectivamente. Veja algumas das sequências
especiais:
• d - qualquer caracter dígito decimal; equivale a [0 − 9];
• D - qualquer caracter que NÃO seja um dígito; equivale a [0−9];
• s - qualquer caracter que significa espaço ’ ’, em qualquer quantidade;
• equivale a [ tnrfv]
• S - qualquer caracter que NÃO significa espaço ’ ’, em qualquer quantidade;
• equivale a [^tnrfv]
• w - qualquer caracter alfa-numérico; equivale a classe de caracteres [a − zA − Z0 − 9];
• W - qualquer caracter NÃO alfa-numérico; equivale a classe [a−aA − Z0 − 9].
Para finalizar esta seção, vamos criar uma tabela com outros metacaracteres dos quais não
falamos ainda. A tabela contém o metacaracter e seu respectivo significado em RE:
82

. No modo default, equivale a qualquer caracter exceto o ’newline’ (n).
^ Testa a validade do padrão no início da String
$ Testa a validade do padrão no final da String
* Equivale a 0 ou mais repetições do caracter na RE. Exemplo: ab* irá resultar
verdadeiro (true) se encontrarmos na string desejada a ocorrência de ’a’, ’ab’
ou ’a’ seguido de qualquer quantidade de letras ’b’
+ Equivale a 1 ( pelo menos 1) ocorrência do caracter na RE. Examplo: ab+ irá
resultar em verdadeiro (true) se encontrarmos na string desejada a ocorrência
de ’a’ seguido de pelo menos uma letra ’b’
? Equivale a nenhuma ou uma ocorrência da expressão precedente. Exemplo:
ab? irá resultar em verdadeiro se encontrarmos na string desejada a
ocorrência da letra ’a’ ou do conjunto ’ab’
m, n Aqui a idéia é encontrar um mínimo (m) e um máximo (n) de caracteres
na string desejada. Exemplo: a3, 5 equivale a buscar um mínimo de 3 e um
máximo de 5 ocorrências da letra ’a’.
m, n? A idéia aqui é diferente da anterior. Quando usamos esta construção,
queremos encontrar o mínimo possível de ocorrências da expressão.
Exemplo: Na string ’aaaaaa’ (seis caracteres), quando usamos a3, 5
encontramos 5 letras ’a’ e nos é retornado ’aaaaa’ (cinco caracteres). Mas
quando usamos a3, 5? equivale a buscar pelo menos 3 ocorrências da letra
’a’. Ou seja, a expressão retornará somente ’aaa’ (três caracteres).
Permite inserir caractéres especiais como "*"ou "?"que
isoladamente seriam interpretados como algum padrão para a RE
(?P<name>...) Agrupa alguma expressão regular, através de um identificador
<name>. Por exemplo, se a expressão é (?P<id>[a − zA − Z]w*),
pode ser referenciado pelo seu nome, em argumentos de métodos, como m.group(’id’)
ou m.end(’id’)
(?P=name) Procura por um padrão que for encontrado apartir do grupo name
11.3 Utilizando RE
Vamos começar a usar RE em um exemplo. E a melhor maneira de fazer isto, é usar extensi-
vamente os metacarateres.
Assuma que tenhamos uma lista de pessoas com seus respectivos números de telefones, to-
das gravadas em arquivo texto. Cada linha deste arquivo seria assim:
Sobrenome, Nome NomeDoMeio: NumeroTelefone
Traduzindo, teríamos:
Sobrenome seguido de ’,’ (vírgula) e ’ ’ (espaço), Nome seguido por ’ ’ (espaço), NomeDoMeio,
seguido por ’:’ (dois pontos) e ’ ’ (espaço) e finalmente, o NumeroTelefone.
Para complicar, o NomeDoMeio pode ou não existir e, além disto, o NumeroTelefone, pode ou
não ter um código de área. Ele pode ser 800-124-4567, ou pode ser apenas, 123-4567.
83

Bem, para escrever um código em python para fazer o ’parser’ destas linhas, pode ser simples se
usarmos RE.
Então vamos começar assumindo que Nome, NomeDoMeio e Sobrenome, todos têm somente
letras e, possivelmente, um hífem. Os metacaracteres [ ] deﬁnidos na seção anterior, podem ser
usados para deﬁnir um padrão que nos servirá para a busca de tais nomes, veja:
[−a − zA − Z]
Este padrão irá encontrar um hífem, ou uma letra (qualquer letra) em minúsculo ou maiúsculo.
Para encontrar o nome completo, por exemplo ’Pedro’, nós precisamos repetir este padrão. O
metacaracter ’+’ nos permite repetir (uma ou mais vezes) este padrão, possibilitando-nos encon-
trar o nome completo. Ficaria assim:
[−a − zA − Z]+
Agora esta RE poderá encontrar um nome simples, como Marcus ou Pedro, mas também nos
permite encontrar ’Marcus-Pedro’. Esta RE também nos permite encontrar coisas que não são
na verdade nome, por exemplo, ’—’ ou ’a-b-c’, mas serve para o nosso propósito neste momento.
Mas o que dizer sobre o número do telefone? Vamos usar o ’d’. Seria:
ddd-ddd-dddd
Ou seja, três digitos, seguidos de ’-’ (hífem), seguido de mais três dígitos, outro ’-’ (hífem) se-
guido de quatro dígitos. Acontece que, neste caso, iríamos localizar somente as linhas nas quais
os números de telefone contivessem o código de área. Então vamos mudar esta RE para:
(ddd-)?ddd-dddd
Agora a sequência (ddd-) é opcional. Ou seja, NumeroTelefone pode ou não ter o código de
área. Bem, colocando tudo junto, teríamos:
[−a − zA − Z]+, [−a − zA − Z]+( [−a − zA − Z]+)?: (ddd-)?ddd-dddd
Poderíamos ter um programa em python assim:
import re
regexp= re.compile(
# Sobrenome e vírgula
r"[−a − zA − Z]+,"
# Nome
r"[−a − zA − Z]+"
# NomeDoMeio opcional
r"([−a − zA − Z]+)?"
# dois pontos, espaço e NumeroTelefone
r": (ddd-)?ddd-dddd
84

)
file = open(’textfile’, ’r’)
for line in file.readlines():
if regex.search(line):
print "Ok, encontrei ... e agora?"
file.close()
11.4 Extraindo conteúdo
Até agora apenas conseguimos ver se uma determinada string possui uma certa sequência
de caracteres. Mas e se nós pudermos extrair dados destas RE’s? Pois é, nós podemos. Para
isto vamos usar o conceito de ’grupos’. A idéia é que podemos dar ’nomes’ aos padrões que
buscamos com a RE para depois usarmos estes ’nomes’. Veja:
(?P<last>[−a−zA−Z]+), (?P<first>[−a−zA−Z]+) ( (?P<middle>([−a−zA−Z]+)))?:(?P<phone>(ddd-
)?ddd-dddd)
Aqui precisamos observar alguns detalhes:
a) toda a expressão deve estar em uma única linha;
b) o caracter ’?’ aqui tem outra função. Ele nos dá condições de usar o método group;
O uso do método group é possível porque quando usamos o search, ele não retorna apenas
’true’ ou ’false’; ele retorna também uma estrutura com os dados equivalentes. Olha como ficaria
o nosso programa agora:
import re
regexp= re.compile(
# Sobrenome e virgula
r"(?P<last>[−a − zA − Z]+),"
# espaco e Nome
r"(?P<first>[−a − zA − Z]+)"
# espaco NomeDoMeio opcional
r"( (?P<middle>([−a − zA − Z]+)))?"
# dois pontos, espaco e NumeroTelefone r": (?P<phone>(ddd-)?ddd-dddd)")
file = open(’textfile’, ’r’)
for line in file.readlines():
result = regexp.search(line)
if result == None:
print "Oops, nao encontrei nadica de nada!"
else:
lastname = result.group(’last’)
firstname = result.group(’first’)
85

middlename = result.group(’middle’)
phonenumber = result.group(’phone’)
print "Nome (%s) NomeDoMeio (%s) Sobrenome (%s) Telefone (%s)"
% (firstname, middlename, lastname, phonenumber)
file.close()
Para testá-lo, basta criar um arquivo chamado textfile, como por exemplo este:
Arantes, Edson Pele: 999-9999
Joaozinho, Trinta: 888-8888
Uma linha qualquer
Veja a saída produzida ao rodar o exemplo com o arquivo acima:
Nome (Edson) NomeDoMeio (Pele) Sobrenome (Arantes) Telefone (999-9999)
Nome (Trinta) NomeDoMeio (None) Sobrenome (Joaozinho) Telefone (888-8888)
Oops, nao encontrei nadica de nada!
Repare que na última linha, não é encontrado um padrão de texto conforme o especificado.
11.5 Substituindo textos com RE
Além de extrair strings de textos como vimos acima, podemos usar RE em Python para en-
contrar e substituir strings nos textos. Isto acontece usando um método chamado sub. O exemplo
a seguir ilustra isto. Nós vamos trocar a ocorrência de uma string que contém ’Perl’ e vamos
substituir por ’Python’. Veja:
»> import re
»> Frase = "Quando vou trabalhar com RE, eu prefiro usar Perl"
»> regexp = re.compile(r"Perl")
»> regexp.sub("Python", Frase)
O codigo acima irá imprimir a seguinte string:
"Quando vou trabalhar com RE, eu prefiro usar Python"
Ou seja, para o método sub nós passamos dois argumentos. O primeiro é o novo termo que
desejamos colocar em Frase. O segundo argumento é onde queremos que a substituição seja
feita. Neste caso, desejamos colocar a palavra "Python"substituindo a palavra "Perl"em Frase.
Bem, isto é bem trivial, mas o legal de Python com RE (e sub), é que podemos fazer do pri-
meiro argumento uma função. Veja este exemplo:
»> import re
»> Numeros = "1 2 3 4 5"# definição de uma variável chamada ’Numeros’
»> def int_para_float(matchObj):
return (matchObj.group(’digitos’) + ".0") # metodo que usarah o Grupo ’digitos’ definido abaixo
86

»> pattern = r"(?P<digitos>[0 − 9]+)"# definição do padrão de procura e de um Grupo chamado
’digitos’
»> regexp = re.compile(pattern)
»> regexp.sub(int_para_float, Numeros) # para a substituição, usa-se o método definido acima
O codigo acima, irá imprimir "1.0 2.0 3.0 4.0 5.0"
Neste caso, o padrão de procura consiste de um ou mais digitos ( a parte [0 − 9]+ ). É tam-
bém dado um nome para este padrão ( a parte ?P<num> ).
O método sub irá procurar dentro de Numeros o padrão que combina com [0 − 9]+. Quando o
padrão for encontrado, ele irá chamar o método ’int_para_float’ que, por sua vez, usará o Grupo
’digitos’ para extrair e produzir uma nova variável ’Numeros’.
87

Capítulo 12
Bibliotecas Gráficas
Conheça as mais famosas bibliotecas gráficas para Python. As bibliotecas oferecem um am-
biente rico para programas você desenvolver programas gráficos.
12.1 TKinter para TK
Baseada em Tcl/Tk, a Tkinter acompanha a distribuição oficial do interpretador Python. É a
biblioteca padrão da linguagem Python.
Vantagens:
• Portabilidade - Programas escritos usando a Tkinter são portáveis livremente entre Linux,
Unix, Windows e Mac, além da garantia de que qualquer um poderá executar o programa
sem precisar instalar bibliotecas extras.
• Aprendizado - Tem uma API simples de se aprender e fácil de lembrar.
• Documentação - Muito bem documentada, com inúmeros tutoriais e referências de ótima
qualidade disponíveis na Web.
Desvantagens:
• Pobre - Faltam muitos componentes importantes, como notebooks e combo box (apesar
de estes poderem ser feitos combinando outros componentes). Alguns elementos (listbox
por exemplo) são incompletos ou limitados. Em compensação o componente Text é muito
poderoso.
• Aparência - A Tk usa uma função própria para acessar diretamente as funções do sistema
operacional e desenhar seus próprios elementos na tela. Isso tem a vantagem de ser mais
facilmente portável, mas a grande desvantagem de ter uma aparência diferente da nativa
do sistema operacional.
• Performance - O desempenho é extremalmente baixo comparado ao que a biblioteca ofe-
rece.
Exemplo de código:
88

from Tkinter import *
class App:
def __init__(self, master):
frame = Frame(master)
frame.pack()
self.button = Button(frame, text="QUIT", fg="red",
command=frame.quit)
self.button.pack(side=LEFT)
self.hi_there = Button(frame, text="Hello",
command=self.say_hi)
self.hi_there.pack(side=LEFT)
def say_hi(self):
print "hi there, everyone!"
root = Tk()
app = App(root)
root.mainloop()
Mais informações:
http://www.python.org/topics/tkinter/
12.2 PyGTK para GTK
PyGTK é um wrapper para o Python criado por James Henstridge, construído sobre o GIMP
Toolkit (GTK), a biblioteca usada pelo GNOME e muitas outras aplicações para Linux. Tem ótimo
desempenho, elementos ricos e é visual mente agradável.
Vantagens:
• Desempenho - PyGTK 0.X (para GTK 1.2) tem um ótimo desempenho. A versão 2.0 (para
gtk 2.X) não tem o mesmo desempenho, mas é bem satisfatória.
• Documentação - Bem documentada. Existem bons tutoriais para ambas as versões. Apesar
de não haver uma referência completa para PyGTK 0.X, existe uma muito boa para a versão
2.X.
• API - PyGTK usa uma API eﬁciente, baseada em propagação de sinais e callbacks. Um
elemento qualquer emite um sinal, que é propagado "pra cima"até ser capturado e gerar a
chamada de um callback.
89

• IDE - Possui uma ferramenta para construção de interfaces, o Glade, que permite gerar uma
referência em XML da interface, que pode ser usada diretamente pela biblioteca.
• Portabilidade - Portar aplicações de PyGTK para Windows é facil. Normalmente sem trocar
o código.
Desvantagens:
• Tamanho do código - Muito do código escrito em PyGTK chega a parecer redundante, mas
é necessário. Por exemplo, para usar um elemento qualquer precisamos criá-lo, chamando
a classe, configurá-lo através dos seus métodos de configuração, posicioná-lo e por fim
mostrá-lo com o método show(). São no mínimo três chamadas de métodos pra cada
objeto. Como resultado disso, temos arquivos de código fonte imensos. Linhas e mais
linhas de código são necessárias para se fazer qualquer coisa.
Exemplo de código:
import gtk
class HelloWorld(gtk.Window):
def __init__(self):
gtk.Window.__init__(self)
self.connect("delete_event", gtk.main_quit)
self.set_border_width(10)
self.set_title("Hello World!")
hbox = gtk.HBox()
self.add(hbox)
self.button1 = gtk.Button("Button 1")
self.button1.connect("clicked", self.button_pressed_cb)
hbox.pack_start(self.button1)
self.button2 = gtk.Button("Button 2")
self.button2.connect("clicked", self.button_pressed_cb)
hbox.pack_start(self.button2)
def button_pressed_cb(self, button):
print "Hello again - %s was pressed"% button.get_label()
if __name__ == "__main__":
win = HelloWorld()
win.show_all()
gtk.main()
90

Mais informações:
http://www.pygtk.org
12.3 PyQT para QT
PyQT é um wrapper da linguagem Python para a biblioteca Qt, que é a base do KDE (ambi-
ente desktop para Linux). Muitas das vantagens e desvantagens do PyQT coincidem com as do
PyGTK, pelo fato do GNOME e KDE serem "concorrentes"e se equivalerem em muitos aspec-
tos. Existe uma biblioteca complementar, PyKDE, que atua sobre elementos específicos do KDE,
como por exemplo interação com o kicker e a barra de tarefas.
Vantagens:
Desempenho: Como o Qt foi construído de forma a facilitar o desenvolvimento de wrappers, o
desempenho do PyQT é bem próximo do Qt quando usado com C++.
• Fácil de aprender: A biblioteca Qt é famosa por ser extremamente bem documentada, pois
a própria Trolltech possui um time de escritores técnicos. Apesar da documentação ser para
C++, é fácil "traduzir"os exemplos para Python. Existe também um ótimo livro online sobre
PyQT no site opendocs.org
• API: A API do PyQT utiliza um sistema de "slots"e "sinais", levemente similar ao sistema de
sinais e callbacks utilizado por outras bibliotecas. A API é bastante rica e coerente.
• IDE: Possui uma IDE muito boa para criação de interfaces, chamada QT Designer. O pro-
grama pyuic transforma essas definições de interfaces em código Python, que pode então
ser usado por outros programas.
Desvantagens:
• Portabilidade: Usar o PyQT é excelente para programas Linux (em especial para rodar
em cima do KDE, embora isso não seja obrigatório), mas como não existe licença GPL para
Windows, provavelmente não é uma boa idéia utilizá-lo nessa plataforma. No ambiente Win-
dows existem DLLs disponíveis para download da Qt 2.x para fins não comerciais, sobre as
quais se encontra disponível também o PyQt para Windows. DLLs para fins não comerciais
da Qt 3.x somente se encontram disponíveis no livro C++ GUI Programming with Qt 3.
Exemplo de código:
import sys
from qt import *
class HelloButton(QPushButton):
def __init__(self, *args):
apply(QPushButton.__init__, (self,) + args)
self.setText("Hello World")
91

class HelloWindow(QMainWindow):
def __init__(self, *args):
apply(QMainWindow.__init__, (self,) + args)
self.button=HelloButton(self)
self.setCentralWidget(self.button)
def main(args):
app=QApplication(args)
win=HelloWindow()
win.show()
app.connect(app, SIGNAL("lastWindowClosed()"),
app, SLOT("quit()"))
app.exec_loop()
if __name__=="__main__":
main(sys.argv)
Mais informações:
http://www.riverbankcomputing.co.uk/pyqt/
12.4 wxPython para wxWidgets
wxPython é um wrapper da biblioteca wxWindows. Assim como a Tkinter, as aplicações são
facilmente portáveis. A diferença é que a wxWindows utiliza um wrapper sobre a interface gráﬁca
padrão do sistema operacional (GTK em Linux, MFC em Windows), o que permite que as apli-
cações sejam mais facilmente portáveis e que tenham a aparência de uma aplicação nativa. Em
compensação, o desempenho vai ladeira abaixo com o acréscimo de mais uma camada entre a
aplicação e o sistema operacional.
Vantagens:
• Portabilidade - Aplicações escritas em wxPython rodam praticamente sem problemas em
várias plataformas. Esse é provavelmente o principal (senão o único) motivo pelo qual está
se tornando bem popular.
• Componentes ricos - Nesse ponto a wxPython é imbatível. Há todo tipo de componentes,
prontamente disponíveis, de telas a caixas de texto que interpretam HTML e até mesmo a
Scintilla.
• Documentação - o wxPython vem com um demo da maioria dos seus widgets que serve
como teste e exemplo de uso.
Desvantagens:
92

• Desempenho - A performance das aplicações em si não é ruim. O problema é o uso de
memória e o tempo de inicialização.
• Instabilidade - Mesmo estando ativamente em desenvolvimento, ainda tem alguns proble-
mas de estabilidade. No mínimo 10% das mensagens na lista wxPython são reportando
bugs.
• API complicada - wxWindows é uma biblioteca com quase 10 anos de idade, que foi sendo
remendada precariamente com o passar dos anos. Apesar da wxPython ser um wrapper
excelente, muito bem escrito, os problemas da wxWindows aparecem: API completamente
diferente entre alguns componentes e outros, números de ID, macros, etc. Porém tem
melhorado bastante a partir da versão 2.5 e o wrapper wxPython oculta bastante a comple-
xidade e idiossincrasias do wxWindows.
• Documentação - Apesar de alguns tutoriais razoáveis, há pouca documentação especí-
ﬁca para wxPython. Para uma referência da biblioteca, tem de se recorrer à referência da
wxWindows. Entretanto, muitas vezes basta seguir o código dos demos (em Python), sem
ser necessário recorrer a documentação do wxWindows.
• IDEs Livres - O wxDesigner é um IDE bom, mas é comercial. Não há nenhum IDE RAD de
qualidade e que seja disponível livremente, embora o BoaConstructor pareça muito promis-
sor.
Mais informações:
http://www.wxpython.org/
93

Python

Mais conteúdo relacionado

Mais procurados (20)

Semelhante a Python (20)

Mais de Tiago (20)

Último (20)

Python