Python sans détour

de l'addition au deep learning

par

Laurent Berger

Pascal Guézet

Python sans détour • de l'addition au deep learning

par Laurent Berger, Pascal Guézet

ISBN (EPUB) : 978-2-8227-1067-1

Copyright © 2022 Éditions D-BookeR

Tous droits réservés

Conformément au Code de la propriété intellectuelle, seules les copies ou reproductions strictement réservées à l'usage privé du copiste et non destinées à une utilisation collective ainsi que les analyses et les courtes citations dans un but d'exemple et d'illustration sont autorisées. Tout autre représentation ou reproduction, qu'elle soit intégrale ou partielle, requiert expressément le consentement de l'éditeur (art L 122-4, L 122-5 2 et 3a).

Publié par les Éditions D-BookeR, 229 rue Solférino, 59000 Lille

www.d-booker.fr

contact@d-booker.fr

Les exemples (téléchargeables ou non), sauf indication contraire, sont propriété des auteurs.

Conception de la couverture : d'après une création de Marie Van Der Marlière (www.marie-graphiste.com)

Visuel de couverture : dessiné par ZdenekSasek (#35068620 sur Vectorstock)

Mise en page : générée sous Calenco avec des XSLT développées par la société NeoDoc (www.neodoc.biz)

Date de publication : Mai 2022

Édition : 1

Version : 1.02

À propos des auteurs

Laurent Berger

Laurent Berger est maître de conférences à l'université du Mans. Ses principaux travaux de recherche portent sur la simulation numérique des systèmes magnétiques et du traitement des images en microscopie et en instrumentation météorologique. Les cours de langage Python donnés en premier cycle d'université sont basés sur une évaluation formative favorisant ainsi l'autonomie de l'étudiant ou du stagiaire.

Pascal Guézet

Après avoir travaillé dans le secteur de l'informatique et de l'électronique, Pascal Guézet enseigne aujourd'hui le langage Python en bac Pro Systèmes Numériques et à l'IUT du Mans. Depuis les années 1980, il a développé des applications en C, C++ puis en Python pour améliorer la productivité des chaînes de fabrication, gérer des réseaux informatiques et traiter des données.

Introduction

Python est un langage de programmation interprété sous licence libre. Il est disponible sous Windows, macOS et Linux. De très nombreuses bibliothèques spécialisées dans tous les domaines viennent le compléter. La simplicité d'installation de ces bibliothèques contribue à faire son succès.

Dans ce livre, nous avons choisi de vous introduire de manière synthétique les bases du langage dans une première partie et de vous montrer dans les autres chapitres comment utiliser Python dans différentes situations.

Pour lire ce livre, vous pouvez suivre l'ordre des chapitres mais aussi aller directement au chapitre application qui vous intéresse. En effet, les cas d'utilisation sont pourvus de nombreux renvois vers la partie Bases et prérequis vous expliquant les techniques Python utilisées.

Dans le chapitre Ouvrir et écrire des fichiers, on aborde la lecture et l'écriture des fichiers mais aussi la gestion de documents de type tableur Excel ou LibreOffice ou bien de traitement de texte comme Word ou LibreOffice.

Dans le chapitre Extraire des informations du Web, on présente comment automatiser des recherches ou bien remplir des formulaires avec Python ou encore extraire des pages web afin de les consulter en local.

Dans le chapitre Calcul scientifique et tracé de courbes , on présente les tableaux de NumPy et on voit comment tracer des courbes avec Matplotlib.

Dans le chapitre Image, son et vidéo, on présente la lecture d'images, de sons et de vidéos et comment enregistrer une vidéo avec le son synchronisé avec l'image.

Dans le chapitre Géographie, on utilise Python pour extraire des cartes, calculer un itinéraire et le tracer sur une carte.

Dans le chapitre Interfaces graphiques utilisateur, on présente les bases des gestionnaires de fenêtres et des widgets.

Dans le dernier chapitre Utilisation du deep learning, on utilise Python pour identifier des objets dans une vidéo ou flouter les personnes.

La version de Python utilisée dans le livre est la version 3 du langage Python, plus précisément la version 3.9.7 ou la version 3.10. Le module wxPython n'est pas disponible pour la version 3.10 en mars 2022. La version bêta nommée wxPython310 peut la remplacer en attendant la sortie définitive.

Les codes sources des exemples sont disponibles sur le dépôt GitHub Python-sans-detour. Ceux de la première partie Bases et prérequis ont été regroupés au sein du dossier chapitre_bases. Et ceux de la seconde partie Pratique de Python sont classés par chapitre et par thème. Nous vous indiquons au fur et à mesure dans quel dossier ils se trouvent. Par ailleurs, vous pouvez afficher séparément, sur une tablette ou un smartphone, les listings les plus longs avec leurs références numérotées pour les visualiser en regard des explications. Il suffit pour cela de cliquer sur le picto qui les précède. La partie du listing concernée s'affiche alors dans votre navigateur web.

En plus du livre, le site https://auto-apprentissage.traimaocv.fr fournit des exercices de base sur le langage Python. L'inscription est gratuite et un forum d'entraide permet de poser des questions sur des points particuliers.

1. URL raccourcies

Dans un souci de lisibilité, et pour pouvoir les maintenir à jour, nous avons pris le parti de remplacer la plupart des adresses internet par ce qu'on appelle des URL raccourcies. Une fois que vous avez accédé à la page cible, nous vous invitons à l'enregistrer avec un marque-page si vous souhaitez y revenir fréquemment. Vous disposerez alors du lien direct. Si celui-ci se périme, n'hésitez pas à repasser par l'URL raccourcie. Si cette dernière aussi échoue, vous pouvez nous le signaler  !

Note > Les adresses laissées en clair correspondent à des renvois vers les principales documentations officielles. En cas d'obsolescence d'un lien remontez, via l'url, au dossier parent ou passez par le champ recherche et saississez le nom de l'élément sur lequel vous souhaitez plus d'informations.

2. Réglage de la largeur de l'écran

Vous trouverez de nombreux exemples de code, formatés dans une police à chasse fixe. Afin d'éviter des retours à la ligne inopportuns à l'intérieur d'une ligne de code, la longueur maximale des lignes de code a été fixée à 75 caractères, une valeur suffisamment basse pour être affichée sur la plupart des supports, tout en étant suffisante pour que le code puisse être correctement formaté.

Toutefois, il est possible que sur votre support la largeur maximale affichable soit inférieure à la limite fixée. Le paragraphe test ci- dessous permet de vérifier votre affichage. Il doit tenir sur deux lignes exactement :

000000000011111111112222222222333333333344444444445555555555666666666677777
0123456789012345678901234567890123456789012345678901234567890123456789012345

Si ce n'est pas le cas, regardez si vous pouvez agrandir la taille de la fenêtre, diminuer la taille des marges ou diminuer la taille de la police d'affichage. Sur un téléphone portable, placez-le plutôt en mode paysage. Si vous n'y arrivez pas, ne vous inquiétez pas pour autant, la plupart des lignes de code sont inférieures à 75 caractères.

Bases et prérequis

Le premier chapitre de cette partie présente les fondamentaux de Python. On commence par le mode console. Ce mode permet un premier contact avec Python de manière interactive. En l'utilisant, on introduit les notions de types numériques, chaînes de caractères et booléens, et de variables ; on définit la bibliothèque standard et comment étendre les possibilités de Python via l'import. Pour finir, on introduit les outils élémentaires permettant d'écrire un programme Python et comment l'exécuter.

Dans les trois chapitres suivants, on présente les principaux types de données, les structures de contrôle et les fonctions de Python. Le chapitre suivant expose la structure d'un programme et la notion de qualité du code avec les outils qui nous permettent d'évaluer cette qualité. Enfin, dans les deux derniers chapitres, on aborde la notion d'exception et les éléments de programmation objet utilisés dans ce livre.

Premier contact

Le mode console permet de nous familiariser avec Python. Dans ce mode, on peut entrer une ou plusieurs commandes Python. L'utilisation des raccourcis clavier facilite leur saisie. Les résultats des commandes ou des calculs ont un type comme int, float ou string. Ils en existent bien d'autres que l'on verra dans le chapitre suivant. Les variables sont utilisées pour nommer des valeurs pouvant évoluer au cours du temps en fonction des calculs à faire.

Les programmes Python s'écrivent dans un fichier texte, que vous pouvez saisir dans votre éditeur préféré ou dans votre environnement Python préféré. On peut exécuter le programme soit à partir du terminal, soit à partir du mode ligne de commande.

1. Lancer et utiliser la ligne de commande

Après le lancement de Python, une fenêtre s'ouvre et un curseur apparaît précédé de trois signes > (>>>), appelés invite de commande. Cette fenêtre est l'interface de ligne de commande [Command Line Interface ou CLI en anglais]. Elle va nous permettre d'entrer des commandes Python et de voir le résultat immédiatement. Par exemple, si vous entrez 2+3 et appuyez sur la touche Entrée [ou Return], le résultat 5 s'affichera :

Python 3.10.2 (tags/v3.10.2:a58ebcc, Jan 17 2022, 14:12:15) [MSC v.1929 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> 2 + 3
5
>>>

PEP 8 ou guide pour l'écriture du code Python

PEP 8 définit un ensemble de recommandations pour écrire du code Python. Ces recommandations s'appliquent aux noms des variables, des fonctions, des méthodes, à l'insertion des espaces, à la documentation, etc. Beaucoup de programmeurs Python suivent ces recommandations favorisant ainsi un code homogène et documenté. Si vous débutez en programmation Python, essayez autant que possible de vous y conformer.

2. Calculer : int et float

Vous pouvez utiliser cette fenêtre comme une machine à calculer :

>>> 2 + 3*5
17

On a laissé volontairement un espace autour du signe + pour suivre les recommandations PEP 8. La présence d'un espace indique que l'opérateur n'est pas prioritaire, ce qui est le cas puisque la multiplication est faite avant l'addition : on dit que la multiplication est prioritaire par rapport à l'addition (ou la soustraction). Par ailleurs, on n'a pas mis d'espaces autour du signe * pour indiquer qu'elle sera faite avant l'addition. Si on veut effectuer l'addition avant la multiplication, on doit utiliser les parenthèses et modifier les espaces autour des opérateurs :

>>> (2+3) * 5
25

La division est aussi prioritaire par rapport à l'addition (ou la soustraction) :

>>> 5 + 10/2
10.0

Le résultat est affiché avec une partie décimale. Il est dit du type nombre décimal ou float [qui signifie décimal en anglais]. Le symbole pour indiquer la partie décimale est le point ("."). Ceci est vrai quels que soient les paramètres régionaux choisis sur votre ordinateur. Lorsque le résultat est sans partie décimale, comme dans les deux premiers exemples 17 et 25, le résultat est du type entier ou int [abrégé de integer en anglais].

Note > Les types int et float sont présentés plus en détail au chapitre suivant.

Recommandations PEP 8 pour la gestion des espaces autour des opérateurs

Un opérateur est un symbole spécifiant une opération. L'opérateur de l'addition est le symbole +.

Les opérateurs (+, –, *, /) doivent être précédés et suivis d'un espace lorsqu'ils sont seuls sur une ligne.

Si la priorité des opérations est différente, on peut enlever les espaces autour des opérations effectuées en premier.

Les opérations addition, soustraction, multiplication et division sont représentées par les symboles + , – , * et /. On peut utiliser les opérateurs // ( deux symboles / consécutifs) et % ( symbole du pourcentage) pour obtenir le quotient de la division euclidienne de deux nombres et le reste de la division euclidienne :

>>> 29 // 3
9
>>> 29 % 3
2
>>> 9*3 + 2
29

Bon, ce n'est pas exactement la division euclidienne car on peut effectuer l'opération avec des nombres de type float (nombre à virgule) :

>>> 5.2 // 2.5
2.0
>>> 5.2 % 2.5
0.20000000000000018

L'idée de la division euclidienne reste : en 5.2 il y a deux fois 2.5 et le reste est de 0.20000000000000018. Ce reste devrait être de 0.2 mais la représentation des nombres float provoque des erreurs d'arrondis. Le lecteur intéressé pourra consulter la page Wikipédia sur la représentation en virgule flottante.

Pour élever un nombre à la puissance, on utilise l'opérateur ** (deux étoiles consécutives) :

>>> 2 ** 3
8
>>> 2 * 2 * 2
8
>>> pow(2, 3)
8

L'opérateur **, élévation de x à la puissance y (x ** y), est équivalent à l'appel de la fonction pow(x, y).

Raccourcis clavier en mode console

Pour retrouver l'historique des commandes, il suffit d'appuyer sur la touche clavier flèche vers le haut. Les raccourcis claviers utilisables en ligne de commande dépendent de votre plate-forme. La souris est généralement inutilisable en mode console. Il vaut mieux l'oublier.

Tableau .1 : Principaux raccourcis en mode console pour Windows, macOS, Linux bash

Action
Windows
macOS
Linux bash

curseur insertion en début de ligne
Home ou ↖
Ctrl+A
Home ou ↖
ou Ctrl+A

curseur insertion en fin de ligne
Fin (ou End)
Ctrl+E
Fin (ou End)
ou Ctrl+E

commande précédente dans l'historique
flèche vers le haut (ou ↑ )
Ctrl+P (ou ↑ )
Ctrl+P (ou ↑ )

commande suivante dans l'historique
flèche vers le bas (ou ↓ )
Ctrl+N (ou ↓ )
Ctrl+N (ou ↓ )

répéter la commande précédente
F3
↑ + Entrée
↑

coller
Maj+Ins
(Maj+Insér)
Cmd+C
Maj+Ins
(Maj+Insér)

affichage de l'historique dans une fenêtre
F7

bascule en mode Plein écran
F11 ou Alt+Enter (Alt+Entrée)
Ctrl+Cmd+F
Méta (touche Windows)+Pg Prec

3. Manipuler des caractères : str

Pour manipuler des caractères, il faut délimiter ceux-ci soit entre deux guillemets droits " (symbole sur la touche du chiffre 3), soit entre deux apostrophes ou guillemets simples ' (symbole sur la touche du chiffre 4). On parle alors de chaîne de caractères ou str [abrégé de string en anglais].

>>> 'c est facile'
'c est facile'

Si l'on veut ajouter l'apostrophe, alors on doit utiliser le caractère " comme délimiteur :

>>> "c'est facile"
"c'est facile"

On peut ajouter deux chaînes de caractères en utilisant l'opérateur + :

>>> 'python' + "c'est facile"
"pythonc'est facile"

Vous noterez qu'il n'y a pas d'espace après le mot python. L'opérateur + fait simplement ce qu'on lui dit de faire. Pour avoir un espace, il faut l'ajouter explicitement avant :

>>> 'python ' + "c'est facile"
"python c'est facile"

Pour délimiter une chaîne de caractères sur plusieurs lignes, on utilise le triple """. Le saut de ligne est alors indiqué par le symbole \n .

>>> """python c'est facile
python c'est facile
vraiment facile"""
"python c'est facile\npython c'est facile\nvraiment facile"

On peut aussi multiplier les chaînes de caractères avec l'opérateur * :

>>> "python c'est " + 4 * 'facile!'
"python c'est facile!facile!facile!facile!"

Note > Le type str est présenté plus en détail au chapitre suivant.

4. Comparer : bool

On peut comparer des valeurs en utilisant des opérateurs de comparaison. Le résultat de cette comparaison sera une valeur de type booléen ou bool [boolean en anglais]. Par exemple Est-ce que 2 est supérieur à 3 ? Le résultat de cette comparaison ne sera pas non mais False en Python [faux en français] ou pour la question 2 est-il inférieur à 3 ?, le résultat sera True[vrai]. Dans d'autres langages informatiques False est représenté par 0 et True par une valeur non nulle.

>>> 2 > 3
False
>>> 2 < 3
True
>>> 2 < 2
False
>>> 2 <= 2
True
>>> 2 >= 2
True
>>> 2 > 2
False

On peut aussi se demander si la lettre 'r' est dans la chaîne de caractères 'bonjour' en utilisant l'opérateur in :

>>> 'r' in 'bonjour'
True

Pour savoir si deux objets sont égaux, on utilisera l'opérateur == et s'ils sont différents, l'opérateur != :

>>> 3 == 3
True
>>> 3 == 2
False
>>> 3 != 2
True
>>> 4 != 4
False

Note > Le type bool est présenté plus en détail au chapitre suivant.

Recommandation PEP 8 pour la gestion des espaces autour des opérateur de comparaison

Les opérateurs (>, >= , <, <=, ==, !=) doivent être précédés et suivis d'un espace.

5. Les variables

Les variables sont des noms utilisés pour nommer des valeurs. Le nom de cette variable est aussi appelé identifiant. Ces valeurs peuvent être des résultats de calcul ou des constantes. Par exemple, la valeur de la TVA (Taxe sur la Valeur Ajoutée) en France est de 20%, on peut donc définir la valeur de la variable val_tva et fixer sa valeur à 20/100 en utilisant l'opérateur d'affectation =.

>>> val_tva = 20 / 100
>>>

Recommandation PEP 8 pour l'affectation

L'opérateur d'affectation à une variable = doit être précédé et suivi d'un espace.

Jusqu'à maintenant, chaque commande donnait un résultat ; or ici aucun résultat ne s'affiche dans la console. C'est normal. Mais le résultat de cette variable peut être utilisé pour obtenir la valeur de la TVA d'un prix hors taxe de 200 en multipliant ce prix par la variable TVA :

>>> 200 * val_tva
40.0

Recommandations PEP 8 pour le nommage des variables

Il faut éviter que le nom d'une variable commence par la lettre l (L en minuscule) ou la lettre o (O minuscule ou majuscule) pour éviter les risques de confusions entre les chiffres zéro et un.

Le nom d'une variable doit être écrit en minuscules.

Si le nom d'une variable est un nom composé, les mots doivent être séparés par un trait de soulignement _ [underscrore en anglais].

Une constante doit être écrite avec des lettres majuscules.

On peut ajouter une variable prix_ht dont la valeur est de 300 et calculer le prix TTC (Toutes Taxes Comprises) en l'affectant à la valeur de la variable prix_ttc :

>>> prix_ht = 300
>>> prix_ttc = prix_ht + prix_ht*val_tva
>>> prix_ttc
360.0

On est en ligne de commande et le résultat est un peu abrupt dans sa présentation. Dans un programme, on pourra utiliser la fonction print :

>>> print("Le prix TTC est de", prix_ttc, "€")
Le prix TTC est de 360.0 €

Note > Une fonction permet d'effectuer des opérations à partir de la ou des valeurs données entre les parenthèses suivant le nom de la fonction. Les valeurs données sont les arguments, ici la chaîne de caractères "Le prix TTC est de ", la variable nommée prix_ttc et la chaîne de caractères "€" (voir le chapitre Fonctions).

Ne pas utiliser des noms de fonctions pour nommer des variables

En langage Python, on peut rapidement faire n'importe quoi si on ne respecte pas les règles :

>>> print("Bonjour")
Bonjour
>>> print = 18
>>> print("Bonjour")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not callable
>>> print + 3
21

Il ne faut pas appeler une variable print, cela conduit a des incohérences et à une perte de temps dans la recherche d'erreur.

Si maintenant on change la valeur de la variable prix_ht, la valeur de prix_ttc restera la même :

>>> prix_ht = 400
>>> prix_ttc
360.0

La valeur de la variable nommée prix_ttc a été calculée à un moment donné en utilisant les valeurs connues à ce moment précis. Si on veut connaître la nouvelle valeur de la variable prix_ttc, il faut entrer de nouveau la formule (utilisez l'historique des commandes pour retrouver la ligne de commande) :

>>> prix_ttc = prix_ht + prix_ht*val_tva
>>> prix_ttc
480.0

La nouvelle valeur de la variable prix_ht a été utilisée et l'ancienne valeur est perdue.

Couper une ligne de commande : usage du symbole \

Si on juge une ligne de commande trop longue on peut la répartir sur plusieurs lignes en utilisant le symbole \ (touche 8).

>>> val_tva = 20 / 100
>>> prix_ht = 300
>>> prix_ttc = prix_ht + prix_ht*val_tva
>>> prix_ttc
360.0

On peut ainsi diviser la ligne du calcul du prix_ttc en deux :

>>> prix_ttc = prix_ht +\
...            prix_ht*val_tva

Notez bien que les caractères ... en début ligne sont ajoutés automatiquement dans la console Python et ne doivent pas être ajoutés dans le script d'un programme.

6. Mots clés en Python

Le langage Python possède 35 mots clés listés dans le Tableau .2. Ces mots clés sont des éléments du langage. Si on les utilise pour nommer une variable ou une fonction, cela provoquera une erreur. On décrira plus précisément l'usage de ces mots clés dans les chapitres suivants.

Tableau .2 : Mots clés en Python

False | await | else | import | pass
None | break | except | in | raise
True | class | finally | is | return
and | continue | for | lambda | try
as | def | from | nonlocal | while
assert | del | global | not | with
async | elif | if | or | yield

À partir de la version Python 3.10, la notion de mots clés souples (ou faibles) a été introduite. Ils sont aux nombres de trois : match, case et _ (caractère souligné ou underscore). Ils sont dits souples car on peut les utiliser comme nom de variable, mais il faut absolument s'interdire de les utiliser comme tel ou comme nom de fonction.

7. Fonctions de base et bibliothèques en Python

Python a aussi quelques fonctions de bases listées dans le Tableau .3 (90 en tout).

Tableau .3 : Fonctions intégrées en Python

abs() | delattr() | hash() | memoryview() | set()
all() | dict() | help() | min() | setattr()
any() | dir() | hex() | next() | slice()
ascii() | divmod() | id() | object() | sorted()
bin() | enumerate() | input() | oct() | staticmethod()
bool() | eval() | int() | open() | str()
breakpoint() | exec() | isinstance() | ord() | sum()
bytearray() | filter() | issubclass() | pow() | super()
bytes() | float() | iter() | print() | tuple()
callable() | format() | len() | property() | type()
chr() | frozenset() | list() | range() | vars()
classmethod() | getattr() | locals() | repr() | zip()
compile() | globals() | map() | reversed() | __import__()
complex() | hasattr() | max() | round() |

Fonction

Une fonction en langage Python est un code informatique nommé effectuant une certaine tâche.

Lorsqu'on appelle une fonction pour effectuer une tâche, son nom est toujours suivi d'une parenthèse ouvrante et fermante. Cette fonction peut nécessiter des valeurs appelées arguments pour effectuer sa tâche ; elles sont alors placées entre la parenthèse ouvrante et fermante. Le ou les résultats donnés par la fonction sont appelés la ou les valeurs retournées. Une fonction peut ne donner aucun résultat.

Par exemple, la tâche effectuée par la fonction pow est l'élévation d'un nombre x à la puissance y ; dans l'expression a = pow(2, 3), il y a deux arguments (les valeurs 2 et 3) et la valeur retournée sera 8.

Autre exemple, la tâche effectuée par la fonction print est d'afficher dans la console les valeurs données en argument et ne donne aucun résultat.

Vous remarquerez que dans le Tableau .3, il n'y a aucune fonction trigonométrique, de fonction pour obtenir l'heure, pour avoir les noms des fichiers dans un dossier. Ces fonctions existent mais ne sont pas incluses dans le langage Python de base. Elles sont contenues dans les modules de la bibliothèque standard. L'accès se fait par l'utilisation des mots clés from ou import.

Par exemple, pour avoir la date et l'heure, il faut d'abord importer le module nommé time à l'aide de l'instruction import time puis appeler la fonction asctime du module time, permettant d'avoir la date et l'heure sous forme de chaînes de caractères, en écrivant l'instruction time.asctime() :

>>> import time
>>> time.asctime()
'Fri Apr 9 16:12:27 2021'
>>> time.asctime()
'Fri Apr 9 16:13:08 2021'

On peut choisir d'utiliser une seule ou plusieurs fonctions d'un module. Dans ce cas, on utilise le mot clé from avec import :

>>> from time import asctime
>>> asctime()
'Fri Apr 9 16:12:27 2021'
>>> asctime()
'Fri Apr 9 16:13:08 2021'

L'appel de la fonction ne nécessite plus l'utilisation du nom de la bibliothèque comme préfixe. Dans ce livre, toutefois, nous avons volontairement banni l'usage du from pour indiquer sans ambiguïté la bibliothèque utilisée lors de chaque appel à la fonction.

Les modules de la bibliothèque standard sont nombreux dans la version de Python de base. Selon le système utilisé, le nombre de modules disponibles peut changer. Par exemple, le module winreg permettant de gérer les clés de registres sous Windows n'est disponible que sous Windows tandis que le module posix n'est disponible que sous Unix.

En ligne de commande, on accède à l'aide en ligne avec la commande help.

>>> help(len)
Help on built-in function len in module builtins:

len(obj, /)
    Return the number of items in a container.

la fonction dont on recherche l'aide est l'argument de la fonction help. La fonction help peut être aussi utilisée pour obtenir l'aide sur un module nommé après la commande import en donnant le nom du module comme argument.

>>> import time
>>> help(time)
Help on built-in module time:

NAME
    time - This module provides various functions to manipulate time values.

DESCRIPTION
    There are two standard representations of time.  One is the number
    of seconds since the Epoch, in UTC (a.k.a. GMT).  It may be an integer
    or a floating point number (to represent fractions of seconds).
    The Epoch is system-defined; on Unix, it is generally January 1st, 1970.
    The actual value can be retrieved by calling gmtime(0).

    The other representation is a tuple of 9 integers giving local time.
    The tuple items are:
      year (including century, e.g. 1998)
      month (1-12)
      day (1-31)
      hours (0-23)
      minutes (0-59)
      seconds (0-59)
      -- Suite  --

L'aide du module apparaît page par page. Pour voir la page suivante, il faut presser la barre d'espacement ; et pour quitter l'aide, appuyer sur la touche q.

8. Erreurs en Python

Les erreurs en Python sont générées lors de l'analyse syntaxique du code ou bien lors de son exécution. Dans le premier cas, on parle d'erreur de syntaxe et dans le second cas (lors de l'exécution) on parle d'exception.

Dans l'exemple suivant, on a une erreur de syntaxe :

>>> print("bonjour)
  File "<stdin>", line 1
    print("bonjour)
                  ^
SyntaxError: EOL while scanning string literal

Le curseur ^ indique la position où la première incohérence a été trouvée dans le code. Ici c'est à priori la bonne position car il manque le " pour fermer la chaîne de caractères. Mais dans ce nouvel exemple, le curseur n'est pas forcément à la bonne position :

>>> 3 + 4) * 2
  File "<stdin>", line 1
    3 + 4)*2
         ^
SyntaxError: unmatched ')'

Soit il y a une parenthèse en trop, soit il manque une parenthèse en début ligne. L'analyseur syntaxique donne la première incohérence et il est important de bien retenir cela en particulier lorsqu'on écrit un programme.

Une exception est lancé par Python lorsque la syntaxe du code est correcte mais que le résultat de l'exécution ne peut être calculé. La division par 0 est impossible ; 10/0 a une syntaxe correcte, mais Python lance une exception :

>>> 10 / 0
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero

La différence entre exception et erreur de syntaxe est qu'une exception peut être interceptée par un programme alors qu'une erreur de syntaxe ne peut pas l'être directement. On reverra cette notion d'exception au chapitre Exceptions.

9. Éditer et lancer un programme

Le mode console permet d'essayer des commandes une à une. C'est pratique, mais on en voit rapidement les limites si l'on doit écrire de nombreuses commandes avant d'arriver au résultat et que l'on doit réutiliser ces instructions en modifiant les données. Pour éviter cela, les instructions peuvent être écrites dans un fichier texte.

Fichier texte

Un fichier texte est un fichier contenant une suite de caractères généralement lisibles par un être humain. Historiquement, les fichiers textes contenaient une suite de caractères codés en ASCII (American Standard Code for Information Interchange). Aujourd'hui, le codage par défaut est l'UTF-8.

Un fichier texte ne contient pas de texte enrichi comme les caractères italiques, gras, indice, etc.

Pour Windows, on peut utiliser Notepad++ comme éditeur de texte UTF-8, sur macOS Atom et sur Linux nano ou l'éditeur de Python idle.

Attention > Pour Windows, le codage de la console doit être en UTF-8 et la police de caractères Lucida console Fonts.

Après avoir ouvert votre éditeur de texte, vous pouvez saisir les commandes Python. Par exemple, écrivez la commande suivante :

#!/usr/bin/python
# -*- coding: utf-8 -*-
print("bonjour python")

Il faut alors sauvegarder ce fichier avec l'extension .py (par exemple programme1.py). On peut sauvegarder ce fichier dans le dossier /Users/username/Documents sous macOS, dans le dossier /home/username/Documents sous Unix ou bien dans le dossier \Users\username\Documents sous Windows. Le séparateur de dossier ou de répertoire est le signe divisé ou barre oblique / sous Linux ou macOS et la barre oblique inversée \ (antislash) sous Windows.

Une fois le fichier sauvegardé, il existe différentes méthodes pour lancer un programme Python.

La première méthode est de lancer le programme à partir de l'interface en ligne de commande du système. Une fois celle-ci ouverte, il faut entrer la commande python3 sous macOS ou Linux (ou python sous Windows) et faire glisser l'icône du fichier dans la fenêtre de la ligne de commande. Si cela n'est pas possible, il faut soit entrer le chemin complet ou bien changer de répertoire à l'aide de la commande cd [change directory en anglais]. La commande pwd [print working directory en anglais] permet d'afficher le dossier par défaut de la ligne de commande.

Figure .1 : Terminal sous macOS

Figure .2 : PowerShell sous Windows

Figure .3 : Terminal (raspbian)

Une seconde méthode consiste à cliquer sur l'icône du fichier contenant le script Python. Si l'association du fichier avec Python a bien été faite lors de l'installation de Python, le système lancera le script dans une console ou bien dans l'environnement Python connu par le système. Pour assurer la bonne lecture des résultats du programme, il est souvent nécessaire d'ajouter à la dernière ligne du programme la commande input("Fin du programme"). Sous Windows, cela est indispensable pour éviter la fermeture automatique du programme. Si vous cliquez sur l'icône, il faut que le shebang sous Linux ou bien que l'extension du fichier .py sous Windows soit présent.

Interface en ligne de commande

Une interface en ligne de commande permet de taper au clavier des commandes interprétables par le système d'exploitation. Sous Linux ou macOS, c'est l'application Terminal. Sous Windows, c'est l'invite de commande ou bien PowerShell, auxquels on a accès en entrant leur nom dans le menu Démarrer.

Une dernière méthode consiste à lancer le script à partir de la console Python en utilisant la commande exec et open.

Par exemple pour Linux (voir Figure .3), après avoir lancé Python, il faut entrer la commande exec(open("/home/lberger/Documents/programme1.py").read())  :

Python 3.7.3 (default, Jan 22 2021, 20:04:44)
[GCC 8.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> exec(open("/home/lberger/Documents/programme1.py").read())

bonjour python

Pour macOS (voir Figure .1), on entre la commande exec(open("/users/lberger/Documents/programme1.py").read()) ,

Python 3.7.3 (default, Jan 22 2021, 20:04:44)
[GCC 8.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> exec(open("/users/lberger/Documents/programme1.py").read())

bonjour python

Pour Windows (voir Figure .2), on entre la commande exec(open(r"c:\users\lberger\Documents\programme1.py",encoding='utf_8").read()) :

Python 3.10.2 (tags/v3.10.2:a58ebcc, Jan 17 2022, 14:12:15) [MSC v.1929 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> exec(open(r"C:\Users\lberger\Documents\programme1.py",encoding="utf-8").read())

bonjour python >>> exec(open("C:/Users/Laurent/Documents/programme1.py",encoding="utf-8").read()) bonjour python

Le r devant la chaîne de caractères "C:\Users\lberger\Documents\programme1.py" signifie que le caractère \ ne doit pas être interprété. On peut aussi remplacer les \ par /. Le caractère r devant la chaîne de caractères n'est alors plus nécessaire .

On a également précisé le type d'encodage du fichier source en donnant l'argument encoding="utf_8" en et (voir l'encadré Fichier binaire ou texte du chapitre Ouvrir et écrire des fichiers).

Types de données

Un type de données définit la nature des valeurs que peut prendre un résultat ou la valeur d'une variable.

1. Déterminer le type

La fonction Python type permet de déterminer le type d'une variable ou d'une valeur. Par exemple, le type de la valeur 2 est int et le type de la valeur 3.1 est float.

>>> type(2)
<class 'int'>
>>> type(3.1)
<class 'float'>

La fonction type renvoie dans le résultat le mot class. En Python, il n'y a pas de différence entre type et class.

Ces valeurs peuvent être des entiers, des nombres à virgule ou bien d'autres choses encore comme nous allons le voir maintenant.

2. Type int

On a déjà vu le type int utilisé pour représenter les nombres entiers au chapitre précédent. Le nombre de chiffres significatifs d'un nombre de type int est limité par la mémoire de votre ordinateur. Dans l'exemple suivant, on entre un entier avec 30 chiffres, on le multiplie par 1000 et on ajoute 1, et le résultat est toujours bon.

>>> x = 123456789012345678901234567890
>>> x*1000 + 1
123456789012345678901234567890001

Dans de très nombreux langages, cela n'est pas le cas. C'est là une spécificité de Python pour les nombres entiers (en C++ le nombre de chiffre est limité à 20).

Le type de la variable x est int, et celui du résultat de l'opération aussi :

>>> type(x)
<class 'int'>
>>> type(x*1000 + 1)
<class 'int'>

Avec tous les types numériques (int, float et complex), on peut utiliser une notation abrégée pour effectuer une opération arithmétique sur une variable. Cette notation est appelée assignation augmentée. Par exemple x = x + 1 peut se noter x += 1, x = x - 4 peut se noter x -= 4ou bien x = 2 * x peut se noter x *= 2. L'assignation augmentée s'applique à de nombreux opérateurs dont les principaux sont +, *, /, -, // %.

3. Type float

On a déjà vu le type float utilisé pour représenter les nombres à virgule au chapitre précédent. Le nombre de chiffres significatifs d'un type float est limité en Python à environ 17.

Dans l'exemple suivant, on entre un nombre à virgule avec 30 chiffres significatifs dans la variable x ; on l'affiche, et il en reste 17 ; on soustrait à la variable x la valeur des dix premiers chiffres, on voit que le résultat ne comporte que 7 chiffres corrects par rapport aux 30 chiffres initiaux :

>>> x = 1234567890.123456789012345678901
>>> print(x)
1234567890.1234567
>>> print(x-1234567890)
0.12345671653747559

Le plus grand nombre de type float est 1.7976931348623157e+308 (1.7976931348623157*10^308) et le plus petit nombre non nul est 2.2204460492503131e−16.

Le type de la variable x est float, et celui du résultat de l'opération aussi :

>>> type(x)
<class 'float'>
>>> type(x*1000 + 1)
<class 'float'>

On remarquera que dans l'opération x*1000+1, 1000 et 1 sont des nombres de type int et x de type float, et que le résultat est de type float.

Conversions arithmétiques

Quand les arguments d'une opération arithmétique sont de types différents, les règles suivantes s'appliquent :

si l'un des deux arguments est un nombre complexe, l'autre est converti en nombre complexe ;

sinon, si l'un des arguments est un nombre à virgule flottante, l'autre est converti en nombre à virgule flottante ;

sinon, les deux doivent être des entiers et aucune conversion n'est nécessaire.

4. Type complex

Nous mentionnons ici ce type complex car il fait partie des types de base en Python. Il est très utilisé en sciences mais nous ne l'utiliserons pas dans le reste du livre. Le lecteur intéressé pourra se reporter à l'article de Wikipédia sur les nombres complexes ou bien à un livre de mathématiques.

Le premier des nombres complexes est l'imaginaire pur noté i en mathématique. En Python, on le note 1j.

>>> x = 1j
>>> print(x)
1j
>>> type(x)
<class 'complex'>

Les opérateurs +, -, *, / et ** (élévation à la puissance) sont applicables aux nombres complexes :

>>> x = 1 + 2j
>>> y = 2.1 + 4j
>>> x* y**2 +3
(-42.19-6.379999999999999j)

5. Type bool

On a déjà vu le type bool utilisé pour représenter les valeurs logiques au chapitre précédent. Le résultat donné par un opérateur de comparaison comme >= (supérieur strictement ou égal à) est un type bool. Les opérateurs de comparaison sont donnés dans le Tableau .1.

Tableau .1 : Opérateurs de comparaison

Opérateur
Action
Exemple avec résultat True
Exemple avec résultat False

<
inférieur à
2 < 3
3 < 3

<=
inférieur ou égal à
3 <= 3
3 <= 2

>
supérieur à
'b' > 'a'
'A' > 'b'

>=
supérieur ou égal à
'aa' >= "aa"
3.0 >= 4

==
égal à
3.0 == 3
'a' == 'aa'

!=
différent
2 != 3.0
'e' == 2.2

is
égalité des identificateurs

>>> x = 3.0 
>>> y = x 
>>> x is y 

>>> x = 3.0 
>>> y = 3.0 
>>> x is y 

is not
différence des identificateurs

>>> x = 3.0 
>>> y = x 
>>> x + 2 is not y + 2 

>>> x = 3.0 
>>> y = x 
>>> x is not y 

in
est inclus dans
'n' in 'bonjour'
'N' in 'bonjour'

not in
n'est pas inclus dans
'N' not in 'bonjour'
'n' not in 'bonjour'

Il y a trois opérations possibles pour le type bool : and (ET logique), or (OU logique) et not (négation logique). Une table de ces opérations est donnée au Tableau .2.

Tableau .2 : Opérations logiques

x | y | x and y | x or y | not x
True | True | True | True | False
True | False | False | True | False
False | True | False | True | True
False | False | False | False | True

On peut utiliser ces opérateurs pour de nombreuses opérations logiques.

Par exemple pour déterminer si la valeur d'une variable est comprise entre 2 et 3 (bornes comprises), on écrira :

>>> x = 2.5
>>> x >= 2 and x <=3
True

L'écriture précédente peut aussi s'écrire :

>>> 2 <= x <= 3
True

Autre exemple, pour déterminer si la valeur d'une variable est hors de l'intervalle 2 et 3 (bornes comprises), on écrira :

>>> x = 8
>>> x < 2 or x > 3

6. Type str

...