examples/PythonBasic.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1:  Assignments and implicit typing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Value assignment with single '=' operator, note that there is no type declaration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2.0\n"
     ]
    }
   ],
   "source": [
    "a = 1\n",
    "b = 2.0\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Type checking confirms that a is int, and b is float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "print(type(a))\n",
    "print(type(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Variables of different types can be operated on, and the \"correct\" type propogates through to the solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.0\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "c = a + b\n",
    "print(c)\n",
    "print(type(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### \"in place\" operators can be used to change the value of a variable WITHOUT creating a new variable\n",
    "#### e.g. c += 2 is equivalent to c = c + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.0\n"
     ]
    }
   ],
   "source": [
    "c += 2\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2: Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### List definition is with '[' values ']' (tuples and dictionaries are also available but not dealt with here)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, -5, 3]\n",
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "myList = [10, -5, 3]\n",
    "print(myList)\n",
    "print(type(myList))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### List indexing starts from 0, and -ve indexes allow access from the end of the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "myList element  0: 10\n",
      "myList element  1: -5\n",
      "myList element  2: 3\n",
      "myList element -1: 3\n",
      "myList element -2: -5\n",
      "myList element -3: 10\n"
     ]
    }
   ],
   "source": [
    "print(f'myList element  0: {myList[0]}')\n",
    "print(f'myList element  1: {myList[1]}')\n",
    "print(f'myList element  2: {myList[2]}')\n",
    "print(f'myList element -1: {myList[-1]}')\n",
    "print(f'myList element -2: {myList[-2]}')\n",
    "print(f'myList element -3: {myList[-3]}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### List value assignment is with list[index] = value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "myList before: [10, -5, 3]\n",
      "myList after: [2, -5, 3]\n"
     ]
    }
   ],
   "source": [
    "print(f'myList before: {myList}')\n",
    "myList[0] = 2\n",
    "print(f'myList after: {myList}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### List contents are \"free\", the type of the list doesn't change if the contents are different"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 10, 15, 20]\n",
      "['this', 'is', 'a', 'list']\n",
      "<class 'list'>\n",
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "numberList = [5, 10, 15, 20]\n",
    "stringList = ['this', 'is', 'a', 'list']\n",
    "print(numberList)\n",
    "print(stringList)\n",
    "print(type(numberList))\n",
    "print(type(stringList))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Lists can contain different types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['this is a string', 1, 2, 'this is another string']\n"
     ]
    }
   ],
   "source": [
    "myList = ['this is a string', 1, 2, 'this is another string']\n",
    "print(myList)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### [:index] syntax access all elements up to index (EXCLUSIVE)\n",
    "#### [index:] syntax access all elements from index onwards (INCLUSIVE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['this is a string', 1, 2, 'this is another string']\n",
      "['this is a string']\n",
      "['this is a string', 1]\n",
      "[1, 2, 'this is another string']\n",
      "[2, 'this is another string']\n"
     ]
    }
   ],
   "source": [
    "print(myList)\n",
    "print(myList[:1])\n",
    "print(myList[:2])\n",
    "print(myList[1:])\n",
    "print(myList[2:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### With lists of lists an additional [index] is added to access the second list, indexing style doesn't change."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of lists: [[5, 10, 15, 20], ['this', 'is', 'a', 'list']]\n",
      "Element 0: [5, 10, 15, 20]\n",
      "Element 1: ['this', 'is', 'a', 'list']\n"
     ]
    }
   ],
   "source": [
    "myList = [numberList, stringList]\n",
    "print(f'List of lists: {myList}')\n",
    "print(f'Element 0: {myList[0]}')\n",
    "print(f'Element 1: {myList[1]}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Element 0 of list at element 0:  5\n",
      "First 2 elements of list at element 1: ['this', 'is']\n"
     ]
    }
   ],
   "source": [
    "print(f'Element 0 of list at element 0:  {myList[0][0]}')\n",
    "print(f'First 2 elements of list at element 1: {myList[1][:2]}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### List sizes are dynamically variable, the list.append(value) function will append value to the end of the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n",
      "[1]\n",
      "[1, 2]\n"
     ]
    }
   ],
   "source": [
    "myList = []\n",
    "print(myList)\n",
    "myList.append(1)\n",
    "print(myList)\n",
    "myList.append(2)\n",
    "print(myList)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### If you append a list to a list, you add the full list not its contents"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, [3, 4, 5]]\n"
     ]
    }
   ],
   "source": [
    "myList.append([3, 4, 5])\n",
    "print(myList)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Adding two lists (list1 + list2) adds the elements from list2 to the elements of list1\n",
    "#### Note:  Here \"in place\" addition is used (+=)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2]\n",
      "[1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "myList = myList[:2]\n",
    "print(myList)\n",
    "myList += [3, 4, 5]\n",
    "print(myList)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3: For loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### For loop syntax (for value in SourceOfValues: do stuff) with indentation defining the hierarchy\n",
    "#### Note:  The value of 'element' is pulled directly from the list, there is no array indexing involved"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index: 0  element: 10\n",
      "Index: 1  element: 11\n",
      "Index: 2  element: 12\n",
      "Index: 3  element: a\n",
      "Index: 4  element: b\n",
      "Index: 5  element: c\n"
     ]
    }
   ],
   "source": [
    "testList = [10, 11, 12, 'a', 'b', 'c']\n",
    "counter = 0\n",
    "for element in testList:\n",
    "    print(\"Index:\", counter, \" element:\", element)\n",
    "    counter = counter + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### List appending can be nested in a for loop to populate the list (depending on the application there can be better ways)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index: 0  element: 10\n",
      "Index: 1  element: 11\n",
      "Index: 2  element: 12\n",
      "Index: 3  element: a\n",
      "Index: 4  element: b\n",
      "Index: 5  element: c\n",
      "counterList: [0, 1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "counter = 0\n",
    "counterList = []\n",
    "for element in testList:\n",
    "    counterList.append(counter)\n",
    "    print(\"Index:\", counter, \" element:\", element)\n",
    "    counter += 1\n",
    "print(\"counterList:\", counterList)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Once value has been taken from SourceOfValues it is a variable itself, reassigning the value will not change SourceOfValues\n",
    "#### Note:  inplace multiplication (\\*=), the value of i as taken from counterList has its value changed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5]\n",
      "old i: 0\n",
      "new i: 0\n",
      "old i: 1\n",
      "new i: 3\n",
      "old i: 2\n",
      "new i: 6\n",
      "old i: 3\n",
      "new i: 9\n",
      "old i: 4\n",
      "new i: 12\n",
      "old i: 5\n",
      "new i: 15\n",
      "[0, 1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "print(counterList)\n",
    "for i in counterList:\n",
    "    print(f'old i: {i}')\n",
    "    i *= 3\n",
    "    print(f'new i: {i}')\n",
    "print(counterList)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The range(x) function creates a simple counter, very useful for for loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for number in range(10):\n",
    "    print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Using the counter from the range function lets the list contents be modified within the for loop by indexing the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "myList before: [10, 20, 30, 40, 50, 60]\n",
      "Replacing the value at index 0 with 5\n",
      "Replacing the value at index 1 with 6\n",
      "Replacing the value at index 2 with 7\n",
      "Replacing the value at index 3 with 8\n",
      "Replacing the value at index 4 with 9\n",
      "Replacing the value at index 5 with 10\n",
      "myList after:  [5, 6, 7, 8, 9, 10]\n"
     ]
    }
   ],
   "source": [
    "myList = [10, 20, 30, 40, 50, 60]\n",
    "print(\"myList before:\", myList)\n",
    "for number in range(6):\n",
    "    print(\"Replacing the value at index\", number, \"with\", number+5)\n",
    "    myList[number] = number+5\n",
    "print(\"myList after: \", myList)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### if/else statements are used for binary logic, here the greater than \">\" operator checks if value is larger than 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 is not greater than 10\n",
      "4 is not greater than 10\n",
      "5 is not greater than 10\n",
      "6 is not greater than 10\n",
      "7 is not greater than 10\n",
      "8 is not greater than 10\n",
      "9 is not greater than 10\n",
      "10 is not greater than 10\n",
      "11 is greater than 10\n",
      "12 is greater than 10\n",
      "13 is greater than 10\n",
      "14 is greater than 10\n"
     ]
    }
   ],
   "source": [
    "testList = [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]\n",
    "for value in testList:\n",
    "    if value > 10:\n",
    "        print(value, \"is greater than 10\")\n",
    "    else:\n",
    "        print(value, \"is not greater than 10\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4: Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Function definitions also use indentation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_function():\n",
    "    print(\"You just called a function\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Functions are called with the function_name() syntax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You just called a function\n"
     ]
    }
   ],
   "source": [
    "my_function()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Due to implicit typing, no type definition is needed when defining variables used in the function call"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_print_function(variable):\n",
    "    print(variable)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Variable passed into the function, could be any variable with the same result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Here is a variable\n",
      "1.2345\n",
      "['here', 'is', 'a', 'list']\n"
     ]
    }
   ],
   "source": [
    "my_print_function(\"Here is a variable\")\n",
    "my_print_function(1.2345)\n",
    "my_print_function(['here', 'is', 'a', 'list'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Multiple input variables are passed to a function with comma separation any output is given back via the 'return' command"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_adding_function(var1, var2):\n",
    "    print(\"var1 =\", var1)\n",
    "    print(\"var2 =\", var2)\n",
    "    return var1 + var2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Assignment of function result is no different to assigning variables to a value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "var1 = 1\n",
      "var2 = 2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "added = my_adding_function(1, 2)\n",
    "print(added)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### And with implicit typing the types of the input and output are automatic."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "var1 = [1, 2, 3]\n",
      "var2 = [4, 5, 6]\n",
      "[1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "list1 = [1, 2, 3]\n",
    "list2 = [4, 5, 6]\n",
    "addList = my_adding_function(list1, list2)\n",
    "print(addList)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Functions can have optional arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "def new_function(anInput, anOptionalInput = 1):\n",
    "    print(\"anInput:\", anInput)\n",
    "    print(\"anOptionalInput:\", anOptionalInput)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### If the optional argument isn't assigned, the default value is taken"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "With default value\n",
      "anInput: test\n",
      "anOptionalInput: 1\n",
      "****************\n",
      "With assigned value\n",
      "anInput: test\n",
      "anOptionalInput: not the default value\n"
     ]
    }
   ],
   "source": [
    "print(\"With default value\")\n",
    "new_function('test')\n",
    "print(\"****************\")\n",
    "print(\"With assigned value\")\n",
    "new_function(\"test\", 'not the default value')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### docstrings can be added to functions to give information about them"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "def a_function_with_docstring():\n",
    "    \"This is a docstring.  This function doesn't do anything\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### a function name followed by a \"?\" will show the docstring in ipython"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[0;31mSignature:\u001b[0m \u001b[0ma_function_with_docstring\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;31mDocstring:\u001b[0m This is a docstring.  This function doesn't do anything\n",
      "\u001b[0;31mFile:\u001b[0m      /var/folders/vg/x_r9qxhj4y55x8swvp3pw60w0000gn/T/ipykernel_2190/1310299108.py\n",
      "\u001b[0;31mType:\u001b[0m      function\n"
     ]
    }
   ],
   "source": [
    "a_function_with_docstring?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5: Libraries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The 'import' command is used to import libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "import TutorialLibraryOfFunctions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Printing a library name tells you what it is and where it's from"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<module 'TutorialLibraryOfFunctions' from '/Users/sterbini/CERNbox/2022/CAS/Sevrier2022/examples/TutorialLibraryOfFunctions.py'>\n"
     ]
    }
   ],
   "source": [
    "print(TutorialLibraryOfFunctions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### import library as name allows the same library to be imported with a much shorter name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "import TutorialLibraryOfFunctions as TLib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Printing the short name shows it is the same library"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<module 'TutorialLibraryOfFunctions' from '/Users/sterbini/CERNbox/2022/CAS/Sevrier2022/examples/TutorialLibraryOfFunctions.py'>\n"
     ]
    }
   ],
   "source": [
    "print(TLib)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### External libraries should provide docstrings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[0;31mSignature:\u001b[0m \u001b[0mTLib\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msin_function\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[0m\n",
      "\u001b[0;31mDocstring:\u001b[0m <no docstring>\n",
      "\u001b[0;31mFile:\u001b[0m      ~/CERNbox/2022/CAS/Sevrier2022/examples/TutorialLibraryOfFunctions.py\n",
      "\u001b[0;31mType:\u001b[0m      function\n"
     ]
    }
   ],
   "source": [
    "TLib.sin_function?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The library contents are accessed with libraryName.functionName"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9999996829318346\n"
     ]
    }
   ],
   "source": [
    "theta = 3.14/2\n",
    "sinTheta = TLib.sin_function(theta)\n",
    "print(sinTheta)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6: Numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Numpy is a fast and powerful mathematical library"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### array and lists are assigned and indexed the same way"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "myList[0]: 1\n",
      "myArray[0]: 1\n"
     ]
    }
   ],
   "source": [
    "myList = [1, 2, 3]\n",
    "myArray = np.array([1, 2, 3])\n",
    "print(\"myList[0]:\", myList[0])\n",
    "print(\"myArray[0]:\", myArray[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Both numpy array and python list can be multiplied by an integer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "newList = myList * 2\n",
    "newArray = myArray * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### But the behaviour is very different"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 1, 2, 3]\n",
      "[2 4 6]\n"
     ]
    }
   ],
   "source": [
    "print(newList)\n",
    "print(newArray)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Adding to a numpy array adds the value to every member of the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3 4 5]\n"
     ]
    }
   ],
   "source": [
    "newArray = myArray + 2\n",
    "print(newArray)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The array will understand any mathematical operator and it will act on every member of the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 4 9]\n"
     ]
    }
   ],
   "source": [
    "print(myArray ** 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The previously defined functions will also understand Numpy arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n",
      "var1 = [1 2 3]\n",
      "var2 = 10\n",
      "[11 12 13]\n"
     ]
    }
   ],
   "source": [
    "print(myArray)\n",
    "print(my_adding_function(myArray, 10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 7: Matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Matplotlib is a powerful plotting library"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Numpy arrays can be created, operated on, and used as plot input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "xAxis = np.linspace(0, 10, 100)\n",
    "yAxis = np.sin(xAxis)\n",
    "plt.plot(xAxis, yAxis)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Operations can be embedded within the function call"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(xAxis, yAxis**2)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Embedding plot calls in a for loop is one way to show multiple plots on the same axis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for i in range(4):\n",
    "    plt.plot(xAxis, yAxis**i, label='sin(x)**'+str(i))\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Numpy has random number generation, and the results can be shown in matplotlib with a scatter plot or a line plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "yRandom = np.random.rand(len(xAxis))\n",
    "plt.plot(xAxis, yRandom)\n",
    "plt.scatter(xAxis, yRandom)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Multiple scatter plots on the same axis can be created with different inputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "yRand1 = np.random.rand(len(xAxis))\n",
    "yRand2 = np.random.rand(len(xAxis))\n",
    "yRand3 = np.random.rand(len(xAxis))\n",
    "\n",
    "plt.scatter(xAxis, yRand1)\n",
    "plt.scatter(xAxis, yRand2)\n",
    "plt.scatter(xAxis, yRand3)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.12 ('base')",
   "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.9.12"
  },
  "vscode": {
   "interpreter": {
    "hash": "9442522243202b4067e6660a0d1fc54594be7bec28e92878ed764986224dbfdf"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}