How to use a dot to access members of dictionary

Question

How do I make Python dictionary members accessible via a dot       For example  instead of writing mydict  val    I d like to write mydict val   Also I d like to access nested dicts this way  For example  mydict mydict2 val    would refer to   mydict      mydict2      val

User · Answer

This solution is a refinement upon the one offered by epool to address the requirement of the OP to access nested dicts in a consistent manner. The solution by epool did not allow for accessing nested dicts.

class YAMLobj(dict):
    def __init__(self, args):
        super(YAMLobj, self).__init__(args)
        if isinstance(args, dict):
            for k, v in args.iteritems():
                if not isinstance(v, dict):
                    self[k] = v
                else:
                    self.__setattr__(k, YAMLobj(v))


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

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

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

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

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

With this class, one can now do something like: A.B.C.D.

User · Answer

Don t  Attribute access and indexing are separate things in Python  and you shouldn t want them to perform the same  Make a class  possibly one made by namedtuple  if you have something that should have accessible attributes and use    notation to get an item from a dict

User · Answer

I recently came across the  Box  library which does the same thing    Installation command   pip install python-box  Example   from box import Box  mydict     key1    v1  0 375                       v2  0 625              key2  0 125              mydict   Box mydict   print mydict key1 v1    I found it to be more effective than other existing libraries like dotmap  which generate python recursion error when you have large nested dicts   link to library and details  https   pypi org project python-box

User · Answer

I d like to throw my own solution into the ring   https   github com skorokithakis jsane  It allows you to parse JSON into something you can access with attribute lookups like this r    mostly because I hadn t seen this answer before starting to work on it

User · Answer

Fabric has a really nice  minimal implementation  Extending that to allow for nested access  we can use a defaultdict  and the result looks something like this   from collections import defaultdict  class AttributeDict defaultdict       def   init   self           super AttributeDict  self    init   AttributeDict       def   getattr   self  key           try              return self key          except KeyError              raise AttributeError key       def   setattr   self  key  value           self key    value   Make use of it as follows   keys   AttributeDict   keys abc xyz x   123 keys abc xyz a b c   234   That elaborates a bit on Kugel s answer of  Derive from dict and and implement   getattr   and   setattr     Now you know how

User · Answer

A solution kind of delicate  class DotDict dict          setattr     dict   setitem         delattr     dict   delitem        def   getattr   self  key            def typer candidate               if isinstance candidate  dict                   return DotDict candidate               if isinstance candidate  str      iterable but no need to iter                 return candidate              try     other iterable are processed as list                 return  typer item  for item in candidate              except TypeError                  return candidate              return candidate          return typer dict get self  key

User · Answer

Install dotmap via pip  pip install dotmap   It does everything you want it to do and subclasses dict  so it operates like a normal dictionary   from dotmap import DotMap  m   DotMap   m hello    world  m hello m hello          m hello and m  hello   now both return  world   m val   5 m val2    Sam    On top of that  you can convert it to and from dict objects   d   m toDict   m   DotMap d    automatic conversion in constructor   This means that if something you want to access is already in dict form  you can turn it into a DotMap for easy access   import json jsonDict   json loads text  data   DotMap jsonDict  print data location city   Finally  it automatically creates new child DotMap instances so you can do things like this   m   DotMap   m people steve age   31   Comparison to Bunch  Full disclosure  I am the creator of the DotMap  I created it because Bunch was missing these features   remembering the order items are added and iterating in that order automatic child DotMap creation  which saves time and makes for cleaner code when you have a lot of hierarchy constructing from a dict and recursively converting all child dict instances to DotMap

User · Answer

