A editora Novatec lançou na semana passada o livro Python para Desenvolvedores do autor Luiz Eduardo Borges. O conteúdo do livro é um curso rápido e prático sobre o Python, dessa vez abordando a versão 3.3.

Eu sou colega de trabalho do Luiz Eduardo e vi todo o empenho que ele fez para poder lançar esse livro com todos os exemplos de códigos atualizados para Python 3 e também para adicionar conteúdo novo e assim tornar o livro ainda mais interessante para desenvolvedores.

A Novatec também fez um excelente trabalho de editoração do livro, a tipografia está muito bonita e a divisão dos capítulos ficou excelente. Segue abaixo parte da descrição do lançamento que foi enviada pela própria editora:

O livro Python para Desenvolvedores, lançado pela Novatec Editora, descreve os principais recursos da linguagem Python, focado em sua versão 3.3, com um texto direto e conciso, repleto de exemplos para descrever desde os conceitos mais básicos até recursos avançados, como a integração com outras linguagens.

O livro aborda conceitos básicos de linguagem, biblioteca-padrão, geradores, programação funcional, classes, testes automatizados, armazenamento de dados, aplicações web, processamento numérico, interface gráfica, computação gráfica, processamento distribuído, plataformas portáteis, empacotamento e distribuição e integração com aplicativos e outras linguagens.

No ano passado, eu mesmo contribui com esse livro quando ele existia apenas na forma de e-book gratuito em sua versão anterior que era focada no Python 2. A minha contribuição foi portar o e-book para a web usando o formato do IPython Notebook, se quiser conhecer um pouco dessa estória, visite esse post.

Parabéns Luiz Eduardo, que o livro possa repetir e aumentar o sucesso das edições anteriores e quem sabe não teremos outras edições ou até outros livros no futuro.

Referências

Site da Novatec

Python para Desenvolvedores

Depois de lançar uma versão na web do livro Python para Desenvolvedores e ter uma boa receptividade, o próximo desafio era traduzir o livro para o inglês e perceber como essa tradução seria aceita pela comunidade de desenvolvedores.

E assim está sendo feito, agora temos uma versão em inglês chamada Python for Developers. Essa primeira versão já está no ar, porém só tem a primeira parte do livro traduzida. Por isso, qualquer ajuda na tradução ou na divulgação será muito bem-vinda.

Para quem estiver curioso em como o livro foi montado dê uma olhada no post anterior sobre o Python para Desenvolvedores em português que explica quais as tecnologias usadas no livro.

Referências

Python for Developers

Python para Desenvolvedores

Há algumas semanas resolvi embarcar num novo projeto que me foi sugerido por um colega de trabalho, usar as facilidades do Github Pages e do IPython Notebook para disponibilizar online o livro do Luiz Eduardo Borges: Python para Desenvolvedores, 2ª edição.

O desafio foi aceito e a primeira parte do livro já está disponibilizada gratuitamente, interativamente e livremente para quem quiser acessar, usar ou modificar.

A montagem do livro foi feita num esquema bem simples. O site do Github Pages foi usado para apresentar o livro e as seções adicionais como prefácio, agradecimentos, como usar, entre outras e ainda para servir como referência a todos os capítulos do livro, onde cada capítulo é um IPython notebook separado e renderizado através da ferramenta nbviewer. Esse esquema é o mesmo usado pelo livro Probablistic Programming & Bayesian Methods for Hackers.

Posso dizer que converter esse livro para a web tem sido até bastante divertido, pois tenho aumentado o meu conhecimento sobre Python e alguns de seus módulos e usos e ainda tenho conhecido melhor o IPython Notebook que é uma excelente ferramenta para renderizar código Python, fazer tutoriais científicos e tudo o mais.

A idéia para o futuro é poder disponibilizar uma tradução desse livro para o inglês, e também, quem sabe, convencer o autor a criar uma nova edição para Python 3.

Atualização: 17 de outubro de 2013

Essa versão online do livro agora está completa, com todo o conteúdo do livro original online e com os exemplos rodando em IPython (onde é possível).

Referências

Python para Desenvolvedores: versão web

Python para Desenvolvedores: site do autor

Cam Davidson-Pilon: Probablistic Programming & Bayesian Methods for Hackers

Aproveitei as minhas últimas férias para concluir um projeto pessoal que já estava querendo fazer há bastante tempo, portar uma biblioteca para Python 3. Agora que já tenho um pouco mais de "intimidade" com essa nova versão do Python, havia chegado a hora de encarar essa tarefa.

A escolha da biblioteca

A biblioteca escolhida para realizar o porte foi a Unipath. Unipath é definida pelo seu próprio criador como uma abordagem orientada a objetos para operações de arquivos e diretórios. Ela substitui operações de diversos módulos da biblioteca padrão do Python, como por exemplo os.path e shutil.

Eu escolhi essa biblioteca por ser algo que eu adotei agora em todos os meus novos projetos com Django além de ser uma base de código pequena e com uma quantidade de testes em que posso confiar.

A estratégia de migração

Em [um dos tutoriais mais conhecidos para portar código da versão 2 para 3], o primeiro tópico abordado é a escolha da estratégia. A escolha da estratégia envolve basicamente 2 passos: definir se irá ou não usar a ferramenta de conversão automática 2to3 e depois definir se a sua nova base de código portada rodará somente em Python 3 ou se continuará também compatível com a versão 2. Ao decidir isso, tenha em mente que desde a versão 2.6 que Python traz algumas facilidades para tornar menos dolorido possível essa migração.

A estratégia que eu escolhi foi ter código compatível com as versões 2 e 3 de Python, sendo que na versão 2, o suporte é a partir da 2.6 e na versão 3, o suporte garantido é a partir da 3.2. Escolhi também adotar o processo de migração manual, pois a base de código é pequena e vi que seria uma melhor maneira de auxiliar meu aprendizado.

O processo de migração

Para portar o código, o processo foi bem simples, primeiro é só garantir que todos os testes estejam funcionando em Python 2, rodar os testes novamente em Python 3 e corrigir os erros que aparecerem. No estágio atual da linguagem, está bem mais fácil fazer código que seja compatível com as duas versões.

Todo o processo de migração foi feito usando os mais que excelentes Git e GitHub e foi muito legal, mesmo no pouco tempo que levei para portar a biblioteca ver o processo de desenvolvimento colaborativo funcionar, pois apenas poucos dias depois de ter criado o meu fork no GitHub, outro usuário, o Norberto Bensa, se interessou também e começou a me ajudar na migração para Python 3.

Outro coisa que vale a pena mencionar, é que eu usei a biblioteca py.test para rodar os testes unitários e a biblioteca tox para automatizar a execução dos testes nas diversas versões de Python suportadas.

