code: def total_size(o, handlers={}, verbose=False, count=False):
      
      # How to make different types of objects iterable
      dict_handler = lambda d: chain.from_iterable(d.items())
      all_handlers = {tuple: iter,
                      list: iter,
                      deque: iter,
                      dict: dict_handler,
                      set: iter,
                      frozenset: iter}
      all_handlers.update(handlers)     # user handlers take precedence
      seen = set()                      # track which object id's have already been seen
      default_size = getsizeof(0)       # estimate sizeof object without __sizeof__
  
      def sizeof(o):
          "Calculate size of `o` and all its children"
          if id(o) in seen:             # do not double count the same object
              return 0
          seen.add(id(o))
          if count:
              s = 1
          else:
              s = getsizeof(o, default_size)
          # If `o` is iterable, add size of its members
          for typ, handler in all_handlers.items():
              if isinstance(o, typ):
                  s += sum(map(sizeof, handler(o)))
                  break
          return s
  
      return sizeof(o)
docs: Returns the approximate memory footprint an object and all of its contents.
  
      Automatically finds the contents of the following builtin containers and
      their subclasses:  tuple, list, deque, dict, set and frozenset.
      To search other containers, add handlers to iterate over their contents:
  
          handlers = {SomeContainerClass: iter,
                      OtherContainerClass: OtherContainerClass.get_elements}
  
      Source: http://code.activestate.com/recipes/577504/ (r3)