基础教程/A1-Python与基础知识/Python介绍.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Python编程环境"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Guido Van Rossum和版本 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### [Guido](https://gvanrossum.github.io/)是[Python](https://www.python.org/)的作者![avatar](http://bazhou.blob.core.windows.net/learning/mpp/guido.jpg)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "在下面的访谈中，[Peter Norvig](https://en.wikipedia.org/wiki/Peter_Norvig)也没有念对他的名字，Guido的主页有它的荷兰语发音。\n",
    "<br><br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<video width=\"80%\" controls src=\"http://bazhou.blob.core.windows.net/learning/mpp/142_Guido_Van_Rossum.mp4\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    ">他在[stackoverflow](https://stackoverflow.com/users/818274/guido-van-rossum)和[github](https://github.com/gvanrossum)上非常活跃。他的[twitter](https://twitter.com/gvanrossum)更新很勤。\n",
    "\n",
    "![Guido_twitter](http://bazhou.blob.core.windows.net/learning/mpp/guido_tweet_996.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- 抛开Python的[前世、今生和未来](http://bazhou.blob.core.windows.net/learning/mpp/python-past-present-and-future-with-guido-van-rossum.mp3) 第一个现实问题是：版本。\n",
    "- Python有两个版本：2和3。\n",
    "- 我们用版本3，再确切些，3.6.5。\n",
    "- 版本问题会引起很大的麻烦，这门课的解决方法是Docker。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 我们使用Python[3.6](https://docs.python.org/3/whatsnew/3.6.html)![py3ver](http://bazhou.blob.core.windows.net/learning/mpp/py3ver.gif)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Shell Script  REPL"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- Shell 命令输入处"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- Script 命令"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- REPL Read-Evaluate-Print-Loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 挑战：获得这门课程的词汇表"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- 17段视频的字幕文件"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "![shell_challenge](http://bazhou.blob.core.windows.net/learning/mpp/shell_challenge.gif)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- 输入数据[例子](http://bazhou.blob.core.windows.net/learning/mpp/msxpy/16_253_6.2-wCnbczfN91s.txt)\n",
    "\n",
    "4\n",
    "\n",
    "00:00:14,010 --> 00:00:19,009\n",
    "\n",
    "In practice, you'll be working with data of\n",
    "different types: numerical values, strings,\n",
    "\n",
    "5\n",
    "\n",
    "00:00:19,009 --> 00:00:21,279\n",
    "\n",
    "booleans and so on.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- 用管道连接脚本"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```bash\n",
    "cat *.txt|./clean.sh #清洗字幕文件，分词\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```bash\n",
    "cat *.txt|./clean.sh|sort|uniq #去掉重复，排序\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```bash\n",
    "cat *.txt|./clean.sh|sort|uniq|wc #统计单词数\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- 清洗字幕脚本 [clean.sh](http://bazhou.blob.core.windows.net/learning/mpp/msxpy/clean.sh)\n",
    "\n",
    "```bash\n",
    "#!/bin/sh\n",
    "tr '[:blank:]' '\\n'|tr '[:upper:]' '[:lower:]'|tr -d '\\r'|grep -vE \"'\"|grep -vE \"\\.\"|tr -d '[:punct:]'|grep -vE \"^[^a-zA-Z].*\"|grep -vE \".*[0-9].*\"\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Jupyter\n",
    "\n",
    "[命名](https://news.ycombinator.com/item?id=16978364)\n",
    "![jupiter](http://bazhou.blob.core.windows.net/learning/mpp/jupiter.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Jupyter\n",
    "\n",
    ">Jupyter像Shell一样，在cell里编辑，在cell里运行，循环往复\n",
    "\n",
    "- R 编辑cell，Enter\n",
    "- E 运行cell，Shift+Enter\n",
    "- P 打印cell\n",
    "- L 下个cell\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world\n"
     ]
    }
   ],
   "source": [
    "print(\"hello world\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# 变量和数据类型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 数字及其运算"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- 计算身高体重指数\n",
    "- BMI(Body Mass Index) 公式\n",
    "  \\begin{equation}BMI = \\frac{weight}{height^{2}}\\end{equation}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "height = 1.79 # 身高1米79"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "weight = 68.7 # 体重68.7公斤"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "bmi = weight / height ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21.44127836209856"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bmi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- 数据类型\n",
    "- float/int\n",
    "- str\n",
    "- bool"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(bmi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(\"hello world\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 + True # 数据类型转换"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "must be str, not int",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-49-c938292d0a35>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;34m\"hello\"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m2\u001b[0m \u001b[0;31m# 运算是有类型的\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: must be str, not int"
     ]
    }
   ],
   "source": [
    "\"hello\" + 2 # 运算是有类型的 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "\"hello\" + \"world\" # + : 字符串连接"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24.4"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 + 22.4 # + ： 加法; 数据类型转换 int → float "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "77 % 17 # 取模"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "77 // 17 # 求商"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 字符串及其运算\n",
    ">字符串是字符的集合"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```python\n",
    "he = \"他\"\n",
    "didnt = \"没\"\n",
    "verb = \"上\"\n",
    "obj = \"上海的车\"\n",
    "# 用字符串组成另一个字符串\n",
    "he + didnt + verb * 3 + obj\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'他没上上上上海的车'"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "he = \"他\"\n",
    "didnt = \"没\"\n",
    "verb = \"上\"\n",
    "obj = \"上海的车\"\n",
    "# 用字符串组成另一个字符串\n",
    "he + didnt + verb * 3 + obj"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- 如果 + * 代表往字符串集合中增加元素\n",
    "- 那么 - / 运算是取字符串集合的子集？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for -: 'str' and '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-87-10dd2cf33aec>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mobj\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mverb\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for -: 'str' and 'str'"
     ]
    }
   ],
   "source": [
    "obj - verb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for /: 'str' and '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-88-c4565663bc96>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mobj\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0mverb\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for /: 'str' and 'str'"
     ]
    }
   ],
   "source": [
    "obj / verb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'海'"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'上'"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "(he + didnt + verb * 3 + obj)[2:6] # 包括第2，但不包括第6，从第0开始"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 布尔型及其运算"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bmi > 25"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(bmi > 25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bmi > 20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bmi > 20 and not bmi > 25 # and, or, not"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bmi > 20 and bmi < 25  # 更符合阅读习惯的写法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bmi == bmi or bmi != bmi # 完全正确"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bmi == he or bmi != he "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 分支"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "bmi = 40\n",
    "if bmi > 40:                 # Python用缩进区分block\n",
    "    print(\"hyper obese\")     # 注意这行的开头有TAB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hyper obese\n"
     ]
    }
   ],
   "source": [
    "bmi = 45                       # 改变bmi，观察分支选择\n",
    "if bmi > 40:\n",
    "    print(\"hyper obese\")\n",
    "else:\n",
    "    print(\"not hyper obese\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hyper obese\n"
     ]
    }
   ],
   "source": [
    "# 对bmi值进行分类\n",
    "if bmi > 40:\n",
    "    print(\"hyper obese\")\n",
    "elif bmi > 35 and bmi <= 40:\n",
    "    print(\"super obese\")\n",
    "elif bmi > 30 and bmi <= 35:\n",
    "    print(\"obese\")\n",
    "elif bmi > 25 and bmi <= 30:\n",
    "    print(\"over weight\")\n",
    "elif bmi > 18.5 and bmi <= 25:\n",
    "    print(\"normal\")\n",
    "elif bmi > 16 and bmi <= 18.5:\n",
    "    print(\"under weight\")\n",
    "else :\n",
    "    print(\"slim\") # https://en.wikipedia.org/wiki/Body_mass_index"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### 根据[肥胖分类定义](https://en.wikipedia.org/wiki/Body_mass_index)补全上面的分类代码\n",
    "\n",
    "| type                      | from |   to |\n",
    "|---------------------------|------|------|\n",
    "| very severely underweight |      |   15 |\n",
    "| severely underweight      |   15 |   16 |\n",
    "| underweight               |   16 | 18.5 |\n",
    "| normal                    | 18.5 |   25 |\n",
    "| overweight                |   25 |   30 |\n",
    "| moderately obese          |   30 |   35 |\n",
    "| severely obese            |   35 |   40 |\n",
    "| very severely obese       |   40 |   45 |\n",
    "| morbidly obese            |   45 |   50 |\n",
    "| super obese               |   50 |   60 |\n",
    "| hyper obese               |   60 |      |\n",
    "\n",
    ">可见，各个种族，地区，年龄段对于肥胖的定义是有很大差别的"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# 列表和循环"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 列表是数据的容器\n",
    ">已经学过一种容器：str"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 列表及其运算\n",
    "- 从通用List开始\n",
    "- 以后基本只关注数值类型容器\n",
    "- 注意程序语言和数学语言的映射"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['他', '没', '上', '上', '上', '上', '海', '的', '车']"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ret = he + didnt + verb * 3 + obj # 用一个变量保存计算结果\n",
    "l = list(ret)                     # 转换为列表\n",
    "l                                 # 可以把一个字符串转换为列表，反之？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['上', '上', '上', '上']"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l[2:6]  # 重复之前的操作，取出'上'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['他', '没']"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l[:2]   # 到第2个为止，不包括第2个，从第0个开始"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['上', '上', '上', '上', '海', '的', '车']"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l[2:]   # 从第2个开始"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'车'"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l[-1]   # 最后一个，或者，从右边开始第1个，注意不是从第0个开始"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "##### 负数索引\n",
    "\n",
    "|-9|-8|-7|-6|-5|-4|-3|-2|-1|0|1|2|3|4|5|6|7|8|\n",
    "|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|\n",
    "|他|没|上|上|上|上|海|的|车|他|没|上|上|上|上|海|的|车|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['的']"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l[-2:-1] # 虽然索引是从右往左计数的，但范围和这些数字的排列顺序是一致的"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "|-9|-8|-7|-6|-5|-4|-3|-2|-1|0|1|2|3|4|5|6|7|8|\n",
    "|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|\n",
    "|他|没|上|上|上|上|海|的|车|他|没|上|上|上|上|海|的|车|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['的', '车']"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l[-2:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "|-9|-8|-7|-6|-5|-4|-3|-2|-1|0|1|2|3|4|5|6|7|8|\n",
    "|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|\n",
    "|他|没|上|上|上|上|海|的|车|他|没|上|上|上|上|海|的|车|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['上', '上', '上', '上']"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l[-7:-3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "|-9|-8|-7|-6|-5|-4|-3|-2|-1|0|1|2|3|4|5|6|7|8|\n",
    "|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|\n",
    "|他|没|上|上|上|上|海|的|车|他|没|上|上|上|上|海|的|车|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['他', '没', '上', '上', '上', '上', '海', '的', '车']"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l[:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "|-9|-8|-7|-6|-5|-4|-3|-2|-1|0|1|2|3|4|5|6|7|8|\n",
    "|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|\n",
    "|他|没|上|上|上|上|海|的|车|他|没|上|上|上|上|海|的|车|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "18"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = [6, 7, 3, 3, 3, 3, 10, 8, 4] # 特征：笔画数\n",
    "f = l + c\n",
    "len(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "f"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "#### 列表里面的数据可以是不同类型的"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['他', '没', '上', '上', '上', '上', '海', '的', '车', 0, 7, 3, 3, 3, 3, 10, 8, 4]"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g = f      # g只是f的另一个名字\n",
    "g[9] = 0   # 改变列表\n",
    "f          # f也会跟着变化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['他', '没', '上', '上', '上', '上', '海', '的', '车', 0, 7, 3, 3, 3, 3, 10, 8, 4]"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g = list(f) # 新创建一个列表\n",
    "f[9] = 6    # 改回去\n",
    "g           # g[9]仍然是0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['他', '没', '上', '上', '上', '上', '海', '的', '车', 7, 3, 3, 3, 3, 10, 8, 4]"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del g[9]   # 删掉第9个元素\n",
    "g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "18"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 循环"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "<class 'str'>\n",
      "<class 'str'>\n",
      "<class 'str'>\n",
      "<class 'str'>\n",
      "<class 'str'>\n",
      "<class 'str'>\n",
      "<class 'str'>\n",
      "<class 'str'>\n",
      "<class 'int'>\n",
      "<class 'int'>\n",
      "<class 'int'>\n",
      "<class 'int'>\n",
      "<class 'int'>\n",
      "<class 'int'>\n",
      "<class 'int'>\n",
      "<class 'int'>\n",
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "for v in f:\n",
    "    print(type(v)) # 注意这行的开头有TAB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(range(1)) # 只生成一个数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(1)[0]   # 这个数是0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 18)"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(len(f)) # f → f的索引"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 <class 'str'>\n",
      "1 <class 'str'>\n",
      "2 <class 'str'>\n",
      "3 <class 'str'>\n",
      "4 <class 'str'>\n",
      "5 <class 'str'>\n",
      "6 <class 'str'>\n",
      "7 <class 'str'>\n",
      "8 <class 'str'>\n",
      "9 <class 'int'>\n",
      "10 <class 'int'>\n",
      "11 <class 'int'>\n",
      "12 <class 'int'>\n",
      "13 <class 'int'>\n",
      "14 <class 'int'>\n",
      "15 <class 'int'>\n",
      "16 <class 'int'>\n",
      "17 <class 'int'>\n"
     ]
    }
   ],
   "source": [
    "for i in range(len(f)): # 以索引做循环变量\n",
    "    print(i, type(f[i]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 <class 'str'>\n",
      "1 <class 'str'>\n",
      "2 <class 'str'>\n",
      "3 <class 'str'>\n",
      "4 <class 'str'>\n",
      "5 <class 'str'>\n",
      "6 <class 'str'>\n",
      "7 <class 'str'>\n",
      "8 <class 'str'>\n",
      "9 <class 'int'>\n",
      "10 <class 'int'>\n",
      "11 <class 'int'>\n",
      "12 <class 'int'>\n",
      "13 <class 'int'>\n",
      "14 <class 'int'>\n",
      "15 <class 'int'>\n",
      "16 <class 'int'>\n",
      "17 <class 'int'>\n"
     ]
    }
   ],
   "source": [
    "for i, v in enumerate(f): # 上例的简化版本\n",
    "    print(i, type(v))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# 函数和库"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 函数的例子"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### 问题：求阶乘\\begin{equation}n!\\end{equation}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def fac(n):                        # 求阶乘\n",
    "    if n == 1:                     # 收敛条件\n",
    "        return 1\n",
    "    else:\n",
    "        return n * fac(n - 1)      # 递归引用本函数的函数名\n",
    "fac(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "ename": "RecursionError",
     "evalue": "maximum recursion depth exceeded in comparison",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mRecursionError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-125-eea0ffd091ad>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m9\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m                      \u001b[0;31m# 需要解决fac函数的一个bug\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfac\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-124-e14d56a19fe5>\u001b[0m in \u001b[0;36mfac\u001b[0;34m(n)\u001b[0m\n\u001b[1;32m      3\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mn\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mfac\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m      \u001b[0;31m# 递归引用本函数的函数名\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      6\u001b[0m \u001b[0mfac\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",
      "... last 1 frames repeated, from the frame below ...\n",
      "\u001b[0;32m<ipython-input-124-e14d56a19fe5>\u001b[0m in \u001b[0;36mfac\u001b[0;34m(n)\u001b[0m\n\u001b[1;32m      3\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mn\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mfac\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m      \u001b[0;31m# 递归引用本函数的函数名\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      6\u001b[0m \u001b[0mfac\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;31mRecursionError\u001b[0m: maximum recursion depth exceeded in comparison"
     ]
    }
   ],
   "source": [
    "for i in range(9):                      # 需要解决fac函数的一个bug\n",
    "    print(fac(i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### \\begin{equation}0!=1\\end{equation}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "fac(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### 用循环来定义阶乘函数\n",
    "```python\n",
    "def fac_loop(n):\n",
    "    ret = 1\n",
    "    for i in range(n):\n",
    "        ret = ret * (i + 1)\n",
    "    return ret\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def fac_loop(n):\n",
    "    ret = 1\n",
    "    for i in range(n):\n",
    "        ret = ret * (i + 1)\n",
    "    return ret\n",
    "print(fac_loop(5))\n",
    "print(fac_loop(0))\n",
    "print(fac_loop(1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### 问题：求组合数 \\begin{equation}{n\\choose k}=\\frac{n!}{(n-k)!k!}\\end{equation}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "270725.0"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def combination(n, k):             # 求组合数\n",
    "    return fac(n) / (fac(n - k) * fac(k))\n",
    "combination(52, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 函数的类型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "##### 函数的类型？\n",
    "```python\n",
    "type(fac)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "function"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(fac) # 和type(True)不是一样？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    ">函数的类型是参数类型到返回值类型两个类型集合的映射关系\n",
    "#### \\begin{equation} fac : int→int \\end{equation}\\begin{equation} combination: int, int → int \\end{equation}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "47"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max([23, 37, 13, 47]) # 输入类型是一个list，输出类型是一个数值"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 方法\n",
    ">第一个参数是固定函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[13, 23, 37, 47]"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pl = [23, 37, 13, 47]\n",
    "pl.sort()              # 输入类型是一个list，输出类型是一个list，类型实例和函数名之间用一个.连接\n",
    "pl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on method_descriptor:\n",
      "\n",
      "sort(...)\n",
      "    L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE*\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(list.sort)        # 获得在线帮助"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[47, 37, 23, 13]"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pl.sort(reverse=True) # 命名参数\n",
    "pl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class list in module builtins:\n",
      "\n",
      "class list(object)\n",
      " |  list() -> new empty list\n",
      " |  list(iterable) -> new list initialized from iterable's items\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __add__(self, value, /)\n",
      " |      Return self+value.\n",
      " |  \n",
      " |  __contains__(self, key, /)\n",
      " |      Return key in self.\n",
      " |  \n",
      " |  __delitem__(self, key, /)\n",
      " |      Delete self[key].\n",
      " |  \n",
      " |  __eq__(self, value, /)\n",
      " |      Return self==value.\n",
      " |  \n",
      " |  __ge__(self, value, /)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __getattribute__(self, name, /)\n",
      " |      Return getattr(self, name).\n",
      " |  \n",
      " |  __getitem__(...)\n",
      " |      x.__getitem__(y) <==> x[y]\n",
      " |  \n",
      " |  __gt__(self, value, /)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __iadd__(self, value, /)\n",
      " |      Implement self+=value.\n",
      " |  \n",
      " |  __imul__(self, value, /)\n",
      " |      Implement self*=value.\n",
      " |  \n",
      " |  __init__(self, /, *args, **kwargs)\n",
      " |      Initialize self.  See help(type(self)) for accurate signature.\n",
      " |  \n",
      " |  __iter__(self, /)\n",
      " |      Implement iter(self).\n",
      " |  \n",
      " |  __le__(self, value, /)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __len__(self, /)\n",
      " |      Return len(self).\n",
      " |  \n",
      " |  __lt__(self, value, /)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __mul__(self, value, /)\n",
      " |      Return self*value.n\n",
      " |  \n",
      " |  __ne__(self, value, /)\n",
      " |      Return self!=value.\n",
      " |  \n",
      " |  __new__(*args, **kwargs) from builtins.type\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  __repr__(self, /)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __reversed__(...)\n",
      " |      L.__reversed__() -- return a reverse iterator over the list\n",
      " |  \n",
      " |  __rmul__(self, value, /)\n",
      " |      Return self*value.\n",
      " |  \n",
      " |  __setitem__(self, key, value, /)\n",
      " |      Set self[key] to value.\n",
      " |  \n",
      " |  __sizeof__(...)\n",
      " |      L.__sizeof__() -- size of L in memory, in bytes\n",
      " |  \n",
      " |  append(...)\n",
      " |      L.append(object) -> None -- append object to end\n",
      " |  \n",
      " |  clear(...)\n",
      " |      L.clear() -> None -- remove all items from L\n",
      " |  \n",
      " |  copy(...)\n",
      " |      L.copy() -> list -- a shallow copy of L\n",
      " |  \n",
      " |  count(...)\n",
      " |      L.count(value) -> integer -- return number of occurrences of value\n",
      " |  \n",
      " |  extend(...)\n",
      " |      L.extend(iterable) -> None -- extend list by appending elements from the iterable\n",
      " |  \n",
      " |  index(...)\n",
      " |      L.index(value, [start, [stop]]) -> integer -- return first index of value.\n",
      " |      Raises ValueError if the value is not present.\n",
      " |  \n",
      " |  insert(...)\n",
      " |      L.insert(index, object) -- insert object before index\n",
      " |  \n",
      " |  pop(...)\n",
      " |      L.pop([index]) -> item -- remove and return item at index (default last).\n",
      " |      Raises IndexError if list is empty or index is out of range.\n",
      " |  \n",
      " |  remove(...)\n",
      " |      L.remove(value) -> None -- remove first occurrence of value.\n",
      " |      Raises ValueError if the value is not present.\n",
      " |  \n",
      " |  reverse(...)\n",
      " |      L.reverse() -- reverse *IN PLACE*\n",
      " |  \n",
      " |  sort(...)\n",
      " |      L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE*\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  __hash__ = None\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(list)             # 列出list的全部方法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### 问题：伟人排序\n",
    "|像|姓名|出生年|寿命|\n",
    "|-|-|-|-|\n",
    "| ![buddha](http://bazhou.blob.core.windows.net/learning/mpp/buddha.jpg)       |  佛陀       | 480BC  |   80 |\n",
    "| ![confucius](http://bazhou.blob.core.windows.net/learning/mpp/confucius.jpg) |  孔子       | 551BC  |   73 |\n",
    "| ![plato](http://bazhou.blob.core.windows.net/learning/mpp/plato.jpg)         |  柏拉图     | 428BC  |   80 |\n",
    "| ![zoroaster](http://bazhou.blob.core.windows.net/learning/mpp/zoroaster.jpg) | 琐罗亚斯德 | 500BC  |    ?  |\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# 新数据类型：dict\n",
    "great = [{'name':'Buddha', 'birth':-480, 'age':80}, \n",
    "         {'name':'Confucius', 'birth':-551, 'age':73}, \n",
    "         {'name':'Plato', 'birth':-428, 'age':80}, \n",
    "         {'name':'Zoroaster', 'birth':-500, 'age':float('nan')}]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Buddha'"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "great[0]['name'] # dict可以按照名字索引"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "73"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "great[1]['age']  # dict本身可以是list的元素"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "##### 无名函数\n",
    "\\begin{equation}\\lambda\\end{equation}\n",
    ">先定义一个函数再使用它有时不如在用它的地方定义它"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'name': 'Buddha', 'birth': -480, 'age': 80},\n",
       " {'name': 'Plato', 'birth': -428, 'age': 80},\n",
       " {'name': 'Confucius', 'birth': -551, 'age': 73},\n",
       " {'name': 'Zoroaster', 'birth': -500, 'age': nan}]"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "great = [{'name':'Buddha', 'birth':-480, 'age':80}, \n",
    "         {'name':'Confucius', 'birth':-551, 'age':73}, \n",
    "         {'name':'Plato', 'birth':-428, 'age':80}, \n",
    "         {'name':'Zoroaster', 'birth':-500, 'age':float('nan')}]\n",
    "great.sort(key=lambda person: person['age'], reverse=True) # key 参数要求一个函数类型，lambda在这里非常方便\n",
    "great"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'name': 'Confucius', 'birth': -551, 'age': 73},\n",
       " {'name': 'Zoroaster', 'birth': -500, 'age': nan},\n",
       " {'name': 'Buddha', 'birth': -480, 'age': 80},\n",
       " {'name': 'Plato', 'birth': -428, 'age': 80}]"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "great = [{'name':'Buddha', 'birth':-480, 'age':80}, \n",
    "         {'name':'Confucius', 'birth':-551, 'age':73}, \n",
    "         {'name':'Plato', 'birth':-428, 'age':80}, \n",
    "         {'name':'Zoroaster', 'birth':-500, 'age':float('nan')}]\n",
    "great.sort(key=lambda o: o['birth'])\n",
    "great"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 库的安装和引用"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```sh\n",
    "pip3 install algorithms\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```sh\n",
    "python3 -c 'from algorithms.sort import merge_sort'\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "from algorithms.sort import merge_sort\n",
    "test_list = [1, 8, 3, 5, 6]\n",
    "result_list = merge_sort(test_list)\n",
    "result_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "##### 在哪里找到这些库？\n",
    "[pypi](https://pypi.org/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Numpy\n",
    "\n",
    "[numpy的功能](https://www.numpy.org/devdocs/user/quickstart.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 引入Numpy的目的\n",
    "\n",
    "- 为何不直接用list？\n",
    "    - 慢\n",
    "    - 缺少数学操作"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for ** or pow(): 'list' and 'int'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-139-287881938841>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mheights\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m1.73\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1.68\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1.71\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1.89\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1.79\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;31m# 5人的身高\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mweights\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m65.4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m59.2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m63.6\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m88.4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m68.7\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;31m# 5人的体重\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mbmis\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mweights\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0mheights\u001b[0m \u001b[0;34m**\u001b[0m \u001b[0;36m2\u001b[0m            \u001b[0;31m# 却不能直接计算5人的BMI\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for ** or pow(): 'list' and 'int'"
     ]
    }
   ],
   "source": [
    "heights = [1.73, 1.68, 1.71, 1.89, 1.79] # 5人的身高\n",
    "weights = [65.4, 59.2, 63.6, 88.4, 68.7] # 5人的体重\n",
    "bmis = weights / heights ** 2            # 却不能直接计算5人的BMI"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([21.85171573, 20.97505669, 21.75028214, 24.7473475 , 21.44127836])"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np \n",
    "np_heights = np.array(heights)        # array，向量，通常只包含数值\n",
    "np_weights = np.array(weights)\n",
    "bmis = np_weights / np_heights ** 2   # 这里计算的单元是一个向量\n",
    "bmis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "##### 更新BMI公式，现在是对向量做计算\n",
    "\\begin{equation}\\vec{BMIS} = \\frac{\\vec{weights}}{\\vec{heights}^{2}}\\end{equation}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True, False,  True,  True,  True])"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bmis > 21  # 符合直觉的结果，"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "type numpy.ndarray doesn't define __round__ method",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-142-2607667d896a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mround\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbmis\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# 只有numpy.ndarray支持的方法\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: type numpy.ndarray doesn't define __round__ method"
     ]
    }
   ],
   "source": [
    "round(bmis) # 只有numpy.ndarray支持的方法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([22., 21., 22., 25., 21.])"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.round(bmis) # 需要使用np重载的方法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.max(bmis) == max(bmis) # 大胆地猜想这两种方法应该都可以"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class ndarray in module numpy:\n",
      "\n",
      "class ndarray(builtins.object)\n",
      " |  ndarray(shape, dtype=float, buffer=None, offset=0,\n",
      " |          strides=None, order=None)\n",
      " |  \n",
      " |  An array object represents a multidimensional, homogeneous array\n",
      " |  of fixed-size items.  An associated data-type object describes the\n",
      " |  format of each element in the array (its byte-order, how many bytes it\n",
      " |  occupies in memory, whether it is an integer, a floating point number,\n",
      " |  or something else, etc.)\n",
      " |  \n",
      " |  Arrays should be constructed using `array`, `zeros` or `empty` (refer\n",
      " |  to the See Also section below).  The parameters given here refer to\n",
      " |  a low-level method (`ndarray(...)`) for instantiating an array.\n",
      " |  \n",
      " |  For more information, refer to the `numpy` module and examine the\n",
      " |  methods and attributes of an array.\n",
      " |  \n",
      " |  Parameters\n",
      " |  ----------\n",
      " |  (for the __new__ method; see Notes below)\n",
      " |  \n",
      " |  shape : tuple of ints\n",
      " |      Shape of created array.\n",
      " |  dtype : data-type, optional\n",
      " |      Any object that can be interpreted as a numpy data type.\n",
      " |  buffer : object exposing buffer interface, optional\n",
      " |      Used to fill the array with data.\n",
      " |  offset : int, optional\n",
      " |      Offset of array data in buffer.\n",
      " |  strides : tuple of ints, optional\n",
      " |      Strides of data in memory.\n",
      " |  order : {'C', 'F'}, optional\n",
      " |      Row-major (C-style) or column-major (Fortran-style) order.\n",
      " |  \n",
      " |  Attributes\n",
      " |  ----------\n",
      " |  T : ndarray\n",
      " |      Transpose of the array.\n",
      " |  data : buffer\n",
      " |      The array's elements, in memory.\n",
      " |  dtype : dtype object\n",
      " |      Describes the format of the elements in the array.\n",
      " |  flags : dict\n",
      " |      Dictionary containing information related to memory use, e.g.,\n",
      " |      'C_CONTIGUOUS', 'OWNDATA', 'WRITEABLE', etc.\n",
      " |  flat : numpy.flatiter object\n",
      " |      Flattened version of the array as an iterator.  The iterator\n",
      " |      allows assignments, e.g., ``x.flat = 3`` (See `ndarray.flat` for\n",
      " |      assignment examples; TODO).\n",
      " |  imag : ndarray\n",
      " |      Imaginary part of the array.\n",
      " |  real : ndarray\n",
      " |      Real part of the array.\n",
      " |  size : int\n",
      " |      Number of elements in the array.\n",
      " |  itemsize : int\n",
      " |      The memory use of each array element in bytes.\n",
      " |  nbytes : int\n",
      " |      The total number of bytes required to store the array data,\n",
      " |      i.e., ``itemsize * size``.\n",
      " |  ndim : int\n",
      " |      The array's number of dimensions.\n",
      " |  shape : tuple of ints\n",
      " |      Shape of the array.\n",
      " |  strides : tuple of ints\n",
      " |      The step-size required to move from one element to the next in\n",
      " |      memory. For example, a contiguous ``(3, 4)`` array of type\n",
      " |      ``int16`` in C-order has strides ``(8, 2)``.  This implies that\n",
      " |      to move from element to element in memory requires jumps of 2 bytes.\n",
      " |      To move from row-to-row, one needs to jump 8 bytes at a time\n",
      " |      (``2 * 4``).\n",
      " |  ctypes : ctypes object\n",
      " |      Class containing properties of the array needed for interaction\n",
      " |      with ctypes.\n",
      " |  base : ndarray\n",
      " |      If the array is a view into another array, that array is its `base`\n",
      " |      (unless that array is also a view).  The `base` array is where the\n",
      " |      array data is actually stored.\n",
      " |  \n",
      " |  See Also\n",
      " |  --------\n",
      " |  array : Construct an array.\n",
      " |  zeros : Create an array, each element of which is zero.\n",
      " |  empty : Create an array, but leave its allocated memory unchanged (i.e.,\n",
      " |          it contains \"garbage\").\n",
      " |  dtype : Create a data-type.\n",
      " |  \n",
      " |  Notes\n",
      " |  -----\n",
      " |  There are two modes of creating an array using ``__new__``:\n",
      " |  \n",
      " |  1. If `buffer` is None, then only `shape`, `dtype`, and `order`\n",
      " |     are used.\n",
      " |  2. If `buffer` is an object exposing the buffer interface, then\n",
      " |     all keywords are interpreted.\n",
      " |  \n",
      " |  No ``__init__`` method is needed because the array is fully initialized\n",
      " |  after the ``__new__`` method.\n",
      " |  \n",
      " |  Examples\n",
      " |  --------\n",
      " |  These examples illustrate the low-level `ndarray` constructor.  Refer\n",
      " |  to the `See Also` section above for easier ways of constructing an\n",
      " |  ndarray.\n",
      " |  \n",
      " |  First mode, `buffer` is None:\n",
      " |  \n",
      " |  >>> np.ndarray(shape=(2,2), dtype=float, order='F')\n",
      " |  array([[ -1.13698227e+002,   4.25087011e-303],\n",
      " |         [  2.88528414e-306,   3.27025015e-309]])         #random\n",
      " |  \n",
      " |  Second mode:\n",
      " |  \n",
      " |  >>> np.ndarray((2,), buffer=np.array([1,2,3]),\n",
      " |  ...            offset=np.int_().itemsize,\n",
      " |  ...            dtype=int) # offset = 1*itemsize, i.e. skip first element\n",
      " |  array([2, 3])\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __abs__(self, /)\n",
      " |      abs(self)\n",
      " |  \n",
      " |  __add__(self, value, /)\n",
      " |      Return self+value.\n",
      " |  \n",
      " |  __and__(self, value, /)\n",
      " |      Return self&value.\n",
      " |  \n",
      " |  __array__(...)\n",
      " |      a.__array__(|dtype) -> reference if type unchanged, copy otherwise.\n",
      " |      \n",
      " |      Returns either a new reference to self if dtype is not given or a new array\n",
      " |      of provided data type if dtype is different from the current dtype of the\n",
      " |      array.\n",
      " |  \n",
      " |  __array_function__(...)\n",
      " |  \n",
      " |  __array_prepare__(...)\n",
      " |      a.__array_prepare__(obj) -> Object of same type as ndarray object obj.\n",
      " |  \n",
      " |  __array_ufunc__(...)\n",
      " |  \n",
      " |  __array_wrap__(...)\n",
      " |      a.__array_wrap__(obj) -> Object of same type as ndarray object a.\n",
      " |  \n",
      " |  __bool__(self, /)\n",
      " |      self != 0\n",
      " |  \n",
      " |  __complex__(...)\n",
      " |  \n",
      " |  __contains__(self, key, /)\n",
      " |      Return key in self.\n",
      " |  \n",
      " |  __copy__(...)\n",
      " |      a.__copy__()\n",
      " |      \n",
      " |      Used if :func:`copy.copy` is called on an array. Returns a copy of the array.\n",
      " |      \n",
      " |      Equivalent to ``a.copy(order='K')``.\n",
      " |  \n",
      " |  __deepcopy__(...)\n",
      " |      a.__deepcopy__(memo, /) -> Deep copy of array.\n",
      " |      \n",
      " |      Used if :func:`copy.deepcopy` is called on an array.\n",
      " |  \n",
      " |  __delitem__(self, key, /)\n",
      " |      Delete self[key].\n",
      " |  \n",
      " |  __divmod__(self, value, /)\n",
      " |      Return divmod(self, value).\n",
      " |  \n",
      " |  __eq__(self, value, /)\n",
      " |      Return self==value.\n",
      " |  \n",
      " |  __float__(self, /)\n",
      " |      float(self)\n",
      " |  \n",
      " |  __floordiv__(self, value, /)\n",
      " |      Return self//value.\n",
      " |  \n",
      " |  __format__(...)\n",
      " |      default object formatter\n",
      " |  \n",
      " |  __ge__(self, value, /)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __getitem__(self, key, /)\n",
      " |      Return self[key].\n",
      " |  \n",
      " |  __gt__(self, value, /)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __iadd__(self, value, /)\n",
      " |      Return self+=value.\n",
      " |  \n",
      " |  __iand__(self, value, /)\n",
      " |      Return self&=value.\n",
      " |  \n",
      " |  __ifloordiv__(self, value, /)\n",
      " |      Return self//=value.\n",
      " |  \n",
      " |  __ilshift__(self, value, /)\n",
      " |      Return self<<=value.\n",
      " |  \n",
      " |  __imatmul__(self, value, /)\n",
      " |      Return self@=value.\n",
      " |  \n",
      " |  __imod__(self, value, /)\n",
      " |      Return self%=value.\n",
      " |  \n",
      " |  __imul__(self, value, /)\n",
      " |      Return self*=value.\n",
      " |  \n",
      " |  __index__(self, /)\n",
      " |      Return self converted to an integer, if self is suitable for use as an index into a list.\n",
      " |  \n",
      " |  __int__(self, /)\n",
      " |      int(self)\n",
      " |  \n",
      " |  __invert__(self, /)\n",
      " |      ~self\n",
      " |  \n",
      " |  __ior__(self, value, /)\n",
      " |      Return self|=value.\n",
      " |  \n",
      " |  __ipow__(self, value, /)\n",
      " |      Return self**=value.\n",
      " |  \n",
      " |  __irshift__(self, value, /)\n",
      " |      Return self>>=value.\n",
      " |  \n",
      " |  __isub__(self, value, /)\n",
      " |      Return self-=value.\n",
      " |  \n",
      " |  __iter__(self, /)\n",
      " |      Implement iter(self).\n",
      " |  \n",
      " |  __itruediv__(self, value, /)\n",
      " |      Return self/=value.\n",
      " |  \n",
      " |  __ixor__(self, value, /)\n",
      " |      Return self^=value.\n",
      " |  \n",
      " |  __le__(self, value, /)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __len__(self, /)\n",
      " |      Return len(self).\n",
      " |  \n",
      " |  __lshift__(self, value, /)\n",
      " |      Return self<<value.\n",
      " |  \n",
      " |  __lt__(self, value, /)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __matmul__(self, value, /)\n",
      " |      Return self@value.\n",
      " |  \n",
      " |  __mod__(self, value, /)\n",
      " |      Return self%value.\n",
      " |  \n",
      " |  __mul__(self, value, /)\n",
      " |      Return self*value.\n",
      " |  \n",
      " |  __ne__(self, value, /)\n",
      " |      Return self!=value.\n",
      " |  \n",
      " |  __neg__(self, /)\n",
      " |      -self\n",
      " |  \n",
      " |  __new__(*args, **kwargs) from builtins.type\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  __or__(self, value, /)\n",
      " |      Return self|value.\n",
      " |  \n",
      " |  __pos__(self, /)\n",
      " |      +self\n",
      " |  \n",
      " |  __pow__(self, value, mod=None, /)\n",
      " |      Return pow(self, value, mod).\n",
      " |  \n",
      " |  __radd__(self, value, /)\n",
      " |      Return value+self.\n",
      " |  \n",
      " |  __rand__(self, value, /)\n",
      " |      Return value&self.\n",
      " |  \n",
      " |  __rdivmod__(self, value, /)\n",
      " |      Return divmod(value, self).\n",
      " |  \n",
      " |  __reduce__(...)\n",
      " |      a.__reduce__()\n",
      " |      \n",
      " |      For pickling.\n",
      " |  \n",
      " |  __reduce_ex__(...)\n",
      " |      helper for pickle\n",
      " |  \n",
      " |  __repr__(self, /)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __rfloordiv__(self, value, /)\n",
      " |      Return value//self.\n",
      " |  \n",
      " |  __rlshift__(self, value, /)\n",
      " |      Return value<<self.\n",
      " |  \n",
      " |  __rmatmul__(self, value, /)\n",
      " |      Return value@self.\n",
      " |  \n",
      " |  __rmod__(self, value, /)\n",
      " |      Return value%self.\n",
      " |  \n",
      " |  __rmul__(self, value, /)\n",
      " |      Return value*self.\n",
      " |  \n",
      " |  __ror__(self, value, /)\n",
      " |      Return value|self.\n",
      " |  \n",
      " |  __rpow__(self, value, mod=None, /)\n",
      " |      Return pow(value, self, mod).\n",
      " |  \n",
      " |  __rrshift__(self, value, /)\n",
      " |      Return value>>self.\n",
      " |  \n",
      " |  __rshift__(self, value, /)\n",
      " |      Return self>>value.\n",
      " |  \n",
      " |  __rsub__(self, value, /)\n",
      " |      Return value-self.\n",
      " |  \n",
      " |  __rtruediv__(self, value, /)\n",
      " |      Return value/self.\n",
      " |  \n",
      " |  __rxor__(self, value, /)\n",
      " |      Return value^self.\n",
      " |  \n",
      " |  __setitem__(self, key, value, /)\n",
      " |      Set self[key] to value.\n",
      " |  \n",
      " |  __setstate__(...)\n",
      " |      a.__setstate__(state, /)\n",
      " |      \n",
      " |      For unpickling.\n",
      " |      \n",
      " |      The `state` argument must be a sequence that contains the following\n",
      " |      elements:\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      version : int\n",
      " |          optional pickle version. If omitted defaults to 0.\n",
      " |      shape : tuple\n",
      " |      dtype : data-type\n",
      " |      isFortran : bool\n",
      " |      rawdata : string or list\n",
      " |          a binary string with the data (or a list if 'a' is an object array)\n",
      " |  \n",
      " |  __sizeof__(...)\n",
      " |      __sizeof__() -> int\n",
      " |      size of object in memory, in bytes\n",
      " |  \n",
      " |  __str__(self, /)\n",
      " |      Return str(self).\n",
      " |  \n",
      " |  __sub__(self, value, /)\n",
      " |      Return self-value.\n",
      " |  \n",
      " |  __truediv__(self, value, /)\n",
      " |      Return self/value.\n",
      " |  \n",
      " |  __xor__(self, value, /)\n",
      " |      Return self^value.\n",
      " |  \n",
      " |  all(...)\n",
      " |      a.all(axis=None, out=None, keepdims=False)\n",
      " |      \n",
      " |      Returns True if all elements evaluate to True.\n",
      " |      \n",
      " |      Refer to `numpy.all` for full documentation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.all : equivalent function\n",
      " |  \n",
      " |  any(...)\n",
      " |      a.any(axis=None, out=None, keepdims=False)\n",
      " |      \n",
      " |      Returns True if any of the elements of `a` evaluate to True.\n",
      " |      \n",
      " |      Refer to `numpy.any` for full documentation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.any : equivalent function\n",
      " |  \n",
      " |  argmax(...)\n",
      " |      a.argmax(axis=None, out=None)\n",
      " |      \n",
      " |      Return indices of the maximum values along the given axis.\n",
      " |      \n",
      " |      Refer to `numpy.argmax` for full documentation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.argmax : equivalent function\n",
      " |  \n",
      " |  argmin(...)\n",
      " |      a.argmin(axis=None, out=None)\n",
      " |      \n",
      " |      Return indices of the minimum values along the given axis of `a`.\n",
      " |      \n",
      " |      Refer to `numpy.argmin` for detailed documentation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.argmin : equivalent function\n",
      " |  \n",
      " |  argpartition(...)\n",
      " |      a.argpartition(kth, axis=-1, kind='introselect', order=None)\n",
      " |      \n",
      " |      Returns the indices that would partition this array.\n",
      " |      \n",
      " |      Refer to `numpy.argpartition` for full documentation.\n",
      " |      \n",
      " |      .. versionadded:: 1.8.0\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.argpartition : equivalent function\n",
      " |  \n",
      " |  argsort(...)\n",
      " |      a.argsort(axis=-1, kind='quicksort', order=None)\n",
      " |      \n",
      " |      Returns the indices that would sort this array.\n",
      " |      \n",
      " |      Refer to `numpy.argsort` for full documentation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.argsort : equivalent function\n",
      " |  \n",
      " |  astype(...)\n",
      " |      a.astype(dtype, order='K', casting='unsafe', subok=True, copy=True)\n",
      " |      \n",
      " |      Copy of the array, cast to a specified type.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      dtype : str or dtype\n",
      " |          Typecode or data-type to which the array is cast.\n",
      " |      order : {'C', 'F', 'A', 'K'}, optional\n",
      " |          Controls the memory layout order of the result.\n",
      " |          'C' means C order, 'F' means Fortran order, 'A'\n",
      " |          means 'F' order if all the arrays are Fortran contiguous,\n",
      " |          'C' order otherwise, and 'K' means as close to the\n",
      " |          order the array elements appear in memory as possible.\n",
      " |          Default is 'K'.\n",
      " |      casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional\n",
      " |          Controls what kind of data casting may occur. Defaults to 'unsafe'\n",
      " |          for backwards compatibility.\n",
      " |      \n",
      " |            * 'no' means the data types should not be cast at all.\n",
      " |            * 'equiv' means only byte-order changes are allowed.\n",
      " |            * 'safe' means only casts which can preserve values are allowed.\n",
      " |            * 'same_kind' means only safe casts or casts within a kind,\n",
      " |              like float64 to float32, are allowed.\n",
      " |            * 'unsafe' means any data conversions may be done.\n",
      " |      subok : bool, optional\n",
      " |          If True, then sub-classes will be passed-through (default), otherwise\n",
      " |          the returned array will be forced to be a base-class array.\n",
      " |      copy : bool, optional\n",
      " |          By default, astype always returns a newly allocated array. If this\n",
      " |          is set to false, and the `dtype`, `order`, and `subok`\n",
      " |          requirements are satisfied, the input array is returned instead\n",
      " |          of a copy.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      arr_t : ndarray\n",
      " |          Unless `copy` is False and the other conditions for returning the input\n",
      " |          array are satisfied (see description for `copy` input parameter), `arr_t`\n",
      " |          is a new array of the same shape as the input array, with dtype, order\n",
      " |          given by `dtype`, `order`.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      Starting in NumPy 1.9, astype method now returns an error if the string\n",
      " |      dtype to cast to is not long enough in 'safe' casting mode to hold the max\n",
      " |      value of integer/float array that is being casted. Previously the casting\n",
      " |      was allowed even if the result was truncated.\n",
      " |      \n",
      " |      Raises\n",
      " |      ------\n",
      " |      ComplexWarning\n",
      " |          When casting from complex to float or int. To avoid this,\n",
      " |          one should use ``a.real.astype(t)``.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> x = np.array([1, 2, 2.5])\n",
      " |      >>> x\n",
      " |      array([ 1. ,  2. ,  2.5])\n",
      " |      \n",
      " |      >>> x.astype(int)\n",
      " |      array([1, 2, 2])\n",
      " |  \n",
      " |  byteswap(...)\n",
      " |      a.byteswap(inplace=False)\n",
      " |      \n",
      " |      Swap the bytes of the array elements\n",
      " |      \n",
      " |      Toggle between low-endian and big-endian data representation by\n",
      " |      returning a byteswapped array, optionally swapped in-place.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      inplace : bool, optional\n",
      " |          If ``True``, swap bytes in-place, default is ``False``.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      out : ndarray\n",
      " |          The byteswapped array. If `inplace` is ``True``, this is\n",
      " |          a view to self.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> A = np.array([1, 256, 8755], dtype=np.int16)\n",
      " |      >>> map(hex, A)\n",
      " |      ['0x1', '0x100', '0x2233']\n",
      " |      >>> A.byteswap(inplace=True)\n",
      " |      array([  256,     1, 13090], dtype=int16)\n",
      " |      >>> map(hex, A)\n",
      " |      ['0x100', '0x1', '0x3322']\n",
      " |      \n",
      " |      Arrays of strings are not swapped\n",
      " |      \n",
      " |      >>> A = np.array(['ceg', 'fac'])\n",
      " |      >>> A.byteswap()\n",
      " |      array(['ceg', 'fac'],\n",
      " |            dtype='|S3')\n",
      " |  \n",
      " |  choose(...)\n",
      " |      a.choose(choices, out=None, mode='raise')\n",
      " |      \n",
      " |      Use an index array to construct a new array from a set of choices.\n",
      " |      \n",
      " |      Refer to `numpy.choose` for full documentation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.choose : equivalent function\n",
      " |  \n",
      " |  clip(...)\n",
      " |      a.clip(min=None, max=None, out=None)\n",
      " |      \n",
      " |      Return an array whose values are limited to ``[min, max]``.\n",
      " |      One of max or min must be given.\n",
      " |      \n",
      " |      Refer to `numpy.clip` for full documentation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.clip : equivalent function\n",
      " |  \n",
      " |  compress(...)\n",
      " |      a.compress(condition, axis=None, out=None)\n",
      " |      \n",
      " |      Return selected slices of this array along given axis.\n",
      " |      \n",
      " |      Refer to `numpy.compress` for full documentation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.compress : equivalent function\n",
      " |  \n",
      " |  conj(...)\n",
      " |      a.conj()\n",
      " |      \n",
      " |      Complex-conjugate all elements.\n",
      " |      \n",
      " |      Refer to `numpy.conjugate` for full documentation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.conjugate : equivalent function\n",
      " |  \n",
      " |  conjugate(...)\n",
      " |      a.conjugate()\n",
      " |      \n",
      " |      Return the complex conjugate, element-wise.\n",
      " |      \n",
      " |      Refer to `numpy.conjugate` for full documentation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.conjugate : equivalent function\n",
      " |  \n",
      " |  copy(...)\n",
      " |      a.copy(order='C')\n",
      " |      \n",
      " |      Return a copy of the array.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      order : {'C', 'F', 'A', 'K'}, optional\n",
      " |          Controls the memory layout of the copy. 'C' means C-order,\n",
      " |          'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,\n",
      " |          'C' otherwise. 'K' means match the layout of `a` as closely\n",
      " |          as possible. (Note that this function and :func:`numpy.copy` are very\n",
      " |          similar, but have different default values for their order=\n",
      " |          arguments.)\n",
      " |      \n",
      " |      See also\n",
      " |      --------\n",
      " |      numpy.copy\n",
      " |      numpy.copyto\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> x = np.array([[1,2,3],[4,5,6]], order='F')\n",
      " |      \n",
      " |      >>> y = x.copy()\n",
      " |      \n",
      " |      >>> x.fill(0)\n",
      " |      \n",
      " |      >>> x\n",
      " |      array([[0, 0, 0],\n",
      " |             [0, 0, 0]])\n",
      " |      \n",
      " |      >>> y\n",
      " |      array([[1, 2, 3],\n",
      " |             [4, 5, 6]])\n",
      " |      \n",
      " |      >>> y.flags['C_CONTIGUOUS']\n",
      " |      True\n",
      " |  \n",
      " |  cumprod(...)\n",
      " |      a.cumprod(axis=None, dtype=None, out=None)\n",
      " |      \n",
      " |      Return the cumulative product of the elements along the given axis.\n",
      " |      \n",
      " |      Refer to `numpy.cumprod` for full documentation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.cumprod : equivalent function\n",
      " |  \n",
      " |  cumsum(...)\n",
      " |      a.cumsum(axis=None, dtype=None, out=None)\n",
      " |      \n",
      " |      Return the cumulative sum of the elements along the given axis.\n",
      " |      \n",
      " |      Refer to `numpy.cumsum` for full documentation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.cumsum : equivalent function\n",
      " |  \n",
      " |  diagonal(...)\n",
      " |      a.diagonal(offset=0, axis1=0, axis2=1)\n",
      " |      \n",
      " |      Return specified diagonals. In NumPy 1.9 the returned array is a\n",
      " |      read-only view instead of a copy as in previous NumPy versions.  In\n",
      " |      a future version the read-only restriction will be removed.\n",
      " |      \n",
      " |      Refer to :func:`numpy.diagonal` for full documentation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.diagonal : equivalent function\n",
      " |  \n",
      " |  dot(...)\n",
      " |      a.dot(b, out=None)\n",
      " |      \n",
      " |      Dot product of two arrays.\n",
      " |      \n",
      " |      Refer to `numpy.dot` for full documentation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.dot : equivalent function\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> a = np.eye(2)\n",
      " |      >>> b = np.ones((2, 2)) * 2\n",
      " |      >>> a.dot(b)\n",
      " |      array([[ 2.,  2.],\n",
      " |             [ 2.,  2.]])\n",
      " |      \n",
      " |      This array method can be conveniently chained:\n",
      " |      \n",
      " |      >>> a.dot(b).dot(b)\n",
      " |      array([[ 8.,  8.],\n",
      " |             [ 8.,  8.]])\n",
      " |  \n",
      " |  dump(...)\n",
      " |      a.dump(file)\n",
      " |      \n",
      " |      Dump a pickle of the array to the specified file.\n",
      " |      The array can be read back with pickle.load or numpy.load.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      file : str\n",
      " |          A string naming the dump file.\n",
      " |  \n",
      " |  dumps(...)\n",
      " |      a.dumps()\n",
      " |      \n",
      " |      Returns the pickle of the array as a string.\n",
      " |      pickle.loads or numpy.loads will convert the string back to an array.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      None\n",
      " |  \n",
      " |  fill(...)\n",
      " |      a.fill(value)\n",
      " |      \n",
      " |      Fill the array with a scalar value.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      value : scalar\n",
      " |          All elements of `a` will be assigned this value.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> a = np.array([1, 2])\n",
      " |      >>> a.fill(0)\n",
      " |      >>> a\n",
      " |      array([0, 0])\n",
      " |      >>> a = np.empty(2)\n",
      " |      >>> a.fill(1)\n",
      " |      >>> a\n",
      " |      array([ 1.,  1.])\n",
      " |  \n",
      " |  flatten(...)\n",
      " |      a.flatten(order='C')\n",
      " |      \n",
      " |      Return a copy of the array collapsed into one dimension.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      order : {'C', 'F', 'A', 'K'}, optional\n",
      " |          'C' means to flatten in row-major (C-style) order.\n",
      " |          'F' means to flatten in column-major (Fortran-\n",
      " |          style) order. 'A' means to flatten in column-major\n",
      " |          order if `a` is Fortran *contiguous* in memory,\n",
      " |          row-major order otherwise. 'K' means to flatten\n",
      " |          `a` in the order the elements occur in memory.\n",
      " |          The default is 'C'.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      y : ndarray\n",
      " |          A copy of the input array, flattened to one dimension.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      ravel : Return a flattened array.\n",
      " |      flat : A 1-D flat iterator over the array.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> a = np.array([[1,2], [3,4]])\n",
      " |      >>> a.flatten()\n",
      " |      array([1, 2, 3, 4])\n",
      " |      >>> a.flatten('F')\n",
      " |      array([1, 3, 2, 4])\n",
      " |  \n",
      " |  getfield(...)\n",
      " |      a.getfield(dtype, offset=0)\n",
      " |      \n",
      " |      Returns a field of the given array as a certain type.\n",
      " |      \n",
      " |      A field is a view of the array data with a given data-type. The values in\n",
      " |      the view are determined by the given type and the offset into the current\n",
      " |      array in bytes. The offset needs to be such that the view dtype fits in the\n",
      " |      array dtype; for example an array of dtype complex128 has 16-byte elements.\n",
      " |      If taking a view with a 32-bit integer (4 bytes), the offset needs to be\n",
      " |      between 0 and 12 bytes.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      dtype : str or dtype\n",
      " |          The data type of the view. The dtype size of the view can not be larger\n",
      " |          than that of the array itself.\n",
      " |      offset : int\n",
      " |          Number of bytes to skip before beginning the element view.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> x = np.diag([1.+1.j]*2)\n",
      " |      >>> x[1, 1] = 2 + 4.j\n",
      " |      >>> x\n",
      " |      array([[ 1.+1.j,  0.+0.j],\n",
      " |             [ 0.+0.j,  2.+4.j]])\n",
      " |      >>> x.getfield(np.float64)\n",
      " |      array([[ 1.,  0.],\n",
      " |             [ 0.,  2.]])\n",
      " |      \n",
      " |      By choosing an offset of 8 bytes we can select the complex part of the\n",
      " |      array for our view:\n",
      " |      \n",
      " |      >>> x.getfield(np.float64, offset=8)\n",
      " |      array([[ 1.,  0.],\n",
      " |         [ 0.,  4.]])\n",
      " |  \n",
      " |  item(...)\n",
      " |      a.item(*args)\n",
      " |      \n",
      " |      Copy an element of an array to a standard Python scalar and return it.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      \\*args : Arguments (variable number and type)\n",
      " |      \n",
      " |          * none: in this case, the method only works for arrays\n",
      " |            with one element (`a.size == 1`), which element is\n",
      " |            copied into a standard Python scalar object and returned.\n",
      " |      \n",
      " |          * int_type: this argument is interpreted as a flat index into\n",
      " |            the array, specifying which element to copy and return.\n",
      " |      \n",
      " |          * tuple of int_types: functions as does a single int_type argument,\n",
      " |            except that the argument is interpreted as an nd-index into the\n",
      " |            array.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      z : Standard Python scalar object\n",
      " |          A copy of the specified element of the array as a suitable\n",
      " |          Python scalar\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      When the data type of `a` is longdouble or clongdouble, item() returns\n",
      " |      a scalar array object because there is no available Python scalar that\n",
      " |      would not lose information. Void arrays return a buffer object for item(),\n",
      " |      unless fields are defined, in which case a tuple is returned.\n",
      " |      \n",
      " |      `item` is very similar to a[args], except, instead of an array scalar,\n",
      " |      a standard Python scalar is returned. This can be useful for speeding up\n",
      " |      access to elements of the array and doing arithmetic on elements of the\n",
      " |      array using Python's optimized math.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> x = np.random.randint(9, size=(3, 3))\n",
      " |      >>> x\n",
      " |      array([[3, 1, 7],\n",
      " |             [2, 8, 3],\n",
      " |             [8, 5, 3]])\n",
      " |      >>> x.item(3)\n",
      " |      2\n",
      " |      >>> x.item(7)\n",
      " |      5\n",
      " |      >>> x.item((0, 1))\n",
      " |      1\n",
      " |      >>> x.item((2, 2))\n",
      " |      3\n",
      " |  \n",
      " |  itemset(...)\n",
      " |      a.itemset(*args)\n",
      " |      \n",
      " |      Insert scalar into an array (scalar is cast to array's dtype, if possible)\n",
      " |      \n",
      " |      There must be at least 1 argument, and define the last argument\n",
      " |      as *item*.  Then, ``a.itemset(*args)`` is equivalent to but faster\n",
      " |      than ``a[args] = item``.  The item should be a scalar value and `args`\n",
      " |      must select a single item in the array `a`.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      \\*args : Arguments\n",
      " |          If one argument: a scalar, only used in case `a` is of size 1.\n",
      " |          If two arguments: the last argument is the value to be set\n",
      " |          and must be a scalar, the first argument specifies a single array\n",
      " |          element location. It is either an int or a tuple.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      Compared to indexing syntax, `itemset` provides some speed increase\n",
      " |      for placing a scalar into a particular location in an `ndarray`,\n",
      " |      if you must do this.  However, generally this is discouraged:\n",
      " |      among other problems, it complicates the appearance of the code.\n",
      " |      Also, when using `itemset` (and `item`) inside a loop, be sure\n",
      " |      to assign the methods to a local variable to avoid the attribute\n",
      " |      look-up at each loop iteration.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> x = np.random.randint(9, size=(3, 3))\n",
      " |      >>> x\n",
      " |      array([[3, 1, 7],\n",
      " |             [2, 8, 3],\n",
      " |             [8, 5, 3]])\n",
      " |      >>> x.itemset(4, 0)\n",
      " |      >>> x.itemset((2, 2), 9)\n",
      " |      >>> x\n",
      " |      array([[3, 1, 7],\n",
      " |             [2, 0, 3],\n",
      " |             [8, 5, 9]])\n",
      " |  \n",
      " |  max(...)\n",
      " |      a.max(axis=None, out=None, keepdims=False)\n",
      " |      \n",
      " |      Return the maximum along a given axis.\n",
      " |      \n",
      " |      Refer to `numpy.amax` for full documentation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.amax : equivalent function\n",
      " |  \n",
      " |  mean(...)\n",
      " |      a.mean(axis=None, dtype=None, out=None, keepdims=False)\n",
      " |      \n",
      " |      Returns the average of the array elements along given axis.\n",
      " |      \n",
      " |      Refer to `numpy.mean` for full documentation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.mean : equivalent function\n",
      " |  \n",
      " |  min(...)\n",
      " |      a.min(axis=None, out=None, keepdims=False)\n",
      " |      \n",
      " |      Return the minimum along a given axis.\n",
      " |      \n",
      " |      Refer to `numpy.amin` for full documentation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.amin : equivalent function\n",
      " |  \n",
      " |  newbyteorder(...)\n",
      " |      arr.newbyteorder(new_order='S')\n",
      " |      \n",
      " |      Return the array with the same data viewed with a different byte order.\n",
      " |      \n",
      " |      Equivalent to::\n",
      " |      \n",
      " |          arr.view(arr.dtype.newbytorder(new_order))\n",
      " |      \n",
      " |      Changes are also made in all fields and sub-arrays of the array data\n",
      " |      type.\n",
      " |      \n",
      " |      \n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      new_order : string, optional\n",
      " |          Byte order to force; a value from the byte order specifications\n",
      " |          below. `new_order` codes can be any of:\n",
      " |      \n",
      " |          * 'S' - swap dtype from current to opposite endian\n",
      " |          * {'<', 'L'} - little endian\n",
      " |          * {'>', 'B'} - big endian\n",
      " |          * {'=', 'N'} - native order\n",
      " |          * {'|', 'I'} - ignore (no change to byte order)\n",
      " |      \n",
      " |          The default value ('S') results in swapping the current\n",
      " |          byte order. The code does a case-insensitive check on the first\n",
      " |          letter of `new_order` for the alternatives above.  For example,\n",
      " |          any of 'B' or 'b' or 'biggish' are valid to specify big-endian.\n",
      " |      \n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      new_arr : array\n",
      " |          New array object with the dtype reflecting given change to the\n",
      " |          byte order.\n",
      " |  \n",
      " |  nonzero(...)\n",
      " |      a.nonzero()\n",
      " |      \n",
      " |      Return the indices of the elements that are non-zero.\n",
      " |      \n",
      " |      Refer to `numpy.nonzero` for full documentation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.nonzero : equivalent function\n",
      " |  \n",
      " |  partition(...)\n",
      " |      a.partition(kth, axis=-1, kind='introselect', order=None)\n",
      " |      \n",
      " |      Rearranges the elements in the array in such a way that the value of the\n",
      " |      element in kth position is in the position it would be in a sorted array.\n",
      " |      All elements smaller than the kth element are moved before this element and\n",
      " |      all equal or greater are moved behind it. The ordering of the elements in\n",
      " |      the two partitions is undefined.\n",
      " |      \n",
      " |      .. versionadded:: 1.8.0\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      kth : int or sequence of ints\n",
      " |          Element index to partition by. The kth element value will be in its\n",
      " |          final sorted position and all smaller elements will be moved before it\n",
      " |          and all equal or greater elements behind it.\n",
      " |          The order of all elements in the partitions is undefined.\n",
      " |          If provided with a sequence of kth it will partition all elements\n",
      " |          indexed by kth of them into their sorted position at once.\n",
      " |      axis : int, optional\n",
      " |          Axis along which to sort. Default is -1, which means sort along the\n",
      " |          last axis.\n",
      " |      kind : {'introselect'}, optional\n",
      " |          Selection algorithm. Default is 'introselect'.\n",
      " |      order : str or list of str, optional\n",
      " |          When `a` is an array with fields defined, this argument specifies\n",
      " |          which fields to compare first, second, etc. A single field can\n",
      " |          be specified as a string, and not all fields need to be specified,\n",
      " |          but unspecified fields will still be used, in the order in which\n",
      " |          they come up in the dtype, to break ties.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.partition : Return a parititioned copy of an array.\n",
      " |      argpartition : Indirect partition.\n",
      " |      sort : Full sort.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      See ``np.partition`` for notes on the different algorithms.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> a = np.array([3, 4, 2, 1])\n",
      " |      >>> a.partition(3)\n",
      " |      >>> a\n",
      " |      array([2, 1, 3, 4])\n",
      " |      \n",
      " |      >>> a.partition((1, 3))\n",
      " |      array([1, 2, 3, 4])\n",
      " |  \n",
      " |  prod(...)\n",
      " |      a.prod(axis=None, dtype=None, out=None, keepdims=False)\n",
      " |      \n",
      " |      Return the product of the array elements over the given axis\n",
      " |      \n",
      " |      Refer to `numpy.prod` for full documentation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.prod : equivalent function\n",
      " |  \n",
      " |  ptp(...)\n",
      " |      a.ptp(axis=None, out=None, keepdims=False)\n",
      " |      \n",
      " |      Peak to peak (maximum - minimum) value along a given axis.\n",
      " |      \n",
      " |      Refer to `numpy.ptp` for full documentation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.ptp : equivalent function\n",
      " |  \n",
      " |  put(...)\n",
      " |      a.put(indices, values, mode='raise')\n",
      " |      \n",
      " |      Set ``a.flat[n] = values[n]`` for all `n` in indices.\n",
      " |      \n",
      " |      Refer to `numpy.put` for full documentation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.put : equivalent function\n",
      " |  \n",
      " |  ravel(...)\n",
      " |      a.ravel([order])\n",
      " |      \n",
      " |      Return a flattened array.\n",
      " |      \n",
      " |      Refer to `numpy.ravel` for full documentation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.ravel : equivalent function\n",
      " |      \n",
      " |      ndarray.flat : a flat iterator on the array.\n",
      " |  \n",
      " |  repeat(...)\n",
      " |      a.repeat(repeats, axis=None)\n",
      " |      \n",
      " |      Repeat elements of an array.\n",
      " |      \n",
      " |      Refer to `numpy.repeat` for full documentation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.repeat : equivalent function\n",
      " |  \n",
      " |  reshape(...)\n",
      " |      a.reshape(shape, order='C')\n",
      " |      \n",
      " |      Returns an array containing the same data with a new shape.\n",
      " |      \n",
      " |      Refer to `numpy.reshape` for full documentation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.reshape : equivalent function\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      Unlike the free function `numpy.reshape`, this method on `ndarray` allows\n",
      " |      the elements of the shape parameter to be passed in as separate arguments.\n",
      " |      For example, ``a.reshape(10, 11)`` is equivalent to\n",
      " |      ``a.reshape((10, 11))``.\n",
      " |  \n",
      " |  resize(...)\n",
      " |      a.resize(new_shape, refcheck=True)\n",
      " |      \n",
      " |      Change shape and size of array in-place.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      new_shape : tuple of ints, or `n` ints\n",
      " |          Shape of resized array.\n",
      " |      refcheck : bool, optional\n",
      " |          If False, reference count will not be checked. Default is True.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      None\n",
      " |      \n",
      " |      Raises\n",
      " |      ------\n",
      " |      ValueError\n",
      " |          If `a` does not own its own data or references or views to it exist,\n",
      " |          and the data memory must be changed.\n",
      " |          PyPy only: will always raise if the data memory must be changed, since\n",
      " |          there is no reliable way to determine if references or views to it\n",
      " |          exist.\n",
      " |      \n",
      " |      SystemError\n",
      " |          If the `order` keyword argument is specified. This behaviour is a\n",
      " |          bug in NumPy.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      resize : Return a new array with the specified shape.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      This reallocates space for the data area if necessary.\n",
      " |      \n",
      " |      Only contiguous arrays (data elements consecutive in memory) can be\n",
      " |      resized.\n",
      " |      \n",
      " |      The purpose of the reference count check is to make sure you\n",
      " |      do not use this array as a buffer for another Python object and then\n",
      " |      reallocate the memory. However, reference counts can increase in\n",
      " |      other ways so if you are sure that you have not shared the memory\n",
      " |      for this array with another Python object, then you may safely set\n",
      " |      `refcheck` to False.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      Shrinking an array: array is flattened (in the order that the data are\n",
      " |      stored in memory), resized, and reshaped:\n",
      " |      \n",
      " |      >>> a = np.array([[0, 1], [2, 3]], order='C')\n",
      " |      >>> a.resize((2, 1))\n",
      " |      >>> a\n",
      " |      array([[0],\n",
      " |             [1]])\n",
      " |      \n",
      " |      >>> a = np.array([[0, 1], [2, 3]], order='F')\n",
      " |      >>> a.resize((2, 1))\n",
      " |      >>> a\n",
      " |      array([[0],\n",
      " |             [2]])\n",
      " |      \n",
      " |      Enlarging an array: as above, but missing entries are filled with zeros:\n",
      " |      \n",
      " |      >>> b = np.array([[0, 1], [2, 3]])\n",
      " |      >>> b.resize(2, 3) # new_shape parameter doesn't have to be a tuple\n",
      " |      >>> b\n",
      " |      array([[0, 1, 2],\n",
      " |             [3, 0, 0]])\n",
      " |      \n",
      " |      Referencing an array prevents resizing...\n",
      " |      \n",
      " |      >>> c = a\n",
      " |      >>> a.resize((1, 1))\n",
      " |      Traceback (most recent call last):\n",
      " |      ...\n",
      " |      ValueError: cannot resize an array that has been referenced ...\n",
      " |      \n",
      " |      Unless `refcheck` is False:\n",
      " |      \n",
      " |      >>> a.resize((1, 1), refcheck=False)\n",
      " |      >>> a\n",
      " |      array([[0]])\n",
      " |      >>> c\n",
      " |      array([[0]])\n",
      " |  \n",
      " |  round(...)\n",
      " |      a.round(decimals=0, out=None)\n",
      " |      \n",
      " |      Return `a` with each element rounded to the given number of decimals.\n",
      " |      \n",
      " |      Refer to `numpy.around` for full documentation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.around : equivalent function\n",
      " |  \n",
      " |  searchsorted(...)\n",
      " |      a.searchsorted(v, side='left', sorter=None)\n",
      " |      \n",
      " |      Find indices where elements of v should be inserted in a to maintain order.\n",
      " |      \n",
      " |      For full documentation, see `numpy.searchsorted`\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.searchsorted : equivalent function\n",
      " |  \n",
      " |  setfield(...)\n",
      " |      a.setfield(val, dtype, offset=0)\n",
      " |      \n",
      " |      Put a value into a specified place in a field defined by a data-type.\n",
      " |      \n",
      " |      Place `val` into `a`'s field defined by `dtype` and beginning `offset`\n",
      " |      bytes into the field.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      val : object\n",
      " |          Value to be placed in field.\n",
      " |      dtype : dtype object\n",
      " |          Data-type of the field in which to place `val`.\n",
      " |      offset : int, optional\n",
      " |          The number of bytes into the field at which to place `val`.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      None\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      getfield\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> x = np.eye(3)\n",
      " |      >>> x.getfield(np.float64)\n",
      " |      array([[ 1.,  0.,  0.],\n",
      " |             [ 0.,  1.,  0.],\n",
      " |             [ 0.,  0.,  1.]])\n",
      " |      >>> x.setfield(3, np.int32)\n",
      " |      >>> x.getfield(np.int32)\n",
      " |      array([[3, 3, 3],\n",
      " |             [3, 3, 3],\n",
      " |             [3, 3, 3]])\n",
      " |      >>> x\n",
      " |      array([[  1.00000000e+000,   1.48219694e-323,   1.48219694e-323],\n",
      " |             [  1.48219694e-323,   1.00000000e+000,   1.48219694e-323],\n",
      " |             [  1.48219694e-323,   1.48219694e-323,   1.00000000e+000]])\n",
      " |      >>> x.setfield(np.eye(3), np.int32)\n",
      " |      >>> x\n",
      " |      array([[ 1.,  0.,  0.],\n",
      " |             [ 0.,  1.,  0.],\n",
      " |             [ 0.,  0.,  1.]])\n",
      " |  \n",
      " |  setflags(...)\n",
      " |      a.setflags(write=None, align=None, uic=None)\n",
      " |      \n",
      " |      Set array flags WRITEABLE, ALIGNED, (WRITEBACKIFCOPY and UPDATEIFCOPY),\n",
      " |      respectively.\n",
      " |      \n",
      " |      These Boolean-valued flags affect how numpy interprets the memory\n",
      " |      area used by `a` (see Notes below). The ALIGNED flag can only\n",
      " |      be set to True if the data is actually aligned according to the type.\n",
      " |      The WRITEBACKIFCOPY and (deprecated) UPDATEIFCOPY flags can never be set\n",
      " |      to True. The flag WRITEABLE can only be set to True if the array owns its\n",
      " |      own memory, or the ultimate owner of the memory exposes a writeable buffer\n",
      " |      interface, or is a string. (The exception for string is made so that\n",
      " |      unpickling can be done without copying memory.)\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      write : bool, optional\n",
      " |          Describes whether or not `a` can be written to.\n",
      " |      align : bool, optional\n",
      " |          Describes whether or not `a` is aligned properly for its type.\n",
      " |      uic : bool, optional\n",
      " |          Describes whether or not `a` is a copy of another \"base\" array.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      Array flags provide information about how the memory area used\n",
      " |      for the array is to be interpreted. There are 7 Boolean flags\n",
      " |      in use, only four of which can be changed by the user:\n",
      " |      WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED.\n",
      " |      \n",
      " |      WRITEABLE (W) the data area can be written to;\n",
      " |      \n",
      " |      ALIGNED (A) the data and strides are aligned appropriately for the hardware\n",
      " |      (as determined by the compiler);\n",
      " |      \n",
      " |      UPDATEIFCOPY (U) (deprecated), replaced by WRITEBACKIFCOPY;\n",
      " |      \n",
      " |      WRITEBACKIFCOPY (X) this array is a copy of some other array (referenced\n",
      " |      by .base). When the C-API function PyArray_ResolveWritebackIfCopy is\n",
      " |      called, the base array will be updated with the contents of this array.\n",
      " |      \n",
      " |      All flags can be accessed using the single (upper case) letter as well\n",
      " |      as the full name.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> y\n",
      " |      array([[3, 1, 7],\n",
      " |             [2, 0, 0],\n",
      " |             [8, 5, 9]])\n",
      " |      >>> y.flags\n",
      " |        C_CONTIGUOUS : True\n",
      " |        F_CONTIGUOUS : False\n",
      " |        OWNDATA : True\n",
      " |        WRITEABLE : True\n",
      " |        ALIGNED : True\n",
      " |        WRITEBACKIFCOPY : False\n",
      " |        UPDATEIFCOPY : False\n",
      " |      >>> y.setflags(write=0, align=0)\n",
      " |      >>> y.flags\n",
      " |        C_CONTIGUOUS : True\n",
      " |        F_CONTIGUOUS : False\n",
      " |        OWNDATA : True\n",
      " |        WRITEABLE : False\n",
      " |        ALIGNED : False\n",
      " |        WRITEBACKIFCOPY : False\n",
      " |        UPDATEIFCOPY : False\n",
      " |      >>> y.setflags(uic=1)\n",
      " |      Traceback (most recent call last):\n",
      " |        File \"<stdin>\", line 1, in <module>\n",
      " |      ValueError: cannot set WRITEBACKIFCOPY flag to True\n",
      " |  \n",
      " |  sort(...)\n",
      " |      a.sort(axis=-1, kind='quicksort', order=None)\n",
      " |      \n",
      " |      Sort an array, in-place.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      axis : int, optional\n",
      " |          Axis along which to sort. Default is -1, which means sort along the\n",
      " |          last axis.\n",
      " |      kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional\n",
      " |          Sorting algorithm. Default is 'quicksort'.\n",
      " |      order : str or list of str, optional\n",
      " |          When `a` is an array with fields defined, this argument specifies\n",
      " |          which fields to compare first, second, etc.  A single field can\n",
      " |          be specified as a string, and not all fields need be specified,\n",
      " |          but unspecified fields will still be used, in the order in which\n",
      " |          they come up in the dtype, to break ties.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.sort : Return a sorted copy of an array.\n",
      " |      argsort : Indirect sort.\n",
      " |      lexsort : Indirect stable sort on multiple keys.\n",
      " |      searchsorted : Find elements in sorted array.\n",
      " |      partition: Partial sort.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      See ``sort`` for notes on the different sorting algorithms.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> a = np.array([[1,4], [3,1]])\n",
      " |      >>> a.sort(axis=1)\n",
      " |      >>> a\n",
      " |      array([[1, 4],\n",
      " |             [1, 3]])\n",
      " |      >>> a.sort(axis=0)\n",
      " |      >>> a\n",
      " |      array([[1, 3],\n",
      " |             [1, 4]])\n",
      " |      \n",
      " |      Use the `order` keyword to specify a field to use when sorting a\n",
      " |      structured array:\n",
      " |      \n",
      " |      >>> a = np.array([('a', 2), ('c', 1)], dtype=[('x', 'S1'), ('y', int)])\n",
      " |      >>> a.sort(order='y')\n",
      " |      >>> a\n",
      " |      array([('c', 1), ('a', 2)],\n",
      " |            dtype=[('x', '|S1'), ('y', '<i4')])\n",
      " |  \n",
      " |  squeeze(...)\n",
      " |      a.squeeze(axis=None)\n",
      " |      \n",
      " |      Remove single-dimensional entries from the shape of `a`.\n",
      " |      \n",
      " |      Refer to `numpy.squeeze` for full documentation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.squeeze : equivalent function\n",
      " |  \n",
      " |  std(...)\n",
      " |      a.std(axis=None, dtype=None, out=None, ddof=0, keepdims=False)\n",
      " |      \n",
      " |      Returns the standard deviation of the array elements along given axis.\n",
      " |      \n",
      " |      Refer to `numpy.std` for full documentation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.std : equivalent function\n",
      " |  \n",
      " |  sum(...)\n",
      " |      a.sum(axis=None, dtype=None, out=None, keepdims=False)\n",
      " |      \n",
      " |      Return the sum of the array elements over the given axis.\n",
      " |      \n",
      " |      Refer to `numpy.sum` for full documentation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.sum : equivalent function\n",
      " |  \n",
      " |  swapaxes(...)\n",
      " |      a.swapaxes(axis1, axis2)\n",
      " |      \n",
      " |      Return a view of the array with `axis1` and `axis2` interchanged.\n",
      " |      \n",
      " |      Refer to `numpy.swapaxes` for full documentation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.swapaxes : equivalent function\n",
      " |  \n",
      " |  take(...)\n",
      " |      a.take(indices, axis=None, out=None, mode='raise')\n",
      " |      \n",
      " |      Return an array formed from the elements of `a` at the given indices.\n",
      " |      \n",
      " |      Refer to `numpy.take` for full documentation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.take : equivalent function\n",
      " |  \n",
      " |  tobytes(...)\n",
      " |      a.tobytes(order='C')\n",
      " |      \n",
      " |      Construct Python bytes containing the raw data bytes in the array.\n",
      " |      \n",
      " |      Constructs Python bytes showing a copy of the raw contents of\n",
      " |      data memory. The bytes object can be produced in either 'C' or 'Fortran',\n",
      " |      or 'Any' order (the default is 'C'-order). 'Any' order means C-order\n",
      " |      unless the F_CONTIGUOUS flag in the array is set, in which case it\n",
      " |      means 'Fortran' order.\n",
      " |      \n",
      " |      .. versionadded:: 1.9.0\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      order : {'C', 'F', None}, optional\n",
      " |          Order of the data for multidimensional arrays:\n",
      " |          C, Fortran, or the same as for the original array.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      s : bytes\n",
      " |          Python bytes exhibiting a copy of `a`'s raw data.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> x = np.array([[0, 1], [2, 3]])\n",
      " |      >>> x.tobytes()\n",
      " |      b'\\x00\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x02\\x00\\x00\\x00\\x03\\x00\\x00\\x00'\n",
      " |      >>> x.tobytes('C') == x.tobytes()\n",
      " |      True\n",
      " |      >>> x.tobytes('F')\n",
      " |      b'\\x00\\x00\\x00\\x00\\x02\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x03\\x00\\x00\\x00'\n",
      " |  \n",
      " |  tofile(...)\n",
      " |      a.tofile(fid, sep=\"\", format=\"%s\")\n",
      " |      \n",
      " |      Write array to a file as text or binary (default).\n",
      " |      \n",
      " |      Data is always written in 'C' order, independent of the order of `a`.\n",
      " |      The data produced by this method can be recovered using the function\n",
      " |      fromfile().\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      fid : file or str\n",
      " |          An open file object, or a string containing a filename.\n",
      " |      sep : str\n",
      " |          Separator between array items for text output.\n",
      " |          If \"\" (empty), a binary file is written, equivalent to\n",
      " |          ``file.write(a.tobytes())``.\n",
      " |      format : str\n",
      " |          Format string for text file output.\n",
      " |          Each entry in the array is formatted to text by first converting\n",
      " |          it to the closest Python type, and then using \"format\" % item.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      This is a convenience function for quick storage of array data.\n",
      " |      Information on endianness and precision is lost, so this method is not a\n",
      " |      good choice for files intended to archive data or transport data between\n",
      " |      machines with different endianness. Some of these problems can be overcome\n",
      " |      by outputting the data as text files, at the expense of speed and file\n",
      " |      size.\n",
      " |      \n",
      " |      When fid is a file object, array contents are directly written to the\n",
      " |      file, bypassing the file object's ``write`` method. As a result, tofile\n",
      " |      cannot be used with files objects supporting compression (e.g., GzipFile)\n",
      " |      or file-like objects that do not support ``fileno()`` (e.g., BytesIO).\n",
      " |  \n",
      " |  tolist(...)\n",
      " |      a.tolist()\n",
      " |      \n",
      " |      Return the array as a (possibly nested) list.\n",
      " |      \n",
      " |      Return a copy of the array data as a (nested) Python list.\n",
      " |      Data items are converted to the nearest compatible Python type.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      none\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      y : list\n",
      " |          The possibly nested list of array elements.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      The array may be recreated, ``a = np.array(a.tolist())``.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> a = np.array([1, 2])\n",
      " |      >>> a.tolist()\n",
      " |      [1, 2]\n",
      " |      >>> a = np.array([[1, 2], [3, 4]])\n",
      " |      >>> list(a)\n",
      " |      [array([1, 2]), array([3, 4])]\n",
      " |      >>> a.tolist()\n",
      " |      [[1, 2], [3, 4]]\n",
      " |  \n",
      " |  tostring(...)\n",
      " |      a.tostring(order='C')\n",
      " |      \n",
      " |      Construct Python bytes containing the raw data bytes in the array.\n",
      " |      \n",
      " |      Constructs Python bytes showing a copy of the raw contents of\n",
      " |      data memory. The bytes object can be produced in either 'C' or 'Fortran',\n",
      " |      or 'Any' order (the default is 'C'-order). 'Any' order means C-order\n",
      " |      unless the F_CONTIGUOUS flag in the array is set, in which case it\n",
      " |      means 'Fortran' order.\n",
      " |      \n",
      " |      This function is a compatibility alias for tobytes. Despite its name it returns bytes not strings.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      order : {'C', 'F', None}, optional\n",
      " |          Order of the data for multidimensional arrays:\n",
      " |          C, Fortran, or the same as for the original array.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      s : bytes\n",
      " |          Python bytes exhibiting a copy of `a`'s raw data.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> x = np.array([[0, 1], [2, 3]])\n",
      " |      >>> x.tobytes()\n",
      " |      b'\\x00\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x02\\x00\\x00\\x00\\x03\\x00\\x00\\x00'\n",
      " |      >>> x.tobytes('C') == x.tobytes()\n",
      " |      True\n",
      " |      >>> x.tobytes('F')\n",
      " |      b'\\x00\\x00\\x00\\x00\\x02\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x03\\x00\\x00\\x00'\n",
      " |  \n",
      " |  trace(...)\n",
      " |      a.trace(offset=0, axis1=0, axis2=1, dtype=None, out=None)\n",
      " |      \n",
      " |      Return the sum along diagonals of the array.\n",
      " |      \n",
      " |      Refer to `numpy.trace` for full documentation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.trace : equivalent function\n",
      " |  \n",
      " |  transpose(...)\n",
      " |      a.transpose(*axes)\n",
      " |      \n",
      " |      Returns a view of the array with axes transposed.\n",
      " |      \n",
      " |      For a 1-D array, this has no effect. (To change between column and\n",
      " |      row vectors, first cast the 1-D array into a matrix object.)\n",
      " |      For a 2-D array, this is the usual matrix transpose.\n",
      " |      For an n-D array, if axes are given, their order indicates how the\n",
      " |      axes are permuted (see Examples). If axes are not provided and\n",
      " |      ``a.shape = (i[0], i[1], ... i[n-2], i[n-1])``, then\n",
      " |      ``a.transpose().shape = (i[n-1], i[n-2], ... i[1], i[0])``.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      axes : None, tuple of ints, or `n` ints\n",
      " |      \n",
      " |       * None or no argument: reverses the order of the axes.\n",
      " |      \n",
      " |       * tuple of ints: `i` in the `j`-th place in the tuple means `a`'s\n",
      " |         `i`-th axis becomes `a.transpose()`'s `j`-th axis.\n",
      " |      \n",
      " |       * `n` ints: same as an n-tuple of the same ints (this form is\n",
      " |         intended simply as a \"convenience\" alternative to the tuple form)\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      out : ndarray\n",
      " |          View of `a`, with axes suitably permuted.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      ndarray.T : Array property returning the array transposed.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> a = np.array([[1, 2], [3, 4]])\n",
      " |      >>> a\n",
      " |      array([[1, 2],\n",
      " |             [3, 4]])\n",
      " |      >>> a.transpose()\n",
      " |      array([[1, 3],\n",
      " |             [2, 4]])\n",
      " |      >>> a.transpose((1, 0))\n",
      " |      array([[1, 3],\n",
      " |             [2, 4]])\n",
      " |      >>> a.transpose(1, 0)\n",
      " |      array([[1, 3],\n",
      " |             [2, 4]])\n",
      " |  \n",
      " |  var(...)\n",
      " |      a.var(axis=None, dtype=None, out=None, ddof=0, keepdims=False)\n",
      " |      \n",
      " |      Returns the variance of the array elements, along given axis.\n",
      " |      \n",
      " |      Refer to `numpy.var` for full documentation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.var : equivalent function\n",
      " |  \n",
      " |  view(...)\n",
      " |      a.view(dtype=None, type=None)\n",
      " |      \n",
      " |      New view of array with the same data.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      dtype : data-type or ndarray sub-class, optional\n",
      " |          Data-type descriptor of the returned view, e.g., float32 or int16. The\n",
      " |          default, None, results in the view having the same data-type as `a`.\n",
      " |          This argument can also be specified as an ndarray sub-class, which\n",
      " |          then specifies the type of the returned object (this is equivalent to\n",
      " |          setting the ``type`` parameter).\n",
      " |      type : Python type, optional\n",
      " |          Type of the returned view, e.g., ndarray or matrix.  Again, the\n",
      " |          default None results in type preservation.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      ``a.view()`` is used two different ways:\n",
      " |      \n",
      " |      ``a.view(some_dtype)`` or ``a.view(dtype=some_dtype)`` constructs a view\n",
      " |      of the array's memory with a different data-type.  This can cause a\n",
      " |      reinterpretation of the bytes of memory.\n",
      " |      \n",
      " |      ``a.view(ndarray_subclass)`` or ``a.view(type=ndarray_subclass)`` just\n",
      " |      returns an instance of `ndarray_subclass` that looks at the same array\n",
      " |      (same shape, dtype, etc.)  This does not cause a reinterpretation of the\n",
      " |      memory.\n",
      " |      \n",
      " |      For ``a.view(some_dtype)``, if ``some_dtype`` has a different number of\n",
      " |      bytes per entry than the previous dtype (for example, converting a\n",
      " |      regular array to a structured array), then the behavior of the view\n",
      " |      cannot be predicted just from the superficial appearance of ``a`` (shown\n",
      " |      by ``print(a)``). It also depends on exactly how ``a`` is stored in\n",
      " |      memory. Therefore if ``a`` is C-ordered versus fortran-ordered, versus\n",
      " |      defined as a slice or transpose, etc., the view may give different\n",
      " |      results.\n",
      " |      \n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> x = np.array([(1, 2)], dtype=[('a', np.int8), ('b', np.int8)])\n",
      " |      \n",
      " |      Viewing array data using a different type and dtype:\n",
      " |      \n",
      " |      >>> y = x.view(dtype=np.int16, type=np.matrix)\n",
      " |      >>> y\n",
      " |      matrix([[513]], dtype=int16)\n",
      " |      >>> print(type(y))\n",
      " |      <class 'numpy.matrixlib.defmatrix.matrix'>\n",
      " |      \n",
      " |      Creating a view on a structured array so it can be used in calculations\n",
      " |      \n",
      " |      >>> x = np.array([(1, 2),(3,4)], dtype=[('a', np.int8), ('b', np.int8)])\n",
      " |      >>> xv = x.view(dtype=np.int8).reshape(-1,2)\n",
      " |      >>> xv\n",
      " |      array([[1, 2],\n",
      " |             [3, 4]], dtype=int8)\n",
      " |      >>> xv.mean(0)\n",
      " |      array([ 2.,  3.])\n",
      " |      \n",
      " |      Making changes to the view changes the underlying array\n",
      " |      \n",
      " |      >>> xv[0,1] = 20\n",
      " |      >>> print(x)\n",
      " |      [(1, 20) (3, 4)]\n",
      " |      \n",
      " |      Using a view to convert an array to a recarray:\n",
      " |      \n",
      " |      >>> z = x.view(np.recarray)\n",
      " |      >>> z.a\n",
      " |      array([1], dtype=int8)\n",
      " |      \n",
      " |      Views share data:\n",
      " |      \n",
      " |      >>> x[0] = (9, 10)\n",
      " |      >>> z[0]\n",
      " |      (9, 10)\n",
      " |      \n",
      " |      Views that change the dtype size (bytes per entry) should normally be\n",
      " |      avoided on arrays defined by slices, transposes, fortran-ordering, etc.:\n",
      " |      \n",
      " |      >>> x = np.array([[1,2,3],[4,5,6]], dtype=np.int16)\n",
      " |      >>> y = x[:, 0:2]\n",
      " |      >>> y\n",
      " |      array([[1, 2],\n",
      " |             [4, 5]], dtype=int16)\n",
      " |      >>> y.view(dtype=[('width', np.int16), ('length', np.int16)])\n",
      " |      Traceback (most recent call last):\n",
      " |        File \"<stdin>\", line 1, in <module>\n",
      " |      ValueError: new type not compatible with array.\n",
      " |      >>> z = y.copy()\n",
      " |      >>> z.view(dtype=[('width', np.int16), ('length', np.int16)])\n",
      " |      array([[(1, 2)],\n",
      " |             [(4, 5)]], dtype=[('width', '<i2'), ('length', '<i2')])\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  T\n",
      " |      Same as self.transpose(), except that self is returned if\n",
      " |      self.ndim < 2.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> x = np.array([[1.,2.],[3.,4.]])\n",
      " |      >>> x\n",
      " |      array([[ 1.,  2.],\n",
      " |             [ 3.,  4.]])\n",
      " |      >>> x.T\n",
      " |      array([[ 1.,  3.],\n",
      " |             [ 2.,  4.]])\n",
      " |      >>> x = np.array([1.,2.,3.,4.])\n",
      " |      >>> x\n",
      " |      array([ 1.,  2.,  3.,  4.])\n",
      " |      >>> x.T\n",
      " |      array([ 1.,  2.,  3.,  4.])\n",
      " |  \n",
      " |  __array_finalize__\n",
      " |      None.\n",
      " |  \n",
      " |  __array_interface__\n",
      " |      Array protocol: Python side.\n",
      " |  \n",
      " |  __array_priority__\n",
      " |      Array priority.\n",
      " |  \n",
      " |  __array_struct__\n",
      " |      Array protocol: C-struct side.\n",
      " |  \n",
      " |  base\n",
      " |      Base object if memory is from some other object.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      The base of an array that owns its memory is None:\n",
      " |      \n",
      " |      >>> x = np.array([1,2,3,4])\n",
      " |      >>> x.base is None\n",
      " |      True\n",
      " |      \n",
      " |      Slicing creates a view, whose memory is shared with x:\n",
      " |      \n",
      " |      >>> y = x[2:]\n",
      " |      >>> y.base is x\n",
      " |      True\n",
      " |  \n",
      " |  ctypes\n",
      " |      An object to simplify the interaction of the array with the ctypes\n",
      " |      module.\n",
      " |      \n",
      " |      This attribute creates an object that makes it easier to use arrays\n",
      " |      when calling shared libraries with the ctypes module. The returned\n",
      " |      object has, among others, data, shape, and strides attributes (see\n",
      " |      Notes below) which themselves return ctypes objects that can be used\n",
      " |      as arguments to a shared library.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      None\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      c : Python object\n",
      " |          Possessing attributes data, shape, strides, etc.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.ctypeslib\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      Below are the public attributes of this object which were documented\n",
      " |      in \"Guide to NumPy\" (we have omitted undocumented public attributes,\n",
      " |      as well as documented private attributes):\n",
      " |      \n",
      " |      .. autoattribute:: numpy.core._internal._ctypes.data\n",
      " |      \n",
      " |      .. autoattribute:: numpy.core._internal._ctypes.shape\n",
      " |      \n",
      " |      .. autoattribute:: numpy.core._internal._ctypes.strides\n",
      " |      \n",
      " |      .. automethod:: numpy.core._internal._ctypes.data_as\n",
      " |      \n",
      " |      .. automethod:: numpy.core._internal._ctypes.shape_as\n",
      " |      \n",
      " |      .. automethod:: numpy.core._internal._ctypes.strides_as\n",
      " |      \n",
      " |      If the ctypes module is not available, then the ctypes attribute\n",
      " |      of array objects still returns something useful, but ctypes objects\n",
      " |      are not returned and errors may be raised instead. In particular,\n",
      " |      the object will still have the as parameter attribute which will\n",
      " |      return an integer equal to the data attribute.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> import ctypes\n",
      " |      >>> x\n",
      " |      array([[0, 1],\n",
      " |             [2, 3]])\n",
      " |      >>> x.ctypes.data\n",
      " |      30439712\n",
      " |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long))\n",
      " |      <ctypes.LP_c_long object at 0x01F01300>\n",
      " |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long)).contents\n",
      " |      c_long(0)\n",
      " |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_longlong)).contents\n",
      " |      c_longlong(4294967296L)\n",
      " |      >>> x.ctypes.shape\n",
      " |      <numpy.core._internal.c_long_Array_2 object at 0x01FFD580>\n",
      " |      >>> x.ctypes.shape_as(ctypes.c_long)\n",
      " |      <numpy.core._internal.c_long_Array_2 object at 0x01FCE620>\n",
      " |      >>> x.ctypes.strides\n",
      " |      <numpy.core._internal.c_long_Array_2 object at 0x01FCE620>\n",
      " |      >>> x.ctypes.strides_as(ctypes.c_longlong)\n",
      " |      <numpy.core._internal.c_longlong_Array_2 object at 0x01F01300>\n",
      " |  \n",
      " |  data\n",
      " |      Python buffer object pointing to the start of the array's data.\n",
      " |  \n",
      " |  dtype\n",
      " |      Data-type of the array's elements.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      None\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      d : numpy dtype object\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.dtype\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> x\n",
      " |      array([[0, 1],\n",
      " |             [2, 3]])\n",
      " |      >>> x.dtype\n",
      " |      dtype('int32')\n",
      " |      >>> type(x.dtype)\n",
      " |      <type 'numpy.dtype'>\n",
      " |  \n",
      " |  flags\n",
      " |      Information about the memory layout of the array.\n",
      " |      \n",
      " |      Attributes\n",
      " |      ----------\n",
      " |      C_CONTIGUOUS (C)\n",
      " |          The data is in a single, C-style contiguous segment.\n",
      " |      F_CONTIGUOUS (F)\n",
      " |          The data is in a single, Fortran-style contiguous segment.\n",
      " |      OWNDATA (O)\n",
      " |          The array owns the memory it uses or borrows it from another object.\n",
      " |      WRITEABLE (W)\n",
      " |          The data area can be written to.  Setting this to False locks\n",
      " |          the data, making it read-only.  A view (slice, etc.) inherits WRITEABLE\n",
      " |          from its base array at creation time, but a view of a writeable\n",
      " |          array may be subsequently locked while the base array remains writeable.\n",
      " |          (The opposite is not true, in that a view of a locked array may not\n",
      " |          be made writeable.  However, currently, locking a base object does not\n",
      " |          lock any views that already reference it, so under that circumstance it\n",
      " |          is possible to alter the contents of a locked array via a previously\n",
      " |          created writeable view onto it.)  Attempting to change a non-writeable\n",
      " |          array raises a RuntimeError exception.\n",
      " |      ALIGNED (A)\n",
      " |          The data and all elements are aligned appropriately for the hardware.\n",
      " |      WRITEBACKIFCOPY (X)\n",
      " |          This array is a copy of some other array. The C-API function\n",
      " |          PyArray_ResolveWritebackIfCopy must be called before deallocating\n",
      " |          to the base array will be updated with the contents of this array.\n",
      " |      UPDATEIFCOPY (U)\n",
      " |          (Deprecated, use WRITEBACKIFCOPY) This array is a copy of some other array.\n",
      " |          When this array is\n",
      " |          deallocated, the base array will be updated with the contents of\n",
      " |          this array.\n",
      " |      FNC\n",
      " |          F_CONTIGUOUS and not C_CONTIGUOUS.\n",
      " |      FORC\n",
      " |          F_CONTIGUOUS or C_CONTIGUOUS (one-segment test).\n",
      " |      BEHAVED (B)\n",
      " |          ALIGNED and WRITEABLE.\n",
      " |      CARRAY (CA)\n",
      " |          BEHAVED and C_CONTIGUOUS.\n",
      " |      FARRAY (FA)\n",
      " |          BEHAVED and F_CONTIGUOUS and not C_CONTIGUOUS.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      The `flags` object can be accessed dictionary-like (as in ``a.flags['WRITEABLE']``),\n",
      " |      or by using lowercased attribute names (as in ``a.flags.writeable``). Short flag\n",
      " |      names are only supported in dictionary access.\n",
      " |      \n",
      " |      Only the WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED flags can be\n",
      " |      changed by the user, via direct assignment to the attribute or dictionary\n",
      " |      entry, or by calling `ndarray.setflags`.\n",
      " |      \n",
      " |      The array flags cannot be set arbitrarily:\n",
      " |      \n",
      " |      - UPDATEIFCOPY can only be set ``False``.\n",
      " |      - WRITEBACKIFCOPY can only be set ``False``.\n",
      " |      - ALIGNED can only be set ``True`` if the data is truly aligned.\n",
      " |      - WRITEABLE can only be set ``True`` if the array owns its own memory\n",
      " |        or the ultimate owner of the memory exposes a writeable buffer\n",
      " |        interface or is a string.\n",
      " |      \n",
      " |      Arrays can be both C-style and Fortran-style contiguous simultaneously.\n",
      " |      This is clear for 1-dimensional arrays, but can also be true for higher\n",
      " |      dimensional arrays.\n",
      " |      \n",
      " |      Even for contiguous arrays a stride for a given dimension\n",
      " |      ``arr.strides[dim]`` may be *arbitrary* if ``arr.shape[dim] == 1``\n",
      " |      or the array has no elements.\n",
      " |      It does *not* generally hold that ``self.strides[-1] == self.itemsize``\n",
      " |      for C-style contiguous arrays or ``self.strides[0] == self.itemsize`` for\n",
      " |      Fortran-style contiguous arrays is true.\n",
      " |  \n",
      " |  flat\n",
      " |      A 1-D iterator over the array.\n",
      " |      \n",
      " |      This is a `numpy.flatiter` instance, which acts similarly to, but is not\n",
      " |      a subclass of, Python's built-in iterator object.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      flatten : Return a copy of the array collapsed into one dimension.\n",
      " |      \n",
      " |      flatiter\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> x = np.arange(1, 7).reshape(2, 3)\n",
      " |      >>> x\n",
      " |      array([[1, 2, 3],\n",
      " |             [4, 5, 6]])\n",
      " |      >>> x.flat[3]\n",
      " |      4\n",
      " |      >>> x.T\n",
      " |      array([[1, 4],\n",
      " |             [2, 5],\n",
      " |             [3, 6]])\n",
      " |      >>> x.T.flat[3]\n",
      " |      5\n",
      " |      >>> type(x.flat)\n",
      " |      <type 'numpy.flatiter'>\n",
      " |      \n",
      " |      An assignment example:\n",
      " |      \n",
      " |      >>> x.flat = 3; x\n",
      " |      array([[3, 3, 3],\n",
      " |             [3, 3, 3]])\n",
      " |      >>> x.flat[[1,4]] = 1; x\n",
      " |      array([[3, 1, 3],\n",
      " |             [3, 1, 3]])\n",
      " |  \n",
      " |  imag\n",
      " |      The imaginary part of the array.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> x = np.sqrt([1+0j, 0+1j])\n",
      " |      >>> x.imag\n",
      " |      array([ 0.        ,  0.70710678])\n",
      " |      >>> x.imag.dtype\n",
      " |      dtype('float64')\n",
      " |  \n",
      " |  itemsize\n",
      " |      Length of one array element in bytes.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> x = np.array([1,2,3], dtype=np.float64)\n",
      " |      >>> x.itemsize\n",
      " |      8\n",
      " |      >>> x = np.array([1,2,3], dtype=np.complex128)\n",
      " |      >>> x.itemsize\n",
      " |      16\n",
      " |  \n",
      " |  nbytes\n",
      " |      Total bytes consumed by the elements of the array.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      Does not include memory consumed by non-element attributes of the\n",
      " |      array object.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> x = np.zeros((3,5,2), dtype=np.complex128)\n",
      " |      >>> x.nbytes\n",
      " |      480\n",
      " |      >>> np.prod(x.shape) * x.itemsize\n",
      " |      480\n",
      " |  \n",
      " |  ndim\n",
      " |      Number of array dimensions.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> x = np.array([1, 2, 3])\n",
      " |      >>> x.ndim\n",
      " |      1\n",
      " |      >>> y = np.zeros((2, 3, 4))\n",
      " |      >>> y.ndim\n",
      " |      3\n",
      " |  \n",
      " |  real\n",
      " |      The real part of the array.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> x = np.sqrt([1+0j, 0+1j])\n",
      " |      >>> x.real\n",
      " |      array([ 1.        ,  0.70710678])\n",
      " |      >>> x.real.dtype\n",
      " |      dtype('float64')\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.real : equivalent function\n",
      " |  \n",
      " |  shape\n",
      " |      Tuple of array dimensions.\n",
      " |      \n",
      " |      The shape property is usually used to get the current shape of an array,\n",
      " |      but may also be used to reshape the array in-place by assigning a tuple of\n",
      " |      array dimensions to it.  As with `numpy.reshape`, one of the new shape\n",
      " |      dimensions can be -1, in which case its value is inferred from the size of\n",
      " |      the array and the remaining dimensions. Reshaping an array in-place will\n",
      " |      fail if a copy is required.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> x = np.array([1, 2, 3, 4])\n",
      " |      >>> x.shape\n",
      " |      (4,)\n",
      " |      >>> y = np.zeros((2, 3, 4))\n",
      " |      >>> y.shape\n",
      " |      (2, 3, 4)\n",
      " |      >>> y.shape = (3, 8)\n",
      " |      >>> y\n",
      " |      array([[ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],\n",
      " |             [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],\n",
      " |             [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.]])\n",
      " |      >>> y.shape = (3, 6)\n",
      " |      Traceback (most recent call last):\n",
      " |        File \"<stdin>\", line 1, in <module>\n",
      " |      ValueError: total size of new array must be unchanged\n",
      " |      >>> np.zeros((4,2))[::2].shape = (-1,)\n",
      " |      Traceback (most recent call last):\n",
      " |        File \"<stdin>\", line 1, in <module>\n",
      " |      AttributeError: incompatible shape for a non-contiguous array\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.reshape : similar function\n",
      " |      ndarray.reshape : similar method\n",
      " |  \n",
      " |  size\n",
      " |      Number of elements in the array.\n",
      " |      \n",
      " |      Equal to ``np.prod(a.shape)``, i.e., the product of the array's\n",
      " |      dimensions.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      `a.size` returns a standard arbitrary precision Python integer. This\n",
      " |      may not be the case with other methods of obtaining the same value\n",
      " |      (like the suggested ``np.prod(a.shape)``, which returns an instance\n",
      " |      of ``np.int_``), and may be relevant if the value is used further in\n",
      " |      calculations that may overflow a fixed size integer type.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> x = np.zeros((3, 5, 2), dtype=np.complex128)\n",
      " |      >>> x.size\n",
      " |      30\n",
      " |      >>> np.prod(x.shape)\n",
      " |      30\n",
      " |  \n",
      " |  strides\n",
      " |      Tuple of bytes to step in each dimension when traversing an array.\n",
      " |      \n",
      " |      The byte offset of element ``(i[0], i[1], ..., i[n])`` in an array `a`\n",
      " |      is::\n",
      " |      \n",
      " |          offset = sum(np.array(i) * a.strides)\n",
      " |      \n",
      " |      A more detailed explanation of strides can be found in the\n",
      " |      \"ndarray.rst\" file in the NumPy reference guide.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      Imagine an array of 32-bit integers (each 4 bytes)::\n",
      " |      \n",
      " |        x = np.array([[0, 1, 2, 3, 4],\n",
      " |                      [5, 6, 7, 8, 9]], dtype=np.int32)\n",
      " |      \n",
      " |      This array is stored in memory as 40 bytes, one after the other\n",
      " |      (known as a contiguous block of memory).  The strides of an array tell\n",
      " |      us how many bytes we have to skip in memory to move to the next position\n",
      " |      along a certain axis.  For example, we have to skip 4 bytes (1 value) to\n",
      " |      move to the next column, but 20 bytes (5 values) to get to the same\n",
      " |      position in the next row.  As such, the strides for the array `x` will be\n",
      " |      ``(20, 4)``.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.lib.stride_tricks.as_strided\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> y = np.reshape(np.arange(2*3*4), (2,3,4))\n",
      " |      >>> y\n",
      " |      array([[[ 0,  1,  2,  3],\n",
      " |              [ 4,  5,  6,  7],\n",
      " |              [ 8,  9, 10, 11]],\n",
      " |             [[12, 13, 14, 15],\n",
      " |              [16, 17, 18, 19],\n",
      " |              [20, 21, 22, 23]]])\n",
      " |      >>> y.strides\n",
      " |      (48, 16, 4)\n",
      " |      >>> y[1,1,1]\n",
      " |      17\n",
      " |      >>> offset=sum(y.strides * np.array((1,1,1)))\n",
      " |      >>> offset/y.itemsize\n",
      " |      17\n",
      " |      \n",
      " |      >>> x = np.reshape(np.arange(5*6*7*8), (5,6,7,8)).transpose(2,3,1,0)\n",
      " |      >>> x.strides\n",
      " |      (32, 4, 224, 1344)\n",
      " |      >>> i = np.array([3,5,2,2])\n",
      " |      >>> offset = sum(i * x.strides)\n",
      " |      >>> x[3,5,2,2]\n",
      " |      813\n",
      " |      >>> offset / x.itemsize\n",
      " |      813\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  __hash__ = None\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(np.ndarray)  # 文档即教程"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 关于Numpy类型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(np_weights)                   # 应该返回numpy的类型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mixed_list = [1.0, \"is\", True] # 通用类型的list\n",
    "type(np.array(mixed_list))     # 转化为numpy array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['1.0', 'is', 'True'], dtype='<U32')"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array(mixed_list)               # 数据类型是字符串"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "##### 深入了解numpy数据类型\n",
    "[dtype](https://docs.scipy.org/doc/numpy/reference/arrays.dtypes.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "##### 快速检索开发文档\n",
    ">具有本地索引的应用程序，Jupyter的help菜单速度不够快\n",
    "\n",
    "- [Dash](https://kapeli.com/dash)\n",
    "- [velocity](http://velocity.silverlakesoftware.com/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 数理统计和线性代数基础"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "##### 数理统计的例子\n",
    "- 在大样本数据上计算身高体重指数\n",
    "- 把前面5人的例子扩大1000倍\n",
    "- 随机产生一个正态分布"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "> [正态分布生成](https://docs.scipy.org/doc/numpy/reference/generated/numpy.random.normal.html?highlight=random%20normal#numpy.random.normal)文档\n",
    "![文档链接](http://bazhou.blob.core.windows.net/learning/mpp/npnormal_doc.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "![正态分布生成文档快照](http://bazhou.blob.core.windows.net/learning/mpp/npnormal.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "##### 中国成年人身高，体重均值和标准差的参考值 （2015）\n",
    "|性别|东北华北|西北|东南|华中|华南|西南|\n",
    "|-|-|-|-|-|-|-|\n",
    "|身高，体重|均值，标准差|均值，标准差|均值，标准差|均值，标准差|均值，标准差|均值，标准差|\n",
    "|男(mm)|1693, 56.6|1684, 53.7|1686, 55,2|1669, 56.3|1650, 57.1|1647, 56.7|\n",
    "|女(mm)|1586, 51.8|1575, 51.9|1575, 50.8|1560, 50.7|1549, 49.7|1546, 53.9|\n",
    "|男(kg)|64, 8.2|60, 7.6|59, 7.7|57, 6.9|56, 6.9|55, 6.8|\n",
    "|女(kg)|55, 7.1|52, 7.1|51, 7.2|50, 6.8|49, 6.5|50, 6.9|\n",
    "\n",
    "> 选择东南地区成年男性数据：身高：1686, 55.2，体重：59, 7.7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.70968916, 52.24683079],\n",
       "       [ 1.58328235, 55.44822133],\n",
       "       [ 1.6495744 , 42.18011517],\n",
       "       ...,\n",
       "       [ 1.84574057, 62.61678161],\n",
       "       [ 1.73779399, 53.75894973],\n",
       "       [ 1.69617327, 55.12759054]])"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "height_5k = np.random.normal(1.686, 0.0552, 5000)   # 5000身高数据\n",
    "weight_5k = np.random.normal(59, 7.7, 5000)         # 5000体重数据\n",
    "shmale_5k = np.column_stack((height_5k, weight_5k)) # 5000上海男性数据\n",
    "shmale_5k                                           # 随机产生一些瘦子和胖子"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "上海男            均值     标准差\n",
      "------------  --------  ---------\n",
      "身高（米）     1.68475  0.0549343\n",
      "体重（公斤）  59.0066   7.79089\n"
     ]
    }
   ],
   "source": [
    "shmale_weight = shmale_5k[:,1]\n",
    "shmale_height = shmale_5k[:,0]\n",
    "shmale_height_mean = np.mean(shmale_height)  # 身高均值\n",
    "shmale_height_std = np.std(shmale_height)    # 身高标准差\n",
    "shmale_weight_mean = np.mean(shmale_weight)  # 体重均值\n",
    "shmale_weight_std = np.std(shmale_weight)    # 体重标准差\n",
    "from tabulate import tabulate                # 格式化成表格样式\n",
    "print(tabulate([['身高（米）', shmale_height_mean, shmale_height_std], \n",
    "                ['体重（公斤）', shmale_weight_mean, shmale_weight_std]], \n",
    "               headers=['上海男','均值', '标准差']))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([21.53342165, 15.81248488, 19.94218316, ..., 19.06582984,\n",
       "       17.61357691, 25.66580711])"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shmale_bmi = shmale_weight / shmale_height ** 2 # 计算5000身高体重指数\n",
    "shmale_bmi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20.854954078674073 3.074664871185173\n"
     ]
    }
   ],
   "source": [
    "print(np.mean(shmale_bmi), np.std(shmale_bmi))  # 上海男性体型分布"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "##### 线性代数例子\n",
    "- 解方程组\n",
    "\\begin{equation}2x + 3y = 8 \\end{equation}\n",
    "\\begin{equation}5x + 2y = 9 \\end{equation}\n",
    "\n",
    "- 用矩阵的形式表示为\n",
    "$$ A = \\begin{bmatrix}2 & 3\\\\5 & 2\\end{bmatrix} \\;\\;\\;\\; \\vec{b} = \\begin{bmatrix}8\\\\9\\end{bmatrix}$$\n",
    "\n",
    "- 目标是求向量x\n",
    "$$ A\\vec{x}= \\vec{b} $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 5],\n",
       "       [3, 2]])"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([[2, 3], [5, 2]]) # 方程组系数矩阵\n",
    "a.transpose()                  # 转置"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2,) (2, 2)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([8, 9])"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = np.array([8, 9])\n",
    "print(b.shape, a.shape)         # shape不是函数，是tuple\n",
    "b.transpose()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  A    0    1\n",
      "---  ---  ---\n",
      "  0    2    3\n",
      "  1    5    2\n"
     ]
    }
   ],
   "source": [
    "# 矩阵的索引\n",
    "print(tabulate([['0', a[0,0], a[0,1]], \n",
    "                ['1', a[1,0], a[1,1]]], \n",
    "               headers=['A', '0', '1']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    ">[矩阵运算](https://docs.scipy.org/doc/numpy/reference/routines.linalg.html)文档\n",
    "![linalg](http://bazhou.blob.core.windows.net/learning/mpp/linalg.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "![矩阵求逆](http://bazhou.blob.core.windows.net/learning/mpp/linalg.inv.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.18181818,  0.27272727],\n",
       "       [ 0.45454545, -0.18181818]])"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 矩阵求逆\n",
    "from numpy.linalg import inv as inv\n",
    "a_inv = inv(a)\n",
    "a_inv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "$$ A^{-1}A=\\begin{bmatrix}1 & 0\\\\0 & 1\\end{bmatrix} $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  0.],\n",
       "       [-0.,  1.]])"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.round(a_inv @ a) # 逆矩阵和原矩阵乘来验证求逆, @代表矩阵乘"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "$$ A^{-1}A\\vec{x}=A^{-1}\\vec{b}$$\n",
    "\n",
    "\n",
    "$$ \\begin{bmatrix}1 & 0\\\\0 & 1\\end{bmatrix}\\vec{x}= A^{-1}\\vec{b}$$\n",
    "\n",
    "\n",
    "$$ \\vec{x} = A^{-1}\\vec{b}$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 2.])"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = a_inv @ b\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 2.])"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from numpy.linalg import solve as solve # 引入求解方法\n",
    "solve(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "$$ \\vec{x} = \\begin{bmatrix}1\\\\2\\end{bmatrix} $$\n",
    "\n",
    "\n",
    "$$ x=1 $$\n",
    "$$ y=2 $$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# 图形绘制\n",
    ">图形可视化是非常强大的工具"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "[Hans Rosling](https://en.wikipedia.org/wiki/Hans_Rosling)的[例子](https://www.ted.com/talks/hans_rosling_shows_the_best_stats_you_ve_ever_seen)\n",
    "![hans](http://bazhou.blob.core.windows.net/learning/mpp/hans_rosling.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<video width=\"80%\" controls src=\"http://bazhou.blob.core.windows.net/learning/mpp/1193_The_best_stats_you_ve_ever_seen_-_Hans_Rosling-usdJgEwMinM.mp4\" />\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Matplot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from IPython.core.interactiveshell import InteractiveShell\n",
    "InteractiveShell.ast_node_interactivity = \"last_expr\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt  \n",
    "year = [1950, 1970, 1990, 2010]      # 世界人口数据\n",
    "pop = [2.519, 3.692, 5.263, 6.972] \n",
    "plt.plot(year, pop)                  # 折线图\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(year, pop)               # 散点图\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(year, pop)\n",
    "plt.xlabel(\"year\")                # 不能使用Unicode, \"年\"\n",
    "plt.ylabel(\"population\")          # 坐标轴标注\n",
    "plt.title(\"world population\")     # 标题\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(year, pop)\n",
    "plt.xlabel(\"year\")\n",
    "plt.ylabel(\"population\")\n",
    "plt.title(\"world population\")\n",
    "plt.yticks([0,2,4,6,8,10],\n",
    "    [\"0\",\"2B\",\"4B\",\"6B\",\"8B\",\"10B\"])        # 坐标轴刻度\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(year, pop)\n",
    "plt.fill_between(year,pop,0,color='lightblue') # 填充色\n",
    "plt.xlabel(\"year\")\n",
    "plt.ylabel(\"population\")\n",
    "plt.title(\"world population\")\n",
    "plt.yticks([0,2,4,6,8,10],\n",
    "    [\"0\",\"2B\",\"4B\",\"6B\",\"8B\",\"10B\"])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 直方图\n",
    "\n",
    "- 数据分布的可视化\n",
    "- 数据分布\n",
    "\n",
    "![分布](http://bazhou.blob.core.windows.net/learning/mpp/distribution.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "> [直方图](https://matplotlib.org/api/_as_gen/matplotlib.pyplot.hist.html?highlight=hist#matplotlib.pyplot.hist)文档\n",
    "![histlink](http://bazhou.blob.core.windows.net/learning/mpp/histlink.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "![histdoc](http://bazhou.blob.core.windows.net/learning/mpp/hist.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "values = [0,0.6,1.4,1.6,2.2,2.5,2.6,3.2,3.5,3.9,4.2,6] \n",
    "plt.hist(values, bins=4)                                    # 分布区间数目\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.hist(shmale_bmi, bins=20)     # 几乎是一个钟形曲线\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.6.5"
  },
  "livereveal": {
   "scroll": true
  },
  "rise": {
   "enable_chalkboard": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}