💥 3 лайфхака по считыванию csv-файла в Python 💥

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

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

🔵 Первый лайфхак

Иногда при больших исходных данных работать приходится только с некоторым количеством из них. И если заранее известно, что из условно 10 миллионов строк вам будет достаточно только 1000, задайте в read_csv параметр nrows. Это позволит сэкономить и память, и время.

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

#Было
df = pd.read_csv('file.csv')
new_df = df[:1000].copy()
del df
_______
#Стало
df = pd.read_csv('file.csv', 
               nrows = 1000)

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

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

#Было
df = pd.read_csv('file.csv')
df = df[['col1', 'col2', 
         'col3']]
________
#Стало
df = pd.read_csv('file.csv', 
     usecols = ['col1', 'col2', 
                'col3'])

🟢 Третий лайфхак, но не по важности - skiprows. Например, если файл содержит несколько строк заголовка или метаданные в начале файла, которые нет необходимости обрабатывать, можно легко их пропустить.

То есть если вы передадите список [0, 1, 2], то будут пропущены первые три строки:

df = pd.read_csv('file.csv', 
       skiprows = [0, 1, 2])

💡 Более того, вы можете не просто пропустить несколько идущих подряд строк, вы можете передать в skiprows функцию, которая определит, какие строки необходимо сохранить, а какие можно пропустить. 

Например, известно, что в файле каждая вторая строка пустая, просто передайте в skiprows лямбда-функцию:

df = pd.read_csv('file.csv', 
          skiprows=lambda x: 
              (x % 2) != 0))

В нашем 👉 Симуляторе «Аналитик данных» 👈 в модуле по Python эти уловки вам точно пригодятся, ведь вы будете работать с файлами (логами, выгрузками и таблицами) из реального бизнеса от наших партнеров!

#python #pandas

🔥 А вы часто используете оператор UNION в SQL?

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

Поэтому предлагаем познакомиться поближе с этим оператором.

🟢 Как представить себе UNION?

Мы предлагаем представить, что UNION укладывает один набор результатов запроса SELECT или строк поверх другого, получая своеобразный стек. Причем это существенно отличается от «джоинов». С помощью JOIN мы присоединяем колонки сбоку, а в UNION - добавляем строки снизу, и никаких дополнительных колонок.

Допустим, у нас есть две таблицы employees и managers, содержащие следующую информацию:

Таблица employees:

| id | name | age | salary |
|----|------|-----|--------|
| 1  |Alice | 25  | 40.000 |
| 2  |Bob   | 30  | 50.000 |
| 3  |Eve   | 35  | 60.000 |

Таблица managers:

| id | name | age |  depart   |
|----|------|-----|-----------|
| 4  |Ben   | 40  | Sales     |
| 5  |David | 45  | Marketing |

Чтобы объединить эти таблицы, мы можем использовать оператор UNION:

SELECT id, name, age
FROM employees
UNION
SELECT id, name, age
FROM managers;

Результатом будет следующая таблица:

| id | name | age |
|----|------|-----|
| 1  |Alice | 25  | 
| 2  |Bob   | 30  | 
| 3  |Eve   | 35  |
| 4  |Ben   | 40  |
| 5  |David | 45  |

Если бы в таблицах были дубликаты строк, то они бы удалились. Если нам нужно сохранить дубликаты, то следует использовать оператор UNION ALL.

🔵 Пара моментов, заслуживающих внимания:

1. Как отмечалось ранее, общее количество колонок в обоих запросах с UNION должно быть одинаково. Равно как и тип данных этих колонок.

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

SELECT id, name, age
FROM employees
UNION
SELECT id, name, age
FROM managers
ORDER BY 1;

🤔 Уже есть идеи, в каких прикладных задачах не обойтись без оператора UNION?

#sql

🔥 Избегайте этого при работе с Pandas

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

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

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

# сначала выбираем столбец, затем строку
%timeit df['col']['row']  
#2.96 µs

# наоборот - строка, затем столбец
%timeit df.loc['row']['col']   
#45.4 µs

❓Почему это происходит?

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

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

# выбираем столбец (смежные блоки памяти) 
%timeit df['my_column']   
# 1.73 µs

# выбираем строку (несмежные)
%timeit df.iloc[0]   
# 38.4 µs

✅ В примере выше, извлечение более 32 миллионов элементов столбца оказалось более чем в 20 раз быстрее, чем извлечение всего девяти элементов, хранящихся в строке.

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

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

Так что запоминайте: сначала столбец, а потом строка 💡


