Tag8-Gruppenaggregation und Zeitreihen

1 Gruppenaggregation

1.1 Datenaggregation und -gruppierung

Die einfache Akkumulationsmethode kann uns ein allgemeines Verständnis des Datensatzes vermitteln, wir müssen jedoch häufig eine kumulative Analyse für bestimmte Tags oder Indexteile durchführen. In diesem Fall ist Groupby erforderlich. Obwohl der Name „Gruppe nach“ einem Befehl in der SQL-Datenbanksprache entlehnt ist, ist es möglicherweise angemessener, sich auf die Idee von Hadley Wickham zu beziehen, der den R-Sprachrahmen erfunden hat: Teilen, Anwenden und Kombinieren.

Teilen, Anwenden und Kombinieren
Eine klassische Split-Anwenden-Kombinieren-Operation, bei der „Anwenden“ eine Summationsfunktion ist.

Die folgende Abbildung beschreibt deutlich den GroupBy-Prozess. Der Aufteilungsschritt teilt den DataFrame entsprechend den angegebenen Schlüsseln in mehrere Gruppen auf. Der Schritt „Anwenden“ wendet eine Funktion auf jede Gruppe an, normalerweise eine kumulative, Transformations- oder Filterfunktion. Der Kombinationsschritt kombiniert die Ergebnisse jeder Gruppe in einem einzigen Ausgabearray.

Obwohl wir dies auch durch eine Reihe von zuvor eingeführten Maskierungs-, Akkumulations- und Zusammenführungsoperationen erreichen können, ist es wichtig zu erkennen, dass der Zwischensegmentierungsprozess nicht explizit offengelegt werden muss. Und GroupBy erfordert (oft) nur eine Codezeile, um die Summe, den Mittelwert, die Anzahl, das Minimum und andere kumulative Werte für jede Gruppe zu berechnen. Der Zweck von GroupBy besteht darin, diese Schritte zu abstrahieren: Der Benutzer muss nicht wissen, wie er auf der untersten Ebene berechnet, solange der Vorgang als Ganzes betrachtet wird.

groupby:(by=None,as_index=True)

by : Was gruppiert werden soll, wird verwendet, um die Gruppe von Groupby zu bestimmen

as_index : Geben Sie für die aggregierte Ausgabe das durch die Gruppennotiz indizierte Objekt zurück, nur für DataFrame

df = pd.DataFrame(
    {
    
    'fruit': ['apple', 'banana', 'orange', 'apple', 'banana'],  # 名称
     'color': ['red', 'yellow', 'yellow', 'cyan', 'cyan'],  # 颜色
     'price': [8.5, 6.8, 5.6, 7.8, 6.4],  # 单价
     'count': [3, 4, 6, 5, 2]})  # 购买总量,单位/斤

df['total'] = df['price'] * df['count']
print(df)

Ausgabe:

	fruit	color	price	count	total
0	apple	red		8.5		3		25.5
1	banana	yellow	6.8		4		27.2
2	orange	yellow	5.6		6		33.6
3	apple	cyan	7.8		5		39.0
4	banana	cyan	6.4		2		12.8

Es ist zu beachten, dass der Rückgabewert hier kein DataFrame-Objekt, sondern ein DataFrameGroupBy-Objekt ist. Der Zauber dieses Objekts besteht darin, dass man es sich als eine spezielle Form von DataFrame vorstellen kann, in der mehrere Datensätze verborgen sind, die jedoch ohne Anwendung der Akkumulationsfunktion nicht berechnet werden. Dieser Ansatz der „verzögerten Auswertung“ ermöglicht die sehr effiziente Implementierung der meisten gängigen Akkumulationsoperationen auf eine Weise, die für den Benutzer nahezu transparent ist (es fühlt sich an, als ob die Operation nicht existierte).

Um dieses Ergebnis zu erhalten, können Sie die Akkumulationsfunktion auf das DataFrameGroupBy-Objekt anwenden, wodurch die entsprechenden Schritte zum Anwenden/Kombinieren ausgeführt werden und das Ergebnis erzeugt wird:

print(df.groupby('fruit').sum())
"""
        price
fruit        
apple    16.3
banana   13.2
orange    5.6
"""

sum() ist nur eine von vielen verfügbaren Methoden. Sie können jede Akkumulationsfunktion von Pandas oder NumPy oder jedes gültige DataFrame-Objekt verwenden.

GroupBy-Objekt

Die wichtigsten Operationen in GroupBy können aggregieren , filtern , transformieren und anwenden (Akkumulierung, Filterung, Konvertierung, Anwendung). Diese Inhalte werden später im Detail vorgestellt. Nun stellen wir einige grundlegende Operationsmethoden von GroupBy vor.

(1) Werte nach Spalte abrufen. Das GroupBy-Objekt unterstützt wie der DataFrame auch spaltenweise Werte und gibt ein modifiziertes GroupBy-Objekt zurück, zum Beispiel:

import pandas as pd

df = pd.DataFrame({
    
    'fruit': ['apple', 'banana', 'orange', 'apple', 'banana'],
                   'color': ['red', 'yellow', 'yellow', 'cyan', 'cyan'],
                   'price': [8.5, 6.8, 5.6, 7.8, 6.4],
                   'count': [3, 4, 6, 5, 2]})
df['total'] = df['price'] * df['count']

# 查看类型
print(df.groupby('fruit'))
print(df.groupby('fruit').sum())

"""group 对象"""
for name, group in df.groupby('fruit'):
    print('分组名:\t', name)  # 输出组名
    print('分组数据:\n', group)  # 输出数据块

# 对数量与总价
print(df.groupby('fruit')[['count', 'total']].apply(lambda x: x.sum()))

Aggregation (agg)

Funktionsname	beschreiben
zählen	Anzahl der Nicht-NA-Werte in der Gruppe
Summe	Summe der Nicht-NA-Werte
bedeuten	Durchschnitt der Nicht-NA-Werte
Median	Median der Nicht-NA-Werte
std, var	Standardabweichung und Varianz
Minimal Maximal	Minimaler Wert, maximaler Wert, der nicht NA ist
Prod	Produkt von Nicht-NA-Werten
zuerst, zuletzt	Der erste und der letzte Nicht-NA-Wert
Zum Beispiel:

import numpy as np
# 多分组数据进行多个运算

print(df.groupby('fruit').aggregate({
    
    'price': 'min', 'count': 'max'}))

"""
如果我现在有个需求，计算每种水果最高价和最低价的差值,
1.上表中的聚合函数不能满足于我们的需求，我们需要使用自定义的聚合函数
2.在分组对象中，使用我们自定义的聚合函数
"""

# 定义一个计算差值的函数
def diff_value(arr): 
    return arr.max() - arr.min()

print(df.groupby('fruit')['price'].agg(diff_value))

        price  count
fruit               
apple     7.8      5
banana    6.4      4
orange    5.6      6
fruit
apple     0.7
banana    0.4
orange    0.0
Name: price, dtype: float64

Filter

"""分组后我们也可以对数据进行过滤<自定义规则过滤>"""
def filter_func(x):
    print('price:\t', [x['price']])
    print('price:\t', type(x['price']))
    print('price:\t', x['price'].mean())
    return x['price'].mean() > 6  # 过滤平均价格大于6

print(df)
print('分组价格的平均数: \t', df.groupby('fruit')['price'].mean())

# 分组之后进行过滤，不影响原本的数据
print(df.groupby('fruit').filter(filter_func))  

1.2 Datenzusammenführung

1.2.1 pd.merge Datenzusammenführung

• Verknüpfen Sie Zeilen verschiedener DataFrames basierend auf einem einzelnen oder mehreren Schlüsseln

• Datenbankähnliche Verbindungsvorgänge

