Python Pandas Select values from another dataFrame depending on the total from another column

What about (with a dataframe restricted to the codes xxx, cvd and eeS for the sake of readability)

df2 = df.groupby('code').agg({
    'canceled' : 'first',
    'order'    : list,
    'id'       : list
}).reset_index().rename(
    columns={
        'id'    : 'ids',
        'order' : 'orders',
    }
)
df2['orders_sum'] = df2.orders.apply(sum)

print(df2)
###   code  canceled              orders                                              ids  orders_sum
### 0  cvd      20.0                [55]                                          [11111]          55
### 1  eeS       5.0  [1, 1, 1, 3, 3, 5]  [115236, 108586, 114107, 113472, 114109, 11111]          14
### 2  xxx      11.0        [6, 1, 5, 1]                 [128281, 128282, 128283, 128284]          13

We may then first want to check if some ids already have an order value that fits directly the canceled value.

df2['direct_ids'] = df2.apply(
    lambda r: [
        i for o, i in zip(r.orders, r.ids)
        if o == r.canceled
    ],
    axis = 1
)

print(df2.loc[:, ('code', 'canceled', 'direct_ids')])   
###   code  canceled direct_ids
### 0  cvd      20.0         []
### 1  eeS       5.0    [11111]    # We could have had more than one id, hence the list
### 2  xxx      11.0         []

... otherwise we necessarily have to get all the possible ids's combinations

import itertools as it
import pprint as pp

df2['ids_']   = df2.ids.apply(lambda l:l[:40])  # Let's make the bet that 40 ids will be enough to find the sum we want, avoiding memory error at the same time.
df2['combos'] = df2.ids_.apply(
    lambda l: list(it.chain.from_iterable(
        it.combinations(l, i + 1)
        for i in range(len(l))
    ))
)

pp.pprint(df2.combos[2]) # an illustration with the indexed-by-2 combinations (code `'xxx'`)
### [('128281',),
###  ('128282',),
###  ('128283',),
###  ('128284',),
###  ('128281', '128282'),
###  ('128281', '128283'),
###  ('128281', '128284'),
###  ('128282', '128283'),
###  ('128282', '128284'),
###  ('128283', '128284'),
###  ('128281', '128282', '128283'),
###  ('128281', '128282', '128284'),
###  ('128281', '128283', '128284'),
###  ('128282', '128283', '128284'),
###  ('128281', '128282', '128283', '128284')]

We now need to compute all the distances between canceled values and order-sums that result from these combinations.

df2['distances'] = df2.apply(
    lambda r : {
        combo : abs(
            r.canceled - df.loc[
            df.code.isin([r.code]) & df.id.isin(combo),
            ('order',)
        ].sum()[0]) for combo in r.combos
    },
    axis = 1
)
pp.pprint(df2.distances[2])                                                                          
### {('128281',): 5.0,
###  ('128281', '128282'): 4.0,
###  ('128281', '128282', '128283'): 1.0,
###  ('128281', '128282', '128283', '128284'): 2.0,
###  ('128281', '128282', '128284'): 3.0,
###  ('128281', '128283'): 0.0,           #<--- this is the 'xxx'-combination we want
###  ('128281', '128283', '128284'): 1.0,
###  ('128281', '128284'): 4.0,
###  ('128282',): 10.0,
###  ('128282', '128283'): 5.0,
###  ('128282', '128283', '128284'): 4.0,
###  ('128282', '128284'): 9.0,
###  ('128283',): 6.0,
###  ('128283', '128284'): 5.0,
###  ('128284',): 10.0}

.. and we can now isolate the exact combination(s) we want

default_minv        = [float('inf')]
df2['min_distance'] = df2.distances.apply(
    lambda ds : min(ds.values() or default_minv) # to avoid errors when ds.values() is empty
)
df2['summed_ids'] = df2.apply(
    lambda r : [
        c for c, d in r.distances.items()
        if d == r.min_distance
    ],
    axis = 1
)

print(df2.loc[:, ('code', 'canceled', 'orders_sum', 'min_distance', 'summed_ids')])                     
###   code  canceled  orders_sum  min_distance                                         summed_ids
### 0  cvd      20.0          55          35.0                                         [(11111,)]
### 1  eeS       5.0          14           0.0  [(11111,), (115236, 108586, 113472), (115236, ...
### 2  xxx      11.0          13           0.0                                 [(128281, 128283)]

i) As you can see above, I have defined min_distance as a distinct column, simply because it is not a good practice to have different/multiple types of objects within a single column and ii) the approach is generalized so that you can have multiple combinations of ids as summed_ids, i.e. if many of them have the same min_distance.

[...] I also need to select the most possible ids that sum up to the canceled value.

Doing so is henceforth as easy as

cols_of_interest = ['code', 'canceled', 'orders_sum', 'direct_ids', 'summed_ids']
sub_df = df2.loc[
    (df2.min_distance==0) | df2.direct_ids.map(len), cols_of_interest
]
print(sub_df)                                                        
###   code  canceled  orders_sum direct_ids                                         summed_ids
### 1  eeS       5.0          14    [11111]  [(11111,), (115236, 108586, 113472), (115236, ...
### 2  xxx      11.0          13         []                                 [(128281, 128283)]

The avoid the storage of all the combinations (no need to define df2['combos'] as before), something you could do is:

df2['distances'] = df2.apply(
    lambda r : {
        combo : abs(
            r.canceled - df.loc[
            df.code.isin([r.code]) & df.id.isin(combo),
            ('order',)
        ].sum()[0]) for combo in it.chain.from_iterable(
            it.combinations(r.ids, i + 1)
            for i in range(len(r.ids))
        )
    },
    axis = 1
)

UPDATE

Because I admit that it started to become code-golf, consider the (entire) code that follows

import itertools as it

df2 = df.groupby('code').agg({
    'canceled' : 'first',
    'order'    : list,
    'id'       : list
}).reset_index().rename(
    columns={
        'id'    : 'ids',
        'order' : 'orders',
    }
)

df2['orders_sum'] = df2.orders.apply(sum)


df2['direct_ids'] = df2.apply(
    lambda r: [
        i for o, i in zip(r.orders, r.ids)
        if o == r.canceled
    ],
    axis = 1
)

def distances_computer(r):
    combos = it.chain.from_iterable(
        it.combinations(r.ids, i + 1)
        for i in range(len(r.ids))
    )
    distances_ = []
    for combo in combos:
        d = abs(
            r.canceled - df.loc[
            df.code.isin([r.code]) & df.id.isin(combo),
            ('order',)
        ].sum()[0])
        distances_.append((combo, d)) 
        if d == 0: # Iterations stops as soon as a zero-distance is found.
            break
    # Let's minimize the number of returned distances, keeping only the 10
    # smallest
    distances = sorted(distances_, key=lambda item:item[1])[:10] # Actually you may want to put `1` instead of `10`.
    return dict(distances)

df2['distances'] = df2.apply(
    distances_computer, axis = 1
)   


default_minv        = [float('inf')]
df2['min_distance'] = df2.distances.apply(
    lambda ds : min(ds.values() or default_minv) # to avoid errors when ds.values() is empty
)
df2['summed_ids'] = df2.apply(
    lambda r : [
        c for c, d in r.distances.items()
        if d == r.min_distance
    ],
    axis = 1
)

cols_of_interest = ['code', 'canceled', 'orders_sum', 'direct_ids', 'summed_ids']
sub_df = df2.loc[
    (df2.min_distance==0) | df2.direct_ids.map(len), cols_of_interest
]