Syntaxe du langage Python

Import des bibliothèques

Afin d’utiliser les bibliothèques mathématiques de python, il est nécessaire de les importer (de manière équivalente à la primitive include en langage C). La manière recommandée d’importer une bibliothèque comm0e numpy est la suivante :

import numpy as np;

Ici, np est un alias pour le nom de la bibliothèque numpy. Après l’avoir importée, il devient possible d’accéder aux fonctions définies à l’intérieur de cette bibliothèque en les préfixant par le nom de la bibliothèque ou de son alias :

np.sqrt(5);
>>  2.2360679774997898

Écriture de fonctions

Pour définir une fonction en python, il faut utiliser le mot-clé def de la manière suivante :

def func(x,y):
	""" Example of function adding x and y"""
	return(x+y)

Quelques remarques :

En python, il n’y a pas de délimiteurs comme en langage C. Le corps de la fonction est donc délimité par le mot-clé def au début et la dernière ligne de code à la fin.
Les indentations du code par des tabulations (le caractère « ________« ) sont obligatoires pour que le code soit accepté par l’interpréteur.
La deuxième ligne correspond à la documentation de la fonction, et apparaîtra lors de l’appel à la commande help(func).

Instructions conditionnelles / Boucles

Les instructions conditionnelles et les boucles ont une syntaxe ressemblant fortement à l’écriture de fonctions. Ici aussi, l’indentation est importante :

if cond:
________instr

if cond_1:
________instr_1
elif cond_2:
________instr_2
else:
________instr_n

for x in array:
________instr

while cond:
________instr

les boucles utilisent des tableaux (arrays), que l’on peut créer avec les commandes range (pour les entiers), array ou arange (cf aide-mémoire).

Structures de données

En python, il existe différentes structures de données permettant de représenter des ensembles de nombres flottants :

les :(1,2,3,4)Ces structures non modifiables sont construites à l’aide de parenthèses \verb'()’ encadrant une liste de nombres séparés par des virgules. Parmi les opérations possibles :

tup = (1,2)
tup[1]                   # -> 2               Access to elements
1 in tup                 # -> True,           Membership test
tup + tup                # -> (1,2,1,2)       Concatenation
for i in (1,2): print i  # -> 1 2             Loops over tuples

les :[1,2,3,4]Ces structures modifiables sont construites à l’aide des crochets \verb'[]’ encadrant une liste de nombres séparés par des virgules. Les opérations possibles sur les tableaux sont les mêmes que sur les tuples, en ajoutant :

arr = [1,2,3,4,5,6,7,8,9,10,11,12]
arr[0] = 7               # -> [7,2,3 ...        Modification of an element
arr.append(42)           # -> ..., 12,42]       Addition of an element
arr[0:6]                 # -> [1,2,3,4,5,6]     Sub-array
arr[0:6:2]               # -> [1,3,5]           Slicing
for i in arr: print i    # -> 1 2 3 ...         Loops over arrays

- les tableaux de la bibliothèque numpy :numpy.array([1,2,3,4])Ils possèdent la plupart du temps les mêmes propriétés que les tableaux python, mais se comportent différemment pour les opérations arithmétiques. Cela les rend pratiques pour la manipulation de vecteurs :
```
nar = numpy.array([1,2,3,4])
arr + arr                # -> [2,4,6,8]         Addition of arrays
arr * arr                # -> [1,4,9,16]        Multiplication of arrays
```

- les matrices définies dans cette même bibliothèque :numpy.matrix([[1, 2], [3, 4]])Ces matrices sont des tableaux particuliers à une ou deux dimensions. La principale différence avec les autres types de tableaux, est que l’opération de multiplication utilise le produit de matrices plutôt que le produit terme à terme.
```
nmat = numpy.matrix( [[1, 1], [0, 1]] )
nmat * nmat     # -> [[1, 2], [0, 1]]           Matrix multiplication
```

Commandes graphiques

Pour afficher des graphiques à l’aide de python, la bibliothèque matplotlib offre un panel de fonctions assez large. Par exemple, pour dessiner la courbe d’une fonction comme la fonction $x\rightarrow\tan(2\pi x)$ :

import matplotlib.pyplot as mp
import numpy as np

t = np.arange(0.0, 2.0, 0.01)
s = np.cos(2*np.pi*t)
mp.plot(t, s, linewidth=1.0)

Cette série d’appels de fonctions ne fait que calculer le graphique. Il reste encore à le sauvegarder dans un fichier :

mp.savefig("figure")

Pour obtenir un graphique plus parlant, il ne faut pas oublier de légender les axes et de lui donner un titre :

mp.xlabel('Abscissa')
mp.ylabel('Ordinate')
mp.legend('Da wave')
mp.title('Surfing on the wave')

Pour des exemples plus complexes, la galerie de matplotlib contient de nombreux graphiques fournis avec leur code.