problem with backpack problem

This is simpler than it seems: What you are missing is a price/weight relationship because what you do is that the process_value function returns only one data from the equation Where do you leave the weight?. If what you want is the maximum number of packages, prioritizing the ones with the highest value, you have to divide the price by the value so that the sorted returns a related key. I don't know if I'm explaining myself but what you have to do is this:

def proceso_valor(item):
    nombre, peso, valor = item
    return float(valor)/ float(peso)

and ready, that way the sorted will give you your 4 elements where the fourth will be that relationship you are looking for. If you try it with process_weight.weight_maximum = 500, it gives you a load equal to 493 and not 451 as you say with the two missing packages.

The knapsack problem is an NP problem, that is, you will not find an algorithm that always obtains the optimal solution. However, what you can do is discard the worst-behaving cases to keep the best possible solutions.

That said, your algorithm should have two goals:

1. Put the largest number of packages
2. Among the solutions obtained, keep those that add the greatest value

In your approach it is not clear if prioritizing by value is putting the most expensive packages first or that the total sum is the highest. I guess it's the latter case. Although the problem can also be put the other way around: wanting to carry the most expensive load, without exceeding the load limit of the truck.

Well, your algorithm starts by sorting by value and then keeping the ones that fit in the maximum load. umm! It's just the opposite of what you should try. To begin with, all the expensive packages you are subtracting from the maximum load. For example, try two packages:

proceso_peso.peso_maximo = 750

PAQUETES = (
    ("Paquete 1", 9, 150), ("Paquete 2", 1000, 10000)
    )

carga_lista = list(takewhile(proceso_peso, reversed(sorted(PAQUETES, key=proceso_valor))))

Package 2 has a lot of value and a lot of weight. Checking with proceso_pesosubtracts its weight from proceso_peso.peso_maximo, which is negative, and takewhileends up returning an empty list.

Having seen the bug, my advice is don't use function attributes and, more importantly, don't change the problem conditions within an iteration (and if you do, make it look clear). For the former, use object-oriented programming; for the latter, use functional programming. For both, use python.

The knapsack problem is well studied. Surely you will find several algorithms that try to find the solution more or less quickly. In case it helps you, I'll show you how it would be done by "brute force" , although it takes a long time in some cases:

from operator import itemgetter

#Paquetes: "Nombre del paquete", Kilos, Precio
PAQUETES = (
    ("Paquete 1", 9, 150), ("Paquete 2", 9, 160), ("Paquete 3", 153, 200), ("Paquete 4", 50, 160),
    ("Paquete 5", 15, 60), ("Paquete 6", 66, 45), ("Paquete 7", 27, 60), ("Paquete 8", 39, 40),
    ("Paquete 9", 230, 591), ("Paquete 10", 520, 10), ("Paquete 11", 110, 70), ("Paquete 12", 32, 30))

#carga máxima del camión
PESOMAXIMO = 230

# Útiles para acceso al peso y valores (irían mejor definiendo una clase)
get_peso = itemgetter(1)
get_valor = itemgetter(2)

def total_peso(paquetes):
    return sum(get_peso(x) for x in paquetes)

def total_valor(paquetes):
    return sum(get_valor(x) for x in paquetes)

# Obtención de todas las combinaciones posibles
# Función recursiva
def combinaciones(paquetes, peso_maximo):
    paqs = [ p for p in paquetes if get_peso(p) <= peso_maximo ]
    resultado = []
    for p in paqs:
        res = combinaciones([x for x in paqs if x!=p], peso_maximo - get_peso(p))
        if len(res) == 0:
            resultado.append([p])
        else:
            resultado.extend([[p]+x for x in res])
    return resultado

# solución
max(combinaciones(PAQUETES, PESOMAXIMO), key=total_valor)