TRHX • 鲍勃
TRHX • 鲍勃

Python 数据分析三剑客之 Pandas（九）：时间序列

CSDN 课程推荐：《迈向数据科学家：带你玩转Python数据分析》，讲师齐伟，苏州研途教育科技有限公司CTO，苏州大学应用统计专业硕士生指导委员会委员；已出版《跟老齐学Python：轻松入门》《跟老齐学Python：Django实战》、《跟老齐学Python：数据分析》和《Python大学实用教程》畅销图书。

Pandas 系列文章：

  • Python 数据分析三剑客之 Pandas（一）：认识 Pandas 及其 Series、DataFrame 对象
  • Python 数据分析三剑客之 Pandas（二）：Index 索引对象以及各种索引操作
  • Python 数据分析三剑客之 Pandas（三）：算术运算与缺失值的处理
  • Python 数据分析三剑客之 Pandas（四）：函数应用、映射、排序和层级索引
  • Python 数据分析三剑客之 Pandas（五）：统计计算与统计描述
  • Python 数据分析三剑客之 Pandas（六）：GroupBy 数据分裂、应用与合并
  • Python 数据分析三剑客之 Pandas（七）：合并数据集
  • Python 数据分析三剑客之 Pandas（八）：数据重塑、重复数据处理与数据替换
  • Python 数据分析三剑客之 Pandas（九）：时间序列
  • Python 数据分析三剑客之 Pandas（十）：数据读写

另有 NumPy、Matplotlib 系列文章已更新完毕，欢迎关注：

  • NumPy 系列文章：https://itrhx.blog.csdn.net/category_9780393.html
  • Matplotlib 系列文章：https://itrhx.blog.csdn.net/category_9780418.html

推荐学习资料与网站（博主参与部分文档翻译）：

  • NumPy 官方中文网：https://www.numpy.org.cn/
  • Pandas 官方中文网：https://www.pypandas.cn/
  • Matplotlib 官方中文网：https://www.matplotlib.org.cn/
  • NumPy、Matplotlib、Pandas 速查表：https://github.com/TRHX/Python-quick-reference-table

文章目录

    • 【01x00】时间序列
    • 【02x00】Timestamp 时间戳
      • 【02x01】pandas.Timestamp
      • 【02x02】freq 频率部分取值
      • 【02x03】to_datetime
      • 【02x04】date_range
      • 【02x05】索引与切片
      • 【02x06】移动数据与数据偏移
      • 【02x07】时区处理
    • 【03x00】period 固定时期
      • 【03x01】pandas.Period
      • 【03x02】period_range
      • 【03x03】asfreq 时期频率转换
      • 【03x04】to_period 与 to_timestamp()
    • 【04x00】timedelta 时间间隔
      • 【04x01】pandas.Timedelta
      • 【04x02】to_timedelta
      • 【04x03】timedelta_range
    • 【05x00】重采样及频率转换

这里是一段防爬虫文本，请读者忽略。
本文原创首发于 CSDN，作者 TRHX。
博客首页：https://itrhx.blog.csdn.net/
本文链接：https://itrhx.blog.csdn.net/article/details/106947061
未经授权，禁止转载！恶意转载，后果自负！尊重原创，远离剽窃！

【01x00】时间序列

官网对于时间序列的介绍：https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html

时间序列（time series）是一种重要的结构化数据形式，应用于多个领域，包括金融学、经济学、生态学、神经科学、物理学等。在多个时间点观察或测量到的任何事物都可以形成一段时间序列。很多时间序列是固定频率的，也就是说，数据点是根据某种规律定期出现的（比如每15秒、每5分钟、每月出现一次）。时间序列也可以是不定期的，没有固定的时间单位或单位之间的偏移量。时间序列数据的意义取决于具体的应用场景，主要有以下几种：

  • 时间戳（timestamp），表示某个具体的时间点，例如 2020-6-24 15:30；

  • 固定周期（period），表示某个时间周期，例如 2020-01；

  • 时间间隔（timedelta），持续时间，即两个日期或时间之间的差异。

  • 针对时间戳数据，Pandas 提供了 Timestamp 类型。它本质上是 Python 的原生 datetime 类型的替代品，但是在性能更好的 numpy.datetime64 类型的基础上创建。对应的索引数据结构是 DatetimeIndex。

  • 针对时间周期数据，Pandas 提供了 Period 类型。这是利用 numpy.datetime64 类型将固定频率的时间间隔进行编码。对应的索引数据结构是 PeriodIndex。

  • 针对时间增量或持续时间，Pandas 提供了 Timedelta 类型。Timedelta 是一种代替 Python 原生datetime.timedelta 类型的高性能数据结构，同样是基于 numpy.timedelta64 类型。对应的索引数据结构是 TimedeltaIndex。

【02x00】Timestamp 时间戳

【02x01】pandas.Timestamp

在 pandas 中，pandas.Timestamp 方法用来代替 Python 中的 datetime.datetime 方法。

Timestamp 与 Python 的 Datetime 等效，在大多数情况下都可以互换。 此类型用于组成 DatetimeIndex 以及 Pandas 中其他面向时间序列的数据结构。

官方文档：https://pandas.pydata.org/docs/reference/api/pandas.Timestamp.html

基本语法：

class pandas.Timestamp(ts_input=<object object>, 
					   freq=None, tz=None, unit=None, 
					   year=None, month=None, day=None, 
					   hour=None, minute=None, second=None, 
					   microsecond=None, nanosecond=None, tzinfo=None)

常用参数：

参数 描述
ts_input 要转换为时间戳的对象，可以是 datetime-like，str，int，float 类型
freq 时间戳将具有的偏移量，可以是 str，日期偏移量类型，取值参见【02x02】freq 频率部分取值
tz 时间戳将具有的时区
unit 如果 ts_input 是整数或浮点数，该参数用于设置其单位（D、s、ms、us、ns）

简单示例：

>>> import pandas as pd
>>> pd.Timestamp('2017-01-01T12')
Timestamp('2017-01-01 12:00:00')

设置 unit='s'，即待转换对象单位为秒：

>>> import pandas as pd
>>> pd.Timestamp(1513393355.5, unit='s')
Timestamp('2017-12-16 03:02:35.500000')

使用 tz 参数设置时区：

>>> import pandas as pd
>>> pd.Timestamp(1513393355, unit='s', tz='US/Pacific')
Timestamp('2017-12-15 19:02:35-0800', tz='US/Pacific')

单独设置年月日：

>>> import pandas as pd
>>> pd.Timestamp(year=2020, month=6, day=24, hour=12)
Timestamp('2020-06-24 12:00:00')

【02x02】freq 频率部分取值

完整取值参见官方文档：https://pandas.pydata.org/docs/user_guide/timeseries.html#timeseries-offset-aliases

参数 类型 描述
D Day 每日历日
B BusinessDay 每工作日
H Hour 每小时
T 或 min Minute 每分
S Second 每秒
L 或 ms Milli 每毫秒（即每千分之一秒）
U Micro 每微秒（即每百万分之一秒）
M MonthEnd 每月最后一个日历日
BM BusinessMonthEnd 每月最后一个工作日
MS MonthBegin 每月第一个日历日
BMS BusinessMonthBegin 每月第一个工作日
W-MON、W-TUE… Week 从指定的星期几（MON、TUE、 WED、THU、FR、SAT、SUN）开始算起，每周
WoM-1MON、WOM-2MON… WeekOfMonth 产生每月第一、第二、第三或第四周的星期几。例如，WoM-3FRI 表示每月第3个星期五
Q-JAN、Q-FEB… QuarterEnd 对于以指定月份（JAN、FEB、MAR、APR、MAY、JUN、JUL、AUG、SEP、OCT、NOV、DEC）结束的年度，每季度最后一月的最后个日历日
BQ-JAN、BQ-FEB… BusinessQuarterEnd 对于以指定月份结束的年度，每季度最后一月的最后一个工作日
QS-JAN、QS-FEB… QuarterBegin 对于以指定月份结束的年度，每季度最后一月的第一个日历日
BQS-JAN、 BQS-FEB… BusinessQuarterBegin 对于以指定月份结束的年度，每季度最后一月的第一个工作日
A-JAN、A-FEB… YearEnd 每年指定月份（JAN、FEB、MAR、APR、MAY、JUN、JUL、AUG、SEP、 OCT、NOV、DEC）的最后一个日历日
BA-JAN、BA-FEB… BusinessYearEnd 每年指定月份的最后一个工作日
AS-JAN、AS-FEB… YearBegin 每年指定月份的第一个历日日
BAS-JAN、BAS-FEB… BusinessYearBegin 每年指定月份的第一个工作日

【02x03】to_datetime

在 Python 中，datetime 库提供了日期和时间处理方法，利用 str 或 strftime 方法可以将 datetime 对象转化成字符串，具体用法可参见【Python 标准库学习】日期和时间处理库 — datetime。

>>> from datetime import datetime
>>> stamp = datetime(2020, 6, 24)
>>> stamp
datetime.datetime(2020, 6, 24, 0, 0)
>>>
>>> str(stamp)
'2020-06-24 00:00:00'
>>> 
>>> stamp.strftime('%Y-%m-%d')
'2020-06-24'

在 pandas 中 to_datetime 方法可以将字符串解析成多种不同的 Timestamp（时间戳） 对象：

>>> import pandas as pd
>>> datestrs = '2011-07-06 12:00:00'
>>> type(datestrs)
<class 'str'>
>>> 
>>> pd.to_datetime(datestrs)
Timestamp('2011-07-06 12:00:00')

基本语法：

pandas.to_datetime(arg, errors='raise', dayfirst=False, 
				   yearfirst=False, utc=None, format=None, 
				   exact=True, unit=None, infer_datetime_format=False, 
				   origin='unix', cache=True)

