3. Variables et types de données de base

Au Chapitre 2, vous avez appris à écrire de petits programmes qui affichent du texte, acceptent des entrées et effectuent des opérations de base. Cependant, ces programmes avaient une limite importante : ils ne pouvaient pas stocker des informations pour une utilisation ultérieure ni travailler avec différents types de données de manière sophistiquée. Dans ce chapitre, vous allez apprendre comment Python stocke et gère les informations en utilisant des variables et des types de données.

Vous pouvez considérer les variables comme des conteneurs étiquetés qui contiennent des informations. Tout comme vous pourriez utiliser des boîtes étiquetées pour organiser des objets chez vous, Python utilise des variables pour organiser et gérer les données dans vos programmes. Mais toutes les données ne sont pas identiques : un nombre est fondamentalement différent d’un texte, et Python doit savoir avec quel type de données il travaille. C’est là qu’interviennent les types de données.

À la fin de ce chapitre, vous aurez compris :

• Comment créer et nommer correctement des variables
• Ce que sont les types de données et pourquoi ils sont importants
• Comment travailler avec des nombres, du texte et des valeurs logiques
• Comment convertir entre différents types de données
• Comment Python représente les données en interne

Ces notions constituent la base de tout ce que vous ferez ensuite en Python, donc nous les explorerons en profondeur avec de nombreux exemples pratiques.

3.1) Nommer et créer des variables

3.1.1) Ce que sont les variables et pourquoi elles sont importantes

Une variable est un nom qui fait référence à une valeur stockée dans la mémoire de votre ordinateur. Lorsque vous créez une variable, vous créez en fait une étiquette qui pointe vers une donnée. Cela vous permet de :

1. Stocker des informations pour une utilisation ultérieure dans votre programme
2. Réutiliser la même valeur plusieurs fois sans avoir à la retaper
3. Mettre à jour des valeurs au fur et à mesure que votre programme s’exécute
4. Rendre votre code lisible en utilisant des noms significatifs au lieu de valeurs brutes

Voyons un exemple concret. Sans variables, si vous vouliez calculer l’aire d’un rectangle, vous pourriez écrire :

# without_variables.py
print("Rectangle area:", 15 * 8)

Cela fonctionne, mais que se passe‑t‑il si vous devez utiliser ces dimensions plusieurs fois ? Et que représentent 15 et 8 ? Avec des variables, le code devient plus clair et plus flexible :

# with_variables.py
length = 15
width = 8
area = length * width
print("Rectangle area:", area)  # Output: Rectangle area: 120

Désormais, le code est auto‑documenté : toute personne qui le lit peut immédiatement comprendre que nous calculons l’aire d’un rectangle avec des dimensions spécifiques. Si nous devons changer les dimensions, nous mettons simplement à jour les affectations de variables en haut.

3.1.2) Créer des variables avec l’affectation

En Python, vous créez une variable à l’aide de l’opérateur d’affectation (=). La syntaxe de base est :

variable_name = value

Le signe = ne signifie pas « égal » au sens mathématique. Il signifie plutôt « affecter la valeur à droite au nom à gauche ». C’est une distinction cruciale. Lorsque Python voit cette instruction, il :

1. Évalue l’expression à droite du =
2. Crée ou met à jour le nom de variable à gauche
3. Fait en sorte que ce nom fasse référence à la valeur obtenue

Voici plusieurs exemples de création de variables :

# creating_variables.py
age = 25
temperature = 72.5
name = "Alice"
is_student = True
 
print(age)          # Output: 25
print(temperature)  # Output: 72.5
print(name)         # Output: Alice
print(is_student)   # Output: True

Remarquez que nous n’avons pas besoin de déclarer le type de données que chaque variable va contenir : Python le déduit automatiquement à partir de la valeur que vous assignez. Cela s’appelle le typage dynamique, et cela rend Python très flexible et simple d’utilisation.

Vous pouvez aussi créer plusieurs variables sur une seule ligne en utilisant une affectation multiple :

# multiple_assignment.py
x, y, z = 10, 20, 30
print(x)  # Output: 10
print(y)  # Output: 20
print(z)  # Output: 30
 
# You can even assign the same value to multiple variables
a = b = c = 100
print(a, b, c)  # Output: 100 100 100

La première forme (appelée dépaquetage de tuple — nous verrons les tuples au Chapitre 14) assigne chaque valeur à la variable correspondante dans l’ordre. La deuxième forme assigne la même valeur aux trois variables.

3.1.3) Règles et conventions de nommage des variables

Python a des règles spécifiques sur ce qui constitue un nom de variable valide. Certaines sont des exigences (règles que vous devez suivre), d’autres sont des conventions (lignes directrices qui rendent votre code plus lisible et cohérent avec le reste du code Python).

Exigences (à respecter absolument) :

1. Doit commencer par une lettre (a‑z, A‑Z) ou un underscore (_) : un nom de variable ne peut pas commencer par un chiffre.
2. Peut contenir des lettres, des chiffres et des underscores : après le premier caractère, vous pouvez utiliser des lettres, des chiffres et des underscores dans n’importe quelle combinaison.
3. Ne peut pas contenir d’espaces ni de caractères spéciaux : espaces, tirets et la plupart des signes de ponctuation ne sont pas autorisés.
4. Ne peut pas être un mot‑clé Python : Python réserve certains mots pour son propre usage (comme if, for, while, def, etc.).
5. Sensible à la casse : age, Age et AGE sont trois variables différentes.

Voici des exemples de noms de variables valides et invalides :

# valid_names.py
# Valid variable names
user_age = 30
firstName = "John"
total_2024 = 1000
_private = "hidden"
x = 5
MAX_SIZE = 100
 
# Invalid variable names (these will cause errors)
# 2nd_place = "silver"      # Error: starts with digit
# user-name = "alice"       # Error: contains hyphen
# total amount = 500        # Error: contains space
# class = "Python 101"      # Error: 'class' is a keyword

Conventions (à suivre pour la lisibilité) :

1. Utiliser des minuscules avec underscores pour les variables ordinaires : ce style est appelé snake_case et c’est la norme en Python.

   python

   user_age = 25
   total_price = 99.99
   is_valid = True

2. Utiliser des MAJUSCULES pour les constantes : valeurs qui ne doivent pas changer pendant l’exécution du programme.

   python

   MAX_ATTEMPTS = 3
   PI = 3.14159
   DEFAULT_COLOR = "blue"

3. Utiliser des noms descriptifs : les noms de variables doivent indiquer clairement ce qu’elles représentent.

   python

   # Good: clear and descriptive
   student_count = 30
   average_temperature = 72.5
    
   # Poor: unclear abbreviations
   sc = 30
   avg_tmp = 72.5
    
   # Poor: too generic
   x = 30
   data = 72.5

4. Éviter les noms à une seule lettre sauf cas particuliers : des lettres simples comme i, j, k sont acceptables pour des compteurs de boucle (que nous verrons au Chapitre 11), et x, y, z conviennent pour des coordonnées. Sinon, utilisez des noms descriptifs.

5. Ne pas utiliser de noms qui masquent les fonctions intégrées : même si Python l’autorise, évitez d’utiliser des noms comme list, str, int, print, etc., car ce sont des noms de fonctions intégrées.

Voyons un exemple pratique qui illustre de bonnes pratiques de nommage :

