Revision sheet: Introduction aux fonctions en Python

📋 Plan du Cours

1. Définition et syntaxe Python
2. Paramètres formels et effectifs
3. Instruction return et valeurs
4. Visibilité des variables
5. Modification des listes en fonction
6. Différence entre affichage et renvoi
7. Utilisation de plusieurs return
8. Commentaires et docstrings
9. Variables paramètre et argument

📖 1. Définition et syntaxe Python

🔑 Notions clés & Définitions

fonction | | Aucune définition spécifique n’est fournie dans le contenu source, mais il s’agit d’un bloc de code permettant d’effectuer une tâche particulière, défini par la syntaxe suivante.

mot-clé def | | AUTEUR (date) : mot-clé utilisé pour indiquer la déclaration d’une fonction en Python. Il signale le début de la définition d’une nouvelle fonction. La déclaration commence toujours par ce mot-clé, suivi du nom de la fonction et des paramètres formels.

paramètres formels | | Aucune définition spécifique n’est fournie dans le contenu source, mais il s’agit des variables listées entre parenthèses dans l’en-tête de la fonction. Ces paramètres servent à recevoir les valeurs lors de l’appel de la fonction.

📝 Points essentiels

La déclaration d’une fonction en Python commence obligatoirement par le mot-clé def. Après ce mot, il faut indiquer le nom de la fonction, qui doit respecter les règles de nommage en Python, puis ouvrir une parenthèse. À l’intérieur de cette parenthèse, on place les paramètres formels de la fonction, qui peuvent être zéro ou plusieurs. Ces paramètres sont séparés par des virgules si plusieurs sont présents. La déclaration se termine par un deux-points (:), qui indique que le corps de la fonction va suivre. L’ensemble de cette ligne constitue l’en-tête de fonction. Le corps de la fonction doit être indenté par rapport à l’en-tête, c’est-à-dire décalé vers la droite, généralement de quatre espaces ou d’une tabulation. La syntaxe précise est la suivante :

• La déclaration commence par def.
• Ensuite, vient le nom de la fonction, par exemple FunctionName.
• Puis, entre parenthèses, on inscrit les paramètres formels (zéro ou plusieurs).
• La ligne se termine par deux-points (:).
• Le corps de la fonction, c’est-à-dire le code qui sera exécuté lors de l’appel, doit être indenté.

Il est important de noter qu’une fonction peut ne pas avoir de paramètres formels, dans ce cas, les parenthèses sont vides. La flexibilité dans le nombre de paramètres permet de créer des fonctions adaptées à différents besoins.

💡 À retenir

Comprendre la structure syntaxique fondamentale pour définir une fonction en Python consiste à connaître que la déclaration débute par le mot-clé def, suivie du nom de la fonction et d’une liste de paramètres formels entre parenthèses, le tout terminé par deux-points. Le corps de la fonction doit être indenté, ce qui permet de délimiter clairement le bloc de code associé à cette fonction.

📖 2. Paramètres formels et effectifs

🔑 Notions clés & Définitions

• Paramètres formels : voir section 1

Paramètres effectifs : Ce sont les valeurs ou les expressions passées lors de l’appel d’une fonction. Ces valeurs sont assignées aux paramètres formels correspondants. La source indique que « les paramètres figurant entre parenthèses dans l’en-tête d’une fonction se nomment paramètres formels, par opposition aux paramètres fournis lors de l’appel de la fonction qui sont appelés paramètres effectifs » (source). Les paramètres effectifs peuvent être des constantes, des variables ou des expressions, et ils déterminent le comportement spécifique de la fonction lors de son exécution.

Appel de fonction : C’est l’action de déclencher l’exécution d’une fonction en utilisant son nom suivi de parenthèses contenant éventuellement des arguments (ou arguments effectifs). Lors de cet appel, les arguments fournis sont assignés aux paramètres formels de la fonction. La source précise que « les arguments fournis lors de l’appel correspondent aux paramètres effectifs » (source), ce qui établit une relation directe entre les valeurs passées et les variables déclarées dans la fonction.

