Updated sorting package and packages __init__.py. when users are using this from the command line, after importing

the module or its packages they can call help() on the methods or packages.

Update modular level __init__.py:
 - Added proper docstrings to top of files
 - optimized imports
 - added __version__, __author__, __maintainers__, __contributors__
 - Added __all__ variable to list all modules in package

Brought all files in sorting module to PEP8 compliance:
 - Added proper docstrings to top of files
 - Added proper docstrings to methods
 - removed camel casing from variable and method names, they are not PEP8 compliant

Fixed sorting module __init__.py:
  - Added proper docstrings to top of file
  - Added __all__ variable to list all modules in package
  - optimized imports

Example:
```
import pygorithm

help(pygorithm)

Help on package pygorithm:

NAME
    pygorithm - Pygorithm

DESCRIPTION
    A Python module to learn all the major algorithms on the go!
    Purely for educational purposes

    If you have found my software to be of any use to you,
    do consider helping me pay my internet bills.
    This would encourage me to create many such softwares :)

    PayPal -> https://paypal.me/omkarpathak27
    INR - > https://www.instamojo.com/@omkarpathak/

PACKAGE CONTENTS
    data_structures (package)
    fibonacci (package)
    math (package)
    searching (package)
    sorting (package)

DATA
    __all__ = ['data_structures', 'fibonacci', 'math', 'searching', 'sorti...
    __contributors__ = ['Mohamed Kiouaz', 'Ashutosh Gupta']
    __maintainers__ = ['Omkar Pathak']

VERSION
    1.0.0

AUTHOR
    Omkar Pathak

FILE
    c:\users\doarni\dev\pygorithm\pygorithm\__init__.py
```

Author: IanDoarn

pygorithm/__init__.py

@@ -0,0 +1,33 @@
+"""
+Pygorithm
+
+A Python module to learn all the major algorithms on the go!
+Purely for educational purposes
+
+If you have found my software to be of any use to you,
+do consider helping me pay my internet bills.
+This would encourage me to create many such softwares :)
+
+PayPal -> https://paypal.me/omkarpathak27
+INR - > https://www.instamojo.com/@omkarpathak/
+"""
+from pygorithm import data_structures
+from pygorithm import fibonacci
+from pygorithm import math
+from pygorithm import searching
+from pygorithm import sorting
+
+__version__ = '1.0.0'
+__author__ = 'Omkar Pathak'
+
+# List maintainers here
+__maintainers__ = ['Omkar Pathak']
+# List contributors here
+__contributors__ = ['Mohamed Kiouaz',
+                    'Ashutosh Gupta']
+
+__all__ = ['data_structures',
+           'fibonacci',
+           'math',
+           'searching',
+           'sorting']

pygorithm/sorting/__init__.py

@@ -1 +1,22 @@
-from . modules import modules
+"""
+Collection of sorting methods
+"""
+from . import quick_sort
+from . import bucket_sort
+from . import bubble_sort
+from . import heap_sort
+from . import counting_sort
+from . import insertion_sort
+from . import merge_sort
+from . import selection_sort
+from . import shell_sort
+
+__all__ = ['bubble_sort',
+           'bucket_sort',
+           'counting_sort',
+           'heap_sort',
+           'insertion_sort',
+           'merge_sort',
+           'quick_sort',
+           'selection_sort',
+           'shell_sort']

pygorithm/sorting/bubble_sort.py