# good_naming.py
# Constants at the top
SALES_TAX_RATE = 0.08
DISCOUNT_THRESHOLD = 100
 
# Descriptive variable names
item_price = 75.00
quantity = 3
subtotal = item_price * quantity
 
# Clear boolean variable
qualifies_for_discount = subtotal >= DISCOUNT_THRESHOLD
 
if qualifies_for_discount:
    discount = subtotal * 0.10
    subtotal = subtotal - discount
    print("Discount applied: $", discount)
 
tax = subtotal * SALES_TAX_RATE
total = subtotal + tax
 
print("Subtotal: $", subtotal)
print("Tax: $", tax)
print("Total: $", total)
# Output:
# Subtotal: $ 202.5
# Tax: $ 16.2
# Total: $ 218.7

Remarquez comment les noms de variables rendent le code auto‑documenté. Même sans commentaires, vous pouvez comprendre ce que le programme calcule.

3.1.4) Utiliser des variables dans des expressions

Une fois que vous avez créé une variable, vous pouvez l’utiliser partout où vous utiliseriez la valeur qu’elle représente. Python remplacera automatiquement la variable par sa valeur actuelle lors de l’évaluation des expressions :

# using_variables.py
# Create some variables
hours_worked = 40
hourly_rate = 25.50
 
# Use variables in calculations
gross_pay = hours_worked * hourly_rate
print("Gross pay:", gross_pay)  # Output: Gross pay: 1020.0
 
# Use variables in other expressions
bonus = gross_pay * 0.10
total_pay = gross_pay + bonus
print("Total with bonus:", total_pay)  # Output: Total with bonus: 1122.0
 
# Use variables in strings (we'll learn more about this in Chapter 5)
message = "You worked " + str(hours_worked) + " hours"
print(message)  # Output: You worked 40 hours

Les variables peuvent aussi être utilisées avec les fonctions que vous avez vues au Chapitre 2 :

# variables_with_functions.py
name = input("What is your name? ")
age = input("What is your age? ")
 
greeting = "Hello, " + name + "!"
print(greeting)
 
age_next_year = int(age) + 1
print("Next year you will be", age_next_year, "years old.")
# If user enters "Alice" and "25":
# Output: Hello, Alice!
# Output: Next year you will be 26 years old.

Cet exemple illustre également un concept important : la fonction input() renvoie toujours du texte (une string), donc si vous voulez faire des opérations mathématiques dessus, vous devez d’abord la convertir en nombre. Nous explorerons ce processus de conversion en détail plus loin dans ce chapitre (Section 3.7).

3.2) Affectation et réaffectation de variables

3.2.1) Comprendre l’affectation

Lorsque vous affectez une valeur à une variable, Python crée une connexion entre le nom de la variable et la valeur en mémoire. Il est important de comprendre que la variable ne « contient » pas la valeur au sens physique : c’est un nom qui fait référence ou pointe vers une valeur stockée ailleurs en mémoire.

Vous pouvez imaginer cela comme un post‑it avec un nom écrit dessus, collé sur une boîte contenant la valeur réelle. La variable (le post‑it) n’est pas la valeur elle‑même : elle pointe simplement vers l’endroit où la valeur est stockée. Lorsque vous réaffectez la variable, vous déplacez le post‑it pour le coller sur une autre boîte, sans modifier le contenu de la boîte d’origine.

Cette distinction devient importante lorsque nous parlons de réaffectation. Voyons ce qui se passe lorsque vous affectez et réaffectez des variables :

# assignment_basics.py
x = 10
print(x)  # Output: 10
 
# Reassign x to a new value
x = 20
print(x)  # Output: 20
 
# The old value (10) is gone; x now refers to 20

Voici ce qui s’est passé étape par étape :

1. x = 10 : Python crée la valeur entière 10 en mémoire et fait en sorte que le nom x y fasse référence
2. print(x) : Python cherche à quoi x fait référence (10) et l’affiche
3. x = 20 : Python crée la valeur entière 20 en mémoire et fait désormais pointer x vers cette nouvelle valeur
4. print(x) : Python cherche à quoi x fait référence (désormais 20) et l’affiche

La valeur d’origine 10 existe encore temporairement en mémoire, mais comme plus aucune variable n’y fait référence, le système de gestion automatique de la mémoire de Python (appelé garbage collection) la supprimera éventuellement.

3.2.2) Réaffectation et mise à jour des variables

L’un des schémas les plus courants en programmation consiste à mettre à jour une variable en fonction de sa valeur actuelle. Par exemple, vous pouvez vouloir incrémenter un compteur, ajouter à un total cumulatif ou modifier une valeur à partir d’un calcul :

# updating_variables.py
score = 0
print("Initial score:", score)  # Output: Initial score: 0
 
# Add 10 points
score = score + 10
print("After first update:", score)  # Output: After first update: 10
 
# Add 5 more points
score = score + 5
print("After second update:", score)  # Output: After second update: 15
 
# Double the score
score = score * 2
print("After doubling:", score)  # Output: After doubling: 30

Décomposons ce qui se passe dans score = score + 10 :

1. Python évalue le côté droit : score + 10
2. Il récupère la valeur actuelle de score (0)
3. Il calcule 0 + 10, ce qui donne 10
4. Il affecte cette nouvelle valeur (10) à score
5. score fait maintenant référence à 10 au lieu de 0

Ce schéma est si courant que Python fournit des opérateurs raccourcis pour cela, que nous verrons au Chapitre 4 (Section 4.3). Pour l’instant, il est important de comprendre la forme complète, car elle montre clairement l’ordre des opérations : évaluer complètement le côté droit, puis affecter au côté gauche.

3.2.3) Les variables sont indépendantes

Quand vous affectez une variable à une autre, Python copie la référence, pas la valeur elle‑même (pour les types simples comme les nombres et les strings). Toutefois, pour les types de base que nous voyons dans ce chapitre, les variables se comportent de manière indépendante après l’affectation :

# independent_variables.py
a = 10
b = a  # b now refers to the same value as a (10)
print("a:", a)  # Output: a: 10
print("b:", b)  # Output: b: 10
 
# Change a
a = 20
print("After changing a:")
print("a:", a)  # Output: a: 20
print("b:", b)  # Output: b: 10 (unchanged!)

Lorsque nous avons affecté b = a, nous avons fait en sorte que b fasse référence à la même valeur que a à ce moment‑là (10). Quand nous avons ensuite changé a pour référencer 20, b est resté inchangé : il fait toujours référence à 10.

Ce comportement est simple pour les nombres et les strings, mais devient plus complexe avec les collections comme les listes (list) et les dictionnaires. Nous explorerons cela en détail au Chapitre 17 lorsque nous parlerons du modèle objet de Python et de la sémantique de référence.

3.2.4) Utiliser des variables avant affectation

Une erreur courante des débutants est d’essayer d’utiliser une variable avant qu’une valeur ne lui soit affectée. Python lève une NameError si vous tentez de faire cela :

# undefined_variable.py
print(total)  # Error: NameError: name 'total' is not defined

Cette erreur survient parce que Python ne sait pas à quoi total fait référence : vous ne l’avez pas encore créée. La correction est simple : affecter une valeur à la variable avant de l’utiliser :

# defined_variable.py
total = 0  # Initialize the variable first
print(total)  # Output: 0
 
