pip

O que é gerenciador de dependências?

Ao longo dos anos, houve uma grande evolução no desenvolvimento das aplicações. Algo muito comum há vinte anos, hoje é impraticável. No passado, quando era preciso, por exemplo, acessar um banco de dados, o desenvolvedor programava todos os aspectos desta conexão ou copiava (basicamente um copy-paste) de alguém que já implementou isso.

Esta dinâmica de “copiar-colar” o código, evoluiu para a “copia” de pacotes. No lugar de copiar o código fonte diretamente, o desenvolvedor passou a obter pacotes que continham os códigos que necessitava, como para o acesso ao banco. Esses pacotes eram adicionados manualmente no projeto que estivesse desenvolvendo.

O problema desde cenário é que se um pacote copiado fosse alterado, por qualquer motivo, o desenvolvedor precisaria repetir todo o procedimento de adição do pacote no projeto. Claro que também precisava ficar atento para saber se o pacote foi alterado ou não.

Com o tempo, os pacotes passaram a serem mais utilizados, o que tornou este gerenciamento manual impraticável. Vindo ao resgaste disso, surgiram os gerenciadores de pacotes, também chamados de gerenciador de dependências. Essas ferramentas realizam automaticamente os procedimentos que os desenvolvedores faziam manualmente. Delegando o gerenciamento dos pacotes de um projeto, o desenvolvedor pode focar no que é mais importante, o desenvolvimento da aplicação que está criando.

Npm - Gerenciador de pacotes para JavaScript
Curso de Npm - Gerenciador de pacotes para JavaScript
CONHEÇA O CURSO

Mas o meu projeto é pequeno, preciso de um gerenciador de dependência?

Durante a criação de uma aplicação, não importa qual seja o seu tamanho, pacotes são adicionados para agilizar o desenvolvimento, mantê-la coesa e evitar a “reinvenção da roda”. Porque criar algo do zero, se outro desenvolvedor já implementou o mesmo procedimento?

Mesmo havendo a possibilidade de adicionar um pacote manualmente, este também pode fazer uso de outro pacote. Neste cenário, trabalhando de maneira manual, mesmo requerendo apenas um pacote, o desenvolvedor precisará se preocupar com dois.

Entretanto, não há garantias que será apenas uma dependência. O segundo pacote pode necessitar de outros e assim por diante, gerindo um complexo grafo de dependências.

Logo vemos que o projeto possui muitas dependências, o que não é ruim, mas gerencia-las manualmente se torna complicado ou mesmo impossível:

É neste momento que os gerenciadores de dependências são imprescindíveis. Eles gerenciam todas as ações com relação as dependências do projeto: listagem, adição, remoção e atualização. Além de analisar o grafo de dependência e garantir que as dependências dos pacotes utilizados no projeto também sejam obtidas.

Principais gerenciadores de dependência

Atualmente qualquer plataforma de desenvolvimento que se preze possui uma ferramenta que permite a criação, compartilhamento e consumo de códigos entre os desenvolvedores.

Existem várias que se encontram neste quesito, entre as mais populações temos:

  • NPM: Para aplicações web e JavaScript;
  • Yarn: Para aplicações web e JavaScript;
  • Composer: Para aplicações PHP;
  • Maven: Para aplicações Java e Kotlin;
  • Gradle: Para aplicações Java, Groovy, Kotlin, Android, Scala e JavaScript;
  • NuGet: Para aplicações .NET;
  • Pip: Para aplicações Python;
  • Rubygem: Para aplicações Ruby;
  • Mix: Para aplicações Elixir;
  • Hex: Para aplicações Erlang;
  • Cargo: Para aplicações Rust;
  • PEAR Installer: Para aplicações PHP;
  • CPAN: Para aplicações Pear.

Cada gerenciador de dependências possui suas particularidades, mas todos facilitam a vida do desenvolvedor, então saber utilizá-los é algo essencial atualmente. Aqui no nosso blog, já abordamos o Yarn, PIP, NPM e NuGet.

Composer - Gerenciador de dependências para PHP
Curso de Composer - Gerenciador de dependências para PHP
CONHEÇA O CURSO

Devemos abordar os outros gerenciadores em artigos futuros, então fique de olho nas nossas publicações aqui do blog.

Configurando ambiente de desenvolvimento para projetos Django

