Update lesson for 2020

Author: davewhipp

L1/a-taste-of-python.ipynb

@@ -9,6 +9,9 @@
    "source": [
     "# A taste of Python\n",
     "\n",
+    "University of Helsinki students are encouraged to use the CSC Notebooks platform.<br/>\n",
+    "<a href=\"https://notebooks.csc.fi/#/blueprint/7e62ac3bddf74483b7ac7333721630e2\"><img alt=\"CSC badge\"     src=\"https://img.shields.io/badge/launch-CSC%20notebook-blue.svg\" style=\"vertical-align:text-bottom\"></a>\n",
+    "\n",
     "We will start our Python lesson by learning a bit of the basic operations you can perform using Python.\n",
     "\n",
     "## General information\n",
@@ -23,7 +26,7 @@
     "\n",
     "### Getting started\n",
     "\n",
-    "Presumably if you have made it this far, you have already opened this Jupyter Notebook using Binder, the CSC notebooks server, or on your own computer. If not, you can launch [Jupyter Lab](http://jupyterlab.readthedocs.io/en/stable/) by clicking on either of the launch buttons at the top of this document or by typing the following in a terminal window.\n",
+    "Presumably if you have made it this far, you have already opened this Jupyter Notebook using Binder, the CSC notebooks server, or on your own computer. If not, you can launch [Jupyter Lab](http://jupyterlab.readthedocs.io/en/stable/) by clicking on the launch button at the top of this document, using the launch Binder icon at the top of the page, or by typing the following in a terminal window.\n",
     "\n",
     "```bash\n",
     "$ jupyter lab\n",
@@ -83,7 +86,7 @@
     "editable": true
    },
    "source": [
-    "If you want to edit and re-run some code, simply make changes to the cell and press **Shift-Enter** to execute the revised code."
+    "If you want to edit and re-run some code, simply make changes to the cell and press **Shift-Enter** to execute the modified code."
    ]
   },
   {
@@ -95,9 +98,9 @@
    "source": [
     "### Functions\n",
     "\n",
-    "You can use Python for more advanced math by using functions. Functions are pieces of code that perform a single action such as printing information to the screen (e.g., the ``print()`` function). Functions exist for a huge number of operations in Python.\n",
+    "You can use Python for more advanced math by using a *function (funktio)*. Functions are pieces of code that perform a single action such as printing information to the screen (e.g., the `print()` function). Functions exist for a huge number of operations in Python.\n",
     "\n",
-    "Let's try out a few simple examples using functions to find the sine or square root of a value. You can type ``sin(3)`` or ``sqrt(4)`` into the cells below to test this out."
+    "Let's try out a few simple examples using functions to find the sine or square root of a value. You can type `sin(3)` or `sqrt(4)` into the cells below to test this out."
    ]
   },
   {
@@ -109,7 +112,10 @@
     "editable": true,
     "jupyter": {
      "outputs_hidden": false
-    }
+    },
+    "tags": [
+     "raises-exception"
+    ]
    },
    "outputs": [],
    "source": []
@@ -123,7 +129,10 @@
     "editable": true,
     "jupyter": {
      "outputs_hidden": false
-    }
+    },
+    "tags": [
+     "raises-exception"
+    ]
    },
    "outputs": [],
    "source": []
@@ -157,7 +166,7 @@
     "| Division       | `/`    | `4 / 2`        | `2`            |\n",
     "| Exponentiation | `**`   | `2**3`         | `8`            |\n",
     "\n",