# Now we can update it
total = total + 10
print(total)  # Output: 10

Ce schéma qui consiste à initialiser une variable (lui donner une valeur initiale) avant de l’utiliser est fondamental en programmation. Nous verrons de nombreux exemples de ce schéma tout au long du livre, en particulier pour les compteurs et les accumulateurs dans les boucles au Chapitre 10.

3.2.5) Échanger les valeurs de variables

Une opération courante consiste à échanger les valeurs de deux variables. Dans beaucoup de langages, cela nécessite une variable temporaire :

# swap_with_temp.py
x = 10
y = 20
print("Before swap: x =", x, ", y =", y)  # Output: Before swap: x = 10 , y = 20
 
# Swap using a temporary variable
temp = x    # Save x's value
x = y       # Put y's value in x
y = temp    # Put saved value in y
 
print("After swap: x =", x, ", y =", y)  # Output: After swap: x = 20 , y = 10

Cependant, Python fournit une manière plus élégante en utilisant l’affectation simultanée :

# swap_pythonic.py
x = 10
y = 20
print("Before swap: x =", x, ", y =", y)  # Output: Before swap: x = 10 , y = 20
 
# Swap in one line
x, y = y, x
 
print("After swap: x =", x, ", y =", y)  # Output: After swap: x = 20 , y = 10

Cela fonctionne parce que Python évalue entièrement le côté droit (y, x) avant de réaliser les affectations. Il crée donc une structure temporaire contenant les valeurs de y et x, puis dépile ces valeurs dans x et y respectivement. C’est un bon exemple de la philosophie de Python : rendre simples et lisibles les opérations courantes.

3.3) Le concept de types de données et la fonction type()

3.3.1) Que sont les types de données ?

Un type de données (ou simplement type) définit le genre de données qu’une valeur représente et quelles opérations peuvent être effectuées dessus. Vous pouvez considérer les types de données comme des catégories qui indiquent à Python comment interpréter et manipuler différents types d’informations.

Par exemple :

• Le nombre 42 est un entier (nombre entier)
• Le nombre 3.14 est un nombre à virgule flottante (nombre avec un point décimal)
• Le texte "Hello" est une string (séquence de caractères)
• La valeur True est un booléen (valeur logique vrai/faux)

Pourquoi les types de données sont‑ils importants ? Parce que différents types prennent en charge des opérations différentes :

# type_operations.py
# You can add numbers
result1 = 10 + 5
print(result1)  # Output: 15
 
# You can also "add" strings (concatenation)
result2 = "Hello" + " " + "World"
print(result2)  # Output: Hello World
 
# But you can't add a number and a string directly
# result3 = 10 + "5"  # Error: TypeError: unsupported operand type(s)

L’erreur dans le dernier exemple se produit parce que Python ne sait pas comment additionner un nombre et une string : ce sont des types de données fondamentalement différents. Doit‑il convertir le nombre en texte et concaténer ? Doit‑il convertir le texte en nombre et faire une addition mathématique ? Python exige que vous soyez explicite sur ce que vous voulez en convertissant l’une des valeurs pour qu’elle corresponde au type de l’autre (nous verrons comment faire en Section 3.7).

3.3.2) Utiliser type() pour vérifier les types de données

Python fournit une fonction intégrée appelée type() qui indique de quel type est une valeur ou une variable. C’est extrêmement utile pour comprendre vos données et pour le débogage :

# checking_types.py
# Check types of literal values
print(type(42))        # Output: <class 'int'>
print(type(3.14))      # Output: <class 'float'>
print(type("Hello"))   # Output: <class 'str'>
print(type(True))      # Output: <class 'bool'>
 
# Check types of variables
age = 25
name = "Alice"
temperature = 98.6
is_valid = False
 
print(type(age))         # Output: <class 'int'>
print(type(name))        # Output: <class 'str'>
print(type(temperature)) # Output: <class 'float'>
print(type(is_valid))    # Output: <class 'bool'>

La sortie <class 'int'> signifie « cette valeur appartient à la classe (type) appelée int ». En Python, les types sont en réalité des classes (nous verrons les classes en détail dans la Partie VIII), mais pour l’instant, vous pouvez considérer ces termes comme interchangeables.

3.3.3) Typage dynamique en Python

Python est un langage à typage dynamique, ce qui signifie que :

1. Les variables n’ont pas de type fixe : une variable peut faire référence à des valeurs de types différents à différents moments
2. Les types sont déterminés à l’exécution : Python détermine les types lorsque le programme s’exécute, et non lorsque vous écrivez le code
3. Vous ne déclarez pas les types explicitement : contrairement à d’autres langages, vous n’avez pas besoin de dire « cette variable contiendra un entier »

Voici un exemple de typage dynamique en action :

# dynamic_typing.py
x = 42
print(x, "is of type", type(x))  # Output: 42 is of type <class 'int'>
 
x = "Hello"
print(x, "is of type", type(x))  # Output: Hello is of type <class 'str'>
 
x = 3.14
print(x, "is of type", type(x))  # Output: 3.14 is of type <class 'float'>

Remarquez que x peut faire référence à des valeurs de types différents à différents moments du programme. Python ne se plaint pas : il met simplement à jour le type auquel x fait référence.

Bien que cette flexibilité soit pratique, elle impose aussi d’être vigilant. Si vous vous attendez à ce qu’une variable contienne un nombre mais qu’elle contient en réalité une string, vous risquez d’obtenir des erreurs inattendues :

# type_confusion.py
value = "100"  # This is a string, not a number!
 
# Trying to do math with it will fail
# result = value + 50  # Error: TypeError: can only concatenate str to str
 
# You need to convert it first
result = int(value) + 50
print(result)  # Output: 150

C’est pour cela que comprendre les types de données est crucial : cela vous aide à prévoir quelles opérations vont fonctionner et à repérer les erreurs avant qu’elles ne provoquent des plantages.

3.3.4) Vue d’ensemble des types intégrés de Python

Python possède plusieurs types de données intégrés. Dans ce chapitre, nous nous concentrerons sur les plus fondamentaux :

Dans ce chapitre, nous verrons :

• int : nombres entiers
• float : nombres à virgule flottante
• str : strings (texte)
• bool : valeurs booléennes (True et False)
• NoneType : la valeur spéciale None

Nous mentionnerons brièvement les nombres complexes (nombres avec partie imaginaire), mais ils sont rarement nécessaires pour la programmation courante. Les types de collection (comme les listes, tuples, dictionnaires et ensembles) sont si importants que nous leur consacrons des chapitres entiers dans la Partie IV.

3.3.5) Vérification des types en pratique

Comprendre les types devient particulièrement important lorsqu’on travaille avec des entrées utilisateur ou des données provenant de sources externes. Rappelez‑vous que input() renvoie toujours une string, même si l’utilisateur saisit un nombre :

# input_types.py
user_input = input("Enter a number: ")
print("You entered:", user_input)
print("Type:", type(user_input))  # Output: Type: <class 'str'>
 
# Even if user types "42", it's still a string!
# To use it as a number, convert it:
number = int(user_input)
print("As a number:", number)
print("Type:", type(number))  # Output: Type: <class 'int'>
 
# Now we can do math with it
doubled = number * 2
print("Doubled:", doubled)

Quand vous exécutez ce programme et tapez 42, vous verrez :

