Discussion :

[sqlbeginner]

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 :

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

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

from xxx import *

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

merci

[Sve@r]

Bonjour

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 python :

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

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

• un fichier "__init__.py"
  

  Code python :

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

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

Et le main.py situé au dessus

Code :

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

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

[wiztricks]

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 :

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

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

[MPython Alaplancha]

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 ?

[Sve@r]

Je n'ai probablement saisi tes contraintes

T'inquiète pas moi non plus

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.

[wiztricks]

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

[papajoker]

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 :

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

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 :

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

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

main.py

Code :

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

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 :

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

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()