官方文档：https://pandas.pydata.org/docs/reference/api/pandas.to_datetime.html

常用参数：

参数 描述
arg 要转换为日期时间的对象，可以接受 int, float, str, datetime, list, tuple, 1-d array, Series DataFrame/dict-like 类型
errors 如果字符串不满足时间戳的形式，是否会发生异常
ignore：不引发异常，返回原始输入；raise：无效解析将引发异常（默认）；coerce：无效解析将被设置为NaT
dayfirst bool 类型，默认 False，如果 arg 是 str 或列表，是否首先解析为日期
例如 dayfirst 为 True，10/11/12 被解析为 2012-11-10，为 False 则解析为 2012-10-11
yearfirst bool 类型，默认 False，如果 arg 是 str 或列表，是否首先解析为年份
例如 dayfirst 为 True，10/11/12 被解析为 2010-11-12，为 False 则解析为 2012-10-11
如果 dayfirst 和 yearfirst 都为 True，则优先 yearfirst
utc bool 类型，是否转换为协调世界时，默认 None
format 格式化时间，如 21/2/20 16:10 使用 %d/%m/%y %H:%M 会被解析为 2020-02-21 16:10:00
符号含义常见文章：【Python 标准库学习】日期和时间处理库 — datetime 或者官方文档
exact 如果为 True，则需要精确的格式匹配。如果为 False，则允许格式与目标字符串中的任何位置匹配
unit 如果 arg 是整数或浮点数，该参数用于设置其单位（D、s、ms、us、ns）

简单应用：

>>> import pandas as pd
>>> obj = pd.DataFrame({'year': [2015, 2016], 'month': [2, 3], 'day': [4, 5]})
>>> obj
   year  month  day
0  2015      2    4
1  2016      3    5
>>> 
>>> pd.to_datetime(obj)
0   2015-02-04
1   2016-03-05
dtype: datetime64[ns]

设置 format 和 errors 参数：

>>> import pandas as pd
>>> pd.to_datetime('13000101', format='%Y%m%d', errors='ignore')
datetime.datetime(1300, 1, 1, 0, 0)
>>> 
>>> pd.to_datetime('13000101', format='%Y%m%d', errors='coerce')
NaT
>>> 
>>> pd.to_datetime('13000101', format='%Y%m%d', errors='raise')
Traceback (most recent call last):
...
pandas._libs.tslibs.np_datetime.OutOfBoundsDatetime: Out of bounds nanosecond timestamp: 1300-01-01 00:00:00

设置 unit 参数：

>>> import pandas as pd
>>> pd.to_datetime(1490195805, unit='s')
Timestamp('2017-03-22 15:16:45')
>>> 
>>> pd.to_datetime(1490195805433502912, unit='ns')
Timestamp('2017-03-22 15:16:45.433502912')

【02x04】date_range

pandas.date_range 方法可用于根据指定的频率生成指定长度的 DatetimeIndex。

基本语法：

pandas.date_range(start=None, end=None, periods=None, freq=None, 
				  tz=None, normalize=False, name=None, closed=None, 
				  **kwargs) → pandas.core.indexes.datetimes.DatetimeIndex

官方文档：https://pandas.pydata.org/docs/reference/api/pandas.date_range.html

参数 描述
start 开始日期
end 结束日期
periods int 类型，要生成的时段数（天）
freq 频率字符串，即按照某种特定的频率来生成日期，取值参见【02x02】freq 频率部分取值
tz 设置时区，例如 “Asia/Hong_Kong”
normalize bool 类型，默认 False，是否在生成日期之前对其进行规范化（仅保留年月日）
name 结果 DatetimeIndex 的名称
closed None：默认值，同时保留开始日期和结束日期
'left'：保留开始日期，不保留结束日期
'right'：保留结束日期，不保留开始日期

简单示例：

>>> import pandas as pd
>>> pd.date_range(start='1/1/2018', end='1/08/2018')
DatetimeIndex(['2018-01-01', '2018-01-02', '2018-01-03', '2018-01-04',
               '2018-01-05', '2018-01-06', '2018-01-07', '2018-01-08'],
              dtype='datetime64[ns]', freq='D')

指定 periods 参数：

>>> import pandas as pd
>>> pd.date_range(start='2012-04-01', periods=20)
DatetimeIndex(['2012-04-01', '2012-04-02', '2012-04-03', '2012-04-04',
               '2012-04-05', '2012-04-06', '2012-04-07', '2012-04-08',
               '2012-04-09', '2012-04-10', '2012-04-11', '2012-04-12',
               '2012-04-13', '2012-04-14', '2012-04-15', '2012-04-16',
               '2012-04-17', '2012-04-18', '2012-04-19', '2012-04-20'],
              dtype='datetime64[ns]', freq='D')
>>> 
>>> pd.date_range(end='2012-06-01', periods=20)
DatetimeIndex(['2012-05-13', '2012-05-14', '2012-05-15', '2012-05-16',
               '2012-05-17', '2012-05-18', '2012-05-19', '2012-05-20',
               '2012-05-21', '2012-05-22', '2012-05-23', '2012-05-24',
               '2012-05-25', '2012-05-26', '2012-05-27', '2012-05-28',
               '2012-05-29', '2012-05-30', '2012-05-31', '2012-06-01'],
              dtype='datetime64[ns]', freq='D')
>>>
>>> pd.date_range(start='2018-04-24', end='2018-04-27', periods=3)
DatetimeIndex(['2018-04-24 00:00:00', '2018-04-25 12:00:00', '2018-04-27 00:00:00'],
              dtype='datetime64[ns]', freq=None)
>>>
>>> pd.date_range(start='2018-04-24', end='2018-04-28', periods=3)
DatetimeIndex(['2018-04-24', '2018-04-26', '2018-04-28'], dtype='datetime64[ns]', freq=None)

指定 freq='M' 会按照每月最后一个日历日的频率生成日期，指定 freq='3M' 会每隔3个月按照每月最后一个日历日的频率生成日期：

>>> import pandas as pd
>>> pd.date_range(start='1/1/2018', periods=5, freq='M')
DatetimeIndex(['2018-01-31', '2018-02-28', '2018-03-31', '2018-04-30',
               '2018-05-31'],
              dtype='datetime64[ns]', freq='M')
>>> 
>>> pd.date_range(start='1/1/2018', periods=5, freq='3M')
DatetimeIndex(['2018-01-31', '2018-04-30', '2018-07-31', '2018-10-31',
               '2019-01-31'],
              dtype='datetime64[ns]', freq='3M')
>>>

使用 tz 参数设置时区：

>>> import pandas as pd
>>> pd.date_range(start='1/1/2018', periods=5, tz='Asia/Tokyo')
DatetimeIndex(['2018-01-01 00:00:00+09:00', '2018-01-02 00:00:00+09:00',
               '2018-01-03 00:00:00+09:00', '2018-01-04 00:00:00+09:00',
               '2018-01-05 00:00:00+09:00'],
              dtype='datetime64[ns, Asia/Tokyo]', freq='D')
>>> 
>>> pd.date_range(start='6/24/2020', periods=5, tz='Asia/Hong_Kong')
DatetimeIndex(['2020-06-24 00:00:00+08:00', '2020-06-25 00:00:00+08:00',
               '2020-06-26 00:00:00+08:00', '2020-06-27 00:00:00+08:00',
               '2020-06-28 00:00:00+08:00'],
              dtype='datetime64[ns, Asia/Hong_Kong]', freq='D')

设置 normalize 参数，在生成时间戳之前对其进行格式化操作：

>>> import pandas as pd
>>> pd.date_range('2020-06-24 12:56:31', periods=5, normalize=True)
DatetimeIndex(['2020-06-24', '2020-06-25', '2020-06-26', '2020-06-27',
               '2020-06-28'],
              dtype='datetime64[ns]', freq='D')

设置 closed 参数：

>>> import pandas as pd
>>> pd.date_range(start='2020-06-20', end='2020-06-24', closed=None)
DatetimeIndex(['2020-06-20', '2020-06-21', '2020-06-22', '2020-06-23',
               '2020-06-24'],
              dtype='datetime64[ns]', freq='D')
>>> 
>>> pd.date_range(start='2020-06-20', end='2020-06-24', closed='left')
DatetimeIndex(['2020-06-20', '2020-06-21', '2020-06-22', '2020-06-23'], dtype='datetime64[ns]', freq='D')
>>> 
>>> pd.date_range(start='2020-06-20', end='2020-06-24', closed='right')
DatetimeIndex(['2020-06-21', '2020-06-22', '2020-06-23', '2020-06-24'], dtype='datetime64[ns]', freq='D')

【02x05】索引与切片

Pandas 最基本的时间序列类型就是以时间戳（通常以 Python 字符串或 datatime 对象表示）为索引的Series，这些 datetime 对象实际上是被放在 DatetimeIndex 中的，可以使用类似 pandas.Series 对象的切片方法对其进行索引：

>>> import pandas as pd
>>> import numpy as np
>>> dates = [datetime(2011, 1, 2), datetime(2011, 1, 5),
	         datetime(2011, 1, 7), datetime(2011, 1, 8),
	         datetime(2011, 1, 10), datetime(2011, 1, 12)]
>>> obj = pd.Series(np.random.randn(6), index=dates)
>>> 
>>> obj
2011-01-02   -0.407110
2011-01-05   -0.186661
2011-01-07   -0.731080
2011-01-08    0.860970
2011-01-10    1.929973
2011-01-12   -0.168599
dtype: float64
>>> 
>>> obj.index
DatetimeIndex(['2011-01-02', '2011-01-05', '2011-01-07', '2011-01-08',
               '2011-01-10', '2011-01-12'],
              dtype='datetime64[ns]', freq=None)
