Reading the [changes in Python 3.1][1], I found something... unexpected:

&gt; The sys.version_info tuple is now a **named tuple**:

I never heard about named tuples before, and I thought elements could either be indexed by numbers (like in tuples and lists) or by keys (like in dicts). I never expected they could be indexed both ways.

Thus, my questions are:

* What are named tuples?
* How to use them?
* Why/when should I use named tuples instead of normal tuples?
* Why/when should I use normal tuples instead of named tuples?
* Is there any kind of &quot;named list&quot; (a mutable version of the named tuple)?

  [1]: http://docs.python.org/py3k/whatsnew/3.1.html#new-improved-and-deprecated-modules

What are &quot;named tuples&quot; in Python?

I&#39;m trying to convert a longish hollow &quot;data&quot; class into a named tuple. My class currently looks like this:


    class Node(object):
        def __init__(self, val, left=None, right=None):
            self.val = val
            self.left = left
            self.right = right

After conversion to `namedtuple` it looks like:

    from collections import namedtuple
    Node = namedtuple(&#39;Node&#39;, &#39;val left right&#39;)

But there is a problem here. My original class allowed me to pass in just a value and took care of the default by using default values for the named/keyword arguments. Something like:

    class BinaryTree(object):
        def __init__(self, val):
            self.root = Node(val)

But this doesn&#39;t work in the case of my refactored named tuple since it expects me to pass all the fields. I can of course replace the occurrences of `Node(val)` to `Node(val, None, None)` but it isn&#39;t to my liking.

So does there exist a good trick which can make my re-write successful without adding a lot of code complexity (metaprogramming) or should I just swallow the pill and go ahead with the &quot;search and replace&quot;? :)

Named tuple and default values for optional keyword arguments

