Лямбда-функция для классов в Python?

Question

Должен быть простой способ сделать это, но каким-то образом я могу обернуть голову вокруг этого. Лучший способ описать то, что я хочу, это лямбда-функция для класса. У меня есть библиотека, которая ожидает в качестве аргумента необоснованную версию класса для работы. Затем он создает экземпляр самого класса для работы. Проблема в том, что я хотел бы иметь возможность динамически создавать версии класса, передавать в библиотеку, но я не могу понять, как это сделать, так как библиотека ожидает неопознанную версию. Код ниже описывает проблему:

class Double:
    def run(self,x):
        return x*2

class Triple:
    def run(self,x):
        return x*3

class Multiply:
    def __init__(self,mult):
        self.mult = mult
    def run(self,x):
        return x*self.mult

class Library:
    def __init__(self,c):
        self.c = c()
    def Op(self,val):
        return self.c.run(val)

op1 = Double
op2 = Triple
#op3 = Multiply(5)

lib1 = Library(op1)
lib2 = Library(op2)
#lib3 = Library(op3)

print lib1.Op(2)
print lib2.Op(2)
#print lib3.Op(2)

Я не могу использовать универсальный класс Multiply, потому что я должен сначала создать его экземпляр, что нарушает библиотеку «AttributeError: экземпляр Multiply не имеет вызова метода». Не изменяя класс библиотеки, есть ли способ сделать это?

Answer 1

Действительно ли библиотека указывает, что она хочет "неинициализированную версию" (т.е. ссылку на класс)?

Мне кажется, что библиотека действительно хочет фабрику объектов. В этом случае допустимо ввести:

lib3 = Library(lambda: Multiply(5))

Чтобы понять, как работает лямбда, рассмотрим следующее:

Multiply5 = lambda: Multiply(5)
assert Multiply5().run(3) == Multiply(5).run(3)

Answer 2

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

class Double:
        def run(self,x):
            return x*2

class Triple:
    def run(self,x):
        return x*3

def createMultiplier(n):
    class Multiply:
        def run(self,x):
            return x*n
    return Multiply

class Library:
    def __init__(self,c):
        self.c = c()
    def Op(self,val):
        return self.c.run(val)

op1 = Double
op2 = Triple
op3 = createMultiplier(5)

lib1 = Library(op1)
lib2 = Library(op2)
lib3 = Library(op3)

print lib1.Op(2)
print lib2.Op(2)
print lib3.Op(2)

Answer 3

Если я правильно понимаю ваше проблемное пространство, у вас есть общий интерфейс, который принимает 1 аргумент, который вызывается с использованием класса Library. К сожалению, вместо вызова функции Library предполагает, что функция заключена в класс с методом run.

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

def make_op(f):
  class MyOp(object):
    def run(self, x):
      return f(x)
  return MyOp

op1 = make_op(lambda x: return x*2)
op2 = make_op(lambda x: return x*3)

def multiply_op(y):
    return make_op(lambda x: return x*y)

op3 = multiply_op(3)

lib1 = Library(op1)
lib2 = Library(op2)
lib3 = Library(op3)

print( lib1.Op(2) )
print( lib2.Op(2) )
print( lib3.Op(2) )

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

Answer 4

def mult(x):
    def f():
        return Multiply(x)
    return f


op3 = mult(5)
lib3 = Library(op3)
print lib3.Op(2)

Answer 5

Это обман, но вы могли бы дать вашему классу Multiply метод __call__, который возвращает сам себя:

class Multiply:
    def __init__(self,mult):
        self.mult = mult
    def __call__(self):
        return self
    def run(self,x):
        return x*self.mult

Таким образом, когда библиотека вызывает c(), она на самом деле вызывает c.__call__(), что возвращает нужный объект.

Answer 6

Поскольку type является классом по умолчанию для объекта класса python, и вызов класса создает новый экземпляр этого класса, вызов type с правильными аргументами приведет к созданию нового класса.

my_class = type("my_class", (object,), {"an_attribute": 1})

my_class теперь ссылается на новый класс с именем «my_class», который является подклассом object, с атрибутом «an_attribute», значение которого равно 1. Так как методы также являются просто атрибутами класса, указывающими на функцию объект, вы также можете добавить их в словарь атрибутов:

{"an_attribute": 1, "a_method": lambda self: print("Hello")}

Вот как это работает. Я не рекомендую делать это таким образом, если вам абсолютно не нужно. В 99% случаев вы этого не делаете. Обратитесь к ответу @Parker Coates, чтобы узнать, как достичь цели.