I miei Jupyternotebook installati con python 2kernel. Non capisco perchè. Potrei aver incasinato qualcosa quando ho fatto l'installazione. Ho già python 3 installato. Come posso aggiungerlo a Jupyter? Ecco uno screenshot di quello di default Jupyterinsalled con python3 -m install jupytere aperto nel browser con jupyter notebookappare come segue:

Questo ha funzionato per me su Ubuntu 16.04:

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

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

Riferimento alla documentazione:
kernel per Python 2 e 3 . Installazione del kernel IPython - IPython Docs.

Assicurati di averlo ipykernelinstallato e utilizzato ipython kernel installper rilasciare kernelspec nella posizione corretta per python2. Quindi ipython3 kernel installper Python3. Ora dovresti essere in grado di scegliere tra i 2 kernel indipendentemente dal tuo utilizzo jupyter notebook, ipython notebookoipython3 notebook (il più tardi due sono obsolete).

Nota che se vuoi installare un eseguibile Python specifico puoi usare il seguente trucco:

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

Funziona quando si usano ambienti (venv, conda, ...) e <options>ti permettono di nominare il tuo kernel (vedi --help). Quindi puoi farlo

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

E ora ottieni un kernel chiamato py36-testnei menu a discesa, insieme agli altri.

Vedere Uso di Python 2.xe Python 3.x in Notebook IPython che contiene informazioni più recenti.

1. Ho un notebook ipython con Python2 (su Windows7)
2. passare a Jupyter con pip install -U jupyter
3. installa Python3
4. installare nuovamente Jupyter usando pip3 install jupyter
5. installa il kernel Python3 usando ipython3 kernelspec install-self
6. Finalmente ho ottenuto 2 kernel funzionanti.

per le versioni recenti di jupyter / ipython : utilizzarejupyter kernelspec

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

elenca i kernel correnti

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

Nel mio caso, l'installazione del kernel python3 è stata interrotta perché il py3.5 collegato non era più lì, sostituito da un py3.6

aggiungi / rimuovi kernel

Rimuovere:

$ jupyter kernelspec uninstall python3

Aggiungine uno nuovo: usando il Python che desideri aggiungere e indicando il python che esegue il tuo Giove:

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

Vedi altri esempi in https://ipython.readthedocs.io/en/6.5.0/install/kernel_install.html#kernels-for-different-environments

Elenca di nuovo:

$ 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

Dettagli

I kernel disponibili sono elencati nella kernelscartella in DIRECTORY DATI di Jupyter (vedi http://jupyter.readthedocs.io/en/latest/projects/jupyter-directories.html per i dettagli).

Ad esempio, su macosx sarebbe /Users/YOURUSERNAME/Library/Jupyter/kernels/

il kernel è semplicemente descritto da un kernel.jsonfile, ad es. per/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"
}

