Module 2

Syntaxe de Base et Types de Données

À l'issue de ce module, vous maîtriserez les concepts fondamentaux de Python : créer et manipuler des variables, comprendre et utiliser les différents types de données, effectuer des opérations avec les opérateurs appropriés, interagir avec l'utilisateur via les entrées/sorties, et convertir des données d'un type à l'autre selon vos besoins.

1. Variables et Types de Données

1.1 Comprendre les Variables

Une variable en Python est un espace de stockage nommé qui contient une valeur. Imaginez-la comme une boîte étiquetée. Ce qui rend Python accessible, c'est son typage dynamique : vous n'avez pas besoin de déclarer le type de donnée à l'avance. Python le détermine automatiquement.

La création d'une variable suit une syntaxe simple : nom_variable = valeur. Le nom doit respecter certaines règles : il peut contenir des lettres, des chiffres et des underscores, mais doit commencer par une lettre ou un underscore. Python est sensible à la casse (age et Age sont différents). Utilisez des noms descriptifs comme prix_total.

1.2 Les Types de Données Fondamentaux

Python propose quatre types de données primitifs essentiels :

Entiers (int) : représentent les nombres sans partie décimale, qu'ils soient positifs, négatifs ou nuls. (ex: age = 25, temperature = -5). Python peut gérer des entiers de taille arbitraire, contrairement à d'autres langages qui ont des limites fixes.
Flottants (float) : représentent les nombres décimaux. Ils sont essentiels pour les calculs scientifiques, financiers ou tout calcul nécessitant de la précision (ex: prix = 19.99). Attention toutefois aux limites de précision inhérentes à la représentation en virgule flottante.
Booléens (bool) : Ne peuvent prendre que deux valeurs : True ou False. Ils sont fondamentaux pour la logique de programmation et les structures de contrôle que nous verrons dans le module suivant.
Chaînes de caractères (str) : Texte défini avec des guillemets simples ou doubles.

# Déclaration et utilisation de variables de différents types
age = 25              # int : nombre entier
salaire = 45000.50    # float : nombre décimal
est_employe = True    # bool : valeur logique
nom = "Dupont"        # str : chaîne de caractères
prenom = 'Jean'       # str : autre façon de déclarer une chaîne

# Affichage des valeurs et de leur type
print(f"Âge : {age}, Type : {type(age)}")
print(f"Salaire : {salaire}, Type : {type(salaire)}")
print(f"Est employé ? {est_employe}, Type : {type(est_employe)}")
print(f"Nom complet : {prenom} {nom}, Type : {type(nom)}")

# Python détermine automatiquement le type
compte = 1000         # Python comprend que c'est un int
compte = compte + 0.50  # Maintenant compte devient un float
print(f"Compte : {compte}, Type : {type(compte)}")

2. Opérateurs en Python

2.1 Opérateurs Arithmétiques

Les opérateurs arithmétiques permettent d'effectuer des calculs mathématiques sur vos données. Python propose les opérations classiques plus quelques spécificités intéressantes.

L'addition (+) et la soustraction (-) fonctionnent comme attendu. La multiplication utilise l'astérisque (*), et la division le slash (/). Notez que la division retourne toujours un float, même si les deux opérandes sont des entiers. Pour une division entière qui retourne uniquement la partie entière du résultat, utilisez l'opérateur //. Le modulo (%) donne le reste d'une division et est particulièrement utile pour déterminer si un nombre est pair ou impair. L'exponentiation (**) élève un nombre à une puissance.

# Opérations arithmétiques de base
a = 15
b = 4

print(f"Addition : {a} + {b} = {a + b}")           # 19
print(f"Soustraction : {a} - {b} = {a - b}")       # 11
print(f"Multiplication : {a} * {b} = {a * b}")     # 60
print(f"Division : {a} / {b} = {a / b}")           # 3.75 (toujours un float)
print(f"Division entière : {a} // {b} = {a // b}") # 3 (partie entière)
print(f"Modulo : {a} % {b} = {a % b}")             # 3 (reste de la division)
print(f"Puissance : {a} ** 2 = {a ** 2}")          # 225

# Application pratique du modulo
nombre = 17
if nombre % 2 == 0:
    print(f"{nombre} est pair")
else:
    print(f"{nombre} est impair")

# Priorité des opérations (PEMDAS)
resultat = 2 + 3 * 4  # Multiplication avant addition
print(f"2 + 3 * 4 = {resultat}")  # 14, pas 20

