Làm cách nào để tránh bản thân bản thân.x = x; tự.y = y; self.z = z mẫu trong __init__?

Tôi thấy các mẫu như

def __init__(self, x, y, z):
    ...
    self.x = x
    self.y = y
    self.z = z
    ...

khá thường xuyên, thường có nhiều thông số hơn. Có một cách tốt để tránh kiểu lặp đi lặp lại tẻ nhạt này? Lớp học nên kế thừa từ namedtuplethay thế?

Chỉnh sửa: Nếu bạn có python 3.7+, chỉ cần sử dụng dataclass

Một giải pháp trang trí giữ chữ ký:

import decorator
import inspect
import sys


@decorator.decorator
def simple_init(func, self, *args, **kws):
    """
    @simple_init
    def __init__(self,a,b,...,z)
        dosomething()

    behaves like

    def __init__(self,a,b,...,z)
        self.a = a
        self.b = b
        ...
        self.z = z
        dosomething()
    """

    #init_argumentnames_without_self = ['a','b',...,'z']
    if sys.version_info.major == 2:
        init_argumentnames_without_self = inspect.getargspec(func).args[1:]
    else:
        init_argumentnames_without_self = tuple(inspect.signature(func).parameters.keys())[1:]

    positional_values = args
    keyword_values_in_correct_order = tuple(kws[key] for key in init_argumentnames_without_self if key in kws)
    attribute_values = positional_values + keyword_values_in_correct_order

    for attribute_name,attribute_value in zip(init_argumentnames_without_self,attribute_values):
        setattr(self,attribute_name,attribute_value)

    # call the original __init__
    func(self, *args, **kws)


class Test():
    @simple_init
    def __init__(self,a,b,c,d=4):
        print(self.a,self.b,self.c,self.d)

#prints 1 3 2 4
t = Test(1,c=2,b=3)
#keeps signature
#prints ['self', 'a', 'b', 'c', 'd']
if sys.version_info.major == 2:
    print(inspect.getargspec(Test.__init__).args)
else:
    print(inspect.signature(Test.__init__))

Tuyên bố miễn trừ trách nhiệm: Có vẻ như nhiều người lo ngại về việc trình bày giải pháp này, vì vậy tôi sẽ cung cấp từ chối trách nhiệm rất rõ ràng. Bạn không nên sử dụng giải pháp này. Tôi chỉ cung cấp nó dưới dạng thông tin, vì vậy bạn biết rằng ngôn ngữ có khả năng này. Phần còn lại của câu trả lời chỉ là thể hiện khả năng ngôn ngữ, không xác nhận sử dụng chúng theo cách này.

Thực sự không có gì sai với việc sao chép rõ ràng các tham số vào các thuộc tính. Nếu bạn có quá nhiều tham số trong ctor, đôi khi nó được coi là mùi mã và có lẽ bạn nên nhóm các tham số này thành một đối tượng ít hơn. Những lần khác, nó là cần thiết và không có gì sai với nó. Dù sao, làm nó rõ ràng là cách để đi.

Tuy nhiên, vì bạn đang hỏi làm thế nào nó có thể được thực hiện (và không nên thực hiện nó), nên một giải pháp là:

class A:
    def __init__(self, **kwargs):
        for key in kwargs:
          setattr(self, key, kwargs[key])

a = A(l=1, d=2)
a.l # will return 1
a.d # will return 2

Như những người khác đã đề cập, sự lặp lại không phải là xấu, nhưng trong một số trường hợp, một tên được đặt tên có thể rất phù hợp với loại vấn đề này. Điều này tránh sử dụng người địa phương () hoặc kwargs, thường là một ý tưởng tồi.

from collections import namedtuple
# declare a new object type with three properties; x y z
# the first arg of namedtuple is a typename
# the second arg is comma-separated or space-separated property names
XYZ = namedtuple("XYZ", "x, y, z")

# create an object of type XYZ. properties are in order
abc = XYZ("one", "two", 3)
print abc.x
print abc.y
print abc.z

Tôi đã tìm thấy việc sử dụng hạn chế cho nó, nhưng bạn có thể thừa hưởng một tên được đặt tên như với bất kỳ đối tượng nào khác (ví dụ tiếp tục):

class MySuperXYZ(XYZ):
    """ I add a helper function which returns the original properties """
    def properties(self):
        return self.x, self.y, self.z

abc2 = MySuperXYZ(4, "five", "six")
print abc2.x
print abc2.y
print abc2.z
print abc2.properties()

rõ ràng là tốt hơn so với ngầm ... vì vậy chắc chắn bạn có thể làm cho nó ngắn gọn hơn:

def __init__(self,a,b,c):
    for k,v in locals().items():
        if k != "self":
             setattr(self,k,v)

Câu hỏi tốt hơn là bạn nên?

... điều đó nói rằng nếu bạn muốn một tuple có tên, tôi sẽ khuyên bạn nên sử dụng một tuple có tên (hãy nhớ các tuple có một số điều kiện kèm theo chúng) ... có lẽ bạn muốn có một lệnh đã ra lệnh hoặc thậm chí chỉ là một lệnh ...

Để mở rộng gruszczycâu trả lời, tôi đã sử dụng một mẫu như:

class X:
    x = None
    y = None
    z = None
    def __init__(self, **kwargs):
        for (k, v) in kwargs.items():
            if hasattr(self, k):
                setattr(self, k, v)
            else:
                raise TypeError('Unknown keyword argument: {:s}'.format(k))

Tôi thích phương pháp này vì nó:

• tránh sự lặp lại
• chống lại lỗi chính tả khi xây dựng một đối tượng
• hoạt động tốt với phân lớp (chỉ có thể super().__init(...))
• cho phép ghi lại các thuộc tính ở cấp độ lớp (nơi chúng thuộc về) chứ không phải trong X.__init__

Trước Python 3.6, điều này không kiểm soát thứ tự các thuộc tính được đặt, có thể là một vấn đề nếu một số thuộc tính là thuộc tính có setters truy cập các thuộc tính khác.

Nó có thể được cải thiện một chút, nhưng tôi là người sử dụng mã riêng của mình nên tôi không lo lắng về bất kỳ hình thức vệ sinh đầu vào nào. Có lẽ một AttributeErrorsẽ thích hợp hơn.

Bạn cũng có thể làm:

locs = locals()
for arg in inspect.getargspec(self.__init__)[0][1:]:
    setattr(self, arg, locs[arg])

Tất nhiên, bạn sẽ phải nhập inspectmô-đun.

Đây là một giải pháp mà không cần nhập thêm.

Chức năng trợ giúp

Một chức năng trợ giúp nhỏ làm cho nó thuận tiện hơn và có thể sử dụng lại:

def auto_init(local_name_space):
    """Set instance attributes from arguments.
    """
    self = local_name_space.pop('self')
    for name, value in local_name_space.items():
        setattr(self, name, value)

Ứng dụng

Bạn cần gọi nó bằng locals():

class A:
    def __init__(self, x, y, z):
        auto_init(locals())

Kiểm tra

a = A(1, 2, 3)
print(a.__dict__)

Đầu ra:

{'y': 2, 'z': 3, 'x': 1}

Không hề thay đổi locals()

Nếu bạn không muốn thay đổi, hãy locals()sử dụng phiên bản này:

def auto_init(local_name_space):
    """Set instance attributes from arguments.
    """
    for name, value in local_name_space.items():
        if name != 'self': 
            setattr(local_name_space['self'], name, value)

Một thư viện thú vị xử lý việc này (và tránh rất nhiều nồi hơi khác) là attrs . Ví dụ của bạn, ví dụ, có thể được giảm xuống này (giả sử lớp được gọi MyClass):

import attr

@attr.s
class MyClass:
    x = attr.ib()
    y = attr.ib()
    z = attr.ib()

Bạn thậm chí không cần một __init__phương pháp nữa, trừ khi nó cũng làm những thứ khác. Đây là một lời giới thiệu hay của Glyph Lefkowitz .

0,02 đô la của tôi. Nó rất gần với câu trả lời của Joran Beasley, nhưng thanh lịch hơn:

def __init__(self, a, b, c, d, e, f):
    vars(self).update((k, v) for k, v in locals().items() if v is not self)

Ngoài ra, câu trả lời của Mike Müller (câu trả lời tốt nhất theo sở thích của tôi) có thể được giảm bớt bằng kỹ thuật này:

def auto_init(ns):
    self = ns.pop('self')
    vars(self).update(ns)

Và cuộc gọi chỉ auto_init(locals())từ bạn__init__

Đó là một cách tự nhiên để làm mọi thứ trong Python. Đừng cố gắng phát minh ra thứ gì đó thông minh hơn, nó sẽ dẫn đến mã quá thông minh mà không ai trong nhóm của bạn sẽ hiểu. Nếu bạn muốn trở thành một người chơi nhóm và sau đó tiếp tục viết nó theo cách này.

Python 3.7 trở đi

Trong Python 3.7, bạn có thể (ab) sử dụng trình dataclasstrang trí, có sẵn từ dataclassesmô-đun. Từ tài liệu:

Mô-đun này cung cấp một trình trang trí và các chức năng để tự động thêm các phương thức đặc biệt được tạo như __init__()và__repr__() vào các lớp do người dùng định nghĩa. Ban đầu nó được mô tả trong PEP 557.

Các biến thành viên để sử dụng trong các phương thức được tạo này được xác định bằng cách sử dụng chú thích loại PEP 526. Ví dụ mã này:

@dataclass
class InventoryItem:
    '''Class for keeping track of an item in inventory.'''
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost(self) -> float:
        return self.unit_price * self.quantity_on_hand

Sẽ thêm, trong số những thứ khác, một __init__()hình như:

def __init__(self, name: str, unit_price: float, quantity_on_hand: int=0):
      self.name = name
      self.unit_price = unit_price
      self.quantity_on_hand = quantity_on_hand

Lưu ý rằng phương thức này được tự động thêm vào lớp: nó không được chỉ định trực tiếp trong định nghĩa InventoryItem được hiển thị ở trên.

Nếu lớp của bạn lớn và phức tạp, có thể không phù hợp để sử dụng a dataclass. Tôi đang viết bài này vào ngày phát hành Python 3.7.0, vì vậy các mẫu sử dụng chưa được thiết lập tốt.