add initial course materials

Author: grobergm

config.yml

@@ -0,0 +1,94 @@
+title: Intermediate Python
+tagline: Create a REST api with Node.js, Express.js, and MongoDB
+description: Learn how to create a dice-rolling app with Python!
+tags:
+  - Python
+
+template:
+  name: intermediate-python-course
+  repo: intermediate-python-course-template
+  description: an intermediate Python course
+before:
+  - type: createIssue
+    title: Set up your project
+    body: 01-setup.md
+
+steps:
+  - title: Set up your project
+    description: Introduces the project and how to set it up
+    event: issue_comment
+    link: "{{ repoUrl }}/issues/1"
+    actions: 
+      - type: respond
+        with: 01-running.md
+        issue: 1
+
+  - title: Running a Python program
+    description: Run a python program with a main method
+    event: push
+    link: "{{ repoUrl }}/issues/1"
+    actions: 
+      - type: respond
+        with: 01-complete.md
+        issue: 1
+      - type: closeIssue
+        issue: 1
+      - type: createIssue
+        title: Using Variables 
+        body: 02-model.md
+
+  - title: Using Variables
+    description: Define variables with random input to simulate a die-roll
+    event: issue_comment
+    link: "{{ repoUrl }}/issues/2"
+    actions: 
+      - type: respond
+        with: 02-multiple.md
+        issue: 2
+        data: 
+          roll: '%payload.comment.body%'
+
+  - title: Rolling multiple Dice
+    description: Roll multiple dice and add their results
+    event: push
+    link: "{{ repoUrl }}/issues/2"
+    actions:
+      - type: respond
+        with: 02-complete.md
+        issue: 2
+      - type: closeIssue
+        issue: 2
+      - type: createIssue
+        title: Adding Conditionals 
+        body: 03-conditionals.md
+
+  - title: Adding Conditionals
+    description: Add some flavor to your responses with conditionals
+    event: issue_comment
+    link: "{{ repoUrl }}/issues/3"
+    actions: 
+      - type: gate
+        left: '%payload.comment.body%'
+        operator: <
+        right: 6
+          - else: respond
+            with: 03-unlucky.md
+            data: 
+              rollNum: '%payload.comment.body%'
+      - type: respond
+        with: 03-input.md
+        issue: 3
+        data: 
+          rollNum: '%payload.comment.body%'
+
+  - title: Rolling multiple Dice
+    description: Roll multiple dice and add their results
+    event: push
+    link: "{{ repoUrl }}/issues/3"
+    actions:
+      - type: respond
+        with: 03-complete.md
+        issue: 3
+      - type: closeIssue
+        issue: 3
+

responses/01-complete.md

@@ -0,0 +1,5 @@
+Great! 
+
+You will be pushing code to your [own repository]({{ repoUrl }}) several times as a reference.
+
+[Click here to for the next steps]({{ repoUrl }}/issues/2)

responses/01-running.md

@@ -0,0 +1,33 @@
+## Running a Python file
+
+Let's look at our Python file. Inside we see a function `main` that will contain all of your commands as you create the dice roller:
+
+```python
+def main():
+    #print('You rolled a die')
+```
+
+Below that, you'll see an `if` statement calling that function:
+
+```python
+`if __name__== "__main__":
+    main()`
+```
+By doing this, the function `main` will run whenever you run the Python script. As you develop the dice roller, be sure to only manipulate the code within the `main` function; nothing else will need to be changed. 
+
+Right now the only line in our `main` function is a `print()` function:`#print('You rolled a die')`. This will print whatever is inside the parenthesis. There's a `#` in front of it right now, which means it's a comment. Uncomment it by removing the `#` to let Python read it, and save the file.
+
+You can run the Python script by typing `python dice_roller.py` in a terminal, provided you're in the correct directory. If not, run the script by typing `python /path/to/directory/dice_roller.py`, where `/path/to/directory` is replaced with the path to the file on your own system.
+
+You'll see the following nifty, albeit not very useful line printed out in your terminal: "You've rolled a die". We'll make it more informative in a bit, but first, let's push those changes to GitHub. 
+
+
+## Pushing your changes
+
+Whenever you change files in your repository, you'll want to `add` and `commit` the file, which allows you to add a message detailing what you changed. Then you can `push` the updated version, along with your comments, to GitHub. 
+
+Let's do those three steps:
+
+1. Git Add: `git add dice_roller.py`
+2. Git Commit: `git commit -m "I uncommented line 2"`
+3. Git Push: `git push`

