Python 基础系列 - [3] 容器型数据.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <div style=\"text-align: center\"><font color='#dc2624' face='微软雅黑'>Python 基础系列</font></div>\n",
    "## <div style=\"text-align: center\"><font color='#dc2624' face='微软雅黑'>容器型数据</font></div>\n",
    "\n",
    "## <font color='#dc2624' face='微软雅黑'>目录</font><a name='toc'></a>\n",
    "### 1. [**<font color='#dc2624' face='微软雅黑'>字符串</font>**](#1)\n",
    "1. [<font color='#2b4750' face='微软雅黑'>创建</font>](#1.1)\n",
    "2. [<font color='#2b4750' face='微软雅黑'>索引切片</font>](#1.2)\n",
    "3. [<font color='#2b4750' face='微软雅黑'>分合查替</font>](#1.3)\n",
    "4. [<font color='#2b4750' face='微软雅黑'>调大小写</font>](#1.4)\n",
    "5. [<font color='#2b4750' face='微软雅黑'>删除补充</font>](#1.5)\n",
    "6. [<font color='#2b4750' face='微软雅黑'>格式化</font>](#1.6)\n",
    "6. [<font color='#2b4750' face='微软雅黑'>运算符</font>](#1.7)\n",
    "\n",
    "### 2. [**<font color='#dc2624' face='微软雅黑'>列表</font>**](#2)\n",
    "1. [<font color='#2b4750' face='微软雅黑'>创建</font>](#2.1)\n",
    "2. [<font color='#2b4750' face='微软雅黑'>索引切片</font>](#2.2)\n",
    "3. [<font color='#2b4750' face='微软雅黑'>常用方法</font>](#2.3)\n",
    "4. [<font color='#2b4750' face='微软雅黑'>运算符</font>](#2.4)\n",
    "\n",
    "### 3. [**<font color='#dc2624' face='微软雅黑'>元组</font>**](#3)\n",
    "1. [<font color='#2b4750' face='微软雅黑'>创建</font>](#3.1)\n",
    "2. [<font color='#2b4750' face='微软雅黑'>索引切片</font>](#3.2)\n",
    "3. [<font color='#2b4750' face='微软雅黑'>不可修改</font>](#3.3)\n",
    "4. [<font color='#2b4750' face='微软雅黑'>打散赋值</font>](#3.4)\n",
    "5. [<font color='#2b4750' face='微软雅黑'>运算符</font>](#3.5)\n",
    "\n",
    "### 4. [**<font color='#dc2624' face='微软雅黑'>字典</font>**](#4)\n",
    "1. [<font color='#2b4750' face='微软雅黑'>创建</font>](#4.1)\n",
    "2. [<font color='#2b4750' face='微软雅黑'>索引</font>](#4.2)\n",
    "3. [<font color='#2b4750' face='微软雅黑'>常见方法</font>](#4.3)\n",
    "\n",
    "### 5. [**<font color='#dc2624' face='微软雅黑'>集合</font>**](#5)\n",
    "1. [<font color='#2b4750' face='微软雅黑'>创建</font>](#5.1)\n",
    "2. [<font color='#2b4750' face='微软雅黑'>集合运算</font>](#5.2)\n",
    "3. [<font color='#2b4750' face='微软雅黑'>常见方法</font>](#5.3)\n",
    "\n",
    "### 6. [**<font color='#dc2624' face='微软雅黑'>Collection</font>**](#6)\n",
    "1. [<font color='#2b4750' face='微软雅黑'>namedtuple</font>](#6.1)\n",
    "2. [<font color='#2b4750' face='微软雅黑'>defaultdict</font>](#6.2)\n",
    "3. [<font color='#2b4750' face='微软雅黑'>Counter</font>](#6.3)\n",
    "4. [<font color='#2b4750' face='微软雅黑'>deque</font>](#6.4)\n",
    "5. [<font color='#2b4750' face='微软雅黑'>ChainMap</font>](#6.5)\n",
    "6. [<font color='#2b4750' face='微软雅黑'>OrderedDict</font>](#6.6)\n",
    "\n",
    "### 6. [**<font color='#dc2624' face='微软雅黑'>习题</font>**](#7)\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <font color='#dc2624' face='微软雅黑'>1. 字符串</font><a name='1'></a>\n",
    "[<font color='black' face='微软雅黑'>回到目录</font>](#toc)\n",
    "### <font color='#2b4750' face='微软雅黑'>1.1 创建字符串</font><a name='1.1'></a>\n",
    "[<font color='black' face='微软雅黑'>回到章首</font>](#1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i love Python! <class 'str'>\n",
      "I love Python! <class 'str'>\n",
      "I LOVE PYTHON <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "s1 = 'i love Python!'\n",
    "print( s1, type(s1) )\n",
    "\n",
    "s2 = \"I love Python!\"\n",
    "print( s2, type(s2) )\n",
    "\n",
    "s3 = str('I LOVE PYTHON')\n",
    "print( s3, type(s3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "快乐机器学习\n",
      "机器学习快乐\n"
     ]
    }
   ],
   "source": [
    "s = \"\"\"快乐机器学习\n",
    "机器学习快乐\"\"\"\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python 里万物皆对象，字符串也是对象，任何对象都有其\n",
    "- **内存地址**，用 `id` 函数查看\n",
    "- **类型**，用 `type` 函数查看\n",
    "- **值**，用 `print` 函数查看"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = 'Python'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ID: 2365290971464\n",
      "Type: <class 'str'>\n",
      "Value: Python\n"
     ]
    }
   ],
   "source": [
    "print( 'ID:', id(s) )\n",
    "print( 'Type:', type(s) )\n",
    "print( 'Value:', s )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color='#2b4750' face='微软雅黑'>1.2 切片和索引</font><a name='1.2'></a>\n",
    "[<font color='black' face='微软雅黑'>回到章首</font>](#1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = 'Python'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "第一个字符所在的索引为 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'P'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "索引值可正可负"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'y'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[-5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "切片包头不包尾"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'yth'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[1:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'tho'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[-4:-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Pyt'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'n'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[5:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'yh'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[1:5:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Pto'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[::2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'nohtyP'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "查看**字符串**里面的内置属性，可用 `dir(str)` 和 `help(str)`。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color='#2b4750' face='微软雅黑'>1.3 分合查替</font><a name='1.3'></a>\n",
    "[<font color='black' face='微软雅黑'>回到章首</font>](#1)\n",
    "\n",
    "### 分合查替 - 获取想要的字符串。\n",
    "\n",
    "**分 - 分隔**\n",
    "- `partition(d)`：以`d`为界，把句子分成三部分，返回元组 (`d`前的字符串, `d`字符串, `d`后的字符串)\n",
    "- `split(d)`：以`d`为分隔符，把句子分成单词\n",
    "- `splitlines()`：把句子分成行"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('LPR Swaption', ':', ' 108,000')"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = 'LPR Swaption: 108,000'\n",
    "s.partition(':')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Python is simple', ' I can do it.']"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = 'Python is simple, I can do it.'\n",
    "s.split(',')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Python', 'is', 'simple,', 'I', 'can', 'do', 'it.']"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.split(' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "#import re\n",
    "#re.split('[\\s,.]', s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"\"\"快乐机器学习\n",
    "机器学习快乐\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['快乐机器学习', '机器学习快乐']"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.splitlines()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['快乐机器学习\\n', '机器学习快乐']"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.splitlines(keepends=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**合 - 合并**\n",
    "- `d.join(l)`：用分隔符`d`将列表`l`中的每个字符串连起来"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python is simple'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = ['Python', 'is', 'simple']\n",
    "' '.join(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**查 - 查找**\n",
    "- `find(x)`：找到给定词`x`在句中的索引，找不到返回 -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = 'I am learning machine learning'\n",
    "s.find('learning')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.find('Learning')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**替 - 替换**\n",
    "- `replace(x,y)`：把句中`x`替换成`y`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python For Finance'"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = 'Python for finance'\n",
    "s.replace('f','F')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color='#2b4750' face='微软雅黑'>1.4 调大小写</font><a name='1.4'></a>\n",
    "[<font color='black' face='微软雅黑'>回到章首</font>](#1)\n",
    "\n",
    "### 调整大小写 - 调整成想要的格式\n",
    "\n",
    "- `upper()`：大写所有的字母\n",
    "- `lower()`：小写所有的字母\n",
    "- `capitalize()`：大写句首的字母\n",
    "- `title()`：大写每个单词的字母，像标题形式那样"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'PYTHON FOR FINANCE'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = 'python for finance'\n",
    "s.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'python for finance'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python for finance'"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.capitalize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python For Finance'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.title()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color='#2b4750' face='微软雅黑'>1.5 删处补充</font><a name='1.5'></a>\n",
    "[<font color='black' face='微软雅黑'>回到章首</font>](#1)\n",
    "\n",
    "### 删处补充 - 调整成想要的格式\n",
    "\n",
    "**删除**\n",
    "- `strip(d)`：删除句首或句末含`d`的部分\n",
    "- `rstrip(d)`：删除句末含`d`的部分，函数名里 **r** 代表 **right**，从右边删除就是从句末删除\n",
    "- `lstrip(d)`：删除句首含`d`的部分，函数名里 **l** 代表 **left**，从左边删除就是从句首删除"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = '*****Python for finance**'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python for finance'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.strip('*')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'*****Python for finance'"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.rstrip('*')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python for finance**'"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.lstrip('*')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**补充**\n",
    "- `center(n,d)`：用`d`前后补齐字符串，使得其长度为`n`\n",
    "- `rjust(n,d)`：用`d`前补齐字符串，使得其长度为`n`。函数名里 **r** 代表 **right**，将原字符串推向右边\n",
    "- `ljust(n,d)`：用`d`后补齐字符串，使得其长度为`n`。函数名里 **l** 代表 **left**，将原字符串推向左边\n",
    "- `zfill(n)`：等价于`rjust(n,'0')`，因为用 0 前补齐字符串的操作太常见，创建一个专用函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = 'Finance'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'*Finance**'"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.center(10,'*')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'***Finance'"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.rjust(10,'*')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Finance***'"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.ljust(10,'*')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'00001234'"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'1234'.zfill(8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'00001234'"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'1234'.rjust(8,'0')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color='#2b4750' face='微软雅黑'>1.6 格式化</font><a name='1.6'></a>\n",
    "[<font color='black' face='微软雅黑'>回到章首</font>](#1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is an integer 15\n"
     ]
    }
   ],
   "source": [
    "print( f'this is an integer {15:d}' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is an integer   15\n"
     ]
    }
   ],
   "source": [
    "print( f'this is an integer {15:4d}' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is an integer 0015\n"
     ]
    }
   ],
   "source": [
    "print( f'this is an integer {15:04d}' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is a float 83.10\n"
     ]
    }
   ],
   "source": [
    "print( f'this is a float {83.1031:.2f}' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is a float 83.10310000\n"
     ]
    }
   ],
   "source": [
    "print( f'this is a float {83.1031:.8f}' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is a float    83.10\n"
     ]
    }
   ],
   "source": [
    "print( f'this is a float {83.1031:8.2f}' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-47-41403e765b7d>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-47-41403e765b7d>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    print( f'this is a string {'love':10s}' )\u001b[0m\n\u001b[1;37m                                   ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "print( f'this is a string {'love':10s}' )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color='#2b4750' face='微软雅黑'>1.7 运算符</font><a name='1.7'></a>\n",
    "[<font color='black' face='微软雅黑'>回到章首</font>](#1)\n",
    "\n",
    "**算术运算符**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'love you'"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'love' + ' ' + 'you'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'love love love '"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'love '*3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**比较运算符**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Python' > 'R'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Python' >= 'Matlab'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Python' == 'P'+'ython'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Python' != 'python'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**成员运算符**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'P' in 'Python'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'f' not in 'finance'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**身份运算符**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'py' is 'py'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'P' is not 'Python'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <font color='#dc2624' face='微软雅黑'>2. 列表<font><a name='2'></a>\n",
    "[<font color='black' face='微软雅黑'>回到目录</font>](#toc)\n",
    "### <font color='#2b4750' face='微软雅黑'>2.1 创建列表</font><a name='2.1'></a>\n",
    "[<font color='black' face='微软雅黑'>回到章首</font>](#2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [1, 10.31, 'Python']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2365332728520"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 10.31, 'Python']\n"
     ]
    }
   ],
   "source": [
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "查看列表和其元素在内存中的**引用次数**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "88\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "import sys \n",
    "print( sys.getsizeof(l) )\n",
    "print( sys.getrefcount(l) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "28\n",
      "2410\n",
      "24\n",
      "2\n",
      "55\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "print( sys.getsizeof(l[0]) )\n",
    "print( sys.getrefcount(l[0]) )\n",
    "print( sys.getsizeof(l[1]) )\n",
    "print( sys.getrefcount(l[1]) )\n",
    "print( sys.getsizeof(l[2]) )\n",
    "print( sys.getrefcount(l[2]) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "列表还可以用内置函数 `list()` 来创建。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 10.31, 'Python']\n"
     ]
    }
   ],
   "source": [
    "l = list((1, 10.31, 'Python'))\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['P', 'y', 't', 'h', 'o', 'n']\n"
     ]
    }
   ],
   "source": [
    "l = list('Python')\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "列表里的元素可以是不同类型的。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[int, float, str, bool]"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = [1, 10.31, 'Python', True]\n",
    "[type(item) for item in l]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "列表里甚至还可以包含另一个列表。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[int, float, str, bool, list]"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = [1, 10.31, 'Python', True, [1,2,3]]\n",
    "[type(item) for item in l]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "查看**列表**里面的内置属性，可用 `dir(list)` 和 `help(list)`。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color='#2b4750' face='微软雅黑'>2.2 切片和索引</font><a name='2.2'></a>\n",
    "[<font color='black' face='微软雅黑'>回到章首</font>](#2)\n",
    "\n",
    "### 索引"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = [7, 2, 9, 10, 1, 3, 7, 2, 0, 1]\n",
    "l[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l[5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 切片 \n",
    "通用范式 `start:stop:step`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [7, 2, 9, 10, 1, 3, 7, 2, 0, 1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**情况 1**: `start:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[7, 2, 9, 10, 1, 3, 7, 2, 0, 1]\n",
      "[10, 1, 3, 7, 2, 0, 1]\n",
      "[7, 2, 0, 1]\n"
     ]
    }
   ],
   "source": [
    "print( l )\n",
    "print( l[3:] )\n",
    "print( l[-4:] )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**情况 2**: `:stop`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[7, 2, 9, 10, 1, 3, 7, 2, 0, 1]\n",
      "[7, 2]\n",
      "[7, 2, 9, 10, 1, 3]\n"
     ]
    }
   ],
   "source": [
    "print( l )\n",
    "print( l[:2] )\n",
    "print( l[:-4] )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**情况 3**: `start:stop`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[7, 2, 9, 10, 1, 3, 7, 2, 0, 1]\n",
      "[9, 10]\n",
      "[3, 7, 2, 0]\n"
     ]
    }
   ],
   "source": [
    "print( l )\n",
    "print( l[2:4] )\n",
    "print( l[-5:-1] )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**情况 4**: `start:stop:step`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[7, 2, 9, 10, 1, 3, 7, 2, 0, 1]\n",
      "[2, 10]\n",
      "[7, 9, 1]\n",
      "[2, 10, 3, 2, 1]\n",
      "[7, 9, 1, 7, 0]\n",
      "[1, 0, 2, 7, 3, 1, 10, 9, 2, 7]\n"
     ]
    }
   ],
   "source": [
    "print( l )\n",
    "print( l[1:5:2] )\n",
    "print( l[:5:2] )\n",
    "print( l[1::2] )\n",
    "print( l[::2] )\n",
    "print( l[::-1] )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color='#2b4750' face='微软雅黑'>2.3 常用方法</font><a name='2.3'></a>\n",
    "[<font color='black' face='微软雅黑'>回到章首</font>](#2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2365332727176\n"
     ]
    }
   ],
   "source": [
    "l = [1, 10.31, 'Python']\n",
    "print( id(l) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "列表的长度，即包含元素的个数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 加\n",
    "\n",
    "- 从尾部加：`append`, `extend` \n",
    "- 从中间加：`insert`\n",
    "\n",
    "`append(x)` 函数是追加，把参数 `x` **整体**添加在列表尾部"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2365332727176\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[1, 10.31, 'Python', [4, 3]]"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l.append([4, 3])\n",
    "print( id(l) )\n",
    "l"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`extend(x)` 函数是扩展，把参数 `x` 里的**所有元素**添加在列表尾部"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2365332727176\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[1, 10.31, 'Python', [4, 3], True, 'OK']"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l.extend([True, 'OK'])\n",
    "print( id(l) )\n",
    "l"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`insert(i,x)` 函数是在索引 `i` 前插入 `x`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2365332727176\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[1, 'abc', 10.31, 'Python', [4, 3], True, 'OK']"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l.insert(1, 'abc')\n",
    "print( id(l) )\n",
    "l"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 减\n",
    "\n",
    "- 指明要删除的元素：`remove`\n",
    "- 指明要删除的位置：`pop`\n",
    "\n",
    "`remove(x)` 函数删除具体元素 `x`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2365332727176\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[1, 'abc', 10.31, [4, 3], True, 'OK']"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l.remove('Python')\n",
    "print( id(l) )\n",
    "l"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`pop(i)` 函数删除具体索引 `i` 对应的元素，并返回出来"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2365332727176\n",
      "[4, 3]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[1, 'abc', 10.31, True, 'OK']"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = l.pop(3)\n",
    "print( id(l) )\n",
    "print( p )\n",
    "l"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 排\n",
    "\n",
    "- 按照元素大小排序：`sort`\n",
    "- 按照索引大小排序：`reverse`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2365331265224\n",
      "2365331265224\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 5, 7]"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = [7, 2, 5, 1, 3]\n",
    "print( id(l) )\n",
    "l.sort()\n",
    "print( id(l) )\n",
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2365350085832\n",
      "2365350085832\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[7, 5, 3, 2, 1]"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = [7, 2, 5, 1, 3]\n",
    "print( id(l) )\n",
    "l.sort(reverse=True)\n",
    "print( id(l) )\n",
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2365331266568\n",
      "2365331266568\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[3, 1, 5, 2, 7]"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = [7, 2, 5, 1, 3]\n",
    "print( id(l) )\n",
    "l.reverse()\n",
    "print( id(l) )\n",
    "l"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 更\n",
    "\n",
    "更新单值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2365332138952\n",
      "2365332138952\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[7, 2, 100, 1, 3]"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = [7, 2, 5, 1, 3]\n",
    "print( id(l) )\n",
    "l[2] = 100\n",
    "print( id(l) )\n",
    "l"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "更新多值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2365332138952\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[7, 0, 0, 0, 3]"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l[1:4] = [0,0,0]\n",
    "print( id(l) )\n",
    "l"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "列表是**可修改的**，对列表进行一系列“加减排更”的操作，发现修改前后的列表的 id 没有变。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color='#2b4750' face='微软雅黑'>2.4 运算符</font><a name='2.4'></a>\n",
    "[<font color='black' face='微软雅黑'>回到章首</font>](#2)\n",
    "\n",
    "**算术运算符**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 10.31, 'Python', 'Finance', None, 'OK']"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1, 10.31, 'Python'] + ['Finance', None] + ['OK']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['OK', 'OK', 'OK']"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "['OK']*3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**比较运算符**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "['Finance', 11] > ['Data', 11]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "['Finance', 11] > ['Finance', 10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "['Finance', 11] == ['Finance', 11]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**成员运算符**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 in [1, 10.31, 'Python']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'python' not in [1, 10.31, 'Python']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**身份运算符**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "['Finance', 11] is ['Finance', 11]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "l1 = ['Finance', 11]\n",
    "l2 = ['Finance', 11]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2365331257160\n",
      "2365331276360\n"
     ]
    }
   ],
   "source": [
    "print(id(l1))\n",
    "print(id(l2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2365331257160\n"
     ]
    }
   ],
   "source": [
    "l3 = l1\n",
    "print(id(l3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l1 is l3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l1 is l2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <font color='#dc2624' face='微软雅黑'>3. 元组</font><a name='3'></a>\n",
    "[<font color='black' face='微软雅黑'>回到目录</font>](#toc)\n",
    "### <font color='#2b4750' face='微软雅黑'>3.1 创建元组</font><a name='3.1'></a>\n",
    "[<font color='black' face='微软雅黑'>回到章首</font>](#3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 10.31, 'Python') <class 'tuple'>\n",
      "(1, 10.31, 'Python') <class 'tuple'>\n",
      "(1, 10.31, 'Python') <class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "t1 = (1, 10.31, 'Python')\n",
    "print( t1, type(t1) )\n",
    "\n",
    "t2 = 1, 10.31, 'Python'\n",
    "print( t2, type(t2) )\n",
    "\n",
    "t3 = tuple((1, 10.31, 'Python'))\n",
    "print( t3, type(t3) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ID: 2365350104736\n",
      "Type: <class 'tuple'>\n",
      "Value: (1, 10.31, 'Python')\n"
     ]
    }
   ],
   "source": [
    "t = (1, 10.31, 'Python')\n",
    "print( 'ID:', id(t) )\n",
    "print( 'Type:', type(t) )\n",
    "print( 'Value:', t )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "查看**元组**里面的内置属性，可用 `dir(tuple)` 和 `help(tuple)`。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.count('Python')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.index('Python')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color='#2b4750' face='微软雅黑'>3.2 索引和切片</font><a name='3.2'></a>\n",
    "[<font color='black' face='微软雅黑'>回到章首</font>](#3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 <class 'int'>\n",
      "10.31 <class 'float'>\n",
      "Python <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "print( t[0], type(t[0]) )\n",
    "print( t[1], type(t[1]) )\n",
    "print( t[2], type(t[2]) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 10.31) <class 'tuple'>\n",
      "(10.31, 'Python') <class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "print( t[0:2], type(t[0:2]) )\n",
    "print( t[1:], type(t[1:]) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color='#2b4750' face='微软雅黑'>3.3 不可修改</font><a name='3.3'></a>\n",
    "[<font color='black' face='微软雅黑'>回到章首</font>](#3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = (3, 2, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-108-88963aa635fa>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mt\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m10\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "t[0] = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t.append(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'tuple' object has no attribute 'remove'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-109-a109db24f957>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mremove\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m: 'tuple' object has no attribute 'remove'"
     ]
    }
   ],
   "source": [
    "t.remove(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'tuple' object has no attribute 'sort'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-110-42b32fd31977>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msort\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m: 'tuple' object has no attribute 'sort'"
     ]
    }
   ],
   "source": [
    "t.sort()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "虽然元组里的元素不能更改，但是可以重新赋值整个元组，我们发现**旧元组**和**新元组**是两个不同的对象，可从 `id()` 来验证。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2365349768216"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = (3, 2, 1)\n",
    "id(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2365333154984"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = (10, 2, 1)\n",
    "id(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "和元组不同，列表里的元素可以更改，更改其元素前后的列表还是指向同一地址。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2365331265544"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = [3, 2, 1]\n",
    "id(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2365331265544"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l[0] = 10\n",
    "id(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2365350304968"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = [10, 2, 1]\n",
    "id(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color='#2b4750' face='微软雅黑'>3.4 打散赋值</font><a name='3.4'></a>\n",
    "[<font color='black' face='微软雅黑'>回到章首</font>](#3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "a, b = 1, 2\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "a, _ = 1, 2\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "not enough values to unpack (expected 3, got 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-118-9dbc59cfd6c6>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0ma\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mb\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mc\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m: not enough values to unpack (expected 3, got 2)"
     ]
    }
   ],
   "source": [
    "a, b, c = 1, 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "[]\n"
     ]
    }
   ],
   "source": [
    "a, b, *c = 1, 2\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "[3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "a, b, *c = 1, 2, 3, 4, 5\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "[3, 4]\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "a, b, *c, d = 1, 2, 3, 4, 5\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "a, b, *_, d = 1, 2, 3, 4, 5\n",
    "print(a)\n",
    "print(b)\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color='#2b4750' face='微软雅黑'>3.5 运算符</font><a name='3.5'></a>\n",
    "[<font color='black' face='微软雅黑'>回到章首</font>](#3)\n",
    "\n",
    "**算术运算符**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate tuple (not \"str\") to tuple",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-123-904f62da6647>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m10.31\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'Python'\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m+\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m'Finance'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m+\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m'OK'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: can only concatenate tuple (not \"str\") to tuple"
     ]
    }
   ],
   "source": [
    "(1, 10.31, 'Python') + ('Finance', None) + ('OK')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "print( type(('OK')) )\n",
    "print( type(('OK',)) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 10.31, 'Python', 'Finance', None, 'OK')"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1, 10.31, 'Python') + ('Finance', None) + ('OK',)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('OK', 'OK', 'OK')"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "('OK',)*3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**比较运算符**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(0, 1, 2) < (5, 1, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(0, 1, 2000000) < (0, 3, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "('Financial','Math') > ('Financial', 'Mathematics')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "('Financial','Math') > ('Applied', 'Math')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**成员运算符**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**身份运算符**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "('Finance', 11) is ('Finance', 11)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [],
   "source": [
    "t1 = ('Finance', 11)\n",
    "t2 = ('Finance', 11)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2365331239112\n",
      "2365331229256\n"
     ]
    }
   ],
   "source": [
    "print(id(t1))\n",
    "print(id(t2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [],
   "source": [
    "t3 = t1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2365331239112\n"
     ]
    }
   ],
   "source": [
    "print(id(t3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t1 is t3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t1 is t2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "元组 Vs 列表：元组和列表对决实际上是**不可修改对象**和**可修改对象**的对决。\n",
    "\n",
    "1. **运行效率**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "941 µs ± 27.8 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "l = []\n",
    "x = range(10000)\n",
    "\n",
    "for item in x:\n",
    "    l.append(item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "167 ms ± 5.01 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "t = ()\n",
    "x = range(10000)\n",
    "\n",
    "for item in x:\n",
    "    t = t +(item,)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. **查错难度**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-10, 3, 5, 7]"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [1, 3, 5, 7]\n",
    "b = a\n",
    "b[0] = -10\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. **内存存储**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "90112\n",
      "80048\n"
     ]
    }
   ],
   "source": [
    "from sys import getsizeof\n",
    "l = list(range(10000))\n",
    "t = tuple(range(10000))\n",
    "print( getsizeof(l) )\n",
    "print( getsizeof(t) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <font color='#dc2624' face='微软雅黑'>4. 字典</font><a name='4'></a>\n",
    "[<font color='black' face='微软雅黑'>回到目录</font>](#toc)\n",
    "### <font color='#2b4750' face='微软雅黑'>4.1 创建</font><a name='4.1'></a>\n",
    "[<font color='black' face='微软雅黑'>回到章首</font>](#4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = {\n",
    "'名字' : '海底捞',\n",
    "'代号' : '06862',\n",
    "'行业' : '食品',\n",
    "'价格' : 29.1,\n",
    "'单位' : 'HKD'\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ID: 2365350209864\n",
      "Type: <class 'dict'>\n",
      "Value: {'名字': '海底捞', '代号': '06862', '行业': '食品', '价格': 29.1, '单位': 'HKD'}\n"
     ]
    }
   ],
   "source": [
    "print( 'ID:', id(d) )\n",
    "print( 'Type:', type(d) )\n",
    "print( 'Value:', d )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "查看**字典**里面的内置属性，可用 `dir(dict)` 和 `help(dict)`。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['名字', '代号', '行业', '价格', '单位'])\n",
      "dict_values(['海底捞', '06862', '食品', 29.1, 'HKD'])\n",
      "dict_items([('名字', '海底捞'), ('代号', '06862'), ('行业', '食品'), ('价格', 29.1), ('单位', 'HKD')])\n"
     ]
    }
   ],
   "source": [
    "print( d.keys() )\n",
    "print( d.values() )\n",
    "print( d.items() )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color='#2b4750' face='微软雅黑'>4.2 索引</font><a name='4.2'></a>\n",
    "[<font color='black' face='微软雅黑'>回到章首</font>](#4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "29.1"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d['价格']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'名字': '海底捞', '代号': '06862', '行业': '食品', '价格': 30.1, '单位': 'HKD'}"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d['价格'] = d['价格'] + 1\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color='#2b4750' face='微软雅黑'>4.3 常见方法</font><a name='4.3'></a>\n",
    "[<font color='black' face='微软雅黑'>回到章首</font>](#4)\n",
    "\n",
    "### 添加"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'名字': '海底捞', '代号': '06862', '行业': '食品', '价格': 30.1, '单位': 'HKD', '国家': '中国'}"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d['国家'] = '中国'\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 获取"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'06862'"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.get('代号')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 更新"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'名字': '海底捞',\n",
       " '代号': '06862',\n",
       " '行业': '食品',\n",
       " '价格': 30.2,\n",
       " '单位': 'HKD',\n",
       " '国家': '中国',\n",
       " '董事长': '张勇'}"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.update( {'价格': 30.2, '董事长': '张勇'} )\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 删除"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "张勇\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'名字': '海底捞', '代号': '06862', '行业': '食品', '价格': 30.2, '单位': 'HKD', '国家': '中国'}"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "item = d.pop('董事长')\n",
    "print(item)\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.clear()\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <font color='#dc2624' face='微软雅黑'>5. 集合</font><a name='5'></a>\n",
    "[<font color='black' face='微软雅黑'>回到目录</font>](#toc)\n",
    "### <font color='#2b4750' face='微软雅黑'>5.1 创建</font><a name='5.1'></a>\n",
    "[<font color='black' face='微软雅黑'>回到章首</font>](#5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'d', 'du', 'u', 'ud'}"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = set(['u', 'd', 'ud', 'du', 'd', 'du'])\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'d', 'dd', 'u', 'uu'}"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = set(('d', 'dd', 'uu', 'u'))\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'d', 'dd', 'u', 'uu'}"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C = {'d', 'dd', 'uu', 'u'}\n",
    "C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a', 'c', 'e', 'f', 'i', 'n'}"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D = set( 'finance' )\n",
    "D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "从 A 的结果发现集合的两个特点：**无序性**和**唯一性**。所以我们没法通过索引来访问集合中的元素。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'set' object is not subscriptable",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-156-72ea7112faa4>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mA\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'set' object is not subscriptable"
     ]
    }
   ],
   "source": [
    "A[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ID: 2365350406408\n",
      "Type: <class 'set'>\n",
      "Value: {1, 2, 3}\n"
     ]
    }
   ],
   "source": [
    "s = {3, 2, 1}\n",
    "print( 'ID:', id(s) )\n",
    "print( 'Type:', type(s) )\n",
    "print( 'Value:', s )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "查看**集合**里面的内置属性，可用 `dir(set)` 和 `help(set)`。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 183,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'u' in A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 184,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'du' in B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, None, 'dd', 'uu'}"
      ]
     },
     "execution_count": 185,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C = {1, 'dd', 'uu', None}\n",
    "C"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color='#2b4750' face='微软雅黑'>5.2 集合运算</font><a name='5.2'></a>\n",
    "[<font color='black' face='微软雅黑'>回到章首</font>](#5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = {1, 3, 5, 7, 9}\n",
    "B = {2, 3, 5, 7}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 并集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 5, 7, 9}\n",
      "{1, 2, 3, 5, 7, 9}\n"
     ]
    }
   ],
   "source": [
    "print( A.union(B) )\n",
    "print( A | B )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 交集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{3, 5, 7}\n",
      "{3, 5, 7}\n"
     ]
    }
   ],
   "source": [
    "print( A.intersection(B) )\n",
    "print( A & B )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 补集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 9}\n",
      "{1, 9}\n"
     ]
    }
   ],
   "source": [
    "print( A.difference(B) )\n",
    "print( A - B )  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{2}\n",
      "{2}\n"
     ]
    }
   ],
   "source": [
    "print( B.difference(A) )\n",
    "print( B - A ) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 对称差集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 9}\n",
      "{1, 2, 9}\n",
      "{1, 2, 9}\n",
      "{1, 2, 9}\n"
     ]
    }
   ],
   "source": [
    "print( A.symmetric_difference(B) )\n",
    "print( A ^ B )\n",
    "print( B.symmetric_difference(A) )\n",
    "print( B ^ A )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 互斥"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "C = A - B\n",
    "D = B - A\n",
    "print( C.isdisjoint(D) )\n",
    "print( A.isdisjoint(B) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 超集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print( A.issuperset(C) )\n",
    "print( A >= C )\n",
    "print( A > C )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 子集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print( D.issubset(B) )\n",
    "print( D <= B )\n",
    "print( D < B )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color='#2b4750' face='微软雅黑'>5.3 常见方法</font><a name='5.3'></a>\n",
    "[<font color='black' face='微软雅黑'>回到章首</font>](#5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 更新集合"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A = {1, 3, 5, 7, 9}\n",
      "B = {2, 3, 5, 7}\n"
     ]
    }
   ],
   "source": [
    "print( 'A =', A )\n",
    "print( 'B =', B )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 5, 7, 9}\n",
      "{1, 2, 3, 5, 7, 9}\n"
     ]
    }
   ],
   "source": [
    "A1, A2, = A.copy(), A.copy()\n",
    "A1.update(B)\n",
    "A2 |= B\n",
    "print(A1)\n",
    "print(A2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{3, 5, 7}\n",
      "{3, 5, 7}\n"
     ]
    }
   ],
   "source": [
    "A1, A2, = A.copy(), A.copy()\n",
    "A1.intersection_update(B)\n",
    "A2 &= B\n",
    "print(A1)\n",
    "print(A2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 9}\n",
      "{1, 9}\n"
     ]
    }
   ],
   "source": [
    "A1, A2, = A.copy(), A.copy()\n",
    "A1.difference_update(B)\n",
    "A2 -= B\n",
    "print(A1)\n",
    "print(A2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 9}\n",
      "{1, 2, 9}\n"
     ]
    }
   ],
   "source": [
    "A1, A2, = A.copy(), A.copy()\n",
    "A1.symmetric_difference_update(B)\n",
    "A2 ^= B\n",
    "print(A1)\n",
    "print(A2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 添加元素"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 3, 5, 7, 9}"
      ]
     },
     "execution_count": 200,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`add(x)`: 添加**不可修改**元素 `x`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 3, 5, 7, 9, 11}"
      ]
     },
     "execution_count": 201,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.add(11)\n",
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 删除元素"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`remove(x)`: 删除元素 `x`, 如果该元素不在集合里会报错"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{3, 5, 7, 9, 11}"
      ]
     },
     "execution_count": 202,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.remove(1)\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "2",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-203-0aeaffd8a1d3>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mA\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mremove\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      2\u001b[0m \u001b[0mA\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mKeyError\u001b[0m: 2"
     ]
    }
   ],
   "source": [
    "A.remove(2)\n",
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`discard(x)`: 删除元素 `x`, 如果该元素不在集合里不会报错"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{5, 7, 9, 11}"
      ]
     },
     "execution_count": 204,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.discard(3)\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{5, 7, 9, 11}"
      ]
     },
     "execution_count": 205,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.discard(2)\n",
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`pop()`: 删除任何元素, 如果集合为空会报错"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{7, 9, 11}"
      ]
     },
     "execution_count": 206,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = A.pop()\n",
    "print(p)\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{9, 11}"
      ]
     },
     "execution_count": 207,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = A.pop()\n",
    "print(p)\n",
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`clear()`: 删除所有元素"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "set()"
      ]
     },
     "execution_count": 208,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.clear()\n",
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <font color='#dc2624' face='微软雅黑'>6. Collection</font><a name='6'></a>\n",
    "[<font color='black' face='微软雅黑'>回到目录</font>](#toc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import namedtuple, Counter, defaultdict, OrderedDict, deque, ChainMap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "complex"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(1+1j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color='#2b4750' face='微软雅黑'>6.1 `namedtuple`</font><a name='6.1'></a>\n",
    "[<font color='black' face='微软雅黑'>回到章首</font>](#6)\n",
    "\n",
    "命名元组 (namedtuple) 是元组和字典的混合体，它赋予每个元素含义 (字典的特性)，而且元素不可修改 (元组的特性)。\n",
    "\n",
    "创建**命名元组** \n",
    "\n",
    "两个必需参数：元组名称，字段名称。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "__main__.FP"
      ]
     },
     "execution_count": 210,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "FP = namedtuple('FP', ['asset', 'instrument'])\n",
    "FP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "FP(asset='FX', instrument='European Option')"
      ]
     },
     "execution_count": 211,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "product = FP('FX', 'European Option')\n",
    "product"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "像字典一样查看其键 (用 `_fields`)，像元组一样查看其值的索引 (用 `index`) 和计数 (用 `count`)。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('asset', 'instrument')"
      ]
     },
     "execution_count": 212,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "product._fields"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 213,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "product.index('FX')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 214,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "product.count('FX')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "获取元素有三种方法：\n",
    "- 像元祖那样用数值索引\n",
    "- 像对象那样用点 `.`\n",
    "- 对对象那样用函数 `getattr`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FX\n",
      "FX\n",
      "FX\n"
     ]
    }
   ],
   "source": [
    "print( product[0] )\n",
    "print( product.asset )\n",
    "print( getattr(product, 'asset') ) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "元组不可修改，命名元组也是，应该直接更新其元素会报错。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "can't set attribute",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-216-94d6edcc05b0>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mproduct\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0masset\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m'IR'\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m: can't set attribute"
     ]
    }
   ],
   "source": [
    "product.asset = 'IR'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "但可以用 `_replace` 函数更新其值，并生成新的命名元组。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "FP(asset='CM', instrument='European Option')"
      ]
     },
     "execution_count": 217,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "product = product._replace(asset='CM')\n",
    "product"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "用 `_asdict` 函数可将命名元组转成有序字典"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('asset', 'CM'), ('instrument', 'European Option')])"
      ]
     },
     "execution_count": 218,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "product._asdict()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "用 `_make` 函数创建新的命名元组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "FP(asset='IR', instrument='Basis Swap')"
      ]
     },
     "execution_count": 219,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "product1 = FP._make(['IR', 'Basis Swap'])\n",
    "product1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "还可以用字典打散的形式来创建命名元组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "FP(asset='EQ', instrument='Accumulator')"
      ]
     },
     "execution_count": 220,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "product2 = FP(**{'asset':'EQ', 'instrument':'Accumulator'})\n",
    "product2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color='#2b4750' face='微软雅黑'>6.2 `defaultdict`</font><a name='6.2'></a>\n",
    "[<font color='black' face='微软雅黑'>回到章首</font>](#6)\n",
    "\n",
    "默认字典 (defaultdict) 和字典不同，我们不需要检查**键**是否存在，对于不存在的键，会赋一个默认值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 221,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "issubclass(defaultdict, dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "创建**默认字典** "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "defaultdict(<class 'int'>, {'one': 1, 'two': 2, 'three': 3, 'four': 0})\n"
     ]
    }
   ],
   "source": [
    "nums = defaultdict(int)  \n",
    "nums['one'] = 1\n",
    "nums['two'] = 2\n",
    "nums['three'] = 3 \n",
    "print( nums['four'] )\n",
    "print( nums )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defaultdict(list, {'one': 1, 'missing': [], 'another_missing': [4]})"
      ]
     },
     "execution_count": 223,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def_dict = defaultdict(list)\n",
    "def_dict['one'] = 1\n",
    "def_dict['missing']\n",
    "def_dict['another_missing'].append(4)\n",
    "def_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color='#2b4750' face='微软雅黑'>6.3 `Counter`</font><a name='6.3'></a>\n",
    "[<font color='black' face='微软雅黑'>回到章首</font>]\n",
    "\n",
    "计数器 (Counter) 是字典的子类，提供了可哈希对象的计数功能。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 224,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "issubclass(Counter, dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "创建**计数器**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Counter({2: 4, 1: 3, 3: 2, 4: 1, 6: 1, 7: 1, 8: 1})\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "l = [1,2,3,4,1,2,6,7,3,8,1,2,2]  \n",
    "answer = Counter(l)\n",
    "print(answer)\n",
    "print(answer[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color='#2b4750' face='微软雅黑'>6.4 `deque`</font><a name='6.4'></a>\n",
    "[<font color='black' face='微软雅黑'>回到章首</font>](#6)\n",
    "\n",
    "双端队列 (deque) 可让我们从头/尾两端添加或删除元素。\n",
    "\n",
    "创建**双端队列**。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "deque([1, 10.31, 'Python'])\n"
     ]
    }
   ],
   "source": [
    "deq = deque([1, 10.31, 'Python'])  \n",
    "print(deq)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "前 (`appendleft`) 后 (`append`) 插值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 227,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "deque([True, 1, 10.31, 'Python', 'OK'])\n"
     ]
    }
   ],
   "source": [
    "deq.append('OK')  \n",
    "deq.appendleft(True)  \n",
    "print(deq)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "前 (`extendleft`) 后 (`extend`) 插值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "deque(['I', None, True, 1, 10.31, 'Python', 'OK', 'Go', 0])\n"
     ]
    }
   ],
   "source": [
    "deq.extend(['Go',0])  \n",
    "deq.extendleft([None,'I'])  \n",
    "print(deq)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "前 (`popleft`) 后 (`pop`) 插值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 I\n",
      "deque([None, True, 1, 10.31, 'Python', 'OK', 'Go'])\n"
     ]
    }
   ],
   "source": [
    "p1 = deq.pop()  \n",
    "p2 = deq.popleft()  \n",
    "print(p1, p2)\n",
    "print(deq)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color='#2b4750' face='微软雅黑'>6.5 `ChainMap`</font><a name='6.5'></a>\n",
    "[<font color='black' face='微软雅黑'>回到章首</font>](#6)\n",
    "\n",
    "链式映射 (ChainMap) 可看成字典的容器，将多个映射串联起来，这样它们就可以作为一个单元处理。通常比创建一个新字典和多次调用 `update` 函数要快很多。\n",
    "\n",
    "创建**链式映射**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {},
   "outputs": [],
   "source": [
    "toys = {'San Guo Sha': 30, 'Monopoly': 20}\n",
    "computers = {'Mac': 1000, 'Lenovo': 800, 'Acer': 400}\n",
    "clothing = {'Jeans': 40, 'Tees': 10}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ChainMap({'San Guo Sha': 30, 'Monopoly': 20}, {'Mac': 1000, 'Lenovo': 800, 'Acer': 400}, {'Jeans': 40, 'Tees': 10})"
      ]
     },
     "execution_count": 231,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inventory = ChainMap( toys, computers, clothing )\n",
    "inventory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 232,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inventory['Monopoly']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "metadata": {},
   "outputs": [],
   "source": [
    "inventory.get('Super Mario')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "ChainMap({'Monopoly': 20}, {'Mac': 1000, 'Lenovo': 800, 'Acer': 400}, {'Jeans': 40, 'Tees': 10})"
      ]
     },
     "execution_count": 234,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = inventory.pop('San Guo Sha')\n",
    "print(p)\n",
    "inventory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ChainMap({'Monopoly': 20, 'Nintendo': 200}, {'Mac': 1000, 'Lenovo': 800, 'Acer': 400}, {'Jeans': 40, 'Tees': 10})"
      ]
     },
     "execution_count": 235,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "toys['Nintendo'] = 200\n",
    "inventory"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color='#2b4750' face='微软雅黑'>6.6 `OrderedDict`</font><a name='6.6'></a>\n",
    "[<font color='black' face='微软雅黑'>回到章首</font>](#6)\n",
    "\n",
    "有序字典 (OrderedDict) 是字典的子类，就像常规字典一样，它会记录放入元素的顺序。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 236,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "issubclass(OrderedDict, dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "创建**有序词典**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OrderedDict([('b', 1), ('a', 2), ('c', 3)])\n"
     ]
    }
   ],
   "source": [
    "order = OrderedDict()  \n",
    "order['b'] = 1  \n",
    "order['a'] = 2  \n",
    "order['c'] = 3  \n",
    "print(order)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'b': 1, 'a': 2, 'c': 3}\n"
     ]
    }
   ],
   "source": [
    "unordered = dict()\n",
    "unordered['b'] = 1\n",
    "unordered['a'] = 2\n",
    "unordered['c'] = 3\n",
    "print(unordered)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b : 1\n",
      "a : 2\n",
      "c : 3\n"
     ]
    }
   ],
   "source": [
    "for key in order:\n",
    "    print( key, ':', order[key] )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 240,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c : 3\n",
      "a : 2\n",
      "b : 1\n"
     ]
    }
   ],
   "source": [
    "for key in reversed(order):\n",
    "    print( key, ':', order[key] )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <font color='#dc2624' face='微软雅黑'>7. 习题</font><a name='7'></a>\n",
    "[<font color='black' face='微软雅黑'>回到目录</font>](#toc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 热身：从 words.txt 文档中找出出现次数最多的词和出现的次数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "to 16\n"
     ]
    }
   ],
   "source": [
    "handle = open('words.txt')\n",
    "text = handle.read()\n",
    "words = text.split()\n",
    "\n",
    "counts = dict()\n",
    "for word in words:\n",
    "    counts[word] = counts.get(word,0) + 1\n",
    "\n",
    "bigcount, bigword = None, None\n",
    "for word, count in counts.items():\n",
    "    if bigcount is None or count > bigcount:\n",
    "        bigword = word\n",
    "        bigcount = count\n",
    "\n",
    "print( bigword, bigcount )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "打印出来中间产出 `words`(列表) 和 `counts` (元组) 来验证一下上面程序的结果。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "words"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "counts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 开始作业：\n",
    "\n",
    "仔细看上面例子的文本，我故意把标点符号去掉了，实际文本中肯定有标点符号，这时需要用 `string.punctuation` 来处理。\n",
    "\n",
    "此外英文第一个字母大小写应该指的同一个词，比如 **Math** 和 **math**，这时需要用 `lower()` 来将文本全部转成小写。\n",
    "\n",
    "完成下面的代码，然后从网上找出任何一段英文文本，存成 **.txt** 格式放到你 Jupyter Notebook 运行的主路径下。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import string\n",
    "\n",
    "name = input('输入文件名 (.txt 格式): ')\n",
    "\n",
    "try:\n",
    "    handle = open(name)\n",
    "except:\n",
    "    print('出错了，文件不能打开:', name)\n",
    "    exit()\n",
    "\n",
    "counts = dict()\n",
    "    \n",
    "for line in handle:\n",
    "    translator = str.maketrans('','',string.punctuation)\n",
    "    line = line.translate(translator)\n",
    "    # 在 ... 这里填写你的代码：将字符串所有字符转成小写，用 l 开始的方法\n",
    "    line = ...\n",
    "    # 在 ... 这里填写你的代码：将句子拆分成词，用 s 开头的方法\n",
    "    words = ...\n",
    "\n",
    "    for word in words:\n",
    "        # 在 ... 这里填写你的代码：看上面的例子，用 get() 方法来更新 counts[words]\n",
    "        counts[word] = ...\n",
    "\n",
    "bigcount, bigword = None, None\n",
    "for word, count in counts.items():\n",
    "    if bigcount is None or count > bigcount:\n",
    "        bigword = word\n",
    "        bigcount = count\n",
    "\n",
    "print( bigword, bigcount )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 先不要看答案，自己先思考一下，是在做不出来再看。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import string\n",
    "\n",
    "name = input('输入文件名 (.txt 格式): ')\n",
    "\n",
    "try:\n",
    "    handle = open(name)\n",
    "except:\n",
    "    print('出错了，文件不能打开:', name)\n",
    "    exit()\n",
    "\n",
    "counts = dict()\n",
    "    \n",
    "for line in handle:\n",
    "    # print(line)\n",
    "    translator = str.maketrans('','',string.punctuation)\n",
    "    line = line.translate(translator)\n",
    "    line = line.lower()\n",
    "    words = line.split()\n",
    "\n",
    "    for word in words:\n",
    "        counts[word] = counts.get(word,0) + 1\n",
    "\n",
    "bigcount, bigword = None, None\n",
    "for word, count in counts.items():\n",
    "    if bigcount is None or count > bigcount:\n",
    "        bigword = word\n",
    "        bigcount = count\n",
    "\n",
    "print( bigword, bigcount )"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}