Meus Jupyternotebooks instalados com o python 2kernel. Eu não entendo o porquê. Eu poderia ter estragado alguma coisa quando fiz a instalação. Eu já tenho python 3 instalado. Como posso adicioná-lo Jupyter? Aqui está uma captura de tela com a Jupyteraparência do padrão python3 -m install jupytere aberto no navegador jupyter notebook:

Isso funcionou para mim no Ubuntu 16.04:

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

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

Referência à documentação:
Kernels para Python 2 e 3 . Instalando o kernel do IPython - IPython Docs.

Certifique-se de ter ipykernelinstalado e usado ipython kernel installpara soltar o kernelspec no local certo para python2. Depois, ipython3 kernel installpara Python3. Agora você deve ser capaz de escolher entre os 2 kernels, independentemente de você usar jupyter notebook, ipython notebookou ipython3 notebook(os dois últimos estão obsoletos).

Observe que se você deseja instalar um executável Python específico, pode usar o seguinte truque:

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

Isso funciona ao usar ambientes (venv, conda, ...) e <options>permite que você nomeie seu kernel (consulte --help). Então você pode fazer

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

E agora você recebe um kernel nomeado py36-testem seus menus suspensos, junto com os outros.

Consulte Usando o Python 2.xe o Python 3.x no IPython Notebook, que possui informações mais recentes.

1. Tenho notebook ipython com Python2 (no Windows7)
2. atualize para o Jupyter com pip install -U jupyter
3. instalar o Python3
4. instale o Jupyter novamente usando pip3 install jupyter
5. instale o kernel do Python3 usando ipython3 kernelspec install-self
6. Finalmente consegui 2 núcleos de trabalho.

para versões recentes do jupyter / ipython : usejupyter kernelspec

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

lista os kernels atuais

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

No meu caso, a instalação do kernel python3 foi interrompida porque o py3.5 vinculado não estava mais lá, substituído por um py3.6

adicionar / remover kernels

Remover:

$ jupyter kernelspec uninstall python3

Adicione um novo: Usando o Python que você deseja adicionar e apontando para o python que executa seu jupiter:

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

Veja mais exemplos em https://ipython.readthedocs.io/en/6.5.0/install/kernel_install.html#kernels-for-different-environments

Listar novamente:

$ 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

Detalhes

Os kernels disponíveis estão listados na kernelspasta no Jupyter DATA DIRECTORY (consulte http://jupyter.readthedocs.io/en/latest/projects/jupyter-directories.html para obter detalhes).

Por exemplo, no macosx, isso seria /Users/YOURUSERNAME/Library/Jupyter/kernels/

o kernel é simplesmente descrito por um kernel.jsonarquivo, por exemplo. 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"
}

