🔥Продолжаем говорить про О-нотацию

Из предыдущих постов мы уже знаем, как работает O(1), O(log n), O(n), если хотите освежить память, можете вернуться к посту.

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

🟢 Сложность O(n log n)

Фактически, все эффективные алгоритмы сортировки представляют собой O(n log n) сложность: сортировка слиянием (merge), пирамидальная сортировка (heap), быстрая сортировка, а еще Timsort (изобретенный Тимом Питерсом алгоритм, который используется методом sort() в Python).

Например, отсортировать n книг в алфавитном порядке, как раз, представляет O(n log n) сложность.

🔵 Сложность O(n^2)

Если требуется найти повторяющиеся книги на несортированной полке, это уже квадратичная сложность. Например, на полке стоят 100 несортированных книг, мы берем одну и ищем дубли среди остальных 99, потом берём другую и снова проверяем оставшиеся. Очень затратно: проверка 100 книг займёт 100 × 100, или 10 000 шагов, причем проверка 200 займёт уже 40 000 шагов - в четыре раза больше.

В реальном мире, именно для этого нам необходимо знание BIG O. Чтобы не писать алгоритм O(n^2), когда можно было написать O(n log n) или O(n).

Итак, остались те, чьи имена нельзя произносить: экспоненциальная O(2^n) и факториальная сложность O(n!).

🟣 Сложность O(2^n)

Допустим, на полке 2 книги, и мы будем собирать все возможные комбинации книг: первая комбинация - пустая полка, вторая - книга A, третья - книга B и последняя - обе книги на полке. Для 3 книг получим уже 8 комбинаций. Так вот, это - экспоненциальный алгоритм. Причем, обратите внимание, нас интересуют не перестановки, а только комбинации.

🔴 Сложность O(n!)

Перестановки, как раз, будут отвечать за факториальную сложность: если у нас на полке 3 книги, все варианты перестановок - 3!.

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

💡 Наконец переходим от теории к практике!

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

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

1. Если код не оперирует входными данными, это O(1).

2. Если код итерируется по данным, это O(n).

3. Два вложенных цикла, каждый из которых проходит по входным данным, дают сложность O(n^2).

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

5. Если в коде есть конструкция «разделяй и властвуй», это O(log n).

6. Если «разделяй и властвуй» выполняется для каждого элемента во входных данных, это O(n log n).

7. Если код проходит по каждой возможной комбинации значений в n данных, это O(2^n) или другая экспоненциальная сложность (3^n, 4^n…).

8. Если рассматриваются все возможные перестановки значений в данных, это O(n!).

9. Если код предполагает сортировку данных, это будет как минимум O(n log n).

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

❓Уже зная некоторые флаги, как вы думаете, какая сложность у этих методов python?

- .append()
- .insert()
- .remove()
- .sort()
- цикл for

#сложность_алгоритмов

🔥 Почему to_char в SQL дал неправильный результат?

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

Получилось два варианта:

- Первый - concat - '+' || ROUND (price * 1.0, 2) || '%') orders_increase
- Второй - to_char - to_char((price * 1.0),'S9990D00%’) orders_increase2

❗️Они, конечно, немного изменены, чтобы не спойлерить решение, но отражают саму проблему.

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

🤔 Есть идеи в чем дело?

Давайте разберемся вместе.

В первом методе сомнений нет, простой конкатенацией формат приводится к необходимому. А вот со вторым уже интереснее! Нужный шаблон заполнения 'S9990D00%' в to_char передали, а все равно решение не принимается.

Секрет здесь в том, что to_char дополняет строку пустыми заполнениями (пробелами) так, чтобы результат имел фиксированную ширину. Вы же заметили, что решения, по сути, различает только выравнивание? Это и есть то самое заполнение пробелами. Отсюда и несоответствие эталонному решению.

Так что же, смириться и не использовать to_char? Ну уж нет, так просто мы не сдадимся!

⁉️ Как исправить код, чтобы он заработал верно?

У to_char есть такая деталь, как модификаторы шаблонов, почитать можно тут. Они применяются, чтобы изменить поведение кода. И среди этих модификаторов нашлась такая приставка - FM, которая подавляет пустые заполнения, она передается прямо в шаблон - 'FMS9990D00%' И буквально двумя буквами мы сделали так, что код был принят!

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

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

#sql

🔥 Сценарии использования NULLIF

Вас когда-нибудь спрашивали на собеседовании о функции NULLIF?

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

Что такое NULLIF и как это использовать?

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

NULLIF(выражение 1, выражение 2)

🔵 Деление на ноль

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

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

SELECT column1/NULLIF(column2, 0)
FROM table1

То есть, когда значение второго столбца равно 0 (аргументы в NULLIF равны), вернется NULL, а не ZeroDivisionError.

🟢 Поиск среднего значения

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

Например дана такая таблица:

| column1 | column2 |
|---------|---------|
| 0       | a       |
| 7       | a       |

Выполнив:

SELECT column2, AVG(column1)
FROM table1
GROUP BY column2;

Получим:

| column2 | avg |
|---------|-----|
| a       | 3.5 |

А с использованием NULLIF получим другой результат:

SELECT column2, AVG(NULLIF(column1, 0))
FROM table1
GROUP BY column2;

| column2 | avg |
|---------|-----|
| a       | 7   |

🟣 Преобразование пустых строк

Другой вариант использования NULLIF - преобразование пустых строк в NULL. Например, в таблице некоторые столбцы содержат пустые строки, которые необходимо трактовать как NULL - идеально подходящая ситуация для NULLIF:

SELECT NULLIF(column1, '') FROM table1;

Получим NULL, если столбец 1 содержит пустую строку, что эффективно обработает все пустые строки.

💡 В следующий раз, когда вы будете работать над проектом, попробуйте найти, где бы вы могли использовать NULLIF и убедитесь, как он легко поможет решать сложные задачи и избегать больших CASE/WHEN конструкций. Кстати говоря, NULLIF это тот же CASE/WHEN, так что, возможно, стоит провести ревизию старых проектов и увидеть потенциальные «use» кейсы. Если вы и раньше использовали NULLIF, расскажите, в каких интересных задачах он вам пригодился?

#sql

🔥 Пишем генератор логинов на Python

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

Вроде этих: 4W008LL, UOJ97HT и тд.

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

Итак, сталкивались ли вы раньше с модулями string и random? Они как раз и помогают генерировать случайные строки символов, и если постараться можно справиться всего одной строкой!

🔵 Первый вариант

import string
import random

''.join(random.choice(
    string.ascii_uppercase + 
    string.digits) 
    for _ in range(N))

- string.ascii_uppercase - строка, содержащая все заглавные буквы английского алфавита (ABCDEFGHIJKLMNOPQRSTUVWXYZ)

- string.digits - это строка, содержащая все цифры (0123456789).

- Соединяем их, и с помощью random.choice выбираем случайный символ.

- И, конечно, используем цикл, для получения N знаков в наш логин, и все это соединяем с помощью ''.join.

🟢 Второй вариант

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

На самом деле, самая сложная часть работы уже сделана:

import string
import random

def generator(first_name, 
           last_name, size=6):
    # Удаляем пробелы из имени 
    и фамилии и преобразуем 
    их в верхний регистр

    first_name = 
    first_name.strip().upper()
    last_name = 
    last_name.strip().upper()
    
    # Эта часть кода у нас уже 
    была

    chars = 
    string.ascii_uppercase + 
    string.digits

    random_string = ''.join(
        random.choice(chars) 
        for _ in range(size))
    
    # Просто соединяем 
    все части
    login_id = first_name[0] + 
        last_name[:5] + 
        random_string
    
    return login_id

Попробуем:

generator('Jon', 'Snow', 5)

>> JSNOWZKHKY

Круто, правда? Теперь вы можете создавать уникальные логины для пользователей всего за несколько строк кода! 😉

#python

🔥 4 разных решения бизнес-задачи c SQL

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

Сегодня мы рассмотрим 4 способа решения такой задачи.

Дано: у нас есть две таблицы: Resellers (id, address) и Proceeds (id, revenue, period). В первой, соответственно, хранятся все наши продавцы, во второй - некоторая форма отчетности (id продавца, доход за период, период), причем эти отчеты формируются не на регулярной основе, а по факту получения прибыли.

❓Итак, мы хотим найти продавцов, которые не приносили нам никакого дохода вообще, то есть не содержатся в таблице proceeds. Как бы вы с этим справились?

У нас, есть как минимум 4 надежных способа решения этой задачи! Мы будем использовать PostgreSQL, но они также будут работать и для других СУБД, так как являются стандартными.


🔴 LEFT JOIN / IS NULL

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

SELECT r.id 
FROM   resellers r 
LEFT   JOIN proceeds p USING (id)  
WHERE  p.id IS NULL;

🔵 NOT EXISTS

А этот метод вряд ли первым придет в голову, хотя зачастую он имеет преимущество в скорости для PostgreSQl.

SELECT id 
FROM   resellers r
WHERE  NOT EXISTS (
   SELECT  
   FROM   proceeds
   WHERE  id = r.id
   );

Обратите внимание, что PostgreSQL позволяет оставить пустым поле select в подзапросе.


🟢 EXCEPT

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

SELECT id 
FROM   resellers

EXCEPT ALL  
SELECT id
FROM   proceeds;

🟡 NOT IN

Будет работать без проблем в том случае, если в таблицах нет NULL значений. То есть, если одно из значений будет NULL, NOT IN вернет NULL, в то время как NOT EXISTS вернет TRUE. В нашем случае, конечно, id не может быть NULL, но это важно понимать для других кейсов.

SELECT id 
FROM   resellers
WHERE  id NOT IN (
   SELECT DISTINCT id 
   FROM   proceeds
   );

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

#sql

🔥 ARPU и ARPPU спешат бизнесу на помощь!

Хотите повысить доходы своего бизнеса, но не уверены, как измерять эффективность монетизации своих пользователей? Мы, с ARPU и ARPPU спешим к вам на помощь.

🔵 Что такое ARPU?

ARPU (Average revenue per user) или средний доход на пользователя - это показатель, который измеряет средний доход, генерируемый каждым активным пользователем.

Как рассчитать?

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

ARPU = общий доход / количество активных пользователей

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

🔴 Что такое ARPPU?

ARPPU (Average revenue per paying user) - доход, генерируемый одним платящим пользователем в течение некоторого периода. Платящие пользователи - это те, кто платит деньги (подписываясь, совершая покупки, либо оплачивая другие услуги). Этот показатель не учитывает тех пользователей, которые активно не тратят деньги в течение пользования (например, тех, кто приносит доход за счет рекламы).

ARPPU = общий доход / количество платящих пользователей

✏️ Пример

Допустим, у вас 1000 пользователей, и 20 из них платят. Ваш общий ежемесячный доход составляет 2000 долларов. Таким образом, ARPU в месяц равен 2000/1000 = 2 (один активный пользователь приносит вам в среднем 2 доллара в месяц). В то же время ARPPU будет равен 2000/20 = 100.

🟢 Для чего используется APRU?

ARPU - отличный показатель качества дохода, который вы получаете от клиентов.

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

🟣 Почему важен ARPPU?

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

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

❓ В чем разница?

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


📈 На Симуляторе "Аналитик данных" мы подробно разбираем продуктовые метрики: какие бывают, как их считать с помощью SQL и Python и как интерпретировать результаты. Попробуйте демо-главу!

#продуктовые_метрики

🔥 Вносим ясность в визуализацию Python

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

💡 Есть решение!

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

Функция annotate() библиотеки matplotlib позволяет добавить *пояснительный* текст на график, фокусируя зрителя на конкретных деталях и контролируя его внимание.

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

import matplotlib.pyplot as plt

# создаем самый элементарный график
x = [1, 2, 3, 4, 5]
y = [2, 4, 6, 8, 10]
plt.plot(x, y)

# добавляем аннотацию
plt.annotate('Max value', xy=(5, 10), xytext=(4, 8),
             arrowprops=dict(facecolor='black', shrink=0.05))

plt.show()

Синтаксис: plt.annotate(text, xy, xytext)

- text - текст аннотации
- xy - позиция на графике, в которую будет передан текст (если не задавать параметр xytext)
- xytext - вторая позиция расположения текста (если она задана, то текст будет расположен в xytext, а в позицию xy будет проведена указательная стрелка, параметры которой можно задать в arrowpops)

Это очень простой пример, поэтому сделаем кое-что посложнее. Добавим аннотации на график индекса S&P 500.

Смотрите в карточках под постом, что у нас получилось!


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

#python #visualization

📆 4 способа сравнить даты типа datetime

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

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

Дано: две даты: '2022-02-03 16:00:00', '2022-01-20 08:00:00'

Задание: найти разницу между ними в днях и/или часах.

Казалось бы, почему в PostgreSQL нет функции date_diff? Но на самом деле, PostgreSQL предоставляет даже больше функций для работы с датами, чем просто date_diff.


🔵 Первый вариант: считаем «в лоб»

Просто вычитаем одну дату из другой (первая карточка - 1 блок кода)

Получим интервал 14 days 08:00:00. Если нам понадобится получить только количество дней - запросто вытащим их с помощью extract() (первая карточка - 2 блок кода).

А если нам необходима разница в часах?

Extract (HOUR …) вернет нам 8, что очевидно - 16:00-8:00, но нам нужен другой результат, придется усложнять запрос (первая карточка - 3 блок кода).

И получим наши заветные 344 часа.


🔴 Второй вариант

PostgreSQL предлагает еще одну функцию - date_part. Extract() - это стандарт SQL, date_part() - специфичен для Postgres. И мы можем переписать наш запрос с помощью неё, но на самом деле, эти функции ничем не отличаются, кроме типа результата: extract() возвращает numeric, а date_part() - double precision.

Но это все выглядит так нагромождённо (вторая карточка - 1 блок кода), как будто должно быть что-то проще. И это так!


🟢 Третий вариант

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


🟡 Четвертый вариант

Но это все-таки не совсем наш случай, мы не получим тут разницу в часах. Поэтому мы возвращаемся к extract(), только на этот раз доставать мы будем нетривиальное EPOCH (третья карточка).

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

💥Этот вариант более эффективен, чем date_part(), а вывод более детализирован, чем с AGE(). При этом учитываются разное число дней в месяцах, изменения часовых поясов (если бы они у нас были) и переходы на летнее время.

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


⏰ Мы в Симуляторе "Аналитик данных" целый урок посвятили работе с датой и временем в SQL. Попробуйте демо 🙃

🔥 3 способа собрать статистику по сгруппированным строкам

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

🔵 Простой подход

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

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

🔴 Более точный подход

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

Сначала мы получаем размер каждой группы, используя метод size(), который возвращает серию с количеством записей в каждой группе. Затем преобразуем его в DataFrame с помощью to_frame() и присваиваем ему имя. И далее с помощью agg() вычисляем среднее, медиану и минимальное значение для каждой группы. А чтобы все объединить используем join().

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

💡 Но у нас есть для вас кое-что еще!

В дополнение к традиционным агрегациям существует удивительный инструмент - Skimpy, который дает исчерпывающую статистическую сводку, всего за одну строку кода. Хотите посмотреть? (карточка 3 и 4)

Skimpy - отличный инструмент для EDA, он показывает куда больше, чем просто describe(), поэтому очень рекомендуем попробовать его самостоятельно. Всегда лучше один раз попробовать, чем сто раз увидеть. Безусловно, важно уверенно оперировать агрегациями, но и упростить себе работу с инструментами вроде skimpy тоже бывает полезно.

#python #pandas

🔥 Cекреты функции sorted() в Python

Итак, в Python существует функция sorted(), которая используется для сортировки данныx. sorted() упорядочивает данные таким образом, чтобы было легче провести анализ и извлечь нужную информацию. Например, в аналитике, сортировка клиентов по возрасту, территориальной принадлежности и другим критериям - далеко не редкая задача.

Для сортировки списка объектов по одному из их атрибутов, как раз можем использовать функцию sorted() в Python. Она отсортирует любой итерируемый объект: список, кортеж или множество.

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

client_list = [
    {'name': 'John', 'age': 25, 'income': 50000},
    {'name': 'Mary', 'age': 30, 'income': 70000},
    {'name': 'Bob', 'age': 35, 'income': 40000},
    {'name': 'Alice', 'age': 27, 'income': 60000}
]

И мы хотим отсортировать этот список по возрастанию возраста. Мы не получим нужный результат если просто передадим наш список в sorted(). Нужно дополнительно указать ключ сортировки.

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

🟨 В нашем случае мы будем использовать лямбда-функцию, которая возвращает значение атрибута 'age' или 'income' каждого клиента в списке. Мы напишем key=lambda x: x['age'], чтобы указать, что мы хотим отсортировать список по возрастанию возраста клиентов. Если понадобится отсортировать список по другому атрибуту, то мы поменяем ключ на key=lambda x: x['нужный атрибут'].

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

sorted(client_list, key=lambda x: x['age'])

🟦 Аналогично, если вы хотите отсортировать список клиентов по убыванию их доходов - добавьте параметр reverse=True:

sorted(client_list, key=lambda x: x['income'], reverse=True)

🟪 Абсолютно таким же образом с помощью sorted() мы сможем отсортировать список объектов класса по некоторому атрибуту. Нам просто понадобится передать в key нужный нам атрибут: key=lambda x: x.age.

Таким образом, функция sorted() сокращает время на написание дополнительного кода и этим облегчает работу.

#python

🔥 Считаем скользящее среднее в PostgreSQL

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

🟡 Для примера, допустим у нас есть таблица sales с данными о продажах за определенный период времени:

date        | amount
------------+-------
2022-01-01  | 100
2022-01-02  | 200
2022-01-03  | 150
2022-01-04  | 50
2022-01-05  | 300

Чтобы посчитать скользящее среднее за последние три дня, удобнее всего использовать оконную функцию AVG(), указав определенный диапазон строк (ROWS BETWEEN 2 PRECEDING AND CURRENT ROW):

SELECT 
  date, 
  amount, 
  AVG(amount) OVER (
    ORDER BY date
    ROWS BETWEEN 2 PRECEDING 
    AND CURRENT ROW
  ) AS avg
FROM sales;

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

date        | amount | avg
------------+--------+--------
2022-01-01  | 100    | 100.00
2022-01-02  | 200    | 150.00
2022-01-03  | 150    | 150.00
2022-01-04  | 50     | 133.33
2022-01-05  | 300    | 166.67

🔵 Давайте разберем более подробно выражение ROWS BETWEEN 2 PRECEDING AND CURRENT ROW. Эта конструкция часто вызывает вопросы.

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

Например, в выражении ROWS BETWEEN 2 PRECEDING AND CURRENT ROW используется два ключевых слова - PRECEDING и CURRENT. Ключевое слово CURRENT определяет текущую строку, а PRECEDING - N предшествующих строк. Существует еще FOLLOWING, что означает - следующие строки.

Таким образом, ROWS BETWEEN 2 PRECEDING AND CURRENT ROW означает, что в окно будет включена текущая строка и две предыдущие строки.

Этот параметр может быть любым, например:

- ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW - включить все строки от начала таблицы до текущей строки
- ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING - включить текущую строку и ее соседние строки
- RANGE BETWEEN '1 day' PRECEDING AND '1 day' FOLLOWING - включить все строки, которые находятся в интервале от одного дня до другого

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

#sql