Enter a number: 42
You entered: 42
Type: <class 'str'>
As a number: 42
Type: <class 'int'>
Doubled: 84

Cela illustre un point crucial : la string "42" et l’entier 42 sont des choses différentes en Python, même s’ils se ressemblent lorsqu’on les affiche. La string est une séquence de deux caractères ('4' et '2'), tandis que l’entier est une valeur numérique qui peut être utilisée dans des opérations mathématiques.

3.4) Nombres entiers et nombres à virgule flottante

3.4.1) Les entiers (int)

Un entier (type int) est un nombre entier sans point décimal. Les entiers peuvent être positifs, négatifs ou nuls, et en Python 3 ils peuvent être arbitrairement grands — limités uniquement par la mémoire disponible de votre ordinateur.

# integers.py
# Positive integers
age = 25
year = 2024
population = 8000000000
 
# Negative integers
temperature = -15
debt = -5000
 
# Zero
balance = 0
 
# Very large integers (Python handles these easily)
huge_number = 123456789012345678901234567890
print(huge_number)  # Output: 123456789012345678901234567890
print(type(huge_number))  # Output: <class 'int'>

Python vous permet d’écrire de grands nombres avec des underscores pour améliorer la lisibilité. Les underscores sont ignorés par Python, mais rendent les nombres plus faciles à lire pour les humains :

# readable_numbers.py
# These are all the same number
million = 1000000
million = 1_000_000  # Much easier to read!
 
# Works with any size
population = 8_000_000_000
national_debt = 31_000_000_000_000
 
print(million)      # Output: 1000000 (underscores not shown in output)
print(population)   # Output: 8000000000

Vous pouvez aussi écrire des entiers dans différentes bases numériques en utilisant des préfixes spéciaux :

# number_bases.py
# Binary (base 2) - prefix 0b
binary = 0b1010  # This is 10 in decimal
print(binary)  # Output: 10
 
# Octal (base 8) - prefix 0o
octal = 0o12  # This is 10 in decimal
print(octal)  # Output: 10
 
# Hexadecimal (base 16) - prefix 0x
hexadecimal = 0xFF  # This is 255 in decimal
print(hexadecimal)  # Output: 255

Ces bases alternatives sont utiles dans certains contextes (comme la gestion des couleurs en développement web ou la programmation bas niveau), mais pour la plupart des usages quotidiens vous utiliserez des entiers décimaux classiques.

3.4.2) Les nombres à virgule flottante (float)

Un nombre à virgule flottante (type float) est un nombre avec un point décimal. Les floats sont utilisés pour représenter des nombres réels — des valeurs qui ne sont pas forcément entières :

# floats.py
# Numbers with decimal points
price = 19.99
temperature = 98.6
pi = 3.14159
 
# Very small numbers
electron_mass = 0.00000000000000000000000000000091093837
 
# Very large numbers
speed_of_light = 299792458.0
 
print(price)           # Output: 19.99
print(temperature)     # Output: 98.6
print(electron_mass)   # Output: 9.1093837e-31 (scientific notation)
print(speed_of_light)  # Output: 299792458.0

Remarquez que les floats très petits ou très grands sont affichés en notation scientifique (aussi appelée notation exponentielle). L’écriture 9.1093837e-31 signifie « 9,1093837 × 10⁻³¹ », c’est‑à‑dire « 9,1093837 divisé par 10 à la puissance 31 ».

Vous pouvez aussi écrire des floats directement en notation scientifique :

# scientific_notation.py
# These are equivalent
avogadro = 602214076000000000000000.0
avogadro = 6.02214076e23  # Much more readable!
 
# Small numbers
planck = 0.000000000000000000000000000000000662607015
planck = 6.62607015e-34  # Much more readable!
 
print(avogadro)  # Output: 6.02214076e+23
print(planck)    # Output: 6.62607015e-34

La lettre e (ou E) signifie « exposant ». Le nombre après e indique de combien de positions déplacer le point décimal (positif vers la droite, négatif vers la gauche).

3.4.3) Entier vs float : différences importantes

Même si les entiers et les floats représentent tous deux des nombres, ils ont des différences importantes :

1. Précision et représentation :

Les entiers sont exacts — la valeur 42 est exactement 42, sans approximation. Les floats, en revanche, sont des approximations en raison de la manière dont les ordinateurs stockent les nombres décimaux en binaire :

# float_precision.py
# This might surprise you!
result = 0.1 + 0.2
print(result)  # Output: 0.30000000000000004
 
# The result isn't exactly 0.3 due to floating-point representation
print(result == 0.3)  # Output: False

Ce n’est pas un bug : c’est une limite fondamentale de la représentation des nombres décimaux sur ordinateur. Nous en parlerons plus en détail au Chapitre 4 (Section 4.10), mais pour l’instant, gardez à l’esprit que les calculs sur les floats peuvent ne pas être parfaitement précis.

2. Opérations et résultats :

Lorsque vous effectuez des opérations avec des entiers et des floats, Python suit des règles spécifiques :

# int_float_operations.py
# Integer operations
int_result = 10 + 5
print(int_result, type(int_result))  # Output: 15 <class 'int'>
 
# Float operations
float_result = 10.0 + 5.0
print(float_result, type(float_result))  # Output: 15.0 <class 'float'>
 
# Mixed operations: result is always float
mixed_result = 10 + 5.0
print(mixed_result, type(mixed_result))  # Output: 15.0 <class 'float'>
 
# Division always returns float, even with integers
division_result = 10 / 5
print(division_result, type(division_result))  # Output: 2.0 <class 'float'>

La règle clé : toute opération impliquant au moins un float produit un résultat de type float. Cela a du sens car les floats peuvent représenter une gamme plus large de valeurs (y compris des nombres non entiers), donc Python « promeut » le résultat vers le type le plus général.

3. Mémoire et performance :

Les entiers utilisent moins de mémoire et sont plus rapides à manipuler que les floats. Pour la plupart des programmes, cette différence est négligeable, mais elle peut compter dans des applications sensibles aux performances ou lorsqu’on travaille avec des ensembles de données très volumineux.

3.4.4) Quand utiliser int et quand utiliser float

Voici quelques lignes directrices pratiques pour choisir entre entiers et floats :

Utilisez des entiers lorsque :

• Vous comptez des éléments discrets (personnes, objets, itérations)
• Vous représentez des quantités exactes qui ne peuvent pas être fractionnaires (nombre d’étudiants, nombre de clics)
• Vous travaillez avec des indices ou des positions dans des séquences
• Vous avez besoin d’une arithmétique exacte

# use_integers.py
student_count = 30  # Can't have 30.5 students
page_number = 42    # Can't be on page 42.7
loop_counter = 0    # Counting iterations

Utilisez des floats lorsque :

• Vous représentez des mesures (température, distance, poids)
• Vous travaillez avec de l’argent (mais attention à la précision — nous en parlerons au Chapitre 4)
• Vous calculez des ratios, pourcentages ou moyennes
• Des valeurs approximatives sont acceptables

# use_floats.py
temperature = 72.5     # Temperature can be fractional
price = 19.99          # Money amounts have cents
average_score = 87.3   # Averages are often fractional
percentage = 0.15      # 15% as a decimal

3.5) Littéraux string et booléens (aperçu rapide)

