fixed small typos

Author: tkoar

README.md

@@ -1,11 +1,11 @@
 
 # Introduction to lists
 
-So far we have worked with individual pieces of data like the string `hello`, then with variables we saw how to give this data a name.  Well, in this lesson, we'll see how we can group data together with lists.  
+So far, we have worked with individual pieces of data like the string `'hello'`. Then with variables we saw how to give this data a name.  Now in this lesson, we'll see how we can group data together with lists.  
 
 ### Creating a list 
 
-A list is our first form of a collection.  A collection is just a way of grouping data together, and lists certainly accomplish this.  For example, let's consider the top cities to travel to according to Travel and Leisure.  We'll see it below, but we must stay focused on Python and data! Here is how we are used to seeing a list of travel locations in a document or on a website.
+A list is our first form of a collection.  A collection is just a way of grouping data together, and lists certainly accomplish this.  For example, let's consider the top cities for travel according to the magazine Travel and Leisure. Here is how we are used to seeing a list of travel locations in a document or on a website.
 
 #### Travel Locations
 1. Solta
@@ -21,7 +21,7 @@ A list is our first form of a collection.  A collection is just a way of groupin
 11. Toronto
 12. Pyeongchang
 
-And here is how that same list looks in Python:
+Here is what that list looks like as a Python `list`:
 
 
 ```python
@@ -46,7 +46,7 @@ And here is how that same list looks in Python:
 
 
 
-So we indicate that we are initializing a `list` by placing a bracket, `[`, and end the list with a closing bracket `']'`.  To separate each list item, called an element, we place a comma.
+We indicate that we are initializing a `list` with an opening bracket, `[`, and we end the list with a closing bracket `]`. We separate each list item, also called an element, with a comma.
 
 
 ```python
@@ -71,7 +71,7 @@ So we indicate that we are initializing a `list` by placing a bracket, `[`, and
 
 
 
-And of course, we can set each list equal to variable so that we can name each list.
+We can, of course, declare variables and set them equal to our lists so that we can both name and later retrieve the list.
 
 
 ```python
@@ -108,13 +108,13 @@ countries_of_top_cities = ['Croatia', 'USA', 'Argentina', 'Mexico', 'USA', 'Moro
 
 ### Accessing Elements of Lists
 
-Now our `top_travel_cities` list contains multiple elements.  And just like we numbered the elements of a list with text:
+Now our `top_travel_cities` list contains multiple elements, and just like we are used to list elements having a rank or number associated with them...
 
 1. Solta
 2. Greenville
 3. Buenos Aires
 
-A list in Python also assigns a number to each element.
+...a list in Python also assigns a number to each element.
 
 
 ```python
@@ -151,9 +151,9 @@ top_travel_cities[0]
 
 
 
-In the above line we are referencing a list and then using the brackets to access specific elements of our list.  We access elements in a list with the `index`, and there is a separate index for each element in the list.  It begins at the number zero, increases for every element thereafter.
+In the above line we are referencing a list and then using the brackets to access a specific element of our list, the first element.  We access elements in a list with the `index`, and there is a separate index for each element in the list.  It begins at the number zero, increases for every element thereafter.
 
-So to access the second element we write `top_travel_cities[1]`, and the third element is `top_travel_cities[2]`:
+So to access the second element we write `top_travel_cities[1]`, and the third element is `top_travel_cities[2]`.
 
 
 ```python
@@ -167,7 +167,7 @@ top_travel_cities[2]
 
 
 
-How would we access the last element?  Well, we could count all of the elements in the list, and `Pyeongchang` would just be one less than that.  Or we can ask Python to start from the back in move back one.
+How would we access the last element?  Well, we could count all of the elements in the list, and `Pyeongchang` would just be one less than that. Or we can ask Python to start from the end and move back one:
 
 
 ```python
@@ -195,7 +195,7 @@ top_travel_cities[-2]
 
 
 
-Each element in our list is a string, so we can always set an element of our string equal to a variable.
+Each element in our list is a string, so, we can always set an element of our string equal to a variable.
 
 
 ```python
@@ -222,7 +222,7 @@ type(top_canadian_city)
 
 
 
-So now we have a variable of `top_canadian_city`, equal to the string 'toronto', and a variable of `top_travel_cities` equal to the list of cities.  
+Now we have a variable of `top_canadian_city`, equal to the string 'Toronto', and a variable of `top_travel_cities` equal to the list of cities.  
 
 
 ```python
@@ -261,7 +261,7 @@ type(top_travel_cities)
 
 ### Accessing Multiple Elements
 
-Now imagine that we don't want to access just one element of a list, but multiple elements at once.  Python allows us to do that as well.
+Now imagine that we don't want to access just one element of a list, but multiple elements at once.  Python allows us to do that as well:
 
 
 ```python
@@ -275,7 +275,7 @@ top_travel_cities[0:2]
 
 
 
-Ok, now to access elements of a list, inside of our brackets we are placing two numbers separated by a colon.  The first number indicates the index of the first element we want returned.  
+As we can see from the above example, we can access elements of a list by placing two numbers separated by a colon inside of our brackets. The first number indicates the index of the first element we want returned.  
 
 The second number could represent the number of elements we want returned back, or maybe it represents the stopping index of the elements that we are retrieving.  Looking at our `top_travel_cities` it could be either.
 
@@ -302,7 +302,7 @@ top_travel_cities
 
 
 
-So let's try a different experiment to answer our question.
+Let's try a different experiment to answer our question.
 
 
 ```python
@@ -316,7 +316,7 @@ top_travel_cities[4:5]
 
 
 
-Ok, so that second number is not representing the number of elements we want returned.  Instead it must be used to indicate the index of the first element not selected.  
+Ok, so that second number is not representing the number of elements we want returned.  Instead it must be the index at which we stop our selection of elements.
 
 
 ```python
@@ -330,7 +330,7 @@ top_travel_cities[4:6]
 
 
 
-This operation is called the `slice`.  So we can say we are `slicing` the elements with indices 4 and 5 in the line above.  Note that even though we are `slicing` elements, our list remains in tact.
+This operation is called `slice`.  So, we can say we are `slicing` the elements with indices 4 and 5 in the line above.  Note that even though we are `slicing` elements, our list remains intact.
 
 
 ```python
@@ -370,11 +370,11 @@ top_two
 
 
 
-So now we have another variable called `top_two` that points to an array which contains an array of elements equal to the first two elements of `top_travel_cities`.
+Now we have another variable called `top_two` that points to an array which contains an array of elements equal to the first two elements of `top_travel_cities`.
 
 ### Changing elements with destructive methods
 
-Now that we read and select certain elements from lists, let's work on changing these lists.  To add a new element to a list, we can use the `append` method.
+Now that we can read and select certain elements from lists, let's work on changing these lists. To add a new element to a list, we can use the `append` method.
 
 
 ```python
@@ -407,15 +407,35 @@ top_travel_cities
 
 
 
-You will see 'San Antonio' included in the list.  So note that unlike slice, `append` is destructive.  That is, it changes our underlying data structure.  Every time we execute the `append` method, another element is added to our list.   Now what if we accidentally add 'San Antonio' a second time to our list.
+You will see that 'San Antonio' has been added to the list.  Note that unlike slice, `append` is destructive.  That is, it changes our underlying data structure.  Every time we execute the `append` method, another element is added to our list.   Now what if we accidentally add 'San Antonio' a second time to our list.
 
 
 ```python
 top_travel_cities.append('San Antonio')
 top_travel_cities
 ```
 
-The `pop` method is available to call on any list, and removes the last element from the list.  As you can see below, calling `pop` removed our last element.
+
+
+
+    ['Solta',
+     'Greenville',
+     'Buenos Aires',
+     'Los Cabos',
+     'Walla Walla Valley',
+     'Marakesh',
+     'Albuquerque',
+     'Archipelago Sea',
+     'Iguazu Falls',
+     'Salina Island',
+     'Toronto',
+     'Pyeongchang',
+     'San Antonio',
+     'San Antonio']
+
+
+
+If you press shift+enter on the above line of code, we will have `'San Antonio'` as the last two elements of the list.  Luckily, we have the `pop` method to remove one of them.  The `pop` method is available to call on any list and removes the last element from the list. As you can see below, calling `pop` removed our last element.
 
 
 ```python
@@ -429,7 +449,7 @@ top_travel_cities.pop()
 
 
 
-Now if we want to change an element from the middle of the list, we can access and then reassign that element.  So for example, let's change 'Walla Walla Valley' to the number 4.
+Now if we want to change an element from the middle of the list, we can access and then reassign that element. For example, let's change 'Walla Walla Valley' to the number 4.
 
 
 ```python
@@ -472,14 +492,14 @@ top_travel_cities
 
 
 
-And our list is now changed.  It's not a sensible list right now, so let's change it back.
+Our list is changed, but now it's not as sensible, so let's change it back.
 
 
 ```python
 top_travel_cities[4] = 'Walla Walla Valley'
 ```
 
-And our list is alright.
+With that, our list is back to the way we like it.
 
 
 ```python
@@ -507,7 +527,7 @@ top_travel_cities
 
 ### Finding Unique elements and length of lists
 
-If we are not sure if there are repeated elements, we can use Python to get a unique list.
+If we are not sure whether there are repeated elements, we can use Python to get a unique list.
 
 
 ```python
@@ -547,13 +567,13 @@ The set function initializes a new set in Python.  A set is a different type col
 
 
 ```python
-set()
+type(set())
 ```
 
 
 
 
-    set()
+    set
 
 
 
@@ -565,11 +585,11 @@ unique_travel_cities[1]
 ```
 
 
-    ---------------------------------------------------------------------------
+    -------------------------------------------------------------------
 
-    TypeError                                 Traceback (most recent call last)
+    TypeError                         Traceback (most recent call last)
 
-    <ipython-input-106-8d1dfec3493a> in <module>()
+    <ipython-input-26-3d2453cad46e> in <module>()
     ----> 1 unique_travel_cities[1]
 
 
@@ -619,19 +639,19 @@ unique_travel_cities
 
 
 
-    ['Archipelago Sea',
+    ['Toronto',
+     'Archipelago Sea',
      'Iguazu Falls',
-     'Solta',
+     'Pyeongchang',
      'Los Cabos',
-     'Walla Walla Valley',
-     'Greenville',
-     'Marakesh',
-     'Toronto',
-     'San Antonio',
      'Buenos Aires',
-     'Salina Island',
+     'Marakesh',
+     'Greenville',
      'Albuquerque',
-     'Pyeongchang']
+     'Salina Island',
+     'Walla Walla Valley',
+     'San Antonio',
+     'Solta']
 
 
 
@@ -686,6 +706,8 @@ top_travel_cities
 
 
 
+> **Note:** *For most purposes, Python developers prefer to work with `lists` as opposed to sets, as `lists` are generally easier to manipulate, as you will see in future lessons.*
+
 ### Summary
 
-In this section we saw how to associate data together in a collection, called a list.  A list is similar to a list in the real world - it implies the data has some connection, and that it has an order to it.  We initialize a list with the brackets, `[]`, and separate each element by a comma.  To access elements from a list, we use the bracket accessor followed by the index of the element we want to retrieve.  And our indices began at zero and increase from there.  To add a new element to the end of the list we use the `append` method, and to remove an element from the end of a list we use `pop`.  We can change elements anywhere between by first accessing the elements and then reassigning them.
+In this section we saw how to associate data together in a collection, called a list.  A list is similar to a list in the real world - it implies the data has some connection, and that it has an order to it.  We initialize a list with the brackets, `[]`, and separate each element by a comma.  To access elements from a list, we use the bracket accessor followed by the index of the element we want to retrieve, and our indices begin at zero and increase from there. To add a new element to the end of the list we use the `append` method, and to remove an element from the end of a list we use `pop`. We can change elements anywhere between by first accessing the elements and then reassigning them.