পান্ডাস: সময় অন্তর দিয়ে গড়ায়


87

আমি পান্ডাদের কাছে নতুন .... আমি একগুচ্ছ পোলিং ডেটা পেয়েছি; আমি তিন দিনের দিনের উইন্ডোর উপর ভিত্তি করে প্রতিটি দিনের জন্য একটি অনুমান পেতে রোলিং অর্থ গণনা করতে চাই। আমি যেমন এই প্রশ্নটি থেকে বুঝতে পারি , রোলিং_ * ফাংশন একটি নির্দিষ্ট সংখ্যক মানগুলির উপর ভিত্তি করে উইন্ডোটি গণনা করে, নির্দিষ্ট তারিখের সীমা নয় range

এই কার্যকারিতা কার্যকর করে এমন কোনও আলাদা কার্য রয়েছে? নাকি আমি নিজের লেখা আটকাচ্ছি?

সম্পাদনা:

নমুনা ইনপুট ডেটা:

polls_subset.tail(20)
Out[185]: 
            favorable  unfavorable  other

enddate                                  
2012-10-25       0.48         0.49   0.03
2012-10-25       0.51         0.48   0.02
2012-10-27       0.51         0.47   0.02
2012-10-26       0.56         0.40   0.04
2012-10-28       0.48         0.49   0.04
2012-10-28       0.46         0.46   0.09
2012-10-28       0.48         0.49   0.03
2012-10-28       0.49         0.48   0.03
2012-10-30       0.53         0.45   0.02
2012-11-01       0.49         0.49   0.03
2012-11-01       0.47         0.47   0.05
2012-11-01       0.51         0.45   0.04
2012-11-03       0.49         0.45   0.06
2012-11-04       0.53         0.39   0.00
2012-11-04       0.47         0.44   0.08
2012-11-04       0.49         0.48   0.03
2012-11-04       0.52         0.46   0.01
2012-11-04       0.50         0.47   0.03
2012-11-05       0.51         0.46   0.02
2012-11-07       0.51         0.41   0.00

আউটপুট প্রতিটি তারিখের জন্য শুধুমাত্র একটি সারি থাকবে।

সম্পাদনা x2: নির্দিষ্ট টাইপ


4
পান্ডাগাস বাগ ট্র্যাকারে এই কার্যকারিতাটির জন্য অনুরোধ করা আছে: খোলা সমস্যা রয়েছে github.com/pydata/pandas/issues/936 । কার্যকারিতা এখনও বিদ্যমান নেই। এই প্রশ্নের উত্তরগুলি পছন্দসই প্রভাব পাওয়ার একটি উপায় বর্ণনা করে তবে অন্তর্নির্মিত rolling_*কার্যগুলির তুলনায় এটি সাধারণত ধীর হবে ।
ব্রেণবার্ন

উত্তর:


75

ইতিমধ্যে, একটি সময়-উইন্ডো সক্ষমতা যুক্ত করা হয়েছিল। এই লিঙ্কটি দেখুন ।

In [1]: df = DataFrame({'B': range(5)})

In [2]: df.index = [Timestamp('20130101 09:00:00'),
   ...:             Timestamp('20130101 09:00:02'),
   ...:             Timestamp('20130101 09:00:03'),
   ...:             Timestamp('20130101 09:00:05'),
   ...:             Timestamp('20130101 09:00:06')]

In [3]: df
Out[3]: 
                     B
2013-01-01 09:00:00  0
2013-01-01 09:00:02  1
2013-01-01 09:00:03  2
2013-01-01 09:00:05  3
2013-01-01 09:00:06  4

In [4]: df.rolling(2, min_periods=1).sum()
Out[4]: 
                       B
2013-01-01 09:00:00  0.0
2013-01-01 09:00:02  1.0
2013-01-01 09:00:03  3.0
2013-01-01 09:00:05  5.0
2013-01-01 09:00:06  7.0

In [5]: df.rolling('2s', min_periods=1).sum()
Out[5]: 
                       B
2013-01-01 09:00:00  0.0
2013-01-01 09:00:02  1.0
2013-01-01 09:00:03  3.0
2013-01-01 09:00:05  3.0
2013-01-01 09:00:06  7.0

এটি শীর্ষ উত্তর হওয়া উচিত।
ইভান

6
অফসেট (যেমন '2s') জন্য আর্গুমেন্ট ডকুমেন্টেশন rolling: লাগতে পারে এখানে pandas.pydata.org/pandas-docs/stable/user_guide/...
Guilherme Salome

