Tiveron!

Argumentos….parece assunto bastante trivial, na verdade é, mas podemos nos deparar com algumas situações um pouco mais complexas que o tradicional.
E como eu qualquer outra linguagem decente, python nos dá algumas opções para trabalharmos com argumentos em uma função.

Basicamente temos 2 tipos de argumentos em python, aqueles que são passados diretamente na execução de uma função(chamado de posicional, o mais tradicional)  e aqueles argumentos passados por palavra-chave(que não precisam estar na ordem certa em que são declarados na função).

Argumentos Posicionais

Quando trabalhamos com argumentos posicionais, devemos respeitar a ordem na qual eles foram definidos na função, ou seja, o primeiro argumento passado na execução da função será o primeiro argumento que ela receberá, e assim por diante. Todo argumento posicional é obrigatório.

def foo(arg1, arg2):
    print arg1
    print arg2
 
>>> foo('valor1', 'valor2')
valor 1
valor 2

Argumentos tipo Palavra-chave

Já argumentos definidos por palavras-chave não precisam ser passados na ordem em que foram definidos, basta fazer a associação através de uma palavra-chave. Argumentos por palavra-chave são opcionais, uma vez que podemos pré-definir valores para eles.

def foo(arg1='valor 1', arg2='valor 2'):
    print arg1
    print arg2
 
>>> foo(arg2='novo valor 2')
valor 1
novo valor 2

Note que  na chamada da função só passamos o argumento arg2, isso funciona porque, como já explicado, argumentos por palavra-chave são opcionais. Como a função não recebeu nenhum argumento chamado arg1, o mesmo assumiu seu valor pré-definido(‘valor 1′).

Um pouco dos 2

Podemos também misturar os 2 tipos de argumentos sem problemas, com uma simples regra. Os argumentos posicionais devem sempre vir antes que argumentos por palavra-chave

def foo(arg1, arg2, arg3='valor 3', arg4='valor 4'):
    print arg1
    print arg2
    print arg3
    print arg4
 
>>> foo(valor1, valor2, arg4='novo valor 4')
valor 1
valor 2
valor 3
novo valor 4

Caixa preta

Até agora, em todos os exemplos passados, sabemos exatamente quais argumentos nossa função deve esperar. Mas se por acaso não soubermos os argumentos que nossa função vai receber? Como adequar nosso código para tratar esse tipo de imprevisto?

Para esses casos python nos dá uma grande ajuda =)  Temos 2 coringas para pegarmos os argumentos adicionais:

*arg = pega todos os argumentos posicionais adicionais em uma função
**kwargs = pega todos os argumentos por palavra-chave adicionais em uma função

Lembrando que as palavras ‘arg’ e ‘kwargs’ são apenas uma convenção, o que interessa mesmo são os asteriscos. 1 para posicionais e 2 para palavras-chave.

esses 2 coringas armazenam os argumentos em objetos iteráveis, *args em tuplas e **kwargs em dicionários.

def foo(arg1, *args):
    print arg1
    print args
 
>>> foo('valor 1', 'valor 3', 'valor 4')
valor 1
('valor 3','valor 4')

def foo(arg1, **kargs):
    print arg1
    print kwargs
 
>>> foo('valor 1', arg2='valor 2', arg3='valor 3')
valor 1
{'arg2': 'valor 2', 'arg3': 'valor3'}

def foo(*args **kargs):
    print arg
    print kwargs
 
>>> foo('valor 1', 'valor 2' arg3='valor 3', arg4='valor 4')
('valor 1', 'valor 2')
{'arg2': 'valor 2', 'arg3': 'valor3'}

 
Com isso temos mais flexibilidade para trabalhar os argumentos, mesmo não sabendo quantos e quais argumentos a função irá receber.
 

Geralmente quando se trabalha ativamente com uma linguagem, e com muitos projetos, gerenciar seu ambiente de desenvolvimento se torna tarefa complicada.

Não só pela quantidade de dependências que um projeto pode ter, mas pelo simples fato de que o projetoA e projetoB podem usar uma mesma dependência, mas em versões diferentes.

Pensando nesse cenário, vou falar um pouco de uma ferramenta que pode ajudar muito na organização de nosso ambiente de trabalho, o virtualenv.

O virtualenv

O conceito do virtualenv é relativamente simples. Com ele podemos criar “ambientes virtuais” para cada um de nossos projetos, assim cada projeto terá um ambiente dedicado para a instalação de suas dependências sem influenciar os demais projetos =)

No final das contas, cada projeto terá um espécie de sandbox.

Instalando o virtualenv

Antes de mais nada, por questões organizacionais criaremos uma pasta para abrigar nossos ambientes virtuais. Eu utilizo a pasta ~/.virtualenvs , mas isso não é regra, qualquer pasta pode ser utilizada desde que se tenha permissão de escrita nela, é claro :P

$ mkdir ~/.virtualenvs

supondo que você tenha o pip instalado(veja aqui como instalar), o virtualenv pode ser instalado a partir do comando:

$ pip install virtualenv

Criando ambientes virtuais

com o virtualenv instalado, podemos criar nossos ambientes virtuais facilmente a partir do comando:

$ virtualenv ~/.virtualenvs/meu_ambiente

será criada uma pasta chamada “meu_ambiente” na sua pasta de ambientes ~/.virtualenvs com a seguinte estrutura

bin: Onde ficam os binários(sério?) do python e os scripts de ativação do ambiente virtual.

include: Onde ficam os headers do python, necessários para compilar extensões escritas em C.

lib: Onde ficam as bibliotecas/módulos do python

Dica: quando for criar o ambiente virtual, é aconselhável usar o parâmetro “–no-site-packages” para criar um ambiente “limpo”, ou seja, seu novo ambiente não herdará nenhum pacote já instalado no seu ambiente atual.

$ virtualenv --no-site-packages ~/.virtualenvs/meu_ambiente

Ativando seu ambiente

uma vez criado seu ambiente virtual, para ativá-lo basta executar o seguinte comando:

$ source ~/.virtualenvs/meu_ambiente/bin/activate

Pronto! Se você estiver utilizando bash(não testei com outros) , no início do prompt aparecerá o nome do seu ambiente entre parênteses, indicando que ele está ativo.

(meu_ambiente)seu_usuario@hostname:~$

Agora você pode utilizar o pip, que já vem com o novo ambiente, para instalar todas as depenências do seu projeto =)

Desativando seu ambiente

A qualquer momento você pode desativar seu ambiente virtual executando o seguinte comando:

$ deactivate

imediatamente após o comando, o nome do seu ambiente virtual que antes aparecia no começo do prompt não aparecerá mais.

Para saber mais, acesse a documentação do virtualenv =)

No próximo post, vou falar um pouco sobre o virtualenvwrapper, que agrega um conjunto de funcionalidades extras ao virtualenv e deixa papel de gerenciar seus ambientes virtuais ainda mais fácil =)

O que é PIP?

PIP significa “PIP Install Packages” e veio para substituir o easy_install, ele usa os mesmos princípios que o easy_install, ou seja, todos os pacotes que são instaláveis pelo easy_install também são instaláveis através do PIP.

Ele tráz algumas melhoras significativas em relação a seu antecessor:

• Todos os pacotes são baixados antes da instalação
• O resultado apresentado no console é realmente útil
• Suporte nativo a sistemas de controle de versão(SVN, Git, Mercurial e Bazaar)
• Desinstalação de pacotes
• Possibilidade de gerar lista de dependências

O PIP veio para se tornar um gerenciador de pacotes completo para python.

Instalando

Você pode instalar o PIP baixando sua versão de desenvolvimento aqui, ou simplesmente instalando através do easy_install =)

easy_install pip

Comandos do PIP

Podemos utilizar o comando pip para diversas tarefas.

Instalar pacotes

$ pip install package

Listar Pacotes instalados

$ pip freeze

Atualizar pacote

$ pip install -U  package

Remover pacote

$ pip uninstall package

Buscar pacotes

$ pip search package

Arquivo de dependência

PIP te dá a opção de ler um arquivo de depêndencias para baixar os pacotes. Isso é ótimo, uma vez que um projeto pode conter dúzias de dependências e cada dependência possuir uma versão específica para o funcionamento desejado do projeto.

Arquivos de depêndencia te dão o poder de gerar um set de pacotes  para um ambiente de desenvolvimento específico, e se utilizado com virtualenv e virtualenv wrapper te facilitam muito a vida =)

Mais pra frente vou postar sobre virtualenv e virtualenv wrapper.

Um arquivo de dependência segue o seguinte formato:

Framework==1.0.5
 
Library>=0.7

Traduzindo:

MinhaAplicacao tem as seguintes dependências

• Framework na versão 1.0.5
• Library na versão 0.7 ou superior

Também é possível referenciar sistemas de controle de versão no arquivo de dependência, exemplo

Framework==1.0.5
 
Library>=0.7
 
-e svn+http://myrepo/svn/package#egg=package

A dependência começa com a diretiva “-e” que significa editable, ou seja, é um pacote editável. Depois temos o sistema de controle de versão, que pode ser svn+, git+, hg+ ou bzr+, logo após temos a url e ainda temos a posibilidade de colocar a hash “#egg+package” para o PIP saber o que esperar da url.

Autocomplete

Muita gente não sabe disso, mas o PIP vem com suporte a autocomplete nativo para os interpretadores de comando bash e zsh, com esta função ativada, é possivel completar os comandos apertando “tab”.

Para ativar o autocomplete  é preciso copiar o seguinte shell script para o arquivo de inicialização do seu interpretador de comandos

bash: (.profile)

$ pip completion --bash >> ~/.profile

zsh: (.zprofile)

$ pip completion --zsh >> ~/.zprofile

Ou simplesmente  utilizando o comando “eval”:

eval "`pip completion --bash`"

Para saber mais sobre o PIP, basta acessar o site.

