Introduction à Python

Propos préliminaires

Pourquoi Python

  • Python est simple et rapide à comprendre, on peut ensuite se perfectionner pendant longtemps
  • Il fonctionne sous différents OS (Windows, Linux, OS X, Android, iOS, etc)
  • De nombreuses bibliothèques couvrant des domaines variés, du réseau aux interfaces graphiques, des méthématiques symboliques au traitement du signal (batteries included)
  • C'est un langage qui est très facile à lire (write once, read often)

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.

Installer Python

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:

  • Linux: il suffit généralement d'utiliser les paquets Python de votre distribution
  • Mac OS: il est possible d'utiliser MacPorts ou homebrew
  • Windows/Linux/OSX: la distribution Canopy propose une alternative intéressante, mais payante pour sa version complète.

Si vous voulez simplement tester Python, vous pouvez utiliser les sites suivants qui vous permettront de faire un peu de code dans votre navigateur :

Python comme calculatrice

Une fois Python lancé vous avez accès à un interpréteur de commande. Je l'utilise régulièrement comme calculatrice.

Les nombres


In [2]:
6*2 + 13


Out[2]:
25

In [3]:
(50-5*6)/4


Out[3]:
5.0

La division de deux entiers retourne le résultat réel


In [4]:
7/2


Out[4]:
3.5

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]:
3

In [6]:
7 % 2


Out[6]:
1

In [7]:
7//-2


Out[7]:
-4

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]:
1474.6666666666667

Les nombres complexes sont également faciles à utiliser en Python.


In [9]:
1 + 1j


Out[9]:
(1+1j)

In [10]:
1j + 1J


Out[10]:
2j

In [11]:
1j * 1j


Out[11]:
(-1+0j)

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]:
900

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]:
20.194000000000003

In [14]:
prix + _


Out[14]:
121.164

In [15]:
round (_, 2)


Out[15]:
121.16

Chaînes de caractères

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]:
'La cigale et la Fourmi'

In [17]:
'n\'est-ce pas'


Out[17]:
"n'est-ce pas"

In [18]:
"n'est-ce pas"


Out[18]:
"n'est-ce pas"

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)


Le corbeau et le Renard
  Maître Corbeau, sur un arbre perché,
  Tenait dans son bec un fromage.

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)


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

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


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]:
'machin'

In [23]:
partie1 = 'mac'
partie2 = 'hin'
mot = partie1 + partie2
mot


Out[23]:
'machin'

In [23]:
print ('<' + 5*mot + '>')


<machinmachinmachinmachinmachin>

Deux chaînes cote à cote sont automatiquement accolées : nous aurions pu écrire


In [24]:
'mac' 'hin'


Out[24]:
'machin'

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]:
'a'

In [26]:
mot[0:4]


Out[26]:
'mach'

In [27]:
mot[2:6]


Out[27]:
'chin'

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'


---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-28-f515d38b2e81> in <module>
----> 1 mot[0] = 't'

TypeError: 'str' object does not support item assignment

In [29]:
mot[2:6] = 'rins'


---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-29-68dee81d5f04> in <module>
----> 1 mot[2:6] = 'rins'

TypeError: 'str' object does not support item assignment

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]:
'tachin'

In [31]:
mot[0:2] + 'rins'


Out[31]:
'marins'

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]:
'ma'

In [33]:
mot[2:] # tout sauf les deux premiers caractères


Out[33]:
'chin'

Il est à noter que s[:i] + s[i:] est égal à s


In [37]:
print (mot[:2] + mot[2:])
print (mot[:3] + mot[3:])


machin
machin

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]:
'achin'

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]:
'n'

In [38]:
mot[-2] # l'avant dernier caractère


Out[38]:
'i'

In [43]:
mot[-2:] # les deux derniers caractères


Out[43]:
'in'

In [44]:
mot[:-2] # tout sauf les deux derniers caractères


Out[44]:
'mach'

In [45]:
mot[-100:]


Out[45]:
'machin'

Vous noterez que -0 est équivalent à 0:


In [46]:
mot[-0] # premier caractère


Out[46]:
'm'

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]


---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-47-969b57397921> in <module>
----> 1 mot[-10]

IndexError: string index out of range

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]:
34

Informations complémentaire

Vous pouvez consulter les pages suivantes pour approfondir les traitements sur les chaînes de caractères:

Listes

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]:
['choux', 'poires', 100, 1234]

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]:
'choux'

In [42]:
ma_liste[3]


Out[42]:
1234

In [43]:
ma_liste[-1]


Out[43]:
1234

In [54]:
ma_liste[1:-1]


Out[54]:
['poires', 100]

In [45]:
ma_liste[:2] + ['raisins', 2*2]


Out[45]:
['choux', 'poires', 'raisins', 4]

In [47]:
2*ma_liste[:2] + ['pommes']


Out[47]:
['choux', 'poires', 'choux', 'poires', 'pommes']

À 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]:
['choux', 'poires', 100, 1234]

In [55]:
ma_liste[2] = ma_liste[2]+23

In [56]:
ma_liste


Out[56]:
['choux', 'poires', 123, 1234]

In [57]:
ma_liste[1] = ma_liste[1]+' conférences'

In [58]:
ma_liste


Out[58]:
['choux', 'poires conférences', 123, 1234]

In [59]:
ma_liste[2] = ma_liste[2] + 'azerty'


---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-59-9fcdb488640c> in <module>
----> 1 ma_liste[2] = ma_liste[2] + 'azerty'

TypeError: unsupported operand type(s) for +: 'int' and 'str'

In [60]:
# Remplacer certains éléments
ma_liste[:2] = [1, 12]
ma_liste


Out[60]:
[1, 12, 123, 1234]

In [61]:
# Pour en enlever
ma_liste[0:2] = []
ma_liste


Out[61]:
[123, 1234]

In [62]:
# pour en ajouter
ma_liste[1:1] = ['abc', 'def']
ma_liste


Out[62]:
[123, 'abc', 'def', 1234]

In [63]:
ma_liste[:0] = ma_liste     # Insère une copie de soi-même au début
ma_liste


Out[63]:
[123, 'abc', 'def', 1234, 123, 'abc', 'def', 1234]

La fonction intégrée len( ) s’applique aussi aux listes :


In [64]:
len(ma_liste)


Out[64]:
8

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]:
3

In [18]:
p[1]


Out[18]:
[2, 3]

In [66]:
p[1][0]


Out[66]:
2

In [67]:
len(p[1])


Out[67]:
2

Notez bien que p[1] et q permette d'accéder à la même chose, au même objet.

Premiers pas vers la programmation

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


1
1
2
3
5
8
13
21
34
55
89

Cet exemple introduit plusieurs fonctionnalités nouvelles.

  • La première ligne contient une affectation multiple : lesvariables 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.
  • La boucle 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 !=.
  • Le corps de la boucle est indenté : l’indentation est le moyen par lequel Python regroupe les instructions. Python ne fournit pas (encore) une fonction d’édition de ligne intelligente, donc vous devez insérer une tabulation ou un espace pour chaque ligne indentée. En pratique vous préparerez les saisies plus compliquées avec un éditeur de texte ; la plupart des éditeurs de texte ont une fonction d’auto-indentation. Lorsqu’une instruction composée est entrée en mode interactif, elle doit être suivie d’une ligne vide pour indiquer qu’elle est terminée (car l’interpréteur ne peut pas deviner si vous avez tapé la dernière ligne).
  • L’instruction 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


1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 

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.