4
যদি ডেটাফ্রেমে একাধিক কলাম থাকে; আমরা কীভাবে নির্দিষ্ট কলামগুলি নির্দিষ্ট করব?
ব্রেন_ ওভার 14

@ ব্রেন_ওভারফ্লোড সূচক হিসাবে সেট হয়েছে
জামেফি

এই পদ্ধতির সাথে মিনি_পিরিয়ড নির্ভরযোগ্য বলে মনে হয় না। মিনি_পিরিয়ডস> ১ এর জন্য, টাইমস্ট্যাম্প নির্ভুলতা / পরিবর্তনশীল স্যাম্পলিং হারের কারণে আপনি তাদের প্রত্যাশা করবেন না এমন জায়গা পেতে পারেন
অ্যালবার্ট জেমস টেডি

50

এরকম কিছু সম্পর্কে:

প্রথমে ডেটা ফ্রেমটিকে 1 ডি বিরতিতে পুনরায় নমুনা করুন। এটি সমস্ত সদৃশ দিনের জন্য মানগুলির গড় গ্রহণ করে। fill_methodহারিয়ে যাওয়া তারিখের মানগুলি পূরণ করতে বিকল্পটি ব্যবহার করুন । এরপরে, pd.rolling_mean3 এবং min_periods = 1 এর একটি উইন্ডো দিয়ে পুনরায় মডেল করা ফ্রেমটি পাস করুন :

pd.rolling_mean(df.resample("1D", fill_method="ffill"), window=3, min_periods=1)

            favorable  unfavorable     other
enddate
2012-10-25   0.495000     0.485000  0.025000
2012-10-26   0.527500     0.442500  0.032500
2012-10-27   0.521667     0.451667  0.028333
2012-10-28   0.515833     0.450000  0.035833
2012-10-29   0.488333     0.476667  0.038333
2012-10-30   0.495000     0.470000  0.038333
2012-10-31   0.512500     0.460000  0.029167
2012-11-01   0.516667     0.456667  0.026667
2012-11-02   0.503333     0.463333  0.033333
2012-11-03   0.490000     0.463333  0.046667
2012-11-04   0.494000     0.456000  0.043333
2012-11-05   0.500667     0.452667  0.036667
2012-11-06   0.507333     0.456000  0.023333
2012-11-07   0.510000     0.443333  0.013333

আপডেট : বেন মন্তব্যগুলিতে উল্লেখ করার সাথে সাথে পান্ডাস 0.18.0 এর বাক্য গঠনটি পরিবর্তিত হয়েছে । নতুন সিনট্যাক্স সহ এটি হবে:

df.resample("1d").sum().fillna(0).rolling(window=3, min_periods=1).mean()

দুঃখিত, পান্ডাস নব্বই, অনুপস্থিত মান সরবরাহের নিয়ম হিসাবে সঠিকভাবে কী ব্যবহার করে?
আনোভ

4
পূরণের কয়েকটি বিকল্প রয়েছে। ffillফরোয়ার্ড ফিলের অর্থ দাঁড়ায় এবং সর্বাধিক সাম্প্রতিক অ-অনুপস্থিত মানের প্রস্তাব দেয়। একইভাবে bfillপিছনের দিকে পূরণের জন্য, বিপরীত ক্রমে একই কাজ করে।
জেলাজনি 7

9
সম্ভবত আমি এখানে ভুল হয়েছি, তবে আপনি কি একই দিন থেকে একাধিক পাঠ উপেক্ষা করছেন (রোলিংটি নেওয়ার সময় আপনি যদি দুটি রিডিং একজনের চেয়ে বেশি ওজন বহন করে আশা করেন ...)
অ্যান্ডি হেডেন

4
দুর্দান্ত উত্তর। কেবলমাত্র লক্ষণীয় যে পান্ডাস 0.18.0 এ সিনট্যাক্সটি পরিবর্তিত হয়েছিল । নতুন বাক্য df.resample("1D").ffill(limit=0).rolling(window=3, min_periods=1).mean()
বেন

4
প্যান্ডাস সংস্করণে 0.18.1 সংস্করণে মূল উত্তরের ফলাফলগুলি প্রতিলিপি করতে আমি ব্যবহার করছি: df.resample("1d").mean().rolling(window=3, min_periods=1).mean()
জন

33

