Ambientes Virtuais

Um ambiente virtual é uma cópia privada do interpretador Python, na qual você pode instalar pacotes de forma privada, sem afetar o interpretador Python global instalado em seu sistema.

Quanto mais projetos você tiver, mais provável será que você trabalhe com diferentes versões do próprio Python, ou pelo menos diferentes versões de bibliotecas Python. Por isso, usamos ambientes virtuais.

Por exemplo, você sempre pode verificar a configuração do seu ambiente com:

$ pip freeze

Virtualenv

Instale o virtualev:
sudo pip install virtualenv

Crie um ambiente virtual:

$ virtualenv venv

Para começar a usar o ambiente virtual, ele precisa ser ativado:

$ source venv/bin/activate

Se você terminou de trabalhar no ambiente virtual no momento, pode desativá-lo:

$ deactivate

Para excluir um ambiente virtual, basta excluir sua pasta.

Virtualenvwrapper

Virtualenvwrapper fornece um conjunto de comandos e também coloca todos os seus ambientes virtuais em um só lugar.

Para instalá-lo, certifique-se de que o virtualenv já esteja instalado e:

$ pip install virtualenvwrapper

Adicione ao seu arquivo .bashrc:

export WORKON_HOME=$HOME/.virtualenvs
export PROJECT_HOME=$HOME/Devel
source /usr/local/bin/virtualenvwrapper.sh

Para criar um ambiente virtual:

$ mkvirtualenv test

Para verificar se está funcionando:

$ which python
$ pip freeze

Para trabalhar em um ambiente virtual:

$ workon test

Para desativar o ambiente:

$ deactivate

Para excluí-lo:

$ rmvirtualenv test

Por quê?

Porque agora podemos ter um arquivo com todos os requisitos do seu projeto e instalá-lo em qualquer lugar onde você configurar seu ambiente de trabalho com:

pip install -r requirements.txt

Depurando

pdb, o depurador Python:

Uma introdução ao pdb pode ser encontrada aqui .

Por exemplo, você pode usar a opção -i para executar um script e, em seguida, ele vai para uma sessão interativa com o interpretador Python:

$ python -i 

Outra maneira de depurar é definir rastreamentos dentro de seu código. Por exemplo, você pode escrever o seguinte snippet dentro da função que deseja inspecionar:

import pdb
pdb.set_trace() # where you want to start to debug

Ao executar a partir do console, alguns comandos úteis são:

(Pdb) list      <- show next 10 lines
(Pdb) p self    <- point  
(Pdb) n         <- next line
(Pdb) help
(Pdb) exit

Testes Unitários

Teste de unidade

• Pacote de teste padrão na biblioteca padrão Python.
• Os arquivos devem começar com test_ .
• Isolamento do teste : cada teste obtém um novo objeto de teste, a falha não interrompe os testes e os testes não afetam um ao outro.
• use em vez de Python para mostrar não apenas o valor com falha, mas também o valor real.self.assert...assert

import unittest

class BasicsTestCase(unittest.TestCase):

    def test_find_name(self):
        self.assertTrue(1 == 1)
        self.assertFalse(1 == 2)

if __name__ == '__main__':
    unittest.main()

Correr com:

$ python -m unittest <filename>

• Boas práticas: use uma classe de caso de teste principal, use métodos de configuração e desmontagem.

Scripting

Você pode adicionar um comando personalizado a um script em seu aplicativo, como manage.py :

@manager.command
def test():
    """Run the unit tests."""
    import unittest
    tests = unittest.TestLoader().discover('tests')
    unittest.TextTestRunner(verbosity=2).run(tests)

Para correr:

$ python manage.py test

pytest

Para usar o pytest, você só precisa incluir uma função que começa com test_ em um arquivo que começa com test_ . Mais informações aqui .

Você instala com:

$ pip install pytest

Por exemplo, crie um arquivo com:

def func(x):
    return x + 1

def test_answer():
    assert func(3) == 5

E execute com:

$ py.test

Você também pode soltar isso no pdb :

$ py.test --pdb

Doctest

O teste é executado em tudo em docstrings:

'''
>>> 1 == 1
False
'''
if __name__ == '__main__':
    import doctest
    doctest.testmod()

teste de nariz

O Nose encontra todos os arquivos que começam com teste e são executados para você. Mais informações aqui .

# run tests over the directory
$ nosetest

Cobertura

As ferramentas de cobertura de código medem quanto do aplicativo é exercido por testes de unidade
e podem fornecer um relatório detalhado que indica quais partes do código do aplicativo
não estão sendo testadas. Para instalar a cobertura em Python:

$ pip install coverage

Para executar a partir da linha de comando:

$ coverage run file.py
$  coverage report -m

Finalmente, você pode criar uma versão de cobertura HTML:

$ coverage html

Scripting

Podemos integrar as métricas de cobertura a um arquivo manage.py em nosso aplicativo. Por exemplo:

#!/usr/bin/env python
import os
COV = None
if os.environ.get('FLASK_COVERAGE'):
     import coverage
     COV = coverage.coverage(branch=True, include='app/*')
     COV.start()
@manager.command
def test(coverage=False):
    """Run the unit tests."""
    if coverage and not os.environ.get('FLASK_COVERAGE'):
       import sys
       os.environ['FLASK_COVERAGE'] = '1'
       os.execvp(sys.executable, [sys.executable] + sys.argv)
   if COV:
      COV.stop()
      COV.save()
      print('Coverage Summary:')
      COV.report()
      basedir = os.path.abspath(os.path.dirname(__file__))
      covdir = os.path.join(basedir, 'tmp/coverage')
      COV.html_report(directory=covdir)
      print('HTML version: file://%s/index.html' % covdir)
      COV.erase()

Para correr:

$ python manage.py test --coverage

Unicode e estilo

Todas as strings são Unicode no Python 3. No entanto, no Python 2, existem muitos problemas com a conversão de UTF-8 e ASCII. Você pode usar o módulo codecs :

import codecs

Um exemplo de código antes:

with open("doc.txt", "r") as f:
     lines = [line.strip('n') for line in f]
     print lines

Agora, usando codecs:

with codecs.open("doc.txt", encoding='utf-8') as f:
     lines = [line.strip('n') for line in f]
     print lines

Finalmente, você deve saber que a convecção usada quando você escreve um código em Python é definida pelo PEP 8 (Python Enhancement Proposal 8) .

Para corrigir problemas de estilo, você pode usar o pep8ify .

–

Intérpretes

Agora, vamos falar sobre o interpretador: o ambiente de linha de comando para executar o código diretamente. O primeiro é o REPL (Read-Evaluate-Print Loop), que vem com a instalação do Python. Você pode usá-lo simplesmente digitando:

$ python

Uma segunda opção é o IPython , que permite fazer notebooks adequados para a web.

Finalmente, você pode usar o bpython , que tem uma ótima interface gráfica do usuário integrada com a documentação do Python.

Referências adicionais

• Boa conversa sobre testes de unidade em Python