Делитель, также известный как фактор или множитель, — это такое целое число m, на которое n делится без остатка. Например, делителями числа 12 являются 1, 2, 3, 4, 6 и 12.

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

Простейший подход

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

def get_all_divisors_brute(n):
    for i in range(1, int(n / 2) + 1):
        if n % i == 0:
            yield i
    yield n

На деле нам нужно дойти только до n/2, потому что все, что больше этого значения, гарантировано не может быть делителем n — если вы разделите n на что-то большее, чем n/2, результат не будет целым числом.

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

Факторизация

В моем проекте я работал в основном с факториалами. Факториал числа n, обозначаемый n! — это произведение всех целых чисел от 1 до n включительно. Например:

8! = 8 × 7 × 6 × 5 × 4 × 3 × 2 × 1

Поскольку факториалы состоят преимущественно из небольших множителей, я решил попробовать получить список делителей, определив сначала наименьшие из них. В частности, я искал простые множители, то есть те, которые также являются простыми числами. (Простое число — это число, единственными делителями которого являются оно само и 1. Например, 2, 3 и 5 являются простыми, а 4 и 6 — нет).

Вот функция, которая находит простые делители числа n:

def get_prime_divisors(n):
    i = 2
    while i * i <= n:
        if n % i == 0:
            n /= i
            yield i
        else:
            i += 1

    if n > 1:
        yield n

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

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

8! = 2^7 × 3^2 × 5 × 7

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

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

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

Переход от факторизации к делителям

Для начала разложим исходное число на простые множители с указанием «кратности», то есть мы должны получить список всех множителей и количество раз, которое каждый из них встречается в факторизации:

import collections

def get_all_divisors(n):
    primes = get_prime_divisors(n)

    primes_counted = collections.Counter(primes)

    ...

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

def get_all_divisors(n):
    ...
    divisors_exponentiated = [
        [div ** i for i in range(count + 1)]
        for div, count in primes_counted.items()
    ]

Например, для 8! представленный код выдаст нам следующее:

[
    [1, 2, 4, 8, 16, 32, 64, 128],  // 2^0, 2^1, ..., 2^7
    [1, 3, 9],  // 3^0, 3^1, 3^2
    [1, 5],
    [1, 7],
]

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

import itertools

def calc_product(iterable):
    acc = 1
    for i in iterable:
        acc *= i
    return acc

def get_all_divisors(n):
    ...

    for prime_exp_combination in itertools.product(*divisors_exponentiated):
        yield calc_product(prime_exp_combination)

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

Собираем все вместе

Сложив все это, мы получим следующую функцию для вычисления делителей n:

import collections
import itertools


def get_prime_divisors(n):
    i = 2
    while i * i <= n:
        if n % i == 0:
            n /= i
            yield i
        else:
            i += 1

    if n > 1:
        yield n


def calc_product(iterable):
    acc = 1
    for i in iterable:
        acc *= i
    return acc


def get_all_divisors(n):
    primes = get_prime_divisors(n)

    primes_counted = collections.Counter(primes)

    divisors_exponentiated = [
        [div ** i for i in range(count + 1)]
        for div, count in primes_counted.items()
    ]

    for prime_exp_combination in itertools.product(*divisors_exponentiated):
        yield calc_product(prime_exp_combination)

print(list(get_all_divisors(40320))) # 8!

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

Сначала давайте вкратце рассмотрим, что такое список в Python и как найти в нем максимальное значение или просто наибольшее число.

Список в Python

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

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

list1 = ["Виктор", "Артем", "Роман"]
list2 = [16, 78, 32, 67]
list3 = ["яблоко", "манго", 16, "вишня", 3.4]

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

1. Встроенная функция max()
2. Метод грубой силы (перебора)
3. Функция reduce()
4. Алгоритм Heap Queue (очередь с приоритетом)
5. Функция sort()
6. Функция sorted()
7. Метод хвостовой рекурсии

№1 Нахождение максимального значения с помощью функции max()

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

В приведенном ниже примере список передается функции max в качестве аргумента.

list1 = [3, 2, 8, 5, 10, 6]
max_number = max(list1)
print("Наибольшее число:", max_number)

Наибольшее число: 10

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

list1 = ["Виктор", "Артем", "Роман"]
max_string = max(list1, key=len)
print("Самая длинная строка:", max_string)

Самая длинная строка: Виктор

№2 Поиск максимального значения перебором

Это самая простая реализация, но она немного медленнее, чем функция max(), поскольку мы используем этот алгоритм в цикле.

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

def large(arr): 
    max_ = arr[0]
    for ele in arr:
        if ele > max_:
           max_ = ele
    return max_ 


list1 = [1,4,5,2,6]
result = large(list1)
print(result)  # вернется 6

№3 Нахождение максимального значения с помощью функции reduce()

В функциональных языках reduce() является важной и очень полезной функцией. В Python 3 функция reduce() перенесена в отдельный модуль стандартной библиотеки под названием functools. Это решение было принято, чтобы поощрить разработчиков использовать циклы, так как они более читабельны. Рассмотрим приведенный ниже пример использования reduce() двумя разными способами.

В этом варианте reduce() принимает два параметра. Первый — ключевое слово max, которое означает поиск максимального числа, а второй аргумент — итерабельный объект.

from functools import reduce


list1 = [-1, 3, 7, 99, 0]
print(reduce(max, list1))  # вывод: 99

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

from functools import reduce


list1 = [-1, 3, 7, 99, 0]
print(reduce(lambda x, y: x if x > y else y, list1))  # -> 99

№4 Поиск максимального значения с помощью приоритетной очереди

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

import heapq


list1 = [-1, 3, 7, 99, 0]
print(heapq.nlargest(1, list1))  # -> [99]

Приведенный выше пример импортирует модуль heapq и принимает на вход список. Функция принимает n=1 в качестве первого аргумента, так как нам нужно найти одно максимальное значение, а вторым аргументом является наш список.

№5 Нахождение максимального значения с помощью функции sort()

Этот метод использует функцию sort() для поиска наибольшего элемента. Он принимает на вход список значений, затем сортирует его в порядке возрастания и выводит последний элемент списка. Последним элементом в списке является list[-1].

list1 = [10, 20, 4, 45, 99]
list1.sort()
print("Наибольшее число:", list1[-1])

Наибольшее число: 99

№6 Нахождение максимального значения с помощью функции sorted()

Этот метод использует функцию sorted() для поиска наибольшего элемента. В качестве входных данных он принимает список значений. Затем функция sorted() сортирует список в порядке возрастания и выводит наибольшее число.

list1=[1,4,22,41,5,2]
sorted_list = sorted(list1)
result = sorted_list[-1]
print(result)  # -> 41

№7 Поиск максимального значения с помощью хвостовой рекурсии

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

def find_max(arr, max_=None):
    if max_ is None:
        max_ = arr.pop()
    current = arr.pop()
    if current > max_:
        max_ = current
    if arr:
        return find_max(arr, max_)
    return max_


list1=[1,2,3,4,2]
result = find_max(list1)
print(result)  # -> 4

Заключение

В этой статье мы научились находить максимальное значение из заданного списка с помощью нескольких встроенных функций, таких как max(), sort(), reduce(), sorted() и других алгоритмов. Мы написали свои код, чтобы попробовать метод перебора, хвостовой рекурсии и алгоритма приоритетной очереди.

Если вам просто нужно найти количество конкретных элементов с списке, используйте метод .count()

>>> list_numbers = [1, 2, 2, 5, 5, 7, 4, 2, 1]
>>> print(list_numbers.count(2))
3

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

1. Использование цикла for для подсчета в списке Python

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

list_numbers = [78, 99, 66, 44, 50, 30, 45, 15, 25, 20]
count = 0

for item in list_numbers:
    if item%5 == 0:
        count += 1

print("количество элементов списка, удовлетворяющих заданному условию:", count)

количество элементов списка, удовлетворяющих заданному условию: 6

2. Применение len() со списковыми включениями для подсчета в списке Python

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

list_numbers = [78, 99, 66, 44, 50, 30, 45, 15, 25, 20]
element_count = len([item for item in list_numbers if item%5 == 0])


print(
    "количество элементов списка, удовлетворяющих заданному условию:",
    element_count
)

количество элементов списка, удовлетворяющих заданному условию: 6

Подсчет ненулевых элементов

В этом примере мы находим общее количество ненулевых элементов. Чтобы узнать число нулевых членов списка, мы можем просто изменить условие на if item == 0.

list_numbers = [78, 99, 66, 44, 50, 30, 45, 0, 0, 0]
element_count = len([item for item in list_numbers if item != 0])

print(
    "количество элементов списка, удовлетворяющих заданному условию:",
    element_count
)

количество элементов списка, удовлетворяющих заданному условию: 7

3. sum() и выражение-генератор для подсчета в списке Python

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

list_numbers = [78, 99, 66, 44, 50, 30, 45, 15, 25, 20]
count = 0
count = sum(True for i in list_numbers if i % 5 == 0)

print(
    "количество элементов списка, удовлетворяющих заданному условию:",
    count
)

количество элементов списка, удовлетворяющих заданному условию: 6

4. sum() и map() для подсчета элементов списка Python с условиями или критериями

Функция map(fun, iterable) принимает два аргумента: итерируемый объект (это может быть строка, кортеж, список или словарь) и функцию, которая применяется к каждому его элементу, — и возвращает map-объект (итератор). Для применения одной функции внутри другой идеально подходит лямбда-функция. Таким образом, map() примет первый аргумент в виде лямбда-функции.

Здесь sum() используется с функцией map(), чтобы получить количество всех элементов списка, которые делятся на 5.

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

list_numbers = [78, 99, 66, 44, 50, 30, 45, 15, 25, 20]
count = 0
count = sum(map(lambda item: item % 5 == 0, list_numbers))

print(
    "количество элементов списка, удовлетворяющих заданному условию:",
    count
)

количество элементов списка, удовлетворяющих заданному условию: 6

5. reduce() с лямбда-функцией для подсчета элементов списка Python с условием или критериями

Lambda — это анонимная (без имени) функция, которая может принимать много параметров, но тело функции должно содержать только одно выражение. Лямбда-функции чаще всего применяют для передачи в качестве аргументов в другие функции или для написания более лаконичного кода. В этом примере мы собираемся использовать функции sum(), map() и reduce() для подсчета элементов в списке, которые делятся на 5.

Приведенный ниже код наглядно демонстрирует это.

from functools import reduce


list_numbers = [78, 99, 66, 44, 50, 30, 45, 15, 25, 20]
result_count = reduce(
    lambda count, item: count + (item % 5 == 0),
    list_numbers,
    0
)

print(
    "количество элементов списка, удовлетворяющих заданному условию:",
    result_count
)

количество элементов списка, удовлетворяющих заданному условию: 6

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

Удачного обучения!

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

Мы можем делать запросы AJAX из шаблонов Django, используя JQuery. AJAX методы библиотеки jQuery позволяют нам запрашивать текст, HTML, XML или JSON с удаленного сервера, используя как HTTP Get, так и HTTP Post. Полученные данные могут быть загружены непосредственно в выбранные HTML-элементы вашей веб-страницы.

В этом руководстве мы узнаем, как выполнять AJAX HTTP GET и POST запросы из шаблонов Django.

Требования к знаниям

Я предполагаю, что у вас есть базовые знания о Django. Поэтому я не буду вдаваться в настройку проекта. Это очень простой проект с приложением под названием AJAX, в котором я использую bootstrap и Django crispy form для стилизации.

Репозиторий Gitlab — https://gitlab.com/PythonRu/django-ajax

Выполнение AJAX GET запросов с помощью Django и JQuery

Метод HTTP GET используется для получения данных с сервера.

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

# ajax/views.py
from django.contrib.auth.models import User
from django.contrib.auth.decorators import login_required
from django.http import JsonResponse
from django.contrib.auth.forms import UserCreationForm
from django.contrib.auth import login, authenticate
from django.shortcuts import render, redirect
from django.views.generic.edit import CreateView
from django.urls import reverse_lazy


@login_required(login_url='signup')
def home(request):
    return render(request, 'home.html')


class SignUpView(CreateView):
    template_name = 'signup.html'
    form_class = UserCreationForm
    success_url = reverse_lazy('home')

    def form_valid(self, form):
        valid = super().form_valid(form)
        login(self.request, self.object)
        return valid


def validate_username(request):
    """Проверка доступности логина"""
    username = request.GET.get('username', None)
    response = {
        'is_taken': User.objects.filter(username__iexact=username).exists()
    }
    return JsonResponse(response)

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

Далее идет SignUpView, унаследованный от класса CreateView. Он нужен для создания пользователей с помощью встроенного Django-класса UserCreationForm, который предоставляет очень простую форму для регистрации. При успешном ее прохождении происходит вход в систему, и пользователь перенаправляется на домашнюю страницу.

Наконец, validate_username — это наше AJAX представление, которое возвращает объект JSON с логическим значением из запроса, проверяющего, существует ли введенное имя пользователя.

Класс JsonResponse возвращает HTTP-ответ с типом содержимого application/json, преобразуя переданный ему объект в формат JSON. Поэтому, если имя пользователя уже существует в базе данных, он вернет JSON-объект, показанный ниже.

{'is_taken': true}

# ajax/urls.py
from django.urls import path
from .views import home, SignUpView, validate_username

urlpatterns = [
    path('', home, name='home'),
    path('signup', SignUpView.as_view(), name='signup'),
    path('validate_username', validate_username, name='validate_username')
]

# dj_ajax/urls.py
from django.contrib import admin
from django.urls import path, include

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