Dans cette section, nous allons présenter brièvement deux autres types de données fondamentaux : les strings et les booléens. Nous verrons les strings en détail aux Chapitres 5 et 6, et les booléens en détail au Chapitre 7, mais vous avez besoin d’une compréhension de base dès maintenant pour écrire ne serait‑ce que de petits programmes.

3.5.1) Bases des strings

Une string (type str) est une séquence de caractères — essentiellement, du texte. Vous créez des strings en entourant du texte de guillemets. Python accepte les guillemets simples (') ou doubles (") :

# string_basics.py
# Single quotes
name = 'Alice'
message = 'Hello, World!'
 
# Double quotes (exactly equivalent)
name = "Alice"
message = "Hello, World!"
 
# Print them
print(name)     # Output: Alice
print(message)  # Output: Hello, World!
print(type(name))  # Output: <class 'str'>

Les guillemets simples et doubles fonctionnent de manière identique : choisissez ceux que vous préférez, mais soyez cohérent dans votre code. Beaucoup de programmeurs Python préfèrent les guillemets doubles car ils sont plus courants dans d’autres langages de programmation, mais les guillemets simples sont tout aussi valides.

Pourquoi avoir les deux ? La principale raison est la commodité quand votre string contient des guillemets :

# quotes_in_strings.py
# Use double quotes when string contains single quotes
sentence = "It's a beautiful day!"
print(sentence)  # Output: It's a beautiful day!
 
# Use single quotes when string contains double quotes
speech = 'She said, "Hello!"'
print(speech)  # Output: She said, "Hello!"
 
# Or use escape sequences (we'll learn more in Chapter 5)
sentence = 'It\'s a beautiful day!'  # \' means a literal single quote
speech = "She said, \"Hello!\""     # \" means a literal double quote

Les strings peuvent être vides (ne contenir aucun caractère) :

# empty_string.py
empty = ""
also_empty = ''
 
print(empty)            # Output: (nothing—it's empty!)
print(len(empty))       # Output: 0 (we'll learn about len() later)
print(type(empty))      # Output: <class 'str'>

Vous pouvez combiner des strings en utilisant l’opérateur + (on parle de concaténation) :

# string_concatenation.py
first_name = "John"
last_name = "Doe"
full_name = first_name + " " + last_name
print(full_name)  # Output: John Doe
 
# Be careful: you can't concatenate strings and numbers directly
age = 25
# message = "I am " + age + " years old"  # Error: TypeError
 
# Convert the number to a string first
message = "I am " + str(age) + " years old"
print(message)  # Output: I am 25 years old

Nous explorerons les strings beaucoup plus en profondeur aux Chapitres 5 et 6, y compris les séquences d’échappement, les méthodes de string, le formatage et le traitement de texte. Pour l’instant, retenez simplement que les strings représentent du texte et se créent avec des guillemets.

3.5.2) Bases des booléens

Un booléen (type bool) est une valeur logique qui peut être soit True, soit False. Ce sont les deux seules valeurs booléennes en Python, et elles servent à représenter le vrai et le faux dans les opérations logiques :

# boolean_basics.py
# Boolean literals
is_sunny = True
is_raining = False
 
print(is_sunny)         # Output: True
print(is_raining)       # Output: False
print(type(is_sunny))   # Output: <class 'bool'>

Important : les valeurs booléennes True et False doivent être écrites exactement avec cette casse. Python est sensible à la casse, donc true, TRUE, false et FALSE ne fonctionneront pas :

# boolean_case.py
correct = True    # Correct
# wrong = true    # Error: NameError: name 'true' is not defined
# wrong = TRUE    # Error: NameError: name 'TRUE' is not defined

Les booléens proviennent généralement de comparaisons ou d’opérations logiques :

# boolean_from_comparisons.py
age = 25
 
# Comparison operators produce boolean results
is_adult = age >= 18
print(is_adult)  # Output: True
 
is_senior = age >= 65
print(is_senior)  # Output: False
 
# You can use booleans in conditions (we'll learn more in Chapter 8)
if is_adult:
    print("You can vote!")  # Output: You can vote!
 
if is_senior:
    print("You get a senior discount!")  # (no output—condition is False)

Opérateurs de comparaison courants produisant des booléens :

• == : égal à
• != : différent de
• < : inférieur à
• > : supérieur à
• <= : inférieur ou égal à
• >= : supérieur ou égal à

# comparison_operators.py
x = 10
y = 20
 
print(x == y)   # Output: False (10 is not equal to 20)
print(x != y)   # Output: True (10 is not equal to 20)
print(x < y)    # Output: True (10 is less than 20)
print(x > y)    # Output: False (10 is not greater than 20)
print(x <= 10)  # Output: True (10 is less than or equal to 10)
print(y >= 20)  # Output: True (20 is greater than or equal to 20)

Point important : ne confondez pas = (affectation) et == (comparaison) :

• x = 10 signifie « affecter la valeur 10 à x »
• x == 10 signifie « vérifier si x est égal à 10 » (renvoie True ou False)

# assignment_vs_comparison.py
x = 10        # Assignment: x now refers to 10
result = (x == 10)  # Comparison: is x equal to 10?
print(result)  # Output: True
 
# This is a common mistake for beginners:
# if x = 10:  # Error: SyntaxError (can't use assignment in if condition)
if x == 10:   # Correct: comparison
    print("x is 10")  # Output: x is 10

Nous verrons les booléens beaucoup plus en détail au Chapitre 7, y compris les opérateurs logiques (and, or, not), la notion de vérité/falsité (truthiness/falsiness), et la façon dont Python utilise les booléens dans les conditions. Pour l’instant, retenez simplement que les booléens représentent des valeurs True/False et proviennent généralement de comparaisons.

3.5.3) Strings et booléens en contexte

Voyons comment les strings et les booléens fonctionnent ensemble dans un petit exemple pratique :

# strings_booleans_example.py
# Get user input
name = input("What is your name? ")
age_input = input("What is your age? ")
 
# Convert age to integer
age = int(age_input)
 
# Create boolean conditions
is_adult = age >= 18
is_child = age < 13
 
# Build messages using strings
if is_adult:
    status = "adult"
else:
    status = "minor"
 
# Combine everything in output
print("Hello, " + name + "!")
print("You are an " + status + ".")
 
if is_child:
    print("You are a child.")
 
# When user enters "Alice" and "16":
# Output: Hello, Alice!
# Output: You are a minor.

Cet exemple montre comment différents types de données fonctionnent ensemble : des strings pour le texte, des entiers pour les nombres, et des booléens pour les décisions logiques. Cette interaction entre types est fondamentale en programmation.

3.6) La valeur None et ses usages

3.6.1) Qu’est‑ce que None ?

Python possède une valeur spéciale appelée None (type NoneType) qui représente l’absence de valeur. C’est la façon pour Python de dire « il n’y a rien ici » ou « ceci n’a pas encore de valeur ».

# none_basics.py
result = None
print(result)        # Output: None
print(type(result))  # Output: <class 'NoneType'>

None n’est pas la même chose que zéro, une string vide ou False : c’est une valeur distincte qui signifie spécifiquement « aucune valeur » :

# none_vs_others.py
x = None
y = 0
z = ""
w = False
 
print(x)  # Output: None
print(y)  # Output: 0
print(z)  # Output: (empty—nothing prints)
print(w)  # Output: False
 
