Numpy/1. Numpy Foundation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://www.tutorialspoint.com/numpy/index.htm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "NumPy, which stands for Numerical Python, is a library consisting of multidimensional array objects and a collection of routines for processing those arrays. Using NumPy, mathematical and logical operations on arrays can be performed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NumPy - Ndarray Object"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)\n",
    "\n",
    "object: Any object exposing the array interface method returns an array, or any (nested) sequence.\t\n",
    "dtype: Desired data type of array, optional\t\n",
    "copy: Optional. By default (true), the object is copied\t\n",
    "order: C (row major) or F (column major) or A (any) (default)\n",
    "subok: By default, returned array forced to be a base class array. If true, sub-classes passed through\n",
    "ndmin: Specifies minimum dimensions of resultant array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np \n",
    "a = np.array([[1, 2], [3, 4]]) \n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.+0.j 2.+0.j 3.+0.j]\n"
     ]
    }
   ],
   "source": [
    "# dtype parameter \n",
    "import numpy as np \n",
    "a = np.array([1, 2, 3], dtype = complex) \n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NumPy - Data Types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Data Types & Description\n",
    "\n",
    "- bool_: Boolean (True or False) stored as a byte\n",
    "- int_: Default integer type (same as C long; normally either int64 or int32)\n",
    "- intc: Identical to C int (normally int32 or int64)\n",
    "- intp: Integer used for indexing (same as C ssize_t; normally either int32 or int64)\n",
    "- int8: Byte (-128 to 127)\n",
    "- int16: Integer (-32768 to 32767)\n",
    "- int32: Integer (-2147483648 to 2147483647)\n",
    "- int64: Integer (-9223372036854775808 to 9223372036854775807)\n",
    "- uint8: Unsigned integer (0 to 255)\n",
    "- uint16: Unsigned integer (0 to 65535)\n",
    "- uint32: Unsigned integer (0 to 4294967295)\n",
    "- uint64: Unsigned integer (0 to 18446744073709551615)\n",
    "- float_: Shorthand for float64\n",
    "- float16: Half precision float: sign bit, 5 bits exponent, 10 bits mantissa\n",
    "- float32: Single precision float: sign bit, 8 bits exponent, 23 bits mantissa\n",
    "- float64: Double precision float: sign bit, 11 bits exponent, 52 bits mantissa\n",
    "- complex_: Shorthand for complex128\n",
    "- complex64: Complex number, represented by two 32-bit floats (real and imaginary components)\n",
    "- complex128: Complex number, represented by two 64-bit floats (real and imaginary components)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "int32\n"
     ]
    }
   ],
   "source": [
    "# using array-scalar type \n",
    "import numpy as np \n",
    "dt = np.dtype(np.int32) \n",
    "print(dt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('age', 'i1')]\n"
     ]
    }
   ],
   "source": [
    "# first create structured data type \n",
    "import numpy as np \n",
    "dt = np.dtype([('age',np.int8)]) \n",
    "print(dt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(10,) (20,) (30,)]\n"
     ]
    }
   ],
   "source": [
    "# now apply it to ndarray object \n",
    "import numpy as np \n",
    "\n",
    "dt = np.dtype([('age',np.int8)]) \n",
    "a = np.array([(10,),(20,),(30,)], dtype = dt) \n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10 20 30]\n"
     ]
    }
   ],
   "source": [
    "# file name can be used to access content of age column \n",
    "import numpy as np \n",
    "\n",
    "dt = np.dtype([('age',np.int8)]) \n",
    "a = np.array([(10,),(20,),(30,)], dtype = dt) \n",
    "print(a['age'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NumPy - Array Attributes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ndarray.shape: returns a tuple consisting of array dimensions. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 3)\n"
     ]
    }
   ],
   "source": [
    "import numpy as np \n",
    "a = np.array([[1,2,3],[4,5,6]]) \n",
    "print(a.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]]\n"
     ]
    }
   ],
   "source": [
    "# this resizes the ndarray \n",
    "import numpy as np \n",
    "\n",
    "a = np.array([[1,2,3],[4,5,6]]) \n",
    "a.shape = (3,2) \n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np \n",
    "a = np.array([[1,2,3],[4,5,6]]) \n",
    "b = a.reshape(3,2) \n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### ndarray.ndim\n",
    "returns the number of array dimensions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "[[[ 0  1  2]\n",
      "  [ 3  4  5]\n",
      "  [ 6  7  8]\n",
      "  [ 9 10 11]]\n",
      "\n",
      " [[12 13 14]\n",
      "  [15 16 17]\n",
      "  [18 19 20]\n",
      "  [21 22 23]]]\n"
     ]
    }
   ],
   "source": [
    "# this is one dimensional array \n",
    "import numpy as np \n",
    "a = np.arange(24) \n",
    "print(a.ndim)\n",
    "\n",
    "# now reshape it \n",
    "b = a.reshape(2,4,3) \n",
    "print(b)\n",
    "# b is having three dimensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### NumPy - Array From Existing Data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### numpy.asarray\n",
    "This function is similar to numpy.array except for the fact that it has fewer parameters.\n",
    "numpy.asarray(a, dtype = None, order = None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "a: Input data in any form such as list, list of tuples, tuples, tuple of tuples or tuple of lists\n",
    "dtype: By default, the data type of input data is applied to the resultant ndarray\n",
    "order: C (row major) or F (column major). C is default"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1. 2. 3.]\n"
     ]
    }
   ],
   "source": [
    "# dtype is float \n",
    "import numpy as np \n",
    "\n",
    "x = [1,2,3]\n",
    "a = np.asarray(x, dtype = float) \n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n"
     ]
    }
   ],
   "source": [
    "# ndarray from tuple \n",
    "import numpy as np \n",
    "\n",
    "x = (1,2,3) \n",
    "a = np.asarray(x) \n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NumPy - Indexing & Slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Contents of ndarray object can be accessed and modified by indexing or slicing\n",
    "Three types of indexing methods are available − field access, basic slicing and advanced indexing.\n",
    "A Python slice object is constructed by giving start, stop, and step parameters to the built-in slice function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n",
      "[2 4 6]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np \n",
    "a = np.arange(10) \n",
    "print(a)\n",
    "s = slice(2,7,2) \n",
    "print(a[s])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The same result can also be obtained by giving the slicing parameters separated by a colon : (start:stop:step) directly to the ndarray object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n",
      "[2 4 6]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np \n",
    "a = np.arange(10) \n",
    "print(a)\n",
    "b = a[2:7:2] \n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 3 4 5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "# slice items starting from index \n",
    "import numpy as np \n",
    "a = np.arange(10) \n",
    "print(a[2:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 3 4]\n"
     ]
    }
   ],
   "source": [
    "# slice items between indexes \n",
    "import numpy as np \n",
    "a = np.arange(10) \n",
    "print(a[2:5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [3 4 5]\n",
      " [4 5 6]]\n",
      "Now we will slice the array from the index a[1:]\n",
      "[[3 4 5]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np \n",
    "a = np.array([[1,2,3],[3,4,5],[4,5,6]]) \n",
    "print(a)\n",
    "\n",
    "# slice items starting from index\n",
    "print('Now we will slice the array from the index a[1:]')\n",
    "print(a[1:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Our array is:\n",
      "[[1 2 3]\n",
      " [3 4 5]\n",
      " [4 5 6]]\n",
      "\n",
      "\n",
      "The items in the second column are:\n",
      "[2 4 5]\n",
      "\n",
      "\n",
      "The items in the second row are:\n",
      "[3 4 5]\n",
      "\n",
      "\n",
      "The items column 1 onwards are:\n",
      "[[2 3]\n",
      " [4 5]\n",
      " [5 6]]\n"
     ]
    }
   ],
   "source": [
    "# array to begin with \n",
    "import numpy as np \n",
    "a = np.array([[1,2,3],[3,4,5],[4,5,6]]) \n",
    "\n",
    "print('Our array is:')\n",
    "print(a)\n",
    "print('\\n')  \n",
    "\n",
    "# this returns array of items in the second column \n",
    "print('The items in the second column are:' )\n",
    "print(a[...,1] )\n",
    "print('\\n' )\n",
    "\n",
    "# Now we will slice all items from the second row \n",
    "print ('The items in the second row are:' )\n",
    "print (a[1,...]) \n",
    "print ('\\n'  )\n",
    "\n",
    "# Now we will slice all items from column 1 onwards \n",
    "print ('The items column 1 onwards are:' )\n",
    "print (a[...,1:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NumPy - Advanced Indexing\n",
    "Advanced indexing always returns a copy of the data. As against this, the slicing only presents a view.\n",
    "\n",
    "There are two types of advanced indexing − Integer and Boolean.\n",
    "### Integer Indexing\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 4 5]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np \n",
    "\n",
    "x = np.array([[1, 2], [3, 4], [5, 6]]) \n",
    "y = x[[0,1,2], [0,1,0]] \n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "y = x[rows,cols]\n",
    "[0,1,2]: row1, row2, row3\n",
    "[0,1,0]:\n",
    "The selection includes elements at (0,0), (1,1) and (2,0) from the first array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Our array is:\n",
      "[[ 0  1  2]\n",
      " [ 3  4  5]\n",
      " [ 6  7  8]\n",
      " [ 9 10 11]]\n",
      "\n",
      "\n",
      "The corner elements of this array are:\n",
      "[[ 0  2]\n",
      " [ 9 11]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np \n",
    "x = np.array([[ 0,  1,  2],[ 3,  4,  5],[ 6,  7,  8],[ 9, 10, 11]]) \n",
    "   \n",
    "print('Our array is:' )\n",
    "print(x )\n",
    "print('\\n' )\n",
    "\n",
    "rows = np.array([[0,0],[3,3]])\n",
    "cols = np.array([[0,2],[0,2]]) \n",
    "y = x[rows,cols] \n",
    "   \n",
    "print('The corner elements of this array are:' )\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Our array is:\n",
      "[[ 0  1  2]\n",
      " [ 3  4  5]\n",
      " [ 6  7  8]\n",
      " [ 9 10 11]]\n",
      "\n",
      "\n",
      "[[1 0]\n",
      " [2 3]]\n",
      "The corner elements of this array are:\n",
      "[[ 4  1]\n",
      " [ 6 11]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np \n",
    "x = np.array([[ 0,  1,  2],[ 3,  4,  5],[ 6,  7,  8],[ 9, 10, 11]]) \n",
    "   \n",
    "print('Our array is:' )\n",
    "print(x )\n",
    "print('\\n')\n",
    "\n",
    "rows = np.array([[1,0],[2,3]])\n",
    "cols = np.array([[1,1],[0,2]]) \n",
    "\n",
    "print(rows)\n",
    "\n",
    "y = x[rows,cols] \n",
    "   \n",
    "print('The corner elements of this array are:' )\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The row, column indices of selection are [1, 1] , [0,1], [2,0] and [3,2]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Our array is:\n",
      "[[ 0  1  2]\n",
      " [ 3  4  5]\n",
      " [ 6  7  8]\n",
      " [ 9 10 11]]\n",
      "\n",
      "\n",
      "After slicing, our array becomes:\n",
      "[[ 4  5]\n",
      " [ 7  8]\n",
      " [10 11]]\n",
      "\n",
      "\n",
      "Slicing using advanced index for column:\n",
      "[[ 3  4]\n",
      " [ 6  7]\n",
      " [ 9 10]]\n",
      "=======\n",
      "[[ 4  5]\n",
      " [ 7  8]\n",
      " [10 11]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np \n",
    "x = np.array([[ 0,  1,  2],[ 3,  4,  5],[ 6,  7,  8],[ 9, 10, 11]]) \n",
    "\n",
    "print('Our array is:')\n",
    "print (x )\n",
    "print ('\\n'  )\n",
    "\n",
    "# slicing \n",
    "z = x[1:4,1:3] \n",
    "\n",
    "print ('After slicing, our array becomes:' )\n",
    "print (z )\n",
    "print ('\\n'  )\n",
    "\n",
    "# using advanced index for column \n",
    "y1 = x[1:4,[0,1]] \n",
    "y2 = x[1:4,[1,2]] \n",
    "print ('Slicing using advanced index for column:' )\n",
    "print (y1)\n",
    "print ('=======')\n",
    "print (y2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Boolean Array Indexing\n",
    "items greater than 5 are returned as a result of Boolean indexing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Our array is:\n",
      "[[ 0  1  2]\n",
      " [ 3  4  5]\n",
      " [ 6  7  8]\n",
      " [ 9 10 11]]\n",
      "The items greater than 5 are:\n",
      "[ 6  7  8  9 10 11]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np \n",
    "x = np.array([[ 0,  1,  2],[ 3,  4,  5],[ 6,  7,  8],[ 9, 10, 11]]) \n",
    "\n",
    "print('Our array is:') \n",
    "print(x) \n",
    "\n",
    "# Now we will print the items greater than 5 \n",
    "print('The items greater than 5 are:' )\n",
    "print(x[x > 5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ex2: In this example, NaN (Not a Number) elements are omitted by using ~ (complement operator)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1. 2. 3. 4. 5.]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np \n",
    "a = np.array([np.nan, 1,2,np.nan,3,4,5]) \n",
    "print(a[~np.isnan(a)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ex3: The following example shows how to filter out the non-complex elements from an array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2. +6.j 3.5+5.j]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np \n",
    "a = np.array([1, 2+6j, 5, 3.5+5j]) \n",
    "print(a[np.iscomplex(a)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NumPy - Broadcasting\n",
    "broadcasting refers to the ability of NumPy to treat arrays of different shapes during arithmetic operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 10  40  90 160]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np \n",
    "\n",
    "a = np.array([1,2,3,4]) \n",
    "b = np.array([10,20,30,40]) \n",
    "c = a * b \n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Broadcasting is possible if the following rules are satisfied \n",
    "- Array with smaller ndim than the other is prepended with '1' in its shape.\n",
    "- Size in each dimension of the output shape is maximum of the input sizes in that dimension.\n",
    "- An input can be used in calculation, if its size in a particular dimension matches the output size or its value is exactly 1.\n",
    "- If an input has a dimension size of 1, the first data entry in that dimension is used for all calculations along that dimension.\n",
    "\n",
    "A set of arrays is said to be broadcastable if the above rules produce a valid result and one of the following is true −\n",
    "- Arrays have exactly the same shape.\n",
    "- Arrays have the same number of dimensions and the length of each dimension is either a common length or 1.\n",
    "- Array having too few dimensions can have its shape prepended with a dimension of length 1, so that the above stated property is true."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First array:\n",
      "[[ 0.  0.  0.]\n",
      " [10. 10. 10.]\n",
      " [20. 20. 20.]\n",
      " [30. 30. 30.]]\n",
      "\n",
      "\n",
      "Second array:\n",
      "[1. 2. 3.]\n",
      "\n",
      "\n",
      "First Array + Second Array\n",
      "[[ 1.  2.  3.]\n",
      " [11. 12. 13.]\n",
      " [21. 22. 23.]\n",
      " [31. 32. 33.]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np \n",
    "a = np.array([[0.0,0.0,0.0],[10.0,10.0,10.0],[20.0,20.0,20.0],[30.0,30.0,30.0]]) \n",
    "b = np.array([1.0,2.0,3.0])  \n",
    "   \n",
    "print('First array:') \n",
    "print(a)\n",
    "print('\\n')  \n",
    "   \n",
    "print('Second array:')\n",
    "print(b)\n",
    "print('\\n')  \n",
    "   \n",
    "print('First Array + Second Array')\n",
    "print(a + b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}