Python 中的面向数据编程

2024年8月29日 | 阅读 10 分钟

在本教程中，我们将学习 Python 中的数据导向编程（DOP），作为传统的面向对象编程（OOP）的替代方案。顾名思义，我们实践的是一种将数据置于首位的编程方法。

我们可以通过遵循四个原则来实现这一目标。这些原则与语言无关。它们可以在面向对象编程语言（Java、C++ 等）、函数式编程（FP）语言（Clojure 等）或通用语言（Python、JavaScript）中表示。让我们了解以下原则。

原则 1：将代码与数据分离

在第一个原则中，我们需要以函数行为不依赖于函数上下文中封装的数据的方式编写函数。在 Python 中使用此原则的自然方法是使用顶级函数和仅包含数据字段的数据类。让我们了解以下示例。

示例 -

from dataclasses import dataclass
@dataclass
class AuthorData:
    """Class for keeping track of an author in the system"""
    first_name: str
    last_name: str
    n_books: int

def calculate_name(first_name: str, last_name: str):
    return f"{first_name} {last_name}"
def is_profile(n_books: int):
    return n_books > 100
author_data = AuthorData("Graham", "Mathew", 200)
calculate_name(author_data.first_name, author_data.last_name)

`calculate_name()` 函数不仅可以用于作者，还可以用于用户、图书管理员或任何具有名字和姓氏的个人。通过将负责计算全名的代码与与作者数据创建相关的代码分离，`calculate_name()` 函数可以轻松地在不同实体之间重用。这种设计提供了灵活性并促进了代码重用，使该函数能够在需要根据名字和姓氏生成全名的地方使用。

这种方法的好处是代码可以在不同的上下文环境中重用。

@dataclass
class UserData:
    """Class for keeping track of a user in the system"""
    first_name: str
    last_name: str
    email: str
user_data = UserData("John", "Doe", "john.doe@gmail.com")
calculate_name(user_data.first_name, user_data.last_name)

让我们看看不遵循原则 1 的以下示例。

示例 -

class Contact:
    def __init__(self, first_name: str, last_name: str, email: str, phone: str):
        self.first_name = first_name
        self.last_name = last_name
        self.email = email
        self.phone = phone

    def send_email(self, message: str):
        # Code for sending an email to the contact's email address
        pass


class Customer:
    def __init__(self, first_name: str, last_name: str, account_balance: float,
                 contact: Contact):
        self.first_name = first_name
        self.last_name = last_name
        self.account_balance = account_balance
        self.contact = contact

    @property
    def full_name(self):
        return f"{self.first_name} {self.last_name}"

    @property
    def is_loyal(self):
        return self.account_balance > 10000
contact_info = Contact("John", "Doe", "johndoe@example.com", "555-1234")
customer = Customer("Alice", "Smith", 50000, contact_info)
assert customer.full_name == "Alice Smith"

解释 -

在上面的代码中，`full_name()` 方法驻留在 `Customer` 类中，我们需要实例化 `Contact` 对象，这需要为每个属性（包括电子邮件和电话）赋值。这只是为了测试一个方法而进行的不必要的复杂而繁琐的设置。

另一方面，在 DOP 版本中，为了测试 `calculate_name()` 代码，我们可以单独创建要传递给函数的数据。

原则 2：用通用数据结构表示数据

根据此原则，数据使用通用数据结构表示，例如映射（或字典）和数组（或列表）。在本文中，我们使用 dataclass，它比 DOP 更接近 OOP。Python 的 dataclass 是一种多功能构造，弥合了面向对象编程（OOP）和数据导向编程（DOP）之间的差距。与字典和元组不同，dataclass 具有多项优势，包括减少拼写错误的可能性、通过类型提示提高可读性、简化嵌套复杂结构的表示等等。此外，dataclass 提供了在需要时轻松将实例转换为字典或元组的灵活性。

