Discussion :

[bibifoot]

Bonjour/bonsoir ^^

Alors voilà le problème est tout bête, pour "simplifier" un programme que je fais je me suis demander une chose et je n'ai pas trouvé de cas similaire ailleurs alors voici:

Si j'ai un fichier 'A.py' qui contient la 'fonction A1' et qui importe un fichier 'B.py' qui contient la 'fonction B1', est-ce que je peux dire dans 'B1' de lancer 'A1' sachant que tout est lancer depuis 'A.py'

Merci d'avance à ceux qui sauront me dire

[wiztricks]

Si j'ai un fichier 'A.py' qui contient la 'fonction A1' et qui importe un fichier 'B.py' qui contient la 'fonction B1', est-ce que je peux dire dans 'B1' de lancer 'A1' sachant que tout est lancer depuis 'A.py'

B1 est appelé depuis A qui a accès à A1.
Si B1 doit lancer une fonction, la passer en paramètre évite de le coder en dur... et les variables globales à trimballer.

- W

[tyrtamos]

Bonjour,

Une solution que j'ai déjà utilisée pour qu'un module importé puisse accéder aux attributs du "main", tout en évitant les importations circulaires:

fichier A.py:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
import B
 
def A1():
    return "toto"
 
B.B1()

Fichier B.py:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
import sys
pmain = sys.modules['__main__']
 
def B1():
    print("B1 =>", pmain.A1())

Exécution de A donne:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

B1 => toto

On voit bien que l'appel à B1 à partir de A a permis à B1 de lancer A1.

A noter que dans cette solution, B n'a pas besoin de connaître le nom de A.

[Invité]

@tyrtamos Intéressant !

J'aurai tendance à penser que le problème se résout en revoyant le code plutôt qu'en voulant faire ça ainsi, mais ça peut sûrement servir dans certains cas...

@wiztricks

Si B1 doit lancer une fonction, la passer en paramètre évite de le coder en dur...

Ah oui tiens j'ai jamais pensé qu'on pouvait faire ça

Script a.py :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
import b
 
def A1(i):
    x = b.B1(i, A1)
    print(x)
 
A1(0)

Script b.py :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
def B1(p, func) :
    z = p+1
 
    if z < 10:
        func(z)
 
    return z

Résultat :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
10
9
8
7
6
5
4
3
2
1

Ca m'a surpris sur le coup ce comportement même si ça se comprend...

[Sve@r]

Alors voilà le problème est tout bête, pour "simplifier" un programme que je fais je me suis demander une chose et je n'ai pas trouvé de cas similaire ailleurs alors voici:

Si j'ai un fichier 'A.py' qui contient la 'fonction A1' et qui importe un fichier 'B.py' qui contient la 'fonction B1', est-ce que je peux dire dans 'B1' de lancer 'A1' sachant que tout est lancer depuis 'A.py'

Pas de cette façon. Car quand B est importé il ne connait pas A1. Et si dans B tu importes A, ça devient un import circulaire

Ce qu'on fait en général: on crée un programme principal qui fait le premier import, celui qui lui permettra d'appeler B1(). Et si B doit appeler A1, alors B importe A mais ce n'est plus un import circulaire puisque A n'importe pas B
Exemple
Fichier A

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
#!/usr/bin/env python3
# coding: utf-8
 
def A1():
	print("A1")

Fichier B.py

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
#!/usr/bin/env python3
# coding: utf-8
 
from A import *
 
def B1():
	print("B1")
	A1()

Fichier main.py

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
#!/usr/bin/env python3
# coding: utf-8
 
from B import *
B1()

[bibifoot]

Pardon de l'absence et merci beaucoup pour vos réponses ! Il y a de quoi faire je vais essayer tout ça, je peux mettre en résolu

[jurassic pork]

hello,
Dans B tu peux faire un import de A voir ici
Traduction par google:

Que se passera-t-il si deux modules s'importent l'un l'autre ?
Pour généraliser le problème, qu'en est-il des importations cycliques en Python ?
Réponse donnée:
Si vous faites import foo(à l'intérieur de bar.py) et import bar(à l'intérieur de foo.py), cela fonctionnera bien. Au moment où quelque chose s'exécute réellement, les deux modules seront complètement chargés et auront des références l'un à l'autre.
Le problème est quand à la place vous faites from foo import abc(à l'intérieur de bar.py) et from bar import xyz(à l'intérieur de foo.py). Parce que maintenant, chaque module nécessite que l'autre module soit déjà importé (afin que le nom que nous importons existe) avant de pouvoir être importé.

Ami calmant, J.P