Python
Овладение Python Shiny: Руководство для начинающих

Овладение Python Shiny: Руководство для начинающих

MoeNagy Dev

Что такое Python Shiny?

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

Определение Python Shiny

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

Обзор фреймворка Shiny

Фреймворк Shiny разработан для облегчения создания веб-приложений, которыми можно пользоваться для отображения данных, выполнения анализа и взаимодействия с пользователями. Он следует реактивной модели программирования, при которой изменения в пользовательском интерфейсе (UI) или данных автоматически вызывают обновление логики и вывода приложения.

Обычно Shiny-приложения состоят из двух основных компонентов:

  1. Пользовательский интерфейс (UI): UI определяет макет, внешний вид и интерактивные элементы приложения, такие как кнопки, выпадающие списки, таблицы и графики.
  2. Логика сервера: Логика сервера содержит код на Python, который обрабатывает пользовательский ввод, обрабатывает данные и генерирует динамическое содержимое для отображения в пользовательском интерфейсе.

Shiny-приложения можно развертывать на различных платформах, включая локальные среды разработки, облачные хостинговые сервисы и корпоративные серверы.

Основные функции и преимущества использования Python Shiny

  1. Быстрая разработка приложений: Shiny упрощает процесс создания интерактивных веб-приложений, позволяя разработчикам сосредоточиться на основных функциях, а не на деталях веб-разработки.
  2. Реактивное программирование: Реактивная модель программирования Shiny гарантирует, что изменения в пользовательском интерфейсе или данных автоматически вызывают обновление приложения, обеспечивая плавный и отзывчивый пользовательский интерфейс.
  3. Гибкость и расширяемость: Shiny-приложения можно настраивать и расширять с помощью HTML, CSS, JavaScript и других библиотек Python, что позволяет разработчикам создавать высокотехнологичные решения.
  4. Интеграция с экосистемой Python: Shiny плотно интегрируется с обширной экосистемой Python, позволяя разработчикам использовать широкий спектр инструментов для обработки данных, анализа и визуализации.
  5. Варианты развертывания: Shiny-приложения можно развертывать на различных платформах, от локальных сред разработки до облачных хостинговых сервисов, что делает его доступным для широкого круга пользователей.
  6. Сообщество и поддержка: Сообщество Shiny предоставляет множество ресурсов, включая документацию, учебники и прикладные приложения от участников сообщества, что упрощает процесс обучения и разработки на фреймворке.

Начало работы с Python Shiny

Установка Python Shiny

Для начала работы с Python Shiny вам потребуется установить Python на свою систему. Затем вы можете установить пакет Shiny с помощью pip, пакетного менеджера Python:

pip install shiny

Это установит основной пакет Shiny, а также все необходимые зависимости.

Настройка среды разработки

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

  1. Интегрированная среда разработки (IDE): Используйте дружественную к Python IDE, такую как PyCharm, Visual Studio Code или Jupyter Notebook, для написания, тестирования и отладки ваших Shiny-приложений.
  2. Виртуальные среды: Создайте виртуальную среду, чтобы изолировать зависимости вашего проекта Shiny от других проектов Python на вашей системе. Для этого можно использовать инструменты, такие как venv или conda.
  3. Система контроля версий: Используйте систему контроля версий, такую как Git, для управления кодовой базой вашего Shiny-приложения и совместной работы с другими разработчиками, если это необходимо.
  4. Инструменты развертывания: Изучите варианты и инструменты развертывания, такие как Docker или облачные хостинговые платформы, для упрощения публикации ваших Shiny-приложений.

Создание простого Shiny-приложения

Давайте начнем с создания простого Shiny-приложения, которое отображает заголовок и кнопку. Создайте новый файл Python, например, app.py, и добавьте следующий код:

import shiny
from shiny import App, Inputs, Outputs, Session
 
