Moje Jupyternotebooki zostały zainstalowane z python 2jądrem. Nie rozumiem dlaczego. Mogłem coś popsuć podczas instalacji. Już python 3 zainstalowałem. Jak mogę to dodać Jupyter? Oto zrzut ekranu tego, co domyślnie Jupyterinstaluje się python3 -m install jupyteri otwiera w przeglądarce za pomocą jupyter notebook:

To działało dla mnie na Ubuntu 16.04:

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

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

Odwołanie do dokumentacji:
Jądra dla Python 2 i 3 . Instalowanie jądra IPython - Dokumenty IPython.

Upewnij się, że ipykernelzainstalowałeś i użyj, ipython kernel installaby upuścić jądro w odpowiednim miejscu dla python2. Następnie ipython3 kernel installdla Python3. Teraz powinieneś być w stanie wybierać między 2 jądrami, niezależnie od tego, czy używasz jupyter notebook, ipython notebookczy ipython3 notebook(dwa późniejsze są przestarzałe).

Zauważ, że jeśli chcesz zainstalować konkretny plik wykonywalny Pythona, możesz użyć następującej sztuczki:

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

Działa to podczas korzystania ze środowisk (venv, conda, ...) i <options>pozwala nazwać jądro (patrz --help). Więc możesz to zrobić

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

A teraz masz jądro o nazwie py36-testw menu rozwijanych, obok innych.

Zobacz Używanie zarówno Python 2.x, jak i Python 3.x w IPython Notebook, który zawiera nowsze informacje.

1. Mam ipython notebook z Python2 (na Windows7)
2. uaktualnij do Jupyter za pomocą pip install -U jupyter
3. zainstaluj Python3
4. zainstaluj ponownie Jupyter za pomocą pip3 install jupyter
5. zainstaluj jądro Python3 używając ipython3 kernelspec install-self
6. W końcu mam 2 działające jądra.

dla najnowszych wersji jupyter / ipython : użyjjupyter kernelspec

Pełny dokument: https://ipython.readthedocs.io/en/latest/install/kernel_install.html

wyświetlać aktualne jądra

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

W moim przypadku konfiguracja jądra python3 została zerwana, ponieważ nie było już powiązanego py3.5, zastąpiono go py3.6

dodaj / usuń jądra

Usunąć:

$ jupyter kernelspec uninstall python3

Dodaj nowy: za pomocą Pythona, który chcesz dodać, i wskazując na python, który uruchamia twój Jowisz:

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

Zobacz więcej przykładów w https://ipython.readthedocs.io/en/6.5.0/install/kernel_install.html#kernels-for-different-environments

Wymień ponownie:

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

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

Detale

Dostępne jądra są wymienione w kernelsfolderze w KATALOGU DANYCH Jupyter ( szczegółowe informacje znajdują się na stronie http://jupyter.readthedocs.io/en/latest/projects/jupyter-directories.html ).

Na przykład na macosx /Users/YOURUSERNAME/Library/Jupyter/kernels/

jądro jest po prostu opisane przez kernel.jsonplik, np. dla/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"
}

