namedtuple und Standardwerte für optionale Schlüsselwortargumente

Ich Unterklassen namedtuple und überschrieb die __new__ Methode:

from collections import namedtuple

class Node(namedtuple('Node', ['value', 'left', 'right'])):
    __slots__ = ()
    def __new__(cls, value, left=None, right=None):
        return super(Node, cls).__new__(cls, value, left, right)

Dies bewahrt eine intuitive Typ-Hierarchie, die die Schaffung einer factory-Funktion getarnt als Klasse nicht.

InformationsquelleAutor der Antwort justinfay

Mit eingeben.NamedTuple in Python 3.6.1+ können Sie sowohl einen Standard-Wert und eine Art Kommentar zu einem NamedTuple Feld. Verwenden typing.Any wenn Sie nur das erstere:

from typing import Any, NamedTuple


class Node(NamedTuple):
    val: Any
    left: 'Node' = None
    right: 'Node' = None

Verwendung:

>>> Node(1)
Node(val=1, left=None, right=None)
>>> n = Node(1)
>>> Node(2, left=n)
Node(val=2, left=Node(val=1, left=None, right=None), right=None)

Auch im Fall, müssen Sie beide default-Werte und optionale Wandelbarkeit, Python 3.7 ist zu haben,Daten-Klassen (PEP 557)dass in einigen (vielen?) Fällen ersetzen namedtuples.

Nebenbei bemerkt: eine Eigenart der aktuellen Spezifikation von Anmerkungen (Ausdrücke nach : für Parameter und Variablen und nach -> für die Funktionen) in Python ist, dass Sie bewertet werden bei der Bestimmung der Zeit^*. So, da die "class-Namen definiert werden, sobald der gesamte Körper von der Klasse ausgeführt wurde", die Anmerkungen für 'Node' in der Klasse Felder oben müssen strings sein, um zu vermeiden Fehler.

Dieser Art geben Hinweise wird als "forward-reference" ([1][2]), und mit PEP 563 Python 3.7+ geht zu einem __future__ importieren (standardmäßig aktiviert in 4.0), mit denen die vorwärts-Referenzen (ohne Anführungszeichen), die Verschiebung Ihrer Bewertung.

^* AFAICT nur lokale variable Anmerkungen werden nicht zur Laufzeit ausgewertet. (Quelle: PEP 526)

InformationsquelleAutor der Antwort monk-time

Dies ist ein Beispiel direkt aus der docs:

Default-Werte kann umgesetzt werden, indem mit _replace() anpassen
Prototyp-Instanz:

>>> Account = namedtuple('Account', 'owner balance transaction_count')
>>> default_account = Account('<owner name>', 0.0, 0)
>>> johns_account = default_account._replace(owner='John')
>>> janes_account = default_account._replace(owner='Jane')

So, die OP ' s Beispiel wäre:

from collections import namedtuple
Node = namedtuple('Node', 'val left right')
default_node = Node(None, None, None)
example = default_node._replace(val="whut")

Allerdings habe ich wie einige der anderen hier gegebenen Antworten besser. Ich wollte nur hinzufügen, diese auf Vollständigkeit.

InformationsquelleAutor der Antwort Tim Tisdall

Ein etwas erweitertes Beispiel zu initialisieren alle fehlenden Argumente mit None:

from collections import namedtuple

class Node(namedtuple('Node', ['value', 'left', 'right'])):
    __slots__ = ()
    def __new__(cls, *args, **kwargs):
        # initialize missing kwargs with None
        all_kwargs = {key: kwargs.get(key) for key in cls._fields}
        return super(Node, cls).__new__(cls, *args, **all_kwargs)

InformationsquelleAutor der Antwort Dennis Golomazov

Kombination der Ansätze von @Denis und @Mark:

from collections import namedtuple
import inspect

class Node(namedtuple('Node', 'left right val')):
    __slots__ = ()
    def __new__(cls, *args, **kwargs):
        args_list = inspect.getargspec(super(Node, cls).__new__).args[len(args)+1:]
        params = {key: kwargs.get(key) for key in args_list + kwargs.keys()}
        return super(Node, cls).__new__(cls, *args, **params) 