আমার ঠিক একই প্রশ্ন ছিল কিন্তু অনিয়মিতভাবে ব্যবধানযুক্ত ডেটাপয়েন্টগুলি। এখানে নমুনা আসলেই কোনও বিকল্প নয়। তাই আমি আমার নিজস্ব ফাংশন তৈরি করেছি। হতে পারে এটি অন্যদের জন্যও কার্যকর হবে:

from pandas import Series, DataFrame
import pandas as pd
from datetime import datetime, timedelta
import numpy as np

def rolling_mean(data, window, min_periods=1, center=False):
    ''' Function that computes a rolling mean

    Parameters
    ----------
    data : DataFrame or Series
           If a DataFrame is passed, the rolling_mean is computed for all columns.
    window : int or string
             If int is passed, window is the number of observations used for calculating 
             the statistic, as defined by the function pd.rolling_mean()
             If a string is passed, it must be a frequency string, e.g. '90S'. This is
             internally converted into a DateOffset object, representing the window size.
    min_periods : int
                  Minimum number of observations in window required to have a value.

    Returns
    -------
    Series or DataFrame, if more than one column    
    '''
    def f(x):
        '''Function to apply that actually computes the rolling mean'''
        if center == False:
            dslice = col[x-pd.datetools.to_offset(window).delta+timedelta(0,0,1):x]
                # adding a microsecond because when slicing with labels start and endpoint
                # are inclusive
        else:
            dslice = col[x-pd.datetools.to_offset(window).delta/2+timedelta(0,0,1):
                         x+pd.datetools.to_offset(window).delta/2]
        if dslice.size < min_periods:
            return np.nan
        else:
            return dslice.mean()

    data = DataFrame(data.copy())
    dfout = DataFrame()
    if isinstance(window, int):
        dfout = pd.rolling_mean(data, window, min_periods=min_periods, center=center)
    elif isinstance(window, basestring):
        idx = Series(data.index.to_pydatetime(), index=data.index)
        for colname, col in data.iterkv():
            result = idx.apply(f)
            result.name = colname
            dfout = dfout.join(result, how='outer')
    if dfout.columns.size == 1:
        dfout = dfout.ix[:,0]
    return dfout


# Example
idx = [datetime(2011, 2, 7, 0, 0),
       datetime(2011, 2, 7, 0, 1),
       datetime(2011, 2, 7, 0, 1, 30),
       datetime(2011, 2, 7, 0, 2),
       datetime(2011, 2, 7, 0, 4),
       datetime(2011, 2, 7, 0, 5),
       datetime(2011, 2, 7, 0, 5, 10),
       datetime(2011, 2, 7, 0, 6),
       datetime(2011, 2, 7, 0, 8),
       datetime(2011, 2, 7, 0, 9)]
idx = pd.Index(idx)
vals = np.arange(len(idx)).astype(float)
s = Series(vals, index=idx)
rm = rolling_mean(s, window='2min')

আপনি কি প্রাসঙ্গিক আমদানি অন্তর্ভুক্ত করতে পারেন?
ব্রাইস ড্রেনান

আপনি দয়া করে একটি উদাহরণ ইনপুট ডেটাফ্রেম সরবরাহ করতে পারেন যা কোনও সময়ের ব্যবধান স্লাইডিং উইন্ডোটি গণনা করা হলে কাজ করবে, ধন্যবাদ
জোশল্ক

মূল পোস্টে একটি উদাহরণ যুক্ত করা হয়েছে।
user2689410

4
একই এখন ব্যবহার করা যেতে পারেs.rolling('2min', min_periods=1).mean()
কাম্পাতা

8

ইউজার 2689410 এর কোডটি আমার প্রয়োজন মতো ছিল। আমার সংস্করণ সরবরাহ করা হচ্ছে (ব্যবহারকারীর কাছে ক্রেডিট 2689410) যা ডেটাফ্রেমে পুরো সারিগুলির জন্য একবারে গড় গণনার কারণে দ্রুত হয়।

আশা করি আমার প্রত্যয় সম্মেলনগুলি পাঠযোগ্য: _s: স্ট্রিং, _ আই: ইনট, _ বি: বুল, _সার: সিরিজ এবং _ডিএফ: ডেটা ফ্রেম। আপনি যেখানে একাধিক প্রত্যয় পেয়েছেন সেখানে টাইপ উভয়ই হতে পারে।

import pandas as pd
from datetime import datetime, timedelta
import numpy as np

