Переклассификация экземпляра в Python

Это нормально. Я использовал эту идиому много раз. Однако следует иметь в виду, что эта идея не работает с классами старого стиля и различными расширениями C. Обычно это не проблема, но поскольку вы используете внешнюю библиотеку, вам просто нужно убедиться, что вы не имеете дело с классами старого стиля или расширениями C.

Я не уверен, что в данном случае лучше всего использовать наследование (по крайней мере, в отношении в «переклассификацию»). Похоже, вы на правильном пути, но похоже, что для этого лучше всего подойдет композиция или агрегирование. Вот пример того, о чем я думаю (в непроверенном псевдо-коде):

from copy import copy

# As long as none of these attributes are defined in the base class,
# this should be safe
class SkilledProgrammer(Programmer):
    def __init__(self, *skillsets):
        super(SkilledProgrammer, self).__init__()
        self.skillsets = set(skillsets)

def teach(programmer, other_programmer):
    """If other_programmer has skillsets, append this programmer's
       skillsets.  Otherwise, create a new skillset that is a copy
       of this programmer's"""
    if hasattr(other_programmer, skillsets) and other_programmer.skillsets:
        other_programmer.skillsets.union(programmer.skillsets)
    else:
        other_programmer.skillsets = copy(programmer.skillsets)
def has_skill(programmer, skill):
    for skillset in programmer.skillsets:
        if skill in skillset.skills
            return True
    return False
def has_skillset(programmer, skillset):
    return skillset in programmer.skillsets


class SkillSet(object):
    def __init__(self, *skills):
        self.skills = set(skills)

C = SkillSet("malloc","free","pointer arithmetic","curly braces")
SQL = SkillSet("SELECT", "INSERT", "DELETE", "UPDATE")

Bob = SkilledProgrammer(C)
Jill = Programmer()

teach(Bob, Jill)          #teaches Jill C
has_skill(Jill, "malloc") #should return True
has_skillset(Jill, SQL)   #should return False

Возможно, вам придется прочитать больше о наборах и произвольных списках аргументов , если вы не Я не знаком с ними, чтобы получить этот пример.

но похоже, что для этого лучше всего подойдет композиция или агрегирование. Вот пример того, о чем я думаю (в непроверенном псевдо-коде):

from copy import copy

# As long as none of these attributes are defined in the base class,
# this should be safe
class SkilledProgrammer(Programmer):
    def __init__(self, *skillsets):
        super(SkilledProgrammer, self).__init__()
        self.skillsets = set(skillsets)

def teach(programmer, other_programmer):
    """If other_programmer has skillsets, append this programmer's
       skillsets.  Otherwise, create a new skillset that is a copy
       of this programmer's"""
    if hasattr(other_programmer, skillsets) and other_programmer.skillsets:
        other_programmer.skillsets.union(programmer.skillsets)
    else:
        other_programmer.skillsets = copy(programmer.skillsets)
def has_skill(programmer, skill):
    for skillset in programmer.skillsets:
        if skill in skillset.skills
            return True
    return False
def has_skillset(programmer, skillset):
    return skillset in programmer.skillsets


class SkillSet(object):
    def __init__(self, *skills):
        self.skills = set(skills)

C = SkillSet("malloc","free","pointer arithmetic","curly braces")
SQL = SkillSet("SELECT", "INSERT", "DELETE", "UPDATE")

Bob = SkilledProgrammer(C)
Jill = Programmer()

teach(Bob, Jill)          #teaches Jill C
has_skill(Jill, "malloc") #should return True
has_skillset(Jill, SQL)   #should return False

Возможно, вам придется прочитать больше о наборах и произвольных списках аргументов , если вы не Я не знаком с ними, чтобы получить этот пример.

но похоже, что для этого лучше всего подойдет композиция или агрегирование. Вот пример того, о чем я думаю (в непроверенном псевдо-коде):

from copy import copy

# As long as none of these attributes are defined in the base class,
# this should be safe
class SkilledProgrammer(Programmer):
    def __init__(self, *skillsets):
        super(SkilledProgrammer, self).__init__()
        self.skillsets = set(skillsets)

def teach(programmer, other_programmer):
    """If other_programmer has skillsets, append this programmer's
       skillsets.  Otherwise, create a new skillset that is a copy
       of this programmer's"""
    if hasattr(other_programmer, skillsets) and other_programmer.skillsets:
        other_programmer.skillsets.union(programmer.skillsets)
    else:
        other_programmer.skillsets = copy(programmer.skillsets)
def has_skill(programmer, skill):
    for skillset in programmer.skillsets:
        if skill in skillset.skills
            return True
    return False
def has_skillset(programmer, skillset):
    return skillset in programmer.skillsets


class SkillSet(object):
    def __init__(self, *skills):
        self.skills = set(skills)

C = SkillSet("malloc","free","pointer arithmetic","curly braces")
SQL = SkillSet("SELECT", "INSERT", "DELETE", "UPDATE")

Bob = SkilledProgrammer(C)
Jill = Programmer()

teach(Bob, Jill)          #teaches Jill C
has_skill(Jill, "malloc") #should return True
has_skillset(Jill, SQL)   #should return False

Возможно, вам придется прочитать больше о наборах и произвольных списках аргументов , если вы не Я не знаком с ними, чтобы получить этот пример.

Хе-хе, забавный пример.

«Переклассификация» на первый взгляд довольно странная. А как насчет подхода «конструктор копирования»? Вы можете сделать это с помощью Reflection-like hasattr , getattr и setattr . Этот код скопирует все из одного объекта в другой, если он еще не существует. Если вы не хотите копировать методы, вы можете их исключить; см. прокомментированный if .

class Foo(object):
    def __init__(self):
        self.cow = 2
        self.moose = 6

class Bar(object):
    def __init__(self):
        self.cat = 2
        self.cow = 11

    def from_foo(foo):
        bar = Bar()
        attributes = dir(foo)
        for attr in attributes:
            if (hasattr(bar, attr)):
                break
            value = getattr(foo, attr)
            # if hasattr(value, '__call__'):
            #     break # skip callables (i.e. functions)
            setattr(bar, attr, value)

        return bar

Все это отражение некрасиво, но иногда вам нужна уродливая машина отражения, чтобы делать крутые вещи. ;)

Мне эта техника кажется вполне питонической. Композиция также была бы хорошим выбором, но присвоение __ class __ вполне допустимо (см. здесь для рецепта, который использует его немного по-другому).

Я скажу, что это прекрасно, если это сработает для вас.

«Шаблон состояния позволяет объекту изменять свое поведение при изменении его внутреннего состояния. Создается впечатление, что объект меняет свой класс». - Шаблон дизайна «Сначала голова». Что-то очень похожее пишут Gamma et.al. в их книге "Паттерны дизайна". (У меня он есть в другом месте, поэтому без цитаты). Я думаю, что в этом весь смысл этого паттерна проектирования. Но если я могу изменить класс объекта во время выполнения, большую часть времени мне не нужен шаблон (бывают случаи, когда State Pattern не просто имитирует изменение класса).

Кроме того, изменение класса во время выполнения не всегда работает:

class A(object):
    def __init__(self, val):
        self.val = val
    def get_val(self):
        return self.val

class B(A):
    def __init__(self, val1, val2):
        A.__init__(self, val1)
        self.val2 = val2
    def get_val(self):
        return self.val + self.val2


a = A(3)
b = B(4, 6)

print a.get_val()
print b.get_val()

a.__class__ = B

print a.get_val() # oops!

Кроме того, я рассматриваю возможность изменения класса во время выполнения Pythonic и время от времени использую его.