pandas.drop_duplicates: Держать='первый' и строка, которую он выбрал для вас

1. Два разных вопроса

Перед пояснением: восемь рядов, три повторяющихся порядковых номера. Скажите, сколько строк повторяются.

На вопрос есть два ответа, и какой из них вы хотите, решает все остальное.

df.duplicated().sum()                      1     whole rows repeated
df.duplicated(subset=["order_id"]).sum()   3     keys repeated

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

«Дубликат» не является свойством данных, это свойство сравниваемых столбцов. При сравнении каждого столбца возникает вопрос: «Является ли эта строка копией?». При сравнении ключей возникает вопрос: «Должна ли эта вещь появиться только один раз». Это разные вопросы и на них разные правильные ответы. drop_duplicates отвечу на любой ваш subset аргумент запрошен без комментариев по поводу выбора.

2. дублируется, а тройка сохраняется

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

df.duplicated()                 flags 1 row     keep='first', the default
df.duplicated(keep='last')      flags 1 row
df.duplicated(keep=False)       flags 2 rows

keep='first' помечает все, кроме первого из каждой группы, что вам и нужно, когда вы собираетесь его удалить. keep=False флаги Каждый член любой группы, которая имеет более одной, и это то, что вам нужно, когда вы собираетесь искать, потому что это дает вам все задействованные строки, а не только дополнительные.

Второй из двух более полезен при расследовании:

df[df.duplicated(subset=["order_id"], keep=False)]

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

3. drop_duplications и возвращаемые им строки

Один и тот же стол, четыре звонка и четыре разных ответа.

drop_duplicates()                                rows 7   units 46
drop_duplicates(subset=["order_id"])             rows 5   units 35
drop_duplicates(subset=["order_id"], keep="last") rows 5   units 37
drop_duplicates(subset=["order_id"], keep=False)  rows 2   units 16

От 8 рядов и 56 единиц до 7–2. Последнее является сюрпризом для большинства людей: keep=False здесь не означает «не оставлять дубликатов», это означает удалить каждую строку, входящую в любую группу из более чем одной, поэтому сохраняются только два порядковых номера, которые появляются ровно один раз.

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

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

4. Выживший выбирается по сорту

С keep="first" означает «в зависимости от того, что выше», способ сознательного выбора состоит в том, чтобы поместить нужную строку сверху, прежде чем ее удалять.

df.sort_values(["order_id", "units"]).drop_duplicates(subset=["order_id"])
     1003 keeps 3        total units 35

df.sort_values(["order_id", "units"], ascending=[True, False]) \
  .drop_duplicates(subset=["order_id"])
     1003 keeps 5        total units 37

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

Три вида, которые появляются постоянно:

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

5. Отметьте вместо удаления

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

df["seen"]     = df.groupby("order_id").cumcount() + 1
df["row_seen"] = df.groupby(list(df.columns)).cumcount() + 1

cumcount нумерует строки внутри каждой группы, начиная с нуля, поэтому добавление единицы дает удобочитаемый текст: «Я это вижу уже в н-й раз». Бегите по столу:

row  order_id  region  units  seen  row_seen
  0      1001   North      4     1         1
  1      1002   South     10     1         1
  2      1002   South     10     2         2
  3      1003   East       3     1         1
  4      1003   East       5     2         1
  5      1004   North      6     1         1
  6      1004   north      6     2         1
  7      1005   West      12     1         1

rows where the key repeats:  3
rows where the row repeats:  1
the rows worth looking at:   1003 and 1004

Строки 4 и 6 являются ключевыми. У обоих есть seen = 2 и row_seen = 1: номер заказа уже был виден, а эта точная строка — нет. Это две строки, в которых данные не согласуются сами с собой, и дедупликация одного столбца уничтожает обе без комментариев.

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

6. В pandas учитывается регистр, а в электронной таблице нет.

Перед пояснением: строки 5 и 6 идентичны, за исключением того, что одна область North а другой north. Скажите, есть ли drop_duplicates() рассматривает их как одну и ту же строку.

"North" == "north"                False
df["region"].nunique()            5    East, North, South, West, north
df["region"].str.lower().nunique() 4

Это не так. pandas точно сравнивает строки, так что это две разные строки, и обе выживают, вот почему drop_duplicates() по всем возвращенным столбцам Семь строки здесь.

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

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

key = df["region"].str.strip().str.casefold()

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

7. Индекс после

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

df.drop_duplicates(subset=["order_id"]).index      [0, 1, 3, 5, 7]

В индексе есть пробелы там, где были пропущенные строки, что правильно, но иногда неудобно. Это означает .iloc[2] и .loc[2] теперь ссылайтесь на разные строки, и все, что предполагает непрерывный индекс, включая некоторые построения графиков и конкатенацию, будет вести себя странно.

df.drop_duplicates(subset=["order_id"]).reset_index(drop=True).index   [0, 1, 2, 3, 4]

drop=True имеет значение: без него старый индекс сохраняется как новый столбец с именем index, что иногда полезно для отслеживания строки до исходного файла и обычно просто загромождает.

8. Считаем, а не опускаем

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

df["order_id"].value_counts().sort_index()

1001  1
1002  2
1003  2
1004  2
1005  1

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

Два взаимосвязанных пункта, которые стоит иметь рядом. df["order_id"].nunique() против len(df) сообщает вам размер проблемы в одном сравнении, здесь 5 против 8. И value_counts()[lambda s: s > 1] фильтрует прямо к нарушителям.

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

Пограничные случаи, которые стоит знать

Шесть, которые пройдут.

Пробелы. "North " и "North" разные, поэтому дубликаты прячутся за конечным пробелом и drop_duplicates сообщает, что ничего не нашел. Прежде чем сравнивать, разденьтесь.

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

Плавает. 10.0 и 10.000000001 — это разные строки и отображаются одинаково. Явно округляйте перед сравнением числового столбца.

Даты со временем. Две записи в один и тот же день имеют разные значения, если одна содержит 09:14. Нормализовать с помощью .dt.normalize() если день - это то, что вы имеете в виду.

Порядок столбцов в subset. Это не имеет значения для правильности, но имеет значение для чтения: перечислите столбцы в том порядке, в котором кто-то их произнесет, потому что этот список является вашим определением идентичности.

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