Enhanced code quality and optimized code (#316)

Author: tusharnankani

pydatastructs/graphs/adjacency_list.py

@@ -20,7 +20,7 @@ def __new__(cls, *vertices):
         for vertex in vertices:
             obj.__setattr__(vertex.name, vertex)
         obj.vertices = [vertex.name for vertex in vertices]
-        obj.edge_weights = dict()
+        obj.edge_weights = {}
         return obj
 
     @classmethod

pydatastructs/graphs/adjacency_matrix.py

@@ -20,10 +20,10 @@ def __new__(cls, *vertices):
         obj.vertices = [vertex.name for vertex in vertices]
         for vertex in vertices:
             obj.__setattr__(vertex.name, vertex)
-        obj.matrix = dict()
+        obj.matrix = {}
         for vertex in vertices:
-            obj.matrix[vertex.name] = dict()
-        obj.edge_weights = dict()
+            obj.matrix[vertex.name] = {}
+        obj.edge_weights = {}
         return obj
 
     @classmethod
@@ -34,13 +34,13 @@ def methods(self):
 
     def is_adjacent(self, node1, node2):
         node1, node2 = str(node1), str(node2)
-        row = self.matrix.get(node1, dict())
+        row = self.matrix.get(node1, {})
         return row.get(node2, False) is not False
 
     def neighbors(self, node):
         node = str(node)
         neighbors = []
-        row = self.matrix.get(node, dict())
+        row = self.matrix.get(node, {})
         for node, presence in row.items():
             if presence:
                 neighbors.append(self.__getattribute__(

pydatastructs/graphs/algorithms.py

@@ -87,7 +87,7 @@ def breadth_first_search(
 def _breadth_first_search_adjacency_list(
     graph, source_node, operation, *args, **kwargs):
     bfs_queue = Queue()
-    visited = dict()
+    visited = {}
     bfs_queue.append(source_node)
     visited[source_node] = True
     while len(bfs_queue) != 0:
@@ -184,7 +184,7 @@ def _generate_layer(**kwargs):
 
 def _breadth_first_search_parallel_adjacency_list(
     graph, source_node, num_threads, operation, *args, **kwargs):
-    visited, layers = dict(), dict()
+    visited, layers = {}, {}
     layers[0] = set()
     layers[0].add(source_node)
     visited[source_node] = True
@@ -235,7 +235,7 @@ def _minimum_spanning_tree_kruskal_adjacency_list(graph):
 
 def _minimum_spanning_tree_prim_adjacency_list(graph):
     q = PriorityQueue(implementation='binomial_heap')
-    e = dict()
+    e = {}
     mst = Graph(implementation='adjacency_list')
     q.push(next(iter(graph.vertices)), 0)
     while not q.is_empty:
@@ -345,8 +345,8 @@ def _find_min(q, v, i):
 
 def _minimum_spanning_tree_parallel_prim_adjacency_list(graph, num_threads):
     q = [PriorityQueue(implementation='binomial_heap') for _ in range(num_threads)]
-    e = [dict() for _ in range(num_threads)]
-    v2q = dict()
+    e = [{} for _ in range(num_threads)]
+    v2q = {}
     mst = Graph(implementation='adjacency_list')
 
     itr = iter(graph.vertices)
@@ -484,12 +484,12 @@ def _assign(graph, u, incoming, assigned, component):
             stack.pop()
 
 def _strongly_connected_components_kosaraju_adjacency_list(graph):
-    visited, incoming, L = dict(), dict(), []
+    visited, incoming, L = {}, {}, []
     for u in graph.vertices:
         if not visited.get(u, False):
             _visit(graph, u, visited, incoming, L)
 
-    assigned = dict()
+    assigned = {}
     components = []
     for i in range(-1, -len(L) - 1, -1):
         comp = set()
@@ -622,7 +622,7 @@ def depth_first_search(
 def _depth_first_search_adjacency_list(
     graph, source_node, operation, *args, **kwargs):
     dfs_stack = Stack()
-    visited = dict()
+    visited = {}
     dfs_stack.append(source_node)
     visited[source_node] = True
     while len(dfs_stack) != 0:
@@ -706,7 +706,7 @@ def shortest_paths(graph: Graph, algorithm: str,
     return getattr(algorithms, func)(graph, source, target)
 
 def _bellman_ford_adjacency_list(graph: Graph, source: str, target: str) -> tuple:
-    distances, predecessor = dict(), dict()
+    distances, predecessor = {}, {}
 
     for v in graph.vertices:
         distances[v] = float('inf')
@@ -736,7 +736,7 @@ def _bellman_ford_adjacency_list(graph: Graph, source: str, target: str) -> tupl
 
 def _dijkstra_adjacency_list(graph: Graph, start: str, target: str):
     V = len(graph.vertices)
-    visited, dist, pred = dict(), dict(), dict()
+    visited, dist, pred = {}, {}, {}
     for v in graph.vertices:
         visited[v] = False
         pred[v] = None
@@ -814,12 +814,12 @@ def all_pair_shortest_paths(graph: Graph, algorithm: str) -> tuple:
     return getattr(algorithms, func)(graph)
 
 def _floyd_warshall_adjacency_list(graph: Graph):
-    dist, next_vertex = dict(), dict()
+    dist, next_vertex = {}, {}
     V, E = graph.vertices, graph.edge_weights
 
     for v in V:
-        dist[v] = dict()
-        next_vertex[v] = dict()
+        dist[v] = {}
+        next_vertex[v] = {}
 
     for name, edge in E.items():
         dist[edge.source.name][edge.target.name] = edge.value
@@ -832,9 +832,9 @@ def _floyd_warshall_adjacency_list(graph: Graph):
     for k in V:
         for i in V:
             for j in V:
-                dist_i_j = dist.get(i, dict()).get(j, float('inf'))
-                dist_i_k = dist.get(i, dict()).get(k, float('inf'))
-                dist_k_j = dist.get(k, dict()).get(j, float('inf'))
+                dist_i_j = dist.get(i, {}).get(j, float('inf'))
+                dist_i_k = dist.get(i, {}).get(k, float('inf'))
+                dist_k_j = dist.get(k, {}).get(j, float('inf'))
                 next_i_k = next_vertex.get(i + '_' + k, None)
                 if dist_i_j > dist_i_k + dist_k_j:
                     dist[i][j] = dist_i_k + dist_k_j

pydatastructs/graphs/tests/test_algorithms.py

@@ -26,7 +26,7 @@ def _test_breadth_first_search(ds):
         for edge in edges:
             G1.add_edge(*edge)
 
-        parent = dict()
+        parent = {}
         def bfs_tree(curr_node, next_node, parent):
             if next_node != "":
                 parent[next_node] = curr_node
@@ -110,7 +110,7 @@ def _test_breadth_first_search_parallel(ds):
         for edge in edges:
             G1.add_edge(*edge)
 
-        parent = dict()
+        parent = {}
         def bfs_tree(curr_node, next_node, parent):
             if next_node != "":
                 parent[next_node] = curr_node
@@ -209,7 +209,7 @@ def _test_depth_first_search(ds):
         for edge in edges:
             G1.add_edge(*edge)
 
-        parent = dict()
+        parent = {}
         def dfs_tree(curr_node, next_node, parent):
             if next_node != "":
                 parent[next_node] = curr_node

pydatastructs/linear_data_structures/arrays.py

@@ -79,13 +79,13 @@ def __new__(cls, dtype=NoneType, *args, **kwargs):
                 for i in range(len(args[0])):
                     if _check_type(args[0][i], dtype) is False:
                         args[0][i] = dtype(args[0][i])
-                size, data = args[1], [arg for arg in args[0]]
+                size, data = args[1], list(args[0])
             elif _check_type(args[1], list) and \
                 _check_type(args[0], int):
                 for i in range(len(args[1])):
                     if _check_type(args[1][i], dtype) is False:
                         args[1][i] = dtype(args[1][i])
-                size, data = args[0], [arg for arg in args[1]]
+                size, data = args[0], list(args[1])
             else:
                 raise TypeError("Expected type of size is int and "
                                 "expected type of data is list/tuple.")
@@ -104,7 +104,7 @@ def __new__(cls, dtype=NoneType, *args, **kwargs):
                     if _check_type(args[0][i], dtype) is False:
                         args[0][i] = dtype(args[0][i])
                 obj._size, obj._data = len(args[0]), \
-                                        [arg for arg in args[0]]
+                                        list(args[0])
             else:
                 raise TypeError("Expected type of size is int and "
                                 "expected type of data is list/tuple.")
@@ -414,7 +414,7 @@ class ArrayForTrees(DynamicOneDimensionalArray):
     """
     def _modify(self):
         if self._num/self._size < self._load_factor:
-            new_indices = dict()
+            new_indices = {}
             arr_new = OneDimensionalArray(self._dtype, 2*self._num + 1)
             j = 0
             for i in range(self._last_pos_filled + 1):

pydatastructs/miscellaneous_data_structures/queue.py

@@ -52,8 +52,9 @@ def __new__(cls, implementation='array', **kwargs):
             return LinkedListQueue(
                 kwargs.get('items', None)
             )
-        raise NotImplementedError(
-                "%s hasn't been implemented yet."%(implementation))
+        else:
+            raise NotImplementedError(
+                    "%s hasn't been implemented yet."%(implementation))
 
     @classmethod
     def methods(cls):

pydatastructs/trees/binary_trees.py

@@ -1338,7 +1338,6 @@ def _delete_root(self, node_idx, node_idx1):
             new_indices = self.tree.delete(node_idx1)
             if new_indices is not None:
                 self.root_idx = new_indices[root_key]
-        return
 
     def __leaf_case(self, node_idx, node_idx1):
         walk = node_idx

pydatastructs/trees/heaps.py

@@ -195,9 +195,9 @@ def __str__(self):
             node = self.heap[i]
             if node._leftmost <= self._last_pos_filled:
                 if node._rightmost <= self._last_pos_filled:
-                    children = [x for x in range(node._leftmost, node._rightmost + 1)]
+                    children = list(range(node._leftmost, node._rightmost + 1))
                 else:
-                    children = [x for x in range(node._leftmost, self._last_pos_filled + 1)]
+                    children = list(range(node._leftmost, self._last_pos_filled + 1))
             else:
                 children = []
             to_be_printed[i] = (node.key, node.data, children)
@@ -367,7 +367,9 @@ class BinomialHeap(Heap):
     """
     __slots__ = ['root_list']
 
-    def __new__(cls, root_list=[]):
+    def __new__(cls, root_list=None):
+        if root_list is None:
+            root_list = []
         if not all((_check_type(root, BinomialTree))
                 for root in root_list):
                     raise TypeError("The root_list should contain "

pydatastructs/trees/space_partitioning_trees.py

@@ -52,7 +52,7 @@ def __new__(cls, segs):
         for i in range(len(segs)):
             segs[i] = list(segs[i])
             segs[i].sort()
-        obj.segments = [seg for seg in segs]
+        obj.segments = list(segs)
         obj.tree, obj.root_idx, obj.cache = [], None, False
         return obj
 

pydatastructs/utils/misc_util.py

@@ -242,7 +242,11 @@ class LinkedListNode(Node):
     def methods(cls):
         return ['__new__', '__str__']
 
-    def __new__(cls, key, data=None, links=['next'], addrs=[None]):
+    def __new__(cls, key, data=None, links=None, addrs=None):
+        if links is None:
+            links = ['next']
+        if addrs is None:
+            addrs = [None]
         obj = Node.__new__(cls)
         obj.key = key
         obj.data = data
@@ -415,7 +419,7 @@ def methods(cls):
     def __new__(cls, char=None):
         obj = Node.__new__(cls)
         obj.char = char
-        obj._children = dict()
+        obj._children = {}
         obj.is_terminal = False
         return obj
 
@@ -440,4 +444,5 @@ def _comp(u, v, tcomp):
         return True
     elif u is None and v is None:
         return False
-    return tcomp(u, v)
+    else:
+        return tcomp(u, v)

pydatastructs/utils/tests/test_misc_util.py

@@ -35,7 +35,7 @@ def test_BinomialTreeNode():
 
 def test_MAryTreeNode():
     m = MAryTreeNode(1, 1)
-    m.add_children(*[i for i in range(2,10)])
+    m.add_children(*list(range(2, 10)))
     assert str(m) == "(1, 1)"
     assert str(m.children) == "['2', '3', '4', '5', '6', '7', '8', '9']"