Up and Running with Python - Introduction.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Up and Running with Python3\n",
    "# Introduction to Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python is a modern, object-oriented scripting language. \n",
    "Developed in the late 1980s by Dutch research programmer Guido van Rossum. Guido wrote the first Python interpreter over his Christmas holiday in 1989. Guido remains Python's principal author to this day. The Python community refers to him as BDFL, Benevolent Dictator For Life.\n",
    "\n",
    "Why \"Python\"? Reference to Monty Python's Flying Circus. \n",
    "\n",
    "Python's core philosophy: \n",
    "- Beautiful is better than ugly. \n",
    "- It's always a good idea to make your code elegant and readable. \n",
    "- Explicit is better than implicit. Don't make your readers guess what your code does, make it obvious. \n",
    "- Simple is better than complex. If you can make it simple, do. \n",
    "- Complex is better than complicated. If complexity is necessary, don't complicate it. \n",
    "- Readability counts. \n",
    "\n",
    "As a casual reader with a good understanding of the Python language, you should be able to understand the code with a minimal amount of effort. For the complete list, simply type Import This into any Python interpreter. Python 3 is very close to Guido's ideal vision for Python. \n",
    "\n",
    "Python is a rich language, and it would be impossible to cover all of it in just one hour. But the online documentation is both accessible and exhaustive. \n",
    "\n",
    "Python is a very powerful and versatile programming language. It's supported on virtually all common operating systems and it's easy to learn and to support. \n",
    "\n",
    "<img src=\"data/logos/python-powered-h-140x182.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hello World"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world!\n"
     ]
    }
   ],
   "source": [
    "print('Hello world!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import a module from the Python library"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We are using python 3.7.4\n"
     ]
    }
   ],
   "source": [
    "import platform\n",
    "print('We are using python', platform.python_version())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Datatypes\n",
    "\n",
    "There are just a few fundamental data types in Python.\n",
    "\n",
    "Python is designed to be extensible so it's easy to create your own types within its object system."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'complex'>\n",
      "<class 'str'>\n",
      "<class 'bool'>\n",
      "<class 'NoneType'>\n"
     ]
    }
   ],
   "source": [
    "x = 7\n",
    "print(type(x))\n",
    "x = 7.0\n",
    "print(type(x))\n",
    "x = 1+2j\n",
    "print(type(x))\n",
    "x = '7'\n",
    "print(type(x))\n",
    "x = True\n",
    "print(type(x))\n",
    "x = None\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is no `double` in Python. A `float` in Python has double precision (like a `double` in C). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Strings\n",
    "\n",
    "Strings are objects, even literal strings. Here we start with literal string, the `'neutrino'` in quotes.\n",
    "Since this is an object, we can run methods on it. Let's start with `capitalize()` here. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "neutrino\n",
      "Neutrino\n"
     ]
    }
   ],
   "source": [
    "x = 'neutrino'\n",
    "print(x)\n",
    "x = x.capitalize()\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can treat strings as _array-like objects_ and access them using indexes with `[2]` to access the third index for example: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'r'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# EXCERCISE: Access the fifth index of the above string\n",
    "\n",
    "x[4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can print a string with the `print` function, and format it to also show values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We currently know there are 3 neutrinos.\n",
      "Or maybe there are more than 3?\n"
     ]
    }
   ],
   "source": [
    "n_neutrinos = 3\n",
    "x = 'We currently know there are {} neutrinos.'.format(n_neutrinos)\n",
    "print(x)\n",
    "\n",
    "# Or event easier with f-strings (Python >= 3.6)\n",
    "x = f'Or maybe there are more than {n_neutrinos}?'\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists\n",
    "Lists in Python represent ordered sequences of values. Here is an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "particles = ['up', 'down', 'electron', 'electron_neutrino',\n",
    "             'charm', 'strange', 'muon', 'muon_neutrino', \n",
    "             'top', 'bottom', 'tau', 'tau_neutrino',\n",
    "             'gluon', 'photon', 'z', 'w',\n",
    "             'higgs']\n",
    "\n",
    "masses = [2.2, 4.7, 0.511, 'less than 1 eV',\n",
    "          1.28, 96, 105.66, 'less than 0.17 eV',\n",
    "          173e3, 4.18e3, 1.78e3, 'less than 18.2 eV',\n",
    "          0, 0, 91.19e3, 80.39e3,\n",
    "          124.97e3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists: `[]` - mutable\n",
    "\n",
    "Tuples: `()` - unmutable\n",
    "\n",
    "Here are some useful operations that can be applied on lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "strange\n"
     ]
    }
   ],
   "source": [
    "# Indexing\n",
    "print(particles[5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use negative indexes too. Negative indexes start counting from the end."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "higgs\n",
      "w\n"
     ]
    }
   ],
   "source": [
    "# EXERCISE: Try to slice the particle array with negative indexes.\n",
    "print(particles[-1])\n",
    "print(particles[-2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also \"slice\" lists. More details on this will be given in the next notebook on numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['down', 'electron', 'electron_neutrino', 'charm', 'strange', 'muon', 'muon_neutrino', 'top', 'bottom', 'tau', 'tau_neutrino', 'gluon', 'photon', 'z', 'w', 'higgs']\n",
      "['electron', 'electron_neutrino']\n"
     ]
    }
   ],
   "source": [
    "# From the first element to the end\n",
    "print(particles[1:])\n",
    "\n",
    "# From the second to the fourth element \n",
    "print(particles[2:4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With `len` you can get the lenght of the vector:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "17\n"
     ]
    }
   ],
   "source": [
    "# Lenght\n",
    "print(len(particles))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionaries\n",
    "Dictionaries are a built-in Python data structure for mapping keys to values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'electron_neutrino': 0, 'muon_neutrino': 0, 'tau_neutrino': 0}"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "par_to_mass = {'electron_neutrino': 0, \n",
    "               'muon_neutrino': 0,\n",
    "               'tau_neutrino': 0}\n",
    "par_to_mass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Electron-neutrino mass is 0\n",
      "No, we only know it is less than 1 eV\n"
     ]
    }
   ],
   "source": [
    "# Query a dictionary\n",
    "print('Electron-neutrino mass is', par_to_mass['electron_neutrino'])\n",
    "\n",
    "# Change a value\n",
    "par_to_mass['electron_neutrino'] = 'less than 1 eV'\n",
    "print('No, we only know it is', par_to_mass['electron_neutrino'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Let's construct the full dictionary to go from particles to masses\n",
    "par_to_mass = {}\n",
    "for p, m in zip(particles, masses):\n",
    "    par_to_mass[p] = m"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To retrieve keys and values from a dictionary:\n",
    "- `.items()` applied to a dictionary return a pair of keys and values\n",
    "- `.keys()` applied to a dictionary return all the keys\n",
    "- `.values()` applied to a dictionary return all the values\n",
    "\n",
    "You can also you `.get()` as in `par_to_mass.get('muon')`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "up 2.2\n",
      "down 4.7\n",
      "electron 0.511\n",
      "electron_neutrino less than 1 eV\n",
      "charm 1.28\n",
      "strange 96\n",
      "muon 105.66\n",
      "muon_neutrino less than 0.17 eV\n",
      "top 173000.0\n",
      "bottom 4180.0\n",
      "tau 1780.0\n",
      "tau_neutrino less than 18.2 eV\n",
      "gluon 0\n",
      "photon 0\n",
      "z 91190.0\n",
      "w 80390.0\n",
      "higgs 124970.0\n"
     ]
    }
   ],
   "source": [
    "for key, value in par_to_mass.items():\n",
    "    print(key, value)\n",
    "# for key in par_to_mass.keys():\n",
    "#     print(key)\n",
    "# for value in par_to_mass.values():\n",
    "#     print(value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `in` operator allows to check is a key is in the dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Do I know the mass of Marco? False\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "105.66"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# EXCERCISE: Try to use \"in\" to check is a key is in the dictionary\n",
    "print('Do I know the mass of Marco?', 'Marco' in par_to_mass)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists and Dictionaries: Conclusions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python provides a number of collection types useful for creating structured data. \n",
    "\n",
    "- The *list* type is a basic sequence. It's created using a pair of square brackets around a list of **objects** separated by commas. The list is mutable, which means that you may add, delete, and change values.\n",
    "\n",
    "- A *dictionary* is a sequence of key-value pairs. In other languages, this may be called an associative array or a hashed array. It is indicated with curly brackets. \n",
    "\n",
    "- A *tuple* is like a list, but it's immutable. You cannot change it once it's been created. A tuple is created using parentheses. \n",
    "\n",
    "- A *set* is is an unordered list of unique values. It's useful for finding and operating upon unique values within a sequence. \n",
    "\n",
    "Any of these collection types may contain any object or type. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Blocks and Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions are the basic unit of reusable code in Python. So, let's take a look at how they work.\n",
    "A couple of examples of functions in python: `round` and `abs`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 3\n",
      "y = 4\n"
     ]
    }
   ],
   "source": [
    "x = round(3.2)\n",
    "y = round(3.6)\n",
    "print('x =', x)\n",
    "print('y =', y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `help()` function is possibly the most important Python function you can learn."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function round in module builtins:\n",
      "\n",
      "round(number, ndigits=None)\n",
      "    Round a number to a given precision in decimal digits.\n",
      "    \n",
      "    The return value is an integer if ndigits is omitted or None.  Otherwise\n",
      "    the return value has the same type as the number.  ndigits may be negative.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(round)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# EXCERCISE:\n",
    "# You can also get help in jupyter by using `?`. Try `round?`\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python differs from many languages in how **blocks** are delimited. Python does not use brackets or any special characters for blocks, instead it uses indentation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A function is defined with the `def` keyword, then the name of the function, and then always parenthesis, even if it does not take any arguments. And any arguments are separated by commas inside of those parentheses. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Argon is NOT in liquid state!\n",
      "Argon is in liquid state!\n"
     ]
    }
   ],
   "source": [
    "def check_temperature(T):\n",
    "    '''\n",
    "    Checks if the argon is in liquid state\n",
    "    give a certain temperature T.\n",
    "    '''\n",
    "    T_c = 87 # K\n",
    "\n",
    "    if T > T_c:\n",
    "        print('Argon is NOT in liquid state!')\n",
    "    else:\n",
    "        print('Argon is in liquid state!')\n",
    "        \n",
    "check_temperature(88)\n",
    "check_temperature(86)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function check_temperature in module __main__:\n",
      "\n",
      "check_temperature(T)\n",
      "    Checks if the argon is in liquid state\n",
      "    give a certain temperature T.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(check_temperature)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def get_mass(particle_name):\n",
    "    try:\n",
    "        return par_to_mass[particle_name]\n",
    "    except:\n",
    "        print('Not found!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "124970.0"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_mass(particle_name='higgs')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "124970.0\n"
     ]
    }
   ],
   "source": [
    "# EXCERCISE: Define get_mass(particle_name) function implementation in 1 line only\n",
    "# (hint: use dictionary \"get\" function, or 1 liner if statement)\n",
    "\n",
    "def get_mass(particle_name):\n",
    "    return par_to_mass.get(particle_name)\n",
    "\n",
    "print(get_mass('higgs'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Argument List\n",
    "\n",
    "Python functions allow variable length argument lists.\n",
    "\n",
    "If you add an argument with an asterisk `*` before it (as done below with `*args`), this is a variable length argument list. It is a `tuple`.\n",
    "\n",
    "Below we check if it has non-zero length, and then we loop over the arguments.\n",
    "\n",
    "Note that we don't have to specify how many arguments or what kind of arguments we are passing. This feature is useful for situations where you want a function that may be called with different numbers of arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def get_mass_2(*args):\n",
    "    if len(args):\n",
    "        for p in args:\n",
    "            try: \n",
    "                print(p, 'mass is', par_to_mass[p])\n",
    "            except: \n",
    "                print(p, 'not found!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "higgs mass is 124970.0\n",
      "electron mass is 0.511\n"
     ]
    }
   ],
   "source": [
    "# EXCERCISE: Try calling the function above\n",
    "\n",
    "get_mass_2('higgs', 'electron')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Keyword Arguments\n",
    "\n",
    "Keyword arguments are like list arguments that are dictionaries instead of tuples. This allows functions to have a variable number of named arguments. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def get_mass_3(**kwargs):\n",
    "    for k in kwargs:\n",
    "        print('Particle', k, 'has mass', kwargs[k])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Particle Higgs has mass 124970.0\n",
      "Particle Electron has mass 0.511\n"
     ]
    }
   ],
   "source": [
    "# EXCERICE: Try to get the mass of the Higgs by passing Higgs=124970.0 as argument\n",
    "get_mass_3(Higgs=124970.0, Electron=0.511)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Everything is an object\n",
    "A list can contain a mix of different types of variables. It can also contain a function!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Here it contains a string, a float, a dictionary, and a function!\n",
    "miscellaneous = ['neutrino', 2.2, par_to_mass, get_mass]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4180.0"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "miscellaneous[-1]('bottom')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classes\n",
    "\n",
    "A class is the basis of all data in Python. \n",
    "\n",
    "Everything is an object in Python, and a class is how an object is defined.\n",
    "\n",
    "A class definition beginning with the keyword `class`, the name of the class, and a colon, and then everything that defines the class is indented under that declaration. \n",
    "\n",
    "Inside the clasee you can have data in the form of **variables**, and **methods** in the form of function definitions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Detector:\n",
    "    \n",
    "    _name = 'sbnd'   # 'icarus'\n",
    "    _near_det = True # False\n",
    "    \n",
    "    def name(self):\n",
    "        print('I am ', self._name, '!', sep='')\n",
    "    \n",
    "    def is_near_det(self):\n",
    "        return self._near_det"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You'll notice that:\n",
    "- The first parameter of a method is always `self`. `self` is not a keyword. You can actually name that first parameter whatever you want to, but self is traditional and it is highly recommend that you use `self` so that as people are reading your code, they know what you're talking about. `self` is a reference to the object, not the class. And so, when an object is created from the class, `self` will reference that object. And then everything that references anything defined in the class is dereferenced off itself to get the instantiated object version of it. And the period operator is used to dereference the object. And the same is true outside of the class.\n",
    "- All class variables start with an underscore `_`. This is a convention to remember ourselves that those variables belong to the class. Python doesn't have private variables, and so there is no way to actually prevent somebody from using these from outside of the class. But this indicates that it is a private variable and it should not be set or retrieved outside of the a setter or getter.\n",
    "\n",
    "#### Next, we will create an instance of a class.  \n",
    "\n",
    "An instance of a class is called an object. It's creating by calling the class itself as if it were a function. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am sbnd!\n",
      "This is a ND.\n"
     ]
    }
   ],
   "source": [
    "# EXCERCISE: Try to instantiate the class and call both class methods\n",
    "\n",
    "mydetector = Detector()\n",
    "mydetector.name()\n",
    "print('This is a ND.' if mydetector.is_near_det() else 'This is a FD.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Class constructor  \n",
    "\n",
    "The class constructor allows us to **initialize** class member variables when we instantiate the class.\n",
    "\n",
    "The constructor can be defined in a special  class method name called `init`, with double underscores before and after: `__init__(self, var1, var2, ...)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am sbnd!\n"
     ]
    }
   ],
   "source": [
    "# EXCERCISE: Add a constructor to the Detector class where you initialize the two variables _name and _near_det\n",
    "\n",
    "class Detector:\n",
    "    \n",
    "    def __init__(self, name='icarus', nd=False):\n",
    "        self._name = name\n",
    "        self._near_det = nd\n",
    "    \n",
    "    def name(self):\n",
    "        print('I am ', self._name, '!', sep='')\n",
    "    \n",
    "    def is_near_det(self):\n",
    "        return self._near_det\n",
    "    \n",
    "mydetector = Detector('sbnd', True)\n",
    "mydetector.name()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Let's print a class!\n",
    "\n",
    "The method `__str__` allows to tell the class how it should behave inside a `print()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi! I am icarus, and I am a FD. I have 360 PMTs.\n"
     ]
    }
   ],
   "source": [
    "# EXCERCISE: Try to add a the __str__ method and print some informaion from the detector class, like this\n",
    "# def __str__(self):\n",
    "#     s = 'I am a ND' if self._near_det else 'I am a FD'\n",
    "#     return f'Hi! I am {self._name}, and ' + s\n",
    "# Also add a new method that returns the number of PMTs (120 in SBND, 360 in ICARUS)\n",
    "\n",
    "class Detector:\n",
    "    \n",
    "    def __init__(self, name='icarus', nd=False):\n",
    "        self._name = name\n",
    "        self._near_det = nd\n",
    "        self._n_pmts = 360\n",
    "    \n",
    "    def name(self):\n",
    "        print('I am ', self._name, '!', sep='')\n",
    "    \n",
    "    def is_near_det(self):\n",
    "        return self._near_det\n",
    "    \n",
    "    def n_pmts(self):\n",
    "        return self._n_pmts \n",
    "    \n",
    "    def __str__(self):\n",
    "        s = 'I am a ND.' if self._near_det else 'I am a FD.'\n",
    "        return f'Hi! I am {self._name}, and ' + s + f' I have {self.n_pmts()} PMTs.'\n",
    "    \n",
    "mydetector = Detector('icarus', False)\n",
    "print(mydetector)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we looked at a couple of special methods: `init` and `str`.\n",
    "\n",
    "You can find a list of all the special method names in the [Python3 documentation](https://docs.python.org/3/reference/datamodel.html#basic-customization). \n",
    "\n",
    "Methods are the primary interface for classes and objects. They work exactly like functions, except they are bound to the object through their first argument, commonly named self."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Class Inheritance\n",
    "\n",
    "Class inheritance is a fundamental part of object-oriented programming.\n",
    "\n",
    "This allows you to extend your classes by driving properties and methods from parent classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi! I am sbnd, and I am a ND. I have 120 PMTs.\n",
      "Hi! I am icarus, and I am a FD. I have 360 PMTs.\n"
     ]
    }
   ],
   "source": [
    "class SBND(Detector):\n",
    "    def __init__(self):\n",
    "        self._name = 'sbnd'\n",
    "        self._near_det = True \n",
    "        self._n_pmts = 120\n",
    "\n",
    "s = SBND()\n",
    "print(s)\n",
    "\n",
    " \n",
    "class ICARUS(Detector):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "\n",
    "i = ICARUS()\n",
    "print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `super()` function above allows to call the parent class (`Detector`). `super().__init__()` calls the constructor of the `Detector` class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi! I am sbnd, and I am a ND. I have 120 PMTs and 384 arapucas.\n",
      "Hi! I am icarus, and I am a FD. I have 360 PMTs.\n"
     ]
    }
   ],
   "source": [
    "# EXCERCISE: SBND has also arapucas (384), extend the SBND class to also return the number of arapucas\n",
    "\n",
    "class SBND(Detector):\n",
    "    def __init__(self):\n",
    "        self._name = 'sbnd'\n",
    "        self._near_det = True \n",
    "        self._n_pmts = 120\n",
    "        self._n_arapucas = 384\n",
    "    \n",
    "    def n_arapucas(self):\n",
    "        return self._n_arapucas\n",
    "    \n",
    "    def __str__(self):\n",
    "        s = 'I am a ND.' if self._near_det else 'I am a FD.'\n",
    "        return f'Hi! I am {self._name}, and ' + s + f' I have {self.n_pmts()} PMTs and {self._n_arapucas} arapucas.'\n",
    "\n",
    "s = SBND()\n",
    "print(s)\n",
    "\n",
    "i = ICARUS()\n",
    "print(i)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusions\n",
    "\n",
    "And now, just for fun, let's import this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Zen of Python, by Tim Peters\n",
      "\n",
      "Beautiful is better than ugly.\n",
      "Explicit is better than implicit.\n",
      "Simple is better than complex.\n",
      "Complex is better than complicated.\n",
      "Flat is better than nested.\n",
      "Sparse is better than dense.\n",
      "Readability counts.\n",
      "Special cases aren't special enough to break the rules.\n",
      "Although practicality beats purity.\n",
      "Errors should never pass silently.\n",
      "Unless explicitly silenced.\n",
      "In the face of ambiguity, refuse the temptation to guess.\n",
      "There should be one-- and preferably only one --obvious way to do it.\n",
      "Although that way may not be obvious at first unless you're Dutch.\n",
      "Now is better than never.\n",
      "Although never is often better than *right* now.\n",
      "If the implementation is hard to explain, it's a bad idea.\n",
      "If the implementation is easy to explain, it may be a good idea.\n",
      "Namespaces are one honking great idea -- let's do more of those!\n"
     ]
    }
   ],
   "source": [
    "import this "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More information on Jupyter Notebooks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Features of Jupyter Notebooks are nicely described [here](http://arogozhnikov.github.io/2016/09/10/jupyter-features.html).\n",
    "\n",
    "A [Nature paper](https://www.nature.com/news/interactive-notebooks-sharing-the-code-1.16261) about Jupyter as an introduction to literate programming concept."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Extras"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List Comprehensions \n",
    "\n",
    "List comprehensions are one of Python's most beloved and unique features. The easiest way to understand them is probably to just look at a an example. \n",
    "\n",
    "Let's assume we want to calculate all the squarer of the numbers between 0 and 9. With a `for` loop we would do:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squares = []\n",
    "for n in range(10):\n",
    "    squares.append(n**2)\n",
    "squares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instead, with list comprehension we can just do:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squares = [n**2 for n in range(10)]\n",
    "squares"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "304 µs ± 1.29 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n",
      "235 µs ± 1.2 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
     ]
    }
   ],
   "source": [
    "squares = []\n",
    "%timeit for n in range(1000): squares.append(n**2)\n",
    "%timeit squares = [n**2 for n in range(1000)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "particles = ['up', 'down', 'electron', 'electron_neutrino',\n",
    "             'charm', 'strange', 'muon', 'muon_neutrino', \n",
    "             'top', 'bottom', 'tau', 'tau_neutrino',\n",
    "             'gluon', 'photon', 'z', 'w',\n",
    "             'higgs']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['up', 'down', 'charm', 'muon', 'top', 'tau', 'gluon', 'z', 'w', 'higgs']"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "short_particles = [particle for particle in particles if len(particle) < 6]\n",
    "short_particles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['anti_up',\n",
       " 'anti_down',\n",
       " 'anti_electron',\n",
       " 'anti_electron_neutrino',\n",
       " 'anti_charm',\n",
       " 'anti_strange',\n",
       " 'anti_muon',\n",
       " 'anti_muon_neutrino',\n",
       " 'anti_top',\n",
       " 'anti_bottom',\n",
       " 'anti_tau',\n",
       " 'anti_tau_neutrino',\n",
       " 'anti_gluon',\n",
       " 'anti_photon',\n",
       " 'anti_z',\n",
       " 'anti_w',\n",
       " 'anti_higgs']"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# EXCERCISE:\n",
    "# Get a list of antiparticles\n",
    "\n",
    "antiparticles = ['anti_' + particle for particle in particles]\n",
    "antiparticles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Down',\n",
       " 'Electron',\n",
       " 'Electron_neutrino',\n",
       " 'Muon',\n",
       " 'Muon_neutrino',\n",
       " 'Top',\n",
       " 'Bottom',\n",
       " 'Tau_neutrino',\n",
       " 'Gluon',\n",
       " 'Photon']"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# EXCERCISE:\n",
    "# Get all the particles that contain character 'o', and capitalize them.\n",
    "\n",
    "selected = [particle.capitalize() for particle in particles if 'o' in particle]\n",
    "selected"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}