Full Code of selfteaching/the-craft-of-selfteaching for AI

Repository: selfteaching/the-craft-of-selfteaching
Branch: master
Commit: 38b0bcaed374
Files: 125
Total size: 5.4 MB

Directory structure:
gitextract_bi0dj80t/

├── .gitignore
├── .vs/
│   ├── VSWorkspaceState.json
│   └── the-craft-of-selfteaching/
│       └── v16/
│           └── .suo
├── 00.cover.ipynb
├── 01.preface.ipynb
├── 02.proof-of-work.ipynb
├── Part.1.A.better.teachyourself.ipynb
├── Part.1.B.why.start.from.learning.coding.ipynb
├── Part.1.C.must.learn.sth.only.by.reading.ipynb
├── Part.1.D.preparation.for.reading.ipynb
├── Part.1.E.1.entrance.ipynb
├── Part.1.E.2.values-and-their-operators.ipynb
├── Part.1.E.3.controlflow.ipynb
├── Part.1.E.4.functions.ipynb
├── Part.1.E.5.strings.ipynb
├── Part.1.E.6.containers.ipynb
├── Part.1.E.7.files.ipynb
├── Part.1.F.deal-with-forward-references.ipynb
├── Part.1.G.The-Python-Tutorial-local.ipynb
├── Part.2.A.clumsy-and-patience.ipynb
├── Part.2.B.deliberate-practicing.ipynb
├── Part.2.C.why-start-from-writing-functions.ipynb
├── Part.2.D.1-args.ipynb
├── Part.2.D.2-aargs.ipynb
├── Part.2.D.3-lambda.ipynb
├── Part.2.D.4-recursion.ipynb
├── Part.2.D.5-docstrings.ipynb
├── Part.2.D.6-modules.ipynb
├── Part.2.D.7-tdd.ipynb
├── Part.2.D.8-main.ipynb
├── Part.2.E.deliberate-thinking.ipynb
├── Part.3.A.conquering-difficulties.ipynb
├── Part.3.B.1.classes-1.ipynb
├── Part.3.B.2.classes-2.ipynb
├── Part.3.B.3.decorator-iterator-generator.ipynb
├── Part.3.B.4.regex.ipynb
├── Part.3.B.5.bnf-ebnf-pebnf.ipynb
├── Part.3.C.breaking-good-and-bad.ipynb
├── Part.3.D.indispensable-illusion.ipynb
├── Part.3.E.to-be-thorough.ipynb
├── Part.3.F.social-selfteaching.ipynb
├── Part.3.G.the-golden-age-and-google.ipynb
├── Part.3.H.prevent-focus-drifting.ipynb
├── Q.good-communication.ipynb
├── R.finale.ipynb
├── README.md
├── S.whats-next.ipynb
├── T-appendix.editor.vscode.ipynb
├── T-appendix.git-introduction.ipynb
├── T-appendix.jupyter-installation-and-setup.ipynb
├── T-appendix.symbols.ipynb
├── from-readers/
│   ├── Cat-self-teaching-stories/
│   │   └── aftermy14dayscamptrial.md
│   ├── baichangping-self-teachingpython-stories/
│   │   └── baichangping-self-teachingpython-stories.md
│   ├── junhong-self-teaching-story.md
│   ├── leask-self-taught-stories.md
│   ├── liujuanjuans-self-taught-stories.md
│   ├── liuyunxin-self-teaching-storise.md
│   ├── lyric-self-teaching-stories.md
│   ├── shuimu0579-self-taught-stories.md
│   ├── sxuya-selfteaching-story.md
│   ├── xiaoqiang-self-teaching-stories.md
│   ├── zhangmmin-selfteaching-camp-story.md
│   └── zhangqis-self-taught-stories.md
├── hdi-china-1870-2015.txt
├── life-expectancy-china-1960-2016.txt
├── markdown/
│   ├── 00.cover.md
│   ├── 01.preface.md
│   ├── 02.proof-of-work.md
│   ├── Part.1.A.better.teachyourself.md
│   ├── Part.1.B.why.start.from.learning.coding.md
│   ├── Part.1.C.must.learn.sth.only.by.reading.md
│   ├── Part.1.D.preparation.for.reading.md
│   ├── Part.1.E.1.entrance.md
│   ├── Part.1.E.2.values-and-their-operators.md
│   ├── Part.1.E.3.controlflow.md
│   ├── Part.1.E.4.functions.md
│   ├── Part.1.E.5.strings.md
│   ├── Part.1.E.6.containers.md
│   ├── Part.1.E.7.files.md
│   ├── Part.1.F.deal-with-forward-references.md
│   ├── Part.1.G.The-Python-Tutorial-local.md
│   ├── Part.2.A.clumsy-and-patience.md
│   ├── Part.2.B.deliberate-practicing.md
│   ├── Part.2.C.why-start-from-writing-functions.md
│   ├── Part.2.D.1-args.md
│   ├── Part.2.D.2-aargs.md
│   ├── Part.2.D.3-lambda.md
│   ├── Part.2.D.4-recursion.md
│   ├── Part.2.D.5-docstrings.md
│   ├── Part.2.D.6-modules.md
│   ├── Part.2.D.7-tdd.md
│   ├── Part.2.D.8-main.md
│   ├── Part.2.E.deliberate-thinking.md
│   ├── Part.3.A.conquering-difficulties.md
│   ├── Part.3.B.1.classes-1.md
│   ├── Part.3.B.2.classes-2.md
│   ├── Part.3.B.3.decorator-iterator-generator.md
│   ├── Part.3.B.4.regex.md
│   ├── Part.3.B.5.bnf-ebnf-pebnf.md
│   ├── Part.3.C.breaking-good-and-bad.md
│   ├── Part.3.D.indispensable-illusion.md
│   ├── Part.3.E.to-be-thorough.md
│   ├── Part.3.F.social-selfteaching.md
│   ├── Part.3.G.the-golden-age-and-google.md
│   ├── Part.3.H.prevent-focus-drifting.md
│   ├── Q.good-communiation.md
│   ├── R.finale.md
│   ├── README.md
│   ├── S.whats-next.md
│   ├── T-appendix.editor.vscode.md
│   ├── T-appendix.git-introduction.md
│   ├── T-appendix.jupyter-installation-and-setup.md
│   ├── T-appendix.symbols.md
│   └── TOC.md
├── my-notes/
│   ├── how-to-merge.md
│   ├── 老生常谈的思考
│   ├── 自学笔记--emhodo.md
│   └── 自学笔记（python篇）--emhodo.md
├── mycode.py
├── regex-target-text-sample.txt
├── results.txt
├── symbols.numbers
├── test-file.txt
├── that.py
└── words_alpha.txt

================================================
FILE CONTENTS
================================================

================================================
FILE: .gitignore
================================================
.python-version

.DS_Store
.ipynb_checkpoints/
__pycache__
**/.DS_Store
**/.ipynb_chechpoints
**/__pycache__
log.txt
**/log.txt

================================================
FILE: .vs/VSWorkspaceState.json
================================================
{
  "ExpandedNodes": [
    "",
    "\\from-readers\\lyric-self-teaching-stories",
    "\\my-notes"
  ],
  "SelectedNode": "\\my-notes\\how-to-merge.md",
  "PreviewInSolutionExplorer": false
}

================================================
FILE: 00.cover.ipynb
================================================
{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 自学是门手艺\n",
    "\n",
    "> One has no future if one couldn't teach themself<a href='#fn1' name='fn1b'><sup>[1]</sup></a>.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**作者：李笑来**\n",
    "\n",
    "特别感谢**霍炬**（[@virushuo](https://github.com/huo-ju)）、**洪强宁**（[@hongqn](https://github.com/hongqn)) 两位良师诤友在此书写作过程中给予我的巨大帮助！\n",
    "\n",
    "```python\n",
    "# pseudo-code of selfteaching in Python\n",
    "\n",
    "def teach_yourself(anything):\n",
    "    while not create():\n",
    "        learn()\n",
    "        practice()\n",
    "    return teach_yourself(another)\n",
    "\n",
    "teach_yourself(coding)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 目录\n",
    "\n",
    "> - [01.preface（**前言**）](01.preface.ipynb)\n",
    "> - [02.proof-of-work（**如何证明你真的读过这本书？**）](02.proof-of-work.ipynb)\n",
    "> - [Part.1.A.better.teachyourself（**为什么一定要掌握自学能力？**）](Part.1.A.better.teachyourself.ipynb)\n",
    "> - [Part.1.B.why.start.from.learning.coding（**为什么把编程当作自学的入口？**）](Part.1.B.why.start.from.learning.coding.ipynb)\n",
    "> - [Part.1.C.must.learn.sth.only.by.reading（**只靠阅读习得新技能**）](Part.1.C.must.learn.sth.only.by.reading.ipynb)\n",
    "> - [Part.1.D.preparation.for.reading（**开始阅读前的一些准备**）](Part.1.D.preparation.for.reading.ipynb)\n",
    "> - [Part.1.E.1.entrance（**入口**）](Part.1.E.1.entrance.ipynb)\n",
    "> - [Part.1.E.2.values-and-their-operators（**值及其相应的运算**）](Part.1.E.2.values-and-their-operators.ipynb)\n",
    "> - [Part.1.E.3.controlflow（**流程控制**）](Part.1.E.3.controlflow.ipynb)\n",
    "> - [Part.1.E.4.functions（**函数**）](Part.1.E.4.functions.ipynb)\n",
    "> - [Part.1.E.5.strings（**字符串**）](Part.1.E.5.strings.ipynb)\n",
    "> - [Part.1.E.6.containers（**数据容器**）](Part.1.E.6.containers.ipynb)\n",
    "> - [Part.1.E.7.files（**文件**）](Part.1.E.7.files.ipynb)\n",
    "> - [Part.1.F.deal-with-forward-references（**如何从容应对含有过多 “过早引用” 的知识？**）](Part.1.F.deal-with-forward-references.ipynb)\n",
    "> - [Part.1.G.The-Python-Tutorial-local（**官方教程：The Python Tutorial**）](Part.1.G.The-Python-Tutorial-local.ipynb)\n",
    "> - [Part.2.A.clumsy-and-patience（**笨拙与耐心**）](Part.2.A.clumsy-and-patience.ipynb)\n",
    "> - [Part.2.B.deliberate-practicing（**刻意练习**）](Part.2.B.deliberate-practicing.ipynb)\n",
    "> - [Part.2.C.why-start-from-writing-functions（**为什么从函数开始？**）](Part.2.C.why-start-from-writing-functions.ipynb)\n",
    "> - [Part.2.D.1-args（**关于参数（上）**）](Part.2.D.1-args.ipynb)\n",
    "> - [Part.2.D.2-aargs（**关于参数（下）**）](Part.2.D.2-aargs.ipynb)\n",
    "> - [Part.2.D.3-lambda（**化名与匿名**）](Part.2.D.3-lambda.ipynb)\n",
    "> - [Part.2.D.4-recursion（**递归函数**）](Part.2.D.4-recursion.ipynb)\n",
    "> - [Part.2.D.5-docstrings（**函数的文档**）](Part.2.D.5-docstrings.ipynb)\n",
    "> - [Part.2.D.6-modules（**保存到文件的函数**）](Part.2.D.6-modules.ipynb)\n",
    "> - [Part.2.D.7-tdd（**测试驱动的开发**）](Part.2.D.7-tdd.ipynb)\n",
    "> - [Part.2.D.8-main（**可执行的 Python 文件**）](Part.2.D.8-main.ipynb)\n",
    "> - [Part.2.E.deliberate-thinking（**刻意思考**）](Part.2.E.deliberate-thinking.ipynb)\n",
    "> - [Part.3.A.conquering-difficulties（**战胜难点**）](Part.3.A.conquering-difficulties.ipynb)\n",
    "> - [Part.3.B.1.classes-1（**类 —— 面向对象编程**）](Part.3.B.1.classes-1.ipynb)\n",
    "> - [Part.3.B.2.classes-2（**类 —— Python 的实现**）](Part.3.B.2.classes-2.ipynb)\n",
    "> - [Part.3.B.3.decorator-iterator-generator（**函数工具**）](Part.3.B.3.decorator-iterator-generator.ipynb)\n",
    "> - [Part.3.B.4.regex（**正则表达式**）](Part.3.B.4.regex.ipynb)\n",
    "> - [Part.3.B.5.bnf-ebnf-pebnf（**BNF 以及 EBNF**）](Part.3.B.5.bnf-ebnf-pebnf.ipynb)\n",
    "> - [Part.3.C.breaking-good-and-bad（**拆解**）](Part.3.C.breaking-good-and-bad.ipynb)\n",
    "> - [Part.3.D.indispensable-illusion（**刚需幻觉**）](Part.3.D.indispensable-illusion.ipynb)\n",
    "> - [Part.3.E.to-be-thorough（**全面 —— 自学的境界**）](Part.3.E.to-be-thorough.ipynb)\n",
    "> - [Part.3.F.social-selfteaching（**自学者的社交**）](Part.3.F.social-selfteaching.ipynb)\n",
    "> - [Part.3.G.the-golden-age-and-google（**这是自学者的黄金时代**）](Part.3.G.the-golden-age-and-google.ipynb)\n",
    "> - [Part.3.H.prevent-focus-drifting（**避免注意力漂移**）](Part.3.H.prevent-focus-drifting.ipynb)\n",
    "> - [Q.good-communiation（**如何成为优秀沟通者**）](Q.good-communication.ipynb)\n",
    "> - [R.finale（**自学者的终点**）](R.finale.ipynb)\n",
    "> - [S.whats-next（**下一步干什么？**）](S.whats-next.ipynb)\n",
    "> - [T-appendix.editor.vscode（**Visual Studio Code 的安装与配置**）](T-appendix.editor.vscode.ipynb)\n",
    "> - [T-appendix.git-introduction（**Git 简介**）](T-appendix.git-introduction.ipynb)\n",
    "> - [T-appendix.jupyter-installation-and-setup（**Jupyterlab 的安装与配置**）](T-appendix.jupyter-installation-and-setup.ipynb)\n",
    "> - [T-appendix.symbols（**这些符号都代表什么？**）](T-appendix.symbols.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "本书的版权协议为 [CC-BY-NC-ND license](https://creativecommons.org/licenses/by-nc-nd/3.0/deed.zh)。\n",
    "\n",
    "![CC-BY-NC-ND](images/CC-BY-NC-ND.png)\n",
    "\n",
    "-----\n",
    "**脚注**\n",
    "\n",
    "<a name='fn1'>[1]</a>：['Themselves' or 'themself'? -- Oxford Dictionary](https://en.oxforddictionaries.com/usage/themselves-or-themself)\n",
    "\n",
    "<a href='#fn1b'><small>↑Back to Content↑</small></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"./01.preface.ipynb\" ><small>Next Page</small></a>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  },
  "toc-autonumbering": false
 },
 "nbformat": 4,
 "nbformat_minor": 2
}


