Merge branch 'main' into kacey-lab10-atm

Author: demolishen

0 General/11 Git Lab Workflow.md

@@ -26,10 +26,10 @@
     `git status`
 
 1. Use whichever or these four options is appropriate to add the necessary files to git tracking:  
-    `git add .`  
-    `git add <filepath>`  
-    `git add <directorypath>`  
-    `git add -A`  
+    `git add .`  # Add file changes in current directory and below to staging.  
+    `git add <filepath>`  # Add a specific filepath to staging.  
+    `git add <directorypath>`  # Add a specific directory path to staging.  
+    `git add -A`  # Add all file changes in whole repository to staging.  
 
 1. Use `git status` to view what files and directories will be added to the commit:  
     `git status`
@@ -71,7 +71,11 @@
 ## Switch between in-progress branches.
 
 1. Git `add` and `commit` changes to current branch:  
-    1. `git add -A`
+    1. Use whichever `git add` option as appropriate:
+        * `git add .`  
+        * `git add <filepath>`  
+        * `git add <directorypath>`  
+        * `git add -A` 
     1. `git commit -m <commit message>`
 
 1. Checkout the different branch we want to work on:  
@@ -80,7 +84,11 @@
 1. Do the code changes for this branch.
 
 1. Git `add` and `commit` changes to the new current branch `<a-branch-name>`:  
-    1. `git add -A`
+    1. Use whichever `git add` option as appropriate:
+        * `git add .`  
+        * `git add <filepath>`  
+        * `git add <directorypath>`  
+        * `git add -A` 
     1. `git commit -m <commit message>`
 
 1. Checkout some other branch we want to work on:  

1 Python/docs/class_code_examples/fileIO/Reader.py

@@ -0,0 +1,51 @@
+class Reader:
+
+    def __init__(self, book_file):
+        self.book_file = book_file
+        self.text = ''
+
+    def load(self):
+        """
+        1) open 'file' with option 'r' for read
+        2) get the text from the file
+        """
+        with open(self.book_file, "r") as f_read:
+            self.text = f_read.read()
+
+        return self.text
+
+    def edit(self, new_text):
+        """
+        1) open file with open 'w' for write
+        2) take in additional text & concat onto existing file
+        3) save to the file
+        """
+        with open(self.book_file, "a") as f_write:
+            f_write.write(new_text)
+
+    def replace(self, new_text):
+        with open(self.book_file, "w") as f_write:
+            f_write.write(new_text)
+
+    def print(self):
+        """
+        print the text
+        """
+
+
+def main():
+    text = Reader('/Users/sb/Desktop/class_HB2/1 Python/docs/class_code_examples/fileIO/book.txt')  # create an instance of our class
+    text.load()
+    while True:
+        command = input('Enter a command: ')
+        if command == 'save':
+            new_text = input('add new text: ')
+            text.save(new_text)
+        elif command == 'print':
+            print('heeey')
+        else:
+            print('Command not recognized')
+
+
+if __name__ == "__main__":
+    main()

1 Python/docs/class_code_examples/fileIO/book.txt

@@ -0,0 +1,2 @@
+David 5551234
+Alice 6662345

1 Python/docs/class_code_examples/fileIO/contact.csv

@@ -0,0 +1,2 @@
+name,phone number,state,zipe code
+Sarah Beth,123432112,VA,22906

1 Python/docs/class_code_examples/mini_capstone_ex/lyric.py

@@ -0,0 +1,12 @@
+import pylyrics3
+# https://github.com/jameswenzel/pylyrics3
+
+
+bon_iver_lyrics = pylyrics3.get_artist_lyrics('bon iver')
+
+print(bon_iver_lyrics)
+
+
+while True:
+    artist = input('What artist do you want to look up?')
+    print(pylyrics3.get_artist_lyrics(artist))

1 Python/labs/11 Contact List.md

@@ -0,0 +1,35 @@
+
+# Lab 11: Contact List
+
+
+Let's build a program to manage a list of contacts. To start, we'll build a CSV ('comma separated values') together, and go over how to load that file. Headers might consist of `name`, `favorite fruit`, `favorite color`. Open the CSV, convert the lines of text into a **list of dictionaries**, one dictionary for each user. The text in the header represents the **keys**, the text in the other lines represent the **values**.
+
+```python
+with open('contacts.csv', 'r') as file:
+    lines = file.read().split('\n')
+    print(lines)
+```
+
+Once you've processed the file, your list of contacts will look something like this...
+```python
+contacts = [
+    {'name':'matthew', 'favorite fruit':'blackberries', 'favorite color':'orange'},
+    {'name':'sam', 'favorite fruit':'pineapple' ...}
+]
+```
+
+*Note: There is a `csv` library in Python that will do much of this for you. It is what you would use normally in a project, but for this lab you need to write all the logic yourself.*
+
+## Version 2
+
+Implement a CRUD REPL
+
+- **C**reate a record: ask the user for each attribute, add a new contact to your contact list with the attributes that the user entered.
+- **R**etrieve a record: ask the user for the contact's name, find the user with the given name, and display their information
+- **U**pdate a record: ask the user for the contact's name, then for which attribute of the user they'd like to update and the value of the attribute they'd like to set.
+- **D**elete a record: ask the user for the contact's name, remove the contact with the given name from the contact list.
+
+## Version 3
+
+When REPL loop finishes, write the updated contact info to the CSV file to be saved. I highly recommend saving a backup `contacts.csv` because you likely won't write it correctly the first time.
+

