{ "cells": [ { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Astronomical data analysis using Python\n", "===\n", "\n", "Lecture 6\n", "-------" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# List Comprehension " ] }, { "cell_type": "code", "execution_count": 61, "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['Pune', 'Mumbai', 'Gauhati']\n" ] } ], "source": [ "cities = [\"Pune\", \"Mumbai\", \"Delhi\", \"Gauhati\", \"Chennai\"]\n", "newlist = []\n", "\n", "for x in cities:\n", " if \"u\" in x:\n", " newlist.append(x)\n", "\n", "print(newlist)" ] }, { "cell_type": "code", "execution_count": 55, "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['Pune', 'Mumbai', 'Gauhati']\n" ] } ], "source": [ "cities = [\"Pune\", \"Mumbai\", \"Delhi\", \"Gauhati\", \"Chennai\"]\n", "\n", "newlist = [x for x in cities if \"u\" in x]\n", "\n", "print(newlist)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# List comprehension syntax\n", "\n", "`newlist = [expression for item in iterable if condition == True]`\n", "\n", "The old list remains unchanged in the list comprehension. The iterable can be any iterable including a list. The if condition is optional." ] }, { "cell_type": "code", "execution_count": 60, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[4, 5, 6]\n" ] } ], "source": [ "newlist = [x for x in range(10) if (x < 7) & (x >3)]\n", "print (newlist)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# Nested lists" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]\n" ] } ], "source": [ "k = [ (i,j) for i in range(3) for j in range(3) ]\n", "print (k)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# List Comprehensions - Dos and Donts\n", "\n", "For simple for-loops like we saw earlier, you SHOULD use list comprehensions.\n", "In fact, list comprehensions run faster than traditional loops.\n", "\n", "But,\n", "\n", "List comprehensions, especially nested ones, can obfuscate code.\n", "In such a case, it's better to use elaborate loops." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# Installing third party modules\n", "\n", "See the instructions at:\n", "\n", "https://docs.python.org/3/installing/index.html\n", "\n", "Please install `numpy, scipy, matplotlib, astropy, astroquery` modules on your computer.\n", "Except for `astroquery` all modules are also available in Google Colab. Even astroquery can be installed on Google Colab using `!pip install astroquery`\n", "\n" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# Python data processing using lists is very slow\n", "\n", "Compared to compiled languages, for loops in Python run extremely slowly. The alternative is to define a more restrictive data structure than a list - **a numpy array**. Unlike lists, a numpy array contains data of only one type.\n", "\n", "In exchange for this restriction, numpy arrays provide for unprecendented speed and convenience and make numerical computation practically possible in Python. The high speed of numpy is due to the fact that its underlying, highly optimised code is written in C.\n", "\n", "**All scientific and technical computing in Python today makes use of `numpy` in one way or another.**" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Adding two arrays - the slow Python way\n", "===" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1, 2, 4, 4, 8, 6]\n" ] } ], "source": [ "l1=[1,2,4]; l2=[4,8,6]\n", "print (l1+l2)\n" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[5, 10, 10]\n" ] } ], "source": [ "l3 = [0]*3\n", "for i in range(3):\n", " l3[i] = l1[i] +l2[i]\n", " \n", "print (l3)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "What we ideally want\n", "===" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "We want `print (l1+l2)` to give us `[5,10,10]`\n", "\n", "Such behaviour is common in Fortran 90, Matlab, IDL" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Creating an n-dimensional array - numpy.ndarray\n", "===" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1.19.5\n", "\n", "\n" ] } ], "source": [ "import numpy as np\n", "print (np.version.version)\n", "\n", "a = np.array([1,2,3]) # Argument to np.array can be a list\n", "b = np.array((1,2,3)) # or a tuple\n", "print (type(a))\n", "print (type(b))\n" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Adding Arrays with numpy\n", "===" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1, 2, 3, 4, 5, 6]\n", "[5 7 9]\n" ] } ], "source": [ "l1 = [1,2,3]\n", "l2=[4,5,6]\n", "a1 = np.array(l1)\n", "a2 = np.array(l2)\n", "print (l1+l2)\n", "print (a1+a2)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Arithmetic operations in numpy\n", "===" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[5 7 9]\n", "[-3 -3 -3]\n", "[ 4 10 18]\n", "[0.25 0.4 0.5 ]\n", "[0 1 0]\n", "[1 4 9]\n" ] } ], "source": [ "print (a1+a2) # addition\n", "print (a1-a2) # substraction\n", "print (a1*a2) # multiplication\n", "print (a1/a2) # division\n", "print (a2%a1) # modulo\n", "print (a1**2) # elementwise squared" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Numpy ufuncs\n", "===" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "add (+) log greater (>) subtract (-) log10 greater_equal ($>=$)\n", "\n", "multiply (*) cos less (<) divide (/) arcos less_equal (<=)\n", "\n", "remainder (%) sin logical_and absolute abs arcsin logical_or\n", "\n", "floor tan logical_xor ceil arctan bitwise_and (&)\n", "\n", "fmod cosh bitwise_or (|) conjugate sinh bitwise_xor (^)\n", "\n", "minimum tanh bitwise_not (~) maximum sqrt rshift (>>)\n", "\n", "power (**) equal (==) lshift (<<) exp not_equal (!=)\n" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Why is an array not a list?\n", "===" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "A numpy array is a table of elements (usually numbers),\n", "all of the __same__ type." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Implicit and explicit datatype declaration\n", "===" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "int64\n", "float64\n", "complex128\n" ] } ], "source": [ "import numpy as np\n", "ai = np.array([1, 2, 3])\n", "af = np.array([1, 2, 3.])\n", "ac = np.array([1j, 2, 3.])\n", "print (ai.dtype)\n", "print (af.dtype)\n", "print (ac.dtype)\n", "af = np.array([1,2,3], float)\n", "ac = np.array([1,2,3], complex)\n", "afn = np.array([1,2], np.float) # numpy float type\n" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Numpy float datatypes\n", "===" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "* `np.float` (== Python float type)\n", "* `np.float32` (single precision)\n", "* `np.float64` (double precision)\n", "* `np.double` (synonym, double prec.)\n", "* `np.longdouble` (very platform dependent !!! np.float96 or np.float128)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Other numpy datatypes\n", "===" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "* Integer datatypes `np.int8 ...int16 ...int32 ...int64`\n", "* Unsigned (!) integer datatypes `np.uint8 ...uint16 ...uint32 ...uint64`\n", "* Complex datatypes `np.complex64 ...complex128...complex256`\n", "* Boolean `np.bool`\n" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Defining your own datatypes\n", "===\n" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ 0 100]\n", "[ True False]\n", "100\n", "True\n" ] } ], "source": [ "dt= np.dtype([('value',np.int),('status',np.bool)])\n", "a = np.array([(0,True),(100,False)],dtype=dt)\n", "print (a['value'])\n", "print (a['status'])\n", "print (a['value'][1])\n", "print (a[0]['status'])\n" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "Structured arrays are sometimes quite useful for reading binary data." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Convenience functions to create arrays\n", "===" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[0. 0. 0.]\n", "[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]\n", "[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]\n", "[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", "[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]\n" ] } ], "source": [ "z = np.zeros(3)\n", "print (z)\n", "o = np.ones(10)\n", "print (o)\n", "e = np.empty(10) # very fast, use only if array elements are guaranteed to be initialised\n", "print (e) # uninitialised values, could be anything!(y)\n", "print (np.zeros_like(e))\n", "print (np.ones_like(e))\n" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Multidimensional Arrays\n", "===" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[1, 2, 3], [4, 5, 6]]\n", "[[1 2 3]\n", " [4 5 6]]\n" ] } ], "source": [ "l2 = [[1,2,3],[4,5,6]]\n", "a2 = np.array(l2)\n", "print (l2)\n", "print (a2)\n", " " ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Swapping of axes\n", "===" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "Note that, like C (and unlike FORTRAN), Python is 0-indexed and the\n", "indices have the slowest axis first and fast axis last, i.e. for a 2-D\n", "image, the fast axis (X-axis) which corresponds to the FITS NAXIS1\n", "keyword, is the second index.\n", "\n", "How best to handle this?\n" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Accessing Arrays\n", "===" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2\n", "2\n", "2\n", "[2 3]\n", "[1 4]\n" ] } ], "source": [ "print l2[0][1]\n", "print a2[0][1]\n", "print a2[0,1] # works only with\n", "print a2[0,1:] # arrays !!!\n", "print a2[:,0] #\n" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Determine size and shape\n", "===" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2 3\n", "2 3\n", "(2, 3)\n" ] } ], "source": [ "# determine the dimensions\n", "# remember: l2=[[1,2,3],[4,5,6]]\n", "# how many rows, how many columns ?\n", "\n", "print len(l2), len(l2[0])\n", "\n", "print len(a2), len(a2[0])\n", "\n", "print a2.shape # shape attribute\n" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Array attributes\n", "===" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "* `array.ndim`: number of dimensions\n", "* `array.shape`: the dimensions\n", "* `array.size`: total number of elements\n", "* `array.dtype`: type of the data\n" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Initialising multidimensional arrays\n", "===" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [], "source": [ "# np.zeros, np.ones, et al.\n", "# can be used to create multidim\n", "# arrays, too !\n", "\n", "o = np.ones( (3,10) )\n", "\n", "e = np.empty( (4,2,19), float)\n" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Convenience functions\n", "===" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [], "source": [ "b = np.linspace(-2.5,1.5,17)\n", "\n", "# 17 equally spaced numbers from -2.5 to 1.5\n", "# including the boundary values !\n", "\n", "c = np.arange(-2.5,1.51,0.25) \n", "# Unreliable because upperbound excluded, rounding errors, use linspace\n", "\n", "x = np.linspace(0, 3.14, 100)\n", "\n", "m = np.logspace(-2,3,9) # special for astronomers!\n", "\n", "y = np.sin(x)\n" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Slicing in numpy\n", "===" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[]\n", "[[0. 0. 0. 0.]\n", " [0. 0. 0. 0.]\n", " [0. 0. 1. 1.]\n", " [0. 0. 1. 1.]]\n", "[[2. 2. 2. 2.]\n", " [0. 0. 0. 0.]\n", " [0. 0. 1. 1.]\n", " [0. 0. 1. 1.]]\n", "[[2. 5. 5. 2.]\n", " [0. 3. 3. 0.]\n", " [0. 3. 4. 1.]\n", " [0. 3. 4. 1.]]\n" ] } ], "source": [ "a = np.zeros( (4,4) )\n", "\n", "print (a[2:4][2:4]) # does this work? no.\n", "\n", "a[2:4,2:4] = 1 # Works\n", "print (a)\n", "a[0] = 2\n", "print (a)\n", "a[:,1:3] += 3\n", "print (a)\n", "# the array shape is unaltered by\n", "# these operations\n" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Rows and columns\n", "===" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[4. 4. 4. 4.]\n" ] } ], "source": [ "a = np.zeros( (4,4) )\n", "\n", "# accessing rows and columns\n", "\n", "a[0,:] # the first row\n", "\n", "a[0] = 4 # the first row set to 4\n", "\n", "# read a[i,...] as\n", "# a[i,]\n", "# this is a specific numpy notation\n", "\n", "print (a[0,...])\n", "\n", "a[:,1] = 5 # the second column\n", "\n", "a[:,-1] = 6 # the last column\n" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "numpy ASCII file reading - obsoleted by astropy.io.ascii\n", "===" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "fname = 'myfile.dat'\n", "\n", "data = np.loadtxt(fname)\n", "\n", "c24 = np.loadtxt(fname,usecols=(1,3)) # to select columns\n", "\n", "n,w,x,y,z = np.loadtxt(fname,unpack = True)\n", "\n", "w,y = np.loadtxt(fname,usecols=(1,3), unpack=True)\n", "\n", "fname2 = 'mydata2.dat' # a different data file\n", "\n", "data2 = np.loadtxt(fname2,delimiter='/', comments='!',skiprows=3) \n", "\n", "# default for comments is '#'\n", "\n", "np.savetxt('result.dat', res,fmt='\\%d :\\\\t \\%.6f')" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Saving/Loading binary arrays\n", "===" ] }, { "cell_type": "code", "execution_count": 26, "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[0 1 2 3 4 5 6 7 8 9]\n", "[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19]\n" ] } ], "source": [ "data=np.arange(10)\n", "data2 = np.arange(20)\n", "np.savez('/tmp/myarrays',x=data,y=data2)\n", "\n", "myarrays = np.load('/tmp/myarrays.npz')\n", "\n", "print (myarrays['x'])\n", "\n", "print (myarrays['y'])" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "more reliable than pickling files on disk." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Reshape and where\n", "===" ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "scrolled": true, "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "x = np.arange(100).reshape((10,10))\n", "plt.imshow(x,interpolation='none')\n" ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "scrolled": true, "slideshow": { "slide_type": "slide" } }, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "x[np.where(np.logical_and(x > 50,x <75))] = 0\n", "plt.imshow(x,interpolation='none')\n", "plt.colorbar()" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "**np.where() may be the single most important function that you will use in numpy.** " ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Numpy documentation with examples\n", "===" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "There are over 400 functions in numpy (doing everything from rebinning to\n", "obtaining polynomial least squares fits) in numpy for array\n", "manipulation.\n", "\n", "As time permits, please read through the excellent Numpy user guide at\n", "\n", "https://numpy.org/doc/stable/user/index.html\n", "\n", "We will cover only a fraction of the capabilities on `numpy`in this course.\n", "\n" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Masked arrays - np.ma\n", "===" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "Masked arrays are arrays that may have missing or invalid entries. Very common in astronomy." ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[-- -- 3 -1 5]\n", "2.0\n", "2.75\n", "[1 2 3 -1 --]\n" ] } ], "source": [ "import numpy.ma as ma, numpy as np\n", "\n", "x = np.array([1, 2, 3, -1, 5])\n", "mx = ma.masked_array(x, mask=[0, 0, 0, 1, 0])\n", "mx2 = ma.masked_array(x, mask=[1, 1, 0, 0, 0])\n", "mx2 = ma.masked_array(x, mask=[True, True, False, False, False]) # equivalent more Pythonic syntax\n", "print (mx2)\n", "print (x.mean())\n", "print (mx.mean())\n", "\n", "mx/mx2 # Arithmetic operations on 2 masked arrays possible.\n", "\n", "y = ma.masked_where(x>3,x)\n", "print (y)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Numpy functions and object methods\n", "===" ] }, { "cell_type": "code", "execution_count": 28, "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "4950\n", "4950\n" ] } ], "source": [ "a = np.arange(100)\n", "\n", "print (np.sum(a)) # Functional programming\n", "\n", "print (a.sum()) # Object oriented programming\n", "\n", "# The same underlying code provides both functional and OO calling functions." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Histograms\n", "===" ] }, { "cell_type": "code", "execution_count": 30, "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "\n", "x, y = np.random.randn(2, 100000)\n", "\n", "H, xedges, yedges = np.histogram2d(x, y, bins=50)\n", "\n", "extent = [xedges[0], xedges[-1], yedges[0], yedges[-1]]\n", "\n", "plt.imshow(H, extent=extent)\n" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Matrix objects\n", "===" ] }, { "cell_type": "code", "execution_count": 52, "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/plain": [ "matrix([[0.2, 0. , 0. ],\n", " [0. , 0.2, 0. ],\n", " [0. , 0. , 0.2]])" ] }, "execution_count": 52, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x1 = np.array([1, 2, 3], float)\n", "\n", "x2 = np.matrix(x1)\n", "\n", "A = np.identity(3)\n", "\n", "A = 5* np.mat(A)\n", "\n", "B = x2*A # matrix multiplication\n", "\n", "np.linalg.inv(A)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "$*$ represents matrix-matrix matrix-vector or vector-matrix multiplication. " ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Numpy capabilities\n", "===" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "* Discrete Fourier Transform (np.fft)\n", "* Linear algebra (np.linalg): cholesky, svd, eigenvalues/vectors, matrix inversion, solving equations (LAPACK)\n", "* Random sampling (np.random)\n", "* statistics: covariance, correlation, variances, histograms\n", "* polynomials: root finding, fitting data \n", "* Matrix library (np.matlib)\n", "* **f2py** - a FORTRAN to Python interface generator" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "How fast is numpy?\n", "===" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "* 100 times faster than with a for loop with native Python types\n", "* Somewhat slower than a modern FORTRAN/C++ compiler with -O3 optimisations\n", "* comparable speed to Matlab \n", "\n", "\n", "But this is run speed. In development and debugging time, Python is\n", "far ahead ofFORTRAN/C++. But if __speed is really critical__ to your code,\n", "you can profile your Python code and rewrite slower parts in\n", "C/C++/FORTRAN." ] } ], "metadata": { "celltoolbar": "Slideshow", "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.9" } }, "nbformat": 4, "nbformat_minor": 1 }