Discussion :

[Mr Hyde]

Bonjour à tous!

Voici mon problème: Je dispose de 10 fichiers .py dont les noms vont de fich_1.py à fich_10.py.

Dans un autre post, guigui m'a expliqué comment importer des fichiers dont le nom est une variable:

Code :

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

1
2
3
4
 
for val in range(10):
      monimport = 'fich_'+str(val)
      exec('import '+monimport)

En fait, ces fichiers contiennent des variables...mon problème est que je ne sais pas comment les récuperer dans ces fichiers. Par exemple une de ces variables s'appelle id.

J'ai essayé:

Code :

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

1
2
3
 
nom_var="fich_1.id"
print nom_var

Mais évidemment, vu qu'il sagit d'une chaine de caractère, ca n'a pas marché....

Quelqu'un sait-il comment récuperer mon id : :

[Onarap]

Essaie ceci:

Code :

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

eval("fich_1.id")

[bibile]

pourquoi tu fais pas:

Code :

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

1
2
nom_var=fich_1.id
print nom_var

[Mr Hyde]

Merci beaucoup Onarap !!
C'est parfait!

pourquoi tu fais pas:
Code:
nom_var=fich_1.id
print nom_var

Car j'ai beaucoup de fichiers fich_ (fich_1, fich_2, fich_3,.....) et mon programme en génère régulièrement. Il faut que je puisse traiter ca dans une boucle... et si je fais:

Code :

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

1
2
 
nom_var="fich_"+str(un_chiffre)+".id"

Je ne peu plus utiliser print ou quoi que ce soit d'autre car ce sera directement interpreté comme une chaine de caractères et non comme un nom de variable...mais bon maintenant tout va bien! Onarap m'a sauvé! Merci encore!!

[tmeg57]

Dans un autre post, guigui m'a expliqué comment importer des fichiers dont le nom est une variable:

Hello Mr Hyde,

As tu la référence de ce post svp ? Je suis confronté au même problème, jJ'ai cherché dans ton historique de message mais pas reussi à retomber dessus...
Merci d'avance.

[Sve@r]

jJ'ai cherché dans ton historique de message mais pas reussi à retomber dessus...

T'aurais simplement cherché dans la doc de import...

Code python :

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

1
2
3
4
>>> x="os"
>>> os=__import__(x)
>>> os.getcwd()
'/tmp'

[tmeg57]

testé et approuvé, merci Sve@r.

Désolé, je débute avec python et j'ai, à tord, pas forément encore les bons reflexes.
En parlant de bonne pratiques .Je m'en vais aussi aller lire la faq au passage.

[Sve@r]

Je suis confronté au même problème

Désolé, je débute avec python

Un débutant Python ne devrait pas avoir de souci d'import variable (il n'aurait pas conçu un projet suffisamment complexe pour en arriver là). Ce qui laisse penser que ton souci est plutôt un souci de mauvaise conception...

[tmeg57]

Un débutant Python ne devrait pas avoir de souci d'import variable (il n'aurait pas conçu un projet suffisamment complexe pour en arriver là). Ce qui laisse penser que ton souci est plutôt un souci de mauvaise conception...

Oui, c'est probablement le cas et je suis tout à fait ouvert à discussion pour m'orienter vers une meilleur voie.

Je cherche à centraliser mes différentes automatisation au sein d'une boite à outils centrale pour gagner du temps et lancer plus rapidement/facilement mes différents outils.
J'ai prévu de passer via un mini programme à menu en ligne de commande.
Je suis tombé sur la possibilité de passer par la commande import pour faire l'appel à mes différents scripts externes, mais le lancement du programme importé ne marche que la première fois et je dois passer par un reload si le module a déjà été importé : d'où mon besoin de passer par une fonction avec variabilisation.

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
36
 
import sys
import importlib
 
MENU = """
| ################################################################### |
|                            Menu                                     |
| ################################################################### |
|  1: getK                                                            |
| 99: Quitter                                                         |
| ################################################################### |
Votre choix : 
"""
MENU_CHOICES = ['1', '99']
 
def launch_prog(programme):
     if not programme in sys.modules:
          __import__(programme)
          # ou exec(f'import {programme}')
     else:
         importlib.reload(sys.modules[programme])
 
# ------------------------- MAIN Program ----------------------------------------------------
while True:
    user_choice = input(MENU)
    print(f"  ==> {user_choice}")
    if user_choice not in MENU_CHOICES:
        print("Veuillez choisir une option valide...")
        continue
 
    if user_choice == "1":  # Ajouter un élément
        launch_prog('getK')
    elif user_choice == "99":  # Quitter
        print("À bientôt !")
        sys.exit()
    print("-" * 50)

Je prévois aussi d'ajouter la possibilité de spécifier des arguments aux différents programmes.

[Sve@r]

Je cherche à centraliser mes différentes automatisation au sein d'une boite à outils centrale pour gagner du temps et lancer plus rapidement/facilement mes différents outils.

La solution de base dans ce genre de cas c'est de tout importer. Ensuite ton programme peut appeler au choix n'importe quelle fonction de n'importe quel module.

Sinon ton système est ingénieux. Il est cependant améliorable

Code python :

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
36
37
38
39
40
41
42
43
44
#!/usr/bin/env python3
# coding: utf-8
 
import sys
import importlib
 
def launch_prog(programme):
	if not programme in sys.modules:
		__import__(programme)
		# ou exec(f'import {programme}')
	else:
		importlib.reload(sys.modules[programme])
# launch_programme()
 
def menu(choices):
	while True:
		print("| ################################################################### |")
		print("|							Menu									 |")
		print("| ################################################################### |")
		for (k, v) in choices.items():
			print("|  %s: %s" % (k, v if v is not None else "Quitter"))
		print("| ################################################################### |")
		c=input("Votre choix :")
		if c in choices: return choices[c]
		print("Veuillez choisir une option valide...")
	# while
# menu()
 
# ------------------------- MAIN Program ----------------------------------------------------
MENU_CHOICES = {
	"1" : "getK",
	"99" : None,
}
while True:
	user_choice = menu(MENU_CHOICES)
	print(f"  ==> {user_choice}")
 
	if user_choice is None:
		print("À bientôt !")
		sys.exit()
 
	launch_prog(user_choice)
	print("-" * 50)
# while

Tu veux rajouter d'autres modules, te suffit de les rajouter simplement dans MENU_CHOICES et le code s'adapte tout seul.

[tmeg57]

Merci Sve@r pour l'optimisation du code.

Il ne m'est pas possible d'importer le tout car certains de mes programmes nécessaites des arguments.

Dailleurs à ce sujet, pour l'appel du programme externe j'ai remplacer l'import par cette commande commande finalement :

Code :

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

os.system(f"python D:\_docz\_devz\python\BDL\getK.py {options}")

car j'utilise argparse dans mes programmes pour la gestion des arguments de type -db (ou --db) et je n'ai pas reussi à passer ce type d'arguments lors de l'import de module. L'autre avantage est que je n'ai plus le problème de module déjà chargés à gérer.

[Sve@r]

car j'utilise argparse dans mes programmes pour la gestion des arguments de type -db (ou --db) et je n'ai pas reussi à passer ce type d'arguments lors de l'import de module.

Ah je me doutais bien qu'il y avait un gros souci de conception. Il ne faut pas confondre "import de module" et "appel de programme".
Quand tu crées un programme, tu lui crées des fonctions permettant d'effectuer les actions. Puis dans l'interface vers l'utilisateur tu y mets les options que l'utilisateur devra utiliser. Et ensuite selon les options choisies tu effectues tel ou tel traitement en appelant telle ou telle fonction
Exemple: prog.py

Code python :

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
def travailX(...):
	... (travail X)...
	... (travail X)...
	... (travail X)...
# travailX()
 
def travailY(...):
	... (travail Y)...
	... (travail Y)...
	... (travail Y)...
# travailY()
 
if __name__ == "__main__":
	... (argparse)...
	if arg == "X": travailX()
	if arg == "Y": travailY()
# if

La partie if __name__ == "__main__" est cele qui permet de différencier "prog utilisé comme programme" et "prog importé". Quand il est utilisé comme programme, la variable __name__ vaut "__main__" et quand il est importé elle vaut autre chose (le nom de l'import).

Donc rien n'interdit d'importer "prog.py" dans un autre programme qui aura ses propres gestion d'options...

Exemple toto.py

Code python :

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

1
2
3
4
5
6
7
import prog
 
if __name__ == "__main__":
	... (argparse)...
	if arg == "XXX": prog.travailX()
	if arg == "YYY": prog.travailY()
# if

Ce n'est pas à l'import qu'on gère les arguments, mais à l'appel du programme. Et donc rien n'interdit de tout importer.