Long story short
PEP-557 introduced data classes into Python standard library, that basically can fill the same role as collections.namedtuple
and typing.NamedTuple
. And now I'm wondering how to separate the use cases in which namedtuple is still a better solution.
Data classes advantages over NamedTuple
Of course, all the credit goes to dataclass
if we need:
mutable objects
inheritance support
property decorators, manageable attributes
generated method definitions out of the box or customizable method definitions
Data classes advantages are briefly explained in the same PEP: Why not just use namedtuple.
Q: In which cases namedtuple is still a better choice?
But how about an opposite question for namedtuples: why not just use dataclass? I guess probably namedtuple is better from the performance standpoint but found no confirmation on that yet.
Example
Let's consider the following situation:
We are going to store pages dimensions in a small container with statically defined fields, type hinting and named access. No further hashing, comparing and so on are needed.
NamedTuple approach:
from typing import NamedTuple
PageDimensions = NamedTuple("PageDimensions", [('width', int), ('height', int)])
DataClass approach:
from dataclasses import dataclass
@dataclass
class PageDimensions:
width: int
height: int
Which solution is preferable and why?
P.S. the question isn't a duplicate of that one in any way, because here I'm asking about the cases in which namedtuple is better, not about the difference (I've checked docs and sources before asking)
NamedTuple
s as an input for np.array
will "just work" because (as mentioned in the accepted answer) NamedTuple
inherits from tuple
. Numpy does not handle dataclasses as smoothly (treating them as having dtype object
).
It depends on your needs. Each of them has own benefits.
Here is a good explanation of Dataclasses on PyCon 2018 Raymond Hettinger - Dataclasses: The code generator to end all code generators
In Dataclass
all implementation is written in Python, whereas in NamedTuple
, all of these behaviors come for free because NamedTuple
inherits from tuple
. And because the tuple
structure is written in C, standard methods are faster in NamedTuple
(hash, comparing and etc).
Note also that Dataclass
is based on dict
whereas NamedTuple
is based on tuple
. Thus, you have advantages and disadvantages of using these structures. For example, space usage is less with a NamedTuple
, but time access is faster with a Dataclass
.
Please, see my experiment:
In [33]: a = PageDimensionsDC(width=10, height=10)
In [34]: sys.getsizeof(a) + sys.getsizeof(vars(a))
Out[34]: 168
In [35]: %timeit a.width
43.2 ns ± 1.05 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
In [36]: a = PageDimensionsNT(width=10, height=10)
In [37]: sys.getsizeof(a)
Out[37]: 64
In [38]: %timeit a.width
63.6 ns ± 1.33 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
But with increasing the number of attributes of NamedTuple
access time remains the same small, because for each attribute it creates a property with the name of the attribute. For example, for our case the part of the namespace of the new class will look like:
from operator import itemgetter
class_namespace = {
...
'width': property(itemgetter(0, doc="Alias for field number 0")),
'height': property(itemgetter(0, doc="Alias for field number 1"))**
}
In which cases namedtuple is still a better choice?
When your data structure needs to/can be immutable, hashable, iterable, unpackable, comparable then you can use NamedTuple
. If you need something more complicated, for example, a possibility of inheritance for your data structure then use Dataclass
.
In programming in general, anything that CAN be immutable SHOULD be immutable. We gain two things:
Easier to read the program- we don't need to worry about values changing, once it's instantiated, it'll never change (namedtuple) Less chance for weird bugs
That's why, if the data is immutable, you should use a named tuple instead of a dataclass
I wrote it in the comment, but I'll mention it here: You're definitely right that there is an overlap, especially with frozen=True
in dataclasses- but there are still features such as unpacking belonging to namedtuples, and it always being immutable- I doubt they'll remove namedtuples as such
@dataclass(frozen=True)
?
x, y = point
-
I had this same question, so ran a few tests and documented them here: https://shayallenhill.com/python-struct-options/
Summary:
NamedTuple is better for unpacking, exploding, and size.
DataClass is faster and more flexible.
The differences aren't tremendous, and I wouldn't refactor stable code to move from one to another.
NamedTuple is also great for soft typing when you'd like to be able to pass a tuple instead.
To do this, define a type inheriting from it...
class CircleArg(NamedTuple):
x: float
y: float
radius: float
...then unpack it inside your functions. Don't use the .attributes
, and you'll have a nice "type hint" without any PITA for the caller.
*focus, radius = circle_arg_instance # or tuple
or tuple
parameter syntax ?
Another important limitation to NamedTuple
is that it cannot be generic:
import typing as t
T=t.TypeVar('T')
class C(t.Generic[T], t.NamedTuple): ...
TypeError: Multiple inheritance with NamedTuple is not supported
One usecase for me is frameworks that do not support dataclasses
. In particular, TensorFlow. There, a tf.function
can work with a typing.NamedTuple
but not with a dataclass
.
class MyFancyData(typing.NamedTuple):
some_tensor: tf.Tensor
some_other_stuf: ...
@tf.function
def train_step(self, my_fancy_data: MyFancyData):
...
Success story sharing
dataclasses.Dataclass
andcollections.namedtuple
are both just code generators. facinating. in the case ofcollections.namedtuple
it has a huge template string literal that getsexec
. i thought they were going to create all of this programmatically somehow. but code generation then exec makes sense.dataclass()
decorator accepts a kwargfrozen=True
.