{# home.html #}
<h1>Привет, {{ user.username }}!</h1>

{# signup.html #}
{% load crispy_forms_tags %}
<!DOCTYPE html>
<html lang="en">

<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.5.2/css/bootstrap.min.css" crossorigin="anonymous">
</head>

<body>
<div class="container mt-5 w-50">
  <form id="signupForm" method="POST">
    {% csrf_token %}
    {{ form|crispy  }}
    <input type="submit" name="signupSubmit" class="btn btn-success btn-lg" />
  </form>
</div>

{% block javascript %}
  <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.5.1/jquery.min.js"></script>

  <script>
      $(document).ready(function () {
          // отслеживаем событие отправки формы
          $('#id_username').keyup(function () {
              // создаем AJAX-вызов
              $.ajax({
                  data: $(this).serialize(), // получаяем данные формы
                  url: "{% url 'validate_username' %}",
                  // если успешно, то
                  success: function (response) {
                      if (response.is_taken == true) {
                          $('#id_username').removeClass('is-valid').addClass('is-invalid');
                          $('#id_username').after('<div class="invalid-feedback d-block" id="usernameError">This username is not available!</div>')
                      }
                      else {
                          $('#id_username').removeClass('is-invalid').addClass('is-valid');
                          $('#usernameError').remove();

                      }
                  },
                  // если ошибка, то
                  error: function (response) {
                      // предупредим об ошибке
                      console.log(response.responseJSON.errors)
                  }
              });
              return false;
          });
      })
  </script>
{% endblock javascript %}
</body>
</html>

Для лучшего понимания давайте подробно разберем все части представленного шаблона.

Внутри тега head мы загружаем bootstrap, используя CDN. Вы также можете сохранить библиотеку себе на диск и отдавать ее клиенту из статических папок.

  <form id="signupForm" method="POST">
    {% csrf_token %}
    {{ form|crispy  }}
    <input type="submit" name="signupSubmit" class="btn btn-success btn-lg" />
  </form>

Затем мы создаем форму Django, используя для стилизации тег crispy.

<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.5.1/jquery.min.js"></script>

Далее внутри блока javascript мы запрашиваем JQuery от google CDN, вы также можете загрузить ее локально.

$(document).ready(function () {
    ( .... )
})

Затем у нас есть еще один скрипт с методом ready(). Код, написанный внутри метода $(document).ready(), будет запущен, когда DOM страницы будет готов для выполнения JavaScript.

$('#id_username').keyup(function () {
    // создаем AJAX-вызов
    $.ajax({
        data: $(this).serialize(), // получаяем данные формы
        url: "{% url 'validate_username' %}",
        // если успешно, то
        success: function (response) {
            if (response.is_taken == true) {
                $('#id_username').removeClass('is-valid').addClass('is-invalid');
                $('#id_username').after('<div class="invalid-feedback d-block" id="usernameError">Это имя пользователя недоступно!</div>')
            }
            else {
                $('#id_username').removeClass('is-invalid').addClass('is-valid');
                $('#usernameError').remove();
            }
        },
        // если ошибка, то
        error: function (response) {
            // предупредим об ошибке
            console.log(response.responseJSON.errors)
        }
    });
    return false;
});

Метод ajax запускается функцией keyup. Он принимает на вход объект с параметрами запроса. После успешного завершения запросов запускается одна из колбэк-функций success или error. При успешном вызове мы используем условный оператор для добавления и удаления классов is-valid/is-invalid поля ввода. А return false в конце скрипта предотвращает отправку форм, таким образом останавливая перезагрузку страницы.

Сохраните файлы и запустите сервер, вы должны увидеть AJAX в действии.

Выполнение AJAX POST запросов с помощью Django и JQuery

Метод HTTP POST используется для отправки данных на сервер.

В этом разделе мы узнаем, как делать POST-запросы с помощью JQuery и AJAX в шаблонах Django.
Мы создадим контактную форму и сохраним данные, предоставленные пользователем, в базу данных с помощью JQuery и AJAX.

# ajax/models.py
from django.db import models

class Contact(models.Model):
    name = models.CharField(max_length=100)
    email = models.EmailField()
    message = models.TextField()

    def __str__(self):
        return self.name

# ajax/forms.py
from django import forms
from .models import Contact


class ContactForm(forms.ModelForm):
    class Meta:
        model = Contact
        fields = '__all__'

# ajax/urls.py
...
from .views import home, SignUpView, validate_username, contact_form

urlpatterns = [
    ...
    path('contact-form/', contact_form, name='contact_form')
]

# ajax/views.py
...
from .forms import ContactForm

...

def contact_form(request):
    form = ContactForm()
    if request.method == "POST" and request.is_ajax():
        form = ContactForm(request.POST)
        if form.is_valid():
            name = form.cleaned_data['name']
            form.save()
            return JsonResponse({"name": name}, status=200)
        else:
            errors = form.errors.as_json()
            return JsonResponse({"errors": errors}, status=400)

    return render(request, "contact.html", {"form": form})

В представлении мы проверяем ajax-запрос с помощью метода request.is_ajax(). Если форма корректно заполнена, мы сохраняем ее в базе данных и возвращаем объект JSON с кодом состояния и именем пользователя. Для недопустимой формы мы отправим клиенту найденные ошибки с кодом 400, что означает неверный запрос (bad request).

{# contact.html #}
{% load crispy_forms_tags %}

<!DOCTYPE html>
<html lang="en">

<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Contact us</title>
  <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.5.2/css/bootstrap.min.css" crossorigin="anonymous">

</head>

<body>
<div class="container mt-5 w-50">
  <form id="contactForm" method="POST">
    {% csrf_token %}
    {{ form|crispy }}
    <input type="submit" name="contact-submit" class="btn btn-success btn-lg" />
  </form>
</div>
{% block javascript %}
  <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.5.1/jquery.min.js"></script>
  <script>
      $(document).ready(function () {
          // отслеживаем событие отправки формы
          $('#contactForm').submit(function () {
              // создаем AJAX-вызов
              $.ajax({
                  data: $(this).serialize(), // получаем данные формы
                  type: $(this).attr('method'), // GET или POST
                  url: "{% url 'contact_form' %}",
                  // если успешно, то
                  success: function (response) {
                      alert("Спасибо, что обратились к нам " + response.name);
                  },
                  // если ошибка, то
                  error: function (response) {
                      // предупредим об ошибке
                      alert(response.responseJSON.errors);
                      console.log(response.responseJSON.errors)
                  }
              });
              return false;
          });
      })
  </script>
{% endblock javascript %}
</body>
</html>

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

Сначала мы импортируем bootstrap в head, используя CDN. Затем внутри body мы создаем форму с тегом crispy для стилизации.

После этого в первом javascript-блоке мы загружаем JQuery из CDN. Далее внутри функции $(document).ready() мы добавили наш AJAX метод.

  <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.5.1/jquery.min.js"></script>
  <script>
      $(document).ready(function () {
          // отслеживаем событие отправки формы
          $('#contactForm').submit(function () {
              // создаем AJAX-вызов
              $.ajax({
                  data: $(this).serialize(), // получаем данные формы
                  type: $(this).attr('method'), // GET или POST
                  url: "{% url 'contact_form' %}",
                  // если успешно, то
                  success: function (response) {
                      alert("Спасибо, что обратились к нам " + response.name);
                  },
                  // если ошибка, то
                  error: function (response) {
                      // предупредим об ошибке
                      alert(response.responseJSON.errors);
                      console.log(response.responseJSON.errors)
                  }
              });
              return false;
          });
      })
  </script>

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

Выполнение AJAX POST запросов с использованием представлений на основе классов

Нам нужно просто вернуть объект JSON из метода form_valid() класса FormView. Вы также можете использовать другие стандартные представления, основанные на классах, переопределив метод post().

# ajax/views.py
...
from django.views.generic.edit import CreateView, FormView
...

class ContactFormView(FormView):
    template_name = 'contact.html'
    form_class = ContactForm

    def form_valid(self, form):
        """
        Если форма валидна, вернем код 200
        вместе с именем пользователя
        """
        name = form.cleaned_data['name']
        form.save()
        return JsonResponse({"name": name}, status=200)

    def form_invalid(self, form):
        """
        Если форма невалидна, возвращаем код 400 с ошибками.
        """
        errors = form.errors.as_json()
        return JsonResponse({"errors": errors}, status=400)

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

Даже после того, как вся подготовительная работа выполнена, применение выборок Scikit-Learn поначалу может показаться вам немного запутанным. Не волнуйтесь, через несколько минут вы точно узнаете, как использовать датасеты, и встанете на путь исследования мира искусственного интеллекта. В этой статье предполагается, что у вас установлены python, scikit-learn, pandas и Jupyter Notebook (или вы можете воспользоваться Google Collab). Давайте начнем.

Введение в Scikit-Learn datasets

Scikit-Learn предоставляет семь наборов данных, которые они называют игровыми датасетами. Не дайте себя обмануть словом «игровой». Эти выборки довольно объемны и служат хорошей отправной точкой для изучения машинного обучения (далее ML). Вот несколько примеров доступных наборов данных и способы их использования:

• Цены на жилье в Бостоне — используйте ML для прогнозирования цен на жилье на основе таких атрибутов, как количество комнат, уровень преступности в городе.
• Датасет диагностики рака молочной железы (Висконсин) — используйте ML для диагностики рака как доброкачественного (не распространяется на остальную часть тела) или злокачественного (распространяется).
• Распознавание вина — используйте ML для определения типа вина по химическим свойствам.

В этой статье мы будем работать с “Breast Cancer Wisconsin” (рак молочной железы, штат Висконсин) датасетом. Мы импортируем данные и разберем, как их читать. В качестве бонуса мы построим простую модель машинного обучения, которая сможет классифицировать сканированные изображения рака как злокачественные или доброкачественные.

Чтобы узнать больше о предоставленных выборках, нажмите здесь для перехода на документацию Scikit-Learn.

Как импортировать модуль datasets?

Доступные датасеты можно найти в sklearn.datasets. Давайте импортируем необходимые данные. Сначала мы добавим модуль datasets, который содержит все семь выборок.

from sklearn import datasets

У каждого датасета есть соответствующая функция, используемая для его загрузки. Эти функции имеют единый формат: «load_DATASET()», где DATASET — названием выборки. Для загрузки набора данных о раке груди мы используем load_breast_cancer(). Точно так же при распознавании вина мы вызовем load_wine(). Давайте загрузим выбранные данные и сохраним их в переменной data.

data = datasets.load_breast_cancer()

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

Не знаете, что такое Bunch? Не волнуйтесь. Считайте объект Bunch причудливым аналогом словаря от библиотеки Scikit-Learn.

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

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

Что в нашем Bunch-словаре?

Предоставленный Sklearn словарь Bunch — достаточно мощный инструмент. Давайте узнаем, какие ключи нам доступны.

print(data.keys())

Получаем следующие ключи:

• data — это необходимые для предсказания данные (показатели, полученные при сканировании, такие как радиус, площадь и другие) в массиве NumPy.
• target — это целевые данные (переменная, которую вы хотите предсказать, в данном случае является ли опухоль злокачественной или доброкачественной) в массиве NumPy.

Значения этих двух ключей предоставляют нам необходимые для обучения данные. Остальные ключи (смотри ниже) имеют пояснительное предназначение. Важно отметить, что все датасеты в Scikit-Learn разделены на data и target. data представляет собой показатели, переменные, которые используются моделью для тренировки. target включает в себя фактические метки классов. В нашем случае целевые данные — это один столбец, в котором опухоль классифицируется как 0 (злокачественная) или 1 (доброкачественная).

• feature_names — это названия показателей, другими словами, имена столбцов в data.
• target_names — это имя целевой переменной или переменных, другими словами, название целевого столбца или столбцов.
• DESCR — сокращение от DESCRIPTION, представляет собой описание выборки.
• filename — это путь к файлу с данными в формате CSV.

Чтобы посмотреть значение ключа, вы можете ввести data.KEYNAME, где KEYNAME — интересующий ключ. Итак, если мы хотим увидеть описание датасета:

print(data.DESCR)

Вот небольшая часть полученного результата (полная версия слишком длинная для добавления в статью):

.. _breast_cancer_dataset:

Breast cancer wisconsin (diagnostic) dataset
--------------------------------------------

**Data Set Characteristics:**

    :Number of Instances: 569

    :Number of Attributes: 30 numeric, predictive attributes and the class

    :Attribute Information:
        - radius (mean of distances from center to points on the perimeter)
        - texture (standard deviation of gray-scale values)
        - perimeter
        - area
        - smoothness (local variation in radius lengths)
        - compactness (perimeter^2 / area - 1.0)
        - concavity (severity of concave portions of the contour)
        - concave points (number of concave portions of the contour)
        - symmetry
        - fractal dimension ("coastline approximation" - 1)
...

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

Работа с датасетом

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

# импорт pandas
import pandas as pd
# Считайте DataFrame, используя данные функции
df = pd.DataFrame(data.data, columns=data.feature_names)
# Добавьте столбец "target" и заполните его данными.
df['target'] = data.target
# Посмотрим первые пять строк
df.head()

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

df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 569 entries, 0 to 568
Data columns (total 31 columns):
 #   Column                   Non-Null Count  Dtype  
---  ------                   --------------  -----  
 0   mean radius              569 non-null    float64
 1   mean texture             569 non-null    float64
 2   mean perimeter           569 non-null    float64
 3   mean area                569 non-null    float64
 4   mean smoothness          569 non-null    float64
 5   mean compactness         569 non-null    float64
 6   mean concavity           569 non-null    float64
 7   mean concave points      569 non-null    float64
 8   mean symmetry            569 non-null    float64
 9   mean fractal dimension   569 non-null    float64
 10  radius error             569 non-null    float64
 11  texture error            569 non-null    float64
 12  perimeter error          569 non-null    float64
 13  area error               569 non-null    float64
 14  smoothness error         569 non-null    float64
 15  compactness error        569 non-null    float64
 16  concavity error          569 non-null    float64
 17  concave points error     569 non-null    float64
 18  symmetry error           569 non-null    float64
 19  fractal dimension error  569 non-null    float64
 20  worst radius             569 non-null    float64
 21  worst texture            569 non-null    float64
 22  worst perimeter          569 non-null    float64
 23  worst area               569 non-null    float64
 24  worst smoothness         569 non-null    float64
 25  worst compactness        569 non-null    float64
 26  worst concavity          569 non-null    float64
 27  worst concave points     569 non-null    float64
 28  worst symmetry           569 non-null    float64
 29  worst fractal dimension  569 non-null    float64
 30  target                   569 non-null    int32  
dtypes: float64(30), int32(1)
memory usage: 135.7 KB

Несколько вещей, на которые следует обратить внимание:

• Нет пропущенных данных, все столбцы содержат 569 значений. Это избавляет нас от необходимости учитывать отсутствующие значения.
• Все типы данных числовые. Это важно, потому что модели Scikit-Learn не принимают качественные переменные. В реальном мире, когда получаем такие переменные, мы преобразуем их в числовые. Датасеты Scikit-Learn не содержат качественных значений.

Следовательно, Scikit-Learn берет на себя работу по очистке данных. Эти наборы данных чрезвычайно удобны. Вы получите удовольствие от изучения машинного обучения, используя их.

Обучение на датесете из sklearn.datasets

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

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

X = data.data
y = data.target
# разделим данные с помощью Scikit-Learn's train_test_split
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y)

Это дает нам два датасета — один для обучения и один для тестирования. Приступим к тренировке модели.

from sklearn.neighbors import KNeighborsClassifier
logreg = KNeighborsClassifier(n_neighbors=6)
logreg.fit(X_train, y_train)
logreg.score(X_test, y_test)

Получили на выходе 0.923? Это означает, что модель точна на 92%! Всего за несколько минут вы создали модель, которая классифицирует результаты сканирования опухолей с точностью 90%. Конечно, в реальном мире все сложнее, но это хорошее начало.

Ноутбук с кодом вы можете скачать здесь.

Вы многому научитесь, пытаясь построить модели с использованием datasets из Scikit-Learn. Удачного обучения искусственному интеллекту!

1. Как настроить Celery с Django.
2. Как протестировать Celery-задачу в Django-оболочке.
3. Где контролировать работу Celery-приложения.

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

Зачем приложению на Django нужен Celery

Celery нужен для запуска задач в отдельном рабочем процессе (worker), что позволяет немедленно отправить HTTP-ответ пользователю в веб-процессе (даже если задача в рабочем процессе все еще выполняется). Цикл обработки запроса не будет заблокирован, что повысит качество взаимодействия с пользователем.
Ниже приведены некоторые примеры использования Celery:

• Вы создали приложение с функцией отправки комментариев, в которых пользователь может использовать символ @, чтобы упомянуть другого пользователя, после чего последний получит уведомление по электронной почте. Если пользователь упоминает 10 человек в своем комментарии, веб-процессу необходимо обработать и отправить 10 электронных писем. Иногда это занимает много времени (сеть, сервер и другие факторы). В данном случае Celery может организовать отправку писем в фоновом режиме, что в свою очередь позволит вернуть HTTP-ответ пользователю без ожидания.
• Нужно создать миниатюру загруженного пользователем изображения? Такую задачу стоит выполнить в рабочем процессе.
• Вам необходимо делать что-то периодически, например, генерировать ежедневный отчет, очищать данные истекшей сессии. Используйте Celery для отправки задач рабочему процессу в назначенное время.

Когда вы создаете веб-приложение, постарайтесь сделать время отклика не более, чем 500мс (используйте New Relic или Scout APM), если пользователь ожидает ответа слишком долго, выясните причину и попытайтесь устранить ее. В решении такой проблемы может помочь Celery.

Celery или RQ

RQ (Redis Queue) — еще одна библиотека Python, которая решает вышеуказанные проблемы.
Логика работы RQ схожа с Celery (используется шаблон проектирования производитель/потребитель). Далее я проведу поверхностное сравнение для лучшего понимания, какой из инструментов более подходит для задачи.

• RQ (Redis Queue) проста в освоении, направлена на снижение барьера в использовании асинхронного рабочего процесса. В ней отсутствуют некоторые функции, и она работает только с Redis и Python.
• Celery предоставляет больше возможностей, поддерживает множество различных серверных конфигураций. Одним из минусов такой гибкости является более сложная документация, что довольно часто пугает новичков.

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

Брокер сообщений и бэкенд результатов

Брокер сообщений — это хранилище, которое играет роль транспорта между производителем и потребителем.
Из документации Celery рекомендуемым брокером является RabbitMQ, потому что он поддерживает AMQP (расширенный протокол очереди сообщений).

Так как во многих случаях нам не нужно использовать AMQP, другой диспетчер очереди, такой как Redis, также подойдет.

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

Здесь рекомендуется использовать Redis.

Как настроить Celery

Celery не работает на Windows. Используйте Linux или терминал Ubuntu в Windows.

Далее я покажу вам, как импортировать Celery worker в ваш Django-проект.

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

Используйте Docker для подготовки среды разработки

Если вы работаете в Linux или Mac, у вас есть возможность использовать менеджер пакетов для настройки Redis (brew, apt-get install), однако я хотел бы порекомендовать вам попробовать применить Docker для установки сервера redis.

1. Вы можете скачать Docker-клиент здесь.
2. Затем попробуйте запустить службу Redis $ docker run -p 6379: 6379 --name some-redis -d redis

Команда выше запустит Redis на 127.0.0.1:6379.

1. Если вы намерены использовать RabbitMQ в качестве брокера сообщений, вам нужно изменить только приведенную выше команду.
2. Закончив работу с проектом, вы можете закрыть Docker-контейнер — окружение вашей рабочей машины по-прежнему будет чистым.

Теперь импортируем Celery в наш Django-проект.

Создание Django-проекта

Рекомендую создать отдельное виртуальное окружение и работать в нем.

$ pip install django==3.1
$ django-admin startproject celery_django
$ python manage.py startapp polls

Ниже представлена структура проекта.

├── celery_django 
│   ├── __init__.py

│   ├── asgi.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
├── manage.py
└── polls
    ├── __init__.py
    ├── admin.py
    ├── apps.py
    ├── migrations
    │   └── __init__.py
    ├── models.py
    ├── tests.py
    └── views.py

Файл celery.py

Давайте приступим к установке и настройке Celery.

pip install celery==4.4.7 redis==3.5.3 flower==0.9.7

Создайте файл celery_django/celery.py рядом с celery_django/wsgi.py.

"""
Файл настроек Celery
https://docs.celeryproject.org/en/stable/django/first-steps-with-django.html
"""
from __future__ import absolute_import
import os
from celery import Celery

# этот код скопирован с manage.py
# он установит модуль настроек по умолчанию Django для приложения 'celery'.
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'celery_django.settings')

# здесь вы меняете имя
app = Celery("celery_django")

# Для получения настроек Django, связываем префикс "CELERY" с настройкой celery
app.config_from_object('django.conf:settings', namespace='CELERY')

# загрузка tasks.py в приложение django
app.autodiscover_tasks()


@app.task
def add(x, y):
    return x / y

Файл __init__.py

Давайте продолжим изменять проект, в celery_django/__init__.py добавьте.

from __future__ import absolute_import, unicode_literals

# Это позволит убедиться, что приложение всегда импортируется, когда запускается Django
from .celery import app as celery_app

__all__ = ('celery_app',)

Дополнение settings.py

Поскольку Celery может читать конфигурацию из файла настроек Django, мы внесем в него следующие изменения.

CELERY_BROKER_URL = "redis://127.0.0.1:6379/0"
CELERY_RESULT_BACKEND = "redis://127.0.0.1:6379/0"

Есть кое-что, о чем следует помнить.

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

1. app.config_from_object('django.conf: settings', namespace = 'CELERY') сообщает Celery, чтобы он считывал значение из пространства имен CELERY, поэтому, если вы установите просто broker_url в своем файле настроек Django, этот параметр не будет работать. Правило применяется для всех ключей конфигурации в документации Celery.
2. Некоторые конфигурационные ключи различаются между Celery 3 и Celery 4, так что, пожалуйста, загляните в документацию при настройке.

Отправка заданий Celery

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

Сначала запустите Redis-клиент, потом celery worker в другом терминале, celery_django — это имя Celery-приложения, которое вы установили в celery_django/celery.py.

$ celery worker -A celery_django --loglevel=info

  -------------- celery@DESKTOP-111111 v4.4.7 (cliffs)
--- ***** ----- 
-- ******* ---- Linux-4.4.0-19041-Microsoft-x86_64-with-glibc2.27 2021-03-15 15:03:44
- *** --- * --- 
- ** ---------- [config]
- ** ---------- .> app:         celery_django:0x7ff07f818ac0
- ** ---------- .> transport:   redis://127.0.0.1:6379/0
- ** ---------- .> results:     redis://127.0.0.1:6379/0
- *** --- * --- .> concurrency: 4 (prefork)
-- ******* ---- .> task events: OFF (enable -E to monitor tasks in this worker)
--- ***** ----- 
 -------------- [queues]
                .> celery           exchange=celery(direct) key=celery


[tasks]
  . celery_django.celery.add

Далее запустим приложение в новом терминале, которое поможет нам отслеживать Celery-задачу (я расскажу об этом чуть позже).

$ flower -A celery_django --port=5555

[I 210315 16:11:39 command:135] Visit me at http://localhost:5555
[I 210315 16:11:39 command:142] Broker: redis://127.0.0.1:6379/0
[I 210315 16:11:39 command:143] Registered tasks:
    ['celery.accumulate',
     'celery.backend_cleanup',
     'celery.chain',
     'celery.chord',
     'celery.chord_unlock',
     'celery.chunks',
     'celery.group',
     'celery.map',
     'celery.starmap',
     'celery_django.celery.add']
[I 210315 16:11:39 mixins:229] Connected to redis://127.0.0.1:6379/0

Затем откройте http://localhost:5555/. Вы должны увидеть информационную панель, на которой отображаются детали выполнения рабочего процесса Celery.

Теперь войдем в Django shell и попробуем отправить Celery несколько задач.

$ python manage.py migrate
$ python manage.py shell
...
>>> from celery_django.celery import add
>>> task = add.delay(1, 2)

Рассмотрим некоторые моменты:

1. Мы используем xxx.delay для отправки сообщения брокеру. Рабочий процесс получает эту задачу и выполняет ее.
2. Когда вы нажимаете клавишу enter для ввода task = add.delay(1, 2), кажется, что команда быстро завершает выполнение (отсутствие блокировки), но метод добавления все еще активен в рабочем процессе Celery.
3. Если вы проверите вывод терминала, где был запущен Celery, то увидите что-то вроде этого:

[2021-03-15 15:04:32,859: INFO/MainProcess] Received task: celery_django.celery.add[e1964774-fd3b-4add-96ff-116e3578de
de]
[2021-03-15 15:04:32,882: INFO/ForkPoolWorker-1] Task celery_django.celery.add[e1964774-fd3b-4add-96ff-116e3578dede] s
ucceeded in 0.013418699999988348s: 0.5

Рабочий процесс получил задачу в 15:04:32, и она была успешно выполнена.
Думаю, теперь у вас уже есть базовое представление об использовании Celery. Попробуем ввести еще один блок кода.

>>> print(task.state, task.result)
SUCCESS 0.5

Затем давайте попробуем вызвать ошибку в Celery worker и посмотрим, что произойдет.

>>> task = add.delay(1, 0)
>>> type(task)
celery.result.AsyncResult

>>> task.state
'FAILURE'
>>> task.result
ZeroDivisionError('division by zero')

Как видите, результатом вызова метода delay является экземпляр AsyncResult.
Мы можем использовать его следующим образом:

1. Проверить состояние задачи.
2. Узнать возвращенное значение (результат) или сведения об исключении.
3. Получить другие метаданные.

Мониторинг Celery с помощью Flower

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

URL-адрес панели управления: http://127.0.0.1:5555/. Откройте страницу задач — Tasks.

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

Заключение

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

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

Что такое функция value_counts()?

Функция value_counts() используется для получения Series, содержащего уникальные значения. Она вернет результат, отсортированный в порядке убывания, так что первый элемент в коллекции будет самым встречаемым. NA-значения не включены в результат.

Синтаксис
df['your_column'].value_counts() — вернет количество уникальных совпадений в определенной колонке.

Важно заметить, что value_counts работает только с series, но не dataframe. Поэтому нужно указать одни квадратные скобки df['your_column'], а не пару df[['your_column']].

Параметры:

• normalize (bool, по умолчанию False) — если True, то возвращаемый объект будет содержать значения относительно частоты встречаемых значений.
• sort (bool, по умолчанию True) — сортировка по частоте.
• ascending (bool, по умолчанию False) — сортировка по возрастанию.
• bins (int) — вместе подсчета значений группирует их по отрезкам, но это работает только с числовыми данными.
• dropna (bool, по умолчанию True) — не включать количество NaN.

Загрузка данных для демонстрации

Рассмотрим, как использовать этот метод на реальных данных. Возьмем в качестве примера датасет из курса Coursera на Kaggle.

Для начала импортируем нужные библиотеки и сами данные. Это нужно в любом проекте. После этого проанализируем данные в notebook Jupyter.

# импорт библиотеки
import pandas as pd

# Загрузка данных
df = pd.read_csv('Downloads/coursea_data.csv', index_col=0)

# проверка данных из csv
df.head(10)

Проверьте, сколько записей в датасете и есть ли у нас пропуски.

df.info()

Результат показывает, что в наборе 981 запись, и нет ни одного NA.

<class 'pandas.core.frame.DataFrame'>
Int64Index: 891 entries, 134 to 163
Data columns (total 6 columns):
 #   Column                    Non-Null Count  Dtype  
---  ------                    --------------  -----  
 0   course_title              891 non-null    object 
 1   course_organization       891 non-null    object 
 2   course_Certificate_type   891 non-null    object 
 3   course_rating             891 non-null    float64
 4   course_difficulty         891 non-null    object 
 5   course_students_enrolled  891 non-null    object 
dtypes: float64(1), object(5)
memory usage: 48.7+ KB

1. value_counts с параметрами по умолчанию

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

Синтаксис: df['your_column'].value_counts().

Получим количество каждого значения для колонки «course_difficulty».

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

df['course_difficulty'].value_counts()
---------------------------------------------------
Beginner        487
Intermediate    198
Mixed           187
Advanced         19
Name: course_difficulty, dtype: int64

Теперь время поработать с параметрами.

2. Сортировка по возрастанию

По умолчанию value_counts() возвращает данные по убыванию. Изменит поведение можно, задав значение True для параметра ascending.

Синтаксис: df['your_column'].value_counts(ascending=True).

df['course_difficulty'].value_counts(ascending=True)
---------------------------------------------------
Advanced         19
Mixed           187
Intermediate    198
Beginner        487
Name: course_difficulty, dtype: int64

3. Сортировка в алфавитном порядке

В определенных случаях может существовать необходимость отсортировать записи в алфавитном порядке. Это делается с помощью добавления sort_index(ascending=True) после value_counts().

По умолчанию функция сортирует «course_difficulty» по количеству совпадений, а с sort_index сортирует по индексу (имени колонки, для которой и используется функция):

df['course_difficulty'].value_counts().sort_index(ascending=True)
---------------------------------------------------
Advanced         19
Beginner        487
Intermediate    198
Mixed           187
Name: course_difficulty, dtype: int64

Если же требуется отобразить value_counts() в обратном алфавитном порядке, то нужно изменить направление сортировки: .sort_index(ascending=False).

4. Сортировка по значению, а затем по алфавиту

Для этого примера используем другой датасет.

df_fruit = pd.DataFrame({
    'fruit':
       ['хурма']*5 + ['яблоки']*5 + ['бананы']*3 + 
       ['персики']*3 + ['морковь']*3 + ['абрикосы'] + ['манго']*2
})

Так, нужно получить вывод, отсортированный в первую очередь по количеству совпадений значений, а потом уже и по алфавиту. Это можно сделать, объединив value_counts() c sort_index(ascending=False) и sort_values(ascending=False).

df_fruit['fruit'].value_counts()\
                 .sort_index(ascending=False)\
                 .sort_values(ascending=False)
-------------------------------------------------
хурма       5
яблоки      5
бананы      3
морковь     3
персики     3
манго       2
абрикосы    1
Name: fruit, dtype: int64

5. Относительная частота уникальных значений

Иногда нужно получить относительные значения, а не просто количество. С параметром normalize=True объект вернет относительную частоту уникальных значений. По умолчанию значение этого параметра равно False.

Синтаксис: df['your_column'].value_counts(normalize=True).

df['course_difficulty'].value_counts(normalize=True)
-------------------------------------------------
Beginner        0.546577
Intermediate    0.222222
Mixed           0.209877
Advanced        0.021324
Name: course_difficulty, dtype: float64

6. value_counts() для разбивки данных на дискретные интервалы

Еще один трюк, который часто игнорируют. value_counts() можно использовать для разбивки данных на дискретные интервалы с помощью параметра bin. Это работает только с числовыми данными. Принцип напоминает pd.cut. Посмотрим как это работает на примере колонки «course_rating». Сгруппируем значения колонки на 4 группы.

Синтаксис: df['your_column'].value_counts(bin=количество групп).

df['course_rating'].value_counts(bins=4)
-------------------------------------------------
(4.575, 5.0]      745
(4.15, 4.575]     139
(3.725, 4.15]       5
(3.297, 3.725]      2
Name: course_rating, dtype: int64

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

7. value_counts() с пропусками

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

Синтаксис: df['your_column'].value_counts(dropna=False).

8. value_counts() как dataframe

Как уже было отмечено, value_counts() возвращает Series, а не Dataframe. Если же нужно получить результаты в последнем виде, то для этого можно использовать функцию .to_frame() после .value_counts().

Синтаксис: df['your_column'].value_counts().to_frame().

Это будет выглядеть следующим образом:

Если нужно задать имя для колонки или переименовать существующую, то эту конвертацию можно реализовать другим путем.

value_counts = df['course_difficulty'].value_counts()

# преобразование в df и присвоение новых имен колонкам
df_value_counts = pd.DataFrame(value_counts)
df_value_counts = df_value_counts.reset_index()
df_value_counts.columns = ['unique_values', 'counts for course_difficulty']
df_value_counts

Groupby и value_counts

Groupby — очень популярный метод в Pandas. С его помощью можно сгруппировать результат по одной колонке и посчитать значения в другой.

Синтаксис: df.groupby('your_column_1')['your_column_2'].value_counts().

Так, с помощью groupby и value_counts можно посчитать количество типов сертификатов для каждого уровня сложности курсов.

df.groupby('course_difficulty')['course_Certificate_type'].value_counts()
-------------------------------------------------
course_difficulty  course_Certificate_type 
Advanced           SPECIALIZATION               10
                   COURSE                        9
Beginner           COURSE                      282
                   SPECIALIZATION              196
                   PROFESSIONAL CERTIFICATE      9
Intermediate       COURSE                      104
                   SPECIALIZATION               91
                   PROFESSIONAL CERTIFICATE      3
Mixed              COURSE                      187
Name: course_Certificate_type, dtype: int64

Это мульти-индекс, позволяющий иметь несколько уровней индексов в dataframe. В этом случае сложность курса соответствует нулевому уровню индекса, а тип сертификата — первому.

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

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

Синтаксис: df['your_column'].value_counts().loc[lambda x : x > 1].

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

Для примера ограничим рейтинг курса значением 4.

df.groupby('course_difficulty')['coudf['course_rating']\
  .value_counts().loc[lambda x: x > 4] 
-------------------------------------------------
4.8    256
4.7    251
4.6    168
4.5     80
4.9     68
4.4     34
4.3     15
4.2     10
Name: course_rating, dtype: int64

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

Тест на знание функции value_counts

Во-первых, Heroku очень редко используют в продакшене. Его платные тарифы сильно выше стоимости аренды сервера.

Во-вторых, крупные кампании дают виртуальные машины бесплатно на год. Этого достаточно, что бы 4 года не платить за работу сервера.

Получение VPS

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

• AWS Amazon, продукт Amazon EC2.
• Azure Microsoft, продукт Виртуальные машины Linux.
• Google Cloud, продукт Compute Engine.
• Alibaba Cloud, продукт Elastic Compute Service.

Только не активируйте все сразу, это разовое предложение.

Не буду подробно описывать, как развернуть VPS, у этих платформ документации на высоком уровне. Если у вас трудности с английским и переводчиками, начинайте с Azure. У них много русской документации. Скажу только, что крайне желательно выбирать OS Ubuntu 18.04.

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

Я буду использовать VPS с почасовой оплатой от reg.ru. Это дешевое и простое решение. Для обучения и демонстрации можно запускать на несколько часов по цене от 0,32 ₽/час. А постоянная работа подобного бота будет стоить 215 рублей в месяц.

Подключение к виртуальной машине

Для подключения к VPS нужно знать ip (IPv4), логин (обычно «root») и пароль.

С Linux и MacOS можно подключится из терминала. Введите команду, логин и ip сервера.

ssh root@123.123.123.23

Для windows можно скачать терминал Ubuntu. Если такой вариант не подходит, используйте PuTTY (порт: 22). Вот так выглядит консоль. Для подключения требуется ввести «yes» и пароль.

После входа я узнал какая версия python установлена командой python -V. Из коробки стоит 3.6.9, а проект на 3.8.5, нужно обновить.

Подготовка сервера

1. Установим необходимую версию python. Внимательно вводите эти команды по очереди, это процесс кастомной установки.

$ sudo apt update
$ sudo apt install build-essential zlib1g-dev libncurses5-dev libgdbm-dev libnss3-dev libssl-dev libreadline-dev libffi-dev libsqlite3-dev wget libbz2-dev
$ wget https://www.python.org/ftp/python/3.8.5/Python-3.8.5.tgz
$ tar -xf Python-3.8.5.tgz
$ cd Python-3.8.5
$ ./configure --enable-optimizations
$ make  # ~15 минут
$ sudo make altinstall
$ cd /home

Немного деталей. Я скачал архив, распаковал и установил python 3.8.5. Будет готов подождать пока выполнится команды make. Введите python3.8 -V и убедитесь, что можно продолжать:

/home# python3.8 -V
Python 3.8.5 

2. Создадим проект. Установим и создадим виртуально окружение. Выполняйте команды по очереди:

$ python3.8 -m pip install --upgrade pip 
$ pip install virtualenv
$ mkdir fonlinebot
$ cd fonlinebot
$ virtualenv venv
$ source venv/bin/activate
$ python -V
$ deactivate

Мы установили pip и virtualenv. Затем создали папку «fonlinebot», создали в ней виртуальное окружение и проверили его.

3. Установим и запустим Redis-server. Для установки и проверки в Ubuntu введите эти команды:

$ sudo apt install redis-server
$ redis-cli
127.0.0.1:6379> ping

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

4. Переменные окружения. Теперь нужно спрятать токен и API-ключ в переменные. Выполните команду nano /etc/environment и вставьте эти строки со своими значениями в кавычках.

fonlinebot_token="замените_на_токен"
fonlinebot_api_key="замените_на_ключ_апи"

Затем нажмите CTRL+O -> Enter -> CTRL+X для сохранения. Перезапустите машину: sudo reboot, что бы переменить настройки.

5. Подготовка кода бота. Отредактируйте файл config.py. Раскомментируем настройки логирования и установим переменные окружения.

# fonlinebot/config.py
#...
import datetime
import os


formatter = '[%(asctime)s] %(levelname)8s --- %(message)s (%(filename)s:%(lineno)s)'
logging.basicConfig(
    filename=f'bot-from-{datetime.datetime.now().date()}.log',
    filemode='w',
    format=formatter,
    datefmt='%Y-%m-%d %H:%M:%S',
    level=logging.WARNING
)


TOKEN = os.environ.get("fonlinebot_token")
#...

   'x-rapidapi-key': os.environ.get("fonlinebot_api_key"),
#...

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

Половина работы сделана. Теперь нужно загрузить файлы на сервер.

Загрузка файлов на VPS

Скачайте и установите WinSCP. Это программа для загрузки проекта на VPS. Альтернативный вариант Filezilla. Вариант для повышения скиллов — Git.

Откройте и установите соединение с сервером:

Далее перенесите файлы проекта (без venv и файлов Pycharm) в папку home/fonlinebot/.

Готово? Запустим бота с сервера.

$ cd /home/fonlinebot/  # перейдем в папку проекта
$ source venv/bin/activate  # активируем окружение
$ pip install -r requirements.txt  # установим зависимости
$ python main.py  # запустим бота

Теперь перейдите в Телеграм и протестируйте работу. Отвечает? Хорошо, остановите его (ctrl+c) и деактивируйте виртуальное окружение (deactivate)

Финишная прямая проекта. После закрытия терминала, бот остановится. После перезапуска сервера, он не запустится. Настроем автономную работу.

Беспрерывная работа бота

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

nano /lib/systemd/system/fonlinebot.service

С настройками:

[Unit]
Description=Football online bot
After=network.target

[Service]
EnvironmentFile=/etc/environment
ExecStart=/home/fonlinebot/venv/bin/python main.py
ExecReload=/home/fonlinebot/venv/bin/python main.py
WorkingDirectory=/home/fonlinebot/
KillMode=process
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target

Затем нажмите CTRL+O -> Enter -> CTRL+X для сохранения. Что это за настройки?

Настройки службы, нам важны эти:

• Description — описание службы.
• EnvironmentFile — путь к файлу с переменными.
• ExecStart и ExecReload — это команды для запуска и перезапуска бота.
• WorkingDirectory — путь к папке в которой файл запуска main.py.

Для запуска службы выполните эти 2 команды.

systemctl enable fonlinebot
systemctl start fonlinebot

Теперь вернемся в бот и посмотрим как он отвечает.

Если бот не отвечает, проверьте статус и логи. Здесь сложно предвидеть ошибку:

systemctl status fonlinebot  # статус
journalctl -u  fonlinebot.service  # логи

Проект готов, отличная работа! Все этапы разработки на Gitlab.

Заключение

Мы проделали большую работу: создали бота, настроили его взаимодействие с внешним api и загрузили на сервера. В процессе затронули кнопки, меню, callback и ошибки.

Вот несколько идей для продолжения проекта:

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

Удачи!

Полный код бота из этого урока на gitlab.

Выбор API для результатов матчей

Обычно я использую Rapid API для получения данных, там много бесплатных предложений. Под нашу задачу хорошо подходит Football Pro. Они дают 100 запросов в день, и возможность получить все результаты за раз.

Зарегистрируйтесь на Rapid Api, создайте приложение и оформите подписку на базовый (бесплатный) план. Сервис бесплатный, но для продолжения требуется карта.

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

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

Обновление настроек для API

Добавим переменные для запросов. Ключ можно найти на вкладке «Endpoints» внизу в поле «X-RapidAPI-Key». Остальные строки можно копировать у меня. Мы будем запрашивать данные по указанному адресу с заголовками для авторизации и параметрами для фильтрации.

# fonlinebot/config.py
# ...
SOCCER_API_URL = "https://football-pro.p.rapidapi.com/api/v2.0/livescores"
SOCCER_API_HEADERS = {
    'x-rapidapi-key': "ваш уникальный ключ",
    'x-rapidapi-host': "football-pro.p.rapidapi.com"
}
SOCCER_API_PARAMS = {
    "tz": "Europe/Moscow",
    "include": "localTeam,visitorTeam"
}
# ...

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

# fonlinebot/config.py
# ...
BOT_LEAGUES = {
    "82": "Немецкая Бундеслига",
    "384": "Итальянская Серия А",
    "564": "Испанская Ла Лига",
    "462": "Португальская Примейра Лига",
    "72": "Чемпионат Нидерландов",
    "2": "Лига Чемпионов",
    "5": "Лига Европы",
    "8": "Английская Премьер-лига",
    "301": "Французская Лига 1",
    "486": "Российская Премьер-лига"
}
# Флаги для сообщений, emoji-код
BOT_LEAGUE_FLAGS = {
    "82": ":Germany:",
    "384": ":Italy:",
    "564": ":Spain:",
    "462": ":Portugal:",
    "72": ":Netherlands:",
    "2": ":European_Union:",
    "5": ":trophy:",
    "8": ":England:",
    "301": ":France:",
    "486": ":Russia:"
}
# ...

Вместо тестовых 1,2,3 я добавил реальные id лиг. Вместе с этим обновились и некоторые лиги. Запустим и проверим:

Отлично, теперь можно следить за Лигой Чемпионов.

Получение данных с внешнего API

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

Посмотрим в каком виде приходят данные в ответе с помощью интерфейса сервиса. Во вкладке «Endpoints» слева выберем «Fixtures of Today» и нажмем «Test Endpoint». Ответ появится в правом столбце.

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

{
  ...
  "league_id":998
  ...
  "scores":{
    ...
    "ht_score":"0-0"
    "ft_score":"1-1"
    ...
  }
  "time":{
    "status":"FT"
    "starting_at":{
      "time":"08:00:00"
      ...
    }
    "minute":90
    ...
    "added_time":NULL
    ...
  }
  ...
  "localTeam":{
    "data":{
    ...
    "name":"Hadiya Hosaena"
    ...
    }
  }
  "visitorTeam":{
    "data":{
    ...
    "name":"Kedus Giorgis"
    ...
    }
  }
}

Для отправки запросов нужно установить библиотеку requests: pip install requests==2.25.1.

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

TODO для вас. Настройте отправку сообщения админу, если fetch_results вернула словарь с ключом "error".

# fonlinebot/app/service.py
import requests
import logging

from config import BOT_LEAGUES, BOT_LEAGUE_FLAGS, MINUTE, \
                   SOCCER_API_URL, SOCCER_API_HEADERS, SOCCER_API_PARAMS
# ...

def limit_control(headers):
    """Контроль бесплатного лимита запросов"""
    if headers.get("x-ratelimit-requests-remaining") is None:
        logging.error(f"Invalid headers response {headers}")

    if int(headers['x-ratelimit-requests-remaining']) <= 5:
        cache.setex(
            "limit_control",
            int(headers['x-ratelimit-requests-reset']),
            msg.limit_control
        )


def fetch_results() -> dict:
    SOCCER_API_PARAMS['leagues'] = ",".join(BOT_LEAGUES.keys())
    try:
        resp = requests.get(SOCCER_API_URL,
                            headers=SOCCER_API_HEADERS,
                            params=SOCCER_API_PARAMS)
    except requests.ConnectionError:
        logging.error("ConnectionError")
        return {"error": "ConnectionError"}

    limit_control(resp.headers)
    if resp.status_code == 200:
        return resp.json()
    else:
        logging.warning(f"Data retrieval error [{resp.status_code}]. Headers: {resp.headers} ")
        return {"error": resp.status_code}

#...

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

Проверку разместим в generate_results_answer. Если запись есть, мы вернем предупреждение.

# fonlinebot/app/service.py
#...

async def generate_results_answer(ids: list) -> str:
    """Функция создaет сообщение для вывода результатов матчей"""
    limit = cache.get("limit_control")
    if limit is not None:
        return limit

    results = await get_last_results(ids)
    if results == [[]]*len(ids):
        return msg.no_results
    elif msg.fetch_error in results:
        return msg.fetch_error
    else:
        text_results = results_to_text(results)
        return msg.results.format(matches=text_results)

#...

А теперь обновите «bot.py» и «dialogs.py».

# fonlinebot/app/bot.py
#...

@dp.callback_query_handler(lambda c: c.data.startswith('update_results'))
async def update_results(callback_query: types.CallbackQuery):
    """Обновление сообщения результатов"""
    if cache.get(f"last_update_{callback_query.from_user.id}") is None:
        user_leagues = callback_query.data.split("#")[1:]
        answer = await s.generate_results_answer(user_leagues)
        if answer == msg.limit_control:
            return await callback_query.answer(answer, show_alert=True)
        else:
            cache.setex(f"last_update_{callback_query.from_user.id}", MINUTE, "Updated")
            await bot.edit_message_text(
                answer,
                callback_query.from_user.id,
                message_id=int(cache.get(f"last_msg_{callback_query.from_user.id}")),
                reply_markup=s.results_kb(user_leagues)
            )
    # игнорируем обновление, если прошло меньше минуты
    await callback_query.answer(msg.cb_updated)

#...

Я дописал в функцию 2 строки для проверки answer. Если в ответе текст превышения лимита мы показываем предупреждение.

# fonlinebot/app/dialogs.py
#...

    limit_control: str = "Лимит запросов исчерпан. Возвращайтесь завтра."
    fetch_error: str = "Ошибка получения данных, попробуйте позже."
#...

Можете добавить такую запись на минуту и убедиться.

cache.setex("limit_control", 60, msg.limit_control)

На самом деле лимит начисляется каждые 24 часа с момента подписки. Если вы подписались в 13:00, значит это время обновления остатка. В заголовках ответа по ключу x-ratelimit-requests-reset можно получить остаток времени в секундах.

Очистка данных API и сохранение

Теперь напишем функцию которая распарсит ответ для сохранения в кеш.

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

# fonlinebot/app/service.py
#...
async def parse_matches() -> dict:
    """Функция сбора матчей по API"""
    data = {}
    matches = fetch_results()
    if matches.get("error", False):
        return matches

    for m in matches['data']:
        if not data.get(str(m['league_id']), False):
            data[str(m['league_id'])] = [m]
        else:
            data[str(m['league_id'])].append(m)
    return data
#...

Эту функцию мы вызываем в get_last_results, если не нашли результатов в кеше. Давайте туда допишем сохранение последних результатов:

# fonlinebot/app/service.py
#...
async def save_results(matches: dict):
    """Сохранение результатов матчей"""
    for lg_id in BOT_LEAGUES.keys():
        cache.jset(lg_id, matches.get(lg_id, []), MINUTE)


async def get_last_results(league_ids: list) -> list:
    last_results = [cache.jget(lg_id) for lg_id in league_ids]
    if None in last_results:
        all_results = await parse_matches()
        if all_results.get("error", False):
            return [msg.fetch_error]
        else:
            await save_results(all_results)
            last_results = [all_results.get(lg_id, []) for lg_id in league_ids]
    return last_results
#...

Если по какой-то лиге у нас нет записи, мы обращаемся к API и сохраняем результат на 1 минуту.

Запись логов в файл

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

# fonlinebot/config.py
#...

formatter = '[%(asctime)s] %(levelname)8s --- %(message)s (%(filename)s:%(lineno)s)'
logging.basicConfig(
    # TODO раскомментировать на сервере
    # filename=f'bot-from-{datetime.datetime.now().date()}.log',
    # filemode='w',
    format=formatter,
    datefmt='%Y-%m-%d %H:%M:%S',
    # TODO logging.WARNING 
    level=logging.DEBUG
)

#...

Теперь строка будет выглядеть так. Появилось время и место лога:

[2021-02-05 11:38:29]     INFO --- Database connection established (database.py:38)

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

Красивый вывод сообщения пользователю

Хорошо, мы получили список словарей с множеством данных. Его нужно превратить в текст формата:

Английская Премьер-лига
Окончен Тоттенхэм 0:1 (0:1) Челси

Форматирование реализуем в results_to_text.

# fonlinebot/app/service.py
#...
def add_text_time(time: dict) -> str:
    """Подбор текста в зависимости от статуса матча
    Все статусы здесь:
    https://sportmonks.com/docs/football/2.0/getting-started/a/response-codes/85#definitions
    """
    scheduled = ["NS"]
    ended = ["FT", "AET", "FT_PEN"]
    live = ["LIVE", "HT", "ET", "PEN_LIVE"]

    if time['status'] in scheduled and time['starting_at']['time'] is not None:
        # обрезаем секунды
        return time['starting_at']['time'][:-3]
    elif time['status'] in ended:
        return "Окончен"
    elif time['status'] in live and time['minute'] is not None:
        if time['extra_minute'] is not None:
            return time['minute'] + time['extra_minute']
        return time['minute']
    else:
        # для других статусов возвращаем заглушку
        return "--:--"


def results_to_text(matches: list) -> str:
    """
    Функция генерации сообщения с матчами
    Получает list[list[dict]]]
    Возвращает текст:
    | Английская Премьер-лига           |
    | Окончен Тоттенхэм 0:1 (0:1) Челси |
    ...
    """

    text = ""
    for lg_matches in matches:
        if not lg_matches:
            continue

        lg_flag = BOT_LEAGUE_FLAGS[str(lg_matches[0]['league_id'])]
        lg_name = BOT_LEAGUES[str(lg_matches[0]['league_id'])]
        text += f"{emojize(lg_flag)} {lg_name}\n"
        for m in lg_matches:
            text += f"{add_text_time(m['time']):>7} "
            if m['localteam_id'] == m['winner_team_id']:
                text += f"*{m['localTeam']['data']['name']}* "
            else:
                text += f"{m['localTeam']['data']['name']} "
            if m['time']['minute'] is not None:
                text += f"{m['scores']['localteam_score']}-{m['scores']['visitorteam_score']} "
            else:
                text += "— "
            if m['scores']['ht_score'] is not None:
                text += f"({m['scores']['ht_score']}) "
            if m['visitorteam_id'] == m['winner_team_id']:
                text += f"*{m['visitorTeam']['data']['name']}*\n"
            else:
                text += f"{m['visitorTeam']['data']['name']}\n"
        text += "\n"
    return text
#...

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

# fonlinebot/app/bot.py
#...
async def get_results(message: types.Message):
    #...
        await message.answer(answer,
                             reply_markup=s.results_kb(user_leagues),
                             parse_mode=types.ParseMode.MARKDOWN)


# ...
async def update_results(callback_query: types.CallbackQuery):
    # ...
            await bot.edit_message_text(
                answer,
                callback_query.from_user.id,
                message_id=int(cache.get(f"last_msg_{callback_query.from_user.id}")),
                parse_mode=types.ParseMode.MARKDOWN,
                reply_markup=s.results_kb(user_leagues)
            )

Запустим и проверим, как работает бот:

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

Теперь допишем немного тестов и пойдем деплоить.

Тестирование бота

Будем проверять работоспособность API и контроль лимита.

# fonlinebot/test.py
#...
import requests
import config
#...
class TestService(IsolatedAsyncioTestCase):
    #...

    def test_limit_control(self):
        test_data = {'x-ratelimit-requests-reset': "60",
                     'x-ratelimit-requests-remaining': "0"}
        service.limit_control(test_data)
        self.assertIsNotNone(cache.get("limit_control"))


class TestAPI(unittest.TestCase):
    def test_api_response(self):
        result = service.fetch_results()
        self.assertIsNotNone(result.get('data', None))

    def test_api_headers(self):
        config.SOCCER_API_PARAMS['leagues'] = ",".join(config.BOT_LEAGUES.keys())
        resp = requests.get(
            config.SOCCER_API_URL,
            headers=config.SOCCER_API_HEADERS,
            params=config.SOCCER_API_PARAMS
        )
        self.assertIsNotNone(resp.headers.get('x-ratelimit-requests-reset', None))

Бот готов! Код этого урока в начале статьи.

Дальше мы подготовим и запустим бота на удаленном сервере.

«Рыба» кода бота

Сразу запишем функции в «bot.py», которые понадобятся. Предварительно удалите test_message:

# fonlinebot/app/bot.py
# ...
dp.middleware.setup(LoggingMiddleware())


@dp.message_handler(commands=['start'])
async def start_handler(message: types.Message):
    """Обработка команды start. Вывод текста и меню"""
    ...


@dp.message_handler(commands=['help'])
async def help_handler(message: types.Message):
    """Обработка команды help. Вывод текста и меню"""
    ...


@dp.callback_query_handler(lambda c: c.data == 'main_window')
async def show_main_window(callback_query: types.CallbackQuery):
    """Главный экран"""
    ...


@dp.message_handler(lambda message: message.text == msg.btn_online)
@dp.message_handler(commands=['online'])
async def get_results(message: types.Message):
    """Обработка команды online и кнопки Онлайн.
    Запрос матчей. Вывод результатов"""
    ...


@dp.callback_query_handler(lambda c: c.data.startswith('update_results'))
async def update_results():
    """Обновление сообщения результатов"""
    ...


@dp.message_handler(lambda message: message.text == msg.btn_config)
async def get_config(message: types.Message):
    """Обработка кнопки Настройки.
    Проверка выбора лиг. Вывод меню изменений настроек"""
    ...


@dp.callback_query_handler(lambda c: c.data.startswith('edit_config'))
async def set_or_update_config(user_id: str):
    """Получение или обновление выбранных лиг"""
    ...


@dp.callback_query_handler(lambda c: c.data[:6] in ['del_le', 'add_le'])
async def update_leagues_info(callback_query: types.CallbackQuery):
    """Добавление/удаление лиги из кеша, обновление сообщения"""
    ...


@dp.callback_query_handler(lambda c: c.data == 'save_config')
async def save_config(callback_query: types.CallbackQuery):
    """Сохранение пользователя в базу данных"""
    ....

@dp.callback_query_handler(lambda c: c.data == 'delete_config')
async def delete_config(user_id: str):
    """Удаление пользователя из базы данных"""
    ...


@dp.message_handler()
async def unknown_message(message: types.Message):
    """Ответ на любое неожидаемое сообщение"""
    ...


async def on_shutdown(dp):
   # ...

Это не окончательная версия, я мог что-то упустить. В процессе добавим недостающие.

Каждая функция обернута декоратором, так мы общаемся с Телегармом:

• @dp.message_handler(commands=['start']) — декоратор ожидает сообщения-команды (которые начинаются с /). В этом примере он ожидает команду /start.
• @dp.callback_query_handler(lambda c: c.data == 'main_window') — ожидает callback и принимает lambda-функцию для его фильтрации. Callback отправляется inline-кнопками. В примере мы ожидаем callback со значением 'main_window'.
• @dp.message_handler(lambda message: message.text == msg.btn_config) — этот декоратор похож на предыдущий, но ожидает сообщение от пользователя. В примере мы будем обрабатывать сообщение с текстом из msg.btn_config.

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

Полный код бота из этого урока на gitlab.

Добавление команд в бота

Изначально команды не настроены. Пользователи могут вводить их, но специально меню нет. Для добавления нужно снова написать https://t.me/botfather команду /setcommands. Выберите своего бота и добавьте этот текст:

start - Запуск и перезапуск бота
help - Возможности бота
online - Результаты матчей

В ответ получите «Success! Command list updated. /help». Теперь можно перейти в своего бота и проверить:

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

Взаимодействие с ботом начинается с команды /start. Нужно поприветствовать и предложить следующий шаг. Эта команда будет возвращать текст с клавиатурой. Точно так же работает и /help.

Добавим обработку этих команд в «bot.py», обновите start_handler help_handler:

# fonlinebot/app/bot.py
# ...
from config import TOKEN, YEAR, MINUTE
import app.service as s

# ...
@dp.message_handler(commands=['start'])
async def start_handler(message: types.Message):
    """Обработка команды start. Вывод текста и меню"""
    # проверка, есть ли пользователь в базе
    user_league_ids = await s.get_league_ids(message.from_user.id)
    if not user_league_ids:
        await message.answer(msg.start_new_user)
        #  добавление id сообщения настроек
        cache.setex(f"last_msg_{message.from_user.id}", YEAR, message.message_id+2)
        await set_or_update_config(user_id=message.from_user.id)
    else:
        await message.answer(msg.start_current_user,
                             reply_markup=s.MAIN_KB)


@dp.message_handler(commands=['help'])
async def help_handler(message: types.Message):
    """Обработка команды help. Вывод текста и меню"""
    await message.answer(msg.help, reply_markup=s.MAIN_KB)

# ...

Я добавил импорт import app.service as s. В этом модуле клавиатура и функция проверки пользователя. start_handler проверяет есть ли пользователь в кеше или базе данных, и отправляет ему соответствующий текст.

Перед отправкой текста для выбора лиг, я сохранил его будущий id. Получил номер последнего сообщения (это сама команда «start») и добавил 2 пункта: +1 за наш ответ на команду и +1 за само сообщения выбора лиг. Зная id сообщения, его можно редактирвать.

Теперь напишем клавиатуру и get_league_ids в модуль «service».

# fonlinebot/app/service.py
from aiogram.types import ReplyKeyboardMarkup, KeyboardButton, \
                          InlineKeyboardMarkup, InlineKeyboardButton
from emoji import emojize
from config import BOT_LEAGUES, BOT_LEAGUE_FLAGS
from database import cache, database as db
from app.dialogs import msg


MAIN_KB = ReplyKeyboardMarkup(
    resize_keyboard=True,
    one_time_keyboard=True
).row(
    KeyboardButton(msg.btn_online),
    KeyboardButton(msg.btn_config)
)


async def get_league_ids(user_id: str) -> list:
    """Функция получает id лиг пользователя в базе данных"""
    leagues = cache.lrange(f"u{user_id}", 0, -1)
    if leagues is None:
        leagues = await db.select_users(user_id)
        if leagues is not None:
            leagues = leagues.split(',')
            [cache.lpush(f"u{user_id}", lg_id) for lg_id in leagues]
        else:
            return []
    return leagues

MAIN_KB — основная клавиатура, как на скриншоте выше. Разберем подробнее:

• ReplyKeyboardMarkup — объект, который создает клавиатуру.
• Параметр resize_keyboard=True уменьшает ее размер.
• А с one_time_keyboard=True клавиатура будет скрываться, после использования.
• .row — метод для группировки кнопок в строку.
• KeyboardButton(msg.btn_online) и KeyboardButton(msg.btn_config) — кнопки с заданным текстом.

Осталось только добавить текста сообщений в dialogs. Вставьте этот код в класс Messages.

# fonlinebot/app/dialogs.py
    # ...
    start_new_user: str = "Привет. Я могу сообщать тебе результаты матчей online."
    start_current_user: str = "Привет. С возвращением! " \
                              "Используй команды или меню внизу для продолжения."
    help: str = """
    Этот бот получает результаты матчей за последние 48 часов.
    Включая режим LIVE.
    - Что бы выбрать/изменить лиги нажмите "Настройки".
    - Для проверки результатов нажмите "Онлайн".
    Бот создан в учебных целях, для сайта pythonru.com
    """

Выбор, изменение и удаление лиг

Сначала внесем правки в наши вспомогательные модули.

В «dababase» в класс Database добавим новый метод insert_or_update_users.

# fonlinebot/database.py
#...

    async def insert_or_update_users(self, user_id: int, leagues: str):
        user_leagues = await self.select_users(user_id)
        if user_leagues is not None:
            await self.update_users(user_id, leagues)
        else:
            await self.insert_users(user_id, leagues)
#...

В настройки добавим переменные метрик времени:

# fonlinebot/config.py
#...

MINUTE = 60
YEAR = 60*60*24*366

И допишем текста для блока настроек:

# fonlinebot/app/dialogs.py
# ...
    league_row: str = "{i}. {flag} {name}"
    config: str = "Сейчас выбраны:\n{leagues}"
    btn_back: str = "<- Назад"
    btn_go: str = "Вперед ->"
    btn_save: str = "Сохранить"
    config_btn_edit: str = "Изменить"
    config_btn_delete: str = "Удалить данные"
    data_delete: str = "Данные успешно удалены"
    set_leagues: str = "Выбери 3 лиги для отслеживания.\nВыбраны:\n{leagues}"
    main: str = "Что будем делать?"
    db_saved: str = "Настройки сохранены"
    cb_not_saved: str = "Лиги не выбраны"
    cb_limit: str = "Превышен лимит. Максимум 3 лиги."

# ...

На этом подготовка окончена, пора написать логику добавления лиг. В модуль «service» добавим две inline-клавиатуры.

Inline-клавиатура привязана к конкретному сообщению. С их помощью можно отправлять и обрабатывать сигналы боту.

# fonlinebot/app/service.py
# ...

CONFIG_KB = InlineKeyboardMarkup().row(
    InlineKeyboardButton(msg.btn_back, callback_data='main_window'),
    InlineKeyboardButton(msg.config_btn_edit, callback_data='edit_config#')
).add(InlineKeyboardButton(msg.config_btn_delete, callback_data='delete_config'))


def leagues_kb(active_leagues: list, offset: int = 0):
    kb = InlineKeyboardMarkup()
    league_keys = list(BOT_LEAGUES.keys())[0+offset:5+offset]
    for lg_id in league_keys:
        if lg_id in active_leagues:
            kb.add(InlineKeyboardButton(
                f"{emojize(':white_heavy_check_mark:')} {BOT_LEAGUES[lg_id]}",
                callback_data=f'del_league_#{offset}#{lg_id}'
            ))
        else:
            kb.add(InlineKeyboardButton(
                BOT_LEAGUES[lg_id],
                callback_data=f'add_league_#{offset}#{lg_id}'
            ))
    kb.row(
        InlineKeyboardButton(
            msg.btn_back if offset else msg.btn_go,
            callback_data="edit_config#0" if offset else "edit_config#5"),
        InlineKeyboardButton(msg.btn_save, callback_data="save_config")
    )
    return kb
# ...

В клавиатуре CONFIG_KB 3 кнопки. Класс кнопки InlineKeyboardButton принимает текст и параметр callback_data. Именно callback нам отправит Телеграм после нажатия на кнопку. Вот так выглядит эта клавиатура:

А leagues_kb генерирует более сложную клавиатуру, с пагинацией. Мы выводим 5 лиг, кнопку «далее/назад» и «сохранить». Функция принимает выбранные лиги и отступ. Отступ нужен, для вывода лиг постранично.

Когда юзер нажимает на лигу, мы добавляем ее в кеш, нажимает повторно — удаляем. Обратите внимание, я генерирую динамическую строку в callback_data. Подставляю параметры offset и lg_id, что бы использовать при обработке.

Теперь напишем функцию красивого вывода списка лиг и обновления этого списка в кеше:

# fonlinebot/app/service.py
# ...


async def get_league_names(ids: list) -> str:
    """Функция собирает сообщение с названиями лиг из id"""
    leagues_text = ""
    for i, lg_id in enumerate(ids, start=1):
        if i != 1:
            leagues_text += '\n'
        leagues_text += msg.league_row.format(
            i=i,
            flag=emojize(BOT_LEAGUE_FLAGS.get(lg_id, '-')),
            name=BOT_LEAGUES.get(lg_id, '-')
        )
    return leagues_text


def update_leagues(user_id: str, data: str):
    """Функция добавляет или удаляет id лиги для юзера"""
    league_id = data.split("#")[-1]  # data ~ add_league_#5#345
    if data.startswith("add"):
        cache.lpush(f"u{user_id}", league_id)
    else:
        cache.lrem(f"u{user_id}", 0, league_id)

Настройка общения с Телеграмом

В файле бота допишем функции для меню настроек.

# fonlinebot/app/bot.py

@dp.callback_query_handler(lambda c: c.data == 'main_window')
async def show_main_window(callback_query: types.CallbackQuery):
    """Главный экран"""
    await callback_query.answer()
    await bot.send_message(callback_query.from_user.id, msg.main, reply_markup=s.MAIN_KB)


dp.message_handler(lambda message: message.text == msg.btn_config)
async def get_config(message: types.Message):
    """Обработка кнопки Настройки.
    Проверка выбора лиг. Вывод меню изменений настроек"""
    user_league_ids = await s.get_league_ids(message.from_user.id)
    if user_league_ids:
        cache.setex(f"last_msg_{message.from_user.id}", YEAR, message.message_id+2)
        leagues = await s.get_league_names(user_league_ids)
        await message.answer(msg.config.format(leagues=leagues),
                             reply_markup=s.CONFIG_KB)
    else:
        cache.setex(f"last_msg_{message.from_user.id}", YEAR, message.message_id+1)
        await set_or_update_config(user_id=message.from_user.id)


@dp.callback_query_handler(lambda c: c.data == 'delete_config')
async def delete_config(callback_query: types.CallbackQuery):
    """Удаление пользователя из базы данных"""
    await db.delete_users(callback_query.from_user.id)
    cache.delete(f"u{callback_query.from_user.id}")
    await callback_query.answer()
    cache.incr(f"last_msg_{callback_query.from_user.id}")
    await bot.send_message(callback_query.from_user.id,
                           msg.data_delete,
                           reply_markup=s.MAIN_KB)

Функция get_config вызывается после нажатия на «Настройки». Если у пользователя выбраны лиги, она возвращает стандартное сообщение и меню настроек. В другом случае будет вызвана set_or_update_config для выбора лиг.

Одновременно я добавил удаление данных и главный экран.

Создавать и редактировать список будем в одной функции. Ей понадобятся параметры из строки callback. Например, пользователь нажал «вперед ->» и Телеграм прислал "edit_config#5". Мы разделили строку по # и взяли последнее значение (‘5’). Так будут передаваться параметры между сообщениями.

# fonlinebot/app/bot.py

@dp.callback_query_handler(lambda c: c.data.startswith('edit_config'))
async def set_or_update_config(callback_query: types.CallbackQuery = None,
                               user_id=None, offset=""):
    """Получение или обновление выбранных лиг"""
    # если пришел callback, получим данные
    if callback_query is not None:
        user_id = callback_query.from_user.id
        offset = callback_query.data.split("#")[-1]

    league_ids = await s.get_league_ids(user_id)
    leagues = await s.get_league_names(league_ids)

    # если это первый вызов функции, отправим сообщение
    # если нет, отредактируем сообщение и клавиатуру
    if offset == "":
        await bot.send_message(
            user_id,
            msg.set_leagues.format(leagues=leagues),
            reply_markup=s.leagues_kb(league_ids)
        )
    else:
        msg_id = cache.get(f"last_msg_{user_id}")
        await bot.edit_message_text(
            msg.set_leagues.format(leagues=leagues),
            user_id,
            message_id=msg_id
        )
        await bot.edit_message_reply_markup(
            user_id,
            message_id=msg_id,
            reply_markup=s.leagues_kb(league_ids, int(offset))
        )

Не хватает еще реакции на нажатие по названию лиг и кнопке «сохранить».

# fonlinebot/app/bot.py

dp.callback_query_handler(lambda c: c.data[:6] in ['del_le', 'add_le'])
async def update_leagues_info(callback_query: types.CallbackQuery):
    """Добавление/удаление лиги из кеша, обновление сообщения"""
    offset = callback_query.data.split("#")[-2]
    s.update_leagues(callback_query.from_user.id, callback_query.data)
    await set_or_update_config(user_id=callback_query.from_user.id, offset=offset)
    await callback_query.answer()


@dp.callback_query_handler(lambda c: c.data == 'save_config')
async def save_config(callback_query: types.CallbackQuery):
    """Сохранение пользователя в базу данных"""
    leagues_list = await s.get_league_ids(callback_query.from_user.id)
    if len(leagues_list) > 3:
        # не сохраняем, если превышен лимит лиг
        await callback_query.answer(msg.cb_limit, show_alert=True)
    elif leagues_list:
        await db.insert_or_update_users(
            callback_query.from_user.id,
            ",".join(leagues_list)
        )
        await callback_query.answer()
        await bot.send_message(
            callback_query.from_user.id,
            msg.db_saved,
            reply_markup=s.MAIN_KB
        )
    else:
        # не сохраняем если список пустой
        await callback_query.answer(msg.cb_not_saved)

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

Сообщение с результатами матчей

Так как работа с API еще не настроена, напишем заглушку для этих процессов.

# fonlinebot/app/bot.py

@dp.message_handler(lambda message: message.text == msg.btn_online)
@dp.message_handler(commands=['online'])
async def get_results(message: types.Message):
    """Обработка команды online и кнопки Онлайн.
    Запрос матчей. Вывод результатов"""
    user_leagues = await s.get_league_ids(message.from_user.id)
    cache.setex(f"last_msg_{message.from_user.id}", YEAR, message.message_id+1)
    if not user_leagues:
        await set_or_update_config(user_id=message.from_user.id)
    else:
        answer = await s.generate_results_answer(user_leagues)
        cache.setex(f"last_update_{message.from_user.id}", MINUTE, "Updated")
        await message.answer(answer, reply_markup=s.results_kb(user_leagues))


@dp.callback_query_handler(lambda c: c.data.startswith('update_results'))
async def update_results(callback_query: types.CallbackQuery):
    """Обновление сообщения результатов"""
    if cache.get(f"last_update_{callback_query.from_user.id}") is None:
        user_leagues = callback_query.data.split("#")[1:]
        answer = await s.generate_results_answer(user_leagues)
        cache.setex(f"last_update_{callback_query.from_user.id}", MINUTE, "Updated")
        await bot.edit_message_text(
            answer,
            callback_query.from_user.id,
            message_id=int(cache.get(f"last_msg_{callback_query.from_user.id}"))
        )
    # игнорируем обновление, если прошло меньше минуты
    await callback_query.answer(msg.cb_updated)

get_results получает лиги и фиксирует id сообщения для редактирования. Если у пользователя нет сохраненных лиг — вызывает set_or_update_config, в другом случает генерируем ответ с матчами и кнопкой «обновить».

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

Допишем зависимости:

# fonlinebot/app/dialogs.py
#...

    results: str = "Все результаты за сегодня\n{matches}"
    no_results: str = "Сегодня нет матчей"
    update_results: str = "Обновить результаты"
    cb_updated: str = f"{emojize(':white_heavy_check_mark:')} Готово"

#...

Кнопку обновления и генерацию ответа в «service.py».

# fonlinebot/app/service.py
from config import BOT_LEAGUES, BOT_LEAGUE_FLAGS, MINUTE
#...

def results_kb(leagues: list):
    params = [f"#{lg}" for lg in leagues]
    kb = InlineKeyboardMarkup()
    kb.add(InlineKeyboardButton(
        msg.update_results,
        callback_data=f"update_results{''.join(params)}"
    ))
    return kb


async def generate_results_answer(ids: list) -> str:
    """Функция создaет сообщение для вывода результатов матчей"""
    results = await get_last_results(ids)
    if results:
        text_results = results_to_text(results)
        return msg.results.format(matches=text_results)
    else:
        return msg.no_results


def ids_to_key(ids: list) -> str:
    """Стандартизация ключей для хранения матчей"""
    ids.sort()
    return ",".join(ids)


async def parse_matches(ids: list) -> list:
    """Функция получения матчей по API"""
    # логику напишем в следующей части
    return []


async def get_last_results(league_ids: list) -> list:
    lg_key = ids_to_key(league_ids)
    last_results = cache.jget(lg_key)
    if last_results is None:
        last_results = await parse_matches(league_ids)
        if last_results:
            # добавляем новые матчи, если они есть
            cache.jset(lg_key, last_results, MINUTE)
    return last_results


def results_to_text(matches: list) -> str:
    """
    Функция генерации сообщения с матчами
    """
    # логику напишем в следующей части
    ...

#...

Функция generate_results_answer получает матчи, преобразовывает данные в текст и возвращает его. Если матчей нет, возвращает соответствующий текст.

Что бы сэкономить ресурсы мы проверяем наличие матчей в кеше и только потом обращаемся к API.

Обработка неизвестных сообщений

Люди будут писать текст, который мы не обрабатываем. Обновите класс Messages:

# fonlinebot/app/dialogs.py
#...
    unknown_text: str = "Ничего не понятно, но очень интересно.\nПопробуй команду /help"

#...

И unknown_message.

# fonlinebot/app/bot.py
#...

@dp.message_handler()
async def unknown_message(message: types.Message):
    """Ответ на любое неожидаемое сообщение"""
    await message.answer(msg.unknown_text, reply_markup=s.MAIN_KB)

#...

Убедимся, что все работает:

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

Обновление тестов

Добавим класс TestService для контроля функции get_league_ids и get_last_results.

# fonlinebot/test.py
from app import bot, service
#...


class TestService(IsolatedAsyncioTestCase):
    async def test_get_league_ids(self):
        ids = await service.get_league_ids("1111")
        self.assertEqual(type(ids), list)

    async def test_get_last_results(self):
        results = await service.get_last_results(["1", "2", "3"])
        self.assertEqual(type(results), list)
#...

Ссылка на репозиторий с кодом в начале статьи. Удачи!

Что дальше?

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

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

Вся разработка разбита на этапы:

1. Локальная установка библиотек и Redis.
2. Регистрация и получение токена.
3. Настройка , подключение к базам данных.
4. Написание основной функциональности бота.
5. Регистрации, выбор и настройка внешнего апи футбольных матчей.
6. Добавление сбора результатов матчей и интеграция в бота.
7. Деплой, публикация на сервере:
   1. Регистрация дешевого или бесплатного VPS.
   2. Запуск Редис-клиента.
   3. Запуск и настройка бота на сервере.

Рабочая версия бота запущена в телеграме до конца февраля @FonlineBOT. Бот отключен.

Вводные данные

Материал рассчитан на уровень Начинающий+, нужно понимать как работают классы и функции, знать основы базы данных и async/await. Если знаний мало, крайне желательно писать код в Pycharm, бесплатная версия подходит.

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

Версия Python - 3.8+

aiogram==2.11.2
emoji==1.1.0
redis==3.5.3
ujson==4.0.1
uvloop==0.14.0  # не работает и не требуется на Windows

Репозиторий с кодом этой для этой части бота:
https://gitlab.com/PythonRu/fonlinebot/-/tree/master/first_step

Локальная установка библиотек для бота и Redis

Для начала нужно создать проект «fonlinebot» с виртуальным окружение. В Pycharm это делается так:

Затем установить библиотеки в виртуальном окружении. Сразу понадобятся 4: для бота, работы с redis, ускорения и emoji в сообщениях.

pip install aiogram==2.11.2 redis==3.5.3 ujson==4.0.1 emoji==1.1.0

Установка Redis локально

Redis — это резидентная база данных (такая, которая хранит записи прямо в оперативной памяти) в виде пар ключ-значение. Чтение и запись в память происходит намного быстрее, чем в случае с дисками, поэтому такой подход отлично подходит для хранения второстепенных данных.

Из недавней статьи — Redis для приложений на Python

Для установки Redis на Linux/Mac следуйте этим инструкциям: https://redis.io/download#from-source-code. Для запуска достаточно ввести src/redis-server.

Что бы установить на Windows скачайте и распакуйте архив отсюда. Для запуска откройте «redis-server.exe».

Теперь нужно убедиться, что все работает. Создайте файл «main.py» в корне проекта и выполните этот код:

# fonlinebot/main.py
import redis


r = redis.StrictRedis()
print(r.ping())

Вывод будет True, в другом случае ошибка.

Регистрация бота и получение токена

Для регистрации напишем https://t.me/botfather команду /newbot. Далее он просит ввести имя и адрес бота. Если данные корректны, выдает токен. Учтите, что адрес должен быть уникальным, нельзя использовать «fonlinebot» снова.

На время разработки сохраним токен в файл. Создайте «config.py» в папке проекта для хранения настроек и запишите токен TOKEN = "ВАШ ТОКЕН"

Настройка бота

Теперь нужно связать бота с redis и базой данных, проверить работоспособность.

Создадим необходимые модули и файлы. В папке «fonlinebot» к созданным ранее «main.py» и «config.py» добавим: «database.py», «requirements.txt» и папку «app». В папку «app» добавьте: «bot.py», «dialogs.py», «service.py». Вот такая структура получится:

Разделив бот на модули, его удобнее поддерживать и дорабатывать.

• «main.py» — для запуска бота.
• «config.py» — хранит настройки, ключи доступов и другую статическую информацию.
• «database.py» — для работы с базой данных и кешем(redis).
• «requirements.txt» — хранит зависимости проекта, для запуска на сервере.
• «app» — папка самого бота.
  • «bot.py» — для взаимодействия бота с юзерами, ответы на сообщения.
  • «dialogs.py» — все текстовые ответы бота.
  • «service.py» — бизнес логика, получение и обработка данных о матчах.

Пришло время перейти к программированию. Запишем в «requirements.txt» наши зависимости:

aiogram==2.11.2
emoji==1.1.0
redis==3.5.3
ujson==4.0.1
uvloop==0.14.0

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

В «config.py» к токену добавим данные бота и подключения к redis.

# fonlinebot/config.py
import ujson
import logging
logging.basicConfig(level=logging.INFO)


TOKEN = "здесь должен быть токен"
BOT_VERSION = 0.1
# База данных хранит выбранные юзером лиги
BOT_DB_NAME = "users_leagues"
# Тестовые данные поддерживаемых лиг
BOT_LEAGUES = {
    "1": "Бундеслига",
    "2": "Серия А",
    "3": "Ла Лига",
    "4": "Турецкая Суперлига",
    "5": "Чемпионат Нидерландов",
    "6": "Про-лига Бельгии",
    "7": "Английская Премьер-лига",
    "8": "Лига 1",
}
# Флаги для сообщений, emoji-код
BOT_LEAGUE_FLAGS = {
    "1": ":Germany:",
    "2": ":Italy:",
    "3": ":Spain:",
    "4": ":Turkey:",
    "5": ":Netherlands:",
    "6": ":Belgium:",
    "7": ":England:",
    "8": ":France:",
}

# Данные redis-клиента
REDIS_HOST = 'localhost'
REDIS_PORT = 6379
# По умолчанию пароля нет. Он будет на сервере
REDIS_PASSWORD = None

Информацию о лигах в будущем можно будет вынести в отдельный json файл. Эта версия бота будет поддерживать не более 10 вариантов, я явно их записал.

Добавление базы данных

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

Юзер будет выбирать 3 чемпионата для отслеживания, бот сохранит их в БД и использует для запроса результатов.

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

# fonlinebot/database.py
import os
import logging
import sqlite3
import redis
import ujson

import config


# класс наследуется от redis.StrictRedis
class Cache(redis.StrictRedis):
    def __init__(self, host, port, password,
                 charset="utf-8",
                 decode_responses=True):
        super(Cache, self).__init__(host, port,
                                    password=password,
                                    charset=charset,
                                    decode_responses=decode_responses)
        logging.info("Redis start")

    def jset(self, name, value, ex=0):
        """функция конвертирует python-объект в Json и сохранит"""
        r = self.get(name)
        if r is None:
            return r
        return ujson.loads(r)

    def jget(self, name):
        """функция возвращает Json и конвертирует в python-объект"""
        return ujson.loads(self.get(name))

Класс Cache наследуется от StrictRedis. Мы добавляем 2 метода jset, jget для сохранения списков и словарей python в хранилище redis. Изначально он не работает с ними.

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

# fonlinebot/database.py
#...


class Database:
    """ Класс работы с базой данных """
    def __init__(self, name):
        self.name = name
        self._conn = self.connection()
        logging.info("Database connection established")

    def create_db(self):
        connection = sqlite3.connect(f"{self.name}.db")
        logging.info("Database created")
        cursor = connection.cursor()
        cursor.execute('''CREATE TABLE users 
                          (id INTEGER PRIMARY KEY,
                           leagues VARCHAR NOT NULL);''')
        connection.commit()
        cursor.close()

    def connection(self):
        db_path = os.path.join(os.getcwd(), f"{self.name}.db")
        if not os.path.exists(db_path):
            self.create_db()
        return sqlite3.connect(f"{self.name}.db")

    def _execute_query(self, query, select=False):
        cursor = self._conn.cursor()
        cursor.execute(query)
        if select:
            records = cursor.fetchone()
            cursor.close()
            return records
        else:
            self._conn.commit()
        cursor.close()

    async def insert_users(self, user_id: int, leagues: str):
        insert_query = f"""INSERT INTO users (id, leagues)
                                       VALUES ({user_id}, "{leagues}")"""
        self._execute_query(insert_query)
        logging.info(f"Leagues for user {user_id} added")

    async def select_users(self, user_id: int):
        select_query = f"""SELECT leagues from leagues 
                           where id = {user_id}"""
        record = self._execute_query(select_query, select=True)
        return record

    async def update_users(self, user_id: int, leagues: str):
        update_query = f"""Update leagues 
                              set leagues = "{leagues}" where id = {user_id}"""
        self._execute_query(update_query)
        logging.info(f"Leagues for user {user_id} updated")

    async def delete_users(self, user_id: int):
        delete_query = f"""DELETE FROM users WHERE id = {user_id}"""
        self._execute_query(delete_query)
        logging.info(f"User {user_id} deleted")

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

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

# fonlinebot/database.py
#...


# создание объектов cache и database
cache = Cache(
    host=config.REDIS_HOST,
    port=config.REDIS_PORT,
    password=config.REDIS_PASSWORD
)
database = Database(config.BOT_DB_NAME)

Добавление текстовых сообщений

Для шаблонов сообщений создадим неизменяемый dataclass. Здесь будут все текстовые ответы. А dataclass удобно использовать при вызове аргументов.

# fonlinebot/app/dialogs.py
from dataclasses import dataclass


@dataclass(frozen=True)
class Messages:
    test: str = "Привет {name}. Работаю..."


msg = Messages()

Создание бота

В файле «bot.py» создадим бота. Импортируем зависимости, создадим объект бота и первое сообщение.

# fonlinebot/app/bot.py
from aiogram import Bot, types
from aiogram.contrib.middlewares.logging import LoggingMiddleware
from aiogram.dispatcher import Dispatcher

from config import TOKEN
from app.dialogs import msg
from database import database as db


# стандартный код создания бота
bot = Bot(token=TOKEN)
dp = Dispatcher(bot)
dp.middleware.setup(LoggingMiddleware())


@dp.message_handler()
async def test_message(message: types.Message):
    # имя юзера из настроек Телеграма
    user_name = message.from_user.first_name
    await message.answer(msg.test.format(name=user_name))

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

# fonlinebot/app/bot.py
# ...

async def on_shutdown(dp):
    logging.warning('Shutting down..')
    # закрытие соединения с БД
    db._conn.close()
    logging.warning("DB Connection closed")

Первый запуск бота

Для запуска используем файл «main.py». Импортируем бота и настроим пулинг:

# fonlinebot/main.py
from aiogram import executor

from app import bot


executor.start_polling(bot.dp, 
                       skip_updates=True, 
                       on_shutdown=bot.on_shutdown)

Теперь запустим проект. Если вы в Pycharm, откройте вкладку «Terminal» и введите python main.py. Что бы запустить бота без Pycharm:

• перейдите в папку проекта,
• активируйте виртуальное окружение,
• запустите скрипт (python main.py).

Теперь откроем телеграм и проверим.

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

Тестирование бота

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

Добавьте модуль «test.py» в папку fonlinebot. На этом этапе достаточно 4 теста, вы можете добавить свои.

# fonlinebot/test.py
import unittest
import aiohttp
from unittest import IsolatedAsyncioTestCase

from database import cache, database
from app import bot


class TestDatabase(IsolatedAsyncioTestCase):
    async def test_crud(self):
        await database.insert_users(1111, "1 2 3")
        self.assertEqual(await database.select_users(1111), ('1 2 3',))
        await database.delete_users(1111)
        self.assertEqual(await database.select_users(1111), None)


class TestCache(unittest.TestCase):
    def test_connection(self):
        self.assertTrue(cache.ping())

    def test_response_type(self):
        cache.setex("test_type", 10, "Hello")
        response = cache.get("test_type")
        self.assertEqual(type(response), str)


class TestBot(IsolatedAsyncioTestCase):
    async def test_bot_auth(self):
        bot.bot._session = aiohttp.ClientSession()
        bot_info = await bot.bot.get_me()
        await bot.bot._session.close()

        self.assertEqual(bot_info["username"], "FonlineBOT")


if __name__ == '__main__':
    unittest.main()

Мы проверим CRUD функции базы данных, запишем тестовые данные и удалим. Проверим соединение с redis и ботом.

Запуск теста такой же как и бота, изменяется только имя файла python main.py.

На скриншоте видно уведомление об ошибке после завершения тестирования. Это известная проблема aiohttp на windows, можно игнорировать.

Ошибки, которые можно встретить

1. aiogram.utils.exceptions.Unauthorized: Unauthorized — неверный токен бота. Токен нужно сохранить как строку, его структура «цифры:буквы-и-цифры», проверьте.
2. redis.exceptions.ConnectionError: Error 10061 connecting to ... — redis-server не запущен.
3. sqlite3.IntegrityError: UNIQUE constraint failed: ... — вы пытаетесь добавить значение в базу данных, которое уже существует.

На этом подготовка проекта окончена. Переходите ко второй части: Написание ядра бота.

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

• date — хранит дату
• time — хранит время
• datetime — хранит дату и время

Как получить текущие дату и время?

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

import datetime



dt_now = datetime.datetime.now()

print(dt_now)

А вот результат:

2020-11-14 15:43:32.249588

Получить текущую дату в Python

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

from datetime import date



current_date = date.today()

print(current_date)

Результат:

2020-11-14

Текущая дата — 2020-11-14 в формате год-месяц-день соответственно.

Получить текущее время

Для получения текущего локального времени сперва нужно получить текущие дату и время, а затем достать из этого объекта только время с помощью метода time():

import datetime



current_date_time = datetime.datetime.now()

current_time = current_date_time.time()

print(current_time)

Результат:

15:51:05.627643

Компоненты datetime в Python

Модуль datetime в Python может использоваться для получения разных версий времени. Для этого нужно ознакомиться с атрибутами модуля. Используем для этого функцию dir().

import datetime



attr = dir(datetime)

print(attr)

# ['MAXYEAR', 'MINYEAR', '__doc__', '__name__', '__package__', 'date', 'datetime',

# 'datetime_CAPI', 'time', 'timedelta', 'tzinfo']

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

• date — объекты даты
• datetime — объекты даты и времени
• time — объекты времени
• timedelta — этот атрибут покрывает интервалы и используется для определения прошлых или будущих событий
• Tzinfo — этот атрибут отвечает за часовые пояса

Как создавать объекты даты и времени

Для создания объекта времени используется класс time из модуля datetime в Python. Синтаксис следующий: datetime.time(hour, minutes, seconds).

В этом примере создается объект времени представленный следующим образом (8, 48, 45).

import datetime



timeobj= datetime.time(8,48,45)

print(timeobj)

Результат такой:

08:48:45

Сначала импортируется модуль datetime. После этого создается экземпляр класса (объект time). Затем ему присваивается значение datetime.time(8, 48, 45), где параметры 8, 48 и 45 представляют собой часы, минуты и секунды соответственно.

Для создания объекта даты нужно передать дату с использованием следующего синтаксиса:

datetime.datetime(year,month,day))

Такой пример:

import datetime



date_obj = datetime.datetime(2020,10,17)

print(date_obj)

Вернет вот такой результат:

2020-10-17 00:00:00

Timedelta

timedelta представляет длительность (даты или времени). Модуль datetime включает атрибут timedelta(), который используется для управления датой в Python. Объект timedelta выглядит следующим образом:

td_object =timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)

