Python 3.7: Utility of Dataclasses and SimpleNameSpace

  • A+
Category:Languages

Python 3.7 provides new dataclasses which have predefined special functions.

From an overview point, dataclasses and SimpleNameSpace both provide nice data encapsulating facility.

@dataclass class MyData:     name:str     age: int  data_1 = MyData(name = 'JohnDoe' , age = 23)  data_2 = SimpleNameSpace(name = 'JohnDoe' , age = 23) 

A lot of times I use SimpleNameSpace just to wrap data and move it around.

I even subclass it to add special functions:

from types import SimpleNameSpace  class NewSimpleNameSpace(SimpleNameSpace):     def __hash__(self):         return some_hashing_func(self.__dict__) 

For my question:

  1. How does someone choose between SimpleNameSpace and dataclasses?
  2. Why were they necessary, when the same effect can be achieved with extending the SimpleNameSpace?
  3. What all other use cases dataclasses cater to?

 


The short answer is that this is all covered by PEP 557. Taking your questions slightly out of order...

Why?

  1. To leverage PEP 526 to provide a simple way to define such classes.
  2. To support static type checkers.

How to pick when to use them?

The PEP is quite clear that they are not a replacement and expect the other solutions to have their own place.

Like any other design decision, you'll therefore need to decide exactly what features you care about. If that includes the following, you definitely don't want dataclasses.

Where is it not appropriate to use Data Classes?

API compatibility with tuples or dicts is required. Type validation beyond that provided by PEPs 484 and 526 is required, or value validation or conversion is required.

That said, the same is true for SimpleNameSpace, so what else can we look at to decide? Let's take a closer look at the extra features provided by dataclasses...

The existing definition of SimpleNameSpace is as follows:

A simple object subclass that provides attribute access to its namespace, as well as a meaningful repr.

The python docs then go on to say that it provides a simple __init__, __repr__ and __eq__ implementation. Comparing this to PEP 557, dataclasses also give you options for:

  • ordering - comparing the class as if it were a tuple of its fields, in order.
  • immutability - where assigning to fields will generate an exception
  • control of the hashing - though this isn't recommended.

Clearly, then, you should use dataclasses if you care about ordering or immutability (or need the niche hashing control).

Other use cases?

None that I can see, though you could argue that the initial "why?" covers other use cases.

Comment

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: