ipython - how - open jupyter notebook python 3

¿Cómo agrego kernel python3 a jupyter(IPython) (20)

INSTALACIÓN DE CANALES MÚLTIPLES EN UN ENTORNO VIRTUAL ÚNICO (VENV)

La mayoría (si no todas) de estas respuestas asumen que está contento de instalar paquetes a nivel mundial. Esta respuesta es para ti si:

usar una máquina * NIX
no me gusta instalar paquetes globalmente
no quieres usar anaconda <-> estás feliz de ejecutar el servidor jupyter desde la línea de comandos
quiero tener una idea de qué / dónde está '''' la instalación del núcleo.

(Nota: esta respuesta agrega un núcleo python2 a una instalación python3-jupyter, pero es conceptualmente fácil intercambiar cosas).

Prerrequisitos
1. Estás en el directorio desde el que ejecutarás el servidor jupyter y guardarás archivos
2. python2 está instalado en su máquina
3. python3 está instalado en su máquina
4. virtualenv está instalado en su máquina
Crea un venv python3 e instala jupyter
1. Cree un nuevo python3 venv: python3 -m venv .venv
2. Activar el venv:. . .venv/bin/activate
3. Instalar jupyterlab: pip install jupyterlab . Esto creará localmente toda la infraestructura esencial para ejecutar portátiles.
4. Nota: al instalar jupyterlab aquí, también genera ''especificaciones de kernel'' predeterminadas (ver más abajo) en $PWD/.venv/share/jupyter/kernels/python3/ . Si desea instalar y ejecutar jupyter en otro lugar, y solo usa este venv para organizar todos sus núcleos, entonces solo necesita: pip install ipykernel
5. Ahora puede ejecutar jupyter lab con jupyter lab (e ir a su navegador a la url que se muestra en la consola). Hasta ahora, solo verá una opción de kernel llamada ''Python 3''. (Este nombre está determinado por la entrada kernel.json en su archivo kernel.json ).
Agregar un núcleo de python2
1. Salga de jupyter (o inicie otro shell en el mismo directorio): ctrl-c
2. Desactiva tu venv python3: deactivate
3. Cree un nuevo venv en el mismo directorio para python2: virtualenv -p python2 .venv2
4. Active su venv python2:. . .venv2/bin/activate
5. Instale el módulo ipykernel: pip install ipykernel . Esto también generará especificaciones de kernel predeterminadas para este python2 venv en .venv2/share/jupyter/kernels/python2
6. Exporte estas especificaciones del kernel a su python3 venv: python -m ipykernel install --prefix=$PWD/.venv . Básicamente, esto solo copia el directorio $PWD/.venv2/share/jupyter/kernels/python2 a $PWD/.venv/share/jupyter/kernels/
7. Vuelva a su venv python3 y / o vuelva a ejecutar / reexaminar su servidor jupyter: deactivate; . .venv/bin/activate; jupyter lab deactivate; . .venv/bin/activate; jupyter lab deactivate; . .venv/bin/activate; jupyter lab . Si todo salió bien, verá una opción de Python 2 en su lista de núcleos. Puede probar que ejecutan intérpretes reales de python2 / python3 manejando un print ''Hellow world'' simple print ''Hellow world'' vs print(''Hellow world'') .
8. Nota: no necesita crear un venv separado para python2 si desea instalar ipykernel y hacer referencia a las especificaciones del núcleo de python2 desde un espacio global, pero prefiero tener todas mis dependencias en un directorio local

TL; DR

Opcionalmente instale un kernel R. Esto es instructivo para desarrollar un sentido de lo que es un núcleo.
1. Desde el mismo directorio, instale el paquete R IRkernel: R -e "install.packages(''IRkernel'',repos=''https://cran.mtu.edu/'')" . (Esto se instalará en su ubicación estándar de paquetes R; para R instalado en casa en una Mac, se verá como /usr/local/Cellar/r/3.5.2_2/lib/R/library/IRkernel ).
2. El paquete IRkernel viene con una función para exportar sus especificaciones del núcleo, por lo tanto, ejecute: R -e "IRkernel::installspec(prefix=paste(getwd(),''/.venv'',sep=''''))" . Si ahora busca en $PWD/.venv/share/jupyter/kernels/ encontrará un directorio ir con el archivo kernel.json que se parece a esto:

{ "argv": ["/usr/local/Cellar/r/3.5.2_2/lib/R/bin/R", "--slave", "-e", "IRkernel::main()", "--args", "{connection_file}"], "display_name": "R", "language": "R" }

En resumen, un kernel simplemente ''es'' una invocación de un ejecutable específico del idioma desde un archivo kernel.json que jupyter busca en el .../share/jupyter/kernels y enumera en su interfaz; en este caso, se llama a R para ejecutar la función IRkernel::main() , que enviará mensajes de ida y vuelta al servidor Jupiter. Del mismo modo, el núcleo python2 simplemente ''es'' una invocación del intérprete python2 con el módulo ipykernel_launcher como se ve en .venv/share/jupyter/kernels/python2/kernel.json , etc.

Aquí hay un script si desea ejecutar todas estas instrucciones de una sola vez.

Mis portátiles Jupyter instalados con kernel python 2 . No entiendo porque. Podría haber estropeado algo cuando hice la instalación. Ya tengo instalado python 3 . ¿Cómo puedo agregarlo a Jupyter ? Aquí hay una captura de pantalla de cómo Jupyter predeterminado se instaló con python3 -m install jupyter y se abrió en el navegador con el jupyter notebook :

Tengo ipython notebook con Python2 (en Windows7)
actualizar a Jupyter con pip install -U jupyter
instalar Python3
instalar Jupyter nuevamente usando pip3 install jupyter
instale el núcleo Python3 usando ipython3 kernelspec install-self
Finalmente obtuve 2 núcleos de trabajo.

Aquí hay un método de línea de comando / no Windows que encontré, que funcionó para mí: encontrar la carpeta donde se almacenan los archivos del núcleo (en mi máquina - C: / ProgramData / jupyter / kernels - tenga en cuenta que ProgramData es una carpeta oculta), cree un copia de la carpeta del kernel existente, cambie el nombre y edite el archivo json para apuntar al nuevo directorio del kernel. En este json también puede editar el nombre del núcleo que se muestra en ipython (por ejemplo, en lugar de solo python 2, puede especificar 2.7.9 si necesita distinguir aún más por alguna razón).

Asegúrese de tener instalado ipykernel y use la ipython kernel install para colocar la especificación del núcleo en la ubicación correcta para python2. Luego, ipython3 kernel install ipython3 para Python3. Ahora debería poder elegir entre los 2 núcleos, independientemente de si utiliza jupyter notebook , ipython notebook o ipython3 notebook (los dos últimos están en desuso).

Tenga en cuenta que si desea instalar un ejecutable específico de Python, puede usar el siguiente truco:

path/to/python -m ipykernel install <options>

Esto funciona cuando se usan entornos (venv, conda, ...) y las <options> permiten nombrar su núcleo (vea --help ). Entonces puedes hacer

conda create -n py36-test python=3.6 source activate py36-test python -m ipykernel install --name py36-test source deactivate

Y ahora obtienes un kernel llamado py36-test en tus menús desplegables, junto con los otros.

Consulte Uso de Python 2.xy Python 3.x en IPython Notebook, que tiene información más reciente.

Cuando use conda administrando sus envs de python, siga estos dos pasos:

activate py3 (en Windows o source activate py3 en Linux)
conda install notebook ipykernel o simplemente use conda install jupyter

El siguiente comando funciona para mí, en macOS Sierra (10.12.3)

python3 -m pip install ipykernel python3 -m ipykernel install --user

verifíquelo con jupyter kernelspec list Kernels disponibles: python3 / Users / admin / Library / Jupyter / kernels / python3 python2 / anaconda2 / share / jupyter / kernels / python2

En Ubuntu 14.04 tuve que usar una combinación de respuestas anteriores.

