Pandas DataFrame: как изначально получить минимальный диапазон строк и столбцов

У меня есть Pandas DataFrame, который похож на этот, но с 10 000 строк и 500 столбцов.

Мой Dataframe

Для каждой строки я хотел бы найти минимальное значение между 3 днями назад в 15:00 и сегодня в 13:30.

Есть ли какой-нибудь собственный способ numpy сделать это быстро? Моя цель - получить минимальное значение для каждой строки, сказав что-то вроде "каково минимальное значение от 3 дней назад назад 15:00 до 0 дней назад (ака сегодня) 13:30?"

Для этого конкретного примера ответы для двух последних строк будут следующими:

2011-01-09 2481.22
2011-01-10 2481.22

Мой текущий способ:

1. Get the earliest row (only the values after the start time)
2. Get the middle rows 
3. Get the last row (only the values before the end time)
4. Concat (1), (2), and (3)
5. Get the minimum of (4)

Но это занимает очень много времени на большом DataFrame

Следующий код сгенерирует аналогичный DF:

import numpy
import pandas
import datetime

numpy.random.seed(0)

random_numbers = (numpy.random.rand(10, 8)*100 + 2000)
columns        = [datetime.time(13,0) , datetime.time(13,30), datetime.time(14,0), datetime.time(14,30) , datetime.time(15,0), datetime.time(15,30) ,datetime.time(16,0), datetime.time(16,30)] 
index          = pandas.date_range('2011/1/1', '2011/1/10')
df             = pandas.DataFrame(data = random_numbers, columns=columns, index = index).astype(int)

print df

Вот json-версия блока данных:

'{ "13:00:00": { "1293840000000": 2085, "1293926400000" : 2062, "1294012800000" : 2035, "1294099200000" : 2086, "1294185600000": 2006, "1294272000000": 2097, "1294358400000" : 2078, "1294444800000" : 2055, "1294531200000" : 2023, "1294617600000" : 2024}, "13:30:00": { "1293840000000": 2045, "1293926400000" : 2039, "1294012800000" : 2035, "1294099200000" : 2045, "1294185600000": 2025, "1294272000000": 2099, "1294358400000" : 2028, "1294444800000" : 2028, "1294531200000" : 2034, "1294617600000" : 2010}, "14:00: 00": { "1293840000000" : 2095, "1293926400000" : 2006, "1294012800000" : 2001, "1294099200000" : 2032, "1294185600000" : 2022, "1294272000000" : 2040, "1294358400000": 2024, "1294444800000": 2070, "1294531200000" : 2081, "1294617600000" : 2095}, "14:30:00": { "1293840000000": 2057, "1293926400000" : 2042, "1294012800000" : 2018, "1294099200000" : 2023, "1294185600000" : 2025, "1294272000000" : 2016, "1294358400000": 2066, "1294444800000": 2041 "1294531200000": 2098, "1294617600000" : 2023}, "15:00:00": { "1293840000000": 2082, "1293926400000" : 2025, "1294012800000" : 2040, "1294099200000" : 2061, "129418 5600000": 2013, "1294272000000" : 2063, "1294358400000": 2024, "1294444800000": 2036, "1294531200000": 2096, "1294617600000" : 2068}, "15:30:00": { "1293840000000": 2090 "1293926400000" : 2084, "1294012800000" : 2092, "1294099200000" : 2003, "1294185600000": 2001, "1294272000000": 2049, "1294358400000" : 2066, "1294444800000" : 2082, "1294531200000" : 2090, "1294617600000" : 2005}, "16:00:00": { "1293840000000" : 2081, "1293926400000" : 2003, "1294012800000" : 2009, "1294099200000" : 2001, "1294185600000" : 2011, "1294272000000": 2098, "1294358400000" : 2051, "1294444800000" : 2092, "1294531200000" : 2029, "1294617600000" : 2073}, "16:30:00": { "1293840000000": 2015, "1293926400000" : 2095, "1294012800000" : 2094, "1294099200000" : 2042, "1294185600000": 2061, "1294272000000": 2006, "1294358400000" : 2042, "1294444800000" : 2004, "1294531200000" : 2099, "1294617600000" : 2088}}р >

ОТВЕТЫ

Ответ 1

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

first, last = ('2011-01-07', datetime.time(15)), ('2011-01-10', datetime.time(13, 30))
df.stack().loc[first: last].min()

