salvari
/
guide_LinuxMint
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Changes python section, deletes sections about emacs configuration

Browse Source
una
Sergio Alvariño 4 years ago
parent 649be3b749
commit 54783fd015
8 changed files with 122 additions and 771 deletions
Show Stats Download Patch File Download Diff File

191
README.md
Unescape View File

@ -1060,100 +1060,48 @@ No te olvides de compilar también el *Project Generator*.
## Python ## Python
De partida tenemos instalado dos versiones: *python* y *python3* De partida tenemos instalado dos versiones: *python2* y *python3*
``` {bash} Parece que Linux Mint no viene con nigún python por defecto. Si
python -V invocamos el comando `python` el sistema nos indicará que no existe.
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
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 En principio yo no quería instalar ninguno para averigüar que paquetes
instalación de librerías y utilidades. no funcionaban, pero la instalación de VirtualBox hizo que se instalara
automáticamente el paquete `python-is-python2`.
Para poder usar los entornos virtuales instalaremos también
*virtualenv*.
Instalamos los dos desde aptitude:
``` {bash} ``` {bash}
sudo apt install python-pip python-virtualenv virtualenv python3-pip python2 -V
``` Python 2.7.18rc1
*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} python3 -V
source /usr/share/virtualenvwrapper/virtualenvwrapper.sh Python 3.8.2
``` ```
O añadir esa linea a nuestros ficheros *.bashrc* y/o *.zshrc* ### Paquetes de python instalados
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*:
``` {bash} Son los que ya comentamos en la sección de instalación de zsh, como ya
sudo pip install virtualfish dijimos conviene que instalemos los paquetes de desarrollo:
```
[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 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 Ademas añadimos las siguientes lineas al fichero `~/.profile`:
nivel de usuario con:
``` {bash} ``` {bash{
pip install --user pipenv # WORKON_HOME for virtualenvwrapper
if [ -d "$HOME/.virtualenvs" ] ; then
WORKON_HOME="$HOME/.virtualenvs"
fi
``` ```
### Instalación del Python 3.8 (última disponible) [Aquí](https://virtualenvwrapper.readthedocs.io/en/latest/command_ref.html)
tenemos la referencia de comandos de *virtualenvwrapper*.
Ejecutamos:
``` {bash}
sudo apt install python3.8 python3.8-dev python3.8-venv
```
### Instalación de bpython y ptpython ### 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 [*ptpython*](https://github.com/prompt-toolkit/ptpython) instalado en un
virtualenv para probarlo 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 ### Jupyter
Una instalación para pruebas. Una instalación para pruebas.

155
out/LinuxMintUlyana.dw
Unescape View File

@ -922,165 +922,48 @@ No te olvides de compilar también el //Project Generator//.
===== Python ===== ===== Python =====
De partida tenemos instalado dos versiones: //python// y //python3// De partida tenemos instalado dos versiones: //python2// y //python3//
<code> Parece que Linux Mint no viene con nigún python por defecto. Si invocamos el comando ''%%python%%'' el sistema nos indicará que no existe.
python -V
Python 2.7.12
python3 -V Para escoger un python por defecto tenemos dos paquetes que podemos instalar: ''%%python-is-python2%%'' y ''%%python-is-python3%%''
Python 3.5.2
</code>
==== 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 ''%%python-is-python2%%''.
<code> <code>
sudo apt install python-dev python2 -V
sudo apt install python3-dev Python 2.7.18rc1
</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:
<code> python3 -V
sudo apt install python-pip python-virtualenv virtualenv python3-pip Python 3.8.2
</code> </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: 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>
sudo apt install virtualenvwrapper -y
</code>
Para usar //virtualenvwrapper// tenemos que hacer:
<code> <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> </code>
O añadir esa linea a nuestros ficheros //.bashrc// y/o //.zshrc// Ademas añadimos las siguientes lineas al fichero ''%%~/.profile%%'':
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:
<code> <code>
# WORKON_HOME for virtualenvwrapper # WORKON_HOME for virtualenvwrapper
if [ -d "$HOME/.local/share/virtualenvs" ] ; then if [ -d "$HOME/.virtualenvs" ] ; then
WORKON_HOME="$HOME/.local/share/virtualenvs" WORKON_HOME="$HOME/.virtualenvs"
fi fi
</code> </code>
[[http://virtualenvwrapper.readthedocs.io/en/latest/command_ref.html|Aquí]] tenemos la referencia de comandos de //virtualenvwrapper// [[https://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.
==== 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 ==== ==== Instalación de bpython y ptpython ====
[[https://bpython-interpreter.org/|//bpython//]] instalado desde repos ''%%sudo apt install bpython bpython3%%'' [[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 [[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 ==== ==== Jupyter ====
Una instalación para pruebas. Una instalación para pruebas.

BIN
out/LinuxMintUlyana.epub
View File

Binary file not shown.

131
out/LinuxMintUlyana.mw
Unescape View File

@ -796,133 +796,42 @@ No te olvides de compilar también el ''Project Generator''.
== Python == == Python ==
De partida tenemos instalado dos versiones: ''python'' y ''python3'' De partida tenemos instalado dos versiones: ''python2'' y ''python3''
<pre class="{bash}">python -V 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.
Python 2.7.12
python3 -V Para escoger un python por defecto tenemos dos paquetes que podemos instalar: <code>python-is-python2</code> y <code>python-is-python3</code>
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 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> python3 -V
''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. Python 3.8.2</pre>
=== Paquetes de python instalados ===
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''
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 <pre class="{bash{"># WORKON_HOME for virtualenvwrapper
if [ -d &quot;$HOME/.local/share/virtualenvs&quot; ] ; then if [ -d &quot;$HOME/.virtualenvs&quot; ] ; then
WORKON_HOME=&quot;$HOME/.local/share/virtualenvs&quot; WORKON_HOME=&quot;$HOME/.virtualenvs&quot;
fi</pre> fi</pre>
[http://virtualenvwrapper.readthedocs.io/en/latest/command_ref.html Aquí] tenemos la referencia de comandos de ''virtualenvwrapper'' [https://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:
<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 === === Instalación de bpython y ptpython ===
[https://bpython-interpreter.org/ ''bpython''] instalado desde repos <code>sudo apt install bpython bpython3</code> [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 [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 === === Jupyter ===
Una instalación para pruebas. Una instalación para pruebas.

BIN
out/LinuxMintUlyana.odt
View File

Binary file not shown.

BIN
out/LinuxMintUlyana.pdf
View File

Binary file not shown.

215
out/LinuxMintUlyana.tex
Unescape View File

@ -1469,113 +1469,55 @@ No te olvides de compilar también el \emph{Project Generator}.
\hypertarget{python}{% \hypertarget{python}{%
\subsection{Python}\label{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} \emph{python3}
\begin{verbatim} Parece que Linux Mint no viene con nigún python por defecto. Si
python -V invocamos el comando \texttt{python} el sistema nos indicará que no
Python 2.7.12 existe.
python3 -V Para escoger un python por defecto tenemos dos paquetes que podemos
Python 3.5.2 instalar: \texttt{python-is-python2} y \texttt{python-is-python3}
\end{verbatim}
\hypertarget{paquetes-de-desarrollo}{% En principio yo no quería instalar ninguno para averigüar que paquetes
\subsubsection{Paquetes de desarrollo}\label{paquetes-de-desarrollo}} no funcionaban, pero la instalación de VirtualBox hizo que se instalara
automáticamente el paquete \texttt{python-is-python2}.
Para que no haya problemas a la hora de instalar paquetes en el futuro
conviene que instalemos los paquetes de desarrollo:
\begin{verbatim} \begin{verbatim}
sudo apt install python-dev python2 -V
sudo apt install python3-dev Python 2.7.18rc1
\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}.
Instalamos los dos desde aptitude: python3 -V
Python 3.8.2
\begin{verbatim}
sudo apt install python-pip python-virtualenv virtualenv python3-pip
\end{verbatim} \end{verbatim}
\emph{virtualenv} es una herramienta imprescindible en Python, pero da \hypertarget{paquetes-de-python-instalados}{%
un poco de trabajo, así que se han desarrollado algunos frontends para \subsubsection{Paquetes de python
simplificar su uso, para \emph{bash} y \emph{zsh} usaremos instalados}\label{paquetes-de-python-instalados}}
\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}
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} \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} \end{verbatim}
O añadir esa linea a nuestros ficheros \emph{.bashrc} y/o \emph{.zshrc} Ademas añadimos las siguientes lineas al fichero
\texttt{\textasciitilde{}/.profile}:
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:
\begin{verbatim} \begin{verbatim}
# WORKON_HOME for virtualenvwrapper # WORKON_HOME for virtualenvwrapper
if [ -d "$HOME/.local/share/virtualenvs" ] ; then if [ -d "$HOME/.virtualenvs" ] ; then
WORKON_HOME="$HOME/.local/share/virtualenvs" WORKON_HOME="$HOME/.virtualenvs"
fi fi
\end{verbatim} \end{verbatim}
\href{http://virtualenvwrapper.readthedocs.io/en/latest/command_ref.html}{Aquí} \href{https://virtualenvwrapper.readthedocs.io/en/latest/command_ref.html}{Aquí}
tenemos la referencia de comandos de \emph{virtualenvwrapper} 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}
\hypertarget{instalaciuxf3n-de-bpython-y-ptpython}{% \hypertarget{instalaciuxf3n-de-bpython-y-ptpython}{%
\subsubsection{Instalación de bpython y \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}} \href{https://github.com/prompt-toolkit/ptpython}{\emph{ptpython}}
instalado en un virtualenv para probarlo 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}{% \hypertarget{jupyter}{%
\subsubsection{Jupyter}\label{jupyter}} \subsubsection{Jupyter}\label{jupyter}}

201
src/400_swdev.md
Unescape View File

@ -220,105 +220,50 @@ No te olvides de compilar también el _Project Generator_.
## Python ## 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} ~~~~{bash}
python -V python2 -V
Python 2.7.12 Python 2.7.18rc1
python3 -V 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: 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-dev
sudo apt install python3-all-dev
sudo apt install virtualenv virtualenvwrapper python3-virtualenv
~~~~ ~~~~
### pip, virtualenv, virtualenvwrapper, virtualfish Ademas añadimos las siguientes lineas al fichero `~/.profile`:
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:
~~~~ ~~~~{bash{
# WORKON_HOME for virtualenvwrapper # WORKON_HOME for virtualenvwrapper
if [ -d "$HOME/.local/share/virtualenvs" ] ; then if [ -d "$HOME/.virtualenvs" ] ; then
WORKON_HOME="$HOME/.local/share/virtualenvs" WORKON_HOME="$HOME/.virtualenvs"
fi fi
~~~~ ~~~~
[Aquí](http://virtualenvwrapper.readthedocs.io/en/latest/command_ref.html) [Aquí](https://virtualenvwrapper.readthedocs.io/en/latest/command_ref.html)
tenemos la referencia de comandos de _virtualenvwrapper_ 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
~~~~
### Instalación de bpython y ptpython ### 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 [_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 ### Jupyter
Una instalación para pruebas. Una instalación para pruebas.

Write Preview
Loading…
Cancel
Save