นุ่น: ค่าเฉลี่ยการหมุนตามช่วงเวลา


87

ฉันยังใหม่กับนุ่น .... ฉันมีข้อมูลการสำรวจมากมาย ฉันต้องการคำนวณค่าเฉลี่ยแบบหมุนเพื่อรับค่าประมาณสำหรับแต่ละวันตามกรอบเวลาสามวัน ตามที่ฉันเข้าใจจากคำถามนี้ฟังก์ชัน rolling_ * จะคำนวณหน้าต่างตามจำนวนค่าที่ระบุไม่ใช่ช่วงวันที่และเวลาที่เฉพาะเจาะจง

มีฟังก์ชันอื่นที่ใช้กับฟังก์ชันนี้หรือไม่? หรือฉันติดอยู่กับการเขียนของตัวเอง?

แก้ไข:

ข้อมูลอินพุตตัวอย่าง:

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: แก้ไขการพิมพ์ผิด


2
มีเปิดประเด็นในบั๊กนุ่นขอทำงานนี้คือgithub.com/pydata/pandas/issues/936 ฟังก์ชันนี้ยังไม่มี คำตอบสำหรับคำถามนี้อธิบายถึงวิธีการได้รับเอฟเฟกต์ที่ต้องการ แต่โดยทั่วไปแล้วจะค่อนข้างช้าเมื่อเทียบกับrolling_*ฟังก์ชันในตัว
BrenBarn

คำตอบ:


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

นี่น่าจะเป็นคำตอบอันดับต้น ๆ
Ivan

6
เอกสารสำหรับอาร์กิวเมนต์ offset (เช่น '2s') rollingสามารถใช้ได้ที่นี่: pandas.pydata.org/pandas-docs/stable/user_guide/…
Guilherme Salomé

2
จะเกิดอะไรขึ้นถ้าในดาต้าเฟรมมีหลายคอลัมน์ เราจะระบุคอลัมน์เฉพาะได้อย่างไร
Brain_overflowed

@Brain_overflowed ตั้งค่าเป็นดัชนี
jamfie

min_period ดูเหมือนจะไม่น่าเชื่อถือสำหรับวิธีนี้ สำหรับ min_periods> 1 คุณอาจได้รับ NaN โดยที่คุณไม่คาดหวังเนื่องจากความแม่นยำในการประทับเวลา / อัตราการสุ่มตัวอย่างตัวแปร
Albert James Teddy

50

อะไรประมาณนี้:

ขั้นแรกให้ทำการจำลองกรอบข้อมูลใหม่เป็นช่วงเวลา 1D ค่านี้ใช้ค่าเฉลี่ยของค่าสำหรับวันที่ซ้ำกันทั้งหมด ใช้fill_methodตัวเลือกเพื่อกรอกค่าวันที่ที่ขาดหายไป จากนั้นส่งเฟรมที่สุ่มตัวอย่างเข้าไปpd.rolling_meanด้วยหน้าต่าง 3 และ 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

UPDATE : เบนชี้ให้เห็นในความคิดเห็นที่มีหมีแพนด้า 0.18.0 ไวยากรณ์ที่มีการเปลี่ยนแปลง ด้วยไวยากรณ์ใหม่สิ่งนี้จะเป็น:

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

ขอโทษค่ะ Pandas newb ffill ใช้อะไรเป็นกฎในการระบุค่าที่ขาดหายไป
Anov

1
มีสองตัวเลือกการเติม ffillย่อมาจาก forward fill และเพียงแค่ propogates ค่าที่ไม่หายไปล่าสุด ในทำนองเดียวกันbfillสำหรับการเติมย้อนกลับจะทำเช่นเดียวกันในลำดับย้อนกลับ
Zelazny7

9
บางทีฉันอาจเข้าใจผิดที่นี่ แต่คุณเพิกเฉยต่อการอ่านหลายครั้งในวันเดียวกัน (เมื่อใช้ค่าเฉลี่ยการหมุนคุณคาดว่าการอ่านสองครั้งจะมีน้ำหนักมากกว่าหนึ่ง ... )
Andy Hayden

4
คำตอบที่ดี เพียงแค่สังเกตว่าในหมีแพนด้า 0.18.0 ไวยากรณ์การเปลี่ยนแปลง ไวยากรณ์ใหม่คือ:df.resample("1D").ffill(limit=0).rolling(window=3, min_periods=1).mean()
Ben

1
ในการจำลองผลลัพธ์ของคำตอบเดิมในแพนด้าเวอร์ชัน 0.18.1 ฉันใช้: df.resample("1d").mean().rolling(window=3, min_periods=1).mean()
JohnE

33

ฉันเพิ่งมีคำถามเดียวกัน แต่มีจุดข้อมูลที่เว้นระยะไม่สม่ำเสมอ Resample ไม่ใช่ตัวเลือกที่นี่ ก็เลยสร้างฟังก์ชันขึ้นมาเอง บางทีมันอาจจะมีประโยชน์สำหรับคนอื่น ๆ ด้วย:

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')

คุณสามารถรวมการนำเข้าที่เกี่ยวข้องได้หรือไม่
Bryce Drennan

คุณช่วยใส่ดาต้าเฟรมอินพุตตัวอย่างที่จะใช้งานได้ไหมถ้าคำนวณช่วงเวลาเลื่อนหน้าต่างขอบคุณ
joshlk

เพิ่มตัวอย่างในโพสต์ต้นฉบับ
user2689410

5
เช่นเดียวกับที่ในขณะนี้ทำได้โดยใช้s.rolling('2min', min_periods=1).mean()
kampta

8

รหัสของ user2689410 คือสิ่งที่ฉันต้องการ ระบุเวอร์ชันของฉัน (ให้เครดิตกับ user2689410) ซึ่งเร็วกว่าเนื่องจากคำนวณค่าเฉลี่ยพร้อมกันสำหรับทั้งแถวใน DataFrame

หวังว่ารูปแบบคำต่อท้ายของฉันจะอ่านได้: _s: string, _i: int, _b: bool, _ser: Series และ _df: DataFrame ในกรณีที่คุณพบคำต่อท้ายหลายคำประเภทสามารถเป็นได้ทั้งสองอย่าง

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

ตัวอย่างนี้ดูเหมือนจะเรียกค่าเฉลี่ยถ่วงน้ำหนักตามที่แนะนำในความคิดเห็นของ @ andyhayden ตัวอย่างเช่นมีสองแบบสำรวจในวันที่ 10/25 และอีกหนึ่งแบบสำรวจในวันที่ 26 ตุลาคมและ 27 ตุลาคม หากคุณเพียงแค่ทำการสุ่มตัวอย่างใหม่แล้วใช้ค่าเฉลี่ยสิ่งนี้จะให้น้ำหนักกับการสำรวจในวันที่ 10/26 และ 10/27 เป็นสองเท่าเมื่อเทียบกับการสำรวจในวันที่ 10/25

ในการให้น้ำหนักแบบสำรวจแต่ละครั้งเท่า ๆ กันแทนที่จะให้น้ำหนักเท่ากันในแต่ละวันคุณสามารถทำสิ่งต่อไปนี้

>>> 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/26 หรือ 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 ตอนนี้คือ 0.51500 (ถ่วงน้ำหนักแบบสำรวจ) แทนที่จะเป็น 52.1667 (ถ่วงน้ำหนักวัน)

โปรดทราบว่ามีการเปลี่ยนแปลงใน API สำหรับresampleและrollingในเวอร์ชัน 0.18.0

กลิ้ง (มีอะไรใหม่ในแพนด้า 0.18.0)

resample (มีอะไรใหม่ในแพนด้า 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

ฉันพบว่ารหัส user2689410 พังเมื่อฉันลองใช้ window = '1M' เนื่องจากเดลต้าในเดือนธุรกิจส่งข้อผิดพลาดนี้:

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.