Basic.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python 入门\n",
    "\n",
    "## 数值类型和计算\n",
    "\n",
    "Python是一门非常简单易懂的语言，绝大多数Python程序都非常符合人类语言的直觉。比如，如果需要计算两个数字相加，可以直接输入："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 + 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "或者乘除法："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7.5"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "30 / 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 * 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果需要整除运算，可以使用两个斜杠："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "30 // 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以及取余运算："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "30 % 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "与其他编程语言稍微有点区别的是幂运算，在Python中需要使用两个\\*号代表幂运算，比如如果需要计算$2^{10}$，可以："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1024"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2**10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以上我们计算了很多整数的加减乘除，这种不带有小数点的整数，在Python中一般使用**int**整型表示，可以使用**type\\()**函数查看其类型："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "而带有小数点的称为浮点型**float**，其用法与int类似"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(3.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "浮点型也有以上所有的运算："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.5"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3.5 + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.5"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3.5 - 1.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12.25"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3.5**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.8708286933869707"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3.5 ** 0.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在Python中，可以使用round()函数将浮点数四舍五入为整数，或者将浮点数保留规定位数的小数，比如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.6666666666666665"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "8 / 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "round(8 / 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.67"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "round(8 / 3, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-2.67"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "round(-8 / 3, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 逻辑运算与比较\n",
    "\n",
    "同理，我们可以使用大于号、小于号、大于等于、小于等于等符号判断大小："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 > 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 >= 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 < 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "注意以上程序的结果返回的是**True**和**False**，这两个值在Python中分别代表逻辑真、逻辑假。逻辑真、假之间可以有与、或、非的运算："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True and True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True and False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "False and False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True or True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True or False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "False or False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 > 2 and 3 > 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "此外，判断是否相等需要用两个连在一起的等号“==”，判断不相等可以使用“!=”，否则会报错："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 == 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4 != 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 != 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "此外，需要额外注意的是，由于舍入误差的原因，尽量不要对浮点数直接使用==或者!=的比较运算，比如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(0.1 + 0.2) == 0.3 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "就会出现与预期不一致的结果。如果需要比较，可以使用round()函数对其进行四舍五入以消除舍入误差："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "round(0.1 + 0.2, 10) == round(0.3, 10) # 保留小数点后10位"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "或者可以直接判断两个数字之间的差距是否小于某个误差范围："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abs(0.1 + 0.2 - 0.3) < 1e-10 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "其中abs()函数为取绝对值，1e-10为科学计数法，即$1\\times10^{-10}$。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 运算优先级\n",
    "\n",
    "以上我们介绍了几种常见的运算，包括：\n",
    "\n",
    "* 算数运算\n",
    "    - \\+\n",
    "    - \\-\n",
    "    - \\*\n",
    "    - /\n",
    "    - //\n",
    "    - %\n",
    "    - \\*\\*\n",
    "* 比较运算\n",
    "    - ==\n",
    "    - !=\n",
    "    - \\<\n",
    "    - \\<=\n",
    "    - \\>\n",
    "    - \\>=\n",
    "* 逻辑运算\n",
    "    - and\n",
    "    - or\n",
    "    - not\n",
    "\n",
    "等等。这些运算符号并不是从左到右依次执行的，而是具有优先级顺序，比如：\n",
    "\n",
    "```python\n",
    "3+5*7-2\n",
    "```\n",
    "\n",
    "计算的结果应该是先将5\\*7计算出来得到35，再加3、减2，得到36，而不是3+5得到8,8\\*7=56，再减2得到54："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "36"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 + 5 * 7 - 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在Python中优先级从高到低依次为：\n",
    "\n",
    "1. \\*\\*\n",
    "2. +x、-x：正负号\n",
    "3. \\*、/、%\n",
    "4. +、-\n",
    "5. ==、!=、\\<、\\>、\\<=、\\>=\n",
    "6. not\n",
    "7. and\n",
    "8. or\n",
    "\n",
    "因而，按照以上规则，我们上面的表达式：\n",
    "```python\n",
    "1>2 and 3>2\n",
    "```\n",
    "\n",
    "应该时先计算1>2的值得到False，再计算3>2的值得到True，最后计算False and True，得到False。\n",
    "\n",
    "此外，需要注意幂运算的等级比正负号要高，所以如果计算："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-4"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "-2**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "其计算顺序为先计算$2^2$，再取负，得到了-4。\n",
    "\n",
    "为了改变运算顺序，我们需要加小括号，比如如果我们想要计算$(-2)^2$，需要使用："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(-2)**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "才能得到正确的答案。\n",
    "\n",
    "当对运算优先级没有信心时，多加括号是非常好的习惯。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 变量\n",
    "\n",
    "**变量**（**variable**）是几乎所有编程语言都具有的特性。变量实质上是内存中的一个区域，其中存储着某一些值。在Python中，由于不用像C、Java一样显示地指明变量类型，因而用起来非常简单，直接使用等号“=”赋值即可。比如，我们可以使用以下语句将3这个值保存在变量x中，并在后面引用这个变量："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "x = 3\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "变量命名需要一些规则\n",
    "\n",
    "* 变量名不能以数字开头\n",
    "* 变量名不能是python的保留字符，比如is、in等\n",
    "* 不能含有+、-、\\*、空格等特殊字符，但是下划线允许\n",
    "* 变量名区分大小写\n",
    "\n",
    "除以上外，其他字符都可以使用，由于Python3支持Unicode，因而即使中文也可以做变量名："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "4\n",
      "4 - 5\n"
     ]
    }
   ],
   "source": [
    "三 = 3\n",
    "print(三)\n",
    "_a = 4\n",
    "print(_a)\n",
    "_A = 5\n",
    "print(_a, \"-\", _A)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "虽然Python的变量名要求相对比较宽松，但是还是有一些良好的习惯需要注意：\n",
    "\n",
    "* 尽量不要使用中文做变量名\n",
    "* 变量名要有意义，方便阅读\n",
    "* 单个下划线（_）以及两个下划线（__）开头的变量有时有特殊含义，建议除非明确知道其含义，否则尽量避免使用下划线开头的变量名\n",
    "* 命名时，如果变量名包含几个单词，可以使用下划线区分，或者使用驼峰规则，每个单词第一个字母大写，比如：cat_weight，或者CatWeight\n",
    "\n",
    "除了简单的使用等号赋值之外，Python还有其他几个比较方便的赋值语句，比如：\n",
    "\n",
    "* +=：a+=b等价于a=a+b\n",
    "* -=：a-=b等价于a=a-b\n",
    "* \\*=：a\\*=b等价于a=a\\*b\n",
    "* /=：a/=b等价于a=a/b\n",
    "* \\*\\*=：a\\*\\*=b等价于a=a\\*\\*b\n",
    "* //=：a//=b等价于a=a//b\n",
    "* %=：a%=b等价于a=a%b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "2\n",
      "4\n",
      "2.0\n",
      "4.0\n"
     ]
    }
   ],
   "source": [
    "a = 2\n",
    "a += 1\n",
    "print(a)\n",
    "a -= 1\n",
    "print(a)\n",
    "a *= 2\n",
    "print(a)\n",
    "a /= 2\n",
    "print(a)\n",
    "a **= 2\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "另一个比较方便的写法是**海象运算符**“**:=**”，Python 3.8之后支持该特性，其作用是在赋值的同时返回赋予的值。比如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = (a := 100 % 8) ** 2 \n",
    "print(a)\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "其中“b = (a := (100 % 8)) \\*\\* 2 ”这个表达式等价于实现了以下两步："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 100 % 8\n",
    "b = a ** 2 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在定义变量时，还可以加入类型提示，比如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a: int = 3\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "其中的“: int”就是类型提示：提示a是一个整数。不过，类型提示没有任何强制性，我们甚至可以直接："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.14"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a: int = 3.14\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "同样不会报错，因为类型提示仅仅是一个提示，对于解释器而言不会有任何影响。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 字符串\n",
    "\n",
    "以上介绍了Python中的数值类型，而在程序设计中，另外一个基础的数据类型就是字符串。\n",
    "\n",
    "与其他大多数语言一样，Python中使用单引号“''”和双引号“\"\"”表示字符串，以上两种表示方法是等价的："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Python!\n"
     ]
    }
   ],
   "source": [
    "a = \"Hello,\"\n",
    "b = 'Python!'\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "为什么有两种表示字符串的方式呢？比如，如果我们需要“Let's go”这样一个字符串，如果使用单引号：\n",
    "```python\n",
    "'Let's go'\n",
    "```\n",
    "\n",
    "我们会发现Python自动将Let前后的单引号作为一个字符串，而其后面的“s go”含义不明，从而报错。为了解决这个问题，可以使用双引号：\n",
    "```python\n",
    "\"Let's go\"\n",
    "```\n",
    "就避免了这个问题。同理，如果字符串中存在双引号，就使用单引号声明字符串：\n",
    "```python\n",
    "'\"Python\" is a programming language.'\n",
    "```\n",
    "\n",
    "此外，也有的时候字符串中会同时出现单引号和双引号，此时我们可是使用转义字符解决这个问题，比如：\n",
    "```python\n",
    "\"\\\"Python\\\" is a programming language, let\\'s learn it.\"\n",
    "```\n",
    "\n",
    "在上面的代码中，我们使用“\\\"”代表了“\"”，使用“\\'”代表“'”，从而解决了单引号、双引号与字符串命名冲突的问题："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"Python\" is a programming language, let's learn it.\n"
     ]
    }
   ],
   "source": [
    "a = \"\\\"Python\\\" is a programming language, let\\'s learn it.\"\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "除了单引号之外，还有一些其他的字符需要转义，比如，斜杠“\\”本身就需要转义，因为如果不对“\\”转义，解释器并不知道这个斜杠就是一个斜杠，还是与后面的字符链接起来的转义字符，比如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'' is a special character in Python\n"
     ]
    }
   ],
   "source": [
    "a = \"'\\' is a special character in Python\"\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以发现，Python将斜杠和后面的单引号视为一体，因而没有将斜杠打印出来，正确的写法应该是："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'\\' is a special character in Python\n"
     ]
    }
   ],
   "source": [
    "a = \"'\\\\' is a special character in Python\"\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "除此之外，Python3中还有其他转义字符：\n",
    "\n",
    "* 每一行结尾处的\\\\：续行符\n",
    "* \\\\\\\\：反斜杠\n",
    "* \\\\'：单引号\n",
    "* \\\\\"：单引号\n",
    "* \\\\b：退格\n",
    "* \\\\v：纵向制表符\n",
    "* \\\\t：横向制表符\n",
    "* \\\\r：回车\n",
    "* \\\\n：换行\n",
    "* \\\\f：换页\n",
    "* ......\n",
    "\n",
    "这里值得注意的是，换行符\\\\n和回车符号\\\\r是两个不同的符号，这点我们在介绍文件时会特别强调。\n",
    "\n",
    "除了使用单引号和双引号表示字符串之外，Python还支持长字符串、原始字符串两种表示方法。\n",
    "\n",
    "其中，长字符串使用三个单引号或者三个双引号包裹，可以用来表示跨越多行的字符串。比如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "这是一个可以跨行的字符串\n",
      "使用三个单引号\n",
      "或者三个双引号包裹\n",
      "\n"
     ]
    }
   ],
   "source": [
    "a = \"\"\"这是一个可以跨行的字符串\n",
    "使用三个单引号\n",
    "或者三个双引号包裹\n",
    "\"\"\"\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "而原始字符串即不对反斜杠进行转义，比如一个路径可能为：\n",
    "```python\n",
    "a=\"C:\\network\"\n",
    "```\n",
    "\n",
    "然而注意到，由于“\\\\n”有转义，所以Python解释器在碰到“\\\\n”时将其解释为回车："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C:\n",
      "etwork\n"
     ]
    }
   ],
   "source": [
    "a = \"C:\\network\"\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果需要声明该字符串为原始字符串，可以直接在字符串前面加一个“r”，即："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C:\\network\n"
     ]
    }
   ],
   "source": [
    "a = r\"C:\\network\"\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "此时，Python解释器就不会将“\\\\n”进行转义了。\n",
    "\n",
    "此外，Python3中所有的字符串都是以Unicode进行编码的，因而极大地规避了在Python2以及其他语言中可能碰到的乱码问题，因而使用Python3是非常方便的。也正因为如此，我们可以很方便的使用Unicode字符，并使用“\\\\N{unicode_name}”来表示Unicode字符，比如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a cat: 🐈\n"
     ]
    }
   ],
   "source": [
    "a = \"This is a cat: \\N{cat}\"\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unicode字符可以从 http://unicode-table.com 中找到。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果需要拼接两个字符串，可以简单的使用加号："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a cat: 🐈\n"
     ]
    }
   ],
   "source": [
    "a = \"This is a cat: \"\n",
    "b = \"\\N{cat}\"\n",
    "c = a + b\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最后需要额外注意的是，作为字符串的\"3\"和作为整型数据的3是完全不一样的，因而我们不能使用：\n",
    "```python\n",
    "\"3\"+2\n",
    "```\n",
    "\n",
    "这样的表达式，正确的做法应该是先使用int()函数将字符串\"3\"转化为数值类型，再进行计算："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "a = int(\"3\") + 2\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "同理，如果希望将一个数值型数字处理为字符串，也需要使用str()函数先将数字转化为字符串："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 3 cats.\n"
     ]
    }
   ],
   "source": [
    "a = 3\n",
    "b = \"There are \" + str(a) + \" cats.\"\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 列表和元组\n",
    "\n",
    "以上我们初步介绍了Python的三种基本数据类型：整型、浮点型以及字符串。接下来我们引入Python中的两种最基本也是最常用的数据结构：**列表**（**list**）和**元组**（**tuple**）。\n",
    "\n",
    "列表和元组都是序列（sequence）的一种，可以看成是一些元素的集合，每个元素都有其位置编号，编号从0开始。列表使用方括号“\\[\\]”进行声明，而元组使用小括号“()”进行声明，或者不用括号直接声明。列表和元组所包含的内容可以是任何Python允许的数据类型、对象等等。\n",
    "\n",
    "### 元组\n",
    "\n",
    "最简单也是最基本的是元组。元组不可更改，一旦创建，只能读取而不能写入，比如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Messi', 10)\n"
     ]
    }
   ],
   "source": [
    "name_list = \"Messi\", 10\n",
    "print(name_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以上就创建了一个元组，我们可以读取其某一个分量，但是不能对其进行更改。我们可以使用元组名后面加一个方括号读取相应编号位的元素："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Messi\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "print(name_list[0])\n",
    "print(name_list[1])\n",
    "## 以下语句会报错：\n",
    "# name_list[1]=7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "由于编号从0开始，因而name_list\\[0\\]代表的是元组中的第一个元素，而name_list\\[1\\]代表第二个元素。方括号中也可以是负数，代表倒数第几个元素："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "Messi\n"
     ]
    }
   ],
   "source": [
    "print(name_list[-1])\n",
    "print(name_list[-2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "此外，如果需要声明只有一个元素的元组，需要额外加一个逗号，否则解释器无法判断需要声明的是一个值还是一个元组："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Messi',)\n",
      "Messi\n"
     ]
    }
   ],
   "source": [
    "name = 'Messi',\n",
    "print(name)\n",
    "name1 = 'Messi'\n",
    "print(name1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "当然，在声明元组时，一个良好的习惯是加上括号，使得程序更具有可读性。\n",
    "\n",
    "由于元组也是Python中的对象，因而元组的成员也可以是元组，并可以使用两个方括号对作为元组成员的元组中的元素进行读取操作："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Messi\n",
      "Xavi : 6\n"
     ]
    }
   ],
   "source": [
    "name_list = (('Messi', 10), ('Xavi', 6), ('Iniesta', 8), ('Puyol', 5))\n",
    "print(name_list[0][0])\n",
    "print(name_list[1][0], \":\", name_list[1][1])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "元组虽然不能修改，但是支持**切片**（**slicing**）操作：即从中取出一个子集。切片操作同样使用元组名称后面跟一个方括号，在方括号中使用冒号“:”代表起始位置和终点位置（注意是左闭右开区间）："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(('Messi', 10), ('Xavi', 6))\n",
      "(('Xavi', 6), ('Iniesta', 8))\n",
      "(('Xavi', 6), ('Iniesta', 8), ('Puyol', 5))\n",
      "(('Iniesta', 8), ('Puyol', 5))\n"
     ]
    }
   ],
   "source": [
    "print(name_list[0:2])\n",
    "print(name_list[-3:-1])\n",
    "print(name_list[-3:])\n",
    "print(name_list[2:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "实际上，切片操作还可以支持步进，切片的通用语法为：\n",
    "```python\n",
    "x[start:end:step]\n",
    "```\n",
    "\n",
    "其中start的默认值为0，step的默认值为1，而end的默认值为x的维数的大小。如果我们指向取出奇数位的元素，我们可以使用："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(('Messi', 10), ('Iniesta', 8))\n"
     ]
    }
   ],
   "source": [
    "print(name_list[::2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以上切片操作被翻译为：从0开始，一直到结束，隔一个取一个元素。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 列表\n",
    "\n",
    "列表的很多操作跟元组类似，但是列表允许被修改，因而更加灵活，也有更多的操作。\n",
    "\n",
    "我们可以很方便的使用方括号定义一个列表："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('Messi', 10), ('Xavi', 6), ('Iniesta', 8), ('Puyol', 5)]\n"
     ]
    }
   ],
   "source": [
    "player_list = [('Messi', 10), ('Xavi', 6), ('Iniesta', 8), ('Puyol', 5)]\n",
    "print(player_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "注意以上声明的过程中，与元组唯一的不同是我们在最外面使用了方括号而非圆括号。\n",
    "\n",
    "或者，我们可以使用list()将一个**可迭代**（**iterable**）的对象（包括字符串、元组、列表等）转化为一个列表，比如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(('Messi', 10), ('Xavi', 6), ('Iniesta', 8), ('Puyol', 5))\n",
      "[('Messi', 10), ('Xavi', 6), ('Iniesta', 8), ('Puyol', 5)]\n",
      "['M', 'e', 's', 's', 'i']\n"
     ]
    }
   ],
   "source": [
    "print(name_list)\n",
    "name_list_list = list(name_list)\n",
    "print(name_list_list)\n",
    "messi = list('Messi')\n",
    "print(messi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "与列表不同的是，我们可以对列表进行修改操作："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('Messi', 10), ('Xavi', 6), ('Iniesta', 8), ('Puyol', 5)]\n",
      "[('Messi', 10), ('Xavi', 6), ('Iniesta', 8), ('ter Stegen', 1)]\n"
     ]
    }
   ],
   "source": [
    "print(player_list)\n",
    "player_list[3] = ('ter Stegen', 1)\n",
    "print(player_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以及使用del语句进行删除操作："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('Messi', 10), ('Xavi', 6), ('ter Stegen', 1)]\n"
     ]
    }
   ],
   "source": [
    "del player_list[2]\n",
    "print(player_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "当然，也可以进行新增，使用列表的append()方法可以在列表最后添加一个元素，比如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('Messi', 10), ('Xavi', 6), ('ter Stegen', 1), ('Busquets', 5)]\n"
     ]
    }
   ],
   "source": [
    "player_list.append(('Busquets', 5))\n",
    "print(player_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果需要添加的元素比较多，可以使用extend()方法，比如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('Messi', 10), ('Xavi', 6), ('ter Stegen', 1), ('Busquets', 5), ('Pique', 3), ('Suárez', 9)]\n"
     ]
    }
   ],
   "source": [
    "player_list_new = [('Pique', 3), ('Suárez', 9)]\n",
    "player_list.extend(player_list_new)\n",
    "print(player_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果需要在某一个位置插入元素，可以使用insert()方法："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('Messi', 10), ('Alba', 18), ('Xavi', 6), ('ter Stegen', 1), ('Busquets', 5), ('Pique', 3), ('Suárez', 9)]\n"
     ]
    }
   ],
   "source": [
    "player_list.insert(1, ('Alba', 18))\n",
    "print(player_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "还可以使用count()方法计算某个元素出现的次数、使用index()方法找到某个元素第一次出现的位置，比如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "messi = list('Messi')\n",
    "count_s = messi.count('s')\n",
    "first_s = messi.index('s')\n",
    "print(count_s)\n",
    "print(first_s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "需要特别注意的是，在Python中，使用等号将一个对象赋值给另一个对象，并不会导致对象的拷贝，而仅仅是给了一个别名，比如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('Messi', 10), ('Alba', 18), ('Xavi', 6), ('ter Stegen', 1), ('Busquets', 5), ('Pique', 3), ('Suárez', 9)]\n",
      "[('Messi', 10), ('Xavi', 6), ('ter Stegen', 1), ('Busquets', 5), ('Pique', 3), ('Suárez', 9)]\n"
     ]
    }
   ],
   "source": [
    "another_play_list = player_list\n",
    "print(player_list)\n",
    "del another_play_list[1]\n",
    "print(player_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在以上程序中，我们会发现，虽然我们删除的是another_play_list的第2个元素，但是实际上，another_player_list和play_list只是同一个变量的不同别名而已，并没有重新复制一个新的list。\n",
    "\n",
    "如果我们需要的是list的一个新的拷贝，需要使用list的copy()方法："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('Messi', 10), ('Xavi', 6), ('ter Stegen', 1), ('Busquets', 5), ('Pique', 3), ('Suárez', 9)]\n",
      "[('Messi', 10), ('Xavi', 6), ('ter Stegen', 1), ('Busquets', 5), ('Pique', 3), ('Suárez', 9)]\n",
      "[('Messi', 10), ('ter Stegen', 1), ('Busquets', 5), ('Pique', 3), ('Suárez', 9)]\n"
     ]
    }
   ],
   "source": [
    "another_play_list = player_list.copy()\n",
    "print(player_list)\n",
    "del another_play_list[1]\n",
    "print(player_list)\n",
    "print(another_play_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最后，列表、元组、字符串还支持in操作符，该操作符判断in之前的元素是否属于之后的列表、元组或者字符串，比如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(('Pique', 3) in player_list)\n",
    "print('Messi' in player_list)\n",
    "print('Messi' in player_list[0])\n",
    "print('Messi' in player_list[1])\n",
    "print('d' in 'Messi')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果要判断in之前的元素“不属于”之后的列表、元组或字符串，可以使用“not in”:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "False\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(('Pique', 3) not in player_list)\n",
    "print('Messi' not in player_list)\n",
    "print('Messi' not in player_list[0])\n",
    "print('Messi' not in player_list[1])\n",
    "print('d' not in 'Messi')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最后，我们还可以使用sort()方法对列表进行排序，比如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 4, 6, 7]\n",
      "[7, 6, 4, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "a = [1, 6, 2, 4, 7]\n",
    "a.sort()\n",
    "print(a)\n",
    "a.sort(reverse=True)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在比较复杂的情况下，还可以使用key选项制定排序的方式，比如，我们可能需要对player_list中的球员号码进行排序，可以使用："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('ter Stegen', 1), ('Pique', 3), ('Busquets', 5), ('Xavi', 6), ('Suárez', 9), ('Messi', 10)]\n"
     ]
    }
   ],
   "source": [
    "player_list.sort(key=lambda x: x[1])\n",
    "print(player_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "当然，以上的语法已经超出了目前所学范围，我们将在后面介绍lambda的含义。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 集合\n",
    "\n",
    "无论是列表还是元组，都允许有重复的元素存在，但是有时我们可能需要不重复的元素，此时可以使用**集合**（**set**）类。\n",
    "\n",
    "集合的声明与列表类似，区别在于集合使用大括号{}，而非中括号。\n",
    "\n",
    "与list()类似，可以使用使用set()构建集合："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'i', 'M', 's', 'e'}\n"
     ]
    }
   ],
   "source": [
    "letters = set(\"Messi\")\n",
    "print(letters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以上可以看到，set()构建了一个不重复元素组成的集合。可以使用add()方法以及update()方法为集合新增元素，比如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'s', 'e', 'M', 'i', 'a'}\n",
      "{'s', 'e', 'M', 'i', 'a', ('a',)}\n",
      "{'d', 's', 'c', 'e', 'M', 'i', 'a', ('a',)}\n"
     ]
    }
   ],
   "source": [
    "letters.add('a')\n",
    "print(letters)\n",
    "letters.add(('a', ))\n",
    "print(letters)\n",
    "letters.update({'c', 'd'})\n",
    "print(letters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "值得注意的是，在上面的程序中，我们添加了字符串'a'，以及一个元组('a',)，两者一个是字符串，一个是元组，是不同的，因而在集合中两者并不冲突。\n",
    "\n",
    "如果需要删除，可以使用remove()方法以及discard()方法，两者的区别在于：remove()方法不能删除不存在的元素，否则报错；而discard()方法如果要删除的元素不存在，不会报错。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'d', 's', 'c', 'e', 'M', 'i', 'a'}\n",
      "{'d', 's', 'c', 'e', 'M', 'i', 'a'}\n"
     ]
    }
   ],
   "source": [
    "letters.remove(('a', ))\n",
    "print(letters)\n",
    "letters.discard('z')\n",
    "print(letters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "此外，集合之间还有交集（&）、并集（|）、差集（-）、对称差（^）等的操作，其中差集的定义为$A-B=A\\cap B^{c}$，对称差的定义为$A \\Delta B=\\left(A\\cap B^{c}\\right)\\cup\\left(B\\cap A^{c}\\right)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2}"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{1, 2, 3} & {1, 2, 4} "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4}"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{1, 2, 3} | {1, 2, 4} "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{3}"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{1, 2, 3} - {1, 2, 4} "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{3, 4}"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{1, 2, 3} ^ {1, 2, 4} "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最后，作为集合，还可以使用issubset()和issuperset()方法判断某一个集合是不是另外一个集合的子集或者超集："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(letters.issuperset({'a', 'b'}))\n",
    "print(letters.issuperset({'a', 'd'}))\n",
    "print({'a', 'd'}.issubset(letters))\n",
    "print({'a', 'd'}.issuperset(letters))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "或者直接使用大于号、小于号"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{1, 2, 3} > {1, 2}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{1, 2, 3} > {1, 2, 3} "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{1, 2, 3} >= {1, 2, 3} "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 控制语句：循环\n",
    "\n",
    "有时我们需要重复一条类似的命令很多次，此时我们可以使用循环命令。\n",
    "\n",
    "在Python中有两个循环语句：while和for，两者很大程度上是等价的，但是在不同情况下方便程度时不一样的。\n",
    "\n",
    "for作为关键字，其基本语法为：\n",
    "```python\n",
    "for var in iterable_obj:\n",
    "    ## code\n",
    "```\n",
    "\n",
    "其中var为一个变量，iterable_obj为一个可迭代对象，如列表、元组或者字符串，其后面紧接着跟着一个冒号。\n",
    "\n",
    "在这里需要注意的是，不像C或者Java使用大括号区分代码块，在Python中，主要靠缩进区分代码块，因而需要循环执行的代码，要写在for语句的下一行，并使用Tab键或者几个（一般为4/8个）空格进行缩进。\n",
    "\n",
    "比如，以下语句把字符串中的每个字符都分别打印出来："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "M\n",
      "e\n",
      "s\n",
      "s\n",
      "i\n"
     ]
    }
   ],
   "source": [
    "name = 'Messi'\n",
    "for n in name:\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "而以下代码将player_list中所有的人名及号码打印出来："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ter Stegen : 1\n",
      "Pique : 3\n",
      "Busquets : 5\n",
      "Xavi : 6\n",
      "Suárez : 9\n",
      "Messi : 10\n",
      "---the end---\n"
     ]
    }
   ],
   "source": [
    "for player in player_list:\n",
    "    print(player[0], end='')\n",
    "    print(\" : \", end='')\n",
    "    print(player[1])\n",
    "print(\"---the end---\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "注意到最后一行并没有被缩进，因而不属于需要循环执行的代码块，因而只执行了一次。\n",
    "\n",
    "此外，经常遇到的一个情形是对数字进行循环，此时可以使用range()函数。如果使用range(N)，将会返回一个可迭代的对象，其值为0,...,N-1。比如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "也可以使用range(N,M)的形式，此时返回迭代对象的值为N,N+1,...,M-1，比如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(1, 11))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "使用以上特性，我们可以方便的使用range()函数来写for 循环，比如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "M\n",
      "e\n",
      "s\n",
      "s\n",
      "i\n"
     ]
    }
   ],
   "source": [
    "name = 'Messi'\n",
    "for i in range(len(name)):\n",
    "    print(name[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "其中len()函数取得name中元素的个数，由于len(name)的值为5，因而range(len(name))就产生了一个可以迭代的、值为0,1,2,3,4的对象。\n",
    "\n",
    "以下程序计算了从1到101的所有奇数的和："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2601\n"
     ]
    }
   ],
   "source": [
    "sum_odd = 0\n",
    "for i in range(0, 51):\n",
    "    odd = 2 * i + 1\n",
    "    sum_odd += odd\n",
    "print(sum_odd)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "但是在迭代列表时，如果需要获得元素的位置，我们可以使用range()函数，比如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 ter Stegen 1\n",
      "1 Pique 3\n",
      "2 Busquets 5\n",
      "3 Xavi 6\n",
      "4 Suárez 9\n",
      "5 Messi 10\n"
     ]
    }
   ],
   "source": [
    "for i in range(len(player_list)):\n",
    "    print(i, player_list[i][0], player_list[i][1])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "然而以上代码还是不够好看，一个更易读的写法是使用enumerate()函数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 ter Stegen 1\n",
      "1 Pique 3\n",
      "2 Busquets 5\n",
      "3 Xavi 6\n",
      "4 Suárez 9\n",
      "5 Messi 10\n"
     ]
    }
   ],
   "source": [
    "for (i, player) in enumerate(player_list):\n",
    "    print(i, player[0], player[1])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这样代码的可读性就更强了。\n",
    "\n",
    "如果我们有两个列表需要同时遍历，还可以使用zip()函数。比如，如果以上列表被拆成两个：\n",
    "```python\n",
    "name_list=[\"ter Stegen\",\"Pique\",\"Busquets\",\"Xavi\",\"Suárez\",\"Messi\"]\n",
    "code_list=[1,3,5,6,9,10]\n",
    "```\n",
    "\n",
    "我们有以下三种方法可以遍历两个列表："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "------Method 1------\n",
      "ter Stegen : 1\n",
      "Pique : 3\n",
      "Busquets : 5\n",
      "Xavi : 6\n",
      "Suárez : 9\n",
      "Messi : 10\n",
      "------Method 2------\n",
      "ter Stegen : 1\n",
      "Pique : 3\n",
      "Busquets : 5\n",
      "Xavi : 6\n",
      "Suárez : 9\n",
      "Messi : 10\n",
      "------Method 3------\n",
      "ter Stegen : 1\n",
      "Pique : 3\n",
      "Busquets : 5\n",
      "Xavi : 6\n",
      "Suárez : 9\n",
      "Messi : 10\n"
     ]
    }
   ],
   "source": [
    "name_list = [\"ter Stegen\", \"Pique\", \"Busquets\", \"Xavi\", \"Suárez\", \"Messi\"]\n",
    "code_list = [1, 3, 5, 6, 9, 10]\n",
    "print(\"------Method 1------\")\n",
    "for i in range(len(name_list)):\n",
    "    print(name_list[i], \":\", code_list[i])\n",
    "print(\"------Method 2------\")\n",
    "for (i, player) in enumerate(name_list):\n",
    "    print(player, \":\", code_list[i])\n",
    "print(\"------Method 3------\")\n",
    "for (p, c) in zip(name_list, code_list):\n",
    "    print(p, \":\", c)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "三种遍历方法都是等价的，但是使用zip()的方法可读性更强一点。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "而while循环的语法为：\n",
    "```python\n",
    "while logic_expression:\n",
    "    ## code\n",
    "```\n",
    "\n",
    "同样，while循环的代码块也需要用缩进表示，而logic_expression是一个逻辑判断语句，只有当logic_expression值为真时，循环才继续执行，否则跳出循环。比如刚刚从1到101的所有奇数的和的代码也可以写为："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2601\n"
     ]
    }
   ],
   "source": [
    "sum_odd = 0\n",
    "odd = 1\n",
    "while odd <= 101:\n",
    "    sum_odd += odd\n",
    "    odd += 2\n",
    "print(sum_odd)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "特别需要注意的是一定不要忘了及时更新odd，否则很容易造成无限循环。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 控制语句：条件\n",
    "\n",
    "条件语句用于判断某一个逻辑表达式，如果为真，则执行某个代码块。其最基本的形式如下：\n",
    "```python\n",
    "if logic_expression:\n",
    "    ## code\n",
    "```\n",
    "\n",
    "同样，代码块也需要用缩进表示，其中的代码块只有当logic_expression的值为真时才执行，否则不执行。\n",
    "\n",
    "比如，如下的代码中，首先判断球员姓名是否为Messi或者Suárez，如果是，则打印其位置："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Suárez :前锋\n",
      "Messi :前锋\n"
     ]
    }
   ],
   "source": [
    "for p in player_list:\n",
    "    if p[0] == 'Messi' or p[0] == 'Suárez':\n",
    "        print(p[0], \":前锋\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "此外，if 后面还可以跟elif语句：\n",
    "```python\n",
    "if logic_expression1:\n",
    "    ## code1\n",
    "elif logic_expression2:\n",
    "    ## code2\n",
    "elif  logic_expression3:\n",
    "    ## code3\n",
    "....\n",
    "```\n",
    "\n",
    "即“else if”，如果logic_expression1满足，则执行code1，如果不满足，则继续判断logic_expression2是否满足，若满足，则执行code2，以此类推。比如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pique ：后卫\n",
      "Busquets ：中场\n",
      "Xavi ：中场\n",
      "Suárez ：前锋\n",
      "Messi ：前锋\n"
     ]
    }
   ],
   "source": [
    "for p in player_list:\n",
    "    if p[0] in ('Messi', 'Suárez'):\n",
    "        print(p[0], \"：前锋\")\n",
    "    elif p[0] in ('Xavi', 'Arthur', 'Busquets'):\n",
    "        print(p[0], \"：中场\")\n",
    "    elif p[0] in ('Pique'):\n",
    "        print(p[0], \"：后卫\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最后，还可以加else语句，用于所有的if或者elif的逻辑表达式都不满足时执行"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ter Stegen 守门员\n",
      "Pique ：后卫\n",
      "Busquets ：中场\n",
      "Xavi ：中场\n",
      "Suárez ：前锋\n",
      "Messi ：前锋\n"
     ]
    }
   ],
   "source": [
    "for p in player_list:\n",
    "    if p[0] in ('Messi', 'Suárez'):\n",
    "        print(p[0], \"：前锋\")\n",
    "    elif p[0] in ('Xavi', 'Iniesta', 'Busquets'):\n",
    "        print(p[0], \"：中场\")\n",
    "    elif p[0] in ('Pique'):\n",
    "        print(p[0], \"：后卫\")\n",
    "    else:\n",
    "        print(p[0], \"守门员\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "此外，if语句可以与break、continue、pass等一起控制循环。其中：\n",
    "\n",
    "* break：跳出循环不再执行\n",
    "* countinue：跳出本次循环后面的代码，但是循环继续执行\n",
    "* pass：什么都不做，继续执行\n",
    "\n",
    "比如，计算从1到101的所有奇数的和的代码也可以写为："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2601\n"
     ]
    }
   ],
   "source": [
    "sum_odd = 0\n",
    "odd = 1\n",
    "while True:\n",
    "    sum_odd += odd\n",
    "    odd += 2\n",
    "    if odd > 101:\n",
    "        break\n",
    "print(sum_odd)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在以上代码中，while True代表循环会一直执行，但是if语句会判断odd是否大于了101，如果odd一旦大于101，就会使用break退出循环。\n",
    "\n",
    "如果我们需要计算从1到101的所有不能被5整除的奇数的和，可以使用pass语句："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2101\n"
     ]
    }
   ],
   "source": [
    "sum_odd = 0\n",
    "odd = 1\n",
    "while odd <= 101:\n",
    "    if odd % 5 == 0:\n",
    "        pass\n",
    "    else:\n",
    "        sum_odd += odd\n",
    "    odd += 2\n",
    "print(sum_odd)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以下代码我们使用continue语句将一个字符串中所有的's'都给去掉"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mei\n"
     ]
    }
   ],
   "source": [
    "a = 'Messi'\n",
    "b = ''\n",
    "for s in a:\n",
    "    if s == 's':\n",
    "        continue\n",
    "    b += s\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在以上代码中，当碰到's'时，循环跳过了b+=s这一句，而是继续执行循环，直到循环结束。与之相比的是break命令直接跳出了循环："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Me\n"
     ]
    }
   ],
   "source": [
    "a = 'Messi'\n",
    "b = ''\n",
    "for s in a:\n",
    "    if s == 's':\n",
    "        break\n",
    "    b += s\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 控制语句：异常\n",
    "\n",
    "理想与现实总是有差距的。在程序现实运行过程中，出于很多原因，总是可能会存在**异常**（**exception**）。比如，一个最简单的异常是，允许用户输入两个数字相除，但是用户却输入了0作为分母；或者，用户输入的不是数字，而是字母。此时，正常的程序可能会发生错误。\n",
    "\n",
    "任何高级语言几乎都带有处理异常的功能，Python也不例外。\n",
    "\n",
    "在Python中，可以使用try...except...else...finally语句来处理异常，语法为：\n",
    "```python\n",
    "try:\n",
    "    # code1\n",
    "except Exception1:\n",
    "    # code2\n",
    "except Exception2:\n",
    "......\n",
    "\n",
    "else:\n",
    "    # code3\n",
    "finally:\n",
    "    #code4\n",
    "```\n",
    "\n",
    "首先，解释器会执行code1，如果没有错误，就执行code3，并继续下去。如果发生了错误，会查看具体发生何种错误，执行相应的except中的命令。else为如果没有发生错误，会执行code3。最终，无论错误是否发生，code4都会被执行，并继续执行finally后面的代码。\n",
    "\n",
    "比如，下面一个例子展示了分母为0时的处理方法："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "分母为0:，错误信息： division by zero\n",
      "C'est la vie!\n",
      "10\n",
      "生活还要继续。\n"
     ]
    }
   ],
   "source": [
    "a = 1\n",
    "b = 0\n",
    "try:\n",
    "    c = a / b\n",
    "except ZeroDivisionError as e:\n",
    "    print(\"分母为0:，错误信息：\", e)\n",
    "else:\n",
    "    print(\"没有错误发生。\")\n",
    "finally:\n",
    "    print(\"C'est la vie!\")\n",
    "    print(c)\n",
    "print(\"生活还要继续。\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "没有错误发生。\n",
      "C'est la vie!\n",
      "0.0\n",
      "生活还要继续。\n"
     ]
    }
   ],
   "source": [
    "a = 0\n",
    "b = 1\n",
    "try:\n",
    "    c = a / b\n",
    "except ZeroDivisionError as e:\n",
    "    print(\"分母为0:，错误信息：\", e)\n",
    "else:\n",
    "    print(\"没有错误发生。\")\n",
    "finally:\n",
    "    print(\"C'est la vie!\")\n",
    "    print(c)\n",
    "print(\"生活还要继续。\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "except可以不止有一个，比如，我们可能还需要处理类型错误，比如将数字和字符串进行运算："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "类型错误： unsupported operand type(s) for /: 'str' and 'int'\n",
      "C'est la vie!\n",
      "0.0\n"
     ]
    }
   ],
   "source": [
    "a = '0'\n",
    "b = 1\n",
    "try:\n",
    "    c = a / b\n",
    "except ZeroDivisionError as e:\n",
    "    print(\"分母为0:，错误信息：\", e)\n",
    "except TypeError as e:\n",
    "    print(\"类型错误：\", e)\n",
    "else:\n",
    "    print(\"没有错误发生。\")\n",
    "finally:\n",
    "    print(\"C'est la vie!\")\n",
    "    print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "或者可以将两者合并："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "错误： unsupported operand type(s) for /: 'str' and 'int'\n",
      "C'est la vie!\n",
      "0.0\n"
     ]
    }
   ],
   "source": [
    "a = '0'\n",
    "b = 1\n",
    "try:\n",
    "    c = a / b\n",
    "except (ZeroDivisionError, TypeError) as e:\n",
    "    print(\"错误：\", e)\n",
    "else:\n",
    "    print(\"没有错误发生。\")\n",
    "finally:\n",
    "    print(\"C'est la vie!\")\n",
    "    print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果不知道会发生什么错误，也可以什么也不加，捕获所有错误："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "错误：\n",
      "C'est la vie!\n",
      "0.0\n"
     ]
    }
   ],
   "source": [
    "a = '0'\n",
    "b = 1\n",
    "try:\n",
    "    c = a / b\n",
    "except:\n",
    "    print(\"错误：\")\n",
    "else:\n",
    "    print(\"没有错误发生。\")\n",
    "finally:\n",
    "    print(\"C'est la vie!\")\n",
    "    print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "更好的办法是将错误捕获，并打印出来方便调试："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "错误： unsupported operand type(s) for /: 'str' and 'int'\n",
      "C'est la vie!\n",
      "0.0\n"
     ]
    }
   ],
   "source": [
    "a = '0'\n",
    "b = 1\n",
    "try:\n",
    "    c = a / b\n",
    "except Exception as e:\n",
    "    print(\"错误：\", e)\n",
    "else:\n",
    "    print(\"没有错误发生。\")\n",
    "finally:\n",
    "    print(\"C'est la vie!\")\n",
    "    print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 列表推导\n",
    "\n",
    "在Python中，可以结合循环语句for、判断语句if、else等，写出更加简洁的程序。\n",
    "\n",
    "比如，如果我们希望生成一个1...99中所有能被3整除的奇数的表达式，一般可以通过如下的程序："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 9, 15, 21, 27, 33, 39, 45, 51, 57, 63, 69, 75, 81, 87, 93, 99]\n"
     ]
    }
   ],
   "source": [
    "a = []\n",
    "for i in range(50):\n",
    "    if (2 * i + 1) % 3 == 0:\n",
    "        a.append(2 * i + 1)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以上代码已经足够简洁，但是Python还支持以下更简洁的方式："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 9, 15, 21, 27, 33, 39, 45, 51, 57, 63, 69, 75, 81, 87, 93, 99]\n"
     ]
    }
   ],
   "source": [
    "a = [2 * i + 1 for i in range(50) if (2 * i + 1) % 3 == 0]\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "当然，也支持双重循环，比如列出一个奇数元组，第一个分类能被3整除，第二个分类能被5整除："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(3, 5), (3, 15), (3, 25), (3, 35), (3, 45), (3, 55), (3, 65), (3, 75), (3, 85), (3, 95), (9, 5), (9, 15), (9, 25), (9, 35), (9, 45), (9, 55), (9, 65), (9, 75), (9, 85), (9, 95), (15, 5), (15, 15), (15, 25), (15, 35), (15, 45), (15, 55), (15, 65), (15, 75), (15, 85), (15, 95), (21, 5), (21, 15), (21, 25), (21, 35), (21, 45), (21, 55), (21, 65), (21, 75), (21, 85), (21, 95), (27, 5), (27, 15), (27, 25), (27, 35), (27, 45), (27, 55), (27, 65), (27, 75), (27, 85), (27, 95), (33, 5), (33, 15), (33, 25), (33, 35), (33, 45), (33, 55), (33, 65), (33, 75), (33, 85), (33, 95), (39, 5), (39, 15), (39, 25), (39, 35), (39, 45), (39, 55), (39, 65), (39, 75), (39, 85), (39, 95), (45, 5), (45, 15), (45, 25), (45, 35), (45, 45), (45, 55), (45, 65), (45, 75), (45, 85), (45, 95), (51, 5), (51, 15), (51, 25), (51, 35), (51, 45), (51, 55), (51, 65), (51, 75), (51, 85), (51, 95), (57, 5), (57, 15), (57, 25), (57, 35), (57, 45), (57, 55), (57, 65), (57, 75), (57, 85), (57, 95), (63, 5), (63, 15), (63, 25), (63, 35), (63, 45), (63, 55), (63, 65), (63, 75), (63, 85), (63, 95), (69, 5), (69, 15), (69, 25), (69, 35), (69, 45), (69, 55), (69, 65), (69, 75), (69, 85), (69, 95), (75, 5), (75, 15), (75, 25), (75, 35), (75, 45), (75, 55), (75, 65), (75, 75), (75, 85), (75, 95), (81, 5), (81, 15), (81, 25), (81, 35), (81, 45), (81, 55), (81, 65), (81, 75), (81, 85), (81, 95), (87, 5), (87, 15), (87, 25), (87, 35), (87, 45), (87, 55), (87, 65), (87, 75), (87, 85), (87, 95), (93, 5), (93, 15), (93, 25), (93, 35), (93, 45), (93, 55), (93, 65), (93, 75), (93, 85), (93, 95), (99, 5), (99, 15), (99, 25), (99, 35), (99, 45), (99, 55), (99, 65), (99, 75), (99, 85), (99, 95)]\n"
     ]
    }
   ],
   "source": [
    "b = [(2 * i + 1, 2 * j + 1) for i in range(50) for j in range(50)\n",
    "     if (2 * i + 1) % 3 == 0 and (2 * j + 1) % 5 == 0]\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "此外还支持else语句，比如，以下代码将1...10的所有奇数都取负数，所有偶数保持不变："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-1, 2, -3, 4, -5, 6, -7, 8, -9, 10]\n"
     ]
    }
   ],
   "source": [
    "c = [i + 1 if (i + 1) % 2 == 0 else -(i + 1) for i in range(10)]\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "注意如果需要使用else，if...else...要写在for前面。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 字典\n",
    "\n",
    "**字典**（**dictionary**）在Python中是一种映射关系，即特定的单词（**键**，**key**）以及其**值**（**value**）之间的关系。字典可以使用大括号配合冒号进行声明，比如之前的球员号码："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Messi': 10, 'Xavi': 6, 'Iniesta': 8, 'Pique': 3}\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "players = {\"Messi\": 10, \"Xavi\": 6, \"Iniesta\": 8, \"Pique\": 3}\n",
    "print(players)\n",
    "print(players['Messi'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在以上的代码中，我们使用大括号以及冒号声明了一个字典：playsers，其中键为\"Messi\"、\"Xavi\"等等，其值分别为10、6等等。接着，使用players\\['Messi'\\]取得了键为'Messi'的值。另外也可以使用dict()进行创建："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Messi': 10, 'Xavi': 6, 'Iniesta': 8, 'Pique': 3}\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "players = dict(Messi=10, Xavi=6, Iniesta=8, Pique=3)\n",
    "print(players)\n",
    "print(players['Messi'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "与上面的结果一样。\n",
    "\n",
    "在循环语句中，可以使用通常的循环方法获得一个字典的keys："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Player:  Messi :  10\n",
      "Player:  Xavi :  6\n",
      "Player:  Iniesta :  8\n",
      "Player:  Pique :  3\n"
     ]
    }
   ],
   "source": [
    "for k in players:\n",
    "    print(\"Player: \", k, \": \", players[k])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在以上循环中，我们使用循环遍历了players中所有的键，并将其值打印了出来。\n",
    "\n",
    "此外，字典还支持如下操作：\n",
    "\n",
    "* len(players)：字典players的键-值对的个数\n",
    "* del players(k)：删除键k\n",
    "* k in players：判断字典players中是否有键k\n",
    "\n",
    "比如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Players中有 4 个球员\n",
      "{'Messi': 10, 'Xavi': 6, 'Iniesta': 8, 'Pique': 3}\n",
      "{'Messi': 10, 'Xavi': 6, 'Pique': 3}\n"
     ]
    }
   ],
   "source": [
    "print(\"Players中有\", len(players), \"个球员\")\n",
    "print(players)\n",
    "if \"Iniesta\" in players:\n",
    "    del players[\"Iniesta\"]\n",
    "print(players)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "此外，字典还提供了dict.keys()、dict.values()以及dict.items()等方法用于遍历键、值或者键值对："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Messi  -  10\n",
      "Xavi  -  6\n",
      "Pique  -  3\n"
     ]
    }
   ],
   "source": [
    "for p in players.keys():\n",
    "    print(p, \" - \", players[p])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 6, 3]"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(players.values())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Messi  -  10\n",
      "Xavi  -  6\n",
      "Pique  -  3\n"
     ]
    }
   ],
   "source": [
    "for p,n in players.items():\n",
    "    print(p, \" - \", n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python中的None\n",
    "\n",
    "在Python中还有一个非常特殊的类型：None，即什么都没有。注意None并不是空的元组、列表，也不是空的字符串，就是None："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "NoneType"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type('')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type([])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "由于None表示空的、没有，因而None跟其他任何数据类型比较都是返回False。\n",
    "\n",
    "如果要判断某个变量是否是None，可以使用is关键字："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "a = None\n",
    "b = []\n",
    "print(a is None)\n",
    "print(b is None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 小结\n",
    "\n",
    "最后，我们使用一个综合的例子，回顾一下目前未知所学的内容。\n",
    "\n",
    "在接下来的程序中，我们使用input()函数从用户的输入中得到数字，知道用户输入“end”为止，并将所有的数字相加。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "6\n",
      "100\n",
      "end\n",
      "110.0\n"
     ]
    }
   ],
   "source": [
    "summ = 0\n",
    "while True:\n",
    "    text = input(\"请输入一个数字，或者end结束：\")\n",
    "    print(text)\n",
    "    if text == \"end\":\n",
    "        break\n",
    "    summ += float(text)\n",
    "print(summ)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在以上的程序中，我们首先使用input()函数获得用户输入，接着判断用户输入的是否为\"end\"，如果是，则退出，否则，由于input()获得的是一个字符串，因而我们使用float()函数将该字符串转换为一个浮点数字，再将其相加。\n",
    "\n",
    "但是以上程序并不完美，比如，如果用户输入的不是“end”也不是数字，就会报错，因而一个更完善的版本是加入错误处理："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "8\n",
      "请输入数字或end！\n",
      "100\n",
      "112.0\n"
     ]
    }
   ],
   "source": [
    "summ = 0\n",
    "while True:\n",
    "    text = input(\"请输入一个数字，或者end结束：\")\n",
    "    if text == \"end\":\n",
    "        break\n",
    "    try:\n",
    "        summ += float(text)\n",
    "    except Exception as e:\n",
    "        print(\"请输入数字或end！\")\n",
    "        continue\n",
    "    else:\n",
    "        print(text)\n",
    "print(summ)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}