td_object

datetime.timedelta(0)

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

Как вычислить разницу для двух дат

Посмотрим на несколько примеров вычисления разницы во времени. Предположим, есть два объекта datetime:

first_date = date(2020, 10, 2)
second_date = date(2020, 10, 30)

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

from datetime import date



first_date = date(2020, 10, 2)

second_date = date(2020, 10, 30)

delta = second_date - first_date

print(delta)

Результат:

28 days,0:00:00

Таким образом между 2 и 30 октября 2020 года 28 дней.

Как вычислить разницу двух объектов datetime.time

С помощью timedelta нельзя выполнять манипуляции над объектами time. Например:

from datetime import datetime, timedelta



current_datetime = datetime.now()

current_time = current_datetime.time()

print("Текущее время:", current_time)

tm_after_1_hr = current_time + timedelta(hours=1)

print(tm_after_1_hr)

Такой код вернет следующую ошибку:

Traceback (most recent call last):
  File "C:\Users\alex\AppData\Local\Programs\Python\Python38\sg_verify.py", line 6, in <module>
    tm_after_1_hr = current_time + timedelta(hours=1)
TypeError: unsupported operand type(s) for +: 'datetime.time' and 'datetime.timedelta'

Как получать прошлые и будущие даты с помощью timedelta

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