Agora que sabemos o que são eggs e como instalá-los, vou explicar como criamos um egg =)

Cenário:

Vamos tomar um exemplo prático para ilustrar a criação desse egg. Eu tenho uma lib chamada uweather que nada mais é que um parser que gera dados sobre previsão do tempo do site weather.com. E ele está na seguinte estrutura de arquivos:

README

uweather

examples

setup.py

Onde README é o arquivo de leitura, uweather onde ficam os arquivos da lib, examples onde ficam os exemplos(dããã)  e setup.py…. hmmmm setup.py?

Criando o egg:

o arquivo setup.py é justamente o responsável pelo empacotamento e meta-informações da sua lib, vamos ver a estrutura básica desse arquivo:

setup(
    name ='nome da lib',
    version='0.1',
    description='descricao da sua lib',
    author='seu nome',
    author_email='seu@email.com',
    url='http://seu.site/lib',
    packages=['nome_do_pacote'])
    long_description="""\
        descricao completa sobre sua lib
    """,
    classifiers=[
        "lista de classificadores da sua lib",
    ],
    keywords='palavras chave separadas por espaço',
    license='tipo da licensa ex: GPL',
    install_requires=[
        'setuptools',
    ],
 )

A lista de classificadores pode ser encontrada aqui.

Esta é a estrutura do setup.py, ela contém meta-informações como nome, versão, informações do autor, classificadores, palavras chave, dependências e outras informações que serão utilizadas quando alguém fizer uma busca pelo easy_install ou pip.

Agora para criar o egg, basta executar o seguinte comando

python setup.py bdist_egg

Ele irá criar o pacote egg em uma pasta chamada ‘dist’ no formato:

nome_do_pacote-versao-versao_python

algo como:

nome_do_pacote-0.1-py2.6

(supondo que a versão do python instalada é a 2.6)

Se você descompactar o egg, vai ver que o conteúdo será o da pasta da lib, no caso ‘uweather’ mais  uma nova pasta chamada ‘EGG_INFO’ que contém as meta-informações de sua lib.

Também serão incluídos os arquivos .pyc, que  são os arquivos .py compilados, os binários.

Com isso, seu arquivo egg agora pode ser distrubuído =)

Distribuindo o seu egg:

Você pode distribuir seu pacote do jeito que bem entender, mas é recomendável utilizar o PyPi, que é o repositório oficial de pacotes python.

Para poder fazer um upload do seu pacote no PyPi, é necessaria a criação de uma conta no site e configurar o arquivo .pypirc no seu diretório HOME.

O arquivo .pypirc segue o seguinte padrão:

[pypirc]
servers = pypi
[server-login]
username:seu_username
password:seu_password

Após feito, é possivel gerar o egg e fazer upload do mesmo pelo comando:

python setup.py bdist_egg upload --identity="Seu Nome" --sign --quiet

Pronto! Agora você tem um pacote egg gerado e indexado no repositório oficial de pacotes python =)

O que são python eggs?

Python eggs nada mais são que uma forma de  se distribuir pacotes python, bem similar a um RPM ou até mesmo a um JAR de Java. Uma vez gerado o egg, o mesmo pode ser repassado e fácilmente instalado através do comando ‘easy_install’ que faz parte do pacote setup tools.

Onde acho os eggs?

Você pode achar eggs de diversas maneiras, como no site do autor por exemplo. Mas a forma mais fácil e rápida de se achar um egg é utilizando o repositório oficial de eggs do python, o PyPi(Python Package Index), também chamado de Cheeseshop(quem sabe a história do python ou assistia monty python vai enteder =D ). Para buscar e instalar eggs, você pode usar o próprio easy_install:

instalando o egg:

easy_install package.egg

utilizando uma URL:

 easy_install http://www.example.com/package.egg

ou simplesmente passando o nome do pacoce, o easy_install irá procurar no repositório e instalar a versão mais atual:

easy_install package

Você pode também baixar uma versão específica:

easy_install package==1.4.0

Alternativas

O easy_install também possúi uma alternativa, o PIP. Ele possúi algumas funcionalidades extras, como instalar dependências, instalar direto de sistemas de controle de versão como Git, SVN e Mercurial, entre outras.

É basicamente é isso, mais pra frente vou escrever um post de como criar eggs e mandar para o PyPi. =)

Aprenda Python e Django na prática!
Você deseja desen­volver sites e aplica­tivos web com agili­dade e efi­ciên­cia? Django é a fer­ra­menta para você!

Django é um frame­work web escrito em Python, que pos­si­bilita o desen­volvi­mento de sis­temas web de alta per­for­mance com elegân­cia e rapi­dez. Usado por mil­hares de sites no mundo inteiro, Django é desen­volvido por uma grande comu­nidade que tem como filosofia poten­cializar o desen­volve­dor, deixando você con­cen­trar os seus esforços na sua idéia.

Ficou inter­es­sado? Então garanta já a sua vaga no curso Wel­come to the Django.