incodewetrust.ias.u-psud.fr

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
{{tag>[Python Python3 Bash asr]}}

====== Utiliser Python3 en Admin Systèmes et Réseaux ======

Note : les exemples sont testés avec le programme //iptyhon3// (Python 3.6.3, IPython 5.1.0)
===== En-tête de fichier =====

Spécifie l'environnement ainsi que l'encodage utiliusé (utf-8) :

<code>
#!/usr/bin/env python3
# -*- coding: utf8 -*-
</code>

===== Documentation =====

Grace aux docstrings, il est très facile (et recommandé!) de documenter son code :

<code>
def server():
    """Définit les caractéristiques du serveur"""
</code>

L'accès à la documentation peut se faire de 2 manières, soit par la fonction help() :

<code>
help(server)
</code>

soit avec l'attribut //__doc__//
<code>
server.__doc__
</code>

===== Bash vs Python3 =====

Les exemples de cette section n'ont pas grand sens en soi, ils servent juste ici à illustrer la différence entre l'écriture de routines en bash et en Python. Ces bases serviront pour les sections suivantes.

==== Boucles ====

On veut lister les 10 premiers numéros de pid avec des retours chariots (pour manipuler de vrais pid, voir l'exemple plus loin après la présentation du module subprocess)

^Bash  ^Python|
| <code>
pid_list="echo {1..10}"
for pid in `eval $pid_list`
do
    echo "$pid"
done
</code>       | <code>
pid_list = range(1,11)
for pid in pid_list:
    print(pid)
</code>       |

==== Tests ====

On teste si l'utilsateur est root :

^Bash^Python<sup>Note</sup>    |
| <code>
if [ `id -u` = 0 ]
then
    echo "Attention vous êtes root!"
fi
</code>       | <code>
import os
current_user = os.popen('id -u').readlines()
current_user = _
if (current_user == 0):
    print("Attention vous êtes root!")
</code>       |

<sup>Note</sup>  : on verra par la suite qu'on peut avantageusement remplacer le module os par subprocess…
==== Fonctions ====

^Bash^Python (avec une f-strings s'il vous plait!)<sup>Note</sup>    |
| <code>
function processus() {
    echo "Il s'agit du process $1"
}
</code>       | <code>
def processus(pid):
    print(f"Il s'agit du process {pid}")
</code>       |

<sup>Note</sup>  : Python peut également prendre en paramètres un nombre arbitraire d'arguments, soit sous forme de tuple
<code>
def processus(*args)
</code>

ou de dictionnaire

<code>
def processus(**kwargs)
</code>

===== Module os =====

ce module contient plusieurs objets permettant d'intéragir avec le système

===== Modules utiles (depuis des librairies standards) =====

==== subprocess ====

Ce module est destiné à remplacer progressivement les modules et fonctions suivants considérés comme devenant obsolètes :

<code>
os.system
os.spawn*
</code>

Utilisation avec la classe <font inherit/Courier New,Courier,monospace;;inherit;;inherit>Popen</font> :

''subprocess.''''Popen'' ( //args//, //bufsize=-1//, //executable=None//, //stdin=None//, //stdout=None//, //stderr=None//, //preexec_fn=None//, //close_fds=True//, //shell=False//, //cwd=None//, //env=None//, //universal_newlines=False//, //startupinfo=None//, //creationflags=0//, //restore_signals=True//, //start_new_session=False//, //pass_fds=()//, //*//, //encoding=None//, //errors=None// )

Par exemple, pour faire l'équivalent de 2 commandes chainées avec un pipe (<font inherit/Courier New,Courier,monospace;;inherit;;inherit>|</font>)

En bash :

<code>
$ cat /var/log/syslog |grep -i failed
</code>

En Python avec le module subprocess :

<code>
In [1]: import subprocess

In [2]: p1 = subprocess.Popen(["cat","/var/log/syslog"],stdout=subprocess.PIPE)

In [3]: p2 = subprocess.Popen(["grep","-i","failed"],stdin=p1.stdout, stdout=subprocess.PIPE)

In [4]: p2.communicate()
</code>

Le résultat en sortie est un tuple. 2 remarques :

  * L'objet tuple est immuable. On pourra donc juste lire les éléments du tuple mais pas les modifier, ni ajouter des éléments,…si besoin, on pourra convertir le tuple par exemple en liste ou en chaine de caractères avec respectivement les fonctions list() et str().
  * Une fois que l'appel de la fonction communicate() a généré la sortie, le processus est terminé. Ce qui veut dire que le résultat n'est généré qu'une fois en mémoire. Si je fais print(p2.communicate()), la première fois le résultat sera affiché mais si je le rapelle je tombe sur une exception de type <font inherit/Courier New,Courier,monospace;;inherit;;inherit>ValueError: read of closed file</font>

Si on veut garder la sortie, on peut sauvegarder le résultat dans un variable. Exemple :

<code>
In [7]: failed_syslog = p2.communicate()
</code>

Et pour le lire différemment que sous la forme d'un tuple, on peut par exemple faire :

<code>
In [8]: failed_syslog_format = str(failed_syslog)

In [9]: failed_syslog_format.split('n')
</code>

A partir de la version 3.5 de Python, la fonction **run()**  a été rajoutée : cette fonction lance la commande décrite par //args//, attend que la commande se termine et renvoie une instance <font inherit/Courier New,Courier,monospace;;inherit;;inherit>CompletedProcess</font>

''subprocess.''''run''  ( //args//, //*//, //stdin=None//, //input=None//, //stdout=None//, //stderr=None//, //shell=False//, //cwd=None//, //timeout=None//, //check=False//, //encoding=None//, //errors=None//  )

Note : les 2 derniers paramètres //encoding //et //errors //n'existent qu'à partir de la version 3.6

<font inherit/Arial,Helvetica,sans-serif;;inherit;;inherit>Exemple pour lister le contenu de /home :</font>

<code>
In [10]: subprocess.run(["ls","-la","/home"])
total 12
drwxr-xr-x  3 root root 4096 nov.  13 10:25 .
drwxr-xr-x 25 root root 4096 janv.  4 10:53 ..
drwxr-xr-x 26 rvb  rvb  4096 janv.  3 16:35 rvb
Out [10]: CompletedProcess(args=['ls', '-la', '/home'], returncode=0)
</code>

Voir la [[https://pymotw.com/3/subprocess/index.html|page dédiée à ce module]] sur le site Python 3 Module of the Week

==== Shlex ====

Le module shlex est un analyseur lexical qui permet d'utiliser une syntaxe ressemblant à ce qu'on peut faire en shell. Le module shlex définit 2 fonctions split() et quote() et une sous-classe shlex qui contient plusieurs méthodes.

Par exemple, j'ai une adresse IP et je souhaite afficher les nombres qui la composent avec des retours chariots.

En bash (il y a peut être plus simple…)

<code>
$ ip="192.168.56.1"
$ IFS=. read -a ip <<<"$ip"
$ printf '%sn' "${ip[@]}"
</code>

Note : sur la dernière ligne, il faut ajouter un //backslash//  entre <font inherit/Courier New,Courier,monospace;;inherit;;inherit>%s</font> et <font inherit/Courier New,Courier,monospace;;inherit;;inherit>n</font> (mais ne s'affiche pas dans Dokuwiki !)

Un exemple d'équivalent avec le module shlex pourrait être :

<code>
ip = "192.168.56.1"

nb = shlex.shlex(ip, punctuation_chars=".", posix=True)

nb.whitespace += '.'

for nombre in nb:
    print(nombre)
</code>

Voir la [[https://pymotw.com/3/shlex/index.html|page dédiée à ce module]] sur le site Python 3 Module of the Week

\\
incodewetrust.ias.u-psud.fr

Outils pour utilisateurs

Outils du site

Outils de la page