import datetime



current_date = datetime.datetime.today()

past_date = datetime.datetime.today() – datetime.timedelta(days=n)

future_date = datetime.datetime.today() – datetime.timedelta(days=n)

Если нужно, например, получить дату за прошлые две недели, то достаточно вычесть 14 дней из текущей даты:

import datetime



past_date = datetime.datetime.today() - datetime.timedelta(days=14)

print(past_date)

Результат:

2020-10-31 16:12:09.142258

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

import datetime



future_date = datetime.datetime.today() + datetime.timedelta(days=21)

print(future_date)

Результат:

2020-12-05 16:14:09.718325

Другие арифметические операции с timedelta

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

import datetime



now = datetime.time(9, 31, 0)

next_hour = datetime.time(10, 31, 0)

print('now < next_hour:', now < next_hour)
today = datetime.date.today()
next_week = datetime.date.today() + datetime.timedelta(days=7)
print('today > next_week:', today > next_week)

Результат:

now < next_hour: True
today > next_week: False

Часовые пояса

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

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

Относительные же содержат достаточно информации для определения часового пояса или отслеживания изменений из-за летнего времени.

Разница между DST, GMT и UTC

1. GMT
   Официальный часовой пояс, используемый в некоторых странах Европы и Африки. Он может быть представлен как в 24, так и в 12-часовом форматах. GMT используется для того, чтобы задавать местное время. Например, местное время для Берлина 2020–10–17 09:40:33.614581+02:00 GMT. Для Найроби же это — 2020–10–17 10:40:33.592608+03:00 GMT.
   
