Gerenciadores de Pacotes e Ambientes Virtuais
PIP é o gerenciador de pacotes do Python, também conhecidos como bibliotecas.
É importante notar que o termo "pacote" neste contexto está sendo usado como sinônimo de distribuição (ou seja, um pacote de software a ser instalado), não para se referir ao tipo de pacote que você importa em seu código-fonte Python (ou seja, um contêiner de módulos). É comum na comunidade Python referir-se a uma distribuição usando o termo "pacote". O uso do termo "distribuição" geralmente não é preferido, porque pode ser facilmente confundido com uma distribuição Linux ou outra distribuição de software maior como o próprio Python.
A partir da versão 3.4 do Python o PIP já vem incluído por padrão com a instalação do Python, então existem grandes chances de você já tê-lo em sua máquina.
Para confirmar se ele está instalado, vamos digitar o seguinte comando na nossa interface de linha de comando:
pip --version
Caso ele não esteja presente em sua máquina, você pode encontrá-lo em: https://pypi.org/project/pip/ ou get-pip.py:
- Faça o download do arquivo
get-pip.py - Execute o comando
python get-pip.py. Isso irá instalar ou atualizar o pip.
Outra opção de instalação é executar o comando:
python -m ensurepip --default-pip
Para confirmar se o pip está atualizado, você pode executar o seguinte comando:
python -m pip install --upgrade pip
Para navegar através da lista de mais de 190,943 projetos, 2,069,359 arquivos e 354,989 usuários, visite: https://pypi.org
Pacotes
Um pacote seria um conjunto de arquivos para um módulo, como já vimos antes, módulos são como bibliotecas de código que podemos incluir em nossos projetos para usarmos suas funcionalidades e facilitar nossa vida como programadores.
Normalmente, não armazenamos todos os nossos arquivos em nosso computador no mesmo local. Usamos uma hierarquia de diretórios bem organizada para facilitar o acesso e gerência.
Conforme nosso programa cresce em tamanho com muitos módulos, colocamos módulos semelhantes em um pacote e módulos diferentes em pacotes diferentes. Isso torna um projeto (programa) fácil de gerenciar.
Da mesma forma, como um diretório pode conter sub-diretórios e arquivos, um pacote Python pode ter sub-pacotes e módulos.
Um diretório deve conter um arquivo denominado __init__.py para que o Python o considere como um pacote. Este arquivo pode ser deixado vazio, mas geralmente colocamos o código de inicialização para esse pacote neste arquivo.
A seguinte ilustração nos apresenta a ideia de como funciona a estrutura de um projeto, usamos como exemplo um pacote de nome Game que possui diversos módulos.
Instalando Pacotes
Novamente, vamos abrir nossa interface de linha de comando e vamos até o diretório que está nosso script. Digitaremos o seguinte comando para instalar a biblioteca requests:
pip install requests
Será iniciado um processo de download e instalação, aguarde um pouco e estará pronto, agora poderemos usar a nova biblioteca.
Utilizando o Pacote
Uma vez que já temos requests instalada, para usarmos é só importá-la, assim como fazemos com os módulos padrão do Python:
import requestsprint(dir(requests))# ['ConnectionError', 'FileModeWarning', 'HTTPError', 'NullHandler', 'PreparedRequest', 'Request', 'RequestException', 'Response', 'Session', 'Timeout', 'TooManyRedirects', 'URLRequired', '__author__', '__build__', '__builtins__', '__cached__', '__copyright__', '__doc__', '__file__', '__license__', '__loader__', '__name__', '__package__', '__path__', '__spec__', '__title__', '__version__', 'adapters', 'api', 'auth', 'certs', 'codes', 'compat', 'cookies', 'delete', 'exceptions', 'get', 'head', 'hooks', 'logging', 'models', 'options', 'packages', 'patch', 'post', 'put', 'request', 'session', 'sessions', 'status_codes', 'structures', 'utils', 'warnings']r = requests.get("http://google.com")print(r.status_code) # 200, significa que a requisição ocorreu com sucessoprint(r.text) # Retorna o conteúdo HTML da páginaprint(r.encoding) # ISO-8859-1, codificação usada na página
Como podem ver, com um rápido download e instalação, temos acesso a uma poderosa biblioteca chamada requests, que nos permite fazer requisições HTTP e uma série de outras funcionalidades web.
Removendo um Pacote
Para desinstalarmos um pacote de nossa máquina podemos usar o comando uninstall
pip uninstall requests
É necessário confirmarmos a desinstalação com a tecla y.
Listando os Pacotes
Podemos usar o comando list para listarmos os pacotes que temos instalado em nossa máquina:
pip list
Atualizando um Pacote Existente
O comando install --upgrade nos permite atualizar um pacote para sua versão mais recente:
pip install --upgrade requests
Obtendo Informações
Através do comando show podemos obter informações sobre um determinado pacote:
pip show requests
Podemos também fazer pesquisas por palavras-chave:
pip search http
Ambientes Virtuais
O principal propósito dos Ambientes Virtuais é criar um ambiente isolado para projetos Python. Isso significa que cada projeto pode ter suas próprias dependências, independente da dependência de outros projetos. Eles são essenciais para evitarmos conflitos de versões de bibliotecas entre os nossos projetos.
Python, como a maioria das outras linguagens de programação modernas, tem sua própria maneira única de baixar, armazenar e resolver pacotes. Embora isso tenha suas vantagens, algumas decisões interessantes foram tomadas sobre o armazenamento e a resolução de pacotes, o que levou a alguns problemas - especialmente em relação à como e onde os pacotes são armazenados.
Existem alguns locais diferentes onde esses pacotes podem ser instalados em seu sistema. Por exemplo, a maioria dos pacotes de sistema são armazenados em um diretório filho, no qual o caminho fica armazenado em sys.prefix.
Sendo assim, podemos usar a biblioteca sys para sabermos onde sys.prefix está apontando:
import sysprint(sys.prefix) # /home/akira/anaconda3
Veja que no meu caso, estou usando anaconda e posso usar este caminho para saber quais pacotes eu tenho instalado com o seguinte comando Linux:
ls -la /home/akira/anaconda3/lib/python3.7/
Mas afinal, por que essas informações são relevantes?
É importante saber isso porque, por padrão, todos os projetos em seu sistema usarão esses mesmos diretórios para armazenar e recuperar pacotes de sites (bibliotecas de terceiros). Inicialmente, isso pode não parecer problemático, e não é realmente, para pacotes de sistema (pacotes que fazem parte da biblioteca Python padrão), mas importa para pacotes de terceiros.
Considere o seguinte cenário em que você tem dois projetos: ProjetoA e ProjetoB, ambos os quais dependem da mesma biblioteca, TimeLib. O problema se torna aparente quando começamos a exigir versões diferentes do TimeLib. Talvez o ProjectA precise da v1.0.0, enquanto o ProjectB requer a v2.0.0 mais recente, por exemplo.
Isso irá gerar conflitos e por este motivo os ambientes virtuais são tão importantes!
Para saber mais detalhes sobre os Ambientes Virtuais você pode visitar: venv
Usando Ambientes Virtuais
Antes de tudo, devemos instalar a ferramenta virtualenv que nos permite trabalhar com ambientes virtuais.
pip install virtualenv
Lembrando que se você instalou a versão 3 do Python, é provável que você já o módulo venv da biblioteca padrão em seu computador. Agora que você já tem a ferramenta para criar ambientes virtuais, vamos criar um novo diretório em nossa máquina e navegar até ele através de nossa interface de linha de comando e digitar o seguinte comando
# Para Python 2virtualenv env# Para Python 3python3 -m venv env
O comando acima irá criar um diretório chamado env (nome arbitrário escolhido por nós) que contém uma estrutura similar a essa:
├── bin│ ├── activate│ ├── activate.csh│ ├── activate.fish│ ├── easy_install│ ├── easy_install-3.5│ ├── pip│ ├── pip3│ ├── pip3.5│ ├── python -> python3.5│ ├── python3 -> python3.5│ └── python3.5 -> /Library/Frameworks/Python.framework/Versions/3.5/bin/python3.5├── include├── lib│ └── python3.5│ └── site-packages└── pyvenv.cfg
Cada folder no diretório env contém:
- bin: arquivos que interagem com o ambiente virtual
- include: Cabeçalhos C que compilam os pacotes Python
- lib: Uma cópia da versão Python juntamente com o folder
site-packagesonde cada dependência está localizada
Ativando um Ambiente Virtual
Dentro do folder bin que vimos anteriormente existem scripts de ativação, esses scripts são usados para setar nossa Shell para usar o executável Python do ambiente e os site-packages.
De forma a usarmos os pacotes e recursos de um ambiente virtual é necessário que ativemos ele:
source env/bin/activate
Ou até mesmo utilizando somente .
. env/bin/activate
Perceba que ao ativarmos o ambiente virtual, nosso prompt de comandos irá se alterar para nos indicar que o ambiente está ligado. Caso você queira desativar o ambiente virtual basta digitar:
deactivate
Agora que vimos como ativar e desativar nosso ambiente virtual, vamos reativá-lo e testá-lo instalando a biblioteca bcrypt:
pip install bcrypt
Abra agora o Python Interactivo ou um Script e vamos testar se a biblioteca está instalada corretamenta:
import bcryptbcrypt.hashpw('senha'.encode('utf-8'), bcrypt.gensalt(12))# b'$2b$12$ZT52zrACwPVFy1ST8UbsKuRQ/LZmhMvmMB7EqchU1VUQTLTi4X7Mu'
Gerando o Arquivo requirements.txt
O comando pip freeze nos permite listar os pacotes que estão instalados em nossa máquina ou, caso estejamos em um ambiente virtual, os pacotes que nele estão presentes.
É muito comum existir em projetos o arquivo requirements.txt que mostra os pacotes e suas versões necessárias para que o projeto possa funcionar corretamente, também é possível instalar pacotes através do arquivo requirements.txt
Assumindo que estamos em nosso ambiente virtual e temos a biblioteca bcrypt instalada, vamos executar:
pip freeze > requirements.txt
Ao verificar o contéudo do arquivo requirements.txt, encontramos o seguinte:
bcrypt==3.1.7cffi==1.12.3pycparser==2.19six==1.12.0
Caso queiramos instalar todos os pacotes contidos nele podemos usar o comando:
pip install -r requirements.txt
Outras Alternativas
Pip é uma ferramenta essencial para todos os Pythonistas e é usada por muitos aplicativos e projetos para gerenciamento de pacotes, ainda sim, existem outras alternativas muito boas que podemos usar em nossos projetos.
Conda
Conda é um gerenciador de pacotes, dependências e ambientes para muitas linguagens, incluindo Python. Na verdade, sua origem vem do Anaconda, que começou como um pacote de ciência de dados para Python.
O Conda é amplamente utilizado para aplicativos de ciência de dados e Machine Learning, e usa seu próprio índice para hospedar pacotes compatíveis.
Conda não apenas permite que você gerencie dependências de pacote, mas também gerencia ambientes virtuais para seus aplicativos, instala distribuições Python compatíveis e empacota seu aplicativo para implantação na produção.
Além do pip e do ambiente virtual tradicional que utilizamos anteriormente, também existem outras opções de gerenciadores de pacotes para Python.
Você pode obter mais detalhes sobre Conda em: https://docs.conda.io/en/latest/
Pipenv
Pipenv é uma ferramenta que visa trazer o melhor de todos os mundos de pacotes (bundler, composer, npm, cargo, yarn, etc.) para o mundo Python. O Windows é um cidadão de primeira classe no Pipenv.
Ele cria e gerencia automaticamente um virtualenv para seus projetos, bem como adiciona / remove pacotes de seu Pipfile conforme você instala / desinstala pacotes. Ele também gera o sempre importante Pipfile.lock, que é usado para produzir compilações determinísticas.
Você pode obter mais detalhes sobre ele em: https://pipenv.pypa.io/en/latest/