class AutoVivification(dict):
    """Implementation of perl's autovivification feature."""
    def __getitem__(self, item):
        try:
            return dict.__getitem__(self, item)
        except KeyError:
            value = self[item] = type(self)()
            return value

Testowanie:

a = AutoVivification()

a[1][2][3] = 4
a[1][3][3] = 5
a[1][2]['test'] = 6

print a

Wyjście:

{1: {2: {'test': 6, 3: 4}, 3: {3: 5}}}

Tylko dlatego, że nie widziałem takiego małego, tutaj jest dict, który jest tak zagnieżdżony, jak chcesz, bez potu:

# yo dawg, i heard you liked dicts                                                                      
def yodict():
    return defaultdict(yodict)

Możesz utworzyć plik YAML i odczytać go za pomocą PyYaml .

Krok 1: Utwórz plik YAML, " zatrudnienie.yml": {]}

new jersey:
  mercer county:
    pumbers: 3
    programmers: 81
  middlesex county:
    salesmen: 62
    programmers: 81
new york:
  queens county:
    plumbers: 9
    salesmen: 36

Krok 2: przeczytaj to w Pythonie

import yaml
file_handle = open("employment.yml")
my_shnazzy_dictionary = yaml.safe_load(file_handle)
file_handle.close()

A teraz my_shnazzy_dictionary ma wszystkie twoje wartości. Jeśli chcesz to zrobić w locie, możesz utworzyć YAML jako ciąg znaków i wprowadzić go do yaml.safe_load(...).

Ponieważ masz schemat Gwiazdy, możesz chcieć uporządkować go bardziej jak tabelę relacyjną, a mniej jak słownik.

import collections

class Jobs( object ):
    def __init__( self, state, county, title, count ):
        self.state= state
        self.count= county
        self.title= title
        self.count= count

