Principes de base de Python : Variables, types de données et structures de contrôle

  1. Conventions de nommage des variables ========================================

Une variable est un espace de stockage dont la valeur peut être modifiée au cours de l'exécution d'un programme. Lors de la déclaration d'une variable, telle que nom = "123", il est crucial de suivre des règles de nommage pour assurer la clarté et éviter les conflits.

Règles de définition des variables :

  • Les noms de variables peuvent être composés de lettres, de chiffres et de tirets bas (_).
  • Un nom de variable ne peut pas commencer par un chiffre.
  • Les mots-clés réservés de Python ne peuvent pas être utilisés comme noms de variables. Ces mots incluent : and, as, assert, break, continue, def, del, elif, else, except, finally, for, from, global, if, import, in, is, lambda, not, or, pass, print, raise, return, try, while, yield. L'utilisation de ces mots comme noms de variables écraserait leur signification prédéfinie.

Conventions de nommage :

  • Style snake_case (recommandé) : Les noms sont en minuscules, avec des mots séparés par des tirets bas. Exemple : age_du_vieux_garçon = 100, nombre_etudiants = 80.
  • Style CamelCase : Les noms commencent par une majuscule (sauf le premier mot), et les mots suivants sont capitalisés. Exemple : AgeDuVieuxGarçon = 100, NombreEtudiants = 80.

Points importants :

  • Les noms de variables ne doivent pas être en chinois ou en pinyin.
  • Les noms de variables excessivement longs sont décnoseillés.
  • Les noms de variables doivent être descriptifs et refléter leur contenu.

Constantes :

En Python, il n'existe pas de type de données dédié aux constantes. Par convention, les programmeurs utilisent des noms de variables entièrement en majuscules pour indiquer qu'une valeur est destinée à rester inchangée. Exemple : AGE = 100.

  1. Interaction utilisateur et commentaires ===========================================

La concaténation de chaînes de caractères s'effectue à l'aide de l'opératteur +.

Lecture des entrées utilisateur :

La fonction input() permet de récupérer des données saisies par l'utilisateur. Le texte passé en argument à input() est affiché comme une invite.

nom = input("Quel est votre nom ? ")
print("Bonjour,", nom)

nom_utilisateur = input("Nom d'utilisateur >> ")
mot_de_passe = input("Mot de passe >> ")
print(nom_utilisateur, mot_de_passe)

Commentaires :

Les commentaires servent à expliquer le code. Il n'est pas nécessaire de commenter chaque ligne. Utilisez des commentaires pour clarifier les parties complexes ou inhabituelles du code. Les commentaires peuvent être rédigés en anglais ou en français, mais l'utilisation du pinyin est à proscrire.

  1. Types de données numériques ===============================

Python distingue plusieurs types de données numériques :

  • Entiers (int) : Représentent les nombres entiers. La taille des entiers est limitée par la mémoire de la machine, mais Python gère automatiquement les très grands entiers (anciennement appelés long).
  • Nombres à virgule flottante (float) : Représentent les nombres réels avec une partie décimale.
  • Nombres complexes : Moins couramment utilisés, ils comportent une partie réelle et une partie imaginaire.

Note : Dans les versions récentes de Python, la distinction entre int et long a été supprimée ; les entiers peuvent croître indéfiniment en fonction de la mémoire disponible.

  1. Types de données chaînes de caractères (str) ==================================================

Une chaîne de caractères est une séquence de caractères entourée de guillemets. Python accepte les guillemets simples (' '), doubles (" ") ou triples (''' ''' ou """ """).

Les guillemets simples et doubles sont interchangeables pour les chaînes courtes. Les guillemets triples sont utiles pour les chaînes multi-lignes ou contenant des guillemets.

nom = "Panda"
age_str = "2"  # Notez que ceci est une chaîne, pas un nombre
message = "J'ai 20 ans !"

# Les chaînes peuvent être concaténées
salutation = "Bonjour, " + nom
print(salutation)

# Les chaînes peuvent être répétées
repetition = nom * 3
print(repetition)

# Tenter d'additionner une chaîne et un nombre génère une erreur
# print(age_str + 5) # Ceci produira une TypeError

Il est essentiel de définir une variable avant de l'utiliser. Les opérations arithmétiques ne sont possibles qu'entre types de données compatibles (par exemple, deux nombres). L'addition de chaînes concatène, tandis que la multiplication répète la chaîne.

  1. Type de données booléen (bool) ====================================

Le type booléen représente la vérité logique et ne peut avoir que deux valeurs : True (vrai) ou False (faux). Les booléens sont fondamentaux pour les structures de contrôle conditionnelles et les comparaisons.

  1. Sortie formatée ===================

La sortie formatée permet de construire des chaînes de caractères en insérant des valeurs de variables de manière structurée. Les spécificateurs de format courants incluent %s pour les chaînes et %d pour les entiers.

nom = input("Nom : ")
age = input("Âge : ")
travail = input("Emploi : ")
ville = input("Ville d'origine : ")

informations = f"""
--------- Informations sur {nom} ---------
Nom : {nom}
Âge : {age}
Emploi : {travail}
Ville : {ville}
--------- Fin des informations --------
"""
print(informations)

# Autre méthode utilisant % (plus ancienne)
# informations_legacy = """
# --------- Informations sur %s ---------
# Nom:%s
# Âge:%s
# Emploi:%s
# Ville:%s
# --------- Fin des informations ---------
# """ % (nom, nom, age, travail, ville)
# print(informations_legacy)

