day8-그룹 집계 및 시계열

1 그룹 집계

1.1 데이터 집계 및 그룹화

단순 누적 방식을 사용하면 데이터 세트에 대한 전반적인 이해를 얻을 수 있지만 특정 태그나 인덱스 부분에 대해 누적 분석을 수행해야 하는 경우가 많으며, 이 경우 groupby가 필요합니다. "group by"라는 이름은 SQL 데이터베이스 언어의 명령에서 차용한 것이지만 R 언어 프레임을 발명한 Hadley Wickham의 분할, 적용 및 결합 아이디어를 참조하는 것이 더 적절할 수 있습니다.

분할, 적용 및 결합
"적용"이 합계 기능인 전형적인 분할-적용-결합 작업입니다.

아래 그림은 GroupBy 프로세스를 명확하게 설명합니다. 분할 단계에서는 지정된 키에 따라 DataFrame을 여러 그룹으로 분할합니다. 적용 단계에서는 각 그룹에 함수(일반적으로 누적, 변환 또는 필터 함수)를 적용합니다. 결합 단계에서는 각 그룹의 결과를 단일 출력 배열로 결합합니다.

앞서 소개한 일련의 마스킹, 누적 및 병합 작업을 통해 이를 달성할 수도 있지만 중간 분할 프로세스를 명시적으로 노출할 필요가 없다는 점을 인식하는 것이 중요합니다. 그리고 GroupBy는 (종종) 각 그룹의 합계, 평균, 개수, 최소값 및 기타 누적 값을 계산하는 데 단 한 줄의 코드만 필요합니다. GroupBy의 목적은 이러한 단계를 추상화하는 것입니다. 사용자는 작업을 전체적으로 보는 한 최하위 수준에서 계산하는 방법을 알 필요가 없습니다.

그룹바이:(by=없음,as_index=True)

by : 무엇을 그룹화할 것인지, groupby의 그룹을 결정하는 데 사용됩니다.

as_index : 집계 출력의 경우 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)

산출:

	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

여기서 반환 값은 DataFrame 개체가 아니라 DataFrameGroupBy 개체라는 점에 유의해야 합니다. 이 객체의 마법은 여러 데이터 세트를 숨기는 특별한 형태의 DataFrame으로 생각할 수 있지만 누적 함수를 적용하지 않으면 계산되지 않는다는 것입니다. 이 "지연 평가" 접근 방식을 사용하면 대부분의 일반적인 누적 작업을 사용자에게 거의 투명한 방식으로 매우 효율적으로 구현할 수 있습니다(작업이 존재하지 않는 것처럼 느껴짐).

이 결과를 얻으려면 DataFrameGroupBy 개체에 누적 함수를 적용하면 해당 적용/결합 단계가 완료되고 결과가 생성됩니다.

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

sum()은 사용 가능한 많은 메소드 중 하나일 뿐입니다. Pandas, NumPy 또는 유효한 DataFrame 객체의 누적 함수를 사용할 수 있습니다.

GroupBy 개체

GroupBy에서 가장 중요한 연산은 Aggregate , Filter , Transform , Apply (누산, 필터링, 변환, 적용)라고 할 수 있는데, 이에 대한 내용은 나중에 자세히 소개하도록 하겠습니다.이제 GroupBy의 몇 가지 기본 연산 방식을 소개하겠습니다.

(1) 열별로 값을 가져옵니다. DataFrame과 같은 GroupBy 개체도 열 단위 값을 지원하고 수정된 GroupBy 개체를 반환합니다. 예를 들면 다음과 같습니다.

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

집계(agg)

기능 이름	설명하다
세다	그룹 내 NA가 아닌 값의 개수
합집합	NA가 아닌 값의 합
평균	NA가 아닌 값의 평균
중앙값	NA가 아닌 값의 중앙값
표준, 변수	표준편차와 분산
최소 최대	NA가 아닌 최소값, 최대값
찌르다	NA가 아닌 값의 곱
처음, 마지막	NA가 아닌 첫 번째 및 마지막 값
예를 들어:

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

필터

"""分组后我们也可以对数据进行过滤<自定义规则过滤>"""
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 데이터 병합

1.2.1 pd.merge 데이터 병합

• 단일 또는 다중 키를 기반으로 다양한 DataFrame의 행 결합

• 데이터베이스와 유사한 연결 작업

• pd.merge :(왼쪽, 오른쪽, 방법='내부',on=없음,left_on=없음, right_on=없음 )

  왼쪽: 병합 시 왼쪽의 DataFrame

  오른쪽: 병합 시 오른쪽에 있는 DataFrame

  방법: 병합 방법, 기본값 'inner', 'outer', 'left', 'right'

  on: 병합할 컬럼 이름이 양쪽에 있어야 하며, 왼쪽과 오른쪽의 컬럼 이름이 교차하는 부분을 연결 키로 사용합니다.

  left_on: 조인 키로 사용되는 왼쪽 데이터 프레임의 열

  right_on: 조인 키로 사용되는 데이터프레임의 오른쪽 열

