1_Introduction__LiveNotebook.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Language Basics\n",
    "\n",
    "This notebook introduces some Python language basics. It is designed for a code-along during the workshop. Some code blocks are deliberately incomplete or have bugs included.\n",
    "\n",
    "To execute code: Place your cursor in the cell, then hit SHIFT + ENTER"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "When writing computer code, there are *rules* and there are *conventions* (adapted from David Dempsey's [Python for Geoscientists](https://github.com/ddempsey/python_for_geoscientists) course)\n",
    "\n",
    "- If you break a __\\*rule\\*__, the code will not work.\n",
    "\n",
    "- If you break a __\\*convention\\*__, someone, somewhere puts a mark against your name in a book. At the end of times, there will be a final accounting.\n",
    "\n",
    "Some Python rules:\n",
    "\n",
    "- __\\*Syntax\\*__ - we have very precise expectations about how you write computer code. If you type an opening a bracket, you must close it again later. Some lines must be terminated by a colon, - if you omit this, the code will not work. __\\*Learning syntax for a new code is very pedantic and a total pain.\\*__ But you have to do it anyway, and at least Python returns readable error messages to help you understand your missteps...\n",
    "- __\\*Indentation\\*__ - Python reads indentation (not all languages do) and your code will not work if it is not correctly indented. \n",
    "\n",
    "Some Python conventions:\n",
    "\n",
    "- __\\*Commenting\\*__ - it is helpful for the poor soul who has to read your poorly written Python (sometimes that is you, weeks or months later) if you have included little 'sign-posts' in the code, articulating what you are doing. These are called comments. They begin with a # symbol, after which you can write whatever you like and it will not be executed as a command.\n",
    "- __\\*Sensible variable names\\*__ - a word or words relating to the thing the variable represents but not too long. For example, if a variable contains the mean temperature, then Tmean is a sensible variable name, where as the_mean_temperature_of_the_profile or a1 are not sensible variable names. \n",
    "- __\\*Layout\\*__ - Although the computer reads Python line-by-line, using a vertical layout improves the human readability and your ability to comment code. Headings and the liberal use of whitespace improves readbility. \n",
    "- __\\*Structure\\*__ - Python files and projects have a standard structure that improves redabality. The structure of files vary, but all files should start with an explanation of what they do and all packages/modules should be imported at the top. For the advanced folks, more on Python project structure can be found [here](https://docs.python-guide.org/writing/structure/).\n",
    "\n",
    "Units are a common source of error. Approches to managing this include:\n",
    "- Include units in the variable names (my preferred) `Tmean_degC = 300`\n",
    "- Include in-line comments on units and conversions used (good, but can be lost information) `Tmean = 300 # mean temp in degC`\n",
    "- Consider tools like [Pint](https://pint.readthedocs.io/en/stable/) to manage units, if it is a large problem (good, but assumes everyone knows how to use pint)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## Python Packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import packages \n",
    "\n",
    "''' Good practice: \n",
    "Import all libraries/packages used at the top of the document'''\n",
    "\n",
    "import matplotlib.pyplot as plt # foundation module for plotting\n",
    "import numpy as np # for array based programming and advanced math\n",
    "import math # for basic mathematical methods\n",
    "import pandas as pd # for spreadsheet-like methods + more\n",
    "import matplotlib.pyplot as plt # foundation module for plotting\n",
    "import seaborn as sns # for advanced plotting methods\n",
    "import matplotlib.dates as mdates # for formatting datetime in plot axis\n",
    "\n",
    "''' Good practice: \n",
    "Packages have standard short names. \n",
    "Using the standard name improves readability. \n",
    "Look at the docs if you are unsure what the standard name is.\n",
    "For example, https://matplotlib.org/3.5.3/api/_as_gen/matplotlib.pyplot.html) ''';\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import antigravity\n",
    "\n",
    "# installing a package can launch code\n",
    "# be careful what you install! "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Language Basics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# variable \n",
    "# the string 'hello world' has been assigned to the variable x\n",
    "\n",
    "x = "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Types: string, integer, float (more on slide)\n",
    "# Python is a dynamic typed language, checking type (variable state)\n",
    "\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Data structures and the many forms of list https://docs.python.org/3/tutorial/datastructures.html#"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Lists and array (numpy)\n",
    "\n",
    "my_list = [1,2,3,4]\n",
    "\n",
    "\n",
    "my_array = \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_of_10s = np.array([10,10,10,10])\n",
    "array_of_5s = np.array([5,5,5,5])\n",
    "\n",
    "new_array = array_of_5s + array_of_10s\n",
    "\n",
    "\n",
    "# array-based programming"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_of_10s = [10,10,10,10]\n",
    "list_of_5s = [5,5,5,5]\n",
    "\n",
    "new_list = list_of_5s + list_of_10s\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Basics: Complex lists and arrays \n",
    "\n",
    "complex_list = ['harry', 1, 9.5, [2,3,4]]\n",
    "print(complex_list)\n",
    "\n",
    "complex_array = np.array(['harry', 1, 9.5,[2,3,4]],dtype=object)\n",
    "print(complex_array, complex_array.shape)\n",
    "\n",
    "nD_array = np.array([[4,5,6],[1,2,3]])\n",
    "print(nD_array, nD_array.shape)\n",
    "\n",
    "# shape tells us the number of elements in each dimension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# tuple - a fixed collection of objects or variables\n",
    "\n",
    "my_tuple = (3, 5, 7)\n",
    "\n",
    "my_object = [9.1,9.2,9.3]\n",
    "\n",
    "complex_tuple = (3, 5, 7, ['d','wow',3.2], 'fish', my_object)\n",
    "\n",
    "print(type(complex_tuple))\n",
    "\n",
    "# Lists vs tuples\n",
    "# Tuples are more memory efficient than lists\n",
    "# Generally, people expect lists to contain one type while it is more acceptable to mix types in a tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# indexing (lists, tuples and arrays)\n",
    "\n",
    "#print(complex_tuple[1])\n",
    "#print(complex_tuple[3][1])\n",
    "\n",
    "#print() # get 9.3 out of complex_tuple\n",
    "#print() # get 9.3 out of complex_tuple\n",
    "\n",
    "# note how python starts counting at zero, so the first element = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# dictionary - a value is mapped to a key\n",
    "colors = {\n",
    "    'blue': '#36648B', # nice low-saturation blue\n",
    "    'brown': '#8B5D36', # complementary color to the blue\n",
    "}\n",
    "\n",
    "\n",
    "\n",
    "#print(colors['blue'])\n",
    "\n",
    "#colors['blue'] = 'another blue'\n",
    "\n",
    "#print(colors['blue'])\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Colors in Python:\n",
    "\n",
    "- Hex colors https://www.color-hex.com/\n",
    "- Named colors https://matplotlib.org/stable/gallery/color/named_colors.html\n",
    "- Colormaps https://matplotlib.org/stable/tutorials/colors/colormaps.html\n",
    "\n",
    "Beware the impact of color on your analysis! https://hess.copernicus.org/articles/25/4549/2021/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython import display\n",
    "display.Image(\"https://imgs.xkcd.com/comics/painbow_award.png\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python as Calculator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "radius_m = 3\n",
    "\n",
    "area_m2 = "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Estimating well injectivity using field operational data:\n",
    "\n",
    "$$\n",
    "I I=\\frac{Q}{P_{H}+W H P-P_{F}-P_{F Z}}\n",
    "$$\n",
    "\n",
    "where $Q$ Flow rate (t/hr), $P_{H}$ is hydrostatic pressure inside the well (bara), $WHP$ is wellhead pressure (bara), $P_{F}$ is the pressure of frictional losses (bara), and $P_{F Z}$ is the reservoir pressure at the feedzone or pivot point (bara). \n",
    "\n",
    "_(Siega et al. (2014) Quantifying the effect of temperature on well injectivity, New Zealand Geothermal Workshop)_\n",
    "\n",
    "Python uses Latex for formatting mathematical expressions https://www.overleaf.com/learn/latex/Mathematical_expressions\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Variable names: \n",
    "# Use common abbreviations or write it out\n",
    "# Do not just use equation terms (Q, Ph, WHP) unless they are universal and defined somewhere in your file\n",
    "\n",
    "flow_rate_tph = 400 \n",
    "hydrostatic_pressure_bara = 115\n",
    "wellhead_pressure_bara = 1\n",
    "friction_loss_bara = 9.7\n",
    "feedzone_pressure_bara = 84\n",
    "\n",
    "ii_tphrpbar = flow_rate_tph / (hydrostatic_pressure_bara + wellhead_pressure_bara - friction_loss_bara - feedzone_pressure_bara)\n",
    "\n",
    "print(ii_tphrpbar)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Using for loops to calculate value for multiple values - iterate over one list\n",
    "\n",
    "flow_rates_tph = [400, 300, 200, 100]\n",
    "\n",
    "varied_rate_ii_tphrpbar = []\n",
    "\n",
    "for rate in flow_rates_tph:\n",
    "    ii = rate / (hydrostatic_pressure_bara + wellhead_pressure_bara - friction_loss_bara - feedzone_pressure_bara)\n",
    "    varied_rate_ii_tphrpbar.append(ii)\n",
    "\n",
    "print(varied_rate_ii_tphrpbar)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Algorithm building: Logical operators and flow control\n",
    "\n",
    "Tests that return True or False\n",
    "\n",
    "### Boolean operators\n",
    "\n",
    "- And\n",
    "- Or\n",
    "- Not\n",
    "\n",
    "### Comparison operators\n",
    "\n",
    "- == Equal to\n",
    "- != Not equal to\n",
    "- <\tLess than\n",
    "- \\> Greater Than\n",
    "- <= Less than or Equal to\n",
    "- \\>= Greater than or Equal to\n",
    "\n",
    "### \"if\" statements\n",
    "\n",
    "- if\n",
    "- elif\n",
    "- else\n",
    "\n",
    "### 'for' loop\n",
    "\n",
    "- pass in a list or array that is iterated over\n",
    "\n",
    "Refer to [this link](https://www.pythoncheatsheet.org/cheatsheet/control-flow) for other options and various examples. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Basics: \"for loop\" and whitespace\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Using for loops to calculate value for multiple values - iterate over many lists\n",
    "\n",
    "flow_rates_tph = [400, 300, 200, 100]\n",
    "wellhead_pressures_bara = [10, 8, 5, 1]\n",
    "\n",
    "varied_rate_and_whp_ii_tphrpbar = []\n",
    "\n",
    "for rate, whp in zip(flow_rates_tph, wellhead_pressures_bara):\n",
    "    ii = rate / (hydrostatic_pressure_bara + whp - friction_loss_bara - feedzone_pressure_bara)\n",
    "    varied_rate_and_whp_ii_tphrpbar.append(ii)\n",
    "\n",
    "print(varied_rate_and_whp_ii_tphrpbar)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Using if statements to dictate behavior\n",
    "\n",
    "flow_rates_tph = [400, 300, 200, 100]\n",
    "wellhead_pressures_bara = [10, 8, 5, 1]\n",
    "\n",
    "for rate, whp in zip(flow_rates_tph, wellhead_pressures_bara):\n",
    "    ii = rate / (hydrostatic_pressure_bara + whp - friction_loss_bara - feedzone_pressure_bara)\n",
    "    if ii > 10:\n",
    "        print('Great well!')\n",
    "    else:\n",
    "        print(':-(')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Simple\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# More flexibility: the axs method\n",
    "# when googling, use \"matplotlib axs\" to get the correct documentation \n",
    "\n",
    "fig, ax = plt.subplots(1,1) \n",
    "\n",
    "# the method plt.subplots() returns two things\n",
    "# one we have called figure (f or fig) and this is analogous to a page in your book\n",
    "# the other is the axis (one or many ax) which is analogous to the plot you draw on the that page\n",
    "\n",
    "ax.plot(\n",
    "    flow_rates_tph,\n",
    "    varied_rate_ii_tphrpbar,\n",
    "    color = colors['brown'],\n",
    "    marker = 'o',\n",
    "    label = 'Stable WHP'\n",
    "    )\n",
    "\n",
    "ax.plot(\n",
    "    flow_rates_tph,\n",
    "    varied_rate_and_whp_ii_tphrpbar,\n",
    "    color = 'k',\n",
    "    marker = 'o',\n",
    "    label = 'Increased WHP with increasing Q'\n",
    "    )\n",
    "\n",
    "ax.set_ylabel('II [T/hr/bar]')\n",
    "ax.set_xlabel('Flow rate [T/hr]')\n",
    "ax.legend()\n",
    "ax.grid()\n",
    "\n",
    "# https://github.com/ICWallis/tutorial-publication-ready-figures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Functions = re-useable tools\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#\n",
    "# Function\n",
    "#\n",
    "\n",
    "def ii_from_operational_conditions(Q,Ph,WHP,Pf,Pfz):\n",
    "    '''Calculate injectivity using field operational data\n",
    "    \n",
    "    For usage and case study, refer to Siega et al. (2014) \n",
    "    Quantifying the effect of temperature on well injectivity, \n",
    "    New Zealand Geothermal Workshop\n",
    "\n",
    "        Args:\n",
    "            Q (float): flow rate - t/hr\n",
    "            Ph (float): hydrostatic pressure inside the well - bara\n",
    "            WHP (float): wellhead pressure - bara\n",
    "            Pf (float): pressure due to friction - bara\n",
    "            Pfz (float): reservoir pressure at the feedzone or pivot point - bara\n",
    "\n",
    "        Returns:\n",
    "            injectivity - T/hr/bar\n",
    "    '''\n",
    "\n",
    "    ii = Q / (Ph + WHP - Pf - Pfz)\n",
    "\n",
    "    return ii\n",
    "\n",
    "#\n",
    "# Usage\n",
    "#\n",
    "\n",
    "# Input parameters for well WJ-13\n",
    "Q_tph = 400 # average for June\n",
    "Ph_bara = 115 # calculated using depth to feedzone and average injection temperature\n",
    "WHP_bara = 1 # average for June\n",
    "Pf_bara = 9.7 # calculated by finding the root of the Colebrook equation\n",
    "Pfz_bara = 84 # from the reservoir pressure correlation\n",
    "\n",
    "WJ13_June_ii_tphrpbar = ii_from_operational_conditions(Q_tph, Ph_bara, WHP_bara, Pf_bara, Pfz_bara)\n",
    "\n",
    "print(round(WJ13_June_ii_tphrpbar,2))\n",
    "\n",
    "\n",
    "# Functions can be placed in a file that is imported at the start\n",
    "# This reduces the code you are looking at\n",
    "# and enables you to focus on the science, rather than the code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['ii_tphrpbar'] = ii_from_operational_conditions(df.Q_tph, df.Ph_bara, df.WHP_bara, df.Pf_bara, df.Pfz_bara)\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Advanced plot for data analysis\n",
    "\n",
    "fig, ax = plt.subplots(1,1,figsize=(10,6))\n",
    "\n",
    "# https://seaborn.pydata.org/generated/seaborn.scatterplot.html\n",
    "\n",
    "sns.scatterplot(\n",
    "    x='Date', # Pandas column name for x data\n",
    "    y='ii_tphrpbar', # Pandas column name for y data\n",
    "    data=df, # Pandas dataframe name\n",
    "    ax=ax, # name of the axis that the seaborn plot goes in\n",
    "    s=140, # marker size\n",
    "    hue='WHP_bara', # marker colour\n",
    "    style='Well', # marker style\n",
    ")\n",
    "\n",
    "#plt.savefig('Case_study_plot1.png',facecolor='w')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Building on the above code to make a nice version for a report/publication\n",
    "\n",
    "# Make empty plot\n",
    "fig, ax = plt.subplots(1,1,figsize=(8,4))\n",
    "\n",
    "# Add data to plot\n",
    "sns.scatterplot(\n",
    "    x='Date', # Pandas column name for x data\n",
    "    y='ii_tphrpbar', # Pandas column name for y data\n",
    "    data=df, # Pandas dataframe name\n",
    "    ax=ax, # name of the axis that the seaborn plot goes in\n",
    "    s=140, # marker size\n",
    "    style='Well', # marker style\n",
    "    hue='WHP_bara', # marker colour\n",
    "    #palette='cividis',\n",
    "    #size='Q_tph',\n",
    "    #sizes=(140, 200)\n",
    "    zorder=10 # places markers in front of grid\n",
    ")\n",
    "\n",
    "# Seaborn color pallets https://seaborn.pydata.org/tutorial/color_palettes.html\n",
    "\n",
    "# Format axis\n",
    "ax.set_ylim(5,20)\n",
    "\n",
    "ax.xaxis.set_major_formatter(mdates.DateFormatter(\"%d %b\"))\n",
    "\n",
    "ax.set_xlabel('') # Replaces auto date label with nothing\n",
    "\n",
    "ax.set_ylabel('II [T/hr/bar]')\n",
    "\n",
    "# Place legend outside the plot area\n",
    "ax.legend(\n",
    "    loc='center left', \n",
    "    bbox_to_anchor=(1.05, 0.45), \n",
    "    ncol=1,\n",
    ")\n",
    "\n",
    "# Add title\n",
    "plt.title('Injection Well Performance Q1 2022')\n",
    "\n",
    "# Add grid\n",
    "ax.grid(linestyle=':', alpha=0.8)\n",
    "\n",
    "# Export figure\n",
    "'''\n",
    "plt.savefig(\n",
    "    'Case_study_plot2.png',\n",
    "    dpi=400,\n",
    "    facecolor='w',\n",
    "    bbox_inches='tight'\n",
    "    )'''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sub-select data using comparison operator  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# using reassignment - take care of notebook order!\n",
    "df = "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "### Where to from here?\n",
    "\n",
    "__\\*The best way forward is to learn by doing!\\*__\n",
    "\n",
    "I most commonly use python to...\n",
    "\n",
    "Document methods and analysis in Jupyter notebooks:\n",
    "- Methods are displayed in sequence\n",
    "- Can combine notes, equations, views on the data and plots in an easily read format\n",
    "- Can be exported to html so non-coding folks can read them\n",
    "\n",
    "Automate tasks: \n",
    "- Especially useful for repetitive data processing tasks\n",
    "- [Automate the Boring Stuff](https://automatetheboringstuff.com/) is a great book for getting started with Python and automation\n",
    "\n",
    "Handle large datasets, do complex calculations, make interactive graphics, and more! \n",
    "\n",
    "__Learn more Python skills__ using on-line resources:\n",
    "- A [list of useful resources](https://mharty3.github.io/resources/) for geoscientists learning python has been put together by Michael Harty\n",
    "- [Practical Python](https://dabeaz-course.github.io/practical-python/Notes/Contents.html) great course if you can survive stock tickers. Self driven and comprehensive. \n",
    "- David Dempsey's [Python for Geoscientists](https://github.com/ddempsey/python_for_geoscientists) specific to geosciences. Designed to be classroom taught, but chock-full of useful examples. \n",
    "- [Plotting with Python](https://github.com/ICWallis/tutorial-publication-ready-figures) for basic to advanced plotting with matplotlib. Designed to be classroom taught, but see solutions and recipes folders for code examples.\n",
    "- [Software carpentry](https://software-carpentry.org/lessons/) a wide range of learning resources\n",
    "- [EdX course](https://www.edx.org/course/introduction-computer-science-harvardx-cs50x)\n",
    "\n",
    "\n",
    "__Find your community__ and join [Software Underground](https://softwareunderground.org/) to connect with people who do computers + subsurface\n",
    "- Active slack community where people help each other (note that they are currently moving to a new platform because of $$)\n",
    "- Annual virtual conference with lots of free training opportunities\n",
    "- [SWUG YouTube channel](https://www.youtube.com/c/softwareunderground), with loads of subsurface-relevant tutorials \n",
    "\n",
    "Don't be discouraged. It takes time to learn any language, including Python. But even if it takes years to become fluent, just a few Python basics can open a whole new world up for you. Have a read of this post by [Peter Norvig](https://norvig.com/21-days.html) for some sage advice on how to learn programming.\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.9.18"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "c268d92783217d0a189fd0f6bc72a35770f06191246a63de0fd4bf64fa0bf04a"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}