Arguments : Ce sont les valeurs ou expressions placées entre parenthèses lors de l’appel d’une fonction. Ils correspondent aux paramètres effectifs et sont transmis à la fonction pour qu’elle puisse effectuer ses opérations. La source indique que « les arguments fournis lors de l’appel correspondent aux paramètres effectifs » (source), soulignant leur rôle dans la personnalisation du comportement de la fonction à chaque appel.

📝 Points essentiels

• Les paramètres formels sont ceux définis dans la déclaration de la fonction, entre parenthèses dans l’en-tête. Ils servent de variables locales qui recevront des valeurs lors de l’appel de la fonction. Par exemple, dans la déclaration def somme(a, b):, a et b sont des paramètres formels.

• Les paramètres effectifs sont les valeurs ou expressions passées lors de l’appel de la fonction. Lorsqu’on écrit somme(3, 5), les valeurs 3 et 5 sont des arguments, qui sont assignés respectivement aux paramètres formels a et b.

• Les arguments fournis lors de l’appel de la fonction correspondent directement aux paramètres effectifs. La relation est telle que chaque argument est associé à un paramètre formel dans l’ordre de leur apparition, sauf si des techniques spécifiques comme les arguments nommés sont utilisées.

• Il peut y avoir autant de paramètres formels que souhaité, y compris aucun. La syntaxe permet de définir des fonctions sans paramètres (par exemple, def maFonction():), ou avec plusieurs paramètres selon les besoins.

• Lorsqu’on écrit une fonction, la première ligne précise la liste des paramètres formels. Après avoir saisi cette ligne, on appuie sur « Entrée » pour passer à la ligne suivante, où l’on écrit le corps de la fonction. La fonction s’exécute en utilisant les arguments passés lors de son appel, qui sont assignés aux paramètres effectifs.

• Dès que l’instruction return something est atteinte dans la fonction, celle-ci renvoie l’objet something et cesse immédiatement son exécution. Les lignes de code qui suivent cette instruction ne seront pas exécutées, ce qui est souvent désigné comme du « code mort ».

💡 À retenir

Les paramètres formels sont définis dans la déclaration de la fonction et servent de variables locales, tandis que les paramètres effectifs sont les valeurs passées lors de l’appel de la fonction, lesquelles sont assignées aux paramètres formels. La distinction est essentielle pour comprendre comment une fonction reçoit et utilise les données lors de son exécution.

📖 3. Instruction return et valeurs

🔑 Notions clés & Définitions

instruction return

• AUTEUR : voir section 1

valeur renvoyée
AUTEUR (date) : La valeur renvoyée par une fonction est l’objet ou le résultat que cette fonction transmet à son appelant via l’instruction return. Elle peut être de n’importe quel type de donnée, comme un nombre, une chaîne de caractères, une liste, ou un objet personnalisé.

code mort
AUTEUR (date) : Le code mort désigne l’ensemble des lignes de code qui suivent une instruction return dans une fonction. Ce code n’est jamais exécuté, car l’instruction return interrompt immédiatement la fonction dès qu’elle est rencontrée.

objet None
AUTEUR (date) : En l’absence d’instruction return dans une fonction, celle-ci renvoie par défaut l’objet spécial None. Cela indique qu’aucune valeur spécifique n’a été explicitement renvoyée, souvent utilisé lorsque la fonction effectue une opération sans produire de résultat précis.

📝 Points essentiels

• L’instruction return renvoie un objet et interrompt immédiatement l’exécution de la fonction.
  Lorsqu’une fonction rencontre une instruction return, elle arrête toute exécution en cours et transmet l’objet spécifié à l’appelant. Cela permet de sortir rapidement d’une fonction dès que le résultat souhaité est obtenu, évitant ainsi de poursuivre inutilement le traitement.

• Le code après return est considéré comme code mort et n’est pas exécuté.
  Tout ce qui se trouve après une instruction return dans la même fonction ne sera jamais exécuté. Ce code est dit « mort » car il est inaccessible lors de l’exécution normale, ce qui peut avoir des implications pour la lisibilité et la maintenance du code.

