variable = valeurVariable : Un espace mémoire qui contient une valeur. En Python, une variable est créée lorsqu'on lui attribue une valeur.
On affecte des valeurs aux variables nom et age
nom = "Alice"
age = 16On utilise la fonction print() pour afficher les valeurs
print("Nom:", nom)
print("Age:", age)Sortie attendue :
Nom: Alice
Age: 16nom = "Alice"
age = 16
print("Nom:", nom)
print("Age:", age)• Affectation : Utilisation de l'opérateur = pour affecter une valeur à une variable
• Nommage : Utilisation de noms explicites et en minuscules avec underscore
• Types : Chaîne de caractères (str) pour le nom, entier (int) pour l'âge
Float : Type de données pour les nombres décimaux. Exemple : 100.0, 0.2, 80.0
On initialise les variables avec les valeurs données
prix_initial = 100.0
taux_reduction = 0.2On applique la formule : prix_final = prix_initial * (1 - taux_reduction)
prix_final = prix_initial * (1 - taux_reduction)On affiche le prix final
print("Prix final:", prix_final, "€")prix_initial = 100.0
taux_reduction = 0.2
prix_final = prix_initial * (1 - taux_reduction)
print("Prix final:", prix_final, "€")Sortie attendue :
Prix final: 80.0 €• Opérations : Multiplication (*) et soustraction (-)
• Calcul : Prix final = Prix initial × (1 - taux de réduction)
• Types : Utilisation de float pour représenter des valeurs monétaires
Division entière (//) : Renvoie la partie entière du quotient.
Modulo (%) : Renvoie le reste de la division euclidienne.
On affecte les valeurs aux variables a et b
a = 15
b = 4a // b donne la partie entière du quotient
division_entiere = a // b
print("Division entière:", division_entiere)a % b donne le reste de la division
reste = a % b
print("Reste:", reste)Division entière: 15 ÷ 4 = 3 (quotient entier)
Modulo: 15 % 4 = 3 (reste de la division)
Verification: 3 × 4 + 3 = 12 + 3 = 15 ✓
a = 15
b = 4
division_entiere = a // b
reste = a % b
print("Division entière:", division_entiere)
print("Reste:", reste)
print("Vérification: ", division_entiere, "×", b, "+", reste, "=", division_entiere*b + reste)• Division entière : Opérateur //, renvoie le quotient entier
• Modulo : Opérateur %, renvoie le reste
• Relation : a = (a//b) × b + (a%b)
int() : Convertit une valeur en entier.
float() : Convertit une valeur en nombre décimal.
type() : Renvoie le type d'une variable.
On part d'une chaîne de caractères
chaine_nombre = "42"On convertit la chaîne en entier
nombre_entier = int(chaine_nombre)On convertit l'entier en flottant
nombre_flottant = float(nombre_entier)On vérifie les types de chaque variable
print("Type original:", type(chaine_nombre))
print("Type entier:", type(nombre_entier))
print("Type flottant:", type(nombre_flottant))chaine_nombre = "42"
nombre_entier = int(chaine_nombre)
nombre_flottant = float(nombre_entier)
print("Valeur originale:", chaine_nombre, "- Type:", type(chaine_nombre))
print("Valeur entière:", nombre_entier, "- Type:", type(nombre_entier))
print("Valeur flottante:", nombre_flottant, "- Type:", type(nombre_flottant))Sortie attendue :
Valeur originale: 42 - Type: <class 'str'>
Valeur entière: 42 - Type: <class 'int'>
Valeur flottante: 42.0 - Type: <class 'float'>• Conversion : int(), float() pour convertir entre types
• Vérification : type() pour connaître le type d'une variable
• Chaînes numériques : Seulement les chaînes représentant des nombres peuvent être converties
Concaténation : Combinaison de deux chaînes avec l'opérateur +.
On crée les variables phrase et nom
phrase = "Bonjour"
nom = "Alice"On combine les deux chaînes avec un espace
resultat = phrase + " " + nomOn affiche la chaîne concaténée
print(resultat)Formatage de chaîne avec f-string
resultat_fstring = f"{phrase} {nom}"
print(resultat_fstring)phrase = "Bonjour"
nom = "Alice"
# Méthode 1: concaténation avec +
resultat1 = phrase + " " + nom
print("Méthode 1:", resultat1)
# Méthode 2: f-string (recommandée)
resultat2 = f"{phrase} {nom}"
print("Méthode 2:", resultat2)Sortie attendue :
Méthode 1: Bonjour Alice
Méthode 2: Bonjour Alice• Concaténation : Utilisation de l'opérateur + entre chaînes
• Espaces : Inclure explicitement les espaces dans la concaténation
• f-strings : Méthode moderne et lisible pour formater les chaînes
Type bool : Valeur logique pouvant être True (vrai) ou False (faux).
Opérateurs logiques : and, or, not
On évalue l'expression (5 > 3) and (2 < 4)
resultat = (5 > 3) and (2 < 4)(5 > 3) est True
(2 < 4) est True
True and True = True
On affiche la valeur de la variable resultat
print("Résultat:", resultat)# Expression booléenne
resultat = (5 > 3) and (2 < 4)
print("Résultat:", resultat)
# Vérification étape par étape
comparaison1 = (5 > 3) # True
comparaison2 = (2 < 4) # True
print(f"(5 > 3) = {comparaison1}")
print(f"(2 < 4) = {comparaison2}")
print(f"{comparaison1} and {comparaison2} = {resultat}")True and True = True
True and False = False
False and True = False
False and False = False• Comparaisons : >, <, ==, !=, >=, <= renvoient des booléens
• AND : Renvoie True seulement si les deux opérandes sont True
• Booléens : True ou False, sensibles à la casse
Affectation simultanée : Python permet d'échanger des variables sans variable temporaire.
On crée les variables a et b avec les valeurs demandées
a = 10
b = 20On vérifie les valeurs initiales
print(f"Avant échange: a = {a}, b = {b}")Python permet l'affectation multiple
a, b = b, aOn vérifie que les valeurs ont été échangées
print(f"Après échange: a = {a}, b = {b}")a = 10
b = 20
print(f"Avant échange: a = {a}, b = {b}")
# Échange des variables
a, b = b, a
print(f"Après échange: a = {a}, b = {b}")Alternative avec opérations arithmétiques (pour entiers uniquement)
# Méthode arithmétique (uniquement pour les nombres)
a = a + b # a = 10 + 20 = 30
b = a - b # b = 30 - 20 = 10
a = a - b # a = 30 - 10 = 20• Affectation multiple : a, b = b, a échange les valeurs en une seule instruction
• Efficient : Pas besoin de variable temporaire en Python
• Universel : Fonctionne avec n'importe quel type de variable
Addition (+) : Somme de plusieurs valeurs.
Division (/) : Résultat sous forme de flottant.
On affecte les valeurs aux variables note1, note2, note3
note1 = 15
note2 = 12
note3 = 18On applique la formule de la moyenne
moyenne = (note1 + note2 + note3) / 3On vérifie si la moyenne est supérieure à 14
est_superieure_a_14 = moyenne > 14On affiche la moyenne et le résultat de la comparaison
print(f"Moyenne: {moyenne}")
print(f"Moyenne supérieure à 14: {est_superieure_a_14}")note1 = 15
note2 = 12
note3 = 18
moyenne = (note1 + note2 + note3) / 3
est_superieure_a_14 = moyenne > 14
print(f"Notes: {note1}, {note2}, {note3}")
print(f"Moyenne: {moyenne}")
print(f"Moyenne supérieure à 14: {est_superieure_a_14}")Moyenne = (15 + 12 + 18) / 3 = 45 / 3 = 15.0
15.0 > 14 → True
• Moyenne : Somme des valeurs divisée par le nombre de valeurs
• Division : Toujours donne un float même si le résultat est entier
• Comparaison : Renvoie un booléen (True/False)
Comparaison : age >= 18 renvoie True si age est supérieur ou égal à 18.
On affecte une valeur à la variable age
age = 16 # Exemple avec 16 ansOn évalue l'expression conditionnelle
est_majeur = age >= 18On affiche la valeur de la variable booléenne
print(f"Âge: {age}")
print(f"Majeur: {est_majeur}")On peut tester avec plusieurs valeurs d'âge
ages_tests = [15, 17, 18, 19, 25]
for test_age in ages_tests:
est_majeur_test = test_age >= 18
print(f"Âge: {test_age}, Majeur: {est_majeur_test}")age = 16
est_majeur = age >= 18
print(f"Âge: {age}")
print(f"Majeur: {est_majeur}")
# Tests supplémentaires
ages_tests = [15, 17, 18, 19, 25]
print("\nTests avec différents âges:")
for test_age in ages_tests:
est_majeur_test = test_age >= 18
print(f"Âge: {test_age}, Majeur: {est_majeur_test}")• Comparaison : >=, <=, >, <, ==, != renvoient des booléens
• Variable booléenne : Stocke le résultat d'une expression logique
• Condition : age >= 18 vérifie si l'âge est supérieur ou égal à 18
Périmètre : 2 × (longueur + largeur)
Aire : longueur × largeur
On affecte les valeurs aux variables longueur et largeur
longueur = 10.5
largeur = 7.2On applique la formule du périmètre
perimetre = 2 * (longueur + largeur)On applique la formule de l'aire
aire = longueur * largeurOn affiche le périmètre et l'aire
print(f"Périmètre: {perimetre}")
print(f"Aire: {aire}")Périmètre = 2 × (10.5 + 7.2) = 2 × 17.7 = 35.4
Aire = 10.5 × 7.2 = 75.6
longueur = 10.5
largeur = 7.2
perimetre = 2 * (longueur + largeur)
aire = longueur * largeur
print(f"Dimensions: {longueur} × {largeur}")
print(f"Périmètre: {perimetre}")
print(f"Aire: {aire}")
# Avec unités
print(f"Périmètre: {perimetre} unités")
print(f"Aire: {aire} unités²")• Périmètre : 2 × (longueur + largeur)
• Aire : longueur × largeur
• Types : Utilisation de float pour des mesures précises
