Python (Português)

From ArchWiki
Status de tradução: Esse artigo é uma tradução de Python. Data da última tradução: 2020-06-21. Você pode ajudar a sincronizar a tradução, se houver alterações na versão em inglês.

Artigos relacionados

Do Wikipédia:

Python é uma linguagem de programação dinâmica de alto nível, de propósito geral, interpretada e amplamente usada. Sua filosofia de design enfatiza a legibilidade do código e sua sintaxe permite que os programadores expressem conceitos em menos linhas de código do que o possível em linguagens como C++ ou Java. A linguagem fornece construções destinadas a permitir a gravação de programas claros em pequena e grande escala.
Python possui suporte a vários paradigmas de programação, incluindo programação orientada a objetos, programação imperativa e funcional ou estilos de procedimentos. Possui um sistema de tipo dinâmico e gerenciamento automático de memória e possui uma biblioteca padrão ampla e abrangente.

Instalação

Python 3

Python 3 é a versão mais recente da linguagem e é incompatível com o Python 2. A linguagem é basicamente a mesma, mas muitos detalhes, especialmente como objetos embutidos como dicionários e strings funcionam, mudaram consideravelmente e muitos recursos descontinuados finalmente foram removidos. Além disso, a biblioteca padrão foi reorganizada em alguns lugares de destaque. Para uma visão geral das diferenças, visite Python2orPython3 e os capítulos relevantes no Dive into Python 3.

Para instalar a versão mais recente do Python 3, instale o pacote python.

Se você deseja criar os candidatos a lançamento(RC) ou betas mais recentes a partir do código-fonte, visite Python Downloads. O Arch User Repository também contém bons PKGBUILDs. Se você decidir compilar o RC, observe que o binário (por padrão) é instalado em /usr/local/bin/python3.x. Como alternativa que não requer permissões de superusuário e instala no diretório pessoal do usuário, considere usar pyenv.

Python 2

Atenção: O Python 2 chegou ao fim de sua vida útil em 1º de janeiro de 2020. Muitos pacotes ainda dependem do Python 2, mas essa versão do Python não será mais mantida. Veja: Sunsetting Python 2

Para obter a versão mais recente do Python 2, instale o pacote python2AUR.

O Python 2 será executado felizmente ao lado do Python 3. Você precisa especificar python2 para executar esta versão.

Qualquer programa que exija o Python 2 precisa apontar para /usr/bin/python2, em vez de /usr/bin/python, que aponta para o Python 3. Para fazer isso, abra o programa ou script em um editor de texto e altere a primeira linha. A linha mostrará um dos seguintes: 

#!/usr/bin/env python

ou 

#!/usr/bin/python

Nos dois casos, basta alterar python para python2 e o programa usará o Python 2 em vez do Python 3.

Outra maneira de forçar o uso de python2 sem alterar os scripts é chamá-lo explicitamente com python2: 

$ python2 meuScript.py

Por fim, talvez você não consiga controlar as chamadas de script, mas existe uma maneira de enganar o ambiente. Funciona apenas se os scripts usarem #!/usr/bin/env python. Não funcionará com #!/usr/bin/python. Esse truque se baseia na pesquisa do env na primeira entrada correspondente na variável PATH.

Primeiro, crie uma pasta: 

$ mkdir ~/bin

Em seguida, adicione um link simbólico python para python2 e os scripts de configuração: 

$ ln -s /usr/bin/python2 ~/bin/python
$ ln -s /usr/bin/python2-config ~/bin/python-config

Por fim, coloque a nova pasta no início da sua variável PATH: 

$ export PATH=~/bin:$PATH
Nota: Esse método de alterar variáveis de ambiente não é permanente e está ativo apenas na sessão atual do terminal.

Para verificar qual interpretador Python está sendo usado por env, use o seguinte comando: 

$ which python

Uma abordagem semelhante ao enganar o ambiente, que também depende de #!/usr/bin/env python a ser chamada pelo script em questão, é usar um #Ambiente virtual.

Implementações alternativas

