Introduction au Codage Python pour Débutants
4 générations
QCM
Question 1 sur 10✅ 0❌ 0
Quel est le résultat de l'opération 4 * 3 + 2 en Python ?
{
"questions": [
{
"question": "Quel est l'objectif principal de ce cours de Python ?",
"options": [
{
"text": "Apprendre à coder en Python à partir de zéro.",
"why": "Ce cours est destiné aux débutants et vise à enseigner les bases de la programmation en Python.",
"correct": true
},
{
"text": "Devenir un expert en développement web.",
"why": "Bien que le cours aborde le développement web, l'objectif principal est d'initier les débutants à la programmation en Python.",
"correct": false
},
{
"text": "Apprendre uniquement les mathématiques avancées.",
"why": "Le cours ne nécessite pas de compétences en mathématiques avancées, il se concentre sur la programmation.",
"correct": false
}
]
},
{
"question": "Quelle est la première étape pour commencer à coder en Python ?",
"options": [
{
"text": "Installer Python et un éditeur de texte.",
"why": "La première étape consiste à installer Python et un éditeur de texte pour écrire du code.",
"correct": true
},
{
"text": "Apprendre les mathématiques avancées.",
"why": "Le cours ne nécessite pas de connaissances en mathématiques avancées pour commencer à coder.",
"correct": false
},
{
"text": "Lire des livres sur la programmation.",
"why": "Bien que la lecture puisse être utile, la première étape pratique est d'installer les outils nécessaires.",
"correct": false
}
]
},
{
"question": "Quel éditeur de texte est recommandé pour coder en Python dans ce cours ?",
"options": [
{
"text": "Visual Studio Code.",
"why": "Visual Studio Code est recommandé comme éditeur de texte pour coder en Python.",
"correct": true
},
{
"text": "Notepad.",
"why": "Notepad n'est pas mentionné comme un éditeur recommandé pour coder en Python dans ce cours.",
"correct": false
},
{
"text": "Sublime Text.",
"why": "Bien que Sublime Text soit un bon éditeur, Visual Studio Code est spécifiquement recommandé dans ce cours.",
"correct": false
}
]
},
{
"question": "Quel est le type de la valeur affichée par la fonction print pour un entier en Python ?",
"options": [
{
"text": "int",
"why": "Les entiers en Python sont de type 'int'.",
"correct": true
},
{
"text": "float",
"why": "Les flottants sont de type 'float', pas les entiers.",
"correct": false
},
{
"text": "str",
"why": "Les chaînes de caractères sont de type 'str', pas les entiers.",
"correct": false
}
]
},
{
"question": "Comment peut-on transformer un entier en chaîne de caractères en Python ?",
"options": [
{
"text": "En utilisant la fonction str().",
"why": "La fonction str() permet de convertir un entier en chaîne de caractères.",
"correct": true
},
{
"text": "En utilisant la fonction int().",
"why": "La fonction int() convertit une chaîne en entier, pas l'inverse.",
"correct": false
},
{
"text": "En utilisant la fonction float().",
"why": "La fonction float() convertit en nombre décimal, pas en chaîne de caractères.",
"correct": false
}
]
},
{
"question": "Quel type de valeur est retourné par la fonction input() ?",
"options": [
{
"text": "str",
"why": "La fonction input() retourne toujours une chaîne de caractères.",
"correct": true
},
{
"text": "int",
"why": "input() retourne une chaîne, pas un entier.",
"correct": false
},
{
"text": "float",
"why": "input() retourne une chaîne, pas un flottant.",
"correct": false
}
]
},
{
"question": "Comment déclare-t-on une variable en Python ?",
"options": [
{
"text": "En utilisant le signe égal (=).",
"why": "Le signe égal est utilisé pour assigner une valeur à une variable en Python.",
"correct": true
},
{
"text": "En utilisant le mot clé var.",
"why": "Python n'utilise pas le mot clé var pour déclarer des variables.",
"correct": false
},
{
"text": "En utilisant le mot clé let.",
"why": "Le mot clé let n'est pas utilisé en Python pour déclarer des variables.",
"correct": false
}
]
},
{
"question": "Quel est le but des variables en Python ?",
"options": [
{
"text": "Stocker des valeurs pour les réutiliser plus tard.",
"why": "Les variables servent à stocker des valeurs pour pouvoir les manipuler et les réutiliser dans le programme.",
"correct": true
},
{
"text": "Exécuter des fonctions automatiquement.",
"why": "Les variables ne servent pas à exécuter des fonctions, mais à stocker des données.",
"correct": false
},
{
"text": "Créer des graphiques.",
"why": "Les variables ne sont pas spécifiquement utilisées pour créer des graphiques.",
"correct": false
}
]
},
{
"question": "Quel est le résultat de l'opération 4 * 3 + 2 en Python ?",
"options": [
{
"text": "14",
"why": "L'ordre de priorité des opérations donne 4 * 3 = 12, puis 12 + 2 = 14.",
"correct": true
},
{
"text": "20",
"why": "20 serait le résultat si l'addition était effectuée avant la multiplication, ce qui n'est pas le cas.",
"correct": false
},
{
"text": "12",
"why": "12 est le résultat de la multiplication seule, pas de l'addition.",
"correct": false
}
]
},
{
"question": "Quelle fonction permet de connaître le type d'une valeur en Python ?",
"options": [
{
"text": "type()",
"why": "La fonction type() retourne le type d'une valeur donnée.",
"correct": true
},
{
"text": "value_type()",
"why": "value_type() n'est pas une fonction existante en Python.",
"correct": false
},
{
"text": "get_type()",
"why": "get_type() n'est pas une fonction existante en Python.",
"correct": false
}
]
}
]
}# Cours de Python pour débutants ## Introduction - Destiné aux débutants - Pas besoin de connaissances préalables - Installation et concepts de base ## Installation ### Python - Site officiel : Python.org - Télécharger la dernière version - Ajouter Python.exe au PATH (Windows) ### Éditeur de texte - Choix : Visual Studio Code - Site : code.visualstudio.com - Installation et configuration de l'extension Python ## Concepts de base ### Affichage de texte - Utilisation de la fonction print - Exemple : Hello World ### Types de valeurs - Entiers - Opérations : addition, soustraction, multiplication, division entière, modulo - Nombres décimaux (float) - Chaînes de caractères (str) - Fonction type pour identifier le type ### Variables - Déclaration et assignation - Exemple : ma_variable = 42 - Réassignation de valeur ### Opérations sur les types - Concaténation de chaînes et erreurs de type - Utilisation de la fonction str pour caster ## Lecture de valeurs ### Fonction input - Récupérer des valeurs utilisateur - Transformation de type avec int ## Projets pratiques ### Convertisseur Celsius vers Fahrenheit - Utilisation de input et print - Formule de conversion ### Gestion des types - Introduction au type booléen - Opérateurs de comparaison - Opérateurs logiques (and, or) ## Structures de contrôle ### Condition If - Exécution conditionnelle de code - Utilisation de else et elif ### Boucles #### While - Répétition tant qu'une condition est vraie #### For - Itération sur des objets itérables - Utilisation de range ## Listes - Déclaration et manipulation - Méthodes : append, remove ## Dictionnaires - Structure clé-valeur - Accès aux valeurs par clé - Méthodes : get, update, pop ## Classes et POO ### Déclaration de classes - Exemple : classe Voiture - Constructeur avec init - Attributs et méthodes ### Instances - Création d'objets à partir de classes - Utilisation de self ## Conclusion - Importance de la pratique - Encouragement à explorer davantage Python
# 📘 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
| Structure | Mutabilité | Ordre | Accès / Exemple | Remarques clés |
|---|---|---|---|---|
| Listes | mutable | ordonné | `liste[i]` | `append`, `remove`, `in` |
| Tuples | immutable | ordonné | `t[i]` | plus rapide que listes; idéal pour structures hétérogènes |
| Sets | immutable après création (non modifiables par index) | non garanti | non indice | pas de doublons; opérations d’ensemble |
| Dictionnaires | mutable | ordre d’insertion (depuis Python 3.7) | `dico[k]` | `get`, `update`, `keys`, `values`, `items` |
## 🧩 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."Quelle est la cible principale de ce cours Python ?","Ce cours est destiné aux débutants sans aucune connaissance préalable en programmation ou en maths."
"Quel est le premier outil à installer pour coder en Python ?","Il faut installer Python depuis le site officiel Python.org."
"Que faut-il cocher lors de l'installation de Python sur Windows ?","Il faut cocher 'Ajouter Python.exe au PATH' pour que l'ordinateur sache où se trouve Python."
"Quel éditeur de texte est recommandé pour coder en Python ?","Visual Studio Code (VS Code) est l'éditeur recommandé."
"Quelle extension faut-il installer dans VS Code pour coder en Python ?","Il faut installer l'extension Python développée par Microsoft."
"Quel est le programme typique pour débuter l'apprentissage d'un langage de programmation ?","Le programme 'Hello World' est typiquement utilisé pour débuter."
"Comment écrire un 'Hello World' en Python ?","On utilise la fonction `print("Hello, World")`."
"Quelle fonction permet d'afficher des valeurs en Python ?","La fonction `print()` permet d'afficher des valeurs."
"Comment afficher un entier en Python ?","On fournit directement la valeur entière à la fonction `print()`, par exemple `print(3)`."
"Quelles sont les opérations arithmétiques possibles sur les entiers en Python ?","Les opérations possibles sont : addition (`+`), soustraction (`-`), multiplication (`*`), division (`/`), exposant (`**`), division entière (`//`), et modulo (`%`)."
"Quel est l'ordre de priorité des opérations arithmétiques en Python ?","L'ordre de priorité est le même qu'en maths : parenthèses, exposants, multiplication/division, addition/soustraction."
"Quelle fonction permet de connaître le type d'une valeur en Python ?","La fonction `type()` permet de connaître le type d'une valeur."
"Quels sont les trois premiers types de données vus dans ce cours ?","Les trois premiers types sont : `str` (chaîne de caractères), `int` (entier), et `float` (nombre décimal)."
"Qu'est-ce qu'une variable en Python ?","Une variable est une 'boîte' qui permet de stocker une valeur pour la réutiliser plus tard."
"Quelle convention de nommage utilise-t-on pour les variables en Python ?","On utilise le *snake_case* : des mots en minuscules séparés par des underscores (`_`)."
"Comment déclarer et assigner une variable en Python ?","On écrit le nom de la variable suivi d'un égal et de la valeur, par exemple `ma_variable = 42`."
"Peut-on réassigner une variable avec une valeur d'un autre type en Python ?","Oui, on peut réassigner une variable avec une valeur d'un autre type, par exemple `ma_variable = "Hello World"`."
"Pourquoi ne peut-on pas concaténer directement une chaîne de caractères avec un entier en Python ?","Parce que Python ne permet de concaténer que des chaînes de caractères entre elles (`str` avec `str`)."
"Quelle fonction permet de transformer un entier en chaîne de caractères ?","La fonction `str()` permet de transformer un entier en chaîne de caractères."
"Qu'est-ce que le *casting* en Python ?","Le *casting* est la transformation d'un type de données en un autre, par exemple `int()`, `float()`, ou `str()`."
"Quelle fonction permet de lire une entrée utilisateur en Python ?","La fonction `input()` permet de lire une entrée utilisateur."
"Quel est le type par défaut des valeurs retournées par la fonction `input()` ?","Le type par défaut est `str` (chaîne de caractères)."
"Comment transformer l'entrée utilisateur en entier ?","On utilise la fonction `int()` sur le résultat de `input()`, par exemple `age = int(input("Quel est votre âge ? "))`."
"Quelle est la formule pour convertir des degrés Celsius en Fahrenheit ?","La formule est : $Fahrenheit = Celsius \times \frac{9}{5} + 32$."
"Qu'est-ce qu'un booléen en Python ?","Un booléen est un type de données qui peut prendre deux valeurs : `True` ou `False`."
"Quelles valeurs sont considérées comme *falsy* en Python ?","Les valeurs *falsy* sont : `0`, `0.0`, `""` (chaîne vide), `[]` (liste vide), et `None`."
"Quels sont les six opérateurs de comparaison en Python ?","Les opérateurs sont : `<` (strictement plus petit), `<=` (plus petit ou égal), `>` (strictement plus grand), `>=` (plus grand ou égal), `==` (égal), et `!=` (différent)."
"Quels sont les deux opérateurs logiques en Python ?","Les opérateurs logiques sont `and` (et) et `or` (ou)."
"Quelle structure de contrôle permet d'exécuter du code si une condition est vraie ?","La structure `if` permet d'exécuter du code si une condition est vraie."
"Quels mots-clés complètent la structure `if` pour gérer plusieurs conditions ?","Les mots-clés sont `elif` (sinon si) et `else` (sinon)."
"Qu'est-ce qu'une indentation en Python ?","L'indentation est un décalage (espaces ou tabulations) qui définit les blocs de code dans les structures comme `if`, `for`, ou `while`."
"Qu'est-ce qu'une liste en Python ?","Une liste est un tableau ou ensemble qui peut contenir plusieurs éléments de n'importe quel type."
"Comment déclarer une liste en Python ?","On utilise des crochets, par exemple `ma_liste = [1, 2, 3]`."
"Comment accéder au premier élément d'une liste ?","On utilise l'indice `0`, par exemple `ma_liste[0]`."
"Quelle méthode permet d'ajouter un élément à une liste ?","La méthode `append()` permet d'ajouter un élément à la fin d'une liste."
"Quelle méthode permet de supprimer un élément d'une liste ?","La méthode `remove()` permet de supprimer un élément spécifique d'une liste."
"Qu'est-ce qu'une boucle `while` en Python ?","Une boucle `while` répète un bloc de code tant qu'une condition est vraie."
"Qu'est-ce qu'une boucle `for` en Python ?","Une boucle `for` permet d'itérer sur chaque élément d'un objet itérable (comme une liste ou une chaîne de caractères)."
"Quelle fonction permet de boucler un certain nombre de fois avec une boucle `for` ?","La fonction `range()` permet de boucler un certain nombre de fois."
"Qu'est-ce qu'une fonction en Python ?","Une fonction est un bloc de code réutilisable qui effectue une tâche spécifique."
"Comment déclarer une fonction en Python ?","On utilise le mot-clé `def`, suivi du nom de la fonction et de parenthèses, par exemple `def ma_fonction():`."
"Qu'est-ce qu'un paramètre dans une fonction ?","Un paramètre est une variable passée à une fonction pour être utilisée dans son corps."
"Quelle est la différence entre une variable locale et une variable globale ?","Une variable locale est accessible uniquement dans la fonction où elle est déclarée, tandis qu'une variable globale est accessible dans tout le programme."
"Qu'est-ce qu'un tuple en Python ?","Un tuple est une collection immuable (non modifiable) déclarée avec des parenthèses, par exemple `(1, 2, 3)`."
"Qu'est-ce qu'un set en Python ?","Un set est une collection non ordonnée et sans doublons déclarée avec des accolades, par exemple `{1, 2, 3}`."
"Qu'est-ce qu'un dictionnaire en Python ?","Un dictionnaire est une collection de paires clé-valeur déclarée avec des accolades, par exemple `{"clé": "valeur"}`."
"Qu'est-ce qu'une classe en Python ?","Une classe est un modèle pour créer des objets qui regroupent des données et des fonctions (méthodes)."
"Comment déclarer une classe en Python ?","On utilise le mot-clé `class`, suivi du nom de la classe en *PascalCase*, par exemple `class Voiture:`."
"Qu'est-ce qu'une instance de classe ?","Une instance est un objet créé à partir d'une classe, par exemple `ma_voiture = Voiture()`."
"Quelle méthode spéciale est utilisée comme constructeur dans une classe ?","La méthode `__init__()` est utilisée comme constructeur pour initialiser une instance."
"Que représente le paramètre `self` dans une méthode de classe ?","Le paramètre `self` est une référence à l'instance actuelle de la classe."