Liste des dictionnaires Python recherche

Supposons que j'ai ceci:

[
{"name": "Tom", "age": 10},
{"name": "Mark", "age": 5},
{"name": "Pam", "age": 7}
]

et en recherchant "Pam" comme nom, je veux récupérer le dictionnaire associé: {name: "Pam", age: 7}

Comment y parvenir?

Vous pouvez utiliser une expression de générateur :

>>> dicts = [
...     { "name": "Tom", "age": 10 },
...     { "name": "Mark", "age": 5 },
...     { "name": "Pam", "age": 7 },
...     { "name": "Dick", "age": 12 }
... ]

>>> next(item for item in dicts if item["name"] == "Pam")
{'age': 7, 'name': 'Pam'}

Si vous devez gérer l'élément qui n'est pas là, vous pouvez faire ce que l'utilisateur Matt a suggéré dans son commentaire et fournir une valeur par défaut en utilisant une API légèrement différente:

next((item for item in dicts if item["name"] == "Pam"), None)

Et pour trouver l'index de l'élément, plutôt que l'élément lui-même, vous pouvez énumérer () la liste:

next((i for i, item in enumerate(dicts) if item["name"] == "Pam"), None)

Cela me semble de la manière la plus pythonique:

people = [
{'name': "Tom", 'age': 10},
{'name': "Mark", 'age': 5},
{'name': "Pam", 'age': 7}
]

filter(lambda person: person['name'] == 'Pam', people)

résultat (renvoyé sous forme de liste en Python 2):

[{'age': 7, 'name': 'Pam'}]

Remarque: En Python 3, un objet filtre est renvoyé. La solution python3 serait donc:

list(filter(lambda person: person['name'] == 'Pam', people))

@ La réponse de Frédéric Hamidi est excellente. Dans Python 3.x, la syntaxe de .next()légèrement modifiée. Ainsi une légère modification:

>>> dicts = [
     { "name": "Tom", "age": 10 },
     { "name": "Mark", "age": 5 },
     { "name": "Pam", "age": 7 },
     { "name": "Dick", "age": 12 }
 ]
>>> next(item for item in dicts if item["name"] == "Pam")
{'age': 7, 'name': 'Pam'}

Comme mentionné dans les commentaires de @Matt, vous pouvez ajouter une valeur par défaut en tant que telle:

>>> next((item for item in dicts if item["name"] == "Pam"), False)
{'name': 'Pam', 'age': 7}
>>> next((item for item in dicts if item["name"] == "Sam"), False)
False
>>>

Vous pouvez utiliser une liste de compréhension :

def search(name, people):
    return [element for element in people if element['name'] == name]

people = [
{'name': "Tom", 'age': 10},
{'name': "Mark", 'age': 5},
{'name': "Pam", 'age': 7}
]

def search(name):
    for p in people:
        if p['name'] == name:
            return p

search("Pam")

J'ai testé différentes méthodes pour parcourir une liste de dictionnaires et retourner les dictionnaires où la clé x a une certaine valeur.

Résultats:

• Vitesse: compréhension des listes> expression du générateur >> itération normale des listes >>> filtre.
• Toutes les échelles sont linéaires avec le nombre de dits dans la liste (taille de liste 10x -> temps 10x)
• Les clés par dictionnaire n'affectent pas de manière significative la vitesse pour de grandes quantités (milliers) de clés. Veuillez consulter ce graphique que j'ai calculé: https://imgur.com/a/quQzv (noms des méthodes, voir ci-dessous).

Tous les tests effectués avec Python 3.6 .4, W7x64.

from random import randint
from timeit import timeit


list_dicts = []
for _ in range(1000):     # number of dicts in the list
    dict_tmp = {}
    for i in range(10):   # number of keys for each dict
        dict_tmp[f"key{i}"] = randint(0,50)
    list_dicts.append( dict_tmp )



def a():
    # normal iteration over all elements
    for dict_ in list_dicts:
        if dict_["key3"] == 20:
            pass

def b():
    # use 'generator'
    for dict_ in (x for x in list_dicts if x["key3"] == 20):
        pass

def c():
    # use 'list'
    for dict_ in [x for x in list_dicts if x["key3"] == 20]:
        pass

def d():
    # use 'filter'
    for dict_ in filter(lambda x: x['key3'] == 20, list_dicts):
        pass

Résultats:

1.7303 # normal list iteration 
1.3849 # generator expression 
1.3158 # list comprehension 
7.7848 # filter

Pour ajouter un tout petit peu à @ FrédéricHamidi.

Dans le cas où vous n'êtes pas sûr qu'une clé se trouve dans la liste des dictés, quelque chose comme ça aiderait:

next((item for item in dicts if item.get("name") and item["name"] == "Pam"), None)

Avez-vous déjà essayé le package pandas? Il est parfait pour ce type de tâche de recherche et optimisé également.

import pandas as pd

listOfDicts = [
{"name": "Tom", "age": 10},
{"name": "Mark", "age": 5},
{"name": "Pam", "age": 7}
]

