01_Basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to jupyter notebooks & python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hier findet ihr einzelne jupyter notebook zellen die euch einzelne Konzepte von python zeigen sollen. Am ende habt ihr die wesentlichen Teile um selbst in python programmieren zu können!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zusammenfassung der Folien:\n",
    "\n",
    "**Programmieren ist das Erstellen von Anweisungen, die einem Computer sagen, was er tun soll.** Diese Anweisungen werden in einer bestimmten Sprache geschrieben, die von dem Computer verstanden wird. Diese Sprachen nennt man Programmiersprachen. Hierbei wird nochmals feiner unterschieden nach solchen Sprachen die eher \"lesbarer\" sind und solchen welche eher für den computer verständlicher sind. Auf einer \"Zentralen Recheneinheit\" oder \"Central Processing Unit\" laufen dann Instruktionen. Diese kann man auch direkt schreiben - in der sogenannten Assembler Programmiersprache. Diese behandeln wir nicht - wir nutzen python zum programmieren.\n",
    "\n",
    "**Das Grundprinzip der Programmierung ist das Eingabe-Verarbeitung-Ausgabe-Prinzip.** Dabei werden folgende Schritte ausgeführt:\n",
    "\n",
    "1. **Eingabe:** Der Computer erhält Daten (entweder aus einer Datei oder der Tastatur oder einem Sensor)\n",
    "2. **Verarbeitung:** Der Computer/die Funktion verarbeitet die Daten gemäß den Anweisungen - und zwar EXAKT so wie wir das instruiert haben!\n",
    "3. **Ausgabe:** Der Computer/die Funktion gibt die Ergebnisse der Verarbeitung an den Benutzer oder an ein anderes Programm/Funktion weiter.\n",
    "\n",
    "**Ein Beispiel für ein Programm ist ein Kochrezept oder in der Chemie Syntheseanleitungen!** Ein Kochrezept ist eine Liste von Anweisungen, die einem Koch/Köchin sagen, wie er/sie ein Gericht zubereiten soll. Die Eingabe sind die Zutaten und die Küchengeräte (sowie deren Parameter wie die Ofentemperatur). Die Verarbeitung ist das Kochen und Backen der Zutaten. Die Ausgabe ist das fertige Gericht.\n",
    "\n",
    "Ein Beispiel:\n",
    "\n",
    "```shell\n",
    "# Define the ingredients\n",
    "grapes = 150  # approximately 150g of seedless blue grapes\n",
    "sherry_vinegar = 1  # 1 tablespoon of Sherry vinegar\n",
    "olive_oil = 2  # 2 tablespoons of olive oil\n",
    "garlic = \"1 clove\"  # 1 clove of garlic, finely chopped\n",
    "brown_sugar = 0.5  # 1/2 teaspoon of brown sugar\n",
    "fennel_seeds = 0.5  # 1/2 teaspoon of fennel seeds\n",
    "burrata = 1  # 1 ball of Burrata cheese\n",
    "salt = \"to taste\"  # Salt (to taste)\n",
    "pepper = \"to taste\"  # Pepper (to taste)\n",
    "basil = 1  # 1-2 sprigs of fresh basil\n",
    "wooden_skewers = 4  # 4 wooden skewers\n",
    "\n",
    "# Preparation\n",
    "# 1. Wash the grapes and remove them from the stems.\n",
    "# 2. Peel and finely chop the garlic.\n",
    "# 3. Mix Sherry vinegar, olive oil, brown sugar, fennel seeds, salt, and pepper in a bowl to make the marinade. Set aside.\n",
    "# 4. Skewer 5-6 grapes on each wooden skewer.\n",
    "# 5. Wash and dry the basil leaves, removing them from the stems.\n",
    "\n",
    "# Cooking\n",
    "# 6. Heat a grill pan or a regular pan.\n",
    "# 7. Grill the grape skewers for about 2-3 minutes in the hot pan, turning them halfway through. Remove the pan from the heat.\n",
    "\n",
    "# Serving\n",
    "# 8. Cut the Burrata ball in half and place one half on each plate.\n",
    "# 9. Place two grape skewers on each plate.\n",
    "# 10. Drizzle the Burrata halves with the remaining marinade.\n",
    "# 11. Garnish with fresh basil leaves.\n",
    "# 12. Serve immediately.\n",
    "\n",
    "# Enjoy your marinated grilled grapes with Burrata!\n",
    "\n",
    "```\n",
    "\n",
    "**Ada Lovelace gilt als die erste Programmiererin.** Sie entwickelte im Jahr 1843 einen Algorithmus zur Berechnung von Bernoulli-Zahlen. Dieser Algorithmus kann als erstes Computerprogramm angesehen werden. Die implementierung in einen echten Computer kam erst knappte 100 Jahre später\n",
    "\n",
    "**Auch für Erstsemester in der Chemie ist Programmieren und Data Science ein wichtiges Werkzeug.** Es kann verwendet werden, um Experimente auszuwerten, Modelle zu erstellen und später sogar um Experimente und Simulationen zu automatisieren.\n",
    "\n",
    "**Teaser Datenmanagement** Daten sollten Suchbar (Findable), Zugänglich (Accesibile), Interoperabel (Interoperable) und Wiederverwendbar (Reuseable) sein. Nur so wird Forschung reproduzierbar und eine Datengetriebene Chemie möglich. Sobald wir die Grundzüge des Programmierens kennengelernt haben werden wir uns mit Datenmanagement beschäftigen. Sie sind übrigens die erste Kohorte die dies bereits im Ersten Semester Chemie behandelt.\n",
    "\n",
    "**Programmiersprache: python**\n",
    "\n",
    "Gründe für python:\n",
    "\n",
    "- Python ist frei und quelloffen.\n",
    "- Python ist plattformunabhängig.\n",
    "- Python ist eine relativ flexible Sprache.\n",
    "- Python ist relativ einfach zu lernen. \n",
    "- Python hat viele Ressourcen\n",
    "\n",
    "Nachteile:\n",
    "- Python ist relativ langsam\n",
    "- Python verbirt manche Konzepte der Programmierung und ist teilweise kontraintuitiv\n",
    "- GUI und Standalone Anwendungen sind etwas komplizierter umzusetzen\n",
    "\n",
    "## Syntax und Grundliegende Konzepte"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Ganzzahlen\n",
    "\n",
    "#Fließkommazahlen -> FLOPS sind fliekommaoperationen pro sekunde\n",
    "\n",
    "#Strings\n",
    "\n",
    "#Booleans\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#getting help\n",
    "help(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#initializing variables\n",
    "#python is odd as it is strongly weakly typed\n",
    "a = 3\n",
    "a += 3\n",
    "a -= 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#print them\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#strings can be added just like numbers\n",
    "string = 'Hallo'\n",
    "string += ' Welt!'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#switch a and b values and pass tuples\n",
    "a = 23\n",
    "b = 42\n",
    "b, a = a, b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#lists are very powerful... they organize numbers as lists!\n",
    "list = [1,1,2,3,5,8,13,42]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#dicts are kind of like a list but store things not sorted\n",
    "#but rather as key-value pairs ... kind of like a dictionary\n",
    "mydict = {\"Key 1\": \"Value 1\", 2: 3, \"pi\": 3.14}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(mydict['pi'])\n",
    "print(mydict['Key 1'])\n",
    "print(mydict[2])\n",
    "#this would create an error because there is no key named 0\n",
    "#print(mydict[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#you can make lists of things other than numbers\n",
    "sample = [1, [\"another\", \"list\"], (\"a\", \"tuple\")]\n",
    "mylist = [\"List item 1\", 2, 3.14]\n",
    "mylist[0] = \"List item 1 again\" # We're changing the item.\n",
    "mylist[-1] = 3.21 # Here, we refer to the last item."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#create an empty list or dict to add things later\n",
    "my_list = []\n",
    "my_dict = {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#add entries to the empty list\n",
    "my_list.append(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#you can even append a list to a list ...\n",
    "my_list.append(['a','b'])\n",
    "my_list.append(['a1','b1'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#now list contains two lists\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "#only print the first list\n",
    "print(my_list[1][0])\n",
    "print(my_list[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#the best library is numpy for anythign with numbers ...\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#is this ma matrix?\n",
    "data = np.array([[1, 1.1, 1.2],\n",
    "                 [2.1, 2.1, 2.6],\n",
    "                 [1.2, 5.2, 8.44],\n",
    "                 [5.6, 7.4, 5.45],\n",
    "                 [3.8, 3.8, 2.32]])\n",
    "print(data)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#you can print slices through a matrix!!\n",
    "print(data[:,1])\n",
    "print(data[1,:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#sometimes you need to print things in a formatted way\n",
    "print(\"X: %s mm Y: %s mm Z: %s mm\" % (42, 23, 0.01))\n",
    "print(\"X: {} mm Y: {} mm Z: {} mm\".format(42, 23, 0.01))\n",
    "\n",
    "print(\"This %(verb)s a %(noun)s.\" % {\"noun\": \"test\", \"verb\": \"is\"})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#a little bit of randomness is sometimes good\n",
    "from random import randint as zufallsInt\n",
    "zufallsZahl = zufallsInt(1,5000)\n",
    "print(zufallsZahl)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#looping in python works like this\n",
    "#you loop with something over an iteratable\n",
    "for a in [1,2,3,4]:\n",
    "  print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    " #range essentially gives an iterable to do something 10 times ... starts at 0!!\n",
    "\n",
    "rangelist = range(10)\n",
    "print(rangelist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python hat nur for loops und while loops sollten vermieden werden ... besseres design"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#a more complex example:\n",
    "for number in rangelist:\n",
    "    # Check if number is one of\n",
    "    # the numbers in the tuple.\n",
    "    if number in (3, 4, 7, 9):\n",
    "        # \"Break\" terminates a for without\n",
    "        # executing the \"else\" clause.\n",
    "        break\n",
    "    else:\n",
    "        # \"Continue\" starts the next iteration\n",
    "        # of the loop. It's rather useless here,\n",
    "        # as it's the last statement of the loop.\n",
    "        continue"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#do you understand this?\n",
    "\n",
    "if rangelist[1] == 2:\n",
    "    print(\"The second item (lists are 0-based) is 2\")\n",
    "else:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#list comprehensions ... powerfull shorthand stuff\n",
    "\n",
    "erster = [1,2,3,4,5]\n",
    "zweiter = [10, 100, 1000, 10000, 100000]\n",
    "listComprehension = [x*y for x in erster for y in zweiter]\n",
    "print(listComprehension)\n",
    "len(listComprehension)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'np' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/gf/ksqjl6fj4zj55hdfzlttfvwr0000gn/T/ipykernel_92839/3428676981.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mn\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0minary\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mel\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0mn\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn\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[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      7\u001b[0m \u001b[0m_comps\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mx\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mit\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mproduct\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrepeat\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minary\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0misclose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\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[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0m_comps\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'np' is not defined"
     ]
    }
   ],
   "source": [
    "#here is a complicated example that I use sometimes in my work\n",
    "#generate a ternary\n",
    "import itertools as it\n",
    "n=10\n",
    "inary=3\n",
    "el = np.array([i/n for i in range(n+1)])\n",
    "_comps = np.array([x for x in it.product(el, repeat=inary) if np.isclose(np.sum(x),1)])\n",
    "_comps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "#as a function this can be reused very easily\n",
    "#you can sepify default values by setting them to a number or anything else\n",
    "default = 3\n",
    "def myFunc(x,y=default):\n",
    "  z = x+y\n",
    "  return z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "#or even do complex stuff:\n",
    "def genComp(n=20,inary=4):\n",
    "    el = np.array([i/n for i in range(n+1)])\n",
    "    _comps = np.array([x for x in it.product(el, repeat=inary) if np.isclose(np.sum(x),1)])\n",
    "\n",
    "xy = genComp(n=10,inary=3)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "#try to understand this line:\n",
    "sum([1 for i in [6, 5, 4, 4, 9] if i == 4])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "#bad programming\n",
    "def crazyFunc(a, b, addOne=False, additor=0):\n",
    "    #return some fraction of a/b+1+n\n",
    "    if addOne==True:\n",
    "        return a/b+1\n",
    "    elif additor!=0:\n",
    "        return a/b+additor\n",
    "    else:\n",
    "        return a/b\n",
    "\n",
    "#better ... yet not good\n",
    "def crazyFunc2(a, b, addOne=False, additor=0):\n",
    "    #return some fraction of a/b+1+n\n",
    "    if addOne==True:\n",
    "        z = a/b+1\n",
    "    elif additor!=0:\n",
    "        z = a/b+additor\n",
    "    else:\n",
    "        z = a/b\n",
    "    return z\n",
    "\n",
    "z = crazyFunc(3,2,addOne=True,additor=1)\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fehlerfehler():\n",
    "    try:\n",
    "        1 / 0\n",
    "        #das universum kaputt\n",
    "    except ZeroDivisionError:\n",
    "        print(\"Duch Null teilen ist verboten.\")\n",
    "    else:\n",
    "        pass\n",
    "        #you may pass\n",
    "    finally:\n",
    "        #finally something is being done\n",
    "        print(\"Noch was gemacht.\")\n",
    "\n",
    "fehlerfehler()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#objects are powerful things that can store values and functions and be initialized\n",
    "#don't need to understand this for now 100%\n",
    "class meineKlasse(object):\n",
    "    allgeminErreichbar = 10\n",
    "    def __init__(self):\n",
    "        self.meineVariable = 3\n",
    "    def meineFunktioninMeinerKlasse(self, arg1, arg2):\n",
    "        return self.meineVariable\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "#There is one strangeness (and others) in python regarding scope ...\n",
    "def ändertNix():\n",
    "    # This will correctly change the global.\n",
    "    x = 3\n",
    "\n",
    "def ändert():\n",
    "    global x\n",
    "    # This will correctly change the global.\n",
    "    x = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "x = 2\n",
    "ändertNix()\n",
    "print(x)\n",
    "ändert()\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#same thing like this:\n",
    "a = 3\n",
    "b = 2\n",
    "c = a+b\n",
    "print(c)\n",
    "b=8\n",
    "print(c)#whatt??"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#finally ploting\n",
    "import matplotlib.pyplot as plt\n",
    "plt.plot([1,2,3,4], [1,4,9,16], 'ro')\n",
    "plt.axis([0, 6, 0, 20])\n",
    "plt.ylabel('Y LABEL')\n",
    "plt.xlabel('xxx')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "#ok now you ahave come this far and can run some really complicated stuff ... use it to play around a bit!\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Fixing random state for reproducibility\n",
    "np.random.seed(1337)\n",
    "\n",
    "mu, sigma = 100, 15\n",
    "x = mu + sigma * np.random.randn(10000)\n",
    "\n",
    "# the histogram of the data\n",
    "n, bins, patches = plt.hist(x, 50, normed=1, facecolor='g', alpha=0.75)\n",
    "plt.xlabel('Xlabel')\n",
    "plt.ylabel('Ylabel')\n",
    "plt.title('Title')\n",
    "plt.text(60, .025, r'$\\mu=100,\\ \\sigma=15$')\n",
    "plt.axis([40, 160, 0, 0.03])\n",
    "plt.grid(True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from matplotlib.ticker import NullFormatter  # useful for `logit` scale\n",
    "\n",
    "# Fixing random state for reproducibility\n",
    "np.random.seed(1337)\n",
    "\n",
    "# make up some data in the interval ]0, 1[\n",
    "y = np.random.normal(loc=0.5, scale=0.4, size=1000)\n",
    "y = y[(y > 0) & (y < 1)]\n",
    "y.sort()\n",
    "x = np.arange(len(y))\n",
    "\n",
    "plt.plot(x, y - y.mean())\n",
    "plt.yscale('log', linthreshy=0.01)\n",
    "plt.title('log')\n",
    "plt.grid(True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#fibonacchi example\n",
    "#no good list comprehension way found\n",
    "fib = np.ones([20,1])\n",
    "for i in range(2,20):\n",
    "    fib[i] = fib[i-1] + fib[i-2]\n",
    "print(fib)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "#fibonacchi example\n",
    "#caluclate the ratio\n",
    "fib = np.ones([100,1])\n",
    "ratio = np.empty([100,1])\n",
    "ratio[0] = 1\n",
    "ratio[1] = 1\n",
    "for i in range(2,100):\n",
    "    fib[i] = fib[i-1] + fib[i-2]\n",
    "    ratio[i] = fib[i]/fib[i-1]\n",
    "print(ratio)\n",
    "from matplotlib import pyplot as pyplot\n",
    "\n",
    "fig = plt.figure(figsize=[10,5])\n",
    "ax = plt.subplot(111)\n",
    "#ax = plt.gca()\n",
    "i = [j for j in range(100)]\n",
    "plot = plt.plot(i,ratio)\n",
    "# use keyword args\n",
    "plt.setp(plot, marker='o', color='k', linewidth=0.5)\n",
    "ax.axis([1, 100, 0.9, 2.1])\n",
    "ax.set_xscale(\"log\", nonposx='clip')\n",
    "#for axis in ['top','bottom','left','right']:\n",
    "#  ax.spines[axis].set_linewidth(2.5)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "#functional programming\n",
    "#python is a multi paradigm language\n",
    "#for developing algorithms it is sometimes useful\n",
    "#to know what functional programming is\n",
    "#here are some basic concepts\n",
    "\n",
    "#iterators\n",
    "\n",
    "h = iter(range(5))\n",
    "print(h)\n",
    "print(next(h))\n",
    "print(next(h))\n",
    "print(next(h))\n",
    "print(next(h))\n",
    "\n",
    "#generators - functions that create iterators i.e. resumable functions\n",
    "def generate_squares(N):\n",
    "    for i in range(N):\n",
    "        yield i**2\n",
    "\n",
    "sq = generate_squares(10)\n",
    "print(next(sq))\n",
    "print(next(sq))\n",
    "print(next(sq))\n",
    "print(next(sq))\n",
    "print(next(sq))\n",
    "\n",
    "#lambda - very shorthand one line functions\n",
    "\n",
    "add = lambda x, y: x + y\n",
    "multiply = lambda x,y : x*y\n",
    "square = lambda x : x**2\n",
    "isgreater = lambda x,y : x>y\n",
    "\n",
    "print(add(3,2))\n",
    "print(multiply(2.5,2))\n",
    "print(isgreater(2.5,2))\n",
    "\n",
    "#example\n",
    "a = [(1, 2), (4, 1,3), (9, 10,6,7,8), (-1,13, -3)]\n",
    "a.sort(key=lambda x: x[-1])\n",
    "\n",
    "#map - apply a function to a list\n",
    "_squared = map(square,[i for i in range(100)])\n",
    "#squared = [s for s in _squared]\n",
    "\n",
    "_cubed = map(lambda x: x**3, [i for i in range(100)])\n",
    "\n",
    "def fsquare(x):\n",
    "    return x**2\n",
    "def fqube(x):\n",
    "    return x**3\n",
    "\n",
    "calcs = [fsquare,fqube]\n",
    "_manycalcs = map(calcs, [i for i in range(10)])\n",
    "\n",
    "#filters\n",
    "even_nums = filter(lambda x: x % 2 == 0, range(30))\n",
    "val = [k for k in even_nums]\n",
    "val\n",
    "\n",
    "#reduce - rolling excecution of functions on lists\n",
    "#recommended to use for loops but conceptualy important\n",
    "from functools import reduce\n",
    "vecsum = reduce(lambda x, y : x+y, [1,-1,1,-1])\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "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.10.10"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}