app = App(
    ui=shiny.ui.page_fluid(
        shiny.ui.h1("Добро пожаловать в мое Shiny-приложение!"),
        shiny.ui.button_primary("Нажми меня", "my_button"),
    ),
    server=function(input, output, session):
        @shiny.input
        def my_button_clicks(event):
            return 0
)
 
if __name__ == "__main__":
    app.run()

В этом примере мы определяем пользовательский интерфейс (UI), используя компоненты UI Shiny, включая заголовок и основную кнопку. Логика на стороне сервера просто определяет реактивную функцию ввода, которая отслеживает количество нажатий кнопки.

Чтобы запустить приложение, сохраните файл и выполните следующую команду в терминале:

python app.py

Это запустит Shiny-приложение и откроет его в вашем веб-браузере по умолчанию.

Создание пользовательского интерфейса (UI)

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

Компоненты пользовательского интерфейса Shiny

Shiny предлагает различные компоненты пользовательского интерфейса, которые можно использовать для создания интерфейса приложения, включая:

  • Layouts: page_fluid(), page_fixed(), sidebаr_lаyout(), tаbs(), и другие
  • Inputs: text_input(), numeric_input(), slider_input(), dropdown(), и другие
  • Outputs: text_output(), plot_output(), table_output(), и другие
  • Контейнеры: column(), row(), box(), card(), и другие
  • Форматирование: h1(), h2(), p(), br(), div(), и другие

Вот пример того, как вы можете использовать некоторые из этих компонентов для создания более сложного интерфейса:

из шини import App, Inputs, Outputs, Session
 
app = App(
    ui=шини.ui.page_fluid(
        shiny.ui.h1("Мое блестящее приложение"),
        shiny.ui.sidebar_layout(
            shiny.ui.sidebar(
                shiny.ui.input_text("name", "Имя"),
                shiny.ui.input_numeric("age", "Возраст", min=0, max=120),
                shiny.ui.input_dropdown("gender", "Пол", ["Мужской", "Женский", "Другой"]),
            ),
            shiny.ui.main_panel(
                shiny.ui.text_output("greeting"),
                shiny.ui.plot_output("plot")
            )
        )
    ),
    сервер=function(input, output, session):
        @shiny.output
        def greeting():
            return f"Привет, {input.name()}! Тебе {input.age()} лет, и ты {input.gender()}."
 
        @shiny.output
        def plot():
            # Создание графика с использованием Matplotlib, Plotly или другой библиотеки визуализации
            import matplotlib.pyplot as plt
            plt.plot([1, 2, 3, 4], [1, 4, 9, 16])
            return plt.gcf()
)
 
если __name__ == "__main__":
    app.run()

В этом примере мы используем sidebar_layout() для создания отзывчивого интерфейса с боковой панелью и основной панелью. В боковой панели содержатся компоненты ввода для имени, возраста и пола пользователя, в то время как в основной панели отображается приветственное сообщение и график.

Настройка макета и внешнего вида

Shiny позволяет настраивать макет и внешний вид вашего приложения с помощью HTML, CSS и JavaScript. Вы можете встраивать эти элементы непосредственно в ваш код Shiny UI или ссылаться на внешние файлы.

Например, чтобы добавить пользовательский CSS-файл в ваше приложение Shiny, вы можете использовать функцию tags.link():

из блестящего импорта App, Inputs, Outputs, Session
из блестящие типы импорта TagList
 
app = App(
    ui=шини.ui.page_fluid(
        shiny.tags.link(rel="stylesheet", href="custom.css"),
        # Другие компоненты пользовательского интерфейса
    ),
    сервер=function(input, output, session):
        # Логика сервера
)
 
если __name__ == "__main__":
    app.run()

В этом случае файл custom.css должен быть помещен в ту же директорию, что и ваш файл app.py.

