python: Function pointer breaks polymorphism

Question

Я хотел бы хранить сигнатуру сигнатур функций в базовом классе и иметь дочерние классы, переопределяющие некоторые из этих сигнатур функций. Однако, похоже, что моя реализация ломает полиморфизм. Я хочу несколько предложений по элегантной альтернативе. Благодаря!

class Base: 
    def __init__(self, key): 
     self.FXN[key](self) 

    def f(self): 
     pass 

    def g(self): 
     pass 

    a = 1 
    FXN = { 
     1 : f, 
     2 : g 
    } 

class Child1(Base): 
    def __init__(self, key): 
     self.FXN[key](self) 

    def f(self): 
     print 'hi' 

class Child2(Base): 
    def __init__(self, key): 
     self.FXN[key](self) 

    def f(self): 
     print 'hey' 

    def g(self): 
     print 'hello' 

if __name__ == '__main__': 
    Child1(1) # Nothing happens 
    Child2(1) # Nothing happens 
    Child2(2) # Nothing happens 

Edit: осветленный проблема

Edit 2: осветленный проблема снова

Комментарий: В более сложном случае, каждый из конструкторов может взять в объект некоторого типа. Ключ - это перечисление, которое идентифицирует тип объекта и диктует, какой путь инициирования экземпляра взять.

Решение от Бруно: Мистер Бруно ниже дал мне относительно элегантное решение.

class Base: 
    def __init__(self, key): 
     self.FXN[key](self) 

    def f(self): 
     pass 

    def g(self): 
     pass 

    FXN = { 
     1 : lambda self: self.f(), 
     2 : lambda self: self.g() 
    } 

class Child1(Base): 
    def __init__(self, key): 
     self.FXN[key](self) 

    def f(self): 
     print 'hi' 

class Child2(Base): 
    def __init__(self, key): 
     self.FXN[key](self) 

    def f(self): 
     print 'hey' 

    def g(self): 
     print 'hello' 

if __name__ == '__main__': 
    Child1(1) # hi 
    Child2(1) # hey 
    Child2(2) # hello 

Answer 1

Это не «указатели на функции», только «функция» - функции Python являются объектами первого класса. И это действительно не сработает, как вы ожидаете, поскольку то, что вы храните в Base.FXN, является локальным (для операторов класса) f и g.

Есть несколько возможных решений, в зависимости от вашего реального прецедента (что вы ничего не говорите о том, и я подозреваю XY problem), один из самых простых являются определением этих функций в виде простых оберток и делегирования осуществление другой функции (которые вы затем переопределить при необходимости в дочерних классах), то есть:

class Base(object): 
    def f(self): 
     return self._f() 

    def _f(self): 
     pass 

    def g(self): 
     return self._g() 

    def _g(self): 
     pass 

    FXN = { 
     1 : f, 
     2 : g 
    } 


class Child1(Base): 
    def _f(self): 
     print 'hi' 

class Child2(Base): 
    def _g(self): 
     print 'hello' 

if __name__ == '__main__': 
    c1 = Child1() 
    c2 = Child2() 
    c1 = Child1.FXN[1](c1) 
    c2 = Child1.FXN[2](c2) 

более сложный (но, возможно, более эффективные, еще раз в зависимости от проблемы реального вы пытаетесь решить) решение может быть основано на декораторах (декораторы классов или декораторы функций), пользовательский дескриптор tors или (и/или ...) пользовательский метакласс.

EDIT: учитывая отредактированный пример, два простых решения:

использование лямбды:

class Base(object): 
    def f(self): 
     pass 

    def g(self): 
     pass 

    FXN = { 
     1 : lambda self: self.f(), 
     2 : lambda self: self.g() 
    } 

for base in receive_some_bases(): 
    base.FXN[1](base) 
    base.FXN[2](base) 

использование getattr():

class Base(object): 
    def f(self): 
     pass 

    def g(self): 
     pass 

    FXN = { 
     1 : "f", 
     2 : "g", 
    } 

for base in receive_some_bases(): 
    getattr(base, base.FXN[1])() 
    getattr(base, base.FXN[2])() 

Answer 2

FXN не имеет значения, если у вас есть экземпляр объекта

Попробуйте это:

class Base: 
    def f(self): 
     pass 

    def g(self): 
     pass 

class Child1(Base): 
    def f(self): 
     print 'hi' 

class Child2(Base): 
    def g(self): 
     print 'hello' 

if __name__ == '__main__': 
    c1 = Child1() 
    c2 = Child2() 

    c1.f() 
    c2.g() 

Answer 3

FXN является переменной класса, а не связаны с дочерними классами. Он также ссылается на исходные объекты функции f, g в dict, а не на имена, определенные в дочерних классах. Как это должно быть, поскольку они даже не существуют, когда тело базового класса выполняется?

Почему бы не использовать обычные методы? Они будут связаны с каждым классом. В качестве альтернативы вы можете привязать функции к каждому экземпляру, используя types.MethodType в __init__().

И, помните: все атрибуты экземпляра/класса уже хранятся в типе объекта (__dict__), поэтому на самом деле нет необходимости создавать свои собственные.

Answer 4

Это сделает ваш пример сделать то, что вы, кажется, хотят:

class Base: 
    def __init__(self): 
     self.FXN = { 
      1 : self.f, 
      2 : self.g 
     } 
    def f(self): 
     pass 

    def g(self): 
     pass 


def receive_some_bases(): 
    return [Child1(), Child2(), Child1(), Child2(), Child1()] 

if __name__ == '__main__': 
    for base in receive_some_bases(): 
     base.FXN[1]() 
     base.FXN[2]() 

Update: Основываясь на последних обновлениях вашего вопроса это звучит, как вы хотите завод какой-то. Словарь для классов может приспосабливать счет:

FXN={ 
    1: Child1, 
    2: Child2 
} 
def receive_some_integers(): 
    return [1, 2, 1, 2, 1] 

if __name__ == '__main__': 
    for value in receive_some_integers(): 
     c = FXN[value]() # instantiate Childx 
     c.f()    # call a method on instance