通过利用 dataclass，我们可以利用 OOP 的优势，例如封装和代码组织，同时利用数据结构简洁和描述性的特性。dataclass 中的类型提示支持有助于确保更好的代码质量，并促进更轻松的调试和维护。此外，将 dataclass 实例转换为字典或元组的固有能力允许与代码库中期望这些数据结构的其他部分或外部系统进行无缝互操作。

让我们理解下面的例子。

示例 -

from dataclasses import dataclass, asdict

@dataclass
class AuthorData:
    """Class for keeping track of an author in the system"""

    first_name: str
    last_name: str
    n_books: int

author_data = AuthorData("Robert", "Downey", 500)
asdict(author_data)

输出

'first_name': 'Robert', 'last_name': 'Downey', 'n_books': 500}

上述通用结构有助于使用 Python 内置的丰富函数集（适用于 dict、list、tuple 等）来操作数据。

author = {"first_name": "Issac", "last_name": "Asimov", "n_books": 500}
# Access dict values
author.get("first_name")
# Add new field to dict
author["alive"] = False
# Update existing field
author["n_books"] = 703

Python 的 dataclass 使我们免于单个类方法的复杂性，使我们能够专注于核心功能。它确保了与不同库版本的兼容性，并最大限度地减少了语言级别更改的影响。这种抽象层促进了代码稳定性，提高了可重用性，并简化了开发和维护过程。

当我们以通用形式定义数据时，这意味着我们可以在需要时进行修改，这是通用数据的一个优势。

在以下示例中，所有字典可能具有不同的键。额外的键可以存在于第二个字典中。

names = []
names.append({"first_name": "Isaac", "last_name": "Asimov"})
names.append({"first_name": "Jane", "last_name": "Doe", 
              "suffix": "III", "age": 70})

在 Python 中，检索类成员的值和访问字典中与键关联的值之间的性能差异很小。与 Java 等语言不同，Python 没有编译步骤，无法专门针对类成员访问进行编译器优化。因此，这些操作的性能特征通常是可比的。

另一方面，由于其作为哈希表的底层实现，Python 中的字典访问效率很高。根据键从字典中检索值涉及快速查找过程，该过程针对性能进行了优化。

与列表和元组相比，Python 中的集合和字典提供更高效的查找时间。哈希函数的使用允许直接访问数据，从而实现常数时间查找复杂性。相反，列表和元组需要线性搜索，导致查找操作的线性时间复杂性。

当数据作为类的实例创建时，类定义包含有关数据结构的信息。这意味着可以通过检查类轻松识别预期的数据形状。类级别的数据模式的存在有助于发现和理解数据的预期结构。

另一方面，当数据使用通用数据结构（例如字典或列表）表示时，数据模式不作为数据表示的一部分固有包含。数据的结构和预期形状必须单独推断或记录，使其可能不那么明显或可发现。

例如，我们可以轻松定义作为类对象实例化的 `FullName` 的数据形状。让我们看看以下示例。

示例 -

class FullName:
    def __init__(self, first_name, last_name, suffix):
        self.first_name = first_name
        self.last_name = last_name
        self.suffix = suffix

但是，上面的类没有确认它期望的数据形状。假设我们错误地将存储名字的字段输入为 `first_name`。我们将收到一个错误 `TypeError: __init__() got an unexpected keyword argument 'first_name'`。

class FullName:
    def __init__(self, first_name, last_name, suffix):
        self.first_name = first_name
        self.last_name = last_name
        self.suffix = suffix

FullName(fist_name="Chris", last_name="Prat", suffix="II")

另一方面，如果我们使用通用数据结构并错误输入字段名，这可能不会抛出错误或异常。相反，结果中会省略名字。

我们将得到以下输出 -

None Prat

原则 3：数据是不可变的

根据此原则，数据永远不应更改或为可变数据。为了应用此原则，我们使我们的数据冻结。