O último passo da migração, já com o código funcionando nas duas versões, foi abrir um pull request para que esse porte seja incorporado no repositório oficial da biblioteca, o que ainda não aconteceu, mas espero que aconteça.

Enquanto isso, segue o repositório do meu fork para quem deseja instalar o Unipath no Python 3.

Referências

Brett Cannon: Porting Python 2 Code to Python 3

Porting to Python 3 - The Book

Como estruturar um projeto Django? Qual o conjunto mínimo de bibliotecas que eu preciso para iniciar um projeto? Quais as melhores práticas que eu posso implementar desde o começo do projeto? Como deixar o meu projeto preparado para facilitar o processo de deploy para vários ambientes? Esse post visa ajudar especialmente os iniciantes nesse framework a responder essas e outras perguntas importantes para quem deseja se aprofundar nessa tecnologia.

Assim como no anterior, esse artigo considera que você já conhece bem Python, que sabe ao menos como instalar o Django, e que, para o seu próprio bem, use virtualenv para isolar os ambientes de cada projeto e pip para instalação e desinstalação de pacotes.

Bibliotecas essenciais para um projeto Django

Abaixo estão as bibliotecas que instalo toda vez que vou iniciar um projeto:

Fabric - Indispensável para fazer deploy de projetos, principalmente quando você trabalha com mais de um servidor para o mesmo projeto nas diversas fases do processo de desenvolvimento.
South - Se não quiser passar pelo inferno das migrações de modelos de dados, e dos próprios dados em si, é mais do que essencial que instale essa ferramenta.
Unipath - Biblioteca orientada a objetos para realizar operações de arquivos e diretórios. Um ótimo substituto para o módulo os.path da biblioteca padrão do Python.
django-jenkins e bibliotecas auxiliares - Ver o post Como configurar um projeto Django no Jenkins.
django-braces - App Django que inclui uma coleção de mixins que complementam as Class Based Views.
django-crispy-forms - App Django para facilitar a renderização dos componentes dos forms.
django-debug-toolbar - App indispensável no desenvolvimento de projetos Django. Traz todas as informações de debug a respeito dos templates e da execução do código que você precisa.
django-discover-runner - Uma alternativa ao test runner do Django baseado na unittest2.
django-floppyforms - HTML5 widgets e outras facilidades para ser usado em conjunto com o django-crispy-forms.
django-model-utils - Utilitários para os models do Django.
flup - Essa biblioteca serve para rodar o projeto em modo FastCGI no servidor web de sua escolha. O servidor web que eu uso é o nginx pela rapidez e praticidade.

Estrutura do projeto

Finalmente, depois de instalar os pacotes mencionados acima, chegou a hora de organizar a estrutura do seu projeto. A estrutura que eu uso, é essa aqui, no seu projeto substitua a palavra project pelo nome do seu projeto.

:::bash
<project_root>
├── <django_project_root>
│   ├── data
│   ├── log
│   ├── main
│   ├── media
│   ├── static
│   ├── <configuration_root>
│   │   ├── settings
│   │   │   ├── __init__.py
│   │   │   ├── base.py
│   │   │   ├── development.py
│   │   │   ├── production.py
│   │   │   ├── staging.py
│   │   │   └── testing.py
│   │   ├── __init__.py
│   │   ├── urls.py
│   │   └── wsgi.py
│   └── manage.py
├── requirements
│   ├── _base.txt
│   ├── development.txt
│   ├── production.txt
│   ├── staging.txt
│   └── testing.txt
├── bootstrap.py
├── fabfile.py
└── nginx.conf

Explicando a estrutura...

A partir da versão 1.4, o Django, ao criar um projeto novo, cria uma estrutura de pasta em 2 níveis, na primeira inicialmente você fica apenas com o arquivo manage.py e no segundo nível é onde fica os arquivos settings.py, urls.py.

Na estrutura que eu uso em meus projetos, a proposta é ter 3 níveis. O primeiro nível, chamado de project_root, serve para incluir os arquivos que estão relacionados com o deploy do projeto e além disso, contém uma pasta chamada requirements que contém todos os requisitos do projeto segregados por ambiente, assim como acontece com a pasta settings que veremos mais a seguir. Além disso, essa pasta serve para conter outros arquivos que não estão relacionados diretamente com o código-fonte do projeto, como arquivos de design, por exemplo. Segue uma explicação básica para os arquivos que encontramos nessa pasta.

bootstrap.py - Esse arquivo usa o requirements.txt para instalar automaticamente todas as bibliotecas da aplicação usando o pip.
fabfile.py - Arquivo da biblioteca Fabric que contém todas as funções de deploy da aplicação.
nginx.conf - Arquivo de configuração do nginx que precisa ser copiado para o servidor toda vez que é feito o deploy da aplicação.

No segundo e terceiro nível, nós temos a estrutura de pasta que foi criada pelo Django, sendo que o segundo nível chamamos de django_project_root e o terceiro chamamos de configuration_root.

django_project_root

Esse é o diretório padrão de um projeto Django, contém o arquivo manage.py, e também as pastas específicas que representam as aplicações do projeto. As demais pastas que constam na estrutura são explicadas logo abaixo.

Pasta data

Essa pasta será usada para para armazenar o banco de dados (caso o mesmo seja embutido na aplicação, como o SQLite) e servirá para armazenar outros artefatos como scripts SQL ou Python, dados de migração, fontes de dados ou quaisquer outras informações relacionadas a base de dados do projeto.

Pasta log

Essa pasta é usada para fazer o deploy com o nginx. Esse servidor web precisa dos dois arquivos contidos nessa pasta para guardar o log de acessos e de erros da aplicação.

Caso não vá usar o nginx, pode deletar essa pasta, ou talvez usá-la para implementar algum tipo de log e armazená-lo.

Pasta main

Representa a app principal do projeto. Independente da divisão de apps que você irá escolher para o projeto, essa app irá servir como um agregador de artefatos que são comuns a todo o projeto ou que serão utilizados por todas as demais apps do projeto.

Por exemplo, essa app main poderá conter os arquivos relativos a tela de login e index do projeto. Poderá conter os arquivos estáticos que são comuns a todo o projeto e assim por diante.

No caso de projetos que sejam muito pequenos, talvez essa seja a única app necessária.

Pasta static

Essa pasta serve para abrigar todos os arquivos estáticos encontrados no projeto quando o comando collectstatic é executado. Para mais informações sobre esse assunto, veja a documentação do Django sobre como gerenciar arquivos estáticos.

Pasta media

Essa pasta serve para abrigar todos os arquivos do projeto relacionados a upload realizados pelo usuário ou arquivos que são gerados dinamicamente pelo próprio projeto (imagens de relatório, por exemplo).

configuration_root

