Navegando em diretórios no Python

Para identificar o diretório atual (pwd):
    import os
    os.getcwd() # cwd = current working directory

Para mudar de diretório (cd):
    import os
    path = '/my/path/'
    os.chdir(path)

Para listar o conteúdo (ls):
    import os
    os.listdir() #retorna um objeto do tipo list (lista), claro!

Ambiente de desenvolvimento Python 3 no Jessie

Eu já tinha escrito sobre isso, mas o jeito que eu tinha criado o ambiente de desenvolvimento na minha máquina era muito trabalhoso e as versões atuais do Python (estou escrevendo em maio de 2015) tornaram a vida mais fácil.

1) Veja que versão de Python você tem instalada.
    Se for a versão 3.4 ou superior, está tudo certo.
    Se não for, instale o pacote python3.
         Digite: sudo apt-get install python3

2) Instale o pip do Python 3:
     sudo apt-get install python3-pip

3) Utilize o comando pip3 (e não pip) para instalar o virtualenv:
    Digite: sudo pip3 install virtualenv
    Repare no sudo! Queremos o virtualenv instalado para o computador como um todo e não só para nosso projeto, então temos que ter permissões para mexer na configuração geral do Python.

4) No diretório do seu projeto, crie o ambiente virtual (virtualenv):
     Digite: virtualenv env
     Chamei o diretório de env, então sua pasta ficaria algo assim:
                /qqcoisa/seuprojeto/env

5) Ative o seu ambiente virtual:
     Digite: . env/bin/activate
     Repare o ponto (.) e o espaço. Eles são importantes! Você pode trocar o ponto por source para ficar mais claro, se quiser.
     (Alternativa): source env/bin/activate
     Estou assumindo que você está na pasta do seu projeto, que chamei antes de /qqcoisa/seuprojeto/.

6) Pronto! Agora você já pode instalar módulos de python. Estou usando Python 3, então usarei também o pip3. Faço assim:
     Digite: pip3 install ipython
     Esse ipython é o primeiro módulo que gosto de instalar. Ele deixa o console do python mais amigável. Aí, ao invés de rodar "python" para iniciar a console, uso "ipython". Teste aí!

Abraços,
Otávio

Como criar um ambiente de desenvolvimento python no Debian

Estou me baseando na seguinte pergunta (e respostas) do StackOverflow para criar meu ambiente de desenvolvimento Python:

http://stackoverflow.com/questions/4324558/whats-the-proper-way-to-install-pip-virtualenv-and-distribute-for-python

1) Baixar o Virtualenv:
- Fui aqui: https://pypi.python.org/pypi/virtualenv#downloads
- Baixei a versão tar.gz
- A versão foi a 12.0.7, a mais recente no momento
- Para descompactar, rodei o seguinte:
   tar xvf virtualenv*

2) Escolher um lugar para o seu ambiente inicial
- O virtualenv cria um ambiente de desenvolvimento isolado. Não é exatamente uma máquina virtual, mas você pode imaginar que é algo parecido.
- No procedimento que estamos adotando, você vai criar um "ambiente zero". É um ambiente de desenvolvimento com as bibliotecas e módulos básicos dos quais você vai derivar ambientes específicos para cada projeto.
- Eu escolhi gravar o meu ambiente inicial em "~/py-env0"

3) Criar o seu ambiente inicial
- Estou usando o python 2.7.8, mas não deve haver diferença para o python 3.
- Rodei o seguinte comando:
python virtualenv.py ~/py-env0
- Eu estava no diretório onde descompactei o arquivo do virtualenv que baixei acima.

4) Instale o virtualenv no seu ambiente inicial:
~/py-env0/bin/pip install virtualenv*.tar.gz
ATUALIZAÇÃO (em 13/02/2015): Meu amigo Paulo Henrique me alertou que este passo é confuso. "Tem que executar o pip sobre o arquivo que eu já descompactei?". É isso mesmo! Se você tiver fé, confie em mim e rode assim mesmo. Se você precisar entender, corra para o fim do post (depois das referências) que eu explico.

