02 - Types de base

En Python, chaque valeur possède un type qui détermine ce qu’on peut en faire. On ne multiplie pas un mot par un autre mot, et on ne met pas un nombre en majuscules. Le type d’une donnée définit les opérations autorisées sur cette donnée.

Python propose quatre types de base, que l’on utilise au quotidien :

La fonction type()

Pour connaître le type d’une valeur ou d’une variable, on utilise la fonction type() :

print(type(42))         # <class 'int'>
print(type(3.14))       # <class 'float'>
print(type('Bonjour'))  # <class 'str'>
print(type(True))       # <class 'bool'>

C’est un outil précieux pour comprendre le comportement d’un programme, notamment lorsqu’une erreur survient.

Question. Quel est le type de chacune des valeurs suivantes : 7, 7.0, "7", True et "True" ?

print(type(7), type(7.0), type("7"), type(True), type("True"))

<class 'int'> <class 'float'> <class 'str'> <class 'bool'> <class 'str'>

En Python, c’est la donnée qui est typée, pas la variable. Une même variable peut donc référencer successivement des valeurs de types différents :

x = 42          # x référence un int
x = "bonjour"   # maintenant x référence un str

Les entiers (int)

Un entier est un nombre sans partie décimale : positif, négatif ou nul.

age = 17
temperature = -5
population = 8000000000
print(type(age))  # <class 'int'>

Particularité de Python : contrairement à beaucoup de langages, la taille des entiers est illimitée. On peut manipuler des nombres aussi grands qu’on le souhaite sans risquer de dépassement :

grand_nombre = 2 ** 100
print(grand_nombre)  # 1267650600228229401496703205376

Division / et division entière //

Parmi les opérations sur les entiers (détaillées dans le cours sur les opérateurs ), la division mérite une attention particulière. Voici deux divisions de 10 par 2, l’une avec une barre, l’autre avec deux barres :