Zamiast manipulować tym ręcznie, możesz użyć kernelspecpolecenia (jak wyżej). Był wcześniej dostępny za pośrednictwem ipython, teraz przez jupyter ( http://ipython.readthedocs.io/en/stable/install/kernel_install.html#kernels-for-different-environmentments - https://jupyter-client.readthedocs.io/ pl / 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`

Jądra dla innych języków

Nawiasem mówiąc, nie jest to ściśle związane z tym pytaniem, ale dostępnych jest wiele innych jąder ... https://github.com/jupyter/jupyter/wiki/Jupyter-kernels

Jeśli używasz dystrybucji anakondy, działało to dla mnie (na komputerze Macintosh):

$ conda create -n py3k python=3 anaconda

$ source activate py3k

$ ipython kernelspec install-self

Tylko uwaga do ostatniego polecenia:

(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

Testowany w OSX Yosemite z powyższymi krokami oraz wprowadzaniem jupter notebooki tworzeniem nowego notesu w przeglądarce zobaczysz następujący zrzut ekranu:

Następujące polecenie działa dla mnie w systemie macOS Sierra (10.12.3)

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

sprawdź to za pomocą listy jądra jupyter Dostępne jądra: python3 / Users / admin / Library / Jupyter / kernels / python3 python2 / anaconda2 / share / jupyter / kernels / python2

Pomyślnie zainstalowałem jądro Python3 na MacOS El Capitan (wersja ipython: 4.1.0) za pomocą następujących poleceń.

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

Możesz zobaczyć wszystkie zainstalowane jądra za pomocą jupyter kernelspec list.

Więcej informacji jest dostępnych tutaj

otwórz terminal (lub cmd dla okna), a następnie uruchom następujące polecenia: (W oknie upuść „źródło” w drugim wierszu.)

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

Próbowałem jakiejś metody, ale to nie działa, a potem znalazłem w ten sposób. To zadziałało ze mną. Mam nadzieję, że to może pomóc.

Miałem Python 2.7 i chciałem móc przełączyć się na Python 3 w Jupyter.

Te kroki działały dla mnie w wierszu polecenia systemu Windows Anaconda:

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

Teraz po otwarciu notesu ipython za pomocą zwykłej komendy dla Python2.7, Python3.3 jest również dostępny podczas tworzenia nowego notatnika.

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

Dla bieżącego programu uruchamiającego Python

Jeśli masz zainstalowany Py3, ale domyślnie jest to py2

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

Jeśli masz zainstalowany Py2, ale domyślnie jest to py3

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

W systemie Ubuntu 14.04 musiałem użyć kombinacji poprzednich odpowiedzi.

Najpierw zainstaluj pip3 apt-get install python-pip3

Następnie pip3zainstaluj jupyter pip3 install jupyter

Następnie za pomocą ipython3instalacji jądra ipython3 kernel install

Żadna z pozostałych odpowiedzi nie działała dla mnie od razu na ElementaryOS Freya (oparty na Ubuntu 14.04); Dostawałem

[TerminalIPythonApp] OSTRZEŻENIE | Nie znaleziono pliku: „kernelspec”

błąd opisany przez Quickbug w odpowiedzi Matta . Musiałem najpierw zrobić:

sudo apt-get install pip3, następnie

sudo pip3 install ipython[all]

W tym momencie możesz uruchomić polecenia sugerowane przez Matta ; mianowicie: ipython kernelspec install-selfiipython3 kernelspec install-self

Teraz, gdy uruchamiam, ipython notebooka następnie otwieram notatnik, jestem w stanie wybrać jądro Python 3 z menu jądra.

Udało mi się zainstalować jądro Python3 oprócz Python2. Oto jak to zrobiłem:

• otwórz nowy notatnik w Jupyter
• skopiuj i uruchom dwie komórki tutaj: Enable-Python-3-kernel

Najnowszy działający link można znaleźć tutaj .

Rzeczywisty kod to:

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

Rozwiązanie jest dobrze udokumentowane w oficjalnych dokumentach: https://ipython.readthedocs.org/en/latest/install/kernel_install.html

Próbowałem pierwszego podejścia. Ponieważ już ipykernelzainstalowałem, po prostu uruchomienie python3 -m ipykernel install --userrozwiązało problem.

Najkrótsze i najlepsze rozwiązanie z mojej strony

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

Dodanie jądra oznacza, że ​​chcesz korzystać Jupyter Notebookz wersji Pythona, które nie pojawiają się na liście.

Proste podejście - uruchom notebook z wymaganą wersją Pythona, załóżmy, że python3.7zainstalowałem, a następnie użyj poniżej polecenia z terminala (cmd), aby uruchomić notebook:

python3.7 -m notebook

Czasami zamiast python3.7instalować z aliasem py, py3.7, python.

INSTALOWANIE WIELU ZIARNÓW W JEDNYM WIRTUALNYM ŚRODOWISKU (VENV)

Większość (jeśli nie wszystkie) tych odpowiedzi zakłada, że ​​z przyjemnością instalujesz pakiety na całym świecie. Ta odpowiedź jest dla Ciebie, jeśli:

• użyj maszyny * NIX
• nie lubię instalować pakietów globalnie
• nie chcesz używać anakondy <-> z przyjemnością uruchomisz serwer jupyter z wiersza poleceń
• chcę mieć pojęcie, co / gdzie instalacja jądra „jest”.

(Uwaga: ta odpowiedź dodaje jądro python2 do instalacji python3-jupyter, ale pod względem koncepcyjnym łatwo jest zmieniać elementy).

1. Wymagania wstępne

   1. Jesteś w katalogu, z którego będziesz uruchamiać serwer jupyter i zapisywać pliki
   2. python2 jest zainstalowany na twoim komputerze
   3. python3 jest zainstalowany na twoim komputerze
   4. virtualenv jest zainstalowany na twoim komputerze

2. Utwórz venv python3 i zainstaluj jupyter

   1. Utwórz nowy venv python3: python3 -m venv .venv
   2. Aktywuj venv: . .venv/bin/activate
   3. Zainstalować jupyterlab: pip install jupyterlab. To stworzy lokalnie całą niezbędną infrastrukturę do uruchamiania notebooków.
   4. Uwaga: instalując tutaj jupyterlab, generujesz również domyślne „specyfikacje jądra” (patrz poniżej) w $PWD/.venv/share/jupyter/kernels/python3/. Jeśli chcesz zainstalować i uruchomić jupyter w innym miejscu i używać tego venv do organizowania wszystkich swoich jąder, potrzebujesz tylko:pip install ipykernel
   5. Możesz teraz uruchomić jupyter lab z jupyter lab(i przejść do przeglądarki na adres URL wyświetlany w konsoli). Jak dotąd zobaczysz tylko jedną opcję jądra o nazwie „Python 3”. (Ta nazwa jest określona przez display_namewpis w twoim kernel.jsonpliku).

3. Dodaj jądro python2

   1. Zamknij jupyter (lub uruchom inną powłokę w tym samym katalogu): ctrl-c
   2. Dezaktywuj Venv Python3: deactivate
   3. Utwórz nowy venv w tym samym katalogu dla python2: virtualenv -p python2 .venv2
   4. Aktywuj swój python2 venv: . .venv2/bin/activate
   5. Zainstalować moduł ipykernel: pip install ipykernel. Spowoduje to również wygenerowanie domyślnych specyfikacji jądra dla tej wersji python2.venv2/share/jupyter/kernels/python2
   6. Eksport tych specyfikacji jądra do python3 venv: python -m ipykernel install --prefix=$PWD/.venv. To po prostu kopiuje katalog $PWD/.venv2/share/jupyter/kernels/python2do$PWD/.venv/share/jupyter/kernels/
   7. Przełączyć się z powrotem do swojej python3 venv i / lub powtórka / ponowne zbadanie serwer jupyter: deactivate; . .venv/bin/activate; jupyter lab. Jeśli wszystko pójdzie dobrze, Python 2na liście jąder pojawi się opcja. Możesz przetestować, czy działają prawdziwe interpretery python2 / python3, posługując się prostą komendą print 'Hellow world'vs.print('Hellow world')
   8. Uwaga: nie musisz tworzyć osobnej wersji dla Python2, jeśli z przyjemnością instalujesz ipykernel i odwołujesz się do specyfikacji jądra python2 z globalnej przestrzeni, ale wolę mieć wszystkie moje zależności w jednym lokalnym katalogu

TL; DR

4. Opcjonalnie zainstaluj jądro R. Jest to pouczające, aby rozwinąć poczucie, czym jest „jądro” jądra.
   1. Z tym samym katalogu, należy zainstalować pakiet R IRkernel: R -e "install.packages('IRkernel',repos='https://cran.mtu.edu/')". (Spowoduje to zainstalowanie w standardowej lokalizacji pakietów R; będzie to wyglądać w przypadku warzonej w domu instalacji R na komputerze Mac /usr/local/Cellar/r/3.5.2_2/lib/R/library/IRkernel).
   2. Pakiet IRkernel pochodzi z funkcją eksportować swoje specyfikacje jądra, tak uruchomić: R -e "IRkernel::installspec(prefix=paste(getwd(),'/.venv',sep=''))". Jeśli spojrzysz teraz $PWD/.venv/share/jupyter/kernels/, znajdziesz irkatalog z kernel.jsonplikiem, który wygląda mniej więcej tak:

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

Podsumowując, jądro po prostu „jest” wywołaniem specyficznego dla języka pliku wykonywalnego z kernel.jsonpliku, który jupyter szuka w katalogu .../share/jupyter/kernelsi wyświetla listę w interfejsie; w tym przypadku wywoływana jest R w celu uruchomienia funkcji IRkernel::main(), która wyśle ​​wiadomości tam iz powrotem do serwera Jupiter. Podobnie, jądro python2 po prostu „jest” wywołaniem interpretera python2 z modułem, ipykernel_launcherjak widać w .venv/share/jupyter/kernels/python2/kernel.jsonitp.

Oto skrypt, jeśli chcesz uruchomić wszystkie te instrukcje za jednym zamachem.

Oto metoda wiersza poleceń systemu Windows / inna, którą znalazłem, która działała dla mnie: Znajdź folder, w którym przechowywane są pliki jądra (na moim komputerze - C: \ ProgramData \ jupyter \ kernels - zwróć uwagę, że ProgramData to ukryty folder), utwórz skopiuj istniejący folder jądra, zmień nazwę i edytuj plik json wewnątrz, aby wskazał katalog nowego jądra. W tym pliku możesz również edytować nazwę jądra wyświetlaną w ipython (np. Zamiast tylko python 2 możesz podać 2.7.9, jeśli z jakiegoś powodu musisz dalej rozróżniać).

Gdy używasz conda do zarządzania env Pythona, wykonaj następujące dwa kroki:

1. activate py3(w systemie Windows lub source activate py3Linux)
2. conda install notebook ipykernel lub po prostu użyj conda install jupyter

Otrzymałem ten sam błąd z python-2. Chciałem uruchomić sesję notatnika jupyter python-2, ale domyślnie otrzymywałem python-3. Tak więc najłatwiejszym obejściem jest otwarcie terminalu Anaconda dla python-2 i napisanie „jupyter notebook” , bez problemu uruchomi sesję jupyter-notebook. Podobnie można to wypróbować z python-3

Jestem pewien, że wszystko, co musisz zrobić, to uruchomić

pip3 zainstaluj jupyter