# Note importante : La fonction input() retourne toujours une chaîne de caractères,
# même si l'utilisateur saisit des chiffres.
# Si une conversion numérique est nécessaire, utilisez int() ou float().
# Exemple : age_num = int(input("Âge : "))

Le spécificateur %s est polyvalent et peut représenter divers types de données sous forme de chaîne.

  1. Opérateurs ==============

Python propose divers opérateurs pour effectuer des opérations :

  • Opérateurs arithmétiques : + (addition), - (soustraction), * (multiplication), / (division), % (modulo), ** (exponentiation), // (division entière).
  • Opérateurs de comparaison : == (égal à), != (différent de), > (supérieur à), < (inférieur à), >= (supérieur ou égal à), <= (inférieur ou égal à).
  • Opérateurs logiques :
    • and : Vrai si les deux opérandes sont vrais.
    • or : Vrai si au moins un des opérandes est vrai.
    • not : Inverse la valeur booléenne de l'opérande.
  • Opérateurs d'affectation : = (affectation simple), +=, -=, *=, /=, %=, **=, //= (affectations combinées).
  • Opérateurs d'appartenance : in, not in (vérifie si un élément est présent dans une séquence).
  • Opérateurs d'identité : is, is not (vérifie si deux variables font référence au même objet).
  1. Contrôle de flux : Conditions simples et doubles ====================================================

Les structures de contrôle permettent d'influencer l'ordre d'exécution du code.

  • Condition simple (if) : Le bloc de code est exécuté uniquement si la condition est vraie. ``` if condition: # Code à exécuter si la condition est vraie
  • Condition double (if-else) : Un bloc de code est exécuté si la condition est vraie, sinon un autre bloc est exécuté. ``` if condition: # Code à exécuter si la condition est vraie else: # Code à exécuter si la condition est fausse

Exemple d'exercice :

nom = input("Entrez votre nom : ")
sexe = input("Entrez votre sexe (M/F) : ")
age = int(input("Entrez votre âge : ")) # Conversion en entier nécessaire pour la comparaison

if sexe.lower() == "f" and age < 28:
   print("J'aime les femmes jeunes.")
elif sexe.lower() == "m":
   print("Le monde des hommes !")
else:
   print("Cas non géré.")
  1. Conditions multiples (if-elif-else) =========================================

Permet de tester plusieurs conditions séquentiellement. Le premier bloc dont la condition est vraie est exécuté.

if condition1:
   # Code si condition1 est vraie
elif condition2:
   # Code si condition1 est fausse ET condition2 est vraie
elif condition3:
   # Code si conditions précédentes sont fausses ET condition3 est vraie
else:
   # Code si aucune des conditions précédentes n'est vraie
  1. Attribution de notes ========================

Exemple d'utilisation des conditions pour attribuer une note basée sur un score.

score = int(input("Entrez votre score (0-100) : "))

if 90 <= score <= 100:
   print("Votre note est A")
elif 80 <= score <= 89:
   print("Votre note est B")
elif 60 <= score <= 79:
   print("Votre note est C")
elif 40 <= score <= 59:
   print("Votre note est D")
elif 0 <= score <= 39:
   print("Votre note est E")
else:
   print("Score invalide !")
  1. Boucle while ==================

La boucle while répète un bloc de code tant qu'une condition spécifiée reste vraie. C'est un outil essentiel pour éviter la répétition de code.

# Afficher les nombres de 0 à 100
compteur = 0
while compteur <= 100:
   print("Itération :", compteur)
   compteur += 1
  1. Boucles infinies ====================

Une boucle while dont la condition est toujours vraie (par exemple, while True:) créera une boucle infinie, qui s'exécutera indéfiniment à moins d'être interrompue explicitement.

  1. continue et break =========================

Ces instructions permettent de contrôler le déroulement d'une boucle :

  • break : Termine immédiatement la boucle actuellle et transfère le contrôle à l'instruction suivant la boucle.
  • continue : Interrompt l'itération actuelle de la boucle et passe à l'itération suivante. Le reste du code dans le bloc de la boucle pour cette itération n'est pas exécuté.

Exemple : Jeu de devinette d'âge

age_secret = 25
tentatives_max = 3
tentatives_restantes = tentatives_max

while True: # Boucle principale pour permettre de rejouer
   compteur_tentatives = 0
   while compteur_tentatives < tentatives_restantes:
       try:
           guess = int(input("Devinez mon âge (il vous reste {} tentatives) : ".format(tentatives_restantes - compteur_tentatives)))
           if guess > age_secret:
               print("Trop grand !")
           elif guess < age_secret:
               print("Trop petit !")
           else:
               print("Félicitations, vous avez trouvé !")
               break # Sortir de la boucle de tentatives interne
           compteur_tentatives += 1
       except ValueError:
           print("Veuillez entrer un nombre valide.")
           compteur_tentatives += 1 # Compter une tentative même pour une entrée invalide

   if guess == age_secret:
       print("Bravo !")
   else:
       print("Dommage, vous avez épuisé vos tentatives. L'âge était", age_secret)

   rejouer = input("Voulez-vous rejouer ? (O/N) : ")
   if rejouer.lower() == 'o':
       tentatives_restantes = tentatives_max # Réinitialiser les tentatives
       continue # Recommencer la boucle principale
   elif rejouer.lower() == 'n':
       print("Merci d'avoir joué !")
       break # Sortir de la boucle principale
   else:
       print("Commande invalide. Le jeu va se terminer.")
       break # Sortir de la boucle principale

Étiquettes: Python variables types de données chaînes de caractères booléens

Publié le 21 juin à 21h34

Étiquettes Populaires

©2026 L'Atelier Monstre