• Capabilities
• Requirements
• Installation
• Usage
• Background
• namedtuple objects and The Zen of Python

• Converts Python iterable objects (list, tuple, set, etc.) into namedtuple objects using a decorator function, so you don't have to rewrite code that already returns iterable objects.

• Sets namedtuple attribute names in one of three ways:

  1. Entering attribute names at input prompts (default).
  2. Manually, by passing an iterable object of attribute names as a keyword argument to the decorated function.
  3. Setting a keyword argument to automatically generate attribute names.

• Automatically corrects attribute name entries that would be invalid.

• Python 3.9+

Install via Python pip:

pip install namedtuple-maker

Python tuple objects are great, right? So are list, set, and many other iterable Python objects. However, accessing the values of an iterable object using arbitrary index numbers can make code difficult to read. For example, the following list object stores data about the foods I might eat in a given day:

my_meals = [
    'pizza',
    'blueberry pancakes',
    'granola',
    'fruit smoothie',
    'rice and beans'
]

Let's say that I want to access values in the list object named my_food. I can do that by referencing one or more numeric list indices like this:

print('My Meals')
print('--------')
print(f'Breakfast: {my_meals[1]}\n'
      f'Snack: {my_meals[3]}\n'
      f'Lunch: {my_meals[4]}')

The resulting output from this code is:

My Meals
--------
Breakfast: blueberry pancakes
Snack: fruit smoothie
Lunch: rice and beans

That works just fine, although it's not terribly intuitive to associate a list (or tuple) index number with a certain meal of the day, since this list doesn't have meals in any particular order. The list index assigned to each meal is arbitrary.

The collections module in the Python Standard Library includes the namedtuple function, which allows you to, as the name implies, create tuple-like objects with values that you can reference by name. What does that mean, practically? Well, it means you can access the values in an iterable object by an explicit attribute name that is much more meaningful than an arbitrary index number.

For example, I'll recreate the my_meals data using a namedtuple object:

1. First, import the namedtuple function from the collections module:

   from collections import namedtuple

2. Next, create a new object type using the namedtuple function.

   • Think of a namedtuple object like a class object with named attributes, but no methods.
   • The typename parameter is an arbitrary name for the object class.
   • The field_names parameter defines the attribute names for the new object.

   Meals = namedtuple(
       typename='Meals',
       field_names=[
           'breakfast',
           'snack',
           'lunch',
           'dinner',
           'dessert'
       ]
   )

3. Now, create an instance of the Meals object, and assign the individual foods to each of the named attributes (specified by the field_names parameter):

   my_meals = Meals(
       breakfast='blueberry pancakes',
       snack='fruit smoothie',
       lunch='rice and beans',
       dinner='pizza',
       dessert='granola'
   )

When I want to access or display data from the namedtuple object named my_meals, my code will look something like this:

print('My Meals')
print('--------')
print(f'Breakfast: {my_meals.breakfast}\n'
      f'Snack: {my_meals.snack}\n'
      f'Lunch: {my_meals.lunch}')

The result from this code looks exactly like it did in the first example:

My Meals
--------
Breakfast: blueberry pancakes
Snack: fruit smoothie
Lunch: rice and beans

The key difference between the list example and the namedtuple example is, accessing the values in the namedtuple object uses explicit named attributes (my_meals.lunch), rather than arbitrary index numbers (my_meals[4]).

For me, it's much easier to remember that the food I ate for breakfast is accessible as my_foods.breakfast within a namedtuple object, than it is to remember an arbitrary list index value like my_foods[3].

The Zen of Python is a great guide for how to write clean and effective Python code. Below is an extract of some of the lines in the output of an import this command.

The intent of the named-tuplemaker package is to help Python developers write code that improves compliance with The Zen of Python by making it simple and easy to access iterable object values by explicit attribute names, rather than arbitrary index numbers.

The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
...
Readability counts.
...