responses/01-setup.md

@@ -0,0 +1,26 @@
+Welcome to this (mildly) advanced Python tutorial! Today we'll be writing a script to mimic a common real-world action. If you've ever played a tabletop game, you know there are many dice rolls to make. This tutorial will show how to harness a combination of Python skills to make an automatic dice roller. But first, before we do that, we'll need to get a few things set up on your system. 
+
+## Having Python 
+
+First, in order to do anything in Python, you need to *have* Python on your computer! Let's make sure it's installed. Open up a terminal and type `python -V. There are a few possible things it can output here:
+
+If the output begins with `Python 3`, you're good to go! This tutorial was tested on a system running Python 3.7.4, but it should be compatible with any version of Python 3. 
+
+If the output begins with `Python 2`, you have Python, but it's an outdated version. You'll need to download Python 3 to follow this tutorial. Go to the [Python](https://www.python.org/downloads/) website to download it.
+
+If you get a command that reads something similar to `command not found`, no version of Python is on your system. You'll need to go to the [Python](https://www.python.org/downloads/) website to download it.
+
+## Having Git
+
+We also need to make sure Git is installed on your system. Check that by typing `git --version` in a terminal. If it outputs a `git version` you're good to go! If not, go to the [Git](https://git-scm.com/downloads) website to download it.
+
+## Cloning this Repository
+
+Now that we have Git, we can clone the repository containing the building block of the code you'll be writing. In the terminal type `git clone {{ repoUrl }}`
+
+Inside the repo you'll see two files:
+
+- `README.md`: a markdown file that details some info about the project
+- `dice-roller.py`: a Python file containing the code you'll be building off of
+
+Now that we have everything we need, we can actually begin writing our dice roller! Let's begin!

responses/02-complete.md

@@ -0,0 +1,3 @@
+🎲🎲 Snake Eyes! 🐍
+
+[Click here]({{ repoUrl }}/issues/3) to learn how to add some custom responses!

responses/02-multiple.md

@@ -0,0 +1,64 @@
+You rolled a {{ roll }}? 😄 Nice!
+
+## Making Python Roll Multiple Dice
+Before moving on, make sure the `main` function contains:
+
+```python
+import random
+roll = random.randint(1, 6)
+print(f'You rolled a {roll}')
+```
+
+Now, what if we wanted to roll two dice? Well, one way to do that is to run the file twice. Another way is to duplicate the print statement within the file. However, this would get tedious for larger projects, so let's make use of a great Python feature: `for` loops. A `for` loop iterates over a range of values and performs a set of commands for all of those values. 
+
+How many dice do we want to roll? Let's go with two for now. Make a variable called `dice_rolls` below `import random` but above everything else, and set it equal to two.
+
+Now let's make the `for loop`. Right below where you set `dice_rolls` type:
+
+```python
+for i in range(0,dice_rolls):
+``` 
+
+Let's unpack what this means. If we were to make this a grammatical sentence it would read something like this:
+
+"`for` every `i`ndex `in` a `range` starting after `0` until the value is equal to `dice_rolls`, do this`:`"
+
+We would then have a set of commands it would do for every `i`. We already have the commands we want to be repeated, we just have to tell Python that by indenting them. Once they're indented, save the file and run it to get the two rolls.
+
+## Manipulating Variables
+
+With a `for` loop implemented, your code takes the form of this:
+
+```python
+import random
+dice_rolls = 2
+for i in range(0,dice_rolls):
+  roll = random.randint(1,6)
+  print(f'You rolled a {roll}')`
+```
+
+In most game situations, rolling multiple dice is followed by adding their values together. Let's do that now. In Python, arithmetic can be performed on variables just by using the equivalent mathematical symbols. Want to add two variables together? It's as simple as: `variable_sum = variable_1 + variable_2`. Since our dice values are stored in a single updating variable instead of separate variables, however, we'll have to add the values upon themselves. First, make a variable called dice_sum above the `for` loop, and set it equal to 0:
+
+```python
+dice_sum = 0
+```
+
+We'll be adding each value of `dice_roll` we get to this `dice_sum` variable as we loop through each dice roll. In the `for` loop, right after the `roll` variable is assigned, type:
+
+```python
+dice_sum = dice_sum + roll
+```
+
+Another way we can do this in Python is using the `+=` operator:
+
+```python
+dice_sum += roll
+```
+
+It doesn't matter which version you prefer, just go with whichever way is easier for you to visualize. Finally, let's print out our final value for `dice_sum`. After the `for` loop is finished, type:
+```python
+print('You have rolled a total of {dice_sum}')
+```
+If you save and run the file, you'll now get the values of the two dice rolls and their combined sum. Neat!
+
+*[push your code]({{ repoUrl }}/issues/1) to GitHub to continue*