print(10 / 2)
print(10 // 2)

Question. Quels nombres ces deux lignes affichent-elles ?

5.0
5

print(type(10 / 2))   # <class 'float'>
print(type(10 // 2))  # <class 'int'>
print(7 // 2)         # 3 : le quotient de 7 par 2

Pour des nombres positifs, la division entière revient à supprimer la partie décimale du quotient : 7 / 2 vaut 3.5, et 7 // 2 vaut 3.

Les flottants (float)

Un flottant (nombre à virgule flottante) est un nombre avec une partie décimale. En Python, on utilise le point comme séparateur décimal (convention anglo-saxonne) :

pi = 3.14159
taille = 1.75
negatif = -0.5
print(type(pi))  # <class 'float'>

Remarque : écrire 3.0 crée un float, pas un int. La seule présence du point décimal suffit à changer le type.

Calcul qui mêle les deux types : si un calcul mêle un int et un float, le résultat est un float. Par exemple, 3 + 4.0 vaut 7.0 et 2 * 1.5 vaut 3.0.

Précision limitée

Les flottants sont stockés en mémoire selon la norme IEEE 754 sur 64 bits. Leur précision est limitée à environ quinze chiffres significatifs, ce qui entraîne parfois des résultats surprenants.

print(0.1 + 0.2)

Question. Qu’affiche cette ligne ?

0.30000000000000004

Conséquence pratique : on ne compare jamais deux flottants avec ==. On vérifie plutôt que leur différence est très petite :

a = 0.1 + 0.2
b = 0.3
print(a == b)              # False (piège !)
print(abs(a - b) < 1e-10)  # True (bonne méthode)

La fonction abs(x) renvoie la valeur absolue de x, c’est-à-dire sa distance à zéro : abs(-3) vaut 3. L’écriture 1e-10 est la notation scientifique de 10⁻¹⁰, soit 0,0000000001 ; c’est un float.

Les chaînes de caractères (str)

Une chaîne de caractères est une séquence de caractères entourée de guillemets simples ou doubles :

prenom = 'Alice'
message = "Bonjour le monde"
print(type(prenom))  # <class 'str'>

Les deux notations sont équivalentes. Les guillemets doubles sont pratiques lorsque la chaîne contient une apostrophe :

phrase = "L'informatique est passionnante"

Opérations de base sur les chaînes

# Longueur
mot = 'Python'
print(len(mot))      # 6

# Concaténation (assemblage)
prenom = 'Ada'
nom = 'Lovelace'
complet = prenom + ' ' + nom
print(complet)       # Ada Lovelace

# Répétition
print('ha' * 3)      # hahaha

Un nombre ou une chaîne ?

Voici le piège le plus fréquent des débutants. Ces deux lignes se ressemblent beaucoup :

print(42 + 1)
print("42" + "1")

Question. Affichent-elles la même chose ?

43
421

À retenir : les guillemets changent tout. Sans guillemets, 42 est un nombre ; avec des guillemets, "42" est une chaîne de caractères.

Attention : on ne peut pas additionner une chaîne et un nombre directement.

age = 17
print("J'ai " + age + " ans")

TypeError: can only concatenate str (not "int") to str

Il faut convertir le nombre en chaîne avec str(), ou utiliser une f-string, plus simple :

age = 17
print("J'ai " + str(age) + " ans")
print(f"J'ai {age} ans")

J'ai 17 ans
J'ai 17 ans

Les chaînes de caractères seront étudiées en détail dans un chapitre dédié .

Les booléens (bool)

Un booléen ne peut prendre que deux valeurs : True (vrai) ou False (faux). Ces valeurs commencent obligatoirement par une majuscule.

majeur = True
inscrit = False
print(type(majeur))  # <class 'bool'>

Les booléens apparaissent naturellement comme résultat des comparaisons (étudiées dans le cours sur les opérateurs ) :

print(5 > 3)    # True
print(2 == 7)   # False

La valeur spéciale None

Python dispose d’une valeur particulière, None, qui représente l’absence de valeur. Son type est NoneType :

resultat = None
print(type(resultat))  # <class 'NoneType'>

On utilise None pour initialiser une variable dont on ne connaît pas encore la valeur. On le rencontre aussi comme valeur de retour de certaines fonctions (ce point sera détaillé dans le chapitre sur les fonctions). Pour savoir si une variable vaut None, on peut l’afficher : si x vaut None, print(x) affiche None.

Valeurs « vraies » et « fausses »

En Python, certaines valeurs sont considérées comme « fausses » dans un contexte booléen : 0, 0.0, '' (la chaîne vide) et None. Toute autre valeur est considérée comme « vraie ». On peut le vérifier avec bool() ; cette règle servira surtout dans les conditions (chapitre 04).

print(bool(0))      # False
print(bool(42))     # True
print(bool(''))     # False
print(bool('abc'))  # True
print(bool(None))   # False

Piège fréquent : la chaîne "False" est vraie, car c’est une chaîne non vide (cinq caractères). Seule la chaîne vide "" est fausse.

Conversions de types

Il est souvent nécessaire de convertir une valeur d’un type à un autre. Python offre des fonctions portant le nom du type cible :

# Entier vers flottant
print(float(42))      # 42.0

# Chaîne vers entier
print(int('15'))      # 15

# Chaîne vers flottant
print(float('3.14'))  # 3.14

# Nombre vers chaîne
print(str(42))        # '42'
print(str(3.14))      # '3.14'

Dans l’autre sens, la conversion d’un flottant en entier réserve une surprise :

print(int(3.7))
print(int(-2.9))

Question. Que donnent ces deux conversions ?

3
-2

Pour arrondir, on utilise round() : round(3.7) donne 4. Avec un second argument, round(x, n) arrondit x à n chiffres après la virgule : round(3.14159, 2) donne 3.14.

La fonction input() renvoie une chaîne

La fonction input() demande à l’utilisateur de taper une valeur au clavier. Supposons qu’il tape 17, et qu’on veuille calculer son âge l’année prochaine :

age = input("Ton âge ? ")   # l'utilisateur tape 17
print(age + 1)

TypeError: can only concatenate str (not "int") to str

Python affiche une erreur, car input() renvoie toujours une chaîne de caractères : age contient la chaîne "17", et Python refuse d’ajouter un nombre à une chaîne. La solution consiste à convertir la saisie en entier avec int(), dès la saisie :

age = int(input("Ton âge ? "))   # l'utilisateur tape 17
print(age + 1)

18

Exemple pas à pas : saisie et conversion

age = input("Ton âge ? ")    # l'utilisateur tape 17
futur = int(age) + 10
print(f"Dans 10 ans : {futur}")

Dans 10 ans : 27

On suit le type de chaque valeur, étape par étape :

Sans la conversion int(age), Python tenterait '17' + 10 et produirait un TypeError, car on ne peut pas additionner une chaîne et un entier.

Conversions impossibles

Certaines conversions échouent et produisent une erreur ValueError :

# int('abc')    # ValueError : la chaîne ne représente pas un nombre
# float('abc')  # ValueError

print(int("3.14"))

Question. Que donne int("3.14") ?

ValueError: invalid literal for int() with base 10: '3.14'

À retenir

1. Chaque valeur a un type : int, float, str ou bool. La fonction type() le donne.
2. Les guillemets font la chaîne : 42 est un entier, "42" une chaîne de caractères, et "42" + "1" vaut "421".
3. Le point décimal fait le flottant : 7.0 est un float.
4. Les entiers ont une taille illimitée. La division / renvoie toujours un flottant, la division entière // un entier.
5. Les flottants sont approchés : on ne compare jamais deux flottants avec ==.
6. input() renvoie toujours une chaîne : on la convertit avec int() ou float() avant de calculer.
7. int() supprime la partie décimale sans arrondir ; round() arrondit.
8. True et False s’écrivent avec une majuscule ; une chaîne non vide est « vraie », même "False".

Résumé