- Introdução
- Instalação do GNU Emacs
- Instalação de pacotes no GNU Emacs
- Habilitar GNU Emacs para R e Python
- Resumão para o impaciente
- Para Windows e Mac OS
Introdução
O GNU Emacs é um editor de texto extensível, customizável e livre. É desenvolvido pela Free Software Foundation.
Diferente de uma IDE (Integrated Development Environment), como o RStudio para R ou Spyder para Python, o GNU Emacs é um editor geral com o qual se pode trabalhar com várias linguagens de programação de maneira eficiente e uniforme em um único editor. Ou seja, caso você precise trabalhar com várias linguagens, pode-se usar o GNU Emacs ao invés de aprender várias IDE separadas.
Além da vasta capacidade de edição de linguagens, o Emacs permite
- edição remota de arquivos (TRAMP),
- operações em diretórios (DirEd),
- monitorar processos no sistema operacional (proced),
- usar sistemas de controle de versão (Magit) e
- trabalhar como cliente de banco de dados.
Estamos apenas citando algumas funcionalidades.
Isso faz do GNU Emacs uma excelente opção para Cientista de Dados.
A comunidade do GNU Emacs é grande e ativa. Estes usuários desenvolvem funcionalidades únicas para esse editor e também implementam recursos interessantes de outros editores, como a navegação de página do Sublime e navegação de árvore de diretório disponível em muitas IDE.
Esse documento contém o passo a passo para instalar o Emacs e habilitá-lo para trabalhar com scripts R e Python. Nele é detalhado o processo de instalação para distribuições Ubuntu e Linux Mint. O Ubuntu utilizado foi o 16.04 LTS e versão do Emacs atual para ele é a 24.5.1.
Para instalar no Windows ou Mac OS, pule para a última seção e leia o restante apenas se precisar habilitar o Python.
Caso queira mais funcionalidades do que as consideradas nesse guia, estude o repositório: https://github.com/walmes/emacs.
Instalação do GNU Emacs
A instalação do GNU Emacs pode ser feita de duas formas: i) gráfica pelo gerenciados de pacotes (Synaptic Package Manager) ou 2) via comandos no Terminal do GNU Linux. Se você preferir a primeira opção, lembre-se de instalar o Synaptic pela Central de Software ou direto via Terminal executando sudo apt-get install synaptic
. Se preferir a segunda opção, pule para instalação pelo Terminal.
Pelo Synaptic
Abra o Synaptic pelo Dash do Ubuntu (exemplo na Figura 4). Clique em Search (1) e então busque por emacs
na caixa de dialógo (2) que abrir. Verifique se nos resultados irão aparecer o emacs
e emacs-goodies-el
. Verifique se as versões são as mesmas, pois elas podem ser mais atuais, o que não é um problema.

Figura 1: Tela do Synaptic fazendo a busca por emacs
. Os resultados exibem emacs
, emacs-goodies-el
e outros começando com emacs24
.
Clique com o botão direito do mouse sobre o emacs
(1) e marque para instalação completa. Faça o mesmo com o emacs-goodies-el
(2). Perceba que os itens que começam com emacs24
ficarão todos marcados quando marcar emacs
. Isso porque emacs
representa essa coleção de componentes. Para cada um deles é possível verificar, no espaço inferior, quais são os pacotes/bibliotecas instaladas (3). Por fim, quando todos os itens necessários estiverem marcados, faça a instalação clicando em Apply na barra de tarefas (4).

Figura 2: Tela do Synaptic destacando os componentes marcados para instalação. No espaço inferior tem-se os pacotes/bibliotecas que são instalados com a marcação de cada item.
Quando pressionar Apply uma caixa de diálogo irá mostrar a relação de componentes a serem instalados e o espaço em disco necessário. Na sequência, irá abrir a caixa exibindo o progresso da instalação.

Figura 3: Tela do Synaptic com os componentes que serão instalados e o espaço em disco ocupado (topo) e progresso da instalação (base).
Assim que a instalação concluir, a caixa irá fechar e pronto: o GNU Emacs está instalado no seu Ubuntu. Procure o GNU Emacs no Ubuntu Dash. Selecione o GNU Emacs GUI, pois o GNU Emacs Terminal, como o nome sugere, é uma instância do GNU Emacs no Terminal. As funcionalidades do GNU Emacs GUI são maiores. O GNU Emacs Terminal é mais usado por/para acesso remoto, por exemplo.

Figura 4: Resultado da busca por GNU Emacs no Ubuntu Dash.

