Computação Científica Com Python

Computao
Cientca
com Python
Computao
Cientca
com Python
Uma introduo programao
para cientistas
Flvio Codeo Coelho
Petrpolis RJ
Edio do Autor
2007

c 2007 Flvio Codeo Coelho
Todos os direitos reservados.
ISBN: 978-85-907346-0-4
Capa: Mosaico construdo com as guras deste livro imitando o logotipo da

linguagem Python. Concebido e realizado pelo autor, com o auxlio do software
livre Metapixel.
Reviso ortogrca: Paulo F. Coelho e Luciene C. Coelho.
Edio do autor. Petrpolis - RJ - Brasil
Primeira Edio: Julho 2007

Este livro dedicado minha esposa e meu lho, sem
os quais nada disso valeria a pena.
Agradecimentos
Muitas pessoas foram indispensveis para que este livro se tornasse
uma realidade. Seria impossvel listar todas elas. Mas algumas
guras fundamentais merecem uma meno especial.
Richard M. Stallman. Sem o Software Livre tudo o que eu sei

sobre programao, provavelmente se reduziria a alguns co-
mandos de DOS.
Linus Torvalds. Sem o Linux, nunca teria me aproximado o su-

ciente da programao para conhecer a linguagem Python.
Guido van Rossum. Muito obrigado por esta bela linguagem, e

por acreditar que elegncia e clareza so atributos importan-
tes de uma linguagem de programao.
Comunidade Python. Obrigado por todas esta extenses ma-

ravilhosas ao Python. comunidade de desenvolvedores do
Numpy e Scipy segue um agradecimento especial por facilitar
a adoo do Python por cientistas.
Alem destas pessoas gostaria ainda de agradecer ao Fernando Pe-

rez (criador e mantenedor do Ipython) por este incrivelmente til
software e por permitir que eu utilizasse alguns dos exemplos da
sua documentao neste livro.
Sumrio
Sumrio i
Lista de Figuras vii
Lista de Tabelas x
Listagens xi
Prefcio: Computao Cientca xvii
Da Computao Cientca e sua denio pragmtica.
Do porqu esta se diferencia, em metas e ferramentas, da
Cincia da Computao.
I Python 1
1 Fundamentos da Linguagem 3
Breve introduo a conceitos bsicos de programao
e linguagem Python. A maioria dos elementos bsicos
da linguagem so abordados neste captulo, com exceo
de classes, que so discutidas em detalhe no captulo 2.
Pr-requisitos: Conhecimentos bsicos de programao
em qualquer linguagem.
i
ii SUMRIO
1.1 Primeiras impresses . . . . . . . . . . . . . . . . . . 3
1.2 Uso Interativo vs. Execuo a Partir de Scripts . . . 5
Operaes com Nmeros . . . . . . . . . . . . . . . . 8
1.3 Nomes, Objetos e Espaos de Nomes . . . . . . . . . 11
1.4 Estruturas de Dados . . . . . . . . . . . . . . . . . . 13
Listas . . . . . . . . . . . . . . . . . . . . . . . . . . 13
Tuplas . . . . . . . . . . . . . . . . . . . . . . . . . . 20
Strings . . . . . . . . . . . . . . . . . . . . . . . . . . 22
Dicionrios . . . . . . . . . . . . . . . . . . . . . . . 24
Conjuntos . . . . . . . . . . . . . . . . . . . . . . . . 27
1.5 Controle de uxo . . . . . . . . . . . . . . . . . . . . 28
Condies . . . . . . . . . . . . . . . . . . . . . . . . 28
Iterao . . . . . . . . . . . . . . . . . . . . . . . . . 29
Lidando com erros: Excees . . . . . . . . . . . . . 32
1.6 Funes . . . . . . . . . . . . . . . . . . . . . . . . . 34
Funes lambda . . . . . . . . . . . . . . . . . . . . . 37
Geradores . . . . . . . . . . . . . . . . . . . . . . . . 38
Decoradores . . . . . . . . . . . . . . . . . . . . . . . 39
Strings de Documentao . . . . . . . . . . . . . . . 41
1.7 Mdulos e Pacotes . . . . . . . . . . . . . . . . . . . 42
Pacotes teis para Computao Cientca . . . . . . 45
1.8 Documentando Programas . . . . . . . . . . . . . . . 47
Pydoc . . . . . . . . . . . . . . . . . . . . . . . . . . 48
Epydoc . . . . . . . . . . . . . . . . . . . . . . . . . 49
1.9 Exerccios . . . . . . . . . . . . . . . . . . . . . . . . 50
2 Orientao a Objeto 51
Introduo programao orientada a objetos e sua
implementao na linguagem Python. Pr-requisitos:
Ter lido o captulo 1.
2.1 Objetos . . . . . . . . . . . . . . . . . . . . . . . . . 52
Denindo Objetos e seus Atributos em Python . . . 53
Adicionando Funcionalidade a Objetos . . . . . . . . 55
Herana . . . . . . . . . . . . . . . . . . . . . . . . . 56
iii
Utilizando Classes como Estruturas de Dados Gen-

ricas. . . . . . . . . . . . . . . . . . . . . . . . 57
2.2 Exerccios . . . . . . . . . . . . . . . . . . . . . . . . 57
3 Criando Grcos em Python 59

Introduo produo de guras de alta qualidade uti-
lizando o pacote matplotlib. Pr-requisitos: Captulo 1.
3.1 Introduo ao Matplotlib . . . . . . . . . . . . . . . 59
Congurando o MPL . . . . . . . . . . . . . . . . . . 61
Comandos Bsicos . . . . . . . . . . . . . . . . . . . 62
3.2 Exemplos Simples . . . . . . . . . . . . . . . . . . . 63
O comando plot . . . . . . . . . . . . . . . . . . . . 63
O Comando subplot . . . . . . . . . . . . . . . . . . 65
Adicionando Texto a Grcos . . . . . . . . . . . . . 68
3.3 Exemplos Avanados . . . . . . . . . . . . . . . . . . 69
Mapas . . . . . . . . . . . . . . . . . . . . . . . . . . 69
4 Ferramentas de Desenvolvimento 73
Exposio de ferramentas voltadas para o aumento da
produtividade em um ambiente de trabalho em computa-
o cientca. Pr-requisitos: Captulos 1 e 2
4.1 Ipython . . . . . . . . . . . . . . . . . . . . . . . . . 73
Primeiros Passos . . . . . . . . . . . . . . . . . . . . 74
Comandos Mgicos . . . . . . . . . . . . . . . . . . . 75
4.2 Editores de Cdigo . . . . . . . . . . . . . . . . . . . 80
Editores Genricos . . . . . . . . . . . . . . . . . . . 80
Editores Especializados . . . . . . . . . . . . . . . . 83
4.3 Controle de Verses em Software . . . . . . . . . . . 86
Entendendo o Mercurial . . . . . . . . . . . . . . . . 88
5 Interagindo com Outras Linguagens 99

Introduo a vrios mtodos de integrao do Python
com outras linguagens. Pr-requisitos: Captulos 1 e 2.
5.1 Introduo . . . . . . . . . . . . . . . . . . . . . . . . 99
iv SUMRIO
5.2 Integrao com a Linguagem C . . . . . . . . . . . . 100
Weave . . . . . . . . . . . . . . . . . . . . . . . . . . 100
Ctypes . . . . . . . . . . . . . . . . . . . . . . . . . . 105
Pyrex . . . . . . . . . . . . . . . . . . . . . . . . . . 106
5.3 Integrao com C++ . . . . . . . . . . . . . . . . . . . 111
Shedskin . . . . . . . . . . . . . . . . . . . . . . . . . 112
5.4 Integrao com a Linguagem Fortran . . . . . . . . 117
f2py . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
5.5 A Pton que sabia Javans Integrao com Java . 126
O interpretador Jython . . . . . . . . . . . . . . . . 126
Criando Applets em Jython . . . . . . . . . . . . . 128
5.6 Exerccios . . . . . . . . . . . . . . . . . . . . . . . . 131
II Aplicaes 133
6 Modelagem Matemtica 135

Introduo modelagem matemtica e sua implemen-
tao computacional. Discusso sobre a importncia da
Anlise dimensional na modelagem e apresentao do pa-
cote Unum para lidar com unidades em Python. Pr-
requisitos:Conhecimentos bsicos de clculo.
6.1 Modelos . . . . . . . . . . . . . . . . . . . . . . . . . 137
Lineares . . . . . . . . . . . . . . . . . . . . . . . . . 137
Exponenciais . . . . . . . . . . . . . . . . . . . . . . 142
6.2 Construindo Modelos Dinmicos . . . . . . . . . . . 145
Modelando Iterativamente . . . . . . . . . . . . . . . 145
Integrao Numrica . . . . . . . . . . . . . . . . . . 148
6.3 Grandezas, Dimenses e Unidades . . . . . . . . . . 155
Anlise Dimensional . . . . . . . . . . . . . . . . . . 158
O Pacote Unum . . . . . . . . . . . . . . . . . . . . . 159
6.4 Exerccios . . . . . . . . . . . . . . . . . . . . . . . . 167
v
7 Teoria de Grafos 169

Breve introduo a teoria de grafos e sua represen-
tao computacional. Introduo ao Pacote NetworkX,
voltado para a manipulao de grafos. Pr-requisitos:
Programao orientada a objetos.
7.1 Introduo . . . . . . . . . . . . . . . . . . . . . . . . 169
7.2 NetworkX . . . . . . . . . . . . . . . . . . . . . . . . 172
Construindo Grafos . . . . . . . . . . . . . . . . . . . 173
Manipulando Grafos . . . . . . . . . . . . . . . . . . 174
Criando Grafos a Partir de Outros Grafos . . . . . . 175
Gerando um Grafo Dinamicamente . . . . . . . . . . 176
Construindo um Grafo a Partir de Dados . . . . . . 179
7.3 Exerccios . . . . . . . . . . . . . . . . . . . . . . . . 182
8 Interao com Bancos de Dados 185

Apresentao dos mdulos de armazenamento de da-
dos Pickle e Sqlite3 que fazem parte da distribuio pa-
dro do Python. Apresentao do pacote SQLObject para
comunicao com os principais sistemas de bancos de da-
dos existentes. Pr-requisitos: Conhecimentos bsicos
de bancos de dados e SQL.
8.1 O Mdulo Pickle . . . . . . . . . . . . . . . . . . . . 186
8.2 O mdulo Sqlite3 . . . . . . . . . . . . . . . . . . . . 187
8.3 O Pacote SQLObject . . . . . . . . . . . . . . . . . . 190
Construindo um aranha digital . . . . . . . . . . . . 190
8.4 Exerccios . . . . . . . . . . . . . . . . . . . . . . . . 197
9 Simulaes Estocsticas 199

Seleo de problemas relacionados com a simulao e
anlise de processos estocsticos. Pr-requisitos: Co-
nhecimentos avanados de estatstica.
9.1 Nmeros Aleatrios . . . . . . . . . . . . . . . . . . . 199
Hipercubo Latino - LHS . . . . . . . . . . . . . . . . 200
9.2 Inferncia Bayesiana . . . . . . . . . . . . . . . . . . 203
vi SUMRIO
9.3 Simulaoes Estocsticas . . . . . . . . . . . . . . . . 205
Integrao Monte Carlo . . . . . . . . . . . . . . . . 205
9.4 Amostragem por Rejeio . . . . . . . . . . . . . . . 207
Mtodo do Envelope . . . . . . . . . . . . . . . . . . 208
Aplicando ao Teorema de Bayes . . . . . . . . . . . . 210
9.5 Cadeias de Markov . . . . . . . . . . . . . . . . . . . 214
9.6 MCMC (Markov Chain Monte Carlo) . . . . . . . . 217
O Amostrador de Metropolis-Hastings . . . . . . . . 217
O Amostrador de Gibbs . . . . . . . . . . . . . . . . 220
9.7 Mtodos Monte Carlo Sequenciais . . . . . . . . . . 223
Sampling Importance Resampling SIR . . . . . . . 224
9.8 Funes de Verossimilhana . . . . . . . . . . . . . . 229
Denio da funo de verossimilhana . . . . . . . . 229
9.9 Inferncia Bayesiana com Objetos. . . . . . . . . . . 235
9.10 Exerccios . . . . . . . . . . . . . . . . . . . . . . . . 248
Console Gnu/Linux 253

Guia de sobrevivncia no console do Gnu/Linux
A linguagem BASH . . . . . . . . . . . . . . . . . . . . . 254
Alguns Comando teis . . . . . . . . . . . . . . . . . 254
Entradas e Sadas, redirecionamento e "Pipes". . . . . . . 257
Redirecionamento . . . . . . . . . . . . . . . . . . . . 258
Pipelines . . . . . . . . . . . . . . . . . . . . . . . . 258
Prolas Cientcas do Console Gnu/Linux . . . . . . . . . 259
Gnu plotutils . . . . . . . . . . . . . . . . . . . . . . 259
ndice Remissivo 267

Lista de Figuras
1.1 Verso HTML da documentao gerada pelo Epydoc. . . . 50
3.1 Histograma simples a partir da listagem 3.2 . . . . . . . 61

3.2 Reta simples a partir da listagem 3.3 . . . . . . . . . . . 63
3.3 Grco com smbolos circulares a partir da listagem 3.4 65
3.4 Figura com dois grcos utilizando o comando subplot,
a partir da listagem 3.5 . . . . . . . . . . . . . . . . . . 67
3.5 Formatao de texto em guras. Gerada pela listagem
3.6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
3.6 Mapa mundi na projeo de Robinson. . . . . . . . . . . 72
4.1 Editor emacs em modo Python e com Code Browser

ativado . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
4.2 Editor Scite. . . . . . . . . . . . . . . . . . . . . . . . . 83
4.3 Editor Gnu Nano. . . . . . . . . . . . . . . . . . . . . . 84
4.4 Editor Jython Jedit . . . . . . . . . . . . . . . . . . . 85
4.5 IDE Boa-Constructor . . . . . . . . . . . . . . . . . . . 86
4.6 IDE Eric. . . . . . . . . . . . . . . . . . . . . . . . . . . 87
4.7 IDE Pydev . . . . . . . . . . . . . . . . . . . . . . . . . 88
4.8 Diagrama de um repositrio do Mercurial. . . . . . . . . 89
4.9 Operao de commit. . . . . . . . . . . . . . . . . . . . 90
4.10 Repositrio da Ana. . . . . . . . . . . . . . . . . . . . . 91
vii
viii LISTA DE FIGURAS
4.11 Modicaes de Bruno. . . . . . . . . . . . . . . . . . . 92
4.12 Modicaes de Ana. . . . . . . . . . . . . . . . . . . . . 92
4.13 Repositrio atualizado de Bruno. . . . . . . . . . . . . . 93
4.14 Repositrio de Bruno aps a fuso. . . . . . . . . . . . . 94
5.1 Comparao da performance entre o Python e o C (we-

ave) para um loop simples. O eixo y est em escala
logaritmica para facilitar a visualizao das curvas. . . . 103
5.2 Regra trapezoidal para integrao aproximada de uma
funo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
5.3 Sada da listagem 5.25. . . . . . . . . . . . . . . . . . . . 129
6.1 Diagrama de disperso do exemplo do taxi. A reta su-

perior descreve o cenrio com bandeirada e a inferior,
sem bandeirada. . . . . . . . . . . . . . . . . . . . . . . 139
6.2 Populao crescendo de forma linear, devido chegada
de um nmero constante de novos indivduos por ano. . 140
6.3 Populao diminui de forma linear, devido saida de
um nmero constante de indivduos por ano. . . . . . . 141
6.4 Representao grca de um modelo linear. Efeito do
parmetro a. . . . . . . . . . . . . . . . . . . . . . . . . 142
6.5 Representao grca de um modelo linear. Efeito do
parmetro b. . . . . . . . . . . . . . . . . . . . . . . . . 143
6.6 Crescimento de uma populao de bactrias por bipar-
tio. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
6.7 Modelos populacionais discretos. Modelo 2 esquerda
e modelo 1 direita. . . . . . . . . . . . . . . . . . . . . 146
6.8 Grco com o resultado da integrao do modelo 6.2. . 153
7.1 Um grafo simples. . . . . . . . . . . . . . . . . . . . . . 171

7.2 Diagrama de um grafo . . . . . . . . . . . . . . . . . . . 174
7.3 Grafo, produto cartesiano e complemento. . . . . . . . . 177
7.4 Resultado da simulao do exemplo 7.5. . . . . . . . . . 180
7.5 Rede social a partir de mensagens de email. . . . . . . . 183
ix
9.1 Amostragem (n=20) de uma distribuio normal com

mdia 0 por LHS (histograma mais escuro) e amostra-
gem padro do scipy (histograma mais claro). . . . . . . 201
9.2 Distribuio acumulada da varivel x N (0, 1), mos-
trando o particionamento do espao amostral em seg-
mentos equiprovveis. . . . . . . . . . . . . . . . . . . . 202
9.3 Resultado da amostragem por envelope de uma distri-
buio beta(1,1) . . . . . . . . . . . . . . . . . . . . . . 211
9.4 Amostragem por rejeio da posterior Bayesiana. . . . . 214
9.5 Cadeia de Markov com kernel de transio exponencial. 216
9.6 Amostrador de Metropolis-Hastings(n=10000). . . . . . 220
9.7 Estrutura de dependncia circular utilizada na listagem
9.7. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223
9.8 Amostrador de Gibbs aplicado a uma distribuio tri-
variada. . . . . . . . . . . . . . . . . . . . . . . . . . . . 224
9.9 Processo markoviano e suas observaes. . . . . . . . . . 225
9.10 Funo de verossimilhana para a comparao de sequn-
cias de DNA. . . . . . . . . . . . . . . . . . . . . . . . . 232
9.11 Log-verossimilhana da funo descrita anteriormente. . 234
9.12 Resultado da listagem 9.21. . . . . . . . . . . . . . . . . 243
1 Konsole: janela contendo uma sesso bash (ou outra)

no KDE. . . . . . . . . . . . . . . . . . . . . . . . . . . . 255
2 Usando spline. . . . . . . . . . . . . . . . . . . . . . . . 262
3 Interpolando uma curva em um plano. . . . . . . . . . . 263
4 Atrator de Lorenz. . . . . . . . . . . . . . . . . . . . . . 266
Lista de Tabelas
1.1 Mtodos de Listas. . . . . . . . . . . . . . . . . . . . . . 16

1.2 Mtodos de Dicionrios. . . . . . . . . . . . . . . . . . . 26
3.1 Principais comandos de plotagem do MPL . . . . . . . . 62

3.2 Argumentos que podem ser passados juntamente com a
funo plot para controlar propriedades de linhas. . . . 66
3.3 Argumentos opcionais dos comandos de insero de texto. 68
6.1 Valor de corridas de taxi . . . . . . . . . . . . . . . . . . 138

6.2 Dimenses bsicas. . . . . . . . . . . . . . . . . . . . . . 156
6.3 Dimenses derivadas. . . . . . . . . . . . . . . . . . . . . 157
6.4 Prexos de Unidades . . . . . . . . . . . . . . . . . . . . 165
x
Listagens
1.1 O console interativo do Python . . . . . . . . . . . . 3

1.2 Palavras reservadas no podem ser utilizadas como
nomes de variveis . . . . . . . . . . . . . . . . . . . 4
1.3 Denio da palavra reservada for. . . . . . . . . . . 5
1.4 Usando o Python como uma calculadora. . . . . . . 6
1.5 Executando script.py via comando de linha. . . . . . 6
1.7 Executando um script Python executvel. . . . . . . 6
1.6 Tornando um script executvel . . . . . . . . . . . . 7
1.8 Operaes aritmticas . . . . . . . . . . . . . . . . . 8
1.9 Atribuindo valores . . . . . . . . . . . . . . . . . . . 9
1.10 Atribuindo o mesmo valor a mltiplas variveis . . . 9
1.11 Nmeros complexos . . . . . . . . . . . . . . . . . . 10
1.12 Explorando nmeros complexos . . . . . . . . . . . . 10
1.13 Atribuindo objetos a nomes (variveis) . . . . . . . . 11
1.14 Exemplo de NameError . . . . . . . . . . . . . . . . 12
1.15 Criando listas. . . . . . . . . . . . . . . . . . . . . . 14
1.16 Fatiando uma lista . . . . . . . . . . . . . . . . . . . 14
1.17 Selecionando o nal de uma lista. . . . . . . . . . . . 15
1.18 selecionando todos os elementos de uma lista. . . . . 15
1.19 Adicionando elementos a listas. . . . . . . . . . . . . 16
1.20 Estendendo uma lista. . . . . . . . . . . . . . . . . . 17
1.21 Efetuando buscas em listas. . . . . . . . . . . . . . . 17
1.22 Removendo elementos de uma lista. . . . . . . . . . . 18
xi
xii LISTAGENS
1.23 Operaes com listas . . . . . . . . . . . . . . . . . . 18
1.24 Criando listas numricas sequenciais. . . . . . . . . . 19
1.25 Denindo uma Tupla. . . . . . . . . . . . . . . . . . 20
1.26 Outras formas de denir tuplas. . . . . . . . . . . . . 20
1.27 Strings. . . . . . . . . . . . . . . . . . . . . . . . . . 22
1.28 Formatando strings. . . . . . . . . . . . . . . . . . . 23
1.29 Problemas com a concatenao de strings. . . . . . . 24
1.30 Criando e manipulando dicionrios. . . . . . . . . . . 24
1.31 Iterando dicionrios. . . . . . . . . . . . . . . . . . . 25
1.32 Exemplo do emprego de ramicaes. . . . . . . . . 28
1.33 Implementando a funcionalidade de if e elif por
meio de um dicionrio. . . . . . . . . . . . . . . . . . 29
1.34 Comandos de lao no Python. . . . . . . . . . . . . . 30
1.35 A funo enumerate. . . . . . . . . . . . . . . . . . . 30
1.36 Iterando sobre mais de uma sequncia. . . . . . . . . 31
1.37 Iterando sobre uma sequncia ordenada. . . . . . . . 31
1.38 Exemplo de uma exceo . . . . . . . . . . . . . . . 32
1.39 Contornando uma diviso por zero . . . . . . . . . . 33
1.40 Lidando com diferentes tipos de erros. . . . . . . . . 34
1.41 Denindo uma funo com um argumento obrigat-
rio e outro opcional (com valor default"). . . . . . . 35
1.42 lista de argumentos varivel . . . . . . . . . . . . . . 36
1.43 Desempacotando argumentos. . . . . . . . . . . . . . 36
1.44 Passando todos os argumentos por meio de um dici-
onrio. . . . . . . . . . . . . . . . . . . . . . . . . . . 37
1.45 Retornando valores a partir de uma funo. . . . . . 37
1.46 Funes lambda . . . . . . . . . . . . . . . . . . . . . 38
1.47 Geradores . . . . . . . . . . . . . . . . . . . . . . . . 38
1.48 Decorador bsico. . . . . . . . . . . . . . . . . . . . . 39
1.49 Utilizando um decorador . . . . . . . . . . . . . . . . 39
1.50 Limpando a gerao de decoradores . . . . . . . . . . 40
1.51 Usando Docstrings . . . . . . . . . . . . . . . . . . . 41
1.52 Mdulo exemplo . . . . . . . . . . . . . . . . . . . . 43
1.53 Executing a module from the console. . . . . . . . . 44
xiii
1.54 importing a package . . . . . . . . . . . . . . . . . . 45

1.55 Calculando e mostrando o determinante de uma ma-
triz. . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
1.56 Listando as opes do Epydoc. . . . . . . . . . . . . 49
2.1 Denindo uma classe . . . . . . . . . . . . . . . . . . 53
2.2 Denindo atributos de uma classe . . . . . . . . . . . 54
caption=Instanciando uma classe.,label=ex:classe3 . . . . 54
2.3 Passando atributos na criao de um objeto . . . . . 54
2.4 Herana . . . . . . . . . . . . . . . . . . . . . . . . . 56
2.5 Classe como uma estrura de dados . . . . . . . . . . 57
3.1 Instalando o matplotlib . . . . . . . . . . . . . . . . 60
3.2 Criando um histograma no modo interativo . . . . . 60
3.3 Grco de linha . . . . . . . . . . . . . . . . . . . . . 63
3.4 Grco de pontos com valores de x e y especicados. 64
3.5 Figura com dois grcos utilizando o comando subplot. 66
3.6 Formatando texto e expresses matemticas . . . . . 69
3.7 Plotando o globo terrestre . . . . . . . . . . . . . . . 70
5.1 Otimizao de loops com o weave . . . . . . . . . . . 100
5.2 Calculando iterativamente a srie de Fibonacci em
Python e em C(weave.inline) . . . . . . . . . . . . 102
5.3 Executando o cdigo do exemplo 5.2. . . . . . . . . . 105
5.4 Carregando bibliotecas em C. . . . . . . . . . . . . . 106
5.5 Chamando fues em bibliotecas importadas com o
ctypes . . . . . . . . . . . . . . . . . . . . . . . . . . 106
5.6 Calculando nmeros primos em Pyrex . . . . . . . . 107
5.7 Gerando Compilando e linkando . . . . . . . . . . . 108
5.8 Calculando nmeros primos em Python . . . . . . . 109
5.9 Comparando performances dentro do ipython . . . . 110
5.10 Automatizando a compilao de extenses em Pyrex
por meio do setuptools . . . . . . . . . . . . . . . . . 110
5.11 Utilizando Setuptools para compilar extenses em
Pyrex . . . . . . . . . . . . . . . . . . . . . . . . . . 111
5.12 implementao da regra trapezoidal(utilizando lao
for) conforme especicada na equao 5.3 . . . . . . 112
xiv LISTAGENS
5.13 Executando a listagem 5.12 . . . . . . . . . . . . . . 114
5.14 Vericando o tempo de execuo em C++ . . . . . . . 114
5.15 Cdigo C++ gerado pelo Shed-skin a partir do script
trapintloopy.py . . . . . . . . . . . . . . . . . . . . . 115
5.16 implementao em Fortran da regra trapezoidal. label118
5.17 Compilando e executando o programa da listagem ?? 120
5.18 Compilando com f2py . . . . . . . . . . . . . . . . . 121
5.19 Script para comparao entre Python e Fortran via
f2py . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
5.20 Executando trapintloopcomp.py . . . . . . . . . . 123
5.21 Implementao vetorizada da regra trapezoidal . . . 123
5.22 setup.py para distribuir programas com extenses
em Fortran . . . . . . . . . . . . . . . . . . . . . . . 125
5.23 Usando o interpretador Jython . . . . . . . . . . . . 127
5.24 Um programa simples em Java usando a classe Swing.127
5.25 Verso Jython do programa da listagem 5.24. . . . . 128
5.26 Criando um applet em Jython . . . . . . . . . . . . 128
5.27 Compilando appletp.py . . . . . . . . . . . . . . . . 129
5.28 Documento HTML contendo o applet. . . . . . . . 130
6.1 Dois modelos discretos de crescimento populacional . 147
6.2 Integrando um sistema de equaes diferenciais or-
dinrias . . . . . . . . . . . . . . . . . . . . . . . . . 149
6.3 Integrao numrica utilizando a classe ODE. . . . . 153
6.4 Criando novas unidades. . . . . . . . . . . . . . . . . 162
7.1 Denindo um grafo como um dicionrio. . . . . . . . 170
7.2 Obtendo a lista de vrtices. . . . . . . . . . . . . . . 171
7.3 Denindo um grafo atravs de seus vrtices . . . . . 172
7.4 Diagrama de um grafo . . . . . . . . . . . . . . . . . 172
7.5 Construindo um grafo dinamicamente . . . . . . . . 176
7.6 Construindo uma rede social a partir de e-mails . . . 179
8.1 Exemplo de uso do mdulo pickle . . . . . . . . . . 186
8.2 Mdulos necessrios . . . . . . . . . . . . . . . . . . 190
8.3 Especicando o banco de dados. . . . . . . . . . . . 191
8.4 Especicando a tabela ideia do banco de dados. . . 192
xv
8.5 Restante do cdigo da aranha. . . . . . . . . . . . . 193

9.1 Amostragem por Hipercubo latino (LHS) . . . . . . 201
9.2 Integrao Monte Carlo . . . . . . . . . . . . . . . . 206
9.3 Amostragem por rejeio utilizando o mtodo do en-
velope . . . . . . . . . . . . . . . . . . . . . . . . . . 209
9.4 Amostragem da Posterior Bayesiana por rejeio. . . 212
9.5 Cadeia de Markov com kernel de transio exponencial215
9.6 Amostrador de Metropolis-Hastings . . . . . . . . . . 218
9.7 Amostrador de Gibbs aplicado uma distribuio
tri-variada . . . . . . . . . . . . . . . . . . . . . . . . 221
9.8 Filtro de partculas usando algoritmo SIR . . . . . . 225
9.9 Funo de verossimilhana para x igual a 0. . . . . . 230
9.10 Calculando a verossimilhana da comparao de duas
sequncias de DNA . . . . . . . . . . . . . . . . . . . 231
9.11 Log-verossimilhana . . . . . . . . . . . . . . . . . . 234
9.12 Maximizando a verossimilhana . . . . . . . . . . . . 235
9.13 Classe Varivel Aleatria Bayesiana Requisitos. . . 236
9.14 Classe Varivel Aleatria Bayesiana Inicializao. . 237
9.15 Classe Varivel Aleatria Bayesiana Herana din-
mica de mtodos. . . . . . . . . . . . . . . . . . . . . 238
9.16 Classe Varivel Aleatria Bayesiana Herana din-
mica de mtodos. . . . . . . . . . . . . . . . . . . . . 238
9.17 Classe Varivel Aleatria Bayesiana Adio de da-
dos e clculo da Verossimilhana. . . . . . . . . . . . 239
9.18 Classe Varivel Aleatria Bayesiana Amostras e
PDF da a priori. . . . . . . . . . . . . . . . . . . . . 240
9.19 Classe Varivel Aleatria Bayesiana Gerando a
posterior. . . . . . . . . . . . . . . . . . . . . . . . . 241
9.20 Classe Varivel Aleatria Bayesiana Cdigo de teste.242
9.21 Classe Varivel Aleatria Bayesiana Listagem com-
pleta . . . . . . . . . . . . . . . . . . . . . . . . . . . 244
22 Redirecionando STDIN e STDOUT . . . . . . . . . . 258
23 Lista ordenada dos usurios do sistema. . . . . . . . 258
24 Plotando dados em um arquivo. . . . . . . . . . . . . 260
xvi LISTAGENS
25 Desenhando um quadrado. . . . . . . . . . . . . . . . 261
26 Uso do spline . . . . . . . . . . . . . . . . . . . . . 261
27 Interpolando uma curva em um plano. . . . . . . . . 261
28 Resolvendo uma equao diferencial simples no con-
sole do Linux. . . . . . . . . . . . . . . . . . . . . . . 264
29 Sistema de trs equaes diferenciais acopladas . . . 265
Prefcio: Computao
Cientca
Da Computao Cientca e sua denio pragmtica.
Do porqu esta se diferencia, em metas e ferramentas,
da Cincia da Computao.
C omputao cientca no uma rea do conhecimento muito

bem denida. A denio utilizada neste livro a de uma rea
de atividade/conhecimento que envolve a utilizao de ferramentas
computacionais (software) para a soluo de problemas cientcos
em reas da cincia no necessariamente ligadas disciplina da
cincia da computao, ou seja, a computao para o restante da
comunidade cientca.
Nos ltimos tempos, a computao em suas vrias facetas, tem
se tornado uma ferramenta universal para quase todos os segmentos
da atividade humana. Em decorrncia, podemos encontrar produ-
tos computacionais desenvolvidos para uma enorme variedade de
aplicaes, sejam elas cientcas ou no. No entanto, a diversidade
de aplicaes cientcas da computao quase to vasta quanto
o prprio conhecimento humano. Por isso, o cientista frequente-
mente se encontra com problemas para os quais as ferramentas
computacionais adequadas no existem.
No desenvolvimento de softwares cientcos, temos dois modos
principais de produo de software: o desenvolvimento de softwares
comerciais, feito por empresas de software que contratam progra-
xvii
xviii PREFCIO: COMPUTAO CIENTFICA
madores prossionais para o desenvolvimento de produtos voltados
para uma determinada aplicao cientca, e o desenvolvimento
feito por cientistas (fsicos, matemticos, bilogos, etc., que no
so programadores prossionais), geralmente de forma colabora-
tiva atravs do compartilhamento de cdigos fonte.
Algumas disciplinas cientcas, como a estatstica por exemplo,
representam um grande mercado para o desenvolvimento de softwa-
res comerciais genricos voltados para as suas principais aplicaes,
enquanto que outras disciplinas cientcas carecem de massa crtica
(em termos de nmero de prossionais) para estimular o desenvol-
vimento de softwares comerciais para a soluo dos seus problemas
computacionais especcos. Como agravante, o desenvolvimento
lento e centralizado de softwares comerciais, tem se mostrado inca-
paz de acompanhar a demanda da comunidade cientca, que pre-
cisa ter acesso a mtodos que evoluem a passo rpido. Alm disso,
esto se multiplicando as disciplinas cientcas que tm como sua
ferramenta principal de trabalho os mtodos computacionais, como
por exemplo a bio-informtica, a modelagem de sistemas comple-
xos, dinmica molecular e etc.
Cientistas que se vem na situao de terem de desenvolver
softwares para poder viabilizar seus projetos de pesquisa, geral-
mente tm de buscar uma formao improvisada em programao
e produzem programas que tem como caracterstica bsica serem
minimalistas, ou seja, os programas contm o mnimo nmero de
linhas de cdigo possvel para resolver o problema em questo. Isto
se deve conjugao de dois fatos: 1) O cientista raramente possui
habilidades como programador para construir programas mais so-
sticados e 2) Frequentemente o cientista dispe de pouco tempo
entre suas tarefas cientcas para dedicar-se programao.
Para complicar ainda mais a vida do cientista-programador, as
linguagens de programao tradicionais foram projetadas e desen-
volvidas por programadores para programadores e voltadas ao de-
senvolvimento de softwares prossionais com dezenas de milhares
de linhas de cdigo. Devido a isso, o nmero de linhas de cdigo
xix
mnimo para escrever um programa cientco nestas linguagens

muitas vezes maior do que o nmero de linhas de cdigo associado
com a resoluo do problema em questo.
Quando este problema foi percebido pelas empresas de soft-
ware cientco, surgiu uma nova classe de software, voltado para a
demanda de cientistas que precisavam implementar mtodos com-
putacionais especcos e que no podiam esperar por solues co-
merciais.
Esta nova classe de aplicativos cientcos, geralmente inclui uma
linguagem de programao de alto nvel, por meio da qual os ci-
entistas podem implementar seus prprios algoritmos, sem ter que
perder tempo tentando explicar a um programador prossional o
que, exatamente, ele deseja. Exemplos destes produtos incluem
MATLAB
TM , MathematicaTM , MapleTM , entre outros. Nestes
aplicativos, os programas so escritos e executados dentro do pr-
prio aplicativo, no podendo ser executados fora dos mesmos. Estes
ambientes, entretanto, no possuem vrias caractersticas impor-
tantes das linguagens de programao: No so portteis, ou seja,
no podem ser levados de uma mquina para a outra e executa-
dos a menos que a mquina-destino possua o aplicativo gerador do
programa (MATLAB
TM , etc.) que custa milhares de dlares por
licena, Os programas no podem ser portados para outra plata-
forma computacional para a qual no exista uma verso do aplica-
tivo gerador. E, por ltimo e no menos importante, o programa
produzido pelo cientista no lhe pertence, pois, para ser executado,
necessita de cdigo proprietrio do ambiente de desenvolvimento
comercial.
Este livro se prope a apresentar uma alternativa livre (base-
ada em Software Livre), que combina a facilidade de aprendizado e
rapidez de desenvolvimento, caractersticas dos ambientes de desen-
volvimento comerciais apresentados acima, com toda a exibilidade
das linguagens de programao tradicionais. Programas cientcos
desenvolvidos inteiramente com ferramentas de cdigo aberto tem
a vantagem adicional de serem plenamente escrutinveis pelo sis-
xx PREFCIO: COMPUTAO CIENTFICA
tema de reviso por pares (peer review), mecanismo central da
cincia para validao de resultados.
A linguagem Python apresenta as mesmas solues propostas
pelos ambientes de programao cientca, mantendo as vantagens
de ser uma linguagem de programao completa e de alto nvel.
Apresentando o Python
O Python uma linguagem de programao dinmica e orientada
a objetos, que pode ser utilizada no desenvolvimento de qualquer
tipo de aplicao, cientca ou no. O Python oferece suporte
integrao com outras linguagens e ferramentas, e distribuido com
uma vasta biblioteca padro. Alm disso, a linguagem possui uma
sintaxe simples e clara, podendo ser aprendida em poucos dias.
O uso do Python frequentemente associado com grandes ganhos
de produtividade e ainda, com a produo de programas de alta
qualidade e de fcil manuteno.
A linguagem de programao Python
1 comeou a ser desen-
volvida ao nal dos anos 80, na Holanda, por Guido van Rossum.
Guido foi o principal autor da linguagem e continua at hoje desem-
penhando um papel central no direcionamento da evoluo. Guido
reconhecido pela comunidade de usurios do Python como Bene-
volent Dictator For Life (BDFL), ou ditador benevolente vitalcio
da linguagem.
A primeira verso pblica da linguagem (0.9.0) foi disponibi-
lizada. Guido continou avanando o desenvolvimento da lingua-
gem, que alcanou a verso 1.0 em 1994. Em 1995, Guido emigrou
para os EUA levando a responsabilidade pelo desenvolvimento do
Python, j na verso 1.2, consigo. Durante o perodo em que Guido
2
trabalhou para o CNRI , o Python atingiu a verso 1.6, que foi rpi-
damente seguida pela verso 2.0. A partir desta verso, o Python
1 www.python.org
2 Corporation for National Research Initiatives
xxi
passa a ser distribudo sob a Python License, compatvel com a

3
GPL , tornando-se ocialmente software livre. A linguagem passa
a pertencer ocialmente Python Software Foundation. Apesar da
implementao original do Python ser desenvolvida na Linguagem
C (CPython), Logo surgiram outras implementaes da Lingua-
4
gem, inicialmente em Java (Jython ), e depois na prpria lingua-
5
gem Python (PYPY ), e na plataforma .NET 6
(IronPython ).
Dentre as vrias caractersticas da linguagem que a tornam in-
teressante para computao cientca, destacam-se:
Multiplataforma: O Python pode ser instalado em qualquer pla-

taforma computacional: Desde PDAs at supercomputadores
com processamento paralelo, passando por todas as platafor-
mas de computao pessoal.
Portabilidade: Aplicativos desenvolvidos em Python podem ser

facilmente distribudos para vrias plataformas diferentes da-
quela em que foi desenvolvido, mesmo que estas no possuam
o Python instalado.
Software Livre: O Python software livre, no impondo qual-

quer limitao distribuio gratuita ou venda de progra-
mas.
Extensibilidade: O Python pode ser extendido atravs de m-

dulos,escritos em Python ou rotinas escritas em outras lin-
guagens, tais como C ou Fortran (Mais sobre isso no captulo
5).
Orientao a objeto: Tudo em Python um objeto: funes,

variveis de todos os tipos e at mdulos (programas escritos
em Python) so objetos.
3 GNU General Public License

4 www.jython.org
5 pypy.org
6 www.codeplex.com/Wiki/View.aspx?ProjectName=IronPython
xxii PREFCIO: COMPUTAO CIENTFICA
Tipagem automtica: O tipo de uma varivel (string, inteiro,
oat, etc.) determinado durante a execuo do cdigo;
desta forma, voc no necessita perder tempo denindo tipos
de variveis no seu programa.
Tipagem forte: Variveis de um determinado tipo no podem

ser tratadas como sendo de outro tipo. Assim, voc no pode
somar a string '123' com o inteiro 3. Isto reduz a chance de
erros em seu programa. A variveis podem, ainda assim, ser
convertidas para outros tipos.
Cdigo legvel: O Python, por utilizar uma sintaxe simplicada

e forar a diviso de blocos de cdigo por meio de indenta-
o, torna-se bastante legvel, mesmo para pessoas que no
estejam familiarizadas com o programa.
Flexibilidade: O Python j conta com mdulos para diversas

aplicaes, cientcas ou no, incluindo mdulos para intera-
o com os protocolos mais comuns da Internet (FTP, HTTP,
XMLRPC, etc.). A maior parte destes mdulos j faz parte
da distribuio bsica do Python.
Operao com arquivos: A manipulao de arquivos, tais como

a leitura e escrita de dados em arquivos texto e binrio,
muito simplicada no Python, facilitando a tarefa de muitos
pesquisadores ao acessar dados em diversos formatos.
Uso interativo: O Python pode ser utilizado interativamente, ou

invocado para a execuco de scripts completos. O uso intera-
tivo permite experimentar comandos antes de inclu-los em
programas mais complexos, ou usar o Python simplesmente
como uma calculadora.
etc...
Entretanto, para melhor compreender todas estas vantagens
apresentadas, nada melhor do que comear a explorar exemplos
xxiii
de computao cientca na linguagem Python. Mas para inspirar

o trabalho tcnico, nada melhor do que um poema:
1 >>> import this

2 The Zen of Python , by Tim Peters
3
4 Beautiful i s b e t t e r than u g l y .
5 Explicit i s b e t t e r than i m p l i c i t .
6 Simple i s b e t t e r than complex .
7 Complex i s b e t t e r than c o m p l i c a t e d .
8 Flat is better than nested .
9 Sparse is better than dense .
10 Readability counts .
11 Special cases aren ' t special enough to break
the rules .
12 Although practicality beats purity .
13 Errors should never pass silently .
14 Unless explicitly silenced .
15 In the face of ambiguity , refuse the
temptation to guess .
16 There should be one and preferably only
one o b v i o u s way to do it .
17 Although that way may not be obvious at
first unless you ' r e Dutch .
18 Now is better than never .
19 Although never is often better than right
now .
20 If the implementation is hard to explain , it
's a bad idea .
21 If the implementation is easy to explain , it
may be a good idea .
22 Namespaces are one honking great idea let
's do more of those !
23 >>>
xxiv PREFCIO: COMPUTAO CIENTFICA
Usando este Livro
Este livro foi planejado visando a versatilidade de uso. Sendo assim,
ele pode ser utilizado como livro didtico (em cursos formais) ou
como referncia pessoal para auto-aprendizagem ou consulta.
Como livro didtico, apresenta, pelo menos, dois nveis de apli-
cao possveis:
1. Um curso introdutrio linguagem Python, no qual se faria

uso dos captulos da primeira parte. O nico pr-requisito
seria uma exposio prvia dos alunos a conceitos bsicos
de programao (que poderia ser condensada em uma nica
aula).
2. Um curso combinado de Python e computao cientca. O

autor tem ministrado este tipo de curso com grande sucesso.
Este curso faria uso da maior parte do contedo do livro, o
instrutor pode selecionar captulos de acordo com o interesse
dos alunos.
Como referncia pessoal, este livro atende a um pblico bas-

tante amplo, de leigos a cientistas. No incio de cada captulo
encontram-se os pr-requisitos para se entender o seu contedo.
Mas no se deixe inibir; as aplicaes cientcas so apresentadas
juntamente com uma breve introduo teoria que as inspira.
Recomendo aos auto-didatas que explorem cada exemplo con-
tido no livro; eles ajudaro enormemente na compreenso dos t-
7
picos apresentados . Para os leitores sem sorte, que no dispem
de um computador com o sistema operacional GNU/Linux insta-
lado, sugiro que o instalem, facilitar muito o acompanhamento dos
exemplos. Para os que ainda no esto prontos para abandonar o
7O cdigo fonte do exemplos est disponvel na seguinte URL: http://

fccoelho.googlepages.com/CCP_code.zip
xxv
Windows
TM , instalem o Linux em uma mquina virtual8 ! A dis-
tribuio que recomendo para iniciantes o Ubuntu (www.ubuntu.
com).
Enm, este livro foi concebido para ser uma leitura prazeirosa
para indivduos curiosos como eu, que esto sempre interessados
em aprender coisas novas!
Bom Proveito! Flvio Codeo Coelho
Petrpolis, 2007
8 Recomendo o VirtualBox (www.virtualbox.org), software livre e fan-

tstico!
Parte I
Introduo ao Python e
Ferramentas de
Desenvolvimento
1
Captulo 1
Fundamentos da Linguagem
Breve introduo a conceitos bsicos de programao e
linguagem Python. A maioria dos elementos bsicos
da linguagem so abordados neste captulo, com exceo
de classes, que so discutidas em detalhe no captulo 2.
Pr-requisitos: Conhecimentos bsicos de programa-
o em qualquer linguagem.
N este Captulo, faremos uma breve introduo linguagem

Python. Esta introduo servir de base para os exemplos
dos captulos subseqentes. Para uma introduo mais completa
linguagem, recomendamos ao leitor a consulta a livros e outros do-
cumentos voltados especicamente para programao em Python.
1.1 Primeiras impresses

Para uma primeira aproximao linguagem, vamos examinar suas
caractersticas bsicas. Faamos isso interativamente, a partir do
console Python. Vejamos como invoc-lo:
Listagem 1.1: O console interativo do Python
1 $ python
3
4 CAPTULO 1. FUNDAMENTOS DA LINGUAGEM
2 Python 2.5.1 ( r251 :54863 , May 2 2007 ,
16:56:35)
3 [GCC 4 . 1 . 2 ( Ubuntu 4 . 1 . 2 0 u bu n tu 4 ) ] on
linux2
4 Type " h e l p " , " copyright " , " credits " or "
license" for more information .
5 >>>
Toda linguagem, seja ela de programao ou linguagem natural,

possui um conjunto de palavras que a caracteriza. As linguagens
de programao tendem a ser muito mais compactas do que as
linguagens naturais. O Python pode ser considerado uma lingua-
gem compacta, mesmo em comparao com outras linguagens de
programao.
As palavras que compem uma linguagem de programao so
ditas reservadas, ou seja, no podem ser utilizadas para nomear
variveis. Se o programador tentar utilizar uma das palavras re-
servadas como varivel, incorrer em um erro de sintaxe.
Listagem 1.2: Palavras reservadas no podem ser utilizadas como

nomes de variveis
1 >>> for =1
2 File "<s t d i n >" , line 1
3 for =1
4 ^
5 SyntaxError : invalid syntax
A linguagem Python em sua verso atual (2.5), possui 30 pala-

and, as, assert, break, class, continue,
vras reservadas. So elas:
def, del, elif, else, except, exec, finally, for, from, global,
if, import, in, is, lambda, not, or, pass, print, raise, return,
try, while e yield. Alm destas palavras, existem constantes,
tipos e funes internas ao Python, que esto disponveis para a
construo de programas. Estes elementos podem ser inspeciona-
dos atravs do comando dir(__builtins__). Nenhum dos ele-
1.2. USO INTERATIVO EXECUO A PARTIR DE
SCRIPTS
VS.
5
mentos do mdulo __builtins__ 1

deve ser redenido . O console
interativo do Python possui um sistema de ajuda integrado que
pode ser usado para acessar a documentao de qualquer elemento
da linguagem. O comando help(), inicia a ajuda interativa. A
partir da, podemos por exemplo, digitar keywords para acessar a
ajuda das palavras reservadas listadas acima. Se digitarmos for
em seguida, obteremos a seguinte ajuda:
Listagem 1.3: Denio da palavra reservada for.

1 7.3 The for statement
2
3 The for statement is used to iterate over
the elements of a sequence
4 ( such as a string , tuple or list ) or other
iterable object :
5 ...
1.2 Uso Interativo Execuo a Partir de

Scripts
vs.
Usurios familiarizados com ambientes de programao cientcos

tais como Matlab, R e similares, caro satisfeitos em saber que o
Python tambm pode ser utilizado de forma interativa. Para isso,
basta invocar o interpretador na linha de comando (Python shell,
em Unix) ou invocar um shell mais sosticado como o Idle, que
vem com a distribuio padro do Python, ou o Ipython (ver 4.1).
Tanto no uso interativo, como na execuo a partir de scripts, o
interpretador espera encontrar apenas uma expresso por linha do
programa. Caso se deseje inserir mais de uma expresso em uma
linha, as expresses devem ser separadas por ;. Mas esta prtica
1 Ateno, os componentes de __builtins__, no geram erros de sintaxe

ao ser redenidos.
deve ser evitada. Expresses podem continuar em outra linha se
algum de seus parnteses, colchetes, chaves ou aspas ainda no tiver
sido fechado. Alternativamente, linhas podem ser quebradas pela
aposio do caractere \ ao nal da linha.
Listagem 1.4: Usando o Python como uma calculadora.
1 >>> 1+1
2 2
3 >>>
No cabealho da shell do Python, acima (listagem 1.1), o interpre-

tador identica a verso instalada, data e hora em que foi compi-
lada, o compilador C utilizado, detalhes sobre o sistema operacional
e uma linhazinha de ajuda para situar o novato.
Para executar um programa, a maneira usual (em Unix) digi-
tar: python script.py. No Windows basta um duplo clique sobre
arquivos *.py.
Listagem 1.5: Executando script.py via comando de linha.
1 $ python s c r i p t . py
No Linux e em vrios UNIXes, podemos criar scripts que so

executveis diretamente, sem precisar invocar o interpretador an-
tes. Para isso, basta incluir a seguinte linha no topo do nosso
script:
1 #! / u s r / b i n / env python
Note que os caracteres #! devem ser os dois primeiros caracteres

do arquivo (como na listagem 1.6).
Depois, resta apenas ajustar as permisses do arquivo para que
possamos execut-lo: chmod +x script.py (listagem 1.7).
Listagem 1.7: Executando um script Python executvel.
1 $ chmod +x s c r i p t . py
SCRIPTS
VS.
7
Listagem 1.6: Tornando um script executvel
1 #! / u s r / b i n / env python
2
3 print " A l Mundo ! "
2 $ . / s c r i p t . py
3 sys : 1 : DeprecationWarning : NonASCII
character ' \ xf4 ' in file ./ teste on line
3, but no encoding declared ; see http
: / /www . p y t h o n . o r g / p e p s / pep 0 2 6 3 . h t m l for
details
4 A l Mundo !
Mas que lixo aquele antes do nosso Al mundo? Trata-

se do interpretador reclamando do acento circunexo em Al.
Para que o Python no reclame de acentos e outros caracteres da
lngua portuguesa no contidos na tabela ASCII, precisamos adi-
cionar a seguinte linha ao script: # -*- coding: latin-1 -*-.
Experimente editar o script acima e veja o resultado.
No exemplo da listagem 1.6, utilizamos o comando print para
fazer com que nosso script produzisse uma string como sada, ou
seja, para escrever no stdout .
2 Como podemos receber informa-
es pelostdin? O Python nos oferece duas funes para isso:
input('texto'), que executa o que o usurio digitar, sendo por-
tanto perigoso, e raw_input('texto'), que retorna uma string
com a resposta do usurio.
Nas listagens que se seguem, alternaremos entre a utilizao
de scripts e a utilizao do Python no modo interativo (como na
listagem 1.4). A presena do smbolo >>>, caracterstico da shell
2 Todos os processos no Linux e outros sistemas operacionais possuem vias

de entrada e sada de dados denominados de stdin e stdout, respectivamente.
do Python ser suciente para diferenciar os dois casos. Exemplos
de scripts viro dentro de caixas.
Operaes com Nmeros
Noventa e nove por cento das aplicaes cientcas envolvem algum

tipo de processamento numrico. Vamos iniciar nosso contato com
o Python atravs dos nmeros (Listagem 1.8).
Listagem 1.8: Operaes aritmticas
1 >>> 2+2
2 4
3 >>> # C o m e n t r i o
4 ... 22
5 4
6 >>> 2 2 # Comentrio na mesma linha
7 4
8 >>> ( 5 0 5 6 ) / 4
9 5
10 >>> # D i v i s o de inteiros retorna " floor ":
11 ... 7/3
12 2
13 >>> 7/ 3
14 3
15 >>> 7 / 3 .
16 2.3333333333333335
Nosso primeiro exemplo numrico (Listagem 1.8) , trata nme-

3
ros em sua representao mais simples: como constantes. desta
forma que utilizamos uma calculadora comum. Em programao
mais comum termos nmeros associados a quantidades, a que
3 Repare como o Python trata a diviso de dois inteiros. Ela retorna o

resultado arredondado para baixo
SCRIPTS
VS.
9
precisamos nos referenciar e que podem se modicar. Esta repre-

sentao de nmeros chama-se varivel.
O sinal de = utilizado para atribuir valores a variveis(Listagem
1.9).
Listagem 1.9: Atribuindo valores
1 >>> l a r g u r a = 2 0
2 >>> a l t u r a = 5 9
3 >>> l a r g u r a altura
4 900
Um valor pode ser atribudo a diversas variveis com uma nica

operao de atribuio, ou mltiplos valores a mltiplas variveis
(Listagem 1.10). Note que no exemplo de atribuio de mltiplos
valores a mltiplas variveis (Listagem 1.10, linha 9) os valores
poderiam estar em uma tupla.
Listagem 1.10: Atribuindo o mesmo valor a mltiplas variveis
1 >>> x = y = z = 0 # Zero x, y e z
2 >>> x
3 0
4 >>> y
5 0
6 >>> z
7 0
8 >>> a , b , c = 1 , 2 , 3
9 >>> a
10 1
11 >>> b
12 2
13 >>> c
14 3
O Python tambm reconhece nmeros reais (ponto-utuante)

e complexos naturalmente. Em operaes entre nmeros reais e
inteiros o resultado ser sempre real. Da mesma forma, operaes
entre nmeros reais e complexos resultam sempre em um nmero
complexo. Nmeros complexos so sempre representados por dois
nmeros ponto-utuante: a parte real e a parte imaginria. A
parte imaginria representada com um suxo j ou J.
Listagem 1.11: Nmeros complexos
1 >>> 1 j 1J
2 (1+0 j )
3 >>> 1 j complex ( 0 , 1 )
4 (1+0 j )
5 >>> 3+1 j 3
6 (3+3 j )
7 >>> (3+1 j ) 3
8 (9+3 j )
9 >>> (1+2 j ) /(1+1 j )
10 (1.5+0.5 j )
Um Nmero complexo para o Python, um objeto . Podemos ex-

4
trair as partes componentes de um nmero complexo c utilizando
atributos do tipo complexo: c.real e c.imag. A funo abs, que
retorna o mdulo de um numero inteiro ou real, retorna o compri-
mento do vetor no plano complexo, quando aplicada a um nmero
complexo. O mdulo de um nmero complexo tambm denomi-
nado magnitude (listagem 1.12).
Listagem 1.12: Explorando nmeros complexos
1 >>> a = 3 . 0 + 3 . 0 j
2 >>> a . r e a l
3 3.0
4 >>> a . imag
5 3.0
6 >>> a b s ( a ) # sqrt (a . real 2 + a . imag 2 )
4 Assim como os outros tipos de nmeros.

1.3. NOMES, OBJETOS E ESPAOS DE NOMES 11
7 4.2426406871192848
1.3 Nomes, Objetos e Espaos de Nomes

Nomes em Python so identicadores de objetos, e tambm so
chamados de variveis. Nomes devem ser iniciados por letras mais-
culas ou minsculas e podem conter algarismos, desde que no se-
jam o primeiro caractere. O Python faz distino entre maisculas
e minsculas portanto, nome != Nome.
No Python, todos os dados so objetos tipados, que so associ-
ados dinamicamente a nomes. O sinal de igual (=), liga o resultado
da avaliao da expresso do seu lado direito a um nome situado
sua esquerda. A esta operao damos o nome de atribuio (ver
exemplo na listagem 1.13).
Listagem 1.13: Atribuindo objetos a nomes (variveis)
1 >>> a =3 2 7
2 >>> a , b = ( ' l a r a n j a ' , ' banana ' )
As variveis criadas por atribuio cam guardadas na memria

do computador. Para evitar preenchimento total da memria, as-
sim que um objeto deixa de ser referenciado por um nome (deixa de
existir no espao de nomes corrente), ele imediatamente apagado
da memria pelo interpretador.
O conceito de espao de nomes uma caracterstica da lingua-
gem Python que contribui para sua robustez e ecincia. Espaos
de nomes so dicionrios (ver 1.4) contendo as variveis, objetos
e funes disponveis durante a execuo de um programa. A um
dado ponto da execuo de um programa, existem sempre dois di-
cionrios disponveis para a resoluo de nomes: um local e um
global. Estes dicionrios podem ser acessados para leitura atravs
das funes locals() e globals(), respectivamente. Sempre que
o interpretador Python encontra uma palavra que no pertence ao
conjunto de palavras reservadas da linguagem, ele a procura, pri-
meiro no espao de nomes local e depois no global. Se a palavra
no encontrada, um erro do tipo NameError acionado (exemplo
1.14).
Listagem 1.14: Exemplo de NameError
1 >>> m a r i a
2 Traceback ( most recent call last ) :
3 File "<s t d i n >" , line 1, in ?
4 NameError : name ' maria ' i s not defined
O espao de nomes local, muda ao longo da execuo de um

programa. Toda a vez que a execuo adentra uma funo, o espao
de nomes local passa a reetir apenas as variveis denidas dentro
daquela funo .
5 Ao sair da funo, o dicionrio local torna-se
igual ao global.
1 >>> a=1
2 >>> l e n ( g l o b a l s ( ) . i t e m s ( ) )
3 4
4 >>> l e n ( l o c a l s ( ) . i t e m s ( ) )
5 4
6 >>> def fun ( ) :
7 ... a= ' novo valor '
8 ... print len ( l o c a l s () . items () )
9 ... print a
10 ...
11 >>> f u n ( )
12 1
13 novo valor
14 >>> print a
15 1
16 >>> l e n ( l o c a l s ( ) . i t e m s ( ) )
5 Mais quaisquer variveis explicitamente denidas como globais

1.4. ESTRUTURAS DE DADOS 13
17 5
18 >>> l o c a l s ( )
19 { ' __builtins__ ' : <module ' __builtin__ ' (
built in ) >, '__name__ ' : '__main__ ' , ' fun
' : <f u n c t i o n fun at 0 xb7c18ed4 >, '
__doc__ ' : None , 'a ' : 1}
Tambm importante lembrar que o espao de nomes local

sempre inclui os __builtins__ como vemos na listagem 1.3.
1.4 Estruturas de Dados

Qualquer linguagem de programao pode ser simplisticamente
descrita como uma ferramenta, atravs da qual, dados e algorit-
mos so implementados e interagem para a soluo de um dado
problema. Nesta seo vamos conhecer os tipos e estruturas de
dados do Python para que possamos, mais adiante, utilizar toda a
sua exibilidade em nossos programas.
No Python, uma grande nfase dada simplicidade e exibi-
lidade de forma a maximizar a produtividade do programador. No
tocante aos tipos e estruturas de dados, esta losoa se apresenta
na forma de uma tipagem dinmica, porm forte. Isto quer dizer
que os tipos das variveis no precisam ser declarados pelo pro-
gramador, como obrigatrio em linguagens de tipagem esttica
como o C, FORTRAN, Visual Basic, etc. Os tipos das variveis
so inferidos pelo interpretador. As principais estruturas de dados
como Listas e Dicionrios, podem ter suas dimenses alteradas,
dinamicamente durante a execuo do Programa , o que facilita
enormemente a vida do programador, como veremos mais adiante.
Listas
As listas formam o tipo de dados mais utilizado e verstil do

Python. Listas so denidas como uma sequncia de valores se-
parados por vrgulas e delimitada por colchetes:
Listagem 1.15: Criando listas.
1 >>> l i s t a = [ 1 , 'a ' , ' pe ' ]

2 >>> l i s t a
3 [1 , 'a ' , ' pe ' ]
4 >>> l i s t a [ 0 ]
5 1
6 >>> l i s t a [ 2 ]
7 ' pe '
8 >>> l i s t a [ 1 ]
9 ' pe '
Na listagem 1.15, criamos uma lista de trs elementos. Uma

lista uma sequncia ordenada de elementos, de forma que pode-
mos selecionar elementos de uma lista por meio de sua posio.
Note que o primeiro elemento da lista lista[0]. Todas as con-
tagens em Python comeam em 0.
Uma lista tambm pode possuir elementos de tipos diferentes.
Na listagem 1.15, o elemento 0 um inteiro enquanto que os ou-
tros elementos so strings. Para vericar isso, digite o comando
type(lista[0]).
Uma caracterstica muito interessante das listas do Python,
que elas podem ser indexadas de trs para frente, ou seja, lista[-1]
o ltimo elemento da lista. Como listas so sequncias de tama-
nho varivel, podemos assessar os ltimos n elementos, sem ter que
contar os elementos da lista.
Listas podem ser fatiadas, ou seja, podemos selecionar uma
poro de uma lista que contenha mais de um elemento.
Listagem 1.16: Fatiando uma lista
1 >>> l i s t a =[ ' a ' , ' p e ' , ' que ' , 1]

2 >>> l i s t a [ 1 : 3 ]
3 [ ' pe ' , ' que ' ]
4 >>> l i s t a [ 1 ]
5 1
6 >>> l i s t a [ 3 ]
7 1
8 >>>
O comando lista[1:3], delimita uma fatia que vai do ele-

mento 1 (o segundo elemento) ao elemento imediatamente anterior
ao elemento 3. Note que esta seleo inclui o elemento correspon-
dente ao limite inferior do intervalo, mas no o limite superior.
Isto pode gerar alguma confuso, mas tem suas utilidades. ndices
negativos tambm podem ser utilizados nestas expresses.
Para retirar uma fatia que inclua o ltimo elemento, temos que
usar uma variao deste comando seletor de intervalos:
Listagem 1.17: Selecionando o nal de uma lista.
1 >>> l i s t a [ 2 : ]
2 [ ' que ' , 1]
3 >>>
Este comando signica todos os elementos a partir do elemento

2 (o terceiro), at o nal da lista. Este comando poderia ser uti-
lizado para selecionar elementos do incio da lista: lista[:3], s
que desta vez no incluindo o elemento 3 (o quarto elemento).
Se os dois elementos forem deixados de fora, so selecionados
todos os elementos da lista:
Listagem 1.18: selecionando todos os elementos de uma lista.
1 >>> l i s t a [ : ]
2 [ 'a ' , ' pe ' , ' que ' , 1]
3 >>>
S que no a mesma lista, uma nova lista com os mesmos

elementos. Desta forma, lista[:] uma maneira de fazer uma
cpia completa de uma lista. Normalmente este recurso utilizado
junto com uma atribuio a = lista[:].
Listagem 1.19: Adicionando elementos a listas.
1 >>> l i s t a [ : ]
2 [ 'a ' , ' pe ' , ' que ' , 1]
3 >>> l i s t a . append ( 2 ) #a d i c i o n a 2 ao final
4 [ 'a ' , ' pe ' , ' que ' , 1, 2]
5 >>> l i s t a . i n s e r t ( 2 , [ ' a ' , ' b ' ] )
6 >>> l i s t a
7 [ 'a ' , ' pe ' , [ 'a ' , 'b ' ] , ' que ' , 1, 2]
8 >>>
As listas so conjuntos mutveis, ao contrrio de tuplas e strings,

portanto pode-se adicionar(listagem 1.19), modicar ou remover
(tabela 1.1) elementos de uma lista.
Tabela 1.1: Mtodos de Listas.
Mtodo Efeito
L.append(objeto) Adiciona um elemento ao nal da lista.
L.count(elemento) Retorna o nmero de ocorrncias do elemento.
L.extend( list ) Concatena listas.
L.index(value) Retorna ndice da primeira ocorrncia do valor.
L. insert ( i , o) Insere objeto (o) antes de ndice (i).
L.pop([indice ]) Remove e retorna objeto no ndice.
ou o ltimo elemento.
L.remove(value) remove primeira ocorrncia do valor.
L.reverse () Inverte lista. In situ
L.sort () Ordena lista. In locus
Note que as operaes in situ no alocam memria extra para

a operao, ou seja, a inverso ou a ordenao descritas na tabela
1.1, so realizadas no mesmo espao de memria da lista original.
Operaes in situ alteram a varivel em si sem fazer uma cpia da
mesma e, portanto no retornam nada.
O mtodo L.insert insere um objeto antes da posio indicada
pelo ndice. Repare, na listagem 1.19, que o objeto em questo era
uma lista, e o mtodo insert no a fundiu com a lista original. Este

exemplo nos mostra mais um aspecto da versatilidade do objeto
lista, que pode ser composto por objetos de qualquer tipo.
Listagem 1.20: Estendendo uma lista.
1 >>> l i s t a 2 =[ ' a ' , ' b ' ]

2 >>> l i s t a . e x t e n d ( l i s t a 2 )
3 >>> l i s t a
4 [ 'a ' , ' pe ' , [ 'a ' , 'b ' ] , ' que ' , 1, 2, 'a ' , 'b
' ]
J na listagem 1.20, os elementos da segunda lista so adicio-

nados, individualmente, ao nal da lista original.
Listagem 1.21: Efetuando buscas em listas.
1 >>> l i s t a . i n d e x ( ' q u e ' )

2 3
3 >>> l i s t a . i n d e x ( ' a ' )
4 0
5 >>> l i s t a . i n d e x ( ' z ' )
7 File "<i n p u t >" , line 1, in ?
8 ValueError : l i s t . index ( x ) : x not in list
9 >>> 'z ' in lista
10 0
Conforme ilustrado na listagem 1.21, o mtodo L.index retorna

o ndice da primeira ocorrncia do valor dado. Se o valor no
existir, o interpretador retorna um ValueError. Para testar se um
elemento est presente em uma lista, pode-se utilizar o comando
in6 como ilustrado na listagem 1.21. Caso o elemento faa parte
da lista, este comando retornar 1, caso contrrio retornar 07 .
6O inverso do operador in, o operador not in e tambm vlido para
todas as sequncias.
7 Verdadeiro e falso: Em Python, quase qualquer coisa pode ser utilizada
em um contexto booleano, ou seja, como verdadeiro ou falso. Por exemplo 0
Existem dois mtodos bsicos para remover elementos de uma
lista: L.remove e L.pop listagem 1.22. O primeiro remove o
elemento nomeado sem nada retornar, o segundo elimina e retorna
o ltimo ou o elemento da lista (se chamado sem argumentos), ou o
determinado pelo ndice, passado como argumento (Listagem 1.22).
Listagem 1.22: Removendo elementos de uma lista.
1 >>> l i s t a . remove ( " q u e " )

2 >>> l i s t a
3 [ 'a ' , ' pe ' , [ 'a ' , 'b ' ] , 1, 2, 'a ' , 'b ' ]
4 >>> l i s t a . pop ( 2 )
5 [ 'a ' , 'b ' ]
6 >>> l i s t a
7 [ 'a ' , ' pe ' , 1, 2, 'a ' , 'b ' ]
8 >>>
Operadores aritmticos tambm podem ser utilizados para ope-

raes com listas. O operador de soma, +, concatena duas listas.
O operador += um atalho para o mtodo L.extend conforme
mostrado na listagem 1.23.
Listagem 1.23: Operaes com listas
1 >>> l i s t a =[ ' a ' , ' pe ' , 1, 2, 'a ' , 'b ' ]

2 >>> l i s t a = l i s t a + [ ' novo ' , ' elemento ' ]
3 >>> l i s t a
4 [ 'a ' , ' pe ' , 1, 2, 'a ' , 'b ' , ' novo ' , '
elemento ' ]
5 >>> l i s t a += ' d o i s '
6 >>> l i s t a
7 [ 'a ' , ' pe ' , 1, 2, 'a ' , 'b ' , 'd ' , 'o ' , ' i ' , '
s ' ]
8 >>> l i s t a += [ ' d o i s ' ]
falso enquanto que todos os outros nmeros so verdadeiros.Uma string, lista,

dicionrio ou tupla vazias so falsas enquanto que as demais so verdadeiras.
Listagem 1.24: Criando listas numricas sequenciais.
1 >>> r a n g e ( 1 0 )
2 [0 , 1, 2, 3, 4, 5, 6, 7, 8, 9]
3 >>> r a n g e ( 2 , 2 0 , 2 )#nmeros pares
4 [2 , 4, 6, 8, 10 , 12 , 14 , 16 , 18]
5 >>> r a n g e ( 1 , 2 0 , 2 )#nmeros mpares
6 [1 , 3, 5, 7, 9, 11 , 13 , 15 , 17 , 19]
9 >>> l i s t a
10 [ 'a ' , ' pe ' , 1, 2, 'a ' , 'b ' , 'd ' , 'o ' , ' i ' , '
s ' , ' dois ' ]
11 >>> l i =[1 ,2]
12 >>> li 3
13 [1 , 2, 1, 2, 1, 2]
14 >>>
Note que a operao lista = lista + lista2 cria uma nova

lista enquanto que o comando += aproveita a lista original e a
extende. Esta diferena faz com que o operador += seja muito
mais rpido, especialmente para grandes listas. O operador de
multiplicao, *, um repetidor/concatenador de listas conforme
mostrado ao nal da listagem 1.23. A operao de multiplicao
in situ (*=) tambm vlida.
Um tipo de lista muito til em aplicaes cientcas, lista
numrica sequencial. Para construir estas listas podemos utilizar o
comando range (exemplo 1.24). O comando range aceita 1, 2 ou
trs argumentos: incio, m e passo, respectivamente (ver exemplo
1.24).
Tuplas
Uma tupla, uma lista imutvel, ou seja, ao contrrio de uma lista,

aps a sua criao, ela no pode ser alterada. Uma tupla denida
de maneira similar a uma lista, com exceo dos delimitadores do
conjunto de elementos que no caso de uma tupla so parnteses
(listagem 1.25).
Listagem 1.25: Denindo uma Tupla.
1 >>> t u = ( ' G e n e r o ' , ' especie ' , ' peso ' , '
estagio ' )
2 >>> t u [ 0 ]
3 ' Genero '
4 >>> t u [ 1 : 3 ]
5 ( ' especie ' , ' peso ' )
6 >>>
Os elementos de uma tupla podem ser referenciados atravs de

ndices, (posio) de forma idntica a como feito em listas. Tuplas
tambm podem ser fatiadas, gerando outras tuplas.
As tuplas no possuem mtodos. Isto se deve ao fato de as
tuplas serem imutveis. Os mtodos append, extend, e pop natu-
ralmente no se aplicam a tuplas, uma vez que no se pode adicio-
nar ou remover elementos de uma tupla. No podemos fazer busca
em tuplas, visto que no dispomos do mtodo index. No entanto,
podemos usar in para determinar se um elemento existe em uma
tupla, como se faz em listas.
Listagem 1.26: Outras formas de denir tuplas.
1 >>> t u =()
2 >>> t u
3 ()
4 >>> t u= ' c a s a ' , #<R e p a r e na vrgula ao
final !
5 >>> t u
6 ( ' casa ' ,)

7 >>> t u = 1 , 2 , 3 , 4
8 >>> t u
9 (1 , 2, 3, 4)
10 >>> v a r =w , x , y , z
11 >>> v a r
12 (w , x , y , z )
13 >>> v a r = t u
14 >>> w
15 1
16 >>> x
17 2
18 >>> y
19 3
20 >>> z
21 4
Conforme exemplicado em 1.26, uma tupla vazia, denida

pela expresso (), j no caso de uma tupla unitria, isto , com ape-
nas um elemento, fazemos a atribuio com uma vrgula aps o ele-
mento, caso contrrio (tu=('casa') ), o interpretador no poder
distinguir se os parnteses esto sendo utilizados como delimitado-
res normais ou delimitadores de tupla. O comando tu=('casa',)
equivalente ao apresentado na quarta linha da listagem 1.26, ape-
nas mais longo.
Na stima linha da listagem 1.26, temos uma extenso do con-
ceito apresentado na linha anterior: a denio de uma tupla sem
a necessidade de parnteses. A este processo, se d o nome de em-
pacotamento de sequncia. O empacotamento de vrios elementos
sempre gera uma tupla.
As tuplas, apesar de no serem to versteis quanto as listas, so
mais rpidas. Portanto, sempre que se precisar de uma sequnca
de elementos para servir apenas de referncia, sem a necessidade
de edio, deve-se utilizar uma tupla. Tuplas tambm so teis na
formatao de strings como veremos na listagem 1.28.
Apesar das tuplas serem imutveis, pode-se contornar esta li-
mitao fatiando e concatenando tuplas. Listas tambm podem
ser convertidas em tuplas, com a funo tuple(lista), assim
como tuplas podem ser convertidas em listas atravs da funo
list(tupla).
Uma outra aplicao interessante para tuplas, mostrada na lis-
tagem 1.26, a atribuio mltipla, em que uma tupla de valores,
atribuda a uma lista de nomes de variveis armazenados em uma
tupla. Neste caso, as duas sequncias devem ter, exatamente, o
mesmo nmero de elementos.
Strings
Strings so um terceiro tipo de sequncias em Python. Strings so

sequncias de caracteres delimitados por aspas simples, 'string345'
ou duplas "string". Todos os operadores discutidos at agora para
outras sequncias, tais como +, *, in, not in, s[i] e s[i:j], tam-
bm so vlidos para strings. Strings tambm podem ser denidas
com trs aspas (duplas ou simples). Esta ltima forma utilizada
para denir strings contendo quebras de linha.
Listagem 1.27: Strings.
1 >>> s t= ' 1 2 3 de oliveira4 '

2 >>> l e n ( s t )
3 16
4 >>> min ( s t )
5 ' '
6 >>> max ( s t )
7 'v '
8 >>> t e x t o = " " " p r i m e i r a linha
9 segunda linha
10 terceira l i n h a """
11 >>> print texto
12 primeira linha
13 segunda linha
14 terceira linha
Conforme ilustrado na listagem 1.27, uma string uma sequn-

cia de quaisquer caracteres alfanumricos, incluindos espaos. A
funo len(), retorna o comprimento da string, ou de uma lista
ou tupla. As funes min() e max() retornam o valor mnimo e o
mximo de uma sequncia, respectivamente. Neste caso, como a
sequncia uma string, os valores so os cdigos ASCII de cada
caracter. Estes comandos tambm so vlidos para listas e tuplas.
O tipo String possui 33 mtodos distintos (na verso 2.2.1 do
Python). Seria por demais enfadonho listar e descrever cada um
destes mtodos neste captulo. Nesta seo vamos ver alguns m-
todos de strings em ao no contexto de alguns exemplos. Outros
mtodos aparecero em outros exemplos nos demais captulos.
O uso mais comum dado a strings a manipulao de textos que
fazem parte da entrada ou sada de um programa. Nestes casos,
interessante poder montar strings, facilmente, a partir de outras
estruturas de dados. Em Python, a insero de valores em strings
envolve o marcador %s.
Listagem 1.28: Formatando strings.
1 >>> a n i m a l= ' Hamster 1 '

2 >>> p e s o =98
3 >>> '%s : %s gramas ' % ( animal , p e s o )
4 ' Hamster 1: 98 gramas '
Na listagem 1.28, temos uma expresso de sintaxe no to b-

via mas de grande valor na gerao de strings. O operador % (m-
dulo), indica que os elementos da tupla seguinte sero mapeados,
em sequncia, nas posies indicadas pelos marcadores %s na string.
Esta expresso pode parecer uma complicao desnecessria
para uma simples concatenao de strings. Mas no . Vejamos
porqu:
Listagem 1.29: Problemas com a concatenao de strings.
1 >>> a n i m a l= ' Hamster 1 '

2 >>> p e s o =98
3 >>> '%s : %s gramas ' % ( animal , p e s o )
4 ' Hamster 1: 98 gramas '
5 >>> a n i m a l+ ' : '+p e s o+ ' gramas '
8 TypeError : cannot concatenate ' str ' and ' int
' objects
9 >>>
Pelo erro apresentado na listagem 1.29, vemos que a formatao

da string utilizando o operador mdulo e os marcadores %s, faz mais
do que apenas concatenar strings, tambm converte a varivel peso
(inteiro) em uma string.
Dicionrios
O dicionrio um tipo de dado muito interessante do Python:

uma estrutura que funciona como um banco de dados em minia-
tura, no sentido de que seus elementos consistem de pares chave
: valor, armazenados sem ordenao. Isto signica que no exis-
tem ndices para os elementos de um dicionrio, a informao
acessada atravs das chaves.
Listagem 1.30: Criando e manipulando dicionrios.
1 >>> Z={ 'C ' : 1 2 , 'O ' : 1 6 , 'N ' : 1 2 , ' Na ' : 4 0 }
2 >>> Z [ 'O ' ]
3 16
4 >>> Z [ 'H ' ]=1
5 >>> Z
6 { ' Na ' : 40 , 'C ' : 12 , 'H ' : 1, 'O ' : 16 , 'N ' :
12}
7 >>> Z . k e y s ( )
8 [ ' Na ' , 'C ' , 'H ' , 'O ' , 'N ' ]
9 >>> Z . has_key ( 'N ' )
10 1
As chaves podem ser de qualquer tipo imutvel: nmeros, strings,

tuplas (que contenham apenas tipos imutveis). Dicionrios pos-
suem os mtodos listados na tabela 1.2.
Os conjuntos (chave:valor) so chamados de tens do dicion-
rios. Esta terminologia importante pois podemos acessar, sepa-
radamente, chaves, valores ou tens de um dicionrio.
Os valores de um dicionrio podem ser de qualquer tipo, nme-
ros, strings, listas, tuplas e at mesmo outros dicionrios. Tambm
no h qualquer restrio para o armazenamento de diferentes tipos
de dados em um mesmo dicionrio.
Conforme exemplicado em 1.30, pode-se adicionar novos tens
a um dicionrio, a qualquer momento, bastando atribuir um valor
a uma chave. Contudo, preciso ter cuidado. Se voc tentar criar
um tem com uma chave que j existe, o novo tem substituir o
antigo.
Os mtodos D.iteritems (), D.iterkeys() e D.itervalues()
criam iteradores. Iteradores permitem iterar atravs dos tens, cha-
ves ou valores de um dicionrio. Veja a listagem 1.31:
Listagem 1.31: Iterando dicionrios.
1 >>> Z . i t e m s ( )
2 [ ( ' Na ' , 40) , ( 'C ' , 12) , ( 'H ' , 1) , ( 'O ' , 16) ,
( 'N ' , 12) ]
3 >>> i =Z . i t e r i t e m s ( )
4 >>> i
5 <d i c t i o n a r y i t e r a t o r object at 0 x 8 9 8 5 d 0 0>
6 >>> i . n e x t ( )
7 ( ' Na ' , 40)
8 >>> i . n e x t ( )
Tabela 1.2: Mtodos de Dicionrios.
Mtodo Efeito
D.clear() Remove todos os itens do dicionrio.
D.copy() Cria uma cpia de um dicionrio.
D.get(k[,d]) Retorna D[k], se a chave k existir. Seno, d.
D.has_key(k) Retorna 1 se D possuir a chave k.
D.items() Retorna lista de tuplas (chave:valor).
D.iteritems() Retorna objeto iterador para D.
D.iterkeys() Idem para chaves.
D.itervalues () Idem para valores.
D.keys() Retorna lista com todas as chaves.
D.popitem() Remove e retorna um tem (chave:valor).
D.update(E) Copia itens de E para D.
D.values() Retorna lista com todas os valores.
9 ( 'C ' , 12)

10 >>> # e assim por diante . . .
11 >>> k=Z . i t e r k e y s ( )
12 >>> k . n e x t ( )
13 ' Na '
14 >>> k . n e x t ( )
15 'C '
16 >>> k . n e x t ( )
17 'H '
18 >>> k . n e x t ( )
19 'O '
20 >>> k . n e x t ( )
21 'N '
22 >>> k . n e x t ( )
25 StopIteration
O uso de iteradores interessante quando se precisa acessar

o contedo de um dicionrio, elemento-a-elemento, sem repetio.
Ao nal da iterao, o iterador retorna um aviso: StopIteration.
Conjuntos
Rearmando sua vocao cientca, a partir da verso 2.4, uma

estrutura de dados para representar o conceito matemtico de con-
junto foi introduzida na linguagem Python. Um conjunto no Python
uma coleo de elementos sem ordenao e sem repeties. O
objeto conjunto em Python aceita operaes matemticas de con-
juntos tais como unio, interseo, diferena e diferena simtrica
(exemplo 1.4).
1 >>> a = s e t ( ' p i r a p o r a ' )

2 >>> b = s e t ( ' paranapanema ' )
3 >>> a #l e t r a s em a
4 set ([ ' i ' , 'p ' , 'r ' , 'a ' , 'o ' ])
5 >>> a b #L e t r a s em a mas no em b
6 set ([ ' i ' , 'o ' ])
7 >>> a | b #l e t r a s em a ou b
8 set ([ 'a ' , 'e ' , ' i ' , 'm ' , 'o ' , 'n ' , 'p ' , 'r '
])
9 >>> a & b #l e t r a s em a e b
10 set ([ 'a ' , 'p ' , 'r ' ])
11 >>> a ^ b #l e t r a s em a ou b mas no em ambos
12 set ([ ' i ' , 'm ' , 'e ' , 'o ' , 'n ' ] )
No exemplo 1.4 pode-se observar as seguintes correspondncias en-

tre a notao do Python e a notao matemtica convencional:
a - b: A B8
a | b: AB
8 Por conveno representa-se conjuntos por letras maisculas.
a & b: A B
a b: (A B) (A B)
1.5 Controle de uxo

Em condies normais o interpretador executa as linhas de um
programa uma a uma. As excees a este caso so linhas perten-
centes denio de funo e classe, que so executadas apenas
quando a respectiva funo ou classe chamada. Entretanto algu-
mas palavras reservadas tem o poder de alterar a direo do uxo
de execuo das linhas de um programa.
Condies
Toda linguagem de programao possui estruturas condicionais que

nos permitem representar decises: se isso, faa isso, caso contrrio
faa aquilo. Estas estruturas tambm so conhecidas por ramica-
es. O Python nos disponibiliza trs palavras reservadas para este
m: if , elif e else. O seu uso melhor demonstrado atravs de
um exemplo (Listagem 1.32).
Listagem 1.32: Exemplo do emprego de ramicaes.
1 if a == 1 :
2 #e s t e bloco executado se a for 1
3 pass
4 elif a == 2 :
5 #e s t e bloco executado se a for 2
6 pass
7 else :
8 #e s t e bloco executado se
9 #s e se nenhum dos blocos
10 #a n t e r i o r e s tiver sido executado
11 pass
1.5. CONTROLE DE FLUXO 29
No exemplo 1.32, vemos tambm emprego da palavra reservada

pass, que apesar de no fazer nada muito til quando ainda no
sabemos quais devem ser as consequncias de determinada condi-
o.
Uma outra forma elegante e compacta de implementar uma
ramicao condicional da execuo de um programa atravs de
dicionrios (Listagem 1.33). As condies so as chaves de um
dicionrio cujos valores so funes. Esta soluo no contempla o
else, porm.
Listagem 1.33: Implementando a funcionalidade de if e elif por

meio de um dicionrio.
1 d e s f e c h o s = { 1 : fun1 , 2 : fun2 }
2 desfechos [ a ]
Iterao
Muitas vezes em problemas computacionais precisamos executar

uma tarefa, repetidas vezes. Entretanto no desejamos ter que es-
crever os mesmos comandos em sequncia, pois alm de ser uma
tarefa tediosa, iria transformar nosso belo programa em algo si-
milar a uma lista telefnica. A soluo tradicional para resolver
este problema a utilizao de laos (loops) que indicam ao inter-
pretador que ele deve executar um ou mais comandos um nmero
arbitrrio de vezes. Existem vrios tipos de laos disponveis no
Python.
O lao while: O lao while repete uma tarefa enquanto uma

condio for verdadeira (Listagem 1.34). Esta tarefa consiste em
um ou mais comandos indentados em relao ao comando que inicia
o lao. O m da indentao indica o m do bloco de instrues
que deve ser executado pelo lao.
Listagem 1.34: Comandos de lao no Python.
1 >>> while True :

2 pass#r e p e t e indefinidamente
3 >>> i =0
4 >>> while i < 10:
5 i +=1
6 print i
7 # saida omitida
8 >>> for i in r a n g e ( 1 ) :
9 print i
O lao for: O lao for nos permite iterar sobre uma sequn-
cia atribuindo os elementos da mesma a uma varivel, sequencial-
mente, medida que prossegue. Este lao se interrompe automa-
ticamente ao nal da sequncia.
Iterao avanada: O Python nos oferece outras tcnicas de

iterao sobre sequncias que podem ser bastante teis na redu-
o da complexidade do cdigo. No exemplo 1.31 ns vimos que
dicionrios possuem mtodos especcos para iterar sobre seus com-
ponentes. Agora suponhamos que desejssemos iterar sobre uma
lista e seu ndice?
Listagem 1.35: A funo enumerate.
1 >>> for n,e in enumerate ( [ ' a ' , ' b ' , ' c ' , ' d ' , ' e
' ]) :
2 print "%s : %s "%(n , e )
3
4 0: a
5 1: b
6 2: c
7 3: d
8 4: e
A funo enumerate (exemplo 1.35) gera um iterador similar ao

visto no exemplo 1.31. O lao for chama o mtodo next deste ite-
rador repetidas vezes, at que receba a mensagem StopIteration
(ver exemplo 1.31).
O comando zip nos permite iterar sobre um conjunto de seqen-
cias pareando sequencialmente os elementos das mltiplas listas
(exemplo 1.36).
Listagem 1.36: Iterando sobre mais de uma sequncia.
1 >>> p e r g u n t a s = [ ' nome ' , ' c a r g o ' , ' p a r t i d o ' ]

2 >>> r e s p o s t a s = [ ' L u l a ' , ' P r e s i d e n t e ' , 'PT ' ]
3 >>> for p, r in z i p ( p e r g u n t a s , r e s p o s t a s ) :
4 print " q u a l o s e u %s ? %s "%(p , r )
5
6
7 qual o seu nome ? Lula
8 qual o seu cargo ? Presidente
9 qual o seu p a r t i d o ? PT
Podemos ainda desejar iterar sobre uma sequncia em ordem

reversa (exemplo 1.5), ou iterar sobre uma sequncia ordenada sem
alterar a sequncia original (exemplo 1.37). Note que no exemplo
1.37, a lista original foi convertida em um conjunto (set) para
eliminar as repeties.
1 >>> for i in r e v e r s e d ( r a n g e ( 5 ) ) :
2 print i
3 4
4 3
5 2
6 1
7 0
Listagem 1.37: Iterando sobre uma sequncia ordenada.
1 >>> for i in sorted ( set ( l ) ) :

2 print i
3 laranja
4 leite
5 manga
6 ovos
7 uva
Iteraes podem ser interrompidas por meio da palavra reser-

vada break. Esta pode ser invocada quando alguma condio se
concretiza. Podemos tambm saltar para a prxima iterao (sem
completar todas as instrues do bloco) por meio da palavra re-
servada continue. A palavra reservada else tambm pode ser
aplicada ao nal de um bloco iterativo. Neste caso o bloco denido
por else s ser executado se a iterao se completar normalmente,
isto , sem a ocorrncia de break.
Lidando com erros: Excees
O mtodo da tentativa e erro no exatamente aceito na ortodoxia

cientca mas, frequentemente, utilizado no dia a dia do trabalho
cientco. No contexto de um programa, muitas vezes somos fora-
dos a lidar com possibilidades de erros e precisamos de ferramentas
para lidar com eles.
Muitas vezes queremos apenas continuar nossa anlise, mesmo
quando certos erros de menor importncia ocorrem; outras vezes,
o erro justamente o que nos interessa, pois nos permite examinar
casos particulares onde nossa lgica no se aplica.
Como de costume o Python nos oferece ferramentas bastante
intuitivas para interao com erros .
9
Listagem 1.38: Exemplo de uma exceo
1 >>> 1 / 0
9 Os erros tratados nesta seo no so erros de sintaxe mas erros que

ocorrem durante a execuo de programas sintaticamente corretos. Estes erros
sero denomidados excees

4 ZeroDivisionError : integer division or
modulo by zero
Suponhamos que voc escreva um programa que realiza divises

em algum ponto, e dependendo dos dados fornecidos ao programa,
o denominador torna-se zero. Como a diviso por zero no poss-
vel, o seu programa para, retornando uma mensagem similar a da
listagem 1.38. Caso voc queira continuar com a execuo do pro-
grama apesar do erro, poderamos solucionar o problema conforme
o exposto na listagem 1.39
Listagem 1.39: Contornando uma diviso por zero
1 >>> for i in range (5) :

2 ... try :
3 ... q =1./ i
4 ... print q
5 ... except Z e r o D i v i s i o n E r r o r :
6 ... print " D i v i s o p o r z e r o ! "
7 ...
8 Diviso por zero !
9 1.0
10 0.5
11 0.333333333333
12 0.25
A construo try:...except: nos permite vericar a ocorrn-

cia de erros em partes de nossos programas e responder adequa-
damente a ele. o Python reconhece um grande nmero de tipos
de excees, chamadas built-in exceptions. Mas no precisamos
sab-las de cor, basta causar o erro e anotar o seu nome.
Certas situaes podem estar sujeitas ocorrncia de mais de
um tipo de erro. neste caso, podemos passar uma tupla de excees
para a palavra-chave except: except (NameError, ValueError,IOError):pass,
ou simplesmente no passar nada: except: pass. Pode aconte-
cer ainda que queiramos lidar de forma diferente com cada tipo de
erro (listagem 1.40).
Listagem 1.40: Lidando com diferentes tipos de erros.
1 >>> try :
2 f = open ( ' a r q . t x t ' )
3 s = f . readline ()
4 i = int ( s . strip () )
5 except I O E r r o r , ( errno , strerror ) :
6 print " E r r o de I /O (% s ) : %s " % (
errno , strerror )
7 except V a l u e E r r o r :
8 print "No f o i possvel converter o
dado em Inteiro . "
9 except :
10 print " Erro desconhecido . "
A construo try:...except: acomoda ainda uma clusula

else opcional, que ser executada sempre que o erro esperado no
ocorrer, ou seja, caso ocorra um erro imprevisto a clusula else
ser executada (ao contrrio de linhas adicionais dentro da clusula
try).
Finalmente, try permite uma outra clusula opcional, finally,
que sempre executada (quer haja erros quer no). Ela util para
tarefas que precisam ser executadas de qualquer forma, como fechar
arquivos ou conexes de rede.
1.6 Funes
No Python, uma funo um bloco de cdigo denido por um
cabealho especco e um conjunto de linhas indentadas, abaixo
deste. Funes, uma vez denidas, podem ser chamadas de qual-
quer ponto do programa (desde que pertenam ao espao de no-
1.6. FUNES 35
mes). Na verdade, uma diferena fundamental entre uma funo e

outros objetos o fato de ser chamvel. Isto decorre do fato de to-
das as funes possuirem um mtodo
10 chamado __call__. Todos
os objetos que possuam este mtodo podero ser chamados
11 .
O ato de chamar um objeto, em Python, caracterizado pela
aposio de parnteses ao nome do objeto. Por exemplo: func().
Estes parnteses podem ou no conter argumentos. Continue
lendo para uma explicao do que so argumentos.
Funes tambm possuem seu prprio espao de nomes, ou seja,
todas as variveis denidas no escopo de uma funo s existem
dentro desta. Funes so denidas pelo seguinte cabealho:
1 def nome ( p a r 1 , par2 , p a r 3=v a l o r d e f a u l t ,

args , k w a r g s ) :
A palavra reservada def indica a denio de uma funo; em
seguida deve vir o nome da funo que deve seguir as regras de
formao de qualquer nome em Python. Entre parnteses vem,
opcionalmente, uma lista de argumentos que sero ser passados
para a funo quando ela for chamada. Argumentos podem ter
valores default se listados da forma a=1. Argumentos com valores
default devem vir necessariamente aps todos os argumentos sem
valores default(Listagem 1.41).
Listagem 1.41: Denindo uma funo com um argumento obriga-

trio e outro opcional (com valor default").
1 >>> def f u n ( a , b=1) :

2 ... print a,b
3 ...
4 >>> f u n ( 2 )
5 2 1
10 Veja o captulo 2 para uma explicao do que so mtodos.

11 O leitor, neste ponto deve estar imaginando todo tipo de coisas inte-
ressantes que podem advir de se adicionar um mtodo __call__ a objetos
normalmente no chamveis.
6 >>> f u n ( 2 , 3 )
7 2 3
8 fun ( b=5 ,2)
9 SyntaxError : nonke ywo rd arg after key wor d
arg
Por m, um nmero varivel de argumentos adicionais pode ser

previsto atravs de argumentos precedidos por * ou **. No exemplo
acima, argumentos passados anonimamente (no associados a um
nome) sero colocados em uma tupla de nome t, e argumentos
passados de forma nominal (z=2,q='asd')sero adicionados a um
dicionrio, chamado d(Listagem 1.42).
Listagem 1.42: lista de argumentos varivel
1 >>> def fun ( t , d ) :

2 print t , d
3 >>> f u n ( 1 , 2 , c =2 , d=4)
4 (1 ,2) { ' c ' :3 , 'd ' :4}
Funes so chamadas conforme ilustrado na linha 3 da listagem

1.42. Argumentos obrigatrios, sem valor default, devem ser pas-
sados primeiro. Argumentos opcionais podem ser passados fora de
ordem, desde que aps os argumentos obrigatrios, que sero atri-
budos sequencialmente aos primeiros nomes da lista denida no
cabealho da funo(Listagem 1.41).
Muitas vezes conveniente desempacotar os argumentos pas-
sados para uma funo a partir de uma tupla ou dicionrio.
Listagem 1.43: Desempacotando argumentos.
1 >>> def fun ( a , b , c , d ) :

2 print a,b,c ,d
3 >>> t = ( 1 , 2 ) ; d i = { ' d ' : 3, 'c ' : 4}
4 >>> f u n ( t , d i )
5 1 2 4 3
1.6. FUNES 37
Argumentos passados dentro de um dicionrio podem ser utili-

zados simultneamente para argumentos de passagem obrigatria
(declarados no cabealho da funo sem valor default) e para ar-
gumentos opcionais, declarados ou no(Listagem 1.44).
Listagem 1.44: Passando todos os argumentos por meio de um

dicionrio.
1 >>> def fun2 ( a , b =1 , o u t r o s ) :

2 ... print a, b, outros
3 ...
4 >>> d i c = { ' a ' : 1 , ' b ' : 2 , ' c ' : 3 , ' d ' : 4 }
5 >>> f u n 2 ( d i c )
6 1 2 { 'c ' : 3, 'd ' : 4}
Note que no exemplo 1.44, os valores cujas chaves correspon-

dem a argumentos declarados, so atribudos a estes e retirados do
dicionrio, que ca apenas com os tens restantes.
Funes podem retornar valores por meio da palavra reservada
return.
Listagem 1.45: Retornando valores a partir de uma funo.
1 >>> def soma ( a , b ) :

2 return a+b
3 print " i g n o r a d o ! "
4 >>> soma (3 ,4)
5 7
A palavra return indica sada imediata do bloco da funo le-

vando consigo o resultado da expresso sua direita.
Funes lambda
Funes lambda so pequenas funes annimas que podem ser

denidas em apenas uma linha. Por denio, podem conter uma
nica expresso.
Listagem 1.46: Funes lambda
1 >>> def r a i z ( n ) :#d e f i n i n d o uma raiz de ordem

n
2 return lambda ( x ) : x ( 1 . / n )
3 >>> r 4 = r a i z ( 4 )#r 4 calcula a raiz de ordem
4
4 >>> r 4 ( 1 6 ) #u t i l i z a n d o
5 2
Observe no exemplo (1.46), que lambda lembra a denio de

variveis do espao de nome em que foi criada. Assim, r4 passa
a ser uma funo que calcula a raiz quarta de um nmero. Este
exemplo nos mostra que podemos modicar o funcionamento de
uma funo durante a execuo do programa: a funo raiz retorna
uma funo raiz de qualquer ordem, dependendo do argumento que
receba.
Geradores
Geradores so um tipo especial de funo que retm o seu estado

de uma chamada para outra. So muito convenientes para criar
iteradores, ou seja, objetos que possuem o mtodo next().
Listagem 1.47: Geradores
1 >>> def l e t r a s ( palavra ) :

2 for i in palavra :
3 yield i
4 >>> for L in l e t r a s ( ' gato ' ) : print L
5 g
6 a
7 t
8 o
Como vemos na listagem 1.47 um gerador uma funo sobre

a qual podemos iterar.
1.6. FUNES 39
Decoradores
Decoradores so uma alterao da sintaxe do Python, introdu-

zida a partir da verso 2.4, para facilitar a modicao de funes
(sem alter-las), adicionando funcionalidade. Nesta seo vamos
ilustrar o uso bsico de decoradores. Usos mais avanados po-
dem ser encontrados nesta url: http://wiki.python.org/moin/
PythonDecoratorLibrary.
Listagem 1.48: Decorador bsico.
1 def faznada ( f ) :
2 def novaf ( args , kwargs ) :
3 print " chamando . . . " , a r g s , k w a r g s
4 return f ( a r g s , k w a r g s )
5 n o v a f . __name__ = f . __name__
6 n o v a f . __doc__ = f . __doc__
7 n o v a f . __dict__ . u p d a t e ( f . __dict__ )
8 return novaf
Na listagem 1.48, vemos um decorador muito simples. Como

seu nome diz, no faz nada, alm de ilustrar a mecnica de um de-
corador. Decoradores esperam um nico argumento: uma funo.
A listagem 1.49, nos mostra como utilizar o decorador.
Listagem 1.49: Utilizando um decorador
1 >>>@ f a z n a d a
2 def soma ( a , b ) :
3 return a+b
4
5 >>> soma ( 1 , 2 )
6 chamando . . . (1 , 2) {}
7 Out [ 5 ] : 3
O decorador da listagem 1.48, na verdade adiciona uma linha

de cdigo funo que decora: print "chamando...",args,kwargs.
Repare que o decorador da listagem 1.48, passa alguns atribu-
tos bsicos da funo original para a nova funo, de forma que
a funo decorada possua o mesmo nome, docstring, etc. que a
funao original. No entanto, esta passagem de atributos polui
o cdigo da funo decoradora. Podemos evitar a poluio e o
trabalho extra utilizando a funcionalidade do mdulo functools.
Listagem 1.50: Limpando a gerao de decoradores
1 >>> from f u n c t o o l s import wraps

2 >>> def m e u D e c o r a d o r ( f ) :
3 ... @wraps ( f )
4 ... def novaf ( args , kwds ) :
5 ... print ' Chamando funcao
decorada '
6 ... return f ( a r g s , kwds )
7 ... return n o v a f
8 ...
9 >>> @meuDecorador
10 ... def exemplo ( ) :
11 ... """ Docstring """
12 ... print ' funcao exemplo
executada ! '
13 ...
14 >>> e x e m p l o ( )
15 Chamando funcao decorada
16 funcao exemplo executada !
17 >>> e x e m p l o . __name__
18 ' exemplo '
19 >>> e x e m p l o . __doc__
20 ' Docstring '
Decoradores nao adicionam nenhuma funcionalidade nova ao

que j possvel fazer com funes, mas ajudam a organizar o
cdigo e reduzir a necessidade duplicao. Aplicaes cientcas
1.6. FUNES 41
de decoradores so raras, mas a sua presena em pacotes e mdu-

los de utilizao genrica vem se tornando cada vez mais comum.
Portanto, familiaridade com sua sintaxe aconselhada.
Strings de Documentao
Strings posicionadas na primeira linha de uma funo, ou seja,

diretamente abaixo do cabealho, so denominadas strings de do-
cumentao, ou simplesmente docstrings.
Estas strings devem ser utilizadas para documentar a funo
explicitando sua funcionalidade e seus argumentos. O contedo de
uma docstring est disponvel no atributo __doc__ da funo.
Ferramentas de documentao de programas em Python ex-
traem estas strings para montar uma documentao automtica
de um programa. A funo help(nome_da_funo) tambm re-
torna a docstring. Portanto a incluso de docstrings auxilia tanto
o programador quanto o usurio.
Listagem 1.51: Usando Docstrings
1 >>> def soma ( a , b ) :

2 """
3 Esta funcao soma dois numeros :
4 >>> soma ( 2 , 3 )
5 5
6 """
7 return a+b
8 >>> h e l p ( soma )
9 Help on function soma in module __main__ :
10
11 soma ( a , b)
12 Esta funcao soma dois numeros :
13 >>> soma ( 2 , 3 )
14 5
No exemplo 1.51, adicionamos uma docstring explicando a na-
lidade da funo soma e ainda inclumos um exemplo. Incluir um
exemplo de uso da funo cortado e colado diretamente do console
Python (incluindo o resultado), nos permitir utilizar o mdulo
doctest para testar funes, como veremos mais adiante.
1.7 Mdulos e Pacotes

Para escrever programas de maior porte ou agregar colees de
funes e/ou objetos criados pelo usurio, o cdigo Python pode
ser escrito em um arquivo de texto, salvo com a terminao .py,
facilitando a re-utilizao daquele cdigo. Arquivos com cdigo
Python contrudos para serem importados, so denominados m-
dulo. Existem algumas variaes na forma de se importar mdu-
los. O comando import meumodulo cria no espao de nomes um
objeto com o mesmo nome do mdulo importado. Funes, classes
(ver captulo 2) e variveis denidas no mdulo so acessveis como
atributos deste objeto. O comando from modulo import * im-
porta todas as funes e classes denidas pelo mdulo diretamente
para o espao de nomes global
12 do nosso script. Deve ser utilizado
com cuidado pois nomes iguais pr-existentes no espao de nomes
global sero redenidos. Para evitar este risco, podemos substituir
o * por uma sequncia de nomes correspondente aos objetos que
desejamos importar: from modulo import nome1, nome2. Pode-
mos ainda renomear um objeto ao import-lo: import numpy as
N ou ainda from numpy import det as D.
Seja um pequeno mdulo como o do exemplo 1.52. Podemos
importar este mdulo em uma sesso do interpretador iniciada no
mesmo diretrio que contm o mdulo (exemplo 1.7).
1 >>> import fibo
12 Dicionrio de nomes de variveis e funes vlidos durante a execuo de

um script
1.7. MDULOS E PACOTES 43
Listagem 1.52: Mdulo exemplo
1 # Disponvel no pacote de programas como :

f i b o . py
2 #modulo para calcular a serie de fibonacci
ate o numero n.
3
4 def fib (n) :
5 a, b = 0, 1
6 while b < n:
7 print b,
8 a, b = b, a+b
9
10 if __name__=="__main__" :
11 import s y s
12 print __name__
13 print s y s . a r g v
14 f i b ( i n t ( sys . argv [ 1 ] ) )
2 >>> f i b o . f i b ( 5 0 )
3 1 1 2 3 5 8 13 21 34
4 >>> f i b o . __name__
5 ' fibo '
Note que a funo declarada em fibo.py chamada como um

mtodo de fibo. Isto porque mdulos importados so objetos
(como tudo o mais em Python).
Quando um mdulo importado ou executado diretamente ,
torna-se um objeto com um atributo __name__. O contedo deste
atributo depende de como o mdulo foi executado. Se foi executado
por meio de importao, __name__ igual ao nome do mdulo
(sem a terminao .py). Se foi executado diretamente (python
modulo.py), __name__ igual a __main__.
Durante a importao de um mdulo, todo o cdigo contido no
mesmo executado, entretanto como o __name__ de bo fibo
e no __main__, as linhas abaixo do if no so executadas.
Qual ento a funo destas linhas de cdigo? Mdulos podem ser
executados diretamente pelo interpretador, sem serem importados
primeiro. Vejamos isso no exemplo 1.53. Podemos ver que agora
o __name__ do mdulo __main__ e, portanto, as linhas de
cdigo dentro do bloco if so executadas. Note que neste caso
importamos o mdulo sys, cujo atributo argv nos retorna uma
lista com os argumentos passados para o mdulo a partir da posio
1. A posio 0 sempre o nome do mdulo.
Listagem 1.53: Executing a module from the console.
1 $ python f i b o . py 60
2 __main__
3 [ ' f i b o . py ' , '60 ']
4 1 1 2 3 5 8 13 21 34 55
Qualquer arquivo com terminao .py considerado um m-

dulo Python pelo interpretador Python. Mdulos podem ser exe-
cutados diretamente ou importados por outros mdulos.
A linguagem Python tem como uma de suas principais vanta-
gens uma biblioteca bastante ampla de mdulos, includa com a
distribuio bsica da linguagem. Nesta seo vamos explorar al-
guns mdulos da biblioteca padro do Python, assim como outros,
mdulos que podem ser obtidos e adicionados sua instalao do
Python.
Para simplicidade de distribuio e utilizao, mdulos podem
ser agrupados em pacotes. Um pacote nada mais do que um
diretrio contendo um arquivo denominado __init__.py (este ar-
quivo no precisa conter nada). Portanto, pode-se criar um pacote
simplesmente criando um diretrio chamado, por exemplo, pacote
contendo os seguintes mdulos: modulo1.py e modulo2.py13 . Um
13 Alm de __init__.py, naturalmente.

1.7. MDULOS E PACOTES 45
pacote pode conter um nmero arbitrrio de mdulos, assim como

outros pacotes.
Como tudo o mais em Python, um pacote tambm um objeto.
Portanto, ao importar o pacote pacote em uma sesso Python,
modulo1 e modulo2 aparecero como seus atributos (listagem 1.54).
Listagem 1.54: importing a package
1 >>> import pacote

2 >>> d i r ( p a c o t e )
3 [ ' modulo1 ' , ' modulo2 ' ]
Pacotes teis para Computao Cientca
Numpy
Um dos pacotes mais importantes, seno o mais importante para
quem deseja utilizar o Python em computao cientca, o numpy.
Este pacote contm uma grande variedade de mdulos voltados
para resoluo de problemas numricos de forma eciente.
Exemplos de objetos e funes pertencentes ao pacote numpy
aparecero regularmente na maioria dos exemplos deste livro. Uma
lista extensiva de exemplos de Utilizao do Numpy pode ser con-
sultada neste endereo: http://www.scipy.org/Numpy_Example_
List
Na listagem 1.55, vemos um exemplo de uso tpico do numpy. O
numpy nos oferece um objeto matriz, que visa representar o conceito
matemtico de matriz. Operaes matriciais derivadas da algebra
linear, so ainda oferecidas como funes atravs do subpacote li-
nalg (Listagem 1.55).
Listagem 1.55: Calculando e mostrando o determinante de uma

matriz.
1 >>> from numpy import

2 >>> a = a r a n g e ( 9 )
3 >>> print a
4 [0 1 2 3 4 5 6 7 8]
5 >>> a . s h a p e =(3 ,3)
6 >>> print a
7 [[0 1 2]
8 [3 4 5]
9 [6 7 8]]
10 >>> from numpy . l i n a l g import det
11 >>> d e t ( a )
12 0.0
13 >>>
Na primeira linha do exemplo 1.55, importamos todas as fun-

es e classes denidas no mdulo numpy.
Na segunda linha, usamos o comando arange(9) para criar
um vetor a de 9 elementos. Este comando equivalente ao range
para criar listas, s que retorna um vetor (matriz unidimensional).
Note que este vetor composto de nmeros inteiros sucessivos co-
meando em zero. Todas as enumeraes em Python comeam
em zero. Como em uma lista, a[0] o primeiro elemento do ve-
tor a. O objeto que criamos, do tipo array, denido no m-
dulo numpy. Uma outra forma de criar o mesmo objeto seria: a =
array([0,1,2,3,4,5,6,7,8]).
Na terceira linha, ns mostramos o contedo da varivel a com
o comando print. Este comando imprime na tela o valor de uma
varivel.
Como tudo em Python um objeto, o objeto array apresenta
diversos mtodos e atributos. O atributo chamado shape contm o
formato da matriz como uma tupla, que pode ser multi-dimensional
ou no. Portanto, para converter vetor a em uma matriz 33, basta
atribuir o valor (3,3) a shape. Conforme j vimos, atributos e
mtodos de objetos so referenciados usando-se esta notao de
ponto
14 .
14 nome_da_varivel.atributo
1.8. DOCUMENTANDO PROGRAMAS 47
Na quinta linha, usamos o comando print para mostrar a al-

terao na forma da varivel a.
Na sexta linha importamos a funo det do mdulo numpy.linalg
para calcular o determinante da nossa matriz. A funo det(a) nos
informa, ento, que o determinante da matriz a 0.0.
Scipy
Outro mdulo muito til para quem faz computao numrica com
Python, o scipy. O scipy depende do numpy e prov uma
grande coleo de rotinas numricas voltadas para aplicaes em
matemtica, engenharia e estatstica.
Diversos exemplos da segunda parte deste livro se utilizaro
do scipy, portanto, no nos extenderemos em exemplos de uso do
scipy.
Uma lista extensa de exemplos de utilizao do scipy pode ser
encontrada no seguinte endereo:http://www.scipy.org/Documentation.
1.8 Documentando Programas

Parte importante de um bom estilo de trabalho em computao ci-
entca a documentao do cdigo produzido. Apesar do Python
ser uma linguagem bastante clara e de fcil leitura por humanos,
uma boa dose de documentao sempre positiva.
O Python facilita muito a tarefa tanto do documentador quanto
do usurio da documentao de um programa. Naturalmente, o
trabalho de documentar o cdigo deve ser feito pelo programador,
mas todo o resto feito pela prpria linguagem.
A principal maneira de documentar programas em Python
atravs da adio de strings de documentao (docstrings) a fun-
es e classes ao redigir o cdigo. Mdulos tambm podem possuir
docstrings contendo uma sinopse da sua funcionalidade. Estas
strings servem no somente como referncia para o prprio progra-
mador durante o desenvolvimento, como tambm como material
para ferramentas de documentao automtica. A principal ferra-
menta de documentao disponvel para desenvolvedores o pydoc,
que vem junto com a distribuio da linguagem.
Pydoc
O pydoc uma ferramenta que extrai e formata a documentao

de programas Python. Ela pode ser utilizada de dentro do console
do interpretador Python, ou diretamente do console do Linux.
1 $ pydoc pydoc
No exemplo acima, utilizamos o pydoc para examinar a documen-

tao do prprio mdulo pydoc. Podemos fazer o mesmo para
acessar qualquer mdulo disponvel no PYTHONPATH.
O pydoc possui algumas opes de comando muito teis:
-k <palavra> Procura por palavras na documentao de todos

os mdulos.
-p <porta> <nome> Gera a documentao em html iniciando

um servidor HTTP na porta especicada da mquina local.
-g til para sistemas sem fcil acesso ao console, inicia um servidor

HTTP e abre uma pequena janela para busca.
-w <nome> escreve a documentao requisitada em formato HTML,

no arquivo <nome>.html, onde <nome> pode ser um mdulo
instalado na biblioteca local do Python ou um mdulo ou pa-
cote em outra parte do sistema de arquivos. Muito til para
gerar documentao para programas que criamos.
Alm do pydoc, outras ferramentas mais sosticadas, desen-

volvidas por terceiros, esto disponveis para automatizar a docu-
mentao de programas Python. Exploraremos uma alternativa a
seguir.
1.8. DOCUMENTANDO PROGRAMAS 49
Epydoc
O Epydoc uma ferramenta consideravelmente mais sosticada do

que o mdulos pydoc. Alm de prover a funcionalidade j demon-
trada para o pydoc, oferece outras facilidades como a gerao da
documentao em formato PDF ou HTML e suporte formatao das
docstrings.
O uso do Epydoc similar ao do pydoc. Entretanto, devido

sua maior versatilidade, suas opes so bem mais numerosas
(1.56).
Listagem 1.56: Listando as opes do Epydoc.
1 $ epydoc h
No vamos discutir em detalhes as vrias opes do Epydoc

pois estas encontram-se bem descritas na pgina man do programa.
Ainda assim, vamos comentar algumas funcionalidades interessan-
tes.
A capacidade de gerar a documentao em L AT X, facilita a

E
customizao da mesma pelo usurio e a exportao para outros
formatos. A opo url, nos permite adicionar um link para o
website de nosso projeto ao cabealho da documentao. O Epydoc
tambm verica o quo bem nosso programa ou pacote encontra-
se documentado. Usando-se a opo check somos avisados sobre
todos os objetos no documentados.
A partir da verso 3.0, o Epydoc adiciona links para o cdigo

fonte na ntegra, de cada elemento de nosso mdulo ou pacote. A
opo graph pode gerar trs tipos de grcos sobre nosso pro-
grama, incluindo um diagrama UML(Figura 1.1).
Dada toda esta funcionalidade, vale apena conferir o Epydoc

15 .
15 http://epydoc.sourceforge.net
Figura 1.1: Verso HTML da documentao gerada pelo Epydoc.
1.9 Exerccios
1. Repita a iterao do exemplo 1.35 sem utilizar a funo enu-
merate. Execute a iterao do objeto gerado por enumerate
manualmente, sem o auxlio do lao for e observe o seu re-
sultado.
2. Adicione a funcionalidade else listagem 1.33 utilizando

excees.
3. Escreva um exemplo de iterao empregando break, continue

e else(ao nal).
Captulo 2
Programao Orientada a
Objetos
Introduo programao orientada a objetos e sua im-
plementao na linguagem Python. Pr-requisitos:
Ter lido o captulo 1.
P rogramao orientada a objetos um tema vasto na litera-

tura computacional. Neste captulo introduziremos os recur-
sos presentes na linguagem Python para criar objetos e, atravs de
exemplos, nos familiarizaremos com o paradigma da programao
orientada a objetos.
Historicamente, a elaborao de programas de computador pas-
sou por diversos paradigmas. Programas de computador comea-
ram como uma simples lista de instrues a serem executadas, em
sequncia, pela CPU. Este paradigma de programao foi mais
tarde denominado de programao no-estruturada. Sua principal
caracterstica a presena de comandos para desviar a execuo
para pontos especcos do programa (goto, jump, etc.) Exem-
plos de linguagens no-estruturadas so Basic, Assembly e Fortran.
Mais tarde surgiram as linguagens estruturadas, que permitiam a
organizao do programa em blocos que podiam ser executados em
qualquer ordem. As Linguagens C e Pascal ganham grande popu-
51
52 CAPTULO 2. ORIENTAO A OBJETO
laridade, e linguagens at ento no estruturadas (Basic, Fortran,
etc.) ganham verses estruturadas. Outros exemplos de lingua-
gens no estruturadas incluem Ada, D, Forth,PL/1, Perl, maple,
Matlab, Mathematica, etc.
A estruturao de programas deu origem a diversos paradig-
mas de programao, tais como a programao funcional, na qual
a computao vista como a avaliao sequencial de funes mate-
mticas, e cujos principais exemplos atuais so as linguagens Lisp
e Haskell.
A programao estruturada atingiu seu pico em versatilidade e
popularidade com o paradigma da programao orientada a obje-
tos. Na programao orientada a objetos, o programa dividido
em unidades (objetos) contendo dados (estado) e funcionalidade
(mtodos) prpria. Objetos so capazes de receber mensagens,
processar dados (de acordo com seus mtodos) e enviar mensagens
a outros objetos. Cada objeto pode ser visto como uma mquina
independente ou um ator que desempenha um papel especco.
2.1 Objetos
Um tema frequente em computao cientca, a simulao de
sistemas naturais de vrios tipos, fsicos, qumicos, biolgicos, etc.
A orientao a objetos uma ferramenta natural na construo de
simulaes, pois nos permite replicar a arquitetura do sistema natu-
ral em nossos programas, representando componentes de sistemas
naturais como objetos computacionais.
A orientao a objeto pode ser compreendida em analogia ao
conceito gramatical de objeto. Os componentes principais de uma
frase so: sujeito, verbo e objeto. Na programao orientada a
objeto, a ao est sempre associada ao objeto e no ao sujeito,
como em outros paradigmas de programao.
Um dos pontos altos da linguagem Python que facilita sua assi-
milao por cientistas com experincia prvia em outras linguagens
2.1. OBJETOS 53
Listagem 2.1: Denindo uma classe
1 class Objeto :
2 pass
de programao, que a linguagem no impe nenhum estilo de

programao ao usurio. Em Python pode-se programar de forma
no estruturada, estruturada, procedural, funcional ou orientada a
objeto. Alm de acomodar as preferncias de cada usurio, per-
mite acomodar as convenincias do problema a ser resolvido pelo
programa.
Neste captulo, introduziremos as tcnicas bsicas de progra-
mao orientada a objetos em Python. Em exemplos de outros
captulos, outros estilos de programao aparecero, justicados
pelo tipo de aplicao a que se prope.
Denindo Objetos e seus Atributos em Python
Ao se construir um modelo de um sistema natural, uma das carac-

tersticas desejveis deste modelo, um certo grau de generalidade.
Por exemplo, ao construir um modelo computacional de um auto-
mvel, desejamos que ele (o modelo) represente uma categoria de
automveis e no apenas nosso automvel particular. Ao mesmo
tempo, queremos ser capazes de ajustar este modelo para que ele
possa representar nosso automvel ou o de nosso vizinho sem pre-
cisar re-escrever o modelo inteiramente do zero. A estes modelos
de objetos d-se o nome de classes.
A denio de classes em Python pode ser feita de forma mais
ou menos genrica. partir das classes, podemos construir instn-
cias ajustadas para representar exemplares especcos de objetos
representados pela classe. Na listagem 2.1, temos uma denio
mnima de uma classe de objetos. Criamos uma classe chamada
Listagem 2.2: Denindo atributos de uma classe
1 class pessoa :
2 i d a d e =20
3 a l t u r a =170
4 s e x o= ' m a s c u l i n o '
5 p e s o =70
Objeto, inteiramente em branco. Como uma classe completamente

vazia no possvel em Python, adicionamos o comando pass que
no tem qualquer efeito.
Para criar uma classe mais til de objetos, precisamos denir
alguns de seus atributos. Como exemplo vamos criar uma classe
que represente pessoas. Na listagem 2.2, denimos alguns atribu-
tos para a classe pessoa. Agora, podemos criar instncias do objeto
pessoa e estas instncias herdaro estes atributos.
1 >>> m a r i a = p e s s o a ( )
2 >>> m a r i a . p e s o
3 70
4 >>> m a r i a . s e x o
5 ' masculino '
6 >>> m a r i a
7 <__main__ . p e s s o a instance at 0 x402f196c>
Entretanto, os atributos denidos para o objeto pessoa (listagem

2.2), so atributos que no se espera que permaneam os mesmos
para todas as possveis instncias (pessoas). O mais comum que
os atributos especcos das instncias sejam fornecidos no momento
da sua criao. Para isso, podemos denir quais as informaes
necessrias para criar uma instncia do objeto pessoa.
Listagem 2.3: Passando atributos na criao de um objeto
1 >>> class pessoa :

2.1. OBJETOS 55
2 ... def __init__ ( s e l f , i d a d e , a l t u r a , s e x o ,

peso ) :
3 ... s e l f . i d a d e=i d a d e
4 ... s e l f . a l t u r a=a l t u r a
5 ... s e l f . s e x o=s e x o
6 ... s e l f . p e s o =70
7 >>> m a r i a = p e s s o a ( )
10 TypeError : __init__ ( ) takes exactly 5
arguments (1 given )
11 m a r i a=p e s s o a ( 3 5 , 1 5 5 , ' f e m i n i n o ' , 5 0 )
12 >>> m a r i a . s e x o
13 ' feminino '
A funo __init__ que denimos na nova verso da classe pessoa

(listagem 2.3), uma funo padro de classes, que executada
automaticamente, sempre que uma nova instncia criada. Assim,
se no passarmos as informaes requeridas como argumentos pela
funo __init__ (listagem 2.3, linha 7), recebemos uma mensagem
de erro. Na linha 11 da listagem 2.3 vemos como instanciar a nova
verso da classe pessoa.
Adicionando Funcionalidade a Objetos
Continuando com a analogia com objetos reais, os objetos computa-

cionais tambm podem possuir funcionalidades, alm de atributos.
Estas funcionalidades so denominadas mtodos de objeto. Mto-
dos so denidos como funes pertencentes ao objeto. A funo
__init__ que vimos h pouco um mtodo presente em todos os
objetos, ainda que no seja denida pelo programador. Mtodos
so sempre denidos com, pelo menos, um argumento: self, que
pode ser omitido ao se invocar o mtodo em uma instncia do ob-
jeto (veja linha 11 da listagem 2.3). O argumento self tambm
deve ser o primeiro argumento a ser declarado na lista de argumen-
tos de um mtodo.
Herana
Para simplicar a denio de classes complexas, classes podem

herdar atributos e mtodos de outras classes. Por exemplo, uma
classe Felino, poderia herdar de uma classe mamfero, que por sua
vez herdaria de outra classe, vertebrados. Esta cadeia de herana
pode ser extendida, conforme necessrio (Listagem 2.4).
Listagem 2.4: Herana
1 >>> class Vertebrado :

2 v e r t e b r a = True
3 >>> class Mamifero ( V e r t e b r a d o ) :
4 mamas = True
5 >>> class C a r n i v o r o ( Mamifero ) :
6 l o n g o s _ c a n i n o s = True
7 >>> b i c h o = C a r n i v o r o ( )
8 >>> d i r ( b i c h o )
9 [ '__doc__ ' , ' __module__ ' , ' longos_caninos ' ,
' mamas ' , ' vertebra ' ]
10 >>> i s s u b c l a s s ( C a r n i v o r o , V e r t e b r a d o )
11 True
12 >>> b i c h o . __class__
13 < class __main__ . C a r n i v o r o at 0 x b 7 a 1 d 1 7 c>
14 >>> i s i n s t a n c e ( b i c h o , M a m i f e r o )
15 True
Na listagem 2.4, vemos um exemplo de criao de um objeto,

instncia da classe Carnivoro, herdando os atributos dos ancestrais
desta. Vemos tambm que possivel testar a pertinncia de um
objeto a uma dada classe, atravs da funo isinstance. A funo
issubclass, de forma anloga, nos permite vericar as relaes
parentais de duas classes.
2.2. EXERCCIOS 57
Utilizando Classes como Estruturas de Dados

Genricas.
Devido natureza dinmica do Python, podemos utilizar uma

classe como um compartimento para quaisquer tipos de dados. Tal
construto seria equivalente ao tipo struct da linguagem C. Para
exemplicar, vamos denir uma classe vazia:
Listagem 2.5: Classe como uma estrura de dados
1 >>> class C a c h o r r o :
2 pass
3 >>> r e x=C a c h o r r o ( )
4 >>> r e x . dono = ' P e d r o '
5 >>> r e x . r a c a = ' P a s t o r '
6 >>> r e x . p e s o =25
7 >>> r e x . dono
8 ' Pedro '
9 >>> l a i k a = C a c h o r r o ( )
10 >>> l a i k a . dono
11 AttributeError : Cachorro instance has no
attribute ' dono '
No exemplo 2.5, a classe Cachorro criada vazia, mas ainda

assim, atributos podem ser atribuidos a suas instncias, sem alterar
a estrutura da classe.
2.2 Exerccios
1. Utilizando os conceitos de herana e os exemplos de classes
apresentados, construa uma classe Cachorro que herde atri-
butos das classes Carnivoro e Mamfero e crie instncias que
possuam donos, raas, etc.
2. No Python, o que dene um objeto como chamvel (funes,

por exemplo) a presena do mtodo __call__. Crie uma
classe, cujas instncias podem ser chamadas, por possurem
o mtodo __call__.
Captulo 3
Criando Grcos em Python

Introduo produo de guras de alta qualidade uti-
lizando o pacote matplotlib. Pr-requisitos: Captulo
1.
E xiste um nmero crescente de mdulos para a criao de gr-

cos cientcos com Python. Entretanto, at o momento da
publicao deste livro, nenhum deles fazia parte da distribuio
ocial do Python.
Para manter este livro prtico e conciso, foi necessrio escolher
apenas um dos mdulos de grcos disponveis, para apresentao
neste captulo.
O critrio de escolha levou em considerao os principais valores
da losoa da linguagem Python (ver listagem ): simplicidade,
elegncia, versatilidade, etc. poca, a aplicao destes critrios
nos deixou apenas uma opo: o mdulo matplotlib .
1
3.1 Introduo ao Matplotlib

O mdulo matplotlib (MPL) voltado para a gerao de grcos
bi-dimensionais de vrios tipos, e se presta para utilizao tanto in-
1 http://matplotlib.sourceforge.net
59
60 CAPTULO 3. CRIANDO GRFICOS EM PYTHON
terativa quanto em scripts, aplicaes web ou integrada a interfaces
grcas (GUIs) de vrios tipos.
A instalao do MPL tambm segue o padro de simplicidade

do Python (listagem 3.1). Basta baixar o pacote tar.gz do stio,
descompactar e executar o comando de instalao.
Listagem 3.1: Instalando o matplotlib
1 $ python s e t u p . py install
O MPL procura tornar simples tarefas de plotagem, simples e

tarefas complexas, possveis (listagem3.2, gura 3.1). Os grcos
gerados podem ser salvos em diversos formatos: jpg, png, ps, eps e
svg. Ou seja, o MPL exporta em formatos raster e vetoriais (svg)
o que torna sua sada adequada para insero em diversos tipos de
documentos.
Listagem 3.2: Criando um histograma no modo interativo
1 >>> from pylab import

2 >>> from numpy . random import
3 >>> x=n o r m a l ( 0 , 1 , 1 0 0 0 )
4 >>> h i s t ( x , 3 0 )
5 ...
6 >>> show ( )
Podemos tambm embutir a sada grca do MPL em diver-

sas GUIs: GTK, WX e TKinter. Naturalmente a utilizao do
MPL dentro de uma GUI requer que os mdulos adequados para
o desenvolvimento com a GUI em questo estejam instalados .
2
Para gerar os grcos e se integrar a interfaces grcas, o MPL

se utiliza de diferentes backends de acordo com nossa escolha
(Wx, GTK, Tk, etc).
2 Veja no sitio do MPL os pr-requisitos para cada uma das GUIs

3.1. INTRODUO AO MATPLOTLIB 61
Figura 3.1: Histograma simples a partir da listagem 3.2
Congurando o MPL
O MPL possui valores default para propriedades genricas dos gr-

cos gerados. Estas conguraes cam em um arquivo texto
chamado matplotlibrc, que deve ser copiado da distribuio do
MPL, editado conforme as preferncias do usurio e renomeado
para /.matplotlibrc, ou seja, deve ser colocado como um ar-
quivo oculto no diretrio home do usurio.
A utilizao de conguraes padro a partir do matplotlibrc
mais til na utilizao interativa do MPL, pois evita a necessidade
de congurar cada gura de acordo com as nossas preferncias, a
bar Grco de barras
cohere Grco da funo de coerncia
csd Densidade espectral cruzada
errorbar Grco com barras de erro
hist Histograma
imshow Plota imagens
pcolor Grco de pseudocores
plot Grco de linha
psd Densidade espectral de potncia
scatter Diagrama de espalhamento
specgram Espectrograma
stem Pontos com linhas verticais
Tabela 3.1: Principais comandos de plotagem do MPL
cada vez que usamos o MPL .

3
Comandos Bsicos
Os comandos relacionados diretamente gerao de grcos so

bastante numerosos(tabela 3.1); mas, alm destes, existe um outro
conjunto ainda maior de comandos, voltados para o ajuste no de
detalhes dos grcos (ver tabela 3.2, para uma amostra), tais como
tipos de linha, smbolos, cores, etc. Uma explicao mais detalhada
dos comandos apresentados na tabela 3.1, ser dada nas prximas
sees no contexto de exemplos.
3 Para uma descrio completa das caractersticas de grcos que podem

ser conguradas, veja o ememplo de matplotlibrc que fornecido com a
distribuio do MPL.
3.2. EXEMPLOS SIMPLES 63
Figura 3.2: Reta simples a partir da listagem 3.3
3.2 Exemplos Simples

O comando plot
O comando plot um comando muito verstil, pode receber um
nmero varivel de argumentos, com diferentes sadas.
Listagem 3.3: Grco de linha
1 from pylab import

2 plot ([1 ,2 ,3 ,4])
3 show ( )
Quando plot recebe apenas uma sequncia de nmeros (lista, tupla
ou array), ele gera um grco (listagem 3.3) utilizando os valores
recebidos como valores de y enquanto que os valores de x so as
posies destes valores na sequncia.
Caso duas sequncias de valores sejam passadas para plot (lis-
tagem 3.4), a primeira atribuida a x e a segunda a y. Note que,
neste exemplo, ilustra-se tambm a especicao do tipo de sada
grca como uma sequncia de pontos. O parmtero 'ro' indica
que o smbolo a ser usado um crculo vermelho.
Listagem 3.4: Grco de pontos com valores de x e y especicados.

1 from pylab import
2 plot ([1 ,2 ,3 ,4] , [1 ,4 ,9 ,16] , ' ro ' )
3 axis ([0 , 6, 0, 20])
4 s a v e f i g ( ' p o n t o . png ' )
5 show ( )
Na linha 3 da listagem 3.4 especica-se tambm os limites dos eixos

como uma lista de quatro elementos: os valores mnimo e mximo
dos eixos x e y, respectivamente. Na linha 4, vemos o comando
savefig que nos permite salvar a gura gerada no arquivo cujo
nome dado pela string recebida. O tipo de arquivo determinado
pela extenso (.png, .ps, .eps, .svg, etc).
O MPL nos permite controlar as propriedades da linha que
forma o grco. Existe mais de uma maneira de determinar as
propriedades das linhas geradas pelo comando plot. Uma das
maneiras mais diretas atravs dos argumentos listados na tabela
3.2. Nos diversos exemplos apresentados neste captulo, alguns
outros mtodos sero apresentados e explicados .
4
Vale a pena ressaltar que o comando plot aceita, tanto listas,

quanto arrays dos mdulos Numpy, Numeric ou numarray. Na ver-
4 Para maiores detalhes consulte a documentao do MPL
(http://matplotlib.sourceforge.net).
Figura 3.3: Grco com smbolos circulares a partir da listagem

3.4
dade todas a sequncias de nmeros passadas para o comando plot

so convertidas internamente para arrays.
O Comando subplot
O MPL trabalha com o conceito de gura independente do de ei-
xos. O comando gcf() retorna a gura atual, e o comando gca()
retorna os eixos atuais. Este detalhe nos permite posicionar os ei-
xos de um grco em posies arbitrrias dentro da gura. Todos
os comandos de plotagem so realizados nos eixos atuais. Mas,
para a maioria dos usurios, estes detalhes so transparentes, ou
Tabela 3.2: Argumentos que podem ser passados juntamente com
a funo plot para controlar propriedades de linhas.
Propriedade Valores
alpha transparncia (0-1)
antialiased true | false
color Cor: b,g,r,c,m,y,k,w
label legenda
linestyle -- : -. -
linewidth Espessura da linha (pontos)
marker + o . s v x > < ^
markeredgewidth Espessura da margem do smbolo
markeredgecolor Cor da margem do smbolo
markerfacecolor Cor do smbolo
markersize Tamanho do smbolo (pontos)
seja, o usrio no precisa tomar conhecimento deles. A listagem

3.5 apresenta uma gura com dois eixos feita de maneira bastante
simples.
Listagem 3.5: Figura com dois grcos utilizando o comando sub-

plot.
1 # Disponivel no pacote de programas como :

s u b p l o t . py
2 from pylab import
3
4 def f(t):
5 s1 = cos (2 pi t )
6 e 1 = e x p ( t )
7 return m u l t i p l y ( s1 , e1 )
8
9 t1 = arange ( 0 . 0 , 5.0 , 0.1)
10 t2 = arange ( 0 . 0 , 5.0 , 0.02)
Figura 3.4: Figura com dois grcos utilizando o comando subplot,

a partir da listagem 3.5
11
12 figure (1)
13 subplot (211)
14 p l o t ( t1 , f ( t1 ) , ' bo ' , t2 , f ( t2 ) , 'k ' )
15
16 subplot (212)
17 p l o t ( t2 , cos (2 pi t2 ) , ' r ' )
18 s a v e f i g ( ' s u b p l o t . png ' , d p i =400)
19 show ( )
Tabela 3.3: Argumentos opcionais dos comandos de insero de
texto.
Propriedades Valores
alpha Transparncia (0-1)
color Cor
fontangle italic | normal | oblique
fontname Nome da fonte
fontsize Tamanho da fonte
fontweight normal | bold | light4
horizontalalignment left | center | right
rotation horizontal | vertical
verticalalignment bottom | center | top
O comando figure(1), na linha 11 da listagem 3.5, opcional,

mas pode vir a ser importante quando se deseja criar mltiplas
guras, antes de dar o comando show(). Note pelo primeiro co-
mando plot da listagem 3.5, que o comando plot aceita mais de
um par (x,y), cada qual com seu tipo de linha especicado inde-
pendentemente.
Adicionando Texto a Grcos
O MPL nos oferece quatro comandos para a adio de texto a gu-

ras: title, xlabel, ylabel, e text. O trs primeiros adicionam
ttulo e nomes para os eixos x e y, respectivamente.
Todos os comandos de insero de texto aceitam argumentos
(tabela 3.3) adicionais para formatao do texto. O MPL tam-
bm nos permite utilizar um subconjunto da linguagem TEXpara
formatar expresses matemticas (Listagem 3.6 e gura 3.5. Para
inserir expresses em TEX, necessrio que as strings contendo
5
as expresses matemticas sejam raw strings , e delimitadas por
5 exemplo: r'raw string'

3.3. EXEMPLOS AVANADOS 69
cifres($).
Listagem 3.6: Formatando texto e expresses matemticas

m a t h t e x t . py
2 from pylab import
3 t = arange ( 0 . 0 , 2.0 , 0.01)
4 s = s i n (2 pi t )
5 plot (t , s )
6 t i t l e ( r ' $\ alpha_i > \ beta_i$ ' , f o n t s i z e =20)
7 text (1 , 0.6 , r ' $ \sum_{ i =0}^\ i n f t y x_i$ ' ,
f o n t s i z e =20)
8 text (0.6 , 0.6 , r ' $ \ c a l {A} \rm{ s i n } ( 2 \ omega t
)$ ' ,
9 f o n t s i z e =20)
10 x l a b e l ( ' time (s) ')
11 y l a b e l ( r ' $ V o l t a g e m ( \mu V) $ ' )
12 s a v e f i g ( ' m a t h t e x t . png ' , d p i =400)
13 show ( )
3.3 Exemplos Avanados

O MPL capaz produzir uma grande variedade grcos mais so-
sticados do que os apresentados at agora. Explorar todas as
possibilidades do MPL, foge ao escopo deste texto, mas diversos
exemplos de outros tipos de grcos sero apresentados junto com
os exemplos da segunda parte deste livro.
Mapas
O matplotlib pode ser extendido para plotar mapas. Para isso pre-
cisamos instalar o Basemap toolkit. Se voc j instalou o matplo-
Figura 3.5: Formatao de texto em guras. Gerada pela listagem

3.6
tlib, basta baixar o arquivo tar.gz do Basemap, descompactar para

um diretrio e executar o j conhecido python setup.py install.
O Basemap j vem com um mapa mundi includo para demons-
trao. Vamos utilizar este mapa em nosso exemplo (Listagem
3.7).
Listagem 3.7: Plotando o globo terrestre

mapa . py
2 from m a t p l o t l i b . t o o l k i t s . basemap import
Basemap
3.3. EXEMPLOS AVANADOS 71
3 import pylab as p
4
5 map = Basemap ( p r o j e c t i o n= ' r o b i n ' , l a t _ 0 = 23,
lon_0 = 46,
6 r e s o l u t i o n= ' l ' , a r e a _ t h r e s h
=1000.)
7 map . d r a w c o a s t l i n e s ( )
8 map . d r a w c o u n t r i e s ( )
9 map . f i l l c o n t i n e n t s ( c o l o r= ' c o r a l ' )
10 map . drawmapboundary ( )
11 map . d r a w m e r i d i a n s ( p . a r a n g e ( 0 , 3 6 0 , 3 0 ) )
12 map . d r a w p a r a l l e l s ( p . a r a n g e ( 9 0 , 9 0 , 3 0 ) )
13 p . show ( )
Na listagem 3.6, criamos um objeto map, que uma instncia,

da classe Basemap (linha 4). A classe Basemap possui diversos atri-
butos, mas neste exemplo estamos denindo apenas alguns como
a projeo (Robinson), coordenadas do centro do mapa, lat_0 e
lon_0, resoluo dos contornos, ajustada para baixa, e tamanho
mnimo de detalhes a serem desenhados, area_thresh, denido
como 1000km2 .
Figura 3.6: Mapa mundi na projeo de Robinson.

Captulo 4
Ferramentas de
Desenvolvimento
Exposio de ferramentas voltadas para o aumento da
produtividade em um ambiente de trabalho em compu-
tao cientca. Pr-requisitos: Captulos 1 e 2
C omo em todo ambiente de trabalho, para aumentar a nossa

produtividade em Computao Cientca, existem vrias fer-
ramentas alm da linguagem de programao. Neste captulo fala-
remos das ferramentas mais importantes, na opinio do autor.
4.1 Ipython
A utilizao interativa do Python de extrema valia. Outros am-
bientes voltados para computao cientca, tais como Matlab
TM ,
R, Mathematica
TM dentre outros, usam o modo interativo como seu
principal modo de operao. Os que desejam fazer o mesmo com o
Python, podem se beneciar imensamente do Ipython.
O Ipython uma verso muito sosticada da shell do Python
voltada para tornar mais eciente a utilizao interativa da lingua-
gem Python.
73
74 CAPTULO 4. FERRAMENTAS DE DESENVOLVIMENTO
Primeiros Passos
Para iniciar o Ipython, digitamos o seguinte comando:
1 $ ipython [ opes ] arquivos
Muita das opes que controlam o funcionamento do Ipython no

so passadas na linha de comando, esto especicadas no arquivo
ipythonrc dentro do diretrio /.ipython.
Quatro opes do Ipython so consideradas especiais e devem
aparecer em primeiro lugar, antes de qualquer outra opo: -gthread,
-qthread, -wthread, -pylab. As trs primeiras opes so vol-
tadas para o uso interativo de mdulos na construo de GUIs
(interfaces grcas), respectivamente GTK, Qt, WxPython. Estas
opes iniciam o Ipython em um thread separado, de forma a per-
mitir o controle interativo de elementos grcos. A opo -pylab
permite o uso interativo do pacote matplotlib (Ver captulo 3).
Esta opo executar from pylab import ao iniciar, e permite
que grcos sejam exibidos sem necessidade de invocar o comando
show(), mas executar scripts que contm show() ao nal, corre-
tamente.
Aps uma das quatro opes acima terem sido especicadas,

as opes regulares podem seguir em qualquer ordem. Todas as
opes podem ser abreviadas forma mais curta no-ambgua,
mas devem respeitar maisculas e minsculas (como nas lingua-
gens Python e Bash, por sinal). Um ou dois hfens podem ser
utilizados na especicao de opes.
Todas as opes podem ser prexadas por no para serem des-
ligadas (no caso de serem ativas por default).
Devido ao grande nmero de opes existentes, no iremos list-

las aqui. consulte a documentao do Ipython para aprender sobre
elas. Entretanto, algumas opes podero aparecer ao longo desta
seo e sero explicadas medida em que surgirem.
4.1. IPYTHON 75
Comandos Mgicos
Uma das caractersticas mais teis do Ipython o conceito de co-

mandos mgicos. No console do Ipython, qualquer linha come-
ada pelo caractere %, considerada uma chamada a um comando
mgico. Por exemplo, %autoindent liga a indentao automtica
dentro do Ipython.
Existe uma opo que vem ativada por default no ipythonrc,
denomidada automagic. Com esta funo, os comandos mgi-
cos podem ser chamados sem o %, ou seja autoindent enten-
dido como %autoindent. Variveis denidas pelo usurio podem
mascarar comandos mgicos. Portanto, se eu denir uma vari-
vel autoindent = 1, a palavra autoindent no mais reconhecida
como um comando mgico e sim como o nome da varivel criada
por mim. Porm, ainda posso chamar o comando mgico colocando
o caractere % no incio.
O usurio pode extender o conjunto de comandos mgicos com
suas prprias criaes. Veja a documentao do Ipython sobre
como fazer isso.
O comando mgico %magic retorna um explicao dos coman-
dos mgicos existentes.
%Exit Sai do console Ipython.
%Pprint Liga/desliga formatao do texto.
%Quit Sai do Ipython sem pedir conrmao.
%alias Dene um sinnimo para um comando.
Voc pode usar %1 para representar a linha em que o comando

alias foi chamado, por exemplo:
1 In [2]: alias all echo " Entrada entre

parnteses : (% l ) "
2 In [3]: all Ola mundo
3 Entrada entre parnteses : ( Ola mundo )
%autocall Liga/desliga modo que permite chamar funes sem os
parnteses. Por exemplo: fun 1 vira fun(1).
%autoindent Liga/desliga auto-indentao.
%automagic Liga/desliga auto-mgica.
%bg Executa um comando em segundo plano, em um thread sepa-

rado. Por exemplo: %bg func(x,y,z=1). Assim que a exe-
cuo se inicia, uma mensagem impressa no console infor-
mando o nmero da tarefa. Assim, pode-se ter acesso ao re-
sultado da tarefa nmero 5 por meio do comando jobs.results[5]
O Ipython possui um gerenciador de tarefas acessvel atravs

do objeto jobs. Para maiores informaes sobre este objeto di-
gite jobs?. O Ipython permite completar automaticamente um
comando digitado parcialmente. Para ver todos os mtodos do
objeto jobs experimente digitar jobs.seguido da tecla <TAB>.
%bookmark Gerencia o sistema de marcadores do Ipython. Para

saber mais sobre marcadores digite %bookmark?.
%cd Muda de diretrio.
%colors Troca o esquema de cores.
%cpaste Cola e executa um bloco pr-formatado da rea de trans-

ferncia (clipboard). O bloco tem que ser terminado por uma
linha contendo .
%dhist Imprime o histrico de diretrios.
%ed Sinnimo para %edit
%edit Abre um editor e executa o cdigo editado ao sair. Este

comando aceita diversas opes, veja a documentao.
4.1. IPYTHON 77
O editor a ser aberto pelo comando %edit o que estiver de-

nido na varivel de ambiente $EDITOR. Se esta varivel no estiver
denida, o Ipython abrir o vi. Se no for especicado o nome de
um arquivo, o Ipython abrir um arquivo temporrio para a edio.
O comando %edit apresenta algumas convenincias. Por exem-
plo: se denirmos uma funco fun em uma sesso de edio ao sair
e executar o cdigo, esta funo permanecer denida no espao
de nomes corrente. Ento podemos digitar apenas %edit fun e
o Ipython abrir o arquivo que a contm, posicionando o cursor,
automaticamente, na linha que a dene. Ao sair desta sesso de
edio, a funo editada ser atualizada.
1 In [ 6 ] : % ed
2 IPython will make a temporary file named : /
tmp/ ipython_edit_GuUWr_ . py
3 done . Executing edited code . . .
4 Out [ 6 ] : " d e f fun ( ) : \ n print ' fun '\ n \
ndef funa ( ) : \ n print ' f u n a ' \ n"
5
6 In [ 7 ] : fun ( )
7 fun
8
9 In [ 8 ] : funa ( )
10 funa
11
12 In [ 9 ] : % ed fun
13 done . Executing edited code . . .
%hist Sinnimo para %history.
%history Imprime o histrico de comandos. Comandos anteriores

tambm podem ser acessados atravs da varivel _i<n>, que
o n-simo comando do histrico.
1 In [1]:% hist
2 1: _ip . m a g i c ( "%h i s t ")
3
4 In [2]:% hist
5 1: _ip . m a g i c ( "%h i s t ")
6 2: _ip . m a g i c ( "%h i s t ")
O Ipython possui um sosticado sistema de registro das ses-

ses. Este sistema controlado pelos seguintes comandos mgicos:
%logon, %logoff, %logstart e %logstate. Para maiores infor-
maes consulte a documentao.
%lsmagic Lista os comandos mgicos disponveis.
%macro Dene um conjunto de linhas de comando como uma macro

para uso posterior: %macro teste 1 2 ou %macro macro2
44-47 49.
%p Sinnimo para print.
%pdb liga/desliga depurador interativo.
%pdef Imprime o cabealho de qualquer objeto chamvel. Se o

objeto for uma classe, retorna informao sobre o construtor
da classe.
%pdoc Imprime a docstring de um objeto.
%pfile Imprime o arquivo onde o objeto encontra-se denido.
%psearch Busca por objetos em espaos de nomes.
%psource Imprime o cdigo fonte de um objeto. O objeto tem que

ter sido importado a partir de um arquivo.
%quickref Mostra um guia de referncia rpida
%quit Sai do Ipython.

4.1. IPYTHON 79
%r Repete o comando anterior.
%rehash Atualiza a tabela de sinnimos com todas as entradas em

$PATH. Este comando no verica permisses de execuo e
se as entradas so mesmo arquivos. %rehashx faz isso, mas
mais lento.
%rehashdir Adiciona os executveis dos diretrios especicados

tabela de sinnimos.
%rehashx Atualiza a tabela de sinnimos com todos os arquivos

executveis em $PATH.
%reset Re-inicializa o espao de nomes removendo todos os nomes
denidos pelo usurio.
%run Executa o arquivo especicado dentro do Ipython como um

programa.
%runlog Executa arquivos como logs.
%save Salva um conjunto de linhas em um arquivo.
%sx Executa um comando no console do Linux e captura sua sada.
%store Armazena variveis para que estejam disponveis em uma

sesso futura.
%time Cronometra a execuo de um comando ou expresso.
%timeit Cronometra a execuo de um comando ou expresso uti-

lizando o mdulo timeit.
%unalias Remove um sinnimo.
%upgrade Atualiza a instalao do Ipython.
%who Imprime todas as variveis interativas com um mnimo de

formatao.
%who_ls Retorna uma lista de todas as variveis interativas.
%whos Similar ao %who, com mais informao sobre cada varivel.
Para nalizar, o Ipython um excelente ambiente de traba-

lho interativo para computao cientca, especialmente quando
invocado coma opo -pylab. O modo pylab alm de grcos,
tambm oferece uma srie de comandos de compatibilidade com o
MATLAB
TM (veja captulo 3). O pacote principal do numpy tam-
bm ca exposto no modo pylab. Subpacotes do numpy precisam
ser importados manualmente.
4.2 Editores de Cdigo

Na edio de programas em Python, um bom editor de cdigo pode
fazer uma grande diferena em produtividade. Devido a signicn-
cia dos espaos em branco para a linguagem, um editor que mantm
a indentao do cdigo consistente, muito importante para evitar
bugs. Tambm desejvel que o editor conhea as regras de in-
dentao do Python, por exemplo: indentar aps :, indentar com
espaos ao invs de tabulaes. Outra caracterstica desejvel a
colorizao do cdigo de forma a ressaltar a sintaxe da linguagem.
Esta caracterstica aumenta, em muito, a legibilidade do cdigo.
Os editores que podem ser utilizados com sucesso para a edio
de programas em Python, se dividem em duas categorias bsicas:
editores genricos e editores especializados na linguagem Python.
Nesta seo, vamos examinar as principais caractersticas de alguns
editores de cada categoria.
Editores Genricos
Existe um sem-nmero de editores de texto disponveis para o Am-

biente Gnu/Linux. A grande maioria deles cumpre nossos requisi-
tos bsicos de indentao automtica e colorizao. Selecionei al-
4.2. EDITORES DE CDIGO 81
guns que se destacam na minha preferncia, quanto a usabilidade

e versatilidade.
Emacs: Editor incrivelmente completo e verstil, funciona como

ambiente integrado de desenvolvimento (gura 4.1). Precisa
ter python-modeinstalado. Para quem no tem experincia
prvia com o Emacs, recomendo que o pacote Easymacs1 seja
tambm instalado. este pacote facilita muito a interface do
Emacs, principalmente para adio de atalhos de teclado pa-
dro CUA. Pode-se ainda utilizar o Ipython dentro do Emacs.
Scite: Editor leve e eciente, suporta bem o Python (executa o

script com <F5>) assim como diversas outras linguagens.
Permite congurar comando de compilao de C e Fortran, o
que facilita o desenvolvimento de extenses. Completamente
congurvel (gura 4.2).
Gnu Nano: Levssimo editor para ambientes de console, possui

suporte a auto indentao e colorizao em diversas lingua-
gens, incluindo o Python (gura 4.3). Ideal para utilizar em
conjuno com o Ipython (comando %edit).
Jedit: Inclu o Jedit nesta lista, pois oferece suporte ao desenvol-

vimento em Jython (ver Seo 5.5). Afora isso, um edi-
tor bastante poderoso para java e no to pesado quanto o
Eclipse (gura 4.4).
Kate/Gedit Editores padro do KDE e Gnome respectivamente.

Bons para uso casual, o Kate tem a vantagem de um console
embutido.
1 http://www.dur.ac.uk/p.j.heslin/Software/Emacs/Easymacs/
Figura 4.1: Editor emacs em modo Python e com Code Browser

ativado
Figura 4.2: Editor Scite.
Editores Especializados
Editores especializados em Python tendem a ser mais do tipo IDE

(ambiente integrado de desenvolvimento), oferecendo funcionalida-
des que s fazem sentido para gerenciar projetos de mdio a grande
porte, sendo demais para se editar um simples Script.
Boa-Constructor: O Boa-constructor um IDE, voltado para o

projetos que pretendam utilizar o WxPython como interface
Figura 4.3: Editor Gnu Nano.
grca. Neste aspecto ele muito bom, permitindo cons-

truo visual da interface, gerando todo o cdigo associado
com a interface. Tambm traz um excelente depurador para
programas em Python e d suporte a mdulos de extenso
escritos em outras linguagens, como Pyrex ou C(gura 4.5).
Eric: O Eric tambm um IDE desenvolvido em Python com a

interface em PyQt. Possui boa integrao com o gerador de
interfaces Qt Designer, tornando muito fcil o desenvolvi-
mento de interfaces grcas com esta ferramenta. Tambm
dispe de timo depurador. Alm disso o Eric oferece muitas
outras funes, tais como integrao com sistemas de controle
Figura 4.4: Editor Jython Jedit
de verso, geradores de documentao, etc.(Figura 4.6).
Pydev (Eclipse): O Pydev, um IDE para Python e Jython

desenvolvido como um plugin para Eclipse. Para quem j
tem experincia com a plataforma Eclipse, pode ser uma boa
alternativa, caso contrrio, pode ser bem mais complicado
de operar do que as alternativas mencionadas acima (Figura
4.7). Em termos de funcionalidade, equipara-se ao Eric e ao
Boa-constructor.
Figura 4.5: IDE Boa-Constructor
4.3 Controle de Verses em Software

Ao se desenvolver software, em qualquer escala, experimentamos
um processo de aperfeioamento progressivo no qual o software
passa por vrias verses. Neste processo muito comum, a um
certo estgio, recuperar alguma funcionalidade que estava presente
em uma verso anterior, e que, por alguma razo, foi eliminada do
cdigo.
Outro desao do desenvolvimento de produtos cientcos (soft-

ware ou outros) o trabalho em equipe em torno do mesmo ob-
jeto (frequentemente um programa). Normalmente cada membro
da equipe trabalha individualmente e apresenta os seus resultados
4.3. CONTROLE DE VERSES EM SOFTWARE 87
Figura 4.6: IDE Eric.
para a equipe em reunies regulares. O que fazer quando modica-

es desenvolvidas por diferentes membros de uma mesma equipe
se tornam incompatveis? Ou mesmo, quando dois ou mais colabo-
radores esto trabalhando em partes diferentes de um programa,
mas que precisam uma da outra para funcionar?
O tipo de ferramenta que vamos introduzir nesta seo, busca

resolver ou minimizar os problemas supracitados e pode ser apli-
cado tambm ao desenvolvimento colaborativo de outros tipos de
documentos, no somente programas.
Como este um livro baseado na linguagem Python, vamos uti-

lizar um sistema de controle de verses desenvolvido inteiramente
Figura 4.7: IDE Pydev
em Python: Mercurial2 . Na prtica o mecanismo por trs de

todos os sistemas de controle de verso muito similar. Migrar
de um para outro uma questo de aprender novos nomes para
as mesmas operaes. Alm do mais, o uso dirio de sistema de
controle de verses envolve apenas dois ou trs comandos.
Entendendo o Mercurial
O Mercurial um sistema de controle de verses descentralizado,

ou seja, no h nenhuma noo de um servidor central onde ca
2 http://www.selenic.com/mercurial
Figura 4.8: Diagrama de um repositrio do Mercurial.
depositado o cdigo. Repositrios de cdigos so diretrios que

podem ser clonados de uma mquina para outra.
Ento, em que consiste um repositrio? A gura 4.8 uma
representao diagramtica de um repositrio. Para simplicar
nossa explanao, consideremos que o repositrio j foi criado ou
clonado de algum que o criou. Veremos como criar um repositrio
a partir do zero, mais adiante.
De acordo com a gura 4.8, um repositrio composto por
um Arquivo
3 e por um diretrio de trabalho. O Arquivo contm
a histria completa do projeto. O diretrio de trabalho contm
uma cpia dos arquivos do projeto em um determinado ponto no
tempo (por exemplo, na reviso 2). no diretrio de trabalho que
o pesquisador trabalha e atualiza os arquivos.
3 Doravante grafado com A maisculo para diferenciar de arquivos co-

muns(les).
Figura 4.9: Operao de commit.
Ao nal de cada ciclo de trabalho, o pesquisador envia suas

modicaes para o arquivo numa operao denominada com-
mit(gura 4.9) .
4
Aps um commit, como as fontes do diretrio de trabalho no

correspondiam ltima reviso do projeto, o Mercurial automati-
camente cria uma ramicao no arquivo. Com isso passamos a ter
duas linhas de desenvolvimento seguindo em paralelo, com o nosso
diretrio de trabalho pertencendo ao ramo iniciado pela reviso 4.
O Mercurial agrupa as mudanas enviadas por um usurio
(via commit), em um conjunto de mudanas atmico, que constitui
4 Vou adotar o uso da palavra commit para me referir a esta operao daqui
em diante. Optei por no tentar uma traduo pois este termo um jargo
dos sistemas de controle de verso.
Figura 4.10: Repositrio da Ana.
uma reviso. Estas revises recebem uma numerao sequencial

(gura 4.9). Mas como o Mercurial permite desenvolvimento de
um mesmo projeto em paralelo, os nmeros de reviso para di-
ferentes desenvolvedores poderiam diferir. Por isso cada reviso
tambm recebe um identicador global, consistindo de um nmero
hexadecimal de quarenta dgitos.
Alm de ramicaes, fuses (merge) entre ramos podem ocor-
rer a qualquer momento. Sempre que houver mais de um ramo
em desenvolvimento, oMercurial denominar as revises mais re-
centes de cada ramo(heads, cabeas). Dentre estas, a que tiver
maior nmero de reviso ser considerada a ponta (tip) do repo-
sitrio.
Exemplo de uso:
Nestes exemplos, exploraremos as operaes mais comuns num am-
biente de desenvolvimento em colaborao utilizando o Mercurial.
Vamos comear com nossa primeira desenvolvedora, chamada
Ana. Ana possui um arquivo como mostrado na gura 4.10.
Nosso segundo desenvolvedor, Bruno, acabou de se juntar ao
time e clona o repositrio Ana .
5
1 $ hg clone s s h : / / maquinadana / p r o j e t o
meuprojeto
2 requesting all changes
5 Assumimos aqui que a mquina da ana est executando um servidor ssh

Figura 4.11: Modicaes de Bruno.
Figura 4.12: Modicaes de Ana.
3 adding changesets
4 adding manifests
5 adding file changes
6 added 4 changesets with 4 changes to 2 files
URLs vlidas:
le://
http://
https://
ssh://
static-http://
Aps o comando acima, Bruno receber uma cpia completa

do arquivo de Ana, mas seu diretrio de trabalho, meu projeto,
permanecer independente. Bruno est ansioso para comear a
trabalhar e logo faz dois commits (gura 4.11).
Enquanto isso, em paralelo, Ana tambm faz suas modicaes
(gura 4.12).
Bruno ento decide puxar o repositrio de Ana para sincroniz-
lo com o seu.
1 $ hg pull
Figura 4.13: Repositrio atualizado de Bruno.
2 pulling from s s h : / / maquinadaana / p r o j e t o

3 searching for changes
4 adding changesets
5 adding manifests
6 adding file changes
7 added 1 changesets with 1 changes to 1 files
8 ( run ' hg heads ' to see heads , ' hg merge ' to
merge )
O comando hg pull, se no especicada a fonte, ir puxar

da fonte de onde o repositrio local foi clonado. Este comando
atualizar o Arquivo local, mas no o diretrio de trabalho.
Aps esta operao o repositrio de Bruno ca como mostrado
na gura 4.13. Como as mudanas feitas por Ana, foram as ltimas
adicionadas ao repositrio de Bruno, esta reviso passa a ser a
ponta do Arquivo.
Bruno agora deseja fundir seu ramo de desenvolvimento, com
a ponta do seu Arquivo que corresponde s modicaes feitas
por Ana. Normalmente, aps puxar modicaes, executamos hg
update para sincronizar nosso diretrio de trabalho com o Arquivo
recm atualizado. Ento Bruno faz isso.
1 $ hg update
2 this update spans a branch affecting the
following files :
3 h e l l o . py ( resolve )
Figura 4.14: Repositrio de Bruno aps a fuso.
4 aborting update spanning branches !

5 ( use ' hg merge ' to merge across branches or
' hg update C ' to lose changes )
Devido ramicao no Arquivo de Bruno, o comando update

no sabe a que ramo fundir as modicaes existentes no diretrio
de trabalho de Bruno. Para resolver isto, Bruno precisar fundir
os dois ramos. Felizmente esta uma tarefa trivial.
1 $ hg merge tip
2 merging h e l l o . py
No comando merge, se nenhuma reviso especicada, o dire-

trio de trabalho cabea de um ramo e existe apenas uma outra
cabea, as duas cabeas sero fundidas. Caso contrrio uma reviso
deve ser especicada.
Pronto! agora o repositrio de Bruno cou como a gura 4.14.
Agora, se Ana puxar de Bruno, receber todas as mocaes de

Bruno e seus repositrios estaro plenamente sincronizados, como
a gura 4.14.
Criando um Repositrio
Para criar um repositrio do zero, preciso apenas um comando:
1 $ hg init
Quando o diretrio criado, um diretrio chamado .hg criado

dentro do diretrio de trabalho. O Mercurial ir armazenar todas
as informaes sobre o repositrio no diretrio .hg. O contedo
deste diretrio no deve ser alterado pelo usurio.
Para saber mais

Naturalmente, muitas outras coisas podem ser feitas com um sis-
tema de controle de verses. O leitor encorajado a consultar a
documentao do Mercurial para descobr-las. Para servir de re-
ferncia rpida, use o comando hg help -v <comando> com qual-
quer comando da lista abaixo.
add Adiciona o(s) arquivo(s) especicado(s) no prximo commit.
addremove Adiciona todos os arquivos novos, removendo os faltan-

tes.
annotate Mostra informao sobre modicaes por linha de ar-

quivo.
archive Cria um arquivo (compactado) no versionado, de uma

reviso especicada.
backout Reverte os efeitos de uma modicao anterior.
branch Altera ou mostra o nome do ramo atual.
branches Lista todas os ramos do repositrio.
bundle Cria um arquivo compactado contendo todas as modica-

es no presentes em um outro repositrio.
cat Retorna o arquivo especicado, na forma em que ele era em

dada reviso.
clone Replica um repositrio.

commit Arquiva todas as modicaes ou os arquivos especicados.
copy Copia os arquivos especicados, para outro diretrio no pr-

ximo commit.
diff Mostra diferenas entre revises ou entre os arquivos especi-
cados.
export Imprime o cabealho e as diferenas para um ou mais con-

juntos de modicaes.
grep Busca por palavras em arquivos e revises especcas.
heads Mostra cabeas atuais.
help Mostra ajuda para um comando, extenso ou lista de coman-

dos.
identify Imprime informaes sobre a cpia de trabalho atual.
import Importa um conjunto ordenado de atualizaes (patches).

Este comando a contrapartida de Export.
incoming Mostra novos conjuntos de modicaes existentes em

um dado repositrio.
init Cria um novo repositrio no diretrio especicado. Se o di-

retrio no existir, ele ser criado.
locate Localiza arquivos.
log Mostra histrico de revises para o repositrio como um todo

ou para alguns arquivos.
manifest Retorna o manifesto (lista de arquivos controlados) da

reviso atual ou outra.
merge Funde o diretrio de trabalho com outra reviso.

outgoing Mostra conjunto de modicaes no presentes no repo-

sitrio de destino.
parents Mostra os pais do diretrio de trabalho ou reviso.
paths Mostra denio de nomes simblicos de caminho.
pull Puxa atualizaes da fonte especicada.
push Envia modicaes para o repositrio destino especicado.

a contra-partida de pull.
recover Desfaz uma transao interrompida.
remove Remove os arquivos especicados no prximo commit.
rename Renomeia arquivos; Equivalente a copy + remove.

revert Reverte arquivos ao estado em que estavam em uma dada
reviso.
rollback Desfaz a ltima transao neste repositrio.
root Imprime a raiz do diretrio de trabalho corrente.
serve Exporta o diretrio via HTTP.
showconfig Mostra a congurao combinada de todos os arqui-

vos hgrc.
status Mostra arquivos modicados no diretrio de trabalho.
tag Adiciona um marcador para a reviso corrente ou outra.
tags Lista marcadores do repositrio.
tip Mostra a reviso ponta.
unbundle Aplica um arquivo de modicaes.

update Atualiza ou funde o diretrio de trabalho.
verify Verica a integridade do repositrio.
version Retorna verso e informao de copyright.

Captulo 5
Interagindo com Outras

Linguagens
Introduo a vrios mtodos de integrao do Python
com outras linguagens. Pr-requisitos: Captulos 1 e
2.
5.1 Introduo
O Python uma linguagem extremamente poderosa e verstil, per-
feitamente apta a ser, no somente a primeira, como a ltima lin-
guagem de programao que um cientista precisar aprender. En-
tretanto, existem vrias situaes nas quais torna-se interessante
combinar o seu cdigo escrito em Python com cdigos escritos em
outras linguagens. Uma das situaes mais comuns, a necessi-
dade de obter maior performance em certos algoritmos atravs da
re-implementao em uma linguagem compilada. Outra Situao
comum possibilidade de se utilizar de bibliotecas desenvolvidas
em outras linguagens e assim evitar ter que reimplement-las em
Python.
O Python uma linguagem que se presta. extremamente bem.
a estas tarefas existindo diversos mtodos para se alcanar os obje-
99
CAPTULO 5. INTERAGINDO COM OUTRAS
100 LINGUAGENS
tivos descritos no pargrafo acima. Neste captulo, vamos explorar
apenas os mais prticos e ecientes, do ponto de vista do tempo de
implementao.
5.2 Integrao com a Linguagem C

A linguagem C uma das linguagens mais utilizadas no desenvol-
vimento de softwares que requerem alta performance. Um bom
exemplo o Linux (kernel) e a prpria linguagem Python. Este
fato torna o C um candidato natural para melhorar a performance
de programas em Python.
Vrios pacotes cientcos para Python como o Numpy e Scipy,
por exemplo, tem uma grande poro do seu cdigo escrito em
C para mxima performance. Coincidentemente, o primeiro m-
todo que vamos explorar para incorporar cdigo C em programas
Python, oferecido como parte do pacote Scipy.
Weave
O weave um mdulo do pacote scipy, que permite inserir trechos

de cdigo escrito em C ou C++ dentro de programas em Python.
Existem vrias formas de se utilizar o weave dependendo do tipo
de aplicao que se tem. Nesta seo, vamos explorar apenas a
aplicao do mdulo inline do weave, por ser mais simples e co-
brir uma ampla gama de aplicaes. Alm disso, utilizaes mais
avanadas do weave, exigem um conhecimento mais profundo da
linguagem C, o que est fora do escopo deste livro. Caso os exem-
plos includos no satisfaam os anseios do leitor, existe uma farta
documentao no site www.scipy.org.
Vamos comear a explorar o weave com um exemplo trivial
(computacionalmente) um simples loop com uma nica operao
(exemplo 5.1).
5.2. INTEGRAO COM A LINGUAGEM C 101
Listagem 5.1: Otimizao de loops com o weave
1 # e n c o d i n g : l a t i n 1
w e a v e l o o p . py
3 from s c i p y . weave import inline , converters
4 import t i m e
5 from p y l a b import
6
7 c o d e=" " "
8 int i =0;
9 while ( i < n)
10 {
11 i ^3;
12 i ++;
13 }"""
14 def loopp (n) :
15 i =0
16 while i < n:
17 i 3
18 i +=1
19
20 def loopc (n) :
21 return i n l i n e ( code , [ ' n ' ] ,
t y p e _ c o n v e r t e r s=c o n v e r t e r s . b l i t z
, c o m p i l e r= ' g c c ' )
22
23 def b e n c h ( max ) :
24 ptim = []
25 ctim = []
26 for n in x r a n g e ( 1 0 0 , max , 1 0 0 ) :
27 t = time . time ( )
28 loopp (n)
29 t 1=t i m e . t i m e ( ) t
102 LINGUAGENS
30 p t i m . append ( t 1 )
32 loopc (n)
33 t 1=t i m e . t i m e ( ) t
34 c t i m . append ( t 1 )
35 return ptim , c t i m , max
36
37 ptim , c t i m , max = b e n c h ( 1 0 0 0 0 )
38 s e m i l o g y ( x r a n g e ( 1 0 0 , max , 1 0 0 ) , ptim , ' bo ' ,
x r a n g e ( 1 0 0 , max , 1 0 0 ) , c t i m , ' go ' )
39 y l a b e l ( ' tempo em s e g u n d o s ' ) ; x l a b e l ( u ' Nmero
de operaes ' ) ; grid ()
40 l e g e n d ( [ ' Python ' , 'C ' ] )
41 s a v e f i g ( ' w e a v e l o o p . png ' , d p i =400)
42 show ( )
No exemplo 5.1 podemos ver como funciona o weave. Uma

string contm o cdigo C a ser compilado. A funo inline com-
pila o cdigo em questo, passando para o mesmo as variveis ne-
cessrias.
Note que, na primeira execuo do loop, o weave mais lento
que o Python, devido compilao do cdigo; mas em seguida,
com a rotina j compilada e carregada na memria, este atraso no
existe mais.
O weave.inline tem uma performance inferior de um pro-
grama em C equivalente, executado fora do Python. Mas a sua
simplicidade de utilizao, compensa sempre que se puder obter
um ganho de performance sobre o Python puro.
Listagem 5.2: Calculando iterativamente a srie de Fibonacci em

Python e em C(weave.inline)
w e a v e f i b . py
2 from scipy import weave
Figura 5.1: Comparao da performance entre o Python e o C

(weave) para um loop simples. O eixo y est em escala logaritmica
para facilitar a visualizao das curvas.
3 from s c i p y . weave import converters

4 import t i m e
5 from s c i p y . s t a t s import bayes_mvs
7
8 c o d e=\
9 """
10 while (b < n)
11 {
12 int savea = a ;
104 LINGUAGENS
13 a=b ;
14 b=s a v e a+b ;
15 }
16 return_val = a ;
17 """
18 def fibp (n) :
19 """
20 Calcula srie de Fibonacci em Python
21 """
22 a , b = 0 ,1
23 while b < n:
24 a , b = b , a+b
25 return a
26
27 def fibw (n) :
28 """
29 Verso weave . i n l i n e
30 """
31 a = 0
32 b = 1
33 return weave . i n l i n e ( c o d e , [ ' n ' , ' a ' , ' b
' ] ,
34 t y p e _ c o n v e r t e r s=c o n v e r t e r s . b l i t z ,
c o m p i l e r= ' g c c ' )
35 ptim = [ ] ; c t i m = [ ]
36 for i in range (100) :
38 pn = f i b p ( 1 0 0 0 0 0 0 0 0 0 )
39 p t = t i m e . t i m e ( ) t ; p t i m . append ( p t )
40 f i b w ( 1 0 )#t o compile before timing
42 cn = f i b w ( 1 0 0 0 0 0 0 0 0 0 )
43 c t = t i m e . t i m e ( ) t ; c t i m . append ( c t )
44 print ' Tempo mdio no p y t h o n : %g s e g u n d o s '%
pt
45 print ' Tempo mdio no weave : %g s e g u n d o s '%
ct
46 S t a t s = bayes_mvs ( a r r a y ( p t i m ) / a r r a y ( c t i m ) )
47 print " Acelerao mdia : %g + %g "% ( S t a t s
[0][0] ,
48 Stats [ 2 ] [ 0 ] )
No exemplo 5.2, o ganho de performance do weave.inline j

no to acentuado.
Listagem 5.3: Executando o cdigo do exemplo 5.2.
1 $ python w e a v e f i b . py
2 Tempo mdio no p y t h o n : 1 . 6 9 2 7 7 e 05 segundos
3 Tempo mdio no weave : 1 . 3 1 1 3 e 05 segundos
4 Acelerao mdia : 1 . 4 9 5 5 4 + 0 . 7 6 4 2 7 5
Ctypes
O pacote ctypes, parte integrante do Python a partir da verso

2.5, um mdulo que nos permite invocar funes de bibliotecas
em C pr-compiladas, como se fossem funes em Python. Apesar
da aparente facilidade de uso, ainda necessrio ter conscincia do
tipo de dados a funo, que se deseja utilizar, requer. Por conse-
guinte, necessrio que o usuario tenha um bom conhecimento da
linguagem C.
Apenas alguns objetos do python podem ser passados para
funes atravs do ctypes: None, inteiros, inteiros longos,
strings, e strings unicode. Outros tipos de dados devem ser
convertidos, utilizando tipos fornecidos pelo ctypes, compatveis
com C.
Dado seu estgio atual de desenvolvimento, o ctypes no
a ferramenta mais indicada ao cientista que deseja fazer uso das
106 LINGUAGENS
convenincias do C em seus programas Python. Portanto, vamos
apenas dar dois exemplos bsicos para que o leitor tenha uma ideia
de como funciona o ctypes. Para maiores informaes recomen-
damos o tutorial do ctypes (http://python.net/crew/theller/
ctypes/tutorial.html)
Nos exemplos abaixo assumimos que o leitor est utilizando
Linux pois o uso do ctypes no Windows no idntico.
Listagem 5.4: Carregando bibliotecas em C

1 >>> from ctypes import
2 >>> l i b c = c d l l . L o a d L i b r a r y ( " l i b c . s o . 6 " )
3 >>> l i b c
4 <CDLL ' l i b c . so . 6 ' , handle ... at ... >
Uma vez importada uma biblioteca (listagem 5.4), podemos

chamar funes como atributos das mesmas.
Listagem 5.5: Chamando fues em bibliotecas importadas com o

ctypes
1 >>> l i b c . p r i n t f
2 <_FuncPtr object at 0x . . . >
3 >>> print l i b c . t i m e ( None )
4 1150640792
5 >>> p r i n t f = l i b c . p r i n t f
6 >>> p r i n t f ( " Ola , %s \ n " , "Mundo ! " )
7 Ola , Mundo !
Pyrex
O Pyrex uma linguagem muito similar ao Python feita para gerar

mdulos em C para o Python. Desta forma, envolve um pouco
mais de trabalho por parte do usurio, mas de grande valor para
acelerar cdigo escrito em Python com pouqussimas modicaes.
O Pyrex no inclui todas as possibilidades da linguagem Python.

As principais modicaes so as que se seguem:
No permitido denir funes dentro de outras funes;
denies de classe devem ocorrer apenas no espao de no-

mes global do mdulo, nunca dentro de funes ou de outras
classes;
No permitido import *. As outras formas de import so

permitidas;
Geradores no podem ser denidos em Pyrex;
As funes globals() e locals() no podem ser utilizadas.

Alm das limitaes acima, existe um outro conjunto de limita-
es que considerado temporrio pelos desenvolvedores do Pyrex.
So as seguintes:
Denies de classes e funes no podem ocorrer dentro de

estruturas de controle (if, elif, etc.);
Operadores in situ (+=, *=, etc.) no so suportados pelo

Pyrex;
List comprehensions no so suportadas;
No h suporte a Unicode.
Para exemplicar o uso do Pyrex, vamos implementar uma fun-

o geradora de nmeros primos em Pyrex (listagem 5.6).
Listagem 5.6: Calculando nmeros primos em Pyrex
1 # Calcula numeros primos

2 def primes ( i n t kmax ) :
3 cdef int n, k, i
4 cdef int p[1000]
108 LINGUAGENS
5 result = []
6 if kmax > 1 0 0 0 :
7 kmax = 1 0 0 0
8 k = 0
9 n = 2
10 while k < kmax :
11 i = 0
12 while i < k and n % p [ i ] <> 0:
13 i = i + 1
14 if i == k :
15 p[k] = n
16 k = k + 1
17 r e s u l t . append ( n )
18 n = n + 1
19 return result
Vamos analisar o cdigo Pyrex, nas linhas onde ele difere do que
seria escrito em Python. Na linha 2 encontramos a primeira pe-
culiaridade: o argumento de entrada kmax denido como inteiro
por meio da expresso int kmax. Em Pyrex, devemos declarar os
tipos das variveis. Nas linhas 3 e 4 tambm ocorre a declarao
dos tipos das variveis que sero utilizadas na funo. Note como
denida uma lista de inteiros. Se uma varivel no declarada,
o Pyrex assume que ela um objeto Python.
Quanto mais variveis conseguirmos declarar como tipos bsicos
de C, mais eciente ser o cdigo C gerado pelo Pyrex. A varivel
result(linha 5) no declarada como uma lista de inteiros, pois
no sabemos ainda qual ser seu tamanho. O restante do cdigo
equivalente ao Python. Devemos apenas notar a preferncia do
lao while for i in range(x). Este
ao invs de um lao do tipo
ultimo seria mais lento devido a incluir a funo range do Python.
O prximo passo gerar a verso em C da listagem 5.6, compilar
e link-lo, transformando-o em um mdulo Python.
Listagem 5.7: Gerando Compilando e linkando
1 $ pyrexc p r i m e s . pyx
2 $ gcc c fPIC I / u s r / i n c l u d e / p y t h o n 2 . 4 /
primes . c
3 $ gcc s h a r e d primes . o o primes . so
Agora vamos comparar a performance da nossa funo com

uma funo em Python razovelmente bem implementada (Lista-
gem 5.8). Anal temos que dar uma chance ao Python, no?
Listagem 5.8: Calculando nmeros primos em Python

p r i m e s 2 . py
2 def p r i m e s (N) :
3 if N <= 3 :
4 return r a n g e ( 2 ,N)
5 #t e s t a apenas os numeros impares
6 primos = [2] + r a n g e ( 3 , N, 2 )
7 index = 1
8 #c o n v e r t e n d o em inteiro
9 #p a r a acelerar comparacao abaixo
10 t o p = i n t (N 0.5)
11 while 1:
12 i = primos [ index ]
13 if i >t o p :
14 break
15 i n d e x += 1
16 primos = [x for x in primos if (x %
i ) or ( x == i ) ]
17 return primos
18 primes (100000)
Comparemos agora a performance das duas funes para en-

contrar todos os nmeros primos menores que 100000. Para esta
110 LINGUAGENS
comparao utilizaremos o ipython que nos facilita esta tarefa atra-
vs da funo mgica %timeit.
Listagem 5.9: Comparando performances dentro do ipython
1 In [1]: from primes import p r i m e s

2 In [2]: from primes2 import p r i m e s as primesp
3 In [3]:\% timeit primes (100000)
4 10 loops , best of 3: 19.6 ms per loop
5 In [4]:\% timeit primesp (100000)
6 10 loops , best of 3: 5 1 2 ms per loop
Uma das desvantagens do Pyrex a necessidade de compilar e

linkar os programas antes de poder utiliz-los. Este problema se
acentua se seu programa Python utiliza extenses em Pyrex e pre-
cisa ser distribuido a outros usurios. Felizmente, existe um meio
de automatizar a compilao das extenses em Pyrex, durante a
instalao de um mdulo. O pacote setuptools, d suporte compi-
lao automtica de extenses em Pyrex. Basta escrever um script
de instalao similar ao da listagem 5.10. Uma vez criado o script
(batizado, por exemplo, de setupyx.py), para compilar a nossa ex-
tenso, basta executar o seguinte comando: python setupix.py
build.
Para compilar uma extenso Pyrex, o usurio deve natural-
mente ter o Pyrex instalado. Entretanto para facilitar a distribui-
o destas extenses, o pacote setuptools, na ausncia do Pyrex,
procura a verso em C gerada pelo autor do programa, e se ela esti-
ver incluida na distribuio do programa, o setuptools passa ento
para a etapa de compilao e linkagem do cdigo C.
Listagem 5.10: Automatizando a compilao de extenses em
Pyrex por meio do setuptools

s e t u p y x . py
2 from setuptools import setup
5.3. INTEGRAO COM C++ 111
Listagem 5.11: Utilizando Setuptools para compilar extenses em

Pyrex
1 import s e t u p t o o l s
2 from s e t u p t o o l s . e x t e n s i o n import Extension
3 from setuptools . extension import Extension

4
5 p r i m e s p i x = E x t e n s i o n ( name = ' primespix ' ,
6 sources = [ ' p r i m e s . pyx
' ]
7 )
8
9 s e t u p ( name = ' primes ' ,
10 ext_modules = [ primespix ]
11 )
5.3 Integrao com C++

A integrao de programas em Python com bibliotecas em C++
normalmente feita por meio ferramentas como SWIG (www.swig.
org), SIP(www.riverbankcomputing.co.uk/sip/) ou Boost.Python
(http://www.boost.org/libs/python/). Estas ferramentas, ape-
sar de relativamente simples, requerem um bom conhecimento de
C++ por parte do usurio e, por esta razo, fogem ao escopo deste
captulo. No entanto, o leitor que deseja utilizar cdigo j escrito
em C++ pode e deve se valer das ferramentas supracitadas, cuja
documentao bastante clara.
Elegemos para esta seo sobre C++. uma ferramenta original.
O ShedSkin.
112 LINGUAGENS
Shedskin
O ShedSkin (http://shed-skin.blogspot.com/)se auto intitula

um compilador de Python para C++ otimizado. O que ele faz ,
na verdade, converter programas escritos em Python para C++,
permitindo assim grandes ganhos de velocidade. Apesar de seu
potencial, o ShedSkin ainda uma ferramenta um pouco limitada.
Uma de suas principais limitaes, que o programa em Python a
ser convertido deve possuir apenas variveis estticas, ou seja as
variveis devem manter-se do mesmo tipo durante toda a execuo
do programa. Se uma varivel denida como um nmero inteiro,
nunca poder receber um nmero real, uma lista ou qualquer outro
tipo de dado.
O ShedSkin tambm no suporta toda a biblioteca padro do
Python na verso testada (0.0.15). Entretanto, mesmo com estas
limitaes, esta ferramenta pode ser muito til. Vejamos um exem-
plo: A integrao numrica de uma funo, pela regra do trapzio.
Esta regra envolve dividir a rea sob a funo em um dado intervalo
em multiplos trapzios e somar as suas reas(gura 5.2.
Matemticamente, podemos expressar a regra trapezoidal da
seguinte frmula.
b n1
ba
Z
h X
f (x) dx (f (a) + f (b)) + h f (a + ih), h= (5.1)
a 2 i=1
n
Na listagem 5.12 podemos ver uma implementao simples da

regra trapezoidal.
Listagem 5.12: implementao da regra trapezoidal(utilizando lao

for) conforme especicada na equao 5.3
1 # e n c o d i n g : l a t i n 1
t r a p i n t l o o p . py
3 # copyright 2007 by Flvio Codeo Coelho
Figura 5.2: Regra trapezoidal para integrao aproximada de uma

funo.
4 from time import clock

5 from math import exp , log , sin
6
7 def t i n t ( a , b , fun ) :
8 """
9 Integrao numrica pela regra
trapezoidal
10 """
11 n = 5000000
12 h2 = ( ba ) / ( n 2 . )
13 r e s = h2 f u n ( a )+h2 f u n ( b )
14 for i in xrange ( n ) :
15 p = a+ i 2 h2
16 r e s += 2 h2 f u n ( p )
114 LINGUAGENS
17 return res
18
19 # Rodando as funcoes em Python
20 start = clock ()
21 r = tint (1.0 ,5.0 , lambda ( x ) :1+ x )
22 stop = clock ()
23 print ' r e s u l t a d o : %d \nTempo : %s s e g ' %(r , s t o p
s t a r t )
24 start = clock ()
25 r = tint (1.0 ,5.0 , lambda ( x ) : e x p ( x 2 l o g ( x+x
sin (x) ) ) )
26 stop = clock ()
s t a r t )
Executando o script da Listagem 5.12 (trapintloop.py) obser-

vamos o tempo de execuo da integrao das duas funes.
Listagem 5.13: Executando a listagem 5.12
1 $ python t r a p i n t l o o p . py
2 resultado : 16
3 Tempo : 11.68 seg
4 resultado : 49029
5 Tempo : 26.96 seg
Para converter o script 5.12 em C++ tudo o que precisamos fazer

:
Listagem 5.14: Vericando o tempo de execuo em C++

1 $ ss t r a p i n t l o o p . py
2 SHED SKIN Pythont o C++ C o m p i l e r 0.0.15

3 Copyright 2005 , 2006 Mark Dufour ; License
GNU GPL v e r s i o n 2 or later ( See LICENSE )
4 ( If your program does not compile , please

mail me at mark . d u f o u r @ g m a i l . com ! ! )
5
6 WARNING trapintloop :13: ' xrange ' , '
enumerate ' and ' reversed ' return lists
for now
7 [ iterative type analysis . . ]
8
9 iterations : 2 templates : 55
10 [ generating c++ c o d e . . ]
11 $ make run
12 g++ O3 I ...
13 ./ trapintloop
14 resultado : 16
15 Tempo : 0.06 seg
16 resultado : 49029
17 Tempo : 1.57 seg
Com estes dois comandos, geramos, compilamos e executamos

uma verso C++ do programa listado em 5.12. O cdigo C++ gerado
pelo Shed-Skin pode ser conferido na listagem 5.15
Como pudemos vericar, o ganho em performance conside-
rvel. Lamentvelmente, o Shed-Skin no permite criar mdulos
de extenso que possam ser importados por outros programas em
Python, s programas independentes. Mas esta limitao pode vir
a ser superada no futuro.
Listagem 5.15: Cdigo C++ gerado pelo Shed-skin a partir do script

trapintloopy.py
1 #include " t r a p i n t l o o p . hpp "

2
3 namespace __trapintloop__ {
4
5 str const_0 ;
116 LINGUAGENS
6
7 double r , start , stop ;
8
9 double __lambda0__ ( double x) {
10
11 return (1+ x ) ;
12 }
13
14 double __lambda1__ ( double x) {
15
16 return e x p ( ( ( x x ) l o g ( ( x+(x s i n ( x ) ) ) ) ) ) ;
17 }
18
19 int __main ( ) {
20 const_0 = new s t r ( " r e s u l t a d o : %d \nTempo :
%s seg " ) ;
21
22 start = clock () ;
23 r = tint (1.0 , 5.0 , __lambda0__ ) ;
24 stop = clock () ;
25 p r i n t ( "%s \ n " , __mod( c o n s t _ 0 , __int ( r ) ,
new f l o a t _ ( ( s t o p s t a r t ) ) ) ) ;
26 start = clock () ;
27 r = tint (1.0 , 5.0 , __lambda1__ ) ;
28 stop = clock () ;
29 p r i n t ( "%s \ n " , __mod( c o n s t _ 0 , __int ( r ) ,
new f l o a t _ ( ( s t o p s t a r t ) ) ) ) ;
30 }
31
32 /
trapeziodal
34 /
35 double tint ( double a, double b, lambda0 fun )
5.4. INTEGRAO COM A LINGUAGEM FORTRAN 117
{
36 double h2 , p , res ;
37 int __0, __1, i , n;
38
39 n = 5000000;
40 h2 = ( ( ba ) / ( n 2 . 0 ) ) ;
41 r e s = ( ( h2 f u n ( a ) ) +(h2 f u n ( b ) ) ) ;
42
43 FAST_FOR( i , 0 , n , 1 , 0 , 1 )
44 p = ( a +(( i 2 ) h2 ) ) ;
45 r e s += ( ( 2 h2 ) f u n ( p ) ) ;
46 END_FOR
47
48 return res ;
49 }
50
51 } // module namespace
52
53 int main ( int argc , char a r g v ) {
54 __shedskin__ : : _ _ i n i t ( ) ;
55 __math__ : : _ _ i n i t ( ) ;
56 __time__ : : _ _ i n i t ( ) ;
57 __trapintloop__ : : __main ( ) ;
58 }
5.4 Integrao com a Linguagem Fortran

A linguagem Fortran uma das mais antigas linguagens de pro-
gramao ainda em uso. Desenvolvida nos anos 50 pela IBM,
foi projetada especicamente para aplicaes cientcas. A sigla
Fortran deriva de IBM mathematical FORmula TRANslation
system. Dada a sua longa existncia, existe uma grande quan-
tidade de cdigo cientco escrito em Fortran disponvel para uso.
118 LINGUAGENS
Felizmente, a integrao do Fortran com o Python pode ser feita
de forma extremamente simples, atravs da ferramenta f2py, que
demonstraremos a seguir.
f2py
Esta ferramenta est disponvel como parte do Pacote numpy (www.
scipy.org). Para ilustrar o uso do f2py, vamos voltar ao problema
da integrao pela regra trapezoidal (equao 5.3). Como vimos, a
implementao deste algoritmo em Python, utilizando um lao for,
ineciente. Para linguagens compiladas como C++ ou Fortran,
laos so executados com grande ecincia. Vejamos a performance
de uma implementao em Fortran da regra trapezoidal (listagem
??).
Listagem 5.16: implementao em Fortran da regra trapezoidal.
label
1 program t r a p e z i o
2 intrinsic exp , l o g , s i n
3 real l i n e a r , n o n l
4 external l i n e a r
5 external n o n l
6 call tint (1.0 ,5.0 , linear , res )
7 print , " R e s u l t a d o : " , r e s
8 c a l l t i n t ( 1 . 0 , 5 . 0 , nonl , r e s )
9 print , " R e s u l t a d o : " , r e s
10 end
11
12 subroutine t i n t ( a , b , f u n , r e s )
13 real a , b , r e s
14 integer 8 n
15 real h2 , a l f a
16 real f u n
17 external f u n
18 n = 5000000
19 Cf2py intent ( in ) a
20 Cf2py intent ( in ) b
21 Cf2py intent ( in ) f u n
22 Cf2py intent ( out , h i d e , c a c h e ) res
23 h2 = ( ba ) / ( 2 n )
24 a l f a =h2 f u n ( a )+h2 f u n ( b )
25 r e s =0.0
26 do i =1 , n
27 p = a+ i 2 h2
28 r e s = r e s +2 h2 f u n ( p )
29 end do
30 r e s = r e s+ a l f a
31 return
32 end
33
34 real function l i n e a r ( x )
35 real x
36 Cf2py intent ( in , out ) x
37 linear = x +1.0
38 return
39 end
40
41 real function n o n l ( x )
42 real x
43 Cf2py intent ( in , out ) x
44 n o n l = e x p ( x 2 l o g ( x+x s i n ( x ) ) )
45 return
46 end
A listagem 5.17 nos mostra como compilar e executar o cdigo
da listagem ??. Este comando de compilao pressupe que voc
possua o GCC (Gnu Compiler Collection) verso 4.0 ou superior.
No caso de verses mais antigas deve-se substituir gfortran por
120 LINGUAGENS
g77 ou f77.
Listagem 5.17: Compilando e executando o programa da listagem

??
1 $ gfortran o trapint trapint . f
2 $ time ./ trapint
3 Resultado : 16.01428
4 Resultado : 48941.40
5
6 real 0m2 . 0 2 8 s
7 user 0m1 . 7 1 2 s
8 sys 0m0 . 0 1 3 s
Como em Fortran no temos a convenincia de uma funo

para cronometrar nossa funo, utilizamos o comando time do
Unix. Podemos constatar que o tempo de execuo similar ao
obtido com a verso em C++ (listagem 5.15).
Ainda que no seja estritamente necessrio, recomendvel
que o cdigo Fortran seja preparado com comentrios especiais
(Cf2py), antes de ser processado e compilado pelo f2py. A lista-
gem ?? j inclui estes comentrios, para facilitar a nossa exposio.
Estes comentrios nos permitem informar ao f2py as variveis de
entrada e sada de cada funo e algumas outras coisas. No exemplo
??, os principais parametros passados ao f2py, atravs das linhas
de comentrio Cf2py intent(), so in, out, hide e cache. As
duas primeiras identicam as variveis de entrada e sada da fun-
o ou procedure. O parmetro hide faz com que a varivel de
sada res, obrigatoriamente declarada no cabealho da procedure
em Fortran que oculta ao ser importada no Python. O parme-
tro cache reduz o custo da realocao de memria em variveis que
so redenidas dentro de um lao em Fortran.
Antes que possamos importar nossas funes em Fortran para
uso em um programa em Python, precisamos compilar nossos fontes
em Fortran com o f2py. A listagem 5.18 nos mostra como fazer

isso.
Listagem 5.18: Compilando com f2py

1 $ f2py m trapintf c trapint . f
Uma vez compilados os fontes em Fortran com o f2py, pode-

mos ento escrever uma variao do script trapintloop.py (lis-
tagem 5.12) para vericar os ganhos de performance. A listagem
5.19 contm nosso script de teste.
Listagem 5.19: Script para comparao entre Python e Fortran

via f2py
1 # e n c o d i n g : l a t i n 1
t r a p i n t l o o p c o m p . py
3 from time import c l o c k
4 from math import exp , l o g , s i n
5 from t r a p i n t f import t i n t a s f t i n t , linear ,
nonl
6 def tint (a ,b , f ) :
7 n = 5000000
8 h2 = ( ba ) / ( n 2 . )
9 r e s = h2 f ( a )+h2 f ( b )
10 for i in xrange ( n ) :
11 p = a+ i 2 h2
12 r e s += 2 h2 f ( p )
13 return res
14 # Rodando as funcoes em Python
15 start = clock ()
16 r = tint (1 ,5 , lambda ( x ) :1+ x )
17 stop = clock ()
s t a r t )
122 LINGUAGENS
19 start = clock ()
20 r = tint (1 ,5 , lambda ( x ) : e x p ( x 2 l o g ( x+x s i n (
x) ) ) )
21 stop = clock ()
s t a r t )
23 #Rodando as funes em Fortran chamando
Python
24 print " tempo do Fortran com funcoes em
Python "
25 start = clock ()
26 r = ftint (1. ,5. , lambda ( x ) :1+ x )
27 print ' r e s u l t a d o : %d \nTempo : %s s e g ' %(r ,
c l o c k ( ) s t a r t )
28 start = clock ()
29 r = ftint (1. ,5. , lambda ( x ) : e x p ( x 2 l o g ( x+x
sin (x) ) ) )
31 #Rodando as funes em Fortran puro
32 print " tempo do Fortran com funcoes em
Fortran "
33 start = clock ()
34 r = ftint (1. ,5. , linear )
36 start = clock ()
37 r = f t i n t ( 1 . , 5 . , nonl )
A listagem 5.19 contem uma verso da regra trapezoidal em

Python puro e importa a funo tint do nosso programa em Fortran.
A funo em Fortran chamado de duas formas: uma para inte-
grar funes implementadas em Python (na forma funes lambda)

e outra substituindo as funes lambda pelos seus equivalentes em
Fortran.
Executando trapintloopcomp.py, podemos avaliar os ganhos
em performance (listagem 5.20). Em ambas as formas de utilizao
da funo ftint, existem chamadas para objetos Python dentro
do laoDO. Vem da a degradao da performance, em relao
execuo do programa em Fortran, puramente.
Listagem 5.20: Executando trapintloopcomp.py

1 $ python t r a p i n t l o o p c o m p . py
2 resultado : 16
3 Tempo : 13.29 seg
4 resultado : 49029
5 Tempo : 29.14 seg
6 tempo do Fortran com funcoes em Python
7 resultado : 16
8 Tempo : 7.31 seg
9 resultado : 48941
10 Tempo : 24.95 seg
11 tempo do Fortran com funcoes em Fortran
12 resultado : 16
13 Tempo : 4.85 seg
14 resultado : 48941
15 Tempo : 6.42 seg
Neste ponto, devemos parar e fazer uma reexo. Ser justo

comparar a pior implementao possvel em Python (utilizando
laos for), com cdigos compilados em C++ e Fortran? Realmente,
no justo. Vejamos como se sai uma implementao competente
da regra trapezoidal em Python (com uma ajudinha do pacote
numpy). Consideremos a listagem 5.21.
Listagem 5.21: Implementao vetorizada da regra trapezoidal

124 LINGUAGENS
1 # e n c o d i n g : l a t i n 1
t r a p i n t v e c t . pt
3 from numpy import
4 from time import c l o c k
5
6 def t i n t ( a , b , fun ) :
7 """
trapezoidal
9 """
10 n = 5000000.
11 h = ( ba ) / n
12 r e s = h / 2 f u n ( a )+h / 2 f u n ( b )+h sum (
fun ( arange ( a , b , h ) ) )
13 return res
14
15 if __name__== '__main__ ' :
16 start = clock ()
17 r = tint (1 ,5 , lambda ( x ) :1+ x )
18 print ' r e s u l t a d o : %d \nTempo : %s seg '
%(r , c l o c k ( ) s t a r t )
19 start = clock ()
20 r = tint (1 ,5 , lambda ( x ) : e x p ( x 2 l o g (
x+x s i n ( x ) ) ) )
21 print ' r e s u l t a d o : %d \nTempo : %s seg '
%(r , c l o c k ( ) s t a r t )
Executando a listagem 5.21, vemos que a implementao veto-

rizada em Python ganha (0.28 e 2.57 segundos)de nossas solues
utilizando f2py.
Da mesma forma que com o Pyrex, podemos distribuir progra-
mas escritos em Python com extenses escritas em Fortran, com
a ajuda do pacote setuptools. Na listagem 5.22 vemos o exem-
plo de como escrever um setup.py para este m. Neste exemplo,

temos um setup.py extrememente limitado, contendo apenas os
parmetros necessarios para a compilao de uma extenso deno-
minada flib, a partir de uma programa em Fortran, localizado no
arquivo flib.f, dentro do pacote meupacote. Observe, que ao
denir mdulos de extenso atravs da funo Extension, podemos
passar tambm outros argumentos, tais como outras bibliotecas das
quais nosso cdigo dependa.
Listagem 5.22: setup.py para distribuir programas com extenses

em Fortran
1 import ez_setup
2 ez_setup . u s e _ s e t u p t o o l s ( )
3 import s e t u p t o o l s
4 from numpy . d i s t u t i l s . c o r e import setup ,
Extension
5 flib = E x t e n s i o n ( name= ' m e u p a c o t e . f l i b ' ,
6 l i b r a r i e s =[] ,
7 library_dirs =[] ,
8 f2py_options =[] ,
9 s o u r c e s =[ ' m e u p a c o t e /
flib . f ' ]
10 )
11 s e t u p ( name = ' mypackage ' ,
12 version = ' 0.3.5 ' ,
13 packages = [ ' meupacote ' ] ,
14 ext_modules = [ flib ]
15 )
126 LINGUAGENS
5.5 A Pton que sabia Javans Integrao
com Java
Peo licena ao mestre Lima Barreto, para parodiar o ttulo do seu
excelente conto, pois no pude resistir analogia. A linguagem
Python, conforme descobrimos ao longo deste livro, extrema-
mente verstil, e deve esta versatilidade, em parte, sua biblioteca
padro. Entretanto existe uma outra linguagem que excede em
muito o Python (ao menos atualmente), na quantidade de mdu-
los disponveis para os mais variados ns: o Java.
A linguagem Java tem, todavia, contra si uma srie de fatores:
A complexidade de sua sintaxe rivaliza com a do C++, e no e-
ciente, como esperaramos que o fosse, uma linguagem compilada,
com tipagem esttica. Mas todos estes aspectos negativos no so
sucientes para anular as vantagens do vasto nmero de bibliotecas
disponveis e da sua portabilidade.
Como poderamos capturar o que o Java tem de bom, sem levar

como brinde seus aspectos negativos? aqui que entra o Jython.
O Jython uma implementao completa do Python 2.21 em
Java. Com o Jython programadores Java podem embutir o Python
em seus aplicativos e applets e ns, programadores Python, pode-
mos utilizar, livremente, toda (ou quase toda) a biblioteca padro
do Python com classes em Java. Alm destas vantagens, O Jython
tambm uma linguagem Open Source, ou seja de cdigo aberto.
O interpretador Jython
Para iniciar nossa aventura com o Jython, precisaremos instal-lo,

e ter instalada uma mquina virtual Java (ou JVM) verso 1.4 ou
mais recente.
1O desenvolvimento do Jython continua, mas no se sabe ainda

quando alcanar o CPython (implementao em C do Python).
5.5. A PTON QUE SABIA JAVANS INTEGRAO COM
JAVA 127
Vamos tentar us-lo como usaramos o interpretador Python e

ver se notamos alguma diferena.
Listagem 5.23: Usando o interpretador Jython

1 $ jython
2 Jython 2.1 on java1 .4.2 01 ( JIT : null )
3 Type " c o p y r i g h t " , " credits " or "license" for
more information .
4 >>> print ' hello world '
5 hello world
6 >>> import math ( )
7 >>> d i r ( math )
8 [ ' acos ' , ' asin ' , ' atan ' , ' atan2 ' , ' ceil ' , '
classDictInit ' , ' cos ' , ' cosh ' , 'e ' , ' exp
' , ' fabs ' , ' floor ' , ' fmod ' , ' frexp ' , '
hypot ' , ' ldexp ' , ' log ' , ' log10 ' , ' modf ' ,
' pi ' , ' pow ' , ' sin ' , ' sinh ' , ' sqrt ' , '
tan ' , ' tanh ' ]
9 >>> math . p i
10 3.141592653589793
At agora, tudo parece funcionar muito bem. Vamos tentar um

exemplo um pouco mais avanado e ver de que forma o Jython
pode simplicar um programa em Java.
Listagem 5.24: Um programa simples em Java usando a classe
Swing.
1 import j a v a x . s w i n g . J O p t i o n P a n e ;
2 class t e s t D i a l o g {
3 public static void main ( S t r i n g [ ] args )
{
4 j a v a x . s wi n g . JOptionPane .
showMessageDialog ( null , " Isto e
um teste . " ) ;
128 LINGUAGENS
5 }
6 }
A verso apresentada na listagem 5.24 est escrita em Java.

Vamos ver como caria a verso em Jython.
Listagem 5.25: Verso Jython do programa da listagem 5.24.
1 >>> import j a v a x . s wi n g . JOptionPane

2 >>> j a v a x . s w i n g . J O p t i o n P a n e .
s h o w M e s s a g e D i a l o g ( None , " I s t o e um teste .
")
Podemos observar, na listagem 5.25, que eliminamos a verbor-

ragia caracterstica do Java, e que o programa em Jython cou
bem mais pitnico. Outro detalhe que vale a pena comentar,
que no precisamos compilar (mas podemos se quisermos) o cdigo
em Jython, como seria necessrio com o Java. S isto j uma
grande vantagem do Jython. Em suma, utilizado-se o Jython ao
invs do Java, ganha-se em produtividade duas vezes: Uma, ao
escrever menos linhas de cdigo e outra, ao no ter que recompilar
o programa a cada vez que se introduz uma pequena modicao.
Para no deixar os leitores curiosos acerca da nalidade do c-
digo apresentado na listagem 5.25, seu resultado encontra-se na
gura 5.3.
Criando Applets em Jython
Para os conhecedores de Java, o Jython pode ser utilizado para

criar servlets, beans e applets com a mesma facilidade que
criamos um aplicativo em Jython. Vamos ver um exemplo de ap-
plet(listagem 5.26).
Listagem 5.26: Criando um applet em Jython

1 import java . a p p l e t . Applet ;
5.5. A PTON QUE SABIA JAVANS INTEGRAO COM
JAVA 129
Figura 5.3: Sada da listagem 5.25.
2 class a p p l e t p ( j a v a . a p p l e t . A p p l e t ) :
3 def p a i n t ( s e l f , g ) :
4 g . drawString ( ` ` Eu s o u um A p p l e t
Jython ! ' ' , 5, 5 )
Para quem no conhece Java, um applet um mini-aplicativo

feito para ser executado dentro de um Navegador (Mozilla, Opera
etc.) que disponha de um plug-in para executar cdigo em Java.
Portanto, desta vez, precisaremos compilar o cdigo da listagem
5.26 para que a mquina virtual Java possa execut-lo. Para isso,
salvamos o cdigo e utilizamos o compilador do Jython, o jythonc.
Listagem 5.27: Compilando appletp.py
1 $ jythonc d e e p c o r e j appletp . j a r
a p p l e t p . py
2 processing appletp
3
4 Required packages :
5 java . applet
6
7 Creating adapters :
8
9 Creating . java files :
130 LINGUAGENS
10 appletp module
11 appletp extends java . a p p l e t . Applet
12
13 Compiling . java to . class . . .
14 Compiling with args : [ ' / o p t / b l a c k d o w n j d k
1.4.2.01/ bin / javac ' , ' c l a s s p a t h ' , '/
usr / share / jython / l i b / jython 2.1. j a r :/ usr
/ s h a r e / l i b r e a d l i n e j a v a / l i b / l i b r e a d l i n e
j a v a . j a r : . : . / jpywork : : / u s r / s h a r e / j y t h o n /
t o o l s / jythonc :/ home/ f c c o e l h o / Documents /
L i v r o P y t h o n / . : / u s r / s h a r e / j y t h o n / Lib ' ,
' . / jpywork / a p p l e t p . java ' ]
15 0 Note : . / jpywork / a p p l e t p . j a v a uses or
overrides a deprecated API .
16 Note : Recompile with d e p r e c a t i o n for
details .
17
18 Building archive : appletp . j a r
19 Tracking java dependencies :
Uma vez compilado nosso applet, precisamos embuti-lo em

um documento HTML (listagem 5.28. Ento, basta apontar nosso
navegador para este documento e veremos o applet ser executado.
Listagem 5.28: Documento HTML contendo o applet.
1 < html>
2 < head>
3 <meta content=" t e x t / h t m l ; c h a r s e t=ISO
8859 1"
4 h t t p e q u i v=" c o n t e n t t y p e ">
5 t i t l e>j y t h o n
< a p p l e t</ t i t l e>
6 </ head>
7 <body>
8 Este
5.6. EXERCCIOS 131
9 &e a c u t e ; o s e u a p p l e t em J y t h o n :<br>
10 < br>
11 <br>
12 <center>
13 <applet code=" a p p l e t p " archive=" a p p l e t p . j a r "
name=" A p p l e t em J y t h o n "
14 alt=" T h i s b r o w s e r d o e s n ' t s u p p o r t JDK 1 . 1
a p p l e t s . " align=" bottom "
15 height=" 5 0 " width=" 1 6 0 ">
16 <PARAMNAME=" c o d e b a s e " VALUE=" . ">
17 <h3>A l g o s a i u e r r a d o ao c a r r e g a r
18 e s t e a p p l e t .</ h3>
19 </ applet>
20 </ center>
21 <br>
22 <br>
23 </ body>
24 </ html>
Na compilao, o cdigo em Jython convertido completa-

mente em cdigo Java e ento compilado atravs do compilador
Java padro.
5.6 Exerccios
1. Compile a listagem 5.1 com o Shed-skin e veja se h ganho de
performance. Antes de compilar, remova as linhas associadas
ao uso do Weave.
2. Aps executar a funo primes (listagem 5.6), determine o

tamanho da lista de nmeros primos menor do que 1000.
Em seguida modique o cdigo Pyrex, declarando a varivel
results como uma lista de inteiros, e eliminando a funo
132 LINGUAGENS
append do lao while. Compare a performance desta nova
verso com a da verso original.
Parte II
Aplicando o Python a
Problemas Cientcos
Concretos
133
Captulo 6
Modelagem Matemtica
Introduo modelagem matemtica e sua implementa-
o computacional. Discusso sobre a importncia da
Anlise dimensional na modelagem e apresentao do
pacote Unum para lidar com unidades em Python. Pr-
requisitos:Conhecimentos bsicos de clculo.
A construo de modelos uma etapa imprescindvel, na ca-

deia de procedimentos normalmente associada ao mtodo cientco.
Modelos matemticos so uma tentativa de representar de forma
lgico/quantitativa, mecanismos que observamos na natureza.
Todo modelo por denio falso. O modelo um instrumento

de organizao de idias e hipteses. Como tal, o modelo bom
aquele que representa bem nossas idias. O que o far til para o
conhecimento do mundo, depender, em grande parte, da qualidade
de nossa concepo de mundo. Assim, bons modelos exigem uma
boa compreenso do sistema a ser modelado. Algum pode estar
pensando: Se preciso conhecer bem para modelar, ento para
que modelar, se o objetivo for conhecer bem? O grande segredo da
modelagem que o ato de modelar , em si, um ato de conhecer.
Isto , para criar um modelo, o autor precisa escrutinar todo o
seu conhecimento do sistema-alvo: identicar seus componentes,
135
136 CAPTULO 6. MODELAGEM MATEMTICA
discriminar o que relevante do que no , hipotetizar sobre as
relaes causais que regem os processos observados, etc.
Ao se deter nestes detalhes, comeam a surgir os vazios do co-
nhecimento, buracos a serem preenchidos com experimentos e ob-
servaes ainda no pensados. Do mesmo modo, observaes e in-
tuies que antes no faziam muito sentido, comeam a se encaixar
melhor. . .
Muitas vezes, o resultado nal de um modelo parece to bvio,
que nos perguntamos para que serviu. No entanto, o bvio s se
tornou bvio, por causa do ato de modelar.
E aquilo que neste momento se revelar aos povos, no

surpreender a todos por ser extico, mas pelo fato de
ter sempre estado oculto, quando ter sido, o bvio
Caetano Veloso
Outras vezes, os modelos abrem novas avenidas de escrutnio,

ao apontar para fenmenos pouco intuitivos (como o caos determi-
nstico).
Para matematizar um modelo, existem dois pontos de partida.
Podemos construir do zero ou pegar emprestado. Pegar emprestado
signica adaptar um modelo proposto por algum. A vantagem de
pegar emprestado que o modelo j vem com alguma bagagem
analtica. A desvantagem que ele tolhe a nossa liberdade cri-
ativa. Ao olharmos para a histria da modelagem, encontramos
alguns modelos que caram de tal forma inseridos no imaginrio
do modelador que parecem ser os nicos existentes. Um exemplo
o modelo de Lotka-Volterra. Ele to usado, que as vezes se
torna difcil escrever alguma coisa nova sem, inconscientemente,
comparar o modelo novo com este padro.
Modelos, embora falsos, devem ser corretos. Existem dois n-
veis de correo de um modelo matemtico: modelos devem ter
coerncia lgica (isto , no se pode somar alhos com bugalhos) e
coerncia com o modelo mental proposto (isto , ele deve represen-
tar aquilo que o autor quer dizer).
6.1. MODELOS 137
Computacionalmente falando, modelos so como mquinas trans-

formadoras, produzem informao a partir de informao. So
equivalentes, portanto, a funes que, a partir de argumentos, pro-
duzem um resultado que consiste na transformao do argumento
de entrada, de acordo com o mecanismo codicado dentro de si.
Vamos comear nossa jornada, em direo representao com-

putacional de modelos matemticos, com uma breve introduo ao
modelos mais simples e suas implementaes.
6.1 Modelos
Lineares
Modelos lineares representam a relao entre grandezas que variam

de forma proporcional. Um exemplo simples o da corrida de
taxi. O valor pago ao motorista numa corrida de taxi calculado
em funo da quilometragem rodada, mais o valor da bandeirada
inicial. Digamos que Joo cobre 0.50 reais por quilmetro rodado e
uma bandeirada de 2,00. Se rodarmos 10km, pagaremos 0.5x10 =
5 reais (+ a bandeirada); se rodarmos o dobro (20km), pagaremos
o dobro pela corrida (10 reais) + bandeirada. As duas grandezas -
quilometragem rodada e valor pago pela quilometragem - variam de
forma proporcional. Vamos supor que Joo tenha um caderno onde
ele registra todas as corridas que faz, incluindo quilometragem,
valor pago pela quilometragem e valor total pago (quilometragem
+ bandeirada).
Se zermos um diagrama de disperso com os dados da tabela

6.1, obteremos uma reta representando o cenrio sem bandeirada
e outra para o cenrio com bandeirada.
O clculo da corrida nal feito pela equao:
R$ = a Km + b
Tabela 6.1: Valor de corridas de taxi
corrida km valor/kilometragem valor total

1 5 2,50 4,50
2 8 4,00 6,00
3 3 1,50 3,50
4 10 5,00 7,00
5 9 4,50 6,50
6 4 2,00 4,00
7 15 7,50 9,50
onde a o valor pago por quilmetro rodado (a = 0, 50) e b o

valor inicial pago (isto , a bandeirada). Em Python:
1 >>> def t a x i ( t a r i f a , km , band =2) :

2 return tarifa km+band
3 >>> p r = t a x i ( 0 . 5 , 1 0 )
4 >>> p r
5 7.0
Vamos ver outros exemplos:

Crescimento populacional por imigrao constante. Uma po-
pulao composta inicialmente por 100 indivduos. A partir do
ano que chamaremos 0, passaram a chegar 10 novos indivduos por
ano. Esta populao crescer, isto , ter 110 indivduos no ano
1, 120 indivduos no ano 2, 130 indivduos no ano 3, etc. Se ns
zermos um grco da relao ano x nmero de indivduos, tere-
mos uma reta crescente. Esta reta intercepta o eixo vertical no
ponto 100 (populao inicial) e tem inclinao dada pelo nmero
de individuos acrescidos por unidade de tempo (isto , a = 10).
Decrescimento populacional por emigrao constante. Agora,
suponha que ao invs de entrar, esto saindo 10 indivduos a cada
ano. Se a populao composta inicialmente por 100 indivduos,
ento teremos 90 indivduos no ano 1; 80 indivduos no ano 2; 70
6.1. MODELOS 139
Figura 6.1: Diagrama de disperso do exemplo do taxi. A reta

superior descreve o cenrio com bandeirada e a inferior, sem ban-
deirada.
indivduos no ano 3, etc. Se ns zermos um grco da relao

entre ano e nmero de indivduos, teremos uma reta decrescente.
Esta reta intercepta o eixo vertical no ponto 100 (populao inicial)
e tem inclinao negativa, cujo valor absoluto dado pelo nmero
de individuos perdidos por unidade de tempo (isto , a = 10).
Todos os exemplos dados so especicaes de modelos cujo
formato geral :
Figura 6.2: Populao crescendo de forma linear, devido chegada

de um nmero constante de novos indivduos por ano.
Y =aX +b
a, chamado de coeciente angular, a taxa de variao da
onde
grandeza Y por unidade de X e b, chamado de coeciente linear,
o valor de Y quando X = 0. Este modelo se expressa gracamente
como uma reta com ngulo a em relao a linha horizontal e que
cruza o eixo vertical no ponto b. Esta reta ser crescente se a
for maior do que 0; horizontal, se a = 0, e decrescente, se a for
negativo.
6.1. MODELOS 141
Figura 6.3: Populao diminui de forma linear, devido saida de

um nmero constante de indivduos por ano.
Propriedades Uma propriedade importante do modelo linear

que a variao de crescimento ou decrescimento constante e in-
dependente do valor de X. No caso da imigrao, por exemplo,
estavam entrando 10 pessoas todos os anos, independentemente do
nmero de pessoas j existentes na populao. No caso do taxi, o
valor pago por quilmetro rodado no mudava se a pessoa j tivesse
rodado 5 ou 20 km.
Figura 6.4: Representao grca de um modelo linear. Efeito do

parmetro a.
Exponenciais
O modelo linear descrito na seo anterior, pode ser um bom mo-

delo para descrever o crescimento de uma populao por imigrao
constante. Porm, no nos serve para descrever o crescimento por
reproduo. Vejamos o clssico exemplo do crescimento bacteriano
por bipartio. Digamos que temos uma populao com uma bac-
tria no tempo t=0. Aps 1 hora, cada bactria se divide e forma
duas bactrias-lha. Estas duas bactrias geram 4 novas bactrias
6.1. MODELOS 143
Figura 6.5: Representao grca de um modelo linear. Efeito do

parmetro b.
em mais uma hora e assim por diante. Se zermos um grco do

nmero de bactrias na populao, teremos algo como a gura 6.6.
Veja que o nmero de novos indivduos a cada gerao no

constante, como no modelo linear. Agora, ele aumenta de forma
geomtrica. Na primeira gerao foram 2 novos indivduos, na
segunda gerao foram 4 e assim por diante. O crescimento muito
mais acelerado e parece tender para uma exploso demogrca! Em
apenas 10 horas, teremos uma populao com 1024 indivduos e,
em um dia, 16.677.216 bactrias!
Figura 6.6: Crescimento de uma populao de bactrias por bipar-

tio.
No entanto, embora o crescimento no seja constante no tempo,

ele constante por indivduo. O que isso quer dizer? Cada indiv-
duo na populao contribui com o mesmo nmero de lhos para a
gerao seguinte,de forma que uma populao pequena gerar um
nmero menor de lhotes do que uma populao grande.
Este tipo de crescimento dependente do nmero de indivduos

presentes chamado de exponencial, pelo fato da varivel indepen-
6.2. CONSTRUINDO MODELOS DINMICOS 145
dente estar no expoente. Matematicamente, ele tem o formato:
Y = wB X
onde w o nmero inicial de bactrias (w = 1).

Ao contrrio do modelo linear, onde a taxa de variao era
independente do nmero de indivduos presentes, no modelo ex-
ponencial, a taxa de variao uma funo, isto , depende, do
nmero de indivduos presentes.
6.2 Construindo Modelos Dinmicos

Na seo anterior vimos como representar fenmenos simples como
expresses matemticas. Agora vamos explorar representaes mais
sosticadas: Vamos modelar processos dinmicos. Processos din-
micos modicam-se em funo de uma varivel independente que,
nos casos mais comuns, pode ser o tempo ou o espao.
Nos modelos estticos da seo anterior, buscamos expressar o
estado do sistema em funo de outras variveis. Uma vez deter-
minado os valor destas variveis, o estado do sistema permanece
inalterado. Agora, no sabemos o que determina o estado do sis-
tema, necessriamente, mas podemos descrever mecanismos que
alteram um estado inicial dado.
Neste tipo de modelagem utilizamos equaes de diferena(varivel
independente discreta) ou diferenciais (varivel independente con-
tnua), para modelar a taxa de variao do sistema, representada
pelas chamadas variveis de estado.
Modelando Iterativamente
Vamos comear a explorar os modelos dinmicos, atravs de mo-

delos com dinmica temporal discreta. Neste caso, podemos repre-
sentar o tempo discreto como a execuo iterativa de uma funo.
Figura 6.7: Modelos populacionais discretos. Modelo 2 esquerda

e modelo 1 direita.
Na listagem 6.1, vemos dois modelos populacionais:
M odelo 1 : Nt+1 = Nt + rNt mNt + i eNt

Ct+1 = Ct + ra At mc Ct eCt
M odelo 2 :
At+1 = At + eCt ma At
No modelo 1, temos o tamanho da populao no tempo seguinte
(Nt+1 ) sendo expresso como uma alterao da populao atual pelo
nascimento de indivduos a uma taxa r, pela mortalidade (m), e
por uxos migratrios (eNt e i).
No modelo 2, temos uma demograa similar, porm agora com
a populao dividida em dois grupos: crianas (Ct ) e adultos (At ).
Nestes modelos, utilizamos um simples lao for para resolver

numericamente as equaes de diferena. Representaes recursi-
vas tambm seriam possveis, mas para este exemplo no so ne-
cessrias.
Listagem 6.1: Dois modelos discretos de crescimento populacional

m o d e l o . py
2 # e n c o d i n g : l a t i n 1
3 from pylab import
4
5 N = [ 1 0 0 0 0 ] #s e r i e temporal de populacao
6 n0 = 1 0 0 0 0 #p o p u l a c a o inicial
7 t = 100 #p e r i o d o de tempo da
simulacao
8 r = 0.02 #n a t a l i d a d e
9 m = 0.03 #t a x a de mortalidade
10 im = 0 #t a x a de imigrao
11 em = 0 #t a x a de emigrao
12 #p a r m e t r o s modelo2
13 mc = 0 . 0 1 #t a x a de mortalidade
infantil
14 ma = 0 . 0 1 #t a x a de mortalidade adulta
15 ra = 0.02 #t a x a de reproducao
16 e = 0.1 #t a x a de envelhecimento
17 C = [ 1 0 0 0 0 ] #s e r i e temporal de crianas
18 A = [ 0 ] #s e r i e temporal de adultos
19 a0 = 0 #p o p u l a c a o inicial de
adultos
20 c0 = 10000 #p o p u l a c a o inicial de
criancas
21
22 def Modelo ( n0 ) :
23 n f = n0 + r n0 m n0 +im em n0
24 N . append ( n f )
25 return nf
26
27 def Modelo2 ( c0 , a 0 ) :
28 c f = c0 + r a a0 mc c 0 e c 0
29 a f = a0 + e c 0 ma a 0
30 C . append ( c f )
31 A . append ( a f )
32 return cf , af
33
34 for i in xrange ( t ) :
35 c0 , a 0 = Modelo2 ( c0 , a 0 )
36 n0 = Modelo ( n0 )
37
38 subplot (121)
39 p l o t (A, ' . ' , C, ' r^ ' )
40 legend ( [ ' Adultos ' , ' Criancas ' ] )
41 x l a b e l ( ' tempo ' )
42 subplot (122)
43 p l o t (N, ' . ' )
44 l e g e n d ( [ u ' Populao ' ] )
45 x l a b e l ( ' tempo ' )
46 s a v e f i g ( ' pop . png ' , d p i =400)
47 show ( )
Integrao Numrica
A simulao de modelos onde a varivel independente contnua,

tcnicamente mais complexa. Por isso, neste caso, lanaremos mo
do pacote scipy .
1
1 http://www.scipy.org
Modelos dinmicos contnuos so comumente representados por

sistemas de equaes diferenciais ordinrias, e sua resoluo envolve
a integrao destas numericamente.
O pacote scipy contm um pacote dedicado integrao nu-
mrica de equaes diferenciais: o integrate.
1 In [1]: from scipy import integrate
Nesta seo utilizaremos o pacote integrate para resolver um

sistema de equaes diferenciais ordinrias bem simples:
dP
= rP pP Q (6.1)
dt
dQ
= mQ + P Q
dt
O sistema de equaes 6.2, representa a dinmica de duas popu-

laes, P e Q onde Q(predador) alimenta-se de P(presa). Em nossa
implementao, utilizaremos a funo odeint do pacote integrate2 .
Esta funo tem como argumentos uma funo que retorna as de-
rivadas, a partir das condies iniciais, e um vetor de valores da
varivel independente(t) para os quais os valores das variveis de
estado sero calculados.
Listagem 6.2: Integrando um sistema de equaes diferenciais or-

dinrias
1 #modelo_ode . py
modelo_ode . py
3 # e n c o d i n g : u t f 8
4 from scipy import integrate
2 A funo odeint encapsula a tradicional biblioteca lsoda implementada em

Fortran. Esta biblioteca determina dinmicamente o algoritmo de integrao
mais adequado a cada passo de integrao, selecionando entre o mtodo de
Adams e o BDF.
5 from numpy import
6 import p y l a b a s P
7
8 class Model :
9 def __init__ ( s e l f , equations , i n i t s ,
trange , ) :
10 """
11 Equations : Lista com as equaes
diferenciais na forma de strings
12 inits : sequencia de condies
iniciais
13 trange : extenso da simulao
14 """
15 s e l f . eqs = equations
16
17 self . Inits = inits
18 s e l f . Trange = a r a n g e ( 0 , t r a n g e , 0 . 1 )
19 s e l f . compileEqs ( )
20
21 def compileEqs ( s e l f ) :
22 """
23 C om p il a as equaes .
24 """
25 try :
26 s e l f . ceqs = [ compile ( i , '<
equation>' , ' eval ' ) for i in
s e l f . eqs ]
27 except S y n t a x E r r o r :
28 print ' H um e r r o de sintaxe nas
e q u a e s , \ n C o n s e r t e o e
tente novamente '
29
30 def Run ( s e l f ) :
31 """
32 Faz a integrao numrica .

33 """
34 t_courseList = []
35 t _ c o u r s e L i s t . append ( i n t e g r a t e . o d e i n t
( s e l f . Equations , s e l f . I n i t s , s e l f .
Trange ) )
36 return ( t _ c o u r s e L i s t , s e l f . Trange )
37
38 def Equations ( s e l f , y , t ) :
39 """
40 Define os sistema d e EDOs calculando
cada equao
41 com base no valor anterior e
retornando as derivadas .
42 """
43 # C r i a vetor de equaes

44 eqs = s e l f . ceqs
45 Neq=l e n ( e q s )
46 y d o t = z e r o s ( ( Neq ) , ' d ' )
47 for k in x r a n g e ( Neq ) :
48 ydot [ k ] = eval ( eqs [ k ] )
49 return ydot
50
51 if __name__=="__main__" :
52 inits = [1 ,1]
53 eqs = [ ' 3.0 y [0] 2.0 y [ 0 ] y [ 1 ] ' , ' 2.0 y
[1]+ y [ 0 ] y [ 1 ] ' ]
54 ODE = Model ( e q s , i n i t s , 1 0 )
55 y , t = ODE. Run ( )
56 #p r i n t y
57 P. plot (t ,y [0][: ,0] , ' v ' , t , y [ 0 ] [ : , 1 ] , ' o
' )
58 P . l e g e n d ( [ ' Presa ' , ' Predador ' ] )
59 P . s a v e f i g ( ' l v . png ' , d p i =400)
60 P . show ( )
O modelo implementado como uma classe. A implementao

poderia ser mais simples, at mesmo feita diretamente do console do
Python. Entretanto, esta implementao mais longa nos permite
apresentar algumas outras tcnicas interessantes.
O modelo denido durante a inicializao do objeto, atravs de
atributos obrigatrios. Um mtodo Run() utilizado para executar
a integrao numrica. neste mtodo que chamamos a funo
odeint, passando os argumentos requeridos, a saber: a funo que
implementa as equaes, os valores iniciais das variveis de estado
e o vetor de tempos.
A equaes so passadas pelo usurio na forma de strings. Estas
strings devem conter uma expresso Python vlida.
O mtodo Equations precisa combinar as expresses das equa-
es para poder calcular o valor das derivadas em cada ponto do
tempo. Por isso, uma notao de lista foi utilizada para permitir
referncias entre as equaes. Desta forma, cada varivel de estado
um elemento da lista y.
As expresses representando as equaes, so interpretadas por
meio da funo eval, a cada passo da integrao numrica. Isto
requer que as strings contendo as expresses, sejam compiladas
para byte-code, e ento interpretadas pelo Python. Para evitar
que esta operao seja repetida a cada passo, o mtodo compileEqs
pr-compila estas expresses, o que acelera em muito a execuo
do programa 6.2.
Ao nal da listagem 6.2, vemos a especicao do modelo e, na
gura 6.8, o seu resultado.
O pacote integrate tambm nos oferece uma outra interface
para a integrao numrica chamada ode. A classe ode uma al-
ternativa orientada a objetos, funo odeint. A listagem 6.3,
mostra como implementar o mesmo sistema de equaes (6.2) uti-
lizando a classe ode.
Figura 6.8: Grco com o resultado da integrao do modelo 6.2.
Listagem 6.3: Integrao numrica utilizando a classe ODE.

modelo_ode_minimo . py
2 # e n c o d i n g : u t f 8
3 from s c i p y import integrate
4 from numpy import
6
7 def Equations ( t , y ) :
8 """
9 Define os sistema d e EDOs calculando
cada equacao
10 com base no valor anterior e retornando
as derivadas .
11 """
12 # C r i a vetor de equacoes

13 eqs = [ ' 3.0 y [0] 2.0 y [ 0 ] y [ 1 ] ' , ' 2.0 y
[1]+ y [ 0 ] y [ 1 ] ' ]
14 Neq=l e n ( e q s )
15 y d o t = z e r o s ( ( Neq ) , ' d ' )
16 for k in x r a n g e ( Neq ) :
17 ydot [ k ] = eval ( eqs [ k ] )
18 return ydot
19
20 if __name__=="__main__" :
21 r = i n t e g r a t e . ode ( E q u a t i o n s ) .
s e t _ i n t e g r a t o r ( ' vode ' )
22 r . set_initial_value ([1 ,1] ,0)
23 tf = 10 #tempo final
24 dt = 0 . 1
25 t = []
26 y = []
27 while r . successful () and r . t <= tf :
28 r . i n t e g r a t e ( r . t+d t )
29 t . append ( r . t )
30 y . append ( r . y )
31 print r .y
32 #P l o t a resultados
33 P. plot ( t , array (y) [ : , 0 ] , ' v ' , t , a r r a y ( y )
[ : , 1 ] , ' o ' )
34 P. t i t l e ( ' Integrador Vode ' )
35 P . l e g e n d ( [ ' Presa ' , ' Predador ' ] )
36 P . s a v e f i g ( ' l v 2 . png ' , d p i =400)
37 P . show ( )
Se voc necessita construir, simular e analisar modelos de equa-

6.3. GRANDEZAS, DIMENSES E UNIDADES 155
es diferenciais com freqncia, talvez prera utilizar um software

mais completo, desenvolvido por mim, chamado Model-Builder .
3
6.3 Grandezas, Dimenses e Unidades

Ao se construir modelos matemticos, cedo ou tarde nos deparamos
com a necessidade de aproximar o modelo conceitual do sistema
real para dar valor preditivo ao modelo. Este processo envolve o
mapeamento da mtrica do sistema real no modelo matemtico,
ou seja, fazer com que os parmetros ou constantes do nosso mo-
delo correspondam, numericamente, a mensuraes efetuadas no
sistema real.
Este processo de parametrizao envolve, frequentemente, a uti-
lizao de medidas das diferentes dimenses do sistema real (massa,
comprimento, temperatura, etc). Estas mensuraes raramente so
efetuadas pelo modelador. Este, frequentemente, se utiliza de me-
didas publicadas na literatura cientca, expressas nas mais varia-
das unidades de medida. A escolha das unidades de medida no
altera as dimenses do objeto de estudo (medir a nossa mesa de
trabalho em milmetros ao invs de metros no a torna mais longa),
mas altera a ordem de grandeza do valor numrico que representa
a dimenso medida.
Os modelos matemticos relacionam as vrias dimenses do sis-
tema estudado, por meio das grandezas numricas que as represen-
tam. Por isso, fundamental que as variveis e parmetros do
nosso modelo que representem uma mesma dimenso do objeto,
sejam expressas nas mesmas unidades de medida. Por exemplo,
se desenvolvemos um modelo que pretende correlacionar massa do
corao com massa corporal, no podemos expressar a massa do
corao em gramas(g) e a massa corporal em quilogramas(kg) .
4
3 http://model-builder.sourceforge.net
4 A menos que adicionemos contantes ao modelo que re-equilibrem a equa-
o do ponto de vista dimensional
Tabela 6.2: Dimenses bsicas.
Grandeza fsica Dimenso Unidade (SI) Smbolo

Comprimento L metro m
Massa M quilograma kg
Tempo T segundo s
Temperatura kelvin K
Quantidade
de uma substncia N mol mol
Corrente eltrica I ampre A
Intensidade luminosa J candela cd
Grandeza, dimenso e unidade no so sinnimos e devido

ubiquidade da sua utilizao em modelagem, so conceitos que de-
vem estar muito bem denidos na mente de todo modelador.
Unidades derivadas de nomes prprios (e.g. Lord Kelvin,

tabela 6.2),tm seu smbolo maisculo, mas o nome da unidade
grafado em minsculas.
As dimenses de variveis e parmetros utilizados em um mo-

delo podem representar dimenses fsicas diretamente mensurveis
do sistema, como massa, comprimento, etc. ou podem ser constru-
tos do investigador, que visam representar propriedades do sistema
que interessam ao modelo (preo, periculosidade, fecundidade etc.).
Devido a isso, antes de comear um trabalho de modelagem, deve-
mos denir quais so as nossas dimenses bsicas. Estas dimenses
so escolhidas de forma a que todas as outras dimenses utilizadas
no modelo, possam ser expressas em termos destas dimenses b-
sicas, ou seja, atravs de operaes algbricas entre as dimenses
bsicas. A tabela 6.2 lista algumas dimenses bsicas que podem
ser teis no contexto da modelagem de sistemas biolgicos.
Vrias dimenses derivadas podem ser construdas a partir do
limitado conjunto de dimenses bsicas apresentado na tabela 6.2.
Tabela 6.3: Dimenses derivadas.
Grandeza fsica Dimenso Unidade (SI) Smbolo

(derivao)
rea L2 metro2 m2
Volume L3 metro3 m3
Velocidade LT 1 metro/segundo m/s
Acelerao LT 2 metro/segundo2 m/s2
Fora M LT 2 newton N (kg m s2 )
Energia M L2 T 2 joule J (kg m2 s2 )
Potncia M L2 T 3 watt W (kg m2 s3 )
Presso M L1 T 2 pascal P a (N m2 )
Viscosidade M L1 T 1 101 poise P
Voltagem M L2 T 3 I 1 volt V
Resistncia elt. M L2 T 3 I 2 ohm (V /A)
ngulo graus, radianos graus, radianos
Veloc. angular T 1 radianos/seg. radianos/s
Frequncia T 1 hertz Hz (s1 )
A tabela 6.3 lista dimenses familiares ao leitor e suas derivaes.

interessante notar que algumas grandezas fsicas so adimen-
sionais (e.g. ngulo, tabela 6.3). Este fato no as impede, entre-
tanto, de possuir unidades.
Um ngulo calculado como a razo entre um dado arco e

o raio da circunferncia que o dene. Portanto, sua dimenso
L/L = 1.
O fato de um ngulo ser adimensional, faz com que seu valor

numrico no se altere, ao se utilizar diferentes unidades de medida
para o raio e o arco da circunferncia que o contm. Funes trigo-
nomtricas so adimensionais pois o argumento destas um ngulo,
que adimensional. O expoente de uma funo exponencial nada
mais do que um logaritmo, e se os logaritmos so adimensionais,
os expoentes tambm o sero.
Outros adimensionais:
Funes trigonomtricas,
Expoentes,
Logaritmos,
Contagens,
, e, etc.
Por exemplo, em uma equao de crescimento exponencial y=

ekt , onde t o tempo, o parmetro k deve ter dimenso T 1 para
que o expoente seja adimensional.
Anlise Dimensional
Um modo eciente de evitar erros dimensionais na construo das

equaes que compem o nosso modelo, consiste em construir uma
verso da equao em questo, substituindo-se as variveis e par-
metros por suas unidades ou dimenses. Em seguida, expande-se
as expresses em ambos os lados da igualdade em termos das di-
menses bsicas. Ento simplicamos ao mximo os dois lados da
equao e vericamos se so de fato iguais. A este processo d-se
o nome de anlise dimensional.
Todas as equaes cientcas devem estar dimensionalmente
corretas, assim sendo, a anlise dimensional uma excelente fer-
ramentar para analisar nossas formulaes. Vamos listar algumas
regras bsicas da anlise dimensional:
1. Dimenses e unidades podem ser combinadas e manipuladas,

utilizando-se regras algbricas.
2. Os dois lados de uma equao devem ser dimensionalmente

idnticos.
3. Deve-se tomar cuidado para no cancelar unidades idnticas

ml CO2
de objetos independentes. Por exemplo,
ml sangue no uma
expresso adimensional, apesar de ser uma razo entre dois

volumes.
4. Grandezas de dimenses diferentes no podem ser somadas

nem subtradas.
Unidades tambm podem ser utilizadas, diretamente, em an-

lise dimensional. Unidades derivadas podem ser construdas a par-
tir de unidades bsicas. Porm, frequentemente, as unidades deri-
vadas recebem smbolos especiais para simplicar sua notao (e.g.
N, W, J etc. na tabela 6.3).
O Pacote Unum
5 Quando escrevemos nossos modelos em Python, podemos fazer
uso de unidades para nossas variveis de forma a no cometer erros
quanto s dimenses do nosso problema. Vamos explorar algumas
possibilidades interativamente dentro do Ipython.
1 In [1]: from unum . u n i t s import
2 In [ 2 ] :M
3 Out [ 2 ] : 1 . 0 [m]
Uma vez importadas as unidades do mdulo units, podemos

representar nmeros com unidades. No exemplo acima temos a
representao de 1 metro. As classes que representam as unida-
des so derivadas das classes que representam os nmeros puros
em Python; portanto, todas as operaes aritmticas vlidas para
nmeros, so possveis para nmeros com unidades. O Unum vem
com muitas unidades pr denidas, mas estas podem ser redeni-
das, durante a sesso, assim como novas unidades podem ser de-
nidas. Todas as unidades prdenidas so denidas em maisculas
para facilitar a sua diferenciao de nomes associados a variveis.
5O pacote Unum pode ser baxado de http://home.scarlet.be/be052320/

Unum.html.
Qualquer grandeza pode ser denida multiplicando-se um nmero
por uma unidade.
1 In [ 3 ] : a=3M
2 In [ 4 ] : t =1 S
3 In [ 5 ] : a/ t
4 Out [ 5 ] : 3 . 0 [m/ s ]
5 In [ 6 ] : 1 / ( 3 M/ S )
6 Out [ 6 ] : 0 . 3 3 3 3 3 3 3 3 3 3 3 3 [ s /m]
7 In [ 7 ] : 2 5 M 2
8 Out [ 7 ] : 2 5 . 0 [ m2 ]
9 In [ 8 ] : ( 3 M) ( 4 M)
10 Out [ 8 ] : 1 2 . 0 [ m2 ]
11 In [ 9 ] : 1 3 KGM/ S 2
12 Out [ 9 ] : 1 3 . 0 [ kg .m/ s 2 ]
Grandeza adimensionais tambm podem ser representadas.
1 In [10]:(2 M/ S ) (3 S /M)
2 Out [ 1 0 ] : 6 . 0 []
Agora que j aprendemos a operar com unidades, vamos imple-

mentar um simples modelo com unidades.
1 In [ 1 1 ] : massa = 1 . 5 KG
2 In [ 1 2 ] : v e l o c i d a d e =2M/ S
3 In [ 1 3 ] : e n e r g i a _ c i n e t i c a =( massa v e l o c i d a d e
2 ) /2
4 In [ 1 4 ] : energia_cinetica
5 Out [ 1 4 ] : 3 . 0 [ kg . m2/ s 2 ]
Evitando Erros
Utilizar unidades no apenas uma questao esttica, tambm pode
ajudar a evitar enganos:
1 In [ 1 5 ] : e n e r g i a _ c i n e t i c a +3KG
2 DimensionError : [ kg . m2/ s 2 ] incompatible with
[ kg ]
3 In [ 1 6 ] :MKG
4 DimensionError : unit [ kg ] unexpected
No exemplo acima, somos lembrados de que no podemos somar

grandezas com unidades diferentes, nem elevar metros a quilogra-
mas! Expoentes devem sempre ser adimensionais.
Tambm podemos fazer converses de unidades. Vamos con-
verter nossa energia cintica em joules:
1 In [ 1 7 ] : e n e r g i a _ c i n e t i c a . as ( J )
2 Out [ 1 7 ] : 3 . 0 [J]
Integrao com Funes Matemticas

J vimos que logaritmos e ngulos so adimensionais; portanto fun-
es logartmicas e trigonomtricas no aceitam nmeros com uni-
dades. No caso dos ngulos podemos usar pseudo-unidades como
RAD(radianos) e ARCDEG(graus).
1 In [18]: from math import pi , log10 , sin , cos
2 In [ 1 9 ] : l o g 1 0 (M/ANGSTROM)
3 Out [ 1 9 ] : 1 0 . 0
4 In [ 2 0 ] : c o s ( 1 8 0 ARCDEG)
5 Out [ 2 0 ] : 1.0
6 In [ 2 4 ] : c o s ( p i RAD)
7 Out [ 2 4 ] : 1.0
8 In [ 2 5 ] : f = 4 4 0 HZ
9 In [ 2 6 ] : sin ( f )
10 DimensionError : unit [ Hz ] unexpected
11 In [ 2 7 ] : dt = 0 . 1 S
12 In [ 2 8 ] : s i n ( f dt 2 p i )
13 Out [ 2 8 ] : 3 . 9 1 9 8 2 4 5 3 4 4 0 4 0 9 2 7 e 14
As unidade do Unum tambm funcionam bem com outras estru-
turas de dados, como matrizes do Numpy, por exemplo.
1 In [1]: from unum . u n i t s import

2 In [2]: from numpy import
3 In [ 3 ] : a= a r a n g e ( 1 0 ) M
4 In [4]:a
5 Out [ 4 ] :
6 array ( [ 0 . 0 [m] , 1.0 [m] , 2.0 [m] , 3.0 [m] ,
4.0 [m] , 5.0 [m] , 6.0 [m] ,
7 7.0 [m] , 8.0 [m] , 9.0 [m ] ] , d t y p e=
object )
8 In [ 5 ] : a 2
9 Out [ 5 ] :
10 array ( [ 0 . 0 [ m2 ] , 1.0 [ m2 ] , 4.0 [ m2 ] , 9.0 [ m2
] , 16.0 [ m2 ] , 25.0 [ m2 ] ,
11 36.0 [ m2 ] , 49.0 [ m2 ] , 64.0 [ m2 ] , 81.0
[ m2 ] ] , d t y p e=o b j e c t )
Por m, o Unum tambm simplica automticamente expres-

ses de unidades. No exemplo abaixo, o Unum sabe que uma presso
multiplicada por uma rea uma fora. Portanto, converte a uni-
dade para Newtons (N).
1 In [ 6 ] : f o r c a = PA M 2
2 In [ 7 ] : forca
3 Out [ 7 ] : 1 . 0 [N]
Conforme j mencionamos, tambm podemos criar novas uni-

dades. Vejamos abaixo como fazer isso:
Listagem 6.4: Criando novas unidades.
1 In [1]: from unum import Unum

2 In [ 2 ] : u n i t = Unum . u n i t
3 In [ 3 ] : LEGUA = u n i t ( ' l e g u a ' )
4 In [ 4 ] : LEGUA
5 Out [ 4 ] : 1 . 0 [ legua ]
6 In [ 5 ] : KLEGUA = u n i t ( ' k i l o l e g u a ' , 1 0 0 0 LEGUA)
7 In [ 6 ] : 2 0 KLEGUA+1LEGUA
8 Out [ 6 ] : 2 0 . 0 0 1 [ kilolegua ]
Uma Aplicao Concreta

Muitas vezes, ao modelar um sistema biolgico, a relao entre
grandezas biolgicas e fsicas no bvia. Nestes casos, a anlise
dimensional pode ajudar a validar nossas formulaes. Suponha
que um pesquisador deseje determinar o trabalho realizado pelo
corao. Ele se lembra da fsica que:
T rabalho(J) = F orca(N ) distancia(m)
Esta equao no diretamente aplicvel ao corao, pois este no

se desloca e a fora que exerce no facilmente mensurvel. Con-
tudo, a fora exercida pelo corao se reete na presso sangunea,
e o volume de sangue bombeado parece ser anlogo distncia
da frmula original. Ento nosso pesquisador-modelador escreve,
timidamente, a seguinte frmula:
T rabalho = P ressao V olume
Mas como saber se esta relao correta? Fazendo a anlise di-

mensional.
N
T rabalho(J) = P ressao V olume = m3 = N m = J
m2
Esta denio de Trabalho (N m), no a mesma da tabela 6.3
mas um pouco de lgebra pode demonstrar a sua validade . Com
6
o Unum, isso seria uma tarefa trivial:
6 Lembre-se de que Trabalho=Energia.

1 In [ 8 ] : J == PA M 3
2 Out [ 8 ] : True
Para que uma anlise dimensional funcione com unidades, de-

vemos nos manter em um mesmo sistema de unidades. O sistema
utilizado em cincia o chamado Sistema Internacional (SI). As
unidades apresentadas nas tabelas 6.2 e 6.3 esto de acordo com o
SI.
Um detalhe em relao a unidades que frequentemente mal
entendido, a aplicao de fatores de escala normalmente expressos
como prexos s unidades (ver tabela 6.4). Devido a este fato o
SI frequentemente denominado sistema MKS (metro, kilograma,
segundo). Um outro sistema que frequentemente confundido com
o SI o CGS (centmetro, grama, segundo). Apesar deste ltimo se
diferenciar do SI apenas nos prexos, um sistema completamente
diferente.
MKS vs. CGS
Fora(MKS):
Newton (m kg/s2 )
Fora(CGS):
Dyne (cm g/s2 )
Ao adicionar ou modicar prexos de unidades estamos aban-

donando nosso sistema de unidades original e nossas equaes no
estaro mais equilibradas dimensionalmente, a menos que realize-
mos as correes necessrias nos demais termos da equao.
Para re-equilibrar dimensionalmente equaes cujas unidades
de uma ou mais de suas variveis tenham sido modicadas, preci-
samos incluir fatores de correo.
Consideremos a relao entre a massa corporal e a massa do
Corao:
Y = 0.006M
Tabela 6.4: Prexos de Unidades
Prexo Smbolo Fator Prexo Smbolo Fator

yocto y 1024 deca da 10
zepto z 1021 hecto h 102
atto a 1018 kilo k 103
femto f 1015 mega M 106
pico p 1012 giga G 109
nano n 109 tera T 1012
micro 106 peta P 1015
mili m 103 exa E 1018
centi c 102 zetta Z 1021
deci d 101 yotta Y 1024
colocando esta equao em termos dimensionais:
M =1M
se quisermos expressar a massa do corao em gramas (CGS), man-

tendo a massa corporal em kg (SI/MKS), basta apenas multiplicar-
mos o lado direito da equao por 1000 para reequilibrar a equao.
Assim, teramos:
Y = 6M
Contudo, nem sempre a determinao dos fatores de correo
to bvia. Vejamos a seguinte equao, que relaciona a massa do
fgado com a massa corporal (ambas em kg):
Mf = 0.082 Mc0.87 (6.2)
Esta relao se mantm, para mamferos, ao longo de vrias ordens

de magnitude de tamanho. Se estivssemos interessados apenas em
pequenos roedores, seria mais conveniente trabalhar com gramas ao
invs de kilogramas. O investigador desavisado, determina a massa
de um hamster (200g), o aplica na equao 6.2: e obtm o seguinte
resultado:
Mf = 8.24
Este valor no seria correto nem em gramas e muito menos em
kg! O que poderia estar errado? Por desencargo de conscincia,
ele decide realizar o clculo novamente aplicando a massa em kg
(0.2kg):
Mf = 0.020kg
este resultado (20g) parece mais realstico. Analisando dimensio-
nalmente a equao, podemos entender o que deu errado em nossa
converso de unidades:
Mf = 0.082 (1000 Mc )0.87
Se esta equao possui apenas duas variveis, ambas de massa,

porque a simples substituio de unidades no funciona? A res-
posta est no fato de que a massa corporal est elevada a 0.87,
portanto sua unidade no mais Kg, da mesma forma que 1 metro
quadrado no igual a 1 metro. Para a equao ser vlida dimen-
sionalmente, a constante 0.082 no pode ser adimensional. Para
descobrir a sua unidade basta rearranjarmos a equao,
Mf
= 0.082
Mc0.87
e resolv-la com o Unum. Como vemos a unidade de nossa constante
kg 0.13 .
1 In [ 1 3 ] : KG/KG 0 . 8 7
2 Out [ 1 3 ] : 1 . 0 [ kg0 . 1 3 ]
se quisermos multiplicar a unidade da massa do corao por 1000

(Kg g ), temos que multiplicar a unidade da constante por 1000
tambm e isso representa multiplic-la por 10000.13 . Podemos ve-
ricar que esta operao retorna um nmero 1000 vezes o valor em
Kg, ou seja, o valor em gramas.
6.4. EXERCCIOS 167
1 In [ 2 0 ] : 1 0 0 0 0 . 1 3 KG 0 . 1 3 1 0 0 0 0 . 8 7 KG
0.87
2 Out [ 2 0 ] : 1 0 0 0 . 0 [ kg ]
3 In [21]:0.082(10000.13) (2000.87)
4 Out [ 2 1 ] : 2 0 . 2 1 6 6 8 5 1 9 9 7 9 1 5 6 3
6.4 Exerccios
1. Determine as dimenses das seguintes grandezas (manual-
mente e depois utilizando o Unum):
a) Volume
b) Acelerao (velocidade/tempo)
c) Densidade (massa/volume)
d) Fora (massa acelerao)
e) Carga eltrica (corrente tempo)
2. Utilizando as repostas da questo anterior determine as di-

menses das seguintes grandezas:
a) Presso (fora/rea)
2
b) (volume)
c) Campo eltrico (fora/carga eltrica)
d) Trabalho (fora distncia)
e) Energia Potencial Gravitacional (= mgh =massa ace-

lerao gravitacional altura)
Captulo 7
Teoria de Grafos
Breve introduo a teoria de grafos e sua representao
computacional. Introduo ao Pacote NetworkX, vol-
tado para a manipulao de grafos. Pr-requisitos:
Programao orientada a objetos.
7.1 Introduo
A teoria de grafos uma disciplina da matemtica cujo objeto de
estudo se presta, muito bem, a uma representao computacional
como um objeto. Matematicamente, um grafo denido por um
conjunto nito de vrtices (V ) e por um segundo conjunto (A) de
relaes entre estes vrtices, denominadas arestas. Grafos tem apli-
caes muito variadas, por exemplo: uma rvore genealgica um
grafo onde as pessoas so os vrtices e suas relaes de parentesco
so as arestas do grafo.
Um grafo pode ser denido de forma no ambgua, por sua lista
de arestas (A), que implica no conjunto de vrtices que compem
o grafo. Grafos podem ser descritos ou mensurados atravs de um
conjunto de propriedades:
Grafos podem ser direcionados ou no;
169
170 CAPTULO 7. TEORIA DE GRAFOS
A ordem de um grafo corresponde ao seu nmero de vrtices;
O tamanho de um grafo corresponde ao seu nmero de ares-

tas;
Vrtices, conectados por uma aresta, so ditos vizinhos ou

adjacentes ;
A ordem de um vrtice corresponde ao seu nmero de vizi-
nhos;
Um caminho uma lista de arestas que conectam dois vrti-

ces;
Um ciclo um caminho que comea e termina no mesmo

vrtice;
Um grafo sem ciclos denominado acclico.

A lista acima no exaure as propriedades dos grafos, mas
suciente para esta introduo.
Podemos representar um grafo como um objeto Python de v-
rias maneiras, dependendo de como desejamos utiliz-lo. A forma
mais trivial de representao de um grafo em Python seria feita
utilizando-se um dicionrio. A Listagem 7.1 mostra um dicionrio
representando o grafo da gura 7.1. Neste dicionrio, utilizamos
como chaves os vrtices do grafo associados a suas respectivas listas
de vizinhos. Como tudo em Python um objeto, poderamos j
nos aproveitar dos mtodos de dicionrio para analisar nosso grafo
(Listagem 7.2).
Listagem 7.1: Denindo um grafo como um dicionrio.
1 >>> g = { ' a ' : [ ' c ' , ' d ' , ' e ' ] , ' b ' : [ ' d ' , ' e ' ] , ' c '
: [ 'a ' , 'd ' ] , 'd ' : [ 'b ' , ' c ' , 'a ' ] , ' e ' : [ 'a ' , 'b
' ]}
7.1. INTRODUO 171
Figura 7.1: Um grafo simples.
Podemos utilizar o mtodo keys para obter uma lista dos vr-
tices de nosso grafo.
Listagem 7.2: Obtendo a lista de vrtices.
1 >>> g . k e y s ( )
2 [ 'a ' , 'c ' , 'b ' , 'e ' , 'd ' ]
Uma extenso do conceito de grafos o conceito de redes. Redes

so grafos nos quais valores numricos so associados s suas ares-
tas. Redes herdam as propriedade dos grafos e possuem algumas
propriedades especcas.
A representao de redes, a partir de objetos pitnicos simples,
como um dicionrio, tambm possivel. Porm, para dar mais
alcance aos nossos exemplos sobre teoria de grafos, vamos nos uti-
lizar do pacote NetworkX1 que j implementa uma representao
bastante completa de grafos e redes em Python.
7.2 NetworkX
O pacote NetworkX se presta criao, manipulao e estudo da
estrutura, dinmica e funes de redes complexas.
A criao de um objeto grafo a partir de seu conjunto de ares-
tas,A, muito simples. Seja um grafo G com vrtices V =
{W, X, Y, Z}:
G : A = {(W, Z), (Z, Y ), (Y, X), (X, Z)}
Listagem 7.3: Denindo um grafo atravs de seus vrtices

g r a p h 1 . py
2 import networkx a s NX
3
4 G = NX. Graph ( )
5 G . add_edges_from ( [ ( 'W' , ' Z ' ) , ( ' Z ' , 'Y ' ) , ( 'Y ' , '
X ' ) , ( 'X ' , ' Z ' ) ] )
6 print G. n o d e s ( ) , G. e d g e s ( )
Executando o cdigo acima, obtemos:
[0 Y 0 ,0 X 0 ,0 Z 0 ,0 W 0 ][(0 Y 0 ,0 X 0 ), (0 Y 0 ,0 Z 0 ), (0 X 0 ,0 Z 0 ), (0 Z 0 ,0 W 0 )]
Ao lidar com grafos, conveniente represent-los gracamente.

Vejamos como obter o diagrama do grafo da listagem 7.3:
Listagem 7.4: Diagrama de um grafo
1 https://networkx.lanl.gov/
7.2. NETWORKX 173

g r a p h 2 . py
3
4 G = NX. Graph ( )
5 G . add_edges_from ( [ ( 'W' , ' Z ' ) , ( ' Z ' , 'Y ' ) , ( 'Y ' , '
X ' ) , ( 'X ' , ' Z ' ) ] )
6
7 import pylab as P
8 NX. draw (G)
9 P . show ( )
A funcionalidade do pacote NetworkX bastante ampla. A

seguir exploraremos um pouco desta funcionalidade.
Construindo Grafos
O NetworkX oferece diferentes classes de grafos, dependendo do tipo

de aplicao que desejada. Abaixo, temos uma lista dos comandos
para criar cada tipo de grafo.
G=Graph() Cria um grafo simples e vazio G.

G=DiGraph() Cria grafo direcionado e vazio G.
G=XGraph() Cria uma rede vazia, ou seja, com arestas que po-
dem receber dados.
G=XDiGraph() Cria uma rede direcionada.

G=empty_graph(n) Cria um grafo vazio com n vrtices.
G=empty_graph(n,create_using=DiGraph()) Cria um grafo
direcionado vazio com n vrtices.
G=create_empty_copy(H) Cria um novo grafo vazio do mesmo

tipo que H.
Figura 7.2: Diagrama de um grafo
Manipulando Grafos
Uma vez de posse de um objeto grafo instanciado a partir de uma

das classes listadas anteriormente, de interesse poder manipul-lo
de vrias formas. O prprio objeto dispe de mtodos para este
m:
G.add_node(n) Adiciona um nico vrtice a G.
G.add_nodes_from(lista) Adiciona uma lista de vrtices a G.
G.delete_node(n) Remove o vrtice n de G.
G.delete_nodes_from(lista) Remove uma lista de vrtices de

G.
7.2. NETWORKX 175
G.add_edge(u,v) Adiciona a aresta (u,v) a G. Se G for um

grafo direcionado, adiciona uma aresta direcionada u v .
Equivalente a G.add_edge((u,v)).
G.add_edges_from(lista) Adiciona uma lista de arestas a G.
G.delete_edge(u,v) Remove a aresta (u,v).

G.delete_edges_from(lista) Remove uma lista de arestas de
G.
G.add_path(listadevertices) Adiciona vrtices e arestas de forma

a compor um caminho ordenado.
G.add_cycle(listadevertices) O mesmo que add_path, exceto

que o primeiro e o ltimo vrtice so conectados, formando
um ciclo.
G.clear() Remove todos os vrtices e arestas de G.
G.copy() Retorna uma cpia rasa do grafo G.

2
G.subgraph(listadevertices) Retorna subgrafo correspondente

lista de vrtices.
Criando Grafos a Partir de Outros Grafos
subgraph(G, listadevertices) Retorna subgrafo de G correspon-

dente lista de vrtices.
union(G1,G2) Unio de grafos.
disjoint_union(G1,G2) Unio disjunta, ou seja, assumindo que

todos os vrtices so diferentes.
2 Uma cpia rasa signica que se cria um novo objeto grafo referenciando
o mesmo contedo. Ou seja, se algum vrtice ou aresta for alterado no grafo
original, a mudana se reete no novo grafo.
cartesian_product(G1,G2) Produto cartesiano de dois grafos
(Figura 7.3).
compose(G1,G2) Combina grafos, identicando vrtices com mesmo

nome.
complement(G) Retorna o complemento do grafo(Figura 7.3).
create_empty_copy(G) Cpia vazia de G.
convert_to_undirected(G) Retorna uma cpia no direcionada

de G.
convert_to_directed(G) Retorna uma cpia no direcionada

de G.
convert_node_labels_to_integers(G) Retorna uma cpia com

os vrtices renomeados como nmeros inteiros.
Gerando um Grafo Dinamicamente
Muitas vezes, a topologia da associao entre componentes de um

sistema complexo no est dada a priori. Frequentemente, esta
estrutura dada pela prpria dinmica do sistema.
No exemplo que se segue, simulamos um processo de contgio
entre os elementos de um conjunto de vrtices, observando ao nal,
a estrutura produzida pelo contgio.
Listagem 7.5: Construindo um grafo dinamicamente

g r a f o d i n . py
3 import t h r e a d i n g , random , pylab as P
4
5 class Contagio :
7.2. NETWORKX 177
Figura 7.3: Grafo, produto cartesiano e complemento.
6 def __init__ ( s e l f , nome ) :

7 s e l f . nome = nome
8 s e l f . doente = 0
9 s e l f . transmite ()
10 def transmite ( s e l f ) :
11 if G . d o e n t e s == G . o r d e r ( ) :
12 return
13 for a l v o in random . s a m p l e (G . n o d e s ( )
,3) :
14 i f not alvo . doente :
15 G . add_edge ( ( s e l f , a l v o ) )
16 print "%s i n f e c t o u %s "%( s e l f
. nome , a l v o . nome )
17 t = t h r e a d i n g . Thread ( t a r g e t=
alvo . contraiu () )
18 t . start ()
19 def contraiu ( s e l f ) :
20 s e l f . d o e n t e +=1
21 G . d o e n t e s +=1
22 s e l f . transmite ()
23
24 G = NX. XDiGraph ( )
25 G . d o e n t e s = 0
26 nos = [ Contagio ( n ) for n in xrange (80) ]
27 G . add_nodes_from ( n o s )
28 c a s o _ i n d i c e = G. n o d e s ( ) [ 0 ]
29 caso_indice . contraiu ()
30 print " usamos %s das arestas p o s s i v e i s "%(NX.
d e n s i t y (G) )
31 print NX. d e g r e e _ h i s t o g r a m (G) , G . d o e n t e s
32 nomes = d i c t ( [ ( no , no . nome ) for no in G. n o d e s
() ])
33 NX. draw (G, l a b e l s =nomes , a l p h a = 0 . 7 , w i d t h =2 ,
s t y l e= ' d o t t e d ' , n o d e _ s i z e =450 , font_size
=14)
34 P . s a v e f i g ( ' c o n t a g i o . png ' , d p i =400)
35 P . show ( )
Mdulo threading: Permite executar mais de uma parte do

programa em paralelo, em um o de execuo independente.
Este os, compartilham todas as variveis globais e qualquer
alterao nestas imediatamente visvel a todos os outros os.
O objeto grafo do NetworkX aceita qualquer objeto como um

vrtice. Na listagem 7.5, nos valemos deste fato para colocar ins-
7.2. NETWORKX 179
tncias da classe Contagio como vrtices do grafo G. O grafo G

contrudo somente por vrtices (desconectado). Ento infectamos
um vrtice do grafo, chamando o seu mtodo contraiu(). O vr-
tice, aps declarar-se doente e incrementar o contador de doentes
a nvel do grafo, chama o mtodo transmite().
O mtodo transmite assume que durante seu perodo infec-
cioso, cada vrtice tem contatos efetivos com apenas dez outros
vrtices. Ento cada vrtice ir transmitir para cada um destes,
desde que no estejam j doentes.
Cada vrtice infectado inicia o mtodo contraiu em um th-
read separado. Isto signica que cada vrtice sai infectando os
restantes, em paralelo. Na verdade, como o interpretador Python
s executa uma instruo por vez, cada um destes objetos recebe
do interpretador uma fatia de tempo por vez, para executar suas
tarefas. Pode ser que o tempo de uma destas fatias seja suciente
para infectar a todos no seu grupo, ou no. Depois que o processo
se desenrola, temos a estrutura do grafo como resultado (Figura
7.4)
Construindo um Grafo a Partir de Dados
O conceito de grafos e redes extremamente til na representao

e anlise de sistemas complexos, com muitos componentes que se
relacionam entre si. Um bom exemplo uma rede social, ou seja,
uma estrutura de interao entre pessoas. Esta interao pode
ser medida de diversas formas. No exemplo que se segue, vamos
tentar inferir a rede social de um indivduo, por meio de sua caixa
de mensagens.
Listagem 7.6: Construindo uma rede social a partir de e-mails

mnet . py
2 import email , sys
3 import email . Errors
Figura 7.4: Resultado da simulao do exemplo 7.5.
4 import m a i l b o x
5 import n e t w o r k x a s NX
6 from p y l a b import show
7
8 def msgfactory ( fp ) :
9 try :
10 return e m a i l . m e s s a g e _ f r o m _ f i l e ( f p )
11 except e m a i l . E r r o r s . M e s s a g e P a r s e E r r o r :
12 return ' '
13
14 def s t a r G ( mess , G) :
15 try :
7.2. NETWORKX 181
16 c e n t r o = me s s . g e t ( ' f r o m ' ) . s p l i t ( )
[ 1]. s t r i p ( '<> ' )
17 pontas = [ j . s p l i t () [ 1]. s t r i p ( '<> ' )
for j in m es s . g e t _ a l l ( ' t o ' ) [ 0 ] .
split ( ' , ') ]
18 arestas = [ ( centro , k) for k in
pontas ]
19 G . add_edges_from ( a r e s t a s )
20 return G
21 except :
22 print ' f a l h o u '
23
24 d i r= ' /home/ f l a v i o / M a i l / i n b o x '
25 # V e j a documentacao do modulo mailbox
26 # p a r a outros tipo de mailboxes .
27 mbox = m a i l b o x . M a i l d i r ( d i r , msgfactory ) #
mailbox do kmail
28 G = NX. DiGraph ( )
29 for n in xrange (50) :
30 i = mbox . n e x t ( )
31 s t a r G ( i , G)
32 print G. n o d e s ( )
33 G = NX. c o n v e r t _ n o d e _ l a b e l s _ t o _ i n t e g e r s (G)
34 NX. draw (G, w i d t h =2 , s t y l e= ' d o t t e d ' , alpha
=0.5)
35 show ( )
Na Listagem 7.6, usamos dois mdulos interessantes da bibli-

oteca padro do Python: O mdulo email e o mdulo mailbox.
mailbox.
Mdulo email: Mdulo para decodicar, manusear, e com-

por emails.
Mdulo mailbox: Conjuto de classes para lidar com caixas

de correio no formato Unix, MMDF e MH.
Neste exemplo, utilizei a minha mailbox associada com o pro-

grama Kmail; portanto, se voc usa este mesmo programa, basta
substituir o diretrio de sua mailbox e o programa ir funcionar
para voc. Caso use outro tipo de programa de email, consulte a
documentaao do Python para buscar a forma correta de ler o seu
mailbox.
A classe Maildir retorna um iterador, que por sua vez, retor-
nar mensagens decodicadas pela funo msgfactory, denida por
ns. Esta funo se utiliza do mdulo email para decodicar a
mensagem.
Cada mensagem recebida processada para gerar um grafo do
tipo estrela, com o remetente no centro e todos os destinatrios
da mensagem nas pontas. Este grafo ento adicionado ao grafo
original, na forma de uma lista de arestas. Depois de todas as
mensagens terem sido assim processadas, geramos a visualizao
do grafo (Figura 7.5).
7.3 Exerccios
1. Determine o conjunto de arestas A que maximiza o tamanho
do grafo cujos vrtices so dados por V = {a, b, c, d, e}.
2. No exemplo do contgio, verique se existe alguma relao

entre o tamanho da amostra de cada vrtice e a densidade
nal do grafo.
3. Ainda no exemplo do contgio, refaa o experimento com um

grafo de topologia dada a priori no qual os vrtices s podem
infectar seus vizinhos.
7.3. EXERCCIOS 183
Figura 7.5: Rede social a partir de mensagens de email.
4. Insira um print no lao for do exemplo 7.6 para ver o formato

de sada do iterador mbox.
5. Modique o programa 7.6 para associar apenas mensagens

que contm uma palavra em comum.
Captulo 8
Interao com Bancos de

Dados
Apresentao dos mdulos de armazenamento de dados
Pickle e Sqlite3 que fazem parte da distribuio padro
do Python. Apresentao do pacote SQLObject para
comunicao com os principais sistemas de bancos de
dados existentes. Pr-requisitos: Conhecimentos b-
sicos de bancos de dados e SQL.
O gerenciamento de dados no se constitui numa disciplina cien-

tca per se. Entretanto, cada vez mais, permeia as atividades
bsicas de trabalho cientco. O volume crescente de dados e o au-
mento de sua complexidade h muito ultrapassou a capacidade de
gerenciamento atravs de simples planilhas.
Atualmente, muito comum a necessidade de se armazenar da-
dos quantitativos, qualitativos e mdias dos mais diferentes forma-
tos(imagens, vdeos, sons) em uma plataforma integrada de onde
possam ser facilmente acessados para ns de anlise, visualizaco
ou simplesmente consulta.
A linguagem Python dispe de solues simples para resolver
esta necessidade em seus mais distintos nveis de sosticao. Se-
guindo a losoa de baterias includas do Python, a sua biblioteca
185
186 CAPTULO 8. INTERAO COM BANCOS DE DADOS
padro nos apresenta o mdulo Pickle e cPickle e, a partir da verso
2.5, o banco de dados relacional sqlite3.
8.1 O Mdulo Pickle

O mdulo pickle e seu primo mais veloz cPickle, implementam
algoritmos que permitem armazenar, em um arquivo, objetos im-
plementados em Python.
Listagem 8.1: Exemplo de uso do mdulo pickle

1 In [1]: import p i c k l e
2 In [ 2 ] : class o i :
3 .2.: def d i g a o i ( s e l f ) :
4 .2.: print " o i "
5 In [ 3 ] : a= o i ( )
6 In [ 4 ] : f = o p e n ( ' p i c t e s t e ' , 'w ' )
7 In [ 5 ] : p i c k l e . dump ( a , f )
8 In [ 6 ] : f . close ()
9 In [ 7 ] : f = open ( ' p i c t e s t e ' , ' r ' )
10 In [ 8 ] : b=p i c k l e . l o a d ( f )
11 In [ 9 ] : b . digaoi ()
12 oi
Como vemos na listagem 8.1, com o mdulo pickle podemos arma-

zenar objetos em um arquivo, e recuper-lo sem problemas para uso
posterior. Contudo, uma caracterstica importante deste mdulo
no ca evidente no exemplo 8.1. Quando um objeto armaze-
nado por meio do mdulo pickle, nem o cdigo da classe, nem
seus dados, so incluidos, apenas os dados da instncia.
1 In [10]: class oi :
2 .10.: def d i g a o i ( s e l f , nome= ' f l a v i o ' ) :
3 .10.: print ' o i %s ! '%nome
4
5 In [ 1 1 ] : f = open ( ' p i c t e s t e ' , ' r ' )
8.2. O MDULO SQLITE3 187
6 In [ 1 2 ] : b=p i c k l e . l o a d ( f )
7 In [ 1 3 ] : b . digaoi ()
8 oi flavio !
Desta forma, podemos modicar a classe, e a instncia arma-

zenada reconhecer o novo cdigo ao ser restaurada a partir do
arquivo, como podemos ver acima. Esta caracterstica signica
que os pickles no se tornam obsoletos quando o cdigo em que
foram baseados atualizado (naturalmente isto vale apenas para
modicaes que no removam atributos j includos nos pickles).
O mdulo pickle no foi construdo para armazenamento de
dados, pura e simplesmente, mas de objetos computacionais com-
plexos, que podem conter em si, dados. Apesar desta versatilidade,
peca por consistir em uma estrutura de armazenamento legvel ape-
nas pelo prprio mdulo pickle em um programa Python.
8.2 O mdulo Sqlite3

Este mdulo passa a integrar a biblioteca padro do Python a partir
da verso 2.5. Portanto, passa a ser uma excelente alternativa
para usurios que requerem a funcionalidade de um banco de dados
relacional compatvel com SQL1 .
O Sqlite nasceu de uma biblioteca em C que disponibilizava
um banco de dados extremamente leve e que dispensa o conceito
servidor-cliente. No sqlite, o banco de dados um arquivo ma-
nipulado atravs da biblioteca sqlite.
Para utilizar o sqlite em um programa Python, precisamos im-
portar o mdulo sqlite3.
1 In [1]: import sqlite3
1 SQL signica Structured Query Language. o SQL um padro internaci-

onal na interao com bancos de dados relacionais. Para saber mais, consulte
http://pt.wikipedia.org/wiki/SQL
O prximo passo a criao de um objeto conexo, atravs
do qual podemos executar comandos SQL.
1 In [2]: c = s q l i t e 3 . c o n n e c t ( ' /tmp/ e x e m p l o ' )
Agora dispomos de um banco de dados vazio, consistindo no

arquivo exemplo, localizado no diretrio /tmp. O sqlite tambm
permite a criao de bancos de dados em RAM; para isso basta
substituir o nome do arquivo pela string :memory:. Para po-
dermos inserir dados neste banco, precisamos primeiro criar uma
tabela.
1 In [3]: c. execute ( ' ' ' c r e a t e table especimes (

nome text , altura real , peso real ) ' ' ' )
2 Out [ 3 ] : < s q l i t e 3 . C u r s o r object at 0 x83fed10>
Note que os comandos SQL so enviados como strings atravs do

objeto Connection, mtodo execute. O comando create table
cria uma tabela; ele deve ser necessriamente seguido do nome da
tabela e de uma lista de variveis tipadas(entre parnteses), cor-
respondendo s variveis contidas nesta tabela. Este comando cria
apenas a estrutura da tabela. Cada varivel especicada corres-
ponder a uma coluna da tabela. Cada registro, inserido subse-
quentemente, formar uma linha da tabela.
1 In [4]: c. execute ( ' ' ' i n s e r t into especimes

v a l u e s ( ' tom ' , 1 2 . 5 , 2 . 3 ) ' ' '
O comando insert mais um comando SQL til para inserir

registros em uma tabela.
Apesar dos comandos SQL serem enviados como strings atravs
da conexo, no se recomenda, por questo de segurana, utilizar
os mtodos de formatao de strings ( ' ... values(%s,%s)'%(1,2))
do Python. Ao invs, deve-se fazer o seguinte:
1 In [ 5 ] : t = ( ' tom ' , )

2 In [ 6 ] : c . execute ( ' s e l e c t from especimes
where nome=? ' , t )
8.2. O MDULO SQLITE3 189
3 In [ 7 ] : c . fetchall ()
4 [ ( ' tom ' , 12.5 , 2.2999999999999998) ]
No exemplo acima utilizamos o mtodo fetchall para recupe-

rar o resultado da operao. Caso desejssemos obter um nico
registro, usaramos fetchone.
Abaixo, vemos como inserir mais de um registro a partir de
estruturas de dados existentes. Neste caso, trata-se de repetir a
operao descrita no exemplo anterior, com uma sequncia de tu-
plas representando a sequncia de registros que se deseja inserir.
1 In [ 8 ] : t = ( ( ' j e r r y ' , 5 . 1 , 0 . 2 ) , ( ' butch '

,42.4 ,10.3) )
2 In [9]: for i in t :
3 .9.: c . execute ( ' i n s e r t into especimes
values (? ,? ,?) ' , i )
O objeto cursor tambm pode ser utilizado como um iterador

para obter o resultado de uma consulta.
1 In [ 1 0 ] : c . execute ( ' s e l e c t from especimes

by peso ' )
2 In [11]: for r e g in c :
3 print r e g
4 ( ' jerry ' ,5.1 ,0.2)
5 ( ' tom ' , 12.5 , 2.2999999999999998)
6 ( ' butch ' , 4 2 . 4 , 1 0 . 3 )
O mdulo sqlite realmente verstil e til, porm, requer que

o usurio conhea, pelo menos, os rudimentos da linguagem SQL.
A soluo apresentada a seguir procura resolver este problema de
uma forma mais pitnica.
8.3 O Pacote SQLObject
O pacote SQLObject
2 estende as solues apresentadas at agora
de duas maneiras: oferece uma interface orientada a objetos para
bancos de dados relacionais e, tambm, nos permite interagir com
diversos bancos de dados sem ter que alterar nosso cdigo.
Para exemplicar o sqlobject, continuaremos utilizando o sqlite
devido sua praticidade.
Construindo um aranha digital
Neste exemplo, teremos a oportunidade de construir uma aranha

3
digital que recolher informaes da web (Wikipedia ) e as arma-
zenar em um banco sqlite via sqlobject.
Para este exemplo, precisaremos de algumas ferramentas que
vo alm do banco de dados. Vamos explorar a capacidade da
biblioteca padro do Python para interagir com a internet, e va-
mos nos utilizar de um pacote externo para decodicar as pginas
obtidas.
Listagem 8.2: Mdulos necessrios
1 # disponivel no pacote de programas como :

a r a n h a . py
2 import n e t w o r k x a s NX
3 from B e a u t i f u l S o u p import SoupStrainer ,
BeautifulSoup as BS
4 from BeautifulSoup import BeautifulStoneSoup
a s XS
5 import s y s , o s , u r l l i b 2 , urllib , re
6 from s q l o b j e c t import
2 http://www.sqlobject.org/
3 http://pt.wikipedia.org
8.3. O PACOTE SQLOBJECT 191
O pacote BeautifulSoup4 um destrinchador de pginas da

web. Um dos problemas mais comuns ao se lidar com pginas html,
que muitas delas possuem pequenos defeitos em sua construo
que nossos navegadores ignoram, mas que podem atrapalhar uma
anlise mais minuciosa. Da o valor do BeautifulSoup; ele ca-
paz de lidar com pginas defeituosas, retornando uma estrutura de
dados com mtodos que permitem uma rpida e simples extrao
da informao que se deseja. Alm disso, se a pgina foi criada
com outra codicao, o BeautifulSoup, retorna todo o contedo
em Unicode, automaticamente, sem necessidade de interveno do
usurio.
Da biblioteca padro, vamos nos servir dos mdulos sys, os,
urllib, urllib2 e re. A utilidade de cada um car clara
medida que avanarmos no exemplo.
O primeiro passo especicar o banco de dados. O sqlobject
nos permite escolher entre MySQL, PostgreSQL, sqlite, Firebird,
MAXDB, Sybase, MSSQL, ADODBAPI. Entretanto, conforme j ex-
ou
plicamos, nos restringiremos ao uso do banco sqlite.
Listagem 8.3: Especicando o banco de dados.
8 l a r a c n a d i r = os . path . expanduser ( ' ~/. l a r a c n a '

)
9 i f not os . path . e x i s t s ( l a r a c n a d i r ) :
10 o s . mkdir ( l a r a c n a d i r )
11 sqlhub . p r o c e s s C o n n e c t i o n = connectionForURI (
' s q l i t e : / / '+l a r a c n a d i r+ ' / knowdb ' )
Na listagem 8.3, criamos o diretrio(os.mkdir) onde o banco

de dados residir (se necessrio) e denimos a conexo com o
banco. Utilizamos os.path.exists para vericar se o diretrio
existe. Como desejamos que o diretrio que na pasta do usurio,
e no temos como saber, de antemo, qual este diretrio, utiliza-
4 http://www.crummy.com/software/BeautifulSoup/
mos os.path.expanduser para substituir o por /home/usuario
como aconteceria no console unix normalmente.
Na linha 11 da listagem 8.3, vemos o comando que cria a cone-
xo a ser utilizada por todos os objetos criados neste mdulo.
Em seguida, passamos a especicar a tabela do nosso banco
de dados como se fora uma classe, na qual seus atributos so as
colunas da tabela.
Listagem 8.4: Especicando a tabela ideia do banco de dados.
16 class I d e i a ( SQLObject ) :
17 nome = U n i c o d e C o l ( )
18 nlinks = IntCol ()
19 links = PickleCol ()
20 ender = StringCol ( )
A classe que representa nossa tabela herdeira da classe SQLObject.

Nesta classe, a cada atributo (coluna da tabela) deve ser atribuido
um objeto que dene o tipo de dados a ser armazenado. Neste
exemplo, vemos quatro tipos distintos, mas existem vrios outros.
UnicodeCol representa textos codicados como Unicode, ou seja,
podendo conter caracteres de qualquer lngua. IntCol corresponde
a nmeros inteiros. PickleCol um tipo muito interessante pois
permite armazenar qualquer tipo de objeto Python. O mais in-
teressante deste tipo de coluna, que no requer que o usurio
invoque o mdulo pickle para armazernar ou ler este tipo de vari-
vel, As variveis so convertidas/reconvertidas automaticamente,
de acordo com a operao. Por m, temos StringCol que uma
verso mais simples de UnicodeCol, aceitando apenas strings de
caracteres ascii. Em SQL comum termos que especicar dife-
rentes tipos, de acordo com o comprimento do texto que se deseja
armazenar em uma varivel. No sqlobject, no h limite para
o tamanho do texto que se pode armazenar tanto em StringCol
quanto em UnicodeCol
A funcionalidade da nossa aranha foi dividida em duas classes:

Crawler, que o rastejador propriamente dito, e a classe UrlFac
que constri as urls a partir da palavra que se deseja buscar na
Wikipedia.
Cada pgina puxada pelo mdulo urllib2. A funo urlencode
do mdulo urllib, facilita a adio de dados ao nosso pedido, de
forma a no deixar transparecer que este provm de uma aranha
digital. Sem este disfarce, a Wikipedia recusa a conexo.
A pginas so ento analisadas pelo mtodo verResp, no qual
o BeautifulSoup tem a chance de fazer o seu trabalho. Usando
a funo SoupStrainer, podemos ltrar o resto do documento,
que no nos interessa, analizando apenas os links (tags 'a') cujo
destino so urls comeadas pela string /wiki/. Todos os artigos
da wikipedia, comeam desta forma. Assim, evitamos perseguir
links externos. A partir da sopa produzida, extramos apenas as
urls, ou seja, o que vem depois de href=. Podemos ver na listagem
8.5 que fazemos toda esta ltragem sosticada em duas linhas de
cdigo(55 e 56), graas ao BeautifulSoup.
Listagem 8.5: Restante do cdigo da aranha.
15 urlatual = ' '

16 class I d e i a ( SQLObject ) :
17 nome = U n i c o d e C o l ( )
18 nlinks = IntCol ()
19 links = PickleCol ()
20 ender = StringCol ( )
21
22 class C r a w l e r :
23 def __init__ ( s e l f , s t a r t u r l , depth ) :
24 try :
25 Ideia . createTable ()
26 except :
27 pass
28 s e l f . SU = starturl
29 s e l f . depth = depth
30 s e l f . f i l a =[]
31 s e l f . depth = depth
32 s e l f . curdepth = 0
33 s e l f . started = 0
34 s e l f . nlinks = 0
35 s e l f . history = []
36 s e l f . G = NX. Graph ( )
37 def parsePag ( s e l f , urlend ) :
38 urlatual = urlend
39 user_agent = ' Mozilla /4.0 (
compatible ; MSIE 5.5; Windows NT
) '
40 v a l u e s = { ' name ' : ' John Smith ' ,
41 ' location ' : ' Northampton ' ,
42 ' language ' : ' Python ' }
43 headers = { ' U s e r Agent ' :
user_agent }
44 data = u r l l i b . urlencode ( values )
45 print " Abrindo ", urlend
46 req = u r l l i b 2 . Request ( u r l e n d , data ,
headers )
47 fd = u r l l i b 2 . urlopen ( req )
48 html = f d . r e a d ( )
49 return html
50
51 def ver Resp ( s e l f , html ) :
52 ' ' '
53 Verifica se resposta e um hit ou nao
54 ' ' '
55 lnkart = SoupStrainer ( ' a ' , h r e f=r e .
c o m p i l e ( ' ^/ w i k i / ' ) )
56 artlist = [ tag [ ' h r e f ' ] for tag in
BS ( html , p a r s e O n l y T h e s e=l n k a r t ) ]
57 if a r t l i s t [ 0 ] . e n ds wi t h ( ' Disambig . svg

'):
58 s e l f . f i l a . append ( ' h t t p : / / '+
l a n g a t u a l+ ' . w i k i p e d i a . o r g '+
artlist [3])
59 self . curlinks = artlist
60 else :
61 self . curlinks = artlist
62 I d e i a ( nome=n o m e a t u a l , n l i n k s =
len ( a r t l i s t ) , links =
a r t l i s t , ender = u r l a t u a l )
63 s e l f . G . add_edges_from ( [ (
nomeatual , i ) for i in self .
curlinks ])
64 if s e l f . curdepth > s e l f . depth :
65 return
66 s e l f . f i l a . e x t e n d ( [ ' h t t p : / / '+
l a n g a t u a l+ ' . w i k i p e d i a . o r g ' +
i for i in artlist ])
67 s e l f . c u r d e p t h +=1
68
69 def move ( s e l f ) :
70 i f not s e l f . f i l a :
71 i f not s e l f . s t a r t e d :
72 s e l f . f i l a . append ( s e l f . SU )
73 while self . fila :
74 s e l f . started = 1
75 urlatual = s e l f . f i l a . pop ( 0 )
76 nomeatual = u r l a t u a l . s p l i t ( ' / ' )
[ 1]
77 if ":" in nomeatual : continue
78 if nomeatual in [ ' Main_page ' ]+
s e l f . history : continue
79 print " buscando ", nomeatual ,
80 print " Faltam ", len ( s e l f . f i l a )
81 try :
82 html = s e l f . parsePag (
urlatual )
83 except :
84 continue
85 s e l f . ve rResp ( html )
86 s e l f . nlinks +=1
87 s e l f . h i s t o r y . append ( n o m e a t u a l )
88
89
90 class U r l F a c :
91 def __init__ ( s e l f , l a n g= ' e n ' ) :
92 global l a n g a t u a l
93 s e l f . lang = lang
94 langatual = lang
95 def u r l i f i c a ( s e l f , palavra ) :
96 nomeatual = p a l a v r a
97 u = " h t t p : / / "+ s e l f . l a n g+" . w i k i p e d i a .
o r g / w i k i / "+p a l a v r a
98 urlatual = u
99 return u
100
101 if __name__=="__main__" :
102 UF = U r l F a c ( ' p t ' )
103 u = UF . u r l i f i c a ( s y s . a r g v [ 1 ] )
104 Cr = C r a w l e r ( u , 1 )
105 Cr . move ( )
A listagem 8.5 mostra o restante do cdigo da aranha e o lei-

tor poder explorar outras soluo implementadas para otimizar
o trabalho da aranha. Note que no estamos guardando o html
completo das pginas para minimizar o espao de armazenamento,
mas este programa pode ser modicado facilmente de forma a reter
8.4. EXERCCIOS 197
todo o contedo dos artigos.
8.4 Exerccios
1. Modique a aranha apresentada neste captulo, para guardar
os documentos varridos.
2. Crie uma classe capaz de conter os vrios aspectos (links,

guras, etc) de um artigo da wikipedia, e utilize a aranha para
criar instncias desta classe para cada artigo encontrado, a
partir de uma nica palavra chave. Dica: para simplicar a
persistncia, armazene o objeto artigo como um Pickle, no
banco de dados.
Captulo 9
Simulaes Estocsticas
Seleo de problemas relacionados com a simulao e
anlise de processos estocsticos. Pr-requisitos: Co-
nhecimentos avanados de estatstica.
N este captulo, ilustraremos mtodos computacionais voltados

para a gerao e anlise de processos estocsticos.
Em probabilidade, um processo estocstico uma funo que
produz resultados aleatrios. Se o domnio desta funo for o
tempo, o processo estocstico se manifestar como uma srie tem-
poral. Processos estocsticos espaciais, geram os chamados campos
aleatrios
Exemplos de processo estocticos so sries temporais de preos
de aes, utuaes de populaes, distribuio espacial de polui-
o particulada.
Muitos processos estocsticos naturais possuem estrutura em
meio aleatoriedade. Muitas das tcnicas desenvolvidas para lidar
com estes processos visam encontrar esta estrutura.
9.1 Nmeros Aleatrios

Ao se estudar processos estocsticos por meio computacional, o
primeiro problema que se precisa resolver o da gerao de nme-
199
200 CAPTULO 9. SIMULAES ESTOCSTICAS
ros aleatrios de forma convel. Felizmente, hoje em dia, pacotes
como o numpy ou o scipy, fornecem geradores de nmeros aleat-
rios de qualidade para muitas famlias de distribuies, de forma
que na maioria das vezes no precisamos nos preocupar com este
problema. Vez por outra, problemas de amostragem mais com-
plexos podem exigir geradores mais sosticados. Neste captulo
exploraremos algumas destas situaes.
Hipercubo Latino - LHS
A tcnica de amostragem do hipercubo latino, mais conhecida pelo

seu nome original Latin Hypercube Sampling ou simplesmente
LHS, uma tcnica de gerao de amostras aleatrias a partir de
uma distribuio conhecida. O diferencial deste algoritmo que
ele garante a amostragem de reas de baixa probabilidade, mesmo
em amostras de tamanho pequeno a moderado (Figura 9.1).
A vantagem de se utilizar o LHS est na reduo do custo com-
putacional necessrio para cobrir o espao amostral, sem deixar
brechas signicativas.
O algoritmo do LHS funciona particionando o suporte da va-
rivel em um nmero n de intervalos equiprovveis, onde n o
nmero de amostras que se deseja obter (Figura 9.2). Ento re-
tiramos uma amostra de cada intervalo (quantis) denido no eixo
y da gura 9.2 .
1 Isto feito por amostragem uniforme naqueles
intervalos (Linha 8 da listagem 9.1). Invertendo-se a funo de
densidade acumulada, obtemos as amostras de x correspondentes.
Esta inverso calculada por meio da funo ppf (percentile point
function) que o inverso da funo de densidade acumulada (Li-
nha 9 da listagem 9.1). As amostras assim geradas equivalem a
amostras retiradas da distribuio de x, mas com uma cobertura
homognea do seu suporte. Na listagem 9.1, a amostragem por
Hipercubo Latino implementadada como uma funo de apenas
1 Veja no programa lhsexp.py como o grco da gura 9.2 foi gerado

9.1. NMEROS ALEATRIOS 201
Figura 9.1: Amostragem (n=20) de uma distribuio normal com

mdia 0 por LHS (histograma mais escuro) e amostragem padro
do scipy (histograma mais claro).
trs linhas, graas utizao dos geradores de nmeros aleatrios

disponveis no mdulo stats do scipy. Neste mdulo os geradores
so classes portadoras de mtodos muito convenientes como o rvs
que gera amostras aleatrias, e o ppf(ou percentile point function)
que representa a inversa da funo de densidade acumulada. Alm
dos mtodos utilizados neste exemplo, existem muitos outros. O
leitor encorajado a explorar estas classes e seus mtodos.
Listagem 9.1: Amostragem por Hipercubo latino (LHS)
1 #! / u s r / b i n / p y t h o n
Figura 9.2: Distribuio acumulada da varivel x N (0, 1), mos-

trando o particionamento do espao amostral em segmentos equi-
provveis.
l h s . py
3 from pylab import plot , f i g u r e , h i s t , show ,
savefig
4 import scipy . stats as stats
5 import numpy
6
7 def lhs ( dist , parms , n =100) :
8 p e r c = numpy . a r a n g e ( 0 , 1 . , 1 . / n )
9 smp = [ s t a t s . uniform ( i , 1 . / n ) . rvs ( ) for i
in perc ]
10 v = d i s t ( parms [ 0 ] , 1 . / parms [ 1 ] ) . p p f ( smp )
9.2. INFERNCIA BAYESIANA 203
11 return v
12
13 if __name__== '__main__ ' :
14 c=l h s ( s t a t s . norm , [0 ,1] ,20)
15 hist (c)
16 n = s t a t s . norm . r v s ( s i z e =20)
17 h i s t ( n . r a v e l ( ) , f a c e c o l o r= ' r ' , a l p h a =0.3)
18 s a v e f i g ( ' l h s . png ' , d p i =400)
19 show ( )
9.2 Inferncia Bayesiana

Atualmente, a resoluo de problemas de inferncia Bayesiana de
considervel complexidade, tem se tornado cada vez mais acessvel,
graas utilizao de mtodos computacionais. Isto no signica
que a computao bayesiana seja simples; pelo contrrio. Entre-
tanto, as vantagens da inferncia Bayesiana sobre a abordagem
frequentista, justicam um certo esforo por parte do pesquisador
no sentido de dominar estas tcnicas.
Antes de chegarmos s tcnicas computacionais utilizadas para
resolver os problemas da inferncia Bayesiana, vamos nos deter
um pouco sobre o porqu da intratabilidade analtica da inferncia
Bayesiana, aplicada a modelos complexos.
Sejam dois eventos E e F. A probabilidade condicional de E
dado F dada por:
P (E F )
P (E | F ) =
P (F )
A partir desta frmula, podemos obter a verso mais simples
do teorema de Bayes.
P (F | E)P (E)
P (E | F ) =
P (F )
Se particionarmos o eventos E em n eventos, mutuamente ex-
cludentes, pelo teorema da probabilidade total, chegaremos ver-
so mais comumente utilizada da frmula de Bayes:
P (F | Ei )P (Ei )
P (Ei | F ) = Pn
i=1 P (F | Ei )P (Ei )
O teorema de Bayes nos permite calcular as probabilidades de um

conjunto de hipteses explanatrias (Ei ), dado que observamos cer-
tos fatos (F ): P (Ei | F ). Mas o teorema de Bayes tambm nos
diz que estas probabilidades dependem das probabilidades a pri-
ori das hipteses P (Ei ) (antes da observao dos fatos). Dadas
estas, o teorema de Bayes nos fornece uma excelente ferramenta
para atualizao de nossos conhecimentos prvios, P (Ei ) luz de
novos fatos P (Ei | F ).
A denio acima reete uma situao em que temos um con-
junto discreto de hipteses explanatrias (Ei ), sobre as quais de-
sejamos realizar nossa inferncia. Quando nossas hipteses so
representadas, no por um conjunto enumervel de opes, mas
pelo valor de uma ou mais variveis contnuas, , e os fatos ou da-
dos denotados por X, nossos conhecimentos prvios passam a ser
representados por distribuies de probabilidade p() e os dados,
condicionados s hipteses, f (x | ), so representados pela funo
de verossimilhana L(; x).
Com a ajuda de alguma lgebra e do teorema da probabilidade
total, em sua verso contnua, chegamos forma contnua do teo-
rema de Bayes:
p()L(; x)
( | x) = R

L(; x)p()d
Ao resolvermos a integral no denominador, este deixa de ser

uma funo de e torna-se apenas uma constante de proporciona-
lidade que garante que a integral de ( | x) seja igual a 1. Isto
nos permite re-escrever a equao acima como:
9.3. SIMULAOES ESTOCSTICAS 205
( | x) p()L(; x)
Logo, a densidade posterior de proporcional sua densidade
a priori multiplicada pela verossimilhana.
Conforme vimos acima, a inferncia Bayesiana pode ser bas-
tante intuitiva, conceitualmente. Na prtica, porm, quando que-
remos calcular a distribuio posterior dos parmetros, nos depa-
ramos com vrios problemas numricos de considervel diculdade.
Para encontrar a constante de proporcionalidade mencionada
na seo anterior, precisamos integrar o produto da distribuio
a priori dos parmetros pela verossimilhana, sobre o suporte de
. Se este suporte innito e/ou multidimensional, temos um
problema de integrao numrica complicadssimo.
Uma vez obtida a constante de proporcionalidade, se o espao
de parmetros multidimensional, encontrar as distribuies mar-
ginais para cada um deles, tambm um problema de integrao
numrica difcil.
9.3 Simulaoes Estocsticas

Se no podemos determinar de forma exata, analtica ou numerica-
mente, as distribuies posteriores geradas pelo teoremas de Bayes,
s nos resta tentar simular amostras destas distribuies e estud-
las. Esta abordagem denominada mtodo de Monte Carlo, em
homenagem ao famoso cassino de Mnaco.
Integrao Monte Carlo
Suponhamos que precisemos resolver a seguinte integral :

2
2 Para humanizar um pouco esta equao, imagine que f (y | x) representa

a probabilidade condicional de y dado x, e que g(x) a funo de densidade de
probabilidade de x.
Z
J(y) = f (y | x)g(x)dx = E[f (y | x)] < +
Se g(x) uma densidade da qual podemos amostrar, podemos

aproximar nossa integral da seguinte forma:
n
= 1
X
J(y) f (y | xi )
n i=1
onde xi , . . . , xn g(x). Pela lei dos grandes nmeros, esta

estimativa se aproximar assintoticamente de J(y).
Vejamos um exemplo: gostaramos de encontrar a integral da
funo y = x no intervalo [0, 1]. Pela frmula da rea do trin-
gulo, (base altura)/2 o resultado exato 0.5. Na listagem 9.2,
nosso g(x) passa a ser uma distribuio uniforme entre 0 e 1, visto
que este o intervalo sobre qual desejamos integrar nossa funo.
Vemos que quanto maior o nmero de amostras de x, mais nossa
estimativa se aproximar de 0.5
Listagem 9.2: Integrao Monte Carlo
1 from numpy import

2 from numpy . random import
3 # desejamos rea embaixo d e uma reta
4 # dada pela funo y=x
5 # ou seja : 0.5
6 x = uniform ( 0 , 1 , 5 0 0 0 )
7 # Seja f (y | x) = x
8 J = 1 . / 5 0 0 0 sum ( x )
9 print J
9.4. AMOSTRAGEM POR REJEIO 207
9.4 Amostragem por Rejeio

Suponhamos que se deseje obter amostras de uma funo de den-
sidade p(x), com suporte no intervalo [a, b], tal que p(x) m,
x [a, b]. Ento denimos:
X U [a, b)
e
Y U [0, m)
Geramos x e y a partir destas distribuies e aceitamos x como
um valor de p(x) se y < f (x), caso contrario, rejeitamos a amostra
e tentamos novamente. Este procedimento signica que denimos
uma funo constante f (x) = m, que funciona como um envelope
para o nosso processo de amostragem.
Em suma, geramos um valor x a partir do suporte de X e
aceitamos este valor com uma probabilidade f (x)/m, caso contrrio
rejeitamos e tentamos novamente.
A ecincia deste mtodo depende da proporo de pontos
amostrados que so aceitos. A probabilidade de aceitao para
este mtodo :
P (aceitar) = P ((X, Y ) A)
Z b
1
= P ((X, Y ) A | X = x) dx
a ba
Z b
f (x) 1
= dx
a m b a
Z b
1
= f (x) dx
m(b a) a
1
=
m(b a)
Se a probabilidade de aceitao for muito baixa, devemos bus-
car um outro mtodo mais eciente. Especialmente para distribui-
es com suporte innito, a escolha de uma funo envelope mais
adequada, pode ajudar a aumentar a ecincia da amostragem.
Mtodo do Envelope
Suponhamos que desejemos simular X com uma densidade de pro-

babilidade (PDF) f () e que podemos obter amostras de Y (que
possui o mesmo suporte de X ), cuja PDF g(). Suponhamos
ainda que exista uma constante a tal que:
f (x) ag(x), x
ou seja, a um limite superior para f (x)/g(x).
Ento, amostramos Y = y deg(), e U = u U [0, ag(y)].
Aceitamos y como uma amostra de X se u < f (y)); caso contr-
rio, rejeitamos e tentamos novamente. Este mtodo funciona pois
distribui pontos uniformemente sobre a regio que envolve f (x), e
aceita apenas os pontos que cumprem o requisito de pertencer
regio delimitada por f (x).
Qual a probabilidade de aceitao?
Z
P (U < f (Y )) = P (U < f (Y ) | Y = y)g(y) dy

Z
f (y)
= g(y) dy
ag(y)
Z
f (y)
= dy
a
1
=
a
Naturalmente, devemos escolher g(x) de forma que a seja o

menor possvel.
Vamos ver como podemos representar estas idias em Python.
Listagem 9.3: Amostragem por rejeio utilizando o mtodo do

envelope

e n v e l o p e . py
2 from numpy import
4 from pylab import
5
6 def amostra ( n ) :
7 """
8 Esta funcao amostra de x e retorna
9 um v e t o r mais curto que n.
10 """
11 x=u n i f o r m ( 0 , 1 , n )
12 y=u n i f o r m ( 0 , 1 , n ) 1.5
13 f x =6 x (1 x ) # x tem distribuicao beta
14 #r e t o r n a so os valores que satifazem a
seguinte condicao :
15 s=c o m p r e s s ( y<f x , x )
16 return s
17
18 def e f i c i e n c i a ( vector , n) :
19 """
20 Testa a eficiencia da amostragem .
21 retorna a probabilidade de aceitacao .
22 """
23 l = len ( vector )
24 prob = l / f l o a t (n)
25 diff = n l
26 #n necessario para obter as amostras que
faltam
27 n2 = i n t ( d i f f / p r o b )
28 v e c 2 = a m o s t r a ( n2 )
29 s = concatenate ( ( vector , vec2 ) )
30 #g e r a histograma
31 nb , bins , patches = hist (s , b i n s =50 ,
normed =0)
32 x l a b e l ( ' Amostra ' )
33 ylabel ( ' Probabilidade ' )
34 t i t l e ( ' Histograma de s: n=%s '% n )
35 s a v e f i g ( ' e n v e l o p e . png ' , d p i =400)
36 show ( )
37 return s
38
39 def testRS ( ) :
40 """
41 Esta funcao testa o modulo
42 """
43 n =100000
44 s a m p l e=a m o s t r a ( n )
45 e f i c i e n c i a ( sample , n )
46
47 if __name__ == '__main__ ' :
48 testRS ( )
Aplicando ao Teorema de Bayes
Podemos aplicar o conceito de amostragem por rejeio a proble-

mas de inferncia Bayesiana. Frequentemente, em inferncia Baye-
siana, conhecemos bem a distribuio a priori, a ponto de poder
amostr-la e, tambm, possuimos dados com os quais podemos
construir a funo de verossimilhana.
Figura 9.3: Resultado da amostragem por envelope de uma distri-

buio beta(1,1)
De posse destes elementos podemos invocar a tcnica de amos-

tragem por rejeio para nos ajudar a amostrar da distribuio
posterior. Dado que:
() = p()L(; x)
temos que, sendo LM ax o valor mximo da nossa funo de

verossimilhana,
() p()LM ax
,
() p()L(; x) L(; x)
= =
LM ax p() LM ax p() LM ax
.
Assim sendo, podemos utilizar o mtodo do envelope, amos-
trando da distribuio a priori e aceitando as amostras com pro-
L(;x)
babilidade igual a
LM ax .
Listagem 9.4: Amostragem da Posterior Bayesiana por rejeio.

p o s t r e j . py
2 from numpy import
4 from pylab import
5
6 def L i k e l i ( data , limits , nl ) :
7 n = l e n ( d a t a ) # Numero de amostras
8 data = array ( data )
9 ( l l , ul ) = l i m i t s #l i m i t e s do espaco de
params .
10 s t e p = ( ul l l ) / f l o a t ( n l )
11 res = [] #l i s t a de resultados
12 s d = s t d ( d a t a ) #DP d o s dados
13 for mu in arange ( l l , ul , s t e p ) :
14 r e s . append ( e x p ( 0 . 5 sum ( ( ( d a t a mu) /
sd ) 2) ) )
15 lik = a r r a y ( r e s ) /max ( a r r a y ( r e s ) ) #
Verossimilhanca
16 return lik
17
18 def amostra ( n , d a t a , p l o t t e d =0) :
19 x=u n i f o r m ( 0 , 1 , n ) #s u p o r t e
20 limits = 0 ,1
21 L= L i k e l i ( d a t a , limits , n)
22 f x =6 x (1 x ) # p r i o r i , b e t a ( 2 , 2 )
23 s=c o m p r e s s ( L [ : l e n ( x ) ] < f x , x ) #R e j e i c a o
24 i f not plotted :
25 p1 = scatter (x , fx )
26 p2 = p l o t ( s o r t ( x ) , L )
27 l e g e n d ( [ p1 , p2 ] , [ ' P r i o r i ' , '
Verossimilhanca ' ] )
28 return s
29
30 def e f i c i e n c i a ( vector , n , data ) :
31 l = len ( vector )
32 prob = l / f l o a t (n)
33 diff = n l
34 n2 = i n t ( d i f f / p r o b )
35 v e c 2 = a m o s t r a ( n2 , d a t a , p l o t t e d =1)
36 s = concatenate ( ( vector , vec2 ) )
37 return s , prob
38
39 def main ( ) :
40 n =90000
41 data = uniform ( 0 , 1 , 3 )
42 s a m p l e=a m o s t r a ( n , data )
43 s , prob = e f i c i e n c i a ( sample , n , data )
44 f i g u r e ( 2 ) #g e r a histograma
45 hist (s , b i n s =50 , normed =1)
46 xlabel ( 'x ' )
47 t e x t ( 0 . 8 , 1 . 2 , ' E f i c i e n c i a :% s '%r o u n d ( pro b
,2) )
48 ylabel ( ' frequencia ' )
49 t i t l e ( ' Posterior : n=%s '% n )
50 s a v e f i g ( ' r e j e i c a o . png ' , d p i =400)
51 show ( )
52 return s
53
54 if __name__ == '__main__ ' :
55 main ( )
Figura 9.4: Amostragem por rejeio da posterior Bayesiana.
Na linha 22 da listagem 9.4, vemos a rejeio de acordo com a

verossimilhana. Note que a verossimilhana calculada a partir de
um modelo normal enquanto que a distribuio a priori apresenta
uma distribuio beta(2,2).
A gura 9.4 mostra o resultado da amostragem da posterior,
junto com a ecincia do processo(canto superior direito).
9.5 Cadeias de Markov

Cadeias de Markov so um tipo particular de processo estocstico
no qual o estado atual do sistema depende apenas do estado imedi-
atamente anterior. Um exemplo muito conhecido de um processo
9.5. CADEIAS DE MARKOV 215
de markov o modelo auto-regressivo de primeira ordem:
Zt = Zt1 + t , t N (0, 2 )
O processo apresentado acima, medida em que o nmero de

iteraes cresce, converge para uma distribuio (z). Esta distri-
buio denominada distribuio estacionria da cadeia. Entre-
tanto, a cadeia necessita de um determinado nmero de iteraes
para alcanar (z). Se desejamos fazer inferncias sobre (z), pre-
cisamos descartar os resultados iniciais da cadeia. Este perodo
necessrio para a convergncia, denominado de burn-in.
Listagem 9.5: Cadeia de Markov com kernel de transio exponen-

cial
1 # c o d i n g : l a t i n 1
markov . py
3 #g e r a n d o uma c a d e i a de markov
5 import random a s r n
7
8 n =10000
9 a l p h a =0.99
10 x=z e r o s ( 1 0 0 0 0 , Float )
11 for i in xrange ( 1 , n ) :
12 x [ i ]= a l p h a x [ i 1] + exponential (1 ,1) [ 0 ]
13 # p l o t t i n g
14 subplot (211)
15 t i t l e ( ' Processo de Markov ' )
16 plot (x)
17 xlabel (u ' Iteraes ' )
18 ylabel ( 'x ' )
19 subplot (212)
20 h i s t ( x , b i n s =50)
21 xlabel ( 'x ' )
22 ylabel (u ' frequncia ' )
23 s a v e f i g ( ' markov . png ' , d p i =400)
24 show ( )
Executando o cdigo apresentado na listagem 9.5 obtm-se a

gura 9.5. Note o perodo at a convergncia. Como exerccio,
refaa o histograma eliminando os valores do perodo burn-in, e
compare com o apresentado na gura 9.5.
Figura 9.5: Cadeia de Markov com kernel de transio exponencial.

9.6. MCMC (MARKOV CHAIN MONTE CARLO) 217
9.6 MCMC (Markov Chain Monte Carlo)

Ns j discutimos algumas ferramentas bsicas da simulao esto-
cstica, como o mtodo de Monte Carlo e as cadeias de Markov.
Agora vamos ver como estes dois mtodos podem ser combinados
para dar origem ao famoso mtodo MCMC.
As tcnicas aqui apresentadas, so de grande utilidade na esta-
tstica, particularmente na inferncia Bayesiana.
O MCMC uma classe de algoritmos que tem como objetivo
contruir cadeias de Markov cuja distribuio estacionria seja idn-
tica a de uma distribuio alvo. Aps alcanarem esta distribuio
estacionria, as cadeias podem ser usadas para se obter amostras
da distribuio alvo.
As cadeias de Markov utilizadas na maioria dos algoritmos
de MCMC, percorrem o espao amostral utilizando-se de alguma
forma de passeio aleatrio. Portanto, podem levar muito tempo
para cobrir o espao desejado. Isto se deve ao fato de que a cadeia
pode voltar atrs percorrendo partes do espao j percorridas. A
seguir descreveremos e implementaremos dois dos mais utilizados
mtodos de MCMC: os amostradores de Metropolis-Hastings e de
Gibbs.
O Amostrador de Metropolis-Hastings
Este amostrador consiste em gerar amostras sequenciais de forma a

aproximar uma distribuio da qual no temos meios de amostrar
diretamente. Este algoritmo pode amostrar de qualquer distribui-
o de probabilidade p(x), desde que a densidade em x possa ser
calculada.
Como qualquer cadeia de markov, o amostrador comea em um
dado valor arbitrrio para a varivel x e prossegue em um passeio
aleatrio, onde cada deslocamento amostrado de uma distribuio
0
de Propostas. Cada proposta(x ) avaliada de acordo com a se-
guinte regra: u amostrado de uma distribuio uniforme, U (0, 1).
Se
p(x0 )
u<
p(xt )
x0 se torna xt+1 , caso contrrio xt+1 = xt .
Listagem 9.6: Amostrador de Metropolis-Hastings
1 # e n c o d i n g : l a t i n 1
2 # Disponivel no pacote de programas como : MH
. py
3 from numpy import
4 from scipy . stats import
5
6 class A m o s t r a d o r :
7 def __init__ ( s e l f , alvo , proposta ) :
8 """
9 Incializa o amostrador
10 alvo : dados definindo densidade alvo
11 proposta : objeto gerador de
propostas .
12 """
13 s e l f . a l v o = kde . g a u s s i a n _ k d e ( a l v o )
14 s e l f . prop = p r o p o s t a
15
16 def Run ( s e l f , n , b u r n i n =100) :
17 ' ' '
18 Roda o amostrador por n passos
19 ' ' '
20 amostra = z e r o s ( n , f l o a t )
21 alvo = s e l f . alvo
22 i = 0
23 while i < n 1:
24 x = amostra [ i ]
25 inova = s e l f . prop . r v s ( ) [ 0 ]
26 can = x + i n o v a
27 a p r o b = min ( [ 1 , a l v o . e v a l u a t e ( c a n
) / alvo . evaluate (x) ] )
28 u = uniform . rvs ( ) [ 0 ]
29 if u < aprob :
30 a m o s t r a [ i +1] = x = c a n
31 i += 1
32 return amostra [ burnin : ]
33
34 if __name__=="__main__" :
35 import pylab as P
36 d a d o s = c o n c a t e n a t e ( ( norm . r v s ( s i z e =500) ,
norm . r v s ( 4 , 1 , s i z e =500) ) )
37 a = A m o s t r a d o r ( d a d o s , norm ( 0 , 1 ) )
38 r e s = a . Run ( 1 0 0 0 0 )
39 P. p l o t ( arange ( 5 ,10 ,.01) , a . alvo . evaluate
( arange ( 5 , 1 0 , . 0 1 ) ) , ' r ' , lw =2)
40 P . h i s t ( r e s , normed =1 , a l p h a = 0 . 5 )
41 P . l e g e n d ( [ ' A l v o ' , ' Amostra ' ] )
42 P . s a v e f i g ( 'MH. png ' , d p i =400)
43 P . show ( )
Normalmente, utiliza-se um amostrador como este para amos-

trar de distribuies das quais toda a informao que se tem pro-
vm de uma amostra. Portanto, a Listagem 9.6, aceita um con-
junto de dados como alvo. A partir desta amostra, uma funo
de densidade de probabilidade (PDF) estimada por meio da fun-
o gaussian_kde do Scipy. Esta funo ser utilizada como alvo
para o amostrador.
Note que a distribuio de propostas passada para o objeto
Amostrador uma das classes geradoras de nmeros aleatrios
oferecidos por scipy.stats3 . A Figura 9.6, mostra o resultado
3 Estas classes podem ser chamadas diretamente com seus parmetros como
mostrado na linha 36 da listagem 9.6, retornando um objeto frozen com os
do amostrador aps a remoo de um nmero de amostras do in-
cio da cadeia determinado pelo parmetro burnin. Esta remoo
importante, pois a cadeia leva algum tempo para convergir para
a rea sob a curva alvo.
Figura 9.6: Amostrador de Metropolis-Hastings(n=10000).
O Amostrador de Gibbs
O amostrador de Gibbs foi desenvolvido para permitir a gerao de

amostras a partir de distribuies conjuntas de duas ou mais va-
riveis. O amostrador de Gibbs um caso especial do amostrador
de Metropolis-Hastings. Na listagem 9.7, vemos uma implementa-
mesmos mtodos mas com os parmetros xos

o do amostrador de Gibbs, que envolve a denio de uma classe

amostradora.
Listagem 9.7: Amostrador de Gibbs aplicado uma distribuio

tri-variada

g i b b s . py
2 # e n c o d i n g : l a t i n 1
3 from numpy import zeros , sqrt , array
5
6 class Amostra :
7 def __init__ ( s e l f , n , v a r l i s t , loc , scale ,
cormat , b u r n i n =1000) :
8 ' ' '
9 n o tamanho da amostra
10 varlist a lista de funes
geradoras do numpy
11 loc e scale sao listas para cada
gerador em varlist
12 geradores testados :
13 normal , beta , gamma , gumbel
14 logistic , lognormal , wald , laplace
15 ' ' '
16 self .n = n
17 s e l f . vars = varlist
18 s e l f . loc = loc
19 self . scale = scale
20 s e l f . r o = cormat
21 s e l f . burnin = burnin
22 def Run ( s e l f ) :
23 results = zeros (( len ( s e l f . vars ) , s e l f
. n) , f l o a t )
24 dp = s q r t (1 s e l f . r o 2)
25 ms = s e l f . loc
26 dps = self . scale
27 ro = s e l f . ro
28 for i in x r a n g e ( 1 , s e l f . n ) :
29 for n , j in e n u m e r a t e ( s e l f . v a r s ) :
30 results [n, i ] = j ( ms [ n ]+ r o [ n ,
n 1 ] ( r e s u l t s [ n 1 , i 1]
ms [ n ] ) / d p s [ n 1 ] , d p s [ n ]
dp [ n , n 1 ] )
31 return r e s u l t s [ : , s e l f . burnin : ]
32
33 if __name__=="__main__" :
34 import pylab as P
35 n = 10000
36 varlist = ( b e t a , gamma , n o r m a l )
37 loc = (2. ,9. ,5 ,)
38 scale = (2 ,.5 ,1.)
39 cormat = z e r o s ( ( 3 , 3 ) , f l o a t )
40 #c o r m a t = a r r a y
([[1 ,0.6 ,0.7] ,[0.6 ,1 ,0.8] ,[0.7 ,0.8 ,1]])
41 s = Amostra ( n , v a r l i s t , l o c , s c a l e , c o r m a t )
42 r e s = s . Run ( )
43 s 1=P . p l o t ( r e s [ 0 ] , r e s [ 2 ] , ' . ' )#m a r k e r = 'p ' ,
c = ' y ' , mec= ' k ' , l w =0)
44 s 2=P . p l o t ( r e s [ 1 ] , r e s [ 2 ] , '+ ' )#m a r k e r = ' v ' ,
c = ' y ' , mec= ' k ' , l w =0)
45 P . l e g e n d ( [ ' Beta x Normal ' , 'Gamma x
Normal ' ] )
46 P . s a v e f i g ( ' g i b b s . png ' , d p i =400)
47 P . show ( )
O amostrador de Gibbs pode ser aplicado quando no se co-

nhece a distribuio conjunta, mas a distribuio condicional de
9.7. MTODOS MONTE CARLO SEQUENCIAIS 223
cada varivel conhecida. No amostrador de Gibbs convencional,

cada nova amostra xit+1 calculada de forma condicional ao valor
de todas outras variveis no tempo t. No exemplo mostrado na lis-
tagem 9.7, uma variante deste mtodo implementado, na qual as
variveis so calculadas a partir de uma estrutura de dependncia
circular(Figura 9.7).
Figura 9.7: Estrutura de dependncia circular utilizada na listagem

9.7.
9.7 Mtodos Monte Carlo Sequenciais

Estes mtodos, tambm chamados de ltros de partculas, visam
determinar a distribuio de um processo markoviano pela anlise
seqencial de observaes. Seja xk uma sequncia de parmetros
desconhecidos (por exemplo o valor esperado de um sistema din-
mico) onde k = 0, 1, 2, 3, . . . e yk [y0 , y1 , . . . , yk ] o conjunto de
observaes sobre X (Figura 9.9).
Os mtodos sequenciais procuram estimar xk a partir da distri-

buio posterior
p(xk | y0 , y1 , . . . , yk )
ao passo que os mtodos MCMC, modelam a posterior com-

pleta:
p(x + 0, x1 , . . . , xk | y0 , y1 , . . . , yk )
Figura 9.8: Amostrador de Gibbs aplicado a uma distribuio tri-

variada.
Sampling Importance Resampling SIR
O algoritmo de amostragem e re-amostragem por importncia um

dos mtodos Monte Carlo sequenciais mais utilizados. Ele procura
aproximar p(xk | y0 , y1 , . . . , yk ) por meio de valores de x pondera-
dos por uma funo de importncia,W que uma aproximao da
distribuio posterior de X
A descrio de um passo do SIR, a seguinte:
1. Retiramos P amostras (x) da distribuio a priori de transi-

o de X , p(xk | xk1 );
Figura 9.9: Processo markoviano e suas observaes.
2. Calculamos a p(yk | xk ) (verossimilhana, no caso da distri-

buio alvo ser a posterior Bayesiana);
3. Calculamos W = p(xk | xk1 )p(yk | xk );

4. Normalizamos W;
5. Re-amostramos P valores de x com probabilidades dadas por

W;
A re-amostra (distribuio posterior de xk )passa a ser a a priori

de transio para a o prximo passo.
Listagem 9.8: Filtro de partculas usando algoritmo SIR
1 # e n c o d i n g : l a t i n 1
s i r . py
3 from numpy import
4 import l i k e
6 from s c i p y . s t a t s import
7
8 class SMC:
9 """
10 Monte Carlo Sequencial usando SIR
11 """
12 def __init__ ( s e l f , p r i o r t y p e , pars , range
, r e s o l u t i o n =512) :
13 ' ' '
14 Inicializa Filtro .
15 priortype deve ser um RNG d e scipy .
stats
16 pars so os parmetros da priori .
17 ' ' '
18 self . priori = priortype
19 s e l f . pars = pars
20 s e l f . range = range
21 s e l f . r e s = ( range [1] range [ 0 ] ) 1./
resolution
22 self . likelihood = None
23 s e l f . p o s t e r i o r=a r r a y ( [ ] )
24
25 def __call__ ( s e l f , datum ) :
26 sc = s e l f . pars [ 1 ]
27 m = s e l f . range [ 0 ]
28 M = s e l f . range [ 1 ]
29 step = s e l f . res
30 s u p = a r a n g e (m,M, s t e p )
31 lik = e x p ( a r r a y ( [ l i k e . Normal ( datum , i
, sc ) for i in sup ] ) )
32 self . likelihood = l i k /sum ( l i k )
33 post = self . c a l c P o s t e r i o r (1000)

34 return post
35
36 def calcPosterior ( self , n) :
37 """
38 Calcula a distribuio posterior
39 """
40 if s e l f . p o s t e r i o r . any ( ) :
41 s = s e l f . p r i o r i . r v s ( s i z e =n , l o c=
s e l f . pars [ 0 ] , s c a l e= s e l f .
pars [ 1 ] )
42 #p d e n s= k d e . g a u s s i a n _ k d e ( s e l f .
posterior )
43 #s= p d e n s . r e s a m p l e ( n )
44 else :
45 s = s e l f . p r i o r i . r v s ( s i z e =n ,
l o c= s e l f . p a r s [ 0 ] , s c a l e=
s e l f . pars [ 1 ] )
46 m = array ( [ s e l f . range [ 0 ] ] )
47 M = array ( [ s e l f . range [ 1 ] ] )
49 s u p p = a r a n g e (m,M, s t e p )
50 s = c o m p r e s s ( l e s s ( s . r a v e l ( ) ,M) &
g r e a t e r ( s . r a v e l ( ) ,m) , s )
51 d = u n i f o r m . r v s ( l o c =0 , s c a l e =1 , s i z e =s
. size )
52 if s e l f . p o s t e r i o r . any ( ) :
53 w= s e l f . p r i o r i . p d f ( supp ) s e l f .
likelihood
54 else :
55 w = s e l f . p r i o r i . p d f ( supp , l o c=
s e l f . p a r s [ 0 ] , s c a l e= s e l f . p a r s
[1]) self . likelihood
56 w = w/sum (w)
57 s x = s e a r c h s o r t e d ( supp , s )
58 w = w [ s x 1]
59 w = w. r a v e l ( )
60 p o s t = c o m p r e s s ( d<w , s )
61 post = post . ravel ()
62 s e l f . p o s t e r i o r = post
63 return post
64
65 if __name__=="__main__" :
66 p f = SMC( norm , ( 3 , 3 ) , r a n g e =( 10 ,15) )
67 d a t a = 2 s i n ( a r a n g e ( 0 , 7 , . 2 ) ) +2#o n e s ( 1 0 )
68 sup = a r a n g e ( 10 ,15 ,25/512.)
69 priori = norm . p d f ( sup , l o c =3 , s c a l e =1)
70 P. ion ()
71 lin , = P . p l o t ( sup , p r i o r i )
72 pt , = P . p l o t ( [ data [ 0 ] ] , [ 0 . 0 5 ] , ' o ' )
73 P. grid ()
74 for i in data :
75 est = pf ( [ i ] )
76 l i n . s e t _ y d a t a ( kde . g a u s s i a n _ k d e ( e s t ) .
e v a l u a t e ( sup ) )
77 pt . set_xdata ( [ i ] )
78 P . draw ( )
79 print i , c o m p r e s s ( p f . l i k e l i h o o d==max (
pf . l i k e l i h o o d ) , s u p ) , median ( e s t )
Na Listagem 9.8, vemos uma implementao de um ltro de

partculas utilizando o algoritmo SIR. O ltro denido como uma
classe. Nesta classe denimos o mtodo __call__, caracterstico
de funes. Desta forma, uma vez criado o objeto (instncia da
classe SMC), ele poder ser chamado diretamente pelo nome. Se o
objeto no possusse tal mtodo, teramos que nos utilizar de um
de seus mtodos para acionar sua maquinaria.
Parametrizamos o objeto SMC com uma distribuio a priori
9.8. FUNES DE VEROSSIMILHANA 229
dada pela classe norm do mdulo scipy.stats com mdia = 3 e

desvio padro = 3. Tambm precisamos especicar os limites de
busca do algoritmo, o que feito atravs do argumento range pas-
sado durante a inicializao. Neste exemplo as funes de clculo
das verossimilhanas foram implementadas de um mdulo sepa-
rado chamado like.py. Este mdulo est no pacote de programas
disponvel no website deste livro.
A convergncia dos mtodos sequenciais, depende fortemente
da qualidade do algoritmo de amostragem da priori, uma vez que
estas amostras formam a matria-prima do algoritmo SIR.
9.8 Funes de Verossimilhana

Ser capaz de calcular funes de verossimilhana essencial quando
se deseja utilizar a inferncia Bayesiana. A verossimilhana o
termo da frmula de Bayes que representa a evidncia contida em
um conjunto de dados, e que utilizada para atualizar nosso co-
nhecimento a priori do problema, de forma a gerar uma nova des-
crio para suas varivieis, denominada de distribuio posterior
conjunta.
Denio da funo de verossimilhana
Varivel Discreta
Seja um espao de parmetros. Seja {p ; } uma famla pa-
rametrizada de modelos probabilsticos para um vetor de variveis
discretas X = (X1 , . . . , Xn ). A funo de verossimilhana para
(x1 , . . . , xn ) dada por:
L( | x1 , . . . , xn ) , p (x1 , . . . , xn )
e uma funo de .
A funo de verossimilhana nos d a probabilidade de que
(X1 , . . . , Xn ) = (x1 , . . . , xn ), ou seja um determinado conjunto de
dados ser amostrado em uma realizao do processo gerador, para
cada valor possvel de . Matematicamente, a funo de verossimi-
lhana apenas uma notao diferente para a funo de probabili-
dade. Contudo, conceitualmente existe uma distino importante:
Quando se estuda a funo de probabilidade, xa-se o parmetro e
obtm-se a variao da probabilidade em funo do valor da vari-
vel, x. Quando estudamos a verossimilhana, consideramos o valor
de x xo e variamos o parmetro, obtendo a verossimilhana de
cada valor. Para uma nica observao de uma varivel discreta,
a verossimilhana igual probabilidade de se observar aquele
valor. Por exemplo: Seja Pp uma distribuio Bernoulli com par-
metro p, 0 < p < 1. Uma varivel aleatria com uma distribuio
Bernoulli, s pode assumir dois valores, 0 e 1.
Para x = 0,
L(p | 0) = 1 p
Para x = 1,
L(p | 1) = p
Um pouco de lgebra, nos permite combinar ambas as frmulas
acima escrevendo:
L(p | x) = px (1 p)1x , x {0, 1}

Podemos visualizar a forma da verossimilhana com quatro li-
nhas de cdigo:
Listagem 9.9: Funo de verossimilhana para x igual a 0.

1 >>> from pylab import
2 >>> L=[1 p for p in a r a n g e ( 0 , 1 , . 0 1 ) ]
3 >>> p l o t ( a r a n g e ( 0 , 1 , . 0 1 ) , L )
4 >>> show ( )
Para mltiplas observaes independentes, a funo de verossi-

milhana caria assim:
L(p | x1 , . . . , xn ) = [px1 (1 p)1x1 ][px2 (1 p)1x2 ] . . . [pxn (1 p)1xn ]

Pn Pn
xi
= p i (1 p)n i xi
(9.1)
Isto dito, vamos a um exemplo cientco mais concreto: um

pesquisador deseja comparar duas sequncias de DNA, buscando
quanticar a homologia entre elas, ou seja, em quantas posies
possuem nucleotdeos idnticos. Sejam as duas sequncias:
AT T AGCCCT T GGGAACAT CCC

AT GAGCT CT T GGT T AAGACCC
Assumindo independncia entre os loci, podemos representar

esta comparao como uma varivel Bernoulli (Xi )que assume valor
1 para loci com letras iguais e 0 para loci com letras distintas.
Vamos resolver este problema aplicando a equao 9.1.
Listagem 9.10: Calculando a verossimilhana da comparao de

duas sequncias de DNA
1 # c o d i n g : l a t i n 1
l i k 1 . py
3 from pylab import
4 a ="ATTAGCCCTTGGGAACATCCC"
5 b ="ATGAGCTCTTGGTTAAGACCC"
6 n = len (a)
7 # Comparando as sequncias :
8 comp = [ i n t ( a [ i ]==b [ i ] ) for i in range ( len ( a
)) ]
9 # Contando nmero d e correspondncias
10 soma = sum ( a r r a y ( comp ) )
11 # C a l c u l a n d o L
12 L = [ p soma (1 p ) ( nsoma ) for p in arange
(0 ,1 ,.01) ]
13 p l o t ( arange ( 0 , 1 , . 0 1 ) , L)
14 s a v e f i g ( ' l i k 1 . png ' , d p i =400)
15 show ( )
A gura 9.10 mostra a funo de verossimilhana gerada pela
listagem 9.10. Mais adiante usaremos este resultado em outro
exemplo.
Analisando o cdigo da listagem 9.10, utilizamos a tcnica de
list comprehension para comparar as duas sequncias locus a locus
retornando 1 quando fossem iguais e 0, caso contrrio. Como a
comparao retorna verdadeiro (True) ou falso (False), aplicamos
a funo int para transformar estas sadas em 1 e 0, respectiva-
mente. Na linha 9, convertemos a lista de resultados da comparao
em vetor para poder somar os seus elementos com sum. Na linha
11, usamos tcnica similar da linha 7 para calcular a funo de
verossimilhana.
Figura 9.10: Funo de verossimilhana para a comparao de

sequncias de DNA.
Varivel Contnua
A funo de verossimilhana para variveis aleatrias contnuas
similar ao caso discreto apresentado acima. Para uma varivel con-
tnua, substitumos a funo de probabilidade da denio discreta
pela funo de densidade de probabilidade. Se g (x1 , . . . , xn ),
, representa uma famlia de funes de densidade de probabili-
dade conjuntas para (X1 , . . . , Xn ), ento
n
Y
L( | x1 , . . . , xn ) = f (xi )
i=1
se X1 , . . . , X n forem independentes e identicamente distribu-

das.
A ttulo de exemplo, vamos escrever a funo de verossimilhana
para uma varivel aleatria normal X com mdia e varincia 1.
Neste caso, o nosso parmetro . Dado que a densidade de Xi
2
(2)1/2 e(x) /2
, para n=3 temos
P3 2
L( | x1 , x2 , x3 ) = (2)3/2 e1/2 1 (xi ) . (9.2)
Como podemos ver pelas equaes 9.2 e 9.1, a verossimilhana

uma famlia de funes que difere por um fator que no depende
de . Portanto, apenas seu valor relativo (forma) nos interessa.
Log-verossimilhana
Na funo de verossimilhana, o termo que no depende de , de-
pende de n (o tamanho amostral), com isso o valor da verossimi-
4
lhana facilmente torna-se extremo . Devido a esta caracterstica
da funo de verossimilhana, frequentemente utiliza-se o seu loga-
ritmo. Vamos plotar a log-verossimilhana calculada na listagem
5
9.10.
4 Se isto no bvio para voc, utilize seus conhecimentos de Python para

investigar numericamente este fato.
5 Modique a listagem anterior incluindo estas linhas
Listagem 9.11: Log-verossimilhana
1 L [ 0 ] = L [ 1 ] #removendo o zero do incio da

lista
2 p l o t ( arange ( 0 , 1 , . 0 1 ) , l o g ( array (L) ) )
3 show ( )
Compare agora os dois grcos( ?? e 9.11). Preste ateno aos va-

lores do eixo y. A funo mudou de forma, porm preservou uma
coisa muito importante: o seu mximo continua com a mesma abs-
cissa. Isto nos leva a uma aplicao muito importante da funo
verossimilhana: a estimao de parmetros por mxima verossi-
milhana.
Figura 9.11: Log-verossimilhana da funo descrita anteriormente.

9.9. INFERNCIA BAYESIANA COM OBJETOS. 235
Vimos na listagem 9.10 que, quando calculamos a funo de

verossimilhana sobre dados obtidos experimentalmente, ela repre-
senta a probabilidade de cada valor de parmetro no eixo x ter
gerado aquele conjunto de dados. Logo, se desejamos estimar este
parmetro a partir dos dados, devemos escolher o valor que maxi-
miza a funo de verossimilhana. Felizmente, este valor o mesmo
para a log-verossimilhana.
Voltando ao problema da comparao de duas sequncias de
DNA, vamos maximizar a funo de verossimilhana para estimar
p (ver listagem 9.12).
Listagem 9.12: Maximizando a verossimilhana
1 MLE = c o m p r e s s ( e q u a l ( L , max ( L ) ) , a r a n g e
(0 ,1 ,.01) )
2 print MLE
3 [ 0.67]
Na linha1 da listagem 9.12, utiliza-se uma funo proveniente

do mdulo numpy6 . Esta funo (compress) nos retorna os elemen-
tos do segundo argumento arange(0,1,.01), nas posies em que
o vetor de condies, equal(L,max(L)), for verdadeiro. Trocando
em midos: nos retorna o valor do parmetro p para o qual o valor
da verossimilhana mximo. As funes max e equal tambm so
provenientes do mdulo numpy.
9.9 Inferncia Bayesiana com Objetos.

Na viso Bayesiana de mundo, nosso conhecimento sobre o mundo
representado por nossas crenas que, por sua vez, so representa-
das por variveis aleatrias com suas distribuies de probabilidade
(PDFs). Como nosso conhecimento do mundo no perfeito, es-
tas distribuies no tm preciso innita, ou seja, no podem ser
6 Importado, neste exemplo, pelo mdulo pylab.

representadas por um simples nmero. Por exemplo, minha altura
no 1, 73m mas uma distribuio de valores em torno deste, visto
que depende de vrios fatores tais como postura, quantidade de
cabelo, etc.
Naturalmente, nossas crenas podem ser modicadas. A cada
vez que ns nos expomos a novas evidncias(dados) a respeito de
um fato, podemos reforar nossa crena original (aumentando sua
preciso). Ou podemos car mais confusos, se os dados no con-
cordam com nossa crena original, e esta ltima perder preciso.
O objetivo desta seo, construir um objeto que emule as ca-
ractersticas de varivel aleatria Bayesiana, facilitando-nos a rea-
lizao das operaes mencionadas acima.
Em computao se desejarmos representar uma distribuio
p(x), teremos que faz-lo por meio de uma funo (se esta fun-
o for conhecida e computvel) que recebe x como argumento e
na sua probabilidade, ou por alguma outra estrutura de dados que
combine todos valores de x e suas respectivas probabilidades, como
por exemplo um dicionrio. Naturalmente esta ltima representa-
o se presta apenas a uma gama bastante limitada de variveis.
1 >>> # D i s t r i b u i o de probabilidades d e um
dado cbico
2 >>> dado =
{1:1/6. ,2:1/6. ,3:1/6. ,4:1/6. ,5:1/6. ,6:1/6.}
Listagem 9.13: Classe Varivel Aleatria Bayesiana Requisitos.
3 # copyright 2007 Flavio Codeco Coelho

4 # Licensed u n d e r GPL v3
5 from numpy import
6 import l i k e , s y s
Como toda varivel Bayesiana, nossa classe deve possuir uma
distribuio a priori, neste exemplo denida de forma paramtrica.
Deve tambm conter dados referentes a ela, e uma distribuio

posterior. Naturalmente deve possuir os mtodos para atualizar a
sua distribuio a priori, transformando-a em posterior.
Listagem 9.14: Classe Varivel Aleatria Bayesiana Inicializao.
8 from scipy . stats import

9
10 class BayesVar :
11 """
12 Bayesian random variate .
13 """
, r e s o l u t i o n =512) :
15 ' ' '
16 Inicializa varivel aleatria .
17 Adquire mtodos da classe priortype
.
stats
20 ' ' '
21 s e l f . p r i o r n = p r i o r t y p e . name
22 s e l f . _ f l a v o r i z e ( p r i o r t y p e ( pars ) ,
priortype )
resolution
26 self . likefun = s e l f . _Likelihood ( s e l f
. priorn )
Esta classe deve solicitar estas informaes na sua inicializa-

o(Listagem 9.14). O pacote scipy.stats j possui classes cor-
respondendo a vrias famlias paramtricas. Portanto nossa classe
requer que o argumento priortype seja uma destas classes. Re-
quer tambm os parmetros da a priori, a extenso do suporte para
a varivel,e a resoluo da representao das distribuies(nmero
de pontos em se subdividir o suporte).
Durante a inicializao da classe, importamos os mtodos da
distribuio a priori para se juntar aos mtodos de nossa classe.
Esta absoro de funcionalidade no poderia ser conseguida atravs
de herana comum, pois no se sabe de antemo de qual classe
desejamos herd-los. Felizmente, a natureza dinmica do Python
nos ajudou neste ponto, permitindo uma herana dinmica. Esta
herana feita no mtodo _flavorize (Listagem 9.15).
Listagem 9.15: Classe Varivel Aleatria Bayesiana Herana di-

nmica de mtodos.
30
31 def _ f l a v o r i z e ( s e l f , pt , ptbase ) :
32 ' ' '
33 add methods from distribution type
34 ' ' '
35 s e l f . c d f = pt . c d f
36 self . isf = pt . i s f
37 if i s i n s t a n c e ( ptbase , rv_continuous ) :
38 s e l f . pdf = pt . pdf
39 elif i s i n s t a n c e ( ptbase , r v _ d i s c r e t e ) :
40 s e l f . p d f = p t . pmf
41 else : sys . exit ( ' Invalid distribution
object ' )
De acordo com o tipo de distribuio a priori, o mtodo Like-

lihood escolhe e retorna a funo de verossimilhana adequada(Listagem
9.16).
Listagem 9.16: Classe Varivel Aleatria Bayesiana Herana di-

nmica de mtodos.
100 return []
101
102 def _ Li k e li h oo d ( s e l f , typ ) :
103 ' ' '
104 Define familia paramtrica da
verossimilhana .
105 Retorna funo de verossimilhana .
106 typ deve ser uma string .
107 ' ' '
108 if t y p == ' norm ' :
109 return lambda ( x ) : l i k e . Normal ( x
[0] ,x[1] ,1./x[2])
110 elif t y p == ' expon ' :
111 return lambda ( x ) : ( 1 . / x [ 2 ] ) x
[0]. size e x p ( ( 1 . / x [ 2 ] ) sum (
x[0]) )
Durante a inicializao da varivel, uma lista vazia de dados

criada. Esta lista conter todos os conjuntos de dados indepen-
dentes que forem atribudos varivel. Isto importante pois a
teoria Bayesiana opera por atualizaes sucessivas da distribuio
posterior a cada novo conjunto de evidncias. Uma vez gerada, a
distribuio posterior ca guardada no atributo posterior.
Nossa classe possui ainda um mtodo chamado addData, cuja
funo a de armazenar os dados, e recalcular a funo de veros-
similhana chamando o mtodo _update(Listagem 9.17).
Listagem 9.17: Classe Varivel Aleatria Bayesiana Adio de

dados e clculo da Verossimilhana.
42 s e l f . ppf = pt . ppf
43 s e l f . r v s = pt . r v s
44 def _update ( s e l f ) :
45 """
46 Calculate likelihood function
47 """
48 if s e l f . data :
49 d = s e l f . data [ 1]
50 sc = s e l f . pars [ 1 ]
51 m = s e l f . range [ 0 ]
52 M = s e l f . range [ 1 ]
54 #s e l f . l i k e f u n returns log
likelihood
55 lik = exp ( a r r a y ( [ s e l f . l i k e f u n ( ( d
, i , sc ) ) for i in a r a n g e (m,M,
step ) ] ) )
57
58 def addData ( s e l f , data = []) :
59 """
60 Adds dataset to variable ' s data
store
61 """
Os mtodos getPriorSample e getPriorDist retornam amos-

tras e a PDF da distribuio a priori, respectivamente(Listagem
9.18).
Listagem 9.18: Classe Varivel Aleatria Bayesiana Amostras e

PDF da a priori.
63 s e l f . _update ( )
64
65 def getPriorSample ( s e l f , n) :
66 ' ' '
67 Returns a sample from the prior
distribution
68 ' ' '

69 return s e l f . r v s ( s i z e =n )
70
71 def getPriorDist ( s e l f ) :
72 """
73 Returns the prior PDF .
Por m temos o mtodo mais complexo: getPosteriorSample

(Listagem 9.19). Este mtodo responsvel por atualizar a distri-
buio posterior da varivel sempre que se solicitar uma amostra.
Utiliza um mtodo de amostragem por importncia no qual se rea-
mostra a distribuio a priori com um probabilidade proporcional
ao produto da verossimilhana e da distribuio a priori. Vale no-
tar, que se existir alguma posterior j calculada, esta utilizada
como a priori. Como deve ser.
Listagem 9.19: Classe Varivel Aleatria Bayesiana Gerando a

posterior.
74 """
75 return s e l f . pdf ( arange ( s e l f . range
[ 0 ] , s e l f . range [ 1 ] , s e l f . r e s ) )
76 def getPosteriorSample ( s e l f , n) :
77 """
78 Return a sample of the posterior
distribution .
79 """
80 if s e l f . p o s t e r i o r . any ( ) :# Use last
posterior as prior
81 k= k d e . g a u s i a n _ k d e ( s e l f .
posterior )
82 s= k . r e s a m p l e ( n )
83 else :
84 s = s e l f . getPriorSample (n)
86 m = s e l f . range [ 0 ]
87 M = s e l f . range [ 1 ]
89 s u p p = a r a n g e (m,M, s t e p )#s u p p o r t
g r e a t e r ( s . r a v e l ( ) ,m) , s )#
removing o u t o f r a n g e
samples
91 d = u n i f o r m . r v s ( l o c =0 , s c a l e =1 ,
s i z e =l e n ( s ) )#U n i f o r m 0 1
samples
92 w = s e l f . p d f ( supp ) s e l f .
likelihood
93 w = w/sum (w) #n o r m a l i z i n g
weights
95 w = w [ s x 1]# s e a r c h sorted
returns 1 b a s e d binlist
98 return post
O cdigo completo deste programa(Listagem 9.21) inclui, ainda,

algumas linhas para testar a classe (Listagem 9.20). Este teste
consiste em inicializar a varivel com uma distribuio a priori
Normal com mdia = 3 e desvio padro = 1. Um pequeno
conjunto de observaes, escolhido de forma a no concordar com
a distribuio a priori, utilizado para demonstrar a atualizao
da varivel(Figura 9.12).
Listagem 9.20: Classe Varivel Aleatria Bayesiana Cdigo de

teste.
113 return lambda ( x ) : l i k e . B e t a ( x

[0] ,x[1] ,x[2])
114
115 if __name__=="__main__" :
116 bv = BayesVar ( norm , ( 3 , 1 ) , r a n g e = ( 0 , 5 ) )
117 data = ones ( 2 0 )
118 bv . addData ( d a t a )
119 p = bv . g e t P o s t e r i o r S a m p l e ( 2 0 0 0 0 0 )
120 P . p l o t ( a r a n g e ( bv . r a n g e [ 0 ] , bv . r a n g e [ 1 ] ,
bv . r e s ) , bv . l i k e l i h o o d , ' ro ' , l w =2)
bv . r e s ) , bv . g e t P r i o r D i s t ( ) , ' g+ ' , l w =2)
122 P. hist (p , normed =1)
123 P. legend ( [ ' Likelihood ' , ' Prior ' ] )
Figura 9.12: Resultado da listagem 9.21.

Listagem 9.21: Classe Varivel Aleatria Bayesiana Listagem
completa
1 # e n c o d i n g : l a t i n 1
B a y e s . py
3 # copyright 2007 Flavio Codeco Coelho
4 # Licensed u n d e r GPL v3
5 from numpy import
6 import l i k e , s y s
8 from s c i p y . s t a t s import
9
10 class BayesVar :
11 """
12 Bayesian random variate .
13 """
, r e s o l u t i o n =512) :
15 ' ' '
16 Inicializa varivel aleatria .
17 Adquire mtodos da classe priortype
.
stats
20 ' ' '
21 s e l f . p r i o r n = p r i o r t y p e . name
22 s e l f . _ f l a v o r i z e ( p r i o r t y p e ( pars ) ,
priortype )
resolution
26 self . likefun = s e l f . _Likelihood ( s e l f

. priorn )
28 s e l f . data = []
30
31 def _ f l a v o r i z e ( s e l f , pt , ptbase ) :
32 ' ' '
33 add methods from distribution type
34 ' ' '
35 s e l f . c d f = pt . c d f
36 self . isf = pt . i s f
37 if i s i n s t a n c e ( ptbase , rv_continuous ) :
38 s e l f . pdf = pt . pdf
39 elif i s i n s t a n c e ( ptbase , r v _ d i s c r e t e ) :
40 s e l f . p d f = p t . pmf
41 else : sys . exit ( ' Invalid distribution
object ' )
42 s e l f . ppf = pt . ppf
43 s e l f . r v s = pt . r v s
44 def _update ( s e l f ) :
45 """
46 Calculate likelihood function
47 """
49 d = s e l f . data [ 1]
50 sc = s e l f . pars [ 1 ]
51 m = s e l f . range [ 0 ]
52 M = s e l f . range [ 1 ]
54 #s e l f . l i k e f u n returns log
likelihood
55 lik = exp ( a r r a y ( [ s e l f . l i k e f u n ( ( d
, i , sc ) ) for i in a r a n g e (m,M,
step ) ] ) )
57
58 def addData ( s e l f , data = []) :
59 """
60 Adds dataset to variable ' s data
store
61 """
62 s e l f . d a t a . append ( a r r a y ( d a t a ) )
63 s e l f . _update ( )
64
65 def getPriorSample ( s e l f , n) :
66 ' ' '
67 Returns a sample from the prior
distribution
68 ' ' '
69 return s e l f . r v s ( s i z e =n )
70
71 def getPriorDist ( s e l f ) :
72 """
73 Returns the prior PDF .
74 """
75 return s e l f . pdf ( arange ( s e l f . range
[ 0 ] , s e l f . range [ 1 ] , s e l f . r e s ) )
76 def getPosteriorSample ( s e l f , n) :
77 """
78 Return a sample of the posterior
distribution .
79 """
80 if s e l f . p o s t e r i o r . any ( ) :# Use last
posterior as prior
81 k= k d e . g a u s i a n _ k d e ( s e l f .
posterior )
82 s= k . r e s a m p l e ( n )
83 else :
84 s = s e l f . getPriorSample (n)
86 m = s e l f . range [ 0 ]
87 M = s e l f . range [ 1 ]
89 s u p p = a r a n g e (m,M, s t e p )#s u p p o r t
g r e a t e r ( s . r a v e l ( ) ,m) , s )#
removing o u t o f r a n g e
samples
91 d = u n i f o r m . r v s ( l o c =0 , s c a l e =1 ,
s i z e =l e n ( s ) )#U n i f o r m 0 1
samples
92 w = s e l f . p d f ( supp ) s e l f .
likelihood
93 w = w/sum (w) #n o r m a l i z i n g
weights
95 w = w [ s x 1]#s e a r c h sorted
returns 1 b a s e d binlist
98 return post
99 else :
100 return []
101
102 def _ Li k e li h oo d ( s e l f , typ ) :
103 ' ' '
104 Define familia paramtrica da
verossimilhana .
105 Retorna funo de verossimilhana .
106 typ deve ser uma string .
107 ' ' '
108 if t y p == ' norm ' :
109 return lambda ( x ) : l i k e . Normal ( x
[0] ,x[1] ,1./x[2])
110 elif t y p == ' expon ' :
111 return lambda ( x ) : ( 1 . / x [ 2 ] ) x
[0]. size e x p ( ( 1 . / x [ 2 ] ) sum (
x[0]) )
112 elif t y p == ' beta ' :
113 return lambda ( x ) : l i k e . B e t a ( x
[0] ,x[1] ,x[2])
114
115 if __name__=="__main__" :
116 bv = BayesVar ( norm , ( 3 , 1 ) , r a n g e = ( 0 , 5 ) )
117 data = ones ( 2 0 )
118 bv . addData ( d a t a )
119 p = bv . g e t P o s t e r i o r S a m p l e ( 2 0 0 0 0 0 )
bv . r e s ) , bv . l i k e l i h o o d , ' ro ' , l w =2)
bv . r e s ) , bv . g e t P r i o r D i s t ( ) , ' g+ ' , l w =2)
122 P. hist (p , normed =1)
123 P. legend ( [ ' Likelihood ' , ' Prior ' ] )
124 P. t i t l e ( ' Bayesian inference ' )
125 P . s a v e f i g ( ' b a y e s v a r . png ' , d p i =400)
126 P . show ( )
9.10 Exerccios
1. Compare a acurcia do amostrador de Metropolis-Hastings
com o amostrador oferecido pelo mtodo resample do objeto
retornado por gaussian kde. Teste com diferentes formas de
distribuio. O mtodo resample uma mera amostragem
com reposio.
9.10. EXERCCIOS 249
2. Verique a importncia do tamanho amostral na atualizao

da distribuio posterior de uma varivel, utilizando o pro-
grama da listagem 9.21
3. Experimente diferentes valores para a varincia da distribui-

o a priori do exemplo 9.8, e verique o efeito na conver-
gncia do algoritmo.
4. Utilize o mtodo do hipercubo latino ilustrado na listagem 9.1

para gerar amostras das distribuies a priori nos exemplos
9.8 e 9.21 e avalie o seu impacto na qualidade das estimativas.
Apndices
251
Introduo ao Console
Gnu/Linux
Guia de sobrevivncia no console do Gnu/Linux
O console Gnu/Linux um poderoso ambiente de trabalho, em

contraste com a interface limitada, oferecida pelo sistema ope-
racional DOS, ao qual comumente comparado. O console Gnu/-
Linux tem uma longa histria desde sua origem no Bourne shell,
distribuido com o Sistema operacional(SO) UNIX verso 7. Em
sua evoluo, deu origem a algumas variantes. A variante mais
amplamente utilizada e que ser objeto de utilizao e anlise neste
captulo o Bash ou Bourne Again Shell. Ao longo deste cap-
tulo o termo console e shell sero utilizados com o mesmo sentido,
ainda que, tecnicamente no sejam sinnimos. Isto se deve falta
de uma traduo mais adequada para a palavra inglesa shell".
Qual a relevncia de um tutorial sobre shell em um livro sobre
computao cientca? Qualquer cientista com alguma experin-
cia em computao est plenamente consciente do fato de que a
maior parte do seu trabalho, se d atravs da combinao da fun-
cionalidade de diversos aplicativos cientcos para a realizao de
tarefas cientcas de maior complexidade. Neste caso, o ambiente
de trabalho chave para agilizar esta articulao entre aplicati-
vos. Este captulo se prope a demonstrar, atravs de exemplos,
que o GNU/Linux um ambiente muito superior para este tipo
de atividade, se comparado com Sistemas Operacionais voltados
253
Console Gnu/Linux
principalmente para usurios leigos.

Alm do Console e sua linguagem (bash), neste captulo va-
mos conhecer diversos aplicativos disponveis no sistema operacio-
nal Gnu/Linux, desenvolvidos para serem utilizados no console.
A linguagem BASH
A primeira coisa que se deve entender antes de comear a estudar
o shell do Linux, que este uma linguagem de programao bas-
tante poderosa em si mesmo. O termo Shell, cpsula, traduzido
literalmente, se refere sua funo como uma interface entre o
usurio e o sistema operacional. A shell nos oferece uma interface
textual para invocarmos aplicativos e lidarmos com suas entradas
e sadas. A segunda coisa que se deve entender que a shell no o
sistema operacional, mas um aplicativo que nos facilita a interao
com o SO.
O Shell no depende de interfaces grcas sosticadas, mas co-
mumente utilizado atravs de uma janela, do conforto de uma
interface grca. Na gura 1, vemos um exemplo de uma sesso
do bash rodando em uma janela.
Alguns Comando teis
ls Lista arquivos. pwd Imprime o nome do di-

retrio corrente (caminho
cp Copia arquivos. completo).
mv Renomeia ou move arqui- mkdir Cria um diretrio.

vos.
rmdir Remove um diretrio.
rm Apaga arquivos (de ver- Para remover recursiva-
dade!). mente toda uma rvore

de diretrios use rm -
ln Cria links para arquivos. rf(cuidado!).
254
A linguagem BASH
Figura 1: Konsole: janela contendo uma sesso bash (ou outra) no

KDE.
cat Joga o arquivo inteiro na tail Visualiza o nal do ar-

tela. quivo.
less Visualiza o arquivo com

nl Visualiza com numerao
das linhas.
possibilidade de movimen-
tao e busca dentro do
od Visualiza arquivo binrio
mesmo.
em base octal.
head Visualiza o incio do ar- xxd Visualiza arquivo binrio

quivo. em base hexadecimal.
255
Console Gnu/Linux
gv Visualiza arquivos Posts- locate Localiza arquivo por

cript/PDF. meio de ndice criado com
updatedb.
xdvi Visualiza arquivos DVI
gerados pelo TEX. which Localiza comandos.
stat Mostra atributos dos ar- whereis Localiza o binrio
quivos. (executvel), fontes, e p-
gina man de um comando.
wc Conta bytes/palavras/li-
nhas. grep Busca em texto retor-
nando linhas.
du Uso de espao em disco.
cut Extrai colunas de um ar-
le Identica tipo do arquivo. quivo.
touch Atualiza registro de l- paste Anexa colunas de um ar-
tima atualizao do arquivo texto.
quivo. Caso o arquivo no

exista, criado.
sort Ordena linhas.
uniq Localiza linhas idnticas.
chown Altera o dono do ar-
quivo. gzip Compacta arquivos no for-
mato GNU Zip.
chgrp Altera o grupo do ar-
quivo. compress Compacta arquivos.
chmod Altera as permisses de bzip2 Compacta arqui-
um arquivo. vos(maior compactao do
que o gzip, porm mais
chattr Altera atributos avan- lento.
ados de um arquivo.
zip Compacta arquivos no for-
lsattr Lista atributos avana- mato zip(Windows).
dos do arquivo.
di Compara arquivos linha a
nd Localiza arquivos. linha.
256
Entradas e Sadas, redirecionamento e "Pipes".
comm Compara arquivos orde- uptime Retorna tempo desde o

nados. ltimo boot, e carga do
sistema.
cmp Compara arquivos byte
por byte. top Monitora processos em exe-
cuo.
md5sum Calcula checksums.
df Espao livre em todos os dis- free Mostra memria livre.
cos(pendrives e etc.) mon- kill Mata processos.
tados.
nice Ajusta a prioridade de um
mount Torna um disco acess-
processo.
vel.
fsck Verica um disco procu-

renice Altera a prioridade de
um processo.
rando por erros.
sync Esvazia caches de disco. watchtervalos

Executa programas a in-
regulares.
ps Lista todos os processos.
crontab Agenda tarefas peri-
w Lista os processos do usurio. dicas.
Entradas e Sadas, redirecionamento e "Pipes".

O esquema padro de entradas e sadas dos SOs derivados do
UNIX, est baseado em duas idias muito simples: toda comunica-
ao formada por uma sequncia arbitrria de caracteres (Bytes),
e qualquer elemento do SO que produza ou aceite dados tratado
como um arquivo, desde dispositivos de hardware at programas.
Por conveno um programa UNIX apresenta trs canais de
comunicao com o mundo externo: entrada padro ou STDIN,
sada padrao ou STDOUT e sada de erros padro ou STDERR.
O Bash(assim como praticamente todas as outras shells) torna
muito simples a utilizao destes canais padro. Normalmente, um
257
Console Gnu/Linux
usurio utiliza estes canais com a nalidade de redirecionar dados

atravs de uma sequncia de passos de processamento. Como este
processo se assemelha ao modo como canalizamos gua para lev-la
de um ponto ao outro, Estas construes receberam o apelido de
pipelines"ou tubulaes onde cada segmento chamado de pipe".
Devido a essa facilidade, muitos dos utilitrios disponveis na
shell do Gnu/Linux foram desenvolvidos para fazer uma nica coisa
bem, uma vez que funes mais complexas poderiam ser obtidas
combinando programas atravs de pipelines".
Redirecionamento
Para redirecionar algum dado para o STDIN de um programa, utili-

zamos o caracter <. Por exemplo, suponha que temos um arquivo
chamado nomes contendo uma lista de nomes, um por linha. O
comando sort < nomes ir lanar na tela os nomes ordenados al-
fabeticamente. De maneira similar, podemos utilizar o caracter >
para redirecionar a saida de um programa para um arquivo, por
exemplo.
Listagem 22: Redirecionando STDIN e STDOUT
1 $ s o r t < nomes > n o m e s _ o r d e n a d o s
O comando do exemplo 22, cria um novo arquivo com o con-

tedo do arquivo nomes, ordenado.
Pipelines
Podemos tambm redirecionar sadas de comandos para outros co-

mandos, ao invs de arquivos, como vimos anteriormente. O carac-
tere que usamos para isto o | conhecido como pipe. Qualquer
linha de comando conectando dois ou mais comandos atravs de
pipes denominada de pipeline.
258
Prolas Cientcas do Console Gnu/Linux
Listagem 23: Lista ordenada dos usurios do sistema.
1 $ cut d : f 1 < / e t c / passwd | sort

2 ajaxterm
3 avahi
4 a v a h i a u t o i p d
5 backup
6 beagleindex
7 bin
8 boinc
9 ...
O simples exemplo apresentado d uma idia do poder dos pipe-

lines, alm da sua convenincia para realizar tarefas complexas,
sem a necessidade de armazenar dados intermedirios em arquivos,
antes de redirecion-los a outros programas.

O console Gnu/Linux extrai a maior parte da sua extrema versati-
lidade de uma extensa coleo de aplicativos leves desenvolvidos
7
para serem utilizados diretamente do console. Nesta seo, vamos
ver alguns exemplos, uma vez que seria impossvel explorar todos
eles, neste simples apndice.
Gnu plotutils
O GNu Ploting Utilities uma suite de aplicativos grcos e

matemticos desenvolvidos para o console Gnu/Linux. So eles:
graph L um ou mais conjuntos de dados a partir de arquivos ou

de STDIN e prepara um grco;
7 Desenvolvidos principalmente pelo projeto Gnu
259
Console Gnu/Linux
plot Converte Gnu metale para qualquer dos formatos listados

acima;
pic2plot Converte diagramas criados na linguagem pic para qual-

quer dos formatos acima;
tek2plot Converte do formato Tektronix para qualquer dos for-

matos acima.
Estes aplicativos grcos podem criar e exportar grcos bi-

SVG, PNG, PNM, pseudo-GIF,
dimensionais em treze formatos diferentes:
WebCGM, Illustrator, Postscript, PCL 5, HP-GL/2, Fig (editvel
com o editor de desenhos xfig), ReGIS, Tektronix ou GNU Metafile.
Aplicativos Matemticos:
ode Integra numericamente sistemas de equaes diferenciais or-
dinrias (EDO);
spline Interpola curvas utilizando splines cbicas ou exponenci-

ais. Pode ser utilizado como ltro em tempo real.
graph
A cada vez que chamamos o programa graph, ele l um ou mais
conjuntos de dados a partir de arquivos especicados na linha de
comando, ou diretamente da STDIN, e produz um grco. O grco
pode ser mostrado em uma janela, ou salvo em um arquivo em
qualquer dos formatos suportados.
Listagem 24: Plotando dados em um arquivo.
1 $ graph T png < a r q u i v o _ d e _ d a d o s _ a s c i i >

p l o t . png
Se o arquivo_de_dados_ascii contiver duas colunas de nme-

ros, o programa as atribuir a x e y, respectivamente. Os pares
260
ordenados que daro origem aos pontos do grco no precisam

estar em linhas diferentes. por exemplo:
Listagem 25: Desenhando um quadrado.
1 $ echo .1 .1 .1 .9 .9 .9 .9 .1 .1 .1 | graph
T X C m 1 q 0.3
A listagem 25 plotar um quadrado com vrtices em (0.1,0.1),

(0.1,0.9), (0.9,0.9) e (0.9,0.1). A repetio do primeiro vr-
tice garante que o polgono ser fechado. A opo -m indica o tipo
da linha utilizada: 1-linha slida, 2-pontilhada, 3-ponto e trao,
4-traos curtos e 5-traos longos. A opo -q indica que o qua-
drado ser preenchido (densidade 30%) com a mesma cor da linha:
vermelho (-C indica grco colorido).
O programa graph aceita ainda muitas outras opes. Leia o
manual(man graph) para descobr-las.
spline
O programa funciona de forma similar ao graph no que diz res-
peito entradas e sadas. Como todos os aplicativos de console,
benecia-se muito da interao com outros programas via pipes.
Listagem 26: Uso do spline

1 $ echo 0 0 1 1 2 0 | spline | graph T X
Spline no serve apenas para interpolar funes, tambm pode

ser usado para interpolar curvas em um espao d-dimensional utilizando-
se a opao -d.
Listagem 27: Interpolando uma curva em um plano.
1 echo 0 0 1 0 1 1 0 1 | spline d 2 a s |
graph T X
O comando da listagem 27 traar uma curva passando pelos

pontos (0,0), (1,0), (1,1) e (0,1). A opo -d 2 indica que
261
Console Gnu/Linux
Figura 2: Usando spline.
262
Figura 3: Interpolando uma curva em um plano.
a varivel dependente bi-dimensional. A opo -a indica que a

varivel independente deve ser gerada automticamente e depois
removida da sada (opo -s).
263
Console Gnu/Linux
ode
O utilitrio ode capaz de produzir uma soluo numrica de sis-
temas de equaes diferenciais ordinrias. A sada de ode pode
ser redirecionada para o utilitrio graph, que j discutimos anteri-
ormente, de forma que as solues sejam plotadas diretamente,
medida em que so calculadas.
Vejamos um exemplo simples:
dy
= y(t) (3)
dt
A soluo desta equao :
y(t) = et (4)
Se ns resolvermos esta equao numericamente, a partir do

valor inicial y(0) = 1, at t = 1 esperaramos obter o valor de e
1
como ltimo valor da nossa curva (e = 2.718282, com 7 algarismos
signicativos). Para isso digitamos no console:
Listagem 28: Resolvendo uma equao diferencial simples no con-

sole do Linux.
1 $ ode
2 y '= y
3 y=1
4 print t ,y
5 step 0 ,1
Aps digitar a ultima linha do exemplo 28, duas colunas de

nmeros aparecero: a primeira correspondendo ao valor de t e
a segunda ao valor de y; a ultima linha ser 1 2.718282. Como
espervamos.
Para facilitar a re-utilizao dos modelos, podemos colocar os
comandos do exemplo 28 em um arquivo texto. Abra o seu editor
favorito, e digite o seguinte modelo:
264
Listagem 29: Sistema de trs equaes diferenciais acopladas
1 # O modelo de Lorenz , Um s i s t e m a de trs

EDOs a c o p l a d a s ,
2 # com um p a r m e t r o r.
3 x' = 3 (xy )
4 y' = x z+r xy
5 z' = x yz
6
7 r = 26
8 x = 0; y = 1; z = 0
9 print x, y
10 step 0, 200
Salve o arquivo com o nome lorenz. Agora digite no console a

seguinte linha de comandos:
1 $ ode < lorenz | graph T X C x 10 10 y

20 20
E eis que surgir a bela curva da gura 4.
265
Console Gnu/Linux
Figura 4: Atrator de Lorenz.
266
ndice Remissivo
arange, 46 EDO, 258

aranha, 190 elif, 28
array, 46 else, 28
.shape, 46 Emacs, 81
enumerate, 30
bancos de dados, 185 equaes de diferena, 145
break, 32 equaes diferenciais, 148
espao de nomes, 10
cadeias de Markov, 214
excees, 32
classe, 53
except, 32
atributos, 54
mtodos, 55 nally, 32
conjuntos, 27 for, 30
Console Python, 4 FORTRAN, 117
Controle de Verses, 86 funes, 34
Mercurial, 88 lista de argumentos va-
Ctypes, 105 rivel, 36
passando argumentos, 36
decoradores, 38 funoes
dicionrios, 24 argumentos opcionais, 35
mtodos, 25
geradores, 38
Editores, 80 Gibbs, 219
editores, 80 Gnu Nano, 81
267
ndice Remissivo
Grafos, 169 MCMC, 216

graph, 258 Mercurial, 88
Metropolis-Hastings, 217
Herana, 56 modelagem matemtica, 135
modelos dinmicos, 145
IDEs, 83
modelos exponenciais, 142
if, 28
modelos lineares, 137
import, 42
monte carlo, 205
Inferncia Bayesiana, 203
integrao numrica, 148 Nmeros complexos, 10
Ipython, 73 NetworkX, 172
Comandos mgicos, 75 numpy, 45
iterao, 29
objetos, 52
Java, 125 operadores aritmticos, 8
Jedit, 81
Jython, 126 pacotes, 44
Palavras reservadas, 4
lambda, 37
pickle, 186
LHS, 200
print, 46
listas, 13
pydoc, 47
mtodos, 16
Pyrex, 106
mdulo
R, xix
numpy.linalg, 46
return, 37
scipy, 46
Mdulos scipy, 46
BeautifulSoup, 190 Scite, 81
email, 181 Shedskin, 111
mailbox, 182 sqlite, 187
threading, 178 SQLObject, 190
mdulos, 41 strings, 22
numpy, 45 formatando, 23
Mathematica, xix
Matlab, xix try, 32
268
tuplas, 19
unidades, 155
unum, 159
urllib, 193
urllib2, 193
uso interativo, 5
verossimilhana, 228
weave, 100
web-spider, 190
while, 29
zip, 31
269
Colophon
Este livro foi formatado usando
LAT X, criado por Leslie
E
Lamport e a classe memoir. O
corpo do texto utiliza fontes de
tamanho 10 Modern Roman,
criadas por Donald Knuth.
Outras fontes incluem Sans,
Smallcaps, Italic, Slanted and
Typewriter, todas da famlia
Computer Modern desenvolvida
por Knuth.

Computação Científica Com Python

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Computação Científica Com Python

Uploaded by

Copyright:

Available Formats

Computao

Capa: Mosaico construdo com as guras deste livro imitando o logotipo da

Reviso ortogrca: Paulo F. Coelho e Luciene C. Coelho.

Edio do autor. Petrpolis - RJ - Brasil

Primeira Edio: Julho 2007

Richard M. Stallman. Sem o Software Livre tudo o que eu sei

Linus Torvalds. Sem o Linux, nunca teria me aproximado o su-

Guido van Rossum. Muito obrigado por esta bela linguagem, e

Comunidade Python. Obrigado por todas esta extenses ma-

Alem destas pessoas gostaria ainda de agradecer ao Fernando Pe-

Utilizando Classes como Estruturas de Dados Gen-

3 Criando Grcos em Python 59

5 Interagindo com Outras Linguagens 99

6 Modelagem Matemtica 135

7 Teoria de Grafos 169

8 Interao com Bancos de Dados 185

9 Simulaes Estocsticas 199

Console Gnu/Linux 253

ndice Remissivo 267

1.1 Verso HTML da documentao gerada pelo Epydoc. . . . 50

3.1 Histograma simples a partir da listagem 3.2 . . . . . . . 61

4.1 Editor emacs em modo Python e com Code Browser

5.1 Comparao da performance entre o Python e o C (we-

6.1 Diagrama de disperso do exemplo do taxi. A reta su-

7.1 Um grafo simples. . . . . . . . . . . . . . . . . . . . . . 171

9.1 Amostragem (n=20) de uma distribuio normal com

1 Konsole: janela contendo uma sesso bash (ou outra)

1.1 Mtodos de Listas. . . . . . . . . . . . . . . . . . . . . . 16

3.1 Principais comandos de plotagem do MPL . . . . . . . . 62

6.1 Valor de corridas de taxi . . . . . . . . . . . . . . . . . . 138

1.1 O console interativo do Python . . . . . . . . . . . . 3

1.54 importing a package . . . . . . . . . . . . . . . . . . 45

8.5 Restante do cdigo da aranha. . . . . . . . . . . . . 193

C omputao cientca no uma rea do conhecimento muito

mnimo para escrever um programa cientco nestas linguagens

passa a ser distribudo sob a Python License, compatvel com a

Multiplataforma: O Python pode ser instalado em qualquer pla-

Portabilidade: Aplicativos desenvolvidos em Python podem ser

Software Livre: O Python software livre, no impondo qual-

Extensibilidade: O Python pode ser extendido atravs de m-

Orientao a objeto: Tudo em Python um objeto: funes,

3 GNU General Public License

Tipagem forte: Variveis de um determinado tipo no podem

Cdigo legvel: O Python, por utilizar uma sintaxe simplicada

Flexibilidade: O Python j conta com mdulos para diversas

Operao com arquivos: A manipulao de arquivos, tais como

Uso interativo: O Python pode ser utilizado interativamente, ou

de computao cientca na linguagem Python. Mas para inspirar

1 >>> import this

1. Um curso introdutrio linguagem Python, no qual se faria

2. Um curso combinado de Python e computao cientca. O

Como referncia pessoal, este livro atende a um pblico bas-

7O cdigo fonte do exemplos est disponvel na seguinte URL: http://

8 Recomendo o VirtualBox (www.virtualbox.org), software livre e fan-

N este Captulo, faremos uma breve introduo linguagem

1.1 Primeiras impresses

Listagem 1.1: O console interativo do Python

Toda linguagem, seja ela de programao ou linguagem natural,

Listagem 1.2: Palavras reservadas no podem ser utilizadas como

A linguagem Python em sua verso atual (2.5), possui 30 pala-

mentos do mdulo __builtins__ 1

Listagem 1.3: Denio da palavra reservada for.

1.2 Uso Interativo Execuo a Partir de

Capa: Mosaico construdo com as guras deste livro imitando o logotipo da

Reviso ortogrca: Paulo F. Coelho e Luciene C. Coelho.

3 Criando Grcos em Python 59

4.1 Editor emacs em modo Python e com Code Browser

C omputao cientca no uma rea do conhecimento muito

mnimo para escrever um programa cientco nestas linguagens

Cdigo legvel: O Python, por utilizar uma sintaxe simplicada

de computao cientca na linguagem Python. Mas para inspirar

2. Um curso combinado de Python e computao cientca. O

mentos do mdulo builtins 1

Listagem 1.3: Denio da palavra reservada for.

Usurios familiarizados com ambientes de programao cientcos

1 Ateno, os componentes de builtins, no geram erros de sintaxe

Mas que lixo aquele antes do nosso Al mundo? Trata-

Noventa e nove por cento das aplicaes cientcas envolvem algum

precisamos nos referenciar e que podem se modicar. Esta repre-

O Python tambm reconhece nmeros reais (ponto-utuante)

As variveis criadas por atribuio cam guardadas na memria

5 Mais quaisquer variveis explicitamente denidas como globais

O comando lista[1:3], delimita uma fatia que vai do ele-

Listagem 1.17: Selecionando o nal de uma lista.

Este comando signica todos os elementos a partir do elemento

Listagem 1.25: Denindo uma Tupla.

Listagem 1.26: Outras formas de denir tuplas.

Conforme exemplicado em 1.26, uma tupla vazia, denida