# Utilisation de parenthèses pour changer la priorité
resultat = (2 + 3) * 4
print(f"(2 + 3) * 4 = {resultat}")  # 20

2.2 Opérateurs de Comparaison

Les opérateurs de comparaison, aussi appelés opérateurs relationnels, comparent deux valeurs et retournent toujours un booléen (True ou False). Ils sont essentiels pour prendre des décisions dans vos programmes.

L'égalité se teste avec == (attention, deux signes égal, un seul sert à l'assignation). L'inégalité s'exprime avec !=. Les comparaisons d'ordre utilisent > (supérieur), < (inférieur), >= (supérieur ou égal) et <= (inférieur ou égal).

# Comparaisons numériques
x = 10
y = 15
z = 10

print(f"{x} == {y} : {x == y}")    # False
print(f"{x} == {z} : {x == z}")    # True
print(f"{x} != {y} : {x != y}")    # True
print(f"{x} < {y} : {x < y}")      # True
print(f"{x} <= {z} : {x <= z}")    # True (égalité compte)
print(f"{x} > {y} : {x > y}")      # False

# Comparaisons de chaînes (ordre alphabétique)
mot1 = "Python"
mot2 = "Java"
print(f"'{mot1}' < '{mot2}' : {mot1 < mot2}")  # False (P vient après J)

# Comparaisons multiples enchaînées (spécificité Python)
age = 25
est_adulte = 18 <= age < 65
print(f"Est adulte actif (18-64 ans) : {est_adulte}")  # True

2.3 Opérateurs Logiques

Ils combinent des booléens avec les mots-clés and, or, et not. and retourne True si toutes les conditions sont vraies, or si au moins une l'est.

# Conditions simples
age = 25
a_permis = True
a_voiture = False

# Opérateur AND
peut_conduire = age >= 18 and a_permis
print(f"Peut conduire légalement : {peut_conduire}")  # True

# Opérateur OR
peut_se_deplacer = a_voiture or a_permis
print(f"A un moyen de transport motorisé : {peut_se_deplacer}")  # True

# Opérateur NOT
est_pieton = not a_voiture
print(f"Est piéton : {est_pieton}")  # True

# Court-circuit : Python arrête l'évaluation dès que le résultat est certain
resultat = False and print("Ceci ne s'affichera pas")
resultat = True or print("Ceci ne s'affichera pas non plus")

3. Entrées et Sorties

3.1 La Fonction print() Avancée

Nous avons déjà utilisé print() dans sa forme simple, mais cette fonction offre bien plus de possibilités pour formater vos sorties de manière professionnelle.

La fonction print() accepte plusieurs arguments qui seront affichés séparés par des espaces par défaut. Vous pouvez personnaliser le séparateur avec le paramètre sep et la fin de ligne avec end. Par défaut, print() ajoute un retour à la ligne, mais vous pouvez le modifier.

# Affichage multiple avec séparateur personnalisé
nom = "Martin"
prenom = "Julie"
age = 28
print(nom, prenom, age, sep=" - ") # Séparateur personnalisé

# Formatage avec f-strings
prix = 49.99
quantite = 3
total = prix * quantite
print(f"Prix unitaire : {prix:.2f}€")
print(f"Total : {total:.2f}€")

# Alignement et remplissage
produit = "Ordinateur"
print(f"{produit:20} : {prix:10.2f}€")  # Alignement sur 20 caractères

# Formatage de nombres
nombre = 1234567.89
print(f"Format standard : {nombre:,.2f}")     # Avec séparateurs de milliers
print(f"Pourcentage : {0.75:.1%}")           # Format pourcentage

3.2 La Fonction input() et l'Interaction Utilisateur

La fonction input() récupère les saisies de l'utilisateur. Attention, elle retourne toujours une chaîne de caractères. Il faut donc la convertir manuellement.

# Saisie simple
nom = input("Quel est votre nom ? ")
print(f"Bonjour, {nom} !")

# Saisie numérique avec conversion
age_str = input("Quel est votre âge ? ")
age = int(age_str)
annee_naissance = 2024 - age
print(f"Vous êtes né(e) aux alentours de {annee_naissance}")

# Gestion d'erreurs basique
try:
    nombre = int(input("Entrez un nombre entier : "))
    print(f"Le double de {nombre} est {nombre * 2}")
except ValueError:
    print("Erreur : vous n'avez pas entré un nombre entier valide")

4. Conversion de Types (Casting)

4.1 Conversion Implicite