# Create a data frame, keys are used as column headers.
# Dict items with the same key are entered into the same respective column.
df = pd.DataFrame(listOfDicts)

# The pandas dataframe allows you to pick out specific values like so:

df2 = df[ (df['name'] == 'Pam') & (df['age'] == 7) ]

# Alternate syntax, same thing

df2 = df[ (df.name == 'Pam') & (df.age == 7) ]

J'ai ajouté un peu de benchmarking ci-dessous pour illustrer les temps d'exécution plus rapides des pandas à plus grande échelle, c'est-à-dire 100 000 entrées et plus:

setup_large = 'dicts = [];\
[dicts.extend(({ "name": "Tom", "age": 10 },{ "name": "Mark", "age": 5 },\
{ "name": "Pam", "age": 7 },{ "name": "Dick", "age": 12 })) for _ in range(25000)];\
from operator import itemgetter;import pandas as pd;\
df = pd.DataFrame(dicts);'

setup_small = 'dicts = [];\
dicts.extend(({ "name": "Tom", "age": 10 },{ "name": "Mark", "age": 5 },\
{ "name": "Pam", "age": 7 },{ "name": "Dick", "age": 12 }));\
from operator import itemgetter;import pandas as pd;\
df = pd.DataFrame(dicts);'

method1 = '[item for item in dicts if item["name"] == "Pam"]'
method2 = 'df[df["name"] == "Pam"]'

import timeit
t = timeit.Timer(method1, setup_small)
print('Small Method LC: ' + str(t.timeit(100)))
t = timeit.Timer(method2, setup_small)
print('Small Method Pandas: ' + str(t.timeit(100)))

t = timeit.Timer(method1, setup_large)
print('Large Method LC: ' + str(t.timeit(100)))
t = timeit.Timer(method2, setup_large)
print('Large Method Pandas: ' + str(t.timeit(100)))

#Small Method LC: 0.000191926956177
#Small Method Pandas: 0.044392824173
#Large Method LC: 1.98827004433
#Large Method Pandas: 0.324505090714

C'est une manière générale de rechercher une valeur dans une liste de dictionnaires:

def search_dictionaries(key, value, list_of_dictionaries):
    return [element for element in list_of_dictionaries if element[key] == value]

names = [{'name':'Tom', 'age': 10}, {'name': 'Mark', 'age': 5}, {'name': 'Pam', 'age': 7}]
resultlist = [d    for d in names     if d.get('name', '') == 'Pam']
first_result = resultlist[0]

C'est une façon ...

En utilisant simplement la compréhension de la liste:

[i for i in dct if i['name'] == 'Pam'][0]

Exemple de code:

dct = [
    {'name': 'Tom', 'age': 10},
    {'name': 'Mark', 'age': 5},
    {'name': 'Pam', 'age': 7}
]

print([i for i in dct if i['name'] == 'Pam'][0])

> {'age': 7, 'name': 'Pam'}

Vous pouvez y parvenir avec l'utilisation du filtre et des méthodes suivantes en Python.

filterLa méthode filtre la séquence donnée et renvoie un itérateur. nextaccepte un itérateur et retourne l'élément suivant dans la liste.

Vous pouvez donc trouver l'élément par,

my_dict = [
    {"name": "Tom", "age": 10},
    {"name": "Mark", "age": 5},
    {"name": "Pam", "age": 7}
]

next(filter(lambda obj: obj.get('name') == 'Pam', my_dict), None)

et la sortie est,

{'name': 'Pam', 'age': 7}

Remarque: Le code ci-dessus retournera au Nonecas où le nom que nous recherchons n'est pas trouvé.

Ma première pensée serait que vous souhaitiez peut-être envisager de créer un dictionnaire de ces dictionnaires ... si, par exemple, vous alliez le rechercher plus d'un petit nombre de fois.

Cependant, cela pourrait être une optimisation prématurée. Quel serait le problème avec:

def get_records(key, store=dict()):
    '''Return a list of all records containing name==key from our store
    '''
    assert key is not None
    return [d for d in store if d['name']==key]

dicts=[
{"name": "Tom", "age": 10},
{"name": "Mark", "age": 5},
{"name": "Pam", "age": 7}
]

from collections import defaultdict
dicts_by_name=defaultdict(list)
for d in dicts:
    dicts_by_name[d['name']]=d

print dicts_by_name['Tom']

#output
#>>>
#{'age': 10, 'name': 'Tom'}

Une façon simple d'utiliser les compréhensions de liste est, si lla liste est

l = [
{"name": "Tom", "age": 10},
{"name": "Mark", "age": 5},
{"name": "Pam", "age": 7}
]

puis

[d['age'] for d in l if d['name']=='Tom']

Vous pouvez essayer ceci:

''' lst: list of dictionaries '''
lst = [{"name": "Tom", "age": 10}, {"name": "Mark", "age": 5}, {"name": "Pam", "age": 7}]

search = raw_input("What name: ") #Input name that needs to be searched (say 'Pam')

print [ lst[i] for i in range(len(lst)) if(lst[i]["name"]==search) ][0] #Output
>>> {'age': 7, 'name': 'Pam'} 