@dataclass(frozen=True)
class StudentData:
    """Class for keeping track of an author in the system"""

    first_name: str
    last_name: str
    roll_nu: int

Python 内置的不可变数据类型有 int、float、decimal、bool、string、tuple 和 range。请注意，dict、list 和 set 是可变的。

可变性的好处是我们都可以自信地访问。处理可变数据时，将其作为参数传递给函数时务必谨慎，因为它有可能被修改或复制。

在给定示例中，最初将空列表作为默认参数传递给函数。但是，由于列表的可变性，每次调用函数时，列表都会经历修改，导致在后续调用中使用了不同的默认值。

让我们理解以下示例 -

示例 -

def append_to_list(el, list1=[]):
    list1.append(el)
    return ls
append_to_list(1)
append_to_list(2)
append_to_list(3)

输出

[1]
[1, 2]
[1, 2, 3]

我们可以使用以下代码。

示例 -

def append_to_list(el, list1=None):
    if list1 is None:
        list1 = []    
    list1.append(el)
    return list1
append_to_list(1)
append_to_list(2)
append_to_list(3)

输出

[1]
[2]
[3]

我们得到了预期的结果，因为 `None` 是不可变的。当我们使用不可变数据时，它可以毫无顾虑地传递给任何函数，因为数据永远不会改变。

它有助于获得可预测的代码行为。让我们了解以下示例。

示例 -

from datetime import date
dict1= {"age": 30}
if date.today().day % 2 == 0:
    dict1["age"] = 40

`dict1` 的年龄值是不可预测的。它取决于我们在偶数天还是奇数天运行代码。

然而，对于不可变数据，可以保证数据永远不会改变。让我们看看以下示例。

示例 -

student_data = StudentData("Rodric", "Asma", 500)
if date.today().day % 2 == 0:
    student_data.roll_nu = 100

当我们运行上面的代码时，我们将收到错误 `dataclasses.FrozenInstanceError: cannot assign to field "roll_nu"`。冻结的数据类不允许更改 `student_data.roll_nu`，无论它是偶数天还是奇数天。

另一个好处是快速相等性检查。Python 提供了两个用于确定两个对象是否相等的运算符：“is”和“==”。“is”运算符通过检查对象是否驻留在相同的内存地址来比较对象的标识，而“==”运算符通过检查对象中存储的实际内容来比较它们值是否相等。

示例 -

# String is immutable
x = "javatpoint"
# Note that the identity of `x` and `abc` is the same
print(id(x))
# 139669244330992
print(id("abc"))
# 139669244330992
print(x == "javatpoint")
# True
print(x is "javatpoint")
# True

# List is mutable
y = [1, 2, 3]