-    "For anything more advanced, we need to load a *module*. For math operations, this module is called *math* and it can be loaded by typing ``import math``. Try that below."
+    "For anything more advanced, we need to load a *module (moduuli)* or *library (ohjelmakirjasto)*. For math operations, this module is called *math* and it can be loaded by typing `import math`. Try that below."
    ]
   },
   {
@@ -319,7 +328,7 @@
    "source": [
     "### Variables\n",
     "\n",
-    "*Variables* can be used to store values calculated in expressions and used for other calculations. Assigning value to variables is straightforward. To assign a value, you simply type ``variable_name = value``, where ``variable_name`` is the name of the variable you wish to define. In the cell below, define a variable called ``temp_celsius``, assign it a value of '10.0', and then print that variable value using the ``print()`` function. Note that you need to do this on two separate lines."
+    "A *variable (muuttuja)* can be used to store values calculated in expressions and used for other calculations. Assigning value to variables is straightforward. To assign a value, you simply type ``variable_name = value``, where ``variable_name`` is the name of the variable you wish to define. In the cell below, define a variable called ``temp_celsius``, assign it a value of '10.0', and then print that variable value using the ``print()`` function. Note that you should do this on two separate lines."
    ]
   },
   {
@@ -427,13 +436,7 @@
     "editable": true
    },
    "source": [
-    "<div class=\"alert alert-warning\">\n",
-    "\n",
-    "**Warning**\n",
-    "\n",
-    "If you try to run some code that accesses a variable that has not yet been defined you will get a `NameError` message. Try printing out the value of the variable ``tempFahrenheit`` using the ``print()`` function in the cell below.\n",
-    "\n",
-    "</div>"
+    "**Warning**: If you try to run some code that accesses a variable that has not yet been defined you will get a `NameError` message. Try printing out the value of the variable `tempFahrenheit` using the `print()` function in the cell below."
    ]
   },
   {
@@ -445,7 +448,10 @@
     "editable": true,
     "jupyter": {
      "outputs_hidden": false
-    }
+    },
+    "tags": [
+     "raises-exception"
+    ]
    },
    "outputs": [],
    "source": []
@@ -457,14 +463,9 @@
     "editable": true
    },
    "source": [
-    "<div class=\"alert alert-info\">\n",
-    "\n",
-    "**Note**\n",
-    "\n",
-    "One of the interesting things here is that if we define the undefined variable in a cell lower down in the notebook and execute that cell, we can return to the earlier cell and the code should now work. That was a bit of a complicated sentence, so let's test this all out. First, let's define a variable called ``tempFahrenheit`` in the cell below and assign it to be equal to ``9/5 * temp_celsius + 32``, the conversion factor from temperatures in Celsius to Fahrenheit. Then, return to the cell above this text and run that cell again. See how the error message has gone away? ``tempFahrenheit`` has now been defined and thus the cell above no longer generates a ``NameError`` when the code is executed.\n",
+    "**Note**: One of the interesting things here is that if we define the undefined variable in a cell lower down in the notebook and execute that cell, we can return to the earlier cell and the code should now work. That was a bit of a complicated sentence, so let's test this all out. First, let's define a variable called `tempFahrenheit` in the cell below and assign it to be equal to `9/5 * temp_celsius + 32`, the conversion factor from temperatures in Celsius to Fahrenheit. Then, return to the cell above this text and run that cell again. See how the error message has gone away? `tempFahrenheit` has now been defined and thus the cell above no longer generates a `NameError` when the code is executed.\n",
     "\n",
-    "Also, the number beside the cell, for example ``In [2]``, tells you the order in which the Python cells have been executed. This way you can see a history of the order in which you have run the cells.\n",
-    "</div>"
+    "Also, the number beside the cell, for example `In [2]`, tells you the order in which the Python cells have been executed. This way you can see a history of the order in which you have run the cells."
    ]
   },
   {
@@ -533,7 +534,8 @@
    "source": [
     "### Data types\n",
     "\n",
-    "There are 4 basic *data types* in Python as shown in the table below.\n",
+    "A *data type (tietotyyppi)* determines the characteristics of data in a program.\n",
+    "There are 4 basic data types in Python as shown in the table below.\n",
     "\n",
     "| Data type name | Data type            | Example    |\n",
     "| -------------- | -------------------- | ---------- |\n",
@@ -578,7 +580,10 @@
     "editable": true,
     "jupyter": {
      "outputs_hidden": false
-    }
+    },
+    "tags": [
+     "raises-exception"
+    ]
    },
    "outputs": [],
    "source": []
@@ -636,15 +641,11 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "<div class=\"alert alert-warning\">\n",
-    "\n",
-    "**Warning**\n",
-    "\n",
-    "Jupyter Notebooks might sometimes get stuck when using the ``input()`` function. If this happens, restart the kernel and run the cell again (**Kernel** -> **Restart Kernel...**).\n",
+    "```{warning}\n",
+    "Jupyter Notebooks might sometimes get stuck when using the `input()` function. If this happens, restart the kernel and run the cell again (**Kernel** -> **Restart Kernel...**).\n",
     "\n",
     "Also, we realize these cells **will not render properly on the course website**, but should work just fine in Binder or using the CSC notebooks. Sorry.\n",
-    "\n",
-    "</div>"
+    "```"
    ]
   },
   {
@@ -656,7 +657,10 @@
     "editable": true,
     "jupyter": {
      "outputs_hidden": false
-    }
+    },
+    "tags": [
+     "raises-exception"
+    ]
    },
    "outputs": [],
    "source": []
