python - 在 Python 中，编写可重用代码以提供与对象列表交互的方法的最佳方法是什么？

Question

我不太确定如何提出这个问题，更不用说找到答案了，部分原因是我解决这个问题的方法可能完全错误。

我正在写一些 Python，我有一个类 (Users)，它基本上用于实例化一些特定类型的对象 (User)，然后提供一些方法来帮助我以更直接的方式处理这些对象。我的代码如下所示:

from defusedxml.ElementTree import parse

class Users:

    def __init__(self, path):

        self.path = path
        self.users = []

        users = parse(path).getroot()

        for user in users:
            u = User.user_from_xml(user)
            self.users.append(u)

    def __iter__(self):

        self.i = 0
        return self

    def __next__(self):

        if self.i < len(self.users):
            self.i += 1
            return self.users[(self.i - 1)]
        else:
            raise StopIteration

    def get_user_by_id(self, user_id):
        return next((user for user in self.users if user.id == user_id), None)

    def search_attribute(self, attribute, value):

        return [user for user in self.users if
            getattr(user, attribute, None) != None and
            value.lower() in str(getattr(user, attribute).lower())]



class User:

    def __init__(self, user_id, username, email, first_name, last_name):

        self.id = int(user_id)
        self.username = username
        self.email = email
        self.first_name = first_name
        self.last_name = last_name

    def __repr__(self):

        if self.first_name == None or self.last_name == None:
            return "%s (User Id: %s)" % (self.username, self.id)

        return "%s %s (%s)" % (self.first_name, self.last_name, self.username)

    @staticmethod
    def user_from_xml(user):

        return User(
            user.get("id"),
            element.find("username").text,
            element.find("email").text,
            element.find("firstname").text,
            element.find("lastname").text
        )

我有许多其他对象以类似的方式存储在 XML 中 - 例如，Events。我可以看出需要使用 Users 中定义的相同方法，唯一真正的区别是 __init__ 中创建的列表中包含的对象类型。

所以问题是:让这段代码可重用，同时保持可读性等的最佳方法是什么？或者我可能完全走错了路。

Answer 1

如果这些类方法真的是相同的，我认为最简单的方法就是创建一个更通用的类来替换采用另一个类的Users(例如，User 或 Event) 作为其 __init__ 方法中的参数。您的类(class)可能如下所示:

class Things(object):

    def __init__(self, PATH, Thing): #Thing is a class

        self.PATH = PATH
        self.users = []

        users = parse(PATH).getroot()

        for thing in things:
            t = Thing.thing_from_xml(thing)
            self.things.append(t)

    def methods...

更健壮/可扩展的解决方案可能是使用继承。

您可以创建一个包含所有方法的抽象基类，然后在每个子类中覆盖基类的 __init__ 方法。我将举出一个例子:

class AbstractBaseClass(object):

    def __init__(self, PATH):
        self.PATH = PATH
        self.things = []

    def methods...



class Users(AbstractBaseClass):

    def __init__(self, PATH):
        super(Users, self).__init__() # calls the parent __init__ method

        users = parse(PATH).getroot()

        for user in users:
            u = User.user_from_xml(user)
            self.things.append(u)


    #no need to define methods, as they were already defined in parent class
    #but you can override methods or add new ones if you want

您的 Events 类也将继承 AbstractBaseClass 并因此具有 Users 的所有相同方法。您应该阅读有关继承的内容，这是一个很棒的工具。

编辑以解决您的评论:

属性可能是将该属性 users 返回到您的 Users 类的好方法。将 things 更改为 _things 以表明它是私有(private)的，然后创建一个 users 属性，如下所示:

class Users(AbstractBaseClass):

    @property
    def users(self):
        return self._things

这样你就可以调用Users.users并得到Users._things。

如果你真的非常关心代码重用，你甚至可以在 __init__ 中做一些动态的事情:

class AbstractBaseClass(object):

    def __init__(self, PATH):
        self._things = []
        self.PATH = PATH

        setattr(self, self.__class__.__name__.lower(), self._things)
        #This creates an attribute that is the lowercase version of the
        #class name and assigns self._things to it

注意:我觉得这有点难看，也没有必要。此外，由于您将拥有两个相同的属性 - 这可能会导致您的对象处于不一致的状态。

也就是说，对我来说 Users.users 似乎是多余的。我不完全了解你的问题的上下文，但我想我更愿意让我的 Users 对象简单地像列表 users 一样，但是有额外的方法(那些你定义的)。

在 AbstractBaseClass 中，您可以将 __iter__ 定义为 _things 属性的 __iter__。

class AbstractBaseClass(object):

    def __init__(self, PATH):
        self._things = []
        self.PATH = PATH

    def __iter__(self):
        return self._things.__iter__()

    #You might also want this - it lets you do list-like indexing
    def __getitem__(self, i):
        return self._things.__getitem__(i)

我认为上面的内容本质上与您在原始代码中使用 __iter__ 和 __next__ 所做的相同，但方式更简洁。这样，您不必直接访问 _things 或 users 来使用您的用户对象列表；您可以通过 Users 类来处理用户列表，从名称上看，这似乎是该类的目的。