Add __len__() method to types.SimpleNamespace

[TomasCorreia2003]

Feature or enhancement

Proposal:

SimpleNamespace is a useful lightweight object container, but currently:

from types import SimpleNamespace
ns = SimpleNamespace(a=1, b=2)
len(ns)  # Raises TypeError

Adding a len() method would improve its usability by allowing:

len(ns)  # returns 2

This matches user expectations since its attributes are stored in dict.

Proposed Implementation:
Define:

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

This is simple, backwards-compatible, and testable.

Benefits:
Improves discoverability

Makes SimpleNamespace feel more like a container

Zero risk of breakage

I would like to implement this as a small contribution.

Has this already been discussed elsewhere?

This is a minor feature, which does not need previous discussion elsewhere

Links to previous discussion of this feature:

No response

[ericvsmith]

How would this be useful? Can you give a code example where this would be needed? And why would it be useful if you can't iterate over a SimpleNamespace?

And why would it only be useful for SimpleNamespace? Why not also dataclasses?

I don't think there's much chance of this being accepted, but if you want to pursue it, the correct way to go about a feature request is to discuss it on https://discuss.python.org/c/ideas/6

[ethanfurman]

The fact that SimpleNamespace uses a __dict__ for storage is an implementation detail and should not affect user expectations. Also, IIRC, SimpleNamespace was designed as an easier alternative to using a full class; i.e.:

class NotSimpleNamespace:
    def __init__(self, a, b):
        self.a = a
        self.b = b

nsn = NotSimpleNamespace(1, 2)
nsn.a   # -> 1
nsn.b   # -> 2

and standard classes do not support len(). (The only classes I am aware of that do support len() are enums, and they use a custom metaclass to do it.)

[mpkocher]

Once you add one of these collection-like methods, it can easily snowball into adding __contains__, __iter__, etc...

Also, SimpleNamespace is in types and not collections because (by design), it doesn't have collection-like semantics.

Adding collection-like methods would mean it should move from types to collections (or at least be confusing why it's in types).

[mpkocher]

The fact that SimpleNamespace uses a __dict__ for storage is an implementation detail and should not affect user expectations.

True, but it does leak implemenation details.

In [1]: from types import SimpleNamespace

In [2]: a = SimpleNamespace(a=1, b=2)

In [3]: b = SimpleNamespace(a=1, b=3)

In [4]: a < b
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[4], line 1
----> 1 a < b

TypeError: '<' not supported between instances of 'dict' and 'dict'

In [5]: 

[picnixz]

Looks like we can have a better error message in this case