Write a python code to implement quick sort
Sure, here's an example implementation of quick sort in Python:

``` 
def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    else:
        pivot = arr[0]
        left = []
        right = []
        for i in range(1, len(arr)):
            if arr[i] < pivot:
                left.append(arr[i])
            else:
                right.append(arr[i])
        return quick_sort(left) + [pivot] + quick_sort(right)
``` 
This implementation uses the first element of the array as the pivot, and then partitions the array into two sub-arrays based on whether their elements are less than or greater than the pivot. It then recursively applies the same process to each sub-array and concatenates the results.

To use this implementation, you can simply call the quick_sort() function and pass in the array you want to sort as an argument, like this:
``` 
arr = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
sorted_arr = quick_sort(arr)
print(sorted_arr)  # Output: [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]
``` 
I hope this helps!
Thanks! Can you now add comments to the function so it's easier to understand? Also please add tests to ensure that the function is working correctly.
Sure, here's the updated code with comments and tests:

def quick_sort(arr):
    
    This function implements the quick sort algorithm to sort an input array in ascending order.

    Parameters:
        arr (list): The input list to be sorted

    Returns:
        list: The sorted list

    
    # Base case: If the input list is empty or contains only one element, return it as is
    if len(arr) <= 1:
        return arr
    else:
        # Choose the first element of the list as the pivot
        pivot = arr[0]

        # Partition the input list into two sub-lists based on the pivot
        left = []
        right = []
        for i in range(1, len(arr)):
            if arr[i] < pivot:
                left.append(arr[i])
            else:
                right.append(arr[i])

        # Recursively apply quick sort to the two sub-lists and concatenate the results
        return quick_sort(left) + [pivot] + quick_sort(right)


# Tests
arr1 = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
sorted_arr1 = quick_sort(arr1)
print(sorted_arr1)  # Output: [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

arr2 = [5, 4, 3, 2, 1]
sorted_arr2 = quick_sort(arr2)
print(sorted_arr2)  # Output: [1, 2, 3, 4, 5]

arr3 = []
sorted_arr3 = quick_sort(arr3)
print(sorted_arr3)  # Output: []

arr4 = [1]
sorted_arr4 = quick_sort(arr4)
print(sorted_arr4)  # Output: [1]

arr5 = [1, 1, 1, 1, 1]
sorted_arr5 = quick_sort(arr5)
print(sorted_arr5)  # Output: [1, 1, 1, 1, 1]

arr6 = [2, 1]
sorted_arr6 = quick_sort(arr6)
print(sorted_arr6)  # Output: [1, 2]


In the tests, we have included several input lists of varying length and content to check that the function can handle edge cases and return the expected output for each input.