O Django é um ótimo framework para o desenvolvimento de aplicações com um grande reaproveitamento de código e facilidade de aprendizado. Segundo o Stack Overflow Trends, o Django é, atualmente, um dos principais frameworks full stack do mercado, sendo mais pesquisado que o Laravel e Spring. Pensando nisso, veremos neste artigo como dar nossos primeiros passos com o Django e criar nosso primeiro projeto.

O que é o Django?

Já falamos em outro artigo o que é e como funciona o Django. Basicamente, ele é um framework escrito em Python para desenvolvimento de aplicações web muito popular e com uma comunidade incrível. Não vamos entrar em detalhes mais específicos sobre o funcionamento básico do Django, já que isto pode ser visto em um artigo que já escrevemos, caso você tenha alguma dúvida, é extremamente recomendado que o leia antes de iniciar seus estudos com o framework 🙂

Django - Fundamentos
Curso de Django - Fundamentos
CONHEÇA O CURSO

Ambiente de desenvolvimento

Basicamente, o Django precisa apenas do Python instalado na máquina para que consigamos criar e executar um projeto. Porém, há três outras ferramentas que você deve considerar em seu ambiente de desenvolvimento, como veremos a seguir.

Sendo assim, o primeiro passo é instalar o Python em nossa máquina. Por ser multi-plataforma, o Python funcionará em qualquer sistema operacional que você utilizar (Windows, Linux ou macOS). Seu download pode ser feito na página oficial da ferramenta. Caso você utilize o Linux ou macOS, você já deve possuir o Python instalado em seu computador. Para verificar esta existência, podemos abrir o terminal e ditarmos o seguinte comando:

python --version

Ao executarmos o comando acima, teremos o seguinte retorno:


Lembrando que podem haver duas versões do Python instalados em sua máquina, então você pode especificar a versão que você deseja verificar a instalação (Python 2 ou Python 3).

No Windows, a instalação é simples (next > next > next > finish), tendo apenas que se atentar em marcar a opção de adicionar o Python ao PATH do sistema:

Feito isso, o Python será instalado e configurado automaticamente no Windows.

PIP, PyCharm e Virtualenv

Com o Python instalado, podemos falar das outras três ferramentas que considero essenciais para o desenvolvimento de aplicações Django: o PIP, PyCharm e Virtualenv.

O PIP é, basicamente, um gerenciador de pacotes para projetos Python. Muito utilizado quando precisamos instalar pacotes externos em nossos projetos. Já temos um ótimo artigo sobre como funciona e como instalar o PIP em nosso ambiente. Recomendo, fortemente, a leitura 🙂

Já o PyCharm é a principal IDE para desenvolvimento de aplicações Python do mercado. Desenvolvido pela Jetbrains, o PyCharm é multi-plataforma e possui as versões Professional e Community.


A instalação do PyCharm segue o velho padrão (next > next > finish) e, com certeza, você vai se encantar com todos os recursos dessa IDE no desenvolvimento de suas aplicações.

A última ferramenta é a virtualenv. Um problema muito comum é quando precisamos utilizar diversas versões de uma mesma biblioteca em diferentes projetos Python. Isso pode acarretar em conflitos entre as versões e muita dor de cabeça para o desenvolvedor. Para resolver este problema, o mais correto é a criação de um ambiente virtual para cada projeto.

Para criar estes ambientes virtuais, podemos utilizar uma virtualenv. Também possuímos aqui no blog um artigo sobre como funciona uma virtualenv no Python e como instalá-la em nossa máquina.

Ambiente configurado, e agora?

Com todas as ferramentas instaladas no computador, já estamos aptos a desenvolver primeiros projetos com o Django. Para isso, veremos no próximo artigo como criar o primeiro projeto com Django e qual a funcionalidade de cada arquivo existente em sua arquitetura 🙂

Até lá!!

Criando ambientes virtuais para projetos Python com o Virtualenv

Quando estamos desenvolvendo diversos projetos em Python, é comum utilizarmos diferentes versões de uma mesma biblioteca entre este projetos. Por exemplo, imagine que estamos desenvolvendo o projeto x com a biblioteca mysqlclient em sua versão 1.0 e o projeto y com a mesma biblioteca, porém na versão 2.0. Como faríamos para gerenciar estas dependências e o sistema operacional saber qual versão correta executar quando estivermos em cada projeto?

Esta é uma tarefa um tanto quanto complexa para o SO gerenciar, podendo acarretar em conflitos entre as versões e causar muita dor de cabeça. Sendo assim, o mais comum é utilizarmos diferentes ambentes virtuais, chamados de virtualenvs, um para cada projeto. E é isso que veremos neste artigo 😀

