Python : Programmation système - Historique des versions

Justine le 22 juin 2022 à 12:07

2022-06-22T12:07:44Z

← Version précédente		Version du 22 juin 2022 à 12:07
Ligne 1 :		Ligne 1 :
			[[Category:prog]]
			[[Category:python]]
	L'ensemble de ces notes est issu de : [https://openclassrooms.com/fr/courses/235344-apprenez-a-programmer-en-python/234239-un-peu-de-programmation-systeme https://openclassrooms.com/fr/courses/235344-apprenez-a-programmer-en-python/234239-un-peu-de-programmation-systeme]		L'ensemble de ces notes est issu de : [https://openclassrooms.com/fr/courses/235344-apprenez-a-programmer-en-python/234239-un-peu-de-programmation-systeme https://openclassrooms.com/fr/courses/235344-apprenez-a-programmer-en-python/234239-un-peu-de-programmation-systeme]

Justine le 26 novembre 2021 à 17:08

2021-11-26T17:08:52Z

← Version précédente		Version du 26 novembre 2021 à 17:08
Ligne 262 :		Ligne 262 :
	</source>		</source>
	La variable resultat_commande contiendra alors la sortie de la commande.		La variable resultat_commande contiendra alors la sortie de la commande.

	~~= ArgParse : Mon bloc habituel =~~
	~~Ceci est le bloc que j'ai l'habitude d'utiliser avec Argparse. Il contient plein de cas de figure.~~

	~~<source>~~
	~~def get_args():~~
	~~'''Gets all the arguments passed to the script and returns them in a parse_args()-type object.~~
	~~No args~~
	~~Returns:~~
	~~-args : an args object containing all the optional arguments passed to the script.~~
	~~'''~~
	~~import argparse~~

	~~parser = argparse.ArgumentParser()~~
	parser.add_argument("-m", "--matrice", help = "Mode individuel : donner le nom de la matrice pour faire un refresh des droits ou tout regénerer sur celle-ci. Utiliser en combinaison avec -r ou -g. exemple : dsi", action="store", type=str, required=False)
	~~parser.add_argument("-g", "--gsd", help="Regénerer tous les groupes et les droits", action='store_true', required=False)~~
	~~parser.add_argument("-v", "--verbose", help="Verbose", action='store_true', required=False)~~
	~~parser.add_argument("-r", "--refresh", help="Ne générer que les droits utilisateurs", action="store_true", required=False)~~
	~~parser.add_argument("-f", "--folder", help="Dossier à partir duquel on va chercher les matrices", type=str, action="store", required=True)~~
	~~parser.add_argument("-a", "--all", help="Mode Collectif : Agir sur toutes les matrices. Utiliser en combinaison avec -r ou -g", action="store_true", required=False)~~
	~~parser.add_argument("-l", "--logdir", help="Dossier ou sera stocké le fichier de log. Par défaut, choisis le même dossier que ce script", type=str, required=False)~~
	~~parser.add_argument("-e", "--execute", help="Executer localement les commandes powershell générées", action='store_true', required=False)~~
	~~parser.add_argument("-s", "--server", help="Serveur Active Directory sur lequel sera vérifiée l'existence des utilisateurs.", type=str, action="store", required=True)~~
	~~#Creating the args object~~
	~~args=parser.parse_args()~~

	~~return args~~
	~~</source>~~

Justine le 25 novembre 2021 à 21:48

2021-11-25T21:48:55Z

← Version précédente		Version du 25 novembre 2021 à 21:48
Ligne 262 :		Ligne 262 :
	</source>		</source>
	La variable resultat_commande contiendra alors la sortie de la commande.		La variable resultat_commande contiendra alors la sortie de la commande.

			= ArgParse : Mon bloc habituel =
			Ceci est le bloc que j'ai l'habitude d'utiliser avec Argparse. Il contient plein de cas de figure.

			<source>
			def get_args():
			'''Gets all the arguments passed to the script and returns them in a parse_args()-type object.
			No args
			Returns:
			-args : an args object containing all the optional arguments passed to the script.
			'''
			import argparse

			parser = argparse.ArgumentParser()
			parser.add_argument("-m", "--matrice", help = "Mode individuel : donner le nom de la matrice pour faire un refresh des droits ou tout regénerer sur celle-ci. Utiliser en combinaison avec -r ou -g. exemple : dsi", action="store", type=str, required=False)
			parser.add_argument("-g", "--gsd", help="Regénerer tous les groupes et les droits", action='store_true', required=False)
			parser.add_argument("-v", "--verbose", help="Verbose", action='store_true', required=False)
			parser.add_argument("-r", "--refresh", help="Ne générer que les droits utilisateurs", action="store_true", required=False)
			parser.add_argument("-f", "--folder", help="Dossier à partir duquel on va chercher les matrices", type=str, action="store", required=True)
			parser.add_argument("-a", "--all", help="Mode Collectif : Agir sur toutes les matrices. Utiliser en combinaison avec -r ou -g", action="store_true", required=False)
			parser.add_argument("-l", "--logdir", help="Dossier ou sera stocké le fichier de log. Par défaut, choisis le même dossier que ce script", type=str, required=False)
			parser.add_argument("-e", "--execute", help="Executer localement les commandes powershell générées", action='store_true', required=False)
			parser.add_argument("-s", "--server", help="Serveur Active Directory sur lequel sera vérifiée l'existence des utilisateurs.", type=str, action="store", required=True)
			#Creating the args object
			args=parser.parse_args()

			return args
			</source>

Justine : /* Exécuter des commandes systèmes sous Python */

2020-01-10T12:25:41Z

Exécuter des commandes systèmes sous Python

← Version précédente		Version du 10 janvier 2020 à 12:25
Ligne 253 :		Ligne 253 :
	<code>#Je vais lire mon pipe, et afficher le résultat, tant qu'à faire...<br/> print(cmd.read())</code>		<code>#Je vais lire mon pipe, et afficher le résultat, tant qu'à faire...<br/> print(cmd.read())</code>
	</div>		</div>
	~~ ~~

	~~ ~~		== La lib subprocess ==
			https://docs.python.org/fr/3/library/subprocess.html

			Subprocess permet de faire beaucooup de choses et est simple à utiliser:
			<source lang="python">
			resultat_commande = subprocess.run(["ls", "-l"])
			</source>
			La variable resultat_commande contiendra alors la sortie de la commande.

Justine le 29 août 2019 à 08:47

2019-08-29T08:47:21Z

← Version précédente		Version du 29 août 2019 à 08:47
Ligne 14 :		Ligne 14 :
	Ici, on écrit dans la sortie standard, et ça affiche aussi le nombre de caractères.		Ici, on écrit dans la sortie standard, et ça affiche aussi le nombre de caractères.

			==Lire depuis le pipe==
			Le moyen le plus simple de lire du texte depuis le pipe est le suivant :

			<nowiki>
			content = sys.stdin.read()
			content = str(content)
			</nowiki>

	= Modifier les flux standards =		= Modifier les flux standards =

Justine le 22 décembre 2018 à 01:42

2018-12-22T01:42:30Z

← Version précédente		Version du 22 décembre 2018 à 01:42
Ligne 13 :		Ligne 13 :

	Ici, on écrit dans la sortie standard, et ça affiche aussi le nombre de caractères.		Ici, on écrit dans la sortie standard, et ça affiche aussi le nombre de caractères.


	= Modifier les flux standards =		= Modifier les flux standards =
Ligne 26 :		Ligne 27 :
	>>>		>>>

	Ici, rien ne s'affiche; cependant, "Quelque chose..." est bien écrit dans le fichier sortie.txt, qui doit se trouver dans le répertoire courant de Python. On peut accéder à ce répertoire à l'aide de la commande :		Ici, rien ne s'affiche; cependant, "Quelque chose..." est bien écrit dans le fichier sortie.txt, qui doit se trouver dans le répertoire courant de Python (et sans le nmbre de caractères à la fin, puisqu'on a utilisé print!). On peut accéder à ce répertoire à l'aide de la commande :

	import os<br/> sys.stdout = sys.__stdout__ #Sans ça, on affiche rien : la sortie va dans un fichier<br/> os.getcwd()		import os<br/> sys.stdout = sys.__stdout__ #Sans ça, on affiche rien : la sortie va dans un fichier<br/> os.getcwd()

Justine le 22 décembre 2018 à 01:35

2018-12-22T01:35:22Z

← Version précédente		Version du 22 décembre 2018 à 01:35
Ligne 217 :		Ligne 217 :

	Nous allons ici voir deux façons de le faire, qui ont le bon goût de marcher sous Windows.		Nous allons ici voir deux façons de le faire, qui ont le bon goût de marcher sous Windows.


	== La fonction os.system ==		== La fonction os.system ==

	Cette fonction du module os prend en paramètre une commande à exécuter, affiche le résultat et renvoie le code de retour; on peut récupérer le code de retour mais pas l'affichage de la commande (qui s'affiche dans le terminal). De plus, cette commande utilise un environnement particulier rien que pour la commande; du coup un os.system("sleep 5") n'arrêtera pas le programme 5 secondes.		Cette fonction du module os prend en paramètre une commande à exécuter, affiche le résultat et renvoie le code de retour; on peut récupérer le code de retour mais pas l'affichage de la commande (qui s'affiche dans le terminal). De plus, cette commande utilise un environnement particulier rien que pour la commande; du coup un os.system("sleep 5") n'arrêtera pas le programme 5 secondes.
	<div style="background:#eeeeee; border:1px solid #cccccc; padding:5px 10px">		<div style="background:#eeeeee; border:1px solid #cccccc; padding:5px 10px"><pre>import os
	import os

	cmd = "date"		cmd = "date"

	#Utiliser simplement la commande pour afficher la date~~<br/>~~ os.system(cmd)		#Utiliser simplement la commande pour afficher la date
			os.system(cmd)

	#Récupérer la valeur retournée, ce qui exécute aussi la commande en même temps~~<br/>~~ valeurRetournee = os.system(cmd)~~<br/>~~ print("La commande a renvoyé~~ ~~:", valeurRetournee)		#Récupérer la valeur retournée, ce qui exécute aussi la commande en même temps
			valeurRetournee = os.system(cmd)
			print("La commande a renvoyé :", valeurRetournee)</pre>
	</div>		</div>




	== La fonction os.popen ==		== La fonction os.popen ==

Justine le 22 décembre 2018 à 01:34

2018-12-22T01:34:57Z

← Version précédente		Version du 22 décembre 2018 à 01:34
Ligne 231 :		Ligne 231 :
	</div>		</div>




Ligne 237 :		Ligne 238 :
	Cette fonction prend aussi une commande en paramètre; cependant au lieu de renvoyer le code retour, elle renvoie un objet appellé un pipe (rien à voir avec \| ), qui permet de lire ce que la commande renvoie (le texte qu'elle renvoie). Lire le pipe bloque le script jusqu'à ce que la commande ait fini de s'exécuter. D'ailleurs, le fait de lire le pipe renvoie un string, mais n'affiche rien en soit dans le terminal (il faut utiliser ce string pour l'afficher par exemple).		Cette fonction prend aussi une commande en paramètre; cependant au lieu de renvoyer le code retour, elle renvoie un objet appellé un pipe (rien à voir avec \| ), qui permet de lire ce que la commande renvoie (le texte qu'elle renvoie). Lire le pipe bloque le script jusqu'à ce que la commande ait fini de s'exécuter. D'ailleurs, le fait de lire le pipe renvoie un string, mais n'affiche rien en soit dans le terminal (il faut utiliser ce string pour l'afficher par exemple).
	<div style="background:#eeeeee; border:1px solid #cccccc; padding:5px 10px">		<div style="background:#eeeeee; border:1px solid #cccccc; padding:5px 10px">
	import os		<code>import os</code>

	cmd = os.popen("ls")<br/> #cmd contient mon pipe		<code>cmd = os.popen("ls")<br/> #cmd contient mon pipe</code>

	###Je vais lire mon pipe, et afficher le résultat, tant qu'à faire...<br/> print(cmd.read())		<code>#Je vais lire mon pipe, et afficher le résultat, tant qu'à faire...<br/> print(cmd.read())</code>
	</div>		</div>

Justine le 22 décembre 2018 à 01:34

2018-12-22T01:34:20Z

← Version précédente		Version du 22 décembre 2018 à 01:34
Ligne 231 :		Ligne 231 :
	</div>		</div>



	== La fonction os.popen ==		== La fonction os.popen ==
Ligne 240 :		Ligne 241 :
	cmd = os.popen("ls")<br/> #cmd contient mon pipe		cmd = os.popen("ls")<br/> #cmd contient mon pipe

	#Je vais lire mon pipe, et afficher le résultat, tant qu'à faire...<br/> print(cmd.read())		###Je vais lire mon pipe, et afficher le résultat, tant qu'à faire...<br/> print(cmd.read())
	</div>		</div>

Justine : Page créée avec « L'ensemble de ces notes est issu de : [https://openclassrooms.com/fr/courses/235344-apprenez-a-programmer-en-python/234239-un-peu-de-programmation-systeme https://op... »

2018-12-22T01:33:45Z

Page créée avec « L'ensemble de ces notes est issu de : [https://openclassrooms.com/fr/courses/235344-apprenez-a-programmer-en-python/234239-un-peu-de-programmation-systeme https://op... »

Nouvelle page

L'ensemble de ces notes est issu de : [https://openclassrooms.com/fr/courses/235344-apprenez-a-programmer-en-python/234239-un-peu-de-programmation-systeme https://openclassrooms.com/fr/courses/235344-apprenez-a-programmer-en-python/234239-un-peu-de-programmation-systeme]  

= Accéder aux flux standards (stin, stdout, stderr) =

L'entrée standard est utilisée par input, la sortie standard est utilisée pour les exceptions (entre autres). En python, les flux standard sont utilisés avec la bibliothèque "sys"; et comme pour utiliser des fichiers, on utilise les méthodes "read" et "write". stdin peut lire et les deux autres écrire.

>>> sys.stdout.write("un test")

un test7

>>>

Ici, on écrit dans la sortie standard, et ça affiche aussi le nombre de caractères.

= Modifier les flux standards =

On peut modifier sys.stdin, sys.stdout, et sys.stderr :

>>> fichier = open('sortie.txt', 'w')

>>> sys.stdout = fichier

>>> print("Quelque chose...")

>>>

Ici, rien ne s'affiche; cependant, "Quelque chose..." est bien écrit dans le fichier sortie.txt, qui doit se trouver dans le répertoire courant de Python. On peut accéder à ce répertoire à l'aide de la commande :

import os<br/> sys.stdout = sys.__stdout__ #Sans ça, on affiche rien : la sortie va dans un fichier<br/> os.getcwd()

Si on a modifié les flux standards, on peut toujours les retrouver dans sys.__stdin__, sys.__stdout__, sys.__stderr__. La documentation conseille quand même de les garder sous la main plutôt que d'aller les chercher dans sys.

= Les signaux =

Les signaux sont utilisés par le système pour communiquer avec les programmes, par exemple pour les arrêter. On peut capturer ces signaux dans notre programme : cela peut par exemple permettre de faire certaines actions si le programme doit se fermer (enregistrer des objets dans un fichier, fermer des connexions réseau...). Les signaux permettent aussi aux programmes de communiquer entre eux, mais on ne verra pas ça ici (dommage...).

== Les différents signaux ==

Tous les signaux en sont pas communs à tous les OS, alors on va ici surtout s'attacher à SIGINT, envoyé pour fermer un programme.

Pour plus de précisions : [https://docs.python.org/3/library/signal.html https://docs.python.org/3/library/signal.html]

== Intercepter un signal ==

On commence par importer le module signal :

import signal

Je peux ensuite voir mon signal avec signal.SIGINT, par exemple. Pour intercepter un signal, il faut créer une fonction qui sera appellée si le signal est envoyé. ELle prend deux paramètres :

*Le signal (on peut envoyer plusieurs signaux à une même fonction)
*le frame, dont on ne parlera pas ici.

Il faut donc créer la fonction et la connecter avec le signal SIGINT :
<div style="background:#eeeeee; border:1px solid #cccccc; padding:5px 10px">import sys
def fermerProgramme(signal, frame):

    """Fonction appelée quand vient l'heure de fermer notre programme"""<br/>     print("C'est l'heure de la fermeture !")<br/>     sys.exit(0) 
</div>
Ici, le code de retour 0 signifie "Pas d'erreur"; n'importe quel autre entier signifierait une erreur. Le sys.exit sert juste à fermer le programme.

Ensuite, il faudra connecter le signal à cette fonction : on utilise pour ça la fonction signal du module signal. Elle prend en paramètres :

*Le signal à intercpter
*La fonction que l'on doit y connecter

Ce qui donne :

signal.signal(signal.SIGINT, fermer_programme)

On ne met pas les parenthèses après fermer_programme, puisqu'on l'utilise en tant qu'objet, mais on ne l'exécute pas.

== Un code complet d'exemple ==
<div style="background:#eeeeee; border:1px solid #cccccc; padding:5px 10px">
import signal   #J'importe mes modules

import sys

<br/> def fermer_programme(signal, frame):      #Ma fonction qui sera appellée lors du signal; elle contient bien ses deux objets

    """Fonction appelée quand vient l'heure de fermer notre programme"""

    print("C'est l'heure de la fermeture !")

    sys.exit(0)

<br/> # Connexion du signal à notre fonction

signal.signal(signal.SIGINT, fermer_programme)

<br/> # Notre programme...

print("Le programme va boucler...")

while True:

    continue
</div>
Si je lance ce script, ma boucle va tourner à l'infini, jusqu'à ce que j'interrompe le script, auquel cas la fonction fermer_programme s'exécutera.

= Les arguments =

Les arguments passés dans la ligne de commande peuvent être obtenus grâce au module sys; notamment sa variable argv. sys.argv contient une liste des arguments que l'on passe à la ligne de commande, en lancant le programme. sys.argv contient une liste contenant chacun des arguments, le premier étant toujours le nom du programme lui-même.

== Exemple : ==

Le code suivant :
<div style="background:#eeeeee; border:1px solid #cccccc; padding:5px 10px">
import sys

print(sys.argv)
</div>
Donne ceci une fois lancé :
<div style="background:#eeeeee; border:1px solid #cccccc; padding:5px 10px">justine@Justine-pc:~/PycharmProjects/Testsvariés$ python3 signaux.py argument1 argument2 "Une phrase entre guillemets"<br/> ['signaux.py', 'argument1', 'argument2', 'Une phrase entre guillemets']</div>
On voit ici que les arguments sont renvoyés sous la forme d'une liste de strings, un argument entre guillemets pouvant contenir des espaces.

== Récupérer et utiliser des arguments ==

Tout ça c'est bien, mais on doit pouvoir utiliser nos arguments : un start, un stop, un restart... Un cas de figure simple donnerait ceci :
<div style="background:#eeeeee; border:1px solid #cccccc; padding:5px 10px">
import sys

<br/> if len(sys.argv) < 2:

    print("Précisez une action en paramètre")

    sys.exit(1)

<br/> action = sys.argv[1]

<br/> if action == "start":

    print("On démarre l'opération")

elif action == "stop":

    print("On arrête l'opération")

elif action == "restart":

    print("On redémarre l'opération")

elif action == "status":

    print("On affiche l'état (démarré ou arrêté ?) de l'opération")

else:

    print("Je ne connais pas cette action")
</div>
Mais on peut faire des choses plus complexes, comme utiliser des arguments courts ( -a) ou longs (--argument). Un argument court est souvent relié à un argument long.

== argparse ==

On va utiliser le module argparse, utile pour interpréter les arguments selon un certain schéma.Sa base est la suivante :
<div style="background:#eeeeee; border:1px solid #cccccc; padding:5px 10px">
import argparse                                   #On importe le module

parser = argparse.ArgumentParser()     #On crée cet objet qui servira à configurer nos options à interpréter

parser.parse_args()                              #On appelle cette méthode, qui servira à retourner les arguments interprétés
</div>
 Nous allons voir comment préciser des options à parser, pour que ce soit plus intéressant. À noter, par défaut parser.parse_args() commence à partir de sys.argv[1], c'est-à-dire qu'il ne prend pas en compte le tout premier argument contenant le nom du script. D'ailleurs, notre parser n'est par défaut pas tout à fait vide, il contient un argument -h qui renvoie une aide. En exécutant le code montré juste avant avec -h, on a :

>python code.py --help<br/> usage: code.py [-h]

optional arguments:<br/>   -h, --help  show this help message and exit

Si j'utilise un argument qu'on a pas déclaré auparavant, il renvoie une erreur. Pour déclarer des arguments :
<div style="background:#eeeeee; border:1px solid #cccccc; padding:5px 10px">
import argparse

parser = argparse.ArgumentParser()<br/> parser.add_argument("x", help="le nombre a mettre au carré")<br/> parser.parse_args()
</div>
La méthode add_argument prend ici deux arguments (même si elle en plein d'autres en option) : l'option et le message d'aide qui y est relié.  Je peux voir ce message d'aide :
<div style="background:#eeeeee; border:1px solid #cccccc; padding:5px 10px">
>python code.py --help<br/> usage: code.py [-h] x

positional arguments:<br/>   x           le nombre à mettre au carré

optional arguments:<br/>   -h, --help  show this help message and exit
</div>
 J'ai désormais une optioni x, je peux alors y mettre un nombre en appelant mon script et le récupérer pour en faire quelque chose :
<div style="background:#eeeeee; border:1px solid #cccccc; padding:5px 10px">import argparse<br/> <br/> parser = argparse.ArgumentParser()<br/> parser.add_argument("x", type=int, help="le nombre a mettre au carré")<br/> args = parser.parse_args()<br/> <br/> print("Vous avez donné en argument", args.x)<br/> <br/> x = args.x<br/> retour = x ** 2<br/> print(retour)</div>
 Ici, on récupère que des nombres. J'ai ajouté un type=int, pour que l'utilisateur ne puisse rentrer que des nombres. Ce code fait finalement quelque chose de concret, à savoir : mettre un nombre au carré.

=== Utiliser des options facultatives ===

Jusque ici, on a utilisé des "positionnal arguments", qui sont précisés sans option. Cependant on peut aussi utiliser des options facultatives, du type --verbose ou -v :
<div style="background:#eeeeee; border:1px solid #cccccc; padding:5px 10px">
import argparse

parser = argparse.ArgumentParser()      #Je crée mon objet parser<br/> parser.add_argument("x", type=int, help="le nombre à mettre au carré")    #Je lui ajoute un argument positionnel<br/> parser.add_argument("-v", "--verbose", action="store_true", help="augmente la verbosité") #Je lui ajoute une option<br/> args = parser.parse_args()     #Je parse les arguments

x = args.x      #Je récupère mon argument positionnel<br/> retour = x ** 2

if args.verbose:     #J'utilise mon option

    print("{} ^ 2 = {}".format(x, retour))

else:

    print(retour)
</div>
Plusieurs choses ici :

*On a rajouté -v ou --verbose. Quand un nom commence par un tiret, argparse suppose que celui-ci est un argument facultatif (même si cette attitude d'argparse peut être modifiée).
*On a utilisé l'argument action, avec store_true :
**store_true permet de convertir l'option en booléen
**Si l'argument est précisé, alors args.verbose vaudra True
**Sinon, il vaudra False

Ce n'est qu'un début : sont dispos un tutoriel sur argparse ([https://docs.python.org/3/howto/argparse.html https://docs.python.org/3/howto/argparse.html]) et la doc ([https://docs.python.org/3/library/argparse.html https://docs.python.org/3/library/argparse.html])

= Exécuter des commandes systèmes sous Python =

Nous allons ici voir deux façons de le faire, qui ont le bon goût de marcher sous Windows.

== La fonction os.system ==

Cette fonction du module os prend en paramètre une commande à exécuter, affiche le résultat et renvoie le code de retour; on peut récupérer le code de retour mais pas l'affichage de la commande (qui s'affiche dans le terminal). De plus, cette commande utilise un environnement particulier rien que pour la commande; du coup un os.system("sleep 5") n'arrêtera pas le programme 5 secondes.
<div style="background:#eeeeee; border:1px solid #cccccc; padding:5px 10px">
import os

cmd = "date"

#Utiliser simplement la commande pour afficher la date<br/> os.system(cmd)

#Récupérer la valeur retournée, ce qui exécute aussi la commande en même temps<br/> valeurRetournee = os.system(cmd)<br/> print("La commande a renvoyé :", valeurRetournee)
</div>
 

== La fonction os.popen ==

Cette fonction prend aussi une commande en paramètre; cependant au lieu de renvoyer le code retour, elle renvoie un objet appellé un pipe (rien à voir avec | ), qui permet de lire ce que la commande renvoie (le texte qu'elle renvoie). Lire le pipe bloque le script jusqu'à ce que la commande ait fini de s'exécuter. D'ailleurs, le fait de lire le pipe renvoie un string, mais n'affiche rien en soit dans le terminal (il faut utiliser ce string pour l'afficher par exemple).
<div style="background:#eeeeee; border:1px solid #cccccc; padding:5px 10px">
import os

cmd = os.popen("ls")<br/> #cmd contient mon pipe

#Je vais lire mon pipe, et afficher le résultat, tant qu'à faire...<br/> print(cmd.read())
</div>
 

 

Python : Programmation système - Historique des versions

Justine le 22 juin 2022 à 12:07

Justine le 26 novembre 2021 à 17:08

Justine le 25 novembre 2021 à 21:48

Justine : /* Exécuter des commandes systèmes sous Python */

Justine le 29 août 2019 à 08:47

Justine le 22 décembre 2018 à 01:42

Justine le 22 décembre 2018 à 01:35

Justine le 22 décembre 2018 à 01:34

Justine le 22 décembre 2018 à 01:34

Justine : Page créée avec « L'ensemble de ces notes est issu de : [https://openclassrooms.com/fr/courses/235344-apprenez-a-programmer-en-python/234239-un-peu-de-programmation-systeme https://op... »

Justine : /* Exécuter des commandes systèmes sous Python */

Justine : Page créée avec « L'ensemble de ces notes est issu de : [https://openclassrooms.com/fr/courses/235344-apprenez-a-programmer-en-python/234239-un-peu-de-programmation-systeme https://op... »