Как распечатать юпитер ноутбук

Добавляем в Jupyter Notebooks красоту и интерактивность

Многие используют в своей работе Jupyter Notebooks. Но с ростом сложности проекта появляются проблемы. В блокноте появляются ячейки с красными пометками для самого себя «перед запуском укажи число. » или «задай количество итераций исходя из. ». Какой-то откат к командной строке получается.

Да и вывод данных на экран не всегда воспринимается без пояснений сторонним человеком, который привык к красивым таблицам, картинкам и прочим современным элементам интерфейса.

Например, у нас есть данные по площадям городов и численности населения. Выведем их на экран в «традиционном виде»:

tabledata = [["Москва", 2561, 12615882], ["Санкт-Петербург", 1439, 5383890], ["Ярославль", 205, 609828], ["Хабаровск", 383, 1321473]] tabledata

Видим в блокноте:

[['Москва', 2561, 12615882], ['Санкт-Петербург', 1439, 5383890], ['Ярославль', 205, 609828], ['Хабаровск', 383, 1321473]]

Современному, избалованному человеку такой формат отображения не всегда нравится. Нужно привести данные к более привычному табличному виду.

Можно использовать широко распространенную библиотеку pandas

import pandas as pd pd.DataFrame(tabledata, columns=["Город","Площадь (кв. км)", "Население (человек)"])

Если по каким-то причинам использование pandas не устраивает, можно воспользоваться другой библиотекой или написать свою функцию.