Not a direct answer to the OP s question  but inspired by and perhaps useful for some   I ve created an object-based solution using the internal   dict    In no way optimized code   payload          name    John        location              lat   53 12312312           long   43 21345112             numbers                            role    home                number    070-12345678                                    role    office                number    070-12345679                      class Map object               Dot style access to object members  access raw values     with an underscore e g       class Foo Map           def foo self               return self get  foo      bar       obj   Foo     foo    foo         obj foo   gt   foobar      obj  foo   gt   foo                def   init   self   args    kwargs           for arg in args              if isinstance arg  dict                   for k  v in arg iteritems                        self   dict   k    v                     self   dict         k    v          if kwargs              for k  v in kwargs iteritems                    self   dict   k    v                 self   dict         k    v      def   getattribute   self  attr           if hasattr self   get     attr               return object   getattribute   self   get     attr            else              return object   getattribute   self  attr       def get self  key           try              return self   dict   get  get     key            except  AttributeError  TypeError               return self   dict   get key       def   repr   self           return u  lt  name  object gt   format              name self   class     name               class Number Map       def get role self           return self get  role        def get number self           return self get  number     class Location Map       def get latitude self           return self get  lat     1      def get longitude self           return self get  long     1   class Item Map       def get name self           return self get  name       Doe       def get location self           return Location   self get  location         def get numbers self           return  Number   n  for n in self get  numbers        Tests  obj   Item   foo    bar      payload   assert type obj     Item assert obj  name     John  assert obj name     John Doe  assert type obj location     Location assert obj location  lat    53 12312312 assert obj location  long    43 21345112 assert obj location latitude    54 12312312 assert obj location longitude    44 21345112  for n in obj numbers      assert type n     Number     if n role     home           assert n number     070-12345678      if n role     office           assert n number     070-12345679

User · Answer

Use SimpleNamespace    gt  gt  gt  from types import SimpleNamespace     gt  gt  gt  d   dict x  1  2   y   a    b     gt  gt  gt  ns   SimpleNamespace   d   gt  gt  gt  ns x  1  2   gt  gt  gt  ns namespace x  1  2   y   a    b

User · Answer

Using namedtuple allows dot access  It is like a lightweight object which also has the properties of a tuple  It allows to define properties and access them using the dot operator  from collections import namedtuple Data   namedtuple  Data     key1    key2     dataObj   Data val1  key2 val2    can instantiate using keyword arguments and positional arguments  Access using dot operator dataObj key1   Gives val1 datObj key2   Gives val2  Access using tuple indices dataObj 0    Gives val1 dataObj 1    Gives val2  But remember this is a tuple  not a dict  So the below code will give error dataObj  key1     Gives TypeError  tuple indices must be integers or slices  not str  Refer  namedtuple

User · Answer

If you want to pickle your modified dictionary  you need to add few state methods to above answers   class DotDict dict          dot notation access to dictionary attributes        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

User · Answer

One simple way to get dot access  but not array access   is to use a plain object in Python  Like this   class YourObject      def   init   self   args    kwargs           for k  v in kwargs items                setattr self  k  v       and use it like this    gt  gt  gt  obj   YourObject key  value    gt  gt  gt  print obj key   value        to convert it to a dict    gt  gt  gt  print obj   dict      key    value

User · Answer

def dict to object dick         http   stackoverflow com a 1305663 968442      class Struct          def   init   self    entries               self   dict   update entries       return Struct   dick    If one decides to permanently convert that dict to object this should do  You can create a throwaway object just before accessing    d   dict to object d

User · Answer

This also works with nested dicts and makes sure that dicts which are appended later behave the same   class DotDict dict        def   init   self   args    kwargs           super     init    args    kwargs            Recursively turn nested dicts into DotDicts         for key  value in self items                if type value  is dict                  self key    DotDict value       def   setitem   self  key  item           if type item  is dict              item   DotDict item          super     setitem   key  item         setattr       setitem         getattr     dict   getitem

User · Answer

The answer of  derek73 is very neat  but it cannot be pickled nor  deep copied  and it returns None for missing keys  The code below fixes this   Edit  I did not see the answer above that addresses the exact same point  upvoted   I m leaving the answer here for reference   class dotdict dict         setattr     dict   setitem         delattr     dict   delitem        def   getattr   self  name           try              return self name          except KeyError              raise AttributeError name

User · Answer

To build upon epool s answer  this version allows you to access any dict inside via the dot operator  foo          quot bar quot               quot baz quot        quot boo quot     quot hoo quot       quot baba quot     quot loo quot              For instance  foo bar baz 1  baba returns  quot loo quot   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

User · Answer

Building on Kugel s answer and taking Mike Graham s words of caution into consideration  what if we make a wrapper     class DictWrap object         Wrap an existing dict  or create a new one  and access with either dot      notation or key lookup       The attribute  data is reserved and stores the underlying dictionary      When using the    operator with create True  the empty nested dict is      replaced with the operand  effectively creating a default dictionary     of mixed types       args        d      Existing dict to wrap  an empty dict is created by default       create True   Create an empty  nested dict instead of raising a KeyError      example         gt  gt  gt dw   DictWrap   pp  3          gt  gt  gt dw a b    2        gt  gt  gt dw a b    2        gt  gt  gt dw a  c       Hello         gt  gt  gt dw a  c        World         gt  gt  gt dw a d        gt  gt  gt print dw  data         a     c    Hello World    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  A Nested dict will only be replaced if it s empty       else        return other

