misc/intro2python/numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Heavily based on Stanford's CS231n [\"Python Numpy Tutorial\"](http://cs231n.github.io/python-numpy-tutorial/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# importing numpy as an object named \"np\" is the convention:\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.13.3\n"
     ]
    }
   ],
   "source": [
    "# know your version\n",
    "print(np.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "# Numpy arrays are the basic numpy data type.\n",
    "# create a 1D numpy array,\n",
    "a = np.array([1, 2, 3])\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3,)\n"
     ]
    }
   ],
   "source": [
    "# shape is the most basic attribute of any numpy array\n",
    "print(a.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "[5 2 3]\n"
     ]
    }
   ],
   "source": [
    "# subsetting similiar to a list\n",
    "print(a[0])\n",
    "a[0] = 5                  # Change an element of the array\n",
    "print(a)                  # Prints \"[5, 2, 3]\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 3)\n",
      "(2, 3) because of number of rows is 2 and number of columns is 3\n",
      "1 2 4\n"
     ]
    }
   ],
   "source": [
    "# creating a 2D array, a matrix, with a nested list\n",
    "b = np.array([[1,2,3],[4,5,6]])\n",
    "print(b.shape)\n",
    "print(\"(2, 3) because of number of rows is %d and number of columns is %d\" % b.shape)\n",
    "# subesetting like subsetting a matrix, remember zero-based indexing!\n",
    "print(b[0, 0], b[0, 1], b[1, 0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.  0.]\n",
      " [ 0.  0.]]\n",
      "\n",
      "[[ 1.  1.]]\n",
      "\n",
      "[[7 7]\n",
      " [7 7]]\n",
      "\n",
      "[[ 1.  0.]\n",
      " [ 0.  1.]]\n",
      "\n",
      "[[ 0.54748276  0.54149801]\n",
      " [ 0.23089523  0.48119211]]\n"
     ]
    }
   ],
   "source": [
    "# create an array of all zeros (the parameter is a tuple specifying the array shape)\n",
    "a = np.zeros((2,2))\n",
    "print(a)\n",
    "print()\n",
    "# create an array of all ones\n",
    "b = np.ones((1,2))\n",
    "print(b)\n",
    "print()\n",
    "# create a constant array\n",
    "c = np.full((2,2), 7)\n",
    "print(c)\n",
    "print()\n",
    "# create a 2x2 identity matrix\n",
    "d = np.eye(2)\n",
    "print(d)\n",
    "print()\n",
    "# create an array filled with random U(0, 1) values\n",
    "e = np.random.random((2,2))\n",
    "print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Indexing and Slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]]\n",
      "\n",
      "[[2 3]\n",
      " [6 7]]\n",
      "\n",
      "2\n",
      "77\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])\n",
    "print(a)\n",
    "print()\n",
    "\n",
    "# use slicing to pull out the subarray consisting of the first 2 rows\n",
    "# and columns 1 and 2; b of shape (2, 2)\n",
    "b = a[:2, 1:3]\n",
    "print(b)\n",
    "print()\n",
    "\n",
    "# a slice of an array is a view into the same data, so modifying it\n",
    "# will modify the original array.\n",
    "print(a[0, 1])\n",
    "b[0, 0] = 77\n",
    "print(a[0, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5 6 7 8] of shape: (4,)\n",
      "[[5 6 7 8]] of shape (1, 4)\n",
      "\n",
      "[77  6 10] of shape (3,)\n",
      "[[77]\n",
      " [ 6]\n",
      " [10]] of shape (3, 1)\n"
     ]
    }
   ],
   "source": [
    "# two ways of accessing the data in the middle row of the array.\n",
    "# mixing integer indexing with slices yields an array of lower rank,\n",
    "# while using only slices yields an array of the same rank as the\n",
    "# original array:\n",
    "row_r1 = a[1, :]    # Rank 1 view of the second row of a\n",
    "row_r2 = a[1:2, :]  # Rank 2 view of the second row of a\n",
    "print(row_r1, \"of shape:\", row_r1.shape)\n",
    "print(row_r2, \"of shape\", row_r2.shape)\n",
    "print()\n",
    "\n",
    "# we can make the same distinction when accessing columns of an array:\n",
    "col_r1 = a[:, 1]\n",
    "col_r2 = a[:, 1:2]\n",
    "print(col_r1, \"of shape\", col_r1.shape)\n",
    "print(col_r2, \"of shape\", col_r2.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3]\n",
      " [ 4  5  6]\n",
      " [ 7  8  9]\n",
      " [10 11 12]]\n",
      "\n",
      "[ 1  6  7 11]\n",
      "\n",
      "[[11  2  3]\n",
      " [ 4  5 16]\n",
      " [17  8  9]\n",
      " [10 21 12]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])\n",
    "print(a)\n",
    "print()\n",
    "\n",
    "# indexing a numpy array with another array of indices:\n",
    "# create an array of indices\n",
    "b = np.array([0, 2, 0, 1])\n",
    "\n",
    "# select one element from each row of a using the indices in b\n",
    "print(a[np.arange(4), b])\n",
    "print()\n",
    "\n",
    "# mutate one element from each row of a using the indices in b\n",
    "a[np.arange(4), b] += 10\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]]\n",
      "\n",
      "[[False False]\n",
      " [ True  True]\n",
      " [ True  True]]\n",
      "\n",
      "[3 4 5 6]\n",
      "\n",
      "[3 4 5 6]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1,2], [3, 4], [5, 6]])\n",
    "print(a)\n",
    "print()\n",
    "\n",
    "# boolean array indexing:\n",
    "# find the elements of a that are bigger than 2;\n",
    "# this returns a numpy array of Booleans of the same shape as a, where each slot of bool_idx tells\n",
    "# whether that element of a is > 2.\n",
    "bool_idx = (a > 2)\n",
    "print(bool_idx)\n",
    "print()\n",
    "\n",
    "# we use boolean array indexing to construct a rank 1 array\n",
    "# consisting of the elements of a corresponding to the True values\n",
    "# of bool_idx\n",
    "print(a[bool_idx])\n",
    "print()\n",
    "\n",
    "# we can do all of the above in a single concise statement:\n",
    "print(a[a > 2]) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Datatypes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "int64\n",
      "\n",
      "float64\n",
      "\n",
      "int64\n"
     ]
    }
   ],
   "source": [
    "# we can choose whether to specify the type of elements in the array or let numpy choose:\n",
    "\n",
    "# let numpy choose the datatype\n",
    "x = np.array([1, 2])\n",
    "print(x.dtype)\n",
    "print()\n",
    "\n",
    "x = np.array([1.0, 2.0])\n",
    "print(x.dtype)\n",
    "print()\n",
    "\n",
    "# specify a particular datatype\n",
    "x = np.array([1, 2], dtype=np.int64)\n",
    "print(x.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Array math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2.  4.]\n",
      " [ 6.  8.]]\n",
      "\n",
      "[[  6.   8.]\n",
      " [ 10.  12.]]\n",
      "[[  6.   8.]\n",
      " [ 10.  12.]]\n",
      "\n",
      "[[-4. -4.]\n",
      " [-4. -4.]]\n",
      "[[-4. -4.]\n",
      " [-4. -4.]]\n",
      "\n",
      "[[  5.  12.]\n",
      " [ 21.  32.]]\n",
      "[[  5.  12.]\n",
      " [ 21.  32.]]\n",
      "\n",
      "[[ 0.2         0.33333333]\n",
      " [ 0.42857143  0.5       ]]\n",
      "[[ 0.2         0.33333333]\n",
      " [ 0.42857143  0.5       ]]\n",
      "\n",
      "[[ 1.          1.41421356]\n",
      " [ 1.73205081  2.        ]]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1,2],[3,4]], dtype=np.float64)\n",
    "y = np.array([[5,6],[7,8]], dtype=np.float64)\n",
    "\n",
    "# elementwise multiplication by 2 (remember this isn't so simple with a list!)\n",
    "print(x * 2)\n",
    "print()\n",
    "\n",
    "# elementwise sum; both produce the array\n",
    "# [[ 6.0  8.0]\n",
    "#  [10.0 12.0]]\n",
    "print(x + y)\n",
    "print(np.add(x, y))\n",
    "print()\n",
    "\n",
    "# elementwise difference; both produce the array\n",
    "# [[-4.0 -4.0]\n",
    "#  [-4.0 -4.0]]\n",
    "print(x - y)\n",
    "print(np.subtract(x, y))\n",
    "print()\n",
    "\n",
    "# elementwise product; both produce the array\n",
    "# [[ 5.0 12.0]\n",
    "#  [21.0 32.0]]\n",
    "print(x * y)\n",
    "print(np.multiply(x, y))\n",
    "print()\n",
    "\n",
    "# elementwise division; both produce the array\n",
    "# [[ 0.2         0.33333333]\n",
    "#  [ 0.42857143  0.5       ]]\n",
    "print(x / y)\n",
    "print(np.divide(x, y))\n",
    "print()\n",
    "\n",
    "# elementwise square root; produces the array\n",
    "# [[ 1.          1.41421356]\n",
    "#  [ 1.73205081  2.        ]]\n",
    "print(np.sqrt(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "219\n",
      "219\n",
      "\n",
      "[29 67]\n",
      "[29 67]\n",
      "\n",
      "[[19 22]\n",
      " [43 50]]\n",
      "[[19 22]\n",
      " [43 50]]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# proper vector/matrix multiplication\n",
    "x = np.array([[1,2],[3,4]])\n",
    "y = np.array([[5,6],[7,8]])\n",
    "\n",
    "v = np.array([9,10])\n",
    "w = np.array([11, 12])\n",
    "\n",
    "# Inner product of vectors; both produce 219\n",
    "print(v.dot(w))\n",
    "print(np.dot(v, w))\n",
    "print()\n",
    "\n",
    "# Matrix / vector product; both produce the rank 1 array [29 67]\n",
    "print(x.dot(v))\n",
    "print(np.dot(x, v))\n",
    "print()\n",
    "\n",
    "# Matrix / matrix product; both produce the rank 2 array\n",
    "# [[19 22]\n",
    "#  [43 50]]\n",
    "print(x.dot(y))\n",
    "print(np.dot(x, y))\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "[4 6]\n",
      "[3 7]\n"
     ]
    }
   ],
   "source": [
    "# no need to use loops for simple aggregation!\n",
    "x = np.array([[1,2],[3,4]])\n",
    "\n",
    "print(np.sum(x))  # Compute sum of all elements\n",
    "print(np.sum(x, axis=0))  # Compute sum of each column\n",
    "print(np.sum(x, axis=1))  # Compute sum of each row"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]]\n",
      "[[1 3]\n",
      " [2 4]]\n"
     ]
    }
   ],
   "source": [
    "# transposing a matrix\n",
    "x = np.array([[1,2], [3,4]])\n",
    "print(x)\n",
    "print(x.T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Broadcasting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2  2  4]\n",
      " [ 5  5  7]\n",
      " [ 8  8 10]\n",
      " [11 11 13]]\n"
     ]
    }
   ],
   "source": [
    "# We will add the vector v to each row of the matrix x,\n",
    "# storing the result in the matrix y\n",
    "x = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])\n",
    "v = np.array([1, 0, 1])\n",
    "y = np.empty_like(x)   # Create an empty matrix with the same shape as x\n",
    "\n",
    "# Add the vector v to each row of the matrix x with an explicit loop\n",
    "for i in range(4):\n",
    "    y[i, :] = x[i, :] + v\n",
    "\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 0 1]\n",
      " [1 0 1]\n",
      " [1 0 1]\n",
      " [1 0 1]]\n",
      "\n",
      "[[ 2  2  4]\n",
      " [ 5  5  7]\n",
      " [ 8  8 10]\n",
      " [11 11 13]]\n"
     ]
    }
   ],
   "source": [
    "# This is better:\n",
    "vv = np.tile(v, (4, 1))   # Stack 4 copies of v on top of each other\n",
    "print(vv)\n",
    "print()\n",
    "\n",
    "y = x + vv  # Add x and vv elementwise\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2  2  4]\n",
      " [ 5  5  7]\n",
      " [ 8  8 10]\n",
      " [11 11 13]]\n"
     ]
    }
   ],
   "source": [
    "# Broadcasting is the best. Magically, v will be added to each row of x:\n",
    "y = x + v\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See more [here](https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html) for broadcasting rules."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 4  5]\n",
      " [ 8 10]\n",
      " [12 15]]\n",
      "\n",
      "[[2 4 6]\n",
      " [5 7 9]]\n",
      "\n",
      "[[ 5  6  7]\n",
      " [ 9 10 11]]\n",
      "\n",
      "[[ 5  6  7]\n",
      " [ 9 10 11]]\n",
      "\n",
      "[[ 2  4  6]\n",
      " [ 8 10 12]]\n"
     ]
    }
   ],
   "source": [
    "# more broadcasting applications:\n",
    "\n",
    "# Compute outer product of vectors\n",
    "v = np.array([1,2,3])  # v has shape (3,)\n",
    "w = np.array([4,5])    # w has shape (2,)\n",
    "# To compute an outer product, we first reshape v to be a column\n",
    "# vector of shape (3, 1); we can then broadcast it against w to yield\n",
    "# an output of shape (3, 2), which is the outer product of v (3 x 1) and w (1 x 2):\n",
    "# [[ 4  5]\n",
    "#  [ 8 10]\n",
    "#  [12 15]]\n",
    "print(np.reshape(v, (3, 1)) * w)\n",
    "print()\n",
    "\n",
    "# Add a vector to each row of a matrix\n",
    "x = np.array([[1,2,3], [4,5,6]])\n",
    "# x has shape (2, 3) and v has shape (3,) so they broadcast to (2, 3),\n",
    "# giving the following matrix:\n",
    "# [[2 4 6]\n",
    "#  [5 7 9]]\n",
    "print(x + v)\n",
    "print()\n",
    "\n",
    "# Add a vector to each column of a matrix\n",
    "# x has shape (2, 3) and w has shape (2,).\n",
    "# If we transpose x then it has shape (3, 2) and can be broadcast\n",
    "# against w to yield a result of shape (3, 2); transposing this result\n",
    "# yields the final result of shape (2, 3) which is the matrix x with\n",
    "# the vector w added to each column. Gives the following matrix:\n",
    "# [[ 5  6  7]\n",
    "#  [ 9 10 11]]\n",
    "print((x.T + w).T)\n",
    "print()\n",
    "\n",
    "\n",
    "# Another solution is to reshape w to be a column vector of shape (2, 1);\n",
    "# we can then broadcast it directly against x to produce the same\n",
    "# output.\n",
    "print(x + np.reshape(w, (2, 1)))\n",
    "print()\n",
    "\n",
    "# Multiply a matrix by a constant:\n",
    "# x has shape (2, 3). Numpy treats scalars as arrays of shape ();\n",
    "# these can be broadcast together to shape (2, 3), producing the\n",
    "# following array:\n",
    "# [[ 2  4  6]\n",
    "#  [ 8 10 12]]\n",
    "print(x * 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# More useful stuff"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `stack`, `cocatenate`, `vstack` and `hstack`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [2 3 4]]\n",
      "[[1 2 3]\n",
      " [2 3 4]]\n",
      "[1 2 3 2 3 4]\n",
      "[1 2 3 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1, 2, 3])\n",
    "b = np.array([2, 3, 4])\n",
    "print(np.stack((a, b)))\n",
    "print(np.vstack((a, b)))\n",
    "print(np.hstack((a, b)))\n",
    "print(np.concatenate((a, b)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1]\n",
      " [2]\n",
      " [3]\n",
      " [2]\n",
      " [3]\n",
      " [4]]\n",
      "[[1 2]\n",
      " [2 3]\n",
      " [3 4]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1], [2], [3]])\n",
    "b = np.array([[2], [3], [4]])\n",
    "print(np.vstack((a, b)))\n",
    "print(np.hstack((a, b)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]]\n",
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1, 2], [3, 4]])\n",
    "b = np.array([[5, 6]])\n",
    "print(np.vstack((a, b)))\n",
    "print(np.concatenate((a, b), axis = 0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `split`, `vsplit` and `hsplit`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[array([ 0.,  1.,  2.]), array([ 3.,  4.,  5.]), array([ 6.,  7.,  8.])]\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(9.0)\n",
    "print(np.split(x, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[array([ 0.,  1.,  2.]), array([ 3.,  4.,  5.]), array([ 6.,  7.,  8.])]\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(9.0)\n",
    "print(np.hsplit(x, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  0.   1.   2.   3.]\n",
      " [  4.   5.   6.   7.]\n",
      " [  8.   9.  10.  11.]\n",
      " [ 12.  13.  14.  15.]]\n",
      "[array([[ 0.,  1.,  2.,  3.],\n",
      "       [ 4.,  5.,  6.,  7.]]), array([[  8.,   9.,  10.,  11.],\n",
      "       [ 12.,  13.,  14.,  15.]])]\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(16.0).reshape(4, 4)\n",
    "print(x)\n",
    "print(np.vsplit(x, 2))"
   ]
  }
 ],
 "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.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}