As seções acima se referem à implementação de referência do Python, chamada de CPython. No entanto, também existem outras implementações disponíveis - as mais populares:

  • PyPy é uma implementação Python 2.7/3.6 utilizando um compilador JIT. Geralmente é mais rápido e usa menos memória, mas não é totalmente compatível com o CPython (embora a maioria dos pacotes e códigos funcione sem alterações).
  • Jython é uma implementação do Python 2.7 construída em Java. Permite fácil integração do código Python e Java, mas não é totalmente compatível com as bibliotecas do CPython. É frequentemente usado para fornecer Python como uma linguagem de script em um aplicativo Java maior.
  • IronPython é uma implementação do Python 2.7 construída em .NET - atinge os mesmos objetivos que o Jython, mas para linguagens .NET (como C#/VB).
  • MicroPython é uma implementação limitada do Python 3.4 direcionada a microcontroladores e outros ambientes incorporados (como UEFI), mas é incompatível com a maioria dos pacotes padrão devido a mudanças menores de sintaxe e biblioteca padrão severamente limitada. É frequentemente usado para criação de protótipos em ambientes incorporados (pois fornece um Python REPL).
  • Mais implementações estão disponíveis, embora a maioria não seja mais mantida devido a melhorias nas mais populares.

Versões antigas

Atenção: As versões do Python anteriores ao 2.7 não recebem mais atualização — incluindo patches de segurança — desde pelo menos 2014. O uso de versões mais antigas para aplicações da Internet ou código não confiável pode ser perigoso e não é recomendado.

As versões antigas do Python estão disponíveis no AUR e podem ser úteis para curiosidade histórica, aplicativos antigos que não são executados nas versões atuais ou para testar programas Python destinados a serem executados em uma distribuição que vem com uma versão mais antiga:

Módulos/bibliotecas extras para versões antigas do Python podem ser encontrados no AUR pesquisando python<versão sem ponto>, por exemplo procurando por "python26" para módulos 2.6.

Gerenciamento de pacotes

Embora um grande número de pacotes Python esteja prontamente disponível nos repositórios oficiais e no AUR, o ecossistema Python fornece seus próprios gerenciadores de pacotes para uso com PyPI, o Índice de Pacotes Python:

  • pip — A ferramenta do PyPA para instalar pacotes Python.
https://pip.pypa.io/ || python-pip, python2-pipAUR
  • setuptools — Baixe, construa, instale, atualize e desinstale facilmente pacotes Python.
https://setuptools.readthedocs.io/ || python-setuptools, python2-setuptoolsAUR

Para um breve histórico e comparação de recursos entre os dois, consulte pip vs easy_install. As melhores práticas de autoridade no gerenciamento de pacotes Python são detalhadas aqui.

Se você precisa usar pip, use um ambiente virtual ou pip install --user para evitar conflitos com pacotes em /usr. É sempre preferível usar o pacman para instalar softwares.

Nota: Também existem ferramentas que integram pip com pacman, gerando automaticamente PKGBUILDs para pacotes pip especificados: consulte Criando pacotes#Geradores de PKGBUILD.
Dica: pipenv fornece uma única CLI para Pipfile, pip e virtualenv. Ele está disponível como python-pipenv.

Ligações de widget

As seguintes ligações para toolkit de widget estão disponíveis:

  • TkInter — Ligações para Tk
https://wiki.python.org/moin/TkInter || módulo padrão
  • pyQt — Ligações para Qt
https://riverbankcomputing.com/software/pyqt/intro || python2-pyqt4AUR python2-pyqt5[link quebrado: package not found] python-pyqt4AUR python-pyqt5
  • pySide2 — Ligações para Qt
https://wiki.qt.io/PySide2 || pyside2AUR pyside2-toolsAUR
  • pyGTK — Ligações para GTK 2
http://www.pygtk.org/ || pygtkAUR
  • PyGObject — Ligações para GTK 2/3 via GObject Introspection
https://wiki.gnome.org/PyGObject/ || python2-gobject2AUR python2-gobjectAUR python-gobject
  • wxPython — Ligações para wxWidgets
https://wxpython.org/ || python2-wxpython3AUR python-wxpython

Para usá-los com o Python, pode ser necessário instalar os kits de widgets associados.

Dicas e truques

Shells alternativos

  • bpython — Interface sofisticada para o interpretador Python.
https://bpython-interpreter.org/ || bpython bpython2AUR[link quebrado: package not found]
  • IPython — Shell Python interativo aprimorado.
https://ipython.org/ || ipython ipython2AUR[link quebrado: package not found]
  • Jupyter Notebook — Interface web para o IPython.
https://jupyter.org/ || jupyter-notebook
  • ptpython — Interface sofisticada para o interpretador Python baseada na interface de entrada prompt-toolkit.
https://github.com/jonathanslenders/ptpython || ptpythonAUR

Ambiente virtual

O Python fornece ferramentas para criar ambientes isolados nos quais você pode instalar pacotes sem interferir nos outros ambientes virtuais nem nos pacotes do sistema Python. Pode mudar o interpretador python usado para um aplicativo específica.

Veja Python/Virtual environment para detalhes.

Conclusão com Tab no shell do Python

Desde o Python 3.4, conclusão com Tab está ativado por padrão, no Python 2 você pode ativá-lo manualmente adicionando as seguintes linhas a um arquivo referenciado pela variável de ambiente PYTHONSTARTUP: [1] 

import rlcompleter
import readline
readline.parse_and_bind("tab: complete")

Observe que o programa de conclusão "readline" só concluirá nomes no espaço para nomes global. Você pode recorrer ao python-jedi para obter uma experiência mais completa de conclusão com Tab [2].

Solução de problemas

Lidando com problema de versão em scripts de compilação

This article or section needs language, wiki syntax or style improvements. See Help:Style for reference.

Reason: Este é um truque feio; em vez disso, explique como corrigir recursivamente shebangs com find e sed. (Discuss in talk:Python)

Muitos scripts de compilação de projetos supõem que python seja Python 2, e isso acabaria resultando em um erro — normalmente reclamando que print 'foo' é uma sintaxe inválida. Felizmente, muitos deles chamam python a partir da variável de ambiente PATH em vez de codificar #!/usr/bin/python na linha shebang, e os scripts Python são todos contido na árvore do projeto. Portanto, em vez de modificar os scripts de construção manualmente, há uma solução alternativa. Crie /usr/local/bin/python com conteúdo como este: 

/usr/local/bin/python
#!/bin/bash
script=$(readlink -f -- "$1")
case "$script" in (/caminho/para/projeto1/*|/caminho/para/projeto2/*|/path/to/project3*)
    exec python2 "$@"
    ;;
esac

exec python3 "$@"

sendo /path/to/project1/*|/path/to/project2/*|/path/to/project3* uma lista de padrões separados por | correspondendo a todas as árvores do projeto. Para alguns scripts, o caminho pode não ser o primeiro parâmetro. Por exemplo, o Google SDK envia -S como o primeiro parâmetro. O comando readlink deve mudar para script=$(readlink -f -- "$1").

Não se esqueça de torná-lo executável. Posteriormente, os scripts nas árvores de projeto especificadas serão executados com o Python 2.

Veja também