O ecossistema do Python tradicionalmente dependeu de ferramentas como pip e virtualenv para gerenciar dependências e ambientes de projeto. Embora essas ferramentas tenham nos servido bem, frequentemente resultam em conflitos de dependências, gerenciamento manual de ambiente e configurações de projeto inconsistentes entre equipes.
O Python Poetry resolve esses desafios ao fornecer uma ferramenta moderna e unificada para gerenciamento de dependências e ambientes. Ela cuida de tudo, desde ambientes virtuais até publicação de pacotes, garantindo compilações reproduzíveis por meio de uma resolução inteligente de dependências.
Este guia irá te mostrar como usar o Poetry para otimizar seu fluxo de trabalho de desenvolvimento em Python e evitar dores de cabeça comuns de dependências.
Python Poetry vs. PIP
Poetry e pip servem para propósitos diferentes no ecossistema Python. Enquanto pip é principalmente um instalador de pacotes, o Poetry é uma ferramenta completa de gerenciamento de dependências e projetos. Aqui estão as principais diferenças:
1. Resolução de dependências
- Pip: Resolução de dependências simples e linear que pode levar a conflitos
- Poesia: Resolvedor avançado de dependências que previne conflitos antes da instalação
2. Gerenciamento de ambiente virtual
- Pip: Requer ferramentas separadas (virtualenv, venv) e ativação manual
- Poesia: Cria e gerencia automaticamente ambientes virtuais por projeto
3. Configuração do projeto
- Pip: Usa requirements.txt para dependências, setup.py para metadados do projeto
- Poesia: Único arquivo pyproject.toml para todas as necessidades de configuração
4. Arquivos de bloqueio
- Pip: Sem suporte integrado a arquivos de bloqueio
- Poesia: Gera poetry.lock para builds reproduzíveis em diversos ambientes
5. Publicação de pacotes
- Pip: Requer ferramentas adicionais (twine, setuptools) para publicação
- Poesia: Comandos integrados para construir e publicar pacotes
Quando usar Poetry em vez de pip
Escolha Poetry quando:
- Trabalhando em projetos de equipe que precisam de ambientes reprodutíveis
- Construindo pacotes que serão publicados no PyPI
- Gerenciando árvores de dependências complexas com possíveis conflitos
- Necessidade de gerenciamento automatizado de ambiente virtual
- Deseja uma única ferramenta para todo o fluxo de desenvolvimento
Mantenha-se com o pip quando:
- Trabalhando em scripts simples com dependências mínimas
- Aprendendo Python pela primeira vez
- Precisando instalar rapidamente um único pacote
- Trabalhando em ambientes onde a instalação do Poetry não é possível
- Manutenção de projetos legados que já estão configurados com pip
A regra geral é: use o Poetry para qualquer projeto que será compartilhado, implantado ou mantido a longo prazo. Use o pip para experimentos rápidos ou exercícios de aprendizado.
Dito isso, vamos mergulhar diretamente no uso do Poetry.
Configurando o Python Poetry
Você interagirá principalmente com o Poetry como uma ferramenta de linha de comando (CLI), então faz sentido instalá-lo no sistema em sua máquina. Esta seção aborda esse primeiro passo crucial e como definir algumas configurações padrão para o Poetry com base em suas necessidades.
Instalando o Poetry
Você pode instalar o Poetry usando um script de instalação oficial, que pode ser baixado e executado com um único comando.
Para macOS, Linux e WSL2:
$ curl -sSL https://install.python-poetry.org | sudo python3 -
Para Windows Powershell (execute com privilégios de administrador):
$ (Invoke-WebRequest -Uri https://install.python-poetry.org -UseBasicParsing).Content | py -
Se você estiver no Windows e tiver instalado o Python pela Microsoft Store (por algum motivo estranho), substitua py por python no comando acima.
Após a conclusão do script de instalação, ele imprime uma mensagem pedindo para adicionar o Poetry ao seu PATH para que o comando poetry esteja disponível em qualquer lugar.
Para macOS, Linux e WSL2, adicione a seguinte linha ao seu script de shell como .bashrc ou .zshrc:
$ export PATH="/Users/bexgboost/.local/bin:$PATH"
Para o Windows, você pode seguir as instruções de saída.
Em seguida, verifique sua instalação executando poetry --version.
Configurando o Poetry
A maior parte da configuração do Poetry diz respeito à forma como os ambientes virtuais são criados e como os pacotes são instalados. Você pode imprimir uma lista (quase) completa das configurações do Poetry com:
$ poetry config --list
A saída será semelhante ao exemplo abaixo:
cache-dir = "/Users/bexgboost/Library/Caches/pypoetry" experimental.system-git-client = false installer.max-workers = null installer.modern-installation = true installer.no-binary = null installer.parallel = true keyring.enabled = true solver.lazy-wheel = true virtualenvs.create = true virtualenvs.in-project = null virtualenvs.options.always-copy = false virtualenvs.options.no-pip = false virtualenvs.options.no-setuptools = false virtualenvs.options.system-site-packages = false virtualenvs.path = "{cache-dir}/virtualenvs" # /Users/bexgboost/Library/Caches/pypoetry/virtualenvs virtualenvs.prefer-active-python = false virtualenvs.prompt = "{project_name}-py{python_version}" warnings.export = true
Na primeira linha, vemos um caminho para o cache de Poetry. É usado principalmente para armazenar distribuições de pacotes baixados e ambientes virtuais. Quaisquer ambientes virtuais que você criar são armazenados aqui por padrão. Se desejar alterar isso, você pode executar o seguinte comando:
$ poetry config virtualenvs.path path/to/new/virtualenv/dir
Outra configuração importante é o número de núcleos usados durante as instalações. Por padrão, está definido como quatro, mas podemos torná-lo mais rápido utilizando todos os núcleos da CPU. Primeiro, descubra o número de núcleos da sua máquina executando os.cpu_count() no Interpretador Python. Em seguida, defina a saída:
$ poetry config installer.max-workers = 10
Uma configuração opcional é se criar ambientes virtuais no diretório de trabalho ou no cache. Isso é controlado via virtualenvs.in-project opção. Se você configurar como True, o diretório .venv será sempre criado no seu diretório de trabalho:
$ poetry config virtualenvs.in-project true
Criando um Novo Projeto com o Poetry
Vamos mergulhar nos principais passos para criar um novo projeto Poetry e entender seu arquivo de configuração principal.
Inicializando um novo projeto Poetry
O uso do Poetry geralmente começa com a criação de um novo projeto com o poetry new comando:
$ poetry new explore-poetry $ cd explore-poetry
O comando cria um explore-poetry diretório pré-populado com os seguintes arquivos e diretórios:
explore-poetry ├── pyproject.toml ├── README.md ├── explore-poetry │ └── __init__.py └── tests └── __init__.py
Esta estrutura de diretório segue as melhores práticas do Python:
pyproject.toml: O arquivo de configuração principal que define metadados do projeto e dependênciasREADME.md: Arquivo de documentação explicando o projetoexplore-poetry/: Diretório de código-fonte contendo o código do pacote principal, com__init__.pypara torná-lo um pacotetests/: Diretório para arquivos de teste, com__init__.pypara torná-lo um pacote (importável)
Entendendo o pyproject.toml
Aqui, o pyproject.toml exige atenção cuidadosa, pois é o único arquivo não vazio gerado pelo Poetry:
[tool.poetry] name = "explore-poetry" version = "0.1.0" description = "" authors = ["BexTuychiev <[email protected]>"] readme = "README.md" [tool.poetry.dependencies] python = "^3.8" [build-system] requires = ["poetry-core"] build-backend = "poetry.core.masonry.api"
Este arquivo orquestra seu projeto e suas dependências. Ele utiliza Tom’s Obvious, Minimal Language, que foi acordado como a linguagem de configuração padrão para pacotes Python em PEP 518.
Todos os pyproject.toml arquivos são divididos em seções chamadas tabelas usando colchetes como tool.poetry ou build-system. O Poetry usa essas tabelas para gerenciar dependências, requisitos de construção do projeto ou realizar outras tarefas.
Ao executar os comandos de Poesia delineados nas seções seguintes, opyproject.toml arquivo será atualizado automaticamente.
Trabalhando com Ambientes Virtuais no Poetry
Nesta seção, você descobrirá os detalhes de como gerenciar ambientes virtuais no Poetry depois de configurá-lo. Você aprenderá por que os ambientes virtuais são importantes, como o Poetry os manipula automaticamente e comandos básicos para manipulá-los, como criação, ativação e troca. Você também aprenderá como gerenciar as versões do Python com o Poetry.
Criando e ativando um ambiente virtual
Ao instalar o Poetry pela primeira vez, ele não vem com ambientes integrados, como evidenciado por uma saída em branco ao executar poetry env list:
$ poetry env list # sem saída
Mas assim que você começa a adicionar dependências (mais sobre isso depois) com poetry add nome-do-pacote, ele cria automaticamente um ambiente no diretório de cache para o projeto. Por exemplo, vamos tentar adicionar requests como uma dependência:
$ poetry add requests
Você deve receber uma saída semelhante à seguinte:
Creating virtualenv explore-poetry--I9GJYUn-py3.8 in /Users/bexgboost/Library/Caches/pypoetry/virtualenvs Using version ^2.32.3 for requests Updating dependencies Resolving dependencies... (2.5s) Package operations: 5 installs, 0 updates, 0 removals - Installing certifi (2024.8.30) - Installing charset-normalizer (3.4.0) - Installing idna (3.10) - Installing urllib3 (2.2.3) - Installing requests (2.32.3) Writing lock file
A primeira linha indica que a Poetry criou o ambiente no cache. As próximas linhas informam que as dependências para requests foram resolvidas com sucesso, e um arquivo de bloqueio é gerado (mais sobre isso depois, também).
Preste atenção ao nome do ambiente: explore-poetry--I9GJYUn-py3.8. O nome inclui o nome do diretório do projeto, seguido por um ID único e então a versão do Python que o ambiente está utilizando.
Da próxima vez que você adicionar uma dependência, o Poetry usará automaticamente este ambiente para instalar pacotes:
$ poetry add beautifulsoup4 Using version ^4.12.3 for beautifulsoup4 Updating dependencies Resolving dependencies... (1.1s) Package operations: 2 installs, 0 updates, 0 removals - Installing soupsieve (2.6) - Installing beautifulsoup4 (4.12.3) Writing lock file
Ao usar o Poetry, seu terminal não mostrará qual ambiente virtual do Poetry está ativo. Para ver esta informação, você precisa executar poetry env list:
$ poetry env list explore-poetry--I9GJYUn-py3.8 (Activated)
Para interagir com o ambiente Poetry ativo, você pode executar poetry shell:
$ poetry shell
O comando abre uma nova sessão shell dentro da atual, e você pode executar comandos como python ou pytest.
Por exemplo, para executar scripts Python:
$ poetry shell $ python script.py
Para executar frameworks de desenvolvimento como Streamlit:
# Dentro do shell $ streamlit run app.py
Em seguida, você pode sair do shell chamando exit.
Alternativamente, você pode executar comandos no shell Poetry sem precisar entrar nele com poetry run:
$ poetry run python script.py $ poetry run streamlit run app.py
Configurando a versão do Python
Ao executar poetry add ou poetry install, o Poetry usa automaticamente a versão do Python especificada no seu arquivo pyproject.toml. Para especificar uma versão diferente do Python, você pode executar o comando env use:
$ poetry env use python3.11
Observe que o Python 3.11 deve estar instalado no sistema em todo o seu computador para que o comando funcione.
Verifique se o Poetry está usando o ambiente com a nova versão do Python:
$ poetry env list explore-poetry--I9GJYUn-py3.11 (Activated) explore-poetry--I9GJYUn-py3.8
Observe como o novo ambiente é automaticamente vinculado ao nosso projeto (os IDs são os mesmos). Depois de configurar a sua versão do Python, você pode remover ambientes com outras versões para liberar espaço em disco:
$ poetry env remove python3.8
Ao excluir um ambiente, você só precisa especificar a versão do Python. Você também pode excluir todos os ambientes e começar do zero:
$ poetry env remove --all
Observe que --all tag remove todos os ambientes associados ao projeto atual, não ambientes de outros projetos.
Se você estiver trabalhando em projetos em equipe, é frequentemente melhor manter o ambiente virtual no diretório do projeto:
$ poetry config virtualenvs.in-project true
Este comando não terá efeito se você já tiver um ambiente para o projeto em cache. Para criar um ambiente local, remova todos os existentes do cache primeiro.
Isso cria uma pasta .venv no seu diretório de trabalho, que você deve adicionar ao seu arquivo .gitignore.
Gerenciando Dependências com Poetry
O gerenciamento de dependências é onde o Poetry se destaca. Ele fornece recursos abrangentes para especificar, instalar e gerenciar dependências para que você nunca encontre conflitos de dependência infernais.
Nesta seção, você aprenderá sobre adicionar e instalar dependências, criar grupos de dependências, sintaxe de especificação de dependências em pyproject.toml e arquivos de bloqueio.
Adicionando dependências no Poetry
Ao usar o Poetry, você usará o poetry add nome-do-pacote comando para instalar pacotes do PyPI em vez de pip install. Isso traz alguns benefícios:
- Adiciona automaticamente o pacote ao
pyproject.tomlcom a restrição de versão correta - Atualiza o arquivo de bloqueio para garantir builds reproduzíveis
- Resolve dependências para evitar conflitos
- Instala o pacote e todas as suas dependências no ambiente virtual
Por exemplo, vamos primeiro adicionar o Numpy como uma dependência:
$ poetry add numpy
Imediatamente, você deve receber um conflito de resolução de dependência que diz que a versão do Numpy que está sendo instalada não é compatível com a sua versão do Python. O motivo é que quando mudamos para o ambiente Python 3.11, não atualizamos o arquivo pyproject.toml agora, ele está assim:
[tool.poetry.dependencies] python = "^3.8" requests = "^2.32.3" beautifulsoup4 = "^4.12.3"
O símbolo de circunflexo ^ é usado para indicar que nosso explore-poetry projeto é compatível com qualquer versão do Python até o Python 4, mas a faixa de versão do Numpy suporta apenas versões do Python entre 3.8 e 3.12, que é uma faixa mais estreita. O erro de conflito decorre desse fato.
Portanto, para corrigir o erro, você deve atualizar a faixa de versão do Python para o seguinte:
python = ">=3.8, <3.12"
Depois de fazer essa alteração, poetry add numpy comando deve funcionar como esperado.
Você acabou de observar uma das melhores características do Poetry — detectar conflitos de versão antes de instalar quaisquer pacotes, em vez de informá-lo sobre incompatibilidades de versão posteriormente, como o pip.
A sintaxe para especificar versões de dependências
A poesia usa uma sintaxe poderosa para especificar uma ampla gama de versões para a melhor sincronização entre dependências. Aqui estão os símbolos mais frequentemente usados:
- Circunflexo (^): Permite atualizações de correção e menores, mas não de maior. Exemplo:
^1.2.3permite atualizações de 1.2.3 a 1.9.9, mas não de 2.0.0. - Til (~): Permite apenas atualizações de correção. Exemplo:
~1.2.3permite atualizações de 1.2.3 a 1.2.9, mas não de 1.3.0. - Versão exata: Especifica o número da versão exata. Exemplo:
1.2.3permite apenas a versão 1.2.3 - Maior que (>): Permite qualquer versão acima da especificada. Exemplo:
>1.2.3permite 1.2.4, 1.3.0, 2.0.0, etc. - Menor que (<): Permite qualquer versão abaixo da especificada. Exemplo:
<2.0.0permite qualquer versão abaixo de 2.0.0. - Maior ou igual (>=): Permite a versão especificada e acima. Exemplo:
>=1.2.3permite a versão 1.2.3 e qualquer versão superior. - Menor ou igual (<=): Permite a versão especificada e abaixo. Exemplo:
<=2.0.0permite a versão 2.0.0 e qualquer versão inferior. - Intervalo de versão: Combina restrições com vírgulas. Exemplo:
>=1.2.3,<2.0.0permite versões de 1.2.3 a 1.9.9 - Wildcard (*): Corresponde a qualquer versão. Exemplo:
1.2.*corresponde a qualquer versão que comece com 1.2
É claro, você pode combinar esses para atender às suas necessidades.
Criando grupos de dependências no Poetry
Em projetos complexos com muitos componentes em movimento, você frequentemente lidará com diferentes categorias de dependências.
Por exemplo, em um projeto de aprendizado de máquina, você frequentemente cria diferentes pipelines e componentes para ingestão de dados, limpeza de dados, engenharia de características, treinamento de modelo, implantação e monitoramento. Sem mencionar que você também precisa concluir a documentação e executar testes. Todos esses passos têm seu ecossistema de ferramentas, e misturar suas dependências infla o pacote de distribuição final.
Com o Poetry, você pode criar grupos de dependência com nomes arbitrários para que você possa instalá-los apenas quando necessário. Ou a melhor parte – os usuários do seu pacote também podem escolher instalar as partes que precisam.
$ poetry add --group ui streamlit plotly dash $ poetry add --group dev black flake8 isort mypy pylint
Os comandos acima criam dois grupos de dependências, ui e dev (se ainda não existirem), e duas sub-tabelas em pyproject.toml:
[tool.poetry.dependencies] python = "^3.11" requests = "^2.32.3" beautifulsoup4 = "^4.12.3" numpy = "^2.1.3" [tool.poetry.group.ui.dependencies] streamlit = "^1.39.0" plotly = "^5.24.1" dash = "^2.18.2" [tool.poetry.group.dev.dependencies] black = "^24.10.0" flake8 = "^7.1.1" isort = "^5.13.2" mypy = "^1.13.0" pylint = "^3.3.1"
Mesmo que os grupos de dependência sejam separados, eles ainda são resolvidos uns contra os outros. Em outras palavras, se houver uma dev dependência conflitante com um pacote em ui, o Poetry não executará a instalação.
Em alguns casos, você pode criar grupos de dependências opcionais ou tornar grupos existentes opcionais para que não sejam instalados por padrão quando um usuário recria o ambiente do seu projeto. Para fazer isso, você precisa criar uma nova sub-tabela no arquivo pyproject.toml. Por exemplo, vamos tornar o grupo ui opcional abaixo:
[tool.poetry.group.ui] optional = true [tool.poetry.group.ui.dependencies] streamlit = "^1.39.0" plotly = "^5.24.1" dash = "^2.18.2"
Isso é feito definindo o opcional parâmetro para true antes de declarar as dependências do grupo.
Reproduzindo um projeto Poetry com o arquivo poetry.lock
Se alguém clonar seu repositório GitHub contendo um projeto Poetry, eles podem recriar uma cópia perfeita do ambiente virtual para o seu projeto executando um único comando: poetry install.
O comando install utiliza o arquivo mais abrangente poetry.lock. Ao contrário do arquivo pyproject.toml, o arquivo de bloqueio lista:
- As versões exatas das principais dependências listadas em pyproject.toml
- As versões exatas das dependências das principais dependências (dependências transitivas)
Por exemplo, requests depende de urllib3, certifi, charset-normalizer e idna. Sem um arquivo de bloqueio, essas subdependências podem ser resolvidas em versões diferentes em máquinas diferentes.
O arquivo de bloqueio garante que todos os membros de sua equipe obtenham as mesmas versões de dependências, evitando o problema de “funciona na minha máquina”.
A diferença entre adicionar e instalar com o poetry
Vamos explicar a diferença entre add e install comandos do Poetry com um caso de uso.
Vamos dizer que você está trabalhando em um projeto de detecção de fraudes. Você adiciona suas dependências iniciais:
$ poetry add pandas scikit-learn
Isso adiciona os pacotes ao arquivo de bloqueio e pyproject.toml. Em seguida, seu colega clona o repositório:
$ git clone fraud-detection-repo-link $ cd fraud-detection $ poetry install
Eles executam o comando install para instalar tudo o que está listado no arquivo de bloqueio.
Mais tarde, você precisa adicionar um novo pacote:
$ poetry add xgboost
Seu colega puxa as alterações:
$ git pull $ poetry install
Eles executam o install comando para instalar o novo pacote. Então,
- Use
poetryadd quando você adicionar novas dependências - Use
poetry installquando você precisar configurar um projeto existente - Sempre faça commit em
pyproject.tomlepoetry.lockno controle de versão
Instalando grupos de dependências com o comando poetry install
Anteriormente, aprendemos como agrupar dependências no Poetry. Quando você executa poetry install, ele instala todos os grupos não opcionais por padrão, o que pode não ser o que você deseja em todos os casos.
Por exemplo, talvez você esteja clonando um repositório apenas para trabalhar na documentação. Ou deseja trabalhar no código principal do repositório, exceto pelos aspectos de documentação e testes. O comando install é flexível o suficiente para cobrir todos esses casos:
Excluir certos grupos:
$ poetry install --without ui,dev
Instalando grupos opcionais também:
# Instalando o grupo de documentos opcional $ poetry install --with docs
Instalando apenas grupos específicos:
$ poetry install --only ui
Instalando apenas as dependências de tempo de execução do projeto (as dependências mencionadas fora de grupos, adicionadas com o comando poetry add package):
$ poetry install --only main
Removendo dependências no Poetry
Excluir uma dependência é simples usando o remove comando:
$ poetry remove requests
Isto remove requests das dependências principais do projeto. Para remover um pacote de uma dependência em grupo, você pode usar a --group tag novamente:
$ poetry remove streamlit --group ui
O comando remove desinstala o pacote de forma limpa, juntamente com suas dependências transitivas.
Publicando um Projeto com Poetry no PyPI
Se o seu projeto estiver pronto para distribuição, publicá-lo no PyPI (Python Package Index) permite que outros desenvolvedores instalem e usem facilmente o seu código através do pip. O Poetry torna esse processo muito simples com apenas dois comandos:
$ poetry build # Construir distribuições $ poetry publish # Publicar no PyPI
No entanto, antes de executar esses comandos, você deve configurar corretamente suas credenciais do PyPI. Primeiro, crie suas contas em:
Configure o Poetry com suas credenciais:
$ poetry config pypi-token.pypi your-pypi-token $ poetry config pypi-token.testpypi your-test-pypi-token
Agora, teste seu pacote primeiro:
# Configure o repositório TestPyPI $ poetry config repositories.testpypi https://test.pypi.org/legacy/ # Publicar no TestPyPI $ poetry build $ poetry publish -r testpypi
Depois de publicar no TestPyPI, você pode tentar instalar seu pacote para testar se tudo está funcionando bem:
$ pip install --index-url https://test.pypi.org/simple/ your-package-name
Se tudo estiver bem, você pode publicar no PyPI em si:
$ poetry publish
Práticas Recomendadas ao Trabalhar com o Poetry
Há muitas armadilhas e práticas recomendadas ao usar o Poetry, e é claro que não podemos mencioná-las todas em um único artigo. Mas aqui estão algumas comuns que você pode aplicar imediatamente:
- Sempre use ambientes virtuais – o Poetry os cria automaticamente para cada projeto
- Mantenha seu
pyproject.tomlsob controle de versão, mas excluapoetry.lockpara bibliotecas - Inclua
poetry.lockno controle de versão para aplicações para garantir builds reproduzíveis - Use versionamento semântico para as versões de seus pacotes (major.minor.patch). Você pode usar
poetry version patch/minor/majorcomandos para aumentar as versões dos pacotes em um. Por exemplo,poetry version majoraltera 0.2.0 para 1.0.0 no arquivopyproject.toml. - Especifique cuidadosamente as restrições de versão das dependências para evitar conflitos
- Atualize regularmente as dependências com
poetry updatemas teste minuciosamente após as atualizações - Use
poetry add --group devpara dependências de desenvolvimento para mantê-las separadas - Documente todos os propósitos das dependências em pyproject.toml usando comentários
- Execute
poetry checkantes de confirmar para validar a sintaxe do arquivo pyproject.toml. Você também pode considerar ganchos pre-commit. - Use
poetry exportpara gerarrequirements.txtquando necessário para outras ferramentas. - Mantenha as dependências de produção mínimas – mova recursos opcionais para extras
- Teste a instalação do seu pacote em um ambiente limpo antes de publicar
- Use o TestPyPI antes de publicar no repositório principal do PyPI
- Mantenha um
CHANGELOG.mdclaro para rastrear as mudanças de versão - Use
poetry runpara execução de scripts para garantir o uso correto do ambiente
Conclusão e Próximos Passos
A poesia revolucionou o gerenciamento de dependências do Python, fornecendo uma solução robusta e intuitiva para os desafios comuns de gerenciamento de pacotes. Suas poderosas funcionalidades para resolução de dependências, gerenciamento de ambiente virtual e publicação de projetos tornam-na uma ferramenta inestimável para o desenvolvimento moderno em Python.
Para continuar sua jornada de desenvolvimento em Python, considere explorar esses caminhos de aprendizado abrangentes:
- Trilha de Programação em Python — Domine os fundamentos e conceitos avançados do Python
- Python Intermediário — Aprimore suas habilidades em Python
- Fundamentos de Dados em Python — Aprenda habilidades essenciais de manipulação de dados
- Associado Cientista de Dados em Python — Aprofunde-se na ciência de dados com Python
Lembre-se, a gestão eficaz de dependências é apenas um aspecto do desenvolvimento profissional em Python. Conforme você continua a crescer como desenvolvedor, ferramentas como Poetry irão ajudá-lo a construir projetos Python mais sustentáveis e confiáveis.