Types de données de base : nombres (int, float), chaînes (str), booléens (bool)

Les nombres entiers (int) : représenter des valeurs entières

En Python, le type `int` est utilisé pour représenter des nombres entiers, positifs ou négatifs, sans partie décimale. Il n'y a pas de limite à la taille des entiers en Python (autre que la limite de la mémoire disponible).

Exemples :

x = 10
y = -5
z = 0

print(type(x))  # Affiche 

Vous pouvez effectuer des opérations arithmétiques classiques sur les entiers : addition (`+`), soustraction (`-`), multiplication (`*`), division (`/`), division entière (`//`), modulo (`%`), exponentiation (`**`).

Exemples :

a = 10
b = 3

print(a + b)   # 13
print(a - b)   # 7
print(a * b)   # 30
print(a / b)   # 3.3333333333333335 (division décimale)
print(a // b)  # 3 (division entière)
print(a % b)   # 1 (reste de la division entière)
print(a ** b)  # 1000 (10 à la puissance 3)

Les nombres à virgule flottante (float) : représenter des valeurs décimales

Le type `float` est utilisé pour représenter des nombres à virgule flottante, c'est-à-dire des nombres avec une partie décimale. Les floats sont représentés en interne sous forme binaire, ce qui peut entraîner des problèmes de précision pour certaines valeurs.

Exemples :

x = 3.14
y = -2.5
z = 0.0

print(type(x))  # Affiche 

Vous pouvez effectuer les mêmes opérations arithmétiques sur les floats que sur les ints.

Il est important de noter que les comparaisons entre floats peuvent parfois être piégeuses en raison des erreurs de représentation. Il est souvent préférable d'utiliser une petite marge d'erreur pour comparer des floats :

a = 0.1 + 0.1 + 0.1
b = 0.3

print(a == b)  # Affiche False (en raison des erreurs de représentation)

# Utilisation d'une marge d'erreur
epsilon = 1e-9  # Une petite valeur
print(abs(a - b) < epsilon)  # Affiche True

Python peut utiliser la notation scientifique pour afficher les `floats` :

x = 1000000000000000000000.0
print(x) # Affiche 1e+21

Les chaînes de caractères (str) : manipuler du texte

Le type `str` est utilisé pour représenter des chaînes de caractères, c'est-à-dire du texte. Les chaînes de caractères peuvent être délimitées par des guillemets simples (`'...'`), des guillemets doubles (`"..."`), ou des triples guillemets (`'''...'''` ou `"""..."""`).

Exemples :

chaine1 = 'Bonjour'
chaine2 = "Python"
chaine3 = '''Ceci est une chaîne
sur plusieurs lignes.'''
chaine4 = """Une autre chaîne
sur plusieurs lignes."""

print(type(chaine1))  # Affiche 

Les triples guillemets permettent de définir des chaînes de caractères sur plusieurs lignes, en conservant les sauts de ligne.

Vous pouvez concaténer des chaînes de caractères avec l'opérateur `+` :

prenom = "Alice"
nom = "Dupont"
nom_complet = prenom + " " + nom
print(nom_complet)  # Affiche Alice Dupont

Vous pouvez accéder à des caractères individuels d'une chaîne de caractères en utilisant l'indexation (le premier caractère a l'index 0) :

message = "Bonjour"
print(message[0])  # Affiche B
print(message[3])  # Affiche j

Vous pouvez extraire des sous-chaînes en utilisant le slicing :

message = "Bonjour"
print(message[0:3])  # Affiche Bon (du caractère 0 inclus au caractère 3 exclu)
print(message[3:])   # Affiche jour (du caractère 3 inclus jusqu'à la fin)
print(message[:3])   # Affiche Bon (du début jusqu'au caractère 3 exclu)

Les chaînes de caractères sont immuables, ce qui signifie que vous ne pouvez pas modifier un caractère individuel d'une chaîne existante. Pour modifier une chaîne, vous devez créer une nouvelle chaîne.

Les booléens (bool) : représenter des valeurs de vérité

Le type `bool` est utilisé pour représenter des valeurs de vérité : `True` (vrai) ou `False` (faux). Les booléens sont souvent utilisés dans les structures de contrôle (conditions `if`, boucles `while`).

Exemples :

x = True
y = False

print(type(x))  # Affiche 

Les opérateurs de comparaison (`==`, `!=`, `<`, `>`, `<=`, `>=`) retournent des valeurs booléennes :

a = 10
b = 5

print(a == b)  # False
print(a != b)  # True
print(a > b)   # True
print(a < b)   # False

Les opérateurs logiques (`and`, `or`, `not`) permettent de combiner des expressions booléennes :

x = True
y = False

print(x and y)  # False
print(x or y)   # True
print(not x)    # False

En Python, certaines valeurs sont considérées comme "fausses" dans un contexte booléen : `False`, `None`, `0`, `0.0`, `""` (chaîne vide), `[]` (liste vide), `()` (tuple vide), `{}` (dictionnaire vide). Toutes les autres valeurs sont considérées comme "vraies".