Changes python section, deletes sections about emacs configuration

una
Sergio Alvariño 4 years ago
parent 649be3b749
commit 54783fd015

@ -1060,100 +1060,48 @@ No te olvides de compilar también el *Project Generator*.
## Python
De partida tenemos instalado dos versiones: *python* y *python3*
De partida tenemos instalado dos versiones: *python2* y *python3*
``` {bash}
python -V
Python 2.7.12
python3 -V
Python 3.5.2
```
### Paquetes de desarrollo
Para que no haya problemas a la hora de instalar paquetes en el futuro
conviene que instalemos los paquetes de desarrollo:
sudo apt install python-dev
sudo apt install python3-dev
### pip, virtualenv, virtualenvwrapper, virtualfish
Parece que Linux Mint no viene con nigún python por defecto. Si
invocamos el comando `python` el sistema nos indicará que no existe.
Los he instalado a nivel de sistema.
Para escoger un python por defecto tenemos dos paquetes que podemos
instalar: `python-is-python2` y `python-is-python3`
*pip* es un gestor de paquetes para **Python** que facilita la
instalación de librerías y utilidades.
Para poder usar los entornos virtuales instalaremos también
*virtualenv*.
Instalamos los dos desde aptitude:
En principio yo no quería instalar ninguno para averigüar que paquetes
no funcionaban, pero la instalación de VirtualBox hizo que se instalara
automáticamente el paquete `python-is-python2`.
``` {bash}
sudo apt install python-pip python-virtualenv virtualenv python3-pip
```
*virtualenv* es una herramienta imprescindible en Python, pero da un
poco de trabajo, así que se han desarrollado algunos frontends para
simplificar su uso, para *bash* y *zsh* usaremos *virtualenvwrapper*, y
para *fish* el *virtualfish*. Como veremos son todos muy parecidos.
Instalamos el virtualwrapper:
``` {bash}
sudo apt install virtualenvwrapper -y
```
Para usar *virtualenvwrapper* tenemos que hacer:
python2 -V
Python 2.7.18rc1
``` {bash}
source /usr/share/virtualenvwrapper/virtualenvwrapper.sh
python3 -V
Python 3.8.2
```
O añadir esa linea a nuestros ficheros *.bashrc* y/o *.zshrc*
Definimos la variable de entorno *WORKON\_HOME* para que apunte al
directorio por defecto, `~/.local/share/virtualenvs`. En ese directorio
es donde se guardarán nuestros entornos virtuales.
En el fichero `.profile` añadimos:
# WORKON_HOME for virtualenvwrapper
if [ -d "$HOME/.local/share/virtualenvs" ] ; then
WORKON_HOME="$HOME/.local/share/virtualenvs"
fi
[Aquí](http://virtualenvwrapper.readthedocs.io/en/latest/command_ref.html)
tenemos la referencia de comandos de *virtualenvwrapper*
Por último, si queremos tener utilidades parecidas en nuestro *fish
shell* instalamos *virtualfish*:
### Paquetes de python instalados
``` {bash}
sudo pip install virtualfish
```
[Aquí](http://virtualfish.readthedocs.io/en/latest/index.html) tenemos
la documentación de *virtualfish* y la descripción de todos los comandos
y plugins disponibles.
Son los que ya comentamos en la sección de instalación de zsh, como ya
dijimos conviene que instalemos los paquetes de desarrollo:
### pipenv
sudo apt install python2-dev
sudo apt install python-all-dev
sudo apt install python3-dev
sudo apt install python3-all-dev
sudo apt install virtualenv virtualenvwrapper python3-virtualenv
No lo he instalado, pero en caso de instalación mejor lo instalamos a
nivel de usuario con:
Ademas añadimos las siguientes lineas al fichero `~/.profile`:
``` {bash}
pip install --user pipenv
``` {bash{
# WORKON_HOME for virtualenvwrapper
if [ -d "$HOME/.virtualenvs" ] ; then
WORKON_HOME="$HOME/.virtualenvs"
fi
```
### Instalación del Python 3.8 (última disponible)
Ejecutamos:
``` {bash}
sudo apt install python3.8 python3.8-dev python3.8-venv
```
[Aquí](https://virtualenvwrapper.readthedocs.io/en/latest/command_ref.html)
tenemos la referencia de comandos de *virtualenvwrapper*.
### Instalación de bpython y ptpython
@ -1163,89 +1111,6 @@ sudo apt install python3.8 python3.8-dev python3.8-venv
[*ptpython*](https://github.com/prompt-toolkit/ptpython) instalado en un
virtualenv para probarlo
### Emacs para programar python
#### elpy: Emacs Python Development Enviroment
Para instalar `elpy` necesitamos intalar previamente *venv* el nuevo
gestor de *virtualenvs* en Python 3.:
sudo apt install python3-venv
En el fichero `~/.emacs` necesitamos activar el módulo *elpy*:
``` {lisp}
;;----------------------------------------------------------------------
;; elpy
(elpy-enable)
```
En cuanto activemos *elpy* tendremos autocompletado del código y errores
sintácticos. Merece la pena leerse toda la
[documentación](https://elpy.readthedocs.io/en/latest/)
#### Flycheck
Para tener análisis sintáctico en tiempo real mientras estamos
programando:
Añadimos a nuestro fichero `~/.emacs`:
;; Enable Flycheck
(when (require 'flycheck nil t)
(setq elpy-modules (delq 'elpy-module-flymake elpy-modules))
(add-hook 'elpy-mode-hook 'flycheck-mode))
#### Formateado
Usando *autopep8* o *black* tendremos autoformateado del código como
paso previo a salvar el mismo en disco. (Yo aún no he probado *black*)
# and autopep8 for automatic PEP8 formatting
sudo apt install python-autopep8
# and yapf for code formatting (innecesario)
# sudo apt install yapf yapf3
Y añadimos la sección siguiente a nuestro fichero `~/.emacs`
``` {lisp}
;; Enable autopep8
(require 'py-autopep8)
(add-hook 'elpy-mode-hook 'py-autopep8-enable-on-save)
```
#### jedi
Jedi le da ciertos superpoderes al autocompletado visualizando la
documentación de cada propuesta de autocompletado.
Instalamos previamente:
``` {bash}
sudo apt install python-jedi python3-jedi
# flake8 for code checks
sudo apt install flake8 python-flake8 python3-flake8
```
Y añadimos la sección en el fichero `~/.emacs`:
``` {lisp}
;;----------------------------------------------------------------------
;; elpy
(elpy-enable)
(setq elpy-rpc-backend "jedi")
(add-hook 'python-mode-hook 'jedi:setup)
(setq jedi:complete-on-dot t)
```
Desde *Emacs* ejecutamos: `alt-x jedi:install-server`
### Jupyter
Una instalación para pruebas.

@ -922,165 +922,48 @@ No te olvides de compilar también el //Project Generator//.
===== Python =====
De partida tenemos instalado dos versiones: //python// y //python3//
De partida tenemos instalado dos versiones: //python2// y //python3//
<code>
python -V
Python 2.7.12
Parece que Linux Mint no viene con nigún python por defecto. Si invocamos el comando ''%%python%%'' el sistema nos indicará que no existe.
python3 -V
Python 3.5.2
</code>
==== Paquetes de desarrollo ====
Para escoger un python por defecto tenemos dos paquetes que podemos instalar: ''%%python-is-python2%%'' y ''%%python-is-python3%%''
Para que no haya problemas a la hora de instalar paquetes en el futuro conviene que instalemos los paquetes de desarrollo:
En principio yo no quería instalar ninguno para averigüar que paquetes no funcionaban, pero la instalación de VirtualBox hizo que se instalara automáticamente el paquete ''%%python-is-python2%%''.
<code>
sudo apt install python-dev
sudo apt install python3-dev
</code>
==== pip, virtualenv, virtualenvwrapper, virtualfish ====
Los he instalado a nivel de sistema.
//pip// es un gestor de paquetes para **Python** que facilita la instalación de librerías y utilidades.
Para poder usar los entornos virtuales instalaremos también //virtualenv//.
Instalamos los dos desde aptitude:
python2 -V
Python 2.7.18rc1
<code>
sudo apt install python-pip python-virtualenv virtualenv python3-pip
python3 -V
Python 3.8.2
</code>
//virtualenv// es una herramienta imprescindible en Python, pero da un poco de trabajo, así que se han desarrollado algunos frontends para simplificar su uso, para //bash// y //zsh// usaremos //virtualenvwrapper//, y para //fish// el //virtualfish//. Como veremos son todos muy parecidos.
==== Paquetes de python instalados ====
Instalamos el virtualwrapper:
<code>
sudo apt install virtualenvwrapper -y
</code>
Para usar //virtualenvwrapper// tenemos que hacer:
Son los que ya comentamos en la sección de instalación de zsh, como ya dijimos conviene que instalemos los paquetes de desarrollo:
<code>
source /usr/share/virtualenvwrapper/virtualenvwrapper.sh
sudo apt install python2-dev
sudo apt install python-all-dev
sudo apt install python3-dev
sudo apt install python3-all-dev
sudo apt install virtualenv virtualenvwrapper python3-virtualenv
</code>
O añadir esa linea a nuestros ficheros //.bashrc// y/o //.zshrc//
Definimos la variable de entorno //WORKON_HOME// para que apunte al directorio por defecto, ''%%~/.local/share/virtualenvs%%''. En ese directorio es donde se guardarán nuestros entornos virtuales.
En el fichero ''%%.profile%%'' añadimos:
Ademas añadimos las siguientes lineas al fichero ''%%~/.profile%%'':
<code>
# WORKON_HOME for virtualenvwrapper
if [ -d "$HOME/.local/share/virtualenvs" ] ; then
WORKON_HOME="$HOME/.local/share/virtualenvs"
if [ -d "$HOME/.virtualenvs" ] ; then
WORKON_HOME="$HOME/.virtualenvs"
fi
</code>
[[http://virtualenvwrapper.readthedocs.io/en/latest/command_ref.html|Aquí]] tenemos la referencia de comandos de //virtualenvwrapper//
Por último, si queremos tener utilidades parecidas en nuestro //fish shell// instalamos //virtualfish//:
<code>
sudo pip install virtualfish
</code>
[[http://virtualfish.readthedocs.io/en/latest/index.html|Aquí]] tenemos la documentación de //virtualfish// y la descripción de todos los comandos y plugins disponibles.
[[https://virtualenvwrapper.readthedocs.io/en/latest/command_ref.html|Aquí]] tenemos la referencia de comandos de //virtualenvwrapper//.
==== pipenv ====
No lo he instalado, pero en caso de instalación mejor lo instalamos a nivel de usuario con:
<code>
pip install --user pipenv
</code>
==== Instalación del Python 3.8 (última disponible) ====
Ejecutamos:
<code>
sudo apt install python3.8 python3.8-dev python3.8-venv
</code>
==== Instalación de bpython y ptpython ====
[[https://bpython-interpreter.org/|//bpython//]] instalado desde repos ''%%sudo apt install bpython bpython3%%''
[[https://github.com/prompt-toolkit/ptpython|//ptpython//]] instalado en un virtualenv para probarlo
==== Emacs para programar python ====
=== elpy: Emacs Python Development Enviroment ===
Para instalar ''%%elpy%%'' necesitamos intalar previamente //venv// el nuevo gestor de //virtualenvs// en Python 3.:
<code>
sudo apt install python3-venv
</code>
En el fichero ''%%~/.emacs%%'' necesitamos activar el módulo //elpy//:
<code>
;;----------------------------------------------------------------------
;; elpy
(elpy-enable)
</code>
En cuanto activemos //elpy// tendremos autocompletado del código y errores sintácticos. Merece la pena leerse toda la [[https://elpy.readthedocs.io/en/latest/|documentación]]
=== Flycheck ===
Para tener análisis sintáctico en tiempo real mientras estamos programando:
Añadimos a nuestro fichero ''%%~/.emacs%%'':
<code>
;; Enable Flycheck
(when (require 'flycheck nil t)
(setq elpy-modules (delq 'elpy-module-flymake elpy-modules))
(add-hook 'elpy-mode-hook 'flycheck-mode))
</code>
=== Formateado ===
Usando //autopep8// o //black// tendremos autoformateado del código como paso previo a salvar el mismo en disco. (Yo aún no he probado //black//)
<code>
# and autopep8 for automatic PEP8 formatting
sudo apt install python-autopep8
# and yapf for code formatting (innecesario)
# sudo apt install yapf yapf3
</code>
Y añadimos la sección siguiente a nuestro fichero ''%%~/.emacs%%''
<code>
;; Enable autopep8
(require 'py-autopep8)
(add-hook 'elpy-mode-hook 'py-autopep8-enable-on-save)
</code>
=== jedi ===
Jedi le da ciertos superpoderes al autocompletado visualizando la documentación de cada propuesta de autocompletado.
Instalamos previamente:
<code>
sudo apt install python-jedi python3-jedi
# flake8 for code checks
sudo apt install flake8 python-flake8 python3-flake8
</code>
Y añadimos la sección en el fichero ''%%~/.emacs%%'':
<code>
;;----------------------------------------------------------------------
;; elpy
(elpy-enable)
(setq elpy-rpc-backend "jedi")
(add-hook 'python-mode-hook 'jedi:setup)
(setq jedi:complete-on-dot t)
</code>
Desde //Emacs// ejecutamos: ''%%alt-x jedi:install-server%%''
==== Jupyter ====
Una instalación para pruebas.

Binary file not shown.

@ -796,133 +796,42 @@ No te olvides de compilar también el ''Project Generator''.
== Python ==
De partida tenemos instalado dos versiones: ''python'' y ''python3''
De partida tenemos instalado dos versiones: ''python2'' y ''python3''
<pre class="{bash}">python -V
Python 2.7.12
Parece que Linux Mint no viene con nigún python por defecto. Si invocamos el comando <code>python</code> el sistema nos indicará que no existe.
python3 -V
Python 3.5.2</pre>
=== Paquetes de desarrollo ===
Para que no haya problemas a la hora de instalar paquetes en el futuro conviene que instalemos los paquetes de desarrollo:
<pre>sudo apt install python-dev
sudo apt install python3-dev</pre>
=== pip, virtualenv, virtualenvwrapper, virtualfish ===
Los he instalado a nivel de sistema.
''pip'' es un gestor de paquetes para '''Python''' que facilita la instalación de librerías y utilidades.
Para escoger un python por defecto tenemos dos paquetes que podemos instalar: <code>python-is-python2</code> y <code>python-is-python3</code>
Para poder usar los entornos virtuales instalaremos también ''virtualenv''.
En principio yo no quería instalar ninguno para averigüar que paquetes no funcionaban, pero la instalación de VirtualBox hizo que se instalara automáticamente el paquete <code>python-is-python2</code>.
Instalamos los dos desde aptitude:
<pre class="{bash}">python2 -V
Python 2.7.18rc1
<pre class="{bash}">sudo apt install python-pip python-virtualenv virtualenv python3-pip</pre>
''virtualenv'' es una herramienta imprescindible en Python, pero da un poco de trabajo, así que se han desarrollado algunos frontends para simplificar su uso, para ''bash'' y ''zsh'' usaremos ''virtualenvwrapper'', y para ''fish'' el ''virtualfish''. Como veremos son todos muy parecidos.
Instalamos el virtualwrapper:
<pre class="{bash}">sudo apt install virtualenvwrapper -y</pre>
Para usar ''virtualenvwrapper'' tenemos que hacer:
<pre class="{bash}">source /usr/share/virtualenvwrapper/virtualenvwrapper.sh</pre>
O añadir esa linea a nuestros ficheros ''.bashrc'' y/o ''.zshrc''
python3 -V
Python 3.8.2</pre>
=== Paquetes de python instalados ===
Definimos la variable de entorno ''WORKON_HOME'' para que apunte al directorio por defecto, <code>~/.local/share/virtualenvs</code>. En ese directorio es donde se guardarán nuestros entornos virtuales.
Son los que ya comentamos en la sección de instalación de zsh, como ya dijimos conviene que instalemos los paquetes de desarrollo:
En el fichero <code>.profile</code> añadimos:
<pre>sudo apt install python2-dev
sudo apt install python-all-dev
sudo apt install python3-dev
sudo apt install python3-all-dev
sudo apt install virtualenv virtualenvwrapper python3-virtualenv</pre>
Ademas añadimos las siguientes lineas al fichero <code>~/.profile</code>:
<pre># WORKON_HOME for virtualenvwrapper
if [ -d &quot;$HOME/.local/share/virtualenvs&quot; ] ; then
WORKON_HOME=&quot;$HOME/.local/share/virtualenvs&quot;
<pre class="{bash{"># WORKON_HOME for virtualenvwrapper
if [ -d &quot;$HOME/.virtualenvs&quot; ] ; then
WORKON_HOME=&quot;$HOME/.virtualenvs&quot;
fi</pre>
[http://virtualenvwrapper.readthedocs.io/en/latest/command_ref.html Aquí] tenemos la referencia de comandos de ''virtualenvwrapper''
Por último, si queremos tener utilidades parecidas en nuestro ''fish shell'' instalamos ''virtualfish'':
<pre class="{bash}">sudo pip install virtualfish</pre>
[http://virtualfish.readthedocs.io/en/latest/index.html Aquí] tenemos la documentación de ''virtualfish'' y la descripción de todos los comandos y plugins disponibles.
=== pipenv ===
No lo he instalado, pero en caso de instalación mejor lo instalamos a nivel de usuario con:
[https://virtualenvwrapper.readthedocs.io/en/latest/command_ref.html Aquí] tenemos la referencia de comandos de ''virtualenvwrapper''.
<pre class="{bash}">pip install --user pipenv</pre>
=== Instalación del Python 3.8 (última disponible) ===
Ejecutamos:
<pre class="{bash}">sudo apt install python3.8 python3.8-dev python3.8-venv</pre>
=== Instalación de bpython y ptpython ===
[https://bpython-interpreter.org/ ''bpython''] instalado desde repos <code>sudo apt install bpython bpython3</code>
[https://github.com/prompt-toolkit/ptpython ''ptpython''] instalado en un virtualenv para probarlo
=== Emacs para programar python ===
==== elpy: Emacs Python Development Enviroment ====
Para instalar <code>elpy</code> necesitamos intalar previamente ''venv'' el nuevo gestor de ''virtualenvs'' en Python 3.:
<pre>sudo apt install python3-venv</pre>
En el fichero <code>~/.emacs</code> necesitamos activar el módulo ''elpy'':
<pre class="{lisp}">;;----------------------------------------------------------------------
;; elpy
(elpy-enable)</pre>
En cuanto activemos ''elpy'' tendremos autocompletado del código y errores sintácticos. Merece la pena leerse toda la [https://elpy.readthedocs.io/en/latest/ documentación]
==== Flycheck ====
Para tener análisis sintáctico en tiempo real mientras estamos programando:
Añadimos a nuestro fichero <code>~/.emacs</code>:
<pre>;; Enable Flycheck
(when (require 'flycheck nil t)
(setq elpy-modules (delq 'elpy-module-flymake elpy-modules))
(add-hook 'elpy-mode-hook 'flycheck-mode))</pre>
==== Formateado ====
Usando ''autopep8'' o ''black'' tendremos autoformateado del código como paso previo a salvar el mismo en disco. (Yo aún no he probado ''black'')
<pre># and autopep8 for automatic PEP8 formatting
sudo apt install python-autopep8
# and yapf for code formatting (innecesario)
# sudo apt install yapf yapf3</pre>
Y añadimos la sección siguiente a nuestro fichero <code>~/.emacs</code>
<pre class="{lisp}">;; Enable autopep8
(require 'py-autopep8)
(add-hook 'elpy-mode-hook 'py-autopep8-enable-on-save)</pre>
==== jedi ====
Jedi le da ciertos superpoderes al autocompletado visualizando la documentación de cada propuesta de autocompletado.
Instalamos previamente:
<pre class="{bash}">sudo apt install python-jedi python3-jedi
# flake8 for code checks
sudo apt install flake8 python-flake8 python3-flake8</pre>
Y añadimos la sección en el fichero <code>~/.emacs</code>:
<pre class="{lisp}">;;----------------------------------------------------------------------
;; elpy
(elpy-enable)
(setq elpy-rpc-backend &quot;jedi&quot;)
(add-hook 'python-mode-hook 'jedi:setup)
(setq jedi:complete-on-dot t)</pre>
Desde ''Emacs'' ejecutamos: <code>alt-x jedi:install-server</code>
=== Jupyter ===
Una instalación para pruebas.

Binary file not shown.

Binary file not shown.

@ -1469,113 +1469,55 @@ No te olvides de compilar también el \emph{Project Generator}.
\hypertarget{python}{%
\subsection{Python}\label{python}}
De partida tenemos instalado dos versiones: \emph{python} y
De partida tenemos instalado dos versiones: \emph{python2} y
\emph{python3}
\begin{verbatim}
python -V
Python 2.7.12
Parece que Linux Mint no viene con nigún python por defecto. Si
invocamos el comando \texttt{python} el sistema nos indicará que no
existe.
python3 -V
Python 3.5.2
\end{verbatim}
Para escoger un python por defecto tenemos dos paquetes que podemos
instalar: \texttt{python-is-python2} y \texttt{python-is-python3}
\hypertarget{paquetes-de-desarrollo}{%
\subsubsection{Paquetes de desarrollo}\label{paquetes-de-desarrollo}}
Para que no haya problemas a la hora de instalar paquetes en el futuro
conviene que instalemos los paquetes de desarrollo:
En principio yo no quería instalar ninguno para averigüar que paquetes
no funcionaban, pero la instalación de VirtualBox hizo que se instalara
automáticamente el paquete \texttt{python-is-python2}.
\begin{verbatim}
sudo apt install python-dev
sudo apt install python3-dev
\end{verbatim}
\hypertarget{pip-virtualenv-virtualenvwrapper-virtualfish}{%
\subsubsection{pip, virtualenv, virtualenvwrapper,
virtualfish}\label{pip-virtualenv-virtualenvwrapper-virtualfish}}
Los he instalado a nivel de sistema.
\emph{pip} es un gestor de paquetes para \textbf{Python} que facilita la
instalación de librerías y utilidades.
Para poder usar los entornos virtuales instalaremos también
\emph{virtualenv}.
python2 -V
Python 2.7.18rc1
Instalamos los dos desde aptitude:
\begin{verbatim}
sudo apt install python-pip python-virtualenv virtualenv python3-pip
python3 -V
Python 3.8.2
\end{verbatim}
\emph{virtualenv} es una herramienta imprescindible en Python, pero da
un poco de trabajo, así que se han desarrollado algunos frontends para
simplificar su uso, para \emph{bash} y \emph{zsh} usaremos
\emph{virtualenvwrapper}, y para \emph{fish} el \emph{virtualfish}. Como
veremos son todos muy parecidos.
Instalamos el virtualwrapper:
\begin{verbatim}
sudo apt install virtualenvwrapper -y
\end{verbatim}
\hypertarget{paquetes-de-python-instalados}{%
\subsubsection{Paquetes de python
instalados}\label{paquetes-de-python-instalados}}
Para usar \emph{virtualenvwrapper} tenemos que hacer:
Son los que ya comentamos en la sección de instalación de zsh, como ya
dijimos conviene que instalemos los paquetes de desarrollo:
\begin{verbatim}
source /usr/share/virtualenvwrapper/virtualenvwrapper.sh
sudo apt install python2-dev
sudo apt install python-all-dev
sudo apt install python3-dev
sudo apt install python3-all-dev
sudo apt install virtualenv virtualenvwrapper python3-virtualenv
\end{verbatim}
O añadir esa linea a nuestros ficheros \emph{.bashrc} y/o \emph{.zshrc}
Definimos la variable de entorno \emph{WORKON\_HOME} para que apunte al
directorio por defecto,
\texttt{\textasciitilde{}/.local/share/virtualenvs}. En ese directorio
es donde se guardarán nuestros entornos virtuales.
En el fichero \texttt{.profile} añadimos:
Ademas añadimos las siguientes lineas al fichero
\texttt{\textasciitilde{}/.profile}:
\begin{verbatim}
# WORKON_HOME for virtualenvwrapper
if [ -d "$HOME/.local/share/virtualenvs" ] ; then
WORKON_HOME="$HOME/.local/share/virtualenvs"
if [ -d "$HOME/.virtualenvs" ] ; then
WORKON_HOME="$HOME/.virtualenvs"
fi
\end{verbatim}
\href{http://virtualenvwrapper.readthedocs.io/en/latest/command_ref.html}{Aquí}
tenemos la referencia de comandos de \emph{virtualenvwrapper}
Por último, si queremos tener utilidades parecidas en nuestro \emph{fish
shell} instalamos \emph{virtualfish}:
\begin{verbatim}
sudo pip install virtualfish
\end{verbatim}
\href{http://virtualfish.readthedocs.io/en/latest/index.html}{Aquí}
tenemos la documentación de \emph{virtualfish} y la descripción de todos
los comandos y plugins disponibles.
\hypertarget{pipenv}{%
\subsubsection{pipenv}\label{pipenv}}
No lo he instalado, pero en caso de instalación mejor lo instalamos a
nivel de usuario con:
\begin{verbatim}
pip install --user pipenv
\end{verbatim}
\hypertarget{instalaciuxf3n-del-python-3.8-uxfaltima-disponible}{%
\subsubsection{Instalación del Python 3.8 (última
disponible)}\label{instalaciuxf3n-del-python-3.8-uxfaltima-disponible}}
Ejecutamos:
\begin{verbatim}
sudo apt install python3.8 python3.8-dev python3.8-venv
\end{verbatim}
\href{https://virtualenvwrapper.readthedocs.io/en/latest/command_ref.html}{Aquí}
tenemos la referencia de comandos de \emph{virtualenvwrapper}.
\hypertarget{instalaciuxf3n-de-bpython-y-ptpython}{%
\subsubsection{Instalación de bpython y
@ -1587,105 +1529,6 @@ repos \texttt{sudo\ apt\ install\ bpython\ bpython3}
\href{https://github.com/prompt-toolkit/ptpython}{\emph{ptpython}}
instalado en un virtualenv para probarlo
\hypertarget{emacs-para-programar-python}{%
\subsubsection{Emacs para programar
python}\label{emacs-para-programar-python}}
\hypertarget{elpy-emacs-python-development-enviroment}{%
\paragraph{elpy: Emacs Python Development
Enviroment}\label{elpy-emacs-python-development-enviroment}}
Para instalar \texttt{elpy} necesitamos intalar previamente \emph{venv}
el nuevo gestor de \emph{virtualenvs} en Python 3.:
\begin{verbatim}
sudo apt install python3-venv
\end{verbatim}
En el fichero \texttt{\textasciitilde{}/.emacs} necesitamos activar el
módulo \emph{elpy}:
\begin{verbatim}
;;----------------------------------------------------------------------
;; elpy
(elpy-enable)
\end{verbatim}
En cuanto activemos \emph{elpy} tendremos autocompletado del código y
errores sintácticos. Merece la pena leerse toda la
\href{https://elpy.readthedocs.io/en/latest/}{documentación}
\hypertarget{flycheck}{%
\paragraph{Flycheck}\label{flycheck}}
Para tener análisis sintáctico en tiempo real mientras estamos
programando:
Añadimos a nuestro fichero \texttt{\textasciitilde{}/.emacs}:
\begin{verbatim}
;; Enable Flycheck
(when (require 'flycheck nil t)
(setq elpy-modules (delq 'elpy-module-flymake elpy-modules))
(add-hook 'elpy-mode-hook 'flycheck-mode))
\end{verbatim}
\hypertarget{formateado}{%
\paragraph{Formateado}\label{formateado}}
Usando \emph{autopep8} o \emph{black} tendremos autoformateado del
código como paso previo a salvar el mismo en disco. (Yo aún no he
probado \emph{black})
\begin{verbatim}
# and autopep8 for automatic PEP8 formatting
sudo apt install python-autopep8
# and yapf for code formatting (innecesario)
# sudo apt install yapf yapf3
\end{verbatim}
Y añadimos la sección siguiente a nuestro fichero
\texttt{\textasciitilde{}/.emacs}
\begin{verbatim}
;; Enable autopep8
(require 'py-autopep8)
(add-hook 'elpy-mode-hook 'py-autopep8-enable-on-save)
\end{verbatim}
\hypertarget{jedi}{%
\paragraph{jedi}\label{jedi}}
Jedi le da ciertos superpoderes al autocompletado visualizando la
documentación de cada propuesta de autocompletado.
Instalamos previamente:
\begin{verbatim}
sudo apt install python-jedi python3-jedi
# flake8 for code checks
sudo apt install flake8 python-flake8 python3-flake8
\end{verbatim}
Y añadimos la sección en el fichero \texttt{\textasciitilde{}/.emacs}:
\begin{verbatim}
;;----------------------------------------------------------------------
;; elpy
(elpy-enable)
(setq elpy-rpc-backend "jedi")
(add-hook 'python-mode-hook 'jedi:setup)
(setq jedi:complete-on-dot t)
\end{verbatim}
Desde \emph{Emacs} ejecutamos: \texttt{alt-x\ jedi:install-server}
\hypertarget{jupyter}{%
\subsubsection{Jupyter}\label{jupyter}}

@ -220,105 +220,50 @@ No te olvides de compilar también el _Project Generator_.
## Python
De partida tenemos instalado dos versiones: _python_ y _python3_
De partida tenemos instalado dos versiones: _python2_ y _python3_
Parece que Linux Mint no viene con nigún python por defecto. Si
invocamos el comando `python` el sistema nos indicará que no existe.
Para escoger un python por defecto tenemos dos paquetes que podemos
instalar: `python-is-python2` y `python-is-python3`
En principio yo no quería instalar ninguno para averigüar que paquetes
no funcionaban, pero la instalación de VirtualBox hizo que se
instalara automáticamente el paquete `python-is-python2`.
~~~~{bash}
python -V
Python 2.7.12
python2 -V
Python 2.7.18rc1
python3 -V
Python 3.5.2
Python 3.8.2
~~~~
### Paquetes de desarrollo
### Paquetes de python instalados
Para que no haya problemas a la hora de instalar paquetes en el futuro
Son los que ya comentamos en la sección de instalación de zsh, como ya dijimos
conviene que instalemos los paquetes de desarrollo:
~~~~
sudo apt install python-dev
sudo apt install python2-dev
sudo apt install python-all-dev
sudo apt install python3-dev
sudo apt install python3-all-dev
sudo apt install virtualenv virtualenvwrapper python3-virtualenv
~~~~
### pip, virtualenv, virtualenvwrapper, virtualfish
Los he instalado a nivel de sistema.
_pip_ es un gestor de paquetes para __Python__ que facilita la
instalación de librerías y utilidades.
Para poder usar los entornos virtuales instalaremos también
_virtualenv_.
Instalamos los dos desde aptitude:
~~~~{bash}
sudo apt install python-pip python-virtualenv virtualenv python3-pip
~~~~
_virtualenv_ es una herramienta imprescindible en Python, pero da un
poco de trabajo, así que se han desarrollado algunos frontends para
simplificar su uso, para _bash_ y _zsh_ usaremos _virtualenvwrapper_,
y para _fish_ el _virtualfish_. Como veremos son todos muy parecidos.
Instalamos el virtualwrapper:
~~~~{bash}
sudo apt install virtualenvwrapper -y
~~~~
Para usar _virtualenvwrapper_ tenemos que hacer:
~~~~{bash}
source /usr/share/virtualenvwrapper/virtualenvwrapper.sh
~~~~
O añadir esa linea a nuestros ficheros _.bashrc_ y/o _.zshrc_
Definimos la variable de entorno *WORKON_HOME* para que
apunte al directorio por defecto, `~/.local/share/virtualenvs`. En ese directorio
es donde se guardarán nuestros entornos virtuales.
En el fichero `.profile` añadimos:
Ademas añadimos las siguientes lineas al fichero `~/.profile`:
~~~~
~~~~{bash{
# WORKON_HOME for virtualenvwrapper
if [ -d "$HOME/.local/share/virtualenvs" ] ; then
WORKON_HOME="$HOME/.local/share/virtualenvs"
if [ -d "$HOME/.virtualenvs" ] ; then
WORKON_HOME="$HOME/.virtualenvs"
fi
~~~~
[Aquí](http://virtualenvwrapper.readthedocs.io/en/latest/command_ref.html)
tenemos la referencia de comandos de _virtualenvwrapper_
Por último, si queremos tener utilidades parecidas en nuestro _fish
shell_ instalamos _virtualfish_:
~~~~{bash}
sudo pip install virtualfish
~~~~
[Aquí](http://virtualfish.readthedocs.io/en/latest/index.html) tenemos
la documentación de _virtualfish_ y la descripción de todos los
comandos y plugins disponibles.
### pipenv
No lo he instalado, pero en caso de instalación mejor lo instalamos a
nivel de usuario con:
~~~~{bash}
pip install --user pipenv
~~~~
### Instalación del Python 3.8 (última disponible)
Ejecutamos:
~~~~{bash}
sudo apt install python3.8 python3.8-dev python3.8-venv
~~~~
[Aquí](https://virtualenvwrapper.readthedocs.io/en/latest/command_ref.html)
tenemos la referencia de comandos de _virtualenvwrapper_.
### Instalación de bpython y ptpython
@ -327,100 +272,6 @@ sudo apt install python3.8 python3.8-dev python3.8-venv
[_ptpython_](https://github.com/prompt-toolkit/ptpython) instalado en un virtualenv para probarlo
### Emacs para programar python
#### elpy: Emacs Python Development Enviroment
Para instalar `elpy` necesitamos intalar previamente _venv_ el nuevo
gestor de _virtualenvs_ en Python 3.:
~~~~
sudo apt install python3-venv
~~~~
En el fichero `~/.emacs` necesitamos activar el módulo _elpy_:
~~~~{lisp}
;;----------------------------------------------------------------------
;; elpy
(elpy-enable)
~~~~
En cuanto activemos _elpy_ tendremos autocompletado del código y
errores sintácticos. Merece la pena leerse toda la
[documentación](https://elpy.readthedocs.io/en/latest/)
#### Flycheck
Para tener análisis sintáctico en tiempo real mientras estamos
programando:
Añadimos a nuestro fichero `~/.emacs`:
~~~~
;; Enable Flycheck
(when (require 'flycheck nil t)
(setq elpy-modules (delq 'elpy-module-flymake elpy-modules))
(add-hook 'elpy-mode-hook 'flycheck-mode))
~~~~
#### Formateado
Usando _autopep8_ o _black_ tendremos autoformateado del código como
paso previo a salvar el mismo en disco. (Yo aún no he probado _black_)
~~~~
# and autopep8 for automatic PEP8 formatting
sudo apt install python-autopep8
# and yapf for code formatting (innecesario)
# sudo apt install yapf yapf3
~~~~
Y añadimos la sección siguiente a nuestro fichero `~/.emacs`
~~~~{lisp}
;; Enable autopep8
(require 'py-autopep8)
(add-hook 'elpy-mode-hook 'py-autopep8-enable-on-save)
~~~~
#### jedi
Jedi le da ciertos superpoderes al autocompletado visualizando la
documentación de cada propuesta de autocompletado.
Instalamos previamente:
~~~~{bash}
sudo apt install python-jedi python3-jedi
# flake8 for code checks
sudo apt install flake8 python-flake8 python3-flake8
~~~~
Y añadimos la sección en el fichero `~/.emacs`:
~~~~{lisp}
;;----------------------------------------------------------------------
;; elpy
(elpy-enable)
(setq elpy-rpc-backend "jedi")
(add-hook 'python-mode-hook 'jedi:setup)
(setq jedi:complete-on-dot t)
~~~~
Desde _Emacs_ ejecutamos: `alt-x jedi:install-server`
### Jupyter
Una instalación para pruebas.

Loading…
Cancel
Save