Created: 2021-05-27 14:25

Updated: 2026-03-06 09:20

Introdução

Este artigo contém as informações necessárias para instalar a versão 3.x do Python no Debian Linux Buster (10.x) à partir do código fonte.

Esta instalação não irá remover a versão do Python instalada no sistema, mas permitirá o uso de uma versão mais atual da linguagem e do interpretador. Optei por não substituir a versão original do sistema porque muitas aplicações e ferramentas do sistema no Debian dependem do Python e a versão da distribuição possui muitos módulos específicos.

Instalando os pré-requisitos

Instale os seguintes pacotes necessários para a compilação do Python3:

sudo apt install build-essential dpkg-dev gdb lcov libbz2-dev \
    libc6-dev libffi-dev libgdbm-compat-dev libgdbm-dev liblzma-dev \
    libmpd-dev libncurses-dev  libreadline-dev \
    libsqlite3-dev libssl-dev lzma liblzma-dev \
    pkg-config tk-dev uuid-dev zlib1g-dev rust-all libnss3-dev

O pacote rust-all é necessário para alguns módulos que podemos instalar futuramente. Um exemplo é módulo rpds_py, que é um dos requisitos para o Jupyter Notebook, entre outros.

Dica: caso seja necessário instalar a última versão do Rust, pode-se tentar o seguinte comando:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Este comando instala o Rust toolchain apenas para o usuário local e, portanto, você deve adicionar o diretório de instalação do PATH de seu usuário (normalmente ~/.cargo/bin).

Gráficos - Pillow: caso o módulo Pillow precise ser instalado, convém adicionar as seguintes dependências:

sudo apt install libjpeg-dev zlib1g-dev libtiff5-dev libfreetype-dev \
libwebp-dev libimagequant-dev libraqm-dev libxcb1-dev

Para fins didáticos, e facilidade de cópia dos comandos, vou usar a seguinte variável de ambiente que define a versão do Python a ser compilada e instalada:

PYVER=3.12.2