Figura 5: Tela de boas vindas do GNU Emacs (1). Essa tela dá acessa a tutorial e guias sobre o GNU Emacs (2). Também possibilita abrir arquivos e customizar o editor (3). Explore o conteúdo da barra de menus para se ambientar (4). A versão do GNU Emacs é exibida como informação final. O minibuffer (6) permite acessar a documentação do editor a qualquer momento.
Pelo Terminal
A instalação do GNU Emacs pelo Terminal é bem mais simples e direta. Guarde esses comandos para instalar de maneira rápida e assertiva o GNU Emacs em outras ocasiões. Trata-se de apenas executar uma linha de comandos no Terminal:
1 |
sudo apt-get install emacs emacs-goodies-el |
O Terminal irá exibir os componentes a serem instalados e o espaço em disco necessário, ou seja, as mesmas informações vistas nas janelas do Synaptic. Pressione ENTER para instalar.

Figura 6: Tela do Terminal com a instrução para instalar o GNU Emacs (1), os componentes da instalação (2) e o espaço em disco necessário (3).
Instalação de pacotes no GNU Emacs
Com a instalação do GNU Emacs e o emacs-goodies-el
, já se pode editar vários tipos de arquivos com apropriado suporte pelo editor. No entanto, o GNU Emacs contém uma gigantesca biblioteca de pacotes (ou plugins, se preferir) que habilitam recursos gerais e específicos. Existem pacotes para se trabalhar com arquivos de linguagens como C, C++, Shell, Java, HTML, CSS, JavaScript, SQL, LaTeX, Markdown, SAS, JSON, e obviamente R e Python que são o nosso interesse aqui.
A instalação de pacotes no GNU Emacs também pode ser feita de duas formas: 1) de maneira gráfica pelo gerenciador de pacotes do próprio editor ou 2) por execução de comandos LISP no GNU Emacs.

Figura 7: Acesse o gerenciador de pacotes pelo menu Options > Manage Emacs Packages
.
Antes de fazermos a instalação propriamente, vamos explorar a coleção de pacotes disponíveis no repositório oficial do GNU Emacs, o ELPA (GNU Emacs Lips Package Archive). Se estiver com pressa, pule para a instalação.

Figura 8: Alguns dos pacotes disponíveis no repositório de pacotes oficial do GNU Emacs. Os pacotes built-in
já estão instalados. O GNU Emacs já vem com suporte nativo para Shell, SQL, JavaScript, JSON e tem um o jogo de Tetris embutido para descontração. Não é preciso sair do GNU Emacs para dar uma jogadinha.
O GNU Emacs tem outros repositórios de pacotes além do ELPA, que é o oficial. O MELPA (Milkypostman’s Emacs Lisp Package Archive) é o mais utilizado e contém bem mais pacotes que o ELPA. Para ter acesso ao conteúdo desse repositório, é necessário adicioná-lo a lista de arquivos de pacotes (ou repositórios) do editor. Para isso, deve ser criado o arquivo .emacs
(caso ainda não exista).
Execute o atalho C-x C-f
(significa Ctrol + x
seguido de Ctrol + f
na convenção GNU Emacs). O minubuffer irá abrir um diálogo para que seja informado o caminho para o arquivo. O arquivo .emacs
fica na home do usuário, pontanto o caminho para ele é ~/.emacs
.
O arquivo .emacs
pode ser criado e editado por qualquer editor de texto. Então, se preferir, abra no editor que está mais acostumado para fazer as modificações documenadas aqui.

Figura 9: Dialógo no minibuffer do GNU Emacs com o caminho para o arquivo de configuração .emacs
. Pressione ENTER (que é RET na terminologia do GNU Emacs) para abrir o arquivo.
O arquivo será criado vazio se não existir até então. Caso queira, ao invés de usar a tecla de atalho, utilize o menu File > Visit New File
ou clique no primeiro ícone da esquerda (um documento com sinal de + no canto). Note que algumas entradas de menu tem a correspondente tecla de atalho escrita do lado direito.

