Est-il possible de trier les deux listes(qui font référence les uns aux autres) exactement de la même façon?

Une approche classique de ce problème est d'utiliser le "décorer, de tri, undecorate" l'idiome, ce qui est particulièrement simple à l'aide de python intégré dans zip fonction:

>>> list1 = [3,2,4,1, 1]
>>> list2 = ['three', 'two', 'four', 'one', 'one2']
>>> list1, list2 = zip(*sorted(zip(list1, list2)))
>>> list1
(1, 1, 2, 3, 4)
>>> list2 
('one', 'one2', 'two', 'three', 'four')

De ces cours ne sont plus des listes, mais c'est facile de remédier, si c'est important:

>>> list1, list2 = (list(t) for t in zip(*sorted(zip(list1, list2))))
>>> list1
[1, 1, 2, 3, 4]
>>> list2
['one', 'one2', 'two', 'three', 'four']

Il est intéressant de noter que le ci-dessus peut sacrifier la vitesse pour la concision; la version, ce qui prend 3 lignes, est un peu plus vite sur ma machine pour les petites listes:

>>> %timeit zip(*sorted(zip(list1, list2)))
100000 loops, best of 3: 3.3 us per loop
>>> %timeit tups = zip(list1, list2); tups.sort(); zip(*tups)
100000 loops, best of 3: 2.84 us per loop

D'autre part, pour les grandes listes, la version d'une ligne pourrait être plus rapide:

>>> %timeit zip(*sorted(zip(list1, list2)))
100 loops, best of 3: 8.09 ms per loop
>>> %timeit tups = zip(list1, list2); tups.sort(); zip(*tups)
100 loops, best of 3: 8.51 ms per loop

Comme Quantum7 souligne, JSF suggestion de l' est un peu plus rapide, mais il sera probablement jamais être un peu plus rapide, parce que Python utilise le même UAD idiome en interne pour tous basés sur une clé sortes. C'est juste arrivé un peu plus proche du métal nu. (Cela montre juste comment bien optimisé la zip routines sont!)

Je pense que le zipest une approche plus souple et est un peu plus lisible, de sorte que je le préfère.

J'ai utilisé la réponse donnée par senderle pendant un long moment jusqu'à ce que j'ai découvert np.argsort.
Voici comment cela fonctionne.

# idx works on np.array and not lists.
list1 = np.array([3,2,4,1])
list2 = np.array(["three","two","four","one"])
idx   = np.argsort(list1)

list1 = np.array(list1)[idx]
list2 = np.array(list2)[idx]

Je trouve cette solution plus intuitive, et il fonctionne vraiment bien. La perfomance:

def sorting(l1, l2):
    # l1 and l2 has to be numpy arrays
    idx = np.argsort(l1)
    return l1[idx], l2[idx]

# list1 and list2 are np.arrays here...
%timeit sorting(list1, list2)
100000 loops, best of 3: 3.53 us per loop

# This works best when the lists are NOT np.array
%timeit zip(*sorted(zip(list1, list2)))
100000 loops, best of 3: 2.41 us per loop

# 0.01us better for np.array (I think this is negligible)
%timeit tups = zip(list1, list2); tups.sort(); zip(*tups)
100000 loops, best for 3 loops: 1.96 us per loop

Même si np.argsort n'est pas le plus rapide, je le trouve plus facile à utiliser.

Ce sujet:

list1 = [3,2,4,1, 1]
list2 = ['three', 'two', 'four', 'one', 'one2']

sortedRes = sorted(zip(list1, list2), key=lambda x: x[0]) # use 0 or 1 depending on what you want to sort
>>> [(1, 'one'), (1, 'one2'), (2, 'two'), (3, 'three'), (4, 'four')]

Une façon consiste à suivre la trace de chaque indice passe par le tri de l'identité [0,1,2,..n]

Cela fonctionne pour n'importe quel nombre de listes.

Déplacer chaque élément à sa position. À l'aide de raccords est le meilleur.

list1 = [3,2,4,1, 1]
list2 = ['three', 'two', 'four', 'one', 'one2']

index = list(range(len(list1)))
print(index)
'[0, 1, 2, 3, 4]'

index.sort(key = list1.__getitem__)
print(index)
'[3, 4, 1, 0, 2]'

list1[:] = [list1[i] for i in index]
list2[:] = [list2[i] for i in index]

print(list1)
print(list2)
'[1, 1, 2, 3, 4]'
"['one', 'one2', 'two', 'three', 'four']"

Note que nous pourrions avoir réaffirmé les listes sans même le tri:

list1_iter = (list1[i] for i in index)

newsource=[];newtarget=[]
for valueT in targetFiles:
    for valueS in sourceFiles:
            l1=len(valueS);l2=len(valueT);
            j=0
            while (j< l1):
                    if (str(valueT) == valueS[j:l1]) :
                            newsource.append(valueS)
                            newtarget.append(valueT)
                    j+=1