Python-Liste von Wörterbüchern suchen

Sieht für mich am meisten pythonic way:

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

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

Ergebnis (Rückgabe als Liste in Python 2):

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

Hinweis: In Python 3, ein filter-Objekt wird zurückgegeben. Also die Python ist3 Lösung wäre:

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

InformationsquelleAutor PaoloC

Können Sie eine list comprehension:

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

InformationsquelleAutor

Getestet habe ich verschiedene Methoden an, gehen Sie durch eine Liste von Wörterbüchern und Rückkehr der Wörterbücher, wo Schlüssel x hat einen bestimmten Wert.

Ergebnisse:

• Geschwindigkeit: list comprehension > generator-Ausdruck >> normale Listen-iteration >>> filter.
• Alle skalieren linear mit der Anzahl der dicts in der Liste (10x Liste Größe -> 10x mal).
• Der Tasten pro Wörterbuch nicht beeinflussen erheblich die Geschwindigkeit für große Datenmengen (Tausende) von Schlüsseln. Bitte sehen Sie sich diese Grafik, die ich berechnet: https://imgur.com/a/quQzv (Methode Namen siehe unten).

Alle tests gemacht mit 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

Ergebnisse:

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

InformationsquelleAutor user136036

Haben Sie jemals versucht, aus der pandas-Paket? Es ist perfekt für diese Art von Suche Aufgabe und optimiert zu werden.

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) ]

Ich habe ein bisschen benchmarking unten, um zu veranschaulichen, pandas' schnellere Laufzeiten auf einem größeren Maßstab, d.h. 100k Einträge:

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

InformationsquelleAutor abby sobh

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]

Dies ist ein Weg...

InformationsquelleAutor Niclas Nilsson

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'}

InformationsquelleAutor robert king

Müssen Sie gehen Sie durch alle Elemente der Liste. Es ist nicht eine Abkürzung!

Es sei denn, woanders halten Sie ein Wörterbuch der Namen verweist auf die Elemente der Liste, aber dann müssen Sie kümmern sich um die Folgen platzender ein element aus Ihrer Liste.

InformationsquelleAutor jimifiki

Ich diesen thread gefunden als ich auf der Suche nach einer Antwort auf dieselbe
Frage. Während ich erkennen, dass es eine späte Antwort, ich dachte, ich würde
tragen Sie in Fall ist es sinnvoll, für alle anderen:

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

InformationsquelleAutor Doug R.

Ich denke, dass Sie verwenden können, Pandas, um sich mit diesem.

import pandas as pd

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

person_df = pd.DataFrame(person_list)
person_df[person_df["name"] == "Pam"].to_dict('records')

It-Ausgänge:

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

Die Vorteile sind:

• Pandas die Bereitstellung von high-performance-Daten-Verarbeitung, das heißt, wenn Sie einen großen Datensatz, den zu suchen würde nicht viel Zeit in Anspruch nehmen.
• Die Daten-Struktur ist einfach zu bedienen und Sie können behandeln Ihre Daten als Tabelle zur weiteren Analyse.

InformationsquelleAutor lazy_frog