Mes Jupytercahiers installés avec le python 2noyau. Je ne comprends pas pourquoi. J'ai peut-être foiré quelque chose quand j'ai fait l'installation. J'ai déjà python 3 installé. Comment puis-je l'ajouter Jupyter? Voici une capture d'écran de ce à quoi la valeur par défaut Jupyterinsallée python3 -m install jupyteret ouverte dans le navigateur jupyter notebookressemble:

Cela a fonctionné pour moi sur Ubuntu 16.04:

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

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

Référence à la documentation:
noyaux pour Python 2 et 3 . Installation du noyau IPython - IPython Docs.

Assurez-vous que vous avez ipykernelinstallé et utilisé ipython kernel installpour déposer le kernelspec au bon endroit pour python2. Ensuite ipython3 kernel installpour Python3. Maintenant , vous devriez être en mesure de choisir entre les 2 noyaux indépendamment du fait que vous utilisez jupyter notebook, ipython notebookou ipython3 notebook(le plus tard deux sont déconseillés).

Notez que si vous souhaitez installer pour un exécutable Python spécifique, vous pouvez utiliser l'astuce suivante:

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

Cela fonctionne lors de l'utilisation d'environnements (venv, conda, ...) et <options>vous permet de nommer votre noyau (voir --help). Vous pouvez donc faire

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

Et maintenant, vous obtenez un noyau nommé py36-testdans vos menus déroulants, ainsi que les autres.

Voir Utilisation de Python 2.x et Python 3.x dans IPython Notebook qui contient des informations plus récentes.

1. Got notebook ipython avec Python2 (sur Windows7)
2. passer à Jupyter avec pip install -U jupyter
3. installer Python3
4. réinstaller Jupyter en utilisant pip3 install jupyter
5. installer le noyau Python3 en utilisant ipython3 kernelspec install-self
6. J'ai finalement obtenu 2 noyaux de travail.

pour les versions récentes de jupyter / ipython : utilisezjupyter kernelspec

Doc complet: https://ipython.readthedocs.io/en/latest/install/kernel_install.html

lister les noyaux actuels

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

Dans mon cas, la configuration du noyau python3 a été interrompue car le py3.5 lié n'était plus là, remplacé par un py3.6

ajouter / supprimer des noyaux

Retirer:

$ jupyter kernelspec uninstall python3

Ajouter un nouveau: En utilisant le Python que vous souhaitez ajouter et en pointant sur le python qui exécute votre jupiter:

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

Voir plus d'exemples dans https://ipython.readthedocs.io/en/6.5.0/install/kernel_install.html#kernels-for-different-environments

Répertorier:

$ 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

Détails

Les noyaux disponibles sont répertoriés dans le kernelsdossier du RÉPERTOIRE DE DONNÉES Jupyter (voir http://jupyter.readthedocs.io/en/latest/projects/jupyter-directories.html pour plus de détails).

Par exemple, sur macosx, ce serait /Users/YOURUSERNAME/Library/Jupyter/kernels/

le noyau est simplement décrit par un kernel.jsonfichier, par exemple. pour/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"
}

