Bądź namedtuple zaakceptować kwargs

Question

Jeśli mam klasy takich jak:

class Person(object): 
    def __init__(self, name, **kwargs): 
     self.name = name 

p = Person(name='joe', age=25) # age is ignored 

Dodatkowe params są ignorowane. Ale jeśli mam namedtuple, Wezmę `nieoczekiwane słowa kluczowego argument:

from collections import namedtuple 

Person = namedtuple('Person', 'name') 
p = Person(name='joe', age=25) 

# Traceback (most recent call last): 
# File "python", line 1, in <module> 
# TypeError: __new__() got an unexpected keyword argument 'age' 

Jak mogę dokonać namedtuple zaakceptować kwargs więc mogę przekazać dodatkowe argumenty bezpiecznie?

Answer 1

Następna sesja w tłumaczu pokazuje jedną p MOŻLIWA rozwiązanie do mocowania problemu:

Python 3.5.0 (v3.5.0:374f501f4567, Sep 13 2015, 02:27:37) [MSC v.1900 64 bit (AMD64)] on win32 
Type "copyright", "credits" or "license()" for more information. 
>>> import collections 
>>> class Person(collections.namedtuple('base', 'name')): 
    __slots__ =() 
    def __new__(cls, *args, **kwargs): 
     for key in tuple(kwargs): 
      if key not in cls._fields: 
       del kwargs[key] 
     return super().__new__(cls, *args, **kwargs) 


>>> p = Person(name='joe', age=25) 
>>> p 
Person(name='joe') 
>>> 

---

alternatywa:

Skoro wolisz prostsze rozwiązanie, można znaleźć następny program bardziej do swoich potrzeb:

#! /usr/bin/env python3 
import collections 


def main(): 
    Person = namedtuple('Person', 'name') 
    p = Person(name='joe', age=25) 
    print(p) 


def namedtuple(typename, field_names, verbose=False, rename=False): 
    base = collections.namedtuple('Base', field_names, verbose, rename) 
    return type(typename, (base,), { 
     '__slots__':(), 
     '__new__': lambda cls, *args, **kwargs: base.__new__(cls, *args, **{ 
      key: value for key, value in kwargs.items() 
      if key in base._fields})}) 


if __name__ == '__main__': 
    main() 

Answer 2

To nie całkiem:

p = Person(*(dict(name='joe', age=25)[k] for k in Person._fields)) 

Answer 3

Możliwe jest owinąć konstruktora Person klasy ignorowania argumentów, które nie są zdefiniowane jako polach Person namedtuple:

from collections import namedtuple 
Person = namedtuple('Person', 'name') 

def make_person(*args, **kwargs): 
    person_args = {} 

    # process positional args 
    if len(args) > len(Person._fields): 
     msg = "Person() takes %d positional arguments but %d were given" % (len(Person._fields), len(args)) 
     raise TypeError(msg) 
    for arg_name, arg_value in zip(Person._fields, args): 
     person_args[arg_name] = arg_value 

    # process keyword args 
    for arg_name, arg_value in kwargs.items(): 
     try: 
      i = Person._fields.index(arg_name) 
     except ValueError: 
      pass # ignore arguments not defined as Person fields 
     else: 
      if arg_name in person_args: 
       msg = "make_person() got multiple values for argument " + repr(arg_name) 
       raise TypeError(msg) 
      person_args[arg_name] = arg_value 

    if len(person_args) != len(Person._fields): 
     msg = "Person() requires additional arguments: " 
     msg += ", ".join([repr(x) for x in Person._fields if x not in person_args]) 
     raise TypeError(msg) 
    return Person(*[person_args[x] for x in Person._fields]) 

Biorąc powyższe:

>>> make_person('a') 
Person(name='a') 
>>> make_person('a', b='b') 
Person(name='a') 
>>> make_person('a', name='b') 
TypeError: make_person() got multiple values for argument 'name' 
>>> make_person(b='b') 
TypeError: Person() requires additional arguments: 'name' 
>>> make_person(1, 2) 
TypeError: Person() takes 1 positional arguments but 2 were given