Unterstützen soll erstellen die Tupel mit den positions-Argumenten und auch mit gemischten Fälle.
Testfälle:

>>> print Node()
Node(left=None, right=None, val=None)

>>> print Node(1,2,3)
Node(left=1, right=2, val=3)

>>> print Node(1, right=2)
Node(left=1, right=2, val=None)

>>> print Node(1, right=2, val=100)
Node(left=1, right=2, val=100)

>>> print Node(left=1, right=2, val=100)
Node(left=1, right=2, val=100)

>>> print Node(left=1, right=2)
Node(left=1, right=2, val=None)

aber auch Unterstützung TypeError:

>>> Node(1, left=2)
TypeError: __new__() got multiple values for keyword argument 'left'

InformationsquelleAutor der Antwort teodor

Finde ich diese version einfacher zu Lesen ist:

from collections import namedtuple

def my_tuple(**kwargs):
    defaults = {
        'a': 2.0,
        'b': True,
        'c': "hello",
    }
    default_tuple = namedtuple('MY_TUPLE', ' '.join(defaults.keys()))(*defaults.values())
    return default_tuple._replace(**kwargs)

Dies ist nicht so effizient, wie es erfordert die Erstellung des Objekts zweimal, aber Sie ändern könnte, dass durch die Definition der Standard-duple innerhalb des Moduls und nur die Funktion haben, die ersetzen-Zeile.

InformationsquelleAutor der Antwort Dave31415

Hier ist eine weniger flexible, aber präziser version von Mark Lodato wrapper: Es nimmt die Felder und Standardwerte als ein Wörterbuch.

import collections
def namedtuple_with_defaults(typename, fields_dict):
    T = collections.namedtuple(typename, ' '.join(fields_dict.keys()))
    T.__new__.__defaults__ = tuple(fields_dict.values())
    return T

Beispiel:

In[1]: fields = {'val': 1, 'left': 2, 'right':3}

In[2]: Node = namedtuple_with_defaults('Node', fields)

In[3]: Node()
Out[3]: Node(val=1, left=2, right=3)

In[4]: Node(4,5,6)
Out[4]: Node(val=4, left=5, right=6)

In[5]: Node(val=10)
Out[5]: Node(val=10, left=2, right=3)

InformationsquelleAutor der Antwort Li-Wen Yip

Andere Lösung:

import collections


def defaultargs(func, defaults):
    def wrapper(*args, **kwargs):
        for key, value in (x for x in defaults[len(args):] if len(x) == 2):
            kwargs.setdefault(key, value)
        return func(*args, **kwargs)
    return wrapper


def namedtuple(name, fields):
    NamedTuple = collections.namedtuple(name, [x[0] for x in fields])
    NamedTuple.__new__ = defaultargs(NamedTuple.__new__, [(NamedTuple,)] + fields)
    return NamedTuple

Verwendung:

>>> Node = namedtuple('Node', [
...     ('val',),
...     ('left', None),
...     ('right', None),
... ])
__main__.Node

>>> Node(1)
Node(val=1, left=None, right=None)

>>> Node(1, 2, right=3)
Node(val=1, left=2, right=3)

InformationsquelleAutor der Antwort sirex

Da Sie über namedtuple als eine Daten-Klasse, die Sie sollten sich bewusst sein, dass python 3.7 die Einführung eines @dataclass Dekorateur für diese Zwecke-und natürlich hat default-Werte.

Ein Beispiel aus den docs:

@dataclass
class C:
    a: int       # 'a' has no default value
    b: int = 0   # assign a default value for 'b'

Viel sauberer, lesbarer und verwendbarer als hacking namedtuple. Es ist nicht schwer vorherzusagen, dass die Nutzung von namedtuples fallen mit der Annahme 3.7.

InformationsquelleAutor der Antwort P-Gn