第7章 文本数据.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 第7章 文本数据"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![mindmap](https://github.com/elsieyin/joyful-pandas/blob/master/picture/c7.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-28T02:56:45.356939Z",
     "start_time": "2020-06-28T02:56:45.210526Z"
    }
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 一、string类型的性质"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. string与object的区别\n",
    "#### string类型和object不同之处有三：\n",
    "#### ① 字符存取方法（string accessor methods，如str.count）会返回相应数据的Nullable类型，而object会随缺失值的存在而改变返回类型\n",
    "#### ② 某些Series方法不能在string上使用，例如： Series.str.decode()，因为存储的是字符串而不是字节\n",
    "#### ③ string类型在缺失值存储或运算时，类型会广播为pd.NA，而不是浮点型np.nan\n",
    "#### 其余全部内容在当前版本下完全一致，但迎合Pandas的发展模式，我们仍然全部用string来操作字符串"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. string类型的转换\n",
    "#### 如果将一个其他类型的容器直接转换string类型可能会出错："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:58.759588Z",
     "start_time": "2020-06-26T00:55:58.739810Z"
    }
   },
   "outputs": [],
   "source": [
    "#pd.Series([1,'1.']).astype('string') #报错\n",
    "#pd.Series([1,2]).astype('string') #报错\n",
    "#pd.Series([True,False]).astype('string') #报错"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 当下正确的方法是分两部转换，先转为str型object，在转为string类型："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:58.783256Z",
     "start_time": "2020-06-26T00:55:58.760587Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0     1\n",
       "1    1.\n",
       "dtype: string"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series([1,'1.']).astype('str').astype('string')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:58.798627Z",
     "start_time": "2020-06-26T00:55:58.784257Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    1\n",
       "1    2\n",
       "dtype: string"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series([1,2]).astype('str').astype('string')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:58.809892Z",
     "start_time": "2020-06-26T00:55:58.798627Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0     True\n",
       "1    False\n",
       "dtype: string"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series([True,False]).astype('str').astype('string')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 二、拆分与拼接"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. str.split方法\n",
    "#### （a）分割符与str的位置元素选取"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:58.825597Z",
     "start_time": "2020-06-26T00:55:58.809892Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    a_b_c\n",
       "1    c_d_e\n",
       "2     <NA>\n",
       "3    f_g_h\n",
       "dtype: string"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = pd.Series(['a_b_c', 'c_d_e', np.nan, 'f_g_h'], dtype=\"string\")\n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 根据某一个元素分割，默认为空格"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:58.841612Z",
     "start_time": "2020-06-26T00:55:58.826599Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    [a, b, c]\n",
       "1    [c, d, e]\n",
       "2         <NA>\n",
       "3    [f, g, h]\n",
       "dtype: object"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.str.split('_')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 这里需要注意split后的类型是object，因为现在Series中的元素已经不是string，而包含了list，且string类型只能含有字符串"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 对于str方法可以进行元素的选择，如果该单元格元素是列表，那么str[i]表示取出第i个元素，如果是单个元素，则先把元素转为列表在取出"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:58.857626Z",
     "start_time": "2020-06-26T00:55:58.842614Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0       b\n",
       "1       d\n",
       "2    <NA>\n",
       "3       g\n",
       "dtype: object"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.str.split('_').str[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:58.873640Z",
     "start_time": "2020-06-26T00:55:58.858628Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    _\n",
       "1    b\n",
       "dtype: object"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series(['a_b_c', ['a','b','c']], dtype=\"object\").str[1]\n",
    "#第一个元素先转为['a','_','b','_','c']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### （b）其他参数\n",
    "#### expand参数控制了是否将列拆开，n参数代表最多分割多少次"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:58.889655Z",
     "start_time": "2020-06-26T00:55:58.874642Z"
    }
   },
   "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>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>a</td>\n",
       "      <td>b</td>\n",
       "      <td>c</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>c</td>\n",
       "      <td>d</td>\n",
       "      <td>e</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>&lt;NA&gt;</td>\n",
       "      <td>&lt;NA&gt;</td>\n",
       "      <td>&lt;NA&gt;</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>f</td>\n",
       "      <td>g</td>\n",
       "      <td>h</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      0     1     2\n",
       "0     a     b     c\n",
       "1     c     d     e\n",
       "2  <NA>  <NA>  <NA>\n",
       "3     f     g     h"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.str.split('_',expand=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:58.905009Z",
     "start_time": "2020-06-26T00:55:58.890657Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    [a, b_c]\n",
       "1    [c, d_e]\n",
       "2        <NA>\n",
       "3    [f, g_h]\n",
       "dtype: object"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.str.split('_',n=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:58.921024Z",
     "start_time": "2020-06-26T00:55:58.906011Z"
    }
   },
   "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>0</th>\n",
       "      <th>1</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>a</td>\n",
       "      <td>b_c</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>c</td>\n",
       "      <td>d_e</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>&lt;NA&gt;</td>\n",
       "      <td>&lt;NA&gt;</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>f</td>\n",
       "      <td>g_h</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      0     1\n",
       "0     a   b_c\n",
       "1     c   d_e\n",
       "2  <NA>  <NA>\n",
       "3     f   g_h"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.str.split('_',expand=True,n=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. str.cat方法\n",
    "#### （a）不同对象的拼接模式\n",
    "#### cat方法对于不同对象的作用结果并不相同，其中的对象包括：单列、双列、多列\n",
    "#### ① 对于单个Series而言，就是指所有的元素进行字符合并为一个字符串"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:58.937038Z",
     "start_time": "2020-06-26T00:55:58.921024Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0      ab\n",
       "1    <NA>\n",
       "2       d\n",
       "dtype: string"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = pd.Series(['ab',None,'d'],dtype='string')\n",
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:58.953055Z",
     "start_time": "2020-06-26T00:55:58.938040Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abd'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.str.cat()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 其中可选sep分隔符参数，和缺失值替代字符na_rep参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:58.969069Z",
     "start_time": "2020-06-26T00:55:58.953055Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ab,d'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.str.cat(sep=',')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:58.980964Z",
     "start_time": "2020-06-26T00:55:58.970070Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ab,*,d'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.str.cat(sep=',',na_rep='*') # 大概是replace的意思"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### ② 对于两个Series合并而言，是对应索引的元素进行合并"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:58.996362Z",
     "start_time": "2020-06-26T00:55:58.981330Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0      24\n",
       "1    <NA>\n",
       "2    <NA>\n",
       "dtype: string"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s2 = pd.Series(['24',None,None],dtype='string')\n",
    "s2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:59.012177Z",
     "start_time": "2020-06-26T00:55:58.996362Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    ab24\n",
       "1    <NA>\n",
       "2    <NA>\n",
       "dtype: string"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.str.cat(s2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 同样也有相应参数，需要注意的是两个缺失值会被同时替换"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:59.029760Z",
     "start_time": "2020-06-26T00:55:59.012177Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    ab,24\n",
       "1      *,*\n",
       "2      d,*\n",
       "dtype: string"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.str.cat(s2,sep=',',na_rep='*') # *,*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### ③ 多列拼接可以分为表的拼接和多Series拼接"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 表的拼接"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:59.045774Z",
     "start_time": "2020-06-26T00:55:59.030761Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    ab15\n",
       "1     *3b\n",
       "2     d5*\n",
       "dtype: string"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.str.cat(pd.DataFrame({0:['1','3','5'],1:['5','b',None]},dtype='string'),na_rep='*') #不管怎样都会拼一起"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 多个Series拼接"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:59.064431Z",
     "start_time": "2020-06-26T00:55:59.046776Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    abab0\n",
       "1     <NA>\n",
       "2      dd0\n",
       "dtype: string"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.str.cat([s+'0'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:59.079934Z",
     "start_time": "2020-06-26T00:55:59.066924Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    abab0abab\n",
       "1         <NA>\n",
       "2        dd0dd\n",
       "dtype: string"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.str.cat([s+'0',s*2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### （b）cat中的索引对齐\n",
    "#### 当前版本中，如果两边合并的索引不相同且未指定join参数，默认为左连接，设置join='left'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:59.095527Z",
     "start_time": "2020-06-26T00:55:59.081516Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1    a\n",
       "2    b\n",
       "3    c\n",
       "dtype: string"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s2 = pd.Series(list('abc'),index=[1,2,3],dtype='string')\n",
    "s2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:59.111186Z",
     "start_time": "2020-06-26T00:55:59.096528Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    ab*\n",
       "1     *a\n",
       "2     db\n",
       "dtype: string"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.str.cat(s2,na_rep='*') # C因为index=3 rep成*了"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 三、替换\n",
    "#### 广义上的替换，就是指str.replace函数的应用，fillna是针对缺失值的替换，上一章已经提及\n",
    "#### 提到替换，就不可避免地接触到正则表达式，这里默认读者已掌握常见正则表达式知识点，若对其还不了解的，可以通过[这份资料](https://regexone.com/)来熟悉"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. str.replace的常见用法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T12:02:46.433988Z",
     "start_time": "2020-06-26T12:02:46.423979Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0       A\n",
       "1       B\n",
       "2       C\n",
       "3    Aaba\n",
       "4    Baca\n",
       "5        \n",
       "6    <NA>\n",
       "7    CABA\n",
       "8     dog\n",
       "9     cat\n",
       "dtype: string"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = pd.Series(['A', 'B', 'C', 'Aaba', 'Baca','', np.nan, 'CABA', 'dog', 'cat'],dtype=\"string\")\n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 第一个值写r开头的正则表达式，后一个写替换的字符串"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T12:07:25.359671Z",
     "start_time": "2020-06-26T12:07:25.352143Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0       ***\n",
       "1       ***\n",
       "2         C\n",
       "3    ***aba\n",
       "4    ***aca\n",
       "5          \n",
       "6      <NA>\n",
       "7      CABA\n",
       "8       dog\n",
       "9       cat\n",
       "dtype: string"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.str.replace(r'^[AB]','***')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T12:07:30.990381Z",
     "start_time": "2020-06-26T12:07:30.980869Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0       A\n",
       "1       B\n",
       "2       C\n",
       "3    Aaba\n",
       "4    Baca\n",
       "5        \n",
       "6    <NA>\n",
       "7    CABA\n",
       "8     dog\n",
       "9     cat\n",
       "dtype: string"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s # replace不修改"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. 子组与函数替换"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 通过正整数调用子组（0返回字符本身，从1开始才是子组）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:59.157397Z",
     "start_time": "2020-06-26T00:55:59.143385Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0       A\n",
       "1       B\n",
       "2       C\n",
       "3     ba*\n",
       "4     ca*\n",
       "5        \n",
       "6    <NA>\n",
       "7     BA*\n",
       "8     dog\n",
       "9     cat\n",
       "dtype: string"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.str.replace(r'([ABC])(\\w+)',lambda x:x.group(2)[1:]+'*')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "group(2)就是取出来你第二个小括号匹配的字符串\n",
    "x.group(0) 返回的是单元格内的字符串本身, x.group(1)返回的是匹配到的第一个子组,   \n",
    "2 是第二个子组(如果正则表达式设置了子组匹配的第二个子组)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 利用?P<....>表达式可以对子组命名调用"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:59.173411Z",
     "start_time": "2020-06-26T00:55:59.158399Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0       A\n",
       "1       B\n",
       "2       C\n",
       "3     ba*\n",
       "4     ca*\n",
       "5        \n",
       "6    <NA>\n",
       "7     BA*\n",
       "8     dog\n",
       "9     cat\n",
       "dtype: string"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.str.replace(r'(?P<one>[ABC])(?P<two>\\w+)',lambda x:x.group('two')[1:]+'*')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. 关于str.replace的注意事项\n",
    "#### 首先，要明确str.replace和replace并不是一个东西：\n",
    "#### str.replace针对的是object类型或string类型，默认是以正则表达式为操作，目前暂时不支持DataFrame上使用\n",
    "#### replace针对的是任意类型的序列或数据框，如果要以正则表达式替换，需要设置regex=True，该方法通过字典可支持多列替换\n",
    "#### 但现在由于string类型的初步引入，用法上出现了一些问题，这些issue有望在以后的版本中修复\n",
    "#### （a）str.replace赋值参数不得为pd.NA\n",
    "#### 这听上去非常不合理，例如对满足某些正则条件的字符串替换为缺失值，直接更改为缺失值在当下版本就会报错"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:59.189426Z",
     "start_time": "2020-06-26T00:55:59.174413Z"
    }
   },
   "outputs": [],
   "source": [
    "#pd.Series(['A','B'],dtype='string').str.replace(r'[A]',pd.NA) #报错\n",
    "#pd.Series(['A','B'],dtype='O').str.replace(r'[A]',pd.NA) #报错"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 此时，可以先转为object类型再转换回来，曲线救国："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:59.205440Z",
     "start_time": "2020-06-26T00:55:59.190427Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    <NA>\n",
       "1       B\n",
       "dtype: string"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series(['A','B'],dtype='string').astype('O').replace(r'[A]',pd.NA,regex=True).astype('string')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 至于为什么不用replace函数的regex替换（但string类型replace的非正则替换是可以的），原因在下面一条"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### （b）对于string类型Series，在使用replace函数时不能使用正则表达式替换\n",
    "#### 该bug现在还未修复"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:59.221454Z",
     "start_time": "2020-06-26T00:55:59.206441Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    A\n",
       "1    B\n",
       "dtype: string"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series(['A','B'],dtype='string').replace(r'[A]','C',regex=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:59.231285Z",
     "start_time": "2020-06-26T00:55:59.222456Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    C\n",
       "1    B\n",
       "dtype: object"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series(['A','B'],dtype='O').replace(r'[A]','C',regex=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### （c）string类型序列如果存在缺失值，不能使用replace替换"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:59.246674Z",
     "start_time": "2020-06-26T00:55:59.231662Z"
    }
   },
   "outputs": [],
   "source": [
    "#pd.Series(['A',np.nan],dtype='string').replace('A','B') #报错"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:59.262688Z",
     "start_time": "2020-06-26T00:55:59.246674Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0       B\n",
       "1    <NA>\n",
       "dtype: string"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series(['A',np.nan],dtype='string').str.replace('A','B')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 综上，概况的说，除非需要赋值元素为缺失值（转为object再转回来），否则请使用str.replace方法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 四、子串匹配与提取"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. str.extract方法\n",
    "#### （a）常见用法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:59.278703Z",
     "start_time": "2020-06-26T00:55:59.263690Z"
    }
   },
   "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>0</th>\n",
       "      <th>1</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>10</td>\n",
       "      <td>87</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>10</td>\n",
       "      <td>88</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>10</td>\n",
       "      <td>89</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    0   1\n",
       "0  10  87\n",
       "1  10  88\n",
       "2  10  89"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series(['10-87', '10-88', '10-89'],dtype=\"string\").str.extract(r'([\\d]{2})-([\\d]{2})')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 使用子组名作为列名"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:59.294717Z",
     "start_time": "2020-06-26T00:55:59.279705Z"
    }
   },
   "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>name_1</th>\n",
       "      <th>name_2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>10</td>\n",
       "      <td>87</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>10</td>\n",
       "      <td>88</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>&lt;NA&gt;</td>\n",
       "      <td>&lt;NA&gt;</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  name_1 name_2\n",
       "0     10     87\n",
       "1     10     88\n",
       "2   <NA>   <NA>"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series(['10-87', '10-88', '-89'],dtype=\"string\").str.extract(r'(?P<name_1>[\\d]{2})-(?P<name_2>[\\d]{2})')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 利用?正则标记选择部分提取"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:59.310731Z",
     "start_time": "2020-06-26T00:55:59.295719Z"
    }
   },
   "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>name_1</th>\n",
       "      <th>name_2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>10</td>\n",
       "      <td>87</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>10</td>\n",
       "      <td>88</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>&lt;NA&gt;</td>\n",
       "      <td>89</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  name_1 name_2\n",
       "0     10     87\n",
       "1     10     88\n",
       "2   <NA>     89"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series(['10-87', '10-88', '-89'],dtype=\"string\").str.extract(r'(?P<name_1>[\\d]{2})?-(?P<name_2>[\\d]{2})')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:59.326746Z",
     "start_time": "2020-06-26T00:55:59.311733Z"
    }
   },
   "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>name_1</th>\n",
       "      <th>name_2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>10</td>\n",
       "      <td>87</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>10</td>\n",
       "      <td>88</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>10</td>\n",
       "      <td>&lt;NA&gt;</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  name_1 name_2\n",
       "0     10     87\n",
       "1     10     88\n",
       "2     10   <NA>"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series(['10-87', '10-88', '10-'],dtype=\"string\").str.extract(r'(?P<name_1>[\\d]{2})-(?P<name_2>[\\d]{2})?')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### （b）expand参数（默认为True）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 对于一个子组的Series，如果expand设置为False，则返回Series，若大于一个子组，则expand参数无效，全部返回DataFrame\n",
    "#### 对于一个子组的Index，如果expand设置为False，则返回提取后的Index，若大于一个子组且expand为False，报错"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:59.342734Z",
     "start_time": "2020-06-26T00:55:59.327747Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['A11', 'B22', 'C33'], dtype='object')"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = pd.Series([\"a1\", \"b2\", \"c3\"], [\"A11\", \"B22\", \"C33\"], dtype=\"string\")\n",
    "s.index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:59.358748Z",
     "start_time": "2020-06-26T00:55:59.343736Z"
    }
   },
   "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>0</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>A11</th>\n",
       "      <td>a</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>B22</th>\n",
       "      <td>b</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>C33</th>\n",
       "      <td>c</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     0\n",
       "A11  a\n",
       "B22  b\n",
       "C33  c"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.str.extract(r'([\\w])') # 对于一个子组的Series，expand默认为True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:59.374763Z",
     "start_time": "2020-06-26T00:55:59.359750Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "A11    a\n",
       "B22    b\n",
       "C33    c\n",
       "dtype: string"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.str.extract(r'([\\w])',expand=False) #对于一个子组的Series，如果expand设置为False，则返回Series"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:59.390777Z",
     "start_time": "2020-06-26T00:55:59.375764Z"
    }
   },
   "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>0</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>A</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>B</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>C</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   0\n",
       "0  A\n",
       "1  B\n",
       "2  C"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.index.str.extract(r'([\\w])') #对于一个子组的Index，expand默认为True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:59.406791Z",
     "start_time": "2020-06-26T00:55:59.391778Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['A', 'B', 'C'], dtype='object')"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.index.str.extract(r'([\\w])',expand=False) #对于一个子组的Index，如果expand设置为False，则返回提取后的Index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:59.422806Z",
     "start_time": "2020-06-26T00:55:59.407793Z"
    }
   },
   "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>0</th>\n",
       "      <th>1</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>A</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>B</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>C</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   0  1\n",
       "0  A  1\n",
       "1  B  2\n",
       "2  C  3"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.index.str.extract(r'([\\w])([\\d])')  #对于一个子组的Index，expand默认为True，取了两列"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:59.438820Z",
     "start_time": "2020-06-26T00:55:59.423807Z"
    }
   },
   "outputs": [],
   "source": [
    "#s.index.str.extract(r'([\\w])([\\d])',expand=False) #报错  大于一个子组且expand为False，报错"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. str.extractall方法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 与extract只匹配第一个符合条件的表达式不同，extractall会找出所有符合条件的字符串，并建立多级索引（即使只找到一个）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:59.454834Z",
     "start_time": "2020-06-26T00:55:59.439821Z"
    }
   },
   "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>letter</th>\n",
       "      <th>digit</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>A</th>\n",
       "      <td>a</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>B</th>\n",
       "      <td>b</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>C</th>\n",
       "      <td>c</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  letter digit\n",
       "A      a     1\n",
       "B      b     1\n",
       "C      c     1"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = pd.Series([\"a1a2\", \"b1\", \"c1\"], index=[\"A\", \"B\", \"C\"],dtype=\"string\")\n",
    "two_groups = '(?P<letter>[a-z])(?P<digit>[0-9])'\n",
    "s.str.extract(two_groups, expand=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:59.470848Z",
     "start_time": "2020-06-26T00:55:59.455836Z"
    }
   },
   "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></th>\n",
       "      <th>letter</th>\n",
       "      <th>digit</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th>match</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">A</th>\n",
       "      <th>0</th>\n",
       "      <td>a</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>a</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>B</th>\n",
       "      <th>0</th>\n",
       "      <td>b</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>C</th>\n",
       "      <th>0</th>\n",
       "      <td>c</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        letter digit\n",
       "  match             \n",
       "A 0          a     1\n",
       "  1          a     2\n",
       "B 0          b     1\n",
       "C 0          c     1"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.str.extractall(two_groups)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:59.486864Z",
     "start_time": "2020-06-26T00:55:59.471850Z"
    }
   },
   "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></th>\n",
       "      <th>letter</th>\n",
       "      <th>digit</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th>match</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>A</th>\n",
       "      <th>0</th>\n",
       "      <td>a</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>B</th>\n",
       "      <th>0</th>\n",
       "      <td>b</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>C</th>\n",
       "      <th>0</th>\n",
       "      <td>c</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        letter digit\n",
       "  match             \n",
       "A 0          a     1\n",
       "B 0          b     1\n",
       "C 0          c     1"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s['A']='a1'\n",
    "s.str.extractall(two_groups)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 如果想查看第i层匹配，可使用xs方法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:59.502475Z",
     "start_time": "2020-06-26T00:55:59.487865Z"
    }
   },
   "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>letter</th>\n",
       "      <th>digit</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>A</th>\n",
       "      <td>a</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>B</th>\n",
       "      <td>b</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>C</th>\n",
       "      <td>c</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  letter digit\n",
       "A      a     2\n",
       "B      b     2\n",
       "C      c     2"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = pd.Series([\"a1a2\", \"b1b2\", \"c1c2\"], index=[\"A\", \"B\", \"C\"],dtype=\"string\")\n",
    "s.str.extractall(two_groups).xs(1,level='match')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. str.contains和str.match\n",
    "#### 前者的作用为检测是否包含某种正则模式"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:59.518489Z",
     "start_time": "2020-06-26T00:55:59.503477Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    False\n",
       "1     <NA>\n",
       "2     True\n",
       "3     True\n",
       "4     True\n",
       "dtype: boolean"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series(['1', None, '3a', '3b', '03c'], dtype=\"string\").str.contains(r'[0-9][a-z]')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 可选参数为na"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:59.534504Z",
     "start_time": "2020-06-26T00:55:59.519492Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    False\n",
       "1    False\n",
       "2     True\n",
       "3    False\n",
       "4    False\n",
       "dtype: boolean"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series(['1', None, '3a', '3b', '03c'], dtype=\"string\").str.contains('a', na=False) #contains 有"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### str.match与其区别在于，match依赖于python的re.match，检测内容为是否从头开始包含该正则模式"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:59.550543Z",
     "start_time": "2020-06-26T00:55:59.535505Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    False\n",
       "1    False\n",
       "2     True\n",
       "3     True\n",
       "4    False\n",
       "dtype: boolean"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series(['1', None, '3a_', '3b', '03c'], dtype=\"string\").str.match(r'[0-9][a-z]',na=False) # match 严格"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:59.566221Z",
     "start_time": "2020-06-26T00:55:59.551545Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    False\n",
       "1    False\n",
       "2    False\n",
       "3     True\n",
       "4    False\n",
       "dtype: boolean"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series(['1', None, '_3a', '3b', '03c'], dtype=\"string\").str.match(r'[0-9][a-z]',na=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 五、常用字符串方法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. 过滤型方法\n",
    "#### （a）str.strip\n",
    "#### 常用于过滤空格"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:59.581903Z",
     "start_time": "2020-06-26T00:55:59.567222Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['space1', 'space2', 'space3'], dtype='object')"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series(list('abc'),index=[' space1  ','space2  ','  space3'],dtype=\"string\").index.str.strip()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### （b）str.lower和str.upper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:59.612655Z",
     "start_time": "2020-06-26T00:55:59.582903Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    a\n",
       "dtype: string"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series('A',dtype=\"string\").str.lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:59.628279Z",
     "start_time": "2020-06-26T00:55:59.613657Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    A\n",
       "dtype: string"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series('a',dtype=\"string\").str.upper()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### （c）str.swapcase和str.capitalize\n",
    "#### 分别表示交换字母大小写和大写首字母"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:59.643960Z",
     "start_time": "2020-06-26T00:55:59.629280Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    ABcd\n",
       "dtype: string"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series('abCD',dtype=\"string\").str.swapcase()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:59.659634Z",
     "start_time": "2020-06-26T00:55:59.644962Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    Abcd\n",
       "dtype: string"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series('abCD',dtype=\"string\").str.capitalize()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. isnumeric方法\n",
    "#### 检查每一位是否都是数字，请问如何判断是否是数值？（问题二）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:59.674648Z",
     "start_time": "2020-06-26T00:55:59.660636Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    False\n",
       "1     True\n",
       "2    False\n",
       "3    False\n",
       "4     <NA>\n",
       "dtype: boolean"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series(['1.2','1','-0.3','a',np.nan],dtype=\"string\").str.isnumeric() #.是字符，检查是否每一位都是数字。\n",
    "# Series.str.isnumeric : Check whether all characters are numeric.\n",
    "# https://github.com/pandas-dev/pandas/blob/v1.0.5/pandas/core/strings.py\n",
    "# 'isnumeric' L3367 3550"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 六、问题与练习\n",
    "### 1. 问题"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 【问题一】 str对象方法和df/Series对象方法有什么区别？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- str.replace针对的是object类型或string类型，默认是以正则表达式为操作，目前暂时不支持DataFrame上使用\n",
    "- replace针对的是任意类型的序列或数据框，如果要以正则表达式替换，需要设置regex=True，该方法通过字典可支持多列替换"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 【问题二】 给出一列string类型，如何判断单元格是否是数值型数据？\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`str.contains(r'-?([0-9]\\d*)(\\.\\d+)?$')`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 【问题三】 rsplit方法的作用是什么？它在什么场合下适用？\n",
    "方法通过指定分隔符对字符串进行分割并返回一个列表"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 【问题四】 在本章的第二到第四节分别介绍了字符串类型的5类操作，请思考它们各自应用于什么场景？\n",
    "- **拆分**:  某个字符串series里有相同的分隔符的时候，可以用split来分开。\n",
    "- **拼接**：理解为拆分的反操作，想用某个符号作为分隔符将几个字符串连起来的时候。\n",
    "- **替换**：在数据清洗的时候作用很大，可以使用正则表达式去除某些不需要的字符，数字之类的。\n",
    "- **字串匹配**：作用同下，但是不用提取出来，只是看里面有没有。contains是看有没有。\n",
    "- **字串提取**: 当字符串series有一定的规律的时候，可以用来提取某一部分，例如年月日可以提取年，就是提取自己需要的模式。extract是提取。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. 练习\n",
    "#### 【练习一】 现有一份关于字符串的数据集，请解决以下问题：\n",
    "#### （a）现对字符串编码存储人员信息（在编号后添加ID列），使用如下格式：“×××（名字）：×国人，性别×，生于×年×月×日”\n",
    "#### （b）将（a）中的人员生日信息部分修改为用中文表示（如一九七四年十月二十三日），其余返回格式不变。\n",
    "#### （c）将（b）中的ID列结果拆分为原列表相应的5列，并使用equals检验是否一致。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-01T03:34:29.254518Z",
     "start_time": "2020-07-01T03:34:29.078749Z"
    }
   },
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-01T03:35:03.873839Z",
     "start_time": "2020-07-01T03:35:03.845292Z"
    }
   },
   "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>姓名</th>\n",
       "      <th>国籍</th>\n",
       "      <th>性别</th>\n",
       "      <th>出生年</th>\n",
       "      <th>出生月</th>\n",
       "      <th>出生日</th>\n",
       "    </tr>\n",
       "    <tr>\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>1</th>\n",
       "      <td>aesfd</td>\n",
       "      <td>2</td>\n",
       "      <td>男</td>\n",
       "      <td>1942</td>\n",
       "      <td>8</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>fasefa</td>\n",
       "      <td>5</td>\n",
       "      <td>女</td>\n",
       "      <td>1985</td>\n",
       "      <td>10</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>aeagd</td>\n",
       "      <td>4</td>\n",
       "      <td>女</td>\n",
       "      <td>1946</td>\n",
       "      <td>10</td>\n",
       "      <td>15</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>aef</td>\n",
       "      <td>4</td>\n",
       "      <td>男</td>\n",
       "      <td>1999</td>\n",
       "      <td>5</td>\n",
       "      <td>13</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>eaf</td>\n",
       "      <td>1</td>\n",
       "      <td>女</td>\n",
       "      <td>2010</td>\n",
       "      <td>6</td>\n",
       "      <td>24</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          姓名 国籍 性别   出生年 出生月 出生日\n",
       "人员编号                            \n",
       "1      aesfd  2  男  1942   8  10\n",
       "2     fasefa  5  女  1985  10   4\n",
       "3      aeagd  4  女  1946  10  15\n",
       "4        aef  4  男  1999   5  13\n",
       "5        eaf  1  女  2010   6  24"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.read_csv('data/String_data_one.csv',index_col='人员编号').astype('str')\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-01T03:35:05.822504Z",
     "start_time": "2020-07-01T03:35:05.804966Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "Int64Index: 2000 entries, 1 to 2000\n",
      "Data columns (total 6 columns):\n",
      " #   Column  Non-Null Count  Dtype \n",
      "---  ------  --------------  ----- \n",
      " 0   姓名      2000 non-null   object\n",
      " 1   国籍      2000 non-null   object\n",
      " 2   性别      2000 non-null   object\n",
      " 3   出生年     2000 non-null   object\n",
      " 4   出生月     2000 non-null   object\n",
      " 5   出生日     2000 non-null   object\n",
      "dtypes: object(6)\n",
      "memory usage: 109.4+ KB\n"
     ]
    }
   ],
   "source": [
    "df.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "法1.读取的数据要是“str”类型否则直接“+”会报错，```astype('str')```   \n",
    "法2.读取后直接转`df=pd.read_csv('data.csv',index_col='人员编号', dtype='str')`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-01T03:42:22.493018Z",
     "start_time": "2020-07-01T03:42:22.488013Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "人员编号\n",
       "1         aesfd\n",
       "2        fasefa\n",
       "3         aeagd\n",
       "4           aef\n",
       "5           eaf\n",
       "         ...   \n",
       "1996        sdf\n",
       "1997         hx\n",
       "1998        drg\n",
       "1999    zfgzdrg\n",
       "2000       fsdf\n",
       "Name: 姓名, Length: 2000, dtype: object"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df['姓名']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-28T02:57:05.058939Z",
     "start_time": "2020-06-28T02:57:05.033909Z"
    }
   },
   "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>ID</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>人员编号</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>aesfd:2国人，性别男，生于1942年8月10日</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>fasefa:5国人，性别女，生于1985年10月4日</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>aeagd:4国人，性别女，生于1946年10月15日</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>aef:4国人，性别男，生于1999年5月13日</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>eaf:1国人，性别女，生于2010年6月24日</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                               ID\n",
       "人员编号                             \n",
       "1      aesfd:2国人，性别男，生于1942年8月10日\n",
       "2     fasefa:5国人，性别女，生于1985年10月4日\n",
       "3     aeagd:4国人，性别女，生于1946年10月15日\n",
       "4        aef:4国人，性别男，生于1999年5月13日\n",
       "5        eaf:1国人，性别女，生于2010年6月24日"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(df['姓名']+':'+df['国籍']+'国人，性别'\n",
    "          +df['性别']+'，生于'\n",
    "          +df['出生年']+'年'\n",
    "          +df['出生月']+'月'+df['出生日']+'日').to_frame().rename(columns={0:'ID'}).head() \n",
    "# 这个比较快，虽然正则也可以做"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### b 1 解法1 半给的"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "b问题就是 怎么把 出生的 年 月 日 转成 中文的  \n",
    "只要把对应数字每个都转成 中文的 然后连起来就可以了 \n",
    "年：0~9，月1~12，日0~31  \n",
    "故考虑构造一个 0-31的字典，key是数字，value是对应的中文"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-28T02:57:09.154092Z",
     "start_time": "2020-06-28T02:57:09.138078Z"
    }
   },
   "outputs": [],
   "source": [
    "cn_d_dic = dict(zip('0123456789', '零一二三四五六七八九'))\n",
    "for i in range(10, 32):\n",
    "    i = str(i)\n",
    "    cn_d_dic[i] = ('十' if i[0]=='1' else f'{cn_d_dic[i[0]]}十') + \\\n",
    "        ('' if i[-1]=='0' else f'{cn_d_dic[i[-1]]}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-28T03:01:17.532417Z",
     "start_time": "2020-06-28T03:01:17.511871Z"
    }
   },
   "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>ID</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>人员编号</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>aesfd:2国人,性别男,生于一九四二八月十日</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>fasefa:5国人,性别女,生于一九八五十月四日</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>aeagd:4国人,性别女,生于一九四六十月十五日</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>aef:4国人,性别男,生于一九九九五月十三日</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>eaf:1国人,性别女,生于二零一零六月二十四日</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1996</th>\n",
       "      <td>sdf:5国人,性别男,生于一九八四四月十七日</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1997</th>\n",
       "      <td>hx:1国人,性别男,生于一九四三七月十六日</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1998</th>\n",
       "      <td>drg:5国人,性别女,生于二零一八四月六日</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1999</th>\n",
       "      <td>zfgzdrg:5国人,性别男,生于二零零五一月三日</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2000</th>\n",
       "      <td>fsdf:3国人,性别女,生于一九六二七月二十三日</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>2000 rows × 1 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                              ID\n",
       "人员编号                            \n",
       "1       aesfd:2国人,性别男,生于一九四二八月十日\n",
       "2      fasefa:5国人,性别女,生于一九八五十月四日\n",
       "3      aeagd:4国人,性别女,生于一九四六十月十五日\n",
       "4        aef:4国人,性别男,生于一九九九五月十三日\n",
       "5       eaf:1国人,性别女,生于二零一零六月二十四日\n",
       "...                          ...\n",
       "1996     sdf:5国人,性别男,生于一九八四四月十七日\n",
       "1997      hx:1国人,性别男,生于一九四三七月十六日\n",
       "1998      drg:5国人,性别女,生于二零一八四月六日\n",
       "1999  zfgzdrg:5国人,性别男,生于二零零五一月三日\n",
       "2000   fsdf:3国人,性别女,生于一九六二七月二十三日\n",
       "\n",
       "[2000 rows x 1 columns]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_new = (df['姓名']+':'+df['国籍']+'国人,性别'+df['性别']+',生于'\n",
    "         +df['出生年'].map(lambda x:''.join(cn_d_dic[i] for i in x))\n",
    "         +df['出生月'].map(cn_d_dic)+'月'\n",
    "         +df['出生日'].map(cn_d_dic)+'日')\\\n",
    "        .to_frame().rename(columns={0:'ID'})\n",
    "df_new"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### b2 解法2 参考答案写法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-28T03:06:42.228916Z",
     "start_time": "2020-06-28T03:06:42.191362Z"
    }
   },
   "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>ID</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>人员编号</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>aesfd:2国人，性别男，生于一九四二年八月十日</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>fasefa:5国人，性别女，生于一九八五年十月四日</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>aeagd:4国人，性别女，生于一九四六年十月十五日</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>aef:4国人，性别男，生于一九九九年五月十三日</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>eaf:1国人，性别女，生于二零一零年六月二十四日</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                              ID\n",
       "人员编号                            \n",
       "1      aesfd:2国人，性别男，生于一九四二年八月十日\n",
       "2     fasefa:5国人，性别女，生于一九八五年十月四日\n",
       "3     aeagd:4国人，性别女，生于一九四六年十月十五日\n",
       "4       aef:4国人，性别男，生于一九九九年五月十三日\n",
       "5      eaf:1国人，性别女，生于二零一零年六月二十四日"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L_year = list('零一二三四五六七八九')\n",
    "L_one = [s.strip() for s in list('  二三四五六七八九')]\n",
    "L_two = [s.strip() for s in list(' 一二三四五六七八九')]\n",
    "df_new = (df['姓名']+':'+df['国籍']+'国人，性别'+df['性别']+'，生于'\n",
    "          +df['出生年'].str.replace(r'\\d',lambda x:L_year[int(x.group(0))])+'年'\n",
    "          +df['出生月'].apply(lambda x:x if len(x)==2 else '0'+x)\\\n",
    "                      .str.replace(r'(?P<one>[\\d])(?P<two>\\d?)',lambda x:L_one[int(x.group('one'))]\n",
    "                      +bool(int(x.group('one')))*'十'+L_two[int(x.group('two'))])+'月'\n",
    "          +df['出生日'].apply(lambda x:x if len(x)==2 else '0'+x)\\\n",
    "                      .str.replace(r'(?P<one>[\\d])(?P<two>\\d?)',lambda x:L_one[int(x.group('one'))]\n",
    "                      +bool(int(x.group('one')))*'十'+L_two[int(x.group('two'))])+'日')\\\n",
    "          .to_frame().rename(columns={0:'ID'})\n",
    "df_new.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这里的`bool(int(x.group('one')))`是什么意思?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "把月份转成两位，不足两位的前面补0，  \n",
    "比如 1月变成 01，然后提取一个字母  \n",
    "如果是0 就没有“十”，否则就加上“十”  \n",
    "bool应该是生成0和1的吧，\n",
    "因为后面是* 十"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### c1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-28T03:02:37.047951Z",
     "start_time": "2020-06-28T03:02:37.030414Z"
    }
   },
   "outputs": [],
   "source": [
    "df_res = df_new['ID'].str.extract(\n",
    "    r'(?P<姓名>[a-zA-Z]+):(?P<国籍>[\\d])国人，性别(?P<性别>[\\w])，生于(?P<出生年>[\\w]{4})年(?P<出生月>[\\w]+)月(?P<出生日>[\\w]+)日')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "用 str.extract 提取相应信息\n",
    "其余类似b，b是把数字替换成中文，c是把中文替换成数字"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### c2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dic_year = {i[0]:i[1] for i in zip(list('零一二三四五六七八九'),list('0123456789'))}\n",
    "dic_two = {i[0]:i[1] for i in zip(list('十一二三四五六七八九'),list('0123456789'))}\n",
    "dic_one = {'十':'1','二十':'2','三十':'3',None:''}\n",
    "df_res = df_new['ID'].str.extract(r'(?P<姓名>[a-zA-Z]+):(?P<国籍>[\\d])国人，性别(?P<性别>[\\w])，生于(?P<出生年>[\\w]{4})年(?P<出生月>[\\w]+)月(?P<出生日>[\\w]+)日')\n",
    "df_res['出生年'] = df_res['出生年'].str.replace(r'(\\w)+',lambda x:''.join([dic_year[x.group(0)[i]] for i in range(4)]))\n",
    "df_res['出生月'] = df_res['出生月'].str.replace(r'(?P<one>\\w?十)?(?P<two>[\\w])',lambda x:dic_one[x.group('one')]+dic_two[x.group('two')]).str.replace(r'0','10')\n",
    "df_res['出生日'] = df_res['出生日'].str.replace(r'(?P<one>\\w?十)?(?P<two>[\\w])',lambda x:dic_one[x.group('one')]+dic_two[x.group('two')]).str.replace(r'^0','10')\n",
    "df_res.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 【练习二】 现有一份半虚拟的数据集，第一列包含了新型冠状病毒的一些新闻标题，请解决以下问题：\n",
    "#### （a）选出所有关于北京市和上海市新闻标题的所在行。\n",
    "#### （b）求col2的均值。\n",
    "#### （c）求col3的均值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:55:59.713585Z",
     "start_time": "2020-06-26T00:55:59.698572Z"
    }
   },
   "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>col1</th>\n",
       "      <th>col2</th>\n",
       "      <th>col3</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>鄂尔多斯市第2例确诊患者治愈出院</td>\n",
       "      <td>19</td>\n",
       "      <td>363.6923</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>云南新增2例，累计124例</td>\n",
       "      <td>-67</td>\n",
       "      <td>-152.281</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>武汉协和医院14名感染医护出院</td>\n",
       "      <td>-86</td>\n",
       "      <td>325.6221</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>山东新增9例，累计307例</td>\n",
       "      <td>-74</td>\n",
       "      <td>-204.9313</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>上海开学日期延至3月</td>\n",
       "      <td>-95</td>\n",
       "      <td>4.05</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               col1 col2     col3  \n",
       "0  鄂尔多斯市第2例确诊患者治愈出院   19   363.6923\n",
       "1     云南新增2例，累计124例  -67   -152.281\n",
       "2   武汉协和医院14名感染医护出院  -86   325.6221\n",
       "3     山东新增9例，累计307例  -74  -204.9313\n",
       "4        上海开学日期延至3月  -95       4.05"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.read_csv('data/String_data_two.csv').head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### (a）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-28T03:18:08.062556Z",
     "start_time": "2020-06-28T03:18:08.031050Z"
    }
   },
   "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>col1</th>\n",
       "      <th>col2</th>\n",
       "      <th>col3</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>上海开学日期延至3月</td>\n",
       "      <td>-95</td>\n",
       "      <td>4.05</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>北京新增25例确诊病例，累计确诊253例</td>\n",
       "      <td>-4</td>\n",
       "      <td>-289.1719</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>上海新增10例，累计243例</td>\n",
       "      <td>2</td>\n",
       "      <td>-73.7105</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>36</th>\n",
       "      <td>上海新增14例累计233例</td>\n",
       "      <td>-55</td>\n",
       "      <td>-83</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>40</th>\n",
       "      <td>上海新增14例累计233例</td>\n",
       "      <td>-88</td>\n",
       "      <td>-99</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>53</th>\n",
       "      <td>上海7个月大婴儿确诊</td>\n",
       "      <td>-71</td>\n",
       "      <td>-391.2325</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>56</th>\n",
       "      <td>正直播！北京市疫情防控工作新闻发布会</td>\n",
       "      <td>-16</td>\n",
       "      <td>167.6711</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>62</th>\n",
       "      <td>北京新增 16 例累计确诊 228 例</td>\n",
       "      <td>-10</td>\n",
       "      <td>-367.7424</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>67</th>\n",
       "      <td>北京新增 16 例累计确诊 228 例</td>\n",
       "      <td>-18</td>\n",
       "      <td>-177.3911</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>69</th>\n",
       "      <td>正直播！北京市疫情防控工作新闻发布会</td>\n",
       "      <td>-92</td>\n",
       "      <td>107.7307</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>80</th>\n",
       "      <td>正直播！上海疫情防控发布会</td>\n",
       "      <td>-52</td>\n",
       "      <td>-211.4114</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>114</th>\n",
       "      <td>上海新增5例累计208例</td>\n",
       "      <td>100</td>\n",
       "      <td>327.2421</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>136</th>\n",
       "      <td>北京共报告聚集性病例41起，涉及确诊病例124人</td>\n",
       "      <td>-65</td>\n",
       "      <td>354.7823</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>137</th>\n",
       "      <td>北京复兴医院现9人感染聚集性病例</td>\n",
       "      <td>-17</td>\n",
       "      <td>52.6503</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>138</th>\n",
       "      <td>北京3名患者出院</td>\n",
       "      <td>-45</td>\n",
       "      <td>251.9116</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>139</th>\n",
       "      <td>北京新增24例，累计212例</td>\n",
       "      <td>3</td>\n",
       "      <td>82.6205</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>145</th>\n",
       "      <td>上海7个月婴儿被感染</td>\n",
       "      <td>-69</td>\n",
       "      <td>140.9409</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>178</th>\n",
       "      <td>上海新增11例累计确诊193例</td>\n",
       "      <td>69</td>\n",
       "      <td>150.661</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>196</th>\n",
       "      <td>北京新确诊8例累计191例</td>\n",
       "      <td>-17</td>\n",
       "      <td>-13.7701</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>204</th>\n",
       "      <td>上海新增5例累计确诊182例</td>\n",
       "      <td>20</td>\n",
       "      <td>-25.9202</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>217</th>\n",
       "      <td>北京新增15例含10月婴儿</td>\n",
       "      <td>-13</td>\n",
       "      <td>150.661</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>263</th>\n",
       "      <td>上海新增8例累计177例</td>\n",
       "      <td>61</td>\n",
       "      <td>-272.1617</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>285</th>\n",
       "      <td>北京市规定：延期开学期间每户家庭可有一名职工在家看护未成年子女 工资待遇照发</td>\n",
       "      <td>-2</td>\n",
       "      <td>-317.522</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>286</th>\n",
       "      <td>北京累计确诊168例，新增治愈出院4例</td>\n",
       "      <td>-25</td>\n",
       "      <td>-63.9904</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>294</th>\n",
       "      <td>上海新增病例16例，新增治愈出院1例</td>\n",
       "      <td>-57</td>\n",
       "      <td>-92.3406</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>295</th>\n",
       "      <td>直播！#上海疫情防控发布会#</td>\n",
       "      <td>37</td>\n",
       "      <td>-267.3017</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>298</th>\n",
       "      <td>北京新增17例累计确诊156例</td>\n",
       "      <td>-37</td>\n",
       "      <td>303.7519</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>301</th>\n",
       "      <td>北京新增17例，累计确诊156例</td>\n",
       "      <td>-93</td>\n",
       "      <td>-51.8403</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>329</th>\n",
       "      <td>上海新增病例18例，累计153例</td>\n",
       "      <td>-64</td>\n",
       "      <td>-8.9101</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>348</th>\n",
       "      <td>北京除必需行业企业2月10日上班</td>\n",
       "      <td>-28</td>\n",
       "      <td>17.0101</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>362</th>\n",
       "      <td>北京新增7例确诊病例</td>\n",
       "      <td>48</td>\n",
       "      <td>-341.8222</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>367</th>\n",
       "      <td>上海新增7例新型冠状病毒感染的肺炎确诊病例</td>\n",
       "      <td>60</td>\n",
       "      <td>58</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>370</th>\n",
       "      <td>北京新增11例</td>\n",
       "      <td>15</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>372</th>\n",
       "      <td>上海4例确诊病例痊愈出院</td>\n",
       "      <td>35</td>\n",
       "      <td>-207.3613</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>374</th>\n",
       "      <td>北京新增11例</td>\n",
       "      <td>26</td>\n",
       "      <td>253.5316</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>377</th>\n",
       "      <td>上海4例确诊病例痊愈出院</td>\n",
       "      <td>-91</td>\n",
       "      <td>-62.3704</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>401</th>\n",
       "      <td>北京新增7例病例，累计确诊121例</td>\n",
       "      <td>-52</td>\n",
       "      <td>206.5513</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>403</th>\n",
       "      <td>上海新增16例，累计128例</td>\n",
       "      <td>-97</td>\n",
       "      <td>52.6503</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>404</th>\n",
       "      <td>北京新增7例病例累计确诊121例</td>\n",
       "      <td>97</td>\n",
       "      <td>206.5513</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>415</th>\n",
       "      <td>北京新增7例，累计确诊121例</td>\n",
       "      <td>67</td>\n",
       "      <td>-264.0617</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>428</th>\n",
       "      <td>北京地铁明起全线网测温进站</td>\n",
       "      <td>-32</td>\n",
       "      <td>-32.4002</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>439</th>\n",
       "      <td>上海新增11例累计112例</td>\n",
       "      <td>-51</td>\n",
       "      <td>-396.9025</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>445</th>\n",
       "      <td>北京小汤山医院启动修缮</td>\n",
       "      <td>20</td>\n",
       "      <td>396.0925</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>454</th>\n",
       "      <td>北京新增3例累计114例</td>\n",
       "      <td>-57</td>\n",
       "      <td>-22.6801</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>455</th>\n",
       "      <td>共同战疫：北京市召开发布会通报疫情防控进展</td>\n",
       "      <td>-79</td>\n",
       "      <td>362.0723</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>499</th>\n",
       "      <td>上海新增5例，累计101例</td>\n",
       "      <td>-95</td>\n",
       "      <td>157.951</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                       col1 col2     col3  \n",
       "4                                上海开学日期延至3月  -95       4.05\n",
       "5                      北京新增25例确诊病例，累计确诊253例   -4  -289.1719\n",
       "6                            上海新增10例，累计243例    2   -73.7105\n",
       "36                            上海新增14例累计233例  -55        -83\n",
       "40                            上海新增14例累计233例  -88        -99\n",
       "53                               上海7个月大婴儿确诊  -71  -391.2325\n",
       "56                       正直播！北京市疫情防控工作新闻发布会  -16   167.6711\n",
       "62                      北京新增 16 例累计确诊 228 例  -10  -367.7424\n",
       "67                      北京新增 16 例累计确诊 228 例  -18  -177.3911\n",
       "69                       正直播！北京市疫情防控工作新闻发布会  -92   107.7307\n",
       "80                            正直播！上海疫情防控发布会  -52  -211.4114\n",
       "114                            上海新增5例累计208例  100   327.2421\n",
       "136                北京共报告聚集性病例41起，涉及确诊病例124人  -65   354.7823\n",
       "137                        北京复兴医院现9人感染聚集性病例  -17    52.6503\n",
       "138                                北京3名患者出院  -45   251.9116\n",
       "139                          北京新增24例，累计212例    3    82.6205\n",
       "145                              上海7个月婴儿被感染  -69   140.9409\n",
       "178                         上海新增11例累计确诊193例   69    150.661\n",
       "196                           北京新确诊8例累计191例  -17   -13.7701\n",
       "204                          上海新增5例累计确诊182例   20   -25.9202\n",
       "217                           北京新增15例含10月婴儿  -13    150.661\n",
       "263                            上海新增8例累计177例   61  -272.1617\n",
       "285  北京市规定：延期开学期间每户家庭可有一名职工在家看护未成年子女 工资待遇照发   -2   -317.522\n",
       "286                     北京累计确诊168例，新增治愈出院4例  -25   -63.9904\n",
       "294                      上海新增病例16例，新增治愈出院1例  -57   -92.3406\n",
       "295                          直播！#上海疫情防控发布会#   37  -267.3017\n",
       "298                         北京新增17例累计确诊156例  -37   303.7519\n",
       "301                        北京新增17例，累计确诊156例  -93   -51.8403\n",
       "329                        上海新增病例18例，累计153例  -64    -8.9101\n",
       "348                        北京除必需行业企业2月10日上班  -28    17.0101\n",
       "362                              北京新增7例确诊病例   48  -341.8222\n",
       "367                   上海新增7例新型冠状病毒感染的肺炎确诊病例   60         58\n",
       "370                                 北京新增11例   15          7\n",
       "372                            上海4例确诊病例痊愈出院   35  -207.3613\n",
       "374                                 北京新增11例   26   253.5316\n",
       "377                            上海4例确诊病例痊愈出院  -91   -62.3704\n",
       "401                       北京新增7例病例，累计确诊121例  -52   206.5513\n",
       "403                          上海新增16例，累计128例  -97    52.6503\n",
       "404                        北京新增7例病例累计确诊121例   97   206.5513\n",
       "415                         北京新增7例，累计确诊121例   67  -264.0617\n",
       "428                           北京地铁明起全线网测温进站  -32   -32.4002\n",
       "439                           上海新增11例累计112例  -51  -396.9025\n",
       "445                             北京小汤山医院启动修缮   20   396.0925\n",
       "454                            北京新增3例累计114例  -57   -22.6801\n",
       "455                   共同战疫：北京市召开发布会通报疫情防控进展  -79   362.0723\n",
       "499                           上海新增5例，累计101例  -95    157.951"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df=pd.read_csv('data/String_data_two.csv')\n",
    "df[df['col1'].str.contains('北京|上海')]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "提取 含有 北京 和上海 的行  \n",
    "用 `re.match` 不行，因为match只能匹配在最前面的字符，在中间的就匹配不了"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果直接用 contains 分别 北京 上海的同学，可以用  \n",
    "`df[df['col1'].str.contains('北京') | df['col1'].str.contains('上海')]`  \n",
    "不用再 concat 起来，这是针对有个同学的作业说的"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-28T03:18:12.062194Z",
     "start_time": "2020-06-28T03:18:12.051184Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "309    0-\n",
       "396    9`\n",
       "485    /7\n",
       "Name: col2, dtype: object"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#df['col2'].mean() #报错\n",
    "df['col2'][~(df['col2'].str.replace(r'-?\\d+','True')=='True')] #这三行有问题"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-28T03:18:14.217140Z",
     "start_time": "2020-06-28T03:18:14.211134Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.984"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.loc[[309,396,485],'col2'] = [0,9,7]\n",
    "df['col2'].astype('int').mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  （c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T10:33:29.506083Z",
     "start_time": "2020-06-26T10:33:29.495572Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['col1', 'col2', 'col3  '], dtype='object')"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#df['col3'].mean() #报错\n",
    "#df['col3'] #报错\n",
    "df.columns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`df['col3'].mean()` 报错是 KeyError: 'col3' ，也就是说找不到 col3 这个字段  \n",
    "通过 df.columns 可以看出 col3多了空格, 去掉空格就可以了↓"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-28T03:18:18.488179Z",
     "start_time": "2020-06-28T03:18:18.483174Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['col1', 'col2', 'col3'], dtype='object')"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.columns = df.columns.str.strip()\n",
    "df.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-28T03:18:21.710854Z",
     "start_time": "2020-06-28T03:18:21.698843Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0     363.6923\n",
       "1     -152.281\n",
       "2     325.6221\n",
       "3    -204.9313\n",
       "4         4.05\n",
       "Name: col3, dtype: object"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df['col3'].head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-28T03:20:40.023948Z",
     "start_time": "2020-06-28T03:20:40.010928Z"
    }
   },
   "outputs": [],
   "source": [
    "#df['col3'].mean() #报错"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " `df['col3'].mean()` 发现是 ValueError: could not convert string to float:  应该是float怎么会有 str 类型?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-28T03:18:24.892860Z",
     "start_time": "2020-06-28T03:18:24.882818Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 500 entries, 0 to 499\n",
      "Data columns (total 3 columns):\n",
      " #   Column  Non-Null Count  Dtype \n",
      "---  ------  --------------  ----- \n",
      " 0   col1    500 non-null    object\n",
      " 1   col2    500 non-null    object\n",
      " 2   col3    500 non-null    object\n",
      "dtypes: object(3)\n",
      "memory usage: 11.8+ KB\n"
     ]
    }
   ],
   "source": [
    "df.info() #随手 .info() 查看的习惯"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "本应是float的dtype 变成 object，说明其中有脏数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-28T03:20:02.616058Z",
     "start_time": "2020-06-28T03:20:02.595510Z"
    }
   },
   "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>col1</th>\n",
       "      <th>col2</th>\n",
       "      <th>col3</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>28</th>\n",
       "      <td>湖南新增确诊病例68例，累计确诊661例</td>\n",
       "      <td>95</td>\n",
       "      <td>355`.3567</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>122</th>\n",
       "      <td>山西新增8例累计确诊74例</td>\n",
       "      <td>91</td>\n",
       "      <td>9056.\\2253</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>332</th>\n",
       "      <td>西班牙确诊首例病例</td>\n",
       "      <td>64</td>\n",
       "      <td>3534.6554{</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                     col1 col2        col3\n",
       "28   湖南新增确诊病例68例，累计确诊661例   95   355`.3567\n",
       "122         山西新增8例累计确诊74例   91  9056.\\2253\n",
       "332             西班牙确诊首例病例   64  3534.6554{"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def is_number(x):\n",
    "    try:\n",
    "        float(x)\n",
    "        return True\n",
    "    except (SyntaxError, ValueError) as e:\n",
    "        return False\n",
    "\n",
    "df[~df.col3.map(is_number)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### 原答案这里用的正则，较麻烦"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T10:33:44.375379Z",
     "start_time": "2020-06-26T10:33:44.365849Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "28      355`.3567\n",
       "37             -5\n",
       "73              1\n",
       "122    9056.\\2253\n",
       "332    3534.6554{\n",
       "370             7\n",
       "Name: col3, dtype: object"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df['col3'][~(df['col3'].str.replace(r'-?\\d+\\.?\\d+','True')=='True')]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 斜杠一点是匹配一点作为小数点，斜杠是转义\n",
    "- ？是非贪婪模式，匹配0个或1个， -？的意思就是有负号就匹配负号，没有就不匹配\n",
    "- \\d是匹配0-9，+是贪婪模式，有多少匹配多少\n",
    "- + 一个或多个重复\n",
    "- \\.？就是匹配一个或零个点\n",
    "- 这个表达式可能有漏洞，最前面加个^，最后面加个$可以分别限定开始和结束字符"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T10:34:02.862706Z",
     "start_time": "2020-06-26T10:34:02.852707Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24.707485"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.loc[[28,122,332],'col3'] = [355.3567,9056.2253, 3534.6554]\n",
    "df['col3'].astype('float').mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 以上题解，参考了群友讨论，原答案，和助教半的讨论，不是我写的"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-28T03:26:14.545291Z",
     "start_time": "2020-06-28T03:26:14.535762Z"
    }
   },
   "source": [
    "[该项目答疑板](https://shimo.im/docs/YGpkeGGqYFAm4laL)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "joyfulpd",
   "language": "python",
   "name": "joyfulpd"
  },
  "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.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}