namedtuple dan nilai default untuk argumen kata kunci opsional

Saya mencoba untuk mengkonversi "data" kelas gondrong gondrong menjadi tuple bernama. Kelas saya saat ini terlihat seperti ini:

class Node(object):
    def __init__(self, val, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

Setelah konversi menjadi namedtupleseperti:

from collections import namedtuple
Node = namedtuple('Node', 'val left right')

Tapi ada masalah di sini. Kelas asli saya memungkinkan saya untuk memberikan nilai dan menjaga standar dengan menggunakan nilai default untuk argumen nama / kata kunci. Sesuatu seperti:

class BinaryTree(object):
    def __init__(self, val):
        self.root = Node(val)

Tapi ini tidak berfungsi dalam kasus tuple bernama refactored saya karena mengharapkan saya untuk lulus semua bidang. Tentu saja saya bisa menggantikan kejadian Node(val)untuk Node(val, None, None)tetapi tidak sesuai dengan keinginan saya.

Jadi apakah ada trik bagus yang dapat membuat penulisan ulang saya berhasil tanpa menambahkan banyak kerumitan kode (metaprogramming) atau haruskah saya menelan pil dan melanjutkan dengan "pencarian dan ganti"? :)

Python 3.7

Gunakan parameter default .

>>> from collections import namedtuple
>>> fields = ('val', 'left', 'right')
>>> Node = namedtuple('Node', fields, defaults=(None,) * len(fields))
>>> Node()
Node(val=None, left=None, right=None)

Atau lebih baik lagi, gunakan perpustakaan kacamata baru , yang jauh lebih bagus daripada namedtuple.

>>> from dataclasses import dataclass
>>> from typing import Any
>>> @dataclass
... class Node:
...     val: Any = None
...     left: 'Node' = None
...     right: 'Node' = None
>>> Node()
Node(val=None, left=None, right=None)

Sebelum Python 3.7

Setel Node.__new__.__defaults__ke nilai default.

>>> from collections import namedtuple
>>> Node = namedtuple('Node', 'val left right')
>>> Node.__new__.__defaults__ = (None,) * len(Node._fields)
>>> Node()
Node(val=None, left=None, right=None)

Sebelum Python 2.6

Setel Node.__new__.func_defaultske nilai default.

>>> from collections import namedtuple
>>> Node = namedtuple('Node', 'val left right')
>>> Node.__new__.func_defaults = (None,) * len(Node._fields)
>>> Node()
Node(val=None, left=None, right=None)

Memesan

Di semua versi Python, jika Anda menetapkan lebih sedikit nilai default daripada yang ada di namesuple, default diterapkan ke parameter paling kanan. Ini memungkinkan Anda menyimpan beberapa argumen seperti argumen yang diperlukan.

>>> Node.__new__.__defaults__ = (1,2)
>>> Node()
Traceback (most recent call last):
  ...
TypeError: __new__() missing 1 required positional argument: 'val'
>>> Node(3)
Node(val=3, left=1, right=2)

Wrapper untuk Python 2.6 hingga 3.6

Inilah pembungkus untuk Anda, yang bahkan memungkinkan Anda (secara opsional) mengatur nilai default ke sesuatu selain None. Ini tidak mendukung argumen yang diperlukan.

import collections
def namedtuple_with_defaults(typename, field_names, default_values=()):
    T = collections.namedtuple(typename, field_names)
    T.__new__.__defaults__ = (None,) * len(T._fields)
    if isinstance(default_values, collections.Mapping):
        prototype = T(**default_values)
    else:
        prototype = T(*default_values)
    T.__new__.__defaults__ = tuple(prototype)
    return T

Contoh:

>>> Node = namedtuple_with_defaults('Node', 'val left right')
>>> Node()
Node(val=None, left=None, right=None)
>>> Node = namedtuple_with_defaults('Node', 'val left right', [1, 2, 3])
>>> Node()
Node(val=1, left=2, right=3)
>>> Node = namedtuple_with_defaults('Node', 'val left right', {'right':7})
>>> Node()
Node(val=None, left=None, right=7)
>>> Node(4)
Node(val=4, left=None, right=7)

Saya subclassed namedtuple dan mengalahkan __new__metode:

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)

Ini mempertahankan hierarki tipe intuitif, yang penciptaan fungsi pabrik tidak menyamar sebagai kelas.

Bungkus dalam suatu fungsi.