Присоединяйтесь к нашим студентам 👉 Симулятора «Аналитик данных» 👈, чтобы не просто уметь решать рабочие кейсы, а знать, как это делать оптимально!

#python #pandas

🔥 Задача с собеседования по SQL

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

🔹 Итак, условие!

Есть таблица table_A. Необходимо перевернуть её таким образом, чтобы id оставались в том же порядке, но значения столбца N были в обратном порядке.

 table_A          Result

| id | N |      | id | N |
|----|---|      |----|---|
| 1  | A |      | 1  | F |
| 2  | B |      | 2  | E |
| 3  | C | ---> | 3  | D |
| 4  | D |      | 4  | C |
| 5  | E |      | 5  | B |
| 6  | F |      | 6  | A |

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

🤔 Согласитесь, тут очень напрашивается JOIN, но как бы его сделать?

А ведь если бы мы имели такую же табличку с колонкой rev (обратные индексы), например, мы могли бы по ней как раз сделать JOIN. По условию t1.id = t2.rev. Например, как здесь:

 table_A          table_B

| id | N |   | id | N |

rev

|
|----|---|   |----|---|----|
| 1  | A |   | 1  | A | 6  |
| 2  | B |   | 2  | B | 5  |
| 3  | C |-->| 3  | C | 4  |
| 4  | D |   | 4  | D | 3  |
| 5  | E |   | 5  | E | 2  |
| 6  | F |   | 6  | F | 1  |

Как создать rev? Воспользуемся оконной функцией ROW_NUMBER, пронумеровав все строки в обратном от столбца id порядке!

Теперь мы можем написать запрос:

SELECT a.id, b.N
FROM table_A a 
INNER JOIN (
    SELECT *, 
    ROW_NUMBER() over 
    (order by id DESC) as rev 
    FROM table_A
    ) b 
ON a.id = b.rev

🔸 И получаем то, что нам и необходимо:

| id | N |
|----|---|
| 1  | F |
| 2  | E |
| 3  | D |
| 4  | C |
| 5  | B |
| 6  | A |

🔻 Кстати, если вы хотите подготовиться к собеседованию по SQL или Python, заходите на нашу платформу 👉 IT Resume 👈! Там вы найдете много полезного 😉

#sql #interview_problems

🔥 А вы активно используете match/case в Python?

Это достаточно новая конструкция, введенная в Python 3.10, которая позволяет нам написать более читаемый и лаконичный код при обработке различных вариантов значений. Из-за ее «молодости» не все о ней знают, но она может быть очень полезна и даже удобнее, чем if/else. Давайте проверим!

🟢 Что такое match/case?

Это способ сопоставления значения с набором шаблонов и выполнения соответствующего блока кода для первого подходящего шаблона. Подобное по функциональности можно встретить в других языках программирования под названием switch/case. Однако в Python match/case стал еще мощнее и гибче.

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

def http_status(status_code):
   match status_code:
      case 200:
         return "OK"
      case 400:
         return "Bad Request"
      case 404:
         return "Not Found"
      case 500:
         return "Internal 
                Server Error"
      case _:
         return "Unknown Status"

print(http_status(200))   
# OK

print(http_status(400))   
# Bad Request

print(http_status(404))   
# Not Found

print(http_status(500))   
# Internal Server Error

print(http_status(403))   
# Unknown Status

Здесь мы определяем функцию http_status, которая принимает аргумент status_code. С помощью конструкции match мы проверяем значение status_code и возвращаем соответствующий текстовый статус для первого подходящего шаблона. Если ни один из шаблонов не подходит, мы используем шаблон _, чтобы вернуть "Unknown Status".

🔵 А что такое шаблон _?

Шаблон _ представляет собой своего рода «по умолчанию» в конструкции match/case. Если ни один из описанных шаблонов не совпадает с переданным значением, то выполняется блок кода, соответствующий шаблону _. Это позволяет предусмотреть обработку всех возможных вариантов, даже тех, которые не перечислены явно.

Согласитесь, что match/case делает наш код более легким для чтения. Мы можем сразу видеть все возможные варианты значений и обрабатывать их отдельно.

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

❓ А вы уже пробовали использовать match/case в Python? Расскажите о своем опыте в комментариях!

#python

🔥 Что еще может match/case в Python

Продолжаем нашу серию постов о match/case! Здорово, что вам так понравилась эта конструкция! Кто-то уже оказался знаком с ней, а для кого-то это стало новым знанием.

В предыдущем посте мы рассмотрели простой пример использования match/case и, как верно заметили наши подписчики, его действительно можно заменить и dict.get() и вполне сносным if/else. Но возможности этой конструкции не ограничиваются только этим.