responses/02-variables.md

@@ -0,0 +1,48 @@
+## Printing Variables
+
+All the file is doing right now is printing the sentence "You rolled a die." But the purpose of rolling a die is to come up with a number, so let's do that now. 
+
+We can  make a new variable named `roll`. Variables are simple to make in Python: set the variable equal to what you want it to be. Above the print function, create and set a variable called `roll` equal to 5 by writing:
+
+```python
+roll = 5
+```
+
+We'll want to print that variable, too, so let's change the print function to reflect what our `roll` variable is set to. This is done through Python's `f-string` functionality. By putting an `f` right before the quotes of the string you're printing, you can then print variables within the string. Let's replace the word 'die' in the sentence to our new `roll` variable. This changes the line to say:
+
+```python
+print(f'You rolled a {roll}')
+```
+
+Run the code again, and it should say `You rolled a 5`. Nice! Now we're getting a number. Go ahead and `push` your code with the output as the comment within `commit` to move on. 
+
+A die that only rolls 5's isn't useful though, so let's add in the randomness that dice are used for.
+
+
+## Randomizing Variables
+
+
+Just like a real die, we want the number we roll to be random. We'll need to use a package to do so. Python is full of packages; think of them like tools you can use for specific situations. Just like how you need a shovel to dig a hole, you need the `random` package to get a random value in Python.
+
+Right now, you should have a `main` function that contains this:
+
+```python
+roll = 5
+print(f'You rolled a {roll}')
+```
+
+To use a package, we'll need to import it. At the top of the file, import the package `random` by writing:
+
+```python
+import random 
+```
+
+In general, it's good practice to import all packages at the beginning of the script. Now let's use that package to randomize our `roll` variable. To get a random integer with the `random` package, we'll want to use the following format:
+
+```python
+random.randint(X,Y)
+```
+
+where X and Y are the boundaries of the range you want your random integers to be in. Note that X, the beginning of the range and Y, and the end of the range, are inclusive bounds. Note that X (the beginning of the range) and Y (the end of the range), are inclusive bounds. This means the integers you put as X and Y will be part of possible values. Knowing that, try changing `roll` to equal any integer that is possible to roll on a six-sided die: 1, 2, 3, 4, 5 and 6. There's no need to change anything in the print statement, as we've already tied it to whatever our `roll` variable is. 
+
+Now run the code and put *the number* you rolled as a comment, and then we'll keep this tutorial *rolling*!

responses/03-complete.md

@@ -0,0 +1,9 @@
+Good work finishing the intermediate python course!
+
+Now you have an awesome tool to use at your next game night! 
+
+Here are some potential *Next Steps* for you:
+
+1. Add more inputs (like player or team name).
+2. Store each player's roll totals in separate arrays.
+3. Choose a dice-based game that you can fully simulate using python. 

responses/03-conditionals.md

@@ -0,0 +1,40 @@
+## Adding Conditionals
+Now our code is developing some complexity! By adding our variable manipulation into our `for` loop, the code now looks like this:
+
+```python
+import random
+dice_rolls = 2
+dice_sum = 0
+for i in range(0,dice_rolls):
+  roll = random.randint(1,6)
+  dice_sum += roll
+  print(f'You rolled a {roll}')
+print('You have rolled a total of {dice_sum}')`
+```
+
+Let's add some flavor to our responses, dependent on how we roll. We can do this by using conditionals. We'll put a command that only triggers if a certain condition is met. For example, let's add "Critical Fail" in the printed statement if the die roll is a one.
+
+In Python, we can set this as the criteria by replacing our print statement with:
+
+```python
+if roll == 1:
+  print(f'You rolled a {roll}! Critical Fail')
+```
+
+But what if it's *not* a one? We need a catch-all for all the other conditions it could be. This is done in Python with the `else` command. Below our `if` statement and the related print function, add an `else` statement:
+
+```python
+else:
+  print(f'You rolled a {roll}')
+```
+    
+Now we have two different statements that can be printed. Try running your code until you have a roll that is a one and a roll that is something else.
+
+If we have additional conditions we want to add, we can use a third type of conditional in Python: `elif`. This is used for a specific condition after `if` has been used. Try adding this `elif` statement between the `if` and `else` statements:
+
+```python
+elif roll == 6:
+  print(f'You rolled a {roll}! Critical Success!')
+```
+
+Leave a comment with the *number of rolls* it took to get a Critical Success. 

responses/03-input.md

@@ -0,0 +1,44 @@
+Wow, it only took {{ rollNum }} rolls? 🤩 You must be lucky! 🍀
+
+With the conditionals added, your code should look something like this:
+
+```python
+import random
+dice_rolls = 2
+dice_sum = 0
+for i in range(0,dice_rolls):
+    roll = random.randint(1,6)
+    dice_sum += roll
+    if roll == 1:
+        print(f'You rolled a {roll}! Critical Fail')
+    elif roll == 6:
+        print(f'You rolled a {roll}! Critical Success!')
+    else:
+        print(f'You rolled a {roll}')
+print(f'You have rolled a total of {dice_sum}')
+```
+
+We have a working dice roller right now! It's useful for a very specific situation: rolling two six-sided dice. What if we want to change the number of dice we roll? We can manually edit the code each time, but there's a better way to do this: adding a user `input`.
+
+Instead of having `dice_rolls` set to a specific value, let's set it equal to:
+```python
+int(input('How many dice would you like to roll?'))
+```
+
+Running the code will give a prompt with that question and we can input our desired number of dice. One thing to note: the value a user inputs defaults to a `str` type and we need it to be a whole number, or an `int` in Python; that's why we encompass the `input` command in an `int()`. Try it out!
+
+Tabletop games use dice with all number of sides so it'll be useful to add a user input for that too. Below where you set `dice_rolls` add this line:
+
+```python
+dice_size = int(input('How many sides are the dice?'))
+```
+
+When changing a value we had assumed to be a specific number previously, we need to make sure the rest of our code still makes sense. All dice start with one, so our `if` statement regarding one still makes sense. Our `elif` statement regarding six doesn't though, as it is no longer guaranteed to be the highest number. Let's make it so our "Critical Success" line is printed to whatever the highest number of our desired dice is. The highest number a dice can roll is the same as the number of sides, so we just to replace our `elif` statement with:
+
+```python
+elif roll == dice_size:
+```
+
+Try it out! Now you can manually input the number of dice and number of sides on the dice knowing that the `Critical Success!` line will realign accordingly. 
+
+*[push your code]({{ repoUrl }}/issues/1) to GitHub to finish the course!*