• 내부 조인: 두 테이블의 키 교차를 조인합니다.
  

• 완전 조인 외부: 두 테이블의 키 합집합

• 

• Left Join Left: 왼쪽 테이블의 모든 키를 조인합니다.

• 

• Right Join Right : 오른쪽 테이블의 모든 키를 합친 것
  

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

기본값은 "내부"(내부)입니다. 즉, 결과의 키는 교차점입니다.

연결 방법을 지정하는 방법

"외부"(외부), 결과의 핵심은 결합입니다

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
"""

중복된 열 이름 처리

• 매개변수 접미사: 기본값은 _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
"""

인덱스로 가입

• 매개변수 left_index=True 또는 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 데이터 병합

축을 따라 여러 개체를 함께 병합

NumPy 연결

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
- 축 방향 지정에 주의하세요. 기본 axis=0
- Join은 병합 방법을 지정하며, 기본값은 Outer입니다.
- Series 병합 시 행 인덱스가 중복되는지 확인합니다.

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 재창조

1.3.1 스택

• 계층적 인덱싱을 완료하려면 열 인덱스를 행 인덱스로 교체하세요.
• DataFrame->시리즈

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 언스택

• 계층적 인덱스 확장
• 시리즈->DataFrame
• 기본 연산은 내부 인덱스, 즉 level=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개

시계열 데이터는 구조화된 데이터의 중요한 형태입니다. 여러 시점에서 관찰되거나 측정된 시간은 시간에 따른 순서를 형성합니다. 시계열은 고정된 빈도를 갖는 경우가 많습니다. 즉, 데이터 포인트가 특정 패턴(예: 15초마다...)에 따라 규칙적으로 나타납니다. 시계열은 불규칙할 수도 있습니다. 시계열 데이터의 의미는 특정 애플리케이션 시나리오에 따라 다릅니다. 주로 다음 유형으로 구성됩니다.

• 타임스탬프, 특정 순간.
• 2007년 1월 또는 2010년 전체와 같은 고정 기간(기간)입니다.
• 시작 및 종료 타임스탬프로 표시되는 시간 간격(간격)입니다. 기간은 간격의 특별한 경우로 생각할 수 있습니다.

2.1 파이썬 내장 시간 모듈

Python 표준 라이브러리에는 날짜 및 시간 데이터에 대한 데이터 유형과 달력 기능이 포함되어 있습니다. 우리는 주로 날짜/시간, 시간, 달력 모듈을 사용할 것입니다. datetime.datetime(datetime이라고도 함)은 가장 일반적으로 사용되는 데이터 유형입니다.

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은 날짜와 시간을 밀리초 단위로 저장합니다. timedelta는 두 날짜/시간 객체 간의 시간 차이를 나타냅니다.

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 문자열과 날짜/시간을 서로 변환

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 시계열

상징	의미	예
%a	축약된 요일 이름	'Wed'
%A	전체 근무일 이름	'Wednesday'
%w	요일번호 - 0(일요일) ~ 6(토요일)	'3'
%d	해당 월의 일(제로 패딩)	'13'
%b	약식 월 이름	'Jan'
%B	전체 월 이름	'January'
%m	올해의 달	'01'
%y	백 년도 없는 해	'16'
%Y	세기가 있는 연도	'2016'
%H	24시간제의 시간	'17'
%I	12시간제의 시간	'05'
%p	아침 오후	'PM'
%M	분	'00'
%S	두번째	'00'
%f	마이크로초	'000000'
%z	시간대 인식 객체에 대한 UTC 오프셋	'-0500'
%Z	시간대 이름	'EST'
%j	일년 중 어느 날	'013'
%W	올해의 주	'02'
%c	현재 로케일의 날짜 및 시간 표현	'Wed Jan 13 17:00:00 2016'
%x	현재 로케일의 날짜 표현	'01/13/16'
%X	현재 로케일의 시간 표현	'17:00:00'
%%	리터럴 %문자	'%'

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 가치

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 예상 시간

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 시간 범위 지정

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天

리샘플링 및 주파수 변환

리샘플링은 시계열을 한 주파수에서 다른 주파수로 변환하는 프로세스를 의미합니다. 고주파수 데이터를 저주파로 집계하는 것을 다운샘플링이라고 하고, 저주파 데이터를 고주파수로 변환하는 것을 업샘플링이라고 합니다. 모든 리샘플링을 이 두 가지 광범위한 범주로 나눌 수 있는 것은 아닙니다. 예를 들어 W-WED(매주 수요일)를 W-FRI로 변환하는 것은 다운샘플링도 업샘플링도 아닙니다.

모든 pandas 객체에는 다양한 빈도 변환 작업의 주요 기능인 resample 메서드가 있습니다. resample에는 groupby와 유사한 API가 있습니다. resample을 호출하면 데이터를 그룹화한 다음 집계 함수를 호출할 수 있습니다.
resample은 매우 큰 시계열을 처리하는 데 사용할 수 있는 유연하고 효율적인 방법입니다.

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

산출:

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