User · Answer

You can do it using this class I just made  With this class you can use the Map object like another dictionary including json serialization  or with the dot notation  I hope to help you   class Map dict               Example      m   Map   first name    Eduardo    last name  Pool   age 24  sports   Soccer                def   init   self   args    kwargs           super Map  self    init    args    kwargs          for arg in args              if isinstance arg  dict                   for k  v in arg iteritems                        self k    v          if kwargs              for k  v in kwargs iteritems                    self k    v      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    Usage examples   m   Map   first name    Eduardo    last name  Pool   age 24  sports   Soccer      Add new key m new key    Hello world     Or m  new key      Hello world   print m new key print m  new key     Update values m new key    Yay     Or m  new key      Yay     Delete key del m new key   Or del m  new key

User · Answer

The language itself doesn t support this  but sometimes this is still a useful requirement  Besides the Bunch recipe  you can also write a little method which can access a dictionary using a dotted string   def get var input dict  accessor string          Gets data from a dictionary using a dotted accessor-string        current data   input dict     for chunk in accessor string split               current data   current data get chunk          return current data   which would support something like this    gt  gt  test dict     thing     spam   12   foo     cheeze    bar      gt  gt  output   get var test dict   thing spam foo cheeze    gt  gt  print output  bar   gt  gt

User · Answer

I ended up trying BOTH the AttrDict and the Bunch libraries and found them to be way to slow for my uses   After a friend and I looked into it  we found that the main method for writing these libraries results in the library aggressively recursing through a nested object and making copies of the dictionary object throughout   With this in mind  we made two key changes   1  We made attributes lazy-loaded 2  instead of creating copies of a dictionary object  we create copies of a light-weight proxy object   This is the final implementation   The performance increase of using this code is incredible   When using AttrDict or Bunch  these two libraries alone consumed 1 2 and 1 3 respectively of my request time what      This code reduced that time to almost nothing somewhere in the range of 0 5ms    This of course depends on your needs  but if you are using this functionality quite a bit in your code  definitely go with something simple like this     class DictProxy object       def   init   self  obj           self obj   obj      def   getitem   self  key           return wrap self obj key        def   getattr   self  key           try              return wrap getattr self obj  key           except AttributeError              try                  return self key              except KeyError                  raise AttributeError key         you probably also want to proxy important list properties along like       items    iteritems   and   len    class ListProxy object       def   init   self  obj           self obj   obj      def   getitem   self  key           return wrap self obj key          you probably also want to proxy important list properties along like         iter   and   len    def wrap value       if isinstance value  dict           return DictProxy value      if isinstance value   tuple  list            return ListProxy value      return value   See the original implementation here by https   stackoverflow com users 704327 michael-merickel   The other thing to note  is that this implementation is pretty simple and doesn t implement all of the methods you might need   You ll need to write those as required on the DictProxy or ListProxy objects

User · Answer

Derive from dict and and implement   getattr   and   setattr     Or you can use Bunch which is very similar   I don t think it s possible to monkeypatch built-in dict class

User · Answer

Use   getattr    very simple  works 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    Output   10000 StackOverflow

User · Answer

I ve always kept this around in a util file  You can use it as a mixin on your own classes too   class dotdict dict          dot notation access to dictionary attributes          getattr     dict get       setattr     dict   setitem         delattr     dict   delitem    mydict     val   it works   nested dict     val   nested works too   mydict   dotdict mydict  mydict val    it works   mydict nested   dotdict nested dict  mydict nested val    nested works too

User · Answer

I tried this   class dotdict dict       def   getattr   self  name           return self name    you can try   getattribute   too   make every dict a type of dotdict would be good enough  if you want to init this from a multi-layer dict  try implement   init   too

User · Answer

I like the Munch and it gives lot of handy options on top of dot access   import munch temp 1     person       fname    senthil     lname    ramalingam    dict munch   munch munchify temp 1  dict munch person fname

[python] How to use a dot "." to access members of dictionary?

Examples related to python

Examples related to dictionary

Examples related to syntax

Examples related to nested