5) Crie o ambiente de desenvolvimento do seu projeto:
~/py-env0/bin/virtualenv pasta_do_projeto/env

6) Ative o ambiente de desenvolvimento quando estiver trabalhando nele:
. pasta_do_projeto/env/bin/activate
Repare que o comando começa com um ponto e um espaço.  Isso é importante! Isso faz com que o comando seja executado no ambiente (shell) atual.
Na maioria dos sistemas (os que usam o bash), isso equivale a:
source pasta_do_projeto/env/bin/activate

7) Alguns módulos exigem o pacote python-dev:
sudo apt-get install python-dev

PERGUNTA BÔNUS: Você deve versionar o ambiente junto com o projeto?
RESPOSTA: Não. Ao invés disso, versione o arquivo requirements.txt gerado com o comando abaixo:
pip freeze

Para instalar os módulos listados no arquivo, use o seguinte:
pip install -r requirements.txt

Referências:
http://stackoverflow.com/questions/6590688/is-it-bad-to-have-my-virtualenv-directory-inside-my-git-repository
http://stackoverflow.com/questions/6812207/how-can-i-correctly-install-multiple-non-package-distribute-virtualenv-pip-ecosys
http://askubuntu.com/questions/232932/in-a-bash-script-what-does-a-dot-followed-by-a-space-and-then-a-path-mean

Bons projetos!

Abs.,
Otávio

----------------------------------------------------------------
ATUALIZAÇÃO (em 13/02/2015): Mas por quê?! Por que rodar o "pip virtualenv*.tar.gz" no passo 4 ??!!

Vou tentar explicar...

Antes de começar o tutorial, não havia nenhum virtualenv, nem pip, nem nada na sua máquina. Quando você executa o passo 3, você roda o virtualenv a partir do código fonte. Ali você está criando um primeiro ambiente (que chamei de ~/py-env0). Só que neste primeiro ambiente, pasme!, não há nenhum virtualenv instalado.

Ahn?

Sabe aquele filme "A Origem" em que as pessoas vivem dentro de um sonho de uma pessoa que está sonhando que está tendo outro sonho? É tipo isso.

No seu ambiente linux (A), não tem virtualenv nenhum instalado:

A (nenhum virtualenv aqui)

No passo 3 você cria o primeiro "sonho", um ambiente em ~/py-env0:

A (nenhum virtualenv aqui)
      B (~/py-env0, nenhum virtualenv aqui também)

Só que você está criando esse ~/py-env0 (B) justamente para poder ter uma base, um ponto de partida para criar outros ambientes. Então você precisa instalar o virtualenv neste ambiente B. É isso que você faz no passo 4:

A (sem virtualenv)
      B (~/py-env0, agora com virtualenv!)


no passo 5, você usa esse virtualenv recém-instalado em B para criar o seu ambiente de projeto (C):

A (nunca terá virtualenv)
      B (~/py-env0, o pai de todos os virtualenvs)
            C (projeto/env, o filho de B)

Neste ambiente C, depois de ativado (passo 6) você já pode dar "pip install qqcoisa" e instalar qualquer pacote. Pode até dar "pip install virtualenv" e instalar um virtualenv.

Peraí! Então eu poderia ter ativado o ambiente B e usado "pip install virtualenv" lá no passo 4? Sim, jovem gafanhoto. Só que o pip teria baixado de novo um pacote que você tinha acabado de baixar e estava bem à mão, compactado naquele arquivo .tar.gz. Sem nem precisar ativar nada...

É, eu sei... Não faz nenhum sentido... Respire e beba um copo d'água antes de ler o próximo parágrafo.

Se você está batendo cabeça e não conseguiu fazer nada disso, não se desespere. O python 2.7.9 já vem com o pip. Você pode dar um "pip install virtualenv" e ser feliz assim que instalar. Uma hora dessas eu experimento e conto aqui como é.

Abraços,
Otávio

Como instalar um ambiente de desenvolvimento Python no Windows