• pd.merge :(left, right, how='inner',on=None,left_on=None, right_on=None )

  links: DataFrame links beim Zusammenführen

  rechts: DataFrame auf der rechten Seite beim Zusammenführen

  Wie: Zusammenführungsmethode, Standardeinstellung „inner“, „outer“, „left“, „right“

  on: Der Spaltenname, der zusammengeführt werden muss, muss auf beiden Seiten vorhanden sein, und der Schnittpunkt der Spaltennamen links und rechts wird als Verbindungsschlüssel verwendet.

  left_on: Spalte im linken Datenrahmen, die als Verbindungsschlüssel verwendet wird

  right_on: rechte Spalte im Datenrahmen, die als Verbindungsschlüssel verwendet wird

• Innerer Join: Verbinde die Schnittmenge der Schlüssel in beiden Tabellen
  

• Full Join Outer: Vereinigung der Schlüsselvereinigungen in beiden Tabellen

• 

• Left Join Left: Verbindet alle Schlüssel der linken Tabelle

• 

• Right Join Right: Vereinigung aller Schlüssel der rechten Tabelle
  

import pandas as pd
import numpy as np

left = pd.DataFrame({
    
    'key': ['K0', 'K1', 'K2', 'K3'],
                      'A': ['A0', 'A1', 'A2', 'A3'],
                       'B': ['B0', 'B1', 'B2', 'B3']})

right = pd.DataFrame({
    
    'key': ['K0', 'K1', 'K2', 'K3'],
                      'C': ['C0', 'C1', 'C2', 'C3'],
                      'D': ['D0', 'D1', 'D2', 'D3']})

pd.merge(left,right,on='key') #指定连接键key

	key	A	B	C	D
0	K0	A0	B0	C0	D0
1	K1	A1	B1	C1	D1
2	K2	A2	B2	C2	D2
3	K3	A3	B3	C3	D3

left = pd.DataFrame({
    
    'key1': ['K0', 'K0', 'K1', 'K2'],
                    'key2': ['K0', 'K1', 'K0', 'K1'],
                    'A': ['A0', 'A1', 'A2', 'A3'],
                    'B': ['B0', 'B1', 'B2', 'B3']})

right = pd.DataFrame({
    
    'key1': ['K0', 'K1', 'K1', 'K2'],
                      'key2': ['K0', 'K0', 'K0', 'K0'],
                      'C': ['C0', 'C1', 'C2', 'C3'],
                      'D': ['D0', 'D1', 'D2', 'D3']})

pd.merge(left,right,on=['key1','key2']) #指定多个键，进行合并

	key1	key2	A	B	C	D
0	K0		K0		A0	B0	C0	D0
1	K1		K0		A2	B2	C1	D1
2	K1		K0		A2	B2	C2	D2

#指定左连接

left = pd.DataFrame({
    
    'key1': ['K0', 'K0', 'K1', 'K2'],
                    'key2': ['K0', 'K1', 'K0', 'K1'],
                    'A': ['A0', 'A1', 'A2', 'A3'],
                    'B': ['B0', 'B1', 'B2', 'B3']})
right = pd.DataFrame({
    
    'key1': ['K0', 'K1', 'K1', 'K2'],
                      'key2': ['K0', 'K0', 'K0', 'K0'],
                      'C': ['C0', 'C1', 'C2', 'C3'],
                      'D': ['D0', 'D1', 'D2', 'D3']})

pd.merge(left, right, how='left', on=['key1', 'key2'])
    key1    key2          A    B    C    D
0    K0        K0        A0    B0    C0    D0
1    K0        K1        A1    B1    NaN    NaN
2    K1        K0        A2    B2    C1    D1
3    K1        K0        A2    B2    C2    D2
4    K2        K1        A3    B3    NaN    NaN

#指定右连接

left = pd.DataFrame({
    
    'key1': ['K0', 'K0', 'K1', 'K2'],
                    'key2': ['K0', 'K1', 'K0', 'K1'],
                    'A': ['A0', 'A1', 'A2', 'A3'],
                    'B': ['B0', 'B1', 'B2', 'B3']})
right = pd.DataFrame({
    
    'key1': ['K0', 'K1', 'K1', 'K2'],
                      'key2': ['K0', 'K0', 'K0', 'K0'],
                      'C': ['C0', 'C1', 'C2', 'C3'],
                      'D': ['D0', 'D1', 'D2', 'D3']})
pd.merge(left, right, how='right', on=['key1', 'key2'])

    key1    key2          A    B    C    D
0    K0        K0        A0    B0    C0    D0
1    K1        K0        A2    B2    C1    D1
2    K1        K0        A2    B2    C2    D2
3    K2        K0        NaN    NaN    C3    D3

Der Standardwert ist „inner“ (inner), dh der Schlüssel im Ergebnis ist der Schnittpunkt

wie man die Verbindungsmethode angibt

„Äußer“ (außen), der Schlüssel zum Ergebnis ist die Vereinigung

left = pd.DataFrame({
    
    'key1': ['K0', 'K0', 'K1', 'K2'],
                    'key2': ['K0', 'K1', 'K0', 'K1'],
                    'A': ['A0', 'A1', 'A2', 'A3'],
                    'B': ['B0', 'B1', 'B2', 'B3']})
right = pd.DataFrame({
    
    'key1': ['K0', 'K1', 'K1', 'K2'],
                      'key2': ['K0', 'K0', 'K0', 'K0'],
                      'C': ['C0', 'C1', 'C2', 'C3'],
                      'D': ['D0', 'D1', 'D2', 'D3']})
pd.merge(left,right,how='outer',on=['key1','key2'])
"""
key1    key2    A    B    C    D
0    K0    K0    A0    B0    C0    D0
1    K0    K1    A1    B1    NaN    NaN
2    K1    K0    A2    B2    C1    D1
3    K1    K0    A2    B2    C2    D2
4    K2    K1    A3    B3    NaN    NaN
5    K2    K0    NaN    NaN    C3    D3
"""

Behandeln Sie doppelte Spaltennamen

• Parametersuffixe: Standard ist _x, _y

df_obj1 = pd.DataFrame({
    
    'key': ['b', 'b', 'a', 'c', 'a', 'a', 'b'],
                        'data' : np.random.randint(0,10,7)})
df_obj2 = pd.DataFrame({
    
    'key': ['a', 'b', 'd'],
                        'data' : np.random.randint(0,10,3)})

print(pd.merge(df_obj1, df_obj2, on='key', suffixes=('_left', '_right')))

#运行结果
"""
   data_left key  data_right
0          9   b           1
1          5   b           1
2          1   b           1
3          2   a           8
4          2   a           8
5          5   a           8
"""

Mit Index verknüpfen

• Parameter left_index=True oder right_index=True

# 按索引连接
df_obj1 = pd.DataFrame({
    
    'key': ['b', 'b', 'a', 'c', 'a', 'a', 'b'],
                        'data1' : np.random.randint(0,10,7)})
df_obj2 = pd.DataFrame({
    
    'data2' : np.random.randint(0,10,3)}, index=['a', 'b', 'd'])

print(pd.merge(df_obj1, df_obj2, left_on='key', right_index=True))

#运行结果
"""
   data1 key  data2
0      3   b      6
1      4   b      6
6      8   b      6
2      6   a      0
4      3   a      0
5      0   a      0
"""

1.2.2 pd.concat-Datenzusammenführung

Mehrere Objekte entlang einer Achse zusammenführen

NumPy-Konkat

import numpy as np
import pandas as pd

arr1 = np.random.randint(0, 10, (3, 4))
arr2 = np.random.randint(0, 10, (3, 4))

print(arr1)
print(arr2)

print(np.concatenate([arr1, arr2]))
print(np.concatenate([arr1, arr2], axis=1))

