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.
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[ ]:
In [ ]:
b
Out[ ]:
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[ ]:
In [ ]:
b/5
Out[ ]:
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[ ]:
In [ ]:
type(b)
Out[ ]:
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[ ]:
In [ ]:
type(b/5)
Out[ ]:
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[ ]:
In [ ]:
type(4.0)
Out[ ]:
In [ ]:
type(True)
Out[ ]:
In [ ]:
type('bonjour')
Out[ ]:
In [ ]:
type([3,4,5])
Out[ ]:
In [ ]:
type((3,4,5))
Out[ ]:
In [ ]:
type({2:3, 4:5})
Out[ ]:
In [ ]:
4
Out[ ]:
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[ ]:
In [ ]:
7 * 9
Out[ ]:
In [ ]:
4 - 6
Out[ ]:
In [ ]:
27 % 10
Out[ ]:
In [ ]:
27 // 10
Out[ ]:
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[ ]:
En Python, la fonction int permet de créer un entier de type int :
In [ ]:
int()
Out[ ]:
In [ ]:
int(4)
Out[ ]:
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[ ]:
In [ ]:
int('41234')
Out[ ]:
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[ ]:
In [ ]:
type(2 ** 62)
Out[ ]:
In [ ]:
type(2 ** 63)
Out[ ]:
In [ ]:
type(2 ** 64)
Out[ ]:
In [ ]:
4.
Out[ ]:
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[ ]:
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[ ]:
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[ ]:
In [ ]:
4 / 5
Out[ ]:
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[ ]:
In [ ]:
float(34)
Out[ ]:
In [ ]:
float('1234')
Out[ ]:
In [ ]:
float('1234.56')
Out[ ]:
In [ ]:
True
Out[ ]:
In [ ]:
False
Out[ ]:
Les valeurs True et False sont des objets de type bool :
In [ ]:
type(False)
Out[ ]:
In [ ]:
type(True)
Out[ ]:
Les opérations de base sur les booléens retournent aussi des booléens:
In [ ]:
True or False
Out[ ]:
In [ ]:
False and True
Out[ ]:
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[ ]:
In [ ]:
True and False
Out[ ]:
In [ ]:
False and True
Out[ ]:
In [ ]:
False and False
Out[ ]:
Pareillement le OU logique (or) retourne True dès qu'une des deux valeurs est vraie:
In [ ]:
True or True
Out[ ]:
In [ ]:
True or False
Out[ ]:
In [ ]:
False or True
Out[ ]:
In [ ]:
False or False
Out[ ]:
La négation (not) retourne l'opposé d'une valeur booléenne:
In [ ]:
not True
Out[ ]:
In [ ]:
not False
Out[ ]:
Un booléen peut être retourné par des fonctions ou des tests de comparaison:
In [ ]:
13 == 5 + 8
Out[ ]:
In [ ]:
20 > 34
Out[ ]:
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[ ]:
In [ ]:
bool(0)
Out[ ]:
In [ ]:
bool(1)
Out[ ]:
In [ ]:
'bonjour'
Out[ ]:
In [ ]:
"bonjour"
Out[ ]:
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[ ]:
In [ ]:
'Je suis "ici"'
Out[ ]:
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[ ]:
On peut créer des chaînes de caractères à partir d'autres objets en utilisant la fonction str :
In [ ]:
str(12345)
Out[ ]:
In [ ]:
str(12345.789)
Out[ ]:
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[ ]:
In [ ]:
w[1]
Out[ ]:
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[ ]:
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[ ]:
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[ ]:
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[ ]: