O ecossistema do Python tradicionalmente dependeu de ferramentas como pip e virtualenv para gerenciar dependências e ambientes de projetos. Embora essas ferramentas tenham nos servido bem, muitas vezes levam a conflitos de dependências, gerenciamento manual de ambiente e configurações de projetos inconsistentes entre equipes.
O Python Poetry resolve esses desafios ao fornecer uma ferramenta moderna e unificada de gerenciamento de dependências e ambientes. Ele lida com tudo, desde ambientes virtuais até publicação de pacotes, garantindo builds reproduzíveis por meio de uma resolução inteligente de dependências.
Este guia irá mostrar como usar o Poetry para otimizar o fluxo de trabalho de desenvolvimento em Python e evitar dores de cabeça comuns de dependências.
Python Poetry vs. PIP
O Poetry e o pip servem para diferentes propósitos 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: Utiliza 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 embutido para arquivos de bloqueio
- Poesia: Gera poetry.lock para compilações reproduzíveis em diferentes 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 o Poetry em vez do pip
Escolha o Poetry quando:
- Estiver trabalhando em projetos de equipe que necessitam de ambientes reprodutíveis
- Estiver construindo pacotes que serão publicados no PyPI
- Gerenciando árvores de dependências complexas com conflitos potenciais
- Necessitar de gerenciamento automatizado de ambientes virtuais
- Desejar uma única ferramenta para todo o fluxo de trabalho de desenvolvimento
Continue utilizando o pip quando:
- Trabalhando em scripts simples com dependências mínimas
- Aprendendo Python pela primeira vez
- Precisa instalar rapidamente um único pacote
- Trabalhando em ambientes onde a instalação do Poetry não é possível
- Mantendo projetos legados que já estão configurados com o 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 passo crucial inicial 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 na Microsoft Store (por alguma razão estranha), substitua py por python no comando acima.
Depois que o script de instalação terminar, ele imprime uma mensagem pedindo para você adicionar o Poetry ao seu PATH para que o comando poetry esteja disponível em todos os lugares.
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 é sobre 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á algo parecido com o seguinte:
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. É principalmente usado 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, é 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 seu diretório de trabalho ou no cache. Isso é controlado viavirtualenvs.in-projectopção. Se configurado 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 explorar os passos-chave 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 diretório explore-poetry pré-povoado 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 que explica 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 arquivo 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 a Linguagem Óbvia e Mínima de Tom, que foi acordada 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 Poetry delineados nas seções seguintes, o pyproject.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 uma vez que o configurar. 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 alternância. Você também aprenderá como gerenciar 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 # no output
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ê deverá 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 são resolvidas com sucesso, e um arquivo de bloqueio é gerado (falaremos mais sobre isso depois).
Preste atenção no 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 adicionar uma dependência, o Poetry usa 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 de 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
Depois, você pode sair do shell chamando exit.
Alternativamente, você pode executar comandos no shell do Poetry sem 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 em todo o sistema da sua máquina 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 conectado ao nosso projeto (os IDs são os mesmos). Assim que você 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 estiver trabalhando em projetos de equipe, geralmente é 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.
Isto cria uma .venv pasta no seu diretório de trabalho, que você deve adicionar ao seu .gitignore arquivo.
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 de forma que você nunca se depare com conflitos de dependências infernais.
Nesta seção, você aprenderá sobre como 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 tem alguns benefícios:
- Adiciona automaticamente o pacote ao arquivo
pyproject.tomlcom a restrição de versão correta - Atualiza o arquivo de bloqueio para garantir compilações reproduzíveis
- Resolve dependências para evitar conflitos
- Instala o pacote e todas as suas dependências no ambiente virtual
Por exemplo, vamos 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 pyproject.toml arquivo. No momento, ele parece com isso:
[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 vem 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 patch e menores, mas não de versão principal. Exemplo:
^1.2.3permite atualizações de 1.2.3 para 1.9.9, mas não para 2.0.0. - Til (~): Permite apenas atualizações de patch. Exemplo:
~1.2.3permite atualizações de 1.2.3 para 1.2.9, mas não para 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. - Menos que (<): Permite qualquer versão abaixo da especificada. Exemplo:
<2.0.0permite qualquer coisa abaixo de 2.0.0. - Maior ou igual (>=): Permite a versão especificada e acima. Exemplo:
>=1.2.3permite 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 - Correspondência de caractere curinga (*): 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 lida 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 também é necessário completar a documentação e executar testes. Todos esses passos possuem 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ências com nomes arbitrários para que possa instalá-los somente 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 (caso ainda não existam), 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ências estejam separados, eles ainda são resolvidos entre si. 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 configurando o parâmetro opcional como true antes de declarar as dependências do grupo.
Reproduzindo um projeto de Poesia com o arquivo poetry.lock
Se alguém clonar o 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 usa 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 resolver para versões diferentes em máquinas diferentes.
O arquivo de bloqueio garante que todos na sua equipe obtenham as mesmas versões de dependência, evitando o problema do “funciona na minha máquina”.
A diferença entre adicionar e instalar no Poetry
Vamos explicar a diferença entre add e install comandos do Poetry com um caso de uso.
Vamos supor que você esteja 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 ao adicionar novas dependências - Use
poetry installquando precisar configurar um projeto existente - Sempre faça commit do arquivo
pyproject.tomle do arquivopoetry.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, você pode estar clonando um repositório apenas para trabalhar na documentação. Ou deseja trabalhar no código principal do repositório, exceto pela documentação e aspectos de teste. O comando install é flexível o suficiente para abranger todos esses casos:
Excluindo certos grupos:
$ poetry install --without ui,dev
Instalando grupos opcionais também:
# Instalando o grupo de documentação opcional $ poetry install --with docs
Instalando apenas grupos específicos:
$ poetry install --only ui
Instalando apenas as dependências em tempo de execução do projeto (as dependências mencionadas fora de grupos, adicionadas com poetry add package comandos):
$ 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 tag --group novamente:
$ poetry remove streamlit --group ui
O comando remove desinstala limparmente o pacote, juntamente com suas dependências transitivas.
Publicando um Projeto com Poetry no PyPI
Se o seu projeto está pronto para distribuição, publicá-lo no PyPI (Python Package Index) permite que outros desenvolvedores instalem e usem seu código facilmente através do pip. O Poetry torna esse processo muito simples com apenas dois comandos:
$ poetry build # Criar 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:
# Configurar 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 estiver tudo bem, você pode publicar no PyPI em si:
$ poetry publish
Melhores Práticas ao Trabalhar com o Poetry
Há muitos detalhes e melhores práticas ao usar o Poetry, e é claro que não podemos mencionar todos eles em um único artigo. Mas aqui estão alguns comuns que você pode aplicar imediatamente:
- Sempre use ambientes virtuais — o Poetry os cria automaticamente para cada projeto
- Mantenha o seu
pyproject.tomlsob controle de versão, mas excluapoetry.lockpara bibliotecas - Inclua o
poetry.lockno controle de versão para aplicações garantir construções reprodutíveis - Use versionamento semântico para as versões de seu pacote (major.minor.patch). Você pode usar
poetry version patch/minor/majorcomandos para aumentar as versões do pacote em um. Por exemplo,poetry version majoraltera 0.2.0 para 1.0.0 em seu 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 as dependências de desenvolvimento mantendo-as separadas - Documente todos os propósitos das dependências no pyproject.toml usando comentários
- Execute
poetry checkantes de confirmar para validar a sintaxe do 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 a gestão 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 ambientes virtuais e publicação de projetos a tornam 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 — Mergulhe na ciência de dados com Python
Lembre-se, o gerenciamento eficaz de dependências é apenas um aspecto do desenvolvimento profissional em Python. Conforme você continuar a crescer como desenvolvedor, ferramentas como o Poetry irão ajudá-lo a construir projetos Python mais sustentáveis e confiáveis.