Invece di manipolarlo a mano, puoi usare il kernelspeccomando (come sopra). In precedenza era disponibile tramite ipython ora tramite jupyter ( http://ipython.readthedocs.io/en/stable/install/kernel_install.html#kernels-for-different-environments - https://jupyter-client.readthedocs.io/ it / 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`

Gherigli per altre lingue

A proposito, non strettamente correlato a questa domanda, ma ci sono molti altri kernel disponibili ... https://github.com/jupyter/jupyter/wiki/Jupyter-kernels

Se stai usando la distribuzione di anaconda, questo ha funzionato per me (su un macintosh):

$ conda create -n py3k python=3 anaconda

$ source activate py3k

$ ipython kernelspec install-self

Solo una nota per l'ultimo 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

Come testato in OSX Yosemite con i passaggi precedenti e immettendo jupter notebooke creando un nuovo blocco note nel browser verrà visualizzato il seguente screenshot:

Il comando seguente funziona per me, su macOS Sierra (10.12.3)

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

controllalo con l'elenco dei kernel di jupyter kernel disponibili: python3 / Users / admin / Library / Jupyter / kernel / python3 python2 / anaconda2 / share / jupyter / kernels / python2

Ho installato con successo il kernel python3 su macOS El Capitan (versione ipython: 4.1.0) con i seguenti comandi.

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

Puoi vedere tutti i kernel installati con jupyter kernelspec list.

Maggiori informazioni sono disponibili qui

apri il terminale (o cmd per la finestra), quindi esegui i seguenti comandi: (Nella finestra, rilascia "sorgente" nella seconda riga.)

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

Ho provato un metodo ma non funziona, quindi l'ho trovato in questo modo. Ha funzionato con me. Sperando che possa aiutare.

Avevo Python 2.7 e volevo poter passare a Python 3 all'interno di Jupyter.

Questi passaggi hanno funzionato per me su un prompt dei comandi di Windows Anaconda:

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

Ora dopo aver aperto il notebook ipython con il solito comando per Python2.7, Python3.3 è disponibile anche durante la creazione di un nuovo notebook.

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

Per l'attuale Python Launcher

Se hai installato Py3 ma predefinito su py2

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

Se hai installato Py2 ma predefinito su py3

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

Su Ubuntu 14.04 ho dovuto usare una combinazione di risposte precedenti.

Innanzitutto, installa pip3 apt-get install python-pip3

Quindi con pip3install jupyter pip3 install jupyter

Quindi usando ipython3install il kernel ipython3 kernel install

Nessuna delle altre risposte ha funzionato per me immediatamente su ElementaryOS Freya (basato su Ubuntu 14.04); Stavo ottenendo il

[TerminalIPythonApp] ATTENZIONE | File non trovato: 'kernelspec'

errore che QuickBug ha descritto nella risposta di Matt . Prima dovevo fare:

sudo apt-get install pip3, poi

sudo pip3 install ipython[all]

A quel punto puoi quindi eseguire i comandi che Matt ha suggerito; vale a dire: ipython kernelspec install-selfeipython3 kernelspec install-self

Ora quando avvio ipython notebooke quindi apro un notebook, sono in grado di selezionare il kernel Python 3 dal menu Kernel.

Sono riuscito a installare un kernel Python3 oltre a Python2. Ecco come l'ho fatto:

• apri un nuovo quaderno in Jupyter
• copia ed esegui qui le due celle: Enable-Python-3-kernel

L'ultimo link funzionante può essere trovato qui .

Il codice attuale è:

! 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 soluzione è ben documentata nei documenti ufficiali: https://ipython.readthedocs.org/en/latest/install/kernel_install.html

Ho provato il primo approccio. Dal momento che avevo già ipykernelinstallato, semplicemente in esecuzione python3 -m ipykernel install --userrisolto il problema.

La soluzione più breve e migliore dalla mia parte

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'aggiunta del kernel significa che si desidera utilizzare Jupyter Notebookcon versioni di Python che non vengono visualizzate nell'elenco.

Approccio semplice: avvia il notebook con la versione python richiesta, supponi che io abbia python3.7installato, quindi usa il comando seguente dal terminale (cmd) per eseguire il notebook:

python3.7 -m notebook

A volte invece di python3.7installarlo con lo pseudonimo di py, py3.7, python.

INSTALLAZIONE DI PIÙ KERNEL IN UN SOLO AMBIENTE VIRTUALE (VENV)

La maggior parte (se non tutte) di queste risposte presuppone che tu sia felice di installare i pacchetti a livello globale. Questa risposta è per te se:

• usa una macchina * NIX
• non mi piace installare i pacchetti a livello globale
• non vuoi usare anaconda <-> sei felice di eseguire il server jupyter dalla riga di comando
• vuole avere un'idea di cosa / dove l'installazione del kernel sia.

(Nota: questa risposta aggiunge un kernel python2 a un'installazione python3-jupyter, ma concettualmente è facile scambiare le cose.)

1. Prerequisiti

   1. Sei nella directory da cui eseguirai il server jupyter e salverai i file
   2. python2 è installato sul tuo computer
   3. python3 è installato sul tuo computer
   4. virtualenv è installato sul tuo computer

2. Crea un venv python3 e installa jupyter

   1. Crea una nuova venv python3: python3 -m venv .venv
   2. Attiva il venv: . .venv/bin/activate
   3. Installa jupyterlab: pip install jupyterlab . Ciò creerà localmente tutta l'infrastruttura essenziale per l'esecuzione dei notebook.
   4. Nota: installando qui jupyterlab, si generano anche 'specifiche del kernel' predefinite (vedi sotto) in $PWD/.venv/share/jupyter/kernels/python3/. Se vuoi installare ed eseguire jupyter altrove e usare questo venv solo per organizzare tutti i tuoi kernel, allora hai solo bisogno di:pip install ipykernel
   5. Ora puoi eseguire jupyter lab con jupyter lab(e andare sul tuo browser all'URL visualizzato nella console). Finora, vedrai solo un'opzione del kernel chiamata 'Python 3'. (Questo nome è determinato dalla display_namevoce nel tuo kernel.jsonfile.)

3. Aggiungi un kernel python2

   1. Esci da jupyter (o avvia un'altra shell nella stessa directory): ctrl-c
   2. Disattiva il tuo python3 venv: deactivate
   3. Crea un nuovo venv nella stessa directory per python2: virtualenv -p python2 .venv2
   4. Attiva il tuo python2 venv: . .venv2/bin/activate
   5. Installare il modulo ipykernel: pip install ipykernel. Questo genererà anche le specifiche del kernel predefinite per questo Python2 venv in.venv2/share/jupyter/kernels/python2
   6. Esportare queste specifiche del kernel al vostro venv python3: python -m ipykernel install --prefix=$PWD/.venv. Questo fondamentalmente solo copia il dir $PWD/.venv2/share/jupyter/kernels/python2a$PWD/.venv/share/jupyter/kernels/
   7. Passare di nuovo al vostro venv python3 e / o di rieseguire / ri-esaminare il server jupyter: deactivate; . .venv/bin/activate; jupyter lab. Se tutto è andato bene, vedrai Python 2un'opzione nel tuo elenco di kernel. Puoi provare che stanno eseguendo veri interpreti python2 / python3 gestendo un semplice print 'Hellow world'vsprint('Hellow world') comando
   8. Nota: non è necessario creare un venv separato per python2 se si è felici di installare ipykernel e fare riferimento alle specifiche del kernel python2 da uno spazio globale, ma preferisco avere tutte le mie dipendenze in una directory locale

TL; DR

4. Opzionalmente installare un kernel R. Questo è istruttivo per sviluppare un senso di ciò che un kernel "è".
   1. Dalla stessa dir, installare il pacchetto R IRkernel: R -e "install.packages('IRkernel',repos='https://cran.mtu.edu/')". (Questo verrà installato nella posizione dei pacchetti R standard; per R installato in casa su un Mac, sarà simile/usr/local/Cellar/r/3.5.2_2/lib/R/library/IRkernel .)
   2. Il pacchetto IRkernel è dotato di una funzione per esportare le sue specifiche del kernel, in modo da eseguire: R -e "IRkernel::installspec(prefix=paste(getwd(),'/.venv',sep=''))". Se ora guardi dentro $PWD/.venv/share/jupyter/kernels/troverai una irdirectory con kernel.jsonfile che assomiglia a questo:

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

In breve, un kernel 'è' solo un richiamo di un eseguibile specifico della lingua da un kernel.jsonfile che jupyter cerca nella directory .../share/jupyter/kernelse negli elenchi nella sua interfaccia; in questo caso, R viene chiamato per eseguire la funzione IRkernel::main(), che invierà i messaggi avanti e indietro al server Jupiter. Allo stesso modo, il kernel python2 'è' solo una chiamata dell'interprete python2 con modulo ipykernel_launchercome visto in .venv/share/jupyter/kernels/python2/kernel.json, ecc.

Ecco uno script se vuoi eseguire tutte queste istruzioni in un colpo solo.

Ecco un metodo Windows / non a riga di comando che ho trovato, che ha funzionato per me: trova la cartella in cui sono memorizzati i file del kernel (sulla mia macchina - C: \ ProgramData \ jupyter \ kernels - nota che ProgramData è una cartella nascosta), crea un copia della cartella del kernel esistente, cambia il nome e modifica il file json all'interno per puntare alla nuova directory del kernel. In questo json è anche possibile modificare il nome del kernel che viene visualizzato in ipython (ad esempio, invece di solo Python 2, è possibile specificare 2.7.9 se è necessario distinguere ulteriormente per qualche motivo).

Quando usi conda per gestire i tuoi python envs, segui questi due passaggi:

1. activate py3(su Windows o source activate py3su Linux)
2. conda install notebook ipykernel o semplicemente usa conda install jupyter

Stavo ottenendo lo stesso errore con python-2. Volevo eseguire la sessione di notebook jupyter python-2 ma di default stavo ottenendo python-3. Quindi la soluzione più semplice è aprire il terminale Anaconda per python-2 e digitare 'jupyter notebook' , avvierà la sessione jupyter-notebook senza alcun problema. Allo stesso modo potrebbe essere provato con Python-3

Sono abbastanza sicuro che tutto ciò che devi fare è correre

pip3 installa jupyter