simplifier mes imports en Python

Bonjour
j'ai l'archi suivant dans mon dossier pour coder une plateforme d'exo de stats.
en gros, j'ai 3 catégories d'exos : des probas, des regressions et des tests d'hypothèses.

La platefome présente une une table de synthèse avec tous les exos dispobibles (ou BDD) : une ligne est égale un exo. et en colonne, on a les 3 colonnes importantes suivantes : la catégorie, les données qui sont dans un un ou plusieurs tableaux, la question. puis d'autres colonnes mais pas important ici.

j'ai un script set_DB.by qui crée les données, les exos, la table de synthèse....
ce n'est pas le script principal.
le script principal est main.py qui appelle ce script set_DB.py, puis ensuite j'ai toute la gestion de la plateforme dans le main.py.
le dossier utils correspond à diverses fonctions pour la gestion de la plafeforme.

le dossier initlaisation contient dont le script set_DB.by et tout les modules nécessaires pour créer les données, les exos, la table de synthèse....
ca marche comme ca:
set_db.py appelle 3 modules proba.py,reg.py et hyp.py.
chacun des modules va alimenter la table de synthèses.
Ainsi, le module proba.py va appeler mes modules proba_exo1.py, proba_exo2.py et proba_exo3.py pour créer la question, organiser les données dans des tableaux.
et Chaque module proba_exo1.py,proba_exo2.py,proba_exo3.py va appeler un module jeu_de_donnéeXXX.py pour créer le jeu de données .
Ils peuvent très bien appeler le meme jeu de données, la question sera différente et la question est gérée par les modules proba_exo1.py, proba_exo2.py et proba_exo3.py

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

. ├── initialisation │ ├── set_DB.py │ ├── deploiement │ ├── proba.py │ ├── reg.py │ ├── hyp.py │ ├── creation_tableau │ ├── creation_data │ │ ├── jeu_de_données1.py │ │ ├── jeu_de_données2.py │ │ ├── jeu_de_données3.py │ │ ├── jeu_de_données4.py │ ├── proba_exo1.py │ ├── proba_exo2.py │ ├── proba_exo3.py │ ├── reg_exo1.py │ ├── reg_exo2.py │ ├── reg_exo3.py │ ├── hyp_exo1.py │ ├── hyp_exo2.py │ ├── main.py │ ├── utils │ ├────── module1.py ├────── module2.py ├────── module3.py

---

en faisant, ca, j'ai des imports à rallonge pour les modules proba.py,reg.py et hyp.py.
comme jia en réalité 15 exercies par catégories.
chacun commence par 15 imports:
Proba.py va avoit 15 lignes d'import : import creation_tableau.proba_exo1 / import creation_tableau.proba_exo2 / import creation_tableau.proba_exo3 etc...
idem por Reg.py et idem pour hyp.py.

comment je peux réduire ces nombre d'import?
En gros, si j'ajout d enouveaux exo, je n'ai aps envoe d'avoir à ajouter une nouvelle ligne d'import
j'aimerai éviter les

Citation:

---

from xxx import *

---

car ensuite, je ne sais de quel module la fonction provient

merci

Bonjour

Citation:

---

Envoyé par sqlbeginner

Proba.py va avoit 15 lignes d'import : import creation_tableau.proba_exo1 / import creation_tableau.proba_exo2 / import creation_tableau.proba_exo3 etc...
idem por Reg.py et idem pour hyp.py.

comment je peux réduire ces nombre d'import?

---

Dans le dossier "creation_tableau" tu crées un fichier "__init__.py" qui contient les imports "proba_exo1", "proba_exo2" et autres. Attention il faut les nommer par rapport au main.py (qui est un niveau au dessus donc ce sera "creation_tableau.proba_exo1")
Et dans ton programme tu fais import creation_tableau. Et tu as alors accès à la fonction X de "proba_exo1" via "creation_tableau.proba_exo1.fctX()"

Exemple: un dossier "fct" qui contient

• un fichier "math.py"
  
  Code:

  ---

  1 2 3

  #!/usr/bin/env python3   def add(x, y): return x+y

  ---

• un fichier "__init__.py"
  
  Code:

  ---

  1 2	#!/usr/bin/env python3 from fct import math

  ---

Et le main.py situé au dessus

Code:

---

1 2 3 4

#!/usr/bin/env python3 import fct   print(fct.math.add(2, 3))

---

Citation:

---

Envoyé par sqlbeginner

comment je peux réduire ces nombre d'import?

---

Déjà vous pourriez choisir une organisation plus régulière et adaptée aux import:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

