{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# 1.2 Python 进阶" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1.2.1 列表推导式" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "循环可以用来生成列表：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = [x for x in range(4)]\n", "a" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "在循环的过程中使用 `if`:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = [x for x in range(3,10) if x % 2 == 0]\n", "a" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "2 个`for` 循环:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = [(x,y) for x in range(1,3) for y in range(1,3)]\n", "a" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "3 个 `for` 循环：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = [(x,y,z) for x in range(1,3) for y in range(1,3) for z in range(1,3)]\n", "a" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "也可以使用推导式生成集合和字典： \n", "**字典推导式**：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "values = [10, 21, 4, 7, 12]\n", "square_dict = {x: x**2 for x in values if x <= 10}\n", "print(square_dict)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**集合推导式**：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "values = [10, 21, 4, 7, 12]\n", "square_set = {x**2 for x in values if x <= 10}\n", "print(square_set)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1.2.2 函数\n", "\n", "### 定义函数\n", "\n", "函数`function`，通常接收输入参数，并有返回值。\n", "\n", "它负责完成某项特定任务，而且相较于其他代码，具备相对的独立性。" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def add(x, y):\n", " \"\"\"Add two numbers\"\"\"\n", " a = x + y\n", " return a" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "函数通常有一下几个特征：\n", "- 使用 `def` 关键词来定义一个函数。\n", "- `def` 后面是函数的名称，括号中是函数的参数，不同的参数用 `,` 隔开， `def foo():` 的形式是必须要有的，参数可以为空；\n", "- 使用缩进来划分函数的内容；\n", "- `docstring` 用 `\"\"\"` 包含的字符串，用来解释函数的用途，可省略；\n", "- `return` 返回特定的值，如果省略，返回 `None` 。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 使用函数\n", "\n", "使用函数时，只需要将参数换成特定的值传给函数。\n", "\n", "**Python** 并没有限定参数的类型，因此可以使用不同的参数类型：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(add(2, 3))\n", "print(add('foo', 'bar'))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "在这个例子中，如果传入的两个参数不可以相加，那么 **Python** 会将报错：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(add(2, \"foo\"))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "如果传入的参数数目与实际不符合，也会报错：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(add(1, 2, 3))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "传入参数时，**Python** 提供了两种选项，第一种是上面使用的按照位置传入参数，另一种则是使用关键词模式，显式地指定参数的值：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(add(x=2, y=3))\n", "print(add(y=\"foo\", x=\"bar\"))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "可以混合这两种模式：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(add(2, y=3))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 设定参数默认值\n", "\n", "可以在函数定义的时候给参数设定默认值，例如：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def quad(x, a=1, b=0, c=0):\n", " return a*x**2 + b*x + c" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "可以省略有默认值的参数：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(quad(2.0))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "可以修改参数的默认值：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(quad(2.0, b=3))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(quad(2.0, 2, c=4))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "这里混合了位置和指定两种参数传入方式，第二个 2 是传给 `a` 的。\n", "\n", "注意，在使用混合语法时，要注意不能给同一个值赋值多次，否则会报错，例如：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(quad(2.0, 2, a=2))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 接收不定长参数\n", "\n", "使用如下方法，可以使函数接受不定数目的参数：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def add(x, *args):\n", " total = x\n", " for arg in args:\n", " total += arg\n", " return total" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "这里，`*args` 表示参数数目不定，可以看成一个元组，把第一个参数后面的参数当作元组中的元素。" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(add(1, 2, 3, 4))\n", "print(add(1, 2))\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "这样定义的函数不能使用关键词传入参数，要使用关键词，可以这样：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def add(x, **kwargs):\n", " total = x\n", " for arg, value in kwargs.items():\n", " print(\"adding %s=%s\"%(arg,value))\n", " total += value\n", " return total\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "这里， `**kwargs` 表示参数数目不定，相当于一个字典，键和值对应于键值对。" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(add(10, y=11, z=12, w=13))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "再看这个例子，可以接收任意数目的位置参数和键值对参数：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def foo(*args, **kwargs):\n", " print(args, kwargs)\n", "\n", "foo(2, 3, x='bar', z=10)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "不过要按顺序传入参数，先传入位置参数 `args` ，再传入关键词参数 `kwargs` 。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 返回多个值\n", "\n", "函数可以返回多个值：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def divid(a, b):\n", " \"\"\"\n", " 除法\n", " :param a: number 被除数\n", " :param b: number 除数\n", " :return: 商和余数\n", " \"\"\"\n", " quotient = a // b\n", " remainder = a % b\n", " return quotient, remainder\n", "\n", "quotient, remainder = divid(7,4)\n", "print(quotient, remainder)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "事实上，**Python** 将返回的两个值变成了元组：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(divid(7,4))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "因为这个元组中有两个值，所以可以使用\n", "\n", " quotient, remainder = divid(7,4)\n", "\n", "给两个值赋值。\n", "\n", "列表也有相似的功能：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a, b, c = [1, 2, 3]\n", "print(a, b, c)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "事实上，不仅仅返回值可以用元组表示，也可以将参数用元组以这种方式传入：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def divid(a, b):\n", " \"\"\"\n", " 除法\n", " :param a: number 被除数\n", " :param b: number 除数\n", " :return: 商和余数\n", " \"\"\"\n", " quotient = a // b\n", " remainder = a % b\n", " return quotient, remainder\n", "\n", "z = (7,4)\n", "print(divid(*z))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "这里的`*`必不可少。\n", "\n", "事实上，还可以通过字典传入参数来执行函数：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def divid(a, b):\n", " \"\"\"\n", " 除法\n", " :param a: number 被除数\n", " :param b: number 除数\n", " :return: 商和余数\n", " \"\"\"\n", " quotient = a // b\n", " remainder = a % b\n", " return quotient, remainder\n", "\n", "z = {'a':7,'b':4}\n", "print(divid(**z))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### `map` 方法生成序列" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "其用法为：\n", " \n", " map(aFun, aSeq)\n", "\n", "将函数 `aFun` 应用到序列 `aSeq` 上的每一个元素上，返回一个列表，不管这个序列原来是什么类型。\n", "\n", "事实上，根据函数参数的多少，`map` 可以接受多组序列，将其对应的元素作为参数传入函数：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def divid(a, b):\n", " \"\"\"\n", " 除法\n", " :param a: number 被除数\n", " :param b: number 除数\n", " :return: 商和余数\n", " \"\"\"\n", " quotient = a // b\n", " remainder = a % b\n", " return quotient, remainder\n", "\n", "a = (10, 6, 7)\n", "b = [2, 5, 3]\n", "print(list(map(divid,a,b)))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1.2.3 模块和包" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 模块\n", "\n", "**Python** 会将所有 `.py` 结尾的文件认定为 **Python** 代码文件，考虑下面的脚本 `ex1.py` ：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%%writefile ex1.py\n", "\n", "PI = 3.1416\n", "\n", "def sum(lst):\n", " \"\"\"\n", " 计算 lst 序列所有元素的和\n", " :param lst: 序列 e.g. [1,2,3]\n", " :return: lst 序列所有元素的总和\n", " \"\"\"\n", " \n", " # 获取 lst序列第一个元素\n", " tot = lst[0]\n", " \n", " # 循环遍历 lst 序列剩余元素\n", " for value in lst[1:]:\n", " tot = tot + value\n", " return tot\n", "\n", "w = [0, 1, 2, 3]\n", "print(sum(w), PI)\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "可以执行它：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%run ex1.py" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "这个脚本可以当作一个模块，可以使用`import`关键词加载并执行它（这里要求`ex1.py`在当前工作目录）：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import ex1" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "ex1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "在导入时，**Python** 会执行一遍模块中的所有内容。\n", "\n", "`ex1.py` 中所有的变量都被载入了当前环境中，不过要使用\n", "\n", " ex1.变量名\n", "\n", "的方法来查看或者修改这些变量：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(ex1.PI)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "ex1.PI = 3.141592653\n", "print(ex1.PI)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "还可以用\n", "\n", " ex1.函数名\n", "\n", "调用模块里面的函数：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(ex1.sum([2, 3, 4]))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "为了提高效率，**Python** 只会载入模块一次，已经载入的模块再次载入时，**Python** 并不会真正执行载入操作，哪怕模块的内容已经改变。\n", "\n", "例如，这里重新导入 `ex1` 时，并不会执行 `ex1.py` 中的 `print` 语句：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import ex1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "需要重新导入模块时，可以使用 `reload` 强制重新载入它，例如：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from imp import reload\n", "reload(ex1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "删除之前生成的文件：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import os\n", "os.remove('ex1.py')\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### `__name__` 属性\n", "\n", "有时候我们想将一个 `.py` 文件既当作脚本，又能当作模块用，这个时候可以使用 `__name__` 这个属性。\n", "\n", "只有当文件被当作脚本执行的时候， `__name__`的值才会是 `'__main__'`，所以我们可以：\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%%writefile ex2.py\n", "\n", "PI = 3.1416\n", "\n", "def sum(lst):\n", " \"\"\" Sum the values in a list\n", " \"\"\"\n", " tot = 0\n", " for value in lst:\n", " tot = tot + value\n", " return tot\n", "\n", "def add(x, y):\n", " \" Add two values.\"\n", " a = x + y\n", " return a\n", "\n", "def test():\n", " w = [0,1,2,3]\n", " assert(sum(w) == 6)\n", " print('test passed.')\n", "\n", "if __name__ == '__main__':\n", " test()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "运行文件：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%run ex2.py" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "当作模块导入， `test()` 不会执行：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import ex2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "但是可以使用其中的变量：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "ex2.PI\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "引入模块时可以为它设置一个别名让使用更方便：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import ex2 as e2\n", "e2.PI" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 其它导入方法\n", "\n", "可以从模块中导入变量：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from ex2 import add, PI" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "使用 `from` 后，可以直接使用 `add` ， `PI`：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "add(2, 3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "或者使用 `*` 导入所有变量：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from ex2 import *\n", "add(3, 4.5)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "这种导入方法不是很提倡，因为如果你不确定导入的都有哪些，可能覆盖一些已有的函数。\n", "\n", "删除文件：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import os\n", "os.remove('ex2.py')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 包\n", "\n", "假设我们有这样的一个文件夹：\n", "\n", "foo/\n", "- `__init__.py` \n", "- `bar.py` (defines func)\n", "- `baz.py` (defines zap)\n", "\n", "这意味着 `foo` 是一个包，我们可以这样导入其中的内容：\n", "\n", "```python \n", "\n", "from foo.bar import func\n", "from foo.baz import zap\n", "\n", "```\n", "\n", "`bar` 和 `baz` 都是 `foo` 文件夹下的 `.py` 文件。\n", "\n", "导入包要求：\n", "- 文件夹 `foo` 在 **Python** 的搜索路径中\n", "- `__init__.py` 表示 `foo` 是一个包，它可以是个空文件。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1.2.4 异常\n", "\n", "写代码的时候，出现错误不可避免，即使代码语法没有问题，也可能遇到其它问题。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "看下面这段代码：\n", "\n", "```python \n", "\n", "import math\n", "\n", "while True:\n", " text = input('> ')\n", " if text[0] == 'q':\n", " break\n", " x = float(text)\n", " y = math.log10(x)\n", " print(\"log10({0}) = {1}\".format(x, y))\n", "```\n", "\n", "这段代码接收命令行的输入，当输入为数字时，计算它的对数并输出，直到输入值为 `q` 为止。\n", "\n", "乍看没什么问题，然而当我们输入 0 或者负数时：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import math\n", "\n", "while True:\n", " text = input('> ')\n", " if text[0] == 'q':\n", " break\n", " x = float(text)\n", " y = math.log10(x)\n", " print(\"log10({0}) = {1}\".format(x, y))\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "`log10` 函数会报错，因为不能接受非正值。\n", "\n", "一旦报错，程序就会停止执行。如果不希望程序停止执行，并且想要捕捉异常，那么我们可以按照 `try/except` 语句。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "```python\n", "\n", "import math\n", "\n", "while True:\n", " try:\n", " text = input('> ')\n", " if text[0] == 'q':\n", " break\n", " x = float(text)\n", " y = math.log10(x)\n", " print(\"log10({0}) = {1}\".format(x, y))\n", " except ValueError:\n", " print(\"the value must be greater than 0\")\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "一旦 `try` 块中的内容出现了异常，那么 `try` 块后面的内容会被忽略，**Python** 会寻找 `except` 里面有没有对应的内容，如果找到，就执行对应的块，没有则抛出这个异常。\n", "\n", "在上面的例子中，`try` 抛出的是 `ValueError`，`except` 中有对应的内容，所以这个异常被 `except` 捕捉到，程序可以继续执行：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import math\n", "\n", "while True:\n", " try:\n", " text = input('> ')\n", " if text[0] == 'q':\n", " break\n", " x = float(text)\n", " y = math.log10(x)\n", " print(\"log10({0}) = {1}\".format(x, y))\n", " except ValueError:\n", " print(\"the value must be greater than 0\")\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 捕捉不同的错误类型" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "``` python\n", "import math\n", "\n", "while True:\n", " try:\n", " text = input('> ')\n", " if text[0] == 'q':\n", " break\n", " x = float(text)\n", " y = 1 / math.log10(x)\n", " print(\"log10({0}) = {1}\".format(x, y))\n", " except ValueError:\n", " print(\"the value must be greater than 0\")\n", "```\n", "\n", "假设我们将这里的 `y` 更改为 `1 / math.log10(x)`，此时输入 `1`：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import math\n", "\n", "while True:\n", " try:\n", " text = input('> ')\n", " if text[0] == 'q':\n", " break\n", " x = float(text)\n", " y = 1 / math.log10(x)\n", " print(\"log10({0}) = {1}\".format(x, y))\n", " except ValueError:\n", " print(\"the value must be greater than 0\")\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "因为我们的 `except` 里面并没有 `ZeroDivisionError`，所以会抛出这个异常，我们可以通过两种方式解决这个问题。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 捕捉所有异常\n", "\n", "将`except` 的值改成 `Exception` 类，来捕获所有的异常。" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import math\n", "\n", "while True:\n", " try:\n", " text = input('> ')\n", " if text[0] == 'q':\n", " break\n", " x = float(text)\n", " y = 1 / math.log10(x)\n", " print(\"1 / log10({0}) = {1}\".format(x, y))\n", " except Exception:\n", " print(\"invalid value\")\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 指定特定异常\n", "\n", "这里，我们把 `ZeroDivisionError` 加入 `except` 。" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import math\n", "\n", "while True:\n", " try:\n", " text = input('> ')\n", " if text[0] == 'q':\n", " break\n", " x = float(text)\n", " y = 1 / math.log10(x)\n", " print(\"1 / log10({0}) = {1}\".format(x, y))\n", " except (ValueError, ZeroDivisionError):\n", " print(\"invalid value\")\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "或者另加处理：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import math\n", "\n", "while True:\n", " try:\n", " text = input('> ')\n", " if text[0] == 'q':\n", " break\n", " x = float(text)\n", " y = 1 / math.log10(x)\n", " print(\"1 / log10({0}) = {1}\".format(x, y))\n", " except ValueError:\n", " print(\"the value must be greater than 0\")\n", " except ZeroDivisionError:\n", " print(\"the value must not be 1\")\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "事实上，我们还可以将这两种方式结合起来，用 `Exception` 来捕捉其他的错误：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import math\n", "\n", "while True:\n", " try:\n", " text = input('> ')\n", " if text[0] == 'q':\n", " break\n", " x = float(text)\n", " y = 1 / math.log10(x)\n", " print(\"1 / log10({0}) = {1}\".format(x, y))\n", " except ValueError:\n", " print(\"the value must be greater than 0\")\n", " except ZeroDivisionError:\n", " print(\"the value must not be 1\")\n", " except Exception:\n", " print(\"unexpected error\")\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 得到异常的具体信息\n", "\n", "在上面的例子中，当我们输入不能转换为浮点数的字符串时，它输出的是 `the value must be greater than 0`，这并没有反映出实际情况。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "为了得到异常的具体信息，我们将这个 `ValueError` 具体化：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import math\n", "\n", "while True:\n", " try:\n", " text = input('> ')\n", " if text[0] == 'q':\n", " break\n", " x = float(text)\n", " y = 1 / math.log10(x)\n", " print(\"1 / log10({0}) = {1}\".format(x, y))\n", " except ValueError as exc:\n", " if exc.message == \"math domain error\":\n", " print(\"the value must be greater than 0\")\n", " else:\n", " print(\"could not convert '%s' to float\" % text)\n", " except ZeroDivisionError:\n", " print(\"the value must not be 1\")\n", " except Exception as exc:\n", " print(\"unexpected error:\", exc.message)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "同时，我们也将捕获的其他异常的信息显示出来。\n", "\n", "这里，`exc.message` 显示的内容是异常对应的说明，例如\n", "\n", " ValueError: could not convert string to float: a\n", "\n", "对应的 `message` 是 \n", "\n", " could not convert string to float: a\n", "\n", "当我们使用 `except Exception` 时，会捕获所有的 `Exception` 和它派生出来的子类，但不是所有的异常都是从 `Exception` 类派生出来的，可能会出现一些不能捕获的情况，因此，更加一般的做法是使用这样的形式：\n", "\n", "```python\n", "try:\n", " pass\n", "except:\n", " pass\n", "```\n", "\n", "这样不指定异常的类型会捕获所有的异常，但是这样的形式并不推荐。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### else\n", "\n", "`try/except` 块有一个可选的关键词 `else`。\n", "\n", "如果使用这个子句，那么必须放在所有的 except 子句之后。else 子句将在 try 子句没有发生任何异常的时候执行。" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "try:\n", " print(1)\n", "except:\n", " pass\n", "else:\n", " print('else was called.')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "出现异常，else 不会执行。" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "try:\n", " print(1/0)\n", "except ZeroDivisionError:\n", " print('divide by 0.')\n", "else:\n", " print('else was called.')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### finally\n", "\n", "`try/except` 块还有一个可选的关键词 `finally`。\n", "\n", "不管 `try` 块有没有异常， `finally` 块的内容总是会被执行，而且会在抛出异常前执行，因此可以用来作为安全保证，比如确保打开的文件被关闭。" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "try:\n", " print(1)\n", "finally:\n", " print('finally was called.')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "在抛出异常前执行：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "try:\n", " print(1 / 0)\n", "finally:\n", " print('finally was called.')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "如果异常被捕获了，在最后执行：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "try:\n", " print(1 / 0)\n", "except ZeroDivisionError:\n", " print('divide by 0.')\n", "finally:\n", " print('finally was called.')\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "异常的处理流程可参考下图：\n", "\n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1.2.5 警告\n", "\n", "出现了一些需要让用户知道的问题，但又不想停止程序，这时候我们可以使用警告：\n", "\n", "首先导入警告模块：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import warnings" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "在需要的地方，我们使用 `warnings` 中的 `warn` 函数：\n", "\n", " warn(msg, WarningType = UserWarning)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def month_warning(m):\n", " if not 1<= m <= 12:\n", " msg = \"month (%d) is not between 1 and 12\" % m\n", " warnings.warn(msg, RuntimeWarning)\n", "\n", "month_warning(13)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "有时候我们想要忽略特定类型的警告，可以使用 `warnings` 的 `filterwarnings` 函数：\n", "\n", " filterwarnings(action, category)\n", "\n", "将 `action` 设置为 `'ignore'` 便可以忽略特定类型的警告：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "warnings.filterwarnings(action = 'ignore', category = RuntimeWarning)\n", "\n", "month_warning(13)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1.2.6 文件读写\n", "\n", "写入测试文件：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%%writefile test.txt\n", "this is a test file.\n", "hello world!\n", "python is good!\n", "today is a good day.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 读文件\n", "\n", "使用 `open` 函数来读文件，使用文件名的字符串作为输入参数：\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "f = open('test.txt')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "默认以读的方式打开文件，如果文件不存在会报错：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "f = open('test1.txt')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "可以使用 `read` 方法来读入文件中的所有内容：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "text = f.read()\n", "print(text)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "也可以按照行读入内容，`readlines` 方法返回一个列表，每个元素代表文件中每一行的内容：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "f = open('test.txt')\n", "lines = f.readlines()\n", "print(lines)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "使用完文件之后，需要将文件关闭。" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "f.close()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "事实上，我们可以将 `f` 放在一个循环中，得到它每一行的内容：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "f = open('test.txt')\n", "for line in f:\n", " print(line)\n", "f.close()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "删除刚才创建的文件：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import os\n", "os.remove('test.txt')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 写文件" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "我们使用 `open` 函数的写入模式来写文件：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "f = open('myfile.txt', 'w')\n", "f.write('hello world!')\n", "f.close()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "使用 `w` 模式时，如果文件不存在会被创建，我们可以查看是否真的写入成功：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(open('myfile.txt').read())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "如果文件已经存在， `w` 模式会覆盖之前写的所有内容：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "f = open('myfile.txt', 'w')\n", "f.write('another hello world!')\n", "f.close()\n", "print(open('myfile.txt').read())\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "除了写入模式，还有追加模式 `a` ，追加模式不会覆盖之前已经写入的内容，而是在之后继续写入：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "f = open('myfile.txt', 'a')\n", "f.write('... and more')\n", "f.close()\n", "print(open('myfile.txt').read())\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "写入结束之后一定要将文件关闭，否则可能出现内容没有完全写入文件中的情况。\n", "\n", "还可以使用读写模式 `w+`：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "f = open('myfile.txt', 'w+')\n", "f.write('hello world!')\n", "f.seek(6)\n", "print(f.read())\n", "f.close()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "这里 `f.seek(6)` 移动到文件的第6个字符处，然后 `f.read()` 读出剩下的内容。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "删除刚才创建的文件：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import os\n", "os.remove('myfile.txt')\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 关闭文件\n", "\n", "在 **Python** 中，如果一个打开的文件不再被其他变量引用时，它会自动关闭这个文件。\n", "\n", "所以正常情况下，如果一个文件正常被关闭了，忘记调用文件的 `close` 方法不会有什么问题。\n", "\n", "关闭文件可以保证内容已经被写入文件，而不关闭可能会出现意想不到的结果：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "f = open('newfile.txt','w')\n", "f.write('hello world')\n", "g = open('newfile.txt', 'r')\n", "print(repr(g.read()))\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "虽然这里写了内容，但是在关闭之前，这个内容并没有被写入磁盘。\n", "\n", "使用循环写入的内容也并不完整：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "f = open('newfile.txt','w')\n", "for i in range(30):\n", " f.write('hello world: ' + str(i) + '\\n')\n", "\n", "g = open('newfile.txt', 'r')\n", "print(g.read())\n", "f.close()\n", "g.close()\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import os\n", "os.remove('newfile.txt')\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "出现异常时候的读写：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "f = open('newfile.txt','w')\n", "for i in range(30):\n", " x = 1.0 / (i - 10)\n", " f.write('hello world: ' + str(i) + '\\n')\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "查看已有内容：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "g = open('newfile.txt', 'r')\n", "print(g.read())\n", "f.close()\n", "g.close()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "可以看到，出现异常的时候，磁盘的写入并没有完成，为此我们可以使用 `try/except/finally` 块来关闭文件，这里 `finally` 确保关闭文件，所有的写入已经完成。" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "f = open('newfile.txt','w')\n", "try:\n", " for i in range(30):\n", " x = 1.0 / (i - 10)\n", " f.write('hello world: ' + str(i) + '\\n')\n", "except Exception:\n", " print(\"something bad happened\")\n", "finally:\n", " f.close()\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "g = open('newfile.txt', 'r')\n", "print(g.read())\n", "g.close()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### with 方法\n", "\n", "事实上，**Python** 提供了更安全的方法，当 `with` 块的内容结束后，**Python** 会自动调用它的`close` 方法，确保读写的安全：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "with open('newfile.txt','w') as f:\n", " for i in range(30):\n", " x = 1.0 / (i - 10)\n", " f.write('hello world: ' + str(i) + '\\n')\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "与 `try/exception/finally` 效果相同，但更简单。" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "g = open('newfile.txt', 'r')\n", "print(g.read())\n", "g.close()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "所以，写文件时候要确保文件被正确关闭。\n", "\n", "删除刚才创建的文件：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import os\n", "os.remove('newfile.txt')\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1.2.7 CSV 文件和 csv 模块\n", "\n", "标准库中有自带的 `csv` 模块处理 `csv` 格式的文件：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import csv" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 读 csv 文件\n", "\n", "假设我们有这样的一个文件：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%%file data.csv\n", "\"alpha 1\", 100, -1.443\n", "\"beat 3\", 12, -0.0934\n", "\"gamma 3a\", 192, -0.6621\n", "\"delta 2a\", 15, -4.515\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "打开这个文件，并产生一个文件 reader：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# 打开 data.csv 文件\n", "fp = open(\"data.csv\")\n", "\n", "# 读取文件“”\n", "r = csv.reader(fp)\n", "\n", "# 可以按行迭代数据\n", "for row in r:\n", " print(row)\n", "\n", "# 关闭文件\n", "fp.close()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "默认数据内容都被当作字符串处理，不过可以自己进行处理：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "data = []\n", "\n", "with open('data.csv') as fp:\n", " r = csv.reader(fp)\n", " for row in r:\n", " data.append([row[0], int(row[1]), float(row[2])])\n", "\n", "data\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "清除刚刚创建的文件：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import os\n", "os.remove('data.csv')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 写 csv 文件" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "可以使用 `csv.writer` 写入文件，不过相应地，传入的应该是以写方式打开的文件，不过一般要用 `'wb'` 即二进制写入方式，防止出现换行不正确的问题：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "data = [('one', 1, 1.5), ('two', 2, 8.0)]\n", "with open('out.csv', 'w') as fp:\n", " w = csv.writer(fp)\n", " w.writerows(data)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "显示结果：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "! cat 'out.csv'" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.5.2" } }, "nbformat": 4, "nbformat_minor": 2 }