Merge branch 'main' into zach-lab11-contact-list

Author: x8bitReignbeaux

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/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.

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

@@ -0,0 +1,19 @@
+
+# Lab: Arbitrary Precision Arithmetic
+
+[Arbitrary Precision Arithmetic](https://en.wikipedia.org/wiki/Arbitrary-precision_arithmetic) is a way of performing arithmetic with greater precision than that offered by ordinary ints and floats. One python library for this is [mpmath](http://mpmath.org/).
+
+## Addition
+
+Remember doing [long addition](https://en.wikipedia.org/wiki/Elementary_arithmetic#Example) in elementary school? You could represent an 'big int' as a list of ints. To add them, loop over the digits from 'right' to 'left', keeping track of the 'carry'. Also be wary of numbers with differing number of digits. Prompt the user for each number and print out their sum.
+
+```
+What is the first number? 23422340923410340239482304
+What is the second number? 303003025050020203492
+23422340923410340239482304 + 303003025050020203492 = 23422643926435390259685796
+```
+
+
+## Multiplication
+
+A simple (but inefficient) way of implementing multiplication is through repeated addition. For example, 564*6 = 564+564+564+564+564+564. A more efficient way would be [long multiplication](http://mathworld.wolfram.com/LongMultiplication.html).

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

@@ -0,0 +1,8 @@
+
+# Crime Data
+
+Open one of the crime data csv's in the data folder, and derive the following statistics.
+
+- The specific most common crime type.
+- The rarest crimes.
+- The year with the most crime.

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

@@ -0,0 +1,34 @@
+# Lab: Road Trip
+
+We've mapped what cities are directly connected by roads and stored them in a dictionary:
+
+```python
+city_to_accessible_cities = {
+  'Boston': {'New York', 'Albany', 'Portland'},
+  'New York': {'Boston', 'Albany', 'Philadelphia'},
+  'Albany': {'Boston', 'New York', 'Portland'},
+  'Portland': {'Boston', 'Albany'},
+  'Philadelphia': {'New York'}
+}
+```
+
+Traveling from one city to an adjacent one is called a **hop**. Let the user enter a city.
+Print out all the cities connected to that city. Then print out all cities that could be reached through two hops.
+
+
+
+## Version 2 (optional)
+
+Let the user enter a city and a number of hops. Print out all cities that could be reached through that number of hops.
+
+We've also mapped the travel time of each hop. When the user enters a city and a number of hops, print out the shortest travel times to each city. Paths with fewer hops are not necessarily those with the shorter travel times.
+
+```python
+city_to_accessible_cities_with_travel_time = {
+  'Boston': {'New York': 4, 'Albany': 6, 'Portland': 3},
+  'New York': {'Boston': 4, 'Albany': 5, 'Philadelphia': 9},
+  'Albany': {'Boston': 6, 'New York': 5, 'Portland': 7},
+  'Portland': {'Boston': 3, 'Albany': 7},
+  'Philadelphia': {'New York': 9},
+}
+```

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

@@ -0,0 +1,15 @@
+
+# Lab: Sock Sorter
+
+You've just finished laundry and your expansive sock collection is in complete disorder. Sort your socks into pairs and pull out any loners.
+
+1) Generate a list of 100 random socks, randomly chosen from a set of types: `sock_types = ['ankle', 'crew', 'calf', 'thigh']`
+
+2) Find the number of duplicates and loners for each sock type. Hint: dictionaries are helpful here.
+
+
+## Version 2
+
+Now you have a mix of types **and** colors. Represent socks using tuples containing one color and one type `('black', 'crew')`. Randomly generate these, and then group them into pairs.
+
+`sock_colors = ['black', 'white', 'blue']`

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

@@ -0,0 +1,54 @@
+
+# Lab: Tree
+
+A tree is a type of data structure, one that represents a hierarchy. Try running the code below and implement the following functions.
+
+- `count_leaves(node)` returns the number of leaves
+- `rename_leaves(node, to_find, to_replace)` finds leaves with the name `to_find` and replaces their name with `to_replace`.
+
+
+
+```python
+import random
+
+names = ['virginia', 'christine', 'carl', 'lillian']
+
+
+def generate_tree(depth):
+    n_children = int(random.random()*10/depth)
+    if n_children == 0:
+        return {'type': 'leaf', 'name': random.choice(names)}
+    branch = {'type': 'branch', 'children': []}
+    for i in range(n_children):
+        child = generate_tree(depth+1)
+        branch['children'].append(child)
+    return branch
+
+
+def print_node(node, indentation):
+    if node['type'] == 'leaf':
+        print(indentation + node['name'])
+    else:
+        print(indentation + '-')
+        for i in range(len(node['children'])):
+            print_node(node['children'][i], indentation + '\t')
+
+
+# count all trees and branches
+def count_nodes(node):
+    if node['type'] == 'leaf':
+        return 1
+    r = 1
+    for i in range(len(node['children'])):
+        r += count_nodes(node['children'][i])
+    return r
+
+
+root = generate_tree(1)
+print_node(root, '')
+print(count_nodes(root))
+```
+
+
+
+

1 Python/practice/practice01-fundamentals.md

@@ -0,0 +1,69 @@
+
+
+# Practice 1: Fundamentals
+
+For each practice problem, write a function that returns a value (not just prints it). You can then call the function a couple times to test it, comment those calls out, and move on to the next problem. An example of this format is given below.
+
+```python
+def add(a, b):
+    return a + b
+#print(add(5, 2))
+#print(add(8, 1))
+```
+
+## Problem 1
+
+Write a function that tells whether a number is even or odd (hint, compare a/2 and a//2, or use a%2)
+
+```python
+def is_even(a):
+    ...
+is_even(5) → False
+is_even(6) → True
+```
+
+
+## Problem 2
+
+Write a function that takes two ints, a and b, and returns True if one is positive and the other is negative.
+
+```python
+def opposite(a, b):
+    ...
+opposite(10, -1) → True
+opposite(2, 3) → False
+opposite(-1, -1) → False
+```
+
+## Problem 3
+
+Write a function that returns True if a number within 10 of 100.
+
+```python
+def near_100(num):
+    ...
+near_100(50) → False
+near_100(99) → True
+near_100(105) → True
+```
+
+## Problem 4
+
+Write a function that returns the maximum of 3 parameters.
+
+```python
+def maximum_of_three(a, b, c):
+    ...
+maximum_of_three(5,6,2) → 6
+maximum_of_three(-4,3,10) → 10
+```
+
+## Problem 5
+
+Print out the powers of 2 from 2^0 to 2^20
+
+`1, 2, 4, 8, 16, 32, ...`
+
+
+
+