01_07_Exercices_sur_les_bases_de_python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exo 1 : Devine le nombre"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ecris une fonction nommée `devinette` qui ne prend aucun argument. Quand on l'exécute, elle choisit un nombre aléatoire en 0 et 100 (inclus)et demande à l'utilisateur de deviner ce nombre.A chaque fois que l'utilisateur entre un nombre, le programme affiche l'une de ces phrases : \n",
    "* Trop grand\n",
    "* Trop petit\n",
    "* Exact\n",
    "\n",
    "Si l'utilisateur a choisit correctement, le programme s'arrete. Sinon, le programme demande encore à l'utilisateur de rentrer un nouveau nombre jusqu'à ce qu'il trouve la bonne solution et s'arrête.\n",
    "\n",
    "> Aide : Cherche le module `random` de Python pour générer un nombre aléatoirement.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exo 2: Devine le nombre: Niveau 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reprend ton code pour le programme précédent. Modifie le pour donner seulement 3 chances à l'utilisateur pour deviner le nombre aléatoire choisit. Après 3 tentatives echouées, le programme s'arrête et affiche à l'utilisateur qu'il a épuisé ses chances."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exo 3 : La fonction sum"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En Python, la fonction sum te permet de faire la somme des nombres d'une liste. Par exemple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "34"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nombres = [5,2,6,8,9,4]\n",
    "sum(nombres)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans cet exercice, nous allons réecrire cette fonction mais nous la nommerons `somme`. La fonction somme prend en entrée une liste de nombres et renvoie la somme de ces nombres. Ici, vous n'avez pas le droit d'utiliser la fonction `sum` de Python. Le but de cet exercice est d'apprendre à implémenter une fonction qui existe déjà et gagner en confiance sur nos capacités à faire des choses que d'autres programmeurs plus expérimentés ont déjà fait."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exo 4 : Adresse email de nos employées"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vous êtes chargé d'octroyer les emails des nouveaux employés de votre entreprise. Vous travaillez chez PythonBoss.\n",
    "L'adresse email de vos employés est sous le format `prenom_nom@pythonboss.com`. Vous souhaitez écrire un programme pour automatiser cela. La programme demande à un utilisateur son prenom, puis son nom et affiche son adresse email. Par exemple Kevin Degila aura comme adresse email : kevin_degila@pythonboss.com . Ici vous devrez remarquer que l'adresse email ne contient que des lettres miniscules: C'est la préférence du directeur de PythonBoss. Vous avez intérêt à le satisfaire."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exo 5 : Ordonner une chaine de caractères"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans cet exercice, vous allez écrire une fonction `ordonne_str` qui prend une chaîne de caractères (string) et retourne ce même string mais en l'ordonnant par ordre alphabétique.\n",
    "\n",
    "Par exemple:\n",
    "```python\n",
    "ordonne_str('python')\n",
    "> 'hnopty'\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exo 6 : Le Francais sans Voyelle"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A quoi ressemblerait le Français sans voyelle ? Nous allons écrire une fonction qui prend une chaine de caractères et enlève les voyelles. \n",
    "> Pour rappel, les voyelles en français sont : a e i o u y\n",
    "\n",
    "Par exemple : \n",
    "```python\n",
    "sans_voyelle('python')\n",
    "> 'pthn'\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exo 7 : Des phrases sans Voyelle autre que a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Modifie la précedente fonction pour quelle prenne desormais en entrée une phrase, c'est à dire des mots séparés par des espaces. Il enlève toutes les voyelles sauf la lettre a.\n",
    "Par exemple : \n",
    "```python\n",
    "sans_voyelle('Il fait tres beau ce matin')\n",
    "> 'l fat trs ba c mtn'\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exo 8 : Début et fin des séquences"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En Python, les listes, les tuples et les strings sont des séquences. En Python, on peut écrire une fonction qui prend différents types de variables. Dans cet exercice, nous allons écrire une fonction qui prend en Entrée, une liste, un tuple ou un string et retourne une variable du même type mais avec le premier et le dernier élément de la séquence.\n",
    "\n",
    "```python\n",
    "debut_fin('deopry')\n",
    "> 'dy'\n",
    "\n",
    "debut_fin([5,2,6,9,8])\n",
    "> [5, 8]\n",
    "\n",
    "debut_fin((2,6,8,9))\n",
    "> 2, 9\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exo 9 : Dis moi ton index, je te dirai qui tu es"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans cet exercice, vous allez écrire une fonction qui prend entrée, une liste de nombre et retourne une liste contenant:\n",
    "* La somme des éléments d'index pairs\n",
    "* La somme des éléments d'index impairs\n",
    "\n",
    "```python\n",
    "somme_pair_impair([10,20,30,40,50,60])\n",
    "> [90, 120]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exo 10 : Mot ayant le plus de lettre répétée"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans cet exercice, tu es appélé à écrire une fonction `mot_lettre_repetee` qui prend en entrée, une liste de mots. Pour chaque mot, trouve la lettre qui se répète le plus. La focntion retourne alors le mot ayant une lettre qui se répète le plus de fois (dans ce même mot, bien sûr).\n",
    "\n",
    "```python\n",
    "mot_lettre_repetee([\"On\", \"a\", \"effectuee\", \"plusieurs\", \"tests\", \"elementaire\", \"ce\", \"matin\"])\n",
    "> \"elementaire\"\n",
    "```\n",
    "En cas d'égalité, n'importe quelle option vraie est juste."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exo 11 : Distance entre plusieurs points"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ecrivez une fonction qui prend une liste des nombres et qui retourne une liste qui contient la distance entre les différents nombres successifs.\n",
    "\n",
    "Exemple\n",
    "\n",
    "* input : [65, 54, 59]\n",
    "* output : [11, 5]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exo 12: Lettres successifs et combien d'occurences"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ecrivez une fonction qui prend en input une chaine de caractères contenant des lettres et retourne une liste de tuple qui contient successivement chaque lettre  et le nombre d'occurences successives.\n",
    "Exemple : \n",
    "\n",
    "* input : 'aaaccdaad\"\n",
    "* output : [(a,3), (c, 2), (d, 1), (a,2), (d, 1)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exo 13: Notre restaurant est fermé à cause de la crise du covid, commandez en ligne"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans cet exercice, vous allez écrire le code pour l'application mobile de votre restaurant afin de permettre aux clients de commander en ligne.\n",
    "\n",
    "Vous allez d'abord définir un menu sous forme de dictionnaire. Les clés (chaines de caractères) sont les différents repas ou boissons que vous servez et les valeurs (integers ou float) sont leurs prix correspondants.\n",
    "Une fonction `restaurant` se chargera de demander à l'utilisateur sa commande:\n",
    "* Si la commande existe dans notre menu, le programme affiche son prix et le total actuel de ses commandes, puis lui demande d'entrée une nouvelle commande.\n",
    "* Si la commande n'existe pas dans notre menu, on le dit à l'utilisateur et lui demande de commander autre chose.\n",
    "* Si l'utilisateur appuie Entrée sans rien commander, on lui affiche le prix total de sa commande.\n",
    "\n",
    "Exemple : \n",
    "\n",
    "> Bienvenu dans notre Restaurant\n",
    "* Commande: Burger\n",
    "* Burger coûte 10, total est 10\n",
    "* Commande: cafe\n",
    "* cafe coûte 7, total est 17\n",
    "* Commande: Chicha\n",
    "* Désolé, Nous n'offrons pas de chicha aujourd'hui.\n",
    "* Commande: <entréee>\n",
    "* Votre total est 17"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exo 14: Trop d'escale, c'est fatiguant"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vous êtes dans une agence de voyage pour acheter un billet d'avion. Vous donnez la destination à l'agent qui vous informe, qu'il faudra faire des escales. Il vous dit alors la ville de chaque escale et la duree de chaque escale. Vous décidez d'enregistrer tout cela dans un dictionnaire pour l'afficher plus tard et la somme des heures d'escales.\n",
    "\n",
    "Vous allez écrire un programme qui demande à l'agent la ville (clé) et le nombre d'heure d'escale (valeur). Le programme lui repose la même question jusqu'à ce qu'il dit que c'est fini en appuyant entrée sans rien écrire. A la fin de la saisie, vous affichez les villes et leur nombre d'heures correspondant et le nombre d'heures total d'escale.\n",
    "\n",
    "Exemple:\n",
    "\n",
    "> Python Airlines\n",
    "* Ville: Paris, nb d'heures : 2\n",
    "* Ville: Nairobi, nb d'heures : 1\n",
    "* Ville: Bamako, nb d'heures : 0.5\n",
    "* Ville: Abuja, nb d'heures : 2.5\n",
    "* Ville: <entréee>\n",
    "\n",
    "Liste des escales : \n",
    "\n",
    "Paris 2,\n",
    "\n",
    "Nairobi 1,\n",
    "\n",
    "Bamako 0.5\n",
    "\n",
    "Abuja 2.5\n",
    "\n",
    "* Votre total d'heures d'escales est 6 heures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exo 15: Combien de mots il y a-t-il dans ton fichier ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans cet exercice, vous allez écrire une fonction `wordcount` qui prend en entrée le chemin d'un fichier et affiche les 4 lignes suivantes en sortie:\n",
    "\n",
    "* Le nombre de caractères (les espaces inclus) est ....\n",
    "* Le nombre de mots (séparé par des espaces: 25 est un mot) est .....\n",
    "* Le nombre de lignes est ....\n",
    "* Le nombre de mots distincts (\"Oui\" et \"oui\" sont 2 mots uniques) est .... (taille du vocabulaire du fichier)\n",
    "\n",
    "Un fichier texte nommée `count.txt` se trouve dans le dossier `datasets`. Vous pouvez l'utiliser pour tester votre code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exo 16: Générateur de mots de passe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous allons écrire une fonction `generateur_password` qui nous génère des mots de passe. Cette fonction est un peu particulière car elle retournera une autre fonction `password`. \n",
    "Certains sites n'acceptent que les mots de passe qu'avec des lettres, ou qu'avec des chiffres, ou acceptent des symboles comme @/$ ou simplement un mélange de tout ceci.\n",
    "\n",
    "La fonction `generateur_password` prend en entrée une chaine de caractères contenant les différents caractères possible et retourne la fonction `password` que je peux éxécuter plus tard en lui donnant le nombre de caractères que je veux dans mon mot de passe.\n",
    "\n",
    "Exemple:\n",
    "\n",
    "```python\n",
    "password = generateur_password('Aer5-/')\n",
    "mon_password = password(7)\n",
    "print(mon_password)\n",
    "> 'eA-Ae5/'\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exo 17: Modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans cet exercice, vous allez crée un module python nommée `bootcamp.py` qui contient la logique selon laquelle, un étudiant a reussi cette formation.\n",
    "\n",
    "Ce bootcamp est fait de 4 cours : \n",
    "* Les bases de Python dont le coefficient est 3\n",
    "* Le calcul numérique avec Numpy : 4\n",
    "* Manipulation des données avec Pandas : 7\n",
    "* Visualisation des données avec Matplotlib et Seaborn : 5\n",
    "\n",
    "La moyenne d'un étudiant est la moyenne coefficiée de ses notes. Pour éviter que les étudiants ratent des jours de cours, une pénalité est mise en place pour chaque jour de cours raté. Un minus de 5% est fait sur la moyenne de chaque étudiant pour chaque abscence. Un bonus de 10% de la moyenne est accordé aux étudiants n'ayant raté aucune séance de cours\n",
    "\n",
    "Avant de commencer ce bootcamp, chaque étudiant a donné son niveau en Python sur une échelle de 1 à 5. \n",
    "Pour réussir la formation, vous devrez avoir une moyenne finale de :\n",
    "* 17/20 si votre niveau est 5\n",
    "* 15/20 si votre niveau est 4\n",
    "* 14/20 si votre niveau est 3\n",
    "* 13.5/20 si votre niveau est 2\n",
    "* 12/20 si votre niveau est 1\n",
    "\n",
    "Vous êtes chargé d'écrire la logique de réussite d'un étudiant afin de faciliter la tâche au formateur. Il aimerait entrer les informations de chaque étudiant et obtenir un Oui s'il est admis et Non s'il ne l'est pas. Voici l'exemple pour un étudiant:\n",
    "\n",
    "```python\n",
    "import bootcamp\n",
    "\n",
    "resultat = bootcamp.decision(python=15, numpy=12, pandas=14.6, matplotlib=18, abscence=3, niveau=3)\n",
    "\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exo 18: Programmation orientée objet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Créez une classe Vehicule avec les attributs suivants:\n",
    "* couleur \n",
    "* distance_parcourue (km)\n",
    "* vitesse maximum (km/h)\n",
    "* vitesse actuelle (km/h)\n",
    "\n",
    "On peut donc créer un nouveau véhicule ce cette manière : \n",
    "```python\n",
    "v1 = Vehicule(couleur='bleu', vitesse_maximum='100')\n",
    "``` \n",
    "Ajoutez à la classe Vehicule les méthodes ou fonctionalités suivantes:\n",
    "* accelerer :  augmente la vitesse actuelle  sur une durée(minutes) sans dépasser la vitesse maximum\n",
    "* ralentir : diminue la vitesse sur une durée (minutes)\n",
    "* arreter : elle met à 0 la vitesse actuelle\n",
    "* la fonction `_repr_`  qui permet d'afficher le nombre de distance parcourue et l'état (arrêt, en cours) quand on fait `print(v1)` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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
}