>>>
>>> obj.index[0]
Timestamp('2011-01-02 00:00:00')
>>> 
>>> obj.index[0:3]
DatetimeIndex(['2011-01-02', '2011-01-05', '2011-01-07'], dtype='datetime64[ns]', freq=None)

另外还可以传入一个可以被解释为日期的字符串，或者只需传入“年”或“年月”即可轻松选取数据的切片：

>>> import pandas as pd
>>> import numpy as np
>>> obj = pd.Series(np.random.randn(1000), index=pd.date_range('1/1/2000', periods=1000))
>>> obj
2000-01-01   -1.142284
2000-01-02    1.198785
2000-01-03    2.466909
2000-01-04   -0.086728
2000-01-05   -0.978437
                ...   
2002-09-22   -0.252240
2002-09-23    0.148561
2002-09-24   -1.330409
2002-09-25   -0.673471
2002-09-26   -0.253271
Freq: D, Length: 1000, dtype: float64
>>> 
>>> obj['26/9/2002']
-0.25327100684233356
>>> 
>>> obj['2002']
2002-01-01    1.058715
2002-01-02    0.900859
2002-01-03    1.993508
2002-01-04   -0.103211
2002-01-05   -0.950090
                ...   
2002-09-22   -0.252240
2002-09-23    0.148561
2002-09-24   -1.330409
2002-09-25   -0.673471
2002-09-26   -0.253271
Freq: D, Length: 269, dtype: float64
>>> 
>>> obj['2002-09']
2002-09-01   -0.995528
2002-09-02    0.501528
2002-09-03   -0.486753
2002-09-04   -1.083906
2002-09-05    1.458975
2002-09-06   -1.331685
2002-09-07    0.195338
2002-09-08   -0.429613
2002-09-09    1.125823
2002-09-10    1.607051
2002-09-11    0.530387
2002-09-12   -0.015938
2002-09-13    1.781043
2002-09-14   -0.277123
2002-09-15    0.344569
2002-09-16   -1.010810
2002-09-17    0.463001
2002-09-18    1.883636
2002-09-19    0.274520
2002-09-20    0.624184
2002-09-21   -1.203057
2002-09-22   -0.252240
2002-09-23    0.148561
2002-09-24   -1.330409
2002-09-25   -0.673471
2002-09-26   -0.253271
Freq: D, dtype: float64
>>> 
>>> obj['20/9/2002':'26/9/2002']
2002-09-20    0.624184
2002-09-21   -1.203057
2002-09-22   -0.252240
2002-09-23    0.148561
2002-09-24   -1.330409
2002-09-25   -0.673471
2002-09-26   -0.253271
Freq: D, dtype: float64

【02x06】移动数据与数据偏移

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

>>> import pandas as pd
>>> import numpy as np
>>> obj = pd.Series(np.random.randn(4),
		    index=pd.date_range('1/1/2000', periods=4, freq='M'))
>>> obj
2000-01-31   -0.100217
2000-02-29    1.177834
2000-03-31   -0.644353
2000-04-30   -1.954679
Freq: M, dtype: float64
>>> 
>>> obj.shift(2)
2000-01-31         NaN
2000-02-29         NaN
2000-03-31   -0.100217
2000-04-30    1.177834
Freq: M, dtype: float64
>>> 
>>> obj.shift(-2)
2000-01-31   -0.644353
2000-02-29   -1.954679
2000-03-31         NaN
2000-04-30         NaN
Freq: M, dtype: float64

因为简单的移位操作不会修改索引，所以部分数据会被丢弃并引入 NaN（缺失值）。因此，如果频率已知，则可以将其传给 shift 以便实现对时间戳进行位移而不是对数据进行简单位移：

>>> import pandas as pd
>>> import numpy as np
>>> obj = pd.Series(np.random.randn(4),
		    index=pd.date_range('1/1/2000', periods=4, freq='M'))
>>> obj
2000-01-31   -0.100217
2000-02-29    1.177834
2000-03-31   -0.644353
2000-04-30   -1.954679
Freq: M, dtype: float64
>>> 
>>> obj.shift(2, freq='M')
2000-03-31   -0.100217
2000-04-30    1.177834
2000-05-31   -0.644353
2000-06-30   -1.954679
Freq: M, dtype: float64

Pandas 中的频率是由一个基础频率（base frequency）和一个乘数组成的。基础频率通常以一个字符串别名表示，比如 "M" 表示每月，"H" 表示每小时。对于每个基础频率，都有一个被称为日期偏移量（date offset）的对象与之对应。例如，按小时计算的频率可以用 Hour 类表示：

>>> from pandas.tseries.offsets import Hour, Minute
>>> hour = Hour()
>>> hour
<Hour>
>>> 
>>> four_hours = Hour(4)
>>> four_hours
<4 * Hours>

一般来说，无需明确创建这样的对象，只需使用诸如 "H" 或 "4H" 这样的字符串别名即可。在基础频率前面放上一个整数即可创建倍数：

>>> import pandas as pd
>>> pd.date_range('2000-01-01', '2000-01-03 23:59', freq='4h')
DatetimeIndex(['2000-01-01 00:00:00', '2000-01-01 04:00:00',
               '2000-01-01 08:00:00', '2000-01-01 12:00:00',
               '2000-01-01 16:00:00', '2000-01-01 20:00:00',
               '2000-01-02 00:00:00', '2000-01-02 04:00:00',
               '2000-01-02 08:00:00', '2000-01-02 12:00:00',
               '2000-01-02 16:00:00', '2000-01-02 20:00:00',
               '2000-01-03 00:00:00', '2000-01-03 04:00:00',
               '2000-01-03 08:00:00', '2000-01-03 12:00:00',
               '2000-01-03 16:00:00', '2000-01-03 20:00:00'],
              dtype='datetime64[ns]', freq='4H')

大部分偏移量对象都可通过加法进行连接：

>>> from pandas.tseries.offsets import Hour, Minute
>>> Hour(2) + Minute(30)
<150 * Minutes>

对于 freq 参数也可以传入频率字符串（如 "2h30min"），这种字符串可以被高效地解析为等效的表达式：

>>> import pandas as pd
>>> pd.date_range('2000-01-01', periods=10, freq='1h30min')
DatetimeIndex(['2000-01-01 00:00:00', '2000-01-01 01:30:00',
               '2000-01-01 03:00:00', '2000-01-01 04:30:00',
               '2000-01-01 06:00:00', '2000-01-01 07:30:00',
               '2000-01-01 09:00:00', '2000-01-01 10:30:00',
               '2000-01-01 12:00:00', '2000-01-01 13:30:00'],
              dtype='datetime64[ns]', freq='90T')

这种偏移量还可以用在 datetime 或 Timestamp 对象上：

>>> from pandas.tseries.offsets import Day, MonthEnd
>>> now = datetime(2011, 11, 17)
>>> now + 3 * Day()
Timestamp('2011-11-20 00:00:00')

如果加的是锚点偏移量，比如 MonthEnd，第一次增量会将原日期向前滚动到符合频率规则的下一个日期：

>>> from pandas.tseries.offsets import Day, MonthEnd
>>> now = datetime(2011, 11, 17)
>>> now + MonthEnd()
Timestamp('2011-11-30 00:00:00')
>>> now + MonthEnd(2)
Timestamp('2011-12-31 00:00:00')

通过锚点偏移量的 rollforward 和 rollback 方法，可明确地将日期向前或向后滚动：

>>> from pandas.tseries.offsets import Day, MonthEnd
>>> now = datetime(2011, 11, 17)
>>> offset = MonthEnd()
>>> offset.rollforward(now)
Timestamp('2011-11-30 00:00:00')
>>> offset.rollback(now)
Timestamp('2011-10-31 00:00:00')

与 groupby 方法结合使用：

>>> import pandas as pd
>>> import numpy as np
>>> from pandas.tseries.offsets import Day, MonthEnd
>>> obj = pd.Series(np.random.randn(20),
		    index=pd.date_range('1/15/2000', periods=20, freq='4d'))
>>> obj
2000-01-15   -0.591729
2000-01-19   -0.775844
2000-01-23   -0.745603
2000-01-27   -0.076439
2000-01-31    1.796417
2000-02-04   -0.500349
2000-02-08    0.515851
2000-02-12   -0.344171
2000-02-16    0.419657
2000-02-20    0.307288
2000-02-24    0.115113
2000-02-28   -0.362585
2000-03-03    1.074892
2000-03-07    1.111366
2000-03-11    0.949910
2000-03-15   -1.535727
2000-03-19    0.545944
2000-03-23   -0.810139
2000-03-27   -1.260627
2000-03-31   -0.128403
Freq: 4D, dtype: float64
>>>
>>> offset = MonthEnd()
>>> obj.groupby(offset.rollforward).mean()
2000-01-31   -0.078640
2000-02-29    0.021543
2000-03-31   -0.006598
dtype: float64

【02x07】时区处理

在 Python 中，时区信息来自第三方库 pytz，使用 pytz.common_timezones 方法可以查看所有的时区名称，使用 pytz.timezone 方法从 pytz 中获取时区对象：

>>> import pytz
>>> pytz.common_timezones
['Africa/Abidjan', 'Africa/Accra', 'Africa/Addis_Ababa', ..., 'UTC']
>>>
>>> tz = pytz.timezone('Asia/Shanghai')
>>> tz
<DstTzInfo 'Asia/Shanghai' LMT+8:06:00 STD>  # 表示与 UTC 时间相差8小时6分

在 date_range 方法中，tz 参数用于指定时区，默认为 None，可以使用 tz_localize 方法将其进行本地化时区转换，如下示例中，将无时区转本地化 UTC 时区：

