Les bases du langage Python et les notebooks Jupyter

Les bases du langage Python¶

Dans cette section, je vais vous donner un aperçu des concepts de programmation Python essentiels et des mécanismes du langage.

Sémantique du langage La conception du langage Python se distingue par l’accent mis sur la lisibilité, la simplicité et l’explicite. Certaines personnes vont jusqu’à le comparer à du “pseudocode exécutable”.

Indentation, pas d’accolades

Python utilise des espaces (tabulations ou espaces) pour structurer le code au lieu d’utiliser des accolades comme dans de nombreux autres langages comme R, C++, Java et Perl. Considérez une boucle for d’un algorithme de tri :

Le symbole deux-points (:) signale le début d’un bloc de code indenté. Toutes les lignes de code suivantes appartenant à ce bloc doivent avoir le même niveau d’indentation jusqu’à la fin du bloc. Que cela plaise ou non, l’indentation significative est une caractéristique inhérente à Python. Bien que cela puisse paraître déconcertant au début, on s’y habitue généralement avec la pratique.

Il est fortement conseillé d’utiliser quatre espaces pour l’indentation par défaut et de configurer son éditeur pour que les tabulations soient remplacées par quatre espaces. De nombreux éditeurs de texte offrent cette option (activez-la !). IPython et les notebooks Jupyter gèrent automatiquement l’insertion de quatre espaces sur les nouvelles lignes après un deux-points et convertissent les tabulations en quatre espaces.

Comme vous l’aurez remarqué, les instructions Python ne nécessitent pas de point-virgule en fin de ligne. Toutefois, le point-virgule peut être utilisé pour séparer plusieurs instructions sur une même ligne :

Placer plusieurs instructions sur une seule ligne est généralement une pratique déconseillée en Python, car cela peut nuire à la lisibilité du code.

Tout est objet¶

Une spécificité importante de Python réside dans la cohérence de son modèle objet. Chaque élément – nombre, chaîne de caractères, structure de données, fonction, classe, module, etc. – existe au sein de l’interpréteur Python sous la forme d’une “entité” distincte, appelée objet Python. Chaque objet possède un type qui lui est associé (par exemple, entier, chaîne de caractères ou fonction) ainsi que des données internes. En pratique, cela confère au langage une grande souplesse, puisque même les fonctions peuvent être manipulées comme n’importe quel autre objet.