2. DST (летнее время)
   Страны, которые переходят на летнее время, делают это для того, чтобы дневное время длилось как можно дольше. Во время летнего времени они переводят стрелки своих часов на час вперед и возвращаются обратно осенью.
   
3. UTC (всемирное координированное время)
   Временной стандарт для часовых поясов во всем мире. Он позволяет синхронизировать время во всем мире и служит отправной точкой для остальных.

Как работать с часовыми поясами

Рассмотрим, как создать простой относительный объект datetime:

import datetime



dt_now = datetime.datetime.utcnow()

print(dt_now)

Эта программа возвращает объект с абсолютным значением datetime. Если же нужно сделать его абсолютным, то нужно явно указать часовой пояс. Как это сделать? В библиотеке datetime в Python нет модуля для работы с часовыми поясами. Для этого нужно использовать другие библиотеки. Одна из таких — pytz.

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

import pytz



pytz.all_timezones

Вот некоторые из них:

['Africa/Abidjan', 'Africa/Accra', 'Africa/Addis_Ababa', 'Africa/Nairobi']

Для получения времени в Найроби:

import pytz

import datetime



tz_nairobi = pytz.timezone("Africa/Nairobi")

dt_nairobi =datetime.datetime.now(tz_nairobi)

print(dt_nairobi)