>>> import pandas as pd
>>> import numpy as np
>>> rng = pd.date_range('3/9/2012 9:30', periods=6, freq='D')
>>> ts = pd.Series(np.random.randn(len(rng)), index=rng)
>>> ts
2012-03-09 09:30:00   -1.527913
2012-03-10 09:30:00   -1.116101
2012-03-11 09:30:00    0.359358
2012-03-12 09:30:00   -0.475920
2012-03-13 09:30:00   -0.336570
2012-03-14 09:30:00   -1.075952
Freq: D, dtype: float64
>>> 
>>> print(ts.index.tz)
None
>>> 
>>> ts_utc = ts.tz_localize('UTC')
>>> ts_utc
2012-03-09 09:30:00+00:00   -1.527913
2012-03-10 09:30:00+00:00   -1.116101
2012-03-11 09:30:00+00:00    0.359358
2012-03-12 09:30:00+00:00   -0.475920
2012-03-13 09:30:00+00:00   -0.336570
2012-03-14 09:30:00+00:00   -1.075952
Freq: D, dtype: float64
>>>
>>> ts_utc.index
DatetimeIndex(['2012-03-09 09:30:00+00:00', '2012-03-10 09:30:00+00:00',
               '2012-03-11 09:30:00+00:00', '2012-03-12 09:30:00+00:00',
               '2012-03-13 09:30:00+00:00', '2012-03-14 09:30:00+00:00'],
              dtype='datetime64[ns, UTC]', freq='D')

时间序列被本地化到某个特定时区后，就可以用 tz_convert 方法将其转换到别的时区了：

>>> import pandas as pd
>>> import numpy as np
>>> rng = pd.date_range('3/9/2012 9:30', periods=6, freq='D')
>>> ts = pd.Series(np.random.randn(len(rng)), index=rng)
>>> ts
2012-03-09 09:30:00    0.480303
2012-03-10 09:30:00   -1.461039
2012-03-11 09:30:00   -1.512749
2012-03-12 09:30:00   -2.185421
2012-03-13 09:30:00    1.657845
2012-03-14 09:30:00    0.175633
Freq: D, dtype: float64
>>>
>>> ts.tz_localize('UTC').tz_convert('Asia/Shanghai')
2012-03-09 17:30:00+08:00    0.480303
2012-03-10 17:30:00+08:00   -1.461039
2012-03-11 17:30:00+08:00   -1.512749
2012-03-12 17:30:00+08:00   -2.185421
2012-03-13 17:30:00+08:00    1.657845
2012-03-14 17:30:00+08:00    0.175633
Freq: D, dtype: float64

这里是一段防爬虫文本，请读者忽略。
本文原创首发于 CSDN，作者 TRHX。
博客首页：https://itrhx.blog.csdn.net/
本文链接：https://itrhx.blog.csdn.net/article/details/106947061
未经授权，禁止转载！恶意转载，后果自负！尊重原创，远离剽窃！

【03x00】period 固定时期

【03x01】pandas.Period

固定时期（period）表示的是时间区间，比如数日、数月、数季、数年等。Period 类所表示的就是这种数据类型，其构造函数需要用到一个字符串或整数。

基本语法：

class pandas.Period(value=None, freq=None, ordinal=None, 
					year=None, month=None, quarter=None, 
					day=None, hour=None, minute=None, second=None)

官方文档：https://pandas.pydata.org/docs/reference/api/pandas.Period.html

常用参数：

参数 描述
value 时间段
freq 时间戳将具有的偏移量，可以是 str，日期偏移量类型，取值参见【02x02】freq 频率部分取值

以下示例中，Period 对象表示的是从2020年1月1日到2020年12月31日之间的整段时间

>>> import pandas as pd
>>> pd.Period(2020, freq='A-DEC')
Period('2020', 'A-DEC')

利用加减法对其按照频率进行位移：

>>> import pandas as pd
>>> obj = pd.Period(2020, freq='A-DEC')
>>> obj
Period('2020', 'A-DEC')
>>> 
>>> obj + 5
Period('2025', 'A-DEC')
>>> 
>>> obj - 5
Period('2015', 'A-DEC')

PeriodIndex 类保存了一组 Period，它可以在任何 pandas 数据结构中被用作轴索引：

>>> import pandas as pd
>>> import numpy as np
>>> rng = [pd.Period('2000-01'), pd.Period('2000-02'), pd.Period('2000-03'), 
		   pd.Period('2000-04'), pd.Period('2000-05'), pd.Period('2000-06')]
>>> obj = pd.Series(np.random.randn(6), index=rng)
>>> obj
2000-01    0.229092
2000-02    1.515498
2000-03   -0.334401
2000-04   -0.492681
2000-05   -2.012818
2000-06    0.338804
Freq: M, dtype: float64
>>> 
>>> obj.index
PeriodIndex(['2000-01', '2000-02', '2000-03', '2000-04', '2000-05', '2000-06'], dtype='period[M]', freq='M')

>>> import pandas as pd
>>> values = ['2001Q3', '2002Q2', '2003Q1']
>>> index = pd.PeriodIndex(values, freq='Q-DEC')
>>> index
PeriodIndex(['2001Q3', '2002Q2', '2003Q1'], dtype='period[Q-DEC]', freq='Q-DEC')
>>>

【03x02】period_range

pandas.period_range 方法可根据指定的频率生成指定长度的 PeriodIndex。

基本语法：

pandas.period_range(start=None, end=None, periods=None, freq=None, name=None) → pandas.core.indexes.period.PeriodIndex

官方文档：https://pandas.pydata.org/docs/reference/api/pandas.period_range.html

常用参数：

参数 描述
start 起始日期
end 结束日期
periods 要生成的时段数
freq 时间戳将具有的偏移量，可以是 str，日期偏移量类型，取值参见【02x02】freq 频率部分取值
name 结果 PeriodIndex 对象名称

简单应用：

>>> import pandas as pd
>>> pd.period_range(start='2019-01-01', end='2020-01-01', freq='M')
PeriodIndex(['2019-01', '2019-02', '2019-03', '2019-04', '2019-05', '2019-06',
             '2019-07', '2019-08', '2019-09', '2019-10', '2019-11', '2019-12',
             '2020-01'],
            dtype='period[M]', freq='M')
>>>
>>> pd.period_range(start=pd.Period('2017Q1', freq='Q'),
                	end=pd.Period('2017Q2', freq='Q'), freq='M')
PeriodIndex(['2017-03', '2017-04', '2017-05', '2017-06'], dtype='period[M]', freq='M')

【03x03】asfreq 时期频率转换

Period 和 PeriodIndex 对象都可以通过 asfreq 方法被转换成别的频率。

基本语法：PeriodIndex.asfreq(self, *args, **kwargs)

常用参数：

参数 描述
freq 新的频率（偏移量），取值参见【02x02】freq 频率部分取值
how 按照开始或者结束对齐，'E' or 'END' or 'FINISH'；'S' or 'START' or 'BEGIN'

应用示例：

>>> import pandas as pd
>>> pidx = pd.period_range('2010-01-01', '2015-01-01', freq='A')
>>> pidx
PeriodIndex(['2010', '2011', '2012', '2013', '2014', '2015'], dtype='period[A-DEC]', freq='A-DEC')
>>> 
>>> pidx.asfreq('M')
PeriodIndex(['2010-12', '2011-12', '2012-12', '2013-12', '2014-12', '2015-12'], dtype='period[M]', freq='M')
>>> 
>>> pidx.asfreq('M', how='S')
PeriodIndex(['2010-01', '2011-01', '2012-01', '2013-01', '2014-01', '2015-01'], dtype='period[M]', freq='M')

【03x04】to_period 与 to_timestamp()

to_period 方法可以将 Timestamp（时间戳） 转换为 Period（固定时期）；

to_timestamp 方法可以将 Period（固定时期）转换为 Timestamp（时间戳） 。

>>> import pandas as pd
>>> rng = pd.date_range('2000-01-01', periods=3, freq='M')
>>> ts = pd.Series(np.random.randn(3), index=rng)
>>> ts
2000-01-31    0.220759
2000-02-29   -0.108221
2000-03-31    0.819433
Freq: M, dtype: float64
>>> 
>>> pts = ts.to_period()
>>> pts
2000-01    0.220759
2000-02   -0.108221
2000-03    0.819433
Freq: M, dtype: float64
>>> 
>>> pts2 = pts.to_timestamp()
>>> pts2
2000-01-01    0.220759
2000-02-01   -0.108221
2000-03-01    0.819433
Freq: MS, dtype: float64
>>> 
>>> ts.index
DatetimeIndex(['2000-01-31', '2000-02-29', '2000-03-31'], dtype='datetime64[ns]', freq='M')
>>> 
>>> pts.index
PeriodIndex(['2000-01', '2000-02', '2000-03'], dtype='period[M]', freq='M')
>>> 
>>> pts2.index
DatetimeIndex(['2000-01-01', '2000-02-01', '2000-03-01'], dtype='datetime64[ns]', freq='MS')

【04x00】timedelta 时间间隔

【04x01】pandas.Timedelta

Timedelta 表示持续时间，即两个日期或时间之间的差。

Timedelta 相当于 Python 的 datetime.timedelta，在大多数情况下两者可以互换。

基本语法：class pandas.Timedelta(value=, unit=None, **kwargs)

官方文档：https://pandas.pydata.org/docs/reference/api/pandas.Timedelta.html

常用参数：

参数 描述
value 传入的值，可以是 Timedelta，timedelta，np.timedelta64，string 或 integer 对象
unit 用于设置 value 的单位，具体取值参见官方文档