#运行结果
"""
# print(arr1)
[[3 3 0 8]
 [2 0 3 1]
 [4 8 8 2]]

# print(arr2)
[[6 8 7 3]
 [1 6 8 7]
 [1 4 7 1]]

# print(np.concatenate([arr1, arr2]))
 [[3 3 0 8]
 [2 0 3 1]
 [4 8 8 2]
 [6 8 7 3]
 [1 6 8 7]
 [1 4 7 1]]

# print(np.concatenate([arr1, arr2], axis=1)) 
[[3 3 0 8 6 8 7 3]
 [2 0 3 1 1 6 8 7]
 [4 8 8 2 1 4 7 1]]
"""

pd.concat
– Achten Sie auf die Angabe der Achsenrichtung, die Standardachse = 0
– Join gibt die Zusammenführungsmethode an, die Standardeinstellung ist äußere
– Überprüfen Sie, ob der Zeilenindex beim Zusammenführen von Serien dupliziert wird

df1 = pd.DataFrame(np.arange(6).reshape(3,2),index=list('abc'),columns=['one','two'])

df2 = pd.DataFrame(np.arange(4).reshape(2,2)+5,index=list('ac'),columns=['three','four'])

print(pd.concat([df1,df2])) #默认外连接，axis=0
print(pd.concat([df1,df2],axis='columns')) #指定axis=1连接
print(pd.concat([df1,df2],axis=1,join='inner'))
"""
   one  two  three  four
a  0.0  1.0    NaN   NaN
b  2.0  3.0    NaN   NaN
c  4.0  5.0    NaN   NaN
a  NaN  NaN    5.0   6.0
c  NaN  NaN    7.0   8.0
   one  two  three  four
a    0    1    5.0   6.0
b    2    3    NaN   NaN
c    4    5    7.0   8.0
   one  two  three  four
a    0    1      5     6
c    4    5      7     8
"""

1.3 Neuerfindung

1.3.1 Stapel

• Drehen Sie den Spaltenindex zum Zeilenindex, um die hierarchische Indizierung abzuschließen
• DataFrame->Serie

data = pd.DataFrame(np.arange(6).reshape((2, 3)),
                    index=pd.Index(['Ohio', 'Colorado'], name='state'),
                    columns=pd.Index(['one', 'two', 'three'],
                    name='number'))
print(data)

result = data.stack()
print(result)
#输出:
"""
number    one  two  three
state                    
Ohio        0    1      2
Colorado    3    4      5
state     number
Ohio      one       0
          two       1
          three     2
Colorado  one       3
          two       4
          three     5
dtype: int32
"""

1.3.2 entstapeln

• Hierarchischen Index erweitern
• Serie->DataFrame
• Die Standardoperation ist der innere Index, also Ebene = 1

# 默认操作内层索引
print(stacked.unstack())

# 通过level指定操作索引的级别
print(stacked.unstack(level=0))

"""
number    one  two  three
state                    
Ohio        0    1      2
Colorado    3    4      5
state   Ohio  Colorado
number                
one        0         3
two        1         4
three      2         5
"""

2 Zeitreihen

Zeitreihendaten sind eine wichtige Form strukturierter Daten. Jede zu mehreren Zeitpunkten beobachtete oder gemessene Zeit bildet eine zeitliche Abfolge. Oftmals hat die Zeitreihe eine feste Häufigkeit, das heißt, die Datenpunkte erscheinen regelmäßig nach einem bestimmten Muster (z. B. alle 15 Sekunden ...). Zeitreihen können auch unregelmäßig sein. Die Bedeutung von Zeitreihendaten hängt vom jeweiligen Anwendungsszenario ab. Besteht hauptsächlich aus folgenden Typen:

• Zeitstempel, ein bestimmter Moment.
• Fester Zeitraum (Zeitraum), z. B. Januar 2007 oder das ganze Jahr 2010.
• Zeitintervall (Intervall), dargestellt durch Start- und Endzeitstempel. Die Periode kann als Sonderfall des Intervalls betrachtet werden.

2.1 Python integriertes Zeitmodul

