Merge branch 'gh-pages' into henryiii/fix/anumpy

Author: noatgnu

.github/workflows/template.yml

@@ -127,13 +127,14 @@ jobs:
         id: check-rmd
         working-directory: lesson
         run: |
-          echo "::set-output name=count::$(shopt -s nullglob; files=($(find . -iname '*.Rmd')); echo ${#files[@]})"
+          echo "count=$(shopt -s nullglob; files=($(find . -iname '*.Rmd')); echo ${#files[@]})" >> $GITHUB_OUTPUT
 
       - name: Set up R
         if: steps.check-rmd.outputs.count != 0
-        uses: r-lib/actions/setup-r@master
+        uses: r-lib/actions/setup-r@v2
         with:
-          r-version: 'release'
+          use-public-rspm: true
+          install-r: false
 
       - name: Install needed packages
         if: steps.check-rmd.outputs.count != 0

.github/workflows/website.yml

@@ -44,13 +44,14 @@ jobs:
       - name: Look for R-markdown files
         id: check-rmd
         run: |
-          echo "::set-output name=count::$(shopt -s nullglob; files=($(find . -iname '*.Rmd')); echo ${#files[@]})"
+          echo "count=$(shopt -s nullglob; files=($(find . -iname '*.Rmd')); echo ${#files[@]})" >> $GITHUB_OUTPUT
 
       - name: Set up R
         if: steps.check-rmd.outputs.count != 0
-        uses: r-lib/actions/setup-r@master
+        uses: r-lib/actions/setup-r@v2
         with:
-          r-version: 'release'
+          use-public-rspm: true
+          install-r: false
 
       - name: Restore R Cache
         if: steps.check-rmd.outputs.count != 0

_episodes/01-intro.md

@@ -14,7 +14,9 @@ keypoints:
 - "Use `variable = value` to assign a value to a variable in order to record it in memory."
 - "Variables are created on demand whenever a value is assigned to them."
 - "Use `print(something)` to display the value of `something`."
+- "Use `# some kind of explanation` to add comments to programs."
 - "Built-in functions are always available to use."
+
 ---
 
 ## Variables
@@ -42,7 +44,7 @@ weight_kg = 60
 {: .language-python}
 
 From now on, whenever we use `weight_kg`, Python will substitute the value we assigned to
-it. In layman's terms, **a variable is a name for a value**.
+it. In layperson's terms, **a variable is a name for a value**.
 
 In Python, variable names:
 
@@ -209,8 +211,12 @@ weight in kilograms is now: 65.0
 > ~~~
 > {: .output}
 >