Результатом df.stack является Series с a MultiIndex, где внутренний уровень состоит из исходных столбцов. Затем мы нарезаем, используя пары tuple с датой начала и окончания и временем. Если вы собираетесь делать много таких операций, вам следует рассмотреть возможность назначения df.stack() некоторой переменной. Затем вы можете рассмотреть возможность изменения индекса на правильный DatetimeIndex. Затем вы можете работать как с временными рядами, так и с форматом сетки по мере необходимости.

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

first_row = df.index.get_loc(first[0])
last_row = df.index.get_loc(last[0])
if first_row == last_row:
    result = df.loc[first[0], first[1]: last[1]].min()
elif first_row < last_row:
    first_row_min = df.loc[first[0], first[1]:].min()
    last_row_min = df.loc[last[0], :last[1]].min()
    middle_min = df.iloc[first_row + 1:last_row].min().min()
    result = min(first_row_min, last_row_min, middle_min)
else: 
    raise ValueError('first row must be <= last row')

Обратите внимание, что если first_row + 1 == last_row, то middle_min есть nan, но результат все равно правильный, если middle_min не приходит первым в вызове min.

Ответ 2

Возьмем следующий пример, это легче понять.

|            | 13:00:00 | 13:30:00 | 14:00:00 | 14:30:00 | 15:00:00 | 15:30:00 | 16:00:00 | 16:30:00 | 
|------------|----------|----------|----------|----------|----------|----------|----------|----------| 
| 2011-01-01 | 2054     | 2071     | 2060     | 2054     | 2042     | 2064     | 2043     | 2089     | 
| 2011-01-02 | 2096     | 2038     | 2079     | 2052     | 2056     | 2092     | 2007     | 2008     | 
| 2011-01-03 | 2002     | 2083     | 2077     | 2087     | 2097     | 2079     | 2046     | 2078     | 
| 2011-01-04 | 2011     | 2063     | 2014     | 2094     | 2052     | 2041     | 2026     | 2077     | 
| 2011-01-05 | 2045     | 2056     | 2001     | 2061     | 2061     | 2061     | 2094     | 2068     | 
| 2011-01-06 | 2035     | 2043     | 2069     | 2006     | 2066     | 2067     | 2021     | 2012     | 
| 2011-01-07 | 2031     | 2036     | 2057     | 2043     | 2098     | 2010     | 2020     | 2016     | 
| 2011-01-08 | 2065     | 2025     | 2046     | 2024     | 2015     | 2011     | 2065     | 2013     | 
| 2011-01-09 | 2019     | 2036     | 2082     | 2009     | 2083     | 2009     | 2097     | 2046     | 
| 2011-01-10 | 2097     | 2060     | 2073     | 2003     | 2028     | 2012     | 2029     | 2011     |

Скажем, мы хотим найти min от (2, b) до (6, d) для каждой строки.

Мы можем просто заполнить нежелательные данные первой и последней строки np.inf.

df.loc["2011-01-07", :datetime.time(15, 0)] = np.inf
df.loc["2011-01-10", datetime.time(13, 30):] = np.inf

вы получаете

|            | 13:00:00 | 13:30:00 | 14:00:00 | 14:30:00 | 15:00:00 | 15:30:00 | 16:00:00 | 16:30:00 | 
|------------|----------|----------|----------|----------|----------|----------|----------|----------| 
| 2011-01-01 | 2054.0   | 2071.0   | 2060.0   | 2054.0   | 2042.0   | 2064.0   | 2043.0   | 2089.0   | 
| 2011-01-02 | 2096.0   | 2038.0   | 2079.0   | 2052.0   | 2056.0   | 2092.0   | 2007.0   | 2008.0   | 
| 2011-01-03 | 2002.0   | 2083.0   | 2077.0   | 2087.0   | 2097.0   | 2079.0   | 2046.0   | 2078.0   | 
| 2011-01-04 | 2011.0   | 2063.0   | 2014.0   | 2094.0   | 2052.0   | 2041.0   | 2026.0   | 2077.0   | 
| 2011-01-05 | 2045.0   | 2056.0   | 2001.0   | 2061.0   | 2061.0   | 2061.0   | 2094.0   | 2068.0   | 
| 2011-01-06 | 2035.0   | 2043.0   | 2069.0   | 2006.0   | 2066.0   | 2067.0   | 2021.0   | 2012.0   | 
| 2011-01-07 | inf      | inf      | inf      | inf      | inf      | 2010.0   | 2020.0   | 2016.0   | 
| 2011-01-08 | 2065.0   | 2025.0   | 2046.0   | 2024.0   | 2015.0   | 2011.0   | 2065.0   | 2013.0   | 
| 2011-01-09 | 2019.0   | 2036.0   | 2082.0   | 2009.0   | 2083.0   | 2009.0   | 2097.0   | 2046.0   | 
| 2011-01-10 | 2097.0   | inf      | inf      | inf      | inf      | inf      | inf      | inf      |