Die Python-Standardbibliothek enthält Datentypen für Datums- und Zeitdaten sowie Kalenderfunktionen. Wir werden hauptsächlich Datums-, Uhrzeit- und Kalendermodule verwenden. datetime.datetime (auch als datetime abgekürzt) ist der am häufigsten verwendete Datentyp:

from datetime import datetime

now = datetime.now()

now

"""
datetime.datetime(2023, 11, 1, 21, 25, 38, 531179)
"""

now.year, now.month, now.day
"""
(2023, 11, 1)   # 返回元组
"""

datetime speichert Datum und Uhrzeit in Millisekunden. timedelta stellt den Zeitunterschied zwischen zwei datetime-Objekten dar:

delta = datetime(2023, 1, 7) - datetime(2022, 6, 24, 8, 15)
delta
"""
datetime.timedelta(days=196, seconds=56700)
"""

delta.days

# 输出:
"""
196
"""

from datetime import timedelta
start = datetime(2022, 1, 7)
start + timedelta(31)
"""
datetime.datetime(2022, 2, 7, 0, 0)
"""

2.1.2 String und Datum/Uhrzeit ineinander konvertieren

stamp = datetime(2023, 10, 1)
stamp

#输出
datetime.datetime(2023, 10, 1, 0, 0)

"""将datetime对象转换成字符串"""

# 强制转换
str(stamp)

# 格式化
stamp.strftime("%Y-%m-%d %H:%M:%S")

#输出:
'2023-10-01 00:00:00'

"""将字符串转换成datetime对象"""

datetime.strptime('2023/5/20', '%Y/%m/%d')

#输出
datetime.datetime(2023, 5, 20, 0, 0)

d = ['2023/7/20', '2023/7/21', '2023/7/22']
pd.to_datetime(d)   # 转换后是 DatetimeIndex 对象

index = pd.to_datetime(d + [None])
index  # NaT 时间序列的缺失值

pd.isnull(index)

index.dropna() #删除NaT 时间序列的缺失值

2.2 Zeitreihen

Symbol	Bedeutung	Beispiel
%a	abgekürzter Wochentagsname	'Wed'
%A	Vollständiger Arbeitstagname	'Wednesday'
%w	Wochentagsnummer – 0 (Sonntag) bis 6 (Samstag)	'3'
%d	Tag des Monats (Nullauffüllung)	'13'
%b	abgekürzter Monatsname	'Jan'
%B	Vollständiger Monatsname	'January'
%m	Monat des Jahres	'01'
%y	Ein Jahr ohne Jahrhundert	'16'
%Y	Jahr mit Jahrhundert	'2016'
%H	Stunde im 24-Stunden-Format	'17'
%I	Stunde im 12-Stunden-Format	'05'
%p	Morgen Nachmittag	'PM'
%M	Minute	'00'
%S	Zweite	'00'
%f	Mikrosekunden	'000000'
%z	UTC-Offset für Objekte mit Zeitzonenerkennung	'-0500'
%Z	Zeitzonenname	'EST'
%j	ein Tag im Jahr	'013'
%W	Woche des Jahres	'02'
%c	Datums- und Uhrzeitdarstellung des aktuellen Gebietsschemas	'Wed Jan 13 17:00:00 2016'
%x	Datumsdarstellung für das aktuelle Gebietsschema	'01/13/16'
%X	Zeitdarstellung für das aktuelle Gebietsschema	'17:00:00'
%%	Wörtliche %Zeichen	'%'

dates = [datetime(2020, 12, 12), datetime(2020, 12, 13), 
         datetime(2020, 12, 14), datetime(2020, 12, 15), 
         datetime(2020, 12, 16)]


ts = pd.Series(np.random.randn(5), index=dates)
ts  # 创建一个 Series 对象, 以时间为行索引

#输出
2020-12-12    0.376037
2020-12-13    0.426828
2020-12-14    0.050578
2020-12-15    0.302734
2020-12-16   -0.068885
dtype: float64

