01 - Prise en main (enonce).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ee77a711",
   "metadata": {},
   "source": [
    "# Introduction et prise en main"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f88c9aaa",
   "metadata": {},
   "source": [
    "Le but de cette première partie est de prendre en main le langage via des manipulations simples avant d'implémenter quelques fonctions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "424720d6",
   "metadata": {},
   "source": [
    "## Variables et calculs\n",
    "\n",
    "La librairie standard de Python fournit plusieurs types de données élémentaires tel que des entiers (int), des booléens (bool), des nombres à virgule flottante (float) ou des chaines de caractères (string)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ab0d060",
   "metadata": {},
   "source": [
    "### Chaînes de caractères\n",
    "A votre avis, quelle est la sortie de la prochaine cellule ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "799b8f70",
   "metadata": {},
   "outputs": [],
   "source": [
    "age = \"J'ai 20 ans\"\n",
    "age+1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "002dac8d",
   "metadata": {},
   "source": [
    "Comment peut-on inclure le caractère \" dans un chaîne de caractères ?\n",
    "Corrigez la cellule ci-dessous"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "86f41ea9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'On est le \"07/12/2023\"'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "date = 'On est le \"07/12/2023\"'\n",
    "date"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fff4e2ec",
   "metadata": {},
   "source": [
    "### Arithmétique\n",
    "Proposez un calcul simple qui permet de vérifier que l'ordre des opérations mathématiques (+, -, / ...) est respecté sous Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8332b25d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "65dc96fe",
   "metadata": {},
   "source": [
    "On souhaite convertir la hauteur de deux blocs en mètre. Le calcul suivant est erroné, corrigez le."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f312c3fa",
   "metadata": {},
   "outputs": [],
   "source": [
    "bloc_1_en_cm = 50\n",
    "bloc_2_en_cm = 122\n",
    "hauteur_totale_en_m = bloc_1_en_cm + bloc_2_en_cm / 100"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4cde1366",
   "metadata": {},
   "source": [
    "Ajoutez du code à la cellule suivante pour échanger les variables `a` et `b` (de sorte que `a` fasse référence à l'objet précédemment référencé par `b` et vice versa)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "265cbc1d",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 102\n",
    "b = 50\n",
    "###"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "563e911b",
   "metadata": {},
   "source": [
    "Alice, Bob et Carol ont convenu de mettre en commun leurs bonbons d'Halloween et de les partager équitablement entre eux.\n",
    "Pour le bien de leur amitié, tous les bonbons restants seront brisés. Par exemple, s’ils rapportent collectivement à la maison 91 bonbons, ils en prendront 30 chacun et en briseront 1.\n",
    "\n",
    "Écrivez une expression arithmétique ci-dessous pour calculer combien de bonbons ils doivent briser pour une récolte donnée."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c9be60f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "alice_candies = 121\n",
    "bob_candies = 77\n",
    "carol_candies = 109\n",
    "\n",
    "to_smash = ###"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cbb8ac64",
   "metadata": {},
   "source": [
    "🌶️ Vous avez vu lors des TP VBA que la loi dite de Planck, permet d’obtenir de façon analytique les densités de flux spectrales. Elle s’exprime comme :\n",
    "$$\n",
    "\\phi_{\\lambda}^0(T) = \\frac{C_1}{\\lambda^5} \\frac{1}{\\text{exp}\\left(\\frac{C_2}{\\lambda T}\\right)-1}\n",
    "$$\n",
    "\n",
    "Avec $C_1=3.742\\times10^8~W.m^{-2}.\\mu m^4$ et $C_2=14388~\\mu m.K$\n",
    "\n",
    "Implémenter une **fonction** qui calcule $\\phi_{\\lambda}^0(T)$ et qui prend comme arguments $\\lambda$ et $T$.\n",
    "Vous pouvez vous aider de la fonction `math.exp()`\n",
    "\n",
    "Pour éviter d'éventuelles erreurs numériques, la fonction donnera $\\phi_{\\lambda}^0(T)=0$ pour $\\lambda \\times T < 50~\\mu m.K$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "455adc8d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "def planck_law():\n",
    "    ###"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a87352bb",
   "metadata": {},
   "source": [
    "Utiliser la fonction implémentée précédemment pour calculer la densité de flux spéctrale pour $\\lambda=1.5\\mu m$ et $T=1500K$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "853ec690",
   "metadata": {},
   "outputs": [],
   "source": [
    "planck_law(wave_length=1, temp=1500)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3203135b",
   "metadata": {},
   "source": [
    "## Listes, tuples, dictionnaires et boucles\n",
    "\n",
    "Python permet la compréhension de listes nativement. Regardez l'expression Python ci-dessous. Que pensez-vous obtenir lorsque nous l'exécuterons ? Décommentez le code et exécutez la cellule pour voir si vous aviez raison."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0eb0fb66",
   "metadata": {},
   "outputs": [],
   "source": [
    "# [1, 2, 3, 4] > 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce739a97",
   "metadata": {},
   "source": [
    "Compléter la fonction ci-dessous selon la `docstring` déjà spécifiée."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "acb2f0dc",
   "metadata": {},
   "outputs": [],
   "source": [
    "def select_second(liste):\n",
    "    \"\"\"\n",
    "    Return the second element on the given list. If the list has no second element, return None.\n",
    "    \"\"\"\n",
    "    ###"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8780015e",
   "metadata": {},
   "source": [
    "Ecrire une fonction qui renvoie la moyenne de tous les termes d'une liste donnée en argument.\n",
    "\n",
    "Vous proposerez deux implémentations :\n",
    "\n",
    "* La première en utilisant une boucle `for`\n",
    "* La deuxième en utilisant la fonction native `sum()` de Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e5018ecc",
   "metadata": {},
   "outputs": [],
   "source": [
    "def moyenne_with_for(liste):\n",
    "    ###\n",
    "\n",
    "def moyenne_with_sum(liste)\n",
    "    ###"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3d65f34",
   "metadata": {},
   "source": [
    "🌶️ Vous analysez des équipes sportives. Les membres de chaque équipe sont stockés dans un **dictionnaire**. Le nom de l'entraîneur est stocké via la clé `coach`, et ceux des autres joueurs sont stockés dans une **liste** via la clé `players`, sachant que le capitaine est le premier nom de la liste et les autres joueurs sont répertoriés après. Ces dictionnaires sont stockés dans une autre **liste**, qui commence par la meilleure équipe et continue jusqu'à la pire équipe en dernier. \n",
    "\n",
    "Remplissez la fonction ci-dessous pour sélectionner l'entraîneur et le capitaine de la pire équipe. Quel est le `type` de l'objet que retourne la fonction ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "deac1761",
   "metadata": {},
   "outputs": [],
   "source": [
    "def losing_team_coach_and_captain(teams):\n",
    "    \"\"\"\n",
    "    Given a list of teams, where each team is a dictionary of two keys: coach and players. The key players holds a list of names.\n",
    "    Returns the name of the coach, and the captain (1st player) for the last team.\n",
    "    \"\"\"\n",
    "    ###"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6c55e77",
   "metadata": {},
   "source": [
    "# Exercices synthétiques\n",
    "\n",
    "### Chaîne de caractères, le retour"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e85fa279",
   "metadata": {},
   "source": [
    "Ecrire une fonction qui a pour argument une chaîne de caractères et qui retourne un dictionnaire comportant le nombre d'occurrences de chaque caractère.\n",
    "\n",
    "Exemple :\n",
    "\n",
    "```python\n",
    ">>> calcul_occurrences('aAabc__')  \n",
    "    {'a':3, 'b':1, 'c':1, '_':2}\n",
    "```\n",
    "\n",
    "La fonction doit ignorer les majuscules/minuscules ainsi que les espaces. Vous pouvez vous aider des fonctions `replace()`, `lower()` et `count` du module `string` natif de Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "75354aa7",
   "metadata": {},
   "outputs": [],
   "source": [
    "import string\n",
    "\n",
    "def calcul_occurrences(mot):\n",
    "    ####"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9300b4be",
   "metadata": {},
   "outputs": [],
   "source": [
    "calcul_occurrences('aAabc__')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dfe78da2",
   "metadata": {},
   "source": [
    "### Approximation de la racine carrée\n",
    "\n",
    "La suite de Héron est une suite permettant de trouver une valeur approchée d’une racine carrée.\n",
    "\n",
    "On définit la suite $\\left(u_n\\right)_{n \\in \\mathbb{N}}$ définie par son premier terme $u_0 > 0$ et par la relation de récurrence suivante :\n",
    "$$\n",
    "u_{n+1} = \\frac{1}{2} \\left(u_n + \\frac{a}{u_n}\\right)\n",
    "$$\n",
    "\n",
    "Où $a$ est un réel strictement plus grand que 0. On peut démontrer que cette suite converge vers le nombre $\\sqrt{a}$. *Et on peut même montrer que la convergence est quadratique.*\n",
    "\n",
    "Implémenter une fonction python qui prend deux paramètre, le nombre $a$ dont on cherche à approximer la racine à $10^{-p}$ près.\n",
    "\n",
    "La fonction devra retourner la valeur de la racine approximée ainsi que le nombre d'itérations effectuées afin d'atteindre la précision souhaitée."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b74aa7ff",
   "metadata": {},
   "outputs": [],
   "source": [
    "def heron(a, p):\n",
    "    ###"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "871e49cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "heron(2,8) # approximation de racine de 2 à 10^-8 près"
   ]
  }
 ],
 "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}