Python est un langage interprété. Il peut s'utiliser en ligne de commande, l'invite étant représentée par trois chevrons
»> 3+2
5
Le code source peut être mis dans un fichier texte portant l'extension de nom de fichier codice_1. Cela requiert donc un éditeur de texte.
Les fichiers que nous allons créer commenceront tous de la manière suivante :
import numpy as np
import matplotlib.pyplot as plt
La première ligne, appelée "shebang", n'est pas utile avec l'environnement que nous allons utiliser mais il est intéressant de la mettre pour assurer une compatibilité du code avec d'autres environnements. Les lignes commençant par codice_2 permettent d'importer des bibliothèques de fonctions ; nous en ajouterons au gré des besoins.
Nous allons utiliser l'environnement de programmation Jupyter, un environnement libre, gratuit et multiplateforme. Jupyter utilise un navigateur Internet comme éditeur de texte et pour l'affichage des résultats.
Installer Jupyter.
Nous utilisons la distribution Anaconda : https://www.anaconda.com/
Suivez les instructions d'installation selon votre système. Choisissez « Python 3 ».
Bien entendu, vous pouvez aussi utiliser un éditeur de texte classique. Vous pouvez par exemple vous intéresser à l'éditeur Atom, libre et multiplateforme.
Premiers pas.
Lancez le programme codice_3. Cela vous ouvre une fenêtre dans votre navigateur Internet. Dans cette fenêtre, choisissez codice_4 : la page devient un éditeur de texte.
Cette page est organisée en cellules ; une cellule est une zone de texte. Vous pouvez donc avoir plusieurs zones de texte, chacune contenant un élément du programme que vous développez. Dans un premier temps, nous allons travailler avec une seule cellule et l'utiliser comme une ligne de commande.
Dans cette cellule, tapez codice_5 puis cliquez que le bouton d'évaluation codice_6 : cela affiche logiquement le résultat « 5 » en dessous.
Vous pouvez sauvegarder cet embryon de programme avec le menu codice_7 Cela crée un fichier portant l'extension de nom de fichier codice_8.
Jupyter Notebook se présente dans le navigateur Internet "()", mais s'utilise comme un navigateur de fichiers (Windows Explorer, Finder, GNOME Commander, Konqueror…). Si l'on veut définir le répertoire de départ, il faut ouvrir Jupyter Notebook avec une commande dans l'Anaconda Prompt :
Où codice_11 est le chemin d'accès au répertoire voulu. Par exemple, si l'on veut utiliser sous Microsoft Windows le répertoire codice_12, on utilise la commande codice_13.
Commandes élémentaires.
Nous avons de base les opérateurs mathématiques élémentaires :
Exemples : cliquez dans la cellule et ajoutez à la suite
print("6/4 =", 6//4, "reste", 6%4)
print(2**0.5) # racine carrée
codice_6
 6/4 = 1 reste 2
 1.4142135623730951
La division euclidienne peut aussi se faire avec l'instruction codice_22 :
a = divmod(6, 4)
print("6/4 =", a[0], "reste", a[1])
Nous voyons ici que la commande codice_23 affiche des informations à l'écran. Les chaînes de caractères peuvent être encadrées de guillemets simple codice_24 ou doubles codice_25. Le croisillon codice_26 permet de mettre des commentaires.
L'opérateur codice_14 permet de concaténer deux chaînes de caractères.
L'affectation d'une variable se fait avec le signe égal :
a = 5
print(2*a)
codice_6
 10
Trois points pour terminer avec les nombres : le type réel à virgule flottante dispose de la méthode codice_29 qui transforme un nombre en fraction.
a = 1.5
print(a.as_integer_ratio()) # (3, 2) : fraction 3/2
Ensuite, on peut obtenir l'infini +∞ avec codice_30 ou codice_31 :
1/float("inf") # 0.0
On peut également avoir le "" avec codice_32.
Enfin, l'imaginaire formula_1 se note codice_33. De manière générale, on peut écrire codice_34, codice_35… Le type complexe dispose de la méthode codice_36 qui calcule le conjugué.
print(1j**2) # (-1+0j)
a = 2 + 3.5j
print(a.conjugate()) # (2-3.5j)
Les commandes de type codice_37, où "x" est un opérateur (codice_14, codice_15, codice_16 ou codice_17, codice_18, codice_19, codice_20), permet de modifier une variable "()" :
Premier tracé graphique.
Pour effectuer des tracés graphiques, il faut charger la bibliothèque Matplotlib ; nous choisissons l'option codice_53 qui permet d'avoir une syntaxe similaire à Matlab. Pour utiliser cette bibliothèque, il faut écrire codice_54 ; cela donne l'accès à de nouvelles fonctions telles que codice_55.
Comme il est fastidieux d'écrire codice_56 avant chaque commande de cette bibliothèque, nous pouvons utiliser une abréviation, par exemple codice_57, introduite par codice_58 lors de l'importation.
Il nous faut aussi pouvoir travailler facilement avec une liste de nombre. Nous chargeons pour cela la bibliothèque NumPy et nous décidons de l'abréger codice_59.
import numpy as np
import matplotlib.pyplot as plt
x = np.arange(0, 2, 0.1)
y = x**2
plt.plot(x, y, label="y = x^2")
plt.xlabel("x")
plt.ylabel("y")
plt.title("Graphes de fonctions")
plt.legend()
La fonction codice_60 permet de créer un vecteur (liste de valeurs) allant de 0 à 2 avec un pas de 0,1. La fonction codice_61 trace la courbe. Les fonctions codice_62, codice_63 et codice_64 permettent de mettre des titres aux axes et au graphique. La commande codice_65 affiche la légende définie dans la commande codice_61.
Concernant la légende : vous pouvez avoir un rendu de type LaTeX en utilisant les balises codice_67 dans le paramètre codice_68 de codice_61 :
plt.plot(x, y, label="$y = x^2$")
Vous remarquerez que la valeur « 2 » n'est pas sur la figure : en effet, selon la logique du « tranchage » "()", dans l'expression codice_70, le nombre 2 est une extrémité exclue du vecteur. Pour l'intégrer, on peut mettre la première valeur qui ne figure pas, ici codice_71 mais cela pourrait poser des problèmes si l'on changeait le pas. Le module NumPy propose une fonction codice_72 qui indique le réel à virgule flottante le plus proche, on pourrait donc écrire codice_73 (le nombre 3 servant juste à indiquer que l'on veut un nombre supérieur à 2). Mais le plus simple consiste à utiliser la fonction codice_74 :
x = np.linspace(0, 2, 20) # 20 valeurs entre 0 et 2 inclus
Les chaînes de caractères.
Une chaîne de caractères est simplement mise entre des guillemets simples codice_75 "ou" des guillemets doubles codice_76. Si le texte contient une apostrophe, on utilise des guillemets doubles ; dans codice_77, le « codice_24 » est interprété comme un caractère et non comme un délimiteur de chaîne. Et à l'inverse, si on veut utiliser des guillemets doubles dans la chaîne, on la délimite par des guillemets simples : codice_79. On peut aussi utiliser la barre de fraction inversée comme « caractère d'échappement » : codice_80.
Pour éviter d'utiliser les échappements codice_81 ou codice_82, si l'encodage du fichier est en Unicode (typiquement utf-8), il est également possible d'utiliser les caractères typographiques : ’ – « – » – “ – ”. Mais ces caractères ne sont pas disponibles facilement à partir du clavier seul.
Dans une variable, les caractères sont numérotés de 0 à "n" – 1 (si "n" est le nombre de caractères de la chaîne) :
a = "Python"
a[2] # t
Si l'on veut extraire plusieurs caractères, on utilise deux-points, sous la forme codice_83 mais il faut bien comprendre que les numéros correspondent en fait aux interstices entre les caractères. Ainsi, codice_84 va extraire uniquement le premier caractère (celui compris entre les interstices 0 et 1), codice_85 va extraire les deux premiers caractères…
L'indice codice_86 correspond à l'interstice entre le dernier et l'avant-dernier caractère. Pour résumer :
 | P | y | t | h | o | n |
 0 1 2 3 4 5 6
-6 -5 -4 -3 -2 -1
Par exemple
a = "Python"
print(a[0:3]) # Pyt
print(a[3:-1]) # ho
La chaîne intégrale s'obtient avec codice_87 ou codice_88. La chaîne sauf le dernier caractère s'obtient avec codice_89 ; la chaîne du troisième au dernier caractère s'obtient avec codice_90. Le dernier caractère s'obtient avec codice_91 ou bien codice_92.
Cette méthode qui consiste à définir des interstices est appelée « découpage en tranches, tranchage », en anglais ".
Listes et n-uplets.
Une liste est une suite d'éléments numérotés. On peut mélanger des nombres et des chaînes de caractère. Pour déclarer une liste, il suffit d'écrire les éléments entre crochets et séparés des virgules. Pour extraire un élément ou un groupe d'éléments, on utilise également le tranchage.
a = ["a", "b", "c", 1, 2, 3]
print(a[2:4]) # ['c', 1]
On peut aussi remplacer une partie de la liste, par exemple :
a = ["a", "b", "c", 1, 2, 3]
a[3] = "foo"
print(a) # ['a', 'b', 'c', 'foo', 2, 3]
Pour ajouter un élément, on peut utiliser la concaténation
a = a + 4
print(a) # ['a', 'b', 'c', 'foo', 2, 3, 4]
ou bien la « méthode » codice_93 :
a.append(4)
Une méthode est une fonction attachée à un type d'objet ; ici, la fonction codice_93 est attachée aux listes.
Un n-uplet, en anglais ", est similaire à une liste mais on ne peut pas la modifier (ajouter ou changer un élément). L'avantage est qu'elle prend moins de place en mémoire. Elle est définie simplement en séparant les éléments par des virgules. Pour plus de clarté, on peut la mettre entre parenthèses.
b = "a", "b", "c", 1, 2, 3
b = ("a", "b", "c", 1, 2, 3)
Pour faire un n-uplet d'un seul élément, il faut mettre une virgule après l'élément. Pour des raisons de lisibilité, il est conseillé d'utiliser alors des parenthèses.
c = ("un seul élément",)
Notez que la commande codice_95 s'applique à un n-uplet, la présence de parenthèses est donc optionnelle.
print "a =", 4
print("a =", 4)
Les booléens.
Les deux valeurs booléennes sont codice_96 et codice_97. Ce sont notamment les résultats des comparaisons avec codice_98 (égalité), codice_99 (différence), codice_100, codice_101, codice_102 et codice_103. On peut leur appliquer les opérateurs logiques codice_104, codice_105 et codice_106.
a = False
b = 4 <= 5
print(a and b) # False
L'opérateur codice_107 est équivalent à codice_105 ; le tube codice_109 est équivalent à codice_106. Comme pour les opérations arithmétiques, on peut modifier une variable avec codice_111 et codice_112. Par exemple :
print(True & False) # False
print(True - False) # True
a = True
a &= False
print(a) # False
Les ensembles et les dictionnaires.
Un ensemble est une liste mais dont l'ordre n'a pas d'importance. Pour cela, il suffit de mettre les éléments entre accolades codice_113. On peut aussi utiliser l'instruction codice_114.
Les opérations possibles sont :
Un dictionnaire est un ensemble de paires « (mot-clef ; valeur) ». Il s'obtient aussi avec des accolades : codice_120. On peut aussi utiliser la commande codice_121.
print(dico["b"]) # 2
Notez que des accolades vides codice_122 créent le dictionnaire vide.
Les espaces de noms.
De nombreux modules additionnels sont développés pour le langage Python. Lorsque l'on charge un module, pour appeler les fonctions ou classe qu'il apporte, il faut rajouter le nom du module devant le nom de la fonction. Ainsi, si plusieurs modules définissent des fonctions de même nom, il n'y a pas d'ambiguïté. Par exemple, si l'on veut utiliser la fonction codice_123 apporté par le module codice_124, il faut taper codice_125.
Le préfixe du nom de fonction ou de classe est appelé l'espace de nom.
Il est possible d'abréger l'espace de nom. Ainsi, ci-dessus, nous avons abrégé codice_124 en codice_59 et ainsi, pour appeler la fonction, il suffit d'écrire codice_128
Notes et références.
Python pour le calcul scientifique < ↑ > Premiers programmes