Commentaires Tout texte qui suit un dièse (#) est ignoré par l’interpréteur Python. Cette syntaxe est fréquemment employée pour insérer des commentaires dans le code. Il peut aussi être utile de vouloir désactiver temporairement des blocs de code sans les effacer. Une méthode pour cela est de les commenter :

Les commentaires peuvent également se trouver à la suite d’une ligne de code exécutable. Bien que certains développeurs préfèrent placer les commentaires sur la ligne précédant le code concerné, cette forme peut s’avérer pratique dans certains cas :

Appels de fonctions et de méthodes d’objets¶

On invoque des fonctions en utilisant des parenthèses et en leur passant zéro ou plusieurs arguments. La valeur retournée par la fonction peut éventuellement être assignée à une variable :

La quasi-totalité des objets en Python disposent de fonctions associées, nommées méthodes, qui ont la capacité d’accéder aux données internes de l’objet. On les appelle en utilisant la syntaxe suivante :

Les fonctions peuvent accepter des arguments positionnels ainsi que des arguments par mots-clés :

Ce point sera examiné plus en détail ultérieurement.

Variables et transmission d’arguments En Python, lorsqu’on assigne une valeur à une variable (ou un nom), on crée en réalité une référence vers l’objet situé à droite du signe égal. Pour illustrer concrètement, prenons une liste d’entiers :

Supposons que nous assignions ma_liste_originale à une nouvelle variable reference_liste :

Dans certains langages, l’affectation reference_liste = ma_liste_originale aurait pour effet de dupliquer les données [10, 20, 30]. En Python, reference_liste et ma_liste_originale désignent en fait le même objet, c’est-à-dire la liste initiale [10, 20, 30] (la Figure illustre ce concept). On peut le vérifier en ajoutant un élément à a puis en inspectant b :

La compréhension de la sémantique des références en Python – quand, comment et pourquoi les données sont copiées – est absolument cruciale lorsqu’on manipule des ensembles de données volumineux. L’assignation est aussi appelée “liaison” (binding), car on lie un nom à un objet. Les noms de variables ayant fait l’objet d’une assignation sont parfois qualifiés de “variables liées” (bound variables).

Lorsqu’on passe des objets en arguments à une fonction, de nouvelles variables locales sont créées. Celles-ci référencent les objets originaux sans qu’aucune copie ne soit effectuée. Si, à l’intérieur d’une fonction, on lie un nouvel objet à une variable, cela n’affectera pas une variable portant le même nom dans la “portée” extérieure à la fonction (la “portée parente”). Il est donc possible de modifier le contenu interne d’un argument mutable. Prenons la fonction suivante :

Nous avons

Références dynamiques et typage fort¶

En Python, les variables n’ont pas de type intrinsèquement associé ; une variable peut désigner un objet de type différent par une simple réassignation. L’exemple suivant ne pose aucun problème :

Les variables sont des noms qui identifient des objets au sein d’un espace de noms donné ; l’information de type est conservée dans l’objet lui-même. Certains pourraient en déduire à tort que Python n’est pas un “langage typé”. C’est inexact, comme le montre cet exemple :

Dans certains langages, la chaîne de caractères ‘2’ pourrait être convertie implicitement (ou “castée”) en un entier, ce qui donnerait 10. Dans d’autres, l’entier 10 pourrait être transformé en chaîne, résultant en la chaîne concaténée ‘5’. Python n’autorise pas de telles conversions implicites. À cet égard, on dit de Python qu’il est un langage fortement typé : chaque objet a un type (ou une classe) bien défini, et les conversions implicites ne se produisent que dans des cas spécifiques autorisés, comme celui-ci :

Ici, bien que num_entier soit un entier, il est converti implicitement en nombre à virgule flottante pour l’opération de division.

Il est important de connaître le type d’un objet, et il est pratique de pouvoir écrire des fonctions capables de traiter divers types de données en entrée. La fonction isinstance permet de vérifier si un objet est une instance d’un type particulier :

isinstance peut également prendre un tuple de types si l’on souhaite vérifier si le type d’un objet appartient à l’un des types présents dans le tuple :

Attributs et méthodes¶

En Python, les objets possèdent généralement à la fois des attributs (d’autres objets Python “contenus” dans l’objet) et des méthodes (des fonctions associées à un objet, capables d’accéder à ses données internes). On accède aux deux via la syntaxe obj.nom_attribut :

Les attributs et méthodes sont également accessibles par leur nom grâce à la fonction getattr :

Bien que getattr et les fonctions apparentées hasattr et setattr ne soient pas abondamment utilisées dans ce livre, elles se révèlent très utiles pour écrire du code générique et réutilisable.

“Duck Typing” (Typage de canard)¶

Souvent, le type exact d’un objet importe moins que sa capacité à effectuer certaines actions ou à présenter certains comportements. C’est ce qu’on appelle parfois le “duck typing”, en référence à l’adage : “Si ça marche comme un canard et que ça cancane comme un canard, alors c’est un canard.” Par exemple, on peut déterminer si un objet est itérable en vérifiant s’il implémente le protocole d’itération. Pour de nombreux objets, cela signifie la présence d’une “méthode magique” iter. Cependant, une approche alternative et préférable consiste à essayer d’utiliser la fonction iter :

Importations de modules¶

En Python, un module n’est rien d’autre qu’un fichier portant l’extension .py et contenant du code Python. Imaginons le module suivant :

Si l’on souhaitait utiliser les variables et fonctions définies dans ou mon_utilitaire.py depuis un autre fichier situé dans le même répertoire, on pourrait procéder ainsi :

Ou bien, de cette manière alternative :

Le mot-clé as permet d’attribuer des noms différents aux éléments importés :

Opérateurs binaires et comparaisons¶

La majorité des opérations mathématiques binaires et des comparaisons utilisent une syntaxe mathématique conventionnelle, similaire à celle d’autres langages de programmation :

Pour déterminer si deux variables font référence au même objet en mémoire, on utilise le mot-clé is. Inversement, is not sert à vérifier que deux objets sont distincts :

Puisque la fonction list (ou dict dans cet exemple) génère systématiquement une nouvelle liste (ou un nouveau dictionnaire) Python (c’est-à-dire une copie), on a l’assurance que c (ou z) est différent de a (ou x). Il ne faut pas confondre la comparaison avec is et l’opérateur ==, car dans la situation présente, nous aurions :

Une application fréquente de is et is not est la vérification qu’une variable a la valeur None, étant donné qu’il n’existe qu’une seule instance de None :

Objets modifiables (mutables) et non modifiables (immutables)¶

De nombreux objets en Python, comme les listes, les dictionnaires, les tableaux NumPy et la plupart des types personnalisés (classes), sont dits modifiables (mutables). Cela implique que l’objet lui-même ou les valeurs qu’il contient peuvent être altérés :

D’autres, en revanche, tels que les chaînes de caractères et les tuples, sont non modifiables (immutables), ce qui signifie que leurs données internes ne peuvent pas être changées après leur création :

Pour comprendre ce message d’erreur, il faut le lire en partant du bas. La tentative de remplacer le caractère (l’“élément”) à l’index 10 par la lettre “f” a échoué, car cette opération n’est pas permise pour les objets de type chaîne. Si une modification d’une chaîne est nécessaire, il faut utiliser une fonction ou une méthode qui génère une nouvelle chaîne, comme la méthode replace des chaînes :

Suite à cette opération, la variable a (ou texte_original) demeure inchangée :

De nombreux objets Python peuvent être transformés en leur représentation textuelle grâce à la fonction str :

Les chaînes de caractères sont des séquences de caractères Unicode et peuvent, à ce titre, être manipulées de la même manière que d’autres séquences comme les listes et les tuples :

La notation mot[2:5] est appelée “slicing” (tranchage) et est disponible pour de nombreux types de séquences en Python. Ce concept sera exploré plus avant ultérieurement, car son usage est fréquent dans cet ouvrage.

Le caractère antislash \ sert de caractère d’échappement ; il est utilisé pour désigner des caractères spéciaux tels que le saut de ligne \n ou des caractères Unicode. Pour inclure des antislashs littéraux dans une chaîne, il faut les échapper eux-mêmes :

Si une chaîne contient de nombreux antislashs et aucun caractère spécial, cette nécessité d’échappement peut devenir fastidieuse. Heureusement, on peut préfixer la chaîne (avant le premier guillemet) par la lettre r, indiquant que les caractères doivent être interprétés littéralement (raw string) :

Le r est l’abréviation de “raw” (brut).

La concaténation de deux chaînes de caractères s’effectue par l’opérateur +, ce qui produit une nouvelle chaîne :

La mise en forme de chaînes, ou “templating”, est un autre sujet d’importance. Les techniques pour ce faire se sont diversifiées avec l’arrivée de Python 3. Je vais ici brièvement exposer le fonctionnement de l’une des interfaces principales. Les objets de type chaîne possèdent une méthode format qui permet de substituer des arguments formatés au sein de la chaîne, générant ainsi une nouvelle chaîne :

Python 3.6 a introduit les “f-strings” (littéraux de chaînes formatées), une fonctionnalité qui simplifie davantage la création de chaînes formatées. Pour créer une f-string, il suffit de faire précéder le littéral de chaîne du caractère f. À l’intérieur de la chaîne, les expressions Python encadrées par des accolades seront remplacées par leur valeur dans la chaîne finale :

Des spécificateurs de format peuvent être ajoutés après chaque expression, en utilisant la même syntaxe que pour les modèles de chaînes vus précédemment :

Le formatage de chaînes est un domaine vaste ; il existe diverses méthodes et de nombreuses options pour contrôler finement la manière dont les valeurs sont intégrées dans la chaîne résultante. Pour une exploration approfondie, référez-vous à la documentation officielle de Python.

Octets (Bytes) et Unicode¶

Dans les versions modernes de Python (Python 3.0 et ultérieures), Unicode est devenu le standard pour les chaînes de caractères, permettant une gestion plus homogène des textes ASCII et non-ASCII. Dans les anciennes versions de Python, les chaînes étaient nativement des séquences d’octets sans encodage Unicode explicite. La conversion vers Unicode était possible à condition de connaître l’encodage des caractères d’origine. Voici un exemple de chaîne Unicode contenant des caractères non-ASCII :

On peut convertir cette chaîne Unicode en sa représentation en octets au format UTF-8 grâce à la méthode encode :

Si l’on connaît l’encodage Unicode d’un objet de type bytes, on peut le reconvertir en chaîne Unicode avec la méthode decode :

Bien que l’UTF-8 soit désormais l’encodage à privilégier pour toute nouvelle donnée, pour des raisons historiques, on peut être amené à traiter des données encodées avec divers autres standards :

Il est fréquent de manipuler des objets de type bytes lors de la lecture de fichiers, situation où un décodage implicite de toutes les données en chaînes Unicode n’est pas toujours souhaitable.

Booléens¶

En Python, les deux valeurs booléennes s’écrivent True et False. Les comparaisons et autres expressions conditionnelles s’évaluent à True ou False. On combine les valeurs booléennes à l’aide des mots-clés and et or :

Lorsqu’ils sont convertis en nombres, False équivaut à 0 et True à 1 :

Le mot-clé not inverse la valeur d’un booléen, transformant True en False et vice-versa :

Conversion de type (Casting)¶

Les types str, bool, int et float servent également de fonctions pour convertir des valeurs vers ces types respectifs :

La valeur None¶

None représente la valeur nulle en Python :

None est aussi fréquemment utilisé comme valeur par défaut pour les arguments de fonctions :

Dates et heures¶

Le module natif datetime de Python met à disposition les types datetime, date et time. Le type datetime, qui fusionne les informations de date et time, est le plus utilisé :

À partir d’une instance datetime, on peut en extraire les objets date et time correspondants en appelant les méthodes du même nom sur l’objet datetime :

La méthode strftime permet de formater un objet datetime en une chaîne de caractères :

Inversement, des chaînes de caractères peuvent être converties (analysées) en objets datetime à l’aide de la fonction strptime :

Lors de l’agrégation ou du regroupement de données temporelles, il est parfois utile de modifier certains champs horaires d’une série d’objets datetime, par exemple, en réinitialisant les minutes et les secondes à zéro :

Puisque datetime.datetime est un type immutable, les méthodes de ce genre retournent toujours de nouveaux objets. Ainsi, dans l’exemple précédent, dt (ou dt_specifique) n’est pas altéré par l’appel à replace :

La soustraction de deux objets datetime produit un objet de type datetime.timedelta :

La sortie (datetime.timedelta(days=9, seconds=43200) signifie que l’objet timedelta représente un intervalle de 9 jours et 43200 secondes. L’ajout d’un timedelta à un datetime donne un nouvel objet datetime décalé :

Structures de contrôle du flux¶

Python intègre plusieurs mots-clés pour la logique conditionnelle, les boucles et d’autres concepts de contrôle de flux que l’on retrouve dans d’autres langages de programmation.

Instructions if, elif et else¶

L’instruction if est l’une des structures de contrôle de flux les plus répandues. Elle évalue une condition et, si celle-ci est vraie (True), exécute le bloc de code qui la suit :

Une instruction if peut être suivie, optionnellement, d’une ou plusieurs clauses elif et d’une clause else finale qui s’exécute si toutes les conditions précédentes sont fausses (False) :

Si l’une des conditions (if ou elif) est vérifiée, les blocs elif ou else suivants ne sont pas évalués. Dans le cas d’une condition composite utilisant and ou or, l’évaluation se fait de gauche à droite et s’interrompt dès que le résultat est connu (évaluation paresseuse) :

Il est également possible d’enchaîner les comparaisons :

Boucles for¶

Les boucles for sont utilisées pour parcourir les éléments d’une collection (comme une liste ou un tuple) ou d’un itérateur. La syntaxe typique d’une boucle for est :

On peut passer à l’itération suivante d’une boucle for, en ignorant le reste du bloc de code pour l’itération courante, grâce au mot-clé continue.

Une boucle for peut être interrompue prématurément avec le mot-clé break. Le code ci-dessous additionne les éléments d’une liste jusqu’à ce qu’il rencontre la valeur 5 :

Le mot-clé break met fin uniquement à la boucle for la plus interne ; toute boucle for englobante poursuit son exécution :

Comme nous le verrons plus en détail, si les éléments de la collection ou de l’itérateur sont eux-mêmes des séquences (des tuples ou des listes, par exemple), il est aisé de les décomposer en variables distinctes directement dans l’instruction de la boucle for

Boucles while¶

Une boucle while définit une condition et un bloc de code qui s’exécute tant que la condition reste vraie (True), ou jusqu’à ce que la boucle soit explicitement terminée par une instruction break :

L’instruction pass¶

L’instruction pass est une opération neutre en Python (elle ne fait rien). Elle peut être employée dans des blocs où aucune action n’est requise (ou comme marqueur pour du code à implémenter ultérieurement). Sa présence est nécessaire uniquement parce que Python utilise l’indentation pour délimiter les blocs :

La fonction range¶

La fonction range produit une séquence d’entiers régulièrement espacés :

On peut spécifier un point de départ, un point d’arrivée et un pas (qui peut être négatif) :

Comme on peut le constater, range génère des entiers jusqu’à la valeur de fin, cette dernière étant exclue. Une utilisation fréquente de range est l’itération sur les indices d’une séquence :

Bien qu’il soit possible d’utiliser des fonctions comme list pour stocker tous les entiers produits par range dans une autre structure de données, c’est souvent la forme itérative par défaut qui est la plus appropriée. L’extrait de code suivant calcule la somme de tous les nombres de 0 à 99 999 qui sont multiples de 3 ou de 5 :

Même si la plage de nombres générée peut être très étendue, la consommation de mémoire à un instant donné reste très faible.