Generics / template trong python?

Python xử lý các tình huống loại chung / mẫu như thế nào? Giả sử tôi muốn tạo một tệp bên ngoài "BinaryTree.py" và để nó xử lý cây nhị phân, nhưng đối với bất kỳ kiểu dữ liệu nào.

Vì vậy, tôi có thể chuyển cho nó kiểu của một đối tượng tùy chỉnh và có một cây nhị phân của đối tượng đó. Làm thế nào điều này được thực hiện trong python?

Python sử dụng kiểu gõ vịt , vì vậy nó không cần cú pháp đặc biệt để xử lý nhiều kiểu.

Nếu bạn từ nền tảng C ++, bạn sẽ nhớ rằng, miễn là các hoạt động được sử dụng trong hàm / lớp mẫu được xác định trên một số kiểu T(ở cấp cú pháp), bạn có thể sử dụng kiểu đó Ttrong mẫu.

Vì vậy, về cơ bản, nó hoạt động theo cùng một cách:

1. xác định hợp đồng cho loại mục bạn muốn chèn vào cây nhị phân.
2. ghi lại hợp đồng này (tức là trong tài liệu lớp học)
3. triển khai cây nhị phân chỉ sử dụng các hoạt động được chỉ định trong hợp đồng
4. thưởng thức

Tuy nhiên, bạn sẽ lưu ý rằng trừ khi bạn viết kiểm tra kiểu rõ ràng (thường không được khuyến khích), bạn sẽ không thể thực thi rằng một cây nhị phân chỉ chứa các phần tử của kiểu đã chọn.

Các câu trả lời khác hoàn toàn ổn:

• Người ta không cần một cú pháp đặc biệt để hỗ trợ generic trong Python
• Python sử dụng kiểu gõ vịt như André đã chỉ ra .

Tuy nhiên, nếu bạn vẫn muốn có một biến thể đã nhập , có một giải pháp tích hợp kể từ Python 3.5.

Các lớp chung :

from typing import TypeVar, Generic

T = TypeVar('T')

class Stack(Generic[T]):
    def __init__(self) -> None:
        # Create an empty list with items of type T
        self.items: List[T] = []

    def push(self, item: T) -> None:
        self.items.append(item)

    def pop(self) -> T:
        return self.items.pop()

    def empty(self) -> bool:
        return not self.items

# Construct an empty Stack[int] instance
stack = Stack[int]()
stack.push(2)
stack.pop()
stack.push('x')        # Type error

Các chức năng chung:

from typing import TypeVar, Sequence

T = TypeVar('T')      # Declare type variable

def first(seq: Sequence[T]) -> T:
    return seq[0]

def last(seq: Sequence[T]) -> T:
    return seq[-1]


n = first([1, 2, 3])  # n has type int.

Tham khảo: tài liệu mypy về thuốc generic .

Trên thực tế, bây giờ bạn có thể sử dụng generic trong Python 3.5+. Xem PEP-484 và tài liệu thư viện đánh máy .

Theo thực tế của tôi, nó không được liền mạch và rõ ràng đặc biệt là đối với những người đã quen thuộc với Java Generics, nhưng vẫn có thể sử dụng được.

Sau khi nảy ra một số suy nghĩ hay về việc tạo các loại chung trong python, tôi bắt đầu tìm kiếm những người khác có cùng ý tưởng, nhưng tôi không thể tìm thấy cái nào. Vì vậy, nó đây. Tôi đã thử điều này và nó hoạt động tốt. Nó cho phép chúng ta tham số hóa các kiểu của mình trong python.

class List( type ):

    def __new__(type_ref, member_type):

        class List(list):

            def append(self, member):
                if not isinstance(member, member_type):
                    raise TypeError('Attempted to append a "{0}" to a "{1}" which only takes a "{2}"'.format(
                        type(member).__name__,
                        type(self).__name__,
                        member_type.__name__ 
                    ))

                    list.append(self, member)

        return List 

Bây giờ bạn có thể lấy các kiểu từ kiểu chung này.

class TestMember:
        pass

class TestList(List(TestMember)):

    def __init__(self):
        super().__init__()


test_list = TestList()
test_list.append(TestMember())
test_list.append('test') # This line will raise an exception

Giải pháp này rất đơn giản và nó có những hạn chế. Mỗi lần bạn tạo một kiểu chung, nó sẽ tạo một kiểu mới. Do đó, nhiều lớp kế thừa List( str )với tư cách là lớp cha sẽ được kế thừa từ hai lớp riêng biệt. Để khắc phục điều này, bạn cần tạo một dict để lưu trữ các dạng khác nhau của lớp bên trong và trả về lớp bên trong đã tạo trước đó, thay vì tạo một lớp mới. Điều này sẽ ngăn việc tạo các loại trùng lặp có cùng thông số. Nếu quan tâm, một giải pháp thanh lịch hơn có thể được thực hiện với máy trang trí và / hoặc kính đo.

Bởi vì Python được gõ động, các loại đối tượng không quan trọng trong nhiều trường hợp. Tốt hơn hết là bạn nên chấp nhận bất cứ điều gì.

Để chứng minh ý tôi muốn nói, lớp cây này sẽ chấp nhận bất cứ thứ gì cho hai nhánh của nó:

class BinaryTree:
    def __init__(self, left, right):
        self.left, self.right = left, right

Và nó có thể được sử dụng như thế này:

branch1 = BinaryTree(1,2)
myitem = MyClass()
branch2 = BinaryTree(myitem, None)
tree = BinaryTree(branch1, branch2)

Vì python được nhập động nên việc này rất dễ dàng. Trên thực tế, bạn phải làm thêm công việc để lớp BinaryTree của bạn không hoạt động với bất kỳ kiểu dữ liệu nào.

Ví dụ: nếu bạn muốn các giá trị khóa được sử dụng để đặt đối tượng trong cây có sẵn bên trong đối tượng từ một phương thức giống như key()bạn vừa gọi key()các đối tượng. Ví dụ:

class BinaryTree(object):

    def insert(self, object_to_insert):
        key = object_to_insert.key()

Lưu ý rằng bạn không bao giờ cần phải xác định loại object_to_insert là gì. Vì vậy, miễn là nó có một key()phương pháp, nó sẽ hoạt động.

Ngoại lệ là nếu bạn muốn nó hoạt động với các kiểu dữ liệu cơ bản như chuỗi hoặc số nguyên. Bạn sẽ phải gói chúng trong một lớp để chúng hoạt động với BinaryTree chung của bạn. Nếu điều đó nghe có vẻ quá nặng và bạn muốn có thêm hiệu quả khi thực sự chỉ lưu trữ các chuỗi, xin lỗi, đó không phải là những gì Python giỏi.

Đây là một biến thể của câu trả lời này sử dụng metaclasses để tránh cú pháp lộn xộn và sử dụng cú pháp typing-style List[int]:

class template(type):
    def __new__(metacls, f):
        cls = type.__new__(metacls, f.__name__, (), {
            '_f': f,
            '__qualname__': f.__qualname__,
            '__module__': f.__module__,
            '__doc__': f.__doc__
        })
        cls.__instances = {}
        return cls

    def __init__(cls, f):  # only needed in 3.5 and below
        pass

    def __getitem__(cls, item):
        if not isinstance(item, tuple):
            item = (item,)
        try:
            return cls.__instances[item]
        except KeyError:
            cls.__instances[item] = c = cls._f(*item)
            item_repr = '[' + ', '.join(repr(i) for i in item) + ']'
            c.__name__ = cls.__name__ + item_repr
            c.__qualname__ = cls.__qualname__ + item_repr
            c.__template__ = cls
            return c

    def __subclasscheck__(cls, subclass):
        for c in subclass.mro():
            if getattr(c, '__template__', None) == cls:
                return True
        return False

    def __instancecheck__(cls, instance):
        return cls.__subclasscheck__(type(instance))

    def __repr__(cls):
        import inspect
        return '<template {!r}>'.format('{}.{}[{}]'.format(
            cls.__module__, cls.__qualname__, str(inspect.signature(cls._f))[1:-1]
        ))

Với siêu kính mới này, chúng ta có thể viết lại ví dụ trong câu trả lời mà tôi liên kết tới là:

@template
def List(member_type):
    class List(list):
        def append(self, member):
            if not isinstance(member, member_type):
                raise TypeError('Attempted to append a "{0}" to a "{1}" which only takes a "{2}"'.format(
                    type(member).__name__,
                    type(self).__name__,
                    member_type.__name__ 
                ))

                list.append(self, member)
    return List

l = List[int]()
l.append(1)  # ok
l.append("one")  # error

Cách tiếp cận này có một số lợi ích tốt

print(List)  # <template '__main__.List[member_type]'>
print(List[int])  # <class '__main__.List[<class 'int'>, 10]'>
assert List[int] is List[int]
assert issubclass(List[int], List)  # True

Xem cách các thùng chứa tích hợp thực hiện điều đó. dictvà listvân vân chứa các yếu tố không đồng nhất thuộc bất kỳ loại nào bạn thích. Chẳng hạn, nếu bạn định nghĩa một insert(val)hàm cho cây của mình, thì đến một lúc nào đó, nó sẽ hoạt động như thế nào đó node.value = valvà Python sẽ lo phần còn lại.

May mắn thay, đã có một số nỗ lực cho việc lập trình chung trong python. Có một thư viện: chung

Đây là tài liệu về nó: http://generic.readthedocs.org/en/latest/

Nó không tiến triển qua nhiều năm, nhưng bạn có thể biết sơ bộ về cách sử dụng và tạo thư viện của riêng mình.

Chúc mừng

Nếu bạn đang sử dụng Python 2 hoặc muốn viết lại mã java. Họ không phải là giải pháp thực sự cho điều này. Đây là những gì tôi làm trong một đêm: https://github.com/FlorianSteenbuck/python-generics Tôi vẫn không nhận được trình biên dịch nào nên bạn hiện đang sử dụng nó như vậy:

class A(GenericObject):
    def __init__(self, *args, **kwargs):
        GenericObject.__init__(self, [
            ['b',extends,int],
            ['a',extends,str],
            [0,extends,bool],
            ['T',extends,float]
        ], *args, **kwargs)

    def _init(self, c, a, b):
        print "success c="+str(c)+" a="+str(a)+" b="+str(b)

VIỆC CẦN LÀM

• Trình biên dịch
• Làm cho các Lớp và Kiểu Chung hoạt động (Đối với những thứ như <? extends List<Number>>)
• Thêm superhỗ trợ
• Thêm ?hỗ trợ
• Xóa mã