facts = [
    Jobs( 'new jersey', 'mercer county', 'plumbers', 3 ),
    ...

def groupBy( facts, name ):
    total= collections.defaultdict( int )
    for f in facts:
        key= getattr( f, name )
        total[key] += f.count

Tego rodzaju rzeczy mogą przejść długą drogę do stworzenia projektu przypominającego hurtownię danych bez kosztów ogólnych SQL.

Jeśli liczba poziomów zagnieżdżania jest mała, używam collections.defaultdict do tego:

from collections import defaultdict

def nested_dict_factory(): 
  return defaultdict(int)
def nested_dict_factory2(): 
  return defaultdict(nested_dict_factory)
db = defaultdict(nested_dict_factory2)

db['new jersey']['mercer county']['plumbers'] = 3
db['new jersey']['mercer county']['programmers'] = 81

Używanie defaultdict w ten sposób pozwala uniknąć bałaganu setdefault(), get(), itd.

Jest to funkcja, która zwraca zagnieżdżony Słownik o dowolnej głębokości:

from collections import defaultdict
def make_dict():
    return defaultdict(make_dict)

Użyj go tak:

d=defaultdict(make_dict)
d["food"]["meat"]="beef"
d["food"]["veggie"]="corn"
d["food"]["sweets"]="ice cream"
d["animal"]["pet"]["dog"]="collie"
d["animal"]["pet"]["cat"]="tabby"
d["animal"]["farm animal"]="chicken"

Iterować przez wszystko z czymś takim:

def iter_all(d,depth=1):
    for k,v in d.iteritems():
        print "-"*depth,k
        if type(v) is defaultdict:
            iter_all(v,depth+1)
        else:
            print "-"*(depth+1),v

iter_all(d)

To drukuje:

- food
-- sweets
--- ice cream
-- meat
--- beef
-- veggie
--- corn
- animal
-- pet
--- dog
---- labrador
--- cat
---- tabby
-- farm animal
--- chicken

Możesz w końcu chcieć zrobić to tak, aby nowe elementy nie mogły być dodawane do dict. Łatwo jest rekurencyjnie przekonwertować wszystkie te defaultdict s na normalne dict s.

def dictify(d):
    for k,v in d.iteritems():
        if isinstance(v,defaultdict):
            d[k] = dictify(v)
    return dict(d)

Uważam, żesetdefault jest całkiem przydatny; sprawdza, czy klucz jest obecny i dodaje go, jeśli nie:

d = {}
d.setdefault('new jersey', {}).setdefault('mercer county', {})['plumbers'] = 3

setdefault zawsze zwraca odpowiedni klucz, więc faktycznie aktualizujesz wartości 'd'.

Jeśli chodzi o iterację, jestem pewien, że można napisać generator wystarczająco łatwo, jeśli nie istnieje jeszcze w Pythonie:

def iterateStates(d):
    # Let's count up the total number of "plumbers" / "dentists" / etc.
    # across all counties and states
    job_totals = {}

    # I guess this is the annoying nested stuff you were talking about?
    for (state, counties) in d.iteritems():
        for (county, jobs) in counties.iteritems():
            for (job, num) in jobs.iteritems():
                # If job isn't already in job_totals, default it to zero
                job_totals[job] = job_totals.get(job, 0) + num

    # Now return an iterator of (job, number) tuples
    return job_totals.iteritems()

# Display all jobs
for (job, num) in iterateStates(d):
    print "There are %d %s in total" % (job, num)

Jak sugerowali inni, relacyjna baza danych może być dla ciebie bardziej przydatna. Możesz użyć wbudowanej w pamięć bazy danych SQLite3 jako struktury danych do tworzenia tabel, a następnie odpytywania ich.

import sqlite3

c = sqlite3.Connection(':memory:')
c.execute('CREATE TABLE jobs (state, county, title, count)')

c.executemany('insert into jobs values (?, ?, ?, ?)', [
    ('New Jersey', 'Mercer County',    'Programmers', 81),
    ('New Jersey', 'Mercer County',    'Plumbers',     3),
    ('New Jersey', 'Middlesex County', 'Programmers', 81),
    ('New Jersey', 'Middlesex County', 'Salesmen',    62),
    ('New York',   'Queens County',    'Salesmen',    36),
    ('New York',   'Queens County',    'Plumbers',     9),
])

# some example queries
print list(c.execute('SELECT * FROM jobs WHERE county = "Queens County"'))
print list(c.execute('SELECT SUM(count) FROM jobs WHERE title = "Programmers"'))

collections.defaultdict może być podklasowany, aby utworzyć zagnieżdżony dict. Następnie dodaj dowolne użyteczne metody iteracji do tej klasy.

>>> from collections import defaultdict
>>> class nesteddict(defaultdict):
    def __init__(self):
        defaultdict.__init__(self, nesteddict)
    def walk(self):
        for key, value in self.iteritems():
            if isinstance(value, nesteddict):
                for tup in value.walk():
                    yield (key,) + tup
            else:
                yield key, value


>>> nd = nesteddict()
>>> nd['new jersey']['mercer county']['plumbers'] = 3
>>> nd['new jersey']['mercer county']['programmers'] = 81
>>> nd['new jersey']['middlesex county']['programmers'] = 81
>>> nd['new jersey']['middlesex county']['salesmen'] = 62
>>> nd['new york']['queens county']['plumbers'] = 9
>>> nd['new york']['queens county']['salesmen'] = 36
>>> for tup in nd.walk():
    print tup


('new jersey', 'mercer county', 'programmers', 81)
('new jersey', 'mercer county', 'plumbers', 3)
('new jersey', 'middlesex county', 'programmers', 81)
('new jersey', 'middlesex county', 'salesmen', 62)
('new york', 'queens county', 'salesmen', 36)
('new york', 'queens county', 'plumbers', 9)

defaultdict() to twój przyjaciel!

Dla dwuwymiarowego słownika możesz zrobić:

d = defaultdict(defaultdict)
d[1][2] = 3

Aby uzyskać więcej wymiarów, możesz:

d = defaultdict(lambda :defaultdict(defaultdict))
d[1][2][3] = 4

Co do "nieznośnych klocków try/catch":

d = {}
d.setdefault('key',{}).setdefault('inner key',{})['inner inner key'] = 'value'
print d

{'key': {'inner key': {'inner inner key': 'value'}}}

Możesz użyć tego do konwersji z formatu płaskiego słownika do formatu strukturalnego:

fd = {('new jersey', 'mercer county', 'plumbers'): 3,
 ('new jersey', 'mercer county', 'programmers'): 81,
 ('new jersey', 'middlesex county', 'programmers'): 81,
 ('new jersey', 'middlesex county', 'salesmen'): 62,
 ('new york', 'queens county', 'plumbers'): 9,
 ('new york', 'queens county', 'salesmen'): 36}

for (k1,k2,k3), v in fd.iteritems():
    d.setdefault(k1, {}).setdefault(k2, {})[k3] = v

Dla łatwego iterowania nad zagnieżdżonym słownikiem, dlaczego nie napisać prostego generatora?

def each_job(my_dict):
    for state, a in my_dict.items():
        for county, b in a.items():
            for job, value in b.items():
                yield {
                    'state'  : state,
                    'county' : county,
                    'job'    : job,
                    'value'  : value
                }

Więc jeśli masz skompilowany słownik zagnieżdżony, iteracja nad nim staje się prosta:

for r in each_job(my_dict):
    print "There are %d %s in %s, %s" % (r['value'], r['job'], r['county'], r['state'])

Oczywiście twój generator może uzyskać dowolny format danych, który jest dla Ciebie przydatny.

Dlaczego używasz bloków try catch, aby odczytać drzewo? Jest wystarczająco łatwo (i prawdopodobnie bezpieczniej) sprawdzić, czy klucz istnieje w dict, zanim spróbuje go odzyskać. Funkcja wykorzystująca guard klauzule mogą wyglądać tak:

if not my_dict.has_key('new jersey'):
    return False

nj_dict = my_dict['new jersey']
...

Lub, być może nieco gadatliwą metodą, jest użycie metody get:

value = my_dict.get('new jersey', {}).get('middlesex county', {}).get('salesmen', 0)

Ale w bardziej zwięzły sposób, możesz chcieć spojrzeć na użycie kolekcji.defaultdict , który jest częścią biblioteki standardowej od Pythona 2.5.

import collections

def state_struct(): return collections.defaultdict(county_struct)
def county_struct(): return collections.defaultdict(job_struct)
def job_struct(): return 0

my_dict = collections.defaultdict(state_struct)

print my_dict['new jersey']['middlesex county']['salesmen']

Robię założenia co do znaczenia struktury danych tutaj, ale powinno być łatwo dostosować się do tego, co rzeczywiście chcesz zrobić.

Możesz użyć Addict: https://github.com/mewwts/addict

>>> from addict import Dict
>>> my_new_shiny_dict = Dict()
>>> my_new_shiny_dict.a.b.c.d.e = 2
>>> my_new_shiny_dict
{'a': {'b': {'c': {'d': {'e': 2}}}}}

Podoba mi się pomysł owinięcia tego w klasę i zaimplementowania __getitem__ i __setitem__ w taki sposób, że zaimplementowali prosty język zapytań:

>>> d['new jersey/mercer county/plumbers'] = 3
>>> d['new jersey/mercer county/programmers'] = 81
>>> d['new jersey/mercer county/programmers']
81
>>> d['new jersey/mercer country']
<view which implicitly adds 'new jersey/mercer county' to queries/mutations>

Jeśli chcesz nabrać fantazji, możesz również zaimplementować coś w stylu:

>>> d['*/*/programmers']
<view which would contain 'programmers' entries>

Ale przede wszystkim myślę, że takie coś byłoby naprawdę fajne w realizacji: d

O ile twój zbiór danych nie będzie dość mały, warto rozważyć użycie relacyjnej bazy danych. Zrobi dokładnie to, co chcesz: ułatwi dodawanie liczeń, wybieranie podzbiorów liczeń, a nawet zagregowanie liczeń według stanu, hrabstwa, zawodu lub dowolnej ich kombinacji.

class JobDb(object):
    def __init__(self):
        self.data = []
        self.all = set()
        self.free = []
        self.index1 = {}
        self.index2 = {}
        self.index3 = {}

    def _indices(self,(key1,key2,key3)):
        indices = self.all.copy()
        wild = False
        for index,key in ((self.index1,key1),(self.index2,key2),
                                             (self.index3,key3)):
            if key is not None:
                indices &= index.setdefault(key,set())
            else:
                wild = True
        return indices, wild

    def __getitem__(self,key):
        indices, wild = self._indices(key)
        if wild:
            return dict(self.data[i] for i in indices)
        else:
            values = [self.data[i][-1] for i in indices]
            if values:
                return values[0]

    def __setitem__(self,key,value):
        indices, wild = self._indices(key)
        if indices:
            for i in indices:
                self.data[i] = key,value
        elif wild:
            raise KeyError(k)
        else:
            if self.free:
                index = self.free.pop(0)
                self.data[index] = key,value
            else:
                index = len(self.data)
                self.data.append((key,value))
                self.all.add(index)
            self.index1.setdefault(key[0],set()).add(index)
            self.index2.setdefault(key[1],set()).add(index)
            self.index3.setdefault(key[2],set()).add(index)

    def __delitem__(self,key):
        indices,wild = self._indices(key)
        if not indices:
            raise KeyError
        self.index1[key[0]] -= indices
        self.index2[key[1]] -= indices
        self.index3[key[2]] -= indices
        self.all -= indices
        for i in indices:
            self.data[i] = None
        self.free.extend(indices)

    def __len__(self):
        return len(self.all)

    def __iter__(self):
        for key,value in self.data:
            yield key

Przykład:

>>> db = JobDb()
>>> db['new jersey', 'mercer county', 'plumbers'] = 3
>>> db['new jersey', 'mercer county', 'programmers'] = 81
>>> db['new jersey', 'middlesex county', 'programmers'] = 81
>>> db['new jersey', 'middlesex county', 'salesmen'] = 62
>>> db['new york', 'queens county', 'plumbers'] = 9
>>> db['new york', 'queens county', 'salesmen'] = 36

>>> db['new york', None, None]
{('new york', 'queens county', 'plumbers'): 9,
 ('new york', 'queens county', 'salesmen'): 36}

>>> db[None, None, 'plumbers']
{('new jersey', 'mercer county', 'plumbers'): 3,
 ('new york', 'queens county', 'plumbers'): 9}

>>> db['new jersey', 'mercer county', None]
{('new jersey', 'mercer county', 'plumbers'): 3,
 ('new jersey', 'mercer county', 'programmers'): 81}

>>> db['new jersey', 'middlesex county', 'programmers']
81

>>>

Edit: TERAZ Zwraca słowniki przy pytaniu z dzikimi kartami (None) i pojedynczymi wartościami w przeciwnym razie.

Możesz użyć rekurencji w lambda i defaultdict, bez potrzeby definiowania nazw:

a = defaultdict((lambda f: f(f))(lambda g: lambda:defaultdict(g(g))))

Oto przykład:

>>> a['new jersey']['mercer county']['plumbers']=3
>>> a['new jersey']['middlesex county']['programmers']=81
>>> a['new jersey']['mercer county']['programmers']=81
>>> a['new jersey']['middlesex county']['salesmen']=62
>>> a
defaultdict(<function __main__.<lambda>>,
        {'new jersey': defaultdict(<function __main__.<lambda>>,
                     {'mercer county': defaultdict(<function __main__.<lambda>>,
                                  {'plumbers': 3, 'programmers': 81}),
                      'middlesex county': defaultdict(<function __main__.<lambda>>,
                                  {'programmers': 81, 'salesmen': 62})})})

Mam coś podobnego. Mam wiele spraw, w których robię:

thedict = {}
for item in ('foo', 'bar', 'baz'):
  mydict = thedict.get(item, {})
  mydict = get_value_for(item)
  thedict[item] = mydict

value = mydict.get('foo', {}).get('bar', {}).get('baz', 0)

Więc zamiast tego zrobiłem:

def dictgetter(thedict, default, *args):
  totalargs = len(args)
  for i,arg in enumerate(args):
    if i+1 == totalargs:
      thedict = thedict.get(arg, default)
    else:
      thedict = thedict.get(arg, {})
  return thedict

Który ma taki sam efekt jeśli to zrobisz:

value = dictgetter(mydict, 0, 'foo', 'bar', 'baz')

Używałem tej funkcji. jest bezpieczny, szybki, łatwy w utrzymaniu.

def deep_get(dictionary, keys, default=None):
    return reduce(lambda d, key: d.get(key, default) if isinstance(d, dict) else default, keys.split("."), dictionary)

Przykład:

>>> from functools import reduce
>>> def deep_get(dictionary, keys, default=None):
...     return reduce(lambda d, key: d.get(key, default) if isinstance(d, dict) else default, keys.split("."), dictionary)
...
>>> person = {'person':{'name':{'first':'John'}}}
>>> print (deep_get(person, "person.name.first"))
John
>>> print (deep_get(person, "person.name.lastname"))
None
>>> print (deep_get(person, "person.name.lastname", default="No lastname"))
No lastname
>>>