第7章 文本数据.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 第7章 文本数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "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",
    "#### 从Pandas的1.1.x版本开始，所有的类型都能够通过astype('string')转为字符串类型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "0     1\n1    1.\ndtype: string"
     },
     "metadata": {},
     "execution_count": 2
    }
   ],
   "source": [
    "pd.Series([1,'1.']).astype('string')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "0    1\n1    2\ndtype: string"
     },
     "metadata": {},
     "execution_count": 3
    }
   ],
   "source": [
    "pd.Series([1,2]).astype('string')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "0     True\n1    False\ndtype: string"
     },
     "metadata": {},
     "execution_count": 4
    }
   ],
   "source": [
    "pd.Series([True,False]).astype('string')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 二、拆分与拼接"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. str.split方法\n",
    "#### （a）分割符与str的位置元素选取"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "0    a_b_c\n1    c_d_e\n2     <NA>\n3    f_g_h\ndtype: string"
     },
     "metadata": {},
     "execution_count": 5
    }
   ],
   "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": 6,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "0    [a, b, c]\n1    [c, d, e]\n2         <NA>\n3    [f, g, h]\ndtype: object"
     },
     "metadata": {},
     "execution_count": 6
    }
   ],
   "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": 7,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "0       b\n1       d\n2    <NA>\n3       g\ndtype: object"
     },
     "metadata": {},
     "execution_count": 7
    }
   ],
   "source": [
    "s.str.split('_').str[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "0    _\n1    b\ndtype: object"
     },
     "metadata": {},
     "execution_count": 8
    }
   ],
   "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": 9,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "      0     1     2\n0     a     b     c\n1     c     d     e\n2  <NA>  <NA>  <NA>\n3     f     g     h",
      "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>"
     },
     "metadata": {},
     "execution_count": 9
    }
   ],
   "source": [
    "s.str.split('_',expand=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "0    [a, b_c]\n1    [c, d_e]\n2        <NA>\n3    [f, g_h]\ndtype: object"
     },
     "metadata": {},
     "execution_count": 10
    }
   ],
   "source": [
    "s.str.split('_',n=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "      0     1\n0     a   b_c\n1     c   d_e\n2  <NA>  <NA>\n3     f   g_h",
      "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>"
     },
     "metadata": {},
     "execution_count": 11
    }
   ],
   "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": 12,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "0      ab\n1    <NA>\n2       d\ndtype: string"
     },
     "metadata": {},
     "execution_count": 12
    }
   ],
   "source": [
    "s = pd.Series(['ab',None,'d'],dtype='string')\n",
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "'abd'"
     },
     "metadata": {},
     "execution_count": 13
    }
   ],
   "source": [
    "s.str.cat()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 其中可选sep分隔符参数，和缺失值替代字符na_rep参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "'ab,d'"
     },
     "metadata": {},
     "execution_count": 14
    }
   ],
   "source": [
    "s.str.cat(sep=',')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "'ab,*,d'"
     },
     "metadata": {},
     "execution_count": 15
    }
   ],
   "source": [
    "s.str.cat(sep=',',na_rep='*')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### ② 对于两个Series合并而言，是对应索引的元素进行合并"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "0      24\n1    <NA>\n2    <NA>\ndtype: string"
     },
     "metadata": {},
     "execution_count": 16
    }
   ],
   "source": [
    "s2 = pd.Series(['24',None,None],dtype='string')\n",
    "s2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "0    ab24\n1    <NA>\n2    <NA>\ndtype: string"
     },
     "metadata": {},
     "execution_count": 17
    }
   ],
   "source": [
    "s.str.cat(s2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 同样也有相应参数，需要注意的是两个缺失值会被同时替换"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "0    ab,24\n1      *,*\n2      d,*\ndtype: string"
     },
     "metadata": {},
     "execution_count": 18
    }
   ],
   "source": [
    "s.str.cat(s2,sep=',',na_rep='*')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### ③ 多列拼接可以分为表的拼接和多Series拼接"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 表的拼接"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "0    ab15\n1     *3b\n2     d5*\ndtype: string"
     },
     "metadata": {},
     "execution_count": 19
    }
   ],
   "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": 20,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "0    abab0abab\n1         <NA>\n2        dd0dd\ndtype: string"
     },
     "metadata": {},
     "execution_count": 20
    }
   ],
   "source": [
    "s.str.cat([s+'0',s*2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### （b）cat中的索引对齐\n",
    "#### 当前版本中，如果两边合并的索引不相同且未指定join参数，默认为左连接，设置join='left'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "1    a\n2    b\n3    c\ndtype: string"
     },
     "metadata": {},
     "execution_count": 21
    }
   ],
   "source": [
    "s2 = pd.Series(list('abc'),index=[1,2,3],dtype='string')\n",
    "s2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "0    ab*\n1     *a\n2     db\ndtype: string"
     },
     "metadata": {},
     "execution_count": 22
    }
   ],
   "source": [
    "s.str.cat(s2,na_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": 23,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "0       A\n1       B\n2       C\n3    Aaba\n4    Baca\n5        \n6    <NA>\n7    CABA\n8     dog\n9     cat\ndtype: string"
     },
     "metadata": {},
     "execution_count": 23
    }
   ],
   "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": 24,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "0       ***\n1       ***\n2         C\n3    ***aba\n4    ***aca\n5          \n6      <NA>\n7      CABA\n8       dog\n9       cat\ndtype: string"
     },
     "metadata": {},
     "execution_count": 24
    }
   ],
   "source": [
    "s.str.replace(r'^[AB]','***')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. 子组与函数替换"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 通过正整数调用子组（0返回字符本身，从1开始才是子组）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "0       A\n1       B\n2       C\n3     ba*\n4     ca*\n5        \n6    <NA>\n7     BA*\n8     dog\n9     cat\ndtype: string"
     },
     "metadata": {},
     "execution_count": 25
    }
   ],
   "source": [
    "s.str.replace(r'([ABC])(\\w+)',lambda x:x.group(2)[1:]+'*')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 利用?P<....>表达式可以对子组命名调用"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "0       A\n1       B\n2       C\n3     ba*\n4     ca*\n5        \n6    <NA>\n7     BA*\n8     dog\n9     cat\ndtype: string"
     },
     "metadata": {},
     "execution_count": 26
    }
   ],
   "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": 27,
   "metadata": {},
   "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": 28,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "0    <NA>\n1       B\ndtype: string"
     },
     "metadata": {},
     "execution_count": 28
    }
   ],
   "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": 29,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "0    A\n1    B\ndtype: string"
     },
     "metadata": {},
     "execution_count": 29
    }
   ],
   "source": [
    "pd.Series(['A','B'],dtype='string').replace(r'[A]','C',regex=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "0    C\n1    B\ndtype: object"
     },
     "metadata": {},
     "execution_count": 30
    }
   ],
   "source": [
    "pd.Series(['A','B'],dtype='O').replace(r'[A]','C',regex=True)"
   ]
  },
  {
   "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": 31,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "    0   1\n0  10  87\n1  10  88\n2  10  89",
      "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>"
     },
     "metadata": {},
     "execution_count": 31
    }
   ],
   "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": 32,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "  name_1 name_2\n0     10     87\n1     10     88\n2   <NA>   <NA>",
      "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>"
     },
     "metadata": {},
     "execution_count": 32
    }
   ],
   "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": 33,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "  name_1 name_2\n0     10     87\n1     10     88\n2   <NA>     89",
      "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>"
     },
     "metadata": {},
     "execution_count": 33
    }
   ],
   "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": 34,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "  name_1 name_2\n0     10     87\n1     10     88\n2     10   <NA>",
      "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>"
     },
     "metadata": {},
     "execution_count": 34
    }
   ],
   "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": 35,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "Index(['A11', 'B22', 'C33'], dtype='object')"
     },
     "metadata": {},
     "execution_count": 35
    }
   ],
   "source": [
    "s = pd.Series([\"a1\", \"b2\", \"c3\"], [\"A11\", \"B22\", \"C33\"], dtype=\"string\")\n",
    "s.index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "     0\nA11  a\nB22  b\nC33  c",
      "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>"
     },
     "metadata": {},
     "execution_count": 36
    }
   ],
   "source": [
    "s.str.extract(r'([\\w])')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "A11    a\nB22    b\nC33    c\ndtype: string"
     },
     "metadata": {},
     "execution_count": 37
    }
   ],
   "source": [
    "s.str.extract(r'([\\w])',expand=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "   0\n0  A\n1  B\n2  C",
      "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>"
     },
     "metadata": {},
     "execution_count": 38
    }
   ],
   "source": [
    "s.index.str.extract(r'([\\w])')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "Index(['A', 'B', 'C'], dtype='object')"
     },
     "metadata": {},
     "execution_count": 39
    }
   ],
   "source": [
    "s.index.str.extract(r'([\\w])',expand=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "   0  1\n0  A  1\n1  B  2\n2  C  3",
      "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>"
     },
     "metadata": {},
     "execution_count": 40
    }
   ],
   "source": [
    "s.index.str.extract(r'([\\w])([\\d])')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "#s.index.str.extract(r'([\\w])([\\d])',expand=False) #报错"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. str.extractall方法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 与extract只匹配第一个符合条件的表达式不同，extractall会找出所有符合条件的字符串，并建立多级索引（即使只找到一个）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "  letter digit\nA      a     1\nB      b     1\nC      c     1",
      "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>"
     },
     "metadata": {},
     "execution_count": 42
    }
   ],
   "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": 43,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "        letter digit\n  match             \nA 0          a     1\n  1          a     2\nB 0          b     1\nC 0          c     1",
      "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>"
     },
     "metadata": {},
     "execution_count": 43
    }
   ],
   "source": [
    "s.str.extractall(two_groups)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "        letter digit\n  match             \nA 0          a     1\nB 0          b     1\nC 0          c     1",
      "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>"
     },
     "metadata": {},
     "execution_count": 44
    }
   ],
   "source": [
    "s['A']='a1'\n",
    "s.str.extractall(two_groups)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 如果想查看第i层匹配，可使用xs方法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "  letter digit\nA      a     2\nB      b     2\nC      c     2",
      "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>"
     },
     "metadata": {},
     "execution_count": 45
    }
   ],
   "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": 46,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "0    False\n1     <NA>\n2     True\n3     True\n4     True\ndtype: boolean"
     },
     "metadata": {},
     "execution_count": 46
    }
   ],
   "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": 47,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "0    False\n1    False\n2     True\n3    False\n4    False\ndtype: boolean"
     },
     "metadata": {},
     "execution_count": 47
    }
   ],
   "source": [
    "pd.Series(['1', None, '3a', '3b', '03c'], dtype=\"string\").str.contains('a', na=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### str.match与其区别在于，match依赖于python的re.match，检测内容为是否从头开始包含该正则模式"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "0    False\n1    False\n2     True\n3     True\n4    False\ndtype: boolean"
     },
     "metadata": {},
     "execution_count": 48
    }
   ],
   "source": [
    "pd.Series(['1', None, '3a_', '3b', '03c'], dtype=\"string\").str.match(r'[0-9][a-z]',na=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "0    False\n1    False\n2    False\n3     True\n4    False\ndtype: boolean"
     },
     "metadata": {},
     "execution_count": 49
    }
   ],
   "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": 50,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "Index(['space1', 'space2', 'space3'], dtype='object')"
     },
     "metadata": {},
     "execution_count": 50
    }
   ],
   "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": 51,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "0    a\ndtype: string"
     },
     "metadata": {},
     "execution_count": 51
    }
   ],
   "source": [
    "pd.Series('A',dtype=\"string\").str.lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "0    A\ndtype: string"
     },
     "metadata": {},
     "execution_count": 52
    }
   ],
   "source": [
    "pd.Series('a',dtype=\"string\").str.upper()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### （c）str.swapcase和str.capitalize\n",
    "#### 分别表示交换字母大小写和大写首字母"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "0    ABcd\ndtype: string"
     },
     "metadata": {},
     "execution_count": 53
    }
   ],
   "source": [
    "pd.Series('abCD',dtype=\"string\").str.swapcase()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "0    Abcd\ndtype: string"
     },
     "metadata": {},
     "execution_count": 54
    }
   ],
   "source": [
    "pd.Series('abCD',dtype=\"string\").str.capitalize()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. isnumeric方法\n",
    "#### 检查每一位是否都是数字，请问如何判断是否是数值？（问题二）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "0    False\n1     True\n2    False\n3    False\n4     <NA>\ndtype: boolean"
     },
     "metadata": {},
     "execution_count": 55
    }
   ],
   "source": [
    "pd.Series(['1.2','1','-0.3','a',np.nan],dtype=\"string\").str.isnumeric()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 六、问题与练习\n",
    "### 1. 问题"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 【问题一】 str对象方法和df/Series对象方法有什么区别？\n",
    "#### 【问题二】 给出一列string类型，如何判断单元格是否是数值型数据？\n",
    "#### 【问题三】 rsplit方法的作用是什么？它在什么场合下适用？\n",
    "#### 【问题四】 在本章的第二到第四节分别介绍了字符串类型的5类操作，请思考它们各自应用于什么场景？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. 练习\n",
    "#### 【练习一】 现有一份关于字符串的数据集，请解决以下问题：\n",
    "#### （a）现对字符串编码存储人员信息（在编号后添加ID列），使用如下格式：“×××（名字）：×国人，性别×，生于×年×月×日”\n",
    "#### （b）将（a）中的人员生日信息部分修改为用中文表示（如一九七四年十月二十三日），其余返回格式不变。\n",
    "#### （c）将（b）中的ID列结果拆分为原列表相应的5列，并使用equals检验是否一致。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "          姓名  国籍 性别   出生年  出生月  出生日\n人员编号                               \n1      aesfd   2  男  1942    8   10\n2     fasefa   5  女  1985   10    4\n3      aeagd   4  女  1946   10   15\n4        aef   4  男  1999    5   13\n5        eaf   1  女  2010    6   24",
      "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>"
     },
     "metadata": {},
     "execution_count": 56
    }
   ],
   "source": [
    "pd.read_csv('data/String_data_one.csv',index_col='人员编号').head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 【练习二】 现有一份半虚拟的数据集，第一列包含了新型冠状病毒的一些新闻标题，请解决以下问题：\n",
    "#### （a）选出所有关于北京市和上海市新闻标题的所在行。\n",
    "#### （b）求col2的均值。\n",
    "#### （c）求col3的均值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "               col1 col2     col3  \n0  鄂尔多斯市第2例确诊患者治愈出院   19   363.6923\n1     云南新增2例，累计124例  -67   -152.281\n2   武汉协和医院14名感染医护出院  -86   325.6221\n3     山东新增9例，累计307例  -74  -204.9313\n4        上海开学日期延至3月  -95       4.05",
      "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>"
     },
     "metadata": {},
     "execution_count": 57
    }
   ],
   "source": [
    "pd.read_csv('data/String_data_two.csv').head()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "PyCharm (pythonProject)",
   "language": "python",
   "name": "pycharm-f7427e7c"
  },
  "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.7.9-final"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}