Удалить строки с дублирующимися индексами (Pandas DataFrame и TimeSeries)

252

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

                      Sta  Precip1hr  Precip5min  Temp  DewPnt  WindSpd  WindDir  AtmPress
Date                                                                                      
2001-01-01 00:00:00  KPDX          0           0     4       3        0        0     30.31
2001-01-01 00:05:00  KPDX          0           0     4       3        0        0     30.30
2001-01-01 00:10:00  KPDX          0           0     4       3        4       80     30.30
2001-01-01 00:15:00  KPDX          0           0     3       2        5       90     30.30
2001-01-01 00:20:00  KPDX          0           0     3       2       10      110     30.28

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

import pandas 
import datetime
startdate = datetime.datetime(2001, 1, 1, 0, 0)
enddate = datetime.datetime(2001, 1, 1, 5, 0)
index = pandas.DatetimeIndex(start=startdate, end=enddate, freq='H')
data1 = {'A' : range(6), 'B' : range(6)}
data2 = {'A' : [20, -30, 40], 'B' : [-50, 60, -70]}
df1 = pandas.DataFrame(data=data1, index=index)
df2 = pandas.DataFrame(data=data2, index=index[:3])
df3 = df2.append(df1)
df3
                       A   B
2001-01-01 00:00:00   20 -50
2001-01-01 01:00:00  -30  60
2001-01-01 02:00:00   40 -70
2001-01-01 03:00:00    3   3
2001-01-01 04:00:00    4   4
2001-01-01 05:00:00    5   5
2001-01-01 00:00:00    0   0
2001-01-01 01:00:00    1   1
2001-01-01 02:00:00    2   2

И поэтому мне нужно df3ровно стать:

                       A   B
2001-01-01 00:00:00    0   0
2001-01-01 01:00:00    1   1
2001-01-01 02:00:00    2   2
2001-01-01 03:00:00    3   3
2001-01-01 04:00:00    4   4
2001-01-01 05:00:00    5   5

Я подумал, что добавление столбца с номерами строк ( df3['rownum'] = range(df3.shape[0])) поможет мне выбрать самую нижнюю строку для любого значения DatetimeIndex, но я застрял в поиске операторов group_byor pivot(или ???), чтобы это работало.

python pandas

— Пол Х
источник

1

Другим способом получения дубликатов являются почасовыми данными в ночное время, когда часы устанавливаются обратно на летнее время: 1 А.М., 2, 3, 2, снова 3, 4 ...

— денис

468

Я бы предложил использовать дублированный метод на самом Индексе Панд:

df3 = df3.loc[~df3.index.duplicated(keep='first')]

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

Используя предоставленные образцы данных:

>>> %timeit df3.reset_index().drop_duplicates(subset='index', keep='first').set_index('index')
1000 loops, best of 3: 1.54 ms per loop

>>> %timeit df3.groupby(df3.index).first()
1000 loops, best of 3: 580 µs per loop

>>> %timeit df3[~df3.index.duplicated(keep='first')]
1000 loops, best of 3: 307 µs per loop

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

Также следует отметить, что этот метод также работает MultiIndex(с использованием df1, как указано в примере Пола ):

>>> %timeit df1.groupby(level=df1.index.names).last()
1000 loops, best of 3: 771 µs per loop

>>> %timeit df1[~df1.index.duplicated(keep='last')]
1000 loops, best of 3: 365 µs per loop

— n8yoder
источник

3

locможет не быть необходимым. Просто сделайте df3 = df3[~df3.index.duplicated(keep='first')], что отбросит все строки с дублирующимся индексом, кроме первого вхождения.

— Линцзянконг

1

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

— cheesus

1

что делает ~ в df3 = df3.loc [~ df3.index.duplicated (keep = 'first')], если кто-то не против ответить?

— jsl5703

3

@ jsl5703 Это меняет маску. Так получается все, что было True False и наоборот. В этом случае это означает, что мы выберем те, которые не дублируются в соответствии с методом.

— n8yoder

115

Мой оригинальный ответ, который сейчас устарел, хранится для справки.

Простое решение заключается в использовании drop_duplicates

df4 = df3.drop_duplicates(subset='rownum', keep='last')

Для меня это работало быстро на больших наборах данных.

Для этого необходимо, чтобы столбец с дубликатами был «rownum». В модифицированном примере «rownum» не имеет дубликатов, поэтому ничего не удаляется. То, что мы действительно хотим, это чтобы столбцы были установлены в индекс. Я не нашел способ указать drop_duplicates, чтобы рассматривать только индекс.

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

df3 = df3.reset_index().drop_duplicates(subset='index', keep='last').set_index('index')

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

df3 = df3.sort()

— DA
источник

10

Еще одна вариация на этот счет:df.reset_index().drop_duplicates(cols='index',take_last=True).set_index('index')

— Лучано

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

— n8yoder

