Sumário

Introdução.............................................................................................................................................3
Histórico...........................................................................................................................................3
Características da linguagem........................................................................................................... 3
Modo interativo................................................................................................................................3
Bytecode.......................................................................................................................................... 4
Ferramentas......................................................................................................................................4
Frameworks..................................................................................................................................... 5
Sintaxe.................................................................................................................................................. 6
Controle de Fluxo................................................................................................................................. 8
Laços.....................................................................................................................................................9
Iteração...........................................................................................................................................10
Variáveis.............................................................................................................................................12
Números.........................................................................................................................................12
Verdadeiro e falso..........................................................................................................................12
Strings............................................................................................................................................ 13
Listas...................................................................................................................................................18
Tuplas.............................................................................................................................................20
Dicionários (Hashes).......................................................................................................................... 21
Funções...............................................................................................................................................23
PyDOC............................................................................................................................................... 25
Exercícios I......................................................................................................................................... 26
Módulos.............................................................................................................................................. 27
Namespaces................................................................................................................................... 28
Módulos da biblioteca padrão........................................................................................................28
Pacotes................................................................................................................................................ 30
Arquivos e I/O.................................................................................................................................... 31
Introspecção........................................................................................................................................32
Módulo inspect.............................................................................................................................. 32
Exceções............................................................................................................................................. 34
Decoradores........................................................................................................................................ 35
Exercícios II........................................................................................................................................37
Classes................................................................................................................................................ 38
Métodos e atributos........................................................................................................................38
Herança simples.............................................................................................................................40
Herança múltipla............................................................................................................................40
Properties....................................................................................................................................... 42
Sobrecarga de operadores.............................................................................................................. 43
Classes abertas............................................................................................................................... 43
Exercícios III...................................................................................................................................... 45
Persistência......................................................................................................................................... 46
Serialização....................................................................................................................................46
Banco de dados...................................................................................................................................47
DBI.................................................................................................................................................47
ZODB................................................................................................................................................. 49
Web.....................................................................................................................................................51
MVC................................................................................................................................................... 53
Exercícios IV...................................................................................................................................... 56
Geradores............................................................................................................................................57
Programação funcional....................................................................................................................... 58
 Mapeamento...................................................................................................................................58
Filtragem........................................................................................................................................58
Redução......................................................................................................................................... 59
Transposição.................................................................................................................................. 60
List comprehension........................................................................................................................62
Generator expression..................................................................................................................... 62
XML................................................................................................................................................... 63
Exercícios V....................................................................................................................................... 66
Introdução 3

Introdução

Python é uma linguagem de altíssimo nível (Very High Level Language, como Perl, PHP e Ruby),
orientada a objetos, de tipagem dinâmica e forte, interpretada, interativa, Open Source (com licença
compatível com GPL) e sua especificação é mantida pela PSF (Python Software Foundation)

Histórico

Python foi criada em 1990, a partir da linguagem ABC, e tinha como foco original usuários como
físicos e engenheiros. Segundo seu criador, Guido van Rossum, a linguagem foi concebida para
ocupar o espaço que existia entre as linguagens C/C++ e o shell do UNIX.

Hoje, a linguagem é bem aceita na industria por empresas de alta tecnologia, tais como:

• Google (Crawlers do sistema de busca, Gmail e outras aplicações)

• Microsoft (IronPython: Python para .NET)
• Nokia (disponível para as linhas recentes de celulares e PDAs)
• Yahoo (aplicações Web)
• Disney (animações 3D)

Características da linguagem

• Sintaxe clara e concisa

• Estruturas de alto nível (listas, tuplas, dicionários, data / hora, complexos)
• Muitos módulos e frameworks disponíveis
• Interpretada via bytecode pela máquina virtual Python
• Portável
• Utilizada como linguagem script em vários softwares, entre eles: [Link],
PostgreSQL e Blender
• Pode ser utilizada em modo interativo
• Recursos modernos: iteradores, geradores, introspecção, unidades de teste, ...

Modo interativo

O modo interativo é uma característica diferencial da linguagem, pois é possível testar e modificar o
código de um programa antes da inclusão do código nos programas, por exemplo.
Introdução 4