================================================
FILE: 01.preface.ipynb
================================================
{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "# 前言"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "\n",
    "想写一本关于自学能力的书，还真的不是一天两天的事，所以肯定不是心血来潮。\n",
    "\n",
    "等我快把初稿框架搭完，跟霍炬说起我正在写的内容时，霍炬说：\n",
    "\n",
    "> 你还记得吗，你第一次背个包来我家的时候，咱们聊的就是咋写本有意思的编程书……\n",
    "\n",
    "我说：\n",
    "\n",
    "> 真是呢！十三年就这么过去了……\n",
    "\n",
    "不过，这次真的写了。写出来的其实并不是，或者说，并不仅仅是 “一本编程书”。\n",
    "\n",
    "这本 “书” 是近些年我一直在做却没做完整的事情，讲清楚 “学习学习再学习”：\n",
    "\n",
    "> 学会学习之后再去学习……\n",
    "\n",
    "只不过，这一次我阐述地更具体 —— 不是 “学会学习”，而是 “学会自学” —— 这一点点的变化，让十多年前没写顺的东西，终于在这一次迎刃而解，自成体系。\n",
    "\n",
    "> 以前，我在写作课里讲，写好的前提就是 “Narrow down your topic” —— 把话题范围缩小缩小再缩小…… 这次算是给读者一个活生生的实例了罢。\n",
    "\n",
    "自学能力，对每个个体来说，是这个变化频率和变化幅度都在不断加大的时代里最具价值的能力。具备这个能力，不一定能直接增加一个人的幸福感（虽然实际上常常确实能），但它一定会缓解甚至消除一个人的焦虑 —— 若是在一个以肉眼可见的方式变化着的环境里生存，却心知肚明自己已然原地踏步许久，自己正在被这个时代甩在身后，谁能不焦虑呢？\n",
    "\n",
    "实际上，这些年来我写的书，都是关于学习的，无论是《[把时间当作朋友](https://github.com/xiaolai/time-as-a-friend)》，还是《通往财富自由之路》，甚至《韭菜的自我修养》，你去看就知道，背后都是同样的目标：学习、进步 —— 甚至**进化**。\n",
    "\n",
    "这一次的《自学是门手艺》，首先，可以看作是之前内容的 “实践版”：\n",
    "\n",
    "> 完成这本书的内容，起码会习得一个新技能：编程。\n",
    "\n",
    "更为重要的是，可以把《自学是门手艺》当作之前内容的 “升级版”：\n",
    "\n",
    "> 自学能力，是持续学习持续成长的发动机……\n",
    "\n",
    "仔细观察整个人群，你就会发现一个惊人且惊悚的事实：\n",
    "\n",
    "> **至少有 99% 的人终生都没有掌握自学能力！**\n",
    "\n",
    "其实这个数字根本不夸张。根据 2017 年的统计数据，从 1977 年到 2017 年，40 年间全国大学录取人数总计为 1.15 亿左右（11518.2 万），占全国人口数量的 10% 不到，另外，这其中一半以上是专科生…… 你觉得那些 4% 左右的本科毕业生中，带着自学能力走入社会的比例是多少？不夸张地讲，我觉得 1% 都是很高的比例了 —— 所以，前面提到的 99% 都是很客气的说法。\n",
    "\n",
    "绝大多数人，终其一生都没有自学过什么。他们也不是没学过，也不是没辛苦过，但事实却是：他们在有人教、有人带、有人逼的情况下都没真学明白那些基础知识…… 更可怕的是，他们学的那些东西中，绝大多数终其一生只有一个用处：考试。于是，考试过后，那些东西就 “考过即弃” 了…… 不得不承认，应试教育的确是磨灭自学能力的最有效方法。\n",
    "\n",
    "在随后的生活里，尽管能意识到自己应该学点什么，常有 “要是我也会这个东西就好了” 的想法，但基本上百分之百以无奈结束 —— 再也没有人教、再也没有人带、再也没有人逼…… 于是，每次 “决心重新做人” 都默默地改成 “继续做人” 而后逢年过节再次许愿 “重新做人”……\n",
    "\n",
    "这是有趣而又尴尬的真相：\n",
    "\n",
    "> 没有不学习的人。\n",
    "\n",
    "你仔细观察就知道了，就算被你认为不学无术的人，其实也在学习，只不过，他们的选择不同，他们想学的是投机取巧，并天天琢磨怎样才能更好地投机取巧……\n",
    "\n",
    "但他们不是最倒霉的人。最倒霉的人是那种人，也 “认真学了”，可总是最终落得个越来越焦虑的下场……\n",
    "经常有一些人指责另外一些人 “贩卖焦虑” —— 根据我的观察，这种指责的肤浅在于，焦虑不是被卖方贩卖的产品，焦虑其实是买方长期自行积累的结果。\n",
    "\n",
    "**别人无法贩卖给你焦虑，是你自己焦虑** —— 是你自己在为自己不断积累越来越多的焦虑……\n",
    "\n",
    "然而，又有谁不想解决掉焦虑呢？又有谁不想马上解决掉焦虑呢？\n",
    "\n",
    "于是，你焦虑，你就要找解决方案。而焦虑的你找到的解决方案，就是花个钱买本书，报个班，找个老师，上个课…… 这能说是别人贩卖焦虑给你吗？\n",
    "\n",
    "自学能力强的人，并非不花钱，甚至他们花的钱可能更多。他们也花钱买书，而且买更多的书；他们也可能花钱上课，而且要上就上最好的课、最好的班；他们更经常费尽周折找到恰当的人咨询、求教、探讨 —— 所以，事实上，他们更可能花了更多的钱……\n",
    "\n",
    "但自学能力强的人不焦虑，起码他们不会因为学习以及学习过程而焦虑 —— 这是重大差别。\n",
    "\n",
    "而焦虑的大多数，并不是因为别人贩卖焦虑给他们，他们才 “拥有” 那些焦虑 —— 他们一直在焦虑，并且越来越焦虑……\n",
    "\n",
    "为什么呢？总也学不会、学不好，换做是你，你不焦虑吗？！\n",
    "\n",
    "生活质量就是这样一点一点被消磨掉的 —— 最消耗生活质量的东西，就是焦虑。\n",
    "\n",
    "我相信，若是《自学是门手艺》这本书真的有用，它的重要用处之一就是能够缓解你的焦虑，让你明白，首先焦虑没用，其次，有办法也有途径让你摆脱过往一事无成的状况，逐步产生积累，并且逐步体会到那积累的作用，甚至最后还能感觉到更多积累带来的加速度…… 到那时候，焦虑就是 “别人的事情” 了。\n",
    "\n",
    "自学没有什么 “秘诀”。**它是一门手艺**，并且，严格意义上来讲，它**只是**一门手艺。\n",
    "\n",
    "手艺的特点就是**无需天分**。手艺的特点就是**熟练程度决定一切**。从这一点上来看，自学这门手艺和擀饺子皮没什么区别 —— 就那点事，刚开始谁都笨手笨脚，但熟练了之后，就那么回事…… 而已。\n",
    "\n",
    "做什么事都有技巧，这不可否认。\n",
    "\n",
    "自学当然也有技巧…… 不过，请做好思想准备：\n",
    "\n",
    "> 这儿的空间，**没什么新鲜**……\n",
    "\n",
    "—— 这是崔健一首歌里的歌词片段，但放在这里竟然非常恰当到位。\n",
    "\n",
    "**一切与自学相关的技巧都是老生常谈**。\n",
    "\n",
    "中国人说，熟能生巧；老外说，Practice makes perfect —— 你看，与自学相关的技巧，干脆不分国界……\n",
    "\n",
    "—— 因为这事人类从起点开始就没变过 —— 每代人都有足够多的人在自学这件事上挣扎…… 有成的有不成的；成的之中有大成有小成…… 可有一件事同样不变：留下的文字、留下的信息，都是大成或者小成之人留下的，不成的人不声不响就销声匿迹。\n",
    "\n",
    "并且，从各国历史上来看，自学技巧这个话题从未涉及到政治，无论是在东方还是西方都是如此。结果就是，在自学能力这个小领域中，留下并流传下来的信息，几乎从未被审查，从未被摧毁，从未被侵犯，从未被扭曲 —— 真的是个特别罕见的 “纯净的领域” —— 这真的是整个人类不可想像之意外好运。\n",
    "\n",
    "这就是为什么一切的自学技巧到最后肯定是老生常谈的原因。\n",
    "\n",
    "大部分年轻人讨厌老生常谈。\n",
    "\n",
    "但这还真的是被误导的结果。年轻人被什么误导了呢？\n",
    "\n",
    "每一代人都是新鲜出生，每一代人出生时都在同一水准…… 随着时间的推移，总是庸者占绝大多数，这个 “绝大多数” 不是 51%，不是 70%，而是 99%！—— 年轻人吃亏就吃在没把这个现象考虑进来。\n",
    "\n",
    "也就是说，虽然有用的道理在不断地传播，可终究还是 99% 的人做不到做不好，于是：\n",
    "\n",
    "> 讲大道理的更可能是庸者、失败者，而不是成功者。\n",
    "\n",
    "人类有很多天赋。就好像我反复提到的那样，“就算不懂也会用” 是人类的特长。同样的道理，人类在这方面同样擅长：\n",
    "\n",
    "> 无论自己什么样，在 “判断别人到底是不是真的很成功” 上，基本上有 99% 的把握……\n",
    "\n",
    "所以，十岁不到的时候，绝大多数小朋友就 “看穿” 了父母，后来再 “看穿” 了老师…… 发现他们整天说的都是他们自己做不到的事情…… 于是误以为自己 “看穿” 了整个世界。\n",
    "\n",
    "那时候小朋友们还没学、或者没学好概率这个重要知识，于是，他们并不知道那只不过是 99% 的情况，而且更不知道 “**因素的重要性与它所占的比例常常全无正相关**”，所以当然不知道那自己尚未见到的 `1%` 才可能是最重要的……\n",
    "\n",
    "于是，99% 的小朋友们一不小心就把自己 “搭了进去”：\n",
    "\n",
    "> 不仅讨厌老生常谈，而且偏要对着干，干着干着就把自己变成了另外一个属于那 99% 的另外一个老生……\n",
    "\n",
    "这是 99% 的人终其一生的生动写照。\n",
    "\n",
    "做 `1%` 很难吗？真的很简单，有时仅仅一条就可能奏效：\n",
    "\n",
    "> **在自学这件事上，重视一切老生常谈……**\n",
    "\n",
    "很难吗？不难，只不过是一个 “开关” 而已。\n",
    "\n",
    "当我动手写这本 “书” 的时候，是 47 岁那年（2019）的春节前 —— 显然，这个时候我也早就是一位 “老生” 了…… 并且，这些道理我已经前后讲了二十年！算是 “常谈” 甚至 “长谈” 了罢……\n",
    "\n",
    "开始在新东方教书那年，我 28 岁；用之前那一点三脚猫的编程能力辅助着去写《TOEFL 核心词汇 21 天突破》是 2003 年；后来写《[把时间当作朋友](https://github.com/xiaolai/time-as-a-friend)》是 2007 年，这本书的印刷版出版发行是在 2009 年；再后来陆续写了很多内容，包括没有纸质版发行只有在线版的《人人都能用英语》（2013）；以及因为在罗振宇的得到 App 上开专栏，把之前写过的《学习学习再学习》重构且扩充而出版的《通往财富自由之路》（2017）；甚至连《韭菜的自我修养》（2018）都是讲思考、学习、和认知升级的……\n",
    "\n",
    "说来说去，就那些事 —— **没什么新鲜**。\n",
    "\n",
    "这中间也有很多写了却没写完，或者因为写得自己不满意扔在柜子里的东西，比如《人人都是工程师》（2016）—— 哈！我就是这么坚韧，有了目标就会死不放弃…… 3 年后的今天，我终于用那个时候完全想不到的方式完成了当时的目标，并且，做到了很多 3 年前自己都完全想象不到的事情。\n",
    "\n",
    "在写当前这本《自学是门手艺》的过程中，我从一开始就干脆没想给读者带来什么 “新鲜” 的或者 “前所未见” 的自学技巧 —— 因为真的就没有，根本就没有什么新鲜的自学技巧…… 没有，真的没有 —— 至少，我自己这么久了还是真的没见识过。\n",
    "\n",
    "然而，我算是最终能做到的人。知道、得到、做到之间，均各不相同。\n",
    "\n",
    "二十年前，在拥挤的课堂里坐在台下听我讲课的小朋友们，绝大多数在当时应该没有想到他们遇到了这样一个人 —— 二十年后，刚认识我的人也不会自动知道我是这样的人。\n",
    "\n",
    "但是，这些年里，看到我在一点一点进步、从未原地踏步的人很多很多…… 我猜，所谓的 “榜样”，也不过如此了罢。\n",
    "\n",
    "不夸张地讲，这可能是当前世界上**最硬核的鸡汤书**了 —— 因为，虽然它就是鸡汤（李笑来自认就是个鸡汤作者），但它不是 “只是拿话糊弄你” 那种，也不是 “只不过是善意的鼓励” 那种，它是那种 “教会你人生最重要的技能” 的鸡汤，并且还不仅仅只有一种技能，起码两个：“自学能力” 和 “编程能力”…… 而这两个能力中的无论哪一种，都是能确定地提高读者未来收入的技能，对，就是 `100%` 地确定 —— 有个会计专业的人求职的时候说 “我还会编程” 且还能拿出作品，你看看他可不可能找不到工作？你看看他是不是能薪水更高？\n",
    "\n",
    "`#!` —— 这是个程序员能看懂的梗。\n",
    "\n",
    "关键在于，这个老生不是说说而已的老生，他是能够**做到**的人：\n",
    "\n",
    "> - 一个末流大学的会计专业毕业的人不得已去做了销售；\n",
    "> - 这个销售后来去国内最大的课外辅导机构当了 7 年 TOEFL/GRE/GMAT 老师；\n",
    "> - 这个英语老师后来同时成了很多畅销书、长销书的作者；\n",
    "> - 这个作者后来居然成了著名天使投资人；\n",
    "> - 这个投资人后来竟然写了本关于编程入门的书籍；\n",
    "> - 这本 “书” 最终竟然还是一个完整的产品，不仅仅是 “一本书”……\n",
    "\n",
    "然而呢？\n",
    "\n",
    "—— 然而，即便是这样的老生，也讲不出什么新鲜道理。\n",
    "\n",
    "因为啊，历史上留下来的所有关于自学的技巧，都是人类史上最聪明的人留下来的 —— 你我这样的人，照做就可以了…… 现在你明白怎么回事了吧？\n",
    "\n",
    "**记住罢** ——\n",
    "\n",
    "> **千万不要一不小心就把自己搭进去……**\n",
    "\n",
    "<p style=\"text-align: right\"><strong>李笑来</strong></p>\n",
    "<p style=\"text-align: right\">初稿完成于 <em>2019</em> 年 <em>2</em> 月 <em>27</em> 日</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Next Page](./02.proof-of-work.ipynb)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}


================================================
FILE: 02.proof-of-work.ipynb
================================================
{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 如何证明你真的读过这本书？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 積ん読"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "日语里有个很好玩的词，“**積ん読**”（[tsundoku](https://en.wikipedia.org/wiki/Tsundoku)）：\n",
    "\n",
    "> 指那些买回来堆在那里还没读过的（甚至后来干脆不看了的）书……\n",
    "\n",
    "细想想，每个人都有很多很多 “積ん読”。小时候我们拿回家的教科书中就有相当一部分，其实就是 “積ん読”，虽然那时候掏钱买书的是父母，不仔细看、或者干脆不看的时候，也知道自己在偷懒…… 再后来就是 “主动犯罪” 了 —— 比如，很多人买到手里的英语词汇书是根本就没有翻到过第二个列表的，乃至于过去我常常开玩笑说，中国学生都认识一个单词，*abandon*，不是吗？这个单词是很多很多人 “决心重新做人” 而后 “就这样罢” 的铁板钉钉的见证者。\n",
    "\n",
    "在没有电子书的时代，印刷版书籍多少还有一点 “装饰品” 功用，可是到了电子书时代，谁知道你的设备里有多少付费书籍呢？攒下那么多，其实并没有炫耀的地方，给谁看呢？据说，Kindle 的后台数据里可以看到清楚的 “打开率”，大抵上也是在 $^1/_4$ ~ $^1/_3$ 之间，也就是说，差不多有 $^2/_3$ ~ $^3/_4$ 的电子书籍被购买下载之后，从来就没有被打开过。\n",
    "\n",
    "如此看来，付费之后并不阅读，只能欺骗一个对象了：自己。跟心理学家们之前想象的不同，我认为人们通常是不会欺骗自己的，至少很难 “故意欺骗自己”。所以，对于 “买了之后坚决不读” 这个现象，我不认为 “给自己虚妄的满足感” 是最好的解释。\n",
    "\n",
    "更朴素一点，更接近真相的解释是：\n",
    "\n",
    "> 那百分之七八十的人，其实是想着给自己一个希望……\n",
    "\n",
    "—— 等我有空了一定看。嗯。\n",
    "\n",
    "说来好笑，其实每个人共同拥有的目标之一是这样的：\n",
    "\n",
    "> 成为前百分之二十的少数人……\n",
    "\n",
    "然而，PK 掉百分之七八十的人的方法真的很简单很简单啊：\n",
    "\n",
    "> 把买来的书都真真切切地认真读过就可以了。\n",
    "\n",
    "这实在是太简单了罢？！可是…… 我知道你刚刚那个没出息的闪念：\n",
    "\n",
    "> 那我少买书甚至不买书不就可以了吗？\n",
    "\n",
    "你自己都知道这是荒谬的，却忍不住为你的小聪明得意 —— 其实吧，幸亏有你们在，否则我们怎么混进前百分之二十呢？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PoW"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "比特币这个地球上第一个真正被证明为可行的区块链应用中有一个特别重要的概念，叫做 “**工作证明**”（Proof of Work）—— 你干活了就是干活了，你没干活就是没干活，你的工作是可被证明的……\n",
    "\n",
    "借用这个思路，我设计了个方法，让你有办法证明自己就是看过这本书，就是读完了这本书 —— 你能向自己也向别人证明自己曾经的工作…… 是不是挺好？\n",
    "\n",
    "证明的方法是使用 [github.com](https://github.com) 这个网站以及版本控制工具 **git**。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 具体步骤"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "请按照以下步骤操作：\n",
    "\n",
    "> 1. 注册 [github.com](https://github.com) 帐号 —— 无论如何你都必须有 github 账户；\n",
    "> 2. 使用浏览器访问 [https://github.com/selfteaching/the-craft-of-selfteaching](https://github.com/selfteaching/the-craft-of-selfteaching)；\n",
    "> 3. 在页面右上部找到 “Fork” 按钮，将该仓库 Fork 到你自己的账户中；\n",
    "> 4. 使用 `git clone` 命令或者使用 [Desktop for Github](https://desktop.github.com/) 将 [the craft of selfteaching](https://github.com/selfteaching/the-craft-of-selfteaching) 这个你 Fork 过来的仓库克隆到本地；\n",
    "> 5. 按照 [Jupyterlab 的安装与配置](T-appendix.jupyter-installation-and-setup.ipynb) 的说明在本地搭建好 Jupyterlab —— 如果在 Jupyterlab 中浏览本书的话，其中的所有代码都是可以 “当场执行” 的，并且，你还可以直接改着玩……\n",
    "> 6. 在阅读过程中，可以不断通过修改文章中的代码作为练习 —— 这样做的结果就是已阅读过的文件会发生变化…… 每读完一章，甚至时时刻刻，你都可以通过 `git commit` 命令向你自己 Fork 过来的仓库提交变化 —— 这就是你的阅读工作证明；\n",
    "> 7. 仓库里有一个目录，`my-notes`，你可以把你在学习过程中写的笔记放在那里；\n",
    "> 8. 仓库里还有另外一个目录，`from-readers`；那是用来收集读者反馈的 —— 将来你可以写一篇《我的自学之路》，放在这个目录里，单独创建一个分支，而后提交 `pull request`，接受其他读者投票，若是达到一定的赞同率，那么你的文章就会被收录到主仓库中被更多人看到，激励更多的人像你一样走上自学之路……\n",
    "\n",
    "当然，为了这么做，你还要多学一样反正你早晚都必须学会的东西，Git —— 请参阅附录《[Git 入门](T-appendix.git-introduction.ipynb)》。\n",
    "\n",
    "时间就是这样，我们没办法糊弄它。而有了 git 这样的工具之后，我们在什么时候做了什么样的工作，是很容易证明的 —— 这对我们来说真是天大的好事。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 如何使用 Pull Request 为这本书校对"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "另外，在你阅读的过程中，发现有错别字啊、代码错误啊，甚至有 “更好的表述” 等等，都可以通过 `pull request` 来帮我改进 —— 这也是一种 “工作证明”。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(1) 使用浏览器访问 https://github.com/selfteaching/the-craft-of-selfteaching\n",
    "\n",
    "(2) 点击右上角的 “Fork 按钮”，将该仓库 Fork 到你的 Github 账户中\n",
    "\n",
    "![](images/github-fork.png)\n",
    "\n",
    "(3) 创建一个新分支，可以取名为 `from-<your_username>`，或是，`by git.basic.tutorial`；之后点击 Create Branch 建立新分支。\n",
    "\n",
    "![](images/github-new-branch.png)\n",
    "\n",
    "(4) 在新分支下进行修改某个文件，而后提交 —— 提交前不要嫌麻烦，一定要在 Comment 中写清楚修改说明：\n",
    "\n",
    "![](images/github-commit.png)\n",
    "\n",
    "以上示例图片中是修改了 README.md 文件 —— 事实上，你应该提交的是的确有必要的校对。\n",
    "\n",
    "另外，**请注意**：在创建分支之前，要将你的 Fork 更新到最新版。具体操作方法见下一节《如何在 Github 网站上将自己的 Fork 与原仓库同步》。\n",
    "\n",
    "(5) 在页面顶部选择 Pull request 标签：\n",
    "\n",
    "![](images/github-pull-request.png)\n",
    "\n",
    "而后点击 `Compare & pull request` 按钮 —— 如果看不到这个按钮，那就点击下面刚刚修改文件的链接，如上图中的 “Update README.md”（这是你刚刚提交修改时所填写的标题）。\n",
    "\n",
    "![](images/github-open-pull-request.png)\n",
    "\n",
    "确认无误之后，点击 `Create pull request` 按钮。\n",
    "\n",
    "![](images/github-create-pull-request.png)\n",
    "\n",
    "(6) 随后，Github 用户 [@xiaolai](https://github.com/xiaolai) —— 就是我，即，the-craft-of-selfteaching 这个仓库的所有者，会被通知有人提交了 Pull request，我会看到：\n",
    "\n",
    "![](images/github-confirm-merge.png)\n",
    "\n",
    "在我确认这个 Pull request 修改是正确的、可接受的之后，我就会按 `Merge pull request` 按钮 —— 如此这般，一个修正就由你我共同完成了。\n",
    "\n",
    "![](images/github-merged-pull-request.png)\n",
    "\n",
    "\n",
    "**注意**\n",
    "\n",
    "提交 Pull request 的时候，最佳策略如下：\n",
    "\n",
    "> * 提交 Pull request 之前，必须先将你的 Fork 的 master 与原仓库同步到最新；\n",
    "> * 从 master 创建 **新的 branch** 进行增补、修改等操作；\n",
    "> * 尽量每次只提交一个小修改；\n",
    "> * 提交时尽量简短且清楚地说明修改原因；\n",
    "> * 耐心等待回复。\n",
    "\n",
    "当自己的 Fork 过来的仓库已经被你在本地 “玩残” 了的时候，它千万不能被当作用来提交 Pull request 的版本。自己本地怎么玩都无所谓，但需要向别人提交 Pull request 的时候，必须重新弄一个当前最新版本到本地，而后再在其基础上修改。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 如何在 Github 网站上将自己的 Fork 与原仓库同步"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(1) 在你的 Fork 页面中如下图所示，点击 `Compare` 链接：\n",
    "\n",
    "![](images/sync-fork-1.png)\n",
    "\n",
    "(2) 将 `base repository` 更改成当前自己的 Fork，在图示中即为 `gitbasictutorial/the-craft-of-selfteaching`：\n",
    "\n",
    "![](images/sync-fork-2.png)\n",
    "\n",
    "(3) 这时候，页面会显示 `There isn't anything to compare.`，因为你在比较 “自己” 和 “自己”。点击 `compare across forks` 链接：\n",
    "\n",
    "![](images/sync-fork-3.png)\n",
    "\n",
    "(4) 将 `head repository` 更改成 Upstream Repository（即，上游仓库），在图示中即为 `selfteaching/the-craft-of-selfteaching`：\n",
    "\n",
    "![](images/sync-fork-4.png)\n",
    "\n",
    "(5) 稍等片刻，你会看到比较结果；而后你可以创建一个 Pull request —— 这是一个由你自己向你自己的 Fork 仓库提交的 Pull request：\n",
    "\n",
    "![](images/sync-fork-5.png)\n",
    "\n",
    "(6) 而后你在 `Pull requests` 标签页里会看到你刚刚提交的 Pull request：\n",
    "\n",
    "![](images/sync-fork-6.png)\n",
    "\n",
    "(7) 同意并合并之后的结果是，你的 Fork 与上游仓库同步完成了：\n",
    "\n",
    "![](images/sync-fork-7.png)\n",
    "\n",
    "当然，有时会出现一些你无法解决的问题，那么，还有一个最后的方法：\n",
    "\n",
    "> 将你的 Fork 删除，而后重新到 https://github.com/selfteaching/the-craft-of-selfteaching 页面按一次 `Fork` 按钮……"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 如何使用 github 记录自己的学习过程"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "你可以在本地建立一个分支（branch），例如，取名为 `study`：\n",
    "\n",
    "```bash\n",
    "git branch study\n",
    "git checkout study\n",
    "```\n",
    "\n",
    "如此这般之后，你在本地工作目录中所做的任何修改，都可以提交到 `study` 这个分支之中。\n",
    "\n",
    "你每次在 Jupyterlab 中浏览 `ipynb` 文件，按 `^ + Enter` 执行 code cell 中的代码的时候，该文件都会发生一些变化；你也可以随意修改文件中的任何地方，比如，添加一个 code cell，将某段代码从头至尾 “敲” 一遍；也可以修改某个 code cell 中的代码看看执行结果有什么不同；还可以添加或者修改任何 markdown cell —— 就当自己做笔记了……\n",
    "\n",
    "总而言之，当你阅读完某一章节并如上所说那样做了一些改动之后，那个 `ipynb` 文件就发生了一些变化。于是，你就可以执行以下命令：\n",
    "\n",
    "```bash\n",
    "git add .\n",
    "git commit -am 'my study result'\n",
    "git push\n",
    "```\n",
    "\n",
    "如此这般，在 `study` 这个分支中就记录着你的学习轨迹。\n",
    "\n",
    "当然，如果在这过程中，你发现本书自身有需要校对的地方，那么，你需要切换到 `master` 分支，执行以下命令：\n",
    "\n",
    "```bash\n",
    "git checkout master\n",
    "git pull\n",
    "```\n",
    "\n",
    "而后再修改，进而按照上一节的方法提交 Pull request。\n",
    "\n",
    "未来，在 [https://github.com/selfteaching](https://github.com/selfteaching) 下我会专门设置一个 repo，用来自动扫描 github 上本书的学习记录 —— 这种记录在过往的书籍当中是不可能存在的，然而，现在却可以了。在我看来，将来这种记录的作用甚至有可能比 “学历” 还要重要。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Next Page](./Part.1.A.better.teachyourself.ipynb)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}


================================================
FILE: Part.1.A.better.teachyourself.ipynb
================================================
{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "# 为什么一定要掌握自学能力？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "一句话解释清楚：\n",
    "\n",
    "> 没有自学能力的人没有**未来**。\n",
    "\n",
    "有两个因素需要深入考虑：\n",
    "\n",
    "> * 未来的日子还很长\n",
    "> * 这世界进步得太快\n",
    "\n",
    "我有个观察：\n",
    "\n",
    "> 很多人都会不由自主地去复刻父母的人生时刻表。\n",
    "\n",
    "比如，你也可能观察到了，父母晚婚的人自己晚婚的概率更高，父母晚育的人自己晚育的概率也更高……\n",
    "\n",
    "再比如，绝大多数人的内心深处，会不由自主地因为自己的父母在五十五岁的时候退休了，所以就默认自己也会在五十五岁前后退休…… 于是，到了四十岁前后的时候就开始认真考虑退休，在不知不觉中就彻底丧失了斗志，早早就活得跟已经老了很多岁似的。\n",
    "\n",
    "但是，这很危险，因为很多人完全没有意识到自己所面临的人生，与父母所面临的人生可能完全不一样 —— 各个方面都不一样。单举一个方面的例子，也是比较容易令人震惊的方面：\n",
    "\n",
    "> 全球范围内都一样，在过去的五十年里，人们的平均寿命预期增长得非常惊人……\n",
    "\n",
    "拿中国地区做例子，根据世界银行的数据统计，中国人在出生时的寿命预期，从 1960 年的 _43.73_ 岁，增长到了 2016 年的 _76.25_ 岁，56 年间的增幅竟然有 **74.39%** 之多！"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "data = np.genfromtxt('life-expectancy-china-1960-2016.txt',\n",
    "                     delimiter=',',\n",
    "                     names=['x', 'y'])\n",
    "da1960  = data[0][1]\n",
    "da2016  = data[-1][1]\n",
    "increase = (da2016 - da1960) / da1960\n",
    "note = 'from {:.2f} in 1960 to {:.2f} in 2016, increased  {:.2%}'\\\n",
    "    .format(da1960, da2016, increase)\n",
    "\n",
    "plt.figure(figsize=(10, 5))\n",
    "plt.plot(data['x'], data['y'])\n",
    "plt.ylabel('Life Expectancy from Birth')\n",
    "plt.tick_params(axis='x', rotation=70)\n",
    "plt.title('CHINA\\n' + note)\n",
    "\n",
    "# plt.savefig('life-expectancy-china-1960-2016.png', transparent=True)\n",
    "plt.show()\n",
    "\n",
    "# data from:\n",
    "# https://databank.worldbank.org/data/reports.aspx?source=2&series=SP.DYN.LE00.IN"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "如此发展下去，虽然人类不大可能永生不死，但平均寿命依然在持续延长是个不争的事实。与上一代不同，现在的千禧一代，需要面对的是百岁人生 —— 毫无疑问，不容置疑。\n",
    "\n",
    "这么长的人生，比默认的想象中可能要多出近一倍的人生，再叠加上另外一个因素 —— 这是个变化越来越快的世界 —— 会是什么样子？\n",
    "\n",
    "我是 1972 年出生的。从交通工具来看，我经历过出门只能靠步行，大街上都是牛车马车，机动车顶多见过拖拉机，到有自行车，到见过摩托车，到坐小汽车，到自己开车，到开有自动辅助驾驶功能的电动车…… 从阅读来看，我经历过只有新华书店，到有网络上的文字，到可以在当当上在线买到纸质书，到有了国际信用卡后可以在 Amazon 上第一时间阅读新书的电子版、听它的有声版，到现在可以很方便地获取最新知识的互动版，并直接参与讨论…… 从技能上来看，我经历过认为不识字是文盲，到不懂英语是文盲，到不懂计算机是文盲，到现在，不懂数据分析的基本与文盲无异……\n",
    "\n",
    "我也见识过很多当年很有用很赚钱很令人羡慕的技能 “突然” 变成几乎毫无价值的东西，最明显的例子是驾驶。也就是二十多年前，的哥还是很多人羡慕的职业呢！我本科的时候学的是会计专业，那时候我们还要专门练习打算盘呢！三十年之后的今天，就算有人打算盘打得再快，有什么具体用处嘛？我上中学的时候，有个人靠出版字帖赚了大钱 —— 那时候据说只要写字漂亮就能找到好工作；可今天，写字漂亮与否还是决定工作好坏的决定性因素吗？打印机很便宜啊！\n",
    "\n",
    "这两个因素叠加在一起的结果就是，这世界对很多人来说，其实是越来越残忍的。\n",
    "\n",
    "我见过太多的同龄人，早早就停止了进步，早早就被时代甩在身后，早早就因此茫然不知所措 —— 早早晚晚，你也会遇到越来越多这样的人。他们的共同特征只有一个：\n",
    "\n",
    "> 没有自学能力\n",
    "\n",
    "有一个统计指数，叫做人类发展指数（Human Development Index），它的曲线画出来，怎么看都有即将成为指数级上升的趋势。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "plt.figure(figsize=(10, 5))\n",
    "\n",
    "lebdata = np.genfromtxt('life-expectancy-china-1960-2016.txt',\n",
    "                        delimiter=',',\n",
    "                        names=['x', 'y'])\n",
    "\n",
    "hdidata = np.genfromtxt('hdi-china-1870-2015.txt',\n",
    "                        delimiter=',',\n",
    "                        names=['x', 'y'])\n",
    "\n",
    "\n",
    "plt.plot(hdidata['x'], hdidata['y'], label='Human Development Index')\n",
    "plt.tick_params(axis='x', rotation=70)\n",
    "plt.title('China: 1870 - 2015')\n",
    "\n",
    "plt.plot(lebdata['x'], lebdata['y'] * 0.005, label='Life Expectancy from Birth')\n",
    "plt.plot(secondary_y=True)\n",
    "\n",
    "plt.legend()\n",
    "\n",
    "# plt.savefig('human-development-index-china-1870-2015.png', transparent=True)\n",
    "plt.show()\n",
    "\n",
    "# link:\n",
    "# https://ourworldindata.org/human-development-index\n",
    "\n",
    "# data from:\n",
    "# blob:https://ourworldindata.org/44b6da71-f79e-42ab-ab37-871e4bd256e9"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "社会发展越来越快，你要面对的人生越来越长，在那一段与你的直觉猜想并不相同的漫漫人生路上，你居然没有磨练过自学能力，竟然只能眼睁睁地看着自己被甩下且无能为力，难道接下来要在那么长的时间里 “苦中作乐” 吗？\n",
    "\n",
    "没有未来的日子，怎么过呢？\n",
    "\n",
    "我本科学的是会计，研究生跑到国外读宏观经济学没读完，跑回国内做计算机硬件批发，再后来去新东方应聘讲授托福课程，离开新东方之后创业，再后来做投资，这期间不断地写书…… 可事实上，我的经历在这个时代并不特殊。有多少人在后来的职业生涯中所做的事情与当年大学里所学的专业相符呢？\n",
    "\n",
    "纽约联邦储蓄银行在 2012 年做过一个调查，发现人们的职业与自己大学所学专业相符的比例连 _30%_ 都不到。而且，我猜，这个比例会持续下降的 —— 因为这世界变化快，因为大多数教育机构与世界发展脱钩的程度只能越来越严重……"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "labels = ['Major Match', '']\n",
    "sizes = [273, 727]\n",
    "colors = ['#E2E2E2', '#6392BF']\n",
    "explode = (0, 0.08)\n",
    "plt.figure(figsize=(7, 7))\n",
    "plt.pie(sizes,\n",
    "        labels=labels,\n",
    "        explode=explode,\n",
    "        autopct='%1.1f%%',\n",
    "        colors=colors,\n",
    "        startangle=270,\n",
    "        shadow=True)\n",
    "# plt.savefig('major-match-job.png', transparent=True)\n",
    "plt.show()\n",
    "\n",
    "# data from:\n",
    "# https://libertystreeteconomics.newyorkfed.org/2013/05/do-big-cities-help-college-graduates-find-better-jobs.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "绝大多数人终生都饱受**时间幻觉**的拖累。\n",
    "\n",
    "小时候觉得时间太长，那是幻觉；长大了觉得时间越来越快，那还是幻觉 —— 时间从来都是匀速的。最大的幻觉在于，总是以为 “时间不够了” —— 这个幻觉最坑人。许多年前，有一次我开导我老婆。她说，“啊？得学五年才行啊？！太长了！” 我说，\n",
    "\n",
    "> “你回头看看呗，想想呗，五年前你在做什么？是不是回头一看的时候，五年前就好像是昨天？道理是一样的，五年之后的某一天你回头想今天，也是 ‘一转眼五年就过去’ 了…… 只不过，你今天觉得需要时间太多，所以不肯学 —— 但是，不管你学还是不学，五年还是会 ‘一转眼就过去’ 的…… 到时候再回头，想起这事的时候，没学的你，一定会后悔 —— 事实上，你已经有很多次后悔过 ‘之前要是学了就好了’，不是吗？”\n",
    "\n",
    "现在回头看，开导是非常成功的。十多年后的今天，她已经真的可以被称为 “自学专家” —— 各种运动在她那儿都不是事。健身，可以拿个北京市亚军登上健与美杂志封面；羽毛球，可以参加专业比赛；潜水，潜遍全球所有潜水胜地，到最后拿到的各种教练证比她遇到的各地教练的都多、更高级；帆船，可以组队横跨大西洋；爬山，登上喜马拉雅……"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "都说，人要有一技之长。那这一技究竟应该是什么呢？\n",
    "\n",
    "> 自学能力是唯一值得被不断磨练的长技。\n",
    "\n",
    "磨练出自学能力的好处在于，无论这世界需要我们学什么的时候，我们都可以主动去学，并且还是马上开始 —— 不需要等别人教、等别人带。\n",
    "\n",
    "哪怕有很强的自学能力的意思也并不是说，什么都能马上学会、什么都能马上学好，到最后无所不精无所不通…… 因为这里有个时间问题。无论学什么，都需要耗费时间和精力，与此同时更难的事情在于不断填补耐心以防它过早耗尽。另外，在极端的情况下，多少也面临天分问题。比如身高可能影响打篮球的表现，比如长相可能影响表演的效果，比如唱歌跑调貌似是很难修复的，比如有些人的粗心大意其实是基因决定的，等等。不过，以我的观察，无论是什么，哪怕只是学会一点点，都比不会强。哪怕只是中等水平，就足够应付生活、工作、养家糊口的需求。\n",
    "\n",
    "我在大学里学的是会计专业，毕业后找不到对口工作，只好去做销售 —— 没人教啊！怎么办？自学。也有自学不怎么样的时候，比如当年研究生课程我就读不完。后来想去新东方教书 —— 因为听说那里赚钱多 —— 可英语不怎么样啊！怎么办？自学。离开新东方去创业，时代早就变了，怎么办？自学，学的不怎么样，怎么办？硬挺。虽然创业这事后来也没怎么大成，但竟然在投资领域开花结果 —— 可赚了钱就一切平安如意了吗？并不是，要面对之前从来没可能遇到的一些险恶与困境，怎么办？自学。除了困境之外，更痛苦的发现在于对投资这件事来说，并没有受过任何有意义的训练，怎么办？自学。觉得自己理解的差不多了，一出手就失败，怎么办？接着学。\n",
    "\n",
    "我出身一般，父母是穷教师。出生在边疆小镇，儿时受到的教育也一般，也是太淘气 —— 后来也没考上什么好大学。说实话，我自认天资也一般，我就是那种被基因决定了经常马虎大意的人。岁数都这么大了，情商也都不是一般的差 —— 还是跟年轻的时候一样，经常莫名其妙就把什么人给得罪透了……\n",
    "\n",
    "但我过得一直不算差。\n",
    "\n",
    "靠什么呢？人么，一个都靠不上。到最后，我觉得只有一样东西真正可靠 —— **自学能力**。于是，经年累月，我磨练出了一套属于我自己的本领：只要我觉得有必要，我什么都肯学，学什么都能学会到够用的程度…… 编程，我不是靠上课学会的；英语，不是哪个老师教我的；写作，也不是谁能教会我的；教书，没有上过师范课程；投资，更没人能教我 —— 我猜，也没人愿意教我…… 自己用的东西自己琢磨，挺好。\n",
    "\n",
    "关键在于，自学这事并不难，也不复杂，挺简单的，因为它所需要的一切都很朴素。\n",
    "\n",
    "于是，从某个层面上来看，我每天都过的很开心。为什么？因为我有未来。凭什么那么确信？因为我知道我自己有自学能力。\n",
    "\n",
    "**—— 我希望你也有。**\n",
    "\n",
    "准确地讲，希望你有个更好的未来。\n",
    "\n",
    "而现在我猜，此刻，你心中也是默默如此作想的罢。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Next Page](./Part.1.B.why.start.from.learning.coding.ipynb)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  },
  "nteract": {
   "version": "nteract-on-jupyter@2.0.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}


================================================
FILE: Part.1.B.why.start.from.learning.coding.ipynb
================================================
{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 为什么把编程当作自学的入口？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "很多人误以为 “编程” 是很难的事情。\n",
    "\n",
    "…… 实则不然 —— 这恰恰是我们选择 “编程” 作为自学的第一个 “执行项目” 的原因。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "一本关于自学能力的书，若是真的能够起到作用，那么它就必须让读者在读之前和读之后不一样 —— 比如，之前可能没有自学能力，或者自学能力很差，之后就有了一定的自学能力……\n",
    "\n",
    "然而，这很难。不但对读者来说很难，对作者来说更难 —— 我当过那么多年被学生高度评价的老师，出版过若干本畅销且长销的书籍，所以更是清楚地知道例子的重要性。\n",
    "\n",
    "道理当然很重要；可是，在传递道理的时候，例子相对来看好像更重要。\n",
    "\n",
    "同样的道理，例子不准，人就可能会理解错；例子不精彩，人就可能听不进去；例子居然可以令人震惊，那就可以做到让听众、让读者 “永生不忘”。\n",
    "\n",
    "许多年前，有位后来在美国读书已经博士毕业了的学生来信，大意是说：\n",
    "\n",
    "> 好多年前，我在新东方上课，听您讲，人学习就好像是动物进化一样…… 很多人很早就开始停止了进化，本质上跟猴子没啥区别。\n",
    ">\n",
    "> 那段类比好长，我记不太清楚细节了…… 可是，当时我是出了一身汗的，因为我忽然觉得自己是一只猴子。可是，突然之间，我不想继续做猴子，更不想一直做猴子！\n",
    ">\n",
    "> 从那之后，我好像变了一个人似的…… 现在我已经博士毕业了，觉得应该写封信告诉您，我不再是猴子了，最起码是大猩猩，而且我保证，我会一直进化。\n",
    ">\n",
    "> ……\n",
    "\n",
    "所以啊，在我看来，写书讲课之前，最重要的工作，也是做得最多的事情，其实就是 “找到好例子” —— 那即意味着说，先要找到很多很多恰当合适的例子，而后再通过反复比较试验，挑出那个效果最好的例子。了解了这一点，将来你准备任何演讲，都会不由自主地多花一点时间在这方面，效果肯定比 “把幻灯片做得更花哨一些” 要好太多了罢？\n",
    "\n",
    "后来，我选中了一个例子：“**自学编程**” —— “*尽量只通过阅读学会编程*”。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## （一）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "选择它的理由，首先就在于：\n",
    "\n",
    "> 事实证明，**它就是无论是谁都能学会的** —— 千万别不信。\n",
    "\n",
    "它老少皆宜 —— 也就是说，“只要你愿意”，根本没有年龄差异。十二岁的孩子可以学；十八岁的大学生可以学；在职工作人员可以学…… 就算你已经退休了，想学就能学，谁也拦不住你。\n",
    "\n",
    "它也不分性别，男性可以学，女性同样可以学，性别差异在这里完全不存在。\n",
    "\n",
    "它也不分国界，更没有区域差异 —— 互联网的恩惠在于，你在北京、纽约也好，老头沟、门头沟也罢，在这个领域里同样完全没有任何具体差异。\n",
    "\n",
    "尤其是在中国。现状是，中国的人口密度极高，优质教育资源的确就是稀缺…… 但在计算机科学领域，所有的所谓 “优质教育资源” 事实上完全没有任何独特的竞争力 —— 编程领域，实际上是当今世上极为罕见的 “**教育机会公平之地**”。又不仅在中国如此，事实上，在全球范围内也都是如此。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## （二）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "编程作为 “讲解如何习得自学能力的例子”，实在是太好了。\n",
    "\n",
    "首先，编程这个东西反正要自学 —— 不信你问问计算机专业的人，他们会如实告诉你的，学校里确实也教，但说实话都教得不太好……\n",
    "\n",
    "其次，编程这个东西最适合 “仅靠阅读自学” —— 这个领域发展很快，到最后，新东西出来的时候，没有老师存在，任由你是谁，都只能去阅读 “官方文档”，只此一条路。\n",
    "\n",
    "然后，也是最重要的一条，别管是不是很多人觉得编程是很难的东西，事实上它就是每个人都应该具备的技能。\n",
    "\n",
    "许多年前，不识字，被称为文盲……\n",
    "\n",
    "后来，人们反应过来了，不识英文，也是文盲，因为科学文献的主导语言是英文，读不懂英文，什么都吃不上热乎的；等菜好不容易端上来了吧，早就凉了不说，味道都常常会变……\n",
    "\n",
    "再后来，不懂基本计算机操作技能的，也算是文盲，因为他们无论做什么事情，效率都太低下了，明明可以用快捷键一下子完成的事情，却非要手动大量重复……\n",
    "\n",
    "到了最近，不懂数据分析的，也开始算作文盲了。许多年前人们惊呼信息时代来了的时候，其实暂时体会不到什么太多的不同。然而，许多年过去，互联网上的格式化数据越来越多，不仅如此，实时产出的格式化数据也越来越多，于是，数据分析不仅成了必备的能力，而且早就开始直接影响一个人的薪资水平。\n",
    "\n",
    "你作为一个个体，每天都在产生各种各样的数据，然后时时刻刻都在被别人使用着、分析着…… 然而你自己却全然没有数据分析能力，甚至不知道这事很重要，是不是感觉很可怕？你看看周边那么多人，有多大的比例想过这事？反正那些天天看机器算法生成的信息流的人好像就是全然不在意自己正在被支配……\n",
    "\n",
    "怎么办？学呗，学点编程罢 —— 巧了，*这还真是个正常人都能学会的技能*。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## （三）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "编程作为 “讲解如何习得自学能力的例子” 最好的地方在于，这个领域的知识结构，最接近每个人所面对的人生中的知识结构。\n",
    "\n",
    "这是什么意思呢？\n",
    "\n",
    "编程入门的门槛之所以高，有个比较特殊的原因：\n",
    "\n",
    "> **它的知识点结构不是线性的**。\n",
    "\n",
    "我们在中小学里所遇到的教科书，其中每个章节所涉及到的知识点之间，全都是线性关联。第一章学好了，就有基础学第二章；在第二章的概念不会出现在第一章之中……\n",
    "\n",
    "很遗憾，编程所涉及到的知识点没办法这样组织 —— 就是不行。编程教材之所以难以读懂，就是因为它的各章中的知识点结构不是线性排列的。你经常在某一章读到不知道后面第几章才可能讲解清楚的概念。\n",
    "\n",
    "比如，几乎所有的 Python 编程书籍上来就举个例子：\n",
    "\n",
    "```python\n",
    "print('Hello, world!')\n",
    "```\n",
    "\n",
    "姑且不管这个例子是否意义非凡或者意义莫名，关键在于，`print()` 是个函数，而函数这个概念，不可能一上来就讲清楚，只能在后面若干章之后才开始讲解……\n",
    "\n",
    "> 想要理解当前的知识点，需要依赖对以后才能开始学习的某个甚至多个知识点的深入了解……\n",
    "\n",
    "这种现象，可以借用一个专门的英文概念，叫做 “**Forward References**” —— 原本是计算机领域里的一个[术语](https://en.wikipedia.org/wiki/Forward_declaration)。为了配合当前的语境，姑且把它翻译为 “**过早引用**” 罢，或者 “**前置引用**” 也行。\n",
    "\n",
    "学校里的课本，都很严谨 —— 任何概念，未经声明就禁止使用。所以，学完一章，就能学下一章；跳到某一章遇到不熟悉的概念，往前翻肯定能找到……\n",
    "\n",
    "在学校里习惯了这种知识体系的人，离开学校之后马上抓瞎 —— **社会的知识结构不仅不是这样的，而且*几乎全都不是*这样的**。工作中、生活里，充满了各式各样的 “*过早引用*”。为什么总是要到多年以后你才明白父母曾经说过的话那么有道理？为什么总要到孩子已经长大之后才反应过来当初自己对孩子做错过很多事情？为什么在自己成为领导之前总是以为他们只不过是在忽悠你？为什么那么多人创业失败了之后才反应过来当初投资人提醒的一些观念其实是千真万确的？—— 因为很多概念很多观念是 “过早引用”，在当时就是非常难以理解……\n",
    "\n",
    "自学编程在这方面的好处在于，在自学的过程中，其实你相当于过了一遍 “模拟人生” —— 于是，面对同样的 “*过早引用*”，你不会觉得那么莫名其妙，你有一套你早已在 “模拟人生” 中练就的方法论去应对。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## （四）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "另外一个把编程作为 “讲解如何习得自学能力的例子” 最好的地方在于，你在这个过程中将不得不习得英语 —— 起码是英文阅读能力，它能让你在不知不觉中 “脱盲”。\n",
    "\n",
    "学编程中最重要的活动就是 “阅读官方文档”。学 Python 更是如此。Python 有很多非常优秀的地方，其中一个令人无法忽视的优点就是它的文档完善程度极好。它甚至有专门的文档生成工具，[Sphinx](http://www.sphinx-doc.org/en/master/)：\n",
    "\n",
    "> Sphinx is a tool that makes it easy to create intelligent and beautiful documentation, written by Georg Brandl and licensed under the BSD license.\n",
    "> \n",
    "> It was originally created for [the Python documentation](https://docs.python.org/), and it has excellent facilities for the documentation of software projects in a range of languages. Of course, this site is also created from reStructuredText sources using Sphinx! \n",
    "\n",
    "最好的 Python 教程，是官方网站上的 [The Python Tutorial](https://docs.python.org/3/tutorial/index.html)，读它就够了。我个人完全没兴趣从头到尾写一本 Python 编程教材，不仅因为人家写得真好，而且它就放在那里。\n",
    "\n",
    "虽然你在官方网站上就是很难找到它的中文版，虽然就不告诉你到底在哪里也显得很不厚道，但是，我建议你就只看英文版 —— 因为离开了这个教程之后，还是要面对绝大多数都是英文的现实。\n",
    "\n",
    "为了照顾那些也想读完本书，但因为种种原因想着读中文可以快一些的人，链接还是放在这里：\n",
    "\n",
    "> * https://docs.python.org/zh-cn/3/tutorial/index.html (for v.3.7.2）\n",
    "> * http://www.pythondoc.com/pythontutorial3/ (for v.3.6.3)\n",
    "\n",
    "我曾经专门写过一本书发布在网上，叫《[人人都能用英语](https://github.com/xiaolai/everyone-can-use-english)》。其中的观点就是，大多数人之所以在英语这事上很矬，是因为他们花无数的时间去 _“学”_，但就是 _“不用”_。学以致用，用以促学。可就是不用，无论如何就是不用，那英语学了那么多年能学好吗？\n",
    "\n",
    "自学编程的一个 “副作用” 就是，**你不得不用英语**。而且还是天天用，不停地用。\n",
    "\n",
    "当年我上大学的时候，最初英语当然也不好。不过，因为想读当时还是禁书的《动物庄园》（[Animal Farm](https://www.marxists.org/subject/art/literature/children/texts/orwell/animal-farm/index.htm)），就只好看原版（当时好不容易搞到的是本英法对照版）…… 然后英语阅读就基本过关了。\n",
    "\n",
    "这原理大抵上是这样，刚开始，英语就好像一层毛玻璃，隔在你和你很想要了解的内容之间。然而，由于你对那内容的兴趣和需求是如此强烈，乃至于即便隔着毛玻璃你也会挣扎着去看清楚…… 挣扎久了（其实没两天就不一样），你的 “视力” 就进化了，毛玻璃还在那里，但你好像可以穿透它看清一切……\n",
    "\n",
    "自学编程，也算是一举两得了！"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": true
   },
   "source": [
    "## （五）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "当然，把编程作为 “讲解如何习得自学能力的例子”，实在是太好了的最重要原因在于，自学编程对任何人来说都绝对是：\n",
    "\n",
    "> * 现实的（Practical）\n",
    "> * 可行动的（Actionable）\n",
    "> * 并且还是真正是可达成的（Achievable）\n",
    "\n",
    "最重要的就是最后这个 “可达成的”。虽然对读者和作者来说，一个做到没那么容易，另一个讲清楚也非常难，但是，既然是所有人都 “可达成的”，总得试试吧？但是，请相信我，这事比减肥容易多了 —— 毕竟，你不是在跟基因作斗争。\n",
    "\n",
    "这只是个起点。\n",
    "\n",
    "尽量只靠阅读学会编程，哪怕仅仅是入门，这个经历和经验都是极为宝贵的。\n",
    "\n",
    "自学是门手艺。只不过它并不像卖油翁的手艺那样很容易被别人看到，也不是很容易拿它出来炫耀 —— 因为别人看不到么！然而，经年累月，就不一样了，那好处管他别人知不知道，自己却清楚得很！\n",
    "\n",
    "你身边总有些人能把别人做不好的事做得极好，你一定很羡慕。可他们为什么能做到那样呢？很简单啊，他们的自学能力强，所以他们能学会大多数自学能力差的人终生学不到的东西。而且他们的自学能力会越来越强，每学会一样新东西，他们就积累了更多自学经验，难以对外言表的经验，再遇到什么新东西，相对没那么吃力。\n",
    "\n",
    "另外，自学者最大的感受就是万物相通。他们经常说的话有这么一句：“…… **到最后，都是一样的呢**。” "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## （六）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最后一个好处，一句话就能说清楚，并且，随着时间的推移，你对此的感触会越来越深：\n",
    "\n",
    "> 在这个领域里，自学的人最多……\n",
    "\n",
    "没有什么比这句话更令人舒心的了：**相信我，你并不孤独**。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Next Page](./Part.1.C.must.learn.sth.only.by.reading.ipynb)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}


================================================
FILE: Part.1.C.must.learn.sth.only.by.reading.ipynb
================================================
{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": false
   },
   "source": [
    "# 只靠阅读习得新技能"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "习得自学能力的终极目标就是：\n",
    "\n",
    "> 有能力**只靠阅读**就能习得新技能。\n",
    "\n",
    "退而求其次，是 “尽量只靠阅读就习得新技能” —— 当然，刚开始的时候可能需要有人陪伴，一起学，一起讨论，一起克服困难…… 但就是要摆脱 “没人教，没人带，没人逼，就彻底没戏” 的状态。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "小时候总是听大人说：\n",
    "\n",
    "> 不是什么东西都可以从书本里学到的……\n",
    "\n",
    "一度，我觉得他们说的有道理。再后来，隐约感觉这话哪儿有毛病，但竟然又感觉无力反驳……\n",
    "\n",
    "那时，真被他们忽悠到了；后来，也差点被他们彻底忽悠到！\n",
    "\n",
    "幸亏后来我渐渐明白，且越来越相信：\n",
    "\n",
    "> 自己生活工作学习上遇到的所有疑问，书本里应该都有答案 —— 起码有所参考。\n",
    "\n",
    "“不是什么东西都可以从书本里学到的……” 这话听起来那么有道理，只不过是因为自己读书**不够多**、**不够对**而已。\n",
    "\n",
    "过了 25 岁，我放弃了读小说，虚构类作品，我只选择看电影；而非虚构类作品，我选择尽量只读英文书，虽然那时候买起来很贵也很费劲，但我觉得值 —— 英文世界和中文世界的文化风格略有不同。在英文世界里，你看到的正常作者好像更多地把 “通俗易懂”、“逻辑严谨” 当作最基本的素养；而在中文世界里，好像 “故弄玄虚”、“偷梁换柱” 更常见一些；在英文世界里，遇到读不懂的东西可以很平静地接受自己暂时的愚笨，心平气和地继续努力就好；在中文世界里，遇到装神弄鬼欺世盗名的，弄不好最初根本没认出来，到最后跟 “认贼作父” 一样令人羞辱难当不堪回首。\n",
    "\n",
    "说实话，我真觉得这事跟崇洋媚外没什么关系。我是朝鲜族，去过韩国，真觉得韩国的书更没法看（虽然明显是个人看法）…… 2015 年年底，我的律师告诉我，美国移民就快帮我办下来了，可那时候我开始觉得美国政府也各种乱七八糟，于是决定停止办理。我是个很宅的人，除了餐馆基本上哪儿都不去，陪家人朋友出去所谓旅游的时候，我只不过是换个房间继续宅着…… 可这些都不是重点，重点在于：\n",
    "\n",
    "> **知识原本就应该无国界**…… 不是吗？不是吗！\n",
    "\n",
    "再说，这些年我其实还读了不少中国人写的英文书呢，比如，张纯如的书很值得一看；郑念的 Life and Death in Shanghai，真的很好很好。我也读了不少老外写的关于中国的书 —— 这些年我一直推荐费正清的剑桥中国史（The Cambridge History of China），当然有中文版的，不过，能读英文版的话感受很不一样。\n",
    "\n",
    "当然，英文书里同样烂书也很多，烂作者也同样一大堆，胡说八道欺世盗名的一大串…… 但总体上来看，非小说类著作质量的确更高一点。\n",
    "\n",
    "还有，英语在科学研究领域早已成为 “主导语言”（Dominant Language）也是不争的事实。不过，英语成为主导语言的结果，就是英语本身被不断 “强奸”，外来语越来越多，“Long time no see” 被辞典收录就是很好的例子。事实上，英语本身就是个大杂烩……\n",
    "\n",
    "![Joseph M. Williams’ research visualized (top 10,000 words).](images/Joseph-M-Williams-research-visualized.png)<a href='https://medium.com/@andreas_simons/the-english-language-is-a-lot-more-french-than-we-thought-heres-why-4db2db3542b3'></a>\n",
    "\n",
    "读书越多越明白读书少会被忽悠…… 很多人真的会大头捣蒜一般地认同 “不是什么东西都可以从书本里学到的……”\n",
    "\n",
    "另外，很多人在如此教导小朋友的时候，往往是因为 “人心叵测” 啊，“江湖险恶” 啊，所以害怕小朋友吃亏。可事实上，如若说，人间那些勾心斗角的事貌似从书本里学不来的话，其实也不过还是历史书看少了 —— 勾心斗角的套路历史上全都被反复用过了。倒是有本中文书值得吐血推荐，民国时代的作者连阔如先生写的《江湖丛谈》，粗略扫过你就知道了，江湖那点事，也早就有人给你里里外外翻了个遍…… 只不过这书不太容易买到就是了。\n",
    "\n",
    "我也遇到过这样的反驳：\n",
    "\n",
    "> 书本能教会你做生意吗？！\n",
    "\n",
    "说实话，去回驳这个反驳还真挺难，因为反驳者是脑容量特别有限才能说出这种话 —— 世界上有那么多商学院都是干嘛的？搞得它们好像不存在一样。首先，它们的存在说明，商业这事是有迹可循的，是可学习的；其次，商业类书籍非常多，是非虚构类书籍中的一大品类；更为重要的是，做生意这事，看谁做 —— 有本事（即，比别人拥有更多技能）的人做生意和没本事的人做生意，用同样的商业技巧，能有一样的效果吗？最后啊，这世界在这方面从来没有变过：一技傍身的人，总是不愁生活……\n",
    "\n",
    "更为重要的是，这才几年啊，互联网本身已经成了一本大书 —— 关于全世界的一整本大书。仅仅是 10 多年前，大约在 2008 年前后，经过几年发展的 Wikipedia 被众多西方大学教授们群起而攻，指责它错误百出…… 可现在呢？Wikipedia 好像有天生的自我修复基因，它变得越来越值得信赖，越来越好用。\n",
    "\n",
    "七零后八零后长大的过程中，还经常被父母无故呵斥：“怎么就你事这么多！” 或者无奈敷衍：“等你长大了就明白了……” 九零后、零零后呢？他们很少有什么疑问需要向父母提问，直接问搜索引擎，效果就是父母们天天被惊到甚至吓到。最近两年更不一样了，我有朋友在旧金山生活，他的孩子整天跟 Google 说话，有点什么问题，就直接 “Hey Google...”\n",
    "\n",
    "我长大的那个年代，一句 “通过阅读了解世界” 好像还是很抽象甚至很不现实的话，现在呢？现在，除了阅读之外，你还能想出什么更有效的方法吗？反正我想不出。\n",
    "\n",
    "有个很有趣的现象：\n",
    "\n",
    "> 人么，只要识字，就忍不住阅读……\n",
    "\n",
    "只不过，人们阅读的选择很不同而已。有自学能力的人和没有自学能力的人，在这一点上很容易分辨：\n",
    "\n",
    "> * 有自学能力的人，选择阅读 “有繁殖能力” 的内容；\n",
    "> * 没有自学能力的人，阅读只是为了消磨时光……\n",
    "\n",
    "我把那些能给你带来新视野，能让你改变思考模式，甚至能让你拥有一项新技能的内容称之为 “有繁殖能力的内容”。\n",
    "\n",
    "人都一样，拥有什么样的能力之后，就会忍不住去用，甚至总是连下意识中也要用。\n",
    "\n",
    "那些靠阅读机器算法推送的内容而杀时间的人，恰恰就是因为他们有阅读能力才去不断地读，读啊读，像是那只被打了兴奋剂后来死在滚轮上的小白鼠。如果这些人哪怕有一点点自学能力，那么他们很快就会分辨出自己正在阅读的东西不会刺激自己的产出，只会消磨自己的时间；那么，他们就会主动放弃阅读那些杀时间的内容，把那时间和精力自然而然地用在筛选有繁殖能力的内容，让自己进步，让自己习得更多技能上去了。\n",
    "\n",
    "所以，只要你有一次 “**只靠阅读习得一项新技能**” 的经验，你就变成另外一个人了。你会不由自主、哪怕下意识里都会去运用你新习得的能力…… 从这个角度看，自学很上瘾！能上瘾，却不仅无害，还好处无穷，这样的好事，恐怕也就这一个了罢。\n",
    "\n",
    "我有过只靠阅读学会游泳的经历…… 听起来不像真的吧？更邪门的是，罗永浩同学的蛙泳，是我站在游泳池边，仅靠言语讲解，就让他从入水就扑腾开始三十分钟之内可以开始蛙泳的 —— 虽然当天他第一次蛙泳，一个来回五十米都坚持不下来。\n",
    "\n",
    "仅靠阅读学会新技能不仅是可能的，并且，你随后会发现的真相是：\n",
    "\n",
    "> 绝大多数情况下，没人能教你，也不一定有人愿意教你…… 到最后，你想学会或你必须学会什么东西的时候，**你只能靠阅读！** —— 因为其实你谁都靠不上……\n",
    "\n",
    "我有很多偶像，英国数学家乔治・布尔就是其中一个 —— 因为他就是个基本上只靠阅读自学成才的人。十八、九岁，就自学了微积分 —— 那是将近两百年前，没有 Google，没有 Wikipedia…… 然后他还自己创办了学校，给自己打工…… 从来没有上过大学，后来却被皇家学院聘请为该学院第一个数学教授。然后，人家发明的布尔代数，在百年之后引发了信息革命…… 达芬奇也是这样的人 —— 要说惨，他比所有人都惨…… 因为几乎从一开始就貌似没有谁有资格有能力教他。\n",
    "\n",
    "这些例子都太遥远了。给你讲个我身边的人，我亲自打过很长时间交道的人 —— 此人姓邱，人称邱老板。\n",
    "\n",
    "邱老板所写的区块链交易所引擎，在 Github 上用的是个很霸气的名字，“[貔貅](https://github.com/peatio/peatio)”（英文用了一个生造的词，Peatio）—— 这个 Repo 至 2019 年春节的时候，总计有 2,913 个 Star，有 2,150 个 Fork…… 绝对是全球这个领域中最受关注的开源项目。2017 年 9 月，云币应有关部门要求关闭之前，是全球排名前三的区块链交易所。\n",
    "\n",
    "邱老板当年上学上到几年级呢？初中未读完，所以，跟他聊天随口说成语是很有负担的，因为他真的可能听不懂…… 然而，他的编程、他的英语，全是自学的…… 学到什么地步呢？学到可以创造极有价值的商业项目的地步。他什么学习班都没上过，全靠阅读 —— 基本上只读互联网这本大书。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "讲真，你没有选择，只靠阅读习得新技能，这是你唯一的出路。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Next Page](Part.1.D.preparation.for.reading.ipynb)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}


================================================
FILE: Part.1.D.preparation.for.reading.ipynb
================================================
{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 开始阅读前的一些准备"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 内容概要"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "关于 Python 编程的第一部分总计 7 章，主要内容概括为：\n",
    "\n",
    "> 1. 以布尔值为入口开始理解程序本质\n",
    "> 1. 了解值的分类和运算方法\n",
    "> 1. 简要了解流程控制的原理\n",
    "> 1. 简要了解函数的基本构成\n",
    "> 1. 相对完整地了解字符串的操作\n",
    "> 1. 了解各种容器的基础操作\n",
    "> 1. 简要了解文件的读写操作"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 阅读策略"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "首先，不要试图一下子就全部搞懂。这不仅很难，**在最初的时候也完全没必要**。\n",
    "\n",
    "因为这部分的知识结构中，充满了 “过早引用”。请在第一遍粗略完成第 1 部分中的 E1 ~ E7 之后，再去阅读《[如何从容应对 “过早引用”？](Part.1.F.deal-with-forward-references.ipynb)》。\n",
    "\n",
    "其次，这一部分，注定要**反复阅读若干遍**。\n",
    "\n",
    "在开始之前，要明确这一部分的阅读目标。\n",
    "\n",
    "这一部分的目标，不是让你读完之后就可以开始写程序；也不是让你读完之后就对编程或者 Python 编程有了完整的了解，甚至不是让你真的学会什么…… 这一部分的目标，只是让你 “**脱盲**”。\n",
    "\n",
    "不要以为脱盲是很容易的事情。你看，所有人出生的时候，都天然是 “文盲”；人们要上好多年的学，才能够真正 “脱盲” —— 仔细想想吧，小学毕业的时候，所有人就真的彻底脱盲了吗？\n",
    "\n",
    "以中文脱盲为例，学字的同时，还要学习笔划；为了学更多的字，要学拼音，要学如何使用《新华字典》……\n",
    "\n",
    "学会了一些基础字之后，要学更多的词，而后在练习了那么多造词造句之后，依然会经常用错…… 你看，脱盲，和阅读能力强之间距离很长呢；不仅如此，阅读能力强和写作能力强之间的距离更长……\n",
    "\n",
    "反复阅读这一部分的结果是：\n",
    "\n",
    "> * 你对基本概念有了一定的了解\n",
    "> * 你开始有能力相对轻松地阅读部分官方文档\n",
    "> * 你可以读懂一些简单的代码\n",
    "\n",
    "仅此而已。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 心理建设"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "当我们开始学习一项新技能的时候，我们的大脑会不由自主地紧张。可这只不过是多年之间在学校里不断受挫的积累效应 —— 学校里别的地方不一定行，可有个地方特别行：给学生制造全方位、无死角、层层递进的挫败感。\n",
    "\n",
    "可是，你要永远记住两个字：\n",
    "\n",
    "> 别怕！\n",
    "\n",
    "用四个字也行：\n",
    "\n",
    "> 啥也别怕！\n",
    "\n",
    "六个字也可以：\n",
    "\n",
    "> 没什么可怕的！\n",
    "\n",
    "我遇到最多的孱弱之语大抵是这样的：\n",
    "\n",
    "> 我一个文科生……\n",
    "\n",
    "哈哈，从某个层面望过去，其实吧，编程既不是文科也不是理科…… 它更像是 “手工课”。你越学就越清楚这个事实，它就好像是你做木工一样，学会使用一个工具，再学会使用另外一个工具，其实总共就没多少工具。然后，你更多做的是各种拼接的工作，至于能做出什么东西，最后完全靠你的想象力……\n",
    "\n",
    "十来岁的孩子都可以学会的东西，你怕什么？\n",
    "\n",
    "**别怕**，无论说给自己，还是讲给别人，都是一样的，它可能是人生中最重要的鼓励词。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 关于这一部分内容中的代码"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "所有的代码，都可以在选中代码单元格（Code Cell）之后，按快捷键 `⇧ ⏎` 或 `^ ⏎` 执行，查看结果。\n",
    "\n",
    "少量执行结果太长的代码，其输出被设置成了 “Scrolled”，是可以通过触摸板或鼠标滑轮上下滑动的。\n",
    "\n",
    "为了避免大量使用 `print()` 才能看到输出结果，在很多的代码单元格中，开头插入了以下代码：\n",
    "\n",
    "```python\n",
    "from IPython.core.interactiveshell import InteractiveShell\n",
    "InteractiveShell.ast_node_interactivity = \"all\"\n",
    "```\n",
    "你可以暂时忽略它们的意义和工作原理。注意：有时，你需要在执行第二次的时候，才能看到全部输出结果。\n",
    "\n",
    "另外，有少量代码示例，为了让读者每次执行的时候看到不同的结果，使用了随机函数，为其中的变量赋值，比如：\n",
    "\n",
    "```python\n",
    "import random\n",
    "r = random.randrange(1, 1000)\n",
    "```\n",
    "\n",
    "同样，你可以暂时忽略它们的意义和工作原理；只需要知道因为有它们在，所以每次执行那个单元格中的代码会有不同的结果就可以了。\n",
    "\n",
    "如果你不是直接在网站上浏览这本 “书”、或者不是在阅读印刷版，而是在本地自己搭建 Jupyterlab 环境使用，那么请参阅附录《[Jupyterlab 的安装与配置](T-appendix.jupyter-installation-and-setup.ipynb)》。\n",
    "\n",
    "> **注意**：尤其需要仔细看看《[Jupyterlab 的安装与配置](T-appendix.jupyter-installation-and-setup.ipynb)》的《关于 Jupyter lab themes》这一小节 —— 否则，阅读体验会有很大差别。\n",
    "\n",
    "另外，如果你使用的是 [nteract](https://nteract.io) 桌面版 App 浏览 `.ipynb` 文件，那么有些使用了 `input()` 函数的代码是无法在 nteract 中执行的。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Next Page](./Part.1.E.1.entrance.ipynb)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}


================================================
FILE: Part.1.E.1.entrance.ipynb
================================================
{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": false
   },
   "source": [
    "# 入口"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "“速成”，对绝大多数人<a href='#fn1' name='fn1b'><sup>[1]</sup></a>来说，在绝大多数情况下，是不大可能的。\n",
    "\n",
    "编程如此，自学编程更是如此。有时，遇到复杂度高一点的知识，连快速入门都不一定是很容易的事情。\n",
    "\n",
    "所以，这一章的名称，特意从 “*入门*” 改成了 “**入口**” —— 它的作用是给你 “指一个入口”，至于你能否从那个入口进去，是你自己的事了……\n",
    "\n",
    "不过，有一点不一样的地方，我给你指出的入口，跟别的编程入门书籍不一样 —— 它们几乎无一例外都是从一个 “Hello World!” 程序开始的…… 而我们呢？\n",
    "\n",
    "让我们从认识一个人开始罢……"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 乔治・布尔"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1833 年，一个 18 岁的英国小伙脑子里闪过一个念头：\n",
    "\n",
    "> **逻辑关系**应该能用**符号**表示。\n",
    "\n",
    "这个小伙子叫乔治・布尔（[George Boole](https://en.wikipedia.org/wiki/George_Boole)，其实之前就提到过我的这位偶像），于 1815 年出生于距离伦敦北部 120 英里之外的一个小镇，林肯。父亲是位对科学和数学有着浓厚兴趣的鞋匠。乔治・布尔在父亲的影响下，靠阅读自学成才。14 岁的时候就在林肯小镇名声大噪，因为他翻译了一首希腊语的诗歌并发表在本地的报纸上。\n",
    "\n",
    "到了 16 岁的时候，他被本地一所学校聘为教师，那时候他已经在阅读微积分书籍。19 岁的时候布尔创业了 —— 他办了一所小学，自任校长兼教师。23 岁，他开始发表数学方面的论文。他发明了 “操作演算”，即，通过操作符号来研究微积分。他曾经考虑过去剑桥读大学，但后来放弃了，因为为了入学他必须放下自己的研究，还得去参加标准本科生课程。这对一个长期只靠自学成长的人来说，实在是太无法忍受了。\n",
    "\n",
    "1847 年，乔治 32 岁，出版了他人生的第一本书籍，[THE MATHEMATICAL ANALYSIS OF LOGIC](http://www.gutenberg.org/ebooks/36884) —— 18 岁那年的闪念终于成型。这本书很短，只有 86 页，但最终它竟然成了人类的瑰宝。在书里，乔治・布尔很好地解释了如何使用代数形式表达逻辑思想。\n",
    "\n",
    "1849 年，乔治・布尔 34 岁，被当年刚刚成立的女皇学院（Queen's College）聘请为第一位数学教授。随后他开始写那本最著名的书，[AN INVESTIGATION OF THE LAWS OF THOUGHT](http://www.gutenberg.org/ebooks/15114)。他在前言里写到：\n",
    "\n",
    "> “The design of the following treatise is to investigate the fundamental laws of those operations of the mind by which reasoning is performed; to give expression to them in the symbolical language of a Calculus, and upon this foundation to establish the science of Logic and construct its method; …”\n",
    ">\n",
    "> “本书论述的是，探索心智推理的基本规律；用微积分的符号语言进行表达，并在此基础上建立逻辑和构建方法的科学……”\n",
    "\n",
    "在大学任职期间，乔治・布尔写了两本教科书，一本讲微分方程，另外一本讲差分方程，而前者，[A TREATISE ON DIFFERENTIAL EQUATIONS](https://archive.org/details/atreatiseondiff06boolgoog/page/n7)，直到今天，依然难以超越。\n",
    "\n",
    "![george-boole-1864](images/george-boole-in-1864.png)\n",
    "\n",
    "乔治・布尔于 1864 年因肺炎去世。\n",
    "\n",
    "乔治・布尔在世的时候，人们并未对他的布尔代数产生什么兴趣。直到 70 年后，克劳德・香农（[Claude Elwood Shannon](https://en.wikipedia.org/wiki/Claude_Shannon)）发表那篇著名论文，[A SYMBOLIC ANALYSIS OF RELAY AND SWITCHING CIRCUITS](https://www.cs.virginia.edu/~evans/greatworks/shannon38.pdf) 之后，布尔代数才算是开始被大规模应用到实处。\n",
    "\n",
    "有本书可以闲暇时间翻翻，[The Logician and the Engineer: How George Boole and Claude Shannon Created the Information Age](https://www.amazon.com/gp/product/B0091XBUTM/ref=dbs_a_def_rwt_hsch_vapi_tkin_p1_i4)。可以说，没有乔治・布尔的**布尔代数**，没有克劳德・香农的**逻辑电路**，就没有后来的计算机，就没有后来的互联网，就没有今天的信息时代 —— 世界将会怎样？\n",
    "\n",
    "2015 年，乔治・布尔诞辰 200 周年，Google 设计了[专门的 Logo](https://www.google.com/doodles/george-booles-200th-birthday) 纪念这位为人类作出巨大贡献的自学奇才。\n",
    "\n",
    "![george-boole-google-doodle-2015](images/george-boole-google-doodle-2015.gif)\n",
    "\n",
    "Google Doodle 的寄语是这样的：\n",
    "\n",
    "> A very happy **11001000**_th_ birthday to genius George Boole!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": true
   },
   "source": [
    "## 布尔运算"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "从定义上来看，所谓**程序**（Programs）其实一点都不神秘。\n",
    "\n",
    "因为程序这个东西，不过是按照一定*顺序*完成任务的**流程**（Procedures）。根据定义，日常生活中你做盘蛋炒饭给自己吃，也是完成了一个 “做蛋炒饭” 的程序 —— 你按部就班完成了一系列的步骤，最终做好了一碗蛋炒饭给自己吃 —— 从这个角度望过去，所有的菜谱都是程序……\n",
    "\n",
    "只不过，菜谱这种程序，编写者是人，执行者还是人；而我们即将要学会写的程序，编写者是人，执行者是计算机 —— 当然，菜谱用自然语言编写，计算机程序由程序员用编程语言编写。\n",
    "\n",
    "然而，这些都不是最重要的差异 —— 最重要的差异在于计算机能做**布尔运算**（Boolean Operations）。\n",
    "\n",
    "于是，一旦代码编写好之后，计算机在执行的过程中，除了可以 “*按照顺序执行任务*” 之外，还可以 “*根据不同情况执行不同的任务*”，比如，“*如果条件尚未满足则重复执行某一任务*”。\n",
    "\n",
    "计算器和计算机都是电子设备，但计算机更为强大的原因，用通俗的说法就是它 “**可编程**”（Programable）—— 而所谓可编程的核心就是*布尔运算*及其相应的**流程控制**（Control Flow）；没有布尔运算能力就没有办法做*流程控制*；没有流程控制就只能 “按顺序执行”，那就显得 “很不智能”……"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 布尔值"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在 Python 语言中，**布尔值**（Boolean Value）用 `True` 和 `False` 来表示。\n",
    "\n",
    "**注意**：请小心区分大小写 —— 因为 Python 解释器是对大小写敏感的，对它来说，`True` 和 `true` 不是一回事。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "任何一个**逻辑表达式**都会返回一个*布尔值*。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.core.interactiveshell import InteractiveShell\n",
    "InteractiveShell.ast_node_interactivity = \"all\"\n",
    "# 请暂时忽略以上两行……\n",
    "\n",
    "1 == 2\n",
    "1 != 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`1 == 2`，用自然语言描述就是 “_1 等于 2 吗？_” —— 它的布尔值当然是 `False`。\n",
    "\n",
    "`1 != 2`，用自然语言描述就是 “_1 不等于 2 吗？_” —— 它的布尔值当然是 `True`。\n",
    "\n",
    "**注意**：自然语言中的 “*等于*”，在 Python 编程语言中，使用的符号是 `==`，**不是一个等号！**\n",
    "\n",
    "**请再次注意**：单个等号 `=`，有其他的用处。初学者最不适应的就是，在编程语言里所使用的操作符，与他们之前在其他地方已经习惯了的使用方法并不相同 —— 不过，适应一段时间就好了。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 逻辑操作符"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python 语言中的**逻辑操作符**（Logical Operators）如下表所示 —— 为了理解方便，也可以将其称为 “*比较操作符*”。\n",
    "\n",
    "| 比较操作符 | 意义     | 示例             | 布尔值  |\n",
    "| ---------- | -------- | ---------------- | ------- |\n",
    "| `==`       | 等于     | `1 == 2`         | `False` |\n",
    "| `!=`       | 不等于   | `1 != 2`         | `True`  |\n",
    "| `>`        | 大于     | `1 > 2`          | `False` |\n",
    "| `>=`       | 大于等于 | `1 >= 1`         | `True`  |\n",
    "| `<`        | 小于     | `1 < 2`          | `True`  |\n",
    "| `<=`       | 小于等于 | `1 <= 2`         | `True`  |\n",
    "| `in`       | 属于     | `'a' in 'basic'` | `True`  |\n",
    "\n",
    "除了等于、大于、小于之外，Python 还有一个逻辑操作符，`in`：\n",
    "\n",
    "这个表达式 `'a' in 'basic'` 用自然语言描述就是：\n",
    "\n",
    "> “`'a'` 存在于 `'basic'` 这个字符串之中吗？”（属于关系）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 布尔运算操作符"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以上的例子中，逻辑操作符的**运算对象**（Operands）是数字值和字符串值。\n",
    "\n",
    "而针对布尔值进行运算的操作符很简单，只有三种：与、或、非：\n",
    "\n",
    "> 分别用 `and`、`or`、`not` 表示\n",
    "\n",
    "**注意**：它们全部是小写。因为布尔值只有两个，所以布尔运算结果只有几种而已，如下图所示：\n",
    "\n",
    "![](images/boolean-operators.png)\n",
    "\n",
    "先别管以下代码中 `print()` 这个函数的工作原理，现在只需要关注其中布尔运算的结果："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(True and False) yields: False\n",
      "(True and True) yields: True\n",
      "(False and True) yields: False\n",
      "(True or False) yields: True\n",
      "(False or True) yields: True\n",
      "(False or False) yields: False\n",
      "(not True) yields: False\n",
      "(not False) yields: True\n"
     ]
    }
   ],
   "source": [
    "print('(True and False) yields:',  True and False)\n",
    "print('(True and True) yields:',  True and True)\n",
    "print('(False and True) yields:',  False and True)\n",
    "print('(True or False) yields:',  True or False)\n",
    "print('(False or True) yields:',  False or True)\n",
    "print('(False or False) yields:',  False or False)\n",
    "print('(not True) yields:',  not True)\n",
    "print('(not False) yields:',  not False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "千万不要误以为布尔运算是*理科生*才必须会、才能用得上的东西…… 文理艺分科是中国的特殊分类方式，真挺害人的。比如，设计师们在计算机上创作图像的时候，也要频繁使用*或与非*的布尔运算操作才能完成各种图案的拼接…… 抽空看看这个网页：[Boolean Operations used by Sketch App](https://sketchapp.com/docs/shapes/boolean-operations/) —— 这类设计软件，到最后是每个人都用得上的东西呢。另，难道艺术生不需要学习文科或者理科？—— 事实上，他们也有文化课……\n",
    "\n",
    "![](images/operations@2x.png)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": true
   },
   "source": [
    "## 流程控制"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "有了布尔运算能力之后，才有*根据情况决定流程*的所谓**流程控制**（Control Flow）的能力。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "693 is odd.\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "r = random.randrange(1, 1000)\n",
    "# 请暂时忽略以上两句的原理，只需要了解其结果：\n",
    "# 引入随机数，而后，每次执行的时候，r 的值不同\n",
    "\n",
    "if r % 2 == 0:\n",
    "    print(r, 'is even.')\n",
    "else:\n",
    "    print(r, 'is odd.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "你可以多执行几次以上程序，看看每次不同的执行结果。执行方法是，选中上面的 Cell 之后按快捷键 `shift + enter`。\n",
    "\n",
    "现在看代码，先忽略其它的部分，只看关键部分：\n",
    "\n",
    "```python\n",
    "    ...\n",
    "    if r % 2 == 0:\n",
    "        ...\n",
    "    else:\n",
    "        ...\n",
    "```\n",
    "\n",
    "这个 `if/else` 语句，完成了流程的**分支**功能。`%` 是计算余数的符号，如果 `r` 除以 `2` 的余数等于 `0`，那么它就是偶数，否则，它就是奇数 —— 写成布尔表达式，就是 `r % 2 == 0`。\n",
    "\n",
    "这一次，你看到了单个等号 `=`：`r = random.randrange(1, 1000)`。\n",
    "\n",
    "这个符号在绝大多数编程语言中都是 “**赋值**”（Assignment）的含义。\n",
    "\n",
    "例如：\n",
    "\n",
    "在 `r = 2` 之中，`r` 是一个名称为 `r` 的**变量**（Variable）—— 现在只需要将变量理解为程序*保存数值的地方*；而 `=` 是赋值符号，`2` 是一个整数**常量**（Literal）。\n",
    "\n",
    "语句 `r = 2` 用自然语言描述就是：\n",
    "\n",
    "> “把 `2` 这个值保存到名称为 `r` 的变量之中”。\n",
    "\n",
    "现在先别在意头两行代码的工作原理，只关注它的工作结果：`random.randrange(1, 1000)` 这部分代码的作用是返回一个 _1 到 1000 之间_（含左侧 `1` 但不含右侧 `1000`）的随机整数。每次执行以上的程序，它就生成一个新的随机整数，然后因为 `=` 的存在，这个数就被保存到 `r` 这个变量之中。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "计算机程序的所谓 “智能”（起码相对于计算器），首先是因为它能做*布尔运算*。计算机的另外一个好处是 “不知疲倦”（反正它也不用自己交电费），所以，它最擅长处理的就是 “重复”，这个词在程序语言中，术语是**循环**（Loop）。以下程序会打印出 `10` 以内的所有奇数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "5\n",
      "7\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    if i % 2 != 0:\n",
    "        print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "其中 `range(10)` 的返回值，是 `0～9` 的整数序列（默认起始值是 `0`；含左侧 `0`，不含右侧 `10`）。\n",
    "\n",
    "用自然语言描述以上的程序，大概是这样的 —— 自然语言写在 `#` 之后：\n",
    "\n",
    "```python\n",
    "for i in range(10): # 对于 0～9 中的所有数字都代入 i 这个变量，执行一遍以下任务：\n",
    "    if i % 2 != 0:  #     如果 i 除以 2 的余数不等于零的话，执行下面的语句：\n",
    "        print(i)    #         向屏幕输出 i 这个变量中所保存的值\n",
    "```\n",
    "\n",
    "就算你让它打印出一百亿以内的奇数，它也毫不含糊 —— 你只需要在 `range()` 这个函数的括号里写上一个那么大的整数就行……\n",
    "\n",
    "让它干一点稍微复杂的事吧，比如，我们想要打印出 `100` 以内所有的*质数*（Primes）。\n",
    "\n",
    "根据质数的定义，它大于等于 `2`，且只有在被它自身或者 `1` 做为除数时余数为 `0`。判断一个数字是否是质数的**算法**是这样的：\n",
    "\n",
    "> * 设 `n` 为整数，`n >= 2`；\n",
    "> * 若 `n == 2`，`n` 是质数；\n",
    "> * 若 `n > 2`，就把 `n` 作为被除数，从 `2` 开始一直到 `n - 1` 都作为除数，*逐一*计算看看余数是否等于 `0`？\n",
    ">> * 如果是，那就不用接着算了，它不是质数；\n",
    ">> * 如果全部都试过了，余数都不是 `0`，那么它是质数。\n",
    "\n",
    "于是，你需要两个**嵌套**的循环，第一个是负责让被除数 `n` 从 `2` **遍历**（就是依次经历一次）到 `99`（题目是 `100` 以内，所以不包含 `100`）的循环，第二个是在前者内部负责让除数 `i` 从 `2` 遍历到 `n - 1` 的循环："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "5\n",
      "7\n",
      "11\n",
      "13\n",
      "17\n",
      "19\n",
      "23\n",
      "29\n",
      "31\n",
      "37\n",
      "41\n",
      "43\n",
      "47\n",
      "53\n",
      "59\n",
      "61\n",
      "67\n",
      "71\n",
      "73\n",
      "79\n",
      "83\n",
      "89\n",
      "97\n"
     ]
    }
   ],
   "source": [
    "for n in range(2, 100): #range(2,100)表示含左侧 2，不含右侧 100，是不是第三次看到这个说法了？\n",
    "    if n == 2:\n",
    "        print(n)\n",
    "        continue\n",
    "    for i in range(2, n):\n",
    "        if (n % i) == 0:\n",
    "            break\n",
    "    else:                  # 这里目前你可能看不懂…… 但先关注结果吧。\n",
    "        print(n)         "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": true
   },
   "source": [
    "## 所谓算法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以上的**算法**可以改进（程序员们经常用的词汇是 “*优化*”）<a id='plusone'></a>：\n",
    "\n",
    "> 从 `2` 作为除数开始试，试到 $\\sqrt{n}$ 之后的一个整数就可以了……"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "5\n",
      "7\n",
      "11\n",
      "13\n",
      "17\n",
      "19\n",
      "23\n",
      "29\n",
      "31\n",
      "37\n",
      "41\n",
      "43\n",
      "47\n",
      "53\n",
      "59\n",
      "61\n",
      "67\n",
      "71\n",
      "73\n",
      "79\n",
      "83\n",
      "89\n",
      "97\n"
     ]
    }
   ],
   "source": [
    "for n in range(2, 100):\n",
    "    if n == 2:\n",
    "        print(n)\n",
    "        continue\n",
    "    for i in range(2, int(n ** 0.5)+1): #为什么要 +1 以后再说…… n 的 1/2 次方，相当于根号 n。\n",
    "        if (n % i) == 0:\n",
    "            break\n",
    "    else:\n",
    "        print(n)         "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "你看，寻找更有效的算法，或者说，不断优化程序，提高效率，最终是程序员的工作，不是编程语言本身的工作。关于判断质数最快的算法，[可以看 Stackoverflow 上的讨论](https://stackoverflow.com/questions/1801391/what-is-the-best-algorithm-for-checking-if-a-number-is-prime)，有更多时间也可以翻翻 [Wikipedia](https://en.wikipedia.org/wiki/Generating_primes)。\n",
    "\n",
    "到最后，**所有的工具都一样，效用取决于使用它的人**。所以，学会使用工具固然重要，更为重要的是与此同时自己的能力必须不断提高。\n",
    "\n",
    "虽然写代码这事刚开始学起来好像门槛很高，那只不过是幻觉，其实门槛比它更高的多的去了。到最后，它就是个最基础的工具，还是得靠思考能力 —— 这就好像识字其实挺难的 —— 小学初中高中加起来十来年，我们才掌握了基本的阅读能力；可最终，即便是本科毕业、研究生毕业，真的能写出一手好文章的人还是少之又少一样 —— 因为用文字值得写出来的是思想，用代码值得写出来的是创造，或者起码是有意义的问题的有效解决方案。有思想，能解决问题，是另外一门手艺 —— 需要终生精进的手艺。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 所谓函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们已经反复见过 `print()` 这个**函数**（Functions）了。它的作用很简单，就是把传递给它的值输出到屏幕上 —— 当然，事实上它的使用细节也很多，以后慢慢讲。\n",
    "\n",
    "现在，最重要的是初步理解一个函数的基本构成。关于**函数**，相关的概念有：*函数名*（Function Name）、*参数*（Parameters）、*返回值*（Return Value）、*调用*（Call）。\n",
    "\n",
    "拿一个更为简单的函数作为例子，`abs()`。它的作用很简单：接收一个数字作为参数，经过运算，返回该数字的绝对值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.1415926"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = abs(-3.1415926)\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在以上的代码的第 1 行中，\n",
    "\n",
    "> * 我们*调用*了一个*函数名*为 `abs` 的函数；写法是 `abs(-3.1415926)`；\n",
    "> * 这么写，就相当于向它*传递*了一个*参数*，其值为：`-3.1415926`；\n",
    "> * 该函数接收到这个参数之后，根据这个参数的*值*在函数内部进行了*运算*；\n",
    "> * 而后该函数返回了一个值，*返回值*为之前接收到的参数的值的绝对值 `3.1415926`；\n",
    "> * 而后这个*值*被保存到*变量* `a` 之中。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "从结构上来看，每个函数都是一个完整的程序，因为一个程序，核心构成部分就是*输入*、*处理*、*输出*：\n",
    "\n",
    "> * 它有输入 —— 即，它能接收外部通过参数传递的值；\n",
    "> * 它有处理 —— 即，内部有能够完成某一特定任务的代码；尤其是，它可以根据 “输入” 得到 “输出”；\n",
    "> * 它有输出 —— 即，它能向外部输送返回值……\n",
    "\n",
    "被调用的函数，也可以被理解为**子程序**（Sub-Program）—— 主程序执行到函数调用时，就开始执行实现函数的那些代码，而后再返回主程序……"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们可以把判断一个数字是否是质数的过程，写成函数，以便将来在多处用得着的时候，随时可以调用它："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "83\n",
      "89\n",
      "97\n",
      "101\n",
      "103\n",
      "107\n",
      "109\n"
     ]
    }
   ],
   "source": [
    "def is_prime(n):            # 定义 is_prime()，接收一个参数\n",
    "    if n < 2:              # 开始使用接收到的那个参数（值）开始计算……\n",
    "        return False       # 不再是返回给人，而是返回给调用它的代码……\n",
    "    if n == 2:\n",
    "        return True\n",
    "    for m in range(2, int(n**0.5)+1):\n",
    "        if (n % m) == 0:\n",
    "            return False\n",
    "    else:\n",
    "        return True\n",
    "\n",
    "for i in range(80, 110):\n",
    "    if is_prime(i):          # 调用 is_prime() 函数，\n",
    "        print(i)            # 如果返回值为 True，则向屏幕输出 i"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": true
   },
   "source": [
    "## 细节补充"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 语句"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "一个完整的程序，由一个或者多个**语句**（Statements）构成。通常情况下，建议每一行只写一条语句。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "5\n",
      "7\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    if i % 2 != 0:\n",
    "        print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 语句块"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在 Python 语言中，**行首空白**（Leading whitespace，由空格 `' '` 或者 Tab `⇥` 构成）有着特殊的含义。\n",
    "\n",
    "如果有行首空白存在，那么，Python 将认为这一行与其他邻近有着相同行首空白的语句同属于一个**语句块** —— 而一个语句块必然由一个行末带有冒号 `:` 的语句起始。同属于一个语句块中的语句，行首空白数量应该相等。这看起来很麻烦，可实际上，程序员一般都使用专门的文本编辑器，比如 [Visual Studio Code](https://code.visualstudio.com)，其中有很多的辅助工具，可以让你很方便地输入具备一致性的行首空白。\n",
    "\n",
    "以上程序，一共三个语句，两个语句块，一个 `for` 循环*语句块*中包含着一个 `if` 条件*语句块*。注意第一行和第二行末尾的冒号 `:`。\n",
    "\n",
    "在很多其他的语言中，比如，JavaScript，用大括号 `{}` 作为语句块标示 —— 这是 Python 比较特殊的地方，它组织语句块的方式如下图所示：\n",
    "\n",
    "![](images/python-leading-space.png)\n",
    "\n",
    ">**注意**：在同一个文件里，不建议混合使用 Tab 和 Space；要么全用空格，要么全用制表符。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 注释"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在 Python 程序中可以用 `#` 符号标示**注释**语句。\n",
    "\n",
    "所谓的注释语句，就是程序文件里写给人看而不是写给计算机看的部分。本节中的代码里就带着很多的注释。\n",
    "\n",
    "人写的 Python 语言代码，要被 Python **解释器**翻译成机器语言，而后才能让计算机 “读懂”，随后计算机才可以按照指令执行。解释器在编译程序的过程中，遇到 `#` 符号，就会忽略其后的部分（包括这个注释符号）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 操作符"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在本节，我们见到的比较操作符可以比较它左右的值，而后返回一个布尔值。\n",
    "\n",
    "我们也见过两个整数被**操作符** `%` 连接，左侧作为被除数，右侧作为除数，`11 % 3` 这个表达式的值是 `2`。对于数字，我们可用的操作符有 `+`、`-`、`*`、`/`、`//`、`%`、`**` —— 它们分别代表加、减、乘、除、商、余、幂。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 赋值符号与操作符的连用"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "你已经知道变量是什么了，也已经知道赋值是什么了。于是，你看到 `x = 1` 就明白了，这是为 `x` 赋值，把 `1` 这个值保存到变量 `x` 之中去。\n",
    "\n",
    "但是，若是你看到 ` x += 1`，就迷惑了，这是什么意思呢？\n",
    "\n",
    "这只是编程语言中的一种惯用法。它相当于 `x = x + 1`。\n",
    "\n",
    "看到 `x = x + 1` 依然会困惑…… 之所以困惑，是因为你还没有习惯把单等号 `=` 当作赋值符号，把双等号 `==` 当作逻辑判断的 “等于”。\n",
    "\n",
    "`x = x + 1` 的意思是说，把表达式 `x + 1` 的值保存到变量 `x` 中去 —— 如此这般之后，`x` 这个变量中所保存的就不再是原来的值了……"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "x = 0\n",
    "x += 1\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "其实不难理解，只要习惯了就好。理论上，加减乘除商余幂这些操作符，都可以与赋值符号并用。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "x = 11\n",
    "x %= 3   # x = x % 3\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": true
   },
   "source": [
    "## 总结"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以下是这一章中所提到的重要概念。了解它们以及它们之间的关系，是进行下一步的基础。\n",
    "\n",
    "> * 数据：整数、布尔值；操作符；变量、赋值；表达式\n",
    "> * 函数、子程序、参数、返回值、调用\n",
    "> * 流程控制、分支、循环\n",
    "> * 算法、优化\n",
    "> * 程序：语句、注释、语句块\n",
    "> * 输入、处理、输出\n",
    "> * 解释器\n",
    "\n",
    "你可能已经注意到了，这一章的小节名称罗列出来的话，看起来像是一本编程书籍的目录 —— 只不过是概念讲解顺序不同而已。事实上还真的就是那么回事。\n",
    "\n",
    "这些概念，基本上都是**独立于**某一种编程语言的（Language Independent），无论将来你学习哪一种编程语言，不管是 C++，还是 JavaScript，抑或是 Golang，这些概念都在那里。\n",
    "\n",
    "学会一门编程语言之后，再学其它的就会容易很多 —— 而且，当你学会了其中一个之后，早晚你会顺手学其它的，为了更高效使用微软办公套件，你可能会花上一两天时间研究一下 VBA；为了给自己做个网页什么的，你会顺手学会 JavaScript；为了修改某个编辑器插件，你发现人家是用 Ruby 写的，大致读读官方文档，你就可以下手用 Ruby 语言了；为了搞搞数据可视化，你会发现不学会 R 语言有点不方便……\n",
    "\n",
    "你把这些概念装在脑子里，而后就会发现几乎所有的编程入门教学书籍结构都差不多是由这些概念构成的。因为，所有的编程语言基础都一样，所有的编程语言都是我们指挥计算机的工具。无论怎样，反正都需要输入输出，无论什么语言，不可能没有布尔运算，不可能没有流程控制，不可能没有函数，只要是高级语言，就都需要编译器…… 所以，掌握这些基本概念，是将来持续学习的基础。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-----\n",
    "**脚注**\n",
    "\n",
    "<a name='fn1'>[1]</a>：对于自学能力强、有很多自学经验的人来说，速成往往真的是可能、可行的。因为他们已经积累的知识与经验会在习得新技能时发挥巨大的作用，乃至于他们看起来相对别人花极少的时间就能完成整个自学任务。也就是说，将来的那个已经习得自学能力、且自学能力已经磨练得很强的你，常常真的可以做到在别人眼里 “速成”。\n",
    "\n",
    "<a href='#fn1b'><small>↑Back to Content↑</small></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"./Part.1.E.2.values-and-their-operators.ipynb\" ><small>Next Page</small></a>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  },
  "toc-autonumbering": true,
  "toc-showmarkdowntxt": false
 },
 "nbformat": 4,
 "nbformat_minor": 2
}


