Déclencher une fonction automatiquement si une fonction d'une liste de fonctions est appelée en Python

voix
0

Est-il un moyen de déclencher une fonction automatiquement le cas échéant d'une liste des fonctions est appelée en python?

Comme dire la fonction A est attaché à une liste de fonctions [b, c, d, e] et si l'une des [b, c, d, e] est appelé (par exemple dire que b ()), puis un () est appelée automatiquement avant cela?

Je veux utiliser la fonction de mettre en place certaines valeurs avant b est appelée pour que b puisse l'utiliser.

Comme par exemple:

# function b is some inbuilt, library function
attach(a, b) #attach function b to function a
b()
# If function b is called first function a gets called, it changes up some 
# global variables for the use of function b, then function b gets executed 

J'ai quelques variables globales et certaines méthodes de classe, les variables globales sont somethings comme CLASSIFIER (par exemple, régression logistique ou XGBClassifier), CLASSIFIER_TYPE (par exemple « linéaire » ou un arbre) que je dois changer chaque fois que j'appelle en forme et prévoir des méthodes sur leurs pipelines respectifs ( par exemple pipeline_linear ou pipeline_tree) .fit / prédire. Ceci est parce que j'ai le code écrit comme:

CLASSIFIER = LogisticRegression
CLASSIFIER_TYPE = 'linear'
pipeline_linear = make_pipeline(preprocessing_pipe, CLASSIFIER())
pipeline_linear.fit(X, y)
CLASSIFIER = XGBClassifier
CLASSIFIER_TYPE = 'tree'
pipeline_tree = make_pipeline(preprocessing_pipe, CLASSIFIER())
pipeline_tree.fit(X, y)
linear_preds = pipeline_linear.predict(X) # This statement throws an error
# because CLASSIFIER and CLASSIFIER_TYPE are not changed
# preprocessing_pipe uses CLASSIFIER_TYPE internally to take care of  
# handling both types of classifiers differently.

Donc, sur la base du pipeline que je utilise, les variables globales doivent être modifiés en conséquence pour que l'ajustement et prévoir des méthodes de travail sur les pipelines (pipeline_linear et pipeline_tree).

Toute autre bonne approche pour prendre soin de ces situations sera vraiment utile!

Créé 27/11/2018 à 15:07
source utilisateur
Dans d'autres langues...                            


3 réponses

voix
2

Utiliser un emballage.

Si votre fonction est my_functionet votre liste est list_of_functions:

def func_wrapper(query):
    for additional_function in list_of_functions:
        # Do whatever you need to do with your list of functions
        additional_function()

    my_function(query)
Créé 27/11/2018 à 15:10
source utilisateur

voix
1

Je pense que vous pouvez toujours utiliser quelque chose comme un décorateur / emballage. Voir si quelque chose comme cela pourrait fonctionner pour vous:

MY_GLOBAL = 123

def wrap_with_global_value(func, global_val):
    def wrap(*args, **kwargs):
        global MY_GLOBAL
        prev_global_val = MY_GLOBAL
        MY_GLOBAL = global_val
        result = func(*args, **kwargs)
        MY_GLOBAL = prev_global_val
        return result
    return wrap

class MyClass(object):
    def my_func(self):
        global MY_GLOBAL
        print('from my_func: MY_GLOBAL is {}.'.format(MY_GLOBAL))

my_obj = MyClass()
my_obj.my_func = wrap_with_global_value(my_obj.my_func, 456)

print('Before calling my_func: MY_GLOBAL is {}.'.format(MY_GLOBAL))
my_obj.my_func()
print('After calling my_func: MY_GLOBAL is {}.'.format(MY_GLOBAL))

Sortie:

Before calling my_func: MY_GLOBAL is 123.
from my_func: MY_GLOBAL is 456.
After calling my_func: MY_GLOBAL is 123.

Vous pouvez ajouter functools.wrapssi cela est important pour vous.

Créé 27/11/2018 à 16:12
source utilisateur

voix
0

Certes, il serait plus facile de simplement appeler la fonction au-dessus de l'autre fonction?

def setup():
    # Set some variables
    pass

def target1():
    setup()
    pass

def target2():
    setup()
    pass
Créé 27/11/2018 à 15:11
source utilisateur

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more