1 Python/labs/Connect Four Mob.md

@@ -0,0 +1,57 @@
+Connect Four
+
+[Connect Four](https://en.wikipedia.org/wiki/Connect_Four) is a board game.
+Players take turns placing tokens of their color into a vertical grid.
+They drop to the bottom, and if anyone has four of their color in a straight line, they've won!
+
+Define a module that simulates a Connect Four game.
+
+This will consist of the following classes:
+
+`Player`:
+- Properties
+    - `name`
+    - `color`
+        
+`Game`:
+- Properties
+    - `board`: 7x6 board representation
+
+- Methods
+    - `get_height(position)`: returns int of how many pieces occupy a column 
+    - `move(player, position)`: adds a player token to a column after figuring out the current height of the column 
+    - `calc_winner()`: returns true if a match (four in a row) is found 
+    - `is_full()`: returns true if all board positions are occupied 
+    - `is_game_over()`: returns true if the game is over (a winner is found or the board is full)
+
+
+Create a program that simulates the _just playing moves_ of an existing Connect Four game.
+Do not concern yourself with figuring out who has won.
+
+It will read a file that contains a history of the moves in a game.
+Assume the playing board is made of columns numbered 1 through 7.
+The file will have one line for each move (players alternate).
+The number in that line is the column the current player placed a token in.
+
+Use the following [example move file](./connect_four/connect-four-moves.txt).
+Save it in something like `connect-four-moves.txt`
+This moves file recreates [this game](https://en.wikipedia.org/wiki/File:Connect_Four.gif).
+
+*   Think about how to figure out how far that token will fall in a given column.
+
+*   Think about how to place a token in a column.
+
+*   Think about how to concisely store the tokens that have been dropped in the board.
+
+*   Read in moves from the file.
+
+*   After each move, print out a representation of the board.
+    You can use `R` and `Y` to represent the pieces.
+
+## Version 2
+
+*   Once all moves are done, also print out what player, if any, won.
+
+## Version 3
+
+*   Make game playable

1 Python/labs/connect-four-moves.txt

@@ -0,0 +1,18 @@
+4
+3
+5
+6
+4
+4
+5
+3
+6
+2
+7
+7
+3
+7
+4
+5
+6
+5

1 Python/labs/game_start.py

@@ -0,0 +1,36 @@
+class Player:
+    '''
+    '   A class to represent each player
+    '   Attributes: name and color
+    '''
+
+class Game:
+    '''
+    '   A connect four game object.
+    '   Attributes: game board (7x6 2D nested list)
+    '   Methods:
+    '           get_height(position) returns int of how many pieces occupy a column
+    '           move(player,position) adds a player token to a column after figuring out the current height of the column
+    '           calc_winner(): returns True if four in a row are found
+    '           is_full(): returns true if all board positions are occupied
+    '           is_game_over(): returns true if the game is over (a winnder is found or the board is full)
+    '           play_turn(): function that plays one turn
+    '           play(): function that plays whole game, given two player
+    '           recursive_chip_checker(): recurisvely checks in all directions to find if theres a connect 4
+    '''
+
+if __name__ == '__main__':
+    # if this module is run directly, this code will run
+    # if the module is imported into another, it won't run
+
+    game = Game()
+    with open('1 Python/docs/class_code_examples/connect-four-moves.txt', 'r') as moves:
+
+        for move_num, line in enumerate(moves):
+            print(line)
+            col_to_play = int(line.strip()) - 1
+            player = 'Y' if move_num % 2 != 0 else 'R'
+            game.play_turn(player, col_to_play)
+            # OPTIONAL/BONUS: print board after each turn
+            game.is_game_over() # could be called w/in play_turn, or in a different order
+

1 Python/labs/optional_labs/optional-LCR.md

@@ -0,0 +1,12 @@
+
+# Lab: LCR Simulator
+
+LCR is a dice game, one of pure chance. Therefore, we can write a simulator to avoid wasting the time playing it ourselves. Description from [wikipedia](https://en.wikipedia.org/wiki/LCR_(dice_game)):
+
+
+> Each player receives at least 3 chips. Players take it in turn to roll three six-sided dice, each of which is marked with "L", "C", "R" on one side, and a single dot on the three remaining sides. For each "L" or "R" thrown, the player must pass one chip to the player to his left or right, respectively. A "C" indicates a chip to the center (pot). A dot has no effect.
+
+>If a player has fewer than three chips left, he/she is still in the game but his number of chips is the number of dice he/she rolls on his/her turn, rather than rolling all three. When a player has zero chips, he/she passes the dice on his turn, but may receive chips from others and take his next turn accordingly. The winner is the last player with chips left. He/she does not roll the dice, and wins the center pot. If he/she chooses to play another round, he/she does not roll 3, he/she keeps his pot and plays with that.
+
+
+When the program starts, it should ask for the names of the players, until the user enters 'done'. Then it should run the simulation, tell the user who won, and ask the player whether they'd like to play again.