Esse diretório contém toda a parte de configuração da aplicação, como o arquivo urls.py e o módulo settings.

Módulo settings

Essa pasta contém os arquivos de configuração da aplicação segregados por ambiente e com o arquivo base.py que é responsável por conter todas as configurações comuns a todos os ambientes da aplicação. Esses arquivos ficam organizados numa espécie de herança. Todos os arquivos herdam de base.py e especializam as suas configurações por ambiente.

E onde entra o settings.py nessa brincadeira? No final das contas, o arquivo settings.py será deletado, e agora toda vez que for rodar a sua aplicação, basta indicar qual o arquivo de configuração que deseja usar através do parâmetro settings, como segue:

:::bash
python manage.py runserver --settings=project.template.settings.testing

Concluindo...

Essa é a estrutura padrão que eu uso para os meus projetos. Caso queira baixar os fontes desse projeto padrão, fique à vontade para visitar o repositório do projeto no GitHub. Consultando os fontes talvez fique bem mais fácil de entender tudo o que foi exposto nesse artigo. De qualquer forma, espero que o tenha ajudado pelo menos a ter uma idéia inicial de como organizar os seus projetos. Agora, compartilhe suas idéias e sugestões nos comentários.

Atualização: 15 de fevereiro de 2013

Esse post foi atualizado em diversas partes para refletir as boas práticas aprendidas ao ler o livro Two Scoops of Django.

Referências

Gareth Rushgrove: Fabric, Django, Git, Apache, Mod_wsgi, Virtualenv and Pip Deployment

Klaus Laube: Como organizar seus projetos Django

Django Best Practices: A guide to developing and deploying with the Django Web framework

Já estava querendo fazer esse tutorial há bastante tempo, mas estava esperando amadurecer algumas idéias para que a coisa ficasse bem redonda. Para facilitar, esse tutorial subentende que o usuário já conhece Python, Django e sabe como instalar e rodar o Jenkins. Sem enrolar, vamos aos passos do tutorial.

Passo 1 - Instalar os plugins do Jenkins

Esses são os plugins que eu uso para facilitar a configuração do meu ambiente e de quebra, trazer algumas informações úteis sobre os projetos.

Cobertura
SLOCCount
Git Plugin (ou o plugin necessário para a sua ferramenta de controle de versão)
Violations

Passo 2 - Instalar módulos Python para o projeto Django

Antes de entrar na configuração do projeto Django, precisamos instalar os seguintes módulos no Python:

django-jenkis - Essa ferramenta será a mais importante em todo o nosso processo de configuração e irá reduzir extremamente o trabalho e a complexidade em configurar um projeto Django no Jenkins.
clonedigger - Usada para encontrar código duplicado no seu projeto, muito útil.
coverage.py - Usada para gerar relatórios de cobertura de testes que serão lidos através do plugin Cobertura do Jenkins.
pep8, pylint e pyflakes - Essas ferramentas serão usadas para gerar relatórios de análise estática de código Python.
nose - Opcional, eu prefiro usar nose para rodar os testes unitários do meu projeto, mas o Django já possui uma biblioteca para rodar testes que é bem interessante.

Passo 3 - Configurar o django-jenkins

Uma vez instalado, para usar o django-jenkins é bem tranquilo. Basta rodar o seguinte comando que foi adicionado ao manage.py do Django.

:::bash
$ python manage.py jenkins

Esse simples comando irá gerar relatórios que serão consumidos pela nossa configuração do Jenkins como veremos mais tarde. Se quiser você pode optar por configurar as tarefas que você deseja que o django-jenkins execute para você. Para isso, é necessário criar a seguinte configuração no seu arquivo settings.py do Django.

:::python
JENKINS_TASKS = (
    'django_jenkins.tasks.with_coverage',
    'django_jenkins.tasks.run_pep8',
    'django_jenkins.tasks.run_pylint',
    'django_jenkins.tasks.run_pyflakes',
    'django_jenkins.tasks.run_jslint',
    'django_jenkins.tasks.run_csslint',
    'django_jenkins.tasks.run_sloccount',
)

Essa é a configuração que eu costumo usar para os projetos da nossa equipe. Para uma lista completa das tarefas, consulte esse link.

IMPORTANTE: Para que as tarefas run_jslint e run_csslint possam funcionar é necessário instalar o rhino ou NODE.js no servidor onde o Jenkins está instalado.

Passo 4 - Configurar o projeto no Jenkins

Para essa parte do tutorial, consideremos que o nome do meu projeto seja ProjetoBlog e que o diretório onde está o código-fonte do projeto é chamado blog. No meu caso, eu uso uma estrutura de projetos do Django em 2 níveis (pretendo escrever um post sobre isso depois), mas você poderá adaptar todos os passos seguintes a estrutura que você usa em seus projetos.

1. Criar o job

Na tela inicial do Jenkins você verá uma opção chamada New Job, ao clicar nela basta preencher o nome desejado para o job e selecionar a opção Build a free-style software project, conforme mostrado na figura abaixo.

2. Configurar o controle de versão

A configuração do controle de versão é extremamente simples, basta selecionar o controle de versão desejado, informar o repositório conforme solicitado e no campo Branches to build informar o branch que você deseja que o Jenkins use como padrão, na maioria absoluta dos casos, é o branch master.

3. Buscar atualizações do projeto

Após configurar o repositório do projeto, precisamos informar o intervalo de tempo que queremos que o job do Jenkins verifique se o projeto foi atualizado e em caso positivo rodar um novo build. Usamos para isso o campo Build Triggers. Na figura abaixo, a configuração colocada indica que o repositório será verificado de 5 em 5 minutos.

4. Processo de build

Agora nesse passo é onde o Jenkins vai realmente realizar o trabalho de build e executar tudo o que planejamos e configuramos anteriormente. Para isso, vamos ter que criar diversos comandos de shell que serão executados em sequência. A figura abaixo mostra isso. Os comandos serão explicados logo abaixo da figura.

Comando 1

:::bash
bash -l -c "source /home/jenkins/.virtualenvs/blog/bin/activate && pip install -r requirements.txt"

Esse primeiro comando é usado para atualizar os módulos da aplicação, como eu uso o virtualenv, então ele precisa da primeira parte para rodar o comando sob o ambiente virtual que foi criado.

Comando 2

:::bash
bash -l -c "source /home/jenkins/.virtualenvs/blog/bin/activate && cd blog &&
python manage.py syncdb --noinput && python manage.py migrate && python manage.py jenkins"

Comando para atualizar o banco de dados e também para rodar as tarefas do django-jenkins.

Comando 3

:::bash
bash -l -c "source /home/jenkins/.virtualenvs/blog/bin/activate &&
clonedigger --cpd-output -o ./blog/reports/clonedigger.xml ./blog"

