02-powerful-calculator.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "zh-cn"
   },
   "source": [
    "强大的计算器\n",
    "=====================\n",
    "\n",
    "Python提示和读评估打印循环（REPL）\n",
    "---------------------------------------------\n",
    "\n",
    "Python是一种*解释型*语言。我们可以将一系列的命令收集并保存到文本文件中，并将其保存为*Python程序*。按照惯例，这些文件的文件扩展名为“ .py”，例如“ hello.py”。\n",
    "\n",
    "我们还可以在Python提示符下输入单个命令，这些命令将立即由Python解释器编译并执行。这对于程序员/学习者了解如何使用某些命令（通常是在将这些命令放到更长的Python程序中之前）非常有用。 Python的角色可以描述为读取命令、执行、打印计算结果并重复（循环）循环-这是REPL缩写的由来。\n",
    "\n",
    "Python带有基本的终端提示；您可能会看到带有“ >>>”标记输入的示例：\n",
    "\n",
    "\n",
    "    >>> 2 + 2\n",
    "    4\n",
    "\n",
    "我们正在使用功能更强大的REPL接口Jupyter Notebook。代码块显示在它们旁边，并带有“ In”提示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4 + 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "zh-cn"
   },
   "source": [
    "要编辑代码，请在代码区域内进行单击。您应该在它周围有一个绿色边框。要运行它，请按Shift-Enter。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "zh-cn"
   },
   "source": [
    "计算器\n",
    "----------\n",
    "\n",
    "基本操作（如加法（`+`），减法（`-`），乘法（`*`），除法（`/`）和幂运算（`* *`））（大部分）按预期工作："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10010"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 + 10000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "40.5"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "42 - 1.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "517"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "47 * 11"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20.0"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 / 0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2**2   # 幂运算是符号 **, 不是符号 ^"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2**3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2**4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 这个是注解\n",
    "2 + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 + 2  # 在代码同一行进行注解"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "zh-cn"
   },
   "source": [
    "利用公式$\\sqrt[n]{x} = x^{1/n}$，我们可以使用`**`计算$\\sqrt{3} = 1.732050\\dots$："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.7320508075688772"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3**0.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "zh-cn"
   },
   "source": [
    "括号可用于分组："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 * 10 + 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 * (10 + 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "zh-cn"
   },
   "source": [
    "整数除法\n",
    "----------------\n",
    "\n",
    "在Python 3中，除法可以按您预计的那样工作："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.5"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "15/6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "zh-cn"
   },
   "source": [
    "但是在Python 2中，“ 15/6”会得到“ 2”。\n",
    "\n",
    "\n",
    "这种现象（在许多编程语言中，包括C）都称为*整数除法*：因为我们向除法运算符（`/`）提供了两个整数（`15`和`6`），所以假设是我们寻求整数类型的返回值。数学上正确的答案是（浮点数）2.5。 （→[第13章](13-numeric-computation.ipynb)中的数字数据类型。）\n",
    "\n",
    "整数除法的约定是截断小数位并仅返回整数部分（即本示例中的“ 2”）。也称为“地板分割”。\n",
    "\n",
    "### 如何避免整数除法\n",
    "\n",
    "有两种方法可以避免整数除法的问题：\n",
    "\n",
    "1.使用Python 3样式划分：即使在带有特殊import语句的Python 2中也可以使用：\n",
    "\n",
    "   ```python\n",
    "   >>> from __future__ import division\n",
    "   >>> 15/6\n",
    "   2.5\n",
    "   ```\n",
    "\n",
    "   如果您想在python程序中使用`from __future__ import division`功能，通常将其包含在文件的开头。\n",
    "\n",
    "2.或者如果我们确保至少一个数字（分子或分母）为float（或复数）类型，则除法运算符将返回浮点数。可以通过写`15.`而不是`15`来实现，也可以通过强制将数字转换为浮点数来实现，即使用`float（15）`代替`15`：\n",
    "\n",
    "   ```python\n",
    "   >>> 15./6\n",
    "   2.5\n",
    "   >>>浮球（15）/ 6\n",
    "   2.5\n",
    "   >>> 15/6。\n",
    "   2.5\n",
    "   >>> 15 /浮球（6）\n",
    "   2.5\n",
    "   >>> 15./6。\n",
    "   2.5\n",
    "   ```\n",
    "\n",
    "如果我们真的想要整数除法，我们可以使用`//`：`1//2`在Python 2和3中都返回0。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "zh-cn"
   },
   "source": [
    "### 我为什么要关心这个划分问题？\n",
    "\n",
    "整数除法会导致令人惊讶的错误：假设您正在编写代码用来计算两个数字*x*和*y*的*平均值* *m* = (*x* + *y*)/2 。编写此文件的第一次尝试可能是：\n",
    "\n",
    "```python\n",
    "m =（x + y）/ 2\n",
    "```\n",
    "\n",
    "假设用*x* = 0.5，*y* = 0.5进行了测试，那么上面的行计算出正确的答案*m* = 0.5（因为0.5 + 0.5 = 1.0 ，即1.0是浮点数，因此，“ 1.0 / 2”的计算结果为“ 0.5”）。或者我们可以使用*x* = 10，*y* = 30，并且由于`10 + 30 = 40`和`40 / 2`的计算结果为`20`，我们得到了正确的答案*m* = 20.但是，如果出现整数*x* = 0和*y* = 1，则代码返回*m* = 0（因为“ 0 +1 = 1”和“ 1/2”计算为“ 0”），而*m* = 0.5将是正确的答案。\n",
    "\n",
    "我们可以通过多种方式更改上面的代码行以安全地工作，包括以下三个版本：\n",
    "\n",
    "```python\n",
    "m = (x + y) / 2.0\n",
    "\n",
    "m = float(x + y) / 2\n",
    "\n",
    "m = (x + y) * 0.5\n",
    "```\n",
    "\n",
    "在大多数编程语言（包括重要的C、C ++和Fortran）中，这种整数除法行为是很常见的，意识到这一点很重要。\n",
    "\n",
    "数学函数\n",
    "----------------------\n",
    "\n",
    "因为Python是一种通用编程语言，所以常用的数学函数（例如sin，cos，exp，log和许多其他函数）位于名为“ math”的数学模块中。一旦*import*数学模块，我们就可以使用它："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.718281828459045"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "math.exp(1.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "zh-cn"
   },
   "source": [
    "使用`dir`函数，我们可以在math模块中看到可用的对象目录："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__doc__',\n",
       " '__loader__',\n",
       " '__name__',\n",
       " '__package__',\n",
       " '__spec__',\n",
       " 'acos',\n",
       " 'acosh',\n",
       " 'asin',\n",
       " 'asinh',\n",
       " 'atan',\n",
       " 'atan2',\n",
       " 'atanh',\n",
       " 'ceil',\n",
       " 'copysign',\n",
       " 'cos',\n",
       " 'cosh',\n",
       " 'degrees',\n",
       " 'e',\n",
       " 'erf',\n",
       " 'erfc',\n",
       " 'exp',\n",
       " 'expm1',\n",
       " 'fabs',\n",
       " 'factorial',\n",
       " 'floor',\n",
       " 'fmod',\n",
       " 'frexp',\n",
       " 'fsum',\n",
       " 'gamma',\n",
       " 'gcd',\n",
       " 'hypot',\n",
       " 'inf',\n",
       " 'isclose',\n",
       " 'isfinite',\n",
       " 'isinf',\n",
       " 'isnan',\n",
       " 'ldexp',\n",
       " 'lgamma',\n",
       " 'log',\n",
       " 'log10',\n",
       " 'log1p',\n",
       " 'log2',\n",
       " 'modf',\n",
       " 'nan',\n",
       " 'pi',\n",
       " 'pow',\n",
       " 'radians',\n",
       " 'remainder',\n",
       " 'sin',\n",
       " 'sinh',\n",
       " 'sqrt',\n",
       " 'tan',\n",
       " 'tanh',\n",
       " 'tau',\n",
       " 'trunc']"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# NBVAL_IGNORE_OUTPUT\n",
    "dir(math)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "zh-cn"
   },
   "source": [
    "和往常一样，“help”函数可以提供有关单个对象上的模块(`help(math)`)的更多信息："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function exp in module math:\n",
      "\n",
      "exp(x, /)\n",
      "    Return e raised to the power of x.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# NBVAL_IGNORE_OUTPUT\n",
    "help(math.exp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "zh-cn"
   },
   "source": [
    "数学模块定义的常量*π*和*e*："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.141592653589793"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.718281828459045"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.e"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.0"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.cos(math.pi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.log(math.e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "zh-cn"
   },
   "source": [
    "变量\n",
    "---------\n",
    "\n",
    "*变量*可用于存储特定值或对象。在Python中，所有数字（以及其他所有东西，包括函数、模块和文件）都是对象。通过赋值创建变量："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "x = 0.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "zh-cn"
   },
   "source": [
    "在这个例子中通过把0.5这个数值赋值给变量后创建变量`x`，我们可以使用它："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.5"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x*3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.25"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "333"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = 111\n",
    "y + 222"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "zh-cn"
   },
   "source": [
    "如果赋值了新值，原来的变量会被覆盖："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = 0.7\n",
    "math.sin(y) ** 2 + math.cos(y) ** 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "zh-cn"
   },
   "source": [
    "等号（'='）用于为变量赋值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "900"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "width = 20\n",
    "height = 5 * 9\n",
    "width * height"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "zh-cn"
   },
   "source": [
    "一个值可以同时赋值给几个变量："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = y = z = 0  # initialise x, y and z with 0\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "zh-cn"
   },
   "source": [
    "变量首先要被创建（赋值），然后才能使用它们，否则会发生错误："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'n' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-32-57d32eaa0fea>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# NBVAL_RAISES_EXCEPTION\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;31m# try to access an undefined variable:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mn\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'n' is not defined"
     ]
    }
   ],
   "source": [
    "# NBVAL_RAISES_EXCEPTION\n",
    "# try to access an undefined variable:\n",
    "n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "zh-cn"
   },
   "source": [
    "在交互模式下，最后打印的表达式被赋值给变量“_”。如果您将Python用作桌面计算器时，会更加容易继续进行一些计算，例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12.5625"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tax = 12.5 / 100\n",
    "price = 100.50\n",
    "price * tax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "113.0625"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "price + _"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "zh-cn"
   },
   "source": [
    "用户应该把这个变量认为是一个只读变量。不要显式的给这个变量赋值——您可以创建一个具有相同名称的独立局部变量，以其内置的魔术行为掩盖内置变量。\n",
    "\n",
    "### 术语\n",
    "\n",
    "严格来说，当我们这样写的时候，这种情况就会发生"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "x = 0.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "zh-cn"
   },
   "source": [
    "首先，Python创建对象“ 0.5”。 Python中的所有内容都是对象，浮点数0.5也是如此。该对象存储在内存中的某个位置。接下来，Python *将名称绑定到对象*。这个名字叫“ x”，我们经常不经意地把“ x”称为变量，对象甚至值0.5。但是，从技术上讲，“ x”是绑定到对象“ 0.5”的名称。换句话说，`x'是对对象的引用。\n",
    "\n",
    "尽管通常考虑将0.5分配给变量x足够了，但是在某些情况下，我们需要记住实际发生的情况。特别是当我们将对象的参数传递给函数时，我们需要意识到函数可以在对象上操作（而不是对象的副本）。在[下一章](03-data-types-structures.ipynb)中将对此进行详细讨论。\n",
    "\n",
    "## 不可能方程\n",
    "--------------------\n",
    "\n",
    "在计算机程序中，我们经常会找到下面这种语句"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "x = x + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "zh-cn"
   },
   "source": [
    "如果我们将其理解为数学中的等式，\n",
    "*x* = *x* + 1\n",
    " 我们可以在两侧减去*x*来发现\n",
    "0 = 1。\n",
    " 我们知道这是不对的，所以这里有些问题。\n",
    "\n",
    "答案是计算机代码中的“等式”不是等式，而是*赋值*。必须始终通过以下两步方式阅读它们：\n",
    "\n",
    "1.评估等号右侧的值\n",
    "\n",
    "2.将该值分配给左侧显示的变量名称。 （在Python中：将左侧的名称绑定到右侧显示的对象。）\n",
    "\n",
    "一些计算机科学文献使用以下符号来表示赋值并避免与数学方程式混淆：\n",
    "\n",
    "$$x \\leftarrow x + 1$$\n",
    "\n",
    "让我们将两步规则应用于上面给出的赋值“ x = x + 1”：\n",
    "\n",
    "1.计算等号右侧的值：为此我们需要知道x的当前值是多少。假设“x”当前为“4”。在这种情况下，右侧的“x + 1”计算结果为“5”。\n",
    "\n",
    "2.将此值（即“5”）分配给左侧“x”所示的变量名称。\n",
    "\n",
    "让我们用Python提示符确认这是正确的解释："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 4     \n",
    "x = x + 1\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "zh-cn"
   },
   "source": [
    "### `+=`表示法\n",
    "\n",
    "因为将变量`x`固定增加一定量`c`是很常见的操作，所以我们可以这样写\n",
    "\n",
    "```python\n",
    "x + = c\n",
    "```\n",
    "\n",
    "代替\n",
    "\n",
    "```python\n",
    "x = x + c\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "zh-cn"
   },
   "source": [
    "因此我们上面的示例可以写成"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 4\n",
    "x += 1\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "zh-cn"
   },
   "source": [
    "其他的运算也定义了类似的运算符，用于与常数进行乘法（`*=`），对常数进行减法（-==）,还有对常数进行除法（`/=`）。\n",
    "\n",
    "注意，“+”和“=”的顺序很重要："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "x += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "zh-cn"
   },
   "source": [
    "这个是将变量“x”增加1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "x =+ 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "zh-cn"
   },
   "source": [
    "这个会将值+1赋给变量x。"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  },
  "nbTranslate": {
   "displayLangs": [
    "zh-cn",
    "en"
   ],
   "hotkey": "alt-t",
   "langInMainMenu": true,
   "sourceLang": "en",
   "targetLang": "zh-cn",
   "useGoogleTranslate": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}