• Si return est absent, la fonction renvoie None par défaut.
  En l’absence d’une instruction return explicite, une fonction ne renverra pas de résultat spécifique. Elle renverra alors l’objet spécial None, indiquant qu’aucune valeur n’a été explicitement définie comme résultat de la fonction.

💡 À retenir

L’instruction return joue un rôle crucial en permettant à une fonction de fournir une sortie précise et de contrôler le flux d’exécution. Sa présence ou absence influence directement la valeur renvoyée par la fonction, ce qui est essentiel pour la gestion des résultats et l’efficacité du code.

📖 4. Visibilité des variables

🔑 Notions clés & Définitions

Variable locale
Une variable locale est une variable définie à l’intérieur d’une fonction. Selon le contenu source, elle est créée lors de l’exécution de cette fonction et n’est visible que dans cette fonction. Elle n’est pas accessible depuis l’extérieur de la fonction, ce qui signifie qu’elle ne peut pas être utilisée ou modifiée en dehors de son contexte d’origine. La variable locale est détruite à la fin de l’exécution de la fonction, libérant ainsi la mémoire qu’elle occupait.

Masquage de variable
Le masquage de variable se produit lorsqu’une variable locale portant le même nom qu’une variable existante en dehors de la fonction (par exemple, une variable globale) est créée à l’intérieur de cette fonction. Pendant l’exécution de la fonction, la variable locale masque temporairement la variable de même nom, rendant cette dernière inaccessible dans ce contexte précis. Une fois la fonction terminée, la variable globale est à nouveau visible et accessible.

Portée de variable
La portée d’une variable désigne l’étendue dans laquelle cette variable est accessible ou visible. Pour une variable locale, cette portée est limitée à la fonction dans laquelle elle a été définie. La portée détermine donc si une variable peut être utilisée ou non dans différentes parties du programme. La variable locale, créée lors de l’exécution, est accessible uniquement durant cette période et dans le contexte de la fonction.

Variable globale
Une variable globale est une variable définie en dehors de toute fonction, accessible depuis n’importe quelle partie du programme, sauf si elle est masquée par une variable locale du même nom. La variable globale existe tout au long de l’exécution du programme, ce qui lui confère une durée de vie prolongée par rapport à une variable locale.

📝 Points essentiels

Les variables définies dans une fonction sont locales et invisibles à l’extérieur. Cela signifie que toute variable créée à l’intérieur d’une fonction ne peut pas être utilisée ou modifiée depuis l’extérieur de cette fonction. La variable locale est créée au moment où la fonction est appelée, lors de l’exécution du code, et elle n’existe que durant cette période. Elle est détruite automatiquement à la fin de l’exécution de la fonction, ce qui libère la mémoire qu’elle occupait.

De plus, si une variable globale existe déjà avant l’appel de la fonction, et qu’une variable locale portant le même nom est créée à l’intérieur de cette fonction, cette dernière masque temporairement la variable globale. Pendant l’exécution de la fonction, toute référence à cette variable avec ce nom correspond à la variable locale, et non à la variable globale. Une fois la fonction terminée, la variable globale redevient visible et accessible.

💡 À retenir

La portée des variables détermine leur accessibilité et leur durée de vie. Les variables locales, créées lors de l’exécution d’une fonction, sont invisibles à l’extérieur et sont détruites à la fin de cette fonction, tandis que les variables globales sont accessibles partout et existent tout au long de l’exécution du programme. Le masquage de variable permet à une variable locale de prendre temporairement le pas sur une variable globale du même nom durant l’exécution de la fonction.

📖 5. Modification des listes en fonction

🔑 Notions clés & Définitions

Objet mutable
Un objet mutable est un objet dont le contenu peut être modifié après sa création. Selon le contenu source, cette notion implique que si une liste (qui est un objet mutable) est modifiée, cette modification affecte directement la liste d’origine. La liste n’est pas copiée ou clonée, mais modifiée en place, ce qui signifie que toute référence à cette liste pointera vers la version modifiée. La mutabilité est une propriété essentielle pour comprendre comment les modifications en place impactent les données lors des appels de fonction.