🟣 Давайте рассмотрим более сложный случай, в котором использование if/else становится неудобным.

Представьте, что у нас есть функция make_point, которая принимает на вход координаты точки. Наша задача - создать объект класса Point3D и инициализировать его соответствующими значениями.

Для начала определим класс:

from dataclasses import dataclass

@dataclass
class Point3D:
    x: int
    y: int
    z: int

📝 А теперь напишем нашу функцию с использованием if/else.

def make_point(point):
  # Проверяем тип
  if isinstance(point, 
              (tuple, list)):  
    # Проверяем длину
    if len(point) == 2:  
      x, y = point
      return Point3D(x, y, 0)
    elif len(point) == 3:
      x, y, z = point  
      return Point3D(x, y, z)
    else:
      raise TypeError("Unsupported")
  else:
    raise TypeError("Unsupported")

❗️ Здесь мы пишем достаточно сложную цепочку вложенных операторов, а также явно проверяем тип, длину и распаковываем переменные. Это усложняет чтение и понимание кода.

Но используя match/case мы можем написать более чистый и выразительный код:

def make_point(point):
  match point:
    case (x, y):
      return Point3D(x, y, 0)
    case (x, y, z):
      return Point3D(x, y, z)
    case _:
      raise 
      TypeError("Unsupported")

👉 В первом case мы сопоставляем точку с двумя элементами (x, y) и создаем объект Point3D с координатами (x, y, 0). Во втором case сопоставляем точку с тремя элементами (x, y, z) и создаем объект Point3D с указанными координатами. В случае, если ни одно из сопоставлений не произошло, мы генерируем исключение TypeError.

🔍 Протестируем работу функции make_point:

make_point((1, 2))
# Point3D(x=1, y=2, z=0)

make_point([1, 2, 3])
# Point3D(x=1, y=2, z=3)

make_point((1, 2, 3, 4))
# TypeError: Unsupported

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

🌟 А если вам интересно, мы можем рассказать о том, как работать со словарями и списками в match/case. Хотите узнать больше?

Проверьте, можно ли решить 👉 задачу 👈 с использованием конструкции match/case!

🔥 Новые крутые фичи на платформе IT Resume

На нашей платформе с задачами по программированию IT Resume произошли большие обновления, и мы спешим с вами поделиться ☺️

💥 Во-первых, вот несколько новых крутых задач, которые вам точно стоит порешать:

[Тестовое Тинькофф] Отчет о зарплате

Это задача по SQL из тестового задания в Тинькофф на позицию Аналитика. Кстати, на платформе есть еще несколько задач из этого цикла - некоторые совсем простые, а над некоторыми придется крепко подумать.

🔗 Ссылка на задачу: ссылка


Сделать из широкой таблицы длинную

Классическая задача на pivot-unpivot в SQL. Недавно сразу 2 человека сказали нам, что встретили эту задачу на собеседованиях в разные компании, поэтому мы решили включить ее сегодня в подборку - обязательно порешайте!

🔗 Ссылка на задачу: ссылка


Поиск опасности

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

🔗 Ссылка на задачу: ссылка


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

Решения других пользователей

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

Цветовые схемы в редакторе кода

Теперь вы можете выбрать одну из 4 цветовых тем в редакторе кода, когда решаете задачи. Если любите темную тему - попробуйте cobalt или material, а если светлую - вам зайдет 3024-day.

Шорткаты и автокомплит

Да, долгожданная фича - теперь вы можете отправлять код на проверку/выполнение нажатием одной клавиши, а также воспользоваться автоматическим дополнением кода 🔥

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

🔗 Ссылка на платформу 👉 ссылка 👈

🔥 SQL vs Excel

Мы частенько встречаем в требованиях к аналитику - умение пользоваться Excel. Это действительно широко используемый инструмент работы с данными. Но когда дело доходит до сложных анализов и больших объемов данных, есть более удобный и иногда незаменимый инструмент – SQL.

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

🟢 COUNT, SUM, AVG

Excel – рабочая лошадка, этот инструмент хорош в вопросах подсчета, суммирования и вычисления среднего. Но когда работать приходится даже с 5000+ строками, он сдает позиции. А для SQL это не проблема, он может сделать те же вычисления и объемы его не пугают:

SELECT COUNT(col) AS count_row,
SUM(col) AS sum_total,
AVG(col) AS avg_total
FROM table;


С SQL вы получите результаты быстро даже для миллионов записей. Чистая магия! 🔮

🔵 GROUP BY

