Python list reordering, remember original order?
Question: I'm working on a Bayesian probability project, in which I need to adjust
probabilities based on new information. I have yet to find an efficient way to
do this. What I'm trying to do is start with an equal probability list for
distinct scenarios. Ex. There are 6 people: E, T, M, Q, L, and Z, and their
initial respective probabilities of being chosen are represented in

    
    
    myList=[.1667, .1667, .1667, .1667, .1667, .1667]
    

New information surfaces that people in the first third alphabetically have a
collective 70% chance of being chosen. A new list is made, sorted
alphabetically by name (E, L, M, Q, T, Z), that just includes the new
information. (.7/.333=2.33, .3/.667=.45)

    
    
        newList=[2.33, 2.33, .45, .45, .45, .45)
    

I need a way to order the newList the same as myList so I can multiply the
right values in list comprehension, and reach the adjust probabilities. Having
a single consistent order is important because the process will be repeated
several times, each with different criteria (vowels, closest to P, etc), and
in a list with about 1000 items. Each newList could instead be a
newDictionary, and then once the adjustment criteria are created they could be
ordered into a list, but transforming multiple dictionaries seems inefficient.
Is it? Is there a simple way to do this I'm entirely missing?

Thanks!


Answer: For what it's worth, the best thing you can do for the speed of your methods
in Python is to use numpy instead of the standard types (you'll thus be using
pre-compiled C code to perform arithmetic operations). This will lead to a
dramatic speed increase. Numpy arrays have fixed orderings anyway, and syntax
is more directly applicable to mathematical operations. You just need to
consider how to express the operations as matrix operations. E.g. your
example:

    
    
    myList = np.ones(6) / 6.
    newInfo = np.array( [.7/2, .7/2, .3/4, .3/4, .3/4, .3/4] )
    result = myList * newInfo
    

Since both vectors have unit sum there's no need to normalise (I'm not sure
what you were doing in your example, I confess, so if there's a subtlety I've
missed let me know), but if you do need to it's trivial:

    
    
    result /= np.sum(result)
    

