ch02_python基础知识.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 数据对象"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 概述"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "无论是哪种语言，Python、R或是其他的，最好都通过面向数据对象的方法来学习。数据对象，是学习的重点，至于基本语法、逻辑控制，在学习数据对象的过程中，很自然就掌握了。 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " 就Python机器学习、数据挖掘而言，需要重点掌握的数据对象：  \n",
    "* 最基本的列表、元组、字典、集合  \n",
    "* numpy中的ndarray  \n",
    "* pandas模块中的Series以及DataFrame  \n",
    "---\n",
    "<img src=figtabs/ch2/important_data_obj.png align='center' width=50% height=50% />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在学习数据对象相关知识时，也可以温故而知新，相信大家都学习过《数据结构》相关课程。数据结构，旨在将数据有效的组织和存储，可以视为存储数据的容器（container）。  \n",
    "容器基本上也就是可包含其他对象的对象。两种主要的容器是序列（如列表和元组）和映射（如字典）。在序列中，每个元素都有编号，而在映射中，每个元素都有名称（也叫键）。还有一种既不是序列也不是映射的容器，它就是集合（set），一般使用较少。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": false
   },
   "source": [
    "## 序列\n",
    "Python内置了多种序列，最常用的是列表、元组、字符串等。 其中，列表是可以修改的，而元组和字符串不可以修改。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 序列的通用操作"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 序列中的所有元素都有编号——从0开始递增至N-1（假如长度为N的话）。你可像下面这样使用编号来访问各个元素："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:06.552335Z",
     "start_time": "2019-03-18T06:10:06.545338Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'H'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greeting = 'Hello'\n",
    "greeting[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-02-13T04:14:09.163458Z",
     "start_time": "2019-02-13T04:14:09.152461Z"
    }
   },
   "source": [
    "当你使用负数索引时，Python将从右（即从最后一个元素）开始往左数，因此-1是最后一个元素的位置"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:06.656293Z",
     "start_time": "2019-03-18T06:10:06.559330Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'o'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greeting[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:06.777205Z",
     "start_time": "2019-03-18T06:10:06.659272Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greeting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 344,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:15.056654Z",
     "start_time": "2019-03-18T06:10:06.781204Z"
    }
   },
   "outputs": [],
   "source": [
    "# 将以数指定年、月、日的日期打印出来\n",
    "months = [\n",
    "    'January',\n",
    "    'February',\n",
    "    'March',\n",
    "    'April',\n",
    "    'May',\n",
    "    'June',\n",
    "    'July',\n",
    "    'August',\n",
    "    'September',\n",
    "    'October',\n",
    "    'November',\n",
    "    'December'\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 346,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:15.056654Z",
     "start_time": "2019-03-18T06:10:06.781204Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "March 8th, 2013\n"
     ]
    }
   ],
   "source": [
    "# 一个列表，其中包含数1～31对应的结尾\n",
    "endings = ['st', 'nd', 'rd'] + 17 * ['th'] \\\n",
    "    + ['st', 'nd', 'rd'] + 7 * ['th'] \\\n",
    "    + ['st']\n",
    "#year = input('Year: ')\n",
    "year = '2013'\n",
    "#month = input('Month (1-12): ')\n",
    "month = 3\n",
    "#day = input('Day (1-31): ')\n",
    "day = '8'\n",
    "month_number = int(month)\n",
    "day_number = int(day)\n",
    "\n",
    "# 别忘了将表示月和日的数减1，这样才能得到正确的索引\n",
    "month_name = months[month_number-1]\n",
    "ordinal = day + endings[day_number-1]\n",
    "print(month_name + ' ' + ordinal + ', ' + year)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font size = 2 face = '微软雅黑'>***切片***</font>\n",
    "\n",
    "---\n",
    "\n",
    "除使用索引来访问单个元素外，还可使用切片（slicing）来访问特定范围内的元素"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:15.070652Z",
     "start_time": "2019-03-18T06:10:15.062649Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'http://www.python.org'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tag = '<a href=\"http://www.python.org\">Python web site</a>'\n",
    "tag[9:30]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:15.166591Z",
     "start_time": "2019-03-18T06:10:15.074643Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python web site'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tag[32:-4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "切片适用于提取序列的一部分，其中的编号非常重要：  \n",
    "> 第一个索引是包含的第一个元素的编号，但第二个索引是切片后余下的第一个元素的编号。换言之，切片是左闭右开的，第一个索引指定的元素包含在切片内，但第二个索引指定的元素不包含在切片内"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-21T04:28:37.777689Z",
     "start_time": "2019-03-21T04:28:37.771693Z"
    }
   },
   "outputs": [],
   "source": [
    "numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "关于左闭右开原则的一些说明：<br/>\n",
    "1. 当只有最后一个位置信息时，我们也可以快速看出切片和区间里有几个元素：range(3) 和 my_list[:3] 都返回 3 个元素  \n",
    "2. 当起止位置信息都可见时，我们可以快速计算出切片和区间的长度，用后一个数减去第一个下标（stop - start）即可  \n",
    "3. 这样做也让我们可以利用任意一个下标来把序列分割成不重叠的两部分，只要写成my_list[:x] 和 my_list[x:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "前n个元素："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-21T04:28:51.021400Z",
     "start_time": "2019-03-21T04:28:51.013406Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers[:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "后n个元素："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-21T04:29:11.196215Z",
     "start_time": "2019-03-21T04:29:11.189222Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[8, 9, 10]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers[-3:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "奇数项："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-21T04:29:59.647549Z",
     "start_time": "2019-03-21T04:29:59.625752Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5, 7, 9]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers[::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "偶数项："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-21T04:30:29.780992Z",
     "start_time": "2019-03-21T04:30:29.773998Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6, 8, 10]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers[1::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "注意左闭右开："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:15.367475Z",
     "start_time": "2019-03-18T06:10:15.280524Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers[0:1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:15.477430Z",
     "start_time": "2019-03-18T06:10:15.371472Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers[3:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-02-13T15:26:24.537549Z",
     "start_time": "2019-02-13T15:26:24.528554Z"
    }
   },
   "source": [
    "假设你要访问前述数字列表中的最后三个元素，显然可以明确地指定这一点。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:15.567379Z",
     "start_time": "2019-03-18T06:10:15.480412Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[8, 9, 10]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " numbers[7:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果要从列表末尾开始数，更好的做法是使用负数索引。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:15.678298Z",
     "start_time": "2019-03-18T06:10:15.570360Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[8, 9]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers[-3:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果切片结束于序列末尾，可省略第二个索引。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:15.789234Z",
     "start_time": "2019-03-18T06:10:15.681296Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[8, 9, 10]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers[-3:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "同样，如果切片始于序列开头，可省略第一个索引。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:15.899171Z",
     "start_time": "2019-03-18T06:10:15.792232Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers[:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "实际上，要复制整个序列，可将两个索引都省略。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:15.989120Z",
     "start_time": "2019-03-18T06:10:15.901169Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers[:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font size = 2 face = '微软雅黑'>***更大的步长***</font>\n",
    "\n",
    "---\n",
    "\n",
    "在普通切片中，步长为1。这意味着从一个元素移到下一个元素，因此切片包含起点和终点之间的所有元素。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:16.067073Z",
     "start_time": "2019-03-18T06:10:15.992117Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers[0:10:1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果指定的步长大于1，将跳过一些元素。例如，步长为2时，将从起点和终点之间每隔一个元素提取一个元素。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:16.211939Z",
     "start_time": "2019-03-18T06:10:16.070073Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5, 7, 9]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers[0:10:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "显式地指定步长时，也可使用前述简写。例如，要从序列中每隔3个元素提取1个，只需提供步长4即可。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:16.340826Z",
     "start_time": "2019-03-18T06:10:16.214938Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 5, 9]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers[::4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "步长不能为0，否则无法向前移动，但可以为负数，即从右向左提取元素。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:16.442901Z",
     "start_time": "2019-03-18T06:10:16.348819Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[9, 8, 7, 6, 5]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers[8:3:-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:16.521856Z",
     "start_time": "2019-03-18T06:10:16.445899Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 8, 6, 4, 2]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers[10:0:-2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:16.622127Z",
     "start_time": "2019-03-18T06:10:16.524853Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 8, 6, 4, 2]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers[::-2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:16.720363Z",
     "start_time": "2019-03-18T06:10:16.625129Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[6, 4, 2]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers[5::-2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:16.833238Z",
     "start_time": "2019-03-18T06:10:16.722362Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 8]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers[:5:-2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "反向"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers[-1::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font size = 2 face = '微软雅黑'>***序列相加***</font>  \n",
    "\n",
    "***\n",
    "\n",
    "可使用加法运算符来拼接序列"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:16.952422Z",
     "start_time": "2019-03-18T06:10:16.836237Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1, 2, 3] + [4, 5, 6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:17.056362Z",
     "start_time": "2019-03-18T06:10:16.970412Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello world'"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"hello \" + 'world'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "容易看出，这里边的“+”，与通常意义上的加法并不是一回事。背后的机制是操作符重载，就像R语言中ggplot2包重新定义+这个二元操作符函数类似。感兴趣的同学可以查阅相关资料，也可以自行定义一些类，增加\\_\\_add\\_\\_等“魔法”。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font size = 2 face = '微软雅黑'>***乘法***</font>\n",
    "\n",
    "---\n",
    "\n",
    "将序列与数x相乘时，将重复这个序列x次来创建一个新序列："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:17.167300Z",
     "start_time": "2019-03-18T06:10:17.061361Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1] * 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:17.277239Z",
     "start_time": "2019-03-18T06:10:17.170297Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 1, 2, 3]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1, 2, 3] * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "之前有R语言基础的同学，可能期待的结果是向量化运算的结果[2, 4, 6]，不过没关系，等到下一章节讲到numpy等科学计算相关内容时，熟悉的内容又会回来。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:17.389173Z",
     "start_time": "2019-03-18T06:10:17.280236Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\n重要的事情说三遍\\n重要的事情说三遍\\n重要的事情说三遍'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'\\n重要的事情说三遍' * 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:17.510104Z",
     "start_time": "2019-03-18T06:10:17.392170Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "重要的事情说三遍\n",
      "重要的事情说三遍\n",
      "重要的事情说三遍\n"
     ]
    }
   ],
   "source": [
    "print('\\n重要的事情说三遍' * 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**None 、空列表和初始化**  \n",
    "空列表是使用不包含任何内容的两个方括号（ [] ）表示的。如果要创建一个可包含10个元素\n",
    "的列表，但没有任何有用的内容，可像前面那样使用 [42]*10 。但更准确的做法是使用 [0]*10 ，这将创建一个包含10个零的列表。然而，在有些情况下，你可能想使用表示“什么都没有”的值，如表示还没有在列表中添加任何内容。在这种情况下，可使用 None 。在Python中， None 表示什么都没有。因此，要将列表的长度初始化为10，可像下面这样做："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:17.622057Z",
     "start_time": "2019-03-18T06:10:17.513101Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[None, None, None, None, None, None, None, None, None, None]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sequence = [None] * 10\n",
    "sequence"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font size = 2 face = '微软雅黑'>***成员资格***</font>\n",
    "\n",
    "---\n",
    "\n",
    "要检查特定的值是否包含在序列中，可使用运算符 in"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:17.732974Z",
     "start_time": "2019-03-18T06:10:17.625038Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "permissions = 'rw'\n",
    "'w' in permissions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:17.845910Z",
     "start_time": "2019-03-18T06:10:17.734974Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'x' in permissions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font  size = 2 face = '微软雅黑'>***长度、最小值和最大值***</font>\n",
    "\n",
    "---\n",
    "\n",
    "内置函数 len 、 min 和 max 很有用，其中函数 len 返回序列包含的元素个数，而 min 和 max 分别返回序列中最小和最大的元素"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:17.953853Z",
     "start_time": "2019-03-18T06:10:17.848909Z"
    }
   },
   "outputs": [],
   "source": [
    "numbers = [100, 34, 678]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:18.055790Z",
     "start_time": "2019-03-18T06:10:17.956847Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "678"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max(numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:18.164729Z",
     "start_time": "2019-03-18T06:10:18.057789Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "34"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min(numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:18.313414Z",
     "start_time": "2019-03-18T06:10:18.166726Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 列表：Python 的主力"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "列表创建的形式：  \n",
    "\\<list> = \\<list>\\[from_inclusive : to_exclusive : ±step_size]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font size = 2 face = '微软雅黑'>***函数list***</font>\n",
    "\n",
    "---\n",
    "\n",
    "鉴于不能像修改列表那样修改字符串，因此在有些情况下使用字符串来创建列表"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:18.498682Z",
     "start_time": "2019-03-18T06:10:18.321405Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['H', 'e', 'l', 'l', 'o']"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " list('Hello')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 314,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 9)"
      ]
     },
     "execution_count": 314,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 315,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8]"
      ]
     },
     "execution_count": 315,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(9))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "反过来，要将字符列表（如前述代码中的字符列表）转换为字符串，可使用下面的表达式"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:18.613899Z",
     "start_time": "2019-03-18T06:10:18.509961Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello'"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chars = list('hello')\n",
    "''.join(chars)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "当然，我们可将任何序列（而不仅仅是字符串）作为 list 的参数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font size = 2 face = '微软雅黑'>***列表的基本操作***</font>\n",
    "\n",
    "---\n",
    "\n",
    "可对列表执行所有的标准序列操作，如索引、切片、拼接和相乘，但列表的有趣之处在于它\n",
    "是可以修改的。本节将介绍一些修改列表的方式：给元素赋值、删除元素、给切片赋值以及使用列表的方法。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 修改列表：给元素赋值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:18.721794Z",
     "start_time": "2019-03-18T06:10:18.617916Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 1]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = [1, 1, 1]\n",
    "x[1] = 2\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*  删除元素"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:18.832757Z",
     "start_time": "2019-03-18T06:10:18.724792Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['张三', '李四', '赵五']"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names = ['张三', '丰', '李四', '赵五']\n",
    "del names[1]\n",
    "names"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-02-13T16:05:45.145175Z",
     "start_time": "2019-02-13T16:05:45.088222Z"
    }
   },
   "source": [
    "* 给切片赋值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:18.945811Z",
     "start_time": "2019-03-18T06:10:18.835771Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['P', 'e', 'r', 'l']"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name = list('Perl')\n",
    "name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:19.060823Z",
     "start_time": "2019-03-18T06:10:18.949808Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['P', 'e', 'a', 'r']"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name[2:] = list('ar')\n",
    "name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:19.166882Z",
     "start_time": "2019-03-18T06:10:19.066820Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['P', 'y', 't', 'h', 'o', 'n']"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name = list('Perl')\n",
    "name[1:] = list('ython')\n",
    "name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 317,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:19.277360Z",
     "start_time": "2019-03-18T06:10:19.169879Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['1', 2, 3, 4, 5, '2']"
      ]
     },
     "execution_count": 317,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers = ['1', '2']\n",
    "numbers[1:1] = [2, 3, 4, 5]\n",
    "numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:19.389398Z",
     "start_time": "2019-03-18T06:10:19.284356Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 5, 6]"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers[1:4] = []\n",
    "numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font size = 2 face = '微软雅黑'>***列表的方法***</font>\n",
    "\n",
    "---\n",
    "\n",
    "方法是与对象（列表、数、字符串等）联系紧密的函数。通常，像下面这样调用方法：\n",
    "object.method(arguments)  \n",
    "方法调用与函数调用很像，只是在方法名前加上了对象和句点"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* append"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:19.477412Z",
     "start_time": "2019-03-18T06:10:19.391396Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst = [1, 2, 3]\n",
    "lst.append(4)\n",
    "lst"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* clear"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:19.556367Z",
     "start_time": "2019-03-18T06:10:19.480409Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst.clear()\n",
    "lst"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 318,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:19.666485Z",
     "start_time": "2019-03-18T06:10:19.558364Z"
    }
   },
   "outputs": [],
   "source": [
    "a = [1, 2, 3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 319,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:19.666485Z",
     "start_time": "2019-03-18T06:10:19.558364Z"
    }
   },
   "outputs": [],
   "source": [
    "b = a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 320,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1910522782152"
      ]
     },
     "execution_count": 320,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 321,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1910522782152"
      ]
     },
     "execution_count": 321,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:19.666485Z",
     "start_time": "2019-03-18T06:10:19.558364Z"
    }
   },
   "outputs": [],
   "source": [
    "b[0] = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:19.666485Z",
     "start_time": "2019-03-18T06:10:19.558364Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 2, 3]"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 322,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:19.797037Z",
     "start_time": "2019-03-18T06:10:19.670485Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 322,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [1, 2, 3]\n",
    "b = a.copy()\n",
    "b[0] = 3\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 324,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "id of a is 1910523226632, and id of b is 1910504017096\n"
     ]
    }
   ],
   "source": [
    "print('id of a is {}, and id of b is {}'.format(id(a), id(b)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:19.888002Z",
     "start_time": "2019-03-18T06:10:19.802032Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "['to', 'be', 'or', 'not', 'to', 'be'].count('to')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* extend"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:20.001232Z",
     "start_time": "2019-03-18T06:10:19.889981Z"
    }
   },
   "outputs": [],
   "source": [
    "a = [1, 2, 3]\n",
    "b = [4, 5, 6]\n",
    "a.extend(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:20.098211Z",
     "start_time": "2019-03-18T06:10:20.001232Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:20.211145Z",
     "start_time": "2019-03-18T06:10:20.101209Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [1, 2, 3]\n",
    "b = [4, 5, 6]\n",
    "a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:20.321808Z",
     "start_time": "2019-03-18T06:10:20.214144Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:20.410831Z",
     "start_time": "2019-03-18T06:10:20.324807Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tobe = ['to', 'be', 'or', 'not', 'to', 'be']\n",
    "tobe.index('be')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* insert"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:20.510463Z",
     "start_time": "2019-03-18T06:10:20.413828Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 'four', 5, 6, 7]"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers = [1, 2, 3, 5, 6, 7]\n",
    "numbers.insert(3, 'four')\n",
    "numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* pop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 325,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:20.622359Z",
     "start_time": "2019-03-18T06:10:20.513477Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 325,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = [1, 2, 3]\n",
    "x.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:20.747357Z",
     "start_time": "2019-03-18T06:10:20.624360Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2]"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 326,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:20.622359Z",
     "start_time": "2019-03-18T06:10:20.513477Z"
    }
   },
   "outputs": [],
   "source": [
    "x = [1, 2, 3]\n",
    "y = x.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 327,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2]"
      ]
     },
     "execution_count": 327,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 328,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 328,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-02-13T16:18:08.929005Z",
     "start_time": "2019-02-13T16:18:08.920014Z"
    }
   },
   "source": [
    "注意：pop 是唯一既修改列表又返回一个非 None 值的列表方法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* remove"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:20.866305Z",
     "start_time": "2019-03-18T06:10:20.758351Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['to', 'or', 'not', 'to', 'be']"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = ['to', 'be', 'or', 'not', 'to', 'be']\n",
    "x.remove('be')\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* reverse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:20.977411Z",
     "start_time": "2019-03-18T06:10:20.871285Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 2, 1]"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = [1, 2, 3]\n",
    "x.reverse()\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* sort"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:10:21.099459Z",
     "start_time": "2019-03-18T06:10:20.980412Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 1, 2, 3, 4, 5, 6, 9]"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = [3, 1, 4, 1, 5, 9, 2, 6]\n",
    "x.sort()\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:11:05.013377Z",
     "start_time": "2019-03-18T06:11:04.890447Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[1;31mSignature:\u001b[0m \u001b[0mx\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[0mkey\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mreverse\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mFalse\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
       "\u001b[1;31mDocstring:\u001b[0m Stable sort *IN PLACE*.\n",
       "\u001b[1;31mType:\u001b[0m      builtin_function_or_method\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x.sort"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:46.805362Z",
     "start_time": "2019-03-18T05:00:46.699241Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 1, 2, 3, 4, 5, 6, 9]"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:46.916271Z",
     "start_time": "2019-03-18T05:00:46.809357Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "y = x.sort()\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:47.014729Z",
     "start_time": "2019-03-18T05:00:46.920270Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 1, 2, 3, 4, 5, 6, 9]\n"
     ]
    }
   ],
   "source": [
    "y = sorted(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:47.141564Z",
     "start_time": "2019-03-18T05:00:47.018728Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['BC', 'ABC', 'CDB', 'ICBC']"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "banks = ['ICBC', 'BC', 'ABC', 'CDB']\n",
    "banks.sort(key = len)\n",
    "banks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:47.224515Z",
     "start_time": "2019-03-18T05:00:47.152556Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[9, 6, 5, 4, 3, 2, 1, 1]"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.sort(reverse = True)\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "由于列表是可修改的，前述的lst.append()、x.sort()都没有返回值，都是就地（inplace）修改——pop是为数不多的例外，既有返回值，又就地修改。为了加深印象，联想成把原对象就地正法、然后洗心革面也可以。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 元组：不可修改的序列\n",
    "与列表一样，元组也是序列，唯一的差别在于元组是不能修改的（字符串也不能修改）。元组语法很简单，只要将一些值用逗号分隔，就能自动创建一个元组。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:47.305886Z",
     "start_time": "2019-03-18T05:00:47.229509Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4, 5, 6)"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tup = 4, 5, 6\n",
    "tup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:16:17.659309Z",
     "start_time": "2019-03-18T06:16:17.655316Z"
    }
   },
   "outputs": [],
   "source": [
    "tup_x = 1,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:16:18.708711Z",
     "start_time": "2019-03-18T06:16:18.700716Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1,)"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tup_x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "元组还可用圆括号括起（这也是通常采用的做法）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:47.439936Z",
     "start_time": "2019-03-18T05:00:47.308866Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3)"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1, 2, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "空元组用两个不包含任何内容的圆括号表示"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:47.551867Z",
     "start_time": "2019-03-18T05:00:47.446928Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如何表示只包含一个值的元组呢？这有点特殊：虽然只有一个值，也必须在它\n",
    "后面加上逗号"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:47.675798Z",
     "start_time": "2019-03-18T05:00:47.554865Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2012,)"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2012,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:47.792730Z",
     "start_time": "2019-03-18T05:00:47.692788Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2012,)"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(2012,)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:47.872683Z",
     "start_time": "2019-03-18T05:00:47.800726Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2012"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(2012)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "函数 tuple 的工作原理与 list 很像：它将一个序列作为参数，并将其转换为元组。如果参数已经是元组，就原封不动地返回它。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:47.973628Z",
     "start_time": "2019-03-18T05:00:47.874682Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3)"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple([1, 2, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:48.094559Z",
     "start_time": "2019-03-18T05:00:47.976626Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3)"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple((1, 2, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:48.182508Z",
     "start_time": "2019-03-18T05:00:48.098555Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('我', '爱', '北', '京', '天', '安', '门')"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple('我爱北京天安门')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:48.263478Z",
     "start_time": "2019-03-18T05:00:48.184504Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3)"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple((1, 2, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "元组并不太复杂，而且除创建和访问其元素外，可对元组执行的操作不多。元组的创建及其元素的访问方式与其他序列相同。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:48.372399Z",
     "start_time": "2019-03-18T05:00:48.266458Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 1, 2, 3\n",
    "x[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:48.506339Z",
     "start_time": "2019-03-18T05:00:48.375395Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2)"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[0:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 列表与元组对比"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "相同点：<br>\n",
    "* both lists and tuples are containers, a sequence of objects\n",
    "* Either can have elements of any type, even within a single sequence.\n",
    "* Both maintain the order of the elements (unlike sets and dicts)\n",
    "\n",
    "---\n",
    "\n",
    "不同点：<br>\n",
    "* Technical Difference between lists and tuples is that lists are mutable (can be changed) and tuples are immutable (cannot be changed). \n",
    "* The Cultural Difference is about how lists and tuples are actually used: lists are used where you have a homogenous sequence of unknown length; tuples are used where you know the number of elements in advance because the position of the element is semantically significant.\n",
    "* a list is an arbitrary number of similar things; a tuple is one thing with a known number of (possibly dissimilar) parts.\n",
    "* lists are like arrays, tuples are like structs\n",
    "\n",
    "---\n",
    "\n",
    "For the most part, you should choose whether to use a list or a tuple based on the Cultural Difference. Think about what your data means. If it can have different lengths based on what your program encounters in the real world, then it is probably a list. If you know when you write the code what the third element means, then it is probably a tuple."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 字符串"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "所有标准序列操作（索引、切片、乘法、成员资格检查、长度、最小值和最\n",
    "大值）都适用于字符串，但别忘了字符串是不可变的，因此所有的元素赋值和切片赋值都是非\n",
    "法的。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:48.629269Z",
     "start_time": "2019-03-18T05:00:48.508319Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'org'"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "website = 'http://www.python.org'\n",
    "website[-3:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:48.750181Z",
     "start_time": "2019-03-18T05:00:48.631249Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(website)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font size = 2 face = '微软雅黑'>***设置字符串的格式***</font>\n",
    "\n",
    "---\n",
    "\n",
    "将值转换为字符串并设置其格式是一个重要的操作，Python提供了多种字符串格式设置方法。<font color =\"red\">*以前*</font>，主要的解决方案是使用字符串格式设置运算符——百分号。这个运算符的行为类似于C语言中的经典函数 printf ：在 % 左边指定一个字符串（格式字符串），并在右边指定要设置其格式的值。指定要设置其格式的值时，可使用单个值（如字符串或数字），可使用元组（如果要设置多个值的格式），还可使用字典，其中最常见的是元组。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:48.884104Z",
     "start_time": "2019-03-18T05:00:48.753180Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello, world. Hot enough for you?'"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "format = \"Hello, %s. %s enough for you?\"\n",
    "values = ('world', 'Hot')\n",
    "format % values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上述格式字符串中的 s % 称为转换说明符，指出了要将值插入什么地方。 s 意味着将值视为字\n",
    "符串进行格式设置。如果指定的值不是字符串，将使用 str 将其转换为字符串。其他说明符将导\n",
    "致其他形式的转换。例如， .3f % 将值的格式设置为包含3位小数的浮点数。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "另一种解决方案是所谓的模板字符串"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:49.005036Z",
     "start_time": "2019-03-18T05:00:48.887102Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello, Mars! Dusty enough for you?'"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from string import Template\n",
    "tmpl = Template(\"Hello, $who! $what enough for you?\")\n",
    "tmpl.substitute(who=\"Mars\", what=\"Dusty\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "前面这两段代码，大家只要能看懂就行，即便不会使用，关系也不大，但是现在用得更多的是字符串方法format ，它融合并强化了早期方法的优点。使用这种方法时，每个替换字段都用花括号括起，其中可能包含名称，还可能包含有关如何对相应的值进行转换和格式设置的信息"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:49.129965Z",
     "start_time": "2019-03-18T05:00:49.008035Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'first, second and third'"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"{}, {} and {}\".format(\"first\", \"second\", \"third\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:49.249895Z",
     "start_time": "2019-03-18T05:00:49.133962Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'to be or not to be'"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"{3} {0} {2} {1} {3} {0}\".format(\"be\", \"not\", \"or\", \"to\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 329,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:26:08.203829Z",
     "start_time": "2019-03-18T06:26:08.195834Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'π is approximately 3.14.'"
      ]
     },
     "execution_count": 329,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import pi\n",
    "\"{name} is approximately {value:.2f}.\".format(value=pi, name=\"π\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果变量与替换字段同名，还可使用一种简写。在这种情况下，可使用 f 字符串——在字符串前面加上 f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:49.484762Z",
     "start_time": "2019-03-18T05:00:49.364829Z"
    }
   },
   "outputs": [],
   "source": [
    "from math import e"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:49.484762Z",
     "start_time": "2019-03-18T05:00:49.364829Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Euler's constant is roughly 2.718281828459045.\""
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f\"Euler's constant is roughly {e}.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在最简单的情况下，只需向 format 提供要设置其格式的未命名参数，并在格式字符串中使用\n",
    "未命名字段。此时，将按顺序将字段和参数配对。你还可给参数指定名称，这种参数将被用于相\n",
    "应的替换字段中。你可混合使用这两种方法。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:49.608693Z",
     "start_time": "2019-03-18T05:00:49.486758Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'3 1 4 2'"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"{foo} {} {bar} {}\".format(1, 2, bar=4, foo=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "还可通过索引来指定要在哪个字段中使用相应的未命名参数，这样可不按顺序使用未命名\n",
    "参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:49.751608Z",
     "start_time": "2019-03-18T05:00:49.612687Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'3 2 4 1'"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"{foo} {1} {bar} {0}\".format(1, 2, bar=4, foo=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "设置浮点数（或其他更具体的小数类型）的格式时，默认在小数点后面显示6位小数，并根据需要设置字段的宽度，而不进行任何形式的填充。当然，这种默认设置可能不是你想要的，在这种情况下，可根据需要在格式说明中指定宽度和精度。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:49.873540Z",
     "start_time": "2019-03-18T05:00:49.753607Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'         3'"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"{num:10}\".format(num=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:49.984477Z",
     "start_time": "2019-03-18T05:00:49.876537Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Bob       '"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"{name:10}\".format(name=\"Bob\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "精度也是使用整数指定的，但需要在它前面加上一个表示小数点的句点。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:50.117417Z",
     "start_time": "2019-03-18T05:00:49.987474Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Pi day is 3.14'"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Pi day is {pi:.2f}\".format(pi=pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "当然，可同时指定宽度和精度"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:50.283303Z",
     "start_time": "2019-03-18T05:00:50.120397Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'      3.14'"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"{pi:10.2f}\".format(pi=pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可使用逗号来指出要添加千位分隔符"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:50.439214Z",
     "start_time": "2019-03-18T05:00:50.286302Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'One googol is 10,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000'"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'One googol is {:,}'.format(10**100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在指定宽度和精度的数前面，可添加一个标志。这个标志可以是零、加号、减号或空格，其中零表示使用0来填充数字。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:50.584149Z",
     "start_time": "2019-03-18T05:00:50.442212Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0000003.14'"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'{:010.2f}'.format(pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "要指定左对齐、右对齐和居中，可分别使用 < 、 > 和 ^ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:50.705063Z",
     "start_time": "2019-03-18T05:00:50.587129Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.14      \n",
      "   3.14   \n",
      "      3.14\n"
     ]
    }
   ],
   "source": [
    "print('{0:<10.2f}\\n{0:^10.2f}\\n{0:>10.2f}'.format(pi))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以使用填充字符来扩充对齐说明符，这样将使用指定的字符而不是默认的空格来填充"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:50.816997Z",
     "start_time": "2019-03-18T05:00:50.708062Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'$$$ WIN BIG $$$'"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"{:$^15}\".format(\" WIN BIG \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果要给正数加上符号，可使用说明符 + （将其放在对齐说明符后面），而不是默认的 - 。如\n",
    "果将符号说明符指定为空格，会在正数前面加上空格而不是 + "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:50.938929Z",
     "start_time": "2019-03-18T05:00:50.818996Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.1\n",
      "-3.1\n"
     ]
    }
   ],
   "source": [
    "print('{0:-.2}\\n{1:-.2}'.format(pi, -pi)) #默认设置"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:51.038870Z",
     "start_time": "2019-03-18T05:00:50.942925Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+3.1\n",
      "-3.1\n"
     ]
    }
   ],
   "source": [
    " print('{0:+.2}\\n{1:+.2}'.format(pi, -pi))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:51.149808Z",
     "start_time": "2019-03-18T05:00:51.041869Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 3.1\n",
      "-3.1\n"
     ]
    }
   ],
   "source": [
    "print('{0: .2}\\n{1: .2}'.format(pi, -pi))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font  size = 2 face = '微软雅黑'>***字符串方法***</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* center: 通过在两边添加填充字符（默认为空格）让字符串居中。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:51.261744Z",
     "start_time": "2019-03-18T05:00:51.152806Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'     The Middle by Jimmy Eat World     '"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " \"The Middle by Jimmy Eat World\".center(39)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* find: 在字符串中查找子串。如果找到，就返回子串的第一个字符的索引，否则返回 -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:51.371682Z",
     "start_time": "2019-03-18T05:00:51.263742Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " 'With a moo-moo here, and a moo-moo there'.find('moo')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* join: 一个非常重要的字符串方法，其作用与 split 相反，用于合并序列的元素"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:51.474624Z",
     "start_time": "2019-03-18T05:00:51.374678Z"
    }
   },
   "outputs": [],
   "source": [
    "seq = ['1', '2', '3', '4', '5']\n",
    "sep = '+'\n",
    "sep.join(seq) # 合并一个字符串列表"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 330,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:51.474624Z",
     "start_time": "2019-03-18T05:00:51.374678Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'12345'"
      ]
     },
     "execution_count": 330,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seq = ['1', '2', '3', '4', '5']\n",
    "sep = ''\n",
    "sep.join(seq) # 合并一个字符串列表"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:51.584559Z",
     "start_time": "2019-03-18T05:00:51.477620Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/usr/bin/env'"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dirs = '', 'usr', 'bin', 'env'\n",
    "'/'.join(dirs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:51.705490Z",
     "start_time": "2019-03-18T05:00:51.586558Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C:\\usr\\bin\\env\n"
     ]
    }
   ],
   "source": [
    "print('C:' + '\\\\'.join(dirs))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* lower:  返回字符串的小写版本"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:51.816426Z",
     "start_time": "2019-03-18T05:00:51.708487Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'trondheim hammer dance'"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Trondheim Hammer Dance'.lower()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*  title: 将字符串转换为词首大写，即所有单词的首字母都大写，其他字母都小写"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:51.927362Z",
     "start_time": "2019-03-18T05:00:51.818424Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"That'S All Folks\""
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"that's all folks\".title()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "另一种方法是使用模块 string 中的函数 capwords"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:52.050293Z",
     "start_time": "2019-03-18T05:00:51.929362Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"That's All, Folks\""
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import string\n",
    "string.capwords(\"that's all, folks\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* replace:  将指定子串都替换为另一个字符串，并返回替换后的结果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:52.163227Z",
     "start_time": "2019-03-18T05:00:52.053294Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Theez eez a test'"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'This is a test'.replace('is', 'eez')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* split: 一个非常重要的字符串方法，其作用与 join 相反，用于将字符串拆分为序列"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:52.260174Z",
     "start_time": "2019-03-18T05:00:52.166226Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['1', '2', '3', '4', '5']"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'1+2+3+4+5'.split('+')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:52.362114Z",
     "start_time": "2019-03-18T05:00:52.263172Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['', 'usr', 'bin', 'env']"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'/usr/bin/env'.split('/')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* strip: 将字符串开头和末尾的空白（但不包括中间的空白）删除，并返回删除后的结果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:52.472056Z",
     "start_time": "2019-03-18T05:00:52.365114Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'internal whitespace is kept'"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "' internal whitespace is kept '.strip()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "判断字符串是否满足特定的条件： isalnum 、 isalpha 、 isdecimal 、 isdigit 、 isidentifier 、 islower 、 isnumeric 、isprintable 、 isspace 、 istitle 、 isupper "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:52.584004Z",
     "start_time": "2019-03-18T05:00:52.475048Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'3.14159'.isalnum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:52.705916Z",
     "start_time": "2019-03-18T05:00:52.586985Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'314159'.isalnum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "算术运算，一般都是用于数值，比如\"1\" / \"2\"显然是不允许的。不过Python里边，+和*对于字符串而言是有意义的"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'我爱你，中国'"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'我爱你，' + \"中国\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "重要的事情说三遍\n",
      "重要的事情说三遍\n",
      "重要的事情说三遍\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print('重要的事情说三遍\\n'*3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "显然，这里的加号和乘号，无非是拼接和重复而已，与算术运算并无关系。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 可变与不可变对象"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-21T00:48:15.104721Z",
     "start_time": "2019-03-21T00:48:15.100721Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "y = x\n",
    "x = 2\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-21T00:48:52.613699Z",
     "start_time": "2019-03-21T00:48:52.607704Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "x = [1]*3\n",
    "y = x\n",
    "x[1] = 2\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-21T00:49:59.579875Z",
     "start_time": "2019-03-21T00:49:59.572882Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 1, 1, 2, 2, 2)\n",
      "(1, 1, 1)\n"
     ]
    }
   ],
   "source": [
    "x = (1,) * 3\n",
    "y = x\n",
    "x = x + (2,) * 3\n",
    "print(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='white'>上述代码容易让人误以为对于可变和不可变对象而言，赋值操作是不一样的。实际上，赋值只是把左侧的name与右侧的value进行了绑定而已，对于可变或是不可变对象而言，完全一样。不一样的地方，是右侧的value是否就地进行了修改，若是就地修改的话，则y和x都指向同一个value，这个value变了，透过x和y这两双眼睛都能看到在变；若不是就地修改，显然这两双眼睛看到的是不一样的。</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": false
   },
   "source": [
    "## 映射"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "字典是Python中唯一的内置映射类型，其中的值不按顺序排列，而是存储在键下。键可能是数、字符串或元组。  \n",
    "字典的名称指出了这种数据结构的用途。普通图书适合按从头到尾的顺序阅读，如果你愿意，可快速翻到任何一页，这有点像Python中的列表。字典（日常生活中的字典和Python字典）旨在让你能够轻松地找到特定的单词（键），以获悉其定义（值）。  \n",
    "\n",
    "---\n",
    "\n",
    "在很多情况下，使用字典都比使用列表更合适。下面是Python字典的一些用途：\n",
    "* 表示棋盘的状态，其中每个键都是由坐标组成的元组；\n",
    "* 存储文件修改时间，其中的键为文件名；\n",
    "* 数字电话/地址簿。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "假设有如下名单："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:52.815856Z",
     "start_time": "2019-03-18T05:00:52.707915Z"
    }
   },
   "outputs": [],
   "source": [
    "names = ['Alice', 'Beth', 'Cecil', 'Dee-Dee', 'Earl']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果要创建一个小型数据库，在其中存储这些人的电话号码，该如何办呢？一种办法是再创建一个列表。假设只存储四位的分机号，这个列表将类似于："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:52.914797Z",
     "start_time": "2019-03-18T05:00:52.818852Z"
    }
   },
   "outputs": [],
   "source": [
    "numbers = ['2341', '9102', '3158', '0142', '5551']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "创建这些列表后，就可像下面这样查找Cecil的电话号码："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:53.028732Z",
     "start_time": "2019-03-18T05:00:52.916796Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'3158'"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers[names.index('Cecil')]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这可行，但不太实用。实际上，你希望能够像下面这样做：  \n",
    "\\>>> phonebook['Cecil']  \n",
    "'3158'  \n",
    "如何达成这个目标呢？只要 phonebook 是个字典就行了。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 创建和使用字典"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "字典由键及其相应的值组成，这种键-值对称为项（item）。在前面的示例中，键为名字，而值为电话号码。每个键与其值之间都用冒号（ : ）分隔，项之间用逗号分隔，而整个字典放在花括号内。空字典（没有任何项）用两个花括号表示，类似于下面这样： {} 。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:53.184641Z",
     "start_time": "2019-03-18T05:00:53.030730Z"
    }
   },
   "outputs": [],
   "source": [
    "phonebook = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可使用函数 dict从其他映射（如其他字典）或键值对序列创建字典。  \n",
    "> 与 list、tuple 和 str 一样， dict 其实根本就不是函数，而是一个类\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:53.396521Z",
     "start_time": "2019-03-18T05:00:53.187643Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'Gumby', 'age': 42}"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "items = [('name', 'Gumby'), ('age', 42)]\n",
    "d = dict(items)\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:53.572420Z",
     "start_time": "2019-03-18T05:00:53.399520Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Gumby'"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d['name']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "还可使用关键字实参来调用这个函数，如下所示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:53.683358Z",
     "start_time": "2019-03-18T05:00:53.575419Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'Gumby', 'age': 42}"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = dict(name='Gumby', age=42)\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 字典的基本操作"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "字典的基本行为在很多方面都类似于序列。  \n",
    "* len(d) 返回字典 d 包含的项（键-值对）数。\n",
    "* d[k] 返回与键 k 相关联的值。\n",
    "* d[k] = v 将值 v 关联到键 k 。\n",
    "* del d[k] 删除键为 k 的项。\n",
    "* k in d 检查字典 d 是否包含键为 k 的项。\n",
    "\n",
    "虽然字典和列表有多个相同之处，但也有一些重要的不同之处。\n",
    "* 键的类型：字典中的键可以是整数，但并非必须是整数。字典中的键可以是任何不可变的类型，如浮点数（实数）、字符串或元组。\n",
    "* 自动添加：即便是字典中原本没有的键，也可以给它赋值，这将在字典中创建一个新项。然而，如果不使用 append 或其他类似的方法，就不能给列表中没有的元素赋值。\n",
    "* 成员资格：表达式 k in d （其中 d 是一个字典）查找的是键而不是值，而表达式 v in l （其中 l 是一个列表）查找的是值而不是索引。这看似不太一致，但你习惯后就会觉得相当自然。毕竟如果字典包含指定的键，检查相应的值就很容易。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:53.783300Z",
     "start_time": "2019-03-18T05:00:53.685357Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{42: 'Foobar'}"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = {}\n",
    "x[42] = 'Foobar'\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 将字符串格式设置功能用于字典"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可使用字符串格式设置功能来设置值的格式，这些值是作为命名或非命名参数提供给方法 format 的。在有些情况下，通过在字典中存储一系列命名的值，可让格式设置更容易些。例如，可在字典中包含各种信息，这样只需在格式字符串中提取所需的信息即可。为此，必须使用 format_map 来指出你将通过一个映射来提供所需的信息。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:53.862273Z",
     "start_time": "2019-03-18T05:00:53.786298Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "phonebook"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:53.973192Z",
     "start_time": "2019-03-18T05:00:53.865252Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Cecil's phone number is 3258.\""
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Cecil's phone number is {Cecil}.\".format_map(phonebook)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 字典方法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* clear：方法 clear 删除所有的字典项，这种操作是<font color = 'red'>就地执行</font>的（就像 list.sort 一样），因此什么都不返回（或者说返回 None ）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:54.084127Z",
     "start_time": "2019-03-18T05:00:53.975189Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'Gumby', 'age': 42}"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = {}\n",
    "d['name'] = 'Gumby'\n",
    "d['age'] = 42\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:54.197064Z",
     "start_time": "2019-03-18T05:00:54.087128Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "returned_value = d.clear()\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:54.305002Z",
     "start_time": "2019-03-18T05:00:54.202060Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "print(returned_value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:54.429948Z",
     "start_time": "2019-03-18T05:00:54.308002Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'key': 'value'}"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = {}\n",
    "y = x\n",
    "x['key'] = 'value'\n",
    "x = {}\n",
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:54.594836Z",
     "start_time": "2019-03-18T05:00:54.432928Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = {}\n",
    "y = x\n",
    "x['key'] = 'value'\n",
    "x.clear()\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-02-14T02:00:21.089369Z",
     "start_time": "2019-02-14T02:00:21.079373Z"
    }
   },
   "source": [
    "* copy:方法 copy 返回一个新字典，其包含的键-值对与原来的字典相同（这个方法执行的是浅复制，\n",
    "因为值本身是原件，而非副本）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:54.705772Z",
     "start_time": "2019-03-18T05:00:54.597833Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'username': 'admin', 'machines': ['foo', 'baz']}"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = {'username': 'admin', 'machines': ['foo', 'bar', 'baz']}\n",
    "y = x.copy()\n",
    "y['username'] = 'mlh'\n",
    "y['machines'].remove('bar')\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "当替换副本中的值时，原件不受影响。然而，如果修改副本中的值（就地修改而\n",
    "不是替换），原件也将发生变化，因为原件指向的也是被修改的值（如这个示例中的 'machines'列表所示）。  \n",
    "为避免这种问题，一种办法是执行深复制，即同时复制值及其包含的所有值，等等。为此，可使用模块 copy 中的函数 deepcopy 。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:54.837696Z",
     "start_time": "2019-03-18T05:00:54.708770Z"
    }
   },
   "outputs": [],
   "source": [
    "from copy import deepcopy\n",
    "d = {}\n",
    "d['names'] = ['Alfred', 'Bertrand']\n",
    "c = d.copy()\n",
    "dc = deepcopy(d)\n",
    "d['names'].append('Clive')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:54.962625Z",
     "start_time": "2019-03-18T05:00:54.840695Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'names': ['Alfred', 'Bertrand', 'Clive']}"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:55.083558Z",
     "start_time": "2019-03-18T05:00:54.966623Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'names': ['Alfred', 'Bertrand']}"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*  fromkeys: 创建一个新字典，其中包含指定的键，且每个键对应的值都是 None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:55.217481Z",
     "start_time": "2019-03-18T05:00:55.086554Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': None, 'age': None}"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{}.fromkeys(['name', 'age'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:55.340408Z",
     "start_time": "2019-03-18T05:00:55.220477Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': None, 'age': None}"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict.fromkeys(['name', 'age'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果你不想使用默认值 None ，可提供特定的值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:55.472333Z",
     "start_time": "2019-03-18T05:00:55.343406Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': '(unknown)', 'age': '(unknown)'}"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict.fromkeys(['name', 'age'], '(unknown)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-02-14T02:04:34.635516Z",
     "start_time": "2019-02-14T02:04:34.628524Z"
    }
   },
   "source": [
    "* get: 方法 get 为访问字典项提供了宽松的环境。通常，如果你试图访问字典中没有的项，将引发错误。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:55.595262Z",
     "start_time": "2019-03-18T05:00:55.475332Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "kitty\n"
     ]
    }
   ],
   "source": [
    "d = {'name': 'kitty', 'sex':'female'}\n",
    "print(d['name'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 331,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:55.595262Z",
     "start_time": "2019-03-18T05:00:55.475332Z"
    }
   },
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'axb'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-331-717968216ad4>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0md\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m{\u001b[0m\u001b[1;34m'name'\u001b[0m\u001b[1;33m:\u001b[0m \u001b[1;34m'kitty'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'sex'\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;34m'female'\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0md\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'axb'\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;31mKeyError\u001b[0m: 'axb'"
     ]
    }
   ],
   "source": [
    "d = {'name': 'kitty', 'sex':'female'}\n",
    "print(d['axb'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 332,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:55.595262Z",
     "start_time": "2019-03-18T05:00:55.475332Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "d = {'name': 'kitty', 'sex':'female'}\n",
    "print(d.get('axb'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:55.727187Z",
     "start_time": "2019-03-18T05:00:55.598260Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "kitty\n"
     ]
    }
   ],
   "source": [
    "print(d.get('name'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:55.869106Z",
     "start_time": "2019-03-18T05:00:55.730185Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'kitty'"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.get('name', 'N/A')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:55.984039Z",
     "start_time": "2019-03-18T05:00:55.872104Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Eric'"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d['name'] = 'Eric'\n",
    "d.get('name')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*  items: 方法 items 返回一个包含所有字典项的列表，其中每个元素都为 (key, value) 的形式。字典项在列表中的排列顺序不确定"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:56.091979Z",
     "start_time": "2019-03-18T05:00:55.987038Z"
    }
   },
   "outputs": [],
   "source": [
    "d = {'title': 'Python Web Site', 'url': 'http://www.python.org', 'spam': 0}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:56.194921Z",
     "start_time": "2019-03-18T05:00:56.094976Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_items([('title', 'Python Web Site'), ('url', 'http://www.python.org'), ('spam', 0)])"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.items()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "返回值属于一种名为字典视图的特殊类型。字典视图可用于迭代"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "另外，你还可确定其长度以及对其执行成员资格检查。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:56.295881Z",
     "start_time": "2019-03-18T05:00:56.197917Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "it = d.items()\n",
    "len(it)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:56.417809Z",
     "start_time": "2019-03-18T05:00:56.297859Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "('spam', 0) in it"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*  keys:方法 keys 返回一个字典视图，其中包含指定字典中的键"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:56.529727Z",
     "start_time": "2019-03-18T05:00:56.419790Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['title', 'url', 'spam'])"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* pop:用于获取与指定键相关联的值，并将该键值对从字典中删除"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:56.666661Z",
     "start_time": "2019-03-18T05:00:56.532727Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = {'x': 1, 'y': 2}\n",
    "d.pop('x')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-02-14T02:11:03.247399Z",
     "start_time": "2019-02-14T02:11:03.237405Z"
    }
   },
   "source": [
    "*  popitem: 类似于 list.pop ，但 list.pop 弹出列表中的最后一个元素，而 popitem 随机地弹出一个字典项，因为字典项的顺序是不确定的，没有“最后一个元素”的概念。如果你要以高效地方式逐个删除并处理所有字典项，这可能很有用，因为这样无需先获取键列表"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:56.833580Z",
     "start_time": "2019-03-18T05:00:56.670646Z"
    }
   },
   "outputs": [],
   "source": [
    "d = {'url': 'http://www.python.org', \n",
    "     'spam': 0, \n",
    "     'title': 'Python Web Site'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:56.911718Z",
     "start_time": "2019-03-18T05:00:56.833580Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('title', 'Python Web Site')"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.popitem()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:57.161686Z",
     "start_time": "2019-03-18T05:00:56.911718Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'url': 'http://www.python.org', 'spam': 0}"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* update:  使用一个字典中的项来更新另一个字典"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:57.393720Z",
     "start_time": "2019-03-18T05:00:57.161686Z"
    }
   },
   "outputs": [],
   "source": [
    "d = {\n",
    "    'title': 'Python Web Site',\n",
    "    'url': 'http://www.python.org',\n",
    "    'changed': 'Mar 14 22:09:15 MET 2016'\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:57.493662Z",
     "start_time": "2019-03-18T05:00:57.398721Z"
    }
   },
   "outputs": [],
   "source": [
    "x = {'title': 'Python Language Website'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:57.584776Z",
     "start_time": "2019-03-18T05:00:57.495661Z"
    }
   },
   "outputs": [],
   "source": [
    "d.update(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:57.685070Z",
     "start_time": "2019-03-18T05:00:57.584776Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'title': 'Python Language Website',\n",
       " 'url': 'http://www.python.org',\n",
       " 'changed': 'Mar 14 22:09:15 MET 2016'}"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-02-14T02:15:24.293567Z",
     "start_time": "2019-02-14T02:15:24.284578Z"
    }
   },
   "source": [
    "* values: 方法 values 返回一个由字典中的值组成的字典视图。不同于方法 keys ，方法 values 返回的视图可能包含重复的值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:57.809069Z",
     "start_time": "2019-03-18T05:00:57.688069Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values([1, 2, 3, 1])"
      ]
     },
     "execution_count": 170,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = {}\n",
    "d[1] = 1\n",
    "d[2] = 2\n",
    "d[3] = 3\n",
    "d[4] = 1\n",
    "d.values()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 集合"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "很久以前，集合是由模块 sets 中的 Set 类实现的。在较新的版本中，集合是由内置类 set 实现的，这意味着你可直接创建集合，而无需导入模块 sets 。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:57.934352Z",
     "start_time": "2019-03-18T05:00:57.815068Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}"
      ]
     },
     "execution_count": 171,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set(range(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可使用序列（或其他可迭代对象）来创建集合，也可使用花括号显式地指定。请注意，不能仅使用花括号来创建空集合，因为这将创建一个空字典。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:58.027399Z",
     "start_time": "2019-03-18T05:00:57.942446Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type({})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "相反，必须在不提供任何参数的情况下调用 set 。集合主要用于成员资格检查，因此将忽略重复的元素："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:58.196301Z",
     "start_time": "2019-03-18T05:00:58.029395Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0, 1, 2, 3, 4, 5}"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{0, 1, 2, 3, 0, 1, 2, 3, 4, 5}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-21T04:24:04.725407Z",
     "start_time": "2019-03-21T04:24:04.710418Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4}"
      ]
     },
     "execution_count": 174,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_set = {1, 2, 1, 2, 3, 4}\n",
    "my_set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "与字典一样，集合中元素的排列顺序是不确定的，因此不能依赖于这一点。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:58.305434Z",
     "start_time": "2019-03-18T05:00:58.199299Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'fee', 'fie', 'foe'}"
      ]
     },
     "execution_count": 175,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{'fee', 'fie', 'foe'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "除成员资格检查外，还可执行各种标准集合操作，如并集和交集。例如，要计算两个集合的并集，可对其中一个集合调用方法 union ，也可使用按位或运算符 | 。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:58.417190Z",
     "start_time": "2019-03-18T05:00:58.308432Z"
    }
   },
   "outputs": [],
   "source": [
    "a = {1, 2, 3}\n",
    "b = {2, 3, 4}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:58.535233Z",
     "start_time": "2019-03-18T05:00:58.417190Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4}"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.union(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:58.618611Z",
     "start_time": "2019-03-18T05:00:58.542656Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4}"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a | b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "还有其他一些方法和对应的运算符："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:58.731980Z",
     "start_time": "2019-03-18T05:00:58.622610Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2, 3}"
      ]
     },
     "execution_count": 179,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = a & b\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:58.840899Z",
     "start_time": "2019-03-18T05:00:58.735964Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2, 3}"
      ]
     },
     "execution_count": 180,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.intersection(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:58.921852Z",
     "start_time": "2019-03-18T05:00:58.843897Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 181,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c.issubset(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:58.997809Z",
     "start_time": "2019-03-18T05:00:58.924851Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 182,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c.issuperset(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:59.291207Z",
     "start_time": "2019-03-18T05:00:59.000808Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 183,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c >= a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:59.417133Z",
     "start_time": "2019-03-18T05:00:59.297205Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1}"
      ]
     },
     "execution_count": 184,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.difference(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:59.539063Z",
     "start_time": "2019-03-18T05:00:59.420131Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1}"
      ]
     },
     "execution_count": 185,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a - b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:59.641003Z",
     "start_time": "2019-03-18T05:00:59.542060Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 4}"
      ]
     },
     "execution_count": 186,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.symmetric_difference(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:59.754958Z",
     "start_time": "2019-03-18T05:00:59.645000Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3}"
      ]
     },
     "execution_count": 187,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:00:59.860877Z",
     "start_time": "2019-03-18T05:00:59.758938Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 188,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.copy() is a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "集合是可变的，因此不能用作字典中的键。另一个问题是，集合只能包含不可变（可散列）的值，因此不能包含其他集合。由于在现实世界中经常会遇到集合的集合，因此这可能是个问题。所幸还有 frozenset 类型，它表示不可变（可散列）的集合。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:01:00.000834Z",
     "start_time": "2019-03-18T05:00:59.863878Z"
    }
   },
   "outputs": [],
   "source": [
    "a = set()\n",
    "b = set()\n",
    "# 以下代码有误\n",
    "#a.add(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:01:00.118770Z",
     "start_time": "2019-03-18T05:01:00.011830Z"
    }
   },
   "outputs": [],
   "source": [
    "a.add(frozenset(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T05:01:00.308657Z",
     "start_time": "2019-03-18T05:01:00.122763Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{frozenset()}"
      ]
     },
     "execution_count": 191,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": false
   },
   "source": [
    "# 程序控制结构和函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": false
   },
   "source": [
    "## 程序控制结构"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 条件和条件语句"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "标准值 False 和 None 、各种类型（包括浮点数、复数等）的数值0、空序列（如空字符串、空元组和空列表）以及空映射（如空字典）都被视为假，而其他各种值都被视为真，包括特殊值 True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:29:38.751836Z",
     "start_time": "2019-03-11T02:29:38.739841Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 192,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True == 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:29:38.884757Z",
     "start_time": "2019-03-11T02:29:38.755831Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 193,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "False == 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:29:39.019680Z",
     "start_time": "2019-03-11T02:29:38.889754Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "43"
      ]
     },
     "execution_count": 194,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True + False + 42"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:29:39.139612Z",
     "start_time": "2019-03-11T02:29:39.023677Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 195,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool('I think, therefore I am')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:29:39.241552Z",
     "start_time": "2019-03-11T02:29:39.143608Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 196,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool('')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:29:39.350492Z",
     "start_time": "2019-03-11T02:29:39.244551Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 197,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool({})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 有条件地执行和 if 语句"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 333,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:56:23.125478Z",
     "start_time": "2019-03-18T06:56:16.315342Z"
    }
   },
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "What is your name?  Leenet Gumby\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Mr. Gumby\n"
     ]
    }
   ],
   "source": [
    "name = input('What is your name? ')\n",
    "if name.endswith('Gumby'):\n",
    "    print('Hello, Mr. Gumby')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-02-14T02:28:19.727417Z",
     "start_time": "2019-02-14T02:28:19.718426Z"
    }
   },
   "source": [
    "* else子句"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:09.395048Z",
     "start_time": "2019-03-11T02:29:54.453561Z"
    }
   },
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "What is your name? Xinbo Ai\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, stranger\n"
     ]
    }
   ],
   "source": [
    "name = input('What is your name?')\n",
    "if name.endswith('Gumby'):\n",
    "    print('Hello, Mr. Gumby')\n",
    "else:\n",
    "    print('Hello, stranger')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "还有一个与 if 语句很像的“亲戚”，它就是条件表达式——C语言中三目运算符的Python版本。\n",
    "下面的表达式使用 if 和 else 确定其值："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:09.410039Z",
     "start_time": "2019-03-11T02:30:09.405042Z"
    }
   },
   "outputs": [],
   "source": [
    "status = \"friend\" if name.endswith(\"Gumby\") else \"stranger\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* elif 子句"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:19.809769Z",
     "start_time": "2019-03-11T02:30:09.421033Z"
    }
   },
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number:  -1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number is negative\n"
     ]
    }
   ],
   "source": [
    "num = int(input('Enter a number: '))\n",
    "if num > 0:\n",
    "    print('The number is positive')\n",
    "elif num < 0:\n",
    "    print('The number is negative')\n",
    "else:\n",
    "    print('The number is zero')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:35.301923Z",
     "start_time": "2019-03-11T02:30:19.813767Z"
    }
   },
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "What is your name?  Xinbo\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, stranger\n"
     ]
    }
   ],
   "source": [
    "name = input('What is your name? ')\n",
    "if name.endswith('Gumby'):\n",
    "    if name.startswith('Mr.'):\n",
    "        print('Hello, Mr. Gumby')\n",
    "    elif name.startswith('Mrs.'):\n",
    "        print('Hello, Mrs. Gumby')\n",
    "    else:\n",
    "        print('Hello, Gumby')\n",
    "else:\n",
    "    print('Hello, stranger')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:35.312918Z",
     "start_time": "2019-03-11T02:30:35.305921Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 203,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"foo\" == \"foo\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:35.441862Z",
     "start_time": "2019-03-11T02:30:35.315918Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 204,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"foo\" == \"bar\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:35.551779Z",
     "start_time": "2019-03-11T02:30:35.444842Z"
    }
   },
   "outputs": [],
   "source": [
    "x = y = [1, 2, 3]\n",
    "z = [1, 2, 3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:35.663245Z",
     "start_time": "2019-03-11T02:30:35.554778Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 206,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x == y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:35.776197Z",
     "start_time": "2019-03-11T02:30:35.673242Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 207,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x == z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:35.885134Z",
     "start_time": "2019-03-11T02:30:35.779177Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 208,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x is y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:36.010212Z",
     "start_time": "2019-03-11T02:30:35.888114Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 209,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x is z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:42.115857Z",
     "start_time": "2019-03-11T02:30:36.013211Z"
    }
   },
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number between 1 and 10:  9\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Great!\n"
     ]
    }
   ],
   "source": [
    "number = int(input('Enter a number between 1 and 10: '))\n",
    "if number <= 10 and number >= 1:\n",
    "    print('Great!')\n",
    "else:\n",
    "    print('Wrong!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:45.054181Z",
     "start_time": "2019-03-11T02:30:42.119855Z"
    }
   },
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number between 1 and 10:  11\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wrong!\n"
     ]
    }
   ],
   "source": [
    "number = int(input('Enter a number between 1 and 10: '))\n",
    "if 1 <= number <= 10:\n",
    "    print('Great!')\n",
    "else:\n",
    "    print('Wrong!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 循环"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* while循环"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:45.066175Z",
     "start_time": "2019-03-11T02:30:45.058182Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n",
      "11\n",
      "12\n",
      "13\n",
      "14\n",
      "15\n"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "while x <= 15:\n",
    "    print(x)\n",
    "    x += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 281,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T06:37:58.264924Z",
     "start_time": "2019-03-25T06:37:47.867079Z"
    }
   },
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Input : 30\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Try Again\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Input : 57\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Try Again\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Input : 20\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Try Again\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Input : 50\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "yes\n"
     ]
    }
   ],
   "source": [
    "TrueAge = 50\n",
    "while True:\n",
    "    Age = input(\"Input :\")\n",
    "    if Age.isdigit():\n",
    "        Age = eval(Age)\n",
    "        if Age == TrueAge:\n",
    "            print(\"yes\")\n",
    "            break\n",
    "        else:\n",
    "            print(\"Try Again\")\n",
    "    else:\n",
    "        print(\"Input Number\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "下边我们通过循环来逼近e"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 385,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i = 10000, error = 1.359223000818588e-08, e = 2.7181459268249255\n",
      "i = 20000, error = 3.398272330201735e-09, e = 2.718213874533619\n",
      "i = 30000, error = 1.5172032519217282e-09, e = 2.718236525145871\n",
      "i = 40000, error = 8.527676342851009e-10, e = 2.7182478507085106\n",
      "i = 50000, error = 5.40039568619477e-10, e = 2.718254646126732\n",
      "i = 60000, error = 4.045799251173321e-10, e = 2.7182591764743544\n",
      "i = 70000, error = 2.813855815020361e-10, e = 2.7182624124202643\n",
      "i = 80000, error = 2.2385426845517031e-10, e = 2.7182648393859488\n",
      "i = 90000, error = 1.7495560555857992e-10, e = 2.71826672706495\n",
      "i = 100000, error = 1.6406254133016773e-10, e = 2.7182682371922975\n",
      "i = 110000, error = 9.240475051797148e-11, e = 2.71826947271711\n",
      "i = 120000, error = 1.3642109664147029e-10, e = 2.7182705023890863\n",
      "i = 130000, error = 9.885781082630274e-11, e = 2.7182713736264996\n",
      "i = 140000, error = 8.05360222955187e-11, e = 2.718272120378959\n",
      "i = 150000, error = 8.918288330050927e-11, e = 2.718272767592797\n",
      "i = 160000, error = 4.922462437662034e-11, e = 2.718273333870663\n",
      "i = 170000, error = 2.7925217693791637e-11, e = 2.7182738335613372\n",
      "i = 180000, error = 1.59530166854438e-11, e = 2.718274277732449\n",
      "i = 190000, error = 5.013633952444252e-11, e = 2.7182746751743467\n",
      "i = 200000, error = 1.0081047108201346e-10, e = 2.7182750328034286\n",
      "i = 210000, error = 2.1544988015875788e-11, e = 2.718275356351191\n",
      "i = 220000, error = 2.8351099246037847e-11, e = 2.7182756505531334\n",
      "i = 230000, error = 3.2805758110043826e-11, e = 2.7182759191619033\n",
      "i = 240000, error = 2.5779378631796135e-12, e = 2.7182761653389114\n",
      "i = 250000, error = 3.981259766305811e-12, e = 2.718276391842594\n",
      "i = 260000, error = 5.012035231288792e-11, e = 2.7182766009577994\n",
      "i = 270000, error = 1.8884005470454213e-11, e = 2.7182767946387054\n",
      "i = 280000, error = 1.3849055235937158e-10, e = 2.7182769743214785\n",
      "i = 290000, error = 3.36712879800416e-11, e = 2.7182771416962517\n",
      "i = 300000, error = 4.455502633504693e-11, e = 2.718277298020982\n",
      "i = 310000, error = 1.7486456727056066e-11, e = 2.7182774440616795\n",
      "i = 320000, error = 1.2965228890493563e-10, e = 2.718277581246092\n",
      "i = 330000, error = 8.834444287231236e-11, e = 2.7182777098432482\n",
      "i = 340000, error = 7.261302670258374e-11, e = 2.718277831002282\n",
      "i = 350000, error = 4.9887649566926484e-11, e = 2.7182779452574475\n",
      "i = 360000, error = 3.083666655356865e-11, e = 2.718278053095038\n",
      "i = 370000, error = 3.0317970356463775e-11, e = 2.7182781551623103\n",
      "i = 380000, error = 1.1151035650414087e-10, e = 2.718278251835079\n",
      "i = 390000, error = 9.912737297668173e-11, e = 2.718278343435912\n",
      "i = 400000, error = 9.579359527833731e-11, e = 2.718278430511639\n",
      "i = 410000, error = 7.214051578330327e-11, e = 2.718278513476246\n",
      "i = 420000, error = 1.7778445382532482e-10, e = 2.7182785925065494\n",
      "i = 430000, error = 8.474998480778595e-12, e = 2.7182786677994115\n",
      "i = 440000, error = 1.25901511438542e-10, e = 2.7182787396232375\n",
      "i = 450000, error = 1.963540441352052e-11, e = 2.718278808169863\n",
      "i = 460000, error = 1.7256152062827823e-10, e = 2.7182788739372237\n",
      "i = 470000, error = 1.6142553960207806e-10, e = 2.718278936747636\n",
      "i = 480000, error = 1.8985701899509877e-11, e = 2.7182789970111187\n",
      "i = 490000, error = 7.109157706963742e-11, e = 2.7182790547975038\n",
      "i = 500000, error = 1.3657519559728826e-10, e = 2.718279110260366\n",
      "i = 510000, error = 2.2044144287747258e-11, e = 2.718279163589995\n",
      "i = 520000, error = 1.9706947185227364e-10, e = 2.718279214676504\n",
      "i = 530000, error = 6.528511065084786e-11, e = 2.7182792638894315\n",
      "i = 540000, error = 1.584248288111212e-10, e = 2.718279311553507\n",
      "i = 550000, error = 8.878231483322452e-12, e = 2.718279357345852\n",
      "i = 560000, error = 2.2533086507792177e-12, e = 2.7182794015159084\n",
      "i = 570000, error = 1.8274537438855987e-10, e = 2.7182794440591582\n",
      "i = 580000, error = 2.3359980616532994e-10, e = 2.7182794852065824\n",
      "i = 590000, error = 1.0917888815242804e-10, e = 2.718279524688798\n",
      "i = 600000, error = 1.0951239914902544e-11, e = 2.718279563245457\n",
      "i = 610000, error = 8.351319635835353e-11, e = 2.718279600434664\n",
      "i = 620000, error = 1.9350299140796778e-11, e = 2.7182796364018302\n",
      "i = 630000, error = 1.3364864770437634e-11, e = 2.7182796710591397\n",
      "i = 640000, error = 5.487166276907374e-11, e = 2.7182797048946457\n",
      "i = 650000, error = 2.2284041278908262e-10, e = 2.7182797373428857\n",
      "i = 660000, error = 5.353317789058565e-11, e = 2.718279769139083\n",
      "i = 670000, error = 2.206306248808687e-10, e = 2.718279800049923\n",
      "i = 680000, error = 1.4773293699477108e-10, e = 2.718279829525621\n",
      "i = 690000, error = 1.5703349731666094e-10, e = 2.7182798588186734\n",
      "i = 700000, error = 1.6622259124687844e-11, e = 2.718279886668445\n",
      "i = 710000, error = 1.7221335468775578e-11, e = 2.718279914298955\n",
      "i = 720000, error = 2.0973534020640727e-10, e = 2.718279940566254\n",
      "i = 730000, error = 5.868860952773503e-11, e = 2.7182799666061075\n",
      "i = 740000, error = 3.272728754666332e-10, e = 2.718279991609072\n",
      "i = 750000, error = 2.646611818590827e-10, e = 2.7182800162006457\n",
      "i = 760000, error = 4.8695714127688916e-11, e = 2.718280039942557\n",
      "i = 770000, error = 4.703126776917088e-11, e = 2.718280063391063\n",
      "i = 780000, error = 1.7912960004196066e-10, e = 2.71828008591812\n",
      "i = 790000, error = 7.837197557591935e-11, e = 2.718280108035241\n",
      "i = 800000, error = 5.42681455328875e-11, e = 2.718280129431941\n",
      "i = 810000, error = 1.0250911230968995e-10, e = 2.718280150527006\n",
      "i = 820000, error = 4.0120706756852087e-10, e = 2.7182801712070748\n",
      "i = 830000, error = 3.0574076603784306e-10, e = 2.718280190724092\n",
      "i = 840000, error = 3.366165124418785e-10, e = 2.7182802105261503\n",
      "i = 850000, error = 1.882276556841589e-10, e = 2.7182802295798036\n",
      "i = 860000, error = 1.2849410424564667e-10, e = 2.71828024819077\n",
      "i = 870000, error = 3.6348257737017775e-11, e = 2.7182802663199928\n",
      "i = 880000, error = 2.078888172718507e-10, e = 2.7182802838311484\n",
      "i = 890000, error = 1.8540191604188294e-10, e = 2.718280301112372\n",
      "i = 900000, error = 4.7841730577147246e-12, e = 2.71828031832182\n",
      "i = 910000, error = 2.648126162796416e-10, e = 2.718280335158345\n",
      "i = 920000, error = 5.735945052265379e-11, e = 2.7182803509822424\n",
      "i = 930000, error = 5.142157810666959e-10, e = 2.7182803667467326\n",
      "i = 940000, error = 6.574296662620327e-11, e = 2.7182803823543136\n",
      "i = 950000, error = 8.369971382649055e-11, e = 2.718280397954482\n",
      "i = 960000, error = 1.587761033761126e-10, e = 2.718280412778849\n",
      "i = 970000, error = 2.8573010624199924e-10, e = 2.718280427410621\n",
      "i = 980000, error = 1.7917667349820476e-10, e = 2.718280441672096\n",
      "i = 990000, error = 2.8625102288515336e-11, e = 2.7182804557714806\n",
      "i = 1000000, error = 2.375788454855865e-10, e = 2.7182804690957534\n",
      "i = 1010000, error = 8.078648860987414e-11, e = 2.7182804827457145\n",
      "i = 1020000, error = 1.688542639044499e-10, e = 2.71828049576967\n",
      "i = 1030000, error = 5.021183469011703e-11, e = 2.7182805090987796\n",
      "i = 1040000, error = 1.0230527536236877e-10, e = 2.7182805215393118\n",
      "i = 1050000, error = 6.118527906551208e-11, e = 2.718280533876991\n",
      "i = 1060000, error = 1.2367706858640304e-10, e = 2.7182805464144115\n",
      "i = 1070000, error = 2.4293189682111915e-10, e = 2.7182805579992846\n",
      "i = 1080000, error = 7.571676619022583e-11, e = 2.718280570014112\n",
      "i = 1090000, error = 2.665023757231211e-10, e = 2.7182805812759496\n",
      "i = 1100000, error = 7.808864666003501e-12, e = 2.718280592593444\n",
      "i = 1110000, error = 1.5237011652402543e-10, e = 2.7182806042800935\n",
      "i = 1120000, error = 1.6687806692061713e-10, e = 2.7182806150316026\n",
      "i = 1130000, error = 1.1053380433168059e-11, e = 2.7182806257465453\n",
      "i = 1140000, error = 2.602549287189504e-10, e = 2.7182806362851544\n",
      "i = 1150000, error = 2.5875257492202763e-10, e = 2.718280646585952\n",
      "i = 1160000, error = 6.126787965854419e-11, e = 2.7182806568770066\n",
      "i = 1170000, error = 3.89999144090325e-11, e = 2.7182806669818285\n",
      "i = 1180000, error = 2.9859359429451615e-10, e = 2.7182806768565593\n",
      "i = 1190000, error = 2.0658852406540973e-10, e = 2.7182806863304396\n",
      "i = 1200000, error = 3.5950309396071134e-10, e = 2.7182806954981427\n",
      "i = 1210000, error = 1.6765255850259564e-11, e = 2.7182807051181417\n",
      "i = 1220000, error = 1.4507417489539876e-10, e = 2.7182807141138996\n",
      "i = 1230000, error = 5.960805182780859e-10, e = 2.718280723702352\n",
      "i = 1240000, error = 1.2327472376227888e-11, e = 2.718280732106563\n",
      "i = 1250000, error = 2.3178969854598108e-10, e = 2.718280741225277\n",
      "i = 1260000, error = 5.611315856413057e-10, e = 2.7182807501203055\n",
      "i = 1270000, error = 1.844702168796175e-10, e = 2.7182807583663946\n",
      "i = 1280000, error = 1.6819790005229152e-10, e = 2.718280766721204\n",
      "i = 1290000, error = 2.574633839458329e-10, e = 2.718280774988638\n",
      "i = 1300000, error = 1.138329430716567e-10, e = 2.718280783226011\n",
      "i = 1310000, error = 2.572737578532269e-10, e = 2.7182807909714666\n",
      "i = 1320000, error = 5.684368531433392e-10, e = 2.718280799187508\n",
      "i = 1330000, error = 6.66844357510854e-12, e = 2.7182808062592705\n",
      "i = 1340000, error = 1.0804424022126113e-10, e = 2.718280813927708\n",
      "i = 1350000, error = 9.260725519766311e-11, e = 2.718280821706489\n",
      "i = 1360000, error = 7.607114937968618e-11, e = 2.718280828891919\n",
      "i = 1370000, error = 4.209375070729493e-10, e = 2.718280836319356\n",
      "i = 1380000, error = 1.3185852409947074e-10, e = 2.7182808437014314\n",
      "i = 1390000, error = 5.2373216874457285e-11, e = 2.7182808507265657\n",
      "i = 1400000, error = 6.399885066343813e-10, e = 2.7182808579039817\n",
      "i = 1410000, error = 2.388285125221046e-10, e = 2.7182808646020757\n",
      "i = 1420000, error = 4.391740304754421e-10, e = 2.7182808710100494\n",
      "i = 1430000, error = 3.100417700352409e-10, e = 2.718280878192237\n",
      "i = 1440000, error = 1.0683409712441971e-10, e = 2.7182808844123083\n",
      "i = 1450000, error = 8.546736651737774e-10, e = 2.7182808906862\n",
      "i = 1460000, error = 1.9287460517602995e-10, e = 2.7182808975227886\n",
      "i = 1470000, error = 1.1850831427295816e-10, e = 2.7182809039642035\n",
      "i = 1480000, error = 5.7825744192996353e-11, e = 2.718280909945821\n",
      "i = 1490000, error = 3.964739647699389e-10, e = 2.7182809158496197\n",
      "i = 1500000, error = 5.448832496313116e-10, e = 2.7182809227456115\n",
      "i = 1510000, error = 1.6252732493171607e-10, e = 2.7182809288065846\n",
      "i = 1520000, error = 2.519433550673966e-10, e = 2.7182809345713133\n",
      "i = 1530000, error = 1.1344036821014924e-10, e = 2.718280939932702\n",
      "i = 1540000, error = 2.5235369349729808e-11, e = 2.7182809454837664\n",
      "i = 1550000, error = 5.136207015254968e-10, e = 2.7182809518838766\n",
      "i = 1560000, error = 3.829017103385013e-10, e = 2.71828095716076\n",
      "i = 1570000, error = 8.904965653755426e-11, e = 2.7182809632351934\n",
      "i = 1580000, error = 3.7552627674131145e-11, e = 2.718280968249512\n",
      "i = 1590000, error = 4.0154146674353797e-10, e = 2.7182809738165985\n",
      "i = 1600000, error = 2.127045206634648e-10, e = 2.7182809788935525\n",
      "i = 1610000, error = 5.495857102744139e-10, e = 2.718280983982605\n",
      "i = 1620000, error = 4.970113209878946e-11, e = 2.718280989501455\n",
      "i = 1630000, error = 5.860734120233246e-11, e = 2.7182809949563658\n",
      "i = 1640000, error = 4.4655523723236e-10, e = 2.718280999950145\n",
      "i = 1650000, error = 2.1535795369231892e-10, e = 2.718281005117692\n",
      "i = 1660000, error = 3.4662051007217087e-10, e = 2.7182810099832935\n",
      "i = 1670000, error = 1.6980727934878814e-10, e = 2.7182810146687513\n",
      "i = 1680000, error = 3.40142580768088e-10, e = 2.718281019537275\n",
      "i = 1690000, error = 8.535914197693728e-10, e = 2.718281024728724\n",
      "i = 1700000, error = 6.768603455498123e-10, e = 2.7182810285601233\n",
      "i = 1710000, error = 1.7280665787211547e-10, e = 2.718281034038286\n",
      "i = 1720000, error = 7.157483494779626e-10, e = 2.7182810378686346\n",
      "i = 1730000, error = 2.480491367862214e-10, e = 2.71828104300965\n",
      "i = 1740000, error = 5.41941158616055e-10, e = 2.7182810474342265\n",
      "i = 1750000, error = 4.601039549356756e-10, e = 2.7182810514329825\n",
      "i = 1760000, error = 1.0526068905392094e-10, e = 2.7182810566002473\n",
      "i = 1770000, error = 5.138116598857323e-10, e = 2.718281060438062\n",
      "i = 1780000, error = 6.311733358188576e-10, e = 2.718281064673503\n",
      "i = 1790000, error = 4.5898973510816177e-10, e = 2.7182810686675993\n",
      "i = 1800000, error = 1.1333156635373598e-12, e = 2.718281073398952\n",
      "i = 1810000, error = 7.476241847825804e-10, e = 2.7182810778724407\n",
      "i = 1820000, error = 6.804321550646364e-10, e = 2.718281081937939\n",
      "i = 1830000, error = 2.2005242072964393e-10, e = 2.7182810858315944\n",
      "i = 1840000, error = 2.4776181106744843e-10, e = 2.7182810896446785\n",
      "i = 1850000, error = 1.3269607634924796e-10, e = 2.718281093836632\n",
      "i = 1860000, error = 2.582867253408949e-10, e = 2.7182810974665736\n",
      "i = 1870000, error = 1.3038548019039808e-10, e = 2.7182811019596405\n",
      "i = 1880000, error = 2.4965762790429835e-10, e = 2.7182811058679155\n",
      "i = 1890000, error = 8.805232099007299e-10, e = 2.718281109680958\n",
      "i = 1900000, error = 5.326801222338418e-10, e = 2.7182811127173694\n",
      "i = 1910000, error = 5.689240190065448e-10, e = 2.7182811167885204\n",
      "i = 1920000, error = 3.7021186116703575e-10, e = 2.718281120663728\n",
      "i = 1930000, error = 6.224309956337493e-11, e = 2.718281124802319\n",
      "i = 1940000, error = 4.4368952956119756e-10, e = 2.7182811279977286\n",
      "i = 1950000, error = 7.303024851523787e-10, e = 2.718281130938619\n",
      "i = 1960000, error = 3.842810514242956e-10, e = 2.7182811351103653\n",
      "i = 1970000, error = 6.501017502102968e-10, e = 2.7182811380569576\n",
      "i = 1980000, error = 2.8549962394208706e-10, e = 2.7182811416077888\n",
      "i = 1990000, error = 2.940017118646665e-10, e = 2.7182811459082536\n",
      "i = 2000000, error = 1.1980860747939914e-10, e = 2.7182811492688552\n",
      "i = 2010000, error = 8.803211493102481e-10, e = 2.7182811528308735\n",
      "i = 2020000, error = 3.4619995759044286e-10, e = 2.7182811555868356\n",
      "i = 2030000, error = 1.6077938980174622e-10, e = 2.718281159022041\n",
      "i = 2040000, error = 2.224180839505152e-10, e = 2.7182811620143177\n",
      "i = 2050000, error = 4.348938986709072e-10, e = 2.718281165451403\n",
      "i = 2060000, error = 9.083844787483031e-10, e = 2.7182811682533554\n",
      "i = 2070000, error = 5.044142881160951e-11, e = 2.7182811719959745\n",
      "i = 2080000, error = 5.2094772939881295e-11, e = 2.7182811755993024\n",
      "i = 2090000, error = 2.6499691330172936e-11, e = 2.718281178665416\n",
      "i = 2100000, error = 2.8536195628703354e-10, e = 2.7182811810861027\n",
      "i = 2110000, error = 5.499067867731355e-10, e = 2.718281183887871\n",
      "i = 2120000, error = 6.093126003747784e-11, e = 2.7182811875177846\n",
      "i = 2130000, error = 4.3607917277199704e-10, e = 2.718281190056869\n",
      "i = 2140000, error = 7.681859592878482e-10, e = 2.718281193111045\n",
      "i = 2150000, error = 3.6152103533027e-10, e = 2.718281196167663\n",
      "i = 2160000, error = 9.40813649208394e-10, e = 2.71828119859335\n",
      "i = 2170000, error = 7.828613313165533e-10, e = 2.7182812016680717\n",
      "i = 2180000, error = 8.527432093785592e-10, e = 2.7182812053922\n",
      "i = 2190000, error = 1.786260028779907e-11, e = 2.7182812078286087\n",
      "i = 2200000, error = 6.591900358898783e-10, e = 2.7182812110479335\n",
      "i = 2210000, error = 1.263105176008139e-10, e = 2.7182812138795818\n",
      "i = 2220000, error = 2.596287629330618e-10, e = 2.7182812165049723\n",
      "i = 2230000, error = 4.993045976675603e-10, e = 2.7182812184295084\n",
      "i = 2240000, error = 7.586353767408127e-10, e = 2.7182812217901944\n",
      "i = 2250000, error = 5.425162541428108e-10, e = 2.7182812238712493\n",
      "i = 2260000, error = 3.473474841086954e-10, e = 2.7182812271355985\n",
      "i = 2270000, error = 8.50741699309765e-12, e = 2.718281230328112\n",
      "i = 2280000, error = 9.027769642955263e-10, e = 2.718281231710791\n",
      "i = 2290000, error = 2.844791069378516e-10, e = 2.7182812351347767\n",
      "i = 2300000, error = 4.756639526704021e-10, e = 2.718281238210194\n",
      "i = 2310000, error = 1.7205792346430826e-11, e = 2.7182812396698193\n",
      "i = 2320000, error = 3.814673021906856e-10, e = 2.7182812427129135\n",
      "i = 2330000, error = 7.886491459885292e-10, e = 2.718281245764417\n",
      "i = 2340000, error = 7.264326917777453e-10, e = 2.7182812471044087\n",
      "i = 2350000, error = 7.082423536530769e-10, e = 2.7182812496062003\n",
      "i = 2360000, error = 8.607883295042029e-10, e = 2.718281252763055\n",
      "i = 2370000, error = 2.9321256533876294e-10, e = 2.718281254510997\n",
      "i = 2380000, error = 1.0257439342353791e-10, e = 2.7182812573973907\n",
      "i = 2390000, error = 6.231903881825929e-10, e = 2.718281260468838\n",
      "i = 2400000, error = 1.804596472254616e-10, e = 2.718281262530503\n",
      "i = 2410000, error = 8.723524125286986e-10, e = 2.718281264023247\n",
      "i = 2420000, error = 7.686740133294734e-12, e = 2.7182812674763115\n",
      "i = 2430000, error = 4.5611026067149396e-10, e = 2.7182812691598155\n",
      "i = 2440000, error = 8.095888404113794e-10, e = 2.7182812711382365\n",
      "i = 2450000, error = 4.255564789445998e-10, e = 2.7182812743896045\n",
      "i = 2460000, error = 2.9736657580770043e-10, e = 2.718281276198041\n",
      "i = 2470000, error = 2.781259667017366e-10, e = 2.7182812779097527\n",
      "i = 2480000, error = 3.673932269521174e-10, e = 2.718281280895085\n",
      "i = 2490000, error = 9.381802001939832e-10, e = 2.7182812824019336\n",
      "i = 2500000, error = 6.392317786207968e-10, e = 2.7182812848810447\n",
      "i = 2510000, error = 2.330584614185227e-10, e = 2.7182812873487947\n",
      "i = 2520000, error = 2.7992363982320967e-10, e = 2.7182812887008394\n",
      "i = 2530000, error = 6.277467434756545e-10, e = 2.718281291098198\n",
      "i = 2540000, error = 9.160272540498227e-11, e = 2.7182812926941176\n",
      "i = 2550000, error = 6.225682191995929e-10, e = 2.7182812955711446\n",
      "i = 2560000, error = 1.2435936724841667e-09, e = 2.7182812968624717\n",
      "i = 2570000, error = 2.206572702334597e-10, e = 2.7182812998215824\n",
      "i = 2580000, error = 6.504983218746929e-10, e = 2.7182813017868805\n",
      "i = 2590000, error = 5.749467568705313e-10, e = 2.718281303742386\n",
      "i = 2600000, error = 3.348068489117395e-10, e = 2.718281305971964\n",
      "i = 2610000, error = 1.8595702755419552e-10, e = 2.7182813083309343\n",
      "i = 2620000, error = 1.453334785850302e-09, e = 2.7182813089363074\n",
      "i = 2630000, error = 1.6071677322315736e-10, e = 2.718281312345282\n",
      "i = 2640000, error = 2.836335610822971e-10, e = 2.7182813140130757\n"
     ]
    }
   ],
   "source": [
    "error_threhold = 1e-20\n",
    "error = float('inf')\n",
    "\n",
    "i = 1\n",
    "lst_i = []\n",
    "lst_e = []\n",
    "while error > error_threhold:\n",
    "    old_e = (1+1/i)**i\n",
    "    i += 1\n",
    "    new_e = (1+1/i)**i\n",
    "    error = abs(new_e - old_e)\n",
    "    if i % 10000 == 0:\n",
    "        lst_i.append(i)\n",
    "        lst_e.append(new_e)\n",
    "        print('i = {i}, error = {error}, e = {e}'.format(i=i, error=error, e=new_e))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 386,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 388,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(lst_i, lst_e)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 379,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import e"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 380,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.718281828459045"
      ]
     },
     "execution_count": 380,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "e"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* for 循环  \n",
    "\n",
    "---  \n",
    "\n",
    "while 语句非常灵活，可用于在条件为真时反复执行代码块。这在通常情况下很好，但有时候你可能想根据需要进行定制。一种这样的需求是为序列（或其他可迭代对象）中每个元素执行代码块。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:45.199099Z",
     "start_time": "2019-03-11T02:30:45.069175Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this\n",
      "is\n",
      "an\n",
      "ex\n",
      "parrot\n"
     ]
    }
   ],
   "source": [
    "words = ['this', 'is', 'an', 'ex', 'parrot']\n",
    "for word in words:\n",
    "    print(word)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:45.313033Z",
     "start_time": "2019-03-11T02:30:45.201098Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "for number in numbers:\n",
    "    print(number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 334,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 10)"
      ]
     },
     "execution_count": 334,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 335,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:45.313033Z",
     "start_time": "2019-03-11T02:30:45.201098Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for number in range(10):\n",
    "    print(number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "鉴于迭代（也就是遍历）特定范围内的数是一种常见的任务，Python提供了一个创建范围的内置函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:45.409979Z",
     "start_time": "2019-03-11T02:30:45.316032Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 10)"
      ]
     },
     "execution_count": 215,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(0, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:45.609893Z",
     "start_time": "2019-03-11T02:30:45.412978Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 216,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(0, 10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:45.718824Z",
     "start_time": "2019-03-11T02:30:45.620883Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "for number in range(1,11):\n",
    "    print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "要遍历字典的所有关键字，可像遍历序列那样使用普通的 for 语句。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:45.951617Z",
     "start_time": "2019-03-11T02:30:45.720824Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x corresponds to 1\n",
      "y corresponds to 2\n",
      "z corresponds to 3\n"
     ]
    }
   ],
   "source": [
    "d = {'x': 1, 'y': 2, 'z': 3}\n",
    "for key in d:\n",
    "    print(key, 'corresponds to', d[key])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "也可使用 keys 等字典方法来获取所有的键。如果只对值感兴趣，可使用 d.values 。d.items 以元组的方式返回键值对。 for 循环的优点之一是，可在其中使用序列解包"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "key, value = 1, 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:46.131118Z",
     "start_time": "2019-03-11T02:30:45.961612Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x corresponds to 1\n",
      "y corresponds to 2\n",
      "z corresponds to 3\n"
     ]
    }
   ],
   "source": [
    "for key, value in d.items():\n",
    "    print(key, 'corresponds to', value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-02-14T02:44:42.588856Z",
     "start_time": "2019-02-14T02:44:42.580859Z"
    }
   },
   "source": [
    "并行迭代\n",
    "\n",
    "---\n",
    "\n",
    "有时候，你可能想同时迭代两个序列。假设有下面两个列表："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:46.239067Z",
     "start_time": "2019-03-11T02:30:46.141107Z"
    }
   },
   "outputs": [],
   "source": [
    "names = ['anne', 'beth', 'george', 'damon']\n",
    "ages = [12, 45, 32, 102]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果要打印名字和对应的年龄，可以像下面这样做："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:46.432073Z",
     "start_time": "2019-03-11T02:30:46.240047Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "anne is 12 years old\n",
      "beth is 45 years old\n",
      "george is 32 years old\n",
      "damon is 102 years old\n"
     ]
    }
   ],
   "source": [
    "for i in range(len(names)):\n",
    "    print(names[i], 'is', ages[i], 'years old')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "一个很有用的并行迭代工具是内置函数 zip ，它将两个序列“缝合”起来，并返回一个由元组组成的序列。返回值是一个适合迭代的对象，要查看其内\n",
    "容，可使用 list 将其转换为列表。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:46.542008Z",
     "start_time": "2019-03-11T02:30:46.440069Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('anne', 12), ('beth', 45), ('george', 32), ('damon', 102)]"
      ]
     },
     "execution_count": 222,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(zip(names, ages))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "“缝合”后，可在循环中将元组解包。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:46.739667Z",
     "start_time": "2019-03-11T02:30:46.545008Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "anne is 12 years old\n",
      "beth is 45 years old\n",
      "george is 32 years old\n",
      "damon is 102 years old\n"
     ]
    }
   ],
   "source": [
    "for name, age in zip(names, ages):\n",
    "    print(name, 'is', age, 'years old')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "迭代时获取索引\n",
    "\n",
    "---\n",
    "\n",
    "在有些情况下，你需要在迭代对象序列的同时获取当前对象的索引。例如，你可能想替换一\n",
    "个字符串列表中所有包含子串 'xxx' 的字符串。当然，完成这种任务的方法有很多，但这里假设\n",
    "你要像下面这样做："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 336,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "char at 0 is h\n",
      "char at 1 is e\n",
      "char at 2 is l\n",
      "char at 3 is l\n",
      "char at 4 is o\n"
     ]
    }
   ],
   "source": [
    "str1 = 'hello'\n",
    "for i in range(5):\n",
    "    print('char at {} is {}'.format(i, str1[i]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:46.899591Z",
     "start_time": "2019-03-11T02:30:46.744661Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0:h\n",
      "1:e\n",
      "2:l\n",
      "3:l\n",
      "4:o\n"
     ]
    }
   ],
   "source": [
    "for index, value in enumerate('hello'):\n",
    "    print(str(index) + ':' + str(value))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "跳出循环\n",
    "\n",
    "---\n",
    "\n",
    "要结束（跳出）循环，可使用 break 。假设你要找出小于100的最大平方值（整数与自己相乘的结果），可从100开始向下迭代。找到一个平方值后，无需再迭代，因此直接跳出循环。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:47.020504Z",
     "start_time": "2019-03-11T02:30:46.902570Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "81\n"
     ]
    }
   ],
   "source": [
    "from math import sqrt\n",
    "for n in range(99, 0, -1):\n",
    "    root = sqrt(n)\n",
    "    if root == int(root):\n",
    "        print(n)\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "循环中的 else 子句\n",
    "\n",
    "---\n",
    "\n",
    "通常，在循环中使用 break 是因为你“发现”了什么或“出现”了什么情况。要在循环提前结束时采取某种措施很容易，但有时候你可能想在循环正常结束时才采取某种措施。如何判断循环是提前结束还是正常结束的呢？可在循环开始前定义一个布尔变量并将其设置为 False，再在跳出循环时将其设置为 True 。这样就可在循环后面使用一条 if 语句来判断循环是否是提前结束的。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:47.213395Z",
     "start_time": "2019-03-11T02:30:47.025501Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Didn't find it!\n"
     ]
    }
   ],
   "source": [
    "broke_out = False\n",
    "from math import sqrt\n",
    "for n in range(99, 81, -1):\n",
    "    root = sqrt(n)\n",
    "    if root == int(root):\n",
    "        print(n)\n",
    "        broke_out = True\n",
    "        break\n",
    "if not broke_out:\n",
    "    print(\"Didn't find it!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-02-14T02:55:19.530521Z",
     "start_time": "2019-02-14T02:55:19.523528Z"
    }
   },
   "source": [
    "一种更简单的办法是在循环中添加一条 else 子句，<font color='blue'>**它仅在没有调用 break 时才执行**</font>。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 227,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:47.341822Z",
     "start_time": "2019-03-11T02:30:47.215392Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Didn't find it!\n"
     ]
    }
   ],
   "source": [
    "from math import sqrt\n",
    "for n in range(99, 81, -1):\n",
    "    root = sqrt(n)\n",
    "    if root == int(root):\n",
    "        print(n)\n",
    "        break\n",
    "else:\n",
    "    print(\"Didn't find it!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "从“孙行者”看一看排列组合："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-21T04:17:18.444263Z",
     "start_time": "2019-03-21T04:17:18.438265Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "孙行者\n",
      "孙者行\n",
      "行孙者\n",
      "行者孙\n",
      "者孙行\n",
      "者行孙\n"
     ]
    }
   ],
   "source": [
    "from itertools import permutations\n",
    "monkey_king = [\"孙\", \"行\", \"者\"]\n",
    "for title in permutations(monkey_king):\n",
    "    print(''.join(title))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 列表推导"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-02-14T02:57:04.051391Z",
     "start_time": "2019-02-14T02:57:04.042394Z"
    }
   },
   "source": [
    "列表推导是一种从其他列表创建列表的方式，类似于数学中的集合推导。列表推导的工作原理非常简单，有点类似于 for 循环。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:47.486203Z",
     "start_time": "2019-03-11T02:30:47.349818Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['p', 'y', 't', 'h', 'o', 'n']"
      ]
     },
     "execution_count": 229,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chars = [c for c in 'python']\n",
    "chars"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T07:18:09.358416Z",
     "start_time": "2019-03-18T07:18:09.344426Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['p', 'y', 't', 'h', 'o', 'n']"
      ]
     },
     "execution_count": 230,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chars = []\n",
    "for c in 'python':\n",
    "    chars.append(c)\n",
    "chars"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 337,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:47.607762Z",
     "start_time": "2019-03-11T02:30:47.489200Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 337,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[x ** 2 for x in range(10)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:47.786658Z",
     "start_time": "2019-03-11T02:30:47.631748Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 9, 36, 81]"
      ]
     },
     "execution_count": 232,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[x*x for x in range(10) if x % 3 == 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:47.955562Z",
     "start_time": "2019-03-11T02:30:47.805651Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]"
      ]
     },
     "execution_count": 233,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[(x, y) for x in range(3) for y in range(3)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "相当于下面的语句："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:48.131461Z",
     "start_time": "2019-03-11T02:30:47.958560Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]"
      ]
     },
     "execution_count": 234,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result = []\n",
    "for x in range(3):\n",
    "    for y in range(3):\n",
    "        result.append((x, y))\n",
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:48.276396Z",
     "start_time": "2019-03-11T02:30:48.134459Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['hi', 'python']"
      ]
     },
     "execution_count": 235,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hi_python = ['Hi', 'Python']\n",
    "[s.lower() for s in hi_python]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "总结一下，创建列表的三种方法：<br>\n",
    "* 用中括号[]包裹元素，元素使用逗号分隔\n",
    "* 用list()方法转化生成列表\n",
    "* 列表推导式生成列表"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "当然，除了列表推导，集合、字典也有推导式："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-21T04:25:09.610571Z",
     "start_time": "2019-03-21T04:25:09.602580Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2, 4, 8}"
      ]
     },
     "execution_count": 236,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num_list = [1, 2, 3, 4, 5, 2, 5, 1, 4, 8]\n",
    "even_set = { x for x in num_list if x % 2 == 0 }\n",
    "even_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-21T04:25:39.801505Z",
     "start_time": "2019-03-21T04:25:39.793511Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: False,\n",
       " 2: True,\n",
       " 3: False,\n",
       " 4: True,\n",
       " 5: False,\n",
       " 6: True,\n",
       " 7: False,\n",
       " 8: True,\n",
       " 9: False,\n",
       " 10: True}"
      ]
     },
     "execution_count": 237,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = { x: x % 2 == 0 for x in range(1, 11) }\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-21T04:22:20.146282Z",
     "start_time": "2019-03-21T04:22:20.132295Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'TensorFlow': 0,\n",
       " 'Theano': 1,\n",
       " 'Keras': 2,\n",
       " 'Caffe': 3,\n",
       " 'PyTorch': 4,\n",
       " ' mxnet': 5}"
      ]
     },
     "execution_count": 238,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "deep_learning = ['TensorFlow', 'Theano', 'Keras', 'Caffe', 'PyTorch', ' mxnet']\n",
    "{key: value for value, key in enumerate(deep_learning)}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": false
   },
   "source": [
    "## 编写函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hadley Wickham\n",
    ">You should consider writing a function whenever you’ve copied and pasted a block of code more than twice (i.e. you now have three copies of the same code).  \n",
    "\n",
    "按照事不过三法则，一旦你复制粘贴代码超过三次，就需要考虑编写函数了。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 自定义函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "函数是结构化编程的核心。那么如何定义函数呢？使用 def （表示定义函数）语句。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:48.407302Z",
     "start_time": "2019-03-11T02:30:48.279376Z"
    }
   },
   "outputs": [],
   "source": [
    "def hello(name):\n",
    "    return 'Hello, ' + name + '!'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 240,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:48.599195Z",
     "start_time": "2019-03-11T02:30:48.410302Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello, world!'"
      ]
     },
     "execution_count": 240,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hello('world')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 241,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:48.753105Z",
     "start_time": "2019-03-11T02:30:48.602191Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello, Beijing!'"
      ]
     },
     "execution_count": 241,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hello('Beijing')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 242,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:48.907019Z",
     "start_time": "2019-03-11T02:30:48.756104Z"
    }
   },
   "outputs": [],
   "source": [
    "def fibs(num):\n",
    "    result = [0, 1]\n",
    "    for i in range(num-2):\n",
    "        result.append(result[-2] + result[-1])\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 243,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:49.030948Z",
     "start_time": "2019-03-11T02:30:48.910015Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]"
      ]
     },
     "execution_count": 243,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fibs(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "要给函数编写文档，以确保其他人能够理解，可添加注释（以#打头的内容）。还有另一种编写注释的方式，就是添加独立的字符串。在有些地方，如 def 语句后面，添加这样的字符串很有用。放在函数开头的字符串称为\n",
    "文档字符串（docstring），将作为函数的一部分存储起来。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 244,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:49.162872Z",
     "start_time": "2019-03-11T02:30:49.033944Z"
    }
   },
   "outputs": [],
   "source": [
    "def square(x):\n",
    "    'Calculates the square of the number x.'\n",
    "    return x * x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以像下面这样访问文档字符串："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:49.274807Z",
     "start_time": "2019-03-11T02:30:49.165869Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Calculates the square of the number x.'"
      ]
     },
     "execution_count": 245,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "square.__doc__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "特殊的内置函数 help 很有用。在交互式解释器中，可使用它获取有关函数的信息，其中包含函数的文档字符串。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 246,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:49.374751Z",
     "start_time": "2019-03-11T02:30:49.277806Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function square in module __main__:\n",
      "\n",
      "square(x)\n",
      "    Calculates the square of the number x.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(square)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 247,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:49.594625Z",
     "start_time": "2019-03-11T02:30:49.378746Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[1;31mSignature:\u001b[0m \u001b[0msquare\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
       "\u001b[1;31mDocstring:\u001b[0m Calculates the square of the number x.\n",
       "\u001b[1;31mFile:\u001b[0m      d:\\wd\\python\\t01_edu\\y02_dataminingexperiments\\<ipython-input-244-a332d74ba4aa>\n",
       "\u001b[1;31mType:\u001b[0m      function\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "?square"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:49.698564Z",
     "start_time": "2019-03-11T02:30:49.597621Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[1;31mSignature:\u001b[0m \u001b[0msquare\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
       "\u001b[1;31mDocstring:\u001b[0m Calculates the square of the number x.\n",
       "\u001b[1;31mFile:\u001b[0m      d:\\wd\\python\\t01_edu\\y02_dataminingexperiments\\<ipython-input-244-a332d74ba4aa>\n",
       "\u001b[1;31mType:\u001b[0m      function\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "square?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 参数魔法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 249,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:49.875463Z",
     "start_time": "2019-03-11T02:30:49.701563Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Mrs. Entity'"
      ]
     },
     "execution_count": 249,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def try_to_change(n):\n",
    "    n = 'Mr. Gumby'\n",
    "\n",
    "name = 'Mrs. Entity'\n",
    "try_to_change(name)\n",
    "name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "字符串（以及数和元组）是不可变的（immutable），这意味着你不能修改它们（即只能替换为新值）。因此这些类型作为参数没什么可说的。但如果参数为可变的数据结构（如列表）呢？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 250,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:49.985399Z",
     "start_time": "2019-03-11T02:30:49.877463Z"
    }
   },
   "outputs": [],
   "source": [
    "def change(n):\n",
    "    n[0] = 'Mr. Gumby'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 251,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:50.120556Z",
     "start_time": "2019-03-11T02:30:49.988398Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Mr. Gumby', 'Mrs. Thing']"
      ]
     },
     "execution_count": 251,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names = ['Mrs. Entity', 'Mrs. Thing']\n",
    "change(names)\n",
    "names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 252,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:50.302993Z",
     "start_time": "2019-03-11T02:30:50.129544Z"
    }
   },
   "outputs": [],
   "source": [
    "names = ['Mrs. Entity', 'Mrs. Thing']\n",
    "n = names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:50.432888Z",
     "start_time": "2019-03-11T02:30:50.311958Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 253,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n == names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 254,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:50.543824Z",
     "start_time": "2019-03-11T02:30:50.435886Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 254,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n is names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:50.651765Z",
     "start_time": "2019-03-11T02:30:50.546823Z"
    }
   },
   "outputs": [],
   "source": [
    "n = names[:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 256,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:50.802135Z",
     "start_time": "2019-03-11T02:30:50.654761Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 256,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n == names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 257,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:50.965040Z",
     "start_time": "2019-03-11T02:30:50.807132Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 257,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n is names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 258,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:51.120951Z",
     "start_time": "2019-03-11T02:30:50.968040Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Mrs. Entity', 'Mrs. Thing']"
      ]
     },
     "execution_count": 258,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "change(names[:])\n",
    "\n",
    "names"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "关键字参数和默认值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 259,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:51.230890Z",
     "start_time": "2019-03-11T02:30:51.123950Z"
    }
   },
   "outputs": [],
   "source": [
    "def hello_1(name, greeting):\n",
    "    print('{}, {}!'.format(name, greeting))\n",
    "\n",
    "def hello_2(greeting, name):\n",
    "    print('{}, {}!'.format(name, greeting))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 260,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:51.363725Z",
     "start_time": "2019-03-11T02:30:51.233887Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, world!\n"
     ]
    }
   ],
   "source": [
    "hello_1('Hello', 'world')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 261,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:51.474764Z",
     "start_time": "2019-03-11T02:30:51.369722Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "world, Hello!\n"
     ]
    }
   ],
   "source": [
    "hello_2('Hello', 'world')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "有时候，参数的排列顺序可能难以记住，尤其是参数很多时。为了简化调用工作，可指定参数的名称。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 262,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:51.617851Z",
     "start_time": "2019-03-11T02:30:51.477754Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "world, Hello!\n"
     ]
    }
   ],
   "source": [
    "hello_1(greeting='Hello', name='world')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 263,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:51.729787Z",
     "start_time": "2019-03-11T02:30:51.626852Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "world, Hello!\n"
     ]
    }
   ],
   "source": [
    "hello_2(greeting='Hello', name='world')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "关键字参数最大的优点在于，可以指定默认值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 264,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:51.895341Z",
     "start_time": "2019-03-11T02:30:51.732784Z"
    }
   },
   "outputs": [],
   "source": [
    "def hello_3(greeting='Hello', name='world'):\n",
    "    print('{}, {}!'.format(greeting, name))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 265,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:52.002277Z",
     "start_time": "2019-03-11T02:30:51.897338Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, world!\n"
     ]
    }
   ],
   "source": [
    "hello_3()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 266,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:52.110217Z",
     "start_time": "2019-03-11T02:30:52.005276Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, beijing!\n"
     ]
    }
   ],
   "source": [
    "hello_3(name = 'beijing')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 267,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:52.220154Z",
     "start_time": "2019-03-11T02:30:52.114214Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hi, beijing!\n"
     ]
    }
   ],
   "source": [
    "hello_3(greeting = 'hi', name = 'beijing')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 268,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:52.330108Z",
     "start_time": "2019-03-11T02:30:52.222151Z"
    }
   },
   "outputs": [],
   "source": [
    "def print_params_2(title, *params):\n",
    "    print(title)\n",
    "    print(params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 269,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:52.431032Z",
     "start_time": "2019-03-11T02:30:52.333089Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Params:\n",
      "(1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "print_params_2('Params:', 1, 2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 270,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:52.539971Z",
     "start_time": "2019-03-11T02:30:52.434031Z"
    }
   },
   "outputs": [],
   "source": [
    "def in_the_middle(x, *y, z):\n",
    "    print(x, y, z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 271,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:52.642930Z",
     "start_time": "2019-03-11T02:30:52.542968Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 (2, 3, 4, 5) 7\n"
     ]
    }
   ],
   "source": [
    "in_the_middle(1, 2, 3, 4, 5, z=7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "要收集关键字参数，可使用两个星号。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 272,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:52.752912Z",
     "start_time": "2019-03-11T02:30:52.645910Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'x': 1, 'y': 2, 'z': 3}\n"
     ]
    }
   ],
   "source": [
    "def print_params_3(**params):\n",
    "    print(params)\n",
    "\n",
    "print_params_3(x=1, y=2, z=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 273,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:52.852855Z",
     "start_time": "2019-03-11T02:30:52.756909Z"
    }
   },
   "outputs": [],
   "source": [
    "def print_params_4(x, y, z=3, *pospar, **keypar):\n",
    "    print(x, y, z)\n",
    "    print(pospar)\n",
    "    print(keypar)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 274,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:52.965791Z",
     "start_time": "2019-03-11T02:30:52.854853Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3\n",
      "(5, 6, 7)\n",
      "{'foo': 1, 'bar': 2}\n"
     ]
    }
   ],
   "source": [
    "print_params_4(1, 2, 3, 5, 6, 7, foo=1, bar=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Here for the third time  \n",
    "\n",
    "---\n",
    "\n",
    "```python\n",
    "import time\n",
    "print(time.asctime(time.localtime(time.time())))\n",
    "```\n",
    "Tue Mar 17 14:41:35 2020"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": true
   },
   "source": [
    "# 面向对象编程"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在面向对象编程中，术语对象大致意味着一系列数据（属性）以及一套访问和操作这些数据的方法。使用对象而非全局变量和函数的原因有多个，下面列出了使用对象的最重要的好处。  \n",
    "* 封装：对外部隐藏有关对象工作原理的细节  \n",
    "* 继承：可基于通用类创建出专用类  \n",
    "* 多态：可对不同类型的对象执行相同的操作，而这些操作就像“被施了魔法”一样能够正常运行  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 275,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:53.074727Z",
     "start_time": "2019-03-11T02:30:52.968788Z"
    }
   },
   "outputs": [],
   "source": [
    "class Person:\n",
    "    def set_name(self, name):\n",
    "        self.name = name\n",
    "    def get_name(self):\n",
    "        return self.name\n",
    "    def greet(self):\n",
    "        print(\"Hello, world! I'm {}.\".format(self.name))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 276,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:53.185662Z",
     "start_time": "2019-03-11T02:30:53.079725Z"
    }
   },
   "outputs": [],
   "source": [
    "foo = Person()\n",
    "bar = Person()\n",
    "foo.set_name('Luke Skywalker')\n",
    "bar.set_name('Anakin Skywalker')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 277,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:53.298598Z",
     "start_time": "2019-03-11T02:30:53.188662Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, world! I'm Luke Skywalker.\n"
     ]
    }
   ],
   "source": [
    "foo.greet()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 278,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:53.397541Z",
     "start_time": "2019-03-11T02:30:53.301597Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, world! I'm Anakin Skywalker.\n"
     ]
    }
   ],
   "source": [
    "bar.greet()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这个示例可能有点简单，但澄清了self 是什么。对 foo 调用 set_name 和 greet 时， foo 都会作为第一个参数自动传递给它们。我将这个参数命名为 self ，这非常贴切。实际上，可以随便给这个参数命名，但鉴于它总是指向对象本身，因此习惯上将其命名为 self 。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "显然， self 很有用，甚至必不可少。如果没有它，所有的方法都无法访问对象本身——要操作的属性所属的对象。与以前一样，也可以从外部访问这些属性。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 282,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:53.498484Z",
     "start_time": "2019-03-11T02:30:53.400540Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Luke Skywalker'"
      ]
     },
     "execution_count": 282,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "foo.name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "要让方法或属性成为私有的（不能从外部访问），只需让其名称以两个下划线打头即可。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 283,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:53.607422Z",
     "start_time": "2019-03-11T02:30:53.503481Z"
    }
   },
   "outputs": [],
   "source": [
    "class Secretive:\n",
    "    def __inaccessible(self):\n",
    "        print(\"Bet you can't see me ...\")\n",
    "    def accessible(self):\n",
    "        print(\"The secret message is:\")\n",
    "        self.__inaccessible()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 284,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:53.708365Z",
     "start_time": "2019-03-11T02:30:53.610420Z"
    }
   },
   "outputs": [],
   "source": [
    "s = Secretive()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 285,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:53.809306Z",
     "start_time": "2019-03-11T02:30:53.712364Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The secret message is:\n",
      "Bet you can't see me ...\n"
     ]
    }
   ],
   "source": [
    "s.accessible()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 286,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:53.921242Z",
     "start_time": "2019-03-11T02:30:53.812305Z"
    }
   },
   "outputs": [],
   "source": [
    "class MemberCounter:\n",
    "    members = 0\n",
    "    def init(self):\n",
    "        MemberCounter.members += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 287,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:54.018205Z",
     "start_time": "2019-03-11T02:30:53.924240Z"
    }
   },
   "outputs": [],
   "source": [
    "m1 = MemberCounter()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 288,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:54.130122Z",
     "start_time": "2019-03-11T02:30:54.021185Z"
    }
   },
   "outputs": [],
   "source": [
    "m1.init()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 289,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:54.243076Z",
     "start_time": "2019-03-11T02:30:54.132135Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 289,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "MemberCounter.members"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 290,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:54.363219Z",
     "start_time": "2019-03-11T02:30:54.246056Z"
    }
   },
   "outputs": [],
   "source": [
    "m2 = MemberCounter()\n",
    "m2.init()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 291,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:54.464165Z",
     "start_time": "2019-03-11T02:30:54.366219Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 291,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "MemberCounter.members"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 292,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:54.576220Z",
     "start_time": "2019-03-11T02:30:54.467160Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 292,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " m1.members"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 293,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-11T02:30:54.686139Z",
     "start_time": "2019-03-11T02:30:54.579201Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 293,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m2.members"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 编码规范"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "请参阅[PEP 8 -- Style Guide for Python Code](https://www.python.org/dev/peps/pep-0008/)。以下是其中部分条款：<br>\n",
    "- 使用4个空格缩进，不要使用制表符<br>\n",
    "  4个空格是一个在小缩进（允许更大的嵌套深度）和大缩进（更容易阅读）的一种很好的折中方案。制表符会引入混乱，最好不要使用它。\n",
    "- 换行，使一行不超过79个字符<br>\n",
    "  这有助于使用小型显示器的用户，并且可以在较大的显示器上并排放置多个代码文件。\n",
    "- 使用空行分隔函数和类，以及函数内的较大的代码块。\n",
    "- 如果可能，把注释放到单独的一行。\n",
    "- 使用文档字符串。\n",
    "- 在运算符前后和逗号后使用空格，但不能直接在括号内使用： a = f(1, 2) + g(3, 4)。\n",
    "- 类和函数命名的一致性；规范是使用 CamelCase 命名类，lower_case_with_underscores 命名函数和方法。始终使用 self 作为第一个方法参数的名称（有关类和方法，请参阅 初探类 ）。\n",
    "- 如果你的代码旨在用于国际环境，请不要使用花哨的编码。Python 默认的 UTF-8 或者纯 ASCII 在任何情况下都能有最好的表现。\n",
    "- 同样，哪怕只有很小的可能，遇到说不同语言的人阅读或维护代码，也不要在标识符中使用非ASCII字符。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "既然说到了PEP，这里稍微展开一下。PEP的全称是Python Enhancement Proposals，即Python增强提案或Python改进建议书。<br>\n",
    ">  A PEP is a design document providing information to the Python community, or describing a new feature for Python or its processes or environment. \n",
    "\n",
    "---\n",
    "\n",
    "* PEP 0 -- Index of Python Enhancement Proposals\n",
    "* PEP 8 -- Style Guide for Python Code，编码规范（必读）\n",
    "* PEP 20 -- The Zen of Python，Python之禅\n",
    "* PEP 202 -- List Comprehensions，列表生成式\n",
    "* PEP 274 -- Dict Comprehensions，字典生成式\n",
    "* PEP 234 -- Iterators，迭代器\n",
    "* PEP 257 -- Docstring Conventions，文档注释规范\n",
    "* PEP 279 -- The enumerate() built-in function，enumerate枚举\n",
    "* PEP 282 -- A Logging System，日志模块\n",
    "* PEP 285 -- Adding a bool type，布尔值\n",
    "* PEP 289 -- Generator Expressions，生成器表达式\n",
    "* PEP 318 -- Decorators for Functions and Methods，装饰器\n",
    "* PEP 342 -- Coroutines via Enhanced Generators，协程\n",
    "* PEP 343 -- The \"with\" Statement，with语句\n",
    "* PEP 380 -- Syntax for Delegating to a Subgenerator，yield from语法\n",
    "* PEP 405 -- Python Virtual Environments，虚拟环境\n",
    "* PEP 471 -- os.scandir() function，遍历目录\n",
    "* PEP 484 -- Type Hints，类型约束\n",
    "* PEP 492 -- Coroutines with async and await syntax，async/await语法\n",
    "* PEP 498 -- Literal String Interpolation Python，字符串插值\n",
    "* PEP 525 -- Asynchronous Generators，异步生成器\n",
    "* PEP 572 -- Assignment Expressions，表达式内赋值\n",
    "* PEP 3105 -- Make print a function，print改为函数\n",
    "* PEP 3115 -- Metaclasses in Python 3000，元类\n",
    "* PEP 3120 -- Using UTF-8 as the default source encoding\n",
    "* PEP 8000 -- Python Language Governance Proposal Overview，决策方案"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 延伸阅读"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "本章铺垫了Python的一些基础知识，包括数据对象、程序控制、面向对象（初步）等，以便后续开展具体实验时能快速上手。对于Python语言的习惯和掌握，是一个日积月累的过程，很多重要的内容，比如程序调试等，均未涉及，请同学们自行参考相关教材资料进行学习。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "假如是要快速概览Python基础的话，下边这个速查表也值得推荐一下：  \n",
    "* [python-cheatsheet](https://github.com/gto76/python-cheatsheet)：简洁明了的Python基础知识速查表 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--NAVIGATION-->\n",
    "< [实验环境配置](ch01_实验环境配置.ipynb) | [Contents](Index.ipynb) | [数据挖掘常用模块](ch03_数据挖掘常用模块.ipynb) >"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "dme",
   "language": "python",
   "name": "dme"
  },
  "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.6"
  },
  "toc": {
   "base_numbering": "2",
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "本章目录",
   "title_sidebar": "",
   "toc_cell": true,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "189px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  },
  "toc-autonumbering": true,
  "toc-showtags": false,
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}