chapter10.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center><h1>第十章 时序数据</h1></center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 一、时序中的基本对象\n",
    "\n",
    "时间序列的概念在日常生活中十分常见，但对于一个具体的时序事件而言，可以从多个时间对象的角度来描述。例如2020年9月7日周一早上8点整需要到教室上课，这个课会在当天早上10点结束，其中包含了哪些时间概念？\n",
    "\n",
    "* 第一，会出现时间戳（Date times）的概念，即'2020-9-7 08:00:00'和'2020-9-7 10:00:00'这两个时间点分别代表了上课和下课的时刻，在`pandas`中称为`Timestamp`。同时，一系列的时间戳可以组成`DatetimeIndex`，而将它放到`Series`中后，`Series`的类型就变为了`datetime64[ns]`，如果有涉及时区则为`datetime64[ns, tz]`，其中tz是timezone的简写。\n",
    "\n",
    "* 第二，会出现时间差（Time deltas）的概念，即上课需要的时间，两个`Timestamp`做差就得到了时间差，pandas中利用`Timedelta`来表示。类似的，一系列的时间差就组成了`TimedeltaIndex`， 而将它放到`Series`中后，`Series`的类型就变为了`timedelta64[ns]`。\n",
    "\n",
    "* 第三，会出现时间段（Time spans）的概念，即在8点到10点这个区间都会持续地在上课，在`pandas`利用`Period`来表示。类似的，一系列的时间段就组成了`PeriodIndex`， 而将它放到`Series`中后，`Series`的类型就变为了`Period`。\n",
    "\n",
    "* 第四，会出现日期偏置（Date offsets）的概念，假设你只知道9月的第一个周一早上8点要去上课，但不知道具体的日期，那么就需要一个类型来处理此类需求。再例如，想要知道2020年9月7日后的第30个工作日是哪一天，那么时间差就解决不了你的问题，从而`pandas`中的`DateOffset`就出现了。同时，`pandas`中没有为一列时间偏置专门设计存储类型，理由也很简单，因为需求比较奇怪，一般来说我们只需要对一批时间特征做一个统一的特殊日期偏置。\n",
    "\n",
    "通过这个简单的例子，就能够容易地总结出官方文档中的这个[表格](https://pandas.pydata.org/docs/user_guide/timeseries.html#overview)：\n",
    "\n",
    "|概念 |                          单元素类型              |    数组类型         |                pandas数据类型|\n",
    "|:---------|:----------|:-----------|:------------|\n",
    "|Date times           |           `Timestamp`       |       `DatetimeIndex`  |   `datetime64[ns]`|\n",
    "|Time deltas          |           `Timedelta`        |      `TimedeltaIndex` |  `timedelta64[ns]`|\n",
    "|Time spans            |          `Period`           |      `PeriodIndex`   |    `period[freq]`|\n",
    "|Date offsets          |          `DateOffset`         |    `None`          |    `None`|\n",
    "\n",
    "由于时间段对象`Period/PeriodIndex`的使用频率并不高，因此将不进行讲解，而只涉及时间戳序列、时间差序列和日期偏置的相关内容。\n",
    "\n",
    "## 二、时间戳\n",
    "### 1. Timestamp的构造与属性\n",
    "\n",
    "- 单个时间戳的生成利用`pd.Timestamp`实现，一般而言的常见日期格式都能被成功地转换：\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2020-01-01 00:00:00')"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ts = pd.Timestamp('2020/1/1')#T要大写\n",
    "ts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2020-01-01 08:10:30')"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ts = pd.Timestamp('2020-1-1 08:10:30')\n",
    "ts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 通过`year, month, day, hour, min, second`可以获取具体的数值："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2020"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ts.year"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ts.month"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ts.day"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ts.hour"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ts.minute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ts.second"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在`pandas`中，时间戳的最小精度为纳秒`ns`，由于使用了64位存储，可以表示的时间范围大约可以如下计算：\n",
    "$$\\rm Time\\,Range = \\frac{2^{64}}{10^9\\times 60\\times 60\\times 24\\times 365} \\approx 585 (Years)$$\n",
    "通过`pd.Timestamp.max`和`pd.Timestamp.min`可以获取时间戳表示的范围，可以看到确实表示的区间年数大小正如上述计算结果："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2262-04-11 23:47:16.854775807')"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Timestamp.max"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('1677-09-21 00:12:43.145225')"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Timestamp.min"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "585"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Timestamp.max.year - pd.Timestamp.min.year"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Datetime序列的生成\n",
    "\n",
    "一组时间戳可以组成时间序列，可以用`to_datetime`和`date_range`来生成。其中，`to_datetime`能够把一列时间戳格式的对象转换成为`datetime64[ns]`类型的时间序列："
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- pd.to_datetime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2020-01-01 08:00:00', '2020-01-03 00:00:00',\n",
       "               '2020-01-06 00:00:00'],\n",
       "              dtype='datetime64[ns]', freq=None)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.to_datetime(['2020-1-1 08:00:00', '2020-1-3', '2020-1-6'])#时间戳形式yyyy-mm-dd hh:mm:ss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0   2019-10-05\n",
       "1   2019-09-04\n",
       "2   2019-09-12\n",
       "3   2020-01-03\n",
       "4   2019-11-06\n",
       "Name: Test_Date, dtype: datetime64[ns]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.read_csv('C:\\datawhale\\joyful-pandas-master\\data\\learn_pandas.csv')\n",
    "s = pd.to_datetime(df.Test_Date)\n",
    "s.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在极少数情况，时间戳的格式不满足转换时，可以强制使用`format`进行匹配："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2020-01-01', '2020-01-03'], dtype='datetime64[ns]', freq=None)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temp = pd.to_datetime(['2020\\\\1\\\\1','2020\\\\1\\\\3'],format='%Y\\\\%m\\\\%d')#设定格式\n",
    "temp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "注意上面由于传入的是列表，而非`pandas`内部的`Series`，因此返回的是`DatetimeIndex`，如果想要转为`datetime64[ns]`的序列，需要显式用`Series`转化："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0   2020-01-01\n",
       "1   2020-01-03\n",
       "dtype: datetime64[ns]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series(temp).head()#index转化成序列"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "另外，还存在一种把表的多列时间属性拼接转为时间序列的`to_datetime`操作，此时的列名必须和以下给定的时间关键词列名一致："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0   2020-01-01 10:30:20\n",
       "1   2020-01-02 20:50:40\n",
       "dtype: datetime64[ns]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_date_cols = pd.DataFrame({'year': [2020, 2020],\n",
    "                             'month': [1, 1],\n",
    "                             'day': [1, 2],\n",
    "                             'hour': [10, 20],\n",
    "                             'minute': [30, 50],\n",
    "                             'second': [20, 40]})\n",
    "pd.to_datetime(df_date_cols)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`date_range`是一种生成连续间隔时间的一种方法，其重要的参数为`start, end, freq, periods`，它们分别表示开始时间，结束时间，时间间隔，时间戳个数。其中，四个中的三个参数决定了，那么剩下的一个就随之确定了。这里要注意，开始或结束日期如果作为端点则它会被包含："
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- pd.date_range"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2020-01-01', '2020-01-11', '2020-01-21'], dtype='datetime64[ns]', freq='10D')"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.date_range('2020-1-1','2020-1-21', freq='10D') # 包含,频率是10day"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2020-01-01', '2020-01-11', '2020-01-21', '2020-01-31',\n",
       "               '2020-02-10', '2020-02-20'],\n",
       "              dtype='datetime64[ns]', freq='10D')"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.date_range('2020-1-1','2020-2-28', freq='10D')#不包含结束端点"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2020-01-01 00:00:00', '2020-01-12 14:24:00',\n",
       "               '2020-01-24 04:48:00', '2020-02-04 19:12:00',\n",
       "               '2020-02-16 09:36:00', '2020-02-28 00:00:00'],\n",
       "              dtype='datetime64[ns]', freq=None)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.date_range('2020-1-1', '2020-2-28', periods=6) # 由于结束日期无法取到，freq不为10天"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 【练一练】\n",
    "`Timestamp`上定义了一个`value`属性，其返回的整数值代表了从1970年1月1日零点到给定时间戳相差的纳秒数，请利用这个属性构造一个随机生成给定日期区间内日期序列的函数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2010-01-18 00:19:02.088919040',\n",
       "               '2010-01-23 04:06:03.198891776',\n",
       "               '2010-01-19 16:27:21.426470400'],\n",
       "              dtype='datetime64[ns]', freq=None)"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def my_datetime(s1,s2,n):#n表示size\n",
    "    t1=pd.Timestamp(s1).value\n",
    "    t2=pd.Timestamp(s2).value\n",
    "    np.random.seed(0)\n",
    "    res=pd.to_datetime(np.random.rand(n)*(t2-t1)+t1)\n",
    "    return res\n",
    "\n",
    "my_datetime('2010/1/1','2010/2/1',3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 【end】"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最后，要介绍一种改变序列采样频率的方法`asfreq`，它能够根据给定的`freq`对序列进行类似于`reindex`的操作："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2020-01-01    0.544883\n",
       "2020-01-03    0.423655\n",
       "2020-01-05    0.645894\n",
       "2020-01-07    0.437587\n",
       "2020-01-09    0.891773\n",
       "dtype: float64"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = pd.Series(np.random.rand(5), index=pd.to_datetime(['2020-1-%d'%i for i in range(1,10,2)]))\n",
    "s.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2020-01-01    0.544883\n",
       "2020-01-02         NaN\n",
       "2020-01-03    0.423655\n",
       "2020-01-04         NaN\n",
       "2020-01-05    0.645894\n",
       "Freq: D, dtype: float64"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.asfreq('D').head()#按一天的频率取样"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2020-01-01 00:00:00    0.544883\n",
       "2020-01-01 12:00:00         NaN\n",
       "2020-01-02 00:00:00         NaN\n",
       "2020-01-02 12:00:00         NaN\n",
       "2020-01-03 00:00:00    0.423655\n",
       "Freq: 12H, dtype: float64"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.asfreq('12H').head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "前面提到了`datetime64[ns]`本质上可以理解为一个大整数，对于一个该类型的序列，可以使用`max, min, mean`，来取得最大时间戳、最小时间戳和“平均”时间戳。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. dt对象\n",
    "\n",
    "如同`category, string`的序列上定义了`cat, str`来完成分类数据和文本数据的操作，在时序类型的序列上定义了`dt`对象来完成许多时间序列的相关操作。这里对于`datetime64[ns]`类型而言，可以大致分为三类操作：取出时间相关的属性、判断时间戳是否满足条件、取整操作。\n",
    "\n",
    "第一类操作的常用属性包括：`date, time, year, month, day, hour, minute, second, microsecond, nanosecond, dayofweek, dayofyear, weekofyear, daysinmonth, quarter`，其中`daysinmonth, quarter`分别表示月中的第几天和季度。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    2020-01-01\n",
       "1    2020-01-02\n",
       "2    2020-01-03\n",
       "dtype: object"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = pd.Series(pd.date_range('2020-1-1','2020-1-3', freq='D'))\n",
    "s.dt.date#s是datetime64【ns】类型，这样是obj类型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    00:00:00\n",
       "1    00:00:00\n",
       "2    00:00:00\n",
       "dtype: object"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.dt.time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    1\n",
       "1    2\n",
       "2    3\n",
       "dtype: int64"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.dt.day"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    31\n",
       "1    31\n",
       "2    31\n",
       "dtype: int64"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.dt.daysinmonth#表示这天所在月的总天数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    1\n",
       "1    1\n",
       "2    1\n",
       "dtype: int64"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.dt.quarter#这个时间戳所在的季度"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在这些属性中，经常使用的是`dayofweek`，它返回了周中的星期情况，周一为0、周二为1，以此类推："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    2\n",
       "1    3\n",
       "2    4\n",
       "dtype: int64"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.dt.dayofweek"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "此外，可以通过`month_name, day_name`返回英文的月名和星期名，注意它们是方法而不是属性："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    January\n",
       "1    January\n",
       "2    January\n",
       "dtype: object"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.dt.month_name()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    Wednesday\n",
       "1     Thursday\n",
       "2       Friday\n",
       "dtype: object"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.dt.day_name()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "第二类判断操作主要用于测试是否为月/季/年的第一天或者最后一天："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0     True\n",
       "1    False\n",
       "2    False\n",
       "dtype: bool"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.dt.is_year_start # 还可选 is_quarter/month_start"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    False\n",
       "1    False\n",
       "2    False\n",
       "dtype: bool"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.dt.is_year_end # 还可选 is_quarter/month_end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "第三类的取整操作包含`round, ceil, floor`，它们的公共参数为`freq`，常用的包括`H, min, S`（小时、分钟、秒），所有可选的`freq`可参考[此处](https://pandas.pydata.org/docs/user_guide/timeseries.html#offset-aliases>)。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0   2020-01-01 20:35:00\n",
       "1   2020-01-01 21:20:00\n",
       "2   2020-01-01 22:05:00\n",
       "dtype: datetime64[ns]"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = pd.Series(pd.date_range('2020-1-1 20:35:00', '2020-1-1 22:35:00', freq='45min'))\n",
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0   2020-01-01 21:00:00\n",
       "1   2020-01-01 21:00:00\n",
       "2   2020-01-01 22:00:00\n",
       "dtype: datetime64[ns]"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.dt.round('1H')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0   2020-01-01 21:00:00\n",
       "1   2020-01-01 22:00:00\n",
       "2   2020-01-01 23:00:00\n",
       "dtype: datetime64[ns]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.dt.ceil('1H')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0   2020-01-01 20:00:00\n",
       "1   2020-01-01 21:00:00\n",
       "2   2020-01-01 22:00:00\n",
       "dtype: datetime64[ns]"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.dt.floor('1H')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. 时间戳的切片与索引\n",
    "\n",
    "一般而言，时间戳序列作为索引使用。如果想要选出某个子时间戳序列，第一类方法是利用`dt`对象和布尔条件联合使用，另一种方式是利用切片，后者常用于连续时间戳。下面，举一些例子说明："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2020-01-01    0\n",
       "2020-01-02    0\n",
       "2020-01-03    0\n",
       "2020-01-04    0\n",
       "2020-01-05    1\n",
       "Freq: D, dtype: int32"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = pd.Series(np.random.randint(2,size=366), index=pd.date_range('2020-01-01','2020-12-31',freq='D'))\n",
    "idx = pd.Series(s.index).dt\n",
    "s.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example1：每月的第一天或者最后一天"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2020-01-01    0\n",
       "2020-01-31    1\n",
       "2020-02-01    1\n",
       "2020-02-29    0\n",
       "2020-03-01    0\n",
       "dtype: int32"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[(idx.is_month_start|idx.is_month_end).values].head()#(idx.is_month_start|idx.is_month_end)是一个布尔序列，取出values是是一个数组array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example2：双休日"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2020-01-04    0\n",
       "2020-01-05    1\n",
       "2020-01-11    1\n",
       "2020-01-12    0\n",
       "2020-01-18    0\n",
       "dtype: int32"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[idx.dayofweek.isin([5,6]).values].head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example3：取出单日值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s['2020-01-01']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s['20200101'] # 自动转换标准格式"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example4：取出七月"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2020-07-01    0\n",
       "2020-07-02    0\n",
       "2020-07-03    1\n",
       "2020-07-04    1\n",
       "2020-07-05    0\n",
       "Freq: D, dtype: int32"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s['2020-07'].head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example5：取出5月初至7月15日"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2020-05-01    1\n",
       "2020-05-02    0\n",
       "2020-05-03    0\n",
       "2020-05-04    1\n",
       "2020-05-05    1\n",
       "Freq: D, dtype: int32"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s['2020-05':'2020-7-15'].head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2020-07-11    1\n",
       "2020-07-12    0\n",
       "2020-07-13    1\n",
       "2020-07-14    1\n",
       "2020-07-15    1\n",
       "Freq: D, dtype: int32"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s['2020-05':'2020-7-15'].tail()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 三、时间差\n",
    "### 1. Timedelta的生成\n",
    "\n",
    "正如在第一节中所说，时间差可以理解为两个时间戳的差，这里也可以通过`pd.Timedelta`来构造："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timedelta('1 days 00:25:00')"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Timestamp('20200102 08:00:00')-pd.Timestamp('20200101 07:35:00')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timedelta('1 days 00:25:00')"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Timedelta(days=1, minutes=25) # 需要注意加s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timedelta('1 days 00:25:00')"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Timedelta('1 days 25 minutes') # 字符串生成"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "生成时间差序列的主要方式是`pd.to_timedelta`，其类型为`timedelta64[ns]`："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>School</th>\n",
       "      <th>Grade</th>\n",
       "      <th>Name</th>\n",
       "      <th>Gender</th>\n",
       "      <th>Height</th>\n",
       "      <th>Weight</th>\n",
       "      <th>Transfer</th>\n",
       "      <th>Test_Number</th>\n",
       "      <th>Test_Date</th>\n",
       "      <th>Time_Record</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Shanghai Jiao Tong University</td>\n",
       "      <td>Freshman</td>\n",
       "      <td>Gaopeng Yang</td>\n",
       "      <td>Female</td>\n",
       "      <td>158.9</td>\n",
       "      <td>46.0</td>\n",
       "      <td>N</td>\n",
       "      <td>1</td>\n",
       "      <td>2019/10/5</td>\n",
       "      <td>0:04:34</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Peking University</td>\n",
       "      <td>Freshman</td>\n",
       "      <td>Changqiang You</td>\n",
       "      <td>Male</td>\n",
       "      <td>166.5</td>\n",
       "      <td>70.0</td>\n",
       "      <td>N</td>\n",
       "      <td>1</td>\n",
       "      <td>2019/9/4</td>\n",
       "      <td>0:04:20</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Shanghai Jiao Tong University</td>\n",
       "      <td>Senior</td>\n",
       "      <td>Mei Sun</td>\n",
       "      <td>Male</td>\n",
       "      <td>188.9</td>\n",
       "      <td>89.0</td>\n",
       "      <td>N</td>\n",
       "      <td>2</td>\n",
       "      <td>2019/9/12</td>\n",
       "      <td>0:05:22</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                          School     Grade            Name  Gender  Height  \\\n",
       "0  Shanghai Jiao Tong University  Freshman    Gaopeng Yang  Female   158.9   \n",
       "1              Peking University  Freshman  Changqiang You    Male   166.5   \n",
       "2  Shanghai Jiao Tong University    Senior         Mei Sun    Male   188.9   \n",
       "\n",
       "   Weight Transfer  Test_Number  Test_Date Time_Record  \n",
       "0    46.0        N            1  2019/10/5     0:04:34  \n",
       "1    70.0        N            1   2019/9/4     0:04:20  \n",
       "2    89.0        N            2  2019/9/12     0:05:22  "
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0   0 days 00:04:34\n",
       "1   0 days 00:04:20\n",
       "2   0 days 00:05:22\n",
       "3   0 days 00:04:08\n",
       "4   0 days 00:05:22\n",
       "Name: Time_Record, dtype: timedelta64[ns]"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = pd.to_timedelta(df.Time_Record)\n",
    "s.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "与`date_range`一样，时间差序列也可以用`timedelta_range`来生成，它们两者具有一致的参数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TimedeltaIndex(['0 days 00:00:00', '0 days 00:06:00', '0 days 00:12:00'], dtype='timedelta64[ns]', freq='6T')"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.timedelta_range('0s', '1000s', freq='6min')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TimedeltaIndex(['0 days 00:00:00', '0 days 00:08:20', '0 days 00:16:40'], dtype='timedelta64[ns]', freq=None)"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.timedelta_range('0s', '1000s', periods=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "对于`Timedelta`序列，同样也定义了`dt`对象，上面主要定义了的属性包括`days, seconds, mircroseconds, nanoseconds`，它们分别返回了对应的时间差特征。需要注意的是，这里的`seconds`不是指单纯的秒，而是对天数取余后剩余的秒数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    274\n",
       "1    260\n",
       "2    322\n",
       "3    248\n",
       "4    322\n",
       "Name: Time_Record, dtype: int64"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.dt.seconds.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果不想对天数取余而直接对应秒数，可以使用`total_seconds`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    274.0\n",
       "1    260.0\n",
       "2    322.0\n",
       "3    248.0\n",
       "4    322.0\n",
       "Name: Time_Record, dtype: float64"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.dt.total_seconds().head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "与时间戳序列类似，取整函数也是可以在`dt`对象上使用的："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0   0 days 00:05:00\n",
       "1   0 days 00:04:00\n",
       "2   0 days 00:05:00\n",
       "3   0 days 00:04:00\n",
       "4   0 days 00:05:00\n",
       "Name: Time_Record, dtype: timedelta64[ns]"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.to_timedelta(df.Time_Record).dt.round('min').head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Timedelta的运算\n",
    "\n",
    "时间差支持的常用运算有三类：与标量的乘法运算、与时间戳的加减法运算、与时间差的加减法与除法运算："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timedelta('2 days 00:00:00')"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "td1 = pd.Timedelta(days=1)\n",
    "td2 = pd.Timedelta(days=3)\n",
    "ts = pd.Timestamp('20200101')\n",
    "td1 * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timedelta('2 days 00:00:00')"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "td2 - td1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2020-01-02 00:00:00')"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ts + td1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2019-12-31 00:00:00')"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ts - td1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这些运算都可以移植到时间差的序列上："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TimedeltaIndex(['5 days', '10 days', '15 days', '20 days', '25 days'], dtype='timedelta64[ns]', freq='5D')"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "td1 = pd.timedelta_range(start='1 days', periods=5)\n",
    "td2 = pd.timedelta_range(start='12 hours', freq='2H', periods=5)\n",
    "ts = pd.date_range('20200101', '20200105')#默认频率为一天\n",
    "td1*5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    0 days\n",
       "1    2 days\n",
       "2    6 days\n",
       "3   12 days\n",
       "4   20 days\n",
       "dtype: timedelta64[ns]"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "td1 * pd.Series(list(range(5))) # 逐个相乘01234"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TimedeltaIndex(['0 days 12:00:00', '1 days 10:00:00', '2 days 08:00:00',\n",
       "                '3 days 06:00:00', '4 days 04:00:00'],\n",
       "               dtype='timedelta64[ns]', freq=None)"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "td1 - td2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2020-01-02', '2020-01-03', '2020-01-04', '2020-01-05',\n",
       "               '2020-01-06'],\n",
       "              dtype='datetime64[ns]', freq='D')"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "td1 + pd.Timestamp('20200101')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2020-01-01', '2020-01-02', '2020-01-03', '2020-01-04',\n",
       "               '2020-01-05'],\n",
       "              dtype='datetime64[ns]', freq='D')"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2020-01-02', '2020-01-04', '2020-01-06', '2020-01-08',\n",
       "               '2020-01-10'],\n",
       "              dtype='datetime64[ns]', freq=None)"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "td1 + ts # 逐个相加"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 四、日期偏置\n",
    "### 1. Offset对象\n",
    "\n",
    "日期偏置是一种和日历相关的特殊时间差，例如回到第一节中的两个问题：如何求2020年9月第一个周一的日期，以及如何求2020年9月7日后的第30个工作日是哪一天。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<WeekOfMonth: week=0, weekday=0>"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.offsets.WeekOfMonth(week=0,weekday=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2020-09-07 00:00:00')"
      ]
     },
     "execution_count": 194,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Timestamp('20200831') + pd.offsets.WeekOfMonth(week=0,weekday=0)#下一月第一个周一"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2020-10-19 00:00:00')"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Timestamp('20200907') + pd.offsets.BDay(30)#30个工作日之后"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "从上面的例子中可以看到，`Offset`对象在`pd.offsets`中被定义。当使用`+`时获取离其最近的下一个日期，当使用`-`时获取离其最近的上一个日期："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2020-08-03 00:00:00')"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Timestamp('20200831') - pd.offsets.WeekOfMonth(week=0,weekday=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2020-07-27 00:00:00')"
      ]
     },
     "execution_count": 179,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Timestamp('20200907') - pd.offsets.BDay(30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2020-09-30 00:00:00')"
      ]
     },
     "execution_count": 180,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Timestamp('20200907') + pd.offsets.MonthEnd()#这个月末那天"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "常用的日期偏置如下可以查阅这里的[文档](https://pandas.pydata.org/docs/user_guide/timeseries.html#dateoffset-objects)描述。在文档罗列的`Offset`中，需要介绍一个特殊的`Offset`对象`CDay`，其中的`holidays, weekmask`参数能够分别对自定义的日期和星期进行过滤，前者传入了需要过滤的日期列表，后者传入的是三个字母的星期缩写构成的星期字符串，其作用是只保留字符串中出现的星期："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2020-01-08    2\n",
       "2020-01-09    3\n",
       "2020-01-10    4\n",
       "2020-01-11    5\n",
       "Freq: D, dtype: int64"
      ]
     },
     "execution_count": 181,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_filter = pd.offsets.CDay(n=1,weekmask='Wed Fri',holidays=['20200109'])\n",
    "dr = pd.date_range('20200108', '20200111')\n",
    "dr.to_series().dt.dayofweek"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Timestamp('2020-01-10 00:00:00'),\n",
       " Timestamp('2020-01-10 00:00:00'),\n",
       " Timestamp('2020-01-15 00:00:00'),\n",
       " Timestamp('2020-01-15 00:00:00')]"
      ]
     },
     "execution_count": 182,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[i + my_filter for i in dr]#下一个周三或者周五或者假日"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上面的例子中，`n`表示增加一天`CDay`，`dr`中的第一天为`20200108`，但由于下一天`20200109`被排除了，并且`20200110`是合法的周五，因此转为`20200110`，其他后面的日期处理类似。\n",
    "#### 【CAUTION】不要使用部分`Offset`\n",
    "在当前版本下由于一些 ``bug`` ，不要使用 ``Day`` 级别以下的 ``Offset`` 对象，比如 ``Hour, Second`` 等，请使用对应的 ``Timedelta`` 对象来代替。\n",
    "#### 【END】\n",
    "### 2. 偏置字符串\n",
    "\n",
    "前面提到了关于`date_range`的`freq`取值可用`Offset`对象，同时在`pandas`中几乎每一个`Offset`对象绑定了日期偏置字符串（`frequencies strings/offset aliases`），可以指定`Offset`对应的字符串来替代使用。下面举一些常见的例子。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2020-01-01', '2020-02-01', '2020-03-01'], dtype='datetime64[ns]', freq='MS')"
      ]
     },
     "execution_count": 183,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.date_range('20200101','20200331', freq='MS') # 月初"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2020-01-31', '2020-02-29', '2020-03-31'], dtype='datetime64[ns]', freq='M')"
      ]
     },
     "execution_count": 184,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.date_range('20200101','20200331', freq='M') # 月末"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2020-01-01', '2020-01-02', '2020-01-03', '2020-01-06',\n",
       "               '2020-01-07', '2020-01-08', '2020-01-09', '2020-01-10'],\n",
       "              dtype='datetime64[ns]', freq='B')"
      ]
     },
     "execution_count": 185,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.date_range('20200101','20200110', freq='B') # 工作日"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2020-01-06', '2020-01-13', '2020-01-20', '2020-01-27'], dtype='datetime64[ns]', freq='W-MON')"
      ]
     },
     "execution_count": 186,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.date_range('20200101','20200201', freq='W-MON') # 周一"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2020-01-06'], dtype='datetime64[ns]', freq='WOM-1MON')"
      ]
     },
     "execution_count": 187,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.date_range('20200101','20200201', freq='WOM-1MON') # 每月第一个周一"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上面的这些字符串，等价于使用如下的`Offset`对象："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2020-01-01', '2020-02-01', '2020-03-01'], dtype='datetime64[ns]', freq='MS')"
      ]
     },
     "execution_count": 188,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.date_range('20200101','20200331', freq=pd.offsets.MonthBegin())#月初"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2020-01-31', '2020-02-29', '2020-03-31'], dtype='datetime64[ns]', freq='M')"
      ]
     },
     "execution_count": 189,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.date_range('20200101','20200331', freq=pd.offsets.MonthEnd())#月末"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2020-01-01', '2020-01-02', '2020-01-03', '2020-01-06',\n",
       "               '2020-01-07', '2020-01-08', '2020-01-09', '2020-01-10'],\n",
       "              dtype='datetime64[ns]', freq='B')"
      ]
     },
     "execution_count": 190,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.date_range('20200101','20200110', freq=pd.offsets.BDay())#工作日"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2020-01-06', '2020-01-13', '2020-01-20', '2020-01-27'], dtype='datetime64[ns]', freq='C')"
      ]
     },
     "execution_count": 191,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.date_range('20200101','20200201', freq=pd.offsets.CDay(weekmask='Mon'))#周一"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2020-01-06', '2020-02-03'], dtype='datetime64[ns]', freq='WOM-1MON')"
      ]
     },
     "execution_count": 193,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.date_range('20200101','20200301', freq=pd.offsets.WeekOfMonth(week=0,weekday=0))#每个月第一个周一"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 【CAUTION】关于时区问题的说明\n",
    "各类时间对象的开发，除了使用`python`内置的`datetime`模块，`pandas`还利用了`dateutil`模块，很大一部分是为了处理时区问题。总所周知，我国是没有夏令时调整时间一说的，但有些国家会有这种做法，导致了相对而言一天里可能会有23/24/25个小时，也就是`relativedelta`，这使得`Offset`对象和`Timedelta`对象有了对同一问题处理产生不同结果的现象，其中的规则也较为复杂，官方文档的写法存在部分描述错误，并且难以对描述做出统一修正，因为牵涉到了`Offset`相关的很多组件。因此，本教程完全不考虑时区处理，如果对时区处理的时间偏置有兴趣了解讨论，可以联系我或者参见[这里](https://github.com/pandas-dev/pandas/pull/36516)的讨论。\n",
    "#### 【END】\n",
    "## 五、时序中的滑窗与分组\n",
    "### 1. 滑动窗口\n",
    "\n",
    "所谓时序的滑窗函数，即把滑动窗口用`freq`关键词代替，下面给出一个具体的应用案例：在股票市场中有一个指标为`BOLL`指标，它由中轨线、上轨线、下轨线这三根线构成，具体的计算方法分别是`N`日均值线、`N`日均值加两倍`N`日标准差线、`N`日均值减两倍`N`日标准差线。利用`rolling`对象计算`N=30`的`BOLL`指标可以如下写出："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2020-01-01   -1\n",
       "2020-01-02   -2\n",
       "2020-01-03   -1\n",
       "2020-01-06   -1\n",
       "2020-01-07   -2\n",
       "Freq: B, dtype: int32"
      ]
     },
     "execution_count": 195,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "idx = pd.date_range('20200101', '20201231', freq='B')#工作日\n",
    "np.random.seed(2020)\n",
    "data = np.random.randint(-1,2,len(idx)).cumsum() # 随机游动构造模拟序列\n",
    "s = pd.Series(data,index=idx)\n",
    "s.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x13e831c9d30>]"
      ]
     },
     "execution_count": 196,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "r = s.rolling('30D')#30天的滑动窗口\n",
    "plt.plot(s)\n",
    "plt.title('BOLL LINES')\n",
    "plt.plot(r.mean())\n",
    "plt.plot(r.mean()+r.std()*2)\n",
    "plt.plot(r.mean()-r.std()*2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "对于`shift`函数而言，作用在`datetime64`为索引的序列上时，可以指定`freq`单位进行滑动："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2020-02-20   -1\n",
       "2020-02-21   -2\n",
       "2020-02-22   -1\n",
       "2020-02-25   -1\n",
       "2020-02-26   -2\n",
       "dtype: int32"
      ]
     },
     "execution_count": 198,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.shift(freq='50D').head()#向后挪50天"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "另外，`datetime64[ns]`的序列进行`diff`后就能够得到`timedelta64[ns]`的序列，这能够使用户方便地观察有序时间序列的间隔："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0   2020-01-01\n",
       "1   2020-01-02\n",
       "2   2020-01-03\n",
       "3   2020-01-06\n",
       "4   2020-01-07\n",
       "dtype: datetime64[ns]"
      ]
     },
     "execution_count": 199,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_series = pd.Series(s.index)\n",
    "my_series.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0      NaT\n",
       "1   1 days\n",
       "2   1 days\n",
       "3   3 days\n",
       "4   1 days\n",
       "dtype: timedelta64[ns]"
      ]
     },
     "execution_count": 201,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_series.diff(1).head()#向前做差"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. 重采样\n",
    "\n",
    "重采样对象`resample`和第四章中分组对象`groupby`的用法类似，前者是针对时间序列的分组计算而设计的分组对象。\n",
    "\n",
    "例如，对上面的序列计算每10天的均值："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2020-01-01   -2.000000\n",
       "2020-01-11   -3.166667\n",
       "2020-01-21   -3.625000\n",
       "2020-01-31   -4.000000\n",
       "2020-02-10   -0.375000\n",
       "Freq: 10D, dtype: float64"
      ]
     },
     "execution_count": 202,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.resample('10D').mean().head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "同时，如果没有内置定义的处理函数，可以通过`apply`方法自定义："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2020-01-01    3\n",
       "2020-01-11    4\n",
       "2020-01-21    4\n",
       "2020-01-31    2\n",
       "2020-02-10    4\n",
       "Freq: 10D, dtype: int32"
      ]
     },
     "execution_count": 203,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.resample('10D').apply(lambda x:x.max()-x.min()).head() # 极差"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在`resample`中要特别注意组边界值的处理情况，默认情况下起始值的计算方法是从最小值时间戳对应日期的午夜`00:00:00`开始增加`freq`，直到不超过该最小时间戳的最大时间戳，由此对应的时间戳为起始值，然后每次累加`freq`参数作为分割结点进行分组，区间情况为左闭右开。下面构造一个不均匀的例子："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2020-01-01 08:26:35   -1\n",
       "2020-01-01 08:27:52   -1\n",
       "2020-01-01 08:29:09   -2\n",
       "2020-01-01 08:30:26   -3\n",
       "2020-01-01 08:31:43   -4\n",
       "Freq: 77S, dtype: int32"
      ]
     },
     "execution_count": 204,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "idx = pd.date_range('20200101 8:26:35', '20200101 9:31:58', freq='77s')\n",
    "data = np.random.randint(-1,2,len(idx)).cumsum()\n",
    "s = pd.Series(data,index=idx)\n",
    "s.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "下面对应的第一个组起始值为`08:24:00`，其是从当天0点增加72个`freq=7 min`得到的，如果再增加一个`freq`则超出了序列的最小时间戳`08:26:35`："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2020-01-01 08:24:00   -1.750000\n",
       "2020-01-01 08:31:00   -2.600000\n",
       "2020-01-01 08:38:00   -2.166667\n",
       "2020-01-01 08:45:00    0.200000\n",
       "2020-01-01 08:52:00    2.833333\n",
       "Freq: 7T, dtype: float64"
      ]
     },
     "execution_count": 205,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.resample('7min').mean().head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "有时候，用户希望从序列的最小时间戳开始依次增加`freq`进行分组，此时可以指定`origin`参数为`start`："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2020-01-01 08:26:35   -2.333333\n",
       "2020-01-01 08:33:35   -2.400000\n",
       "2020-01-01 08:40:35   -1.333333\n",
       "2020-01-01 08:47:35    1.200000\n",
       "2020-01-01 08:54:35    3.166667\n",
       "Freq: 7T, dtype: float64"
      ]
     },
     "execution_count": 206,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.resample('7min', origin='start').mean().head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在返回值中，要注意索引一般是取组的第一个时间戳，但`M, A, Q, BM, BA, BQ, W`这七个是取对应区间的最后一个时间戳："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2020-01-31    0.451613\n",
       "2020-02-29    0.448276\n",
       "2020-03-31    0.516129\n",
       "2020-04-30    0.566667\n",
       "2020-05-31    0.451613\n",
       "Freq: M, dtype: float64"
      ]
     },
     "execution_count": 207,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = pd.Series(np.random.randint(2,size=366), index=pd.date_range('2020-01-01', '2020-12-31'))\n",
    "s.resample('M').mean().head()#月末"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2020-01-01    0.451613\n",
       "2020-02-01    0.448276\n",
       "2020-03-01    0.516129\n",
       "2020-04-01    0.566667\n",
       "2020-05-01    0.451613\n",
       "Freq: MS, dtype: float64"
      ]
     },
     "execution_count": 208,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.resample('MS').mean().head() # 结果一样，但索引不同"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 六、练习\n",
    "### Ex1：太阳辐射数据集\n",
    "\n",
    "现有一份关于太阳辐射的数据集："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Data</th>\n",
       "      <th>Time</th>\n",
       "      <th>Radiation</th>\n",
       "      <th>Temperature</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>9/29/2016 12:00:00 AM</td>\n",
       "      <td>23:55:26</td>\n",
       "      <td>1.21</td>\n",
       "      <td>48</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>9/29/2016 12:00:00 AM</td>\n",
       "      <td>23:50:23</td>\n",
       "      <td>1.21</td>\n",
       "      <td>48</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>9/29/2016 12:00:00 AM</td>\n",
       "      <td>23:45:26</td>\n",
       "      <td>1.23</td>\n",
       "      <td>48</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                    Data      Time  Radiation  Temperature\n",
       "0  9/29/2016 12:00:00 AM  23:55:26       1.21           48\n",
       "1  9/29/2016 12:00:00 AM  23:50:23       1.21           48\n",
       "2  9/29/2016 12:00:00 AM  23:45:26       1.23           48"
      ]
     },
     "execution_count": 209,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.read_csv('C:\\datawhale\\joyful-pandas-master\\data\\solar.csv', usecols=['Data','Time','Radiation','Temperature'])\n",
    "df.head(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. 将`Datetime, Time`合并为一个时间列`Datetime`，同时把它作为索引后排序。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {},
   "outputs": [],
   "source": [
    "solar_date = df.Data.str.extract('([/|\\w]+\\s).+')[0]#取出日期\n",
    "df['Data'] = pd.to_datetime(solar_date + df.Time)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = df.drop(columns='Time').rename(columns={'Data':'Datetime'}).set_index('Datetime').sort_index()#将time列删除，将data名字改名为datatime令其为索引并根据索引排序"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Radiation</th>\n",
       "      <th>Temperature</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Datetime</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2016-09-01 00:00:08</th>\n",
       "      <td>2.58</td>\n",
       "      <td>51</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2016-09-01 00:05:10</th>\n",
       "      <td>2.83</td>\n",
       "      <td>51</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2016-09-01 00:20:06</th>\n",
       "      <td>2.16</td>\n",
       "      <td>51</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                     Radiation  Temperature\n",
       "Datetime                                   \n",
       "2016-09-01 00:00:08       2.58           51\n",
       "2016-09-01 00:05:10       2.83           51\n",
       "2016-09-01 00:20:06       2.16           51"
      ]
     },
     "execution_count": 216,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. 每条记录时间的间隔显然并不一致，请解决如下问题：\n",
    "* 找出间隔时间的前三个最大值所对应的三组时间戳。\n",
    "* 是否存在一个大致的范围，使得绝大多数的间隔时间都落在这个区间中？如果存在，请对此范围内的样本间隔秒数画出柱状图，设置`bins=50`。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Int64Index([25923, 24522, 7417], dtype='int64')"
      ]
     },
     "execution_count": 217,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = df.index.to_series().reset_index(drop=True).diff().dt.total_seconds()#将索引转化成序列做差查看delta的秒数\n",
    "max_3 = s.nlargest(3).index#s最大的三个值的索引"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2016-09-29 23:55:26', '2016-10-01 00:00:19',\n",
       "               '2016-11-29 19:05:02', '2016-12-01 00:00:02',\n",
       "               '2016-12-05 20:45:53', '2016-12-08 11:10:42'],\n",
       "              dtype='datetime64[ns]', name='Datetime', freq=None)"
      ]
     },
     "execution_count": 219,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.index[max_3.union(max_3-1)]#三组时间戳"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "res = s.mask((s>s.quantile(0.99))|(s<s.quantile(0.01)))#s的大部分区间0.01到0.99\n",
    "_=plt.hist(res, bins=50)#画时间间隔秒数的柱状图"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. 求如下指标对应的`Series`：\n",
    "* 温度与辐射量的6小时滑动相关系数\n",
    "* 以三点、九点、十五点、二十一点为分割，该观测所在时间区间的温度均值序列\n",
    "* 每个观测6小时前的辐射量（一般而言不会恰好取到，此时取最近时间戳对应的辐射量）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Datetime\n",
       "2016-12-31 23:45:04    0.328574\n",
       "2016-12-31 23:50:03    0.261883\n",
       "2016-12-31 23:55:01    0.262406\n",
       "dtype: float64"
      ]
     },
     "execution_count": 225,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res = df.Radiation.rolling('6H').corr(df.Temperature)\n",
    "res.tail(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Datetime\n",
       "2016-08-31 21:00:00    51.218750\n",
       "2016-09-01 03:00:00    50.033333\n",
       "2016-09-01 09:00:00    59.379310\n",
       "Freq: 6H, Name: Temperature, dtype: float64"
      ]
     },
     "execution_count": 226,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res = df.Temperature.resample('6H', origin='03:00:00').mean()#6h\n",
    "res.head(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Datetime\n",
       "2016-09-01 00:00:08    2.58\n",
       "2016-09-01 00:00:08    2.58\n",
       "2016-09-01 00:00:08    2.58\n",
       "Name: Radiation, dtype: float64"
      ]
     },
     "execution_count": 228,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dt = df.index.shift(freq='-6H')#向前6h的索引\n",
    "int_loc = [df.index.get_loc(i, method='nearest') for i in my_dt]#得到最近的索引\n",
    "res = df.Radiation.iloc[int_loc]\n",
    "res.head(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ex2：水果销量数据集\n",
    "\n",
    "现有一份2019年每日水果销量记录表："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Date</th>\n",
       "      <th>Fruit</th>\n",
       "      <th>Sale</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2019-04-18</td>\n",
       "      <td>Peach</td>\n",
       "      <td>15</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2019-12-29</td>\n",
       "      <td>Peach</td>\n",
       "      <td>15</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2019-06-05</td>\n",
       "      <td>Peach</td>\n",
       "      <td>19</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         Date  Fruit  Sale\n",
       "0  2019-04-18  Peach    15\n",
       "1  2019-12-29  Peach    15\n",
       "2  2019-06-05  Peach    19"
      ]
     },
     "execution_count": 230,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.read_csv('C:\\\\datawhale\\\\joyful-pandas-master\\\\data\\\\fruit.csv')\n",
    "df.head(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. 统计如下指标：\n",
    "* 每月上半月（15号及之前）与下半月葡萄销量的比值\n",
    "* 每月最后一天的生梨销量总和\n",
    "* 每月最后一天工作日的生梨销量总和\n",
    "* 每月最后五天的苹果销量均值"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>First</th>\n",
       "      <th>Second</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Date</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>66.349462</td>\n",
       "      <td>56.467742</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>59.447059</td>\n",
       "      <td>61.355828</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>57.502890</td>\n",
       "      <td>60.443396</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          First     Second\n",
       "Date                      \n",
       "1     66.349462  56.467742\n",
       "2     59.447059  61.355828\n",
       "3     57.502890  60.443396"
      ]
     },
     "execution_count": 238,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.Date = pd.to_datetime(df.Date)#将date转化为datetime\n",
    "df_grape = df.query(\"Fruit == 'Grape'\")#取出葡萄\n",
    "res = df_grape.groupby([np.where(df_grape.Date.dt.day<=15,'First', 'Second'),df_grape.Date.dt.month])['Sale'].mean().to_frame().unstack(0).droplevel(0,axis=1)\n",
    "#分组有两个条件，第一个依据天数小于大于15分为first与second，第二个依据月份\n",
    "res.head(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Month\n",
       "1    1.174998\n",
       "2    0.968890\n",
       "3    0.951351\n",
       "dtype: float64"
      ]
     },
     "execution_count": 239,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res = (res.First/res.Second).rename_axis('Month')\n",
    "res.head(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 240,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Date\n",
       "2019-01-31    847\n",
       "2019-02-28    774\n",
       "2019-03-31    761\n",
       "2019-04-30    648\n",
       "2019-05-31    616\n",
       "Name: Sale, dtype: int64"
      ]
     },
     "execution_count": 240,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[df.Date.dt.is_month_end].query(\"Fruit == 'Pear'\").groupby('Date').Sale.sum().head()#月末，梨子销量"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 242,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Date\n",
       "2019-01-31    847\n",
       "2019-02-28    774\n",
       "2019-03-29    510\n",
       "2019-04-30    648\n",
       "2019-05-31    616\n",
       "Name: Sale, dtype: int64"
      ]
     },
     "execution_count": 242,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[df.Date.isin(pd.date_range('20190101', '20191231',freq='BM'))].query(\"Fruit == 'Pear'\").groupby('Date').Sale.sum().head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 246,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Month\n",
       "1    65.313725\n",
       "2    54.061538\n",
       "3    59.325581\n",
       "Name: Sale, dtype: float64"
      ]
     },
     "execution_count": 246,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "target_dt = df.drop_duplicates().groupby(df.Date.drop_duplicates().dt.month)['Date'].nlargest(5).reset_index(drop=True)#取出每个月最后五天\n",
    "res = df.set_index('Date').loc[target_dt].reset_index().query(\"Fruit == 'Apple'\")#取出苹果\n",
    "res = res.groupby(res.Date.dt.month)['Sale'].mean().rename_axis('Month')#根据每个月分类\n",
    "res.head(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. 按月计算周一至周日各品种水果的平均记录条数，行索引外层为水果名称，内层为月份，列索引为星期。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 251,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0       April\n",
       "1    December\n",
       "Name: Date, dtype: category\n",
       "Categories (12, object): ['January' < 'February' < 'March' < 'April' ... 'September' < 'October' < 'November' < 'December']"
      ]
     },
     "execution_count": 251,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "month_order = ['January','February','March','April','May','June','July','August','September','October','November','December']\n",
    "week_order = ['Mon','Tue','Wed','Thu','Fri','Sat','Sun']\n",
    "group1 = df.Date.dt.month_name().astype('category').cat.reorder_categories(month_order, ordered=True)#月名字转化成类别对象\n",
    "group1.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 252,
   "metadata": {},
   "outputs": [],
   "source": [
    "group2 = df.Fruit\n",
    "group3 = df.Date.dt.dayofweek.replace(dict(zip(range(7),week_order))).astype('category').cat.reorder_categories(week_order, ordered=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Date</th>\n",
       "      <th>January</th>\n",
       "      <th>February</th>\n",
       "      <th>March</th>\n",
       "      <th>April</th>\n",
       "      <th>May</th>\n",
       "      <th>June</th>\n",
       "      <th>July</th>\n",
       "      <th>August</th>\n",
       "      <th>September</th>\n",
       "      <th>October</th>\n",
       "      <th>November</th>\n",
       "      <th>December</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Fruit</th>\n",
       "      <th>Date</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"5\" valign=\"top\">Apple</th>\n",
       "      <th>Mon</th>\n",
       "      <td>46</td>\n",
       "      <td>43</td>\n",
       "      <td>43</td>\n",
       "      <td>47</td>\n",
       "      <td>43</td>\n",
       "      <td>40</td>\n",
       "      <td>41</td>\n",
       "      <td>38</td>\n",
       "      <td>59</td>\n",
       "      <td>42</td>\n",
       "      <td>39</td>\n",
       "      <td>45</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tue</th>\n",
       "      <td>50</td>\n",
       "      <td>40</td>\n",
       "      <td>44</td>\n",
       "      <td>52</td>\n",
       "      <td>46</td>\n",
       "      <td>39</td>\n",
       "      <td>50</td>\n",
       "      <td>42</td>\n",
       "      <td>40</td>\n",
       "      <td>57</td>\n",
       "      <td>47</td>\n",
       "      <td>47</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Wed</th>\n",
       "      <td>50</td>\n",
       "      <td>47</td>\n",
       "      <td>37</td>\n",
       "      <td>43</td>\n",
       "      <td>39</td>\n",
       "      <td>39</td>\n",
       "      <td>58</td>\n",
       "      <td>43</td>\n",
       "      <td>35</td>\n",
       "      <td>46</td>\n",
       "      <td>47</td>\n",
       "      <td>38</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Thu</th>\n",
       "      <td>45</td>\n",
       "      <td>35</td>\n",
       "      <td>31</td>\n",
       "      <td>47</td>\n",
       "      <td>58</td>\n",
       "      <td>33</td>\n",
       "      <td>52</td>\n",
       "      <td>44</td>\n",
       "      <td>36</td>\n",
       "      <td>63</td>\n",
       "      <td>37</td>\n",
       "      <td>40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Fri</th>\n",
       "      <td>32</td>\n",
       "      <td>33</td>\n",
       "      <td>52</td>\n",
       "      <td>31</td>\n",
       "      <td>46</td>\n",
       "      <td>38</td>\n",
       "      <td>37</td>\n",
       "      <td>48</td>\n",
       "      <td>34</td>\n",
       "      <td>37</td>\n",
       "      <td>46</td>\n",
       "      <td>41</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Date        January  February  March  April  May  June  July  August  \\\n",
       "Fruit Date                                                             \n",
       "Apple Mon        46        43     43     47   43    40    41      38   \n",
       "      Tue        50        40     44     52   46    39    50      42   \n",
       "      Wed        50        47     37     43   39    39    58      43   \n",
       "      Thu        45        35     31     47   58    33    52      44   \n",
       "      Fri        32        33     52     31   46    38    37      48   \n",
       "\n",
       "Date        September  October  November  December  \n",
       "Fruit Date                                          \n",
       "Apple Mon          59       42        39        45  \n",
       "      Tue          40       57        47        47  \n",
       "      Wed          35       46        47        38  \n",
       "      Thu          36       63        37        40  \n",
       "      Fri          34       37        46        41  "
      ]
     },
     "execution_count": 255,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res = df.groupby([group1, group2,group3])['Sale'].count().to_frame().unstack(0).droplevel(0,axis=1)#删除0列索引\n",
    "res.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. 按天计算向前10个工作日窗口的苹果销量均值序列，非工作日的值用上一个工作日的结果填充。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 258,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2019-01-01    189.000000\n",
       "2019-01-02    335.500000\n",
       "2019-01-03    520.333333\n",
       "2019-01-04    527.750000\n",
       "2019-01-05    527.750000\n",
       "Freq: D, dtype: float64"
      ]
     },
     "execution_count": 258,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_apple = df[(df.Fruit=='Apple')&(~df.Date.dt.dayofweek.isin([5,6]))]#工作日的苹果\n",
    "s = pd.Series(df_apple.Sale.values,index=df_apple.Date).groupby('Date').sum()\n",
    "res = s.rolling('10D').mean().reindex(pd.date_range('20190101','20191231')).fillna(method='ffill')#滑动平均后填充非工作日\n",
    "res.head()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}