NodeT = namedtuple('Node', 'val left right')

def Node(val, left=None, right=None):
  return NodeT(val, left, right)

Dengan typing.NamedTupledi Python 3.6.1+ Anda bisa memberikan nilai default dan anotasi tipe ke bidang NamedTuple. Gunakan typing.Anyjika Anda hanya membutuhkan yang pertama:

from typing import Any, NamedTuple


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

Pemakaian:

>>> 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)

Juga, jika Anda memerlukan nilai default dan mutabilitas opsional, Python 3.7 akan memiliki kelas data (PEP 557) yang dapat dalam beberapa kasus (banyak?) Menggantikan namedtuple.

Jenis petunjuk ini disebut "referensi maju" ( [1] , [2] ), dan dengan PEP 563 Python 3.7+ akan memiliki __future__impor (akan diaktifkan secara default di 4.0) yang akan memungkinkan untuk menggunakan referensi maju tanpa kutipan, menunda evaluasi mereka.

^{* AFAICT hanya anotasi variabel lokal yang tidak dievaluasi saat runtime. (sumber: PEP 526 )}

Ini adalah contoh langsung dari dokumen :

Nilai default dapat diimplementasikan dengan menggunakan _replace () untuk menyesuaikan contoh prototipe:

>>> 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')

Jadi, contoh OP adalah:

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

Namun, saya suka beberapa jawaban lain yang diberikan di sini lebih baik. Saya hanya ingin menambahkan ini untuk kelengkapan.

Saya tidak yakin apakah ada cara mudah hanya dengan namesuple bawaan. Ada modul bagus bernama recordtype yang memiliki fungsi ini:

>>> from recordtype import recordtype
>>> Node = recordtype('Node', [('val', None), ('left', None), ('right', None)])
>>> Node(3)
Node(val=3, left=None, right=None)
>>> Node(3, 'L')
Node(val=3, left=L, right=None)

Ini adalah versi yang lebih ringkas yang terinspirasi oleh jawaban justinfay:

from collections import namedtuple
from functools import partial

Node = namedtuple('Node', ('val left right'))
Node.__new__ = partial(Node.__new__, left=None, right=None)

Di python3.7 + ada default baru = argumen kata kunci.

nilai default dapat berupa Nonenilai default yang dapat diubah. Karena bidang dengan nilai default harus datang setelah bidang apa pun tanpa standar, standar diterapkan ke parameter paling kanan. Misalnya, jika nama fieldnya ['x', 'y', 'z']dan defaultnya adalah (1, 2), maka xakan menjadi argumen yang diperlukan, yakan default ke 1, dan zakan default ke 2.

Contoh penggunaan:

$ ./python
Python 3.7.0b1+ (heads/3.7:4d65430, Feb  1 2018, 09:28:35) 
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> from collections import namedtuple
>>> nt = namedtuple('nt', ('a', 'b', 'c'), defaults=(1, 2))
>>> nt(0)
nt(a=0, b=1, c=2)
>>> nt(0, 3)  
nt(a=0, b=3, c=2)
>>> nt(0, c=3)
nt(a=0, b=1, c=3)

Singkat, sederhana, dan tidak membuat orang menggunakan dengan isinstancetidak tepat:

class Node(namedtuple('Node', ('val', 'left', 'right'))):
    @classmethod
    def make(cls, val, left=None, right=None):
        return cls(val, left, right)

# Example
x = Node.make(3)
x._replace(right=Node.make(4))

Contoh yang sedikit diperluas untuk menginisialisasi semua argumen yang hilang dengan 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)

Python 3.7: pengenalan defaultsparam dalam namedtuple definition.

Contoh seperti yang ditunjukkan dalam dokumentasi:

>>> Account = namedtuple('Account', ['type', 'balance'], defaults=[0])
>>> Account._fields_defaults
{'balance': 0}
>>> Account('premium')
Account(type='premium', balance=0)

Baca lebih lanjut di sini .

Anda juga dapat menggunakan ini:

import inspect

def namedtuple_with_defaults(type, default_value=None, **kwargs):
    args_list = inspect.getargspec(type.__new__).args[1:]
    params = dict([(x, default_value) for x in args_list])
    params.update(kwargs)

    return type(**params)

Ini pada dasarnya memberi Anda kemungkinan untuk membuat tuple bernama apa pun dengan nilai default dan mengabaikan hanya parameter yang Anda butuhkan, misalnya:

import collections

Point = collections.namedtuple("Point", ["x", "y"])
namedtuple_with_defaults(Point)
>>> Point(x=None, y=None)

namedtuple_with_defaults(Point, x=1)
>>> Point(x=1, y=None)

Menggabungkan pendekatan @Denis dan @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) 

Itu harus mendukung pembuatan tuple dengan argumen posisi dan juga dengan kasus campuran. Kasus uji:

>>> 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)

tetapi juga mendukung TypeError:

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

Saya menemukan versi ini lebih mudah dibaca:

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)

Ini tidak seefisien karena membutuhkan penciptaan objek dua kali tetapi Anda bisa mengubahnya dengan mendefinisikan duple default di dalam modul dan hanya memiliki fungsi melakukan ganti baris.

Karena Anda menggunakan namedtuplesebagai kelas data, Anda harus menyadari bahwa python 3.7 akan memperkenalkan a@dataclass dekorator untuk tujuan ini - dan tentu saja ia memiliki nilai default.

Contoh dari dokumen :

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

Jauh lebih bersih, mudah dibaca dan dapat digunakan daripada meretas namedtuple. Tidak sulit untuk memprediksi bahwa penggunaan namedtuples akan turun dengan adopsi 3,7.

Terinspirasi oleh jawaban ini untuk pertanyaan yang berbeda, berikut ini adalah solusi yang saya usulkan berdasarkan metaclass dan penggunaannya super(untuk menangani pengaliran di masa depan dengan benar). Ini sangat mirip dengan jawaban justinfay .

from collections import namedtuple

NodeTuple = namedtuple("NodeTuple", ("val", "left", "right"))

class NodeMeta(type):
    def __call__(cls, val, left=None, right=None):
        return super(NodeMeta, cls).__call__(val, left, right)

class Node(NodeTuple, metaclass=NodeMeta):
    __slots__ = ()

Kemudian:

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

Jawaban oleh jterrace untuk menggunakan recordtype sangat bagus, tetapi penulis perpustakaan merekomendasikan untuk menggunakan proyek daftar namanya , yang menyediakan implementasi yang bisa berubah ( namedlist) dan tidak berubah ( namedtuple).

from namedlist import namedtuple
>>> Node = namedtuple('Node', ['val', ('left', None), ('right', None)])
>>> Node(3)
Node(val=3, left=None, right=None)
>>> Node(3, 'L')
Node(val=3, left=L, right=None)

Inilah jawaban umum singkat dan sederhana dengan sintaks yang bagus untuk tuple bernama dengan argumen default:

import collections

def dnamedtuple(typename, field_names, **defaults):
    fields = sorted(field_names.split(), key=lambda x: x in defaults)
    T = collections.namedtuple(typename, ' '.join(fields))
    T.__new__.__defaults__ = tuple(defaults[field] for field in fields[-len(defaults):])
    return T

Pemakaian:

Test = dnamedtuple('Test', 'one two three', two=2)
Test(1, 3)  # Test(one=1, three=3, two=2)

Diperkecil:

def dnamedtuple(tp, fs, **df):
    fs = sorted(fs.split(), key=df.__contains__)
    T = collections.namedtuple(tp, ' '.join(fs))
    T.__new__.__defaults__ = tuple(df[i] for i in fs[-len(df):])
    return T

Menggunakan NamedTuplekelas dari Advanced Enum (aenum)perpustakaan saya , dan menggunakan classsintaks, ini cukup sederhana:

from aenum import NamedTuple

class Node(NamedTuple):
    val = 0
    left = 1, 'previous Node', None
    right = 2, 'next Node', None

Satu kelemahan potensial adalah persyaratan untuk __doc__string untuk atribut apa pun dengan nilai default (itu opsional untuk atribut sederhana). Dalam penggunaannya terlihat seperti:

>>> Node()
Traceback (most recent call last):
  ...
TypeError: values not provided for field(s): val

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

Kelebihan ini lebih dari justinfay's answer:

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)

adalah kesederhanaan, serta metaclassberbasis bukan execberbasis.

Solusi lain:

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

Pemakaian:

>>> 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)

Berikut ini versi pembungkus Mark Lodato yang kurang fleksibel, tetapi lebih ringkas: Dibutuhkan bidang dan default sebagai kamus.

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

Contoh:

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)