Делитель, также известный как фактор или множитель, — это такое целое число 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!

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

Синтаксис:

lambda [аргументы] : выражение

Лямбда-функция может иметь ноль или более аргументов перед символом ‘:’. При вызове такой функции выполняется выражение, указанное после ‘:’.

Пример определения лямбда-функции:

get_cube = lambda x : x ** 3

Приведенная выше лямбда-функция начинается с ключевого слова lambda, за которым следует параметр x. Выражение x ** 3 после ‘:’ возвращает вызывающему коду значение куба переданного числа. Сама лямбда-функция lambda x : x ** 3 присваивается переменной get_cube для ее последующего вызова как именованной функции. Имя переменной становится именем функции, чтобы мы могли работать с ней как с обычной функцией.

Пример вызова лямбда-функции:

    >>> get_cube(4)
    64

Приведенное выше определение лямбда-функции аналогично следующей стандартной функции:

    def get_cube(x):
        return x ** 3

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

Пример лямбда-функции, не возвращающей значение:

    >>> welcome = lambda user: print('Welcome, ' + name + '!')
    >>> welcome('Anon')
    Welcome, Anon!

Примечание:

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

Следующая лямбда-функция содержит несколько параметров.

Пример лямбда-функции с тремя параметрами:

    >>> get_prod = lambda a, b, c : a * b * c
    >>> get_prod(3, 5, 7)
    105

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

Пример лямбда-функции с неопределенным числом аргументов (используются только первые 3):

Лямбда-функция без параметров

Ниже приведен пример лямбда-функции без параметров.

    >>> welcome = lambda : print('Welcome!')
    >>> welcome()
    Welcome!

Анонимная функция

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

Пример анонимной лямбда-функции:

    >>> (lambda x: x**3)(10)
    1000

Здесь lambda x: x3 определяет анонимную функцию и вызывает ее один раз, передавая аргументы в скобках (lambda x: x3)(10).

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

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

Пример передачи лямбда-функции в качестве параметра:

def run_task(task):
	    print('Before running the task')
	    task()
	    print('After running the task')

run_task(lambda : print('Task is complete!')) # передача анонимной функции
important_task = lambda : print('Important task is complete!') 
run_task(important_task) # передача лямбда-функции

Вывод:

Before running the task
Task is complete!
After running the task
Before running the task
Important task is complete!
After running the task

Представленная выше функция run_task() определена с параметром task, который вызывается как функция внутри run_task(). run_task(lambda : print(‘Task is complete!’)) вызывает функцию run_task() с анонимной лямбда-функцией в качестве аргумента.

В Python есть встроенные функции, которые принимают в качестве аргументов другие функции. Функции map(), filter() и reduce() являются важными инструментами функционального программирования. Все они принимают на вход функцию. Такая функция-аргумент может быть обычной функцией или лямбда-функцией.

Пример передачи лямбда-функции в map():

    >>> prime_cube_list = map(lambda x: x**3, [2, 3, 5, 7, 11]) # передача анонимной функции
    >>> next(prime_cube_list)
    8
    >>> next(prime_cube_list)
    27
    >>> next(prime_cube_list)
    125
    >>> next(prime_cube_list)
    343
    >>> next(prime_cube_list)
    1331

Давайте посмотрим на следующий фрагмент:

# Простая программа на Python для демонстрации
# работы yield
  
# Функция-генератор, которая выдает 2 при
# первом обращении, 4 — при втором и
# 8 — при третьем
def simple_generator():
    yield 2
    yield 4
    yield 8
  
# Код для проверки simple_generator()
for value in simple_generator(): 
    print(value)

Вывод:

2
4
8

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

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

# Программа на Python для генерации степеней 2
# от 2 до 256
def get_next_num():
    n = 2
  
    # Бесконечный цикл для генерации степеней 2
    while True:
        yield n
        n *= 2  # При последующем обращении к 
                # get_next_num() выполнение
                # продолжится отсюда 
  
# Код для проверки get_next_num()
for num in get_next_num():
    if num > 256:
         break    
    print(num)

Вывод:

2
4 
8 
16
32
64
128
256

Кубический корень обозначается символом «3√». В случае с квадратным корнем мы использовали только символ ‘√’ без указания степени, который также называется радикалом.

Например, кубический корень из 125, обозначаемый как 3√125, равен 5, так как при умножении 5 на само себя три раза получается 5 x 5 x 5 = 125 = 5^3.

Кубический корень в Python

Чтобы вычислить кубический корень в Python, используйте простое математическое выражение x ** (1. / 3.), результатом которого является кубический корень из x в виде значения с плавающей точкой. Для проверки, корректно ли произведена операция извлечения корня, округлите полученный результат до ближайшего целого числа и возведите его в третью степень, после сравните, равен ли результат x.

x = 8

cube_root = x ** (1./3.)

print(cube_root)

Вывод

2.0

В Python для того, чтобы возвести число в степень, мы используем оператор **. Указание степени, равной 1/3, в выражении с ** позволяет получить кубический корень данного числа.

Извлечение кубического корня из отрицательного числа в Python

Мы не можем найти кубический корень из отрицательных чисел указанным выше способом. Например, кубический корень из целого числа -64 должен быть равен -4, но Python возвращает 2+3.464101615137754j.

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

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

def get_cube_root(x):
    if x < 0:
        x = abs(x)
        cube_root = x**(1/3)*(-1)
    else:
        cube_root = x**(1/3)
    return cube_root

print(round(get_cube_root(64)))
print(get_cube_root(-64))

Вывод

4
-3.9999999999999996

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

Использование функции Numpy cbrt()

Библиотека numpy предлагает еще один вариант нахождения кубического корня в Python, который заключается в использовании метода cbrt(). Функция np.cbrt() вычисляет кубический корень для каждого элемента переданного ей массива.

import numpy as np 

cubes = [125, -64, 27, -8, 1] 
cube_roots = np.cbrt(cubes) 
print(cube_roots)

Вывод

[ 5. -4.  3. -2.  1.]

Функция np.cbrt() — самый простой способ получения кубического корня числа. Она не испытывает проблем с отрицательными входными данными и возвращает целочисленное число, например, -4 для переданного в качестве аргумента числа -64, в отличие от вышеописанных подходов.

В этой статье мы рассмотрим несколько примеров использования циклов for с функцией range() в Python.

Циклы for в Python

Циклы for повторяют определённый код для некоторого набора значений.

Из документации Python можно узнать, что в нем циклы for работают несколько иначе, чем в таких языках, как JavaScript или C.

Цикл for присваивает итерируемой переменной каждое значение из предоставленного списка, массива или строки и повторяет код в теле цикла for для каждого установленного таким образом значения переменной-итератора.

В приведенном ниже примере мы используем цикл for для вывода каждого числа в нашем массиве.

# Простой пример цикла for
for i in [0, 1, 2, 3, 4, 5]:
    print(i, end="; ") # выведет: 0; 1; 2; 3; 4; 5; 

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

# Пример посложнее
for i in [0, 1, 2, 3, 4, 5]:
    x = (i-2)*(i+2) - i**2 + 4
    print(x, end="; ") # выведет: 0; 0; 0; 0; 0; 0;

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

Функция Range в Python

Функция range() возвращает последовательность целых чисел на основе переданных ей аргументов. Дополнительную информацию можно найти в документации Python по функции range().

range(stop)
range(start, stop[, step])

Аргумент start — это первое значение в диапазоне. Если функция range() вызывается только с одним аргументом, то Python считает, что start = 0.

Аргумент stop — это верхняя граница диапазона. Важно понимать, что само граничное значение не включается в последовательность.

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

# Использование range() с единственным аргументом
for i in range(6):
    print(i, end="; ") # выведет: 0; 1; 2; 3; 4; 5; 

В следующем примере мы задаем start = -2 и включаем целые числа меньше 4.

# В этот раз передаются два аргумента
for i in range(-2, 4):
    print(i, end="; ") # выведет: -2; -1; 0; 1; 2; 3; 

Необязательное значение step (шаг) управляет приращением между значениями последовательности. По умолчанию step = 1.

В нашем последнем примере мы используем диапазон целых чисел от -2 до 6 и задаем step = 2.

# Здесь используются все аргументы range()
for i in range(-2, 6, 2):
    print(i, end="; ") # выведет: -2; 0; 2; 4; 

Заключение

В этой статье мы рассмотрели циклы for в Python и функцию range().

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

Как было показано, мы можем использовать range(), чтобы упростить написание цикла for. При вызове данной функции вы обязаны указать stop значение, также вами могут быть определены начальное значение и шаг между целыми числами в возвращаемом диапазоне.

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

Замена элемента в списке на Python

Вы можете заменить элемент в списке на Python, используя цикл for, обращение по индексу или list comprehension. Первые два метода изменяют существующий список, а последний создает новый с заданными изменениями.

Давайте кратко опишем каждый метод:

• Обращение по индексу: мы используем порядковый номер элемента списка для изменения его значения. Знак равенства используется для присвоения нового значения выбранному элементу.
• List comprehension или генератор списка создает новый список из существующего. Синтаксис list comprehension позволяет добавлять различные условия для определения значений в новом списке.
• Цикл For выполняет итерацию по элементам списка. Для внесения изменений в данном случае используется обращение по индексу. Мы применяем метод enumerate() для создания двух списков: с индексами и с соответствующими значениями элементов — и итерируем по ним.

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

Замена элемента в списке на Python: обращение по индексу

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

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

Начнем с создания списка, который содержит цены на наши товары:

prices = [29.30, 10.20, 44.00, 5.99, 81.90]

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

prices[0] = 31.30
print(prices)

Наш код выбирает элемент в нулевой позиции и устанавливает его значение равным 31.30, что на $2 больше прежней цены. Далее мы возвращаем список со скорректированной ценой первого товара:

[31.30, 10.20, 44.00, 5.99, 81.90]

Мы также можем изменить наш список, добавив два к текущему значению prices[0]:

prices[0] = prices[0] + 2
print(prices)

prices[0] соответствует первому элементу в нашем списке (тот, который находится в позиции с нулевым индексом).

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

[31.30, 10.20, 44.00, 5.99, 81.90]

Замена элемента в списке на Python: list comprehension

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

Использование list comprehension позволяет перебирать элементы существующего списка и образовывать из них новый список на основе определенного критерия. Например, из последовательности слов можно скомпоновать новую, выбрав только те, которые начинаются на «C».

Здесь мы написали программу, которая рассчитывает 30% скидку на все товары в магазине одежды, стоимость которых превышает $40. Мы используем представленный ранее список цен на товары:

prices = [29.30, 10.20, 44.00, 5.99, 81.90]

Далее мы применяем list comprehension для замены элементов в нашем списке:

sale_prices = [round(price - (price * 30 / 100), 2) if price > 40 else price for price in prices]
print(sale_prices)

Таким образом, наш генератор проходит по списку «prices» и ищет значения стоимостью более 40 долларов. К найденным товарам применяется скидка в 30%. Мы округляем полученные значения цен со скидкой до двух десятичных знаков после точки с помощью метода round().

Наш код выводит следующий список с новыми ценами:

[29.3, 10.2, 30.8, 5.99, 57.33]

Замена элемента в списке на Python: цикл for

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

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

prices = [29.30, 10.20, 44.00, 5.99, 81.90]

Затем мы определим цикл for, который проходит по данному списку с помощью функции enumerate():

for index, item in enumerate(prices):
	if item > 40:
		prices[index] = round(prices[index] - (prices[index] * 30 / 100), 2)

print(prices)

В коде выше переменная «index» содержит позиционный номер элемента. В свою очередь «item» — это значение, хранящееся в элементе списка на данной позиции. Индекс и соответствующее значение, возвращаемые методом enumerate(), разделяются запятой.

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

Здесь мы используем ту же формулу, что и ранее, для расчета 30% скидки на товары стоимостью более 40 долларов. Давайте запустим наш код и посмотрим, что получится:

[29.3, 10.2, 30.8, 5.99, 57.33]

Наш код успешно изменяет товары в списке «prices» в соответствии с нашей скидкой.

Заключение

Вы можете заменить элементы в списке на Python с помощью обращения по индексу, list comprehension или цикла for.

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

Определение функции

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

Синтаксис:

    def имя_функции(параметры):
        """docstring"""
        инструкция1
        инструкция2
        ...
        ...
        return [выражение]

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

Первой инструкцией в теле функции может быть строка, которая называется docstring. Она описывает функциональность функции/класса. Строка docstring не является обязательной.

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

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

В следующем примере определена функция welcome().

Пример созданной пользователем функции:

    def welcome():
        """This function prints 'Welcome!'"""
        print('Welcome!')

Выше мы определили функцию welcome(). Первая инструкция — это docstring, в котором сообщается о том, что делает эта функция. Вторая — это метод print, который выводит указанную строку на консоль. Обратите внимание, что welcome() не содержит оператор return.

Чтобы вызвать определенную ранее функцию, просто используйте выражение, состоящее из ее имени и двух круглых скобок ‘()’, в любом месте кода. Например, приведенная выше функция может быть вызвана так: welcome().

Пример вызова определенной пользователем функции:

welcome()

Вывод:

Welcome!

По умолчанию все функции возвращают None, если отсутствует оператор return.

returned_value = welcome()
print(returned_value)

Вывод:

Welcome!
None

Функция help() выводит docstring, как показано ниже.

    >>> help(welcome)
    Help on function welcome in module __main__:
    
    welcome()
        This function prints 'Welcome!'

Параметры функции

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

Пример функции с аргументами:

def welcome(user_name):
    print('Welcome, ' + user_name + '!')

welcome('Anon') # вызов функции с параметром

Вывод:

   Welcome, Anon!

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

Параметры функции могут иметь аннотацию для указания типа аргумента с использованием синтаксиса parameter:type. Например, следующая аннотация указывает тип параметра string.

Пример использования аннотации типов:

def welcome(user_name:str):
    print('Welcome, ' + user_name + '!')

welcome('Anon') # передача строки в функцию
                # пройдет нормально
welcome(42) # а передача числа в функцию
            # вызовет ошибку

Передача нескольких параметров

Функция может иметь множество параметров. Представленная ниже вариация welcome() принимает три аргумента.

Пример определения функции с несколькими параметрами:

def welcome(first_name:str, last_name:str):
    print('Welcome, ' + first_name + ' ' + last_name + '!')

welcome('Anton', 'Chekhov') # передача аргументов в функцию

Вывод:

Welcome, Anton Chekhov!

Неизвестное количество аргументов

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

Пример функции с неизвестным числом параметров (используются только первые 3):

def welcome(*name_parts):
    message = 'Welcome, ' + name_parts[0] + " "
    message += name_parts[1] + " " + name_parts[2]
    print(message + "!")

welcome('Anton', 'Pavlovich', 'Chekhov')

Вывод:

Welcome, Anton Pavlovich Chekhov!

Следующая функция работает с любым количеством аргументов.

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

def welcome(*name_parts):
    message = 'Welcome,'
    for part in name_parts:
        message += " " + part
    print(message + "!")

welcome('Anton', 'Pavlovich', 'Chekhov',
    'and', 'Fyodor', 'Mikhailovich', 'Dostoevsky')

Вывод:

Welcome, Anton Pavlovich Chekhov and Fyodor Mikhailovich Dostoevsky!

Аргументы-ключевые слова

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

def welcome(first_name:str, last_name:str):
    print('Welcome, ' + first_name + ' ' + last_name + '!')

welcome(last_name='Chekhov', first_name='Anton') # передача
    # аргументов в функцию в произвольном порядке

Вывод:

Welcome, Anton Chekhov!

Аргументы-ключевые слова **kwarg

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

Пример использования **kwarg:

def welcome(**name_parts):
    print('Welcome, ' + name_parts['first_name'] + ' ' + name_parts['last_name'] + '!')

welcome(last_name='Chekhov', first_name='Anton')
welcome(last_name='Chekhov', first_name='Anton', age='28')
welcome(last_name='Chekhov') # вызовет KeyError 

Вывод:

Welcome, Anton Chekhov!
Welcome, Anton Chekhov!

При использовании параметра ** порядок аргументов не имеет значения. Однако их имена должны быть идентичными. Доступ к аргументам-ключевым словам для получения переданных значений осуществляется с помощью такого выражения: имя_параметра_kwarg[‘имя_переданного_аргумента’].

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

Пример функции, вызывающей KeyError:

    def welcome(**name_parts):
        print('Welcome, ' + name_parts['first_name'] + ' ' + name_parts['last_name'] + '!')
    
    welcome(last_name='Chekhov') # вызывет KeyError: необходимо предоставить аргумент 'first_name'

Вывод:

    Traceback (most recent call last):
        ...
        line 2, in welcome
        print('Welcome, ' + name_parts['first_name'] + ' ' + name_parts['last_name'] + '!')
        KeyError: 'first_name'

Параметры со значением по умолчанию

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

Представленная ниже функция welcome() определена с параметром name, имеющим значение по умолчанию ‘Anon’. Оно будет заменено только в том случае, если вызывающей стороной будет передан какой-либо фактический аргумент.

Пример функции со значением по умолчанию:

def welcome(user:str = 'Anon'):
    print('Welcome, ' + user + '!')

welcome()
welcome('Chekhov')

Вывод:

Welcome, Anon!
Welcome, Chekhov!

Функция с возвращаемым значением

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

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

Пример функции с возвращаемым значением:

def get_product(a, b): 
    return a * b

Ниже показано, как при вызове функции get_product() получить результат ее работы.

Пример использования функции с возвращаемым значением:

result = get_product(6, 7) 
print(result)
result = get_product(3, get_product(4, 5))
print(result)

Вывод:

42
60

Enum в Python

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

Модуль enum используется для создания перечислений в Python. Вы можете определить их с помощью ключевого слова class или с помощью функционального API.

Существуют специальные производные перечисления enum.IntEnum, enum.IntFlag и enum.Flag.

Простой пример использования enum в Python

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

    #!/usr/bin/python3
    
    from enum import Enum
     
    class Weapon(Enum):
        SWORD = 1
        BOW = 2
        DAGGER = 3
        CLUB = 4
    
    ranged_weapon = Weapon.BOW
    print(ranged_weapon)
    
    if ranged_weapon == Weapon.BOW:
        print("It's a bow")
    
    print(list(Weapon))

В примере у нас есть перечисление Weapon, которое имеет четыре различных значения: SWORD, BOW, DAGGER и CLUB. Чтобы получить доступ к одному из членов enum, мы должны указать название перечисления, за которым следует точка и имя интересующей нас символической константы.

    class Weapon(Enum):
        SWORD = 1
        BOW = 2
        DAGGER = 3
        CLUB = 4

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

    ranged_weapon = Weapon.BOW
    print(ranged_weapon)

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

    if ranged_weapon == Weapon.BOW:
        print("It's a bow")

Данный фрагмент демонстрирует использование Weapon.BOW в выражении if.

print(list(Weapon))

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

Вывод:

    Weapon.BOW
    It's a bow
    [, , , ]

Еще один пример использования enum в Python

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

    #!/usr/bin/python3
    
    from enum import Enum
    
    class Weapon(Enum):
            SWORD = 1
            BOW = 2
            DAGGER = 3
            CLUB = 4
    
    weapon = Weapon.SWORD
    
    print(weapon)
    print(isinstance(weapon, Weapon))
    print(type(weapon))
    print(repr(weapon))
    
    print(Weapon['SWORD'])
    print(Weapon(1))

И снова мы имеем дело с enum Weapon, созданным с помощью класса.

print(weapon)

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

print(isinstance(weapon, Weapon))

С помощью метода isinstance мы проверяем, имеет ли переменная значение типа Weapon.

print(type(weapon))

Функция type выводит тип переменной.

print(repr(weapon))

Функция repr предоставляет дополнительную информацию о перечислении.

    print(Weapon['SWORD'])
    print(Weapon(1))

Доступ к символической константе можно получить как по ее имени, так и по значению (индексу).

Вывод:

    Weapon.SWORD
    True
    
    
    Weapon.SWORD
    Weapon.SWORD

Функциональное создание enum в Python

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

    from enum import Enum
    
    Weapon = Enum('Weapon', 'SWORD BOW DAGGER CLUB', start=1)
    
    weapon = Weapon.DAGGER
    print(weapon)
    
    if weapon == Weapon.DAGGER:
        print("Dagger")

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

Weapon = Enum('Weapon', 'SWORD BOW DAGGER CLUB', start=1)

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

Вывод:

    Weapon.DAGGER
    Dagger

Итерирование enum в Python

Мы можем выполнять итерацию по перечислениям Python.

    from enum import Enum

    Weapon = Enum('Weapon', 'SWORD BOW DAGGER CLUB', start=10)

    for weapon in Weapon:
        print(weapon)

    for weapon in Weapon:
        print(weapon.name, weapon.value)

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

    for weapon in Weapon:
        print(weapon)