Caso você esteja em ambiente Linux, que é o sistema usado neste artigo, o uso desta variável facilita o processo de copiar e colar os comandos a seguir. é uma opção pessoal. Caso você ache compĺicado ou não queira usá-la, basta substituir o texto ${PYVER} nos comandos a seguir pelo número de versão do Python em questão (exemplo: para a versão 3.12.2 do Python, troque todas as ocorrências de "${PYVER}" por "3.12.2" (sem as aspas).

Como a compilação pode demorar um pouco, dependendo dos recursos de hardware disponíveis, pode-se optar por utilizar mais recursos do sistema para esta tarefa. O comando make permite o uso da opção -j N, onde N é o número de processadores (físicos e lógicos) disponíveis no sistema. Para obter o número de processadores do sistema, utilize o comando:

nproc

O valor retornado por este comando é o número de processadores físicos e lógicos do sistema. Este é o valor máximo que se pode utilizar na opção -j do comando make. Lembrando que, em tese, quanto mais processadores usados na compilação, mais rápida ela será; porém, o sistema poderá ficar mais lento para outras tarefas.

Descompacte, configure, compile e instale o Python (estou assumindo que o arquivo do código fonte do Python já tenha sido baixado do site http://www.python.org):

PYVER=3.12.2
tar xJvf Python-${PYVER}.tar.xz
cd Python-${PYVER}
./configure --prefix=/opt/python-${PYVER} --enable-optimizations --with-lto
time make -j $(nproc) test
sudo make install

O comando configure permite o uso de várias flags, sendo as mais comuns as seguintes:

--disable-gil: para Python-3.13: habilita o suporte a execução sem GIL (Global Interpreter Lock). Se compilado com esta flag, os programas poderão ser executados sem a limitação imposta pelo GIL. Desabilitar o GIL pode provocar problemas em alguns pacotes. Por exemplo, no Python-3.13.0, quando compilei com GIL desabilitado por padrão, o SQLModel provocou falha de segmentação, mesmo forçando a execução com GIL habilitado. Então, talvez seja melhor aguardar as próximas versões até que os módulos se ajustem ao GIL desabilitado (opinião pessoal);
--enable-pydebug: esta flag é sugerida na do documentação do Python, porém, seu uso é destinado aos desenvolvedores da linguagem, e não dos programadores que usam o Python;
--enable-shared: esta flag pode não ser uma boa ideia em todos os casos, então, se ficar na dúvida, não a use. De forma simples, o uso de bibliotecas compartilhadas faz com que o arquivo executável gerado seja menor, porque parte do código do Python será gravado em arquivo separado. Isso faz com que o arquivo executável seja carregado mais rapidamente, já que ele vai ler o arquivo de biblioteca (algo como libpython3.XX.so.1.0) quando precisar. Se esta flag não for inserida no comando, a compilação será estática, ou seja, a biblioteca (por exemplo, libpython3.XX.so.1.0) que poderia ficar em arquivo separado, será inclusa no arquivo executável do comando python. Isso faz com que o carregamento do arquivo seja mais lento, porém, não exige nenhuma configuração extra do sistema. Por exemplo, no Linux, eu sempre opto por instalar o Python em pasta exclusiva (/opt/python-X.Y.Z) para evitar que ele interfira nos aplicativos do sistema operacional que usam o Python padrão do sistema (sim, no Linux há muitos aplicativos em Python, inclusive ferramentas de sistema). Neste caso, se eu compilar com a opção --enable-shared, será necessário adicionar o caminho para a pasta onde as bibliotecas compartilhadas foram instaladas nas configurações do sistema operacional (veja a configuração do ld.so.conf logo a seguir);
--enable-optimizations: é uma boa opção para melhorar a performance geral do Python, com o custo adicional de demorar mais para que a compilação seja finalizada, dependendo dos recursos do computador, pode demorar até 3 vezes mais para compilar. De qualquer forma, eu usaria esta opção.
--with-lto: habilita *Link Time Optimization( (LTO) durante a compilação do CPython. Em termos de compilação, isso significa que otimizações são feitas no momento do link, quando todos os objetos compilados (.o) já estão disponíveis. Isso permite ao compilador otimizar entre diferentes arquivos fonte, algo que normalmente não é possível.

No comando make, a oção -j 8 indica o número de processos que o make pode utilizar edeve ser ajustado para os recursos do seu computador. Normalmente, para maior rapidez, usamos o mesmo número de cores ou CPUs do computador. Nas versões recentes do make, se omitirmos o número de jobs na opção -j, o make usará o máximo que ele conseguir. Note que, teoricamente, quanto mais processos, mais rápida será a compilação, porém, maior processamento e I/O de disco será utilizado do computador, então, a usabilidade do computador pode ficar comprometida durante o processo de compilação. A opção test executa os testes do software.

O último comando (make install) irá instalar a nova versão do Python em /opt/${PYVER}.

Caso ocorra algum problema com o teste da data, tente fazer o seguinte:

export TZ=UTC; export LC_TIME=C; time make -j $(nproc) test

Atenção: Os dois passos a seguir só devem ser executados se você optou por habilitar a flag --enable-shared descrita anteriormente.

Atualize o cache de bibliotecas do sistema operacional. Para fazer isto, crie o arquivo /etc/ld.so.conf.d/python.conf e adicione o seguinte conteúdo:

/opt/python-VERSÃO/lib

Substitua VERSÃO pela versão do Python em questão.

Grave o arquivo e atualize o cache das bibliotecas:

sudo ldconfig

Algumas vezes me deparei com o seguinte problema: após a compilação, o pip não é criado na pasta bin do Python. Se isto ocorrer, execute o seguinte comando:

sudo /opt/python-${PYVER}/bin/python3 -m ensurepip --default-pip

Atualize as ferramentas pip e setuptools:

cd /opt/python-${PYVER}/bin
sudo ./pip3 install --upgrade pip
sudo ./pip install --upgrade setuptools

Instale o Cython (biblioteca para uso de código em C/C++ junto com Python):

sudo ./pip3 install cython

Ajustando a variável de ambiente PATH

Adicione a nova versão do Python no PATH de seu usuário: edite o arquivo ~/.bashrc e altera a variável PATH. Veja o exemplo:

export PATH=/home/mario/bin:/opt/python-3.9.2/bin:/opt/Qt5.12.1/Tools/QtCreator/bin/:$PATH

Qt5

Para que o Qt, é preciso instalar as biblioteca no sistema operacional.

Instale as dependências:

sudo apt install libpoppler-qt5-1  libqt5concurrent5 \
    libqt5core5a  libqt5dbus5  libqt5designer5  libqt5gui5 \
    libqt5help5 libqt5network5 libqt5opengl5 \
    libqt5opengl5-dev libqt5printsupport5 \
    libqt5qml5 libqt5quick5 libqt5script5 libqt5sql5 \
    libqt5sql5-sqlite libqt5svg5 libqt5test5 libqt5webkit5 \
    libqt5widgets5 libqt5xml5 libqt5xmlpatterns5 \
    libqt5xmlpatterns5-dev  python-pyqt5 \
    python-pyqt5.qtsvg python-pyqt5.qtwebkit \
    qt5-qmake qtbase5-dev libqt5xmlpatterns5-dev libxcb-cursor0

Instale o módulo de suporte ao Qt5 no Python:

cd /opt/python-3.9.2/bin
sudo ./pip3 install PyQt5

PySide6

A biblioteca PySide2 está disponível no repositório PyPI, o que torna a instalação quase que trivial (desde que as dependências descritas anteriormente esteja instaladas)::

cd /opt/python-3.9.2/bin
sudo ./pip3 install PySide6

Pacotes opcionais (minha seleção)

Eu costumo utilizar algumas ferramentas desenvolvidas em Python, tanto ferramentas disponíveis na Internet como de minha própria autoria e que precisam de alguns módulos específicos. Então, até para manter uma lista destes módulos e aplicações, segue a lista que eu costumo instalar após a instalação do Python. No entanto, alguns destes módulos possuem dependências que precisam ser instaladas antes:

Módulo	Biblioteca	Comando para instalação
lxml	libxml2-dev, libxslt1-dev	sudo aptitude install libxml2-dev libxslt1-dev
cryptography	libffi-dev	sudo aptitude install libffi-dev
GeoIP	libgeoip-dev, libgeoip-bin	sudo aptitude install libgeoip-dev libgeoip-bin

Quando uso um editor para programação em Python, mais especificamente para o VSCode ou Codium, eu costumo instalar também os seguintes pacotes:

pip install black
pip install pylint
pip install pyright

Para facilitar a vida, podemos criar um arquivo texto contendo todos os módulos e aplicações que desejamos instalar, com um item por linha, conforme a lista a seguir:

alabaster
beautifulsoup4
chardet
cloud-sptheme
cryptography
dnspython3
flake8
Flask
httplib2
imapclient
lxml
matplotlib
netaddr
nose
numpy
oauth2client
oauthlib
paho-mqtt
pandas
paramiko
pdfrw
pep8
psutil
psycopg2
psycopg2-binary
pydbus
pydialog
pygame
PyInstaller
pymongo
pyPdf
pypyodbc
pyserial
python-dateutil
pythondialog
python-magic
pyusb
requests
requests-oauthlib
rsa
scapy
scikit-learn
scipy
shodan
Slowloris
Sphinx
sphinx-bootstrap-theme
sphinxcontrib-disqus
sphinx-intl
sphinxjp.themecore
sphinxjp.themes.htmlslide
sphinxjp.themes.tinkerpress
sphinx-rtd-theme
sqlalchemy
sslscan
Tinkerer
tornado
virustotal2
websockets
Werkzeug
wheel
xlrd

Criado o arquivo, basta solicitar so pip que instale todos os módulos. Por exemplo, supondo que o arquivo com os nomes dos módulos e aplicações seja o arquivo /tmp/requirements.txt, o comando a seguir instalará todos os módulos contidos no arquivo:

cd /opt/python-3.9.2/bin
sudo ./pip3 install -r /tmp/requirements.txt

Um detalhe importante: a instalação a partir de arquivo é muito prática, porém deve-se ficar atento para possíveis erros. Nestes casos, observe as mensagens na tela e corrija os problemas.

PyGame

O pacote PyGame é necessário para uso com Kivy. Normalmente eu instalo diretamente do código fonte, mas nesta versão de Python precisei apenas instalar algumas dependências e depois instalar o PyGame e o Kivy diretamente do PIP.

Eis as dependências:

sudo apt install fonts-freefont-ttf \
     libfreetype6 libjpeg62-turbo libpng16-16 \
     libportmidi0 libsdl-image1.2 libsdl-mixer1.2 \
     libsdl-ttf2.0-0 libsdl1.2debian libflac-dev \
     libmad0-dev libmikmod-config libmikmod-dev \
     libsdl-image1.2-dev libsdl-mixer1.2-dev \
     libsdl-ttf2.0-dev libwebp-dev

A instalação via PIP ocorreu assim:

sudo ./pip3 install pygame

Da mesma forma para o Kivy:

sudo ./pip3 install kivy[base] kivy_examples --pre --extra-index-url https://kivy.org/downloads/simple/

Para testar, execute o seguinte código::

from kivy.app import App
from kivy.uix.button import Button

class TestApp(App):
    def build(self):
        return Button(text='Hello World')

TestApp().run()

Conclusão

Instalar o Python a partir do código-fonte não é uma tarefa difícil, mas trabalhosa. A compilação, caso sejam habilitados os testes, pode demorar bastante dependendo dos recursos computacionais disponíveis. No entanto, esta á uma opção para podermos testar e usar as últimas versões do Python.

Python3: Dicas de Instalação