Modification en place
La modification en place désigne l’action de changer le contenu d’un objet mutable sans créer une nouvelle instance de cet objet. Lorsqu’une liste est modifiée en place, ses éléments sont modifiés, ajoutés ou supprimés directement dans la liste existante. La modification en place a pour conséquence que toutes les références à cette liste voient la version modifiée, ce qui peut entraîner des effets secondaires si cette modification n’est pas intentionnelle.

Copie de liste
Une copie de liste consiste à créer une nouvelle liste qui contient les mêmes éléments que la liste originale, mais qui est indépendante de celle-ci. La copie permet d’éviter que les modifications effectuées sur la nouvelle liste n’affectent la liste initiale. Il existe différentes méthodes pour réaliser une copie, comme la méthode .copy() ou la syntaxe de slicing liste[:]. La copie est essentielle pour préserver l’intégrité de la liste initiale lors de modifications dans une fonction ou un traitement spécifique.

📝 Points essentiels

• Modifier une liste passée en paramètre dans une fonction modifie la liste originale. En effet, comme la liste est un objet mutable, toute modification effectuée en place dans la fonction affecte directement la liste d’origine. Par exemple, si une fonction ajoute ou supprime des éléments d’une liste reçue en paramètre, ces changements seront visibles après l’appel de la fonction, car la liste n’a pas été copiée mais utilisée directement.

• Pour éviter que la liste originale ne soit modifiée lors de l’appel d’une fonction, il est nécessaire de travailler sur une copie de la liste. Cela consiste à créer une nouvelle liste contenant les mêmes éléments que l’original, puis à effectuer les modifications sur cette copie. Ainsi, la liste initiale reste intacte, et les modifications n’ont d’impact que sur la copie. Par exemple, en utilisant liste.copy() ou liste[:], on peut réaliser cette copie.

• Une fonction peut ne pas avoir d’instruction return si elle modifie un objet mutable en place. En effet, la modification de l’objet mutable se fait directement, sans nécessiter de renvoyer une nouvelle liste ou un nouvel objet. La fonction agit alors comme un procédé qui modifie l’état de l’objet reçu en paramètre, ce qui peut suffire pour certains usages.

💡 À retenir

Reconnaître l’impact des objets mutables sur les données lors des appels de fonction est crucial pour éviter des effets secondaires indésirables. En travaillant sur une copie de la liste, on garantit que la liste initiale reste inchangée, permettant ainsi un contrôle précis des modifications et une meilleure gestion des données dans le programme.

📖 6. Différence entre affichage et renvoi

🔑 Notions clés & Définitions

Affichage
L’affichage désigne l’action de présenter une valeur à l’écran pour que l’utilisateur puisse la voir. La commande utilisée pour cela est print(). Selon le contenu source, print() affiche une valeur à l’écran mais ne la renvoie pas, ce qui signifie qu’elle n’est pas disponible pour être utilisée dans d’autres parties du programme après l’affichage. En d’autres termes, l’affichage est une opération de présentation visuelle et non de transmission de données pour un traitement ultérieur.

print()
print() est une fonction qui sert à afficher une valeur ou un message à l’écran. Elle ne modifie pas la valeur d’origine ni ne la stocke dans une variable ; elle se contente de la rendre visible pour l’utilisateur. La valeur affichée par print() n’est pas accessible dans le programme après l’exécution de cette commande, sauf si elle a été préalablement stockée dans une variable ou une autre structure.

Renvoi de valeur
Le renvoi de valeur correspond à la capacité d’une fonction à transmettre une valeur à l’extérieur de son propre contexte d’exécution. La valeur renvoyée peut ensuite être utilisée dans d’autres opérations ou calculs dans le programme. Contrairement à print(), le renvoi de valeur ne concerne pas l’affichage mais la transmission d’une donnée, permettant ainsi une utilisation ultérieure dans le code.

📝 Points essentiels

