confluence
diff --git a/‎python_notes/Classes.rst‎
Lines changed: 2 additions & 2 deletions b/‎python_notes/Classes.rst‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎python_notes/Errors_and_Exceptions.rst‎
Lines changed: 4 additions & 4 deletions b/‎python_notes/Errors_and_Exceptions.rst‎
Lines changed: 4 additions & 4 deletions
diff --git a/‎python_notes/Functions.rst‎
Lines changed: 2 additions & 2 deletions b/‎python_notes/Functions.rst‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎python_notes/Loop_Control_Statements.rst‎
Lines changed: 1 addition & 1 deletion b/‎python_notes/Loop_Control_Statements.rst‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎python_notes/Python_Basics.rst‎
Lines changed: 7 additions & 7 deletions b/‎python_notes/Python_Basics.rst‎
Lines changed: 7 additions & 7 deletions
diff --git a/‎python_notes/Selection_Control_Statements.rst‎
Lines changed: 1 addition & 1 deletion b/‎python_notes/Selection_Control_Statements.rst‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎python_notes/Sorting_and_Searching_Algorithms.rst‎
Lines changed: 3 additions & 3 deletions b/‎python_notes/Sorting_and_Searching_Algorithms.rst‎
Lines changed: 3 additions & 3 deletions
diff --git a/‎python_notes/Variables_and_Scope.rst‎
Lines changed: 2 additions & 2 deletions b/‎python_notes/Variables_and_Scope.rst‎
Lines changed: 2 additions & 2 deletions
@@ -60,11 +60,11 @@ Here is an example of a simple custom class which stores information about a per
 
 We start the class definition with the ``class`` keyword, followed by the class name and a colon.  We would list any parent classes in between round brackets before the colon, but this class doesn't have any, so we can leave them out.
 
-Inside the class body, we define two functions -- these are our objects's methods.  The first is called ``__init__``, which is a special method.  When we call the class object, a new instance of the class is created, and the ``__init__`` method on this new object is immediately executed with all the parameters that we passed to the class object.  The purpose of this method is thus to set up a new object using data that we have provided.
+Inside the class body, we define two functions -- these are our object's methods.  The first is called ``__init__``, which is a special method.  When we call the class object, a new instance of the class is created, and the ``__init__`` method on this new object is immediately executed with all the parameters that we passed to the class object.  The purpose of this method is thus to set up a new object using data that we have provided.
 
 The second method is a custom method which calculates the age of our person using the birthdate and the current date.
 
-.. Note:: ``__init__`` is sometimes called the object's *constructor*, because it is used similarly to the way that constructors are used in other languages, but that is not technically correct -- it's better to call it the *initializer*.  There is a different method called ``__new__`` which is more analogous to a constructor, but it is hardly ever used.
+.. Note:: ``__init__`` is sometimes called the object's *constructor*, because it is used similarly to the way that constructors are used in other languages, but that is not technically correct -- it's better to call it the *initialiser*.  There is a different method called ``__new__`` which is more analogous to a constructor, but it is hardly ever used.
 
 You may have noticed that both of these method definitions have ``self`` as the first parameter, and we use this variable inside the method bodies -- but we don't appear to pass this parameter in.  This is because whenever we call a method on an object, *the object itself* is automatically passed in as the first parameter.  This gives us a way to access the object's properties from inside the object's methods.
 
 
@@ -75,7 +75,7 @@ Sometimes there can be absolutely nothing wrong with your Python implementation
 
 * using the wrong variable name
 * indenting a block to the wrong level
-* using integer division instead of floating point division
+* using integer division instead of floating-point division
 * getting operator precedence wrong
 * making a mistake in a boolean expression
 * off-by-one, and other numerical errors
@@ -121,7 +121,7 @@ Handling exceptions
 
 Until now, the programs that we have written have generally ignored the fact that things can go wrong.  We have have tried to prevent runtime errors by checking data which may be incorrect before we used it, but we haven't yet seen how we can handle errors when they do occur -- our programs so far have just crashed suddenly whenever they have encountered one.
 
