Skip to content
TheChatArchiveThe Chat Archive
gpt-4-0125-preview· OpenAIAi2 WildChat-4.8M (AI2)

Comment faire pour appeler dynamiquement une fonction d'un classe en Python. Par…

  1. User

    Comment faire pour appeler dynamiquement une fonction d'un classe en Python. Par exemple, j'ai la classe MyClass et j'aimerais appeler MyClass.function ou MyClass.subfunction.function . La fonction est un paramètre d'une fonction.

  2. Assistant

    Appeler dynamiquement une fonction d'une classe en Python peut s'effectuer de diverses manières, notamment en utilisant getattr(). Cette approche est utile dans des cas où vous ne connaissez pas à l'avance la méthode que vous souhaitez appeler, mais vous la recevez peut-être comme une chaîne de caractères (par exemple, à partir d'un fichier de configuration ou d'une entrée d'utilisateur). Je vais vous montrer comment faire cela en utilisant getattr() et en divisant les sous-fonctions et fonctions par des points si nécessaire.

    Voici un exemple basique pour vous démarrer :

    class MyClass:
        def function(self):
            print("Fonction principale appelée")
    
        class SubFunction:
            @staticmethod
            def function():
                print("Sous-fonction appelée")
    
    def call_function_dynamically(obj, function_name):
        parts = function_name.split('.')
        
        # Access the initial object (could be a class or an instance)
        current_part = getattr(obj, parts[0])
        
        # Loop through any remaining parts
        for part in parts[1:]:
            # If it's a callable (like a method), you need to call it, 
            # otherwise, just keep digging.
            if callable(current_part):
                current_part = getattr(current_part(), part)
            else:
                current_part = getattr(current_part, part)
    
        # Finally, call the function if it hasn't been called yet
        if callable(current_part):
            current_part()
    
    # Utilisation
    obj = MyClass()
    
    # Appeler une fonction directement
    call_function_dynamically(obj, 'function')
    
    # Appeler une sous-fonction
    call_function_dynamically(MyClass, 'SubFunction.function')
    

    Dans cet exemple, call_function_dynamically est une fonction qui prend un objet (instance de classe ou classe elle-même) et une chaîne de caractères représentant le nom de la fonction ou la chaîne de sous-fonctions séparées par des points. Elle utilise getattr pour accéder dynamiquement à l'attribut suivant chaque partie de la chaîne, et si cet attribut est appelable (comme une méthode ou fonction), elle l'appelle à la fin.

    Il s'agit d'une implémentation assez simple. Selon vos besoins spécifiques, en particulier si vous voulez passer des arguments à la fonction que vous appelez, vous devrez adapter cette solution. Vous pourriez, par exemple, étendre call_function_dynamically pour accepter des arguments/paramètres supplémentaires qui seront transmis lors de l'appel final.