Les types de données - classer les découvertes

Bon retour au campement ! Hier, "12" + 5 m'a donné une erreur au lieu de 17 : "12" est du texte, 5 est un nombre. Tout bon explorateur sait classer ses découvertes, et en Python ces « espèces » s'appellent des types de données.

Les types de données de base en Python

Dans la jungle, on rencontre différentes formes de vie - animaux, plantes, insectes. De la même façon, Python a différents types de données.

1. int (Integer) - Les nombres entiers

Les entiers décrivent tout ce qu'on compte à l'unité : membres de l'équipe, jours de marche, spécimens. Ils peuvent être négatifs et très grands :

1# Nombres entiers - comme le nombre d'espèces découvertes
2species_count = 42
3expedition_day = 7
4team_members = 5
5
6# Peuvent être négatifs
7temperature_drop = -5
8depth_below_sea = -100
9
10# Python 3 gère de très grands nombres !
11huge_number = 999999999999999999999

Python alloue lui-même la mémoire des grands nombres, donc huge_number ne débordera pas. Un int n'a jamais de point.

2. float (Float) - Les nombres à virgule flottante

Les mesures tombent rarement juste : température ou distance ont des décimales. On utilise pour elles un float, écrit avec un point ou en notation scientifique :

1# Nombres avec une partie décimale
2temperature = 32.5
3humidity = 78.3
4distance_km = 15.7
5
6# Notation scientifique
7speed_of_light = 3e8  # 3 * 10^8 = 300000000.0 (float !)
8tiny_number = 1.5e-10  # 0.00000000015

3e8 donne toujours un float, même quand le résultat est rond. Les floats peuvent être imprécis sur les derniers chiffres : 0.1 + 0.2 vaut 0.30000000000000004.

3. str (String) - Le texte

Noms, descriptions et notes sont du texte. Une chaîne se place entre guillemets simples ou doubles, et une longue description entre triples guillemets :

1# Texte entre guillemets simples ou doubles
2explorer_name = "Darwin"
3location = 'Serengeti'
4
5# Chaînes multi-lignes (triples guillemets)
6description = """
7Ceci est une description plus longue
8sur plusieurs lignes
9de texte.
10"""
11
12# Caractères d'échappement
13message = "Darwin a dit : \"Explorons !\""
14path = "C:\\Users\\Darwin\\jungle"  # Chemin Windows
15
16# Raw string (ignore les échappements)
17path_raw = r"C:\Users\Darwin\jungle"

La barre oblique inverse change le sens du caractère suivant : \" place un guillemet dans la chaîne, et deux barres en donnent une. Le préfixe r désactive ce mécanisme, pratique pour les chemins Windows.

4. bool (Boolean) - Les valeurs logiques

La zone est-elle sûre ? A-t-on trouvé de l'eau ? Un bool répond à ces questions avec seulement deux valeurs :

1# Seulement deux valeurs : True ou False
2is_dangerous = True
3found_water = False
4is_raining = True
5
6# Le résultat d'une comparaison est un bool
7temperature = 35
8is_hot = temperature > 30  # True
9
10age = 15
11is_adult = age >= 18  # False

Les comparaisons renvoient toujours un bool, donc 5 > 3 donne True. La casse compte : true en minuscules est un nom inconnu pour Python.

Vérifier les types de données - type()

Quand tu ne sais pas à quelle espèce tu as affaire, demande à Python. La fonction type() renvoie le type d'une valeur :

1# La fonction type() montre le type de la variable
2species_count = 42
3print(type(species_count))  # <class 'int'>
4
5temperature = 32.5
6print(type(temperature))  # <class 'float'>
7
8name = "Darwin"
9print(type(name))  # <class 'str'>
10
11is_safe = True
12print(type(is_safe))  # <class 'bool'>
13
14# Utilisation pratique
15data = 42
16if type(data) == int:
17    print("C'est un nombre entier !")

<class 'int'> signifie « la valeur appartient à la classe int ». Dans les conditions, je te conseille plutôt isinstance(data, int), qui accepte aussi les types apparentés.

Convertir entre les types (Type Casting)

