Python

Python18 de abril de 2007

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 112.1 Objetivo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112.2 Público Alvo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112.3 Pré-requisitos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112.4 Descrição . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112.5 Metodologia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112.6 Cronograma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112.7 Programa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122.8 Avaliação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132.9 Bibliografia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

3 Visão Geral 143.1 O que é? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143.2 Por que Python? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143.3 Características da Linguagem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153.4 Plataformas Disponíveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173.5 Filosofia da Linguagem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173.6 Histórico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183.7 Organização . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183.8 Licença . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193.9 Documentação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193.10 Comparação de Linguagens de Programação . . . . . . . . . . . . . . . . . . . . . . 193.11 Adquirindo o Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193.12 Instalando o Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203.13 Testando o Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213.14 Interpretador . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

1

CDTC Centro de Difusão de Tecnologia e Conhecimento Brasil/DF

4 Introdução à Linguagem 234.1 Identação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234.2 Comentando o código . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244.3 Entrada de dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254.4 Saída de dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274.5 Tipos - Números . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284.6 Tipos - Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314.7 Operações sobre Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334.8 Substituição em strings: o operador de porcentagem . . . . . . . . . . . . . . . . . . 354.9 Mais sobre Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

5 Operadores 385.1 Operadores de Atribuição . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 385.2 Operadores Aritméticos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 385.3 Operadores Relacionais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395.4 Operadores Lógicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 405.5 Operadores Bit a Bit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

6 Estruturas de Controle 426.1 Introdução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 426.2 if, else e elif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 426.3 for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 436.4 while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 456.5 break e continue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

7 Estrutura de Dados 477.1 Listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 477.2 Outros métodos de Listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 487.3 Mais sobre listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 507.4 Tuplas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 507.5 Sets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 517.6 Dicionário . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 517.7 Mais sobre dicionários . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 537.8 Utilizando Listas como Pilhas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 537.9 Utilizando Listas como Fila . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 537.10 Trabalhando com arquivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54

8 Funções 578.1 Introdução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 578.2 Criando e chamando uma Função . . . . . . . . . . . . . . . . . . . . . . . . . . . . 578.3 Variáveis locais x globais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 588.4 Argumentos padrões . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 598.5 Argumentos chaves . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 598.6 Retorno . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 608.7 DocStrings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 608.8 Módulos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 618.9 Introdução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 618.10 Criando um módulo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 618.11 Mais sobre módulos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

2


8.12 Módulos Padrões . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 628.13 Módulos independentes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64

9 Erros e exceções 669.1 Introdução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 669.2 Erros de sintaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 669.3 Exceções . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 679.4 Tratamento e disparo(raise) de exceções . . . . . . . . . . . . . . . . . . . . . . . . 679.5 Ações de limpeza(clean-up) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68

10 Python Orientado a Objetos 7010.1 Introdução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7010.2 Conceitos OO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7110.3 Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7110.4 Objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7210.5 Instância . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7310.6 Atributos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7310.7 Métodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7310.8 Variáveis de classe vs objeto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7410.9 Variáveis privadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7510.10O método init . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7510.11O argumento self . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7610.12Herança . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76

11 Expressões Regulares 7811.1 Definindo expressões regulares . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7811.2 Sintaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7811.3 Utilizando RE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8111.4 Extraindo conteúdo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8311.5 Substituindo textos com RE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84

12 Bibliotecas Gráficas 8612.1 TKinter para TK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8612.2 PyGTK para GTK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8712.3 PyQT para QT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8912.4 wxPython para wxWidgets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90

3

Parte I

Sobre essa Apostila

4


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çaGNU Free Documentation License, cujo teor integral encontra-se aqui reproduzido na seção demesmo nome, tendo inclusive uma versão traduzida (não oficial).

A revisão e alteração vem sendo realizada pelo CDTC ([email protected]) desde outubrode 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, quevem sendo realizado pelo ITI (Instituto Nacional de Tecnologia da Informação) em conjunto comoutros parceiros institucionais, atuando em conjunto com as universidades federais brasileirasque tem produzido e utilizado Software Livre, apoiando inclusive a comunidade Free Softwarejunto a outras entidades no país.

Informações adicionais podem ser obtidas através do email [email protected], ou dahome 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 responsabilizamdireta 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 ([email protected]) .

Permission is granted to copy, distribute and/or modify this document under the termsof the GNU Free Documentation License, Version 1.1 or any later version published bythe 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 DocumentationLicense.

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 dodesenvolvimento 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 ede código fonte aberto, identificando e mobilizando grupos de formadores de opinião dentre osservidores públicos e agentes políticos da União Federal, estimulando e incentivando o mercadonacional a adotar novos modelos de negócio da tecnologia da informação e de novos negóciosde comunicação com base em software não-proprietário e de código fonte aberto, oferecendotreinamento 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 comoincentivadores 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 deprodutos 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ê comeceseu 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 oroteiro acima.

Licença

Copyright ©2006, Instituto Nacional de Tecnologia da Informação ([email protected]).

7


É dada permissão para copiar, distribuir e/ou modificar este documento sob os termosda Licença de Documentação Livre GNU, Versão 1.1 ou qualquer versão posteriorpúblicada pela Free Software Foundation; com o Capitulo Invariante SOBRE ESSAAPOSTILA. 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 seuscolegas de turma respeitando-os e fazendo ser respeitado pelo mesmo.

