$$ \def\CC{\bf C} \def\QQ{\bf Q} \def\RR{\bf R} \def\ZZ{\bf Z} \def\NN{\bf N} $$

Types de données de Python

In [ ]:
from __future__ import division, print_function   # Python 3

Nous avons vu dans les chapitres précédents quelques types de données comme les entiers et les nombres flottants de Python ainsi que quelques structures de données (listes, tuples, dictionnaires) utilisées comme argument ou comme valeur de retour de certaines fonctions de SymPy. Dans ce chapitre, nous allons présenter avec plus de détails les types de données qui sont les plus souvent utilisées en programmation.

Le type d'un objet

Construisons le nombre entier 4 de deux façons différentes, avec Python puis avec SymPy:

In [ ]:
a = 4
from sympy import S
b = S(4)

Le nombre 4 est stocké dans la variable a et dans la variable b :

In [ ]:
a
Out[ ]:
4
In [ ]:
b
Out[ ]:
4

Bien qu'ils représentent tous deux le nombre 4 et qu'ils s'affichent de la même façon à l'écran, ils ne se comportent pas de la même façon:

In [ ]:
a/5
Out[ ]:
0.8
In [ ]:
b/5
Out[ ]:
4/5

C'est que les objets stockés dans les variables a et b ne sont pas du même type. La fonction type permet de connaître le type d'un objet avec la syntaxe type(objet) :

In [ ]:
type(a)
Out[ ]:
<type 'int'>
In [ ]:
type(b)
Out[ ]:
<class 'sympy.core.numbers.Integer'>

Cela explique le comportement différent de a/5 qui retourne un nombre décimal et b/5 qui retourne un nombre rationel de SymPy:

In [ ]:
type(a/5)
Out[ ]:
<type 'float'>
In [ ]:
type(b/5)
Out[ ]:
<class 'sympy.core.numbers.Rational'>

Comme le comportement d'un objet dépend de son type, il est souvent pertinent de vérifier le type d'un objet avant de l'utiliser. Les autres types très communs que nous allons voir dans les sections suivantes sont ci-dessous:

In [ ]:
type(4)
Out[ ]:
<type 'int'>
In [ ]:
type(4.0)
Out[ ]:
<type 'float'>
In [ ]:
type(True)
Out[ ]:
<type 'bool'>
In [ ]:
type('bonjour')
Out[ ]:
<type 'str'>
In [ ]:
type([3,4,5])
Out[ ]:
<type 'list'>
In [ ]:
type((3,4,5))
Out[ ]:
<type 'tuple'>
In [ ]:
type({2:3, 4:5})
Out[ ]:
<type 'dict'>

Nombres entiers (type int)

Les nombres entiers sont créés simplement en Python:

In [ ]:
4
Out[ ]:
4

Ils sont aussi obtenus par le résultat d'opérations sur les nombres entiers comme l'addition, la multiplication, la soustraction, le modulo et le quotient:

In [ ]:
4 + 6
Out[ ]:
10
In [ ]:
7 * 9
Out[ ]:
63
In [ ]:
4 - 6
Out[ ]:
-2
In [ ]:
27 % 10
Out[ ]:
7
In [ ]:
27 // 10
Out[ ]:
2

On peut vérifier que le résultat des opérations ci-haut est bel et bien un entier Python de type int :

In [ ]:
type(27 // 10)
Out[ ]:
<type 'int'>

En Python, la fonction int permet de créer un entier de type int :

In [ ]:
int()
Out[ ]:
0
In [ ]:
int(4)
Out[ ]:
4

Cette fonction permet aussi de traduire un objet d'un autre type en un nombre entier de Python de type int :

In [ ]:
int(4.02)
Out[ ]:
4
In [ ]:
int('41234')
Out[ ]:
41234

Pour stocker des nombres entiers un peu plus grand, Python utilise une autre structure de données appelé entier long. On peut tester à partir d'où cela se produit:

In [ ]:
type(2 ** 61)
Out[ ]:
<type 'int'>
In [ ]:
type(2 ** 62)
Out[ ]:
<type 'int'>
In [ ]:
type(2 ** 63)
Out[ ]:
<type 'long'>
In [ ]:
type(2 ** 64)
Out[ ]:
<type 'long'>

Nombres flottants (type float)

Les nombres décimaux aussi appelé nombre flottants ou nombre à virgule flottante sont créés simplement en Python:

In [ ]:
4.
Out[ ]:
4.0

Ils sont aussi obtenus par le résultat d'opérations sur les nombres flottants comme l'addition, la multiplication, la soustraction, le modulo et le quotient:

In [ ]:
4. * 3.41
Out[ ]:
13.64

On vérifie que le type du résultat précédent est bel et bien un nombre flottant de type float :

In [ ]:
type(_)
Out[ ]:
<type 'float'>

Les nombres flottants peuvent aussi être obtenus comme résultats d'opérations impliquant des nombres d'autres types comme la multiplication par un nombre entier ou la division de deux nombres entiers:

In [ ]:
4. * 3
Out[ ]:
12.0
In [ ]:
4 / 5
Out[ ]:
0.8

Finalement, les nombres flottants peuvent être créés avec la fonction float qui permet aussi de transformer un objet d'un autre type en nombre flottant:

In [ ]:
float()
Out[ ]:
0.0
In [ ]:
float(34)
Out[ ]:
34.0
In [ ]:
float('1234')
Out[ ]:
1234.0
In [ ]:
float('1234.56')
Out[ ]:
1234.56

Booléens (type bool)

Les booléens permettent de représenter les valeurs vrai et faux. On les écrit en anglais avec un majuscule:

In [ ]:
True
Out[ ]:
True
In [ ]:
False
Out[ ]:
False

Les valeurs True et False sont des objets de type bool :

In [ ]:
type(False)
Out[ ]:
<type 'bool'>
In [ ]:
type(True)
Out[ ]:
<type 'bool'>

Les opérations de base sur les booléens retournent aussi des booléens:

In [ ]:
True or False
Out[ ]:
True
In [ ]:
False and True
Out[ ]:
False

Si cela est nécessaire, voici toutes les possibilités de valeurs d'entrées pour le ET logique and qui retourne vrai lorsque les deux valeurs d'entrées sont vraies:

In [ ]:
True and True
Out[ ]:
True
In [ ]:
True and False
Out[ ]:
False
In [ ]:
False and True
Out[ ]:
False
In [ ]:
False and False
Out[ ]:
False

Pareillement le OU logique (or) retourne True dès qu'une des deux valeurs est vraie:

In [ ]:
True or True
Out[ ]:
True
In [ ]:
True or False
Out[ ]:
True
In [ ]:
False or True
Out[ ]:
True
In [ ]:
False or False
Out[ ]:
False

La négation (not) retourne l'opposé d'une valeur booléenne:

In [ ]:
not True
Out[ ]:
False
In [ ]:
not False
Out[ ]:
True

Un booléen peut être retourné par des fonctions ou des tests de comparaison:

In [ ]:
13 == 5 + 8
Out[ ]:
True
In [ ]:
20 > 34
Out[ ]:
False

La fonction bool permet de transformer un objet en un booléen. En général, les valeurs zéro ou les listes vides sont transformées en False et les valeurs non nulles ou les listes non vides sont transformées en True :

In [ ]:
bool(113)
Out[ ]:
True
In [ ]:
bool(0)
Out[ ]:
False
In [ ]:
bool(1)
Out[ ]:
True

Chaînes de caractères (type str)

En Python, les chaînes de caractères sont définies par l'utilisation des simple guillemets (') ou des doubles guillemets ("):

In [ ]:
'bonjour'
Out[ ]:
'bonjour'
In [ ]:
"bonjour"
Out[ ]:
'bonjour'

Si on veut utiliser les simples guillemets à l'intérieur de la chaînes de caractères, on doit utiliser les doubles pour l'entourer et vice versa:

In [ ]:
"aujourd'hui"
Out[ ]:
"aujourd'hui"
In [ ]:
'Je suis "ici"'
Out[ ]:
'Je suis "ici"'

Pour utiliser à la fois des simples et des doubles guillemets dans la chaîne de caractères, on utilise des triple double guillemets pour entourer la chaîne de caractères:

In [ ]:
"""Je suis "ici" aujourd'hui"""
Out[ ]:
'Je suis "ici" aujourd\'hui'

On peut créer des chaînes de caractères à partir d'autres objets en utilisant la fonction str :

In [ ]:
str(12345)
Out[ ]:
'12345'
In [ ]:
str(12345.789)
Out[ ]:
'12345.789'

Pour accéder aux lettres d'une chaîne de caractères, on utilise les crochets après la variable de la façon suivante:

In [ ]:
w = 'bonjour'
w[0]
Out[ ]:
'b'
In [ ]:
w[1]
Out[ ]:
'o'

Comme vous remarquez, l'indexation commence à zéro et non pas à un. C'est comme ça en Python. Ainsi la septième et dernière lettre du mot bonjour est à la position 6:

In [ ]:
w[6]
Out[ ]:
'r'

On peut aussi compter à partir de la fin avec des indices négatifs. La position -1 retourne la dernière lettre:

In [ ]:
w[-1]
Out[ ]:
'r'

On peut accéder aux sous-chaînes de la position i à la position j-1 avec la syntaxe w[i:j] de la façon suivante:

In [ ]:
w[2:5]
Out[ ]:
'njo'

Si on ne spécifie pas le début ou la fin, alors le comportement par défaut est d'aller jusqu'au bout:

In [ ]:
w[:4]
Out[ ]:
'bonj'