İç içe geçmiş sözlüklerde ve listelerde bir anahtarın tüm oluşumlarını bulun

Bunun gibi bir sözlüğüm var:

{ "id" : "abcde",
  "key1" : "blah",
  "key2" : "blah blah",
  "nestedlist" : [ 
    { "id" : "qwerty",
      "nestednestedlist" : [ 
        { "id" : "xyz",
          "keyA" : "blah blah blah" },
        { "id" : "fghi",
          "keyZ" : "blah blah blah" }],
      "anothernestednestedlist" : [ 
        { "id" : "asdf",
          "keyQ" : "blah blah" },
        { "id" : "yuiop",
          "keyW" : "blah" }] } ] } 

Temel olarak, keyfi derinlikte iç içe geçmiş listeler, sözlükler ve dizeler içeren bir sözlük.

Her "id" anahtarının değerlerini çıkarmak için bunu geçmenin en iyi yolu nedir? "// id" gibi bir XPath sorgusunun eşdeğerini elde etmek istiyorum. "İd" değeri her zaman bir dizedir.

Örneğimden ihtiyacım olan çıktı temelde:

["abcde", "qwerty", "xyz", "fghi", "asdf", "yuiop"]

Düzen önemli değil.

Bu S / C'yi çok ilginç buldum, çünkü aynı problem için birkaç farklı çözüm sunuyor. Tüm bu işlevleri aldım ve karmaşık bir sözlük nesnesiyle test ettim. Testten iki işlevi çıkarmak zorunda kaldım, çünkü çok sayıda başarısız sonuç vardı ve listelerin veya diktelerin değer olarak döndürülmesini desteklemiyorlardı ki bu benim gerekli bulduğum, çünkü hemen hemen her verinin gelmesi için bir işlevin hazırlanması gerekiyordu .

Bu yüzden diğer fonksiyonları 100.000 yinelemeyle timeitmodül üzerinden pompaladım ve çıktı aşağıdaki sonuca geldi:

0.11 usec/pass on gen_dict_extract(k,o)
- - - - - - - - - - - - - - - - - - - - - - - - - - - - -
6.03 usec/pass on find_all_items(k,o)
- - - - - - - - - - - - - - - - - - - - - - - - - - - - -
0.15 usec/pass on findkeys(k,o)
- - - - - - - - - - - - - - - - - - - - - - - - - - - - -
1.79 usec/pass on get_recursively(k,o)
- - - - - - - - - - - - - - - - - - - - - - - - - - - - -
0.14 usec/pass on find(k,o)
- - - - - - - - - - - - - - - - - - - - - - - - - - - - -
0.36 usec/pass on dict_extract(k,o)
- - - - - - - - - - - - - - - - - - - - - - - - - - - - -

Tüm işlevler aramak için aynı iğneye sahipti ('günlüğe kaydetme') ve aynı sözlük nesnesi şu şekilde oluşturuldu:

o = { 'temparature': '50', 
      'logging': {
        'handlers': {
          'console': {
            'formatter': 'simple', 
            'class': 'logging.StreamHandler', 
            'stream': 'ext://sys.stdout', 
            'level': 'DEBUG'
          }
        },
        'loggers': {
          'simpleExample': {
            'handlers': ['console'], 
            'propagate': 'no', 
            'level': 'INFO'
          },
         'root': {
           'handlers': ['console'], 
           'level': 'DEBUG'
         }
       }, 
       'version': '1', 
       'formatters': {
         'simple': {
           'datefmt': "'%Y-%m-%d %H:%M:%S'", 
           'format': '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
         }
       }
     }, 
     'treatment': {'second': 5, 'last': 4, 'first': 4},   
     'treatment_plan': [[4, 5, 4], [4, 5, 4], [5, 5, 5]]
}

Tüm işlevler aynı sonucu verdi, ancak zaman farklılıkları çarpıcı! İşlev gen_dict_extract(k,o), buradaki işlevlerden uyarlanmış findişlevimdir , aslında Alfe'nin işlevine çok benzer , temel farkla, özyineleme sırasında dizelerin iletilmesi durumunda verilen nesnenin yineleme işlevi olup olmadığını kontrol ediyorum:

def gen_dict_extract(key, var):
    if hasattr(var,'iteritems'):
        for k, v in var.iteritems():
            if k == key:
                yield v
            if isinstance(v, dict):
                for result in gen_dict_extract(key, v):
                    yield result
            elif isinstance(v, list):
                for d in v:
                    for result in gen_dict_extract(key, d):
                        yield result

Yani bu değişken, buradaki işlevlerin en hızlı ve en güvenli olanıdır. Ve find_all_itemsinanılmaz derecede yavaş ve ikinciden çok uzak get_recursivley, geri kalanlar dict_extractise birbirine yakın. İşlevler funve keyHoleyalnızca dizeleri arıyorsanız çalışır.

Burada ilginç öğrenme yönü :)

d = { "id" : "abcde",
    "key1" : "blah",
    "key2" : "blah blah",
    "nestedlist" : [ 
    { "id" : "qwerty",
        "nestednestedlist" : [ 
        { "id" : "xyz", "keyA" : "blah blah blah" },
        { "id" : "fghi", "keyZ" : "blah blah blah" }],
        "anothernestednestedlist" : [ 
        { "id" : "asdf", "keyQ" : "blah blah" },
        { "id" : "yuiop", "keyW" : "blah" }] } ] } 


def fun(d):
    if 'id' in d:
        yield d['id']
    for k in d:
        if isinstance(d[k], list):
            for i in d[k]:
                for j in fun(i):
                    yield j

>>> list(fun(d))
['abcde', 'qwerty', 'xyz', 'fghi', 'asdf', 'yuiop']