# They're all different types
print(type(x))  # Output: <class 'NoneType'>
print(type(y))  # Output: <class 'int'>
print(type(z))  # Output: <class 'str'>
print(type(w))  # Output: <class 'bool'>

3.6.2) Quand None est utilisé

None apparaît dans plusieurs situations courantes :

1. Comme valeur temporaire pour des variables qui seront affectées plus tard :

# none_placeholder.py
# Initialize variables that will be assigned later
user_name = None
user_age = None
 
# Later in the program, after getting user input:
user_name = input("Enter your name: ")
user_age = int(input("Enter your age: "))
 
print("Name:", user_name)
print("Age:", user_age)

2. Comme valeur de retour par défaut des fonctions qui ne renvoient rien explicitement :

Les fonctions que nous verrons au Chapitre 19 peuvent renvoyer des valeurs. Si une fonction ne renvoie rien explicitement, Python renvoie automatiquement None :

# none_from_function.py
# The print() function returns None
result = print("Hello!")  # Output: Hello!
print(result)             # Output: None
print(type(result))       # Output: <class 'NoneType'>

Cela peut sembler étrange, mais c’est utile. Cela signifie que chaque fonction renvoie quelque chose, même si ce quelque chose est « aucune valeur significative ».

3. Pour représenter des données optionnelles ou manquantes :

# none_optional.py
# Representing optional middle name
first_name = "John"
middle_name = None  # No middle name
last_name = "Doe"
 
if middle_name is None:
    full_name = first_name + " " + last_name
else:
    full_name = first_name + " " + middle_name + " " + last_name
 
print(full_name)  # Output: John Doe

3.6.3) Tester si une valeur est None

Pour vérifier si une valeur est None, utilisez l’opérateur is (et non ==) :

# checking_none.py
value = None
 
# Correct way: use 'is'
if value is None:
    print("Value is None")  # Output: Value is None
 
# Also correct: use 'is not'
if value is not None:
    print("Value has a value")
else:
    print("Value is None")  # Output: Value is None
 
# While == works, 'is' is preferred for None
if value == None:  # This works but is not idiomatic Python
    print("Value is None")  # Output: Value is None

Pourquoi utiliser is plutôt que == ? L’opérateur is vérifie si deux noms font référence au même objet exact en mémoire (nous verrons cela au Chapitre 17). Comme il n’existe qu’un seul objet None en Python, is est à la fois plus efficace et plus précis pour ce test. Utiliser is None est l’idiome standard en Python.

3.6.4) None en pratique

Voici un exemple pratique montrant comment None est utile dans de vrais programmes :

# none_practical.py
# Simulate looking up a user's age
# (In real programs, we'd use functions and dictionaries from later chapters)
 
user_name = input("Enter a name (Alice, Bob, or Charlie): ")
 
# Check each name and assign age or None
if user_name == "Alice":
    user_age = 25
elif user_name == "Bob":
    user_age = 30
elif user_name == "Charlie":
    user_age = 35
else:
    user_age = None  # User not found
 
# Check if we found the user
if user_age is not None:
    print(user_name, "is", user_age, "years old")
else:
    print(user_name, "not found")
 
# When user enters "Alice":
# Output: Alice is 25 years old
# When user enters "David":
# Output: David not found

Dans cet exemple, None indique clairement « utilisateur non trouvé », ce qui est différent de trouver un utilisateur d’âge 0 (qui serait un âge valide pour un nouveau‑né).

3.6.5) None vs valeurs vides

Il est important de distinguer None des valeurs vides :

# none_vs_empty.py
# These are all different
nothing = None
zero = 0
empty_string = ""
# Note: We'll learn about lists in Chapter 13
# empty_list = []
 
print(nothing is None)       # Output: True
print(zero is None)          # Output: False
print(empty_string is None)  # Output: False
 
# None means "no value"
# 0 means "the number zero"
# "" means "text with no characters"

Chacune de ces valeurs représente un concept différent :

• None : absence de valeur
• 0 : une valeur numérique précise (zéro)
• "" : une string qui existe mais ne contient aucun caractère

Comprendre cette distinction vous aidera à écrire des programmes plus clairs et plus corrects.

3.7) Conversion de type de base avec int(), float() et str()

3.7.1) Pourquoi la conversion de type est nécessaire

Comme nous l’avons vu, Python a des règles strictes sur les opérations possibles entre les types. Vous ne pouvez pas additionner un nombre et une string, multiplier une string par un float, ni effectuer d’opérations mathématiques sur du texte. Quand vous devez utiliser une valeur comme un autre type, vous devez la convertir explicitement.

La conversion de type (aussi appelée cast de type) est le processus qui consiste à transformer une valeur d’un type à un autre. Python fournit des fonctions intégrées pour les conversions les plus courantes :

• int() : convertir en entier
• float() : convertir en nombre à virgule flottante
• str() : convertir en string

Explorons chacune d’elles en détail.

3.7.2) Conversion en entier avec int()

La fonction int() convertit une valeur en entier. Voici les principaux cas d’usage :

Convertir des floats en entiers :

# float_to_int.py
# int() truncates (cuts off) the decimal part
x = int(3.14)
y = int(3.99)
z = int(-2.7)
 
print(x)  # Output: 3 (not 4—it doesn't round!)
print(y)  # Output: 3 (not 4—it truncates!)
print(z)  # Output: -2 (truncates toward zero)

Important : int() n’arrondit pas — il supprime simplement la partie décimale (tronque vers zéro). C’est une source fréquente de confusion pour les débutants qui s’attendent à ce que int(3.9) renvoie 4.

Convertir des strings en entiers :

C’est extrêmement courant lorsqu’on travaille avec des entrées utilisateur :

# string_to_int.py
# Convert string containing a number
age_str = "25"
age_int = int(age_str)
 
print(age_str, type(age_str))  # Output: 25 <class 'str'>
print(age_int, type(age_int))  # Output: 25 <class 'int'>
 
# Now we can do math with it
next_year = age_int + 1
print("Next year:", next_year)  # Output: Next year: 26
 
# Practical example with input()
user_age = int(input("Enter your age: "))
print("In 10 years, you'll be", user_age + 10)

Que se passe‑t‑il lors de conversions invalides ?

Si vous essayez de convertir une string qui ne représente pas un entier valide, Python lève une ValueError :

# invalid_int_conversion.py
# These work
print(int("123"))    # Output: 123
print(int("-456"))   # Output: -456
print(int("  789 ")) # Output: 789 (whitespace is ignored)
 
# These don't work
# print(int("12.5"))   # Error: ValueError: invalid literal for int()
# print(int("hello"))  # Error: ValueError: invalid literal for int()
# print(int("12 34"))  # Error: ValueError: invalid literal for int()

Nous verrons comment gérer ces erreurs proprement au Chapitre 27 lorsque nous traiterons la gestion d’exceptions. Pour l’instant, sachez simplement que vos strings doivent contenir des entiers valides avant conversion.

Convertir des booléens en entiers :

Les booléens peuvent être convertis en entiers, où True devient 1 et False devient 0 :

# bool_to_int.py
print(int(True))   # Output: 1
print(int(False))  # Output: 0
 
# This is sometimes useful in calculations
is_premium = True
is_student = False
 
# Calculate discount (10% for premium, 5% for students)
discount = int(is_premium) * 0.10 + int(is_student) * 0.05
print("Discount:", discount)  # Output: Discount: 0.1