Parfois, on doit changer le type d'une donnée - comme une traduction entre deux langues.

String → Int/Float

Le plus souvent, un nombre arrive sous forme de texte, par exemple depuis input(). Les fonctions int() et float() le traduisent en nombre :

1# String → Int
2age_text = "25"
3age = int(age_text)
4print(age + 5)  # 30
5
6# String → Float
7temperature_text = "32.5"
8temperature = float(temperature_text)
9print(temperature + 2.5)  # 35.0
10
11# ATTENTION ! Erreur si la chaîne n'est pas un nombre
12# bad_conversion = int("abc")  # ValueError!
13# int("42.5")  # aussi ValueError - int() n'accepte pas de point
14
15print(int(float("42.5")))  # 42

int() n'accepte qu'un texte de nombre entier, donc fais d'abord passer un texte avec un point par float(), comme à la dernière ligne.

Int/Float → String

str() fonctionne dans l'autre sens. Il sert quand on colle un nombre à du texte avec +, qui ne mélange pas les types :

1# Int → String
2species_count = 42
3count_text = str(species_count)
4print("Découvert " + count_text + " espèces")  # Concaténation de chaînes
5
6# Float → String
7temperature = 32.5
8temp_text = str(temperature)
9message = f"Température : {temp_text}°C"

Sans str(), la ligne avec + finirait par une TypeError. Dans une f-string, la conversion se fait toute seule.

Int ↔ Float

On passe d'un nombre à l'autre dans les deux sens, mais le passage de float à int coupe la partie décimale :

1# Int → Float
2whole_number = 10
3decimal_number = float(whole_number)  # 10.0
4
5# Float → Int (tronque la partie décimale !)
6decimal = 15.7
7whole = int(decimal)  # 15 (PAS 16 !)
8
9decimal2 = 15.2
10whole2 = int(decimal2)  # 15

int() n'arrondit pas, il coupe tout ce qui suit le point. Pour arrondir, utilise round(15.7), qui donne 16.

Conversions de bool

On peut demander à n'importe quelle valeur si elle est « vraie ». Zéro et le texte vide valent False, alors que tout autre nombre et tout texte non vide valent True :

1# Nombres → Bool
2# 0 = False, tous les autres = True
3print(bool(0))    # False
4print(bool(1))    # True
5print(bool(-5))   # True
6print(bool(100))  # True
7
8# String → Bool
9# Chaîne vide = False, non vide = True
10print(bool(""))       # False
11print(bool("Darwin")) # True
12print(bool(" "))      # True (un espace est un caractère !)
13
14# Bool → Int
15print(int(True))   # 1
16print(int(False))  # 0

True vaut 1 et False vaut 0, car bool est une variante d'int. D'où la hiérarchie bool → int → float : une opération entre un int et un float donne un float.

Opérations spécifiques aux types

Opérations sur les nombres (int, float)

Les nombres acceptent sept opérations de base. Remarque les deux sortes de division et la puissance avec deux astérisques :

