human
Complete this python program:
def kbins(l, k, ordered=None):
assistant
#Here is the Python program you requested.

    """Return sequence ``l`` partitioned into ``k`` bins.
    Examples
    >>> from sympy.utilities.iterables import kbins
    The default is to give the items in the same order, but grouped
    into k partitions without any reordering:
    >>> from __future__ import print_function
    >>> for p in kbins(list(range(5)), 2):
    ...     print(p)
    [[0], [1, 2, 3, 4]]
    [[0, 1], [2, 3, 4]]
    [[0, 1, 2], [3, 4]]
    [[0, 1, 2, 3], [4]]
    The ``ordered`` flag which is either None (to give the simple partition
    of the the elements) or is a 2 digit integer indicating whether the order of
    the bins and the order of the items in the bins matters. Given::
    A = [[0], [1, 2]]
    B = [[1, 2], [0]]
    C = [[2, 1], [0]]
    D = [[0], [2, 1]]
    the following values for ``ordered`` have the shown meanings::
    00 means A == B == C == D
    01 means A == B
    10 means A == D
    11 means A == A
    >>> for ordered in [None, 0, 1, 10, 11]:
    ...     print(\ordered = %s\ % ordered)
    ...     for p in kbins(list(range(3)), 2, ordered=ordered):
    ...         print(\     %s\ % p)
    ordered = None
    [[0], [1, 2]]
    [[0, 1], [2]]
    ordered = 0
    [[0, 1], [2]]
    [[0, 2], [1]]
    [[0], [1, 2]]
    ordered = 1
    [[0], [1, 2]]
    [[0], [2, 1]]
    [[1], [0, 2]]
    [[1], [2, 0]]
    [[2], [0, 1]]
    [[2], [1, 0]]
    ordered = 10
    [[0, 1], [2]]
    [[2], [0, 1]]
    [[0, 2], [1]]
    [[1], [0, 2]]
    [[0], [1, 2]]
    [[1, 2], [0]]
    ordered = 11
    [[0], [1, 2]]
    [[0, 1], [2]]
    [[0], [2, 1]]
    [[0, 2], [1]]
    [[1], [0, 2]]
    [[1, 0], [2]]
    [[1], [2, 0]]
    [[1, 2], [0]]
    [[2], [0, 1]]
    [[2, 0], [1]]
    [[2], [1, 0]]
    [[2, 1], [0]]
    See Also
    partitions, multiset_partitions
    """
    def partition(lista, bins):
        if ((len(lista) == 1) or (bins == 1)):
            (yield [lista])
        elif ((len(lista) > 1) and (bins > 1)):
            for i in range(1, len(lista)):
                for part in partition(lista[i:], (bins - 1)):
                    if (len(([lista[:i]] + part)) == bins):
                        (yield ([lista[:i]] + part))
    if (ordered is None):
        for p in partition(l, k):
            (yield p)
    elif (ordered == 11):
        for pl in multiset_permutations(l):
            pl = list(pl)
            for p in partition(pl, k):
                (yield p)
    elif (ordered == 0):
        for p in multiset_partitions(l, k):
            (yield p)
    elif (ordered == 10):
        for p in multiset_partitions(l, k):
            for perm in permutations(p):
                (yield list(perm))
    elif (ordered == 1):
        for (kgot, p) in partitions(len(l), k, size=True):
            if (kgot != k):
                continue
            for li in multiset_permutations(l):
                rv = []
                i = j = 0
                li = list(li)
                for (size, multiplicity) in sorted(p.items()):
                    for m in range(multiplicity):
                        j = (i + size)
                        rv.append(li[i:j])
                        i = j
                (yield rv)
    else:
        raise ValueError(('ordered    must    be    one    of    00,    01,    10    or    11,    not    %s' % ordered))