Вы также можете использовать встроенные CSS-классы и темы Shiny для оформления пользовательского интерфейса вашего приложения. Shiny предоставляет несколько предопределенных тем, таких как "cerulean", "cosmo", и "flatly", которые можно применить к компонентам page_fluid() или page_fixed() вашего приложения.

app = App(
    ui=шини.ui.page_fluid(
        theme=shiny.bootstrap.themes.cerulean,
        # Другие компоненты пользовательского интерфейса
    ),
    сервер=function(input, output, session):
        # Логика сервера
)

Обработка действий пользователя

Реактивная модель программирования Shiny позволяет создавать приложения, откликающиеся на действия пользователя в режиме реального времени. Это достигается с использованием реактивных входных и выходных данных.

Реактивное программирование в Shiny

В Shiny логика со стороны сервера определяется как набор реактивных функций, которые реагируют на изменения состояния приложения, такие как пользовательские входные данные или другие реактивные значения. Эти реактивные функции помечены декораторами @shiny.input или @shiny.output, в зависимости от того, отвечают ли они за обработку входных данных пользователя или генерацию вывода для пользовательского интерфейса.

Вот пример простой реактивной функции ввода:

из блестящего импорта App, Inputs, Outputs, Session
 
app = App(
    ui=шини.ui.page_fluid(
        shiny.ui.input_text("name", "Введите ваше имя"),
        shiny.ui.text_output("greeting"),
    ),
    сервер=function(input, output, session):
        @shiny.output
        def greeting():
            return f"Привет, {input.name()}!"
)
 
если __name__ == "__main__":
    app.run()

В этом примере функция greeting() является реактивным выводом, который зависит от значения входного параметра name. Когда пользователь изменяет текст в поле ввода, функция greeting() будет автоматически переоцениваться, и новый вывод будет отображаться в пользовательском интерфейсе.

Отклик на действия пользователя

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

Вот пример того, как вы можете реагировать на нажатие кнопки:

из блестящего импорта App, Inputs, Outputs, Session
 
app = App(
    ui=шини.ui.page_fluid(
        shiny.ui.button_primary("Нажми меня", "my_button"),
        shiny.ui.text_output("click_count"),
    ),
    сервер=function(input, output, session):
        click_count = 0
 
        @shiny.input
        def my_button_clicks(event):
            nonlocal click_count
            click_count += 1
            return click_count
 
        @shiny.output
        def click_count():
            return f"Вы нажали кнопку {input.my_button_clicks()} раз."
)
 
если __name__ == "__main__":
    app.run()

В этом примере функция my_button_clicks() является реактивным вводом, который отслеживает количество нажатий на кнопку. Функция click_count() является реактивным выводом, который отображает текущее количество нажатий в пользовательском интерфейсе.

Обновление пользовательского интерфейса на основе действий пользователя

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

Вот пример того, как вы можете обновить график на основе ввода пользователя:

от shiny импорт приложение, Входы, выводы, сеанс
импорт numpy как np
импорт matplotlib.pyplot как plt
 