Одной из ключевых особенностей SQL является группировка данных с помощью GROUP BY. В Excel это можно реализовать с помощью сложных формул или использования сводных таблиц, но это требует куда больше усилий и времени. А SQL легко группирует ваши данные и применяет агрегатные функции к каждой группе:

SELECT category_name, COUNT(*) 
       AS count_products
FROM products
GROUP BY category_name;

Удобно, правда?

🟣 Оконные функции

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

SELECT date,
       value,
       AVG(value) OVER (
       ORDER BY date ROWS 
       BETWEEN 2 PRECEDING 
       AND CURRENT ROW) 
       AS rolling_average
FROM table_name;

Быстро, легко и главное – коротко!

Итак, можно с уверенностью сказать, что Excel – неплохой выбор для небольших объемов данных, но SQL – это босс. Изучив SQL вы сделаете свою аналитику эффективной и удобной! Поэтому время начать учить SQL и перейти на новый уровень аналитической мощи! 💥

📢 Приглашаем вас на наш Симулятор «Аналитик данных», где мы не просто рассказываем теорию по SQL, Python, продуктовым метрикам и другим темам, но и даем много задач из реальной работы аналитика!

#sql

🔍 Быстро и надежно: Избегаем проблем с NumPy! 🔍

Аналитики знают, что NumPy - это мощный инструмент для численных вычислений. Однако, существует одна тонкость, о которой стоит помнить.

Если в массиве NumPy присутствует значение NaN (Not a Number), некоторые агрегатные функции могут вернуть неожиданный результат. И это может оказаться совсем не то, чего вы ожидаете!

import numpy as np
arr = np.array([1, 2, 3, np.NaN])
np.sum(arr)     # nan
np.mean(arr)    # nan
np.max(arr)     # nan

Но не беспокойтесь, у нас есть решение! 👇

🔵 Во-первых, хорошей практикой является проверка массива на наличие значений NaN и их замена, например, на 0. Это поможет избежать проблем в большинстве случаев.

🟠 Однако, есть ещё один способ избежать проблем, который предлагает сам NumPy. Для тех, кто хочет быть на высоте, существуют специальные методы, нечувствительные к значениям NaN! 🚀

Например, вместо использования функций np.sum, np.mean, np.max и др., вы можете воспользоваться np.nansum, np.nanmean, np.nanmax и другими аналогичными методами.

import numpy as np
arr = np.array([1, 2, 3, np.NaN])
np.nansum(arr)      # 6.0
np.nanmean(arr)     # 2.0
np.nanmax(arr)      # 3.0

Их особенностью является то, что они игнорируют значения NaN в массиве и возвращают результат, как будто эти значения не существуют.

Теперь, даже если где-то в вашем массиве присутствует хотя бы одно значение NaN, это уже не повлияет на все остальные вычисления! Вы получите верные и надежные результаты! 💪

💬 Пишите в комментариях, если вам пригодился этот совет или если у вас есть свои хитрости по работе с NumPy! 📚

#python #numpy

🔥 Как извлекать данные из JSON в PostgreSQL?

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

💡 Сразу обозначим примерный JSON, с которым будем работать:

{
"name": "Ivan Ivanov",
"age": 25,
"person": {
"address": {
"city": "Moscow",
"street": "Pushkina str"
},
"phone": "+7 904 111 22 33"
},
"items": [
{
"name": "Item 1",
"price": 1000
},
{
"name": "Item 2",
"price": 1500
},
{
"name": "Item 3",
"price": 2000
}
]
}
Итак, приступим к разбору!

🔹 Оператор ->

Оператор -> позволяет получать значение определенного поля из JSON-документа по ключу. Для этого необходимо указать путь к нужному полю. Рассмотрим пример:

SELECT json_data -> 'name' 
AS name 
FROM my_table;

Здесь мы извлекаем значение поля name из JSON-документа. Результатом будет столбец name с извлеченными значениями, в нашем случае "Ivan Ivanov" (кавычки так же сохранятся).

🔹 Оператор ->>

Оператор ->> используется для извлечения значения поля в типе text. В отличие от оператора ->, который возвращает значение в формате JSON. Например, получим текстовое значение поля age:

SELECT json_data ->> 'age' 
AS age 
FROM my_table;

Или, аналогично прошлому примеру, можем использовать оператор ->>, чтобы получить результат в текстовом формате.

🔹 Извлечение элементов массива

JSON также позволяет хранить данные в виде массивов. Используя операторы -> и ->>, мы можем извлекать значения элементов массива по индексу. Извлечем первый элемент из массива items:

SELECT json_data-> 'items'-> 0 
AS first_item 
FROM my_table;

🔹 Использование пути для извлечения данных

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

