101-Python入门.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Python入门"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## License\n",
    "\n",
    "CC-BY-SA 4.0\n",
    "\n",
    "大部分内容来自”a byte of python”，在此感谢作者。\n",
    "\n",
    "http://python.swaroopch.com/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Python的历史\n",
    "\n",
    "作者：Guido van Rossum\n",
    "\n",
    "首次发行时间：1991\n",
    "\n",
    "版本系列：2.7 / 3.8\n",
    "\n",
    "分类：强类型动态语言\n",
    "\n",
    "支持系统：几乎全部"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 本讲义的兼容性\n",
    "\n",
    "本讲义的基础环境为Python3.8，代码保证在3.8上可运行。原则上可兼容Python2.7，Python3.3-3.7，但是并未一一测试。如发现问题可反馈。\n",
    "\n",
    "其中部分代码有少量代码有2/3不兼容现象，在讲课时会特别提出。\n",
    "\n",
    "本讲义的系统环境为Linux(Debian Buster)，有少量指令在Windows下有变化，亦会特别提出。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Python的成功案例\n",
    "\n",
    "知名公司\n",
    "\n",
    "* Industrial Light & Magic (工业光魔) 电影制作\n",
    "* D-Link Australia Firmware更新\n",
    "* Odoo ERP产品\n",
    "* Douban 全站\n",
    "* Eleme 全站\n",
    "\n",
    "知名应用\n",
    "\n",
    "* Django 网页开发\n",
    "* Odoo ERP产品\n",
    "* OpenStack 虚拟化管理平台\n",
    "* SaltStack 自动化运维\n",
    "* Ansible 自动化运维\n",
    "* Pandas 数据分析\n",
    "* PySpark 内存计算\n",
    "* TensorFlow 机器学习"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# 基础环境准备"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Python环境安装\n",
    "\n",
    "Windows/MacOS:\n",
    "\n",
    "1. 访问 https://www.python.org/downloads/\n",
    "2. 下载合适的版本\n",
    "3. 点击安装\n",
    "\n",
    "Linux:\n",
    "\n",
    "1. 多数系统自带\n",
    "2. 请找对应系统手册"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Python运行交互界面\n",
    "\n",
    "在命令行下执行python，进入Python交互界面。类似这样：\n",
    "\n",
    "    Python 3.7.3 (default, Dec 20 2019, 18:57:59) \n",
    "    [GCC 8.3.0] on linux\n",
    "    Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n",
    "    >>> \n",
    "\n",
    "出现这个界面，说明你正常的安装了python。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Jupyter演示界面\n",
    "\n",
    "Jupyter是一种记事本工具。可以插入代码，进行执行，显示结果，并把这些内容保存成记事本以供后续查阅。\n",
    "\n",
    "下面我们会大量使用Jupyter进行代码执行展示。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 简单命令测试\n",
    "\n",
    "在交互界面敲入1 + 2，出现如下结果：\n",
    "\n",
    "    >>> 1 + 2\n",
    "    3\n",
    "\n",
    "在交互界面敲入print(‘1+2’)，出现如下结果：\n",
    "\n",
    "    >>> print('1+2')\n",
    "    1+2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1+2\n"
     ]
    }
   ],
   "source": [
    "print('1+2')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 文件编辑和执行\n",
    "\n",
    "用任意编辑器（随你喜欢）新建一文件，修改内容为print('1+2')，然后将其保存为xxx.py文件。\n",
    "\n",
    "然后用python执行文件：python xxx.py\n",
    "\n",
    "注意，如果python不在默认路径中（常见于windows），需要写完整路径。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "以下代码，%%开头的为jupyter内部指令。writefile为写入文件。\n",
    "\n",
    "!开头的为系统指令。cat和rm为linux系统指令，windows下需要做变更。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing test.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile test.py\n",
    "print('1+2')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "print('1+2')"
     ]
    }
   ],
   "source": [
    "!cat test.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1+2\r\n"
     ]
    }
   ],
   "source": [
    "!python test.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "!rm test.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Python基本语法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 基本类型\n",
    "\n",
    "* 注释：以#开头的为注释，直到行结束为止。\n",
    "* 数字：以数字，.或者-开头的为数字。带小数点.的为浮点数，不带小数点的为整数。支持科学计数法，例如52.3E-4。可以以\\_作为分隔，增强可读性，例如1\\_000\\_000。\n",
    "* 字符串：以单引号’，双引号”，三引号’’’开始，同样符号结束。\n",
    "* 布尔值：只有两个，True和False。大小写敏感。\n",
    "* 空值：只有一个，None。大小写敏感。表示没有值的值。\n",
    "\n",
    "练习：写出数字和字符串的例子，并加以注释。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 例子"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.00523"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "52.3E-4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'string'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'string'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'string'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"string\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'string'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''string'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 == 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 == 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 字符串转义\n",
    "\n",
    "在单引号字符串中表达单引号需要转义，双引号和三引号同。例如：\n",
    "\n",
    "“what’s wrong”是合法字符串。’what’s wrong’会出错，需要写为’what\\’s wrong’。\n",
    "\n",
    "转义也可以用于表达不可见字符，例如tab：\\t。\n",
    "\n",
    "如果要表达\\本身，也需要转义，写为\\\\\\\\。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"what's wrong\""
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'what\\'s wrong'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Raw String\n",
    "\n",
    "在字符串的开始加r，使得字符串中不发生转义。\n",
    "\n",
    "常用于大量需要表达\\的字符串。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"what\\\\'s wrong\""
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r'what\\'s wrong'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "what\\'s wrong\n"
     ]
    }
   ],
   "source": [
    "print(r'what\\'s wrong')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Unicode字符串\n",
    "\n",
    "在字符串前加u，表示这是一个unicode字符串。前面加b，表示是一个bytes字符串（也叫raw字符串）。如果什么都不加，则看Python版本。Python2中默认为raw字符串，Python3中默认为unicode字符串。\n",
    "\n",
    "unicode字符串和普通字符串的区别在于。unicode字符串中，每一个位表示一个“字”。而普通字符串中，一个位表示一个字节。\n",
    "\n",
    "一个“字”可能由一个字节表示，也可能由多个字节表示。尤其是中文的情况下。这种“字符串”在处理文字的时候容易发生混乱。\n",
    "\n",
    "unicode字符串和普通字符串外形相似，但是很多地方无法混用。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'string'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u'string'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'string' == u'string'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# -*- coding: utf-8 -*-\n",
    "'中文' == u'中文'\n",
    "# 在Python2下不相等，Python3下相等。因为Python3下都是Unicode。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 变量\n",
    "\n",
    "变量需要一个名字。\n",
    "\n",
    "首字母需要是字母或下划线，其余部分可以是字母，下划线和数字。\n",
    "\n",
    "变量大小写敏感，但是使用大小写区分变量是不可取的。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 变量类型\n",
    "\n",
    "每个变量都会指向一个值，每个值都拥有一个类型。\n",
    "\n",
    "变量在运行过程中可以指向不同的值，拥有不同的类型。\n",
    "\n",
    "因此在运行前无法知道名字所对应的类型。（动态类型语言特征）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# 算符和表达式"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 算符\n",
    "\n",
    "算符是连接一个或多个元素的符号，用来表达计算。\n",
    "\n",
    "常见算符：\n",
    "\n",
    "    + - * ** / // % << >> & | ^ ~ < > <= >= == != not and or\n",
    "\n",
    "算符和赋值的快速写法\n",
    "\n",
    "    a = 10\n",
    "    a = a + 10\n",
    "    a += 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "可以挑讲常见算符。一般+ - * /需要重点讲解，其他算符可以简单介绍，等到合适的机会再讲。\n",
    "\n",
    "在这里，/和//算符，2和3的差异是常被提到的话题。//是整数除法，无论参与数是浮点还是整数。\n",
    "\n",
    "另一个讲解重点在于python不会自动转换类型。这点即是“强类型语言”。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 算符优先级\n",
    "\n",
    "* lambda\n",
    "* if - else\n",
    "* or\n",
    "* and\n",
    "* not\n",
    "* in, not in, is, is not, <, <=, >, >=, !=, == \n",
    "* |\n",
    "* ^\n",
    "* &\n",
    "* <<, >>\n",
    "* +, -\n",
    "* *, /, //, %\n",
    "* +x, -x, ~x\n",
    "* \\*\\*\n",
    "* x[index], x[index:index], x(arguments...), x.attribute\n",
    "* (expressions...), [expressions...], {key: value...}, {expressions...} \n",
    "\n",
    "使用()可以改变优先级顺序"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "同样挑讲优先级，重点几乎只有+ - * /之间。101不要全部展开。\n",
    "\n",
    "优先级的正解应当是尽量使用()，不确定的应当用python去解决而不是大脑。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 练习\n",
    "\n",
    "计算以下表达式的求值顺序，并求值算出结果：\n",
    "\n",
    "    1 + 8 <= 1 + 2 * 3\n",
    "    1 + 2 and 3 * 4 or 5 ** 6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "强调值的真假，and和or的运算特性。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 答案"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 + 8 <= 1 + 2 * 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 + 2 and 3 * 4 or 5 ** 6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 表达式\n",
    "\n",
    "表达式为一串由算符连接的元素。\n",
    "\n",
    "表达式一般会有值，值为按照优先级依次求解表达式得到的结果。\n",
    "\n",
    "有些表达式在语法上亦不可求值。\n",
    "\n",
    "表达式除了值以外，还可能造成“副作用”。即造成环境改变，或执行某些操作。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "area is 78.5\n"
     ]
    }
   ],
   "source": [
    "Pi = 3.14\n",
    "r = 5\n",
    "area = Pi * r * r\n",
    "print(\"area is {0}\".format(area))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 格式化字符串\n",
    "\n",
    "将变量的值格式化到字符串中，形成新的字符串。\n",
    "\n",
    "常用于输出数据内容。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "my name is shell and the length of name is 5\n",
      "my name is shell and the length of name is 5\n"
     ]
    }
   ],
   "source": [
    "name = 'shell'\n",
    "\n",
    "print('my name is {0} and the length of name is {1}'.format(name, len(name)))\n",
    "print('my name is %s and the length of name is %d' % (name, len(name)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# f-string\n",
    "\n",
    "借助f-string，我们可以在字符串内直接引用变量，格式化字符串。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "my name is shell and the length of name is 5\n"
     ]
    }
   ],
   "source": [
    "name = 'shell'\n",
    "\n",
    "print(f'my name is {name} and the length of name is {len(name)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 练习\n",
    "\n",
    "* 编写一行代码，打印出hello, world。\n",
    "* 假定有变量name，值为你的名字。编写代码打印出hello, [your name]。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# 执行流控制\n",
    "\n",
    "执行流控制代码控制流的先后执行顺序。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 逻辑行和物理行\n",
    "\n",
    "Python语句执行以行为单位。每行可选的可以以分号;结尾。\n",
    "\n",
    "但是物理上的一行可以包含多个执行单位，例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "i = 5; print(i);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "同一个执行单位也可以拆分为多行，例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, world\n"
     ]
    }
   ],
   "source": [
    "print(\n",
    "'Hello, world')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 格式对齐\n",
    "\n",
    "Python使用对齐表达逻辑，例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ok\n",
      "done\n"
     ]
    }
   ],
   "source": [
    "a = 1\n",
    "if a == 1:\n",
    "    print('ok')\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "当print(‘done’)和if对齐时，必然被执行。而和print(‘ok’)对齐时，在条件下执行。\n",
    "\n",
    "因此对齐不合适的代码会引发语法错误。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "------\n",
      "ok\n",
      "done\n"
     ]
    }
   ],
   "source": [
    "a = 0\n",
    "if a == 1:\n",
    "    print('ok')\n",
    "print('done')\n",
    "\n",
    "print('------')\n",
    "\n",
    "a = 1\n",
    "if a == 1:\n",
    "    print('ok')\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "------\n",
      "ok\n",
      "done\n"
     ]
    }
   ],
   "source": [
    "a = 0\n",
    "if a == 1:\n",
    "    print('ok')\n",
    "    print('done')\n",
    "\n",
    "print('------')\n",
    "\n",
    "a = 1\n",
    "if a == 1:\n",
    "    print('ok')\n",
    "    print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 单行写法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ok\n"
     ]
    }
   ],
   "source": [
    "if True: print('ok')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## if"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number: 12\n",
      "guess: 23\n",
      "No, it is a little lower than that\n",
      "Done\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "# input是python3写法，raw_input是对应的python2写法。\n",
    "# 此处四行是Python2/3兼容写法，后续统一写为input，不再出现这四行。\n",
    "try:\n",
    "    input = raw_input\n",
    "except NameError:\n",
    "    pass\n",
    "\n",
    "number = random.randint(10, 30)\n",
    "print('number:', number)\n",
    "\n",
    "guess = random.randint(10, 30)\n",
    "print(\"guess:\", guess)\n",
    "if guess == number:\n",
    "    print('Congratulations, you guessed it.')\n",
    "    print('(but you do not win any prizes!)')\n",
    "elif guess < number:\n",
    "    print('No, it is a little higher than that')\n",
    "else:\n",
    "    print('No, it is a little lower than that')\n",
    "print('Done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## while"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number: 61\n",
      "guess: 50\n",
      "No, it is a little higher than that.\n",
      "guess: 75\n",
      "No, it is a little lower than that.\n",
      "guess: 62\n",
      "No, it is a little lower than that.\n",
      "guess: 56\n",
      "No, it is a little higher than that.\n",
      "guess: 59\n",
      "No, it is a little higher than that.\n",
      "guess: 60\n",
      "No, it is a little higher than that.\n",
      "guess: 61\n",
      "Congratulations, you guessed it.\n",
      "The while loop is over.\n",
      "Done\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "number = random.randint(0, 99)\n",
    "print('number:', number)\n",
    "\n",
    "low = 0\n",
    "high = 100\n",
    "running = True\n",
    "\n",
    "while running:\n",
    "    guess = int((low+high)/2)\n",
    "    print('guess:', guess)\n",
    "    if guess == number:\n",
    "        print('Congratulations, you guessed it.')\n",
    "        running = False\n",
    "    elif guess < number:\n",
    "        print('No, it is a little higher than that.')\n",
    "        low = guess\n",
    "    else:\n",
    "        print('No, it is a little lower than that.')\n",
    "        high = guess\n",
    "else:\n",
    "    print('The while loop is over.')\n",
    "print('Done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## for"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "The for loop is over\n"
     ]
    }
   ],
   "source": [
    "for i in range(1, 5):\n",
    "    print(i)\n",
    "else:\n",
    "    print('The for loop is over')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number: 90\n",
      "guess: 50\n",
      "No, it is a little higher than that.\n",
      "guess: 75\n",
      "No, it is a little higher than that.\n",
      "guess: 87\n",
      "No, it is a little higher than that.\n",
      "guess: 93\n",
      "No, it is a little lower than that.\n",
      "guess: 90\n",
      "Congratulations, you guessed it.\n",
      "Done\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "number = random.randint(0, 99)\n",
    "print('number:', number)\n",
    "\n",
    "low = 0\n",
    "high = 100\n",
    "running = True\n",
    "\n",
    "while running:\n",
    "    guess = int((low+high)/2)\n",
    "    print('guess:', guess)\n",
    "    if guess == number:\n",
    "        print('Congratulations, you guessed it.')\n",
    "        break\n",
    "    elif guess < number:\n",
    "        print('No, it is a little higher than that.')\n",
    "        low = guess\n",
    "    else:\n",
    "        print('No, it is a little lower than that.')\n",
    "        high = guess\n",
    "else:\n",
    "    print('The while loop is over.')\n",
    "print('Done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## continue"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number: 84\n",
      "guess: 50\n",
      "No, it is a little higher than that.\n",
      "guess: 75\n",
      "No, it is a little higher than that.\n",
      "guess: 87\n",
      "No, it is a little lower than that.\n",
      "guess: 81\n",
      "No, it is a little higher than that.\n",
      "guess: 84\n",
      "Congratulations, you guessed it.\n",
      "Done\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "number = random.randint(0, 99)\n",
    "print('number:', number)\n",
    "\n",
    "low = 0\n",
    "high = 100\n",
    "running = True\n",
    "\n",
    "while running:\n",
    "    guess = int((low+high)/2)\n",
    "    print('guess:', guess)\n",
    "    if guess == number:\n",
    "        print('Congratulations, you guessed it.')\n",
    "        break\n",
    "    if guess < number:\n",
    "        print('No, it is a little higher than that.')\n",
    "        low = guess\n",
    "        continue\n",
    "    if guess > number:\n",
    "        print('No, it is a little lower than that.')\n",
    "        high = guess\n",
    "        continue\n",
    "else:\n",
    "    print('The while loop is over.')\n",
    "print('Done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 练习\n",
    "\n",
    "说出下面代码的执行过程和输出结果：\n",
    "\n",
    "    for i in range(12):\n",
    "        if i < 5:\n",
    "            continue\n",
    "        elif i > 9:\n",
    "            break\n",
    "        else:\n",
    "            print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 答案"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for i in range(12):\n",
    "    if i < 5:\n",
    "        continue\n",
    "    elif i > 9:\n",
    "        break\n",
    "    else:\n",
    "        print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# 函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 函数的定义和调用\n",
    "\n",
    "定义："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "def say_hello():\n",
    "    print('hello world')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "调用："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world\n"
     ]
    }
   ],
   "source": [
    "say_hello()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 参数\n",
    "\n",
    "可以通过参数向函数传递数据。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4 is maximum\n"
     ]
    }
   ],
   "source": [
    "def print_max(a, b):\n",
    "    if a > b:\n",
    "        print('{0} is maximum'.format(a))\n",
    "    elif a == b:\n",
    "        print('{0} is equal to {1}'.format(a, b))\n",
    "    else:\n",
    "        print('{0} is maximum'.format(b))\n",
    "print_max(3, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "exceptions\n"
     ]
    }
   ],
   "source": [
    "# python2.7下通过，python3下报错\n",
    "try:\n",
    "    print_max(3, '4')\n",
    "    print_max('3', 4)\n",
    "except:\n",
    "    print('exceptions')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "坑爹。print_max(3, '4')居然也能执行。说好的强类型呢？\n",
    "\n",
    "需要着重声明例子中的返回是违背常理的。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 局部变量\n",
    "\n",
    "在函数体内定义的变量称为局部变量。\n",
    "\n",
    "局部变量在函数执行时产生，在函数结束时消亡。函数外无法看到局部变量。\n",
    "\n",
    "参数可视为一种局部变量。\n",
    "\n",
    "对局部变量的修改不影响全局变量。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Changed local x to 2\n",
      "50\n"
     ]
    }
   ],
   "source": [
    "x = 50\n",
    "def func():\n",
    "    x = 2\n",
    "    print('Changed local x to {0}'.format(x))\n",
    "func()\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Changed local x to 2\n",
      "50\n"
     ]
    }
   ],
   "source": [
    "x = 50\n",
    "def func(x):\n",
    "    print('Changed local x to {0}'.format(x))\n",
    "func(2)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 全局变量\n",
    "\n",
    "在模块内定义的变量叫全局变量。\n",
    "\n",
    "全局变量在全局可见，函数体内可以引用全局变量。\n",
    "\n",
    "函数可以用global关键字声明某变量是全局的。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is 50\n"
     ]
    }
   ],
   "source": [
    "x = 50\n",
    "def func():\n",
    "    print('x is {0}'.format(x))\n",
    "func()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is 50 before function.\n",
      "x is 50\n",
      "Changed x to 2\n",
      "x is 2 after function.\n"
     ]
    }
   ],
   "source": [
    "x = 50\n",
    "def func():\n",
    "    global x\n",
    "    print('x is {0}'.format(x))\n",
    "    x = 2\n",
    "    print('Changed x to {0}'.format(x))\n",
    "    \n",
    "print('x is {0} before function.'.format(x))\n",
    "func()\n",
    "print('x is {0} after function.'.format(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 作用域\n",
    "\n",
    "变量可见的范围叫做变量的作用域。\n",
    "\n",
    "局部变量的作用域在函数内，全局变量的作用域在模块内（关于模块后文会讲）。\n",
    "\n",
    "作用域的基本原则是，内层作用域可访问外层作用域的变量，反之外层不可访问内层变量。\n",
    "\n",
    "如果两个作用域内有同一个名字，那么内层的起作用。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Unbound异常\n",
    "\n",
    "python内的“local中有变量定义”，是以local中存在对变量构建的语法（例如赋值）为标准的。\n",
    "\n",
    "这个构建语法所在行可能尚未执行（或永远无法执行到），但是这并不影响“local中有变量定义”这个事实。\n",
    "\n",
    "当local中定义了变量，但是变量尚未完成构建时，对变量做引用，会发生什么？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "ename": "UnboundLocalError",
     "evalue": "local variable 'x' referenced before assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mUnboundLocalError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-47-d73f257fa89f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-47-d73f257fa89f>\u001b[0m in \u001b[0;36mfunc\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m     \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mUnboundLocalError\u001b[0m: local variable 'x' referenced before assignment"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "\n",
    "def func():\n",
    "    print(x)\n",
    "    x = 2\n",
    "    \n",
    "func()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 参数默认值\n",
    "\n",
    "函数定义时，可以给参数一个值。当调用时，该参数并未给出的情况下，使用默认值。\n",
    "\n",
    "提示：从安全性角度来说，不要使用可变对象作为参数默认值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "WorldWorldWorldWorldWorld\n"
     ]
    }
   ],
   "source": [
    "def say(message, times=1):\n",
    "    print(message * times)\n",
    "\n",
    "say('Hello')\n",
    "say('World', 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1]\n",
      "[1]\n",
      "------\n",
      "[1]\n",
      "[1, 1]\n"
     ]
    }
   ],
   "source": [
    "def append1(l=[]):\n",
    "    l.append(1)\n",
    "    return l\n",
    "\n",
    "print(append1([]))\n",
    "print(append1([]))\n",
    "\n",
    "print('------')\n",
    "\n",
    "print(append1())\n",
    "print(append1())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "遇到希望使用可变对象作为参数默认值的情况，需要使用None作为默认值。\n",
    "\n",
    "在函数中判断是否为None，是的话再对参数做默认值赋值处理。\n",
    "\n",
    "以此模式来避免上述问题。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1]\n",
      "[1]\n",
      "------\n",
      "[1]\n",
      "[1]\n"
     ]
    }
   ],
   "source": [
    "def append1(l=None):\n",
    "    if l is None:\n",
    "        l = []\n",
    "    l.append(1)\n",
    "    return l\n",
    "\n",
    "print(append1([]))\n",
    "print(append1([]))\n",
    "\n",
    "print('------')\n",
    "\n",
    "print(append1())\n",
    "print(append1())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 返回值\n",
    "\n",
    "将函数内数据传递回去。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "The numbers are equal\n"
     ]
    }
   ],
   "source": [
    "def maximum(x, y):\n",
    "    if x > y:\n",
    "        return x\n",
    "    elif x == y:\n",
    "        return 'The numbers are equal'\n",
    "    else:\n",
    "        return y\n",
    "\n",
    "print(maximum(2, 3))\n",
    "print(maximum(2, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 多值返回\n",
    "\n",
    "Python允许一次返回多个值。\n",
    "\n",
    "多值返回的本质是使用tuple中转（后面详细讲解）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "提前强调“最小惊讶原则”。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4, 5)\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "def f():\n",
    "    return 1,2,3,4,5\n",
    "print (f())\n",
    "\n",
    "a,b,c,d,e = f()\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Doc String\n",
    "\n",
    "Python允许为每个函数增加一个文档字符串，这个文档字符串可以被代码访问。\n",
    "\n",
    "具体方式是，在函数的第一个逻辑行定义一个字符串（不执行任何操作）。\n",
    "\n",
    "访问方式是function.\\_\\_doc\\_\\_。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "讲解doc string在文档里的作用，对比java doc。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 is maximum\n",
      "Prints the maximum of two numbers. \n",
      "The two values must be integers.\n"
     ]
    }
   ],
   "source": [
    "def print_max(x, y):\n",
    "    '''Prints the maximum of two numbers. \\nThe two values must be integers.'''\n",
    "    x = int(x)\n",
    "    y = int(y)\n",
    "    if x > y:\n",
    "        print('{} is maximum'.format(x))\n",
    "    else:\n",
    "        print('{} is maximum'.format(y))\n",
    "\n",
    "print_max(3, 5)\n",
    "print(print_max.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Annotations\n",
    "\n",
    "Python允许对函数的变量进行注解，表明参数和返回值的类型。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def maximum(x: int, y: int) -> int:\n",
    "    if x > y:\n",
    "        return x\n",
    "    elif x == y:\n",
    "        return 'The numbers are equal'\n",
    "    else:\n",
    "        return y\n",
    "\n",
    "maximum(1, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "然而，Python默认对注解不做验证。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2'"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "maximum('1', '2')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## lambda\n",
    "\n",
    "一种快速定义简单函数的方法。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n",
      "11\n"
     ]
    }
   ],
   "source": [
    "def inc(n):\n",
    "    return n+1\n",
    "print(inc(10))\n",
    "\n",
    "inc = lambda n: n+1\n",
    "print(inc(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 练习\n",
    "\n",
    "定义fib函数。\n",
    "\n",
    "输入n，fib的输出为数列第n项的值。\n",
    "\n",
    "数列某项等于前两项之和。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "可演示递归和循环算法，比较其特性。说明简洁和快速的矛盾。\n",
    "\n",
    "可以在最后使用for循环打印输出，为后面“\\_\\_main\\_\\_标准写法”打基础。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 答案"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "89"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def fib(n):\n",
    "    if n <= 1: return 1\n",
    "    return fib(n-1) + fib(n-2)\n",
    "\n",
    "fib(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# 模块"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Module\n",
    "\n",
    "预先写好的代码，供其他代码使用。\n",
    "\n",
    "一个module是一个独立文件。\n",
    "\n",
    "每个module拥有自己的全局变量空间。数据定义，函数，均定义在其中。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing testmod.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile testmod.py\n",
    "varible1 = 1\n",
    "varible2 = 2\n",
    "\n",
    "def add(a, b):\n",
    "    return a+b\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    print('run as script')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-rw-r--r-- 1 shell shell 111 Mar 22 20:06 testmod.py\r\n"
     ]
    }
   ],
   "source": [
    "!ls -l testmod.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Windows下要用dir testmod.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## import\n",
    "\n",
    "import引入某个module对象，可使用module.name的方式引用它的全局变量。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import testmod\n",
    "testmod.varible1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## from import\n",
    "\n",
    "from import引入模块中的某个（或全部）变量。\n",
    "\n",
    "被引入变量不需要module.name来访问，仅需要name。\n",
    "\n",
    "注意：不推荐引入全部变量，会引起名称空间污染。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from testmod import varible2\n",
    "varible2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## dir\n",
    "\n",
    "列出某个模块的所有变量。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__builtins__',\n",
       " '__cached__',\n",
       " '__doc__',\n",
       " '__file__',\n",
       " '__loader__',\n",
       " '__name__',\n",
       " '__package__',\n",
       " '__spec__',\n",
       " 'add',\n",
       " 'varible1',\n",
       " 'varible2']"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import testmod\n",
    "dir(testmod)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 模块预编译\n",
    "\n",
    "当import时，python会试图去编译出pyc文件来。\n",
    "\n",
    "pyc是被编译过的py文件，加载pyc文件可以跳过语法解析过程。\n",
    "\n",
    "当py日期新于pyc时，重新生成pyc。所以日期紊乱可能导致执行老代码。\n",
    "\n",
    "在Python3(3.2以后)中，会在当前目录下生成\\_\\_pycache\\_\\_目录，来缓存pyc文件。\n",
    "\n",
    "这样可以避免多个Python解释器无法互相载入对方的pyc文件。\n",
    "\n",
    "具体可以参考这里： https://docs.python.org/3/whatsnew/3.2.html "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "注意加载顺序导致当前目录模块名和系统相同时会发生覆盖问题。\n",
    "\n",
    "同时注意这个现象受制于系统库是否已经载入，从而引出系统库不会多次“加载”的结论。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-rw-r--r-- 1 shell shell 111 Mar 22 20:06 testmod.py\r\n"
     ]
    }
   ],
   "source": [
    "!ls -l testmod*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-rw-r--r-- 1 shell shell 365 Jun 25  2018 __pycache__/testmod.cpython-35.pyc\r\n",
      "-rw-r--r-- 1 shell shell 349 Mar 22 20:06 __pycache__/testmod.cpython-37.pyc\r\n"
     ]
    }
   ],
   "source": [
    "!ls -l __pycache__/testmod*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "由于这个系统使用了Python3作为基础，因此没有`testmod.pyc`文件。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## \\_\\_name\\_\\_属性\n",
    "\n",
    "模块有一个属性，\\_\\_name\\_\\_。当这个属性为'\\_\\_main\\_\\_'时，说明当前模块被作为脚本运行。\n",
    "\n",
    "模块被作为以脚本运行时，不生成pyc文件（因为不是import）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'__main__'"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "__name__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'testmod'"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "testmod.__name__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Main文件模式化写法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "if __name__ == '__main__':\r\n",
      "    print('run as script')"
     ]
    }
   ],
   "source": [
    "!tail -n 2 testmod.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "run as script\r\n"
     ]
    }
   ],
   "source": [
    "!python testmod.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "!rm testmod*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Package\n",
    "\n",
    "从组织结构上说，package是比modules更大一级的结构。\n",
    "\n",
    "一个package里可以包含多个modules和packages。\n",
    "\n",
    "一般一个package是一个独立目录，里面有\\_\\_init\\_\\_.py文件。\n",
    "\n",
    "这个文件指明了如何加载整个package。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "可以找一些实际的文件布局的例子。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 练习\n",
    "\n",
    "* 导入系统sys模块\n",
    "* 列出sys模块中以s开头并且以e结尾的成员。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "此处需要提前说明startswith和endswith的用法。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 答案"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "setprofile\n",
      "settrace\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "for name in dir(sys):\n",
    "    if name.startswith('s') and name.endswith('e'):\n",
    "        print(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# 内置数据结构\n",
    "\n",
    "* list\n",
    "* tuple\n",
    "* dict\n",
    "* set\n",
    "* string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## list\n",
    "\n",
    "具有顺序的一组对象。\n",
    "\n",
    "可以随意访问其中的任意位置。\n",
    "\n",
    "可以添加和删除。\n",
    "\n",
    "其中的元素不需要是同类型。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "原书例子有问题，那是python3的代码。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I have 4 items to purchase.\n",
      "These items are: apple mango carrot banana \n",
      "I also have to buy rice.\n",
      "My shopping list is now ['apple', 'mango', 'carrot', 'banana', 'rice']\n",
      "I will sort my list now\n",
      "Sorted shopping list is ['apple', 'banana', 'carrot', 'mango', 'rice']\n",
      "The first item I will buy is apple\n",
      "I bought the apple\n",
      "My shopping list is now ['banana', 'carrot', 'mango', 'rice']\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "shoplist = ['apple', 'mango', 'carrot', 'banana']\n",
    "\n",
    "print('I have {} items to purchase.'.format(len(shoplist)))\n",
    "sys.stdout.write('These items are: ')\n",
    "for item in shoplist:\n",
    "    sys.stdout.write(str(item) + ' ')\n",
    "\n",
    "print('\\nI also have to buy rice.')\n",
    "shoplist.append('rice')\n",
    "print('My shopping list is now {0}'.format(shoplist))\n",
    "\n",
    "print('I will sort my list now')\n",
    "shoplist.sort()\n",
    "print('Sorted shopping list is {0}'.format(shoplist))\n",
    "\n",
    "print('The first item I will buy is {0}'.format(shoplist[0]))\n",
    "olditem = shoplist[0]\n",
    "del shoplist[0]\n",
    "print('I bought the {0}'.format(olditem))\n",
    "print('My shopping list is now {0}'.format(shoplist))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## tuple\n",
    "\n",
    "具有顺序的一组对象。\n",
    "\n",
    "可以随意访问其中的任意位置。\n",
    "\n",
    "不可以添加和删除。\n",
    "\n",
    "其中的元素不需要是同类型。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of animals in the zoo is 3\n",
      "Number of cages in the new zoo is 3\n",
      "All animals in new zoo are ('monkey', 'camel', ('python', 'elephant', 'penguin'))\n",
      "Animals brought from old zoo are ('python', 'elephant', 'penguin')\n",
      "Last animal brought from old zoo is penguin\n",
      "Number of animals in the new zoo is 5\n"
     ]
    }
   ],
   "source": [
    "zoo = ('python', 'elephant', 'penguin')\n",
    "print('Number of animals in the zoo is {0}'.format(len(zoo)))\n",
    "\n",
    "new_zoo = 'monkey', 'camel', zoo\n",
    "print('Number of cages in the new zoo is {0}'.format(len(new_zoo)))\n",
    "\n",
    "print('All animals in new zoo are {0}'.format(new_zoo))\n",
    "print('Animals brought from old zoo are {0}'.format(new_zoo[2]))\n",
    "print('Last animal brought from old zoo is {0}'.format(new_zoo[2][2]))\n",
    "print('Number of animals in the new zoo is {0}'.format(len(new_zoo)-1+len(new_zoo[2])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3)"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r = 1, 2, 3\n",
    "r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "a, b, c = r\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "a, b = b, a\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 操作序列对象\n",
    "\n",
    "* 通过[]访问\n",
    "* 通过[]设定值\n",
    "* 通过for枚举\n",
    "* 通过[:]访问\n",
    "* 通过[:]设定值\n",
    "* 通过[::]设定步进"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Item 0 is apple\n",
      "Item 1 is mango\n",
      "Item 2 is carrot\n",
      "Item 3 is banana\n",
      "Item -1 is banana\n",
      "Item -2 is carrot\n",
      "Character 0 is s\n",
      "Item 1 to 3 is ['mango', 'carrot']\n",
      "Item 2 to end is ['carrot', 'banana']\n",
      "Item 1 to -1 is ['mango', 'carrot']\n",
      "Item start to end is ['apple', 'mango', 'carrot', 'banana']\n",
      "characters 1 to 3 is wa\n",
      "characters 2 to end is aroop\n",
      "characters 1 to -1 is waroo\n",
      "characters start to end is swaroop\n",
      "reversed characters is pooraws\n"
     ]
    }
   ],
   "source": [
    "shoplist = ['apple', 'mango', 'carrot', 'banana']\n",
    "name = 'swaroop'\n",
    "print('Item 0 is {0}'.format(shoplist[0]))\n",
    "print('Item 1 is {0}'.format(shoplist[1]))\n",
    "print('Item 2 is {0}'.format(shoplist[2]))\n",
    "print('Item 3 is {0}'.format(shoplist[3]))\n",
    "print('Item -1 is {0}'.format(shoplist[-1]))\n",
    "print('Item -2 is {0}'.format(shoplist[-2]))\n",
    "print('Character 0 is {0}'.format(name[0]))\n",
    "\n",
    "print('Item 1 to 3 is {0}'.format(shoplist[1:3]))\n",
    "print('Item 2 to end is {0}'.format(shoplist[2:]))\n",
    "print('Item 1 to -1 is {0}'.format(shoplist[1:-1]))\n",
    "print('Item start to end is {0}'.format(shoplist[:]))\n",
    "print('characters 1 to 3 is {0}'.format(name[1:3]))\n",
    "print('characters 2 to end is {0}'.format(name[2:]))\n",
    "print('characters 1 to -1 is {0}'.format(name[1:-1]))\n",
    "print('characters start to end is {0}'.format(name[:]))\n",
    "print('reversed characters is {0}'.format(name[::-1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 练习\n",
    "\n",
    "1. 建立一个list，内容为10以内的所有质数。\n",
    "2. 计算出100内所有质数的列表。\n",
    "3. 将这个列表转为tuple。\n",
    "4. 根据上面的tuple，获得反转的tuple。\n",
    "5. 将一个list分为两个：第一个list拥有原本list前一半的反向，第二个list拥有原本list后一半的反向。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "埃拉托斯特尼筛法。注意代码实现中的筛法效率是有问题的。主要因为sqrt函数没教过。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 答案"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 5, 7]"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "primes = [2, 3, 5, 7]\n",
    "primes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]\n"
     ]
    }
   ],
   "source": [
    "for i in range(10, 100):\n",
    "    prime = True\n",
    "    for j in primes:\n",
    "        if i % j == 0:\n",
    "            prime = False\n",
    "            break\n",
    "    if prime:\n",
    "        primes.append(i)\n",
    "print(primes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97)\n"
     ]
    }
   ],
   "source": [
    "tuple_primes = tuple(primes)\n",
    "print(tuple_primes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(97, 89, 83, 79, 73, 71, 67, 61, 59, 53, 47, 43, 41, 37, 31, 29, 23, 19, 17, 13, 11, 7, 5, 3, 2)\n"
     ]
    }
   ],
   "source": [
    "print(tuple_primes[::-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(97, 89, 83, 79, 73, 71, 67, 61, 59, 53, 47, 43, 41, 37, 31, 29, 23, 19, 17, 13, 11, 7, 5, 3, 2)\n"
     ]
    }
   ],
   "source": [
    "print(tuple(reversed(tuple_primes)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([37, 31, 29, 23, 19, 17, 13, 11, 7, 5, 3, 2],\n",
       " [97, 89, 83, 79, 73, 71, 67, 61, 59, 53, 47, 43, 41])"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Python2下可以不需要int，因为len结果是整数，整数除法结果是整数。\n",
    "# 在Python3，没有int会导致出错。\n",
    "list(reversed(primes[:int(len(primes)/2)])), list(reversed(primes[int(len(primes)/2):]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([37, 31, 29, 23, 19, 17, 13, 11, 7, 5, 3, 2],\n",
       " [97, 89, 83, 79, 73, 71, 67, 61, 59, 53, 47, 43, 41])"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "primes[int(len(primes)/2-1)::-1], primes[:int(len(primes)/2-1):-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 列表推导式"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121]\n"
     ]
    }
   ],
   "source": [
    "l = range(12)\n",
    "t = [i * i for i in l]\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 9, 25, 49, 81, 121]\n"
     ]
    }
   ],
   "source": [
    "t = [i * i for i in l if i % 2 != 0]\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 练习\n",
    "\n",
    "思考一下，列表推导式是否能够将素数列表直接实现出来？为什么？\n",
    "\n",
    "然后自己测试一下。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "问题的关键在于“生成列表的时候列表是空的”。所以不能一次性生成，必须渐进。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## dict\n",
    "\n",
    "具有一系列成对对象。一个叫做key，一个叫做value。\n",
    "\n",
    "无顺序，key不可重复。\n",
    "\n",
    "通过其中一个(key)可以唯一确定另外一个(value)，反之未必。\n",
    "\n",
    "可以添加和删除。\n",
    "\n",
    "其中的元素(包括key和value)不需要是同类型。\n",
    "\n",
    "key必须是不可变对象。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "1: 注意在某些情况下，dict可表现出内在顺序。但这并不是有序约定。\n",
    "\n",
    "2: 在Python3.6之后，dict表现出类似于OrderedDict的性质。现阶段可无视这个差异。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Swaroop's address is swaroop@swaroopch.com\n",
      "There are 3 contacts in the address-book\n",
      "Name list: Swaroop, Larry, Matsumoto\n",
      "Contact Swaroop at swaroop@swaroopch.com\n",
      "Contact Larry at larry@wall.org\n",
      "Contact Matsumoto at matz@ruby-lang.org\n",
      "Guido's address is guido@python.org\n"
     ]
    }
   ],
   "source": [
    "ab = {\n",
    "    'Swaroop': 'swaroop@swaroopch.com',\n",
    "    'Larry': 'larry@wall.org',\n",
    "    'Matsumoto': 'matz@ruby-lang.org',\n",
    "    'Spammer': 'spammer@hotmail.com'\n",
    "}\n",
    "\n",
    "print(\"Swaroop's address is {}\".format(ab['Swaroop']))\n",
    "del ab['Spammer']\n",
    "\n",
    "print('There are {} contacts in the address-book'.format(len(ab)))\n",
    "print('Name list: %s' % ', '.join(ab))\n",
    "for name, address in ab.items():\n",
    "    print('Contact {} at {}'.format(name, address))\n",
    "\n",
    "ab['Guido'] = 'guido@python.org'\n",
    "if 'Guido' in ab:\n",
    "    print(\"Guido's address is {}\".format(ab['Guido']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## set\n",
    "\n",
    "具有一组对象。无顺序，不可重复。\n",
    "\n",
    "可以添加和删除。\n",
    "\n",
    "其中的元素不需要是同类型，但必须是不可变对象。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bri = set(['brazil', 'russia', 'india'])\n",
    "bri = {'brazil', 'russia', 'india'}\n",
    "'india' in bri"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'usa' in bri"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'china', 'russia', 'brazil', 'india'}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bric = bri.copy()\n",
    "bric.add('china')\n",
    "print(bric)\n",
    "bric.issuperset(bri)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'china', 'brazil', 'india'}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'brazil', 'india'}"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bric.remove('russia')\n",
    "print(bric)\n",
    "bri & bric"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'brazil', 'china', 'india', 'russia'}"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bri | bric"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## string的一些其他方法\n",
    "\n",
    "* startswith\n",
    "* endswith\n",
    "* in\n",
    "* find\n",
    "* replace\n",
    "* upper\n",
    "* lower\n",
    "* join\n",
    "* split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yes, the string starts with \"Swa\"\n",
      "Yes, it contains the string \"a\"\n",
      "position of the string \"war\" is 1\n",
      "the string replace war to peace is Speaceoop\n",
      "the string replace o to 0 is Swar00p\n",
      "upper case: SWAROOP\n",
      "lower case: swaroop\n",
      "Brazil_*_Russia_*_India_*_China\n",
      "['Brazil', 'Russia', 'India', 'China']\n",
      "['Brazil_', '_Russia_', '_India_', '_China']\n"
     ]
    }
   ],
   "source": [
    "name = 'Swaroop'\n",
    "if name.startswith('Swa'):\n",
    "    print('Yes, the string starts with \"Swa\"')\n",
    "\n",
    "if 'a' in name:\n",
    "    print('Yes, it contains the string \"a\"')\n",
    "\n",
    "pos = name.find('war')\n",
    "if pos != -1:\n",
    "    print('position of the string \"war\" is %d' % pos)\n",
    "\n",
    "print(\"the string replace war to peace is %s\" % name.replace('war', 'peace'))\n",
    "print(\"the string replace o to 0 is %s\" % name.replace('o', '0'))\n",
    "\n",
    "print(\"upper case: %s\" % name.upper())\n",
    "print(\"lower case: %s\" % name.lower())\n",
    "\n",
    "delimiter = '_*_'\n",
    "mylist = ['Brazil', 'Russia', 'India', 'China']\n",
    "print(delimiter.join(mylist))\n",
    "\n",
    "print(delimiter.join(mylist).split(delimiter))\n",
    "print(delimiter.join(mylist).split('*'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 练习\n",
    "\n",
    "每个国家都有一定的地区号码，现在我们知道这些国家和地区号码关系：\n",
    "\n",
    "+30 希腊 +45 丹麦 +51 秘鲁 +65 新加坡 +86 中国\n",
    "\n",
    "写代码求出以下电话号码里面有几个国家：\n",
    "\n",
    "+86 1123 +65 1234 +51 2347 +30 9123 +65 1246 +30 2347 +86 2935"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 答案"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "希腊, 秘鲁, 新加坡, 中国\n"
     ]
    }
   ],
   "source": [
    "number2country = {\n",
    "    '+30': u'希腊',\n",
    "    '+45': u'丹麦',\n",
    "    '+51': u'秘鲁',\n",
    "    '+65': u'新加坡',\n",
    "    '+86': u'中国'\n",
    "}\n",
    "\n",
    "numbers = \"+86 1123 +65 1234 +51 2347 +30 9123 +65 1246 +30 2347 +86 2935\".split()\n",
    "country_set = set([number2country[n] for n in numbers if n.startswith('+')])\n",
    "\n",
    "print(len(country_set))\n",
    "# 注意：这里的输出顺序在不同的机器上可能不一样，具体依赖于python的版本和实现。set本身是没有顺序约定的。\n",
    "print(', '.join(country_set))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "numbers: ['+86', '1123', '+65', '1234', '+51', '2347', '+30', '9123', '+65', '1246', '+30', '2347', '+86', '2935']\n",
      "filtered: ['+86', '+65', '+51', '+30', '+65', '+30', '+86']\n",
      "filtered and mapped: 中国, 新加坡, 秘鲁, 希腊, 新加坡, 希腊, 中国\n",
      "希腊, 秘鲁, 新加坡, 中国\n"
     ]
    }
   ],
   "source": [
    "numbers = \"+86 1123 +65 1234 +51 2347 +30 9123 +65 1246 +30 2347 +86 2935\".split()\n",
    "print(\"numbers: %s\" % str(numbers))\n",
    "print(\"filtered: %s\" % str([n for n in numbers if n.startswith('+')]))\n",
    "print(\"filtered and mapped: %s\" % ', '.join([number2country[n] for n in numbers if n.startswith('+')]))\n",
    "country_set = set([number2country[n] for n in numbers if n.startswith('+')])\n",
    "print(', '.join(country_set))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# 面对对象编程"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "“一个苹果加一个苹果是什么？”\n",
    "\n",
    "“两个苹果。”\n",
    "\n",
    "“一个雪梨加一个雪梨呢？”\n",
    "\n",
    "“两个雪梨。”\n",
    "\n",
    "“一个苹果加一个雪梨呢？”\n",
    "\n",
    "“……”\n",
    "\n",
    "虽然妲柯妮丝不知道这和欣赏抽象画有什么关系，但还是敲着额头想了想。\n",
    "\n",
    "“……两个水果？”\n",
    "\n",
    "“明白了吧？”冰清灵看着若有所思的妲柯妮丝笑道，“从苹果、雪梨到水果，其实是一个去掉不同的部分，然后把相同的部分进行累加的一个过程。从水果、杯子到‘东西’，也是它们的存在本身，也是一样的道理。”\n",
    "\n",
    "——XINPINGYE《御天者.星星》"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## class\n",
    "\n",
    "如何定义类："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person:\n",
    "    pass  # An empty block"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如何使用类产生对象："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.Person object at 0x7f13cc23b358>\n"
     ]
    }
   ],
   "source": [
    "p = Person()\n",
    "print(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 方法\n",
    "\n",
    "如何定义类的成员方法："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, how are you?\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def say_hi(self):\n",
    "        print('Hello, how are you?')\n",
    "\n",
    "p = Person()\n",
    "p.say_hi()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 数据\n",
    "\n",
    "对象里包含的数据。\n",
    "\n",
    "可以用.访问。\n",
    "\n",
    "和方法的主要差别在于。方法需要使用()来调用，而数据不需要。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "shell\n",
      "hello, shell, how are you?\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def set_name(self, name):\n",
    "        self.name = name\n",
    "\n",
    "    def say_hi(self):\n",
    "        print('hello, {}, how are you?'.format(self.name))\n",
    "        \n",
    "p = Person()\n",
    "p.set_name('shell')\n",
    "print(p.name)\n",
    "p.say_hi()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## self\n",
    "\n",
    "在python中，成员函数使用”self”来指代对象自身。类似于java和C++中的”this”。\n",
    "\n",
    "在调用时，p.say_hi()即可。不需要传递p.say_hi(self)或者p.say_hi(p)。\n",
    "\n",
    "在使用时，需要先将self定义为第一个参数。例如def say_hi(self):。\n",
    "    \n",
    "在函数内使用时，对象的成员需要用self.xx的方式使用，例如self.name。\n",
    "\n",
    "self不是关键词，也不是强制名称。它只是函数的第一个参数。但是为了保持传统，请不要将他改为其他名称。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## \\_\\_init\\_\\_方法\n",
    "\n",
    "\\_\\_init\\_\\_是对象的第一个方法，用于初始化对象数据。\n",
    "\n",
    "\\_\\_init\\_\\_函数是初始化方法，而非构造方法。\n",
    "\n",
    "在\\_\\_init\\_\\_函数被调用时，self对象已经创建完毕。\n",
    "\n",
    "在python中，对象的属性可以自由添加删除，不需要先在类里面声明。\n",
    "\n",
    "一般而言，对象里的所有数据会在\\_\\_init\\_\\_方法中赋值，后面可以变更。\n",
    "\n",
    "但是不在\\_\\_init\\_\\_中赋值，后面直接赋值创建属性也是合法的。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Swaroop\n",
      "hello, Swaroop, how are you?\n",
      "shell\n",
      "hello, shell, how are you?\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "\n",
    "    def set_name(self, name):\n",
    "        self.name = name\n",
    "\n",
    "    def say_hi(self):\n",
    "        print('hello, {}, how are you?'.format(self.name))\n",
    "\n",
    "p = Person('Swaroop')\n",
    "print(p.name)\n",
    "p.say_hi()\n",
    "\n",
    "p.set_name('shell')\n",
    "print(p.name)\n",
    "p.say_hi()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 练习\n",
    "\n",
    "定义一个马克杯类，定义一个加水方法和一个喝水方法。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 答案"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Mug:\n",
    "\n",
    "    def __init__(self):\n",
    "        self.water = 0\n",
    "\n",
    "    def drink(self, mass):\n",
    "        self.water -= mass\n",
    "\n",
    "    def watering(self, mass):\n",
    "        self.water += mass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 类成员和对象成员\n",
    "\n",
    "类和对象分别拥有成员，例如数据和方法。\n",
    "\n",
    "对象可以引用类成员，例如p.say_hi()。也可以引用对象成员，或者self.name。\n",
    "\n",
    "当有重名时优先引用对象成员。\n",
    "\n",
    "类成员在所有对象间共享，而对象成员只是它自己的。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "这里是否要加个例子说明类和对象变量的优先引用次序。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Robot:\n",
    "    \"\"\"Represents a robot, with a name.\"\"\"\n",
    "\n",
    "    # A class variable, counting the number of robots\n",
    "    population = 0\n",
    "\n",
    "    def __init__(self, name):\n",
    "        \"\"\"Initializes the data.\"\"\"\n",
    "        self.name = name\n",
    "        print(\"(Initializing {})\".format(self.name))\n",
    "        # When this person is created, the robot\n",
    "        # adds to the population\n",
    "        Robot.population += 1\n",
    "\n",
    "    def die(self):\n",
    "        \"\"\"I am dying.\"\"\"\n",
    "        print(\"{} is being destroyed!\".format(self.name))\n",
    "        Robot.population -= 1\n",
    "        if Robot.population == 0:\n",
    "            print(\"{} was the last one.\".format(self.name))\n",
    "        else:\n",
    "            print(\"There are still {:d} robots working.\".format(\n",
    "                Robot.population))\n",
    "\n",
    "    def say_hi(self):\n",
    "        \"\"\"Greeting by the robot.\n",
    "        Yeah, they can do that.\"\"\"\n",
    "        print(\"Greetings, my masters call me {}.\".format(self.name))\n",
    "\n",
    "    @classmethod\n",
    "    def how_many(cls):\n",
    "        \"\"\"Prints the current population.\"\"\"\n",
    "        print(\"We have {:d} robots.\".format(cls.population))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Initializing R2-D2)\n",
      "Greetings, my masters call me R2-D2.\n",
      "We have 1 robots.\n",
      "(Initializing C-3PO)\n",
      "Greetings, my masters call me C-3PO.\n",
      "We have 2 robots.\n",
      "\n",
      "Robots can do some work here.\n",
      "\n",
      "Robots have finished their work. So let's destroy them.\n",
      "R2-D2 is being destroyed!\n",
      "There are still 1 robots working.\n",
      "C-3PO is being destroyed!\n",
      "C-3PO was the last one.\n",
      "We have 0 robots.\n"
     ]
    }
   ],
   "source": [
    "droid1 = Robot(\"R2-D2\")\n",
    "droid1.say_hi()\n",
    "Robot.how_many()\n",
    "\n",
    "droid2 = Robot(\"C-3PO\")\n",
    "droid2.say_hi()\n",
    "Robot.how_many()\n",
    "\n",
    "print(\"\\nRobots can do some work here.\\n\")\n",
    "\n",
    "print(\"Robots have finished their work. So let's destroy them.\")\n",
    "droid1.die()\n",
    "droid2.die()\n",
    "\n",
    "Robot.how_many()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 练习\n",
    "\n",
    "回想一下，上一节你的定义里是否考虑了马克杯的“最大容量”。如果没有，请加上。\n",
    "\n",
    "思考一下，“最大容量”是对象属性还是类属性，为什么？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 答案"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Mug:\n",
    "\n",
    "    capacity = 300\n",
    "\n",
    "    def __init__(self):\n",
    "        self.water = 0\n",
    "\n",
    "    def drink(self, mass):\n",
    "        self.water -= mass\n",
    "        if self.water < 0:\n",
    "            self.water = 0\n",
    "\n",
    "    def watering(self, mass):\n",
    "        self.water += mass\n",
    "        if self.water > self.capacity:\n",
    "            self.water = self.capacity"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 继承\n",
    "\n",
    "继承关系分为基类和继承类（也叫父类和子类）。\n",
    "\n",
    "子类可以继承父类的成员。当子类和父类定义同名成员时，优先引用子类的。\n",
    "\n",
    "原则上说，父类能做的事，子类一定能做（虽然行为可能有差异）。父类能出现的地方，子类一定能出现。\n",
    "\n",
    "因为子类拥有父类的所有成员。\n",
    "\n",
    "继承的写法为：\n",
    "\n",
    "    class Person(Animal):\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class SchoolMember:\n",
    "    '''Represents any school member.'''\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        print('(Initialized SchoolMember: {})'.format(self.name))\n",
    "\n",
    "    def tell(self):\n",
    "        '''Tell my details.'''\n",
    "        print('Name:\"{}\" Age:\"{}\"'.format(self.name, self.age))\n",
    "\n",
    "\n",
    "class Teacher(SchoolMember):\n",
    "    '''Represents a teacher.'''\n",
    "    def __init__(self, name, age, salary):\n",
    "        SchoolMember.__init__(self, name, age)\n",
    "        self.salary = salary\n",
    "        print('(Initialized Teacher: {})'.format(self.name))\n",
    "\n",
    "    def tell(self):\n",
    "        SchoolMember.tell(self)\n",
    "        print('Salary: \"{:d}\"'.format(self.salary))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Initialized SchoolMember: Mrs. Shrividya)\n",
      "(Initialized Teacher: Mrs. Shrividya)\n",
      "(Initialized SchoolMember: Swaroop)\n",
      "(Initialized Student: Swaroop)\n",
      "\n",
      "Name:\"Mrs. Shrividya\" Age:\"40\"\n",
      "Salary: \"30000\"\n",
      "Name:\"Swaroop\" Age:\"25\"\n",
      "Marks: \"75\"\n"
     ]
    }
   ],
   "source": [
    "class Student(SchoolMember):\n",
    "    '''Represents a student.'''\n",
    "    def __init__(self, name, age, marks):\n",
    "        SchoolMember.__init__(self, name, age)\n",
    "        self.marks = marks\n",
    "        print('(Initialized Student: {})'.format(self.name))\n",
    "\n",
    "    def tell(self):\n",
    "        SchoolMember.tell(self)\n",
    "        print('Marks: \"{:d}\"'.format(self.marks))\n",
    "\n",
    "t = Teacher('Mrs. Shrividya', 40, 30000)\n",
    "s = Student('Swaroop', 25, 75)\n",
    "\n",
    "# prints a blank line\n",
    "print()\n",
    "\n",
    "members = [t, s]\n",
    "for member in members:\n",
    "    # Works for both Teachers and Students\n",
    "    member.tell()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 练习\n",
    "\n",
    "请为马克杯增加一个“添满”方法，可以求出需要添多少水到加满，并自动为杯子加水。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 答案"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Mug(object):\n",
    "    capacity = 300\n",
    "\n",
    "    def __init__(self):\n",
    "        self.water = 0\n",
    "\n",
    "    def drink(self, mass):\n",
    "        self.water -= mass\n",
    "        if self.water < 0:\n",
    "            self.water = 0\n",
    "\n",
    "    def watering(self, mass):\n",
    "        self.water += mass\n",
    "        if self.water > self.capacity:\n",
    "            self.water = self.capacity\n",
    "\n",
    "    def full(self):\n",
    "        mass = self.capacity - self.water\n",
    "        self.watering(mass)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 练习\n",
    "\n",
    "请定义一个运动杯类，并同样实现“喝水”，“加水”和“添满”方法。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 练习\n",
    "\n",
    "考虑一下，如果“马克杯”和“运动杯”的“喝水”和“添水”行为是不一样的。\n",
    "\n",
    "那么，“添满”行为是否一样，两边是否可以重用“添满”？\n",
    "\n",
    "如果可以，怎么做？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 答案"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "class Cup(object):\n",
    "\n",
    "    def __init__(self):\n",
    "        self.water = 0\n",
    "\n",
    "    def full(self):\n",
    "        mass = self.capacity - self.water\n",
    "        self.watering(mass)\n",
    "\n",
    "class Mug(Cup):\n",
    "    capacity = 300\n",
    "\n",
    "    def drink(self, mass):\n",
    "        self.water -= mass\n",
    "        if self.water < 0:\n",
    "            self.water = 0\n",
    "\n",
    "    def watering(self, mass):\n",
    "        self.water += mass\n",
    "        if self.water > self.capacity:\n",
    "            self.water = self.capacity\n",
    "\n",
    "class SportBottle(Cup):\n",
    "    capacity = 500\n",
    "\n",
    "    def drink(self, mass):\n",
    "        self.water -= mass\n",
    "        if self.water < 0:\n",
    "            self.water = 0\n",
    "\n",
    "    def watering(self, mass):\n",
    "        self.water += mass\n",
    "        if self.water > self.capacity:\n",
    "            self.water = self.capacity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "200\n",
      "400\n"
     ]
    }
   ],
   "source": [
    "m = Mug()\n",
    "m.full()\n",
    "m.drink(100)\n",
    "print(m.water)\n",
    "\n",
    "s = SportBottle()\n",
    "s.full()\n",
    "s.drink(100)\n",
    "print(s.water)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# 输入输出"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 从命令行输入\n",
    "\n",
    "Python3使用input从命令行输入。Python2使用raw_input从命令行输入。\n",
    "\n",
    "两者参数一致，都是一个提示字符串。\n",
    "\n",
    "在Python2中，input是eval(input)，有安全性问题。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter text: abc\n",
      "No, it is not a palindrome\n"
     ]
    }
   ],
   "source": [
    "#Rise to vote, sir.\n",
    "\n",
    "def reverse(text):\n",
    "    return text[::-1]\n",
    "\n",
    "def is_palindrome(text):\n",
    "    return text == reverse(text)\n",
    "\n",
    "something = input(\"Enter text: \")\n",
    "\n",
    "if is_palindrome(something):\n",
    "    print(\"Yes, it is a palindrome\")\n",
    "else:\n",
    "    print(\"No, it is not a palindrome\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 练习\n",
    "\n",
    "刚刚的回文字符串程序只能检测纯粹的字符串，真正的回文字符检测程序应当能够处理标点，空格和大小写。\n",
    "\n",
    "例如\"Rise to vote, sir.\"实际上也是回文字符串，但是刚刚的程序判定他不是。\n",
    "\n",
    "请写出一个新的版本。\n",
    "\n",
    "简单起见，只需要处理,和.即可。先不用管理各种复杂标点，例如&。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 答案"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter text: Rise to vote, sir.\n",
      "Yes, it is a palindrome\n"
     ]
    }
   ],
   "source": [
    "def reverse(text):\n",
    "    return text[::-1]\n",
    "\n",
    "def is_palindrome(text):\n",
    "    text = text.replace(',', '')\n",
    "    text = text.replace('.', '')\n",
    "    text = text.replace(' ', '')\n",
    "    text = text.lower()\n",
    "    return text == reverse(text)\n",
    "\n",
    "something = input(\"Enter text: \")\n",
    "\n",
    "if is_palindrome(something):\n",
    "    print(\"Yes, it is a palindrome\")\n",
    "else:\n",
    "    print(\"No, it is not a palindrome\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 从文件中输入输出\n",
    "\n",
    "使用open打开文件进行读写。调用方法和C的fopen类似。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Programming is fun\n",
      "When the work is done\n",
      "if you wanna make your work also fun:\n",
      "    use Python!\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "poem = '''\\\n",
    "Programming is fun\n",
    "When the work is done\n",
    "if you wanna make your work also fun:\n",
    "    use Python!\n",
    "'''\n",
    "f = open('poem.txt', 'w')\n",
    "f.write(poem)\n",
    "f.close()\n",
    "\n",
    "f = open('poem.txt')\n",
    "while True:\n",
    "    line = f.readline()\n",
    "    if len(line) == 0:\n",
    "        break\n",
    "    sys.stdout.write(line)\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-rw-r--r-- 1 shell shell 95 Mar 22 20:06 poem.txt\r\n"
     ]
    }
   ],
   "source": [
    "!ls -l poem.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Programming is fun\r\n",
      "When the work is done\r\n",
      "if you wanna make your work also fun:\r\n",
      "    use Python!\r\n"
     ]
    }
   ],
   "source": [
    "!cat poem.txt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以上皆是linux指令，因此不能（也不需要）在windows上执行。windows上对应的行为为dir，type，和del。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# 异常"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 简介\n",
    "\n",
    "Python允许在出现错误的时候，“抛”出这个错误。\n",
    "\n",
    "错误按照调用顺序依次向上找，找到第一个合适的处理方法对错误进行处理。如果无人处理错误，则程序崩溃。\n",
    "\n",
    "这种错误处理机制允许调用者对函数深层的错误进行容错，同时中间所有代码对这个过程无需干预。\n",
    "\n",
    "    >>> Print(\"Hello World\")\n",
    "    Traceback (most recent call last):\n",
    "      File \"<stdin>\", line 1, in <module>\n",
    "    NameError: name 'Print' is not defined\n",
    "    >>> print(\"Hello World\")\n",
    "    Hello World"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'Print' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-114-82ee0b7fee85>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mPrint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Hello World\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'Print' is not defined"
     ]
    }
   ],
   "source": [
    "Print(\"Hello World\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello World\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 异常输出阅读\n",
    "\n",
    "python的大多数错误会伴随抛出异常。因此，为了解决日常在使用中碰到的种种问题，我们需要学会如何阅读异常。\n",
    "\n",
    "异常输出通常和函数的调用顺序相同，和栈的顺序相反。\n",
    "\n",
    "最上层的调用（最先发生的）在最上面，最后执行到的地方在最下面。最后一个异常行就是异常发生的精确地点。\n",
    "\n",
    "最后一行是异常的名字和参数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "layer1 called\n",
      "layer2 called\n"
     ]
    },
    {
     "ename": "Exception",
     "evalue": "('arg1', 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mException\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-116-ee9e317c1a37>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      8\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlayer1\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-116-ee9e317c1a37>\u001b[0m in \u001b[0;36mlayer1\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mlayer1\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'layer1 called'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mlayer2\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mlayer2\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-116-ee9e317c1a37>\u001b[0m in \u001b[0;36mlayer2\u001b[0;34m()\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mlayer2\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'layer2 called'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m     \u001b[0;32mraise\u001b[0m \u001b[0mException\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'arg1'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      8\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mException\u001b[0m: ('arg1', 2)"
     ]
    }
   ],
   "source": [
    "def layer1():\n",
    "    print('layer1 called')\n",
    "    return layer2()\n",
    "\n",
    "def layer2():\n",
    "    print('layer2 called')\n",
    "    raise Exception('arg1', 2)\n",
    "    return 1\n",
    "\n",
    "print(layer1())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 异常处理\n",
    "\n",
    "常规异常处理代码段需要包含三部分内容：被监管代码体，错误类型和异常处理代码体。\n",
    "\n",
    "当被监管代码体中发生异常时，异常被向上抛出。\n",
    "\n",
    "向上寻找处理函数的异常属于定义的这个错误类的子类时，异常处理代码体被调用。\n",
    "\n",
    "一般来说，除非明确知道确实要捕获所有异常，否则严禁用捕获所有异常来处理某种特定问题。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter something --> abc\n",
      "Illegal number\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    number = int(input('Enter something --> '))\n",
    "except ValueError:\n",
    "    print('Illegal number')\n",
    "else:\n",
    "    print(number+1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 常见异常\n",
    "\n",
    "* AttributeError\n",
    "* ImportError\n",
    "* IndexError\n",
    "* KeyError\n",
    "* NameError\n",
    "* SyntaxError\n",
    "* IndentationError\n",
    "* TypeError\n",
    "* ValueError"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 抛出异常"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I'm ok\n",
      "actually not\n"
     ]
    }
   ],
   "source": [
    "def f():\n",
    "    print(\"I'm ok\")\n",
    "    raise Exception('actually not')\n",
    "\n",
    "try:\n",
    "    f()\n",
    "except Exception as err:\n",
    "    print(err)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 自定义异常"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 必须自Exception中继承\n",
    "class ShortInputException(Exception):\n",
    "    '''A user-defined exception class.'''\n",
    "    def __init__(self, length, atleast):\n",
    "        Exception.__init__(self)\n",
    "        self.length = length\n",
    "        self.atleast = atleast"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter something --> a\n",
      "ShortInputException: The input was 1 long, expected at least 3\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    text = input('Enter something --> ')\n",
    "    if len(text) < 3:\n",
    "        raise ShortInputException(len(text), 3)\n",
    "except ShortInputException as ex:\n",
    "    print('ShortInputException: The input was {0} long, expected at least {1}'.format(\n",
    "        ex.length, ex.atleast))\n",
    "else:\n",
    "    print('No exception was raised.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## finally\n",
    "\n",
    "finally用于“无论是异常还是正常，以下内容必然被执行”的情况。\n",
    "\n",
    "多用于清理。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter something --> abc\n",
      "Illegal number\n",
      "(clean up here)\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    number = int(input('Enter something --> '))\n",
    "except ValueError:\n",
    "    print('Illegal number')\n",
    "else:\n",
    "    print(number+1)\n",
    "finally:\n",
    "    print('(clean up here)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## with\n",
    "\n",
    "with可以在推出区块时自动关闭文件，而且对异常安全（异常在下一节讲）。\n",
    "\n",
    "with不仅可以用于文件，而且可以用于很多需要在离开区域时自动关闭的对象，例如锁。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Programming is fun\n",
      "When the work is done\n",
      "if you wanna make your work also fun:\n",
      "    use Python!\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "with open(\"poem.txt\") as f:\n",
    "    for line in f:\n",
    "        sys.stdout.write(line)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "!rm -f poem.txt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## assert"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "ename": "AssertionError",
     "evalue": "of course",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-124-edbb3195c18c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0;36m1\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mException\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'of course'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m: of course"
     ]
    }
   ],
   "source": [
    "assert 1 == 0, Exception('of course')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# 文档"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 文档获得和查阅\n",
    "\n",
    "在线文档：\n",
    "\n",
    "https://docs.python.org/3/\n",
    "\n",
    "本地文档：随安装版本变化。\n",
    "\n",
    "两者冲突以本地为准，本地一定对应安装使用的版本。\n",
    "\n",
    "库查Library Reference，这是最主要部分。\n",
    "\n",
    "语法特性查Language Reference。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 练习\n",
    "\n",
    "打开文档，请查阅itertools.permutations的意义，参数，返回值，用法，注意要点等信息。并向大家解释。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 第三方文档查询\n",
    "\n",
    "没有什么固定方法。\n",
    "\n",
    "在google（注意，不是baidu）上搜索关键词。找一个比较像的官网。找到文档。\n",
    "\n",
    "可以参考pypi，很多第三方库可以在上面找到。里面往往带有文档地址。\n",
    "\n",
    "缺点是，pypi上搜出来的重名库太多，很难搞清楚哪个才是你要的。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Python2和Python3的差异"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 简述\n",
    "\n",
    "Python2中有很多固有的设计问题，例如：\n",
    "\n",
    "1. print是内置关键词。一般来说，关键词越少越好，因为关键词越少，语言的内核越简洁。\n",
    "2. 混同了bytes和unicode。\n",
    "3. /是整数除法。\n",
    "\n",
    "这些问题在Python3中逐步给予了修复。\n",
    "\n",
    "常规来说，修复问题最重要的是“向下兼容，逐步进行”。\n",
    "\n",
    "然而上述问题几乎全部都是语言本质问题，不对语言进行伤筋动骨的大改是没有办法修复的。\n",
    "\n",
    "因此Python3的预订是“不和Python2兼容”，这造成了Python社区目前2/3分裂的现状。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Python2和Python3有很多细节差异。但是大致来说，最主要就是上面提到的三项。\n",
    "\n",
    "1. Python2的print由关键字改为了函数。因此print ‘xxx’的写法就不合法了。\n",
    "2. 在Python3中，所有的字符串默认都是unicode。要处理原生数据需要用bytes。因此很多在Python2中能够很方便就处理过去的地方需要仔细思考是unicode还是bytes。\n",
    "3. Python3中/不是整数除法。\n",
    "\n",
    "在下面这个连接里，收录了Python2和Python3的其他一些细节差异。\n",
    "\n",
    "https://wiki.python.org/moin/Python2orPython3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Python2到3迁移\n",
    "\n",
    "Python3带有2to3脚本，可以完成很多项目的迁移。\n",
    "\n",
    "但是对于某些情况，他仍然不能自动的完成所有工作。\n",
    "\n",
    "2到3迁移的主要问题在于，目前有很多库，仍然没有完成Python3的迁移工作。这导致使用这些库编写的程序很难在Python3上找到更好的（或者更习惯的）替代产品。\n",
    "\n",
    "而这件事情是2to3脚本无法自动完成的。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 我该用哪个版本/哪个更好\n",
    "\n",
    "由于Python2已经停止维护，因此新开项目时请一律使用Python3。\n",
    "\n",
    "教材教授了很多Python2写法，主要是考虑到接手项目中可能有大量遗留代码。对于这些代码，读懂维护是必要技能。\n",
    "\n",
    "对现存代码。如果预期会被长期维护的，建议将代码迁移到Python3中。如果代码生命期不长，短期维护Python2代码也可接受。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# 第三方软件安装\n",
    "\n",
    "两套基本系统：\n",
    "\n",
    "* setuptools\n",
    "* pip"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## setuptools\n",
    "\n",
    "系统中必须安装了setuptools（请咨询管理员安装），或者使用以下指令安装：\n",
    "\n",
    "Linux:\n",
    "\n",
    "    wget https://bootstrap.pypa.io/ez_setup.py -O - | sudo python\n",
    "\n",
    "MacOS:\n",
    "\n",
    "    curl https://bootstrap.pypa.io/ez_setup.py -o - | python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## setuptools的使用\n",
    "\n",
    "1. easy_install 包名\n",
    "2. easy_install 安装包路径。（路径可以填写一个url，系统会从网络上下载安装）\n",
    "3. 在软件的分发包中找到setup.py，直接运行python setup.py install\n",
    "\n",
    "进一步资料请参考：https://setuptools.readthedocs.io/en/latest/easy_install.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## pip\n",
    "\n",
    "系统中必须有pip，具体请咨询管理员。或者下载该文件：\n",
    "\n",
    "https://bootstrap.pypa.io/get-pip.py\n",
    "\n",
    "使用python执行安装（注意需要管理员权限）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## pip的使用\n",
    "\n",
    "1. pip install 包名\n",
    "2. pip install -r requirements.txt （自动处理里面的所有依赖）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## virtualenv\n",
    "\n",
    "功能：用于隔离出一套独立的环境，可以在里面安装各种包，而不对系统造成影响。\n",
    "\n",
    "使用场景：可以在用户目录中安装包，无需系统权限。也可以隔离多个环境，安装不同版本的不同程序。\n",
    "\n",
    "限制：virtualenv本身，及其依赖的Python是无法隔离的。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## virtualenv的使用\n",
    "\n",
    "建立环境：virtualenv 目录名\n",
    "\n",
    "激活环境：进入目录后执行source bin/activate\n",
    "\n",
    "退出激活环境：deactivate\n",
    "\n",
    "隔离环境内的安装：pip或者setup.py均可\n",
    "\n",
    "注意：安装库时需要编译的，系统中必须有编译工具链。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 访问系统库\n",
    "\n",
    "如果在使用virtualenv的同时，也想使用系统中安装的库。那么需要在创建环境时用--system-site-packages参数。\n",
    "\n",
    "从工程管理角度，我们不推荐这种办法。建议将系统中的所有库在虚环境中再安装一次。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 虚拟环境的发布\n",
    "\n",
    "使用virtualenv生成的虚拟环境可以迁移到其他机器上，从而允许将运行环境在多台机器上迁移。但是需要注意以下事项：\n",
    "\n",
    "* virtualenv依赖于目录工作，所以所有机器上virtualenv必须处于同一路径下。\n",
    "* virtualenv不能隔离系统/Python基础环境。因此所有机器必须同构，并且Python环境基本一致。\n",
    "* 里面所安装的库所依赖的其他系统文件，例如动态运行库，数据文件。如果不在virtualenv里安装的，则每个系统上均需要自行安装。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 更进一步资料\n",
    "\n",
    "请参考这里：\n",
    "\n",
    "https://virtualenv.pypa.io/en/stable/userguide/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 软件包安装和管理建议\n",
    "\n",
    "Python默认情况下会试图将软件包安装到系统里，如果不具备管理员权限，需要使用virtualenv来安装软件包。\n",
    "\n",
    "对于Debian/Ubuntu而言，安装软件的第一选择是apt系统。如果找不到包，或版本不对，建议采用virtualenv + pip的方式安装。\n",
    "\n",
    "对于RHEL/CentOS而言，安装软件的第一选择是yum系统。如果找不到包，或版本不对，建议采用virtualenv + pip的方式安装。\n",
    "\n",
    "对于Windows/MacOS而言，建议使用virtualenv + pip的方式安装。"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}