Wie verwende ich einen Punkt "." um auf Elemente eines Wörterbuchs zuzugreifen?

Question

Wie mache ich Python-Wörterbuchmitglieder über einen Punkt "." zugänglich?

Zum Beispiel würde ich gerne statt mydict['val'] mydict.val schreiben.

Außerdem würde ich gerne auf verschachtelte Wörterbücher auf diese Weise zugreifen. Zum Beispiel

mydict.mydict2.val 

würde sich auf

mydict = { 'mydict2': { 'val': ... } }

Answer 1

Wenn Sie Ihr geändertes Wörterbuch einlegen möchten, müssen Sie den obigen Antworten einige Zustandsmethoden hinzufügen:

class DotDict(dict):
    """Punkt-Notationszugriff auf Wörterbucheigenschaften"""
    def __getattr__(self, attr):
        return self.get(attr)
    __setattr__= dict.__setitem__
    __delattr__= dict.__delitem__

    def __getstate__(self):
        return self

    def __setstate__(self, state):
        self.update(state)
        self.__dict__ = self

Answer 2

Um auf die Antwort von epool aufzubauen, erlaubt diese Version den Zugriff auf jedes Dictionary innerhalb via Punktoperator:

foo = {
    "bar" : {
        "baz" : [ {"boo" : "hoo"} , {"baba" : "loo"} ]
    }
}

Zum Beispiel gibt foo.bar.baz[1].baba "loo" zurück.

class Map(dict):
    def __init__(self, *args, **kwargs):
        super(Map, self).__init__(*args, **kwargs)
        for arg in args:
            if isinstance(arg, dict):
                for k, v in arg.items():
                    if isinstance(v, dict):
                        v = Map(v)
                    if isinstance(v, list):
                        self.__convert(v)
                    self[k] = v

        if kwargs:
            for k, v in kwargs.items():
                if isinstance(v, dict):
                    v = Map(v)
                elif isinstance(v, list):
                    self.__convert(v)
                self[k] = v

    def __convert(self, v):
        for elem in range(0, len(v)):
            if isinstance(v[elem], dict):
                v[elem] = Map(v[elem])
            elif isinstance(v[elem], list):
                self.__convert(v[elem])

    def __getattr__(self, attr):
        return self.get(attr)

    def __setattr__(self, key, value):
        self.__setitem__(key, value)

    def __setitem__(self, key, value):
        super(Map, self).__setitem__(key, value)
        self.__dict__.update({key: value})

    def __delattr__(self, item):
        self.__delitem__(item)

    def __delitem__(self, key):
        super(Map, self).__delitem__(key)
        del self.__dict__[key]

Answer 3

Basierend auf Kugels Antwort und unter Berücksichtigung von Mike Grahams Worten der Vorsicht, was ist, wenn wir einen Wrapper erstellen?

class DictWrap(object):
  """ Verpacken Sie ein vorhandenes Dictionary oder erstellen Sie ein neues und greifen Sie sowohl mit Punktschreibweise als auch mit Schlüsselsuche darauf zu.

    Das Attribut _data ist reserviert und enthält das zugrunde liegende Dictionary. Bei Verwendung des += Operators mit create=True wird das leere geschachtelte Dictionary durch den Operanden ersetzt und erstellt effektiv ein Standard-Dictionary gemischter Typen.

    args:
      d({}): Vorhandenes Dictionary zum Verpacken, standardmäßig wird ein leeres Dictionary erstellt
      create(True): Erstellt ein leeres geschachteltes Dictionary anstelle des Auslösens eines KeyError

    Beispiel:
      >>>dw = DictWrap({'pp':3})
      >>>dw.a.b += 2
      >>>dw.a.b += 2
      >>>dw.a['c'] += 'Hallo'
      >>>dw.a['c'] += ' Welt'
      >>>print dw.a.d
      >>>print dw._data
      {'a': {'c': 'Hallo Welt', 'b': 4, 'd': {}}, 'pp': 3}

  """

  def __init__(self, d=None, create=True):
    if d is None:
      d = {}
    supr = super(DictWrap, self)  
    supr.__setattr__('_data', d)
    supr.__setattr__('__create', create)

  def __getattr__(self, name):
    try:
      value = self._data[name]
    except KeyError:
      if not super(DictWrap, self).__getattribute__('__create'):
        raise
      value = {}
      self._data[name] = value

    if hasattr(value, 'items'):
      create = super(DictWrap, self).__getattribute__('__create')
      return DictWrap(value, create)
    return value

  def __setattr__(self, name, value):
    self._data[name] = value  

  def __getitem__(self, key):
    try:
      value = self._data[key]
    except KeyError:
      if not super(DictWrap, self).__getattribute__('__create'):
        raise
      value = {}
      self._data[key] = value

    if hasattr(value, 'items'):
      create = super(DictWrap, self).__getattribute__('__create')
      return DictWrap(value, create)
    return value

  def __setitem__(self, key, value):
    self._data[key] = value

  def __iadd__(self, other):
    if self._data:
      raise TypeError("Ein geschachteltes Dictionary wird nur ersetzt, wenn es leer ist")
    else:
      return other

Answer 4

Verwenden Sie __getattr__, sehr einfach, funktioniert in Python 3.4.3

class myDict(dict):
    def __getattr__(self, val):
        return self[val]

blockBody = myDict()
blockBody['item1'] = 10000
blockBody['item2'] = "StackOverflow"
print(blockBody.item1)
print(blockBody.item2)

Ausgabe:

10000
StackOverflow

Answer 5

Ich mag den Munch und er bietet viele praktische Optionen zusätzlich zum Punktzugriff.

import munch

temp_1 = {'person': { 'fname': 'senthil', 'lname': 'ramalingam'}}

dict_munch = munch.munchify(temp_1)

dict_munch.person.fname