{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "nbsphinx": "hidden"
   },
   "source": [
    "[prev: Utilisation avancée des chaines de caractères](string-template.ipynb) | [home](../index.ipynb) | [next: Utilisation avancée des indices](indexing-tricks.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Un point sur les méthodes\n",
    "\n",
    "## *Déjà vu*\n",
    "```python\n",
    "ma_liste.append(42)\n",
    "```\n",
    "Cette expression a pour effet d'agrandir `ma_liste` en ajoutant à la fin une case contenant la valeur `42`.  \n",
    "On voit ici que\n",
    "\n",
    "* `ma_liste` est une liste\n",
    "* `ma_liste.append` est une fonction\n",
    "* `ma_liste.append(42)` est l'appel de cette fonction.\n",
    "\n",
    "La fonction s'exécute en connaissant `ma_liste` **et** `42`.\n",
    "\n",
    "## La syntaxe des méthodes\n",
    "\n",
    "La syntaxe générale se présente ainsi:\n",
    "```python\n",
    "mon_objet.nom_methode(argument)\n",
    "```\n",
    "\n",
    "`mon_objet` est un objet quelconque. On y accède le plus souvent par un nom de variable mais parfois aussi directement par une expression littérale.\n",
    "```python\n",
    "# ma_liste est un nom de variable qui désigne un liste\n",
    "ma_liste.extend(des_mots)\n",
    "```\n",
    "```python\n",
    "# \", \" est une expression littérale de string\n",
    "\", \".join(des_mots)\n",
    "```\n",
    "\n",
    "`nom_methode` est un nom, comme un nom de variable. Les noms disponibles dépendent du type de `mon_objet`.\n",
    "```python\n",
    "# python peut vous renseigner sur les méthodes disponibles pour un objet donné\n",
    "dir(mon_objet)\n",
    "help(mon_objet)\n",
    "```\n",
    "\n",
    "`argument` représente les arguments passés à la fonction. Ils suivent les mêmes règles que pour une fonction classique.\n",
    "```python\n",
    "mon_objet.nom_methode(a, b)\n",
    "mon_objet.nom_methode(a, b, option=c)\n",
    "```\n",
    "\n",
    "\n",
    "\n",
    "## Les attributs\n",
    "\n",
    "En vérité, un objet peut abriter derrière le `.` des fonctions (méthodes) mais aussi des valeurs (attributs).  \n",
    "Les attributs disponibles et leurs noms dépendent entièrement du type de l'objet.\n",
    "```python\n",
    "help(mon_objet)\n",
    "```\n",
    "\n",
    "## Conclusion\n",
    "\n",
    "Selon leur type, les objets peuvent exposer derrière le `.` un ou plusieurs attributs et méthodes.  \n",
    "Les noms des méthodes/attributs est fixe pour un type donné.  \n",
    "Il faut se rapporter à la documentation du type de l'objet pour découvrir ce que contient qu'il propose.  \n",
    "\n",
    "Quand une méthode est appelée, elle connait à la fois:\n",
    "\n",
    "* l'objet auquel elle se rattache (à gauche du `.`)\n",
    "* les arguments de la fonction (dans les parenthèses)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercices\n",
    "\n",
    "Découvrir quelques méthodes des types de bases:\n",
    "\n",
    "* `list.append()`\n",
    "* `dict.get()`\n",
    "* `str.split()`"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}