-> ![Value of 65.0 with weight_kg label stuck on it, and value of 143.0 with weight_lb label
-stuck on it](../fig/python-sticky-note-variables-02.svg)
+> Everything in a line of code following the '#' symbol is a
+> [comment]({{ page.root }}/reference/#comment) that is ignored by Python.
+> Comments allow programmers to leave explanatory notes for other
+> programmers or their future selves.
+> 
+> ![Value of 65.0 with weight_kg label stuck on it, and value of 143.0 with weight_lb label stuck on it](../fig/python-sticky-note-variables-02.svg)
 >
 > Similar to above, the expression `2.2 * weight_kg` is evaluated to `143.0`,
 > and then this value is assigned to the variable `weight_lb` (i.e. the sticky

_episodes/02-numpy.md

@@ -32,7 +32,7 @@ that can be called upon when needed.
 
 To begin processing the clinical trial inflammation data, we need to load it into Python.
 We can do that using a library called
-[NumPy](http://docs.scipy.org/doc/numpy/ "NumPy Documentation"), which stands for Numerical Python.
+[NumPy](https://numpy.org/doc/stable "NumPy Documentation"), which stands for Numerical Python.
 In general, you should use this library when you want to do fancy things with lots of numbers,
 especially if you have matrices or arrays. To tell Python that we'd like to start using NumPy,
 we need to [import]({{ page.root }}/reference.html#import) it:
@@ -70,9 +70,8 @@ The expression `numpy.loadtxt(...)` is a
 [function call]({{ page.root }}/reference.html#function-call)
 that asks Python to run the [function]({{ page.root }}/reference.html#function) `loadtxt` which
 belongs to the `numpy` library.
-This [dotted notation]({{ page.root }}/reference.html#dotted-notation)
-is used everywhere in Python: the thing that appears before the dot contains the thing that
-appears after.
+The dot notation in Python is used most of all as an object attribute/property specifier or for invoking its method. `object.property` will give you the object.property value,
+`object_name.method()` will invoke on object_name method.
 
 As an example, John Smith is the John that belongs to the Smith family.
 We could use the dot notation to write his name `smith.john`,
@@ -205,16 +204,16 @@ first value in data: 0.0
 {: .output}
 
 ~~~
-print('middle value in data:', data[30, 20])
+print('middle value in data:', data[29, 19])
 ~~~
 {: .language-python}
 
 ~~~
-middle value in data: 13.0
+middle value in data: 16.0
 ~~~
 {: .output}
 
-The expression `data[30, 20]` accesses the element at row 30, column 20. While this expression may
+The expression `data[29, 19]` accesses the element at row 30, column 20. While this expression may
 not surprise you,
  `data[0, 0]` might.
 Programming languages like Fortran, MATLAB and R start counting at 1
@@ -411,11 +410,6 @@ maximum inflammation for patient 0: 18.0
 ~~~
 {: .output}
 
-Everything in a line of code following the '#' symbol is a
-[comment]({{ page.root }}/reference.html#comment) that is ignored by Python.
-Comments allow programmers to leave explanatory notes for other
-programmers or their future selves.
-
 We don't actually need to store the row in a variable of its own.
 Instead, we can combine the selection and the function call:
 

_episodes/04-lists.md

@@ -166,57 +166,80 @@ does not.
 > ## Nested Lists
 > Since a list can contain any Python variables, it can even contain other lists.
 >
-> For example, we could represent the products in the shelves of a small grocery shop:
+> For example, you could represent the products on the shelves of a small grocery shop
+> as a nested list called `veg`:
+>
+> ![`veg` is represented as a shelf full of produce. There are three rows of vegetables
+> on the shelf, and each row contains three baskets of vegetables. We can label
+> each basket according to the type of vegetable it contains, so the top row
+> contains (from left to right) lettuce, lettuce, and peppers.](../fig/04_groceries_veg.png)
+>
+> To store the contents of the shelf in a nested list, you write it this way:
 >
 > ~~~
-> x = [['pepper', 'zucchini', 'onion'],
->      ['cabbage', 'lettuce', 'garlic'],
->      ['apple', 'pear', 'banana']]
+> veg = [['lettuce', 'lettuce', 'peppers', 'zucchini'],
+>      ['lettuce', 'lettuce', 'peppers', 'zucchini'],
+>      ['lettuce', 'cilantro', 'peppers', 'zucchini']]
 > ~~~
 > {: .language-python}
 >
-> Here is a visual example of how indexing a list of lists `x` works:
+> Here are some visual examples of how indexing a list of lists `veg` works. First,
+> you can reference each row on the shelf as a separate list. For example, `veg[2]`
+> represents the bottom row, which is a list of the baskets in that row.
 >
-> [![x is represented as a pepper shaker containing several packets of pepper. [x[0]] is represented
-> as a pepper shaker containing a single packet of pepper. x[0] is represented as a single packet of
-> pepper. x[0][0] is represented as single grain of pepper.  Adapted
-> from @hadleywickham.](../fig/indexing_lists_python.png)][hadleywickham-tweet]
+> ![`veg` is now shown as a list of three rows, with `veg[0]` representing the top row of
+> three baskets, `veg[1]` representing the second row, and `veg[2]` representing the bottom row.](../fig/04_groceries_veg0.png)
 >
-> Using the previously declared list `x`, these would be the results of the
-> index operations shown in the image:
+> Index operations using the image would work like this:
 >
 > ~~~
-> print([x[0]])
+> print(veg[2])
 > ~~~
 > {: .language-python}
 >
 > ~~~
-> [['pepper', 'zucchini', 'onion']]
+> ['lettuce', 'cilantro', 'peppers', 'zucchini']
 > ~~~
 > {: .output}
 >
 > ~~~
-> print(x[0])
+> print(veg[0])
 > ~~~
 > {: .language-python}
 >
 > ~~~
-> ['pepper', 'zucchini', 'onion']
+> ['lettuce', 'lettuce', 'peppers', 'zucchini']
 > ~~~
 > {: .output}
 >
+> To reference a specific basket on a specific shelf, you use two indexes. The first
+> index represents the row (from top to bottom) and the second index represents
+> the specific basket (from left to right).
+> ![`veg` is now shown as a two-dimensional grid, with each basket labeled according to
+> its index in the nested list. The first index is the row number and the second
+> index is the basket number, so `veg[1][3]` represents the basket on the far right
+> side of the second row (basket 4 on row 2): zucchini](../fig/04_groceries_veg00.png)
+>
 > ~~~
-> print(x[0][0])
+> print(veg[0][0])
 > ~~~
 > {: .language-python}
 >
 > ~~~
-> 'pepper'
+> 'lettuce'
+> ~~~
+> {: .output}
+>
+> ~~~
+> print(veg[1][2])
+> ~~~
+> {: .language-python}
+>
+> ~~~
+> 'peppers'
 > ~~~
 > {: .output}
 >
-> Thanks to [Hadley Wickham][hadleywickham-tweet]
-> for the image above.
 {: .callout}
 
 > ## Heterogeneous Lists
@@ -273,7 +296,7 @@ copy it and then modify this list, we can cause all sorts of trouble. This also
 the list using the above functions:
 
 ~~~
-odds = [1, 3, 5, 7]
+odds = [3, 5, 7]
 primes = odds
 primes.append(2)
 print('primes:', primes)
@@ -282,8 +305,8 @@ print('odds:', odds)
 {: .language-python}
 
 ~~~
-primes: [1, 3, 5, 7, 2]
-odds: [1, 3, 5, 7, 2]
+primes: [3, 5, 7, 2]
+odds: [3, 5, 7, 2]
 ~~~
 {: .output}
 
@@ -292,7 +315,7 @@ same list. If all we want to do is copy a (simple) list, we can again use the `l
 do not modify a list we did not mean to:
 
 ~~~
-odds = [1, 3, 5, 7]
+odds = [3, 5, 7]
 primes = list(odds)
 primes.append(2)
 print('primes:', primes)
@@ -301,8 +324,8 @@ print('odds:', odds)
 {: .language-python}
 
 ~~~
-primes: [1, 3, 5, 7, 2]
-odds: [1, 3, 5, 7]
+primes: [3, 5, 7, 2]
+odds: [3, 5, 7]
 ~~~
 {: .output}
 

_episodes/05-loop.md

@@ -307,8 +307,8 @@ so we should always use it when we can.
 > Given the following loop:
 > ~~~
 > word = 'oxygen'
-> for char in word:
->     print(char)
+> for letter in word:
+>     print(letter)
 > ~~~
 > {: .language-python}
 >

_episodes/07-cond.md

@@ -268,6 +268,14 @@ freeing us from having to manually examine every plot for features we've seen be
 > > ## Solution
 > > C gets printed because the first two conditions, `4 > 5` and `4 == 5`, are not true,
 > > but `4 < 5` is true.
+> > In this case only one of these conditions can be true for at a time, but in other 
+> > scenarios multiple `elif` conditions could be met. In these scenarios only the action
+> > associated with the first true `elif` condition will occur, starting from the top of the 
+> > conditional section. 
+> > ![A flowchart diagram of a conditional section with multiple `elif` conditions and some possible outcomes.](../fig/python-else-if.png)
+> > This contrasts with the case of multiple `if` statements, where every action can occur
+> > as long as their condition is met.
+> > ![A flowchart diagram of a conditional section with multiple `if` statements and some possible outcomes.](../fig/python-multi-if.png)
 > {: .solution}
 {: .challenge}
 

_episodes/08-func.md

@@ -31,26 +31,45 @@ keypoints:
    then call it with different parameter values to customize its behavior."
 ---
 
-At this point,
-we've written code to draw some interesting features in our inflammation data,
-loop over all our data files to quickly draw these plots for each of them,
-and have Python make decisions based on what it sees in our data.
-But, our code is getting pretty long and complicated;
-what if we had thousands of datasets,
-and didn't want to generate a figure for every single one?
-Commenting out the figure-drawing code is a nuisance.
-Also, what if we want to use that code again,
-on a different dataset or at a different point in our program?
+At this point, we've seen that code can have Python make decisions about what it sees in our data. What if we want to convert some of our data, like taking a temperature in Fahrenheit and converting it to Celsius. We could write something like this for converting a single number 
+
+~~~
+fahrenheit_val = 99
+celsius_val = ((fahrenheit_val - 32) * (5/9))
+~~~
+{: .language-python}
+
+and for a second number we could just copy the line and rename the variables
+
+~~~
+fahrenheit_val = 99
+celsius_val = ((fahrenheit_val - 32) * (5/9))
+
+fahrenheit_val2 = 43
+celsius_val2 = ((fahrenheit_val2 - 32) * (5/9))
+~~~
+{: .language-python}
+
+But we would be in trouble as soon as we had to do this more than a couple times. 
 Cutting and pasting it is going to make our code get very long and very repetitive,
 very quickly.
 We'd like a way to package our code so that it is easier to reuse,
-and Python provides for this by letting us define things called 'functions' ---
-a shorthand way of re-executing longer pieces of code.
+a shorthand way of re-executing longer pieces of code. In Python we can use 'functions'.
 Let's start by defining a function `fahr_to_celsius` that converts temperatures
 from Fahrenheit to Celsius:
 
 ~~~
+def explicit_fahr_to_celsius(temp):
+    # Assign the converted value to a variable
+    converted = ((temp - 32) * (5/9))
+    # Return the value of the new variable
+    return converted
+    
 def fahr_to_celsius(temp):
+    # Return converted value more efficiently using the return
+    # function without creating a new variable. This code does
+    # the same thing as the previous function but it is more explicit
+    # in explaining how the return command works.
     return ((temp - 32) * (5/9))
 ~~~
 {: .language-python}
@@ -897,7 +916,7 @@ readable code!
 > > and does not alter `k` outside of its local copy. 
 > > Therefore the original value of `k` remains unchanged.
 > > Beware that a local `k` is created because `f2k` internal statements
-> > *affect* a new value to it. If `k` was only `read`, it would simply retreive the
+> > *affect* a new value to it. If `k` was only `read`, it would simply retrieve the
 > > global `k` value.
 > {: .solution}
 {: .challenge}