Variables et types de données essentiels

Stocker des informations : le rôle crucial des variables en Python

En programmation, une variable est un peu comme une boîte étiquetée dans laquelle on peut stocker une information. Cette information peut être un nombre, du texte, ou une valeur plus complexe. L'étiquette, c'est le nom que vous donnez à votre variable, et elle vous permet de retrouver et d'utiliser facilement l'information stockée. Python est un langage à typage dynamique, ce qui signifie que vous n'avez pas besoin de déclarer explicitement le type de données qu'une variable contiendra ; Python le déduit automatiquement au moment où vous lui assignez une valeur.

Pour assigner une valeur à une variable en Python, on utilise le signe égal (`=`). Par exemple, si vous voulez stocker l'âge d'une personne, vous pourriez écrire :

age_utilisateur = 30

Le choix des noms de variables est important pour la lisibilité de votre code. En Python, la convention la plus répandue est le `snake_case`, où les mots sont en minuscules et séparés par des underscores (tirets du bas). Par exemple, `nom_utilisateur`, `prix_total`, `est_valide`. Un nom de variable doit commencer par une lettre ou un underscore, et ne peut contenir que des caractères alphanumériques et des underscores. Evitez d'utiliser des mots-clés réservés par Python (comme `if`, `for`, `while`, etc.) comme noms de variables.

Les nombres en Python : entiers (`int`) et décimaux (`float`)

Python gère nativement plusieurs types de nombres, les plus courants étant les entiers (`int`) et les nombres à virgule flottante (décimaux, `float`). Les entiers sont des nombres sans partie décimale, comme `-5`, `0`, `100`. Les nombres `float` représentent les nombres réels et possèdent une partie décimale, comme `3.14`, `-0.001`, `2.71828`.

Vous pouvez effectuer toutes les opérations arithmétiques de base avec ces types numériques : l'addition (`+`), la soustraction (`-`), la multiplication (`*`), la division (`/`). Python propose aussi la division entière (`//`) qui retourne le quotient entier de la division, l'opérateur modulo (`%`) qui retourne le reste de la division entière, et l'exponentiation (`**`) pour élever un nombre à une puissance.

Voici quelques exemples d'opérations :

nombre1 = 10
nombre2 = 3.5

somme = nombre1 + nombre2  # Résultat: 13.5 (un float)
produit = nombre1 * 2    # Résultat: 20 (un int)
division_exacte = nombre1 / 4 # Résultat: 2.5 (un float)
division_entiere = nombre1 // 4 # Résultat: 2 (un int)
reste = nombre1 % 4        # Résultat: 2 (un int)
puissance = nombre2 ** 2   # Résultat: 12.25 (un float)

Manipuler le texte : les chaînes de caractères (`str`) en Python

Les chaînes de caractères, ou `str` en Python, servent à représenter du texte. Vous pouvez les définir en utilisant des guillemets simples (`'...'`), doubles (`"..."`) ou triples (`'''...'''` ou `"""..."""`). Les guillemets triples sont particulièrement utiles pour les chaînes de caractères s'étendant sur plusieurs lignes ou contenant des guillemets simples et doubles sans avoir à les échapper.

La manipulation la plus simple des chaînes est la concaténation, qui consiste à assembler plusieurs chaînes bout à bout. Cela se fait avec l'opérateur `+`. Par exemple :

prenom = "Alice"
nom = "Dupont"
nom_complet = prenom + " " + nom  # Résultat: "Alice Dupont"

etoiles = "*" * 5  # Résultat: "*****"

Pour formater des chaînes de manière plus lisible et flexible, Python offre les f-strings (chaînes formatées). Elles sont précédées d'un `f` avant le guillemet ouvrant et permettent d'insérer des expressions Python directement dans la chaîne en les plaçant entre accolades `{}`.

age = 25
message = f"Bonjour, je m'appelle {prenom} et j'ai {age} ans."
# Résultat: "Bonjour, je m'appelle Alice et j'ai 25 ans." (si prenom est "Alice")

Les booléens (`True`, `False`) et les opérateurs logiques essentiels

Les booléens sont un type de données fondamental qui ne peut prendre que deux valeurs : `True` (vrai) ou `False` (faux). Ils sont au coeur de la logique de décision dans les programmes. Par exemple, le résultat d'une comparaison est toujours un booléen :

est_majeur = 18 >= 18  # est_majeur vaudra True
condition_fausse = 5 < 3 # condition_fausse vaudra False

Pour combiner ou modifier des expressions booléennes, Python fournit trois opérateurs logiques principaux : `and`, `or`, et `not`. L'opérateur `and` (ET logique) retourne `True` si et seulement si les deux expressions qu'il relie sont `True`.

resultat_and = (5 > 2) and (10 < 20)  # True and True -> True
resultat_and_faux = (5 > 2) and (10 > 20) # True and False -> False

L'opérateur `or` (OU logique) retourne `True` si au moins l'une des deux expressions qu'il relie est `True`.

resultat_or = (1 == 0) or (2 == 2)  # False or True -> True
resultat_or_faux = (1 > 5) or ("a" == "b") # False or False -> False

est_actif = True
n_est_pas_actif = not est_actif  # n_est_pas_actif vaudra False

Exemple concret : calculer l'aire d'un rectangle en Python

Mettons en pratique les concepts de variables et de types de données numériques pour résoudre un problème simple : calculer l'aire d'un rectangle. L'aire d'un rectangle est donnée par la formule : `Aire = longueur × largeur`.

Nous allons d'abord définir deux variables pour stocker la longueur et la largeur du rectangle. Ces valeurs pourraient provenir d'une saisie utilisateur ou être définies directement dans le code. Pour cet exemple, nous allons les définir directement.

# Définition des dimensions du rectangle
longueur = 10.5  # On utilise un float pour permettre des dimensions non entières
largeur = 5.0    # Un autre float

Ensuite, nous utilisons ces variables pour calculer l'aire en appliquant la formule. Le résultat sera stocké dans une nouvelle variable, que nous appellerons `aire_rectangle`.

# Calcul de l'aire
aire_rectangle = longueur * largeur

Finalement, nous pouvons afficher le résultat à l'utilisateur en utilisant la fonction `print()` et une f-string pour un affichage clair.

# Affichage du résultat
print(f"La longueur du rectangle est : {longueur}")
print(f"La largeur du rectangle est : {largeur}")
print(f"L'aire du rectangle est : {aire_rectangle}")