• 5. Organização pessoal: planejar e organizar tudo é fundamental para facilitar a sua revisãoe a sua recuperação de materiais.

• 6. Vontade para realizar as atividades no tempo correto: anotar todas as suas obrigações erealizá-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, aprendizagense 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ãocontrola a sua dedicação, mas reflete 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çõesque 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 queinteresse ao grupo, favor postá-la aqui.Porém, se o que você deseja é resolver alguma dúvida ou discutir algum tópico específico docurso. É recomendado que você faça uso do Forum de dúvidas gerais que lhe dá recursos maisefetivos para esta prática.

. O fórum de dúvidas gerais tem por objetivo disponibilizar um meio fácil, rápido e interativopara solucionar suas dúvidas e trocar experiências. As mensagens postadas nele são enviadasa todos participantes do curso. Assim, fica muito mais fácil obter respostas, já que todos podemajudar.Se você receber uma mensagem com algum tópico que saiba responder, não se preocupe com aformalizaçã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 podemser 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, porpessoas 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 dasferramentas 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 respectivosvalores e atitudes, incentiva mas é honesto, imparcial, amável, positivo, respeitador, aceita asidé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 tutorou 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 umreparo de um estudante: ’os comentários deixam-nos com uma sensação de crítica, deameaç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 quepossui características poderosas que a tornam uma linguagem muito simples e eficiente. Suaabstração sobre a orientação a objetos permite a criação rápida de softwares, bem como, a suaintegração à outras linguagens de programação como C/C++, JAVA e .NET, permitindo grande fle-xíbilidade. Python já é uma realidade no mundo do Software Livre e vem conquistando tambéma 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 daprimeira 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 aseguir.

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ásicospara 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 Moodlecomo ferramenta de aprendizagem. O curso tem duração de uma semana e possui um conjuntode atividades (lições, fóruns, glossários, questionários e outros) que deverão ser executadas deacordo com as instruções fornecidas. O material didático está disponível on-line de acordo comas 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 finalde uma lição, você receberá uma nota de acordo com o seu desempenho. Caso sua nota numadeterminada 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 osmó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 doMoodle".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 eobtenção do certificado o participante deverá obter nota final maior ou igual a 6.0 de acordocom 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 rapidamentee 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 SoftwareLivre e vem conquistando também a cada dia o Software Proprietário (jogos de computador sãoum exemplo forte).