Comando usado para rodar a ferramenta clonedigger com os seus parâmetros e especificar o formato do relatório, esse formato é obrigatório para que ele seja entendido pelo jenkins.

Comando 4

:::bash
bash -l -c "source /home/jenkins/.virtualenvs/blog/bin/activate &&
cd blog && python manage.py test"

Esse último comando é opcional, eu apenas o uso pois como coloquei antes, eu não uso a suíte de testes padrão do Django, mas uso o nose.

5. Configurar o relatório de cobertura de testes

Chegou a hora de configurar o Jenkins para ler os relatórios que foram gerados, vamos começar com o relatório de cobertura de testes gerado pelo coverage.py. Selecione a opção Publish Cobertura Coverage Report e indique o caminho onde foi gravado o arquivo coverage.xml. Vejamos a imagem.

6. Configurar o relatório de testes unitários e quantidade de linhas de código

Assim como na configuração anterior, precisamos apenas marcar as opções exibidas abaixo na figura e colocar o caminho para os respectivos relatórios.

7. Configurar os relatórios do plugin Violations

Chegamos na última etapa desse tutorial que envolve somente indicar os caminhos para os relatórios de violações que foram resultado das análises estáticas de código Python, Javascript e CSS conforme configuramos no início desse tutorial. Assim como nas opções anteriores, marque a opção Report Violations e coloque os caminhos de acordo com a imagem que é mostrada logo abaixo.

Conclusão

E é isso! Essa é a configuração que precisamos fazer para que um projeto Django use o Jenkins. Depois de tudo isso feito, é só salvar a configuração e clicar no link Build Now e ver os resultados. Seguem alguns exemplos de informações que veremos como resultado, clique nas imagens para ver em tamanho real.

Dicas extras

Algo que pode facilitar ainda mais a configuração de um projeto no Jenkins é um plugin chamado ShiningPanda que permite trabalhar com diferentes versões do Python e inclusive usar o virtualenv de maneira mais transparente mas eu nunca testei.
Outra dica legal é que existem alguns plugins que podem ser usados para melhorar a aparência do Jenkins. Esse artigo mostra quais são os melhores plugins para fazer isso.

Referências

Mikhail Podgurskiy: django-jenkins Tutorial

Joe Heck: Setting up a Python CI server with Hudson

Gareth Rushgrove: A Continuous Deployment Example Setup

Bartek Ciszkowski: Continuous Integration with Jenkins

O que é software design? Qual é o produto final da atividade software design? Por que é tão importante entender esse conceito nos nossos dias e como entendê-lo pode mudar a forma como você encara o desenvolvimento de software e toda a indústria de software que conhecemos atualmente.

O que me fez ter vontade de levantar essa discussão foi que um dia desses eu estava dando uma olhada nos meus itens para ler no delicious.com e me deparei com um artigo bem antigo, de 1992 e que chamou a minha atenção imediatamente. O artigo em questão foi escrito por Jack W. Reeves e apesar de antigo continua tão atual que parece ter sido escrito ontem. Sugiro fortemente que antes de você continuar lendo esse post, leia o artigo original ou pelo menos guarde-o nos seus bookmarks para ler depois.

O artigo

Durante todo o artigo de Reeves, você percebe que ele tenta colocar na mente do leitor um conceito principal. O produto gerado pela atividade de software design não é documentação, mas sim código-fonte. E esse conceito principal é desdobrado em diversos outros aspectos relacionados que realmente abrem os olhos para alguns aspectos que ele mesmo diz que são tão óbvios que parece que estão localizados em um ponto-cego das empresas. Vejamos alguns desses aspectos.

There is one consequence of considering code as software design that completely overwhelms all others. It is so important and so obvious that it is a total blind spot for most software organizations. This is the fact that software is cheap to build. It does not qualify as inexpensive; it is so cheap it is almost free. If source code is a software design, then actually building software is done by compilers and linkers.

O primeiro aspecto aqui é bem claro. Reeves coloca que "construir" software é muito barato. Mas não construir software do jeito que nós entendemos, o que encaramos hoje como construir software é o que ele chama de software design e é justamente aí que a coisa toda começa a fazer mesmo todo o sentido pois os conceitos começam a ser esclarecidos e mais importante ainda, unificados. Construir software ou build software se refere a atividade de compilar o software, gerar o artefato final do software, que pode variar de um executável para um conjunto de arquivos interpretados, dependendo da linguagem de programação que usamos. E nesse caso, build software, é muito barato, basta um computador comum para isso.

Mas software design é caro, muito caro. Observemos a explicação de Reeves, mais uma vez.

Designing software is an exercise in managing complexity. The complexity exists within the software design itself, within the software organization of the company, and within the industry as a whole. Software design is very similar to systems design. It can span multiple technologies and often involves multiple sub-disciplines. Software specifications tend to be fluid, and change rapidly and often, usually while the design process is still going on. Software development teams also tend to be fluid, likewise often changing in the middle of the design process. In many ways, software bears more resemblance to complex social or organic systems than to hardware. All of this makes software design a difficult and error prone process. None of this is original thinking, but almost 30 years after the software engineering revolution began, software development is still seen as an undisciplined art compared to other engineering professions.

Aí está, software design envolve essencialmente tratar a complexidade que é exigida no desenvolvimento de software, e essa complexidade tende a crescer exponencialmente a medida que o software cresce em funcionalidades. Apenas para termos um exemplo mais atual que o do artigo, levemos em conta um desenvolvimento web da atualidade.

Para desenvolver uma aplicação web hoje, você precisa conhecer inicialmente HTML e alguma linguagem para realizar a programação do lado servidor, recomendo que caso queira reduzir a complexidade dessa aplicação, escolha Python. Daí, para poder deixar a aplicação apresentável em termos visuais, você terá de conhecer bem CSS. Se quiser que sua aplicação seja bastante interativa com o usuário, terá que conhecer Javascript. Para facilitar o uso do Javascritp, hoje quase todo mundo prefere a fantástica biblioteca jQuery. Se quiser facilitar as coisas ainda mais e ficar antenado com as tendências mais recentes acrescente aí as novidades do HTML5 e as novidades do CSS3. E olhe que estamos falando aqui apenas da parte de tecnologia de uma aplicação.

Para complicar ainda mais o cenário exposto acima, adicione a essa receita de complexidade as regras de negócio do seu cliente, que na maioria dos casos devem ser inúmeras e mudar constantemente e sim, chegamos facilmente a conclusão de que desenvolver software é realmente um exercício de complexidade, e por isso realizar software design é caro, muito caro.

Conclusão

