deleted files, improved python/numpy basics

Author: gregparkes

01-Principles/01 Python Basics.ipynb

@@ -110,7 +110,60 @@
    "source": [
     "The difference between the two is that using double quotes makes it easy to include apostrophes (whereas these would terminate the string if using single quotes). There are additional variations on defining strings that make it easier to include things such as carriage returns, backslashes and Unicode characters.\n",
     "\n",
-    "We can use single operators on numbers and strings, such as concatenation:"
+    "The dynamic typing means that the same variable name could be used for multiple different data types, for an example, look at this C code:\n",
+    "\n",
+    "```C\n",
+    "/* C code */\n",
+    "int result = 0;\n",
+    "for (int i = 0; i < 100; i++)\n",
+    "{\n",
+    "    result += i;\n",
+    "}\n",
+    "```\n",
+    "\n",
+    "While in Python the equivalent operation could be written as:\n",
+    "\n",
+    "```python\n",
+    "# python code\n",
+    "result = 0\n",
+    "for i in range(100):\n",
+    "    result += i\n",
+    "```\n",
+    "\n",
+    "Notice that the `result` variable is explicitly declared, whereas in Python it is not explicitly an integer. See what happens in C if `result` is set a string variable:\n",
+    "\n",
+    "```C\n",
+    "/* C code */\n",
+    "int x = 4;\n",
+    "x = \"four\"; // FAILS\n",
+    "```\n",
+    "\n",
+    "Whereas in Python:\n",
+    "\n",
+    "```python\n",
+    "# python code\n",
+    "x = 4\n",
+    "x = \"four\" # overwritten\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In Python, all types such as integers and strings are not *primitives*, but also *objects*. In fact, the standard Python implementation is written in C, meaning that a Python `int` is actually a C `struct`:\n",
+    "\n",
+    "```C\n",
+    "/* C code */\n",
+    "struct _longobject {\n",
+    "    long ob_refcnt;\n",
+    "    PyTypeObject *ob_type;\n",
+    "    size_t ob_size;\n",
+    "    long ob_digit[1];\n",
+    "};\n",
+    "```\n",
+    "\n",
+    "The same is true for all Python types, and even objects, which we will come onto later. We can use single operators on numbers and strings, such as concatenation:"
    ]
   },
   {
@@ -1358,7 +1411,7 @@
    "source": [
     "## Dictionaries\n",
     "\n",
-    "A dictionary is a data type similar to arrays, but works with keys and values instead of indexes. Each value stored in a dictionary can be accessed using a key, which is any type of object (a string, a number, a list, etc.) instead of using its index to address it.\n",
+    "A dictionary (previously known as a *hash table*) is a data type similar to arrays, but works with keys and values instead of indexes. Each value stored in a dictionary can be accessed using a key, which is any type of object (a string, a number, a list, etc.) instead of using its index to address it.\n",
     "\n",
     "For example, a database of phone numbers could be stored using a dictionary like this:"
    ]
@@ -1704,7 +1757,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python [default]",
+   "display_name": "Python 3",
    "language": "python",
    "name": "python3"
   },
@@ -1718,7 +1771,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.5.6"
+   "version": "3.6.7"
   }
  },
  "nbformat": 4,

02-Simulation/01 NumPy Basics.ipynb

@@ -11,14 +11,39 @@
     "NumPy arrays therefore **must** be the same datatype (float, int etc).\n",
     "\n",
     "The flow of this notebook is as follows:\n",
-    "1. Creating an array\n",
-    "2. Creating zeros, ones, linspace...\n",
+    "1. Supported types\n",
+    "1. Creating an array from scratch\n",
     "3. Generating random numbers\n",
     "4. Inspecting the array\n",
     "5. Arithmetic operations\n",
     "6. Aggregation\n",
     "7. Subsetting, slicing, indexing\n",
     "\n",
+    "## Supported types\n",
+    "\n",
+    "NumPy arrays contain values of a *single type*, so it's important to know which types are available to use, in addition to the fact that NumPy is built in C. These can usually be specified in NumPy array-creating functions using the `dtype` parameter:\n",
+    "\n",
+    "| **Data Type** | **Description** |\n",
+    "| ---------- | ----------------------------- |\n",
+    "| `bool_` | Boolean (`True` or `False` stored as a byte |\n",
+    "| `int_` | Default integer type (same as C `long`) |\n",
+    "| `intc` | Identical to C `int` |\n",
+    "| `intp` | Integer for indexing |\n",
+    "| `int8` | A byte |\n",
+    "| `int16` | Integer (-32768 to 32767) |\n",
+    "| `int32` | Integer (-2147483648 to 2147483647) |\n",
+    "| `int64` | Integer (-9223372036854775808 to 9223372036854775807) |\n",
+    "| `uint8` | Unsigned Integer (0 to 255) |\n",
+    "| `uint16` | Unsigned Integer (0 to 65535) |\n",
+    "| `uint32` | Unsigned Integer (0 to 4294967295) |\n",
+    "| `uint64` | Unsigned Integer (0 to 18446744073709551615) |\n",
+    "| `float_` | Same as `float64` |\n",
+    "| `float16` | Half precision float (1-bit sign, 5-bit exponent, 10-bit mantissa) |\n",
+    "| `float32` | Single precision float (1-bit sign, 8-bit exponent, 23-bit mantissa) |\n",
+    "| `float64` | Double precision float (1-bit sign, 11-bit exponent, 52-bit mantissa) |\n",
+    "|`complex_` | Same as `complex128` |\n",
+    "| `complex64` | Complex number, as two 32-bit floats |\n",
+    "| `complex128` | Complex number, represented by two 64-bit floats |\n",
     "\n",
     "We use the following convention **np** for numpy import:"
    ]
@@ -36,7 +61,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Creating an array\n",
+    "## Creating arrays from scratch\n",
     "\n",
     "We can initialize numpy arrays from nested Python lists, and access elements using square brackets:"
    ]
@@ -61,7 +86,7 @@
    "outputs": [],
    "source": [
     "# 2-d ints\n",
-    "b = np.array([[3.0, 2.0],[1.0, 2.0]], dtype=int)\n",
+    "b = np.array([[3.0, 2.0],[1.0, 2.0]], dtype=np.int_)\n",
     "b"
    ]
   },
@@ -87,8 +112,6 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Creating zeros, ones, linspace, identity matrix...\n",
-    "\n",
     "Numpy also provides many functions to create arrays from the same value or not, for example `zeros()` creates an array full of zeros, given a specific size (or tuple of dimensions!), and `linspace()` creates an incrementally-ordered vector of numbers between two given values, and given a size."
    ]
   },
@@ -170,6 +193,23 @@
     "g"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "An even faster form of allocation, if you're going to fill the array/matrix yourself, is to allocate an *empty array*, meaning the values are uninitialized:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "c2 = np.empty((10,), dtype=np.float64)\n",
+    "c2"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -227,7 +267,28 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Data Types"
+    "## Array attributes\n",
+    "\n",
+    "The three primary attributes a NumPy array has are:\n",
+    "\n",
+    "1. Number of dimensions (`ndim`)\n",
+    "2. Array shape (`shape`)\n",
+    "3. Total size of the array (`size`)\n",
+    "\n",
+    "If we begin by allocating a 1-D, 2-D and 3-D array:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# for reproducibility\n",
+    "np.random.seed(0)\n",
+    "array1d = np.random.randint(10, size=6)\n",
+    "array2d = np.random.randint(10, size=(3, 4))\n",
+    "array3d = np.random.randint(10, size=(3,4,5))"
    ]
   },
   {
@@ -236,19 +297,19 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "print(np.int64)\n",
-    "print(np.float64)\n",
-    "print(np.bool)\n",
-    "print(np.string_)"
+    "def print_array(arr):\n",
+    "    print(\"array ndim: %d\" % arr.ndim)\n",
+    "    print(\"array shape: {}\".format(arr.shape))\n",
+    "    print(\"array size: %d\" % arr.size)"
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": null,
    "metadata": {},
+   "outputs": [],
    "source": [
-    "## Array shape\n",
-    "\n",
-    "Returns a *tuple* whereby the first number represents the **number of rows** (FORTRAN-style memory-mapping!), the second number represents the **number of columns** and so on into higher dimensions."
+    "print_array(array1d)"
    ]
   },
   {
@@ -257,9 +318,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "print(a.shape)\n",
-    "print(j.shape)\n",
-    "print(c.shape)"
+    "print_array(array2d)"
    ]
   },
   {
@@ -268,8 +327,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# the number of dimensions!\n",
-    "b.ndim"
+    "print_array(array3d)"
    ]
   },
   {
@@ -278,8 +336,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "print(a.dtype)\n",
-    "print(b.dtype)"
+    "print(array3d.dtype)"
    ]
   },
   {
@@ -1200,9 +1257,7 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "source": [
     "### Task 3.\n",
     "\n",
@@ -1235,7 +1290,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.6"
+   "version": "3.6.7"
   }
  },
  "nbformat": 4,