TEST_Python_intro1_variables_fonctions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "frozen": true
   },
   "source": [
    "gtghhnujudvgu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": false
   },
   "source": [
    "# INTRODUCTION AU LANGAGE PYTHON appliqué au programme de 2 BCP: les variables et les fonctions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## LES TYPES DE DONNEES ET LES VARIA    BLES"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Les types de données"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Python** est un langage qui travaille avec des **objets** qui appartiennent à des **classes** .  \n",
    "Pour chaque classe, des *fonctions* ou *méthodes* spécifiques peuvent être utilisées.  \n",
    "Voici les principales classes d'objets mentionnées dans les programmes de BCP :\n",
    "\n",
    "|**Différentes classes d'objets**||\n",
    "|:----|:----|\n",
    "|***int***|c'est la classe des **nombres entiers**|\n",
    "|***float***|c'est la classe des **nombres décimaux**|\n",
    "|***bool***|c'est la classe des **booléens** (True - False)|\n",
    "|***str***|c'est la classe des **chaînes de caractères**|\n",
    "|***list***|c'est la classe des **listes d'objets**|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Les variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une **variable** est une donnée stockée dans la mémoire de l'ordinateur.\n",
    "\n",
    "\n",
    "&#128187; *Exécuter les codes suivants pour afficher les résultats:*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "deletable": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n",
      "34\n",
      "60\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mon_age=30        #La valeur 25 est AFFECTEE à la variable mon_age (mon_age RECOIT la valeur 25)\n",
    "print(mon_age)    #Affiche la valeur de la variable\n",
    "print(mon_age+4)\n",
    "print(mon_age*2)\n",
    "type(mon_age)     #Affiche la classe de la variable\n",
    "\n",
    "#MODIFIER LE CODE AVEC UN AGE DECIMAL et observer les résultats."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 3 15\n",
      "9 5\n"
     ]
    }
   ],
   "source": [
    "#Affectation des variables\n",
    "a=5\n",
    "b=3\n",
    "c=a*b\n",
    "print(a,b,c)\n",
    "\n",
    "d,e=9,5\n",
    "print(d,e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "texte=\"Bonjour les amis !\"    #Une chaine de caractères est définie entre des doubles apostrophes \"\".\n",
    "print(texte)\n",
    "type(texte)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## LES FONCTIONS\n",
    "Une **fonction** permet d'exécuter un certain nombre d'instructions déjà enregistrées."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quelques fonctions très utiles"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|Fonctions|Syntaxes||\n",
    "|:---|:---|:---|\n",
    "|***type***|**type(**nom_de_la_variable**)**|**Renvoie la classe** de la variable.|\n",
    "|***print***|**print(**valeur1, valeur2, ...**)**|**Affiche la valeur** ou les valeurs d'une ou plusieurs variables.|\n",
    "|***input***|**input(**paramètre**)**|**Renvoie l'objet** saisi par l'utilisateur.|\n",
    "|***int<br>float <br>str <br>bool <br>list***|**int(**paramètre**)**<br>**float(**paramètre**)**<br>**str(**paramètre**)**<br>**bool(**paramètre**)**<br>**list(**paramètre**)**<br>|**Convertit la classe** du paramètre (en entier, nombre décimal, chaîne de caractères, booléen, liste).|\n",
    "|***help***|**help(**paramètre**|**Affiche la documentation** ***(docstring)*** du paramètre.|\n",
    "\n",
    "\n",
    "&#128187; *Exemples de codes à exécuter:*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Fonctions input(), print() et type()\n",
    "lycee=input(\"votre lycée:\")               #La variable lycee reçoit la réponse\n",
    "ville=input(\"dans quelle ville?\")      \n",
    "print(\"Mon lycée est\", lycee, \"à\", ville)\n",
    "print(type(lycee))                        #Affiche le type de la variable lycee"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Fonctions input(), print() et int()\n",
    "annee=input(\"votre année de naissance: \") \n",
    "annee+10                                        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**A RETENIR:**  \n",
    "La fonction *input()* renvoie des objets de la classe **str** .   \n",
    "Les messages d'erreur renseignent sur l'erreur (ligne, type, ...). Ici, c'est une erreur de type (**TypeError**).  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "&#128187; *Modifier et exécuter le code précédent pour pouvoir réaliser l'opération: utiliser la fonction int() pour modifier la classe de la variable annee.*  \n",
    "Pour *rafraîchir* un seul code (*JupyterLab*), `clic-droit sur la cellule de code` -> `Clear Outputs`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Programme calculant l'aire d'un rectangle\n",
    "l=input(\"largeur du rectangle:\")\n",
    "L=input(\"longueur du rectangle:\")\n",
    "#changement de classe des variables\n",
    "l=float(l)\n",
    "L=float(L)\n",
    "\n",
    "aire=l*L\n",
    "print(\"L'aire du rectangle est\", aire, \"cm2\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Créations de fonctions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il est souvent intéressant de créer des fonctions pour les utiliser ensuite.  \n",
    "Pour créer une fonction, une syntaxe est :\n",
    "```python\n",
    "       def nom_de_la_fonction(paramètre1, paramètre2, ...) : \n",
    "           #bloc d'intructions\n",
    "```\n",
    "\n",
    "\n",
    "\n",
    "&#128187; *Codes à exécuter:*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Fonction calculant l'aire d'un rectangle\n",
    "def aire_rectangle(l,L):                           #!!! NE PAS OUBLIER LES :     \n",
    "    aire=L*l                                       #!!! RESPECTER LES INDENTATIONS (espacements) DU BLOC d'instructions de la fonction\n",
    "    print(\"L'aire du rectangle est\", aire, \"cm2\")\n",
    "    \n",
    "#Test de la fonction\n",
    "aire_rectangle(5,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Fonction calculant le périmètre d'un rectangle\n",
    "def perimetre(l,L):\n",
    "    return 2*L+2*l\n",
    "\n",
    "#Test de la fonction\n",
    "a=perimetre(5,10)     #La valeur renvoyée par la fonction est affectée à la variable a.\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Importation de fonctions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les fonctions que l'on crée peuvent être sauvegardées dans des fichiers appelés **modules** .  \n",
    "Python stocke dans des **modules** des fonctions et des variables ayant un rapport entre elles.  \n",
    "Il existe un grand nombre de modules Python.  \n",
    "Plusieurs modules sont parfois regroupés dans des ***packages (ou bibilothèques)*** (= dossiers).  \n",
    "*Exemples de modules et bibliothèque utiles:*  \n",
    "\n",
    "|*modules et bibliothèque utiles*||\n",
    "|:----|:----|\n",
    "|***math***|Contient les principales fonctions mathématiques|\n",
    "|***random***|Permet la génération de nombres aléatoires|\n",
    "|***turtle***|La tortue Python, l'équivalent de *Scratch* <br>Permet de tracer des figures géométriques|\n",
    "|***time***|Pour l'heure, la date et chronométrer|\n",
    "|***tkinter***|Permet d'afficher des fenêtres graphiques|\n",
    "|***matplotlib <br>(bibliothèque)***|Bibliothèque destinée à tracer et visualiser des données sous formes de graphiques.|\n",
    "|***numpy <br>(bibliothèque)***|Bibliothèque destinée à manipuler des matrices ou tableaux multidimensionnels <br>ainsi que des fonctions mathématiques opérant sur ces tableaux.|\n",
    "\n",
    "\n",
    "Pour utiliser les fonctions et variables d'un module, il faut **importer** le module.  \n",
    "*Remarque:*  \n",
    "Une opération d'importation *crée un lien* entre votre document de travail et le module appelé qui est déjà sur votre machine. *Ce n'est pas une opération de téléchargement* .  \n",
    "Certaines bibliothèques (comme mathplotlib, numpy, ...) peuvent être absentes de votre machine et nécessitent alors un **téléchargement** par exemple via Internet."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**A RETENIR:**  \n",
    "Pour connaître les fonctions ou variables d'un module ainsi que leurs caractéristiques, penser à utiliser la fonction **help()** dans l'*interpéteur Python* .  \n",
    "\n",
    "|||\n",
    "|:----|:----|\n",
    "|***Pour connaître les fonctions Python présentes <br>nativement dans l'interpéteur (sans importations)***|[https://docs.python.org/3/library/functions.html](https://docs.python.org/3/library/functions.html)|\n",
    "|***Pour connaître les modules Python présents sur votre machine***|help(\"modules\")|\n",
    "|***Informations sur un module***|help(\"nom_du_module\")  <br>help(nom_du_module) si le module est déjà importé|\n",
    "|***Informations sur une fonction d'un module***|help(\"nom_du_module.nom_de_la_fonction\") <br>help(nom_du_module.nom_de_la_fonction) <br>help(nom_de_la_fonction)  si la fonction est déjà importée|\n",
    "\n",
    "\n",
    "Taper `Q` pour quitter l'aide, `espace` pour avancer d'une page, `entrer`pour avancer d'une ligne. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "&#128187; *Exemples de recherches d'informations.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Chercher des informations sur la fonction radian du module math\n",
    "help(\"math.radians\")\n",
    "#Chercher des informations sur le module math par exemple, pour connaître l'ensemble des fonctions du module).!!!L'exécution de cette commande peut être longue...\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Chercher des informations sur le module random\n",
    "\n",
    "#Chercher des informations sur la fonction randint\n",
    "\n",
    "#Chercher des informations sur la fonction random (du module random ...)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "&#128187; *Exemples d'importations de modules et d'utilisations de fonctions:*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Méthode import\n",
    "import math          #Importation du module math\n",
    "a=math.pi            #Appel de la variable pi du module math avec la syntaxe nom_du_module.nom_de_la_fonction\n",
    "b=math.sqrt(19)\n",
    "print(a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Méthode from ... import ...\n",
    "from math import radians   #Importation de la fonction radians du module math\n",
    "radians(180)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Méthode from ... import *\n",
    "from random import *       #Importation de TOUTES les fonctions et variables du module random\n",
    "a=random()\n",
    "b=randint(1,6)\n",
    "print(a,b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## EXERCICES D'APPLICATIONS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Géométrie"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Compléter les fonctions suivantes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def volume_boule(r):                #Fonction renvoyant le volume d'une boule\n",
    "    from math import pi  \n",
    "    return   #Votre code\n",
    "\n",
    "#Test fonction\n",
    "a=volume_boule(10)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cote_carre(A):                  #Fonction renvoyant la longueur du côté d'un carré d'aire A\n",
    "    \n",
    "    #Votre code\n",
    "    #Importer la fonction renvoyant la racine carré d'un nombre\n",
    "    \n",
    "#Test fonction\n",
    "print(cote_carre(100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def diametre_cylindre(h,V):         #Fonction renvoyant le diamètre d'un cylindre connaissant la hauteur h et le volume V\n",
    "    \n",
    "    #Votre code\n",
    "    \n",
    "    \n",
    "#Test fonction\n",
    "print(diametre_cylindre(3,5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculs commerciaux et financiers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Compléter le programme suivant renvoyant le montant d'un intérêt simple.  \n",
    "Exemple:    C0= 1000€; t=5%; n=250 jours --> I &asymp; 34,72€"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "En entrée:\n",
    "C0: capital placé\n",
    "t: taux annuel des intérêts en %\n",
    "n: période du placement en jours\n",
    "En sortie:\n",
    "chaine de caractères présentant les intérêts I\n",
    "\"\"\"\n",
    "\n",
    "C0=float(input(\"capital placé:\"))\n",
    "t=\n",
    "n=\n",
    "\n",
    "I=        \n",
    "\n",
    "print(\"Un capital de\", C0,\"€ placé pendant\", n,\"jours au taux annuel de\", t, \"%, produit\",I,\"€ d'intérêts\")\n",
    "\n",
    "#Remarque: pour arrondir le montant des intérêts aux centimes d'euros, utiliser la fonction round() ...infos avec la fonction help()."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Réaliser un programme calculant le montant net à payer après remise en % pour une facture."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "En entrée:\n",
    "PBHT: prix brut hors taxe en €\n",
    "remise: remise en %\n",
    "En sortie:\n",
    "chaine de caractères présentant le prix net HT (PNHT)\n",
    "\"\"\"\n",
    "\n",
    "#votre code\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fonctions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Créer un programme qui, à partir des données des coordonnées de deux points, renvoie l'équation réduite d'une droite non // à l'axe des ordonnées."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "En entrée:\n",
    "xA\n",
    "yA\n",
    "xB       On suppose xB > xA\n",
    "yB\n",
    "En sortie:\n",
    "chaine de caractères présentant l'équation réduite ou ses paramètres a et b.\n",
    "\"\"\"\n",
    "\n",
    "#Détermination du coefficient a\n",
    "#Votre code\n",
    "\n",
    "#Détermination du coefficient b\n",
    "#Votre code\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Résolution d'un problème du premier degré"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une agence de location de voiture propose la formule suivante: 21€ puis 0,05€/km.  \n",
    "Compléter les fonctions suivantes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prix(x):\n",
    "    \"\"\"\n",
    "    Fonction renvoyant le prix à payer en fonction du nombre de km parcourus\n",
    "\n",
    "    En entrée:\n",
    "    x: nombre de km\n",
    "    En sortie:\n",
    "    y: prix à payer en €\n",
    "    \"\"\"\n",
    "\n",
    "    #votre code\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def nb_km(y):\n",
    "    \"\"\"\n",
    "    Fonction renvoyant le nombre de km à parcourir en fonction du prix en €\n",
    "\n",
    "    En entrée:\n",
    "    y: prix en €\n",
    "    En sortie:\n",
    "    x: nombre de km\n",
    "    \"\"\"\n",
    "\n",
    "    #votre code\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Éditer les Méta-Données",
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}