• Виртуализация
• Контейнеризация (с помощью Docker)
• Docker
• Создание Dockerfile
• Docker Compose
• Настройка Django приложения в среде Docker с помощью Dockerfile и docker-compose

Условия

Чтобы справиться с этим руководством вам нужно иметь следующее:

• Git/GitHub
• PyCharm (или любой другой редактор кода)
• Опыт работы с Django

Готовый репозиторий с Django-приложением, как всегда на GitLab: https://gitlab.com/PythonRu/django-docker.

Что такое виртуализация

Обычно при развертывании веб-приложения в хостинге (например, DigitalOcean или Linode) вы настраиваете виртуальную машину или виртуальный компьютер, куда будет перенесен весь код с помощью git, FTP или другими средствами. Это называется виртуализацией.

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

Что такое контейнеры, и что в них такого особенного?

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

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

Поскольку контейнеризация — куда более портативное, масштабируемое и эффективное решение, такие платформы, как Docker, становятся популярным выбором разработчиков.

Введение в Docker

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

Установка Docker

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

• Для Windows
• Linux
• и Mac

Настройка приложения

Для этого руководства используем репозиторий приложения для опросов, написанного на Django. По мере продвижения в этом руководстве настроим Dockerfile, в котором будут обозначены инструкции для контейнера, внутри которого приложение и будет работать. После этого же настроим и файл docker-compose.yml для упрощения всего процесса.

На ПК с установленным git перейдите в выбранную папку и клонируйте следующий репозиторий из GitLab:

git clone https://gitlab.com/PythonRu/django-docker.git

После этого перейдите в корень этой папки и откройте ее в редакторе с помощью такой команды:

cd django-docker && code .

В этой папке создайте файл Dockerfile (регистр играет роль) без формата. Внутри него будут находиться настройки контейнера. Инструкции из него компьютер будет выполнять каждый раз при запуске команды docker build.

Следующий этап — создание файла requirements.txt, в котором перечислены все зависимости. Позже он будет использован для Dockerfile, в котором также требуется указывать все требуемые зависимости.

В файле requirements.txt добавьте Django версии 3.1.2 в таком формате:

Django==3.1.2

Что такое Dockerfile

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

1. Базовый образ, на основе которого требуется построить свой. Он выступает своего рода фундаментом для вашего приложения. Это может быть операционная система, язык программирования (Python в нашем случае) или фреймворк.
2. Пакеты и дополнительные инструменты для образа.
3. Скрипты и файлы, которые требуется скопировать в образ. Обычно это и есть исходный код приложения.

При чтении или написании такого файла удобно держать в голове следующее:

• Строки с инструкциями обычно начинаются с ключевого слова, например: RUN, FROM, COPY, WORKDIR и так далее.
• Комментарии начинаются с символа #. При выполнении инструкций из файла такие комментарии обычно игнорируются.

Создание Dockerfile

Приложение будет работать на основе официального образа Python. Напишем следующие инструкции:

# Указывает Docker использовать официальный образ python 3 с dockerhub в качестве базового образа
FROM python:3
# Устанавливает переменную окружения, которая гарантирует, что вывод из python будет отправлен прямо в терминал без предварительной буферизации
ENV PYTHONUNBUFFERED 1
# Устанавливает рабочий каталог контейнера — "app"
WORKDIR /app
# Копирует все файлы из нашего локального проекта в контейнер
ADD ./app
# Запускает команду pip install для всех библиотек, перечисленных в requirements.txt
RUN pip install -r requirements.txt

Файл Docker Compose

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

Обычно Docker Compose использует файл docker-compose.yml для настройки сервисов, которые приложение будет использовать. Запускаются эти сервисы с помощью команды docker-compose up. Это создает и запускает все сервисы из файла. В большинстве веб-приложений нужны, веб-сервер (такой как nginx) и база данных (например, PostgreSQL). В этом приложении будем использовать SQLite, поэтому внешняя база данных не потребуется.

Для использования особенностей Docker Compose нужно создать файл docker-compose.yml в той же папке, где находится Dockerfile и добавить туда следующий код:

version: '3.8'
services:
   web:
       build: .
       command: python manage.py runserver localhost:8000
       ports:
           - 8000:8000

Дальше разберем содержимое файла построчно:

version: '3.8'

Эта строка сообщает Docker, какая версия docker-compose должна быть использована для запуска файла. На момент написания руководства последняя версия — 3.8, но обычно синтаксис не сильно меняется по мере выхода последующих.

После настройки docker-compose откройте терминал и запустите команду docker-compose up -d для запуска приложения. Дальше открывайте ссылку localhost:8000 в браузере, чтобы увидеть приложение в действии:

Для закрытия контейнера используется команда docker-compose down.

Выводы

Репозиторий проекта: https://gitlab.com/PythonRu/django-docker.

В этом руководстве вы познакомились с виртуализацией, контейнеризацией и другими терминами из мира Docker. Также вы теперь знаете, что такое Dockerfile, как его создавать для запуска контейнеризированного Django-приложения. Наконец, разобрались с настройкой docker-compose с помощью файла docker-compose.yml для сервисов, от которых зависит самое приложения.

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

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

Алгоритм Random Forest

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

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

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

Вышеупомянутый процесс принятия решения состоит из двух частей.

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

Технически Random forest — это метод (основанный на подходе «разделяй и властвуй»), использующий ансамбль деревьев решений, созданных на случайно разделенном датасете. Набор таких деревьев-классификаторов образует лес. Каждое отдельное дерево решений генерируется с использованием метрик отбора показателей, таких как критерий прироста информации, отношение прироста и индекс Джини для каждого признака.

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

Как работает случайный лес?

Алгоритм состоит из четырех этапов:

1. Создайте случайные выборки из заданного набора данных.
2. Для каждой выборки постройте дерево решений и получите результат предсказания, используя данное дерево.
3. Проведите голосование за каждый полученный прогноз.
4. Выберите предсказание с наибольшим количеством голосов в качестве окончательного результата.

Поиск важных признаков

Random forest также предлагает хороший критерий отбора признаков. Scikit-learn предоставляет дополнительную переменную при использовании модели случайного леса, которая показывает относительную важность, то есть вклад каждого показателя в прогноз. Библиотека автоматически вычисляет оценку релевантности каждого признака на этапе обучения. Затем полученное значение нормализируется так, чтобы сумма всех оценок равнялась 1.

Такая оценка поможет выбрать наиболее значимые показатели и отбросить наименее важные для построения модели.

Случайный лес использует критерий Джини, также известный как среднее уменьшение неопределенности (MDI), для расчета важности каждого признака. Кроме того, критерий Джини иногда называют общим уменьшением неопределенности в узлах. Он показывает, насколько снижается точность модели, когда вы отбрасываете переменную. Чем больше уменьшение, тем значительнее отброшенный признак. Таким образом, среднее уменьшение является необходимым параметром для выбора переменной. Также с помощью данного критерия можете быть отображена общая описательная способность признаков.

Сравнение случайных лесов и деревьев решений

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

Создание классификатора с использованием Scikit-learn

Вы будете строить модель на основе набора данных о цветках ириса, который является очень известным классификационным датасетом. Он включает длину и ширину чашелистика, длину и ширину лепестка, и тип цветка. Существуют три вида (класса) ирисов: Setosa, Versicolor и Virginica. Вы построите модель, определяющую тип цветка из вышеперечисленных. Этот датасет доступен в библиотеке scikit-learn или вы можете загрузить его из репозитория машинного обучения UCI.

Начнем с импорта datasets из scikit-learn и загрузим набор данных iris с помощью load_iris().

from sklearn import datasets

# загрузка датасета
iris = datasets.load_iris()

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

print(iris.target_names)
print(iris.feature_names)

['setosa' 'versicolor' 'virginica']
['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']

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

Ниже мы создаем dataframe из нашего набора данных об ирисах.

import pandas as pd

data=pd.DataFrame({
    'sepal length':iris.data[:,0],
    'sepal width':iris.data[:,1],
    'petal length':iris.data[:,2],
    'petal width':iris.data[:,3],
    'species':iris.target
})
data.head()

Далее мы разделяем столбцы на зависимые и независимые переменные (признаки и метки целевых классов). Затем давайте создадим выборки для обучения и тестирования из исходных данных.

from sklearn.model_selection import train_test_split

X = data[['sepal length', 'sepal width', 'petal length', 'petal width']]
y = data['species']

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=85)

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

from sklearn.ensemble import RandomForestClassifier

clf = RandomForestClassifier(n_estimators=100)
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)

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

from sklearn.ensemble import RandomForestClassifier

clf = RandomForestClassifier(n_estimators=100)
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)

Accuracy: 0.9333333333333333

Вы также можете сделать предсказание для единственного наблюдения. Предположим, sepal length=3, sepal width=5, petal length=4, petal width=2.

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

clf.predict([[3, 5, 4, 2]])
# результат - 2

Выше цифра 2 указывает на класс цветка «virginica».

Поиск важных признаков с помощью scikit-learn

В этом разделе вы определяете наиболее значимые признаки или выполняете их отбор в датасете iris. В scikit-learn мы можем решить эту задачу, выполнив перечисленные шаги:

• Создадим модель случайного леса.
• Используем переменную feature_importances_, чтобы увидеть соответствующие оценки значимости показателей.
• Визуализируем полученные оценочные значения с помощью библиотеки seaborn.

from sklearn.ensemble import RandomForestClassifier
import pandas as pd

clf = RandomForestClassifier(n_estimators=100)
clf.fit(X_train,y_train)
feature_imp = pd.Series(clf.feature_importances_,index=iris.feature_names).sort_values(ascending=False)
feature_imp

petal width (cm)     0.470224
petal length (cm)    0.424776
sepal length (cm)    0.075913
sepal width (cm)     0.029087

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

Для построения необходимых диаграмм вы можете использовать библиотеки matplotlib и seaborn совместно, потому что seaborn, построенная поверх matplotlib, предлагает множество специальных тем и дополнительных графиков. Matplotlib — это надмножество seaborn, и обе библиотеки одинаково необходимы для хорошей визуализации.

import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline

sns.barplot(x=feature_imp, y=feature_imp.index)

plt.xlabel('Важность признаков')
plt.ylabel('Признаки')
plt.title('Визуализация важных признаков')
plt.show()

Повторная генерация модели с отобранными признаками

Далее мы удаляем показатель «sepal width» и используем оставшиеся 3 признака, поскольку ширина чашелистика имеет очень низкую важность.

from sklearn.model_selection import train_test_split

X = data[['petal length', 'petal width','sepal length']]
y = data['species']

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.7, random_state=85)

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

from sklearn.ensemble import RandomForestClassifier

clf = RandomForestClassifier(n_estimators=100)
clf.fit(X_train,y_train)

y_pred = clf.predict(X_test)

from sklearn import metrics
print("Accuracy:", metrics.accuracy_score(y_test, y_pred))

Accuracy: 0.9619047619047619

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

Преимущества Random Forest:

• Случайный лес считается высокоточным и надежным методом, поскольку в процессе прогнозирования участвует множество деревьев решений.
• Random forest не страдает проблемой переобучения. Основная причина в том, что случайный лес использует среднее значение всех прогнозов, что устраняет смещения.
• RF может использоваться в обоих типах задач (задачах классификации и регрессии).
• Случайный лес также может работать с отсутствующими значениями. Есть два способа решения такой проблемы в Random forest. В первом используется медианное значение для заполнения непрерывных переменных, а во втором вычисляется среднее взвешенное пропущенных значений.
• RF также рассчитывает относительную важность показателей, которая помогает в выборе наиболее значимых признаков для классификатора.

Недостатки Random Forest:

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

Заключение

Вы узнали об алгоритме Random forest и принципе его работы, о поиске важных признаков, о главных отличиях случайного леса от дерева решений, о преимуществах и недостатках данного метода. Также научились создавать и оценивать модели, находить наиболее значимые показатели в scikit-learn. Не останавливайся на этом!

Я рекомендую вам попробовать RF на разных наборах данных и прочитать больше о матрице ошибок.

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

Две модели машинного обучения выполняют большую часть работы, когда дело доходит до задач классификации:

• Метод K-ближайших соседей
• Метод К-средних

Из этого руководства вы узнаете, как применять алгоритмы K-ближайших соседей и K-средних в коде на Python.

Модели K-ближайших соседей

Алгоритм K-ближайших соседей является одним из самых популярных среди ML-моделей для решения задач классификации.

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

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

Используемый датасет

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

Далее вам нужно переместить загруженный файл с датасетом в рабочий каталог. После этого откройте Jupyter Notebook — теперь мы можем приступить к написанию кода на Python!

Необходимые библиотеки

Чтобы написать алгоритм K-ближайших соседей, мы воспользуемся преимуществами многих Python-библиотек с открытым исходным кодом, включая NumPy, pandas и scikit-learn.

Начните работу, добавив следующие инструкции импорта:

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

%matplotlib inline

Импорт датасета

Следующий шаг — добавление файла classified_data.csv в наш код на Python. Библиотека pandas позволяет довольно просто импортировать данные в DataFrame.

Поскольку датасет хранится в файле csv, мы будем использовать метод read_csv:

raw_data = pd.read_csv('classified_data.csv')

Отобразив полученный DataFrame в Jupyter Notebook, вы увидите, что представляют собой наши данные:

Стоит заметить, что таблица начинается с безымянного столбца, значения которого равны номерам строк DataFrame. Мы можем исправить это, немного изменив команду, которая импортировала наш набор данных в скрипт Python:

raw_data = pd.read_csv('classified_data.csv', index_col = 0)

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

raw_data.columns

Получаем:

Index(['WTT', 'PTI', 'EQW', 'SBI', 'LQE', 'QWG', 'FDJ', 'PJF', 'HQE', 'NXJ',
       'TARGET CLASS'],
      dtype='object')

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

Стандартизация датасета

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

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

К счастью, библиотека scikit-learn позволяет сделать это без особых проблем.

Для начала нам нужно будет импортировать класс StandardScaler из scikit-learn. Для этого добавьте в свой скрипт Python следующую команду:

from sklearn.preprocessing import StandardScaler

Этот класс во многом похож на классы LinearRegression и LogisticRegression, которые мы использовали ранее в этом курсе. Нам нужно создать экземпляр StandardScaler, а затем использовать этот объект для преобразования наших данных.

Во-первых, давайте создадим экземпляр класса StandardScaler с именем scaler следующей инструкцией:

scaler = StandardScaler()

Теперь мы можем обучить scaler на нашем датасете, используя метод fit:

scaler.fit(raw_data.drop('TARGET CLASS', axis=1))

Теперь мы можем применить метод transform для стандартизации всех признаков, чтобы они имели примерно одинаковый масштаб. Мы сохраним преобразованные семплы в переменной scaled_features:

scaled_features = scaler.transform(raw_data.drop('TARGET CLASS', axis=1))

В качестве результата мы получили массив NumPy со всеми точками данных из датасета, но нам желательно преобразовать его в формат DataFrame библиотеки pandas.

К счастью, сделать это довольно легко. Мы просто обернем переменную scaled_features в метод pd.DataFrame и назначим этот DataFrame новой переменной scaled_data с соответствующим аргументом для указания имен столбцов:

scaled_data = pd.DataFrame(scaled_features, columns = raw_data.drop('TARGET CLASS', axis=1).columns)

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

Разделение датасета на обучающие и тестовые данные

Мы будем использовать функцию train_test_split библиотеки scikit-learn в сочетании с распаковкой списка для создания обучающих и тестовых датасетов из нашего набора секретных данных.

Во-первых, вам нужно импортировать train_test_split из модуля model_validation библиотеки scikit-learn:

from sklearn.model_selection import train_test_split

Затем нам необходимо указать значения x и y, которые будут переданы в функцию train_test_split.

Значения x представляют собой DataFrame scaled_data, который мы создали ранее. Значения y хранятся в столбце "TARGET CLASS" нашей исходной таблицы raw_data.

Вы можете создать эти переменные следующим образом:

x = scaled_data
y = raw_data['TARGET CLASS']

Затем вам нужно запустить функцию train_test_split, используя эти два аргумента и разумный test_size. Мы будем использовать test_size 30%, что дает следующие параметры функции:

x_training_data, x_test_data, y_training_data, y_test_data = train_test_split(x, y, test_size = 0.3)

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

Обучение модели K-ближайших соседей

Начнем с импорта KNeighborsClassifier из scikit-learn:

from sklearn.neighbors import KNeighborsClassifier

Затем давайте создадим экземпляр класса KNeighborsClassifier и назначим его переменной model.

Для этого требуется передать параметр n_neighbors, который равен выбранному вами значению K алгоритма K-ближайших соседей. Для начала укажем n_neighbors = 1:

model = KNeighborsClassifier(n_neighbors = 1)

Теперь мы можем обучить нашу модель, используя метод fit и переменные x_training_data и y_training_data:

model.fit(x_training_data, y_training_data)

Теперь давайте сделаем несколько прогнозов с помощью полученной модели!

Делаем предсказания с помощью алгоритма K-ближайших соседей

Способ получения прогнозов на основе алгоритма K-ближайших соседей такой же, как и у моделей линейной и логистической регрессий, построенных нами ранее в этом курсе: для предсказания достаточно вызвать метод predict, передав в него переменную x_test_data.

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

predictions = model.predict(x_test_data)

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

Оценка точности нашей модели

В руководстве по логистической регрессии мы видели, что scikit-learn поставляется со встроенными функциями, которые упрощают измерение эффективности классификационных моделей машинного обучения.

Для начала импортируем в наш отчет две функции classification_report и confusion_matrix:

from sklearn.metrics import classification_report
from sklearn.metrics import confusion_matrix

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

print(classification_report(y_test_data, predictions))

Полученный вывод:

              precision    recall  f1-score   support

           0       0.92      0.91      0.91       148
           1       0.91      0.92      0.92       152

    accuracy                           0.91       300
   macro avg       0.91      0.91      0.91       300
weighted avg       0.91      0.91      0.91       300

Точно так же вы можете сгенерировать матрицу ошибок:

print(confusion_matrix(y_test_data, predictions))
# Вывод:
# [[134  14]
# [ 12 140]]

Глядя на такие метрики производительности, похоже, что наша модель уже достаточно эффективна. Но ее еще можно улучшить.

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

Выбор оптимального значения для K с помощью метода «Локтя»

В этом разделе мы будем использовать метод «локтя», чтобы выбрать оптимальное значение K для нашего алгоритма K-ближайших соседей.

Метод локтя включает в себя итерацию по различным значениям K и выбор значения с наименьшей частотой ошибок при применении к нашим тестовым данным.

Для начала создадим пустой список error_rates. Мы пройдемся по различным значениям K и добавим их частоту ошибок в этот список.

error_rates = []

Затем нам нужно создать цикл Python, который перебирает различные значения K, которые мы хотим протестировать, и на каждой итерации выполняет следующее:

• Создает новый экземпляр класса KNeighborsClassifier из scikit-learn.
• Тренирует эту модель, используя наши обучающие данные.
• Делает прогнозы на основе наших тестовых данных.
• Вычисляет долю неверных предсказаний (чем она ниже, тем точнее наша модель).

Реализация описанного цикла для значений K от 1 до 100:

for i in np.arange(1, 101):
    new_model = KNeighborsClassifier(n_neighbors = i)
    new_model.fit(x_training_data, y_training_data)
    new_predictions = new_model.predict(x_test_data)
    error_rates.append(np.mean(new_predictions != y_test_data))

Давайте визуализируем, как изменяется частота ошибок при различных K, используя matplotlib — plt.plot(error_rates):

Как видно из графика, мы достигаем минимальной частоты ошибок при значении K, равном приблизительно 35. Это означает, что 35 является подходящим выбором для K, который сочетает в себе простоту и точность предсказаний.

Вы можете найти весь код в ноутбуке на GitLab:
https://gitlab.com/PythonRu/notebooks/-/blob/master/sklearn_kmeans_and_knn.ipynb

Модели кластеризации методом K-средних

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

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

В этом разделе вы узнаете, как создать свой первый алгоритм кластеризации K-средних на Python.

Используемый датасет

В этом руководстве мы будем использовать набор данных, созданный с помощью scikit-learn.

Давайте импортируем функцию make_blobs из scikit-learn, чтобы сгенерировать необходимые данные. Откройте Jupyter Notebook и запустите свой скрипт Python со следующей инструкцией:

from sklearn.datasets import make_blobs

Теперь давайте воспользуемся функцией make_blobs, чтобы получить фиктивные данные!

В частности, вот как вы можете создать набор данных из 200 семплов, который имеет 2 показателя и 4 кластерных центров. Стандартное отклонение для каждого кластера будет равно 1.8.

raw_data = make_blobs(
    n_samples = 200, 
    n_features = 2, 
    centers = 4, 
    cluster_std = 1.8
)

Если вы выведите объект raw_data, то заметите, что на самом деле он представляет собой кортеж Python. Первым его элементом является массив NumPy с 200 наблюдениями. Каждое наблюдение содержит 2 признака (как мы и указали в нашей функции make_blobs).

