Introduction à Python - e-campus

Notebook
18/12/2014 12:14
In [24]: from __future__ import print_function
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étrocompatibilité : 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
2014), il est commence à devenir plus intéressant de travailler en Python 3.
Pour installer Python sur votre ordinateur, il existe plusieurs moyens. Je vous recommande d'installer la suite Canopy d'Entought
(https://store.enthought.com/#canopy-academic), qui est gratuite pour les universitaires et payante pour les entreprises. Pour bénéficier de la version
académique, il faut vous enregistrer (https://store.enthought.com/accounts/login/?next=/licenses/academic/request/) avec votre adresse mail officielle
ens.uvsq.fr.
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 (http://www.macports.org/) ou homebrew (http://www.brew.sh/)
Windows: la distribution Anaconda (http://www.continuum.io/downloads) regroupe tout ce qu'il vous faut.
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]: 2+2
Out[2]: 4
In [1]: (50-5*6)/4 # un commentaire
Out[1]: 5
In [4]: # Ceci est um commentaire
La division de deux entiers retourne l'entier immédiatement inférieur
In [2]: 7/2 # c'est un commentaire sur la même ligne que
le code
Out[2]: 3
In [6]: 7/-2
Out[6]: -4
http://localhost:8888/nbconvert/html/coursIntroPython/1-ApprendrePython-Introduction.ipynb?download=false
Page 1 sur 8
Notebook
18/12/2014 12:14
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 [7]: 553 * 4 / 1.5
Out[7]: 1474.6666666666667
In [6]: 7 / 2.
Out[6]: 3.5
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 [8]: largeur = 20
hauteur = 5*9
largeur * hauteur
Out[8]: 900
Il est possible d'affecter une valeur à plusieurs variables simultanément :
In [6]: 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 [11]: tva = 19.6 / 100
prix = 100.95
prix * tva
Out[11]: 19.7862
In [12]: prix + _
Out[12]: 120.7362
In [13]: round (_, 2)
Out[13]: 120.74
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 [17]: 'La cigale et la Fourmi'
Out[17]: 'La cigale et la Fourmi'
In [15]: 'n\'est-ce pas'
Out[15]: "n'est-ce pas"
http://localhost:8888/nbconvert/html/coursIntroPython/1-ApprendrePython-Introduction.ipynb?download=false
Page 2 sur 8
Notebook
18/12/2014 12:14
In [19]: "n'est-ce pas"
Out[19]: "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 [20]: fable = "Le corbeau et le Renard\n\
Maître Corbeau, sur un arbre perché,\n
print (fable)
Tenait dans son bec un fromage"
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 [21]: fable
Une
Qui
print
= r"La Grenouille qui veut se faire aussi grosse que le Bœuf\n \
Grenouille vit un Bœuf,\n \
lui sembla de belle taille"
(fable)
La Grenouille qui veut se faire aussi grosse que le Bœuf\n
de belle taille
Une Grenouille vit un Bœuf,\n
Qui lui sembla
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 [19]: print ("""
Usage: trucmuche [OPTIONS]
-h
-b
""")
Usage: trucmuche [OPTIONS]
-h
-b
affiche cette page d'aide
active l'option bidule
affiche cette page d'aide
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 [17]: mot = 'mac' + 'hin'
mot
Out[17]: 'machin'
In [18]: partie1 = 'mac'
partie2 = 'hin'
mot = partie1 + partie2
mot
Out[18]: 'machin'
In [19]: print ('<' + 5*mot + '>')
<machinmachinmachinmachinmachin>
Deux chaînes cote à cote sont automatiquement accolées : nous aurions pu écrire
In [23]: 'mac' 'hin'
Out[23]: 'machin'
http://localhost:8888/nbconvert/html/coursIntroPython/1-ApprendrePython-Introduction.ipynb?download=false
Page 3 sur 8
Notebook
18/12/2014 12:14
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[0]
Out[25]: 'm'
In [29]: mot[0:2]
Out[29]: 'ma'
In [30]: mot[2:4]
Out[30]: 'ch'
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 [20]: mot[0] = 't'
--------------------------------------------------------------------------TypeError
Traceback (most recent call last)
<ipython-input-20-a298fccab792> in <module>()
----> 1 mot[0] = 't'
TypeError: 'str' object does not support item assignment
In [22]: mot[2:6] = 'rins'
--------------------------------------------------------------------------TypeError
Traceback (most recent call last)
<ipython-input-22-ea6fefd1f66b> 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 [38]: 't' + mot[1:6]
Out[38]: 'tachin'
In [39]: mot[0:2] + 'rins'
Out[39]: '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 [34]: mot[:2] # les deux premiers caractères
Out[34]: 'ma'
In [35]: mot[2:] # tout sauf les deux premiers caractères
Out[35]: 'chin'
Il est à noter que s[:i] + s[i:] est égal à s
In [36]: 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
http://localhost:8888/nbconvert/html/coursIntroPython/1-ApprendrePython-Introduction.ipynb?download=false
Page 4 sur 8
Notebook
18/12/2014 12:14
In [37]: mot[1:100]
Out[37]: 'achin'
In [38]: mot[10:]
Out[38]: ''
In [40]: mot[2:1]
Out[40]: ''
Les indices peuvent être négatifs pour compter à partir de la droite :
In [40]: mot[-1] # le dernier caractère
Out[40]: 'n'
In [41]: mot[-2] # l'avant dernier caractère
Out[41]: 'i'
In [42]: mot[-2:] # les deux derniers caractères
Out[42]: 'in'
In [43]: mot[:-2] # tout sauf les deux derniers caractères
Out[43]: 'mach'
Vous noterez que -0 est équivalent à 0:
In [44]: mot[-0] # premier caractère
Out[44]: '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 [45]: mot[-100:]
Out[45]: 'machin'
In [25]: mot[-10]
--------------------------------------------------------------------------IndexError
Traceback (most recent call last)
<ipython-input-25-4feaf8131d45> 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
-+---+---+---+---+---+---+
-4 -3 -2 -1
| m | a | c | h | i | n |
+---+---+---+---+---+---+
0
1
2
3
4
5
6 -6
-5
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 [47]: s = 'supercalifragilisticexpialidocious'
len (s)
Out[47]: 34
Il est possible d'utiliser des chaînes de caractères en Unicode, pour avoir accès aux caractères non-ASCII, comme é, è, ê, etc. Pour cela, il suffit de mettre un u
devant la chaîne de caractères.
In [48]: s_unicode = u"Épautre français"
print (s_unicode)
Épautre français
http://localhost:8888/nbconvert/html/coursIntroPython/1-ApprendrePython-Introduction.ipynb?download=false
Page 5 sur 8
Notebook
18/12/2014 12:14
Informations complémentaire
Vous pouvez consulter les pages suivantes pour approfondir les traitements sur les chaînes de caractères:
https://docs.python.org/3/library/string.html qui explique toutes les méthodes relatives aux chaînes de caractères, à leur transformation, et aux
recherches dans les chaînes
http://docs.python.org/lib/typesseq-strings.html qui indique comment mettre en forme les chaînes, avec l'opérateur %, un peu à la façon du C
http://docs.python.org/lib/typesseq.html qui décrit les types séquences et leur méthodes, que nous verrons plus tard.
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 [3]: ma_liste = ['reseaux', 'neuronaux', 100, 1234]
ma_liste
Out[3]: ['reseaux', 'neuronaux', 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 [4]: ma_liste[0]
Out[4]: 'reseaux'
In [5]: ma_liste[3]
Out[5]: 1234
In [6]: ma_liste[-2]
Out[6]: 100
In [7]: ma_liste[1:-1]
Out[7]: ['neuronaux', 100]
In [8]: ma_liste[:2] + ['biomimetiques', 2*2]
Out[8]: ['reseaux', 'neuronaux', 'biomimetiques', 4]
In [9]: 2*ma_liste[:3] + ['Fin']
Out[9]: ['reseaux', 'neuronaux', 100, 'reseaux', 'neuronaux', 100, 'Fin']
A la différence des chaînes, qui sont non-modifiables, il est possible de changer les éléments individuels d’une liste :
In [10]: ma_liste
Out[10]: ['reseaux', 'neuronaux', 100, 1234]
In [11]: ma_liste[2] = ma_liste[2]+23
In [12]: ma_liste
Out[12]: ['reseaux', 'neuronaux', 123, 1234]
In [14]: # Remplacer certains éléments
ma_liste[:2] = [1, 12]
ma_liste
Out[14]: [1, 12, 123, 1234]
In [15]: # Pour en enlever
ma_liste[0:2] = []
ma_liste
Out[15]: [123, 1234]
http://localhost:8888/nbconvert/html/coursIntroPython/1-ApprendrePython-Introduction.ipynb?download=false
Page 6 sur 8
Notebook
18/12/2014 12:14
In [19]: # pour en ajouter
ma_liste[1:1] = ['abc', 'def']
ma_liste
Out[19]: [123, 'abc', 'def', 1234]
In [20]: ma_liste[:0] = ma_liste
ma_liste
# Insère une copie de soi-même au début
Out[20]: [123, 'abc', 'def', 1234, 123, 'abc', 'def', 1234]
La fonction intégrée len( ) s’applique aussi aux listes :
In [21]: len(ma_liste)
Out[21]: 8
Il est possible d’emboîter des listes (créer des listes contenant d’autres listes), par exemple :
In [16]: q = [2, 3]
p = [1, q, 4]
len(p)
Out[16]: 3
In [18]: p[1]
Out[18]: [2, 3]
In [19]: p[1][0]
Out[19]: 2
In [21]: len(p[1])
Out[21]: 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 [22]: # 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
http://localhost:8888/nbconvert/html/coursIntroPython/1-ApprendrePython-Introduction.ipynb?download=false
Page 7 sur 8
Notebook
18/12/2014 12:14
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 :
In [25]: i = 256*256
print ('La valeur de i est', i)
La valeur de i est 65536
Il est possible de supprimer le saut de ligne de print en changeant le caractère de fin de ligne:
In [39]: 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.
http://localhost:8888/nbconvert/html/coursIntroPython/1-ApprendrePython-Introduction.ipynb?download=false
Page 8 sur 8