Pythonic way to group values from a list based on values from another list

I have 2 lists:

List_A = [1, 25, 40]
List_B = [2, 19, 23, 26, 30, 32, 34, 36]

I want to generate a list of lists such that I group values in list B by determining if they are in between values in list A. So in this example, list B would be grouped into:

[[2,19,23], [26,30,32,34,36]]

Is there any clean way in python to achieve this without multiple nested for loops?

Tried a messy double nested loop structure, was not pleased with how clunky it was (due to lack of readability).

This is the simplest way I can think of to code it.

result = []
for start, end in zip(List_A, List_A[1:]):
    result.append([i for i in List_B if start <= i < end])

It's O(NxM), so not very efficient for large lists.

You could make it more efficient by sorting List_B (I assume List_A is already sorted) and stepping through both of them together, but it will be more complicated.

Group List_B according to the index that they would have, if inserted into List_A. The standard library provides functionality in the bisect module to figure out (by using a standard bisection algorithm) where the value would go; it provides functionality in the itertools module to group adjacent values in an input sequence, according to some predicate ("key" function).

This looks like:

from bisect import bisect
from itertools import groupby

List_A = [1, 25, 40]
List_B = [2, 19, 23, 26, 30, 32, 34, 36]
groups = groupby(List_B, key=lambda x: bisect(List_A, x))
print([list(group) for key, group in groups])

which gives [[2, 19, 23], [26, 30, 32, 34, 36]] as requested.

bisect.bisect is an alias for bisect.bisect_right; that is, a value in List_B that is equal to a value from List_A will be put at the beginning of a later list. To have it as the end of the previous list instead, use bisect.bisect_left.

bisect.bisect also relies on List_A being sorted, naturally.

itertools.groupby will group adjacent values; it will make separate groups for values that belong in the same "bin" but are separated by values that belong in a different "bin". If this is an issue, sort the input first.

This will be O(N * lg M) where N is the length of List_B and M is the length of List_A. That is: finding a bin takes logarithmic time in the number of bins, and this work is repeated for each value to be binned.

This will not generate empty lists if there is a bin that should be empty; the actual indices into List_A are ignored by the list comprehension in this example.