Python_tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A Brief Introduction to Python, numpy, and matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this lesson, we'll learn about the [Python programming language](https://www.python.org/) and the [Jupyter notebook](http://jupyter.org/), as well as the Python packages [numpy](http://www.numpy.org/) and [matplotlib](http://matplotlib.org/).\n",
    "\n",
    "This isn't a very thorough introduction -- we'll just learn the things that are essential for the course.  Some resources for learning more about Python and its use in scientific computing are linked [at the end of this notebook](#Further-resources)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To run the code in this notebook, you'll need an installation of Python, numpy, and matplotlib.  The easiest way to get them all is to use [CoCalc](http://cocalc.com) -- just create a free account, start a new project, and upload this notebook file.  Then open this notebook there and you're off.\n",
    "\n",
    "You can also install everything locally on your own machine.  For local installation, [Anaconda](https://www.anaconda.com/) is convenient, or you can just use pip.  All of these are free.  If you're new to Python, I recommend using Python version 3.7 or later."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python and the Jupyter Notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The code for this course is written in Python, which is a programming language designed to promote code that is easy to read and write.  Python has become one of the most important languages in scientific computing, and is arguably [the most popular programming language in the world](https://www.hpcwire.com/2018/08/07/python-remains-the-most-popular-programming-language/).  It is high-level like MATLAB, but unlike MATLAB it is free and is intended as a general-purpose language."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Jupyter](http://www.jupyter.org) is a collection of tools for interactive programming in Python.  Most importantly for us, Jupyter includes a browser-based notebook.  The notebook (which you are using now) allows you to run Python code in your web browser; just click on a cell with code and hit shift+enter.  Try it with the cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"AMCS 252 is the best!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try changing the message in the box and running it again.\n",
    "\n",
    "The box of code above is called a *cell*.  You can use the menu and toolbar near the top of your browser to insert or delete cells or save the notebook.  The text you're reading is also in a cell, which you can edit (just double-click on this text).  You'll also see math in these cells; the math is written using LaTeX.  For example:\n",
    "\n",
    "$$e^{i \\pi} = -1.$$\n",
    "\n",
    "The menu bar above also has buttons to run cells or to stop code running."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can find a huge collection of interesting Jupyter notebooks on a wide range of topics [here](https://github.com/jupyter/jupyter/wiki/A-gallery-of-interesting-Jupyter-Notebooks).  Since notebooks combine text, mathematics, and executable code, they're a great way to learn.\n",
    "\n",
    "If you prefer programming in an IDE, you may wish to try out [Jupyterlab](https://jupyterlab.readthedocs.io/en/stable/)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python basics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has many built-in functions, like `print`, but most functions are inside *modules*, which aren't loaded unless you `import` them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import sqrt\n",
    "print(sqrt(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also import a whole module:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "print(math.sqrt(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What else is in the `math` module?  You can find out using IPython's tab completion.  Just put your cursor at the end of the line below and hit `tab`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "math."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What does `math.atan2` do, for instance?  You can find out with IPython's magic help function, invoked by using the question mark after a function name.  When you're done reading the help, you can close the pager below by clicking on the \"x\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "math.atan2?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A *list* is an ordered collection of values or objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = ['apple',2,3,4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can ask for one or more items from a list as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x[:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x[:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Two important things to remember:\n",
    "1. Python lists are indexed starting from zero.\n",
    "2. When you ask for a range of things, you don't get the last one."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can quickly make lists of numbers using the `range` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = list(range(5))\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in [10, 20, 'x']:\n",
    "    print(i)\n",
    "    print('in the loop')\n",
    "    # still inside the loop\n",
    "\n",
    "# Now outside the loop    \n",
    "print('finished')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A *for loop* just iterates over a list.  Notice how the contents of the loop are indented.  Python knows the loop has ended when it finds a line that is not indented.  \n",
    "\n",
    "To nest loops, indent again:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(5):\n",
    "    print(i)\n",
    "    for j in range(2):\n",
    "        print('in the inner loop')\n",
    "    \n",
    "print('finished')\n",
    "print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Don't forget the colon!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def square(x):\n",
    "    return x**2\n",
    "\n",
    "print(square(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def identity(x):\n",
    "    return square(sqrt(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "identity(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how the contents of the function are indented (just like the for loop).  Python knows the function has ended when it finds a line that is not indented."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numpy\n",
    "Python includes a package for numerical computation called numpy,  which will be an essential tool in this course. You may find the  following links helpful:  \n",
    "\n",
    "- [Numpy docs tutorial](https://docs.scipy.org/doc/numpy/user/quickstart.html)\n",
    "- [Another nice numpy tutorial](http://cs231n.github.io/python-numpy-tutorial/)\n",
    "\n",
    "If you want something really exhaustive, read either of the books by Hans Petter Langtangen (KAUST has access to the e-books).  \n",
    "\n",
    "To get started, we import the numpy module.  We will also tell Python that we want to refer to numpy by the short abbreviation \"np\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arrays\n",
    "\n",
    "The most important Numpy class is the `array`.  You can make arrays just like you would in MATLAB:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.linspace(0, 1, 5)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Try changing the inputs to the *linspace* function and see if you can determine exactly what it does.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = np.arange(0, 1, 0.2)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Try changing the inputs to the *arange* function to determine exactly what it does.**  You can also use the help (via \"?\") to get an explanation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like `range`, `arange` omits the final value."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arrays are like lists, except that you can perform math with them in an easier and faster way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(x+y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(x*y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The syntax for creating a multidimensional array in numpy is also similar to Matlab:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([[1,2,3],[2,5,6],[3,8,9]])\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can slice numpy arrays just as in Fortran 90 or Matlab, but (as with lists) the arrays are indexed from zero and you don't get the last element of a slice."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(A[1,0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(A[:,0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can index in some slightly fancier ways, too:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(A[:,1:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(A[-1,:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Array and matrix multiplication\n",
    "How does multiplication of arrays work? Let's see:  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can do lots of other things with arrays.  Type \"A.\" (notice the period!) and press `tab` to see some of them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(A*A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default, numpy just multiplies componentwise. If you want to do matrix-matrix (or matrix-vector) multiplication, use the *dot* function:  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.dot(A,A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python 3, you can also just use the \"@\" symbol:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A@A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.array([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.dot(A,x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A@x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that Numpy doesn't have different representations for \"row\" or \"column\" vectors.  It will interpret a vector whichever way is necessary so that the operation you ask for makes sense:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x@A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.dot(x,x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x@x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.outer(x,x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Linear algebra\n",
    "What else can you do with ndarrays? Besides basic arithmetic, there is a nice linear algebra package:  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.linalg?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use this package to solve a linear system of equations: $Mx=b$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "M = np.array([[0,2],[8,0]])\n",
    "b = np.array([1,2])\n",
    "print(M)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.linalg.solve(M,b)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Can you think of an easy way to check that $x$ is the correct solution?  Program your check in the box below.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also solve eigenvalue problems:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lamda, V = np.linalg.eig(M)\n",
    "print(lamda)\n",
    "print(V)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how we have put two variables on the left of the equals sign, to assign the outputs of *eig()* to two different variables. What are the two outputs?  **How can you check that these outputs are correct?  Program it in the box below.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Try playing around with some of the things you found in the box below. See if you can do the following:**   \n",
    "1. Create a 10x10 matrix whose $(i,j)$ entry is equal to $i\\times j$ without using a loop. Hint: use <em>np.fromfunction()</em>.  \n",
    "2. Split your 10x10 matrix into five $10 \\times 2$ matrices with one line of code. Hint: use <em>np.hsplit()</em>**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For plotting we will use the [matplotlib](http://matplotlib.org/) package.  It works a lot like MATLAB's plotting functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now for a very simple example. Suppose we want to plot the function $\\sin(\\exp(x))$ on the interval $x\\in(0,4)$. We'll use the numpy versions of the sine and exponential functions, which operate on arrays (the math module versions operate only on scalars):  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=np.linspace(0,4,1000)\n",
    "f=np.sin(np.exp(x))\n",
    "plt.plot(x,f,'--k');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll also see later how to make animations with Matplotlib and Jupyter."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A note about speed\n",
    "\n",
    "Like MATLAB, Python is relatively slow -- especially when using **loops** with many iterations, nested loops, or deeply nested function calls.  For the exercises in this course, Python will be sufficiently fast, but you should use numpy slicing whenever possible.\n",
    "\n",
    "We will often need to compute the difference of each pair of successive entries of an array.  Here are two ways to do it.  Which is faster?  We can find out using another \"magic\" function, `%%timeit`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "N = 1000000\n",
    "a = np.random.rand(N)\n",
    "b = np.zeros(N-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%timeit\n",
    "for i in range(len(b)):\n",
    "    b[i] = a[i+1]-a[i]  # Compute successive differences"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%timeit\n",
    "b = a[1:]-a[:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For large-scale computational problems, you shouldn't use Python for any code that needs to be fast. Instead, you can write/generate code in C or Fortran and use weave, [cython](http://cython.org/), [f2py](http://www.f2py.com/), or other similar packages like [numba](https://numba.pydata.org/) to automatically incorporate compiled code into your Python program."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Why use Python?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hopefully this brief adventure has convinced you that Python is a worthwhile programming language.  Some of the reasons I chose Python as the language for this course (and other courses I teach) are:\n",
    "- Compared to lower-level languages like C, C++, and Fortran, Python code is easier to write and read (meaning fewer bugs!)\n",
    "- A huge number of available libraries means it is easy to get things done in Python without writing a lot of code yourself\n",
    "- Python is a general-purpose programming language, with features (like optional arguments with defaults) that lead to more elegant, maintainable code than what you can write with specialized languages like MATLAB.\n",
    "- Python is free and comes installed on most systems.  You can run this whole course with only a web browser and access to the internet.\n",
    "- It's easy to incorporate code written in other languages into your Python programs.\n",
    "- It's often easy to [parallelize existing scientific codes](http://numerics.kaust.edu.sa/papers/pyclaw-sisc/pyclaw-sisc.html) using Python.\n",
    "- All these advantages have made it [very](https://www.economist.com/graphic-detail/2018/07/26/python-is-becoming-the-worlds-most-popular-coding-language) [popular](https://stackoverflow.blog/2017/09/06/incredible-growth-python/)\n",
    "\n",
    "For a longer discussion with links to some scientific studies of the value of Python, see [this blog post by Lorena Barba](http://lorenabarba.com/blog/why-i-push-for-python/)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Further resources"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python, numpy, and matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We've only scratched the surface of Python here.  You'll learn more in the rest of the course -- and it's great to learn by doing.  But if you want a really solid foundation, you may want to take a look at these:\n",
    "\n",
    "- http://www.learnpython.org/ (free)\n",
    "- http://www.codecademy.com/tracks/python (free)\n",
    "- https://diveintopython3.net/ (free)\n",
    "- [A Primer on Scientific Programming with Python](http://www.amazon.com/Scientific-Programming-Computational-Science-Engineering/dp/3642302920) (book; not free)\n",
    "- [Matplotlib tutorials](https://matplotlib.org/tutorials/index.html) (free)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Other Python packages for science"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Besides numpy and matplotlib, there are many other useful Python packages for scientific computing. Here is a short list:  \n",
    "\n",
    "- [PyTorch](https://pytorch.org/), [scikit-learn](https://scikit-learn.org/stable/) - Machine learning\n",
    "- [scipy](http://scipy.github.io/devdocs//) - optimization, ODEs, sparse linear algebra, etc.\n",
    "- [sympy](http://sympy.org/) - symbolic computation\n",
    "- Visualization: [yt](http://yt-project.org/), [vispy](http://vispy.org/), [Bokeh](http://bokeh.pydata.org/)\n",
    "- [pandas](http://pandas.pydata.org/) - data analysis\n",
    "- [mpi4py](https://mpi4py.readthedocs.io/en/stable/) - parallel computing\n",
    "- [petsc4py](https://petsc4py.readthedocs.io/en/stable/), [pytrilinos](https://trilinos.org/packages/pytrilinos/) - Python bindings for the \"big 2\" parallel scientific libraries\n",
    "- [FENiCS](http://fenicsproject.org/), [FiPy](http://www.ctcms.nist.gov/fipy/), [PyClaw](http://clawpack.github.io/pyclaw/) - solve complicated PDEs with very sophisticated numerical methods\n",
    "- [networkX](http://networkx.github.com/), [pygraphviz](https://pygraphviz.github.io/) - graphs\n",
    "- [astropy](http://www.astropy.org/), [biopython](http://biopython.org/wiki/Main_Page), [pychem](http://pychem.sourceforge.net/) - discipline-specific tools"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.4"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}