Primero, instale pip3 apt-get install python-pip3

Luego con pip3 instale jupyter pip3 install jupyter

Luego, utilizando ipython3 instale el kernel ipython3 kernel install

Esto funcionó para mí en Ubuntu 16.04:

python2 -m pip install ipykernel python2 -m ipykernel install --user python3 -m pip install ipykernel python3 -m ipykernel install --user

Referencia a la documentación:
Kernels para Python 2 y 3 . Instalación del núcleo de IPython - IPython Docs.

Estoy bastante seguro de que todo lo que tienes que hacer es correr

pip3 instalar jupyter

Instalé con éxito el núcleo de python3 en macOS El Capitan (versión de ipython: 4.1.0) con los siguientes comandos.

python3 -m pip install ipykernel python3 -m ipykernel install --user

Puede ver todos los núcleos instalados con jupyter kernelspec list .

Más información está disponible here

La solución está bien documentada en los documentos oficiales: https://ipython.readthedocs.org/en/latest/install/kernel_install.html

Intenté el primer acercamiento. Como ya tenía instalado ipykernel , simplemente ejecutando python3 -m ipykernel install --user resolvió el problema.

La solución más corta y mejor de mi lado

conda create --name py3-ml python=3.6 conda install ipykernel source activate py3-ml # or conda activate py3-ml python -m ipykernel install --user --name py3-ml

Logré instalar un núcleo Python3 además del Python2. Aquí está la forma en que lo hice:

abrir un cuaderno nuevo en Jupyter
copie y ejecute las dos celdas aquí: Enable-Python-3-kernel

El último enlace de trabajo se puede encontrar here .

El código actual es:

! mkdir -p ~/.ipython/kernels/python3 %%file ~/.ipython/kernels/python3/kernel.json { "display_name": "IPython (Python 3)", "language": "python", "argv": [ "python3", "-c", "from IPython.kernel.zmq.kernelapp import main; main()", "-f", "{connection_file}" ], "codemirror_mode": { "version": 2, "name": "ipython" } }

Ninguna de las otras respuestas me funcionó de inmediato en ElementaryOS Freya (basado en Ubuntu 14.04); Estaba recibiendo el

[TerminalIPythonApp] ADVERTENCIA | Archivo no encontrado: ''kernelspec''

error que Quickbug describió en la respuesta de Matt . Primero tuve que hacer:

sudo apt-get install pip3 , luego

sudo pip3 install ipython[all]

En ese momento, puede ejecutar los comandos que Matt sugirió; a saber: ipython kernelspec install-self e ipython3 kernelspec install-self

Ahora, cuando inicio ipython notebook y luego abro una notebook, puedo seleccionar el kernel de Python 3 en el menú Kernel.

Para el actual Python Launcher

Si tiene instalado Py3 pero por defecto es py2

py -3 -m pip install ipykernel py -3 -m ipykernel install --user

Si tiene instalado Py2 pero por defecto es py3

py -2 -m pip install ipykernel py -2 -m ipykernel install --user

Si está utilizando la distribución anaconda, esto funcionó para mí (en una macintosh):

$ conda create -n py3k python=3 anaconda $ source activate py3k $ ipython kernelspec install-self

Solo una nota para el último comando:

(py3k)Monas-MacBook-Pro:cs799 mona$ ipython kernelspec install-self [TerminalIPythonApp] WARNING | Subcommand `ipython kernelspec` is deprecated and will be removed in future versions. [TerminalIPythonApp] WARNING | You likely want to use `jupyter kernelspec` in the future [InstallNativeKernelSpec] WARNING | `jupyter kernelspec install-self` is DEPRECATED as of 4.0. You probably want `ipython kernel install` to install the IPython kernelspec. [InstallNativeKernelSpec] Installed kernelspec python3 in /usr/local/share/jupyter/kernels/python3 (py3k)Monas-MacBook-Pro:cs799 mona$ ipython kernel install Installed kernelspec python3 in /usr/local/share/jupyter/kernels/python3

