时间序列

1.日期和时间数据类型及工具

# 日期和时间数据类型及工具

from datetime import datetime

d=datetime.now()

d

datetime.datetime(2023, 12, 18, 14, 58, 7, 750689)

# datetime.datetime(2023, 12, 18, 10, 2, 26, 974645)，datetime.后面的datetime是一种数据类型。datetime还有其他的数据类型：
# date 以公历形式存储日历日期（年、月、日）
# time 以时间存储为时、分、秒、毫秒
# datetime 存储日期和时间
# timedelta 表示2个时间值的差（日、秒、毫秒）

1.1 数据类型

1.1.1 date

d.date()

datetime.date(2023, 12, 18)

1.1.2 time

d.time()

datetime.time(14, 58, 7, 750689)

1.1.3 datetime

1.1.4 timedelta

start = datetime(2023,12,18)
end = datetime(1986,12,11)
delta = start-end

delta

datetime.timedelta(days=13521)

1.2 类

1.2.1 datetime 类

# datetime 类：
# datetime(year, month, day[, hour[, minute[, second[, microsecond[, tzinfo]]]]])：创建一个表示日期和时间的对象。

current_datetime = datetime.now()
current_datetime

datetime.datetime(2023, 12, 18, 14, 58, 10, 358578)

1.2.2 date 类

# date 类：
# date(year, month, day)：创建一个表示日期的对象。

from datetime import date

specific_date = date(2023, 1, 1)
specific_date

datetime.date(2023, 1, 1)

1.2.3 time 类

# time 类：
# time([hour[, minute[, second[, microsecond[, tzinfo]]]]])：创建一个表示时间的对象。

from datetime import time

specific_time = time(12, 30, 0)
specific_time

datetime.time(12, 30)

1.2.4 datetime 类

from datetime import datetime

# 将字符串转换为 datetime 对象
date_string = "2023-01-01 12:30:00"
formatted_datetime = datetime.strptime(date_string, "%Y-%m-%d %H:%M:%S")
formatted_datetime

datetime.datetime(2023, 1, 1, 12, 30)

# datetime 模块的常用函数：
# datetime.now([tz])：返回当前日期和时间。
# datetime.combine(date, time)：将日期和时间合并为一个 datetime 对象。
# datetime.strptime(date_string, format)：根据指定的格式将字符串转换为 datetime 对象。
# datetime.strftime(format)：将 datetime 对象格式化为字符串。

1.2.5 timedelta 类

# timedelta 类：
# timedelta(days[, seconds[, microseconds[, milliseconds[, minutes[, hours[, weeks]]]]]])：表示两个日期或时间之间的差异。

from datetime import datetime, timedelta

# 计算两个日期之间的差异
start_date = datetime(2023, 1, 1)
end_date = datetime(2023, 1, 10)
difference = end_date - start_date
difference

datetime.timedelta(days=9)

# 使用 timedelta 类的方法获取天数和总秒数
days_difference = difference.days
seconds_difference = difference.seconds

days_difference

9

seconds_difference

0

# 创建一个 timedelta 对象表示一段时间
custom_timedelta = timedelta(days=5, hours=3, minutes=30)
# 使用 timedelta 对象进行日期时间运算
new_date = start_date + custom_timedelta
new_date

datetime.datetime(2023, 1, 6, 3, 30)

1.2.6 timezone 类

# timezone 类：
# timezone(offset, name=None)：表示时区信息，可以与 datetime 对象一起使用。

from datetime import datetime, timezone, timedelta

# 创建带有时区信息的 datetime 对象
dt_with_timezone = datetime(2023, 1, 1, tzinfo=timezone(timedelta(hours=8)))
dt_with_timezone

datetime.datetime(2023, 1, 1, 0, 0, tzinfo=datetime.timezone(datetime.timedelta(seconds=28800)))

2.时间序列基础

pandas最基本的时间序列类型就是时间戳

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

import pymysql
import pandas as pd

db = pymysql.connect(
    host='000.000.000.000',
    port=3306,
    user='root',
    password='root',
    database='rating_data'
)

sql = "SELECT * from t_pca_fi_report"

df_1 = pd.read_sql(sql,db)

C:\Users\hspcadmin\AppData\Local\Temp\ipykernel_820\2659158565.py:1: UserWarning: pandas only supports SQLAlchemy connectable (engine/connection) or database string URI or sqlite3 DBAPI2 connection. Other DBAPI2 objects are not tested. Please consider using SQLAlchemy.
  df_1 = pd.read_sql(sql,db)

df_1

dates = df_1['report_date']

dates

0     2023-07-17
1     2023-08-08
2     2023-05-30
3     2023-07-28
4     2023-08-02
         ...    
60    2023-11-01
61    2023-11-01
62    2023-11-01
63    2023-10-31
64    2023-12-18
Name: report_date, Length: 65, dtype: object

dates[1]

datetime.date(2023, 8, 8)

type(dates[1])

datetime.date

type(dates)

pandas.core.series.Series

ts = df_1['report_date']

type(ts)

pandas.core.series.Series

ts

0     2023-07-17
1     2023-08-08
2     2023-05-30
3     2023-07-28
4     2023-08-02
         ...    
60    2023-11-01
61    2023-11-01
62    2023-11-01
63    2023-10-31
64    2023-12-18
Name: report_date, Length: 65, dtype: object

ts.values

array([datetime.date(2023, 7, 17), datetime.date(2023, 8, 8),
       datetime.date(2023, 5, 30), datetime.date(2023, 7, 28),
       datetime.date(2023, 8, 2), datetime.date(2023, 5, 30),
       datetime.date(2023, 5, 31), datetime.date(2023, 5, 31),
       datetime.date(2023, 5, 31), datetime.date(2023, 5, 30),
       datetime.date(2023, 7, 17), datetime.date(2023, 10, 17),
       datetime.date(2023, 5, 30), datetime.date(2023, 5, 30),
       datetime.date(2023, 3, 27), datetime.date(2022, 12, 23),
       datetime.date(2023, 9, 18), datetime.date(2023, 9, 14),
       datetime.date(2023, 8, 1), datetime.date(2023, 2, 13),
       datetime.date(2023, 5, 8), datetime.date(2023, 5, 30),
       datetime.date(2023, 9, 4), datetime.date(2023, 1, 18),
       datetime.date(2023, 5, 30), datetime.date(2023, 7, 5),
       datetime.date(2023, 5, 4), datetime.date(2023, 5, 30),
       datetime.date(2023, 9, 5), datetime.date(2023, 5, 7),
       datetime.date(2023, 5, 8), datetime.date(2023, 6, 1),
       datetime.date(2023, 5, 31), datetime.date(2023, 1, 17),
       datetime.date(2023, 5, 30), datetime.date(2023, 7, 30),
       datetime.date(2023, 5, 30), datetime.date(2023, 5, 30),
       datetime.date(2023, 7, 17), datetime.date(2023, 10, 17),
       datetime.date(2023, 9, 10), datetime.date(2023, 8, 18),
       datetime.date(2023, 10, 1), datetime.date(2023, 10, 27),
       datetime.date(2023, 10, 27), datetime.date(2023, 10, 1),
       datetime.date(2023, 10, 29), datetime.date(2021, 11, 7),
       datetime.date(2023, 10, 24), datetime.date(2022, 6, 6),
       datetime.date(2023, 7, 18), datetime.date(2023, 8, 24),
       datetime.date(2023, 10, 3), datetime.date(2023, 2, 7),
       datetime.date(2023, 1, 18), datetime.date(2021, 3, 4),
       datetime.date(2023, 11, 27), datetime.date(2023, 11, 28),
       datetime.date(2023, 10, 29), datetime.date(2023, 10, 30),
       datetime.date(2023, 11, 1), datetime.date(2023, 11, 1),
       datetime.date(2023, 11, 1), datetime.date(2023, 10, 31),
       datetime.date(2023, 12, 18)], dtype=object)

# 将 'update_time' 列转换为日期时间格式
df_1['date_index'] = pd.to_datetime(ts)
df_1.set_index('date_index', inplace=True)

df_1

df_restored = df_1.reset_index()

df_restored

2.1 索引、选取、子集构造

# df索引指定行
df_1.iloc[0]

id                                                                 1
emerald_id                                               3579_entity
entity_name                                       上海华培动力科技(集团)股份有限公司
sector                                                          金融机构
report_date                                               2023-07-17
update_time                                      2023-09-04 17:25:19
operation_tag                                                       
doc_version                                                   v2.4.0
doc                {"entityName":"上海华培动力科技(集团)股份有限公司","entityShor...
anchor                                                          bbb+
sacp                                                             aaa
icr                                                              aaa
analyst_name                                                 金融机构总经理
create_datetime                                  2023-10-17 14:33:41
Name: 2023-07-17 00:00:00, dtype: object

# df索引指定列
df_1['id']

date_index
2023-07-17     1
2023-08-08     2
2023-05-30     3
2023-07-28     4
2023-08-02     5
              ..
2023-11-01    61
2023-11-01    62
2023-11-01    63
2023-10-31    64
2023-12-18    65
Name: id, Length: 65, dtype: int64

ts = df_1['report_date']

ts

date_index
2023-07-17    2023-07-17
2023-08-08    2023-08-08
2023-05-30    2023-05-30
2023-07-28    2023-07-28
2023-08-02    2023-08-02
                 ...    
2023-11-01    2023-11-01
2023-11-01    2023-11-01
2023-11-01    2023-11-01
2023-10-31    2023-10-31
2023-12-18    2023-12-18
Name: report_date, Length: 65, dtype: object

ts.index[1]

Timestamp('2023-08-08 00:00:00')

ts.index[2]

Timestamp('2023-05-30 00:00:00')

# 确保索引已排序
ts.sort_index(inplace=True)

# 使用 truncate 截取某个日期之后的数据
ts.truncate(after='2023/08/11')

date_index
2021-03-04    2021-03-04
2021-11-07    2021-11-07
2022-06-06    2022-06-06
2022-12-23    2022-12-23
2023-01-17    2023-01-17
2023-01-18    2023-01-18
2023-01-18    2023-01-18
2023-02-07    2023-02-07
2023-02-13    2023-02-13
2023-03-27    2023-03-27
2023-05-04    2023-05-04
2023-05-07    2023-05-07
2023-05-08    2023-05-08
2023-05-08    2023-05-08
2023-05-30    2023-05-30
2023-05-30    2023-05-30
2023-05-30    2023-05-30
2023-05-30    2023-05-30
2023-05-30    2023-05-30
2023-05-30    2023-05-30
2023-05-30    2023-05-30
2023-05-30    2023-05-30
2023-05-30    2023-05-30
2023-05-30    2023-05-30
2023-05-30    2023-05-30
2023-05-31    2023-05-31
2023-05-31    2023-05-31
2023-05-31    2023-05-31
2023-05-31    2023-05-31
2023-06-01    2023-06-01
2023-07-05    2023-07-05
2023-07-17    2023-07-17
2023-07-17    2023-07-17
2023-07-17    2023-07-17
2023-07-18    2023-07-18
2023-07-28    2023-07-28
2023-07-30    2023-07-30
2023-08-01    2023-08-01
2023-08-02    2023-08-02
2023-08-08    2023-08-08
Name: report_date, dtype: object

2.2 带有重复索引的时间序列

# 通过检查索引是否唯一不重复，如果是False，则表示存在重复索引
ts.index.is_unique

False

# 通过group by进行聚合
grouped = ts.groupby(level=0)

grouped

<pandas.core.groupby.generic.SeriesGroupBy object at 0x000001EA43158AD0>

grouped.count()

date_index
2021-03-04     1
2021-11-07     1
2022-06-06     1
2022-12-23     1
2023-01-17     1
2023-01-18     2
2023-02-07     1
2023-02-13     1
2023-03-27     1
2023-05-04     1
2023-05-07     1
2023-05-08     2
2023-05-30    11
2023-05-31     4
2023-06-01     1
2023-07-05     1
2023-07-17     3
2023-07-18     1
2023-07-28     1
2023-07-30     1
2023-08-01     1
2023-08-02     1
2023-08-08     1
2023-08-18     1
2023-08-24     1
2023-09-04     1
2023-09-05     1
2023-09-10     1
2023-09-14     1
2023-09-18     1
2023-10-01     2
2023-10-03     1
2023-10-17     2
2023-10-24     1
2023-10-27     2
2023-10-29     2
2023-10-30     1
2023-10-31     1
2023-11-01     3
2023-11-27     1
2023-11-28     1
2023-12-18     1
Name: report_date, dtype: int64

ts

date_index
2021-03-04    2021-03-04
2021-11-07    2021-11-07
2022-06-06    2022-06-06
2022-12-23    2022-12-23
2023-01-17    2023-01-17
                 ...    
2023-11-01    2023-11-01
2023-11-01    2023-11-01
2023-11-27    2023-11-27
2023-11-28    2023-11-28
2023-12-18    2023-12-18
Name: report_date, Length: 65, dtype: object

3 日期的范围、频率及移动

df_restored = df_1.reset_index()

df_restored

df_1

3.1 生成日期范围

index = pd.date_range('2023-05-30','2023-11-01')

index

DatetimeIndex(['2023-05-30', '2023-05-31', '2023-06-01', '2023-06-02',
               '2023-06-03', '2023-06-04', '2023-06-05', '2023-06-06',
               '2023-06-07', '2023-06-08',
               ...
               '2023-10-23', '2023-10-24', '2023-10-25', '2023-10-26',
               '2023-10-27', '2023-10-28', '2023-10-29', '2023-10-30',
               '2023-10-31', '2023-11-01'],
              dtype='datetime64[ns]', length=156, freq='D')

• start: 起始日期，可以是字符串、datetime 对象或 Timestamp。如果没有指定，则默认为当前日期。
• end: 结束日期，可以是字符串、datetime 对象或 Timestamp。如果没有指定，则默认为当前日期。
• periods: 生成日期范围的长度，与 end 参数互斥。如果指定了 periods，那么 end 将被忽略。
• freq: 频率，表示时间间隔。可以是字符串（如 'D' 表示天，'H' 表示小时）或 DateOffset 对象。默认为 'D'，即按天间隔。
• tz: 时区，表示生成的日期范围的时区。
• normalize: 如果设置为 True，生成的日期范围将会被规范化，将时分秒等时间部分设为 00:00:00。
• name: 为返回的索引对象指定一个名称。
• closed: 控制区间的开闭，可以是 'right'、'left'、'both' 或 'neither'。默认为 'right'，表示右闭区间。
• freq: 字符串别名或 DateOffset 对象，表示频率。例如，'B' 表示工作日频率。
• normalize: 如果为 True，则规范化时间戳，将时分秒等部分设置为 00:00:00。

3.2 频率和日期偏移量

index = pd.date_range('2023-05-30','2023-11-01',freq='4H')

index

DatetimeIndex(['2023-05-30 00:00:00', '2023-05-30 04:00:00',
               '2023-05-30 08:00:00', '2023-05-30 12:00:00',
               '2023-05-30 16:00:00', '2023-05-30 20:00:00',
               '2023-05-31 00:00:00', '2023-05-31 04:00:00',
               '2023-05-31 08:00:00', '2023-05-31 12:00:00',
               ...
               '2023-10-30 12:00:00', '2023-10-30 16:00:00',
               '2023-10-30 20:00:00', '2023-10-31 00:00:00',
               '2023-10-31 04:00:00', '2023-10-31 08:00:00',
               '2023-10-31 12:00:00', '2023-10-31 16:00:00',
               '2023-10-31 20:00:00', '2023-11-01 00:00:00'],
              dtype='datetime64[ns]', length=931, freq='4H')

from pandas.tseries.offsets import Hour
# 设置便宜时间
datel_time = Hour(4)

index = pd.date_range('2023-05-30','2023-11-01',freq=datel_time)

index

DatetimeIndex(['2023-05-30 00:00:00', '2023-05-30 04:00:00',
               '2023-05-30 08:00:00', '2023-05-30 12:00:00',
               '2023-05-30 16:00:00', '2023-05-30 20:00:00',
               '2023-05-31 00:00:00', '2023-05-31 04:00:00',
               '2023-05-31 08:00:00', '2023-05-31 12:00:00',
               ...
               '2023-10-30 12:00:00', '2023-10-30 16:00:00',
               '2023-10-30 20:00:00', '2023-10-31 00:00:00',
               '2023-10-31 04:00:00', '2023-10-31 08:00:00',
               '2023-10-31 12:00:00', '2023-10-31 16:00:00',
               '2023-10-31 20:00:00', '2023-11-01 00:00:00'],
              dtype='datetime64[ns]', length=931, freq='4H')

index = pd.date_range('2023-05-30','2023-11-01',freq='2h30min')
index

DatetimeIndex(['2023-05-30 00:00:00', '2023-05-30 02:30:00',
               '2023-05-30 05:00:00', '2023-05-30 07:30:00',
               '2023-05-30 10:00:00', '2023-05-30 12:30:00',
               '2023-05-30 15:00:00', '2023-05-30 17:30:00',
               '2023-05-30 20:00:00', '2023-05-30 22:30:00',
               ...
               '2023-10-31 01:30:00', '2023-10-31 04:00:00',
               '2023-10-31 06:30:00', '2023-10-31 09:00:00',
               '2023-10-31 11:30:00', '2023-10-31 14:00:00',
               '2023-10-31 16:30:00', '2023-10-31 19:00:00',
               '2023-10-31 21:30:00', '2023-11-01 00:00:00'],
              dtype='datetime64[ns]', length=1489, freq='150T')

时间序列的基础频率：

3.3 移动（超前和滞后）数据

移动指的是沿着时间轴将数据前移或者后移。Series和DataFrame都有shift方法，用于执行单纯的前移和后移操作，保持索引不变。

import akshare as ak
stock_zh_a_hist_df = ak.stock_zh_a_hist(symbol="600570", period="daily", start_date="20230101", end_date='20231218', adjust="qfq")
stock_zh_a_hist_df

上面的例子中，存在一个涨跌幅，我们现在通过shift方法，看看是不是也能计算出这个数值来。

# shift通常用于计算一个时间序列或者多个时间序列（如DataFrame的列）中的百分比变化。
# 新增一个“涨跌幅—新计算”列
# shift(1)向后移动
# stock_zh_a_hist_df['涨跌幅-新计算'] = (stock_zh_a_hist_df['收盘']/stock_zh_a_hist_df.shift(1)['收盘']-1)*100
stock_zh_a_hist_df['涨跌幅-新计算'] = (stock_zh_a_hist_df['收盘']-stock_zh_a_hist_df.shift(1)['收盘'])*100/stock_zh_a_hist_df.shift(1)['收盘']

stock_zh_a_hist_df

3.4 通过偏移量对日期进行位移

from pandas.tseries.offsets import Day,MonthEnd
now = datetime.now()

now

datetime.datetime(2023, 12, 18, 16, 12, 47, 706090)

now.strftime('%Y-%m-%d')

'2023-12-18'

now_new = now+3*Day()

now_new

Timestamp('2023-12-21 16:12:47.706090')

now_new.strftime('%Y-%m-%d')

'2023-12-21'

4 时区处理

import pytz

# 略，以后用到了再学习。

5 时期及其算术运算

# DataFrame的Period类表示时间区间，比如数日、数月、数季、数年
p = pd.Period(2023,freq='A-DEC')

p

Period('2023', 'A-DEC')

p+5

Period('2028', 'A-DEC')

p-2

Period('2021', 'A-DEC')

v = pd.Period('2028', 'A-DEC')-p

v

<5 * YearEnds: month=12>

5.1 时间的频率转换

# asfreq方法

p = pd.Period(2021,freq='A-DEC')

p.asfreq('M',how='start')

Period('2021-01', 'M')

p.asfreq('M',how='end')

Period('2021-12', 'M')

5.1.1 案例分析

import pandas as pd

# 创建一个示例 DataFrame
data = {
    'date': pd.to_datetime(['2023-01-01', '2023-01-21','2023-02-01', '2023-03-01']),
    'sales': [100, 120, 150, 200]
}

df = pd.DataFrame(data)

# 将日期列转换为时期对象
# df.dt.to_period() 是 Pandas 中用于将日期时间列转换为时期（Period）的方法。它允许你改变日期时间的表示形式，从而更方便地进行时期性的分析。
# 详细解释,见下面
df['month'] = df['date'].dt.to_period(freq='M')

# 输出原始 DataFrame
print("原始 DataFrame:")
print(df)

# 将月份时期调整为日频率，使用最后一天表示整个月的销售额
df['last_day_of_month'] = df['month'].apply(lambda x: x.asfreq('D', 'e'))
print("\n调整频率后的 DataFrame:")
print(df)

原始 DataFrame:
        date  sales    month
0 2023-01-01    100  2023-01
1 2023-01-21    120  2023-01
2 2023-02-01    150  2023-02
3 2023-03-01    200  2023-03

调整频率后的 DataFrame:
        date  sales    month last_day_of_month
0 2023-01-01    100  2023-01        2023-01-31
1 2023-01-21    120  2023-01        2023-01-31
2 2023-02-01    150  2023-02        2023-02-28
3 2023-03-01    200  2023-03        2023-03-31

df.dt 是 DataFrame 对象上的属性

• df['date'].dt.year： 提取年份。
• df['date'].dt.month： 提取月份。
• df['date'].dt.day： 提取日期。
• df['date'].dt.hour： 提取小时。
• df['date'].dt.minute： 提取分钟。
• df['date'].dt.second： 提取秒数。
• df['date'].dt.microsecond： 提取微秒。
• df['date'].dt.quarter： 提取季度信息。
• df['date'].dt.is_leap_year： 检查是否是闰年。
• df['date'].dt.is_month_start： 检查是否是月初。
• df['date'].dt.is_month_end： 检查是否是月末。
• df['date'].dt.is_quarter_start： 检查是否是季度初。
• df['date'].dt.is_quarter_end： 检查是否是季度末。
• df['date'].dt.is_year_start： 检查是否是年初。
• df['date'].dt.is_year_end： 检查是否是年末。
• df['date'].dt.to_period(freq='M')： 将日期时间列转换为时期对象，可以指定频率，例如 'M' 表示月份。

5.1.2 季节性销售分析

假设你有一份销售数据，日期以月为单位。你想要进行季节性分析，找出每年同一季度的销售趋势。

import pandas as pd

# 创建一个示例 DataFrame
data = {
    'date': pd.to_datetime(['2022-01-01', '2022-01-21', '2022-04-15', '2022-08-20', '2023-01-05', '2023-04-10']),
    'sales': [100, 110, 120, 150, 110, 130]
}

df = pd.DataFrame(data)

# 将日期列转换为季度时期对象
df['quarter'] = df['date'].dt.to_period(freq='Q')

# 输出原始 DataFrame
print("原始 DataFrame:")
print(df)

# 计算每个季度的总销售额
quarterly_sales = df.groupby('quarter')['sales'].sum()
print("\n每个季度的总销售额:")
print(quarterly_sales)

原始 DataFrame:
        date  sales quarter
0 2022-01-01    100  2022Q1
1 2022-01-21    110  2022Q1
2 2022-04-15    120  2022Q2
3 2022-08-20    150  2022Q3
4 2023-01-05    110  2023Q1
5 2023-04-10    130  2023Q2

每个季度的总销售额:
quarter
2022Q1    210
2022Q2    120
2022Q3    150
2023Q1    110
2023Q2    130
Freq: Q-DEC, Name: sales, dtype: int64

5.1.3 数据可视化

假设你有一份每日的气温数据，但你想在图表上显示每周的平均温度，以平滑曲线显示趋势。

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.dates import WeekdayLocator
from matplotlib.ticker import MaxNLocator

# 设置中文字体为SimHei
plt.rcParams['font.family'] = 'SimHei'

# 创建一个示例 DataFrame
date_rng = pd.date_range('2022-01-01', '2022-12-31', freq='D')
temperature = np.random.randint(20, 30, size=len(date_rng))

df = pd.DataFrame({'date': date_rng, 'temperature': temperature})

# 将日期列转换为周时期对象
df['week'] = df['date'].dt.to_period(freq='W')

# 输出原始 DataFrame
print("原始 DataFrame:")
print(df.head())

# 计算每周的平均温度
weekly_avg_temperature = df.groupby('week')['temperature'].mean().reset_index()

# 调整图表大小
fig, ax = plt.subplots(figsize=(8, 4))

# 绘制图表
ax.plot(weekly_avg_temperature['week'].dt.strftime('%m-%d'), weekly_avg_temperature['temperature'], marker='o')
ax.set_title('周平均气温')
ax.set_xlabel('日期')
ax.set_ylabel('气温(°C)')

# 设置每隔N周显示一个刻度
N = 1  # 每隔2周显示一个刻度
ax.xaxis.set_major_locator(WeekdayLocator(interval=N))
ax.xaxis.set_major_locator(MaxNLocator(integer=True))  # 设置为整数刻度

plt.xticks(rotation=45, ha='right')  # 旋转刻度标签
plt.tight_layout()  # 调整布局以防止重叠
plt.show()

原始 DataFrame:
        date  temperature                   week
0 2022-01-01           26  2021-12-27/2022-01-02
1 2022-01-02           25  2021-12-27/2022-01-02
2 2022-01-03           25  2022-01-03/2022-01-09
3 2022-01-04           26  2022-01-03/2022-01-09
4 2022-01-05           24  2022-01-03/2022-01-09

5.1.4 数据聚合：按季度计算总销售额

假设你有一个包含每日销售数据的 DataFrame，你想按季度聚合数据并计算每个季度的总销售额。

import pandas as pd

# 创建一个示例 DataFrame
date_rng = pd.date_range('2022-01-01', '2022-12-31', freq='D')
sales_data = {'date': date_rng, 'sales': np.random.randint(50, 200, size=len(date_rng))}
df = pd.DataFrame(sales_data)

# 将日期列转换为季度时期对象
df['quarter'] = df['date'].dt.to_period(freq='Q')

# 输出原始 DataFrame
print("原始 DataFrame:")
print(df.head())

# 按季度聚合数据并计算总销售额
quarterly_sales_total = df.groupby('quarter')['sales'].sum().reset_index()
print("\n每个季度的总销售额:")
print(quarterly_sales_total)

原始 DataFrame:
        date  sales quarter
0 2022-01-01    173  2022Q1
1 2022-01-02    118  2022Q1
2 2022-01-03     78  2022Q1
3 2022-01-04    109  2022Q1
4 2022-01-05     76  2022Q1

每个季度的总销售额:
  quarter  sales
0  2022Q1  11392
1  2022Q2  12454
2  2022Q3  11402
3  2022Q4  11234

5.1.5 数据切片和选择：选择特定季度的销售数据

假设你想选择特定季度的销售数据进行进一步分析，你可以使用布尔索引来选择特定季度的数据。

# 选择特定季度的销售数据
target_quarter = '2022Q2'
sales_in_target_quarter = df[df['quarter'] == target_quarter]
print(f"\n{target_quarter} 的销售数据:")
print(sales_in_target_quarter)

2022Q2 的销售数据:
        date  sales quarter
1 2022-04-15    120  2022Q2

5.2 通过数组创建PeiodIndex

import pandas as pd
import random

def generate_sales_data(start_year, end_year):
    data = {'Year': [], 'Quarter': [], 'Sales': []}

    for year in range(start_year, end_year + 1):
        for quarter in range(1, 5):
            data['Year'].append(year)
            data['Quarter'].append(quarter)
            # 生成随机销售数据，这里使用了 random 模块，你可以根据实际情况修改生成规则
            data['Sales'].append(random.randint(100000, 500000))

    df = pd.DataFrame(data)
    return df

# 指定起始年份和结束年份，比如从 2020 年到 2022 年
start_year = 2020
end_year = 2022

sales_data = generate_sales_data(start_year, end_year)

# 打印生成的销售数据
sales_data

sales_data.Year

0     2020
1     2020
2     2020
3     2020
4     2021
5     2021
6     2021
7     2021
8     2022
9     2022
10    2022
11    2022
Name: Year, dtype: int64

sales_data.Quarter

0     1
1     2
2     3
3     4
4     1
5     2
6     3
7     4
8     1
9     2
10    3
11    4
Name: Quarter, dtype: int64

# 现在将两个数组以及一个频率传入PeriodIndex，就可以将他们合并成DataFrame的一个索引

index = pd.PeriodIndex(year=sales_data.Year,quarter=sales_data.Quarter,freq='Q-DEC')

index

PeriodIndex(['2020Q1', '2020Q2', '2020Q3', '2020Q4', '2021Q1', '2021Q2',
             '2021Q3', '2021Q4', '2022Q1', '2022Q2', '2022Q3', '2022Q4'],
            dtype='period[Q-DEC]')

sales_data.index = index

sales_data

6 重采样及频率转换

# 重采样，指将时间序列从一个频率转换到另一个频率的处理过程。

# 高频率-》低频率：降采样

# 低频率-》高频率：升采样

s = sales_data['Sales']

s

2020Q1    144418
2020Q2    244268
2020Q3    425860
2020Q4    439691
2021Q1    403592
2021Q2    495826
2021Q3    223561
2021Q4    156590
2022Q1    346261
2022Q2    209534
2022Q3    268904
2022Q4    191569
Freq: Q-DEC, Name: Sales, dtype: int64

6.1 低频转高频

# 低频转高频
s.resample('M').sum()

2020-01    144418.0
2020-02         NaN
2020-03         NaN
2020-04    244268.0
2020-05         NaN
2020-06         NaN
2020-07    425860.0
2020-08         NaN
2020-09         NaN
2020-10    439691.0
2020-11         NaN
2020-12         NaN
2021-01    403592.0
2021-02         NaN
2021-03         NaN
2021-04    495826.0
2021-05         NaN
2021-06         NaN
2021-07    223561.0
2021-08         NaN
2021-09         NaN
2021-10    156590.0
2021-11         NaN
2021-12         NaN
2022-01    346261.0
2022-02         NaN
2022-03         NaN
2022-04    209534.0
2022-05         NaN
2022-06         NaN
2022-07    268904.0
2022-08         NaN
2022-09         NaN
2022-10    191569.0
2022-11         NaN
2022-12         NaN
Freq: M, Name: Sales, dtype: float64

6.2 高频转低频

# 高频转低频
s.resample('Y').sum()

2020    1254237
2021    1279569
2022    1016268
Freq: A-DEC, Name: Sales, dtype: int64

6.3 OHLC重采样

s.resample('5min').ohlc()

6.4 通过groupby进行重采样

s.groupby(lambda x:x.month).mean()

3     298090.333333
6     316542.666667
9     306108.333333
12    262616.666667
Name: Sales, dtype: float64

7 时间序列绘图

import akshare as ak
stock_zh_a_tick_tx_js_df = ak.stock_zh_a_tick_tx_js(symbol="sh600570")

D:\Program Files\Python\Python311\Lib\site-packages\akshare\stock\stock_zh_a_tick_tx.py:27: UserWarning: 正在下载数据，请稍等
  warnings.warn("正在下载数据，请稍等")

stock_zh_a_tick_tx_js_df

import matplotlib.pyplot as plt
stock_zh_a_tick_tx_js_df['成交价格'].plot()

<Axes: >

# 将“成交时间”作为index

stock_zh_a_tick_tx_js_df.set_index('成交时间',inplace=True)

stock_zh_a_tick_tx_js_df

# 设置中文字体为SimHei
plt.rcParams['font.family'] = 'SimHei'
stock_zh_a_tick_tx_js_df.plot()

<Axes: xlabel='成交时间'>

# 调整图表大小
fig, ax = plt.subplots(figsize=(15, 5))
stock_zh_a_tick_tx_js_df['成交价格'].plot()

<Axes: xlabel='成交时间'>

8 移动窗口函数

8.1 移动窗口函数

a = stock_zh_a_tick_tx_js_df['成交价格'].plot()

import akshare as ak
stock_zh_a_hist_df = ak.stock_zh_a_hist(symbol="600570", period="daily", start_date="20170301", end_date='20231218', adjust="qfq")
stock_zh_a_hist_df

stock_zh_a_hist_df.set_index('日期',inplace=True)

# 调整图表大小
fig, ax = plt.subplots(figsize=(15, 5))
stock_zh_a_hist_df['收盘'].plot()

<Axes: xlabel='日期'>

# DataFrame.rolling(window, min_periods=None, axis=0, win_type=None, on=None, center=False, closed=None)

# 参数说明：
# window: 滚动窗口的大小，表示在每个窗口中包含的观测值数量。
# min_periods: 可选参数，指定要执行滚动计算的最小观测值数量。默认为窗口大小。
# axis: 指定滚动操作的轴。默认为0，表示在行方向上执行滚动操作。
# win_type: 可选参数，指定窗口类型，例如平均窗口、高斯窗口等。默认为None，表示使用均匀窗口。
# on: 可选参数，如果你的DataFrame具有多个时间列，并且要在特定的时间列上执行滚动操作，则可以使用此参数指定列的名称。
# center: 布尔值，表示是否在窗口的中心执行计算。默认为False，表示在窗口的右侧执行计算。
# closed: 指定窗口的开闭方式。可以是'right'、'left'、'both'或'neither'。默认为'right'，表示右闭左开。

rolling_mean = stock_zh_a_hist_df['收盘'].rolling(window=1).mean()

stock_zh_a_hist_df['rolling_mean'] = rolling_mean

stock_zh_a_hist_df

# 计算滚动窗口的标准差
rolling_std = stock_zh_a_hist_df['收盘'].rolling(window=3).std()

# 将滚动窗口的标准差添加到DataFrame
stock_zh_a_hist_df['rolling_std'] = rolling_std

stock_zh_a_hist_df

# 调整图表大小
fig, ax = plt.subplots(figsize=(15, 5))
stock_zh_a_hist_df['rolling_std'].plot()

<Axes: xlabel='日期'>

8.2 指数加权函数

在 pandas 中，可以使用 ewm 方法来执行指数加权平均。ewm 表示“指数加权移动”，其基本语法如下：

DataFrame.ewm(span=None, alpha=None, min_periods=1, adjust=True, ignore_na=False, axis=0)

参数说明：

• span: 指定指数加权平均的窗口大小，它表示观测值的半衰期（half-life）。与窗口大小有关，通常与 alpha 中的一个参数有关。可以在 span 和 alpha 中选择一个来指定权重。
• alpha: 控制指数加权平均的平滑度。如果选择使用 alpha，则不需要指定 span。alpha 取值范围在 0 到 1 之间。
• min_periods: 可选参数，指定要执行指数加权计算的最小观测值数量。
• adjust: 控制是否应用校正。默认为 True，表示应用校正以考虑观测值的数量。
• ignore_na: 布尔值，表示是否忽略缺失值。默认为 False，表示不忽略缺失值。
• axis: 指定操作的轴。默认为 0，表示在行方向上执行指数加权操作。

import pandas as pd

# 创建一个示例DataFrame
data = {'value': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]}
df = pd.DataFrame(data)

# 计算指数加权平均
ewma = df['value'].ewm(span=3).mean()

# 将指数加权平均添加到DataFrame
df['ewma'] = ewma

df

# 调整图表大小
fig, ax = plt.subplots(figsize=(15, 5))
stock_zh_a_hist_df['收盘'].plot()

<Axes: xlabel='日期'>

# ma5 = stock_zh_a_hist_df['收盘'].ewm(span=5).mean()
# ma10 = stock_zh_a_hist_df['收盘'].ewm(span=10).mean()
# ma30 = stock_zh_a_hist_df['收盘'].ewm(span=30).mean()
ma60 = stock_zh_a_hist_df['收盘'].ewm(span=60).mean()
ma60_mean = stock_zh_a_hist_df['收盘'].rolling(60).mean()
# ma120 = stock_zh_a_hist_df['收盘'].ewm(span=120).mean()
# ma180 = stock_zh_a_hist_df['收盘'].ewm(span=180).mean()
# 调整图表大小
fig, ax = plt.subplots(figsize=(15, 5))
# ma5.plot()
# ma10.plot()
# ma30.plot()
ma60.plot()
ma60_mean.plot()
# ma120.plot()
# ma180.plot()
stock_zh_a_hist_df['收盘'].plot()

<Axes: xlabel='日期'>

8.3 二元移动窗口函数

import akshare as ak
stock_zh_a_hist_df_600570 = ak.stock_zh_a_hist(symbol="600570", period="daily", start_date="20170301", end_date='20231218', adjust="qfq")
stock_zh_a_hist_df_600570.set_index('日期',inplace=True)
stock_zh_a_hist_df_600570

stock_zh_index_daily_df = ak.stock_zh_index_daily(symbol="sh510300")
stock_zh_index_daily_df.set_index('date',inplace=True)
stock_zh_index_daily_df.index = pd.to_datetime(stock_zh_index_daily_df.index)
start_date = "2017-03-01"
end_date = "2023-12-18"
stock_zh_index_daily_df = stock_zh_index_daily_df.loc[start_date:end_date]
stock_zh_index_daily_df

# 调整图表大小
fig, ax = plt.subplots(figsize=(15, 5))
stock_zh_a_hist_df_600570['收盘'].plot()
stock_zh_index_daily_df['close'].plot()

<Axes: xlabel='date'>

import akshare as ak
import pandas as pd
import matplotlib.pyplot as plt

# 获取股票“600570”数据
stock_zh_a_hist_df_600570 = ak.stock_zh_a_hist(symbol="600570", period="daily", start_date="20170301", end_date='20231218', adjust="qfq")
stock_zh_a_hist_df_600570.set_index('日期', inplace=True)

# 获取上证深证300指数数据
stock_zh_index_daily_df = ak.stock_zh_index_daily(symbol="sh510300")
stock_zh_index_daily_df.set_index('date', inplace=True)
stock_zh_index_daily_df.index = pd.to_datetime(stock_zh_index_daily_df.index)
start_date = "2017-03-01"
end_date = "2023-12-18"
stock_zh_index_daily_df = stock_zh_index_daily_df.loc[start_date:end_date]

# 创建两个子图
fig, ax1 = plt.subplots(figsize=(10, 5))

# 在第一个子图上绘制股票数据
color = 'tab:red'
ax1.set_xlabel('日期')
ax1.set_ylabel('股票600570收盘价', color=color)
ax1.plot(stock_zh_a_hist_df_600570.index, stock_zh_a_hist_df_600570['收盘'], color=color)
ax1.tick_params(axis='y', labelcolor=color)

# 创建第二个子图，并共享x轴
ax2 = ax1.twinx()
color = 'tab:blue'
ax2.set_ylabel('上证深证300指数收盘价', color=color)
ax2.plot(stock_zh_index_daily_df.index, stock_zh_index_daily_df['close'], color=color)
ax2.tick_params(axis='y', labelcolor=color)

# 调整布局
fig.tight_layout()
plt.show()

