Initiation à Python

Manipulation des types de données en ligne de commande

Tout le code de cette page, y compris dans les exercices, peut être testé en ligne de commande avec un interprète comme Python IDLE ou la console de Spyder.

Pour conserver le résultat d'un calcul en mémoire afin de l'utiliser un peu plus tard, on peut l'affecter à une variable, dont le nom commencera par une lettre et peut contenir d'autres lettres, des chiffres et le symbole souligné _. On ne peut donc utiliser de nom avec une espace, ni avec un trait d'union ou une apostrophe. On évitera aussi les accents et cédilles.

Majuscules et minuscules sont considérées comme des caractères distincts.

L'affectation ne produit pas de résultat. En revanche, on peut afficher plusieurs résultats en saisissant des expressions séparées par des virgules.

a = 2
A = 3
a, A
(2, 3)

Le résultat de chaque ligne de commande peut être rappelé dans la commande suivante à l'aide du symbole souligné _.

Voir aussi les compléments sur les variables.

Nombres, opérations arithmétiques et relations

Les nombres peuvent être saisis comme d'habitude, avec le point comme séparateur décimal, voire en notation scientifique.

Les opérations arithmétiques élémentaires se notent aussi classiquement de façon infixe et respectent l’ordre de priorité usuel croissant : + et - (soustraction), puis * et / (version 3), puis - (changement de signe) et enfin ** pour l’exponentiation. Les parenthèses peuvent être utilisées normalement.

Attention, le caret ^ est l’opérateur de XOR bit à bit.

Le quotient et le reste de la division euclidienne s’obtiennent respectivement avec les opérateurs // et %.

Exercice
  1. Combien y a-t-il de jours en quatre ans ? Combien cela représente-t-il de semaines complètes ?
  2. Saisir 3**1**2 et en déduire l’ordre d’évaluation de l’opérateur d’exponentiation par rapport à lui-même.
  3. Pourquoi la commande 5^2 n'affiche-t-elle pas 25 ?

On distingue les nombres entiers des nombres flottants, qui sont obtenus avec un point séparateur décimal ou en notation scientifique avec mantisse et exposant séparés par la lettre e ou E. Ces derniers sont arrondis avec 17 chiffres significatifs environ mais le test d'égalité (avec l'opérateur ==) est valide entre un entier et le flottant correspondant si la mantisse est exacte.

2 == 2.0
True
123456789123456789
123456789123456789
123456789123456789.0
1.2345678912345678e17
123456789123456789 == 123456789123456789.0
False

Les opérateurs pour les inégalités se notent <=, >=, <, > et !=. Ils peuvent être combinés.

2 <= 2 < 3
True
1 != 0 != 1
True

Voir aussi les compléments sur les booléens, sur les types de nombres et notamment les nombres complexes, ainsi que sur la simulation aléatoire.

Fonctions

Quelques fonctions sont directement utilisables, avec la notation mathématique habituelle nomfonction(argument).

abs(-3.5)  # valeur absolue
3.5
divmod(100, 7)  # quotient et reste euclidiens de 100 par 7
(14, 2)
max(2, 3, 0.5), min(2, 3, 0.5)
(3, 0.5)

Les fonctions max et min s'appliquent aussi à des listes.

Les autres fonctions usuelles sont fournies par le module math : cos, sin, tan, acos, asin, atan, degrees, radians, cosh, sinh, tanh, acosh, asinh, atanh, exp, log, log10, pow, sqrt, floor, ceil, factorial… avec les constantes pi et e. Il suffit d'importer une seule fois le module pour pouvoir l'utiliser autant de fois qu'on le souhaite.

import math
math.sin(math.pi/4)
0.7071067811865475

Pour éviter d’avoir à écrire math. devant chaque objet importé, on peut modifier la commande d’importation avec le mot clé from.

from math import *
log(e)
1.0

Pour n’importer qu’un seul objet du module, il suffit de remplacer l’astérisque ci-dessus par le nom de l’objet voulu.

