zh-CN/NewToDataScience/PythonDataScience.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "doOoC294Grdq"
   },
   "source": [
    "# **Python 数据科学实用指南**\n",
    "-----\n",
    "\n",
    "## **介绍**\n",
    "\n",
    "本指南探讨了允许你使用 Python 执行数据分析的最佳实践和基础知识。在本指南中，你将学习如何使用 Jupyter notebook 和 Python 库（如 Pandas ， Matplotlib 和 Numpy ）轻松、透明地探索和分析数据集。\n",
    "\n",
    "\n",
    "## **什么是数据科学？**\n",
    "\n",
    "\n",
    "从本质上讲，[数据科学](https://zh.wikipedia.org/wiki/%E6%95%B0%E6%8D%AE%E7%A7%91%E5%AD%A6) 是关于从大量数据中 *提取知识* 来生成信息。这基本上是使用数学和计算机科学等几门学科完成的，如统计学，概率模型，机器学习，数据存储，计算机编程等。\n",
    "\n",
    "欲了解更多信息，我们邀请读者查看 [这本书](https://www.amazon.com/Data-Science-Scratch-Principles-Python/dp/149190142X) .\n",
    "\n",
    "## **先决条件**\n",
    "\n",
    "在参加本指南之前，有必要从 *Python 编程* 开始，我们还将参考 *概率和统计* 的基本概念，以及 *关系代数*\n",
    "\n",
    "## **主要用途**\n",
    "\n",
    "遵循本指南后，读者应熟悉以下任务：\n",
    "\n",
    "\n",
    "* 创建和安装 Python 模块;\n",
    "* 修改和使用 Jupyter notebook ; \n",
    "* 使用 `Matplotlib` 和 `Seaborn` 进行数据可视化; \n",
    "* 使用 `Numpy` 处理表;;\n",
    "* 使用 `Pandas` 处理数据集。.\n",
    "\n",
    "\n",
    "## **指南计划**\n",
    "\n",
    "我们将根据以下计划提出分层内容：\n",
    "\n",
    "\n",
    "\n",
    "1. 设置你的工作环境;\n",
    "2. 开始使用Python; \n",
    "3. 使用Numpy和Matplotlib处理数据; \n",
    "4. 使用Pandas库处理大量数据。\n",
    "\n",
    "让我们开始。\n",
    "\n",
    "### **1. 设置你的工作环境;**\n",
    "\n",
    "为了开始用 Python 分析数据，我们需要有一些背景知识，就像所有其它相关主题一样。现在，我们将尝试解释如何在自己的机器上安装 Jupyter。\n",
    "\n",
    "如果你还没有 Python ，可以使用 [这个方案](https://jupyter.org/install.html) 直接安装 Python ，包括所有必需的库和 Jupyter notebook。\n",
    "一旦安装了 Python ，你将需要安装 Jupyter notebook ，以及以下库： `Pandas`  , `Matplotlib` ,  `Numpy`  和  `SciPy`.\n",
    " \n",
    "\n",
    "在实践中，有两种可能的解决方案来安装 Jupyter notebook 及其必要的库：\n",
    "\n",
    "\n",
    "\n",
    "* 与 Anaconda 发行版一起完全安装; \n",
    "* 单独安装 Jupyter notebook（不含Anaconda）。\n",
    "\n",
    "\n",
    "**1.1. 与 Anaconda 发行版一起完全安装**\n",
    "\n",
    "对于那些从未安装过 Python 的人，建议直接安装 Anaconda 发行版。这是我们将在本节中做的。请注意， Anaconda 是为数据科学开发的 Python 发行版。\n",
    "\n",
    "Anaconda 会安装我们需要的一切，但它可以会安装太多（我们不会使用的库，等等）。你可以在此处 [下载](https://conda.io/en/latest/)  Anaconda 的改进版本。但是，目的是不会自动安装库，尤其是 Jupyter 。因此，这是有经验的用户的解决方案。\n",
    "\n",
    "\n",
    "在 [这个页面](http://docs.anaconda.com/anaconda/install) 你将找到正式的安装说明，以防这些说明不再有效。\n",
    "\n",
    "\n",
    "要在 Windows 或 macOS  上安装 Anaconda ，你必须：\n",
    "\n",
    "*  (1) 下载 [Windows](https://www.anaconda.com/distribution/#windows) 或 [macOS](https://www.anaconda.com/distribution/#macos) 的设置文件，然后双击下载的文件启动它;\n",
    "*   (2) 安装完成后，确保通过执行 Jupyter 程序完成所有操作\n",
    "\n",
    "**1.2. 单独安装 Jupyter notebook（不含Anaconda）**\n",
    "\n",
    "为避免安装 Anaconda ，你可以在安装 Python 后按照以下说明操作：\n",
    "\n",
    "* 检查你的机器上是否安装了 `pip` 。为此，你只需在控制台中键入 `pip` 。通常， pip 与 Python 同时启动。接下来，连续输入这些代码："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 836
    },
    "colab_type": "code",
    "id": "hnMfzYYKG4K2",
    "outputId": "1e213f95-9ed8-4d30-9e5a-1f601bca1f6e"
   },
   "outputs": [],
   "source": [
    "!python -m pip install --upgrade pip    \n",
    "!python -m pip install jupyter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "S9VuAmUOIgtx"
   },
   "source": [
    "通过在控制台中键入以下命令，你可以验证设置是否正常："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 153
    },
    "colab_type": "code",
    "id": "bhb_k8YdIiEj",
    "outputId": "443f3cbb-b56e-447a-93b4-36ebb2d24834"
   },
   "outputs": [],
   "source": [
    "  !jupyter notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Zj7YIvGkM3yO"
   },
   "source": [
    "现在你可以创建一个新 notebook 了。\n",
    "\n",
    "\n",
    "* 检查你的计算机上是否安装了 `pip 命令`  。为此，你只需在控制台键入 pip 即可。然后，在控制台中键入以下命令："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 289
    },
    "colab_type": "code",
    "id": "_-wtSmeGM59a",
    "outputId": "c16886e4-4c6e-45bd-d0d8-6adf6c82cd88"
   },
   "outputs": [],
   "source": [
    "   !pip install scipy\n",
    "   !pip install numpy\n",
    "   !pip install matplotlib\n",
    "   !pip install pandas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "nobVMi-aNEMh"
   },
   "source": [
    "作为替代方案，你现在可以测试 Jupyter ，通过 [此链接](https://jupyter.org/try) 而无需安装任何内容。\n",
    "\n",
    "让我们在 Jupyter notebook 中进行第一次实验：\n",
    "\n",
    "要创建一个新 notebook, 请从主 Jupyter 窗口中单击 `New` 然后再打开 `Python 3`, 如下所示：\n",
    "\n",
    "![创建一个新 notebook](https://i.ibb.co/dWDfrwV/ju1.jpg) \n",
    "\n",
    "在启动 Jupyter 的目录中，通常会创建一个名为 `Untitled.ipynb` 的文件。必须在 `In [ ]` 标签旁边的字段中键入所有Python命令。为此，只需同时键入几条指令即可。甚至可以定义函数。每个单元格中生成的所有变量都可以在 notebook 的所有单元格中访问。完成输入后，按下 `Shift+Enter` 执行它们。\n",
    "\n",
    "要对其进行测试，请键入例如 `2 + 5` 位于窗口中心的空单元格。然后单击此按钮：\n",
    "![Test](https://i.ibb.co/0VQWxHS/2.jpg) \n",
    "\n",
    "### 2.   开始使用 Python\n",
    "\n",
    "在本节中，我们将记住 Python 编程的基础知识。此外，我们不会列出我们需要掌握的所有内容，但我们将模拟整个问题。好吧，我们第一次听说 [蒙提霍尔问题/三门问题（Monty Hall problem）](https://www.montyhallproblem.com/) 。该游戏涉及一个针对竞争对手（玩家）的主持人。该竞争对手位于三个关闭的门前。其中一个门后面有一辆车，其它门后面都是一只山羊。首先，它必须指明一扇门。然后，主持人必须打开一扇门，既不是候选人选择的门，也不是隐藏汽车的门。然后，竞争对手有权打开门，或坚持他最初的选择，或打开第三扇门。\n",
    "\n",
    "首先，让我们在 notebook 中设置我们的工作区："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "_MWPLDtrNOS2"
   },
   "outputs": [],
   "source": [
    "# For displaying graphics in the code sequence, \n",
    "# and not in a separate window:\n",
    "%matplotlib inline\n",
    "\n",
    "# By using the randint function, which generates numbers\n",
    "# whole in a random way:\n",
    "from random import randint, seed\n",
    "\n",
    "# An Enum is a data structure that consists of a \n",
    "# set of appointed elements. This type of variable can be\n",
    "# have as value one of these elements.\n",
    "from enum import Enum\n",
    "\n",
    "# For displaying graphs:\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "nZwquF_zNgwt"
   },
   "source": [
    "可以定义我们的函数。我们将创建一个非常简单的函数。它只代表特定策略的游戏的一部分。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "nvdScfJWNhau"
   },
   "outputs": [],
   "source": [
    "class Strategy(Enum) :\n",
    "    CHANGE = 1\n",
    "    KEEP = 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "BplRPuL5NkSK"
   },
   "source": [
    "在这里，我们定义了 枚举(Enum) 的子类，它将包含可能的策略。此代码涉及使用面向对象的编程概念，包括类和继承。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "KoOiSdLiNmdw"
   },
   "outputs": [],
   "source": [
    "# Uses the system clock to initialize the generator of \n",
    "# pseudo-random numbers.\n",
    "seed() \n",
    "\n",
    "def Hall_game(strategy) :\n",
    "    ''' Simulates part of the Monty Hall game. This function simulates the participant's choice of door, the elimination of a bad door by the presenter, and the final choice. It only returns the result of the game, because that we will only need the result to perform our calculations.\n",
    "    \n",
    "    Args:\n",
    "        strategy (strategy) : The player's strategy\n",
    "        \n",
    "    Returns:\n",
    "        bool: Has the player won?\n",
    " '''\n",
    "    doors =[0, 1, 2]\n",
    "    \n",
    "    good_door = randint(0,2) \n",
    "    \n",
    "    # Choice of player\n",
    "    first_choice = randint(0,2) \n",
    "    \n",
    "    # We have two doors left\n",
    "    doors.remove(first_choice) \n",
    "    \n",
    "    # The presenter eliminates a door\n",
    "    if first_choice == good_door:\n",
    "        doors.remove(doors[randint(0,1) ]) \n",
    "    else:\n",
    "        doors =[good_door]\n",
    "    \n",
    "    second_choice = 0\n",
    "    # The second choice depends on the strategy\n",
    "    if strategy == Strategy.CHANGE:\n",
    "        second_choice = doors[0]\n",
    "    elif strategy == Strategy.KEEP:\n",
    "        second_choice = first_choice\n",
    "    else:\n",
    "        raise ValueError(\"Strategy not recognized!\") \n",
    "    \n",
    "    return second_choice == good_door"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "SNl8XXn8NtQB"
   },
   "source": [
    "`Randint` 函数返回其两个参数之间的随机整数。例如，randint(0,1) 将返回 0 或 1 。\n",
    "\n",
    "我们现在将测试我们的函数。多次运行下一行以确保结果是随机的。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 299
    },
    "colab_type": "code",
    "id": "nfy76TSTNvXV",
    "outputId": "bba613d8-cdd6-4588-fb08-bdad3d5c4ab5"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "strategy = Strategy.CHANGE\n",
    "Hall_game(strategy) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "GFrftRwlQOSS"
   },
   "source": [
    "在这种情况下，有必要定义一个将一遍又一遍地启动游戏的函数，并返回每个游戏的结果 `list`.\n",
    "\n",
    "为了对这些结果进行计算，我们将不再将它们保留为布尔变量（ True 或 False ），而是根据玩家的胜利（如果他赢了则为 1 ，如果他输了则为 0 ）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "-9TACrxTQPzj"
   },
   "outputs": [],
   "source": [
    "def Play(strategy, nb_turns) :\n",
    "    '''Simulates a sequence of game turns. This function returns the results of several games of the Monty Hall game in the form of a list of winnings by the player.\n",
    "    \n",
    "    Args:\n",
    "        strategy (strategy) : The player's strategy\n",
    "        nb_turns (int) : Number of revolutions\n",
    "        \n",
    "    Returns:\n",
    "        list: List of players' winnings for each game\n",
    "    '''\n",
    "\n",
    "    return [1 if Hall_game(strategy) else 0 for i in range(nb_turns) ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "yZU-_k6YQdyx"
   },
   "source": [
    "对于给定数量的游戏（10000），首先需要知道哪种策略对于玩家最有效。我们有一个列表，其中包含最多 1 个玩家赢得的游戏数量。只需要计算此列表中所有项目的总和 `sum function`，即可知道 1 的数量。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "id": "0_BXVfgIQhQZ",
    "outputId": "dbf105d0-fbbb-4866-be6f-e2ab1c953c9c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "By changing doors, the player has won 6737 on 10,000 games.\n",
      "By keeping his initial choice, the player has won 3441 out of 10,000 games.\n"
     ]
    }
   ],
   "source": [
    "print(\"By changing doors, the player has won {} on 10,000 games.\"\n",
    "      .format(sum(Play(Strategy.CHANGE, 10000) )) )\n",
    "      \n",
    "print(\"By keeping his initial choice, the player has won {} out of 10,000 games.\"\n",
    "      .format(sum(Play(Strategy.KEEP, 10000) )) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "LTrEp2ELQxf3"
   },
   "source": [
    "### 3.   使用 Numpy 和 Matplotlib 操作数据\n",
    "\n",
    "**3.1. 使用 Numpy 处理数据**\n",
    "\n",
    "本节将重点介绍如何有效地加载，存储和操作数据。它们可以在各种各样的来源中找到，但它们总是可以被视为数字数组。我们将看到一个操纵这些数组的工具： Numpy 。 NumPy（Numerical Python）提供了一个存储和处理数据的接口。Numpy 数组就像 Python 列表，但是 Numpy 可以让事情变得更有效率，，特别是对于更大的数组。\n",
    "\n",
    "让我们从导入Numpy开始："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "zneWztcTQyF5"
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "AJTzKGKdQ1BV"
   },
   "source": [
    "**创建 Numpy 数组**\n",
    "\n",
    "与 Python 列表不同， Numpy 数组只能包含一种类型的成员。有几种方法可以在 Numpy 中创建数组："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "UaOceLg1Q7nP",
    "outputId": "8306ea43-8866-4191-c62e-882ac84e78b6"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Array of integers:\n",
    "np.array([1, 2, 3]) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "KuT4455wQ-6i"
   },
   "source": [
    "如果初始列表中有不同类型的数据，Numpy 将尝试将它们全部转换为最通用的类型。例如，整数 `int` 将转换为 `float` 数字："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "sSMQDcypRDhy",
    "outputId": "5e3d0734-4440-48d2-a679-0cdf23a70a91"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3.1, 4. , 5. , 6. ])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([3.1, 4, 5, 6]) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "zWMIeEjLRElp"
   },
   "source": [
    "作为替代方案，也可以手动设置类型："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "0mZYyk1oRGkE",
    "outputId": "d509cfd2-2d73-4662-99d4-8a299cc70518"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 2., 3.], dtype=float32)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([1, 2, 3], dtype='float32') "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "M8KjB1MjRJMq"
   },
   "source": [
    "在许多情况下，通过直接创建它们更有效，特别是对于大型数组。 Numpy 有以下几个函数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 68
    },
    "colab_type": "code",
    "id": "PKSRzj29RMlL",
    "outputId": "3ecdcb7e-a7c3-4619-9a50-6c93f7130602"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0.],\n",
       "       [0., 1., 0.],\n",
       "       [0., 0., 1.]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# An array of length 10, filled with integers that are worth 0\n",
    "np.zeros(10, dtype=int) \n",
    "\n",
    "# A 3x5 size array filled with floating point numbers of value 1\n",
    "np.ones((3, 5) , dtype=float) \n",
    "\n",
    "# A 3x5 table filled with 3.14\n",
    "np.full((3, 5) , 3.14) \n",
    "\n",
    "# A table filled with a linear sequence\n",
    "# starting from 0 and ending from 20, with a step of 2\n",
    "np.arange(0, 20, 2) \n",
    "\n",
    "# A table of 5 values, uniformly spaced between 0 and 1\n",
    "np.linspace(0, 1, 5) \n",
    "\n",
    "# This one you already know! Try also \"randint\" and \"normal\"\n",
    "#np.random((3, 3) )\n",
    "\n",
    "# The identity matrix size 3x3 \n",
    "np.eye(3) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "zLe8-RkmRaZy"
   },
   "source": [
    "**数组属性，索引和切片**\n",
    "\n",
    "每个 Numpy 数组都有一些通常有用的属性。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 85
    },
    "colab_type": "code",
    "id": "ix_cPObPRdFu",
    "outputId": "46a1a17d-1748-4328-f1ef-1a2059f4e522"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dimensions number of x1: 1\n",
      "shape of x1: (6,)\n",
      "size of x1: 6\n",
      "type of x1: int64\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(0) \n",
    "x1 = np.random.randint(10, size=6) # Dimension table 1\n",
    "print(\"dimensions number of x1:\", x1.ndim) \n",
    "print(\"shape of x1:\", x1.shape) \n",
    "print(\"size of x1:\", x1.size) \n",
    "print(\"type of x1:\", x1.dtype) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "QdpuA9SNRgl-"
   },
   "source": [
    "为此，我们经常需要访问数组的一个或多个元素。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 119
    },
    "colab_type": "code",
    "id": "P7AbMQJhRivJ",
    "outputId": "81c5931f-ff87-42af-e8e7-7ce4b27748f3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5 0 3 3 7 9]\n",
      "5\n",
      "9\n",
      "5\n",
      "[   5 1000    3    3    7    9]\n",
      "[5 3 3 3 7 9]\n"
     ]
    }
   ],
   "source": [
    "print(x1) \n",
    "\n",
    "# To get access to the first element\n",
    "print(x1[0]) \n",
    "\n",
    "# to get access to the last element\n",
    "print(x1[-1]) \n",
    "\n",
    "x2 = np.random.randint(10, size=(3, 4) ) # Dimension table of 2\n",
    "print(x2[0,1]) \n",
    "\n",
    "# We can also set different values\n",
    "x1[1] = \"1000\"\n",
    "print(x1) \n",
    "\n",
    "x1[1] = 3.14\n",
    "print(x1) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "liX0prIARmVi"
   },
   "source": [
    "我们可以与索引元素相同的方式使用 `[]` ，我们通过组合 `[]` 和 `:` 访问一组元素。语法有一个简单的规则：`x[start:end:step]`。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 68
    },
    "colab_type": "code",
    "id": "PaZYbOG6Rot9",
    "outputId": "c2202130-c3a7-482c-b12b-ce6d57d0fffa"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5 3 3 3 7]\n",
      "[9]\n",
      "[5 3 7]\n"
     ]
    }
   ],
   "source": [
    "print(x1[:5]) # The first five elements\n",
    "\n",
    "print(x1[5:]) # Elements starting at index 5\n",
    "\n",
    "print(x1[::2]) # One of two elements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Poor6AWnRri_"
   },
   "source": [
    "可以连接两个或多个数组："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "hdXtfGdMRtl0",
    "outputId": "f58ec1b8-24ad-427e-a279-3764c5dd01b8"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 3, 2, 1])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array([1, 2, 3]) \n",
    "y = np.array([3, 2, 1]) \n",
    "np.concatenate([x, y]) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "HcMlwxroRw1a"
   },
   "source": [
    "到目前为止，我们已经看到了 Numpy 数组上非常基本的东西。从这里开始，我们将看到是什么让 Numpy 变得非常重要。 Python 的基准实现（也称为 CPython ）非常灵活，但这种灵活性使其无法使用所有可能的优化。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "SVunc4lGRy8K",
    "outputId": "42f550af-baf4-40f9-e58f-586fe49d4c7c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.11111111 0.5        0.16666667 0.11111111 0.2       ]\n"
     ]
    }
   ],
   "source": [
    "def reverse_calculation(values) :\n",
    "    output = np.empty(len(values) )\n",
    "    for i in range(len(values) ):\n",
    "        output[i] = 1.0 / values[i]\n",
    "    return output\n",
    "        \n",
    "values = np.random.randint(1, 10, size=5) \n",
    "print(reverse_calculation(values) )\n",
    "\n",
    "wide_array = np.random.randint(1, 100, size=1000000) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Qyo3lqRMR15u"
   },
   "source": [
    "我们现在提供此类操作的总览："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 119
    },
    "colab_type": "code",
    "id": "mIwFRfWcR4He",
    "outputId": "87c423c3-5af1-4447-e840-be0528b6f3c5"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = [0 1 2 3]\n",
      "x + 5 = [5 6 7 8]\n",
      "x - 5 = [-5 -4 -3 -2]\n",
      "x * 2 = [0 2 4 6]\n",
      "x / 2 = [0.  0.5 1.  1.5]\n",
      "x // 2 = [0 0 1 1]\n"
     ]
    }
   ],
   "source": [
    "# First of all, there are simple mathematical operations\n",
    "x = np.arange(4) \n",
    "print(\"x =\", x) \n",
    "print(\"x + 5 =\", x + 5) \n",
    "print(\"x - 5 =\", x - 5) \n",
    "print(\"x * 2 =\", x * 2) \n",
    "print(\"x / 2 =\", x / 2) \n",
    "print(\"x // 2 =\", x // 2) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "gOhq-mtQR_Rk"
   },
   "source": [
    "或者，你也可以在 Numpy 数组上调用函数，甚至在 Python 列表上调用函数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 68
    },
    "colab_type": "code",
    "id": "xYL_PAT5SBNg",
    "outputId": "1c7de189-e9de-4a8b-ffdd-8f4881bb58f2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Absolute value: [6 3 2 5]\n",
      "Exponential: [2.47875218e-03 4.97870684e-02 7.38905610e+00 1.48413159e+02]\n",
      "Logarithm: [1.79175947 1.09861229 0.69314718 1.60943791]\n"
     ]
    }
   ],
   "source": [
    "x = [-6, -3, 2, 5]\n",
    "print(\"Absolute value:\", np.abs(x) )\n",
    "print(\"Exponential:\", np.exp(x) )\n",
    "print(\"Logarithm:\", np.log(np.abs(x) )) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "r_HOMXA0SK7B"
   },
   "source": [
    "你还可以在数组上执行布尔运算："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 85
    },
    "colab_type": "code",
    "id": "z5PuqE6-SNaO",
    "outputId": "43c29e4f-4a3b-4389-bc71-7f1def033eb4"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ True,  True, False,  True],\n",
       "       [ True, False, False, False],\n",
       "       [False, False, False, False],\n",
       "       [False,  True, False, False]])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.random.rand(4,4) \n",
    "x > 0.7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "XG99GF20SQTb"
   },
   "source": [
    "Numpy 有在它的数组上对这些数据的求和函数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "lgbTOOL4SSeK",
    "outputId": "8817aecd-3f69-4675-ea87-34cda2928a45"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.698357490059848"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = np.random.random(10) \n",
    "np.sum(L) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "g6gzsAFDSWYn"
   },
   "source": [
    "**3.2. 使用 Matplotlib 处理数据**\n",
    "\n",
    "创建 Matplotlib 是为了直接从 Python 生成图形。在本节中，我们将重点放在使用 Matplotlib 作为 Jupyter notebook 中的可视化工具。\n",
    "\n",
    "要开始这个过程，我们设置工作区："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "YEWMt8RPSZY2"
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "plt.style.use('seaborn-whitegrid') \n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "zezABqrkScrf"
   },
   "source": [
    "让我们首先检查一个简单的案例，绘制一个 `sin` 函数的曲线："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 265
    },
    "colab_type": "code",
    "id": "uccZjDF_Seo4",
    "outputId": "0486a3bf-3ecf-4967-b9e1-d23747ba82b8"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure() \n",
    "ax = plt.axes() \n",
    "x = np.linspace(0, 10, 1000) \n",
    "ax.plot(x, np.sin(x) );"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "7IqEfDb4Si5P"
   },
   "source": [
    "`fig` 变量是指包含所有项目（轴，标签，数据等）的容器。轴与上面显示的方形匹配，然后将包含图形中的数据。\n",
    "\n",
    "在离散数据集（点）的情况下，我们经常使用误差线来表示每个点的不确定性，以确定其准确值："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 265
    },
    "colab_type": "code",
    "id": "09iO8hbDSluo",
    "outputId": "51ef4bbb-e7ed-40a1-92ba-42e9661951fd"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.linspace(0, 30, 80) \n",
    "dy = 0.3\n",
    "y = np.sin(x) + dy * np.random.randn(80) \n",
    "\n",
    "plt.errorbar(x, y, yerr=dy, fmt='.k') ;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "P5RZ30ScSoWM"
   },
   "source": [
    "### 4.   使用 Pandas 库处理大量数据\n",
    "\n",
    "\n",
    "Pandas 库是 Python 中数据科学的基本库之一。 Pandas 提供易于使用且功能强大的数据结构以及快速使用它们的方法。在本节中，我们将讨论 Pandas 库感兴趣的内容，以及该库主要对象的基本操作 `Dataframe`.\n",
    "\n",
    "这个 pandas 可以用 numpy 数组表示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "1tzoSgueSrA6",
    "outputId": "ae0af486-a14d-42f7-fd5e-e214dd21d8e1"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([200,  50, 100,  80])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "panda_numpy = np.array([200,50,100,80]) \n",
    "panda_numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "h92pbZcLSuFS"
   },
   "source": [
    "可以这样做："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "BjkfVMrsSwCx"
   },
   "outputs": [],
   "source": [
    "family = [\n",
    "    np.array([100, 5, 20, 80]) , # mom \n",
    "    np.array([50, 2.5, 10, 40]) , # baby \n",
    "    np.array([110, 6, 22, 80]) , # daddy \n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ftbgk7TbSz1O"
   },
   "source": [
    "让我们使用 Pandas 表示 `family`："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 142
    },
    "colab_type": "code",
    "id": "pJDW2v14S1vd",
    "outputId": "67323e32-7806-4625-ea54-59d5a16a057c"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>100.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>20.0</td>\n",
       "      <td>80.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>50.0</td>\n",
       "      <td>2.5</td>\n",
       "      <td>10.0</td>\n",
       "      <td>40.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>110.0</td>\n",
       "      <td>6.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>80.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       0    1     2     3\n",
       "0  100.0  5.0  20.0  80.0\n",
       "1   50.0  2.5  10.0  40.0\n",
       "2  110.0  6.0  22.0  80.0"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "family_df = pd.DataFrame(family) \n",
    "family_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "WBTvQb0ES7mN"
   },
   "source": [
    "可用于表示数组的对象是 `DataFrame` 对象\n",
    "\n",
    "实际上，通过指定列名和行名，我们可以做得更好："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 142
    },
    "colab_type": "code",
    "id": "wNwohKggS-ha",
    "outputId": "4b09b61d-8f2b-4b49-b7f0-19455fb7db4d"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>legs</th>\n",
       "      <th>hair</th>\n",
       "      <th>hands</th>\n",
       "      <th>belly</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>mom</th>\n",
       "      <td>100.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>20.0</td>\n",
       "      <td>80.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>baby</th>\n",
       "      <td>50.0</td>\n",
       "      <td>2.5</td>\n",
       "      <td>10.0</td>\n",
       "      <td>40.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>dad</th>\n",
       "      <td>110.0</td>\n",
       "      <td>6.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>80.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       legs  hair  hands  belly\n",
       "mom   100.0   5.0   20.0   80.0\n",
       "baby   50.0   2.5   10.0   40.0\n",
       "dad   110.0   6.0   22.0   80.0"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "family_df = pd.DataFrame(family,\n",
    "                                index = ['mom','baby','dad'],\n",
    "                                columns = ['legs','hair','hands','belly']) \n",
    "family_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "VINRsHjhTMAU"
   },
   "source": [
    "以下是 Dataframes 的一些小功能。首先，访问我们数组的 belly 列。有两种可能的语法，它们返回完全相同的结果："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 85
    },
    "colab_type": "code",
    "id": "NhtOaX-CTOOv",
    "outputId": "39ccf429-5fb3-497a-ab6b-54f46788b760"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "mom     80.0\n",
       "baby    40.0\n",
       "dad     80.0\n",
       "Name: belly, dtype: float64"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "family_df.belly\n",
    "family_df[\"belly\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "_fBmFYgMTREr"
   },
   "source": [
    "我们现在将逐个看到整个系列，通过 `iterrows` 返回一个元组作为其第一个元素的元组索引和行的内容："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 323
    },
    "colab_type": "code",
    "id": "Z9BIOR9WTTkH",
    "outputId": "b75f5bde-5f08-463b-8e6b-c003676d0249",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Family:  mom :\n",
      "legs     100.0\n",
      "hair       5.0\n",
      "hands     20.0\n",
      "belly     80.0\n",
      "Name: mom, dtype: float64\n",
      "Family:  baby :\n",
      "legs     50.0\n",
      "hair      2.5\n",
      "hands    10.0\n",
      "belly    40.0\n",
      "Name: baby, dtype: float64\n",
      "Family:  dad :\n",
      "legs     110.0\n",
      "hair       6.0\n",
      "hands     22.0\n",
      "belly     80.0\n",
      "Name: dad, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "for ind, content in family_df.iterrows() :\n",
    "    print(\"Family:  %s :\" % ind) \n",
    "    print(content) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a CSV file called dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "H9eHMwNST868",
    "outputId": "e8ca042a-8ce0-4256-ebc8-8727490382fd"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting dataset.csv\n"
     ]
    }
   ],
   "source": [
    "%%writefile dataset.csv\n",
    "\n",
    "John,Doe,120 jefferson st.,Riverside, NJ, 08075\n",
    "Jack,McGinnis,220 hobo Av.,Phila, PA,09119\n",
    "\"John \"\"Da Man\"\"\",Repici,120 Jefferson St.,Riverside, NJ,08075\n",
    "Stephen,Tyler,\"7452 Terrace \"\"At the Plaza\"\" road\",SomeTown,SD, 91234\n",
    ",Blankman,,SomeTown, SD, 00298\n",
    "\"Joan \"\"the bone\"\", Anne\",Jet,\"9th, at Terrace plc\",Desert City,CO,00123"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ntXXjrp9TXA_"
   },
   "source": [
    "Pandas 库是指向数组操作的指针。因此，可以使用 Pandas 读取 CSV 文件：从 CSV 创建数据框只需要一行："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "rVirXOQdTZPy"
   },
   "outputs": [],
   "source": [
    "data = pd.read_csv(\"dataset.csv\", sep=\";\") "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "mbop7pxoTjGa"
   },
   "source": [
    "* `data` 变量现在包含一个包含 csv 文件数据的数据帧；\n",
    "* 我们的CSV文件中的值由符号分隔 `;` ；\n",
    "* 默认情况下， `pd.read_csv` 期望以逗号分隔的值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>John,Doe,120 jefferson st.,Riverside, NJ, 08075</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Jack,McGinnis,220 hobo Av.,Phila, PA,09119</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>John \"Da Man\",Repici,120 Jefferson St.,Riversi...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Stephen,Tyler,\"7452 Terrace \"\"At the Plaza\"\" r...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>,Blankman,,SomeTown, SD, 00298</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Joan \"the bone\", Anne,Jet,\"9th, at Terrace plc...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     John,Doe,120 jefferson st.,Riverside, NJ, 08075\n",
       "0         Jack,McGinnis,220 hobo Av.,Phila, PA,09119\n",
       "1  John \"Da Man\",Repici,120 Jefferson St.,Riversi...\n",
       "2  Stephen,Tyler,\"7452 Terrace \"\"At the Plaza\"\" r...\n",
       "3                     ,Blankman,,SomeTown, SD, 00298\n",
       "4  Joan \"the bone\", Anne,Jet,\"9th, at Terrace plc..."
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "PythonDataScience",
   "provenance": [],
   "toc_visible": true,
   "version": "0.3.2"
  },
  "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}