03.Lists_and_dictionaries.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. 动态类型(Dynamic typing)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在我们学习列表等其它类型之前，掌握 Python 语言中最基本的动态类型概念很重要。动态类型以及它提供的多态性，无疑是 Python 语言简洁性和灵活性的基础。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.1 缺少类型声明语句\n",
    "\n",
    "如果你有静态编译类型语言 C/C++ 或 Java 的背景，你也许会有些困惑。到现在为止，我们使用变量时，都没有声明变量的类型，但变量还可以工作。例如，当输入 a = 3 时，Python 怎么知道那代表了一个整数呢？在这种情况下，Python 怎么知道 a 是什么？\n",
    "\n",
    "你已经进入了 Python 动态类型模型的领域。当运行赋值语句 a = 3 时，即使没有告诉 Python 将 a 作为一个变量来使用，或者没有告诉它 a 应该作为一个整数类型对象，但一样也能工作。类型是在运行过程中自动决定的，而不是通过代码声明。这意味着没有必要事先声明变量。\n",
    "\n",
    "- 变量创建\n",
    "      一个变量名，就像 a，当代码第一次给它赋值时就创建了它。之后的赋值将会改变已创建的变量名的值。\n",
    "    \n",
    "- 变量类型\n",
    "      变量永远不会有任何的和它关联的类型信息或约束。类型的概念是存在于对象中而不是变量名中。变量原本是通用的，它只是在一个特定的时间点，简单地引用了一个特定的对象而已。\n",
    "      \n",
    "- 变量使用\n",
    "      当变量出现在表达式中时，它会马上被当前引用的对象所代替，无论这个对象是什么类型。此外，所有的变量必须在其使用前明确地赋值，使用未赋值的变量会产生错误。例如，必须把计数器变量初始化为 0，然后才能增加它。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "动态类型与传统语言的类型相比有明显的不同。当我们执行\n",
    "```\n",
    "a = 3\n",
    "```\n",
    "Python 会执行三个不同的步骤去完成这个请求：\n",
    "\n",
    "- 创建一个对象来代表数值3\n",
    "\n",
    "- 创建一个变量 a（如果它还没有被创建的话）\n",
    "\n",
    "- 将变量与新的对象 3 相连接。\n",
    "\n",
    "![assignment](images/chapter03/assignment.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在 Python 中从变量到对象的连接称作**引用**。引用是一种关系，以内存中的指针形式实现。一旦变量被使用，Python 自动追踪这个变量到对象的连接。\n",
    "\n",
    "- **变量**是一个系统表的元素，拥有指向对象的连接的空间。\n",
    "\n",
    "- **对象**是分配的一块内存，有足够的空间去表示它们所代表的值。\n",
    "\n",
    "- **引用**是自动形成的从变量到对象的指针。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.2 类型属于对象，而不是变量\n",
    "\n",
    "为了理解对象类型是如何使用的，先看对一个变量进行多次赋值后的结果："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 3                       # It's an integer\n",
    "a = 'spam'                  # Now it's a string\n",
    "a = 1.23                    # Now it's a floating point"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这个例子对于 C/C++ 程序员来说特别奇怪，因为变量 a 的类型发生了改变。\n",
    "\n",
    "事实并非如此。在 Python 中，情况很简单：变量名没有类型。我们没有改变变量 a 的类型，只是把 a 修改为对不同对象的引用。另一方面，对象知道自己的类型。每个对象都包含一个**头信息**，其中标记了这个对象的类型。例如，整数对象 3，包含了数值 3 以及一个头信息，用来告诉 Python 这是一个整数对象。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.3 垃圾收集\n",
    "\n",
    "我们把变量 a 赋值给了不同类型的对象，它前一个引用值发生了什么变化？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 3\n",
    "a = 'spam'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "答案是，之前的那个对象占用的空间就会被回收（如果它没有被其它的变量名或对象所引用的话）。这种自动回收对象空间的技术叫做**垃圾收集（GC, Garbage Collection）**。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在 Python 内部，它在每个对象中保持了一个计数器，计数器记录了当前指向该对象的引用的数目。一旦这个计数器被设置为零，这个对象的内容空间就会被自动回收。\n",
    "\n",
    "垃圾收集最直接的好处是：在脚本中任意使用对象而不需要考虑释放内存空间。在程序运行时，Python 会自动清理那些不再使用的空间。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.4 共享引用\n",
    "\n",
    "现在引入另一个变量，看一下变量名和对象的变化："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 3\n",
    "b = a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "实际的效果就是变量 a 和 b 都引用了相同的对象（也就是说，指向了相同的内存空间）。多个变量名引用了同一个对象，这在 Python 中叫做共享引用。\n",
    "![img](images/chapter03/shared_reference.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "下一步，假设运行第三行语句，设置变量 a 对新的字符串进行引用。尽管这样，这并不会改变 b 的值，b 仍然引用原始的对象——整数 3。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 3\n",
    "b = a\n",
    "a = 'spam'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最终的引用结构如图所示：\n",
    "![img](images/chapter03/shared_reference2.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "思考下面这三条语句："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 3\n",
    "b = a\n",
    "a = a + 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这里产生了同样的结果，最后的赋值将 a 设置为 5 的引用，而并不会产生改变了 b 的副作用。\n",
    "\n",
    "不像其它的语言，在 Python 中，变量总是一个指向对象的指针，而不是可改变的内存区域的标签：给一个变量赋一个新的值，并不是替换了原始对象，而是让这个变量去引用完全不同的另一个对象。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.5 共享引用和在原处修改\n",
    "\n",
    "先看个列表对象的示例："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "L1 = [2, 3, 4]\n",
    "L2 = L1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L1 是一个包含对象 2、3 和 4 的列表，所以 L1[0] 引用对象 2，它是列表 L1 中的第一个元素。在运行两个赋值后，L1 和 L2 引用了相同的对象，就像我们之前例子中的 a 和 b 一样。如果接下来我们去修改 L1 列表："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[24, 3, 4]\n",
      "[24, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "L1 = [2, 3, 4]              # A mutable object\n",
    "L2 = L1                     # Make a reference to the same object\n",
    "L1[0] = 24                  # An in-place change\n",
    "print(L1)\n",
    "print(L2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "改变了 L1 所引用的对象的一个元素，这个在原处的改变不仅仅会对 L1 有影响，也会对 L2 产生影响，因为 L2 与 L1 都引用了相同的对象。\n",
    "\n",
    "如果你不想要这样的现象发生，需要 Python 拷贝对象，而不是创建引用。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[24, 3, 4]\n",
      "[2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "L1 = [2, 3, 4]\n",
    "L2 = L1[:]                  # Make a copy of L1 (or list(L1), copy.copy(L1), etc.)\n",
    "L1[0] = 24\n",
    "print(L1)\n",
    "print(L2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这里，对 L1 的修改不会影响 L2，因为 L2 引用的是 L1 所引用对象的一个拷贝（两个变量指向不同的内存区域）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.6 共享引用和相等\n",
    "\n",
    "由于 Python 的引用模型，在 Python 程序中有两种不同的方法去检查是否相等。\n",
    "\n",
    "第一种是 **\"==\"** 操作符，**测试两个被引用对象是否有相同的值**。\n",
    "\n",
    "第二种是 **\"is\"** 操作符，**检查对象的同一性**。如果两个变量名精确指向同一个对象，它会返回 **True**，所以是更严格形式的相等测试。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = [1, 2, 3]\n",
    "M = L                       # M and L reference the same object\n",
    "L == M                      # Same values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L is M                      # Same objects"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "实际上，**is** 是代码中检测共享引用的一种方法。如果变量名引用值相等，但是是不同的对象，它的返回值是 **False**。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = [1, 2, 3]\n",
    "M = [1, 2, 3]\n",
    "L == M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L is M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "思考："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 3\n",
    "y = 3\n",
    "x is y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 10000\n",
    "y = 10000\n",
    "x is y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这是因为小的整数和字符串被缓存并复用了，所以 is 告诉我们 x 和 y 引用了一个相同的对象 3。\n",
    "\n",
    "你可以向 Python 查询一个对象引用的次数：在 sys 模块中的 getrefcount() 函数会返回对象的引用次数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2959"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import sys\n",
    "sys.getrefcount(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. 列表(List)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "列表是 Python 中最具有灵活性的**有序**集合对象类型。与字符串不同的是，列表可以包含任何种类的对象：数字、字符串甚至其它列表，并且列表属于可变对象。列表支持在原处修改的操作，可以通过指定的偏移值和分片、列表方法调用、删除语句等方法来实现。\n",
    "\n",
    "- 任意对象的有序集合\n",
    "      从功能上看，列表就是收集其它对象的地方。同事列表所包含的每一项都保持了从左到右的位置顺序（也就是说它们是序列）。\n",
    "\n",
    "- 通过偏移读取\n",
    "      就像字符串一样，你可以通过列表对象的偏移对其进行索引，从而读取对象的某一部分内容。由于列表的每一项都是有序的，那么你也可以执行诸如分片和合并之类的任务。\n",
    "      \n",
    "- 可变长度、异构以及任意嵌套\n",
    "      与字符串不同的是，列表是可变长度的，并且可以包含任意类型的对象（字符串只能包含单个字符）。\n",
    "      \n",
    "- 属于可变序列\n",
    "      列表支持在原处的修改，也可以响应所有针对字符串序列的操作，如索引、分片以及合并。列表支持字符串所不支持的序列操作，如删除和索引赋值操作，它们都是在原处修改列表。\n",
    "      \n",
    "- 对象引用数组\n",
    "      从技术上来讲，列表包含了零个或多个其他对象的引用。从 Python 列表中读取一个项的速度与索引一个 C 语言数组差不多。实际上，在标准 CPython 解释器内部，列表就是 C 数组实现的。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.1 基本操作\n",
    "\n",
    "列表是序列，它支持很多与字符串相同的操作。例如，列表对 **+** 和 * 操作的响应与字符串很相似，产生的结果是一个新的列表。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = []           # Empty list\n",
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = [1, 2, 3]\n",
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type([1, 2, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len([1, 2, 3])    # Length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1, 2, 3] + [4, 5, 6]    # Concatenation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[4, 5, 6] * 4    # Repetition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 in [1, 2, 3]    # Membership"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2 列表迭代和解析\n",
    "\n",
    "for 循环从左到右遍历序列中的每一项，对每一项执行一条或多条语句。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 "
     ]
    }
   ],
   "source": [
    "for x in [1, 2, 3]:    # Iteration\n",
    "    print(x, end=' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['SSSS', 'PPPP', 'AAAA', 'MMMM']"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res = [c * 4 for c in 'SPAM']    # List comprehensions\n",
    "res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['SSSS', 'PPPP', 'AAAA', 'MMMM']"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res = []\n",
    "for c in 'SPAM':    # List comprehension equivalent\n",
    "    res.append(c * 4)\n",
    "res"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.3 索引、分片和矩阵\n",
    "\n",
    "列表的索引和分片操作与字符串中的操作基本相同。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('SPAM!', ['Spam', 'SPAM!'], 'Spam')"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = ['spam', 'Spam', 'SPAM!']    # Offsets start at zero\n",
    "L[2], L[1:], L[-2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "由于列表是可变的，它们支持原处改变列表对象的操作。可以将一个特定项或整个片段来改变列表的内容。Python 中的索引赋值与 C 及大多数其它语言极为相似：用一个新值取代指定偏移的对象引用。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['spam', 'eggs', 'SPAM!']"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = ['spam', 'Spam', 'SPAM!']\n",
    "L[1] = 'eggs'\n",
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['eat', 'more', 'SPAM!']"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L[0:2] = ['eat', 'more']\n",
    "L"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以用嵌套列表来表示矩阵，下面一个基于列表的3x3的二维数组。如果使用一次索引，会得到一整行，如果使用两次索引，将会得到单个数值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 5, 6]\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
    "print(matrix[1])\n",
    "print(matrix[2][0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.4 列表方法\n",
    "\n",
    "Python 列表对象支持特定类型方法调用，其中很多方法可以在原处修改主体列表。\n",
    "\n",
    "最常用的方法是 **append()**，它能简单的将一个单项加至列表末端。与合并不同的是，append 将参数视作为单一对象而不是列表。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['eat', 'more', 'SPAM!', 'please']"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = ['eat', 'more', 'SPAM!']\n",
    "L.append('please')     # Append method call: add item at end\n",
    "L"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "另一个常见方法是 **sort()**，它原地(in-place)对列表按照默认递增顺序进行排序。可以手动指定 reverse 参数为True，使得按照降序进行排序。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['SPAM!', 'eat', 'more', 'please']"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L.sort()              # Sort list items ('S' < 'e')\n",
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['please', 'more', 'eat', 'SPAM!']\n"
     ]
    }
   ],
   "source": [
    "L.sort(reverse=True)\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "注意：append() 和 sort() 都是原处修改列表，两个函数的返回值都是 None："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "dummy = L.sort(reverse=True)\n",
    "print(dummy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "再看一些更多的列表方法："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = [1, 2]\n",
    "L.extend([3, 4, 5])    # extend 在列表末端插入多个元素\n",
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "[1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "print(L.pop())        # pop 弹出列表最后一个元素，可以与 append 方法联用，用来实现栈结构\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 3, 2, 1]"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L.reverse()           # reverse 原地反转列表\n",
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = ['spam', 'eggs', 'ham']\n",
    "L.index('eggs')       # Index of an object (search/find)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['spam', 'toast', 'eggs', 'ham']"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L.insert(1, 'toast')  # Insert at position\n",
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['spam', 'toast', 'ham']"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L.remove('eggs')      # Delete by value\n",
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'toast'"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L.pop(1)              # Delete by position"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['spam', 'ham']"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L.count('spam')      # Number of occurrences"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L.clear()            # 清空列表\n",
    "L"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. 字典(Dictionary)\n",
    "\n",
    "除了列表之外，字典也许是 Python 中最灵活的内置数据结构类型。如果把列表看作是有序的对象集合，那么就可以将字典当成是无序的集合。它们的主要差别在于：字典中的元素是通过键来存取的，而不是通过偏移存取。\n",
    "\n",
    "字典可以取代需要搜索算法和数据结构，而这些在较低级的语言如 C/C++ 中不得不通过手工来实现。对字典进行索引是非常快速的搜索操作。字典有时也能执行其他语言中的记录、符号表的功能，可以表示稀疏的数据结构等。\n",
    "\n",
    "- 通过键而不是偏移量来存取\n",
    "      字典有时也叫 hash 表，它们通过键将一系列值联系起来，采用键作为索引从字典中获取内容。\n",
    "\n",
    "- 任意对象的无序集合\n",
    "      与列表不同，保存在字典中的项没有特定的顺序。实际上，Python 将各项随机排序，以便快速查找。键提供了字典项的象征性位置，而非物理性的位置。\n",
    "\n",
    "- 可变长、异构、任意嵌套\n",
    "      与列表类似，字典可以在原处增长或是缩短。它可以包含任何类型的对象，而且支持任意深度的嵌套。\n",
    "      \n",
    "- 属于可变映射类型\n",
    "      通过给索引赋值，字典可以在原处修改，但不支持用于字符串和列表中的序列操作。实际上，因为字典是无序集合，所以根据固定顺序进行操作是行不通的。相反，字典是唯一内置的映射类型对象。\n",
    "      \n",
    "- 对象引用表\n",
    "      字典是使用 hash 表实现的，一开始所占空间很小，并根据要求而增长。Python 采用最优化的 hash 算法来寻找键，因此搜索是很快速的。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.1 字典的基本操作\n",
    "\n",
    "通常情况下，创建字典并且通过键来存储、访问其中的某项："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D = {'spam': 2, 'ham': 1, 'eggs': 3}     # Make a dictionary\n",
    "D['spam']                                # Fetch a value by key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'spam': 2, 'ham': 1, 'eggs': 3}"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在这里，字典被赋值给一个变量D，键 'spam' 的值为整数2。和利用偏移索引列表类似，字典用键对其进行索引操作，这也意味着用键来读取，而不是用位置来读取。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果需要动态地创建字典，可以先构造一个空字典，然后逐一赋值："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'Bob', 'age': 40}"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D2 = {} # Assign by keys dynamically\n",
    "D2['name'] = 'Bob'\n",
    "D2['age'] = 40\n",
    "D2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python 内置函数 **len()** 也可以用于字典，它能够返回存储在字典中的键值对数目。字典的 **in** 成员关系表达式提供了键存在与否的测试方法，**keys** 方法能够返回字典中所有的键，将它们收集在一个列表中。\n",
    "\n",
    "Python 2.x 中广泛使用的 has_key() 键存在测试方法已经在Python 3.x 中取消了，现在都应该用 **in** 表达式。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(D)                       # Number of entries in dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'ham' in D                  # Key membership test alternative\n",
    "# D.has_key('ham')          # Deprecated"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['spam', 'ham', 'eggs']"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(D.keys())               # Create a new list of D's keys"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.2 原处修改字典\n",
    "\n",
    "与列表相同，字典也是可变的，因此可以在原处对它们进行修改、扩展以及缩短而不需要生成新字典。简单地给一个键赋值就可以改变或者生成元素。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'spam': 2, 'ham': ['grill', 'bake', 'fry'], 'eggs': 3}"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D = {'spam': 2, 'ham': 1, 'eggs': 3}\n",
    "D['ham'] = ['grill', 'bake', 'fry']      # Change entry (value=list)\n",
    "D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'spam': 2, 'ham': ['grill', 'bake', 'fry']}"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del D['eggs']                           # Delete entry\n",
    "D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "与列表不同的是，每当新字典键进行赋值（之前没有被赋值的键），就会在字典内生成一个新的元素。如果想扩充列表，需要使用 append() 方法或分片赋值来实现。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'spam': 2, 'ham': ['grill', 'bake', 'fry'], 'brunch': 'Bacon'}"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D['brunch'] = 'Bacon'                  # Add new entry\n",
    "D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.3 其它字典方法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__class__',\n",
       " '__class_getitem__',\n",
       " '__contains__',\n",
       " '__delattr__',\n",
       " '__delitem__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__getitem__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__ior__',\n",
       " '__iter__',\n",
       " '__le__',\n",
       " '__len__',\n",
       " '__lt__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__or__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__reversed__',\n",
       " '__ror__',\n",
       " '__setattr__',\n",
       " '__setitem__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " 'clear',\n",
       " 'copy',\n",
       " 'fromkeys',\n",
       " 'get',\n",
       " 'items',\n",
       " 'keys',\n",
       " 'pop',\n",
       " 'popitem',\n",
       " 'setdefault',\n",
       " 'update',\n",
       " 'values']"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "字典 **values()** 和 **items()** 方法分别返回字典的值列表和 (key, value) 键值对。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 1, 3]"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D = {'spam': 2, 'ham': 1, 'eggs': 3}\n",
    "list(D.values())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('spam', 2), ('ham', 1), ('eggs', 3)]"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(D.items())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " **get()** 方法可以用来读取键值。读取不存在的键往往都会出错，但是使用 **get()** 方法能够返回默认值（None 或者用户定义的默认值）。这是在当键不存在时为了避免 missing-key 错误而填入默认值的一个简单方法："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D.get('spam')                      # A key that is there"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "print(D.get('toast'))              # A key that is missing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D.get('toast', 8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "字典的 **update()** 方法有点类似于合并，它把一个字典的键和值合并到另一个字典中，盲目的覆盖相同键的值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'spam': 2, 'ham': 1, 'eggs': 3, 'toast': 4, 'muffin': 5}"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D = {'spam': 2, 'ham': 1, 'eggs': 3}\n",
    "D2 = {'toast':4, 'muffin':5}     # Lots of delicious scrambled order here\n",
    "D.update(D2)\n",
    "D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "字典 **pop()** 方法能够从字典中删除一个键并返回它的值，类似于列表的 pop() 方法。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'spam': 2, 'ham': 1, 'eggs': 3, 'toast': 4, 'muffin': 5}"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D.pop('muffin')        # pop a dictionary by key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D.pop('toast')         # Delete and return from a key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'spam': 2, 'ham': 1, 'eggs': 3}"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['aa', 'bb', 'cc']\n",
      "['aa', 'cc']\n"
     ]
    }
   ],
   "source": [
    "# pop a list by position\n",
    "L = ['aa', 'bb', 'cc', 'dd']\n",
    "L.pop()               # Delete and return from the end\n",
    "print(L)\n",
    "L.pop(1)              # Delete from a specific position\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们可以使用 for 循环对字典进行遍历。下面的例子能够生成一个表格，把程序语言名称（键）映射到它们的作者（值）。可以通过语言名称索引来读取作者的名字："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python \t Guido van Rossum\n",
      "Perl \t Larry Wall\n",
      "Tcl \t John Ousterhout\n"
     ]
    }
   ],
   "source": [
    "table = {'Python' : 'Guido van Rossum',\n",
    "        'Perl':     'Larry Wall',\n",
    "        'Tcl':      'John Ousterhout'}\n",
    "for language in table:\n",
    "    print(language, '\\t', table[language])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.4 字典用法注意事项\n",
    "\n",
    "- 序列运算无效\n",
    "      字典元素之间没有顺序的概念，类似分片（提取相邻片段）的运算是不能用的。\n",
    "\n",
    "- 对新索引赋值会添加项\n",
    "     \n",
    "\n",
    "- 键不一定总是字符串\n",
    "      此前的例子中都是用字符串作为键，但任何不可变对象都是可以的。例如可以用整数作为键，这样字典看起来很像列表。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 使用字典模拟灵活的列表\n",
    "\n",
    "当使用列表时，对列表末尾外的偏移复制是非法的："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "L = []\n",
    "# L[99] = 'spam'            # 空列表使用偏移值非法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "spam\n",
      "{99: 'spam'}\n"
     ]
    }
   ],
   "source": [
    "D = {}\n",
    "D[99] = 'spam'\n",
    "print(D[99])\n",
    "print(D)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在这里，看起来似乎 D 是一个有100项的列表，但其实是一个由单个元素的字典。你可以像列表那样用偏移访问这一结构，但你不需要为将来可能会被赋值的位置提前分配空间。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 字典用于稀疏数据结构\n",
    "\n",
    "例如，多维数组中只有少数位置上有非零值："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{(2, 3, 4): 88, (7, 8, 9): 99}"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Matrix = {}\n",
    "Matrix[(2, 3, 4)] = 88\n",
    "Matrix[(7, 8, 9)] = 99\n",
    "Matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "88"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = 2; Y = 3; Z = 4                           # ; separates statements\n",
    "Matrix[(X, Y, Z)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 动态初始化字典\n",
    "\n",
    "**zip()** 函数可以将两个列表动态构建成一个字典，并通过 for 循环并行步进处理。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 1, 'b': 2, 'c': 3}"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D = dict(zip(['a', 'b', 'c'], [1, 2, 3]))      # Make a dict from zip result\n",
    "D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 1, 'b': 2, 'c': 3}"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D = {k: v for (k, v) in zip(['a', 'b', 'c'], [1, 2, 3])}\n",
    "D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 1, 2: 4, 3: 9, 4: 16}"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D = {x: x ** 2 for x in [1, 2, 3, 4]}         # Or: range(1, 5)\n",
    "D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'S': 'SSSS', 'P': 'PPPP', 'A': 'AAAA', 'M': 'MMMM'}"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D = {c: c * 4 for c in 'SPAM'} # Loop over any iterable\n",
    "D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 小结\n",
    "\n",
    "本章探讨了Python 程序中两种最常见、最具有灵活性、功能最强大的两种集合体类型——列表和字典。\n",
    "\n",
    "列表类型支持任意对象的以位置排序的集合体，而且可以任意嵌套，按需增长和缩短。\n",
    "\n",
    "字典类型也是如此，不过它是以键来存储元素而不是位置，并且不会保持元素之间的顺序关系。\n",
    "\n",
    "列表和字典都是可变的，所以它们支持各种不适用于字符串的原处修改操作。例如，列表可以通过 append() 方法来进行增长，而字典通过赋值给新键来实现增长。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 练习\n",
    "\n",
    "1. 举出两种方式来创建内含五个整数零的列表。\n",
    "\n",
    "2. 创建一个字典，有26个键从\"A\"到\"Z\"，每个键关联的值是从1到26。"
   ]
  }
 ],
 "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": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}