8.4 用户定义的移动窗口函数

import pandas as pd
import numpy as np

# 创建一个示例的DataFrame
data = {'value': [1, 2, 3, 4, 5, 6, 7, 8, 9]}
df = pd.DataFrame(data)

# 定义一个自定义的移动窗口函数
def custom_window_function(window):
    # 示例：计算窗口内元素的平均值
    return np.mean(window)

# 使用rolling和apply应用自定义窗口函数
window_size = 3  # 移动窗口的大小
df['rolling_mean'] = df['value'].rolling(window=window_size).apply(custom_window_function, raw=True)

# 打印结果
print(df)

   value  rolling_mean
0      1           NaN
1      2           NaN
2      3           2.0
3      4           3.0
4      5           4.0
5      6           5.0
6      7           6.0
7      8           7.0
8      9           8.0

df.plot()

<Axes: >

本栏目推荐文章
• 代码随想录 day18 找树左下角的值 路径总和 从中序与后序遍历序列构造二叉树
• Jmeter 如何连接mysql数据库？
• SQL Server 检测是不是数字型数据的两种方法
• 字节微服务HTTP框架Hertz使用与源码分析｜拥抱开
• 如何通过Navicat把MySQL远程数据库导入到本地数据库
• 和利时MACS6通过dat文件实现任意时间范围与测点的历史数据提取与科研分析
• 深入理解spring框架：剖析多线程模式下数据库连接
• 数据可视化是如何帮助大型企业提高效率的？
• redis 数据库
• openpyxl模块--------------------------------重复数据

时间序列 数据分析 序列 时间 数据过程 时间序列 数据 序列 时间序列 数据 销售量 序列 模型 时间序列 数据 序列 时间序列 序列 时间 数据 时间序列 数据 神经网络 序列 时间序列 数据 矢量 序列 时间序列 数据 神经网络 波形 时间序列 数据分析 序列 时间 时间序列 数据 失业率 序列 时间序列 数据 噪声 大豆