Percebe agora por que software design é tão importante? Software design de verdade acontece no momento em que estamos produzindo código-fonte, é ali que precisamos nos preocupar com a complexidade do software, se vamos usar orientação a objetos, programação funcional, se vamos dividir em módulos o sistema, qual vai ser a arquitetura da aplicação que vai suportar essa complexidade.

Porém, o problema é que já por muito tempo, a indústria tem adicionado outras complexidades em cima de algo que já é por natureza bastante complexo com metodologias, processos, certificações entre outras coisas que só complicam a nossa vida ao invés de realmente nos ajudar. Não sou contra processo e acho até que ele ajuda em muitos casos, mas precisamos claramente de processos que tornem a vida de quem cria o software, o desenvolvedor, mais fácil e não mais complicada. Métodos ágeis estão aí para tentar ajudar nessa questão, mas quantas empresas hoje são realmente ágeis? Quanto tempo ainda vai demorar para que elas saiam desse ponto-cego em que se encontram e passem a enxergar o óbvio como um artigo desses que foi escrito em 1992? São perguntas que eu infelizmente não sei a resposta, mas sei que precisamos persistir em tentar respondê-las.

Esse tutorial tem por objetivo mostrar como podemos ser produtivos programando em Python no Emacs. Além disso, o tutorial vai mostrar um pouco do meu ambiente de desenvolvimento e para quem tiver curiosidade, eu vou deixar alguns links no final para quem quiser se aprofundar no assunto.

Para começar escolha a versão de Emacs que mais se adeque ao seu gosto e ao seu sistema operacional, tem até versão para Windows e depois de tê-lo instalado, faça o tutorial para começar a se acostumar com os conceitos fundamentais do Emacs.

Configurando o Emacs para uso geral

Se você estiver usando Emacs no Linux, e eu realmente espero que esteja, na instalação foi criada uma pasta oculta dentro da pasta do seu usuário de nome .emacs.d. Para facilitar a configuração, crie dentro dessa pasta uma outra pasta de nome plugins.

Toda a nossa configuração ficará colocada dentro do seguinte arquivo: /home/<nome_usuario>/.emacs.d/init.el. Como já devem ter lido por aí, a grande vantagem de uso do Emacs é a customização, é como brincar de lego para montar a sua IDE personalizada. Toda a configuração do Emacs é feita em LISP, mas não se preocupe, você não precisa conhecer LISP a fundo para entender esse tutorial, a maior parte dos comandos é bem fácil de entender. Abra esse arquivo no próprio Emacs ou em outro editor de texto de sua preferência. Todos os trechos de código expostos nesse post devem ser colocados dentro desse arquivo de configuração.

Passo 1

Coloque essas linhas abaixo no início do arquivo de configuração.

