namedtuple

`namedtuple` allows us to create a lightweight data structure with named fields. It provides a convenient way to define simple classes without writing a full class definition.

To use `namedtuple`, you need to import it from the `collections` module. Here's an example:


from collections import namedtuple

Person = namedtuple("Person", ["name", "age", "city"])
person = Person("Alice", 25, "New York")

print(person.name)  # Output: Alice
print(person.age)  # Output: 25
print(person.city)  # Output: New York
Alice
25
New York

In this code, we create a named tuple called `Person` using the `namedtuple` function. The first argument is the name of the named tuple, and the second argument is a list of field names as strings.

We create an instance of the `Person` named tuple called `person` with values `"Alice"`, `25`, and `"New York"`. We can access the fields of the named tuple using dot notation, such as `person.name`, `person.age`, and `person.city`.

The benefit of using `namedtuple` is that it provides a more readable and concise way to define simple classes with named fields. It saves you from writing a full class definition when you only need a lightweight data structure.

Both `namedtuple` and [dataclasses](/tutorials/dataclasses) are useful tools for creating lightweight classes to store data. Here are some considerations to help you decide when to use `namedtuple` or `dataclasses`:

Use `namedtuple` when:

- You need a simple data structure with named fields.
- You want a lightweight class without additional functionality or methods.
- You don't need mutability (i.e., the values of fields won't change after creation).

Use `dataclasses` when:

- You want a more feature-rich class with additional functionality.
- You need mutability and want to modify the values of fields after creation.
- You want automatic generation of common methods like `__init__`, `__repr__`, and `__eq__`.
- You want to take advantage of other features provided by `dataclasses`, such as automatic ordering, hashing, and default values.

In general, if you need a simple data container with named fields and no additional functionality, `namedtuple` is a lightweight and efficient choice. On the other hand, if you require more features and flexibility, or if you anticipate the need for additional methods or customization, `dataclasses` provide a more comprehensive solution.

Consider your specific requirements and the desired functionality of your class to determine whether `namedtuple` or `dataclasses` is the better fit for your use case.

You may also like