├── all │ ├── __init__.py │ ├── set_DB.py │ ├── deploiement ├── data │ │ ├── __init__.py │ │ ├── set1.py │ │ ├── set2.py │ │ ├── set3.py │ │ ├── set4.py │ ├── proba │ │ ├── __init__.py │ │ ├── exo1.py │ │ ├── exo2.py │ │ ├── exo3.py │ │ │ ├── reg │ │ ├── __init__.py │ │ ├── exo1.py │ │ ├── exo2.py │ │ ├── exo3.py │ │ │ ├── hyp │ ├── __init__.py │ ├── exo1.py │ ├── exo2.py │ ├── main.py │ ├── utils │ ├────── module1.py ├────── module2.py ├────── module3.py

---

Après tout dépendra de comment seront adressés les objets des différents modules...

Exemple: si depuis main je veux lancer la fonction f du module exo1.py du package all.hyp est-ce que j'ai envie de la désigner par f? exo1.f? hyp.f? hyp.exo1.f?.... Suivant ce que je veux faire, il va falloir renseigner les différents __init__.py.

Par ailleurs, pourquoi passer par des "import"? Plutôt que considérer exo1.py comme module, il pourrait être script principal d'un programme lancé via subprocess. Cela n'a pas les mêmes contraintes qu'import.

Plutôt que de vouloir faire fonctionner votre organisation peut être qu'il faudrait en trouver une plus adaptée à vos besoins (et mieux profiter des imports de modules ou d'une hiérarchie de répertoires).

- W

Bonjour,
Je n'ai probablement saisi tes contraintes , et je vais être certainement à côté de la plaque (d'autant que les cadors n'en ont pas parlé), mais au cas où :
Est-il est vraiment nécessaire de créer un module pour chacun des exercices ? Tu ne peux pas utiliser un json ?

Citation:

---

Envoyé par Hominidé

Je n'ai probablement saisi tes contraintes

---

T'inquiète pas moi non plus :aie:

Citation:

---

Envoyé par Hominidé

d'autant que les cadors n'en ont pas parlé

---

Ben c'est un peu le corollaire: je pige que dalle à son organisation donc je me contente juste de répondre à sa question "comment réduire les lignes d'import dans les différents scripts" => en les centralisant dans "__init__.py". On est d'accord que le __init__.py aura lui plein de lignes d'import qui devront êtres fatalement mises à jour quand le contenu des dossiers changera mais les scripts, eux, n'ont qu'un seul import à faire: importer le nom du dossier.

Citation:

---

Envoyé par Hominidé

Est-il est vraiment nécessaire de créer un module pour chacun des exercices ? Tu ne peux pas utiliser un json ?

---

Il n'est jamais nécessaire de... sauf que si j'ai 3 exos dans le même module, je me retrouve avec 3 fonctions différentes à appeler. Ce qui n'est pas rédhibitoire: on va juste avoir une mécanique de nommage un peu différente qui va s'appuyer sur d'autres propriétés... Mais c'est une piste à évaluer au même titre que subprocess.

- W

rien compris, je pense que le problème est plus un problème d'architecture

Une piste, il est possible de charger un fichier python dynamiquement

arborescence
.

Code:

---

1 2 3 4 5

├── exemples │ ├── 1.py │ ├── 2.py │ ├── 3.py └── main.py

---

même code "test" pour tous les fichiers dans exemples :

Code:

---

1 2	def run(): print("importé", __file__)

---

main.py

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

import importlib.util from pathlib import Path   dossier = Path( __file__ ).parent / "exemples"   # charger json avec liste et boucler dessus for i in range(1, 4): spec = importlib.util.spec_from_file_location('exercices', dossier / f"{i}.py") exercice = importlib.util.module_from_spec(spec) spec.loader.exec_module(exercice)   # chaque exercice a une fonction run() exercice.run()

---

-------------

EDIT: petite idée HS après avoir vu ce code ...

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

import importlib.util from pathlib import Path   class Loader_module: def __init__(self, filename, name="module"): self.filename = filename self.name = name   def __enter__(self): spec = importlib.util.spec_from_file_location(self.name, self.filename) mod = importlib.util.module_from_spec(spec) spec.loader.exec_module(mod) return mod   def __exit__(self, exc_type, exc_val, exc_tb): return False   dossier = Path( __file__ ).parent / "exemples" # charger json avec liste et boucler dessus for i in range(1, 4): with ( Loader_module(dossier / f"{i}.py") as exo, Loader_module(dossier / f"{i}-rep.py", name="reps") as reponse ): exo.run() reponse.run()

---