2023/python/1-python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "7173f1bf-a38f-4eb5-b5cd-f195f1e383c0",
   "metadata": {
    "tags": []
   },
   "source": [
    "# 数据科学语言 Python 入门到熟悉\n",
    "\n",
    "## 初识 Python\n",
    "\n",
    "\n",
    "- Python是一门广受欢迎的编程语言，其简洁、易读的语法使其成为编程入门的理想选择。对于非计算机背景的学习者，Python尤其友好。代码可读性强，易于理解他人的逻辑和编写清晰的代码。\n",
    "\n",
    "- Python提供了丰富的基础代码库，涵盖了网络、文件、GUI、数据库、文本等多个领域，被戏称为“内置电池（batteries included）”。这意味着在Python开发中，许多功能都可以直接使用现成的代码，而无需从零开始。此外，Python还拥有大量的第三方库，为开发者提供了更多便利。\n",
    "\n",
    "- 许多知名网站和公司，如YouTube、Instagram、Google、Yahoo等，以及NASA都广泛使用Python。在数据科学领域，Python更是占据绝对优势的地位。具有计算机科学背景的从业者在数据科学工作中经常使用Python。虽然在统计学领域，有些同学习惯使用R语言，但Python同样提供了强大的数据科学工具，使得从R迁移到Python变得轻松。\n",
    "\n",
    "### Python与大数据\n",
    "\n",
    "- 尽管大数据领域主要由Java、Scala等语言主导，但Python也在这个领域崭露头角。从早期的Hadoop生态中使用Python脚本完成Map-Reduce任务，到现在广泛使用的Spark，Python都提供了无缝衔接的接口。虽然Java等语言在大数据处理方面仍占主导地位，但Python在效率上与其他语言并无太大差异。\n",
    "\n",
    "\n",
    "### Python官方中文文档\n",
    "\n",
    "- 学习Python的最佳途径之一是阅读官方中文文档。它提供了全面的教程和参考资料，帮助学习者更好地理解Python的各个方面。详细内容请参阅官方[中文文档](https://docs.python.org/zh-cn/3.10/)。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e40d51cd-9e7b-4ef3-bca1-ac9602e021a2",
   "metadata": {},
   "source": [
    "### 获取帮助\n",
    "\n",
    "在学习Python过程中，获取帮助是非常重要的一部分。以下是几种获取帮助的方法：\n",
    "\n",
    "- 内置帮助函数 `help`：Python提供了内置的 `help()` 函数，可用于获取函数、模块和类的帮助信息。你可以在交互式解释器中使用 `help()` 函数，或在脚本中调用它来获取详细的帮助文档。\n",
    "\n",
    "- Jupyter Lab 中的快捷键 `Shift+TAB`：在Jupyter Lab（或 Notebook）中，你可以使用 `Shift+TAB` 组合键来获取有关函数、方法或模块的简要描述。按住Shift键并连续按两次TAB键，将会显示更详细的帮助信息。\n",
    "\n",
    "- `dir`函数：使用内置的 `dir()` 函数可以列出一个模块、类或对象的所有属性和方法。这有助于你了解可用的功能，并快速查找需要的信息。\n",
    "\n",
    "这些方法将有助于你更好地理解和使用Python中的各种功能。在学习和实践中，熟练使用这些获取帮助的方法对于编写高效的Python代码至关重要。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "1d7ea4ca-713b-4d10-8157-08ee045c79e1",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3626e3c6-e0c8-4744-a81d-ade0b1abf1d8",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "51c375ec-ab0d-4865-b3eb-81d095dfaad5",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "help(np.array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "362ec634-a083-4f05-9b9f-ed10806efd8a",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import datetime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "869ea092-67b9-448e-b806-253cef2a8b0f",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "help(datetime.date)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "dd7ae448-4526-4d06-ac16-6e850935173e",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total 2292\n",
      "-rw-r--r-- 1 root root   90385 Nov 29 11:36 1-python.ipynb\n",
      "-rw-r--r-- 1 root root     768 Nov 29 06:39 2-numpy_pandas.ipynb\n",
      "-rw-r--r-- 1 root root    5349 Nov 29 10:00 ShangHai.txt\n",
      "-rw-r--r-- 1 root root 1162059 Nov 29 10:00 python-cheatsheet1.png\n",
      "-rw-r--r-- 1 root root 1075965 Nov 29 10:00 python-cheatsheet2.png\n"
     ]
    }
   ],
   "source": [
    "!ls -l"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a532053-b7e5-4a62-b354-8446d8e3b678",
   "metadata": {},
   "source": [
    "## Python 基本数据类型: 变量，运算，表达式\n",
    "\n",
    "官方教程：https://docs.python.org/zh-cn/3.10/library/stdtypes.html\n",
    "\n",
    "- 基本数据类型：\n",
    "    \n",
    "    1. 整型 (int)： 整型是Python中表示整数的基本数据类型。它支持常见的整数运算，如加法、减法、乘法、除法等。在处理数学运算时，要注意清楚变量的数据精度，以避免精度丢失。\n",
    "    \n",
    "    2. 浮点型 (float)：浮点型用于表示带有小数点的数值。在Python中，浮点数支持各种数学运算，包括指数运算 (**)、取余数 (%) 等。在处理浮点数时，要注意处理舍入误差和精度问题。\n",
    "    \n",
    "    3. 字符串 (str)：字符串是一种文本序列类型，用于表示文本数据。Python中的字符串可以使用单引号 (') 或双引号 (\") 括起来。了解字符串的转义、拼接、重复、切片等操作是使用Python进行文本处理的基础。\n",
    "    \n",
    "    4. 布尔型 (bool)：布尔型只有两个取值，即 True 和 False。在条件判断和逻辑运算中，布尔型非常重要。\n",
    "    \n",
    "    5. type 函数：type 函数用于获取一个对象的类型。了解对象的类型有助于确保在处理数据时使用正确的方法和操作。\n",
    " \n",
    "-  数字类型操作\n",
    "\n",
    "    - 数字运算：Python作为计算器，支持常见的算术运算，包括加法 (+)、减法 (-)、乘法 (*)、除法 (/)、整除 (//)、取余 (%)、指数运算 (**) 等。\n",
    "\n",
    "\n",
    "- 字符串操作\n",
    "\n",
    "    - 字符串拼接和重复：使用 + 来拼接字符串，使用 * 来重复字符串。\n",
    "\n",
    "    - 字符串转义：了解字符串中特殊字符的转义，如换行符 (\\n)、制表符 (\\t) 等。\n",
    "\n",
    "    - 字符串切片：通过切片操作可以获取字符串中的子串，灵活运用切片有助于对文本数据的处理。\n",
    "\n",
    "    - 字符串常见操作：Python提供了丰富的字符串内置函数，包括查找子串、替换、大小写转换等操作，这些函数对文本处理非常实用。\n",
    "\n",
    "\n",
    "学习和掌握这些基本数据类型及其操作，是Python数据挖掘工具的基石，为进一步深入学习提供了坚实的基础。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "175f40a2-cb79-4171-b17b-c988236772b5",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aaee5ac2-7921-4778-9565-ea83c1322e9f",
   "metadata": {},
   "source": [
    "### 数据精度（整型 vs 浮点数）\n",
    "\n",
    "- 数字类型：`Int`、`Float`\n",
    "    - 数据精度\n",
    "    - Python 用作计算器 `+`、`-`、`*`、`/`、`//`、`%`、`**`、`()`、..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "e49ca3b2-2724-44ca-92eb-5976f3713b51",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "x = 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "dbaf551b-e2cd-4c5d-93c7-27c946fd0669",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "a7006bec-dab6-4f80-864c-9880bc6720f3",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "y = 3.1415926"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "8d420894-fd50-48da-a8cc-c2e75169eb1a",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "61a5b4df-9817-49fd-8ba1-1680add72ec8",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3db837be-77fd-48ae-a614-e88594eff6b5",
   "metadata": {},
   "source": [
    "- 浮点数在计算机硬件中是以基数为 2 (二进制) 的小数来表示的。 例如，十进制 小数 0.625 的值为 6/10 + 2/100 + 5/1000，而同样的 二进制 小数 0.101 的值为 1/2 + 0/4 + 1/8。 这两个小数具有相同的值，唯一的区别在于第一个写成了基数为 10 的小数形式，而第二个则写成的基数为 2 的小数形式。\n",
    "- 不幸的是，大多数的十进制小数都不能精确地表示为二进制小数。这导致在大多数情况下，你输入的十进制浮点数都只能近似地以二进制浮点数形式储存在计算机中。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "2ad87979-d185-44dc-8d0e-afa253af676b",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = 5\n",
    "a = b/1.0\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba666547-14b2-4edc-8eed-8b45e83ce692",
   "metadata": {},
   "source": [
    "浮点数在计算机硬件中表示为以 2 为基数（二进制）的小数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "4fa76198-b675-4fc9-b558-fa630ef83fea",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.3333333333333333 0.8571428571428571\n"
     ]
    }
   ],
   "source": [
    "print(1/3, 6/7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "e3e00b11-1bb6-4b8e-b475-969e19c9e6e8",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'3.14'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 想要更美观的输出，你可能会希望使用字符串格式化来产生限定长度的有效位数:\n",
    "import math\n",
    "format(math.pi, '.3g')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "f6461ee7-8aeb-46e8-87e9-d8be5331f38b",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0.333'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "format(1/3, '.3f')\n",
    "# 它是十进制下的一个近似值，结果是无论往后看多少的数字，它都永远不会等于 1/3 ，只是更加更加地接近 1/3 。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64d29b5e-95e2-4ffd-b518-c79059955ad3",
   "metadata": {
    "tags": []
   },
   "source": [
    "因此 Python 通过改为显示舍入值来保留可管理的数位。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "3e0a714f-500d-439f-8f6f-2389065c1026",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0.1000000000000000055511151'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 二进制浮点数的本质特性: 在所有支持浮点运算的语言中出现~\n",
    "format(.1, '.25f')\n",
    "\n",
    "# 牢记，即使输出的结果看起来好像就是 1/10 的精确值，实际储存的值只是最接近 1/10 的计算机可表示的二进制分数。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dfd90281-65e3-44e9-bccb-678b231b0b07",
   "metadata": {},
   "source": [
    "请注意这种情况是二进制浮点数的本质特性：它不是 Python 的错误，也不是你代码中的错误。 你会在所有支持你的硬件中的浮点运算的语言中发现同样的情况（虽然某些语言在默认状态或所有输出模块下都不会 显示 这种差异）。\n",
    "\n",
    "进一步，你就能理解：由于这个 0.1 并非真正的 1/10，将三个 0.1 的值相加也无法恰好得到 0.3:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "f45f1ac8-d700-416b-97c6-d1c9239fff45",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ".1 + .1 + .1 == .3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f33cd7d5-b5b3-4661-87f0-de0798954736",
   "metadata": {},
   "source": [
    "而且，由于这个 0.1 无法精确表示 1/10 而这个 0.3 也无法精确表示 3/10 的值，使用 `round()` 函数进行预先舍入也是没用的:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "85a3a245-90c7-4f12-aaae-f21b20cddfc8",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "round(.1,1) + round(.1,1) + round(.1,1) == round(.3,1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28646f2e-c8c8-4f7b-910d-22f3f788a899",
   "metadata": {},
   "source": [
    "可以使用 `round()` 函数来大致地比较近似程度:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "3a12896b-0927-4df6-aae7-d6c30106de38",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "round(.1 + .1 + .1, 10) == round(.3, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20ec1bef-1071-44a0-87e2-1a45aba7336d",
   "metadata": {},
   "source": [
    "> See more: [Floating Point Arithmetic: Issues and Limitations](https://docs.python.org/3.10/tutorial/floatingpoint.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45398901-d160-4ddf-ae08-9df32a8fda2e",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "73022d5a-5d83-4b74-a102-de1584ed1a7d",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(9, 5, 3.5, 3, 1, 49)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Python 用作计算器 +、-、*、/、//、%、**、()、...\n",
    "7+2, 7-2, 7/2, 7//2, 7%2, 7**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "fa6d9a11-a123-4dce-9481-f861ae75c06d",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 3\n",
    "x -= 3\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "77a068cc-009b-42b6-8e13-9f6798450c74",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "#  ** 比 - 有更高的优先级\n",
    "-7*2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d4acc2eb-4c06-4547-a95f-8669efec4595",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# （）用来分组\n",
    "(-7)**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "22132981-2b28-414c-8092-f127e21205d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 负数取余\n",
    "-12 % 5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0faeafbf-a73d-440c-963b-75e8a38e9ca8",
   "metadata": {},
   "source": [
    "Ref: [Python 中负数取余问题](https://zhuanlan.zhihu.com/p/342839024)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f746f92e-af7e-403f-aec4-c073f142431f",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5c9a8c8-e172-4bff-9e63-e1df7cc52037",
   "metadata": {},
   "source": [
    "### 玩转字符串\n",
    "\n",
    "- 文本序列类型：String\n",
    "    - `' '` 和 `\" \"` 的区别？\n",
    "    - 用 + 来拼接，用 `*` 来重复\n",
    "    - 字符串的转义\n",
    "    - 字符串序列的切片\n",
    "    - 关于 String 的常见buitin函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "9ece1d2f-c5c4-4f36-9e76-d7822eeb1c58",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('123', '123', \"'123'\", '\"123\"')"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ' ' 和 \" \" 的区别？\n",
    "'123', \"123\", \"'123'\", '\"123\"'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "87803eda-1419-46f9-b93c-0288ee4926ba",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'123' == \"123\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "770ba74f-e6e1-4b1c-8299-16a665db5279",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"'123'\" == '\"123\"'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "96ef20c2-a7ff-4e0b-9fde-3e66af600960",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z = 'GWData-Bootcamp'\n",
    "type(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "b713815f-f404-49f0-8a0b-931f702234ac",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "02db1243-594b-4fab-90ea-caeb3b6340c1",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = \"引力波数据探索：编程与分析实战训练营\"\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "e63c6ef4-b8c3-475d-bdea-c69b6d70290a",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = '''\n",
    "引力波数据探索\n",
    "：\n",
    "编程与分析实战\n",
    "训练营\n",
    "'''\n",
    "type(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "3a6a4840-7194-44af-a04c-e889fe845a44",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "引力波数据探索\n",
      "：\n",
      "编程与分析实战\n",
      "训练营\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "48917277-6d4a-4f36-9010-a69780b00b49",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\n引力波数据探索\\n：\\n编程与分析实战\\n训练营\\n'"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "287d04a0-e69e-48a2-8a36-73ba737eb895",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Hello World!', '喂~ 喂~ 喂~ 你好吗？')"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 用 + 来拼接，用 * 来重复\n",
    "\"Hello\" + \" World!\", \"喂~ \"*3 + \"你好吗？\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "451e95c3-cc71-40f4-b17d-4c599651377e",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "World!\tAgain!\n",
      "我是啊!\n"
     ]
    }
   ],
   "source": [
    "# 字符串的转义\n",
    "s = 'Hello\\nWorld!\\tAgain!\\n你好啊!\\r我是'\n",
    "print(s)\n",
    "# s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "12ef0d35-5f19-4d42-a2a1-ae3bd2c92240",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\\nWorld!\\tAgain!\\n你好啊!\\r我是\n"
     ]
    }
   ],
   "source": [
    "print(r'Hello\\nWorld!\\tAgain!\\n你好啊!\\r我是')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "8ca06495-bf28-462d-8221-4e960236ac01",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Hello', 'Hello\\n')"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 字符串序列的切片\n",
    "s[:5], s[:6]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aecb2f94-9780-4459-bcc5-4b593ea9f1a6",
   "metadata": {},
   "source": [
    "![](https://i.loli.net/2019/07/29/5d3ef50fea38853202.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "536e94e2-0d28-4e68-863b-597d0c93cec9",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Monty', 'Pyth', 'Monty', 'Pyth')"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S = 'Monty Python'  #左闭右开\n",
    "S[-12:-7], S[6:10], S[:-7], S[6:-2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "bbc7d6ed-040c-4838-a54a-9051a0094ad0",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Monty Python', ['Mon', 'ty ', 'Pyt', 'hon'])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Why like whis?\n",
    "S[:4] + S[4:], [S[3*i : 3*i+3] for i in range(4)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "cf8b73ed-a17e-4634-8c20-d3ab64faadbc",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Monty Python', 'MnyPto', 'oyyo', 'nohtyP ytnoM', '', 'hy t')"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S[::1], S[::2], S[1::3], S[::-1], S[1:-3:-2], S[-3:1:-2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "067e9425-07d9-4764-8d2e-83088241b477",
   "metadata": {},
   "source": [
    "> string_name[beginning: end : step]\n",
    "\n",
    "- **beginning** represents the starting index of string\n",
    "- **end** denotes the end index of string which is not inclusive \n",
    "- **steps** denotes the distance between the two words (steps are optional)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "c8fbd1ec-87c3-4c42-95de-55b3c1d85d18",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, True, True)"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# in, not in  -> O(n)\n",
    "'H' in 'Hello', 'He' in 'Hello', 'll' in 'Hello'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4bc56cc1-7de1-4f55-9d3d-38f07c22bf57",
   "metadata": {},
   "source": [
    "> - See more in [time complexity](https://wiki.python.org/moin/TimeComplexity) document for the complexity of several built-in types.\n",
    "> - PerformanceTips: https://wiki.python.org/moin/PythonSpeed/PerformanceTips"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "7df009dd-0dd8-46b0-a586-18760a4de51f",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# find\n",
    "'Hello'.find('H')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "62fd2d0a-3aa8-483a-a467-ecd3d8aaddd8",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HelloWorld\n"
     ]
    }
   ],
   "source": [
    "# join\n",
    "ex = ['H','e','l','l','o','W','o','r','l','d']\n",
    "\n",
    "ex_str = ''\n",
    "for i in ex:\n",
    "    ex_str += i\n",
    "print(ex_str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "e934766a-ebe7-41b8-bdb7-7b035898bf3b",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HelloWorld\n"
     ]
    }
   ],
   "source": [
    "ex_str = ''.join(ex)\n",
    "print(ex_str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "04c1fb51-4538-4c0f-a5e0-ea00bb7d22e2",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Hell', 'W', 'rld']"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# split (verse find...)\n",
    "ex_str.split('o')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "dd118800-7228-4e4b-88f2-8949b6b4273c",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2023-11-29 12:13:10.596323\n"
     ]
    }
   ],
   "source": [
    "import datetime\n",
    "time = str(datetime.datetime.today())\n",
    "print(time)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "96dfd67f-b1cd-4b25-9eac-6602e7cb2362",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'12'"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "time.split(' ')[-1].split(':')[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "f8929fd4-8843-4db7-9671-4225ea5dc5da",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# strip、lstrip、rstrip\n",
    "text = '   引力波数据探索：编程与分析实战训练营    '"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "180875c8-24bb-4f6b-b8ba-c0a99acf9c96",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "dir(str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "89803297-b3c5-4adf-9276-df929165c4e1",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "help(str.strip)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "c921fa3c-cb6e-48c2-bb1f-3860b7fc627a",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('ABCDABCD', 'abcdabcd', 'Abcd')"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# upper、lower\n",
    "'ABCDabcd'.upper(), 'ABCDabcd'.lower(), 'abcd'.capitalize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "4117ce83-81a6-480e-9a48-1f2973397525",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, False)"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'GWData-Bootcamp'.startswith('GW'), 'GWData-Bootcamp'.endswith('GW')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "51b30fad-c8da-4627-b53d-2c2ab9144135",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "某人说: 哎呦! 我去!\n",
      "某人说: 哎呦! 我去!\n"
     ]
    }
   ],
   "source": [
    "# format vs %\n",
    "print( '%s说: %s! %s!' %('某人', '哎呦', '我去') ) \n",
    "print( '{}说: {}! {}!'.format('某人', '哎呦', '我去') ) # Python 2.6 introduced"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "09966808-81a2-4f8c-98f2-520d3fa1d835",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Hello]        |1024.00\n",
      "[World]        |1024.00\n",
      "[CEO]          |1024.00\n",
      "[ILOVECHINA]   |1024.00\n"
     ]
    }
   ],
   "source": [
    "# more example for format\n",
    "for name in ['Hello', 'World', 'CEO', 'ILOVECHINA']:\n",
    "    print('{name:<{len}}|{num:.2f}'.format(name='['+name+']',len=15, num=1024))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "3691f552-31a7-403b-a191-32089aa36474",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "' 12345678 YES votes  22.25%'"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "yes_votes = 12_345_678\n",
    "no_votes = 43_132_495\n",
    "percentage = yes_votes / (yes_votes + no_votes)\n",
    "'{:9} YES votes  {:2.2%}'.format(yes_votes, percentage)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "2d8fefa8-73cb-461d-9fa6-b1f613c8c807",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "' 12345678 YES votes  22.25%'"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f'{yes_votes:9} YES votes  {percentage:2.2%}'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59d10239-e4d5-4420-b4ec-7ee9dbef4e18",
   "metadata": {},
   "source": [
    "- [Python string formatting: is '%' more efficient than 'format' function?](https://stackoverflow.com/questions/40714555/python-string-formatting-is-more-efficient-than-format-function)\n",
    "\n",
    "- f-Strings     (Python 3.6 introduced) [Ref](https://realpython.com/python-f-strings/)\n",
    "- https://docs.python.org/3.10/tutorial/inputoutput.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "1cadfdbd-c8c0-4894-936b-40ac94be0ecc",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sjoe       ==>       4127\n",
      "Jack       ==>       4098\n",
      "Dcab       ==>       7678\n"
     ]
    }
   ],
   "source": [
    "table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}\n",
    "for name, phone in table.items():\n",
    "    print(f'{name:10.4s} ==> {phone:10d}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7017b6a0-d7a4-4e24-8464-17082674f1e5",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a078a465-baeb-45ef-b73e-168709edb504",
   "metadata": {},
   "source": [
    "### 可变对象 vs 不可变对象 (序列类型 or 容器)\n",
    "\n",
    "- 序列类型：可任何类型元素的序列结构\n",
    "    - 注意：留意嵌套的列表表示矩阵\n",
    "- 序列类型：用 + 来拼接，用 * 来重复\n",
    "- 关于 List 的常见的方法：len, append, extend, sort, pop, count, index, copy\n",
    "- 关于 List 的赋值内涵：\n",
    "    - https://www.runoob.com/w3cnote/python-understanding-dict-copy-shallow-or-deep.html\n",
    "    - https://www.jianshu.com/p/efa9dd51f5cc\n",
    "- List 和 Tuple 有啥区别？逗号的区别！\n",
    "    - 外观上看是()和逗号的区别：`()`  'hello', 元组打包 ；元组中的一个单独的元素赋值是不允许的;\n",
    "- Set 是由不重复元素组成的无序的集：爱做逻辑运算\n",
    "    - | & ^ unique"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "3c34609f-4727-438d-9cc9-0a1a4d7d6f9c",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 2, 3], [4, 5, 6]]"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 列表\n",
    "[1,2,3,4,5]\n",
    "['Hello', 45, 1.5]\n",
    "\n",
    "[\n",
    "    [\n",
    "        1, 2, 3\n",
    "    ],\n",
    "    [\n",
    "        4, 5, 6\n",
    "    ]\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "d7ba5481-bef9-4085-a640-e3348734b10f",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1] + [1] + [1]\n",
    "[1]*10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "ab594d3c-482d-417e-8ace-6fb33efffaf4",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "ex = ['引力波数据探索', 2, 3.1415926, True, ['LiLei', 'HanMeimei']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "e45a09f6-cfcb-417b-b8d6-f166e8e9ee2c",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['LiLei', 'HanMeimei']"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ex[4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "05f1c1b1-e196-4462-9445-66ff29a2de29",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'HanMeimei'"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ex[4][1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "c6e9c12a-4516-4a71-969d-0b1c9e075eff",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 列表长度\n",
    "# len\n",
    "len(ex)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f1021ccd-700c-4e21-93ac-20aeb920e238",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "dir(list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "id": "9dc29c9d-ee1b-48b4-9660-cb91c7febaad",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['引力波数据探索',\n",
       " 2,\n",
       " 3.1415926,\n",
       " True,\n",
       " ['LiLei', 'HanMeimei'],\n",
       " 'append',\n",
       " 'extend',\n",
       " 'extend1',\n",
       " 'extestset',\n",
       " ['append']]"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# append vs extend\n",
    "ex.append(['append'])\n",
    "ex"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "id": "8422e23c-5cc8-4b2e-b76b-9a4086798c3c",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['引力波数据探索',\n",
       " 2,\n",
       " 3.1415926,\n",
       " True,\n",
       " ['LiLei', 'HanMeimei'],\n",
       " 'append',\n",
       " 'extend',\n",
       " 'extend1',\n",
       " 'extestset']"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ex.extend(['extend1', 'extestset'])\n",
    "ex"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "id": "78d206cf-ab15-4e5f-81b6-2f602a7fcf2a",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# sort, reverse, pop, count, index\n",
    "ex = [5,45,7,567,45, 35, 67, 7, 45,]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "514e961c-0a79-4610-9330-b79eb4f1e2b2",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 45, 7, 567, 45, 35, 67, 7, 45]"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# copy\n",
    "a = ex # + [100]\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "id": "4f7962db-d3a0-4983-ad60-afd696aa70b6",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "a[1] = -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "id": "206d328f-f21d-4576-979a-567ede09e397",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, -1, 7, 567, 45, 35, 67, 7, 45]"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "id": "1ffc1b47-f920-4f0b-a137-1610e8de5320",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, -1, 7, 567, 45, 35, 67, 7, 45]"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ex"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "id": "0243ae5c-ff1d-4297-b39f-57c2a618ec99",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "a = ex.copy()\n",
    "a[0] = -2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "id": "a4bb34c1-4164-4fcf-82a9-698d8bb2573b",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-2, -1, 7, 567, 45, 35, 67, 7, 45]"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "id": "6d6e1434-75c1-4755-b1b9-9c5223c2c5bd",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, -1, 7, 567, 45, 35, 67, 7, 45]"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ex"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9e81745-550f-4d43-b04f-edc4b0e2879e",
   "metadata": {},
   "source": [
    "- 关于 List 的赋值内涵：\n",
    "\n",
    "    - 直接赋值：其实就是对象的引用（别名）。\n",
    "    - 浅拷贝(copy)：拷贝父对象，不会拷贝对象的内部的子对象。\n",
    "    - 深拷贝(deepcopy)： copy 模块的 deepcopy 方法，完全拷贝了父对象及其子对象。\n",
    "    \n",
    "\n",
    "1. `b = a`: 赋值引用，a 和 b 都指向同一个对象。\n",
    "![](https://i.loli.net/2019/07/30/5d3fd8f9f3e6652963.png)\n",
    "\n",
    "2. `b = a.copy()`: 浅拷贝, a 和 b 是一个独立的对象，但他们的子对象还是指向统一对象（是引用）。\n",
    "![](https://i.loli.net/2019/07/30/5d3fd90f57acb43568.png)\n",
    "\n",
    "3. `b = copy.deepcopy(a)`: 深度拷贝, a 和 b 完全拷贝了父对象及其子对象，两者是完全独立的。\n",
    "![](https://i.loli.net/2019/07/30/5d3fd928e23f883201.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "id": "47a6b636-518d-4ea6-a0cc-1a063719d118",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([1, 2, 3, 4, ['a', 'b']],\n",
       " [1, 2, 3, 4, ['a', 'b']],\n",
       " [1, 2, 3, 4, ['a', 'b']],\n",
       " [1, 2, 3, 4, ['a', 'b']],\n",
       " [1, 2, 3, 4, ['a', 'b']],\n",
       " [1, 2, 3, 4, ['a', 'b'], 'GW'])"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import copy\n",
    "a = [1, 2, 3, 4, ['a', 'b']]\n",
    "b = a                   # 直接赋值\n",
    "c = a.copy()            # 浅拷贝 (also copy.copy())\n",
    "d = copy.deepcopy(a)    # 深拷贝\n",
    "e = a[:]                # 切片赋值??\n",
    "f = a + ['GW']          # ??\n",
    "\n",
    "a, b, c, d, e, f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "id": "d8142868-aa5f-4798-b518-2c335d015d9c",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "a.append(5) # 改变对象\n",
    "a[4].append('c') # 改变子对象"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "id": "72eae895-a8a9-496a-a4f7-53300d17ce7b",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([1, 2, 3, 4, ['a', 'b', 'c'], 5], 140559575716608)"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a, id(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "id": "d4cf3930-bd3d-4772-a389-f3b67e07125a",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([1, 2, 3, 4, ['a', 'b', 'c'], 5], 140559575716608)"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b, id(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "id": "b7cccc2b-a35c-49bb-84c8-d61726b4b4f2",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([1, 2, 3, 4, ['a', 'b', 'c']], 140559577073920)"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c, id(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "id": "92fb81d8-8c78-446d-a863-5309918f920c",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([1, 2, 3, 4, ['a', 'b']], 140559725761088)"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d, id(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "id": "007f4d14-8989-497c-94ee-d57985f68e70",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([1, 2, 3, 4, ['a', 'b', 'c']], 140559727218624)"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "e, id(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "id": "cb07bc9e-c1ef-4332-9383-1a72528f0eb8",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([1, 2, 3, 4, ['a', 'b', 'c'], 'GW'], 140559575719552)"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f, id(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "61829deb-edc4-4eb7-a9c3-d34f32496bf3",
   "metadata": {},
   "source": [
    "> 到底会不会变，好麻烦，咋记？一般怎么用呢？\n",
    "\n",
    "- Python 中的 可变对象 vs 不可变对象：\n",
    "\n",
    "    - 不可变对象，该对象所指向的内存中的值不能被改变。当改变某个变量时候，由于其所指的值不能被改变，相当于把原来的值复制一份后再改变，这会开辟一个新的地址，变量再指向这个新的地址。\n",
    "        - **数值类型（int和float）、字符串str、元组tuple**\n",
    "    - 可变对象，该对象所指向的内存中的值可以被改变。变量（准确的说是引用）改变后，实际上是其所指的值直接发生改变，并没有发生复制行为，也没有开辟新的出地址，通俗点说就是原地改变。\n",
    "        - **列表list、字典dict、集合set** \n",
    "        \n",
    "- Tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "id": "f71d4167-b775-4dac-ac2d-dc942e19ee12",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([1, 2, 3, 4, 1], [1, 2, 3, 4, 1])"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# list\n",
    "a = [1,2,3,4]\n",
    "b = a\n",
    "a += [1]\n",
    "a, b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "id": "7e9d0171-4ad5-49a3-a43d-2dab6deb9250",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((1, 2, 3, 4, 1), (1, 2, 3, 4))"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# tuple\n",
    "a = (1,2,3,4)\n",
    "b = a\n",
    "a += (1,)\n",
    "a, b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "id": "4d00d7e0-459c-45ff-8309-172aec7a44d1",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 4, 5)"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def test(x):\n",
    "    return x, x+1, x+2\n",
    "\n",
    "test(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "id": "4ca6d837-a619-4948-9c88-8cfb540220c3",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1,)"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "id": "4336a471-d931-453c-b67b-a40d4c921e63",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34efcb2e-9dea-4b6e-8fc8-d581c4e03177",
   "metadata": {},
   "source": [
    "- Set 是由不重复元素组成的无序的集：爱做逻辑运算"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "id": "04fc88f0-184d-495e-94e1-1edccb19bb3c",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "({1, 2, 3, 4}, {2, 3, 4, 5})"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set1 = [1,2,2,3,4]\n",
    "set2 = [4,2,3,4,5]\n",
    "\n",
    "set(set1), set(set2)  # unique elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "id": "0129e9f7-1d1e-4fc5-b95d-85cdb28d1cf0",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "({2, 3, 4}, {1, 2, 3, 4, 5}, {1, 5}, {1})"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set(set1) & set(set2), set(set1) | set(set2), set(set1) ^ set(set2), set(set1) - set(set2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce10e9e0-4fd6-4a8f-b9f6-9a6eb22912ed",
   "metadata": {},
   "source": [
    "- Dict\n",
    "    - key-value （键-值）\n",
    "    - key 是唯一的\n",
    "    - Dict 的属性和方法: `in, not in, keys, values, items, setdefault`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "id": "c032a797-b0ce-48fe-8fb9-a682cde408e4",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Num1': [1, 2, 3, 4, 5],\n",
       " 666: '引力波数据探索',\n",
       " 'DICT1': {'编程与分析': 22, '实战训练营': 88},\n",
       " 'DICT2': 100}"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dd = {\n",
    "    'Num1': [1,2,3,4,5],\n",
    "    666: '引力波数据探索',\n",
    "    'DICT1': {'编程与分析': 22, '实战训练营': 88},\n",
    "    'DICT2': 90\n",
    "}\n",
    "\n",
    "# dd['Num1']\n",
    "# dd[666]\n",
    "# dd['DICT1']\n",
    "dd['DICT2'] = 100\n",
    "dd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "id": "8eb24730-6f67-49b7-8405-24cdb8bb36b2",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, False)"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# in, not in\n",
    "666 in dd, '引力波数据探索' in dd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "id": "f42dbde0-77f5-41ea-ba2b-d59ed092ecc3",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values([[1, 2, 3, 4, 5], '引力波数据探索', {'编程与分析': 22, '实战训练营': 88}, 100])"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# dd.keys()\n",
    "dd.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "id": "e0505228-48f8-4d69-8797-ebda4b00ee15",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 Num1 [1, 2, 3, 4, 5]\n",
      "1 666 引力波数据探索\n",
      "2 DICT1 {'编程与分析': 22, '实战训练营': 88}\n",
      "3 DICT2 100\n"
     ]
    }
   ],
   "source": [
    "dd.items()\n",
    "\n",
    "for index, (key, value) in enumerate(dd.items()):\n",
    "    print(index, key, value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "id": "ee718d7d-f979-4e63-8ab2-f21f431c4192",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "200"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dd.setdefault('DICT3', 200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "id": "1c60c63f-2a9a-48a6-ba30-90057577e654",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Num1': [1, 2, 3, 4, 5],\n",
       " 666: '引力波数据探索',\n",
       " 'DICT1': {'编程与分析': 22, '实战训练营': 88},\n",
       " 'DICT2': 100,\n",
       " 'DICT3': 200}"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "id": "33c565df-1ee1-48b1-a632-51d64bf2acac",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Num1': [1, 2, 3, 4, 5],\n",
       " 666: '引力波数据探索',\n",
       " 'DICT1': {'编程与分析': 22, '实战训练营': 88},\n",
       " 'DICT2': 100,\n",
       " 'DICT3': 200,\n",
       " 'ICTP': 123}"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 多个字典的快速合并\n",
    "{\n",
    "    **dd,\n",
    "    **{'ICTP': 123}\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa782cc7-aabb-4442-b1b7-29ab2ab3a7cb",
   "metadata": {},
   "source": [
    "### List comprehensions\n",
    "\n",
    "- 官方教程：https://docs.python.org/3.10/tutorial/datastructures.html#list-comprehensions\n",
    "- [When to Use a List Comprehension in Python](https://realpython.com/list-comprehension-python/)\n",
    "\n",
    "列表推导式（List comprehensions）是一种用简洁而灵活的语法创建列表的方法。它允许你通过在一行代码中描述操作，生成新的序列。\n",
    "\n",
    "- 优点：\n",
    "    - 简洁： 列表推导式提供了一种简洁而清晰的语法，使得在一行代码中完成复杂的列表生成操作成为可能。\n",
    "    - 可读性： 对于简单的转换和筛选操作，列表推导式通常比传统的循环和条件语句更易读。\n",
    "    - 高效： 在某些情况下，列表推导式可以比传统的循环更高效，因为它们在底层使用了更快的迭代机制。\n",
    "    - 功能强大： 支持多层嵌套、条件筛选等复杂操作，使得生成各种形式的列表变得灵活而强大。\n",
    "\n",
    "- 缺点：\n",
    "    - 可读性下降： 对于复杂的列表推导式，可读性可能下降，使得代码难以理解，降低了维护性。\n",
    "    - 不适用于复杂逻辑： 当列表生成的逻辑较为复杂时，使用传统的循环和条件语句可能更为直观，不容易出错。\n",
    "    - 不利于调试： 列表推导式一般在一行内完成，当出现错误时，定位问题可能相对困难。\n",
    "    - 可能影响性能： 在某些情况下，列表推导式可能会导致性能下降，特别是对于大规模数据集的处理。\n",
    "\n",
    "- 注意事项：\n",
    "    - 保持可读性： 尽管列表推导式简洁，但在编写时应注意保持可读性，避免嵌套层次过深或逻辑过于复杂。\n",
    "    - 适度使用： 在简单的转换和筛选操作中使用列表推导式是合适的，但对于复杂逻辑，还是应该使用传统的循环和条件语句。\n",
    "    - 避免滥用： 不要滥用列表推导式，以免影响代码的可维护性和可读性。\n",
    "    - 考虑生成器表达式： 如果可能会处理大规模数据集，考虑使用生成器表达式而不是列表推导式，以降低内存占用。\n",
    "    - 列表推导式本身并没有并行性，它是在单线程中按顺序执行的。每个元素的计算都依赖于前一个元素的结果。虽然在某些情况下，列表推导式可能比传统的循环更高效，但它并不能实现真正的并行性。\n",
    "\n",
    "列表推导式是一种强大而灵活的工具，但在使用时需要谨慎，根据具体情况选择合适的编程方式，以达到代码简洁、可读、高效的平衡。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "id": "e32fa4aa-3073-48ed-8da9-aca25f387ff8",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 170,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squares = []\n",
    "for x in range(10):\n",
    "    squares.append(x**2)\n",
    "squares"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "id": "aafebcb1-ebf0-46ef-b913-9ceab54ecece",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 171,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squares = list(map(lambda x: x**2, range(10)))\n",
    "squares"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "id": "b8e39d9a-bf54-4ac6-9aa4-3947fbacccd3",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squares = [x**2 for x in range(10)]\n",
    "squares"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b3b453f-454e-496a-9be1-d8007f7f70a4",
   "metadata": {
    "tags": []
   },
   "source": [
    "![](https://i.loli.net/2019/07/30/5d3fe7e04a01381804.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "id": "114665d1-91d6-4783-97da-7366274efd24",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 4, 16, 36, 64]"
      ]
     },
     "execution_count": 174,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squares = []\n",
    "for i in range(10):\n",
    "    if i % 2 == 0 :\n",
    "        squares.append(i**2)\n",
    "squares"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "id": "6ea4c5ff-5f96-4af6-b692-301ca95cd43a",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 4, 16, 36, 64]"
      ]
     },
     "execution_count": 175,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squares = [i**2 for i in range(10) if i % 2 == 0]\n",
    "squares"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10c055de-2116-4b8f-918c-168b522fc8aa",
   "metadata": {
    "tags": []
   },
   "source": [
    "![](https://i.loli.net/2019/07/30/5d3fe8418b72256876.png)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "id": "ee34c33d-8606-41c3-85db-10cf4d5bd45f",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Num1': [1, 2, 3, 4, 5],\n",
       " 666: '引力波数据探索',\n",
       " 'DICT1': {'编程与分析': 22, '实战训练营': 88},\n",
       " 'DICT2': 100,\n",
       " 'DICT3': 200}"
      ]
     },
     "execution_count": 176,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "id": "6b67d5fd-63f0-4141-8098-dd3395e417b2",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['DICT1']"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[key for key, value in dd.items() if type(value) == dict ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "id": "abdecb62-dc0e-4698-9a44-ccd647c39390",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['编程与分析', '实战训练营']"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[key for _, value in dd.items()\n",
    " if type(value) == dict\n",
    " for key, _ in value.items() ]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e568294b-85f3-49c7-b52f-6985a64a9f52",
   "metadata": {},
   "source": [
    "![](https://i.loli.net/2019/07/30/5d3fe87e488ac69861.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "id": "d7716a8b-91f8-4a01-891e-083d92253778",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Not 实战', '实战训练营']"
      ]
     },
     "execution_count": 179,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[key if '实战' in key else 'Not 实战' for _, value in dd.items() if type(value) == dict for key, _ in value.items() ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "id": "81a1f486-5470-431a-8e82-1a17d0a71a39",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'编程与分析': 'Not 实战', '实战训练营': '实战训练营'}"
      ]
     },
     "execution_count": 180,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Not only list....\n",
    "# 字典推导和列表推导的使用方法是类似的，只不中括号该改成大括号。直接举例说明\n",
    "\n",
    "{key: key if '实战' in key else 'Not 实战' for _, value in dd.items() if type(value) == dict for key, _ in value.items() }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "id": "89507288-40ac-4332-a823-884b4445ca71",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{10: 'a', 34: 'b'}\n"
     ]
    }
   ],
   "source": [
    "# 快速更换key和value\n",
    "mcase = {'a': 10, 'b': 34}\n",
    "mcase_frequency = {v: k for k, v in mcase.items()}\n",
    "print (mcase_frequency)\n",
    "#  Output: {10: 'a', 34: 'b'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "id": "bd41f77b-288a-4e6f-b5f1-17ef0a18c969",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n"
     ]
    }
   ],
   "source": [
    "# 生成器推导式\n",
    "\n",
    "multiples_2 = (i for i in range(30) if i % 3 == 0)\n",
    "print(type(multiples_2))\n",
    "#  Output: <type 'generator'>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb4642fa-c654-43a3-a69d-764c01a2784b",
   "metadata": {},
   "source": [
    "- **生成器** 是做什么用的？请参考： https://www.cnblogs.com/MnCu8261/p/6410594.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "id": "7902d21a-78b1-4c17-af81-a990aecab1e2",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 4}\n"
     ]
    }
   ],
   "source": [
    "# 集合推导式\n",
    "# 它们跟列表推导式也是类似的。 唯一的区别在于它使用大括号{}\n",
    "\n",
    "squared = {x**2 for x in [1, 1, 2]}\n",
    "print(squared)\n",
    "# Output: set([1, 4])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a798c4a9-69da-4ce1-87e8-3056300cd212",
   "metadata": {},
   "source": [
    "- One-lined Python:  https://wiki.python.org/moin/Powerful%20Python%20One-Liners\n",
    "    - List Comprehensions\n",
    "    - lambda (map、filter、reduce)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "111b4d9a-42d9-46c7-80cc-d5d688787ca2",
   "metadata": {},
   "source": [
    "## Python 流程控制与异常处理"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe709e16-02ba-487e-93a1-bf41a2d66fd3",
   "metadata": {},
   "source": [
    "- 官方教程：https://docs.python.org/3.10/tutorial/controlflow.html\n",
    "\n",
    "![case](https://vip2.loli.io/2023/11/25/zDPA92mlxTJeRO7.jpg)\n",
    "\n",
    "---\n",
    "- `continue`\n",
    "\n",
    "    ```python\n",
    "    for num in range(2, 10):\n",
    "        if num % 2 == 0:\n",
    "            print('Found an even number', num)\n",
    "            continue\n",
    "    print('Found a number', num)\n",
    "    ```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "id": "c0861435-2d41-4fd5-88b1-5f84207071de",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found an even number 2\n",
      "Found an even number 4\n",
      "Found an even number 6\n",
      "Found an even number 8\n",
      "Found a number 9\n"
     ]
    }
   ],
   "source": [
    "for num in range(2, 10):\n",
    "    if num % 2 == 0:\n",
    "        print('Found an even number', num)\n",
    "        continue\n",
    "print('Found a number', num)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5a87e68-8a1e-49d9-8f28-8dfac663ed5c",
   "metadata": {},
   "source": [
    "---\n",
    "- `break` and  `for ... else ...`\n",
    "\n",
    "```python\n",
    "for n in range(2, 10):\n",
    "    for x in range(2, n):\n",
    "        if n % x == 0:\n",
    "            print(n, 'equals', x, '*', n//x)\n",
    "            break\n",
    "    else:\n",
    "        # loop fell through without finding a factor\n",
    "        print(n, 'is a prime number')\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "id": "e0853b49-cb70-465d-b803-675cdd75a284",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 is a prime number\n",
      "3 is a prime number\n",
      "4 equals 2 * 2\n",
      "5 is a prime number\n",
      "6 equals 2 * 3\n",
      "7 is a prime number\n",
      "8 equals 2 * 4\n",
      "9 equals 3 * 3\n"
     ]
    }
   ],
   "source": [
    "for n in range(2, 10):\n",
    "    for x in range(2, n):\n",
    "        if n % x == 0:\n",
    "            print(n, 'equals', x, '*', n//x)\n",
    "            break\n",
    "    else:\n",
    "        # loop fell through without finding a factor\n",
    "        print(n, 'is a prime number')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e122906-654c-46f2-b1ac-e7261ec05b8a",
   "metadata": {},
   "source": [
    "- `break` 和 `else` 是两个互斥的条件：只有当循环里没有遇到 `break` 时，`else` 块才会在循环结束后执行。\n",
    "\n",
    "```python\n",
    "for i in mylist:\n",
    "    if i == target:\n",
    "        break\n",
    "    process(i)\n",
    "else:\n",
    "    raise ValueError(\"List argument missing terminal flag.\")\n",
    "```\n",
    "- Compare this to a method that does not use this syntactic sugar:\n",
    "    \n",
    "    ```python\n",
    "    flagfound = False\n",
    "    for i in mylist:\n",
    "        if i == theflag:\n",
    "            flagfound = True\n",
    "            break\n",
    "        process(i)\n",
    "    \n",
    "    if not flagfound:\n",
    "        raise ValueError(\"List argument missing terminal flag.\")\n",
    "    # 所以无需专门建立一个临时标记变量来标记是否找到了 target\n",
    "    # Source: https://stackoverflow.com/a/9980752/8656360\n",
    "    ```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eadaa743-3003-4ad4-b7a6-1e5846ca53cd",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "- `while/for ... try ... except ...`\n",
    "\n",
    "```python\n",
    "while True:\n",
    "    try:\n",
    "        x = int(input(\"Please enter a number:\"))\n",
    "        break  # Don't forget stop the Loop!\n",
    "    except ValueError:\n",
    "        print(\"Oops! That was no valid number. Try again...\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46dab1bf-5dc9-4689-9b32-61fd24f29235",
   "metadata": {},
   "source": [
    "\n",
    "- `try ... except ... (else) ... (finally) ...`\n",
    "\n",
    "```python\n",
    "def divide(x, y):\n",
    "    try:\n",
    "        result = x / y\n",
    "    except ZeroDivisionError:\n",
    "        print(\"division by zero!\")\n",
    "    else:\n",
    "        print(\"result is\", result)\n",
    "    finally:\n",
    "        print(\"executing finally clause\")\n",
    "\n",
    ">>> divide(2, 1)\n",
    ">>> divide(2, 0)\n",
    ">>> divide(\"2\", \"1\")\n",
    "```\n",
    "\n",
    "- `except` 可以写多个。\n",
    "- `else` 和 `Error` 是互斥的； `finally` 是跟屁虫，总少不了(执行)它。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "id": "f1eabd30-b306-4546-8356-5efb421858da",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def divide(x, y):\n",
    "    try:\n",
    "        result = x / y\n",
    "    except ZeroDivisionError:\n",
    "        print(\"division by zero!\")\n",
    "    except TypeError:\n",
    "        print('TypeError')\n",
    "    else:\n",
    "        print(\"result is\", result)\n",
    "    finally:\n",
    "        print(\"executing finally clause\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "id": "eff956b6-922d-44c6-9aef-aadcdfdf8261",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TypeError\n",
      "executing finally clause\n"
     ]
    }
   ],
   "source": [
    "# >>> divide(2, 1)\n",
    "# >>> divide(2, 0)\n",
    "divide(\"2\", \"1\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36c3ae04-a89d-4faf-bc6a-1b2d6c83495e",
   "metadata": {},
   "source": [
    "## 函数\n",
    "\n",
    "官方教程：https://docs.python.org/3.10/tutorial/controlflow.html#more-on-defining-functions\n",
    "\n",
    "* def关键字\n",
    "* 用括号表示参数列表\n",
    "* 语句需要缩进"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0bafacc7-c53f-4afd-a729-c2f0a46f70c5",
   "metadata": {},
   "source": [
    "## Python 面向对象编程\n",
    "\n",
    "零门槛入门：\n",
    "\n",
    "- [Python面向对象编程从零开始（1）——从没对象到有对象](https://ask.hellobi.com/blog/wangdawei/8429)\n",
    "- [Python面向对象编程从零开始（2）—— 与对象相互了解](https://ask.hellobi.com/blog/wangdawei/8446)\n",
    "- [Python面向对象编程从零开始（3）—— 小姐姐请客上篇](https://ask.hellobi.com/blog/wangdawei/8463)\n",
    "- [Python面向对象编程从零开始（4）—— 小姐姐请客下篇](https://ask.hellobi.com/blog/wangdawei/8478)\n",
    "- [Python面向对象编程从零开始（5）—— 小姐姐要买房](https://ask.hellobi.com/blog/wangdawei/8586)\n",
    "\n",
    "官方教程：https://docs.python.org/3.10/tutorial/classes.html\n",
    "\n",
    "---\n",
    "\n",
    "- 面向过程编程\n",
    "  - 过程为核心： 面向过程编程是以过程或函数为中心，将程序分解为一个个独立的步骤，通过调用这些步骤来完成任务。\n",
    "  - 数据和操作分离： 数据和操作数据的函数是分离的，数据被传递给函数进行处理。\n",
    "  - 简洁直观： 面向过程的代码通常比较直观，适用于简单的任务和算法。\n",
    "- 面向对象编程\n",
    "  - 对象为核心： 面向对象编程是以对象为核心，将数据和操作数据的方法封装在一起，形成对象。\n",
    "  - 封装性： 对象封装了数据和行为，通过定义类来创建对象，使得代码更具可重用性和可维护性。\n",
    "  - 继承性： 允许创建一个类，该类是现有类的子类，从而可以继承现有类的属性和方法。\n",
    "  - 多态性： 允许使用一个实体的多种形式或类型，提高了灵活性。\n",
    "\n",
    "\n",
    "- 选择面向过程： 适用于简单的、线性的任务，代码相对较短，不需要复杂的结构。\n",
    "- 选择面向对象： 适用于需要处理复杂问题、具有多个实体（对象）相互交互的场景，代码更易维护、扩展和理解。\n",
    "\n",
    "综合考虑问题的复杂度和可维护性，选择合适的编程范式来完成任务。在实际开发中，常常采用面向对象的方法，因为它更灵活、可扩展，适用于大型项目和团队协作。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "id": "a38a3784-de0f-41f6-b3e4-cb239d7e55dd",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# 面向过程\n",
    "std1 = {'name': 'Michael', 'score': 98}\n",
    "std2 = {'name': 'Bob', 'score': 81}\n",
    "\n",
    "#处理学生信息可以通过函数实现，比如打印学生的成绩：\n",
    "def print_score(std):\n",
    "    print(f\"{std['name']} : {std['score']}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "id": "98577a6f-0da2-4145-aafa-49623ae6a815",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Michael : 98\n",
      "Bob : 81\n"
     ]
    }
   ],
   "source": [
    "print_score(std1)\n",
    "print_score(std2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "id": "3dcb2b77-0f6c-482c-bfe4-12bfb2fbc575",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# 面向对象\n",
    "class Student:   # 类\n",
    "    def __init__(self, name, score):\n",
    "        self.name = name    # 类的属性\n",
    "        self.score = score\n",
    "    def print_score(self):  # 类的方法\n",
    "        print(f\"{self.name} : {self.score}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "id": "6a3ebbc8-ff88-41e6-9fbc-c911d89300a8",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "st1 = Student('amy', 120)   # 类对象的实例化\n",
    "st2 = Student('jack', 108)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "id": "1ac2cad9-6465-4572-a514-587da6afcae3",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "amy : 120\n",
      "jack : 108\n"
     ]
    }
   ],
   "source": [
    "st1.print_score()\n",
    "st2.print_score()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "id": "3bd128a9-7f28-4bf7-a0e2-b79b0c90e593",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import random as r\n",
    "class Fish:\n",
    "    def __init__(self):\n",
    "        self.x = r.randint(0, 10)\n",
    "        self.y = r.randint(0, 10)\n",
    "    def move(self):\n",
    "        self.x -= 1\n",
    "        print(\"我的位置是：\", self.x, self.y)\n",
    "\n",
    "# 利用继承演示鱼游动方向位置\n",
    "class Goldfish(Fish):\n",
    "    pass\n",
    "class Salman(Fish):\n",
    "    pass\n",
    "class Shark(Fish):\n",
    "    # 这里重写了 __init__ 方法，就会覆盖掉父类的方法\n",
    "    # 而用到 super 函数后就可以继续使用父类的方法\n",
    "    def __init__(self):\n",
    "        # super函数不用给定任何基类的名字(如下)，它会一层层找出代码所有父类里面对应的方法，\n",
    "        # 要改变该类的继承关系时只需修改这个类的父类就行就是括号里面的Fish。\n",
    "        super().__init__()    # super().重写的属性或方法\n",
    "        self.hungry = True\n",
    "    def eat(self):\n",
    "        if self.hungry:\n",
    "            print(\"我要开吃了。。。\")\n",
    "            self.hungry = False\n",
    "        else:\n",
    "            print(\"肚肚不饿哦。。。\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "id": "67a0727a-a1dd-4cc1-b5fc-9573736362e6",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "goldfish1 at: 6 5\n",
      "Salman1 at: 9 8\n"
     ]
    }
   ],
   "source": [
    "goldfish1 = Goldfish()\n",
    "Salman1 = Salman()\n",
    "\n",
    "print('goldfish1 at:', goldfish1.x, goldfish1.y)\n",
    "print('Salman1 at:', Salman1.x, Salman1.y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "id": "cfb49cde-8392-4c7d-829b-66a785997f67",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "我的位置是： 2 5\n",
      "我的位置是： 5 8\n"
     ]
    }
   ],
   "source": [
    "goldfish1.move(), Salman1.move();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "id": "9fa7f57e-fe2d-4b99-a167-1312d8d4e403",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "goldfish1 at: 2 5\n",
      "Salman1 at: 5 8\n"
     ]
    }
   ],
   "source": [
    "print('goldfish1 at:', goldfish1.x, goldfish1.y)\n",
    "print('Salman1 at:', Salman1.x, Salman1.y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91e845e4-def1-499b-b864-bbcd758cbf95",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Python 文件读写\n",
    "\n",
    "官方教程：https://docs.python.org/3.10/tutorial/inputoutput.html#reading-and-writing-files\n",
    "\n",
    "- `open`\n",
    "- `with`:  `with` 语句用于简化文件或资源的管理，确保在代码块执行前后资源被正确地分配和释放。主要应用在文件处理、网络连接、数据库连接等需要进行资源管理的场景。\n",
    "    - 机理: `with` 语句使用上下文管理器对象，该对象定义了 `__enter__` 和 `__exit__` 方法。当执行进入 `with` 代码块时，会调用 `__enter__` 方法获取资源；当退出 with 代码块时，会调用 `__exit__` 方法进行资源释放。\n",
    "    - 特点:\n",
    "        - 自动资源管理： `with` 语句确保在代码块执行结束后资源会被自动释放，即使出现异常。\n",
    "        - 可读性：代码更加清晰简洁，避免了手动管理资源带来的繁琐性。\n",
    "        - 异常处理：`__exit__` 方法中可以处理异常，使得异常发生时能够进行适当的处理，比如关闭文件或回滚数据库事务。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "id": "4b68ef1f-9591-435b-9cf9-d27373caed4f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-rw-r--r-- 1 root root 5.3K Nov 29 10:00 ShangHai.txt\n"
     ]
    }
   ],
   "source": [
    "# shell 运行命令\n",
    "!ls -lh ShangHai.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "id": "c4cafd8b-8fda-43fe-8d85-6bd8b83750aa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['\\ufeffOn', 'the', 'morning', 'of', 'June', '20th', '1830,', 'Lord', 'Amnerst,', 'the', 'first', 'British', 'ship', 'to', 'visit', 'Shanghai', 'was', 'anchored', 'at', 'the', 'mouth', 'of', 'Huangpu,', 'two', 'Europeans', 'strode', 'ashore.', 'These', 'men', 'were', 'Charles', 'Gutzlaff,', 'translator', 'and', 'missionary,', 'and', 'Hill', 'Lynsay,', 'representative', 'of', 'the', 'British', 'East', 'India', 'Company.', 'Crowds', 'gathered', 'together', 'to', 'witness', 'these', 'so-called', 'barbarians;', 'though', 'in', 'his', 'report', 'Linsay', 'mentioned', 'cotton', 'cloth', 'and', 'calico,', 'his', 'real', 'objective', 'was', 'to', 'sell', 'opium.', 'Nine', 'years', 'later,', 'the', 'opium', 'war', 'broke', 'out.', 'After', 'the', 'Chinese', 'was', 'defeated', 'by', 'Britain,', 'Shanghai', 'became', 'one', 'of', 'the', 'cities', 'opened', 'to', 'foreign', 'trade', 'by', 'the', '1842', 'Treaty', 'of', 'Nanking,', 'and', 'a', 'new', 'city', 'began', 'to', 'develop.\\n']\n",
      "['Shanghailanders\\n']\n",
      "['Until', 'the', '19th', 'century', 'and', 'the', 'first', 'opium', 'war,', 'Shanghai', 'was', 'considered', 'to', 'be', 'essentially', 'a', 'fishing', 'village.', 'However,', 'in', '1914,', 'Shanghai', 'had', '200', 'banks', 'dealing', 'with', '80%', 'of', 'its', 'foreign', 'investments', 'in', 'China.', 'Citizens', 'of', 'many', 'countries', 'on', 'all', 'continents', 'gathered', 'in', 'Shanghai', 'to', 'live', 'and', 'work', 'in', 'the', 'ensuing', 'decades.', 'By', '1932,', 'Shanghai', 'had', 'become', 'the', 'world’s', '5th', 'largest', 'city', 'and', 'home', 'to', '70,000', 'foreigners.', 'Foreign', 'residents', 'of', 'the', 'city', 'called', 'themselves', 'Shanghailanders.', 'From', '1842', 'to', '1949,', 'while', 'the', 'British', 'established', 'settlement', 'in', 'a', 'section', 'of', 'Shanghai,', 'the', 'French', 'and', 'the', 'American', 'also', 'established', 'their', 'own', 'settlements;', 'these', 'settlements', 'were', 'later', 'called', 'concessions.', 'World', 'War', 'II', 'marked', 'Shanghai', 'as', 'a', 'destination', 'for', 'refugees.', 'Between', '1937', 'and', '1939,', 'an', 'estimated', '20,000', 'Jews', 'traveled', 'to', 'Shanghai', 'to', 'flee', 'the', 'Nazis,', 'Shanghai', 'was', 'the', 'only', 'city', 'where', 'Jews', 'were', 'welcome', 'without', 'condition.', 'Today,', 'the', 'streets', 'of', 'the', 'French', 'concession', 'and', 'other', 'foreign', 'settlements', 'had', 'changed', 'to', 'become', 'what-to-do', 'n’', 'you-need', 'avenues,', 'while', 'the', 'Bund,', 'a', 'stretch', 'of', 'Western', 'buildings', 'is', 'still', 'representing', 'the', 'Western', 'influence', 'that', 'dominated', 'so', 'much', 'of', 'the', 'city’s', 'history.', '', '\\n']\n",
      "['General', 'Facts\\n']\n",
      "['Shanghai', 'is', 'a', 'city', 'in', 'East', 'China;', 'it', 'is', 'the', 'largest', 'city', 'of', 'the', 'People’s', 'Republic', 'of', 'China', 'and', 'the', '8th', 'largest', 'city', 'in', 'the', 'world.', 'Due', 'to', 'its', 'rapid', 'growth', 'of', 'the', 'last', 'two', 'decades,', 'it', 'has', 'again', 'become', 'a', 'global', 'city;', 'it', 'is', 'also', 'known', 'as', 'the', 'Paris', 'of', 'the', 'East.', 'According', 'to', 'the', '2009', 'census,', 'Shanghai', 'has', 'a', 'population', 'of', 'about', '19', 'millions,', 'four', 'times', 'more', 'than', 'the', 'people', 'in', 'New', 'Zealand,', 'registered', 'migrants', 'comprise', 'of', 'one-third', 'of', 'the', 'population', 'in', '2007.', 'However,', 'as', 'the', 'most', 'success', 'of', 'cities', 'of', 'the', 'one-child', 'policy,', 'Shanghai', 'has', 'the', 'lowest', 'fertility', 'rate', 'in', 'China.', 'The', 'main', 'language', 'spoken', 'in', 'Shanghai', 'is', 'Shanghainese,', 'one', 'of', 'the', '248', 'Chinese', 'dialects', 'identified', 'by', 'Wikipedia.', 'It', 'is', 'gigantically', 'different', 'from', 'Mandarin.', 'If', 'you', 'were', 'to', 'say', 'something', 'in', 'Shanghainese', 'to', 'a', 'Beijinger,', 'he’s', 'bound', 'to', 'get', 'a', 'confused', 'stroke', 'and', 'possibly', 'get', 'some', 'eye-rolling.', 'Shanghainese', 'kids', 'start', 'learning', 'English', 'in', 'the', 'first', 'grade,', 'like', 'it', 'or', 'not,', 'English', 'is', 'now', 'a', 'compulsory', 'course', 'for', 'all', 'pupils', 'in', 'Shanghai.', 'In', 'a', 'decade’s', 'time,', 'everyone', 'in', 'the', 'city', 'may', 'speak', 'English', 'or', 'a', 'hybrid', 'language', 'of', 'Chinese', 'and', 'English,', 'known', 'as', 'Chinglish.', '\\n']\n",
      "['Economy\\n']\n",
      "['Shanghai', 'means', 'on', 'top', 'of', 'the', 'sea,', 'but', 'the', 'fact', 'is,', 'quite', 'a', 'lot', 'of', 'local', 'Shanghainese', 'have', 'never', 'seen', 'the', 'sea', 'despite', 'Shanghai', 'is', 'not', 'more', 'than', 'one', 'hundred', 'miles', 'from', 'the', 'Pacific', 'Ocean;', 'and', 'it', 'is', 'not', 'blue', 'as', 'you', 'may', 'expect,', 'because', 'of', 'pollutions', 'from', 'factories', 'around', 'the', 'Yangtze', 'River', 'delta.', 'In', '2005,', 'Shanghai', 'was', 'termed', 'to', 'be', 'the', 'world’s', 'largest', 'port', 'for', 'cargo', 'and', 'it', 'is', 'now', 'the', 'world’s', 'busiest', 'seaport.', 'It', 'handled', '29', 'million', 'TEUs', 'in', '2010,', '25%', 'of', 'Chinese', 'industrial', 'output', 'comes', 'from', 'the', 'city', 'out', 'of', 'sea,', 'and', 'Shanghai', 'produces', '30%', 'of', 'China’s', 'GDP.', 'By', 'the', 'end', 'of', '2009,', 'there', 'were', '787', 'financial', 'institutions', 'in', 'Shanghai,', 'of', 'which', '170', 'were', 'foreign', 'invested.', 'In', '2009,', 'the', 'Shanghai', 'Stock', 'Exchange', 'ranked', 'third', 'among', 'worldwide', 'stock', 'exchanges', 'in', 'terms', 'of', 'traded', 'volume', 'and', 'trading', 'volume', 'of', 'six', 'key', 'commodities', 'including', 'rubber,', 'copper', 'and', 'zinc', 'under', 'Shanghai', 'Future', 'Exchange', 'all', 'ranked', 'first', 'across', 'the', 'world.', 'Shanghai', 'is', 'now', 'ranked', '5th', 'in', 'the', 'latest', 'edition', 'of', 'the', 'Global', 'Financial', 'Center', 'Index', 'published', 'by', 'the', 'city', 'of', 'London.\\n']\n",
      "['Urban', 'Development\\n']\n",
      "['One', 'uniquely', 'Shanghainese', 'cultural', 'element', 'is', 'the', 'SHI', 'Ku', 'Men', 'residences,', 'which', 'is', 'a', 'two', 'or', 'three', 'storey', 'townhouses.', 'The', 'Shi', 'Ku', 'Men', 'is', 'a', 'cultural', 'blend', 'of', 'elements', 'found', 'in', 'Western', 'architecture,', 'traditional', 'Chinese', 'architecture', 'and', 'social', 'behavior.', 'Today,', 'many', 'of', 'the', 'area', 'with', 'classic', 'Shi', 'Ku', 'Men', 'stood', 'had', 'been', 'redeveloped', 'for', 'modern', 'Shanghai,', 'with', 'only', 'a', 'few', 'areas', 'remaining.', 'During', 'the', '1990s,', 'Shanghai', 'had', 'the', 'largest', 'agglomeration', 'of', 'construction', 'cranes;', 'since', '2008,', 'Shanghai', 'has', 'boasted', 'more', 'free', 'standing', 'buildings', 'for', '400', 'meters', 'than', 'any', 'other', 'cities,', 'The', 'Shanghai', 'World', 'Financial', 'Center', 'is', 'currently', 'the', 'third', 'tallest', 'building', 'in', 'the', 'world;', 'in', 'the', 'future,', 'the', 'Shanghai', 'Tower,', 'straight', 'to', 'completion', 'in', '2014,', 'will', 'be', 'the', 'tallest', 'in', 'China.', 'Meanwhile,', 'Shanghai', 'is', 'sinking', 'at', 'a', 'rate', 'of', '1.5cm', 'a', 'year.', 'Shanghai’s', 'rapid', 'transit', 'system,', 'Shanghai', 'Metro,', 'extends', 'to', 'every', 'core', 'neighbor', 'districts', 'in', 'and', 'to', 'every', 'suburban', 'district.', 'As', 'of', '2010,', 'there', 'were12', 'metro', 'lines,', '273', 'stations', 'and', 'over', '420', 'km', 'of', 'tracks', 'in', 'operation,', 'making', 'it', 'the', 'largest', 'network', 'in', 'the', 'world.', '', '', '', '', '', '', '', '', '\\n']\n",
      "['And', 'the', 'shuttle', 'maglev', 'train', 'linking', 'the', 'airport', 'to', 'the', 'city', 'center', 'built', 'in', '2004', 'is', 'the', 'world’s', 'fastest', 'passenger', 'train,', 'reaching', 'a', 'maximum', 'cruising', 'speed', 'of', '431', 'km', 'per', 'hour.', 'Shanghai', 'has', 'the', 'largest', 'bus', 'system', 'in', 'the', 'planet', 'with', '1424', 'bus', 'lines.']\n"
     ]
    }
   ],
   "source": [
    "for line in open('./ShangHai.txt', 'rb'):\n",
    "    print(line.decode('utf8').split(\" \"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "id": "7d5b3a65-972d-4195-ab12-d6d6fe69b4bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 打开文件，获得文件句柄\n",
    "f = open('ShangHai.txt', 'r', encoding='utf8')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "id": "70ea17d2-f1d1-4eb7-95e6-22e1c9ed4cb8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 读一行\n",
    "content = f.readline()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "id": "e5e92845-1542-43fe-804e-6c90b37c101c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "﻿On the morning of June 20th 1830, Lord Amnerst, the first British ship to visit Shanghai was anchored at the mouth of Huangpu, two Europeans strode ashore. These men were Charles Gutzlaff, translator and missionary, and Hill Lynsay, representative of the British East India Company. Crowds gathered together to witness these so-called barbarians; though in his report Linsay mentioned cotton cloth and calico, his real objective was to sell opium. Nine years later, the opium war broke out. After the Chinese was defeated by Britain, Shanghai became one of the cities opened to foreign trade by the 1842 Treaty of Nanking, and a new city began to develop.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# 输出\n",
    "print(content)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "id": "5807ca85-3c0b-4b4e-8df0-c62666fa0834",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 再读一行\n",
    "content = f.readline()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "id": "6dc13cbc-9905-4768-97e4-1b66bfd125e9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shanghailanders\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# 输出\n",
    "print(content)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "id": "7ed04150-e1a4-42c1-8665-c4b36732ad46",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 再读一行\n",
    "content = f.readline()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "id": "119b8972-bc78-4fa3-97be-7c3394e02c52",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Until the 19th century and the first opium war, Shanghai was considered to be essentially a fishing village. However, in 1914, Shanghai had 200 banks dealing with 80% of its foreign investments in China. Citizens of many countries on all continents gathered in Shanghai to live and work in the ensuing decades. By 1932, Shanghai had become the world’s 5th largest city and home to 70,000 foreigners. Foreign residents of the city called themselves Shanghailanders. From 1842 to 1949, while the British established settlement in a section of Shanghai, the French and the American also established their own settlements; these settlements were later called concessions. World War II marked Shanghai as a destination for refugees. Between 1937 and 1939, an estimated 20,000 Jews traveled to Shanghai to flee the Nazis, Shanghai was the only city where Jews were welcome without condition. Today, the streets of the French concession and other foreign settlements had changed to become what-to-do n’ you-need avenues, while the Bund, a stretch of Western buildings is still representing the Western influence that dominated so much of the city’s history.  \n",
      "\n"
     ]
    }
   ],
   "source": [
    "# 输出\n",
    "print(content)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "id": "fc253f73-9269-43cf-a72b-9ac7e162ee5a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 关闭文件\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "id": "4072b419-e54d-46c2-9e16-49a6bcc53fca",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 打开文件，获得文件句柄\n",
    "f = open('ShangHai.txt', 'r', encoding='utf8')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "id": "4b5a94be-576d-4d65-bffb-227f6f30ac50",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['\\ufeffOn the morning of June 20th 1830, Lord Amnerst, the first British ship to visit Shanghai was anchored at the mouth of Huangpu, two Europeans strode ashore. These men were Charles Gutzlaff, translator and missionary, and Hill Lynsay, representative of the British East India Company. Crowds gathered together to witness these so-called barbarians; though in his report Linsay mentioned cotton cloth and calico, his real objective was to sell opium. Nine years later, the opium war broke out. After the Chinese was defeated by Britain, Shanghai became one of the cities opened to foreign trade by the 1842 Treaty of Nanking, and a new city began to develop.\\n',\n",
       " 'Shanghailanders\\n',\n",
       " 'Until the 19th century and the first opium war, Shanghai was considered to be essentially a fishing village. However, in 1914, Shanghai had 200 banks dealing with 80% of its foreign investments in China. Citizens of many countries on all continents gathered in Shanghai to live and work in the ensuing decades. By 1932, Shanghai had become the world’s 5th largest city and home to 70,000 foreigners. Foreign residents of the city called themselves Shanghailanders. From 1842 to 1949, while the British established settlement in a section of Shanghai, the French and the American also established their own settlements; these settlements were later called concessions. World War II marked Shanghai as a destination for refugees. Between 1937 and 1939, an estimated 20,000 Jews traveled to Shanghai to flee the Nazis, Shanghai was the only city where Jews were welcome without condition. Today, the streets of the French concession and other foreign settlements had changed to become what-to-do n’ you-need avenues, while the Bund, a stretch of Western buildings is still representing the Western influence that dominated so much of the city’s history.  \\n',\n",
       " 'General Facts\\n',\n",
       " 'Shanghai is a city in East China; it is the largest city of the People’s Republic of China and the 8th largest city in the world. Due to its rapid growth of the last two decades, it has again become a global city; it is also known as the Paris of the East. According to the 2009 census, Shanghai has a population of about 19 millions, four times more than the people in New Zealand, registered migrants comprise of one-third of the population in 2007. However, as the most success of cities of the one-child policy, Shanghai has the lowest fertility rate in China. The main language spoken in Shanghai is Shanghainese, one of the 248 Chinese dialects identified by Wikipedia. It is gigantically different from Mandarin. If you were to say something in Shanghainese to a Beijinger, he’s bound to get a confused stroke and possibly get some eye-rolling. Shanghainese kids start learning English in the first grade, like it or not, English is now a compulsory course for all pupils in Shanghai. In a decade’s time, everyone in the city may speak English or a hybrid language of Chinese and English, known as Chinglish. \\n',\n",
       " 'Economy\\n',\n",
       " 'Shanghai means on top of the sea, but the fact is, quite a lot of local Shanghainese have never seen the sea despite Shanghai is not more than one hundred miles from the Pacific Ocean; and it is not blue as you may expect, because of pollutions from factories around the Yangtze River delta. In 2005, Shanghai was termed to be the world’s largest port for cargo and it is now the world’s busiest seaport. It handled 29 million TEUs in 2010, 25% of Chinese industrial output comes from the city out of sea, and Shanghai produces 30% of China’s GDP. By the end of 2009, there were 787 financial institutions in Shanghai, of which 170 were foreign invested. In 2009, the Shanghai Stock Exchange ranked third among worldwide stock exchanges in terms of traded volume and trading volume of six key commodities including rubber, copper and zinc under Shanghai Future Exchange all ranked first across the world. Shanghai is now ranked 5th in the latest edition of the Global Financial Center Index published by the city of London.\\n',\n",
       " 'Urban Development\\n',\n",
       " 'One uniquely Shanghainese cultural element is the SHI Ku Men residences, which is a two or three storey townhouses. The Shi Ku Men is a cultural blend of elements found in Western architecture, traditional Chinese architecture and social behavior. Today, many of the area with classic Shi Ku Men stood had been redeveloped for modern Shanghai, with only a few areas remaining. During the 1990s, Shanghai had the largest agglomeration of construction cranes; since 2008, Shanghai has boasted more free standing buildings for 400 meters than any other cities, The Shanghai World Financial Center is currently the third tallest building in the world; in the future, the Shanghai Tower, straight to completion in 2014, will be the tallest in China. Meanwhile, Shanghai is sinking at a rate of 1.5cm a year. Shanghai’s rapid transit system, Shanghai Metro, extends to every core neighbor districts in and to every suburban district. As of 2010, there were12 metro lines, 273 stations and over 420 km of tracks in operation, making it the largest network in the world.         \\n',\n",
       " 'And the shuttle maglev train linking the airport to the city center built in 2004 is the world’s fastest passenger train, reaching a maximum cruising speed of 431 km per hour. Shanghai has the largest bus system in the planet with 1424 bus lines.']"
      ]
     },
     "execution_count": 222,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 读取全部内容，每一行作为一个元素存放在list中\n",
    "f.readlines()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "id": "09bf63e3-740e-44ce-8cd9-cdf56aa1bd7e",
   "metadata": {},
   "outputs": [],
   "source": [
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "id": "89302566-31f3-4ea2-96f4-ef4dfe011215",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "﻿On the morning of June 20th 1830, Lord Amnerst, the first British ship to visit Shanghai was anchored at the mouth of Huangpu, two Europeans strode ashore. These men were Charles Gutzlaff, translator and missionary, and Hill Lynsay, representative of the British East India Company. Crowds gathered together to witness these so-called barbarians; though in his report Linsay mentioned cotton cloth and calico, his real objective was to sell opium. Nine years later, the opium war broke out. After the Chinese was defeated by Britain, Shanghai became one of the cities opened to foreign trade by the 1842 Treaty of Nanking, and a new city began to develop.\n",
      "Shanghailanders\n",
      "Until the 19th century and the first opium war, Shanghai was considered to be essentially a fishing village. However, in 1914, Shanghai had 200 banks dealing with 80% of its foreign investments in China. Citizens of many countries on all continents gathered in Shanghai to live and work in the ensuing decades. By 1932, Shanghai had become the world’s 5th largest city and home to 70,000 foreigners. Foreign residents of the city called themselves Shanghailanders. From 1842 to 1949, while the British established settlement in a section of Shanghai, the French and the American also established their own settlements; these settlements were later called concessions. World War II marked Shanghai as a destination for refugees. Between 1937 and 1939, an estimated 20,000 Jews traveled to Shanghai to flee the Nazis, Shanghai was the only city where Jews were welcome without condition. Today, the streets of the French concession and other foreign settlements had changed to become what-to-do n’ you-need avenues, while the Bund, a stretch of Western buildings is still representing the Western influence that dominated so much of the city’s history.  \n",
      "General Facts\n",
      "Shanghai is a city in East China; it is the largest city of the People’s Republic of China and the 8th largest city in the world. Due to its rapid growth of the last two decades, it has again become a global city; it is also known as the Paris of the East. According to the 2009 census, Shanghai has a population of about 19 millions, four times more than the people in New Zealand, registered migrants comprise of one-third of the population in 2007. However, as the most success of cities of the one-child policy, Shanghai has the lowest fertility rate in China. The main language spoken in Shanghai is Shanghainese, one of the 248 Chinese dialects identified by Wikipedia. It is gigantically different from Mandarin. If you were to say something in Shanghainese to a Beijinger, he’s bound to get a confused stroke and possibly get some eye-rolling. Shanghainese kids start learning English in the first grade, like it or not, English is now a compulsory course for all pupils in Shanghai. In a decade’s time, everyone in the city may speak English or a hybrid language of Chinese and English, known as Chinglish. \n",
      "Economy\n",
      "Shanghai means on top of the sea, but the fact is, quite a lot of local Shanghainese have never seen the sea despite Shanghai is not more than one hundred miles from the Pacific Ocean; and it is not blue as you may expect, because of pollutions from factories around the Yangtze River delta. In 2005, Shanghai was termed to be the world’s largest port for cargo and it is now the world’s busiest seaport. It handled 29 million TEUs in 2010, 25% of Chinese industrial output comes from the city out of sea, and Shanghai produces 30% of China’s GDP. By the end of 2009, there were 787 financial institutions in Shanghai, of which 170 were foreign invested. In 2009, the Shanghai Stock Exchange ranked third among worldwide stock exchanges in terms of traded volume and trading volume of six key commodities including rubber, copper and zinc under Shanghai Future Exchange all ranked first across the world. Shanghai is now ranked 5th in the latest edition of the Global Financial Center Index published by the city of London.\n",
      "Urban Development\n",
      "One uniquely Shanghainese cultural element is the SHI Ku Men residences, which is a two or three storey townhouses. The Shi Ku Men is a cultural blend of elements found in Western architecture, traditional Chinese architecture and social behavior. Today, many of the area with classic Shi Ku Men stood had been redeveloped for modern Shanghai, with only a few areas remaining. During the 1990s, Shanghai had the largest agglomeration of construction cranes; since 2008, Shanghai has boasted more free standing buildings for 400 meters than any other cities, The Shanghai World Financial Center is currently the third tallest building in the world; in the future, the Shanghai Tower, straight to completion in 2014, will be the tallest in China. Meanwhile, Shanghai is sinking at a rate of 1.5cm a year. Shanghai’s rapid transit system, Shanghai Metro, extends to every core neighbor districts in and to every suburban district. As of 2010, there were12 metro lines, 273 stations and over 420 km of tracks in operation, making it the largest network in the world.         \n",
      "And the shuttle maglev train linking the airport to the city center built in 2004 is the world’s fastest passenger train, reaching a maximum cruising speed of 431 km per hour. Shanghai has the largest bus system in the planet with 1424 bus lines.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 225,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "with open('ShangHai.txt', encoding=\"utf-8\") as f:\n",
    "    read_data = f.read()\n",
    "    print(read_data)\n",
    "\n",
    "# We can check that the file has been automatically closed.\n",
    "f.closed"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9aac35b9-9ba4-4048-8f2d-14aa72dac238",
   "metadata": {},
   "source": [
    "## 应用：词频统计\n",
    "\n",
    "给你一个文件，统计这个文件中每个出现的单词的词频"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "id": "de450d80-bd69-41e2-80df-426e55f4edff",
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "﻿on 1\n",
      "the 73\n",
      "morning 1\n",
      "of 42\n",
      "june 1\n",
      "20th 1\n",
      "1830, 1\n",
      "lord 1\n",
      "amnerst, 1\n",
      "first 4\n",
      "british 3\n",
      "ship 1\n",
      "to 22\n",
      "visit 1\n",
      "shanghai 27\n",
      "was 6\n",
      "anchored 1\n",
      "at 2\n",
      "mouth 1\n",
      "huangpu, 1\n",
      "two 3\n",
      "europeans 1\n",
      "strode 1\n",
      "ashore. 1\n",
      "these 3\n",
      "men 4\n",
      "were 6\n",
      "charles 1\n",
      "gutzlaff, 1\n",
      "translator 1\n",
      "and 22\n",
      "missionary, 1\n",
      "hill 1\n",
      "lynsay, 1\n",
      "representative 1\n",
      "east 2\n",
      "india 1\n",
      "company. 1\n",
      "crowds 1\n",
      "gathered 2\n",
      "together 1\n",
      "witness 1\n",
      "so-called 1\n",
      "barbarians; 1\n",
      "though 1\n",
      "in 33\n",
      "his 2\n",
      "report 1\n",
      "linsay 1\n",
      "mentioned 1\n",
      "cotton 1\n",
      "cloth 1\n",
      "calico, 1\n",
      "real 1\n",
      "objective 1\n",
      "sell 1\n",
      "opium. 1\n",
      "nine 1\n",
      "years 1\n",
      "later, 1\n",
      "opium 2\n",
      "war 2\n",
      "broke 1\n",
      "out. 1\n",
      "after 1\n",
      "chinese 5\n",
      "defeated 1\n",
      "by 6\n",
      "britain, 1\n",
      "became 1\n",
      "one 4\n",
      "cities 2\n",
      "opened 1\n",
      "foreign 5\n",
      "trade 1\n",
      "1842 2\n",
      "treaty 1\n",
      "nanking, 1\n",
      "a 20\n",
      "new 2\n",
      "city 11\n",
      "began 1\n",
      "develop. 1\n",
      "shanghailanders 1\n",
      "until 1\n",
      "19th 1\n",
      "century 1\n",
      "war, 1\n",
      "considered 1\n",
      "be 3\n",
      "essentially 1\n",
      "fishing 1\n",
      "village. 1\n",
      "however, 2\n",
      "1914, 1\n",
      "had 5\n",
      "200 1\n",
      "banks 1\n",
      "dealing 1\n",
      "with 4\n",
      "80% 1\n",
      "its 2\n",
      "investments 1\n",
      "china. 3\n",
      "citizens 1\n",
      "many 2\n",
      "countries 1\n",
      "on 2\n",
      "all 3\n",
      "continents 1\n",
      "live 1\n",
      "work 1\n",
      "ensuing 1\n",
      "decades. 1\n",
      "1932, 1\n",
      "become 3\n",
      "world’s 4\n",
      "5th 2\n",
      "largest 7\n",
      "home 1\n",
      "70,000 1\n",
      "foreigners. 1\n",
      "residents 1\n",
      "called 2\n",
      "themselves 1\n",
      "shanghailanders. 1\n",
      "from 5\n",
      "1949, 1\n",
      "while 2\n",
      "established 2\n",
      "settlement 1\n",
      "section 1\n",
      "shanghai, 3\n",
      "french 2\n",
      "american 1\n",
      "also 2\n",
      "their 1\n",
      "own 1\n",
      "settlements; 1\n",
      "settlements 2\n",
      "later 1\n",
      "concessions. 1\n",
      "world 2\n",
      "ii 1\n",
      "marked 1\n",
      "as 6\n",
      "destination 1\n",
      "for 5\n",
      "refugees. 1\n",
      "between 1\n",
      "1937 1\n",
      "1939, 1\n",
      "an 1\n",
      "estimated 1\n",
      "20,000 1\n",
      "jews 2\n",
      "traveled 1\n",
      "flee 1\n",
      "nazis, 1\n",
      "only 2\n",
      "where 1\n",
      "welcome 1\n",
      "without 1\n",
      "condition. 1\n",
      "today, 2\n",
      "streets 1\n",
      "concession 1\n",
      "other 2\n",
      "changed 1\n",
      "what-to-do 1\n",
      "n’ 1\n",
      "you-need 1\n",
      "avenues, 1\n",
      "bund, 1\n",
      "stretch 1\n",
      "western 3\n",
      "buildings 2\n",
      "is 17\n",
      "still 1\n",
      "representing 1\n",
      "influence 1\n",
      "that 1\n",
      "dominated 1\n",
      "so 1\n",
      "much 1\n",
      "city’s 1\n",
      "history. 1\n",
      "general 1\n",
      "facts 1\n",
      "china; 1\n",
      "it 9\n",
      "people’s 1\n",
      "republic 1\n",
      "china 1\n",
      "8th 1\n",
      "world. 3\n",
      "due 1\n",
      "rapid 2\n",
      "growth 1\n",
      "last 1\n",
      "decades, 1\n",
      "has 5\n",
      "again 1\n",
      "global 2\n",
      "city; 1\n",
      "known 2\n",
      "paris 1\n",
      "east. 1\n",
      "according 1\n",
      "2009 1\n",
      "census, 1\n",
      "population 2\n",
      "about 1\n",
      "19 1\n",
      "millions, 1\n",
      "four 1\n",
      "times 1\n",
      "more 3\n",
      "than 3\n",
      "people 1\n",
      "zealand, 1\n",
      "registered 1\n",
      "migrants 1\n",
      "comprise 1\n",
      "one-third 1\n",
      "2007. 1\n",
      "most 1\n",
      "success 1\n",
      "one-child 1\n",
      "policy, 1\n",
      "lowest 1\n",
      "fertility 1\n",
      "rate 2\n",
      "main 1\n",
      "language 2\n",
      "spoken 1\n",
      "shanghainese, 1\n",
      "248 1\n",
      "dialects 1\n",
      "identified 1\n",
      "wikipedia. 1\n",
      "gigantically 1\n",
      "different 1\n",
      "mandarin. 1\n",
      "if 1\n",
      "you 2\n",
      "say 1\n",
      "something 1\n",
      "shanghainese 4\n",
      "beijinger, 1\n",
      "he’s 1\n",
      "bound 1\n",
      "get 2\n",
      "confused 1\n",
      "stroke 1\n",
      "possibly 1\n",
      "some 1\n",
      "eye-rolling. 1\n",
      "kids 1\n",
      "start 1\n",
      "learning 1\n",
      "english 3\n",
      "grade, 1\n",
      "like 1\n",
      "or 3\n",
      "not, 1\n",
      "now 3\n",
      "compulsory 1\n",
      "course 1\n",
      "pupils 1\n",
      "shanghai. 1\n",
      "decade’s 1\n",
      "time, 1\n",
      "everyone 1\n",
      "may 2\n",
      "speak 1\n",
      "hybrid 1\n",
      "english, 1\n",
      "chinglish. 1\n",
      "economy 1\n",
      "means 1\n",
      "top 1\n",
      "sea, 2\n",
      "but 1\n",
      "fact 1\n",
      "is, 1\n",
      "quite 1\n",
      "lot 1\n",
      "local 1\n",
      "have 1\n",
      "never 1\n",
      "seen 1\n",
      "sea 1\n",
      "despite 1\n",
      "not 2\n",
      "hundred 1\n",
      "miles 1\n",
      "pacific 1\n",
      "ocean; 1\n",
      "blue 1\n",
      "expect, 1\n",
      "because 1\n",
      "pollutions 1\n",
      "factories 1\n",
      "around 1\n",
      "yangtze 1\n",
      "river 1\n",
      "delta. 1\n",
      "2005, 1\n",
      "termed 1\n",
      "port 1\n",
      "cargo 1\n",
      "busiest 1\n",
      "seaport. 1\n",
      "handled 1\n",
      "29 1\n",
      "million 1\n",
      "teus 1\n",
      "2010, 2\n",
      "25% 1\n",
      "industrial 1\n",
      "output 1\n",
      "comes 1\n",
      "out 1\n",
      "produces 1\n",
      "30% 1\n",
      "china’s 1\n",
      "gdp. 1\n",
      "end 1\n",
      "2009, 2\n",
      "there 2\n",
      "787 1\n",
      "financial 3\n",
      "institutions 1\n",
      "which 2\n",
      "170 1\n",
      "invested. 1\n",
      "stock 2\n",
      "exchange 2\n",
      "ranked 3\n",
      "third 2\n",
      "among 1\n",
      "worldwide 1\n",
      "exchanges 1\n",
      "terms 1\n",
      "traded 1\n",
      "volume 2\n",
      "trading 1\n",
      "six 1\n",
      "key 1\n",
      "commodities 1\n",
      "including 1\n",
      "rubber, 1\n",
      "copper 1\n",
      "zinc 1\n",
      "under 1\n",
      "future 1\n",
      "across 1\n",
      "latest 1\n",
      "edition 1\n",
      "center 3\n",
      "index 1\n",
      "published 1\n",
      "london. 1\n",
      "urban 1\n",
      "development 1\n",
      "uniquely 1\n",
      "cultural 2\n",
      "element 1\n",
      "shi 3\n",
      "ku 3\n",
      "residences, 1\n",
      "three 1\n",
      "storey 1\n",
      "townhouses. 1\n",
      "blend 1\n",
      "elements 1\n",
      "found 1\n",
      "architecture, 1\n",
      "traditional 1\n",
      "architecture 1\n",
      "social 1\n",
      "behavior. 1\n",
      "area 1\n",
      "classic 1\n",
      "stood 1\n",
      "been 1\n",
      "redeveloped 1\n",
      "modern 1\n",
      "few 1\n",
      "areas 1\n",
      "remaining. 1\n",
      "during 1\n",
      "1990s, 1\n",
      "agglomeration 1\n",
      "construction 1\n",
      "cranes; 1\n",
      "since 1\n",
      "2008, 1\n",
      "boasted 1\n",
      "free 1\n",
      "standing 1\n",
      "400 1\n",
      "meters 1\n",
      "any 1\n",
      "cities, 1\n",
      "currently 1\n",
      "tallest 2\n",
      "building 1\n",
      "world; 1\n",
      "future, 1\n",
      "tower, 1\n",
      "straight 1\n",
      "completion 1\n",
      "2014, 1\n",
      "will 1\n",
      "meanwhile, 1\n",
      "sinking 1\n",
      "1.5cm 1\n",
      "year. 1\n",
      "shanghai’s 1\n",
      "transit 1\n",
      "system, 1\n",
      "metro, 1\n",
      "extends 1\n",
      "every 2\n",
      "core 1\n",
      "neighbor 1\n",
      "districts 1\n",
      "suburban 1\n",
      "district. 1\n",
      "were12 1\n",
      "metro 1\n",
      "lines, 1\n",
      "273 1\n",
      "stations 1\n",
      "over 1\n",
      "420 1\n",
      "km 2\n",
      "tracks 1\n",
      "operation, 1\n",
      "making 1\n",
      "network 1\n",
      "shuttle 1\n",
      "maglev 1\n",
      "train 1\n",
      "linking 1\n",
      "airport 1\n",
      "built 1\n",
      "2004 1\n",
      "fastest 1\n",
      "passenger 1\n",
      "train, 1\n",
      "reaching 1\n",
      "maximum 1\n",
      "cruising 1\n",
      "speed 1\n",
      "431 1\n",
      "per 1\n",
      "hour. 1\n",
      "bus 2\n",
      "system 1\n",
      "planet 1\n",
      "1424 1\n",
      "lines. 1\n"
     ]
    }
   ],
   "source": [
    "# 字典： 词=>词频\n",
    "punc = [',', '.', '?']\n",
    "\n",
    "count_dic = {}\n",
    "for line in open(\"ShangHai.txt\", 'r', encoding='utf8'):\n",
    "    words = line.strip().split(\" \") #存放在list中\n",
    "    for word in words:\n",
    "        word = word.lower()\n",
    "        # 如果是标点，就跳过当前这次操作\n",
    "        #if word in punc:\n",
    "        #    continue\n",
    "        # 如果在字典中已经存在，把计数加1\n",
    "        if word in count_dic:\n",
    "            count_dic[word] += 1\n",
    "            #print(\"我当前看到的词是：\"+word)\n",
    "            #print(\"这个词出现了\"+str(count_dic[word])+\"次\")\n",
    "        # 如果不存在，第一次出现，把次数设为1\n",
    "        else:\n",
    "            count_dic[word] = 1\n",
    "\n",
    "for word, count in count_dic.items():\n",
    "    print(word, count)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "289cfe47-7d59-48cb-a5e5-acb9046ff717",
   "metadata": {},
   "source": [
    "## Python 中内存回收机制\n",
    "\n",
    "- Python本身是一个高层次的结合了解释性、编译性、互动性和面向对象的动态脚本语言。与大多数编程语言c/c++/java不同。Python中的变量无需事先申明，不需要事先定义变量开辟内存空间，然后给变量赋值，存储到变量的内存空间中。使用结束，当然也不需要你去手动调用析构函数释放内存了。即程序员无需关心内存管理，Python解释器给你自动回收。开发人员不用过多的关心内存管理机制, 这一切全部由 python内存管理器承担了复杂的内存管理工作。\n",
    "\n",
    "- Python会预先申请一部分内存空间，在运行时定义了变量-对象，根据对象确认它的type，将对象放到申请的内存中，Python每过一段时间就来检查一次，当有对象的引用为0时，就回收这块内存，返还回先申请的内存空间，而不是计算机。这样避免了内存碎片过多问题。\n",
    "\n",
    "- 内存泄漏（Memory Leak）是指程序中己动态分配的堆内存由于某种原因程序未释放或无法释放，造成系统内存的浪费，导致程序运行速度减慢甚至系统崩溃等严重后果。\n",
    "    - Python 会为变量维护引用记数器 ，这是 Python 垃圾回收机制的基础，如果一个对象的引用数量不为 0 那么是不会被垃圾回收的；\n",
    "    - 因此如果在程序中恰好有方法造成了循环引用或通过某种方式使得引用数量无法降至0，则变量无法被回收， 在批量处理大量任务时内存占用便会不断提升\n",
    "    - 内存泄漏最直接的现象就是 Python 占用的内存量不断增加，直至内存溢出\n",
    "\n",
    "- Refs:\n",
    "    - [Python小白（二十一）：深/浅拷贝+内存回收机制+避免内存泄漏](https://zhuanlan.zhihu.com/p/368065134)\n",
    "    - [简书：python 内存管理，内存泄漏](https://www.jianshu.com/p/c2c960481011)\n",
    "    - [【Python基础】什么是Python的 “内存管理机制”](https://blog.csdn.net/fengdu78/article/details/108332789?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522165147898816781483781053%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=165147898816781483781053&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-1-108332789.142%5Ev9%5Econtrol,157%5Ev4%5Econtrol&utm_term=python%E5%86%85%E5%AD%98%E7%AE%A1%E7%90%86%E6%9C%BA%E5%88%B6&spm=1018.2226.3001.4187)\n",
    "    - [Python 弱引用 weakref](https://www.zywvvd.com/notes/coding/python/python-weakref/python-weakref/)\n",
    "    - [腾讯云-开发者社区：python 内存泄漏](https://cloud.tencent.com/developer/article/2069006)\n",
    "    - [Understanding and Detecting Memory Leaks in Python](https://www.linkedin.com/pulse/understanding-detecting-memory-leaks-python-gehan-fernando/)\n",
    "    - [官方文档：tracemalloc --- 跟踪内存分配](https://docs.python.org/zh-cn/3.10/library/tracemalloc.html)\n",
    "\n",
    "\n",
    "- 怎么减少对象的引用\n",
    "    1. 将变量引用指向其他对象\n",
    "    2. 删除变量（对象的引用）\n",
    "\n",
    "总结：回收机制为判断对象引用是否为0，如果为零就回收内存到自己申请的内存空间，不是计算机硬盘。\n",
    "\n",
    "- 再谈不可变类型\n",
    "    - 当定义变量为数字、字符串、tuple、布尔值时，这些变量所对应的对象在内存空间的值是不可改变了，你重新赋值，也只是把变量引用指向了另一个对象，id变了，本身那个对象是不可变的。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ee8cefc-787d-474d-a8e3-8ad5f74eb0d8",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "- 引用计数机制：可以对“非循环引用”变量进行垃圾回收\n",
    "\n",
    "Python通过引用计数来保存内存中的变量追踪，即记录该对象被其他使用的对象引用的次数。当某个对象的引用计数为0时，就列入了垃圾回收队列。查看对象的引用计数：sys.getrefcount()。\n",
    "\n",
    ">注意：当把a作为参数传递给 `sys.getrefcount()` 时，会产生一个临时的引用，因此结果比真实情况+1。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 227,
   "id": "bc25f386-e327-409c-8f59-114845b56323",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import sys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "id": "ad873fb0-0c0b-4cda-89ba-65ce508fc166",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 228,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [1, 2]\n",
    "sys.getrefcount(a) # 获取对象a的引用次数的同时，引用次数还+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "id": "d2fd2f1c-6b00-4e53-9352-53778ddd947b",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 229,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = a  # 增加b的引用，a的引用次数+1\n",
    "sys.getrefcount(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "id": "abdf279a-ac40-436d-afa2-8bf88f18e094",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 230,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del b  # 删除b的引用，a的引用次数-1\n",
    "sys.getrefcount(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "id": "657372c4-a412-47c2-99f9-474c0ff6ce69",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 231,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = list()\n",
    "c.append(a)  # 增加c的引用，a的引用次数+1\n",
    "sys.getrefcount(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "id": "29cc4d33-2801-41b2-9858-ef9d932e1d19",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 232,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del c  # 删除c的引用，a的引用次数-1\n",
    "sys.getrefcount(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "id": "8878e267-d570-44e2-9102-880b0ebfda95",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 233,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=[3,4]  # 重新赋值，以前关于a引用被释放\n",
    "sys.getrefcount(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b7bf8c6-4dd0-47db-9b9f-d725e80044ba",
   "metadata": {},
   "source": [
    "下面这些情况引用计数+1：\n",
    "\n",
    "- 对象被创建：a=4\n",
    "- 引用被复制：y=x\n",
    "- 被作为参数传递给函数：f(x)\n",
    "- 作为容器对象的一个元素：a=[1,x] or c.append(a)\n",
    "\n",
    "下面这些情况引用计数-1:\n",
    "- 离开作用域。比如f(x)函数结束时，x指向的对象引用减1。\n",
    "- 引用被显式的销毁：del x\n",
    "- 对象的一个别名被赋值给其他对象：y=1\n",
    "- 对象从一个容器对象中移除：l.remove(x)\n",
    "- 容器对象本身被销毁：del l or del c。\n",
    "\n",
    "**循环引用**，就是一个对象直接或者间接引用自己本身,导致循环引用的对象引用计数器永不为0。\n",
    "\n",
    "```python\n",
    "class Test(object):\n",
    "    pass\n",
    "t1 = Test()\n",
    "t1.a = t1\n",
    "\n",
    "a, b = Test(), Test()\n",
    "a.attr_b = b\n",
    "b.attr_a = a\n",
    "```\n",
    "---\n",
    "```python\n",
    "l1=[]\n",
    "l2=[]\n",
    "l1.append(l2)\n",
    "l2.append(l1)\n",
    "```\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "id": "311c0f47-da47-49df-b41c-eb9caf10f238",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import weakref\n",
    "import sys\n",
    "\n",
    "def test_dict(dict_leak):\n",
    "    for index in range(10):\n",
    "        value = np.ones([1000, 1000, 1000])\n",
    "        dict_leak[index] = value\n",
    "        print(index,f'size of dict_leak: {round(sys.getsizeof(dict_leak[index]) / 10**9)} GB')\n",
    "    return dict_leak"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "id": "9269ae8d-28be-42a2-a921-d17f290857ef",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 size of dict_leak: 8 GB\n",
      "1 size of dict_leak: 8 GB\n",
      "2 size of dict_leak: 8 GB\n",
      "3 size of dict_leak: 8 GB\n",
      "4 size of dict_leak: 8 GB\n",
      "5 size of dict_leak: 8 GB\n",
      "6 size of dict_leak: 8 GB\n",
      "7 size of dict_leak: 8 GB\n",
      "8 size of dict_leak: 8 GB\n",
      "9 size of dict_leak: 8 GB\n",
      "memory usage chanegd is 80 GB (peak at 80 GB)\n"
     ]
    }
   ],
   "source": [
    "# importing the module\n",
    "import tracemalloc\n",
    "\n",
    "dict_leak = {}\n",
    "# dict_leak = weakref.WeakValueDictionary()\n",
    "\n",
    "# starting the monitoring\n",
    "tracemalloc.start()\n",
    "start, _ = tracemalloc.get_traced_memory()\n",
    "\n",
    "dict_leak = test_dict(dict_leak)\n",
    "\n",
    "# displaying the memory\n",
    "current, peak = tracemalloc.get_traced_memory()\n",
    "usage = round((current - start) / 10**9)\n",
    "print(f'memory usage chanegd is {usage} GB (peak at {round(peak/10**9)} GB)')\n",
    "\n",
    "# stopping the library\n",
    "tracemalloc.stop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "id": "3da47021-d346-41b8-ac1e-f41d75b5a5ba",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 size of dict_leak: 8 GB\n",
      "1 size of dict_leak: 8 GB\n",
      "2 size of dict_leak: 8 GB\n",
      "3 size of dict_leak: 8 GB\n",
      "4 size of dict_leak: 8 GB\n",
      "5 size of dict_leak: 8 GB\n",
      "6 size of dict_leak: 8 GB\n",
      "7 size of dict_leak: 8 GB\n",
      "8 size of dict_leak: 8 GB\n",
      "9 size of dict_leak: 8 GB\n",
      "memory usage chanegd is 0 GB (peak at 16 GB)\n"
     ]
    }
   ],
   "source": [
    "# importing the module\n",
    "import tracemalloc\n",
    "\n",
    "# dict_leak = {}\n",
    "dict_leak = weakref.WeakValueDictionary()\n",
    "\n",
    "# starting the monitoring\n",
    "tracemalloc.start()\n",
    "start, _ = tracemalloc.get_traced_memory()\n",
    "\n",
    "dict_leak = test_dict(dict_leak)\n",
    "\n",
    "# displaying the memory\n",
    "current, peak = tracemalloc.get_traced_memory()\n",
    "usage = round((current - start) / 10**9)\n",
    "print(f'memory usage chanegd is {usage} GB (peak at {round(peak/10**9)} GB)')\n",
    "\n",
    "# stopping the library\n",
    "tracemalloc.stop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "id": "7bd342b1-1e25-488d-a1c1-c90be9e172a4",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 239,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict_leak.data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80a8e054-9310-43f5-9a7d-ac18e093c42b",
   "metadata": {},
   "source": [
    "`WeakValueDictionary` 类实现的是一种可变映射，里面的值是对象的弱引用。\n",
    "\n",
    "被引用的对象在程序中的其他地方被当作垃圾回收后，对应的键会自动从 `WeakValueDictionary` 中删除。\n",
    "\n",
    "因此，`WeakValueDictionary` 经常用于缓存。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b95a0204-e33f-447d-9eda-eec4844fc291",
   "metadata": {},
   "source": [
    "## Python 中的常见标准库（模块）\n",
    "\n",
    "\n",
    "- `os` / `sys` （操作系统接口/与解释器交互的接口）\n",
    "    - `os.getcwd()` / `os.listdir()` / `os.mkdir()` / `os.remore()` / `os.system()` / ...\n",
    "    - `os.sys.path` / `sys.path` / `sys.argv` / `sys.stdout` / `sys.stdin` / `sys.stderr` / ...\n",
    "- math / random / statistics （数学、随机数、统计）\n",
    "    - `random.random()` / `random.sample()` / `random.seed()` / ...\n",
    "- `glob` （文件通配符）\n",
    "- `urllib.request`  / `smtplib` （互联网访问/邮件发送）\n",
    "- `time` / `datetime` （日期与时间格式化）\n",
    "    - [官方教程：strftime() and strptime() Behavior](https://docs.python.org/zh-cn/3/library/datetime.html#strftime-and-strptime-behavior)\n",
    "- `logging` （日志） [loguru](https://github.com/Delgan/loguru)\n",
    "- `re` （字符串的模式匹配 - 正则表达式）\n",
    "- ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6c8707be-d768-4d04-944b-e0a61df62d19",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# 关于 datetime 的转换\n",
    "from datetime import datetime, timedelta\n",
    "now = datetime.today()\n",
    "now.strftime(\"%m-%d-%y %H:%M:%S. %d %b %Y is a %A on the %d day of %B.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba266c0a-ecfa-44f9-bd7d-8f54d1a32672",
   "metadata": {},
   "source": [
    "- [官方教程：timedelta-objects](https://docs.python.org/zh-cn/3/library/datetime.html#timedelta-objects)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0393ee11-47d5-4b4b-882a-2806069ad73d",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# 关于 datetime 的运算\n",
    "delta30 = timedelta(days=30)\n",
    "datetime.today() - delta30"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc840f58-5538-446a-9a84-ef7d3736d926",
   "metadata": {},
   "source": [
    "## Python 编程语言的进阶途径\n",
    "\n",
    "See slide: https://slides.com/iphysresearch/gwda_coding_2_python"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6262535-d93a-4964-a998-2f10cfcc2653",
   "metadata": {},
   "source": [
    "## Python cheatsheet\n",
    "\n",
    "![](python-cheatsheet1.png)\n",
    "![](python-cheatsheet2.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9d3597de-0718-4aec-ba54-637c62935b36",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.10.13"
  },
  "toc-autonumbering": true,
  "toc-showcode": false
 },
 "nbformat": 4,
 "nbformat_minor": 5
}