def time_offset_rolling_mean_df_ser(data_df_ser, window_i_s, min_periods_i=1, center_b=False):
    """ Function that computes a rolling mean

    Credit goes to user2689410 at http://stackoverflow.com/questions/15771472/pandas-rolling-mean-by-time-interval

    Parameters
    ----------
    data_df_ser : DataFrame or Series
         If a DataFrame is passed, the time_offset_rolling_mean_df_ser is computed for all columns.
    window_i_s : int or string
         If int is passed, window_i_s is the number of observations used for calculating
         the statistic, as defined by the function pd.time_offset_rolling_mean_df_ser()
         If a string is passed, it must be a frequency string, e.g. '90S'. This is
         internally converted into a DateOffset object, representing the window_i_s size.
    min_periods_i : int
         Minimum number of observations in window_i_s required to have a value.

    Returns
    -------
    Series or DataFrame, if more than one column

    >>> idx = [
    ...     datetime(2011, 2, 7, 0, 0),
    ...     datetime(2011, 2, 7, 0, 1),
    ...     datetime(2011, 2, 7, 0, 1, 30),
    ...     datetime(2011, 2, 7, 0, 2),
    ...     datetime(2011, 2, 7, 0, 4),
    ...     datetime(2011, 2, 7, 0, 5),
    ...     datetime(2011, 2, 7, 0, 5, 10),
    ...     datetime(2011, 2, 7, 0, 6),
    ...     datetime(2011, 2, 7, 0, 8),
    ...     datetime(2011, 2, 7, 0, 9)]
    >>> idx = pd.Index(idx)
    >>> vals = np.arange(len(idx)).astype(float)
    >>> ser = pd.Series(vals, index=idx)
    >>> df = pd.DataFrame({'s1':ser, 's2':ser+1})
    >>> time_offset_rolling_mean_df_ser(df, window_i_s='2min')
                          s1   s2
    2011-02-07 00:00:00  0.0  1.0
    2011-02-07 00:01:00  0.5  1.5
    2011-02-07 00:01:30  1.0  2.0
    2011-02-07 00:02:00  2.0  3.0
    2011-02-07 00:04:00  4.0  5.0
    2011-02-07 00:05:00  4.5  5.5
    2011-02-07 00:05:10  5.0  6.0
    2011-02-07 00:06:00  6.0  7.0
    2011-02-07 00:08:00  8.0  9.0
    2011-02-07 00:09:00  8.5  9.5
    """

    def calculate_mean_at_ts(ts):
        """Function (closure) to apply that actually computes the rolling mean"""
        if center_b == False:
            dslice_df_ser = data_df_ser[
                ts-pd.datetools.to_offset(window_i_s).delta+timedelta(0,0,1):
                ts
            ]
            # adding a microsecond because when slicing with labels start and endpoint
            # are inclusive
        else:
            dslice_df_ser = data_df_ser[
                ts-pd.datetools.to_offset(window_i_s).delta/2+timedelta(0,0,1):
                ts+pd.datetools.to_offset(window_i_s).delta/2
            ]
        if  (isinstance(dslice_df_ser, pd.DataFrame) and dslice_df_ser.shape[0] < min_periods_i) or \
            (isinstance(dslice_df_ser, pd.Series) and dslice_df_ser.size < min_periods_i):
            return dslice_df_ser.mean()*np.nan   # keeps number format and whether Series or DataFrame
        else:
            return dslice_df_ser.mean()

    if isinstance(window_i_s, int):
        mean_df_ser = pd.rolling_mean(data_df_ser, window=window_i_s, min_periods=min_periods_i, center=center_b)
    elif isinstance(window_i_s, basestring):
        idx_ser = pd.Series(data_df_ser.index.to_pydatetime(), index=data_df_ser.index)
        mean_df_ser = idx_ser.apply(calculate_mean_at_ts)

    return mean_df_ser

3

এই উদাহরণটি @ অ্যান্ডহেডেনের মন্তব্যে প্রস্তাবিত ওজনযুক্ত গড় হিসাবে বিবেচনা করবে বলে মনে হচ্ছে। উদাহরণস্বরূপ, 10/25 এ দুটি পোল এবং 10/26 এবং 10/27- তে একটি করে পোল রয়েছে। যদি আপনি কেবল পুনরায় নমুনা নেন এবং তারপরে এর অর্থ গ্রহণ করেন তবে এটি কার্যকরভাবে 10/26 এবং 10/27 এর নির্বাচনের তুলনায় দ্বিগুণ ওজন দেয়।

প্রতিটি সমান ওজন দিতে পোলের সমান ওজন বদলে প্রতিটি দিন , আপনি নিচের মত কিছু করতে পারে।

