Intro-Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Intro Python PHYS-311"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we are going to import some modules that we will use in our notebook, <code> numpy </code>, <code> scipy </code> and <code> matplotlib </code>. We will use an alias for each of the modules."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I 💜 🍺\n",
      "χ\n"
     ]
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import scipy as sp\n",
    "import matplotlib.pylab as plt\n",
    "\n",
    "from IPython.display import Markdown\n",
    "plt.style.use('bmh')\n",
    "plt.rcParams.update({'axes.labelsize': 20})\n",
    "plt.rcParams.update({'legend.fontsize': 20})\n",
    "\n",
    "\n",
    "print(\"I \\N{purple heart} \\N{Beer Mug}\")\n",
    "\n",
    "print(\"\\N{GREEK SMALL LETTER CHI}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python doesn't require explicitly declared variable types, like C and other languages do. Just assign a variable and Python understands what you want:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 5      # a is an integer 5\n",
    "b = 'five' # b is a string of the word 'five'\n",
    "c = 5.0    # c is a floating point 5  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can ask python to tell you the type of the variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'> <class 'str'> <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "print(type(a), type(b), type(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Lists\n",
    "\n",
    "Lists in python are like C arrays except that each element can be of any type.\n",
    "The syntax for creating lists in Python is [...]:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "l = [23, 234, 3.1416, 45, 341, 33, \"I am in a list\", True]\n",
    "print (type(l[-1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use the same slicing techniques to manipulate lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[234, 3.1416, 45]\n",
      "True\n",
      "45\n",
      "[23, 234, 3.1416, 45, 341, 33, 'I am in a list', True]\n",
      "[23, 3.1416, 341, 'I am in a list']\n"
     ]
    }
   ],
   "source": [
    "print (l[1:4]) # slides of elements from 1 to 2\n",
    "print (l[-1]) #last element\n",
    "print (l[3]) # third element\n",
    "print (l[:]) #all elements (Same as l)\n",
    "print (l[::2]) #elements from 0 to last in steps of 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3]\n"
     ]
    }
   ],
   "source": [
    "print (100*[3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function <code> range </code> in python is widely use to generate enumeration lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 4 6 8]\n"
     ]
    }
   ],
   "source": [
    "l = np.arange(2, 10, 2)\n",
    "\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A function is a block of organized, reusable code that is used to perform a single, related action. Functions provide better modularity for your application and a high degree of code reusing. As you already know, python gives you many built-in functions like print(), etc. but you can also create your own functions. The syntax for functions is:\n",
    "\n",
    "```python\n",
    "def functionname( parameters ):\n",
    "   \"\"\"docstring\"\"\"\n",
    "   code\n",
    "   return something\n",
    "```\n",
    "\n",
    "An example is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16\n"
     ]
    }
   ],
   "source": [
    "def mypower(x, power):\n",
    "    return x**power\n",
    "\n",
    "print (mypower(4,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "def mypower(x: float, power: float) -> float:\n",
    "    return x**power\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0.703125\n"
     ]
    }
   ],
   "source": [
    "def myfunction(x):\n",
    "    if x < -1 or x > 1:\n",
    "        return 0\n",
    "    else:\n",
    "        return 15./4. * (x**2 - x**4)\n",
    "    \n",
    "print (myfunction(3), myfunction(0.5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The power of Python: Modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Most of the functionality in Python is provided by *modules*. The Python Standard Library is a large collection of modules that provides *cross-platform* implementations of common facilities such as access to the operating system, file I/O, string management, network communication, and much more.\n",
    "\n",
    "* Must haves\n",
    "    * [numpy](www.numpy.org): random numbers, arrays, transcendental functions, linear algebra.\n",
    "    * `scipy`: statistical tests, special functions, integration, curve fitting, minimization.\n",
    "    * `matplotlib`: plotting: xy plots, error bars, contour plots, histograms.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Importing style"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are several ways to load a module for example, in the case of numpy we could do:\n",
    "\n",
    "**Option 1**:  \n",
    "```Python \n",
    "import numpy\n",
    "x = numpy.cos(2 * numpy.pi)\n",
    "```\n",
    "\n",
    "**Option 2**:  \n",
    "```Python \n",
    "import numpy as np\n",
    "x = np.cos(2 * np.pi)\n",
    "```\n",
    "\n",
    "**Option 3**:  \n",
    "```Python \n",
    "from numpy import cos, pi\n",
    "x = cos(2 * pi)\n",
    "```\n",
    "\n",
    "**Option 4**:  \n",
    "```Python \n",
    "from numpy import *\n",
    "x = cos(2 * pi)\n",
    "```\n",
    "\n",
    "Options **1** and **2** are the preferred one. They allowed you to keep each function related to its function. For example, there is another module `math` with a the function `cos` implemented, by keeping the `np.cos` or `numpy.cos` you avoid confusion between them. Option **3** might be used we need access only to some of the functions inside the module. Option **4** saves a lot of typing but is sloppy and **not recommended**. \n",
    "\n",
    "\n",
    "Explicit is better than implicit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The numpy module"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The <code>numpy</code> package (module) is used in almost all numerical computation using Python. It is a package that provide high-performance vector, matrix and higher-dimensional data structures for Python. It is implemented in C and <code>Fortran</code> so when calculations are vectorized (formulated with vectors and matrices), performance is very good. \n",
    "\n",
    "The central feature of NumPy is the array object class. Arrays are similar to lists in Python, except that every element of an array must be of the same type, typically a numeric type like float or int. Arrays make operations with large amounts of numeric data very fast and are generally much more efficient than lists. An array can be created from a list by using the array function. You can use the second argument to specify what type of data is in the list or leave it out entirely for numpy to decided what kind of data it is."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1. 4. 5. 8.]\n",
      "<class 'numpy.float64'>\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1, 4, 5, 8], float) \n",
    "print (a)\n",
    "print (type(a[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arrays can be multidimensional. Unlike lists, different axes are accessed using commas inside bracket notation. Here is an example with a two-dimensional array (aka, a matrix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 2. 3.]\n",
      " [4. 5. 6.]]\n",
      "1.0\n",
      "2.0\n",
      "(2, 3)\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1, 2, 3], [4, 5, 6]], float) \n",
    "print (a)\n",
    "print (a[0,0])\n",
    "print (a[0,1])\n",
    "\n",
    "print (a.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Array slicing works with multiple dimensions in the same way as usual, applying each slice specification as a filter to a specified dimension. Use of a single \":\" in a dimension indicates the use of everything along that dimension. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4. 5. 6.]\n",
      "[3. 6.]\n",
      "[[5. 6.]]\n"
     ]
    }
   ],
   "source": [
    "print (a[1,:])\n",
    "print (a[:,2])\n",
    "print (a[-1:,-2:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The shape property of an array returns a tuple with the size of each array dimension: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 95. 195. 295.]\n",
      " [395. 495. 595.]]\n"
     ]
    }
   ],
   "source": [
    "print (100*a -5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 3)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions in <code>numpy</code> are vectorized meaning they can take arrays as arguments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n",
      "[[ 1.  4.  9.]\n",
      " [16. 25. 36.]]\n"
     ]
    }
   ],
   "source": [
    "x = a[0,0] #this is a scalar\n",
    "print (np.power(x,2))\n",
    "print (np.power(a,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This will not work with our function defined with conditions, example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "x = np.linspace(-1, 1, 50, endpoint=True) # this creates an array between -1, 1 with 50 points\n",
    "\n",
    "\n",
    "print (type(x))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-34-428cdafc1216>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mmyfunction\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-20-67d2ed84c0f5>\u001b[0m in \u001b[0;36mmyfunction\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mmyfunction\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0;32mif\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0;36m15.\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0;36m4.\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0;36m2\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()"
     ]
    }
   ],
   "source": [
    "print (myfunction(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can handle better errors by using the function:\n",
    "```Python\n",
    "    try:\n",
    "        statement\n",
    "    except:\n",
    "        print(\"Caught an exception\")\n",
    "```\n",
    "To get information about the error, we can access the Exception class instance that describes the\n",
    "exception by using for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Caught exception: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    myfunction(x)\n",
    "except Exception as e:\n",
    "    print(\"Caught exception: {}\".format(e))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To avoid this error we can *vectorized* our function using the `numpy` function `np.vectorize(function)`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.         0.27589504 0.4952903  0.66393098 0.78731252 0.87068053\n",
      " 0.91903086 0.93710954 0.92941283 0.90018719 0.85342929 0.792886\n",
      " 0.72205441 0.64418182 0.56226572 0.47905383 0.39704406 0.31848454\n",
      " 0.2453736  0.17945979 0.12224186 0.07496876 0.03863967 0.01400395\n",
      " 0.0015612  0.0015612  0.01400395 0.03863967 0.07496876 0.12224186\n",
      " 0.17945979 0.2453736  0.31848454 0.39704406 0.47905383 0.56226572\n",
      " 0.64418182 0.72205441 0.792886   0.85342929 0.90018719 0.92941283\n",
      " 0.93710954 0.91903086 0.87068053 0.78731252 0.66393098 0.4952903\n",
      " 0.27589504 0.        ]\n"
     ]
    }
   ],
   "source": [
    "vmyfunction = np.vectorize(myfunction)\n",
    "\n",
    "y = vmyfunction(x)\n",
    "\n",
    "print (y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The matplotlib module\n",
    "\n",
    "Matplotlib is an excellent 2D and 3D graphics library for generating scientific figures. The tidy thing to import matplotlib.pyplot matplotlib.pyplot module under the name plt (the tidy way):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#fig = plt.figure(figsize=(8,6))\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(8,6)) #Another way to generate figure and axes at the same time\n",
    "\n",
    "#ax = fig.add_axes([0.1, 0.1, 0.8, 0.8]) # left, bottom, width, height (range 0 to 1)\n",
    "\n",
    "ax.plot(x, y, 'b--', lw=4)\n",
    "\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_xlim(-1,1)\n",
    "#ax.grid()\n",
    "ax.set_title('My Function');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use numpy also to calculate the integral using the trapezoidal method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The integral of the function is 0.9979\n"
     ]
    }
   ],
   "source": [
    "dx = np.diff(x)[0] # numpy diff calcualtes the difference of x[i+1] - x[i], it returns an array.\n",
    "integral = np.trapz(y, dx = dx )\n",
    "print (\"The integral of the function is %.4f\"%integral)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.12.1"
  },
  "latex_envs": {
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 0
  },
  "vscode": {
   "interpreter": {
    "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}