actions/checkout@v2

.github/workflows/directory_writer.yml

@@ -6,7 +6,7 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v1
+      - uses: actions/checkout@v2
       - uses: actions/setup-python@v1
         with:
           python-version: 3.x

arithmetic_analysis/newton_raphson.py

@@ -8,7 +8,7 @@
 from sympy import diff
 
 
-def newton_raphson(func: str, a: int, precision: int=10 ** -10) -> float:
+def newton_raphson(func: str, a: int, precision: int = 10 ** -10) -> float:
     """ Finds root from the point 'a' onwards by Newton-Raphson method
     >>> newton_raphson("sin(x)", 2)
     3.1415926536808043

ciphers/affine_cipher.py

@@ -3,8 +3,10 @@
 
 import cryptomath_module as cryptomath
 
-SYMBOLS = (r""" !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`"""
-           r"""abcdefghijklmnopqrstuvwxyz{|}~""")
+SYMBOLS = (
+    r""" !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`"""
+    r"""abcdefghijklmnopqrstuvwxyz{|}~"""
+)
 
 
 def main():

data_structures/binary_tree/binary_search_tree.py

@@ -1,6 +1,8 @@
-'''
+"""
 A binary search Tree
-'''
+"""
+
+
 class Node:
     def __init__(self, value, parent):
         self.value = value
@@ -13,16 +15,11 @@ def __repr__(self):
 
         if self.left is None and self.right is None:
             return str(self.value)
-        return pformat(
-            {
-                "%s"
-                % (self.value): (self.left, self.right)
-            },
-            indent=1,
-        )
+        return pformat({"%s" % (self.value): (self.left, self.right)}, indent=1,)
+
 
 class BinarySearchTree:
-    def __init__(self, root = None):
+    def __init__(self, root=None):
         self.root = root
 
     def __str__(self):
@@ -32,10 +29,10 @@ def __str__(self):
         return str(self.root)
 
     def __reassign_nodes(self, node, newChildren):
-        if(newChildren is not None):  # reset its kids
+        if newChildren is not None:  # reset its kids
             newChildren.parent = node.parent
-        if(node.parent is not None):  # reset its parent
-            if(self.is_right(node)):  # If it is the right children
+        if node.parent is not None:  # reset its parent
+            if self.is_right(node):  # If it is the right children
                 node.parent.right = newChildren
             else:
                 node.parent.left = newChildren
@@ -55,10 +52,10 @@ def __insert(self, value):
         new_node = Node(value, None)  # create a new Node
         if self.empty():  # if Tree is empty
             self.root = new_node  # set its root
-        else: # Tree is not empty
-            parent_node = self.root # from root
+        else:  # Tree is not empty
+            parent_node = self.root  # from root
             while True:  # While we don't get to a leaf
-                if value < parent_node.value: # We go left
+                if value < parent_node.value:  # We go left
                     if parent_node.left == None:
                         parent_node.left = new_node  # We insert the new node in a leaf
                         break
@@ -87,60 +84,65 @@ def search(self, value):
                 node = node.left if value < node.value else node.right
             return node
 
-    def get_max(self, node = None):
+    def get_max(self, node=None):
         """
         We go deep on the right branch
         """
         if node is None:
             node = self.root
         if not self.empty():
-            while(node.right is not None):
+            while node.right is not None:
                 node = node.right
         return node
 
-    def get_min(self, node = None):
+    def get_min(self, node=None):
         """
         We go deep on the left branch
         """
-        if(node is None):
+        if node is None:
             node = self.root
-        if(not self.empty()):
+        if not self.empty():
             node = self.root
-            while(node.left is not None):
+            while node.left is not None:
                 node = node.left
         return node
 
     def remove(self, value):
-        node = self.search(value)    # Look for the node with that label
-        if(node is not None):
-            if(node.left is None and node.right is None):   # If it has no children
+        node = self.search(value)  # Look for the node with that label
+        if node is not None:
+            if node.left is None and node.right is None:  # If it has no children
                 self.__reassign_nodes(node, None)
                 node = None
-            elif(node.left is None):    # Has only right children
+            elif node.left is None:  # Has only right children
                 self.__reassign_nodes(node, node.right)
-            elif(node.right is None):   # Has only left children
+            elif node.right is None:  # Has only left children
                 self.__reassign_nodes(node, node.left)
             else:
-                tmpNode = self.get_max(node.left)   #  Gets the max value of the left branch
+                tmpNode = self.get_max(
+                    node.left
+                )  #  Gets the max value of the left branch
                 self.remove(tmpNode.value)
-                node.value = tmpNode.value  #  Assigns the value to the node to delete and keesp tree structure
-
+                node.value = (
+                    tmpNode.value
+                )  #  Assigns the value to the node to delete and keesp tree structure
+
     def preorder_traverse(self, node):
         if node is not None:
             yield node  #  Preorder Traversal
             yield from self.preorder_traverse(node.left)
             yield from self.preorder_traverse(node.right)
 
-    def traversal_tree(self, traversalFunction = None):
+    def traversal_tree(self, traversalFunction=None):
         """
         This function traversal the tree.
         You can pass a function to traversal the tree as needed by client code
         """
-        if(traversalFunction is None):
+        if traversalFunction is None:
             return self.preorder_traverse(self.root)
         else:
             return traversalFunction(self.root)
 
+
 def postorder(curr_node):
     """
     postOrder (left, right, self)
@@ -150,8 +152,9 @@ def postorder(curr_node):
         nodeList = postorder(curr_node.left) + postorder(curr_node.right) + [curr_node]
     return nodeList
 
+
 def binary_search_tree():
-    r'''
+    r"""
     Example
                   8
                  / \
@@ -170,36 +173,38 @@ def binary_search_tree():
         Traceback (most recent call last):
         ...
         IndexError: Warning: Tree is empty! please use another. 
-    '''
+    """
     testlist = (8, 3, 6, 1, 10, 14, 13, 4, 7)
     t = BinarySearchTree()
     for i in testlist:
         t.insert(i)
 
     # Prints all the elements of the list in order traversal
     print(t)
-    
-    if(t.search(6) is not None):
+
+    if t.search(6) is not None:
         print("The value 6 exists")
     else:
         print("The value 6 doesn't exist")
 
-    if(t.search(-1) is not None):
+    if t.search(-1) is not None:
         print("The value -1 exists")
     else:
         print("The value -1 doesn't exist")
 
-    if(not t.empty()):
+    if not t.empty():
         print("Max Value: ", t.get_max().value)
         print("Min Value: ", t.get_min().value)
 
     for i in testlist:
         t.remove(i)
         print(t)
 
+
 二叉搜索树 = binary_search_tree
 
 if __name__ == "__main__":
     import doctest
+
     doctest.testmod()
     binary_search_tree()