приложение = Приложение(
    интерфейс = сверка.ui.page_fluid(
        сверка.ui.input_numeric("num_points", "Количество точек", min=10, max=1000, value=100),
        сверка.ui.plot_output("plot"),
    ),
    серверная часть = функция(
 
## Структуры данных
 
### Списки
Списки являются одной из самых фундаментальных структур данных в Python. Они представляют собой упорядоченные коллекции элементов и могут содержать элементы разных типов данных. Вот пример:
 
```python
my_list = [1, 'привет', 3.14, True]

Вы можете получить доступ к элементам в списке с помощью их индекса, который начинается с 0:

print(my_list[0])  # Вывод: 1
print(my_list[2])  # Вывод: 3.14

Списки поддерживают различные методы для манипулирования их содержимым, такие как append(), insert(), remove() и pop().

my_list.append(42)
my_list.insert(1, 'мир')
my_list.remove(True)
popped_item = my_list.pop(2)

Кортежи

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

my_tuple = (1, 'привет', 3.14)

Вы можете получить доступ к элементам в кортеже так же, как в списке:

print(my_tuple[0])  # Вывод: 1
print(my_tuple[2])  # Вывод: 3.14

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

Словари

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

my_dict = {'name': 'Джон', 'age': 30, 'city': 'Нью-Йорк'}

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

print(my_dict['name'])  # Вывод: 'Джон'
print(my_dict['age'])   # Вывод: 30

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

Множества

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

my_set = {1, 2, 3, 4, 5}

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

множество1 = {1, 2, 3}
множество2 = {2, 3, 4}
print(set1 | set2)  # Вывод: {1, 2, 3, 4}
print(set1 & set2)  # Вывод: {2, 3}
print(set1 - set2)  # Вывод: {1}

Управление потоком выполнения

Условные операторы

Условные операторы в Python используют ключевые слова if, elif и else для выполнения разных блоков кода в зависимости от определенных условий.

x = 10
if x > 0:
    print("x положительный")
elif x < 0:
    print("x отрицательный")
else:
    print("x равен нулю")

Циклы

Python поддерживает два основных типа циклов: циклы for и циклы while. Циклы for используются для итерации по последовательностям, таким как списки, кортежи или строки, а циклы while используются для выполнения блока кода до тех пор, пока определенное условие истинно.

# цикл for
for i in range(5):
    print(i)  # Вывод: 0 1 2 3 4
 
# цикл while
count = 0
while count < 3:
    print(count)
    count += 1  # Вывод: 0 1 2

Списковые включения

Списковые включения предоставляют краткий способ создания новых списков на основе существующих. Они особенно полезны для выполнения преобразований или фильтрации данных в коллекциях.

# Создание списка квадратов
numbers = [1, 2, 3, 4, 5]
squares = [x**2 for x in numbers]
print(squares)  # Вывод: [1, 4, 9, 16, 25]
 
# Фильтрация четных чисел
even_numbers = [x for x in numbers if x % 2 == 0]
print(even_numbers)  # Вывод: [2, 4]

Функции

Функции в Python определяются с помощью ключевого слова def, за которым следует имя функции и набор скобок, которые могут содержать параметры.

def greet(name):
    print(f"Привет, {name}!")
 
greet("Алиса")  # Вывод: Привет, Алиса!

Функции также могут возвращать значения с помощью ключевого слова return.

def add_numbers(a, b):
    return a + b
 
result = add_numbers(3, 4)
print(result)  # Вывод: 7

Значения параметров по умолчанию и именованные аргументы

Функции могут иметь значения по умолчанию для своих параметров и также могут принимать именованные аргументы.

def greet(name, message="Привет"):
    print(f"{message}, {name}!")
 
greet("Алиса")  # Вывод: Привет, Алиса!
greet("Боб", message="Привет")  # Вывод: Привет, Боб!

Область видимости переменных

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

global_var = 10
 
def my_function():
    local_var = 20
    print(global_var)  # Можно обращаться к глобальной переменной
    print(local_var)   # Можно обращаться к локальной переменной
 
my_function()
print(global_var)  # Можно обращаться к глобальной переменной
# print(local_var)  # Ошибка: local_var не определено за пределами функции

Модули и пакеты

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

# my_module.py
def say_hello(name):
    print(f"Привет, {name}!")
 
# main.py
import my_module
my_module.say_hello("Алиса")  # Вывод: Привет, Алиса!

Вы также можете импортировать конкретные функции или атрибуты из модуля с помощью ключевого слова from.

from my_module import say_hello
say_hello("Боб")  # Вывод: Привет, Боб!

Пакеты создаются путем добавления файла __init__.py к каталогу, содержащему несколько модулей.

my_package/
    __init__.py
    module1.py

Вы можете импортировать функции или классы из пакета, используя его имя.

import my_package.module1
my_package.module1.my_function()

Заключение

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

MoeNagy Dev