Note : les exemples sont testés avec le programme iptyhon3 (Python 3.6.3, IPython 5.1.0)

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

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

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

def server():
    """Définit les caractéristiques du serveur"""

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

help(server)

soit avec l'attribut doc

server.__doc__

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.

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)

pid_list="echo {1..10}"
for pid in `eval $pid_list`
do
    echo "$pid"
done

pid_list = range(1,11)
for pid in pid_list:
    print(pid)

On teste si l'utilsateur est root :

if [ `id -u` = 0 ]
then
    echo "Attention vous êtes root!"
fi

import os
current_user = os.popen('id -u').readlines()
current_user = _
if (current_user == 0):
    print("Attention vous êtes root!")

^Note : on verra par la suite qu'on peut avantageusement remplacer le module os par subprocess…

function processus() {
    echo "Il s'agit du process $1"
}

def processus(pid):
    print(f"Il s'agit du process {pid}")

^Note : Python peut également prendre en paramètres un nombre arbitraire d'arguments, soit sous forme de tuple

def processus(*args)

ou de dictionnaire

def processus(**kwargs)

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

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

os.system
os.spawn*

Utilisation avec la classe Popen :

subprocess.Popen ( args, bufsize=-1, executable=None, stdin=None, stdout=None, stderr=None, preexecfn=None, closefds=True, shell=False, cwd=None, env=None, universalnewlines=False, startupinfo=None, creationflags=0, restoresignals=True, startnewsession=False, pass_fds=(), *, encoding=None, errors=None )

Par exemple, pour faire l'équivalent de 2 commandes chainées avec un pipe (|)

En bash :

$ cat /var/log/syslog |grep -i failed

En Python avec le module subprocess :

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

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 ValueError: read of closed file

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

In [7]: failed_syslog = p2.communicate()

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

In [8]: failed_syslog_format = str(failed_syslog)

In [9]: failed_syslog_format.split('n')

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 CompletedProcess

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

Exemple pour lister le contenu de /home :

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)

Voir la page dédiée à ce module sur le site Python 3 Module of the Week

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

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

Note : sur la dernière ligne, il faut ajouter un backslash entre %s et n (mais ne s'affiche pas dans Dokuwiki !)

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

ip = "192.168.56.1"

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

nb.whitespace += '.'

for nombre in nb:
    print(nombre)

Voir la page dédiée à ce module sur le site Python 3 Module of the Week