Теперь, когда наши данные созданы, мы можем перейти к импорту других необходимых библиотек с открытым исходным кодом в наш скрипт Python.

Импортируемые библиотеки

В этом руководстве будет использоваться ряд популярных библиотек Python с открытым исходным кодом, включая pandas, NumPy и matplotlib. Продолжим написание скрипта, добавив следующие импорты:

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

%matplotlib inline

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

Теперь перейдем к созданию визуального представления нашего датасета.

Визуализация датасета

В функции make_blobs мы указали, что в нашем наборе данных должно быть 4 кластерных центра. Лучший способ убедиться, что все действительно так, — это создать несколько простых точечных диаграмм.

Для этого мы воспользуемся функцией plt.scatter, передав в нее все значения из первого столбца нашего набора данных в качестве X и соответствующие значения из второго столбца в качестве Y:

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

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

Чтобы исправить это, нужно сослаться на второй элемент кортежа raw_data, представляющий собой массив NumPy: он содержит индекс кластера, которому принадлежит каждое наблюдение.

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

plt.scatter(raw_data[0][:,0], raw_data[0][:,1], c=raw_data[1]);

Теперь мы видим, что в нашем наборе данных есть четыре уникальных кластера. Давайте перейдем к построению нашей модели на основе метода K-средних на Python!

Создание и обучение модели кластеризации K-средних

Для того, чтобы начать использовать метод K-средних, импортируем соответствующий класс из scikit-learn. Для этого добавьте в свой скрипт следующую команду:

from sklearn.cluster import KMeans

Затем давайте создадим экземпляр класса KMeans с параметром n_clusters=4 и присвоим его переменной model:

model = KMeans(n_clusters=4)

Теперь обучим нашу модель, вызвав на ней метод fit и передав первый элемент нашего кортежа raw_data:

model.fit(raw_data[0])

В следующем разделе мы рассмотрим, как делать прогнозы с помощью модели кластеризации K-средних.

Прежде чем двигаться дальше, я хотел бы указать на одно различие, которое вы, возможно заметили, между процессом построения модели, используя метод K-средних (он является алгоритмом кластеризации без учителя), и алгоритмами машинного обучения с учителем, с которыми мы работали ранее в данном курсе.

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

Применяем нашу модель кластеризации K-средних для получения предсказаний

Специалисты по машинному обучению обычно используют алгоритмы кластеризации, чтобы делать два типа прогнозов:

• К какому кластеру принадлежит каждая точка данных.
• Где находится центр каждого кластера.

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

Во-первых, давайте предскажем, к какому кластеру принадлежит каждая точка данных. Для этого обратимся к атрибуту labels_ из объекта model с помощью оператора точки:

model.labels_

Таким образом мы получаем массив NumPy с прогнозами для каждого семпла:

array([3, 2, 1, 1, 3, 2, 1, 0, 0, 0, 0, 0, 3, 2, 1, 2, 1, 3, 3, 3, 3, 1,
       1, 1, 2, 2, 3, 1, 3, 2, 1, 0, 1, 3, 1, 1, 3, 2, 0, 1, 3, 2, 3, 3,
       0, 3, 2, 2, 3, 0, 0, 0, 1, 1, 2, 1, 2, 0, 1, 2, 2, 1, 2, 3, 0, 3,
       0, 2, 0, 0, 1, 1, 0, 3, 2, 3, 2, 0, 1, 2, 0, 2, 0, 3, 3, 0, 3, 3,
       0, 3, 2, 3, 2, 1, 2, 1, 3, 3, 2, 2, 0, 2, 0, 2, 0, 2, 1, 0, 0, 2,
       3, 2, 1, 2, 3, 0, 1, 1, 1, 3, 2, 2, 3, 3, 2, 1, 3, 0, 0, 3, 0, 1,
       1, 3, 1, 0, 1, 1, 0, 3, 2, 0, 3, 0, 1, 2, 1, 2, 1, 2, 2, 3, 2, 1,
       0, 2, 3, 3, 2, 0, 1, 3, 3, 2, 0, 0, 0, 3, 1, 2, 0, 2, 3, 3, 2, 2,
       3, 1, 0, 1, 2, 3, 1, 3, 1, 1, 0, 2, 1, 0, 2, 1, 3, 1, 3, 3, 1, 3,
       0, 3])

Чтобы узнать, где находится центр каждого кластера, аналогичным способом обратитесь к атрибуту cluster_centers_:

model.cluster_centers_

Получаем двумерный массив NumPy, содержащий координаты центра каждого кластера. Он будет выглядеть так:

array([[ 5.2662658 , -8.20493969],
       [-9.39837945, -2.36452588],
       [ 8.78032251,  5.1722511 ],
       [ 2.40247618, -2.78480268]])

Визуализация точности предсказаний модели

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

f, (ax1, ax2) = plt.subplots(1, 2, sharey=True,figsize=(10,6))
ax1.set_title('Наши предсказания')
ax1.scatter(raw_data[0][:,0], raw_data[0][:,1],c=model.labels_)
ax2.set_title('Реальные значения')
ax2.scatter(raw_data[0][:,0], raw_data[0][:,1],c=raw_data[1]);

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

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

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

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

Вы можете найти весь код в ноутбуке на GitLab:
https://gitlab.com/PythonRu/notebooks/-/blob/master/sklearn_kmeans_and_knn.ipynb

Заключительные мысли

В этом руководстве вы научились создавать модели машинного обучения на Python, используя методы K-ближайших соседей и K-средних.

Вот краткое изложение того, что вы узнали о моделях K-ближайших соседей в Python:

• Как засекреченные данные являются распространенным инструментом для обучения студентов решению задач K-ближайших соседей.
• Почему важно стандартизировать набор данных при построении моделей K-ближайших соседей.
• Как разделить датасет на обучающую и тестирующую выборки с помощью функции train_test_split.
• Способ обучить вашу первую модель K-ближайших соседей и как получить сделанные ее прогнозы.
• Как оценить эффективность модели K-ближайших соседей.
• Метод локтя для выбора оптимального значения K в модели K-ближайших соседей.

А вот краткое изложение того, что вы узнали о моделях кластеризации K-средних в Python:

• Как сгенерировать фиктивные данные в scikit-learn с помощью функции make_blobs.
• Как создать и обучить модель кластеризации K-средних.
• То, что ML-методы без учителя не требуют, чтобы вы разделяли датасет на данные для обучения и данные для тестирования.
• Как создать и обучить модель кластеризации K-средних с помощью scikit-learn.
• Как визуализировать эффективность алгоритма K-средних, если вы изначально владеете информацией о кластерах.

В бой. Импортируем рабочие библиотеки и датасет:

from sklearn.datasets import load_boston
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
from sklearn.model_selection import learning_curve 
from sklearn.metrics import make_scorer 
%matplotlib inline

np.random.seed(42)

boston_data = load_boston() 
boston_df = pd.DataFrame(boston_data.data, columns=boston_data.feature_names) 
target = boston_data.target

Вот краткое описание нашего датасета:

• CRIM — уровень преступности на душу населения по городам.
• ZN — доля земли под жилую застройку, разделенная на участки площадью более 25 000 кв. футов.
• INDUS — доля акров, которые принадлежат предприятиям, не связанным с розничной торговлей, на город.
• CHAS — фиктивная переменная реки Чарльз (1, если участок соединен с рекой; 0 в противном случае).
• NOX — концентрация оксидов азота (в десятимиллионных долях).
• RM — среднее количество комнат в доме.
• AGE — доля занимаемых зданий, построенных до 1940 г.
• DIS — взвешенные расстояния до пяти бостонских центров занятости.
• RAD — индекс доступности радиальных автомобильных дорог.
• TAX — полная ставка налога на имущество за каждые 10000 долларов стоимости.
• PTRATIO — соотношение учеников и учителей по городам.
• B — 1000 (Bk — 0,63) , где Bk — доля граждан афроамериканского происхождения по городам.
• LSTAT — процент более низкого статуса населения.
• TARGET —медианное значение стоимости занимаемых домов в тысячах долларов США.

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

Полный ноутбук с кодом статьи: https://gitlab.com/PythonRu/notebooks/-/blob/master/linear_regression_sklearn.ipynb

Линейная регрессия

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

plt.scatter(boston_df['LSTAT'], target);

По оси X у нас есть LSTAT, а по оси Y — TARGET. Просто взглянув на это, можно увидеть отрицательную взаимосвязь: когда LSTAT растет, TARGET падает.

Функция оценки/стоимости

Как мы можем решить проблему предсказания TARGET на основе LSTAT? Хорошая отправная точка для размышлений: допустим, мы разрабатываем множество моделей для прогнозирования целевого показателя, как нам выбрать лучшую из них? Как только мы найдем подходящее для сравнения значение, наша задача — минимизировать/максимизировать его.

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

Поэтому для нашей задачи предлагаю использовать среднюю квадратическую ошибку (mean squared error) в качестве оценочной метрики. Для лучшего понимания смысла MSE, давайте определимся с терминологией:

Таким образом, MSE:

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

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

Наша модель

Теперь, когда у нас есть функция оценки, как найти способ ее минимизировать? В этом посте мы рассмотрим модель линейной регрессии. Она выглядит следующим образом:

Где j — количество имеющихся у нас предсказателей (независимых переменных), значения бета — это наши коэффициенты. А бета 0 является смещением (intercept). По сути, данная модель представляет собой линейную комбинацию наших предсказателей с intercept.

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

Градиентный спуск

Градиентный спуск — это метод, который мы позаимствовали из оптимизации. Очень простой, но мощный алгоритм, который можно использовать для поиска минимума функции.

1. Выберите случайное начальное значение.
2. Делайте шаги, пропорциональные отрицательному градиенту в текущей точке.
3. Повторяйте, пока не достигните предела.

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

Первый вопрос, на который нам нужно ответить: является ли наша функция оценки выпуклой? Давайте посмотрим:

mses = []
lstat_coef = range(-20, 23)

for coef in lstat_coef:
    pred_values = np.array([coef * lstat for lstat in boston_df.LSTAT.values])
    mses.append(np.sum((target - pred_values)**2))
    
plt.plot(lstat_coef, mses);

Для построения графика выше мы взяли диапазон значений коэффициентов для LSTAT, и для каждого из них рассчитали MSE на основе наших данных. Если мы затем отобразим полученные значения, мы получим приведенную выше кривую — выглядит довольно выпуклой! И оказывается, что наша функция MSE с нашей моделью линейной регрессии всегда будет выпуклой! Это означает: мы можем использовать градиентный спуск, чтобы найти оптимальные коэффициенты для нашей модели!

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

Градиенты

Если вы снова посмотрите на наш псевдокод для градиентного спуска, вы увидите, что на самом деле все, что нам нужно сделать, это вычислить градиенты. Итак, что такое градиенты? Это просто частные производные по коэффициентам. Для каждого имеющегося коэффициента нам нужно будет вычислить производную MSE по этому коэффициенту. Давайте начнем!

Для начала запишем выражение для MSE, подставив функцию оценки со смещением и единственной переменной LSTAT:

Теперь, взяв производную по бета 0, мы получим (умноженное на -1):

И для бета 1:

Теперь давайте запустим наш алгоритм градиентного спуска и убедимся, что MSE действительно уменьшается:

beta_0 = 0
beta_1 = 0
learning_rate = 0.001
lstat_values = boston_df.LSTAT.values
n = len(lstat_values)
all_mse = []

for _ in range(10000):
    predicted = beta_0 + beta_1 * lstat_values
    residuals = target - predicted
    all_mse.append(np.sum(residuals**2))
    beta_0 = beta_0 - learning_rate * ((2/n) * np.sum(residuals) * -1)
    beta_1 = beta_1 - learning_rate * ((2/n) * residuals.dot(lstat_values) * -1)
    
plt.plot(range(len(all_mse)), all_mse);

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

На графике видно, что мы вполне могли завершить работу раньше. MSE переходит в прямую (почти не изменяется) примерно после 4000 итераций.

print(f"Beta 0: {beta_0}")
print(f"Beta 1: {beta_1}")
plt.scatter(boston_df['LSTAT'], target)
x = range(0, 40)
plt.plot(x, [beta_0 + beta_1 * l for l in x]);

Итак, запуск градиентного спуска показал, что оптимальное смещение составляет 34.55, а оптимальный наклон равен -0,95. На приведенном выше графике эта линия показана поверх наших данных, она выглядит как аппроксимирующая прямая.

Скорость обучения

Один параметр, который нам еще предстоит обсудить, — это скорость обучения. Эта скорость — гиперпараметр, используемый для определения того, насколько большие шаги мы делаем от направления градиента. Как узнать, какое значение выбрать? Как правило, можно попробовать множество вариантов. Вот некоторые из них, которые были предложены Andrew Ng: .001, .003, .01, .03, .1, .3, 1, 3.

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

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

Когда прекратить итерацию?

В моем коде я просто выполняю наш цикл 10000 раз. Почему 10000? Никакой реальной причины, кроме моей уверенности в том, что этого достаточно, чтобы достичь минимума. Такой подход точно нельзя назвать лучшей практикой. Вот несколько более разумных идей:

1. Следите за оценкой после каждого цикла, и когда ее очередное изменение меньше некоторого граничного значения — скажем, 0.001 — останавливайтесь.
2. Используйте проверочный датасет (validation set) и отслеживайте число ошибок, например, с помощью MSE. Когда метрика перестанет уменьшаться, остановитесь.

Нормализация данных

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

Другие виды градиентного спуска

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

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

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

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

Допущения нашей модели

Всякий раз, когда вы имеете дело с моделью, хорошо знать, какие допущения она делает. Университет Дьюка написал об этом целую статью:

https://people.duke.edu/~rnau/testing.htm

Реализация линейной регрессии в Scikit-Learn

Теперь, когда мы немного разбираемся в теории и реализации, давайте обратимся к библиотеке scikit-learn, чтобы на самом деле использовать линейную регрессию на наших данных. Написание моделей с нуля довольно полезно для обучения, но на практике вам, как правило, гораздо лучше использовать проверенную и широко используемую библиотеку.

Для начала нужно нормализовать данные:

from sklearn.linear_model import SGDRegressor
from sklearn.metrics import mean_squared_error
from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
scaler.fit(boston_df) 
scaled_df = scaler.transform(boston_df)

У Scikit-learn довольно удобный API. Он предоставляет множество моделей, и все они имеют функции fit и predict. Вы можете вызвать fit с вашими X и y данными для обучения модели, а затем использовать predict для получения предсказанных значений на основе новых данных. Scikit-learn также предоставляет множество метрик, которые вы можете использовать для оценки, такие как MSE. Здесь я вычисляю среднеквадратическую ошибку (RMSE). Так мы можем использовать шкалу нашего целевого показателя, что, легче для понимания.

SGDRegressor выполняет линейную регрессию с использованием градиентного спуска и принимает следующие аргументы: tol(сообщает модели, когда следует прекратить итерацию) и eta0(начальная скорость обучения).

linear_regression_model = SGDRegressor(tol=.0001, eta0=.01) 
linear_regression_model.fit(scaled_df, target)
predictions = linear_regression_model.predict(scaled_df)
mse = mean_squared_error(target, predictions) 
print("RMSE: {}".format(np.sqrt(mse)))

RMSE в итоге составила 4.68… для нашей обучающей выборки с использованием scikit-learn.

Полиномиальные переменные

Рассматривая построенный выше график стоимости от LSTAT, вы могли заметить, что между данными показателями существует полиномиальная связь. Линейная регрессия хорошо подходит в случае линейной зависимости, но, если вы добавите полиномиальные показатели, такие как LSTAT, вы сможете установить более сложные отношения. SKLearn упрощает данный процесс:

from sklearn.preprocessing import PolynomialFeatures

poly = PolynomialFeatures(2, include_bias=False)
poly_df = poly.fit_transform(boston_df) 
scaled_poly_df = scaler.fit_transform(poly_df) 
print(f"shape: {scaled_poly_df.shape}")


linear_regression_model.fit(scaled_poly_df, target)
predictions = linear_regression_model.predict(scaled_poly_df) 
mse = mean_squared_error(target, predictions) 
print("RMSE: {}".format(np.sqrt(mse)))

shape: (506, 104)
RMSE: 3.243477309312183

Функция PolynomialFeatures сгенерировала новую матрицу показателей, состоящую из всех их полиномиальных комбинаций со степенью меньше или равной указанной (в нашем примере 2). Затем мы нормализовали эти данные и скормили их нашей модели. Так мы получили улучшенную тренировочную RMSE, равную 3.24. Однако обратите внимание, что эти результаты, представленные в иллюстративных целях, используют только тренировочную выборку.

Категориальные переменные

Линейная регрессия — одна из моделей, с которой нужно быть осторожным, когда у вас есть качественные данные. Если у вас переменные со значениями 1, 2 и 3, которые на самом деле означают «Мужской», «Женский», «Нет ответа», не передавайте их модели таким образом, даже если они являются числами.

Если бы вы это сделали, модель присвоила бы такому показателю коэффициент — возможно, 0.1. Это будет означать, что принадлежность к женскому полу увеличивает предсказанное значение на 0.1. А отсутствие ответа — на 0.2. Но, возможно, метка «Женский» должна повысить результат на 1.2, а «Нет ответа» — всего на 0.001. Чтобы решить данную проблему, вы должны преобразовать такие значения в фиктивные переменные, чтобы каждая категория имела свой собственный вес. Вы можете узнать, как это сделать с помощью scikit-learn, здесь.

Интерпретация вашей модели

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

Во-первых, давайте посмотрим на коэффициенты, которым научилась наша модель (по всем показателям):

linear_regression_model.fit(scaled_df, target) 
sorted(list(zip(boston_df.columns, linear_regression_model.coef_)), 
       key=lambda x: abs(x[1]))

[('AGE', -0.09572161737815363),
 ('INDUS', -0.21745291834072922),
 ('CHAS', 0.7410105153873195),
 ('B', 0.8435653632801421),
 ('CRIM', -0.850480180062872),
 ('ZN', 0.9500420835249525),
 ('TAX', -1.1871976153182786),
 ('RAD', 1.7832553590229068),
 ('NOX', -1.8352515775847786),
 ('PTRATIO', -2.0059298125382456),
 ('RM', 2.8526547965775757),
 ('DIS', -2.9865347158079887),
 ('LSTAT', -3.724642983604627)]

Что они означают? Каждый коэффициент представляет собой среднее изменение цены на жилье при изменении соответствующего показателя на единицу с условием, что все остальные показатели остаются неизменными. Например, если значения других показателей не затрагиваются, то увеличение LSTAT на единицу снижает наш целевой показатель (цену на жилье) на 3.72, а увеличение RM увеличивает его на 2.85.

Таким образом, если вы хотите повысить стоимость дома, то может быть стоит начать с увеличения RM и уменьшения LSTAT. Я говорю «может быть», потому что линейная регрессия рассматривает корреляции. Судя по нашим данным, такая взаимосвязь имеет место быть, что само по себе не означает обязательное наличие причинно-следственной связи между показателями.

Доверительные интервалы

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

Bootstrap — это случайная выборка на основе наших данных, и эта выборка того же размера, что и исходные данные. Так мы можем создать несколько представлений одних и тех же данных. Давайте создадим 1000 bootstrap-семплов наших данных.

from sklearn.utils import resample

n_bootstraps = 1000 
bootstrap_X = [] 
bootstrap_y = [] 

for _ in range(n_bootstraps): 
    sample_X, sample_y = resample(scaled_df, target)
    bootstrap_X.append(sample_X) 
    bootstrap_y.append(sample_y)

Затем мы обучим модель на каждом из полученных датасетов и получим следующие коэффициенты:

linear_regression_model = SGDRegressor(tol=.0001, eta0=.01)
coeffs = [] 

for i, data in enumerate(bootstrap_X):
    linear_regression_model.fit(data, bootstrap_y[i])
    coeffs.append(linear_regression_model.coef_)
    
coef_df = pd.DataFrame(coeffs, columns=boston_df.columns) 
coef_df.plot(kind='box') 
plt.xticks(rotation=90);

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

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

Мы даже можем немного углубиться в полученные коэффициенты для LSTAT:

print(coef_df['LSTAT'].describe())
coef_df['LSTAT'].plot(kind='hist');

count    1000.000000
mean       -3.686064
std         0.713812
min        -6.032298
25%        -4.166195
50%        -3.671628
75%        -3.202391
max        -1.574986
Name: LSTAT, dtype: float64

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

Разделение на обучающий/тестовый датасеты и кросс-валидация

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

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

Другая сторона проблемы называется bias. Модель имеет высокий bias, когда она плохо обучена. В этом случае MSE будет высокой как для тренировочных данных, так и для данных, не показанных во время обучения.

В ML всегда существует компромисс между смещением (bias) и дисперсией (overfitting). По мере того, как ваши модели становятся более сложными, возрастает риск переобучения на тренировочных данных.

Теперь, когда мы знаем о проблемах с вычислением MSE, используя только обучающее множество, что мы можем сделать, чтобы лучше судить о способности модели к обобщению? А также диагностировать overfitting и bias? Типичным решением является разделение наших данных на две части: обучающий и тестовый датасеты.

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(scaled_df, 
                                                    target, 
                                                    test_size=0.33, 
                                                    random_state=42)

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

linear_regression_model = SGDRegressor(tol=.0001, eta0=.01) 
linear_regression_model.fit(X_train, y_train)

train_predictions = linear_regression_model.predict(X_train) 
test_predictions = linear_regression_model.predict(X_test)

train_mse = mean_squared_error(y_train, train_predictions)
test_mse = mean_squared_error(y_test, test_predictions)
print("Train MSE: {}".format(train_mse))
print("Test MSE: {}".format(test_mse))

Train MSE: 23.068773005090424
Test MSE: 21.243935754712375

Отлично! Теперь у нас есть MSE как для тренировочных данных, так и для данных тестирования. И оба значения довольно близки, что говорит об отсутствии проблемы с переобучением. Но достаточно ли они низкие? Большие значения предполагают наличие высокого bias.

Один из способов разобраться в этом — построить график обучения. Кривая обучения отображает нашу функцию ошибок (MSE) с различными объемами данных, используемых для тренировки. Вот наш график:

# Источник: http://scikit-learn.org/0.15/auto_examples/plot_learning_curve.html
def plot_learning_curve(estimator, title, X, y, ylim=None, cv=None,
                        n_jobs=1, train_sizes=np.linspace(.1, 1.0, 5)):
 
    plt.figure()
    plt.title(title)
    if ylim is not None:
        plt.ylim(*ylim)
    plt.xlabel("Train примеры")
    plt.ylabel("Оценка")
    train_sizes, train_scores, test_scores = learning_curve(
        estimator, X, y, cv=cv, n_jobs=n_jobs, train_sizes=train_sizes, scoring=make_scorer(mean_squared_error))
    train_scores_mean = np.mean(train_scores, axis=1)
    train_scores_std = np.std(train_scores, axis=1)
    test_scores_mean = np.mean(test_scores, axis=1)
    test_scores_std = np.std(test_scores, axis=1)
    plt.grid()

    plt.fill_between(train_sizes, train_scores_mean - train_scores_std,
                     train_scores_mean + train_scores_std, alpha=0.1,
                     color="r")
    plt.fill_between(train_sizes, test_scores_mean - test_scores_std,
                     test_scores_mean + test_scores_std, alpha=0.1, color="g")
    plt.plot(train_sizes, train_scores_mean, 'o-', color="r",
             label="Train score")
    plt.plot(train_sizes, test_scores_mean, 'o-', color="g",
             label="C-V score")

    plt.legend(loc="best")
    return plt

plot_learning_curve(linear_regression_model, 
                    "Кривая обучения", 
                    X_train, 
                    y_train, 
                    cv=5);

Вы можете видеть, что с менее чем 50 обучающими примерами тренировочная MSE неплохая, а кросс-валидация оставляет желать лучшего — довольно плохая (мы еще не говорили о кросс-валидации, так что пока думайте об этом как о тестировании). Если бы у нас было только такое количество данных, это выглядело бы как явная проблема высокой дисперсии (переобучения).

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

Этот график больше похож на проблему с большим смещением (bias), поскольку две наши кривые очень близки и сглаживаются. Однако трудно сказать наверняка, потому что, возможно, мы только что достигли наилучшего возможного MSE. В таком случае это не будет проблемой высокого смещения. Такой результат был бы ей только в том случае, если бы наши кривые выровнялись при значении MSE выше оптимального. В реальной жизни вы не знаете, какова оптимальная MSE, поэтому вам нужно немного поразмышлять, считаете ли вы, что уменьшение bias улучшит ваш результат — но лучше просто попробуйте!

Устранение проблем высоких bias/variance

Итак, теперь, когда вы диагностировали проблему смещения или дисперсии, как ее исправить?

Для высокой дисперсии:

• Получите больше данных для обучения
• Попробуйте меньший набор показателей
• Используйте менее сложную модель
• Добавьте регуляризацию

Для высокого смещения:

• Попробуйте увеличить число показателей
• Перейдите на более сложную модель

Кросс-валидация и настройка гиперпараметров

Ранее мы упоминали этот термин: кросс-валидация. Давайте поговорим об этом сейчас. На данный момент мы узнали, что неплохо разделить данные на наборы для обучения и тестирования, чтобы лучше понять, насколько хорошо работает модель. Это замечательно, но представьте, что мы хотим протестировать несколько разных моделей или протестировать разные параметры нашей модели — например, другую скорость обучения или толерантность. Как бы нам решить, какая модель или какой параметр лучше? Будем ли мы обучать все на тренировочных данных и тестировать все на наших тестовых данных?

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

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

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

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

Это означает, что мы выбираем значение k, скажем 3. Затем мы берем наши обучающие данные и делим их на 3 части. Мы случайным образом выбираем 2 блока для тренировки, а затем используем оставшийся для тестирования. Повторяем этот процесс еще 2 раза, так чтобы все наблюдения были использованы как для обучения, так и для проверки, и каждое из них применялось для валидации только один раз. После этого усредняем все три оценки (в нашем случае MSE), чтобы получить общую оценку для конкретной модели. Затем мы можем повторить этот процесс для других моделей, чтобы найти лучшую.

Вот видео, которое более наглядно описывает этот подход (с русскими субтитрами): https://www.youtube.com/watch?v=TIgfjmp-4BA

Этот процесс довольно просто реализуется с помощью sklearn:

from sklearn.model_selection import RandomizedSearchCV

param_dist = {"eta0": [ .001, .003, .01, .03, .1, .3, 1, 3]} 
linear_regression_model = SGDRegressor(tol=.0001) 
n_iter_search = 8 
random_search = RandomizedSearchCV(linear_regression_model, 
                                   param_distributions=param_dist, 
                                   n_iter=n_iter_search, 
                                   cv=3, 
                                   scoring='neg_mean_squared_error') 
random_search.fit(X_train, y_train) 

print("Лучшие параметры: {}".format(random_search.best_params_)) 
print("Лучшая оценка MSE: {}".format(random_search.best_score_))

Лучшие параметры: {'eta0': 0.001}
Лучшая оценка MSE: -25.64219216972172

Здесь мы фактически использовали рандомизированный поиск (RandomizedSearchCV), который обычно лучше, чем поиск по всем возможным значениям. Часто вы хотите попробовать много разных параметров для множества различных регуляторов, и сеточный поиск (перебор всех возможных комбинаций) вам не подходит.

Обычно вы хотите использовать рандомизированный поиск (случайный выбор комбинаций), как мы сделали выше. Хотя, поскольку у нас было только небольшое количество значений, мы заставили его работать как сеточный поиск, установив n_iter_search равным числу вариантов, которые мы хотели попробовать.

Мы также установили cv=3, чтобы иметь 3 блока и использовали отрицательную MSE, потому что функции CV в scikit-learn пытаются максимизировать значение.

Вы можете узнать больше о случайном и «сеточном» вариантах поиска здесь: https://scikit-learn.org/stable/modules/grid_search.html.

Кроме того, в scikit-learn есть много других CV функций, которые полезны, особенно если вы хотите протестировать разные модели с одинаковыми блоками. Вот некоторая документация: https://scikit-learn.org/stable/modules/cross_validation.html.

Регуляризация

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

Идея состоит в том, что если мы переоцениваем влияние предсказателя (большое значение коэффициента), то, вероятно, мы переобучаемся. Примечание: у нас все еще могут быть просто большие коэффициенты. Регуляризация говорит о том, что уменьшение MSE должно оправдывать увеличение значений коэффициентов.

• Регуляризация L1 (Lasso): вы добавляете сумму абсолютных значений коэффициентов к функции оценки. Этот метод может принудительно обнулить коэффициенты, что затем может быть средством выбора показателей.
• Регуляризация L2 (Ridge): вы добавляете сумму квадратов значений коэффициентов к функции оценки.
• Эластичная сетка: вы добавляете обе и выбираете, как их утяжелить.

Каждый из этих методов принимает весовой множитель, который говорит вам, насколько сильное влияние регуляризация будет иметь на функцию оценки. В scikit-learn такой параметр называется альфа. Альфа равный 0 не добавит штрафа, в то время как высокое его значение будет сильно наказывать модель за наличие больших коэффициентов. Вы можете использовать кросс-валидацию, чтобы найти хорошее значение для альфа.
Sklearn упрощает это:

from sklearn.linear_model import ElasticNetCV

clf = ElasticNetCV(l1_ratio=[.1, .5, .7, .9, .95, .99, 1], alphas=[.1, 1, 10]) 
clf.fit(X_train, y_train) 

train_predictions = clf.predict(X_train) 
test_predictions = clf.predict(X_test) 
print("Train MSE: {}".format(mean_squared_error(y_train, train_predictions)))
print("Test MSE: {}".format(mean_squared_error(y_test, test_predictions)))

Train MSE: 23.58766002758097
Test MSE: 21.54591803491954

Здесь мы использовали функцию ElasticNetCV, которая имеет встроенную кросс-валидацию, чтобы выбрать лучшее значение для альфы. l1_ratio — это вес, который придается регуляризации L1. Оставшийся вес применяется к L2.

Итог

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

Кроме того, здесь вы можете найти весь код статьи.

Django REST Framework — это набор инструментов для создания REST API с помощью Django. В этом руководстве рассмотрим, как правильно его использовать. Создадим эндпоинты(точки доступа к ресурсам) для пользователей, постов в блоге, комментариев и категорий.

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

Вот чему вы научитесь:

• Добавлять новые и существующие модели Django в API.
• Сериализовать модели с помощью встроенных сериализаторов для распространенных API-паттернов.
• Создавать представления и URL-паттерны.
• Создавать отношения многие-к-одному и многие-ко-многим.
• Аутентифицировать пользовательские действия.
• Использовать созданный API Django REST Framework.

Код урока можно скачать в репозитории https://gitlab.com/PythonRu/blogapi.

Требования

У вас в системе должен быть установлен Python 3, желательно 3.8. Также понадобится опыт работы с REST API. Вы должны быть знакомы с реляционными базами данными, включая основные и внешние ключи, модели баз данных, миграции, а также отношения многие-к-одному и многие-ко-многим.

Наконец, потребуется опыт работы с Python и Django.

Настройка проекта

Для создания нового API-проекта для начала создайте виртуальную среду Python в своей рабочей директории. Для этого запустите следующую команду в терминале:

python3 -m venv env
source env/bin/activate

В Windows это будет source env\Scripts\activate.

Не забывайте запускать все команды из этого руководства в виртуальной среде. Убедиться в том, что она активирована можно благодаря надписи (env) в начале строки приглашения к вводу в терминале.

Чтобы деактивировать среду, введите deactivate.

После этого установите Django и REST Framework в среду:

pip install django==3.1.7 djangorestframework==3.12.4

Создайте новый проект «blog» и новое приложение «api»:

django-admin startproject blog
cd blog
django-admin startapp api

Из корневой директории «blog» (там где находится файл «manage.py»), синхронизируйте базу данных. Это запустит миграции для admin, auth, contenttypes и sessions.

python manage.py migrate

Вам также понадобится пользователь admin для взаимодействия с панелью управления Django и API. Из терминала запустите следующее:

python manage.py createsuperuser --email admin@example.com --username admin

Установите любой пароль (у него должно быть как минимум 8 символов). Если вы введете слишком простой пароль, то можете получить ошибку.

Для настройки, добавьте rest_framework и api в файл конфигурации (blog/blog/settings.py):

INSTALLED_APPS = [
    ...
    'rest_framework',
    'api.apps.ApiConfig',
]

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

Наконец, запустите локальный сервер с помощью команды python manage.py runserver.

Перейдите по ссылке http://127.0.0.1:8000/admin и войдите в админ-панель сайта. Нажмите на «Users», чтобы увидеть пользователя и добавить новых при необходимости.

Создание API для пользователей

Теперь с пользователем «admin» можно переходить к созданию самого API. Это предоставит доступ только для чтения списку пользователей из списка API-эндпоинтов.

Сериализатор для User

REST Framework Django использует сериализаторы, чтобы переводить наборы запросов и экземпляры моделей в JSON-данные. Сериализация также определяет, какие данные вернет API в ответ на запрос клиента.

Пользователи Django создаются из модели User, которая определена в django.contrib.auth. Для создания сериализатора для модели добавьте следующее в blog/api/serializers.py (файл нужно создать):

from rest_framework import serializers
from django.contrib.auth.models import User


class UserSerializer(serializers.ModelSerializer):
    class Meta:
        model = User
        fields = ['id', 'username']

По примеру импортируйте модель User из Django вместе с набором сериализаторов из REST Framework Django.

Теперь создайте класс UserSerializer, который должен наследоваться от класса ModelSerializer.

Определите модель, которая должна ассоциироваться с сериализатором (model = User). Массив fields определяет, какие поля модели должны быть включены. Например, можно добавлять поля first_name и last_name.

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

Этот сериализатор также создает простые методы create() и update(). При необходимости их можно переписать.

Ознакомиться подробнее с работой ModelSerializer можно на официальном сайте.

Представления для User

Есть несколько способов создавать представления в REST Framework Django. Чтобы получить возможность повторного использования кода и избегать повторений, используйте классовые представления.

REST Framework предоставляет несколько обобщенных представлений, основанных на классе APIView. Они представляют собой самые распространенные паттерны.

Например, ListAPIView используется для эндпоинтов с доступом только для чтения. Он предоставляет метод-обработчик get. ListCreateAPIView используется для эндпоинтов с разрешением чтения-записи, а также обработчики get и post.

Для создания эндпоинта только для чтения, который возвращал бы список пользователей, добавьте следующее в blog/api/views.py:

from rest_framework import generics
from . import serializers
from django.contrib.auth.models import User


class UserList(generics.ListAPIView):
    queryset = User.objects.all()
    serializer_class = serializers.UserSerializer


class UserDetail(generics.RetrieveAPIView):
    queryset = User.objects.all()
    serializer_class = serializers.UserSerializer

В первую очередь здесь импортируется generics коллекция представлений, а также модель User и UserSerialized из предыдущего шага. Представление UserList предоставляет доступ только для чтения (через get) к списку пользователей, а UserDetails — к одному пользователю.

Названия представлений должны быть в следующем формате: {ModelName}List и {ModelName}Details для коллекции объектов и одного объекта соответственно.

Для каждого представления переменная queryset содержит коллекцию экземпляров модели, которую возвращает User.objects.all(). Значением serializer_class должно быть UserSerializer, который и сериализует данные модели User.

Пути к эндпоинтам будут настроены на следующем шаге.

URL-паттерны

С моделью, сериализатором и набором представлений для User финальным шагом будет создание эндпоинтов (которые в Django называются URL-паттернами) для каждого представления.

В первую очередь добавьте следующее в blog/api/urls.py (этот файл тоже нужно создать):

from django.urls import path
from rest_framework.urlpatterns import format_suffix_patterns
from . import views

urlpatterns = [
    path('users/', views.UserList.as_view()),
    path('users/<int:pk>/', views.UserDetail.as_view()),
]

urlpatterns = format_suffix_patterns(urlpatterns)

Здесь импортируется функция path и также коллекция представлений приложения api.

Функция path создает элемент, который Django использует для показа страницы приложения. Для этого Django в первую очередь ищет нужный элемент с соответствующим URL (например, users/) для запрошенного пользователем. После этого он импортирует и вызывает соответствующее представление (то есть, UserList)

Последовательность <int:pk> указывает на целочисленное значение, которое является основным ключом (pk). Django захватывает эту часть URL и отправляет в представление в виде аргумента-ключевого слова.

В этом случае основным ключом для User является поле id, поэтому http://127.0.0.1:8000/users/1 вернет id со значением 1.

Прежде чем можно будет взаимодействовать с этими URL-паттернами (и теми, которые будут созданы позже) их нужно добавить в проект. Добавьте следующее в blog/blog/urls.py:

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('api.urls')),
]

Чтобы убедиться, что все элементы работают корректно, перейдите по ссылке http://127.0.0.1:8000/users, чтобы увидеть список пользователей приложения.

В этом руководстве используется графическое представление API из Django REST Framework для демонстрации эндпоинтов. Интерфейс предоставляет элементы аутентификации и формы, имитирующие фронтенд-клиент. Для тестирования API также можно использовать cURL или httpie.

Обратите внимание на то, что значение пользователя admin равно 1. Можете перейти к нему, открыв для этого http://127.0.0.1:8000/users/1.

В итоге класс модели Django сериализуется с помощью UserSerializaer. Он предоставляет данные представлениям UserList и UserDetail, доступ к которым можно получить с помощью паттернов users/ и users/<int:pk>.

Создание API для Post

После базовой настройки можно приступать к созданию полноценного API для блога с эндпоинтами для постов, комментариев и категорий. Начнем с API для Post.

Модель Post

В blog/api/models.py создайте модель Post, которая наследуется от класса Model из Django и определите ее поля:

from django.db import models


class Post(models.Model):
    created = models.DateTimeField(auto_now_add=True)
    title = models.CharField(max_length=100, blank=True, default='')
    body = models.TextField(blank=True, default='')
    owner = models.ForeignKey('auth.User', related_name='posts', on_delete=models.CASCADE)

    class Meta:
        ordering = ['created']

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

Обратите внимание на то, что тип ForeignKey создает отношение многие-к-одному между текущей моделью и моделью, указанной в первом аргументе (auth.User — то есть, модель User, с которой вы работаете).

В этом случае пользователь может иметь много статей, но у поста может быть всего один владелец. Поле owner может быть использовано во фронтенд-приложении для получения пользователя и отображения его имени в качестве автора поста.

Аргумент related_name позволяет задать другое имя доступа к текущей модели (posts) вместо стандартного (post_set). Список постов будет добавлен в сериализатор User на следующем шаге для завершения отношения многие-к-одному.

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

python manage.py makemigrations api
python manage.py migrate

Поскольку мы работаем с моделями Django, таким как User, посты можно изменить из административной панели Django, зарегистрировав ее в blog/api/admin.py:

from django.contrib import admin
from .models import Post


admin.site.register(Post)

Позже их можно будет создавать и через графическое представление API.

Перейдите на http://127.0.0.1:8000/admin, кликните на Posts и добавьте новые посты. Вы заметите, что поля title и body в форме соответствуют типам CharField и TextField из модели Post.

Также можно выбрать owner среди существующих пользователей. При создании поста в API пользователя выбирать не нужно. Owner будет задан автоматически на основе данных залогиненного пользователя. Это настроим в следующем шаге.

Сериализатор Post

Чтобы добавить модель Post в API, нужно повторить шаги добавления модели User.

Сначала нужно сериализовать данные модели Post. В blog/api/serializers.py добавьте следующее:

from rest_framework import serializers
from django.contrib.auth.models import User
from .models import Post


class PostSerializer(serializers.ModelSerializer):
    owner = serializers.ReadOnlyField(source='owner.username')

    class Meta:
        model = Post
        fields = ['id', 'title', 'body', 'owner']


class UserSerializer(serializers.ModelSerializer):
    posts = serializers.PrimaryKeyRelatedField(many=True, read_only=True)

    class Meta:
        model = User
        fields = ['id', 'username', 'posts']

Импортируйте модель Post из приложения api и создайте PostSerializer, который будет наследоваться от класса ModelSerializer. Задайте модель и поля, которые будут использоваться сериализатором.

ReadOnlyField — это класс, возвращающий данные без изменения. В этом случае он используется для возвращения поля username вместо стандартного id.

Дальше добавьте поле posts в UserSerializer. Отношение многие-к-одному между постами и пользователями определено моделью Post в прошлом шаге. Название поля (posts) должно быть равным аргументу related_field поля Post.owner. Замените posts на post_set (значение по умолчанию), если вы не задали значение related_field в прошлом шаге.

PrimaryKeyRelatedField представляет список публикаций в этом отношении многие-к-одному (many=True указывает на то, что постов может быть больше чем один).

Если не задать read_only=True поле posts будет иметь права записи по умолчанию. Это значит, что будет возможность вручную задавать список статей, принадлежащих пользователю при его создании. Вряд ли это желаемое поведение.

Перейдите по ссылке http://127.0.0.1:8000/users, чтобы увидеть поле posts каждого пользователя.

Обратите внимание на то, что список posts — это, по сути, список id. Вместо этого можно возвращать список URL с помощью HyperLinkModelSerializer.

Представления Post

Следующий шаг — создать набор представлений для Post API. Добавьте следующее в blog/api/views.py:

...
from .models import Post

...

class PostList(generics.ListCreateAPIView):
    queryset = Post.objects.all()
    serializer_class = serializers.PostSerializer

    def perform_create(self, serializer):
        serializer.save(owner=self.request.user)


class PostDetail(generics.RetrieveUpdateDestroyAPIView):
    queryset = Post.objects.all()
    serializer_class = serializers.PostSerializer

ListCreateAPIView и RetrieveUpdateDestroyAPIView предоставляют самые распространенные обработчики API-методов: get и post для списка (ListCreateAPIView) и get, update и delete для одной сущности (RetrieveUpdateDestroyAPIView).

Также нужно перезаписать функцию по умолчанию perform_create, чтобы задать поле owner текущего пользователя (значение self.request.user).

URL-паттерны Post

Чтобы закончить с эндпоинтами для Post API создайте URL-паттерны Post. Добавьте следующее в массив urlpatterns в blog/api/urls.py:

urlpatterns = [
    ...
    path('posts/', views.PostList.as_view()),
    path('posts/<int:pk>/', views.PostDetail.as_view()),
]

Объединение представлений с этими URL-паттернами создает эндпоинты:

• get posts/,
• post posts/,
• get posts/<int:pk>/,
• put posts/<int:pk>/
• и delete posts/<int:pk>/.

Чтобы протестировать их, перейдите на http://127.0.0.1:8000/posts и создайте публикации. Я взял несколько статей из Медиума.

Перейдите на один пост (например, http://127.0.0.1:8000/posts/1 и нажмите DELETE. Чтобы поменять название поста, обновите поле «title» и нажмите PUT.

После этого перейдите на http://127.0.0.1:8000/posts, чтобы увидеть список существующих публикаций или создать новый. Убедитесь, что вы залогинены, потому что при создании поста его автор создается на основе данных текущего пользователя.

Настройка разрешений

Для удобства добавим кнопку «Log in» в графическое представление API с помощью следующего кода в blog/urls.py:

urlpatterns = [
    ...
    path('api-auth/', include('rest_framework.urls')),
]

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

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

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

Начните с этого кода в blog/api/permisisions.api (файл необходимо создать):

from rest_framework import permissions


class IsOwnerOrReadOnly(permissions.BasePermission):
    def has_object_permission(self, request, view, obj):
        if request.method in permissions.SAFE_METHODS:
            return True

        return obj.owner == request.user

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

Также есть встроенное разрешение IsAuthenticatedOrReadOnly. С ним любом аутентифицированный пользователь может выполнять любой запрос, а остальные — только на чтение.

Добавьте эти разрешения в представления Post:

from rest_framework import generics, permissions
...
from .serializers import PostSerializer
from .permissions import IsOwnerOrReadOnly

...

class PostList(generics.ListCreateAPIView):
    queryset = Post.objects.all()
    serializer_class = PostSerializer
    permission_classes = [permissions.IsAuthenticatedOrReadOnly]

    def perform_create(self, serializer):
        serializer.save(owner=self.request.user)


class PostDetail(generics.RetrieveUpdateDestroyAPIView):
    queryset = Post.objects.all()
    serializer_class = PostSerializer
    permission_classes = [permissions.IsAuthenticatedOrReadOnly,
                          IsOwnerOrReadOnly]

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

Для PostDetails нужны оба разрешения, поскольку обновлять или удалять пост должен только залогиненный пользователь, а также его владелец. Для получения поста прав не нужно. Вернитесь на http://127.0.0.1:8000/posts. Зайдите в учетную запись admin и другие, чтобы проверить, какие действия доступны аутентифицированным и анонимным пользователям.

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

Создание API для Comments

Теперь у вас есть базовый API для постов. Можно добавить в систему комментарии.

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

Модель Comment

Сначала создайте модель в blog/api/models.py:

...

class Comment(models.Model):
    created = models.DateTimeField(auto_now_add=True)
    body = models.TextField(blank=False)
    owner = models.ForeignKey('auth.User', related_name='comments', on_delete=models.CASCADE)
    post = models.ForeignKey('Post', related_name='comments', on_delete=models.CASCADE)

    class Meta:
        ordering = ['created']

Модель Comment похожа на Post и имеет отношение многие-к-одному с пользователями через поле owner. У комментария есть отношение многие-к-одному с одним постом через поле post.

Запустите миграции базы данных:

python manage.py makemigrations api
python manage.py migrate

Сериализатор Comment

Для создания API комментариев нужно добавить модель Comment в PostSerializer и UserSerializer, чтобы убедиться, что связанные комментарии отправляются вместе с данными о пользователе и посте.

Обновите код в blog/api/serializers.py:

...

from .models import Post, Comment


class PostSerializer(serializers.ModelSerializer):
    owner = serializers.ReadOnlyField(source='owner.username')
    comments = serializers.PrimaryKeyRelatedField(many=True, read_only=True)

    class Meta:
        model = Post
        fields = ['id', 'title', 'body', 'owner', 'comments']


class UserSerializer(serializers.ModelSerializer):
    posts = serializers.PrimaryKeyRelatedField(many=True, read_only=True)
    comments = serializers.PrimaryKeyRelatedField(many=True, read_only=True)

    class Meta:
        model = User
        fields = ['id', 'username', 'posts', 'comments']

Процесс напоминает добавление posts в UserSerializer. Это настраивает часть «многие» отношения многие-к-одному между комментариями и пользователем, а также между комментариями и постом. Список комментариев должен быть доступен только для чтения (read_only=True)

Теперь добавим CommentSerializer в тот же файл:

...

class CommentSerializer(serializers.ModelSerializer):
    owner = serializers.ReadOnlyField(source='owner.username')

    class Meta:
        model = Comment
        fields = ['id', 'body', 'owner', 'post']

Обратите внимание на то, что поле post не меняется. После добавления поля post в массив fields он будет сериализоваться по умолчанию (согласно ModelSerializer). Это эквивалентно post=serializers.PrimaryKeyRelatedField(queryset=Post.objects.all()).

Это значит, что у поля post есть право на запись по умолчанию: при создании комментария настраивается, какому посту он принадлежит.

Представления комментариев

Наконец, создадим представления и паттерны для комментариев. Процесс похож на тот, что был при настройке API Post.

Добавьте этот код в blog/api/views.py:

...
from .models import Post, Comment

...

class CommentList(generics.ListCreateAPIView):
    queryset = Comment.objects.all()
    serializer_class = serializers.CommentSerializer
    permission_classes = [permissions.IsAuthenticatedOrReadOnly]

    def perform_create(self, serializer):
        serializer.save(owner=self.request.user)

class CommentDetail(generics.RetrieveUpdateDestroyAPIView):
    queryset = Comment.objects.all()
    serializer_class = serializers.CommentSerializer
    permission_classes = [permissions.IsAuthenticatedOrReadOnly,
                          IsOwnerOrReadOnly]

Представления похожи на PostList и PostDetails.

URL-Паттерны комментариев

Чтобы закончить API комментариев, определите URL-паттерны в blog/api/urls.py:

urlpatterns = [
    ...
    path('comments/', views.CommentList.as_view()),
    path('comments/<int:pk>/', views.CommentDetail.as_view()),
]

Теперь по ссылке http://127.0.0.1:8000/comments можете увидеть список существующих комментариев и создавать новые.

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

Создание API для Category

Финальный элемент блога — система категорий.

Пост может принадлежать к одной или нескольким категориям. Также одна категория может принадлежать нескольким постам, значит это отношение многие-ко-многим.

Модель категории

Создайте модель Category в blog/api/models.py:

urlpatterns = [
    ...
    path('comments/', views.CommentList.as_view()),
    path('comments/<int:pk>/', views.CommentDetail.as_view()),
]

Здесь класс ManyToManyField создает отношение многие-ко-многим между текущей моделью и моделью из первого аргумента. Как и в случае с классом ForeignKey отношение завершает сериализатор.

Обратите внимание на то, что verbose_name_plural определяет, как правильно писать название модели во множественном числе. Это нужно, например, для административной панели. Так, вы можете указать, что во множественном числе правильно писать categories, а не categorys.

Запустите миграции базы данных:

python manage.py makemigrations api
python manage.py migrate

Сериализатор Category

Процесс создания похож на описанный в прошлых шагах. Сперва создайте сериализатор для Category, добавив код в blog/api/serializers.py:

...
from .models import Post, Comment, Category

...

class CategorySerializer(serializers.ModelSerializer):
    owner = serializers.ReadOnlyField(source='owner.username')
    posts = serializers.PrimaryKeyRelatedField(many=True, read_only=True)

    class Meta:
        model = Category
        fields = ['id', 'name', 'owner', 'posts']

class PostSerializer(serializers.ModelSerializer):
    owner = serializers.ReadOnlyField(source='owner.username')
    comments = serializers.PrimaryKeyRelatedField(many=True, read_only=True)

    class Meta:
        model = Post
        fields = ['id', 'title', 'body', 'owner', 'comments', 'categories']

class UserSerializer(serializers.ModelSerializer):
    posts = serializers.PrimaryKeyRelatedField(many=True, read_only=True)
    comments = serializers.PrimaryKeyRelatedField(many=True, read_only=True)
    categories = serializers.PrimaryKeyRelatedField(many=True, read_only=True)

    class Meta:
        model = User
        fields = ['id', 'username', 'posts', 'comments', 'categories']

Не забудьте добавить имя поля categories в список полей PostSerializer и UserSerializer. Обратите внимание на то, что UserSerializer.categories можно отметить как read_only=True. Это поле представляет список всех созданных категорий.

С другой стороны, поле PostSerializer.categories будет иметь право на запись по умолчанию. То же самое, что указать categories = serializers.PrimaryKeyRelatedField(many=True, queryset=Category.objects.all()). Это позволит пользователю выбирать одну или нескольких категорий для поста.

Представления для категории

Дальше создайте представления в blog/api/views.api:

...
from .models import Post, Comment, Category

...

class CategoryList(generics.ListCreateAPIView):
    queryset = Category.objects.all()
    serializer_class = serializers.CategorySerializer
    permission_classes = [permissions.IsAuthenticatedOrReadOnly]

    def perform_create(self, serializer):
        serializer.save(owner=self.request.user)

class CategoryDetail(generics.RetrieveUpdateDestroyAPIView):
    queryset = Category.objects.all()
    serializer_class = serializers.PostSerializer
    permission_classes = [permissions.IsAuthenticatedOrReadOnly,
                          IsOwnerOrReadOnly]

По аналогии с прошлыми.

URL-паттерны категорий

Наконец, добавьте этот код в blog/api/urls.py:

...
from .models import Post, Comment, Category

urlpatterns = [
    ...
    path('categories/', views.CategoryList.as_view()),
    path('categories/<int:pk>/', views.CategoryDetail.as_view()),
]

Теперь отправляйтесь на http://127.0.0.1:8000/categories и создайте пару категорий. А на http://127.0.0.1:8000/posts создайте пост и выберите для него категории.

Выводы

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

Чтобы расширить возможности своего API, переходите к официальной документации Django REST Framework. А ссылку на код этого урока можно найти в начале статьи.

Что такое статические файлы в Django?
Изображения, JS и CSS-файлы называются статическими файлами или ассетами проекта Django.

Код из урока: https://gitlab.com/PythonRu/django_static

1. Создадим папку для статических файлов

В папке проекта Django создайте новую папку «static». В примере выше она находится в директории «dstatic».

2. Укажите статический URL Django в настройках

Теперь убедитесь, что статические файлы Django django.contrib.staticfiles указаны в списке установленных приложений в settings.py.

# dstatic > dstatic > settings.py

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
]

Они должны быть там по умолчанию.

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

# dstatic > dstatic > settings.py

STATIC_URL = '/static/'

STATICFILES_DIRS = [
   os.path.join(BASE_DIR, "static"),
]

Не забудьте импортировать библиотеку os после добавления кода выше.

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

3. Создайте папку для изображений

Создайте папку в «static» специально для изображений. Назовите ее «img». Главное после этого правильно ссылаться на нее в шаблонах.

4. Загрузите статический файл в свой HTML-шаблон

Теперь в выбранном шаблоне (например, в «home.html») загрузите статический файл в верхней части страницы.

Важно добавить {% load static %} до того, как добавлять изображение. В противном случае оно не будет загружено.

Использование тега static в шаблоне

После этого вы можете использовать тег «static» в шаблоне для работы с источником изображения.

dstatic > templates > home.html

{% load static %}
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Home</title>
  <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.0.0-beta1/dist/css/bootstrap.min.css" rel="stylesheet">
</head>
<body>
  <div class="container">
    <h1 class="text-center">Привет Django</h1>
    <img class="w-50 mx-auto d-block" src="{% static 'img/example.png' %}" alt="photo">
  </div>
</body>
</html>

Стоит отметить, что этот файл использует также Bootstrap CDN. Результат:

5. Создание папки и файла JavaScript

Если нужно добавить кастомные JS-файлы в проект, создайте папку «js» внутри «static».

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

Создание файла script.js

В папке static > js создайте файл «script.js», в котором будут храниться все функции JavaScript.

$(window).scroll(function() {
    if ($(document).scrollTop() > 600 && $("#myModal").attr("displayed") === "false") {
        $('#myModal').modal('show');
        $("#myModal").attr("displayed", "true");
    }
});

6. Загрузите скрипт в шаблон

Теперь для подключения JS-файла к проекту добавьте файл в «header.html». Файл должен вызываться так же, как и в случае с изображениями.

Не забудьте и о {% load static %} в верхней части страницы для корректной работы тегов.

{% load static %}
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Home</title>
  <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.0.0-beta1/dist/css/bootstrap.min.css" rel="stylesheet">
  <script src="{% static 'js/script.js' %}"></script>
</head>
<body>
  <div class="container">
    <h1 class="text-center">Привет Django</h1>
    <img class="w-50 mx-auto d-block" src="{% static 'img/example.png' %}" alt="photo">
  </div>
</body>
</html>

7. Создание папки и файла для CSS

Также можно подключить CSS-файлы. Для этого создайте папку «css» внутри «static». Вы также можете использовать элемент <style> и вложить все стили туда.

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

Создание файла стилей css

Создайте файл «stylesheet.css» в static > css. Там будут храниться все ваши стили.

.custom {
    color:#007bff;
    background:#000000;
    font-size:20px;
}

8. Загрузите ссылку на CSS в шаблон

Для подключения собственных стилей к проекту, добавьте HTML-элемент <link> в «header.html». Файл вызывается так же, как изображения и JS-файлы.

{% load static %}
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Home</title>
  <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.0.0-beta1/dist/css/bootstrap.min.css" rel="stylesheet">
  <link rel="stylesheet" href="{% static 'css/stylesheet.css'%}" type="text/css">
  <script src="{% static 'js/script.js' %}"></script>
</head>
<body>
  <div class="container custom">
    <h1 class="text-center">Привет Django</h1>
    <img class="w-50 mx-auto d-block" src="{% static 'img/example.png' %}" alt="photo">
  </div>
</body>
</html>

И снова не забудьте о {% load static %} в верхней части страницы. Если не добавить эту строку, то будет ошибка.

Если класс custom добавить к container вы увидите изменения:

Ошибки, связанные с загрузкой статических файлов Django

Если вы получили ошибку «Invalid block tag on line 8: ‘static’, expected ‘endblock’. Did you forget to register or load this tag?», то вы наверняка забыли добавить тег загрузки статических файлов в верхней части страницы: {% load static %} до вызова самого изображения.

{% load static %}
<img src="{% static 'img/photo.jpg' %}">

Такая ошибка «Could not parse the remainder: ‘/photo.jpg’ from ‘img/photo.jpg’» значит, что вы забыли добавить кавычки вокруг ссылки на изображения. В этом случае нужно использовать две пары кавычек: одни для всего содержимого src, а вторые — для ссылки на изображение.

<img src="{% static img/photo.jpg %}"> {# ошибка #}
<img src="{% static 'img/photo.jpg' %}"> {# верно #}

«Invalid block tag on line 9: »static/img/photo.jpg», expected ‘endblock’. Did you forget to register or load this tag?» говорит о том, что вы случайно добавили тег static в URL.

<img src="{% 'static/img/photo.jpg' %}"> {# ошибка #}
<img src="{% static 'img/photo.jpg' %}"> {# верно #}

Если страница не загружается, и появляется следующая ошибка: «django.core.exceptions.ImproperlyConfigured: You’re using the staticfiles app without having set the required STATIC_URL setting», то это указывает на то, что вы забыли указать статический URL в файле настроек. Его нужно задать в settings.py и сохранить документ.

STATIC_URL = '/static/'

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

<img src="{ static img/photo.jpg }"> {# ошибка #}
<img src="{% static 'img/photo.jpg' %}"> {# верно #}

Где используется?

Словари — распространенная структура данных в Python. Они используются в самых разных ситуациях. Вот некоторые из методов и функций словарей:

• .keys() — используется для вывода ключей словаря.
• .items() — используется для создания кортежей с ключами и значениями.
• .get() — метод для получения значения по ключу.
• .clear() — очистить словарь.
• .copy() — скопировать весь словарь.
• len() — получить длину словаря.
• type() — узнать тип.
• min() — получить ключ с минимальным значением.
• max() — получить ключ с максимальным значением.

Рекомендации по работе со словарями

1. Словари создаются с помощью фигурных скобок.
2. Пары из ключа и значения разделяются запятыми.
3. Ключи и значения разделяются между собой двоеточием
4. Ключи в словаре могут быть только строками, целыми числами или числами с плавающей точкой. А вот значения могут быть любого типа
5. Важно не забывать использовать кавычки для строки-ключа

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

>>> p_ages = {"Андрей": 32, "Виктор": 29, "Максим": 18}

>>> print(p_ages)

{"Андрей": 32, "Виктор": 29, "Максим": 18}

Все строки в словаре заключены в кавычки. В следующем примере ключами уже являются целые числа, а значениями — строки.

>>> p_ages = {32: "Андрей", 29: "Виктор", 18: "Максим"}

>>> print(p_ages)

{32: "Андрей", 29: "Виктор", 18: "Максим"}

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

Так, для получения значения ключа «Виктор» нужно использовать такой синтаксис:

>>> p_ages = {"Андрей": 32, "Виктор": 29, "Максим": 18}

>>> p_ages["Максим"]

18

>>> p_ages["Андрей"]

32

Merge и Update

Начиная с версии Python 3.9, в языке появились новые операторы, которые облегчают процесс слияния словарей.

1. Merge (|): этот оператор позволяет объединять два словаря с помощью одного символа |.
2. Update (|=): с помощью такого оператора можно обновить первый словарь значением второго (с типом dict)

Вот основные отличия этих двух операторов:

• «|» создает новый словарь, объединяя два, а «|=» обновляет первый словарь.
• Оператор merge (|) упрощает процесс объединения словарей и работы с их значениями.
• Оператор update (|=) используется для обновления словарей.

>>> dict1 = {"x": 1, "y":2}

>>> dict2 = {"a":11, "b":22}

>>> dict3 =  dict1 | dict2

>>> print(dict3)

{"x":1, "y":2, "a":11, "b":22}

>>> dict1 = {"x": 1, "y":2}

>>> dict2 = {"a":11, "b":22}

>>> dict2 |=  dict1

>>> print(dict2)

{"x":1, "y":2, "a":11, "b":22}

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

Функция №1: .keys()

.keys() — это удобный метод, который возвращает все ключи в словаре. Дальше посмотрим на пример с использованием метода keys.

>>> p_ages = {"Андрей": 32, "Виктор": 29, "Максим": 18}

>>> print(p_ages.keys())

dict_keys(['Андрей', 'Виктор', 'Максим'])

Функция №2: .items()

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

>>> p_ages = {"Андрей": 32, "Виктор": 29, "Максим": 18}

>>> a = p_ages.items()

>>> print(a)

dict_items([('Андрей', 32), ('Виктор', 29), ('Максим', 18)])

Метод .items() пригодится при необходимости использовать индексацию для доступа к данным.

Функция №3: .get()

.get() — полезный метод для получения значений из словаря по ключу. Получим доступ к возрасту с помощью метода .get().

>>> p_ages = {"Андрей": 32, "Виктор": 29, "Максим": 18}

>>> print(p_ages.get("Андрей"))

32

Функция №4: .clear()

Метод .clear() очищает словарь ото всех элементов.

>>> p_ages = {"Андрей": 32, "Виктор": 29, "Максим": 18}

>>> p_ages.clear()

>>> print(p_ages)

{}

Функция №5: .copy()

Метод .copy() возвращает копию словаря.

>>> p_ages = {"Андрей": 32, "Виктор": 29, "Максим": 18}

>>> print(p_ages.copy())

{"Андрей": 32, "Виктор": 29, "Максим": 18}

Функция №6: len()

Метод len() возвращает количество элементов словаря.

>>> p_ages = {"Андрей": 32, "Виктор": 29, "Максим": 18}

>>> print(len(p_ages))

3

Полезно знать

1. Метод get() — более продвинутый по сравнению с подходом получения значения по ключу.
   Если добавить в метод второй параметр, то он вернет переданное значение в случае, когда ключ не будет найден. Если второй параметр не указывать, получите None.
2. Если попробовать использовать новые операторы (| и |=) в старых версиях python, то вернется ошибка TypeError. Это касается в том числе и dict comprehension.

>>> p_ages = {"Андрей": 32, "Виктор": 29, "Максим": 18}

>>> print(p_ages.get("Михаил", "Не найдено"))

Не найдено

>>> print(p_ages.get("Андрей", "Не найдено"))

32

Задачи к уроку

Попробуйте решить задачи к этому уроку для закрепления знаний.

1. Выведите значение возраста из словаря person.

# данный код
person = {"name": "Kelly", "age":25, "city": "New york"}
# требуемый вывод:
# 25

2. Значениями словаря могут быть и списки. Допишите словарь с ключами BMW, ВАЗ, Tesla и списками из 3х моделей в качестве значений.

# данный код
models_data = {..., "Tesla": ["Modes S", ...]}
print(models_data["Tesla"][0])
# требуемый вывод:
# Modes S

3. Исправьте ошибки в коде, что бы получить требуемый вывод.

# данный код
d1 = {"a": 100. "b": 200. "c":300}
d2 = {a: 300, b: 200, d:400}
print(d1["b"] == d2["b"])
# требуемый вывод:
# True

Файл со всем заданиями: https://gitlab.com/PythonRu/python-dlya-nachinayushih/-/blob/master/lesson_8.py.

Тест по словарям

Пройдите тест к этому уроку для проверки знаний. В тесте 5 вопросов, количество попыток неограниченно.

p = {"name": "Mike", "salary": 8000}
print(p.get("age"))

sample = {"1":["a","b"], "2":["c","d"]}

Если нашли ошибку, опечатку или знаете как улучшить этот урок, пишите на почту. Ее можно найти внизу сайта.

Конец. Что делать дальше?

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

Вы можете учится основам, например на бесплатных курсах от Нетологии или практиковаться на вебинарах Skillbox.

Для перехода на следующий уровень напишите свою программу: калькулятор, игру, api. Самостоятельно или с поддержкой менторов из Twitter и EPAM на программе Профессия Python-разработчик.

Отображение панелей с вкладками с помощью Notebook

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

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

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

Создаем ttk.Notebook с фиксированными размерами, и затем проходимся по словарю с заранее определенными данными. Он выступит источником вкладок и названий для каждой области:

import tkinter as tk

import tkinter.ttk as ttk



class App(tk.Tk):

    def __init__(self):

        super().__init__()

        self.title("Ttk Notebook")



        todos = {

            "Дом": ["Постирать", "Сходить за продуктами"],

            "Работа": ["Установить Python", "Учить Tkinter", "Разобрать почту"],

            "Отпуск": ["Отдых!"]

        }



        self.notebook = ttk.Notebook(self, width=250, height=100, padding=10)

        for key, value in todos.items():

            frame = ttk.Frame(self.notebook)

            self.notebook.add(frame, text=key, underline=0,

                              sticky=tk.NE + tk.SW)

            for text in value:

                ttk.Label(frame, text=text).pack(anchor=tk.W)

        self.label = ttk.Label(self)



        self.notebook.pack()

        self.label.pack(anchor=tk.W)

        self.notebook.enable_traversal()

        self.notebook.bind("<<NotebookTabChanged>>", self.select_tab)



    def select_tab(self, event):

        tab_id = self.notebook.select()

        tab_name = self.notebook.tab(tab_id, "text")

        text = "Ваш текущий выбор: {}".format(tab_name)

        self.label.config(text=text)



if __name__ == "__main__":

    app = App()

    app.mainloop()

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

Как работает этот виджет

Виджет ttk.Notebook создается с фиксированными шириной, высотой и внешними отступами.

Каждый ключ из словаря todos используется в качестве названия вкладки, а список значений добавляется в виде меток в ttk.Frame, который представляет собой область окна:

self.notebook = ttk.Notebook(self, width=250, height=100, padding=10)

for key, value in todos.items():

    frame = ttk.Frame(self.notebook)

    self.notebook.add(frame, text=key,

                               underline=0, sticky=tk.NE+tk.SW)

    for text in value:

        ttk.Label(frame, text=text).pack(anchor=tk.W)

После этого у виджета ttk.Notebook вызывается метод enable_traversal(). Это позволяет пользователям переключаться между вкладками с помощью Ctrl + Shift + Tab и Ctrl + Tab соответственно.

Благодаря этому также можно переключиться на определенную вкладку, зажав Alt и подчеркнутый символ: Alt + H для вкладки Home, Alt + W — для Work, а Alt + V — для Vacation.

Виртуальное событие "<<NotebookTabChanged>>" генерируется автоматически при изменении выбора. Оно связывается с методом select_tab(). Стоит отметить, что это событие автоматически срабатывает при добавлении вкладки в ttk.Notebook:

self.notebook.pack()

self.label.pack(anchor=tk.W)

self.notebook.enable_traversal()

self.notebook.bind("<<NotebookTabChanged>>", self.select_tab)

При упаковке элементов необязательно размещать дочерние элементы ttk.Notebook, поскольку это делается автоматически с помощью вызова geometry manager:

def select_tab(self, event):

    tab_id = self.notebook.select()

    tab_name = self.notebook.tab(tab_id, "text")

    self.label.config(text=f"Ваш текущий выбор: {tab_name}")

Если нужно получить текущий дочерний элемент ttk.Notebook, то для этого не нужно использовать дополнительные структуры данных для маппинга индекса вкладки и окна виджета.

Метод nametowidget() доступен для всех классов виджетов, так что с его помощью можно легко получить объект виджета, соответствующий определенному имени:

def select_tab(self, event):

    tab_id = self.notebook.select()

    frame = self.nametowidget(tab_id)

    # ...

Применение стилей Ttk

У тематических виджетов есть отдельный API для изменения внешнего вида. Прямо задавать параметры нельзя, потому что они определены в классе ttk.Style.

В этом разделе разберем, как изменять виджеты и добавлять им стили.

Для добавления дополнительных настроек нужен объект ttk.Style, который предоставляет следующие методы:

• configure(style, opts) — меняет внешний вид opts для style виджета. Именно здесь задаются такие параметры, как фон, отступы и анимации.
• map(style, query) — меняет динамический вид style виджета. Аргумент query — аргумент-ключевое слово, где каждый ключ отвечает за параметр стиля, а значение — список кортежей в виде (state, value). Это значит, что значение каждого параметра определяется его текущим состоянием.

Например, отметим следующие примеры для двух ситуаций:

import tkinter as tk

import tkinter.ttk as tk



class App(tk.Tk):

    def __init__(self):

        super().__init__()



        self.title("Tk themed widgets")

        style = ttk.Style(self)

        style.configure("TLabel", padding=10)

        style.map("TButton",

                       foreground=[("pressed", "grey"), ("active", "white")],

                       background=[("pressed", "white"), ("active", "grey")]

        )

       # ...

Теперь каждый ttk.Label отображается с внутренним отступом 10, а у ttk.Button динамические стили: серая заливка с белым фоном, когда состояние кнопки — pressed и белая заливка с серым фоном — когда active.

Как работают стили

Создавать ttk.Style довольно просто. Нужно лишь создать экземпляр с родительским виджетом в качестве первого параметра.

После этого можно задать настройки стиля для виджетов с помощью символа T в верхнем регистре и названия виджета: Tbutton для ttk.Button, Tlabel для ttk.Label и так далее. Однако есть и исключения, поэтому рекомендуется сверяться с помощью интерпретатора Python, вызывая winfo_class() для экземпляра виджета.

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

style.configure("My.TLabel", padding=10)

# ...

label = ttk.Label(master, text="Какой-то текст", style="My.TLabel")

Создание виджета выбора даты

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

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

В этом материале пошагово разберем процесс создания виджета выбора даты с помощью виджетов Ttk:

Это рефакторинг решения https://svn.python.org/projects/sandbox/trunk/t tk-gsoc/samples/ttkcalendar.py, который не требует внешних зависимостей.

Помимо модулей tkinter также нужны модули calendar и datetime из стандартной библиотеки. Это поможет моделировать данные виджета и взаимодействовать с ними.

Заголовок виджета показывает стрелки для перемещения между месяцами. Их внешний вид зависит от текущих выбранных стилей Tk. Тело виджета состоит из таблицы ttk.Treeview с экземпляром Canvas, который подсвечивает ячейку выбранной даты:

import calendar

import datetime

import tkinter as tk

import tkinter.ttk as ttk

import tkinter.font as tkfont

from itertools import zip_longest



class TtkCalendar(ttk.Frame):

    def __init__(self, master=None, **kw):

        now = datetime.datetime.now()

        fwday = kw.pop('firstweekday', calendar.MONDAY)

        year = kw.pop('year', now.year)

        month = kw.pop('month', now.month)

        sel_bg = kw.pop('selectbackground', '#ecffc4')

        sel_fg = kw.pop('selectforeground', '#05640e')



        super().__init__(master, **kw)



        self.selected = None

        self.date = datetime.date(year, month, 1)

        self.cal = calendar.TextCalendar(fwday)

        self.font = tkfont.Font(self)

        self.header = self.create_header()

        self.table = self.create_table()

        self.canvas = self.create_canvas(sel_bg, sel_fg)

        self.build_calendar()



        # ...



def main():

    root = tk.Tk()

    root.title('Календарь Tkinter')

    ttkcal = TtkCalendar(firstweekday=calendar.SUNDAY)

    ttkcal.pack(expand=True, fill=tk.BOTH)

    root.mainloop()



if __name__ == '__main__':

    main()

Полный код в файле lesson_23/creating_widget.py на Gitlab.

Как создается виджет

Этот класс TtkCalendar можно кастомизировать, передавая параметры в виде аргументов-ключевых слов. Их можно получать при инициализации, указав кое-какие значения по умолчанию, например, текущие месяц и год:

    def __init__(self, master=None, **kw):

        now = datetime.datetime.now()

        fwday = kw.pop('firstweekday', calendar.MONDAY)

        year = kw.pop('year', now.year)

        month = kw.pop('month', now.month)

        sel_bg = kw.pop('selectbackground', '#ecffc4')

        sel_fg = kw.pop('selectforeground', '#05640e')



        super().__init__(master, **kw)

После этого задаются атрибуты для хранения информации:

• selected — хранит значение выбранной даты.
• date — дата, представляющая текущий месяц, который показывается на календаре.
• calendar — григорианский календарь с информацией о неделях и названиями месяцев.

Визуальные элементы виджета внутри создаются с помощью методов create_header() и create_table(), речь о которых пойдет дальше.

Также используется экземпляр tkfont.Font для определения размера шрифта.

После инициализации этих атрибутов визуальные элементы календаря выравниваются с помощью вызова метода build_calendar():

self.selected = None

self.date = datetime.date(year, month, 1)

self.cal = calendar.TextCalendar(fwday)

self.font = tkfont.Font(self)

self.header = self.create_header()

self.table = self.create_table()

self.canvas = self.create_canvas(sel_bg, sel_fg)

self.build_calendar()

Метод create_header() использует ttk.Style для отображения стрелок, которые нужны для переключения между месяцами. Он возвращает метку названия текущего месяца:

    def create_header(self):

        left_arrow = {'children': [('Button.leftarrow', None)]}

        right_arrow = {'children': [('Button.rightarrow', None)]}

        style = ttk.Style(self)

        style.layout('L.TButton', [('Button.focus', left_arrow)])

        style.layout('R.TButton', [('Button.focus', right_arrow)])



        hframe = ttk.Frame(self)

        btn_left = ttk.Button(hframe, style='L.TButton',

                              command=lambda: self.move_month(-1))

        btn_right = ttk.Button(hframe, style='R.TButton',

                               command=lambda: self.move_month(1))

        label = ttk.Label(hframe, width=15, anchor='center')



        hframe.pack(pady=5, anchor=tk.CENTER)

        btn_left.grid(row=0, column=0)

        label.grid(row=0, column=1, padx=12)

        btn_right.grid(row=0, column=2)

        return label

Колбек move_month() скрывает текущий выбор, выделенный с помощью поля полотна и добавляет параметр offset текущему месяцу, чтобы задать атрибут date с предыдущим или следующим месяцем. После этого календарь снова перерисовывается, показывая уже дни нового месяца:

    def move_month(self, offset):

        self.canvas.place_forget()

        month = self.date.month - 1 + offset

        year = self.date.year + month // 12

        month = month % 12 + 1

        self.date = datetime.date(year, month, 1)

        self.build_calendar()

Тело календаря создается в create_table() с помощью виджета ttk.Treeview, который показывает каждую неделю текущего месяца в одной строке:

    def create_table(self):

        cols = self.cal.formatweekheader(3).split()

        table = ttk.Treeview(self, show='', selectmode='none',

                             height=7, columns=cols)

        table.bind('<Map>', self.minsize)

        table.pack(expand=1, fill=tk.BOTH)

        table.tag_configure('header', background='grey90')

        table.insert('', tk.END, values=cols, tag='header')

        for _ in range(6):

            table.insert('', tk.END)



        width = max(map(self.font.measure, cols))

        for col in cols:

            table.column(col, width=width, minwidth=width, anchor=tk.E)

        return table

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

    def create_canvas(self, bg, fg):

        canvas = tk.Canvas(self.table, background=bg,

                           borderwidth=0, highlightthickness=0)

        canvas.text = canvas.create_text(0, 0, fill=fg, anchor=tk.W)

        handler = lambda _: canvas.place_forget()

        canvas.bind('<ButtonPress-1>', handler)

        self.table.bind('<Configure>', handler)

        self.table.bind('<ButtonPress-1>', self.pressed)

        return canvas

Календарь строится за счет перебора недель и позиций элементов таблицы ttk.Treeview. С помощью функции zip_longest() из модуля itertools перебираем коллекцию, оставляя на месте недостающих дней пустые строки.

Это поведение нужно для первой и последней недель месяца, ведь именно там часто можно найти пустые слоты:

    def build_calendar(self):

        year, month = self.date.year, self.date.month

        month_name = self.cal.formatmonthname(year, month, 0)

        month_weeks = self.cal.monthdayscalendar(year, month)



        self.header.config(text=month_name.title())

        items = self.table.get_children()[1:]

        for week, item in zip_longest(month_weeks, items):

            week = week if week else []

            fmt_week = ['%02d' % day if day else '' for day in week]

            self.table.item(item, values=fmt_week)

При клике по элементу таблицы обработчик события pressed() задает выделение и меняет полотно для выделения выбора:

    def pressed(self, event):

        x, y, widget = event.x, event.y, event.widget

        item = widget.identify_row(y)

        column = widget.identify_column(x)

        items = self.table.get_children()[1:]



        if not column or not item in items:

            # клик на заголовок или за пределами столбцов

            return



        index = int(column[1]) - 1

        values = widget.item(item)['values']

        text = values[index] if len(values) else None

        bbox = widget.bbox(item, column)

        if bbox and text:

            self.selected = '%02d' % text

            self.show_selection(bbox)

Метод show_selection() размещает полотно в пределах выбранного элемента, так что текст помещается внутри:

    def show_selection(self, bbox):

        canvas, text = self.canvas, self.selected

        x, y, width, height = bbox

        textw = self.font.measure(text)

        canvas.configure(width=width, height=height)

        canvas.coords(canvas.text, width - textw, height / 2 - 1)

        canvas.itemconfigure(canvas.text, text=text)

        canvas.place(x=x, y=y)

Наконец, параметр selection позволяет получить выбранную дату в виде объекта datetime.date. Он не используется в примере, но нужен для работы API в классе TtkCalendar:

    @property

    def selection(self):

        if self.selected:

            year, month = self.date.year, self.date.month

            return datetime.date(year, month, int(self.selected))

Индекс начинается с нуля, как и в случае списков, а отрицательный индекс — с -1. Этот индекс указывает на последний элемент кортежа.

Где используется?

Кортежи — распространенная структура данных для хранения последовательностей в Python.

• .index() — используется для вывода индекса элемента.
• .count() — используется для подсчета количества элементов в кортеже.
• sum() — складывает все элементы кортежа.
• min() — показывает элемент кортежа с наименьшим значением.
• max() — показывает элемент кортежа с максимальным значением.
• len() — показывает количество элементов кортежа.

Рекомендации по работе с кортежами

1. Кортежи создаются с помощью круглых скобок: ();
2. Элементы внутри кортежей разделяются запятыми;
3. Важно соблюдать особенности синтаксиса, характерные для каждого отдельного типа данных в кортеже — кавычки для строк, числа и булевые значения без кавычек и так далее.

Дальше — кортеж, включающий элементы разных типов:

>>> p_tup = ("Лондон", "Пекин", 44, True)

>>> print(p_tup)

('Лондон', 'Пекин', 44, True)

Доступ к элементам: получить элементы кортежа можно с помощью соответствующего индекса в квадратных скобках.

Например, для получения элемента «Лондон» нужно использовать следующий индекс: p_tup[0]

А для 44: p_tup[2]

Последний элемент следующего кортежа — булево True. Доступ к нему мы получаем с помощью функции print.

>>> p_tup = ("Лондон", "Пекин", 44, True)

>>> print(p_tup[3])

True

Пример получения первого элемента кортежа.

>>> p_tup = ("Лондон", "Пекин", 44, True)

>>> print(p_tup[0])

'Лондон'

Советы:

1. Обратное индексирование: по аналогии с элементами списка элементы кортежа также можно получить с помощью обратного индексирования. Оно начинается с -1. Это значение указывает на последний элемент.
   Так, для получения последнего элемент p_tup нужно писать p_tup[-1]. p_tup[-2] вернет второй элемент с конца и так далее.
2. Главное отличие кортежей от списков — они неизменяемые. Кортежам нельзя добавлять или удалять элементы.
   Поэтому эта структура используется, когда известно, что элементы не будут меняться в процессе работы программы.

>>> p_tup = ("Лондон", "Пекин", 44, True)

>>> print(p_tup[-1])

True

Функция .index()

.index() — полезный метод, используемый для получения индекса конкретного элемента в кортеже.

Посмотрим на примере.

>>> p_tup = ("Лондон", "Пекин", 44, True)

>>> print(p_tup.index("Лондон"))

0

Функция .count()

Метод .count() подходит для определения количества вхождений определенного элемента в кортеже.

В примере ниже можно увидеть, что считается количество вхождений числа 101 в списке p_cup. Результат — 2.

>>> p_tup = (5, 101, 42, 3, 101)

>>> print(p_tup.count(101))

2

Функция sum()

Функция sum() возвращает общую сумму чисел внутри кортежа.

>>> lucky_numbers = (5, 55, 4, 3, 101, 42)

>>> print(sum(lucky_numbers))

210

Функция min()

Функция min() вернет элемент с самым маленьким значением в кортеже.

>>> lucky_numbers = (5, 55, 4, 3, 101, 42)

>>> print(min(lucky_numbers))

5

Функция max()

Функция max() вернет элемент с максимальным значением в кортеже.

>>> lucky_numbers = (5, 55, 4, 3, 101, 42)

>>> print(max(lucky_numbers))

101

Задачи к уроку

Попробуйте решить задачи к этому уроку для закрепления знаний.

1. Создайте кортеж с цифрами от 0 до 9 и посчитайте сумму.

# данный код
numbers =
print(sum(numbers))
# требуемый вывод:
# 45

2. Введите статистику частотности букв в кортеже.

# данный код
long_word = (
    'т', 'т', 'а', 'и', 'и', 'а', 'и', 
    'и', 'и', 'т', 'т', 'а', 'и', 'и',
    'и', 'и', 'и', 'т', 'и'
)

print("Количество 'т':", )
print("Количество 'a':", )
print("Количество 'и':", )
# требуемый вывод:
# Колличество 'т': 5
# Колличество 'а': 3
# Колличество 'и': 11

3. Допишите скрипт для расчета средней температуры.
   Постарайтесь посчитать количество дней на основе week_temp. Так наш скрипт сможет работать с данными за любой период.

# данный код
week_temp = (26, 29, 34, 32, 28, 26, 23)
sum_temp =
days =
mean_temp = sum_temp / days
print(int(mean_temp))
# требуемый вывод:
# 28

Файл со всем заданиями: https://gitlab.com/PythonRu/python-dlya-nachinayushih/-/blob/master/lesson_7.py.

Тест по кортежам

Пройдите тест к этому уроку для проверки знаний. В тесте 5 вопросов, количество попыток неограниченно.

sample = (10, 20, 30)
sample.append(60)
print(sample)

lake = ("Python", 51, False, "22")

Если нашли ошибку, опечатку или знаете как улучшить этот урок, пишите на почту. Ее можно найти внизу сайта.

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

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

Первая строка класса ttk.Treeview состоит из заголовков, которые определяют каждую колонку с помощью имени. Их можно скрыть.

С помощью ttk.Treeview создадим таблицу из списка контактов, которые хранятся в CSV-файле:

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

Контакты загружаются из CSV-файла с помощью модуля csv, и после этого добавляется связывание для виртуального элемента <<TreeviewSelect>>, который генерируется при выборе одного или большего количества элементов:

import csv

import tkinter as tk

import tkinter.ttk as ttk



class App(tk.Tk):

    def __init__(self, path):

        super().__init__()

        self.title("Ttk Treeview")



        columns = ("#1", "#2", "#3")

        self.tree = ttk.Treeview(self, show="headings", columns=columns)

        self.tree.heading("#1", text="Фамилия")

        self.tree.heading("#2", text="Имя")

        self.tree.heading("#3", text="Почта")

        ysb = ttk.Scrollbar(self, orient=tk.VERTICAL, command=self.tree.yview)

        self.tree.configure(yscroll=ysb.set)



        with open("../lesson_13/contacts.csv", newline="") as f:

            for contact in csv.reader(f):

                self.tree.insert("", tk.END, values=contact)

        self.tree.bind("<<TreeviewSelect>>", self.print_selection)



        self.tree.grid(row=0, column=0)

        ysb.grid(row=0, column=1, sticky=tk.N + tk.S)

        self.rowconfigure(0, weight=1)

        self.columnconfigure(0, weight=1)



    def print_selection(self, event):

        for selection in self.tree.selection():

            item = self.tree.item(selection)

            last_name, first_name, email = item["values"][0:3]

            text = "Выбор: {}, {} <{}>"

            print(text.format(last_name, first_name, email))



if __name__ == "__main__":

    app = App(path=".")

    app.mainloop()

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

Как работает виджет Treeview

Для создания ttk.Treeview с несколькими колонками нужно указать идентификатор каждой с помощью параметра columns. После этого можно настроить текст заголовка с помощью метода heading().

Используем идентификаторы #1, #2 и #3, поскольку первая колонка, включающая иконку раскрытия и текст, всегда генерируется с идентификатором #0.

Также параметру show передается значение «headings», чтобы обозначить, что нужно скрыть колонку #0, потому что вложенных элементов тут не будет.

Следующие значения являются валидными для параметра show:

• tree — отображает колонку #0;
• headings — отображает строку заголовка;
• tree headings — отображает и колонку #0, и строку заголовка (является значением по умолчанию);
• "" — не отображает ни колонку #0, ни строку заголовка.

После этого к виджету ttk.Treeview добавляется вертикальный скроллбар:

        columns = ("#1", "#2", "#3")

        self.tree = ttk.Treeview(self, show="headings", columns=columns)

        self.tree.heading("#1", text="Фамилия")

        self.tree.heading("#2", text="Имя")

        self.tree.heading("#3", text="Почта")

        ysb = ttk.Scrollbar(self, orient=tk.VERTICAL, command=self.tree.yview)

        self.tree.configure(yscroll=ysb.set)

Для загрузки контактов в таблицу файл нужно обработать с помощью функции render() из модуля CSV. В процессе строка, прочтенная на каждой итерации, добавляется к ttk.Treeview.

Это делается с помощью метода insert(), который получает родительский узел и положение для размещения элемента.

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

Также можно использовать другие аргументы-ключевые слова для метода insert(). Здесь используется параметр values, который принимает последовательность значений — они и отображаются в каждой колонке Treeview:

        with open("../lesson_13/contacts.csv", newline="") as f:

            for contact in csv.reader(f):

                self.tree.insert("", tk.END, values=contact)

        self.tree.bind("<<TreeviewSelect>>", self.print_selection)

<<TreeviewSelect>> — это виртуальное событие, которое генерируется при выборе одного или нескольких элементов из таблицы. В обработчике print_selection() получаем текущее выделение с помощью метода selection(), и для каждого результата выполняем следующие шаги:

1. С помощью метода item() получаем словарь параметров и значений выбранного элемента.
2. Получаем первые три значения словаря item, которые соответствуют фамилии, имени и адресу электронной почты контакта.
3. Значения форматируются и выводятся в стандартный вывод:

    def print_selection(self, event):

        for selection in self.tree.selection():

            item = self.tree.item(selection)

            last_name, first_name, email = item["values"][0:3]

            text = "Выбор: {}, {} <{}>"

            print(text.format(last_name, first_name, email))

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

Использование тегов в элементах Treeview

Тэги доступны для элементов ttk.Treeview, благодаря чему существует возможность связать последовательности события с конкретными строками таблицы Contacts.

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

Это можно реализовать, добавляя тег с условием при вставке. После этого нужно вызывать tag_bind() на экземпляре виджета с последовательностью "<Double-Button-1>" — здесь можно просто сослаться на реализацию функции-обработчика send_email_to_contact() по имени:

columns = ("Фамилия", "Имя", "Почта")

tree = ttk.Treeview(self, show="headings", columns=columns)



for contact in csv.reader(f):

    email = contact[2]

    tags = ("dbl-click",) if email else ()

    self.tree.insert("", tk.END, values=contact, tags=tags)



tree.tag_bind("dbl-click", "<Double-Button-1>", send_email_to_contact)

По аналогии с тем, что происходит при связывании событий с элементами Canvas, важно не забывать добавлять элементы с тегами к ttk.Treeview до вызова tag_bind(), потому что связывания добавляются только к существующим совпадающим элементам.

Заполнение вложенных элементов в Treeview

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

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

Для демонстрации рекурсивного добавления элементов в виджет ttk.Treeview создадим базовый браузер файловой системы. Раскрываемые узлы будут представлять собой папки, а после раскрытия они будут показывать вложенные файлы и папки:

Дерево изначально будет заполняться с помощью метода populate_node(), который содержит записи текущей директории. Если запись сама является директорией, то она добавляет дочерний раскрываемый узел.

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

import os

import tkinter as tk

import tkinter.ttk as ttk



class App(tk.Tk):

    def __init__(self, path):

        super().__init__()

        self.title("Ttk Treeview")



        abspath = os.path.abspath(path)

        self.nodes = {}

        self.tree = ttk.Treeview(self)

        self.tree.heading("#0", text=abspath, anchor=tk.W)

        ysb = ttk.Scrollbar(self, orient=tk.VERTICAL,

                            command=self.tree.yview)

        xsb = ttk.Scrollbar(self, orient=tk.HORIZONTAL,

                            command=self.tree.xview)

        self.tree.configure(yscroll=ysb.set, xscroll=xsb.set)



        self.tree.grid(row=0, column=0, sticky=tk.N + tk.S + tk.E + tk.W)

        ysb.grid(row=0, column=1, sticky=tk.N + tk.S)

        xsb.grid(row=1, column=0, sticky=tk.E + tk.W)

        self.rowconfigure(0, weight=1)

        self.columnconfigure(0, weight=1)



        self.tree.bind("<<TreeviewOpen>>", self.open_node)

        self.populate_node("", abspath)



    def populate_node(self, parent, abspath):

        for entry in os.listdir(abspath):

            entry_path = os.path.join(abspath, entry)

            node = self.tree.insert(parent, tk.END, text=entry, open=False)

            if os.path.isdir(entry_path):

                self.nodes[node] = entry_path

                self.tree.insert(node, tk.END)



    def open_node(self, event):

        item = self.tree.focus()

        abspath = self.nodes.pop(item, False)

        if abspath:

            children = self.tree.get_children(item)

            self.tree.delete(children)

            self.populate_node(item, abspath)



if __name__ == "__main__":

    app = App(path="../")

    app.mainloop()

Запуск предыдущего примера выведет иерархию файловой системы в зависимости от того, где запустить этот файл. Однако можно явно указать директорию с помощью аргумента path конструктора App.

Как работают выпадающие элементы

В этом примере будем использовать модуль os, который является частью стандартной библиотеки Python и предоставляет удобный способ для выполнения запросов к операционной системе.

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

import os

import tkinter as tk

import tkinter.ttk as ttk



class App(tk.Tk):

    def __init__(self, path):

        # ...

        abspath = os.path.abspath(path)

        self.nodes = {}

Например, os.path.abspath(".") вернет абсолютную версию пути к папке, откуда был запущен скрипт. Этот подход лучше использования относительных путей, потому что он помогает не думать о возможных проблемах при работе с путями.

Дальше инициализируется экземпляр ttk.Treeview с вертикальным и горизонтальным скроллбарами. Параметр text иконки заголовка будет тем самым абсолютным путем:

        self.tree = ttk.Treeview(self)

        self.tree.heading("#0", text=abspath, anchor=tk.W)

        ysb = ttk.Scrollbar(self, orient=tk.VERTICAL,

                            command=self.tree.yview)

        xsb = ttk.Scrollbar(self, orient=tk.HORIZONTAL,

                            command=self.tree.xview)

        self.tree.configure(yscroll=ysb.set, xscroll=xsb.set)

После этого виджеты размещаются с помощью geometry manager Grid. Экземпляр ttk.Treeview нужно сделать автоматически изменяемым горизонтально и вертикально.

После этого выполняется связывание виртуального события "<<TreeviewOpen>>", которое генерируется при открытии раскрываемого элемента в обработчике open_node(). populate_node() вызывается для загрузки записей конкретной директории:

    self.tree.bind("<<TreeviewOpen>>", self.open_node)

    self.populate_node("", abspath)

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

В методе populate_node() перечисляем названия записей директорий с помощью вызова os.listdir(). Для каждого названия после этого выполняем следующие действия:

• Вычисляем абсолютный путь к записи. В UNIX-системах это делается за счет объединения строк слэшем, а в Windows используются обратные слэши. Благодаря os.path.join() с путями можно работать безопасно, не думая об особенностях платформ.
• Вставляем строку entry как последний дочерний элемент конкретного узла parent. Всегда отмечаем их закрытыми, чтобы «лениво» загружать вложенные элементы только тогда, когда те потребуются.
• Если абсолютный путь записи указывает на директорию, то добавляется связь для узла и пути в атрибут nodes, а также добавляется пустой дочерний элемент, позволяющий раскрывать его:

    def populate_node(self, parent, abspath):

        for entry in os.listdir(abspath):

            entry_path = os.path.join(abspath, entry)

            node = self.tree.insert(parent, tk.END, text=entry, open=False)

            if os.path.isdir(entry_path):

                self.nodes[node] = entry_path

                self.tree.insert(node, tk.END)

При нажатии на такой элемент обработчик open_node() получает выбранный элемент с помощью вызова метода focus() экземпляра ttk.Treeview.

Идентификатор элемента используется для получения абсолютного пути, который был добавлен до этого в атрибут nodes. Чтобы ошибка KeyError не появлялась, если узел не существует в словаре, используем метод pop(), который возвращает второй параметр в качестве значения по умолчанию — False.

Если узел существует, очищаем «фейковый» элемент расширяемого узла. Вызов self.tree.get_children(item) возвращает идентификаторы дочерних элементов item. После этого они удаляются с помощью вызова self.tree.delete(children).

После очистки элемента добавляем реальные дочерние элементы с помощью метода populate_node() и item в качестве родителя:

    def open_node(self, event):

        item = self.tree.focus()

        abspath = self.nodes.pop(item, False)

        if abspath:

            children = self.tree.get_children(item)

            self.tree.delete(children)

            self.populate_node(item, abspath)

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

Индексация: важно отметить, что индексация списков начинается с 0 (нуля). Это значит, что первый элемент в списке на самом деле является нулевым в мире Python. Об этом очень важно помнить.

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

Где используется?

Списки — распространенная структура данных в Python. Они используются для самых разных целей.

Рекомендации по работе со списками

1. Списки создаются с помощью квадратных скобок [].
2. Элементы списка нужно разделять запятыми.
3. Правила синтаксиса, характерные для определенных типов данных, нужно соблюдать внутри списка. Так, если у строки должны быть кавычки, то их нужно использовать и внутри списка, а для чисел и значений булево типа их не нужно использовать.

Дальше идет список, включающий значения разных типов. Это отличный пример, демонстрирующий нюансы списков. Посмотрим.

>>> p_datatypes = ["Python", "апельсин", 23, 51, False, "False", "22"]

>>> print(p_datatypes)

"Python", "апельсин", 23, 51, False, "False", "22"

1. Во-первых, видно, что внутри находятся значения разных типов. Это строка, целое число, булево значение и снова строка.
2. Последние два элемента списка — это строки, хотя они могут напоминать булев тип и целое число. Однако использование кавычек прямо указывает на то, что это строки в Python.
3. Наконец, если посмотреть на индексы элементов, то можно увидеть, что нулевой элемент — это «Python», а шестой — «22». Оба являются строками. Хотя элементов 7, последним индексом является 6.

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

Например, для получения первого элемента («Python») нужно написать следующим образом: p_datatypes[0]. Для получения элемента 23: p_datatypes[2].

Посмотрим на другие примеры. Последний элемент следующего списка — булево значение False. Получим доступ к нему внутри функции print.

>>> p_datatypes = ["Python", "апельсин", 23, False]

>>> print(p_datatypes[3])

False

А вот получение первого элемента из списка.

>>> p_datatypes = ["Python", "апельсин", 23, False]

>>> print(p_datatypes[0])

'Python'

Обратное индексирование

1. Обратное индексирование. Элементы списка также можно вызывать, начиная с конца — это называется обратным индексированием. В отличие от обычного индексирования, обратное начинается не с 0, а с -1.
   Для получения последнего элемента списка p_datatypes: p_datatypes[-1].
2. Аналогично p_datatypes[-2] вернет второй элемент с конца и так далее.

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

>>> p_datatypes = ["Python", "апельсин", 23, False]

>>> print(p_datatypes[-1])

False

Методы и функции списков

Метод №1: .append()

append() — это, наверное, самый используемый метод списков. Он используется для добавления элементов к списку. Теперь посмотрим на пример, где метод .append() используется для добавления нового элемента в конец списка.

>>> p_datatypes = ["Python", "апельсин"]

>>> p_datatypes.append("BMW")

>>> print(p_datatypes)

["Python", "апельсин", "BMW"]

Метод №2: .insert()

.insert() — еще один полезный метод для списков. Он используется для вставки элемента в список по индексу.

Посмотрим на примере — .insert() принимает два аргумента: индекс, куда нужно вставить новый элемент, и сам элемент.

>>> p_datatypes = ["Python", "апельсин"]

>>> p_datatypes.insert(1, “BMW”)

>>> print(p_datatypes)

["Python", "BMW", "апельсин"]

Метод №3 .index()

.index() помогает определить индекс элемента. Дальше идет пример получения индекса конкретного элемента.

>>> lst = [1, 33, 5, 55, 1001]

>>> a = lst.index(55)

>>> print(a)

3

Метод №4: .clear()

Метод .clear() удаляет все элементы списка.

>>> lucky_numbers = [5, 55, 4, 3, 101, 42]

>>> lucky_numbers.clear()

>>> print(lucky_numbers)

[]

Метод №5: .remove()

Метод .remove() удаляет конкретный элемент списка.

>>> lucky_numbers = [5, 55, 4, 3, 101, 42]

>>> lucky_numbers.remove(101)

>>> print(lucky_numbers)

[5, 55, 4, 3, 42]

Метод №6: .reverse()

Метод .reverse() разворачивает порядок элементов в списке.

>>> lucky_numbers = [5, 55, 4, 3, 101, 42]

>>> lucky_numbers.reverse()

>>> print(lucky_numbers)

[42, 101, 3, 4, 55, 5]

Метод №7: .count()

Метод .count() используется, чтобы подсчитать, как часто конкретный элемент встречается в списке.

В следующем примере мы считаем, как часто в списке встречается число 5. Результат — 1, что значит, что число 5 встретилось всего один раз.

>>> lucky_numbers = [5, 55, 4, 3, 101, 42]

>>> print(lucky_numbers.count(5))

1

В этом же случае в списке нет 1, поэтому и вывод будет 0.

>>> lucky_numbers = [5, 55, 4, 3, 101, 42]

>>> print(lucky_numbers.count(1))

0

Функция №8: sum()

Функция sum() вернет общую сумму всех чисел в списке.

>>> lucky_numbers = [5, 55, 4, 3, 101, 42]

>>> print(sum(lucky_numbers))

210

Функция №9: min()

Функция min() покажет элемент с минимальным значением в списке. Посмотрим пример.

>>> lucky_numbers = [5, 55, 4, 3, 101, 42]

>>> print(min(lucky_numbers))

3

Функция №10: max()

Функция max() покажет элемент с максимальным значением в списке. Пример:

>>> lucky_numbers = [5, 55, 4, 3, 101, 42]

>>> print(max(lucky_numbers))

101

Продвинутые рекомендации

Вот еще некоторые функции и методы списков, особенности которых мы рассмотрим позже:

1. .sort()
2. .find()
3. .pop()
4. len() — используется и в других структурах данныхю.
5. zip()
6. map()
7. filter()
8. List Comprehension (очень практичный и удобный способ работы со списками)

Как перемешать элементы списка

Перемешать элементы в списке можно с помощью библиотеки random.

Это стандартная библиотека Python, которая предлагает разные полезные элементы (среди самых используемых — randrange и randint).

В этой библиотеке также есть метод shuffle, который можно использовать после импорта random: random.shuffle(список).

>>> import random

>>> lst = [1,2,3,4,5,6,7,8,9,10]

>>> random.shuffle(lst)

>>> print(lst)

[7,3,5,2,6,8,4,1,9]

Задачи к уроку

Попробуйте решить задачи к этому уроку для закрепления знаний.

1. Допишите код, что бы вывести последний элемент списка.

# данный код
sample = ["abc", "xyz", "aba", 1221]
# требуемый вывод:
# 1221

2. Допишите код, что бы вывести расширенный список.

# данный код
sample = ["Green", "White", "Black"]

print(sample)
# требуемый вывод:
# ["Red", "Green", "White", "Black", "Pink", "Yellow"]

3. Исправьте ошибки в коде, что бы посчитать сумму элементов в списке.

# данный код
sample = ["11", "33", "50"]
print(sample.sum())
# требуемый вывод:
# 94

Файл со всем заданиями: https://gitlab.com/PythonRu/python-dlya-nachinayushih/-/blob/master/lesson_6.py.

Тест по спискам

Пройдите тест к этому уроку для проверки знаний. В тесте 5 вопросов, количество попыток неограниченно.

a = [ 1, 342, 223, 'India', 'Fedora']
print(a[-3])

sample = [10, 20, 30]
sample.append(60)
sample.insert(3, 40)
print(sample)

lake = ["Python", 51, False, "22"]
lake.reverse()
lake.reverse()
print(lake[-2])

Если нашли ошибку, опечатку или знаете как улучшить этот урок, пишите на почту. Ее можно найти внизу сайта.

Тематические виджеты Tk — это отдельная коллекция виджетов Tk, которые выглядят и ощущаются как нативные, и могут быть кастомизированы с помощью API.

Эти классы определены в модуле tkinter.ttk. Помимо новых виджетов, таких как Treeview и Notebook, этот модуль предлагает альтернативную реализацию классических виджетов Tk: Button, Label и Frame.

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

Набор тематических виджетов Tk был представлен в Tk 8.5, что не должно быть проблемой, ведь установка Python как минимум версии 3.6 добавляет интерпретатор Tcl/Tk версии 8.6.

Убедиться в этом можно, набрав на любой платформе в командной строке python –mtkinter. После этого запустится следующая программа с указанием текущей версии Tcl/Tk:

Замена классов базовых виджетов

В качестве первого пункта знакомства с тематическими виджетами Tkinter посмотрим, как использовать уже знакомые (Button, Label, Entry и так далее), но взятые из другого модуля, сохраняя то же поведение в приложении.

Хотя это не даст аналогичных возможностей в плане настройки стилей, достаточно обратить внимание на визуальные отличия, которые привносят нативные дизайн и «ощущения» этих тематических виджетов.

На следующем скриншоте можно увидеть различия между тематическим виджетом и стандартным виджетом Tkinter:

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

Стоит отметить, что это поведение сильно зависит от платформы. В этом конкретном случае тематический виджет повторяет внешний вид виджетов с Windows 10.

Чтобы начать использовать тематические виджеты нужны импортировать модуль tkinter.ttk и привычным образом использовать виджеты из него в приложении:

import tkinter as tk

import tkinter as ttk



class App(tk.Tk):

    greetings = ("Привет", "Ciao", "Hola")



    def __init__(self):

        super().__init__()

        self.title("Тематические виджеты Tk")



        var = tk.StringVar()

        var.set(self.greetings[0])

        label_frame = ttk.LabelFrame(self, text="Выберите приветствие")

        for greeting in self.greetings:

            radio = ttk.Radiobutton(label_frame, text=greeting,

                                    variable=var, value=greeting)

            radio.pack()



        frame = ttk.Frame(self)

        label = ttk.Label(frame, text="Введите ваше имя")

        entry = ttk.Entry(frame)



        command = lambda: print("{}, {}!".format(var.get(), entry.get()))

        button = ttk.Button(frame, text="Приветствовать", command=command)



        label.grid(row=0, column=0, padx=5, pady=5)

        entry.grid(row=0, column=1, padx=5, pady=5)

        button.grid(row=1, column=0, columnspan=2, pady=5)



        label_frame.pack(side=tk.LEFT, padx=10, pady=10)

        frame.pack(side=tk.LEFT, padx=10, pady=10)



if __name__ == "__main__":

    app = App()

    app.mainloop()

Если же в будущем потребуется переключиться к обычным виджетам Tkinter, то достаточно заменить все ttk. на tk..

Как работает замена виджетов

Чтобы начать использовать тематически виджеты нужно импортировать модуль tkinter.ttk с помощь синтаксиса import … as. Это позволит быстро отличать стандартные виджеты благодаря имени tk и тематические — с именем ttk:

import tkinter as tk

import tkinter as ttk

Вы могли заметить, что для замены виджетов из модуля tkinter на аналогичные им из tkinter.ttk достаточно просто поменять алиас:

import tkinter as tk

import tkinter as ttk



# ...

entry_1 = tk.Entry(root)

entry_2 = ttk.Entry(root)

В этом примере мы делаем это с помощью виджетов ttk.Frame, ttk.Label, ttk.Entry, ttk.LabelFrame и ttk.Radiobutton. Эти классы принимают почти те же базовые параметры, что и эквиваленты из Tkinter. На самом деле, они являются их подклассами.

Тем не менее эта смена довольно простая, потому что в этом случае не переносятся никакие особенности стиля: например, foreground и background. В тематических виджетах эти ключевые слова используются в классе ttk.Style, речь о котором пойдет дальше.

Создание редактируемого выпадающего списка с Combobox

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

Эта функциональность комбинируется с классом ttk.Combobox, который выглядит и ощущается как нативные (для конкретной платформы) выпадающие списки.

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

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

Это приложение создает экземпляр ttk.Combobox при инициализации, передавая заранее определенную последовательность значений, которые можно будет выбирать из списка:

import tkinter as tk

import tkinter.ttk as ttk



class App(tk.Tk):

    def __init__(self):

        super().__init__()

        self.title("Ttk Combobox")

        colors = ("Purple", "Yellow", "Red", "Blue")



        self.label = ttk.Label(self, text="Пожалуйста, выберите цвет")

        self.combo = ttk.Combobox(self, values=colors)

        btn_submit = ttk.Button(self, text="Разместить",

                                command=self.display_color)

        btn_clear = ttk.Button(self, text="Очистить",

                                command=self.clear_color)



        self.combo.bind("<>", self.display_color)



        self.label.pack(pady=10)

        self.combo.pack(side=tk.LEFT, padx=10, pady=5)

        btn_submit.pack(side=tk.TOP, padx=10, pady=5)

        btn_clear.pack(padx=10, pady=5)



    def display_color(self, *args):

        color = self.combo.get()

        print("Ваш выбор", color)



    def clear_color(self):

        self.combo.set("")



if __name__ == "__main__":

    app = App()

    app.mainloop()

Как работает виджет Combobox

Традиционно виджет ttk.Combobox добавляется в приложение через передачу экземпляра Tk в качестве первого параметра в конструктор. Параметр values определяет список выбираемых вариантов, которые будут отображаться по клику.

Также выполняется связывание виртуального события <<ComboboxSelected>> при выборе одного из значений списка:

        self.label = ttk.Label(self, text="Пожалуйста, выберите цвет")

        self.combo = ttk.Combobox(self, values=colors)

        btn_submit = ttk.Button(self, text="Разместить",

                                command=self.display_color)

        btn_clear = ttk.Button(self, text="Очистить",

                                command=self.clear_color)



        self.combo.bind("<<ComboboxSelected>>", self.display_color)

Тот же метод вызывается при клике по кнопке Submit, так что она получает значение, введенное пользователем.

display_color() принимает переменный список аргументов с помощью синтаксиса *, что позволяет безопасно обрабатывать опциональные аргументы. Это происходит, потому что событие передается внутрь при вызове через связывание. Однако функция не получает параметры при вызове через колбек кнопки.

Внутри этого метода мы получаем текущее значение Combobox с помощью метода get() и выводим его:

    def display_color(self, *args):

        color = self.combo.get()

        print("Ваш выбор", color)

Наконец, clear_color() очищает содержимое Combobox с помощью вызова set() с пустой строкой:

    def clear_color(self):

        self.combo.set("")

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

Класс ttk.Combobox расширяет ttk.Entry, который, в свою очередь, расширяет класс Entry из модуля tkinter.

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

combobox.insert(0, "Добавьте это в начало: ")

Вот этот код более понятен чем combobox.set("Добавьте это в начало: " + combobox.get()).

Инициализировать список, кортеж и словарь можно несколькими способами. Один из наиболее распространенных — присвоить соответствующие символы переменной. Для списка эти символы — [], для кортежа — (), а для словаря — {}. Если присвоить эти символы без значений внутри, то будут созданы соответствующие пустые структуры данных.

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

Где используется

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

• Списки: содержат значения. Ими могут быть числа, строки, имена и так далее:
  • Модели автомобилей;
  • Имена собак;
  • Посещенные страны;
  • Посетители магазина и так далее;
• Кортежи: этот тип данных очень похож на список, но с одним исключением. После создания кортежа его значения нельзя менять. Списки — изменяемые, а кортежи — нет. Это может понадобиться в определенных случаях для достижения безопасности или просто удобства. В кортежах могут, например, храниться:
  • Все месяцы года;
  • Дисциплины Олимпийских игр;
  • Штаты США;
    Важно только отметить, что кортежи не являются вообще неизменяемыми, ведь вы всегда можете переписать код, поменяв или удалив определенные значения. Речь идет о том, что значения не могут быть изменены после создания — во время работы программы.

• Словари — это пары из ключа и значения. Словари также являются изменяемыми. Это удобная структура данных, которая подходит для сохранения значения с определенными дополнительными параметрами, например:
  • Данные клиента включая список его покупок
  • Названия стран + их количество олимпийских медалей
  • Автомобильные бренды и их модели
  • Страны с количеством ДТП с летальным исходом
• Функции list() и dict() очень простые. Они помогают создавать соответствующие структуры данных.

Рекомендации по работе со структурами данных

1. List(), dict() и float() используют круглые скобки, потому что они являются функциями;
2. Скобки сами по себе представляют кортеж, и их не стоит путать со скобками в функциях, например, list();
3. При создании пустого списка нужно использовать квадратные, а не круглые скобки: [].

Функция №1: list()

У функции list() очень простой сценарий применения.

C помощью скобок создается список. После этого выводится переменная с присвоенным ей пустым списком. Выводится «[]», что указывает пусть и на пустой, но список. После этого выводится подтверждение того, что это действительно список.

>>> my_first_list = []

>>> print(my_first_list )

>>> print(type(my_first_list ))

[]

<class 'list'>

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

>>> my_first_list = list()

>>> print(my_first_list)

>>> print(type(my_first_list))

[]

<class 'list'>

Функция №2: dict()

Рассмотрим функцию dict(), с помощью которой можно создать словарь Python.

>>> my_first_dictionary = {}

>>> print(my_first_dictionary)

>>> print(type(my_first_dictionary))

{}

<class 'dict'>

И вот еще один пример создания пустого словаря. Тот же результат, но с помощью функции dict().

>>> my_first_dictionary = dict()

>>> print(my_first_dictionary)

>>> print(type(my_first_dictionary))

{}

<class 'dict'>

Функция №3: tuple()

Функция tuple() для создания кортежа Python. Пример с присваиванием переменной пустого кортежа.

>>> my_first_tuple = ()

>>> print(my_first_tuple)

>>> print(type(my_first_tuple))

()

<class 'tuple'>

И снова тот же результат, но уже с помощью функции tuple().

>>> my_first_tuple = tuple()

>>> print(my_first_tuple)

>>> print(type(my_first_tuple))

()

<class 'tuple'>

Советы:

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

Создадим список со значениями внутри.

>>> mylist = ["лыжные ботинки", "лыжи", "перчатки"]

>>> print(mylist)

>>> print(type(mylist))

["лыжные ботинки", "лыжи", "перчатки"]

<class 'list'>

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

Теперь создадим словарь с этими значениями.

>>> mydict = {"лыжные ботинки": 3, "лыжи": 2, "перчатки": 5}

>>> print(mydict)

>>> print(type(mydict))

{"лыжные ботинки": 3, "лыжи": 2, "перчатки": 5}

<class 'dict'>

В этом примере создается словарь. Он присвоен переменной mydict, которая состоит из 3 ключей: “лыжные ботинки”, “лыжи” и “перчатки”. Каждому ключу присвоено свое значение: 3, 2 и 5 соответственно.

Теперь создадим список со значениями разных типов.

>>> mylist = ["карабины", False, "порошок", 666, 25.25]

>>> print(mylist)

>>> print(type(mylist))

["карабины", False, "порошок", 666, 25.25]

<class 'list'>

В этом примере список включает 5 значений четырех разных типов: строка, булев тип, строка, целое число и число с плавающей точкой.

Наконец, создадим пример кортежа.

>>> mytuple = ("карабины", False, "порошок", 666, 25.25)

>>> print(mytuple)

>>> print(type(mytuple))

("карабины", False, "порошок", 666, 25.25)

<class 'tuple'>

Единственное отличие здесь в том, что используются круглые (), а не квадратные [] скобки.

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

Задачи к уроку

Попробуйте решить задачи к этому уроку для закрепления знаний.

1. Создайте пустой список, определите его тип и выведите в консоль.

# данный код
gift_list=
answer_1=
print(answer_1)
# требуемый вывод:
# <class 'list'>

2. Допишите код, чтобы gift_list был заполненным кортежем. Порядок элементов значения не имеет.

gifts=
print(gifts)
# требуемый вывод:
# ("Камера", "Наушники", "Часы")

3. Исправьте ошибки в коде, для получения требуемого вывода.

stats = {1 - 10, 220, 3 - 30, 4 - 40, 5 - 50 6 - 60}
print(stat)
# требуемый вывод:
# {1: 10, 2: 20, 3: 30, 4: 40, 5: 50, 6: 60}

Файл со всем заданиями: https://gitlab.com/PythonRu/python-dlya-nachinayushih/-/blob/master/lesson_5.py.

Тест по конвертации типов данных

Пройдите тест к этому уроку для проверки знаний. В тесте 5 вопросов, количество попыток неограниченно.

tuple1 = (1120, 'a')
print(tuple1)

target = ["1"]
print(target)

mylist = (2019, 2020, 2021)
print(mylist)

Если нашли ошибку, опечатку или знаете как улучшить этот урок, пишите на почту. Ее можно найти внизу сайта.

Определение пересечений между элементами

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

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

Поскольку код во многом повторяет предыдущий, отметим лишь те части кода, которые отвечают за создание новых прямоугольников и вызов метода canvas.find_overlapping():

import tkinter as tk



class App(tk.Tk):

    def __init__(self):

        super().__init__()

        self.title("Обнаружение пересечений между предметами")



        self.canvas = tk.Canvas(self, bg="white")

        self.canvas.pack()

        self.update()

        self.width = w = self.canvas.winfo_width()

        self.height = h = self.canvas.winfo_height()



        pos = (w / 2 - 15, h / 2 - 15, w / 2 + 15, h / 2 + 15)

        self.item = self.canvas.create_rectangle(*pos, fill="blue")

        positions = [(60, 60), (w - 60, 60), (60, h - 60), (w - 60, h - 60)]

        for x, y in positions:

            self.canvas.create_rectangle(x - 10, y - 10, x + 10, y + 10,

                                         fill="green")



        self.pressed_keys = {}

        self.bind("<KeyPress>", self.key_press)

        self.bind("<KeyRelease>", self.key_release)

        self.process_movements()



    def key_press(self, event):

        self.pressed_keys[event.keysym] = True



    def key_release(self, event):

        self.pressed_keys.pop(event.keysym, None)



    def process_movements(self):

        all_items = self.canvas.find_all()

        for item in filter(lambda i: i is not self.item, all_items):

            self.canvas.itemconfig(item, fill="green")



        x0, y0, x1, y1 = self.canvas.coords(self.item)

        items = self.canvas.find_overlapping(x0, y0, x1, y1)

        for item in filter(lambda i: i is not self.item, items):

            self.canvas.itemconfig(item, fill="yellow")



        off_x, off_y = 0, 0

        speed = 3

        if 'Right' in self.pressed_keys:

            off_x += speed

        if 'Left' in self.pressed_keys:

            off_x -= speed

        if 'Down' in self.pressed_keys:

            off_y += speed

        if 'Up' in self.pressed_keys:

            off_y -= speed



        pos_x = x0 + (x1 - x0) / 2 + off_x

        pos_y = y0 + (y1 - y0) / 2 + off_y

        if 0 <= pos_x <= self.width and 0 <= pos_y <= self.height:

            self.canvas.move(self.item, off_x, off_y)



        self.after(10, self.process_movements)



if __name__ == "__main__":

    app = App()

    app.mainloop()

Как определяются пересечения

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

    def process_movements(self):

        all_items = self.canvas.find_all()

        for item in filter(lambda i: i is not self.item, all_items):

            self.canvas.itemconfig(item, fill="green")

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

    def process_movements(self):

        # ...
        x0, y0, x1, y1 = self.canvas.coords(self.item)

        items = self.canvas.find_overlapping(x0, y0, x1, y1)

        for item in filter(lambda i: i is not self.item, items):

            self.canvas.itemconfig(item, fill="yellow")

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

Если нужно определить, когда движущийся элемент полностью перекрывает другой (а не частично), то стоит воспользоваться методом canvas.find_enclosed() вместо canvas.find_overlapping() с теми же параметрами.

Удаление элементов с полотна

Помимо добавления и изменения элементов полотна их также можно удалять с помощью метода delete() класса Canvas. Хотя в принципах его работы нет каких-либо особенностей, существуют кое-какие паттерны, которые будут рассмотрены дальше.

Стоит учитывать, что чем больше элементов на полотне, тем дольше Tkinter будет рендерить виджет. Таким образом важно удалять неиспользуемые для улучшения производительности.

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

Чтобы случайным образом размещать элементы на полотне, будем генерировать координаты с помощью функции randint модуля random. Цвет элемента будет выбираться случайным образом с помощью вызова choice и определенного набора цветов.

После генерации элементы можно будет удалить с помощью обработчика on_click или кнопки Clearitems, которая, в свою очередь, вызывает функцию обратного вызова clear_all. Внутри этот метод вызывает canvas.delete() с нужными параметрами:

import random

import tkinter as tk



class App(tk.Tk):

    colors = ("red", "yellow", "green", "blue", "orange")



    def __init__(self):

        super().__init__()

        self.title("Удаление элементов холста")



        self.canvas = tk.Canvas(self, bg="white")

        frame = tk.Frame(self)

        generate_btn = tk.Button(frame, text="Создавать элементы",

                                 command=self.generate_items)

        clear_btn = tk.Button(frame, text="Удалить элементы",

                              command=self.clear_items)



        self.canvas.pack()

        frame.pack(fill=tk.BOTH)

        generate_btn.pack(side=tk.LEFT, expand=True, fill=tk.BOTH)

        clear_btn.pack(side=tk.LEFT, expand=True, fill=tk.BOTH)



        self.update()

        self.width = self.canvas.winfo_width()

        self.height = self.canvas.winfo_height()



        self.canvas.bind("<Button-1>", self.on_click)

        self.generate_items()



    def on_click(self, event):

        item = self.canvas.find_withtag(tk.CURRENT)

        self.canvas.delete(item)



    def generate_items(self):

        self.clear_items()

        for _ in range(10):

            x = random.randint(0, self.width)

            y = random.randint(0, self.height)

            color = random.choice(self.colors)

            self.canvas.create_oval(x, y, x + 20, y + 20, fill=color)



    def clear_items(self):

        self.canvas.delete(tk.ALL)



if __name__ == "__main__":

    app = App()

    app.mainloop()

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

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

В обработчике on_click() можно увидеть пример удаления элемента по идентификатору:

    def on_click(self, event):

        item = self.canvas.find_withtag(tk.CURRENT)

        self.canvas.delete(item)

Стоит также отметить, что если сейчас кликнуть по пустой точке, то canvas.find_withtag(tk.CURRENT) вернет None, но когда это значение будет передано в canvas.delete(), то ошибки не будет. Это объясняется тем, что параметр None не совпадает ни с одним идентификатором или тегом. Таким образом это валидный параметр, хоть в результате никакое действие и не выполняется.

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

    def clear_items(self):

        self.canvas.delete(tk.ALL)

Можно обратить внимание на то, что тег ALL работает «из коробки», поэтому его не нужно добавлять каждому элементу полотна.

Связывание событий с элементами полотна

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

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

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

import tkinter as tk



class App(tk.Tk):

    def __init__(self):

        super().__init__()

        self.title("Drag and drop")



        self.dnd_item = None

        self.canvas = tk.Canvas(self, bg="white")

        self.canvas.pack()



        self.canvas.create_rectangle(30, 30, 60, 60, fill="green",

                                     tags="draggable")

        self.canvas.create_oval(120, 120, 150, 150, fill="red",

                                tags="draggable")



        self.canvas.tag_bind("draggable", "<ButtonPress-1>",

                             self.button_press)

        self.canvas.tag_bind("draggable", "<Button1-Motion>",

                             self.button_motion)



    def button_press(self, event):

        item = self.canvas.find_withtag(tk.CURRENT)

        self.dnd_item = (item, event.x, event.y)



    def button_motion(self, event):

        x, y = event.x, event.y

        item, x0, y0 = self.dnd_item

        self.canvas.move(item, x - x0, y - y0)

        self.dnd_item = (item, x, y)



if __name__ == "__main__":

    app = App()

    app.mainloop()

Как работает drag and drop

Для связывания событий с элементами используется метод tag_bind() из класса Canvas. Это добавляет связывание для всех элементов, которые соответствуют конкретному элементу — тегу draggable в этом случае.

И хотя метод называется tag_bind() вместо тега в него можно передавать также идентификатор:

        self.canvas.tag_bind("draggable", "<ButtonPress-1>",

                             self.button_press)

        self.canvas.tag_bind("draggable", "<Button1-Motion>",

                             self.button_motion)

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

Метод button_press() — это обработчик, который запускается после нажатия на элемент. Традиционный паттерн для получения соответствующего элемента — вызов canvas.find_withtag(tk.CURRENT).

Идентификатор элемента, а также координаты x и y события click хранятся в поле dnd_item. Эти значения позже будут использованы для перемещения элемента в соответствии с движением мыши:

   def button_press(self, event):

        item = self.canvas.find_withtag(tk.CURRENT)

        self.dnd_item = (item, event.x, event.y)

Метод button_motion() обрабатывает события движения мыши до тех пор, пока зажата основная кнопка.

Для определения дистанции, на которую должен быть перемещен элемент, нужно вычислить разницу текущей позиции с предыдущими координатами. Эти значения передаются в метод canvas.move() и снова сохраняются в поле dnd_item:

    def button_motion(self, event):

        x, y = event.x, event.y

        item, x0, y0 = self.dnd_item

        self.canvas.move(item, x - x0, y - y0)

        self.dnd_item = (item, x, y)

Существуют вариации этой drag & drop функциональности, которые также задействуют обработчик последовательности <ButtonRelease-1>. Она сбрасывает текущий элемент.

Однако использовать его необязательно, потому что после того как это событие происходит, связывание <Button1-Motion> не запустится до очередного клика по элементу. Это также помогает избежать проверки того, не является ли None значением dnd_item в начале обработчика button_motion().

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

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

final_x, final_y = pos_x + off_x, pos_y + off_y

if 0 <= final_x <= canvas_width and 0 <= final_y <= canvas_height:

        canvas.move(item, off_x, off_y)

Рендер полотна в файл PostScript

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

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

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

import tkinter as tk

from lesson_18.drawing import LineForm



class App(tk.Tk):

    def __init__(self):

        super().__init__()

        self.title("Базовый холст")



        self.line_start = None

        self.form = LineForm(self)

        self.render_btn = tk.Button(self, text="Render canvas",

                                    command=self.render_canvas)

        self.canvas = tk.Canvas(self, bg="white")

        self.canvas.bind("<Button-1>", self.draw)



        self.form.grid(row=0, column=0, padx=10, pady=10)

        self.render_btn.grid(row=1, column=0)

        self.canvas.grid(row=0, column=1, rowspan=2)



    def draw(self, event):

        x, y = event.x, event.y

        if not self.line_start:

            self.line_start = (x, y)

        else:

            x_origin, y_origin = self.line_start

            self.line_start = None

            line = (x_origin, y_origin, x, y)

            arrow = self.form.get_arrow()

            color = self.form.get_color()

            width = self.form.get_width()

            self.canvas.create_line(*line, arrow=arrow,

                                    fill=color, width=width)



    def render_canvas(self):

        self.canvas.postscript(file="output.ps", colormode="color")



if __name__ == "__main__":

    app = App()

    app.mainloop()

Как работает рендеринг в .ps

Основное нововведение — это кнопка Render canvas с функцией обратного вызова render_canvas().

Она вызывает метод postscript() для экземпляра canvas с аргументами file и colormode. Эти параметры определяют путь к расположению файла, а также информацию о цвете. Вторым параметром может быть color для полностью цветного вывода, gray — для использования оттенков серого или mono — для конвертации цветов в черный и белый:

def render_canvas(self):

    self.canvas.postscript(file="output.ps", colormode="color")

Все параметры, которые можно передать в postscript(), стоит искать в официальной документации Tk/Tcl по ссылке https://www.tcl.tk/m an/tcl8.6/TkCmd/canvas.htm#M61. Стоит напомнить, что PostScript — язык печати, поэтому большая часть его параметров касается настроек страницы.

Поскольку файлы PostScript не так популярны, как другие форматы файлов, возможно, возникнет необходимость конвертировать готовый файл во что-то более знакомое — например, PDF.

Для этого нужен сторонний софт, такой как, например, Ghostscript, который распространяется по лицензии GNU APGL. Интерпретатор и инструмент рендеринга можно вызвать из программы для автоматической конвертации результатов PostScript в PDF.

Установить программу можно с сайта https://w ww.ghostscript.com/download/gsdnld.html. Дальше нужно только добавить папки bin и lib из установки в переменную path операционной системы.

Затем остается изменить приложение Tkinter для вызова программы ps2pdf в качестве подпроцеса и удалить файл output.ps после завершения выполнения:

import os

import subprocess

import tkinter as tk



class App(tk.Tk):

    # ...



    def render_canvas(self):

        output_filename = "output.ps"

        self.canvas.postscript(file=output_filename, colormode="color")

        process = subprocess.run(["ps2pdf", output_filename, "output.pdf"],

                                               shell=True)

        os.remove(output_filename)

Также в этом материале рассмотрим другие функции, которые могут помочь в процессе конвертации типа данных. Некоторые из них — это int(), float() или str().

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

Где используется

• Функция type() используется для определения типа переменной.
• Это очень важная информация, которая часто нужна программистам.
• Например, программа может собирать данные, и будет необходимость знать тип этих данных.
• Часто требуется выполнять определенные операции с конкретными типами данных: например, арифметические вычисления на целых или числах с плавающей точкой или поиск символа в строках.
• Иногда будут условные ситуации, где с данными нужно будет обращаться определенным образом в зависимости от их типа.
• Будет и много других ситуаций, где пригодится функция type().

Рекомендации по работе с типами данных

1. Типы int и float можно конвертировать в str, потому что строка может включать не только символы алфавита, но и цифры.
2. Значения типа str всегда представлены в кавычках, а для int, float и bool они не используются.
3. Строку, включающую символы алфавита, не выйдет конвертировать в целое или число с плавающей точкой.

Примеры конвертации типов данных

>>> game_count = 21

>>> print(type(game_count))

<class 'int'>

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

>>> person1_weight = 121.25

>>> print(type(person1_weight))

<class 'float'>

Функция int()

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

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

Из-за этих кавычек переменная регистрирует данные как строку. Дальше следуют команды print для вывода оригинального типа и значения переменной, а затем — использование функции int() для конвертации переменной к типу int.

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

Можно обратить внимание на то, что после конвертации выведенные данные не отличаются от тех, что были изначально. Так что без использования type() вряд ли удастся увидеть разницу.

>>> inc_count = "2256"

>>> print(type(inc_count))

>>> print(inc_count)

>>> inc_count = int(inc_count)

>>> print(type(inc_count))

>>> print(inc_count)

<class 'str'>

2256

<class 'int'>

2256

Функция float()

Функция float() используется для конвертации данных из других типов в тип числа с плавающей точкой.

>>> inc_count = "2256"

>>> print(type(inc_count))

>>> print(inc_count)

>>> inc_count = float(inc_count)

>>> print(type(inc_count))

>>> print(inc_count)

<class 'str'>

2256

<class 'float'>

2256.0

Функция str()

Как и int() с float() функция str() помогает конвертировать данные в строку из любого другого типа.

>>> inc_count = 2256

>>> print(type(inc_count))

>>> print(inc_count)

>>> inc_count = str(inc_count)

>>> print(type(inc_count))

>>> print(inc_count)

<class 'int'>

2256

<class 'str'>

2256

Советы:

1. Не любой тип можно конвертировать в любой другой. Например, если строка состоит только из символов алфавита, то при попытке использовать с ней int() приведет к ошибке.
2. Зато почти любой символ или число можно привести к строке. Это будет эквивалентно вводу цифр в кавычках, поскольку именно так создаются строки в Python.

Как можно увидеть в следующем примере, поскольку переменная состоит из символов алфавита, Python не удается выполнить функцию int(), и он возвращает ошибку.

>>> my_data = "Что-нибудь"

>>> my_data = int(my_data)

ValueError: invalid literal for int() with base 10: 'Что-нибудь'

Задачи к уроку

Попробуйте решить задачи к этому уроку для закрепления знаний.

1. Измените и дополните код, что бы переменная salary_type хранила результат функции type() со значением int.

# данный код
salary = "50000"
salary_type = 
print(salary_type)
# требуемый вывод:
# <class 'int'>

2. Исправьте ошибку в коде, что бы получить требуемый вывод.

# данный код
mark = int("5+")
print(mark, "баллов")
# требуемый вывод:
# 5+ баллов

3. Конвертируйте переменные и введите только целые числа через дефис.

# данный код
score1 = 50.5648
score2 = 23.5501
score3 = 96.560
print()
# требуемый вывод:
# 50-23-96

Файл со всем заданиями: https://gitlab.com/PythonRu/python-dlya-nachinayushih/-/blob/master/lesson_4.py.

Тест по конвертации типов данных

Пройдите тест к этому уроку для проверки знаний. В тесте 5 вопросов, количество попыток неограниченно.

price = 68.5
print(int(price))

x = int("2.6 odds")
print(x)

Если нашли ошибку, опечатку или знаете как улучшить этот урок, пишите на почту. Ее можно найти внизу сайта.

Добавление геометрических фигур на полотно

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

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

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

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

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

import tkinter as tk

from functools import partial



class App(tk.Tk):

    shapes = ("прямоугольник", "овал", "дуга")

    def __init__(self):

        super().__init__()

        self.title("Отрисовка стандартных элементов")



        self.start = None

        self.shape = None

        self.canvas = tk.Canvas(self, bg="white")

        frame = tk.Frame(self)

        for shape in self.shapes:

            btn = tk.Button(frame, text=shape.capitalize())

            btn.config(command=partial(self.set_selection, btn, shape))

            btn.pack(side=tk.LEFT, expand=True, fill=tk.BOTH)



        self.canvas.bind("<Button-1>", self.draw_item)

        self.canvas.pack()

        frame.pack(fill=tk.BOTH)



    def set_selection(self, widget, shape):

        for w in widget.master.winfo_children():

            w.config(relief=tk.RAISED)

        widget.config(relief=tk.SUNKEN)

        self.shape = shape



    def draw_item(self, event):

        x, y = event.x, event.y

        if not self.start:

            self.start = (x, y)

        else:

            x_origin, y_origin = self.start

            self.start = None

            bbox = (x_origin, y_origin, x, y)

            if self.shape == "прямоугольник":

                self.canvas.create_rectangle(*bbox, fill="blue",

                                             activefill="yellow")

            elif self.shape == "овал":

                self.canvas.create_oval(*bbox, fill="red",

                                        activefill="yellow")

            elif self.shape == "дуга":

                self.canvas.create_arc(*bbox, fill="green",

                                       activefill="yellow")



if __name__ == "__main__":

    app = App()

    app.mainloop()

Как работает рисование фигур

Для сохранения возможности динамически выбирать тип элемента создаются кнопки для каждого из представленных. Они создаются за счет перебора кортежа shapes.

Каждая функция обратного вызова определяется с помощью функции partial из модуля functools. Это позволяет заморозить экземпляр Button и текущую форму цикла в качестве аргументов функции обратного вызова для каждой кнопки:

for shape in self.shapes:

    btn = tk.Button(frame, text=shape.capitalize())

    btn.config(command=partial(self.set_selection, btn, shape))

    btn.pack(side=tk.LEFT, expand=True, fill=tk.BOTH)

Функция обратного вызова set_section() помечает нажатую кнопку с помощью SUNKEN и сохраняет выбор в поле shape.

Остальные кнопки настраиваются со стандартным рельефом RAISED. Это делается с помощью перехода к родителю, который доступен в поле master текущего виджета. Из него и можно получить все дочерние виджеты, используя метод winfo_children():

def set_selection(self, widget, shape):

    for w in widget.master.winfo_children():

        w.config(relief=tk.RAISED)

    widget.config(relief=tk.SUNKEN)

    self.shape = shape

Обработчик draw_item() сохраняет координаты первого клика каждой пары событий, чтобы нарисовать элемент при повторном клике по полотну.

В зависимости от типа поля shape вызывается один из следующих методов для отображения соответствующего элемента:

• canvas.create_rectangele(x0, y0, x1, y,1 **options) – рисует прямоугольник, чей левый верхний угол расположен по координатам (x0, y0), а правый нижний – (x1, y1).

• canvas.create_oval(x0, y0, x1, y1, **options) – рисует эллипс, который вписывается в прямоугольник с координатами (x0, y0) и (x1, y1).

• canvas.create_arc(x0, y0, x1, y1, **options) – рисует четверть эллипса, который поместится в прямоугольник с координатами (x0, y0) и (x1, y1).

Поиск элементов по их положению

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

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

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

Для нахождения ближайшего к курсору элемента координаты мыши передаются методу canvas.find_closest(), который и определяют идентификатор ближайшего элемента.

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

import tkinter as tk



class App(tk.Tk):

    def __init__(self):

        super().__init__()

        self.title("Поиск предметов на canvas")



        self.current = None

        self.canvas = tk.Canvas(self, bg="white")

        self.canvas.bind("<Motion>", self.mouse_motion)

        self.canvas.pack()



        self.update()

        w = self.canvas.winfo_width()

        h = self.canvas.winfo_height()

        positions = [(60, 60), (w-60, 60), (60, h-60), (w-60, h-60)]

        for x, y in positions:

            self.canvas.create_rectangle(x-10, y-10, x+10, y+10,

                                         fill="blue")



    def mouse_motion(self, event):

        self.canvas.itemconfig(self.current, fill="blue")

        self.current = self.canvas.find_closest(event.x, event.y)

        self.canvas.itemconfig(self.current, fill="yellow")



if __name__ == "__main__":

    app = App()

    app.mainloop()

Как работает поиск элементов

При инициализации приложения создается полотно и определяется поле current для сохранения ссылки на текущий подсвеченный элемент. Также обрабатываются события "<Motion>" с помощью метода mouse_motion():

self.current = None

self.canvas = tk.Canvas(self, bg="white")

self.canvas.bind("<Motion>", self.mouse_motion)

self.canvas.pack()

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

self.update()

w = self.canvas.winfo_width()

h = self.canvas.winfo_height()

positions = [(60, 60), (w-60, 60), (60, h-60), (w-60, h-60)]

for x, y in positions:

    self.canvas.create_rectangle(x-10, y-10, x+10, y+10,

      fill="blue")

Обработчик mouse_motion() задает цвет текущего элемента обратно в синий и сохраняет идентификатор нового. Наконец, цвет fill этого элемента становится желтым:

def mouse_motion(self, event):

    self.canvas.itemconfig(self.current, fill="blue")

    self.current = self.canvas.find_closest(event.x, event.y)

    self.canvas.itemconfig(self.current, fill="yellow")

Изначально при вызове mouse_motion() ошибок нет, а поле current равно None, поскольку это также валидное значение для параметра itemconfig. Просто в таком случае действия не выполняются.

Перемещение элементов в canvas

После размещения элементы полотна могут быть перемещены – для этого им не нужно задавать абсолютные координаты.

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

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

Чтобы элемент не ушел за пределы экрана, ограничим перемещение в пределах полотна:

import tkinter as tk



class App(tk.Tk):

    def __init__(self):

        super().__init__()

        self.title("Перемещение элементов холста")



        self.canvas = tk.Canvas(self, bg="white")

        self.canvas.pack()

        self.update()

        self.width = self.canvas.winfo_width()

        self.height = self.canvas.winfo_height()



        self.item = self.canvas.create_rectangle(30, 30, 60, 60,

                                                 fill="blue")

        self.pressed_keys = {}

        self.bind("<KeyPress>", self.key_press)

        self.bind("<KeyRelease>", self.key_release)

        self.process_movements()



    def key_press(self, event):

        self.pressed_keys[event.keysym] = True



    def key_release(self, event):

        self.pressed_keys.pop(event.keysym, None)



    def process_movements(self):

        off_x, off_y = 0, 0

        speed = 3

        if 'Right' in self.pressed_keys:

            off_x += speed

        if 'Left' in self.pressed_keys:

            off_x -= speed

        if 'Down' in self.pressed_keys:

            off_y += speed

        if 'Up' in self.pressed_keys:

            off_y -= speed



        x0, y0, x1, y1 = self.canvas.coords(self.item)

        pos_x = x0 + (x1 - x0) / 2 + off_x

        pos_y = y0 + (y1 - y0) / 2 + off_y

        if 0 <= pos_x <= self.width and 0 <= pos_y <= self.height:

            self.canvas.move(self.item, off_x, off_y)



        self.after(10, self.process_movements)



if __name__ == "__main__":

    app = App()

    app.mainloop()

Как работает перемещение элементов

Для обработки клавиш стрелок на клавиатуре свяжем "<KeyPress>" и "<KeyRelease>" с экземпляром приложения. Нажатые сейчас клавиши сохраняются в словарь pressed_keys:

def __init__(self):

    # ...

    self.pressed_keys = {}

    self.bind("<KeyPress>", self.key_press)

    self.bind("<KeyRelease>", self.key_release)



def key_press(self, event):

    self.pressed_keys[event.keysym] = True



def key_release(self, event):

    self.pressed_keys.pop(event.keysym, None)

Такой подход лучше отдельного связывания клавиш "<Up>", "<Down>", "<Right>" и "<Left>", потому что они вызывали бы каждый из обработчиков только при обработке событий клавиатуры. В результате элементы бы «перепрыгивали» с одного положения на другое, а не плавно перемещались.

Последний элемент инициализации экземпляра App – вызов process_movements(), который запускает обработку движения элемента полотна.

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

def process_movements(self):

    off_x, off_y = 0, 0

    speed = 3

    if 'Right' in self.pressed_keys:

        off_x += speed

    if 'Left' in self.pressed_keys:

        off_x -= speed

    if 'Down' in self.pressed_keys:

        off_y += speed

    if 'Up' in self.pressed_keys:

        off_y -= speed

После этого мы получаем положение текущего элемента с помощью вызова canvas.coords() и распаковки пары точек, которые формируют контейнер из четырех переменных.

Центр каждого элемента вычисляется за счет сложения x и y верхнего левого угла с половиной ширины и высоты. Результат, плюс сдвиг по каждой оси, соответствует финальному положению элемента после перемещения:

x0, y0, x1, y1 = self.canvas.coords(self.item)

pos_x = x0 + (x1 - x0) / 2 + off_x

pos_y = y0 + (y1 - y0) / 2 + off_y

После этого мы проверяем, находимся ли мы в пределах полотна. Для этого используем встроенную в Python поддержку связанных операторов сравнения:

if 0 <= pos_x <= self.width and 0 <= pos_y <= self.height:

    self.canvas.move(self.item, off_x, off_y)

Наконец, этот метод планирует сам себя с задержкой в 10 миллисекунд с помощью вызова self.after(10, self.process_movements). Таким образом достигается эффект собственного основного цикла внутри реального цикла Tkinter.

Вас может заинтересовать, почему в этом примере использовался after(), а не after_idle() для планирования метода process_movements().

Это может казаться корректным подходом, поскольку других событий для обработки помимо перерисовки полотна и обработки событий клавиатуры нет, и нет необходимости добавлять задержку между вызовами process_movements(), если нет событий интерфейса в процессе ожидания.

Однако при использовании after_idle элементы бы перемещались со скоростью, зависящей от скорости компьютера. Это значит, что более быстрая система вызывала бы process_movements() больше раз за один и тот же промежуток времени.

С помощью минимальной фиксированной задержки есть возможность одинаково обрабатывать элементы на разных машинах.

1. int — этот тип данных состоит из целых чисел.
2. float — этот тип используется для работы с десятичными числами.
3. str — переменная с типом str (от string — строка) хранит данные в виде текстовых строк.

Где используется

• Данные используются в программирования повсеместно, поэтому важно понимать, с какими именно вы сейчас работаете, и какие последствия это накладывает на процесс взаимодействия. Существует множество типов данных, но только некоторые из них используются каждым программистом.
• int — тип данных для работы с целыми числами, а float — для работы с числами с плавающей точкой. str хранит данные в строковом формате и может включать буквы, символы и цифры. В то же время в int и float использовать символы нельзя — только числа.
• тип bool состоит всего из двух значений: True или False. Важно отметить, что при инициализации или присваивании значения типа bool True или False нужно вводить без кавычек. Строковые же значения наоборот всегда заключены в кавычки.

Рекомендации по работе с типами данных

1. Нужно всегда помнить о следующих особенностях типов данных: их форматах, областях применения и возможностях.
2. Строковые значения всегда заключены в кавычки, тогда как int, float или bool записываются без них.

Примеры работы с разными типами данных

>>> my_сars_number = 3

>>> my_сars_color = "Бронза, зеленый, черный"

>>> print(my_сars_number)

>>> print(my_сars_color)

3

Бронза, зеленый, черный

В этом примере были созданы переменные двух типов данных, после чего они были выведены на экран. my_сars_number — это целое число (int), а my_сars_color — строка (str).

Рассмотрим порядок выполнения этого года:

1. В первой строке создается переменная my_сars_number, и ей присваивается значение 3. Это внутренний процесс, поэтому увидеть результат этой операции не выйдет, только если не попробовать вывести значение переменной.
2. На второй строке создается еще одна переменная, которой присваивается свое значение.
3. На 3 и 4 строках ранее созданные переменные выводятся на экран.

Советы:

А зачем типы данных вообще нужны в Python? Этот вопрос наверняка будет интересовать в первую очередь начинающих программистов.

1. Если подумать о внутреннем устройстве компьютера, то память в нем занимается распределением, а центральный процессор отвечает за вычисления. Благодаря типам данных компьютер знает, как распределять память, для чего ее использовать и какие операции выполнять с каким типом данных.
   
2. Отличное сравнение в данном случае — контейнеры для продуктов. Типы данных можно воспринимать как разные контейнеры. В зависимости от типа еды, ее нужно размещать в соответствующих емкостях.
   
3. С другой стороны, если конкретные данные — это целое число, то компьютер может не думать о конвертации их в нижний или верхний регистр, поиске гласных и так далее. Если строка — то здесь уже арифметические операции, поиск квадратного корня, конвертация и прочие команды становятся нерелевантными.

Создадим число с плавающей точкой.

>>> miami_temp_today = 103.40

>>> print(miami_temp_today)

103.4

В этом примере создаем число с плавающей точкой и выводим его на экране.

Продвинутые концепции

В Python есть и много других типов данных, например:

• байты;
• комплексные числа;
• булевые значения.

Есть даже и другие значения в других областях: дата, время, GPS-координаты и так далее. В будущем полезно использовать их особенно в крупных проектах. Но пока что остановимся на базовых.

Посмотрим на булевый тип. Это довольно простая концепция, но более сложный тип данных. Основная сложность в том, что мы не сталкиваемся с таким типом в реальном мире, и поэтому порой его сложновато воспринимать. Булевый тип можно воспринимать как переключатель. Он может быть либо включенным, либо выключенным. В Python это либо True, либо False.

Важно запомнить, что значения этого типа не должны быть заключены в кавычки. Это их основное отличие от строк. По сути, True и "True" — это два разных типа данных в Python: булевое и строка.

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

В следующем примере может показаться, что используется строка, но на самом деле это значение булевого типа. Оно может быть либо True, либо False.

>>> hungry_or_not = True

>>> print(hungry_or_not)

True

Задачи к уроку

Попробуйте решить задачи к этому уроку для закрепления знаний.

1. Присвойте переменной целое число и получите вывод <class 'int'>.

Функция type() возвращает тип объекта. Для решения задачи изменять нужно только первую строку.

# данный код
current_month =
type_var = type(current_month)
print(type_var)
# требуемый вывод:
# <class 'int'>

2. Исправьте ошибки в коде, что бы получить требуемый вывод.

# данный код
polar_radius_title = "Радиус" "Земли"
polar_radius_float = 6378,1 
print(polar_radius_title, polar_radius_float)
# требуемый вывод:
# Радиус Земли 6378.1

3. Создайте переменные, что бы получить требуемый вывод.

# данный код
str_type, int_type, float_type, bool_type = 
print("Типы данных: ", end="")
print(type(str_type), type(int_type, type(float_type), type(bool_type), sep=",")
# требуемый вывод:
# Типы данных: <class 'str'>, <class 'int'>, <class 'float'>, <class 'bool'>

Файл со всем заданиями: https://gitlab.com/PythonRu/python-dlya-nachinayushih/-/blob/master/lesson_3.py.

Тест по типам данных