d = { "id" : "abcde",
    "key1" : "blah",
    "key2" : "blah blah",
    "nestedlist" : [
    { "id" : "qwerty",
        "nestednestedlist" : [
        { "id" : "xyz", "keyA" : "blah blah blah" },
        { "id" : "fghi", "keyZ" : "blah blah blah" }],
        "anothernestednestedlist" : [
        { "id" : "asdf", "keyQ" : "blah blah" },
        { "id" : "yuiop", "keyW" : "blah" }] } ] }


def findkeys(node, kv):
    if isinstance(node, list):
        for i in node:
            for x in findkeys(i, kv):
               yield x
    elif isinstance(node, dict):
        if kv in node:
            yield node[kv]
        for j in node.values():
            for x in findkeys(j, kv):
                yield x

print(list(findkeys(d, 'id')))

def find(key, value):
  for k, v in value.iteritems():
    if k == key:
      yield v
    elif isinstance(v, dict):
      for result in find(key, v):
        yield result
    elif isinstance(v, list):
      for d in v:
        for result in find(key, d):
          yield result

DÜZENLEME: @Anthon, bunun doğrudan iç içe geçmiş listeler için çalışmayacağını fark etti. Girişinizde bu varsa, bunu kullanabilirsiniz:

def find(key, value):
  for k, v in (value.iteritems() if isinstance(value, dict) else
               enumerate(value) if isinstance(value, list) else []):
    if k == key:
      yield v
    elif isinstance(v, (dict, list)):
      for result in find(key, v):
        yield result

Ama bence orijinal versiyonun anlaşılması daha kolay, bu yüzden bırakacağım.

Bulunan sonuçların iç içe geçmiş yolunu içeren başka bir varyasyon ( not: bu sürüm listeleri dikkate almaz ):

def find_all_items(obj, key, keys=None):
    """
    Example of use:
    d = {'a': 1, 'b': 2, 'c': {'a': 3, 'd': 4, 'e': {'a': 9, 'b': 3}, 'j': {'c': 4}}}
    for k, v in find_all_items(d, 'a'):
        print "* {} = {} *".format('->'.join(k), v)    
    """
    ret = []
    if not keys:
        keys = []
    if key in obj:
        out_keys = keys + [key]
        ret.append((out_keys, obj[key]))
    for k, v in obj.items():
        if isinstance(v, dict):
            found_items = find_all_items(v, key, keys=(keys+[k]))
            ret += found_items
    return ret

Sadece @ hexerei-software'in en yield fromüst düzey listeleri kullanarak ve kabul ederek mükemmel yanıtını yinelemek istedim .

def gen_dict_extract(var, key):
    if isinstance(var, dict):
        for k, v in var.items():
            if k == key:
                yield v
            if isinstance(v, (dict, list)):
                yield from gen_dict_extract(v, key)
    elif isinstance(var, list):
        for d in var:
            yield from gen_dict_extract(d, key)

Bu işlev, iç içe geçmiş sözlükler ve listeler içeren bir sözlüğü yinelemeli olarak arar. Alan her bulunduğunda geçerli olan değeri içeren, Fields_found adlı bir liste oluşturur. 'Alan', sözlükte ve onun iç içe geçmiş listelerinde ve sözlüklerinde aradığım anahtardır.

def get_recursively (search_dict, alan):
    "" "İç içe geçmiş listeler ve diktelerle bir dikte alır,
    ve alanın bir anahtarı için tüm sözcükleri arar
    sağlanan.
    "" "
    Fields_found = []

    anahtar için search_dict.iteritems () içindeki değer:

        eğer anahtar == alanı:
            Fields_found.append (değer)

        elif isinstance (değer, dikte):
            sonuçlar = get_recursively (değer, alan)
            sonuçlarla sonuçlanmak için:
                Fields_found.append (sonuç)

        elif isinstance (değer, liste):
            değerdeki öğe için:
                durum ise (öğe, dikte):
                    more_results = get_recursively (öğe, alan)
                    more_results içinde another_result için:
                        Fields_found.append (another_result)

    alanlar_found döndür

İşte ona bıçağım:

def keyHole(k2b,o):
  # print "Checking for %s in "%k2b,o
  if isinstance(o, dict):
    for k, v in o.iteritems():
      if k == k2b and not hasattr(v, '__iter__'): yield v
      else:
        for r in  keyHole(k2b,v): yield r
  elif hasattr(o, '__iter__'):
    for r in [ keyHole(k2b,i) for i in o ]:
      for r2 in r: yield r2
  return

Ör .:

>>> findMe = {'Me':{'a':2,'Me':'bop'},'z':{'Me':4}}
>>> keyHole('Me',findMe)
<generator object keyHole at 0x105eccb90>
>>> [ x for x in keyHole('Me',findMe) ]
['bop', 4]

@Hexerei yazılımının yanıtını ve @ bruno-bronosky'nin yorumunu takip ederek, bir liste / anahtar dizisi üzerinde yinelemek istiyorsanız:

def gen_dict_extract(var, keys):
   for key in keys:
      if hasattr(var, 'items'):
         for k, v in var.items():
            if k == key:
               yield v
            if isinstance(v, dict):
               for result in gen_dict_extract([key], v):
                  yield result
            elif isinstance(v, list):
               for d in v:
                  for result in gen_dict_extract([key], d):
                     yield result    

Dize anahtarı yerine tek bir öğe ([key]} içeren bir liste geçirdiğimi unutmayın.

pip install nested-lookup tam olarak aradığınız şeyi yapar:

document = [ { 'taco' : 42 } , { 'salsa' : [ { 'burrito' : { 'taco' : 69 } } ] } ]

>>> print(nested_lookup('taco', document))
[42, 69]