ts.index  # 行索引是时间序列索引对象

输出
DatetimeIndex(['2020-12-12', '2020-12-13', '2020-12-14', '2020-12-15',
               '2020-12-16'],
              dtype='datetime64[ns]', freq=None)

2.2.1 Wert

ts

2020-12-12    0.376037
2020-12-13    0.426828
2020-12-14    0.050578
2020-12-15    0.302734
2020-12-16   -0.068885
dtype: float64

ts[::2]  # 取步长

2020-12-12    0.376037
2020-12-14    0.050578
2020-12-16   -0.068885
dtype: float64

2.2.2 Geschätzte Zeit

ts1 = pd.Series(
    data=np.random.randn(1000),
    index=pd.date_range('2020/01/01', periods=1000)
)

ts1

2020-01-01   -0.700438
2020-01-02   -1.961004
2020-01-03   -0.226558
2020-01-04   -0.594778
2020-01-05   -1.394763
                ...   
2022-09-22    0.025743
2022-09-23    0.784406
2022-09-24   -0.930995
2022-09-25    0.974117
2022-09-26   -1.625869
Freq: D, Length: 1000, dtype: float64

ts1['2021-05-18': '2021-05-27']  # 切片

2021-05-18   -0.487663
2021-05-19   -0.529925
2021-05-20   -0.316952
2021-05-21    0.476325
2021-05-22   -1.006280
2021-05-23    0.438202
2021-05-24    1.505284
2021-05-25    0.523409
2021-05-26   -1.139620
2021-05-27    0.573387
Freq: D, dtype: float64

2.2.3 Zeitbereich angeben

pd.date_range('2020-01-01', '2023-08-28')

DatetimeIndex(['2020-01-01', '2020-01-02', '2020-01-03', '2020-01-04',
               '2020-01-05', '2020-01-06', '2020-01-07', '2020-01-08',
               '2020-01-09', '2020-01-10',
               ...
               '2023-08-19', '2023-08-20', '2023-08-21', '2023-08-22',
               '2023-08-23', '2023-08-24', '2023-08-25', '2023-08-26',
               '2023-08-27', '2023-08-28'],
              dtype='datetime64[ns]', length=1336, freq='D')

pd.date_range(start='2020-01-01', periods=100)  # 往后推算100天
pd.date_range(end='2023-08-28', periods=100)  # 往前推算100天

Resampling und Frequenzumwandlung

Unter Resampling versteht man den Prozess der Konvertierung einer Zeitreihe von einer Frequenz in eine andere. Das Aggregieren hochfrequenter Daten in niedrige Frequenzen wird als Downsampling bezeichnet, während das Konvertieren niederfrequenter Daten in hohe Frequenzen als Upsampling bezeichnet wird. Nicht jedes Resampling kann in diese beiden großen Kategorien unterteilt werden. Beispielsweise ist die Konvertierung von W-WED (jeden Mittwoch) in W-FRI weder ein Downsampling noch ein Upsampling.

Alle Pandas-Objekte verfügen über eine Resample-Methode, die die Hauptfunktion für verschiedene Frequenzkonvertierungsaufgaben darstellt. resample verfügt über eine ähnliche API wie groupby. Durch den Aufruf von resample können Daten gruppiert und anschließend eine Aggregatfunktion aufgerufen werden.
resample ist eine flexible und effiziente Methode, mit der sehr große Zeitreihen verarbeitet werden können.

pd.date_range(start='2023-08-28', periods=10, freq='BH')  # freq指定时间频率

Ausgabe:

DatetimeIndex(['2023-08-28 09:00:00', '2023-08-28 10:00:00',
               '2023-08-28 11:00:00', '2023-08-28 12:00:00',
               '2023-08-28 13:00:00', '2023-08-28 14:00:00',
               '2023-08-28 15:00:00', '2023-08-28 16:00:00',
               '2023-08-29 09:00:00', '2023-08-29 10:00:00'],
              dtype='datetime64[ns]', freq='BH')