Pythonic moyen de tri de la liste de namedtuples par nom de champ

Je veux trier une liste de uplets nommé sans avoir à se souvenir de l'indice de la fieldname. Ma solution semble plutôt maladroit et a été en espérant que quelqu'un aurait une solution plus élégante.

from operator import itemgetter
from collections import namedtuple

Person = namedtuple('Person', 'name age score')
seq = [
    Person(name='nick', age=23, score=100),
    Person(name='bob', age=25, score=200),
]

# sort list by name
print(sorted(seq, key=itemgetter(Person._fields.index('name'))))
# sort list by age
print(sorted(seq, key=itemgetter(Person._fields.index('age'))))

Grâce,
Nick

Est le nom du champ est toujours donné comme une chaîne de caractères ou la solution par @clyfish aussi le travail?
Je n'étais pas en train de faire quelque chose de dynamique, de sorte que les deux solutions fonctionnent parfaitement.

InformationsquelleAutor Nick | 2012-08-23

from operator import attrgetter
from collections import namedtuple

Person = namedtuple('Person', 'name age score')
seq = [Person(name='nick', age=23, score=100),
       Person(name='bob', age=25, score=200)]

Trier la liste par nom

sorted(seq, key=attrgetter('name'))

Trier la liste par âge

sorted(seq, key=attrgetter('age'))

InformationsquelleAutor jamylak

47
```
sorted(seq, key=lambda x: x.name)
sorted(seq, key=lambda x: x.age)
```
- Je pense que c'est plus élégant que d'utiliser attrgetter
- Je préfère le attrgetter, mais c'est juste le goût. Un avantage est aussi, si je devais faire pour obtenir les champs à trier de façon dynamique. Alors je pourrais juste passer à la chaîne.
- Gardez à l'esprit attrgetter effectue beaucoup mieux et lambdas arent généralement considéré comme élégant
- et sorted(seq, key=lambda x: [x.age, x.name]) sortes par plusieurs attributs
InformationsquelleAutor clyfish

J'ai testé les deux solutions données ici pour la vitesse, puisque @zenpoy était préoccupé par la performance.

Script de test:

import random
from collections import namedtuple
from timeit import timeit
from operator import attrgetter

runs = 10000
size = 10000
random.seed = 42
Person = namedtuple('Person', 'name,age')
seq = [Person(str(random.randint(0, 10 ** 10)), random.randint(0, 100)) for _ in range(size)]

def attrgetter_test_name():
    return sorted(seq.copy(), key=attrgetter('name'))

def attrgetter_test_age():
    return sorted(seq.copy(), key=attrgetter('age'))

def lambda_test_name():
    return sorted(seq.copy(), key=lambda x: x.name)

def lambda_test_age():
    return sorted(seq.copy(), key=lambda x: x.age)

print('attrgetter_test_name', timeit(stmt=attrgetter_test_name, number=runs))
print('attrgetter_test_age', timeit(stmt=attrgetter_test_age, number=runs))
print('lambda_test_name', timeit(stmt=lambda_test_name, number=runs))
print('lambda_test_age', timeit(stmt=lambda_test_age, number=runs))

Résultats:

attrgetter_test_name 44.26793992166096
attrgetter_test_age 31.98247099677627
lambda_test_name 47.97959511074551
lambda_test_age 35.69356267603864

À l'aide de lambda est en effet plus lent. Jusqu'à 10% plus lent.

MODIFIER:

D'autres tests montre les résultats obtenus lors du tri de l'utilisation de plusieurs attributs. Ajouté les deux cas de test avec la même configuration:

def attrgetter_test_both():
    return sorted(seq.copy(), key=attrgetter('age', 'name'))

def lambda_test_both():
    return sorted(seq.copy(), key=lambda x: (x.age, x.name))

print('attrgetter_test_both', timeit(stmt=attrgetter_test_both, number=runs))
print('lambda_test_both', timeit(stmt=lambda_test_both, number=runs))

Résultats:

attrgetter_test_both 92.80101586919373
lambda_test_both 96.85089983147456

Lambda encore connaît une contre performance, mais moins. Maintenant environ 5% plus lent.

Tests sont effectués sur le Python 3.6.0.

Merci pour le multi attribut de tri de cas 🙂

InformationsquelleAutor André C. Andersen

puisque personne n'a mentionné l'aide de itemgetter(), voici comment le faire en utilisant itemgetter().

from operator import itemgetter
from collections import namedtuple

Person = namedtuple('Person', 'name age score')
seq = [
    Person(name='nick', age=23, score=100),
    Person(name='bob', age=25, score=200),
]

# sort list by name
print(sorted(seq, key=itemgetter(0)))

# sort list by age
print(sorted(seq, key=itemgetter(1)))

InformationsquelleAutor sir.Suhrab

0

Cela peut être un peu trop "magique" pour certains, mais je suis partie à l':
```
# sort list by name
print(sorted(seq, key=Person.name.fget))
```
InformationsquelleAutor Sumudu Fernando

Vous devez vous connecter pour publier un commentaire.