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

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.

Asegúrese de haber ipykernelinstalado y usar ipython kernel installpara soltar el kernelspec en la ubicación correcta para python2. Luego ipython3 kernel installpara Python3. Ahora usted debería ser capaz de elegir entre los 2 núcleos, independientemente de si se utiliza jupyter notebook, ipython notebookoipython3 notebook (la tarde dos 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 le <options>permiten nombrar su núcleo (ver --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 nombrado py36-testen 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.

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

para versiones recientes de jupyter / ipython : usejupyter kernelspec

Documento completo: https://ipython.readthedocs.io/en/latest/install/kernel_install.html

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

Agregue uno nuevo: usando el Python que desea agregar y señalando el python que ejecuta su júpiter:

$ /path/to/kernel/env/bin/python -m ipykernel install --prefix=/path/to/jupyter/env --name 'python-my-env'

Ver más ejemplos en https://ipython.readthedocs.io/en/6.5.0/install/kernel_install.html#kernels-for-different-environments

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 kernelscarpeta 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 eso sería /Users/YOURUSERNAME/Library/Jupyter/kernels/

el núcleo simplemente se describe mediante un kernel.jsonarchivo, 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 kernelspeccomando (como arriba). 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/ es / 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

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 notebooky creando una nueva computadora portátil en el navegador, verá la siguiente captura de pantalla:

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

Instalé con éxito el núcleo python3 en macOS El Capitan (versión 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 aquí

abra la terminal (o cmd para 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, entonces lo encontré de esta manera. Funcionó conmigo Esperando que pueda ayudar.

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.

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

Para el actual Python Launcher

Si tiene instalado Py3 pero el valor predeterminado 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

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

Primero instale pip3 apt-get install python-pip3

Luego con pip3instalar jupyter pip3 install jupyter

Luego usando ipython3instalar el kernel ipython3 kernel install

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 punto, puede ejecutar los comandos que Matt sugirió; a saber: ipython kernelspec install-selfyipython3 kernelspec install-self

Ahora, cuando inicio ipython notebooky luego abro un cuaderno, puedo seleccionar el núcleo de Python 3 en el menú Kernel.

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

• abrir un nuevo cuaderno en Jupyter
• copia y ejecuta las dos celdas aquí: Enable-Python-3-kernel

El último enlace de trabajo se puede encontrar aquí .

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"
 }
}

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 lo había ipykernelinstalado, simplemente ejecutar python3 -m ipykernel install --userresolvió 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

Agregar kernel significa que quieres usar Jupyter Notebook con versiones de python que no se muestran en la lista.

Enfoque simple: inicie el cuaderno con la versión de python requerida, suponga que lo he python3.7instalado y luego use el siguiente comando desde la terminal (cmd) para ejecutar el cuaderno:

python3.7 -m notebook

A veces, en lugar de python3.7instalar con alias de py, py3.7, python.

INSTALACIÓN DE KERNELS 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 kernel python2 a una instalación python3-jupyter, pero es conceptualmente fácil intercambiar cosas).

1. 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

2. Crea un venv python3 e instala jupyter

   1. Crea 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 display_nameentrada en su kernel.jsonarchivo).

3. Agregar un núcleo 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. Instalar 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. Exportar estas especificaciones kernel a su Venv python3: python -m ipykernel install --prefix=$PWD/.venv. Esto básicamente solo copia el directorio $PWD/.venv2/share/jupyter/kernels/python2a$PWD/.venv/share/jupyter/kernels/
   7. Cambie de nuevo a su Venv python3 y / o volver a ejecutar / re-examinar su servidor jupyter: deactivate; . .venv/bin/activate; jupyter lab. Si todo salió bien, verá una Python 2opción en su lista de núcleos. Puede probar que ejecutan intérpretes reales de python2 / python3 al manejar un print 'Hellow world'vs simpleprint('Hellow world') comando
   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

4. Opcionalmente instale un kernel R. Esto es instructivo para desarrollar un sentido de lo que es un núcleo.
   1. Del mismo directorio, instalar 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á así /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 ejecute: R -e "IRkernel::installspec(prefix=paste(getwd(),'/.venv',sep=''))". Si ahora busca $PWD/.venv/share/jupyter/kernels/, encontrará un irdirectorio con un kernel.jsonarchivo similar a este:

{
  "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 núcleo simplemente 'es' una invocación de un ejecutable específico del idioma desde un kernel.jsonarchivo que Jupyter busca en el .../share/jupyter/kernelsdirectorio 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 de Júpiter. Del mismo modo, el núcleo python2 simplemente 'es' una invocación del intérprete python2 con el módulo ipykernel_launchercomo 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.

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 que apunte 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).

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

1. activate py3(en Windows o source activate py3en Linux)
2. conda install notebook ipykernel o simplemente usar conda install jupyter

Estaba recibiendo el mismo error con python-2. Quería ejecutar la sesión de notebook jupyter python-2 pero por defecto estaba obteniendo python-3. La solución más fácil es abrir el terminal Anaconda para python-2 y escribir 'jupyter notebook' , lanzará la sesión jupyter-notebook sin ningún problema. De manera similar, podría probarse con python-3

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

pip3 instalar jupyter