-There are some situations in which runtime errors are likely to occur.  Whenever we try to read a file or get input from a user, there is a chance that something unexpected will happen -- the file may have been moved or deleted, and the user may enter data which is not in the right format.  Good programmers should add safeguards to their programs so that common situations like this can be handled gracefully -- a program which crashes whenever it encounters an easily forseeable problem is not very pleasant to use.  Most users expect programs to be robust enough to recover from these kinds of setbacks.
+There are some situations in which runtime errors are likely to occur.  Whenever we try to read a file or get input from a user, there is a chance that something unexpected will happen -- the file may have been moved or deleted, and the user may enter data which is not in the right format.  Good programmers should add safeguards to their programs so that common situations like this can be handled gracefully -- a program which crashes whenever it encounters an easily foreseeable problem is not very pleasant to use.  Most users expect programs to be robust enough to recover from these kinds of setbacks.
 
 If we know that a particular section of our program is likely to cause an error, we can tell Python what to do if it does happen.  Instead of letting the error crash our program we can intercept it, do something about it, and allow the program to continue.
 
@@ -491,7 +491,7 @@ Answer to exercise 1
 
 #.
 
-    #. The values entered by the user may not be valid integers or floating point numbers.
+    #. The values entered by the user may not be valid integers or floating-point numbers.
     #. The user may enter zero for the divisor.
     #. If the ``math`` library hasn't been imported, ``math.round`` is undefined.
 
@@ -620,4 +620,4 @@ Answer to exercise 4
             logging.info("%s already has %d elements." % (listname, len(l)))
         finally:
             thedict[listname].append(element)
-            logging.info("Added %s to %s." % (element, listname))
+            logging.info("Added %s to %s." % (element, listname))
@@ -323,7 +323,7 @@ Remember that although we can execute a function *body* many times, a function *
 Exercise 4
 ----------
 
-#. Write a function called ``calculator``.  It should take the following parameters: two numbers, an arithmetic operation (which can be addition, subtraction, multiplication or division and is addition by default), and an output format (which can be integer or floating point, and is floating point by default).  Division should be floating point division.
+#. Write a function called ``calculator``.  It should take the following parameters: two numbers, an arithmetic operation (which can be addition, subtraction, multiplication or division and is addition by default), and an output format (which can be integer or floating point, and is floating point by default).  Division should be floating-point division.
 
    The function should perform the requested operation on the two input numbers, and return a result in the requested format (if the format is integer, the result should be rounded and not just truncated).  Raise exceptions as appropriate if any of the parameters passed to the function are invalid.
 
@@ -363,7 +363,7 @@ We can use ``*`` or ``**`` when we are *calling* a function to *unpack* a sequen
     my_dict = {"name": "Jane", "surname": "Doe"}
     print_kwargs(**my_dict)
 
