conditionals and functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "6569d55e-56fb-406b-9be7-6f808f841e9d",
   "metadata": {},
   "source": [
    "# Conditionals\n",
    "* how do we make a program take action when certain conditions are satisifed?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "1f2372ee-7220-4e73-a6fc-bacfa869699e",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Not greater\n",
      "done\n"
     ]
    }
   ],
   "source": [
    "num = 37\n",
    "if num > 100:\n",
    "    print(\"greater\")\n",
    "else:\n",
    "    print(\"Not greater\")\n",
    "print(\"done\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3bf7d1b5-c151-4e00-ab12-428dc2efad9b",
   "metadata": {},
   "source": [
    "* explain if\n",
    "* explain else\n",
    "* mention indentation, compare with for loops\n",
    "* show flowchart\n",
    "* we don't need an else, but nothing happens if the condition is false\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "fe98a545-7ad5-4269-a7a4-ac898a99cc83",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "before conditional...\n",
      "...after conditional\n"
     ]
    }
   ],
   "source": [
    "num = 53\n",
    "print('before conditional...')\n",
    "if num > 100:\n",
    "    print(num, 'is greater than 100')\n",
    "print('...after conditional')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d782259-4a7a-48c2-9889-5cffe74dfc30",
   "metadata": {},
   "source": [
    "* we can chain several tests together with elif"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "630ad093-bdf0-49d2-9182-523f5ad5631f",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-3 is negative\n"
     ]
    }
   ],
   "source": [
    "num = -3\n",
    "\n",
    "if num > 0:\n",
    "    print(num, 'is positive')\n",
    "elif num == 0:\n",
    "    print(num, 'is zero')\n",
    "else:\n",
    "    print(num, 'is negative')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6db9d55e-b415-4e03-a923-249d59e85a9a",
   "metadata": {},
   "source": [
    "* comparing in python, cover < > == != >= <=\n",
    "* combining operators: and, or"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f79a6404-2975-439a-a43b-b207887d1c4b",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "at least one part is false\n"
     ]
    }
   ],
   "source": [
    "if (1 > 0) and (-1 >= 0):\n",
    "    print('both parts are true')\n",
    "else:\n",
    "    print('at least one part is false')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "81d9371e-d193-43e8-a781-ad400d3a992d",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "at least one test is true\n"
     ]
    }
   ],
   "source": [
    "if (1 < 0) or (1 >= 0):\n",
    "    print('at least one test is true')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84dd5af4-6e8e-426e-839d-ca72eb97f9c0",
   "metadata": {},
   "source": [
    "* True and False are booleans, 1 < 0 returns false, -1 < 0 True"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "626c4dc7-3279-45f8-b9dc-6bae9036f521",
   "metadata": {
    "tags": []
   },
   "source": [
    "* making a descision on when it is safe to go to sea\n",
    "* we want waves under 3m\n",
    "* which months can we operate safely?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "edb65d7e-dc73-4a45-b8af-ca52559f5842",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.599567567567566\n"
     ]
    }
   ],
   "source": [
    "import numpy\n",
    "\n",
    "data = numpy.loadtxt(fname='data/wavesmonthly.csv', delimiter=',', skiprows=1)\n",
    "reshaped_data = numpy.reshape(data[:,2], [37,12])\n",
    "\n",
    "month0 = numpy.mean(reshaped_data, axis=0)[0]\n",
    "print(month0)\n",
    "if month0 < 3:\n",
    "    print(\"can't take passengers out\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "a20287b4-586b-4ce7-bc3e-869b9938640c",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Can't take any boats out to sea\n"
     ]
    }
   ],
   "source": [
    "if month0 < 3:\n",
    "    print(\"can't take passengers out\")\n",
    "elif month0 < 4:\n",
    "    print(\"Can take survey vehicles (but not passengers)\")\n",
    "else:\n",
    "    print(\"Can't take any boats out to sea\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "f0a2980d-0774-4030-8fa5-9c8b8e0f7ce6",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.3072972972972976\n",
      "Can take passengers this month\n"
     ]
    }
   ],
   "source": [
    "#try it for june\n",
    "month5 = numpy.mean(reshaped_data, axis=0)[5]\n",
    "print(month5)\n",
    "\n",
    "if month5 < 3:\n",
    "    print('Can take passengers this month')\n",
    "elif month5 < 4:\n",
    "    print('Can take survey vehicles (but not passengers)')\n",
    "else:\n",
    "    print(\"Can't take any boats out to sea\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9dc551b-f764-4d62-ab96-3a18644c75ba",
   "metadata": {},
   "source": [
    "* we can write a loop to test this for every month"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "2a4a6b42-346a-4723-98f2-328c51054116",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Month 0: we can't take any boats out to sea this month\n",
      "Month 1: we can't take any boats out to sea this month\n",
      "Month 2: we can't take any boats out to sea this month\n",
      "Month 3: we can take survey vehicles (but not passengers) this month\n",
      "Month 4: we can take passengers this month\n",
      "Month 5: we can take passengers this month\n",
      "Month 6: we can take passengers this month\n",
      "Month 7: we can take passengers this month\n",
      "Month 8: we can take passengers this month\n",
      "Month 9: we can take survey vehicles (but not passengers) this month\n",
      "Month 10: we can take survey vehicles (but not passengers) this month\n",
      "Month 11: we can't take any boats out to sea this month\n"
     ]
    }
   ],
   "source": [
    "for month_index, monthly_waveheight in enumerate(numpy.mean(reshaped_data, axis=0)):\n",
    "    if monthly_waveheight < 3:\n",
    "        print(f\"Month {month_index}: we can take passengers this month\")\n",
    "    elif monthly_waveheight < 4:\n",
    "        print(f\"Month {month_index}: we can take survey vehicles (but not passengers) this month\")\n",
    "    else:\n",
    "        print(f\"Month {month_index}: we can't take any boats out to sea this month\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ee37488-fd80-408d-82d8-119be9089aea",
   "metadata": {},
   "source": [
    "* remember enumerate gives us the index and the value, pythonic way to get index values in a loop"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa95c6a2-663e-460f-b6a0-9c2ed8038bc8",
   "metadata": {},
   "source": [
    "* could now use this to suggest a plan for a ferry company\n",
    "\n",
    "## Exercises"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "fb577e0d-9c33-4e45-adcb-bd5ff828ac3b",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C\n"
     ]
    }
   ],
   "source": [
    "if 4 > 5:\n",
    "    print('A')\n",
    "elif 4 == 5:\n",
    "    print('B')\n",
    "elif 4 < 5:\n",
    "    print('C')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "fd48f78b-0c8b-406d-b193-c75948c7966e",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "word is true\n",
      "non-empty list is true\n",
      "one is true\n"
     ]
    }
   ],
   "source": [
    "if '':\n",
    "    print('empty string is true')\n",
    "if 'word':\n",
    "    print('word is true')\n",
    "if []:\n",
    "    print('empty list is true')\n",
    "if [1, 2, 3]:\n",
    "    print('non-empty list is true')\n",
    "if 0:\n",
    "    print('zero is true')\n",
    "if 1:\n",
    "    print('one is true')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "645b9072-550b-4013-a488-e59a829a397e",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "empty string is not true\n",
      "not not True is true\n"
     ]
    }
   ],
   "source": [
    "if not '':\n",
    "    print('empty string is not true')\n",
    "if not 'word':\n",
    "    print('word is not true')\n",
    "if not not True:\n",
    "    print('not not True is true')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "f1647089-d2de-4aa6-8793-2f0b1c351a25",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "a = 5\n",
    "b = 5.5\n",
    "\n",
    "if abs(a - b) <= 0.1 * abs(b):\n",
    "    print('True')\n",
    "else:\n",
    "    print('False')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "3bdd42c4-8889-471b-9039-e0ee76042ba9",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(abs(a - b) <= 0.1 * abs(b))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "10999790-3c7c-483b-b11f-c9b1682f5e16",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "x = 1  # original value\n",
    "x += 1 # add one to x, assigning result back to x\n",
    "x *= 3 # multiply x by 3\n",
    "print(x)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "6af07106-8b51-481a-bc67-772f8a4d5989",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "filenames = ['wavesmonthly.csv',\n",
    "         'waves_00s.csv',\n",
    "         'waves_10s.csv',\n",
    "         'waves_80s.csv',\n",
    "         'waves_90s.csv',\n",
    "         'multyear_hs_avg.nc']\n",
    "csv_files = []\n",
    "nc_files = []\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "c9d4926b-c3f8-42db-a17d-01ee0e241958",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "csv_files = ['waves_00s.csv', 'waves_10s.csv', 'waves_80s.csv', 'waves_90s.csv', 'wavesmonthly.csv']\n",
    "nc_files = ['multyear_hs_avg.nc']\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "fd024596-1af0-467f-bd9a-daec06da1ce7",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "csv_files: ['wavesmonthly.csv', 'waves_00s.csv', 'waves_10s.csv', 'waves_80s.csv', 'waves_90s.csv']\n",
      "nc_files: ['multyear_hs_avg.nc']\n",
      "other_files: []\n"
     ]
    }
   ],
   "source": [
    "csv_files = []\n",
    "nc_files = []\n",
    "other_files = []\n",
    "\n",
    "for filename in filenames:\n",
    "    if filename.endswith('csv'):\n",
    "        csv_files.append(filename)\n",
    "    elif filename.endswith('nc'):\n",
    "        nc_files.append(filename)\n",
    "    else:\n",
    "        other_files.append(filename)\n",
    "\n",
    "print('csv_files:', csv_files)\n",
    "print('nc_files:', nc_files)\n",
    "print('other_files:', other_files)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "921ebf0d-9d68-433a-b537-32d7e05a18ad",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number of vowels in this string is 6\n"
     ]
    }
   ],
   "source": [
    "vowels = 'aeiouAEIOU'\n",
    "sentence = 'Mary had a little lamb.'\n",
    "count = 0\n",
    "for char in sentence:\n",
    "    if char in vowels:\n",
    "        count += 1\n",
    "\n",
    "print('The number of vowels in this string is ' + str(count))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b3409c8-32ff-4951-b083-327d65561768",
   "metadata": {},
   "source": [
    "## Recap\n",
    "* Use if condition to start a conditional statement, elif condition to provide additional tests, and else to provide a default.\n",
    "* The bodies of the branches of conditional statements must be indented.\n",
    "* Use == to test for equality.\n",
    "* X and Y is only true if both X and Y are true.\n",
    "* X or Y is true if either X or Y, or both, are true.\n",
    "* Zero, the empty string, and the empty list are considered false; all other numbers, strings, and lists are considered true.\n",
    "* True and False represent truth values."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d8ebf84-5350-4c54-ab02-2b95b00a5e6a",
   "metadata": {},
   "source": [
    "# Creating Functions\n",
    "* code is getting long and complicated now\n",
    "* what if we had lots of datasets to apply it to? don't want figures for each\n",
    "* needs modularising into functions\n",
    "* create a fahr_to_celsius function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "6b172aee-f63a-44d3-934f-7baf4a5affa8",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def fahr_to_celsius(temp):\n",
    "    return ((temp - 32) * (5/9))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8b147ba-1ae0-449e-a761-a0402fdea86c",
   "metadata": {},
   "source": [
    "* def statement, function name, parameter names, return statement, return value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "407c9366-56ce-4e4b-8c40-29da014aa0c8",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fahr_to_celsius(32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "e34a67f7-b780-408c-b7c8-3876b4ddf17b",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "freezing point of water: 0.0 C\n",
      "boiling point of water: 100.0 C\n"
     ]
    }
   ],
   "source": [
    "print('freezing point of water:', fahr_to_celsius(32), 'C')\n",
    "print('boiling point of water:', fahr_to_celsius(212), 'C')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0e03150-00b7-4dd5-a5df-743cbb76e9e9",
   "metadata": {},
   "source": [
    "* write a celsius to kelvin function as well"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "646ebbda-4a54-4e6e-bfc9-12cbe2481666",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "freezing point of water in Kelvin: 273.15\n"
     ]
    }
   ],
   "source": [
    "def celsius_to_kelvin(temp_c):\n",
    "    return temp_c + 273.15\n",
    "\n",
    "print('freezing point of water in Kelvin:', celsius_to_kelvin(0.))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abb956ca-336c-4d8b-bfb4-8935acf758b4",
   "metadata": {},
   "source": [
    "* what about fahrenheit to kelvin, we can combine our two existing functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "5e282c22-1996-4ca7-8090-60ce4ef6bc27",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "boiling point of water in Kelvin: 373.15\n"
     ]
    }
   ],
   "source": [
    "def fahr_to_kelvin(temp_f):\n",
    "    temp_c = fahr_to_celsius(temp_f)\n",
    "    temp_k = celsius_to_kelvin(temp_c)\n",
    "    return temp_k\n",
    "\n",
    "print('boiling point of water in Kelvin:', fahr_to_kelvin(212.0))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1f418f1-fd47-421c-ba13-35bba36f9d1b",
   "metadata": {},
   "source": [
    "* real functions usually a bit bigger, 10s of lines\n",
    "\n",
    "* variable scope, variables inside functions are local to function\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "e0ac2340-ad15-47c5-87f9-5ccc820a0e4d",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'temp_k' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[53], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mAgain, temperature in Kelvin was:\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[43mtemp_k\u001b[49m)\n",
      "\u001b[0;31mNameError\u001b[0m: name 'temp_k' is not defined"
     ]
    }
   ],
   "source": [
    "print('Again, temperature in Kelvin was:', temp_k)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "013e2740-51d6-4d82-8957-07a8c0966a4e",
   "metadata": {},
   "source": [
    "* can't access temp_k variable that was used inside the function\n",
    "* variables can be global, accessible in and out of the function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "91748541-d554-4aee-965a-af6a3ff54ad6",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "temperature in Fahrenheit was: 212.0\n",
      "temperature in Kelvin was: 373.15\n"
     ]
    }
   ],
   "source": [
    "def print_temperatures():\n",
    "  print('temperature in Fahrenheit was:', temp_fahr)\n",
    "  print('temperature in Kelvin was:', temp_kelvin)\n",
    "\n",
    "temp_fahr = 212.0\n",
    "temp_kelvin = fahr_to_kelvin(temp_fahr)\n",
    "\n",
    "print_temperatures()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36a01af1-6b9e-4ba6-86f4-c5b69ca01f44",
   "metadata": {},
   "source": [
    "* let's tidy up the plotting code we wrote before\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "eff600fc-9ff2-471e-9497-73e633a1f07a",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot\n",
    "\n",
    "def visualize(filename):\n",
    "\n",
    "    data = numpy.loadtxt(fname=filename, delimiter=',')\n",
    "    reshaped_data = numpy.reshape(data[:,2], [10,12])\n",
    "\n",
    "    fig = matplotlib.pyplot.figure(figsize=(10.0, 3.0))\n",
    "\n",
    "    axes1 = fig.add_subplot(1, 3, 1)\n",
    "    axes2 = fig.add_subplot(1, 3, 2)\n",
    "    axes3 = fig.add_subplot(1, 3, 3)\n",
    "\n",
    "    axes1.set_ylabel('average')\n",
    "    axes1.plot(numpy.mean(reshaped_data, axis=0))\n",
    "\n",
    "    axes2.set_ylabel('max')\n",
    "    axes2.plot(numpy.max(reshaped_data, axis=0))\n",
    "\n",
    "    axes3.set_ylabel('min')\n",
    "    axes3.plot(numpy.min(reshaped_data, axis=0))\n",
    "\n",
    "    fig.tight_layout()\n",
    "    matplotlib.pyplot.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "e1720f6b-ee64-4837-8bc8-8be738f11816",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def detect_problems(filename):\n",
    "\n",
    "    data = numpy.loadtxt(fname=filename, delimiter=',')\n",
    "    \n",
    "    reshaped_data = numpy.reshape(data[:,2], [10,12])\n",
    "\n",
    "    if numpy.max(reshaped_data, axis=0)[0] == 0 and numpy.max(reshaped_data, axis=0)[11] == 11:\n",
    "        print('Suspicious looking maxima!')\n",
    "    elif numpy.sum(numpy.min(reshaped_data, axis=0)) == 0:\n",
    "        print('Minima add up to zero!')\n",
    "    else:\n",
    "        print('Seems OK!')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "id": "0a6c23f8-4b0e-4de8-b43c-c5dbe6f4884f",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data/waves_00s.csv\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x300 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Seems OK!\n",
      "data/waves_10s.csv\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "cannot reshape array of size 72 into shape (10,12)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[114], line 7\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m filename \u001b[38;5;129;01min\u001b[39;00m filenames[:\u001b[38;5;241m3\u001b[39m]:\n\u001b[1;32m      6\u001b[0m     \u001b[38;5;28mprint\u001b[39m(filename)\n\u001b[0;32m----> 7\u001b[0m     \u001b[43mvisualize\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfilename\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m      8\u001b[0m     detect_problems(filename)\n",
      "Cell \u001b[0;32mIn[112], line 6\u001b[0m, in \u001b[0;36mvisualize\u001b[0;34m(filename)\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mvisualize\u001b[39m(filename):\n\u001b[1;32m      5\u001b[0m     data \u001b[38;5;241m=\u001b[39m numpy\u001b[38;5;241m.\u001b[39mloadtxt(fname\u001b[38;5;241m=\u001b[39mfilename, delimiter\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m,\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[0;32m----> 6\u001b[0m     reshaped_data \u001b[38;5;241m=\u001b[39m \u001b[43mnumpy\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mreshape\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata\u001b[49m\u001b[43m[\u001b[49m\u001b[43m:\u001b[49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m10\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m12\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m      8\u001b[0m     fig \u001b[38;5;241m=\u001b[39m matplotlib\u001b[38;5;241m.\u001b[39mpyplot\u001b[38;5;241m.\u001b[39mfigure(figsize\u001b[38;5;241m=\u001b[39m(\u001b[38;5;241m10.0\u001b[39m, \u001b[38;5;241m3.0\u001b[39m))\n\u001b[1;32m     10\u001b[0m     axes1 \u001b[38;5;241m=\u001b[39m fig\u001b[38;5;241m.\u001b[39madd_subplot(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m3\u001b[39m, \u001b[38;5;241m1\u001b[39m)\n",
      "File \u001b[0;32m<__array_function__ internals>:180\u001b[0m, in \u001b[0;36mreshape\u001b[0;34m(*args, **kwargs)\u001b[0m\n",
      "File \u001b[0;32m~/mambaforge/envs/pangeo/lib/python3.10/site-packages/numpy/core/fromnumeric.py:298\u001b[0m, in \u001b[0;36mreshape\u001b[0;34m(a, newshape, order)\u001b[0m\n\u001b[1;32m    198\u001b[0m \u001b[38;5;129m@array_function_dispatch\u001b[39m(_reshape_dispatcher)\n\u001b[1;32m    199\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mreshape\u001b[39m(a, newshape, order\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mC\u001b[39m\u001b[38;5;124m'\u001b[39m):\n\u001b[1;32m    200\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m    201\u001b[0m \u001b[38;5;124;03m    Gives a new shape to an array without changing its data.\u001b[39;00m\n\u001b[1;32m    202\u001b[0m \n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    296\u001b[0m \u001b[38;5;124;03m           [5, 6]])\u001b[39;00m\n\u001b[1;32m    297\u001b[0m \u001b[38;5;124;03m    \"\"\"\u001b[39;00m\n\u001b[0;32m--> 298\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_wrapfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[43ma\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mreshape\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnewshape\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43morder\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43morder\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[0;32m~/mambaforge/envs/pangeo/lib/python3.10/site-packages/numpy/core/fromnumeric.py:57\u001b[0m, in \u001b[0;36m_wrapfunc\u001b[0;34m(obj, method, *args, **kwds)\u001b[0m\n\u001b[1;32m     54\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m _wrapit(obj, method, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwds)\n\u001b[1;32m     56\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m---> 57\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mbound\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     58\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m:\n\u001b[1;32m     59\u001b[0m     \u001b[38;5;66;03m# A TypeError occurs if the object does have such a method in its\u001b[39;00m\n\u001b[1;32m     60\u001b[0m     \u001b[38;5;66;03m# class, but its signature is not identical to that of NumPy's. This\u001b[39;00m\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m     64\u001b[0m     \u001b[38;5;66;03m# Call _wrapit from within the except clause to ensure a potential\u001b[39;00m\n\u001b[1;32m     65\u001b[0m     \u001b[38;5;66;03m# exception has a traceback chain.\u001b[39;00m\n\u001b[1;32m     66\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m _wrapit(obj, method, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwds)\n",
      "\u001b[0;31mValueError\u001b[0m: cannot reshape array of size 72 into shape (10,12)"
     ]
    }
   ],
   "source": [
    "import glob\n",
    "\n",
    "filenames = sorted(glob.glob('data/waves_*.csv'))\n",
    "\n",
    "for filename in filenames[:3]:\n",
    "    print(filename)\n",
    "    visualize(filename)\n",
    "    detect_problems(filename)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aea1e663-adc6-405c-98f0-1167343db85a",
   "metadata": {},
   "source": [
    "* functions can be re-used\n",
    "* lets have one to offset a dataset so that it's mean shifts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "074af060-3a80-41e4-acb2-5cafc108172b",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def offset_mean(data, target_mean_value):\n",
    "    return (data - numpy.mean(data)) + target_mean_value\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "563e2d90-fc62-430c-8a49-4356c62b818e",
   "metadata": {},
   "source": [
    "* use some dummy data to test it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "8a7d19d0-7ed7-4e58-8ce6-39d12e10cce3",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[3. 3.]\n",
      " [3. 3.]]\n"
     ]
    }
   ],
   "source": [
    "z = numpy.zeros((2,2))\n",
    "print(offset_mean(z, 3))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "87328874-61a7-4606-9b13-4e96055c5981",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 4.04436937e-01  3.84436937e-01  1.39043694e+00 -5.65563063e-01\n",
      "  -6.49563063e-01 -1.29756306e+00 -1.31756306e+00 -1.14756306e+00\n",
      "  -6.15630631e-02  1.28436937e-01  9.64436937e-01  1.24443694e+00]\n",
      " [ 2.82436937e-01  9.42436937e-01  1.38436937e-01 -2.03563063e-01\n",
      "  -1.42956306e+00 -1.66356306e+00 -1.52356306e+00 -1.43356306e+00\n",
      "  -2.73563063e-01  3.96436937e-01  9.04369369e-02  1.89643694e+00]\n",
      " [ 1.68443694e+00  1.57043694e+00  3.86436937e-01 -9.81563063e-01\n",
      "  -1.21756306e+00 -1.29956306e+00 -1.13756306e+00 -1.15556306e+00\n",
      "  -7.49563063e-01  1.02643694e+00  9.58436937e-01 -1.03563063e-01]\n",
      " [ 3.46436937e-01  1.50243694e+00  1.37643694e+00 -1.95563063e-01\n",
      "  -8.55563063e-01 -1.72156306e+00 -1.43156306e+00 -9.95563063e-01\n",
      "  -4.75630631e-02  6.50436937e-01  1.11843694e+00  2.05443694e+00]\n",
      " [ 3.57243694e+00 -2.75630631e-02  1.04243694e+00 -3.63563063e-01\n",
      "  -1.48156306e+00 -9.91563063e-01 -1.14156306e+00 -1.06556306e+00\n",
      "  -7.33563063e-01  9.58436937e-01 -1.55563063e-01  1.16043694e+00]\n",
      " [ 2.15643694e+00  1.79043694e+00 -6.27563063e-01 -3.79563063e-01\n",
      "  -1.40356306e+00 -1.22756306e+00 -1.71556306e+00 -1.29956306e+00\n",
      "  -6.83563063e-01  1.04369369e-02  1.32436937e-01  1.40643694e+00]\n",
      " [-2.21563063e-01  3.20436937e-01  4.20436937e-01 -2.23563063e-01\n",
      "  -1.17756306e+00 -1.36156306e+00 -1.37956306e+00 -1.17956306e+00\n",
      "  -7.71563063e-01 -5.35630631e-02  7.64369369e-02  8.74436937e-01]\n",
      " [ 1.73843694e+00 -7.21563063e-01  1.86843694e+00 -9.29563063e-01\n",
      "  -7.75563063e-01 -1.25956306e+00 -1.58956306e+00 -1.71756306e+00\n",
      "  -2.85563063e-01  1.52643694e+00  1.76643694e+00  1.91243694e+00]\n",
      " [-3.77563063e-01  3.18436937e-01  8.32436937e-01 -4.09563063e-01\n",
      "  -9.55563063e-01 -1.56356306e+00 -1.45356306e+00 -1.41956306e+00\n",
      "  -8.15630631e-02 -2.03563063e-01  5.84369369e-02  1.80436937e-01]\n",
      " [ 9.20436937e-01  7.42436937e-01  3.40436937e-01 -6.57563063e-01\n",
      "  -9.63563063e-01 -1.21356306e+00 -1.28756306e+00 -1.10356306e+00\n",
      "  -3.85563063e-01 -3.19563063e-01  6.44369369e-02  1.69843694e+00]\n",
      " [ 2.88843694e+00  2.69043694e+00  1.31843694e+00 -8.11563063e-01\n",
      "  -6.97563063e-01 -1.37956306e+00 -1.31756306e+00 -6.05563063e-01\n",
      "   3.86436937e-01  2.92436937e-01 -4.03563063e-01  4.90436937e-01]\n",
      " [ 2.62443694e+00  2.50843694e+00  2.78443694e+00  1.85443694e+00\n",
      "   1.15043694e+00  1.20043694e+00  1.26443694e+00  1.30443694e+00\n",
      "   1.68043694e+00  1.64843694e+00  1.52843694e+00  2.14643694e+00]\n",
      " [ 1.04443694e+00  5.98436937e-01  8.44369369e-02 -6.95630631e-02\n",
      "  -9.79563063e-01 -1.51356306e+00 -1.76356306e+00 -9.21563063e-01\n",
      "  -6.15563063e-01  4.38436937e-01  9.86436937e-01  1.56643694e+00]\n",
      " [ 1.16643694e+00  2.18243694e+00  1.45443694e+00 -2.55563063e-01\n",
      "  -8.81563063e-01 -1.03556306e+00 -1.13556306e+00 -1.11356306e+00\n",
      "  -8.47563063e-01 -4.07563063e-01  1.24443694e+00  1.37443694e+00]\n",
      " [ 3.08643694e+00  1.44043694e+00  1.28643694e+00 -3.93563063e-01\n",
      "  -1.07556306e+00 -1.12556306e+00 -1.38556306e+00 -9.73563063e-01\n",
      "  -1.54956306e+00 -7.75630631e-02  8.96436937e-01  1.54443694e+00]\n",
      " [ 2.28243694e+00  1.08443694e+00  2.80043694e+00  8.14436937e-01\n",
      "  -1.18556306e+00 -7.77563063e-01 -1.23756306e+00 -1.48756306e+00\n",
      "  -8.37563063e-01 -4.89563063e-01  5.04436937e-01  1.95043694e+00]\n",
      " [ 1.72843694e+00  2.04443694e+00  1.18443694e+00  2.78436937e-01\n",
      "  -1.33556306e+00 -1.62156306e+00 -1.37356306e+00 -1.20156306e+00\n",
      "  -5.09563063e-01  2.56436937e-01 -1.37563063e-01 -1.47563063e-01]\n",
      " [ 2.64436937e-01  6.78436937e-01 -4.39563063e-01 -4.81563063e-01\n",
      "  -1.20556306e+00 -1.01556306e+00 -1.23156306e+00 -1.30556306e+00\n",
      "  -8.47563063e-01  6.48436937e-01  5.58436937e-01 -2.35563063e-01]\n",
      " [ 2.60436937e-01  2.60436937e-01  1.91643694e+00  2.22443694e+00\n",
      "   1.28443694e+00  1.37043694e+00 -9.37563063e-01 -4.07563063e-01\n",
      "  -9.45563063e-01 -1.39156306e+00 -1.26156306e+00 -1.45756306e+00]\n",
      " [-1.41156306e+00 -1.52756306e+00 -9.75563063e-01 -1.01156306e+00\n",
      "  -2.71563063e-01 -3.19563063e-01 -1.41563063e-01 -2.27563063e-01\n",
      "   4.32436937e-01  3.38436937e-01  1.37843694e+00  1.14843694e+00]\n",
      " [ 1.23243694e+00  2.46043694e+00  4.46436937e-01 -3.11563063e-01\n",
      "  -7.41563063e-01 -1.15556306e+00 -1.35156306e+00 -1.65756306e+00\n",
      "  -5.07563063e-01  2.54436937e-01  7.26436937e-01  9.58436937e-01]\n",
      " [ 1.64243694e+00  2.31443694e+00  6.34436937e-01 -1.11563063e-01\n",
      "  -1.15356306e+00 -1.04356306e+00 -1.54556306e+00 -1.57356306e+00\n",
      "  -5.69563063e-01  7.66436937e-01 -1.55563063e-01  3.14436937e-01]\n",
      " [ 2.02436937e-01  7.92436937e-01 -4.39563063e-01 -4.73563063e-01\n",
      "  -1.11956306e+00 -1.06756306e+00 -1.31556306e+00 -1.25756306e+00\n",
      "  -7.53563063e-01 -2.29563063e-01  1.33443694e+00  9.64369369e-02]\n",
      " [ 1.57443694e+00  2.45043694e+00  8.54436937e-01 -2.75630631e-02\n",
      "  -8.95563063e-01 -1.01956306e+00 -1.37756306e+00 -1.42156306e+00\n",
      "  -1.31556306e+00 -2.49563063e-01  6.70436937e-01 -3.21563063e-01]\n",
      " [ 1.25643694e+00  1.68043694e+00  5.70436937e-01 -9.57563063e-01\n",
      "  -1.05756306e+00 -1.33156306e+00 -1.88756306e+00 -1.48356306e+00\n",
      "  -2.41563063e-01  4.24369369e-02  3.64369369e-02  4.26436937e-01]\n",
      " [ 7.84436937e-01  5.84436937e-01  5.96436937e-01 -5.65563063e-01\n",
      "  -7.65563063e-01 -1.23956306e+00 -1.58356306e+00 -1.30756306e+00\n",
      "   3.24369369e-02 -4.41563063e-01  6.32436937e-01  2.23643694e+00]\n",
      " [ 1.85043694e+00  3.82436937e-01 -1.56306306e-03  1.64369369e-02\n",
      "  -1.33156306e+00 -1.29156306e+00 -1.41356306e+00 -1.12156306e+00\n",
      "  -3.19563063e-01  3.94436937e-01  9.50436937e-01  1.10443694e+00]\n",
      " [ 1.50643694e+00  3.56436937e-01 -4.21563063e-01  1.62436937e-01\n",
      "  -1.04756306e+00 -1.44156306e+00 -1.21156306e+00 -9.55563063e-01\n",
      "  -7.23563063e-01  6.24369369e-02  1.10243694e+00  1.00443694e+00]\n",
      " [ 7.04436937e-01  9.84369369e-02  7.50436937e-01 -2.61563063e-01\n",
      "  -3.21563063e-01 -6.31563063e-01 -5.81563063e-01 -1.41563063e-01\n",
      "  -1.15630631e-02 -4.55630631e-02  1.82436937e-01  6.18436937e-01]\n",
      " [ 7.92436937e-01  8.62436937e-01  8.43693694e-03 -2.53563063e-01\n",
      "  -6.97563063e-01 -4.51563063e-01 -5.45563063e-01 -4.65563063e-01\n",
      "  -9.75630631e-02  7.62436937e-01  2.28436937e-01  3.98436937e-01]\n",
      " [ 1.39443694e+00  2.18436937e-01  6.76436937e-01 -5.17563063e-01\n",
      "  -9.35630631e-02 -1.82556306e+00 -1.58356306e+00 -1.21556306e+00\n",
      "  -3.95630631e-02 -3.59563063e-01  3.16436937e-01  4.42436937e-01]\n",
      " [ 3.90436937e-01 -6.39563063e-01 -2.07563063e-01 -5.65563063e-01\n",
      "  -1.27156306e+00 -1.42956306e+00 -1.10356306e+00 -1.47756306e+00\n",
      "  -5.07563063e-01 -6.95630631e-02 -1.35630631e-02 -2.49563063e-01]\n",
      " [ 5.54436937e-01  2.23443694e+00  7.22436937e-01  6.62436937e-01\n",
      "  -8.71563063e-01 -1.28956306e+00 -1.33556306e+00 -1.33956306e+00\n",
      "  -1.61563063e-01  7.50436937e-01  8.94436937e-01  1.94043694e+00]\n",
      " [ 1.76443694e+00  1.23443694e+00  9.72436937e-01 -8.01563063e-01\n",
      "  -8.13563063e-01 -1.64356306e+00 -1.17756306e+00 -1.32156306e+00\n",
      "   2.34436937e-01 -8.51563063e-01  5.26436937e-01  5.44436937e-01]\n",
      " [ 8.86436937e-01  7.06436937e-01  3.12436937e-01 -8.15630631e-02\n",
      "  -8.81563063e-01 -1.61156306e+00 -1.36756306e+00 -1.21156306e+00\n",
      "  -3.49563063e-01  7.84369369e-02  4.72436937e-01  2.37643694e+00]\n",
      " [ 9.10436937e-01  4.10436937e-01  1.26243694e+00 -1.71563063e-01\n",
      "  -1.15756306e+00 -1.82556306e+00 -1.48956306e+00 -1.29156306e+00\n",
      "  -8.03563063e-01  4.86436937e-01 -2.75563063e-01  2.66043694e+00]\n",
      " [ 3.10443694e+00  2.57043694e+00  8.76436937e-01  2.45443694e+00\n",
      "   1.49843694e+00  2.94436937e-01 -7.55630631e-02 -5.97563063e-01\n",
      "  -6.73563063e-01 -3.37563063e-01  1.23843694e+00  1.66443694e+00]]\n"
     ]
    }
   ],
   "source": [
    "data = numpy.loadtxt(fname='data/wavesmonthly.csv', delimiter=',', skiprows=1)\n",
    "reshaped_data = numpy.reshape(data[:,2], [37,12])\n",
    "print(offset_mean(reshaped_data, 0))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "98580643-0b2e-47fe-8f46-694b5b904168",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "original min, mean, and max are: 1.496 3.383563063063063 6.956\n",
      "min, mean, and max of offset data are: -1.8875630630630629 1.960393809248024e-16 3.5724369369369375\n"
     ]
    }
   ],
   "source": [
    "print('original min, mean, and max are:', numpy.min(reshaped_data), numpy.mean(reshaped_data), numpy.max(reshaped_data))\n",
    "offset_data = offset_mean(reshaped_data, 0)\n",
    "print('min, mean, and max of offset data are:',\n",
    "      numpy.min(offset_data),\n",
    "      numpy.mean(offset_data),\n",
    "      numpy.max(offset_data))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "c06d1028-f5cc-4006-97a4-a89e953d6d95",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "std dev before and after: 1.1440155050316319 1.144015505031632\n"
     ]
    }
   ],
   "source": [
    "print('std dev before and after:', numpy.std(reshaped_data), numpy.std(offset_data))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "bf83db08-41aa-41f5-8120-e7ef660847ab",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "difference in standard deviations before and after: -2.220446049250313e-16\n"
     ]
    }
   ],
   "source": [
    "print('difference in standard deviations before and after:',\n",
    "      numpy.std(reshaped_data) - numpy.std(offset_data))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6546bebb-e79c-4416-831a-64fa4106ebbe",
   "metadata": {},
   "source": [
    "* difference in standard deviations is very small\n",
    "* one more task, documentation, lets add some comments about our function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "814cf098-c08d-47cd-9399-e081c16c5615",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# offset_mean(data, target_mean_value):\n",
    "# return a new array containing the original data with its mean offset to match the desired value.\n",
    "def offset_mean(data, target_mean_value):\n",
    "    return (data - numpy.mean(data)) + target_mean_value\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7fe4cfe3-a544-43fa-ab92-7ff7597c4ee4",
   "metadata": {},
   "source": [
    "* better way to do it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "d8b03d2d-d2eb-483a-9ebd-0b33754e6fdf",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def offset_mean(data, target_mean_value):\n",
    "    \"\"\"Return a new array containing the original data\n",
    "       with its mean offset to match the desired value.\"\"\"\n",
    "    return (data - numpy.mean(data)) + target_mean_value\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "882ca7c4-8a19-4e0d-85ac-4a75a718ffc5",
   "metadata": {},
   "source": [
    "* this works with python's built in help function.\n",
    "* called a docstring\n",
    "* triple quotes allows a multiline comment\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "d1d5fd21-3198-4733-a1fe-bbe34d5361cf",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function offset_mean in module __main__:\n",
      "\n",
      "offset_mean(data, target_mean_value)\n",
      "    Return a new array containing the original data\n",
      "    with its mean offset to match the desired value.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(offset_mean)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "6708400d-f667-414c-9046-0c529896cce7",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function offset_mean in module __main__:\n",
      "\n",
      "offset_mean(data, target_mean_value)\n",
      "    Return a new array containing the original data\n",
      "       with its mean offset to match the desired value.\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    >>> offset_mean([1, 2, 3], 0)\n",
      "    array([-1.,  0.,  1.])\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def offset_mean(data, target_mean_value):\n",
    "    \"\"\"Return a new array containing the original data\n",
    "       with its mean offset to match the desired value.\n",
    "\n",
    "    Examples\n",
    "    --------\n",
    "    >>> offset_mean([1, 2, 3], 0)\n",
    "    array([-1.,  0.,  1.])\n",
    "    \"\"\"\n",
    "    return (data - numpy.mean(data)) + target_mean_value\n",
    "\n",
    "help(offset_mean)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14bfc1b0-d89c-4dd1-a7e1-c7f52d6f2690",
   "metadata": {},
   "source": [
    "* we've passed data in named and unmamed arguments\n",
    "* could have done filename in loadtxt without a name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "5bf96578-ffd0-451e-a926-0063427dad6f",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.979e+03, 1.000e+00, 3.788e+00],\n",
       "       [1.979e+03, 2.000e+00, 3.768e+00],\n",
       "       [1.979e+03, 3.000e+00, 4.774e+00],\n",
       "       ...,\n",
       "       [2.015e+03, 1.000e+01, 3.046e+00],\n",
       "       [2.015e+03, 1.100e+01, 4.622e+00],\n",
       "       [2.015e+03, 1.200e+01, 5.048e+00]])"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numpy.loadtxt('data/wavesmonthly.csv', delimiter=',', skiprows=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea51359d-1196-4904-a256-ee4f1353d028",
   "metadata": {
    "tags": []
   },
   "source": [
    "* doesn't work for the delimiter\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "297db42d-6e6e-4bea-9494-384169a7b160",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<unknown>, line 1)",
     "output_type": "error",
     "traceback": [
      "Traceback \u001b[0;36m(most recent call last)\u001b[0m:\n",
      "\u001b[0m  File \u001b[1;32m~/mambaforge/envs/pangeo/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3442\u001b[0m in \u001b[1;35mrun_code\u001b[0m\n    exec(code_obj, self.user_global_ns, self.user_ns)\u001b[0m\n",
      "\u001b[0m  Cell \u001b[1;32mIn[86], line 1\u001b[0m\n    numpy.loadtxt('data/wavesmonthly.csv', ',', skiprows=1)\u001b[0m\n",
      "\u001b[0m  File \u001b[1;32m~/mambaforge/envs/pangeo/lib/python3.10/site-packages/numpy/lib/npyio.py:1338\u001b[0m in \u001b[1;35mloadtxt\u001b[0m\n    arr = _read(fname, dtype=dtype, comment=comment, delimiter=delimiter,\u001b[0m\n",
      "\u001b[0m  File \u001b[1;32m~/mambaforge/envs/pangeo/lib/python3.10/site-packages/numpy/lib/npyio.py:900\u001b[0m in \u001b[1;35m_read\u001b[0m\n    dtype = np.dtype(dtype)\u001b[0m\n",
      "\u001b[0m  File \u001b[1;32m~/mambaforge/envs/pangeo/lib/python3.10/site-packages/numpy/core/_internal.py:200\u001b[0m in \u001b[1;35m_commastring\u001b[0m\n    newitem = (dtype, ast.literal_eval(repeats))\u001b[0m\n",
      "\u001b[0m  File \u001b[1;32m~/mambaforge/envs/pangeo/lib/python3.10/ast.py:64\u001b[0m in \u001b[1;35mliteral_eval\u001b[0m\n    node_or_string = parse(node_or_string.lstrip(\" \\t\"), mode='eval')\u001b[0m\n",
      "\u001b[0;36m  File \u001b[0;32m~/mambaforge/envs/pangeo/lib/python3.10/ast.py:50\u001b[0;36m in \u001b[0;35mparse\u001b[0;36m\n\u001b[0;31m    return compile(source, filename, mode, flags,\u001b[0;36m\n",
      "\u001b[0;36m  File \u001b[0;32m<unknown>:1\u001b[0;36m\u001b[0m\n\u001b[0;31m    ,\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "numpy.loadtxt('data/wavesmonthly.csv', ',', skiprows=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad42a03a-8806-40c6-993d-ecdc1fe0928a",
   "metadata": {},
   "source": [
    "* redefine offset_mean to include a named parameter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "6488715a-655d-4095-ba36-43a506ab1a09",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def offset_mean(data, target_mean_value=0.0):\n",
    "    \"\"\"Return a new array containing the original data\n",
    "       with its mean offset to match the desired value, (0 by default).\n",
    "\n",
    "    Examples\n",
    "    --------\n",
    "    >>> offset_mean([1, 2, 3])\n",
    "    array([-1.,  0.,  1.])\n",
    "    \"\"\"\n",
    "    return (data - numpy.mean(data)) + target_mean_value\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84e9645f-123f-4a29-8208-a61e156af1b1",
   "metadata": {},
   "source": [
    "* if we call with two arguments things work as they did before\n",
    "* but call with one and target_mean_value is assumed to be 0.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "7dbdea00-9cad-4141-bc1c-d49a63215678",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[3. 3.]\n",
      " [3. 3.]]\n"
     ]
    }
   ],
   "source": [
    "test_data = numpy.zeros((2, 2))\n",
    "print(offset_mean(test_data, 3))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "f97da7fd-f176-471b-91a2-3eaf1612f32f",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data before mean offset:\n",
      "[[5. 5.]\n",
      " [5. 5.]]\n",
      "offset data:\n",
      "[[0. 0.]\n",
      " [0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "more_data = 5 + numpy.zeros((2, 2))\n",
    "print('data before mean offset:')\n",
    "print(more_data)\n",
    "print('offset data:')\n",
    "print(offset_mean(more_data))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97ca509d-5dc2-4fef-86b5-4a0fa04949a9",
   "metadata": {},
   "source": [
    "* useful if we occasionally want a different paramter, but most of the time we don't want to specify it\n",
    "* example of python matching different function calls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "0c0f1a86-d093-4bc4-9fe4-0b5d8d0350c9",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "no parameters:\n",
      "a: 1 b: 2 c: 3\n",
      "one parameter:\n",
      "a: 55 b: 2 c: 3\n",
      "two parameters:\n",
      "a: 55 b: 66 c: 3\n"
     ]
    }
   ],
   "source": [
    "def display(a=1, b=2, c=3):\n",
    "    print('a:', a, 'b:', b, 'c:', c)\n",
    "\n",
    "print('no parameters:')\n",
    "display()\n",
    "print('one parameter:')\n",
    "display(55)\n",
    "print('two parameters:')\n",
    "display(55, 66)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "871cd273-48a2-4d7e-b9ea-5a6611c9069e",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "only setting the value of c\n",
      "a: 1 b: 2 c: 77\n"
     ]
    }
   ],
   "source": [
    "print('only setting the value of c')\n",
    "display(c=77)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad7211cc-3954-4ba6-b229-24e9a114aee5",
   "metadata": {
    "tags": []
   },
   "source": [
    "* look at help text for numpy.loadtxt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "ffa62b4b-1151-4095-bd31-01991b083c59",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function loadtxt in module numpy:\n",
      "\n",
      "loadtxt(fname, dtype=<class 'float'>, comments='#', delimiter=None, converters=None, skiprows=0, usecols=None, unpack=False, ndmin=0, encoding='bytes', max_rows=None, *, quotechar=None, like=None)\n",
      "    Load data from a text file.\n",
      "    \n",
      "    Each row in the text file must have the same number of values.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    fname : file, str, pathlib.Path, list of str, generator\n",
      "        File, filename, list, or generator to read.  If the filename\n",
      "        extension is ``.gz`` or ``.bz2``, the file is first decompressed. Note\n",
      "        that generators must return bytes or strings. The strings\n",
      "        in a list or produced by a generator are treated as lines.\n",
      "    dtype : data-type, optional\n",
      "        Data-type of the resulting array; default: float.  If this is a\n",
      "        structured data-type, the resulting array will be 1-dimensional, and\n",
      "        each row will be interpreted as an element of the array.  In this\n",
      "        case, the number of columns used must match the number of fields in\n",
      "        the data-type.\n",
      "    comments : str or sequence of str or None, optional\n",
      "        The characters or list of characters used to indicate the start of a\n",
      "        comment. None implies no comments. For backwards compatibility, byte\n",
      "        strings will be decoded as 'latin1'. The default is '#'.\n",
      "    delimiter : str, optional\n",
      "        The character used to separate the values. For backwards compatibility,\n",
      "        byte strings will be decoded as 'latin1'. The default is whitespace.\n",
      "    \n",
      "        .. versionchanged:: 1.23.0\n",
      "           Only single character delimiters are supported. Newline characters\n",
      "           cannot be used as the delimiter.\n",
      "    \n",
      "    converters : dict or callable, optional\n",
      "        A function to parse all columns strings into the desired value, or\n",
      "        a dictionary mapping column number to a parser function.\n",
      "        E.g. if column 0 is a date string: ``converters = {0: datestr2num}``.\n",
      "        Converters can also be used to provide a default value for missing\n",
      "        data, e.g. ``converters = lambda s: float(s.strip() or 0)`` will\n",
      "        convert empty fields to 0.\n",
      "        Default: None.\n",
      "    \n",
      "        .. versionchanged:: 1.23.0\n",
      "           The ability to pass a single callable to be applied to all columns\n",
      "           was added.\n",
      "    \n",
      "    skiprows : int, optional\n",
      "        Skip the first `skiprows` lines, including comments; default: 0.\n",
      "    usecols : int or sequence, optional\n",
      "        Which columns to read, with 0 being the first. For example,\n",
      "        ``usecols = (1,4,5)`` will extract the 2nd, 5th and 6th columns.\n",
      "        The default, None, results in all columns being read.\n",
      "    \n",
      "        .. versionchanged:: 1.11.0\n",
      "            When a single column has to be read it is possible to use\n",
      "            an integer instead of a tuple. E.g ``usecols = 3`` reads the\n",
      "            fourth column the same way as ``usecols = (3,)`` would.\n",
      "    unpack : bool, optional\n",
      "        If True, the returned array is transposed, so that arguments may be\n",
      "        unpacked using ``x, y, z = loadtxt(...)``.  When used with a\n",
      "        structured data-type, arrays are returned for each field.\n",
      "        Default is False.\n",
      "    ndmin : int, optional\n",
      "        The returned array will have at least `ndmin` dimensions.\n",
      "        Otherwise mono-dimensional axes will be squeezed.\n",
      "        Legal values: 0 (default), 1 or 2.\n",
      "    \n",
      "        .. versionadded:: 1.6.0\n",
      "    encoding : str, optional\n",
      "        Encoding used to decode the inputfile. Does not apply to input streams.\n",
      "        The special value 'bytes' enables backward compatibility workarounds\n",
      "        that ensures you receive byte arrays as results if possible and passes\n",
      "        'latin1' encoded strings to converters. Override this value to receive\n",
      "        unicode arrays and pass strings as input to converters.  If set to None\n",
      "        the system default is used. The default value is 'bytes'.\n",
      "    \n",
      "        .. versionadded:: 1.14.0\n",
      "    max_rows : int, optional\n",
      "        Read `max_rows` rows of content after `skiprows` lines. The default is\n",
      "        to read all the rows. Note that empty rows containing no data such as\n",
      "        empty lines and comment lines are not counted towards `max_rows`,\n",
      "        while such lines are counted in `skiprows`.\n",
      "    \n",
      "        .. versionadded:: 1.16.0\n",
      "        \n",
      "        .. versionchanged:: 1.23.0\n",
      "            Lines containing no data, including comment lines (e.g., lines \n",
      "            starting with '#' or as specified via `comments`) are not counted \n",
      "            towards `max_rows`.\n",
      "    quotechar : unicode character or None, optional\n",
      "        The character used to denote the start and end of a quoted item.\n",
      "        Occurrences of the delimiter or comment characters are ignored within\n",
      "        a quoted item. The default value is ``quotechar=None``, which means\n",
      "        quoting support is disabled.\n",
      "    \n",
      "        If two consecutive instances of `quotechar` are found within a quoted\n",
      "        field, the first is treated as an escape character. See examples.\n",
      "    \n",
      "        .. versionadded:: 1.23.0\n",
      "    like : array_like, optional\n",
      "        Reference object to allow the creation of arrays which are not\n",
      "        NumPy arrays. If an array-like passed in as ``like`` supports\n",
      "        the ``__array_function__`` protocol, the result will be defined\n",
      "        by it. In this case, it ensures the creation of an array object\n",
      "        compatible with that passed in via this argument.\n",
      "    \n",
      "        .. versionadded:: 1.20.0\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    out : ndarray\n",
      "        Data read from the text file.\n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    load, fromstring, fromregex\n",
      "    genfromtxt : Load data with missing values handled as specified.\n",
      "    scipy.io.loadmat : reads MATLAB data files\n",
      "    \n",
      "    Notes\n",
      "    -----\n",
      "    This function aims to be a fast reader for simply formatted files.  The\n",
      "    `genfromtxt` function provides more sophisticated handling of, e.g.,\n",
      "    lines with missing values.\n",
      "    \n",
      "    .. versionadded:: 1.10.0\n",
      "    \n",
      "    The strings produced by the Python float.hex method can be used as\n",
      "    input for floats.\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    >>> from io import StringIO   # StringIO behaves like a file object\n",
      "    >>> c = StringIO(\"0 1\\n2 3\")\n",
      "    >>> np.loadtxt(c)\n",
      "    array([[0., 1.],\n",
      "           [2., 3.]])\n",
      "    \n",
      "    >>> d = StringIO(\"M 21 72\\nF 35 58\")\n",
      "    >>> np.loadtxt(d, dtype={'names': ('gender', 'age', 'weight'),\n",
      "    ...                      'formats': ('S1', 'i4', 'f4')})\n",
      "    array([(b'M', 21, 72.), (b'F', 35, 58.)],\n",
      "          dtype=[('gender', 'S1'), ('age', '<i4'), ('weight', '<f4')])\n",
      "    \n",
      "    >>> c = StringIO(\"1,0,2\\n3,0,4\")\n",
      "    >>> x, y = np.loadtxt(c, delimiter=',', usecols=(0, 2), unpack=True)\n",
      "    >>> x\n",
      "    array([1., 3.])\n",
      "    >>> y\n",
      "    array([2., 4.])\n",
      "    \n",
      "    The `converters` argument is used to specify functions to preprocess the\n",
      "    text prior to parsing. `converters` can be a dictionary that maps\n",
      "    preprocessing functions to each column:\n",
      "    \n",
      "    >>> s = StringIO(\"1.618, 2.296\\n3.141, 4.669\\n\")\n",
      "    >>> conv = {\n",
      "    ...     0: lambda x: np.floor(float(x)),  # conversion fn for column 0\n",
      "    ...     1: lambda x: np.ceil(float(x)),  # conversion fn for column 1\n",
      "    ... }\n",
      "    >>> np.loadtxt(s, delimiter=\",\", converters=conv)\n",
      "    array([[1., 3.],\n",
      "           [3., 5.]])\n",
      "    \n",
      "    `converters` can be a callable instead of a dictionary, in which case it\n",
      "    is applied to all columns:\n",
      "    \n",
      "    >>> s = StringIO(\"0xDE 0xAD\\n0xC0 0xDE\")\n",
      "    >>> import functools\n",
      "    >>> conv = functools.partial(int, base=16)\n",
      "    >>> np.loadtxt(s, converters=conv)\n",
      "    array([[222., 173.],\n",
      "           [192., 222.]])\n",
      "    \n",
      "    This example shows how `converters` can be used to convert a field\n",
      "    with a trailing minus sign into a negative number.\n",
      "    \n",
      "    >>> s = StringIO('10.01 31.25-\\n19.22 64.31\\n17.57- 63.94')\n",
      "    >>> def conv(fld):\n",
      "    ...     return -float(fld[:-1]) if fld.endswith(b'-') else float(fld)\n",
      "    ...\n",
      "    >>> np.loadtxt(s, converters=conv)\n",
      "    array([[ 10.01, -31.25],\n",
      "           [ 19.22,  64.31],\n",
      "           [-17.57,  63.94]])\n",
      "    \n",
      "    Using a callable as the converter can be particularly useful for handling\n",
      "    values with different formatting, e.g. floats with underscores:\n",
      "    \n",
      "    >>> s = StringIO(\"1 2.7 100_000\")\n",
      "    >>> np.loadtxt(s, converters=float)\n",
      "    array([1.e+00, 2.7e+00, 1.e+05])\n",
      "    \n",
      "    This idea can be extended to automatically handle values specified in\n",
      "    many different formats:\n",
      "    \n",
      "    >>> def conv(val):\n",
      "    ...     try:\n",
      "    ...         return float(val)\n",
      "    ...     except ValueError:\n",
      "    ...         return float.fromhex(val)\n",
      "    >>> s = StringIO(\"1, 2.5, 3_000, 0b4, 0x1.4000000000000p+2\")\n",
      "    >>> np.loadtxt(s, delimiter=\",\", converters=conv, encoding=None)\n",
      "    array([1.0e+00, 2.5e+00, 3.0e+03, 1.8e+02, 5.0e+00])\n",
      "    \n",
      "    Note that with the default ``encoding=\"bytes\"``, the inputs to the\n",
      "    converter function are latin-1 encoded byte strings. To deactivate the\n",
      "    implicit encoding prior to conversion, use ``encoding=None``\n",
      "    \n",
      "    >>> s = StringIO('10.01 31.25-\\n19.22 64.31\\n17.57- 63.94')\n",
      "    >>> conv = lambda x: -float(x[:-1]) if x.endswith('-') else float(x)\n",
      "    >>> np.loadtxt(s, converters=conv, encoding=None)\n",
      "    array([[ 10.01, -31.25],\n",
      "           [ 19.22,  64.31],\n",
      "           [-17.57,  63.94]])\n",
      "    \n",
      "    Support for quoted fields is enabled with the `quotechar` parameter.\n",
      "    Comment and delimiter characters are ignored when they appear within a\n",
      "    quoted item delineated by `quotechar`:\n",
      "    \n",
      "    >>> s = StringIO('\"alpha, #42\", 10.0\\n\"beta, #64\", 2.0\\n')\n",
      "    >>> dtype = np.dtype([(\"label\", \"U12\"), (\"value\", float)])\n",
      "    >>> np.loadtxt(s, dtype=dtype, delimiter=\",\", quotechar='\"')\n",
      "    array([('alpha, #42', 10.), ('beta, #64',  2.)],\n",
      "          dtype=[('label', '<U12'), ('value', '<f8')])\n",
      "    \n",
      "    Two consecutive quote characters within a quoted field are treated as a\n",
      "    single escaped character:\n",
      "    \n",
      "    >>> s = StringIO('\"Hello, my name is \"\"Monty\"\"!\"')\n",
      "    >>> np.loadtxt(s, dtype=\"U\", delimiter=\",\", quotechar='\"')\n",
      "    array('Hello, my name is \"Monty\"!', dtype='<U26')\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(numpy.loadtxt)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87b4a0bf-4d94-4698-a589-8ae5a9c2371d",
   "metadata": {},
   "source": [
    "* most important info in the first couple of lines\n",
    "* if we call numpy.loadtxt('filename.csv', ',') we are actually sending , to the dtype parameter.\n",
    "* don't have to put fname= since it is first, do have to put delimiter if we don't want to also specify dtype and comments"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18494c51-ce98-4406-8409-ec98bb889070",
   "metadata": {},
   "source": [
    "* compare readability of the two different functions\n",
    "* they both do the same thing\n",
    "* they will run in the same time\n",
    "## Exercises"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "cccf64b7-32a1-4a81-8952-ac9979b31c90",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*name*\n"
     ]
    }
   ],
   "source": [
    "def fence(original, wrapper):\n",
    "    return wrapper + original + wrapper\n",
    "\n",
    "\n",
    "print(fence('name', '*'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "4455f69a-55b3-4648-996c-bfeaf195f3e8",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "def add(a, b):\n",
    "    print(a + b)\n",
    "\n",
    "A = add(7, 3)\n",
    "print(A)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "af8f1c32-8249-4060-a479-464d0013fb5d",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hm\n"
     ]
    }
   ],
   "source": [
    "def outer(input_string):\n",
    "    return input_string[0] + input_string[-1]\n",
    "\n",
    "\n",
    "print(outer('helium'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "17216e2d-e35e-437e-9060-5d8cdabecdf4",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def rescale(input_array):\n",
    "    L = numpy.min(input_array)\n",
    "    H = numpy.max(input_array)\n",
    "    output_array = (input_array - L) / (H - L)\n",
    "    return output_array\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "62ae7ec3-3464-4d25-9e3e-91bf43edd63e",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function arange in module numpy:\n",
      "\n",
      "arange(...)\n",
      "    arange([start,] stop[, step,], dtype=None, *, like=None)\n",
      "    \n",
      "    Return evenly spaced values within a given interval.\n",
      "    \n",
      "    ``arange`` can be called with a varying number of positional arguments:\n",
      "    \n",
      "    * ``arange(stop)``: Values are generated within the half-open interval\n",
      "      ``[0, stop)`` (in other words, the interval including `start` but\n",
      "      excluding `stop`).\n",
      "    * ``arange(start, stop)``: Values are generated within the half-open\n",
      "      interval ``[start, stop)``.\n",
      "    * ``arange(start, stop, step)`` Values are generated within the half-open\n",
      "      interval ``[start, stop)``, with spacing between values given by\n",
      "      ``step``.\n",
      "    \n",
      "    For integer arguments the function is roughly equivalent to the Python\n",
      "    built-in :py:class:`range`, but returns an ndarray rather than a ``range``\n",
      "    instance.\n",
      "    \n",
      "    When using a non-integer step, such as 0.1, it is often better to use\n",
      "    `numpy.linspace`.\n",
      "    \n",
      "    See the Warning sections below for more information.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    start : integer or real, optional\n",
      "        Start of interval.  The interval includes this value.  The default\n",
      "        start value is 0.\n",
      "    stop : integer or real\n",
      "        End of interval.  The interval does not include this value, except\n",
      "        in some cases where `step` is not an integer and floating point\n",
      "        round-off affects the length of `out`.\n",
      "    step : integer or real, optional\n",
      "        Spacing between values.  For any output `out`, this is the distance\n",
      "        between two adjacent values, ``out[i+1] - out[i]``.  The default\n",
      "        step size is 1.  If `step` is specified as a position argument,\n",
      "        `start` must also be given.\n",
      "    dtype : dtype, optional\n",
      "        The type of the output array.  If `dtype` is not given, infer the data\n",
      "        type from the other input arguments.\n",
      "    like : array_like, optional\n",
      "        Reference object to allow the creation of arrays which are not\n",
      "        NumPy arrays. If an array-like passed in as ``like`` supports\n",
      "        the ``__array_function__`` protocol, the result will be defined\n",
      "        by it. In this case, it ensures the creation of an array object\n",
      "        compatible with that passed in via this argument.\n",
      "    \n",
      "        .. versionadded:: 1.20.0\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    arange : ndarray\n",
      "        Array of evenly spaced values.\n",
      "    \n",
      "        For floating point arguments, the length of the result is\n",
      "        ``ceil((stop - start)/step)``.  Because of floating point overflow,\n",
      "        this rule may result in the last element of `out` being greater\n",
      "        than `stop`.\n",
      "    \n",
      "    Warnings\n",
      "    --------\n",
      "    The length of the output might not be numerically stable.\n",
      "    \n",
      "    Another stability issue is due to the internal implementation of\n",
      "    `numpy.arange`.\n",
      "    The actual step value used to populate the array is\n",
      "    ``dtype(start + step) - dtype(start)`` and not `step`. Precision loss\n",
      "    can occur here, due to casting or due to using floating points when\n",
      "    `start` is much larger than `step`. This can lead to unexpected\n",
      "    behaviour. For example::\n",
      "    \n",
      "      >>> np.arange(0, 5, 0.5, dtype=int)\n",
      "      array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])\n",
      "      >>> np.arange(-3, 3, 0.5, dtype=int)\n",
      "      array([-3, -2, -1,  0,  1,  2,  3,  4,  5,  6,  7,  8])\n",
      "    \n",
      "    In such cases, the use of `numpy.linspace` should be preferred.\n",
      "    \n",
      "    The built-in :py:class:`range` generates :std:doc:`Python built-in integers\n",
      "    that have arbitrary size <c-api/long>`, while `numpy.arange` produces\n",
      "    `numpy.int32` or `numpy.int64` numbers. This may result in incorrect\n",
      "    results for large integer values::\n",
      "    \n",
      "      >>> power = 40\n",
      "      >>> modulo = 10000\n",
      "      >>> x1 = [(n ** power) % modulo for n in range(8)]\n",
      "      >>> x2 = [(n ** power) % modulo for n in np.arange(8)]\n",
      "      >>> print(x1)\n",
      "      [0, 1, 7776, 8801, 6176, 625, 6576, 4001]  # correct\n",
      "      >>> print(x2)\n",
      "      [0, 1, 7776, 7185, 0, 5969, 4816, 3361]  # incorrect\n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    numpy.linspace : Evenly spaced numbers with careful handling of endpoints.\n",
      "    numpy.ogrid: Arrays of evenly spaced numbers in N-dimensions.\n",
      "    numpy.mgrid: Grid-shaped arrays of evenly spaced numbers in N-dimensions.\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    >>> np.arange(3)\n",
      "    array([0, 1, 2])\n",
      "    >>> np.arange(3.0)\n",
      "    array([ 0.,  1.,  2.])\n",
      "    >>> np.arange(3,7)\n",
      "    array([3, 4, 5, 6])\n",
      "    >>> np.arange(3,7,2)\n",
      "    array([3, 5])\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(numpy.arange)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "987c0d4e-474e-4f3d-9dd0-e0ea97a6ab37",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function linspace in module numpy:\n",
      "\n",
      "linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)\n",
      "    Return evenly spaced numbers over a specified interval.\n",
      "    \n",
      "    Returns `num` evenly spaced samples, calculated over the\n",
      "    interval [`start`, `stop`].\n",
      "    \n",
      "    The endpoint of the interval can optionally be excluded.\n",
      "    \n",
      "    .. versionchanged:: 1.16.0\n",
      "        Non-scalar `start` and `stop` are now supported.\n",
      "    \n",
      "    .. versionchanged:: 1.20.0\n",
      "        Values are rounded towards ``-inf`` instead of ``0`` when an\n",
      "        integer ``dtype`` is specified. The old behavior can\n",
      "        still be obtained with ``np.linspace(start, stop, num).astype(int)``\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    start : array_like\n",
      "        The starting value of the sequence.\n",
      "    stop : array_like\n",
      "        The end value of the sequence, unless `endpoint` is set to False.\n",
      "        In that case, the sequence consists of all but the last of ``num + 1``\n",
      "        evenly spaced samples, so that `stop` is excluded.  Note that the step\n",
      "        size changes when `endpoint` is False.\n",
      "    num : int, optional\n",
      "        Number of samples to generate. Default is 50. Must be non-negative.\n",
      "    endpoint : bool, optional\n",
      "        If True, `stop` is the last sample. Otherwise, it is not included.\n",
      "        Default is True.\n",
      "    retstep : bool, optional\n",
      "        If True, return (`samples`, `step`), where `step` is the spacing\n",
      "        between samples.\n",
      "    dtype : dtype, optional\n",
      "        The type of the output array.  If `dtype` is not given, the data type\n",
      "        is inferred from `start` and `stop`. The inferred dtype will never be\n",
      "        an integer; `float` is chosen even if the arguments would produce an\n",
      "        array of integers.\n",
      "    \n",
      "        .. versionadded:: 1.9.0\n",
      "    \n",
      "    axis : int, optional\n",
      "        The axis in the result to store the samples.  Relevant only if start\n",
      "        or stop are array-like.  By default (0), the samples will be along a\n",
      "        new axis inserted at the beginning. Use -1 to get an axis at the end.\n",
      "    \n",
      "        .. versionadded:: 1.16.0\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    samples : ndarray\n",
      "        There are `num` equally spaced samples in the closed interval\n",
      "        ``[start, stop]`` or the half-open interval ``[start, stop)``\n",
      "        (depending on whether `endpoint` is True or False).\n",
      "    step : float, optional\n",
      "        Only returned if `retstep` is True\n",
      "    \n",
      "        Size of spacing between samples.\n",
      "    \n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    arange : Similar to `linspace`, but uses a step size (instead of the\n",
      "             number of samples).\n",
      "    geomspace : Similar to `linspace`, but with numbers spaced evenly on a log\n",
      "                scale (a geometric progression).\n",
      "    logspace : Similar to `geomspace`, but with the end points specified as\n",
      "               logarithms.\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    >>> np.linspace(2.0, 3.0, num=5)\n",
      "    array([2.  , 2.25, 2.5 , 2.75, 3.  ])\n",
      "    >>> np.linspace(2.0, 3.0, num=5, endpoint=False)\n",
      "    array([2. ,  2.2,  2.4,  2.6,  2.8])\n",
      "    >>> np.linspace(2.0, 3.0, num=5, retstep=True)\n",
      "    (array([2.  ,  2.25,  2.5 ,  2.75,  3.  ]), 0.25)\n",
      "    \n",
      "    Graphical illustration:\n",
      "    \n",
      "    >>> import matplotlib.pyplot as plt\n",
      "    >>> N = 8\n",
      "    >>> y = np.zeros(N)\n",
      "    >>> x1 = np.linspace(0, 10, N, endpoint=True)\n",
      "    >>> x2 = np.linspace(0, 10, N, endpoint=False)\n",
      "    >>> plt.plot(x1, y, 'o')\n",
      "    [<matplotlib.lines.Line2D object at 0x...>]\n",
      "    >>> plt.plot(x2, y + 0.5, 'o')\n",
      "    [<matplotlib.lines.Line2D object at 0x...>]\n",
      "    >>> plt.ylim([-0.5, 1])\n",
      "    (-0.5, 1)\n",
      "    >>> plt.show()\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(numpy.linspace)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "76871e3a-a45e-4b8c-8c10-d1752a1e6d3d",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def rescale(input_array, low_val=0.0, high_val=1.0):\n",
    "    \"\"\"rescales input array values to lie between low_val and high_val\"\"\"\n",
    "    L = numpy.min(input_array)\n",
    "    H = numpy.max(input_array)\n",
    "    intermed_array = (input_array - L) / (H - L)\n",
    "    output_array = intermed_array * (high_val - low_val) + low_val\n",
    "    return output_array\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "518cbc51-424f-4645-9116-4b8ef24bcd00",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "259.81666666666666\n",
      "278.15\n",
      "273.15\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "f = 0\n",
    "k = 0\n",
    "\n",
    "def f2k(f):\n",
    "    k = ((f - 32) * (5.0 / 9.0)) + 273.15\n",
    "    return k\n",
    "\n",
    "print(f2k(8))\n",
    "print(f2k(41))\n",
    "print(f2k(32))\n",
    "\n",
    "print(k)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "b838a346-7718-40b8-b27d-cf078e86de15",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "non-default argument follows default argument (589919717.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  Cell \u001b[0;32mIn[104], line 1\u001b[0;36m\u001b[0m\n\u001b[0;31m    def numbers(one, two=2, three, four=4):\u001b[0m\n\u001b[0m                            ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m non-default argument follows default argument\n"
     ]
    }
   ],
   "source": [
    "def numbers(one, two=2, three, four=4):\n",
    "    n = str(one) + str(two) + str(three) + str(four)\n",
    "    return n\n",
    "\n",
    "print(numbers(1, three=3))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "ae0f4736-4739-4a46-afbb-71b667aa4115",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a:  -1 b:  2 c: 6\n"
     ]
    }
   ],
   "source": [
    "def func(a, b=3, c=6):\n",
    "    print('a: ', a, 'b: ', b, 'c:', c)\n",
    "\n",
    "func(-1, 2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "736c5fca-1e1f-470f-ba22-6760918fa9e6",
   "metadata": {},
   "source": [
    "## Key Points\n",
    "* Define a function using def function_name(parameter).\n",
    "* The body of a function must be indented.\n",
    "* Call a function using function_name(value).\n",
    "* Numbers are stored as integers or floating-point numbers.\n",
    "* Variables defined within a function can only be seen and used within the body of the function.\n",
    "* Variables created outside of any function are called global variables.\n",
    "* Within a function, we can access global variables.\n",
    "* Variables created within a function override global variables if their names match.\n",
    "* Use help(thing) to view help for something.\n",
    "* Put docstrings in functions to provide help for that function.\n",
    "* Specify default values for parameters when defining a function using name=value in the parameter list.\n",
    "* Parameters can be passed by matching based on name, by position, or by omitting them (in which case the default value is used).\n",
    "* Put code whose parameters change frequently in a function, then call it with different parameter values to customize its behavior.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a6a7c2a-651e-4238-aee0-fd39e9702097",
   "metadata": {},
   "outputs": [],
   "source": [
    "# What Next?\n",
    "* Explain RSE Team and RSEs in general\n",
    "* Training Survey\n",
    "* Workshops available on request\n",
    "* Research Computing Team\n",
    "* Code Surgery\n",
    "* Show and Tell"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}