Batching minor fixes and typo corrections into one PR (#96)

* Update 00-who.md

* add correction to minor typos

* Update workshop website link in readme body

* Typo correction

* Update 20-adding-removing-finding.md

I think that you wanted to state that one can call help on the variable that's already a list, instead of the type itself (?)

* Typos in 04-the-repl-in-vscode.md

Changed "type" to "directory" (but could possibly also just be "dir" here) and add the word "pass" to a sentence under the help() section.

* Typos in Best Practices - 02-brief-history.md

Just fixing a few small typos.

* Typos in  020-basic-data-types / 00-variables.md

Just a few minor typos

* Update 50-sets.md

* Update 65-mutability.md

values in a python should be immutable

* Update 60-dictionaries.md

Remove unnecessary quotation mark

* Fix typo.

reccomended -> recommended

* Update 00-variables.md

* Fix typo

^ character is called caret.
https://en.wikipedia.org/wiki/Caret

* Fixed Grammatical Error

* fix mistype

Co-authored-by: Jim Horn <[email protected]>
Co-authored-by: ChidinmaKO <[email protected]>
Co-authored-by: Christian Nwamba <[email protected]>
Co-authored-by: Lokesh Jadhav <[email protected]>
Co-authored-by: Daniel Silva <[email protected]>
Co-authored-by: Marc Johlic <[email protected]>
Co-authored-by: trufkin <[email protected]>
Co-authored-by: Eric Dai <[email protected]>
Co-authored-by: Matilda Smeds <[email protected]>
Co-authored-by: Kim Brandl <[email protected]>
Co-authored-by: Adeyemi Ridwan <[email protected]>
Co-authored-by: sherry808 <[email protected]>
Co-authored-by: Itamar Held <[email protected]>

Author: 14 people

README.md

@@ -6,7 +6,7 @@ These are the resources for Nina Zakharenko's Python Fundamentals and Intermedia
 
 The majority of the content can be found on the course website.
 
-* [Course Website - learnpython.netlify.com](https://learnpython.netlify.com)
+* [Course Website - https://www.learnpython.dev](https://www.learnpython.dev)
 * [This Repo - git.io/python3](https://git.io/python3)
 * [Follow Nina on Twitter](https://twitter.com/nnja)
 

website/content/01-introduction/00-who.md

@@ -10,7 +10,7 @@ draft: false
 {{< figure src="/images/me.jpg" width="20%" title="Nina Zakharenko" >}}
 </a>
 
-Hi, I'm Nina Zakharenko. I'm a Senior Cloud Developer Advocate and Microsoft, focusing on Python. Before Microsoft, I wrote code for other cool companies like Reddit, Meetup, and HBO. In my spare time I like drinking scotch and tinkering with wearable electronics. I enjoy hiking and snowboarding from my home base in Portland, Oregon. I change my hair color regularly.
+Hi, I'm Nina Zakharenko. I'm a Senior Cloud Developer Advocate at Microsoft, focusing on Python. Before Microsoft, I wrote code for other cool companies like Reddit, Meetup, and HBO. In my spare time I like drinking scotch and tinkering with wearable electronics. I enjoy hiking and snowboarding from my home base in Portland, Oregon. I change my hair color regularly.
 
 
 I've been involved in the Python community for approximately 6 years. During that time I've spoken at multiple Python conferences on a variety of topics, including PyCon US, PyParis, DjangoCon, and even PyCon Russia in Moscow.

website/content/01-introduction/02-requirements/05-vs-code/04-the-repl-in-vscode.md

@@ -90,14 +90,14 @@ For example, in the REPL, let's make a new variable `name`, and check its `type`
 We'll see that the type is `str`, Python's version of a string. Now that we know this object's type, we can
 pass the type into other methods.
 
-The first one is `dir()` which stands for directory. If we check the type of `str` (notice, no quotes here)) in the REPL, we'll see all the methods available on strings in Python. Don't worry about these for now, we'll use them later in the day.
+The first one is `dir()` which stands for directory. If we check the directory of `str` (notice, no quotes here)) in the REPL, we'll see all the methods available on strings in Python. Don't worry about these for now, we'll use them later in the day.
 
 ```Python
 >>> dir(str)
 ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
 ```
 
-The next useful method is `help()`. You can a type, method, or other object to help to instantly see available documentation about the method, the parameters it expects, and what it returns.
+The next useful method is `help()`. You can pass a type, method, or other object to help to instantly see available documentation about the method, the parameters it expects, and what it returns.
 
 Let's try this in the REPL, and look up the documentation for the `isupper` method in String. We access it with the period symbol (`.`). This is called dot-notation.
 

website/content/02-introduction-to-python/010-Best-Practices/02-brief-history.md

@@ -13,11 +13,11 @@ You might be surprised to learn that Python is 30 years old!
 
 ### Where is it used?
 
-A common misconception that Python is a scripting language. It's used at companies from Reddit, to Netflix, to Dropbox.
+A common misconception is that Python is a scripting language. It's used at companies from Reddit, to Netflix, to Dropbox.
 
 ### What's all this about Python 2 vs Python 3
 
-This part is a bit of a stain on Pythons history. Python 3 was released 2008, and its adoption was slow. First and foremost because it took popular packages a fair amount of time to port over their code.
+This part is a bit of a stain on Python's history. Python 3 was released 2008, and its adoption was slow. First and foremost because it took popular packages a fair amount of time to port over their code.
 
 This debate is now over. Python 2 will reach end-of-life in 2020, meaning that important updates - including security updates - will stop being released. That's why this course focuses on *Python3 only*.
 
@@ -56,4 +56,4 @@ The biggest yearly conference is [PyCon US](https://us.pycon.org) with approxima
 
 There are many local user groups worldwide, with many listed on [this wiki](https://wiki.python.org/moin/LocalUserGroups).
 
-There are many supportive groups for women and non-binary developers, such as [PyLadies](https://www.pyladies.com/) and [DjangoGirls](https://djangogirls.org/). These organizations have chapters in most major cities.
+There are many supportive groups for women and non-binary developers, such as [PyLadies](https://www.pyladies.com/) and [DjangoGirls](https://djangogirls.org/). These organizations have chapters in most major cities.

website/content/02-introduction-to-python/020-basic-data-types/00-variables.md

@@ -7,7 +7,7 @@ weight: 1
 
 ### Naming Variables
 
-Python variables can't start with with a number. In general, they're named all lower case, separated by underscores. Unlike other languages, that name their variables with camelCase.
+Python variables can't start with a number. In general, they're named all lower case, separated by underscores. Unlike other languages, that name their variables with camelCase.
 
 You don't want to name your variables the same as the *types* that we'll be working with. For example **don't** name your variables `int`, `list`, `dict`. Etc.
 
@@ -56,7 +56,7 @@ When creating variables, there are a few best practices you should follow.
 
 #### Naming Variables
 
-Convention says that numbers should be named in lower case, with whole words separated by underscores.
+Convention says that variables should be named in lowercase, with whole words separated by underscores.
 
 {{% notice note %}}
 If you want to learn more about Python naming conventions look at [PEP8](https://www.python.org/dev/peps/pep-0008/#naming-conventions) during a break.
@@ -84,7 +84,7 @@ If you notice your program behaving oddly and you can't find the source of the b
 
 ## Types
 
-Python has a very easy way of determining the type of something. It's the `type()` function.
+Python has a very easy way of determining the type of something, with the `type()` function.
 
 ```python
 >>> num = 42
@@ -101,4 +101,4 @@ If you try to examine a variable on the REPL that's been set to `None`, you won'
 ```python
 >>> x = None
 >>> x
-```
+```

website/content/02-introduction-to-python/080-advanced-datatypes/20-adding-removing-finding.md

@@ -76,7 +76,7 @@ insert(self, index, object, /)
     Insert object before index.
 ```
 
-You can also call help on `list.insert`. Because `names` is already of type `list`, it achieves the same result.
+You can also call help on `names.insert`. Because `names` is already of type `list`, it achieves the same result.
 
 ##### `my_list.extend(other_list)` adds all the contents of `other_list` to `my_list`
 
@@ -116,7 +116,7 @@ False
 Notice that only the *first* index of the string `"Nina"` is returned. We'll learn more about what an index is in the next chapter.
 
 {{% notice info %}}
-If the item we're looking for *is not* in the list, Python with throw a `ValueError`.
+If the item we're looking for *is not* in the list, Python will throw a `ValueError`.
 {{% /notice %}}
 
 You'll learn how to deal with exceptions later. For now, you can use the `in` operator to check if an item is present in the list before finding its index.

website/content/02-introduction-to-python/080-advanced-datatypes/50-sets.md

@@ -197,7 +197,7 @@ Your set will update with each character of the `str`ing, which was probably not
 |---------------------	|------------------	|-------------------------------------------------------------------------------	|
 | `s.union(t)`        	| <code>s &#124; t</code> | creates a new set with all the items **from both `s` and `t`**             |
 | `s.intersection(t)` 	| `s & t`          	| creates a new set containing *only* items that are **both in `s` and in `t`** 	|
-| `s.difference(t)`    	| `s ^ t`          	| creates a new set with items **in `s` but not in `t`**                        	|
+| `s.difference(t)`    	| `s ^ t`          	| creates a new set containing items that are **not in both `s` and in `t`**                        	|
 
 #### examples
 

website/content/02-introduction-to-python/080-advanced-datatypes/60-dictionaries.md

@@ -142,7 +142,7 @@ If you try to put a key into a dictionary that's already there, you'll just end
 
 >>> nums[8] = "oops, overwritten"
 >>> nums
-{1: 'one', 2: 'two', 3: 'three', 8: ', overwritten'}
+{1: 'one', 2: 'two', 3: 'three', 8: 'oops, overwritten'}
 >>> 8 in nums
 True
 ```
@@ -178,7 +178,7 @@ There are three useful methods you need to remember about `dict`ionary access:
 
 1. `my_dict.keys()`
 2. `my_dict.values()`
-3. `'my_dict.items()`
+3. `my_dict.items()`
 
 #### 1. `my_dict.keys()` Getting all the keys in a dictionary
 
@@ -204,4 +204,4 @@ Notice that `my_dict.items()` returns a type that looks like a list. It contains
 >>> nums = {1: 'one', 2: 'two', 3: 'three', 8: 'eight'}
 >>> nums.items()
 dict_items([(1, 'one'), (2, 'two'), (3, 'three'), (8, 'eight')])
-```
+```

website/content/02-introduction-to-python/080-advanced-datatypes/65-mutability.md

@@ -26,6 +26,6 @@ For the mutability of the container types we covered in this chapter, check this
 | container type 	| use                                                                                                     	| mutable? 	|
 |----------------	|---------------------------------------------------------------------------------------------------------	|----------	|
 | `list`         	| ordered group of items, accessible by position                                                          	| **yes**  	|
-| `set`          	| unordered group of mutable items. useful for set operations (membership, intersection, difference, etc) 	| **yes**  	|
+| `set`          	| mutable unordered group consisting only of immutable items. useful for set operations (membership, intersection, difference, etc) 	| **yes**  	|
 | `tuple`        	| contain ordered groups of items in an **immutable** collection                                          	| **no**   	|
-| `dict`         	| contains key value pairs                                                                                	| **yes**  	|
+| `dict`         	| contains key value pairs                                                                                	| **yes**  	|

website/content/02-introduction-to-python/190-APIs/final-exercise.md

@@ -11,7 +11,7 @@ Let's review what we learned today and put it all together.
 For the final exercise of today, we're going to write a small program that requests the top repositories from GitHub, ordered by the number of stars each repository has, then we're going to print the results to our terminal. Create a new file called `day_one.py`.
 
 {{% notice note %}}
-You may need to install the `requests` library using `python -m pip install requests`. You may see `pip` used directly, but using `python -m pip` is [reccomended by Python](https://docs.python.org/3/installing/index.html).
+You may need to install the `requests` library using `python -m pip install requests`. You may see `pip` used directly, but using `python -m pip` is [recommended by Python](https://docs.python.org/3/installing/index.html).
 {{% /notice %}}
 
 Let's start with our key function, the one that gets the data from the [GitHub API](https://developer.github.com/v3/search/). Use the `requests` library to do a GET request on the GitHub search API URL ("https://api.github.com/search/repositories"). Use `if __name__ == "__main__"` to check to make sure we're running the file directly, and to call our function. Don't forget to `import requests`

website/content/03-intermediate-python/10-introduction/15-converting-between-types/10-exercise.md

@@ -84,7 +84,7 @@ Oops, that wasn't quite what we wanted. Running any object through `str()` will
 >>> '-'.join(my_list)
 ```
 
-Another common way of converting a list to a string is with the string's `split()` method. This is useful for lightweight parsing of, for example, CSV (comma separated value) data.
+Another common way of converting a string into a list is with the string's `split()` method. This is useful for lightweight parsing of, for example, CSV (comma separated value) data.
 
 ```python
 >>> my_string = "the,quick,brown,fox"
@@ -117,4 +117,4 @@ Another common way of converting a list to a string is with the string's `split(
 ['the', 'quick', 'brown', 'fox']
 ```
 
-{{%/expand%}}
+{{%/expand%}}

website/content/03-intermediate-python/40-exceptions/10-all-about-exceptions.md

@@ -38,7 +38,7 @@ So, if you wanted to catch a divide-by-zero error, you could use `except ZeroDiv
 
 ## Exiting your Program
 
-As we mentioned, exceptions that are allowed to bubble up to the top level (called *unhandled* exceptions) will cause your program to exit. This is generally unwanted - even if an error in unrecoverable, we still want to provide more detailed information about the error for later inspection, or a pretty error for the user if our program is user-facing, and in most cases, we want the program to go back to doing what it was doing.
+As we mentioned, exceptions that are allowed to bubble up to the top level (called *unhandled* exceptions) will cause your program to exit. This is generally unwanted - even if an error is unrecoverable, we still want to provide more detailed information about the error for later inspection, or a pretty error for the user if our program is user-facing, and in most cases, we want the program to go back to doing what it was doing.
 
 What if we want our program to stop, though? You may already be familiar with `ctrl-c`, the age-old posix method of sending SIGINT (an interrupt signal) to a program. You may be surprised to know asking your operating system to send SIGINT to Python causes, yes, an exception - `KeyboardInterrupt`. And yes, you can catch `KeyboardInterrupt`, but this will make your program a little harder to kill.
 

website/content/03-intermediate-python/40-exceptions/30-try-except-else-finally.md

@@ -16,12 +16,12 @@ A basic example looks like this:
 ...     print("That number was invalid")
 ```
 
-First, the `try` clause is executed. If no exception occurs, the `except` clause is skipped and execution of the `try` statement is finished. If an exception occurs in the `try` clause, the rest of the clause is skipped. If the the exception's type matches the exception named after the `except` keyword, then the `except` clause is executed. If the exception doesn't match, then the exception is *unhandled* and execution stops.
+First, the `try` clause is executed. If no exception occurs, the `except` clause is skipped and execution of the `try` statement is finished. If an exception occurs in the `try` clause, the rest of the clause is skipped. If the exception's type matches the exception named after the `except` keyword, then the `except` clause is executed. If the exception doesn't match, then the exception is *unhandled* and execution stops.
 
 
 ### The `except` Clause
 
-An `except` clause my have multiple exceptions, given as a parenthesized tuple:
+An `except` clause may have multiple exceptions, given as a parenthesized tuple:
 
 ```python
 try:

website/content/03-intermediate-python/40-exceptions/99-exercise.md

@@ -21,7 +21,7 @@ IndentationError: expected an indented block
 
 Notice that we started a new function scope with the `def` keyword, but didn't indent the next line of the function, the `print()` argument.
 
-You've probably also seen the more general `SyntaxError`. This one's probably obvious - something is misspelled, or the syntax is otherwise wrong. Python gives us a helpful little carrot `^` under the earliest point where the error was detected, however you'll have to learn to read this with a critical eye as sometimes the actual mistake precedes the invalid syntax. For example:
+You've probably also seen the more general `SyntaxError`. This one's probably obvious - something is misspelled, or the syntax is otherwise wrong. Python gives us a helpful little caret `^` under the earliest point where the error was detected, however you'll have to learn to read this with a critical eye as sometimes the actual mistake precedes the invalid syntax. For example:
 
 ```python
 >>> a = [4,