Plutôt que de manipuler cela à la main, vous pouvez utiliser la kernelspeccommande (comme ci-dessus). Il était auparavant disponible via ipython via jupyter ( http://ipython.readthedocs.io/en/stable/install/kernel_install.html#kernels-for-different-environments - https://jupyter-client.readthedocs.io/ fr / 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`

Noyaux pour d'autres langues

Au fait, pas strictement lié à cette question mais il y a beaucoup d'autres noyaux disponibles ... https://github.com/jupyter/jupyter/wiki/Jupyter-kernels

Si vous utilisez la distribution anaconda, cela a fonctionné pour moi (sur un macintosh):

$ conda create -n py3k python=3 anaconda

$ source activate py3k

$ ipython kernelspec install-self

Juste une note pour la dernière commande:

(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

Comme testé dans OSX Yosemite avec les étapes ci-dessus et en entrant jupter notebooket en créant un nouveau bloc-notes dans le navigateur, vous verrez la capture d'écran suivante:

La commande suivante fonctionne pour moi, sur macOS Sierra (10.12.3)

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

vérifier avec jupyter kernelspec list Noyaux disponibles: python3 / Users / admin / Library / Jupyter / kernels / python3 python2 / anaconda2 / share / jupyter / kernels / python2

J'ai installé avec succès le noyau python3 sur macOS El Capitan (version ipython: 4.1.0) avec les commandes suivantes.

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

Vous pouvez voir tous les noyaux installés avec jupyter kernelspec list.

Plus d'informations sont disponibles ici

ouvrez le terminal (ou cmd pour la fenêtre), puis exécutez les commandes suivantes: (Sur la fenêtre, déposez "source" sur la deuxième ligne.)

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

J'ai essayé une méthode mais ça ne marche pas, j'ai trouvé ça. Ça a marché avec moi. En espérant que cela puisse aider.

J'avais Python 2.7 et je voulais pouvoir passer à Python 3 à l'intérieur de Jupyter.

Ces étapes ont fonctionné pour moi sur une invite de commande Windows Anaconda:

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

Maintenant, après avoir ouvert le bloc-notes ipython avec la commande habituelle pour Python2.7, Python3.3 est également disponible lors de la création d'un nouveau bloc-notes.

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

Pour le lanceur Python actuel

Si vous avez installé Py3 mais par défaut py2

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

Si vous avez installé Py2 mais par défaut py3

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

Sur Ubuntu 14.04, j'ai dû utiliser une combinaison de réponses précédentes.

Tout d'abord, installez pip3 apt-get install python-pip3

Puis avec pip3install jupyter pip3 install jupyter

Puis en utilisant ipython3installer le noyau ipython3 kernel install

Aucune des autres réponses ne fonctionnait pour moi immédiatement sur ElementaryOS Freya (basé sur Ubuntu 14.04); Je recevais le

[TerminalIPythonApp] AVERTISSEMENT | Fichier introuvable: 'kernelspec'

erreur que quickbug décrit sous la réponse de Matt . Je devais d'abord faire:

sudo apt-get install pip3, puis

sudo pip3 install ipython[all]

À ce stade, vous pouvez ensuite exécuter les commandes suggérées par Matt ; à savoir: ipython kernelspec install-selfetipython3 kernelspec install-self

Maintenant, lorsque je lance ipython notebookpuis ouvre un cahier, je peux sélectionner le noyau Python 3 dans le menu Kernel.

J'ai réussi à installer un noyau Python3 en plus de Python2. Voici comment je l'ai fait:

• ouvrir un nouveau cahier dans Jupyter
• copiez et exécutez les deux cellules ici: Enable-Python-3-kernel

Le dernier lien de travail se trouve ici .

Le code réel est:

! 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 solution est bien documentée dans les documents officiels: https://ipython.readthedocs.org/en/latest/install/kernel_install.html

J'ai essayé la première approche. Étant donné que j'avais déjà ipykernelinstallé, simplement l'exécution a python3 -m ipykernel install --userrésolu le problème.

La solution la plus courte et la meilleure de mon côté

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

L'ajout de noyau signifie que vous souhaitez utiliser Jupyter Notebookavec des versions de python qui n'apparaissent pas dans la liste.

Approche simple: démarrez le bloc-notes avec la version python requise, supposons que j'aie python3.7installé puis utilisez la commande ci-dessous à partir du terminal (cmd) pour exécuter le bloc-notes:

python3.7 -m notebook

Parfois, au lieu de python3.7son installation avec l'alias depy, py3.7, python .

INSTALLATION DE MULTIPLES AMANDES DANS UN ENVIRONNEMENT VIRTUEL UNIQUE (VENV)

La plupart (sinon toutes) de ces réponses supposent que vous êtes heureux d'installer des packages à l'échelle mondiale. Cette réponse est pour vous si vous:

• utiliser une machine * NIX
• n'aime pas installer des packages à l'échelle mondiale
• vous ne voulez pas utiliser anaconda <-> vous êtes heureux d'exécuter le serveur jupyter à partir de la ligne de commande
• veulent avoir une idée de ce que / où est l'installation du noyau.

(Remarque: cette réponse ajoute un noyau python2 à une installation python3-jupyter, mais il est conceptuellement facile d'échanger les choses.)

1. Conditions préalables

   1. Vous êtes dans le répertoire à partir duquel vous allez exécuter le serveur jupyter et enregistrer les fichiers
   2. python2 est installé sur votre machine
   3. python3 est installé sur votre machine
   4. virtualenv est installé sur votre machine

2. Créez un venv python3 et installez jupyter

   1. Créez un nouveau venv python3: python3 -m venv .venv
   2. Activez le venv: . .venv/bin/activate
   3. Installer jupyterlab: pip install jupyterlab. Cela créera localement toute l'infrastructure essentielle pour faire fonctionner les ordinateurs portables.
   4. Remarque: en installant jupyterlab ici, vous générez également des 'spécifications de noyau' par défaut (voir ci-dessous) dans $PWD/.venv/share/jupyter/kernels/python3/. Si vous souhaitez installer et exécuter jupyter ailleurs, et utiliser uniquement ce venv pour organiser tous vos noyaux, alors vous n'avez besoin que:pip install ipykernel
   5. Vous pouvez maintenant exécuter jupyter lab avec jupyter lab(et accédez à votre navigateur à l'url affichée dans la console). Jusqu'à présent, vous ne verrez qu'une seule option de noyau appelée 'Python 3'. (Ce nom est déterminé par l' display_nameentrée dans votre kernel.jsonfichier.)

3. Ajouter un noyau python2

   1. Quittez jupyter (ou démarrez un autre shell dans le même répertoire): ctrl-c
   2. Désactivez votre python3 venv: deactivate
   3. Créez un nouveau venv dans le même répertoire pour python2: virtualenv -p python2 .venv2
   4. Activez votre python2 venv: . .venv2/bin/activate
   5. Installez le module ipykernel: pip install ipykernel. Cela générera également des spécifications de noyau par défaut pour ce venv python2 dans.venv2/share/jupyter/kernels/python2
   6. Exporter ces spécifications du noyau à votre python3 venv: python -m ipykernel install --prefix=$PWD/.venv. Cela copie simplement le répertoire $PWD/.venv2/share/jupyter/kernels/python2dans$PWD/.venv/share/jupyter/kernels/
   7. Revenez à votre venv de python3 et / ou exécutez à nouveau / re-interroger votre serveur jupyter: deactivate; . .venv/bin/activate; jupyter lab. Si tout s'est bien passé, vous verrez une Python 2option dans votre liste de noyaux. Vous pouvez tester qu'ils exécutent de vrais interprètes python2 / python3 en gérant une simple commande print 'Hellow world'vs.print('Hellow world')
   8. Remarque: vous n'avez pas besoin de créer un venv séparé pour python2 si vous êtes heureux d'installer ipykernel et de référencer les spécifications du noyau python2 à partir d'un espace global, mais je préfère avoir toutes mes dépendances dans un répertoire local

TL; DR

4. Installez éventuellement un noyau R. Cela est instructif pour développer une idée de ce qu'est un noyau.
   1. De la même répertoire, installez le package R IRkernel: R -e "install.packages('IRkernel',repos='https://cran.mtu.edu/')". (Cela s'installera à votre emplacement R-packages standard; pour R installé à la maison sur un Mac, cela ressemblera /usr/local/Cellar/r/3.5.2_2/lib/R/library/IRkernel.)
   2. Le paquet IRkernel est livré avec une fonction pour exporter ses spécifications du noyau, donc exécuter: R -e "IRkernel::installspec(prefix=paste(getwd(),'/.venv',sep=''))". Si vous regardez maintenant dans, $PWD/.venv/share/jupyter/kernels/vous trouverez un irrépertoire avec un kernel.jsonfichier qui ressemble à ceci:

{
  "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 résumé, un noyau «est» simplement une invocation d'un exécutable spécifique à une langue à partir d'un kernel.jsonfichier que jupyter recherche dans le répertoire .../share/jupyter/kernelset répertorie dans son interface; dans ce cas, R est appelé pour exécuter la fonction IRkernel::main(), qui enverra des messages d'avant en arrière au serveur Jupiter. De même, le noyau python2 est juste «une» invocation de l'interpréteur python2 avec module ipykernel_launchercomme vu dans.venv/share/jupyter/kernels/python2/kernel.json , etc.

Voici un script si vous souhaitez exécuter toutes ces instructions d'un seul coup.

Voici une méthode Windows / sans ligne de commande que j'ai trouvée, qui a fonctionné pour moi: recherchez le dossier où les fichiers du noyau sont stockés (sur ma machine - C: \ ProgramData \ jupyter \ kernels - notez que ProgramData est un dossier caché), créez un copie du dossier du noyau existant, changez le nom et éditez le fichier json à l'intérieur pour pointer vers le nouveau répertoire du noyau. Dans ce json, vous pouvez également modifier le nom du noyau qui est affiché dans ipython (par exemple, au lieu de simplement python 2, vous pouvez spécifier 2.7.9 si vous avez besoin de faire une distinction supplémentaire pour une raison quelconque).

Lorsque vous utilisez conda pour gérer vos envs python, procédez comme suit:

1. activate py3(sous Windows ou source activate py3sous Linux)
2. conda install notebook ipykernel ou utilisez simplement conda install jupyter

J'obtenais la même erreur avec python-2. Je voulais exécuter une session de bloc-notes jupyter python-2, mais par défaut, j'obtenais python-3. La solution la plus simple est donc d'ouvrir le terminal Anaconda pour python-2 et de taper 'jupyter notebook' , il lancera la session jupyter-notebook sans aucun problème. Similairement, il pourrait être essayé avec python-3

Je suis sûr que tout ce que tu as à faire est de courir

pip3 installer jupyter