1. Python - Le Langage

1.1. Historique

Le langage Python a été créé à partir de 1980 par Guido van Rossum et le nom Python fait référence au Monty Python's Flying Circus.

La première version (Python 0.9.0) date de Février 1991 et il a évolué jusqu'à la version 3 (Décembre 2008) pour gagner en maturité. Il est souvent enseigné comme premier langage de programmation, grâce à sa lisibilité et sa simplicité malgré quelques défauts liés à sa syntaxe et sa lenteur d'interprétation, son comportement erratique.

Python doit son succès :

• à sa syntaxe claire et lisible
• à un large écosystème de bibliothèques couvrant des domaines variés comme l'intelligence artificielle, le calcul scientifique, ou encore le développement web
• une communauté dynamique, en effet, Python bénéficie d'une communauté active qui contribue à son développement et à son adoption
• au fait qu'il permet de se concentrer sur les traitement des données et non sur des tâches de bas niveau (allocation mémoire, contrôle des indices des tableaux/listes)

Voici rapidement quelques spécificités du langage :

1.2. Documentation

• python.org, le site officiel
• documentation officielle

1.3. Editeur

Il est donc conseillé d'utiliser toujours le même environnement de développement (IDE). Parmi les IDE les plus populaires pour Python, on trouve :

• Visual Studio Code (Microsoft, Python : IntelliSense, débogage, Jupyter Notebook)
• PyCharm (JetBrains - Editeur complet avec autocomplétion, débogage, refactorisation, gestion des tests et virtualenvs
• Eclipse (Eclipse.org avec le plugin PyDev, environnement complet avec autocomplétion, refactorisation et débogage)
• Spyder (Anaconda, Spécialisé pour la science des données et le calcul scientifique)
• Netbeans (Apache - Extensible pour Python avec des plugins)
• Jupyter Notebook / JupyterLab (Interface web interactive pour l'exécution de code, idéal pour les données et la visualisation. )

1.4. Caractéristiques du langage

1.4.1. langage interprété

On peut, pour mieux appréhender ce concept, utiliser une analogie : imaginons que vous ne parliez que français et que vous soyez amené à consulter un livre en russe. Deux possibilités s'offrent à vous :

• soit faire traduire une bonne fois pour toute le livre du russe vers le français (compilation)
• soit demander à un interpréteur de vous traduire en direct le passage que vous désirez lire, cela prendra plus de temps et à chaque fois que vous aurez besoin de lire un passage il faudra faire appel une nouvelle fois à l'interprète

1.4.2. typage dynamique

1 + 2 => 3		int + int -> int

"bonjour " + "Jean-Michel" => "bonjour Jean-Michel" (str + str -> str, concaténation)

1 + "bonjour" => ?
TypeError: unsupported operand type(s) for +: 'int' and 'str'

"bonjour" + 1 =?> "bonjour1"
TypeError: can only concatenate str (not "int") to str

"bonjour" + str(1) => "bonjour1"

x = 1 (entier, int)
y = 3.14 (réel, float)
s = "bonjour" (chaine, str)

Notons que le typage dynamique est une notion qui est associée aux langages interprétés.

Par exemple en Python :

>>> x = 10
>>> type(x)
<class 'int'>
>>> id(x)	(adresse de x en mémoire)
11753896
>>> x = 3.14
>>> type(x)
<class 'float'>
>>> x = "coucou"
>>> type(x)
<class 'str'>
>>> x = [1,2,3]
>>> type(x)
<class 'list'>
>>> id(x)
123902002645824

1.5. Avantages et inconvénients

1.5.1. Avantages

• Python est un langage assez simple que l'on apprend facilement
• Python dispose de nombreuses bibliothèques (numpy, scipy, pyplot, pandas, scikitlearn, tensorflow, pytorch, django, ...) : le développement d'une application est rapide
• communauté de développement très importante et active
• portabilité : tout système d'exploitation

1.5.2. inconvénients

• Python est lent car interprété : cependant il peut être amélioré avec des librairies comme Cython, PyPy (Just-In-Time Compiler)
• Python est gourmand en mémoire
• pas forcément adapté à des projets lourds
• comportement erratique (i.e. qui ne manifeste aucune tendance cohérente)
  Afficher le code    ens/l1/python1/langage/python_erratique.py

  1. # ===================================================================
  2. # créer une matrice
  3. # l'écriture suivante pose problème car 'ligne' est trois fois
  4. # la même variable, donc si on modifie un élément de ligne il
  5. # est répercuté sur les autres lignes
  6. # ===================================================================
  7. ligne = [0, 0, 0, 0, 0]
  8. matrice = [ ligne, ligne, ligne ]
  9.  
  10. matrice[0][3] = 1
  11. print(matrice)
  12. # [[0, 0, 0, 1, 0], [0, 0, 0, 1, 0], [0, 0, 0, 1, 0]]
  13.  
  14. # ===================================================================
  15. # oubli
  16. # au lieu d'écrire t[i] == True, on a écrit :
  17. # mais Python n'indique aucune erreur !!
  18. # ===================================================================
  19. i = 1
  20. if [i] == True:
  21.   print("ici")
  22. else:
  23.   print("non, ici !")
  24.  
  25. # ===================================================================
  26. #
  27. # modification d'un élément répercutée sur la liste passée en
  28. # paramètre dans f(x) : ok
  29. #
  30. # ===================================================================
  31. def f(x):
  32.     x[3] = 99
  33.  
  34. z = [0 for _ in range(5)]
  35.  
  36. print(z) # [0, 0, 0, 0, 0]
  37. f(z)
  38. print(z) # [0, 0, 0, 99, 0] OK !
  39.  
  40. # ===================================================================
  41. #
  42. # modification de la structure non répercutée sur la liste x : ko
  43. #
  44. # ===================================================================
  45. def power(x, d):
  46.     if d <= 0:
  47.         for i in range(len(x)):
  48.             x[i] = 0
  49.  
  50.     x = x[d:]           # x = [0,99,0]
  51.     x = x + [0] * d     # x = [0,99,0,0,0]
  52.     # mais manque un "return x"
  53.    
  54. power(z, 2)
  55. print(z) # [0, 0, 0, 99, 0] au lieu de [ 0, 99, 0, 0, 0]
  56.  
  57. # ===================================================================
  58. #
  59. # objet mutable en paramètre
  60. #
  61. # ===================================================================
  62. def func(a, L=[]):
  63.   for i in range(a):
  64.     L.append(i)
  65.   return L
  66.  
  67. # premier appel, L est créée puis vaut [0,1] 
  68. print(func(2))
  69. # second appel, L n'est pas recréée donc L = [0, 1, 0, 1, 2]
  70. print(func(3))
  71.  
  72.  

1.6. Les types de données

Nous allons nous intéresser principalement aux types de données suivants :

• booléens (bool) : True, False
• entiers (int) : 1234, -789999
• range (intervalle entiers - range(a,b,c)) : range(1,10), range(20,1,-1)
• chaînes de caractères ("str") : "bonjour", f"x={x}", b"hello"
• nombres flottants (réels - float)
• listes ($≈$ tableaux [ list ])
• les tuples (listes non modifiables ( tuple ))
• dictionnaires (mapping - { dict })
• ensembles ({ set })

Il existe également d'autres types que nous ne verrons pas dans ce cours : complex, function, frozenset, bytes, bytearray, memoryview, ...

# chaine vers entier
entier = int("125")

# entier vers réel
reel = float(123)

# réel vers entier => 3
entier = int(3.14)

# ensemble vers liste
liste = list({1,2,3})

# liste vers ensemble => { 1,2,3 }
ensemble = set([1, 2, 3, 3, 3, 2, 1, 3])

# Exemple
est_vrai = True
print(type(est_vrai))  # Résultat : <class 'bool'>

# Exemple
nombre = 42
print(type(nombre))  # Résultat : <class 'int'>

# Exemple
r = range(10)
print(list(r)) # Résultat : [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

r = range(1,10)
print(list(r))  # Résultat : [1, 2, 3, 4, 5, 6, 7, 8, 9], <class 'range'>

r = range(4,1,-1)
print(list(r))  # Résultat : [4,3,2]

# Exemple
nombre_decimal = 3.14
epsilon = 8.91e-7
print(type(nombre_decimal))  # Résultat : <class 'float'>

# Exemple
texte = "Bonjour, Python !"
print(type(texte))  # Résultat : <class 'str'>

# Exemple
une_longue_chaine = '''Bonjour, Python !
voici une chaine sur 
plusieurs lignes'''
print(type(une_longue_chaine))  # Résultat : <class 'str'>

ord("A")
65
ord("€")
8364 
print(chr(65))
A
print(chr(8364))
€

x = 1
pi = 3.14
print(f"{x} {pi/60} {f(3)}") # Résultat 1 0.052333333333333336 9

x=3
y=4
pi=3.1415927

# x sur 6 caractères, y sur 6 caractères mais précédé par des 0
# pi avec 4 chiffres après la virgule (arrondi)

print(f"{x:6d} {y:06d} {pi:.4f}") 

# donne
# ␣␣␣␣␣3 000004 3.1416

# Exemple
ma_liste = [1, 2, 3, "Python", True]
print(type(ma_liste))  # Résultat : <class 'list'>
print(ma_liste[3]) # Résultat : Python

# Exemple
ma_liste = [1, 2, 3, "Python", True]
print(len(ma_liste))  # Résultat 5

présence
absence

['fiat', 'peugeot', 'renault']
['audi', 'fiat', 'peugeot', 'renault']

['peugeot', 'renault', 'toyota']
['peugeot', 'renault', 'toyota', 'volkswagen']

['audi', 'citroën', 'fiat', 'peugeot', 'renault']
['audi', 'fiat', 'hyundai', 'peugeot', 'renault']

['fiat', 'peugeot', 'renault']
['peugeot', 'renault']

['audi', 'fiat', 'peugeot']
['audi', 'fiat']

['audi', 'fiat', 'renault', 'volkswagen']
['audi', 'fiat', 'volkswagen']
['audi', 'volkswagen']

[ nouvel_élément for élément in iterable if condition]

liste = [x for x in range(5)]
print(liste)  # [0, 1, 2, 3, 4]

liste = []
for x in range(5):
	liste.append(x)

combinaisons = [(x, y) for x in range(2) for y in range(2)]
print(combinaisons)  # [(0, 0), (0, 1), (1, 0), (1, 1)]

liste_de_zeros = [0 for _ in range(5)]
print(liste_de_zeros)  # Résultat : [0, 0, 0, 0, 0]

pairs = [x for x in range(10) if x % 2 == 0]
print(pairs)  # [0, 2, 4, 6, 8]

# Exemple
mon_tuple = (1, 2, 3, "Python")
print(type(mon_tuple))  # Résultat : <class 'tuple'>
print(t[0]) # Résultat : 1
print(t[3]) # Résultat : Python

# Exemple
mon_dico = {"nom": "Alice", "âge": 30}
print(type(mon_dico))  # Résultat : <class 'dict'>
print(mon_dico["nom"]) # Résultat : "Alice"

mon_dico = { 1: "rouge", 2:"vert", 3:"bleu", 0:"noir" }
print(mon_dico.values())
# Résultat : dict_values(['rouge', 'vert', 'bleu', 'noir'])
print(mon_dico.keys())
# Résultat : dict_keys([1, 2, 3, 0])
print(mon_dico.items())
# Résultat : dict_items([(1, 'rouge'), (2, 'vert'), (3, 'bleu'), (0, 'noir')])

bleu
clé absente

{3: 'bleu', 0: 'noir', 2: 'vert'}
{3: 'bleu', 0: 'noir', 2: 'vert', 1: 'rouge'}

{0: 'noir', 2: 'vert', 1: 'rouge'}
rouge
{0: 'noir', 2: 'vert'}

# Exemple
mon_ensemble = {1, 2, 3, 3, 2, 1, 3}
print(mon_ensemble)  # Résultat : {1, 2, 3}
print(type(mon_ensemble))  # Résultat : <class 'set'> 

print(mon_ensemble[0]) # Résultat : 1

3 est présent
4 n'est pas présent

{{1, 2, 3, 4}
{1, 2, 3, 4, 5, 6}

{1, 3, 5, 7, 9, 11, 13, 15}
3 est dans l'ensemble
3 n'est pas dans l'ensemble
1
 0 => 5
 1 => 7
 2 => 9
 3 => 11
 4 => 13
 5 => 15

<class '_io.TextIOWrapper'>

['Bonjour le monde !\n', 'lorem ipsum dolor\n']
<class '_io.TextIOWrapper'>

1.7. Les instructions

1.7.1. L'instruction if-elif-else

Le if appelée conditionnelle permet de réaliser un traitement si une condition est vraie :

valeurs valides

1.7.2. L'instruction match

Le match (encore appelé switch ou case of dans d'autres langage) et l'équivalent d'un if mais ne s'applique la plupart du temps qu'à des valeurs scalaires comme les entiers :

a=2

1.7.3. L'instruction while

Le while permet de réaliser le même traitement en boucle tant qu'une condition est vraie :

1
4	

1.7.4. L'instruction for

Le for est utilisé pour parcourir containers (list, dict) ou des itérateurs (range) :

0
1
2
3
4
5
6
7
8
9

1
2
3
4
5
6
7
8
9

renault
peugeot
fiat
volkswagen
audi

0 renault
1 peugeot
2 fiat
3 volkswagen
4 audi
0 noir
1 bleu
2 rouge
3 vert
0 noir
1 bleu
2 rouge
3 vert

1.7.5. L'instruction print

Elle permet l'affichage d'information à l'écran ou l'enregistrement d'information dans un fichier au format texte. Son prototype est le suivant :

print(*args, sep=' ', end='\n', file=None, flush=False)

On affiche un ensemble d'arguments (args) qui sont des entiers, des flottant, decs chaînes, etc.

• sep représente le séparateur entre les arguments, par défaut c'est un espace
• end est le caractère affiché après avoir réalisé print, par défaut c'est le retour à la ligne mais on peut le remplacer par un caractère vide end='' pour continuer à écrire sur la même ligne
• file est un fichier si on ne veut pas écrire sur la sortie standard
• flush indique si on doit vider le flux d'affichage après print

Bonjour***le--monde--!

1.7.6. L'instruction input

Elle permet de récupérer une chaîne saisie au clavier et terminée par un retour chariot qui ne sera pas pris en compte. Son format est le suivant :

input(prompt='')

saisir un entier:70
<class 'str'> <class 'int'>
70
saisir 3 prénoms: jean-michel karla sarah
jean-michel karla sarah

1.8. Les sous-programmes (procédures et fonctions)

Un sous-programme est introduit par le mot clé def suivi du nom du sous-programme et de ses paramètres :

• une fonction est un sous-programme qui retourne une valeur
• une procédure est un sous-programme qui ne retourne pas de valeur : la valeur obtenue sera None

Il est nécessaire d'ajouter des commentaires aux sous-programmes afin d'indiquer à d'autres personnes qui voudraient les utiliser, comment ils fonctionnent :

1.8.1. Valeur de retour

Une fonction peut retourner plusieurs valeurs :

on récupère les résultats dans deux variables différentes
9 5
on récupère les résultats sous forme d'un tuple
(7, 3)
on ne récupère que le reste
3

1.8.2. Passage par valeur et par adresse

Pour simuler un passage par adresse avec des objets immuables, on peut encapsuler la valeur dans un objet mutable comme une liste ou un dictionnaire :

1.8.3. Typage des paramètres et du type de retour

Le typage des paramètres et des valeurs de retour des fonctions a pour objectif :

• d'améliorer la qualité du code (lisibilité, robustesse, maintenabilité)
• de faciliter la collaboration et la documentation
• d'aider à prévenir les erreurs grâce à l’analyse statique

Cependant, le typage en Python :

• est facultatif et n’est pas enforçable à l’exécution
• nécessite des outils externes comme mypy pour tirer pleinement partie de ses avantages
• peut ajouter un peu de complexité ou de verbosité, surtout pour les fonctions complexes

Par exemple dans le code suivant, bien qu'on ait spécifié que la fonction addition prenait des paramètres entiers, il est toujours possible de passer des chaînes :

Voici quelques exemples de typage de base ainsi que l'utilisation du package typing :

1.8.4. Les fonctions intégrées

Une fonction intégrée est une fonction propre au langage et peut parfois être appliquée à différents types :

1.8.4.a  Les fonctions de base

• len() : renvoie la longueur d'un objet (list, chaîne, dictionnaire)
• type() : renvoie le type de l'objet
• print() : affiche un message ou une valeur
• id() : renvoie l'identifiant unique d'un objet
• isinstance() : vérifie si un objet est une instance d'une classe

1.8.4.b  Les fonctions numériques

• abs() : valeur absolue
• round() : arrondi au plus proche
• pow() : exponentiation (équivalent à **)
• divmod() : renvoie le quotient et le reste de la division
• min(), max() : valeurs minimale et maximale
• sum() : somme des éléments d'un itérable

1.8.4.c  Les fonctions liées aux chaînes et objets itérables

• all() : renvoie True si tous les éléments d'un itérable sont vrais
• any() : renvoie True si au moins un élément est vrai
• sorted() : renvoie une version triée d'un itérable
• reversed() : renvoie un itérable inversé
• enumerate() : renvoie un itérable avec indices
• filter(): filtre les éléments d'un itérable.
• map() : applique une fonction à tous les éléments d'un itérable
• zip() : regroupe plusieurs itérables

1.8.4.d  Les fonctions liées aux types

• int(), float(), str(), bool() : conversions de types
• list(), tuple(), set(), dict() : crée ou convertit des types de collections
• bytes(), bytearray() : manipulation des données binaires
• complex() : crée un nombre complexe

1.8.4.e  Les fonctions liées aux entrées / sorties

• open() : ouvre un fichier
• input() : lit une chaîne au clavier
• exit(), quit() : quitte le programme

1.9. Packages et import

Lorsque l'on crée un fichier Python, l'ensemble des variables globales et sous-programmes qu'il définit peuvent être réutilisés dans un autre fichier.

Imaginons que vous avons le fichier suivant fonction.py :

Afin d'utiliser dans un autre fichier Python, les sous-programmes qu'il définit, trois possibilités s'offrent à nous :

• utiliser le nom du fichier en tant que préfixe de référence
• renommer le nom du fichier pour utiliser un autre préfixe : en général plus court pour avoir moins à écrire
• importer l'ensemble des fonctions et variables globales et y faire référence sans préfixe : il ne faut pas qu'il y ait de conflit avec un autre fichier

1.9.1. import du fichier

[-2.  -1.5 -1.  -0.5  0.   0.5  1.   1.5]
-2.000  4.00 -3.999999975690116
-1.500  2.25 -2.999999981767587
-1.000  1.00 -1.9999999989472883
-0.500  0.25 -0.9999999883714139
0.000  0.00 1e-08
0.500  0.25 1.0000000161269895
1.000  1.00 1.999999987845058
1.500  2.25 2.999999981767587

1.9.2. import du fichier avec renommage

1.9.3. import de tous les éléments du fichier

1.9.4. version d'un package

Certains packages nécessitent une version particulière d'un autre package pour pouvoir fonctionner correctement.

On peut connaître la version d'un package :

Soit en ligne de commande :

\$ pip list | grep numpy
numpy                       1.26.4

Soit dans l'interpréteur Python ou n exécutant un programme :

\$ python3
Python 3.12.3 (main, Nov  6 2024, 18:32:19) [GCC 13.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import numpy
>>> print(numpy.__version__)
1.26.4

1.10. Amélioration de l'efficacité du code

Voici un petit exemple qui montre comment utiliser pythran afin d'améliorer le temps d'exécution d'un programme Python.

1.10.1. Sans pythran

On considère le module suivant qui fournit une fonction somme_sin_cos :

On importe le package math de Python.

Ainsi que le programme qui utilise cette fonction :

Si on exécute simplement ce programme en Python sur un AMD Ryzen 5 5600G, on obtient :

\$ time python3 utilisation_calcul.py
temps d'exécution= 7.702448606491089
résultat=35401505.8430852

real	0m8,248s
user	0m8,253s
sys	0m0,753s

Soit un temps d'exécution total de $8,253$ secondes dont $7,702$ secondes pour exécuter le code de la fonction somme_sin_cos.

1.10.2. Avec pythran

Il suffit de précompiler le code grâce à la commande qui suit, ce qui crée le fichier calcul.cpython-312-x86_64-linux-gnu.so :

\$ pythran calcul.py>
\$ ls *.so
calcul.cpython-312-x86_64-linux-gnu.so

Ici cela ne fonctionne uniquement parce qu'on a ajouté une directive :

pythran export somme_sin_cos(float64[])

devant la fonction à optimiser qui indique quel type de donnée est fourni en entrée à la fonction. Pythran génère alors du code assembleur tout comme le ferait un compilateur C/C++.

Si maintenant on exécute le code comme précédemment, Python va utiliser le fichier objet partagé, mais cela est transparent pour l'utilisateur :

\$ time python3 utilisation_calcul.py
temps d'exécution= 0.9642660617828369
résultat=35404787.98554713

real	0m1,505s
user	0m1,502s
sys	0m0,761s

On met alors moins d'une seconde pour exécuter la fonction compilée.

Dans le fichier .so, on retrouve le code assembleur qui correspond au calcul :

3d80:       movsd  xmm0,QWORD PTR [r15]                  ; charger x ou t[i]
3d85:       mov    rsi,rbp 
3d88:       mov    rdi,r12
3d8b:       add    r15,0x8
3d8f:       call   2420 < sincos@plt>                    ; calculer sin(x) et cos(x)
3d94:       movsd  xmm0,QWORD PTR [rsp+0x18]               
3d9a:       mulsd  xmm0,QWORD PTR [rsp+0x10]             ; multiplier sin(x) par cos(x)
3da0:       addsd  xmm0,QWORD PTR [rsp]                  ; ajouter au résultat
3da5:       movsd  QWORD PTR [rsp],xmm0
3daa:       cmp    rbx,r15                               ; continuer tant qu'on est pas
3dad:       jne    3d80 <PyInit_calcul@@Base+0xa10>      ; à la fin du tableau
3daf:       lea    rdi,[rsp+0x40]

La fonction sincos appartient normalement à la librairie mathématique et son protoype est __sincos (double x, double *sinx, double *cosx).

Pour résumer :

On notera cependant qu'on n'obtient pas le même résultat car les valeurs ne sont pas les mêmes dans les deux cas.