Python convertit automatiquement certains types pour éviter la perte de données (ex: int en float lors d'une opération mixte). Cependant, il ne convertit pas implicitement un nombre en chaîne pour la concaténation.

Cette conversion implicite, aussi appelée coercition, suit une hiérarchie : bool → int → float → complex. Python convertit toujours vers le type le plus général pour préserver l'information.

# Concaténation de chaînes - pas de conversion implicite !
texte = "Le résultat est : "
nombre = 42
# print(texte + nombre)  # Erreur !
print(texte + str(nombre))  # Conversion explicite nécessaire

4.2 Conversion Explicite

Vous pouvez forcer la conversion avec les fonctions int(), float(), str(), et bool(). La conversion d'un flottant en entier tronque la partie décimale.

# Conversions numériques
decimal = 9.78
entier = int(decimal)
print(f"int({decimal}) = {entier}")  # 9 (pas d'arrondi !)

# Pour arrondir, utilisez round()
arrondi = round(decimal)
print(f"round({decimal}) = {arrondi}")  # 10

# Chaîne vers nombre
prix_str = "29.99"
prix = float(prix_str)
tva = prix * 0.20
print(f"Prix TTC : {prix + tva:.2f}€")

# Conversions booléennes
print(f"bool(0) = {bool(0)}")           # False
print(f"bool('texte') = {bool('texte')}") # True

5. Exercices Pratiques

Exercice 1 : Calculatrice Simple

Créez un programme qui demande deux nombres à l'utilisateur et affiche le résultat de toutes les opérations arithmétiques de base. Le programme doit gérer la division par zéro.

Voir la solution

def calculatrice():
    try:
        num1 = float(input("Entrez le premier nombre : "))
        num2 = float(input("Entrez le second nombre : "))

        print(f"\n--- Résultats ---")
        print(f"Addition : {num1 + num2}")
        print(f"Soustraction : {num1 - num2}")
        print(f"Multiplication : {num1 * num2}")

        if num2 != 0:
            print(f"Division : {num1 / num2:.2f}")
            print(f"Division entière : {num1 // num2}")
        else:
            print("Division par zéro impossible !")

    except ValueError:
        print("Erreur : Veuillez entrer des nombres valides.")

if __name__ == "__main__":
    calculatrice()

Exercice 2 : Analyseur de Types

Écrivez un programme qui demande à l'utilisateur d'entrer une valeur et détermine son type probable en distinguant entre entiers, décimaux, booléens et texte.

Voir la solution

def analyseur_de_types():
    entree = input("Entrez n'importe quelle valeur : ")

    # Vérifier si c'est un booléen
    if entree.lower() in ["true", "false"]:
        print(f"La valeur '{entree}' semble être un booléen (bool).")
        return

    # Essayer de convertir en entier
    try:
        int(entree)
        print(f"La valeur '{entree}' semble être un entier (int).")
        return
    except ValueError:
        pass

    # Essayer de convertir en décimal
    try:
        float(entree)
        print(f"La valeur '{entree}' semble être un décimal (float).")
        return
    except ValueError:
        pass

    print(f"La valeur '{entree}' est du texte (str).")

if __name__ == "__main__":
    analyseur_de_types()

Exercice 3 : Convertisseur d'Unités

Développez un convertisseur qui permet de transformer des températures (Celsius ↔ Fahrenheit), des distances (km ↔ miles) et des poids (kg ↔ livres). L'utilisateur choisit le type de conversion et entre la valeur à convertir.

Voir la solution

def convertisseur_unites():
    print("Choisissez une conversion :")
    print("1. Celsius vers Fahrenheit")
    print("2. Kilomètres vers Miles")
    choix = input("Votre choix (1 ou 2) : ")

    try:
        if choix == '1':
            celsius = float(input("Entrez la température en Celsius : "))
            fahrenheit = (celsius * 9/5) + 32
            print(f"{celsius}°C équivaut à {fahrenheit:.1f}°F.")
        elif choix == '2':
            km = float(input("Entrez la distance en km : "))
            miles = km / 1.609
            print(f"{km} km équivaut à {miles:.2f} miles.")
        else:
            print("Choix invalide.")
    except ValueError:
        print("Erreur : Veuillez entrer une valeur numérique valide.")

if __name__ == "__main__":
    convertisseur_unites()

6. Points Clés à Retenir

Les variables en Python utilisent le typage dynamique.
Les quatre types de base sont int, float, bool, et str.
La fonction input() retourne toujours une chaîne ; pensez à convertir.
Les f-strings (f"...") sont la méthode moderne pour formater les chaînes.

Pour aller plus loin

Source: EvoluNoob