Comment faire pour ajouter des fonctions

J'ai regardé partout mais c'est un difficile sujet de la recherche, sans beaucoup de bruit. Je veux faire quelque chose comme ceci:

def f(arg):
  return arg * arg

def add(self, other):
  return self * other

f.__add__ = add

cubefunction = f + f

Mais j'ai des erreurs sur la commande à cubefunction comme:

TypeError: unsupported operand type(s) for +: 'function' and 'function'

Est-il pas la fonction de l'algèbre possible en python ou suis-je en faisant une erreur stupide?

edit: beaucoup plus tard, je lisais Python officiel de l'intro à la programmation fonctionnelle (http://docs.python.org/howto/functional.html), et vers le bas, il fait référence à un tiers package "fonctionnelle" (http://oakwinter.com/code/functional/documentation/), ce qui peut composer des fonctions, c'est à dire:

>>> from functional import compose
>>> def add(a, b):
...     return a + b
...
>>> def double(a):
...     return 2 * a
...
>>> compose(double, add)(5, 6)
22
Cependant, votre exemple, ce qui semble indiquer que vous souhaitez soulever une valeur à la quatrième puissance, pas de cube.
J'imagine + est destinée à être la fonction "gof" composition? (Pas de qui est permet de répondre à la surcharge de + sur un objet de fonction).
Oups, je veux dire (f + g)(x) ==> f(g(x)) ... de toute façon, je veux m'assurer que l'intention est claire. Il y a déjà une réponse montrant une technique d'utilisation d'un type intermédiaire/wrapper.
pst: je ne pense pas vraiment que des détails, je vais m'occuper de ceux plus tard, je voulais juste ajouter des fonctions aux fonctions de façon naturelle. Aurait probablement été un peu plus clair..

OriginalL'auteur user318904 | 2010-11-04

  1. 6

    Je ne pense pas que vous pouvez le faire. Cependant, l'utilisation de la __call__ méthode magique vous permet de définir votre propre rachetables de classe qui agit comme une fonction et sur lequel vous peut définir __add__:

    >>> class FunctionalFunction(object):
...     def __init__(self, func):
...             self.func = func
...
...     def __call__(self, *args, **kwargs):
...             return self.func(*args, **kwargs)
...
...     def __add__(self, other):
...             def summed(*args, **kwargs):
...                     return self(*args, **kwargs) + other(*args, **kwargs)
...             return summed
...
...     def __mul__(self, other):
...             def composed(*args, **kwargs):
...                     return self(other(*args, **kwargs))
...             return composed
...
>>> triple = FunctionalFunction(lambda x: 3 * x)
>>> times_six = triple + triple
>>> times_six(2)
12
>>> times_nine = triple * triple
>>> times_nine(3)
27

    Ici + est surchargé ponctuellement en outre, et * à la composition. Bien sûr, vous pouvez faire ce que vous voulez.

    Question intéressante pour le Python gourous: pourquoi ne le suivant pas les travaux (sale hack si elle est)?

    >>> from types import MethodType, FunctionType
>>> f = lambda: None
>>> f.__add__ = MethodType(lambda self, other: "summed!", f, FunctionType)
>>> f.__add__(f)
'summed!'
>>> f + f
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'function' and 'function'
    +1 pour montrer à l'aide d'un type intermédiaire " et " _ " call_. Cependant, je crois (f + g)(x) ==> f(g(x)) -- qui est fonction de la composition.
    heh c'est un problème de notation. J'ai ajouté à la composition de l'OP.
    Ouais, katriealex est totalement raison à ce sujet. Les fonctions sont généralement prises à un anneau. + est universellement ponctuellement en plus. * peut être ponctuellement multiplication de ou composition (si possible).
    RE: question Intéressante -- "Pour les nouvelles classes de style, implicite des invocations de méthodes spéciales sont uniquement garantis pour fonctionner correctement si elle est définie sur un objet de type, pas dans l'instance de l'objet de dictionnaire." docs.python.org/reference/...
    Oui ce n'est pas la réponse que je cherchais, mais une réponse qui fonctionne, je sais à propos de appel et les classes. Je vais marquer ce que répondu si rien de mieux se montre.

    OriginalL'auteur Katriel

  2. 1

    Je pense que ce que tu veux faire c'est:

    cubefunction = (lambda x: add(f(x), f(x)))
    Non, je pense que ce qu'il essaie de faire est de définir __add__ sur les fonctions.

    OriginalL'auteur Ross Light

  3. 1

    Dans votre code, f doit être une classe, pas une fonction. Si vous avez une classe, vous pouvez mettre en œuvre un ajouter(self, autre) méthode de la surcharge de l'opérateur+.

    OriginalL'auteur Alex

  4. 1

    Eh bien, je crois que j'ai quelque chose d'intéressant à ajouter des fonctions. C'est à propos d'une fonction lambda et il pourrait résoudre votre problème. Au moins, il fixe la mienne :

    >>> def func( x ) :
>>>     return x
>>> 
>>> f = lambda x : func( x )
>>> sum_of_f = [ f for i in range( 5 ) ]
>>> F = lambda x : sum( [ i( x ) for i in sum_of_f ] ) 
>>> F( 1 )
5
>>> F( 2 )
10

    et pour ceux qui sont intéressés pour passer des paramètres

    >>> def func( x, p ) :
>>>     return x * p
>>>
>>> param = [ 0, 1, 2, 3, 4 ]
>>> 
>>> f = lambda x, p : func( x, p )
>>> sum_of_f = [ f for i in range( 5 ) ]
>>> F_bis = lambda x : sum( [ sum_of_f[i]( x, param[i] ) for i in range( 5 ) ] )
>>> F_bis( 1 )
10
>>> F_bis( 2 )
20

    OriginalL'auteur Raoulinet

  5. 1

    Un peu en retard, mais ce genre de l'algèbre peut être fait facilement en utilisant les lambda fonctions:

    >>> f = lambda x: x*x
>>> g = lambda x: x*x
>>> h = lambda x: f(g(x))
>>> h(2)
16
>>> j = lambda x: f(x) + g(x)
>>> j(2)
8
>>>

    (f et g n'ont pas besoin d'être lambda fonctions)

    Vous pouvez faire toutes sortes de choses intéressantes avec ce. Disons que vous voulez définir la fonction f(x) = 1 + x + x**2 + ... + x**n pour un n. Vous pouvez le faire:

    >>> n = 3
>>> f = lambda x: 1
>>> for i in range(n):
...     f = lambda x, j = i + 1, k = f: k(x) + x**j
... 
>>> f(2)
15

    à comprendre pourquoi j'ai fait le lambda de cette façon (lambda x, j = i + 1, k = f:) est mieux de lire ceci: https://docs.python.org/3.5/faq/programming.html#why-do-lambdas-defined-in-a-loop-with-different-values-all-return-the-same-result

    Longue histoire courte: les paramètres dans une fonction lambda n'avez pas de copie locale. Si j'avais utilisé le ide la boucle, comme dans lambda x, k = f: k(x) + x**(i + 1), nous aurions eu de la fonction f(x) = 1 + x**3 + x**3 + x**3.

    OriginalL'auteur Andrés

  6. -2

    L'étape 1. Lisez ceci. http://en.wikipedia.org/wiki/Function_composition_(computer_science)#la Première class_composition

    L'étape 2. Lisez ceci.
    http://en.wikipedia.org/wiki/Haskell_(programming_language)

    L'étape 3. Lisez ceci.
    http://en.wikipedia.org/wiki/Scheme_(programming_language)

    Ce n'est pas le sweet spot pour Python.

    OriginalL'auteur S.Lott