Pour approfondir vos connaissances en Python, plusieurs livres sont disponibles à la bibliothèque. Il y a également un tutoriel très bien fait de Guido van Rossum, le créateur du langage.
Il y a deux branches de Python, la version 2 et la version 3. Cette dichotomie vient du fait qu'un certain nombre d'améliorations nécessitaient de casser la rétro-compatibilité : lancer un code valide en Python 2.X avec un interpréteur en Python 3.Y peut générer des erreurs. Il existe cependant beaucoup d'outils pour convertir automatiquement des codes de Python 2 en Python 3. La transition entre les versions 2 et 3 est prévue sur 5 ans, pour finir en 2016. Aujourd'hui (fin 2017), il faut travailler en Python 3.
Pour installer Python sur votre ordinateur, il existe plusieurs moyens. Je vous recommande d'installer la distribution Anaconda qui regroupe tout ce qu'il vous faut. Il faut télécharger la version de Python 3.Y en 64bits. Vous aurez accès rapidement à tous les outils importants : un environnement de programmation qui ressemble à Matlab (Spyder), le gestionnaire de notebook (Jupyter) et une console intelligente (iPython).
Sinon, il existe aussi les alternatives suivantes:
Si vous voulez simplement tester Python, vous pouvez utiliser les sites suivants qui vous permettront de faire un peu de code dans votre navigateur :
Une fois Python lancé vous avez accès à un interpréteur de commande. Je l'utilise régulièrement comme calculatrice.
In [2]:
6*2 + 13
Out[2]:
In [3]:
(50-5*6)/4
Out[3]:
La division de deux entiers retourne le résultat réel
In [4]:
7/2
Out[4]:
Pour faire une division réelle, il faut utiliser l'opérateur //, qui retourne l'entier directement inférieur
In [5]:
7//2
Out[5]:
In [6]:
7 % 2
Out[6]:
In [7]:
7//-2
Out[7]:
Les nombres à virgules flottantes sont pris en compte. Lorsque des entiers et des flottants sont mélangés dans un calcul, les opérateurs travaillent toujours avec la plus grande précision possible, donc en flottants.
In [8]:
553 * 4 / 1.5
Out[8]:
Les nombres complexes sont également faciles à utiliser en Python.
In [9]:
1 + 1j
Out[9]:
In [10]:
1j + 1J
Out[10]:
In [11]:
1j * 1j
Out[11]:
On peut utiliser le signe = pour affecter une valeur à une variable. La valeur de la variable affichée n'est pas affichée.
In [12]:
largeur = 20
hauteur = 5*9
largeur * hauteur
Out[12]:
Il est possible d'affecter une valeur à plusieurs variables simultanément :
In [11]:
x = 0; y = 0; z = 0
x = y = z = 0 # Mettre à zéro x, y et z
En mode interactif (utilisé ici comme calculatrice), la dernière valeur affichée est affectée à la variable _, ce qui peut être pratique pour continuer les calculs
In [13]:
tva = 20. / 100
prix = 100.97
prix * tva
Out[13]:
In [14]:
prix + _
Out[14]:
In [15]:
round (_, 2)
Out[15]:
Python propose de manipuler les chaînes de caractères avec beaucoup de facilité. Ces chaînes peuvent être exprimées de différentes façons, elles peuvent être incluses entre simples quotes (apostrophes) et doubles quotes (guillemets)
In [16]:
"La cigale et la Fourmi"
Out[16]:
In [17]:
'n\'est-ce pas'
Out[17]:
In [18]:
"n'est-ce pas"
Out[18]:
Attention aux caractères accentués, il est posible qu'ils soient mal interprétés si vous passez d'un OS à l'autre (Windows à Linux par exemple). Il n'est pas permis d'utiliser des accents pour nommer des variables en Python.
Il est possible de définir des chaînes de caractères qui s'étendent sur plusieurs lignes.
In [19]:
fable = "Le corbeau et le Renard\n\
Maître Corbeau, sur un arbre perché,\n Tenait dans son bec un fromage."
print (fable)
Les retours à la ligne sont indiqués par des \n. Le \ qui suit indique qu'il ne faut pas tenir compte le retour à la ligne du texte. Vous noterez que les blancs en début de ligne sont significatifs.
Une chaîne de caractères peut être définie comme chaîne raw (brute), dans ce cas les \n ne sont pas interprétés mais les \ avec le retour chariot permettent tout de même de revenir à la ligne. Il suffit pour cela de rajouter un r avant d'ouvrir les guillemets (" ou ') de la chaîne.
In [20]:
fable = r"La Grenouille qui veut se faire aussi grosse que le Bœuf\n \
Une Grenouille vit un Bœuf,\n \
Qui lui sembla de belle taille"
print (fable)
Les chaînes peuvent également être entourées de triples guillemets (""" ou '''). Dans ce cas, un retour à la ligne est considéré comme un retour à la ligne. Il n'est plus nécessaire de mettre \n ou \\.
In [21]:
print ("""
Usage: trucmuche [OPTIONS]
-h affiche cette page d'aide
-b active l'option bidule
""")
Les chaînes peuvent être concaténée, ou accolées, avec l'opérateur + et multipliée avec l'opérateur *.
In [22]:
mot = 'mac' + 'hin'
mot
Out[22]:
In [23]:
partie1 = 'mac'
partie2 = 'hin'
mot = partie1 + partie2
mot
Out[23]:
In [23]:
print ('<' + 5*mot + '>')
Deux chaînes cote à cote sont automatiquement accolées : nous aurions pu écrire
In [24]:
'mac' 'hin'
Out[24]:
Les chaînes de caractères peuvent être décomposées, ou indexées. Dans ce cas, comme en C, le premier caractère est à la position 0. Le type caractère n'existe pas, un caractère est considéré comme une chaîne de caractère de taille 1. Il est possible de découper des sous-chaînes de caractères en utilisant la notation de découpage (ou slice) avec les deux points (:).
In [25]:
mot[1]
Out[25]:
In [26]:
mot[0:4]
Out[26]:
In [27]:
mot[2:6]
Out[27]:
Il n'est pas possible de modifier les chaînes de caractères, à la différence du C. Vous obtiendrez une erreur si vous essayez de modifier un caractère de la chaîne:
In [28]:
mot[0] = 't'
In [29]:
mot[2:6] = 'rins'
Mais il est très facile de créer une nouvelle chaîne avec le contenu que l'on souhaite :
In [30]:
't' + mot[1:6]
Out[30]:
In [31]:
mot[0:2] + 'rins'
Out[31]:
Les indices de découpages ont des valeurs par défaut utile. Le premier indice non défini prend la valeur par défaut 0, le deuxième indice prend la taille de la chaîne que l'on est en train de découper.
In [32]:
mot[:2] # les deux premiers caractères
Out[32]:
In [33]:
mot[2:] # tout sauf les deux premiers caractères
Out[33]:
Il est à noter que s[:i] + s[i:] est égal à s
In [37]:
print (mot[:2] + mot[2:])
print (mot[:3] + mot[3:])
Les indices erronés sont générés de façon élégante : un indice trop grand est remplacé par la taille de la chaîne et un indice de fin plus grand qu'un indice de début génère une chaîne vide
In [34]:
mot[1:100]
Out[34]:
In [35]:
mot[10:]
Out[35]:
In [36]:
mot[2:1]
Out[36]:
Les indices peuvent être négatifs pour compter à partir de la droite :
In [37]:
mot[-1] # le dernier caractère
Out[37]:
In [38]:
mot[-2] # l'avant dernier caractère
Out[38]:
In [43]:
mot[-2:] # les deux derniers caractères
Out[43]:
In [44]:
mot[:-2] # tout sauf les deux derniers caractères
Out[44]:
In [45]:
mot[-100:]
Out[45]:
Vous noterez que -0 est équivalent à 0:
In [46]:
mot[-0] # premier caractère
Out[46]:
On peut donner des valeurs négatives hors limites pour le découpage. Cependant, pour l'accès direct, cela génère des erreurs
In [47]:
mot[-10]
Pour bien se rappeler le découpage, une bonne méthode est de penser à des indices qui pointent entre les caractères, par exemple
-+---+---+---+---+---+---+
| m | a | c | h | i | n |
+---+---+---+---+---+---+
0 1 2 3 4 5 6
-6 -5 -4 -3 -2 -1
Ainsi le découpage entre i et j est celui qui contient tous les caractères compris entre i et j.
La fonction len() retourne la longueur d'une chaîne:
In [39]:
s = 'supercalifragilisticexpialidocious'
len(s)
Out[39]:
Vous pouvez consulter les pages suivantes pour approfondir les traitements sur les chaînes de caractères:
Python connaît un grand nombre de types de données composites, utilisées pour regrouper un ensemble de valeurs. La plus riche en possibilités est la liste, qui peut être écrite comme une liste de valeurs (éléments) entre crochets et séparés par des virgules. Les éléments d’une liste n’ont pas nécessairement le même type.
In [53]:
ma_liste = ['choux', 'poires', 100, 1234]
ma_liste
Out[53]:
Comme les indices des chaînes, les indices des listes commencent à 0, et les listes peuvent être découpées, concaténées, et ainsi de suite :
In [41]:
ma_liste[0]
Out[41]:
In [42]:
ma_liste[3]
Out[42]:
In [43]:
ma_liste[-1]
Out[43]:
In [54]:
ma_liste[1:-1]
Out[54]:
In [45]:
ma_liste[:2] + ['raisins', 2*2]
Out[45]:
In [47]:
2*ma_liste[:2] + ['pommes']
Out[47]:
À la différence des chaînes, qui sont non-modifiables, il est possible de changer les éléments individuels d’une liste :
In [48]:
ma_liste
Out[48]:
In [55]:
ma_liste[2] = ma_liste[2]+23
In [56]:
ma_liste
Out[56]:
In [57]:
ma_liste[1] = ma_liste[1]+' conférences'
In [58]:
ma_liste
Out[58]:
In [59]:
ma_liste[2] = ma_liste[2] + 'azerty'
In [60]:
# Remplacer certains éléments
ma_liste[:2] = [1, 12]
ma_liste
Out[60]:
In [61]:
# Pour en enlever
ma_liste[0:2] = []
ma_liste
Out[61]:
In [62]:
# pour en ajouter
ma_liste[1:1] = ['abc', 'def']
ma_liste
Out[62]:
In [63]:
ma_liste[:0] = ma_liste # Insère une copie de soi-même au début
ma_liste
Out[63]:
La fonction intégrée len( ) s’applique aussi aux listes :
In [64]:
len(ma_liste)
Out[64]:
Il est possible d’emboîter des listes (créer des listes contenant d’autres listes), par exemple :
In [65]:
q = [2, 3]
p = [1, q, 4]
len(p)
Out[65]:
In [18]:
p[1]
Out[18]:
In [66]:
p[1][0]
Out[66]:
In [67]:
len(p[1])
Out[67]:
Notez bien que p[1] et q permette d'accéder à la même chose, au même objet.
Bien sûr, nous pouvons utiliser Python pour des tâches plus compliquées que d’ajouter deux et deux. Par exemple, nous pouvons écrire une sous-séquence de la suite de Fibonacci de la façon suivante :
In [68]:
# Suite de Fibonacci
# La somme de deux éléments définit le suivant
a, b = 0, 1
while b < 100:
print (b)
a, b = b, a + b
Cet exemple introduit plusieurs fonctionnalités nouvelles.
a et b prennent simultanément les nouvelles valeurs 0 et 1. Sur la dernière ligne l’affectation multiple est utilisée à nouveau, montrant que les expressions en partie droite sont d’abord toutes évaluées avant qu’aucune affectation ne se fasse.while s’exécute tant que la condition (ici : b < 10) reste vraie . En Python, comme en C, toute valeur entière différente de zéro est vraie ; zéro est faux. La condition pourrait aussi être une chaîne ou une valeur de type liste, en fait n’importe quelle séquence ; n’importe quoi avec une longueur différente de zéro est vrai, les séquences vides correspondent à faux. Le test utilisé dans l’exemple est une simple comparaison. Les opérateurs de comparaison standard sont écrits de la même façon qu’en C : <, >, ==, <=, >= et !=.print écrit la valeur de la ou des expressions qui lui sont données. Elle diffère de la simple écriture de l’expression (comme tout-à-l’heure dans les exemples de la calculatrice) dans la mesure où elle accepte plusieurs expressions et chaînes. Les chaînes sont imprimées sans apostrophes, et un espace est inséré entre les éléments, ce qui vous permet de les afficher dans un format plus sympathique, comme ceci :Il est possible de supprimer le saut de ligne de print en changeant le caractère de fin de ligne:
In [22]:
a, b = 0, 1
while b < 1000:
print (b, end=' ')
a, b = b, a+b
Ce notebook est une adaptation de la traduction française, dirigée par Olivier Berger et mise à jour par Henri Garreta, du tutoriel Python édité par Guido van Rossum et Fred L. Drake.