• print() affiche une valeur à l’écran mais ne la renvoie pas.
  Lorsqu’on utilise print(), la valeur est simplement montrée à l’utilisateur, mais elle n’est pas stockée ou accessible pour d’autres opérations dans le programme. Par exemple, si on écrit print(5 + 3), cela affichera « 8 » à l’écran, mais ne permettra pas d’utiliser directement cette valeur dans une autre instruction.

• Une fonction peut renvoyer une valeur sans l’afficher.
  Il est possible d’écrire une fonction qui calcule ou détermine une valeur et la renvoie à l’appelant sans utiliser print(). Par exemple, une fonction def somme(a, b): return a + b renvoie la somme de deux nombres, mais ne l’affiche pas. La valeur peut alors être stockée dans une variable ou utilisée dans d’autres calculs.

• La valeur renvoyée peut être utilisée ailleurs dans le programme.
  La capacité de renvoyer une valeur permet de faire suivre cette donnée à d’autres parties du code. Par exemple, si une fonction renvoie un résultat, celui-ci peut être affecté à une variable ou intégré dans une expression plus complexe, ce qui n’est pas possible avec une simple commande d’affichage.

💡 À retenir

Il est crucial de distinguer clairement entre montrer une valeur à l’écran et la transmettre pour un usage ultérieur. L’affichage (print()) sert uniquement à la présentation visuelle, tandis que le renvoi de valeur permet de faire circuler des données dans le programme pour des traitements ou calculs ultérieurs.

📖 7. Utilisation de plusieurs return

🔑 Notions clés & Définitions

• Plusieurs instructions return : Il s'agit de plusieurs commandes return présentes dans une même fonction. Chaque instruction return peut potentiellement renvoyer une valeur différente selon la logique du programme. Leur présence permet d'interrompre immédiatement l'exécution de la fonction et de retourner un résultat spécifique à un moment donné.

• Exécution unique de return : Lorsqu'une fonction contient plusieurs instructions return, seule la première rencontrée lors de l'exécution sera effectivement exécutée. Après cette première exécution, la fonction s’arrête, et aucune autre instruction return située après ne sera atteinte ou exécutée.

• Arrêt de fonction : Le fait qu’une instruction return provoque la fin immédiate de l’exécution de la fonction. Dès qu’un return est rencontré, la fonction cesse toute opération en cours et retourne la valeur spécifiée. Cela permet de contrôler précisément le flux d’exécution et d’éviter l’exécution de code supplémentaire inutile.

📝 Points essentiels

• Une fonction peut contenir plusieurs instructions return : Il est possible d’insérer plusieurs commandes return dans une même fonction, chacune pouvant être placée à différents endroits selon la logique souhaitée. Par exemple, dans une fonction qui vérifie des conditions, on peut avoir un return pour chaque cas de figure.

• Seule la première instruction return rencontrée est exécutée : Lorsqu’une fonction s’exécute, elle lit le code dans l’ordre. Si plusieurs instructions return existent, seule celle qui apparaît en premier dans le flux d’exécution sera effectivement exécutée. Les autres return situés après ne seront jamais atteints dans cette exécution.

• Après return, la fonction s’arrête immédiatement : La présence d’un return provoque la fin immédiate de la fonction. Aucune instruction située après ce return ne sera exécutée, même si elles sont dans la même fonction. Cela permet de sortir rapidement d’une fonction dès qu’une condition est remplie ou qu’un résultat est obtenu.

💡 À retenir

Maîtriser l’usage de plusieurs return permet de contrôler précisément le flux d’exécution d’une fonction, en permettant des sorties anticipées selon différentes conditions. Seule la première instruction return rencontrée est exécutée, ce qui garantit une exécution claire et prévisible.

📖 8. Commentaires et docstrings

🔑 Notions clés & Définitions

Commentaire

• AUTEUR : voir section 1

Docstring
AUTEUR (date) : La docstring est une chaîne de caractères entourée de triples guillemets (""" ou ''') placée immédiatement après l’en-tête d’une fonction, d’une classe ou d’un module. Elle sert à décrire de manière claire et structurée ce que fait la fonction ou le module, ses paramètres, ses valeurs de retour, et éventuellement ses exceptions ou effets secondaires. La docstring facilite la documentation automatique et la compréhension du code.

Documentation de fonction
AUTEUR (date) : La documentation de fonction correspond à l’ensemble des informations formelles et informatives qui décrivent la fonction. Elle inclut notamment la description de ce que la fonction réalise, ses paramètres, ses valeurs de retour, et toute autre information utile pour l’utilisateur ou le développeur. Elle est généralement rédigée sous forme de docstring, placée juste après l’en-tête de la fonction.

📝 Points essentiels

• Les commentaires expliquent le code mais ne sont pas exécutés.
  Les commentaires sont des annotations dans le code qui ont pour but d’éclairer le lecteur sur la logique ou les choix effectués par le programmeur. Ils ne sont pas pris en compte lors de l’exécution du programme, ce qui signifie qu’ils n’affectent pas le comportement ou le résultat du code. Leur rôle principal est d’améliorer la lisibilité et la maintenabilité du code, notamment lors de modifications ou de relectures ultérieures.

• Une docstring est une chaîne de caractères triple guillemets décrivant la fonction.
  La docstring doit être placée immédiatement après l’en-tête de la fonction, c’est-à-dire après la ligne de définition (par exemple, def ma_fonction():). Elle doit contenir une description claire et synthétique de ce que la fonction réalise, éventuellement accompagnée d’informations sur ses paramètres, ses valeurs de retour, et ses éventuelles exceptions levées. La forme triple guillemets permet d’écrire une chaîne multi-lignes, facilitant une description détaillée.

• La docstring se place juste après l’en-tête de la fonction.
  Il est essentiel de respecter cette position pour que la documentation soit reconnue et exploitée par des outils automatiques ou par d’autres développeurs. La cohérence dans la rédaction et la position des docstrings contribue à une documentation claire et facilement accessible, ce qui facilite la compréhension et l’utilisation des fonctions dans un projet.

💡 À retenir

Une documentation claire et structurée, notamment via des commentaires et des docstrings, est essentielle pour rendre le code compréhensible et facilement maintenable. La bonne pratique consiste à commenter le code pour expliquer sa logique et à utiliser des docstrings pour décrire précisément chaque fonction, ce qui facilite la compréhension et l’utilisation du code par tous les développeurs.

📖 9. Variables paramètre et argument

🔑 Notions clés & Définitions

Paramètre
Le paramètre est une variable déclarée dans la définition d’une fonction. Il sert à recevoir une valeur lors de l’appel de cette fonction, permettant ainsi de transmettre des données à la fonction pour qu’elle puisse les utiliser dans son traitement. Selon le contenu source, lors de la définition d’une fonction, les variables placées entre parenthèses dans l’entête de la fonction sont appelées paramètres. Par exemple, dans la définition suivante :

def addition(a, b):
    return a + b

les variables a et b sont des paramètres. Ces paramètres agissent comme des variables locales à la fonction, dont la valeur sera déterminée lors de l’appel.

Argument
L’argument correspond à la valeur ou à l’expression passée lors de l’appel d’une fonction, destinée à être assignée à un ou plusieurs paramètres. Lorsqu’on appelle une fonction, on écrit entre parenthèses après son nom des arguments qui seront transmis à la fonction. Par exemple, dans l’appel :

addition(3, 5)

les valeurs 3 et 5 sont les arguments. Ces arguments peuvent être des valeurs littérales, des variables ou des expressions, et ils sont utilisés pour alimenter la fonction en données concrètes.

Appel de fonction
L’appel de fonction est l’instruction qui permet d’exécuter une fonction définie précédemment. Lors de cet appel, on fournit des arguments correspondant aux paramètres attendus par la fonction. La correspondance entre chaque paramètre et son argument est essentielle pour que la fonction fonctionne correctement. Par exemple, dans l’appel addition(3, 5), la valeur 3 est assignée au paramètre a et la valeur 5 au paramètre b. La relation entre paramètres et arguments doit être respectée pour assurer le bon fonctionnement de la fonction.

📝 Points essentiels

• Les variables entre parenthèses lors de la définition sont les paramètres. Ces paramètres jouent un rôle de variables locales à la fonction, permettant de recevoir des valeurs lors de l’appel. La définition précise des paramètres dans l’entête de la fonction est cruciale pour son fonctionnement, car elle indique quels types de données la fonction attend.

• Les valeurs passées lors de l’appel sont les arguments. Ces arguments sont les données concrètes que l’on fournit à la fonction pour qu’elle puisse effectuer ses opérations. La syntaxe de l’appel doit respecter l’ordre et le nombre de paramètres attendus par la fonction.

• La correspondance paramètre-argument est essentielle au fonctionnement. Elle garantit que chaque paramètre reçoit la bonne valeur, ce qui est fondamental pour que la fonction produise le résultat attendu. Une erreur dans cette correspondance peut entraîner des comportements inattendus ou des erreurs d’exécution.

💡 À retenir

Le rôle distinct des paramètres et arguments est fondamental : les paramètres définissent ce que la fonction attend comme données d’entrée, tandis que les arguments sont les valeurs concrètes transmises lors de l’appel pour alimenter ces paramètres. La bonne correspondance entre eux est essentielle pour le bon fonctionnement de la fonction.

📊 Tableaux de Synthèse

Critère	Fonction	Paramètres formels	Paramètres effectifs	Auteur / Source
Définition	Bloc de code pour effectuer une tâche	Variables déclarées dans la déclaration	Valeurs passées lors de l’appel	Source
Syntaxe	def nomFonction(param1, ...):	Variables dans l’en-tête	Arguments lors de l’appel	Source
Rôle	Encapsuler un traitement	Reçoit des données	Transmet des données à la fonction	Source
Nombre de paramètres	Zéro ou plusieurs	Correspond à la liste dans la déclaration	Correspond aux arguments fournis	Source

Critère	Instruction return	Valeur renvoyée	Code mort	Auteur / Source
Fonction	Interrompt la fonction et renvoie un objet	Objet ou résultat transmis	Lignes après return non exécutées	Source
Valeur par défaut	None si pas d’instruction return	Objet None si aucune valeur renvoyée	Code après return considéré comme mort	Source
Utilité	Obtenir un résultat ou interrompre la fonction	Résultat calculé ou transmis	N/A	Source

⚠️ Pièges & Confusions Fréquentes

1. Oublier que la déclaration d’une fonction doit commencer par le mot-clé def.
2. Confondre paramètres formels (définis dans la fonction) et paramètres effectifs (valeurs passées lors de l’appel).
3. Ignorer que le corps de la fonction doit être indenté, sinon erreur de syntaxe.
4. Ne pas comprendre que l’instruction return interrompt immédiatement la fonction.
5. Oublier que tout code après un return n’est jamais exécuté (code mort).
6. Confondre valeur renvoyée et affichage à l’écran : return ne fait pas d’affichage.
7. Ne pas maîtriser la différence entre affichage (print) et renvoi (return).

✅ Checklist Examen

• Connaître la syntaxe correcte pour définir une fonction en Python avec le mot-clé def.
• Savoir distinguer entre paramètres formels (définis dans la déclaration) et paramètres effectifs (passés lors de l’appel).
• Comprendre le rôle et le fonctionnement de l’instruction return dans une fonction.
• Savoir que le code après un return est considéré comme code mort et ne sera jamais exécuté.
• Être capable d’écrire une fonction sans paramètres, avec plusieurs paramètres, ou avec un seul paramètre.
• Maîtriser la différence entre affichage (utilisation de print) et renvoi (utilisation de return).
• Connaître la syntaxe pour écrire des commentaires et des docstrings dans une fonction.
• Savoir comment utiliser plusieurs instructions return dans une même fonction.
• Comprendre la différence entre variables paramètre (dans la déclaration) et argument (valeur passée lors de l’appel).
• Connaître les notions clés : fonction, mot-clé def, paramètres formels, paramètres effectifs, arguments, instruction return, code mort, objet None.
• Maîtriser la syntaxe pour indiquer une fonction sans paramètres (parenthèses vides).
• Savoir que l’absence d’return dans une fonction entraîne le renvoi implicite de None.