Para vocês terem uma idéia, enquanto ASSEMBLY é uma linguagem de baixo nível, C umalinguagem de nível intermediário e JAVA uma linguagem de alto nível, Python é uma linguagemde 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(independeda 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 curtoe 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 testarrapidamente 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 dedefeitos reduzido - menos código, menos oportunidade para errar.

• Existe suporte para uma diversidade grande de bibliotecas externas. Ou seja, pode-se fazerem Python qualquer tipo de programa, mesmo que utilize gráficos, funções matemáticascomplexas, 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 bibliotecaapenas nestas linguagens.

• Python permite que o programa execute inalterado em múltiplas plataformas; em outraspalavras, 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. Estapropriedade 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. Oprojeto 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 processosimples 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(masnã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 apreocupação do programador com o controle de ponteiros por exemplo. O Python herda nuancesdo FORTRAN, C, C++, ABC. Podemos compara-lo com ao C++ e ao Java quando falamos deorientaçã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 umamaneira simples de lidar com orientação a objetos, especialmente quando comparado com asgrandes 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 engenheirose arquitetos de software escreverem seus códigos apenas uma vez e possam rodar o programaem qualquer plataforma que suporte Python.

Robusta

Não há melhor poder para um engenheiro de software do que reconhecer condições de erroe 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 vidado 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ódigofonte não é convertido diretamente para a linguagem da máquina. Para esta transição, existe ummeio 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 dalinguagem.

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 algunscelulares, como a série 60 da Nokia e palmtops. O código fonte é traduzido pelo interpretadorpara o formato bytecode, que é multiplataforma e pode ser executado e distribuído sem fonteoriginal.

3.5 Filosofia 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 first 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ãotrabalhando na época para CWI na Holanda e em meados de 1991 publicou uma versão paradistribuição pública. Suas principais motivações foram a possibilidade de inovação no mundodas 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 alinguagem-interpretada ABC, contudo, foi a sua aproximação com o sistema operacional Amoebaque lhe deu experiência, e foi justamente com suas pesquisas junto a especificação da linguagemAmoeba, 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 semfins lucrativos que é responsável por proteger a plataforma Python. É ela quem determina se umaimplementaçã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 criadorda linguagem. No universo pythonista existe um ditador benevolente (BDFL - Benevolent Dictatorfor Life) que é o próprio GvR. Alguns podem dizer que isso é uma desvantagem do Python, masna verdade isso é que protege o Python e O GvR está nessa posição por mérito. A democracianem sempre é muito boa, principalmente quando envolve muito dinheiro pode ser corrompida etomar rumos inesperados.

O processo de proposição de mudanças na plataforma Python ocorre seguindo mais ou menos aseguinte 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 umaPEP (Python Enhancement Proposals) ([WWW] http://python.org/peps/) que deve seguiralgumas regras básicas. Neste documento a proposta é descrita em detalhes e algumasdas 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 quandoisso 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 certificada pela OSI compatível com a GPL, po-rém menos restritiva. Sua licença prevê (entre outras coisas) que binários da linguagem sejamdistribuídos sem a necessidade de se haver o código-fonte junto. Para maiores detalhes, visitehttp://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 naURL: 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 edentre 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 oDebian, 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 doPython. 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 ./configure

22


• Execute make

Neste momento, o Python já esta operacional, porém não está instalado em /usr/local nosystem. Faça o seguinte:

• Para instalar execute: make install

O Python é normalmente instalado em locais padrão como em máquinas Unix e GNU/Linuxno /usr/bin quando que suas bibliotecas(lib) estao em /usr/lib/python2.x , já no caso do DOS ouMS-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 interpretadordo Python. Ele permite que você execute todos os comandos da linguagem, sem que para issoprecise 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 identificar a primeira linha como sendo umcomentá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 ficaria da seguinte maneira:

#!/usr/bin/env pythonprint ’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 einicializando um script Python.

O primeiro modo pode ser feito no shell (terminal do GNU/Linux) ou no DOS com o comando:

$ pythonPython 2.3.5 (#2, Sep 4 2005, 22:01:42)[GCC3.3.5(Debian1 : 3.3.5− 13)] on linux2Type "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:

#!/usr/bin/env python#-*- coding: iso8859-1 -*-print "Ola mundo!"

No caso, o script deve possuir em seu cabeçalho as duas primeiras linhas deste exemplo. Aprimeira 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 ecaracteres 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 ocabeç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 fique visualmente mais agradávele intuitivo. No Python estes espaços são bem importantes, pois os blocos de instruções devemestar em um mesmo nível de identação, caso contrário, erros podem ocorrer.Exemplo:for x in range(1,10):print xFile «stdin>", line 2print x^IndentationError: expected an indented blockExemplo:for x in range(1,10):print x123456789

As identações podem ser feitas com espaços em brancos ou com tabulações. Recomenda-seutilizar 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 definir 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 é bomquando 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ífica dentro de funções e classes, estescomentários geram uma documentação automaticamente e que pode ser acessada atravésda 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, nonosso 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 senão entenderem muito bem o código abaixo, prestem atenção apenas no código em negrito evejam 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 detalheimportante é 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 defined 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 ocomentário que fizemos.

4.3 Entrada de dados

Nossos programas com certeza precisaram em algum momento de alguma interação com ousuário. Já vimos como funcionam as impressões através da saída padrão do sistema, e agoraveremos 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 entradade 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. EmPython 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 aentrada é manualmente pela entrada padrão. Não se preocupe, vamos exemplificar maisabaixo.

• raw_input() - lê um objeto do tipo string da entrada padrão. Ou seja, qualquer tipo quefor 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ávelnúmero. Isso é um fato importante, pois sendo ele uma string não podemos simplesmente, porexemplo, adicionar mais 2 ao número, veja o que acontece se tentarmos isso:

»> numero + 2Traceback (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) + 212

Neste caso, adicionamos o valor da saída gerada pela função int() com o número 2, como nestecaso, 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émsã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 oque citamos, veja como realizaríamos o mesmo login feito acima:

»> user = input("Entre com seu login: ")Entre com seu login: rootTraceback (most recent call last):File «stdin>", line 1, in ?

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 foifalado 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 confirmarque user realmente é uma string perguntando ao interpretador o tipo da variável com a funçãotype().

»> type(user)<type ’str’>

E agora com o exemplo da entrada de um número:

»> numero = input("Digite um numero: ")Digite um numero: 10»> numero10»> type(numero)<type ’int’>

Viu? essa é a grande diferença destas duas funções que são utilizadas para entrada padrãono 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 dosistema, 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árioo 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 usamoso print. Veja:

29


»> myString = ’Ola Mundo Python! ’»> print myStringOla 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 aoutros 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 otipo 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 2020»> print 10+3949»> print "python"+ "= cobra"python = cobra

Agora veja o que acontece se tentamos misturar objetos de tipos diferentes:

»> print "Python "+ 1938Traceback (most recent call last):File «stdin>", line 1, in ?TypeError: cannot concatenate ’str’ and ’int’ objects

Ou seja, um erro na tentativa de concatenar objetos do tipo string e integer. Para corrigirmoso 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 stringde saída.

4.5 Tipos - Números

Python, assim como qualquer outra linguagem de programação tem tipos pré-definidos 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 tiposnumé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çãonumé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 numero10»> 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 aprofundarem 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 seuprograma for utilizar um número muito maior que o limite de 2 mil casas, utilize então um inteirodo 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 oque isso quer dizer? quer dizer que o ’.’ que representa o início das casas decimais flutua dentrodo número. A representação para este tipo numérico é o que chamamos de float e para definirque uma variável contém um tipo float apenas devemos colocar o ’.’ (ponto) seguido de algumaquantidade 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 maisdinâ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 umaviso 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 assustemse virem algo como isso:

»> 0.10.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, mesmoque seja zero. O fato de ser considerado um float é importante para a operação divisão, poisdependendo do tipo dos operandos, a divisão é inteira ou em ponto flutuante.

»> 5 / 2 # divisão inteira, resultado inteiro2»> 5 / 2.0 # divisão em ponto flutuante2.5»> 5 * 2.1310.649999999999999Finalmente 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, ePython faz isso.

O tipo complex representa o conjunto dos números complexos da matemática que conhecemose é 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.real10.0»> numero.imag3.0

Com eles podemos acessar a parte real e imaginária do número complexo. Note uma coisaimportante, a parte imaginária é definida 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 conceitosimportantes que podem ser encaixados neste momento, o conceito de caractere e de conjunto decaracteres. 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 comapenas aspas simples como usando aspas duplas. Exemplo:variavel = ’Ola mundo!’print variavelOla mundo!E da mesma forma:variavel = "Ola mundo!"print variavelOla mundo!

com certeza você deve estar rindo dos desenvolvedores do Python, se perguntando o porquede 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 1variavel = ’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 ficaria o exemplo acima:

variavel = "Estamos estudando ’Python’"print variavelEstamos 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:

variavel = ’Estamos estudando \’Python\”print variavelEstamos estudando ’Python’

contudo esta forma é um tanto quanto confusa dependendo do que você esta atribuindo a suavariá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ídatenha a forma que quisermos. Por exemplo, poderíamos querer tabular ou adicionar uma linha embranco a mais em uma saída e podemos faze-lo apenas adicionando estes caracteres. Abaixotemos 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ífica de Python para as strings, as aspas triplas.Quando um texto esta entre aspas triplas, Python entende como uma entrada de texto que nãodeve ser formatada, o que quero dizer com isso? Que todo texto entre este tipo de aspas vai serimpresso 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 programasaida É um arquivo de saída do programaopcional É 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 programasaida É um arquivo de saída do programaopcional É 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 digitamosdentro 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 duassã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étodosneste 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étodosficaria 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 comalguns objetos interessantes, vamos ver mais alguns operações.

Como comentamos acima, a multiplicação também é uma operação muito divertida! Vejamoscomo 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 fazervocê amar Python! A operação de SLICE.

Variáveis que contém objetos do tipo string podem ter os seus textos cortados da forma queo 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 issofunciona? 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 daposiçã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 emuma 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 floats

• \%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 deformatação, seguido do valor ou variável a substituir:

»> print a \% 10Total de itens: 10

Como pode ser visto, o símbolo é substituído pelo valor fornecido. Podem ser utilizados tantovalores explícitos quanto variáveis para a substituição:

»> custo = 5.50»> print b \% custoCusto: 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 reservarum tamanho total à string:

»> a = "Quantidade: \%4d"»> print a \% 3»> print a \% 53»> print a \% 120Quantidade: 3Quantidade: 53Quantidade: 120

É possível controlar a formatação de tipos numéricos de maneira especial através de modifi-cadores nos símbolos no formato m.n. Como acima, m indica o total de caracteres reservados.

37


Para floats, n indica o número de casas decimais; para inteiros, indica o tamanho total do número,preenchido com zeros à esquerda. Ambos os modificadores podem ser omitidos.

»> e = 2.7313»> p = 3.1415»> sete = 7»> print "Euler: \%.7f"\% e # 7 casas decimaisEuler: 2.7313000»> print "Pi: \%10.3f"\% p # 10 espaços, 3 casasPi: 3.142»> print "Sete: \%10.3d"\% sete # 10 espaços, 3 dígitosSete: 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éricox.isalpha() Verifica se a String tem o conteúdo apenas alfabéticox.islower() Verifica se a String tem o conteúdo minúsculo.x.isupper() Verifica se a String tem o conteúdo em maiúsculox.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 Stringx.find(parâmetro) Procura por uma ocorrência de determinado caractere em um

String, e retorna o seu endereço dentro da String. Retornando -1indica 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 possuiroperadores 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 comobjetos numéricos, os lógicos se utilizam destes objetos para conseguir relações que possam serconectadas 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 adireita de uma expressão para a variável ou variáveis a esquerda da expressao. Exemplo:

»> numero = 10»> print numero10

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 + 34»> 4 - -26»> soma = 1 + 1»> soma + 79»> soma / 21»> soma \% 20»> soma += 1»> soma \% 21»> 2**38

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 ooperador de diferença. Podemos realizar alguns teste dentro do interpretador que retornará Falsequando a operação for false ou True quando for verdadeira, veja:

»> 1 > 2False»> 2 >= 2True»> 3 == 4False»> 3 != 4True»> 3 <> 4True

41


»> 3 > 2 > 1True

As expressões são testadas em tempo real, sendo avaliadas da direita para a esquerda, e umobjeto 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 tabelasquais são:

Operador Açãoand E lógicoor OU lógiconot 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. Vejaque 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 fins: 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çõesserã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 » 12# cada bit deslocado à esquerda equivale à multiplicar por 2»> 4 « 18»> 4 & 10»> 4 | 15»> 4 ^15»> ~4-5

Como vemos nos exemplos, o deslocamento à esquerda significa divisão por 2n, onde n é ovalor 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 &:

100001 &=000

Temos como resposta 0. Agora para o | e para o ^, que possuem a mesma resposta nestecaso, temos o seguinte:

100001 |=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 "Boanoite"de acordo com o horário do dia. Pode querer também que o usuário digite uma palavrasecreta 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. EmPython 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. Aparte de condição pode incluir um operador de comparação. Vamos iniciar mostrando o maisbásico dos operadores, o de igualdade: ==. Um uso comum desse operador é testar se umavariá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 osoperadores > 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 algoelif condição :faça algoelif condição :faça algo...else :faça algo

Exemplo:

x = int(raw_input("Entre com um inteiro:"))if x < 0:x = 0print ’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 nenhumadas 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++. Nestecaso, 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, ouseja, percorre cada item em sequência.Exemplo:for cadaNumero in [0, 1, 2, 3, 4, 5, 6, 7]:print cadaNumero01234567Exemplo:

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 itememailnet-surfingchat

O Python tem um funcao built-in que gera uma lista, a funcao range().Exemplo:for i in range(1,5):print ielse:print ’Fim do looping...’1234Fim 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 final 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*224681012141618

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çãoExemplo:counter = 0while counter < 5:print ’loop #\%d’ \% (counter)counter = counter + 1loop #0loop #1loop #2loop #3loop #4

Opcionalmente, podemos ter uma condição else no looping whileExemplo:x = 0while x < 5:x = x + 1print "Valor de x = ", xelse:print "Saindo do looping..."Valor de x = 1Valor de x = 2Valor de x = 3Valor de x = 4Valor de x = 5Saindo do looping...

6.5 break e continue

O break quebra o laço mais interno de um for ou while.Exemplo:ss = 1while True:print ss,if (ss == 9):breakprint ",",ss = ss + 11 , 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:continueprint x1357

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, float 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 listae 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. Seadicionarmos um valor diretamente a lista, retornaremos um erro, pois não é possível adicionarvalores diretamente a lista, sendo necessário utilizarmos outro método.

»> lista+22Traceback (most recent call last):File «pyshell#134>", line 1, in -toplevel-lista+22TypeError: can only concatenate list (not "int") to list

Porém se fizermos 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-ficar 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"Traceback (most recent call last):File «pyshell#138>", line 1, in -toplevel-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 definir 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 outralista. 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 valordentro 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")Traceback (most recent call last):File «pyshell#168>", line 1, in -toplevel-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 listaFalse

Se o valor retornar True significa que temos o valor na lista, caso contrário teremos o valor Falsecomo acima. Lembre-se que é diferenciado letras maiúsculas de minúsculas, de modo que sevocê 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 servelista.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 umanova. 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 delistas em tuplas.

7.5 Sets

Um set é uma coleção não-ordenada e que não contém duplicações de elementos. O usobá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)»> resultadoset([′pera′,′ laranja′,′ banana′,′maca′])»> ’laranja’ in resultadoTrue

Podemos também eliminar duplicatas em uma palavra:

»> a = set(’asdadasdad’)»> a #letras únicas em aset([′a′,′ s′,′ d′])»> b = set(’abcbcdyyx’)»> b #letras únicas em bset([′a′,′ c′,′ b′,′ d′,′ y′,′ x′])»> b - a #letras em b que não estão em aset([′y′,′ x′,′ c′,′ b′])»> b | a #letras em b ou em aset([′a′,′ c′,′ b′,′ d′,′ y′,′ x′,′ s′])»> b & a #letras em b e em aset([′a′,′ d′])»> b ^a #letras em a ou em b, mas não nos doisset([′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 sistemade localização dos valores fica 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 definimos 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 umanova chave e um novo valor fazemos assim:

»> cadastro[′Signo′]="Leão"»> cadastro{’idade’: ’22’, ’Signo’: ’Le\xe3o’, ’Nome’: ’Fabio Rizzo’}

Dessa forma adicionamos uma nova chave e valor ao dicionário cadastro. E para alterarmosum valor de uma determinada chave:

»> cadastro{’idade’: ’22’, ’Signo’: ’Le\xe3o’, ’Nome’: ’Fabio Rizzo’}»> cadastro[′Nome′]="Fabio Rizzo Matos"»> cadastro{’idade’: ’22’, ’Signo’: ’Le\xe3o’, ’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′]Traceback (most recent call last):File «pyshell#14>", line 1, in -toplevel-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’: ’Le\xe3o’, ’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 servedicionario.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 adicionarum 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. Pythonconsegue 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 servew 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 quantidadede dados e retorna como uma string. tamanho é um argumento numérico opcional. Quando oargumento tamanho é omitido ou negativo, é retornado o conteúdo inteiro do arquivo. Se o finaldo 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. Casoseja 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 arquivo\012’»> f.readline()

readlines() utiliza readline() repetidamente, e retorna uma lista contendo o dado de cada todas aslinhas do arquivo.

»> f.readlines()[Primeiralinhadoarquivo.\012′,′ Segundalinhadoarquivo\012′]

write(string) escreve o conteudo de uma string no arquivo.

»> f.write(’Este e um teste\n’)

Quando você terminar de manipular o arquivo, utilize a função close() para fechar o arquivo eliberar os recursos que foram utilizados ao se abrir o arquivo. Lembre-se que uma vez fechado oarquivo, qualquer tentativa de usá-lo novamente irá falhar.Exemplo:

»> f.close()»> f.read()Traceback (innermost last):File «stdin>", line 1, in ?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 allLinesprint eachLineExemplo:# Copia o conteúdo de um arquivo para outro

# Abre arquivos para leitura e escritainp = open("entrada.txt","r")outp = open("saida.txt","w")

# Le o arquivo e copia cada linha para o arquivo de saídafor 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 paraum conjunto de instruções, e que você possa rodar este conjunto de instruções simplesmentechamando 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 definidas utilizando se a palavra def, seguido do nome que irá identi-ficar a função, seguido de 0 ou mais argumentos que estarão entre chaves. Em seguida, temos obloco 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 outrasvariáveis que tenham o mesmo nome mas estejam fora da função. Ou seja, as variáveis sãolocais à função. Isto também é conhecido como escopo da variável. Todas as variáveis tem oescopo 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 = 50Valor de x local mudado para 10»> print "valor de x externo = ", xvalor de x externo = 50

No exemplo acima, podemos ver que uma alteração da variável x dentro da função não tevereflexos 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 modificado para 10»> print "Valor de x = ", xValor de x = 10

8.4 Argumentos padrões

Para algumas funções, você pode querer que alguns dos parâmetros se tornem opcionais epossuam 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 (seuvalor 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 especificar apenas algunsdeles, 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 dosargumentos

• 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 simplesmentepara sair dela sem retornar um valor. Na verdade, todas as funções que não retornam um valorexplícitamente, retornam o valor None.

»> def testandoRetorno():... x = 0... while (True):... if x > 5:... return... print "x = ", x... x = x + 1...»>»> testandoRetorno()x = 0x = 1x = 2x = 3x = 4x = 5

Neste caso, utilizamos o comando return para sair da função imediatamente. Lembre-se quecaso 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 umaboa forma de documentação e organização, tal documentação pode ser chamada em tempo deexecuçã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 emdiversos pontos do mesmo arquivo.

A medida que seu programa cresce, é desejavel separá-lo em diversos arquivos para facilitara 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 suasfuncionalidades.

8.10 Criando um módulo

Vamos criar um módulo que defina a função de Fibonacci. Abra o seu editor de texto favoritoe 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, 1while 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ódulosno 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 necessidadede 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 algunsdeles.

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 dosdiretórios de busca de módulos do python, argv, a lista de parâmetros passados na linha decomando e exit(), uma função que termina o programa.

• time: oferece funções para manipular valores de tempo. Inclui: time(), uma função queretorna 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(), quecria diretórios; rename(), que altera nomes e caminhos de arquivos; e system, que executacomandos 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 retornauma 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 comométodos da string). Inclui: split(c, s, p), que divide a string c em até p partições separadaspelo símbolo s, retornando-as em uma lista; lower(c), que retorna a string c convertida emminúsculas; e strip(c), que retorna c removendo espaços e quebras de linha do seu início efim.

• math: funções matemáticas gerais. Inclui funções como cos(x), que retorna o cosseno dex; 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.pi3.1415926535897931»> math.e2.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), queretorna 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 quepassamos para o interpretador na linha de execução. Inclui: getopt(), que retorna duaslistas, 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áfica, incluindojanelas, botões e campos texto.

• urllib2: proporciona uma interface de conexão e tratamento de URLs»> import urllib2»> for line inurllib2.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 destesmó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. Justamentepor 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ídaem 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çãode imagens. http://www.pythonware.com/products/pil/ NumPy: provê mecanismos simples e dealto desempenho para manipular matrizes multi-dimensionais; ideal para operações numéricasde alto volume que necessitem de velocidade. http://numpy.sourceforge.net/

HTMLgen: uma biblioteca de classes que gera documentos HTML conforme padrões pré-definidos.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ódulosimplementam 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 ehora, 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 usadoem 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-plataformausando 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 pormeio 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 listammó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, oque aconteceria se seu programa lesse um arquivo mas ele não existisse, ou se você tivesseexcluído ele acidentalmente no meio do programa? Neste capítulo, veremos como o Python lidacom 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’File «stdin>", line 1while 1 print ’Ola Mundo’^SyntaxError: invalid syntax

O erro é causado pela instrução que esta imediatamente antes da seta. No exemplo acima, oerro é detectado na palavra chave print, pois não temos os dois pontos ’:’ imediatamente antesda instrução.

»> Print ’ola mundo’File «stdin>", line 1Print ’ola mundo’^SyntaxError: invalid syntax

Neste caso, o erro esta no comando Print, que deveria ser print. Não se esqueça que o Pythondiferencia 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 demelhorar o aplicativo desenvolvido, podendo antecipar e simular erros que poderao acontecer. Amaioria das exceções não são tratadas, resultando em mensagens de erros como no exemplo aseguir:

# Divisão por 0»> 10 * (1/0)Traceback (innermost last):File «stdin>", line 1ZeroDivisionError: integer division or modulo

# Tentativa de somar string com inteiro»> ’2’ + 2Traceback (innermost last):File «stdin>", line 1TypeError: illegal argument type for built-in operation

A ultima linha da mensagem de erro indica o que ocorreu. Exceções podem ser de diferentestipos (ZeroDivisionError e TypeError para os nossos exemplos). Vemos que logo após o tipo doerro, 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 naclá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:

fluxo 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.000300032.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 tiposde 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’Traceback (innermost last):File «stdin>", line 1NameError: Descricao

O primeiro argumento é o nome da exceção a ser lançada. O segundo argumento, é opcional eespecifica 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 devemser executados em qualquer circunstâncias.A cláusula finally é executada com ou sem a ocorrência de uma exceção no bloco try. Quandouma exceção ocorre, ela é re-lançada após a execução da cláusula finally. O código na cláusulafinally é útil para liberar recursos, como por exemplo, fechar arquivos ou conexão com banco dedados.

Por exemplo:

»> try:... raise KeyboardInterrupt... finally:

70


... print ’Goodbye, world!’

...Goodbye, world!Traceback (most recent call last):File «stdin>", line 2, in ?KeyboardInterrupt

A cláusula try pode ter uma ou mais cláusulas except ou uma cláusula finally, 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 é conhecidocomo 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 utilizarum 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 umalinguagem de programação específica.

10.2 Conceitos OO

Nesta seção, vamos conhecer alguns dos conceitos básicos de OO, dando alguns exemplosde como isto é aplicado para a linguagem Python.

10.3 Classes

Classes são agrupamentos de objetos (computacionais) que têm propriedades em comum epodem realizar as mesmas ações. A classe pode ser vista como um molde para um objeto, ouseja, ela não tem existência própria durante a execução do programa. Durante a execução sãomanipulados 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 Mariapropriedades 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, definimos 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. Iremosaprender 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 precisaser 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 comouma 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 aoproblema 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çãoda classe é utilizada como um modelo informando como alocar o espaço de dados necessáriopara 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 GATOObjetos Tom, Garfield, Fi-fi, etc.

Classe PESSOAObjetos Rosiane, Ana, José, etc.

Classe DISCIPLINAObjetos 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 quese 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 dealguma 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 umainstâ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ísticasespecí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étodosdaquela classe.

75


Métodos são as operações ou comportamentos realizados por um objeto. São as funções outransformações que podem ser aplicadas (em/ou por) um objeto de uma classe, em resposta aosestí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 davariável, isto será refletido para o outro objeto. Uma analogia para quem programa em Java porexemplo, seria o modificar static, que desempenha a mesma função. Em Python, utilizamos umavariá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»> paulo.getIdade()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ãoserá 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»> paulo.getIdade()0»> joao = setIdade(21)»> joao.getIdade()21»> paulo.getIdade()0

10.9 Variáveis privadas

Variáveis privadas são aquelas que estão visíveis apenas no escopo da classe em que foramdeclaradas, 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 davariável. Isso permite que a visibilidade das variáveis sejam facilmente diferenciadas apartir donome delas.

10.10 O método init

Quando definido dentro de uma classe, o método __init__ é chamado toda vez que uma novainstância daquela classe é criada. Isto permite que você possa inicializar o objeto da maneira quedeseja, 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 argumentoextra, a palavra self.

Note que nós não especificamos self quando chamamos o método. Todos os métodos de Pythontrabalham assim. Este argumento representa a instância, e o Python esconde ele por trás dospanos.

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, masapenas nome significaria a variável local nome. E como você sabe, variáveis locais deixam deexistir 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: FulanoClasse Herdada - Nome Maiusculo: FULANOmaior 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õesde textos em certas strings de dados (textos ou palavras).

A RE é definida por um sequência de caracteres (também chamados metacaracteres) com umsignificado especial. Quando bem construídas, as RE nos permitem encontrar padrões de textosem 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 programaque usa RE. Ele conta quantas linhas de um arquivo texto contém a palavra ’hello’. A linha quecontiver ’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õesregulares, chamado ’re’. A seguir, o programa pega a string ’hello’ como uma expressão regulartextual e a compila, usando para isto a função re.compile. Isto não é estritamente necessário (omó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 aexpressão regular, criamos um objeto chamado ’regexp’. Como todo objeto, este também possuialguns 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 metodosearch. Este método retorna true se a linha lida contém a string correspondente ao objeto regexpe false em caso negativo (nós vamos falar mais sobre o search na próxima seção). Portanto, sea linha do ’if’ retornar true, adicionamos mais 1 (um) no contador. Ao final da leitura do arquivotexto, 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ãoestamos 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’. Umaoutra 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, especificandouma 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 comececom "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 seutilizarmos o objeto regexp.

O ” talvez seja um dos metacaracteres mais utilizados. Você pode usa-lo seguido de várioscaracteres para sinalizar sequências especiais. Ele tambem é usado para ’escapar’ todos osoutros metacaracteres. Por exemplo, se você precisar encontrar em uma string o caracter "["ouo "?", pode usar a seguinte construção: \[ e \? respectivamente. Veja algumas das sequênciasespeciais:

• \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 [ \t\n\r\f\v]

• \S - qualquer caracter que NÃO significa espaço ’ ’, em qualquer quantidade;

• equivale a [^\t\n\r\f\v]

• \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ãofalamos 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ênciade ’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 aocorrê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 caracteresna string desejada. Exemplo: a3, 5 equivale a buscar um mínimo de 3 e ummá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, 5encontramos 5 letras ’a’ e nos é retornado ’aaaaa’ (cinco caracteres). Masquando 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 "?"queisoladamente 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 ounã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 seusarmos RE.

Então vamos começar assumindo que Nome, NomeDoMeio e Sobrenome, todos têm somenteletras e, possivelmente, um hífem. Os metacaracteres [ ] definidos na seção anterior, podem serusados para definir 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. Ometacaracter ’+’ 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 nospermite encontrar ’Marcus-Pedro’. Esta RE também nos permite encontrar coisas que não sãona 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:

\d\d\d-\d\d\d-\d\d\d\d

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 quaisos números de telefone contivessem o código de área. Então vamos mudar esta RE para:

(\d\d\d-)?\d\d\d-\d\d\d\d

Agora a sequência (\d\d\d-) é 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]+)?: (\d\d\d-)?\d\d\d-\d\d\d\d

Poderíamos ter um programa em python assim:

import reregexp= re.compile(# Sobrenome e vírgular"[−a− zA− Z]+,"# Nomer"[−a− zA− Z]+"# NomeDoMeio opcionalr"([−a− zA− Z]+)?"# dois pontos, espaço e NumeroTelefoner": (\d\d\d-)?\d\d\d-\d\d\d\d

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ênciade caracteres. Mas e se nós pudermos extrair dados destas RE’s? Pois é, nós podemos. Paraisto vamos usar o conceito de ’grupos’. A idéia é que podemos dar ’nomes’ aos padrões quebuscamos 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>(\d\d\d-)?\d\d\d-\d\d\d\d)

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 ficariao nosso programa agora:


import reregexp= re.compile(# Sobrenome e virgular"(?P<last>[−a− zA− Z]+),"# espaco e Nomer"(?P<first>[−a− zA− Z]+)"# espaco NomeDoMeio opcionalr"( (?P<middle>([−a− zA− Z]+)))?"# dois pontos, espaco e NumeroTelefone r": (?P<phone>(\d\d\d-)?\d\d\d-\d\d\d\d)")

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-9999Joaozinho, Trinta: 888-8888Uma 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 exemploa seguir ilustra isto. Nós vamos trocar a ocorrência de uma string que contém ’Perl’ e vamossubstituir 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 quedesejamos colocar em Frase. O segundo argumento é onde queremos que a substituição sejafeita. 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 opadrã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. É abiblioteca 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 programasem 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 ótimaqualidade disponíveis na Web.

Desvantagens:

• Pobre - Faltam muitos componentes importantes, como notebooks e combo box (apesarde estes poderem ser feitos combinando outros componentes). Alguns elementos (listboxpor exemplo) são incompletos ou limitados. Em compensação o componente Text é muitopoderoso.

• Aparência - A Tk usa uma função própria para acessar diretamente as funções do sistemaoperacional e desenhar seus próprios elementos na tela. Isso tem a vantagem de ser maisfacilmente portável, mas a grande desvantagem de ter uma aparência diferente da nativado 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 GIMPToolkit (GTK), a biblioteca usada pelo GNOME e muitas outras aplicações para Linux. Tem ótimodesempenho, 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 (paragtk 2.X) não tem o mesmo desempenho, mas é bem satisfatória.

• Documentação - Bem documentada. Existem bons tutoriais para ambas as versões. Apesarde não haver uma referência completa para PyGTK 0.X, existe uma muito boa para a versão2.X.

• API - PyGTK usa uma API eficiente, baseada em propagação de sinais e callbacks. Umelemento qualquer emite um sinal, que é propagado "pra cima"até ser capturado e gerar achamada de um callback.

89


• IDE - Possui uma ferramenta para construção de interfaces, o Glade, que permite gerar umareferência em XML da interface, que pode ser usada diretamente pela biblioteca.

• Portabilidade - Portar aplicações de PyGTK para Windows é facil. Normalmente sem trocaro 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, chamandoa classe, configurá-lo através dos seus métodos de configuração, posicioná-lo e por fimmostrá-lo com o método show(). São no mínimo três chamadas de métodos pra cadaobjeto. Como resultado disso, temos arquivos de código fonte imensos. Linhas e maislinhas 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 doPyGTK, 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, odesempenho do PyQT é bem próximo do Qt quando usado com C++.

• Fácil de aprender: A biblioteca Qt é famosa por ser extremamente bem documentada, poisa própria Trolltech possui um time de escritores técnicos. Apesar da documentação ser paraC++, é fácil "traduzir"os exemplos para Python. Existe também um ótimo livro online sobrePyQT no site opendocs.org

• API: A API do PyQT utiliza um sistema de "slots"e "sinais", levemente similar ao sistema desinais 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ãoser usado por outros programas.

Desvantagens:

• Portabilidade: Usar o PyQT é excelente para programas Linux (em especial para rodarem cima do KDE, embora isso não seja obrigatório), mas como não existe licença GPL paraWindows, 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 asquais se encontra disponível também o PyQt para Windows. DLLs para fins não comerciaisda Qt 3.x somente se encontram disponíveis no livro C++ GUI Programming with Qt 3.

Exemplo de código:

import sysfrom 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ãofacilmente portáveis. A diferença é que a wxWindows utiliza um wrapper sobre a interface gráficapadrã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. Emcompensação, o desempenho vai ladeira abaixo com o acréscimo de mais uma camada entre aaplicação e o sistema operacional.

Vantagens:

• Portabilidade - Aplicações escritas em wxPython rodam praticamente sem problemas emvá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 aScintilla.

• Documentação - o wxPython vem com um demo da maioria dos seus widgets que servecomo teste e exemplo de uso.

Desvantagens:

92


• Desempenho - A performance das aplicações em si não é ruim. O problema é o uso dememó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 reportandobugs.

• API complicada - wxWindows é uma biblioteca com quase 10 anos de idade, que foi sendoremendada precariamente com o passar dos anos. Apesar da wxPython ser um wrapperexcelente, muito bem escrito, os problemas da wxWindows aparecem: API completamentediferente entre alguns componentes e outros, números de ID, macros, etc. Porém temmelhorado 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í-fica para wxPython. Para uma referência da biblioteca, tem de se recorrer à referência dawxWindows. Entretanto, muitas vezes basta seguir o código dos demos (em Python), semser necessário recorrer a documentação do wxWindows.

• IDEs Livres - O wxDesigner é um IDE bom, mas é comercial. Não há nenhum IDE RAD dequalidade e que seja disponível livremente, embora o BoaConstructor pareça muito promis-sor.

Mais informações:

http://www.wxpython.org/

93

Python

Documents

Transcript of Python