📘 Python pour débutants

🚀 Démarrage rapide

• Installer Python depuis le site officiel Python.org et ajouter Python.exe au PATH sur Windows.
• Télécharger et installer Visual Studio Code (VS Code) puis installer l’extension Python (Microsoft).
• Créer un fichier .py et écrire son premier programme avec la fonction print (exemple: print("Hello, World")).
• Lancer le programme via le bouton Run/Play et vérifier l’affichage.

🎯 Concepts de base et types

• Types de base à connaître: str, int, float.
• Utiliser la fonction Python intégrée print pour afficher des valeurs et type pour connaître le type d’une valeur.
• Définir des variables en utilisant le style snake_case (ex: ma_variable).
• Les opérateurs arithmétiques et l’ordre des priorités: addition, soustraction, multiplication, division, exposant, division entière et modulo.
• Le type booléen (bool) possède deux valeurs: True et False (en Python on écrit true/false dans le texte, mais ce seront les mots-clés Python). Tout objet peut être évalué en booléen: valeurs truthy ou falsy.
• Conversion de types (cast) avec:
  • str(...) convertir en chaîne de caractères
  • int(...) convertir en entier
  • float(...) convertir en nombre décimal
• Lire des entrées utilisateur avec input(...) qui retourne une chaîne; pour en faire un nombre, il faut convertir (ex: float(input("Âge : "))).
• Affichage formaté et multi-arguments: print(a, b) insère des espaces entre les valeurs.

Projet simple: convertisseur Celsius → Fahrenheit

• Formule: $F = C \times \frac{9}{5} + 32$
• Étapes: lire C (float), calculer F, afficher le résultat.
• Amélioration d’affichage: utiliser print avec plusieurs arguments afin d’indiquer les unités: print(C, "°C équivaut à", F, "°F").

🧭 Contrôles de flux

• Structure conditionnelle: if, elif, else avec indentation cohérente (espaces ou tabulations, mais constants dans tout le bloc).
• Exemple mot de passe: vérifier égalité, puis afficher messages appropriés selon les cas.
• Utilisation de len(...) pour obtenir la longueur d’une chaîne.
• Notion d’Elif: permet de tester plusieurs conditions dans un seul bloc if.

Exercices de conditions

• Vérifier la longueur du mot de passe et afficher si trop court ou égal à zéro.
• Vérifier la moyenne et afficher les mentions:
  • 12 ≤ moyenne < 14 → "assez bien"
  • 14 ≤ moyenne < 16 → "bien"
  • 16 ≤ moyenne < 18 → "très bien"
  • ≥ 18 → "félicitations du jury"
  • Sinon → pas de mention

🪄 Boucles et collections

• Boucles: while et for.
  • while répète tant que la condition est vraie; attention aux boucles infinies si l’incrément n’est pas correct.
  • for itère sur des objets itérables; pour répéter N fois, utiliser range(N) qui retourne 0..N-1.
• Listes: déclarées avec [] et peuvent contenir tout type d’objet
  • Accès par indice (zéro-based), modification d’un élément, slicing [start:end].
  • Méthodes: append(...), remove(...).
  • Vérification d’appartenance: in.
• Tuples: immuables; accès par indice; méthodes index et count.
• Sets: ensembles non ordonnés et sans doublons; immutable; méthodes add, remove, pop et opérations union, intersection, difference.
• Dictionnaires: paires clé-valeur; accès par clé; méthodes get, update, pop, keys, values, items.
• Debug et introspection: dir(obj) et help(obj).

Petit rappel sur les structures

🧩 Fonctions

• Définir une fonction avec def nom(params): puis indenter le corps et utiliser return pour renvoyer une valeur.
• Paramètres: zéro ou plusieurs; valeurs par défaut pour paramètres optionnels; paramètres variable à l’aide de *args (tuple) et de **kwargs (dict).
• Portée (scope): variables locales à une fonction; variables globales si déclarées en dehors.
• Exemples:
  • def somme(A, B): return A + B
  • Appel: S = somme(4, 5) puis print(S) → 9
  • Retourner plusieurs valeurs: return A+B, A, B puis traitement lors de l’appel.
• Notion pratique: les paramètres optionnels et les args permettent de créer des fonctions flexibles et réutilisables.

🧱 Programmation orientée objet (POO)

• Classe: modèle (moule) pour créer des objets; convention de nommage: PascalCase (ex: Voiture, non voiture).
• Instances: objets créés à partir d’une classe; chaque instance a ses propres attributs.
• Self: référence à l’instance courante dans les méthodes; premier paramètre des méthodes de classe.
• Constructeur: méthode spéciale __init__(self, ...), appelée lors de l’instanciation, qui initialise les attributs.
• Exemples de base: création d’une classe Voiture avec attributs marque, modele, annee et méthode klaxonner(self).
• Utilisation de dir(obj) pour l’inspection et help(obj) pour l’aide.
• Cas d’usage: créer plusieurs voitures (Tesla Cyber Truck, Toyota Corolla) avec des attributs différents et appeler leurs méthodes.

Projet pizza (exercice POO simplifié)

• Classe Pizza avec attributs: base, prix, diametre, style, ingredients.
• Constructeur initialise les attributs avec les paramètres: self.base = base, self.prix = prix, etc.
• Méthodes:
  • ajouter_ingrédient(nouvel_ingrédient) vérifie que l’ingrédient n’est pas ananas (sinon, levée d’erreur) et augmente le prix de 1€ par ingrédient ajouté.
  • servir(table) affiche “J’amène la pizza à la table {table}".
  • livrer(adresse) affiche "Je livre la pizza à l’adresse {adresse}".
• Interaction utilisateur: demande base (tomate/blanche), taille (moyenne/grande → diam 30/34 cm), style (classique/calzone/Stromboli/autre), ingrédients (séparés par des virgules).
• Calcul du prix: prix de base + 1€ par ingrédient.
• Contrôle d’erreur: interdiction d’ananas (levée d’erreur si présent).
• Démonstration: ajout d’olives augmente le nombre d’ingrédients et le prix; utilisation des méthodes servir et livrer.

⏩ Rappels pratiques et conseils

• Python est un langage polyvalent et populaire en 2024; utile pour backend, data science, IA, automatisation, jeux simples.

• Même si on peut passer à d’autres langages, Python est idéal pour comprendre les bases.

• Pour réviser, utilisez des déclencheurs mnémotechniques: noms de variables clairs (snake_case), indentation constante, et connaître les primitives (print, input, type, len, range, etc.).

• Utiliser les exercices concrets (Hello World, conversions, conditions, boucles, structures de données et POO) pour consolider la compréhension et la mémorisation active.

• Fin de fiche technique.