Если вашим индексом является MultiIndex, reset_index()добавляются столбцы level_0, level_1 и т. Д. И если у вашего индекса есть имя, это имя будет использоваться вместо метки «index». Это делает это немного больше, чем одной строкой, чтобы сделать это правильно для любого DataFrame. index_label = getattr(df.index, 'names', getattr(df.index, 'name', 'index'))то cols=index_labelтогда set_index(index_labels)и даже это не является надежным (не будет работать на неназванные multiindexes).

— конфорки

1

Перемещение индекса в столбец, очистка дубликатов и сброс индекса были удивительными, это было именно то, что мне было нужно!

— mxplusb

Учитывая idx = df.index.name or 'index', что можно также сделать, df2 = df.reset_index(); df2.drop_duplicates(idx, inplace=True); df2.set_index(idx, inplace=True)чтобы избежать промежуточных копий (из-за inplace=True)

— Анакханд

67

Боже мой Это на самом деле так просто!

grouped = df3.groupby(level=0)
df4 = grouped.last()
df4
                      A   B  rownum

2001-01-01 00:00:00   0   0       6
2001-01-01 01:00:00   1   1       7
2001-01-01 02:00:00   2   2       8
2001-01-01 03:00:00   3   3       3
2001-01-01 04:00:00   4   4       4
2001-01-01 05:00:00   5   5       5

Follow up edit 2013-10-29 В случае, если у меня довольно сложный MultiIndex, думаю, я предпочитаю groupbyподход. Вот простой пример для потомков:

import numpy as np
import pandas

# fake index
idx = pandas.MultiIndex.from_tuples([('a', letter) for letter in list('abcde')])

# random data + naming the index levels
df1 = pandas.DataFrame(np.random.normal(size=(5,2)), index=idx, columns=['colA', 'colB'])
df1.index.names = ['iA', 'iB']

# artificially append some duplicate data
df1 = df1.append(df1.select(lambda idx: idx[1] in ['c', 'e']))
df1
#           colA      colB
#iA iB                    
#a  a  -1.297535  0.691787
#   b  -1.688411  0.404430
#   c   0.275806 -0.078871
#   d  -0.509815 -0.220326
#   e  -0.066680  0.607233
#   c   0.275806 -0.078871  # <--- dup 1
#   e  -0.066680  0.607233  # <--- dup 2

и вот важная часть

# group the data, using df1.index.names tells pandas to look at the entire index
groups = df1.groupby(level=df1.index.names)  
groups.last() # or .first()
#           colA      colB
#iA iB                    
#a  a  -1.297535  0.691787
#   b  -1.688411  0.404430
#   c   0.275806 -0.078871
#   d  -0.509815 -0.220326
#   e  -0.066680  0.607233

— Пол Х
источник

если у них есть имена, в противном случае (если одно имя None), скажем, level=[0,1]будет работать, если есть 2 уровня df1.groupby(level=[0,1]).last(). Это должно быть частью Pandas в качестве дополнения кdrop_duplicates

— dashesy

@dashesy да. Использование df.index.names- это простой способ группировки по всем уровням индекса.

— Пол Х

Отличное решение, спасибо! Я также добавлю, что это работает xarrayдля работы с дублирующимися индексами DateTime, которые делают ds.resampleи ds.groupbyоперации терпят неудачу

— drg

Поправка к моему предыдущему комментарию: он работает xarrayдо тех пор, пока вы не измените измерение grouped = df3.groupby(level=0)на grouped = df3.groupby(dim='time')или содержащее дубликаты

— drg

4

К сожалению, я не думаю, что Pandas позволяет сбрасывать спады с индексов. Я бы предложил следующее:

df3 = df3.reset_index() # makes date column part of your data
df3.columns = ['timestamp','A','B','rownum'] # set names
df3 = df3.drop_duplicates('timestamp',take_last=True).set_index('timestamp') #done!

— user128754
источник

1

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

df3 = df3.query('~index.duplicated()')

Это позволяет создавать цепочки операторов следующим образом:

df3.assign(C=2).query('~index.duplicated()').mean()

— bbiegel
источник

Я попробовал это, но не смог заставить его работать .. Я получаю ошибку вроде этого: TypeError: 'Series' objects are mutable, thus they cannot be hashed.. Это на самом деле работает для вас?

— Онно Эберхард

1

Удалить дубликаты (Keeping First)

idx = np.unique( df.index.values, return_index = True )[1]
df = df.iloc[idx]

Удалить дубликаты (Сохраняя последний)

df = df[::-1]
df = df.iloc[ np.unique( df.index.values, return_index = True )[1] ]

Тесты: 10 тыс. Циклов с использованием данных OP

numpy method - 3.03 seconds
df.loc[~df.index.duplicated(keep='first')] - 4.43 seconds
df.groupby(df.index).first() - 21 seconds
reset_index() method - 29 seconds

— Mott The Tuple
источник