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 %.

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.

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

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)

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.

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]

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'

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

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.

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.