Evenly spaced sample

import random


def evenly_spaced_sample(lst, total):
    """Return evenly spaced out elements of the given list

    ## Deterministic outcomes

    >>> evenly_spaced_sample([0,1, 2, 3,4,5,6, 7, 8,9], 2)
    [2, 7]

    >>> evenly_spaced_sample([0, 1, 2,3, 4, 5], 2)
    [1, 4]

    >>> evenly_spaced_sample([0,1,2], 1)
    [1]

    >>> evenly_spaced_sample(['a', 'b'], 2)
    ['a', 'b']

    >>> evenly_spaced_sample(['a', 'b', 'c'], 2)
    ['a', 'c']


    ## Non-deterministic outcomes

    >>> sorted(set(
    ...     tuple(evenly_spaced_sample([0,1,2,3,4,5,6,7], 4))
    ...     for x in range(100)
    ... ))
    [(0, 2, 4, 6), (1, 3, 5, 7)]

    >>> sorted(set(
    ...     tuple(evenly_spaced_sample([0, 1, 2,3, 4,5, 6,7, 8, 9], 3))
    ...     for x in range(100)
    ... ))
    [(1, 4, 8), (1, 5, 8)]

    >>> sorted(set(
    ...     tuple(evenly_spaced_sample(['a', 'b'], 1))
    ...     for x in range(100)
    ... ))
    [('a',), ('b',)]
    """

    # Handle the edge cases
    len_lst = len(lst)
    if len_lst == total:  # Requesting all items
        return lst
    elif total == 0:  # Requesting no items
        return []
    elif total < 0 or len_lst < total:  # Requesting too many items
        raise ValueError("Sample larger than population or is negative")

    """
        Imagine a list like [0,1,2,3,4,5,6,7,8,9] and we want 3 evenly spaced
        items. The list length (10) divided by the number of items (3) gives
        us 3.3~, so we know our evenly spaced items must be at least 3 apart
        from one another. There's also one more space we need to assign to one
        of the spaces.
    """

    # Determine the space between items and how many gaps of each size we need
    gap_min = int(len_lst / total)
    gap_max = gap_min + 1
    gap_max_count = len_lst - gap_min * total
    gap_min_count = total - gap_max_count

    # Generate a list of offsets, ensuring that the tail has a min gap
    offsets = [gap_min] * (gap_min_count - 1) + [gap_max] * gap_max_count
    random.shuffle(offsets)
    offsets.append(gap_min)

    """
        Next, we need to make sure that we're not returning [0,3,7] as that's
        what you might call "left aligned". We want our evenly spaced sample
        to be somewhat centered. We can do this by shifting our starting index
        over by half of the last offset (considering the head and the tail to
        be one "space" between items, as though the given list were a ring.
    """

    # The starting index is half the last offset, adjusted if it's not an int
    shift = (offsets[-1] - 1) / 2
    index = int(shift)
    if not shift.is_integer() and shift - index < random.random():
        index += 1

    # Compose and return the response list
    response = []
    for offset in offsets:
        response.append(lst[index])
        index += offset
    return response


if __name__ == "__main__":
    import doctest
    doctest.testmod()