Hoje eu fui desenvolver com Python no meu notebook com Windows 8 e descobri que não tinha nem pip, nem virtualenv, nem mesmo o setuptools instalado... E agora, José? Como é que você prepara uma máquina no Windows para trabalhar com Django, Flask, suds e outras tantas coisas legais que só o Python pode oferecer?

Eu tentei várias coisas, baixei scripts .py para rodar diretamente, instalei programas e mais programas dentro e fora do Cygwin, versões 64-bit e 32-bit de uma infinidade de pacotes e nada parecia dar certo. Então, resolvi começar de novo, explicando para vocês meu procedimento.

Primeiro de tudo, você precisa do Python, lógico. A versão mais atual é a 3.3, mas muita gente ainda usa a 2.7. Eu sou uma dessas pessoas. Estou fazendo um curso de "Introdução à Ciência da Computação e Programação com Python" no site edx.org e eles usam a versão 2.7.

Instalar o Python é fácil. Ele tem um instalador para Windows e tudo mais... Ainda assim, você precisa atentar para as variáveis de ambiente. Você deve ajustar o seu PATH. Algo assim:

PATH=%PATH%;C:\Python27;C:\Python27\Scripts
Agora, sim, você pode instalar o setuptools, que vai te permitir instalar o virtualenv, o pip e os demais utilitários do Python que vão te permitir instalar as bibliotecas e tudo mais.

Para instalar o setuptools, segui as orientações do site oficial, ou seja, usei o PowerShell. Eu nunca tinha usado isso, não sabia nem o que era. Aparentemente, é só mais um console, como o cmd e o cygwin. Apertei o botão do windows, escrevi "PowerShell", cliquei com o botão direito do mouse e pedi para Executar como Administrador. No console que se abriu, rodei o comando a seguir:

(Invoke-WebRequest https://bootstrap.pypa.io/ez_setup.py).Content | python -

Parece mágica, mas na verdade o que isso faz é baixar o arquivo ez_setup.py (tipo um wget ou curl) e depois executa ele com o python.

Eu já tinha colocado ali em cima a pasta Python27\Scripts no Path, mas é agora que isso se torna útil. O instalador do setuptools grava ali o arquivo easy_install.exe. Se você não incluiu a pasta no Path, inclua agora. Depois, saia do PowerShell e abra um console com permissões de administrador. Eu fiz assim: (Windows) cmd (botão direito) Executar como Administrador.

Dentro desse console de administrador é que nós vamos executar o easy_install para instalar o pip, assim:

easy_install pip

E agora, com o pip, você pode instalar o virtualenv:

pip install virtualenv

O virtualenv no Windows funciona um pouco diferente do Linux. Para ativar e desativar o ambiente virtual, ele grava arquivos .bat no diretório Scripts. Então para usar um novo ambiente virtualenv você faria:

virtualenv venv
cd venv
Scripts/activate.bat

Em algumas de minhas primeiras tentativas, este ambiente não funcionava e o erro não era claro, mas quando finalmente consegui uma mensagem legível descobri que o problema era de permissões. Bastou executar os comandos em um console como administrador que isso resolveu o problema. Não é a melhor solução, mas deu certo na falta de algo melhor.

Se tiverem outras sugestões de boas práticas, sou todo ouvidos. Sempre trabalhei com Java e sempre com outras pessoas (ou equipes) que cuidavam da infraestrutura, então tudo isso é meio novidade para mim.

ATUALIZAÇÃO (em 18/06/2014): E o git? Pois é, instalar as ferramentas Python sem usar o Cygwin tem essa desvantagem de te deixar fora do ambiente Unix-like e sem essa ferramenta essencial... Mas se você instalar o Git para Windows,  pode optar por utilizá-lo no cmd (console normal do Windows) e por permitir que ele instale também outros comandos Unix nesse ambiente, como o ls, ssh, etc. Aí, sim, você nem vai sentir tanta falta do Cygwin...

Para instalar alguns pacotes, como o pandas, você vai precisar instalar no Windows o Visual C++ 2008 Express Edition. Há algumas perguntas e respostas no StackOverflow sobre isso.

Abs.,
Otávio

Como acessar os Dados Abertos da Câmara dos Deputados usando Python

A Câmara dos Deputados tem um serviço muito interessante chamado Dados Abertos. A ideia é que qualquer cidadão tenha acesso a informações sobre Deputados e sobre a tramitação de propostas de leis. Você não precisa se cadastrar nem nada, basta saber montar suas consultas. E foi para ensinar a fazê-lo que resolvi escrever este post.

O serviço Dados Abertos é um WebService. Um webservice é como se fosse um sistema de informação sem telas. Você pode consultar o que quiser, mas não tem um formulário para preencher o que quer. E o retorno do sistema não é uma planilha bonitinha nem um relatório em PDF, é só um monte de informação que você mesmo tem que tratar.

Eu resolvi usar python para fazer minhas pesquisas. Eu estou usando a biblioteca suds, que é um cliente leve de webservices para python.

Para instalar no linux, usei:

$  sudo pip install suds

Para poder fazer isso, você tem que ter o python e o pip instalados.

Depois você faz o seguinte:

$ python

>>> from suds.client import Client  #importa o cliente

Aí você define a URL:

>>> url = 'http://www.camara.gov.br/SitCamaraWS/Proposicoes.asmx?wsdl'

e acessa:

>>> client = Client(url)

Pronto! Você já tem acesso ao WebService. Agora você pode olhar os métodos disponíveis de forma já tratada pelo suds:

>>> print (client)

Um dos métodos que ele mostra como disponíveis é esse:
     ListarSiglasTipoProposicao()

Para consumí-lo, você faz o seguinte:

>>> resultado = client.service.ListarSiglasTipoProposicao()

O retorno é um xml composto pela tag <siglas> que possui vários objetos <sigla> com atributos "tipoSigla", "descricao" e outros.

Se quiser ver o "tipoSigla" do terceiro item, você pode acessá-lo assim:

>>> resultado['siglas']['sigla'][2]._tipoSigla

E o retorno vai ser: 

ANEXO

Agora digamos que você quer saber quantas medidas provisórias estão em tramitação no Congresso Nacional neste momento...

Você poderia utilizar o método ListarProposicoes. Nossa chamada "print client" mostra este método da seguinte forma:

Methods (11):
            ListarProposicoes(xs:string sigla, xs:string numero, xs:string ano, xs:string datApresentacaoIni, xs:string datApresentacaoFim, xs:string idTipoAutor, xs:string parteNomeAutor, xs:string siglaPartidoAutor, xs:string siglaUFAutor, xs:string generoAutor, xs:string codEstado, xs:string codOrgaoEstado, xs:string emTramitacao, )

Olhando a documentação do método, você vai ver que alguns campos são obrigatórios. Um deles é o ano, infelizmente. Então, para descobrir quantas medidas provisórias (de qualquer ano) estão em tramitação no Congresso, você tem que fazer várias chamadas como esta:

>>> resultado = client.service.ListarProposicoes('MPV', None, 2014, None, None, None, None, None, None, None, None, None, 1)

O 'MPV' no começo significa Medida Provisória e o 1 no final indica que a proposição está tramitando. Para ver quantas deram você usa o seguinte comando:

>>> len(resultado['proposicoes']['proposicao'])

Se quiser ver vários anos, pode executar o seguinte:

>>> for a in range(2005,2015):
...    resultado = client.service.ListarProposicoes('MPV', None, a, None, None, None, None, None, None, None, None, None, 1)
...    print(str(a) + ': ' + str(len(resultado['proposicoes']['proposicao'])))
...

Para minha surpresa, no momento em que fiz a consulta, havia 12 proposições do tipo Medida Provisória de 2014, e dezenas de outras de outros anos. Na verdade, como vocês podem ver em outra consulta, quase todas as situações de proposições são consideradas "Ativas", inclusive "Retirado pelo Autor", "Perdeu a Eficácia", "Enviada ao Arquivo" e "Arquivada"... Acho que terei que montar meu próprio conceito de "Ativa". Conto para vocês depois....

Abs.,Otávio