Em vez de manipular isso manualmente, você pode usar o kernelspeccomando (como acima). Estava disponível anteriormente através do ipython agora através do jupyter ( http://ipython.readthedocs.io/en/stable/install/kernel_install.html#kernels-for-different-environments - https://jupyter-client.readthedocs.io/ pt-br / 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 outros idiomas

A propósito, não está estritamente relacionado a essa pergunta, mas há muitos outros kernels disponíveis ... https://github.com/jupyter/jupyter/wiki/Jupyter-kernels

Se você estiver usando a distribuição anaconda, isso funcionou para mim (em um macintosh):

$ conda create -n py3k python=3 anaconda

$ source activate py3k

$ ipython kernelspec install-self

Apenas uma nota para o ú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

Conforme testado no OSX Yosemite, com as etapas acima, e ao inserir jupter notebooke criar um novo notebook no navegador, você verá a seguinte captura de tela:

O comando a seguir funciona para mim no macOS Sierra (10.12.3)

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

verifique com jupyter kernelspec list Kernels disponíveis: python3 / Usuários / admin / Biblioteca / Jupyter / kernels / python3 python2 / anaconda2 / share / jupyter / kernels / python2

Instalei com êxito o kernel python3 no macOS El Capitan (versão ipython: 4.1.0) com os seguintes comandos.

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

Você pode ver todos os kernels instalados com jupyter kernelspec list.

Mais informações estão disponíveis aqui

abra o terminal (ou cmd para window) e execute os seguintes comandos: (Na janela, solte "source" na segunda linha.)

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

Eu tentei algum método, mas ele não funciona, então eu encontrei este caminho. Funcionou comigo. Esperando que possa ajudar.

Eu tinha o Python 2.7 e queria poder mudar para o Python 3 dentro do Jupyter.

Essas etapas funcionaram para mim em um prompt de comando do Windows Anaconda:

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

Agora, após abrir o notebook ipython com o comando usual para o Python2.7, o Python3.3 também estará disponível ao criar um novo notebook.

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

Para o atual lançador Python

Se você possui o Py3 instalado, mas o padrão é py2

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

Se você possui o Py2 instalado, mas o padrão é py3

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

No Ubuntu 14.04, tive que usar uma combinação de respostas anteriores.

Primeiro, instale pip3 apt-get install python-pip3

Em seguida, com pip3install jupyter pip3 install jupyter

Então, usando ipython3install the kernel ipython3 kernel install

Nenhuma das outras respostas estava funcionando para mim imediatamente no ElementaryOS Freya (baseado no Ubuntu 14.04); Eu estava recebendo o

[TerminalIPythonApp] AVISO | Arquivo não encontrado: 'kernelspec'

erro que o quickbug descrito na resposta de Matt . Eu tive que fazer primeiro:

sudo apt-get install pip3, então

sudo pip3 install ipython[all]

Nesse ponto, você pode executar os comandos que Matt sugeriu; a saber: ipython kernelspec install-selfeipython3 kernelspec install-self

Agora, quando inicio ipython notebooke abro um notebook, posso selecionar o kernel do Python 3 no menu Kernel.

Consegui instalar um kernel Python3 além do Python2. Aqui está o que eu fiz:

• abrir um novo notebook em Jupyter
• copie e execute as duas células aqui: Enable-Python-3-kernel

O link de trabalho mais recente pode ser encontrado aqui .

O código real é:

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

A solução está bem documentada nos documentos oficiais: https://ipython.readthedocs.org/en/latest/install/kernel_install.html

Eu tentei a primeira abordagem. Desde que eu já tinha ipykernelinstalado, a simples execução python3 -m ipykernel install --userresolveu o problema.

Solução mais curta e melhor do meu 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

Adicionar kernel significa que você deseja usar Jupyter Notebookcom versões do python que não estão aparecendo na lista.

Abordagem simples - Inicie o notebook com a versão python necessária, suponha que eu tenha python3.7instalado e use o comando abaixo do terminal (cmd) para executar o notebook:

python3.7 -m notebook

Às vezes em vez de python3.7instalar com o apelido de py, py3.7, python.

INSTALAÇÃO DE MÚLTIPLOS KERNELS EM UM ÚNICO AMBIENTE VIRTUAL (VENV)

A maioria (se não todas) dessas respostas assume que você está feliz em instalar pacotes globalmente. Esta resposta é para você se você:

• use uma máquina * NIX
• não gosto de instalar pacotes globalmente
• não quero usar anaconda <-> você está feliz em executar o servidor jupyter na linha de comando
• quer ter uma noção do que / onde a instalação do kernel 'é'.

(Nota: esta resposta adiciona um kernel python2 a uma instalação python3-jupyter, mas é conceitualmente fácil trocar as coisas.)

1. Pré-requisitos

   1. Você está no diretório a partir do qual você executará o servidor jupyter e salvará os arquivos
   2. python2 está instalado na sua máquina
   3. python3 está instalado na sua máquina
   4. virtualenv está instalado na sua máquina

2. Crie um venv python3 e instale o jupyter

   1. Crie um novo python3 venv: python3 -m venv .venv
   2. Ative o venv: . .venv/bin/activate
   3. Instale jupyterlab: pip install jupyterlab. Isso criará localmente toda a infraestrutura essencial para a execução de notebooks.
   4. Nota: instalando o jupyterlab aqui, você também gera 'especificações do kernel' padrão (veja abaixo) em $PWD/.venv/share/jupyter/kernels/python3/. Se você deseja instalar e executar o jupyter em outro lugar, e usar este venv apenas para organizar todos os seus kernels, precisará apenas de:pip install ipykernel
   5. Agora você pode executar o jupyter lab com jupyter lab(e ir para o navegador no URL exibido no console). Até agora, você verá apenas uma opção do kernel chamada 'Python 3'. (Este nome é determinado pela display_nameentrada no seu kernel.jsonarquivo.)

3. Adicionar um kernel python2

   1. Saia do jupyter (ou inicie outro shell no mesmo diretório): ctrl-c
   2. Desative seu python3 venv: deactivate
   3. Crie um novo venv no mesmo diretório para python2: virtualenv -p python2 .venv2
   4. Ative seu python2 venv: . .venv2/bin/activate
   5. Instalar o módulo ipykernel: pip install ipykernel. Isso também irá gerar especificações padrão do kernel para este python2 venv no.venv2/share/jupyter/kernels/python2
   6. Exportar essas especificações do kernel para o seu venv python3: python -m ipykernel install --prefix=$PWD/.venv. Basicamente, apenas copia o diretório $PWD/.venv2/share/jupyter/kernels/python2para$PWD/.venv/share/jupyter/kernels/
   7. Volte para o seu venv python3 e / ou reprise / re-examinar o seu servidor jupyter: deactivate; . .venv/bin/activate; jupyter lab. Se tudo correu bem, você verá uma Python 2opção na sua lista de kernels. Você pode testar se eles estão executando verdadeiros intérpretes python2 / python3 manipulando um simples comando print 'Hellow world'vs.print('Hellow world')
   8. Nota: você não precisa criar um venv separado para python2 se quiser instalar o ipykernel e fazer referência às especificações do python2-kernel de um espaço global, mas prefiro ter todas as minhas dependências em um diretório local

TL; DR

4. Opcionalmente, instale um kernel R. Isso é instrutivo para desenvolver uma noção do que um kernel 'é'.
   1. A partir da mesma dir, instale o pacote de R IRkernel: R -e "install.packages('IRkernel',repos='https://cran.mtu.edu/')". (Isso será instalado no local padrão dos pacotes R; para o R instalado em um Mac instalado em casa, será semelhante /usr/local/Cellar/r/3.5.2_2/lib/R/library/IRkernel.)
   2. O pacote IRkernel vem com uma função para exportar suas especificações do kernel, então execute: R -e "IRkernel::installspec(prefix=paste(getwd(),'/.venv',sep=''))". Se você procurar agora, $PWD/.venv/share/jupyter/kernels/encontrará um irdiretório com um kernel.jsonarquivo parecido com 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"
}

Em resumo, um kernel apenas 'é' uma invocação de um executável específico da linguagem a partir de um kernel.jsonarquivo que o jupyter procura no .../share/jupyter/kernelsdir e lista em sua interface; nesse caso, R está sendo chamado para executar a função IRkernel::main(), que enviará mensagens para o servidor Jupiter. Da mesma forma, o kernel python2 apenas 'é' uma invocação do interpretador python2 com o módulo ipykernel_launchercomo visto em .venv/share/jupyter/kernels/python2/kernel.jsonetc.

Aqui está um script, se você quiser executar todas essas instruções de uma só vez.

Aqui está um método de linha de comando para Windows / que não encontrei, que funcionou para mim: Encontre a pasta em que os arquivos do kernel estão armazenados (na minha máquina - C: \ ProgramData \ jupyter \ kernels - observe que ProgramData é uma pasta oculta), crie um cópia da pasta do kernel existente, altere o nome e edite o arquivo json dentro para apontar para o novo diretório do kernel. Neste json, você também pode editar o nome do kernel que é exibido no ipython (por exemplo, em vez de apenas o python 2, você pode especificar 2.7.9 se precisar distinguir ainda mais por algum motivo).

Quando você usa o conda gerenciando seus envs python, siga estas duas etapas:

1. activate py3(no Windows ou source activate py3no Linux)
2. conda install notebook ipykernel ou apenas use conda install jupyter

Eu estava recebendo o mesmo erro com python-2. Eu queria executar a sessão do notebook python-2 jupyter, mas por padrão estava obtendo o python-3. Para que a solução mais fácil seja o terminal Anaconda aberto para python-2 e digite 'jupyter notebook' , ele iniciará a sessão jupyter-notebook sem nenhum problema. Similarmente, poderia ser tentado com python-3

Tenho certeza de que tudo o que você precisa fazer é executar

pip3 install jupyter