================================================
FILE: Part.1.E.2.values-and-their-operators.ipynb
================================================
{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 值及其相应的运算"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "从结构上来看，一切的计算机程序，都由且只由两个最基本的成分构成：\n",
    "\n",
    "> * **运算**（Evaluation）\n",
    "> * **流程控制**（Control Flow）\n",
    "\n",
    "没有流程控制的是计算器而已；有流程控制的才是可编程设备。\n",
    "\n",
    "看看之前我们见过的计算质数的程序：（按一下 `⎋`，即 `ESC`，确保已经进入命令模式，`⇧ L` 可以切换是否显示代码行号）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "83\n",
      "89\n",
      "97\n",
      "101\n",
      "103\n",
      "107\n",
      "109\n"
     ]
    }
   ],
   "source": [
    "def is_prime(n):            # 定义 is_prime()，接收一个参数\n",
    "    if n < 2:              # 开始使用接收到的那个参数（值）开始计算……\n",
    "        return False       # 不再是返回给人，而是返回给调用它的代码……\n",
    "    if n == 2:\n",
    "        return True\n",
    "    for m in range(2, int(n**0.5)+1):\n",
    "        if (n % m) == 0:\n",
    "            return False\n",
    "    else:\n",
    "        return True\n",
    "\n",
    "for i in range(80, 110):\n",
    "    if is_prime(i):          # 调用 is_prime() 函数，\n",
    "        print(i)            # 如果返回值为 True，则向屏幕输出 i"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`if...`，`for...` 在控制流程：在什么情况下运算什么，在什么情况下重复运算什么；\n",
    "\n",
    "第 13 行 `is_prime()` 这个函数的调用，也是在控制流程 —— 所以我们可以**把函数看作是 “子程序”**；\n",
    "\n",
    "一旦这个函数被调用，流程就转向开始执行在第 1 行中定义的 `is_prime()` 函数内部的代码，而这段代码内部还是*计算*和*流程控制*，决定一个返回值 —— 返回值是布尔值；再回到第 13 行，将返回值交给 `if` 判断，决定是否执行第 14 行……\n",
    "\n",
    "而计算机这种可编程设备之所以可以做流程控制，是因为它可以做**布尔运算**，即，它可以*对布尔值*进行*操作*，而后将布尔值交给*分支*和*循环*语句，构成了程序中的流程控制。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 值"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "从本质上看，程序里的绝大多数语句包含着**运算**（Evaluation），即，在对某个值进行**评价**。这里的 “评价”，不是 “判断某人某事的好坏”，而是 “*计算出某个值究竟是什么*” —— 所以，我们用中文的 “**运算**” 翻译这个 “_Evaluation_” 可能表达得更准确一些。\n",
    "\n",
    "在程序中，被运算的可分为**常量**（Literals）和**变量**（Variables）。\n",
    "\n",
    "```python\n",
    "a = 1 + 2 * 3\n",
    "a += 1\n",
    "print(a)\n",
    "```\n",
    "\n",
    "在以上代码中，\n",
    "\n",
    "`1`、`2`、`3`，都是**常量**。_Literal_ 的意思是“字面的”，顾名思义，常量的*值*就是它字面上的值。`1` 的值，就是 `1`。\n",
    "\n",
    "`a` 是**变量**。顾名思义，它的值将来是可变的。比如，在第 2 句中，这个变量的*值*发生了改变，之前是 `7`，之后变成了 `8`。\n",
    "\n",
    "第 1 句中的 `+`、`*`，是**操作符**（Operators），它用来对其左右的值进行相应的*运算*而后得到一个值。先是由操作符 `*` 对 `2` 和 `3` 进行运算，\n",
    "生成一个值，`6`；然后再由操作符 `+` 对 `1` 和 `6` 进行运算，生成一个值 `7`。先算乘除后算加减，这是操作符的**优先级**决定的。\n",
    "\n",
    "`=` 是赋值符号，它的作用是将它右边的值保存到左边的变量中。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*值*是程序的基础成分（Building blocks），它就好像盖房子用的砖块一样，无论什么样的房子，到最后都主要是由砖块构成。\n",
    "\n",
    "*常量*，当然有个*值* —— 就是它们字面所表达的值。\n",
    "\n",
    "*变量*必须先*赋值*才能使用，也就是说，要先把一个*值*保存到变量中，它才能在其后被运算。\n",
    "\n",
    "在 Python 中每个函数都有*返回值*，即便你在定义一个函数的时候没有设定返回值，它也会加上默认的返回值 `None`……（请注意 `None` 的大小写！）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n",
      "None\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "def f():\n",
    "    pass\n",
    "print(f())        # 输出 f() 这个函数被调用后的返回值，None\n",
    "print(print(f())) # 这一行最外围的 print() 调用了一次 print(f())，所以输出一个 None，\n",
    "                  # 而后再输出这次调用的返回值，所以又输出一次 None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "当我们调用一个函数的时候，本质上来看，就相当于：\n",
    "\n",
    "> 我们把一个值交给某个函数，请函数根据它内部的运算和流程控制对其进行操作而后返回另外一个值。\n",
    "\n",
    "比如，`abs()` 函数，就会返回传递给它的*值*的*绝对值*；`int()` 函数，会将传递给它的值的小数部分砍掉；`float()` 接到整数参数之后，会返回这个整数的浮点数形式："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.14159"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.core.interactiveshell import InteractiveShell\n",
    "InteractiveShell.ast_node_interactivity = \"all\"\n",
    "\n",
    "abs(-3.14159)\n",
    "int(abs(-3.14159))\n",
    "float(int(abs(-3.14159)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 值的类型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在编程语言中，总是包含最基本的三种数据类型：\n",
    "\n",
    "> * 布尔值（Boolean Value)\n",
    "> * 数字（Numbers）：整数（Int）、浮点数（Float）、复数（Complex Numbers）\n",
    "> * 字符串（Strings）\n",
    "\n",
    "既然有不同类型的数据，它们就分别对应着不同类型的值。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "运算的一个默认法则就是，通常情况下应该是*相同类型的值才能相互运算*。\n",
    "\n",
    "显然，数字与数字之间的运算是合理的，但你让 `+` 这个操作符对一个字符串和一个数字进行运算就不行："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20.0"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "ename": "TypeError",
     "evalue": "can only concatenate str (not \"int\") to str",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-18-e922b7565e53>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;36m11\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m10\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0;36m9\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0;36m8\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0;36m7\u001b[0m \u001b[0;34m//\u001b[0m \u001b[0;36m6\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0;34m'3.14'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m3\u001b[0m                  \u001b[0;31m# 这一句会报错\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
     ]
    }
   ],
   "source": [
    "from IPython.core.interactiveshell import InteractiveShell\n",
    "InteractiveShell.ast_node_interactivity = \"all\"\n",
    "\n",
    "11 + 10 - 9 * 8 / 7 // 6 % 5\n",
    "'3.14' + 3                  # 这一句会报错"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "所以，在不得不对不同类型的值进行运算之前，总是要事先做 **Type Casting**（类型转换）。比如，\n",
    "\n",
    "> * 将字符串转换为数字用 `int()`、`float()`；\n",
    "> * 将数字转换成字符串用 `str()`；\n",
    "\n",
    "另外，即便是在数字之间进行计算的时候，有时也需要将整数转换成浮点数字，或者反之：\n",
    "> * 将整数转换成浮点数字用 `float()`；\n",
    "> * 将浮点数字转换成整数用 `int()`；"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "有个函数，`type()`，可以用来查看某个值属于什么类型："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "range"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "set"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.core.interactiveshell import InteractiveShell\n",
    "InteractiveShell.ast_node_interactivity = \"all\"\n",
    "\n",
    "type(3)\n",
    "type(3.0)\n",
    "type('3.14')\n",
    "type(True)\n",
    "type(range(10))\n",
    "type([1,2,3])\n",
    "type((1,2,3))\n",
    "type({1,2,3})\n",
    "type({'a':1, 'b':2, 'c':3})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 操作符"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "针对不同类型的数据，有各自专用的**操作符**。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 数值操作符"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "针对数字进行计算的操作符有加减乘除商余幂：`+`、`-`、`*`、`/`、`//`、`%`、`**`。\n",
    "\n",
    "其中 `+` 和 `-` 可以对单个值进行操作，`-3`；其它的操作符需要有两个值才能操作。\n",
    "\n",
    "从优先级来看，这些操作符中：\n",
    "\n",
    "> * 对两个值进行操作的 `+`、`-` 的优先级最低；\n",
    "> * 稍高的是 `*`、`/`、`//`、`%`；\n",
    "> * 更高的是对单个值进行操作的 `+`、`-`；\n",
    "> * 优先级最高的是 `**`。\n",
    "\n",
    "完整的操作符优先级列表，参见官方文档：\n",
    "\n",
    "> https://docs.python.org/3/reference/expressions.html#operator-precedence\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 布尔值操作符"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "针对布尔值，操作符有`与`、`或`、`非`：`and`、`or`、`not`。\n",
    "\n",
    "它们之中，优先级最低的是或 `or`，然后是与 `and`, 优先级最高的是非 `not`："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True and False or not True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最先操作的是 `not`，因为它优先级最高。所以，上面的表达式相当于 `True and False or (not True)`，即相当于 `True and False or False`；\n",
    "\n",
    "然后是 `and`，所以，`True and False or False` 相当于是 `(True and False) or False`，即相当于 `False or False`；\n",
    "\n",
    "于是，最终的值是 `False`。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 逻辑操作符"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "数值之间还可以使用逻辑操作符，`1 > 2` 返回布尔值 `False`。逻辑操作符有：`<`（小于）、`<=`（小于等于）、`>`（大于）、`>=`（大于等于）、`!=`（不等于）、`==`（等于）。\n",
    "\n",
    "逻辑操作符的优先级，高于布尔值的操作符，低于数值计算的操作符。\n",
    "即：数值计算的操作符优先级最高，其次是逻辑操作符，布尔值的操作符优先级最低。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n = -95\n",
    "n < 0 and (n + 1) % 2 == 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 字符串操作符"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "针对字符串，有三种操作：\n",
    "\n",
    "> * 拼接：`+` 和 `' '`（后者是空格）\n",
    "> * 拷贝：`*`\n",
    "> * 逻辑运算：`in`、`not in`；以及，`<`、`<=`、`>`、`>=`、`!=`、`==` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'AwesomePython'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'AwesomePython'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'Python, Awesome! Awesome! Awesome! '"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.core.interactiveshell import InteractiveShell\n",
    "InteractiveShell.ast_node_interactivity = \"all\"\n",
    "\n",
    "'Awesome' + 'Python'\n",
    "'Awesome' 'Python'\n",
    "'Python, ' + 'Awesome! ' * 3\n",
    "'o' in 'Awesome' and 'o' not in 'Python'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "字符之间，字符串之间，除了 `==` 和 `!=` 之外，也都可以被逻辑操作符 `<`、`<=`、`>`、`>=` 运算："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'a' < 'b'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这是因为字符对应着 Unicode 码，字符在被比较的时候，被比较的是对应的 Unicode 码。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "65"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "97"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.core.interactiveshell import InteractiveShell\n",
    "InteractiveShell.ast_node_interactivity = \"all\"\n",
    "\n",
    "'A' > 'a'\n",
    "ord('A')\n",
    "ord('a')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "当字符串被比较的时候，将从两个字符串各自的第一个字符开始逐个比较，“一旦决出胜负马上停止”："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'PYTHON' > 'Python 3'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 列表的操作符"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "数字和字符串（由字符构成的序列）是最基本的数据类型，而我们往往需要批量处理数字和字符串，这样的时候，我们需要**数组**（Array）。不过，在 Python 语言中，它提供了一个**容器**（Container）的概念，用来容纳批量的数据。\n",
    "\n",
    "Python 的容器有很多种 —— 字符串，其实也是容器的一种，它的里面容纳着批量的字符。\n",
    "\n",
    "我们先简单接触一下另外一种容器：**列表**（List）。\n",
    "\n",
    "列表的标示，用方括号 `[]`；举例来说，`[1, 2, 3, 4, 5]` 和 `['ann', 'bob', 'cindy', 'dude', 'eric']`，或者 `['a', 2, 'b', 32, 22, 12]` 都是一个列表。\n",
    "\n",
    "因为列表和字符串一样，都是*有序容器*（容器还有另外一种是无序容器），所以，它们可用的操作符其实相同：\n",
    "\n",
    "> * 拼接：`+` 和 `' '`（后者是空格）\n",
    "> * 拷贝：`*`\n",
    "> * 逻辑运算：`in`、`not in`；以及，`<`、`<=`、`>`、`>=`、`!=`、`==`\n",
    "\n",
    "两个列表在比较时（前提是两个列表中的数据元素类型相同），遵循的还是跟字符串比较相同的规则：“一旦决出胜负马上停止”。但实际上，由于列表中可以包含不同类型的元素，所以，通常情况下没有实际需求对他们进行 “大于、小于” 的比较。（比较时，类型不同会引发 `TypeError`……）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.core.interactiveshell import InteractiveShell\n",
    "InteractiveShell.ast_node_interactivity = \"all\"\n",
    "\n",
    "a_list = [1, 2, 3, 4, 5]\n",
    "b_list = [1, 2, 3, 5]\n",
    "c_list = ['ann', 'bob', 'cindy', 'dude', 'eric']\n",
    "a_list > b_list\n",
    "10 not in a_list\n",
    "'ann' in c_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": false
   },
   "source": [
    "## 更复杂的运算"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "对于数字进行加、减、乘、除、商、余、幂的操作，对于字符串进行拼接、拷贝、属于的操作，对布尔值进行或、与、非的操作，这些都是相对简单的运算。\n",
    "\n",
    "更为复杂一点的，我们要通过调用函数来完成 —— 因为在函数内部，我们可以用比 “单个表达式” 更为复杂的程序针对传递进来的参数进行运算。换言之，函数就相当于各种事先写好的子程序，给它传递一个值，它会对其进行运算，而后返回一个值（最起码返回一个 `None`）。\n",
    "\n",
    "以下是 Python 语言所有的内建函数（[Built-in Functions](https://docs.python.org/3/library/functions.html)）：\n",
    "\n",
    "| ( | Python | Built-in  |  Functions   |  )  |\n",
    "| --- | --- | --- | --- | --- |\n",
    "| [abs()](https://docs.python.org/3/library/functions.html#abs) | [delattr()](https://docs.python.org/3/library/functions.html#delattr) | [hash()](https://docs.python.org/3/library/functions.html#hash) | [memoryview()](https://docs.python.org/3/library/functions.html#func-memoryview) | [set()](https://docs.python.org/3/library/functions.html#func-set) |\n",
    "| [all()](https://docs.python.org/3/library/functions.html#all) | [dict()](https://docs.python.org/3/library/functions.html#func-dict) | [help()](https://docs.python.org/3/library/functions.html#help) | [min()](https://docs.python.org/3/library/functions.html#min) | [setattr()](https://docs.python.org/3/library/functions.html#setattr) |\n",
    "| [any()](https://docs.python.org/3/library/functions.html#any) | [dir()](https://docs.python.org/3/library/functions.html#dir) | [hex()](https://docs.python.org/3/library/functions.html#hex) | [next()](https://docs.python.org/3/library/functions.html#next) | [slice()](https://docs.python.org/3/library/functions.html#slice) |\n",
    "| [ascii()](https://docs.python.org/3/library/functions.html#ascii) | [divmod()](https://docs.python.org/3/library/functions.html#divmod) | [id()](https://docs.python.org/3/library/functions.html#id)  | [object()](https://docs.python.org/3/library/functions.html#object) | [sorted()](https://docs.python.org/3/library/functions.html#sorted) |\n",
    "| [bin()](https://docs.python.org/3/library/functions.html#bin) | [enumerate()](https://docs.python.org/3/library/functions.html#enumerate) | [input()](https://docs.python.org/3/library/functions.html#input) | [oct()](https://docs.python.org/3/library/functions.html#oct) | [staticmethod()](https://docs.python.org/3/library/functions.html#staticmethod) |\n",
    "| [bool()](https://docs.python.org/3/library/functions.html#bool) | [eval()](https://docs.python.org/3/library/functions.html#eval) | [int()](https://docs.python.org/3/library/functions.html#int) | [open()](https://docs.python.org/3/library/functions.html#open) | [str()](https://docs.python.org/3/library/functions.html#func-str) |\n",
    "| [breakpoint()](https://docs.python.org/3/library/functions.html#breakpoint) | [exec()](https://docs.python.org/3/library/functions.html#exec) | [isinstance()](https://docs.python.org/3/library/functions.html#isinstance) | [ord()](https://docs.python.org/3/library/functions.html#ord) | [sum()](https://docs.python.org/3/library/functions.html#sum) |\n",
    "| [bytearray()](https://docs.python.org/3/library/functions.html#func-bytearray) | [filter()](https://docs.python.org/3/library/functions.html#filter) | [issubclass()](https://docs.python.org/3/library/functions.html#issubclass) | [pow()](https://docs.python.org/3/library/functions.html#pow) | [super()](https://docs.python.org/3/library/functions.html#super) |\n",
    "| [bytes()](https://docs.python.org/3/library/functions.html#func-bytes) | [float()](https://docs.python.org/3/library/functions.html#float) | [iter()](https://docs.python.org/3/library/functions.html#iter) | [print()](https://docs.python.org/3/library/functions.html#print) | [tuple()](https://docs.python.org/3/library/functions.html#func-tuple) |\n",
    "| [callable()](https://docs.python.org/3/library/functions.html#callable) | [format()](https://docs.python.org/3/library/functions.html#format) | [len()](https://docs.python.org/3/library/functions.html#len) | [property()](https://docs.python.org/3/library/functions.html#property) | [type()](https://docs.python.org/3/library/functions.html#type) |\n",
    "| [chr()](https://docs.python.org/3/library/functions.html#chr) | [frozenset()](https://docs.python.org/3/library/functions.html#func-frozenset) | [list()](https://docs.python.org/3/library/functions.html#func-list) | [range()](https://docs.python.org/3/library/functions.html#func-range) | [vars()](https://docs.python.org/3/library/functions.html#vars) |\n",
    "| [classmethod()](https://docs.python.org/3/library/functions.html#classmethod) | [getattr()](https://docs.python.org/3/library/functions.html#getattr) | [locals()](https://docs.python.org/3/library/functions.html#locals) | [repr()](https://docs.python.org/3/library/functions.html#repr) | [zip()](https://docs.python.org/3/library/functions.html#zip) |\n",
    "| [compile()](https://docs.python.org/3/library/functions.html#compile) | [globals()](https://docs.python.org/3/library/functions.html#globals) | [map()](https://docs.python.org/3/library/functions.html#map) | [reversed()](https://docs.python.org/3/library/functions.html#reversed) | [__import__()](https://docs.python.org/3/library/functions.html#__import__) |\n",
    "| [complex()](https://docs.python.org/3/library/functions.html#complex) | [hasattr()](https://docs.python.org/3/library/functions.html#hasattr) | [max()](https://docs.python.org/3/library/functions.html#max) | [round()](https://docs.python.org/3/library/functions.html#round) |  |\n",
    "\n",
    "现在倒不用着急一下子全部了解它们 —— 反正早晚都会的。\n",
    "\n",
    "这其中，针对数字，有计算绝对值的函数 `abs()`，有计算商余的函数 `divmod()` 等等。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.1415926"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "(3, 2)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.core.interactiveshell import InteractiveShell\n",
    "InteractiveShell.ast_node_interactivity = \"all\"\n",
    "\n",
    "abs(-3.1415926)\n",
    "divmod(11, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这些内建函数也依然只能完成 “基本操作”，比如，对于数字，我们想计算三角函数的话，内建函数就帮不上忙了，于是，我们需要调用标准库（Standard Library）中的 math 模块（Module）："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.9589242746631385"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "math.sin(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "代码 `math.sin(5)` 这里的 `.`，也可以被理解为 “操作符”，它的作用是：\n",
    "\n",
    "> 从其它模块中调用函数。\n",
    "\n",
    "代码 `math.sin(5)` 的作用是：\n",
    "\n",
    "> 把 `5` 这个值，传递给 `math` 这个模块里的 `sin()` 函数，让 `sin()` 根据它内部的代码对这个值进行运算，而后返回一个值（即，计算结果）。\n",
    "\n",
    "类（Class）中定义的函数，也可以这样被调用 —— 虽然你还不明白类（Class）究竟是什么，但从结构上很容易理解，它实际上也是保存在其他文件中的一段代码，于是，那段代码内部定义的函数，也可以这样调用。\n",
    "\n",
    "比如，数字，其实属于一个类，所以，我们可以调用那个类里所定义的函数，比如，`float.as_integer_ratio()`，它将返回两个值，第一个值除以第二个值，恰好等于传递给它的那个浮点数字参数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3537118815677477, 1125899906842624)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3.1415926.as_integer_ratio()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 关于布尔值的补充"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "当你看到以下这样的表达式，而后再看看它的结果，你可能会多少有点迷惑："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True or 'Python'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这是因为 Python 将 `True` 定义为：\n",
    "\n",
    "> By default, an object is considered true unless its class defines either a \\_\\_bool\\_\\_() method that returns `False` or a \\_\\_len\\_\\_() method that returns zero, when called with the object.\n",
    ">\n",
    "> https://docs.python.org/3/library/stdtypes.html#truth-value-testing\n",
    "\n",
    "这一段文字，初学者是看不懂的。但下一段就好理解了：\n",
    "\n",
    "> Here are most of the built-in objects considered `False`:\n",
    "> \n",
    "> > * constants defined to be false: `None` and `False`.\n",
    "> > * zero of any numeric type: `0`, `0.0`, `0j`, `Decimal(0)`, `Fraction(0, 1)`\n",
    "> > * empty sequences and collections: `''`, `()`, `[]`, `{}`, `set()`, `range(0)`\n",
    "\n",
    "所以，`'Python'` 是个非空的字符串，即，不属于是 `empty sequences`，所以它不被认为是 `False`，即，它的布尔值是 `True`\n",
    "\n",
    "于是，这么理解就轻松了：\n",
    "\n",
    "> 每个变量或者常量，除了它们的值之外，同时还相当于有一个对应的布尔值。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 关于值的类型的补充"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "除了数字、布尔值、字符串，以及上一小节介绍的列表之外，还有若干数据类型，比如 `range()`（等差数列）、`tuple`（元组）、`set`（集合）、`dictionary`（字典），再比如 `Date Type`（日期）等等。\n",
    "\n",
    "它们都是基础数据类型的各种组合 —— 现实生活中，更多需要的是把基础类型组合起来构成的数据。比如，一个通讯簿，里面是一系列字符串分别对应着若干字符串和数字。\n",
    "\n",
    "``` python\n",
    "entry[3662] = {\n",
    "    'first_name': 'Michael',\n",
    "    'last_name': 'Willington',\n",
    "    'birth_day': '12/07/1992',\n",
    "    'mobile': {\n",
    "        '+714612234', \n",
    "        '+716253923'\n",
    "    }\n",
    "    'id': 3662,\n",
    "    ...\n",
    "}\n",
    "```  \n",
    "\n",
    "针对不同的类型，都有相对应的操作符，可以对其进行运算。\n",
    "\n",
    "这些类型之间有时也有不得不相互运算的需求，于是，在相互运算之前同样要 _Type Casting_，比如将 List 转换为 Set，或者反之："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5, 6, 7}"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.core.interactiveshell import InteractiveShell\n",
    "InteractiveShell.ast_node_interactivity = \"all\"\n",
    "\n",
    "a = [1, 2, 3, 4, 5, 6, 7]\n",
    "b = set(a)\n",
    "c = list(b)\n",
    "a\n",
    "b\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 总结"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "回到最开始：从结构上来看，一切的计算机程序，都由且只由两个最基本的成分构成：\n",
    "\n",
    "> * **运算**（Evaluation）\n",
    "> * **流程控制**（Control Flow）\n",
    "\n",
    "这一章主要介绍了基础数据类型的运算细节。而除了基础数据类型，我们需要由它们组合起来的更多复杂数据类型。但无论数据的类型是什么，被操作符操作的总是该数据的**值**。所以，虽然绝大多数编程书籍按照惯例会讲解 “数据类型”，但为了究其本质，我们在这里关注的是 “值的类型”。虽然只是关注焦点上的一点点转换，但实践证明，这一点点的不同，对初学者更清楚地把握知识点有巨大的帮助。\n",
    "\n",
    "针对每一种*值*的类型，无论简单复杂，都有相应的操作方式：\n",
    "\n",
    "> * **操作符**\n",
    ">   * 值运算\n",
    ">   * 逻辑运算\n",
    "> *  **函数**\n",
    ">   * 内建函数\n",
    ">   * 其他模块里的函数\n",
    ">   * 其本身所属类之中所定义的函数\n",
    "\n",
    "所以，接下来要学习的，无非就是熟悉各种*数据类型*，及其相应的操作，包括能对它们的*值*进行操作的操作符和函数；无论是操作符还是函数，最终都会返回一个相应的**值**，及其相应的*布尔值* —— 这么看来，编程知识结构没多复杂。因为换句话讲，\n",
    "\n",
    "> 接下来你要学习的无非是各种*数据类型*的*运算*而已。\n",
    "\n",
    "另外，虽然现在尚未来得及对**函数**进行深入讲解，但最终你会发现它跟操作符一样，在程序里无所不在。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 备注"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "另外，以下几个链接先放在这里，未来你会返回来参考它们，还是不断地参考它们：\n",
    "\n",
    "> * 关于表达式：https://docs.python.org/3/reference/expressions.html\n",
    "> * 关于所有操作的优先级：https://docs.python.org/3/reference/expressions.html#operator-precedence\n",
    "> * 上一条链接不懂 BNF 的话根本读不懂：https://en.wikipedia.org/wiki/Backus-Naur_form\n",
    "> * Python 的内建函数：https://docs.python.org/3/library/functions.html\n",
    "> * Python 的标准数据类型：https://docs.python.org/3/library/stdtypes.html\n",
    "\n",
    "另外，其实所有的操作符，在 Python 内部也是调用函数完成的……\n",
    "\n",
    "> https://docs.python.org/3.7/library/operator.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"./Part.1.E.3.controlflow.ipynb\"><small>Next Page</small></a>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}


================================================
FILE: Part.1.E.3.controlflow.ipynb
================================================
{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 流程控制"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在相对深入了解了值的基本操作之后，我们需要再返回来对流程控制做更深入的了解。\n",
    "\n",
    "之前我们看过这个寻找质数的程序：\n",
    "\n",
    "```python\n",
    "for n in range(2, 100):\n",
    "    if n == 2:\n",
    "        print(n)\n",
    "        continue\n",
    "    for i in range(2, n):\n",
    "        if (n % i) == 0:\n",
    "            break\n",
    "    else:\n",
    "        print(n)  \n",
    "```\n",
    "\n",
    "这其中，包含了*分支*与*循环* —— 无论多复杂的流程控制用这两个东西就够了，就好像无论多复杂的电路最终都是由通路和开路仅仅两个状态构成的一样。\n",
    "\n",
    "> 今天的人们觉得这是 “天经地义” 的事情，可实际上并非如此。这是 1966 年的一篇论文所带来的巨大改变 —— *Flow diagrams, turing machines and languages with only two formation rules* by Böhm and Jacopini (1966)。实际上，直到上个世纪末，`GOTO` 语句才从各种语言里近乎 “灭绝”……\n",
    ">\n",
    "> 任何进步，无论大小，其实都相当不容易，都非常耗时费力 —— 在哪儿都一样。有兴趣、有时间，可以去浏览 Wikipedia 上的简要说明 —— [Wikipedia: Minimal structured control flow](https://en.wikipedia.org/wiki/Control_flow#Goto)。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## if 语句"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`if` 语句的最简单构成是这样 —— 注意第 1 行末尾的冒号 `:` 和第 2 行的缩进：\n",
    "\n",
    "```python\n",
    "if expression:\n",
    "    statements\n",
    "```\n",
    "\n",
    "如果表达式 `expression` 返回值为真，执行 `if` 语句块内部的 `statements`，否则，什么都不做，执行 `if` 之后的下一个语句。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "372 is even.\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "r = random.randrange(1, 1000)\n",
    "\n",
    "if r % 2 == 0:\n",
    "    print(f'{r} is even.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果，表达式 `expression` 返回值无论真假，我们都需要做一点相应的事情，那么我们这么写：\n",
    "\n",
    "```python\n",
    "if expression:\n",
    "    statements_for_True\n",
    "else:\n",
    "    statements_for_False\n",
    "```\n",
    "\n",
    "如果表达式 `expression` 返回值为真，执行 `if` 语句块内部的 `statements_for_True`，否则，就执行 `else` 语句块内部的 `statements_for_False`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "945 is odd.\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "r = random.randrange(1, 1000)\n",
    "\n",
    "if r % 2 == 0:\n",
    "    print(f'{r} is even.')\n",
    "else:\n",
    "    print(f'{r} is odd.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "有时，表达式 `<expression>` 返回的值有多种情况，并且针对不同的情况我们都要做相应的事情，那么可以这么写：\n",
    "\n",
    "```python\n",
    "if expression_1:\n",
    "    statements_for_expression_1_True\n",
    "    \n",
    "elif expression_2:\n",
    "    statements_for_expression_2_True\n",
    "\n",
    "elif expression_3:\n",
    "    statements_for_expression_3_True\n",
    "\n",
    "elif expression_...:\n",
    "    statements_for_expression_..._True\n",
    "```\n",
    "\n",
    "Python 用 `elif` 处理这种多情况分支，相当于其它编程语言中使用 `switch` 或者 `case`……\n",
    "\n",
    "`elif` 是 `else if` 的缩写，作用相同。\n",
    "\n",
    "以下程序模拟投两个骰子的结果 —— 两个骰子数字加起来，等于 `7` 算平，大于 `7` 算大，小于 `7` 算小："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Big!\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "r = random.randrange(2, 13)\n",
    "\n",
    "if r == 7:\n",
    "    print('Draw!')\n",
    "elif r < 7:\n",
    "    print('Small!')\n",
    "elif r > 7:\n",
    "    print('Big!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "当然你还可以模拟投飞了的情况，即，最终的骰子数是 `0` 或者 `1`，即，`< 2`："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Small!\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "r = random.randrange(0, 13) # 生成的随机数应该从 0 开始了；\n",
    "\n",
    "if r == 7:\n",
    "    print('Draw!')\n",
    "elif r >= 2 and r < 7:      # 如果这里直接写 elif r < 7:，那么，else: 那一部分永远不会被执行……\n",
    "    print('Small!')\n",
    "elif r > 7:\n",
    "    print('Big!')\n",
    "else:\n",
    "    print('Not valid!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": false
   },
   "source": [
    "## for 循环"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python 语言中，`for` 循环不使用其它语言中那样的计数器，取而代之的是 `range()` 这个我称其为 “整数等差数列生成器” 的函数。\n",
    "\n",
    "用 C 语言写循环是这样的：\n",
    "\n",
    "```C\n",
    "for( a = 0; a < 10; a = a + 1 ){\n",
    "    printf(\"value of a: %d\\n\", a);\n",
    "}\n",
    "```\n",
    "\n",
    "用 Python 写同样的东西，是这样的："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "value of a: 0\n",
      "value of a: 1\n",
      "value of a: 2\n",
      "value of a: 3\n",
      "value of a: 4\n",
      "value of a: 5\n",
      "value of a: 6\n",
      "value of a: 7\n",
      "value of a: 8\n",
      "value of a: 9\n"
     ]
    }
   ],
   "source": [
    "for a in range(10):\n",
    "    print(f'value of a: {a}') #每次 a 的值都不同，从 0 递增至 9"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### range() 函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`range()` 是个内建函数，[它的文档](https://docs.python.org/3/library/functions.html#func-range)是这样写的：\n",
    "\n",
    "> **range**(_stop_) \n",
    ">\n",
    "> **range**(_start, stop[, step]_)\n",
    "\n",
    "只有一个参数的时候，这个参数被理解为 `stop`，生成一个从 `0` 开始，到 `stop - 1` 的整数数列。\n",
    "\n",
    "这就解释了为什么有的时候我们会在 `for ... in range(...):` 这种循环内的语句块里进行计算的时候，经常会在变量之后写上 `+ 1`，因为我们 range(n) 的返回数列中不包含 `n`，但我们有时候却需要 `n`。[点击这里返回看看第一章里提到的例子：所谓算法那一小节](Part.1.E.1.entrance.ipynb#plusone)。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 10)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.core.interactiveshell import InteractiveShell\n",
    "InteractiveShell.ast_node_interactivity = \"all\"\n",
    "\n",
    "range(10)\n",
    "list(range(10)) # 将 range(10) 转换成 list，以便清楚看到其内容。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`start` 参数的默认值是 `0`。如需指定起点，那么得给 `range()` 传递两个参数，比如，`range(2, 13)`……"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(2, 13))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "第三个参数可选；`step`，步长，就相当于是 “等差数列” 当中的 “差”，默认值是 `1`。例如，`range(1, 10, 2)` 生成的是这样一个数列 `[1, 3, 5, 7, 9]`。所以，打印 `0 ～ 10` 之间的所有奇数，可以这样写："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "5\n",
      "7\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for i in range(1, 10, 2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们也可以生成负数的数列："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(0, -10, -1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Continue、Break 和 Pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在循环的过程中，还可以用 `continue` 和 `break` 控制流程走向，通常是在某条件判断发生的情况下 —— 正如你早就见过的那样：\n",
    "\n",
    "```python\n",
    "for n in range(2, 100):\n",
    "    if n == 2:\n",
    "        print(n)\n",
    "        continue\n",
    "    for i in range(2, n):\n",
    "        if (n % i) == 0:\n",
    "            break\n",
    "    else:\n",
    "        print(n)  \n",
    "```\n",
    "\n",
    "`continue` 语句将忽略其后的语句开始下次循环，而 `break` 语句将从此结束当前循环，开始执行循环之后的语句：\n",
    "\n",
    "![](images/continue-break.png)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`for` 语句块还可以附加一个 `else` —— 这是 Python 的一个比较有个性的地方。附加在 `for` 结尾的 `else` 语句块，_在没有 `break` 发生的情况下会运行_。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "5\n",
      "7\n",
      "11\n",
      "13\n",
      "17\n",
      "19\n",
      "23\n",
      "29\n",
      "31\n",
      "37\n",
      "41\n",
      "43\n",
      "47\n",
      "53\n",
      "59\n",
      "61\n",
      "67\n",
      "71\n",
      "73\n",
      "79\n",
      "83\n",
      "89\n",
      "97\n"
     ]
    }
   ],
   "source": [
    "for n in range(2, 100):\n",
    "    if n == 2:\n",
    "        print(n)\n",
    "        continue\n",
    "    for i in range(2, n):\n",
    "        if (n % i) == 0:\n",
    "            break\n",
    "    else:               # 下一行的 print(n) 事实上属于语句块 for i in range(2, n):\n",
    "        print(n)        # 整个循环结束，都没有发生 break 的情况下，才执行一次 print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "试比较以下两段代码："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for n in range(2, 100):\n",
    "    if n == 2:\n",
    "        print(n)\n",
    "        continue\n",
    "    for i in range(2, n):\n",
    "        if (n % i) == 0:\n",
    "            break\n",
    "    print(n)            # 事实上相当于针对 range(2, 100) 中每个 n 都执行了一次 print(n)\n",
    "                        # 这个 print(n) 属于语句块 for n in range(2, 100): "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "5\n",
      "5\n",
      "5\n",
      "7\n",
      "7\n",
      "7\n",
      "7\n",
      "7\n",
      "9\n",
      "11\n",
      "11\n",
      "11\n",
      "11\n",
      "11\n",
      "11\n",
      "11\n",
      "11\n",
      "11\n",
      "13\n",
      "13\n",
      "13\n",
      "13\n",
      "13\n",
      "13\n",
      "13\n",
      "13\n",
      "13\n",
      "13\n",
      "13\n",
      "15\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "19\n",
      "19\n",
      "19\n",
      "19\n",
      "19\n",
      "19\n",
      "19\n",
      "19\n",
      "19\n",
      "19\n",
      "19\n",
      "19\n",
      "19\n",
      "19\n",
      "19\n",
      "19\n",
      "19\n",
      "21\n",
      "23\n",
      "23\n",
      "23\n",
      "23\n",
      "23\n",
      "23\n",
      "23\n",
      "23\n",
      "23\n",
      "23\n",
      "23\n",
      "23\n",
      "23\n",
      "23\n",
      "23\n",
      "23\n",
      "23\n",
      "23\n",
      "23\n",
      "23\n",
      "23\n",
      "25\n",
      "25\n",
      "25\n",
      "27\n",
      "29\n",
      "29\n",
      "29\n",
      "29\n",
      "29\n",
      "29\n",
      "29\n",
      "29\n",
      "29\n",
      "29\n",
      "29\n",
      "29\n",
      "29\n",
      "29\n",
      "29\n",
      "29\n",
      "29\n",
      "29\n",
      "29\n",
      "29\n",
      "29\n",
      "29\n",
      "29\n",
      "29\n",
      "29\n",
      "29\n",
      "29\n",
      "31\n",
      "31\n",
      "31\n",
      "31\n",
      "31\n",
      "31\n",
      "31\n",
      "31\n",
      "31\n",
      "31\n",
      "31\n",
      "31\n",
      "31\n",
      "31\n",
      "31\n",
      "31\n",
      "31\n",
      "31\n",
      "31\n",
      "31\n",
      "31\n",
      "31\n",
      "31\n",
      "31\n",
      "31\n",
      "31\n",
      "31\n",
      "31\n",
      "31\n",
      "33\n",
      "35\n",
      "35\n",
      "35\n",
      "37\n",
      "37\n",
      "37\n",
      "37\n",
      "37\n",
      "37\n",
      "37\n",
      "37\n",
      "37\n",
      "37\n",
      "37\n",
      "37\n",
      "37\n",
      "37\n",
      "37\n",
      "37\n",
      "37\n",
      "37\n",
      "37\n",
      "37\n",
      "37\n",
      "37\n",
      "37\n",
      "37\n",
      "37\n",
      "37\n",
      "37\n",
      "37\n",
      "37\n",
      "37\n",
      "37\n",
      "37\n",
      "37\n",
      "37\n",
      "37\n",
      "39\n",
      "41\n",
      "41\n",
      "41\n",
      "41\n",
      "41\n",
      "41\n",
      "41\n",
      "41\n",
      "41\n",
      "41\n",
      "41\n",
      "41\n",
      "41\n",
      "41\n",
      "41\n",
      "41\n",
      "41\n",
      "41\n",
      "41\n",
      "41\n",
      "41\n",
      "41\n",
      "41\n",
      "41\n",
      "41\n",
      "41\n",
      "41\n",
      "41\n",
      "41\n",
      "41\n",
      "41\n",
      "41\n",
      "41\n",
      "41\n",
      "41\n",
      "41\n",
      "41\n",
      "41\n",
      "41\n",
      "43\n",
      "43\n",
      "43\n",
      "43\n",
      "43\n",
      "43\n",
      "43\n",
      "43\n",
      "43\n",
      "43\n",
      "43\n",
      "43\n",
      "43\n",
      "43\n",
      "43\n",
      "43\n",
      "43\n",
      "43\n",
      "43\n",
      "43\n",
      "43\n",
      "43\n",
      "43\n",
      "43\n",
      "43\n",
      "43\n",
      "43\n",
      "43\n",
      "43\n",
      "43\n",
      "43\n",
      "43\n",
      "43\n",
      "43\n",
      "43\n",
      "43\n",
      "43\n",
      "43\n",
      "43\n",
      "43\n",
      "43\n",
      "45\n",
      "47\n",
      "47\n",
      "47\n",
      "47\n",
      "47\n",
      "47\n",
      "47\n",
      "47\n",
      "47\n",
      "47\n",
      "47\n",
      "47\n",
      "47\n",
      "47\n",
      "47\n",
      "47\n",
      "47\n",
      "47\n",
      "47\n",
      "47\n",
      "47\n",
      "47\n",
      "47\n",
      "47\n",
      "47\n",
      "47\n",
      "47\n",
      "47\n",
      "47\n",
      "47\n",
      "47\n",
      "47\n",
      "47\n",
      "47\n",
      "47\n",
      "47\n",
      "47\n",
      "47\n",
      "47\n",
      "47\n",
      "47\n",
      "47\n",
      "47\n",
      "47\n",
      "47\n",
      "49\n",
      "49\n",
      "49\n",
      "49\n",
      "49\n",
      "51\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "53\n",
      "55\n",
      "55\n",
      "55\n",
      "57\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "59\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "61\n",
      "63\n",
      "65\n",
      "65\n",
      "65\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "67\n",
      "69\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "71\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "73\n",
      "75\n",
      "77\n",
      "77\n",
      "77\n",
      "77\n",
      "77\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "79\n",
      "81\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",
      "83\n",