# Note that the identity of `y` and `[1, 2, 3]` is different
print(id(y))
# 140110790605632
print(id([1, 2, 3])
# 140110790605632

print(y == [1, 2, 3])
# True
print(y is [1, 2, 3])
# Fasle

如所提供的示例所示，“is”和“==”运算符在比较不可变数据类型（例如字符串，其值无法更改）时表现出相似的行为。但是，当应用于可变数据类型（例如列表）时，它们的行为有所不同。

在比较不可变数据对象时，“is”运算符往往表现得更一致。这是因为它检查对象的内存地址，提供了一种可靠的方法来确定它们在内存中是否是同一对象。另一方面，“==”运算符检查对象中存储的实际内容以评估它们的相等性。

在性能方面，“is”运算符通常比“==”运算符更快。这是因为比较对象地址比比较对象中的所有单个字段更快。不可变数据允许通过引用而不是内容比较数据来高效进行相等性检查。

在多线程环境中，当数据可变时，可能会导致潜在的竞态条件失败。竞态条件是指两个或多个线程尝试同时访问和修改相同数据，从而导致不可预测的结果。

例如，让我们考虑一个场景，其中两个线程同时尝试访问和修改变量“x”的值，通过向/从其中加/减 10。在这种情况下，由于线程执行的非确定性交错，可能会出现竞态条件。线程可能会同时读取“x”的值，执行各自的操作，然后相互覆盖更改，从而导致不正确的结果或意外的行为。

原则 4：将数据模式与数据表示分离

下面是一个简单的 JSON 模式（本质上是一个字典），它指定了表示为另一个字典的数据的结构。该模式概述了所需的字段及其各自的数据类型。另一方面，数据使用通用数据结构表示。

示例 -

schema = {
    "required": ["first_name", "last_name"],
    "properties": {
        "first_name": {"type": str},
        "last_name": {"type": str},
        "books": {"type": int},
    }
}

data = {
    "valid": {
        "first_name": "Isaac",
        "last_name": "Asimov",
        "books": 500
    },
    "invalid1": {
        "fist_name": "Isaac",
        "last_name": "Asimov",
    },
    "invalid2": {
        "first_name": "Isaac",
        "last_name": "Asimov",
        "books": "five hundred"
    }
}

数据验证函数（或库）可用于检查一段数据是否符合数据模式。

示例 -

def validate(data):
    assert set(schema["required"]).issubset(set(data.keys())), \
        f"Data must have following fields: {schema['required']}"

    for k in data:
        if k in schema["properties"].keys():
            assert type(data[k]) == schema["properties"][k]["type"], \
                f"Field {k} must be of type {str(schema['properties'][k]['type'])}"

当数据无效时，`validate()` 函数返回带有详细信息的错误，否则通过。

validate(data["valid"]))
# No error
validate(data["invalid1"])
# AssertionError: Data must have following fields: ['first_name', 'last_name']
validate(data["invalid2"])
# AssertionError: Field books must be of type <class 'int'>

在 Python 中，我们可以允许类成员是可选的。因此，此优点在 Python 上下文中并不强烈。例如，我们可以将 `roll_number` 的默认参数设置为 `None` 以指示该字段是可选的。

示例 -

class Student:
    def __init__(self, first_name: str, last_name: str, roll_number: int = None):
        self.first_name = first_name
        self.last_name = last_name
        self.roll_number = n_books
    @property
    def fullname(self):
        return f"{self.first_name} {self.last_name}"
    @property
    def is_prolific(self):
        if self.n_books:
            return self.roll_number > 100
    
student = Student("Issac", "Asimov")

此原则允许在运行时进行数据验证。它允许定义超出字段类型的数据验证条件。

如果我们将上面的模式与给定的模式进行比较，我们可以为每个字段定义更多的属性。

schema = {
    "required": ["first_name", "last_name"],
    "properties": {
        "first_name": {
            "type": str,
            "max_length": 100,
        },
        "last_name": {
            "type": str,
            "max_length": 100
        },
        "books": {
            "type": int,
            "min": 0,
            "max": 10000,
        },
    }
}

通过采用数据导向编程 (DOP) 的原则和技术，Python 开发人员可以提高他们编写更易于维护和扩展的代码的能力，从而充分发挥其数据的潜力。

下一主题什么是 PyDev

Python 中的面向数据编程

原则 1：将代码与数据分离

原则 2：用通用数据结构表示数据

原则 3：数据是不可变的

原则 4：将数据模式与数据表示分离

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Python 问题

Python 中的面向数据编程

原则 1：将代码与数据分离

原则 2：用通用数据结构表示数据

原则 3：数据是不可变的

原则 4：将数据模式与数据表示分离

相关帖子

Python 中红黑树的删除

Python 程序显示给定年份的日历

类方法 vs 静态方法 vs 实例方法

Python 中的队列

使用 Django REST Framework 创建 REST API | Django REST Framework 教程

使用 Python 求解线性方程

使用平凡哈希函数进行排序

练习 Python 编程的最佳应用程序

Python 程序将十六进制字符串转换为十进制字符串

在 Python 中保存 json 文件

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器