SELECT json_data -> 'person' ->
'address' ->> 'city' AS city 
FROM my_table;

В этом примере мы извлекаем значение поля city, находящегося во вложенном объекте address, который в свою очередь находится в объекте person.

💡 Знание и использование операторов -> и ->> для извлечения данных из JSON в PostgreSQL дает широкие возможности для работы с гибкими иерархическими структурами данных. Это помогает извлекать нужные значения и использовать их в запросах.

P.S. Если вы хотите попробовать самостоятельно запросы из поста, вам понадобится предварительно создать табличку с JSON-файлом. Вы можете сделать это так:

CREATE TABLE my_table (
id serial NOT NULL PRIMARY KEY,
json_data json NOT NULL
);

INSERT INTO my_table (json_data)
VALUES('здесь ваш JSON-файл');

#sql

🔥 Match/case со списками и словарями

Признавайтесь, ждали ли вы наш заключительный пост о нашем новом знакомом - match/case? Сегодня испробуем, как он может работать со списками и словарями.

🟢 Надеемся вы уже убедились, что возможности у match/сase огромные. И они далеки от обычного if/else. Со списками, например, мы можем сопоставлять индексы, значения и даже длину списка! Например:

- Используем _ в качестве wildcard (и мы можем добавлять их сколь угодно много)
- Мы можем извлечь значения, присвоив им имя (case [i1, i2, i3])
- *_ звездочка-подчеркивание используется, чтобы брать все оставшиеся элементы

Смотрите код, который у нас получился, на карточке 1 😉

🔵 Что еще можно сделать?

Мы также можем следить за расположением элементов. Например подберем:

- Любой список, начинающийся с А
- Любой список из 3 предметов, начинающийся с Б, а затем А ИЛИ С
- Любой список, где второй элемент с конца - Д

Код с фруктами на карточках 2-3 😉

🟣 Можем ли мы мэтчить словари?

Конечно да! Мы даже можем быть очень точными в наших мэтчах. Например:

- Смэтчить любой словарь с ключом name
- Смэтчить любую str, если она состоит из заглавных букв

Код на карточке 4!

💡 Обратите внимание, что мы проверяем типы, добавляя скобки () после типа класса. И несмотря на то, что мы использовали только str(), это также будет работать и для int().

🔥 Вот такие удивительные вещи может match/case! Расскажите, приходилось ли вам уже использовать его в работе, или вы раньше не были знакомы с этой конструкцией? Или может вы думали, что это простой switch/case? 🤪

#python

🔥 Полезная команда для анализа данных!

Сегодня хотим обсудить с вами удивительную тему в PostgreSQL, которая поможет вам ускорить и улучшить свои аналитические запросы - материализованные представления (Materialized Views).

🟢 Что такое материализованные представления?

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

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

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

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

1️⃣ Во-первых, это ускорит запросы: Поскольку данные уже предварительно вычислены и сохранены в таблице, выполнение запросов становится намного быстрее.

2️⃣ Во-вторых, снизит нагрузки на базу данных: Представления обновляются только по мере необходимости, что позволяет снизить количество обращений к базовым таблицам и оптимизировать работу с данными.

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


🔵 Как создать материализованное представление:

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

1️⃣ Написать запрос, который будет формировать данные для представления.

2️⃣ Создать материализованное представление с помощью команды CREATE MATERIALIZED VIEW.

3️⃣ Определить опции материализованного представления (столбцы, условия фильтрации и сортировки данных, а также права доступа для пользователей или ролей).

4️⃣ Указать опцию REFRESH MATERIALIZED VIEW для обновления данных представления по мере необходимости. Вы можете настроить автоматическое обновление представления или выполнять его вручную.

🎯 Пример

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

-- Создание материализованного представления
CREATE MATERIALIZED VIEW 
         monthly_sales AS
SELECT DATE_TRUNC('month', 
         order_date) AS month,
       SUM(sales_amount) AS 
         total_sales
FROM sales_data
GROUP BY month;

-- Обновление данных в представлении
REFRESH MATERIALIZED VIEW monthly_sales;

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

💥 В нашем Симуляторе «Аналитик данных» мы раскрываем еще больше возможностей SQL, Python и других инструментов аналитика!

#sql

🔥 Pandas vs SQL

Мы уже написали множество постов для тех, кто работает с Pandas, еще больше для тех, кто работает с SQL. А что, если среди нас все еще остались те, кто пользуется только одним из этих инструментов? 🤔

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

🔎 В карточках под постом мы представили некоторые операции в Pandas и их соответствующие аналоги в SQL 👇

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

#sql #pandas