Popular recipes tagged "namedtuple"

Create on-the-fly class adapters with functools.partial (Python)

2014-05-29T18:48:28-07:00

Python recipe 578884 by Christoph Schueler (adapter, namedtuple, partial, pattern).

functools.partial could not only applied to functions it also works with classes. This opens some interesting perspectives, like on-the-fly creation of class adapters, as the following code illustrates.

A class decorator for creating named tuples (Python)

2013-02-14T19:58:13-08:00

Python recipe 578456 by Eric Snow (metaprogramming, namedtuple). Revision 3.

This class decorator factory is useful for replacing the following:

class MyTuple(namedtuple('MyTuple', "a b c")):
    """Something special."""
    @classmethod
    def from_defaults(cls, a, b=None, c=5):
        return cls(a, b, c)

or even:

class MyTuple(namedtuple('MyTuple', "a b c")):
    """Something special."""
    def __new__(cls, a, b=None, c=5):
        return super().__new__(cls, a, b, c)

with this:

@as_namedtuple("a b c", None, c=5)
class MyTuple:
    """Something special."""

I found that I often subclass named tuples to add on some functionality or even just a nice docstring. Plus with the class syntax there's no missing that a class is bound to the name (and it's a little easier to search for the definition). When you subclass a named tuple the boilerplate involved really jumps out.

One of the main reasons Adding support for defaults to namedtuple would mitigate the need for that functionality here, but I'm not going to hold my breath on that.

One nice (though minor) thing is that you don't have to repeat the name when defining the namedtuple.

PseudoStruct (Python)

2012-11-25T03:43:06-08:00

Python recipe 578349 by Matthew Zipay (datastructures, namedtuple, record).

This is a recipe for a Python "data object." It is similar in function to namedtuple (http://code.activestate.com/recipes/500261/) and recordtype (http://code.activestate.com/recipes/576555-records/) in that it is a simple container for data, but is designed to meet three specific goals:

Easy to subclass data objects.
Get/set speed comparable to a simple class.
Minimal memory consumption per instance.

namedtuple.abc - abstract base class + mix-in for named tuples (Python)

2011-04-02T02:07:00-07:00

Python recipe 577629 by Jan Kaliszewski (abc, collections, dry, inheritance, namedtuple, shortcuts). Revision 7.

If you need

to define named tuple subclasses (including reusable abstract ones), adding/overriding some methods, in a convenient way;
to have the named tuple ABC (abstract base class) for isinstance/issubclass tests;
or simply would like to define your named tuple classes in a class-syntax-based and DRY way (without repeating type names...)

-- this recipe is for you.

typesafe records (Python)

2010-07-10T01:43:38-07:00

Python recipe 577249 by andrew johnson (namedtuple, record, type, typesafe). Revision 4.

A typesafe wrapper for namedtuple.

Records (Python)

2008-11-04T06:52:42-08:00

Python recipe 576555 by George Sakkis (datastructures, namedtuple, record).

This is a recipe similar in functionality and exec-style optimized implementation to the very well received namedtuple (http://code.activestate.com/recipes/500261/) that was included in Python 2.6. The main difference is that records, unlike named tuples, are mutable. In addition, fields can have a default value. Instead of subclassing tuple or list, the implementation create a regular class with __slots__.

Parse call function for Py2.6 and Py2.7 (Python)

2009-02-28T20:13:15-08:00

Python recipe 576671 by Jervis Whitley (ast, call, function, namedtuple, nodevisitor, parsing). Revision 14.

In some cases it may be desirable to parse the string expression "f1(*args)" and return some of the key features of the represented function-like call.

This recipe returns the key features in the form of a namedtuple.

e.g. (for the above)

>>> explain("f1(*args)")
[ Call(func='f1', starargs='args') ]

The recipe will return a list of such namedtuples for "f1(*args)\nf2(*args)" Note that while the passed string expression must evaluate to valid python syntax, names needn't be declared in current scope.