Ferramentas úteis que te podem ajudar a desenvolver código Python do Exercism na tua própria máquina.
Esta é uma coleção de ferramentas populares na nossa comunidade.
Não pretende ser prescritiva nem exaustiva.
Achamos que estas ferramentas fazem bem o seu trabalho, mas há certamente outras igualmente boas.
Se tiveres uma sugestão de editor, IDE, ferramenta ou plug-in, incentivamos-te a acrescentá-la a este documento no GitHub.
Antes de começares a explorar, certifica-te de que tens uma versão recente do Python instalada.
A plataforma web do Exercism suporta atualmente o Python 3.10 - 3.13.5 (exercícios e testes) e o Python 3.13.5 (ferramentas).
O nosso test runner online usa atualmente o pytest 8.4.0 e o pytest-subtests 0.14.2.
O nosso analisador online usa o pylint 4.0.4.
Usar versões diferentes de Python, pytest ou pylint localmente pode dar-te resultados diferentes dos do site.
Para mais informações, consulta Instalar o Python localmente.
Ambientes virtuais
Os ambientes virtuais do Python oferecem isolamento leve do runtime e dos pacotes.
Podem ajudar-te a organizar os teus projetos, mantendo os pacotes Python que instalas agrupados dentro do diretório de um ambiente específico.
Ambientes diferentes podem conter versões diferentes do runtime do Python, juntamente com quaisquer dependências do projeto ou de bibliotecas.
Isto ajuda a evitar bugs e incompatibilidades causadas por atualizar uma biblioteca num projeto que "quebra" uma dependência noutro.
Há hoje muitas ferramentas de ambiente virtual e ferramentas semelhantes a ambientes virtuais, e um movimento crescente para usar metadados de script inline, dev containers ou docker em vez de ambientes virtuais.
É importante experimentar estratégias diferentes e encontrar uma que se adeque ao teu estilo de desenvolvimento e às necessidades do teu projeto.
Não partas do princípio de que as estratégias aqui apresentadas servem para todos os casos ou de que são as tuas únicas opções.
Para uma visão mais geral de ferramentas que não são abordadas aqui, dá uma vista de olhos a este artigo de blogue do Bas Nijholt e mantém-te curioso.
Vamos abordar aqui três grandes ferramentas de ambiente virtual: a venv da biblioteca padrão do Python, o conda env de terceiros, que usa o gestor de pacotes conda e (normalmente) a distribuição Anaconda do Python, e o uv, um substituto de terceiros para o pip + venv.
As três são bastante simples de usar e/ou instalar.
Além disso, o PyEnv, o Poetry e o virtualenvwrapper são ferramentas que te podem ajudar a gerir várias versões do Python e vários ambientes Python na mesma máquina.
Para criar um ambiente virtual com o venv, usa cd para ir até ao diretório onde queres guardar os teus ambientes.
Deve ser um diretório separado do código do teu projeto e que não vais colocar no controlo de versões.
De seguida, executa o comando venv com o nome de uma pasta onde queres guardar este ambiente em particular.
A convenção habitual é chamar a essa pasta <project-name-here>_venv:
Windows
PS C:\Users\foobar> py -m venv {name_of_virtualenv}
Para ativar o ambiente virtual, executa o seguinte comando:
PS> .\{name_of_virtual_env}\Scripts\activate.bat
(venv) PS> _
Linux/MacOS
$ python3 -m venv {name_of_virtualenv}
created virtual environment ... in 8568ms
Para ativar o ambiente virtual, executa o seguinte comando:
$ source {name_of_virtual_env}/bin/activate
(venv) $ _
Depois de ativares um venv, podes executar comandos pip para instalar pacotes "dentro" do ambiente.
Os pacotes instalados ficam associados à versão do Python do venv e localizam-se dentro de {name_of_virtual_env}/Lib.
Podes desativar um ambiente virtual executando o script deactivate, que se encontra no mesmo diretório que o activate.
A versão mais recente do conda pode ser instalada através do miniconda.
Este guia rápido do conda é muito útil, tal como a documentação do conda.
Criado originalmente como gestor de pacotes Python para a popular Anaconda distribution de "Python científico", o conda foi mais tarde generalizado e ampliado.
Os ambientes do conda são semelhantes aos venv, com a diferença principal de que o conda pode criar ambientes virtuais e instalar pacotes para muitas outras linguagens de programação, além do Python.
As linguagens suportadas pelo conda incluem R, JavaScript, Ruby, Fortran, C/C++, Scala, Java e muitas mais.
Para uma comparação entre os comandos do conda e do venv, consulta a referência de comandos do conda.
MacOS/Linux
Para criar um ambiente conda, escreve o seguinte, substituindo {name of environment} pelo nome que escolheres e python={version} pela versão do Python que quiseres.
Podes acrescentar a seguir quaisquer pacotes adicionais que queiras instalar dentro do ambiente:
$ conda create --name {name of environment} python={version} "pytest>6.0" pylint
...
## Package Plan ##
environment location: /usr/local/anaconda3/envs/test_env
added / updated specs:
- pylint
- pytest[version='>6']
- python=3.10
The following packages will be downloaded:
package | build
---------------------------|-----------------
astroid-2.11.1 | py310h2ec42d9_0 364 KB conda-forge
dill-0.3.4 | pyhd8ed1ab_0 62 KB conda-forge
lazy-object-proxy-1.7.1 | py310he24745e_0 32 KB conda-forge
....
additional packages here
....
------------------------------------------------------------
Total: 21.8 MB
Proceed ([y]/n)? y
Preparing transaction: done
Verifying transaction: done
Executing transaction: done
#
# To activate this environment, use
#
# $ conda activate test_env
#
# To deactivate an active environment, use
#
# $ conda deactivate
Windows
Criar um ambiente conda no Windows usa os mesmos comandos gerais que no Linux/MacOS.
No entanto, recomenda-se que uses os prompts cmd ou powershell do Anaconda em vez de adicionares o conda ao teu path:
(base) PS C:\Users\foobar> conda create --name {name_of_environment} python={version} "pytest>6" pylint
...
Collecting package metadata (current_repodata.json): done
Solving environment: done
## Package Plan ##
environment location: C:\ProgramData\Anaconda3\envs\test_env
added / updated specs:
- pylint
- pytest[version='>6']
- python=3.10
The following packages will be downloaded:
package | build
---------------------------|-----------------
astroid-2.11.1 | py310h5588dad_0 364 KB conda-forge
attrs-21.4.0 | pyhd8ed1ab_0 49 KB conda-forge
bzip2-1.0.8 | h8ffe710_4 149 KB conda-forge
...
additional packages here
...
------------------------------------------------------------
Total: 37.5 MB
Proceed ([y]/n)? y
...
Preparing transaction: done
Verifying transaction: done
Executing transaction: done
#
# To activate this environment, use
#
# $ conda activate test_env
#
# To deactivate an active environment, use
#
# $ conda deactivate
Trabalhar em projetos com o uv: uv
O uv é uma ferramenta de gestão de pacotes e de projetos Python da Astral, escrita em Rust.
Foi concebido para substituir o pip, o venv, o poetry e outras ferramentas de gestão de pacotes e dependências do Python.
Ao contrário do Conda ou do Mamba, o uv é especializado apenas no Python.
No entanto, o uv suporta a compilação de módulos de extensão do Python escritos noutras linguagens, como o Fortran.
A Astral é também a criadora do popular linter Ruff e do TY, um verificador estático de tipos para as anotações de tipo do Python, ambos escritos em Rust.
Em vez de entrar em detalhes aqui, a documentação do UV é a tua melhor fonte para instalação e configuração.
Documentação e contexto: virtualenvwrapper.
O pacote virtualenvwrapper funciona por cima do venv para gerir todos os teus ambientes virtuais num único local.
Podes criar, copiar, eliminar e alternar entre ambientes com comandos ao estilo do Linux, como lsvirtualenv (para listar ambientes) e mkvirtualenv (para criar um ambiente).
Também te permite adicionar ferramentas de gestão adicionais através de extensões.
Podes até criar as tuas próprias extensões para a ferramenta com este tutorial.
PyEnv
O pyenv é o fork para Python das populares ferramentas rbenv/ruby-build, modificadas para o Python.
É essencialmente um conjunto de scripts e shims que permitem definir versões do Python tanto a nível global como por utilizador.
Procura seguir a tradição Unix de uma ferramenta discreta, de propósito único, que faz bem uma só coisa.
O pyenv e a documentação do pyenv estão disponíveis no GitHub.
Editores e IDEs
Visual Studio Code
O Visual Studio Code (VS Code) é um editor de código gratuito criado pela Microsoft.
Inclui um excelente suporte tanto para ambientes virtuais/conda como para o docker (através do plug-in docker) e pode ser ampliado com muitos plug-ins diferentes para testes, linting, formatação e desenvolvimento web.
Python para o VS Code
ID da extensão: ms-python.python
A extensão Python da Microsoft é a extensão Python oficial da Microsoft para o VS Code e uma instalação altamente recomendada.
Tem uma vasta gama de funcionalidades, incluindo gestão de ambientes, gestão de testes, linting e depuração.
A partir da versão mais recente, instalar a extensão MS Python também descarrega o pylance (um pacote popular para fazer linting e validar código Python) e o jupyter (para trabalhar com Jupyter Notebooks).
- Há um tutorial de configuração disponível aqui e a referência de definições é muito útil.
- Encontras informação sobre como configurar versões do Python e trabalhar com ambientes virtuais aqui.
- Encontras informação sobre como configurar e trabalhar com o unittest e o pytest no VS Code aqui.
PyCharm
O PyCharm é uma IDE (ambiente de desenvolvimento integrado) criada pela JetBrains.
Foi criado especificamente para Python e é popular entre profissionais.
Tal como o VS Code, pode ser ampliado com vários plug-ins, temas e formatadores pagos e gratuitos.
A versão paga também suporta desenvolvimento com Django, desenvolvimento com Docker e integração com bases de dados.
PyCharm e pytest
- Encontras os passos para configurar o pytest com o PyCharm aqui.
- O PyCharm usa
unittest por omissão, por isso tens de ter o pytest instalado no ambiente que estás a usar com o PyCharm (vê os documentos sobre o intérprete e o ambiente acima) e depois apontar o PyCharm para ele.
-
Executar testes diretamente a partir da interface gráfica é muito fácil, mas não te esqueças de dar uma boa vista de olhos aos parâmetros do pytest subjacentes, para que fique configurado a teu gosto.
- Encontras documentação geral sobre executar testes e depurar no PyCharm aqui.
- Encontras ferramentas e orientações adicionais de depuração aqui.
O Spyder é uma IDE de Python gratuita, de código aberto e multiplataforma, adaptada à comunidade científica.
É habitualmente incluído na distribuição Anaconda do Python, mas pode ser instalado de forma autónoma e usado com qualquer versão do Python.
Recomendamos uma instalação autónoma para garantir a máxima flexibilidade e evitar conflitos entre pacotes.
O Spyder suporta totalmente ambientes venv e conda.
Inclui um terminal interativo IPython integrado, um depurador interativo e um suporte rico para criar gráficos e explorar dados dentro do próprio editor.
A conclusão de código e o linting adicionais são fornecidos através do kite.
As integrações com Jupyter Notebooks e ferramentas de teste são fornecidas através de plug-ins desenvolvidos pela comunidade.
Também podes escrever os teus próprios plug-ins, usando a API do Spyder.
Emacs
O Emacs é um editor de texto gratuito, de código aberto e altamente personalizável, escrito em Lisp.
Há um excelente guia de instalação e configuração no Real Python.
- A Emacs Wiki também tem um bom guia sobre programação em Python com o Emacs.
- O Full Stack Python também reúne boa informação e ligações para começar com o Emacs.
Vim
O Vim é uma versão gratuita e "melhorada" do editor de texto vi, padrão do Unix.
Está disponível numa grande variedade de sistemas operativos e de variantes de Linux/Unix.
Há um excelente guia de instalação e configuração no Real Python, e guias rápidos úteis estão disponíveis em vimsheet, glump e rtorr.
Mesmo que decidas que editar código Python no vim não é para ti, recomenda-se que te familiarizes com um conjunto básico de comandos.
O vim ou o vi é muitas vezes o editor de texto "base" ou "predefinido" nas distribuições Linux e Unix e é o editor predefinido para as mensagens de commit do git (entre outras coisas) nesses sistemas.
É bem provável que acabes num sistema *nix a precisar de editar um ficheiro de configuração com apenas o vi disponível, por isso saber como sair do vim é (no mínimo) uma boa forma de autodefesa.
Spacemacs
O Spacemacs (repositório do GitHub) é uma distribuição gratuita do Emacs orientada pela comunidade, que combina funcionalidades do Emacs e do Vim.
- Encontras a documentação oficial aqui
- Este guia no opensource dá uma visão rápida das opções de instalação e configuração.
- A camada de Python do Spacemacs acrescenta funcionalidades de testes, linting, gestão de ambientes e formatação de código.
Sublime Text
O Sublime Text é um editor de texto pago para programação, criado pela Sublime HQ Pty Ltd.
É semelhante ao VS Code e ao Atom, com muitos pacotes e plug-ins para personalização.
Também podes desenvolver os teus próprios plug-ins para o editor, usando Python.
