Hướng dẫn do python objects have a value? - các đối tượng python có giá trị không?

Hướng dẫn về người mới bắt đầu Python

Tìm hiểu về so sánh danh tính so với so sánh bình đẳng In [47]: dir(a)[:5] Out[47]: ['T', '__abs__', '__add__', '__and__', '__array__'] 1

Đối tượng trong Python

Các đối tượng là sự trừu tượng của Python cho dữ liệu. Tất cả dữ liệu trong chương trình Python được biểu thị bằng các đối tượng hoặc bằng mối quan hệ giữa các đối tượng.-Python Docs

Một đối tượng giá trị là một trong những khối xây dựng cơ bản của thiết kế dựa trên tên miền. Nó là một đối tượng nhỏ (về bộ nhớ), bao gồm một hoặc nhiều thuộc tính và đại diện cho một tổng thể khái niệm. Đối tượng giá trị thường là một phần của thực thể.Value Object is one of the fundamental building blocks of Domain-Driven Design. It is a small object (in terms of memory), which consists of one or more attributes, and which represents a conceptual whole. Value Object is usually a part of Entity.

Một số ví dụ về các đối tượng giá trị là:

In [47]: dir(a)[:5]
Out[47]: ['T', '__abs__', '__add__', '__and__', '__array__']

In [47]: dir(a)[:5]
Out[47]: ['T', '__abs__', '__add__', '__and__', '__array__']

In [47]: dir(a)[:5]
Out[47]: ['T', '__abs__', '__add__', '__and__', '__array__']

In [47]: dir(a)[:5]
Out[47]: ['T', '__abs__', '__add__', '__and__', '__array__']

Như bạn có thể thấy từ các ví dụ trên, các đối tượng giá trị không có danh tính - chúng chỉ đơn giản là một tập hợp các thuộc tính có liên quan với nhau.

Dưới đây là các thuộc tính quan trọng nhất của một đối tượng giá trị:

1. Nhà nước của nó là bất biến. Sau khi được tạo, trạng thái của một đối tượng giá trị không thể được thay đổi.
2. Nó chỉ có thể phân biệt bằng trạng thái của các thuộc tính của nó. Hai trường hợp có cùng giá trị thuộc tính được coi là bằng nhau (điều này còn được gọi là bình đẳng cấu trúc).
3. Nó sẽ gói gọn logic kinh doanh ngăn chúng ta xây dựng một đối tượng giá trị với trạng thái không hợp lệ (nghĩa là ngày bắt đầu
4. Tất cả các phương thức của một đối tượng giá trị phải là tinh khiết, tức là gọi một phương thức không kích hoạt bất kỳ tác dụng phụ nào hoặc thay đổi trạng thái của đối tượng giá trị. Tuy nhiên, trả lại một thể hiện mới phản ánh các thay đổi là tốt.
5. Nó sẽ dễ dàng kiểm tra đơn vị một đối tượng giá trị và nó sẽ dễ dàng lý luận về logic của nó.

Để nhận ra một đối tượng giá trị trong mô hình miền của bạn, thay thế tinh thần bằng một bộ xử lý bằng một số logic xác thực và một vài phương pháp bổ sung dễ kiểm tra.

Hãy thực hiện đối tượng giá trị

In [47]: dir(a)[:5]
Out[47]: ['T', '__abs__', '__add__', '__and__', '__array__']

from dataclasses import dataclass
from datetime import date

class BusinessRuleValidationException(Exception):
  """A base class for all business rule validation exceptions"""

class ValueObject:
  """A base class for all value objects"""

@dataclass(frozen=True)
class DateRange(ValueObject):
  """Our first value object"""
  start_date: date
  end_date: date

  def __post_init__(self):
    """Here we check if a value object has a valid state."""
    if not self.start_date < self.end_date
      raise BusinessRuleValidationException("end date date should be greater than start date")

  def days(self):
    """Returns the number of days between the start date and the end date"""
    delta = self.end_date - self.start_date + timedelta(days=1)
    return delta.days

  def extend(self, days):
    """Extend the end date by a specified number of days"""
    new_end_date = self.end_date + timedelta(days=days)
    return DateRange(self.start_date, new_end_date)

from dataclasses import dataclass
from datetime import date

class BusinessRuleValidationException(Exception):
  """A base class for all business rule validation exceptions"""

class ValueObject:
  """A base class for all value objects"""

@dataclass(frozen=True)
class DateRange(ValueObject):
  """Our first value object"""
  start_date: date
  end_date: date

  def __post_init__(self):
    """Here we check if a value object has a valid state."""
    if not self.start_date < self.end_date
      raise BusinessRuleValidationException("end date date should be greater than start date")

  def days(self):
    """Returns the number of days between the start date and the end date"""
    delta = self.end_date - self.start_date + timedelta(days=1)
    return delta.days

  def extend(self, days):
    """Extend the end date by a specified number of days"""
    new_end_date = self.end_date + timedelta(days=days)
    return DateRange(self.start_date, new_end_date)

Re 1: Để đảm bảo tính bất biến của

In [47]: dir(a)[:5]
Out[47]: ['T', '__abs__', '__add__', '__and__', '__array__']

from dataclasses import dataclass
from datetime import date

class BusinessRuleValidationException(Exception):
  """A base class for all business rule validation exceptions"""

class ValueObject:
  """A base class for all value objects"""

@dataclass(frozen=True)
class DateRange(ValueObject):
  """Our first value object"""
  start_date: date
  end_date: date

  def __post_init__(self):
    """Here we check if a value object has a valid state."""
    if not self.start_date < self.end_date
      raise BusinessRuleValidationException("end date date should be greater than start date")

  def days(self):
    """Returns the number of days between the start date and the end date"""
    delta = self.end_date - self.start_date + timedelta(days=1)
    return delta.days

  def extend(self, days):
    """Extend the end date by a specified number of days"""
    new_end_date = self.end_date + timedelta(days=days)
    return DateRange(self.start_date, new_end_date)

In [47]: dir(a)[:5]
Out[47]: ['T', '__abs__', '__add__', '__and__', '__array__']

from dataclasses import dataclass
from datetime import date

class BusinessRuleValidationException(Exception):
  """A base class for all business rule validation exceptions"""

class ValueObject:
  """A base class for all value objects"""

@dataclass(frozen=True)
class DateRange(ValueObject):
  """Our first value object"""
  start_date: date
  end_date: date

  def __post_init__(self):
    """Here we check if a value object has a valid state."""
    if not self.start_date < self.end_date
      raise BusinessRuleValidationException("end date date should be greater than start date")

  def days(self):
    """Returns the number of days between the start date and the end date"""
    delta = self.end_date - self.start_date + timedelta(days=1)
    return delta.days

  def extend(self, days):
    """Extend the end date by a specified number of days"""
    new_end_date = self.end_date + timedelta(days=days)
    return DateRange(self.start_date, new_end_date)

Re 2: Bình đẳng được đảm bảo bởi chính

from dataclasses import dataclass
from datetime import date

class BusinessRuleValidationException(Exception):
  """A base class for all business rule validation exceptions"""

class ValueObject:
  """A base class for all value objects"""

@dataclass(frozen=True)
class DateRange(ValueObject):
  """Our first value object"""
  start_date: date
  end_date: date

  def __post_init__(self):
    """Here we check if a value object has a valid state."""
    if not self.start_date < self.end_date
      raise BusinessRuleValidationException("end date date should be greater than start date")

  def days(self):
    """Returns the number of days between the start date and the end date"""
    delta = self.end_date - self.start_date + timedelta(days=1)
    return delta.days

  def extend(self, days):
    """Extend the end date by a specified number of days"""
    new_end_date = self.end_date + timedelta(days=days)
    return DateRange(self.start_date, new_end_date)

from dataclasses import dataclass
from datetime import date

class BusinessRuleValidationException(Exception):
  """A base class for all business rule validation exceptions"""

class ValueObject:
  """A base class for all value objects"""

@dataclass(frozen=True)
class DateRange(ValueObject):
  """Our first value object"""
  start_date: date
  end_date: date

  def __post_init__(self):
    """Here we check if a value object has a valid state."""
    if not self.start_date < self.end_date
      raise BusinessRuleValidationException("end date date should be greater than start date")

  def days(self):
    """Returns the number of days between the start date and the end date"""
    delta = self.end_date - self.start_date + timedelta(days=1)
    return delta.days

  def extend(self, days):
    """Extend the end date by a specified number of days"""
    new_end_date = self.end_date + timedelta(days=days)
    return DateRange(self.start_date, new_end_date)

Re 3: Chúng tôi xác nhận trạng thái của một thể hiện trong phương thức

from dataclasses import dataclass
from datetime import date

class BusinessRuleValidationException(Exception):
  """A base class for all business rule validation exceptions"""

class ValueObject:
  """A base class for all value objects"""

@dataclass(frozen=True)
class DateRange(ValueObject):
  """Our first value object"""
  start_date: date
  end_date: date

  def __post_init__(self):
    """Here we check if a value object has a valid state."""
    if not self.start_date < self.end_date
      raise BusinessRuleValidationException("end date date should be greater than start date")

  def days(self):
    """Returns the number of days between the start date and the end date"""
    delta = self.end_date - self.start_date + timedelta(days=1)
    return delta.days

  def extend(self, days):
    """Extend the end date by a specified number of days"""
    new_end_date = self.end_date + timedelta(days=days)
    return DateRange(self.start_date, new_end_date)

from dataclasses import dataclass
from datetime import date

class BusinessRuleValidationException(Exception):
  """A base class for all business rule validation exceptions"""

class ValueObject:
  """A base class for all value objects"""

@dataclass(frozen=True)
class DateRange(ValueObject):
  """Our first value object"""
  start_date: date
  end_date: date

  def __post_init__(self):
    """Here we check if a value object has a valid state."""
    if not self.start_date < self.end_date
      raise BusinessRuleValidationException("end date date should be greater than start date")

  def days(self):
    """Returns the number of days between the start date and the end date"""
    delta = self.end_date - self.start_date + timedelta(days=1)
    return delta.days

  def extend(self, days):
    """Extend the end date by a specified number of days"""
    new_end_date = self.end_date + timedelta(days=days)
    return DateRange(self.start_date, new_end_date)

Re 4: Đối tượng giá trị của chúng tôi chỉ có 2 phương pháp:

from dataclasses import dataclass
from datetime import date

class BusinessRuleValidationException(Exception):
  """A base class for all business rule validation exceptions"""

class ValueObject:
  """A base class for all value objects"""

@dataclass(frozen=True)
class DateRange(ValueObject):
  """Our first value object"""
  start_date: date
  end_date: date

  def __post_init__(self):
    """Here we check if a value object has a valid state."""
    if not self.start_date < self.end_date
      raise BusinessRuleValidationException("end date date should be greater than start date")

  def days(self):
    """Returns the number of days between the start date and the end date"""
    delta = self.end_date - self.start_date + timedelta(days=1)
    return delta.days

  def extend(self, days):
    """Extend the end date by a specified number of days"""
    new_end_date = self.end_date + timedelta(days=days)
    return DateRange(self.start_date, new_end_date)

from dataclasses import dataclass
from datetime import date

class BusinessRuleValidationException(Exception):
  """A base class for all business rule validation exceptions"""

class ValueObject:
  """A base class for all value objects"""

@dataclass(frozen=True)
class DateRange(ValueObject):
  """Our first value object"""
  start_date: date
  end_date: date

  def __post_init__(self):
    """Here we check if a value object has a valid state."""
    if not self.start_date < self.end_date
      raise BusinessRuleValidationException("end date date should be greater than start date")

  def days(self):
    """Returns the number of days between the start date and the end date"""
    delta = self.end_date - self.start_date + timedelta(days=1)
    return delta.days

  def extend(self, days):
    """Extend the end date by a specified number of days"""
    new_end_date = self.end_date + timedelta(days=days)
    return DateRange(self.start_date, new_end_date)

from dataclasses import dataclass
from datetime import date

class BusinessRuleValidationException(Exception):
  """A base class for all business rule validation exceptions"""

class ValueObject:
  """A base class for all value objects"""

@dataclass(frozen=True)
class DateRange(ValueObject):
  """Our first value object"""
  start_date: date
  end_date: date

  def __post_init__(self):
    """Here we check if a value object has a valid state."""
    if not self.start_date < self.end_date
      raise BusinessRuleValidationException("end date date should be greater than start date")

  def days(self):
    """Returns the number of days between the start date and the end date"""
    delta = self.end_date - self.start_date + timedelta(days=1)
    return delta.days

  def extend(self, days):
    """Extend the end date by a specified number of days"""
    new_end_date = self.end_date + timedelta(days=days)
    return DateRange(self.start_date, new_end_date)

from dataclasses import dataclass
from datetime import date

class BusinessRuleValidationException(Exception):
  """A base class for all business rule validation exceptions"""

class ValueObject:
  """A base class for all value objects"""

@dataclass(frozen=True)
class DateRange(ValueObject):
  """Our first value object"""
  start_date: date
  end_date: date

  def __post_init__(self):
    """Here we check if a value object has a valid state."""
    if not self.start_date < self.end_date
      raise BusinessRuleValidationException("end date date should be greater than start date")

  def days(self):
    """Returns the number of days between the start date and the end date"""
    delta = self.end_date - self.start_date + timedelta(days=1)
    return delta.days

  def extend(self, days):
    """Extend the end date by a specified number of days"""
    new_end_date = self.end_date + timedelta(days=days)
    return DateRange(self.start_date, new_end_date)

from dataclasses import dataclass
from datetime import date

class BusinessRuleValidationException(Exception):
  """A base class for all business rule validation exceptions"""

class ValueObject:
  """A base class for all value objects"""

@dataclass(frozen=True)
class DateRange(ValueObject):
  """Our first value object"""
  start_date: date
  end_date: date

  def __post_init__(self):
    """Here we check if a value object has a valid state."""
    if not self.start_date < self.end_date
      raise BusinessRuleValidationException("end date date should be greater than start date")

  def days(self):
    """Returns the number of days between the start date and the end date"""
    delta = self.end_date - self.start_date + timedelta(days=1)
    return delta.days

  def extend(self, days):
    """Extend the end date by a specified number of days"""
    new_end_date = self.end_date + timedelta(days=days)
    return DateRange(self.start_date, new_end_date)

from dataclasses import dataclass
from datetime import date

class BusinessRuleValidationException(Exception):
  """A base class for all business rule validation exceptions"""

class ValueObject:
  """A base class for all value objects"""

@dataclass(frozen=True)
class DateRange(ValueObject):
  """Our first value object"""
  start_date: date
  end_date: date

  def __post_init__(self):
    """Here we check if a value object has a valid state."""
    if not self.start_date < self.end_date
      raise BusinessRuleValidationException("end date date should be greater than start date")

  def days(self):
    """Returns the number of days between the start date and the end date"""
    delta = self.end_date - self.start_date + timedelta(days=1)
    return delta.days

  def extend(self, days):
    """Extend the end date by a specified number of days"""
    new_end_date = self.end_date + timedelta(days=days)
    return DateRange(self.start_date, new_end_date)

from dataclasses import dataclass
from datetime import date

class BusinessRuleValidationException(Exception):
  """A base class for all business rule validation exceptions"""

class ValueObject:
  """A base class for all value objects"""

@dataclass(frozen=True)
class DateRange(ValueObject):
  """Our first value object"""
  start_date: date
  end_date: date

  def __post_init__(self):
    """Here we check if a value object has a valid state."""
    if not self.start_date < self.end_date
      raise BusinessRuleValidationException("end date date should be greater than start date")

  def days(self):
    """Returns the number of days between the start date and the end date"""
    delta = self.end_date - self.start_date + timedelta(days=1)
    return delta.days

  def extend(self, days):
    """Extend the end date by a specified number of days"""
    new_end_date = self.end_date + timedelta(days=days)
    return DateRange(self.start_date, new_end_date)

from dataclasses import dataclass
from datetime import date

class BusinessRuleValidationException(Exception):
  """A base class for all business rule validation exceptions"""

class ValueObject:
  """A base class for all value objects"""

@dataclass(frozen=True)
class DateRange(ValueObject):
  """Our first value object"""
  start_date: date
  end_date: date

  def __post_init__(self):
    """Here we check if a value object has a valid state."""
    if not self.start_date < self.end_date
      raise BusinessRuleValidationException("end date date should be greater than start date")

  def days(self):
    """Returns the number of days between the start date and the end date"""
    delta = self.end_date - self.start_date + timedelta(days=1)
    return delta.days

  def extend(self, days):
    """Extend the end date by a specified number of days"""
    new_end_date = self.end_date + timedelta(days=days)
    return DateRange(self.start_date, new_end_date)

from dataclasses import dataclass
from datetime import date

class BusinessRuleValidationException(Exception):
  """A base class for all business rule validation exceptions"""

class ValueObject:
  """A base class for all value objects"""

@dataclass(frozen=True)
class DateRange(ValueObject):
  """Our first value object"""
  start_date: date
  end_date: date

  def __post_init__(self):
    """Here we check if a value object has a valid state."""
    if not self.start_date < self.end_date
      raise BusinessRuleValidationException("end date date should be greater than start date")

  def days(self):
    """Returns the number of days between the start date and the end date"""
    delta = self.end_date - self.start_date + timedelta(days=1)
    return delta.days

  def extend(self, days):
    """Extend the end date by a specified number of days"""
    new_end_date = self.end_date + timedelta(days=days)
    return DateRange(self.start_date, new_end_date)

from dataclasses import dataclass
from datetime import date

class BusinessRuleValidationException(Exception):
  """A base class for all business rule validation exceptions"""

class ValueObject:
  """A base class for all value objects"""

@dataclass(frozen=True)
class DateRange(ValueObject):
  """Our first value object"""
  start_date: date
  end_date: date

  def __post_init__(self):
    """Here we check if a value object has a valid state."""
    if not self.start_date < self.end_date
      raise BusinessRuleValidationException("end date date should be greater than start date")

  def days(self):
    """Returns the number of days between the start date and the end date"""
    delta = self.end_date - self.start_date + timedelta(days=1)
    return delta.days

  def extend(self, days):
    """Extend the end date by a specified number of days"""
    new_end_date = self.end_date + timedelta(days=days)
    return DateRange(self.start_date, new_end_date)

Re 5: Nhờ hành vi đơn giản của nó, kiểm tra đơn vị

from dataclasses import dataclass
from datetime import date

class BusinessRuleValidationException(Exception):
  """A base class for all business rule validation exceptions"""

class ValueObject:
  """A base class for all value objects"""

@dataclass(frozen=True)
class DateRange(ValueObject):
  """Our first value object"""
  start_date: date
  end_date: date

  def __post_init__(self):
    """Here we check if a value object has a valid state."""
    if not self.start_date < self.end_date
      raise BusinessRuleValidationException("end date date should be greater than start date")

  def days(self):
    """Returns the number of days between the start date and the end date"""
    delta = self.end_date - self.start_date + timedelta(days=1)
    return delta.days

  def extend(self, days):
    """Extend the end date by a specified number of days"""
    new_end_date = self.end_date + timedelta(days=days)
    return DateRange(self.start_date, new_end_date)

from dataclasses import dataclass
from datetime import date

class BusinessRuleValidationException(Exception):
  """A base class for all business rule validation exceptions"""

class ValueObject:
  """A base class for all value objects"""

@dataclass(frozen=True)
class DateRange(ValueObject):
  """Our first value object"""
  start_date: date
  end_date: date

  def __post_init__(self):
    """Here we check if a value object has a valid state."""
    if not self.start_date < self.end_date
      raise BusinessRuleValidationException("end date date should be greater than start date")

  def days(self):
    """Returns the number of days between the start date and the end date"""
    delta = self.end_date - self.start_date + timedelta(days=1)
    return delta.days

  def extend(self, days):
    """Extend the end date by a specified number of days"""
    new_end_date = self.end_date + timedelta(days=days)
    return DateRange(self.start_date, new_end_date)

import unittest

class DateRangeTestCase(unittest.TestCase):
    def test_equality(self):
        range1 = DateRange(start_date=date(2020,1,1), end_date=date(2021,1,1))
        range2 = DateRange(start_date=date(2020,1,1), end_date=date(2021,1,1))
        self.assertEqual(range1, range2)

    def test_days(self):
        range = DateRange(start_date=date(2020,1,1), end_date=date(2020,1,1))
        self.assertEqual(range.days(), 1)

    def test_days(self):
        range1 = DateRange(start_date=date(2020,1,1), end_date=date(2020,1,1))
        range2 = range1.extend(days=1)
        self.assertEqual(
            range2, 
            DateRange(start_date=date(2020,1,1), end_date=date(2021,1,2))
        )

    def test_cannot_create_invalid_date_range(self):
        with self.assertRaises(BusinessRuleValidationException):
            DateRange(start_date=date(2021,1,1), end_date=date(2020,1,1))

Sử dụng các đối tượng giá trị trong mã của bạn cũng sẽ giúp bạn chiến đấu với nỗi ám ảnh nguyên thủy. Tại sao nó lại quan trọng? Hãy để tôi cho bạn một ví dụ để minh họa vấn đề. Hãy nói rằng bạn quyết định cắt góc và sử dụng

import unittest

class DateRangeTestCase(unittest.TestCase):
    def test_equality(self):
        range1 = DateRange(start_date=date(2020,1,1), end_date=date(2021,1,1))
        range2 = DateRange(start_date=date(2020,1,1), end_date=date(2021,1,1))
        self.assertEqual(range1, range2)

    def test_days(self):
        range = DateRange(start_date=date(2020,1,1), end_date=date(2020,1,1))
        self.assertEqual(range.days(), 1)

    def test_days(self):
        range1 = DateRange(start_date=date(2020,1,1), end_date=date(2020,1,1))
        range2 = range1.extend(days=1)
        self.assertEqual(
            range2, 
            DateRange(start_date=date(2020,1,1), end_date=date(2021,1,2))
        )

    def test_cannot_create_invalid_date_range(self):
        with self.assertRaises(BusinessRuleValidationException):
            DateRange(start_date=date(2021,1,1), end_date=date(2020,1,1))

In [47]: dir(a)[:5]
Out[47]: ['T', '__abs__', '__add__', '__and__', '__array__']