python_para_desenvolvedores

if x % 2 )
# Mostra os resultados
for num in gen:
 print num
O Generator Expression usa menos recursos do que o List Comprehension equivalente.
Exercícios III 79
Exercícios III
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.
80 Parte IV
Parte IV
▪ Decoradores.
▪ Classes.
▪ Testes automatizados.
▪ Exercícios IV.
Decoradores 81
Decoradores
Decoradores (decorators) são funções que são aplicadas em outras funções e retornam 
funções modificadas. Decoradores tanto podem ser usados para alterar propriedades das 
funções (que são objetos) quanto para “envolver” as funções, acrescentando uma camada 
em torno delas com novas funcionalidades.
A partir do Python 2.4, o caractere “@” pode ser usado para automatizar o processo de 
aplicar o decorador:
def decorator(f):
 f.decorated = True
 return f
@decorator
def func(arg):
 return arg
Com isso, foi criado um atributo novo na função, que pode ser usado depois, quando a 
função for executada.
Função
Original
Função
Modificada
def func(arg):
 return arg
def decorator(f):
 f.decorated = True
 return f
func = decorator(func)
Decorador
O decorador foi aplicado.
82 Decoradores
Exemplo:
# -*- coding: latin1 -*-
# Função decoradora
def dumpargs(f):
 # Função que envolverá a outra
 def func(*args):
 # Mostra os argumentos passados para a função
 print args
 # Retorna o resultado da função original
 return f(*args)
 # Retorna a função modificada
 return func
@dumpargs
def multiply(*nums):
 m = 1
 for n in nums:
 m = m * n
 return m
print multiply(1, 2, 3)
Saída:
(1, 2, 3)
6
A saída apresenta os parâmetros que a função decorada recebeu.
Classes 83
Classes
Um objeto é uma abstração computacional que representa uma entidade, com qualidades 
(atributos) e ações (métodos) que a entidade pode realizar. A classe é a estrutura básica do 
paradigma de orientação a objetos. A classe representa o tipo do objeto, que define as 
qualidades do objeto e o que ele pode fazer.
Por exemplo, a classe Canino descreve as características e ações dos caninos em geral, 
enquanto o objeto Bandit representa um canino em especial.
Os atributos são estruturas de dados sobre o objeto e os métodos são funções que 
descrevem como o objeto se comporta.
No Python, novos objetos são criados a partir das classes através de atribuição.
Quando um novo objeto é criado, o construtor da classe é executado. Em Python, o 
construtor é um método especial chamado __new__(). Após a chamada ao construtor, o 
método __init__() é chamado para inicializar a nova instância.
Um objeto continua existindo na memória enquanto existir pelo menos uma referência a 
Canino
Peso, Altura, 
idade, Raça
Correr, Atacar, 
Comer, Latir
Suas 
características.
O que ele pode 
fazer.
Bandit
Peso, Altura, 
idade, Raça
Correr, Atacar, 
Comer, Latir
A classe 
representa 
qualquer canino.
O objeto 
representa um 
canino.
Bandit = Canino()
84 Classes
ele. O interpretador Python possui um recurso chamado coletor de lixo (Garbage Collector) 
que limpa da memória objetos sem referências17. Quando o objeto é apagado, o método 
especial __done__() é evocado. Funções ligadas ao coletor de lixo podem ser encontradas 
no módulo gc.
Em Python:
▪ Quase tudo é objeto, mesmo os tipos básicos, como números inteiros.
▪ Tipos e classes são unificados.
▪ Os operadores são na verdade chamadas para métodos especiais.
▪ As classes são abertas (menos para os tipos builtins).
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 se 
comportarão em situações particulares, como em sobrecarga de operadores.
As classes new style são derivadas da classe object e podem utilizar recursos novos das 
classes do 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 classes que geram 
classes, com isso permitem personalizar o comportamento das classes.
17 Para apagar uma referência a um objeto, use o comando del. Se todas as referências forem apagadas, o 
Garbage Collector apagará o objeto.
Classe
Métodos de 
classe
Atributos de 
classe
Métodos 
estáticos
Objeto
Métodos de 
classe
Atributos de 
classe
Métodos 
estáticos
Métodos 
dinâmicos
Atributos de 
objeto
Objeto = Classe()
O construtor é executado neste 
momento.
Classes 85
Sintaxe:
# -*- coding: latin1 -*-
class Classe(supcl1, supcl2):
 """
 Isto é uma classe
 """
 clsvar = []
 def __init__(self, args):
 """
 Inicializador da classe
 """
 <bloco de código>
 def __done__(self):
 """
 Destrutor da classe
 """
 <bloco de código>
 def metodo(self, params):
 """
 Método de objeto
 """
 <bloco de código>
 @classmethod
 def cls_metodo(cls, params):
 """
 Método de classe
 """
 <bloco de código>
 @staticmethod
 def est_metodo(params):
 """
 Método estático
 """
 <bloco de código>
obj = Classe()
obj.metodo()
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. 
86 Classes
Funcionam como as funções comuns.
Métodos de classe podem usar apenas atributos e outros métodos de classe. O argumento 
cls representa a classe em si, precisa ser passado explicitamente como primeiro parâmetro 
do método.
Métodos de objeto podem usar atributos e outros métodos do objeto. A variável self, que 
representa o objeto e também precisa ser passado de forma explícita. O nome self é uma 
convenção, assim como cls, podendo ser trocado por outro nome qualquer, porém é 
considerada como boa prática manter o nome.
Exemplo de classe:
# -*- coding: latin1 -*-
class Cell(object):
 """
 Classe para células de planilha
 """
 def __init__(self, formula='""', format='%s'):
 """
 Inicializa a célula
 """
 self.formula = formula
 self.format = format
 def __repr__(self):
 """
 Retorna a representação em string da célula
 """
 return self.format % eval(self.formula)
print Cell('123**2')
print Cell('23*2+2')
print Cell('abs(-1.45 / 0.3)', '%2.3f')
Saída:
15129
48
4.833
Classes 87
O método __repr__() é usado internamente pelo comando print para obter uma 
representação do objeto em forma de texto.
88 Classes
Classes abertas
No Python, as classes que não são builtins podem ser alteradas em tempo de execução, 
devido a natureza dinâmica da linguagem. É possível acrescentar métodos e atributos 
novos, por exemplo. A mesma lógica se aplica aos objetos.
Exemplo de como acrescentar um novo método:
# -*- coding: latin1 -*-
class User(object):
 """Uma classe bem simples.
 """
 def __init__(self, name):
 """Inicializa a classe, atribuindo um nome