表示两个 datetime 对象之间的时间差：

>>> import pandas as pd
>>> pd.to_datetime('2020-6-24') - pd.to_datetime('2016-1-1')
Timedelta('1636 days 00:00:00')

通过字符串传递参数：

>>> import pandas as pd
>>> pd.Timedelta('3 days 3 hours 3 minutes 30 seconds')
Timedelta('3 days 03:03:30')

通过整数传递参数：

>>> import pandas as pd
>>> pd.Timedelta(5,unit='h')
Timedelta('0 days 05:00:00')

获取属性：

>>> import pandas as pd
>>> obj = pd.Timedelta('3 days 3 hours 3 minutes 30 seconds')
>>> obj
Timedelta('3 days 03:03:30')
>>> 
>>> obj.days
3
>>> obj.seconds
11010

【04x02】to_timedelta

to_timedelta 方法可以将传入的对象转换成 timedelta 对象。

基本语法：pandas.to_timedelta(arg, unit='ns', errors='raise')

官方文档：https://pandas.pydata.org/docs/reference/api/pandas.to_timedelta.html

常用参数：

参数 描述
arg 要转换为 timedelta 的对象，可以是 str，timedelta，list-like 或 Series 对象
unit 用于设置 arg 的单位，具体取值参见官方文档
errors 如果 arg 不满足时间戳的形式，是否会发生异常
ignore：不引发异常，返回原始输入；raise：无效解析将引发异常（默认）；coerce：无效解析将被设置为NaT

将单个字符串解析为 timedelta 对象：

>>> import pandas as pd
>>> pd.to_timedelta('1 days 06:05:01.00003')
Timedelta('1 days 06:05:01.000030')
>>>
>>> pd.to_timedelta('15.5us')
Timedelta('0 days 00:00:00.000015')

将字符串列表或数组解析为 timedelta 对象：

>>> import pandas as pd
>>> pd.to_timedelta(['1 days 06:05:01.00003', '15.5us', 'nan'])
TimedeltaIndex(['1 days 06:05:01.000030', '0 days 00:00:00.000015', NaT], dtype='timedelta64[ns]', freq=None)

指定 unit 参数：

>>> import pandas as pd
>>> pd.to_timedelta(np.arange(5), unit='s')
TimedeltaIndex(['00:00:00', '00:00:01', '00:00:02', '00:00:03', '00:00:04'], dtype='timedelta64[ns]', freq=None)
>>> 
>>> pd.to_timedelta(np.arange(5), unit='d')
TimedeltaIndex(['0 days', '1 days', '2 days', '3 days', '4 days'], dtype='timedelta64[ns]', freq=None)

【04x03】timedelta_range

timedelta_range 方法可根据指定的频率生成指定长度的 TimedeltaIndex。

基本语法：

pandas.timedelta_range(start=None, end=None, periods=None,
					   freq=None, name=None, closed=None) → pandas.core.indexes.timedeltas.TimedeltaIndex

官方文档：https://pandas.pydata.org/docs/reference/api/pandas.timedelta_range.html

常用参数：

参数 描述
start 开始日期
end 结束日期
periods int 类型，要生成的时段数
freq 频率字符串，即按照某种特定的频率来生成日期，取值参见【02x02】freq 频率部分取值
name 结果 TimedeltaIndex 的名称
closed None：默认值，同时保留开始日期和结束日期
'left'：保留开始日期，不保留结束日期
'right'：保留结束日期，不保留开始日期

应用示例：

>>> import pandas as pd
>>> pd.timedelta_range(start='1 day', periods=4)
TimedeltaIndex(['1 days', '2 days', '3 days', '4 days'], dtype='timedelta64[ns]', freq='D')

closed 参数指定保留哪个端点。默认保留两个端点：

>>> import pandas as pd
>>> pd.timedelta_range(start='1 day', periods=4, closed='right')
TimedeltaIndex(['2 days', '3 days', '4 days'], dtype='timedelta64[ns]', freq='D')

freq 参数指定 TimedeltaIndex 的频率。只接受固定频率，非固定频率如 'M' 将会报错：

>>> import pandas as pd
>>> pd.timedelta_range(start='1 day', end='2 days', freq='6H')
TimedeltaIndex(['1 days 00:00:00', '1 days 06:00:00', '1 days 12:00:00',
                '1 days 18:00:00', '2 days 00:00:00'],
               dtype='timedelta64[ns]', freq='6H')
>>> 
>>> pd.timedelta_range(start='1 day', end='2 days', freq='M')
Traceback (most recent call last):
...
ValueError: <MonthEnd> is a non-fixed frequency

【05x00】重采样及频率转换

重采样（resampling）指的是将时间序列从一个频率转换到另一个频率的处理过程。将高频率数据聚合到低频率称为降采样（downsampling），而将低频率数据转换到高频率则称为升采样（upsampling）。并不是所有的重采样都能被划分到这两个大类中。例如，将 W-WED（每周三）转换为 W-FRI 既不是降采样也不是升采样。

Pandas 中提供了 resample 方法来帮助我们实现重采样。Pandas 对象都带有一个 resample 方法，它是各种频率转换工作的主力函数。

基本语法：

Series.resample(self, rule, axis=0, 
				closed: Union[str, NoneType] = None, 
				label: Union[str, NoneType] = None, 
				convention: str = 'start', 
				kind: Union[str, NoneType] = None, 
				loffset=None, base: int = 0, 
				on=None, level=None)

DataFrame.resample(self, rule, axis=0, 
				   closed: Union[str, NoneType] = None, 
				   label: Union[str, NoneType] = None, 
				   convention: str = 'start', 
				   kind: Union[str, NoneType] = None, 
				   loffset=None, base: int = 0, 
				   on=None, level=None)

常用参数：

参数 描述
rule
axis 重采样的轴，默认 0
closed 在重采样中，各时间段的哪一端是闭合（即包含）的，
除 'M'、'A'、'Q'、'BM'、'BA'、'BQ' 和 'W' 默认值为 ‘right’ 外，其他默认值为 'left‘
label 在重采样中，如何设置聚合值的标签， right 或 left，默认为 None，
例如，9:30 到 9:35 之间的这 5 分钟会被标记为 9:30 或 9:35
convention 仅用于 PeriodIndex（固定时期），对周期进行重采样，'start' or 's'，'end' or 'e'
on 对于 DataFrame 对象，可用该参数指定重采样后的数据的 index（行索引） 为原数据中的某列
level 对于具有层级索引（MultiIndex）的 DataFrame 对象，可以使用该参数来指定需要在哪个级别上进行重新采样

将序列重采样到三分钟的频率，并将每个频率的值相加：

>>> import pandas as pd
>>> index = pd.date_range('1/1/2000', periods=9, freq='T')
>>> series = pd.Series(range(9), index=index)
>>> series
2000-01-01 00:00:00    0
2000-01-01 00:01:00    1
2000-01-01 00:02:00    2
2000-01-01 00:03:00    3
2000-01-01 00:04:00    4
2000-01-01 00:05:00    5
2000-01-01 00:06:00    6
2000-01-01 00:07:00    7
2000-01-01 00:08:00    8
Freq: T, dtype: int64
>>> 
>>> series.resample('3T').sum()
2000-01-01 00:00:00     3
2000-01-01 00:03:00    12
2000-01-01 00:06:00    21
Freq: 3T, dtype: int64

设置 label='right'，即每个索引 index 会使用靠右侧（较大值）的标签：

>>> import pandas as pd
>>> index = pd.date_range('1/1/2000', periods=9, freq='T')
>>> series = pd.Series(range(9), index=index)
>>> series
2000-01-01 00:00:00    0
2000-01-01 00:01:00    1
2000-01-01 00:02:00    2
2000-01-01 00:03:00    3
2000-01-01 00:04:00    4
2000-01-01 00:05:00    5
2000-01-01 00:06:00    6
2000-01-01 00:07:00    7
2000-01-01 00:08:00    8
Freq: T, dtype: int64
>>> 
>>> series.resample('3T', label='right').sum()
2000-01-01 00:03:00     3
2000-01-01 00:06:00    12
2000-01-01 00:09:00    21
Freq: 3T, dtype: int64

设置 closed='right'，即结果中会包含原数据中最右侧（较大）的值：

>>> import pandas as pd
>>> index = pd.date_range('1/1/2000', periods=9, freq='T')
>>> series = pd.Series(range(9), index=index)
>>> series
2000-01-01 00:00:00    0
2000-01-01 00:01:00    1
2000-01-01 00:02:00    2
2000-01-01 00:03:00    3
2000-01-01 00:04:00    4
2000-01-01 00:05:00    5
2000-01-01 00:06:00    6
2000-01-01 00:07:00    7
2000-01-01 00:08:00    8
Freq: T, dtype: int64
>>> 
>>> series.resample('3T', label='right', closed='right').sum()
2000-01-01 00:00:00     0
2000-01-01 00:03:00     6
2000-01-01 00:06:00    15
2000-01-01 00:09:00    15
Freq: 3T, dtype: int64

以下示例将序列重采样到30秒的频率，asfreq()[0:5] 用于选择前5行数据：

>>> import pandas as pd
>>> index = pd.date_range('1/1/2000', periods=9, freq='T')
>>> series = pd.Series(range(9), index=index)
>>> series
2000-01-01 00:00:00    0
2000-01-01 00:01:00    1
2000-01-01 00:02:00    2
2000-01-01 00:03:00    3
2000-01-01 00:04:00    4
2000-01-01 00:05:00    5
2000-01-01 00:06:00    6
2000-01-01 00:07:00    7
2000-01-01 00:08:00    8
Freq: T, dtype: int64
>>> 
>>> series.resample('30S').asfreq()[0:5]
2000-01-01 00:00:00    0.0
2000-01-01 00:00:30    NaN
2000-01-01 00:01:00    1.0
2000-01-01 00:01:30    NaN
2000-01-01 00:02:00    2.0
Freq: 30S, dtype: float64

