Merge pull request #350 from dstndstn/typo-fixes

Minor fixes: typos, grammar, formatting, minor clarifications

Author: valentina-s

_episodes/01-numpy.md

@@ -19,9 +19,9 @@ keypoints:
 - "Variables are created on demand whenever a value is assigned to them."
 - "Use `print(something)` to display the value of `something`."
 - "The expression `array.shape` gives the shape of an array."
-- "Use `array[x, y]` to select a single element from an array."
+- "Use `array[x, y]` to select a single element from a 2D array."
 - "Array indices start at 0, not 1."
-- "Use `low:high` to specify a slice that includes the indices from `low` to `high-1`."
+- "Use `low:high` to specify a `slice` that includes the indices from `low` to `high-1`."
 - "All the indexing and slicing that works on arrays also works on strings."
 - "Use `# some kind of explanation` to add comments to programs."
 - "Use `numpy.mean(array)`, `numpy.max(array)`, and `numpy.min(array)` to calculate simple statistics."
@@ -30,6 +30,7 @@ keypoints:
 ---
 In this lesson we will learn how to manipulate the inflammation dataset with Python. But before we discuss how to deal with many data points, we will show how to store a single value on the computer.
 
+
 The line below [assigns](reference.html#assignment) the value `55` to a [variable](reference.html#variable) `weight_kg`:
 
 ~~~
@@ -169,7 +170,7 @@ Importing a library is like getting a piece of lab equipment out of a storage lo
 Libraries provide additional functionality to the basic Python package,
 much like a new piece of equipment adds functionality to a lab space. Just like in the lab, importing too many libraries
 can sometimes complicate and slow down your programs - so we only import what we need for each program. 
-Once you've imported the library,
+Once we've imported the library,
 we can ask the library to read our data file for us:
 
 ~~~
@@ -308,7 +309,7 @@ because they have the same part-and-whole relationship.
 
 If we want to get a single number from the array,
 we must provide an [index]({{ page.root }}/reference/#index) in square brackets,
-just as we do in math:
+just as we do in math when referring to an element of a matrix.  Our inflammation data has two dimensions, so we will need to use two indices to refer to a value:
 
 ~~~
 print('first value in data:', data[0, 0])
@@ -558,7 +559,7 @@ standard deviation: 4.61383319712
 >
 > How did we know what functions NumPy has and how to use them?
 > If you are working in the IPython/Jupyter Notebook there is an easy way to find out.
-> If you type the name of something with a full-stop then you can use tab completion
+> If you type the name of something followed by a dot, then you can use tab completion
 > (e.g. type `numpy.` and then press tab)
 > to see a list of all functions and attributes that you can use. After selecting one you
 > can also add a question mark (e.g. `numpy.cumprod?`) and IPython will return an
@@ -573,7 +574,7 @@ One way to do this is to create a new temporary array of the data we want,
 then ask it to do the calculation:
 
 ~~~
-patient_0 = data[0, :] # 0 on the first axis, everything on the second
+patient_0 = data[0, :] # 0 on the first axis (rows), everything on the second (columns)
 print('maximum inflammation for patient 0:', patient_0.max())
 ~~~
 {: .python}
@@ -584,7 +585,7 @@ maximum inflammation for patient 0: 18.0
 {: .output}
 
 Everything in a line of code following the '#' symbol is a
-[comment]({{ page.root }}/reference/#comment) that is ignored by the computer.
+[comment]({{ page.root }}/reference/#comment) that is ignored by Python.
 Comments allow programmers to leave explanatory notes for other
 programmers or their future selves.
 

_episodes/02-loop.md

@@ -5,13 +5,13 @@ exercises: 0
 questions:
 - "How can I do the same operations on many different values?"
 objectives:
-- "Explain what a for loop does."
-- "Correctly write for loops to repeat simple calculations."
+- "Explain what a `for` loop does."
+- "Correctly write `for` loops to repeat simple calculations."
 - "Trace changes to a loop variable as the loop runs."
-- "Trace changes to other variables as they are updated by a for loop."
+- "Trace changes to other variables as they are updated by a `for` loop."
 keypoints:
 - "Use `for variable in sequence` to process the elements of a sequence one at a time."
-- "The body of a for loop must be indented."
+- "The body of a `for` loop must be indented."
 - "Use `len(thing)` to determine the length of something that contains other values."
 ---
 
@@ -34,7 +34,7 @@ word = 'lead'
 {: .python}
 
 We can access a character in a string using its index. For example, we can get the first
-character of the word 'lead', by using word[0]. One way to print each character is to use
+character of the word `'lead'`, by using `word[0]`. One way to print each character is to use
 four `print` statements:
 
 ~~~
@@ -151,18 +151,13 @@ The numbers in the diagram denote which loop cycle the character was printed in
 We can call the [loop variable]({{ page.root }}/reference/#loop-variable) anything we like,
 but there must be a colon at the end of the line starting the loop,
 and we must indent anything we want to run inside the loop. Unlike many other languages, there is no
-command to signify the end of the loop body (e.g. end for); what is indented after the for statement belongs to the loop.
+command to signify the end of the loop body (e.g. `end for`); what is indented after the `for` statement belongs to the loop.
 
 
-> ## What's in a name?
+> ## What's in a name?{.callout}
 >
-> In the example above, the loop variable was given the name `char`
-> as a mnemonic; it is short for 'character'.
-> 'Char' is not a keyword in Python that pulls the characters
-> from words or strings.
-> In fact when a similar loop is run over a list rather than a word,
-> the output would be each member of that list printed in order,
-> rather than the characters.
+>
+> In the example above, the loop variable was given the name `char` as a mnemonic; it is short for 'character'. 'Char' is not a keyword in Python that pulls the characters from words or strings. In fact when a similar loop is run over a list rather than a word, the output would be each member of that list printed in order, rather than the characters.
 >
 > ~~~
 > elements = ['oxygen', 'nitrogen', 'argon']
@@ -178,10 +173,7 @@ command to signify the end of the loop body (e.g. end for); what is indented aft
 > ~~~
 > {: .output}
 >
-> We can choose any name we want for variables.
-> We might just as easily have chosen the name `banana`
-> for the loop variable,
-> as long as we use the same name when we invoke the variable inside the loop:
+> We can choose any name we want for variables. We might just as easily have chosen the name `banana` for the loop variable, as long as we use the same name when we invoke the variable inside the loop:
 >
 > ~~~
 > word = 'oxygen'
@@ -200,9 +192,7 @@ command to signify the end of the loop body (e.g. end for); what is indented aft
 > ~~~
 > {: .output}
 >
-> It is a good idea to choose variable names
-> that are meaningful so that it is easier
-> to understand what the loop is doing.
+> It is a good idea to choose variable names that are meaningful, otherwise it would be more difficult to understand what the loop is doing.
 {: .callout}
 
 Here's another loop that repeatedly updates a variable:
@@ -278,14 +268,19 @@ so we should always use it when we can.
 
 > ## From 1 to N
 >
-> Python has a built-in function called `range` that creates a sequence of numbers. Range can
-> accept 1-3 parameters. If one parameter is input, range creates an array of that length,
-> starting at zero and incrementing by 1. If 2 parameters are input, range starts at
-> the first and ends just before the second, incrementing by one. If range is passed 3 parameters,
-> it starts at the first one, ends just before the second one, and increments by the third one. For
-> example,
-> `range(3)` produces the numbers 0, 1, 2, while `range(2, 5)` produces 2, 3, 4,
-> and `range(3, 10, 3)` produces 3, 6, 9.
+> Python has a built-in function called `range` that creates a sequence of numbers. `range` can
+> accept 1, 2, or 3 parameters.
+>
+> * If one parameter is given, `range` creates an array of that length,
+>   starting at zero and incrementing by 1.
+>   For example, `range(3)` produces the numbers `0, 1, 2`.
+> * If two parameters are given, `range` starts at
+>   the first and ends just before the second, incrementing by one.
+>   For example, `range(2, 5)` produces `2, 3, 4`.
+> * If `range` is given 3 parameters,
+>   it starts at the first one, ends just before the second one, and increments by the third one.
+>   For exmaple `range(3, 10, 2)` produces `3, 5, 7, 9`.
+>
 > Using `range`,
 > write a loop that uses `range` to print the first 3 natural numbers:
 >

_episodes/04-files.md

@@ -5,8 +5,8 @@ exercises: 0
 questions:
 - "How can I do the same operations on many different files?"
 objectives:
-- "Use a library function to get a list of filenames that match a simple wildcard pattern."
-- "Write a for loop to process multiple files."
+- "Use a library function to get a list of filenames that match a wildcard pattern."
+- "Write a `for` loop to process multiple files."
 keypoints:
 - "Use `glob.glob(pattern)` to create a list of files whose names match a pattern."
 - "Use `*` in a pattern to match zero or more characters, and `?` to match any single character."
@@ -141,6 +141,7 @@ where the maxima are a bit less regular, but the minima are consistently zero.
 > composite_data = numpy.zeros((60,40))
 > for f in filenames:
 >     # sum each new file's data into as it's read
+>     #
 > # and then divide the composite_data by number of samples
 > composite_data /= len(filenames)
 > ~~~

_episodes/05-cond.md

@@ -11,8 +11,8 @@ keypoints:
 - "Use `if condition` to start a conditional statement, `elif condition` to provide additional tests, and `else` to provide a default."
 - "The bodies of the branches of conditional statements must be indented."
 - "Use `==` to test for equality."
-- "`X and Y` is only true if both X and Y are true."
-- "`X or Y` is true if either X or Y, or both, are true."
+- "`X and Y` is only true if both `X` and `Y` are true."
+- "`X or Y` is true if either `X` or `Y`, or both, are true."
 - "Zero, the empty string, and the empty list are considered false; all other numbers, strings, and lists are considered true."
 - "Nest loops to operate on multi-dimensional data."
 - "Put code whose parameters change frequently in a function, then call it with different parameter values to customize its behavior."
@@ -199,13 +199,7 @@ freeing us from having to manually examine every plot for features we've seen be
 
 > ## How Many Paths?
 >
-> Which of the following would be printed if you were to run this code?
-> Why did you pick this answer?
->
-> 1.  A
-> 2.  B
-> 3.  C
-> 4.  B and C
+> Consider this code:
 >
 > ~~~
 > if 4 > 5:
@@ -217,6 +211,14 @@ freeing us from having to manually examine every plot for features we've seen be
 > ~~~
 > {: .python}
 >
+> Which of the following would be printed if you were to run this code?
+> Why did you pick this answer?
+>
+> 1.  A
+> 2.  B
+> 3.  C
+> 4.  B and C
+>
 > > ## Solution
 > > C gets printed because the first two conditions, `4 > 5` and `4 == 5`, are not true,
 > > but `4 < 5` is true.
@@ -339,7 +341,7 @@ freeing us from having to manually examine every plot for features we've seen be
 > >
 > > Here `pass` means "don't do anything".
 > In this particular case, it's not actually needed, since if `num == 0` neither
-> > sum needs to change, but it illustrates the use of `elif`.
+> > sum needs to change, but it illustrates the use of `elif` and `pass`.
 > {: .solution}
 {: .challenge}
 

_episodes/06-func.md

@@ -39,7 +39,7 @@ on a different dataset or at a different point in our program?
 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' -
+and Python provides for this by letting us define things called 'functions' ---
 a shorthand way of re-executing longer pieces of code.
 
 Let's start by defining a function `fahr_to_kelvin` that converts temperatures from Fahrenheit to Kelvin:
@@ -720,10 +720,10 @@ numpy.loadtxt('inflammation-01.csv', ',')
 
 then the filename is assigned to `fname` (which is what we want),
 but the delimiter string `','` is assigned to `dtype` rather than `delimiter`,
-because `dtype` is the second parameter in the list. However ',' isn't a known `dtype` so
+because `dtype` is the second parameter in the list. However `','` isn't a known `dtype` so
 our code produced an error message when we tried to run it.
 When we call `loadtxt` we don't have to provide `fname=` for the filename because it's the
-first item in the list, but if we want the ',' to be assigned to the variable `delimiter`,
+first item in the list, but if we want the `','` to be assigned to the variable `delimiter`,
 we *do* have to provide `delimiter=` for the second parameter since `delimiter` is not
 the second parameter in the list.
 
@@ -831,8 +831,8 @@ readable code!
 >
 > Write a function `rescale` that takes an array as input
 > and returns a corresponding array of values scaled to lie in the range 0.0 to 1.0.
-> (Hint: If $L$ and $H$ are the lowest and highest values in the original array,
-> then the replacement for a value $v$ should be $(v-L) / (H-L)$.)
+> (Hint: If `L` and `H` are the lowest and highest values in the original array,
+> then the replacement for a value `v` should be `(v-L) / (H-L)`.)
 >
 > > ## Solution
 > > ~~~
@@ -873,7 +873,7 @@ readable code!
 
 > ## Defining Defaults
 >
-> Rewrite the `rescale` function so that it scales data to lie between 0.0 and 1.0 by default,
+> Rewrite the `rescale` function so that it scales data to lie between `0.0` and `1.0` by default,
 > but will allow the caller to specify lower and upper bounds if they want.
 > Compare your implementation to your neighbor's:
 > do the two functions always behave the same way?
@@ -894,7 +894,7 @@ readable code!
 
 > ## Variables Inside and Outside Functions
 >
-> What does the following piece of code display when run - and why?
+> What does the following piece of code display when run --- and why?
 >
 > ~~~
 > f = 0
@@ -976,12 +976,7 @@ readable code!
 
 > ## The Old Switcheroo
 >
-> Which of the following would be printed if you were to run this code? Why did you pick this answer?
->
-> 1. `7 3`
-> 2. `3 7`
-> 3. `3 3`
-> 4. `7 7`
+> Consider this code:
 >
 > ~~~
 > a = 3
@@ -997,6 +992,14 @@ readable code!
 > print(a, b)
 > ~~~
 > {: .python}
+>
+> Which of the following would be printed if you were to run this code? Why did you pick this answer?
+>
+> 1. `7 3`
+> 2. `3 7`
+> 3. `3 3`
+> 4. `7 7`
+>
 > > ## Solution
 > > `3, 7` is correct. Initially `a` has a value of 3 and `b` has a value of 7.
 > > When the swap function is called, it creates local variables (also called

_episodes/07-errors.md

@@ -239,7 +239,7 @@ Variable name errors come with some of the most informative error messages,
 which are usually of the form "name 'the_variable_name' is not defined".
 
 Why does this error message occur?
-That's harder question to answer,
+That's a harder question to answer,
 because it depends on what your code is supposed to do.
 However,
 there are a few very common reasons why you might have an undefined variable.

_episodes/09-debugging.md

@@ -151,7 +151,7 @@ Replacing random chunks of code is unlikely to do much good.
 if you got it wrong the first time,
 you'll probably get it wrong the second and third as well.)
 Good programmers therefore
-*change one thing at a time, for a reason*
+*change one thing at a time, for a reason*.
 They are either trying to gather more information
 ("is the bug still there if we change the order of the loops?")
 or test a fix

_episodes/10-cmdline.md

@@ -585,7 +585,7 @@ $ python count_stdin.py small-01.csv
 ~~~
 {: .bash}
 
-i.e., to forget the `<` character that redirect the file to standard input.
+i.e., to forget the `<` character that redirects the file to standard input.
 In this case,
 there's nothing in standard input,
 so the program waits at the start of the loop for someone to type something on the keyboard.
@@ -985,7 +985,7 @@ the program now does everything we set out to do.
 >
 > Write a program called `check_arguments.py` that prints usage
 > then exits the program if no arguments are provided.
-> (Hint) You can use `sys.exit()` to exit the program.
+> (Hint: You can use `sys.exit()` to exit the program.)
 >
 > ~~~
 > $ python check_arguments.py