:::common-lisp
(add-to-list 'load-path "~/.emacs.d")
(add-to-list 'load-path "~/.emacs.d/plugins")

Essas linhas acima carregam as pastas onde serão procurados os arquivos com extensão .el, que são os arquivos que representam extensões e plugins que usaremos durante esse tutorial.

Passo 2

Agora, vamos baixar o primeiro plugin da nossa configuração, é o ido-mode. Baixe esse arquivo e coloque na pasta ~/.emacs.d/plugins. Depois adicione o seguinte trecho no arquivo de configuração.

:::common-lisp
(require 'ido)
(ido-mode t)

Esse plugin serve para facilitar a abertura de arquivos dentro do Emacs e também a troca entre os buffers. Como o Emacs pode ser bastante confuso para os iniciantes esse plugin é mais do que recomendado.

Passo 3

:::common-lisp
(cua-mode t)
(setq cua-auto-tabify-rectangles nil) ;; Don't tabify after rectangle commands
(transient-mark-mode 1) ;; No region when it is not highlighted
(setq cua-keep-region-after-copy t) ;; Standard Windows behaviour

(delete-selection-mode 1)

cua-mode vai servir para deixar o Emacs parecido com qualquer outra IDE comum permitindo usar as teclas de atalho Ctrl + C, Ctrl + V e assim por diante. Só é preciso ter cuidado pois esses atalhos conflitam com alguns outros do Emacs e por isso somente estão ativos quando algum texto está selecionado.

As demais linhas desse passo são opcionais, chamo a atenção para a linha do delete-selection-mode, essa linha faz com que, toda vez que um texto estiver selecionado, qualquer inserção será inserida no lugar do texto selecionado.

Passo 4

[Auto Complete Mode] melhora a funcionalidade de auto-completar do Emacs. A parada é realmente inteligente. Para instalar:

:::bash
$ cd ~/.emacs.d/plugins/
$ curl http://cx4a.org/pub/auto-complete/auto-complete-1.3.1.tar.bz2 | tar jx
$ cd auto-complete-1.3.1
$ make byte-compile

Para configurar:

:::common-lisp
(add-to-list 'load-path "~/.emacs.d/plugins/auto-complete-1.3.1/")
(require 'auto-complete-config)
(add-to-list 'ac-dictionary-directories "~/.emacs.d/plugins/auto-complete-1.3.1/ac-dict")
(ac-config-default)

Passo 5

Instale o YASnippet. Esse cara cria um menu no Emacs onde podemos usar um sistema de templates semelhante ao TextMate.

Passo 6

:::common-lisp
(require 'uniquify)
(setq uniquify-buffer-name-style 'forward)

O último passo dessa customização geral é o uso do uniquify, esse modo é extremamente útil quando começamos a trabalhar com vários arquivos abertos e que alguns tenham nomes iguais.

Configurando o Emacs para programar com Python

Antes de entrar no passo-a-passo de como configurar o Emacs para Python é importante avisar algo. Para não deixar a instalação original de Python no meu Ubuntu ficar poluída com todas as bibliotecas que eu quero instalar, eu instalo uma ferramenta conhecida como virtualenv, e para instalação de pacotes do Python, eu uso uma ferramenta chamada pip. Basicamente, virtualenv é uma ferramenta para criar ambientes isolados de Python, e pip é simplesmente o melhor gerenciador de pacotes Python que eu conheço.

Para essa configuração eu criei um ambiente de Python isolado com virtualenv apenas para servir ao Emacs. Sugiro que, se estiver seguindo esse tutorial, você faça o mesmo. Vamos continuar com o passo-a-passo.

Passo 1

:::common-lisp
(setq-default indent-tabs-mode nil)  ; use only spaces and no tabs
(setq default-tab-width 4)

Python usa indentação para definição de blocos de código, assim é extremamente importante que usemos essas linhas código para definir o tamanho da indentação e também definir que sempre serão usados espaços ao invés de tabs.

Passo 2

Agora vamos instalar um pacote essencial para uso de Python no Emacs, o nome desse pacote é Pymacs. Se estiver usando Linux, vá até o seu terminal e digite os comandos abaixo:

Instalação Pymacs (Parte Emacs) :::bash $ curl -L https://github.com/pinard/Pymacs/tarball/v0.24-beta2 | tar zx $ cd pinard-Pymacs-016b0bc $ make $ cp pymacs.el ~/.emacs.d/pymacs.el $ emacs -batch -eval '(byte-compile-file "~/.emacs.d/pymacs.el")'
Instalação Pymacs (Parte Python) :::bash $ pip install https://github.com/pinard/Pymacs/tarball/v0.24-beta2

Agora vamos ao arquivo de configuração no Emacs e incluir o seguinte trecho:

:::common-lisp
(setenv "PYMACS_PYTHON" "~/<caminho_virtualenv>/bin/python")

(autoload 'pymacs-apply "pymacs")
(autoload 'pymacs-call "pymacs")
(autoload 'pymacs-eval "pymacs" nil t)
(autoload 'pymacs-exec "pymacs" nil t)
(autoload 'pymacs-load "pymacs" nil t)

A primeira linha será necessária apenas se você estiver usando o virtualenv.

Passo 3

Nesse passo, vamos instalar o Ropemacs e o Rope. Rope é uma poderosa biblioteca de refactoring para Python, e Ropemacs obviamente um plugin do Emacs para uso do Rope.

Para instalar o Rope e Ropemacs, digite no terminal:

:::bash
$ pip install http://bitbucket.org/agr/ropemacs/get/tip.tar.gz

No arquivo de configuração do Emacs:

:::common-lisp
(require 'pymacs)

(pymacs-load "ropemacs" "rope-")
(setq ropemacs-enable-autoimport t)

Passo 4

Chegamos em uma das partes que eu mais gosto do Emacs, análise automática, on-the-fly, do código Python. O responsável por isso é o Flymake que já vem por padrão, a partir da versão 23 do Emacs. O que vamos precisar instalar aqui é o pep8 e o pyflakes que são bibliotecas para análise estática de código-fonte Python.

:::bash
$ pip install pyflakes pep8

Depois, precisamos configurar o Flymake no Emacs:

:::common-lisp
(when (load "flymake" t)
  (defun flymake-pyflakes-init ()
    (let* ((temp-file (flymake-init-create-temp-buffer-copy
                       'flymake-create-temp-inplace))
           (local-file (file-relative-name
                        temp-file
                        (file-name-directory buffer-file-name))))
      (list "/home/lslf/<caminho_virtualenv>/bin/pyflakes" (list local-file))))

  (add-to-list 'flymake-allowed-file-name-masks
               '("\\.py\\'" flymake-pyflakes-init)))

(add-hook 'find-file-hook 'flymake-find-file-hook)

(defun my-flymake-show-help ()
  (when (get-char-property (point) 'flymake-overlay)
   (let ((help (get-char-property (point) 'help-echo)))
    (if help (message "%s" help)))))

(add-hook 'post-command-hook 'my-flymake-show-help)

(delete '("\\.html?\\'" flymake-xml-init) flymake-allowed-file-name-masks)

Passo 5

O último passo desse tutorial, também se refere a análise de código, mas ao invés de análise automática, vamos configurar uma análise de código através de um comando do Emacs.

Primeiro crie um arquivo no caminho ~/.emacs.d/ chamado pychecker.sh. O conteúdo do arquivo será:

:::bash
#!/bin/bash
~/<caminho_virtualenv>/bin/pyflakes $1
echo "## pyflakes acima, pep8 abaixo ##"
~/<caminho_virtualenv>/bin/pep8 --repeat $1

Agora a configuração do Emacs:

:::common-lisp
(custom-set-variables
  '(py-pychecker-command "~/.emacs.d/pychecker.sh")
  '(py-pychecker-command-args (quote ("")))
  '(python-check-command "~/.emacs.d/pychecker.sh")
)

Dicas extras

Além de tudo o que foi colocado aí acima, você pode querer ir além e melhorar cada vez mais o seu uso do Emacs, para ficar do seu gosto, aqui vão algumas dicas:

O Emacs já funciona automaticamente com Subversion, basta aprender a usar;
Você pode configurar o Emacs para te ajudar com o Django também;
Coloque o seu diretório ~/.emacs.d sob controle de versão;
Explore a infinidade de possibilidades de customização do Emacs.

Conclusão

Eu sei que esse tutorial ficou bem longo, mas eu tentei colocar todas as principais dicas de otimização de tempo e produtividade que eu adquiri em pouco tempo usando o Emacs, como eu disse antes, é como brincar de lego para montar a sua IDE, com as funcionalidades que você precisa.

Deixe as suas impressões nos comentários, se houver algum problema, pode entrar em contato que tentarei ajudar o máximo que puder.

Referências

Ryan McGuire: Emacs as a powerful Python IDE

SaltyCrane: My Emacs Python environment

Lei Chen: Setup Perfect Python Environment In Emacs

Jesse Legg: Emacs for Python Programmers: Basics

Jesse Legg: Emacs for Python Programmers #2: Virtualenv, IPython & Daemon Mode

Brandon Rhodes: Installing Python packages for Emacs with virtualenv

Alex Clemesha: Tools of modern Python hacker: Virtualenv, Fabric and pip

A revista TI Digital do mês março vem com uma matéria de capa com 14 páginas sobre a minha linguagem de programação favorita, Python. E por pura coincidência eu fui um dos convidados a responder algumas perguntas para compor a matéria.

Eu não conhecia a revista antes disso, mas o contato com eles foi sempre muito cordial e a matéria ficou bem bacana, servindo como uma excelente divulgação para a linguagem. Aproveito esse post para colocar aqui as perguntas que a revista me fez e as minhas respostas na íntegra.

Quais foram suas primeiras impressões quando começou a programar em Python? Qual era a linguagem de programação que você utilizava antes?

Eu comecei a utilizar Python em 2005, quando ainda trabalhava no SERPRO. Nessa época eu fui integrado a uma equipe que desenvolvia um sistema para o Ministério da Educação e esse sistema era inteiramente feito em Python. Uma das coisas que mais me impressionou em Python foi o ganho de produtividade em um curto espaço de tempo. Eu não tinha experiência anterior com a linguagem e em apenas 2 dias eu já estava participando ativamente no desenvolvimento de alguns módulos desse sistema.

Anteriormente, eu já havia programado com Java, C#, Visual Basic e ASP e ainda assim, Python também me impressionou bastante pela legibilidade do código-fonte. Quando somos desenvolvedores de software, nós passamos mais tempo lendo código do que propriamente escrevendo, e em Python sempre foi muito fácil entender o código que foi escrito por outro desenvolvedor.

Onde se pode programar Python?

Python pode ser programado em qualquer sistema operacional moderno e até mesmo nos sistemas mais antigos. Em diversas distribuições Linux, como Ubuntu, Fedora, Suse entre outras, o Python já vem instalado nativamente, o mesmo acontece também para o Mac OS X. No caso da plataforma Windows, existem instaladores que podem ser usados para facilmente instalar o Python. Posso destacar que é de longe a linguagem mais portável com que eu trabalhei, e você nem mesmo precisa alterar o código-fonte da sua aplicação para que ela funcione em sistemas operacionais diferentes, isso eu já pude comprovar na prática.

O que é possível desenvolver com o Python?

Python é uma linguagem de programação flexível. Por ser uma linguagem dinâmica e multi-paradigma, Python é ideal para desenvolver desde pequenos scripts para automatização de determinadas tarefas, passando por sistemas web, cliente-servidor, desktop e até mesmo sistemas científicos. Basta dizer que a NASA usa Python, para comprovar o que estou dizendo.

Por que o Python possui duas versões disponíveis para download (Python 2.6.4 and Python 3.1.1)?

Python é uma linguagem um tanto quanto antiga, foi lançada em 1991, e desde a sua criação tem como premissas ser uma linguagem simples, que cabe no nosso cérebro e que procura sempre remover os obstáculos da frente do desenvolvedor para que o mesmo possa se preocupar mais com o conteúdo do que está sendo desenvolvido do que com a linguagem. No entanto, assim como acontece com qualquer linguagem de programação, mesmo Python tendo adotado essas premissas para o seu desenvolvimento, ela foi acumulando alguns "probleminhas" chatos. Para resolver esses problemas e manter uma linguagem simples e que cabe no nosso cérebro, o criador da linguagem resolveu criar a versão 3 de Python quebrando a compatibilidade com a versão anterior (Python 2).

Sendo assim, para manter a compatibilidade com os sistemas antigos criados em Python, foi lançada a versão 2.6 que contém ainda algumas funcionalidades novas da versão 3. E a versão 3, pôde então ser lançada com as novas funcionalidades previstas e sem o compromisso de manter a compatibilidade com as versões anteriores. Com o lançamento dessa nova versão, foi criada também uma ferramenta batizada 2to3 que auxilia na migração de código-fonte criado em Python 2 para Python 3.

O Python pode ser integrado a outras linguagens de programação e ferramentas. Quais são as principais? O que estas integrações oferecem?

As principais integrações de Python são justamente com as plataformas de desenvolvimento que mais fazem sucesso no mercado hoje. Python possui integração com a plataforma Java através de um projeto chamado Jython que está em constante evolução e oferece acesso total as classes Java e permite que código Python seja compilado em classes Java.

Existe também a integração com a plataforma .NET através do projeto IronPython, sendo esse também um projeto bastante evoluído que conta com um console interativo para experimentar trechos de código e conta também com uma IDE específica baseada no Visual Studio da Microsoft. Essa integração permite que você tenha acesso às bibliotecas do .NET Framework usando o Python, ao invés de uma das linguagens da plataforma .NET . Com essa integração nós podemos, por exemplo, criar uma aplicação desktop com a biblioteca .NET padrão (WPF) usando código Python na solução.

Outra integração que ainda está em fase beta, mas que promete ser bem interessante é o PyObjC que é uma integração entre Python e Objective-C, a linguagem utilizada para desenvolver aplicativos para iPhone, iPod Touch e para o recém-lançado iPad. Acho que não preciso nem comentar muito quais serão as vantagens dessa integração né?

Existem alguns fatores tecnológicos q o Python precisa evoluir. Então, o que você sente falta no Python? O que gostaria que fosse diferente na linguagem?

Python possui um conceito muito interessante chamado de "batteries included", o que significa que a biblioteca padrão do Python é muito poderosa, de modo que lhe oferece funcionalidades para diversos tipos de necessidades que venham a surgir para a sua aplicação. Mas mesmo assim, ainda sinto falta em Python de uma biblioteca nativa que seja capaz de lidar com web services por exemplo, existem alguns projetos interessantes nesse sentido, mas acredito que a biblioteca padrão pudesse incorporar essa funcionalidade.

Usar concorrência em Python também ainda é bem rudimentar, e acredito que a linguagem possa evoluir MUITO nesse ponto, não somente na questão de performance que se torna sofrível em alguns casos que você precise lidar com concorrência, como a própria módulo python para esse fim, threading, poderia incluir mais funcionalidades para facilitar a vida de quem precisa programar usando concorrência.

Na parte de orientação a objetos, eu gostaria que Python tivesse uma melhor implementação de encapsulamento, não somente por necessidade minha, mas também para poder "agradar" aos desenvolvedores que tem uma grande experiência com OO e acabam não se acostumando muito bem com o encapsulamento de Python que é bem diferente de Java e .Net, por exemplo.

A comunidade Python ainda não é muito conhecida. Qual a melhor maneira de fazer com que o Python seja mais explorado? O que ainda falta para convencer os programadores sobre o poder do Python?

Outro dia ouvi um colega de trabalho dizer que Python é uma linguagem que deu certo em outros países, mas não funcionou no Brasil. Concordo que isso já pode ter sido verdade algum dia, mas hoje estamos experimentando uma realidade diferente. Muitas empresas no país tem adotado Python para projetos importantes, e acredito que para fazer com que o Python seja mais explorado é importante mostrar que a cena está mudando. É necessário investir em um marketing positivo, ou seja, ao invés de criticar duramente as linguagens que hoje dominam o mercado, precisamos exaltar as características do Python, convencer as pessoas, especialmente aquelas que hoje estão em posição de decisão, de que Python é uma alternativa viável, estável, mais rápida e mais barata do que a maioria das opções que existem hoje.

Convencer os programadores, eu acredito ser a parte mais fácil do processo, mas precisamos de mais eventos técnicos focados em Python para mostrar todas as possibilidades que o Python oferece. Usar um veículo de comunicação como a revista TI Digital com uma matéria de capa sobre Python já mostra que o cenário está mudando rapidamente e favoravelmente à linguagem, isso também ajuda a mostrar para os desenvolvedores que existem alternativas.

A comunidade brasileira tem ajudado de alguma forma para o crescimento e atualização da linguagem?

A comunidade brasileira de Python é fantástica. Hoje nós temos a Associação Python Brasil que promove anualmente uma conferência de Python que cada vez mais tem crescido em qualidade e audiência. E sem contar que temos diversos grupos locais espalhados pelo país, entre eles posso destacar o PythonRio que promove alguns eventos importantes sobre Python durante o ano. Um desses eventos promovidos que merece destaque é o PythonCampus que é uma espécie de caravana de tecnologia que visa integrar os estudantes de diversas universidades do estado com o mercado e com a tecnologia em si.

Na semana passada estava precisando de uma biblioteca Python para realizar acesso a um web service SOAP. Fazendo uma rápida pesquisa encontrei algumas bibliotecas bem utilizadas, mas todas estavam muito desatualizadas, como a SOAPpy por exemplo, que não é atualizada desde 2005.

Quando já estava quase desistindo de encontrar algo atualizado que atendesse a minha necessidade, eu me deparo com essa biblioteca de nome suds. Fiquei positivamente surpreso ao encontrar uma biblioteca que além de ser atualizada e possuir uma boa documentação, representa toda a simplicidade e praticidade de Python.

Como muitos sabem, o protocolo SOAP é um protocolo de comunicação complicado, mas usando o suds tudo fica muito simples. Vejam só.

Para o nosso exemplo, vamos usar um web service que traz informações sobre a Copa do Mundo (eu sei, estou meio atrasado, mas vá lá, é só um exemplo). O endereço do serviço é: http://footballpool.dataaccess.eu/data/info.wso?WSDL. Vamos agora usar o suds para acessar esse serviço.

:::python
from suds.client import Client

url = "http://footballpool.dataaccess.eu/data/info.wso?WSDL"

cliente = Client(url)

print cliente

Simples assim e temos o cliente que representa o serviço com informações sobre a Copa do Mundo carregado em memória. A última linha do código acima serve para listar os métodos que esse serviço disponibiliza. O resultado é esse:

:::bash
Suds ( https://fedorahosted.org/suds/ )  version: 0.3.9 GA  build: R659-20100219


Service ( Info ) tns="http://footballpool.dataaccess.eu"
   Prefixes (1)
      ns0 = "http://footballpool.dataaccess.eu"
   Ports (1):
      (InfoSoap)
         Methods (41):
            AllCards()
            AllDefenders(xs:string sCountryName, )
            AllForwards(xs:string sCountryName, )
            AllGames()
            AllGoalKeepers(xs:string sCountryName, )
            AllGroupCompetitors()
            AllMidFields(xs:string sCountryName, )
            AllPlayerNames(xs:boolean bSelected, )
            AllPlayersWithRedCards(xs:boolean bSortedByName, xs:boolean bSortedByRedCards, )
            AllPlayersWithYellowCards(xs:boolean bSortedByName, xs:boolean bSortedByYellowCards, )
            AllPlayersWithYellowOrRedCards(xs:boolean bSortedByName, xs:boolean bSortedByYellowCards, xs:boolean bSortedByRedCards, )
            AllStadiumInfo()
            Cities()
            Coaches()
            CountryNames(xs:boolean bWithCompetitors, )
            DateLastGroupGame()
            DateOfFirstGame()
            DateOfLastGame()
            FullTeamInfo(xs:string sTeamName, )
            GameInfo(xs:int iGameId, )
            GameResultCodes()
            GamesPerCity(xs:string sCityName, )
            GamesPlayed()
            GoalsScored(xs:int iGameId, )
            GroupCompetitors(xs:string sPoule, )
            GroupCount()
            Groups()
            NextGame()
            NumberOfGames()
            PlayedAtWorldCup(xs:string sTeamName, )
            RedCardsTotal()
            StadiumInfo(xs:string sStadiumName, )
            StadiumNames()
            StadiumURL(xs:string sStadiumName, )
            Teams()
            TeamsCompeteList()
            TopGoalScorers(xs:int iTopN, )
            TopSelectedGoalScorers(xs:int iTopN, )
            TournamentInfo()
            YellowAndRedCardsTotal()
            YellowCardsTotal()
         Types (38):
            ArrayOfString
            ArrayOftCardInfo
            ArrayOftCoaches
            ArrayOftCountryInfo
            ArrayOftCountrySelectedTopScorer
            ArrayOftGameCard
            ArrayOftGameInfo
            ArrayOftGameResultCode
            ArrayOftGoal
            ArrayOftGroupInfo
            ArrayOftGroupsCompetitors
            ArrayOftPlayerNames
            ArrayOftPlayersWithCards
            ArrayOftStadiumInfo
            ArrayOftTeamCompete
            ArrayOftTeamInfo
            ArrayOftTopGoalScorer
            ArrayOftTopSelectedGoalScorer
            tCardInfo
            tCards
            tCoaches
            tCountryInfo
            tCountrySelectedTopScorer
            tFullTeamInfo
            tGameCard
            tGameInfo
            tGameResultCode
            tGoal
            tGroupInfo
            tGroupsCompetitors
            tPlayerNames
            tPlayersWithCards
            tStadiumInfo
            tTeamCompete
            tTeamInfo
            tTopGoalScorer
            tTopSelectedGoalScorer
            tTournamentInfo

Como podem perceber, esse serviço tem 41 métodos que eu posso acionar para obter informações sobre a Copa do Mundo. Vamos ver como eu posso usar esses métodos.

:::python
resultado = cliente.service.RedCardsTotal()
print resultado

O resultado impresso pelo trecho acima é: 17.

Vamos todos dar um viva à simplicidade do Python! :o)

Blog do Ricardo Duarte

Livro Python para Desenvolvedores lançado pela Novatec

Referências

Livro gratuito Python para Desenvolvedores, agora em inglês

Referências

Livro gratuito Python para Desenvolvedores, versão web

Atualização: 17 de outubro de 2013

Referências

Minha primeira biblioteca portada para Python 3

A escolha da biblioteca

A estratégia de migração

O processo de migração

Referências

Minha estrutura padrão para um projeto Django

Bibliotecas essenciais para um projeto Django

Estrutura do projeto

Explicando a estrutura...

django_project_root

Pasta data

Pasta log

Pasta main

Pasta static

Pasta media

configuration_root

Módulo settings

Concluindo...

Atualização: 15 de fevereiro de 2013

Referências

Como configurar um projeto Django no Jenkins

Passo 1 - Instalar os plugins do Jenkins

Passo 2 - Instalar módulos Python para o projeto Django

Passo 3 - Configurar o django-jenkins

Passo 4 - Configurar o projeto no Jenkins

1. Criar o job

2. Configurar o controle de versão

3. Buscar atualizações do projeto

4. Processo de build

5. Configurar o relatório de cobertura de testes

6. Configurar o relatório de testes unitários e quantidade de linhas de código

7. Configurar os relatórios do plugin Violations

Conclusão

Dicas extras

Referências

O que é software design? E por que é tão importante

O artigo

Conclusão

Programando em Python no Emacs

Configurando o Emacs para uso geral

Passo 1

Passo 2

Passo 3

Passo 4

Passo 5

Passo 6

Configurando o Emacs para programar com Python

Passo 1

Passo 2

Passo 3

Passo 4

Passo 5

Dicas extras

Conclusão

Referências

Python e eu na revista TI Digital

Como acessar webservices SOAP com Python