Book1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numpy(不包含附录A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### numpy有几个随机函数，np.random.randn, np.random.rand \n",
    "website:https://blog.csdn.net/mengenqing/article/details/80615668"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.72734335, -0.31369605, -0.33075275],\n",
       "       [-0.03462178, -0.94307661,  2.48976625]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Numpy最重要的一个特点就是其N维数组对象(即ndarray)\n",
    "data = np.random.randn(2,3)             #返回一个或一组服从标准正态分布的随机样本值\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 3) float64\n"
     ]
    }
   ],
   "source": [
    "# ndarray是一个通用的同构数据多维容器，即所有元素同类型。每个数组都有shape，dtype\n",
    "print(data.shape, data.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-10.96140325,  -2.15916436,   0.40272461],\n",
       "       [ 10.70931062,  -4.55041935,   5.28033085]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data * 10 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-2.19228065, -0.43183287,  0.08054492],\n",
       "       [ 2.14186212, -0.91008387,  1.05606617]])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data + data "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 建议用 import numpy as np, 而不是 from numpy import * ，因为numpy命名空间大，\n",
    "# 很多函数与python内置函数相同"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 列表、Numpy数组与矩阵的理解  对于ndarray 和 matrix的选择，官方建议使用ndarray\n",
    "参考链接:https://blog.csdn.net/wyl1813240346/article/details/79806207\n",
    "http://blog.nex3z.com/2017/07/23/numpy-%E4%B8%AD-ndarray-%E5%92%8C-matrix-%E7%9A%84%E5%8C%BA%E5%88%AB/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[1, 2],\n",
       "        [3, 4]])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# matrix只能是二维\n",
    "a = np.mat([[1,2],[3,4]])\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[5, 6],\n",
       "        [7, 8]])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = np.mat('5 6;7 8')\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#尝试生成多于二维，会报错\n",
    "#c = np.mat([[[1,2],[3,4],[5,6]]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ndarray可以是n维\n",
    "x = np.array([[1,2],[3,4]])\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[5, 6],\n",
       "       [7, 8]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = np.array([[5,6],[7,8]])\n",
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[1, 2],\n",
       "        [3, 4]],\n",
       "\n",
       "       [[5, 6],\n",
       "        [7, 8]]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 可以生成任意维度数\n",
    "z = np.array([[[1,2],[3,4]],[[5,6],[7,8]]])\n",
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 2, 2)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[1, 2],\n",
       "        [3, 4]])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[5, 6],\n",
       "        [7, 8]])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[19, 22],\n",
       "        [43, 50]])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 矩阵乘法\n",
    "a * b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[19, 22],\n",
       "        [43, 50]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(a, b)       #numpy数组的矩阵乘积操作"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 5, 12],\n",
       "        [21, 32]])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.multiply(a, b)   #矩阵使用multiply实现点乘，对应位置乘积"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[5, 6],\n",
       "       [7, 8]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5, 12],\n",
       "       [21, 32]])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x * y    #ndarray 使用 * 或 multiply()方法计算数量积"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5, 12],\n",
       "       [21, 32]])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.multiply(x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[19, 22],\n",
       "       [43, 50]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.dot(y)  #使用np.dot(x,y) 或者 ndarray的dot() 或者 @方法计算矢量积"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[19, 22],\n",
       "       [43, 50]])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[19, 22],\n",
       "       [43, 50]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x @ y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[1, 2],\n",
       "        [3, 4]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 转换 从matrix到ndarray\n",
    "d = a.A                               #可以使用matrix的A属性或者NumPy的\n",
    "                                      #asarray()方法进行转换\n",
    "type(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "e = np.asarray(a)\n",
    "type(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "e"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.matrix"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z = np.asmatrix(x)                      #使用numpy的asmatrix()将ndarray转换为matrix\n",
    "type(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[1, 2],\n",
       "        [3, 4]])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 上面的转换方法不会复制数据，如果修改原始matrix(a),\n",
    "### 则会反映到转换后的ndarray(即d、e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 这里有一个小差别！"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[1, 2],\n",
       "        [3, 4]])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 2)"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[1, 2]])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[0][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[1, 2]])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d[0][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3, 4],\n",
       "       [5, 6, 7, 8]])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#创建ndarray\n",
    "\n",
    "#方法1:使用array函数\n",
    "data1 = [[1,2,3,4],[5,6,7,8]]\n",
    "arr1 = np.array(data1)\n",
    "print(type(data1))\n",
    "arr1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "(2, 4)\n"
     ]
    }
   ],
   "source": [
    "print(arr1.ndim)\n",
    "print(arr1.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#方法2：使用Numpy的zeros,ones,empty这些方法创建多维数组，只需传入一个表示形状的元组即可\n",
    "np.zeros(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros((3, 6))                #全0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones((3,6))                  #全1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[0., 0.],\n",
       "        [0., 0.],\n",
       "        [0., 0.]],\n",
       "\n",
       "       [[0., 0.],\n",
       "        [0., 0.],\n",
       "        [0., 0.]]])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.empty((2,3,2))                #创建一个没有任何具体值的数组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 方法3: arange是python内置函数range的numpy数组版\n",
    "np.arange(15)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 总结创建numpy数组方式:array,asarray,arange,ones,ones_like,zeros,\n",
    "### zeros_like,empty,empty_like,full,full_like,eye,identity(书中有表格)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ndarray的数据类型dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "float64 int32\n",
      "float64 float64\n"
     ]
    }
   ],
   "source": [
    "# ndarray的数据类型dtype\n",
    "arr1 = np.array([1,2,3], dtype=np.float64)\n",
    "arr2 = np.array([1,2,3], dtype=np.int32)\n",
    "print(arr1.dtype, arr2.dtype)\n",
    "\n",
    "float_arr = arr2.astype(np.float64)\n",
    "print(arr1.dtype,float_arr.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 调用astype总会创建一个新的数组(数据的备份)，即使新的dtype与旧的相同"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3.7, -1.2, -2.6,  0.5, 12.9, 10.1])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.array([3.7,-1.2,-2.6,0.5,12.9,10.1])\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3, -1, -2,  0, 12, 10])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.astype(np.int32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.25, -9.6 , 42.  ])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numeric_strings = np.array(['1.25','-9.6','42'], dtype=np.string_)\n",
    "\n",
    "numeric_strings.astype(np.float64)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int_array = np.arange(10)\n",
    "calibers = np.array([22,270,357,380], dtype=np.float64)\n",
    "int_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int_array.astype(calibers.dtype)         #dtype的另一个属性"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([       233,          0, 3901692400,       2046,          1,\n",
       "                0, 4294967295, 4294967295], dtype=uint32)"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "empty_uint32 = np.empty(8, dtype='u4')    #用简洁的类型代码表示dtype\n",
    "empty_uint32"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### zip"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<zip object at 0x0000023FB575D408>\n",
      "[(1, 4), (2, 5), (3, 6)]\n"
     ]
    }
   ],
   "source": [
    "a = [1,2,3]\n",
    "b = [4,5,6]\n",
    "zipped = zip(a, b)\n",
    "print(zipped)\n",
    "print(list(zipped))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 4), (2, 5), (3, 6)]"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m = [(i,j) for i,j in zip(a, b)]\n",
    "m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "arrivals = [4.4048936802570715, 5.322676697583111, 16.064751991695644, 20.769293179216618, 23.29757871480588, 23.427538817033057, 23.581135672038535, 25.02444021233857, 28.973654362176188]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "starts = [4.4048936802570715, 9.2767466441387, 16.064751991695644, 20.79837411169798, 25.99529684102368, 30.666697923104618, 36.027795090635806, 40.80984916968291, 45.635113599754504]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(4.4048936802570715, 4.4048936802570715),\n",
       " (5.322676697583111, 9.2767466441387),\n",
       " (16.064751991695644, 16.064751991695644),\n",
       " (20.769293179216618, 20.79837411169798),\n",
       " (23.29757871480588, 25.99529684102368),\n",
       " (23.427538817033057, 30.666697923104618),\n",
       " (23.581135672038535, 36.027795090635806),\n",
       " (25.02444021233857, 40.80984916968291),\n",
       " (28.973654362176188, 45.635113599754504)]"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n = [(i, j) for i,j in zip(arrivals, starts)]\n",
    "n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numpy数组的运算\n",
    "数组很重要，因为它使你不用编写循环即可对数据执行批量运算。NumPy用户称其为矢量化（vectorization）。大小相等的数组之间的任何算术运算都会将运算应用到元素级"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 2., 3.],\n",
       "       [4., 5., 6.]])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.array([[1,2,3],[4,5,6]], dtype=np.float64)\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  4.,  9.],\n",
       "       [16., 25., 36.]])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr * arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0.],\n",
       "       [0., 0., 0.]])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr - arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.        , 0.5       , 0.33333333],\n",
       "       [0.25      , 0.2       , 0.16666667]])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 数组与标量的算术运算会将标量值传播到各个元素\n",
    "1 / arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.        , 1.41421356, 1.73205081],\n",
       "       [2.        , 2.23606798, 2.44948974]])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr ** 0.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numpy索引和切片 \n",
    "##### 数组切片是原始数组的视图，对视图任何修改会直接反映到源数组上"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.arange(10)\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 6, 7])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[5:8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4, 12, 12, 12,  8,  9])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[5:8] = 12\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([12, 12, 12])"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr_slice = arr[5:8]                       # 创建一个arr的切片\n",
    "\n",
    "arr_slice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([    0,     1,     2,     3,     4,    12, 12345,    12,     8,\n",
       "           9])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr_slice[1] = 12345\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4, 64, 64, 64,  8,  9])"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr_slice[:] = 64\n",
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Numpy设计目的是处理大数据，故视图不用直接复制来复制去，如果要一份文本。可直接copy，如 arr[5:8].copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([7, 8, 9])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr2d = np.array([[1,2,3],[4,5,6],[7,8,9]])       #高维数组索引位置上是一维数组\n",
    "arr2d[2]    #array([7,8,9])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "print(arr2d[0][2])\n",
    "print(arr2d[0,2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 1,  2,  3],\n",
       "        [ 4,  5,  6]],\n",
       "\n",
       "       [[ 7,  8,  9],\n",
       "        [10, 11, 12]]])"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr3d = np.array([[[1,2,3],[4,5,6]],[[7,8,9],[10,11,12]]])\n",
    "\n",
    "arr3d                                                   #2*2*3数组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr3d[0]     #2*3数组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[42, 42, 42],\n",
       "        [42, 42, 42]],\n",
       "\n",
       "       [[ 7,  8,  9],\n",
       "        [10, 11, 12]]])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "old_values = arr3d[0].copy()\n",
    "\n",
    "arr3d[0] = 42\n",
    "arr3d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 1,  2,  3],\n",
       "        [ 4,  5,  6]],\n",
       "\n",
       "       [[ 7,  8,  9],\n",
       "        [10, 11, 12]]])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr3d[0] = old_values\n",
    "arr3d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([7, 8, 9])"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr3d[1,0] #一维数组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([7, 8, 9])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = arr3d[1]   #两步进行，结果相同\n",
    "x[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 切片索引"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4, 64, 64, 64,  8,  9])"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  2,  3,  4, 64])"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[1:6]                  #一维数组切片"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6],\n",
       "       [7, 8, 9]])"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr2d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr2d[:2]        #沿第0轴切片，意为选取arr2d的前两"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 3],\n",
       "       [5, 6]])"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr2d[:2, 1:]     #沿两个轴"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 5])"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr2d[1, :2]       #整数索引和切片混合"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 6])"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr2d[:2, 2]        #整数索引和切片混合"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1],\n",
       "       [4],\n",
       "       [7]])"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr2d[:, :1]         #‘只有冒号’表示选取整个轴"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6],\n",
       "       [7, 8, 9]])"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr2d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 0, 0],\n",
       "       [4, 0, 0],\n",
       "       [7, 8, 9]])"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr2d[:2, 1:] = 0     #对切片表达式的赋值操作扩散到整个选区\n",
    "\n",
    "arr2d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 布尔型索引"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'], dtype='<U4')"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names = np.array(['Bob','Joe','Will','Bob','Will','Joe','Joe'])\n",
    "names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.87577733,  0.88790129, -1.02970491,  0.17791586],\n",
       "       [-0.05129299, -0.85989812,  0.20101601, -0.11632506],\n",
       "       [-0.22698501, -0.28376242,  0.69489344, -1.25013218],\n",
       "       [-0.014047  ,  0.5959857 ,  1.17693856, -1.00752617],\n",
       "       [-0.62579615,  0.56864145,  0.16940054, -0.17097638],\n",
       "       [-0.53047362,  0.58766355,  0.1670565 , -0.33286479],\n",
       "       [-0.45461978, -0.43768097, -0.43623719,  0.08717927]])"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = np.random.randn(7, 4)     #numpy.random中的randn函数生成一些正态分布的随机数据\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True, False, False,  True, False, False, False])"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names == 'Bob'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.87577733,  0.88790129, -1.02970491,  0.17791586],\n",
       "       [-0.014047  ,  0.5959857 ,  1.17693856, -1.00752617]])"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[names == 'Bob']   #如果布尔型数组的长度与被索引的轴长度不一致，布尔型选择就会出错"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.77030376, -0.82473748],\n",
       "       [-0.69731885,  0.59912687]])"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[names == 'Bob', 2:]  #布尔型数组与切片、整数、整数序列混合使用"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.17791586, -1.00752617])"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[names == 'Bob', 3] #选取行，并索引列"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False,  True,  True, False,  True,  True,  True])"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 选取除'Bob'以外的其他值，既可以使用不等于(！=)，也可以通过~对条件进行否定\n",
    "names != 'Bob'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False,  True,  True, False,  True,  True,  True])"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "~(names == 'Bob')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.05129299, -0.85989812,  0.20101601, -0.11632506],\n",
       "       [-0.22698501, -0.28376242,  0.69489344, -1.25013218],\n",
       "       [-0.62579615,  0.56864145,  0.16940054, -0.17097638],\n",
       "       [-0.53047362,  0.58766355,  0.1670565 , -0.33286479],\n",
       "       [-0.45461978, -0.43768097, -0.43623719,  0.08717927]])"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[~(names == 'Bob')]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.05129299, -0.85989812,  0.20101601, -0.11632506],\n",
       "       [-0.22698501, -0.28376242,  0.69489344, -1.25013218],\n",
       "       [-0.62579615,  0.56864145,  0.16940054, -0.17097638],\n",
       "       [-0.53047362,  0.58766355,  0.1670565 , -0.33286479],\n",
       "       [-0.45461978, -0.43768097, -0.43623719,  0.08717927]])"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[names != 'Bob']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.05129299, -0.85989812,  0.20101601, -0.11632506],\n",
       "       [-0.22698501, -0.28376242,  0.69489344, -1.25013218],\n",
       "       [-0.62579615,  0.56864145,  0.16940054, -0.17097638],\n",
       "       [-0.53047362,  0.58766355,  0.1670565 , -0.33286479],\n",
       "       [-0.45461978, -0.43768097, -0.43623719,  0.08717927]])"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cond = names == 'Bob'      #可以像该步以及下一步一样简写，用变量名替换\n",
    "data[~cond]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True, False,  True,  True,  True, False, False])"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mask = (names == 'Bob') | (names == 'Will')  #组合应用多个布尔条件，使用&(和)，|(或)之类即可\n",
    "\n",
    "mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.87577733,  0.88790129, -1.02970491,  0.17791586],\n",
       "       [-0.22698501, -0.28376242,  0.69489344, -1.25013218],\n",
       "       [-0.014047  ,  0.5959857 ,  1.17693856, -1.00752617],\n",
       "       [-0.62579615,  0.56864145,  0.16940054, -0.17097638]])"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[mask]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.87577733,  0.88790129, -1.02970491,  0.17791586],\n",
       "       [-0.05129299, -0.85989812,  0.20101601, -0.11632506],\n",
       "       [-0.22698501, -0.28376242,  0.69489344, -1.25013218],\n",
       "       [-0.014047  ,  0.5959857 ,  1.17693856, -1.00752617],\n",
       "       [-0.62579615,  0.56864145,  0.16940054, -0.17097638],\n",
       "       [-0.53047362,  0.58766355,  0.1670565 , -0.33286479],\n",
       "       [-0.45461978, -0.43768097, -0.43623719,  0.08717927]])"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.        , 0.88790129, 0.        , 0.17791586],\n",
       "       [0.        , 0.        , 0.20101601, 0.        ],\n",
       "       [0.        , 0.        , 0.69489344, 0.        ],\n",
       "       [0.        , 0.5959857 , 1.17693856, 0.        ],\n",
       "       [0.        , 0.56864145, 0.16940054, 0.        ],\n",
       "       [0.        , 0.58766355, 0.1670565 , 0.        ],\n",
       "       [0.        , 0.        , 0.        , 0.08717927]])"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[data < 0] = 0\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[7.        , 7.        , 7.        , 7.        ],\n",
       "       [0.        , 0.        , 0.20101601, 0.        ],\n",
       "       [7.        , 7.        , 7.        , 7.        ],\n",
       "       [7.        , 7.        , 7.        , 7.        ],\n",
       "       [7.        , 7.        , 7.        , 7.        ],\n",
       "       [0.        , 0.58766355, 0.1670565 , 0.        ],\n",
       "       [0.        , 0.        , 0.        , 0.08717927]])"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[names != 'Joe'] = 7             #通过一维布尔数组设置整行或列的值\n",
    "data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 花式索引(Fancy indexing)，指利用整数数组进行索引\n",
    "#### 无论数组多少维，花式索引总是一维的\n",
    "#### 花式索引跟切片不一样，总是将数据复制到新数组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0.],\n",
       "       [1., 1., 1., 1.],\n",
       "       [2., 2., 2., 2.],\n",
       "       [3., 3., 3., 3.],\n",
       "       [4., 4., 4., 4.],\n",
       "       [5., 5., 5., 5.],\n",
       "       [6., 6., 6., 6.],\n",
       "       [7., 7., 7., 7.]])"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.empty((8,4))\n",
    "for i in range(8):\n",
    "    arr[i] = i\n",
    "    \n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4., 4., 4., 4.],\n",
       "       [3., 3., 3., 3.],\n",
       "       [0., 0., 0., 0.],\n",
       "       [6., 6., 6., 6.]])"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[[4,3,0,6]]     #一特定顺序选取，传入整数列表或ndarray即可"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[5., 5., 5., 5.],\n",
       "       [3., 3., 3., 3.],\n",
       "       [1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[[-3, -5, -7]]    #使用负数索引"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "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",
       "       [24, 25, 26, 27],\n",
       "       [28, 29, 30, 31]])"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.arange(32).reshape((8,4))\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 4,  5,  6,  7],\n",
       "       [20, 21, 22, 23],\n",
       "       [28, 29, 30, 31],\n",
       "       [ 8,  9, 10, 11]])"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[[1,5,7,2]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 4, 23, 29, 10])"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[[1,5,7,2],[0,3,1,2]]     #传入多个索引数组，最终的元素是(1,0),(5,3),(7,1),(2,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 4,  7,  5,  6],\n",
       "       [20, 23, 21, 22],\n",
       "       [28, 31, 29, 30],\n",
       "       [ 8, 11,  9, 10]])"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[[1,5,7,2]][:,[0,3,1,2]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 数组转置和轴对换\n",
    "#### 转置是重塑的一种特殊形式，它返回的是源数据的视图(不会进行任何复制操作)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4],\n",
       "       [ 5,  6,  7,  8,  9],\n",
       "       [10, 11, 12, 13, 14]])"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.arange(15).reshape((3, 5))\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  5, 10],\n",
       "       [ 1,  6, 11],\n",
       "       [ 2,  7, 12],\n",
       "       [ 3,  8, 13],\n",
       "       [ 4,  9, 14]])"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.T                      #两种转置方式，1. transpose // 2. .T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  5, 10],\n",
       "       [ 1,  6, 11],\n",
       "       [ 2,  7, 12],\n",
       "       [ 3,  8, 13],\n",
       "       [ 4,  9, 14]])"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.transpose()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-2.08057276, -0.63528466,  0.69745071],\n",
       "       [-0.85196628,  0.13037915,  1.36271177],\n",
       "       [-0.27844153, -0.99202153,  0.86818405],\n",
       "       [ 0.23888233,  1.47474323, -1.82361118],\n",
       "       [ 0.81214011,  0.46240596, -0.87122223],\n",
       "       [ 0.13613499, -0.97863477, -0.62305615]])"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.random.randn(6, 3)\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4.66448395, 2.30881133, 3.86849282],\n",
       "       [2.30881133, 9.00203489, 3.2199672 ],\n",
       "       [3.86849282, 3.2199672 , 4.62561489]])"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(arr.T, arr)                            #进行矩阵计算时，经常用np.dot计算矩阵内积"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 三维矩阵转置不太会，此例为第一个轴换成了第二个，第二个换成了第一个，最后一个不变"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  1,  2,  3],\n",
       "        [ 4,  5,  6,  7]],\n",
       "\n",
       "       [[ 8,  9, 10, 11],\n",
       "        [12, 13, 14, 15]]])"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.arange(16).reshape((2,2,4))\n",
    "\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  1,  2,  3],\n",
       "        [ 8,  9, 10, 11]],\n",
       "\n",
       "       [[ 4,  5,  6,  7],\n",
       "        [12, 13, 14, 15]]])"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.transpose((1,0,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  1,  2,  3],\n",
       "        [ 4,  5,  6,  7]],\n",
       "\n",
       "       [[ 8,  9, 10, 11],\n",
       "        [12, 13, 14, 15]]])"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  4],\n",
       "        [ 1,  5],\n",
       "        [ 2,  6],\n",
       "        [ 3,  7]],\n",
       "\n",
       "       [[ 8, 12],\n",
       "        [ 9, 13],\n",
       "        [10, 14],\n",
       "        [11, 15]]])"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.swapaxes(1, 2)           #ndarray有一个swapaxes方法，需要接受一对轴编号，不进行复制操作，交换矩阵的轴，旋转维度"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 三维数组转置研究，参考链接https://blog.csdn.net/jin739738709/article/details/76136776"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  1,  2,  3],\n",
       "        [ 4,  5,  6,  7]],\n",
       "\n",
       "       [[ 8,  9, 10, 11],\n",
       "        [12, 13, 14, 15]]])"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr1 = np.arange(16).reshape((2,2,4))\n",
    "arr1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  1,  2,  3],\n",
       "        [ 8,  9, 10, 11]],\n",
       "\n",
       "       [[ 4,  5,  6,  7],\n",
       "        [12, 13, 14, 15]]])"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr2 = arr1.transpose((1,0,2))\n",
    "arr2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 正序(0,1,2)，转置(1,0,2).前两个轴互换位置，第三轴不变，通过结果看第一页的第二行与第二页的第一行换了位置，如何理解？索引参数表的变化和转置序的不同似乎存在某种联系\n",
    "#### 可举例：arr1[0,1,0],值为4；arr2[1,0,0],值为4.\n",
    "#### 对于arr1数组，[0,0,x]表示第一页第一行数据，当前两个参数对换之后，同一个元素的索引参数表并没变化，所以arr2的第一页第一行和arr1的第一页第一行相同；\n",
    "#### 同样，[0,1,x]表示第一页第二行数据，当前两个轴对换之后，变为[1,0,x]-->第二页第一行数据。结果即可由如上解释，以下再举几例"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  1,  2,  3],\n",
       "        [ 4,  5,  6,  7]],\n",
       "\n",
       "       [[ 8,  9, 10, 11],\n",
       "        [12, 13, 14, 15]]])"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  4],\n",
       "        [ 1,  5],\n",
       "        [ 2,  6],\n",
       "        [ 3,  7]],\n",
       "\n",
       "       [[ 8, 12],\n",
       "        [ 9, 13],\n",
       "        [10, 14],\n",
       "        [11, 15]]])"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr3 = arr1.transpose((0,2,1))\n",
    "arr3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  4],\n",
       "        [ 8, 12]],\n",
       "\n",
       "       [[ 1,  5],\n",
       "        [ 9, 13]],\n",
       "\n",
       "       [[ 2,  6],\n",
       "        [10, 14]],\n",
       "\n",
       "       [[ 3,  7],\n",
       "        [11, 15]]])"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr4 = arr1.transpose((2,0,1))\n",
    "arr4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  8],\n",
       "        [ 4, 12]],\n",
       "\n",
       "       [[ 1,  9],\n",
       "        [ 5, 13]],\n",
       "\n",
       "       [[ 2, 10],\n",
       "        [ 6, 14]],\n",
       "\n",
       "       [[ 3, 11],\n",
       "        [ 7, 15]]])"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr5 = arr1.transpose((2,1,0))\n",
    "arr5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  8],\n",
       "        [ 1,  9],\n",
       "        [ 2, 10],\n",
       "        [ 3, 11]],\n",
       "\n",
       "       [[ 4, 12],\n",
       "        [ 5, 13],\n",
       "        [ 6, 14],\n",
       "        [ 7, 15]]])"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr6 = arr1.transpose((1,2,0))      #索引参数表的变化和转置序的不同似乎存在某种联系！！\n",
    "arr6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 通用函数(ufunc)是一种对ndarray中的数据执行元素级运算的函数，可以将其看做简单函数的矢量化包装器，一元ufunc-->abs,sqrt,square,exp等"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.arange(10)\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.        , 1.        , 1.41421356, 1.73205081, 2.        ,\n",
       "       2.23606798, 2.44948974, 2.64575131, 2.82842712, 3.        ])"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sqrt(arr)             #一元ufunc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.00000000e+00, 2.71828183e+00, 7.38905610e+00, 2.00855369e+01,\n",
       "       5.45981500e+01, 1.48413159e+02, 4.03428793e+02, 1.09663316e+03,\n",
       "       2.98095799e+03, 8.10308393e+03])"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.exp(arr)              #一元ufunc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2.6741559 ,  1.64064663, -0.42868043, -0.08817983,  0.02997015,\n",
       "        1.97978596,  0.3848678 ,  0.95633097])"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.random.randn(8)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.26991967, -2.01923503, -0.71523995, -0.91295581,  1.23575096,\n",
       "        0.47112532, -0.71549131,  0.73947388])"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = np.random.randn(8)\n",
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.26991967,  1.64064663, -0.42868043, -0.08817983,  1.23575096,\n",
       "        1.97978596,  0.3848678 ,  0.95633097])"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.maximum(x, y)         #计算了x和y中元素级别最大的元素,二元(binary)ufunc "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.93794126, -1.06273283,  9.25760074,  3.51383495,  0.27130574,\n",
       "        7.51357698,  3.86209921])"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.random.randn(7) * 5\n",
    "arr "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.93794126, -0.06273283,  0.25760074,  0.51383495,  0.27130574,\n",
       "        0.51357698,  0.86209921])"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "remainder, whole_part = np.modf(arr)   #modf是python内置函数divmod的矢量化版本，它返回浮点数数组的小数和整数部分\n",
    "remainder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1., -1.,  9.,  3.,  0.,  7.,  3.])"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "whole_part"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Anaconda\\lib\\site-packages\\ipykernel_launcher.py:1: RuntimeWarning: invalid value encountered in sqrt\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([1.39209959,        nan, 3.04263056, 1.87452259, 0.52087018,\n",
       "       2.74109047, 1.96522243])"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sqrt(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.93794126, -1.06273283,  9.25760074,  3.51383495,  0.27130574,\n",
       "        7.51357698,  3.86209921])"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Anaconda\\lib\\site-packages\\ipykernel_launcher.py:1: RuntimeWarning: invalid value encountered in sqrt\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([1.39209959,        nan, 3.04263056, 1.87452259, 0.52087018,\n",
       "       2.74109047, 1.96522243])"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sqrt(arr, arr)   #ufuncs接受一个out可选参数，就能在数组原地进行操作"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.39209959,        nan, 3.04263056, 1.87452259, 0.52087018,\n",
       "       2.74109047, 1.96522243])"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr                 #arr值已经得到改变"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 利用数组进行数据处理\n",
    "#### Numpy数组可以将多种数据处理任务表述为简洁的数组表达式(否则要编写循环)，\n",
    "#### 用数组代替循环的做法，通常被称为矢量化。\n",
    "#### 一般矢量化数组运算要比等价的纯python方式至少快上一两个数量级，尤其是各种数值计算。广播是针对矢量化计算的强大手段"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-5.0000000e+00, -4.9900000e+00, -4.9800000e+00, -4.9700000e+00,\n",
       "       -4.9600000e+00, -4.9500000e+00, -4.9400000e+00, -4.9300000e+00,\n",
       "       -4.9200000e+00, -4.9100000e+00, -4.9000000e+00, -4.8900000e+00,\n",
       "       -4.8800000e+00, -4.8700000e+00, -4.8600000e+00, -4.8500000e+00,\n",
       "       -4.8400000e+00, -4.8300000e+00, -4.8200000e+00, -4.8100000e+00,\n",
       "       -4.8000000e+00, -4.7900000e+00, -4.7800000e+00, -4.7700000e+00,\n",
       "       -4.7600000e+00, -4.7500000e+00, -4.7400000e+00, -4.7300000e+00,\n",
       "       -4.7200000e+00, -4.7100000e+00, -4.7000000e+00, -4.6900000e+00,\n",
       "       -4.6800000e+00, -4.6700000e+00, -4.6600000e+00, -4.6500000e+00,\n",
       "       -4.6400000e+00, -4.6300000e+00, -4.6200000e+00, -4.6100000e+00,\n",
       "       -4.6000000e+00, -4.5900000e+00, -4.5800000e+00, -4.5700000e+00,\n",
       "       -4.5600000e+00, -4.5500000e+00, -4.5400000e+00, -4.5300000e+00,\n",
       "       -4.5200000e+00, -4.5100000e+00, -4.5000000e+00, -4.4900000e+00,\n",
       "       -4.4800000e+00, -4.4700000e+00, -4.4600000e+00, -4.4500000e+00,\n",
       "       -4.4400000e+00, -4.4300000e+00, -4.4200000e+00, -4.4100000e+00,\n",
       "       -4.4000000e+00, -4.3900000e+00, -4.3800000e+00, -4.3700000e+00,\n",
       "       -4.3600000e+00, -4.3500000e+00, -4.3400000e+00, -4.3300000e+00,\n",
       "       -4.3200000e+00, -4.3100000e+00, -4.3000000e+00, -4.2900000e+00,\n",
       "       -4.2800000e+00, -4.2700000e+00, -4.2600000e+00, -4.2500000e+00,\n",
       "       -4.2400000e+00, -4.2300000e+00, -4.2200000e+00, -4.2100000e+00,\n",
       "       -4.2000000e+00, -4.1900000e+00, -4.1800000e+00, -4.1700000e+00,\n",
       "       -4.1600000e+00, -4.1500000e+00, -4.1400000e+00, -4.1300000e+00,\n",
       "       -4.1200000e+00, -4.1100000e+00, -4.1000000e+00, -4.0900000e+00,\n",
       "       -4.0800000e+00, -4.0700000e+00, -4.0600000e+00, -4.0500000e+00,\n",
       "       -4.0400000e+00, -4.0300000e+00, -4.0200000e+00, -4.0100000e+00,\n",
       "       -4.0000000e+00, -3.9900000e+00, -3.9800000e+00, -3.9700000e+00,\n",
       "       -3.9600000e+00, -3.9500000e+00, -3.9400000e+00, -3.9300000e+00,\n",
       "       -3.9200000e+00, -3.9100000e+00, -3.9000000e+00, -3.8900000e+00,\n",
       "       -3.8800000e+00, -3.8700000e+00, -3.8600000e+00, -3.8500000e+00,\n",
       "       -3.8400000e+00, -3.8300000e+00, -3.8200000e+00, -3.8100000e+00,\n",
       "       -3.8000000e+00, -3.7900000e+00, -3.7800000e+00, -3.7700000e+00,\n",
       "       -3.7600000e+00, -3.7500000e+00, -3.7400000e+00, -3.7300000e+00,\n",
       "       -3.7200000e+00, -3.7100000e+00, -3.7000000e+00, -3.6900000e+00,\n",
       "       -3.6800000e+00, -3.6700000e+00, -3.6600000e+00, -3.6500000e+00,\n",
       "       -3.6400000e+00, -3.6300000e+00, -3.6200000e+00, -3.6100000e+00,\n",
       "       -3.6000000e+00, -3.5900000e+00, -3.5800000e+00, -3.5700000e+00,\n",
       "       -3.5600000e+00, -3.5500000e+00, -3.5400000e+00, -3.5300000e+00,\n",
       "       -3.5200000e+00, -3.5100000e+00, -3.5000000e+00, -3.4900000e+00,\n",
       "       -3.4800000e+00, -3.4700000e+00, -3.4600000e+00, -3.4500000e+00,\n",
       "       -3.4400000e+00, -3.4300000e+00, -3.4200000e+00, -3.4100000e+00,\n",
       "       -3.4000000e+00, -3.3900000e+00, -3.3800000e+00, -3.3700000e+00,\n",
       "       -3.3600000e+00, -3.3500000e+00, -3.3400000e+00, -3.3300000e+00,\n",
       "       -3.3200000e+00, -3.3100000e+00, -3.3000000e+00, -3.2900000e+00,\n",
       "       -3.2800000e+00, -3.2700000e+00, -3.2600000e+00, -3.2500000e+00,\n",
       "       -3.2400000e+00, -3.2300000e+00, -3.2200000e+00, -3.2100000e+00,\n",
       "       -3.2000000e+00, -3.1900000e+00, -3.1800000e+00, -3.1700000e+00,\n",
       "       -3.1600000e+00, -3.1500000e+00, -3.1400000e+00, -3.1300000e+00,\n",
       "       -3.1200000e+00, -3.1100000e+00, -3.1000000e+00, -3.0900000e+00,\n",
       "       -3.0800000e+00, -3.0700000e+00, -3.0600000e+00, -3.0500000e+00,\n",
       "       -3.0400000e+00, -3.0300000e+00, -3.0200000e+00, -3.0100000e+00,\n",
       "       -3.0000000e+00, -2.9900000e+00, -2.9800000e+00, -2.9700000e+00,\n",
       "       -2.9600000e+00, -2.9500000e+00, -2.9400000e+00, -2.9300000e+00,\n",
       "       -2.9200000e+00, -2.9100000e+00, -2.9000000e+00, -2.8900000e+00,\n",
       "       -2.8800000e+00, -2.8700000e+00, -2.8600000e+00, -2.8500000e+00,\n",
       "       -2.8400000e+00, -2.8300000e+00, -2.8200000e+00, -2.8100000e+00,\n",
       "       -2.8000000e+00, -2.7900000e+00, -2.7800000e+00, -2.7700000e+00,\n",
       "       -2.7600000e+00, -2.7500000e+00, -2.7400000e+00, -2.7300000e+00,\n",
       "       -2.7200000e+00, -2.7100000e+00, -2.7000000e+00, -2.6900000e+00,\n",
       "       -2.6800000e+00, -2.6700000e+00, -2.6600000e+00, -2.6500000e+00,\n",
       "       -2.6400000e+00, -2.6300000e+00, -2.6200000e+00, -2.6100000e+00,\n",
       "       -2.6000000e+00, -2.5900000e+00, -2.5800000e+00, -2.5700000e+00,\n",
       "       -2.5600000e+00, -2.5500000e+00, -2.5400000e+00, -2.5300000e+00,\n",
       "       -2.5200000e+00, -2.5100000e+00, -2.5000000e+00, -2.4900000e+00,\n",
       "       -2.4800000e+00, -2.4700000e+00, -2.4600000e+00, -2.4500000e+00,\n",
       "       -2.4400000e+00, -2.4300000e+00, -2.4200000e+00, -2.4100000e+00,\n",
       "       -2.4000000e+00, -2.3900000e+00, -2.3800000e+00, -2.3700000e+00,\n",
       "       -2.3600000e+00, -2.3500000e+00, -2.3400000e+00, -2.3300000e+00,\n",
       "       -2.3200000e+00, -2.3100000e+00, -2.3000000e+00, -2.2900000e+00,\n",
       "       -2.2800000e+00, -2.2700000e+00, -2.2600000e+00, -2.2500000e+00,\n",
       "       -2.2400000e+00, -2.2300000e+00, -2.2200000e+00, -2.2100000e+00,\n",
       "       -2.2000000e+00, -2.1900000e+00, -2.1800000e+00, -2.1700000e+00,\n",
       "       -2.1600000e+00, -2.1500000e+00, -2.1400000e+00, -2.1300000e+00,\n",
       "       -2.1200000e+00, -2.1100000e+00, -2.1000000e+00, -2.0900000e+00,\n",
       "       -2.0800000e+00, -2.0700000e+00, -2.0600000e+00, -2.0500000e+00,\n",
       "       -2.0400000e+00, -2.0300000e+00, -2.0200000e+00, -2.0100000e+00,\n",
       "       -2.0000000e+00, -1.9900000e+00, -1.9800000e+00, -1.9700000e+00,\n",
       "       -1.9600000e+00, -1.9500000e+00, -1.9400000e+00, -1.9300000e+00,\n",
       "       -1.9200000e+00, -1.9100000e+00, -1.9000000e+00, -1.8900000e+00,\n",
       "       -1.8800000e+00, -1.8700000e+00, -1.8600000e+00, -1.8500000e+00,\n",
       "       -1.8400000e+00, -1.8300000e+00, -1.8200000e+00, -1.8100000e+00,\n",
       "       -1.8000000e+00, -1.7900000e+00, -1.7800000e+00, -1.7700000e+00,\n",
       "       -1.7600000e+00, -1.7500000e+00, -1.7400000e+00, -1.7300000e+00,\n",
       "       -1.7200000e+00, -1.7100000e+00, -1.7000000e+00, -1.6900000e+00,\n",
       "       -1.6800000e+00, -1.6700000e+00, -1.6600000e+00, -1.6500000e+00,\n",
       "       -1.6400000e+00, -1.6300000e+00, -1.6200000e+00, -1.6100000e+00,\n",
       "       -1.6000000e+00, -1.5900000e+00, -1.5800000e+00, -1.5700000e+00,\n",
       "       -1.5600000e+00, -1.5500000e+00, -1.5400000e+00, -1.5300000e+00,\n",
       "       -1.5200000e+00, -1.5100000e+00, -1.5000000e+00, -1.4900000e+00,\n",
       "       -1.4800000e+00, -1.4700000e+00, -1.4600000e+00, -1.4500000e+00,\n",
       "       -1.4400000e+00, -1.4300000e+00, -1.4200000e+00, -1.4100000e+00,\n",
       "       -1.4000000e+00, -1.3900000e+00, -1.3800000e+00, -1.3700000e+00,\n",
       "       -1.3600000e+00, -1.3500000e+00, -1.3400000e+00, -1.3300000e+00,\n",
       "       -1.3200000e+00, -1.3100000e+00, -1.3000000e+00, -1.2900000e+00,\n",
       "       -1.2800000e+00, -1.2700000e+00, -1.2600000e+00, -1.2500000e+00,\n",
       "       -1.2400000e+00, -1.2300000e+00, -1.2200000e+00, -1.2100000e+00,\n",
       "       -1.2000000e+00, -1.1900000e+00, -1.1800000e+00, -1.1700000e+00,\n",
       "       -1.1600000e+00, -1.1500000e+00, -1.1400000e+00, -1.1300000e+00,\n",
       "       -1.1200000e+00, -1.1100000e+00, -1.1000000e+00, -1.0900000e+00,\n",
       "       -1.0800000e+00, -1.0700000e+00, -1.0600000e+00, -1.0500000e+00,\n",
       "       -1.0400000e+00, -1.0300000e+00, -1.0200000e+00, -1.0100000e+00,\n",
       "       -1.0000000e+00, -9.9000000e-01, -9.8000000e-01, -9.7000000e-01,\n",
       "       -9.6000000e-01, -9.5000000e-01, -9.4000000e-01, -9.3000000e-01,\n",
       "       -9.2000000e-01, -9.1000000e-01, -9.0000000e-01, -8.9000000e-01,\n",
       "       -8.8000000e-01, -8.7000000e-01, -8.6000000e-01, -8.5000000e-01,\n",
       "       -8.4000000e-01, -8.3000000e-01, -8.2000000e-01, -8.1000000e-01,\n",
       "       -8.0000000e-01, -7.9000000e-01, -7.8000000e-01, -7.7000000e-01,\n",
       "       -7.6000000e-01, -7.5000000e-01, -7.4000000e-01, -7.3000000e-01,\n",
       "       -7.2000000e-01, -7.1000000e-01, -7.0000000e-01, -6.9000000e-01,\n",
       "       -6.8000000e-01, -6.7000000e-01, -6.6000000e-01, -6.5000000e-01,\n",
       "       -6.4000000e-01, -6.3000000e-01, -6.2000000e-01, -6.1000000e-01,\n",
       "       -6.0000000e-01, -5.9000000e-01, -5.8000000e-01, -5.7000000e-01,\n",
       "       -5.6000000e-01, -5.5000000e-01, -5.4000000e-01, -5.3000000e-01,\n",
       "       -5.2000000e-01, -5.1000000e-01, -5.0000000e-01, -4.9000000e-01,\n",
       "       -4.8000000e-01, -4.7000000e-01, -4.6000000e-01, -4.5000000e-01,\n",
       "       -4.4000000e-01, -4.3000000e-01, -4.2000000e-01, -4.1000000e-01,\n",
       "       -4.0000000e-01, -3.9000000e-01, -3.8000000e-01, -3.7000000e-01,\n",
       "       -3.6000000e-01, -3.5000000e-01, -3.4000000e-01, -3.3000000e-01,\n",
       "       -3.2000000e-01, -3.1000000e-01, -3.0000000e-01, -2.9000000e-01,\n",
       "       -2.8000000e-01, -2.7000000e-01, -2.6000000e-01, -2.5000000e-01,\n",
       "       -2.4000000e-01, -2.3000000e-01, -2.2000000e-01, -2.1000000e-01,\n",
       "       -2.0000000e-01, -1.9000000e-01, -1.8000000e-01, -1.7000000e-01,\n",
       "       -1.6000000e-01, -1.5000000e-01, -1.4000000e-01, -1.3000000e-01,\n",
       "       -1.2000000e-01, -1.1000000e-01, -1.0000000e-01, -9.0000000e-02,\n",
       "       -8.0000000e-02, -7.0000000e-02, -6.0000000e-02, -5.0000000e-02,\n",
       "       -4.0000000e-02, -3.0000000e-02, -2.0000000e-02, -1.0000000e-02,\n",
       "       -1.0658141e-13,  1.0000000e-02,  2.0000000e-02,  3.0000000e-02,\n",
       "        4.0000000e-02,  5.0000000e-02,  6.0000000e-02,  7.0000000e-02,\n",
       "        8.0000000e-02,  9.0000000e-02,  1.0000000e-01,  1.1000000e-01,\n",
       "        1.2000000e-01,  1.3000000e-01,  1.4000000e-01,  1.5000000e-01,\n",
       "        1.6000000e-01,  1.7000000e-01,  1.8000000e-01,  1.9000000e-01,\n",
       "        2.0000000e-01,  2.1000000e-01,  2.2000000e-01,  2.3000000e-01,\n",
       "        2.4000000e-01,  2.5000000e-01,  2.6000000e-01,  2.7000000e-01,\n",
       "        2.8000000e-01,  2.9000000e-01,  3.0000000e-01,  3.1000000e-01,\n",
       "        3.2000000e-01,  3.3000000e-01,  3.4000000e-01,  3.5000000e-01,\n",
       "        3.6000000e-01,  3.7000000e-01,  3.8000000e-01,  3.9000000e-01,\n",
       "        4.0000000e-01,  4.1000000e-01,  4.2000000e-01,  4.3000000e-01,\n",
       "        4.4000000e-01,  4.5000000e-01,  4.6000000e-01,  4.7000000e-01,\n",
       "        4.8000000e-01,  4.9000000e-01,  5.0000000e-01,  5.1000000e-01,\n",
       "        5.2000000e-01,  5.3000000e-01,  5.4000000e-01,  5.5000000e-01,\n",
       "        5.6000000e-01,  5.7000000e-01,  5.8000000e-01,  5.9000000e-01,\n",
       "        6.0000000e-01,  6.1000000e-01,  6.2000000e-01,  6.3000000e-01,\n",
       "        6.4000000e-01,  6.5000000e-01,  6.6000000e-01,  6.7000000e-01,\n",
       "        6.8000000e-01,  6.9000000e-01,  7.0000000e-01,  7.1000000e-01,\n",
       "        7.2000000e-01,  7.3000000e-01,  7.4000000e-01,  7.5000000e-01,\n",
       "        7.6000000e-01,  7.7000000e-01,  7.8000000e-01,  7.9000000e-01,\n",
       "        8.0000000e-01,  8.1000000e-01,  8.2000000e-01,  8.3000000e-01,\n",
       "        8.4000000e-01,  8.5000000e-01,  8.6000000e-01,  8.7000000e-01,\n",
       "        8.8000000e-01,  8.9000000e-01,  9.0000000e-01,  9.1000000e-01,\n",
       "        9.2000000e-01,  9.3000000e-01,  9.4000000e-01,  9.5000000e-01,\n",
       "        9.6000000e-01,  9.7000000e-01,  9.8000000e-01,  9.9000000e-01,\n",
       "        1.0000000e+00,  1.0100000e+00,  1.0200000e+00,  1.0300000e+00,\n",
       "        1.0400000e+00,  1.0500000e+00,  1.0600000e+00,  1.0700000e+00,\n",
       "        1.0800000e+00,  1.0900000e+00,  1.1000000e+00,  1.1100000e+00,\n",
       "        1.1200000e+00,  1.1300000e+00,  1.1400000e+00,  1.1500000e+00,\n",
       "        1.1600000e+00,  1.1700000e+00,  1.1800000e+00,  1.1900000e+00,\n",
       "        1.2000000e+00,  1.2100000e+00,  1.2200000e+00,  1.2300000e+00,\n",
       "        1.2400000e+00,  1.2500000e+00,  1.2600000e+00,  1.2700000e+00,\n",
       "        1.2800000e+00,  1.2900000e+00,  1.3000000e+00,  1.3100000e+00,\n",
       "        1.3200000e+00,  1.3300000e+00,  1.3400000e+00,  1.3500000e+00,\n",
       "        1.3600000e+00,  1.3700000e+00,  1.3800000e+00,  1.3900000e+00,\n",
       "        1.4000000e+00,  1.4100000e+00,  1.4200000e+00,  1.4300000e+00,\n",
       "        1.4400000e+00,  1.4500000e+00,  1.4600000e+00,  1.4700000e+00,\n",
       "        1.4800000e+00,  1.4900000e+00,  1.5000000e+00,  1.5100000e+00,\n",
       "        1.5200000e+00,  1.5300000e+00,  1.5400000e+00,  1.5500000e+00,\n",
       "        1.5600000e+00,  1.5700000e+00,  1.5800000e+00,  1.5900000e+00,\n",
       "        1.6000000e+00,  1.6100000e+00,  1.6200000e+00,  1.6300000e+00,\n",
       "        1.6400000e+00,  1.6500000e+00,  1.6600000e+00,  1.6700000e+00,\n",
       "        1.6800000e+00,  1.6900000e+00,  1.7000000e+00,  1.7100000e+00,\n",
       "        1.7200000e+00,  1.7300000e+00,  1.7400000e+00,  1.7500000e+00,\n",
       "        1.7600000e+00,  1.7700000e+00,  1.7800000e+00,  1.7900000e+00,\n",
       "        1.8000000e+00,  1.8100000e+00,  1.8200000e+00,  1.8300000e+00,\n",
       "        1.8400000e+00,  1.8500000e+00,  1.8600000e+00,  1.8700000e+00,\n",
       "        1.8800000e+00,  1.8900000e+00,  1.9000000e+00,  1.9100000e+00,\n",
       "        1.9200000e+00,  1.9300000e+00,  1.9400000e+00,  1.9500000e+00,\n",
       "        1.9600000e+00,  1.9700000e+00,  1.9800000e+00,  1.9900000e+00,\n",
       "        2.0000000e+00,  2.0100000e+00,  2.0200000e+00,  2.0300000e+00,\n",
       "        2.0400000e+00,  2.0500000e+00,  2.0600000e+00,  2.0700000e+00,\n",
       "        2.0800000e+00,  2.0900000e+00,  2.1000000e+00,  2.1100000e+00,\n",
       "        2.1200000e+00,  2.1300000e+00,  2.1400000e+00,  2.1500000e+00,\n",
       "        2.1600000e+00,  2.1700000e+00,  2.1800000e+00,  2.1900000e+00,\n",
       "        2.2000000e+00,  2.2100000e+00,  2.2200000e+00,  2.2300000e+00,\n",
       "        2.2400000e+00,  2.2500000e+00,  2.2600000e+00,  2.2700000e+00,\n",
       "        2.2800000e+00,  2.2900000e+00,  2.3000000e+00,  2.3100000e+00,\n",
       "        2.3200000e+00,  2.3300000e+00,  2.3400000e+00,  2.3500000e+00,\n",
       "        2.3600000e+00,  2.3700000e+00,  2.3800000e+00,  2.3900000e+00,\n",
       "        2.4000000e+00,  2.4100000e+00,  2.4200000e+00,  2.4300000e+00,\n",
       "        2.4400000e+00,  2.4500000e+00,  2.4600000e+00,  2.4700000e+00,\n",
       "        2.4800000e+00,  2.4900000e+00,  2.5000000e+00,  2.5100000e+00,\n",
       "        2.5200000e+00,  2.5300000e+00,  2.5400000e+00,  2.5500000e+00,\n",
       "        2.5600000e+00,  2.5700000e+00,  2.5800000e+00,  2.5900000e+00,\n",
       "        2.6000000e+00,  2.6100000e+00,  2.6200000e+00,  2.6300000e+00,\n",
       "        2.6400000e+00,  2.6500000e+00,  2.6600000e+00,  2.6700000e+00,\n",
       "        2.6800000e+00,  2.6900000e+00,  2.7000000e+00,  2.7100000e+00,\n",
       "        2.7200000e+00,  2.7300000e+00,  2.7400000e+00,  2.7500000e+00,\n",
       "        2.7600000e+00,  2.7700000e+00,  2.7800000e+00,  2.7900000e+00,\n",
       "        2.8000000e+00,  2.8100000e+00,  2.8200000e+00,  2.8300000e+00,\n",
       "        2.8400000e+00,  2.8500000e+00,  2.8600000e+00,  2.8700000e+00,\n",
       "        2.8800000e+00,  2.8900000e+00,  2.9000000e+00,  2.9100000e+00,\n",
       "        2.9200000e+00,  2.9300000e+00,  2.9400000e+00,  2.9500000e+00,\n",
       "        2.9600000e+00,  2.9700000e+00,  2.9800000e+00,  2.9900000e+00,\n",
       "        3.0000000e+00,  3.0100000e+00,  3.0200000e+00,  3.0300000e+00,\n",
       "        3.0400000e+00,  3.0500000e+00,  3.0600000e+00,  3.0700000e+00,\n",
       "        3.0800000e+00,  3.0900000e+00,  3.1000000e+00,  3.1100000e+00,\n",
       "        3.1200000e+00,  3.1300000e+00,  3.1400000e+00,  3.1500000e+00,\n",
       "        3.1600000e+00,  3.1700000e+00,  3.1800000e+00,  3.1900000e+00,\n",
       "        3.2000000e+00,  3.2100000e+00,  3.2200000e+00,  3.2300000e+00,\n",
       "        3.2400000e+00,  3.2500000e+00,  3.2600000e+00,  3.2700000e+00,\n",
       "        3.2800000e+00,  3.2900000e+00,  3.3000000e+00,  3.3100000e+00,\n",
       "        3.3200000e+00,  3.3300000e+00,  3.3400000e+00,  3.3500000e+00,\n",
       "        3.3600000e+00,  3.3700000e+00,  3.3800000e+00,  3.3900000e+00,\n",
       "        3.4000000e+00,  3.4100000e+00,  3.4200000e+00,  3.4300000e+00,\n",
       "        3.4400000e+00,  3.4500000e+00,  3.4600000e+00,  3.4700000e+00,\n",
       "        3.4800000e+00,  3.4900000e+00,  3.5000000e+00,  3.5100000e+00,\n",
       "        3.5200000e+00,  3.5300000e+00,  3.5400000e+00,  3.5500000e+00,\n",
       "        3.5600000e+00,  3.5700000e+00,  3.5800000e+00,  3.5900000e+00,\n",
       "        3.6000000e+00,  3.6100000e+00,  3.6200000e+00,  3.6300000e+00,\n",
       "        3.6400000e+00,  3.6500000e+00,  3.6600000e+00,  3.6700000e+00,\n",
       "        3.6800000e+00,  3.6900000e+00,  3.7000000e+00,  3.7100000e+00,\n",
       "        3.7200000e+00,  3.7300000e+00,  3.7400000e+00,  3.7500000e+00,\n",
       "        3.7600000e+00,  3.7700000e+00,  3.7800000e+00,  3.7900000e+00,\n",
       "        3.8000000e+00,  3.8100000e+00,  3.8200000e+00,  3.8300000e+00,\n",
       "        3.8400000e+00,  3.8500000e+00,  3.8600000e+00,  3.8700000e+00,\n",
       "        3.8800000e+00,  3.8900000e+00,  3.9000000e+00,  3.9100000e+00,\n",
       "        3.9200000e+00,  3.9300000e+00,  3.9400000e+00,  3.9500000e+00,\n",
       "        3.9600000e+00,  3.9700000e+00,  3.9800000e+00,  3.9900000e+00,\n",
       "        4.0000000e+00,  4.0100000e+00,  4.0200000e+00,  4.0300000e+00,\n",
       "        4.0400000e+00,  4.0500000e+00,  4.0600000e+00,  4.0700000e+00,\n",
       "        4.0800000e+00,  4.0900000e+00,  4.1000000e+00,  4.1100000e+00,\n",
       "        4.1200000e+00,  4.1300000e+00,  4.1400000e+00,  4.1500000e+00,\n",
       "        4.1600000e+00,  4.1700000e+00,  4.1800000e+00,  4.1900000e+00,\n",
       "        4.2000000e+00,  4.2100000e+00,  4.2200000e+00,  4.2300000e+00,\n",
       "        4.2400000e+00,  4.2500000e+00,  4.2600000e+00,  4.2700000e+00,\n",
       "        4.2800000e+00,  4.2900000e+00,  4.3000000e+00,  4.3100000e+00,\n",
       "        4.3200000e+00,  4.3300000e+00,  4.3400000e+00,  4.3500000e+00,\n",
       "        4.3600000e+00,  4.3700000e+00,  4.3800000e+00,  4.3900000e+00,\n",
       "        4.4000000e+00,  4.4100000e+00,  4.4200000e+00,  4.4300000e+00,\n",
       "        4.4400000e+00,  4.4500000e+00,  4.4600000e+00,  4.4700000e+00,\n",
       "        4.4800000e+00,  4.4900000e+00,  4.5000000e+00,  4.5100000e+00,\n",
       "        4.5200000e+00,  4.5300000e+00,  4.5400000e+00,  4.5500000e+00,\n",
       "        4.5600000e+00,  4.5700000e+00,  4.5800000e+00,  4.5900000e+00,\n",
       "        4.6000000e+00,  4.6100000e+00,  4.6200000e+00,  4.6300000e+00,\n",
       "        4.6400000e+00,  4.6500000e+00,  4.6600000e+00,  4.6700000e+00,\n",
       "        4.6800000e+00,  4.6900000e+00,  4.7000000e+00,  4.7100000e+00,\n",
       "        4.7200000e+00,  4.7300000e+00,  4.7400000e+00,  4.7500000e+00,\n",
       "        4.7600000e+00,  4.7700000e+00,  4.7800000e+00,  4.7900000e+00,\n",
       "        4.8000000e+00,  4.8100000e+00,  4.8200000e+00,  4.8300000e+00,\n",
       "        4.8400000e+00,  4.8500000e+00,  4.8600000e+00,  4.8700000e+00,\n",
       "        4.8800000e+00,  4.8900000e+00,  4.9000000e+00,  4.9100000e+00,\n",
       "        4.9200000e+00,  4.9300000e+00,  4.9400000e+00,  4.9500000e+00,\n",
       "        4.9600000e+00,  4.9700000e+00,  4.9800000e+00,  4.9900000e+00])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "points = np.arange(-5,5,0.01)\n",
    "points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-5.  , -5.  , -5.  , ..., -5.  , -5.  , -5.  ],\n",
       "       [-4.99, -4.99, -4.99, ..., -4.99, -4.99, -4.99],\n",
       "       [-4.98, -4.98, -4.98, ..., -4.98, -4.98, -4.98],\n",
       "       ...,\n",
       "       [ 4.97,  4.97,  4.97, ...,  4.97,  4.97,  4.97],\n",
       "       [ 4.98,  4.98,  4.98, ...,  4.98,  4.98,  4.98],\n",
       "       [ 4.99,  4.99,  4.99, ...,  4.99,  4.99,  4.99]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#想要在一组值(网格型)上计算函数 sqrt(x^2+y^2)\n",
    "xs, ys = np.meshgrid(points, points)         #生成网格点坐标矩阵\n",
    "ys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-5.  , -4.99, -4.98, ...,  4.97,  4.98,  4.99],\n",
       "       [-5.  , -4.99, -4.98, ...,  4.97,  4.98,  4.99],\n",
       "       [-5.  , -4.99, -4.98, ...,  4.97,  4.98,  4.99],\n",
       "       ...,\n",
       "       [-5.  , -4.99, -4.98, ...,  4.97,  4.98,  4.99],\n",
       "       [-5.  , -4.99, -4.98, ...,  4.97,  4.98,  4.99],\n",
       "       [-5.  , -4.99, -4.98, ...,  4.97,  4.98,  4.99]])"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "xs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### numpy.meshgrid()理解:如:生成3*2网格，有3个x，2个y都是数组形式，由该函数生成两个矩阵，对应点即为对应的(x,y) \n",
    "参考链接:https://blog.csdn.net/lllxxq141592654/article/details/81532855"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[7.07106781, 7.06400028, 7.05693985, ..., 7.04988652, 7.05693985,\n",
       "        7.06400028],\n",
       "       [7.06400028, 7.05692568, 7.04985815, ..., 7.04279774, 7.04985815,\n",
       "        7.05692568],\n",
       "       [7.05693985, 7.04985815, 7.04278354, ..., 7.03571603, 7.04278354,\n",
       "        7.04985815],\n",
       "       ...,\n",
       "       [7.04988652, 7.04279774, 7.03571603, ..., 7.0286414 , 7.03571603,\n",
       "        7.04279774],\n",
       "       [7.05693985, 7.04985815, 7.04278354, ..., 7.03571603, 7.04278354,\n",
       "        7.04985815],\n",
       "       [7.06400028, 7.05692568, 7.04985815, ..., 7.04279774, 7.04985815,\n",
       "        7.05692568]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z = np.sqrt(xs ** 2 + ys ** 2)       #将这个数组当做两个浮点数那样编写表达式\n",
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x171bb69b9b0>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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",
    "plt.title('Image plot of $\\sqrt{x^2 + y^2}$ for a grid of values')\n",
    "plt.imshow(z, cmap=plt.cm.gray) #plt.colorbar()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 将条件逻辑表述为数组运算 numpy.where函数是三元表达式 x if condition else y 的矢量化版本。例子如下:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [],
   "source": [
    "xarr = np.array([1.1,1.2,1.3,1.4,1.5])\n",
    "yarr = np.array([2.1,2.2,2.3,2.4,2.5])\n",
    "cond = np.array([True, False, True, True, False])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1.1, 2.2, 1.3, 1.4, 2.5]"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#我们想根据cond值选取xarr和yarr的值，当True时，选取xarr的值，否则从yarr选取\n",
    "result = [(x if c else y) for x,y,c in zip(xarr, yarr, cond)]\n",
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 以上问题 1.对大数组处理速度不够快(纯python完成)，2.无法用于多维数组，若用np.where,该功能写得非常简洁"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.1, 2.2, 1.3, 1.4, 2.5])"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result = np.where(cond, xarr, yarr)\n",
    "\n",
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 应用:np.where的第二个和第三个参数不必是数组，都可以是标量值。在数据分析工作中，where通常用于根据另一个数组而产生一个新的数组。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.74779398,  0.11820237, -1.58306519, -1.11745199],\n",
       "       [ 0.79882459, -0.25769943, -0.33154026,  0.90323136],\n",
       "       [ 0.04223746,  1.01892781,  0.76772818,  0.70794568],\n",
       "       [-0.62717128,  0.83255688,  0.40063546,  0.6814034 ]])"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#假如有一个由随机数据组成的矩阵，你希望将所有正值替换为2，负值替换为-2\n",
    "arr = np.random.randn(4, 4)\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False,  True, False, False],\n",
       "       [ True, False, False,  True],\n",
       "       [ True,  True,  True,  True],\n",
       "       [False,  True,  True,  True]])"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr > 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-2,  2, -2, -2],\n",
       "       [ 2, -2, -2,  2],\n",
       "       [ 2,  2,  2,  2],\n",
       "       [-2,  2,  2,  2]])"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.where(arr > 0, 2, -2)          #将所有正值替换为2，负值替换为-2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.74779398,  0.11820237, -1.58306519, -1.11745199],\n",
       "       [ 0.79882459, -0.25769943, -0.33154026,  0.90323136],\n",
       "       [ 0.04223746,  1.01892781,  0.76772818,  0.70794568],\n",
       "       [-0.62717128,  0.83255688,  0.40063546,  0.6814034 ]])"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.74779398,  2.        , -1.58306519, -1.11745199],\n",
       "       [ 2.        , -0.25769943, -0.33154026,  2.        ],\n",
       "       [ 2.        ,  2.        ,  2.        ,  2.        ],\n",
       "       [-0.62717128,  2.        ,  2.        ,  2.        ]])"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.where(arr > 0, 2, arr)            #将标量和数组结合起来，用常数2替换arr中的正值"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 数学和统计方法\n",
    "可以通过数组上的一组数学函数对整个数组或某个轴向的数据进行统计计算\n",
    "聚合(aggregation，约简)计算(如sum,mean,std)既可以当做数组的实例方法调用，也可以当做顶级Numpy函数使用"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.72205338,  1.34222907,  0.81369584, -0.01455959],\n",
       "       [-2.43292106, -0.53497083,  1.01951257, -1.22941312],\n",
       "       [-0.15632059, -0.69090985,  0.52822478,  0.50677066],\n",
       "       [ 0.90984159, -0.68047884, -0.25337873,  1.35285974],\n",
       "       [ 0.6943484 , -0.73622266,  0.66094779, -0.47399023]])"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.random.randn(5,4)\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.004839422896884155"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.mean()                   #数组的实例方法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.004839422896884155"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean(arr)                 #顶级Numpy函数，以下几例亦是如此"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.35482799, -0.79444811,  0.04694125,  0.33221094,  0.03627082])"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.mean(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.34142101, -0.26007062,  0.55380045,  0.02833349])"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.mean(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.41931194, -3.17779244,  0.18776499,  1.32884376,  0.1450833 ])"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.sum(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1.70710505, -1.30035311,  2.76900226,  0.14166745])"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.sum(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.09678845793768309"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.09678845793768309"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1.70710505, -1.30035311,  2.76900226,  0.14166745])"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(arr, axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  3,  6, 10, 15, 21, 28], dtype=int32)"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.array([0,1,2,3,4,5,6,7])\n",
    "arr.cumsum()                      #累加函数。返回同样大小数组，不聚合"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [3, 4, 5],\n",
       "       [6, 7, 8]])"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.array([[0,1,2],[3,4,5],[6,7,8]])\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2],\n",
       "       [ 3,  5,  7],\n",
       "       [ 9, 12, 15]], dtype=int32)"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.cumsum(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  0,   0,   0],\n",
       "       [  3,  12,  60],\n",
       "       [  6,  42, 336]], dtype=int32)"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.cumprod(axis=1)                 #累积函数，也会沿所选轴计算部分聚类"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 用于布尔型数组的方法，布尔值经常转换为1和0，sum计数，any，all也都有用"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "49"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.random.randn(100)\n",
    "(arr > 0).sum()               #使用sum计数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bools = np.array([False, False, True, False])\n",
    "bools.any()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bools.all()                    #all，any也可用于非布尔型数组，所有非0元素都会被当做True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 排序，Numpy数组跟python内置列表类型一样，可以通过sort方法排序"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.40567324,  1.64138266, -0.68458043,  0.56349489,  0.70992129,\n",
       "        0.14404585])"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.random.randn(6)\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.68458043,  0.14404585,  0.56349489,  0.70992129,  1.40567324,\n",
       "        1.64138266])"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.sort()\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.16805894, -1.4270707 ,  0.63080819],\n",
       "       [ 2.33686046,  0.37204896,  0.29396929],\n",
       "       [-0.22860011,  1.53511206,  1.42436268],\n",
       "       [-0.72119076, -0.86448144,  0.19733638],\n",
       "       [ 1.32648891,  0.08468509, -1.41541985]])"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.random.randn(5, 3)\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-1.4270707 ,  0.63080819,  1.16805894],\n",
       "       [ 0.29396929,  0.37204896,  2.33686046],\n",
       "       [-0.22860011,  1.42436268,  1.53511206],\n",
       "       [-0.86448144, -0.72119076,  0.19733638],\n",
       "       [-1.41541985,  0.08468509,  1.32648891]])"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.sort(1)\n",
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 就地排序会修改数组本身，计算数组分位数最简单的办法是对其进行排序，然后取特定位置的值。顶级方法np.sort返回的是数组的已排序副本。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.6738705447546762"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "large_arr = np.random.randn(1000)\n",
    "large_arr.sort()                          # 就地排序\n",
    "large_arr[int(0.05 * len(large_arr))]     # 5% quantile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.79848974,  0.73281159,  1.22796053,  1.38303283, -0.8936416 ,\n",
       "        0.15140799, -0.17086982, -0.0448712 , -2.16846283,  1.35073917])"
      ]
     },
     "execution_count": 170,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.random.randn(10)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2.16846283, -0.8936416 , -0.17086982, -0.0448712 ,  0.15140799,\n",
       "        0.73281159,  0.79848974,  1.22796053,  1.35073917,  1.38303283])"
      ]
     },
     "execution_count": 171,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sort(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.79848974,  0.73281159,  1.22796053,  1.38303283, -0.8936416 ,\n",
       "        0.15140799, -0.17086982, -0.0448712 , -2.16846283,  1.35073917])"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a                #顶级方法np.sort()返回的是数组的已排序副本"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 唯一化以及其他的集合逻辑，针对一维ndarray的集合运算np.unique，用于找出数组中的唯一值并返回已排序的结果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Bob', 'Joe', 'Will'], dtype='<U4')"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names = np.array(['Bob','Joe','Will','Bob','Will','Joe','Joe'])\n",
    "np.unique(names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4])"
      ]
     },
     "execution_count": 174,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ints = np.array([3,3,3,2,2,1,1,4,4])\n",
    "np.unique(ints)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4,)"
      ]
     },
     "execution_count": 175,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.unique(ints)    #np.unique方法\n",
    "a.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Bob', 'Joe', 'Will']"
      ]
     },
     "execution_count": 176,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(set(names))     #纯python代码"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True, False, False,  True,  True, False,  True])"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#np.in1d用于测试一个数组中的值在另一个数组中的成员资格\n",
    "values = np.array([6,0,0,3,2,5,6])\n",
    "\n",
    "np.in1d(values, [2,3,6])           #返回布尔型数组，检测[2,3,6]在前面的成员资格"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numpy能够读写磁盘上的文本数据或二进制数据,暂时不做学习"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 线性代数\n",
    "线性代数(如矩阵乘法、矩阵分解、行列式、其他方阵数学)是任何数组库的重要组成部分"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 2., 3.],\n",
       "       [4., 5., 6.]])"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array([[1,2,3],[4,5,6]], dtype=np.float64)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 6, 23],\n",
       "       [-1,  7],\n",
       "       [ 8,  9]])"
      ]
     },
     "execution_count": 179,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = np.array([[6,23],[-1,7],[8,9]])\n",
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 28.,  64.],\n",
       "       [ 67., 181.]])"
      ]
     },
     "execution_count": 180,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.dot(y)       #矩阵乘法，既是数组方法也是命名空间的函数，现在是数组方法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 28.,  64.],\n",
       "       [ 67., 181.]])"
      ]
     },
     "execution_count": 181,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(x, y)    #等价于x.dot(y),这里是numpy命名空间的函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 6., 15.])"
      ]
     },
     "execution_count": 182,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(x, np.ones(3))         #一个二维2*3数组与3*1一维数组点积运算之后会得到一个一维数组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 6., 15.])"
      ]
     },
     "execution_count": 183,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x @ np.ones(3)                #该作用也是做点积(矢量积)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.14765252,  0.83765688, -0.48115072,  2.1448262 , -1.42667063],\n",
       "       [ 0.83765688,  0.9754393 , -0.48895131,  1.85738568, -1.45443302],\n",
       "       [-0.48115072, -0.48895131,  0.61055165, -0.9519445 ,  0.91751631],\n",
       "       [ 2.1448262 ,  1.85738568, -0.9519445 ,  5.69919664, -2.85198238],\n",
       "       [-1.42667063, -1.45443302,  0.91751631, -2.85198238,  2.76677872]])"
      ]
     },
     "execution_count": 184,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from numpy.linalg import inv, qr\n",
    "\n",
    "X = np.random.randn(5,5)\n",
    "mat = X.T.dot(X)                          #表达式X.Tdot(X)计算X和它的转置X.T的点积\n",
    "inv(mat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.00000000e+00, -2.22044605e-16,  0.00000000e+00,\n",
       "         4.44089210e-16,  4.44089210e-16],\n",
       "       [-4.44089210e-16,  1.00000000e+00,  0.00000000e+00,\n",
       "        -8.88178420e-16,  8.88178420e-16],\n",
       "       [-4.44089210e-16, -4.44089210e-16,  1.00000000e+00,\n",
       "        -8.88178420e-16,  8.88178420e-16],\n",
       "       [ 0.00000000e+00, -1.11022302e-16, -1.38777878e-16,\n",
       "         1.00000000e+00,  0.00000000e+00],\n",
       "       [ 0.00000000e+00,  0.00000000e+00,  0.00000000e+00,\n",
       "         0.00000000e+00,  1.00000000e+00]])"
      ]
     },
     "execution_count": 185,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat.dot(inv(mat))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-4.29389404, -0.74871181,  0.09030506,  1.13961111, -1.55035352],\n",
       "       [ 0.        , -6.52990951,  0.18255496,  0.7583254 , -2.83137007],\n",
       "       [ 0.        ,  0.        , -3.41821651,  0.10063798,  1.3351944 ],\n",
       "       [ 0.        ,  0.        ,  0.        , -0.50106767, -0.74213634],\n",
       "       [ 0.        ,  0.        ,  0.        ,  0.        ,  0.21936224]])"
      ]
     },
     "execution_count": 186,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q , r = qr(mat)\n",
    "r"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### numpy.random模块对python内置的random进行了补充，增加了一些用于高效生成多种概率分布的样本值的函数，例子如下"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.46894968, -0.15220398,  1.23398703, -0.68109508],\n",
       "       [ 2.17831584,  0.49594536,  1.07261722,  0.46793135],\n",
       "       [-0.1841054 , -0.24769616, -1.49581333, -0.22432508],\n",
       "       [ 1.14966155, -0.29337564, -1.30918442, -1.843577  ]])"
      ]
     },
     "execution_count": 187,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "samples = np.random.normal(size=(4,4))\n",
    "samples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.49 s ± 111 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "from random import normalvariate\n",
    "\n",
    "N = 1000000\n",
    "\n",
    "%timeit samples = [normalvariate(0,1) for _ in range(N)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "54.7 ms ± 7.66 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit np.random.normal(size=N)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 以上，Python内置random模块只能一次生成一个样本值，如果需要大量样本值，numpy.random快了不止一个数量级"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 伪随机数\n",
    "我们说这些是伪随机数，都是通过算法基于随机数生成器种子，在确定性的条件下生成的。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.47143516, -1.19097569,  1.43270697, -0.3126519 , -0.72058873,\n",
       "        0.88716294,  0.85958841, -0.6365235 ,  0.01569637, -2.24268495])"
      ]
     },
     "execution_count": 190,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.seed(1234)    #np.random的数据生成函数使用了全局的随机种子\n",
    "rng = np.random.RandomState(1234)\n",
    "#想要避免就用np.random.RandomState,创建与其他隔离的随机数生成器\n",
    "rng.randn(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numpy示例 ： 随机漫步"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "#从0开始，步长为1和-1出现的概率相等\n",
    "#通过内置的random模块以纯python的方式实现1000步的随机漫步:\n",
    "\n",
    "position = 0\n",
    "walk = [position]\n",
    "steps = 1000\n",
    "for i in range(steps):\n",
    "    step = 1 if random.randint(0,1) else -1      #random模块，randint(a <= x <= b)\n",
    "    position += step\n",
    "    walk.append(position)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0xddec5f8>]"
      ]
     },
     "execution_count": 192,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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(walk[:100])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [],
   "source": [
    "#这其实是随机漫步中各步的累积和，可以用一个数组运算来实现。\n",
    "nsteps = 1000\n",
    "draws = np.random.randint(0, 2,size=nsteps)   #1000个数，一维数组  半开半闭[low,high)\n",
    "steps = np.where(draws > 0, 1, -1)          #一个充满1，-1的数组\n",
    "walk = steps.cumsum()\n",
    "#walk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-9"
      ]
     },
     "execution_count": 194,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "walk.min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "60"
      ]
     },
     "execution_count": 195,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "walk.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "297"
      ]
     },
     "execution_count": 196,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(np.abs(walk) >= 10).argmax()            #需要多久才能距离初始0点至少10步远"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 一次模拟多个随机漫步"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  1,   2,   3, ...,  46,  47,  46],\n",
       "       [  1,   0,   1, ...,  40,  41,  42],\n",
       "       [  1,   2,   3, ..., -26, -27, -28],\n",
       "       ...,\n",
       "       [  1,   0,   1, ...,  64,  65,  66],\n",
       "       [  1,   2,   1, ...,   2,   1,   0],\n",
       "       [ -1,  -2,  -3, ...,  32,  33,  34]], dtype=int32)"
      ]
     },
     "execution_count": 197,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 模拟5000个随机漫步\n",
    "nwalks = 5000\n",
    "nsteps = 1000\n",
    "draws = np.random.randint(0,2,size=(nwalks, nsteps))  #0,1   np.random.randint(半开半闭)\n",
    "steps = np.where(draws > 0, 1, -1)\n",
    "walks = steps.cumsum(1)\n",
    "walks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "122"
      ]
     },
     "execution_count": 198,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "walks.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-9"
      ]
     },
     "execution_count": 199,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "walk.min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True,  True,  True, ...,  True, False,  True])"
      ]
     },
     "execution_count": 200,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#我们计算30或-30的最小穿越时间\n",
    "hits30 = (np.abs(walks) >= 30).any(1)\n",
    "hits30"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3368"
      ]
     },
     "execution_count": 201,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hits30.sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([133, 395, 343, ..., 409, 297, 747], dtype=int64)"
      ]
     },
     "execution_count": 202,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 调用argmax在轴1上获取穿越时间\n",
    "crossing_times = (np.abs(walks[hits30]) >= 30).argmax(1)\n",
    "crossing_times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "509.99762470308787"
      ]
     },
     "execution_count": 203,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "crossing_times.mean()    #获取符合条件的平均穿越时间"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 可以尝试用其他分布方式得到漫步数据"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pandas\n",
    "pandas和其他工具如数值计算工具Numpy和Scipy，分析库statsmodels和scikit-learn，和数据处理可视化库matplotlib。pandas基于Numpy数组构建，特别是基于数组的函数和不使用for循环的数据处理"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 与Numpy不同:\n",
    "pandas是专门为处理表格和混杂数据设计；numpy更适合处理统一的数值数组数据。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from pandas import Series, DataFrame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Series\n",
    "Series是一种类似于一维数组的对象，它由一组数据(各种Numpy数据类型)以及一组与之相关的数据标签(即索引)组成"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    4\n",
       "1    7\n",
       "2   -5\n",
       "3    3\n",
       "dtype: int64"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj = pd.Series([4,7,-5,3])\n",
    "obj"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 4,  7, -5,  3], dtype=int64)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj.values                  #获取值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RangeIndex(start=0, stop=4, step=1)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj.index                    #获取索引"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "d    4\n",
       "b    7\n",
       "a   -5\n",
       "c    3\n",
       "dtype: int64"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#可以创建带有对各个数据点标记的索引\n",
    "obj2 = pd.Series([4,7,-5,3], index = ['d','b','a','c'])\n",
    "obj2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['d', 'b', 'a', 'c'], dtype='object')"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj2.index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-5"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj2['a']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "c    3\n",
       "a   -5\n",
       "d    6\n",
       "dtype: int64"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj2['d'] = 6\n",
    "\n",
    "obj2[['c','a','d']]       #索引列表"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "d    6\n",
       "b    7\n",
       "c    3\n",
       "dtype: int64"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 使用Numpy函数或类似Numpy的运算都会保留索引值\n",
    "obj2[obj2 > 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "d    12\n",
       "b    14\n",
       "a   -10\n",
       "c     6\n",
       "dtype: int64"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj2  * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "d     403.428793\n",
       "b    1096.633158\n",
       "a       0.006738\n",
       "c      20.085537\n",
       "dtype: float64"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.exp(obj2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#可以将Series看成有序字典，它是索引值到数据值的一个映射。\n",
    "'b' in obj2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'e' in obj2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Ohio      35000\n",
       "Texas     71000\n",
       "Oregon    16000\n",
       "Utah       5000\n",
       "dtype: int64"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 将一个python字典代入pd.Series,即也可以创建\n",
    "sdata = {'Ohio':35000, 'Texas':71000, 'Oregon':16000, 'Utah':5000}\n",
    "\n",
    "obj3 = pd.Series(sdata)\n",
    "obj3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "California        NaN\n",
       "Ohio          35000.0\n",
       "Oregon        16000.0\n",
       "Texas         71000.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "states = ['California', 'Ohio', 'Oregon', 'Texas']  #California不存在，即为NaN\n",
    "\n",
    "obj4 = pd.Series(sdata, index=states) #在pandas，NaN用于表示缺失或NA值\n",
    "obj4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "California     True\n",
       "Ohio          False\n",
       "Oregon        False\n",
       "Texas         False\n",
       "dtype: bool"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Pandas的isnull和notnull函数可用于检测缺失数据\n",
    "pd.isnull(obj4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "California    False\n",
       "Ohio           True\n",
       "Oregon         True\n",
       "Texas          True\n",
       "dtype: bool"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.notnull(obj4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "California     True\n",
       "Ohio          False\n",
       "Oregon        False\n",
       "Texas         False\n",
       "dtype: bool"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj4.isnull()                        #Series也有类似的实例方法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Ohio      35000\n",
       "Texas     71000\n",
       "Oregon    16000\n",
       "Utah       5000\n",
       "dtype: int64"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Series会根据运算的索引标签自动对齐数据,类似数据库join的操作\n",
    "obj3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "California        NaN\n",
       "Ohio          35000.0\n",
       "Oregon        16000.0\n",
       "Texas         71000.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "California         NaN\n",
       "Ohio           70000.0\n",
       "Oregon         32000.0\n",
       "Texas         142000.0\n",
       "Utah               NaN\n",
       "dtype: float64"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj3 + obj4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Series对象本身及其索引都有个name属性"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "state\n",
       "California        NaN\n",
       "Ohio          35000.0\n",
       "Oregon        16000.0\n",
       "Texas         71000.0\n",
       "Name: population, dtype: float64"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj4.name = 'population'\n",
    "obj4.index.name = 'state'\n",
    "\n",
    "obj4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    4\n",
       "1    7\n",
       "2   -5\n",
       "3    3\n",
       "dtype: int64"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Series的索引通过赋值方式修改\n",
    "obj"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Bob      4\n",
       "Steve    7\n",
       "Jeff    -5\n",
       "Ryan     3\n",
       "dtype: int64"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj.index = ['Bob','Steve', 'Jeff','Ryan']\n",
    "\n",
    "obj"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### DataFrame\n",
    "表格的数据结构，一组有序的列，每列可以是不同的值类型，是以一个或多个二维块存放的\n",
    "##### 但其实也可以表示为更高维度的数据(层次化索引的表格型结构)，这是高级处理功能的关键要素"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada', 'Nevada'],\n",
    "       'year': [2000,2001,2002,2001,2002,2003],\n",
    "       'pop': [1.5,1.7,3.6,2.4,2.9,3.2]}\n",
    "frame = pd.DataFrame(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "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>state</th>\n",
       "      <th>year</th>\n",
       "      <th>pop</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Ohio</td>\n",
       "      <td>2000</td>\n",
       "      <td>1.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Ohio</td>\n",
       "      <td>2001</td>\n",
       "      <td>1.7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Ohio</td>\n",
       "      <td>2002</td>\n",
       "      <td>3.6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Nevada</td>\n",
       "      <td>2001</td>\n",
       "      <td>2.4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Nevada</td>\n",
       "      <td>2002</td>\n",
       "      <td>2.9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Nevada</td>\n",
       "      <td>2003</td>\n",
       "      <td>3.2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    state  year  pop\n",
       "0    Ohio  2000  1.5\n",
       "1    Ohio  2001  1.7\n",
       "2    Ohio  2002  3.6\n",
       "3  Nevada  2001  2.4\n",
       "4  Nevada  2002  2.9\n",
       "5  Nevada  2003  3.2"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "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>state</th>\n",
       "      <th>year</th>\n",
       "      <th>pop</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Ohio</td>\n",
       "      <td>2000</td>\n",
       "      <td>1.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Ohio</td>\n",
       "      <td>2001</td>\n",
       "      <td>1.7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Ohio</td>\n",
       "      <td>2002</td>\n",
       "      <td>3.6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Nevada</td>\n",
       "      <td>2001</td>\n",
       "      <td>2.4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Nevada</td>\n",
       "      <td>2002</td>\n",
       "      <td>2.9</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    state  year  pop\n",
       "0    Ohio  2000  1.5\n",
       "1    Ohio  2001  1.7\n",
       "2    Ohio  2002  3.6\n",
       "3  Nevada  2001  2.4\n",
       "4  Nevada  2002  2.9"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#对于特别大的Dataframe, head方法会选取前五行\n",
    "frame.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "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>year</th>\n",
       "      <th>state</th>\n",
       "      <th>pop</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2000</td>\n",
       "      <td>Ohio</td>\n",
       "      <td>1.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2001</td>\n",
       "      <td>Ohio</td>\n",
       "      <td>1.7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2002</td>\n",
       "      <td>Ohio</td>\n",
       "      <td>3.6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2001</td>\n",
       "      <td>Nevada</td>\n",
       "      <td>2.4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2002</td>\n",
       "      <td>Nevada</td>\n",
       "      <td>2.9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>2003</td>\n",
       "      <td>Nevada</td>\n",
       "      <td>3.2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   year   state  pop\n",
       "0  2000    Ohio  1.5\n",
       "1  2001    Ohio  1.7\n",
       "2  2002    Ohio  3.6\n",
       "3  2001  Nevada  2.4\n",
       "4  2002  Nevada  2.9\n",
       "5  2003  Nevada  3.2"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#如果指定了列序列，则DataFrame的列就会按照特定顺序排列\n",
    "pd.DataFrame(data, columns = ['year', 'state', 'pop'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "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>year</th>\n",
       "      <th>state</th>\n",
       "      <th>pop</th>\n",
       "      <th>debt</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>one</th>\n",
       "      <td>2000</td>\n",
       "      <td>Ohio</td>\n",
       "      <td>1.5</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>two</th>\n",
       "      <td>2001</td>\n",
       "      <td>Ohio</td>\n",
       "      <td>1.7</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>three</th>\n",
       "      <td>2002</td>\n",
       "      <td>Ohio</td>\n",
       "      <td>3.6</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>four</th>\n",
       "      <td>2001</td>\n",
       "      <td>Nevada</td>\n",
       "      <td>2.4</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>five</th>\n",
       "      <td>2002</td>\n",
       "      <td>Nevada</td>\n",
       "      <td>2.9</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>six</th>\n",
       "      <td>2003</td>\n",
       "      <td>Nevada</td>\n",
       "      <td>3.2</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       year   state  pop debt\n",
       "one    2000    Ohio  1.5  NaN\n",
       "two    2001    Ohio  1.7  NaN\n",
       "three  2002    Ohio  3.6  NaN\n",
       "four   2001  Nevada  2.4  NaN\n",
       "five   2002  Nevada  2.9  NaN\n",
       "six    2003  Nevada  3.2  NaN"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 传入的列在数据中找不到，则会在结果中产生缺失值\n",
    "frame2 = pd.DataFrame(data, columns = ['year','state','pop','debt'], \n",
    "                      index=['one','two','three','four','five','six'])\n",
    "\n",
    "frame2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['year', 'state', 'pop', 'debt'], dtype='object')"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frame2.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "one        Ohio\n",
       "two        Ohio\n",
       "three      Ohio\n",
       "four     Nevada\n",
       "five     Nevada\n",
       "six      Nevada\n",
       "Name: state, dtype: object"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#类似字典标记的方式或属性的方式，可以获取一个Series\n",
    "frame2['state']                                    #用字典标记的方式获取Series"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "one      2000\n",
       "two      2001\n",
       "three    2002\n",
       "four     2001\n",
       "five     2002\n",
       "six      2003\n",
       "Name: year, dtype: int64"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frame2.year                                       #类似属性的方式获取Series"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### frame2[column]适用于任何列的名，frame2.column只有在列名是合理python变量名才适用"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "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>year</th>\n",
       "      <th>state</th>\n",
       "      <th>pop</th>\n",
       "      <th>debt</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>one</th>\n",
       "      <td>2000</td>\n",
       "      <td>Ohio</td>\n",
       "      <td>1.5</td>\n",
       "      <td>16.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>two</th>\n",
       "      <td>2001</td>\n",
       "      <td>Ohio</td>\n",
       "      <td>1.7</td>\n",
       "      <td>16.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>three</th>\n",
       "      <td>2002</td>\n",
       "      <td>Ohio</td>\n",
       "      <td>3.6</td>\n",
       "      <td>16.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>four</th>\n",
       "      <td>2001</td>\n",
       "      <td>Nevada</td>\n",
       "      <td>2.4</td>\n",
       "      <td>16.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>five</th>\n",
       "      <td>2002</td>\n",
       "      <td>Nevada</td>\n",
       "      <td>2.9</td>\n",
       "      <td>16.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>six</th>\n",
       "      <td>2003</td>\n",
       "      <td>Nevada</td>\n",
       "      <td>3.2</td>\n",
       "      <td>16.5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       year   state  pop  debt\n",
       "one    2000    Ohio  1.5  16.5\n",
       "two    2001    Ohio  1.7  16.5\n",
       "three  2002    Ohio  3.6  16.5\n",
       "four   2001  Nevada  2.4  16.5\n",
       "five   2002  Nevada  2.9  16.5\n",
       "six    2003  Nevada  3.2  16.5"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frame2['debt'] = 16.5                               #列可以通过赋值的方式进行修改\n",
    "frame2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "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>year</th>\n",
       "      <th>state</th>\n",
       "      <th>pop</th>\n",
       "      <th>debt</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>one</th>\n",
       "      <td>2000</td>\n",
       "      <td>Ohio</td>\n",
       "      <td>1.5</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>two</th>\n",
       "      <td>2001</td>\n",
       "      <td>Ohio</td>\n",
       "      <td>1.7</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>three</th>\n",
       "      <td>2002</td>\n",
       "      <td>Ohio</td>\n",
       "      <td>3.6</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>four</th>\n",
       "      <td>2001</td>\n",
       "      <td>Nevada</td>\n",
       "      <td>2.4</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>five</th>\n",
       "      <td>2002</td>\n",
       "      <td>Nevada</td>\n",
       "      <td>2.9</td>\n",
       "      <td>4.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>six</th>\n",
       "      <td>2003</td>\n",
       "      <td>Nevada</td>\n",
       "      <td>3.2</td>\n",
       "      <td>5.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       year   state  pop  debt\n",
       "one    2000    Ohio  1.5   0.0\n",
       "two    2001    Ohio  1.7   1.0\n",
       "three  2002    Ohio  3.6   2.0\n",
       "four   2001  Nevada  2.4   3.0\n",
       "five   2002  Nevada  2.9   4.0\n",
       "six    2003  Nevada  3.2   5.0"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frame2['debt'] = np.arange(6.)\n",
    "frame2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "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>year</th>\n",
       "      <th>state</th>\n",
       "      <th>pop</th>\n",
       "      <th>debt</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>one</th>\n",
       "      <td>2000</td>\n",
       "      <td>Ohio</td>\n",
       "      <td>1.5</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>two</th>\n",
       "      <td>2001</td>\n",
       "      <td>Ohio</td>\n",
       "      <td>1.7</td>\n",
       "      <td>-1.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>three</th>\n",
       "      <td>2002</td>\n",
       "      <td>Ohio</td>\n",
       "      <td>3.6</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>four</th>\n",
       "      <td>2001</td>\n",
       "      <td>Nevada</td>\n",
       "      <td>2.4</td>\n",
       "      <td>-1.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>five</th>\n",
       "      <td>2002</td>\n",
       "      <td>Nevada</td>\n",
       "      <td>2.9</td>\n",
       "      <td>-1.7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>six</th>\n",
       "      <td>2003</td>\n",
       "      <td>Nevada</td>\n",
       "      <td>3.2</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       year   state  pop  debt\n",
       "one    2000    Ohio  1.5   NaN\n",
       "two    2001    Ohio  1.7  -1.2\n",
       "three  2002    Ohio  3.6   NaN\n",
       "four   2001  Nevada  2.4  -1.5\n",
       "five   2002  Nevada  2.9  -1.7\n",
       "six    2003  Nevada  3.2   NaN"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "val = pd.Series([-1.2, -1.5, -1.7], index=['two', 'four', 'five'])   \n",
    "frame2['debt'] = val                ##将列表或数组赋值给某个列，长度会精确匹配DataFrame的索引\n",
    "frame2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "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>year</th>\n",
       "      <th>state</th>\n",
       "      <th>pop</th>\n",
       "      <th>debt</th>\n",
       "      <th>eastern</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>one</th>\n",
       "      <td>2000</td>\n",
       "      <td>Ohio</td>\n",
       "      <td>1.5</td>\n",
       "      <td>NaN</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>two</th>\n",
       "      <td>2001</td>\n",
       "      <td>Ohio</td>\n",
       "      <td>1.7</td>\n",
       "      <td>-1.2</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>three</th>\n",
       "      <td>2002</td>\n",
       "      <td>Ohio</td>\n",
       "      <td>3.6</td>\n",
       "      <td>NaN</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>four</th>\n",
       "      <td>2001</td>\n",
       "      <td>Nevada</td>\n",
       "      <td>2.4</td>\n",
       "      <td>-1.5</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>five</th>\n",
       "      <td>2002</td>\n",
       "      <td>Nevada</td>\n",
       "      <td>2.9</td>\n",
       "      <td>-1.7</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>six</th>\n",
       "      <td>2003</td>\n",
       "      <td>Nevada</td>\n",
       "      <td>3.2</td>\n",
       "      <td>NaN</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       year   state  pop  debt  eastern\n",
       "one    2000    Ohio  1.5   NaN     True\n",
       "two    2001    Ohio  1.7  -1.2     True\n",
       "three  2002    Ohio  3.6   NaN     True\n",
       "four   2001  Nevada  2.4  -1.5    False\n",
       "five   2002  Nevada  2.9  -1.7    False\n",
       "six    2003  Nevada  3.2   NaN    False"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 为不存在的列赋值会创建出一个新列\n",
    "\n",
    "frame2['eastern'] = frame2.state == 'Ohio'\n",
    "frame2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['year', 'state', 'pop', 'debt'], dtype='object')"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del frame2['eastern']    #关键字del用于删除列\n",
    "frame2.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 嵌套字典\n",
    "pop = {'Nevada': {2001: 2.4, 2002: 2.9},\n",
    "      'Ohio': {2000: 1.5, 2001: 1.7, 2002: 3.6}}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Nevada': {2001: 2.4, 2002: 2.9}, 'Ohio': {2000: 1.5, 2001: 1.7, 2002: 3.6}}"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "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>Nevada</th>\n",
       "      <th>Ohio</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2000</th>\n",
       "      <td>NaN</td>\n",
       "      <td>1.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2001</th>\n",
       "      <td>2.4</td>\n",
       "      <td>1.7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2002</th>\n",
       "      <td>2.9</td>\n",
       "      <td>3.6</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      Nevada  Ohio\n",
       "2000     NaN   1.5\n",
       "2001     2.4   1.7\n",
       "2002     2.9   3.6"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#嵌套字典传入，解释为:外层字典的键作为列，内层键作为行索引\n",
    "frame3 = pd.DataFrame(pop)\n",
    "frame3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "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>2000</th>\n",
       "      <th>2001</th>\n",
       "      <th>2002</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Nevada</th>\n",
       "      <td>NaN</td>\n",
       "      <td>2.4</td>\n",
       "      <td>2.9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Ohio</th>\n",
       "      <td>1.5</td>\n",
       "      <td>1.7</td>\n",
       "      <td>3.6</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        2000  2001  2002\n",
       "Nevada   NaN   2.4   2.9\n",
       "Ohio     1.5   1.7   3.6"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frame3.T                            #对DataFrame进行转置(交换行和列)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "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>Nevada</th>\n",
       "      <th>Ohio</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2001</th>\n",
       "      <td>2.4</td>\n",
       "      <td>1.7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2002</th>\n",
       "      <td>2.9</td>\n",
       "      <td>3.6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2003</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      Nevada  Ohio\n",
       "2001     2.4   1.7\n",
       "2002     2.9   3.6\n",
       "2003     NaN   NaN"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#明确指定索引,这步有点小问题 出错了 --> 已解决\n",
    "pd.DataFrame(frame3, index=[2001, 2002, 2003])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "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>Ohio</th>\n",
       "      <th>Nevada</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2000</th>\n",
       "      <td>1.5</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2001</th>\n",
       "      <td>1.7</td>\n",
       "      <td>2.4</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      Ohio  Nevada\n",
       "2000   1.5     NaN\n",
       "2001   1.7     2.4"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Series\n",
    "pdata = {'Ohio': frame3['Ohio'][:-1],\n",
    "        'Nevada': frame3['Nevada'][:2]}\n",
    "         \n",
    "pd.DataFrame(pdata)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "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>state</th>\n",
       "      <th>Nevada</th>\n",
       "      <th>Ohio</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>year</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2000</th>\n",
       "      <td>NaN</td>\n",
       "      <td>1.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2001</th>\n",
       "      <td>2.4</td>\n",
       "      <td>1.7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2002</th>\n",
       "      <td>2.9</td>\n",
       "      <td>3.6</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "state  Nevada  Ohio\n",
       "year               \n",
       "2000      NaN   1.5\n",
       "2001      2.4   1.7\n",
       "2002      2.9   3.6"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#设置DataFrame的index和columns的name属性\n",
    "frame3.index.name = 'year'; frame3.columns.name = 'state'\n",
    "frame3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[nan, 1.5],\n",
       "       [2.4, 1.7],\n",
       "       [2.9, 3.6]])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#values属性 也返回二维ndarray形式数据\n",
    "frame3.values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "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>year</th>\n",
       "      <th>state</th>\n",
       "      <th>pop</th>\n",
       "      <th>debt</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>one</th>\n",
       "      <td>2000</td>\n",
       "      <td>Ohio</td>\n",
       "      <td>1.5</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>two</th>\n",
       "      <td>2001</td>\n",
       "      <td>Ohio</td>\n",
       "      <td>1.7</td>\n",
       "      <td>-1.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>three</th>\n",
       "      <td>2002</td>\n",
       "      <td>Ohio</td>\n",
       "      <td>3.6</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>four</th>\n",
       "      <td>2001</td>\n",
       "      <td>Nevada</td>\n",
       "      <td>2.4</td>\n",
       "      <td>-1.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>five</th>\n",
       "      <td>2002</td>\n",
       "      <td>Nevada</td>\n",
       "      <td>2.9</td>\n",
       "      <td>-1.7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>six</th>\n",
       "      <td>2003</td>\n",
       "      <td>Nevada</td>\n",
       "      <td>3.2</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       year   state  pop  debt\n",
       "one    2000    Ohio  1.5   NaN\n",
       "two    2001    Ohio  1.7  -1.2\n",
       "three  2002    Ohio  3.6   NaN\n",
       "four   2001  Nevada  2.4  -1.5\n",
       "five   2002  Nevada  2.9  -1.7\n",
       "six    2003  Nevada  3.2   NaN"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frame2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2000, 'Ohio', 1.5, nan],\n",
       "       [2001, 'Ohio', 1.7, -1.2],\n",
       "       [2002, 'Ohio', 3.6, nan],\n",
       "       [2001, 'Nevada', 2.4, -1.5],\n",
       "       [2002, 'Nevada', 2.9, -1.7],\n",
       "       [2003, 'Nevada', 3.2, nan]], dtype=object)"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#如果DataFrame各列的数据类型不同，则最后的dtype会选用兼容所有列的数据类型\n",
    "frame2.values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 索引对象"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['a', 'b', 'c'], dtype='object')"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj = pd.Series(range(3), index=['a','b','c'])\n",
    "index = obj.index\n",
    "index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['b', 'c'], dtype='object')"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index[1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Index对象是不可变的，因此用户不能对其进行修改\n",
    "#index[1] = 'd'     #TypeError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Int64Index([0, 1, 2], dtype='int64')"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "labels = pd.Index(np.arange(3))\n",
    "labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    1.5\n",
       "1   -2.5\n",
       "2    0.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Index对象不可变使得Index对象在多个数据结构之间安全共享\n",
    "obj2 = pd.Series([1.5, -2.5, 0], index=labels)\n",
    "obj2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj2.index is labels"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 以后一些操作会生成包含被索引化的数据，理解Index的工作原理挺重要"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "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>state</th>\n",
       "      <th>Nevada</th>\n",
       "      <th>Ohio</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>year</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2000</th>\n",
       "      <td>NaN</td>\n",
       "      <td>1.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2001</th>\n",
       "      <td>2.4</td>\n",
       "      <td>1.7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2002</th>\n",
       "      <td>2.9</td>\n",
       "      <td>3.6</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "state  Nevada  Ohio\n",
       "year               \n",
       "2000      NaN   1.5\n",
       "2001      2.4   1.7\n",
       "2002      2.9   3.6"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#除了类似于数组，index功能也类似一个固定大小的集合\n",
    "frame3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['Nevada', 'Ohio'], dtype='object', name='state')"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frame3.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Ohio' in frame3.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2003 in frame3.index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['foo', 'foo', 'bar', 'bar'], dtype='object')"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#与python集合不同，pandas的Index可以包含重复的标签\n",
    "dup_labels = pd.Index(['foo', 'foo','bar','bar'])\n",
    "dup_labels   #选择重复的标签，会显示所有符合条件的结果，不举例"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 重新索引 reindex"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "d    4.5\n",
       "b    7.2\n",
       "a   -5.3\n",
       "c    3.6\n",
       "dtype: float64"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj = pd.Series([4.5, 7.2, -5.3, 3.6], index=['d','b','a','c'])\n",
    "obj"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a   -5.3\n",
       "b    7.2\n",
       "c    3.6\n",
       "d    4.5\n",
       "e    NaN\n",
       "dtype: float64"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#利用该series的reindex根据新索引进行重排\n",
    "obj2 = obj.reindex(['a', 'b', 'c', 'd', 'e'])\n",
    "obj2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0      blue\n",
       "2    purple\n",
       "4    yellow\n",
       "dtype: object"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#对于时间序列这样的有序数据，重新索引时要做插值处理，用method选项\n",
    "obj3 = pd.Series(['blue','purple','yellow'], index = [0,2,4])\n",
    "obj3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0      blue\n",
       "1      blue\n",
       "2    purple\n",
       "3    purple\n",
       "4    yellow\n",
       "5    yellow\n",
       "dtype: object"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj3.reindex(range(6), method = 'ffill')            #reomdex的method选项"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "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>Ohio</th>\n",
       "      <th>Texas</th>\n",
       "      <th>California</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>a</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>c</th>\n",
       "      <td>3</td>\n",
       "      <td>4</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>d</th>\n",
       "      <td>6</td>\n",
       "      <td>7</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Ohio  Texas  California\n",
       "a     0      1           2\n",
       "c     3      4           5\n",
       "d     6      7           8"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# reindex可以修改(行)索引和列。\n",
    "frame = pd.DataFrame(np.arange(9).reshape((3, 3)),\n",
    "                    index = ['a', 'c', 'd'],\n",
    "                    columns = ['Ohio', 'Texas', 'California'])\n",
    "frame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "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>Ohio</th>\n",
       "      <th>Texas</th>\n",
       "      <th>California</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>a</th>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>b</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>c</th>\n",
       "      <td>3.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>5.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>d</th>\n",
       "      <td>6.0</td>\n",
       "      <td>7.0</td>\n",
       "      <td>8.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Ohio  Texas  California\n",
       "a   0.0    1.0         2.0\n",
       "b   NaN    NaN         NaN\n",
       "c   3.0    4.0         5.0\n",
       "d   6.0    7.0         8.0"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frame2 = frame.reindex(['a', 'b', 'c', 'd'])      #重新索引行索引\n",
    "frame2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "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>Texas</th>\n",
       "      <th>Utah</th>\n",
       "      <th>California</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>a</th>\n",
       "      <td>1</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>c</th>\n",
       "      <td>4</td>\n",
       "      <td>NaN</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>d</th>\n",
       "      <td>7</td>\n",
       "      <td>NaN</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Texas  Utah  California\n",
       "a      1   NaN           2\n",
       "c      4   NaN           5\n",
       "d      7   NaN           8"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#用columns关键字重新索引列\n",
    "states = ['Texas', 'Utah', 'California']\n",
    "frame.reindex(columns=states)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 丢弃指定轴上的项 (pandas的series，dataframe),  drop方法返回的是一个指定轴上删除了指定值的新对象"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    0.0\n",
       "b    1.0\n",
       "c    2.0\n",
       "d    3.0\n",
       "e    4.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Series\n",
    "obj = pd.Series(np.arange(5.), index=['a','b','c','d','e'])\n",
    "obj"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    0.0\n",
       "b    1.0\n",
       "d    3.0\n",
       "e    4.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_obj = obj.drop('c')\n",
    "new_obj"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    0.0\n",
       "b    1.0\n",
       "e    4.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj.drop(['d', 'c'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "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>one</th>\n",
       "      <th>two</th>\n",
       "      <th>three</th>\n",
       "      <th>four</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Ohio</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Colorado</th>\n",
       "      <td>4</td>\n",
       "      <td>5</td>\n",
       "      <td>6</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Utah</th>\n",
       "      <td>8</td>\n",
       "      <td>9</td>\n",
       "      <td>10</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>New York</th>\n",
       "      <td>12</td>\n",
       "      <td>13</td>\n",
       "      <td>14</td>\n",
       "      <td>15</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          one  two  three  four\n",
       "Ohio        0    1      2     3\n",
       "Colorado    4    5      6     7\n",
       "Utah        8    9     10    11\n",
       "New York   12   13     14    15"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#DataFrame\n",
    "data = pd.DataFrame(np.arange(16).reshape(4,4),\n",
    "                   index = ['Ohio', 'Colorado', 'Utah','New York'],\n",
    "                   columns=['one', 'two', 'three', 'four'])\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "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>one</th>\n",
       "      <th>two</th>\n",
       "      <th>three</th>\n",
       "      <th>four</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Utah</th>\n",
       "      <td>8</td>\n",
       "      <td>9</td>\n",
       "      <td>10</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>New York</th>\n",
       "      <td>12</td>\n",
       "      <td>13</td>\n",
       "      <td>14</td>\n",
       "      <td>15</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          one  two  three  four\n",
       "Utah        8    9     10    11\n",
       "New York   12   13     14    15"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.drop(['Colorado', 'Ohio'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "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>one</th>\n",
       "      <th>three</th>\n",
       "      <th>four</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Ohio</th>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Colorado</th>\n",
       "      <td>4</td>\n",
       "      <td>6</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Utah</th>\n",
       "      <td>8</td>\n",
       "      <td>10</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>New York</th>\n",
       "      <td>12</td>\n",
       "      <td>14</td>\n",
       "      <td>15</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          one  three  four\n",
       "Ohio        0      2     3\n",
       "Colorado    4      6     7\n",
       "Utah        8     10    11\n",
       "New York   12     14    15"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#通过传递axis=1或axis='columns'可以删除列\n",
    "data.drop('two', axis=1)                 #传递axis=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "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>one</th>\n",
       "      <th>three</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Ohio</th>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Colorado</th>\n",
       "      <td>4</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Utah</th>\n",
       "      <td>8</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>New York</th>\n",
       "      <td>12</td>\n",
       "      <td>14</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          one  three\n",
       "Ohio        0      2\n",
       "Colorado    4      6\n",
       "Utah        8     10\n",
       "New York   12     14"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.drop(['two', 'four'], axis='columns')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#####  就地修改对象，不返回新的对象，inplace选项。inplace = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    0.0\n",
       "b    1.0\n",
       "d    3.0\n",
       "e    4.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj.drop('c', inplace=True)\n",
    "obj"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 索引、选取和过滤"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    0.0\n",
       "b    1.0\n",
       "c    2.0\n",
       "d    3.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj = pd.Series(np.arange(4.), index = ['a','b','c','d'])\n",
    "obj"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj['b']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "c    2.0\n",
       "d    3.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj[2:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b    1.0\n",
       "a    0.0\n",
       "d    3.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj[['b','a','d']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b    1.0\n",
       "d    3.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj[[1,3]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    0.0\n",
       "b    1.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj[obj < 2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b    1.0\n",
       "c    2.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#标签切片，末端是包含的\n",
    "obj['b':'c']                          #利用标签切片运算 末端是包含的"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    0.0\n",
       "b    5.0\n",
       "c    5.0\n",
       "d    3.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj['b':'c'] = 5\n",
    "obj"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 用一个值或序列对DataFrame进行索引其实就是获取一个或多个列"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "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>one</th>\n",
       "      <th>two</th>\n",
       "      <th>three</th>\n",
       "      <th>four</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Ohio</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Colorado</th>\n",
       "      <td>4</td>\n",
       "      <td>5</td>\n",
       "      <td>6</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Utah</th>\n",
       "      <td>8</td>\n",
       "      <td>9</td>\n",
       "      <td>10</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>New York</th>\n",
       "      <td>12</td>\n",
       "      <td>13</td>\n",
       "      <td>14</td>\n",
       "      <td>15</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          one  two  three  four\n",
       "Ohio        0    1      2     3\n",
       "Colorado    4    5      6     7\n",
       "Utah        8    9     10    11\n",
       "New York   12   13     14    15"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = pd.DataFrame(np.arange(16).reshape((4,4)),\n",
    "                    index = ['Ohio', 'Colorado', 'Utah', 'New York'],\n",
    "                    columns = ['one', 'two', 'three', 'four'])\n",
    "\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Ohio         1\n",
       "Colorado     5\n",
       "Utah         9\n",
       "New York    13\n",
       "Name: two, dtype: int32"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data['two']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "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>three</th>\n",
       "      <th>one</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Ohio</th>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Colorado</th>\n",
       "      <td>6</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Utah</th>\n",
       "      <td>10</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>New York</th>\n",
       "      <td>14</td>\n",
       "      <td>12</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          three  one\n",
       "Ohio          2    0\n",
       "Colorado      6    4\n",
       "Utah         10    8\n",
       "New York     14   12"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[['three','one']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "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>one</th>\n",
       "      <th>two</th>\n",
       "      <th>three</th>\n",
       "      <th>four</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Ohio</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Colorado</th>\n",
       "      <td>4</td>\n",
       "      <td>5</td>\n",
       "      <td>6</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          one  two  three  four\n",
       "Ohio        0    1      2     3\n",
       "Colorado    4    5      6     7"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "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>one</th>\n",
       "      <th>two</th>\n",
       "      <th>three</th>\n",
       "      <th>four</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Colorado</th>\n",
       "      <td>4</td>\n",
       "      <td>5</td>\n",
       "      <td>6</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Utah</th>\n",
       "      <td>8</td>\n",
       "      <td>9</td>\n",
       "      <td>10</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>New York</th>\n",
       "      <td>12</td>\n",
       "      <td>13</td>\n",
       "      <td>14</td>\n",
       "      <td>15</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          one  two  three  four\n",
       "Colorado    4    5      6     7\n",
       "Utah        8    9     10    11\n",
       "New York   12   13     14    15"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[data['three'] > 5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "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>one</th>\n",
       "      <th>two</th>\n",
       "      <th>three</th>\n",
       "      <th>four</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Ohio</th>\n",
       "      <td>True</td>\n",
       "      <td>True</td>\n",
       "      <td>True</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Colorado</th>\n",
       "      <td>True</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Utah</th>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>New York</th>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            one    two  three   four\n",
       "Ohio       True   True   True   True\n",
       "Colorado   True  False  False  False\n",
       "Utah      False  False  False  False\n",
       "New York  False  False  False  False"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data < 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "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>one</th>\n",
       "      <th>two</th>\n",
       "      <th>three</th>\n",
       "      <th>four</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Ohio</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Colorado</th>\n",
       "      <td>0</td>\n",
       "      <td>5</td>\n",
       "      <td>6</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Utah</th>\n",
       "      <td>8</td>\n",
       "      <td>9</td>\n",
       "      <td>10</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>New York</th>\n",
       "      <td>12</td>\n",
       "      <td>13</td>\n",
       "      <td>14</td>\n",
       "      <td>15</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          one  two  three  four\n",
       "Ohio        0    0      0     0\n",
       "Colorado    0    5      6     7\n",
       "Utah        8    9     10    11\n",
       "New York   12   13     14    15"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[data < 5] = 0\n",
    "data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 用loc和iloc进行选取，轴标签(loc)和整数索引(iloc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "two      5\n",
       "three    6\n",
       "Name: Colorado, dtype: int32"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.loc['Colorado', ['two', 'three']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "four    11\n",
       "one      8\n",
       "two      9\n",
       "Name: Utah, dtype: int32"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.iloc[2, [3,0,1]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "one       8\n",
       "two       9\n",
       "three    10\n",
       "four     11\n",
       "Name: Utah, dtype: int32"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.iloc[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "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>four</th>\n",
       "      <th>one</th>\n",
       "      <th>two</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Colorado</th>\n",
       "      <td>7</td>\n",
       "      <td>0</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Utah</th>\n",
       "      <td>11</td>\n",
       "      <td>8</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          four  one  two\n",
       "Colorado     7    0    5\n",
       "Utah        11    8    9"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.iloc[[1, 2], [3,0,1]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Ohio        0\n",
       "Colorado    5\n",
       "Utah        9\n",
       "Name: two, dtype: int32"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#这两个索引函数也适用于一个标签或多个标签的切片\n",
    "data.loc[:'Utah', 'two']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "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>one</th>\n",
       "      <th>two</th>\n",
       "      <th>three</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Ohio</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Colorado</th>\n",
       "      <td>0</td>\n",
       "      <td>5</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Utah</th>\n",
       "      <td>8</td>\n",
       "      <td>9</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>New York</th>\n",
       "      <td>12</td>\n",
       "      <td>13</td>\n",
       "      <td>14</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          one  two  three\n",
       "Ohio        0    0      0\n",
       "Colorado    0    5      6\n",
       "Utah        8    9     10\n",
       "New York   12   13     14"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.iloc[:, :3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "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>one</th>\n",
       "      <th>two</th>\n",
       "      <th>three</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Colorado</th>\n",
       "      <td>0</td>\n",
       "      <td>5</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Utah</th>\n",
       "      <td>8</td>\n",
       "      <td>9</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>New York</th>\n",
       "      <td>12</td>\n",
       "      <td>13</td>\n",
       "      <td>14</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          one  two  three\n",
       "Colorado    0    5      6\n",
       "Utah        8    9     10\n",
       "New York   12   13     14"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.iloc[:, :3][data.three > 5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 整数索引，可能会搞混，所以要用好loc，iloc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 算术运算和数据对齐。可以对不完全相同的索引对象进行算术运算，如果相加，其结果是该索引对的并集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Series结构\n",
    "\n",
    "s1 = pd.Series([7.3, -2.5, 3.4, 1.5], index=['a', 'c', 'd', 'e'])\n",
    "\n",
    "s2 = pd.Series([-2.1, 3.6, -1.5, 4, 3.1],\n",
    "              index = ['a', 'c', 'e', 'f', 'g'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    7.3\n",
       "c   -2.5\n",
       "d    3.4\n",
       "e    1.5\n",
       "dtype: float64"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a   -2.1\n",
       "c    3.6\n",
       "e   -1.5\n",
       "f    4.0\n",
       "g    3.1\n",
       "dtype: float64"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    5.2\n",
       "c    1.1\n",
       "d    NaN\n",
       "e    0.0\n",
       "f    NaN\n",
       "g    NaN\n",
       "dtype: float64"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1 + s2                        #自动的数据对齐操作在不重叠的索引处引入了NA值，缺失值会在算术运算过程中传播"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [],
   "source": [
    "#对于DataFrame，对齐操作会同时发生在行和列上\n",
    "df1 = pd.DataFrame(np.arange(9.).reshape((3, 3)), columns=list('bcd'), index=['Ohio', 'Texas', 'Colorado'])\n",
    "df2 = pd.DataFrame(np.arange(12.).reshape((4, 3)), columns=list('bde'), index=['Utah', 'Ohio', 'Texas', 'Oregon'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "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>b</th>\n",
       "      <th>c</th>\n",
       "      <th>d</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Ohio</th>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Texas</th>\n",
       "      <td>3.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>5.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Colorado</th>\n",
       "      <td>6.0</td>\n",
       "      <td>7.0</td>\n",
       "      <td>8.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            b    c    d\n",
       "Ohio      0.0  1.0  2.0\n",
       "Texas     3.0  4.0  5.0\n",
       "Colorado  6.0  7.0  8.0"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "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>b</th>\n",
       "      <th>d</th>\n",
       "      <th>e</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Utah</th>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Ohio</th>\n",
       "      <td>3.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>5.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Texas</th>\n",
       "      <td>6.0</td>\n",
       "      <td>7.0</td>\n",
       "      <td>8.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Oregon</th>\n",
       "      <td>9.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>11.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          b     d     e\n",
       "Utah    0.0   1.0   2.0\n",
       "Ohio    3.0   4.0   5.0\n",
       "Texas   6.0   7.0   8.0\n",
       "Oregon  9.0  10.0  11.0"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "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>b</th>\n",
       "      <th>c</th>\n",
       "      <th>d</th>\n",
       "      <th>e</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Colorado</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Ohio</th>\n",
       "      <td>3.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>6.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Oregon</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Texas</th>\n",
       "      <td>9.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>12.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Utah</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            b   c     d   e\n",
       "Colorado  NaN NaN   NaN NaN\n",
       "Ohio      3.0 NaN   6.0 NaN\n",
       "Oregon    NaN NaN   NaN NaN\n",
       "Texas     9.0 NaN  12.0 NaN\n",
       "Utah      NaN NaN   NaN NaN"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df1 + df2                                 #索引和列为两个DataFrame的并集，不存在的以缺失值出现"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 没有公用的行或列标签，结果如下\n",
    "df1 = pd.DataFrame({'A':[1,2]})\n",
    "df2 = pd.DataFrame({'B':[3,4]})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "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>A</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   A\n",
       "0  1\n",
       "1  2"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "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>B</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   B\n",
       "0  3\n",
       "1  4"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "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>A</th>\n",
       "      <th>B</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    A   B\n",
       "0 NaN NaN\n",
       "1 NaN NaN"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df1 - df2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 在算术方法中填充值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1 = pd.DataFrame(np.arange(12.).reshape((3,4)),\n",
    "                  columns=list('abcd'))\n",
    "df2 = pd.DataFrame(np.arange(20.).reshape((4, 5)),\n",
    "                  columns=list('abcde'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "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>a</th>\n",
       "      <th>b</th>\n",
       "      <th>c</th>\n",
       "      <th>d</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>6.0</td>\n",
       "      <td>7.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>8.0</td>\n",
       "      <td>9.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>11.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     a    b     c     d\n",
       "0  0.0  1.0   2.0   3.0\n",
       "1  4.0  5.0   6.0   7.0\n",
       "2  8.0  9.0  10.0  11.0"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "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>a</th>\n",
       "      <th>b</th>\n",
       "      <th>c</th>\n",
       "      <th>d</th>\n",
       "      <th>e</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>4.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>5.0</td>\n",
       "      <td>6.0</td>\n",
       "      <td>7.0</td>\n",
       "      <td>8.0</td>\n",
       "      <td>9.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>10.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>12.0</td>\n",
       "      <td>13.0</td>\n",
       "      <td>14.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>15.0</td>\n",
       "      <td>16.0</td>\n",
       "      <td>17.0</td>\n",
       "      <td>18.0</td>\n",
       "      <td>19.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      a     b     c     d     e\n",
       "0   0.0   1.0   2.0   3.0   4.0\n",
       "1   5.0   6.0   7.0   8.0   9.0\n",
       "2  10.0  11.0  12.0  13.0  14.0\n",
       "3  15.0  16.0  17.0  18.0  19.0"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "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>a</th>\n",
       "      <th>b</th>\n",
       "      <th>c</th>\n",
       "      <th>d</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>6.0</td>\n",
       "      <td>7.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>8.0</td>\n",
       "      <td>9.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>11.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     a    b     c     d\n",
       "0  0.0  1.0   2.0   3.0\n",
       "1  4.0  5.0   6.0   7.0\n",
       "2  8.0  9.0  10.0  11.0"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df2.loc[1, 'b'] = np.nan\n",
    "df1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "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>a</th>\n",
       "      <th>b</th>\n",
       "      <th>c</th>\n",
       "      <th>d</th>\n",
       "      <th>e</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>4.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>5.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>7.0</td>\n",
       "      <td>8.0</td>\n",
       "      <td>9.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>10.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>12.0</td>\n",
       "      <td>13.0</td>\n",
       "      <td>14.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>15.0</td>\n",
       "      <td>16.0</td>\n",
       "      <td>17.0</td>\n",
       "      <td>18.0</td>\n",
       "      <td>19.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      a     b     c     d     e\n",
       "0   0.0   1.0   2.0   3.0   4.0\n",
       "1   5.0   NaN   7.0   8.0   9.0\n",
       "2  10.0  11.0  12.0  13.0  14.0\n",
       "3  15.0  16.0  17.0  18.0  19.0"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "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>a</th>\n",
       "      <th>b</th>\n",
       "      <th>c</th>\n",
       "      <th>d</th>\n",
       "      <th>e</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>6.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>9.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>13.0</td>\n",
       "      <td>15.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>18.0</td>\n",
       "      <td>20.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>24.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      a     b     c     d   e\n",
       "0   0.0   2.0   4.0   6.0 NaN\n",
       "1   9.0   NaN  13.0  15.0 NaN\n",
       "2  18.0  20.0  22.0  24.0 NaN\n",
       "3   NaN   NaN   NaN   NaN NaN"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df1 + df2 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "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>a</th>\n",
       "      <th>b</th>\n",
       "      <th>c</th>\n",
       "      <th>d</th>\n",
       "      <th>e</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>6.0</td>\n",
       "      <td>4.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>9.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>13.0</td>\n",
       "      <td>15.0</td>\n",
       "      <td>9.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>18.0</td>\n",
       "      <td>20.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>24.0</td>\n",
       "      <td>14.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>15.0</td>\n",
       "      <td>16.0</td>\n",
       "      <td>17.0</td>\n",
       "      <td>18.0</td>\n",
       "      <td>19.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      a     b     c     d     e\n",
       "0   0.0   2.0   4.0   6.0   4.0\n",
       "1   9.0   5.0  13.0  15.0   9.0\n",
       "2  18.0  20.0  22.0  24.0  14.0\n",
       "3  15.0  16.0  17.0  18.0  19.0"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#使用df1的add方法\n",
    "df1.add(df2, fill_value=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "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>a</th>\n",
       "      <th>b</th>\n",
       "      <th>c</th>\n",
       "      <th>d</th>\n",
       "      <th>e</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>6.0</td>\n",
       "      <td>4.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>9.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>13.0</td>\n",
       "      <td>15.0</td>\n",
       "      <td>9.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>18.0</td>\n",
       "      <td>20.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>24.0</td>\n",
       "      <td>14.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>15.0</td>\n",
       "      <td>16.0</td>\n",
       "      <td>17.0</td>\n",
       "      <td>18.0</td>\n",
       "      <td>19.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      a     b     c     d     e\n",
       "0   0.0   2.0   4.0   6.0   4.0\n",
       "1   9.0   5.0  13.0  15.0   9.0\n",
       "2  18.0  20.0  22.0  24.0  14.0\n",
       "3  15.0  16.0  17.0  18.0  19.0"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df1.radd(df2, fill_value=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "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>a</th>\n",
       "      <th>b</th>\n",
       "      <th>c</th>\n",
       "      <th>d</th>\n",
       "      <th>e</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>-4.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-1.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>-1.0</td>\n",
       "      <td>-1.0</td>\n",
       "      <td>-9.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>-2.0</td>\n",
       "      <td>-2.0</td>\n",
       "      <td>-2.0</td>\n",
       "      <td>-2.0</td>\n",
       "      <td>-14.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>-15.0</td>\n",
       "      <td>-16.0</td>\n",
       "      <td>-17.0</td>\n",
       "      <td>-18.0</td>\n",
       "      <td>-19.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      a     b     c     d     e\n",
       "0   0.0   0.0   0.0   0.0  -4.0\n",
       "1  -1.0   5.0  -1.0  -1.0  -9.0\n",
       "2  -2.0  -2.0  -2.0  -2.0 -14.0\n",
       "3 -15.0 -16.0 -17.0 -18.0 -19.0"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df1.sub(df2, fill_value=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "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>a</th>\n",
       "      <th>b</th>\n",
       "      <th>c</th>\n",
       "      <th>d</th>\n",
       "      <th>e</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>4.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1.0</td>\n",
       "      <td>-5.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>9.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>14.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>15.0</td>\n",
       "      <td>16.0</td>\n",
       "      <td>17.0</td>\n",
       "      <td>18.0</td>\n",
       "      <td>19.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      a     b     c     d     e\n",
       "0   0.0   0.0   0.0   0.0   4.0\n",
       "1   1.0  -5.0   1.0   1.0   9.0\n",
       "2   2.0   2.0   2.0   2.0  14.0\n",
       "3  15.0  16.0  17.0  18.0  19.0"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df1.rsub(df2, fill_value=0)     #rsub,rdiv, rfloordiv都是翻转参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "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>a</th>\n",
       "      <th>b</th>\n",
       "      <th>c</th>\n",
       "      <th>d</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>inf</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.500000</td>\n",
       "      <td>0.333333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.250000</td>\n",
       "      <td>0.200000</td>\n",
       "      <td>0.166667</td>\n",
       "      <td>0.142857</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.125000</td>\n",
       "      <td>0.111111</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.090909</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          a         b         c         d\n",
       "0       inf  1.000000  0.500000  0.333333\n",
       "1  0.250000  0.200000  0.166667  0.142857\n",
       "2  0.125000  0.111111  0.100000  0.090909"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 / df1                         #与df1.rdiv(1)等价"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "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>a</th>\n",
       "      <th>b</th>\n",
       "      <th>c</th>\n",
       "      <th>d</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>inf</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.500000</td>\n",
       "      <td>0.333333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.250000</td>\n",
       "      <td>0.200000</td>\n",
       "      <td>0.166667</td>\n",
       "      <td>0.142857</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.125000</td>\n",
       "      <td>0.111111</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.090909</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          a         b         c         d\n",
       "0       inf  1.000000  0.500000  0.333333\n",
       "1  0.250000  0.200000  0.166667  0.142857\n",
       "2  0.125000  0.111111  0.100000  0.090909"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df1.rdiv(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "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>a</th>\n",
       "      <th>b</th>\n",
       "      <th>c</th>\n",
       "      <th>d</th>\n",
       "      <th>e</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>6.0</td>\n",
       "      <td>7.0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>8.0</td>\n",
       "      <td>9.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     a    b     c     d  e\n",
       "0  0.0  1.0   2.0   3.0  0\n",
       "1  4.0  5.0   6.0   7.0  0\n",
       "2  8.0  9.0  10.0  11.0  0"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 在对Series或DataFrame重新索引时，也可以指定填充值\n",
    "df1.reindex(columns = df2.columns, fill_value=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### DataFrame和Series之间的运算"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.,  1.,  2.,  3.],\n",
       "       [ 4.,  5.,  6.,  7.],\n",
       "       [ 8.,  9., 10., 11.]])"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 计算一个二维数组与某某行之间的差\n",
    "arr = np.arange(12.).reshape((3,4))\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 1., 2., 3.])"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0.],\n",
       "       [4., 4., 4., 4.],\n",
       "       [8., 8., 8., 8.]])"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr - arr[0]                   #每一行都执行这个操作，这叫广播(broadcasting)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "frame = pd.DataFrame(np.arange(12.).reshape((4, 3)),\n",
    "                    columns = list('bde'),\n",
    "                    index = ['Utah', 'Ohio', 'Texas', 'Oregon'])\n",
    "series = frame.iloc[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "scrolled": true
   },
   "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>b</th>\n",
       "      <th>d</th>\n",
       "      <th>e</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Utah</th>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Ohio</th>\n",
       "      <td>3.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>5.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Texas</th>\n",
       "      <td>6.0</td>\n",
       "      <td>7.0</td>\n",
       "      <td>8.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Oregon</th>\n",
       "      <td>9.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>11.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          b     d     e\n",
       "Utah    0.0   1.0   2.0\n",
       "Ohio    3.0   4.0   5.0\n",
       "Texas   6.0   7.0   8.0\n",
       "Oregon  9.0  10.0  11.0"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b    0.0\n",
       "d    1.0\n",
       "e    2.0\n",
       "Name: Utah, dtype: float64"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "series"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {
    "scrolled": true
   },
   "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>b</th>\n",
       "      <th>d</th>\n",
       "      <th>e</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Utah</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Ohio</th>\n",
       "      <td>3.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Texas</th>\n",
       "      <td>6.0</td>\n",
       "      <td>6.0</td>\n",
       "      <td>6.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Oregon</th>\n",
       "      <td>9.0</td>\n",
       "      <td>9.0</td>\n",
       "      <td>9.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          b    d    e\n",
       "Utah    0.0  0.0  0.0\n",
       "Ohio    3.0  3.0  3.0\n",
       "Texas   6.0  6.0  6.0\n",
       "Oregon  9.0  9.0  9.0"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 默认情况下，DataFrame和Series之间的算术运算会将Series的索引匹配到DataFrame的列，然后沿着往后广播\n",
    "frame - series"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "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>b</th>\n",
       "      <th>d</th>\n",
       "      <th>e</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Utah</th>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Ohio</th>\n",
       "      <td>3.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>5.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Texas</th>\n",
       "      <td>6.0</td>\n",
       "      <td>7.0</td>\n",
       "      <td>8.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Oregon</th>\n",
       "      <td>9.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>11.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          b     d     e\n",
       "Utah    0.0   1.0   2.0\n",
       "Ohio    3.0   4.0   5.0\n",
       "Texas   6.0   7.0   8.0\n",
       "Oregon  9.0  10.0  11.0"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "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>b</th>\n",
       "      <th>d</th>\n",
       "      <th>e</th>\n",
       "      <th>f</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Utah</th>\n",
       "      <td>0.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>3.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Ohio</th>\n",
       "      <td>3.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>6.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Texas</th>\n",
       "      <td>6.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>9.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Oregon</th>\n",
       "      <td>9.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>12.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          b   d     e   f\n",
       "Utah    0.0 NaN   3.0 NaN\n",
       "Ohio    3.0 NaN   6.0 NaN\n",
       "Texas   6.0 NaN   9.0 NaN\n",
       "Oregon  9.0 NaN  12.0 NaN"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 某个索引值在DataFrame的列或Series的索引中找不到，则重新索引引以形成并集\n",
    "series2 = pd.Series(range(3), index=['b','e','f'])\n",
    "frame + series2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "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>b</th>\n",
       "      <th>d</th>\n",
       "      <th>e</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Utah</th>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Ohio</th>\n",
       "      <td>3.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>5.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Texas</th>\n",
       "      <td>6.0</td>\n",
       "      <td>7.0</td>\n",
       "      <td>8.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Oregon</th>\n",
       "      <td>9.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>11.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          b     d     e\n",
       "Utah    0.0   1.0   2.0\n",
       "Ohio    3.0   4.0   5.0\n",
       "Texas   6.0   7.0   8.0\n",
       "Oregon  9.0  10.0  11.0"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "series3 = frame['d']\n",
    "frame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Utah       1.0\n",
       "Ohio       4.0\n",
       "Texas      7.0\n",
       "Oregon    10.0\n",
       "Name: d, dtype: float64"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "series3 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "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>b</th>\n",
       "      <th>d</th>\n",
       "      <th>e</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Utah</th>\n",
       "      <td>-1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Ohio</th>\n",
       "      <td>-1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Texas</th>\n",
       "      <td>-1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Oregon</th>\n",
       "      <td>-1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          b    d    e\n",
       "Utah   -1.0  0.0  1.0\n",
       "Ohio   -1.0  0.0  1.0\n",
       "Texas  -1.0  0.0  1.0\n",
       "Oregon -1.0  0.0  1.0"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frame.sub(series3, axis='index')               #传入的轴号就是希望匹配的轴"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "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>b</th>\n",
       "      <th>d</th>\n",
       "      <th>e</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Utah</th>\n",
       "      <td>-1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Ohio</th>\n",
       "      <td>-1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Texas</th>\n",
       "      <td>-1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Oregon</th>\n",
       "      <td>-1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          b    d    e\n",
       "Utah   -1.0  0.0  1.0\n",
       "Ohio   -1.0  0.0  1.0\n",
       "Texas  -1.0  0.0  1.0\n",
       "Oregon -1.0  0.0  1.0"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frame.sub(series3, axis=0)                       #传入axis=0/axis='index'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 函数应用和映射"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "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>b</th>\n",
       "      <th>d</th>\n",
       "      <th>e</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Utah</th>\n",
       "      <td>0.321652</td>\n",
       "      <td>0.770945</td>\n",
       "      <td>-1.050139</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Ohio</th>\n",
       "      <td>-1.129032</td>\n",
       "      <td>0.561449</td>\n",
       "      <td>1.207370</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Texas</th>\n",
       "      <td>-0.442619</td>\n",
       "      <td>0.821926</td>\n",
       "      <td>0.577966</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Oregon</th>\n",
       "      <td>-2.226717</td>\n",
       "      <td>-0.652762</td>\n",
       "      <td>-1.072895</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               b         d         e\n",
       "Utah    0.321652  0.770945 -1.050139\n",
       "Ohio   -1.129032  0.561449  1.207370\n",
       "Texas  -0.442619  0.821926  0.577966\n",
       "Oregon -2.226717 -0.652762 -1.072895"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Numpy的ufunc(元素级数组方法)也可用于操作pandas对象\n",
    "frame = pd.DataFrame(np.random.randn(4, 3), columns = list('bde'),\n",
    "                    index = ['Utah','Ohio','Texas','Oregon'])\n",
    "frame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "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>b</th>\n",
       "      <th>d</th>\n",
       "      <th>e</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Utah</th>\n",
       "      <td>0.321652</td>\n",
       "      <td>0.770945</td>\n",
       "      <td>1.050139</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Ohio</th>\n",
       "      <td>1.129032</td>\n",
       "      <td>0.561449</td>\n",
       "      <td>1.207370</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Texas</th>\n",
       "      <td>0.442619</td>\n",
       "      <td>0.821926</td>\n",
       "      <td>0.577966</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Oregon</th>\n",
       "      <td>2.226717</td>\n",
       "      <td>0.652762</td>\n",
       "      <td>1.072895</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               b         d         e\n",
       "Utah    0.321652  0.770945  1.050139\n",
       "Ohio    1.129032  0.561449  1.207370\n",
       "Texas   0.442619  0.821926  0.577966\n",
       "Oregon  2.226717  0.652762  1.072895"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.abs(frame)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b    2.548369\n",
       "d    1.474689\n",
       "e    2.280265\n",
       "dtype: float64"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 将函数应用到由各行/列所形成的一维数组上。DataFrame的apply方法可以实现\n",
    "f = lambda x: x.max() - x.min()\n",
    "frame.apply(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Utah      1.821084\n",
       "Ohio      2.336403\n",
       "Texas     1.264546\n",
       "Oregon    1.573955\n",
       "dtype: float64"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frame.apply(f, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Utah      1.821084\n",
       "Ohio      2.336403\n",
       "Texas     1.264546\n",
       "Oregon    1.573955\n",
       "dtype: float64"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frame.apply(f, axis='columns')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "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>b</th>\n",
       "      <th>d</th>\n",
       "      <th>e</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>-2.226717</td>\n",
       "      <td>-0.652762</td>\n",
       "      <td>-1.072895</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>0.321652</td>\n",
       "      <td>0.821926</td>\n",
       "      <td>1.207370</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            b         d         e\n",
       "min -2.226717 -0.652762 -1.072895\n",
       "max  0.321652  0.821926  1.207370"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#最常见的数组统计功能df都有方法，如sum和mean，无需apply\n",
    "#传递apply的函数返回可以是多个值组成的Series\n",
    "def f(x):\n",
    "    return pd.Series([x.min(), x.max()], index=['min','max'])\n",
    "\n",
    "frame.apply(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "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>b</th>\n",
       "      <th>d</th>\n",
       "      <th>e</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Utah</th>\n",
       "      <td>0.32</td>\n",
       "      <td>0.77</td>\n",
       "      <td>-1.05</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Ohio</th>\n",
       "      <td>-1.13</td>\n",
       "      <td>0.56</td>\n",
       "      <td>1.21</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Texas</th>\n",
       "      <td>-0.44</td>\n",
       "      <td>0.82</td>\n",
       "      <td>0.58</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Oregon</th>\n",
       "      <td>-2.23</td>\n",
       "      <td>-0.65</td>\n",
       "      <td>-1.07</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            b      d      e\n",
       "Utah     0.32   0.77  -1.05\n",
       "Ohio    -1.13   0.56   1.21\n",
       "Texas   -0.44   0.82   0.58\n",
       "Oregon  -2.23  -0.65  -1.07"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#元素级的python函数也可以使用。DataFrame有applymap，Series有一个应用于元素级函数的map方法\n",
    "format = lambda x: '%.2f' % x\n",
    "frame.applymap(format)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Utah      -1.05\n",
       "Ohio       1.21\n",
       "Texas      0.58\n",
       "Oregon    -1.07\n",
       "Name: e, dtype: object"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frame['e'].map(format)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 排序和排名\n",
    "要对行或列索引进行排序，可使用sort_index方法，返回一个已排序的新对象"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    1\n",
       "b    2\n",
       "c    3\n",
       "d    0\n",
       "dtype: int64"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj = pd.Series(range(4), index=['d','a','b','c'])\n",
    "obj.sort_index()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "d    0\n",
       "a    1\n",
       "b    2\n",
       "c    3\n",
       "dtype: int64"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "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>d</th>\n",
       "      <th>a</th>\n",
       "      <th>b</th>\n",
       "      <th>c</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>three</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>one</th>\n",
       "      <td>4</td>\n",
       "      <td>5</td>\n",
       "      <td>6</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       d  a  b  c\n",
       "three  0  1  2  3\n",
       "one    4  5  6  7"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 对于DataFrame，则根据任意一个轴上的索引进行排序\n",
    "frame = pd.DataFrame(np.arange(8).reshape((2,4)),\n",
    "                    index = ['three','one'],\n",
    "                    columns=['d','a','b','c'])\n",
    "frame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "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>d</th>\n",
       "      <th>a</th>\n",
       "      <th>b</th>\n",
       "      <th>c</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>one</th>\n",
       "      <td>4</td>\n",
       "      <td>5</td>\n",
       "      <td>6</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>three</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       d  a  b  c\n",
       "one    4  5  6  7\n",
       "three  0  1  2  3"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frame.sort_index()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "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>a</th>\n",
       "      <th>b</th>\n",
       "      <th>c</th>\n",
       "      <th>d</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>three</th>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>one</th>\n",
       "      <td>5</td>\n",
       "      <td>6</td>\n",
       "      <td>7</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       a  b  c  d\n",
       "three  1  2  3  0\n",
       "one    5  6  7  4"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frame.sort_index(axis=1)     #按axis=1排序 升序"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "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>d</th>\n",
       "      <th>c</th>\n",
       "      <th>b</th>\n",
       "      <th>a</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>three</th>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>one</th>\n",
       "      <td>4</td>\n",
       "      <td>7</td>\n",
       "      <td>6</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       d  c  b  a\n",
       "three  0  3  2  1\n",
       "one    4  7  6  5"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frame.sort_index(axis=1, ascending=False)   #按axis=1排序，降序"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 对值排序\n",
    "sort_values()方法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2   -3\n",
       "3    2\n",
       "0    4\n",
       "1    7\n",
       "dtype: int64"
      ]
     },
     "execution_count": 170,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 按值对Series进行排序\n",
    "obj = pd.Series([4, 7, -3, 2])\n",
    "obj.sort_values()                           #sort_values方法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4   -3.0\n",
       "5    2.0\n",
       "0    4.0\n",
       "2    7.0\n",
       "1    NaN\n",
       "3    NaN\n",
       "dtype: float64"
      ]
     },
     "execution_count": 171,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#排序时，缺失值默认在末尾\n",
    "obj = pd.Series([4, np.nan, 7, np.nan, -3, 2])\n",
    "obj.sort_values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "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>a</th>\n",
       "      <th>b</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0</td>\n",
       "      <td>-3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   a  b\n",
       "0  0  4\n",
       "1  1  7\n",
       "2  0 -3\n",
       "3  1  2"
      ]
     },
     "execution_count": 174,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 排序一个DataFrame。你可能希望根据一个或多个列中的值进行排序。sort_values的by选项即可达到该目的\n",
    "frame = pd.DataFrame({'a':[0,1,0,1] ,'b':[4,7,-3,2]})\n",
    "frame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "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>a</th>\n",
       "      <th>b</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0</td>\n",
       "      <td>-3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   a  b\n",
       "2  0 -3\n",
       "3  1  2\n",
       "0  0  4\n",
       "1  1  7"
      ]
     },
     "execution_count": 175,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frame.sort_values(by='b')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "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>a</th>\n",
       "      <th>b</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0</td>\n",
       "      <td>-3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   a  b\n",
       "2  0 -3\n",
       "0  0  4\n",
       "3  1  2\n",
       "1  1  7"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#要对多个列进行排序\n",
    "frame.sort_values(by=['a','b'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    6.5\n",
       "1    1.0\n",
       "2    6.5\n",
       "3    4.5\n",
       "4    3.0\n",
       "5    2.0\n",
       "6    4.5\n",
       "dtype: float64"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Rank方法求排名，rank是通过'为各组分配一个平均排名'的方式来破坏平级关系的\n",
    "obj = pd.Series([7, -5, 7, 4, 2, 0, 4])\n",
    "obj.rank()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    6.0\n",
       "1    1.0\n",
       "2    7.0\n",
       "3    4.0\n",
       "4    3.0\n",
       "5    2.0\n",
       "6    5.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 179,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 根据值在原数据中出现的顺序给出排名\n",
    "obj.rank(method='first')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    2.0\n",
       "1    7.0\n",
       "2    2.0\n",
       "3    4.0\n",
       "4    5.0\n",
       "5    6.0\n",
       "6    4.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 180,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj.rank(ascending=False, method='max')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "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>a</th>\n",
       "      <th>b</th>\n",
       "      <th>c</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>4.3</td>\n",
       "      <td>-2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>7.0</td>\n",
       "      <td>5.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0</td>\n",
       "      <td>-3.0</td>\n",
       "      <td>8.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>2.0</td>\n",
       "      <td>-2.5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   a    b    c\n",
       "0  0  4.3 -2.0\n",
       "1  1  7.0  5.0\n",
       "2  0 -3.0  8.0\n",
       "3  1  2.0 -2.5"
      ]
     },
     "execution_count": 182,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frame = pd.DataFrame({'a':[0,1,0,1],'b':[4.3,7,-3,2],\n",
    "                     'c':[-2, 5, 8, -2.5]})\n",
    "frame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "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>a</th>\n",
       "      <th>b</th>\n",
       "      <th>c</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     a    b    c\n",
       "0  2.0  3.0  1.0\n",
       "1  1.0  3.0  2.0\n",
       "2  2.0  1.0  3.0\n",
       "3  2.0  3.0  1.0"
      ]
     },
     "execution_count": 183,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frame.rank(axis='columns')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "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>a</th>\n",
       "      <th>b</th>\n",
       "      <th>c</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     a    b    c\n",
       "0  2.0  3.0  1.0\n",
       "1  1.0  3.0  2.0\n",
       "2  2.0  1.0  3.0\n",
       "3  2.0  3.0  1.0"
      ]
     },
     "execution_count": 184,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frame.rank(axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 带有重复标签的轴索引,会使代码有点复杂"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    0\n",
       "a    1\n",
       "b    2\n",
       "b    3\n",
       "c    4\n",
       "dtype: int64"
      ]
     },
     "execution_count": 185,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj = pd.Series(range(5),index=['a','a','b','b','c'])\n",
    "obj"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 186,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj.index.is_unique"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    0\n",
       "a    1\n",
       "dtype: int64"
      ]
     },
     "execution_count": 187,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj['a']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 188,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj['c']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "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>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>a</th>\n",
       "      <td>-1.314411</td>\n",
       "      <td>0.601045</td>\n",
       "      <td>0.248240</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>a</th>\n",
       "      <td>-1.159405</td>\n",
       "      <td>-0.283612</td>\n",
       "      <td>0.229632</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>b</th>\n",
       "      <td>0.734259</td>\n",
       "      <td>-0.837608</td>\n",
       "      <td>-0.575956</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>b</th>\n",
       "      <td>-0.741576</td>\n",
       "      <td>2.138981</td>\n",
       "      <td>2.020752</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          0         1         2\n",
       "a -1.314411  0.601045  0.248240\n",
       "a -1.159405 -0.283612  0.229632\n",
       "b  0.734259 -0.837608 -0.575956\n",
       "b -0.741576  2.138981  2.020752"
      ]
     },
     "execution_count": 189,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.DataFrame(np.random.randn(4,3), index=['a','a','b','b'])\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "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>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>b</th>\n",
       "      <td>0.734259</td>\n",
       "      <td>-0.837608</td>\n",
       "      <td>-0.575956</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>b</th>\n",
       "      <td>-0.741576</td>\n",
       "      <td>2.138981</td>\n",
       "      <td>2.020752</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          0         1         2\n",
       "b  0.734259 -0.837608 -0.575956\n",
       "b -0.741576  2.138981  2.020752"
      ]
     },
     "execution_count": 190,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.loc['b']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 汇总和计算描述统计，pandas的大部分属于约简和汇总统计。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "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>one</th>\n",
       "      <th>two</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>a</th>\n",
       "      <td>1.40</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>b</th>\n",
       "      <td>7.10</td>\n",
       "      <td>-4.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>c</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>d</th>\n",
       "      <td>0.75</td>\n",
       "      <td>-1.3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    one  two\n",
       "a  1.40  NaN\n",
       "b  7.10 -4.5\n",
       "c   NaN  NaN\n",
       "d  0.75 -1.3"
      ]
     },
     "execution_count": 191,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.DataFrame([[1.4, np.nan], [7.1, -4.5],\n",
    "                  [np.nan, np.nan], [0.75, -1.3]],\n",
    "                 index = ['a','b','c','d'],\n",
    "                 columns=['one', 'two'])\n",
    "\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "one    9.25\n",
       "two   -5.80\n",
       "dtype: float64"
      ]
     },
     "execution_count": 192,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    1.40\n",
       "b    2.60\n",
       "c    0.00\n",
       "d   -0.55\n",
       "dtype: float64"
      ]
     },
     "execution_count": 193,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.sum(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    1.40\n",
       "b    2.60\n",
       "c    0.00\n",
       "d   -0.55\n",
       "dtype: float64"
      ]
     },
     "execution_count": 194,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.sum(axis='columns')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a      NaN\n",
       "b    1.300\n",
       "c      NaN\n",
       "d   -0.275\n",
       "dtype: float64"
      ]
     },
     "execution_count": 195,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.mean(axis='columns', skipna=False)     #默认是True。计算时NA值会自动被切除，除非整行/列是NA。在这里禁用"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    1.400\n",
       "b    1.300\n",
       "c      NaN\n",
       "d   -0.275\n",
       "dtype: float64"
      ]
     },
     "execution_count": 196,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.mean(axis='columns')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "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>one</th>\n",
       "      <th>two</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>a</th>\n",
       "      <td>1.40</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>b</th>\n",
       "      <td>7.10</td>\n",
       "      <td>-4.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>c</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>d</th>\n",
       "      <td>0.75</td>\n",
       "      <td>-1.3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    one  two\n",
       "a  1.40  NaN\n",
       "b  7.10 -4.5\n",
       "c   NaN  NaN\n",
       "d  0.75 -1.3"
      ]
     },
     "execution_count": 200,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 间接统计(比如达到最小值或最大值的索引),idxmin和idmax\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "one    b\n",
       "two    d\n",
       "dtype: object"
      ]
     },
     "execution_count": 199,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.idxmax()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "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>one</th>\n",
       "      <th>two</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>a</th>\n",
       "      <td>1.40</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>b</th>\n",
       "      <td>8.50</td>\n",
       "      <td>-4.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>c</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>d</th>\n",
       "      <td>9.25</td>\n",
       "      <td>-5.8</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    one  two\n",
       "a  1.40  NaN\n",
       "b  8.50 -4.5\n",
       "c   NaN  NaN\n",
       "d  9.25 -5.8"
      ]
     },
     "execution_count": 201,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 累计型\n",
    "df.cumsum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "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>one</th>\n",
       "      <th>two</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>3.000000</td>\n",
       "      <td>2.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>3.083333</td>\n",
       "      <td>-2.900000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>3.493685</td>\n",
       "      <td>2.262742</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>0.750000</td>\n",
       "      <td>-4.500000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>1.075000</td>\n",
       "      <td>-3.700000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>1.400000</td>\n",
       "      <td>-2.900000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>4.250000</td>\n",
       "      <td>-2.100000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>7.100000</td>\n",
       "      <td>-1.300000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            one       two\n",
       "count  3.000000  2.000000\n",
       "mean   3.083333 -2.900000\n",
       "std    3.493685  2.262742\n",
       "min    0.750000 -4.500000\n",
       "25%    1.075000 -3.700000\n",
       "50%    1.400000 -2.900000\n",
       "75%    4.250000 -2.100000\n",
       "max    7.100000 -1.300000"
      ]
     },
     "execution_count": 202,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 一次性产生多个汇总统计\n",
    "df.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "count     16\n",
       "unique     3\n",
       "top        a\n",
       "freq       8\n",
       "dtype: object"
      ]
     },
     "execution_count": 204,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#对于非数值型数据，describe产生另外一种汇总统计\n",
    "obj = pd.Series(['a','a','b','c'] * 4)\n",
    "obj.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 唯一值、值计数以及成员资格"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['c', 'a', 'd', 'b'], dtype=object)"
      ]
     },
     "execution_count": 205,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj = pd.Series(['c','a','d','a','a','b','b','c','c'])\n",
    "uniques = obj.unique()\n",
    "uniques"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['a', 'b', 'c', 'd'], dtype=object)"
      ]
     },
     "execution_count": 210,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 对结果再次排序\n",
    "uniques.sort()      #就地改变，没有返回值       \n",
    "uniques"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "c    3\n",
       "a    3\n",
       "b    2\n",
       "d    1\n",
       "dtype: int64"
      ]
     },
     "execution_count": 212,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 计算Series中各值出现的频率\n",
    "obj.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    3\n",
       "d    1\n",
       "c    3\n",
       "b    2\n",
       "dtype: int64"
      ]
     },
     "execution_count": 213,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# value_counts还是一个顶级pandas方法，可用于任何数组或序列\n",
    "pd.value_counts(obj.values, sort=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    c\n",
       "1    a\n",
       "2    d\n",
       "3    a\n",
       "4    a\n",
       "5    b\n",
       "6    b\n",
       "7    c\n",
       "8    c\n",
       "dtype: object"
      ]
     },
     "execution_count": 214,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# isin用于判断矢量化集合的成员资格，可用于过滤Series中或DataFrame列中数据的子集\n",
    "obj"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0     True\n",
       "1    False\n",
       "2    False\n",
       "3    False\n",
       "4    False\n",
       "5     True\n",
       "6     True\n",
       "7     True\n",
       "8     True\n",
       "dtype: bool"
      ]
     },
     "execution_count": 215,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mask = obj.isin(['b','c'])\n",
    "mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    c\n",
       "5    b\n",
       "6    b\n",
       "7    c\n",
       "8    c\n",
       "dtype: object"
      ]
     },
     "execution_count": 216,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj[mask]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2, 1, 1, 0, 2], dtype=int64)"
      ]
     },
     "execution_count": 218,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "to_match = pd.Series(['c','a','b','b','c','a'])\n",
    "unique_vals = pd.Series(['c', 'b', 'a'])\n",
    "\n",
    "pd.Index(unique_vals).get_indexer(to_match)       #一个数组在另一个数组的索引"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "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>Qu1</th>\n",
       "      <th>Qu2</th>\n",
       "      <th>Qu3</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>4</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3</td>\n",
       "      <td>2</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Qu1  Qu2  Qu3\n",
       "0    1    2    1\n",
       "1    3    3    5\n",
       "2    4    1    2\n",
       "3    3    2    4\n",
       "4    4    3    4"
      ]
     },
     "execution_count": 220,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = pd.DataFrame({'Qu1':[1,3,4,3,4],\n",
    "                    'Qu2': [2,3,1,2,3],\n",
    "                    'Qu3': [1,5,2,4,4]})\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "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>Qu1</th>\n",
       "      <th>Qu2</th>\n",
       "      <th>Qu3</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Qu1  Qu2  Qu3\n",
       "1  1.0  1.0  1.0\n",
       "2  0.0  2.0  1.0\n",
       "3  2.0  2.0  0.0\n",
       "4  2.0  0.0  2.0\n",
       "5  0.0  0.0  1.0"
      ]
     },
     "execution_count": 222,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 多个相关列的柱状图\n",
    "result = data.apply(pd.value_counts).fillna(0)\n",
    "result                                              #结果中的行标签是所有列的唯一值，后面的频率值是这些值的相应计数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}