Figura 10: Menu File
do GNU Emacs. Dá acesso para ações de abrir arquivos e outras ações. A tecla de atalho associada a cada ação é exibida do lado direito. O emprego delas deixa muito mais ágil o uso de qualquer editor.
Dentro do arquivo é informado o endereço dos repositórios para instalação de pacotes. O MELPA possui dois repositórios. O MELPA estável (https://stable.melpa.org/) tem menos pacotes (no caso 1945 pacotes) e assume-se que estão livres de bugs, etc. O MELPA (https://melpa.org/) que tem mais pacotes (no caso 3828 pacotes) é a caixa de entrada das contribuições e pode ter pacotes com bugs ainda não descobertos/resolvidos. É opcional de onde se irá instalar os pacotes. É conservador usar o MELPA estável mas os pacotes no MELPA tradicional estão com versões mais recentes e, portanto, com mais funcionalidades. Utilize o código do bloco de código após a 11.

Figura 11: Arquivo .emacs
com o a instrução para adicionar o repositório MELPA à lista de arquivos de pacotes. No GNU Emacs os comentários são precedidos de ;
.
1 2 3 4 5 6 7 8 9 10 11 12 13 |
;;---------------------------------------------------------------------- ;; Pacotes. (require 'package) (package-initialize) ;; (add-to-list 'package-archives ;; '("melpa-stable" . "https://stable.melpa.org/packages/") t) (add-to-list 'package-archives '("melpa" . "https://melpa.org/packages/") t) ;;---------------------------------------------------------------------- |
Agora que o MELPA foi adicionado à lista de arquivos de pacotes, é necessário carregar o arquivo .emacs
para que as modificações sejam aplicadas. Para isso pressione M-x
(que é Alt + x
na convenção do GNU Emacs) e escreva load-file
, pressione ENTER, dê o caminho ~/.emacs
e pressione ENTER novamente. Pronto.
Você irá encontrar instruções como essa acima escritas assim pela WEB:
1 |
M-x load-file RET `~/.emacs` RET |
Na convenção GNU Emacs RET
é ENTER
, M
é Alt
, C
é Ctrol
. A razão por trás dessa convenção é histórica e não vem ao caso. Porém, acostume-se com esse padrão porque é o que predomina em forúns sobre o GNU Emacs, além de ser o padrão da documentação interna e online do editor.
Caso prefira, uma forma equivalente de carregar o arquivo .emacs
é fechar e abrir o GNU Emacs. Sempre que ele abrir, irá carregar o arquivo .emacs
.

Figura 12: Carregando o arquivo .emacs
para que as modificações sejam aplicadas.
Agora que o repositório do MELPA foi adicionado à lista do GNU Emacs, podemos instalar os pacotes que precisamos: ESS para R e Elpy para Python.
O ESS significa Emacs Speaks Statistics. Ele dá suporte para se trabalhar com linguagens de programação de Estatística (R, S-Plus, SAS, Stata and OpenBUGS/JAGS) em vários sistemas operacionais.
O Elpy é o pacote que dá o ambiente de desenvolvimento para Python no Emacs.
Com o gerenciador de pacotes
Para abrir o gerenciados de pacotes você pode ir pelo menu Options > Manage Emacs Packages
conforme ilustra a figura 7. Ou escreva no minibfer:
1 |
M-x package-list-packages RET |
Os pacotes encontrados nos repositórios serão exibidos em ordem alfabética. Percorra o buffer usando seta para cima e para baixo. Com o cursor na linha do pacote que deseja instalar pressione a tecla i
para marcá-lo para instalação. Quando todos os pacotes estiverem marcados, pressione x
para executar a instalação. O minibuffer vai mostrar o progresso da instalação. Aguarde até que termine.

Figura 13: Os pacotes ess
e elpy
marcados para instalação (note o I
na borda esquerda). Neste exemplo, ambos serão instalados do MELPA estável.

Figura 14: O minibuffer pede para confirmar a instalação dos pacotes. Após a instalação o minibuffer informa a quantidade de arquivos compilados e diretórios.
Como já foi comentado, o GNU Emacs possui uma gigantesca biblioteca de pacotes. Percorra o buffer lendo a descrição de cada um. Para mais detalhes sobre, consulte a documentação online dos pacotes no MELPA.

Figura 15: Uma lista de pacotes interessantes para o GNU Emacs.
Depois que os pacotes forem instalados, diretórios para cada um deles (e pacotes dos quais dependem) serão criados em ~/.emacs.d/elpa/
. Após o nome do pacote tem uma sequência numérica que corresponde a sua versão. Esteja atento a versão que está usando de cada pacote sempre que se deparar com alguma infuncionalidade/bug/problema. Instale a versão mais recente, caso exista. Veja a figura 22 como exemplo.
Com comandos em LISP
A instalação por comandos é bem mais direta e reproduzível. Se você guardar as instruções irá instalar os esses e novos pacotes rapidamente sempre que precisar.
Uma forma de instalar é via minibuffer conforme exemplificado abaixo:
1 |
M-x package-install RET <package_name> |

Uma forma mais conveniente é criar um arquivo de extensão .el
, por exemplo pacotes.el
, que contenha a instrução em LISP para instalar os pacotes:
1 2 |
(package-install 'ess) (package-install 'elpy) |
Abra o arquivo no GNU Emacs e com o cursos posicionado no final de cada linha pressione o atalho C-c C-e
. Esse atalho envia para o interpretador LISP essa expressão e o pacote será instalado. Aguarde até a instalação concluir e vá para o próximo pacote. É possivel serializar a instalação dos pacotes, veja um exemplo aqui: https://oremacs.com/2015/03/20/managing-emacs-packages/.
Também é possível fazer a instalação pelo Terminal chamando um script LISP. Considere que o conteúdo abaixo esteja no arquivo emacs-packs.el
.
1 2 3 4 5 6 7 8 9 10 11 12 13 |
;; Arquivo: emacs-packs.el. -------------------------------------------- (require 'package) (package-initialize) (add-to-list 'package-archives '("melpa" . "https://melpa.org/packages/") t) (package-list-packages) (package-install 'bm) ;;---------------------------------------------------------------------- |
Abra o terminal e escreva a instrução dando o caminho para o arquivo:
1 |
emacs --script emacs-packs.el |
Neste exemplo está sendo instalado o pacote bm
que permite marcar linhas dentro do arquivo para facilmente saltar entre as posições marcadas.
Habilitar GNU Emacs para R e Python
Para completar, é necessário chamar os pacotes e fazer alguns ajustes finos. Nessa customização será adicionado a funcionalidade de auto complete, que ajuda muito no desenvolvimento de scripts de R e Python.
O auto complete é em recurso genérico que funciona até mesmo no buffer fundamental, ou seja, na edição de um arquivo .txt
. Quando você começar a escrever uma palavra, o auto complete vai sugerir completar com palavras similares próximas ao seu ponto de edição. Para R e Python, o auto complete sugere nomes de funções e métodos, além de nomes de objetos presentes no arquivo. Se você é pouco experiente nessas liguagens, o auto complete irá auxiliá-lo nas descobertas.
Para instalar o auto-complete
, execute:
1 |
M-x package-install RET auto-complete RET |
Como visto, você pode manter em um arquivo .el
a instrução LISP abaixo e enviá-la para o interpretador com C-c C-e
.
1 |
(package-install 'auto-complete) |
Depois de instalar o auto-complete
, adicione o bloco a seguir no arquivo .emacs
para habilitar o recurso. Para saber mais sobre o auto complete, visite: https://www.emacswiki.org/emacs/AutoComplete e https://github.com/auto-complete.
1 2 3 4 5 |
;;---------------------------------------------------------------------- ;; Habilitar auto-complete. (require 'auto-complete-config) (ac-config-default) |
Para scripts Python
A instalação do elpy
já foi descrita. O caminho para interpretador Python é informado alterando a variável de ambiente python-shell-interpreter
.
Para ter o recurso de auto completar é preciso instalar o jedi
e jedi-core
. Eles dependem do virtualenv
que é instalado via Terminal. Os comentários dentro do bloco a seguir contém as instruções para instalá-los.

Figura 16: Terminal com a instalação do virtualenv
.

Figura 17: Versões disponíveis do jedi
e jedi-core
no MELPA e MELPA estável.
1 2 3 4 5 6 7 8 9 10 11 12 13 |
;;---------------------------------------------------------------------- ;; Habilitar Python. (elpy-enable) (setq python-shell-interpreter "/usr/bin/python3") ;; Seguir: http://tkf.github.io/emacs-jedi/latest/ ;; Terminal : sudo apt-get install virtualenv ;; Emacs : M-x package-install RET jedi RET ;; Emacs : M-x jedi:install-server RET (add-hook 'python-mode-hook 'jedi:setup) (setq jedi:complete-on-dot t) |
Para começar, apenas memorize as teclas de atalho a seguir:
C-RET
: envia um linha de código por vez para o interpretador/console e move o cursor para a próxima linha.C-c C-c
: envia o conteúdo de uma região com texto selecionado para o interpretador/console. Se nada estiver selecionado, é enviado o conteúdo do buffer inteiro.

Figura 18: GNU Emacs no modo de edição para scripts Python. O menu do editor contém entradas próprias para ações relacionadas ao Python (1 e 2). O major-mode de edição do arquivo é Python (3) e o console inferior está com o intepretador Python especificado no .emacs
.

Figura 19: GNU Emacs com auto complete habilitado para Python. Após o ponto abre-se um popup com sugestões de métodos para o objeto (1). O elpy
e auto-complete
estão ativos como minor-modes.
Para scripts R
Para habilitar a edição de scripts R, basta adicionar o conteúdo abaixo ao .emacs
. Essa é a configuração mais minimalista possível. Ganhe experiência primeiro para depois fazer personalização fina nas opções.
1 2 3 4 5 6 7 8 9 |
;;---------------------------------------------------------------------- ;; Habilitar R. ;; ESS - Emacs Speaks Statistics. ;; http://ess.r-project.org/ ;; http://members.cbio.mines-paristech.fr/~thocking/primer.html (require 'ess-eldoc) (setq-default ess-dialect "R") |
Para começar, apenas memorize as teclas de atalho a seguir:
C-RET
eC-c C-n
: enviam um linha de código por vez para o interpretador/console e movem o cursor para a próxima linha.C-c C-c
eC-c C-p
: enviam um parágrafo de código por vez para o interpretador e movem o cursor para o próximo parágrafo.

Figura 20: GNU Emacs no modo de edição para scripts R. O menu do editor contém entradas próprias para ações relacionadas ao R via o ESS (1). O major-mode de edição do arquivo é o ess-mode
e o console inferior está com R. O minibuffer mostra os primeiros argumentos de uma função quando o cursor está no espaço dos argumentos.

Figura 21: GNU Emacs com auto complete habilitado para R. Após dois caracteres o abre um popup com sugestões texto. A documentação é exibida se o objeto estiver documentado.
Resumão para o impaciente
Se você já tem experiência e quer rapidamente instalar e configurar o Emacs, siga os passos a seguir.
-
Instale o GNU Emacs pelo terminal:
1sudo apt-get install emacs emacs-goodies-el virtualenv -
Crie o arquivo
emacs-packs.el
com o seguinte conteúdo:1234567891011121314151617;; Arquivo: emacs-packs.el. --------------------------------------------(require 'package)(package-initialize)(add-to-list 'package-archives'("melpa" . "https://melpa.org/packages/") t)(package-list-packages)(package-install 'ess)(package-install 'elpy)(package-install 'auto-complete)(package-install 'jedi)(package-install 'jedi-core);;---------------------------------------------------------------------- -
Faça a instalação dos pacotes pelo terminal:
1emacs --script emacs-packs.el -
Adicione no
~/.emacs
o conteúdo para que fique assim:12345678910111213141516171819202122232425262728293031323334353637383940;;----------------------------------------------------------------------;; Pacotes.(require 'package)(package-initialize)(add-to-list 'package-archives'("melpa" . "https://melpa.org/packages/") t);;----------------------------------------------------------------------;; Habilitar auto-complete.(require 'auto-complete-config)(ac-config-default);;----------------------------------------------------------------------;; Habilitar Python.(elpy-enable)(setq python-shell-interpreter "/usr/bin/python3");; Seguir: http://tkf.github.io/emacs-jedi/latest/;; Terminal : sudo apt-get install virtualenv;; Emacs : M-x package-install RET jedi RET;; Emacs : M-x jedi:install-server RET(add-hook 'python-mode-hook 'jedi:setup)(setq jedi:complete-on-dot t);;----------------------------------------------------------------------;; Habilitar R.;; ESS - Emacs Speaks Statistics.;; http://ess.r-project.org/;; http://members.cbio.mines-paristech.fr/~thocking/primer.html(require 'ess-eldoc)(setq-default ess-dialect "R");;---------------------------------------------------------------------- -
A primeira vez que abrir o GNU Emacs, termine a instalação do
jedi
executando:1M-x jedi:install-server RET
Após instalar todos os componentes, o diretório ~/.emacs.d/elpa/
deverá ter o seguinte conteúdo (a menos das versões dos pacotes).

Figura 22: Lista de pacotes instalados para habilitar R e Python no GNU Emacs.
Agora o GNU Emacs está habilitado para trabalhar com o R e Python.
Para Windows e Mac OS
Para Windows e Mac OS é recomendado instalar o Emacs disponibilizado por Vicent Goulet. Na página dele estão versões para Mac OS e Windows. No entanto, de acordo com a descrição, o Python não vem habilitado nelas. Dessa forma, siga as mesmas etapas de instalação indicadas acima usando o gerenciador de pacotes do GNU Emacs.