@@ -677,7 +681,10 @@
     "editable": true,
     "jupyter": {
      "outputs_hidden": false
-    }
+    },
+    "tags": [
+     "raises-exception"
+    ]
    },
    "outputs": [],
    "source": []
@@ -697,7 +704,10 @@
    "execution_count": null,
    "metadata": {
     "deletable": true,
-    "editable": true
+    "editable": true,
+    "tags": [
+     "raises-exception"
+    ]
    },
    "outputs": [],
    "source": []
@@ -712,108 +722,13 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "tags": [
+     "raises-exception"
+    ]
+   },
    "outputs": [],
    "source": []
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Good coding practices - Selecting \"good\" variable names\n",
-    "\n",
-    "This course aims to introduce you to programming in Python, but also to *good programming practices*. These comprise practical tips based on practices used by professional programmers that help them write better programs that are easier to understand and share with others. To say it differently, there are many ways to learn to program, and we want to help you learn how to program the right way!\n",
-    "\n",
-    "This week our good programming practice is about selecting \"good\" variable names. \n",
-    "\n",
-    "### Some \"not-so-good\" variable names\n",
-    "\n",
-    "To illustrate the point, consider a few not-so-good examples below."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "s = \"101533\""
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "or"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "sid = \"101533\""
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Any idea what these variables are for? Of course not, the variables ``s`` and ``sid`` are too short and cannot communicate what they should be used for in the code. You might think you know what they are for now, but imagine not looking at the code for a few months. Would you know then? What about if you share the code with a friend? Would they know? Probably not.\n",
-    "\n",
-    "Let's look at another example."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "finnishmeteorologicalinstituteobservationstationidentificationnumber = \"101533\""
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "OK, so now we have another issue. The variable name ``finnishmeteorologicalinstituteobservationstationidentificationnumber`` potentially provides more information about what the variable represents (the identification number of an FMI observation station), but it does so in a format that is not easy to read, nor something you're likely to want to type more than once. The previous example was too short, and now we have a variable name that is too long (and hard to read as a result)."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Selecting \"good\" variable names\n",
-    "\n",
-    "A good variable name should:\n",
-    "\n",
-    "1. Be clear and concise. \n",
-    "\n",
-    "2. Be written in English. A general coding practice is to write code with variable names in English, as that is the most likely common language between programmers. Thus, variable names such as ``muuttuja`` (which is also not a good name on other levels) should be avoided.\n",
-    "\n",
-    "3. Not contain special characters. Python supports use of special characters by way of various encoding options that can be given in a program. That said, it is better to avoid variables such as ``lämpötila`` because encoding issues can arise in some cases. Better to stick to the [standard printable ASCII character set](https://en.wikipedia.org/wiki/ASCII#Printable_characters) to be safe.\n",
-    "\n",
-    "4. Not conflict with any [Python keywords](https://www.pythonforbeginners.com/basics/keywords-in-python), such as ``for``, ``True``, ``False``, ``and``, ``if``, or ``else``. These are reserved for speical operations in Python and cannot be used as variable names.\n",
-    "\n",
-    "With this in mind, let's now look at a few better options for variable names."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Formatting \"good\" variable names\n",
-    "\n",
-    "There are several possibilities for \"good\" variable name formats, of which we'll consider two:\n",
-    "\n",
-    "1. *pothole_case_naming* uses lowercase words separated by underscores ``_``. This is our suggested format as the underscores make it easy to read the variable, and don't add too much to the length of the variable name. As an example, consider the variable ``temp_celsius``. In the context of the examples above, we might rename our variable ``fmi_station_id``, which conveys all of the essential information we need, while remaining easy to read.\n",
-    "\n",
-    "2. *camelCase* or *CamelCase* uses capitalization of the first letter of words in a variable name to make it easier to read. In some cases the first letter of the variable may be capitalized. The variable ``tempFahrenheit`` was one example of camelCase. Again, if we consider the examples from the previous section, we might consider the variable name ``fmiStationID`` or simply ``stationID`` if we elect to use camelCase.\n",
-    "\n",
-    "As mentioned in point 1, pothole_case_naming is preferred, mostly because we feel it is the easiest to read and seems to be most common amongst Python programmers. We are happy with you using either option, as long as you are consistent in the use. It might take an extra second of thought, but could make a big difference in the ease of use of your programs!"
-   ]
   }
  ],
  "metadata": {
@@ -833,7 +748,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.3"
+   "version": "3.7.4"
   }
  },
  "nbformat": 4,