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”
File «stdin>", line 1
^
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

Python

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Semelhante a Python

Semelhante a Python (20)

Mais de Tiago

Mais de Tiago (20)

Último

Último (20)

Python