Exercice
  1. Quel est le volume approximatif de la Terre si la longueur du méridien géographique est de vingt mille kilomètres ?
  2. Calculer l’angle de réfraction limite (en degrés) entre l’air et l’eau d’indice 1,333.
  3. Quel est le nombre de chiffres de 5432 en base dix ?

Pour définir une nouvelle fonction, on peut utiliser le mot clé lambda qui fait référence au lambda-calcul.

f = lambda x: 1/(1 + x**2)
f(0.5)
0.8

On peut définir des fonctions de plusieurs variables ou une fonction par morceaux avec un test interne.

moyenne = lambda x, y: (x+y)/2
echelon = lambda t: 0 if t < 0 else 1
Exercice
  1. Définir une fonction distance qui calcule la distance entre deux points du plan en fonction de leurs coordonnées.
  2. Définir une fonction signe qui renvoie +1, −1 ou 0 pour traduire le signe de son argument.

Voir aussi les compléments sur la représentation graphique et sur la résolution numériques des équations différentielles.

Listes

Les listes peuvent être saisies de façon extensive entre crochets en utilisant la virgule comme séparateur. Elles peuvent contenir des objets de types différents, y compris des listes.

Les opérateurs in et not in permettent de tester la présence d’une valeur dans une liste. La fonction len donne le nombre de termes d'une liste. La fonction sorted renvoie une copie triée de la liste donnée en argument, en préservant les répétitions.

liste = [3, 1, 4, 1, 5, 9]
2 in liste
False
len(liste)
6
triee = sorted(liste)
liste, triee   # la liste initiale n'a pas été modifiée
([3, 1, 4, 1, 5, 9], [1, 1, 3, 4, 5, 9])
sum(liste), max(liste), min(liste)
(23, 9, 1)
Exercice
  1. Construire une fonction moyenne qui calcule la moyenne des valeurs d'une liste de nombres.
  2. Construire une fonction etendue qui calcule l'étendue des valeurs d'une liste de nombres.

On accède à un terme d'une liste en précisant son index entre crochets. Attention, le premier terme est indexé par 0. On peut aussi accéder aux termes en partant de la fin avec un index négatif. Ces accès permettent aussi de modifier une liste sans réaffectation. Si deux variables pointent sur la même liste, toute modification par l'une sera visible par l'autre.

liste = [3, 1, 4, 1, 5, 9]
liste[2], liste[-2]
(4, 5)
copie = liste
copie[2] = 0  # on modifie le 3e terme
liste         # la liste initiale a été modifiée !
[3, 1, 0, 1, 5, 9]

On peut copier une sous-liste en précisant l'index de début (inclus, par défaut 0), celui de fin (exclu, par défaut le nombre de termes) et éventuellement un pas (par défaut 1), séparés par des deux-points. Si on modifie ces copies, on ne modifie pas la liste initiale.

liste = [3, 1, 4, 1, 5, 9]
liste[2:4], liste[-3:], liste[::2]
([4, 1], [1, 5, 9], [3, 4, 5])
liste[::-1]
[9, 5, 1, 4, 1, 3]

On peut construire concaténer deux listes avec l'opérateur +, mais pour adjoindre un terme à la fin il vaut mieux utiliser la méthode .append. Plusieurs autres méthodes s'appliquent aux listes.

liste = [3, 1, 4] + [1, 5, 9]
liste.append(2)
liste
[3, 1, 4, 1, 5, 9, 2]
liste.pop()  # extraction du dernier terme
2
liste   # le dernier terme a disparu
[3, 1, 4, 1, 5, 9]
liste.index(5)   # premier index de la valeur
4
liste.count(1)   # nombre d'occurrences
2
liste.sort()   # trie la liste
liste
[1, 1, 3, 4, 5, 9]

La commande [1, 3, 4].index(2) provoque une erreur. Python signale le problème et arrête le calcul, même si d'autres calculs valides ont été demandés avec la même instruction. Le traitement d'erreurs au sein d'un programme est géré par un système d'exceptions.

Exercice
  1. Définir une fonction valeurcentrale qui à toute liste L renvoie le terme d'index n si la liste a 2n+1 termes et qui renvoie la moyenne des termes d'index n−1 et n si la liste a 2n termes. En déduire une fonction mediane.
  2. Définir une fonction quantile qui détermine le quantile d'ordre α pour une liste L.

Il est possible d'engendrer automatiquement des listes à l'aide de la fonction range, qui produit des intervalles d'entiers, et de la description par compréhension, analogue à l'axiome de compréhension de théorie des ensembles. Un intervalle d'entiers est défini par son nombre de termes (en commençant par 0), ou bien par ses premier terme (inclus) et dernier terme (exclu) avec éventuellement un pas en troisième paramètre. Dans la version 3, son affichage passe par une conversion en liste.

list(range(3, 7))  # intervalle d'entiers
[3, 4, 5, 6]
[n**2 for n in range(10)]  # 10 premiers carrés
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
[d for d in range(1,101) if (100 % d == 0)]  # liste des diviseurs de 100
[1, 2, 4, 5, 10, 20, 25, 50, 100]

On peut multiplier une liste par un entier avec l'opérateur *, mais que cette opération n'est pas distributive avec la concaténation.

2*([1, 3] + [1, 4, 5])
[1, 3, 1, 4, 5, 1, 3, 1, 4, 5]
2*[1, 3] + 2*[1, 4, 5]
[1, 3, 1, 3, 1, 4, 5, 1, 4, 5]
Exercice
  1. Construire la liste des entiers naturels inférieurs à 100 qui ne sont pas multiples de 7.
  2. Définir une fonction subdivision qui prend en argument deux bornes et un nombre de points et qui renvoie la liste des valeurs d'une subdivision régulière de l'intervalle défini par ses deux bornes.
  3. Calculer le nombre d’entiers entre 1 et 100 dont le cosinus est positif.
  4. Construire une fonction diviseurs qui renvoie la liste des diviseurs d'un entier.
  5. Calculer ζ(4) et comparer avec sa valeur théorique.

Voir aussi les compléments sur les matrices.

Chaines de caractères

Elles peuvent être délimitées par des apostrophes droites ' ou des guillemets anglais ". Il est même possible d’utiliser trois apostrophes droites ou trois guillemets simples pour délimiter du texte contenant des retours à la ligne. Pour afficher un caractère qui sert aussi de délimiteur, il suffit de le préfixer par une barre transversale \. L’opérateur de concaténation des chaines est le symbole +. De nombreuses méthodes permettent de calculer la longueur, d’obtenir une sous-chaine ou de chercher la position d’une sous-chaine.

print('L\'apostrophe')
L'apostrophe
"Petit".lower(), "Grand".upper()
('petit', 'GRAND')
"bonjour"[2:5]             # extraction d'une sous-chaine
'njo'
"bonjour".find('j')        # indice d'occurrence de la sous-chaine
3
"bonjour".count('o')       # dénombrement de sous-chaine
2
"Un petit texte".split()   # découpage de texte, selon espace par défaut
['Un', 'petit', 'texte']
"ara".replace('a', 'che')  # remplacement de texte
'cherche'
'a'.join(['b', 'rb', 'r', ''])  # concaténation d'une suite de chaines
'barbara'
'www.exemple.com'.strip('cmw.') # élagage au bord, des espaces par défaut
'exemple.co'

Documentation Python sur les chaines de caractères

Les fonctions ord et chr associent chaque caractère à son numéro d’ordre et réciproquement.

