Numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NumPy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "The NumPy library provides support for arrays, matricies and mathematical functions to operate on them. We'll start with the basics and then cover a few more advanced topics."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The N-dimensional array (ndarray) and array basics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The core of NumPy is the n-dimensional array (ndarray). Although it may seem similar to Python lists or the array.array class, there are some important differences. ndarrays ...\n",
    "\n",
    "+ are homogenous, all elements must be of the same type (unlike list)\n",
    "+ can be multidimensional (unlike array.array)\n",
    "+ have much more functionality\n",
    "\n",
    "We'll dive in with an example. The arange function is analogous to Python's range function, while reshape does exactly what you would expect and reshapes an array into a specified shape.\n",
    "\n",
    "+ ndarray.ndim: number of dimensions or rank\n",
    "+ ndarray.shape: tuple containing the dimensions of the array\n",
    "+ ndarray.dtype: data type of elements\n",
    "+ ndarray.size: total number of elements (product of dimensions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(20).reshape(5,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arrays creation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arrays can be created from lists or tuples using the array method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.array([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.array([[1,2,3], [4,5,6], [7,8,9]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy provides functions for creating arrays of arbitrary dimensions containing all zeros or ones. Note that the argument is a tuple of dimensions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.zeros( (3,4) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.ones ( (5,3) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The zeros_like and ones_like functions create arrays filled with zeros or ones, respectively, of the same shape as the argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(20).reshape(5,4)\n",
    "np.zeros_like(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(12).reshape(6,2)\n",
    "np.ones_like(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Printing arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we've seen, arrays can be printed using the built-in print function. To avoid cluttering you screen, only the top and bottom of very large arrays are displayed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(10000).reshape(2000,5)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Array math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Basic math operations are performed elementwise on conforming arrays (arrays of the same shape). Scalar arguments are applied to each element\n",
    "\n",
    "Universal functions (ufunc) are applied to each element. Note in the examples below that we did not need to use the map function since the NumPy ufuncs are designed to operate on ndarray arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(9).reshape(3,3)\n",
    "b = np.arange(9,18).reshape(3,3)\n",
    "print(a)\n",
    "print()\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a+b + 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the \"\\*\" operator does an elementwise multiplication and is not the linear algebra matrix multiply"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a*b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.sin(a) + np.log(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A brief digression - how would we have done this with lists?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arithmetic on Python lists doesn't work the way you might expect. Let's define a couple of conformable lists and add them element by element. Sounds easy enough"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [ 1,  2,  3]\n",
    "b = [10, 20, 30]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a+b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's not what we wanted. The '+' operator concatenates the elements of the two lists to create a new list with length equal to the sum of the lengths of the original lists. There are multiple ways we can do this, two based on map are shown below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from operator import add\n",
    "list(map(add, a, b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(map(lambda x,y: x+y, a, b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The second choice is more general since we're not limited to simply adding the elements. Of course, if you're going to be doing a lot of this sort of thing, just use numpy arrays."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sum, min, max, argmin, argmax, cumsum"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The ndarray class has methods for finding the min and max values in an array, their locations (argmin and argmax), the sum and the cumulative sum. When applied to multidimensional arrays, the array is first flattened into a 1d array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(123)\n",
    "a = np.random.rand(6)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Min :\", a.min())\n",
    "print(\"Max :\", a.max())\n",
    "print(\"Sum :\", a.sum())\n",
    "print(\"Argmin :\", a.argmin())\n",
    "print(\"Argmax :\", a.argmax())\n",
    "\n",
    "print(\"\\nCumlative sum :\\n\", a.cumsum())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For multidimensional arrays, many of these functions can take an argument specifying the axis along which the operations should be applied. The result is an array of dimension one lower than the array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(123)\n",
    "a = np.random.rand(16).reshape(4,4)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# By column (axis = 0)\n",
    "print(\"Min :\", a.min(axis=0))\n",
    "print(\"Max :\", a.max(axis=0))\n",
    "print(\"Sum :\", a.sum(axis=0))\n",
    "print(\"Argmin :\", a.argmin(axis=0))\n",
    "print(\"Argmax :\", a.argmax(axis=0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# By row (axis = 1)\n",
    "print(\"Min :\", a.min(axis=1))\n",
    "print(\"Max :\", a.max(axis=1))\n",
    "print(\"Sum :\", a.sum(axis=1))\n",
    "print(\"Argmin :\", a.argmin(axis=1))\n",
    "print(\"Argmax :\", a.argmax(axis=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# By entire array \n",
    "# Note that argmin/max returns index for flattened array (row major order)\n",
    "print(\"Min :\", a.min())\n",
    "print(\"Max :\", a.max())\n",
    "print(\"Sum :\", a.sum())\n",
    "print(\"Argmin :\", a.argmin())\n",
    "print(\"Argmax :\", a.argmax())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Stacking and splitting arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy provides methods for stacking arrays (hstack, vstack) and splitting arrays (hsplit, vsplit). The stacking methods take as input a tuple containing an arbitrary number of arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(16).reshape(4,4)\n",
    "b = np.arange(16,32).reshape(4,4)\n",
    "print(a)\n",
    "print()\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.vstack( (a,b) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = np.hstack( (a,b,a,b) )\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(d, e) = np.hsplit(c,(3,))\n",
    "print(d)\n",
    "print()\n",
    "print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Copies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Be aware that ndarrays behave the same way as other Python objects when doing a simple assignment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(4)\n",
    "b = a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a)\n",
    "b[0] = 7\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you really want to copy an array, use the copy method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(4)\n",
    "b = a.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a)\n",
    "b[0] = 7\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Histograms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Although most plotting packages have the capabilities to directly generate a histogram from a data set, sometimes you just want the result and not the plot. This can be done using the NumPy histogram method. In its simplest form, the method just takes an array and the number of bins"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mu, sigma = 2, 0.5\n",
    "v = np.random.normal(mu,sigma,10000)\n",
    "(hist, bin_edges) = np.histogram(v, bins=50)\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "plt.plot(.5*(bin_edges[1:]+bin_edges[:-1]), hist)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Linear algebra"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy provides a comprehensive set of linear algebra capabilities. We demonstrate a few of these below. A convenient summary of of these capabilities can be found here https://docs.scipy.org/doc/numpy-1.13.0/reference/routines.linalg.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this first example, we calculate the inverse of a matrix and then confirm that the product of the matrix and its inverse is equal to the identity matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.random.rand(4,4)      # Populate matrix with random values\n",
    "Ainv = np.linalg.inv(A)      # Calculate the inverse\n",
    "I = np.eye(4)                # Identity matrix used for testing \n",
    "AxAinv = np.matmul(A, Ainv)  # Matrix multiplication\n",
    "np.all(AxAinv == I)          # Test if all elements of A x Ainv are true"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What happened? Wouldn't we expect the matrix multipied by its inverse to be equal to the identity matrix? Let's take a look at the content of the arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Matrix A\")\n",
    "print(A, \"\\n\")\n",
    "print(\"Inverse of matrix A\")\n",
    "print(Ainv, \"\\n\")\n",
    "print(\"Product A x Ainv\")\n",
    "print(AxAinv, \"\\n\")\n",
    "print(\"Identity matrix\")\n",
    "print(I)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We forgot to take into account the fact that floating point math involves rounding errors. Fortunately, these floating point comparisons are so common that numpy provides a function for testing whether results agree to within a tolerance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.allclose(AxAinv, I)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a second example, we'll solve the eigenvalue problem Hx = λx and confirm that the sum over the eigenvalues is equal to the trace of the matrix. Don't worry if you're unfamiliar with eigenvalue problems. These come up in many scientific and engineering problems and are used in the machine learning technique principal component analysis (PCA)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eigvals = np.linalg.eigvals(A)\n",
    "eigvals_sum = eigvals.sum()\n",
    "trace = np.trace(A)\n",
    "np.allclose(eigvals_sum, trace)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Random sampling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy contains an extensive set of functions for generating samplings from random distributions. For the full set of functions, see https://docs.scipy.org/doc/numpy-1.13.0/reference/routines.random.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The random.rand() function returns an array of floating point values between 0 ≤ x < 1, with the argument specifying the dimensions of the array. We saw this earlier, in the discussion of linear algeba funcions, but without explanation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.rand(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.rand(4,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.rand(3,3,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "random.randimt(low, [,high ,size]) generates random integers between low (inclusive) and high (exclusive), with size setting the number of random integers returned"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.randint(1,7,100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "random.randn() samples a normal distribution with mean 0 and standard deviation 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.randn(5,5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To convert to a normal distribution with a different mean ($\\mu$) and standard deviation ($\\sigma$), multiply results by sigma and add mu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sigma, mu = 0.5, 5\n",
    "np.random.randn(25)*sigma + mu"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "random.binomial(n,p [,size]) samples a binomial distribution with n trials, probability p. A third optional argument (size) specifies the number of samples to be generated"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This will return the number of heads from six (n) flips of a fair coin (p)\n",
    "n, p = 6, 0.5\n",
    "np.random.binomial(n, p, 100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Many machine learning applications require that we either permute the data or draw a subsample of the data. This can be done with random.permutation() and random.choice() functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate permutations of a list\n",
    "x = np.array(['a', 'b', 'c', 'd', 'e'])\n",
    "for i in range(10):\n",
    "    print(np.random.permutation(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Random select 4 elemnts from a list with replacement allowed\n",
    "y = np.array(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])\n",
    "for i in range(10):\n",
    "    print(np.random.choice(y, 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Random select 4 elemnts from a list without replacement\n",
    "y = np.array(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])\n",
    "for i in range(10):\n",
    "    print(np.random.choice(y, 4, replace=False))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A brief digression: Python collections - High-performance container datatypes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We've already explored Python's major built in data types: lists, dictionaries, sets and tuples. The collections package adds some additional containers such as Counter, OrderedDict, and dequeue. We'll take a look at a few of these here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import collections"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Counter container is a dict subclass for counting hashable objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist = ['A', 'B', 'C', 'D', 'A', 'A', 'A', 'B', 'C']\n",
    "collections.Counter(mylist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The deque (pronounced \"deck\") is a double-ended queue that allows pushing and popping data onto either end."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mydeq = collections.deque(['C','D','E'])\n",
    "mydeq.append('F')\n",
    "mydeq.appendleft('B')\n",
    "mydeq"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The OrderedDict container has all the properties of a Python dict except that the order in which items (key-value pairs) are added is preserved. Recall that order is not guaranteed for the standard built-in dictionary type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myord = collections.OrderedDict({'A':1, 'B':2, 'C':3})\n",
    "myord"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Back to sampling - choosing elements from an uneven probability distribution"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An especially useful feature of np.random.choice is the ability to choose elements from an uneven probability distribution. This might arise, for example, in bioinformatics applications where we want to select amino acids with the probabilities that they appear in an organism."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import Counter\n",
    "\n",
    "x = ['A', 'B', 'C']\n",
    "probs = [0.1, 0.2, 0.7]\n",
    "sampling = np.random.choice(x, size=10000, p=probs)\n",
    "Counter(sampling)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you really need your distribution of elements to exactly match the probability distribution and have a random ordering, just create a list and then apply the permutation operation. Note that we took advantage of the way that list addition really works to create a list containing the correct numbers of A, B and C."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = ['A']*10 + ['B']*5 + ['C']*10\n",
    "np.random.permutation(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Counter(np.random.permutation(x))"
   ]
  },
  {
   "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}