Home > Article > Backend Development > Python data structure: an underrated Namedtuple (2)
python video tutorialThe column continues to take you to understand the Namedtuple of Python data structure.
Part 1Python data structure: an underestimated Namedtuple (1) After talking about some basic usage of namedtuple, this article continues.
Prior to Python 3.7, you could create a simple data container using any of the following methods:
attrs
If you want to use regular classes, that means you will have to implement a few methods. For example, a regular class would require an __init__
method to set properties during class instantiation. If you want the class to be hashable, that means implementing a __hash__
method yourself. In order to compare different objects, you also need to __eq__
implement a method. Finally, to simplify debugging, you need a __repr__
method.
Let's use regular classes to implement our color use case.
class Color: """A regular class that represents a color.""" def __init__(self, r, g, b, alpha=0.0): self.r = r self.g = g self.b = b self.alpha = alpha def __hash__(self): return hash((self.r, self.g, self.b, self.alpha)) def __repr__(self): return "{0}({1}, {2}, {3}, {4})".format( self.__class__.__name__, self.r, self.g, self.b, self.alpha ) def __eq__(self, other): if not isinstance(other, Color): return False return ( self.r == other.r and self.g == other.g and self.b == other.b and self.alpha == other.alpha )复制代码
As above, you need to implement many methods. You just need a container to hold your data for you without worrying about distracting details. Again, a key difference in why people prefer implementation classes is that regular classes are mutable.
In fact, the PEP that introduces Data Classes
refers to them as "mutable namedtuples with default values" (Translator's Note: Data Class introduced in python 3.7, reference: docs.python.org/zh-cn/3/lib…
Now, let’s see how to do it using data classes
.
from dataclasses import dataclass ...@dataclassclass Color: """A regular class that represents a color.""" r: float g: float b: float alpha: float复制代码
Wow! That’s it Simple. Since there is no __init__
, you just define the properties after the docstring. Additionally, they must be annotated with type hints.
In addition to being mutable, data classes can Optional fields are provided out of the box. Suppose our Color class does not require an alpha field. Then we can make it optional.
from dataclasses import dataclassfrom typing import Optional ...@dataclassclass Color: """A regular class that represents a color.""" r: float g: float b: float alpha: Optional[float]复制代码
We can instantiate it like this:
>>> blue = Color(r=0, g=0, b=255)复制代码
Since They are mutable, so we can change any field we want. We can instantiate it like this:
>>> blue = Color(r=0, g=0, b=255) >>> blue.r = 1 >>> # 可以设置更多的属性字段 >>> blue.e = 10复制代码
In comparison, namedtuple
has no optional fields by default .To add them we need a little trickery and some metaprogramming.
Tip: To add the __hash__
method you need to make it immutable by setting unsafe_hash
to True
:
@dataclass(unsafe_hash=True)class Color: ...复制代码
Another difference is that unpacking is a built-in function of namedtuples (first-class citizen). If you want the data class
to have If you have the same behavior, you must implement yourself.
from dataclasses import dataclass, astuple ...@dataclassclass Color: """A regular class that represents a color.""" r: float g: float b: float alpha: float def __iter__(self): yield from dataclasses.astuple(self)复制代码
Only comparing functions is not enough, namedtuple and data classes are also different in performance. The data class implements dict based on pure Python. This makes them faster when accessing fields. Namedtuples, on the other hand, are just regular extended tuples. This means that their implementation is based on faster C code and has a smaller memory footprint.
To prove At this point, please consider running this experiment on Python 3.8.5.
In [6]: import sys In [7]: ColorTuple = namedtuple("Color", "r g b alpha") In [8]: @dataclass ...: class ColorClass: ...: """A regular class that represents a color.""" ...: r: float ...: g: float ...: b: float ...: alpha: float ...: In [9]: color_tup = ColorTuple(r=50, g=205, b=50, alpha=1.0) In [10]: color_cls = ColorClass(r=50, g=205, b=50, alpha=1.0) In [11]: %timeit color_tup.r36.8 ns ± 0.109 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each) In [12]: %timeit color_cls.r38.4 ns ± 0.112 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each) In [15]: sys.getsizeof(color_tup) Out[15]: 72In [16]: sys.getsizeof(color_cls) + sys.getsizeof(vars(color_cls)) Out[16]: 152复制代码
As above, data classes are slightly faster to access fields in, but they take up more memory space than nametuples.
Data classes use type hints by default. We can also put them on namedtuples. We can annotate Color tuples by importing the Namedtuple annotation type and inheriting from it .
from typing import NamedTuple ...class Color(NamedTuple): """A namedtuple that represents a color.""" r: float g: float b: float alpha: float复制代码
Another detail that may not have been noticed is that this approach also allows us to use docstrings. If we enter help(Color) we will be able to see them.
Help on class Color in module __main__:class Color(builtins.tuple) | Color(r: float, g: float, b: float, alpha: Union[float, NoneType]) | | A namedtuple that represents a color. | | Method resolution order: | Color | builtins.tuple | builtins.object | | Methods defined here: | | __getnewargs__(self) | Return self as a plain tuple. Used by copy and pickle. | | __repr__(self) | Return a nicely formatted representation string | | _asdict(self) | Return a new dict which maps field names to their values.复制代码
In the previous section, we learned that data classes can have optional values. In addition, I mentioned that to imitate the same behavior, namedtuple
requires some technical modifications. It turns out that we can use inheritance as shown in the following example.
from collections import namedtupleclass Color(namedtuple("Color", "r g b alpha")): __slots__ = () def __new__(cls, r, g, b, alpha=None): return super().__new__(cls, r, g, b, alpha)>>> c = Color(r=0, g=0, b=0)>>> c Color(r=0, g=0, b=0, alpha=None)复制代码
Tuple is a very powerful data structure. They make our code cleaner and more reliable. Despite the fierce competition with the new data classes
, they still have a large number of scenarios available. In this tutorial, we learned several ways to use namedtuples
and we hope you can use them.
Related free learning recommendations: python video tutorial
The above is the detailed content of Python data structure: an underrated Namedtuple (2). For more information, please follow other related articles on the PHP Chinese website!