Cependant, utiliser des booléens directement dans des calculs est généralement déconseillé car cela rend le code moins lisible. Nous en reparlerons au Chapitre 7.

3.7.3) Conversion en float avec float()

La fonction float() convertit une valeur en nombre à virgule flottante :

Convertir des entiers en floats :

# int_to_float.py
x = float(42)
y = float(-17)
z = float(0)
 
print(x, type(x))  # Output: 42.0 <class 'float'>
print(y, type(y))  # Output: -17.0 <class 'float'>
print(z, type(z))  # Output: 0.0 <class 'float'>

Convertir des strings en floats :

# string_to_float.py
# Convert string containing decimal number
price_str = "19.99"
price_float = float(price_str)
 
print(price_str, type(price_str))    # Output: 19.99 <class 'str'>
print(price_float, type(price_float))  # Output: 19.99 <class 'float'>
 
# Strings without decimal points work too
x = float("42")
print(x, type(x))  # Output: 42.0 <class 'float'>
 
# Scientific notation strings work
big = float("1.5e10")
print(big)  # Output: 15000000000.0

Conversions invalides :

Comme int(), float() lève une ValueError pour des strings invalides :

# invalid_float_conversion.py
# These work
print(float("3.14"))      # Output: 3.14
print(float("  2.5  "))   # Output: 2.5 (whitespace ignored)
print(float("-0.5"))      # Output: -0.5
print(float("inf"))       # Output: inf (infinity)
 
# These don't work
# print(float("hello"))   # Error: ValueError
# print(float("1.2.3"))   # Error: ValueError

Convertir des booléens en floats :

# bool_to_float.py
print(float(True))   # Output: 1.0
print(float(False))  # Output: 0.0

3.7.4) Conversion en string avec str()

La fonction str() convertit n’importe quelle valeur en sa représentation sous forme de string :

Convertir des nombres en strings :

# number_to_string.py
# Convert integer
age = 25
age_str = str(age)
print(age_str, type(age_str))  # Output: 25 <class 'str'>
 
# Convert float
price = 19.99
price_str = str(price)
print(price_str, type(price_str))  # Output: 19.99 <class 'str'>
 
# Now we can concatenate with other strings
message = "The price is $" + price_str
print(message)  # Output: The price is $19.99

C’est particulièrement utile pour construire des messages :

# building_messages.py
name = "Alice"
age = 25
height = 5.6
 
# Without str(), this would cause an error
# message = "Name: " + name + ", Age: " + age  # Error!
 
# With str(), it works
message = "Name: " + name + ", Age: " + str(age) + ", Height: " + str(height)
print(message)  # Output: Name: Alice, Age: 25, Height: 5.6

Convertir des booléens en strings :

# bool_to_string.py
is_valid = True
is_error = False
 
print(str(is_valid))  # Output: True
print(str(is_error))  # Output: False
 
# Useful in messages
status = "Status: " + str(is_valid)
print(status)  # Output: Status: True

Convertir None en string :

# none_to_string.py
value = None
value_str = str(value)
print(value_str)        # Output: None
print(type(value_str))  # Output: <class 'str'>
 
# The string "None" is different from the value None
print(value is None)      # Output: True
print(value_str is None)  # Output: False
print(value_str == "None")  # Output: True

3.7.5) Schémas de conversion en pratique

Voici un exemple complet montrant des schémas de conversion courants :

# conversion_patterns.py
# Get user input (always strings)
name = input("Enter your name: ")
age_str = input("Enter your age: ")
height_str = input("Enter your height in feet: ")
 
# Convert to appropriate types
age = int(age_str)
height = float(height_str)
 
# Perform calculations
age_in_months = age * 12
height_in_inches = height * 12
 
# Convert back to strings for output
print("Hello, " + name + "!")
print("You are " + str(age_in_months) + " months old.")
print("Your height is " + str(height_in_inches) + " inches.")
 
# Alternative: use multiple arguments to print() (no conversion needed)
print("Hello,", name + "!")
print("You are", age_in_months, "months old.")
print("Your height is", height_in_inches, "inches.")
 
# When user enters "Alice", "25", and "5.5":
# Output: Hello, Alice!
# Output: You are 300 months old.
# Output: Your height is 66.0 inches.
# Output: Hello, Alice!
# Output: You are 300 months old.
# Output: Your height is 66.0 inches.

Remarquez que print() avec plusieurs arguments (séparés par des virgules) convertit automatiquement les valeurs en strings et ajoute des espaces entre elles. C’est souvent plus pratique que de convertir et concaténer manuellement les strings.

3.7.6) Diagramme de flux de conversion

Voici une représentation visuelle des conversions de type courantes :

Points clés sur les conversions :

• int → float : toujours sûr, ajoute .0
• float → int : tronque la partie décimale (n’arrondit pas)
• Any → str : toujours possible, convertit en représentation textuelle
• str → int/float : ne fonctionne que si la string représente un nombre valide
• bool → int/float : True devient 1/1.0, False devient 0/0.0

3.7.7) Erreurs courantes de conversion

Voici quelques erreurs fréquentes de débutants avec la conversion de type :

Erreur 1 : oublier de convertir une entrée utilisateur

# conversion_mistake1.py
# Wrong: trying to do math with string
age = input("Enter your age: ")
# next_year = age + 1  # Error: TypeError
 
# Right: convert first
age = int(input("Enter your age: "))
next_year = age + 1
print("Next year:", next_year)

Erreur 2 : convertir alors que ce n’est pas nécessaire

# conversion_mistake2.py
# Unnecessary: print() handles conversion automatically
age = 25
print("Age:", age)  # This works fine
 
# No need for:
print("Age:", str(age))  # Unnecessary str() conversion

Erreur 3 : essayer de convertir des strings invalides

# conversion_mistake3.py
# This will crash if user enters non-numeric input
# age = int(input("Enter your age: "))  # Crashes on "twenty"
 
# We'll learn to handle this safely in Chapter 27

Erreur 4 : s’attendre à ce que int() arrondisse

# conversion_mistake4.py
# Wrong expectation: int() truncates, doesn't round
x = int(3.7)
print(x)  # Output: 3 (not 4!)
 
# If you want rounding, use round()
x = round(3.7)
print(x)  # Output: 4

3.8) Obtenir des représentations textuelles avec str() et repr()

3.8.1) Différence entre str() et repr()

Python fournit deux moyens d’obtenir une représentation textuelle d’un objet : str() et repr(). Bien qu’elles puissent paraître similaires, elles ont des objectifs différents :

• str() : crée une représentation textuelle « agréable », lisible par un humain
• repr() : crée une représentation textuelle « officielle », non ambiguë, destinée aux développeurs

Pour les types simples comme les nombres, elles sont souvent identiques, mais pour d’autres types, elles peuvent différer fortement :

# str_vs_repr.py
# For numbers, they're usually the same
x = 42
print(str(x))   # Output: 42
print(repr(x))  # Output: 42
 
# For strings, they differ
text = "Hello"
print(str(text))   # Output: Hello
print(repr(text))  # Output: 'Hello' (includes quotes!)
 
# For strings with special characters, repr() shows escape sequences
message = "Hello\nWorld"
print(str(message))   # Output: Hello
                      #         World (newline is interpreted)
print(repr(message))  # Output: 'Hello\nWorld' (shows the \n literally)

3.8.2) Quand utiliser str()

Utilisez str() lorsque vous voulez une représentation lisible pour les utilisateurs finaux :

# using_str.py
price = 19.99
quantity = 3
 
# Create user-friendly messages
message = "Total: $" + str(price * quantity)
print(message)  # Output: Total: $59.97
 
# str() is what print() uses automatically
print("Total: $", price * quantity)  # Output: Total: $ 59.97

La fonction str() est conçue pour produire une sortie qui a du sens pour les humains, même si elle perd une partie de la précision technique. Lorsque vous appelez print(), Python appelle automatiquement str() sur les valeurs que vous lui passez.

3.8.3) Quand utiliser repr()

Utilisez repr() lorsque vous avez besoin d’une représentation non ambiguë, typiquement pour le débogage :

# using_repr.py
# Debugging: see exactly what's in a variable
text = "Hello\nWorld"
print("Debug info:", repr(text))  # Output: Debug info: 'Hello\nWorld'
 
# Compare two similar-looking strings
str1 = "42"
str2 = "42 "  # Has trailing space
 
print(str1)       # Output: 42
print(str2)       # Output: 42  (space not obvious)
print(repr(str1)) # Output: '42'
print(repr(str2)) # Output: '42 ' (space is visible!)

La fonction repr() est conçue pour vous montrer exactement ce que voit Python, y compris les détails qui peuvent ne pas être visibles dans une sortie normale. Cela la rend inestimable pour le débogage.

3.8.4) Objectif de repr() : des représentations recréables

Idéalement, repr() devrait produire une string qui, si vous la passiez à l’interpréteur Python, recréerait l’objet d’origine. Pour les types de base, cela fonctionne :

# repr_recreate.py
# For numbers
x = 42
x_repr = repr(x)
print(x_repr)  # Output: 42
 
# You could use this to recreate x
x_recreated = eval(x_repr)  # eval() evaluates a string as Python code
print(x_recreated)  # Output: 42
 
# For strings
text = "Hello"
text_repr = repr(text)
print(text_repr)  # Output: 'Hello'
 
# This could recreate the string
text_recreated = eval(text_repr)
print(text_recreated)  # Output: Hello

Remarque importante : la fonction eval() évalue une string comme du code Python. Nous la mentionnons ici pour expliquer l’objectif de repr(), mais n’utilisez jamais eval() sur une entrée non fiable : c’est un risque de sécurité. Nous discuterons d’alternatives plus sûres dans des chapitres ultérieurs.

3.8.5) Exemples pratiques de str() et repr()

Exemple 1 : déboguer des problèmes de string

# debugging_strings.py
# User input might have unexpected whitespace
user_input = "  Alice  "
 
print("User entered:", user_input)         # Output: User entered:   Alice  
print("Debug view:", repr(user_input))     # Output: Debug view: '  Alice  '
 
# Now the extra spaces are obvious!
cleaned = user_input.strip()  # Remove leading/trailing whitespace
print("Cleaned:", repr(cleaned))  # Output: Cleaned: 'Alice'

Exemple 2 : comparer différents types

# comparing_types.py
# These look similar but are different
num = 42
text = "42"
 
print("Number:", num)       # Output: Number: 42
print("Text:", text)        # Output: Text: 42
 
print("Number repr:", repr(num))   # Output: Number repr: 42
print("Text repr:", repr(text))    # Output: Text repr: '42'
 
# repr() makes the difference clear
print("Are they equal?", num == text)  # Output: Are they equal? False

3.8.6) str() et repr() avec d’autres types

Voyons comment str() et repr() fonctionnent avec les types que nous avons vus :

# str_repr_types.py
# Integers
x = 42
print("int str:", str(x))    # Output: int str: 42
print("int repr:", repr(x))  # Output: int repr: 42
 
# Floats
y = 3.14159
print("float str:", str(y))   # Output: float str: 3.14159
print("float repr:", repr(y)) # Output: float repr: 3.14159
 
# Booleans
b = True
print("bool str:", str(b))   # Output: bool str: True
print("bool repr:", repr(b)) # Output: bool repr: True
 
# None
n = None
print("None str:", str(n))   # Output: None str: None
print("None repr:", repr(n)) # Output: None repr: None
 
# Strings (where they differ most)
s = "Hello\nWorld"
print("string str:", str(s))   # Output: string str: Hello
                                #                     World
print("string repr:", repr(s)) # Output: string repr: 'Hello\nWorld'

3.8.7) Points essentiels à retenir

Utilisez str() lorsque :

• Vous créez une sortie destinée aux utilisateurs finaux
• Vous construisez des messages lisibles
• Vous formatez des données pour affichage
• Vous voulez une sortie agréable et conviviale

Utilisez repr() lorsque :

• Vous déboguez du code
• Vous journalisez des informations techniques
• Vous devez voir exactement ce qu’il y a dans une variable
• Vous voulez des représentations non ambiguës

Rappelez‑vous :

• print() utilise automatiquement str() sur ses arguments
• Pour la plupart des types simples, str() et repr() donnent des résultats similaires
• Pour les strings, repr() inclut les guillemets et affiche les séquences d’échappement
• repr() est conçu pour être non ambigu et (idéalement) recréable

Résumé du chapitre

Dans ce chapitre, vous avez appris les notions fondamentales de variables et de types de données en Python. Récapitulons les points clés :

Variables :

• Les variables sont des noms qui font référence à des valeurs en mémoire
• Elles sont créées avec une affectation : variable_name = value
• Elles peuvent être réaffectées à de nouvelles valeurs à tout moment
• Elles doivent respecter des règles de nommage et devraient suivre des conventions
• Des noms descriptifs rendent le code auto‑documenté

Types de données :

• Chaque valeur en Python a un type
• Utilisez type() pour vérifier le type d’une valeur
• Python est à typage dynamique — une variable peut faire référence à des types différents au fil du temps
• Différents types supportent des opérations différentes

Les types de base :

• int : nombres entiers (positifs, négatifs ou nuls), taille arbitraire
• float : nombres avec un point décimal, avec des limitations de précision possibles
• str : texte entouré de guillemets (simples ou doubles)
• bool : valeurs logiques True ou False
• None : valeur spéciale représentant l’absence de valeur

Conversion de type :

• int() : conversion en entier (tronque les floats, interprète les strings)
• float() : conversion en nombre à virgule flottante
• str() : conversion en string (fonctionne toujours)
• Les conversions peuvent échouer avec des entrées invalides (lèvent une ValueError)

Représentations textuelles :

• str() : représentation lisible pour les utilisateurs finaux
• repr() : représentation non ambiguë pour les développeurs et le débogage
• print() utilise automatiquement str()

Ces notions constituent la base de tout le reste en Python. Chaque programme que vous écrirez utilisera des variables pour stocker des données, et comprendre les types de données vous aidera à prévoir quelles opérations fonctionneront et quelles erreurs peuvent survenir.

Au chapitre suivant, nous approfondirons ce socle en explorant en détail la manipulation des nombres, y compris les opérations arithmétiques, la priorité des opérateurs et des schémas numériques courants. Vous apprendrez à effectuer des calculs, à utiliser des fonctions mathématiques et à gérer les particularités de l’arithmétique en virgule flottante.