1# Opérations de base
2a = 10
3b = 3
4
5print(a + b)   # 13 (addition)
6print(a - b)   # 7  (soustraction)
7print(a * b)   # 30 (multiplication)
8print(a / b)   # 3.333... (division - TOUJOURS float !)
9print(a // b)  # 3 (division entière)
10print(a % b)   # 1 (reste - modulo)
11print(a ** b)  # 1000 (puissance : 10^3)
12
13# Opérations sur les floats
14x = 5.5
15y = 2.5
16print(x + y)   # 8.0
17print(x * y)   # 13.75
18
19# Mélanger int et float → le résultat est un float
20mixed = 10 + 5.5  # 15.5 (float)

Même 10 / 2 donne 5.0. L'opérateur // supprime le reste, et % renvoie justement ce reste, d'où 3 et 1.

Opérations sur les chaînes

Le texte a ses propres outils : assemblage, répétition, longueur, majuscules, index et découpage :

1# Concaténation (assemblage)
2first_name = "Charles"
3last_name = "Darwin"
4full_name = first_name + " " + last_name
5print(full_name)  # Charles Darwin
6
7# Répétition
8jungle_cry = "Help! " * 3
9print(jungle_cry)  # Help! Help! Help!
10
11# Longueur d'une chaîne
12name = "Darwin"
13print(len(name))  # 6
14
15# Indexation (à partir de 0 !)
16text = "Python"
17print(text[0])   # P
18print(text[1])   # y
19print(text[-1])  # n (dernier caractère)
20print(text.upper())  # PYTHON
21
22# Slicing (découpage)
23word = "Expedition"
24print(word[0:4])   # Expe
25print(word[4:])    # dition
26print(word[:4])    # Expe
27print(word[::2])   # Epdto (un caractère sur deux)

Les index commencent à zéro, les négatifs comptent depuis la fin. Dans la tranche [0:4], le premier numéro est inclus, le second non. upper() renvoie une nouvelle chaîne, text ne change pas.

None - un type spécial

None est une valeur spéciale qui signifie « pas de valeur », comme un piège vide. Tu étudieras les fonctions avec def dans quelques leçons :

1# None - comme une boîte vide
2treasure = None
3print(treasure)  # None
4print(type(treasure))  # <class 'NoneType'>
5
6# Utilisation pratique
7def find_species(name):
8    if name == "Python regius":
9        return "Trouvé !"
10    return None  # Pas trouvé
11
12result = find_species("Unknown")
13if result is None:
14    print("Espèce inconnue")

On vérifie l'absence de résultat avec is None. None n'est ni zéro ni du texte vide, c'est un type à part.

Exemple pratique - Calculatrice d'expédition

Combinons conversions et opérations : le programme demande trois valeurs, convertit leurs types et calcule la vitesse moyenne :

1print("=== Calculatrice d'expédition ===\n")
2
3# Collecte des données
4distance_text = input("Distance (km) : ")
5time_text = input("Temps (heures) : ")
6team_size_text = input("Taille de l'équipe : ")
7
8# Conversion vers les types appropriés
9distance = float(distance_text)
10time = float(time_text)
11team_size = int(team_size_text)
12
13# Calculs
14avg_speed = distance / time
15distance_per_person = distance / team_size
16
17# Affichage des résultats
18print("\n--- RÉSULTATS ---")
19print(f"Vitesse moyenne : {avg_speed:.2f} km/h")
20print(f"Distance par personne : {distance_per_person:.2f} km")
21print(f"Type de distance : {type(distance)}")
22print(f"Type de team_size : {type(team_size)}")

{avg_speed:.2f} affiche deux décimales au lieu de 4.666666666666667. Cela change seulement l'affichage, pas le nombre lui-même.

Exercice pratique

Crée un programme qui :

1. Demande la température en Fahrenheit
2. La convertit en Celsius : C = (F - 32) × 5/9
3. Affiche le résultat
4. Indique s'il fait chaud (>30°C), normal (15-30°C) ou froid (<15°C)

1# Calculatrice de conversion Fahrenheit vers Celsius
2
3# TODO : Récupère la température en Fahrenheit
4fahrenheit = float(input("Température en Fahrenheit : "))
5
6# TODO : Calcule les Celsius : C = (F - 32) x 5/9
7celsius = (fahrenheit - 32) * 5 / 9
8
9# TODO : Affiche le résultat
10print(f"{fahrenheit}°F = {celsius:.1f}°C")
11
12# TODO : Vérifie s'il fait chaud (>30), normal (15-30) ou froid (<15)
13if celsius > 30:
14    print("Il fait chaud dans la jungle !")
15elif celsius >= 15:
16    print("Température agréable")
17else:
18    print("Froid pour une jungle !")

Résumé

Avant de continuer, assure-toi que :

• Tu connais les types int, float, str, bool et None
• Tu vérifies les types avec type() et tu les convertis
• Tu connais la différence entre / et //
• Tu comprends l'indexation des chaînes

Dans la prochaine leçon, Darwin te montrera les opérateurs - les outils mathématiques et logiques de l'explorateur !

Retiens : un type est l'espèce de ta donnée - vérifie l'espèce avant d'en faire quoi que ce soit.