Рассмотрим одну из таких библиотек — tabulate (https://pypi.org/project/tabulate/)
Для установки запустите из командной строки pip install tabulate

from IPython.display import HTML, display from tabulate import tabulate display(HTML(tabulate(tabledata, tablefmt='html')))

Можно вывести данные в «псевдографическом» виде.

print(tabulate(tabledata))

Можно добавить заголовки

print(tabulate(tabledata, headers=["Город","Площадь (кв. км)", "Население (человек)"]))

И индексы

display(HTML(tabulate(tabledata, headers=["Город","Площадь (кв. км)", "Население (человек)"], tablefmt='html', showindex="always")))

tabulate позволяет получить визуально такой же результат как и pandas.

Можно написать свою функцию, которая потом обрастёт дополнительными возможностями.

from IPython.display import HTML, display def dataToTable(data, columns = None): if len(data) == 0 : display(HTML('Нет данных')) return hdr = '' if columns != None: for col in columns: # Формируем заголовок таблицы hdr = hdr + '' + col + '' hdr = '' + hdr + '' dt = '' for row in data: # Проходим циклом по всем строкам dt = dt + '' for cell in row: # И формируем тело таблицы dt = dt + '' + str(cell) + '' dt = dt + '' display(HTML('' + hdr + dt + '
')) # Выводим таблицу на экран dataToTable(tabledata, columns=["Город","Площадь (кв. км)", "Население (человек)"])

Вывод изображений

Мы привыкли к пиктограммам и иконкам. Даже в прогнозе погоды мы видим картинки с солнышками и тучками. Чтобы добавить изображения в наши программы можно использовать библиотеку IPython. Ее функция Image позволяет работать с изображениями (PNG/JPEG/GIF), размещенными как локально, так и на интернет-ресурсах. Задавать их размеры.

from IPython.display import Image # Библиотека для отображения картинок display(Image(url='https://habrastorage.org/webt/9m/2c/zd/9m2czdt-uv7oe6v-nws3frtw7-a.jpeg', width = 200) # Задаем ширину картинки ) # display(Image(filename='Python_royal_35.JPG', width = 200)) # Локальный файл

Украшаем текст

Конечно, можно генерировать HTML напрямую, используя все его возможности:

from IPython.core.display import display, HTML display(HTML("Мой зеленый текст"))

А можно воспользоваться библиотекой termcolor. Она позмоляет не углубляясь в HTML задавать цвет текста и фона, задавать атрибуты шрифта. Описание библиотеки тут — pypi.org/project/termcolor

from termcolor import colored # Для установки запустите из командной строки pip install termcolor print(colored("Красный текст (без атрибутов)", "red")) print(colored("Красный текст (подчеркивание)", "red", attrs=["underline"])) print(colored("Зеленый текст на красном фоне (без атрибутов)", "green", "on_red" )) print(colored("Зеленый текст на красном фоне (bold)", "green", "on_red", attrs=["bold"]))

Отображаем прогресс выполнения задачи

Никому не нравится следить за ходом выполнения длительной задачи не понимая какая часть работы уже выполнена.

Видеть сколько осталось — гораздо приятнее (да-да, знаю, что скорость движения «червяка» может меняться).

Для установки используйте команды

pip install ipywidgets jupyter nbextension enable --py widgetsnbextension

from ipywidgets import IntProgress from IPython.display import display import time prgBar = IntProgress(min = 0, max = 100) # Создаем прогрессбар display(prgBar) # Выводим прогрессбар на экран while prgBar.value < prgBar.max: # Пока положение не дошло до максимума - продолжаем цикл prgBar.value = prgBar.value + 1 # Двигаем "полоску" time.sleep(0.1) print('Процесс завершен')

Интерактивное взаимодействие с пользователем

Та же библиотека ipywidgets позволяет не только отображать, но и вносить информацию.

Самый, наверное, простой пример взаимодействия с пользователем — это реакция на нажатие кнопки. Библиотека ipywidgets позволяет создать кнопку с заданными параметрами (текстом, стилем и размерами) и назначить функцию-обработчик ее нажатия.

from IPython.display import display from ipywidgets import Button # Создаем кнопку с нужными параметрами button1 = Button(description="Нажми меня!", button_style='success' # 'success', 'info', 'warning', 'danger', '' ) def on_button_clicked(b): # Описываем обработчик события print("Клик") button1.on_click(on_button_clicked) # Назначаем этот обработчик на событие "on_click" display(button1) # Отображаем кнопку

Размер кнопки задается при помощи свойства layout

from IPython.display import display from ipywidgets import Button, Layout button2 = Button(description='Кнопка с заданными размерами', button_style='success', layout=Layout(width='50%', height='80px')) display(button2)

Для удобного ввода пользователем чисел и дат есть компоненты FloatSlider и DatePicker.

Чтобы получить введенное значение — используется свойство .value

Чтобы отловить момент изменения значений, нужно использовать событие observe

from IPython.display import display from ipywidgets import FloatSlider fSlider = FloatSlider( value=7.5, # Первоначальное значение min=0, # Минимум max=10.0, # Максимум step=0.1, # Шаг изменения description='Параметр:', continuous_update=False, # True - событие observe возникает для каждого шага при изменении значения orientation='horizontal' # Горизонтальное или вертикальное расположение ) def on_value_change(b): print(b['old'], '->', b['new']) fSlider.observe(on_value_change, names='value') display(fSlider)

Проверим доступ к текущему значению:

fSlider.value

from IPython.display import display from ipywidgets import DatePicker dPicker = DatePicker( description='Дата:' ) def on_button_clicked(b): print(b['old'], '->', b['new']) dPicker.observe(on_button_clicked, names='value') display(dPicker)

Для выбора одного значения из нескольких вариантов есть список RadioButtons, выпадающий список Dropdown и группа кнопок ToggleButtons. value и observe для этих компонентов используются точно так же.

Значения можно задавать как в виде перечня строчных величин, так и в виде списка кортежей.

Попробуем самый простой вариант, со значениями в виде списка строк.

from IPython.display import display from ipywidgets import RadioButtons rButtons1 = RadioButtons( options=['Красный', 'Желтый', 'Зеленый'], value='Желтый', # Выбор по умолчанию description='Цвет:' ) def on_button_clicked(b): print(b['old'], '->', b['new']) rButtons1.observe(on_button_clicked, names='value') display(rButtons1)

Выведем на экран значение:

rButtons1.value

В этом режиме значением rButtons1.value является строка.

Пробуем второй вариант задания списка значений:

from IPython.display import display from ipywidgets import RadioButtons rButtons2 = RadioButtons( options=[('Красный', 1), ('Желтый', 2), ('Зеленый', 3)], value=2, # Выбор по умолчанию description='Цвет:' ) def on_button_clicked(b): print(b['old'], '->', b['new']) rButtons2.observe(on_button_clicked, names='value') display(rButtons2)

В этом режиме значением rButtons2.value является число, соответствующее выбранному значению.

Аналогично работает выпадающий список (Dropdown)

from IPython.display import display from ipywidgets import Dropdown dropdown1 = Dropdown( options=[('Красный', 1), ('Желтый', 2), ('Зеленый', 3)], value=2, # Выбор по умолчанию description='Цвет:' ) def on_button_clicked(b): print(b['old'], '->', b['new']) dropdown1.observe(on_button_clicked, names='value') display(dropdown1)

Для ввода булевых значений можно использовать Checkbox и ToggleButton. У них есть уже знакомые нам value и observe.

from IPython.display import display from ipywidgets import Checkbox cb1 = Checkbox( value=False, description='Согласен' ) def on_button_clicked(b): print(cb1.value) cb1.observe(on_button_clicked, names='value') display(cb1)

from IPython.display import display from ipywidgets import ToggleButton tb1 = ToggleButton( value=False, description='Не нажата', disabled=False, button_style='success', # 'success', 'info', 'warning', 'danger' or '' tooltip='Принять условия', icon='check' ) tb2 = ToggleButton( value=True, description='А эта нажата', disabled=False, button_style='success', # 'success', 'info', 'warning', 'danger' or '' tooltip='Принять условия', icon='check' ) display(tb1, tb2)

Для ввода многострочного текста служет компонент Textarea

from IPython.display import display from ipywidgets import Textarea, Layout Textarea1 = Textarea( value='Привет, Habr!', placeholder='Введите текст', description='Текст:', layout=Layout(width='600px', height='100px') ) display(Textarea1)

ИИ (интерфейсные изыски)

Когда элементов интерфейса становится слишком много, хочется пойти по пути десктопных приложений и объединить отдельные элементы в обособленные группы.

Для этого нам пригодятся Accordion и Tab.

from IPython.display import display from ipywidgets import Accordion, IntSlider, Text accordion = Accordion(children=[IntSlider(value=42), Text(value='Сорок два')]) accordion.set_title(0, 'Раздел 1') accordion.set_title(1, 'Раздел 2') display(accordion)

from IPython.display import display from ipywidgets import Tab, IntSlider, Text tab = Tab() tab.children = [IntSlider(value=42), Text(value='Сорок два')] tab.set_title(0, 'Раздел 1') tab.set_title(1, 'Раздел 2') display(tab)

Библиотека ipywidgets не ограничивается элементами, которые я перечислил. В ней еще масса полезных вещей, которые могут сделать программы в Jupyter Notebooks более привлекательными.

Python
Программирование

Jupyter Notebook для начинающих: учебник

Jupyter Notebook – невероятно мощный инструмент для интерактивной разработки и представления проектов в области наук о данных. В этой статье вы узнаете, как настроить Jupyter Notebooks на локальном компьютере и как начать использовать его в ваших проектах.

Начнем с определения: что такое «notebook» (блокнот)? Блокнот объединяет код и его вывод в единый документ, который объединяет визуализацию, повествовательный текст, математические уравнения и другие мультимедиа. Этот интуитивно понятный рабочий процесс способствует итеративной и быстрой разработке, что делает ноутбуки все более популярным выбором для представления в данных и их анализа.

Лучше всего то, что в рамках проекта с открытым исходным кодом Project Jupyter он полностью бесплатен.

Проект Jupyter является преемником более раннего проекта IPython Notebook, который впервые был опубликован в качестве прототипа в 2010 году. Хотя в Jupyter Notebooks можно использовать с многими разными языками программирования, в этой статье основное внимание будет уделено Python, поскольку он является наиболее распространенный вариантом использования.

Чтобы получить максимальную отдачу от этого урока, вы должны быть знакомы с программированием, особенно с Python и pandas. Тем не менее, если у вас есть опыт работы с другим языком, Python в этой статье не будет слишком сложным, а статья все равно будет вам полезной в настройке Jupyter Notebooks локально. Как вы увидите позже в этой статье, Jupyter Notebooks также может выступать в качестве гибкой платформы для работы с pandas и даже с Python.

В этой статье мы:

Изучим основы установки Jupyter и создания своего первого ноутбука
Погрузимся глубже и рассмотрим всю важную терминологию
Расскажем, как легко можно обмениваться блокнотами и публиковать их в Интернете.

Пример анализа данных в блокноте Jupyter

Сначала мы пройдемся по настройке и анализу примера, чтобы ответить на наш вопрос. Итак, допустим, вы аналитик данных, и вам было поручено выяснить, как исторически менялась прибыль крупнейших компаний в США. У нас для этого будет набор данных о компаниях из списка Fortune 500, охватывающих более 50 лет с момента первой публикации списка в 1955 году, собранных из открытого архива Fortune. Для анализа мы создали CSV файл данных, который вы можете скачать отсюда.

Как мы покажем, ноутбуки Jupyter идеально подходят для этого исследования.

И так, давайте продолжим и установим Jupyter.

Инсталяция

Для новичка проще всего начать работу с Jupyter Notebooks, установив дистрибутив Anaconda. Anaconda является наиболее широко используемым дистрибутивом Python для работы с данными и поставляется с предустановленными наиболее популярными библиотеками и инструментами. Некоторые из крупнейших библиотек Python, включенных в Anaconda, включают NumPy, pandas и Matplotlib, хотя вы можете взглянуть на полный список с более чем 1000+ пакетов. Это позволит вам приступить к работе, без хлопот управления бесчисленными установками или беспокойства о зависимостях и проблемах установки, связанных с ОС.

Чтобы установить Анаконду, просто:

Загрузите последнюю версию Anaconda для Python 3 (игнорируйте Python 2.7).
Установите Anaconda, следуя инструкциям на странице загрузки и/или в исполняемом файле.

Если вы более продвинутый пользователь с уже установленным Python и предпочитаете управлять своими пакетами вручную, вы можете просто использовать pip для установки Jupyter Notebooks:

pip3 install jupyter

Создание вашего первого блокнота

В этом разделе мы научимся запускать и сохранять блокноты, познакомиться с их структурой и рассмотрим их интерфейс. Мы познакомимся с некоторыми основными терминами, которые приведут вас к практическому пониманию того, как самостоятельно использовать Jupyter Notebooks, и подготовимся к следующему разделу, в котором описан пример анализа данных и опробуем на практике все, что мы изучаем здесь.

Запуск Jupyter

В Windows вы можете запустить Jupyter с помощью ярлыка, который Anaconda добавляет в ваше меню «Пуск», которое откроет новую вкладку в веб-браузере по умолчанию, и которая должна выглядеть примерно так, как показано на следующем скриншоте

Jupyter control panel

Это пока не блокнот, но не паникуйте! Это панель инструментов ноутбука, специально разработанная для управления ноутбуками Jupyter. Думайте об этом как о панели запуска.

Имейте в виду, что панель управления предоставит вам доступ только к файлам и подпапкам, содержащимся в каталоге запуска Jupyter; однако каталог запуска может быть изменен. Также можно запустить панель мониторинга в любой системе через командную строку (или терминал в системах Unix), введя команду jupyter notebook; в этом случае текущим рабочим каталогом будет каталог запуска.

Проницательный читатель, возможно, заметил, что URL-адрес панели мониторинга похож на http://localhost:8888/tree. Localhost не является веб-сайтом, но указывает, что контент обслуживается с вашего локального компьютера: с вашего собственного компьютера. Ноутбуки и панель инструментов Jupyter – это веб-приложения, и Jupyter запускает локальный веб сервер Python для обслуживания этих приложений в веб-браузере, что делает его практически независимым от платформы и открывает возможности для более удобного обмена в Интернете.

Интерфейс панели управления в основном не требует пояснений – хотя мы вернемся к нему позже. Так чего же мы ждем? Перейдите в папку, в которой вы хотите создать свой первый блокнот, нажмите кнопку «Создать» в правом верхнем углу и выберите «Python 3» (или выбранную вами версию).

Ваш первый блокнот Jupyter откроется в новой вкладке – каждый блокнот использует свою вкладку, поэтому вы можете открывать несколько блокнотов одновременно. Если вы переключитесь обратно на панель инструментов, вы увидите новый файл Untitled.ipynb и зеленый текст, который говорит о том, что ваш ноутбук работает.

Что за файл ipynb?

Будет полезно понять, что это за файл на самом деле. Каждый файл .ipynb представляет собой текстовый файл, который описывает содержимое вашей записной книжки в формате JSON. Каждая ячейка и ее содержимое, включая вложения изображений, которые были преобразованы в строки текста, перечислены в нем вместе с некоторыми метаданными. Вы можете редактировать их самостоятельно – если знаете, что делаете! – выбрав «Edit> Edit Notebook Metadata» в строке меню в записной книжке.

Вы также можете просмотреть содержимое файлов вашей записной книжки, выбрав «Edit» на панели управления, но ключевое слово здесь – «можете»; нет никакой другой причины, кроме любопытства, делать это, если вы действительно не знаете, что делаете.

Интерфейс Notebook

Теперь, когда перед вами открытый блокнот, надеюсь, его интерфейс не будет выглядеть совершенно чуждым; В конце концов, Jupyter – это просто продвинутый текстовый процессор. Почему бы не осмотреться? Просотрите меню, чтобы почувствовать его, особенно потратьте несколько минут, чтобы прокрутить список команд в палитре команд, который представляет собой небольшую кнопку со значком клавиатуры (или Ctrl + Shift + P).

New Jupyter Notebook

Вы должны заметить два довольно важных термина, которые, вероятно, являются новыми для вас: cells (ячейки) и kernels (ядра) являются ключом как к пониманию Jupyter, так и к тому, что делает его не просто текстовым процессором. К счастью, эти термины не сложно понять.

kernel (Ядро) – это «вычислительный движок», который выполняет код, содержащийся в документе ноутбука.
cell (Ячейка) – это контейнер для текста, который будет отображаться в записной книжке, или код, который будет выполняться ядром записной книжки.

Ячейки (Cell)

Мы вернемся к ядрам чуть позже, но сначала давайте разберемся с ячейками. Ячейки образуют структуру ноутбука. На скриншоте нового блокнота в приведенном выше разделе это поле с зеленым контуром. Есть два основных типа ячеек, которые мы рассмотрим:

Ячейка кода содержит код, который должен быть выполнен в ядре, и отображает его вывод ниже.
Ячейка Markdown содержит текст, отформатированный с использованием Markdown, и отображает его вывод на месте при запуске.

Первая ячейка в новой записной книжке всегда является ячейкой кода. Давайте проверим это на классическом примере с Hello World. Введите print (‘Hello World!’) в ячейку и нажмите кнопку запуска на панели инструментов показанная выше или нажмите Ctrl + Enter. Результат должен выглядеть как то так:

print('Hello World!')

Hello World!

Когда вы запустите ячейку, ее вывод будет отображен ниже, а метка слева изменится с In [] на In [1]. Вывод ячейки кода также является частью документа, поэтому вы можете увидеть его в этой статье. Вы всегда можете определить разницу между кодом и ячейками Markdown, потому что ячейки кода имеют эту метку слева, а ячейки Markdown – нет.

Часть «In» метки просто короткая запись слова «Input», а номер метки указывает, когда ячейка была выполнена в ядре – в нашем случае ячейка была выполнена первой. Запустите ячейку снова, и метка изменится на In [2], потому что теперь ячейка была второй, запущенной в ядре. Позже станет понятнее, почему это так полезно, когда мы поближе познакомимся с ядрами.

В строке меню нажмите Insert (Вставить) и выберите Insert Cell Below (Вставить ячейку ниже), чтобы создать новую ячейку кода под первым и попробуйте следующий код, чтобы увидеть, что происходит. Вы замечаете что-то другое?

import time time.sleep(3)

Эта ячейка не производит никакого вывода, но для ее выполнения требуется три секунды. Обратите внимание, как Jupyter показывает, что ячейка в данный момент работает, изменив метку на In [*].

Как правило, выходные данные ячейки поступают из любых текстовых данных, специально напечатанных во время выполнения ячеек, а также из значения последней строки в ячейке, будь то переменная-одиночка, вызов функции или что-то еще. Например:

def say_hello(recipient): return 'Hello, <>!'.format(recipient) say_hello('Tim')

'Hello, Tim!'

Горячие клавиши

Последнее, что вы, возможно, заметили при запуске ваших ячеек, это то, что их рамка стала синей, тогда как она была зеленой, когда вы редактировали ее. Всегда есть одна «активная» ячейка, выделенная рамкой, цвет которой обозначает ее текущий режим, где зеленый означает edit mode (режим редактирования), а синий – command mode (командный режим).

До сих пор мы показали, как запустить ячейку с помощью Ctrl + Enter, но есть еще много других возможностей. Сочетания клавиш являются очень популярным аспектом среды Jupyter, поскольку они обеспечивают быстрый рабочий процесс на основе ячеек. Многие из этих действий вы можете выполнять в активной ячейке, когда она находится в командном режиме.

Ниже вы найдете список некоторых сочетаний клавиш Jupyter. Вам не нужно сразу их запоминать, но список должен дать вам хорошее представление о том, что это возможно.

Переключение между режимом редактирования и командным режимом с помощью Esc и Enter соответственно.

В командном режиме:

Прокрутите свои ячейки вверх и вниз с помощью клавиш «Вверх» и «Вниз».
Нажмите A или B, чтобы вставить новую ячейку выше или ниже активной ячейки.
M преобразует активную ячейку в ячейку Markdown.
Y установит активную ячейку в кодовую ячейку.
D + D (D дважды) удалит активную ячейку.
Z отменит удаление ячейки.

Удерживайте Shift и нажмите Вверх или Вниз, чтобы выбрать несколько ячеек одновременно.

С выделением нескольких ячеек Shift + M объединит выбранные ячейки.

Попробуй это в своей записной книжке. После того, как вы опробуете все команды, создайте новую ячейку Markdown, и мы научимся форматировать текст в наших блокнотах.

Markdown

Markdown – это легкий, простой в освоении язык разметки для форматирования простого текста. Его синтаксис имеет однозначное соответствие с тегами HTML, поэтому некоторые предварительные знания здесь могут быть полезны, но это определенно не является обязательным условием. Давайте рассмотрим основы с кратким примером.

# This is a level 1 heading ## This is a level 2 heading This is some plain text that forms a paragraph. Add emphasis via **bold** and __bold__, or *italic* and _italic_. Paragraphs must be separated by an empty line. * Sometimes we want to include lists. * Which can be indented. 1. Lists can also be numbered. 2. For ordered lists. [It is possible to include hyperlinks](https://www.example.com) Inline code uses single backticks: `foo()`, and code blocks use triple backticks: ``` bar() ``` Or can be indented by 4 spaces: foo() And finally, adding images is easy: ![Alt text](https://www.example.com/image.jpg)

При прикреплении изображений у вас есть три варианта:

Используйте URL для изображения в Интернете.
Используйте локальный URL-адрес изображения, которое вы будете хранить рядом с ноутбуком, например, в том же git-репо.
Добавьте вложение через «Edit> Insert Image»; Это преобразует изображение в строку и сохраняет его в файле .ipynb вашего ноутбука.
Обратите внимание, что это сделает ваш файл .ipynb намного больше!

У Markdown гораздо больше возможностей, особенно в отношении гиперссылок, а также возможно просто включить простой HTML. Если вы захотите узнать больше, вы можете обратиться к официальному руководству от создателя Markdown, Джона Грубера, на его веб-сайте.

Ядра (Kernels)

За каждым ноутбуком работает ядро. Когда вы запускаете ячейку кода, этот код выполняется в ядре, и любой вывод возвращается обратно в ячейку для отображения. Состояние ядра сохраняется во времени и между ячейками – оно относится к документу в целом, а не к отдельным ячейкам.

Например, если вы импортируете библиотеки или объявляете переменные в одной ячейке, они будут доступны в другой. Таким образом, вы можете думать о документе блокнота как о чем-то сравнимом с файлом сценария, за исключением того, что он является мультимедийным. Давайте попробуем, чтобы почувствовать это. Сначала мы импортируем пакет Python и определим функцию.

import numpy as np def square(x): return x * x

Как только мы выполнили ячейку выше, мы можем ссылаться на np и square в любой другой ячейке.

x = np.random.randint(1, 10) y = square(x) print('%d squared is %d' % (x, y))

1 squared is 1

Это будет работать независимо от порядка ячеек в вашем блокноте. Вы можете попробовать сами, давайте снова распечатаем наши переменные.

print('Is %d squared is %d?' % (x, y))

Is 1 squared is 1?

Здесь нет сюрпризов! Но теперь давайте изменим у.

y = 10

Как вы думаете, что произойдет, если мы снова запустим ячейку, содержащую наш оператор print? Мы получим на выходе 4 в квадрате 10?

Большую часть времени поток в вашем ноутбуке будет сверху вниз, но часто приходится возвращаться, чтобы внести изменения. В этом случае важен порядок выполнения, указанный слева от каждой ячейки, например, In [6], позволит вам узнать, имеет ли какая-либо из ваших ячеек устаревший вывод. И если вы когда-нибудь захотите сбросить настройки, есть несколько невероятно полезных опций из меню Kernel:

Restart: перезапускает ядро, таким образом очищая все переменные и т.д., которые были определены.
Restart & Clear Output: то же, что и выше, но также стирает вывод, отображаемый под ячейками кода.
Restart & Run All: то же, что и выше, но также будет запускать все ваши ячейки в порядке от первого до последнего.

Если ваше ядро зависло в вычислении, и вы хотите остановить его, вы можете выбрать опцию Interupt.

Выбор ядра

Возможно, вы заметили, что Jupyter дает вам возможность сменить ядро, и на самом деле есть много разных вариантов на выбор. Когда вы создавали новую записную книжку на панели инструментов, выбирая версию Python, вы фактически выбирали, какое ядро использовать.

Существуют не только ядра для разных версий Python, но и более 100 языков, включая Java, C и даже Fortran. Исследователи данных могут быть особенно заинтересованы в ядрах для R и Julia, а также в imatlab и ядре Calysto MATLAB Kernel для Matlab. Ядро SoS обеспечивает многоязычную поддержку в пределах одного ноутбука. Каждое ядро имеет свои собственные инструкции по установке, но, вероятно, потребует от вас выполнения некоторых команд на вашем компьютере.

Пример анализа

Теперь когда мы рассмотрели, что такое Jupyter Notebook, пришло время взглянуть на то, как они используются на практике, что должно дать вам более четкое представление о том, почему они так популярны. Наконец-то пришло время начать работу с тем набором данных Fortune 500, который упоминался ранее. Помните, наша цель – узнать, как исторически менялась прибыль крупнейших компаний США.

Названия для ноутбуков

Прежде чем начать создавать свой проект, вы, вероятно, захотите дать ему осмысленное имя. Возможно, это несколько сбивает с толку: но вы не можете назвать или переименовать свои записные книжки из самого приложения для записной книжки, а для переименования файла .ipynb необходимо использовать панель мониторинга или файловый браузер. Мы вернемся к информационной панели, чтобы переименовать созданный ранее файл, который будет иметь имя файла по умолчанию для записной книжки Untitled.ipynb.

Вы не можете переименовать ноутбук во время его работы, потому что его сначала нужно выключить. Самый простой способ сделать это – выбрать «File> Close and Halt» в меню ноутбука. Однако вы также можете выключить ядро, перейдя в «Kernel> Shutdown» в приложении для ноутбука или выбрав ноутбук на приборной панели и нажав «Shutdown» (см. Изображение ниже).

A running notebook

Затем вы можете выбрать свой блокнот и нажать «Rename» на панели управления.

A running notebook

Обратите внимание, что закрытие вкладки «notebook» в вашем браузере не «закроет» вашу записную книжку так же, как закрытие документа в традиционном приложении. Ядро ноутбука будет продолжать работать в фоновом режиме и должно быть отключено, прежде чем оно действительно «закроется». Это очень удобно, если вы случайно закрыли вкладку или браузер! Если ядро закрыто, вы можете закрыть вкладку, не беспокоясь о том, работает ли оно по-прежнему или нет.

Как только вы назвали свою записную книжку, откройте ее снова, и мы начнем.

Настройка

Обычно начинают с ячейки кода, специально предназначенной для импорта и настройки, поэтому, если вы решите добавить или изменить что-либо, вы можете просто отредактировать и повторно запустить ячейку, не вызывая побочных эффектов.

import pandas as pd import matplotlib.pyplot as plt import seaborn as sns sns.set(style="darkgrid")

Здесь мы импортируем pandas для работы с нашими данными, Matplotlib для построения графиков и Seaborn для улучшения внешнего вида наших графиков. Обычно также импортируется NumPy, но в нашем случае, мы используем его через pandas, и нам не нужно это делать явно. Последняя строка не является командой Python, она является нечто, называемое строковой магией, для инструктирования Jupyter захватывать графики Matplotlib и отображать их в выходных данных ячейки; это одна из ряда расширенных функций, которые выходят за рамки данной статьи.

Давайте продолжим и загрузим наши данные.

df = pd.read_csv('fortune500.csv')

Целесообразно делать это в отдельной ячейке на случай, если нам понадобится перезагрузить ее в любой момент.

Сохранение и контрольная точка

Теперь, когда мы начали создавать проект, лучше регулярно сохраняться. Нажатие Ctrl + S сохранит вашу записную книжку, вызвав команду «Save and Checkpoint», но что это за checkpoint (контрольная точка)?

Каждый раз, когда вы создаете новую записную книжку, создается файл контрольной точки, а также файл вашей записной книжки; он будет расположен в скрытом подкаталоге вашего места сохранения с именем .ipynb_checkpoints, и также является файлом .ipynb. По умолчанию Jupyter каждые 120 секунд автоматически сохраняет ваш блокнот в этот файл контрольных точек, не изменяя основной файл блокнота. Когда вы сохраняете и сохраняете контрольную точку, файлы записной книжки и контрольной точки обновляются. Следовательно, контрольная точка позволяет вам восстановить несохраненную работу в случае непредвиденной проблемы. Вы можете вернуться к контрольной точке из меню через «File> Revert to Checkpoint».

Изучение нашего набора данных

Наш блокнот благополучно сохранен, и мы загрузили наш набор данных переменную df в наиболее часто используемую структуру данных pandas, которая называется DataFrame и в основном выглядит как таблица. Давай те посмотрим как выглядят наши данные?

df.head()

year	rank	company	revenue (in millions)	profit (in millions)
0	1955	1	General Motors	9823.5	806
1	1955	2	Exxon Mobil	5661.4	584.8
2	1955	3	U.S. Steel	3250.4	195.4
3	1955	4	General Electric	2959.1	212.6
4	1955	5	Esmark	2510.8	19.1

df.tail()

year	rank	company	revenue (in millions)	profit (in millions)
25495	2005	496	Wm. Wrigley Jr.	3648.6	493
25496	2005	497	Peabody Energy	3631.6	175.4
25497	2005	498	Wendy’s International	3630.4	57.8
25498	2005	499	Kindred Healthcare	3616.6	70.6
25499	2005	500	Cincinnati Financial	3614.0	584

У нас есть столбцы, которые нам нужны, и каждая строка соответствует одной компании за один год.

Давайте просто переименуем эти столбцы, чтобы мы могли обратиться к ним позже.

df.columns = ['year', 'rank', 'company', 'revenue', 'profit']

Далее нам нужно изучить наш набор данных. Являются ли они завершенными? Распознало ли pandas их, как ожидалось? Отсутствуют ли в них какие-либо значения?

len(df)

У нас есть 500 строк за каждый год с 1955 по 2005 год включительно.

Давайте проверим, был ли наш набор данных импортирован, как мы ожидали. Простая проверка состоит в том, чтобы увидеть, были ли типы данных (или dtypes) правильно интерпретированы.

df.dtypes

year int64 rank int64 company object revenue float64 profit object dtype: object

Ооо Похоже, что с колонкой profit что-то не так – мы ожидаем, что это будет float64, как колонка revenue. Это указывает на то, что она, вероятно, содержит нецелые значения, так что давайте посмотрим.

non_numberic_profits = df.profit.str.contains('[^0-9.-]') df.loc[non_numberic_profits].head()

year	rank	company	revenue	profit
228	1955	229	Norton	135.0	N.A.
290	1955	291	Schlitz Brewing	100.0	N.A.
294	1955	295	Pacific Vegetable Oil	97.9	N.A.
296	1955	297	Liebmann Breweries	96.0	N.A.
352	1955	353	Minneapolis-Moline	77.4	N.A.

Как мы и подозревали! Некоторые значения являются строками, которые использовались для указания отсутствующих данных. Есть ли какие-то другие значения, которые закрались?

set(df.profit[non_numberic_profits])

Получается, что других значений нет. Это облегчает интерпретацию, но что нам делать? Это зависит от того, сколько значений пропущено.

len(df.profit[non_numberic_profits])

Это небольшая часть нашего набора данных, хотя и не совсем несущественная, поскольку все еще составляет около 1,5%. Если строки, содержащие N.A., примерно одинаково распределены по годам, самым простым решением было бы просто удалить их. Итак, давайте кратко рассмотрим их распределение.

bin_sizes, _, _ = plt.hist(df.year[non_numberic_profits], bins=range(1955, 2006))

Missing value distribution

На первый взгляд, мы видим, что самые недопустимые значения за один год составляют менее 25, а поскольку существует 500 точек данных в год, удаление этих значений будет составлять менее 4% данных для худших лет. Действительно, кроме всплеска около 90-х годов, большинство лет имеют менее половины недостающих значений пика. Для наших целей допустим, что это приемлемо, и мы просто удалим эти строки.

df = df.loc[~non_numberic_profits] df.profit = df.profit.apply(pd.to_numeric)

Мы должны проверить, что у нас получилось.

len(df)

df.dtypes

year int64 rank int64 company object revenue float64 profit float64 dtype: object

Супер! Мы завершили настройку набора данных.

Если бы вы собирались представить свою записную книжку в виде отчета, вы могли бы избавиться от созданных нами исследовательских ячеек, которые включены здесь в качестве демонстрации процесса работы с записными книжками, и объединить соответствующие ячейки (см. Раздел «Дополнительные функции» ниже для подробностей об этом) для создания единой ячейки настройки набора данных. Это будет означать, что если мы когда-нибудь испортим наш набор данных в другом месте, мы сможем просто повторно запустить ячейку настройки, чтобы восстановить ее.

Графики с matplotlib

Далее мы можем перейти к решению данного вопроса, построив график средней прибыли за год. Мы можем также рассчитать доход, поэтому сначала мы определим некоторые переменные и метод, чтобы уменьшить наш код.

group_by_year = df.loc[:, ['year', 'revenue', 'profit']].groupby('year') avgs = group_by_year.mean() x = avgs.index y1 = avgs.profit def plot(x, y, ax, title, y_label): ax.set_title(title) ax.set_ylabel(y_label) ax.plot(x, y) ax.margins(x=0, y=0)

fig, ax = plt.subplots() plot(x, y1, ax, 'Increase in mean Fortune 500 company profits from 1955 to 2005', 'Profit (millions)')

Increase in mean Fortune 500 company profits from 1955 to 2005

Вау, это похоже на экспоненту, но у нее есть огромные провалы. Они должны соответствовать рецессии начала 1990-х и пузырю доткомов. Это довольно интересно увидеть в данных. Но почему прибыль возвращается к еще более высоким уровням после каждой рецессии?

Может быть, доходы могут рассказать нам больше.

y2 = avgs.revenue fig, ax = plt.subplots() plot(x, y2, ax, 'Increase in mean Fortune 500 company revenues from 1955 to 2005', 'Revenue (millions)')

Increase in mean Fortune 500 company revenues from 1955 to 2005

Это добавляет другую сторону истории. Доходы отнюдь не так сильно пострадали, это отличная бухгалтерская работа для финансовых отделов.

С небольшой помощью Stack Overflow мы можем наложить эти графики с +/- их стандартными отклонениями.

def plot_with_std(x, y, stds, ax, title, y_label): ax.fill_between(x, y - stds, y + stds, alpha=0.2) plot(x, y, ax, title, y_label) fig, (ax1, ax2) = plt.subplots(ncols=2) title = 'Increase in mean and std Fortune 500 company %s from 1955 to 2005' stds1 = group_by_year.std().profit.values stds2 = group_by_year.std().revenue.values plot_with_std(x, y1.values, stds1, ax1, title % 'profits', 'Profit (millions)') plot_with_std(x, y2.values, stds2, ax2, title % 'revenues', 'Revenue (millions)') fig.set_size_inches(14, 4) fig.tight_layout()

jupyter-notebook-tutorial_48_0

Это ошеломляет, стандартные отклонения огромны. Некоторые компании из списка Fortune 500 зарабатывают миллиарды, в то время как другие теряют миллиарды, и риск увеличивается вместе с ростом прибыли за последние годы. Возможно, некоторые компании работают лучше, чем другие; Являются ли прибыли первых 10% более или менее волатильными, чем нижние 10%?

Есть много вопросов, которые мы могли бы рассмотреть далее, и легко увидеть, как процесс работы в блокноте соответствует собственному мыслительному процессу, поэтому сейчас пришло время подвести этот пример к концу. Этот блокнот помог нам легко исследовать наш набор данных в одном месте без переключения контекста между приложениями, и наша работа сразу становится доступной и воспроизводимой. Если бы мы хотели создать более краткий отчет для конкретной аудитории, мы могли бы быстро реорганизовать нашу работу, объединив ячейки и удалив промежуточный код.

Примечание: оригинальная версия этой статьи использовала as_matrix () вместо .values в приведенном выше фрагменте кода. На момент написания этой статьи команда .as_matrix () все еще существует, но ее планируется удалить в будущей версии pandas, поэтому мы заменили его на значение .values.

Делимся своими ноутбуками

Когда люди говорят о совместном использовании своих ноутбуков, обычно они рассматривают две парадигмы. Чаще всего люди разделяют конечный результат своей работы, что означает обмен неинтерактивными, предварительно отрендеренными версиями своих ноутбуков; однако также существует возможность совместного использования ноутбуков с такими вспомогательными системами контроля версий, как Git.

Так же, в интернете появляются новые компании, предлагающие возможность запуска интерактивных Jupyter Notebooks в облаке.

Прежде чем поделиться

Общий блокнот будет отображаться точно в том состоянии, в котором он находился при экспорте или сохранении, включая вывод любых ячеек кода. Поэтому, чтобы обеспечить совместимость вашего ноутбука, так сказать, есть несколько шагов, которые вы должны предпринять, прежде чем им делиться:

Кликните “Cell > All Output > Clear”
Кликните “Kernel > Restart & Run All”
Дождитесь окончания выполнения ваших ячеек кода и проверьте, что они отработали так, как ожидалось.

Это гарантирует, что ваши записные книжки не будут содержать промежуточный вывод, не будут иметь устаревшее состояние и будут выполнены в порядке на момент публикации.

Экспорт ваших ноутбуков

Jupyter имеет встроенную поддержку экспорта в HTML и PDF, а также в некоторые другие форматы, которые вы можете найти в меню «File> Download As». Если вы хотите поделиться своими записными книжками с небольшой частной группой, этой функция будет достаточно. Но если совместного доступа к экспортированным файлам будет не достаточно, есть также несколько чрезвычайно популярных методов совместного использования файлов .ipynb в Интернете.

GitHub

Поскольку к началу 2018 года количество общедоступных ноутбуков на GitHub превысило 1,8 миллиона, это, безусловно, самая популярная независимая платформа для обмена проектами Jupyter со всем миром. GitHub имеет встроенную поддержку рендеринга файлов .ipynb непосредственно как в репозиториях, так и в списках на своем веб-сайте. Если вы еще не знаете, GitHub – это платформа для размещения кода для контроля версий и совместной работы для репозиториев, созданных с помощью Git. Вам понадобится аккаунт, чтобы воспользоваться их услугами (стандартные аккаунты бесплатны).

Если у вас есть учетная запись GitHub, самый простой способ поделиться записной книжкой через GitHub на самом деле вообще не используя Git. С 2008 года GitHub предоставляет сервис Gist для размещения и совместного использования фрагментов кода, каждый из которых имеет свой собственный репозиторий. Чтобы поделиться блокнотом с помощью Gists:

Войдите в GitHub и перейдите на gist.github.com.
Откройте файл .ipynb в текстовом редакторе, выберите его содержимое и скопируйте JSON в память.
Вставьте скопированное в блокнот JSON в gist.
Определите имя файла вашего Gist, не забывая добавить .iypnb, иначе это не сработает.
Нажмите “Create secret gist” или “Create public gist.”

Это должно выглядеть примерно так:

Creating a Gist

Если вы создали общедоступную Gist, теперь вы сможете поделиться ее URL-адресом с кем угодно, а другие смогут fork and clone вашу работу.

Создание собственного репозитория Git и распространение его на GitHub выходит за рамки данного руководства, но GitHub предоставляет множество руководств, которые помогут вам освоить его самостоятельно.

Дополнительным советом для тех, кто использует git, является добавление исключения в ваш .gitignore для скрытых каталогов .ipynb_checkpoints, которые создает Jupyter, чтобы избежать ненужной фиксации файлов контрольных точек в вашем репо.

Nbviewer

К 2015 году NBViewer стал самым популярным средством рендеринга ноутбуков в Интернете. Если у вас уже есть место для размещения ваших ноутбуков Jupyter в Интернете, будь то GitHub или где-либо еще, NBViewer отобразит ваш блокнот и предоставит совместно используемый URL-адрес вместе с ним. Предоставляется как бесплатный сервис в рамках проекта Jupyter, он доступен по адресу nbviewer.jupyter.org.

Первоначально разработанный до интеграции GitHub с Jupyter Notebook, NBViewer позволяет любому вводить URL-адрес, идентификатор Gist или имя пользователя/репозиторий/файл GitHub, и он отображает блокнот в виде веб-страницы. Идентификатор Gist – это уникальный номер в конце URL; например, строка символов после последнего обратного слеша в https://gist.github.com/username/50896401c23e0bf417e89cd57e89e1de. Если вы введете имя пользователя GitHub или username/репо, вы увидите минимальный файловый браузер, который позволит вам просматривать репозитории пользователя и их содержимое.

URL-адрес, отображаемый NBViewer при отображении записной книжки, является константой в зависимости от URL-адреса записываемой записной книжки, поэтому вы можете поделиться этим с кем угодно, и он будет работать, пока исходные файлы остаются в сети.

Заключение

Начав с основ, мы познакомились с естественным рабочим процессом Jupyter Notebooks, углубились в более продвинутые функции IPython и, наконец, научились делиться своей работой с друзьями, коллегами и миром. И мы сделали все это из самой записной книжки!

Если вы хотите получить вдохновение для своих собственных ноутбуков, Jupyter собрал галерею интересных ноутбуков Jupyter, которые вам могут пригодиться, и на домашней странице Nbviewer есть ссылки на действительно интересные примеры качественных ноутбуков.

The Jupyter Notebook#

Jupyter Notebook is a notebook authoring application, under the Project Jupyter umbrella. Built on the power of the computational notebook format, Jupyter Notebook offers fast, interactive new ways to prototype and explain your code, explore and visualize your data, and share your ideas with others.

Notebooks extend the console-based approach to interactive computing in a qualitatively new direction, providing a web-based application suitable for capturing the whole computation process: developing, documenting, and executing code, as well as communicating the results. The Jupyter notebook combines two components:

A web application: A browser-based editing program for interactive authoring of computational notebooks which provides a fast interactive environment for prototyping and explaining code, exploring and visualizing data, and sharing ideas with others

Computational Notebook documents: A shareable document that combines computer code, plain language descriptions, data, rich visualizations like 3D models, charts, mathematics, graphs and figures, and interactive controls

See the installation guide on how to install the notebook and its dependencies.

Main features of the web application#

In-browser editing for code, with automatic syntax highlighting, indentation, and tab completion/introspection.
The ability to execute code from the browser, with the results of computations attached to the code which generated them.
Displaying the result of computation using rich media representations, such as HTML, LaTeX, PNG, SVG, etc. For example, publication-quality figures rendered by the [matplotlib] library, can be included inline.
In-browser editing for rich text using the [Markdown] markup language, which can provide commentary for the code, is not limited to plain text.
The ability to easily include mathematical notation within markdown cells using LaTeX, and rendered natively by MathJax.

Notebook documents#

Notebook documents contains the inputs and outputs of a interactive session as well as additional text that accompanies the code but is not meant for execution. In this way, notebook files can serve as a complete computational record of a session, interleaving executable code with explanatory text, mathematics, and rich representations of resulting objects. These documents are internally JSON files and are saved with the .ipynb extension. Since JSON is a plain text format, they can be version-controlled and shared with colleagues.

Notebooks may be exported to a range of static formats, including HTML (for example, for blog posts), reStructuredText, LaTeX, PDF, and slide shows, via the [nbconvert] command.

Furthermore, any .ipynb notebook document available from a public URL can be shared via the Jupyter Notebook Viewer . This service loads the notebook document from the URL and renders it as a static web page. The results may thus be shared with a colleague, or as a public blog post, without other users needing to install the Jupyter notebook themselves. In effect, nbviewer is simply [nbconvert] as a web service, so you can do your own static conversions with nbconvert, without relying on nbviewer.

Notebooks and privacy#

Because you use Jupyter in a web browser, some people are understandably concerned about using it with sensitive data. However, if you followed the standard install instructions, Jupyter is actually running on your own computer. If the URL in the address bar starts with http://localhost: or http://127.0.0.1: , it’s your computer acting as the server. Jupyter doesn’t send your data anywhere else—and as it’s open source, other people can check that we’re being honest about this.

You can also use Jupyter remotely: your company or university might run the server for you, for instance. If you want to work with sensitive data in those cases, talk to your IT or data protection staff about it.

We aim to ensure that other pages in your browser or other users on the same computer can’t access your notebook server. See the security documentation for more about this.

Starting the notebook server#

You can start running a notebook server from the command line using the following command:

jupyter notebook

This will print some information about the notebook server in your console, and open a web browser to the URL of the web application (by default, http://127.0.0.1:8888 ).

The landing page of the Jupyter notebook web application, the dashboard, shows the notebooks currently available in the notebook directory (by default, the directory from which the notebook server was started).

You can create new notebooks from the dashboard with the New Notebook button, or open existing ones by clicking on their name. You can also drag and drop .ipynb notebooks and standard .py Python source code files into the notebook list area.

When starting a notebook server from the command line, you can also open a particular notebook directly, bypassing the dashboard, with jupyter notebook my_notebook.ipynb . The .ipynb extension is assumed if no extension is given.

When you are inside an open notebook, the File | Open. menu option will open the dashboard in a new browser tab, to allow you to open another notebook from the notebook directory or to create a new notebook.

You can start more than one notebook server at the same time, if you want to work on notebooks in different directories. By default the first notebook server starts on port 8888, and later notebook servers search for ports near that one. You can also manually specify the port with the --port option.

Creating a new notebook document#

A new notebook may be created at any time, either from the dashboard, or using the File ‣ New menu option from within an active notebook. The new notebook is created within the same directory and will open in a new browser tab. It will also be reflected as a new entry in the notebook list on the dashboard.

Opening notebooks#

An open notebook has exactly one interactive session connected to a kernel, which will execute code sent by the user and communicate back results. This kernel remains active if the web browser window is closed, and reopening the same notebook from the dashboard will reconnect the web application to the same kernel. In the dashboard, notebooks with an active kernel have a Shutdown button next to them, whereas notebooks without an active kernel have a Delete button in its place.

Other clients may connect to the same kernel. When each kernel is started, the notebook server prints to the terminal a message like this:

[JupyterNotebookApp] Kernel started: 87f7d2c0-13e3-43df-8bb8-1bd37aaf3373

This long string is the kernel’s ID which is sufficient for getting the information necessary to connect to the kernel. If the notebook uses the IPython kernel, you can also see this connection data by running the %connect_info magic , which will print the same ID information along with other details.

You can then, for example, manually start a Qt console connected to the same kernel from the command line, by passing a portion of the ID:

$ jupyter qtconsole --existing 87f7d2c0

Without an ID, --existing will connect to the most recently started kernel.

With the IPython kernel, you can also run the %qtconsole magic in the notebook to open a Qt console connected to the same kernel.

Notebook user interface#

When you create a new notebook document, you will be presented with the notebook name, a menu bar, a toolbar and an empty code cell.

a screenshot showing a blank notebook

Notebook name: The name displayed at the top of the page, next to the Jupyter logo, reflects the name of the .ipynb file. Clicking on the notebook name brings up a dialog which allows you to rename it. Thus, renaming a notebook from “Untitled0” to “My first notebook” in the browser, renames the Untitled0.ipynb file to My first notebook.ipynb .

Menu bar: The menu bar presents different options that may be used to manipulate the way the notebook functions.

Toolbar: The tool bar gives a quick way of performing the most-used operations within the notebook, by clicking on an icon.

Code cell: the default type of cell; read on for an explanation of cells.

Structure of a notebook document#

The notebook consists of a sequence of cells. A cell is a multiline text input field, and its contents can be executed by using Shift - Enter , or by clicking either the “Play” button the toolbar, or Cell , Run in the menu bar. The execution behavior of a cell is determined by the cell’s type. There are three types of cells: code cells, markdown cells, and raw cells. Every cell starts off being a code cell, but its type can be changed by using a drop-down on the toolbar (which will be “Code”, initially), or via keyboard shortcuts .

For more information on the different things you can do in a notebook, see the collection of examples.

Code cells#

A code cell allows you to edit and write new code, with full syntax highlighting and tab completion. The programming language you use depends on the kernel, and the default kernel (IPython) runs Python code.

When a code cell is executed, code that it contains is sent to the kernel associated with the notebook. The results that are returned from this computation are then displayed in the notebook as the cell’s output. The output is not limited to text, with many other possible forms of output are also possible, including matplotlib figures and HTML tables (as used, for example, in the pandas data analysis package). This is known as IPython’s rich display capability.

[Rich Output] example notebook

Markdown cells#

You can document the computational process in a literate way, alternating descriptive text with code, using rich text. In IPython this is accomplished by marking up text with the Markdown language. The corresponding cells are called Markdown cells. The Markdown language provides a simple way to perform this text markup, that is, to specify which parts of the text should be emphasized (italics), bold, form lists, etc.

If you want to provide structure for your document, you can use markdown headings. Markdown headings consist of 1 to 6 hash # signs # followed by a space and the title of your section. The markdown heading will be converted to a clickable link for a section of the notebook. It is also used as a hint when exporting to other document formats, like PDF.

When a Markdown cell is executed, the Markdown code is converted into the corresponding formatted rich text. Markdown allows arbitrary HTML code for formatting.

Within Markdown cells, you can also include mathematics in a straightforward way, using standard LaTeX notation: $. $ for inline mathematics and $$. $$ for displayed mathematics. When the Markdown cell is executed, the LaTeX portions are automatically rendered in the HTML output as equations with high quality typography. This is made possible by MathJax, which supports a large subset of LaTeX functionality

Standard mathematics environments defined by LaTeX and AMS-LaTeX (the amsmath package) also work, such as \begin. \end , and \begin. \end . New LaTeX macros may be defined using standard methods, such as \newcommand , by placing them anywhere between math delimiters in a Markdown cell. These definitions are then available throughout the rest of the IPython session.

[Working with Markdown Cells] example notebook

Raw cells#

Raw cells provide a place in which you can write output directly. Raw cells are not evaluated by the notebook. When passed through [nbconvert], raw cells arrive in the destination format unmodified. For example, you can type full LaTeX into a raw cell, which will only be rendered by LaTeX after conversion by nbconvert.

Basic workflow#

The normal workflow in a notebook is, then, quite similar to a standard IPython session, with the difference that you can edit cells in-place multiple times until you obtain the desired results, rather than having to rerun separate scripts with the %run magic command.

Typically, you will work on a computational problem in pieces, organizing related ideas into cells and moving forward once previous parts work correctly. This is much more convenient for interactive exploration than breaking up a computation into scripts that must be executed together, as was previously necessary, especially if parts of them take a long time to run.

To interrupt a calculation which is taking too long, use the Kernel , Interrupt menu option, or the i,i keyboard shortcut. Similarly, to restart the whole computational process, use the Kernel , Restart menu option or 0,0 shortcut.

A notebook may be downloaded as a .ipynb file or converted to a number of other formats using the menu option File , Download as .

[Running Code in the Jupyter Notebook] example notebook

[Notebook Basics] example notebook

Keyboard shortcuts#

All actions in the notebook can be performed with the mouse, but keyboard shortcuts are also available for the most common ones. The essential shortcuts to remember are the following:

Shift - Enter : run cell : Execute the current cell, show any output, and jump to the next cell below. If Shift - Enter is invoked on the last cell, it makes a new cell below. This is equivalent to clicking the Cell , Run menu item, or the Play button in the toolbar.
Esc : Command mode : In command mode, you can navigate around the notebook using keyboard shortcuts.
Enter : Edit mode : In edit mode, you can edit text in cells.

For the full list of available shortcuts, click Help , Keyboard Shortcuts in the notebook menus.

Searching#

Jupyter Notebook has an advanced built-in search plugin for finding text within a notebook or other document, which uses the Ctrl - F ( Cmd + F for macOS) shortcut by default.

Your browser’s find function will give unexpected results because it doesn’t have access to the full content of a document (by default), but you can still use your browser find function from the browser menu if you want, or you can disable the built-in search shortcut using the Advanced Settings Editor.

Alternatively, you can disable windowed notebook rendering to expose the full document content to the browser at the expense of performance.

Plotting#

One major feature of the Jupyter notebook is the ability to display plots that are the output of running code cells. The IPython kernel is designed to work seamlessly with the [matplotlib] plotting library to provide this functionality. Specific plotting library integration is a feature of the kernel.

Installing kernels#

For information on how to install a Python kernel, refer to the IPython install page.

The Jupyter wiki has a long list of Kernels for other languages. They usually come with instructions on how to make the kernel available in the notebook.

Trusting Notebooks#

To prevent untrusted code from executing on users’ behalf when notebooks open, we store a signature of each trusted notebook. The notebook server verifies this signature when a notebook is opened. If no matching signature is found, Javascript and HTML output will not be displayed until they are regenerated by re-executing the cells.

Any notebook that you have fully executed yourself will be considered trusted, and its HTML and Javascript output will be displayed on load.

If you need to see HTML or Javascript output without re-executing, and you are sure the notebook is not malicious, you can tell Jupyter to trust it at the command-line with:

$ jupyter trust mynotebook.ipynb

See the security documentation for more details about the trust mechanism.

Browser Compatibility#

The Jupyter Notebook aims to support the latest versions of these browsers:

Up to date versions of Opera and Edge may also work, but if they don’t, please use one of the supported browsers.

Using Safari with HTTPS and an untrusted certificate is known to not work (websockets will fail).

User interface components

Руководство для начинающих о том, как сделать Jupyter Notebook быстрее, мощнее и круче

Самое классное в технологиях— это множество людей, которые усердно трудятся для улучшения нашей жизни. Каждый день они кровью и потом создают инструменты, упрощающие нашу работу.

Вам, к примеру, может казаться, что одной установки и запуска Jupyter Notebook вполне достаточно. Если все заработало, то и отлично! Но вы вряд ли знаете, что существует множество способов по настройке этой оболочки. А установка программы или пакета — это всего лишь начало!

Почему бы не потратить пару минут на то, чтобы сделать свой Jupyter Notebook удобнее для работы: быстрее, круче, мощнее и даже интереснее?

Данное руководство рассчитано на новичков в Jupyter Notebook. Мы начнем с самых основ, а затем перейдем к интересным примерам.

Сначала — о главном

После установки запустить Jupyter Notebook можно из терминала по команде:

jupyter notebook

теперь все готово для работы!

Изменение темы блокнота

Обычно первое, что люди хотят изменить в блокнотах Jupyter Notebook, — это тема оформления. Люди сходят с ума по темной теме! Изменить тему можно в любое время, и делается это довольно просто.

Для начала перейдите в терминал и установите jupyterthemes:

pip install jupyterthemes

Теперь можно установить мега-популярную темную тему:

jt -t chesterish

Восстановить основную тему можно через

jt -r

Вот здесь можно найти GitHub-репозиторий jupyterthemes.

Основные команды

Список горячих клавиш доступен из палитры команд, которая открывается по нажатию Ctrl + Shift + P или Cmd + Shift + P . Появившееся диалоговое окно очень похоже на Spotlight Search в Mac и позволяет выполнять команды по названию. Это очень удобно, если вы не знаете нужного сочетания клавиш.

Shift + Enter запускает текущую ячейку;
Esc открывает командный режим. Переходить по блокноту можно с помощью клавиш со стрелками.

В командном режиме можно пользоваться следующими клавишами:

A — добавляет новую ячейку над текущей;
B — добавляет новую ячейку под текущей;
M — изменяет текущую ячейку на Markdown;
Y — возвращает к ячейке с кодом;
D + D — удаляет текущую ячейку (двойное нажатие клавиши);
Enter — переход из командного режима в режим редактирования.

Shift + Tab — показывает документацию для объекта, который вы только что добавили в ячейку кода (продолжайте нажимать эти клавиши для переключения между режимами);
Esc + F — помогает найти и заменить информацию в коде (кроме выходных значений);
Esc + 0 — переключает вывод ячеек;
Shift + J или Shift + Down — выделяет ячейку ниже текущей. Shift + K или Shift + Up выделяет ячейку выше текущей. После выделения (выбора) ячеек можно выполнять пакетное удаление/копирование/вырезание/вставку/запуск. Это очень удобно, если нужно перенести часть документа.
Shift + M — объединяет несколько ячеек (простой клик по нужным ячейкам ничего вам не даст. Для объединения ячеек их следует выделять с зажатым Shift , а затем, не отпуская Shift , нажать M ).

В Jupiter Notebook можно запускать bash-команды. Для этого добавьте в начало строки восклицательный знак. Например: !pip install numpy
Вы можете подавить вывод функции в последней строке кода, добавив в конце этой строки точку с запятой.

Комментирование/ удаление комментариев в блоках кода

Возможно, в процессе работы вам захочется добавить новые строки кода или закомментировать старые. Это весьма полезно при отладке и улучшении производительности кода.

Для добавления комментариев в код выделите нужные строки и нажмите cmd + / .

LaTex

Если напечатать LaTex в Markdown-ячейке, то она отобразится в виде формулы.

LaTex заменяет это:

$P(A \mid B) = \frac$

Вывод всех значений ячейки

Как правило, в ячейке отображается только последний вывод. Для всего остального нужно прописывать print() . В принципе, ничего сложного, но это не всегда удобно. Изменить ситуацию можно, добавив вверху блокнота следующее:

from IPython.core.interactiveshell import InteractiveShellInteractiveShell.ast_node_interactivity = “all”

Несмотря на то, что по умолчанию выводится только последний результат:

… вы увидите их все!

Если захотите вернуться к обычному представлению, то выполните следующее:

from IPython.core.interactiveshell import InteractiveShellInteractiveShell.ast_node_interactivity = “last_expr”

Обратите внимание, что запускать команду для изменения настроек необходимо в отдельной ячейке. Тогда изменения вступят в силу при следующем выполнении ячейки.

Расширения

Jupyter Notebook — это веб-приложение с открытым кодом, поэтому для него написано множество расширений. Все поддерживаемые расширения можно найти в официальном списке iPython-расширений или популярной подборке расширений.

Установить Nbextensions из командной строки довольно просто.

С помощью pip:

pip install jupyter_contrib_nbextensions
jupyter contrib nbextension install — user

или Anaconda:

conda install -c conda-forge jupyter_contrib_nbextensions
conda install -c conda-forge jupyter_nbextensions_configurator
jupyter contrib nbextension install — user

Сразу после их установки вы увидите вкладку Nbextensions. Пользуйтесь на здоровье!

В самом Jupyter Notebook детально описано, как добавлять, включать и работать с расширениями. Кликните по Nbextensions вверху экрана, нажмите на нужное расширение, пролистайте информацию о нем и посмотрите GIF-файл с его возможностями.