Python - Fundamentos
Curso de Python - Fundamentos
CONHEÇA O CURSO

O que é uma virtualenv?

Como dito acima, um problema muito comum é quando precisamos utilizar diversas versões de uma mesma biblioteca em diferentes projetos Python. Isso pode acarretar em conflitos entre as versões e muita dor de cabeça para o desenvolvedor. Para resolver este problema, o mais correto é a criação de um ambiente virtual para cada projeto.

Basicamente, um ambiente virtual empacota todas as dependências que um projeto precisa e armazena em um diretório, fazendo com que nenhum pacote seja instalado diretamente no sistema operacional. Sendo assim, cada projeto pode possuir seu próprio ambiente e, consequentemente, suas bibliotecas em versões específicas.

Como funciona uma virtualenv?

O funcionamento de uma virtualenv é bem simples. Basicamente, uma cópia dos diretórios necessários para que um programa Python seja executado é criada, incluindo:

  • PIP (Gerenciador de pacotes);
  • A versão do Python utilizada (2.x ou 3.x);
  • Dependências instaladas com o pip (armazenadas no diretório site-packages);
  • Seu código fonte;
  • Bibliotecas comuns do Python.

Isso faz com que as dependências sejam sempre instaladas em uma virtualenv específica, não mais no sistema operacional. A partir daí, cada projeto executa seu código-fonte utilizando sua virtualenv própria 🙂

Instalando a virtualenv

A instalação de uma virtualenv é feita utilizando o pip, gerenciador de pacotes do Python. Já falamos sobre o PIP em um outro artigo aqui do blog. Caso você não saiba do que se trata ou como instalá-lo, sugiro você dar uma passada por lá 🙂
Após instalar o pip, utilizamos o comando abaixo para instalar o pacote virtualenv em nosso computador:

pip install virtualenv

Feito isso, o pacote estará instalado e pronto para ser utilizado. Agora já podemos criar e gerenciar nossos ambientes virtuais.

Criando uma nova virtualenv

O processo de criação de uma virtualenv é bastante simples e pode ser feito utilizando um único comando, como podemos ver abaixo:

virtualenv nome_da_virtualenv

O mais comum é criar a virtualenv na raiz do projeto que ela irá pertencer. Isso permite uma organização maior das virtualenvs que possuímos em nosso computador:

Com isso, criamos a virtualenv do projeto chamada “venv”. É ela quem vai comportar todos os pacotes necessários para a execução do projeto.

Ativando uma virtualenv

Após criar uma virtualenv, precisamos ativá-la para que possamos instalar os pacotes necessários do projeto. Para isso, utilizamos o seguinte comando:

  • source nome_da_virtualenv/bin/activate (Linux ou macOS)
  • nome_da_virtualenvScriptsactivate (Windows)

O comando acima irá ativar a virutalenv e teremos um retorno similar ao ilustrado abaixo:

Note que o nome da virtualenv, agora, é exibido antes do caminho do diretório em que estamos. Isso indica que a virtualenv foi ativada com sucesso.

Desativando uma virtualenv

Para desativar uma virtualenv utilizamos o comando deactivate, como podemos ver abaixo:

Instalando pacotes

Com a virtualenv ativada, podemos instalar os pacotes necessários do projeto utilizando o próprio PIP:

Com isso, instalamos o pacote Django, em sua versão mais atual, na virtualenv do projeto “projeto_python”.

Agora, se precisarmos instalar uma outra versão do Django em outro projeto, bastaria criar uma nova virtualenv e realizar o mesmo processo:

Com isso, teremos diferentes versões do Django instaladas no mesmo sistema operacional, porém isoladas em cada ambiente. Sendo assim, o projeto “projeto_python” utiliza a versão mais recente (2.1.3) e o “projeto_python_2” utiliza a versão 2.11, tudo de forma isolada entre os projetos:


Concluindo

Com isso, vimos o quão importante e simples é utilizar uma virtualenv para cada projeto. Com isso, garantimos que as versões de cada pacote sejam isoladas, permitindo que não haja conflito entre elas.

Python - Orientação a objetos
Curso de Python - Orientação a objetos
CONHEÇA O CURSO

© 2004 - 2019 TreinaWeb Tecnologia LTDA - CNPJ: 06.156.637/0001-58 Av. Paulista, 1765, Conj 71 e 72 - Bela Vista - São Paulo - SP - 01311-200