Según lo probado en OSX Yosemite con los pasos anteriores e ingresando jupter notebook y creando una nueva notebook en el navegador, verá la siguiente captura de pantalla:

Tenía Python 2.7 y quería poder cambiar a Python 3 dentro de Jupyter.

Estos pasos me funcionaron en un símbolo del sistema de Windows Anaconda:

conda update conda conda create -n py33 python=3.3 anaconda activate py33 ipython kernelspec install-self deactivate

Ahora, después de abrir el cuaderno de ipython con el comando habitual para Python2.7, Python3.3 también está disponible al crear un nuevo cuaderno.

abra la terminal (o cmd para la ventana), luego ejecute los siguientes comandos: (En la ventana, suelte "fuente" en la segunda línea).

conda create -n py35 python=3.5 source activate py35 conda install notebook ipykernel ipython kernel install --user --name=python3.5

Intenté algún método pero no funciona, luego lo encontré de esta manera. Funcionó conmigo Esperando que pueda ayudar.

para versiones recientes de jupyter / ipython : use jupyter kernelspec

enumerar los núcleos actuales

$ jupyter kernelspec list Available kernels: python2 .../Jupyter/kernels/python2 python3 .../Jupyter/kernels/python3

En mi caso, la configuración del núcleo python3 se rompió porque el enlace py3.5 ya no estaba allí, reemplazado por un py3.6

agregar / quitar núcleos

Eliminar:

$ jupyter kernelspec uninstall python3

Agrega uno nuevo:

$ jupyter kernelspec install /usr/local/Cellar/python3/3.6.1/bin/

Para encontrar la carpeta, puede usar which PYTHON por ejemplo, which python3.6 (o pyenv which python3.6 si está usando pyenv!). Entonces

ls -la `which python3.6`

le mostrará dónde está el ejecutable.

Lista de nuevo:

$ jupyter kernelspec list Available kernels: python3 /usr/local/lib/python3.6/site-packages/ipykernel/resources python2 /Users/stefano/Library/Jupyter/kernels/python2

Doc: https://jupyter-client.readthedocs.io/en/latest/kernels.html#kernelspecs

Detalles

Los núcleos disponibles se enumeran en la carpeta de kernels en el DIRECTORIO DE DATOS de Jupyter (consulte http://jupyter.readthedocs.io/en/latest/projects/jupyter-directories.html para más detalles).

Por ejemplo, en macosx, sería /Users/YOURUSERNAME/Library/Jupyter/kernels/

el núcleo simplemente se describe mediante un archivo kernel.json , por ejemplo. para /Users/me/Library/Jupyter/kernels/python3/kernel.json

{ "argv": [ "/usr/local/opt/python3/bin/python3.5", "-m", "ipykernel", "-f", "{connection_file}" ], "language": "python", "display_name": "Python 3" }

En lugar de manipular eso a mano, puede usar el comando kernelspec (como se kernelspec anteriormente). Anteriormente estaba disponible a través de ipython ahora a través de jupyter ( http://ipython.readthedocs.io/en/stable/install/kernel_install.html#kernels-for-different-environments - https://jupyter-client.readthedocs.io/en/latest/kernels.html#kernelspecs ).

$ jupyter kernelspec help Manage Jupyter kernel specifications. Subcommands ----------- Subcommands are launched as `jupyter kernelspec cmd [args]`. For information on using subcommand ''cmd'', do: `jupyter kernelspec cmd -h`. list List installed kernel specifications. install Install a kernel specification directory. uninstall Alias for remove remove Remove one or more Jupyter kernelspecs by name. install-self [DEPRECATED] Install the IPython kernel spec directory for this Python. To see all available configurables, use `--help-all`

Kernels para otros idiomas

Por cierto, no está estrictamente relacionado con esta pregunta, pero hay muchos otros núcleos disponibles ... https://github.com/jupyter/jupyter/wiki/Jupyter-kernels

sudo apt-get install python3-pip python3-dev pip3 install -U jupyter