Voici une comparaison en utilisant la liste itérative throuhg, en utilisant un filtre + lambda ou en refactorisant (si nécessaire ou valide pour votre cas) votre code pour dicter des dict plutôt qu'une liste de dict

import time

# Build list of dicts
list_of_dicts = list()
for i in range(100000):
    list_of_dicts.append({'id': i, 'name': 'Tom'})

# Build dict of dicts
dict_of_dicts = dict()
for i in range(100000):
    dict_of_dicts[i] = {'name': 'Tom'}


# Find the one with ID of 99

# 1. iterate through the list
lod_ts = time.time()
for elem in list_of_dicts:
    if elem['id'] == 99999:
        break
lod_tf = time.time()
lod_td = lod_tf - lod_ts

# 2. Use filter
f_ts = time.time()
x = filter(lambda k: k['id'] == 99999, list_of_dicts)
f_tf = time.time()
f_td = f_tf- f_ts

# 3. find it in dict of dicts
dod_ts = time.time()
x = dict_of_dicts[99999]
dod_tf = time.time()
dod_td = dod_tf - dod_ts


print 'List of Dictionries took: %s' % lod_td
print 'Using filter took: %s' % f_td
print 'Dict of Dicts took: %s' % dod_td

Et la sortie est la suivante:

List of Dictionries took: 0.0099310874939
Using filter took: 0.0121960639954
Dict of Dicts took: 4.05311584473e-06

Conclusion: Avoir clairement un dictionnaire de dict est le moyen le plus efficace de pouvoir rechercher dans ces cas, où vous savez dire que vous rechercherez uniquement par identifiant. intéressant d'utiliser un filtre est la solution la plus lente.

Vous devez parcourir tous les éléments de la liste. Il n'y a pas de raccourci!

Sauf si ailleurs, vous conservez un dictionnaire des noms pointant vers les éléments de la liste, mais vous devez alors vous occuper des conséquences de l'extraction d'un élément de votre liste.

J'ai trouvé ce fil lorsque je cherchais une réponse à la même question. Bien que je réalise que c'est une réponse tardive, j'ai pensé que j'y contribuerais au cas où cela serait utile à quelqu'un d'autre:

def find_dict_in_list(dicts, default=None, **kwargs):
    """Find first matching :obj:`dict` in :obj:`list`.

    :param list dicts: List of dictionaries.
    :param dict default: Optional. Default dictionary to return.
        Defaults to `None`.
    :param **kwargs: `key=value` pairs to match in :obj:`dict`.

    :returns: First matching :obj:`dict` from `dicts`.
    :rtype: dict

    """

    rval = default
    for d in dicts:
        is_found = False

        # Search for keys in dict.
        for k, v in kwargs.items():
            if d.get(k, None) == v:
                is_found = True

            else:
                is_found = False
                break

        if is_found:
            rval = d
            break

    return rval


if __name__ == '__main__':
    # Tests
    dicts = []
    keys = 'spam eggs shrubbery knight'.split()

    start = 0
    for _ in range(4):
        dct = {k: v for k, v in zip(keys, range(start, start+4))}
        dicts.append(dct)
        start += 4

    # Find each dict based on 'spam' key only.  
    for x in range(len(dicts)):
        spam = x*4
        assert find_dict_in_list(dicts, spam=spam) == dicts[x]

    # Find each dict based on 'spam' and 'shrubbery' keys.
    for x in range(len(dicts)):
        spam = x*4
        assert find_dict_in_list(dicts, spam=spam, shrubbery=spam+2) == dicts[x]

    # Search for one correct key, one incorrect key:
    for x in range(len(dicts)):
        spam = x*4
        assert find_dict_in_list(dicts, spam=spam, shrubbery=spam+1) is None

    # Search for non-existent dict.
    for x in range(len(dicts)):
        spam = x+100
        assert find_dict_in_list(dicts, spam=spam) is None

La plupart (sinon la totalité) des implémentations proposées ici ont deux défauts:

• Ils supposent qu'une seule clé doit être transmise pour la recherche, alors qu'il peut être intéressant d'en avoir plus pour un dict complexe
• Ils supposent que toutes les clés passées pour la recherche existent dans les dict, donc ils ne traitent pas correctement avec KeyError se produisant quand ce n'est pas le cas.

Une proposition mise à jour:

def find_first_in_list(objects, **kwargs):
    return next((obj for obj in objects if
                 len(set(obj.keys()).intersection(kwargs.keys())) > 0 and
                 all([obj[k] == v for k, v in kwargs.items() if k in obj.keys()])),
                None)

Peut-être pas le plus pythonique, mais au moins un peu plus sûr.

Usage:

>>> obj1 = find_first_in_list(list_of_dict, name='Pam', age=7)
>>> obj2 = find_first_in_list(list_of_dict, name='Pam', age=27)
>>> obj3 = find_first_in_list(list_of_dict, name='Pam', address='nowhere')
>>> 
>>> print(obj1, obj2, obj3)
{"name": "Pam", "age": 7}, None, {"name": "Pam", "age": 7}

L' essentiel .