В чем разница между отдельными () и dropDuplicates () в Spark?

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

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

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

Отличный () метод

distinct()

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

distinct() вернет отдельные строки DataFrame. В качестве примера рассмотрим следующий DataFrame

>>> df.show()
+---+------+---+                                                                
| id|  name|age|
+---+------+---+
|  1|Andrew| 25|
|  1|Andrew| 25|
|  1|Andrew| 26|
|  2| Maria| 30|
+---+------+---+

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

>>> df.distinct().show()

+---+------+---+
| id|  name|age|
+---+------+---+
|  1|Andrew| 26|
|  2| Maria| 30|
|  1|Andrew| 25|
+---+------+---+

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

>>> df.select(['id', 'name']).distinct().show()
+---+------+
| id|  name|
+---+------+
|  2| Maria|
|  1|Andrew|
+---+------+

Это означает, что возвращенный DataFrame будет содержать только подмножество столбцов, которые использовались для устранения дубликатов. В таком случае, вероятно, distinct() не поможет.

Метод dropDuplicates ()

dropDuplicates(subset=None)

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

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

drop_duplicates() - это псевдоним для dropDuplicates().

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

>>> df.dropDuplicates().show()
+---+------+---+
| id|  name|age|
+---+------+---+
|  1|Andrew| 26|
|  2| Maria| 30|
|  1|Andrew| 25|
+---+------+---+

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

df.dropDuplicates(['id', 'name']).show()
+---+------+---+
| id|  name|age|
+---+------+---+
|  2| Maria| 30|
|  1|Andrew| 25|
+---+------+---+

Заключение

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

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