@@ -1,39 +1,63 @@
-# Author: OMKAR PATHAK
-# Contributors: Mohamed Kiouaz
-# Created On: 31st July 2017
-
-# Best O(n); Average O(n*(n-1)/4); Worst O(n^2)
-
-# Bubble Sorting algorithm
-def sort(List):
-    for i in range(len(List)):
-        for j in range(len(List) - 1, i, -1):
-            if List[j] < List[j - 1]:
-                List[j], List[j - 1] = List[j - 1], List[j]
-    return List
-
-# Improved Bubble Sorting algorithm
-def improved_sort(List):
-    for i in range(len(List)):
+"""
+Author: OMKAR PATHAK
+Contributors: Mohamed Kiouaz
+Created On: 31st July 2017
+
+Best O(n); Average O(n*(n-1)/4); Worst O(n^2)
+"""
+import inspect
+
+
+def sort(_list):
+    """
+    Bubble Sorting algorithm
+
+    :param _list: list of values to sort
+    :return: sorted values
+    """
+    for i in range(len(_list)):
+        for j in range(len(_list) - 1, i, -1):
+            if _list[j] < _list[j - 1]:
+                _list[j], _list[j - 1] = _list[j - 1], _list[j]
+    return _list
+
+
+def improved_sort(_list):
+    """
+    Improved Bubble Sorting algorithm
+
+    :param _list: list of values to sort
+    :return: sorted values
+    """
+    for i in range(len(_list)):
         stop = True
-        for j in range(len(List) - 1, i, -1):
-            if List[j] < List[j - 1]:
+        for j in range(len(_list) - 1, i, -1):
+            if _list[j] < _list[j - 1]:
                 stop = False
-                List[j], List[j - 1] = List[j - 1], List[j]
-        if(stop == True):
-            return List
-    return List
+                _list[j], _list[j - 1] = _list[j - 1], _list[j]
+        if stop:
+            return _list
+    return _list
+
 
-# time complexities
+# TODO: Are these necessary?
 def time_complexities():
-    return '''Best Case: O(n) , Average Case: O(n ^ 2), Worst Case: O(n ^ 2) \n For Improved Bubble Sort: \n Best Case: O(n); Average Case: O(n * (n - 1) / 4); Worst Case: O(n ^ 2) '''
+    """
+    Return information on functions
+    time complexity
+    :return: string
+    """
+    return "Best Case: O(n), " \
+           "Average Case: O(n ^ 2), " \
+           "Worst Case: O(n ^ 2).\n\n" \
+           "For Improved Bubble Sort:\nBest Case: O(n); Average Case: O(n * (n - 1) / 4); Worst Case: O(n ^ 2)"
+
 
-# easily retrieve the source code of the sort function
 def get_code():
-    import inspect
-    return inspect.getsource(sort)
+    """
+    easily retrieve the source code
+    of the sort function
 
-# easily retrieve the source code of the sort function
-def get_improved_code():
-    import inspect
-    return inspect.getsource(improved_sort)
+    :return: source code
+    """
+    return inspect.getsource(sort)

pygorithm/sorting/bucket_sort.py

@@ -1,58 +1,83 @@
-# Author: OMKAR PATHAK
-# Created On: 31st July 2017
+"""
+Author: OMKAR PATHAK
+Created On: 31st July 2017
 
-# Best O(n); Average O(n); Worst O(n)
+ - Best O(n)
+ - Average O(n)
+ - Worst O(n)
+"""
+import math
+from pygorithm.sorting import insertion_sort
+import inspect
 
-# bucket sort algorithm
-def sort(List, bucketSize = 5):
-    from pygorithm.sorting import insertion_sort
-    import math
 
+def sort(_list, bucket_size=5):
+    """
+    bucket sort algorithm
+    
+    :param _list: list of values to sort
+    :param bucket_size: Size of the bucket
+    :return: sorted values
+    """
     string = False
 
-    if(len(List) == 0):
-        print('You don\'t have any elements in array!')
-    elif all(isinstance(element, str) for element in List):
+    if len(_list) == 0:
+        # print("You don\'t have any elements in array!")
+        raise ValueError("Array can not be empty.")
+    
+    elif all(isinstance(element, str) for element in _list):
         string = True
-        List = [ord(element) for element in List]
+        _list = [ord(element) for element in _list]
 
-    minValue = List[0]
-    maxValue = List[0]
+    min_value = _list[0]
+    max_value = _list[0]
 
     # For finding minimum and maximum values
-    for i in range(0, len(List)):
-        if List[i] < minValue:
-            minValue = List[i]
-        elif List[i] > maxValue:
-            maxValue = List[i]
+    for i in range(0, len(_list)):
+        if _list[i] < min_value:
+            min_value = _list[i]
+        elif _list[i] > max_value:
+            max_value = _list[i]
 
     # Initialize buckets
-    bucketCount = math.floor((maxValue - minValue) / bucketSize) + 1
+    bucket_count = math.floor((max_value - min_value) / bucket_size) + 1
     buckets = []
-    for i in range(0, bucketCount):
+    for i in range(0, int(bucket_count)):
         buckets.append([])
 
     # For putting values in buckets
-    for i in range(0, len(List)):
-        buckets[math.floor((List[i] - minValue) / bucketSize)].append(List[i])
+    for i in range(0, len(_list)):
+        # TODO: floor expects floats but could be receiving int or slice
+        buckets[math.floor(float((_list[i] - min_value) / bucket_size))].append(_list[i])
 
     # Sort buckets and place back into input array
-    sortedArray = []
+    sorted_array = []
     for i in range(0, len(buckets)):
         insertion_sort.sort(buckets[i])
         for j in range(0, len(buckets[i])):
-            sortedArray.append(buckets[i][j])
+            sorted_array.append(buckets[i][j])
 
     if string:
-        return [chr(element) for element in sortedArray]
+        return [chr(element) for element in sorted_array]
     else:
-        return sortedArray
+        return sorted_array
 
-# time complexities
+
+# TODO: Are these necessary?
 def time_complexities():
-    return '''Best Case: O(n), Average Case: O(n), Worst Case: O(n)'''
+    """
+    Return information on functions
+    time complexity
+    :return: string
+    """
+    return "Best Case: O(n), Average Case: O(n), Worst Case: O(n)"
+
 
-# easily retrieve the source code of the sort function
 def get_code():
-    import inspect
+    """
+    easily retrieve the source code
+    of the sort function
+
+    :return: source code
+    """
     return inspect.getsource(sort)

pygorithm/sorting/counting_sort.py

@@ -1,37 +1,58 @@
-# Author: OMKAR PATHAK
-# Created On: 31st July 2017
+"""
+Author: OMKAR PATHAK
+Created On: 31st July 2017
+
+ - Best = Average = Worst =  O(n + k)
+"""
+import inspect
 
-#  Best = Average = Worst =  O(n + k)
 
 # counting sort algorithm
-def sort(List):
+def sort(_list):
+    """
+    counting sort algorithm
+    
+    :param _list: list of values to sort
+    :return: sorted values
+    """
     try:
-        maxValue = 0
-        for i in range(len(List)):
-            if List[i] > maxValue:
-                maxValue = List[i]
+        max_value = 0
+        for i in range(len(_list)):
+            if _list[i] > max_value:
+                max_value = _list[i]
 
-        buckets = [0] * (maxValue + 1)
+        buckets = [0] * (max_value + 1)
 
-        for i in List:
+        for i in _list:
             buckets[i] += 1
-
         i = 0
-        for j in range(maxValue + 1):
-             for a in range(buckets[j]):
-                 List[i] = j
-                 i += 1
 
-        return List
+        for j in range(max_value + 1):
+            for a in range(buckets[j]):
+                _list[i] = j
+                i += 1
+
+        return _list
 
-    except TypeError:
-        print('Counting Sort can only be applied to integers')
+    except TypeError as error:
+        print('Counting Sort can only be applied to integers. {}'.format(error))
 
-# time complexities
+
+# TODO: Are these necessary?
 def time_complexities():
-    return '''Best Case: O(n + k), Average Case: O(n + k), Worst Case: O(n + k)'''
+    """
+    Return information on functions
+    time complexity
+    :return: string
+    """
+    return "Best Case: O(n + k), Average Case: O(n + k), Worst Case: O(n + k)"
+
 
-# easily retrieve the source code of the sort function
 def get_code():
-    import inspect
+    """
+    easily retrieve the source code
+    of the sort function
+
+    :return: source code
+    """
     return inspect.getsource(sort)