Tutoriel d'introduction à Python 3¶

L'objectif de ce tutoriel est de présenter une introduction à Python 3 à des étudiants ayant déjà des notions d'algorithmique et de programmation. Par exemple le fonctionnement des boucles $\mathtt{for}$ n'est pas expliqué mais on y étudie leur implémentation en Python.

La documentation officielle est disponible à l'adresse https://docs.python.org/fr/3/

  • Ce tutoriel a été écrit sur Jupyter Notebook (https://jupyter.org/). C'est un excellent moyen de produire des documents contenant du texte (en Markdown), des instructions de code et le résultat de ce code. Pensez-y pour produire vos documents.

  • Sur les machines du département (IUT Informatique, site Aix), sur la partition Linux la distribution Anaconda est installée (commande $\mathtt{anaconda-navigator}$ dans un terminal). Celle-ci contient notamment l'IDE $\mathtt{Spyder}$ (accessible directement par la commande $\mathtt{spyder}$ dans un terminal) ainsi que Jupyter Notebook (accessible directement par la commande $\mathtt{jupyter-notebook}$ dans un terminal) mentionné au point précédent.

Voici les différents points abordés dans ce tutoriel.

  • Ce tutoriel débute par une introduction (incomplète) au langage Python. Cette partie est consacrée aux notions de base pour prendre en main ce langage.

    Types de données et opérations de base
    Structures de données : listes, tuples, dictionnaires, ensembles
    Tests et instructions conditionnelles
    Boucles while et for
    Procédures et fonctions
    Importer un module

  • Ce tutoriel présente aussi quelques bibliothèques utiles pour faire des mathématiques en Python dont
    Random pour une introduction à l'aléatoire,
    NumPy pour gérer notamment les matrices et les vecteurs,
    Matplotlib pour effectuer des tracés,
    NetworkX pour gérer les graphes,
    Différents modules pour faire des statistiques et visualiser les données : NumPy et Pandas.
    On donne aussi quelques références pour l'utilisation de la bibliothèque SciPy pour des fonctionnalités avancées ainsi que du logiciel SageMath qui permet de gérer le calcul formel et contient notamment de nombreuses fonctions pour la théorie des graphes.

Introduction à la programmation en Python¶

Types et opérations de base ¶

  • Commençons par voir comment parler avec Python. Python nous parle au travers de la fonction $\mathtt{print}$. Celle-ci peut prendre plusieurs arguments de types différents.
In [1]:
a=1
print(a)

1
In [2]:
a=1
print(a+1)

2
In [3]:
a=1
print("Si a=",a,"\nalors a+1=",a+1)

Si a= 1 
alors a+1= 2
  • À l'inverse, on peut communiquer des données à Python avec la fonction $\mathtt{input}$.
In [4]:
a=input("Rentrer la valeur de a :")
print(a)

Rentrer la valeur de a :12
12

Attention le résultat de la fonction $\mathtt{input}$ est toujours une chaîne de caractères (type $\mathtt{str}$).

  • Il y a donc différents types en Python. Par exemple : $\mathtt{int}$ pour les entiers, $\mathtt{float}$ pour les nombres à virgule flottante, $\mathtt{str}$ pour les caractères ou chaînes de caractères, $\mathtt{bool}$ pour les booléens.
In [5]:
a=1
type(a)
Out[5]:
int

Notez que le booléen $\mathtt{True}$ prend la valeur $\mathtt{1}$ et le booléen $\mathtt{False}$ la valeur $\mathtt{0}$.

In [6]:
print(True+1)

2

Comme vu plus haut il n'est pas nécessaire de déclarer le type d'une variable avant de lui affecter une valeur. On peut bien évidemment utiliser des fonctions de conversion d'un type à l'autre.

In [7]:
a=int(input("Entrer la valeur de a :"))    # notez la conversion en int
print(a+1)

Entrer la valeur de a :12
13
  • Les opérations élémentaires sont implémentées par les symboles usuels : $\mathtt{+}$, $\mathtt{-}$, $\mathtt{*}$, $\mathtt{/}$. A noter que le résultat d'une division est toujours un $\mathtt{float}$.
In [8]:
a=4
print(4/2)

2.0

La puissance s'obtient avec le symbole $\mathtt{**}$.

In [9]:
print(2**3)

8

Pour les entiers il existe aussi les fonctions de modulo $\mathtt{\%}$ et de division entière $\mathtt{//}$.

In [10]:
print(5%2)
print(5//2)

1
2
  • Pour faire un échange de valeurs il existe en Python une subtilité qui permet d'éviter le recours explicite à une variable temporaire :
In [11]:
a=1
b=2
a, b = b, a
print("a=",a)
print("b=",b)

a= 2
b= 1

Premières structures de données ¶

Type $\mathtt{list}$ ¶

  • Les listes Python (type $\mathtt{list}$) sont semblables à ce qui dans d'autres langages peut être appelé un tableau.

Les listes sont définies via le constructeur $\mathtt{[ ]}$. Le premier élément d'une liste est celui d'indice $\mathtt{0}$.

In [12]:
l = [0, 1, 2]
print("Liste entière :", l)
print("Deuxième élément de la liste", l[1])

Liste entière : [0, 1, 2]
Deuxième élément de la liste 1
  • On peut accéder à et modifier n'importe quel élément d'une liste. Les éléments d'une liste ne sont pas forcément tous du même type.
In [13]:
l = [0, 1, 2]
l[0] = "test"
print(l)

['test', 1, 2]
  • La longueur d'une liste est donné par la fonction $\mathtt{len}$.
In [14]:
l1 = [0, 1]
l2 = [2]

print(len(l1))
print(len(l2))

2
1

La somme de deux listes est l'opération de concaténation.

In [15]:
l1 = [0, 1]
l2 = [2]
l = l1 + l2
print(len(l))
print(l)

3
[0, 1, 2]

Dans le même esprit on peut répliquer une liste avec l'opération $\mathtt{*}$. Ceci est bien pratique si l'on veut créer une liste d'une taille donnée.

In [16]:
print(3*['a','b'])
print(7*[0])

['a', 'b', 'a', 'b', 'a', 'b']
[0, 0, 0, 0, 0, 0, 0]
  • Il existe de nombreuses autres fonctions implémentées pour les listes. Quelques exemples ci-dessous
In [17]:
l = [0,1,2,3]
print(min(l))
print(max(l))
print(sum(l))

0
3
6
  • Attention lors de l'affectation d'une liste ! La commande ci-dessous
In [18]:
l1= [0,1,2]
l2= l1

ne va pas copier les valeurs de $\mathtt{l1}$ dans la liste $\mathtt{l2}$ mais donner deux noms différents à la même liste (c'est un pointeur). Ainsi, toute modification de $\mathtt{l1}$ va modifier $\mathtt{l2}$...

In [19]:
l1 = [0,1,2]
l2 = l1
l2[0] = 3
print(l2)
print(l1)

l1.append(4)
print(l1)
print(l2)

[3, 1, 2]
[3, 1, 2]
[3, 1, 2, 4]
[3, 1, 2, 4]

Il y a une exception à cette règle : la concatenation.

In [20]:
l1 = [0,1,2]
l2 = l1
l2 = l2 + [3]
print(l2)
print(l1)

[0, 1, 2, 3]
[0, 1, 2]

Pour copier les valeurs d'une liste on préférera l'utilisation de la méthode (notez la différence lors du recours à une méthode par rapport à une fonction) $\mathtt{copy}$

In [21]:
l1= [0,1,2]
l2= l1.copy()
l1 = l1 + [3]
print(l2)

[0, 1, 2]
  • Pour ajouter un élément en fin de liste on utilise la méthode $\mathtt{append}$, pour ajouter un élément à une position donnée on utilise la méthode $\mathtt{insert(position, valeur)}$. Pour supprimer un élément d'une liste on utilise l'instruction $\mathtt{del}$ ou $\mathtt{remove}$
In [1]:
l=[0,1,2]
l.append(3)     # on ajoute 3 à la fin
print(l)

l.insert(0,-1)  # on ajoute -1 en position 0
print(l)

del l[1]       # on supprime l'élément en position 1
print(l)

l.remove(2)    # on supprime le 2
print(l)

[0, 1, 2, 3]
[-1, 0, 1, 2, 3]
[-1, 1, 2, 3]
[-1, 1, 3]
  • On peut utiliser des indices négatifs pour accéder/modifier des éléments d'une liste. L'élément d'indice $\mathtt{-1}$ est le dernier, celui d'indice $\mathtt{-2}$ le précédent etc...

Il faut donc être particulièrement vigilant avec les indices lors des parcours de listes.

In [23]:
l = [0,1,2]
print(l[-1])

2
  • On peut accéder à/modifier des tranches de la liste $\mathtt{l}$ par l'instruction $\mathtt{l[début:fin]}$. L'élément d'indice $\mathtt{fin}$ n'est pas inclus dans la tranche.
In [24]:
l = [0,1,2,3,4]
print(l[1:4])

# Un autre exemple
print(l[0:2])

# Le 0 étant le début de la liste est optionnel
print(l[:2])

# Idem pour l'indice de fin
print(l[:])

# On peut aussi modifier directement des tranches
l[:2] = ['a','b']
print(l)

[1, 2, 3]
[0, 1]
[0, 1]
[0, 1, 2, 3, 4]
['a', 'b', 2, 3, 4]
  • On peut tester si un élément est présent ou non dans une liste avec les instructions $\mathtt{in}$ et $\mathtt{not}$ $\mathtt{in}$
In [25]:
l=['a','b','c','d']
print('a' in l)
print('e' in l)
print('e' not in l)

True
False
True

Si un élément est présent dans une liste on peut récupérer son indice avec la méthode $\mathtt{index}$.

In [26]:
l=['a','b','c','d']
print(l.index('c'))

2
  • On peut trier une liste avec la méthode $\mathtt{sort}$. Si besoin on peut aussi retourner une liste avec la méthode $\mathtt{reverse}$.
In [27]:
l = [0,2,1,4,3]
l.sort()
print(l)

[0, 1, 2, 3, 4]
In [28]:
l = [0,2,1,4,3]
l.reverse()
print(l)

[3, 4, 1, 2, 0]
  • On peut aussi trier avec la fonction $\mathtt{sorted}$ dont le champ d'action est plus large que pour les listes.
In [2]:
l = [0,2,1,4,3]
l2 = sorted(l)
print("Liste dans l'ordre croissant : ",l2)

l3 = sorted(l, reverse=True)
print("Liste dans l'ordre décroissant : ",l3)

Liste dans l'ordre croissant :  [0, 1, 2, 3, 4]
Liste dans l'ordre décroissant :  [4, 3, 2, 1, 0]

Avec l'argument $\mathtt{key}$ on peut spécifier par rapport à quel élément on souhaite trier.

In [3]:
l = [(1,'b'), (3,'a'), (2,'c')]

print("Tri suivant le 1er élément : ",sorted(l, key= lambda x : x[0]))
print("Tri suivant le 2eme élément : ",sorted(l, key= lambda x : x[1]))

Tri suivant le 1er élément :  [(1, 'b'), (2, 'c'), (3, 'a')]
Tri suivant le 2eme élément :  [(3, 'a'), (1, 'b'), (2, 'c')]
  • Le type des éléments d'une liste étant quelconque, on peut alors faire des listes de listes...
In [29]:
m = [[1,2,3],[4,5,6]]
print(m)
print(m[1][2])

[[1, 2, 3], [4, 5, 6]]
6

Type $\mathtt{tuple}$ ¶

  • Le type $\mathtt{tuple}$ est défini avec ou sans parenthèses.
In [30]:
t = (1, 2, 3)
type(t)
Out[30]:
tuple
In [31]:
t = 1, 2
type(t)
Out[31]:
tuple
In [32]:
t = 1,
type(t)
Out[32]:
tuple

On peut récupérer ces éléments en utilisant leurs indices ou la syntaxe suivante

In [33]:
t = (1, 2, 3, 4)
a= t[0]
print(a)

# Si l'on veut donner un nom à tous les éléments
a, b, c, d = t
print(b)

# Si l'on ne veut que certains éléments
a, *l, d = t
print(a,l,d)

1
2
1 [2, 3] 4
  • Le type $\mathtt{tuple}$ est très proche du type $\mathtt{list}$ et de nombreuses opérations vues avec les listes restent valables.
In [34]:
t = (1, 2, 3, 4)
print(t[0])
print(t[:3])

t2 = t + (5,6)
print(t2)

print(3 in t2)

print(t2.index(3))

1
(1, 2, 3)
(1, 2, 3, 4, 5, 6)
True
2
  • Attention : une différence notable est que le type $\mathtt{tuple}$ est dit immutable . Cela signifie en particulier qu'on ne peut pas changer ses valeurs ou sa longueur.
In [35]:
t = (1,2)
t[0]=2

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-35-6b0b18175a0f> in <module>
      1 t = (1,2)
----> 2 t[0]=2

TypeError: 'tuple' object does not support item assignment
In [36]:
t = (1,2)
t.append(3)

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-36-78f6a6297cdf> in <module>
      1 t = (1,2)
----> 2 t.append(3)

AttributeError: 'tuple' object has no attribute 'append'
  • On peut convertir un $\mathtt{tuple}$ en $\mathtt{list}$ et réciproquement.
In [37]:
t = 1, 2, 3
print(t)
print(list(t))

l = [4,5,6]
print(l)
print(tuple(l))

(1, 2, 3)
[1, 2, 3]
[4, 5, 6]
(4, 5, 6)

Dictionnaires ¶

  • Un dictionnaire est un ensemble (donc non ordonné) de clés auxquelles on attribue des valeurs. Il est défini par des accolades. Par exemple, on attribue des valeurs à certaines lettres :
In [38]:
d = {'b':2, 'c':3, 'a':1}
print(d)

{'b': 2, 'c': 3, 'a': 1}
In [39]:
print(d['a'])

1

Là encore on peut mélanger plusieurs types.

In [40]:
d = { 1:2 , 'a':1, 'b':(1,2)}
print(d[1])
print(d['b'])

2
(1, 2)
  • La modification des valeurs se fait comme pour une liste. A la différence près que si on cherche à une modifier une valeur associée à une clé non présente dans le dictionnaire cela produira un ajout dans le dictionnaire.
In [41]:
d = {'b':2, 'c':3, 'a':1}
print(d)

d['c']=0
print(d)

d['d']=8
print(d)

{'b': 2, 'c': 3, 'a': 1}
{'b': 2, 'c': 0, 'a': 1}
{'b': 2, 'c': 0, 'a': 1, 'd': 8}
  • La suppression d'une clé se fait avec l'instruction $\mathtt{del}$. La valeur associée est automatiquement supprimée.
In [42]:
d = {'b':2, 'c':3, 'a':1}
print(d)

d2 = d.copy()

del d2['b']
print(d)
print(d2)

{'b': 2, 'c': 3, 'a': 1}
{'b': 2, 'c': 3, 'a': 1}
{'c': 3, 'a': 1}

Regardez la différence entre le résultat obtenu et le résultat suivant.

In [43]:
d = {'b':2, 'c':3, 'a':1}
print(d)

d2 = d    # ici d n'est pas copié : une modification de d2 entraine une modification de d

del d2['b']
print(d)
print(d2)

{'b': 2, 'c': 3, 'a': 1}
{'c': 3, 'a': 1}
{'c': 3, 'a': 1}
  • Les méthodes $\mathtt{keys}$ et $\mathtt{items}$ permettent de récupérer respectivement la liste des clés et la liste des couples (clés, valeurs).
In [44]:
d = {'b':2, 'c':3, 'a':1}

print(d.keys())
print(d.items())

dict_keys(['b', 'c', 'a'])
dict_items([('b', 2), ('c', 3), ('a', 1)])

Ce sont des itérables : on peut donc les utiliser dans une boucle $\mathtt{for}$

In [4]:
d = {'b':2, 'c':3, 'a':1}

for k in d.keys():
    print(d[k])

2
3
1

Symmétriquement la fonction $\mathtt{dict}$ construit un dictionnaire à partir d'une liste de couples (clés, valeurs).

In [45]:
l = [('a',1), ('b',2), ('c',3)]
d = dict(l)
print(d)

{'a': 1, 'b': 2, 'c': 3}

Ensembles : type $\mathtt{set}$ ¶

En $\texttt{Python}$ comme en mathématiques un ensemble est non ordonné. Il est défini par des accolades.

In [5]:
V = {1, 2, 3}
W = {3, 1, 2}

print(V == W)

True

On peut tester si un élément est présent ou non dans un ensemble

In [6]:
V = {1, 2, 3}

print(1 in V)
print(2 not in V)

True
False

On peut ajouter et enlever un élément dans un ensemble

In [7]:
V = {1, 2, 3}

V.add(4)
print(V)

V.remove(2)
print(V)

{1, 2, 3, 4}
{1, 3, 4}

On peut aussi réaliser les différentes opérations ensemblistes

In [9]:
V = {1,2,3} 
W = {3,4,5}

print("Union : ",V.union(W))
print("Intersection : ",V.intersection(W))
print("Difference : ",V.difference(W))

Union :  {1, 2, 3, 4, 5}
Intersection :  {3}
Difference :  {1, 2}

Tests et instructions conditionnelles ¶

  • Les tests classiques sont implémentés de la façon suivante : $\mathtt{==}$ pour l'égalité, $\mathtt{!=}$ pour la différence, $\mathtt{>}$ pour strictement supérieur, $\mathtt{<}$ pour strictement inférieur, $\mathtt{>=}$ pour supérieur ou égal et $\mathtt{<=}$ pour inférieur ou égal. Le résultat de ces tests est un booléen : $\mathtt{True}$ ou $\mathtt{False}$.
In [46]:
a=1
a+1 == 2
Out[46]:
True

Il peut être important de remarquer que pour des nombres le type n'importe pas lors du test.

In [47]:
print(1 == 1.0)
print(type(1) == type(1.0))

True
False
  • Les instructions conditionnelles sont implémentées par les mots clés $\mathtt{if}$, $\mathtt{elif}$ pour la disjonction de cas else if, et $\mathtt{else}$.

Chacune de ces instructions est suivie du symbole "$\mathtt{:}$" qui débute le champ d'action de l'instruction conditionnelle. Le champ d'action est délimité par l'indentation : en Python il n'y a pas de mot clé de fin d'instruction ! Cela sera aussi valable pour les boucles ou les fonctions. Regardez bien la différence entre les deux programmes suivants.

In [48]:
a=1
if a%2 == 0:
    a=a+1
    print(a)
# Rien ne se passe car "le print est dans le if"
In [49]:
a=1
if a%2 == 0:
    a=a+1
print(a)
# Le programme affiche a car "le print n'est pas dans le if"

1

Exemples d'utilisation

In [50]:
# L'utilisateur entre un nombre, le programme affiche la parité de ce nombre
a = int(input("Entrez un nombre :"))
if (a%2) == 0:
    print("Vous avez entré un nombre pair")
else:
    print("Vous avez entré un nombre impair")

Entrez un nombre :15
Vous avez entré un nombre impair
In [51]:
# Le même programme qui affiche un message différent si le nombre entré est 5
a = int(input("Entrez un nombre :"))
if a==5:
    print("C'est mon nombre préféré")
else:
    if (a%2) == 0:
        print("Vous avez entré un nombre pair")
    else:
        print("Vous avez entré un nombre impair différent de 5")

Entrez un nombre :15
Vous avez entré un nombre impair différent de 5
In [52]:
# Le même programme en utilisant elif
a = int(input("Entrez un nombre :"))
if a==5:
    print("C'est mon nombre préféré")
elif (a%2) == 0:
    print("Vous avez entré un nombre pair")
else:
    print("Vous avez entré un nombre impair différent de 5")

Entrez un nombre :15
Vous avez entré un nombre impair différent de 5

Boucles $\mathtt{while}$ et boucles $\mathtt{for}$ ¶

Boucles $\mathtt{while}$¶

  • L'implémentation de la boucle $\mathtt{while}$ est relativement standard.

Comme pour les instructions conditionnelles, la boucle démarre après le symbole "$\mathtt{:}$" et concerne toutes les lignes indentées.

In [53]:
i=0
while i<=5:
    print(i)
    i=i+1
print("la boucle est terminée")  # cette ligne n'est pas indentée donc ne fait pas partie de la boucle

0
1
2
3
4
5
la boucle est terminée
In [54]:
# Le même programme mais en n'affichant que les nombres pairs
i=0
while i<=5:
    if i%2 == 0:
        print(i)     # cette ligne est dans le if
    i=i+1            # cette ligne n'est pas dans le if mais est bien dans la boucle while
print("on a affiché les nombres pairs entre 0 et 5")

0
2
4
on a affiché les nombres pairs entre 0 et 5

Boucles $\mathtt{for}$¶

  • L'implémentation de la boucle $\mathtt{for}$ possède en Python possède quelques spécificités. La boucle $\mathtt{for}$ itère sur la liste passée en argument.

La première utilisation est classique.

In [55]:
for i in [0,1,2,3,4]:
    print(i,end=" ")    # le paramètre end évite ici les sauts de ligne

0 1 2 3 4

Il est bien sûr inevisageable de taper les listes $[0,1,2,3,4]$ à la main. Pour cela on va utiliser la fonction $\mathtt{range}$. Cette fonction produit une suite. Même si ce n'est pas tout à fait le cas on peut avoir en tête que $$ \mathtt{range}(N) = [0, 1, 2, \dots, N-1].$$ Donc $\mathtt{range}(N)$ contient $N$ éléments : le paramètre de fin est exclu. On peut préciser le paramètre de début. Alors $$ \mathtt{range}(\text{début}, \text{fin}) = [\text{début}, \text{début}+1, \dots, \text{fin}-1].$$ S'il y a trois arguments, le troisième est le pas de l'itération.

In [56]:
print("Utilisation de range avec un paramètre")
for i in range(5):
    print(i,end=" ")

print('\n')
print("Utilisation de range avec deux paramètres")
for i in range(2,7):
    print(i,end=" ")

print('\n')
print("Utilisation de range avec trois paramètres")
for i in range(2,12,2):
    print(i,end=" ")

print('\n')
print("Le pas peut être négatif. Observez bien le résultat.")
for i in range(8,2,-1):
    print(i,end=" ")

Utilisation de range avec un paramètre
0 1 2 3 4 

Utilisation de range avec deux paramètres
2 3 4 5 6 

Utilisation de range avec trois paramètres
2 4 6 8 10 

Le pas peut être négatif. Observez bien le résultat.
8 7 6 5 4 3

Ainsi, une possibilité pour parcourir une liste est :

In [57]:
l = [5,3,4,1,2]
for i in range(len(l)):
    print(l[i], end=" ")

5 3 4 1 2

En fait la boucle $\mathtt{for}$ itère sur les éléments présents dans la liste (ou le tuple ou la chaîne de caractères ou la suite fournie par $\mathtt{range}$) donnée en paramètre et pas sur un compteur. Le code précédent peut donc être simplifié.

In [58]:
# Itération sur une liste
l = [5,3,4,1,2]
for i in l:
    print(i, end=" ")
print()

# Itération sur une chaîne de caractères
s = "Test"
for i in s:
    print(i, end="-")   # on sépare les caractères par des -
print()

# Itération sur un tuple
t = 1, [2,3], 'a'
for i in t:
    print(i, end=" ")

5 3 4 1 2 
T-e-s-t-
1 [2, 3] a
  • Boucles $\mathtt{for}$ pour la génération d'itérables. On peut utiliser la syntaxe ci-dessous pour créer facilement des listes.
In [59]:
l = [i for i in range(10)]
print(l)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
In [60]:
l = [x**2 for x in range(10)]
print(l)

# On extrait un élément sur deux de la liste l
l2 = [l[i] for i in range(len(l)) if i%2 ==0]
print(l2)

# On ne garde que les éléments impairs de la liste l
l3 = [x for x in l if x%2 ==1]
print(l3)

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
[0, 4, 16, 36, 64]
[1, 9, 25, 49, 81]

Cette syntaxe est aussi valable pour les dictionnaires. Pour les tuples, il suffit de convertir la liste en tuple.

In [61]:
d = {j:j**2 for j in range(5)}
print(d)

t = [j for j in range(5)]
print(tuple(t))

{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
(0, 1, 2, 3, 4)

Les instructions $\mathtt{break}$ et $\mathtt{continue}$¶

Lorsqu'une boucle rencontre l'instruction $\mathtt{break}$ elle s'arrête.

In [62]:
for i in range(10):
    if i==5:
        break
    print(i, end=" ")

0 1 2 3 4
In [63]:
i=0 
while True:
    if i==5:
        break
    print(i, end=" ")
    i=i+1

0 1 2 3 4

Lorsqu'une boucle rencontre l'instruction $\mathtt{continue}$ elle arrête l'itération courante mais n'arrête pas la boucle.

In [64]:
for i in range(10):
    if i==5:
        continue
    print(i, end=" ")

0 1 2 3 4 6 7 8 9

Ainsi, le programme ci-dessous donnerait une boucle infinie

In [65]:
#i=0 
#while True:
#    if i==5:
#        continue
#    print(i, end=" ")
#    i=i+1

Procédures et fonctions ¶

  • La syntaxe pour définir les procédures et les fonctions est la même $\mathtt{def}$ nom_fonction(arguments):

La différence entre les deux étant la présence ou non de l'instruction $\mathtt{return}$. Une fois encore, la définition de la fonction se termine en même temps que l'indentation.

In [66]:
# Pour que ce tutoriel soit validé par l'académie des tutoriels, 
# on écrit une procédure qui affiche "Hello World!"

def ceci_est_un_vrai_tutoriel():
    print("Hello World!")
In [67]:
# La compilation précédente n'a aucune action car la fonction n'a pas encore été appelée
ceci_est_un_vrai_tutoriel()
# c'est maintenant le cas

Hello World!
In [68]:
# Et maintenant une fonction qui produit le même résultat
def ceci_est_un_vrai_tutoriel():
    return "Hello World!"

s = ceci_est_un_vrai_tutoriel()
print(s)

Hello World!
  • Une fonction ou une procédure n'a pas besoin de connaître le type de ses arguments. Elles peuvent même être utilisées avec des arguments de type différents.
In [69]:
def affiche(a):
    print(a)
affiche(1)
affiche("bonjour")

1
bonjour

Le résultat d'une procédure est de type $\mathtt{None}$

In [70]:
type(affiche(1))

1
Out[70]:
NoneType

Une fonction peut renvoyer un résultat de n'importe quel type.

  • Une fonction avec plusieurs paramètres
In [71]:
def somme(a,b,c):
    return a+b+c
somme(a=1,b=2,c=3)
Out[71]:
6

Lors de l'appel d'une fonction on peut spécifier le nom de certains arguments. Dans ce cas, l'ordre des paramètres n'a plus d'importance.

In [72]:
def retourne_b_et_pas_juste_le_deuxieme(a,b,c):
    return b
print(retourne_b_et_pas_juste_le_deuxieme(b=3,a=2,c=1))

3

Si l'on commence à mixer des arguments implicites (par leur position) et des arguments par leur nom on ne peut pas faire n'importe quoi...

In [73]:
somme(1,c=1,b=3) # Ceci est correct

somme(a=1,1,3)  # Ceci n'est pas possible car Python ne sait pas qui est b et qui est c

  File "<ipython-input-73-019255840396>", line 3
    somme(a=1,1,3)  # Ceci n'est pas possible car Python ne sait pas qui est b et qui est c
              ^
SyntaxError: positional argument follows keyword argument
  • On peut aussi donner une valeur par défaut à certains arguments. Si ces paramètres sont absents lors de l'appel alors ils prendront la valeur par défaut. Si des valeurs sont données elles écrasent les valeurs par défaut.
In [74]:
def forme_un_couple(a=0,b=1):
    return a,b

print(forme_un_couple())

print(forme_un_couple(5))

print(forme_un_couple(7,8))

print(forme_un_couple(b=5))

(0, 1)
(5, 1)
(7, 8)
(0, 5)

Importer une bibliothèque ¶

  • Il existe de très nombreuses bibliothèques en Python (voir https://pypi.org/). Nous allons voir rapidement comment importer une bibliothèque (ou une partie de la bibliothèque) et utiliser ce qu'elle contient. En guise d'exemple, nous allons utiliser la bibliothèque $\mathtt{math}$.
In [75]:
import math
# ce que contient la bibliothèque math est maintenant disponible. 

# Pour voir la liste de qu'elle contient on peut utiliser la commande dir(math)
#dir(math)

# l'affichage étant long, on affiche dans ce tutoriel seulement les 15 derniers éléments
contenu = dir(math)
for i in contenu[-15:-1]:
    print(i,",",end=" ")

modf , nan , perm , pi , pow , prod , radians , remainder , sin , sinh , sqrt , tan , tanh , tau ,

Cette bibliothèque contient par exemple la valeur de la constante $\pi$ ou la fonction trigonométrique $\sin$. Pour y accéder, on préfixe par le nom de la bibliothèque.

In [76]:
print(math.pi)
print(math.sin(0))

3.141592653589793
0.0
  • Plutôt que d'importer la totalité d'une bibliothèque, on peut importer seulement ce dont on a besoin. On remarquera qu'avec cette syntaxe on n'a plus besoin de préfixer par le nom de la bibliothèque.
In [77]:
from math import pi
print(pi)

3.141592653589793
In [78]:
from math import sin, cos 
print(sin(0)**2 + cos(0)**2)

1.0
  • Si besoin on peut au moment de l'import renommer la bibliothèque, la fonction ou la variable que l'on importe.
In [79]:
import math as ma
ma.pi
Out[79]:
3.141592653589793
In [80]:
from math import sin as sinus
from math import cos as cosinus
print(cosinus(12)**2 + sinus(12)**2)

1.0

Quelques bibliothèques pour faire des maths ¶

La bibliothèque $\mathtt{math}$¶

Elle a été rapidement vue dans le paragraphe Importer une bibliothèque.

Elle contient les principales constantes ainsi que les fonctions mathématiques usuelles.

La bibliothèque $\mathtt{random}$ ¶

  • La fonction principale est la fonction $\mathtt{random}$. C'est un générateur pseudo-aléatoire (basé sur l'algorithme Mersenne-Twister dont le fonctionnement n'est pas l'objet de cette section) simulant une loi uniforme sur l'intervalle $[0,1)$.
In [81]:
import random as rd

for i in range(5):
    print(rd.random())

0.3551520938304833
0.14269347885503014
0.7562712583156511
0.5757134159448596
0.3586063839070792

Pour fixer la graine du générateur on utilise la fonction $\mathtt{seed}$. Cela permet d'obtenir toujours le même résultat quand on relance le code.

In [82]:
import random as rd

for i in range(5):
    rd.seed(12)
    print(rd.random())

0.4745706786885481
0.4745706786885481
0.4745706786885481
0.4745706786885481
0.4745706786885481

Pour la loi uniforme sur l'intervalle $(a,b)$ on utilise la fonction $\mathtt{uniform}$. C'est l'équivalent de $a + (b-a)*\mathtt{random}$.

In [83]:
import random as rd

for i in range(5):
    print(rd.uniform(10,12))

11.314945005314511
11.332820942249676
10.285200705850736
10.021720886180136
10.749508984126729

Pour un tirage de nombres entiers entre $a$ et $b$ inclus, on utilise la fonction $\mathtt{randint}$.

In [84]:
import random as rd

for i in range(5):
    print(rd.randint(10,15))

12
15
13
15
14
  • Pour faire un tirage parmi un ensemble donné on utilise les fonctions $\mathtt{choices}$ (ou $\mathtt{choice}$ pour un seul élément) si l'on s'autorise des remises ou $\mathtt{sample}$ s'il n'y a pas de remise.
In [85]:
import random as rd

liste = ['a','b','c','d','e']
print("Choix d'un élément :",rd.choice(liste))
print("Choix de 5 éléments dans la liste avec remise :",rd.choices(liste,k=5))

print("Choix de 5 éléments dans la liste sans remise :",rd.sample(liste,5))

Choix d'un élément : b
Choix de 5 éléments dans la liste avec remise : ['c', 'd', 'a', 'c', 'a']
Choix de 5 éléments dans la liste sans remise : ['b', 'a', 'c', 'd', 'e']

La bibliothèque $\mathtt{NumPy}$ ¶

Le tutoriel de cette bibliothèque est détaillé ici

La bibliothèque $\mathtt{matplotlib.pyplot}$ ¶

Le tutoriel de cette bibliothèque est détaillé ici

Théorie des graphes : la bibliothèque $\mathtt{NetworkX}$ ¶

Le tutoriel de cette bibliothèque est détaillé ici

Statistiques : les bibliothèques $\mathtt{NumPy}$ et $\mathtt{Pandas}$ ¶

Le tutoriel de cette bibliothèque est détaillé ici

Pour aller plus loin en mathématiques :¶

la bibliothèque $\mathtt{SciPy}$ ¶

La bibliothèque $\mathtt{SciPy}$ possède de nombreuses sous-librairies permettant d'attaquer de nombreux problèmes mathématiques numériques :

  • l'intégration numérique ($\mathtt{integrate}$),
  • la résolution d'équations et l'optimisation ($\mathtt{optimize}$),
  • l'algèbre linéaire ($\mathtt{linalg}$),
  • l'interpolation ($\mathtt{interpolate}$) et les problèmes de clustering ($\mathtt{cluster}$),
  • les statistiques ($\mathtt{stats}$),
  • le traitement d'images ($\mathtt{ndimage}$) ou du signal ($\mathtt{signal}, \mathtt{fftpack}$)
  • ...

Une présentation rapide de quelques fonctionnalités est disponible à l'adresse https://www.southampton.ac.uk/~fangohr/teaching/python/book/html/16-scipy.html

Le tutoriel complet est accessible à l'adresse https://docs.scipy.org/doc/scipy/reference/tutorial/index.html

le logiciel $\mathtt{SageMath}$ ¶

Le logiciel $\mathtt{SageMath}$ écrit en $\mathtt{Python}$ permet de gérer le calcul formel. Un bref tutoriel est disponible à l'adresse http://mmorancey.perso.math.cnrs.fr/TutorielSage.html

Étant écrit en $\mathtt{Python}$ la syntaxe est très proche de celle décrite dans ce tutoriel. S'il est toujours possible d'y importer des modules, la plupart des fonctions utiles pour faire des mathématiques sont déjà présentes dans ce logiciel (mais parfois la syntaxe diffère, voir notamment le paragraphe sur l'algèbre linéaire).