Чтобы получить результат:

df.loc["2011-01-07": "2011-01-10", :].idxmin(axis=1)

2011-01-07    15:30:00
2011-01-08    15:30:00
2011-01-09    14:30:00
2011-01-10    13:00:00
Freq: D, dtype: object

Ответ 3

Хакерный способ, но должен быть быстрым, заключается в том, чтобы скомпоновать сдвинутые DataFrames:

In [11]: df.shift(1)
Out[11]:
            13:00:00  13:30:00  14:00:00  14:30:00  15:00:00  15:30:00  16:00:00  16:30:00
2011-01-01       NaN       NaN       NaN       NaN       NaN       NaN       NaN       NaN
2011-01-02      2054      2071      2060      2054      2042      2064      2043      2089
2011-01-03      2096      2038      2079      2052      2056      2092      2007      2008
2011-01-04      2002      2083      2077      2087      2097      2079      2046      2078
2011-01-05      2011      2063      2014      2094      2052      2041      2026      2077
2011-01-06      2045      2056      2001      2061      2061      2061      2094      2068
2011-01-07      2035      2043      2069      2006      2066      2067      2021      2012
2011-01-08      2031      2036      2057      2043      2098      2010      2020      2016
2011-01-09      2065      2025      2046      2024      2015      2011      2065      2013
2011-01-10      2019      2036      2082      2009      2083      2009      2097      2046

In [12]: df.shift(2).iloc[:, 4:]
Out[12]:
            15:00:00  15:30:00  16:00:00  16:30:00
2011-01-01       NaN       NaN       NaN       NaN
2011-01-02       NaN       NaN       NaN       NaN
2011-01-03      2042      2064      2043      2089
2011-01-04      2056      2092      2007      2008
2011-01-05      2097      2079      2046      2078
2011-01-06      2052      2041      2026      2077
2011-01-07      2061      2061      2094      2068
2011-01-08      2066      2067      2021      2012
2011-01-09      2098      2010      2020      2016
2011-01-10      2015      2011      2065      2013

In [13]: pd.concat([df.iloc[:, :1], df.shift(1), df.shift(2).iloc[:, 4:]], axis=1)
Out[13]:
            13:00:00  13:00:00  13:30:00  14:00:00  14:30:00  15:00:00  15:30:00  16:00:00  16:30:00  15:00:00  15:30:00  16:00:00  16:30:00
2011-01-01      2054       NaN       NaN       NaN       NaN       NaN       NaN       NaN       NaN       NaN       NaN       NaN       NaN
2011-01-02      2096      2054      2071      2060      2054      2042      2064      2043      2089       NaN       NaN       NaN       NaN
2011-01-03      2002      2096      2038      2079      2052      2056      2092      2007      2008      2042      2064      2043      2089
2011-01-04      2011      2002      2083      2077      2087      2097      2079      2046      2078      2056      2092      2007      2008
2011-01-05      2045      2011      2063      2014      2094      2052      2041      2026      2077      2097      2079      2046      2078
2011-01-06      2035      2045      2056      2001      2061      2061      2061      2094      2068      2052      2041      2026      2077
2011-01-07      2031      2035      2043      2069      2006      2066      2067      2021      2012      2061      2061      2094      2068
2011-01-08      2065      2031      2036      2057      2043      2098      2010      2020      2016      2066      2067      2021      2012
2011-01-09      2019      2065      2025      2046      2024      2015      2011      2065      2013      2098      2010      2020      2016
2011-01-10      2097      2019      2036      2082      2009      2083      2009      2097      2046      2015      2011      2065      2013

и возьмите минимум по столбцам (убедитесь, что вы сбросили столбцы, которые слишком рано или слишком поздно в определенный день:

In [14]: pd.concat([df.iloc[:, :1], df.shift(1), df.shift(2).iloc[:, 4:]], axis=1).min(1)
Out[14]:
2011-01-01    2054
2011-01-02    2042
2011-01-03    2002
2011-01-04    2002
2011-01-05    2011
2011-01-06    2001
2011-01-07    2006
2011-01-08    2010
2011-01-09    2010
2011-01-10    2009
Freq: D, dtype: float64

Вы можете сделать это более эффективно, но более шумно, взяв минимум каждого сдвинутого DataFrame перед конкатенацией:

In [21]: pd.concat([df.iloc[:, :1].min(1),
                    df.shift(1).min(1),
                    df.shift(2).iloc[:, 4:].min(1)],
                   axis=1).min(1)
Out[21]:
2011-01-01    2054
2011-01-02    2042
2011-01-03    2002
2011-01-04    2002
2011-01-05    2011
2011-01-06    2001
2011-01-07    2006
2011-01-08    2010
2011-01-09    2010
2011-01-10    2009
Freq: D, dtype: float64

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

Ответ 4

Я использовал метод pandas 'stack() и объект timeseries для создания результата из данных образца. Этот подход хорошо обобщается на любой произвольный временной диапазон с несколькими настройками и использует pandas встроенные функционалы для построения результата.

import pandas as pd
import datetime as dt
# import df from json
df = pd.read_json('''{"13:00:00":     {"1293840000000":2085,"1293926400000":2062,"1294012800000":2035,"1294099200000":2086,"1294185600000":2006,"1294272000000":2097,"1294358400000":2078,"1294444800000":2055,"1294531200000":2023,"1294617600000":2024},
                      "13:30:00":{"1293840000000":2045,"1293926400000":2039,"1294012800000":2035,"1294099200000":2045,"1294185600000":2025,"1294272000000":2099,"1294358400000":2028,"1294444800000":2028,"1294531200000":2034,"1294617600000":2010},
                      "14:00:00":{"1293840000000":2095,"1293926400000":2006,"1294012800000":2001,"1294099200000":2032,"1294185600000":2022,"1294272000000":2040,"1294358400000":2024,"1294444800000":2070,"1294531200000":2081,"1294617600000":2095},
                      "14:30:00":{"1293840000000":2057,"1293926400000":2042,"1294012800000":2018,"1294099200000":2023,"1294185600000":2025,"1294272000000":2016,"1294358400000":2066,"1294444800000":2041,"1294531200000":2098,"1294617600000":2023},
                      "15:00:00":{"1293840000000":2082,"1293926400000":2025,"1294012800000":2040,"1294099200000":2061,"1294185600000":2013,"1294272000000":2063,"1294358400000":2024,"1294444800000":2036,"1294531200000":2096,"1294617600000":2068},
                      "15:30:00":{"1293840000000":2090,"1293926400000":2084,"1294012800000":2092,"1294099200000":2003,"1294185600000":2001,"1294272000000":2049,"1294358400000":2066,"1294444800000":2082,"1294531200000":2090,"1294617600000":2005},
                      "16:00:00":{"1293840000000":2081,"1293926400000":2003,"1294012800000":2009,"1294099200000":2001,"1294185600000":2011,"1294272000000":2098,"1294358400000":2051,"1294444800000":2092,"1294531200000":2029,"1294617600000":2073},
                      "16:30:00":{"1293840000000":2015,"1293926400000":2095,"1294012800000":2094,"1294099200000":2042,"1294185600000":2061,"1294272000000":2006,"1294358400000":2042,"1294444800000":2004,"1294531200000":2099,"1294617600000":2088}}
                   '''#,convert_axes=False
                    )
date_idx=df.index                    
# stack the data 
stacked = df.stack()
# merge the multindex into a single idx. 
idx_list = stacked.index.tolist()
idx = []
for item in idx_list:
    day = item[0]
    time = item[1]
    idx += [dt.datetime(day.year, day.month, day.day, time.hour, time.minute)]
# make a time series to simplify slicing
timeseries = pd.TimeSeries(stacked.values, index=idx)
# get the results for each date

for i in range(2, len(date_idx)):
    # get the min values for each day in the sample data. 
    start_time='%s 15:00:00'%date_idx[i-2]
    end_time = '%s 13:30:00'%date_idx[i]
    slice_idx =timeseries.index>=start_time 
    slice_idx *= timeseries.index<=end_time
    print "%s %s"%(date_idx[i].date(), timeseries[slice_idx].min())

выход:

2011-01-03 2003
2011-01-04 2001
2011-01-05 2001
2011-01-06 2001
2011-01-07 2001
2011-01-08 2006
2011-01-09 2004
2011-01-10 2004