Результат:

2020-11-14 17:27:31.141255+03:00

А вот так можно получить время Берлина:

import pytz

import datetime



tz_berlin = pytz.timezone("Europe/Berlin")

dt_berlin =datetime.datetime.now(tz_berlin)

print(dt_berlin)

Результат:

2020-11-14 15:28:20.977529+01:00

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

Конвертация часовых поясов

При конвертации часовых поясов в первую очередь нужно помнить о том, что все атрибуты представлены в UTC. Допустим, нужно конвертировать это значение в America/New_York:

import datetime

import pytz



timezone_berlin = '2019-06-29 17:08:00'

tz_ber_obj = datetime.datetime.strptime(timezone_berlin, '%Y-%m-%d %H:%M:%S')

timezone_newyork = pytz.timezone('America/New_York')

timezone_newyork_obj = timezone_newyork.localize(tz_ber_obj)

print(timezone_newyork_obj)

print(timezone_newyork_obj.tzinfo)

Результат:

2019-06-29 17:08:00-04:00
America/New_York

Другие практические примеры

Всегда храните даты в UTC. Вот примеры:

import datetime

import pytz



time_now = datetime.datetime.now(pytz.utc)

print(time_now)

Результат для этого кода — 2020-11-14 14:38:46.462397+00:00, хотя локальное время может быть, например, таким 2020-11-14 16:38:46.462397+00:00. А уже при демонстрации даты пользователю стоит использовать метод localize с местными настройками:

import datetime

import pytz



now = datetime.datetime.today()

now_utc = pytz.utc.localize(now)

Вернет текущее локальное время — 2020-11-14 16:42:38.228528+00:00.

Как конвертировать строки в datetime

strptime() в Python — это метод из модуля datetime. Вот его синтаксис:

dateobj = datetime.strptime(date_string, format)

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

import datetime



current_dt = datetime.datetime.now()

print(current_dt)

Результат:

2020-11-14 16:50:45.049229

Результат будет в формате ISO 8601, то есть YYYY-MM-DDTHH:MM:SS.mmmmmm — формат по умолчанию, что позволяет получать строки в едином формате.

Таблица форматов:

import datetime



date_string = "11/17/20"

date_obj = datetime.datetime.strptime(date_string, '%m/%d/%y')

print(date_obj)

Результат:

2020-11-17 00:00:00

Примеры конвертации строки в объект datetime с помощью strptime

Предположим, что есть следующая строка с датой: «11/17/20 15:02:34», и ее нужно конвертировать в объект datetime.

from datetime import datetime



datetime_string = "11/17/20 15:02:34"

datetime_obj = datetime.strptime(datetime_string, '%m/%d/%y %H:%M:%S')

print(datetime_obj)

Результат:

2020-11-17 15:02:34

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

• Friday, November 17, 2020;
• 11/17/20;
• 11–17–2020.

Вот как это работает:

from datetime import datetime



# создадим даты как строки

ds1 = 'Friday, November 17, 2020'

ds2 = '11/17/20'

ds3 = '11-17-2020'



# Конвертируем строки в объекты datetime и сохраним

dt1 = datetime.strptime(ds1, '%A, %B %d, %Y')

dt2 = datetime.strptime(ds2, '%m/%d/%y')

dt3 = datetime.strptime(ds3, '%m-%d-%Y')



print(dt1)

print(dt2)

print(dt3)

Результат будет одинаковым для всех форматов:

2020-11-17 00:00:00
2020-11-17 00:00:00
2020-11-17 00:00:00

Практические примеры

Если строка представлена в формате «Oct 17 2020 9:00PM», то ее можно конвертировать следующим образом:

date_string = 'Oct 17 2020 9:00PM'

date_object = datetime.strptime(date_string, '%b %d %Y %I:%M%p')

print(date_object)

Результат — 2020-10-17 21:00:00.

Функцию strptime() можно использовать для конвертации строки в объект даты:

from datetime import datetime



date_string = '10-17-2020'

date_object = datetime.strptime(date_string, '%m-%d-%Y').date()

print(type(date_object))

print(date_object)

Результат:

<type 'datetime.date'>
2020-10-17

Как конвертировать объект datetime в строку

Модуль datetime в Python содержит метод strftime(), который делает обратное (то есть, конвертирует объект datetime и time в строки). Вот его синтаксис:

datetime_string = datetime_object.strftime(format_string)
time_string = datetime_object.strftime(format_string[,time_object])

Примеры конвертации datetime в строку с помощью strftime()

Предположим, нужно конвертировать текущий объект datetime в строку. Сначала нужно получить представление объекта datetime и вызвать на нем метод strftime().

import datetime



current_date = datetime.datetime.now()

current_date_string = current_date.strftime('%m/%d/%y %H:%M:%S')

print(current_date_string)

Результат — 11/14/20 17:15:03.

Как получить строковое представление даты и времени с помощью функции format()

Пример №1. Конвертация текущей временной метки в объекте datetime в строку в формате «DD-MMM-YYYY (HH:MM:SS:MICROS)»:

import datetime



dt_obj =datetime.datetime.now()

dt_string = dt_obj.strftime("%d-%b-%Y (%H:%M:%S.%f)")

print('Текущее время : ', dt_string)

Результат:

Текущее время :  14-Nov-2020 (17:18:09.890960)

Пример №2. Конвертация текущей временной метки объекта datetime в строку в формате «HH:MM:SS.MICROS – MMM DD YYYY».

import datetime



dt_obj =datetime.datetime.now()

dt_string = dt_obj.strftime("%H:%M:%S.%f - %b %d %Y")

print('Текущее время : ', dt_string)

Результат:

Текущее время :  17:20:28.841390 - Nov 14 2020

Другие datetime-библиотеки в Python

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

Arrow

Arrow — еще один популярный модуль, который делает более простым процесс создания, управления и форматирования дат и времени. Получить его можно с помощью pip. Для установки достаточно ввести pip install arrow.

Arrow можно использовать для получения текущего времени по аналогии с модулем datetime:

import arrow



current_time = arrow.now()

print(current_time)

print(current_time.to('UTC'))

Результат:

2020-11-14T15:52:58.921198+00:00
2020-11-14T15:52:58.921198+00:00

Maya

Maya упрощает процесс парсинга строк и конвертации часовых поясов. Например:

import maya



dt = maya.parse('2019-10-17T17:45:25Z').datetime()

print(dt.date())

print(dt)

print(dt.time())

Результат:

2019-10-17
2019-10-17 17:45:25+00:00
17:45:25

Dateutil

Dateutil — это мощная библиотека, которая используется для парсинга дат и времени в разных форматах. Вот некоторые примеры.

from dateutil import parser



dt_obj = parser.parse('Thu Oct 17 17:10:28 2019')

print(dt_obj)
dt_obj1=parser.parse('Thursday, 17. October 2019 5:10PM')

print(dt_obj1)
dt_obj2=parser.parse('10/17/2019 17:10:28')

print(dt_obj2)
t_obj=parser.parse('10/17/2019')

print(t_obj)

Результат:

2019-10-17 17:10:28
2019-10-17 17:10:00
2019-10-17 17:10:28
2010-10-17 00:00:00

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

Важные нюансы

Вот о чем важно помнить при работе с datetime в Python:

• Рекомендуется всегда работать с UTC. Это позволяет не думать о часовых поясах, что часто приводит к ошибкам из-за разницы во времени в разных регионах.
• Дату и время стоит конвертировать в локальную только при выводе пользователю.

Выводы

Есть масса сценариев работы с датой и временем в реальных приложениях. Например:

• Запланировать работу скрипта на определенное время.
• Отфильтровать даты.
• Извлечь дату из определенных API каждый день, в определенное время.
• Приложения для отслеживания событий, записей, бронирования и так далее.

В этом материале разберемся с этой функцией и рассмотрим более продвинутые вещи.

Как выводить текст в Python 3

Выводить текст в Python очень просто. Достаточно лишь написать:

print("Текст для вывода")

Но все становится чуть сложнее, учитывая, что существуют две популярные версии Python. Этот пример сработает с Python 3+ (поддерживаемой сегодня версией), однако стоит убрать скобки в том случае, если это Python 2:

print "Текст для вывода"

Вывод строк и других переменных

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

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

Например:

hello_world = "Hello world!"

print(hello_world)

Этот код хранит строку "Hello world!" в переменной hello_world. Позже ее можно будет использовать для вывода текста, указав в скобках без кавычек.

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

name = input("Введите ваше имя пожалуйста: ")

print("Привет " + name)

Если запустить этот код и ввести «Витя» получим:

Введите ваше имя пожалуйста: Витя
Привет Витя

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

Некоторые приемы вывода

Если при выводе текста в Python после него нужна пустая строка, то для этого используется символ \n.:

print("Привет\n")

print(name)

Привет
Витя

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

print('Он "умеет" кодить!')

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

print("""Я сказал "Привет" и все еще жду, когда 'они' ответят мне""")

Вот и все что нужно знать о выводе текста в Python.

Краткий итог

Что бы вывести текст в python достаточно вызвать функцию print(). Например: print("Ваш текст").

В этом материале речь пойдет о следующем:

• Как определять символ новой строки в Python.
• Как использовать символ новой строки в строках и инструкциях вывода.
• Вывод текста без добавления символа новой строки в конце.

Символ новой строки

Символ новой строки в Python выглядит так \n. Он состоит из двух символов:

• Обратной косой черты.
• Символа n (в нижнем регистре).

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

>>> print("Hello\nWorld!")
Hello
World!

Его же можно использовать в f-строках: print(f"Hello\nWorld!").

Символ новой строки в print

По умолчанию инструкции вывода добавляют символ новой строки «за кулисами» в конце строки. Вот так:

Это поведение описано в документации Python. Значение параметра end встроенной функции print по умолчанию — \n. Именно таким образом символ новой строки добавляется в конце строки.

Вот определение функции:

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

Значением end='\n', поэтому именно этот символ будет добавлен к строке.

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

print("Hello, World 1!")

print("Hello, World 2!")

print("Hello, World 3!")

print("Hello, World 4!")

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

Hello, World 1!
Hello, World 2!
Hello, World 3!
Hello, World 4!

Как использовать print без символа новой строки

Изменить поведение по умолчанию можно, изменив значение параметра end в функции print. В этом примере настройки по умолчанию приведут к такому результату:

>>> print("Hello")

>>> print("World")

Hello

World

Но если указать значением end пробел (" "), то этот он будет добавлен в конце строки вместо \n, поэтому вывод отобразится на одной строке:

>>> print("Hello", end=" ")

>>> print("World")

Hello World

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

for i in range(15):

    if i < 14:

        print(i, end=", ")

    else:

        print(i)

Вывод будет такой:

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14

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

Таким же образом можно использовать print для вывода значений итерируемого объекта в одну строку:

data = [1, 2, 3, 4, 5]



for num in range(len(data)):

    print(data[num], end=" ")

Вывод:

1 2 3 4 5 

Для вывода всех элементов списка списка , лучше использовать join: " ".join([str(i) for i in data])

Символ новой строки в файлах

Символ новой строки можно найти и в файлах, но он «скрыт». Создадим файл с именами. Каждое имя будет на новой строке.

names = ['Petr', 'Dima', 'Artem', 'Ivan']



with open("names.txt", "w") as f:

    for name in names[:-1]:

        f.write(f"{name}\n")

    f.write(names[-1])

Если в текстовом файле есть разделение на несколько строк, то это значит, что в конце предыдущей символ \n. Проверить это можно с помощью функции .readlines():

with open("names.txt", "r") as f:

    print(f.readlines())

Вывод:

['Petr\n', 'Dima\n', 'Artem\n', 'Ivan']

Так, первые три строки текстового файла заканчиваются символом новой строки \n, которая работает «за кулисами».

Выводы

• Символ новой строки в Python — это \n. Он используется для обозначения окончания строки текста.
• Вывести текст без добавления новой строки можно с помощью параметра end ="<character>", где <character> — это символ, который дальше будет использоваться для разделения строк.

numbers = [1, 1, 2, 3, 3, 4]

Но нужен список с уникальными числами:

numbers = [1, 2, 3, 4]

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

Вариант №1. Использование множества (set) для получения элементов

Использование множества (set) — один из вариантов. Он удобен тем, что включает только уникальные элементы. После этого множество можно обратно превратить в список.

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

numbers = [1, 2, 2, 3, 3, 4, 5]



def get_unique_numbers(numbers):

    list_of_unique_numbers = []

    unique_numbers = set(numbers)



    for number in unique_numbers:

        list_of_unique_numbers.append(number)



    return list_of_unique_numbers



print(get_unique_numbers(numbers))

Разберем, что происходит на каждом этапе. Есть список чисел numbers. Передаем его в функцию get_unique_numbers.

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

unique_numbers = set(numbers)

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

for number in unique_numbers:

       list_of_unique_numbers.append(number)

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

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

Короткий вариант с set

Весь код выше можно сжать в одну строку с помощью встроенных в Python функций.

numbers = [1, 2, 2, 3, 3, 4, 5]

unique_numbers = list(set(numbers))

print(unique_numbers)

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

unique_numbers = list(set(numbers))

Проще всего думать «изнутри наружу» при чтении этого кода. Самый вложенный код выполняется первым: set(numbers). Затем — внешний блок: list(set(numbers)).

Вариант №2. Использование цикла for

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

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

Рассмотрим два способа использования цикла. Начнем с более подробного.

numbers = [20, 20, 30, 30, 40]



def get_unique_numbers(numbers):

    unique = []



    for number in numbers:

        if number in unique:

            continue

        else:

            unique.append(number)

    return unique



print(get_unique_numbers(numbers))

Вот что происходит на каждом этапе. Сначала есть список чисел numbers. Он передается в функцию get_unique_numbers.

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

Цикл будет использоваться для перебора по числам в списке numbers.

    for number in numbers:

        if number in unique:

            continue

        else:

            unique.append(number)

Условные конструкции в цикле проверяют, есть ли число текущей итерации в списке unique. Если да, то цикл переходит на следующую итерации. Если нет — число добавляется в список.

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

Короткий способ с циклом

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

numbers = [20, 20, 30, 30, 40]



def get_unique_numbers(numbers):

    unique = []

    for number in numbers:

        if number not in unique:

            unique.append(number)

    return unique

Разница в условной конструкции. В этот раз она следующая — если числа нет в unique, то его нужно добавить.

if number not in unique:

    unique.append(number)

В противном случае цикл перейдет к следующему числу в списке numbers.

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

Есть еще несколько способов поиска уникальных значений в списке Python. Но достаточно будет тех, которые описаны в этой статье.

Архив с проектом contact.rar

Первоначальная настройка

Если вы уже знаете как создавать джанго-приложение, этот шаг можно пропустить. Создайте проект — config, приложение — sendemail и виртуальное окружение contact.

Первый шаг — создание отдельной папки для проекта. Создайте ее в ручную или с помощью терминала. В командной строке (Mаc или Linux, для Windows некоторые команды отличаются) выполните следующие команды, чтобы перейти в нужную директорию и создать новую папку «contact».

$ cd ~/ПУТЬ_К_ПАПКЕ
$ mkdir contact && cd contact

Теперь можно установить Django и активировать виртуальную среду.

Примечание:

Есть pipenv у вас не установлен, начните с pip install pipenv

$ pipenv install django==3.0.5
$ pipenv shell

Далее создадим новый проект Django под названием config в приложении sendemail:

(contact) $ django-admin startproject config .
(contact) $ python manage.py startapp sendemail

Чтобы убедиться, что все работает, запустим migrate и runserver.

(contact) $ python manage.py migrate
(contact) $ python manage.py runserver

Если теперь открыть ссылку 127.0.0.1:8000, то должно появиться приблизительно следующее:

Обновление settings.py

Созданное приложение теперь нужно явно добавить в проект Django. В файле settings.py следует записать sendemail в разделе INSTALLED_APPS.

# config/settings.py

INSTALLED_APPS [

    'sendemail.apps.SendemailConfig',  # новая строка

    ...

]

Затем в этом же файле нужно создать DEFAULT_FROM_EMAIL — ваша@почта.com и RECIPIENTS_EMAIL — список почт получателей по уполчанию. Также стоит обновить EMAIL_BACKEND, указав, какой бэкенд email используется — в данном случае это console. Это нужно, чтобы почта выводилась в командной строке.

# config/settings.py

RECIPIENTS_EMAIL = ['manager@mysite.com']   # замените на свою почту

DEFAULT_FROM_EMAIL = 'admin@mysite.com'  # замените на свою почту

EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'

Обновление urls.py

После добавления приложения в проект Django нужно обновить корневой файл config/urls.py, добавив include в верхней строке, а также новый urlpattern в приложении:

# config/urls.py

from django.contrib import admin

from django.urls import path, include



urlpatterns = [

    path('admin/', admin.site.urls),

    path('', include('sendemail.urls')),

]

Дальше создайте файл sendemail/urls.py в приложении вручную или:

touch sendemail/urls.py

Теперь — этот код. Благодаря ему основная контактная форма будет доступна по ссылке email/, а удачная отправка — перенаправлять на success/.

# sendemail/urls.py

from django.contrib import admin

from django.urls import path



from .views import contact_view, success_view



urlpatterns = [

    path('contact/', contact_view, name='contact'),

    path('success/', success_view, name='success'),

]

Создание forms.py

Внутри приложения sendemail теперь нужно создать новый файл forms.py.

touch sendemail/forms.py

Он будет содержать все поля для самой формы. Потребуются три: from_email, subject и message.

# sendemail/forms.py

from django import forms



class ContactForm(forms.Form):

    from_email = forms.EmailField(label='Email', required=True)

    subject = forms.CharField(label='Тема', required=True)

    message = forms.CharField(label='Сообщение', widget=forms.Textarea, required=True)

Будем использовать встроенный в Django Forms API для быстрого создания трех полей.

Создание views.py

Создадим представление, которое будет выполнять основную работу для контактной формы. Обновим существующий файл sendemail/views.py:

from django.shortcuts import render



from django.core.mail import send_mail, BadHeaderError

from django.http import HttpResponse, HttpResponseRedirect

from django.shortcuts import render, redirect

from .forms import ContactForm

from config.settings import RECIPIENTS_EMAIL, DEFAULT_FROM_EMAIL