>>> wt = df.resample('D',limit=5).count()

            favorable  unfavorable  other
enddate                                  
2012-10-25          2            2      2
2012-10-26          1            1      1
2012-10-27          1            1      1

>>> df2 = df.resample('D').mean()

            favorable  unfavorable  other
enddate                                  
2012-10-25      0.495        0.485  0.025
2012-10-26      0.560        0.400  0.040
2012-10-27      0.510        0.470  0.020

এটি আপনাকে দিনভিত্তিক গড়ের পরিবর্তে পোল-ভিত্তিক গড় করার কাঁচামাল দেয়। আগের মতোই, পোলের গড় গড়ে 10/25 করা হয়, তবে 10/25 এর ওজনও সংরক্ষণ করা হয় এবং 10/25 বা 10/27 এ ওজন দ্বিগুণ হয় যাতে প্রতিফলিত হয় যে দুটি পোল 10/25 এ নেওয়া হয়েছিল।

>>> df3 = df2 * wt
>>> df3 = df3.rolling(3,min_periods=1).sum()
>>> wt3 = wt.rolling(3,min_periods=1).sum()

>>> df3 = df3 / wt3  

            favorable  unfavorable     other
enddate                                     
2012-10-25   0.495000     0.485000  0.025000
2012-10-26   0.516667     0.456667  0.030000
2012-10-27   0.515000     0.460000  0.027500
2012-10-28   0.496667     0.465000  0.041667
2012-10-29   0.484000     0.478000  0.042000
2012-10-30   0.488000     0.474000  0.042000
2012-10-31   0.530000     0.450000  0.020000
2012-11-01   0.500000     0.465000  0.035000
2012-11-02   0.490000     0.470000  0.040000
2012-11-03   0.490000     0.465000  0.045000
2012-11-04   0.500000     0.448333  0.035000
2012-11-05   0.501429     0.450000  0.032857
2012-11-06   0.503333     0.450000  0.028333
2012-11-07   0.510000     0.435000  0.010000

নোট করুন যে 10/27 এর রোলিং গড় এখন 52.1667 (দিন-ভারিত) এর পরিবর্তে 0.51500 (পোল-ওজনযুক্ত)।

এছাড়াও নোট করুন যে সংস্করণ 0.18.0 এর জন্য resampleএবং এপিআই-তে পরিবর্তন হয়েছে rolling

ঘূর্ণায়মান (পান্ডাস 0.18.0 এ নতুন কী)

পুনরায় নমুনা (পান্ডাস 0.18.0 এ নতুন কী)


3

এটি বেসিক রাখতে, আপনাকে শুরু করার জন্য আমি একটি লুপ এবং এরকম কিছু ব্যবহার করেছি (আমার সূচকটি তারিখের সময়):

import pandas as pd
import datetime as dt

#populate your dataframe: "df"
#...

df[df.index<(df.index[0]+dt.timedelta(hours=1))] #gives you a slice. you can then take .sum() .mean(), whatever

এবং তারপরে আপনি সেই স্লাইসে ফাংশন পরিচালনা করতে পারেন। আপনি দেখতে পাচ্ছেন যে কীভাবে আপনার ডেটাফ্রেম সূচকের প্রথম মান ব্যতীত উইন্ডোটির সূচনা করার জন্য একটি পুনরাবৃত্তকারী যুক্ত করা উইন্ডোটি রোল করবে (আপনি উদাহরণস্বরূপ> শুরুর জন্য একটি> নিয়মও ব্যবহার করতে পারেন)।

দ্রষ্টব্য, এটি সুপার বড় ডেটার জন্য খুব কম দক্ষ বা খুব ছোট বৃদ্ধি হতে পারে কারণ আপনার স্লাইসিং আরও কঠোর হয়ে উঠতে পারে (কয়েক সপ্তাহ ধরে ঘণ্টার উইন্ডোতে যদিও কয়েক হাজার সারি ডেটা এবং কয়েকটি কলামের জন্য আমার পক্ষে যথেষ্ট কাজ করে)


2

আমি দেখতে পেলাম যে আমি যখন ব্যবসায়িক মাসের ডেল্টায় এই ত্রুটিটি ফেলে দিয়েছিলাম তখন উইন্ডো = '1 এম' দিয়ে চেষ্টা করার পরে ব্যবহারকারীর 2689410 কোডটি ভেঙে গেছে:

AttributeError: 'MonthEnd' object has no attribute 'delta'

