comment activer une fonction à partir d'un autre script


Réponse 1:

Votre code d'origine est:

def func1 (): a = 8 b = 9def func2 (x, y): z = x + y + a + b retour za = func2 (4,6)imprimer (a)

Il y a plusieurs moyens de le faire :

# Utiliser les valeurs de retour # Soyez explicite que l'appel à func2 repose sur le résultat # de l'appel à func1def func1 (): a = 8 b = 9 retourne a, bdef func2 (x, y, args): a, b = * args # Décompresser les arguments z = x + y + a + b retour za = func2 (4,6, args = func1 ())imprimer (a)# mais vous pouvez faire: a = func2 (4,6, args = (9,11)) # Vous n'avez pas besoin d'une fonction pour créer vos données

ou

# Fonctions de passage: # Dans cette solution, vous êtes explicite lorsque vous appelez # func2 dont il a besoin pour appeler func1: func1 est une fonction d'assistancedef func1 (): a = 8 b = 9 retourne a, bdef func2 (x, y, func): a, b = func () z = x + y + a + b retour za = func2 (4,6, func1)imprimer (a)# Si vous avez une autre fonction qui génère une paire de valeurs # tu pourrais passer ça aussi

Je dirais de ne pas utiliser du tout Globals - ils semblent être une solution rapide, mais c'est une très mauvaise habitude à prendre.

Les globaux par définition représentent des informations sur le fonctionnement de votre fonction qui sont en dehors des arguments de votre fonction, ce qui peut rendre votre fonction beaucoup plus difficile à tester - car vous devez maintenant passer des arguments à votre fonction et définir séparément les valeurs globales pertinentes dans l'ordre pour tester votre fonction (vous testez vos fonctions, n'est-ce pas). Parfois, il est impossible de s'éloigner des données globales (par exemple, les bases de données, les sites Web externes), et vous devez parfois sauter à travers des cerceaux pour tester votre code lorsque vous avez des données externes - mais ne vous rendez pas la vie encore plus difficile. .


Réponse 2:

Cela dépend du code de chaque fichier, mais la réponse est essentiellement la même:

Que la fonction soit une méthode d'un objet, ou simplement nue dans un module, vous pouvez l'importer de partout où elle a été déclarée, où vous voulez l'utiliser.

Vous pouvez avoir de bonnes raisons de ne pas incorporer votre fonction dans un objet, mais vous voudrez peut-être valider cette raison. Il existe des arguments raisonnables pour et contre.

Appelons un fichier de code Python un 'module'. De manière pratique, les modules Python nous donnent un espace de noms «gratuit» pour garder nos déclarations hors de l'espace de noms global, où elles peuvent entrer en collision avec des déclarations actuelles ou futures ailleurs dans le code.

Une structure de répertoires de modules étroitement liés est appelée un package.

Une structure de répertoires de modules non liés s'appelle… un désordre.

Dans tous les cas, si un module, stocké dans un fichier appelé foo.py, contient une fonction nommée bar:

def bar (chose1, chose2): renvoie "{0}, {1}". format (chose1, chose2)// ignorer ça pour le moment def yoda_speak (chose1, chose2): renvoie "{0}, {1}". format (chose2, chose1)

… Puis, dans un autre fichier, vous pouvez importer la barre de fonctions depuis le module foo:

de la barre d'importation foochose = bar ("importé", "ceci")

… Ou bien, vous pouvez importer le module entier foo, tous ont accès à toutes ses fonctions à la fois, si vous êtes sûr que vous les voudrez toutes… tant que vous vous y référez par leur espace de noms (par exemple foo.function_name () )…

importer fooboth_things = foo.bar ("Attention avec ça", "mais vous pouvez importer toutes les fonctions de ce module") yoda_speak = foo.anti_bar ("c'est", "en arrière")

Réponse 3:

Il y a un cas qui fait exactement ce que vous décrivez dans votre question, même si ce n'est peut-être pas votre cas d'utilisation. C'est une * fermeture *.

def ma fonction (a): b = 2 * a def myotherfunction (c): retour b * c retourner mon autre fonction

myotherfunction conserve effectivement une copie de a, qui l'utilisera à chaque appel

myother = mafonction (5)résultat = ma mère (5)imprimer (résultat)

qui imprimera: 50

La variable locale b est le résultat de a * 2, qui dans notre cas était 5. Elle est conservée comme référence pour mon autre fonction qui est la valeur de retour

Chaque fois que la fonction retournée est invoquée, elle multipliera l'argument c par la valeur de la variable locale b qui a été conservée comme référence.


Réponse 4:

Je vais vous proposer d'autres méthodes, bien que l'utilisation d'une classe et de méthodes et d'attributs soit la voie à suivre.

'' ' solution explicite, passant des informations via un mutable. J'utilise quelque chose comme ça pour les programmes récursifs avec des informations d'état.'' 'importer pprintdef f (d: dict) -> Aucun: print ('fonction f: remplissage de l'argument avec des variables locales') a_local_variable = 'f m'a créé' d ['a_local_variable_from_elsewhere'] = a_local_variabledef g (d: dict) -> Aucun: print ('FONCTION g: UTILISATION D'ARGUMENT AVEC DES VARIABLES LOCALES CRÉÉES AILLEURS') pprint.pprint (d)def main (): pass_variables_around = {} f (pass_variables_around) g (pass_variables_around)principale()

Réponse 5:
variable = 0def modify_global (): variable globale variable + = 1variable d'impression>>>> 1

Le mot-clé global permet de modifier localement des variables globales dans une fonction.

La définition d'une fonction à l'intérieur d'une autre ne transmet pas la valeur des mêmes variables nommées. Check-out

9. Classes - Documentation Python 3.7.0

les sections 9.1 et 9.2 pour une brève explication du fonctionnement du nommage en Python.


Réponse 6:
def func1 (): global a, b a = 8 b = 9def func2 (x, y): func1 () z = x + y + a + b retour za = func2 (4, 6)imprimer (a)#Je suis nouveau sur python donc je ne suis pas sûr que ce soit la meilleure solution. Mais c'est une des solutions.Vous devez essentiellement rendre les variables a et b globales en les déclarant si vous souhaitez les utiliser dans une autre fonction.

Réponse 7:

Je ne suis pas sûr de comprendre ce que vous voulez dire. Mais si vous importez une fonction d'un fichier dans un autre, l'importateur peut transmettre des valeurs à la fonction et la fonction peut mettre à jour n'importe quoi dans son propre fichier.

Cependant, si je comprends bien (et il est fort probable que je ne le fasse pas), ce que vous essayez de faire est, dans de nombreux cas, de très mauvaises pratiques de programmation, en vous appuyant sur des globaux de module.


Réponse 8:

Bien qu'il existe certainement des moyens, ne le faites pas. Si vous souhaitez modifier certaines valeurs à l'intérieur d'une fonction et utiliser ces valeurs modifiées dans une autre fonction, transmettez les valeurs à modifier à la première fonction via les paramètres d'appel et acceptez les valeurs modifiées comme valeur de retour de la fonction. Transmettez les valeurs modifiées à la deuxième fonction et acceptez ses valeurs de retour.

Il s'agit d'une meilleure pratique généralement acceptée du paradigme de la programmation fonctionnelle qui tente de minimiser (inattendu et non évident) les effets secondaires de l'appel d'une fonction.


Réponse 9:

Le code que vous avez fourni va générer des erreurs.

Pourquoi? En raison du fonctionnement des portées variables dans Python. a et b, déclarés dans func (), n'affectent que cette fonction, c'est leur portée.

Si vous souhaitez modifier les valeurs d'une variable globale à l'intérieur d'une fonction, vous devez utiliser le mot-clé global:

global xx = 123imprimer xfunc ()imprimer xdef func (): x = 124

tl; dr Votre code, tel qu'il est, ne fonctionnera pas.


Réponse 10:

Oui, c'est ce que vous recherchez. J'espère que ça aide.

def c (): r = raw_input ("Demander quelque chose?") ... retour rdef p (x): ... faire quelque chose ....r = c ()p (r)