def contact_view(request):

    # если метод GET, вернем форму

    if request.method == 'GET':

        form = ContactForm()

    elif request.method == 'POST':

        # если метод POST, проверим форму и отправим письмо

        form = ContactForm(request.POST)

        if form.is_valid():

            subject = form.cleaned_data['subject']

            from_email = form.cleaned_data['from_email']

            message = form.cleaned_data['message']

            try:

                send_mail(f'{subject} от {from_email}', message,

                          DEFAULT_FROM_EMAIL, RECIPIENTS_EMAIL)

            except BadHeaderError:

                return HttpResponse('Ошибка в теме письма.')

            return redirect('success')

    else:

        return HttpResponse('Неверный запрос.')

    return render(request, "email.html", {'form': form})

def success_view(request):

    return HttpResponse('Приняли! Спасибо за вашу заявку.')

Сначала импортируем send_email и BadHeaderError для безопасности. После этого добавим ссылку на класс ContactForm, который был создан в файле forms.py.

Создание шаблонов

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

(contact) $ mkdir templates
(contact) $ touch templates/email.html

Теперь обновим файл settings.py, чтобы Django знал, где искать папку с шаблонами. Обновим настройку DIRS в TEMPLATES.

# config/settings.py

TEMPLATES = [

    {

        ...

        'DIRS': [os.path.join(BASE_DIR, 'templates')],

        ...

    },

]

Далее обновим сами файлы шаблонов, используя следующий код:

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Пример отправки сообщений</title>
  <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/3.3.7/css/bootstrap.min.css">
</head>
<body>
  <h1 class="text-center">Оставьте заявку</h1>
  <div class="container text-center">
    <div id="form_container">
      <form method="post">
        {% csrf_token %}
        {{ form.as_p }}
        <div class="form-actions form-group ">
          <button type="submit" class="form-control btn btn-success">Отправить</button>
        </div>
      </form>
    </div>
  </div>
</body>
</html>

Отправка первого сообщения

Убедитесь, что сервер запущен с помощью команды python manage.py runserver и откройте http://127.0.0.1:8000/contact в браузере. Заполните форму и нажмите кнопку Отправить.

Программа перенаправит на страницу http://127.0.0.1:8000/success, если сообщение отправилось.

А в консоли должно отобразиться, что сообщение отправилось:

Content-Type: text/plain; charset="utf-8"
MIME-Version: 1.0
Content-Transfer-Encoding: 8bit
Subject: =?utf-8?b?0J/RgNC40LLQtdGC?=
From: admin@mysite.com
To: manager@mysite.com
Date: Sat, 03 Oct 2020 11:10:29 -0000
Message-ID: <160172342967.9128.15896163902795968694@DESKTOP-4G7VN>

Email-сервис

Для реальной отправки сообщений нужно настроить сервис: SendGrid, mailgun или SES. К счастью, в Django их очень легко использовать.

Для использования SendGrid нужно создать бесплатный аккаунт и выбрать вариант SMTP. Его легче настраивать при работе с Web API.

Необходимо выполнить верификацию отправителя. Инструкции доступны по этой ссылке. Если раньше можно было отправлять сообщения с бесплатных адресов (gmail.com или yahoo.com), но теперь это не будет работать из-за протокола email-аутентификации DMARC. Поэтому для реальной отправки сообщений нужно почту на своем домене, владение которой придется подтвердить.

После добавления отправителя на странице https://app.sendgrid.com/settings/sender_auth/senders/new, подтвердите почту и переходите к настройке Web API https://app.sendgrid.com/guide/integrate/langs/python.

Следующее окно требует указать название для API-ключа. После этого нужно нажать на Create Key.

Следуйте инструкциям. На момент написания нужно установить библиотеку sendgrid и отправить тестовое письмо. Можете воспользоваться этим файлом sg_verify.py. Пройдя все этапы вы увидите сообщение об успешном подключении:

Дальше обновим файл settings.py, поменяв значение console на smtp в переменной EMAIL_BACKEND. Также добавим еще несколько полей. А также EMAIL_HOST_PASSWORD с ключем аккаунта SendGrid.

# config/settings.py

# почты для получения писем

RECIPIENTS_EMAIL = ['manager@mysite.com']

# почта отправителя по умолчанию, та что верифицирована

DEFAULT_FROM_EMAIL = 'admin@myiyte.com'

EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'

EMAIL_HOST = 'smtp.sendgrid.net'

EMAIL_HOST_USER = 'apikey'

# ваш уникальный апи-ключ с сайта sendgrid

EMAIL_HOST_PASSWORD = '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'

EMAIL_PORT = 587

EMAIL_USE_TLS = True

Вернемся на http://127.0.0.1:8000/contact/, заполним и отправим форму еще раз. Работает!

Выводы

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

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

import time



def waiter():

    cook('Паста', 8)

    cook('Салат Цезарь', 3)

    cook('Отбивные', 16)



def cook(order, time_to_prepare):

    print(f'Новый заказ: {order}')

    time.sleep(time_to_prepare)

    print(order, '- готово')



if __name__ == '__main__':

    waiter()

Сохраним файл sync.py.

Здесь повар симулируется в виде функции. Он принимает заказ и время на его приготовление. Затем с помощью функции time.sleep симулируется сам процесс готовки. А по завершении выводится сообщение о том, что заказ готов.

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

Убедитесь, что установлена версия Python 3.7+ с помощью команды python3 --version на Mac или python --version — на Windows. Если версия меньше 3.7, обновите.

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

Новый заказ: Паста
Паста - готово
Новый заказ: Салат Цезарь
Салат Цезарь - готово
Новый заказ: Отбивные
Отбивные - готово

Первая асинхронная программа

Теперь конвертируем программу так, чтобы она использовала библиотеку asyncio. Это будет первый шаг для того, чтобы разобраться с тем, как писать асинхронный код. Скопируем файл sync.py в новый файл coros.py со следующим кодом:

import asyncio

import time



async def waiter() -> None:

    cook('Паста', 8)

    cook('Салат Цезарь', 3)

    cook('Отбивные', 16)



async def cook(order: str, time_to_prepare: int) -> None:

    print(f'Новый заказ: {order}')

    time.sleep(time_to_prepare)

    print(order, '- готово')



asyncio.run(waiter())

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

В конце программы заменим if __name__ == '__main__' на новый метод run из модуля asyncio. Что именно делает run?

По сути, run берет низкоуровневый псевдо-сервер asyncio, который называется рабочим циклом. Этот цикл является координатором, который следит за приостановкой и возобновлением задач из кода. В примере с поваром и официантом вызов «cook(»Паста’)» — это задача, которая выполнится, но также будет приостановлена на 8 секунд. Таким образом после получения запроса он отмечается, а программа переходит к выполнению следующего. После завершения заказа на приготовление пасты цикл продолжит выполнение на следующей строке, где готовится салат «Цезарь».

Команде run нужна функция, которую она будет выполнять, поэтому передаем waiter, которая является основной функцией в этом коде.

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

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

async def waiter() -> None:

    await cook('Паста', 8)

    await cook('Салат Цезарь', 3)

    await cook('Отбивные', 16)

Функция waiter объявляется асинхронной за счет добавления приставки async в начале. После этого появляется возможность сообщать asyncio, какие из задач будут асинхронными внутри. Для этого к ним добавляется ключевое слово await.

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

Достаточно лишь запомнить, что если есть задачи с await, то сама функция должна быть объявлена с async.

А как же функция cook? Ее тоже нужно сделать асинхронной, поэтому перепишем ее вот так.

async def cook(order, time_to_prepare):

    print(f'Новый заказ: {order}')

    await time.sleep(time_to_prepare)

    print(order, '- готово')

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

async def cook(order, time_to_prepare):

    print(f'Новый заказ: {order}')

    await asyncio.sleep(time_to_prepare)

    print(order, '- готово')

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

Если сейчас запустить программу, то результат будет таким:

Новый заказ: Паста
Паста - готово
Новый заказ: Салат Цезарь
Салат Цезарь - готово
Новый заказ: Отбивные
Отбивные - готово

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

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

Сопрограммы и задачи (coroutines and tasks)

Сопрограммы (coroutines)

Функции waiter и cook трансформируются именно в тот момент, когда перед их определением ставится ключевое слово async. С этого момент их можно считать сопрограммами.

Если попытаться запустить одну из таких прямо, то вернется сообщение с информацией о ней, но сама программа не будет запущена. Попробуем запустить терминал Python и импортировать туда функцию cook из файла coros. Во-первых, нужно закомментировать команду asyncio.run так, чтобы код не выполнялся. После этого файл можно сохранить.

# asyncio.run(waiter())

Затем откроем терминал и сделаем следующее:

>>> from coros import cook

>>> cook('Паста', 8)

Сопрограммы могут выполняться только в пределах рабочего цикла или их ожидания (awaiting) внутри других сопрограмм.

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

Задачи (tasks)

С помощью задач можно запустить несколько сопрограмм одновременно. Скопируем файл coros.py в файл tasks.py и допишем следующее:

import asyncio



async def waiter():

    task1 = asyncio.create_task(cook('Паста', 8))

    task2 = asyncio.create_task(cook('Салат Цезарь', 3))

    task3 = asyncio.create_task(cook('Отбивные', 16))



    await task1

    await task2

    await task3



async def cook(order, time_to_prepare):

    print(f'Новый заказ: {order}')

    await asyncio.sleep(time_to_prepare)

    print(order, '- готово')



asyncio.run(waiter())

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

1. Они используются для планирования последовательного выполнения сопрограмм;
2. Задачи могут быть отменены при ожидании завершения их выполнения.

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

Новый заказ: Паста
Новый заказ: Салат Цезарь
Новый заказ: Отбивные
Салат Цезарь - готово
Паста - готово
Отбивные - готово

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

Частые ошибки с asyncio

При переходе к асинхронному коду нужно помнить о некоторых вещах:

Вызов блокирующей функции из сопрограммы

Одна из самых распространенных проблем — использование синхронной функции внутри асинхронной.

Один из примеров такого — использование синхронной функции time.sleep внутри асинхронной функции cook. Использование обычного метода sleep из стандартной библиотеки заблокировало бы весь код.

Попробуйте. Добавьте import time в верхней части файла coros.py и синхронную функцию sleep:

async def cook(order, time_to_prepare):

    print(f'Новый заказ: {order}')

    await time.sleep(time_to_prepare)

    print(order, '- готово')

При попытке выполнить такой код вернется следующая ошибка:

...
  File "coros.py", line 7, in waiter
    await cook('Pasta', 8)
  File "coros.py", line 13, in cook
    await time.sleep(time_to_prepare)
TypeError: object NoneType can't be used in 'await' expression

На первый взгляд эта ошибка кажется странной. Дело в том, что time.sleep() — это не объект, выполнения которого можно дождаться (await). Таким образом он возвращает вызвавшей его функции None. И даже исключение появляется не сразу, а только через 8 секунд.

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

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

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

Не дожидаться завершения выполнения сопрограммы

Во-первых, уберем time.sleep и вернем на место asyncio.sleep. После этого поменяем второй вызов функции cook, забрав у нее ключевое слово await:

import asyncio

import time



async def waiter() -> None:

    await cook('Паста', 8)

    cook('Салат Цезарь', 3)

    await cook('Отбивные', 16)



async def cook(order, time_to_prepare):

    print(f'Новый заказ: {order}')

    await asyncio.sleep(time_to_prepare)

    print(order, '- готово')



 asyncio.run(waiter())

При попытке запустить этот код вернется следующая ошибка:

coros.py:5: RuntimeWarning: coroutine 'cook' was never awaited

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

Неполученные результаты

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

Например, возьмем следующий код:

import asyncio



async def executed():

    asyncio.sleep(15)

    print("Функция executed")



async def main():

    asyncio.create_task(executed())



asyncio.run(main())

После его запуска вернется следующая ошибка:

RuntimeWarning: coroutine 'sleep' was never awaited
  asyncio.sleep(15)
RuntimeWarning: Enable tracemalloc to get the object allocation traceback
Функция executed

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

Теперь вы знаете, на что обращать внимание при получении ошибки not consumed.

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

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

О проекте

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

Требования

Для работы над проектом требуются базовые знания программирования на Python и библиотеки pygame.

Для установки библиотеки используйте в терминале следующую команду.

pip install pygame

Шаги для создания проекта

По этой ссылке можно загрузить весь исходный код проекта: typing-speed-game.rar

Для начала разберемся с файловой структурой проекта:

• background.jpg — фоновое изображение для программы
• icon.jpg — иконка для кнопки сброса
• sentences.txt — текстовый файл со списком предложений
• speed_typing.py — файл со всем кодом программы
• typing-speed-open.png — иконка для отображения при запуске игры

Создадим файл sentences.txt, в котором на каждой строке добавим по предложению.

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

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

Для этого проекта будем использовать библиотеку pygame. Ее нужно импортировать вместе с другими встроенными модулями Python, такими как time и random.

import pygame
from pygame.locals import *
import sys
import time
import random

Создадим класс игры

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

Создадим конструктор класса, в котором будет определены все переменные проекта.

class Game:
    def __init__(self):
        self.w=750
        self.h=500
        self.reset=True
        self.active = False
        self.input_text=''
        self.word = ''
        self.time_start = 0
        self.total_time = 0
        self.accuracy = '0%'
        self.results = 'Time:0 Accuracy:0 % Wpm:0 '
        self.wpm = 0
        self.end = False
        self.HEAD_C = (255,213,102)
        self.TEXT_C = (240,240,240)
        self.RESULT_C = (255,70,70)
        
        pygame.init()
        self.open_img = pygame.image.load('type-speed-open.png')
        self.open_img = pygame.transform.scale(self.open_img, (self.w,self.h))
        
        self.bg = pygame.image.load('background.jpg')
        self.bg = pygame.transform.scale(self.bg, (500,750))
        
        self.screen = pygame.display.set_mode((self.w,self.h))
        pygame.display.set_caption('Type Speed test')

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

Метод draw_text()

Метод draw_text() — это вспомогательная функция для класса Game, которая выводит текст на экран. В качестве аргумента она принимает экран, выводимое сообщение, координату y экрана, где нужно нарисовать текст, а также размер и цвет шрифта. В этом случае все должно выводиться по центру. После прорисовки pygame нужно обновить экран.

def draw_text(self, screen, msg, y ,fsize, color):
    font = pygame.font.Font(None, fsize)
    text = font.render(msg, 1,color)
    text_rect = text.get_rect(center=(self.w/2, y))
    screen.blit(text, text_rect)
    pygame.display.update()

Метод get_sentence()

В файле sentences.txt хранится список предложений. Метод get_sentence() будет открывать его и возвращать случайное предложение из списка. Целая строка будет разбиваться с помощью символа новой строки.

def get_sentence(self):
    f = open('sentences.txt').read()
    sentences = f.split('\n')
    sentence = random.choice(sentences)
    return sentence

Метод show_results()

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

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

Формула следующая:
(правильные символы) х 100 / (всего символов в предложении)

WPM (words per minute) — это количество слов в минуту. Типичное слово состоит приблизительно из 5 символов, поэтому рассчитываем показатель, разделяя общее количество слов на 5. Затем результат делится на общее время, которое потребовалось для набора. Поскольку общее время указано в секундах, его сначала нужно конвертировать в минуты, разделив значение на 60.

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

    def show_results(self, screen):
        if(not self.end):
            # Расчет времени
            self.total_time = time.time() - self.time_start
               
            # Расчет точности
            count = 0
            for i,c in enumerate(self.word):
                try:
                    if self.input_text[i] == c:
                        count += 1
                except:
                    pass
            self.accuracy = count/len(self.word)*100
           
            # Расчет количества слов в минуту
            self.wpm = len(self.input_text)*60/(5*self.total_time)
            self.end = True
            print(self.total_time)
                
            self.results = 'Time:'+str(round(self.total_time)) +" secs   Accuracy:"+ str(round(self.accuracy)) + "%" + '   Wpm: ' + str(round(self.wpm))

            # Загрузка иконки
            self.time_img = pygame.image.load('icon.png')
            self.time_img = pygame.transform.scale(self.time_img, (150,150))
            # screen.blit(self.time_img, (80,320))
            screen.blit(self.time_img, (self.w/2-75,self.h-140))
            self.draw_text(screen,"Reset", self.h - 70, 26, (100,100,100))
            
            print(self.results)
            pygame.display.update()

Метод run()

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

Другой цикл ждет событий мыши и клавиатуры. Когда кнопка мыши нажимается, проверяется ее положение. Если она над полем ввода, то таймер запускается, а переменная active становится True. Если над кнопкой сброса — игра сбрасывается.

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

    def run(self):
        self.reset_game()
    
       
        self.running=True
        while(self.running):
            clock = pygame.time.Clock()
            self.screen.fill((0,0,0), (50,250,650,50))
            pygame.draw.rect(self.screen,self.HEAD_C, (50,250,650,50), 2)
            # Обновление текста пользовательского ввода
            self.draw_text(self.screen, self.input_text, 274, 26,(250,250,250))
            pygame.display.update()
            for event in pygame.event.get():
                if event.type == QUIT:
                    self.running = False
                    sys.exit()
                elif event.type == pygame.MOUSEBUTTONUP:
                    x,y = pygame.mouse.get_pos()
                    # Расположение окна ввода
                    if(x>=50 and x<=650 and y>=250 and y<=300):
                        self.active = True
                        self.input_text = ''
                        self.time_start = time.time() 
                     # Расположение кнопки сброса
                    if(x>=310 and x<=510 and y>=390 and self.end):
                        self.reset_game()
                        x,y = pygame.mouse.get_pos()
         
                        
                elif event.type == pygame.KEYDOWN:
                    if self.active and not self.end:
                        if event.key == pygame.K_RETURN:
                            print(self.input_text)
                            self.show_results(self.screen)
                            print(self.results)
                            self.draw_text(self.screen, self.results,350, 28, self.RESULT_C)  
                            self.end = True
                            
                        elif event.key == pygame.K_BACKSPACE:
                            self.input_text = self.input_text[:-1]
                        else:
                            try:
                                self.input_text += event.unicode
                            except:
                                pass
            
            pygame.display.update()
             
                
        clock.tick(60)

Метод reset_game()

Метод reset_game() сбрасывает все переменные, так что проверить скорость набора можно снова. Еще раз выбирается случайное предложение с помощью метода get_sentence(). В конце определение класса закрывается. Создаем объект класса Game и запускаем программу.

    def reset_game(self):
        self.screen.blit(self.open_img, (0,0))

        pygame.display.update()
        time.sleep(1)
        
        self.reset=False
        self.end = False

        self.input_text=''
        self.word = ''
        self.time_start = 0
        self.total_time = 0
        self.wpm = 0

        # Получаем случайное предложение 
        self.word = self.get_sentence()
        if (not self.word): self.reset_game()
        # Загрузка окна
        self.screen.fill((0,0,0))
        self.screen.blit(self.bg,(0,0))
        msg = "Typing Speed Test"
        self.draw_text(self.screen, msg,80, 80,self.HEAD_C)  
        # Отрисовка поля ввода
        pygame.draw.rect(self.screen,(255,192,25), (50,250,650,50), 2)

        # Отрисовка строки предложения
        self.draw_text(self.screen, self.word,200, 28,self.TEXT_C)
        
        pygame.display.update()



Game().run()

Вывод:

Выводы

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

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

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

Что такое распознавание рукописных цифр?

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

О Python-проекте

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

Требования

Для этого проекта нужны базовые знания программирования на Python, библиотеки Keras для глубокого обучения и библиотеки Tkinter для создания графического интерфейса.

Установим требуемые библиотеки для проекта с помощью pip install.

Библиотеки: numpy, tensorflow, keras, pillow.

Набор данных MNIST

Это, наверное, один из самых популярных наборов данных среди энтузиастов, работающих в сфера машинного обучения и глубокого обучения. Он содержит 60 000 тренировочных изображений написанных от руки цифр от 0 до 9, а также 10 000 картинок для тестирования. В наборе есть 10 разных классов. Изображения с цифрами представлены в виде матриц 28 х 28, где каждая ячейка содержит определенный оттенок серого.

Создание проекта на Python для распознавания рукописных цифр

Скачайте файлы проекта

1. Импорт библиотек и загрузка набор данных

Сначала нужно импортировать все модули, которые потребуются для тренировки модели. Библиотека Keras уже включает некоторые из них. В их числе и MNIST. Таким образом можно запросто импортировать набор и начать работать с ним. Метод mnist.load_data() возвращает тренировочные данные, их метки и тестовые данные с метками.

import keras
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D
from keras import backend as K

# скачиваем данные и разделяем на надор для обучения и тесовый
(x_train, y_train), (x_test, y_test) = mnist.load_data()

print(x_train.shape, y_train.shape)

2. Предварительная обработка данных

Данные с изображения нельзя прямо передать в модель, поэтому сперва нужно выполнить определенные операции, обработав данные, чтобы нейронная сеть с ними работала. Размерность тренировочных данных — (60000, 28, 28). Модель сверточной нейронной сети требует одну размерность, поэтому потребуется перестроить форму (60000, 28, 28, 1).

