05.Assignments, tests_and_loops.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. 赋值语句"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "赋值语句将对象赋给一个变量，其基本形式是在等号左边写赋值语句的目标，而要赋值的对象位于右侧。\n",
    "\n",
    "- 赋值语句建立对象引用值\n",
    "        Python 变量更像是指针，而不是数据存储区域\n",
    "        \n",
    "- 变量名在首次赋值时会被创建\n",
    "\n",
    "\n",
    "- 变量名在引用前必须先赋值\n",
    "        使用尚未进行赋值的变量名是一种错误，Python 会引发异常。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "赋值语句的形式\n",
    "\n",
    "|运算|解释|\n",
    "|:--|:---|\n",
    "|spam='Spam'|基本形式|\n",
    "|spam, ham = 'yum', 'YUM'|元组赋值运算|\n",
    "|[spam, ham] = ['yum', 'YUM']|列表赋值运算|\n",
    "|a, b, c, d = 'spam'|序列赋值运算|\n",
    "|a, \\*b = 'spam'|序列解包|\n",
    "|spam = ham = 'lunch'|多目标赋值|\n",
    "|spams += 42|增强赋值运算（相当于spams = spams + 42）|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.1 序列赋值"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以下是一些序列分解赋值语句的简单例子："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2)"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "theta = 1\n",
    "delta = 2\n",
    "[C, D] = [theta, delta]     # List assignment\n",
    "C, D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A, B = theta, delta          # Tuple assignment\n",
    "A, B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "第二个例子是元组赋值语句，只是省略了元组的括号。在语句执行时，Python 会建立临时的元组来存储赋值运算符右侧变量的值，再将其和左侧元组内的变量互相匹配。\n",
    "\n",
    "元组赋值语句是 Python 中一个常用的编写代码技巧。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 1)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A, B = B, A                 # Swap values\n",
    "A, B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "事实上，Python 中原始的元组和列表赋值语句形式已被通用化，支持右侧是任何类型的序列（可迭代的对象），只要左右两侧长度相等即可。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 3)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[a, b, c] = (1, 2, 3)\n",
    "a, c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('A', 'C')"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(a, b, c) = 'ABC'\n",
    "a, c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在 for 循环中也同样有效："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 3\n",
      "4 6\n"
     ]
    }
   ],
   "source": [
    "for (a, b, c) in [(1, 2, 3), (4, 5, 6)]:\n",
    "    print(a, c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 3\n",
      "4 6\n"
     ]
    }
   ],
   "source": [
    "for ((a, b), c) in [((1, 2), 3), ((4, 5), 6)]:\n",
    "    print(a, c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在循环中将序列分割为开头和剩余两部分："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 [2, 3, 4]\n",
      "2 [3, 4]\n",
      "3 [4]\n",
      "4 []\n"
     ]
    }
   ],
   "source": [
    "L = [1, 2, 3, 4]\n",
    "while L:\n",
    "    front, L = L[0], L[1:]\n",
    "    print(front, L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.2 序列解包"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "序列赋值通常要求左边的目标名称数量与右边的主体中的数量完全相同。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#a, b, c = [1, 2, 3, 4]   # ValueError: too many values to unpack"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python 3.0 允许我们使用更为通用的扩展解包语法：**序列解包**。我们可以在目标中使用带单个星号的名称来更通用的匹配。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a, *b = [1, 2, 3, 4]\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 4]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "带星号的名称可以出现在目标中的任何地方。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([1, 2, 3], 4)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "*a, b = [1, 2, 3, 4]\n",
    "a, b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, [2, 3], 4)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a, *b, c = [1, 2, 3, 4]\n",
    "a, b, c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "和常规的序列赋值一样，**序列解包**语法对于任何序列类型都有效。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('s', ['p', 'a', 'm'])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a, *b = 'spam'\n",
    "a, b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "序列解包赋值总是返回多个匹配项的一个列表。有了这样的语法，我们处理前一小节的最后一个例子变得容易很多。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 [2, 3, 4]\n",
      "2 [3, 4]\n",
      "3 [4]\n",
      "4 []\n"
     ]
    }
   ],
   "source": [
    "L = [1, 2, 3, 4]\n",
    "while L:\n",
    "    front, *L = L\n",
    "    print(front, L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "序列解包对于 for 循环语句也同样有效："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 [2, 3] 4\n",
      "5 [6, 7] 8\n"
     ]
    }
   ],
   "source": [
    "for (a, *b, c) in [(1, 2, 3, 4), (5, 6, 7, 8)]:\n",
    "    print(a, b, c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 边界情况"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "尽管序列解包很灵活，一些边界情况需要我们注意。\n",
    "\n",
    "首先，带星号的名称可能只匹配单个的项，但总是会向其赋值一个列表："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 [4]\n"
     ]
    }
   ],
   "source": [
    "a, b, c, *d = [1, 2, 3, 4]\n",
    "print(a, b, c, d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "其次，如果没有剩下的内容可以匹配带星号的名称，它会赋值一个空的列表，而不会引发错误。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 []\n"
     ]
    }
   ],
   "source": [
    "a, b, c, d, *e = [1, 2, 3, 4]\n",
    "print(a, b, c, d, e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 [] 3 4\n"
     ]
    }
   ],
   "source": [
    "a, b, *c, d, e = [1, 2, 3, 4]\n",
    "print(a, b, c, d, e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最后，如果有多个带星号的名称，以及带星号的名称没有编写到一个列表或元组中，都会引发错误。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "#a, *b, *c, d = [1, 2, 3, 4]   # SyntaxError: two starred expressions in assignment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "#*a = [1, 2, 3, 4]          # SyntaxError: starred assignment target must be in a list or tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.3 多目标赋值语句\n",
    "\n",
    "多目标赋值语句就是直接把所有提供的变量名都赋值给右侧的对象。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "spame spame spame\n"
     ]
    }
   ],
   "source": [
    "a = b = c = 'spame'\n",
    "print(a, b, c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "记住，这里只有一个对象，由三个变量共享（三个变量全部指向内存同一对象）。当对象是可变对象时，我们就得小心一点："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([42], [42])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = b = []\n",
    "b.append(42)\n",
    "a, b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "因为 a 和 b 引用相同的对象，通过 b 在原处添加元素上去，通过 a 也会看见修改的结果。\n",
    "\n",
    "为了避免这个问题，要在单独的语句中初始化可变对象，以便分别执行独立的常量表达式来创建独立的空对象："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([], [42])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = []\n",
    "b = []\n",
    "b.append(42)\n",
    "a, b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.4 增强赋值语句"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "增强赋值语句是从 C 语言借鉴而来，也就是二元表达式和赋值语句的组合：\n",
    "\n",
    "- 传统形式\n",
    "\n",
    "        x = x + y         \n",
    "\n",
    "- 增强赋值\n",
    "\n",
    "        x += y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 1\n",
    "x += 2\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'spamSPAM'"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S = 'spam'\n",
    "S += 'SPAM'            # Implied concatenation\n",
    "S"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "每个 Python 二元表达式的运算符都有对应的增强赋值形式：        \n",
    "\n",
    "| | | | |\n",
    "|:-:|:-:|:-:|:-:|\n",
    "| x += y|  x -=y | x \\*= y |  x /=y |\n",
    "| x %= y | x \\*\\*=y | x //= y |x &= y|\n",
    "| x \\|=y | x ^= y | x <<= y | x >>=y |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "增强赋值语句的优点：\n",
    "\n",
    "- 程序员减少输入\n",
    "\n",
    "\n",
    "- 左侧只需计算一次。\n",
    "        在完整形式 x = x + y 中，x 出现了两次。如果 x 是复杂的对象表达式，则必须被计算两次。而增强形式中只需计算一次。因此增强赋值语句通常执行得更快。\n",
    "\n",
    "\n",
    "- 会自动选择优化技术\n",
    "        支持原处修改的对象，增强形式会自动执行原处的修改运算，而不是相比来说速度更慢的复制。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = [1, 2]\n",
    "L = L + [3]           # Slower concatenate\n",
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L += [4]             # Faster\n",
    "L"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 增强赋值和共享引用\n",
    "\n",
    "注意：增强赋值对于可变类型，隐含了原处修改的意思"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([1, 2, 3, 4], [1, 2])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = [1, 2]\n",
    "M = L\n",
    "L = L + [3, 4]         # Concatenation makes a new object\n",
    "L, M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([1, 2, 3, 4], [1, 2, 3, 4])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = [1, 2]\n",
    "M = L\n",
    "L += [3, 4]            # += really means in-place extend\n",
    "L, M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. if 语句"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "复合语句 = 首行 + \":\" + 缩进语句。\n",
    "\n",
    "Python 中所有复合语句都遵循相同格式：首行会以冒号终止，再接一个或多个嵌套语句，而且通常都是在首行下缩进的。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python **if** 语句用来选取要执行的操作，是 Python 中主要的选择工具。它也是我们首度讨论的复合语句：if 语句可以包含其它语句，也可以嵌套包含。\n",
    "\n",
    "其形式是 **if** 判断，后面跟着零个或多个 **elif** (\"else if\")判断，以及一个最终可选的 **else** 块。当 if 语句执行时，Python 会执行测试第一个计算结果为真的代码块，或者如果所有测试都为假时执行 else 块。if 语句一般形式如下：\n",
    "\n",
    "```python\n",
    "if test1:               # if test\n",
    "    statements1         # Associated block\n",
    "elif test2:             # Optional elifs\n",
    "    statements2\n",
    "else:\n",
    "    statements3         # Optional else\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "true\n"
     ]
    }
   ],
   "source": [
    "if 1:\n",
    "    print('true')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Run away! Run away!\n"
     ]
    }
   ],
   "source": [
    "x = 'killer rabbit'\n",
    "if x == 'roger':\n",
    "    print(\"shave and a haircut\")\n",
    "elif x == 'bugs':\n",
    "    print(\"what's up doc?\")\n",
    "else:\n",
    "    print('Run away! Run away!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.1. 真值测试\n",
    "\n",
    "Python 的布尔运算符和 C/C++ 语言(&&、|| 和 !)有些不同，Pyhon的三种表达式运算符为 **'and' 'or' 'not'**\n",
    "\n",
    "- 任何非零数字或非空对象都为**真**\n",
    "\n",
    "- 数字零、空对象以及特殊对象 None 都被认作是**假**\n",
    "\n",
    "- 比较和相等测试会递归应用在数据结构中\n",
    "\n",
    "- 比较和相等测试会返回 True 或 False\n",
    "\n",
    "- 布尔 **and** 和 **or** 运算符会返回真或假的操作对象"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "就 **or** 测试而言，Python 会从左向右求算操作对象，然后返回第一个为真的操作对象，这通常叫做**短路计算(short-circuit evaluation)**。如果左边操作数为假，则计算右边的操作数并将其返回。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 3)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 or 3, 3 or 2                  # Return left operand if true"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[] or 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[] or {}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在结果知道时，**and** 运算也会立刻停止。因此，当 Python 从左向右计算操作数时，如果左操作数为假则返回左操作数，否则返回右操作数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 2)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 and 3, 3 and 2                # Return left operand if false"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 and []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[] and {}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2. if / else三元表达式"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "下面的简单例子，根据 X 的真值将 A 赋值成 Y 或 Z。\n",
    "\n",
    "```python\n",
    "if X:\n",
    "    A = Y\n",
    "else:\n",
    "    A = Z\n",
    "```\n",
    "Python 中支持在一个表达式中编写出相同的结果：\n",
    "```python\n",
    "A = Y if X else Z\n",
    "```\n",
    "只有当 X 为假，才会执行表达式 Z。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'t'"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = 't' if 'spam' else 'f'          # For strings, nonempty means true\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'f'"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = 't' if '' else 'f'\n",
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. while 和 for 循环\n",
    "\n",
    "此前已经见过这两种循环，这里会介绍一些其它的有用细节，如 break 和 continue，并且会介绍循环中常用的内置函数 (range, zip 和 map)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. while 循环\n",
    "\n",
    "while 语句是 Python 中最通用的迭代结构。只要顶端测试一直为真值，就会重复执行一个语句块（通常有缩进）。当测试为假时，控制权会传给 while 块后的语句。\n",
    "\n",
    "```python\n",
    "while <test>:                    # Loop test\n",
    "    <statements1>                # Loop body\n",
    "else:                            # Optional else\n",
    "    <statements2>                # Run if didn't exit loop with break\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "spam pam am m "
     ]
    }
   ],
   "source": [
    "x = 'spam'\n",
    "while x:                            # While x is not empty\n",
    "    print(x, end=' ')               # In 2.X use print x,\n",
    "    x = x[1:]                       # Strip first character off x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "无限循环：Python 会一直执行主体，直到你停止执行位置。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "#while True:\n",
    "#    print('Type Ctrl-C to stop me!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.1 break、continue、pass和循环else\n",
    "\n",
    "- break\n",
    "      跳出整个循环语句\n",
    "\n",
    "- continue\n",
    "      跳到最近所在循环的开头处\n",
    "\n",
    "- pass\n",
    "      无运算的空占位语句。当语法需要语句但还没有实用的语句可写时，就可以使用它。\n",
    "\n",
    "- 循环else块\n",
    "      只有当循环正常离开（没有碰到 break 语句）才会执行"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "加入 break  和 continue 语句后，while 循环的一般格式如下所示：\n",
    "\n",
    "```python\n",
    "while <test1>:\n",
    "    <statements1>\n",
    "    if <test2>: break               # Exit loop now, skip else if present\n",
    "    if <test3>: continue            # Go to top of loop now, to test1\n",
    "else:\n",
    "    <statements2>                  # Run if we didn't hit a 'break'\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### continue\n",
    "\n",
    "continue 语句会立即跳到循环的顶端。下面示例使用 continue 跳过奇数。这个程序代码会打印所有10并大于等于0的偶数。只有当 continue 不执行时，才会运行到 print()。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8 6 4 2 0 "
     ]
    }
   ],
   "source": [
    "x = 10\n",
    "while x:\n",
    "    x = x - 1                               # Or, x -= 1\n",
    "    if x % 2 != 0:\n",
    "        continue                            # Odd? -- skip print\n",
    "    print(x, end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "但是，continue 会降低程序的可读性，应该尽量减少使用。上面代码可以写成："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8 6 4 2 0 "
     ]
    }
   ],
   "source": [
    "x = 10\n",
    "while x:\n",
    "    x = x - 1\n",
    "    if x % 2 == 0:                          # Even? -- print\n",
    "        print(x, end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### break\n",
    "\n",
    "break 语句会立刻离开循环，位于其后的循环代码都不会执行。所以有时可以引入 break 来避免嵌套化。以下是简单的交互模式下的循环，当用户在 name 中输入\"stop\"时结束。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter name:Bob\n",
      "Enter age: 20\n",
      "Hello Bob => 400\n",
      "Enter name:stop\n"
     ]
    }
   ],
   "source": [
    "while True:\n",
    "    name = input('Enter name:')             # Use raw_input() in 2.X\n",
    "    if name == 'stop':\n",
    "        break\n",
    "    age = input('Enter age: ')\n",
    "    print('Hello', name, '=>', int(age) ** 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 循环else\n",
    "\n",
    "循环else 分句是很多编程语言都不支持而 Python 特有的，容易使一些初学者产生困惑。和循环else 子句结合时，break 语句通常可以忽略其他语言中所需的搜索状态标志位。\n",
    "\n",
    "例如，下面程序搜索大于 1 的因子，用来决定正整数 y 是否为质数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12 has factor 6\n"
     ]
    }
   ],
   "source": [
    "y = 12\n",
    "x = y // 2                      # For some y > 1\n",
    "while x > 1:\n",
    "    if y % x == 0: # Remainder\n",
    "        print(y, 'has factor', x)\n",
    "        break                   # Skip else\n",
    "    x -= 1\n",
    "else:                           # Normal exit\n",
    "    print(y, 'is prime')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "例如，假设需要写个循环搜索列表的值，而且需要知道离开循环后该值是否已找到，可能会用这种方式编写该任务：\n",
    "```python\n",
    "found = False\n",
    "while x and not found:\n",
    "    if match(x[0]):          # Value at front?\n",
    "        print('Ni')\n",
    "        found = True\n",
    "    else:\n",
    "        x = x[1:]            # Slice off front and repeat\n",
    "if not found:\n",
    "    print('not found')\n",
    "```\n",
    "如果改用循环else 分句，将会得到简洁的版本。因为在循环末尾使用 else 取代了 if 测试，不再需要标志位变量了，\n",
    "```python\n",
    "while x:                    # Exit when x empty\n",
    "    if match(x[0]):\n",
    "        print('Ni')\n",
    "        break               # Exit, go around else\n",
    "    x = x[1:]\n",
    "else:\n",
    "    print('Not found')      # Only here if exhausted x\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. for 循环\n",
    "\n",
    "for 循环在 Python 中是一个通用的序列迭代器：可以遍历任何有序的序列对象元素。for 语句可用于字符串、列表、元组、其它内置可迭代对象以及自己创建的类对象。\n",
    "\n",
    "Python for 循环的首行定义了一个赋值目标，以及想遍历的对象，首行后面是想重复的语句块。\n",
    "```python\n",
    "for target in object:       # Assign object items to target\n",
    "    statements              # Repeated loop body: use target\n",
    "else:                       # Optional else part\n",
    "    statements              # If we didn't hit a 'break'\n",
    "```\n",
    "\n",
    "当运行 for 循环时，会逐个将序列对象中的元素赋值给目标，然后为每个元素执行循环主体。循环主体一般使用赋值的目标来引用序列中当前的元素，因此目标就像遍历序列的游标。\n",
    "\n",
    "for 循环也支持一个可选的 else 块：如果循环离开时没有碰到 break 语句，就会执行（也就是所有元素都访问过了）。\n",
    "\n",
    "```python\n",
    "for target in object:       # Assign object items to target\n",
    "    statements\n",
    "    if test:\n",
    "        break               # Exit loop now, skip else\n",
    "    if test:\n",
    "        continue            # Go to top of loop now\n",
    "else:\n",
    "    statements              # If we didn't hit a 'break'\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## 4.1 基本应用\n",
    "\n",
    "for 循环遍历任何一种序列对象，包括列表、字符串和元组。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "spam eggs ham "
     ]
    }
   ],
   "source": [
    "for x in [\"spam\", \"eggs\", \"ham\"]:\n",
    "    print(x, end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "下面的例子会计算列表中所有元素的和与积。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum = 0\n",
    "for x in [1, 2, 3, 4]:\n",
    "    sum = sum + x\n",
    "sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prod = 1\n",
    "for item in [1, 2, 3, 4]:\n",
    "    prod *= item\n",
    "prod"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "l u m b e r j a c k "
     ]
    }
   ],
   "source": [
    "S = \"lumberjack\"\n",
    "for x in S:\n",
    "    print(x, end=' ')               # Iterate over a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "and I'm okay "
     ]
    }
   ],
   "source": [
    "T = (\"and\", \"I'm\", \"okay\")\n",
    "for x in T:\n",
    "    print(x, end=' ')               # Iterate over a tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.2 在 for 循环中的元组赋值\n",
    "\n",
    "在迭代元组组成的序列时，循环目标本身可以是元组，这也是元组解包的赋值运算。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2\n",
      "3 4\n",
      "5 6\n"
     ]
    }
   ],
   "source": [
    "T = [(1, 2), (3, 4), (5, 6)]\n",
    "for (a, b) in T:                 # Tuple assignment at work\n",
    "    print(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "尽管我们可以在 for 循环中手动赋值以解包："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2\n",
      "3 4\n",
      "5 6\n"
     ]
    }
   ],
   "source": [
    "for both in T:\n",
    "    a, b = both                 # Manual assignment equivalent\n",
    "    print(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "因此，我们可以在遍历字典中键值对时变得很方便，而不必再遍历键并手动索引以获取值："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a => 1\n",
      "b => 2\n",
      "c => 3\n"
     ]
    }
   ],
   "source": [
    "D = {'a': 1, 'b': 2, 'c': 3}\n",
    "for key in D:\n",
    "    # Use dict keys iterator and index\n",
    "    print(key, '=>', D[key])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('a', 1), ('b', 2), ('c', 3)]"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(D.items())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a => 1\n",
      "b => 2\n",
      "c => 3\n"
     ]
    }
   ],
   "source": [
    "for (key, value) in D.items():\n",
    "    # Iterate over both keys and values\n",
    "    print(key, '=>', value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.3 嵌套 for 循环\n",
    "\n",
    "下面示例在 for 循环中包含了语句嵌套以及 else 分句。这段代码会在对象列表中搜索每个键，然后打印其搜索结果。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(4, 5) was found\n",
      "3.14 not found!\n"
     ]
    }
   ],
   "source": [
    "items = [\"aaa\", 111, (4, 5), 2.01]          # A set of objects\n",
    "tests = [(4, 5), 3.14]                      # Keys to search for\n",
    "\n",
    "for key in tests:                           # For all keys\n",
    "    for item in items:                      # For all items\n",
    "        if item == key:                     # Check for match\n",
    "            print(key, \"was found\")\n",
    "            break\n",
    "    else:\n",
    "        print(key, \"not found!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "外层循环扫描键列表，而内层循环扫描 items 列表。嵌套 if 会在找到相符结果时执行 break，而循环 else 分句是认定如果来到此处意味搜索失败。\n",
    "\n",
    "如果这里改成 in 运算符测试成员关系，这个示例会更加简洁："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(4, 5) was found\n",
      "3.14 not found!\n"
     ]
    }
   ],
   "source": [
    "for key in tests:                           # For all keys\n",
    "    if key in items:                        # Let Python check for a match\n",
    "        print(key, \"was found\")\n",
    "    else:\n",
    "        print(key, \"not found!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. 编写循环的技巧\n",
    "\n",
    "一般而言，for 比 while 容易写，运行得也更快，因此当需要遍历序列时，应该把它作为首选工具。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.1 不要在 for 和 while 循环后面写 else 块"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loop 0\n",
      "Loop 1\n",
      "Loop 2\n",
      "Else block!\n"
     ]
    }
   ],
   "source": [
    "for i in range(3):\n",
    "    print('Loop {}'.format(i))\n",
    "else:\n",
    "    print('Else block!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上面代码中的 else 块会在整个循环执行完之后立刻执行。既然如此，那它为什么叫做 **else** 而不是 **and** 呢？\n",
    "\n",
    "在 if/else语句中，else 的意思是：如果不执行前面那个 if 块，那就执行 else 块。刚接触 Python 的人可能会把 for/else 结构中的 else 块理解为：如果循环没有正常执行完，那就执行 else 块。实际上刚好相反——在循环里用 break 语句提前跳出，会导致程序不执行 else 块。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loop 0\n",
      "Loop 1\n"
     ]
    }
   ],
   "source": [
    "for i in range(3):\n",
    "    print('Loop {}'.format(i))\n",
    "    if i == 1:\n",
    "        break\n",
    "else:\n",
    "    print('Else block!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "还有一个奇怪的地方：初始循环条件为 False 的 while 循环，如果后面跟着 else 块，那它会立刻执行。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "While Else block!\n"
     ]
    }
   ],
   "source": [
    "while False:\n",
    "    print('Never runs')\n",
    "else:\n",
    "    print('While Else block!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果 for 循环要遍历的序列是空的，那么也会立刻执行 else 块："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For Else block!\n"
     ]
    }
   ],
   "source": [
    "for x in []:\n",
    "    print('Never runs')\n",
    "else:\n",
    "    print('For Else block!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这样的写法会让阅读代码的人（包括你自己）感到相当费解。像循环这种简单的语言结构，在 Python 程序中应该写的非常直白才对。所以，我们完全不应该在循环后面使用 else 块。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.2 相关内置函数\n",
    "\n",
    "在有些情况下，需要以更为特定的方式来迭代。Python 提供了三个内置函数，可以在 for 循环内定制迭代。\n",
    "\n",
    "- 内置 range() 函数返回一系列连续增加的整数，可作为 for 中的索引\n",
    "\n",
    "- 内置 zip() 函数返回并行元素的元组的列表，可用于在 for 中遍历多个序列\n",
    "\n",
    "- 内置 enumerate() 函数同时返回迭代对象的索引和数值"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.2.1 range() 函数\n",
    "\n",
    "range() 函数是一个通用的迭代器，会根据需要产生元素，常用在 for 循环中产生索引。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([0, 1, 2, 3, 4], [2, 3, 4], [0, 2, 4, 6, 8])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(5)), list(range(2, 5)), list(range(0, 10, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4]"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(-5, 5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 4, 3, 2, 1, 0, -1, -2, -3, -4]"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(5, -5, -1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "例如，要打印3行时，使用range() 产生适当的整数数字："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 Pythons\n",
      "1 Pythons\n",
      "2 Pythons\n"
     ]
    }
   ],
   "source": [
    "for i in range(3):\n",
    "    print(i, 'Pythons')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以用 range() 产生用于迭代索引的列表。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s p a m "
     ]
    }
   ],
   "source": [
    "x = 'spam'\n",
    "for i in range(len(x)):\n",
    "    print(x[i], end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "但是，它的运行速度会较慢。只要可能，就改用 Python 中的简单的 for 循环，只将 range() 调用视为最后的手段。这样不仅更容易编写，而且通常运行的更快。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s p a m "
     ]
    }
   ],
   "source": [
    "X = 'spam'\n",
    "for item in X:\n",
    "    print(item, end=' ')             # Simple iteration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "使用 range() 可以让我们做更特殊的遍历。例如，在遍历过程中跳过一些元素，同时依然保持 for 循环的简单性。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a c e g i k "
     ]
    }
   ],
   "source": [
    "S = 'abcdefghijk'\n",
    "for i in range(0, len(S), 2):\n",
    "    print(S[i], end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 修改列表\n",
    "\n",
    "假设因某种理由要为列表中每个元素加1，你可以通过简单的 for 循环来做，但是结果并不符合期望："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5]"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = [1, 2, 3, 4, 5]\n",
    "for x in L:\n",
    "    x += 1                  # Changes x, not L\n",
    "L"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "因为修改的是循环变量 x 而不是列表L。要真的在遍历列表时对其进行修改，我们需要使用索引。range/len 组合可以产生所需要的索引："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = [1, 2, 3, 4, 5]\n",
    "for i in range(len(L)):     # Add one to each item in L\n",
    "    L[i] += 1               # Or L[i] = L[i] + 1\n",
    "L"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "也可以用等效的 while 循环实现，但是这种循环需要我们多做些工作，并且有可能运行得更慢："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = [1, 2, 3, 4, 5]\n",
    "i = 0\n",
    "while i < len(L):\n",
    "    L[i] += 1\n",
    "    i += 1\n",
    "L"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.2.2 zip() 函数\n",
    "\n",
    "内置的 **zip**() 函数允许我们使用 for 循环来并行遍历多个序列。zip 会取得一个或多个序列作为参数，然后返回元组的列表，将这些序列中的并排元素配成对。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 5), (2, 6), (3, 7), (4, 8)]"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L1 = [1,2,3,4]\n",
    "L2 = [5,6,7,8]\n",
    "list(zip(L1, L2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "for 循环使用元组赋值运算以解包 zip 结果中的每个元组。第一次迭代时，就类似执行了赋值语句\n",
    "```python\n",
    "(x, y) = (1, 5)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 5 -- 6\n",
      "2 6 -- 8\n",
      "3 7 -- 10\n",
      "4 8 -- 12\n"
     ]
    }
   ],
   "source": [
    "for (x, y) in zip(L1, L2):\n",
    "    print(x, y, '--', x + y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果不用 zip() 函数，我们可以用 while 循环手动处理索引，以达到同样的效果，但是需要更多的输入，而且可能始终比 for/zip方法运行效率低。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "当参数长度不同时，zip 会以最短序列的长度为准来截断所得到的的元组。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('a', 'x'), ('b', 'y'), ('c', 'z')]"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S1 = 'abc'\n",
    "S2 = 'xyz123'\n",
    "list(zip(S1, S2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 使用 zip 构造字典\n",
    "\n",
    "内置变量名 dict 其实是 Python 中的类型名称。对它进行调用的时候，可以得到类似列表到字典的转换。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'spam': 1, 'eggs': 3, 'toast': 5}"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "keys = ['spam', 'eggs', 'toast']\n",
    "vals = [1, 3, 5]\n",
    "D3 = dict(zip(keys, vals))\n",
    "D3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.2.3 enumerate() 函数\n",
    "\n",
    "之前，我们讨论通过 range() 来产生偏移值，而不是那些偏移值处的元素。不过，有些程序中，我们两者都需要：要用的元素以及这个元素的偏移值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s appears at offset 0\n",
      "p appears at offset 1\n",
      "a appears at offset 2\n",
      "m appears at offset 3\n"
     ]
    }
   ],
   "source": [
    "S = 'spam'\n",
    "offset = 0\n",
    "for item in S:\n",
    "    print(item, 'appears at offset', offset)\n",
    "    offset += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上面的例子同时输出了元素和偏移值。内置函数 enumerate() 提供了一种精简的写法，可以在遍历迭代器时获知每个元素的索引。使用 enumerate()，可以简化我们的程序："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s appears at offset 0\n",
      "p appears at offset 1\n",
      "a appears at offset 2\n",
      "m appears at offset 3\n"
     ]
    }
   ],
   "source": [
    "S = 'spam'\n",
    "for (offset, item) in enumerate(S):\n",
    "    print(item, 'appears at offset', offset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "enumerate"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "E = enumerate(S)               # enumerate(S)返回一个生成器对象\n",
    "type(E)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 's')"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(E)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 'p')"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(E)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 练习\n",
    "\n",
    "1. 一个循环的 else 分句何时执行？\n",
    "\n",
    "2. 实现从1到100求和\n",
    "\n",
    "3. 从一个包含多个字符串的列表中找出长度最长的字符串及其位置\n",
    "```python\n",
    "names = ['Cecilia', 'Lise', 'Marie', 'Jennifer']\n",
    "```\n",
    "\n",
    "4. 输出九九乘法口诀"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.7"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "313px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}