আমি সরাসরি একটি আপেক্ষিক সময় ডেল্টা পাস করার বিকল্প যুক্ত করেছি, যাতে আপনি ব্যবহারকারী সংজ্ঞায়িত সময়কালের জন্য একই জিনিস করতে পারেন।

পয়েন্টারগুলির জন্য ধন্যবাদ, এখানে আমার চেষ্টা - আশা করি এটি কার্যকর হবে।

def rolling_mean(data, window, min_periods=1, center=False):
""" Function that computes a rolling mean
Reference:
    http://stackoverflow.com/questions/15771472/pandas-rolling-mean-by-time-interval

Parameters
----------
data : DataFrame or Series
       If a DataFrame is passed, the rolling_mean is computed for all columns.
window : int, string, Timedelta or Relativedelta
         int - number of observations used for calculating the statistic,
               as defined by the function pd.rolling_mean()
         string - must be a frequency string, e.g. '90S'. This is
                  internally converted into a DateOffset object, and then
                  Timedelta representing the window size.
         Timedelta / Relativedelta - Can directly pass a timedeltas.
min_periods : int
              Minimum number of observations in window required to have a value.
center : bool
         Point around which to 'center' the slicing.

Returns
-------
Series or DataFrame, if more than one column
"""
def f(x, time_increment):
    """Function to apply that actually computes the rolling mean
    :param x:
    :return:
    """
    if not center:
        # adding a microsecond because when slicing with labels start
        # and endpoint are inclusive
        start_date = x - time_increment + timedelta(0, 0, 1)
        end_date = x
    else:
        start_date = x - time_increment/2 + timedelta(0, 0, 1)
        end_date = x + time_increment/2
    # Select the date index from the
    dslice = col[start_date:end_date]

    if dslice.size < min_periods:
        return np.nan
    else:
        return dslice.mean()

data = DataFrame(data.copy())
dfout = DataFrame()
if isinstance(window, int):
    dfout = pd.rolling_mean(data, window, min_periods=min_periods, center=center)

elif isinstance(window, basestring):
    time_delta = pd.datetools.to_offset(window).delta
    idx = Series(data.index.to_pydatetime(), index=data.index)
    for colname, col in data.iteritems():
        result = idx.apply(lambda x: f(x, time_delta))
        result.name = colname
        dfout = dfout.join(result, how='outer')

elif isinstance(window, (timedelta, relativedelta)):
    time_delta = window
    idx = Series(data.index.to_pydatetime(), index=data.index)
    for colname, col in data.iteritems():
        result = idx.apply(lambda x: f(x, time_delta))
        result.name = colname
        dfout = dfout.join(result, how='outer')

if dfout.columns.size == 1:
    dfout = dfout.ix[:, 0]
return dfout

এবং গড় গণনা করার জন্য 3 দিনের সময় উইন্ডো সহ উদাহরণ:

from pandas import Series, DataFrame
import pandas as pd
from datetime import datetime, timedelta
import numpy as np
from dateutil.relativedelta import relativedelta

idx = [datetime(2011, 2, 7, 0, 0),
           datetime(2011, 2, 7, 0, 1),
           datetime(2011, 2, 8, 0, 1, 30),
           datetime(2011, 2, 9, 0, 2),
           datetime(2011, 2, 10, 0, 4),
           datetime(2011, 2, 11, 0, 5),
           datetime(2011, 2, 12, 0, 5, 10),
           datetime(2011, 2, 12, 0, 6),
           datetime(2011, 2, 13, 0, 8),
           datetime(2011, 2, 14, 0, 9)]
idx = pd.Index(idx)
vals = np.arange(len(idx)).astype(float)
s = Series(vals, index=idx)
# Now try by passing the 3 days as a relative time delta directly.
rm = rolling_mean(s, window=relativedelta(days=3))
>>> rm
Out[2]: 
2011-02-07 00:00:00    0.0
2011-02-07 00:01:00    0.5
2011-02-08 00:01:30    1.0
2011-02-09 00:02:00    1.5
2011-02-10 00:04:00    3.0
2011-02-11 00:05:00    4.0
2011-02-12 00:05:10    5.0
2011-02-12 00:06:00    5.5
2011-02-13 00:08:00    6.5
2011-02-14 00:09:00    7.5
Name: 0, dtype: float64

0

আপনার সূচকটি সত্যই datetime, কার্যকর str হতে পারে না তা পরীক্ষা করে দেখুন :

data.index = pd.to_datetime(data['Index']).values
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.