Une introduction à Python 3

Le module principal est celui qui est donné en argument sur la ligne de commande ou qui est lancé en premier lors de l'exécution d'un script. Son nom est contenu dans la variable globale __name__. Sa valeur dépend du contexte de l'exécution.

Soit le module :

# je_me_nomme.py
print("Je me nomme :", __name__)

Premier contexte exécution sur la ligne de commande (ou dans un EDI), on obtient la valeur de la variable prédéfinie __main__ :

$ python3 je_me_nomme.py
Je me nomme : __main__

Second contexte import de ce module (ce n'est donc plus le module principal), on obtient l'identificateur du module :

>>> import je_me_nomme
Je me nomme : je_me_nomme

Grâce à un test, on peut donc facilement savoir si le code est exécuté en tant que script principal :

• on écrit un script de fonctions ou de classes (souvent appelé bibliothèque) et on termine le fichier par un test, l'« autotest », pour vérifier que l'on est dans le module principal. On en profite pour vérifier tous les éléments de la bibliothèque ;
• quand on importe le script, le test inclus est faux et on se borne à utiliser la bibliothèque.

def cube(x) :
    """retourne le cube de <x>."""
    return x**3

# autotest ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if __name__ == "__main__" : # vrai car module principal
    if cube(9) == 729:
        print("OK !")
    else :
        print("KO !")

Utilisation de ce module dans un autre (par exemple celui qui contient le programme principal) :

import cube

# programme principal ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
for i in range(1, 4) :
    print("cube de", i, "=", cube_m.cube(i))

"""
cube de 1 = 1
cube de 2 = 8
cube de 3 = 27
"""

Autre exemple :

def ok(message) :
    """
    Retourne True si on saisit <Entrée>, <O>, <o>, <Y> ou <y>,
    False dans tous les autres cas.
    """
    s = input(message + " (O/n) ?")
    return True if s == "" or s[0] in "OoYy" else False

# autotest ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if __name__ == '__main__' :
    while True :
        if ok("Encore") :
            print("Je continue")
        else :
            print("Je m'arrête")
            break

"""
Encore (O/n) ?
Je continue
Encore (O/n) ? o
Je continue
Encore (O/n) ? n
Je m'arrête
"""

D'après ses concepteurs, les objectifs d'IPython sont les suivants :

• fournir un interpréteur Python plus puissant que celui par défaut. IPython propose de nombreuses caractéristiques comme l'introspection d'objet, l'accès au shell système ainsi que ses propres commandes permettant une grande interaction avec l'utilisateur ;
• proposer un interpréteur embarquable et prêt à l'emploi pour vos programmes Python. IPython s'efforce d'être un environnement efficace à la fois pour le développement de code Python et pour la résolution des problèmes liés à l'utilisation d'objets Python ;
• offrir un ensemble de bibliothèques pouvant être utilisé comme environnement pour d'autres systèmes utilisant Python comme langage sous-jacent (particulièrement pour les environnements scientifiques comme MATLAB, Maple ou Mathematica) ;
• permettre le test interactif des bibliothèques graphiques gérées comme Tkinter, wxPython, PyGTK alors que IDLE ne le permet qu'avec des applications Tkinter.

• IPython est autodocumenté.
• Coloration syntaxique.
• Les docstrings des objets Python sont disponibles en accolant un « ? » au nom de l'objet ou « ?? » pour une aide plus détaillée.
• Numérote les entrées et les sorties.
• Organise les sorties : messages d'erreur ou retour à la ligne entre chaque élément d'une liste si on l'affiche.

• Autocomplétion avec la touche  : L'autocomplétion trouve les variables qui ont été déclarées.

  • Elle trouve les mots clés et les fonctions locales.
  • La complétion des méthodes sur les variables tient compte du type actuel de cette dernière.
  • Par contre la complétion ne tient pas compte du contexte.

• Historique persistant (même si on quitte l'interpréteur, on peut retrouver les dernières commandes par l'historique).

  • Recherche dans l'historique avec les flèches du clavier.
  • Isole dans l'historique les entrées multilignes.
  • On peut appeler les entrées et sorties précédentes.
• Contient des raccourcis et des alias. On peut en afficher la liste en tapant la commande lsmagic.
• Permet d'exécuter des commandes système en les préfixant par un point d'exclamation. Par exemple !ls sous Linux ou OSX, ou !dir sous une fenêtre de commande Windows.

Le module numpy est la boîte à outils indispensable pour faire du calcul scientifique avec Python(18).

Pour modéliser les vecteurs, matrices et, plus généralement, les tableaux à n dimensions, numpy fournit le type ndarray.

On note des différences majeures avec les listes (resp. les listes de listes) qui pourraient elles aussi nous servir à représenter des vecteurs (resp. des matrices) :

• les tableaux numpy sont homogènes, c'est-à-dire constitués d'éléments du même type.
  On trouvera donc des tableaux d'entiers, des tableaux de flottants, des tableaux de chaînes de caractères, etc. ;
• la taille des tableaux numpy est fixée à la création. On ne peut donc augmenter ou diminuer la taille d'un tableau comme on le ferrait pour une liste (à moins de créer un tout nouveau tableau, bien sûr).

Ces contraintes sont en fait des avantages :

• le format d'un tableau numpy et la taille des objets qui le composent étant fixés, l'empreinte du tableau en mémoire est invariable et l'accès à ses éléments se fait en temps constant ;
• les opérations sur les tableaux sont optimisées en fonction du type des éléments, et sont beaucoup plus rapides qu'elles ne le seraient sur des listes équivalentes.

Dans ce premier exemple, on définit un tableau a d'entiers puis on le multiplie globalement, c'est-à-dire sans utiliser de boucle, par le scalaire 2.5. On définit de même le tableau d qui est affecté en une seule instruction à a + b.

In [1]: import numpy as np

In [2]: a = np.array([1, 2, 3, 4])

In [3]: a # a est un tableau d'entiers
Out[3]: array([1, 2, 3, 4])

In [4]: b = a * 2.5

In [5]: b # b est bien devenu un tableau de flottants
Out[5]: array([ 2.5, 5. , 7.5, 10. ])

In [6]: c = np.array([5, 6, 7, 8])

In [7]: d = b + c

In [8]: d # transtypage en flottants
Out[8]: array([ 7.5, 11. , 14.5, 18. ])

L'exemple suivant définit un tableau positions de 10 000 000 lignes et 2 colonnes, formant des positions aléatoires. Les vecteurs colonnes x et y sont extraits du tableau position. On affiche le tableau et le vecteur x avec 3 chiffres après le point décimal. On calcule (bien sûr globalement) le vecteur des distances euclidiennes à un point particulier kitxmlcodeinlinelatexdvp\left ( x_{0}, y_{0}\right )finkitxmlcodeinlinelatexdvp et on affiche l'indice du tableau de la distance minimale à ce point.

In [1]: import numpy as np

In [2]: positions = np.random.rand(10000000, 2)

In [3]: x, y = positions[:, 0], positions[:, 1]

In [4]: %precision 3
Out[4]: '%.3f'

In [5]: positions
Out[5]:

array([[ 0.861, 0.373],
       [ 0.627, 0.935],
       [ 0.224, 0.058],
       ...,
       [ 0.628, 0.66 ],
       [ 0.546, 0.416],
       [ 0.396, 0.625]])

In [6]: x
Out[6]: array([ 0.861, 0.627, 0.224, ..., 0.628, 0.546, 0.396])

In [7]: x0, y0 = 0.5, 0.5

In [8]: distances = (x - x0)**2 + (y - y0)**2

In [9]: distances.argmin()
Out[9]: 4006531

Ce type de traitement très efficace et élégant est typique des logiciels analogues comme MATLAB.

SymPy est une bibliothèque en pur Python spécialisée dans le calcul formel à l'instar de Maple ou Mathematica(20). Elle permet de faire du calcul arithmétique formel basique, de l'algèbre, des mathématiques différentielles, de la physique, de la mécanique…

Il est facile de se familiariser avec SymPy en l'expérimentant directement sur Internet(21).

Si l'interpréteur IPython est déjà installé, une alternative intéressante est fournie par le script isympy. Voici quelques exemples des très nombreuses possibilités offertes par cette bibliothèque :

In [1]: P = (x-1) * (x-2) * (x-3)

In [2]: P.expand()
Out[2]:
 3     2
x - 6?x + 11?x - 6

In [3]: P.factor()
Out[3]: (x - 3)?(x - 2)?(x - 1)

In [4]: roots = solve(P, x)

In [5]: roots
Out[5]: [1, 2, 3]

In [6]: sin(pi/6)
Out[6]: 1/2

In [7]: cos(pi/6)
Out[7]:
   ___
?? 3
?????
  2

In [8]: tan(pi/6)
Out[8]:
   ___
?? 3
?????
  3

In [9]: e = 2*sin(x)**2 + 2*cos(x)**2

In [10]: trigsimp(e)
Out[10]: 2

In [11]: z = 4 + 3*I

In [12]: Abs(z)
Out[12]: 5

In [13]: arg(z)
Out[13]: atan(3/4)

In [14]: f = x**2 * sin(x)

In [15]: diff(f, x)
Out[15]:
 2
x ?cos(x) + 2?x?sin(x)