python_para_desenvolvedores
Pré-visualização34 páginas
a partir de um programa feito
em Python, como o Py2exe66 e cx_Freeze67.
O Py2exe só funciona na plataforma Windows, porém possui muitos recursos, podendo
gerar executáveis com interface de texto, gráficos, serviços (programas que rodam sem
intervenção do usuário, de forma semelhante aos daemons nos sistemas UNIX) e servidores
COM (arquitetura de componentes da Microsoft).
O cx_Freeze é portável, podendo rodar em ambientes UNIX, porém é bem menos versátil
que o Py2exe.
Para usar o Py2exe, é preciso criar um script, que normalmente se chama \u201csetup.py\u201d, que
66 Documentação, fontes e binários de instalação podem ser encontrados em: http://www.py2exe.org/.
67 Documentação, fontes e binários de instalação para várias plataformas podem ser encontrados em:
http://starship.python.net/crew/atuining/cx_Freeze/.
Fontes
(*.py)
Bytecode
(*.pyc / *.pyo)
Binários
Interpretador e
dependências
Compilação Empacotamento
Instalador
Binários
202 Performance
diz ao Py2exe o que é necessário para gerar o executável.
Exemplo de \u201csetup.py\u201d:
# -*- coding: latin1 -*-
"""
Exemplo de uso do py2exe
"""
from distutils.core import setup
import py2exe
setup(name = 'SIM - Sistema Interativo de Música',
service = ['simservice'],
console = ['sim.py', 'simimport.py'],
windows = ['simgtk.py'],
options = {'py2exe': {
'optimize': 2,
'includes': ['atk', 'gobject', 'gtk','gtk.glade',
'pango', 'cairo', 'pangocairo']
}},
data_files=[('',['janela.glade', 'sim.ico'])],
description = 'Primeira Versão...',
version = '1.0')
No exemplo, temos um sistema que é composto por dois utilitários de linha comando, um
aplicativo com interface gráfica e um serviço. O aplicativo com GUI depende do GTK+
para funcionar e foi desenvolvido usando Glade.
Entre os parâmetros do Py2exe, os mais usuais são:
\u25aa name: nome da aplicação.
\u25aa service: lista de serviços.
\u25aa console: lista de programas com interface de texto.
\u25aa windows: lista de programas com interface gráfica.
\u25aa options['py2exe']: dicionário com opções que alteram o comportamento do Py2exe:
\u25aa optimize: 0 (otimização desativada, bytecode padrão), 1 (otimização ativada, equivale
ao parâmetro \u201c-O\u201d do interpretador) ou 2 (otimização com remoção de Doc Strings
ativada, equivale ao parâmetro \u201c-OO\u201d do interpretador)
\u25aa includes: lista de módulos que serão incluídos como dependências. Geralmente, o
Py2exe detecta as dependências sem necessidade de usar esta opção.
\u25aa data_files: outros arquivos que fazem parte da aplicação, tais como imagens, ícones e
arquivos de configuração.
\u25aa description: comentário.
\u25aa version: versão da aplicação, como string.
Para gerar o executável, o comando é:
Performance 203
python setup.py py2exe
O Py2exe criará duas pastas:
\u25aa build: arquivos temporários.
\u25aa dist: arquivos para distribuição.
Entre os arquivos para distribuição, \u201cw9xpopen.exe\u201d é necessário apenas para as versões
antigas do Windows (95 e 98) e pode ser removido sem problemas em versões mais
recentes.
Pela linha de comando também é possível passar algumas opções interessantes, como o
parâmetro \u201c-b1\u201d, para gerar menos arquivos para a distribuição.
O cx_Freeze é um utilitário de linha de comando.
FreezePython -OO -c sim.py
A opção \u201c-c\u201d faz com que o bytecode seja comprimido no formato zip.
FreezePython -OO --include-modules=atk,cairo,pango,pangocairo simgtk.py
A opção \u201c--include-modules\u201d, permite passar uma lista de módulos que serão incluídos na
distribuição.
Tanto o Py2exe quanto o cx_Freeze não são compiladores. O que eles fazem é empacotar
os bytecodes da aplicação, suas dependências e o interpretador em si em (pelo menos) um
arquivo executável (e arquivos auxiliares) que não dependem do ambiente aonde foram
gerados. Com isso, a distribuição do aplicativo se torna bem mais simples. Entretanto, não
há ganho de performance em gerar executáveis, tirando na carga da aplicação para a
memória em alguns casos.
Eles também não geram programas de instalação. Para isso, é necessário o uso de um
software específico. Os instaladores são gerados por aplicativos que se encarregam de
automatizar tarefas comuns do processo de instalação. São exemplos de softwares dessa
categoria: Inno Setup68 e NSIS69.
68 Documentação e binários de instalação disponíveis em: http://www.jrsoftware.org/isinfo.php.
69 Endereço do projeto: http://nsis.sourceforge.net/Main_Page.
204 Exercícios VI
Exercícios VI
1. Implementar um módulo com uma função tribonacci(n) que retorne uma lista de n
números de Tribonacci, aonde n é o parâmetro da função. Faça testes da função caso o
módulo seja executado como principal.
2. Implementar:
\u25aa um servidor que publique um objeto distribuído e este evoque a função tribonacci.
\u25aa um cliente que use o objeto distribuído para calcular a seqüência de Tribonacci.
Apêndices 205
Apêndices
\u25aa Integração com Blender.
\u25aa Integração com BrOffice.org.
\u25aa Integração com Linguagem C.
\u25aa Integração com .NET.
\u25aa Respostas dos exercícios.
206 Apêndices
Integração com Blender
Python pode ser usado como linguagem script em várias aplicações para automatizar
tarefas e/ou adicionar novas funcionalidades. Entre elas, está o Blender70, que é um
software de modelagem 3D de código aberto, que pode gerar animações e também pode
ser usado como Game Engine (infraestrutura especializada para criação de jogos para
computador).
No Blender, uma cena é composta por objetos, que precisam ser fixados em posições e
conectados a cena. Se o objeto não estiver conectado a cena, ele é eliminado ao fim do
processamento. Normalmente, uma cena contém pelo menos uma fonte de luz, uma
câmera e meshes (malhas que representam os objetos 3D), que podem usar vários materiais
e estes podem ter várias texturas. Texturas são imagens bidimensionais (procedurais ou
raster) que podem ser usadas nos materiais aplicados as superfícies dos objetos, alterando
várias propriedades, tais como reflexão, translucência, coloração e enrugamento (bump) da
superfície.
Uma malha é um conjunto de pontos (vértices), interligados por linhas (arestas) que
formam superfícies (faces) de um objeto.
70 Documentação, fontes e binários podem ser encontrados em: http://www.blender.org/.
Apêndices 207
Com Python é possível acessar todas essas estruturas do Blender através de módulos:
\u25aa Blender: permite abrir arquivos, salvar e outras funções correlatas.
\u25aa Object: operações com objetos 3D.
\u25aa Materials: manipulação de materiais.
\u25aa Textures: manipulação de texturas.
\u25aa World: manipulação do ambiente da cena.
Fluxo para a criação de um cenário 3D no Blender:
Exemplo de código para a criação de uma cena:
import math
import Blender
# Pega a cena atual
cena = Blender.Scene.GetCurrent()
# Elementos da cena "default"
camera = Blender.Object.Get()[0]
cubo = Blender.Object.Get()[1]
lamp = Blender.Object.Get()[2]
Cria
estruturas
Materiais
Cria
Materiais
Cria
Texturas
Aplica
Texturas
Texturas
Estruturas
Aplica
Materiais
Renderiza
Aplica
Estruturas
Cria cena
Imagem
final
Cena
208 Apêndices
# Move a camera
camera.setLocation(8., -8., 4.)
camera.setEuler(math.radians(70), 0.,
math.radians(45))
# Muda a lente
camera.data.lens = 25
# Remove da cena o objeto "default"
cena.objects.unlink(cubo)
# Altera a intensidade da luz
lamp.data.energy = 0.8
# E a cor
lamp.data.col = (1., 1., 0.9)
# Cria outra fonte de luz
lamp1 = Blender.Lamp.New('Lamp')
lamp1.energy = 0.7
lamp1.col = (0.9, 1., 1.)
_lamp1 = Blender.Object.New('Lamp')
# Muda o lugar da fonte (default = 0.0, 0.0, 0.0)
_lamp1.setLocation(6., -6., 6.)
# "Prende" a fonte de luz na cena
_lamp1.link(lamp1)
cena.objects.link(_lamp1)