num_classes = 10
x_train = x_train.reshape(x_train.shape[0], 28, 28, 1)
x_test = x_test.reshape(x_test.shape[0], 28, 28, 1)
input_shape = (28, 28, 1)

# преобразование векторных классов в бинарные матрицы
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)

x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
print('Размерность x_train:', x_train.shape)
print(x_train.shape[0], 'Размер train')
print(x_test.shape[0], 'Размер test')

3. Создание модели

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

batch_size = 128
epochs = 10

model = Sequential()
model.add(Conv2D(32, kernel_size=(3, 3),activation='relu',input_shape=input_shape))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(256, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(num_classes, activation='softmax'))
model.compile(loss=keras.losses.categorical_crossentropy,optimizer=keras.optimizers.Adadelta(),metrics=['accuracy'])

4. Тренировка модели

Функция model.fit() в Keras начнет тренировку модели. Она принимает тренировочные, валидационные данные, эпохи (epoch) и размер батча (batch).

Тренировка модели занимает некоторое время. После этого веса и определение модели сохраняются в файле mnist.h5.

hist = model.fit(x_train, y_train, batch_size = batch_size, epochs=epochs, verbose=1, validation_data=(x_test, y_test))
print("Модель успешно обучена")

model.save('mnist.h5')
print("Модель сохранена как mnist.h5")

5. Оценка модели

В наборе данных есть 10 000 изображений, которые используются для оценки качества работы модели. Тестовые данные не используются во время тренировки, поэтому являются новыми для модели. Набор MNIST хорошо сбалансирован, поэтому можно рассчитывать на точность около 99%.

score = model.evaluate(x_test, y_test, verbose=0)
print('Потери на тесте:', score[0])
print('Точность на тесте:', score[1])

6. Создание графического интерфейса для предсказания цифр

Для графического интерфейса создадим новый файл, в котором будет интерактивное окно для рисования цифр на полотне и кнопка, отвечающая за процесс распознавания. Библиотека Tkinter является частью стандартной библиотеки Python. Функция predict_digit() принимает входящее изображение и затем использует натренированную сеть для предсказания.

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

Дальше весь код из файла gui_digit_recognizer.py:

from keras.models import load_model
from tkinter import *
import tkinter as tk
import win32gui
from PIL import ImageGrab, Image
import numpy as np

model = load_model('mnist.h5')

def predict_digit(img):
    # изменение рзмера изобржений на 28x28
    img = img.resize((28,28))
    # конвертируем rgb в grayscale
    img = img.convert('L')
    img = np.array(img)
    # изменение размерности для поддержки модели ввода и нормализации
    img = img.reshape(1,28,28,1)
    img = img/255.0
    # предстказание цифры
    res = model.predict([img])[0]
    return np.argmax(res), max(res)
    
class App(tk.Tk):
    def __init__(self):
        tk.Tk.__init__(self)
        
        self.x = self.y = 0
        
        # Создание элементов
        self.canvas = tk.Canvas(self, width=300, height=300, bg = "white", cursor="cross")
        self.label = tk.Label(self, text="Думаю..", font=("Helvetica", 48))
        self.classify_btn = tk.Button(self, text = "Распознать", command =         self.classify_handwriting) 
        self.button_clear = tk.Button(self, text = "Очистить", command = self.clear_all)
        
        # Сетка окна
        self.canvas.grid(row=0, column=0, pady=2, sticky=W, )
        self.label.grid(row=0, column=1,pady=2, padx=2)
        self.classify_btn.grid(row=1, column=1, pady=2, padx=2)
        self.button_clear.grid(row=1, column=0, pady=2)
        
        # self.canvas.bind("<Motion>", self.start_pos)
        self.canvas.bind("<B1-Motion>", self.draw_lines)
        
    def clear_all(self):
        self.canvas.delete("all")
        
    def classify_handwriting(self):
        HWND = self.canvas.winfo_id() 
        rect = win32gui.GetWindowRect(HWND) # получаем координату холста
        im = ImageGrab.grab(rect)
        
        digit, acc = predict_digit(im)
        self.label.configure(text= str(digit)+', '+ str(int(acc*100))+'%')
        
    def draw_lines(self, event):
        self.x = event.x
        self.y = event.y
        r=8
        self.canvas.create_oval(self.x-r, self.y-r, self.x + r, self.y + r, fill='black')


app = App()
mainloop()

Получится:

Выводы

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

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

• Казино получает конкурентное преимущество, заставляя игроков совершать действия до дилера (действовать в условиях неполной информации). Это создает риск получить перебор (таким образом игроки теряют все еще до того, как дилер совершает хоть какое-нибудь действие).
• Особую опасность представляют ситуации, когда карты на руках игроков стоят от 12 до 16 очков (в таком случае вероятность получить перебор со следующей картой максимальная), а дилер показывает старшую карту. В таких случаях можно предположить, что у дилера будет более высокое значение, так что игрокам остается только брать еще или проигрывать. Это можно увидеть даже визуально на графике с шансами на победу или ничью (промежуток значений от 12 до 16 называется “долиной отчаяния”).
  
• Наконец, простейшая «наивная» стратегия брать карты в случае нулевой вероятности получить перебор значительно увеличивает шансы на победу, ведь в таком случае растет вероятность того, что проиграет казино.

Также в том материале были описаны и правила игры.

Способно ли глубокое обучение справиться лучше?

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

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

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

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

Генерация тренировочных данных

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

Что нужно предсказать? Есть два кандидата на роль целевой переменной:

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

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

1. раздать карты игроку и дилеру;
2. проверить, нет ли у одного из них 21;
3. выполнить одно действие (взять карту или спасовать);
4. симулировать игру до конца и записать результат.

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

• Если игрок взял карту и выиграл, тогда карта (Y=1) была правильным решением
• Если игрок взял карту и проиграл, тогда пас (Y=0) был правильным решением
• Если игрок спасовал и выиграл, тогда пас (Y=1) был правильным решением
• Если игрок спасовал и проиграл, тогда карта (Y=0) была правильным решением

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

1. Открытая карта лидера (вторая закрыта от игроков)
2. Общая стоимость карт в руках игрока
3. Проверка, есть ли у игрока туз
4. Действие игрока (карта или пас)

Цель — выявить правильно решение на основе описанный выше логики.

Тренировка нейронной сети

ВАЖНО! Весь код статьи в этом архиве

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

from keras.models import Sequential
from keras.layers import Dense, LSTM, Flatten, Dropout

Теперь настроим переменные ввода для тренировки сети. feature_list — это переменная с колонками, представляющими перечисленные выше признаки. В dataframe model_rf хранятся данные запущенных симуляций.

# Задаем переменные для нейронной сети
feature_list = [i for i in model_df.columns if i not in  
['dealer_card','Y','lose','correct_action']  
]  
train_X = np.array(model_df[feature_list])  
train_Y = np.array(model_df['correct_action']).reshape(-1,1)

Код, запускающий и тренирующий нейронную сеть, довольно простой. Первая строка создает нейронную сеть последовательного типа, которая является линейной последовательностью слоев нейронной сети. Следующие строки друг за другом добавляют слои (Dense — простейший тип слоя, представляющий собой набор нейронов), а числа 16, 128 и т. д. обозначают количество нейронов в каждом слое.

Наконец, для последнего слоя нужно выбрать функцию активации. Она конвертирует сырой вывод в более осмысленный вид. Обратите внимание на две вещи: во-первых, финальный слой включает лишь один нейрон, потому что предсказание делается на основе двух возможных выводов (двухклассовая проблема). Во-вторых, используется сигмоидная функция, потому что необходимо, чтобы нейронная сеть действовала по принципу логистической регрессии и предсказывала, что является корректным действием: карта (Y=1) или пас (Y=0). Другими словами, необходимо знать вероятность того, что карта — это правильный вариант.

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

# Настройка нейронной сети с 5 слоями
model = Sequential()
model.add(Dense(16))
model.add(Dense(128))
model.add(Dense(32))
model.add(Dense(8))
model.add(Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='sgd')
model.fit(train_X, train_Y, epochs=20, batch_size=256, verbose=1)

pred_Y_train = model.predict(train_X)
actuals = train_Y[:,-1]

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

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

График показывает ROC-кривую для нейронной сети, играющей в блэкджек. Судя по всему, она все-таки дает обеспечивает полезность относительно случайного угадывания (красная пунктирная линия). Площадь под кривой, AUC, — 0,73, в то время как показатель AUC для случайного предсказывания равен 0,5.

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

Время играть!

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

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

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

def model_decision(model, player_sum, has_ace, dealer_card_num):
    input_array = np.array([player_sum, 0, has_ace, dealer_card_num]).reshape(1,-1)
    predict_correct = model.predict(input_array)
    if predict_correct >= 0.52:
        return 1
    else:
        return 0

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

А модель хороша!

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

• Всего было запущено 300 000 симуляций для каждой стратегии
• При наивной стратегии карта берется только в том случае, если на руках меньше 12 очков
• При случайной стратегии подбрасывается монетка: если орел, тогда берем карту, если решка — пас. Если карта взята и нет перебора, тогда процесс продолжается снова и снова.

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

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

Также можно взглянуть на вероятность победы или ничьей в зависимости от стартовой руки игрока. Нам всем диапазоне нейронная сеть показывает себя намного эффективнее. И в отличие от наивной, которая работает даже хуже угадывания в долине отчаяния (когда на руках значения от 12 до 16), нейронная сеть выступает очень неплохо.

Следующий график показывает, насколько нейронная сеть эффективнее наивной стратегии. Последняя (из-за используемого алгоритма) даже не предпринимает попыток, когда есть хоть какая-то вероятность перебора. Нейронная сеть же регулярно берет еще карту, когда у нее 12, 13, 14 или 15. В данном случае речь идет о принятии решений с большим количество деталей и способностью учитывать некоторые риски.

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

Похоже, что сеть часто берет карту, когда дилер показывает старшую карту (8, 9 или 10). Но даже когда у него на руках что-то низкое, например 3, нейронная сеть берет карту в 60% случаев. Это связано с тем, что она учитывает все признаки. На основе этого можно было бы разработать несколько простых правил.

Выводы

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

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

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

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

Возможно, вам удастся добиться более впечатляющих результатов. Удачи!

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

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

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

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

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

1. Игроки делают ставки
2. Им выдают по 2 карты в закрытом виде
3. Дилер также получает 2 карты, но одна из них видна игрокам.
4. Цель игры — набрать больше очков, чем у дилера (но не больше 21, больше 21 — это автоматическое поражение, которое называется перебор). Если удалось набрать больше очков, чем у дилера, то выигрышем является ставка (победа также присуждается, если у дилера перебор). Тузы оцениваются в 1 или 11 очков, а все остальные карты — согласно их значениям (валет, дама и король — их называют “картинками” — в 10 очков).
5. Лучшая стартовая комбинация — туз и картинка. Она называется блэкджек.
6. После первого раунда у каждого игрока есть возможность взять больше карт или спасовать (не брать карт). Если игрок набрал больше 21 очка, то его ставка сгорает.
7. Когда все игроки решили, что не будут больше брать карты, дилер переворачивает свою скрытую карту. Если у него меньше 17 очков, то он обязан взять еще. Так продолжается до тех пор, пока он не наберет 17 или больше.
8. После этого подводятся итоги. Если у дилера перебор, тогда игроки без перебора получают свои ставки. Если нет — тогда набранные значения сравниваются. Каждый, кто набрал больше дилера, выигрывает сумму равную ставке. Тот, у кого меньше, теряет поставленное. В случае ничьей деньги остаются на местах.

А теперь пришло время программирования

Для удобства и избежания ошибок используйте этот black_jack.ipynb

Создание симулятора

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

Для начала добавим необходимые импорты:

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

Теперь создадим кое-какие функции. Во-первых, нужна та, что будет создавать новую колоду карт. За эту операцию будет отвечать make_decks. Она должна добавлять 4 масти каждой карты (туза, двойки, тройки, четверки и так далее) в список new_deck, перемешивать его и возвращать новый список, с которым предстоит играть. В функции можно указать и количество колод (num_decks), которые должна создавать функция.

# Создаем колоду
def make_decks(num_decks, card_types):
    new_deck = []
    for i in range(num_decks):
        for j in range(4):
            new_deck.extend(card_types)
    random.shuffle(new_deck)
    return new_deck

Также нужна функция, которая будет прибавлять значения карт в руке. Это сложнее базовой операции прибавления, потому что, например, туз может быть равен 1 или 11 в зависимости от того, что выгодно владельцу. Поэтому в первую очередь функция подсчитывает значение всех карт в руке за исключением туза (все картинки могут быть представлены в виде 10, поскольку в блэкджеке они работают идентично). Затем она подсчитывает количество тузов. Наконец, определяет, сколько должен «стоить» туз в зависимости от значений остальных карт в руке.

Вспомогательная функция ace_values принимает в качестве аргумента количество тузов в руке и выдает список уникальных значений стоимости тузов:

# Эта функция перечисляет все комбинации значений туза в  
# массив sum_array.  
# Например, если у вас 2 туза, есть 4 комбинации:  
# [[1,1], [1,11], [11,1], [11,11]]  
# Эти комбинации приводят к 3 уникальным суммам: [2, 12, 22]  
# Из этих 3 только 2 являются <= 21, поэтому они возвращаются: [2, 12]+
def get_ace_values(temp_list):  
    sum_array = np.zeros((2**len(temp_list), len(temp_list)))  
    # Этот цикл получает комбинации
    for i in range(len(temp_list)):  
        n = len(temp_list) - i  
        half_len = int(2**n * 0.5)  
        for rep in range(int(sum_array.shape[0]/half_len/2)):  
            sum_array[rep*2**n : rep*2**n+half_len, i]=1  
            sum_array[rep*2**n+half_len : rep*2**n+half_len*2, i]=11  
    # Только значения, которые подходят (<=21)  
    return list(set([int(s) for s in np.sum(sum_array, axis=1)\  
                     if s<=21]))  # Конвертация num_aces, int в list
                       
# Например, если num_aces = 2, вывод должен быть [[1,11],[1,11]]  
# Нужен этот формат для функции get_ace_values
def ace_values(num_aces):  
    temp_list = []  
    for i in range(num_aces):  
        temp_list.append([1,11])  
    return get_ace_values(temp_list)

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

# Сумма на руках
def total_up(hand):
    aces = 0
    total = 0
    
    for card in hand:
        if card != 'A':
            total += card
        else:
            aces += 1
    
    # Вызовите функцию ace_values, чтобы получить список возможных значений для тузов на руках.
    ace_value_list = ace_values(aces)
    final_totals = [i+total for i in ace_value_list if i+total<=21]
    
    if final_totals == []:
        return min(ace_value_list) + total
    else:
        return max(final_totals)

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

• stacks — количество стеков карт (где каждый стек может состоять из одной или большего количества колод), которые будут симулироваться
• players — количество игроков в одной партии
• num_decks — количество колод в каждом стеке
• card_types — список всех 13 типов карт

stacks = 50000
players = 1
num_decks = 1

card_types = ['A',2,3,4,5,6,7,8,9,10,10,10,10]

Дальше начинаются основные циклы симулятора. Всего их два:

1. Цикл for перебирает 50 000 симулируемых стеков карт
2. Цикл while, по одному для каждого стека, играет в блэкджек до тех пор, пока в стеке не осталось 20 или меньше карт. В этот момент он переходит к следующему стеку

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

В цикле while каждый игрок и дилер получают по карте (фрагмент с комментарием # Получение ПЕРВОЙ карты). После этого все получают еще по одной карте. Для этого используется функция pop с аргументом 0 — она возвращает первый элемент списка, удаляя его из списка (идеально подходит для работы с картами в стеке). Когда в стеке дилера меньше 20 карт, новый стек заменяет предыдущий (переходит к следующей итерации цикла for).

for stack in range(stacks):
    blackjack = set(['A',10])
    dealer_cards = make_decks(num_decks, card_types)
    while len(dealer_cards) > 20:
        
        curr_player_results = np.zeros((1,players))
        
        dealer_hand = []
        player_hands = [[] for player in range(players)]

        # Получение ПЕРВОЙ карты
        for player, hand in enumerate(player_hands):
            player_hands[player].append(dealer_cards.pop(0))
        dealer_hand.append(dealer_cards.pop(0))
        # Получение ВТОРОЙ карты
        for player, hand in enumerate(player_hands):
            player_hands[player].append(dealer_cards.pop(0))
        dealer_hand.append(dealer_cards.pop(0))

Дальше дилер проверяет, нет ли у него блэкджека (туз и 10). Обратите внимание, что блэкджек определен как множество, включающее туз (ace) и десятку.

Если у дилера блэкджек, тогда игроки проиграли (они получают соответствующее значение -1 в curr_player_results). Это касается только тех, у кого также не выпало 21 очков (в этом случае объявляется ничья).

# Дилер проверяется на 21
        if set(dealer_hand) == blackjack:
            for player in range(players):
                if set(player_hands[player]) != blackjack:
                    curr_player_results[0,player] = -1
                else:
                    curr_player_results[0,player] = 0

Если дилер не получил блэкджек, тогда игра продолжается. Теперь игроки проверяют, нет ли у них победной комбинации. Если есть — они автоматически одерживают победу (в некоторых казино это подразумевает выплату 1,5 к 1, то есть вы можно получить $150 в ответ на ставку $100). Выигрыш записывается с помощью значения 1 в массиве curr_player_results соответствующего игрока.

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

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

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

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

else:
            for player in range(players):
                # Игроки проверяются на 21
                if set(player_hands[player]) == blackjack:
                    curr_player_results[0,player] = 1
                else:
                    # Игроки случайным образом, проверяются на перебор
                    while (random.random() >= 0.5) and (total_up(player_hands[player]) != 21):
                        player_hands[player].append(dealer_cards.pop(0))
                        if total_up(player_hands[player]) > 21:
                            curr_player_results[0,player] = -1
                            break

В финальном разделе цикла очередь дилера. Он должен брать карты до тех пор, пока не получит перебор или не наберет как минимум 17. Так что пока дилер получает карты общей суммой до 17 нужно лишь проверять, не перебор ли у него. Если он взял больше 21, тогда каждый игрок без перебора побеждает и получает 1 в curr_player_results.

# Дилер добирает карты, если нужно
        while total_up(dealer_hand) < 17:
            dealer_hand.append(dealer_cards.pop(0))
        # Сравнение очков дилера с очками игрока, но сначала проверка, не перебрал ли дилер
        if total_up(dealer_hand) > 21:
            for player in range(players):
                if curr_player_results[0,player] != -1:
                    curr_player_results[0,player] = 1

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

else:
            for player in range(players):
                if total_up(player_hands[player]) > total_up(dealer_hand):
                    if total_up(player_hands[player]) <= 21:
                        curr_player_results[0,player] = 1
                elif total_up(player_hands[player]) == total_up(dealer_hand):
                    curr_player_results[0,player] = 0
                else:
                    curr_player_results[0,player] = -1

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

# Отслеживание результатов симуляции
        dealer_card_feature.append(dealer_hand[0])
        player_card_feature.append(player_hands)
        player_results.append(list(curr_player_results[0]))

Результаты симуляции

Теперь можно изучить результаты. Симуляция была проведена для 50 000 стеков. Вот что получилось в итоге:

• Сыграно 312 459 партий в блэкджек
• Игрок проиграл в 199 403 играх (64% всех случаев)
• Игрок победил в 99 324 играх (32% всех случаев)
• Ничья в 13 732 играх (4% всех случаев)

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

Вероятность выигрыша или ничьей к показанной карты дилера

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

• Если дилер показывает карту с маленьким значением, тогда при прочих равных вполне вероятно, что у него невысокая общая сумма. В таком случае игроку проще одержать победу. Это частично объясняет, почему вероятности от 2 до 6 в среднем выше, чем от 7 до туза.
• Также нужно напомнить правило дилера — если общее значение у него в руке меньше 17, он должен брать еще карту. В этом случае увеличивается вероятность того, что у него будет перебор. Это объясняет, почему вероятность растет от 2 до 6. Подумайте, какое значение самое распространенное в колоде? Конечно, 10, ведь так оценены аж 16 из 52 карт (валеты, дамы и короли). Так что если дилер показывает 6 (при условии что мы не считаем карты) наиболее вероятное предсказание — что у него на руках 16 очков. 16 меньше 17, поэтому он вынужден брать еще. А в колоде достаточно много карт, которые приведут к тому, что у дилера будет перебор: от 6 и выше. То же касается и 5, только здесь на одну карту меньше, которая приведет к перебору (7 или выше).
• Теперь подумайте о том, что происходит, когда дилер показывает 7. В этом случае велики шансы, что у него 10. Тогда игроки с 16 очками или меньше будут вынуждены брать еще. В таком случае высока вероятность перебора. В противном — недобрать достаточно очков.

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