-This makes it easier to build lists of parameters programatically.  Note that we can use this for *any* function, not just one which uses ``*args`` or ``**kwargs``::
+This makes it easier to build lists of parameters programmatically.  Note that we can use this for *any* function, not just one which uses ``*args`` or ``**kwargs``::
 
     my_dict = {
         "title": "Mr",
 
@@ -190,7 +190,7 @@ Exercise 2
 
 #. Write a program which finds the factorial of a given number. E.g. 3 factorial, or **3!** is equal to **3 x 2 x 1**; **5!** is equal to **5 x 4 x 3 x 2 x 1**, etc.. Your program should only contain a single loop.
 
-#. Write a program which prompts the user for 10 floating point numbers and calculates their sum, product and average. Your program should only contain a single loop.
+#. Write a program which prompts the user for 10 floating-point numbers and calculates their sum, product and average. Your program should only contain a single loop.
 
 #. Rewrite the previous program so that it has two loops -- one which collects and stores the numbers, and one which processes them.
 
 
@@ -655,7 +655,7 @@ results in an integer solution.
 
 .. Note:: In Python 2, the operator ``/`` performed integer division
           if both the dividend and the divisor were integers, and
-          floating point division if at least one of them was a float.
+          floating-point division if at least one of them was a float.
           In Python 3, ``/`` *always* performs floating-point division
           and ``//`` *always* performs integer division -- even if the
           dividend and divisor are floats!
@@ -739,7 +739,7 @@ Floating-point numbers
 Floating-point numbers (``float`` type) are numbers with a decimal
 point or an exponent (or both). Examples are ``5.0``, ``10.24``,
 ``0.0``, ``12.`` and ``.3``. We can use scientific notation to denote
-very large or very small floating point numbers, e.g. 3.8 x 10\
+very large or very small floating-point numbers, e.g. 3.8 x 10\
 :sup:`15`. The first part of the number, 3.8, is the mantissa and 15
 is the exponent. We can think of the exponent as the number of times
 we have to move the decimal point to the right to get to the actual
@@ -808,18 +808,18 @@ the order of precedence.
 
 .. Note::
 
-    Python floating-point numbers confirm to standardized format named
+    Python floating-point numbers conform to a standardised format named
     ``IEEE 754``. The standard represents each floating-point number
     using a small fixed amount of memory, so unlike Python's integers,
-    Python's floating point numbers have a limited range. The largest
+    Python's floating-point numbers have a limited range. The largest
     floating-point number that can be represented in Python is
     ``2**1023``.
 
 .. Note::
 
     Python includes three other types for dealing with numbers:
 
-    * ``complex`` (like floating-point but for complex numbers; try
+    * ``complex`` (like floating point but for complex numbers; try
       ``1+5j``)
     * ``Fraction`` (for rational numbers; available in the ``fractions``
       module)
@@ -836,9 +836,9 @@ Exercise 5
    ``1.0``, ``1.12e4``, ``-3.141759``, ``735``, ``0.57721566``,
    ``7.5e-3``
 
-#. What is the difference between integer and floating point division?
+#. What is the difference between integer and floating-point division?
    What is the operator used for integer division? What is the
-   operator used for floating point division?
+   operator used for floating-point division?
 
 #. What are the results of the following operations? Explain why:
    #. ``1.5 + 2``
 
@@ -465,7 +465,7 @@ The following code fragment will print out a message if the given age is less th
     if age < 0 or age > 120:
         print("Invalid age: %d" % age)
 
-The interpreter also performs a short-circuit evaluation for ``or`` expressions.  If it evaluates the first subexpression to be true, it will not bother to evaluate the second, because this is suffifent to determine that the whole expression is true.
+The interpreter also performs a short-circuit evaluation for ``or`` expressions.  If it evaluates the first subexpression to be true, it will not bother to evaluate the second, because this is sufficient to determine that the whole expression is true.
 
 The || operator is also binary::
 
 
@@ -12,7 +12,7 @@ likely to be many possible algorithms which can perform the same task.
 Are some of these algorithms in some sense better than others?
 Algorithm analysis is the study of this question.
 
-In this chapter we will analyze four algorithms; two for each of the
+In this chapter we will analyse four algorithms; two for each of the
 following common tasks:
 
 * *sorting*: ordering a list of values
@@ -511,14 +511,14 @@ Python's sorting algorithm
 Python's default sorting algorithm, which is used by the built-in
 ``sorted`` function as well as the ``sort`` method of list objects, is
 called *Timsort*.  It's an algorithm developed by Tim Peters in 2002 for
-use in Python. Timsort is a modifed version of merge sort which uses
+use in Python. Timsort is a modified version of merge sort which uses
 insertion sort to arrange the list of items into conveniently mergeable
 sections.
 
 .. Note::
 
    Tim Peters is also credited as the author of *The Zen of Python* --
-   an attempt to summarize the early Python community's ethos in a
+   an attempt to summarise the early Python community's ethos in a
    short series of koans. You can read it by typing ``import this``
    into the Python console.
 
 
@@ -283,7 +283,7 @@ Some Python libraries define common constants for our convenience, for example::
     # All the lowercase ASCII letters: 'abcdefghijklmnopqrstuvwxyz'
     print(string.ascii_lowercase)
 
-    # The mathematical constants pi and e, both floating point numbers
+    # The mathematical constants pi and e, both floating-point numbers
     print(math.pi) # ratio of circumference of a circle to its diameter
     print(math.e) # natural base of logarithms
 
@@ -405,7 +405,7 @@ Finally, we output the results::
 Exercise 2
 ----------
 
-#. Write a Python program to convert a temperature given in degrees Fahrenheit to its equivalent in degrees Celsius.  You can assume that **T_c = (5/9) x (T_f - 32)**, where **T_c** is the temperature in °C and **T_f** is the temperature in °F.  Your program should ask the user for an input value, and print the output.  The input and output values should be floating point numbers.
+#. Write a Python program to convert a temperature given in degrees Fahrenheit to its equivalent in degrees Celsius.  You can assume that **T_c = (5/9) x (T_f - 32)**, where **T_c** is the temperature in °C and **T_f** is the temperature in °F.  Your program should ask the user for an input value, and print the output.  The input and output values should be floating-point numbers.
 
 #. What could make this program crash? What would we need to do to handle this situation more gracefully?