В коде выше мы выполняем итерации по членам перечисления в цикле for.

    for weapon in Weapon:
        print(weapon.name, weapon.value)

Здесь мы выводим их имена и значения.

Вывод:

Weapon.SWORD
Weapon.BOW
Weapon.DAGGER
Weapon.CLUB
SWORD 10
BOW 11
DAGGER 12
CLUB 13

Автоматическое назначение имен для enum в Python

Значения символьных констант могут быть автоматически установлены с помощью функции auto().

    #!/usr/bin/python3
    
    from enum import Enum, auto
    
    class Weapon(Enum):
        SWORD = auto()
        BOW = auto()
        DAGGER = auto()
        CLUB = auto()
    
    for weapon in Weapon:
        print(weapon.value)

В этом фрагменте мы создали перечисление Weapon, члены которого получают значения с помощью функции auto.

Вывод:

    1
    2
    3
    4

Уникальные значения enum в Python

Значения символьных констант могут быть принудительно уникальными с помощью декоратора @unique.

#!/usr/bin/python3

from enum import Enum, unique

@unique
class Weapon(Enum):
    SWORD = 1
    BOW = 2
    DAGGER = 3
    CLUB = 3
    # CLUB = 4

for weapon in Weapon:
    print(weapon)

Данный пример завершается с ошибкой ValueError: duplicate values found in : CLUB -> DAGGER, потому что члены CLUB и DAGGER имеют одинаковые значения. Если мы закомментируем декоратор @unique, пример выведет три члена; CLUB игнорируется.

Python enum __members__

Специальный атрибут members представляет собой упорядоченное отображение имен на символьные константы enum, доступное только для чтения.

#!/usr/bin/python3

from enum import Enum

Weapon = Enum('Weapon', [('SWORD', 1), ('BOW', 2), 
    ('DAGGER', 3), ('CLUB', 4)])

for name, member in Weapon.__members__.items():
    print(name, member)

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

Вывод:

    SWORD Weapon.SWORD
    BOW Weapon.BOW
    DAGGER Weapon.DAGGER
    CLUB Weapon.CLUB

enum.Flag

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

#!/usr/bin/python3

from enum import Flag, auto

class Permission(Flag):
    READ = auto()
    WRITE = auto()
    EXECUTE = auto()

print(list(Permission))
print(Permission.READ | Permission.WRITE)

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

Вывод:

    [<Permission.READ: 1>, <Permission.WRITE: 2>, <Permission.EXECUTE: 4>]
    Permission.WRITE|READ

Если вы считаете Colorama полезной, не забудьте поблагодарить ее авторов и сделать пожертвование. Спасибо!

Установка

pip install colorama
# или
conda install -c anaconda colorama

Описание

Управляющие символы ANSI давно используются для создания цветного текста и позиционирования курсора в терминале на Unix и Mac. Colorama делает возможным их использование на платформе Windows, оборачивая stdout, удаляя найденные ANSI-последовательности (которые будут выглядеть как тарабарщина при выводе) и преобразуя их в соответствующие вызовы win32 для изменения состояния командной строки. На других платформах Colorama ничего не меняет.

В результате мы получаем простой кроссплатформенный API для отображения цветного терминального текста из Python, а также следующий приятный побочный эффект: существующие приложения или библиотеки, использующие ANSI-последовательности для создания цветного вывода на Linux или Mac, теперь могут работать и на Windows, просто вызвав colorama.init().

Альтернативный подход заключается в установке ansi.sys на машины с Windows, что обеспечивает одинаковое поведение для всех приложений, работающих с командной строкой. Colorama предназначена для ситуаций, когда это не так просто (например, может быть, у вашего приложения нет программы установки).

Демо-скрипты в репозитории исходного кода библиотеки выводят небольшой цветной текст, используя последовательности ANSI. Сравните их работу в Gnome-terminal и в Windows Command-Prompt, где отображение осуществляется с помощью Colorama:

Эти скриншоты показывают, что в Windows Colorama не поддерживает ANSI ‘dim text’ (тусклый текст); он выглядит так же, как и ‘normal text’.

Использование

Инициализация

Приложения должны инициализировать Colorama с помощью:

from colorama import init
init()

В Windows вызов init() отфильтрует управляющие ANSI-последовательности из любого текста, отправленного в stdout или stderr, и заменит их на эквивалентные вызовы Win32.

На других платформах вызов init() не имеет никакого эффекта (если только вы не укажете другие дополнительные возможности; см. раздел «Аргументы Init», ниже). По задумке разработчиков такое поведение позволяет приложениям вызывать init() безоговорочно на всех платформах, после чего вывод ANSI должен просто работать.

Чтобы прекратить использование Colorama до выхода из программы, просто вызовите deinit(). Данный метод вернет stdout и stderr к их исходным значениям, так что Colorama будет отключена. Чтобы возобновить ее работу, используйте reinit(); это выгоднее, чем повторный вызов init() (но делает то же самое).

Цветной вывод

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

from colorama import init
init()
from colorama import Fore, Back, Style
print(Fore.GREEN + 'зеленый текст')
print(Back.YELLOW + 'на желтом фоне')
print(Style.BRIGHT + 'стал ярче' + Style.RESET_ALL)
print('обычный текст')

При этом вы также можете использовать ANSI-последовательности напрямую в своем коде:

print('\033[31m' + 'красный текст')
print('\033[39m') # сброс к цвету по умолчанию

Еще одним вариантом является применение Colorama в сочетании с существующими ANSI библиотеками, такими как Termcolor или Blessings. Такой подход настоятельно рекомендуется для чего-то большего, чем тривиальное выделение текста:

from colorama import init
from termcolor import colored

# используйте Colorama, чтобы Termcolor работал и в Windows
init()

# теперь вы можете применять Termcolor для вывода
# вашего цветного текста
print(colored('Termcolor and Colorama!', 'red', 'on_yellow'))

Доступны следующие константы форматирования:

// цвет текста
Fore: BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE, RESET.
// цвет фона
Back: BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE, RESET.
// яркость текста и общий сброс
Style: DIM, NORMAL, BRIGHT, RESET_ALL

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

Позиционирование курсора

Библиотекой поддерживаются ANSI-коды для изменения положения курсора. Пример их генерации смотрите в demos/demo06.py.

Аргументы Init

init() принимает некоторые **kwargs для переопределения поведения по умолчанию.

init(autoreset=False):
Если вы постоянно осуществляете сброс указанных вами цветовых настроек после каждого вывода, init(autoreset=True) будет выполнять это по умолчанию:

from colorama import init, Fore
init(autoreset=True)
print(Fore.GREEN + 'зеленый текст')
print('автоматический возврат к обычному')

init(strip=None):
Передайте True или False, чтобы определить, должны ли коды ANSI удаляться при выводе. Поведение по умолчанию — удаление, если программа запущена на Windows или если вывод перенаправляется (не на tty).

init(convert=None):
Передайте True или False, чтобы определить, следует ли преобразовывать ANSI-коды в выводе в вызовы win32. По умолчанию Colorama будет их конвертировать, если вы работаете под Windows и вывод осуществляется на tty (терминал).

init(wrap=True):
В Windows Colorama заменяет sys.stdout и sys.stderr прокси-объектами, которые переопределяют метод .write() для выполнения своей работы. Если эта обертка вызывает у вас проблемы, то ее можно отключить, передав init(wrap=False). Поведение по умолчанию — обертывание, если autoreset, strip или convert равны True.

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

import sys
from colorama import init, Fore, AnsiToWin32
init(wrap=False)
stream = AnsiToWin32(sys.stderr).stream

# Python 2
print >>stream, Fore.RED + 'красный текст отправлен в stderr'

# Python 3
print(Fore.RED + 'красный текст отправлен в stderr', file=stream)

Распознаваемые ANSI-последовательности

Последовательности ANSI обычно имеют вид:

ESC [ <параметр> ; <параметр> ... <команда>

Где <параметр> — целое число, а <команда> — один символ. В <команда> передается ноль или более параметров. Если параметры не представлены, это, как правило, синоним передачи одного нуля. В последовательности нет пробелов; они были добавлены здесь исключительно для удобства чтения.

Единственные ANSI-последовательности, которые Colorama преобразует в вызовы win32, это:

ESC [ 0 m     # сбросить все (цвета и яркость)
    ESC [ 1 m     # яркий
    ESC [ 2 m     # тусклый (выглядит так же, как обычная яркость)
    ESC [ 22 м    # нормальная яркость
    
    # FOREGROUND (цвет текста)
    ESC [ 30 м     # черный
    ESC [ 31 м     # красный
    ESC [ 32 м     # зеленый
    ESC [ 33 м     # желтый
    ESC [ 34 m     # синий
    ESC [ 35 m     # пурпурный
    ESC [ 36 m     # голубой
    ESC [ 37 m     # белый
    ESC [ 39 m     # сброс
    
    # ФОН
    ESC [ 40 m     # черный
    ESC [ 41 m     # красный
    ESC [ 42 м     # зеленый
    ESC [ 43 m     # желтый
    ESC [ 44 m     # синий
    ESC [ 45 m     # пурпурный
    ESC [ 46 m     # голубой
    ESC [ 47 m     # белый
    ESC [ 49 m     # сброс
    
    # позиционирование курсора
    ESC [ y;x H    # позиционирование курсора в позиции x, y (у направлена вниз)
    ESC [ y;x f    # позиционирование курсора в точке x, y
    ESC [ n A      # перемещение курсора на n строк вверх
    ESC [ n B      # перемещение курсора на n строк вниз
    ESC [ n C      # перемещение курсора на n символов вперед
    ESC [ n D      # перемещение курсора на n символов назад
    
    # очистить экран
    ESC [ режим J     # очистить экран
    
    # очистить строку
    ESC [ режим K     # очистить строку

Несколько числовых параметров команды ‘m’ могут быть объединены в одну последовательность:

ESC [ 36 ; 45 ; 1 m     # яркий голубой текст на пурпурном фоне

Все другие ANSI-последовательности вида ESC [ <параметр> ; <параметр> … <команда> молча удаляются из вывода в Windows.

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

Текущий статус и известные проблемы

Лично я тестировал библиотеку только на Windows XP (CMD, Console2), Ubuntu (gnome-terminal, xterm) и OS X.

Некоторые предположительно правильные ANSI-последовательности не распознаются (см. подробности ниже), но, насколько мне известно, никто еще не жаловался на это. Загадка.

См. нерешенные проблемы и список пожеланий: https://github.com/tartley/colorama/issues

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

Код #1: Демонстрация работы yield

# Код на Python3 для демонстрации
# использования ключевого слова yield
 
# генерация нового списка, состоящего
# только из четных чисел
def get_even(list_of_nums) :
    for i in list_of_nums:
        if i % 2 == 0:
            yield i
 
# инициализация списка
list_of_nums = [1, 2, 3, 8, 15, 42]
 
# вывод начального списка
print ("До фильтрации в генераторе: " +  str(list_of_nums))
 
# вывод только четных значений из списка
print ("Только четные числа: ", end = " ")
for i in get_even(list_of_nums):
    print (i, end = " ")

Вывод

До фильтрации в генераторе: [1, 2, 3, 8, 15, 42] 
Только четные числа:  2 8 42

Код #2

# Данная Python программа выводит
# числа от 1 до 15, возведенные в куб,
# используя yield и, следовательно, генератор
 
# Функция ниже будет бесконечно генерировать
# последовательность чисел в третьей степени,
# начиная с 1
def nextCube():
    acc = 1
 
    # Бесконечный цикл
    while True:
        yield acc**3                
        acc += 1 # После повторного обращения
                # исполнение продолжится отсюда
 
# Ниже мы запрашиваем у генератора 
# и выводим ровно 15 чисел
count = 1
for num in nextCube():
    if count > 15:
        break   
    print(num)
    count += 1

Вывод:

1
8
27
64
125
216
343
512
729
1000
1331
1728
2197
2744
3375

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

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

Недостатки yield:

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

Практическое применение

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

# Код Python3 для демонстрации
# использования ключевого слова yield
 
# Поиск слова pythonru в тексте

# Импорт библиотеки для работы 
# с регулярными выражениями
import re

# Этот генератор создает последовательность
# значений True: по одному на каждое
# найденное слово pythonru
# Также для наглядности он выводит
# обработанные слова
def get_pythonru (text) :
    text = re.split('[., ]+', text)
    for word in text:
        print(word)
        if word == "pythonru":
            yield True
 
# Инициализация строки, содержащей текст для поиска
text = "В Интернете есть множество сайтов, \
            но только один pythonru. \
            Программа никогда не прочтет \
            последнее предложение."

# Инициализация переменной с результатом
result = "не найден"

# Цикл произведет единственную итерацию
# в случае наличия в тексте pythonru и 
# не сделает ни одной, если таких слов нет
for j in get_pythonru(text):
    result = "найден"
    break

print ('Результат поиска: %s' % result)

Вывод

В
Интернете
есть
множество
сайтов
но
только
один
pythonru
Результат поиска: найден

Сначала давайте вкратце рассмотрим, что такое список в 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() и других алгоритмов. Мы написали свои код, чтобы попробовать метод перебора, хвостовой рекурсии и алгоритма приоритетной очереди.

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

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

Я решил подойти к делу обстоятельно, поэтому постарался структурировать все варианты (спойлер, их два основных), оценить все «‎за» и «‎против» и уже на основе этого мини исследования принимать решение. Надеюсь, кому-нибудь это тоже будет полезно и поможет увидеть новые возможности.

Вводные и первые выводы

Дано: 

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

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

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

Проверка гипотезы #1 — работа

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

За пару дней не осталось предложений в моём городе (Калининград), которые бы не попались мне два, а то и три раза. Я отправил 28 откликов на вакансии, показавшиеся мне интересными. 

Основной критерий здесь был такой: если при прочтении текста вакансии я думал: «‎Классное место! Здесь мне будет интересно», то отправлял свое резюме.

• На мои запросы в течение недели пришло 12 ответов. 
• 5 из них поблагодарили за интерес и обещали иметь меня ввиду.
• 7 пригласили на собеседование или предложили тестовые задания.

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

Проверка гипотезы #2 — учеба и подработка

Эта гипотеза изначально не вызывала у меня уверенности. 

Допустим, я смогу найти интересную магистратуру в моём городе  — Калининграде. Но нужно будет еще искать работу, которую получится совместить с учебой. А значит, работать придётся больше, чем при варианте #1: учеба — работа — сон — учеба — и т.д. Я не против труда, но опасался, что просто не смогу качественно успевать на обоих фронтах.

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

Мой поиск привел меня на сайт МФТИ. Где я наткнулся на магистратуру «‎Системы машинного обучения для умного производства». Сразу скажу, что свой запрос на участие в отборе на грант я уже отправил. Но решил поделиться, потому что знаю, насколько иногда важно найти нужную информацию.

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

Я не просто так делаю на этом акцент. Первое, что меня заинтересовало в этой программе — работа под руководством IT-специалистов НЛМК над проектами компании. Ни через год или два, а с первого семестра учебы. Одна мысль о том, что во время магистратуры не придется довольствоваться только теорией, меня крайне впечатлила.

Следующий аргумент «‎за» — грант. Магистранты не платят за это обучение совсем. Как я понял, суть в том, что компания НЛМК готова выращивать свои кадры. Поэтому они берут тех, кто разбирается в программировании и математике, и обеспечивают им среду для роста. А за пару лет плотной работы с задачами НЛМК магистранты превращаются в спецов Data Science и инженеров искусственного интеллекта.

Кстати, о работе тоже переживать не придется. Студенты получают доход от 35 до 80 тыс. рублей и официальный опыт работы с первых дней учебы. В интервью с куратором программы Шамилем Ульбашевым я прочитал, что доход на последних курсах может расти до 140 тыс. рублей, это зависит от самого студента. Чем больше пользы приносишь, тем больше получаешь. 

Смотрите, какой у меня итог:

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

Итог исследования

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

Если кому-то интересно, вот сайт магистратуры, может, будем учиться вместе. 

Удачи всем выпускникам в определении своего пути!

Автор: Игорь Макушев

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

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

Python считается современным языком программирования и используется для разработки бесчисленных программных продуктов. С помощью него дети могут создавать свои приложения от простого вывода «Hello World!» до разработки анимации и игр. Программирование на Python развивает у ребенка интерес к изучению этой сферы.

Что такое Python?

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

Например, если вы хотите отобразить «Hello!» на экране компьютера, необходимая для этого команда в Python будет выглядеть следующим образом:

print("Hello")

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

• Встроенные структуры данных.
• Поощряет повторное использование кода.
• Наличие обширной стандартной библиотеки.
• Сверхбыстрый цикл редактирования-тестирования-отладки.

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

Почему дети должны изучать Python?

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

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

Причины, по которым дети должны изучать Python:

1. Python — один из самых гибких языков программирования. Он имеет легко читаемый набор команд и синтаксис, который гораздо менее сложен, чем в других языках программирования. Эти команды представляют собой обычные английские слова, что делает изучение Python более доступным для детей.
2. Детям не нужно прочесть множество учебников, чтобы начать писать код на Python. Изучение Python для детей — вполне выполнимая задача, даже если у них нет никаких предшествующих знаний о программировании.
3. Python имеет обширную стандартную библиотеку, которую можно импортировать по необходимости. Дети могут осуществить многие свои идеи при создании приложений на Python, просто добавляя нужные библиотеки. Такой подход повышает доступность Python. Дети могут написать код любой программы на Python за меньшее число шагов, чем если бы им пришлось писать на Java или C.
4. Python — очень дружелюбный к детям язык программирования. Они могут экспериментировать с различными фрагментами кода и постепенно собирать из них более осмысленные программы для создания собственных видеоигр и анимации.
5. Совершенно очевидно, что язык программирования Python останется с нами надолго. Поэтому для детей довольно важно изучать Python из-за широкого спектра его применения. Знание Python также даст им преимущество при получении высшего образования в области науки о данных, автоматизации, машинного обучения и веб-разработки.
6. Несмотря на различные усовершенствования, базовая структура языка Python остается неизменной. Поэтому изучение программирования на Python для малышей является большим плюсом, так как их навыки точно не устареют в будущем.
7. Изучение Python также повысит способность детей к критическому мышлению. Да, последовательное рассуждение — это ключ к пониманию основных концепций программирования. Поэтому написание кода на Python для различных приложений позволит детям визуализировать и в итоге осмыслить сложные абстрактные понятия программирования. Это, в свою очередь, также улучшит их способность анализировать и решать математические задачи.

Как лучше всего детям изучать Python?

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

1. «Поколение Python»: курс для начинающих
2. Программирование на Python [Sanak-lab]
3. ПИТОНТЬЮТОР

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

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

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

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

1. Python — практические задачи
2. Основы программирования на языке Python в примерах и задачах
3. Книга «1400 задач по программированию»

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

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

Некоторые из лучших книг по Python для детей

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

• Python для детей и родителей. Играй и программируй
• Python для детей. Самоучитель по программированию

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

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

Книга «Python для детей и родителей. Играй и программируй» также имеет очень интересный подход. Темы, освещенные в ней, подходят для изучения языка детьми и родителями.

Что дети могут делать с Python?

Начнем с того, что они могут отображать простые сообщения типа «Hello World!» или «Good Morning!» с помощью Python на начальном уровне. Также могут выполнять и выводить простые математические вычисления с помощью функции print. Например:

>>> print("Доброе утро!")
Доброе уро!
>>> print(12 + 10 - 2)
20

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

>>> print("Клубника и\nМалина")
Клубника и
Малина
>>> x = 2
>>> print(x)
2

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

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

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

Ресурсы для детей

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

Spark предоставляет API для Scala, Java, Python и R. Система поддерживает повторное использование кода между рабочими задачами, пакетную обработку данных, интерактивные запросы, аналитику в реальном времени, машинное обучение и вычисления на графах. Она использует кэширование в памяти и оптимизированное выполнение запросов к данным любого размера.

У нее нет одной собственной файловой системы, такой как Hadoop Distributed File System (HDFS), вместо этого Spark поддерживает множество популярных файловых систем, таких как HDFS, HBase, Cassandra, Amazon S3, Amazon Redshift, Couchbase и т. д.

Преимущества использования Apache Spark:

• Он запускает программы в памяти до 100 раз быстрее, чем Hadoop MapReduce, и в 10 раз быстрее на диске, потому что Spark выполняет обработку в основной памяти рабочих узлов и предотвращает ненужные операции ввода-вывода.
• Spark крайне удобен для пользователя, поскольку имеет API-интерфейсы, написанные на популярных языках, что упрощает задачу для разработчиков: такой подход скрывает сложность распределенной обработки за простыми высокоуровневыми операторами, что значительно снижает объем необходимого кода.
• Систему можно развернуть, используя Mesos, Hadoop через Yarn или собственный диспетчер кластеров Spark.
• Spark производит вычисления в реальном времени и обеспечивает низкую задержку благодаря их резидентному выполнению (в памяти).

Давайте приступим.

Настройка среды в Google Colab

Чтобы запустить pyspark на локальной машине, нам понадобится Java и еще некоторое программное обеспечение. Поэтому вместо сложной процедуры установки мы используем Google Colaboratory, который идеально удовлетворяет наши требования к оборудованию, и также поставляется с широким набором библиотек для анализа данных и машинного обучения. Таким образом, нам остается только установить пакеты pyspark и Py4J. Py4J позволяет программам Python, работающим в интерпретаторе Python, динамически обращаться к объектам Java из виртуальной машины Java.

Итоговый ноутбук можно скачать в репозитории: https://gitlab.com/PythonRu/notebooks/-/blob/master/pyspark_beginner.ipynb

Команда для установки вышеуказанных пакетов:

!pip install pyspark==3.0.1 py4j==0.10.9

Spark Session

SparkSession стал точкой входа в PySpark, начиная с версии 2.0: ранее для этого использовался SparkContext. SparkSession — это способ инициализации базовой функциональности PySpark для программного создания PySpark RDD, DataFrame и Dataset. Его можно использовать вместо SQLContext, HiveContext и других контекстов, определенных до 2.0.

Вы также должны знать, что SparkSession внутренне создает SparkConfig и SparkContext с конфигурацией, предоставленной с SparkSession. SparkSession можно создать с помощью SparkSession.builder, который представляет собой реализацию шаблона проектирования Builder (Строитель).

Создание SparkSession

Чтобы создать SparkSession, вам необходимо использовать метод builder().

• getOrCreate() возвращает уже существующий SparkSession; если он не существует, создается новый SparkSession.
• master(): если вы работаете с кластером, вам нужно передать имя своего кластерного менеджера в качестве аргумента. Обычно это будет либо yarn, либо mesos в зависимости от настройки вашего кластера, а при работе в автономном режиме используется local[x]. Здесь X должно быть целым числом, большим 0. Данное значение указывает, сколько разделов будет создано при использовании RDD, DataFrame и Dataset. В идеале X должно соответствовать количеству ядер ЦП.
• appName() используется для установки имени вашего приложения.

Пример создания SparkSession:

from pyspark.sql import SparkSession

spark = SparkSession.builder\
        .master("local[*]")\
        .appName('PySpark_Tutorial')\
        .getOrCreate()

# где "*" обозначает все ядра процессора.

Чтение данных

Используя spark.read мы может считывать данные из файлов различных форматов, таких как CSV, JSON, Parquet и других. Вот несколько примеров получения данных из файлов:

# Чтение CSV файла
csv_file = 'data/stocks_price_final.csv'
df = spark.read.csv(csv_file)

# Чтение JSON файла
json_file = 'data/stocks_price_final.json'
data = spark.read.json(json_file)

# Чтение parquet файла
parquet_file = 'data/stocks_price_final.parquet'
data1 = spark.read.parquet(parquet_file)

Структурирование данных с помощью схемы Spark

Давайте прочитаем данные о ценах на акции в США с января 2019 года по июль 2020 года, которые доступны в датасетах Kaggle.

Код для чтения данных в формате файла CSV:

data = spark.read.csv(
    'stocks_price_final.csv',
    sep=',',
    header=True,
)

data.printSchema()

Теперь посмотрим на схему данных с помощью метода PrintSchema.

Схема Spark отображает структуру фрейма данных или датасета. Мы можем определить ее с помощью класса StructType, который представляет собой коллекцию объектов StructField. Они в свою очередь устанавливают имя столбца (String), его тип (DataType), допускает ли он значение NULL (Boolean), и метаданные (MetaData).

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

from pyspark.sql.types import *

data_schema = [
               StructField('_c0', IntegerType(), True),
               StructField('symbol', StringType(), True),
               StructField('data', DateType(), True),
               StructField('open', DoubleType(), True),
               StructField('high', DoubleType(), True),
               StructField('low', DoubleType(), True),
               StructField('close', DoubleType(), True),
               StructField('volume', IntegerType(), True),
               StructField('adjusted', DoubleType(), True),
               StructField('market.cap', StringType(), True),
               StructField('sector', StringType(), True),
               StructField('industry', StringType(), True),
               StructField('exchange', StringType(), True),
            ]

final_struc = StructType(fields = data_schema)

data = spark.read.csv(
    'stocks_price_final.csv',
    sep=',',
    header=True,
    schema=final_struc 
)

data.printSchema()

В приведенном выше коде создается структура данных с помощью StructType и StructField. Затем она передается в качестве параметра schema методу spark.read.csv(). Давайте взглянем на полученную в результате схему структурированных данных:

root
 |-- _c0: integer (nullable = true)
 |-- symbol: string (nullable = true)
 |-- data: date (nullable = true)
 |-- open: double (nullable = true)
 |-- high: double (nullable = true)
 |-- low: double (nullable = true)
 |-- close: double (nullable = true)
 |-- volume: integer (nullable = true)
 |-- adjusted: double (nullable = true)
 |-- market.cap: string (nullable = true)
 |-- sector: string (nullable = true)
 |-- industry: string (nullable = true)
 |-- exchange: string (nullable = true)

Различные методы инспекции данных

Существуют следующие методы инспекции данных: schema, dtypes, show, head, first, take, describe, columns, count, distinct, printSchema. Давайте разберемся в них на примере.

• schema(): этот метод возвращает схему данных (фрейма данных). Ниже показан пример с ценами на акции.

data.schema

# -------------- Вывод ------------------
# StructType(
#           List(
#             StructField(_c0,IntegerType,true),
#             StructField(symbol,StringType,true),
#             StructField(data,DateType,true),
#             StructField(open,DoubleType,true),
#             StructField(high,DoubleType,true),
#             StructField(low,DoubleType,true),
#             StructField(close,DoubleType,true),
#             StructField(volume,IntegerType,true),
#             StructField(adjusted,DoubleType,true),
#             StructField(market_cap,StringType,true),
#             StructField(sector,StringType,true),
#             StructField(industry,StringType,true),
#             StructField(exchange,StringType,true)
#           )
#         )

• dtypes возвращает список кортежей с именами столбцов и типами данных.

data.dtypes

#------------- Вывод ------------
# [('_c0', 'int'),
#  ('symbol', 'string'),
#  ('data', 'date'),
#  ('open', 'double'),
#  ('high', 'double'),
#  ('low', 'double'),
#  ('close', 'double'),
#  ('volume', 'int'),
#  ('adjusted', 'double'),
#  ('market_cap', 'string'),
#  ('sector', 'string'),
#  ('industry', 'string'),
#  ('exchange', 'string')]

• head(n) возвращает n строк в виде списка. Вот пример:

data.head(3)

# ---------- Вывод ---------

# [
#  Row(_c0=1, symbol='TXG', data=datetime.date(2019, 9, 12), open=54.0, high=58.0, low=51.0, close=52.75, volume=7326300, adjusted=52.75, market_cap='$9.31B', sector='Capital Goods', industry='Biotechnology: Laboratory Analytical Instruments', exchange='NASDAQ'),
#  Row(_c0=2, symbol='TXG', data=datetime.date(2019, 9, 13), open=52.75, high=54.355, low=49.150002, close=52.27, volume=1025200, adjusted=52.27, market_cap='$9.31B', sector='Capital Goods', industry='Biotechnology: Laboratory Analytical Instruments', exchange='NASDAQ'),
#  Row(_c0=3, symbol='TXG', data=datetime.date(2019, 9, 16), open=52.450001, high=56.0, low=52.009998, close=55.200001, volume=269900, adjusted=55.200001, market_cap='$9.31B', sector='Capital Goods', industry='Biotechnology: Laboratory Analytical Instruments', exchange='NASDAQ')
# ]

• show() по умолчанию отображает первые 20 строк, а также принимает число в качестве параметра для выбора их количества.
• first() возвращает первую строку данных.

data.first()

# ----------- Вывод -------------

# Row(_c0=1, symbol='TXG', data=datetime.date(2019, 9, 12), open=54.0, high=58.0, low=51.0, 
# close=52.75, volume=7326300, adjusted=52.75, market_cap='$9.31B', sector='Capital Goods', 
# industry='Biotechnology: Laboratory Analytical Instruments', exchange='NASDAQ')

• take(n) возвращает первые n строк.
• describe() вычисляет некоторые статистические значения для столбцов с числовым типом данных.
• columns возвращает список, содержащий названия столбцов.

data.columns

# --------------- Вывод --------------

# ['_c0',
#  'symbol',
#  'data',
#  'open',
#  'high',
#  'low',
#  'close',
#  'volume',
#  'adjusted',
#  'market_cap',
#  'sector',
#  'industry',
#  'exchange']

• count() возвращает общее число строк в датасете.

data.count()

# возвращает количество строк данных
# -------- Вывод ---------
# 1292361

• distinct() — количество различных строк в используемом наборе данных.
• printSchema() отображает схему данных.

df.printSchema()

# ------------ Вывод ------------

# root
#  |-- _c0: integer (nullable = true)
#  |-- symbol: string (nullable = true)
#  |-- data: date (nullable = true)
#  |-- open: double (nullable = true)
#  |-- high: double (nullable = true)
#  |-- low: double (nullable = true)
#  |-- close: double (nullable = true)
#  |-- volume: integer (nullable = true)
#  |-- adjusted: double (nullable = true)
#  |-- market_cap: string (nullable = true)
#  |-- sector: string (nullable = true)
#  |-- industry: string (nullable = true)
#  |-- exchange: string (nullable = true)

Манипуляции со столбцами

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

1. Добавление столбца: используйте withColumn, чтобы добавить новый столбец к существующим. Метод принимает два параметра: имя столбца и данные. Пример:

data = data.withColumn('date', data.data)

data.show(5)

2. Обновление столбца: используйте withColumnRenamed, чтобы переименовать существующий столбец. Метод принимает два параметра: название существующего столбца и его новое имя. Пример:

data = data.withColumnRenamed('date', 'data_changed')

data.show(5)

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

data = data.drop('data_changed')

data.show(5)

Работа с недостающими значениями

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

• Удаление: удалить строки с пропущенными значениями в любом из столбцов.
• Замена средним/медианным значением: замените отсутствующие значения, используя среднее или медиану соответствующего столбца. Это просто, быстро и хорошо работает с небольшими наборами числовых данных.
• Замена на наиболее частые значения: как следует из названия, используйте наиболее часто встречающееся значение в столбце, чтобы заменить отсутствующие. Это хорошо работает с категориальными признаками, но также может вносить смещение (bias) в данные.
• Замена с использованием KNN: метод K-ближайших соседей — это алгоритм классификации, который рассчитывает сходство признаков новых точек данных с уже существующими, используя различные метрики расстояния, такие как Евклидова, Махаланобиса, Манхэттена, Минковского, Хэмминга и другие. Такой подход более точен по сравнению с вышеупомянутыми методами, но он требует больших вычислительных ресурсов и довольно чувствителен к выбросам.

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

# Удаление строк с пропущенными значениями
data.na.drop()

# Замена отсутствующих значений средним
data.na.fill(data.select(f.mean(data['open'])).collect()[0][0])

# Замена отсутствующих значений новыми
data.na.replace(old_value, new_vallue)

Получение данных

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

• Select
• Filter
• Between
• When
• Like
• GroupBy
• Агрегирование

Select

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

# Выбор одного столбца
data.select('sector').show(5)

# Выбор нескольких столбцов
data.select(['open', 'close', 'adjusted']).show(5)

Filter

Данный метод фильтрует данные на основе заданного условия. Вы также можете указать несколько условий, используя операторы AND (&), OR (|) и NOT (~). Вот пример получения данных о ценах на акции за январь 2020 года.

from pyspark.sql.functions import col, lit

data.filter( (col('data') >= lit('2020-01-01')) & (col('data') <= lit('2020-01-31')) ).show(5)

Between

Этот метод возвращает True, если проверяемое значение принадлежит указанному отрезку, иначе — False. Давайте посмотрим на пример отбора данных, в которых значения adjusted находятся в диапазоне от 100 до 500.

data.filter(data.adjusted.between(100.0, 500.0)).show()

When

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

data.select('open', 'close', 
            f.when(data.adjusted >= 200.0, 1).otherwise(0)
).show(5)

Like

Этот метод похож на оператор Like в SQL. Приведенный ниже код демонстрирует использование rlike() для извлечения имен секторов, которые начинаются с букв M или C.

data.select(
    'sector', 
    data.sector.rlike('^[B,C]').alias('Колонка sector начинается с B или C')
).distinct().show()

GourpBy

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

data.select(['industry', 'open', 'close', 'adjusted'])\
    .groupBy('industry')\
    .mean()\
    .show()

Агрегирование

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

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

from pyspark.sql import functions as f

data.filter((col('data') >= lit('2019-01-02')) & (col('data') <= lit('2020-01-31')))\
    .groupBy("sector") \
    .agg(f.min("data").alias("С"), 
         f.max("data").alias("По"), 
         
         f.min("open").alias("Минимум при открытии"),
         f.max("open").alias("Максимум при открытии"), 
         f.avg("open").alias("Среднее в open"), 

         f.min("close").alias("Минимум при закрытии"), 
         f.max("close").alias("Максимум при закрытии"), 
         f.avg("close").alias("Среднее в close"), 

         f.min("adjusted").alias("Скорректированный минимум"), 
         f.max("adjusted").alias("Скорректированный максимум"), 
         f.avg("adjusted").alias("Среднее в adjusted"), 

      ).show(truncate=False)

Визуализация данных

Для визуализации данных мы воспользуемся библиотеками matplotlib и pandas. Метод toPandas() позволяет нам осуществить преобразование данных в dataframe pandas, который мы используем при вызове метода визуализации plot(). В приведенном ниже коде показано, как отобразить гистограмму, отображающую средние значения цен открытия, закрытия и скорректированных цен акций для каждого сектора.

from matplotlib import pyplot as plt

sec_df =  data.select(['sector', 
                       'open', 
                       'close', 
                       'adjusted']
                     )\
                     .groupBy('sector')\
                     .mean()\
                     .toPandas()

ind = list(range(12))
ind.pop(6)

sec_df.iloc[ind ,:].plot(kind='bar', x='sector', y=sec_df.columns.tolist()[1:], 
                         figsize=(12, 6), ylabel='Stock Price', xlabel='Sector')
plt.show()

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

industries_x = data.select(['industry', 'open', 'close', 'adjusted']).groupBy('industry').mean().toPandas()

q  = industries_x[(industries_x.industry != 'Major Chemicals') & (industries_x.industry != 'Building Products')]
q.plot(kind='barh', x='industry', y=q.columns.tolist()[1:], figsize=(10, 50), xlabel='Stock Price', ylabel='Industry')

plt.show()

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

industries_x = data.select(['industry', 'open', 'close', 'adjusted']).groupBy('industry').mean().toPandas()

q  = industries_x[(industries_x.industry != 'Major Chemicals') & (industries_x.industry != 'Building Products')]
q.plot(kind='barh', x='industry', y=q.columns.tolist()[1:], figsize=(10, 50), xlabel='Stock Price', ylabel='Industry')

plt.show()

Запись/сохранение данных в файл

Метод write.save() используется для сохранения данных в различных форматах, таких как CSV, JSVON, Parquet и других. Давайте рассмотрим, как записать данные в файлы разных форматов. Мы можем сохранить как все строки, так и только выбранные с помощью метода select().

# CSV
data.write.csv('dataset.csv')

# JSON
data.write.save('dataset.json', format='json')

# Parquet
data.write.save('dataset.parquet', format='parquet')

# Запись выбранных данных в различные форматы файлов

# CSV
data.select(['data', 'open', 'close', 'adjusted'])\
    .write.csv('dataset.csv')

# JSON
data.select(['data', 'open', 'close', 'adjusted'])\
    .write.save('dataset.json', format='json')

# Parquet
data.select(['data', 'open', 'close', 'adjusted'])\
    .write.save('dataset.parquet', format='parquet')

Заключение

PySpark — отличный инструмент для специалистов по данным, поскольку он обеспечивает масштабируемые анализ и ML-пайплайны. Если вы уже знакомы с Python, SQL и Pandas, тогда PySpark — хороший вариант для быстрого старта.

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

Мы узнали, что Google Colaboratory Notebooks — это удобное место для начала изучения PySpark без долгой установки необходимого программного обеспечения. Не забудьте ознакомиться с представленными ниже ссылками на ресурсы, которые могут помочь вам быстрее и проще изучить PySpark.

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

В этом материале разберемся с этой ошибкой, и по каким еще причинам она возникает. Разберем несколько примеров, чтобы понять, как с ней справляться.

Ошибка «SyntaxError: unexpected EOF while parsing» возникает в том случае, когда программа добирается до конца файла, но не весь код еще выполнен. Это может быть вызвано ошибкой в структуре или синтаксисе кода.

EOF значит End of File. Представляет собой последний символ в Python-программе.

Python достигает конца файла до выполнения всех блоков в таких случаях:

• Если забыть заключить код в специальную инструкцию, такую как, циклы for или while, или функцию.
• Не закрыть все скобки на строке.

Разберем эти ошибки на примерах построчно.

Пример №1: незавершенные блоки кода

Циклы for и while, инструкции if и функции требуют как минимум одной строки кода в теле. Если их не добавить, результатом будет ошибка EOF.

Рассмотрим такой пример цикла for, который выводит все элементы рецепта:

ingredients = ["325г муки", "200г охлажденного сливочного масла", "125г сахара", "2 ч. л. ванили", "2 яичных желтка"]

for i in ingredients:

Определяем переменную ingredients, которая хранит список ингредиентов для ванильного песочного печенья. Используем цикл for для перебора по каждому из элементов в списке. Запустим код и посмотрим, что произойдет:

File "main.py", line 4
    
                     	^
SyntaxError: unexpected EOF while parsing

Внутри цикла for нет кода, что приводит к ошибке. То же самое произойдет, если не заполнить цикл while, инструкцию if или функцию.

Для решения проблемы требуется добавить хотя бы какой-нибудь код. Это может быть, например, инструкция print() для вывода отдельных ингредиентов в консоль:

for i in ingredients:
	print(i)

Запустим код:

325г муки
200г охлажденного сливочного масла
125г сахара
2 ч. л. ванили
2 яичных желтка

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

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

for i in ingredients:
	pass

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

Пример №2: незакрытые скобки

Ошибка «SyntaxError: unexpected EOF while parsing» также возникает, если не закрыть скобки в конце строки с кодом.

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

name = "Капитанская дочка"
author = "Александр Пушкин"
genre = "роман"

Отформатируем строку с помощью метода .format():

print('Книга "{}" - это {}, автор {}'.format(name, genre, author)

Значения {} заменяются на реальные из .format(). Это значит, что строка будет выглядеть вот так:

Книга "НАЗВАНИЕ" - это ЖАНР, автор АВТОР

Запустим код:

File "main.py", line 7

              ^
SyntaxError: unexpected EOF while parsing

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

Решаем проблему, добавляя вторую закрывающую скобку («)») в конце строки с print().

print('Книга "{}" - это {}, автор {}'.format(name, genre, author))

Теперь на этой строке закрываются две скобки. И все из них теперь закрыты. Попробуем запустить код снова:

Книга "Капитанская дочка" это роман. Александр Пушкин

Теперь он работает. То же самое произойдет, если забыть закрыть скобки словаря {} или списка [].

Выводы

Ошибка «SyntaxError: unexpected EOF while parsing» возникает, если интерпретатор Python добирается до конца программы до выполнения всех строк.

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

Python используют чуть более 10 миллионов пользователей по всему миру, в 2020 году число новых разработчиков составило 1,6 миллиона человек. Python — второй по распространенности язык после JavaScript.

Откуда эта информация? Благодаря опросу Developer Nation, в котором дважды в год принимают участие более 36 000 разработчиков по всему миру. Их спрашивают о любимых (и не очень) языках программирования, библиотеках, фреймворках, инструментах разработчика и платформах. Опрос организовывает независимая аналитическая компания SlashData, которая специализируется на отслеживании глобальных тенденций в разработке за последние 10 лет.

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

Организаторы позаботились о локализации и добавили русскую версию.

Сделайте среду разработки, облачные сервисы и ML-инструменты лучше

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

Если вы когда-либо хотели повлиять на экосистему разработчиков, то сейчас у вас есть шанс. Новое глобальное исследование Developer Nation, приглашает всех разработчиков и дизайнеров поделится мнением о популярных технологиях, платформах и инструментах в 13 различных областях разработки программного обеспечения:

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

Расскажите над какими проектами вы работаете и с какими трудностями сталкиваетесь. Если вы только учитесь, расскажите о трудностях в обучении. Пройти опрос ->

Выигрывайте ценные призы

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

Респонденты могут выиграть:

1. Ноутбук MacBook Pro 13,
2. Samsung Galaxy S21 Plus,
3. лицензию GitKraken Pro,
4. гаджеты для рабочего места,
5. сертификаты и лицензии на обучающие курсы,
6. ваучеры Amazon
7. и многое другое.

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

Поспешите, опрос заканчивается 4 августа. Пройти опрос ->

Как научиться программированию на Python удаленно

Обучение по Python-разработке можно пройти в онлайн-школе. Это удобно:

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

Как проходит обучение в онлайн-школе:

• Вы смотрите лекции в режиме реального времени или в записи. Преподаватель на экране объясняет новую тему, отвечает на вопросы.
• После урока в личном кабинете появляется домашнее задание, которое нужно сделать за 4-7 дней. Это могут быть задачи на язык программирования Python, работа с тренажером и т. д.
• Готовую работу проверяет куратор. Вы узнаете, какие ошибки допустили, и получите рекомендации.
• На протяжении всего курса вы будете готовить дипломный проект, который добавите в портфолио.

Как выбрать онлайн-курс начинающему программисту

Выбирая курс Python-программирования для начинающих, обращайте внимание на следующие условия:

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

Для поиска онлайн-курсов мы рекомендуем пользоваться специальными агрегаторами. Например, УчисьОнлайн.ру — здесь самая большая подборка курсов разных школ, которые можно сравнить по цене, длительности, формату занятий. А также на сервисе есть отзывы учеников. Лучшие курсы по Python мы нашли именно там, расскажем о них ниже.

Лучшие курсы обучения Python-программированию с нуля

Мы составили ТОП курсов для тех, кто хочет изучить программирование на Python с нуля:

1. «Python-разработчик с нуля» от Нетологии. Вам покажут, как использовать Python для разных целей: от разработки сайтов до игр и приложений. Будет много практических уроков, на которых вы создадите 4 проекта для портфолио. После курса получите диплом о профессиональной переподготовке гос. образца.
2. «Онлайн-курс по Python» от Hedu. На курсе вы познакомитесь с основами Python и напишете собственное приложение. Программа разработана специально для новичков: после каждого урока есть тест или домашнее задание с проверкой, на всех этапах обучения вас поддержит куратор. Школа выдает электронный сертификат, а при необходимости высылает оригинал по почте.
3. «Python для начинающих программистов» от OTUS. Изучите синтаксис языка программирования Python, узнаете, как создаются сайты на Django, научитесь использовать библиотеки NumPy и Pandas для анализа данных. После каждого вебинара — проверочный тест. Курс является подготовительным и предназначен для самостоятельного прохождения.

Учебные программы для продвинутых разработчиков

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

1. «Мидл Python-разработчик» от Яндекс.Практикум. Вы освоите технологии, которые используются в backend-разработке, научитесь решать сложные задачи с базами данных, работать с фреймворками, получите опыт командной работы. Отработаете навыки на онлайн-тренажере, создадите несколько крупных проектов для портфолио, по которым профессиональный разработчик сделает код-ревью. Доступ к вводному блоку тем — бесплатно.
2. «Python-разработчик PRO» от Geekbrains. Практический курс по программированию, на котором освоите фреймворк Django, создадите приложение с сервером, потренируетесь работать в команде. В конце обучения сможете пройти стажировку и получите опыт работы на проекте, который приближен к реальным условиям. По окончании онлайн-курса вам выдадут удостоверение о повышении квалификации гос. образца.
3. «Python Developer. Professional» от OTUS. Вы на практике освоите технологии разработки высоконагруженных веб-приложений, систем контроля качества и аналитических систем. После прохождения курса получите сертификат, а также сможете пройти собеседование у партнера онлайн-школы. Видеоуроки, презентации лекций и примеры кодов останутся у вас навсегда.

Дистанционное обучение Python-разработке с трудоустройством

Кроме вышеперечисленных курсов, помощь с трудоустройством предусмотрена и на следующих:

1. «Профессия Python-разработчик» от Skillbox. Вы с нуля изучите возможности Python и Django, сделаете несколько крупных проектов: сервис по доставке еды, интернет-магазин, сайт-задачник. В конце онлайн-курса у вас будет консультация с HR-менеджером, который поможет оформить резюме и портфолио, подготовит к собеседованию у партнеров. На защите дипломов будут присутствовать реальные работодатели.
2. «Python-разработчик» от Яндекс.Практикум. Вы изучите язык Python и основные инструменты бэкенд-разработчика: Django, SQL, GITHub. В процессе обучения создадите несколько приложений: соцсеть, бот-ассистент и др. За 2 месяца до конца курса вы подготовите резюме и портфолио, начнете проходить собеседования.
3. «Факультет Python-разработки» от Geekbrains. На курсе вы освоите web-разработку, научитесь писать веб-приложения и самостоятельно создадите интернет-магазин, сетевой чат, базу данных, веб-сайт и другие программы. Вместе с HR-консультантом составите резюме и откликнитесь на вакансии партнеров школы. Гарантия трудоустройства указана в договоре: если не сможете найти работу после курса – вам вернут деньги.

Где найти бесплатные онлайн-уроки по Python

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

• «Python-разработка для начинающих» от Нетологии. После регистрации на сайте школы вам предоставят доступ к шести вебинарам. Вы изучите основы разработки на Python, самостоятельно сделаете 2 программы, а также получите подборку полезных статей, инструментов и чек-листов.
• «Python для непрограммистов» от Skillfactory. Игровой онлайн-тренажер поможет сделать первые шаги в программировании. Вы выполните несколько простых упражнений и напишете первый код. 

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

Условия

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

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

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

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

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

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

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

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

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

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

Введение в Docker

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

Установка Docker

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

• Для Windows
• Linux
• и Mac

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

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

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

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

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

cd django-docker && code .

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

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

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

Django==3.1.2

Что такое Dockerfile

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

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

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

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

Создание Dockerfile

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

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

Файл Docker Compose

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

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

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

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

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

version: '3.8'

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

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

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

Выводы

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

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

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

Если вам просто нужно найти количество конкретных элементов с списке, используйте метод .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 с помощью условия или критериев для фильтрации данных.

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

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

Алгоритм Random Forest

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

from sklearn import datasets

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

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

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

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

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

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

import pandas as pd

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

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

from sklearn.model_selection import train_test_split

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

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

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

from sklearn.ensemble import RandomForestClassifier

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

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

from sklearn.ensemble import RandomForestClassifier

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

Accuracy: 0.9333333333333333

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

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

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

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

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

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

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

from sklearn.ensemble import RandomForestClassifier
import pandas as pd

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

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

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

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

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

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

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

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

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

from sklearn.model_selection import train_test_split

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

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

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

from sklearn.ensemble import RandomForestClassifier

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

y_pred = clf.predict(X_test)

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

Accuracy: 0.9619047619047619

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

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

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

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

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

Заключение

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

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

Почему крупные компании выбирают Django?

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

• Инструменты для управления аутентификацией пользователя (создание аккаунта, логин и так далее).
• Панель управления своим аккаунтом.
• Загрузка и скачивание файлов и так далее.

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

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

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

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

1. YouTube

Крупнейший видеохостинг — это часть компании Google, которая использует Python и Django во множестве своих проектов. YouTube — не исключение, ведь вся платформа написана с использованием этого фреймворка.

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

2. Поиск Google

Google использует Python во множестве своих продуктов. Компания всегда видела потенциал этого языка и пыталась задействовать его как можно чаще. Так, Python в целом и Django в частности используются для главного проекта компании — поиска Google.

3. Dropbox

Один из крупнейших в мире сайтов для хранения данных, Dropbox, создал новый способ хранения данных — в облаке. Благодаря нему пользователи имеют возможность получать доступ к файлам из любого места (только находясь онлайн, конечно). Dropbox подходит для хранения документов, видео, изображений и других данных. И все это благодаря возможностям Python.

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

4. Instagram

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

Изначально Python был ядром технологического стека приложения. Команда использовала несколько версий языка и в конце остановилась на Python 3.5.

Instagram обрабатывает большие объемы данных и взаимодействий пользователей. Использование Django упрощает это все и позволяет сосредоточиться на UI и UX.

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

Instagram начал быстро расти и компания искала новые технологии, чтобы задействовать их, но в итоге они приняли решение остаться с Python и Django.

Бывший глава разработки рассказал:

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

Более того Instagram использует Sentry для мониторинга и составления отчетов о багах. И все это происходит в реальном времени.

5. Reddit

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

6. Pinterest

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

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

7. Quora

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

8. Yahoo Maps

В основном, Yahoo использует для своих проектов Node.js. Но для создания карт они решили использовать Python. Yahoo Maps — стандартное решение, которое позволяет проложить маршрут из точки A в точку B. Этот поисковый движок не так популярен в восточных странных, но пользуется популярностью на западе. Он считается надежным, поэтому его часто используют в повседневных поездках.

9. Spotify

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

Как и iTunes, Spotify изменил то, как люди слушают музыку и делятся ею. С помощью Spotify получить доступ к своей медиатеке можно с любого устройства. Разработчики выбрали Django по двум причинам:

• Быстрый бэкенд
• Возможности для машинного обучения

Они не только используют возможности Python, но и создают новые. В Spotify также используют Java и C++, но последний — все меньше и меньше.

10. The Onion

The Onion — еще один пример отличного сервиса, созданного с помощью Django. Это сатирическое издание, у которого есть онлайн-версия. Публикации, дизайн и все функции созданы с помощью Django и Python.

Сегодня это одна из самых известных и читаемых газет в мире.

11. Disqus

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

Использование Disqus не только позволило команде быстрее создать сайт, но также стремительно масштабировать его. Сегодня разработчики используют и другие фреймворки, но Django остается выбором №1 благодаря отличному сообществу и готовым компонентам.

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

12. Washington Post

Изначально Django был создан для поддержки контентного приложения для Lawrence Journal-World, The Washington Post, The Guardian, The New York Post и других сайтов новостных изданий. Django работает быстро и отлично масштабируется, что позволяет обрабатывать запросы аудитории любого масштаба.

13. Bitbucket

Облачный Git-репозиторий привлек миллионы разработчиков в 2008 году. С 17 миллионами запросов и 6 млн репозиториев в год это одно из крупнейших веб-приложений на Django.

Команда Bitbucket выбрала Django по нескольким причинам: тысячи разработчиков в сообществе и готовые решение.

14. Eventbrite

Eventbrite — популярная платформа для управления и продажи билетов на мероприятия. Изначально она была создана на чистом Python, но позже разработчики переключились на Django, чтобы справляться с ростом аудитории и объемом взаимодействия между ними.

15. Mozilla

Один из популярнейших браузеров, Mozilla, должен обрабатывать миллионы запросов каждый месяц. Учитывая это количество, нет ничего удивительного, что команда решила перейти с PHP + CakePHP на Python + Django. Сайт поддержки и дополнений Mozilla сегодня работают с помощью Django.

Почему веб-разработка на Django?

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

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

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

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

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

Где асинхронность применяется в реальном мире?

Асинхронность больше всего подходит для таких сценариев:

1. Программа выполняется слишком долго.
2. Причина задержки — не вычисления, а ожидания ввода или вывода.
3. Задачи, которые включают несколько одновременных операций ввода и вывода.

Это могут быть:

• Парсеры,
• Сетевые сервисы.

Разница в понятиях параллелизма, concurrency, поточности и асинхронности

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

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

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

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

Составляющие асинхронного программирования

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

Сопрограммы

Сопрограммы (coroutine) — это обобщенные формы подпрограмм. Они используются для кооперативных задач и ведут себя как генераторы Python.

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

Для запуска сопрограммы нужно запланировать его в цикле событий. После этого такие сопрограммы оборачиваются в задачи (Tasks) как объекты Future.

Пример сопрограммы

В коде ниже функция async_func вызывается из основной функции. Нужно добавить ключевое слово await при вызове синхронной функции. Функция async_func не будет делать ничего без await.

import asyncio


async def async_func():
    print('Запуск ...')
    await asyncio.sleep(1)
    print('... Готово!')


async def main():
    async_func()  # этот код ничего не вернет 
    await async_func()


asyncio.run(main())

Вывод:

Warning (from warnings module):
  File "\AppData\Local\Programs\Python\Python38\main.py", line 8
    async_func() # этот код ничего не вернет
RuntimeWarning: coroutine 'async_func' was never awaited
Запуск ...
... Готово!

Задачи (tasks)

Задачи используются для планирования параллельного выполнения сопрограмм.

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

Пример задачи

В коде ниже создается create_task (встроенная функция библиотеки asyncio), после чего она запускается.

import asyncio


async def async_func():
    print('Запуск ...')
    await asyncio.sleep(1)
    print('... Готово!')


async def main():
    task = asyncio.create_task (async_func())
    await task

asyncio.run(main())

Вывод:

Запуск ...
... Готово!

Циклы событий

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

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

Пример цикла событий

Дальше создаются три задачи, которые добавляются в список. Они выполняются асинхронно с помощью get_event_loop, create_task и await библиотеки asyncio.

import asyncio


async def async_func(task_no):
    print(f'{task_no}: Запуск ...')
    await asyncio.sleep(1)
    print(f'{task_no}: ... Готово!')


async def main():
    taskA = loop.create_task (async_func('taskA'))
    taskB = loop.create_task(async_func('taskB'))
    taskC = loop.create_task(async_func('taskC'))
    await asyncio.wait([taskA,taskB,taskC])


if __name__ == "__main__":
    try:
        loop = asyncio.get_event_loop()
        loop.run_until_complete(main())
    except :
        pass

Вывод:

taskA: Запуск ...
taskB: Запуск ...
taskC: Запуск ...
taskA: ... Готово!
taskB: ... Готово!
taskC: ... Готово!

Future

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

Если этот объект подождать (await), то сопрограмма дождется, пока Future не будет выполнен в другом месте.

В следующих разделах посмотрим, на то, как Future используется.

Сравнение многопоточности и асинхронности

Прежде чем переходить к асинхронности попробуем проверить многопоточность на производительность и сравним результаты. Для этого теста будем получать данные по URL с разной частотой: 1, 10, 50, 100 и 500 раз соответственно. После этого сравним производительность обоих подходов.

Реализация

Многопоточность:

import requests
import time
from concurrent.futures import ProcessPoolExecutor


def fetch_url_data(pg_url):
    try:
        resp = requests.get(pg_url)
    except Exception as e:
        print(f"Возникла ошибка при получении данных из url: {pg_url}")
    else:
        return resp.content
        

def get_all_url_data(url_list):
    with ProcessPoolExecutor() as executor:
        resp = executor.map(fetch_url_data, url_list)
    return resp
    

if __name__=='__main__':
    url = "https://www.uefa.com/uefaeuro-2020/"
    for ntimes in [1,10,50,100,500]:
        start_time = time.time()
        responses = get_all_url_data([url] * ntimes)
        print(f'Получено {ntimes} результатов запроса за {time.time() - start_time} секунд')

Вывод:

Получено 1 результатов запроса за 0.9133939743041992 секунд
Получено 10 результатов запроса за 1.7160518169403076 секунд
Получено 50 результатов запроса за 3.842841625213623 секунд
Получено 100 результатов запроса за 7.662721633911133 секунд
Получено 500 результатов запроса за 32.575703620910645 секунд

ProcessPoolExecutor — это пакет Python, который реализовывает интерфейс Executor. fetch_url_data — функция для получения данных по URL с помощью библиотеки request. После получения get_all_url_data используется, чтобы замапить function_url_data на список URL.

Асинхронность:

import asyncio
import time
from aiohttp import ClientSession, ClientResponseError


async def fetch_url_data(session, url):
    try:
        async with session.get(url, timeout=60) as response:
            resp = await response.read()
    except Exception as e:
        print(e)
    else:
        return resp
    return


async def fetch_async(loop, r):
    url = "https://www.uefa.com/uefaeuro-2020/"
    tasks = []
    async with ClientSession() as session:
        for i in range(r):
            task = asyncio.ensure_future(fetch_url_data(session, url))
            tasks.append(task)
        responses = await asyncio.gather(*tasks)
    return responses


if __name__ == '__main__':
    for ntimes in [1, 10, 50, 100, 500]:
        start_time = time.time()
        loop = asyncio.get_event_loop()
        future = asyncio.ensure_future(fetch_async(loop, ntimes))
        # будет выполняться до тех пор, пока не завершится или не возникнет ошибка
        loop.run_until_complete(future)
        responses = future.result()
        print(f'Получено {ntimes} результатов запроса за {time.time() - start_time} секунд')

Вывод:

Получено 1 результатов запроса за 0.41477298736572266 секунд
Получено 10 результатов запроса за 0.46897053718566895 секунд
Получено 50 результатов запроса за 2.3057644367218018 секунд
Получено 100 результатов запроса за 4.6860511302948 секунд
Получено 500 результатов запроса за 18.013994455337524 секунд

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

Функция fetch_async используется для добавления задачи в объект цикла событий, а fetch_url_data — для чтения данных URL с помощью пакета session. Метод future_result возвращает ответ всех задач.

Результаты

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

Выводы

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

%matplotlib inline

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

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

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

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

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

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

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

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

raw_data.columns

Получаем:

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

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

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

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

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

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

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

from sklearn.preprocessing import StandardScaler

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

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

scaler = StandardScaler()

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

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

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

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

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

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

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

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

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

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

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

from sklearn.model_selection import train_test_split

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

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

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

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

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

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

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

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

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

from sklearn.neighbors import KNeighborsClassifier

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

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

model = KNeighborsClassifier(n_neighbors = 1)

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

model.fit(x_training_data, y_training_data)

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

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

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

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

predictions = model.predict(x_test_data)

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

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

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

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

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

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

print(classification_report(y_test_data, predictions))

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

              precision    recall  f1-score   support

           0       0.92      0.91      0.91       148
           1       0.91      0.92      0.92       152

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

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

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

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

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

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

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

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

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

error_rates = []

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

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

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

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

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

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

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

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

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

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

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

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

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

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

from sklearn.datasets import make_blobs

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

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

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

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

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

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

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

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

%matplotlib inline

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

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

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

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

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

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

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

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

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

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

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

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

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

from sklearn.cluster import KMeans

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

model = KMeans(n_clusters=4)

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

model.fit(raw_data[0])

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

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

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

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

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

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

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

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

model.labels_

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

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

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

model.cluster_centers_

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Реальные приложения на Python

Python сильно поменялся с момента создания в 1991 году Гвино ван Россумом. Это динамический, интерпретируемый, высокоуровневый язык программирования, с помощью которого можно создать массу разнообразных приложений. У него плавная кривая обучения и понятный синтаксис.

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

1. Веб-разработка

Наверняка все разработчики знают, что такое веб-разработка. Это квинтэссенция применимости Python. Также этот язык выделяет широкое разнообразие фреймворков и систем управления контентом (CMS), которые упрощают жизнь разработчика. Среди самых популярных решений — Django, Flask, Pyramid и Bottle. Среди CMS выделяются Django CMS, Plone CMS и Wagtail.

Веб-разработка на Python дает такие преимущества, как повышенная безопасность, масштабируемость и удобство в процессе работы. Также язык из коробки поддерживает такие протоколы, как HTML, XML, email-протоколы, FTP. У Python одна из крупнейших коллекций библиотек, упрощающих и улучшающих жизнь разработчика.

Посмотреть список сайтов, которые использую python можно на https://trends.builtwith.com/framework/Python.

2. Разработка игр

По аналогии с веб-разработкой в Python есть масса инструментов и библиотек для разработки игр. Кстати, а вы знали, что на этом языке программирования была написала популярная некогда Battlefield 2?

Для разработки игр используются такие библиотеки, как PyGame, Pycap, Construct, Panda3D, PySoy и PyOpenGL.

Также с помощью Python были разработаны такие проекты, как Sims 4, World of Tanks, Civilization IV и EVE Online. Можно вспомнить еще Mount & Blade, Doki Doki Literature Club, Frets on Fire и Disney’s Toontown Online.

3. Искусственный интеллект и машинное обучение

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

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

Стабильность и безопасность языка сделали его идеальным для интенсивных вычислений, без которых AI и ML не обходятся. А широкая коллекция библиотек помогает при разработке моделей и алгоритмов. Вот самые популярные библиотеки:

• SciPy для научных и технических вычислений.
• Pandas для анализа данных и манипуляции ими.
• Keras для нейронных сетей.
• TensorFlow для машинного обучения, особенно для глубоких нейронных сетей.
• NumPy для сложных математических функций и вычислений.
• Scikit-Learn для работы с разными моделями машинного обучения.

4. Графический интерфейс для настольных приложений

Иногда можно обойтись и без полноценного интерфейса, но для большинства проектов сегодня важен GUI. И для них в Python тоже есть множество решений.

При этом доступный синтаксис и модульная структура позволяют создавать быстрые и отзывчивые интерфейсы, делая еще и сам процесс разработки приятным. Среди самых популярных библиотек и фреймоворков — PyQt, Tkinter, Python GTK+, wxWidgets и Kivy.

5. Обработка изображений

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

Среди самых популярных инструментов в Python можно выделить OpenCV, Scikit-Image, Python Imaging Library (PIL). Среди известных приложений, использующих Python — GIMP, Corel PaintShop, Blender и Houdini.

6. Обработка текста

Обработка текста — чуть ли не самый распространенный сценарий использования Python. Она руку идет с NLP (обработкой естественного языка), но не будем погружаться в эту тему сейчас. Обработка текста позволяет обрабатывать большие объемы текста, предоставляя гибкость структуры. Можно запросто сортировать строки, извлекать определенный текст, форматировать абзацы и так далее.

7. Бизнес приложения

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

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

Например, с помощью Python созданы Odoo и Tryton.

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

8. Образовательные и тренировочные программы

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

Есть масса обучающих ресурсов для получения начальных знаний по Python, но среди самых популярных можно выделить Coursera, edX, Udemy, Python Institute и Harvard.

9. Аудио и видео приложения

Эффективность Python позволяет использовать его для аудио и видео приложений. Для этого есть масса инструментов и библиотек. Сигнальная обработка, управление аудио, распознавание звуков — все это доступно с помощью таких библиотек, как Pyo, pyAudioANalysis, Dejavu и других.

Для видео же есть Scikit-video, OpenCV и SciPy. С их помощью можно управлять видеороликами и готовить их к использованию в других приложениях. На Python написаны Spotify, Netflix и YouTube.

10. Парсинг

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

На Python есть такие библиотеки, как PythonRequest, BeautifulSoup, MechanicalSoup, Selenium и другие. Парсеры используются для отслеживания цены, аналитики, анализа в социальных медиа, проектах машинного обучения и в любых других проектах, где есть большие объемы данных.

11. Data Science и визуализация данных

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

В экосистеме Python есть такие решения, как TensorFlow, PyTorch, Pandas, Scikit-Learn, NumPy, SciPy и многие другие.

Визуализация важна, когда данные нужно преподнести команде или держателям акций. Для этого в Python есть Plotly, Matplotlib, Seaborn, Ggplot, Geoplotlib и другие.

12. Научные и математические приложения

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

Стоит отметить такие инструменты, как Pandas, IPython, SciPy, Numeric Python, Matplotlib и другие. С помощью Python созданы такие приложения, как FreeCAD и Abaqus.

13. Разработка программного обеспечения

Python подходит не только для веб-разработки, научной разработки, создания игр или встраиваемых систем. По большому счету, это универсальное решение для софта любого типа. Все это возможно благодаря тому, что Python обеспечивает высокую скорость исполнения, хорошую совместимость, отличную поддержку со стороны сообщества, а также огромное количество библиотек. С помощью Python были созданы Roundup, Buildbot, SCons, Mercurial, Orbiter и Allura.

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

14. Операционные системы

Операционные системы — мозг любого компьютера. На Python, например, работают ОС, построенные на базе Linux. Как минимум, отдельные части таких систем.

В качестве примеров можно вспомнить Ubiquity Installer от Ubuntu, Anaconda Installer от Red Hat Enterprise. Также язык использовался для создания Gentoo Linux и системы управления пакетами Portage в Google Chrome OS. Вообще комбинация Python и C дает огромные преимущества при проектировании и разработке операционных систем.

15. CAD-приложения

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

В среде Python из таких приложений есть FreeCAD, Fandango, PythonCAD, Blender и Vintech RCAM. Они предоставляют такие функции, как макрозапись, верстаки, симуляция роботов, скетчинг, поддержка мультиформатного импорта/экспорта, модули технического чертежа и многое другое.

16. Встроенные приложения

Одна из самых впечатляющих возможностей Python — работа на встроенном железе. Это такие устройства, которые предназначены для выполнения ограниченного набора действий. Встроенный софт — это тот, который отвечает за работу таких устройств. Среди самых популярных приложений MicroPython, Zerynth, PyMite и EmbeddedPython.

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

Другие приложение на Python

• Консольные приложения
• Компьютерное зрение
• Робототехника
• Разработка языков
• Автоматическое тестирование
• Автоматизация
• Анализа данных

Вывод

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

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

В этом материале разберем особенности его использования.

Что делает split в Python?

Функция split сканирует всю строку и разделяет ее в случае нахождения разделителя.
В строке должен быть как минимум один разделитель. Им может выступать в том
числе и символ пробела. Пробел — разделитель по умолчанию.

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

Синтаксис функции следующий:

string.split(separator*, maxsplit*)

Параметр separator — необязательный, но он позволяет задать разделитель
вручную.

Параметр maxsplit определяет максимальное количество разделений. Значение по
умолчанию — -1, будут выполнены все разделения.

Как разделить строку в Python

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

my_st = "Пример строки Python"
print(my_st.split())

В примере выше была объявлена строка my_st. Она помещена в одинарные кавычки. Функция .split() разделяет ее на список таких строк:

['Пример', 'строки', 'Python']

Вывод содержит список подстрок.

Еще один пример разбиения строки:

my_st = "синий,оранжевый,красный"
print(my_st.split(","))

В приведенном выше примере мы создали строку my_st с 3 подстроками. В этом случае именно запятая выступит параметром разделения в функции. Вывод будет следующий:

['синий', 'оранжевый', 'красный']

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

Разделение сроки по пробелу

Если не передать параметр разделителя, то .split() выполнит разделение по пробелу.

my_st = "Пример строки Python"
print(my_st.split())

Код вернет: ['Пример', 'строки', 'Python'].

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

Разделение строки по запятой

Разделителем может выступать запятая (","). Это вернет список строк, которые
изначально были окружены запятыми.

my_st = "Например, строка Python"
print(my_st.split(","))

Вывод: ['Например', ' строка Python']. Результатом является список подстрок, разделенных по запятым в исходной строке.

Разделение строк по нескольким разделителям

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

Возьмем в качестве примера ситуацию, где разделителями выступают одновременно : и ,. Задействуем функцию re.split().

import re

my_st = "Я\nучу; язык,программирования\nPython"
print(re.split(";|,|\n", my_st))

Вывод:

['Я', 'учу', ' язык', 'программирования', 'Python']

Здесь мы используем модуль re и функции регулярных выражений. Переменной my_st была присвоена строка с несколькими разделителями, включая «\n», «;» и «,». А функция re.split() вызывается для этой строки с перечисленными выше разделителями.

Вывод — список подстрок, разделенных на основе оригинальной строки.

Как работает параметр maxsplit в функции split?

Этот параметр помогает задать максимальное число разделений. Разделить стоку можно, передав значение этого параметра. Например, если разделителем выступает символ пробела, а значение maxsplit — 1,
то строка будет разделена максимум на 2 подстроки.

languages = "Python,Java,Perl,PHP,Swift"

print(languages.split(",",1))

В строке languages хранится строка с перечислением разных языков. Функция split принимает запятую в качестве разделителя и значение 1 для параметра maxsplit. Это значит, что разделение будет выполнено только один раз.

['Python', 'Java,Perl,PHP,Swift']

Следующий пример показывает, как выполнить разделение два раза. Здесь разделителем выступает пробел, а значение maxplit равно 2.

languages = "Python,Java,Perl,PHP,Swift"

print(languages.split(",",2))

['Python', 'Java', 'Perl,PHP,Swift']

Как разделить строку посередине

Функция .split() не может разбить строку на две равных части.
Однако для этого можно использовать срезы (оператор :) и функцию len().

languages = "Python,Java,Perl,PHP,Swift"
mean_index = len(languages) // 2

print(f"Первая половина: {languages[:mean_index]}")
print(f"Вторая половина: {languages[mean_index:]}")

Вывод:

Первая половина: Python,Java,P
Вторая половина: erl,PHP,Swift

Значение languages было разбито на две равных части. Для работы был использован оператор целочисленного деления.

Вывод

Вот что вы узнали:

• Функция split разбивает строку на подстроки по разделителю.
• Параметр maxsplit позволяет указать максимально количество разделений.
• Если разделитель не задать, то по умолчанию будет выбрано значение пробела.
• Срезы используются для деления строк на равные части.

Прочитав статью, вы узнаете как:

• Использовать функцию run для запуска внешнего процесса.
• Получить стандартный вывод процесса и информацию об ошибках.
• Проверить код возврата процесса и вызвать исключение в случае сбоя.
• Запустить процесс, используя оболочку в качестве посредника.
• Установить время ожидания завершения процесса.
• Использовать класс Popen напрямую для создания конвейера (pipe) между двумя процессами.

Так как модуль subprocess почти всегда используют с Linux все примеры будут касаться Ubuntu. Для пользователей Windows советую скачать терминал Ubuntu 18.04 LTS.

Функция «run»

Функция run была добавлена в модуль subprocess только в относительно последних версиях Python (3.5). Теперь ее использование является рекомендуемым способом создания процессов и должно решать наиболее распространенные задачи. Прежде всего, давайте посмотрим на простейший случай применения функции run.

Предположим, мы хотим запустить команду ls -al; для этого в оболочке Python нам нужно ввести следующие инструкции:

>>> import subprocess
>>> process = subprocess.run(['ls', '-l', '-a'])

Вывод внешней команды ls отображается на экране:

total 12
drwxr-xr-x 1 cnc  cnc  4096 Apr 27 16:21 .
drwxr-xr-x 1 root root 4096 Apr 27 15:40 ..
-rw------- 1 cnc  cnc  2445 May  6 17:43 .bash_history
-rw-r--r-- 1 cnc  cnc  220  Apr 27 15:40 .bash_logout
-rw-r--r-- 1 cnc  cnc  3771 Apr 27 15:40 .bashrc

Здесь мы просто использовали первый обязательный аргумент функции run, который может быть последовательностью, «описывающей» команду и ее аргументы (как в примере), или строкой, которая должна использоваться при запуске с аргументом shell=True (мы рассмотрим последний случай позже).

Захват вывода команды: stdout и stderr

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

>>> process = subprocess.run(['ls', '-l', '-a'], capture_output=True)

Как мы можем впоследствии получить вывод (stdout и stderr) процесса? Если вы посмотрите на приведенные выше примеры, то увидите, что мы использовали переменную process для ссылки на объект CompletedProcess, возвращаемый функцией run. Этот объект представляет процесс, запущенный функцией, и имеет много полезных свойств. Помимо прочих, stdout и stderr используются для «хранения» соответствующих дескрипторов команды, если, как уже было сказано, для аргумента capture_output установлено значение True. В этом случае, чтобы получить stdout, мы должны использовать:

>>> process = subprocess.run(['ls', '-l', '-a'], capture_output=True)
>>> process.stdout
b'total 12\ndrwxr-xr-x 1 cnc  cnc  4096 Apr 27 16:21 .\ndrwxr-xr-x 1 root root 4096 Apr 27 15:40 ..\n-rw------- 1 cnc  cnc  2445 May  6 17:43 .bash_history\n-rw-r--r-- 1 cnc  cnc  220 Apr 27 15:40 .bash_logout...

По умолчанию stdout и stderr представляют собой последовательности байтов. Если мы хотим, чтобы они хранились в виде строк, мы должны установить для аргумента text функции run значение True.

Управление сбоями процесса

Команда, которую мы запускали в предыдущих примерах, была выполнена без ошибок. Однако при написании программы следует принимать во внимание все случаи. Так, что случится, если порожденный процесс даст сбой? По умолчанию ничего «особенного» не происходит. Давайте посмотрим на примере: мы снова запускаем команду ls, пытаясь вывести список содержимого каталога /root, который не доступен для чтения обычным пользователям:

>>> process = subprocess.run(['ls', '-l', '-a', '/root'])

Мы можем узнать, не завершился ли запущенный процесс ошибкой, проверив его код возврата, который хранится в свойстве returncode объекта CompletedProcess:

>>> process.returncode
2

Видите? В этом случае returncode равен 2, подтверждая, что процесс столкнулся с ошибкой, связанной с недостаточными правами доступа, и не был успешно завершен. Мы могли бы проверять выходные данные процесса таким образом чтобы при возникновении сбоя возникало исключение. Используйте аргумент check функции run: если для него установлено значение True, то в случае, когда внешний процесс завершается ошибкой, возникает исключение CalledProcessError:

>>> process = subprocess.run(['ls', '-l', '-a', '/root'])
ls: cannot open directory '/root': Permission denied

Обработка исключений в Python довольно проста. Поэтому для управления сбоями процесса мы могли бы написать что-то вроде:

>>> try:
...     process = subprocess.run(['ls', '-l', '-a', '/root'], check=True)
... except subprocess.CalledProcessError as e:
...     print(f"Ошибка команды {e.cmd}!")
...
ls: cannot open directory '/root': Permission denied
['ls', '-l', '-a', '/root'] failed!
>>>

Исключение CalledProcessError, как мы уже сказали, возникает, когда код возврата процесса не является 0. У данного объекта есть такие свойства, как returncode, cmd, stdout, stderr; то, что они представляют, довольно очевидно. Например, в приведенном выше примере мы просто использовали свойство cmd, чтобы отобразить последовательность, которая использовалась для запуска команды при возникновении исключения.

Выполнение процесса в оболочке

Процессы, запущенные с помощью функции run, выполняются «напрямую», это означает, что для их запуска не используется оболочка: поэтому для процесса не доступны никакие переменные среды и не выполняются раскрытие и подстановка выражений. Давайте посмотрим на пример, который включает использование переменной $HOME:

>>> process = subprocess.run(['ls', '-al', '$HOME'])
ls: cannot access '$HOME': No such file or directory

Как видите, переменная $HOME не была заменена на соответствующее значение. Такой способ выполнения процессов является рекомендованным, так как позволяет избежать потенциальные угрозы безопасности. Однако, в некоторых случаях, когда нам нужно вызвать оболочку в качестве промежуточного процесса, достаточно установить для параметра shell функции run значение True. В таких случаях желательно указать команду и ее аргументы в виде строки:

>>> process = subprocess.run('ls -al $HOME', shell=True)
total 12
drwxr-xr-x 1 cnc  cnc  4096 Apr 27 16:21 .
drwxr-xr-x 1 root root 4096 Apr 27 15:40 ..
-rw------- 1 cnc  cnc  2445 May  6 17:43 .bash_history
-rw-r--r-- 1 cnc  cnc  220  Apr 27 15:40 .bash_logout
...

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

Ограничение времени работы процесса

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

>>> process = subprocess.run(['ping', 'google.com'], timeout=5)
PING google.com (216.58.208.206) 56(84) bytes of data.
64 bytes from par10s21-in-f206.1e100.net (216.58.208.206): icmp_seq=1 ttl=118 time=15.8 ms
64 bytes from par10s21-in-f206.1e100.net (216.58.208.206): icmp_seq=2 ttl=118 time=15.7 ms
64 bytes from par10s21-in-f206.1e100.net (216.58.208.206): icmp_seq=3 ttl=118 time=19.3 ms
64 bytes from par10s21-in-f206.1e100.net (216.58.208.206): icmp_seq=4 ttl=118 time=15.6 ms
64 bytes from par10s21-in-f206.1e100.net (216.58.208.206): icmp_seq=5 ttl=118 time=17.0 ms
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/lib/python3.8/subprocess.py", line 495, in run
    stdout, stderr = process.communicate(input, timeout=timeout)
  File "/usr/lib/python3.8/subprocess.py", line 1028, in communicate
    stdout, stderr = self._communicate(input, endtime, timeout)
  File "/usr/lib/python3.8/subprocess.py", line 1894, in _communicate
    self.wait(timeout=self._remaining_time(endtime))
  File "/usr/lib/python3.8/subprocess.py", line 1083, in wait
    return self._wait(timeout=timeout)
  File "/usr/lib/python3.8/subprocess.py", line 1798, in _wait
    raise TimeoutExpired(self.args, timeout)
subprocess.TimeoutExpired: Command '['ping', 'google.com']' timed out after 4.999637200000052 seconds

В приведенном выше примере мы запустили команду ping без указания фиксированного числа пакетов ECHO REQUEST, поэтому она потенциально может работать вечно. Мы также установили время ожидания в 5 секунд с помощью параметра timeout. Как мы видим, ping была запущена, а по истечении 5 секунд возникло исключение TimeoutExpired и процесс был остановлен.

Функции call, check_output и check_call

Как мы уже говорили ранее, функция run является рекомендуемым способом запуска внешнего процесса. Она должна использоваться в большинстве случаев. До того, как она была представлена в Python 3.5, тремя основными функциями API высокого уровня, применяемыми для создания процессов, были call, check_output и check_call; давайте взглянем на них вкратце.

Прежде всего, функция call: она используется для выполнения команды, описанной параметром args; она ожидает завершения команды; ее результатом является соответствующий код возврата. Это примерно соответствует базовому использованию функции run.

Поведение функции check_call практически не отличается от run, когда для параметра check задано значение True: она запускает указанную команду и ожидает ее завершения. Если код возврата не равен 0, возникает исключение CalledProcessError.

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

Работа на более низком уровне с классом Popen

До сих пор мы изучали функции API высокого уровня в модуле subprocess, особенно run. Все они под капотом используют класс Popen. Из-за этого в подавляющем большинстве случаев нам не нужно взаимодействовать с ним напрямую. Однако, когда требуется большая гибкость, без создания объектов Popen не обойтись.

Предположим, например, что мы хотим соединить два процесса, воссоздав поведение конвейера (pipe) оболочки. Как мы знаем, когда передаем две команды в оболочку, стандартный вывод той, что находится слева от пайпа «|», используется как стандартный ввод той, которая находится справа. В приведенном ниже примере результат выполнения двух связанных конвейером команд сохраняется в переменной:

$ output="$(dmesg | grep sda)"

Чтобы воссоздать подобное поведение с помощью модуля subprocess без установки параметра shell в значение True, как мы видели ранее, мы должны напрямую использовать класс Popen:

dmesg = subprocess.Popen(['dmesg'], stdout=subprocess.PIPE)
grep = subprocess.Popen(['grep', 'sda'], stdin=dmesg.stdout)
dmesg.stdout.close()
output = grep.comunicate()[0]

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

Первое, что мы сделали в приведенном выше фрагменте кода, — это создали объект Popen, представляющий процесс dmesg. Мы установили stdout этого процесса на subprocess.PIPE. Данное значение указывает, что пайп к указанному потоку должен быть открыт.

Затем мы создали еще один экземпляр класса Popen для процесса grep. В конструкторе Popen мы, конечно, указали команду и ее аргументы, но вот что важно, мы установили стандартный вывод процесса dmesg в качестве стандартного ввода для grep (stdin=dmesg.stdout), чтобы воссоздать поведение конвейера оболочки.

После создания объекта Popen для команды grep мы закрыли поток stdout процесса dmesg, используя метод close(). Это, как указано в документации, необходимо для того, чтобы первый процесс мог получить сигнал SIGPIPE. Дело в том, что обычно, когда два процесса соединены конвейером, если один справа от «|» (grep в нашем примере) завершается раньше, чем тот, что слева (dmesg), то последний получает сигнал SIGPIPE (пайп закрыт) и по умолчанию тоже заканчивает свою работу.

Однако при репликации пайплайна между двумя командами в Python возникает проблема. stdout первого процесса открывается как в родительском скрипте, так и в стандартном вводе другого процесса. Таким образом, даже если процесс grep завершится, пайп останется открытым в вызывающем процессе (нашем скрипте), поэтому dmesg никогда не получит сигнал SIGPIPE. Вот почему нам нужно закрыть поток stdout первого процесса в нашем основном скрипте после запуска второго.

Последнее, что мы сделали, — это вызвали метод communicate() объекта grep. Этот метод можно использовать для необязательной передачи данных в stdin процесса. Он ожидает завершения процесса и возвращает кортеж. Где первый элемент — это stdout (на который ссылается переменная output), а второй — stderr процесса.

Заключение

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

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

Книги расскажут о фундаментальных концепциях контейнеров, оркестрации, OpenShift, непрерывного развертывания, cloud-native и т.д. Кроме того, я добавил несколько книг для людей, которые уже знакомы с Kubernetes и хотят попрактиковаться.

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

Если вы не знаете, что делает Kubernetes и как он работает, читайте статью Kubernetes для чайников, в ней подробно описаны принципы работы.

Лучшие книги по Kubernetes

Kubernetes в действии, второе издание — 2019

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

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

Kubernetes. Лучшие практики. Построение эффективных приложений — 2021

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

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

Kubernetes для DevOps: развертывание, запуск и масштабирование в облаке — 2020

Kubernetes, без сомнения, является отличным изобретением для «облачного мира». Авторы этой книги Джон Арундел и Джастин Домингус — настоящие эксперты по облачным технологиям. Они расскажут вам обо всех тонкостях экосистемы платформы.

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

Паттерны Kubernetes. Шаблоны разработки собственных облачных приложений — 2020

Микросервисы и контейнеры значительно изменили способ создания и развертывания программных приложений. В этой книге Билджин Ибрам и Роланд Хасс, работающие в компании Red Hat, расскажут вам об общих методах разработки и внедрения облачных нативных приложений на платформе. Они предоставят вам популярные элементы, паттерны и принципы, которые повысят вашу производительность при создании реальных приложений.

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

Книга посвящена следующим категориям паттернов:

• Основополагающие паттерны
• Поведенческие паттерны
• Структурные паттерны
• Конфигурационные паттерны
• Продвинутые шаблоны

Введение в технологии контейнеров и Kubernetes — 2019

Главная особенность этой книги — знакомство с возможностями дистрибутива OpenShift (OKD) от Red Hat. Это один из самых популярных дистрибутивов Kubernetes. Вместе с ним рассматриваются механизмы работы контейнеров в Linux, основы работы с помощью Docker и Podman, а также сама система оркестрации контейнеров.

Книга подходит тем, кто уже знаком с GNU/Linux и хочет повысить уровень знаний контейнерных технологий и этой системы оркестровки.

Будущее Kubernetes

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

Согласно отчету, опубликованному Cloud Native Computing Foundation (CNCF), контейнеры, используемые в производственной среде, выросли на 300% с 2016 года. Кроме того, использование платформы в производстве выросло до 83% по сравнению с 78% в прошлом году.

Kubernetes в основном используется компаниями корпоративного уровня, такими как Google, VMware, Deloitte и др. Доля рынка Kubernetes постоянно растет, это создает новые вакансии для инженеров DevOps.

Gensim может работать с большими текстовыми коллекциями. Этим она отличается от других программных библиотек машинного обучения, ориентированных на обработку в памяти. GenSim также предоставляет эффективные многоядерные реализации различных алгоритмов для увеличения скорости обработки. В нее добавлены более удобные средства для обработки текста, чем у конкурентов, таких как Scikit-learn, R и т. д.

В этом руководстве будут рассмотрены следующие концепции:

1. Создание корпуса из заданного датасета.
2. Матрицы TFIDF в Gensim.
3. Создание биграммы и триграммы с помощью Gensim.
4. Модели Word2Vec, с использованием Gensim.
5. Модели Doc2Vec, с использованием Gensim.
6. Создание тематической модели с LDA.
7. Создание тематической модели с LSI.

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

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

Например:

У вас есть документ, состоящий из таких слов, как:
bat, car, racquet, score, glass, drive, cup, keys, water, game, steering, liquid.

Их можно сгруппировать по разным темам:

Некоторые из методов тематического моделирования:

• Латентно-семантический анализ (LSI)
• Латентное размещение Дирихле (LDA)

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

pip install gensim
# или
conda install gensim

Шаг 1. Создайте корпус из заданного датасета

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

1. Загрузите выбранный датасет.
2. Проведите предварительную обработку вашего набора данных.
3. Создайте словарь.
4. Создайте Bag of Words.

1.1 Загрузите выбранный датасет:

У вас может быть файл .txt в качестве набора данных или вы также можете загрузить необходимые датасеты с помощью API Gensim Downloader.

import os

#  прочитать текстовый файл как объект
doc = open('sample_data.txt', encoding ='utf-8')

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

import gensim.downloader as api
  
# проверка имеющихся моделей и датасетов
info_datasets = api.info()
print(info_datasets)
  
# информация ы конкретном наборе данных
dataset_info = api.info("text8")
  
# загрузка набора данных "text8"
dataset = api.load("text8")
  
# загрузка предварительно обученной модели
word2vec_model = api.load('word2vec-google-news-300')

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

1.2 Предварительная обработка набора данных

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

import gensim
import os
from gensim.utils import simple_preprocess
  
#  прочитать текстовый файл как объект
doc = open('nlp-wiki.txt', encoding ='utf-8')
  
# предварительная обработка файла для получения списка токенов
tokenized = []
for sentence in doc.read().split('.'):
    # функция simple_preprocess возвращает список слов каждого предложения
    tokenized.append(simple_preprocess(sentence, deacc = True))
  
print(tokenized)
doc.close()

Токенизированный вывод:

[['the', 'history', 'of', 'natural', 'language', 'processing', 'generally', 'started', 'in', 'the', 'although', 'work', 'can', 'be', 'found', 'from', 'earlier', 'periods'], ['in', 'alan', 'turing', 'published', 'an', 'article', 'titled', 'intelligence', 'which', 'proposed', 'what', 'is', 'now', 'called', 'the', 'turing', 'test', 'as', 'criterion', 'of', 'intelligence'], ['the', 'georgetown', 'experiment', 'in', 'involved', 'fully', 'automatic', 'translation', 'of', 'more', 'than', 'sixty', 'russian', 'sentences', 'into', 'english'], ['the', 'authors', 'claimed', 'that', 'within', 'three', 'or', 'five', 'years', 'machine', 'translation', 'would', 'be', 'solved', 'problem'],
...

1.3 Создание словаря

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

from gensim import corpora
#  сохранение извлеченных токенов в словарь
my_dictionary = corpora.Dictionary(tokenized)
print(my_dictionary)

Dictionary(410 unique tokens: ['although', 'be', 'can', 'earlier', 'found']...)

1.3.1 Сохранение словаря

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

# сохраните словарь на диске
my_dictionary.save('my_dictionary.dict')
  
# загрузите обратно
load_dict = corpora.Dictionary.load('my_dictionary.dict')
                                    
# сохраните словарь в текстовом файле
from gensim.test.utils import get_tmpfile
tmp_fname = get_tmpfile("dictionary")
my_dictionary.save_as_text(tmp_fname)
  
# загрузите текстовый файл с вашим словарем
load_dict = corpora.Dictionary.load_from_text(tmp_fname)

1.4 Создание Bag of Words

Когда у нас есть словарь, мы можем создать корпус Bag of Words с помощью функции doc2bow(). Эта функция подсчитывает число вхождений и генерирует целочисленный идентификатор для каждого слова. Результат возвращается в виде разреженного вектора.

# преобразование в слов Bag of Word
bow_corpus =[my_dictionary.doc2bow(doc, allow_update = True) for doc in tokenized]
print(bow_corpus)

[[(0, 1), (1, 1), (2, 1),
...
(407, 1), (408, 1), (409, 1)], []]

1.4.1 Сохранение корпуса на диск

Код для сохранения/загрузки вашего корпуса:

from gensim.corpora import MmCorpus
from gensim.test.utils import get_tmpfile
  
output_fname = get_tmpfile("BoW_corpus.mm")
  
# сохранение корпуса на диск
MmCorpus.serialize(output_fname, bow_corpus)
  
# загрузка корпуса
load_corpus = MmCorpus(output_fname)

Шаг 2: Создание матрицы TF-IDF в Gensim

TF-IDF (Term Frequency – Inverse Document Frequency) – это часто используемая модель обработки естественного языка, которая помогает вам определять самые важные слова для каждого документа в корпусе. Она была разработана для коллекций небольшого размера.

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

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

from gensim import models
import numpy as np
  
# Вес слова в корпусе Bag of Word
word_weight =[]
for doc in bow_corpus:
    for id, freq in doc:
        word_weight.append([my_dictionary[id], freq])
print(word_weight)

Вес слов перед применением TF-IDF:

[['although', 1], ['be', 1], ['can', 1], ['earlier', 1],
...
['steps', 1], ['term', 1], ['transformations', 1]]

Код (применение модели TF-IDF):

# создать модель TF-IDF
tfIdf = models.TfidfModel(bow_corpus, smartirs ='ntc')
  
# TF-IDF вес слова
weight_tfidf =[]
for doc in tfIdf[bow_corpus]:
    for id, freq in doc:
        weight_tfidf.append([my_dictionary[id], np.around(freq, decimals=3)])
print(weight_tfidf) 

Вес слов после применением TF-IDF:

[['although', 0.339], ['be', 0.19], ['can', 0.237], ['earlier', 0.339], 
...
['steps', 0.191], ['term', 0.191], ['transformations', 0.191]]

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

Шаг 3. Создание биграмм и триграмм с помощью Gensim

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

Например:
Beatboxing -> слова beat и boxing имеют собственные смысловые вариации, но вместе они представляют совсем иное значение.

Биграмма — группа из двух слов.
Триграмма — группа из трех слов.

Здесь мы будем использовать датасет text8, который можно загрузить с помощью API downloader Gensim. Код построения биграмм и триграмм:

import gensim.downloader as api
from gensim.models.phrases import Phrases
  
# загрузка набора данных "text8"
dataset = api.load("text8")
  
# извлечь список слов из датасета
data =[]
for word in dataset:
    data.append(word)
                
# Биграм с использованием модели фразера             
bigram_model = Phrases(data, min_count=3, threshold=10)
  
print(bigram_model[data[0]])

['anarchism', 'originated', 'as', 'a', 'term', 'of', 'abuse', 'first', 'used', 'against', 'early', 'working_class', 'radicals', 'including', 'the', 'diggers', 'of', 'the', 'english', 'revolution', 'and', 'the', 'sans_culottes', 'of', 'the', 'french_revolution', 'whilst', 'the', 'term', 'is', 'still' ...

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

# Триграмма с использованием модели фразы
trigram_model = Phrases(bigram_model[data], threshold=10)

# Триграмма
print(trigram_model[bigram_model[data[0]]])

['anarchism', 'originated', 'as', 'a', 'term', 'of', 'abuse', 'first', 'used', 'against', 'early' ...

Шаг 4: Создайте модель Word2Vec с помощью Gensim

Алгоритмы ML/DL не могут использовать текст напрямую, поэтому нам нужно некоторое числовое представление, чтобы эти алгоритмы могли обрабатывать данные. В простых приложениях машинного обучения используются CountVectorizer и TFIDF, которые не сохраняют связь между словами.

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

Пример: queen — women + man = king.

Готовые векторно-семантические модели, такие как word2vec, GloVe, fasttext и другие можно загрузить с помощью API загрузчика Gensim. Иногда векторные представления определенных слов из вашего документа могут отсутствовать в упомянутых пакетах. Но вы можете решить данную проблему, обучив свою модель.

4.1) Обучение модели

import gensim.downloader as api
from multiprocessing import cpu_count
from gensim.models.word2vec import Word2Vec
  
# загрузка набора данных "text8"
dataset = api.load("text8")
  
# извлечь список слов из датасета
data =[]
for word in dataset:
    data.append(word)

# Разделим данные на две части
data_1 = data[:1200]   # используется для обучения модели
data_2 = data[1200:]   # используется для обновления модели
  
# Обучение модели Word2Vec
w2v_model = Word2Vec(data_1, min_count=0, workers=cpu_count())
  
# вектор слов для слова "время"
print(w2v_model.wv['time'])

Вектор для слова «time»:

[-0.04681756 -0.08213229  1.0628034  -1.0186515   1.0779341  -0.89710116
  0.6538859  -0.81849015 -0.29984367  0.55887854  2.138567   -0.93843514
...
 -1.4128548  -1.3084044   0.94601256  0.27390406  0.6346426  -0.46116787
  0.91097695 -3.597664    0.6901859   1.0902803 ]

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

# слова, похожие на "time"
print(w2v_model.wv.most_similar('time'))

# сохранение и загрузка модели
w2v_model.save('Word2VecModel')
model = Word2Vec.load('Word2VecModel')

Cлова, наиболее похожие на «time»:

[('moment', 0.6137239933013916), ('period', 0.5904807448387146), ('stage', 0.5393826961517334), ('decade', 0.51670902967453), ('lifetime', 0.4878680109977722), ('once', 0.4843854010105133), ('distance', 0.4821343719959259), ('breteuil', 0.4815649390220642), ('preestablished', 0.47662678360939026), ('point', 0.4757876396179199)]

4.2) Обновление модели

# построим словарный запас по образцу из последовательности предложений
w2v_model.build_vocab(data_2, update=True)
  
# обучение вектора слов
w2v_model.train(data_2, total_examples=w2v_model.corpus_count, epochs=w2v_model.epochs)
  
print(w2v_model.wv['time'])

На выходе вы получите новые веса для слов.

Шаг 5: Создание модели Doc2Vec с помощью Gensim

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

Если натренировать модель на литературе типа «Алиса в Зазеркалье». Мы можем сказать, что
Алиса в Зазеркалье == Алиса в Стране чудес.

5.1) Обучите модель

import gensim
import gensim.downloader as api
from gensim.models import doc2vec
  
# получить датасета
dataset = api.load("text8")
data =[]
for w in dataset:
    data.append(w)

# Для обучения модели нам нужен список целевых документов
def tagged_document(list_of_ListOfWords):
    for x, ListOfWords in enumerate(list_of_ListOfWords):
        yield doc2vec.TaggedDocument(ListOfWords, [x])
    
# тренировочные данные
data_train = list(tagged_document(data))
    
# вывести обученный набор данных
print(data_train[:1])

Вывод – обученный датасет.

5.2) Обновите модель

# Инициализация модели
d2v_model = doc2vec.Doc2Vec(vector_size=40, min_count=2, epochs=30)
  
# расширить словарный запас
d2v_model.build_vocab(data_train)
  
# Обучение модели Doc2Vec
d2v_model.train(data_train, total_examples=d2v_model.corpus_count, epochs=d2v_model.epochs)
  
# Анализ выходных данных
analyze = d2v_model.infer_vector(['violent', 'means', 'to', 'destroy'])
print(analyze)

Вывод обновленной модели:

[-3.79053354e-02 -1.03341974e-01 -2.85615563e-01  1.37473553e-01
  1.79868549e-01  3.42468806e-02 -1.68495290e-02 -1.86038092e-01
 ...
 -1.20517321e-01 -1.48323074e-01 -5.70210926e-02 -2.15077385e-01]

Шаг 6. Создание тематической модели с помощью LDA

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

1. качества обработки текста,
2. нахождения оптимального количества тем,
3. настройки параметров алгоритма.

Выполните следующие шаги, чтобы создать модель.

6.1 Подготовка данных

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

pip install pattern

# в python консоле
>>> import nltk
>>> nltk.download('stopwords')

import gensim
from gensim import corpora
from gensim.models import LdaModel, LdaMulticore
import gensim.downloader as api
from gensim.utils import simple_preprocess
import nltk
from nltk.stem.wordnet import WordNetLemmatizer
# nltk.download('stopwords')
from nltk.corpus import stopwords
import re
import logging
  
logging.basicConfig(format='%(asctime)s : %(levelname)s : %(message)s')
logging.root.setLevel(level=logging.INFO)
  
# загрузка stopwords
stop_words = stopwords.words('english')
# добавление stopwords
stop_words = stop_words + ['subject', 'com', 'are', 'edu', 'would', 'could']
lemmatizer = WordNetLemmatizer()
# загрузка датасета
dataset = api.load("text8")
data = [w for w in dataset]
  
# подготовка данных
processed_data = []
for x, doc in enumerate(data[:100]):
    doc_out = []
    for word in doc:
        if word not in stop_words:  # для удаления стоп-слов
            lemmatized_word = lemmatizer.lemmatize(word)  # лемматизация
            if lemmatized_word:
                print
                doc_out.append(lemmatized_word)
        else:
            continue
    processed_data.append(doc_out) # processed_data это список слов

# вывод образца  
print(processed_data[0][:10]) 

['anarchism', 'originated', 'term', 'abuse', 'first', 'used', 'early', 'working', 'class', 'radical']

6.2 Создание словаря и корпуса

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

dictionary = corpora.Dictionary(processed_data)
corpus = [dictionary.doc2bow(l) for l in processed_data]

6.3 Обучение LDA-модели

Мы будем обучать модель LDA с 5 темами, используя словарь и корпус, созданные ранее. Здесь используется функция LdaModel(), но вы также можете использовать функцию LdaMulticore(), поскольку она позволяет выполнять параллельную обработку.

# Обучение
LDA_model = LdaModel(corpus=corpus, id2word=dictionary, num_topics=5)
# сохранение модели
LDA_model.save('LDA_model.model')
  
# показать темы
print(LDA_model.print_topics(-1))

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

6.4 Интерпретация вывода

Модель LDA в основном дает нам информацию по трем направлениям:

1. Темы в документе
2. К какой теме принадлежит каждое слово
3. Значение фи

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

# вероятность принадлежности слова к теме
LDA_model.get_term_topics('fire')
  
bow_list =['time', 'space', 'car']
# сначала преобразуйте в bag of words
bow = LDA_model.id2word.doc2bow(bow_list) 
  
# интерпретация данных
doc_topics, word_topics, phi_values = LDA_model.get_document_topics(bow, per_word_topics=True)

Шаг 7. Создание тематической модели с помощью LSI

Чтобы создать модель с LSI, просто выполните те же шаги, что и с LDA.
Только для обучения используйте функцию LsiModel() вместо LdaMulticore() или LdaModel().

from gensim.models import LsiModel

# Обучение модели с помощью LSI
LSI_model = LsiModel(corpus=corpus, id2word=dictionary, num_topics=7, decay=0.5)
  
# темы
print(LSI_model.print_topics(-1))

Заключение

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

При использовании SQLAlchemy ORM взаимодействие с базой данных происходит через объект Session. Он также захватывает соединение с базой данных и транзакции. Транзакция неявно стартует как только Session начинает общаться с базой данных и остается открытой до тех пор, пока Session не коммитится, откатывается или закрывается.

Для создания объекта session можно использовать класс Session из sqlalchemy.orm.

from sqlalchemy import create_engine
from sqlalchemy.orm import Session

engine = create_engine("postgresql+psycopg2://postgres:1111@localhost/sqlalchemy_tuts")
session = Session(bind=engine)

Создавать объект Session нужно будет каждый раз при взаимодействии с базой.

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

Чтобы упростить этот процесс, SQLAlchemy предоставляет класс sessionmaker, который создает класс Session с аргументами для конструктора по умолчанию.

from sqlalchemy.orm import Session, sessionmaker

session = sessionmaker(bind=engine)

Нужно просто вызвать sessionmaker один раз в глобальной области видимости.

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

session = Session()

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

Вставка(добавление) данных

Для создания новой записи с помощью SQLAlchemy ORM нужно выполнить следующие шаги:

1. Создать объект
2. Добавить его в сессию
3. Сохранить сессию

Создадим два новых объекта Customer:

c1 = Customer(
    first_name = 'Dmitriy',
    last_name = 'Yatsenko',
    username = 'Moseend',
    email = 'moseend@mail.com'
)

c2 = Customer(
    first_name = 'Valeriy',
    last_name = 'Golyshkin',
    username = 'Fortioneaks',
    email = 'fortioneaks@gmail.com'
)

print(c1.first_name, c2.last_name)

session.add(c1)
session.add(c2)

print(session.new)

session.commit()

Первый вывод: Dmitriy Golyshkin.

Два объекта созданы. Получить доступ к их атрибутам можно с помощью оператора точки (.).

Дальше в сессию добавляются объекты.

session.add(c1)
session.add(c2)

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

Значение атрибута id обоих объектов — None. Это значит, что они еще не сохранены в базе данных.

Вместо добавления одного объекта за раз можно использовать метод add_all(). Он принимает список объектов, которые будут добавлены в сессию.

session.add_all([c1, c2])

Добавление объекта в сессию несколько раз не приводит к ошибкам. В любой момент на имеющиеся объекты можно посмотреть с помощью session.new.

IdentitySet([<__main__.Customer object at 0x000001BD25928C40>, <__main__.Customer object at 0x000001BD25928C70>])

Наконец, для сохранения данных используется метод commit():

session.commit()

После сохранения транзакции ресурсы соединения, на которые ссылается объект Session, возвращаются в пул соединений. Последующие операции будут выполняться в новой транзакции.

Сейчас таблица Customer выглядит вот так:

Пока что покупатели ничего не приобрели. Поэтому c1.orders и c2.orders вернут пустой список.

[] []

Добавим еще потребителей в таблицу customers:

from sqlalchemy import create_engine
from sqlalchemy.orm import Session, sessionmaker

engine = create_engine("postgresql+psycopg2://postgres:1111@localhost/sqlalchemy_tuts")
session = Session(bind=engine)

c3 = Customer(
    first_name = "Vadim", 
    last_name = "Moiseenko", 
    username = "Antence73", 
    email = "antence73@mail.com",
)

c4 = Customer(          
    first_name = "Vladimir", 
    last_name = "Belousov", 
    username = "Andescols", 
    email = "andescols@mail.com",       
)

c5 = Customer(
    first_name = "Tatyana", 
    last_name = "Khakimova", 
    username = "Caltin1962", 
    email = "caltin1962@mail.com",
)

c6 = Customer(
    first_name = "Pavel", 
    last_name = "Arnautov", 
    username = "Lablen", 
    email = "lablen@mail.com",
)

session.add_all([c3, c4, c5, c6])
session.commit()

Также добавим продукты в таблицу items:

i1 = Item(name = 'Chair', cost_price = 9.21, selling_price = 10.81, quantity = 5)
i2 = Item(name = 'Pen', cost_price = 3.45, selling_price = 4.51, quantity = 3)
i3 = Item(name = 'Headphone', cost_price = 15.52, selling_price = 16.81, quantity = 50)
i4 = Item(name = 'Travel Bag', cost_price = 20.1, selling_price = 24.21, quantity = 50)
i5 = Item(name = 'Keyboard', cost_price = 20.1, selling_price = 22.11, quantity = 50)
i6 = Item(name = 'Monitor', cost_price = 200.14, selling_price = 212.89, quantity = 50)
i7 = Item(name = 'Watch', cost_price = 100.58, selling_price = 104.41, quantity = 50)
i8 = Item(name = 'Water Bottle', cost_price = 20.89, selling_price = 25, quantity = 50)

session.add_all([i1, i2, i3, i4, i5, i6, i7, i8])
session.commit()

Создадим заказы:

o1 = Order(customer = c1)
o2 = Order(customer = c1)

line_item1 = OrderLine(order = o1, item = i1, quantity =  3)
line_item2 = OrderLine(order = o1, item = i2, quantity =  2)
line_item3 = OrderLine(order = o2, item = i1, quantity =  1)
line_item3 = OrderLine(order = o2, item = i2, quantity =  4)

session.add_all([o1, o2])

session.new
session.commit()

В данном случае в сессию добавляются только объекты Order (o1 и o2). Order и OrderLine связаны отношением один-ко-многим. Добавление объекта Order в сессию неявно добавляет также и объекты OrderLine. Но даже если добавить последние вручную, ошибки не будет.

Вместо передачи объекта Order при создании экземпляра OrderLine можно сделать следующее:

o3 = Order(customer = c1)
orderline1 = OrderLine(item = i1, quantity = 5)
orderline2 = OrderLine(item = i2, quantity = 10)

o3.line_items.append(orderline1)
o3.line_items.append(orderline2)

session.add_all([o3,])
session.new
session.commit()

После коммита таблицы orders и order_lines будут выглядеть вот так:

Если сейчас получить доступ к атрибуту orders объекта Customer, то вернется не-пустой список.

[<Order:1>, <Order:2>]

С другой стороны отношения можно получить доступ к объекту Customer, которому заказ принадлежит через атрибут customer объекта Order — o1.customer.

Сейчас у покупателя c1 три заказа. Чтобы посмотреть все пункты в заказе нужно использовать атрибут line_items объекта Order.

c1.orders[0].line_items, c1.orders[1].line_items

([<OrderLine:1>, <OrderLine:2>], [<OrderLine:3>, <OrderLine:4>])

Для получения элемента заказа используйте item.

for ol in c1.orders[0].line_items:
    ol.id, ol.item, ol.quantity
    
print('-------')
    
for ol in c1.orders[1].line_items:
    ol.id, ol.item, ol.quantity

Вывод:

(1, <Item:1-Chair>, 3)
(2, <Item:2-Pen>, 2)
-------
(3, <Item:1-Chair>, 1)
(4, <Item:2-Pen>, 4)

Все это возможно благодаря отношениям relationship() моделей.

Получение данных

Чтобы сделать запрос в базу данных используется метод query() объекта session. Он возвращает объект типа sqlalchemy.orm.query.Query, который называется просто Query. Он представляет собой инструкцию SELECT, которая будет использована для запроса в базу данных. В следующей таблице перечислены распространенные методы класса Query.

Метод all()

В базовой форме метод query() принимает в качестве аргументов один или несколько классов модели или колонок. Следующий код вернет все записи из таблицы customers.

from sqlalchemy import create_engine
from sqlalchemy.orm import Session

engine = create_engine("postgresql+psycopg2://postgres:1111@localhost/sqlalchemy_tuts")
session = Session(bind=engine)

print(session.query(Customer).all())

[<Customer:1-Moseend>,
 <Customer:2-Fortioneaks>,
 <Customer:3-Antence73>,
 <Customer:4-Andescols>,
 <Customer:5-Caltin1962>,
 <Customer:6-Lablen>]

Так же можно получить записи из таблиц items и orders.

Чтобы получить сырой SQL, который используется для выполнения запроса в базу данных, примените sqlalchemy.orm.query.Query следующим образом: print(session.query(Customer)).

SELECT
    customers. ID AS customers_id,
    customers.first_name AS customers_first_name,
    customers.last_name AS customers_last_name,
    customers.username AS customers_username,
    customers.email AS customers_email,
    customers.address AS customers_address,
    customers.town AS customers_town,
    customers.created_on AS customers_created_on,
    customers.updated_on AS customers_updated_on
FROM
    customers

Вызов метода all() на большом объекте результата не очень эффективен. Вместо этого стоит использовать цикл for для перебора по объекту Query:

q = session.query(Customer)

for c in q:
    print(c.id, c.first_name)

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

print(session.query(Customer.id, Customer.first_name).all())

Вывод:

[(1, 'Dmitriy'), 
 (2, 'Valeriy'), 
 (3, 'Vadim'), 
 (4, 'Vladimir'), 
 (5, 'Tatyana'), 
 (6, 'Pavel')]

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

Метод count()

count() возвращает количество элементов в результате.

session.query(Item).count()
# Вывод - 8

Метод first()

first() возвращает первый результат запроса или None, если последний не вернул данных.

session.query(Order).first()
# Вывод - Order:1

Метод get()

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

session.query(Customer).get(1)
# Вывод - Customer:1-Moseend

Метод filter()

Этот метод позволяет отфильтровать результаты, добавив оператор WHERE. Он принимает колонку, оператор и значение. Например:

session.query(Customer).filter(Customer.first_name == 'Vadim').all()

Этот запрос вернет всех покупателей, чье имя — Vadim. А вот SQL-эквивалент этого запроса:

print(session.query(Customer).filter(Customer.first_name == 'Vadim'))

SELECT
    customers.id AS customers_id,
    customers.first_name AS customers_first_name,
    customers.last_name AS customers_last_name,
    customers.username AS customers_username,
    customers.email AS customers_email,
    customers.address AS customers_address,
    customers.town AS customers_town,
    customers.created_on AS customers_created_on,
    customers.updated_on AS customers_updated_on
FROM
    customers
WHERE
    customers.first_name = %(first_name_1)s

Строка %(first_name_1)s в операторе WHERE — это заполнитель, который будет заменен на реальное значение (Vadim) при выполнении запроса.

Можно передать несколько фильтров в метод filter() и они будут объединены с помощью оператора AND. Например:

session.query(Customer).filter(Customer.id <= 5, Customer.last_name == "Arnautov").all()

Этот запрос вернет всех покупателей, чей первичный ключ меньше или равен 5, а фамилия начинается с "Ar".

session.query(Customer).filter(Customer.id <= 5, Customer.last_name.like("Ar%")).all()

Еще один способ комбинировать условия — союзы (and_(), or_() и not_()). Некоторые примеры:

# все клиенты с именем Vadim и Tatyana
session.query(Customer).filter(or_(
    Customer.first_name == 'Vadim', 
    Customer.first_name == 'Tatyana'
)).all()


# найти всех с именем и Pavel фамилией НЕ Yatsenko
session.query(Customer).filter(and_(
    Customer.first_name == 'Pavel', 
    not_(
        Customer.last_name == 'Yatsenko', 
    )
)).all()

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

IS NULL

session.query(Order).filter(Order.date_placed == None).all()

IS NOT NULL

session.query(Order).filter(Order.date_placed != None).all()

IN

session.query(Customer).filter(Customer.first_name.in_(['Pavel', 'Vadim'])).all()

NOT INT

session.query(Customer).filter(Customer.first_name.notin_(['Pavel', 'Vadim'])).all()

BETWEEN

session.query(Item).filter(Item.cost_price.between(10, 50)).all()

NOT BETWEEN

session.query(Item).filter(not_(Item.cost_price.between(10, 50))).all()

LIKE

session.query(Item).filter(Item.name.like("%r")).all()

Метод like() выполняет поиск с учетом регистра. Для поиска совпадений без учета регистра используйте ilike().

session.query(Item).filter(Item.name.ilike("w%")).all()

NOT LIKE

session.query(Item).filter(not_(Item.name.like("W%"))).all()

Метод limit()

Метод limit() добавляет оператор LIMIT к запросу. Он принимает количество записей, которые нужно вернуть.

session.query(Customer).limit(2).all()
session.query(Customer).filter(Customer.username.ilike("%Andes")).limit(2).all()

SQL-эквивалент:

SELECT
    customers. id AS customers_id,
    customers.first_name AS customers_first_name,
    customers.last_name AS customers_last_name,
    customers.username AS customers_username,
    customers.email AS customers_email,
    customers.address AS customers_address,
    customers.town AS customers_town,
    customers.created_on AS customers_created_on,
    customers.updated_on AS customers_updated_on
FROM
    customers
LIMIT %(param_1)s 

Метод offset()

Метод offset() добавляет оператор OFFSET к запросу. Он принимает в качестве аргумента значение смещения. Часто используется с оператором limit().

session.query(Customer).limit(2).offset(2).all()

SQL-эквивалент:

SELECT
    customers. ID AS customers_id,
    customers.first_name AS customers_first_name,
    customers.last_name AS customers_last_name,
    customers.username AS customers_username,
    customers.email AS customers_email,
    customers.address AS customers_addrees,
    customers.town AS customers_town,
    customers.created_on AS customers_created_on,
    customers.updated_on AS customers_updated_on
FROM
    customers
LIMIT %(param_1)s OFFSET %(param_2)s

Метод order_by()

Метод order_by() используется для сортировки результата с помощью оператора ORDER BY. Он принимает названия колонок, по которым необходимо сортировать результат. По умолчанию сортирует по возрастанию.

session.query(Item).filter(Item.name.ilike("wa%")).all()
session.query(Item).filter(Item.name.ilike("wa%")).order_by(Item.cost_price).all()

Чтобы сортировать по убыванию используйте функцию desc():

from sqlalchemy import desc
session.query(Item).filter(Item.name.ilike("wa%")).order_by(desc(Item.cost_price)).all()

Метод join()

Метод join() используется для создания SQL INNER JOIN. Он принимает название таблицы, с которой нужно выполнить SQL JOIN.

Используем join(), чтобы найти всех покупателей, у которых как минимум один заказ.

session.query(Customer).join(Order).all()

SQL-эквивалент:

SELECT
    customers.id AS customers_id,
    customers.first_name AS customers_first_name,
    customers.last_name AS customers_last_name,
    customers.username AS customers_username,
    customers.email AS customers_email,
    customers.address AS customers_address,
    customers.town AS customers_town,
    customers.created_on AS customers_created_on,
    customers.updated_on AS customers_updated_on
FROM
    customers
JOIN orders ON customers.id = orders.customer_id

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

session.query(Customer.id, Customer.username, Order.id).join(Order).all()

Можно создать SQL JOIN для более чем двух таблиц, объединив несколько методов join() следующим образом:

session.query(Table1).join(Table2).join(Table3).join(Table4).all()

Вот еще один пример, который использует 3 объединения для нахождения всех пунктов в первом заказе Dmitriy Yatsenko.

session.query(
    Customer.first_name, 
    Item.name, 
    Item.selling_price, 
    OrderLine.quantity
).join(Order).join(OrderLine).join(Item).filter(
    Customer.first_name == 'Dmitriy',
    Customer.last_name == 'Yatsenko',
    Order.id == 1,
).all()

Метод outerjoin()

Метод outerjoin() работает как join(), но создает LEFT OUTER JOIN.

session.query(        
    Customer.first_name,
    Order.id,
).outerjoin(Order).all()

В этом запросе левой таблицей является customers. Это значит, что он вернет все записи из customers и только те, которые соответствуют условию, из orders.

Создать FULL OUTER JOIN можно, передав в метод full=True. Например:

session.query(        
    Customer.first_name,
    Order.id,
).outerjoin(Order, full=True).all()

Метод group_by()

Результаты группируются с помощью group_by(). Этот метод принимает одну или несколько колонок и группирует записи в соответствии со значениями в колонке.

Следующий запрос использует join() и group_by() для подсчета количества заказов, сделанных Dmitriy Yatsenko.

from sqlalchemy import func

session.query(func.count(Customer.id)).join(Order).filter(
    Customer.first_name == 'Dmitriy',
    Customer.last_name == 'Yatsenko',    
).group_by(Customer.id).scalar()

Метод having()

Чтобы отфильтровать результаты на основе значений, которые возвращают агрегирующие функции, используется метод having(), добавляющий оператор HAVING к инструкции SELECT. По аналогии с where() он принимает условие.

session.query(
    func.count("*").label('username_count'),    
    Customer.town
).group_by(Customer.username).having(func.count("*") > 2).all()

Работа с дубликатами

Для работы с повторяющимися записями используется параметр DISTINCT. Его можно добавить к SELECT с помощью метода distinct(). Например:

from sqlalchemy import distinct

session.query(Customer.first_name).filter(Customer.id  < 10).all()
session.query(Customer.first_name).filter(Customer.id  < 10).distinct().all()

session.query(        
    func.count(distinct(Customer.first_name)),
    func.count(Customer.first_name)
).all()

Приведение

Приведение (конвертация) данных от одного типа к другому — распространенная операция, которая выполняется с помощью функции cast() из библиотеки sqlalchemy.

from sqlalchemy import cast, Date, distinct, union

session.query(
    cast(func.pi(), Integer),
    cast(func.pi(), Numeric(10,2)),
    cast("2010-12-01", DateTime),
    cast("2010-12-01", Date),
).all()

Объединения

Для объединения запросов используется метод union() объекта Query. Он принимает один или несколько запросов. Например:

s1 = session.query(Item.id, Item.name).filter(Item.name.like("Wa%"))
s2 = session.query(Item.id, Item.name).filter(Item.name.like("%e%"))
s1.union(s2).all()

[(2, 'Pen'),
 (4, 'Travel Bag'),
 (3, 'Headphone'),
 (5, 'Keyboard'),
 (7, 'Watch'),
 (8, 'Water Bottle')]

По умолчанию union() удаляет все повторяющиеся записи из результата. Для их сохранения используйте union_all().

s1.union_all(s2).all()

Обновление данных

Для обновления объекта просто установите новое значение атрибуту, добавьте объект в сессию и сохраните ее.

i = session.query(Item).get(8)
i.selling_price = 25.91
session.add(i)
session.commit()

Таким образом можно обновлять только один объект за раз. Для обновления нескольких записей за раз используйте метод update() объекта Query. Он возвращает общее количество обновленных записей. Например:

session.query(Item).filter(
    Item.name.ilike("W%")
).update({"quantity": 60}, synchronize_session='fetch')
session.commit()

Удаление данных

Для удаления объекта используйте метод delete() объекта сессии. Он принимает объект и отмечает его как удаленный для следующего коммита.

i = session.query(Item).filter(Item.name == 'Monitor').one()
session.delete(i)
session.commit()

<Item:6-Monitor>

Этот коммит удаляет Monitor из таблицы items.

Для удаления нескольких записей за раз используйте метод delete() объекта Query.

session.query(Item).filter(
    Item.name.ilike("W%")
).delete(synchronize_session='fetch')
session.commit()

Этот коммит удаляет все элементы, название которых начинается с W.

Сырые(raw) запросы

ORM предоставляет возможность использовать сырые SQL-запросы с помощью функции text(). Например:

from sqlalchemy import text

session.query(Customer).filter(text("first_name = 'Vladimir'")).all()
session.query(Customer).filter(text("username like 'Cal%'")).all()
session.query(Customer).filter(text("username like 'Cal%'")).order_by(text("first_name, id desc")).all()

Транзакции

Транзакция — это способ выполнения набора SQL-инструкций так, что выполняются или все вместе, или ни одна из них. Если хотя бы одна инструкция из транзакции была провалена, база данных возвращается к предыдущему состоянию.

В базе данных есть два заказа, в процессе отгрузки заказа есть такие этапы:

1. В колонке date_placed таблицы orders устанавливается дата отгрузки.
2. Количество заказанных товаров вычитается из items.

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

В следующем коде определяем метод dispatch_order(), который принимает order_id в качестве аргумента и выполняет описанные выше задачи в одной транзакции.

def dispatch_order(order_id):
    # проверка того, правильно ли указан order_id
    order = session.query(Order).get(order_id)
    
    if not order:
        raise ValueError("Недействительный order_id: {}.".format(order_id))    
 
    try:
        for i in order.line_items:
            i.item.quantity = i.item.quantity - i.quantity            
        
        order.date_placed = datetime.now()                            
        session.commit()
        print("Транзакция завершена.")

    except IntegrityError as e:
        print(e)
        print("Возврат назад...")
        session.rollback()
        print("Транзакция не удалась.")


dispatch_order(1)

В первом заказе 3 стула и 2 ручки. dispatch_order() с идентификатором заказа 1 даст следующий вывод:

Транзакция завершена.

«Я не думаю, что мы подходим друг другу. Похоже, наши мысли работают по-разному.
Будто ты написана на Python, а он — на Java»

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

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

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

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

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

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

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

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

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

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

Тенденции в Java и Python

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

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

Между тем популярность Java, возможно, снизилась из-за ее невысокой репутации в области безопасности. Сайты технических новостей, такие как The Register, с наслаждением критикуют Java. The Hill утверждает, что 88% приложений на Java имеют проблемы с безопасностью. Конечно, плохая репутация языка во многом объясняется недостатками Java-плагина для браузера. В остальном потенциальные уязвимости в Java не намного хуже, чем у других языков.

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

Однако было бы неразумно думать о Java как о языке «из далекого прошлого». Разработчики Java продолжают добавлять новые функции. Они делают язык меньше, быстрее и гибче при использовании в крупномасштабной разработке. Мощная виртуальная машина Java (JVM) упрощает создание кроссплатформенных приложений. Java продолжает процветать в создании большого традиционного ПО, чем сегодня занимается большинство предприятий.

Более того, язык используется в 90% компаний из Fortune 500! Как ни крути, огромное количество установленных Java-приложений (как и вакансий на должность Java-разработчика) в ближайшее время точно никуда не исчезнут.

Java и Python также используют очень разные модели потоков. Python GIL или глобальная блокировка интерпретатора означает, что, в отличие от Java, Python фактически является однопоточным. Он может работать только на одном CPU-ядре одновременно. С другой стороны, использовать GPU с Python относительно легко по сравнению с аналогичным процессом в Java.

Таким образом, приложение на Python, работающее в параллельном режиме на 5120-ядерном графическом процессоре, скорее всего, оставит далеко позади полностью оптимизированное приложение на Java, запущенное на 8-ядерном CPU.

Возможно, из-за широкого диапазона позиций Java-разработчиков, было замечено, что Python-программисты обычно зарабатывают больше денег, чем Java-разработчики: 116000 долларов против 102000 долларов на Indeed и 99000 долларов против 96000 долларов на StackOverflow.

Проблема «грамотного программирования»

Кривая обучения языку программирования во многом зависит от ваших текущих знаний. От того, как вы планируете его использовать, и среды обучения. Например, если вы знакомы с программированием на C, C ++ или JavaScript и намерены писать код для стандартного приложения, процесс изучения Java будет относительно простым.

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

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

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

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

Грамотное программирование часто применяется для:

• Демонстраций
• Взаимодействия между разработчиками
• Исследований
• Обучения
• Презентаций

Python напрямую поддерживает такой подход через IDE, такие как Leo и Jupyter Notebook. Вы также можете добавить эту поддержку в другие редакторы, такие как Atom, используя специальные инструкции. Напротив, аналогичный функционал в среде с использованием Java может казаться принудительно склеенным. И кривая обучения для него, как правило, выше.

Сравнение производительности

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

«Конечно, пишите код на Python или на чем-то еще, но, когда вам нужно будет масштабировать приложение, его придется переписать на Java».

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

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

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

Также важно учитывать, как разные версии языка влияют на производительность. В реальном мире не всегда имеет смысл сравнивать только последние их выпуски. Если мы говорим о Java, то большинство приложений отстают от текущей версии на 2-3 обновления. Что касается Python, Python 3.x обычно работает быстрее, чем 2.x.

Поэтому, хотя это может показаться контрпродуктивным, некоторые программисты (и другие пользователи), занимающиеся data science, по-прежнему предпочитают использовать Python 2.x вместо 3.x из-за определенных библиотек. Обратите внимание, что сообщество Python изо всех сил пытается перейти 3 версию и в настоящее время отказалась от поддержки 2х.

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

Доля рынка и сообщество

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

Важно отметить, что оба языка поддерживаются большими и активными сообществами пользователей. Группы пользователей Java (JUG) существуют по всему миру. (Это геолокационное приложение позволяет вам найти ближайший к вам JUG.) Java-программисты также могут посещать крупные мероприятия, такие как JavaOne.

Сообщество Python не уступает по размаху: 1637 пользовательских Python-групп в 191 городе и 37 странах. В них участвуют более 860000 человек. События Python варьируются от встреч PyLadies, где женщины могут встречаться и программировать вместе, до PyCon и многих других.

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

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

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

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

Мультиязычность путь к победе

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

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

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

• Python был бы моим личным выбором для задач, связанных с data science, искусственным интеллектом и машинным обучением.
• Когда нужно написать ПО для пользователей, особенно десктопные и кроссплатформенные приложения, Java будет лучшим выбором.
• Оба языка являются отличным выбором для создания серверного приложения.

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

В этом руководстве поговорим об ошибке «NameError name is not defined». Разберем несколько примеров и разберемся, как эту ошибку решать.

Что такое NameError?

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

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

Самая распространенная NameError выглядит вот так:

NameError: name 'some_name' is not defined

Разберем частые причина возникновения этой ошибки.

Причина №1: ошибка в написании имени переменной или функции

Для человека достаточно просто сделать опечатку. Также просто для него — найти ее. Но это не настолько просто для Python.

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

Если ошибку не исправить, то возникнет исключение. Возьмем в качестве примера следующий код:

books = ["Near Dark", "The Order", "Where the Crawdads Sing"]
print(boooks)

Он вернет:

Traceback (most recent call last):
  File "main.py", line 3, in <module>
	print(boooks)
NameError: name 'boooks' is not defined

Для решения проблемы опечатку нужно исправить. Если ввести print(books), то код вернет список книг.

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

Причина №2: вызов функции до объявления

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

Напишем программу, которая вызывает функцию до объявления:

books = ["Near Dark", "The Order", "Where the Crawdads Sing"]

print_books(books)

def print_books(books):
	for b in books:
		print(b)

Код вернет:

Traceback (most recent call last):
  File "main.py", line 3, in <module>
	print_books(books)
NameError: name 'print_books' is not defined

На 3 строке мы пытаемся вызвать print_books(). Однако эта функция объявляется позже.

Чтобы исправить эту ошибку, нужно перенести функцию выше:

def print_books(books):
	for b in books:
		print(b)

books = ["Near Dark", "The Order", "Where the Crawdads Sing"]

print_books(books)

Причина №3: переменная не объявлена

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

Посмотрим на программу, которая выводит список книг:

for b in books:
    print(b)

Такой код вернет:

Traceback (most recent call last):
  File "main.py", line 1, in <module>
	for b in books:
NameError: name 'books' is not defined

Переменная books объявлена не была.

Для решения проблемы переменную нужно объявить в коде:

books = ["Near Dark", "The Order", "Where the Crawdads Sing"]

for b in books:
    print(b)

Причина №4: попытка вывести одно слово

Чтобы вывести одно слово, нужно заключить его в двойные скобки. Таким образом мы сообщаем Python, что это строка. Если этого не сделать, язык будет считать, что это часть программы. Рассмотрим такую инструкцию print():

print(Books)

Этот код пытается вывести слово «Books» в консоль. Вместо этого он вернет ошибку:

Traceback (most recent call last):
  File "main.py", line 1, in <module>
	print(Books)
NameError: name 'Books' is not defined

Python воспринимает «Books» как имя переменной. Для решения проблемы нужно заключить имя в скобки:

print("Books")

Теперь Python знает, что нужно вывести в консоли строку, и код возвращает Books.

Причина №5: объявление переменной вне области видимости

Есть две области видимости переменных: локальная и глобальная. Локальные переменные доступны внутри функций или классов, где они были объявлены. Глобальные переменные доступны во всей программе.

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

Следующий код пытается вывести список книг вместе с их общим количеством:

def print_books():
  books = ["Near Dark", "The Order", "Where the Crawdads Sing"]
  for b in books:
      print(b)

print(len(books))

Код возвращает:

Traceback (most recent call last):
  File "main.py", line 5, in <module>
	print(len(books))
NameError: name 'books' is not defined

Переменная books была объявлена, но она была объявлена внутри функции print_books(). Это значит, что получить к ней доступ нельзя в остальной части программы.

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

books = ["Near Dark", "The Order", "Where the Crawdads Sing"]

def print_books():
  for b in books:
      print(b)


print(len(books))

Код выводит название каждой книги из списка books. После этого выводится общее количество книг в списке с помощью метода len().

ORM построен на базе SQLAlchemy Core, поэтому имеющиеся знания должны пригодиться.

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

Прежде чем двигаться дальше удалите все таблицы из sqlalchemy-tuts с помощью следующей команды: metadata.drop_all(engine).

Создание моделей

Модель — это класс Python, соответствующий таблице в базе данных, а его свойства — это колонки.

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

1. Наследоваться от декларативного базового класса с помощью вызова функции declarative_base().
2. Объявить имя таблицы с помощью атрибута __tablename__.
3. Объявить как минимум одну колонку, которая должна быть частью первичного ключа.

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

Базовый класс управляет каталогом классов и таблиц. Другими словами, декларативный базовый класс — это оболочка над маппером и MetaData. Маппер соотносит подкласс с таблицей, а MetaData сохраняет всю информацию о базе данных и ее таблицах. По аналогии с Core в ORM методы create_all() и drop_all() объекта MetaData используются для создания и удаления таблиц.

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

from sqlalchemy import create_engine, MetaData, Table, Integer, String, \
    Column, DateTime, ForeignKey, Numeric
from sqlalchemy.ext.declarative import declarative_base
from datetime import datetime

Base = declarative_base()

class Post(Base):
    __tablename__ = 'posts'
    id = Column(Integer, primary_key=True)
    title = Column(String(100), nullable=False)
    slug = Column(String(100), nullable=False)
    content = Column(String(50), nullable=False)
    published = Column(String(200), nullable=False, unique=True)    
    created_on = Column(DateTime(), default=datetime.now)
    updated_on = Column(DateTime(), default=datetime.now, onupdate=datetime.now)

Разберем построчно:

1. На 1-4 строках импортируются нужные классы и функции.
2. В 6 строке создается базовый класс с помощью вызова функции declarative_base().
3. На 10-16 строках колонки объявляются как атрибуты класса.

Стоит обратить внимание на то, что для создания колонок используется тот же класс Column, что и для SQLAlchemy Core. Единственное отличие в том, что первым аргументом является тип, а не название колонки. Аргументы-ключевые слова, в свою очередь, переданные в Column(), работают одинаково в ORM и Core.

Поскольку ORM построен на базе Core, SQLAlchemy использует определение модели для создания объекта Table и связи его с моделью с помощью функции mapper(). Это завершает процесс маппинга модели Post с соответствующим экземпляром Table. Теперь модель Post можно использовать для управления базой данных и для осуществления запросов к ней.

Классический маппинг

После прошлого раздела может создаться впечатление, что для использования SQLAlchemy ORM нужно переписать все экземпляры Table в виде моделей. Но это не так.

Можно запросто мапить любые Python классы на экземпляры Table с помощью функции mapper(). Например:

from sqlalchemy import MetaData, Table, Integer, String, Column, Text, DateTime, Boolean
from sqlalchemy.orm import mapper
from datetime import datetime

metadata = MetaData()

post = Table('post', metadata, 
    Column('id', Integer(), primary_key=True),
    Column('title', String(200), nullable=False),
    Column('slug', String(200),  nullable=False),
    Column('content', Text(),  nullable=False),
    Column('published', Boolean(),  default=False),
    Column('created_on', DateTime(), default=datetime.now),
    Column('updated_on', DateTime(), default=datetime.now, onupdate=datetime.now)
)

class Post(object):
    pass

mapper(Post, post)

Этот класс принимает два аргумента: класс для маппинга и объект Table.

После этого у класса Post будут атрибуты, соответствующие колонкам таблицы. Таким образом у Post сейчас следующие атрибуты:

• post.id
• post.title
• post.slug
• post.content
• post.published
• post.created_on
• post.updated_on

Код в списке выше эквивалентен модели Post, которая была объявлена выше.

Теперь вы должны лучше понимать, что делает declarative_base().

Добавление ключей и ограничений

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

from sqlalchemy import Table, Index, Integer, String, Column, Text, \
                       DateTime, Boolean, PrimaryKeyConstraint, \
                       UniqueConstraint, ForeignKeyConstraint
from sqlalchemy.ext.declarative import declarative_base
from datetime import datetime

Base = declarative_base()


class User(Base):
    __tablename__ = 'users'
    id = Column(Integer)
    username = Column(String(100), nullable=False)
    email = Column(String(100), nullable=False)    
    password = Column(String(200), nullable=False)
    
    __table_args__ = (
        PrimaryKeyConstraint('id', name='user_pk'),
        UniqueConstraint('username'),
        UniqueConstraint('email'),
    )


class Post(Base):
    __tablename__ = 'posts'
    id = Column(Integer, primary_key=True)
    title = Column(String(100), nullable=False)
    slug = Column(String(100), nullable=False)
    content = Column(String(50), nullable=False)
    published = Column(String(200), nullable=False, default=False)
    user_id = Column(Integer(), nullable=False)
    created_on = Column(DateTime(), default=datetime.now)
    updated_on = Column(DateTime(), default=datetime.now, onupdate=datetime.now)
    
    __table_args__ = (
        ForeignKeyConstraint(['user_id'], ['users.id']),        
        Index('title_content_index' 'title', 'content'), # composite index on title and content   
    )

Отношения

Один-ко-многим

Отношение один-ко-многим создается за счет передачи внешнего ключа в дочерний класс. Например:

class Author(Base):
    __tablename__ = 'authors'
    id = Column(Integer, primary_key=True)
    first_name = Column(String(100), nullable=False)
    last_name = Column(String(100), nullable=False)
    books = relationship("Book")

class Book(Base):
    __tablename__ = 'books'
    id = Column(Integer, primary_key=True)
    title = Column(String(100), nullable=False)
    copyright = Column(SmallInteger, nullable=False)
    author_id = Column(Integer, ForeignKey('authors.id'))

Строчка author_id = Column(Integer, ForeignKey('authors.id')) устанавливает отношение один-ко-многим между моделями Author и Book.

Функция relationship() добавляет атрибуты в модели для доступа к связанным данным. Как минимум — название класса, отвечающего за одну сторону отношения.

Строчка books = relationship("Book") добавляет атрибут books классу Author.

Имея объект a класса Author, получить доступ к его книгам можно через a.books. А если нужно получить автора книги через объект Book?

Для этого можно определить отдельное отношение relationship() в модели Author:

class Author(Base):
    __tablename__ = 'authors'
    id = Column(Integer, primary_key=True)
    first_name = Column(String(100), nullable=False)
    last_name = Column(String(100), nullable=False)
    books = relationship("Book")

class Book(Base):
    __tablename__ = 'books'
    id = Column(Integer, primary_key=True)
    title = Column(String(100), nullable=False)
    copyright = Column(SmallInteger, nullable=False)
    author_id = Column(Integer, ForeignKey('authors.id'))
    author = relationship("Author")

Теперь через объект b класса Book можно получить автора b.author.

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

class Author(Base):
    __tablename__ = 'authors'
    id = Column(Integer, primary_key=True)
    first_name = Column(String(100), nullable=False)
    last_name = Column(String(100), nullable=False)
    books = relationship("Book", backref="book")

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

class Book(Base):
    __tablename__ = 'books'
    id = Column(Integer, primary_key=True)
    title = Column(String(100), nullable=False)
    copyright = Column(SmallInteger, nullable=False)
    author_id = Column(Integer, ForeignKey('authors.id'))
    author = relationship("Author", backref="books")

Один-к-одному

Установка отношения один-к-одному в SQLAlchemy почти не отличается от одного-ко-многим. Единственное отличие в том, что нужно передать дополнительный аргумент uselist=False в функцию relationship(). Например:

class Person(Base):
    __tablename__ = 'persons'
    id = Column(Integer(), primary_key=True)
    name = Column(String(255), nullable=False)
    designation = Column(String(255), nullable=False)
    doj = Column(Date(), nullable=False)
    dl = relationship('DriverLicense', backref='person', uselist=False)


class DriverLicense(Base):
    __tablename__ = 'driverlicense'
    id = Column(Integer(), primary_key=True)
    license_number = Column(String(255), nullable=False)
    renewed_on = Column(Date(), nullable=False)
    expiry_date = Column(Date(), nullable=False)
    person_id = Column(Integer(), ForeignKey('persons.id'))

Имея объект p класса Person, p.dl вернет объект DriverLicense. Если не передать uselist=False в функцию, то установится отношение один-ко-многим между Person и DriverLicense, а p.dl вернет список объектов DriverLicense вместо одного. При этом uselist=False никак не влияет на атрибут persons объекта DriverLicense. Он вернет объект Person как и обычно.

Многие-ко-многим

Для отношения многие-ко-многим нужна отдельная таблица. Она создается как экземпляр класса Table и затем соединяется с моделью с помощью аргумента secondary функции relationship().

author_book = Table('author_book', Base.metadata, 
    Column('author_id', Integer(), ForeignKey("authors.id")),
    Column('book_id', Integer(), ForeignKey("books.id"))
)

class Author(Base):
    __tablename__ = 'authors'
    id = Column(Integer, primary_key=True)
    first_name = Column(String(100), nullable=False)
    last_name = Column(String(100), nullable=False)


class Book(Base):
    __tablename__ = 'books'
    id = Column(Integer, primary_key=True)
    title = Column(String(100), nullable=False)
    copyright = Column(SmallInteger, nullable=False)
    author_id = Column(Integer, ForeignKey('authors.id'))
    author = relationship("Author", secondary=author_book, backref="books")

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

Для представления этого отношения была создана таблица author_book.

Через объект a класса Author можно получить все книги автора с помощью a.books. По аналогии через b класса Book можно вернуть список авторов b.authors.

В этом случае relationship() была объявлена в модели Book, но это можно было сделать и с другой стороны.

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

class Author_Book(Base):
    __tablename__ = 'author_book'
    id = Column(Integer, primary_key=True)
    author_id =  Column(Integer(), ForeignKey("authors.id"))
    book_id =  Column(Integer(), ForeignKey("books.id"))
    extra_data = Column(String(100))

class Author(Base):
    __tablename__ = 'authors'
    id = Column(Integer, primary_key=True)
    first_name = Column(String(100), nullable=False)
    last_name = Column(String(100), nullable=False)
    books = relationship("Author_Book", backref='author')

class Book(Base):
    __tablename__ = 'books'
    id = Column(Integer, primary_key=True)
    title = Column(String(100), nullable=False)
    copyright = Column(SmallInteger, nullable=False)    
    authors = relationship("Author_Book", backref="book")

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

По аналогии с SQLAlchemy Core в ORM есть метод create_all() экземпляра MetaData, который отвечает за создание таблицы.

Base.metadata.create_all(engine)

Для удаления всех таблиц есть drop_all.

Base.metadata.drop_all(engine)

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

from sqlalchemy import create_engine, MetaData, Table, Integer, String, \
    Column, DateTime, ForeignKey, Numeric, SmallInteger

from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import relationship

from datetime import datetime

engine = create_engine("postgresql+psycopg2://postgres:1111@localhost/sqlalchemy_tuts")

Base = declarative_base()

class Customer(Base):
    __tablename__ = 'customers'
    id = Column(Integer(), primary_key=True)
    first_name = Column(String(100), nullable=False)
    last_name = Column(String(100), nullable=False)
    username = Column(String(50), nullable=False)
    email = Column(String(200), nullable=False)
    created_on = Column(DateTime(), default=datetime.now)
    updated_on = Column(DateTime(), default=datetime.now, onupdate=datetime.now)
    orders = relationship("Order", backref='customer')
    

class Item(Base):
    __tablename__ = 'items'
    id = Column(Integer(), primary_key=True)
    name = Column(String(200), nullable=False)
    cost_price =  Column(Numeric(10, 2), nullable=False)
    selling_price = Column(Numeric(10, 2),  nullable=False)
    quantity = Column(Integer())


class Order(Base):
    __tablename__ = 'orders'
    id = Column(Integer(), primary_key=True)
    customer_id = Column(Integer(), ForeignKey('customers.id'))
    date_placed = Column(DateTime(), default=datetime.now)
    line_items = relationship("OrderLine", backref='order')
    

class OrderLine(Base):
    __tablename__ = 'order_lines'
    id =  Column(Integer(), primary_key=True)
    order_id = Column(Integer(), ForeignKey('orders.id'))
    item_id = Column(Integer(), ForeignKey('items.id'))
    quantity = Column(SmallInteger())
    item = relationship("Item")

Base.metadata.create_all(engine)

Популярность отрасли постоянно растет. В 2015 только 17% компаний использовали возможности аналитики Big Data, а в 2017 это значение выросло до 53%.

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

В этом материале разберем Python и то, как он используется для анализа данных.

Подходит ли Python для анализа данных?

Python появился еще в 1990 году, но начал приобретать популярность не так давно. В 2020 Python стал четвертым в списке самых используемых языков программирования после JavaScript, HTML/CSS и SQL — его используют 44,1% разработчиков.

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

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

Как Python используется для анализа данных?

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

Поиск данных

Инженеры используют Scrapy и BeautifulSoup для поиска данных с помощью Python.С помощью Scrapy можно создавать программы, которые собирают структурированные данные в сети. Также его можно использовать для сбора данных из API.

BeautifulSoup применяется там, где получить данные из API не выходит; он собирает данные и расставляет их в определенном формате.

Обработка и моделирование данных

На этом этапе в числе самых используемых библиотек NumPy и Pandas. NumPy (Numerical Python) используется для сортировки больших наборов данных. Он упрощает математические операции и их векторизацию на массивах. Pandas предлагает два структуры данных: Series (список элементов) и Data Frames (таблица с несколькими колонками). Эта библиотека конвертирует данные в Data Frame, позволяя удалять и добавлять новые колонки, а также выполнять разные операции.

Визуализация данных

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

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

Преимущества и недостатки Python для анализа данных

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

Преимущества Python

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

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

Легко изучается

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

Гибкий и масштабируемый

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

Разнообразие библиотек

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

Недостатки

Динамическая типизация

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

Где учится анализу данных

Один из лучших курсов — годовая программа Профессия Data Scientist: анализ данных от Skillbox. Аналитики из Ivi, QIWI, Rambler и Epam обучают работе с данными и комментируют домашние задания.

Программа курса:

1. Python для Data Science
2. Аналитика. Начальный уровень
3. Статистика и теория вероятностей
4. Основы математики для Data Science
5. Аналитика. Средний уровень
6. Универсальные знания программиста
7. Английский для IT-специалистов 

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

Альтернативы Python для анализа данных

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

R

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

SQL

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

Julia

Julia был разработан для data science и научных вычислений. Это относительно новый язык, который быстро приобретает популярность среди специалистов в области. Главная его цель — преодолеть недостатки Python и стать выбором №1 среди инженеров. Julia — компилируемый язык, что подразумевает более высокую производительность. Однако синтаксис похож на Python, пусть и с акцентом на математику. В Julia можно использовать библиотеки из Python, C и Forton. Также язык славится параллельными вычислениями, которые работают быстрее и сложнее чем в Python.

Scala

Scala и фреймворк Spark часто используются для работы с большими базами данных. Для этого даже не обязательно загружать все данные — можно работать кусками. Scala работает на JVM и может быть встроен в enterprise-код. Предлагает массу инструментов для обработки данных, которые работают быстрее, чем у Python и R.

Это 4 самых популярных языка среди специалистов в сфере data science. Однако стоит также отметить MATLAB для статистического анализа, TensorFlow для BigData, графов и параллельных вычислений, а также JavaScript для визуализации.

Выводы

Данные — важная часть любого бизнеса. Для анализа данных сегодня существует масса языков, включая R, SQL, Julia и Scala. Каждый из них выполняет определенный набор задач и справляется с ним лучше остальных. В целом, нет одного идеального языка для проекта.

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