Python 2.4.3 (#69, Mar 29 2006, 17:35:34) [MSC v.1310 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> ary = [4, 5, 3, 6, 2, 7, 1, 9, 0]
>>> print ary
[4, 5, 3, 6, 2, 7, 1, 9, 0]
>>>

Bytecode

O código fonte é traduzido pelo interpretador para o formato bytecode, que é multiplataforma e
pode ser executado e distribuído sem fonte original.

Por padrão, o interpretador compila os fontes e armazena o bytecode em disco, para que a próxima
vez que o executar, não precise compilar novamente o programa, reduzindo o tempo de carga na
execução. Se os fontes forem alterados, o interpretador se encarregará de regerar o bytecode
automaticamente, mesmo utilizando o shell interativo. Porém quando um programa ou um módulo é
evocado, o interpretador faz a análise do código, compila se necessário e executá-lo na máquina
virtual Python.

O bytecode é armazenado em arquivos com extensão .pyc ou .pyo (bytecode otimizado)

Ferramentas

Existem muitas ferramentas de desenvolvimento para Python, como IDEs, editores e shells (que
aproveitam da capacidade interativa do Python)

IDEs:

• PyDev (plugin para o Eclipse)

• SPE (Stani's Python Editor)
• Eric

Editores:

• SciTE

Shells:

• PyCrust (gráfico)
• Ipython (texto)
Introdução 5

Frameworks

Alguns frameworks disponíveis mais conhecidos:

• Web: Django, TurboGears, Zope

• Interface gráfica: wxPython, PyGTK, PyQT
• Processamento cientifico: Numarray
• Processamento de imagens: PIL
• 2D: Matplotlib
• 3D: Visual Python, Panda3D
Sintaxe 6

Sintaxe

Um programa feito em Python é constituído de linhas lógicas, que são terminadas por um caractere
de nova linha ('\n'), ou continuadas na próxima linha, pelo caractere de contra-barra ('\') ou por
parênteses, colchetes ou chaves, em expressões que utilizam tais caracteres.

Exemplos:

# Uma linha de código

a=b+c
# Uma linha (quebrada por contra-barra)
x=x*f+\
x0 * f
# Uma lista (quebrada por vírgula)
l = [1, 2,
3, 4]
# Um dicionário
d = {'a': 1,
'b' : 2}

Observações:

• Após o caractere '#' até o final da linha, tudo é considerado um comentário e ignorado,
exceto por funções que trabalham diretamente com os comentários.
• Para alterar a codificação de um arquivo fonte é necessário acrescentar o comentário '#-#-
coding: <encoding-name> -#-' no inicio do arquivo.

Endentação:

• Em Python, os blocos de código são delimitados pelo uso de endentação.

• A endentação deve ser constante no bloco de código, porém é considerado uma boa prática
no projeto todo.
• A mistura tabulações e espaços deve ser evitada.

Exemplos:

a=1
b=2

if a < b:
print 'a menor'
else:
Sintaxe 7

print 'b menor' # funciona, mas evite

Controle de Fluxo 8

Controle de Fluxo

Sintaxe:

if <condição>:
<código>
elif <condição>:
<código>
elif <condição>:
<código>
else:
<código>

Aonde:

• <condição>: sentença que possa ser avaliada como verdadeira ou falsa.

• <código>: sequência de comandos.
• As clausulas elif e else são opcionais e podem existir vários elifs para o mesmo if.
• Parênteses só são necessários para evitar ambiguidades.

Exemplo:

temp = int(raw_input('Entre com a temperatura: '))

if temp < 0:
print 'Congelando...'
elif 0 <= temp <= 20:
print 'Frio'
elif 21 <= temp <= 25:
print 'Normal'
elif 26 <= temp <= 35:
print 'Quente'
else:
print 'Muito quente!'
Laços 9

Laços

Sintaxe:

for <alvo> in <sequência>:

<código>
continue
break
else:
<código>

while <condição>:
<código>
continue
break
else:
<código>

A clausula break interrompe o laço e continue passa para a próxima iteração. O código dentro do
else é executado ao final do laço, a não ser que o laço tenha sido interrompido por break.

Exemplo:

# Soma de 0 a 99
s=0
for x in range(1, 100):
s=s+x
print s

# De outra forma
s=0
x=1
while x < 100:
s=s+x
x=x+1
print s

A função range(m, n) retorna uma lista de inteiros, começando em “m” e menores que “n”.
O “for” aceita não só sequências estáticas, mas também sequências geradas por iteradores.
Laços 10

Iteração

Sequência Primeira iteração

1 x Agora, x aponta para 1.

2
3
4
5
6
...
“x” é apenas uma referência.

Sequência Segunda iteração

1
2 x Agora, x aponta para 2.
3
4
5
6
...
A referência foi atualizada.
Laços 11
Variáveis 12

Variáveis

Python usa tipagem dinâmica, o que significa que o tipo de uma variável é inferido pelo
interpretador em tempo de execução.

As variáveis são criadas através da atribuição e destruídas pelo coletor de lixo, quando não existem
mais referências a elas.

Os nomes das variáveis devem começar com letra (sem acentuação) ou sublinhado (_) e seguido por
letras (sem acentuação), dígitos ou sublinhados (_), sendo que maiúsculas e minúsculas são
consideradas diferentes.

Números

• Inteiro: 123 (decimal), 0632 (octal), 0xff00 (hexadecimal)

• Longo: 123L ou 123l
• Ponto Flutuante: 3.14, 10., .12, 1.23e-9
• Complexos: 10.0 + 3j

Exemplos:

# Tipos mais comuns

# Inteiro
i = 10
# Real
f = 1.5
# String
s = 'Python'
# Lista
l = [1, 2, 3, 'x', 'y', 'z']
# Tupla
t = ('a', 'b', 'c')
# Hash
d = {'Python': 10, 'PHP': 0}
# Arquivo
f = file('[Link]')

Verdadeiro e falso

Os seguintes valores são considerados falsos:

Variáveis 13

• São considerados falsos: False, None (nulo), 0 (zero), '' (string vazia), [] (lista vazia), ()
(tupla vazia), {} (dicionário vazio) e outras estruturas com tamanho (len()) igual a zero
• São considerados verdadeiros todos os outros objetos
• Os operadores lógicos são: and, or, not, is e in

Operadores:

Operador Método Operação

+ __add__ adição
- __sub__ subtração
* __mul__ multiplicação
** __pow__ potenciação
/ __div__ divisão
// __floordiv__ divisão truncada
% __mod__ módulo
< __lt__ menor
> __gt__ maior
<= __le__ menor ou igual
>= __ge__ maior ou igual
== __eq__ igual
!= __ne__ diferente
<< __lshift__ deslocamento à esquerda
>> __rshift__ deslocamento à direita
& __and__ “e” bit-a-bit
| __or__ “ou” bit-a-bit
^ __xor__ “ou exclusivo” bit-a-bit
~ __inv__ Inverte

Strings

As strings no Python são imutáveis, sendo assim, não é possível adicionar texto ou mesmo
modificar algum caractere.

Representação:

• Comum: 'texto' ou "texto"

• Multiline: '''texto várias linhas''' ou """texto várias linhas"""
• Unicode: u'texto unicode' ou u"texto"
• Raw: r'texto bruto\n'
Variáveis 14

Criação:

str1 = 'abcdefghij'
str2 = "outro texto"
str3 = '''este texto
tem mais de uma
linha'''

Acesso a elementos pelo índice:

print str1[2] # Imprime 'c'

print 'GSB'[1] # Imprime 'S'

Acesso a pedaços da string:

print str1[:2] # imprime 'ab'

print str1 [2:] # imprime 'cdefghij'
print str1[2:4] # imprime 'cd'

Funções de procura por sub-strings:

# No começo:
[Link]( 'abc') # Verdadeiro
[Link]('cba') # Falso

# No fim:
[Link]('ij') # Verdadeiro
[Link]('xy') # Falso

# Em qualquer posição:
[Link]('cde') # retorna 2
[Link]('XXX') # retorna -1, pois não existe

Funções de verificação de conteúdo:

#Se são somente letras:

'abc'.isalpha() # Verdadeiro
'123'.isalpha() # Falso
Variáveis 15

'a12'.isalpha() # Falso

#Se são somente números:

'abc'.isdigit() # Falso
'123'.isdigit() # Verdadeiro
'a12'.isdigit() # Falso

#Se são letras e números:

'abc'.isalnum() # Verdadeiro
'123'.isalnum() # Verdadeiro
'a12'.isalnum() # Verdadeiro

#Se são somente espaços:

' '.isspace() # Verdadeiro
' \t\n'.isspace() # Verdadeiro
'a'.isspace () # Falso

Transformar seqüências em texto e texto em seqüências:

#Juntando textos de uma lista em um texto só:

print '-'.join(['a', 'b', 'cde']) # Imprime a-b-cde

#Quebrando um texto em uma lista:

print 'nome:senha'.split(':') # Imprime [' nome', 'senha ']

Transformar a caixa do texto (novas instâncias serão criadas):

#Para maiúscula:
print 'abC'.upper() # Imprime: ABC

#Para minúscula:
print 'aBC'.lower() # Imprime: abc

#Inverter maiúsculas e minúsculas:

print 'aBc'.swapcase() # Imprime: AbC

Funções de verificação de conteúdo:

#Se está em maiúscula, minúscula, ...:

'abc'.islower() # Verdadeiro
Variáveis 16

'AbC'.islower() # Falso
'ABC'.isupper() # Verdadeiro

'Abc Teste'.istitle() # Verdadeiro

'Abc teste'.istitle() # Falso

Retirar caracteres (novas instâncias serão criadas):

#Da esquerda:
print 'abc'.lstrip() # Imprime: abc
print '_*_ abc _*_' .lstrip('*_') # Imprime: abc

#Da direita:
print 'abc'.rstrip() # Imprime: abc
print '_*_ abc _*_'.rstrip('*_') # Imprime : abc

#De ambos os lados:

print 'abc'.strip() # Imprime: abc
print '_*_ abc _*_'.strip( '*_' ) # Imprime: abc

Troca de caracteres (novas instâncias serão criadas):

#Troca de pedaços:
print 'este eh um teste'.replace('ste', 'ABC')
# Imprime: eABC eh um teABC

Troca de caracteres individuais, baseados em uma tabela:

import string

tabela = [Link]('ael', '431' )

txt = 'lammers like to write like this'
print [Link](tabela)

# Imprime: '14mm3rs 1ik3 to writ3 1ik3 this '

Interpolação:
Variáveis 17

Operador “%” é usado para fazer interpolação de strings.

print 'Agora são %2d:%2d.' % (16, 30)

# Imprime: Agora são 16:30.
Listas 18

Listas

Criação:

lista = [10, 2, 3, 'texto', 20]

Acesso a elementos pelo índice:

print lista [2] # imprime 3

Mudar elementos já existentes:

lista[0] = 123

Acesso a pedaços da lista:

sub_lista = lista[2:4] # pega de 2 a 4 (não incluso)

print sub_lista # imprime '[ 3, 'texto ' ]'
sl1 = lista[:3] # pega elementos até posicão 3
sl2 = lista[3:] # pega elementos da posição 3 até o fim

Acrescentando ao fim:

[Link](1) # Acrescenta 1 ao fim da lista

Estendendo a lista com outra lista:

[Link]([10, 20, 30])

lista += [40, 50, 60]

Ordenando a lista (altera a própria lista):

[Link]()
[Link](lambda x, y: cmp(y, x)) # reverso

Inverter lista (altera a própria lista):

Listas 19

[Link]()

Contar ocorrências de um elemento:

[Link](3) # retorna 1

Retorna a posição do elemento na lista:

[1, 2, 3, 4].index(3) # retorna 2

Inserir um elemento na posição desejada:

[Link](0, 'abc') # insere no começo da lista

Apagando um elemento:

del lista[2] # apaga o 3o elemento

Apagando um pedaço da lista:

del lista[3:5] # apaga da posição 4 até 5 (não incluso)

Mudando um pedaço da lista:

l =[1, 2, 3, 4, 5, 6]
l[2:4] = [10, 20]
print l # imprime '[1, 2, 10, 20, 5, 6]'

Repetindo uma lista:

l =[1, 2]*5 # l é[1, 2, 1, 2, 1, 2, 1, 2, 1, 2]

Tamanho da lista:

print len(range(10)) # imprime 10

Listas 20

Tuplas

Parecido com as listas, porém é imutável: não se pode acrescentar, apagar ou modificar valores.

Exemplos:

>>>tupla = (1, 2, 'abc')

>>>tupla[0]
1
>>>tupla[:2]
(1,2)
>>>tupla[2:]
('abc',)
>>>len(tupla)
3
t=1, 2, 3
>>>t
(1,2,3)

As tuplas é são mais eficientes do que as listas convencionais.

Dicionários (Hashes) 21

Dicionários (Hashes)

• Lista de associações entre uma chave única e uma estrutura

• Não existe garantia de ordem da chave
• Dicionários são mutáveis
• A chave tem que ser de tipo imutável (geralmente strings)
• Sintaxe: l = {'a': a, 'b': b, ..., 'z', z}

Estrutura:

Elementos Objetos
imutáveis quaisquer
Chaves Valores

Fractal IFS
Palheta Verde
Limites (640, 480)
(0, 0) (42, 35)

{'Fractal': 'IFS', 'Palheta': 'Verde', 'Limites':

(640, 480), (0, 0): (42, 35)}

Criação:

dic = {'nome': 'Shirley Manson', 'banda': 'Garbage'}

Acesso a elementos:

print dic['nome']

Adicionando elementos:
Dicionários (Hashes) 22

dic['album'] = 'Version 2.0'

dic[1] = 10
dic[(1, 2)] = 120

As chaves devem ser imutáveis:

lista = [1, 2]
dic[lista] = '***'

# Gera erro: TypeError: list objects are unhashable

Apagando um elemento do dicionário:

del dic['album']

Obtendo os itens, chaves e valores:

itens = [Link]()
chaves = [Link]()
valores = [Link]()

Obtendo os iteradores:

for chave in [Link]():

print chave

for valor in [Link]():

print valor

for chave, valor in [Link]():

print chave, '=', valor
Funções 23

Funções

• Uma função pode retornar nenhum, um ou mais objetos

• Tem namespace próprio (escopo local), que podem obscurecer definições de escopo global
• Aceita Doc Strings
• Aceita parâmetros opcionais (com defaults) e nomeados (independente da ordem)
• Pode ter suas propriedades modificadas (geralmente por decoradores)

Exemplos:

def fatorial(num):
if num <= 1:
return 1
else:
return(num * fatorial(num - 1))

def fib(n):
"""Fibonacci
fib(n) => fib(n - 1) + fib(n - 2) se n > 1
fib(n) => 1 se n <= 1
"""
if n > 1:
return fib(n - 1) + fib(n - 2)
else:
return 1

# Mostrar Fibonacci de 1 a 5
for i in [1, 2, 3, 4, 5]:
print i, '=>', fib(i)
Funções 24

def rgb_html(r=0, g=0, b=0):

"""Converte R, G, B em #RRGGBB"""
return '#%02x%02x%02x' % (r, g, b)

def html_rgb(color='#000000'):
"""Converte #RRGGBB em R, G, B"""
if [Link]('#'): color = color[1:]
r = int(color[:2], 16)
g = int(color[2:4], 16)
b = int(color[4:], 16)
return r, g, b # Uma sequência

print rgb_html(200, 200, 255)

print rgb_html(b=200, g=200, r=255) # O que houve?
print html_rgb('#c8c8ff')

Observações:

• Os argumentos com valor devem vir por último, depois dos argumentos sem padrão.
• O valor do padrão para um parâmetro é calculado quando a função é definida.
• Os argumentos passados sem identificador são recebidos pela função na forma de uma lista.
• Os argumentos passados com identificador são recebidos pela função na forma de um
dicionário.

# *args - argumentos sem nome (lista)

# **kargs - argumentos com nome (dicionário)

def func(*args, **kargs):

print args
print kargs
PyDOC 25

PyDOC

PyDOC é a ferramenta padrão de documentação do Python.

Para utilizar o PyDOC em um terminal:

pydoc ./[Link]

para ver a documentação de [Link] no diretório atual.

Para ver a documentação no browser, utilize o comando:

pydoc -p 8000

E acesse o endereço [Link]

Para rodar a versão gráfica do PyDOC execute:

pydoc -g

No Windows, acesse o ícone “Module Docs”.

O PyDOC utiliza as Doc Strings dos módulos para gerar a documentação.

Exercícios I 26

Exercícios I

1. Implementar duas funções:

a. uma que converta graus Celsius para Fahrenheit;

b. outra que converta graus Fahrenheit para Celsius.

Lembrando que:

9
F = ⋅C 32
5

2. Implementar uma função que retorne verdadeiro se o número for primo (falso caso contrário).
Testar de 1 a 100.

3. Implementar uma função que receba uma lista de listas de comprimentos quaisquer e retorne uma
lista de uma dimensão.

4. Implementar uma função que receba um dicionário e retorne a soma, a média e a variação dos
valores.
Módulos 27

Módulos

Módulos podem conter qualquer estrutura do Python e são executados quando importados. Eles
geralmente são compilados uma vez e armazenados em arquivo (pyc ou pyo), possuem namespace
próprio e aceitam Doc Strings. São objetos Singleton (só é carregada uma instância, que é acessada
de forma global).

Os módulos são localizados pelo interpretador através da lista de pastas PYTHONPATH ([Link]),
que normalmente inclui a pasta corrente em primeiro lugar. O módulo principal de um programa
tem a variável __name__ igual à “__main__”.

__main__ Módulo principal em execução.

sys Módulo sys (import sys)

path path é uma lista.
exit exit é uma função.

Função Função definida em __main__.

[Link]
[Link]() Chamando exit de sys.

Os módulos carregados através da instrução import. Desta forma, ao usar alguma estrutura do
módulo, é necessário identificar o módulo. Isto é chamado importação absoluta.

import os
print [Link]

Também possível importar módulos de forma relativa:

Módulos 28

from os import name

print name

Namespaces

Namespaces são dicionários que relacionam os nomes dos objetos (referências) e os objetos em si.

Normalmente, os nomes estão definidos em dois dicionários, acessíveis pelas funções locals() e
globals(). Os dicionários mudam dinamicamente em tempo de execução.

Módulo Namespace é um escopo de

definição de estruturas.
Var 1
Var 2 Estas são variáveis globais.
Var 3
Var 3 foi ofuscada, pois foi
(re)definida no escopo local.
Função

Var 3
Estas são variáveis locais.
Var 4

Módulos da biblioteca padrão

Alguns módulos importantes da biblioteca padrão:

• Sistema: os, [Link], glob, shutils, subprocess
• Threads: threading
• Persistência: pickle, cPickle, shelve
• XML: [Link], [Link], elementTree (a partir de 2.5)
• Configuração: ConfigParser, optparse
• Tempo: time, datetime
• Outros: sys, logging, traceback, profile, inspect, types, timeit, decimal
Módulos 29

Exemplo de módulo:

"""
modutils => utilitários para módulos
"""
import [Link]
import sys
import glob

def find(txt):
"""encontra módulos que tem o nome contendo texto"""
resp = []
for path in [Link]:
mods = [Link]('%s/*.py' % path)
for mod in mods:
if txt in [Link](mod):
[Link](mod)
return resp

Exemplo de uso do módulo:

from [Link] import getsize, getmtime

from time import localtime, asctime

import modutils

mods = [Link]('xml')

for mod in mods:

tm = asctime(localtime(getmtime(mod)))
kb = getsize(mod) / 1024
print '%s: (%d kbytes, %s)' % (mod, kb, tm)

Saída:

c:\python24\lib\[Link]: (34 kbytes, Fri Oct 28 20:16:20 2005)

c:\python24\lib\[Link]: (44 kbytes, Fri Oct 28 20:16:18 2005)
Pacotes 30

Pacotes

Pacotes são pastas que são identificadas pelo interpretador pela presença de um arquivo com o
nome “__init__.py”. Os pacotes servem como containers para os módulos.

componentes Esta pasta é um pacote.

__init__.py Identifica a pasta como pacote.
[Link] [Link]
termostato [Link]

[Link] [Link]
crt [Link]
lcd [Link]
oled [Link]
Arquivos e I/O 31

Arquivos e I/O

Os arquivos no Python são representados por objetos do tipo file. Os objetos file oferecem métodos
para leitura e escrita, em modo texto ou binário.

Exemplo de escrita:

import sys

# Criando um objeto do tipo file

temp = file('[Link]', 'w')
# Escrevendo no arquivo
for i in range(100):
[Link]('%03d\n' % i)
# Fechando
[Link]()

temp = file('[Link]')
for x in temp:
[Link](x)
[Link]()

Exemplo de leitura:

import sys
import [Link]

# raw_input retorna a string digitada

fn = raw_input('Nome do arquivo: ').strip()

if not [Link](fn):
print 'Tente outra vez...'
[Link]()

# Numerando as linhas
for i, s in enumerate(file(fn)):
print i + 1, s,

A função enumerate é um iterador que retorna dois elementos a cada iteração: um número
sequencial e um item da sequência.
Introspecção 32

Introspecção

Introspecção ou reflexão é capacidade do software de identificar suas próprias estruturas internas,

tais como tipos, escopo de variáveis, métodos e atributos.

Funções nativas do interpretador:

type(objeto)
# Retorna o tipo (classe) do objeto.

id(objeto)
# Retorna o identificador do objeto.

locals()
# Retorna o dicionário de variáveis locais.

globals()
# Retorna o dicionário de variáveis globais.

len(objeto)
# Retorna o tamanho do objeto.

dir(objeto)
# Retorna a lista de estruturas do objeto.

help(objeto)
# Retorna as Doc Strings do objeto.

isinstance(objeto, classe)
# Retorna verdadeiro se objeto deriva da classe.

issubclass(subclasse, classe)
# Retorna verdadeiro se subclasse herda classe.

Módulo inspect

O módulo inspect provê um conjunto de funções de introspecção prontas que permitem investigar
métodos, módulos e outras estruturas.

Exemplo:
Introspecção 33

# inspect: módulo de instrospecção "amigável"

import inspect
import [Link]

print [Link]([Link])
# <module 'ntpath' from 'C:\Python24\lib\[Link]'>

print [Link](str)
# True

# Lista todas as funções que existem em "[Link]"

for name, struct in [Link]([Link]):
if [Link](struct):
print name
Exceções 34

Exceções

print 1/0

Traceback (most recent call last):

File "<input>", line 1, in ?
ZeroDivisionError: integer division or modulo by zero

try:
print 1/0

except ZeroDivisionError:
print 'Erro ao tentar dividir por zero.'

Erro ao tentar dividir por zero.

import traceback

try:
fn = raw_input('Nome do arquivo: ').strip()

# Numerando as linhas
for i, s in enumerate(file(fn)):
print i + 1, s,

except:
trace = traceback.format_exc()
print 'Aconteceu um erro:\n', trace
file('[Link]', 'a').write(trace)
raise SystemExit
Decoradores 35

Decoradores

Decorador
Função
Função
transformada

def func(arg): def decorator(f):

return arg [Link] = True
return f
def decorator(f):
[Link] = True @decorator
return f def func(arg):
return arg
func = decorator(func)

Exemplo:

def dumpargs(f):
def func(*args):
print args
return f(*args)
return func

@dumpargs
def multiply(*nums):
m=1
for n in nums:
m=m*n
return m

print multiply(1, 2, 3)

Saída:
Decoradores 36

(1, 2, 3)
6
Exercícios II 37

Exercícios II

1. Implementar um programa que receba um nome de arquivo e gere estatísticas sobre o arquivo
(número de caracteres, número de linhas e número de palavras)

2. Implementar um módulo com duas funções:

a. matrix_sum(*matrices), que retorna a matriz soma de matrizes de duas dimensões;

b. camel_case(s), que converte nomes para CamelCase.

3. Implementar uma função que leia um arquivo e retorne uma lista de tuplas com os dados (o
separador de campo do arquivo é vírgula), eliminando as linhas vazias. Caso ocorra algum
problema, imprima uma mensagem de aviso e encerre o programa.

4. Implementar um módulo com duas funções:

a. split(fn, n), que quebra o arquivo fn em partes de n bytes e salva com nomes sequênciais (se fn =
[Link], então arq_001.txt, arq_002.txt, ... )
b. join(fn, fnlist) que junte os arquivos da lista fnlist em um arquivo só fn.
Classes 38

Classes

Uma classe é uma abstração de uma entidade modelada de forma computacional. Esta abstração
geralmente é composta por estruturas de dados (atributos) que descrevem o que é a entidade e
funções (métodos) que descrevem como a entidade se comporta.

As classes são a estrutura básica do paradigma de orientação a objetos. No Python, as classes

podem ter herança simples ou múltipla e são abertas (menos para os tipos builtins)

Novos objetos são criados a partir das classes através de atribuição comum.

Objeto
Atributos de
Classe classe
Atributos de
Métodos de
classe
Objeto = Classe() classe
Métodos de
classe Métodos
estáticos
Métodos
estáticos Métodos
dinâmicos

O construtor é executado neste Atributos de

momento. objeto

Métodos e atributos

Métodos e atributos novos podem ser da classe, portanto compartilhados por todas as instâncias
(objetos) daquela classe ou exclusivos da instância.

Métodos especiais são identificados por nomes no padrão “__metodo__” (dois sublinhados no
início e no final do nome) e definem como os objetos derivados da classe irão se comportar em
situações particulares, como na sobrecarga de operadores.

As classes new style são derivadas da classe object e podem utilizar recursos novos das classes do
Classes 39

Python, como properties e metaclasses. As properties são atributos calculados em tempo de

execução através de métodos, enquanto as metaclasses são uma maneira de personalizar como as
classes são criadas.

Sintaxe:

class Classe(supcl1, supcl2):

"""Isto é uma classe"""
clsvar = []

def __init__(self, args):

"""Construtor da classe"""
<codigo>

def __done__(self):
"""Destrutor da classe"""
<codigo>

def metodo(self, params):

"""Método dinâmico"""
<codigo>

@classmethod
"""Método de classe"""
def cls_metodo(cls, params):
<codigo>

@staticmethod
"""Método estático"""
def est_metodo(params):
<codigo>

obj = Classe()
[Link]()

Classe.cls_metodo()
Classe.est_metodo()

Métodos estáticos são aqueles que não tem ligação com atributos do objeto ou da classe. Funcionam
como as funções comuns.

Métodos de classe podem usar atributos e outros métodos de classe, porém não dos objetos.

Métodos dinâmicos podem usar atributos e outros métodos do objeto.

Classes 40

Herança simples

Herança é um mecanismo que a orientação a objeto provê visando o reaproveitamento de código.

Herança múltipla

Classe Antiga

Atributos Métodos

class Nova(Antiga):
Classe Nova
Atributos Métodos
antigos antigos

Atributos Métodos
redefinidos redefinidos

Atributos Métodos
novos novos
Classes 41

Ordem de resolução Object 5

3 Terrestre Aquático 4

1 Carro Barco 2

class Anfibio(Carro, Barco): Anfíbio 0

Exemplo:

class Cell(object):
"""Classe para células de planilha"""
def __init__(self, formula='""', format='%s'):
[Link] = formula
[Link] = format
def __repr__(self):
return [Link] % eval([Link])

print Cell('123**2')
print Cell('23*2+2')
print Cell('abs(-1.45 / 0.3)', '%2.3f')

Exemplo de herança:

class Pendrive(object):
def __init__(self, size, usb='2.0'):
[Link] = size
Classes 42

[Link] = usb

class MP3Player(Pendrive):
def __init__(self, size, usb='2.0', turner=False):
[Link] = turner
Pendrive.__init__(self, size, usb)

mp3 = MP3Player(1024)

print '%s\n%s\n%s' % ([Link], [Link], [Link])

Properties

# get_*, set_*...

class Projetil(object):
def __init__(self, alcance, tempo):
[Link] = alcance
[Link] = tempo

def get_velocidade(self):
return [Link] / [Link]

moab = Projetil(alcance=10000, tempo=60)

print moab.get_velocidade()

# Property de leitura

class Projetil(object):
def __init__(self, alcance, tempo):
[Link] = alcance
[Link] = tempo

@property
def velocidade(self):
return [Link] / [Link]

moab = Projetil(alcance=10000, tempo=60)

Classes 43

print [Link]

# Property de leitura & escrita

class Projetil(object):
def __init__(self, alcance, tempo):
[Link] = alcance
[Link] = tempo
def getv(self):
return [Link] / [Link]
def setv(self, v):
[Link] = [Link] / v
velocidade = property(getv, setv)

moab = Projetil(alcance=10000, tempo=60)

[Link] = 350
print [Link]

Sobrecarga de operadores

class String(str):

def __sub__(self, s):

return [Link](s, '')

s1 = String('The Lamb Lies Down On Broadway')

s2 = 'Down '

print '"%s" - "%s" = "%s"' % (s1, s2, s1 - s2)

Classes abertas
Classes 44

class User(object):
def __init__(self, name):
[Link] = name

def set_password(self, password):

[Link] = password

User.set_password = set_password

user = User('guest')
user.set_password('guest')
print dir(user)
print [Link]
Exercícios III 45

Exercícios III

1. Crie uma classe que modele um quadrado, com um atributo lado e os métodos: mudar valor do
lado, retornar valor do lado e calcular área.

2. Crie uma classe derivada de lista com um método retorne os elementos da lista sem repetição.

3. Implemente uma classe chamada Carro com as seguintes propriedades:

• Um veículo tem um certo consumo de combustível (medidos em km / litro) e uma certa

quantidade de combustível no tanque;
• O consumo é especificado no construtor e o nível de combustível inicial é 0;
• Forneça um método mover(km) que receba a distância em quilômetros e reduza o nível de
combustível no tanque de gasolina;
• Forneça um método gasolina(), que retorna o nível atual de combustível;
• Forneça um método abastecer(litros), para abastecer o tanque.

4. Implementar uma classe Vetor:

• Com coordenadas x, y e z;
• Que suporte soma, subtração, produto escalar, produto vetorial;
• Que calcule o módulo (valor absoluto) do vetor.
Persistência 46

Persistência

Persistência pode ser definida como a manutenção automática do estado de um objeto entre
execuções de um programa. A persistência libera o desenvolvedor de escrever código
explicitamente para armazenar objetos em arquivos e ajuda a manter o foco no modelo de dados da
aplicação.

Serialização

A forma mais simples e direta de persistência é chamada de serialização e consiste em gravar em

disco um dump do objeto. No Python, a serialização é implementada de várias formas, mas a mais
comum é através do módulo chamado pickle.

Exemplo:

import pickle

try:
setup = [Link](file('[Link]'))
print setup

except:
setup = {'timeout': 10,
'server': '[Link]',
'port': 80
}
[Link](setup, file('[Link]', 'w'))

Recupera setup usando o objeto arquivo [Link].

O setup default.

Salva setup usando o objeto arquivo [Link].

Banco de dados 47

Banco de dados

DBI

DBI (Database Interface) é uma especificação que descreve como deve ser o comportamento de um
módulo de acesso de banco de dados.

Interpretador As consultas são sentenças

SQL e as respostas são listas de
Programa tuplas ou dicionários.

O módulo DBI (Database

Interface) é um driver especifico
para o SGBD.
DBI

SGBD

Exemplo:

import MySQLdb

con = [Link](db='test', user='root', passwd='')

cur = [Link]()

[Link]('show databases')

recordset = [Link]()
Banco de dados 48

for record in recordset:

print record

[Link]()
ZODB 49

ZODB

ZODB: Zope Object Database

Aplicação
persistente

Pesistence Database Transaction

ZODB

ZEO Storage

Projetado para ter o menor impacto possível no código da aplicação

Suporta transações e versionamento de objetos
Pode ser conectado a outros backends através do ZEO (Zope Enterprise Objects), permitindo
aplicações distribuídas em máquinas diferentes
Limitações:
Os objetos precisam ser “serializáveis” para serem armazenados.
Objetos mutáveis requerem cuidados

Exemplo:

from ZODB import FileStorage, DB

import transaction

# Definindo o armazenamento do banco

storage = [Link]('[Link]')
db = DB(storage)

# Conectando
ZODB 50

conn = [Link]()

# Referência para a raíz da árvore

root = [Link]()

# Um registro persistente
root['singer'] = 'Kate Bush'

# Efetuando a alteração
[Link]()
print root['singer'] # Kate Bush

# Mudando um atributo
root['singer'] = 'Tori Amos'
print root['singer'] # Tori Amos

# Abortando...
[Link]()
print root['singer'] # Kate Bush
Web 51

Web

A Web dinâmica é uma forma de

execução remota.

Servidor
Requisição GET
ou POST HTTP

Browser Resposta

url?param=arg => url(param=arg)

Exemplo (CherryPy):

import cherrypy

class Root(object):

@[Link]
def index(self):
return 'Hello World!'

[Link](Root())

Exemplo (CherryPy + CherryTemplate):

from cherrytemplate import renderTemplate

Web 52

progs = ['Yes', 'Genesis', 'King Crimson']

template = '<html>\n<body>\n'\
'<py-for="prog in progs">'\
' <py-eval="prog"><br>\n'\
'</py-for>'\
'</body>\n</html>\n'

print renderTemplate(template)

Saída:

<html>
<body>
Yes<br>
Genesis<br>
King Crimson<br>
</body>
</html>
MVC 53

MVC

MVC: Model View Controller

Obtêm os dados e
Controller Recebe e traduz as
apresenta ao
entradas do usuário.
usuário.

View Model

Encapsula os dados
da aplicação e a
lógica de domínio.

Exemplo:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""Exemplo MVC"""

# CherryPy
import cherrypy
# CherryTemplate
from cherrytemplate import renderTemplate
# ZODB
from ZODB import FileStorage, DB
from persistent import Persistent
import transaction

# Classe persistente
MVC 54

class Animal(Persistent):
"""Classe de animais"""
pass

# Banco de dados Zoo

storage = [Link]('[Link]')
db = DB(storage)
conn = [Link]()
zoo = [Link]()

class Root(object):
"""Raíz do site"""

@[Link]
def index(self):
"""Lista de animais do Zoo"""

return renderTemplate(file='[Link]')

@[Link]
def add(self):
"""Cadastra novos animais"""

return renderTemplate(file='[Link]')

@[Link]
def save(self, animal):
"""Salva o animal"""

if animal:

new = Animal()
[Link] = animal
[Link] = animal
zoo[[Link]] = new
[Link]()
return renderTemplate(file='[Link]')

# Inicia o servidor
[Link](Root())

Arquivo [Link]:
MVC 55

<html>
<body>
<py-if="zoo">
<py-for="animal in sorted([Link]())">
<py-eval="animal"><br />
</py-for>
</py-if>
<form action="/add" method="post">
<input type="submit" value=" adicionar " />
</body>
</html>

Arquivo [Link]:

<html>
<body>
<form action="/save" method="post">
<input type="text" size="30" name="animal" />
<input type="submit" value=" salvar " />
</body>
</html>
Exercícios IV 56

Exercícios IV

1. Implementar uma classe Animal com os atributos: nome, especie, gênero, peso, altura e idade. O
objeto derivado desta classe deverá salvar seu estado em arquivo com um método chamado “salvar”
e recarregar o estado em um método chamado “desfazer”.

2. Implementar uma função que formate uma lista de tuplas como tabela HTML

Solução:

3. Implementar uma aplicação Web com uma saudação dependente do horário (exemplos: “Bom
dia, são 09:00.”, “Boa tarde, são 13:00.” e “Boa noite, são 23:00.”)

4. Implementar uma aplicação Web com um formulário que receba expressões Python e retorne a
expressão com seu resultado.
Geradores 57

Geradores

Geradores são funções que, ao invés de retornar sequências, retornam um valor de cada vez
Geralmente são evocados através de um iterador (for ... in ...)
Lazy evaluation: só processam quando for necessário, sendo assim, economizam recursos
Permitem trabalhar com sequências ilimitadas de itens.

Exemplo:

import os

def find(path='.'):
for item in [Link](path):
fn = [Link]([Link](path, item))
if [Link](fn):
for f in find(fn):
yield f
else:
yield fn

for fn in find('c:/temp'):
print fn

Yield substitue o return.

A nova cada iteração, yield retorna o próximo valor.

Programação funcional 58

Programação funcional

Paradigma que trata a computação como uma avaliação de funções matemáticas

Tais funções podem ser aplicadas em sequências de dados (geralmente listas)
São exemplos de linguagens funcionais: LISP, Scheme e Haskell (esta última influenciou o projeto
do Python de forma marcante)
As operações básicas do paradigma funcional são implementadas pelas funções map, filter, reduce e
zip

Mapeamento

O mapeamento consiste em aplicar uma função a todos os itens de uma sequência, gerando outra
lista contendo os resultados e com o mesmo tamanho da lista inicial.

Sequência Função Sequência

x**2
1 1
2 4
3 9
4 16
5 25
6 36
7 49

No Python, o mapeamento é implementado pela função map.

Filtragem
Programação funcional 59

Sequência Função Sequência

x%2
1 1
2 Falso
3 3
4 Falso
5 5
6 Falso
7 7

Redução
Programação funcional 60

Sequência Função Resultado

x+y
1 1
2 3
3 6
4 10
5 15
6 21
7 28

Transposição
Programação funcional 61

Sequências Função Sequências

1 1
2 4
3
2
5
4
5 3
6 6

Exemplos:

nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

# log na base 10
from math import log10

print map(log10, nums)

# Dividindo por 3
print map(lambda x: x / 3, nums)

# Só os ímpares
print filter(lambda x: x % 2, nums)

# Soma
print reduce(lambda x, y: x + y, nums)

# Soma mais simples

print sum(nums)
Programação funcional 62

# Multiplicação
print reduce(lambda x, y: x * y, nums)

# Uma lista com ('a', 1), ('b', 2), ...

from string import ascii_lowercase
print zip(ascii_lowercase, range(1, 100))

matriz = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# Transposta de matriz
print zip(*matriz)

List comprehension

Generator expression
XML 63

XML

XML é um padrão representação de dados aonde o metadado é transportado junto com os dados
através de tags.

Árvore de elementos

Canino Raiz

Lobo Raposa Elementos

Chacal Cachorro
Nome: Bandit
Raça: Labrador Atributos
Cor: castanho claro
XML 64

Elemento <Lobo>...</Lobo>

Lobo

Cachorro Tag
Nome: Bandit
Raça: Labrador Atributos
Cor: castanho claro

<Cachorro cor="Castanho Claro"

nome="Bandit" raca="Labrador" />

Exemplo:

from [Link] import Element, ElementTree

root = Element('Canino')
lobo = Element('Lobo')
raposa = Element('Raposa')
chacal = Element('Chacal')
cachorro = Element('Cachorro', nome='Bandit',
raca='Labrador', cor='Castanho Claro')

[Link](lobo)
[Link](raposa)
[Link](chacal)
[Link](cachorro)

ElementTree(root).write('[Link]')
XML 65

<Canino>
<Lobo>
<Chacal />
<Cachorro cor="Castanho Claro" nome="Bandit" raca="Labrador" />
</Lobo>
<Raposa />
</Canino>

from [Link] import ElementTree

tree = ElementTree(file='[Link]')
root = [Link]()

# Lista os nós abaixo do root

print [Link]()
# Encontra o lobo
lobo = [Link]('Lobo')
# Encontra o cachorro
cachorro = [Link]('Cachorro')
print [Link], [Link]
# Remove a raposa
[Link]([Link]('Raposa'))
print [Link]()
Exercícios V 66

Exercícios V

1. Implementar um gerador de números primos.

2. Implementar o gerador de números primos como uma expressão (dica: use o módulo itertools)

3. Implementar um gerador que produza tuplas com as cores do padrão RGB (R, G e B variam de 0
a 255) usando xrange() e uma função que produza uma lista com as tuplas RGB usando range().
Compare a performance.

4. Implementar um gerador que leia um arquivo e retorne uma lista de tuplas com os dados (o
separador de campo do arquivo é vírgula), eliminando as linhas vazias. Caso ocorra algum
problema, imprima uma mensagem de aviso e encerre o programa.