I have a named tuple class in python 

    class Town(collections.namedtuple(&#39;Town&#39;, [
        &#39;name&#39;, 
        &#39;population&#39;,
        &#39;coordinates&#39;,
        &#39;population&#39;, 
        &#39;capital&#39;, 
        &#39;state_bird&#39;])):
        # ...


I&#39;d like to convert Town instances into dictionaries. I don&#39;t want it to be rigidly tied to the names or number of the fields in a Town. 

Is there a way to write it such that I could add more fields, or pass an entirely different named tuple in and get a dictionary.

I can not alter the original class definition as its in someone else&#39;s code. So I need to take an instance of a Town and convert it to a dictionary.


Convert a namedtuple into a dictionary

Consider following piece of code:


    from collections import namedtuple
    point = namedtuple(&quot;Point&quot;, (&quot;x:int&quot;, &quot;y:int&quot;))

The Code above is just a way to demonstrate as to what I am trying to achieve.
I would like to make `namedtuple` with type hints. 

Do you know any elegant way how to achieve result as intended?



Type hints in namedtuple

I see patterns like

    def __init__(self, x, y, z):
        ...
        self.x = x
        self.y = y
        self.z = z
        ...

quite frequently, often with a lot more parameters. Is there a good way to avoid this type of tedious repetitiveness? Should the class inherit from `namedtuple` instead?


How do I avoid the &quot;self.x = x; self.y = y; self.z = z&quot; pattern in __init__?

Long story short
----------------

[PEP-557][1] introduced data classes into Python standard library, that basically can fill the same role as `collections.namedtuple` and `typing.NamedTuple`. And now I&#39;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][2].

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&#39;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(&quot;PageDimensions&quot;, [(&#39;width&#39;, int), (&#39;height&#39;, 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&#39;t a duplicate of [that one][3] in any way, because here I&#39;m asking about **the cases** in which namedtuple is better, not about **the difference** (I&#39;ve checked docs and sources before asking)


  [1]: https://www.python.org/dev/peps/pep-0557/
  [2]: https://www.python.org/dev/peps/pep-0557/#why-not-just-use-namedtuple
  [3]: https://stackoverflow.com/questions/47955263

Data Classes vs typing.NamedTuple primary use cases

Can anyone amend [namedtuple][1] or provide an alternative class so that it works for mutable objects?

Primarily for readability, I would like something similar to namedtuple that does this:

    from Camelot import namedgroup
    
    Point = namedgroup(&#39;Point&#39;, [&#39;x&#39;, &#39;y&#39;])
    p = Point(0, 0)
    p.x = 10
    
    &gt;&gt;&gt; p
    Point(x=10, y=0)

    &gt;&gt;&gt; p.x *= 10
    Point(x=100, y=0)

It must be possible to pickle the resulting object.  And per the characteristics of named tuple, the ordering of the output when represented must match the order of the parameter list when constructing the object.


  [1]: http://code.activestate.com/recipes/500261/

Existence of mutable named tuple in Python?

What is the recommended way of serializing a [`namedtuple`][1] to json with the field names retained?

Serializing a `namedtuple` to json results in only the values being serialized and the field names being lost in translation. I would like the fields also to be retained when json-ized and hence did the following:

    class foobar(namedtuple(&#39;f&#39;, &#39;foo, bar&#39;)):
        __slots__ = ()
        def __iter__(self):
            yield self._asdict()

The above serializes to json as I expect and behaves as `namedtuple` in other places I use (attribute access etc.,) except with a non-tuple like results while iterating it (which fine for my use case).

What is the &quot;correct way&quot; of converting to json with the field names retained?


  [1]: http://docs.python.org/dev/library/collections.html#collections.namedtuple

Serializing a Python namedtuple to json

I can access elements of a named tuple by name as follows(*):

    from collections import namedtuple
    Car = namedtuple(&#39;Car&#39;, &#39;color mileage&#39;)
    my_car = Car(&#39;red&#39;, 100)
    print my_car.color

But how can I use a variable to specify the name of the field I want to access? E.g.

    field = &#39;color&#39;
    my_car[field] # doesn&#39;t work
    my_car.field # doesn&#39;t work

My actual use case is that I&#39;m iterating through a pandas dataframe with `for row in data.itertuples()`. I am doing an operation on the value from a particular column, and I want to be able to specify the column to use by name as a parameter to the method containing this loop.



(*) [example taken from here](https://dbader.org/blog/writing-clean-python-with-namedtuples). I am using Python 2.7.


How to access a field of a namedtuple using a variable for the field name?

I have a dictionary like:

    d = {&#39;a&#39;: 1, &#39;b&#39;: 2, &#39;c&#39;: 3, &#39;d&#39;: 4}

which I would like to convert to a namedtuple.
My current approach is with the following code

    namedTupleConstructor = namedtuple(&#39;myNamedTuple&#39;, &#39; &#39;.join(sorted(d.keys())))
    nt= namedTupleConstructor(**d)

which produces

&gt;  myNamedTuple(a=1, b=2, c=3, d=4)

This works fine for me (I think), but am I missing a built-in such as... 

    nt = namedtuple.from_dict() ?

UPDATE: as discussed in the comments, my reason for wanting to convert my dictionary to a namedtuple is so that it becomes hashable, but still generally useable  like a dict.

UPDATE2: 4 years after I&#39;ve posted this question, [TLK posts a new answer](https://stackoverflow.com/a/68947528/1870832) recommending using the dataclass decorator that I think is really great. I think that&#39;s now what I would use going forward. 

Pythonic way to convert a dictionary into namedtuple or another hashable dict-like?

Is it possible to add a documentation string to a namedtuple in an easy manner?

I tried

    from collections import namedtuple

    Point = namedtuple(&quot;Point&quot;, [&quot;x&quot;, &quot;y&quot;])
    &quot;&quot;&quot;
    A point in 2D space
    &quot;&quot;&quot;

    # Yet another test

    &quot;&quot;&quot;
    A(nother) point in 2D space
    &quot;&quot;&quot;
    Point2 = namedtuple(&quot;Point2&quot;, [&quot;x&quot;, &quot;y&quot;])

    print Point.__doc__ # -&gt; &quot;Point(x, y)&quot;
    print Point2.__doc__ # -&gt; &quot;Point2(x, y)&quot;

but that doesn&#39;t cut it. Is it possible to do in some other way?

Adding docstrings to namedtuples?

I want to sort a list of named tuples without having to remember the index of the fieldname. My solution seems rather awkward and was hoping someone would have a more elegant solution.

    from operator import itemgetter
    from collections import namedtuple

    Person = namedtuple(&#39;Person&#39;, &#39;name age score&#39;)
    seq = [
        Person(name=&#39;nick&#39;, age=23, score=100),
        Person(name=&#39;bob&#39;, age=25, score=200),
    ]

    # sort list by name
    print(sorted(seq, key=itemgetter(Person._fields.index(&#39;name&#39;))))
    # sort list by age
    print(sorted(seq, key=itemgetter(Person._fields.index(&#39;age&#39;))))

Thanks,
Nick

Pythonic way to sorting list of namedtuples by field name

I&#39;m learning how to use pickle. I&#39;ve created a namedtuple object, appended it to a list, and tried to pickle that list. However, I get the following error:

    pickle.PicklingError: Can&#39;t pickle &lt;class &#39;__main__.P&#39;&gt;: it&#39;s not found as __main__.P

I found that if I ran the code without wrapping it inside a function, it works perfectly. Is there an extra step required to pickle an object when wrapped inside a function?

Here is my code:

    from collections import namedtuple
    import pickle
    
    def pickle_test():
        P = namedtuple(&quot;P&quot;, &quot;one two three four&quot;)
        my_list = []
        abe = P(&quot;abraham&quot;, &quot;lincoln&quot;, &quot;vampire&quot;, &quot;hunter&quot;)
        my_list.append(abe)
        with open(&#39;abe.pickle&#39;, &#39;wb&#39;) as f:
            pickle.dump(abe, f)
        
    pickle_test()

How to pickle a namedtuple instance correctly

Why does Python not support a record type natively? It&#39;s a matter of having a mutable version of namedtuple.

I could use `namedtuple._replace`. But I need to have these records in a collection and since `namedtuple._replace` creates another instance, I also need to modify the collection which becomes messy quickly. 

Background:
I have a device whose attributes I need to get by polling it over TCP/IP. i.e. its representation is a mutable object.

Edit:
I have a set of devices for whom I need to poll.

Edit:
I need to iterate through the object displaying its attributes using PyQt. I know I can add special methods like `__getitem__` and `__iter__`, but I want to know if there is an easier way.

Edit:
I would prefer a type whose attribute are fixed (just like they are in my device), but are mutable.

Why does Python not support record type? (i.e. mutable namedtuple)

I was having trouble implementing `namedtuple._replace()`, so I copied the code right off of the documentation:

    Point = namedtuple(&#39;Point&#39;, &#39;x,y&#39;)
    
    p = Point(x=11, y=22)
    
    p._replace(x=33)
    
    print p

and I got:

    Point(x=11, y=22)

instead of:

    Point(x=33, y=22)

as is shown in the doc.

I&#39;m using Python 2.6 on Windows 7

What&#39;s going on?

namedtuple._replace() doesn&#39;t work as described in the documentation

How do I check if an object is an instance of a [Named tuple][1]?


  [1]: http://docs.python.org/dev/library/collections.html#namedtuple-factory-function-for-tuples-with-named-fields

How to check if an object is an instance of a namedtuple?

It looks like [this][1] or [this][2] are somewhat related threads, but still haven&#39;t figured things out :)

I&#39;m trying to create a subclass of `namedtuple` and provide different initializers so that I can construct objects in different ways.  For example:

    &gt;&gt;&gt; from collections import namedtuple
    &gt;&gt;&gt; class C(namedtuple(&quot;C&quot;, &quot;x, y&quot;)) :
    ...     __slots__ = ()
    ...     def __init__(self, obj) : # Initialize a C instance by copying values from obj
    ...         self.x = obj.a
    ...         self.y = obj.b
    ...     def __init__(self, x, y) : # Initialize a C instance from the parameters
    ...         self.x = x
    ...         self.y = y

However, that doesn&#39;t work:

    &gt;&gt;&gt; c = C(1, 2)
    Traceback (most recent call last):
      File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;
      File &quot;&lt;stdin&gt;&quot;, line 7, in __init__
    AttributeError: can&#39;t set attribute

After some poking around (for example, see [this][3] thread) I tried to use constructors instead of initializers:

    &gt;&gt;&gt; from collections import namedtuple
    &gt;&gt;&gt; class C(namedtuple(&quot;C&quot;, &quot;x, y&quot;)) :
    ...     __slots__ = ()
    ...     def __new__(cls, obj) :
    ...       self = super(C, cls).__new__(cls, obj.a, obj.b)
    ...     def __new__(cls, x, y) :
    ...       self = super(C, cls).__new__(cls, x, y)

which seemed to construct an object but then I can&#39;t read its attributes:

    &gt;&gt;&gt; c = C(1,2)
    &gt;&gt;&gt; c.x, c.y
    Traceback (most recent call last):
      File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;
    AttributeError: &#39;NoneType&#39; object has no attribute &#39;x&#39;

Where am I going wrong here?  How can I create a subclass with multiple constructors or initializers?


  [1]: https://stackoverflow.com/questions/1529002/cant-set-attributes-of-object-class
  [2]: https://stackoverflow.com/questions/4183432/cant-set-attribute-with-new-style-properties-in-python
  [3]: https://stackoverflow.com/questions/12745671/cannot-init-an-instance-of-a-subclassed-namedtuple

Can&#39;t set attribute for subclasses of namedtuple

I&#39;d like to use namedtuples internally, but I want to preserve compatibility with users that feed me ordinary tuples.

    from collections import namedtuple
    
    tuple_pi = (1, 3.14, &quot;pi&quot;)  #Normal tuple 
    
    Record = namedtuple(&quot;Record&quot;, [&quot;ID&quot;, &quot;Value&quot;, &quot;Name&quot;])
    
    named_e = Record(2, 2.79, &quot;e&quot;)  #Named tuple
    
    named_pi = Record(tuple_pi)  #Error
    TypeError: __new__() missing 2 required positional arguments: &#39;Value&#39; and &#39;Name&#39;
    
    tuple_pi.__class__ = Record
    TypeError: __class__ assignment: only for heap types

All Namedtuple Solutions on Gang of Coders

Total of 18 Namedtuple Solutions

What are "named tuples" in Python?