flake8 revisions

Author: copev313

coin_flip_streaks.py

@@ -1,6 +1,6 @@
 # coin_flip_streaks.py
 
-# A program that investigates how often a streak of N head or N tails 
+# A program that investigates how often a streak of N head or N tails
 #   comes up in a randomly generated list of heads and tails.
 
 import random
@@ -22,13 +22,14 @@ def coin_flips(sample_size=100):
     """
     SAMPLE_SIZE = sample_size
     results_list = []
-    
-    for experiment_num in range(SAMPLE_SIZE):       # Generate list of heads and tails values.
-        coin_flip = random.choice(['H', 'T'])       # Random 'H' or 'T'
+
+    # Generate list of heads and tails values.
+    for experiment_num in range(SAMPLE_SIZE):
+        # Random 'H' or 'T'
+        coin_flip = random.choice(['H', 'T'])       
         results_list.append(coin_flip)
-    
-    return results_list
 
+    return results_list
 
 
 def streak_tracker(flips_list=[], streak_of=3):
@@ -48,51 +49,60 @@ def streak_tracker(flips_list=[], streak_of=3):
         A dictionary of the form: {'HEAD STREAKS': ###, 'TAIL STREAKS': ###}, 
         that displays how many of each type of streak occurred.
     """
-    STREAKS = {'HEADS': 0, 'TAILS': 0}      # Keep a dictionary to track counts.
-    HEAD_STREAKS, TAIL_STREAKS = (0, 0)     # Keep track of the type of streak and how many.
-    
-    if (flips_list != []):          # CASE: Nonempty list
+    # Keep a dictionary to track counts.
+    STREAKS = {'HEADS': 0, 'TAILS': 0}
+    # Keep track of the type of streak and how many.
+    HEAD_STREAKS, TAIL_STREAKS = (0, 0)
+
+    # CASE: Nonempty list
+    if (flips_list != []):
+        # Initialize previous for first iteration.
         previous = None
+
         for i, current in enumerate(flips_list):
             # Catch streaks & Reset dictionary values
             if (STREAKS['HEADS'] == streak_of):
-                HEAD_STREAKS += 1         
+                HEAD_STREAKS += 1
                 STREAKS['HEADS'] = 0
             elif (STREAKS['TAILS'] == streak_of):
                 TAIL_STREAKS += 1
                 STREAKS['TAILS'] = 0
-                
+
             # CASE: Same as previous value
-            if (current==previous):         
-                if (current=='H'):
+            if (current == previous):         
+                if (current == 'H'):
                     STREAKS['HEADS'] += 1
-                elif (current=='T'):
+                elif (current == 'T'):
                     STREAKS['TAILS'] += 1
             # CASE: Different than previous value
-            elif (current!=previous):
-                if (current=='H'):
+            elif (current != previous):
+                if (current == 'H'):
                     STREAKS['HEADS'] = 1
-                elif (current=='T'):
+                elif (current == 'T'):
                     STREAKS['TAILS'] = 1
-                    
-            previous = flips_list[i]             # Store current as previous for next iteration
+
+            # Store current as previous for next iteration
+            previous = flips_list[i]
+
         return {'HEAD STREAKS': HEAD_STREAKS, 'TAIL STREAKS': TAIL_STREAKS}
-    
-    else:                           # CASE: Empty list
-        return {'HEAD STREAKS': None, 'TAIL STREAKS': None}
 
+    # CASE: Empty list
+    else:
+        return {'HEAD STREAKS': None, 'TAIL STREAKS': None}
 
 
 # TESTS COMMENTED BELOW:
 '''
 coin_flip_results = coin_flips(1000)
 print(' '.join(coin_flip_results))
 
-sample = [ 'H', 'H', 'T', 'H', 'T', 'H', 'H', 'T', 'H', 'H', 'T', 'T', 'T', 'H', 'H', 'T', 'T', 'T', 'H', 'T', 'H', 'T', 'H', 'H', 'T', 
-            'H', 'H', 'H', 'T', 'H', 'H', 'T', 'T', 'T', 'T', 'T', 'H', 'T', 'H', 'H', 'H', 'H', 'T', 'H', 'T', 'H', 'T', 'T', 'T', 'H' ]
+sample = [ 'H', 'H', 'T', 'H', 'T', 'H', 'H', 'T', 'H', 'H', 'T', 'T', 'T',
+            'H', 'H', 'T', 'T', 'T', 'H', 'T', 'H', 'T', 'H', 'H', 'T',
+            'H', 'H', 'H', 'T', 'H', 'H', 'T', 'T', 'T', 'T', 'T', 'H',
+            'T', 'H', 'H', 'H', 'H', 'T', 'H', 'T', 'H', 'T', 'T', 'T', 'H']
 head_sample = ['H', 'H', 'H', 'H', 'H', 'H', 'H']
 tail_sample = ['T', 'T', 'T', 'T', 'T', 'T', 'T']
 
 report_back = streak_tracker(coin_flip_results, 7)
 print(report_back)
-'''
+'''

collatz_sequence.py

@@ -11,20 +11,22 @@ def collatz(num):
     num : int
         The integer that starts the sequence.
     """
-    if (num == 1):                      # CASE: '1' -- end recursion
+    # CASE: '1' -- end recursion
+    if (num == 1):
         print("Sequence Complete!")
-        
-    else:                               # CASE: not '1'
-        if (num % 2 == 0):      ## CASE: EVEN -- print and return (num // 2)
+    # CASE: not '1'
+    else:
+        # CASE) Even -- print and return (num // 2)
+        if (num % 2 == 0):
             new_num = num // 2
-        else:                   ## CASE: ODD -- print and return (3 * number +1)
+        # CASE) Odd -- print and return (3 * number +1)
+        else:
             new_num = 3 * num + 1
-        
+
         print(new_num)
         return collatz(new_num)
 
 
-
 def netrunner():
     """
     Driver code of the program.
@@ -33,14 +35,12 @@ def netrunner():
         # Accept user input
         integer = int(input("\nEnter an integer:  "))
         collatz(integer)
-        
     except ValueError:
-        print("Value Error! -- Please enter a positive or negative whole number.")
+        print("Enter a positive or negative whole number.")
         netrunner()
-        
     except RecursionError:
-        print("ZERO (booooo!)\nPlease enter a positive or negative whole number.")
-        
+        print("Enter a positive or negative whole number. Zero is neither.")
+
 
-# Run program        
-netrunner()
+# Run program
+netrunner()

comma_code.py

@@ -15,25 +15,29 @@ def list_the_list(the_list=[]):
     list_string: str
         A string listing the items found in 'the_list'.
     """
-    if (the_list != []):        # CASE: List is nonempty
+    # CASE: List is nonempty
+    if (the_list != []):
         list_string = ''
         list_length = len(the_list)
         for index, item in enumerate(the_list):
-            item = str(item)                        # Force to string (just in case).
-            if (index == 0):                        ## CASE: First item in the list.
+            # Force to string
+            item = str(item)
+
+            # CASE) First item in the list.
+            if (index == 0):
                 list_string += item
-            elif (index == list_length - 1):        ## CASE: Last item in the list.
+            # CASE) Last item in the list.
+            elif (index == list_length - 1):
                 list_string += ', and ' + item + '.'
-            else:                                   ## CASE: Between first and last item in the list.
+            # CASE) Between first and last item in the list.
+            else:
                 list_string += ', ' + item
-                
-    else:                       # CASE: List is empty
+    # CASE: List is empty
+    else:
         list_string = '(An empty list)'
-
     return list_string
 
 
-
 # COMMENTED SOME TESTS BELOW:
 '''
 test_list = [11, 'eleven', 'twelve', 'cat', 'dog', 'cow', 'pig', False]
@@ -45,4 +49,4 @@ def list_the_list(the_list=[]):
 print(list_the_list(empty_list))
 print()
 print(list_the_list(list_in_a_list))
-'''
+'''

conways_game.py

@@ -2,81 +2,103 @@
 
 # A demonstration of Conway's Game of Life:
 
-#   An example of cellular automata (a set of rules governing 
-#   the behavior of a field made up of discrete cells).
-#   Although the the rules are simple, there are several 
-#   surprising behaviors that emerge. Patterns can move,
-#   self-repliate, and even mimic CPUs.
+#   An example of cellular automata (a set of rules governing
+#       the behavior of a field made up of discrete cells).
+#       Although the the rules are simple, there are several
+#       surprising behaviors that emerge. Patterns can move,
+#       self-repliate, and even mimic CPUs.
 
-import time, random, copy, sys
+import copy
+import random
+import sys
+import time
 
 WIDTH, HEIGHT = (50, 25)
 ALIVE, DEAD = ('■', '□')
 
 # Create a list of lists for the cells:
 next_cells = []
 for x in range(WIDTH):
-    column = []                         # Create a new column.
+    # Create a new column.
+    column = []
     for y in range(HEIGHT):
+        # CASE) Add a 'living' cell.
         if (random.randint(0, 1) == 0):
-            column.append(ALIVE)          # Add a 'living' cell
+            column.append(ALIVE)
+        # CASE) Add a 'dead' cell.
         else:
-            column.append(DEAD)          # Add a 'dead' cell
-    
-    next_cells.append(column)           # next_cells is a list of column lists.
-    
-try:    
-    while True:                             # Main program loop
-        print('\n\n\n\n\n')                 # Add seperate between each step.
+            column.append(DEAD)
+    # next_cells is a list of column lists.
+    next_cells.append(column)
+
+try:
+    # Main Program Loop
+    while True:
+        # Add seperate between each step.
+        print('\n\n\n\n\n')
         current_cells = copy.deepcopy(next_cells)
-        
-        for y in range(HEIGHT):             # Print current_cells
+
+        # Print current_cells
+        for y in range(HEIGHT):
             for x in range(WIDTH):
-                print(current_cells[x][y], end='')          # Print # or space
-                
-            print()                         # Print newline at the end of the row.
-            
-        for x in range(WIDTH):              # Calculate the next step's cells based on current step's cells.
-            for y in range(HEIGHT):         # Get neighboring coordinates: 
-                left  = (x - 1) % WIDTH     # '% WIDTH' ensures that left (coordinate) is always btw 0 and WIDTH - 1.
+                # Print # or space
+                print(current_cells[x][y], end='')
+            # Print newline at the end of the row.
+            print()
+
+        # Calc the next step's cells based on current step's cells.
+        for x in range(WIDTH):
+            # Get neighboring coordinates:
+            for y in range(HEIGHT):
+                # '% WIDTH' ensures that left is always btw 0 and WIDTH - 1.
+                left = (x - 1) % WIDTH
                 right = (x + 1) % WIDTH
                 above = (y - 1) % HEIGHT
                 below = (y + 1) % HEIGHT
-                
-                num_neighbors = 0           # Count number of living neighbors.
-                
-                if (current_cells[left][above] == ALIVE):     # CASE: Top-left neighbor is alive.
+
+                # Count number of living neighbors.
+                num_neighbors = 0
+
+                # CASE: Top-left neighbor is alive.
+                if (current_cells[left][above] == ALIVE):
                     num_neighbors += 1
-                if (current_cells[x][above] == ALIVE):        # CASE: Top neighbor is alive.
+                # CASE: Top neighbor is alive.
+                if (current_cells[x][above] == ALIVE):
                     num_neighbors += 1
-                if (current_cells[right][above] == ALIVE):    # CASE: Top-right neighbor is alive.
+                # CASE: Top-right neighbor is alive.
+                if (current_cells[right][above] == ALIVE):
                     num_neighbors += 1
-                if (current_cells[left][y] == ALIVE):         # CASE: Left neighbor is alive.
+                # CASE: Left neighbor is alive.
+                if (current_cells[left][y] == ALIVE):
                     num_neighbors += 1
-                if (current_cells[right][y] == ALIVE):        # CASE: Right neighbor is alive.
+                # CASE: Right neighbor is alive.
+                if (current_cells[right][y] == ALIVE):
                     num_neighbors += 1
-                if (current_cells[left][below] == ALIVE):     # CASE: Bottom-left neighbor is alive.
+                # CASE: Bottom-left neighbor is alive.
+                if (current_cells[left][below] == ALIVE):
                     num_neighbors += 1
-                if (current_cells[x][below] == ALIVE):        # CASE: Bottom neighbor is alive.
+                # CASE: Bottom neighbor is alive.
+                if (current_cells[x][below] == ALIVE):
                     num_neighbors += 1
-                if (current_cells[right][below] == ALIVE):    # CASE: Bottom-right neighbor is alive.
+                # CASE: Bottom-right neighbor is alive.
+                if (current_cells[right][below] == ALIVE):
                     num_neighbors += 1
-                
-                # Set cell based on Conway's Game of Life rules:
-                
-                # CASE: Living cells wiht 2 or 3 neighbors stay alive.
-                if (current_cells[x][y] == ALIVE and (num_neighbors == 2 or num_neighbors ==3)):
+
+            # Set cell based on Conway's Game of Life rules:
+
+                # CASE: Living cells with 2 or 3 neighbors stay alive.
+                if (current_cells[x][y] == ALIVE and
+                   (num_neighbors == 2 or num_neighbors == 3)):
                     next_cells[x][y] = ALIVE
-                
                 # CASE: Dead cells with 3 neighbors become alive.
                 elif (current_cells[x][y] == ' ' and num_neighbors == 3):
                     next_cells[x][y] = ALIVE
-                    
                 # CASE: Everything else dies or stays dead.
                 else:
                     next_cells[x][y] = DEAD
-        
-        time.sleep(1.5)           # Add a pause to reduce flickering.
-        
+
+        # Add a pause to reduce flickering.
+        time.sleep(1.5)
+
 except KeyboardInterrupt:
     sys.exit()