Exercice
  1. Programmer un générateur de billets galants pour M. Jourdain, par permutations aléatoires des cinq chaines « , belle Marquise, », « vos beaux yeux », « me font », « mourir » et « d'amour », en corrigeant la typographie du résultat (supprimer les éventuels espaces ou virgules au début ou à la fin, ajouter un point à la fin et capitaliser la première lettre de la phrase).
  2. Déterminer les plages de codes correspondant aux chiffres et aux lettres majuscules, minuscules, y compris aux lettres accentuées courantes en français.
  3. Décoder le mot « guahczckoy » par décalage de 6 lettres dans l’alphabet.

L’opérateur % permet d’insérer une valeur numérique (avec %d pour un entier et %f pour un réel flottant) ou une chaine de caractères (avec %s) à l’intérieur d’un texte prédéfini.

from datetime import date
nom, annee_naissance = 'Tux', 1996
annonce = "Mon nom est %s et j'ai %d ans cette année."
print(annonce % (nom, date.today().year-annee_naissance))
Mon nom est Tux et j'ai 17 ans cette année.

L'analyse d’une chaine de caractères ou d’un texte sur plusieurs lignes peut être facilitée par l’emploi des expressions régulières du module re.

import re
re.findall('(tt|tr|rt|t)', "Trois tortues trottent sur trois toits très pointus.")
['t', 'rt', 'tr', 'tt', 't', 'tr', 't', 't', 'tr', 't']
re.sub('[aeiouy]', '*', 'Qui trouvera les voyelles ?')
'Q** tr**v*r* l*s v***ll*s ?'

Tables associatives

Tandis que les listes sont indexées par des entiers, les tables associatives ou dictionnaires permettent de référencer des objets à l’aide de chaines de caractères ou de tout type admettant une fonction de hachage (nombres, ensembles figés frozenset…) et tout uplet formé avec de tels types.

fiche = {'nom': 'Tux', 'annee_naissance': 1996}
'nom' in fiche, len(fiche)
(True, 2)
print('%s, né en %d à %s.' %   # passage à la ligne
(fiche['nom'], fiche.get('annee_naissance', '?'), fiche.get('lieu_naissance', '(lieu inconnu)')))
Tux, né en 1996 à (lieu inconnu).
morpion = {(1, 1): 'X', (0, 0): 'O', (0,1): 'X', (1, 0): 'O'}
del morpion[(1, 0)]
morpion[(2, 1)] = 'O'
morpion.keys()
[(0, 1), (0, 0), (1, 1), (2, 1)]
morpion.values()
['X', 'O', 'X', 'O']

Attention, les ordres d’affichage des listes fournies par les méthodes keys et values ne sont pas nécessairement cohérents entre eux ni avec l’ordre de saisie du dictionnaire. Une liste des couples (clé, valeur) est fournie par la méthode items.

Documentation Python sur les tables associatives
Exercice
  1. Définir une table précisant pour chaque lettre de l’alphabet admettant des signes diacritiques une chaine des caractères avec diacritiques correspondants. Construire ensuite une table précisant pour chaque lettre avec diacritique la lettre sans diacritique correspondante.
  2. Commencer une table des atomes, précisant pour chacun son nom, son numéro atomique et son symbole.

Autres types

D’autres types d’objets sont utilisables.

Ensembles
Les types set et frozenset représentent des ensembles (respectivement modifiables ou non) d’objets admettant une fonction de hachage. L’intérêt des ensembles figés (frozenset) est qu’ils peuvent eux-mêmes être des éléments d’autres ensembles, ou servir de clés pour des tables associatives.
Binaires
Les types byte et bytearray codent des chaines d’octets, respectivement non modifiables et modifiables.
Types
Les types sont les objets renvoyés par la fonction type.
Objets
Le type object est fondamental car permet de dériver l’essentiel des classes et objets composites créés dans un programme Python.
Cas particuliers
Les types None et NotImplementedType ne concernent qu’un seul objet chacun.
Sections
Le type slice permet de sélectionner une partie d’une séquence.
Exceptions
Les exceptions servent à la gestion des erreurs mais aussi parfois la sortie de boucle ou l’interruption d’un sous-programme.
Modules
Les modules fournissent des types d’objets et des fonctions supplémentaires.