Programmation Python/Type

Un livre de Wikibooks.

L'objectif de cette section est la découverte des types de données Python et de la façon dont on les écrits sous formes littérales. L'étude complète des types complexe nécessite l'étude complète des structures de contrôles et sera donc abordé postérieurement.

[modifier] Type de données

Python est un langage dont le typage est automatique. Cela signifie que bien que gérant différents types, lorsqu'une variable est affectée, l'interpréteur trouvera automatiquement son type.

[modifier] La fonction type()

La fonction type() permet de connaître le type d'une variable

>>> a=3
>>> type(a)
<type 'int'>

[modifier] Les nombres

Il existe deux types pour définir des nombres entiers : le type int et le type long. Il existe également un type pour représenter des nombres à virgule : le type float.

[modifier] Les nombres entiers de type int

Les int représentent le type le plus facilement représentable sur une architecture donnée. Par exemple, sur une machine 32-bits, la taille d'un int sera de 32-bit, donc un int permettra de représenter des nombres entre − 2³1 + 1 et 2³1 − 1, soit entre -2 147 483 647 et 2 147 483 647.

Un littéral int s'écrit tout simplement avec les chiffres de 0 à 9, précédé éventuellement du symbole -. Il est possible d'écrire ce littéral suivant trois bases :

• la base décimal : le littéral devra commencer par un chiffre entre 1 et 9
• la base octal (base 8) : le littéral devra commencer par 0 suivie de chiffre de 0 à 7
• la base hexadécimal (base 16): le littéral devra commencer par 0x suivie de chiffre de 0 à 9 et de lettre de A à F (en minuscule ou majuscule)

x=1
x=0
x=-33
x=4566
x=2147483647
x=076 #équivalent à x=62
x=0xFF #équivalent à x=255
x=0xa1 #équivalent à x=161

[modifier] Les nombres entiers de type long

Un entier long est un entier dont la taille n'est limitée que par la mémoire allouée par l'ordinateur à l'interpréteur Python. C'est à dire qu'un long permet d'écrire des entiers aussi grand que l'on veut.

Il existe deux manières d'utiliser des long :

• il faut rajouter L ou l à la fin d'un littéral entier pour qu'il soit automatiquement long
• lorsque le résultat d'une opération dépasse la capacité de stockage d'un int, alors, ce résultat est automatiquement convertit en long

x=1L
x=-45l
x=121212121212121212121212121 #Automatiquement converti en long
x=2147483647+1

Il n'est pas nécessaire d'utiliser le type long de manière systématique : pour les entiers de taille raisonnable, le type int est beaucoup plus optimisé.

Pour convertir un long en int (et inversement), il est possible d'utiliser les fonctions int() et long().

x = int(1L) #x est un int
x = long(1) #x est un long
x = int(12121212121212121) #x est quand même un long

[modifier] Les nombres à virgule flottante (float)

Un nombre à virgule flottante est un nombre décimale qu'il est possible de représenter par sa mantisse et son exposant. Par exemple, le nombre 125,789 est représentable par le couple (mantisse = 1,25789, exposant = 2). La mantisse étant toujours comprise entre -10 et 10 exclus.

Les nombres sont traduits par la formule nombre = mantisse * 10^exposant.

Les limites dépendent de l'architecture de la machine et sont équivalentes au type de donnée double du langage C.

Les littéraux peuvent s'écrire avec les chiffres, le caractère virgule pour indiquer la séparation entre la partie entière et la partie décimale et la lettre 'e' ou 'E' pour spécifier l'exposant.

x = 1.234
x = 1.0 #Notons qu'un entier peut être un flottant
x = 1. #Même résultat que précédemment
x = 1.234e54 #C'est à dire <math>1.234*10^{54}</math>
x = 1.234E54 #idem
x = -1.454e-2 #La mantisse et l'exposant peuvent être négatifs

[modifier] Les nombres complexes

Python est un des rares langages à proposer un type de base pour les nombres complexes . Un nombre complexe est un nombre composé d'une partie réelle et d'une partie imaginaire. On note i une des racines du polynôme x² = − 1.

(voir aussi l'article de wikipédia sur les nombres complexes )

En anglais, le nombre i est noté j. Il en est de même en Python.

Un littéral complexe s'écrit donc : a + bj, avec a et b des variables de type float. Attention, j doit être précédé d'un nombre car sinon, Python l'interprétera comme étant la variable j. Il ne doit pas y avoir d'espace entre ce nombre et j.

x = 1 + 1j
x = 1.2e3 + 1.5e7j
x = 5j + 4 
x = 1 + x*1j

[modifier] Les booléens

Un booléen est un type de données qui ne peut prendre que deux valeurs : vrai ou faux. En Python, les constantes littérales sont notées True et False.

Tous les types de variables peuvent être interprétés de manière booléenne. Par exemple, pour les entiers (int), la valeur 0 correspond à faux et les autres valeurs à vrai. Il en est de même pour tous les autres types : une valeur particulière vaut False et le reste des valeurs True. Le tableau suivant présente les valeurs "faux" pour les principaux type de données.

[modifier] Les chaînes, introduction

Les chaînes de caractères sont des suites de caractères non modifiables en Python. Les littéraux chaînes s'écrivent soit entre guillemets, soit entre simple quote. Il est possible de mettre des quote (respectivement des guillemets) dans une chaîne entouré de guillemets (respectivement, de quote).

 a = "Bonjour"
 a = 'Bonjour'
 a = "Je m'appelle Pierre"
 a = 'Il lui a dit : "Bonjour"'

Pour une étude plus approfondie sur les chaînes, voir la section sur les chaînes de caractères.

[modifier] La conversion des types

Il existe plusieurs fonctions qui permettent de forcer le type d'une variable en un autre type.

• int() : permet de modifier une variable en entier. Provoque une erreur si cela n'est pas possible.
• long() : transforme une valeur en long.
• La fonction str() permet de transformer la plupart des variables d'un autre type en chaînes de caractère.
• float() : permet la transformation en flottant.
• repr() : similaire à str. Voir la partie sur les objets
• eval() : évalue le contenu de son argument comme si c'était du code Python.

<< Page précédente: Variable | Sommaire général | Page suivante: Opérateur >>