使用 pad 方法向后填充缺失值（NaN）：

>>> import pandas as pd
>>> index = pd.date_range('1/1/2000', periods=9, freq='T')
>>> series = pd.Series(range(9), index=index)
>>> series
2000-01-01 00:00:00    0
2000-01-01 00:01:00    1
2000-01-01 00:02:00    2
2000-01-01 00:03:00    3
2000-01-01 00:04:00    4
2000-01-01 00:05:00    5
2000-01-01 00:06:00    6
2000-01-01 00:07:00    7
2000-01-01 00:08:00    8
Freq: T, dtype: int64
>>> 
>>> series.resample('30S').pad()[0:5]
2000-01-01 00:00:00    0
2000-01-01 00:00:30    0
2000-01-01 00:01:00    1
2000-01-01 00:01:30    1
2000-01-01 00:02:00    2
Freq: 30S, dtype: int64

使用 bfill 方法向前填充缺失值（NaN）：

>>> import pandas as pd
>>> index = pd.date_range('1/1/2000', periods=9, freq='T')
>>> series = pd.Series(range(9), index=index)
>>> series
2000-01-01 00:00:00    0
2000-01-01 00:01:00    1
2000-01-01 00:02:00    2
2000-01-01 00:03:00    3
2000-01-01 00:04:00    4
2000-01-01 00:05:00    5
2000-01-01 00:06:00    6
2000-01-01 00:07:00    7
2000-01-01 00:08:00    8
Freq: T, dtype: int64
>>> 
>>> series.resample('30S').bfill()[0:5]
2000-01-01 00:00:00    0
2000-01-01 00:00:30    1
2000-01-01 00:01:00    1
2000-01-01 00:01:30    2
2000-01-01 00:02:00    2
Freq: 30S, dtype: int64

通过 apply 方法传递自定义函数：

>>> import pandas as pd
>>> index = pd.date_range('1/1/2000', periods=9, freq='T')
>>> series = pd.Series(range(9), index=index)
>>> series
2000-01-01 00:00:00    0
2000-01-01 00:01:00    1
2000-01-01 00:02:00    2
2000-01-01 00:03:00    3
2000-01-01 00:04:00    4
2000-01-01 00:05:00    5
2000-01-01 00:06:00    6
2000-01-01 00:07:00    7
2000-01-01 00:08:00    8
Freq: T, dtype: int64
>>> 
>>> def custom_resampler(array_like):
	return np.sum(array_like) + 5

>>> series.resample('3T').apply(custom_resampler)
2000-01-01 00:00:00     8
2000-01-01 00:03:00    17
2000-01-01 00:06:00    26
Freq: 3T, dtype: int64

convention 参数的应用：

>>> import pandas as pd
>>> s = pd.Series([1, 2], index=pd.period_range('2012-01-01', freq='A', periods=2))
>>> s
2012    1
2013    2
Freq: A-DEC, dtype: int64
>>> 
>>> s.resample('Q', convention='start').asfreq()
2012Q1    1.0
2012Q2    NaN
2012Q3    NaN
2012Q4    NaN
2013Q1    2.0
2013Q2    NaN
2013Q3    NaN
2013Q4    NaN
Freq: Q-DEC, dtype: float64
>>> 
>>> s.resample('Q', convention='end').asfreq()
2012Q4    1.0
2013Q1    NaN
2013Q2    NaN
2013Q3    NaN
2013Q4    2.0
Freq: Q-DEC, dtype: float64

>>> import pandas as pd
>>> q = pd.Series([1, 2, 3, 4], index=pd.period_range('2018-01-01', freq='Q', periods=4))
>>> q
2018Q1    1
2018Q2    2
2018Q3    3
2018Q4    4
Freq: Q-DEC, dtype: int64
>>> 
>>> q.resample('M', convention='end').asfreq()
2018-03    1.0
2018-04    NaN
2018-05    NaN
2018-06    2.0
2018-07    NaN
2018-08    NaN
2018-09    3.0
2018-10    NaN
2018-11    NaN
2018-12    4.0
Freq: M, dtype: float64
>>> 
>>> q.resample('M', convention='start').asfreq()
2018-01    1.0
2018-02    NaN
2018-03    NaN
2018-04    2.0
2018-05    NaN
2018-06    NaN
2018-07    3.0
2018-08    NaN
2018-09    NaN
2018-10    4.0
2018-11    NaN
2018-12    NaN
Freq: M, dtype: float64

对于 DataFrame 对象，可以使用关键字 on 来指定原数据中的某列为重采样后数据的行索引：

>>> import pandas as pd
>>> d = dict({'price': [10, 11, 9, 13, 14, 18, 17, 19],
          	  'volume': [50, 60, 40, 100, 50, 100, 40, 50]})
>>> df = pd.DataFrame(d)
>>> df['week_starting'] = pd.date_range('01/01/2018', periods=8, freq='W')
>>> df
   price  volume week_starting
0     10      50    2018-01-07
1     11      60    2018-01-14
2      9      40    2018-01-21
3     13     100    2018-01-28
4     14      50    2018-02-04
5     18     100    2018-02-11
6     17      40    2018-02-18
7     19      50    2018-02-25
>>> 
>>> df.resample('M', on='week_starting').mean()
               price  volume
week_starting               
2018-01-31     10.75    62.5
2018-02-28     17.00    60.0

对于具有层级索引（MultiIndex）的 DataFrame 对象，可以使用关键字 level 来指定需要在哪个级别上进行重新采样：

>>> import pandas as pd
>>> days = pd.date_range('1/1/2000', periods=4, freq='D')
>>> d2 = dict({'price': [10, 11, 9, 13, 14, 18, 17, 19],
           	   'volume': [50, 60, 40, 100, 50, 100, 40, 50]})
>>> df2 = pd.DataFrame(d2, index=pd.MultiIndex.from_product([days, ['morning', 'afternoon']]))
>>> df2
                      price  volume
2000-01-01 morning       10      50
           afternoon     11      60
2000-01-02 morning        9      40
           afternoon     13     100
2000-01-03 morning       14      50
           afternoon     18     100
2000-01-04 morning       17      40
           afternoon     19      50
>>> 
>>> df2.resample('D', level=0).sum()
            price  volume
2000-01-01     21     110
2000-01-02     22     140
2000-01-03     32     150
2000-01-04     36      90

这里是一段防爬虫文本，请读者忽略。
本文原创首发于 CSDN，作者 TRHX。
博客首页：https://itrhx.blog.csdn.net/
本文链接：https://itrhx.blog.csdn.net/article/details/106947061
未经授权，禁止转载！恶意转载，后果自负！尊重原创，远离剽窃！

你可能感兴趣的:(#,Pandas,python,数据分析,pandas,时间序列)

  • 理解Gunicorn：Python WSGI服务器的基石 范范0825 ipythonlinux运维
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
  • Python数据分析与可视化实战指南 William数据分析 pythonpython数据
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
  • python os.environ 江湖偌大 python深度学习
    os.environ['TF_CPP_MIN_LOG_LEVEL']='0'#默认值，输出所有信息os.environ['TF_CPP_MIN_LOG_LEVEL']='1'#屏蔽通知信息（INFO）os.environ['TF_CPP_MIN_LOG_LEVEL']='2'#屏蔽通知信息和警告信息（INFO\WARNING）os.environ['TF_CPP_MIN_LOG_LEVEL']='
  • Python中os.environ基本介绍及使用方法 鹤冲天Pro #Pythonpython服务器开发语言
    文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
  • Pyecharts数据可视化大屏：打造沉浸式数据分析体验 我的运维人生 信息可视化数据分析数据挖掘运维开发技术共享
    Pyecharts数据可视化大屏：打造沉浸式数据分析体验在当今这个数据驱动的时代，如何将海量数据以直观、生动的方式展现出来，成为了数据分析师和企业决策者关注的焦点。Pyecharts，作为一款基于Python的开源数据可视化库，凭借其丰富的图表类型、灵活的配置选项以及高度的定制化能力，成为了构建数据可视化大屏的理想选择。本文将深入探讨如何利用Pyecharts打造数据可视化大屏，并通过实际代码案例
  • Python教程：一文了解使用Python处理XPath 旦莫 Python进阶python开发语言
    目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
  • python os.environ_python os.environ 读取和设置环境变量 weixin_39605414 pythonos.environ
    >>>importos>>>os.environ.keys()['LC_NUMERIC','GOPATH','GOROOT','GOBIN','LESSOPEN','SSH_CLIENT','LOGNAME','USER','HOME','LC_PAPER','PATH','DISPLAY','LANG','TERM','SHELL','J2REDIR','LC_MONETARY','QT_QPA
  • 使用Faiss进行高效相似度搜索 llzwxh888 faisspython
    在现代AI应用中，快速和高效的相似度搜索是至关重要的。Faiss（FacebookAISimilaritySearch）是一个专门用于快速相似度搜索和聚类的库，特别适用于高维向量。本文将介绍如何使用Faiss来进行相似度搜索，并结合Python代码演示其基本用法。什么是Faiss？Faiss是一个由FacebookAIResearch团队开发的开源库，主要用于高维向量的相似性搜索和聚类。Faiss
  • python是什么意思中文-在python中%是什么意思 编程大乐趣
    Python中%有两种：1、数值运算：%代表取模，返回除法的余数。如：>>>7%212、%操作符（字符串格式化，stringformatting），说明如下：%[(name)][flags][width].[precision]typecode(name)为命名flags可以有+，-，''或0。+表示右对齐。-表示左对齐。''为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填
  • Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Pythonpython开发语言大数据数据分析数据挖掘
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
  • python八股文面试题分享及解析(1) Shawn________ python
    #1.'''a=1b=2不用中间变量交换a和b'''#1.a=1b=2a,b=b,aprint(a)print(b)结果：21#2.ll=[]foriinrange(3):ll.append({'num':i})print(11)结果:#[{'num':0},{'num':1},{'num':2}]#3.kk=[]a={'num':0}foriinrange(3):#0,12#可变类型，不仅仅改变
  • 每日算法&面试题，大厂特训二十八天——第二十天（树） 肥学 ⚡算法题⚡面试题每日精进java算法数据结构
    目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
  • Python快速入门 —— 第三节：类与对象 孤华暗香 Python快速入门python开发语言
    第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#
  • pyecharts——绘制柱形图折线图 2224070247 信息可视化pythonjava数据可视化
    一、pyecharts概述自2013年6月百度EFE(ExcellentFrontEnd）数据可视化团队研发的ECharts1.0发布到GitHub网站以来，ECharts一直备受业界权威的关注并获得广泛好评，成为目前成熟且流行的数据可视化图表工具，被应用到诸多数据可视化的开发领域。Python作为数据分析领域最受欢迎的语言，也加入ECharts的使用行列，并研发出方便Python开发者使用的数据
  • Python 实现图片裁剪（附代码） | Python工具 剑客阿良_ALiang
    前言本文提供将图片按照自定义尺寸进行裁剪的工具方法，一如既往的实用主义。环境依赖ffmpeg环境安装，可以参考我的另一篇文章：windowsffmpeg安装部署_阿良的博客-CSDN博客本文主要使用到的不是ffmpeg，而是ffprobe也在上面这篇文章中的zip包中。ffmpy安装：pipinstallffmpy-ihttps://pypi.douban.com/simple代码不废话了，上代码
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（4) 算法大师 华为od面试python
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
  • python os 环境变量 CV矿工 python开发语言numpy
    环境变量：环境变量是程序和操作系统之间的通信方式。有些字符不宜明文写进代码里，比如数据库密码，个人账户密码，如果写进自己本机的环境变量里，程序用的时候通过os.environ.get（）取出来就行了。os.environ是一个环境变量的字典。环境变量的相关操作importos"""设置/修改环境变量：os.environ[‘环境变量名称’]=‘环境变量值’#其中key和value均为string类
  • Python爬虫解析工具之xpath使用详解 eqa11 python爬虫开发语言
    文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（1） 算法大师 华为od面试python
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.数据预处理流程数据预处理的主要步骤工具和库2.介绍线性回归、逻辑回归模型线性回归（LinearRegression）模型形式：关键点：逻辑回归（LogisticRegression）模型形式：关键点：参数估计与评估：3.python浅拷贝及深拷贝浅拷贝（Shal
  • nosql数据库技术与应用知识点 皆过客，揽星河 NoSQLnosql数据库大数据数据分析数据结构非关系型数据库
    Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
  • 《Python数据分析实战终极指南》 xjt921122 python数据分析开发语言
    对于分析师来说，大家在学习Python数据分析的路上，多多少少都遇到过很多大坑**，有关于技能和思维的**：Excel已经没办法处理现有的数据量了，应该学Python吗？找了一大堆Python和Pandas的资料来学习，为什么自己动手就懵了？跟着比赛类公开数据分析案例练了很久，为什么当自己面对数据需求还是只会数据处理而没有分析思路？学了对比、细分、聚类分析，也会用PEST、波特五力这类分析法，为啥
  • Python中深拷贝与浅拷贝的区别 yuxiaoyu.
    转自：http://blog.csdn.net/u014745194/article/details/70271868定义：在Python中对象的赋值其实就是对象的引用。当创建一个对象，把它赋值给另一个变量的时候，python并没有拷贝这个对象，只是拷贝了这个对象的引用而已。浅拷贝：拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。也就是，把对象复制一遍，但是该对象中引用的其他对象我不复
  • Python开发常用的三方模块如下： 换个网名有点难 python开发语言
    Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
  • ES聚合分析原理与代码实例讲解 光剑书架上的书 大厂Offer收割机面试题简历程序员读书硅基计算碳基计算认知计算生物计算深度学习神经网络大数据AIGCAGILLMJavaPython架构设计Agent程序员实现财富自由
    ES聚合分析原理与代码实例讲解1.背景介绍1.1问题的由来在大规模数据分析场景中，特别是在使用Elasticsearch（ES）进行数据存储和检索时，聚合分析成为了一个至关重要的功能。聚合分析允许用户对数据集进行细分和分组，以便深入探索数据的结构和模式。这在诸如实时监控、日志分析、业务洞察等领域具有广泛的应用。1.2研究现状目前，ES聚合分析已经成为现代大数据平台的核心组件之一。它支持多种类型的聚
  • Python编译器 鹿鹿~ Python编译器Pythonpython开发语言后端
    嘿嘿嘿我又来了啊有些小盆友可能不知道Python其实是有编译器的，也就是PyCharm。你们可能会问到这个是干嘛的又不可以吃也不可以穿好像没有什么用，其实你还说对了这个还真的不可以吃也不可以穿，但是它用来干嘛的呢。用来编译你所打出的代码进行运行（可能这里说的有点不对但是只是个人认为）现在我们来说说PyCharm是用来干嘛的。PyCharm是一种PythonIDE，带有一整套可以帮助用户在使用Pyt
  • 一文掌握python面向对象魔术方法（二） 程序员neil pythonpython开发语言
    接上篇：一文掌握python面向对象魔术方法（一）-CSDN博客目录六、迭代和序列化：1、__iter__(self):定义迭代器，使得类可以被for循环迭代。2、__getitem__(self,key):定义索引操作，如obj[key]。3、__setitem__(self,key,value):定义赋值操作，如obj[key]=value。4、__delitem__(self,key):定义
  • 一文掌握python常用的list（列表）操作 程序员neil pythonpython开发语言
    目录一、创建列表1.直接创建列表：2.使用list()构造器3.使用列表推导式4.创建空列表二、访问列表元素1.列表支持通过索引访问元素，索引从0开始：2.还可以使用切片操作访问列表的一部分：三、修改列表元素四、添加元素1.append()：在末尾添加元素2.insert()：在指定位置插入元素五、删除元素1.del：删除指定位置的元素2.remove()：删除指定值的第一个匹配项3.pop()：
  • Python实现简单的机器学习算法 master_chenchengg pythonpython办公效率python开发IT
    Python实现简单的机器学习算法开篇：初探机器学习的奇妙之旅搭建环境：一切从安装开始必备工具箱第一步：安装Anaconda和JupyterNotebook小贴士：如何配置Python环境变量算法初体验：从零开始的Python机器学习线性回归：让数据说话数据准备：从哪里找数据编码实战：Python实现线性回归模型评估：如何判断模型好坏逻辑回归：从分类开始理论入门：什么是逻辑回归代码实现：使用skl
  • 自然语言处理_tf-idf _feivirus_ 算法机器学习和数学自然语言处理tf-idf逆文档频率词频
    importpandasaspdimportmath1.数据预处理docA="Thecatsatonmyface"docB="Thedogsatonmybed"wordsA=docA.split("")wordsB=docB.split("")wordsSet=set(wordsA).union(set(wordsB))print(wordsSet){'on','my','face','sat',
  • K近邻算法_分类鸢尾花数据集 _feivirus_ 算法机器学习和数学分类机器学习K近邻
    importnumpyasnpimportpandasaspdfromsklearn.datasetsimportload_irisfromsklearn.model_selectionimporttrain_test_splitfromsklearn.metricsimportaccuracy_score1.数据预处理iris=load_iris()df=pd.DataFrame(data=ir
  • 312个免费高速HTTP代理IP（能隐藏自己真实IP地址） yangshangchuan 高速免费superwordHTTP代理
        124.88.67.20:843 190.36.223.93:8080 117.147.221.38:8123 122.228.92.103:3128 183.247.211.159:8123 124.88.67.35:81 112.18.51.167:8123 218.28.96.39:3128 49.94.160.198:3128 183.20
  • pull解析和json编码 百合不是茶 androidpull解析json
    n.json文件: [{name:java,lan:c++,age:17},{name:android,lan:java,age:8}]   pull.xml文件 <?xml version="1.0" encoding="utf-8"?> <stu>     <name>java
  • [能源与矿产]石油与地球生态系统 comsci 能源
          按照苏联的科学界的说法,石油并非是远古的生物残骸的演变产物,而是一种可以由某些特殊地质结构和物理条件生产出来的东西,也就是说,石油是可以自增长的....       那么我们做一个猜想: 石油好像是地球的体液,我们地球具有自动产生石油的某种机制,只要我们不过量开采石油,并保护好
  • 类与对象浅谈 沐刃青蛟 java基础
           类，字面理解，便是同一种事物的总称，比如人类，是对世界上所有人的一个总称。而对象，便是类的具体化，实例化，是一个具体事物，比如张飞这个人，就是人类的一个对象。但要注意的是：张飞这个人是对象，而不是张飞，张飞只是他这个人的名字，是他的属性而已。而一个类中包含了属性和方法这两兄弟，他们分别用来描述对象的行为和性质（感觉应该是
  • 新站开始被收录后，我们应该做什么？ IT独行者 PHPseo
    新站开始被收录后，我们应该做什么？         百度终于开始收录自己的网站了，作为站长，你是不是觉得那一刻很有成就感呢，同时，你是不是又很茫然，不知道下一步该做什么了？至少我当初就是这样，在这里和大家一份分享一下新站收录后，我们要做哪些工作。       至于如何让百度快速收录自己的网站，可以参考我之前的帖子《新站让百
  • oracle 连接碰到的问题 文强chu oracle
    Unable to find a java Virtual Machine－－安装64位版Oracle11gR2后无法启动SQLDeveloper的解决方案 作者：草根IT网 来源：未知 人气：813标签： 导读：安装64位版Oracle11gR2后发现启动SQLDeveloper时弹出配置java.exe的路径，找到Oracle自带java.exe后产生的路径“C:\app\用户名\prod
  • Swing中按ctrl键同时移动鼠标拖动组件（类中多借口共享同一数据） 小桔子 java继承swing接口监听
            都知道java中类只能单继承，但可以实现多个接口，但我发现实现多个接口之后，多个接口却不能共享同一个数据，应用开发中想实现：当用户按着ctrl键时，可以用鼠标点击拖动组件，比如说文本框。 编写一个监听实现KeyListener,NouseListener,MouseMotionListener三个接口，重写方法。定义一个全局变量boolea
  • linux常用的命令 aichenglong linux常用命令
    1 startx切换到图形化界面 2 man命令:查看帮助信息 man 需要查看的命令,man命令提供了大量的帮助信息,一般可以分成4个部分 name:对命令的简单说明 synopsis:命令的使用格式说明 description:命令的详细说明信息 options:命令的各项说明 3 date:显示时间 语法：date [OPTION]... [+FORMAT]
  • eclipse内存优化 AILIKES javaeclipsejvmjdk
    一 基本说明      在JVM中，总体上分2块内存区,默认空余堆内存小于 40%时，JVM就会增大堆直到-Xmx的最大限制；空余堆内存大于70%时，JVM会减少堆直到-Xms的最小限制。     1)堆内存(Heap memory):堆是运行时数据区域，所有类实例和数组的内存均从此处分配,是Java代码可及的内存，是留给开发人
  • 关键字的使用探讨 百合不是茶 关键字
    //关键字的使用探讨/*访问关键词private 只能在本类中访问public 只能在本工程中访问protected 只能在包中和子类中访问默认的 只能在包中访问*//*final   类 方法 变量 final 类 不能被继承 final 方法 不能被子类覆盖，但可以继承 final 变量 只能有一次赋值，赋值后不能改变 final 不能用来修饰构造方法*///this()
  • JS中定义对象的几种方式 bijian1013 js
        1. 基于已有对象扩充其对象和方法(只适合于临时的生成一个对象)： <html> <head> <title>基于已有对象扩充其对象和方法(只适合于临时的生成一个对象)</title> </head> <script> var obj = new Object();
  • 表驱动法实例 bijian1013 java表驱动法TDD
    获得月的天数是典型的直接访问驱动表方式的实例，下面我们来展示一下： MonthDaysTest.java package com.study.test; import org.junit.Assert; import org.junit.Test; import com.study.MonthDays; public class MonthDaysTest { @T
  • LInux启停重启常用服务器的脚本 bit1129 linux
    启动，停止和重启常用服务器的Bash脚本，对于每个服务器，需要根据实际的安装路径做相应的修改   #! /bin/bash Servers=(Apache2, Nginx, Resin, Tomcat, Couchbase, SVN, ActiveMQ, Mongo); Ops=(Start, Stop, Restart); currentDir=$(pwd); echo
  • 【HBase六】REST操作HBase bit1129 hbase
    HBase提供了REST风格的服务方便查看HBase集群的信息，以及执行增删改查操作   1. 启动和停止HBase REST 服务 1.1 启动REST服务 前台启动（默认端口号8080） [hadoop@hadoop bin]$ ./hbase rest start   后台启动 hbase-daemon.sh start rest   启动时指定
  • 大话zabbix 3.0设计假设 ronin47
    What’s new in Zabbix 2.0? 去年开始使用Zabbix的时候，是1.8.X的版本，今年Zabbix已经跨入了2.0的时代。看了2.0的release notes，和performance相关的有下面几个：          :: Performance improvements::Trigger related da
  • http错误码大全 byalias http协议javaweb
    响应码由三位十进制数字组成，它们出现在由HTTP服务器发送的响应的第一行。 响应码分五种类型，由它们的第一位数字表示： 1）1xx：信息，请求收到，继续处理 2）2xx：成功，行为被成功地接受、理解和采纳 3）3xx：重定向，为了完成请求，必须进一步执行的动作 4）4xx：客户端错误，请求包含语法错误或者请求无法实现 5）5xx：服务器错误，服务器不能实现一种明显无效的请求
  • J2EE设计模式-Intercepting Filter bylijinnan java设计模式数据结构
    Intercepting Filter类似于职责链模式 有两种实现 其中一种是Filter之间没有联系，全部Filter都存放在FilterChain中，由FilterChain来有序或无序地把把所有Filter调用一遍。没有用到链表这种数据结构。示例如下： package com.ljn.filter.custom; import java.util.ArrayList;
  • 修改jboss端口 chicony jboss
    修改jboss端口   %JBOSS_HOME%\server\{服务实例名}\conf\bindingservice.beans\META-INF\bindings-jboss-beans.xml   中找到 <!-- The ports-default bindings are obtained by taking the base bindin
  • c++ 用类模版实现数组类 CrazyMizzz C++
    最近c++学到数组类，写了代码将他实现，基本具有vector类的功能 #include<iostream> #include<string> #include<cassert> using namespace std; template<class T> class Array { public: //构造函数
  • hadoop dfs.datanode.du.reserved 预留空间配置方法 daizj hadoop预留空间
    对于datanode配置预留空间的方法 为：在hdfs-site.xml添加如下配置  <property>     <name>dfs.datanode.du.reserved</name>     <value>10737418240</value>    
  • mysql远程访问的设置 dcj3sjt126com mysql防火墙
    第一步: 激活网络设置 你需要编辑mysql配置文件my.cnf. 通常状况，my.cnf放置于在以下目录： /etc/mysql/my.cnf (Debian linux) /etc/my.cnf （Red Hat Linux/Fedora Linux) /var/db/mysql/my.cnf (FreeBSD) 然后用vi编辑my.cnf，修改内容从以下行： [mysqld] 你所需要: 1
  • ios 使用特定的popToViewController返回到相应的Controller dcj3sjt126com controller
    1、取navigationCtroller中的Controllers NSArray * ctrlArray = self.navigationController.viewControllers; 2、取出后，执行， [self.navigationController popToViewController:[ctrlArray objectAtIndex:0] animated:YES
  • Linux正则表达式和通配符的区别 eksliang 正则表达式通配符和正则表达式的区别通配符
    转载请出自出处：http://eksliang.iteye.com/blog/1976579 首先得明白二者是截然不同的 通配符只能用在shell命令中,用来处理字符串的的匹配。 判断一个命令是否为bash shell(linux 默认的shell)的内置命令 type -t commad 返回结果含义 file  表示为外部命令 alias  表示该
  • Ubuntu Mysql Install and CONF gengzg Install
    http://www.navicat.com.cn/download/navicat-for-mysql Step1: 下载Navicat ，网址：http://www.navicat.com/en/download/download.html Step2：进入下载目录，解压压缩包：tar -zxvf navicat11_mysql_en.tar.gz
  • 批处理，删除文件bat huqiji windowsdos
    @echo off ::演示：删除指定路径下指定天数之前（以文件名中包含的日期字符串为准）的文件。 ::如果演示结果无误，把del前面的echo去掉，即可实现真正删除。 ::本例假设文件名中包含的日期字符串（比如：bak-2009-12-25.log） rem 指定待删除文件的存放路径 set SrcDir=C:/Test/BatHome rem 指定天数 set DaysAgo=1
  • 跨浏览器兼容的HTML5视频音频播放器 天梯梦 html5
    HTML5的video和audio标签是用来在网页中加入视频和音频的标签，在支持html5的浏览器中不需要预先加载Adobe Flash浏览器插件就能轻松快速的播放视频和音频文件。而html5media.js可以在不支持html5的浏览器上使video和audio标签生效。   How to enable <video> and <audio> tags in
  • Bundle自定义数据传递 hm4123660 androidSerializable自定义数据传递BundleParcelable
          我们都知道Bundle可能过put****()方法添加各种基本类型的数据，Intent也可以通过putExtras(Bundle)将数据添加进去，然后通过startActivity()跳到下一下Activity的时候就把数据也传到下一个Activity了。如传递一个字符串到下一个Activity   把数据放到Intent
  • C＃：异步编程和线程的使用（.NET 4.5 ） powertoolsteam .net线程C#异步编程
    异步编程和线程处理是并发或并行编程非常重要的功能特征。为了实现异步编程，可使用线程也可以不用。将异步与线程同时讲，将有助于我们更好的理解它们的特征。 本文中涉及关键知识点 1. 异步编程 2. 线程的使用 3. 基于任务的异步模式 4. 并行编程 5. 总结 异步编程 什么是异步操作？异步操作是指某些操作能够独立运行，不依赖主流程或主其他处理流程。通常情况下，C＃程序
  • spark 查看 job history 日志 Stark_Summer 日志sparkhistoryjob
    SPARK_HOME/conf 下: spark-defaults.conf 增加如下内容 spark.eventLog.enabled true spark.eventLog.dir hdfs://master:8020/var/log/spark spark.eventLog.compress true spark-env.sh 增加如下内容 export SP
  • SSH框架搭建 wangxiukai2015eye springHibernatestruts
    MyEclipse搭建SSH框架 Struts Spring Hibernate 1、new一个web project。 2、右键项目，为项目添加Struts支持。    选择Struts2 Core Libraries -<MyEclipes-Library>      点击Finish。src目录下多了struts