diff --git a/EXERCICES_S2/TP1_nombre.ipynb b/EXERCICES_S2/TP1_nombre.ipynb new file mode 100644 index 000000000..8d3995fef --- /dev/null +++ b/EXERCICES_S2/TP1_nombre.ipynb @@ -0,0 +1,381 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# TD1 Représentation de nombres" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Exercice sur papier:\n", + "\n", + "1. Convertir en binaire le nombre 115 (division successive par 2).\n", + "2. Donner la représentation de -115 en complément à 2 sur 8 bits.\n", + "3. Donner la représentation de 12,625 comme un flottant. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "On représente un entier en binaire par une liste de 0 et de 1. Donner une fonction `conversionBase2(nombre)`\n", + "qui transforme un entier en sa représentation binaire. Attention, les bits sont calculés dans l'ordre inverse\n", + "(little endian), il faudra sans doute renverser la liste avec la méthode `.reverse()`." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['1', '1', '1', '0', '0', '1', '1']" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def conversionBase2(nombre):\n", + " if(nombre==0):\n", + " return [0]\n", + " res = []\n", + " while nombre!=0:\n", + " if nombre%2==1:\n", + " res.append(\"1\")\n", + " elif nombre%2==0:\n", + " res.append(\"0\")\n", + " nombre=nombre//2\n", + " res.reverse()\n", + " return res\n", + " \n", + "conversionBase2(115)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Faire une fonction d'affichage d'une liste représentant un nombre en binaire. Pour afficher avec `print` sans passer à la ligne il faut utiliser l'argument optionnel end=\"\"." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1110011" + ] + } + ], + "source": [ + "def afficheBase(liste):\n", + " for i in liste:\n", + " print(i,end=\"\")\n", + "\n", + "afficheBase(conversionBase2(115))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Convertir un nombre dans n'importe quelle base b (représentée comme une liste des chiffres dans cette base).\n", + "Que faut-il changer dans `conversionBase2` pour gérer n'importe quelle base ?" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['1', '1', '1', '0', '0', '1', '1']\n" + ] + }, + { + "data": { + "text/plain": [ + "['1', '1', '0', '2', '1']" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def conversionBase(nombre,b):\n", + " if(nombre==0):\n", + " return [0]\n", + " res = []\n", + " while nombre!=0:\n", + " if nombre%b==0:\n", + " res.append(\"0\")\n", + " elif nombre%b!=0:\n", + " res.append(str(nombre%b))\n", + " nombre=nombre//b\n", + " res.reverse()\n", + " return res\n", + "\n", + "print(conversionBase(115,2))\n", + "conversionBase(115,3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Quels sont les nombres entiers qu'on peut écrire avec n chiffres en base b ?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Écrire une fonction d'affichage pour un nombre en Hexadécimal (en base 16).\n", + "On rappelle que 10 doit être représenté par A, 11 par B ..." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "22B8\n" + ] + } + ], + "source": [ + "def afficheBaseHexa(liste):\n", + " lettres=[\"A\",\"B\",\"C\",\"D\",\"E\",\"F\"]\n", + " for v in liste:\n", + " if int(v)<10:\n", + " print(v,end=\"\")\n", + " else:\n", + " print(lettres[int(v)%10],end=\"\")\n", + " print()\n", + " \n", + "\n", + " \n", + "\n", + "afficheBaseHexa(conversionBase(8888,16))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Donner la valeur de $(1001101)_2$ (dans la représentation traditionnelle en base 10).\n", + "Écrire une fonction qui transforme la représentation en base b d'un entier en cet entier." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "115\n", + "77\n" + ] + } + ], + "source": [ + "\n", + "def conversionEntier(liste,b):\n", + " res = 0\n", + " for i in range (len(liste)):\n", + " res+=int(liste[-i-1])*b**i\n", + "\n", + " return res\n", + "\n", + "\n", + "\n", + "test = conversionBase(115,2)\n", + "print(conversionEntier(test,2))\n", + "\n", + "print(conversionEntier([\"1\",\"0\",\"0\",\"1\",\"1\",\"0\",\"1\"],2))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Additioner $(10001101)_2$ et $(10111001)_2$ à la main. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "On a `l` un nombre en base b et on veut l'écrire sur n chiffres (en ajoutant des 0 devant). Donner une fonction pour réaliser cette transformation." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[0, 0, 0, '1', '1', '1', '0', '0', '1', '1']" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def etendreEcriture(l,n):\n", + " if n len(l2)):\n", + " l2 = etendreEcriture(l2,len(l1))\n", + " else:\n", + " l1 = etendreEcriture(l1,len(l2))\n", + " res = []\n", + " ret=0\n", + " for i in range(len(l2)-1,-1,-1):\n", + " somme=l2[i]+l1[i]+ret\n", + "\n", + " res.insert(0,somme%b)\n", + " \n", + " \n", + "\n", + " return res\n", + "\n", + "test1 = conversionBase(7,2)\n", + "test2 = conversionBase(18,2)\n", + "\n", + "addition(test1,test2,2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "La multiplication Égyptienne est basée sur la propriété suivante:\n", + "* si x est pair, x*y = (x/2)*(y*2)\n", + "* si x est impair, x*y = (x/2)*(y*2) + y\n", + "\n", + "Implémenter la multiplication et la division par 2 d'un nombre en binaire. \n", + "S'en servir pour implémenter la multiplication Égyptienne en base 2. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def division2(l):\n", + " l.pop()\n", + " return l\n", + "\n", + "def multiplication2(l):\n", + " l.append(0)\n", + " return l\n", + " \n", + " \n", + "def est_pair(l):\n", + " return l[-1] == 0\n", + " \n", + "\n", + "def est_zero(l):\n", + " for e in l:\n", + " if e:\n", + " return False\n", + " return True\n", + " \n", + "\n", + "def multiplication_egyptienne(l1,l2):\n", + " if l1%2==0:\n", + " return(l1/2)*(l2*2)\n", + " elif l1%2!=0:\n", + " return(l1/2)*(l2*2)+l2\n", + " \n", + "\n", + "\n", + "test1 = conversionBase(15,2)\n", + "test2 = conversionBase(6,2)\n", + "multiplication_egyptienne(test1,test2) " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "base", + "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.11.4" + }, + "vscode": { + "interpreter": { + "hash": "e5f921d2cbc40cc05b5a24db6ba0e6b62c33b50cc3ec097b0c624e897b5a9797" + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/EXERCICES_S2/TP2_Tkinter.ipynb b/EXERCICES_S2/TP2_Tkinter.ipynb new file mode 100644 index 000000000..4b4db0b2f --- /dev/null +++ b/EXERCICES_S2/TP2_Tkinter.ipynb @@ -0,0 +1,325 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Commencer par importer 'tkinter' et les librairies nécessaires à l'aide des commandes suivantes :" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import tkinter as tk\n", + "import PIL as pil\n", + "from PIL import Image\n", + "from PIL import ImageTk \n", + "from tkinter import filedialog\n", + "from tkinter import simpledialog" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vous pouvez consulter la documentation de tkinter https://docs.python.org/fr/3/library/tk.html et une documentation en français http://tkinter.fdex.eu/.\n", + "Créer une fenêtre tkinter qui a pour titre \"J'apprends Tkinter\" et qui affiche le texte \"J'adore Python !\" dans la fenêtre" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import tkinter as tk\n", + "\n", + "root=tk.Tk()\n", + "root.geometry(\"500x500\")\n", + "root.title(\"J'apprends Tkinter\")\n", + "label= tk.Label(root, text=\"J'adore Python !\", font=('Arial',18))\n", + "label.pack(padx=20, pady=20)\n", + "root.mainloop()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Toujours dans la même fenêtre, ajouter maintenant un bouton permettant de quitter la fenêtre, il faudra pour cela \n", + "créer une fonction callback `fermer_fenetre` qui appelle la méthode `destroy()`" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import tkinter as tk\n", + "def fermer_fenetre():\n", + " return root.destroy\n", + "\n", + "\n", + "root=tk.Tk()\n", + "root.geometry(\"500x500\")\n", + "root.title(\"J'apprends Tkinter\")\n", + "label= tk.Label(root, text=\"J'adore Python !\", font=('Arial',18))\n", + "label.pack(padx=20, pady=20)\n", + "button1= tk.Button(root, text=\"Click ici!\", command=fermer_fenetre())\n", + "button1.pack(padx=50 , pady=50)\n", + "root.mainloop()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Maintenant nous allons modifier la disposition des différents éléments en utilisant une grille pour positionner les éléments dans la fenêtre. Ajouter un canevas rouge à droite du label et du bouton." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "#Faire un canevas de taile 300x300 pour que ce soit lisible\n", + "import tkinter as tk\n", + "def fermer_fenetre():\n", + " return root.destroy\n", + "\n", + "\n", + "root=tk.Tk()\n", + "root.geometry(\"300x300\")\n", + "root.title(\"J'apprends Tkinter\")\n", + "label= tk.Label(root, text=\"J'adore Python !\", font=('Arial',18))\n", + "label.pack(padx=20, pady=20)\n", + "\n", + "buttonfenetre=tk.Frame(root)\n", + "button1= tk.Button(buttonfenetre, text=\"Click ici!\", command=fermer_fenetre())\n", + "button1.grid(row=0 , column=0 , sticky=\"we\")\n", + "canevas1=tk.Canvas(buttonfenetre, background=\"red\", width=50 , height=50)\n", + "canevas1.grid(row=0 , column=1, sticky=\"we\" )\n", + "buttonfenetre.pack()\n", + "\n", + "root.mainloop()\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ajouter un canevas noir en dessous du canevas rouge précédent. Faire une fonction qui permet de compter le nombre de clics sur le carré rouge. Afficher cette valeur dans le label qui servait à afficher \"j'adore python\". Attention, le compteur du nombre de clics est appelé dans une fonction callback, il faut donc le récupérer en dehors de cette fonction en le déclarant comme variable globale. Utiliser la méthode `bind` pour récupérer le clic de souris." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "#Faire un canevas de taile 300x300 pour que ce soit lisible\n", + "import tkinter as tk\n", + "def fermer_fenetre():\n", + " return root.destroy\n", + "cnt = 0\n", + "def countclick(event):\n", + " global cnt\n", + " cnt+=1\n", + " label.configure(text=\"J'adore Python ! \" +str(cnt))\n", + "\n", + "root=tk.Tk()\n", + "root.geometry(\"300x300\")\n", + "root.title(\"J'apprends Tkinter \")\n", + "label= tk.Label(root, text=\"J'adore Python ! \" +str(cnt), font=('Arial',18))\n", + "label.pack(padx=20, pady=20)\n", + "\n", + "buttonfenetre=tk.Frame(root)\n", + "button1= tk.Button(buttonfenetre, text=\"Click ici!\", command=fermer_fenetre())\n", + "button1.grid(row=0 , column=0 , sticky=\"we\")\n", + "canevasR=tk.Canvas(buttonfenetre, background=\"red\", width=50 , height=50)\n", + "canevasR.grid(row=0 , column=1, sticky=\"we\")\n", + "buttonfenetre.pack()\n", + "canevasN=tk.Canvas(buttonfenetre, background=\"black\", width=50, height=50)\n", + "canevasN.grid(row=1 , column=1, sticky=\"n\")\n", + "canevasR.bind('', countclick)\n", + "root.mainloop()\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Créer une unique fonction qui renvoie la couleur du canevas sur lequel on a double-cliqué.\n", + "Afficher la couleur à la place du compteur précédent." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "#Faire un canevas de taile 300x300 pour que ce soit lisible\n", + "import tkinter as tk\n", + "def fermer_fenetre():\n", + " return root.destroy\n", + "\n", + "\n", + "cnt = 0\n", + "def givecouleurR(event):\n", + " label.configure(text=\"C'est du rouge!\")\n", + " \n", + "def givecouleurN(event):\n", + " label.configure(text=\"C'est du noir!\")\n", + "\n", + "root=tk.Tk()\n", + "root.geometry(\"300x300\")\n", + "root.title(\"J'apprends Tkinter \")\n", + "label= tk.Label(root, text=\"J'adore Python ! \", font=('Arial',18))\n", + "label.pack(padx=20, pady=20)\n", + "\n", + "buttonfenetre=tk.Frame(root)\n", + "button1= tk.Button(buttonfenetre, text=\"Click ici!\", command=fermer_fenetre())\n", + "button1.grid(row=0 , column=0 , sticky=\"we\")\n", + "canevasR=tk.Canvas(buttonfenetre, background=\"red\", width=50 , height=50)\n", + "canevasR.grid(row=0 , column=1, sticky=\"we\")\n", + "buttonfenetre.pack()\n", + "canevasN=tk.Canvas(buttonfenetre, background=\"black\", width=50, height=50)\n", + "canevasN.grid(row=1 , column=1, sticky=\"n\")\n", + "\n", + "canevasR.bind('', givecouleurR)\n", + "canevasN.bind('', givecouleurN)\n", + "root.mainloop()\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "REMARQUE : Attention à ne pas mettre deux `bind` différents qui se déclenchent \n", + "sur une même action sinon seul le dernier sera réalisé.\n", + "En effet, la variable `event` va être modifiée deux fois et seule sa dernière modification sera donc prise en compte." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Créer une nouvelle fenêtre qui permet de charger une image depuis un fichier en utilisant la fonction `charger(widg)`. \n", + "Vous allez devoir passer un paramètre dans la fonction callback `charger`. On ne demande pas de comprendre le fonctionnement de la fonction `charger`." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "pyimage3\n" + ] + } + ], + "source": [ + "create=True\n", + "\n", + "def charger(widg):\n", + " global create\n", + " global photo\n", + " global img\n", + " global canvas\n", + " filename= filedialog.askopenfile(mode='rb', title='Choose a file')\n", + " img = pil.Image.open(filename)\n", + " photo = ImageTk.PhotoImage(img)\n", + " print(photo)\n", + " if create: \n", + " canvas = tk.Canvas(widg, width = img.size[0], height = img.size[1])\n", + " canvas.create_image(0,0,anchor = tk.NW, image=photo)\n", + " canvas.pack()\n", + " create=False\n", + " \n", + " else:\n", + " canvas.pack_forget()\n", + " canvas = tk.Canvas(widg, width = img.size[0], height = img.size[1])\n", + " canvas.create_image(0,0,anchor = tk.NW, image=photo)\n", + " canvas.pack()\n", + "root=tk.Tk()\n", + "root.title('Image')\n", + "img= charger(root)\n", + "root.mainloop()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Faire une fenêtre qui :\n", + "- Permet d'écrire dans une zone de texte\n", + "- contient un label d'affichage\n", + "- contient deux boutons, respectivement \"Bouton1\" et \"Bouton2\" permettant d'afficher dans le label le numéro du bouton sur lequel on a cliqué\n", + "- contient un dernier bouton qui permet d'afficher dans le label le texte tapé dans la zone de texte" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "root=tk.Tk()\n", + "root.title(\"ooooh baby, i feel right, music sound sbetter with you\")\n", + "root.geometry(\"500x500\")\n", + "Script=tk.Text(root,height=5, font=(\"Arial\",18))\n", + "Script.pack()\n", + "label= tk.Label(root, text=\"label d'affichage askip\")\n", + "label.pack() \n", + "def afficher1():\n", + " label.configure(text=\"boutton 1 clické !\")\n", + "def afficher2():\n", + " label.configure(text=\"boutton 2 clické !\")\n", + "bouton1=tk.Button(root,text=\"boutton1\",command=afficher1)\n", + "bouton2=tk.Button(root,text=\"boutton2\",command=afficher2)\n", + "bouton1.pack()\n", + "bouton2.pack()\n", + "def montrertext():\n", + " label.configure(text=Script.get(\"1.0\",\"end\"))\n", + "bouttonshow= tk.Button(root, text=\"Show\", command=montrertext)\n", + "bouttonshow.pack()\n", + "root.mainloop()" + ] + } + ], + "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.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/EXERCICES_S2/TP3/TP3_Image.ipynb b/EXERCICES_S2/TP3/TP3_Image.ipynb new file mode 100644 index 000000000..51e0d3055 --- /dev/null +++ b/EXERCICES_S2/TP3/TP3_Image.ipynb @@ -0,0 +1,333 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Questions de cours \n", + "\n", + "1.Qu'est-ce qu'un pixel ?\n", + "\n", + "2.Quel format de stockage utilise-t-on pour stocker un pixel ?\n", + "\n", + "3.Donner la suite de 0 et de 1 permettant de stocker une image de 2 fois 2 qui part du noir en haut à gauche\n", + "et devient plus rouge en allant à doite et plus bleu en allant vers le bas." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Matrices" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Créer une matrice avec 3 lignes et 4 colonnes" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#définir la matrice sans utiliser de boucles comme une liste de liste\n", + "mat_liste = []\n", + "\n", + "#définir la matrice comme un numpy array à deux dimensions\n", + "import numpy as np\n", + "mat_numpy = [] " + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Afficher le nombre de lignes et de colonnes de `mat_liste` et de `mat_numpy`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Remplir `mat_numpy` de 9 en utilisant deux boucles sur les index de la matrice." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def rempli9(matrice):\n", + " pass\n", + "\n", + "rempli9(mat_numpy)\n", + "print(mat_numpy)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Maintenant, remplir la matrice de 8 en utilisant les fonctions spécifiques de numpy, sans faire de boucle. Consulter la documentation de numpy pour trouver une solution." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def rempli8(matrice):\n", + " pass\n", + "\n", + "rempli8(mat_numpy)\n", + "print(mat_numpy)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Créer une liste de taille 50 qui ne contient que des 3, en utilisant la compréhension de liste.\n", + "Créer ensuite une matrice comme liste de listes dont la première ligne contient des 1, la deuxième des 2 ..." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Matrice de Pixels" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "On va importer la librairie PIL pour charger et afficher des images. On importe aussi tkinter pour l'interface d'ouverture de fichier." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import PIL as pil\n", + "from PIL import Image\n", + "from PIL import ImageTk " + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "La fonction `save` permet de stocker la matrice de pixels passée en paramètre `matPix` dans un fichier spécifié par `filename`.\n", + "La fonction `load` renvoie la matrice représentant l'image stockée dans le fichier `filename`. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def save(matPix, filename):\n", + " Image.fromarray(matPix).save(filename)\n", + "\n", + "def load(filename):\n", + " return np.array(pil.Image.open(filename))\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Créer une matrice de pixels de taille 100x100 ainsi qu'une fonction qui met à vert les pixels de la moitié gauche de l'image et à bleu les pixels de moitié droite.\n", + "Afin de visualiser l'image obtenue, on utilisera la fonction `save` et on ouvrira le fichier ainsi généré. On utilisera ensuite la méthode show de PIL." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#definir une nouvelle matrice 100x100\n", + "matVB= np.empty((100,100,3),dtype=np.uint8)\n", + "\n", + "#utiliser une double boucle\n", + "def rempliVB(matrice):\n", + " pass\n", + "\n", + "#alternativement, utiliser les slices de numpy\n", + "\n", + " \n", + "rempliVB(matVB)\n", + "save(matVB,\"vertbleu.png\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "En vous servant de la fonction `load`, calculer le nombre de pixels dans une image `.bmp` de votre choix, puis calculer la taille de l'image en octets. Comparer avec la taille donnée par votre machine." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mat=load(\"test.bmp\")\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Modifier l'image que vous avez créé précédemment en ajoutant un rectangle noir au milieu de l'image." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "matrice=load(\"vertbleu.png\")\n", + "\n", + "def ajouteCarreNoir(mat):\n", + " pass\n", + "\n", + "ajouteCarreNoir(matrice)\n", + "save(matrice,\"vertbleumodif.png\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "De la même manière ajouter un filtre qui ne conserve que la composante verte d'une image." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "matrice=load(\"cheetah.png\")\n", + "\n", + "#avec une boucle\n", + "def filtre_vert(mat):\n", + " pass\n", + "\n", + "#avec les slices de numpy\n", + "\n", + "\n", + "filtre_vert(matrice)\n", + "save(matrice,\"filtre.png\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Créer une méthode qui permet d'afficher le négatif de l'image (on inverse la luminosité)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "matrice=load(\"cheetah.png\")\n", + "\n", + "def negatif(mat): \n", + " pass\n", + "\n", + "negatif(matrice)\n", + "save(matrice,\"negatif.png\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Créer une méthode qui permet d'afficher le symétrique de l'image par rapport à la droite verticale en son milieu." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "matrice=load(\"cheetah.png\")\n", + "\n", + "def symetrique(mat): \n", + " pass\n", + "\n", + "save(symetrique(matrice),\"sym.png\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "base", + "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.8.16" + }, + "vscode": { + "interpreter": { + "hash": "e5f921d2cbc40cc05b5a24db6ba0e6b62c33b50cc3ec097b0c624e897b5a9797" + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/EXERCICES_S2/TP3/cheetah.png b/EXERCICES_S2/TP3/cheetah.png new file mode 100644 index 000000000..91706ebdd Binary files /dev/null and b/EXERCICES_S2/TP3/cheetah.png differ diff --git a/EXERCICES_S2/TP3/test.bmp b/EXERCICES_S2/TP3/test.bmp new file mode 100644 index 000000000..a4a6f68d2 Binary files /dev/null and b/EXERCICES_S2/TP3/test.bmp differ diff --git a/EXERCICES_S2/TP7_crypto.ipynb b/EXERCICES_S2/TP7_crypto.ipynb new file mode 100644 index 000000000..07f8ae18a --- /dev/null +++ b/EXERCICES_S2/TP7_crypto.ipynb @@ -0,0 +1,356 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Cryptographie\n", + "\n", + "Nous allons programmer une interface pour chiffrer et déchiffrer un message à partir d'une clé secrète.\n", + "Vous commencerez par créer l'interface graphique suivante : deux zones de saisies de texte `Entry`, pour récupérer\n", + "le message à chiffrer et la clé, deux boutons pour chiffrer et déchiffrer et une zone de saisie pour afficher le résultat (et pouvoir copier le résultat). " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import tkinter as tk\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1. Créer une fonction `decalage(lettre_message,lettre_cle)` qui prend en argument deux caractères ASCII (en python chaine de caractères d'une lettre) et qui renvoie le décalage de la première lettre par la seconde. On rapelle que la fonction `ord(caractere)` donne le code (entier) de `caractere` et que la fonction `chr(code)` qui transforme le code en le caractère correspondant. Les codes ASCII sont sur 8 bits." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "b\n", + "a\n", + "97\n", + "122\n" + ] + }, + { + "data": { + "text/plain": [ + "'a'" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "placement=0\n", + "def decalage(lettre_message,lettre_cle):\n", + " indice=ord(lettre_message)-ord(\"a\")\n", + " decal=ord(lettre_cle)-ord(\"a\") \n", + " new_pos=(indice+decal)%26\n", + " return chr(new_pos+ord(\"a\"))\n", + "\n", + "\n", + "\n", + "print(decalage(\"a\",\"b\"))\n", + "print(decalage(\"z\",\"b\"))\n", + "print(ord(\"a\"))\n", + "print(ord(\"z\"))\n", + "chr(97)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2. Créer une fonction `chiffrer()` qui lit le message et la clé contenus dans les deux widgets `Entry` et \n", + "applique lettre par lettre la fonction décalage. Si la clé est trop courte, elle est répétée cycliquement.\n", + "Le résultat est affiché dans le widget `Entry` prévu à cet usage. \n", + "Pour afficher dans un widget `Entry` qui s'appelle `entree`, il faut faire `entree.insert(0,texte)`\n", + "et pour effacer le contenu du widget faire `entree.delete(0,tk.END)`. On fera une fonction qui effectuera le calcul et une fonction callback pour l'appliquer à nos textes en entrée." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "kajbjeocpdf\n" + ] + } + ], + "source": [ + "def dec_texte(texte,cle):\n", + " res=\"\"\n", + " for i in range (len(texte)):\n", + " if i%len(cle)==0:\n", + " cle+=cle\n", + " res+=decalage(texte[i],cle[i])\n", + " return res\n", + "\n", + "print(dec_texte(\"jaibiencode\",\"ba\"))\n", + "\n", + "def chiffre():#gère la lecture dans les champs d'entrée et l'affichage du résultat \n", + " if len(entree.cle.get())==0 or len(entree_texte.get()) ==0:\n", + " print('remplir les deux champ')\n", + " else:\n", + " resultat.delete(0,tk.END)\n", + " resultat.insert(0,dec_texte(entree_texte.get(),entree_cle.get()))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "3. Détecter si le message ou la clé est vide, pour afficher un message d'erreur." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def erreurs(cle):\n", + " if cle == \"\":\n", + " print(\"ERROR: clé vide!\")\n", + " elif cle==None:\n", + " print(\"ERROR: clé vide!\")\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "4. Créer une fonction `dechiffrer()` qui lit le message et la clé contenue dans les deux widgets `Entry` et déchiffre le message grâce à la clé. Le résultat est affiché dans le `Label` prévu à cet usage.\n", + "En quoi l'opération est différente du chiffrement ?" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "jaibiencode\n" + ] + } + ], + "source": [ + "def decalage_inv(lettre_message,lettre_cle):\n", + " indice=ord(lettre_message)-ord(\"a\")\n", + " decal=ord(lettre_cle)-ord(\"a\") \n", + " new_pos=(indice-decal)%26\n", + " return chr(new_pos+ord(\"a\"))\n", + "\n", + "\n", + "def dec_texte_inv(texte,cle):\n", + " res=\"\"\n", + " for i in range (len(texte)):\n", + " if i%len(cle)==0:\n", + " cle+=cle\n", + " res+=decalage_inv(texte[i],cle[i])\n", + " return res\n", + " \n", + " \n", + " \n", + "\n", + "def dechiffre():\n", + "\n", + "# gère la lecture dans les champs d'entrée et l'affichage du résultat \n", + " if len(entree.cle.get())==0 or len(entree_texte.get()) ==0:\n", + " print('remplir les deux champ')\n", + " else:\n", + " resultat.delete(0,tk.END)\n", + " resultat.insert(0,dec_texte_inv(entree_texte.get(),entree_cle.get()))\n", + "print(dec_texte_inv(\"kajbjeocpdf\",\"ba\"))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "5. Tester votre programme en envoyant un message crypté à un de vos camarades et en lui donnant la clé à l'oral (par exemple votre prénom). Il doit être capable de retrouver le texte original." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "6. Crypter un texte et cacher le dans une image avec le programme du TD précédent et envoyer le résultat à un camarade. Est-il capable de récupérer le message ?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "7. Au lieu de chiffrer caractère par caractère, on veut coder bit à bit en appliquant un XOR. \n", + "Donner une nouvelle méthode `chiffre_xor(lettre_message,lettre_cle)` pour remplacer `decalage(lettre_message,lettre_cle)` et tester votre nouvelle méthode cryptage." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u0003\n", + "\u000eC\u0015\u001e\u0010P\u0018\n", + "P\u0019\u0001\u0003\u0019\n", + "c'est un test\n" + ] + } + ], + "source": [ + "def chiffre_xor(lettre_message,lettre_cle):\n", + " return chr(ord(lettre_message)^ord(lettre_cle))\n", + "\n", + "print(chiffre_xor(\"a\",\"b\"))\n", + "\n", + "def dec_texte_xor(texte,cle):\n", + " res=\"\"\n", + " for i in range (len(texte)):\n", + " if i%len(cle)==0:\n", + " cle+=cle\n", + " res+=chiffre_xor(texte[i],cle[i])\n", + " return res\n", + "\n", + "print(dec_texte_xor(\"c'est un test\",\"mdp\"))\n", + "print(dec_texte_xor(dec_texte_xor(\"c'est un test\",\"mdp\"),\"mdp\"))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n", + "7\n" + ] + } + ], + "source": [ + "print(7^2)\n", + "print(5^2)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "def dechiffre():\n", + "\n", + "# gère la lecture dans les champs d'entrée et l'affichage du résultat \n", + " if len(entree_cle.get())==0 or len(entree_texte.get()) ==0:\n", + " resultat.config(text='remplir les deux champ')\n", + " else:\n", + " resultat.config(text=tk.END)\n", + " resultat.config(text=dec_texte_inv(entree_texte.get(),entree_cle.get()))\n", + "\n", + "def chiffre():#gère la lecture dans les champs d'entrée et l'affichage du résultat \n", + " if len(entree_cle.get())==0 or len(entree_texte.get()) ==0:\n", + " resultat.config(text='remplir les deux champ')\n", + " else:\n", + " resultat.config(text=tk.END)\n", + " resultat.config(text=dec_texte(entree_texte.get(),entree_cle.get()))\n", + "\n", + "fenetre=tk.Tk()\n", + "fenetre.title(\"Crypto\")\n", + "fenetre.geometry(\"500x300\")\n", + "entree_texte=tk.Entry(fenetre, width=30)\n", + "entree_texte.grid(column=1,row=0)\n", + "\n", + "entree_cle=tk.Entry(fenetre, width=30)\n", + "entree_cle.grid(column=2,row=0)\n", + "\n", + "ButtonCrypt=tk.Button(fenetre, text=\"crypter\",command=chiffre)\n", + "ButtonCrypt.grid(column=1,row=1)\n", + "\n", + "ButtonDecrypt=tk.Button(fenetre, text= \"decrypter\", command=dechiffre)\n", + "resultat=tk.Label(fenetre,text=\"resultat\")\n", + "resultat.grid(column=2,row=3)\n", + "ButtonDecrypt.grid(column=2,row=1)\n", + "fenetre.mainloop()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Note: you may need to restart the kernel to use updated packages.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "ERROR: Could not find a version that satisfies the requirement tkinter (from versions: none)\n", + "ERROR: No matching distribution found for tkinter\n" + ] + } + ], + "source": [] + }, + { + "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.12.2" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/EXERCICES_S2/modif.png b/EXERCICES_S2/modif.png new file mode 100644 index 000000000..a876244f4 Binary files /dev/null and b/EXERCICES_S2/modif.png differ diff --git a/cours/03_structures_iteratives/03_structures_iteratives.ipynb b/cours/03_structures_iteratives/03_structures_iteratives.ipynb index f201afd3e..210446f2f 100644 --- a/cours/03_structures_iteratives/03_structures_iteratives.ipynb +++ b/cours/03_structures_iteratives/03_structures_iteratives.ipynb @@ -679,13 +679,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": { "slideshow": { "slide_type": "fragment" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 est impair\n", + "3 est impair\n", + "5 est impair\n", + "7 est impair\n", + "9 est impair\n", + "11 est impair\n", + "13 est impair\n", + "15 est impair\n", + "17 est impair\n", + "19 est impair\n", + "Terminé\n" + ] + } + ], "source": [ "for i in range(1, 21) :\n", " if i % 2 == 0 :\n", @@ -708,13 +726,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": { "slideshow": { "slide_type": "fragment" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 est impair\n", + "Terminé\n" + ] + } + ], "source": [ "for i in range(1, 21) :\n", " if i % 2 == 0 :\n", @@ -791,28 +818,85 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": { "slideshow": { "slide_type": "fragment" } }, - "outputs": [], + "outputs": [ + { + "ename": "SyntaxError", + "evalue": "positional argument follows keyword argument (2779333493.py, line 4)", + "output_type": "error", + "traceback": [ + "\u001b[1;36m Cell \u001b[1;32mIn[17], line 4\u001b[1;36m\u001b[0m\n\u001b[1;33m print(start=' ',j)\u001b[0m\n\u001b[1;37m ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m positional argument follows keyword argument\n" + ] + } + ], "source": [ - "for i in range(1, 6):\n", - " j = 0\n", + "for i in range(1, 10):\n", + " j = 1\n", " while j < i:\n", - " print(j, end = \" \")\n", + " print(start=' ',j)\n", " j += 1\n", " print(\"\")" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "sabri says you are awesome\n" + ] + } + ], + "source": [ + "print(\"sabri \",end=\"says \")\n", + "print(\"you are awesome\")" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 1 2 3 4 5 6 7 8 9 " + ] + } + ], + "source": [ + "\n", + "for i in range(10):\n", + " print(i,end=\" \")\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "print(type(5 + 2.0))" + ] }, { "cell_type": "code", @@ -839,7 +923,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.6" + "version": "3.11.4" } }, "nbformat": 4, diff --git a/exercises/24 b/exercises/24 new file mode 100644 index 000000000..e69de29bb diff --git a/exercises/365 b/exercises/365 new file mode 100644 index 000000000..e69de29bb diff --git a/exercises/60 b/exercises/60 new file mode 100644 index 000000000..e69de29bb diff --git a/exercises/TD01_prise_en_main/01_prise_en_mainmodif.ipynb b/exercises/TD01_prise_en_main/01_prise_en_mainmodif.ipynb new file mode 100644 index 000000000..d675b5c39 --- /dev/null +++ b/exercises/TD01_prise_en_main/01_prise_en_mainmodif.ipynb @@ -0,0 +1,1691 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# TD 1: Environnement de programmation et premiers pas avec Python" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "## 1.Vérification de l'installation de l'environnement de programmation\n", + "\n", + "Avant de débuter ce td, vous devez avoir suivi la procédure d'installation [INSTALL.md](https://github.com/uvsq-info/l1-python/blob/master/INSTALL.md) si vous utilisez votre ordinateur personnel. Et, que vous utilisiez votre ordinateur personnel ou bien un ordinateur du cartable numérique, vous avez testé toutes les étapes du [tutoriel de prise en main de l'environnement de programmation](https://github.com/uvsq-info/l1-python/blob/master/README.md) jusqu'à la partie **utilisation du projet dans un terminal**. Si un des tests ne marche pas, appelez un enseignant. Si vous ne réusissez pas à exécuter le code du notebook, et en attendant que l'on vienne vous aider, vous pouvez travailler en utilisant un [notebook en ligne](https://colab.research.google.com/notebooks/intro.ipynb). Le notebook en ligne est aussi une solution pour programmer depuis chez vous si vous n'avez pas installé l'environnement correctement. Mais la solution privilégiée reste d'installer l'environnement.\n", + "\n", + "Si vous n'avez suivi que les étapes antérieures à l'installation du système de gestion de versions dans le document INSTALL.md, vous pouvez simplement ignorer la section concernant Git dans le tutoriel d'introduction à l'environnement de programmation.\n", + "\n", + "Tout au long du travail que vous ferez sur les notebooks, pensez à sauvegarder via la barre de menus *File* puis *Save* ou avec le raccourci clavier Ctrl+S. Lorsqu'un fichier est correctement sauvegardé, le rond blanc disposé à côté du nom du fichier en haut de VSCode disparait.\n", + "A la fin du td, mais également à la fin de chaque section du notebook, pensez à sauvegardez votre travail sur votre compte github.\n", + "\n", + "Afin d'utiliser les cellules de ce notebook, en haut à droite de la fenêtre cliquer sur \"Select Kernel\" et choisir \"Python 3.9.X XX-bit ('l1-python': conda)\"." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "## 2.Utilisation du notebook **Python**\n", + "\n", + "Dans un premier temps, nous allons voir comment utiliser le notebook. Le notebook permet d'écrire du code que l'on peut évaluer au fur et à mesure. Plus tard, nous programmerons dans un fichier texte, en utilisant l'éditeur VisualStudioCode (VSCode dans la suite) et l'environnement qu'il fournit pour écrire des programmes en Python. \n", + "\n", + "Un notebook contient des *cellules* qui sont de deux sortes: il y a des cellules de texte écrites dans un langage de mise en forme de texte appelé *Markdown*, et les cellules de code que vous allez remplir. Les cellules de code sont sur fond gris et un triangle gris apparait sur la gauche de la cellule lorsque votre souris la survole.\n", + "\n", + "1. Dans la cellule de code suivante, tapez `1 + 1` puis évaluez la cellule en cliquant sur le triangle gris situé à gauche de la cellule!\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2" + ] + }, + "execution_count": 65, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "1+1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2. Cliquez de nouveau sur cette cellule et appuyez sur les touches `SHIFT + ENTREE` du clavier.\n", + "\n", + "**Note**: Cela évalue également la cellule de code. Remarquez le numéro qui s'affiche dans les crochets à gauche de la cellule de code : c'est *l'ordre d'évaluation* de la cellule. \n", + "\n", + "3. Dans la cellule suivante, affectez le résultat de l'expression `1 + 1` à une variable notée `a`. Bien entendu, évaluez la cellule (on ne le rappellera pas systématiquement)." + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2" + ] + }, + "execution_count": 66, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "1+1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "4. Remarquez que l'évaluation de cette cellule ne génère aucun *texte en sortie*. Pour connaître la valeur de la variable `a`, tapez le nom de la variable dans la cellule suivante." + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2" + ] + }, + "execution_count": 67, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a=1+1\n", + "a\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "5. Testez maintenant l'expression `print(a)`." + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n" + ] + } + ], + "source": [ + "print(a)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Le résultat est identique. La première méthode fonctionne dans le notebook, mais pas dans un programme Python. C'est pourquoi il vaut mieux utiliser la deuxième méthode qui repose sur l'utilisation de la *fonction native* `print()`. L'ensemble de ces fonctions est [disponible ici](https://docs.python.org/fr/3.5/library/functions.html).\n", + "\n", + "6. Augmentez de 1 la valeur de `a`. L'expression doit donner le bon résultat quelle que soit la valeur de la variable." + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n" + ] + }, + { + "data": { + "text/plain": [ + "3" + ] + }, + "execution_count": 69, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(a)\n", + "a+=1\n", + "a" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Et vérifiez en affichant la valeur de `a`." + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "3" + ] + }, + "execution_count": 70, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "7. Ré-évaluez toutes les cellules où vous avez affiché la valeur de `a`. Que remarquez-vous? On voit ici que ce qui compte dans le notebook est *l'ordre d'évaluation* et non pas *l'ordre d'apparition* des cellules. Ce comportement est source d'erreur, il faut donc bien y faire attention.\n", + "\n", + "8. Sans écrire de code supplémentaire, augmentez encore de 1 la valeur de `a`, et vérifiez que ça a bien fonctionné.\n", + "\n", + "**Note**: les 5 questions suivantes sont relatives à l'usage du notebook dans VSCode. Si vous travaillez avec un autre type de notebook, il est possible que vous n'ayez pas accès à toutes ces fonctionnalités.\n", + "\n", + "9. Parmi les icônes situés en haut du notebook, cliquez sur `Clear Outputs` puis ré-évaluez la variable `a`.\n", + "\n", + "10. Parmi les icônes situés en haut du notebook, cliquez sur `Variables` et regardez le résultat. Cet outil est très utile pour comprendre les erreurs liées à l'ordre d'évaluation des cellules.\n", + "\n", + "11. Parmi les icônes situés en haut du notebook, cliquez sur `Restart` et regardez le résultat dans l'affichage des variables. Ré-évaluez la variable `a`. Que se passe-t'il ?\n", + "\n", + "12. Enfin, sauvegardez votre travail.\n", + "\n", + "13. Dans la cellule suivante, affectez la valeur 5 à la variable `a` et la valeur 2 à la variable `b`, puis afficher les 2 valeurs avec l'expression `print(a, b)`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n", + "2\n", + "5 2\n" + ] + } + ], + "source": [ + "a=5 \n", + "b=2\n", + "print(a)\n", + "print(b)\n", + "print(a,b)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "15. Ecrivez le code qui permet d'échanger la valeur des variables `a` et `b`. Puis affichez leurs valeurs." + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n", + "2\n", + "2 5\n" + ] + } + ], + "source": [ + "print(a)\n", + "print(b)\n", + "a,b=b,a\n", + "print(a,b)" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n", + "5\n", + "5 2\n" + ] + } + ], + "source": [ + "print(a)\n", + "print(b)\n", + "b,a=a,b\n", + "print(a,b)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "16. Pour enrichir l'affichage, recopiez l'expression `print(\"a vaut\", a, \"et b vaut\", b)`." + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a vaut 5 et b vaut 2\n" + ] + } + ], + "source": [ + "print(\"a vaut\", a, \"et b vaut\", b)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "17. Recopiez l'affectation suivante `a = \"hello world\"`, puis affichez la valeur de `a`." + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'hello world'" + ] + }, + "execution_count": 75, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a=\"hello world\"\n", + "a" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Note**: la variable `a` contenait un entier, et maintenant une chaîne de caractères. En Python les variables ont un *type dynamique* contrairement au type statique où le type des variables est défini une fois pour toutes. De plus ce typage est *implicite*, c'est-à-dire qu'il est déterminé par les objets auxquels les variables font référence sans avoir besoin de l'écrire explicitement.\n", + "\n", + "18. Afficher de nouveau la valeur de `a` sans utiliser la fonction `print`. Que constatez-vous?\n", + "\n", + "19. Avant de passer à la suite, sauvegardez votre notebook, et sauvegardez le sur github." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "-------------------\n", + "## 3.Types de données\n", + "En Python, toute variable ou expression possède un *type* qui définit, entre autres, les opérations que l'on peut lui appliquer. Parmi les types natifs on peut citer les nombres entiers, les nombres flottants, les chaînes de caractères (string en anglais) et les booléens (Vrai ou Faux).\n", + "\n", + "\n", + "1. Prédisez le type de chacune des expressions suivantes. Vérifiez le à l'aide de la fonction `type()`:\n", + "\n", + "* `5`\n", + "* `5.0`\n", + "* `\"5\"`\n", + "* `-5`\n", + "* `5 / 2`\n", + "* `5 // 2`\n", + "* ` 5 == 2 `\n", + "* `5 = 2`" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "print(type(5))" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "print(type(5.0))" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "print(type(\"5\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "print(type(-5))" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "print(type(5/2))" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n" + ] + } + ], + "source": [ + "print(5%2)" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "print(type(5//2))" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "print(type(5==2))" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": {}, + "outputs": [ + { + "ename": "SyntaxError", + "evalue": "expression cannot contain assignment, perhaps you meant \"==\"? (1591063500.py, line 1)", + "output_type": "error", + "traceback": [ + "\u001b[1;36m Cell \u001b[1;32mIn[84], line 1\u001b[1;36m\u001b[0m\n\u001b[1;33m print(type(5 = 2))\u001b[0m\n\u001b[1;37m ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m expression cannot contain assignment, perhaps you meant \"==\"?\n" + ] + } + ], + "source": [ + "print(type(5 = 2))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n", + "True\n", + "\n" + ] + }, + { + "ename": "TypeError", + "evalue": "type() takes 1 or 3 arguments", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32mc:\\Users\\Administrator\\Desktop\\l1-python-master\\l1-python-master\\exercises\\TD01_prise_en_main\\01_prise_en_main.ipynb Cell 35\u001b[0m line \u001b[0;36m8\n\u001b[0;32m 6\u001b[0m \u001b[39mprint\u001b[39m(a)\n\u001b[0;32m 7\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39mtype\u001b[39m(a))\n\u001b[1;32m----> 8\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39mtype\u001b[39;49m(a,b))\n", + "\u001b[1;31mTypeError\u001b[0m: type() takes 1 or 3 arguments" + ] + } + ], + "source": [ + "a=True\n", + "b=False \n", + "c=5\n", + "d=2\n", + "print(c>2)\n", + "print(a)\n", + "print(type(a))\n", + "print(type(a,b))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ce sont les types de base du langage Python que nous allons étudier dans la suite. Notez que les nombres flottants s'écrivent avec un point et non avec une virgule.\n", + "\n", + "2. Faites la même chose avec les expressions suivantes:\n", + "\n", + "* `(5, 2)`\n", + "* `[5, 2]`\n", + "* `{5, 2}`\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "print(type((5, 2)))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "print(type([5, 2]))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "print(type({5, 2}))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ce sont des types avancés, qui permettent de construire des structures de données plus complexes, que nous apprendrons à manipuler plus tard. Pouvez-vous trouver une expression ayant un autre type? Vous pouvez consulter la [documentation Python sur les types](https://docs.python.org/fr/3/library/stdtypes.html).\n", + "\n", + "3. Maintenant, affectez une valeur à une variable `x`, et écrivez le code qui affiche, par exemple, `le type de x est ` si jamais la valeur stockée dans `x` est un entier.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "le type de x est \n" + ] + } + ], + "source": [ + "x=2\n", + "print('le type de x est',type(x))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 3.1 Type numérique entier\n", + "\n", + "1. Affectez une valeur entière à une variable `v`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "v=211" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2. Ecrivez le résultat de la division entière de `v` par 11. Par exemple, si `v` vaut 149, le résultat affiché doit être de la forme: \n", + "\n", + "`149 = 13 x 11 + 6`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "211 = 19 x 11 + 2\n" + ] + } + ], + "source": [ + "print(v,'=',v//11,\"x 11 +\",v%11)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "3. Prédisez le résultat des expressions suivantes, puis évaluer le code:\n", + "* `3 * (10 / 3)`\n", + "* `3 * (10 // 3)`\n", + "* `(3 * 10) // 3`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10.0\n" + ] + } + ], + "source": [ + "print(3*(10/3))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "9\n" + ] + } + ], + "source": [ + "print(3*(10//3))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10\n" + ] + } + ], + "source": [ + "print((3*10)//3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "5. Le résultat change-t'il si on retire les parenthèses des expressions précédentes?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "6. Affectez un nombre entier à une variable, puis écrivez une expression qui affiche `True` si la variable est paire et `False` sinon." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n" + ] + } + ], + "source": [ + "nombre=122\n", + "print((nombre%2)==0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "7. L'opérateur puissance s'écrit `**`. Par exemple, 2 à la puissance 10 s'écrit `2 ** 10`. Affichez la valeur de 2 puissance 256. Combien de chiffres a ce nombre (en évitant de compter sur l'écran)?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "115792089237316195423570985008687907853269984665640564039457584007913129639936\n", + "78\n" + ] + } + ], + "source": [ + "print(2**256)\n", + "print(len(str(2**256)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Note**: les nombres entiers ont une précision arbitraire." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ecrire l'expression qui donne le dernier chiffre du nombre référencé par la variable `a`." + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n" + ] + } + ], + "source": [ + "a=2005\n", + "print((str(a))[-1])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ecrire l'expression qui donne l'avant-dernier chiffre du nombre référencé par la variable `a`." + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n" + ] + } + ], + "source": [ + "print((str(a))[-2])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 3.2 Nombres flottants\n", + "\n", + "1. L'expression `0.2 + 0.4` est-elle égale, supérieure ou inférieure à `0.6`?" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n", + "False\n" + ] + } + ], + "source": [ + "print((0.2 + 0.4)>0.6)\n", + "print((0.2+0.4)<0.6)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2. Affectez la valeur 0.5 à une variable `x`. Multipliez `x` par $2^{30}$ puis convertissez le résultat obtenu en valeur entière (utilisez la fonction `int()`) puis divisez le résultat par $2^{30}$ (faire une division flottante)." + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.5\n" + ] + } + ], + "source": [ + "x=0.5\n", + "x=x*(2**30)\n", + "int(x)\n", + "x=x/(2**30)\n", + "print(x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "3. Remplacez la valeur de `x` par 0.1 et refaites le calcul." + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.1\n" + ] + } + ], + "source": [ + "x=0.1\n", + "x=x*(2**30)\n", + "int(x)\n", + "x=x/(2**30)\n", + "print(x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "4. Pouvez-vous trouver d'autres valeurs de `x` pour lesquelles l'expression calculée redonne la valeur de `x`?\n", + "\n", + "**Note**: les nombres flottants que l'on manipule sont en fait une approximation de ces nombres. Pour plus de détails, vous pouvez consulter [cet article](https://docs.python.org/fr/3.8/tutorial/floatingpoint.html)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 3.3 Chaînes de caractères" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1. Dans la cellule de code suivante, affichez le résultat de l'expression `a + b`, et de `b + a`" + ] + }, + { + "cell_type": "code", + "execution_count": 107, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "helloworld\n", + "worldhello\n" + ] + } + ], + "source": [ + "a = \"hello\"\n", + "b = 'world'\n", + "print(a+b)\n", + "print(b+a)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Notes**: les chaînes de caractères peuvent s'écrire avec des guillemets simples ou doubles (d'autres formes existent). L'opération d'addition de chaînes est appelée *concaténation*.\n", + "\n", + "2. Dans la cellule précédente, ajoutez un espace entre `hello` et `world` sans modifier les variables." + ] + }, + { + "cell_type": "code", + "execution_count": 108, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "hello world\n", + "world hello\n" + ] + } + ], + "source": [ + "print(a,b)\n", + "print(b,a)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "3. Avant d'afficher le résultat, prédire ce que valent `a * 3` et `(a + b) * 2`?" + ] + }, + { + "cell_type": "code", + "execution_count": 110, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "hellohellohello\n", + "helloworldhelloworld\n" + ] + } + ], + "source": [ + "print(a*3)\n", + "print((a+b)*2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "4. On peut appliquer des *méthodes* (ce sont des fonctions qui s'appliquent à un certain type d'objets) à une chaîne de caractères. Par exemple tester ce que vaut `a.upper()`." + ] + }, + { + "cell_type": "code", + "execution_count": 111, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "HELLO\n" + ] + } + ], + "source": [ + "print(a.upper())" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Bonjour\n" + ] + } + ], + "source": [ + "print(\"bonjour\".capitalize())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vous pouvez voir la liste des méthodes associées aux chaînes de caractères (ainsi que sur les autres types natifs) sur [cette page](https://docs.python.org/fr/3/library/stdtypes.html#string-methods).\n", + "\n", + "5. La variable `a` a-t'elle été modifiée?" + ] + }, + { + "cell_type": "code", + "execution_count": 112, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "hello\n" + ] + } + ], + "source": [ + "print(a)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "6. Que vaut `a > b`?" + ] + }, + { + "cell_type": "code", + "execution_count": 113, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "False\n" + ] + } + ], + "source": [ + "print(a>b)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "7. Quelle est la signification de cette comparaison?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 3.4 Conversions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1. Dans la cellule de code suivante, devinez ce que vaut `a * 2` avant de l'afficher." + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3232\n" + ] + } + ], + "source": [ + "a = \"32\"\n", + "print(a*2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2. Utilisez la fonction de conversion `int()` pour obtenir le résultat de la multiplication de nombres entiers (64 ici)." + ] + }, + { + "cell_type": "code", + "execution_count": 119, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "64\n" + ] + } + ], + "source": [ + "a = \"32\"\n", + "print(int(a)*2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "3. Ecrivez l'expression `s = input(\"Tape quelquechose au clavier\")` puis affichez `s`. Que se passe-t'il?" + ] + }, + { + "cell_type": "code", + "execution_count": 121, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bonjour\n" + ] + } + ], + "source": [ + "s = input(\"Tape quelquechose au clavier\")\n", + "print(s)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "4. Recopiez le code de la cellule précédente. L'utilisateur doit saisir un nombre entier puis vous affichez ce nombre multiplié par 2." + ] + }, + { + "cell_type": "code", + "execution_count": 125, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "100\n", + "200\n" + ] + } + ], + "source": [ + "s = input(\"Tape quelquechose au clavier\")\n", + "print(s)\n", + "print(int(s)*2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "5. ́Ecrivez le code qui demande son âge à l’utilisateur et répond en utilisant sa réponse au milieu d’une phrase, comme par exemple en lui donnant l’âge qu’il aura en 2031 le même jour." + ] + }, + { + "cell_type": "code", + "execution_count": 126, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "vous aurez 26 ans en 2031 le même jour.\n" + ] + } + ], + "source": [ + "age=input(\"donnez vôtre âge\")\n", + "print(\"vous aurez\",int(age)+8,\"ans en 2031 le même jour.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "6. Avant de passer à la suite, sauvegardez votre notebook sur github." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "## Exercices supplémentaires" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "1. Parmi les chaînes de caractères suivantes, lesquelles peuvent être des noms de variable?\n", + "* `f`\n", + "* `l`\n", + "* `f2`\n", + "* `2f`\n", + "* `totolehero`\n", + "* `toto_le_hero`\n", + "* `import`\n", + "* `toto2-le-retour`\n", + "\n", + "Et parmi les noms corrects, lesquels ne sont pas recommandés (voir la [PEP8](https://www.python.org/dev/peps/pep-0008/#naming-conventions))?\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**réponses** chaînes de caractères pouvant être des variables: f ; l ; f2 ; totolehero; toto_le_hero." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2. Demandez à l'utilisateur de rentrer un nombre, puis afficher sa racine carrée en faisant une phrase." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4\n", + "2.0\n" + ] + } + ], + "source": [ + "racine= input(\"donnez-moi un nombre\")\n", + "print(racine)\n", + "print((int(racine))**(1/2))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "3. Ecrivez le code qui affiche:\n", + "* la chaı̂ne ”aaaaaa...” (250 ”a”)\n", + "* la chaı̂ne ”bbbb....a” (250 ”b” suivis d’un ”a”)\n", + "* la chaı̂ne ”bbbb....aaabbb...” (250 ”b” suivis d’un ”a” suivi de 100 b)\n", + "* 50 fois ”bonjour” en allant à la ligne à chaque fois (utilisez ”\\n”)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" + ] + } + ], + "source": [ + "print(\"a\"*250)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbba\n" + ] + } + ], + "source": [ + "print(\"b\"*250+\"a\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" + ] + } + ], + "source": [ + "print(\"b\"*250+\"a\"+\"b\"*100) " + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "bonjour\n", + "\n" + ] + } + ], + "source": [ + "print((\"bonjour\\n\")*50)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "4. Evaluez chaque expression numérique étape par étape selon la priorité des opérateurs.\n", + " * a) 3 + 4 * 6\n", + " * b) 3 * 4 / 6 + 6\n", + " * c) 2 * 3 / 12 * 8 / 4\n", + " * d) 10 * ( 1 + 7 * 3 )\n", + " * e) 20 - 2 / 6 + 3\n", + " * f) ( 20 - 2 ) / ( 6 + 3 )\n", + " * g) 10 + 15 % 2 + 4.3\n", + " * h) 3 * 4 / 6 + 6" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Réponses:**\n", + "* a) 3+4*6=3+24=27 \n", + "* b) 3*4/6+6=12/6+6=2+6=8\n", + "* c) 2*3/12*8/4=6/12*8/4=1/2*8/4=1/2*2=1\n", + "* d) 10*(1+7*3)=10*(1+21)=10*22=220\n", + "* e) 20-2/6+3=20-1/2+3=20+7/2=(40+7)/2=47/2=23.5\n", + "* f) (20-2)/(6+3)=18/9=2\n", + "* g) 10+15%2+4.3=10+1+4.3=11+4.3=15.3\n", + "* h) 3*4/6+6=12/6+6=2+6=8" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "5. Saisir, Calculer et Afficher\n", + "\n", + " * (1) Ecrire un code qui permet de faire les tâches suivantes :\n", + " * a) Saisir deux variables, a et b, de type entier.\n", + " * b) Calculer la somme de ces deux variables.\n", + " * c) Affecter le résultat dans la variable « Somme ».\n", + " * d) Calculer le quotient de ces deux variables.\n", + " * e) Affecter le résultat dans la variable « Quotient ».\n", + " * f) Afficher les valeurs des variables « Somme » et « Quotient ». Le message doit être sous la forme suivante «La somme de 3 et 1 est 4 et le quotient de 3 sur 1 est 3 »\n", + " \n", + " * (2) Quel est le nombre total de variables utilisées pour cet algorithme ?\n", + " \n", + " * (3) On veut, maintenant, minimiser le nombre de variables utilisées par le code précédent.\n", + " * a) Quel est le nombre maximal de variables qu’on peut supprimer ?\n", + " * b) Quel est le nombre minimal de variables qu’on peut supprimer ?\n", + " \n", + " * (4) Ecrire le code correspondant à 3.a. " + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "la somme de 5 et 2 est 7 et le quotient de 5 sur 2 est 2\n" + ] + } + ], + "source": [ + "a= input(\"saisir a\")\n", + "b= input(\"saisir b\")\n", + "somme= int(a)+int(b)\n", + "quotient=int(a)//int(b)\n", + "print(\"la somme de\",a,\"et\",b,\"est\",somme,\"et le quotient de\",a,\"sur\",b,\"est\",quotient)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "6. Ecrire un code qui permet de calculer le diamètre, le périmètre et la surface d’un cercle. Pour ce faire nous allons procéder comme suit :\n", + " * a) Déclarer la variable constante 𝝅 et la variable Ray contenant la valeur 10.\n", + " * b) Déclarer trois variables DM, PR et SR.\n", + " * c) Affecter respectivement à DM, PR et SR les valeurs du diamètre, du périmètre et de la surface d’un cercle dont le rayon est Ray.\n", + " * d) Afficher le message suivant \"Le cercle de rayon AA a pour diamètre BB, pour périmètre CC et pour surface DD\"." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Le cercle de rayon 10 a pour diamètre 20 , pour périmètre 62.800000000000004 et pour surface 314.0\n" + ] + } + ], + "source": [ + "pi=3.14\n", + "Ray=10\n", + "DM=2*Ray\n", + "PR=2*pi*Ray\n", + "SR=pi*(Ray**2)\n", + "\n", + "\n", + "print(\"Le cercle de rayon\",Ray, \"a pour diamètre\", DM,\", pour périmètre\", PR,\" et pour surface\", SR)" + ] + } + ], + "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.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/exercises/TD02_structures_controle/02_structures_controle_modif.ipynb b/exercises/TD02_structures_controle/02_structures_controle_modif.ipynb new file mode 100644 index 000000000..eac0c21ea --- /dev/null +++ b/exercises/TD02_structures_controle/02_structures_controle_modif.ipynb @@ -0,0 +1,1578 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# TD 2: Les structures de contrôle\n", + "\n", + "---\n", + "\n", + "## 0. Récupération des nouveaux documents\n", + "\n", + "\n", + "Les sujets de TD ainsi que les supports de cours sont publiés en ligne au fur et à mesure sur l'espace github original [https://github.com/uvsq-info/l1-python](https://github.com/uvsq-info/l1-python). Au moment où vous avez fait le fork de cet espace sur votre espace personnel, il est probable que tous les contenus n'étaient pas présents. Pour compléter votre espace, deux solutions sont possibles:\n", + "\n", + "\n", + "1. (solution à privilégier) aller sur la page du projet original [https://github.com/uvsq-info/l1-python](https://github.com/uvsq-info/l1-python), et cliquer sur le bouton vert `Code` en haut à droite. Choisir `download ZIP`, puis extraire l'ensemble des nouveaux fichiers vers votre projet personnel local. Vous pouvez ensuite sauvegarder ces ajouts dans votre espace github personnel en suivant la procédure habituelle.\n", + "2. (solution qui présente des risques de conflits entre différentes versions d'un même document) en ligne de commande dans le terminal, en suivant la procédure de la section *Intégrer les mises à jour du projet original* du fichier [README.md](https://github.com/uvsq-info/l1-python/blob/master/README.md#int%C3%A9grer-les-mises-%C3%A0-jour-du-projet-original)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "---\n", + "\n", + "## 1. Premiers exercices avec les structures conditionnelles\n", + "\n", + "**Exercice 1:**\n", + "\n", + "1. Soit *num1 = 15* et *num2 = 5*. Ecrire un programme qui affiche *Factors!* si l'un des nombres est un facteur de l'autre (c'est-à-dire qu'il divise l'autre nombre). Si aucun des nombres n'est un facteur de l'autre, le programme n'affiche rien.\n", + "2. Changer le code que vous avez écrit de telle sorte qu'il affiche toujours *Factors!* si un nombre est un facteur de l'autre, mais qui affiche aussi *Not factors!* si aucun des nombres n'est un facteur de l'autre." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "slideshow": { + "slide_type": "notes" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Factors!\n" + ] + } + ], + "source": [ + "num1=15\n", + "num2=5\n", + "if num1%num2==0 or num2%num1==0:\n", + " print(\"Factors!\")\n", + "else:\n", + " print(\"Not factors!\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "**Exercice 2:**\n", + " \n", + "Soit *state = \"Georgia\"*. Ecrire un programme qui permet d'afficher un message spécifique en fonction de la variable *state* : \n", + "* \"School isn't cancelled.\" si nous sommes à New Jersey, \n", + "* \"School is postponed.\" si nous sommes à North Carolina,\n", + "* \"School is cancelled!\" si nous sommes à Georgia, \n", + "* \"School's status is unknown\" si nous ne sommes pas dans un des trois états précédemment mentionnés." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "slideshow": { + "slide_type": "notes" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "School is cancelled\n" + ] + } + ], + "source": [ + "state= \"Georgia\"\n", + "if state==\"New Jersey\":\n", + " print(\"School isn't cancelled.\")\n", + "if state==\"North Carolina\":\n", + " print(\"School is postponed\")\n", + "if state==\"Georgia\":\n", + " print(\"School is cancelled\")\n", + "else:\n", + " print(\"School status is unknown\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "**Exercice 3:**\n", + "\n", + "Ecrire un programme pour découvrir le signe du zodiaque chinois pour une année donnée. Le signe du zodiaque chinois est basé sur un cycle de 12 ans et chaque année de ce cycle est représentée par un animal :\n", + "* 0: monkey\n", + "* 1: rooster\n", + "* 2: dog\n", + "* 3: pig\n", + "* 4: rat\n", + "* 5: fox\n", + "* 6: tiger\n", + "* 7: rabbit\n", + "* 8: dragon\n", + "* 9: snake\n", + "* 10: horse\n", + "* 11: sheep\n", + "\n", + "La valeur de l'année % 12 détermine le signe du zodiaque. Par exemple, 1900 est l'année du *rat* puisque 1900 % 12 est 4." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "slideshow": { + "slide_type": "notes" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "rabbit\n" + ] + } + ], + "source": [ + "année=2023\n", + "signe=année%12\n", + "zodiac=[\"monkey\",\"rooster\",\"dog\",\"pig\",\"rat\",\"fox\",\"tiger\",\"rabbit\",\"dragon\",\"snake\",\"horse\",\"sheep\"]\n", + "print(zodiac[signe])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "**Exercice 4:**\n", + "\n", + "Soit *temperature = -3.7* et *celsius = True*. *celsius* est une variable booléenne qui indique si la température est en Celsius; si c'est *False*, alors la température donnée est en Fahrenheit. Ecrire un premier programme en utilisant *if-else* seulement qui permet d'afficher *Freezing* si les valeurs données représentent une température très basse, et *Not freezing* si ce n'est pas le cas. En Celsius, on considère qu'il fait très froid lorsque la température est inférieure ou égale à 0 degré. En Fahrenheit, on considère qu'il fait très froid lorsque la température est inférieure ou égale à 32 degrés. Proposer une seconde solution en utilisant *if-elif-else* à ce même problème." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "slideshow": { + "slide_type": "notes" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Freezing\n" + ] + } + ], + "source": [ + "temperature= -3.7\n", + "celsius = True\n", + "if celsius:\n", + " if temperature<=0:\n", + " print('Freezing')\n", + " else:\n", + " print('Not freezing')\n", + "else:\n", + " if temperature<=32:\n", + " print(\"Freezing\")\n", + " else:\n", + " print(\"Not freezing\")\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "**Exercice 5:**\n", + " \n", + "Ecrire un programme qui permet de déterminer si une année est bissextile ou non en utilisant une seule instruction *if-else*. Une année *A* est bissextile si *A* est divisible par 4. Elle ne l’est cependant pas si *A* est un multiple\n", + "de 100, à moins que *A* ne soit multiple de 400. " + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "slideshow": { + "slide_type": "notes" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "année non-bissextile\n" + ] + } + ], + "source": [ + "A=2023\n", + "if A%4==0 and (A%100!=0 or A%400==0):\n", + " print(\"année bissextile\")\n", + "else:\n", + " print(\"année non-bissextile\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "write a program that shows \"hello\" if the number given n user is a multiple of 5 else, it shows \"byebye\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "n=input(\"give number\")\n", + "if int(n)%5==0:\n", + " print(\"hello\")\n", + "else:\n", + " print(\"bye bye\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "ecrire un programme qui accepte 2 nombres et un operateur mathématiques et execute l'operation correspondante donné par utilisateur\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "8\n" + ] + } + ], + "source": [ + "number1=int(input(\"give number1\"))\n", + "number2=int(input(\"give number 2\"))\n", + "oper=input(\"give operator\")\n", + "if oper==\"-\":\n", + " print(number1-number2)\n", + "elif oper==\"+\":\n", + " print(number1+number2)\n", + "elif oper==\"*\":\n", + " print(number1*number2)\n", + "elif oper==\"/\":\n", + " print(number1/number2)\n", + "elif oper==\"//\":\n", + " print(number1//number2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "ecrire un programme qui accepte l'âge , le genre(M/F), nombre de jours et affiche le salaire.\n", + "Si l'âge ne figure pas dans l'intervalle alors le programme affiche le mess suivant:\"entrez un âge approprié\"" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "M\n", + "280000\n" + ] + } + ], + "source": [ + "age=int(input(\"donnez age\"))\n", + "genre=input(\"donnez genre(M/F)\")\n", + "genre=genre.upper()\n", + "print(genre)\n", + "nbrjours=int(input(\"donnez nombre de jours\"))\n", + "salaire=0\n", + "if age>=18 and age<30:\n", + " if genre==\"M\":\n", + " salaire=700\n", + " else:\n", + " salaire=750\n", + "elif age>=30 and age<=40:\n", + " if genre==\"M\":\n", + " salaire=800\n", + " else:\n", + " salaire=850\n", + "else:\n", + " age=input(\"donnez age approprié\")\n", + "print(salaire*nbrjours)\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "## 2. Premiers exercices avec les structures itératives\n", + "\n", + "**Exercice 6:**\n", + "\n", + "1. Ecrire un programme qui permet d'afficher tous les nombres entre 1 et 10 (bornes incluses).\n", + "2. Ecrire un programme se limitant à la boucle *for* qui permet d'afficher tous les nombres pairs entre 1 et 20 (bornes incluses). Proposer une deuxième solution en incluant une structure conditionnelle." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n", + "7\n", + "8\n", + "9\n", + "10\n" + ] + } + ], + "source": [ + "for i in range (1,11):\n", + " print(i)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "3\n", + "5\n", + "7\n", + "9\n", + "11\n", + "13\n", + "15\n", + "17\n", + "19\n" + ] + } + ], + "source": [ + "for i in range (1,21,2):\n", + " print(i)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n", + "4\n", + "6\n", + "8\n", + "10\n", + "12\n", + "14\n", + "16\n", + "18\n", + "20\n" + ] + } + ], + "source": [ + "for i in range (1,21):\n", + " if i%2==0:\n", + " print(i)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n" + ] + } + ], + "source": [ + "print([i for i in range (1,11)])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Exercice 7:**\n", + " \n", + "1. Ecrire un programme qui demande à l'utilisateur de saisir *n* nombres, *n* étant choisi par l'utilisateur, puis d'afficher la moyenne de ces nombres.\n", + "\n", + "2. Même question, mais l'utilisateur ne choisit pas à l'avance le nombre *n*, la procédure s'arrête quand il saisit le nombre -1.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "14.5\n" + ] + } + ], + "source": [ + "n=input(\"calcul de moyenne: combien de nombres?\")\n", + "liste=[]\n", + "moyenne=0\n", + "for i in range (int(n)):\n", + " place=input(\"quel sera le nombre?\")\n", + " liste.append(float(place))\n", + "for terme in liste:\n", + " moyenne=moyenne+terme\n", + "moyenne=moyenne/len(liste)\n", + "print(moyenne)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6.666666666666667\n" + ] + } + ], + "source": [ + "n=int(input(\"donnez nombre\"))\n", + "x=0\n", + "for i in range (1,n):\n", + " x+=int(input(\"nombre?\"))\n", + "x/=n\n", + "print(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "7.4\n" + ] + } + ], + "source": [ + "x=0\n", + "i=0\n", + "n=0\n", + "while n!=-1:\n", + " n=int(input(\"donnez nombre\"))\n", + " x+=n\n", + " i+=1\n", + "moyenne=x/i\n", + "print(moyenne)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4.125\n" + ] + } + ], + "source": [ + "liste=[]\n", + "moyenne=0\n", + "place=\"\"\n", + "while place!=\"-1\":\n", + " place=input(\"quel sera le nombre?\")\n", + " liste.append(float(place))\n", + "for terme in liste:\n", + " moyenne=moyenne+terme\n", + "moyenne=moyenne/len(liste)\n", + "print(moyenne)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Exercice 8:**\n", + "\n", + "Ecrire un programme qui permet de calculer le factoriel d'un nombre positif donné par l'utlisateur selon la formule suivante : \n", + "n! = 1 x 2 x ... x n. \n", + "\n", + "1. Une première version en utilisant la boucle *for*\n", + "2. Une seconde version en utilisant la boucle *while*" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "24\n" + ] + } + ], + "source": [ + "n=input(\"nombre?\")\n", + "n=int(n)\n", + "factoriel=1\n", + "for i in range (1,n+1):\n", + " factoriel=factoriel*i\n", + "print(factoriel)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "24\n" + ] + } + ], + "source": [ + "n=input(\"nombre?\")\n", + "n=int(n)\n", + "factoriel=1\n", + "i=1\n", + "while factoriel<=n:\n", + " factoriel*=i\n", + " i+=1\n", + "print(factoriel)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "---\n", + "\n", + "## 3. Pour aller plus loin\n", + "\n", + "**Excercice 9:**\n", + "\n", + "Ecrire un programme qui permet de connaître le jour de naissance de l'utilisateur en posant cinq questions.\n", + "Chaque question demande si le jour est dans l'un des cinq ensembles suivants :\n", + "\n", + "* Set 1: \\[1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31\\]\n", + "* Set 2: \\[2 3 6 7 10 11 14 15 18 19 22 23 26 27 30 31\\]\n", + "* Set 3: \\[4 5 6 7 12 13 14 15 20 21 22 23 28 29 30 31\\]\n", + "* Set 4: \\[8 9 10 11 12 13 14 15 24 25 26 27 28 29 30 31\\]\n", + "* Set 5: \\[16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31\\]\n", + " \n", + "\n", + "Le jour de naissance est la somme des premiers nombres dans les ensembles où le jour apparaît. Par exemple,\n", + "si le jour de naissance est 19, il apparaît dans Set 1, Set 2 et Set 5. Les premiers chiffres de ces trois ensembles sont 1, 2 et 16. Leur somme est 19." + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": { + "slideshow": { + "slide_type": "notes" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "19\n" + ] + } + ], + "source": [ + "set1=[1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31]\n", + "set2=[2 ,3 ,6 ,7 ,10 ,11 ,14 ,15 ,18 ,19 ,22 ,23 ,26 ,27 ,30, 31]\n", + "set3= [4 ,5 ,6 ,7 ,12, 13 ,14 ,15 ,20 ,21 ,22 ,23 ,28 ,29 ,30 ,31]\n", + "set4= [8 ,9 ,10 ,11 ,12 ,13 ,14 ,15 ,24 ,25 ,26 ,27 ,28 ,29 ,30 ,31]\n", + "set5=[16 ,17 ,18 ,19 ,20 ,21 ,22 ,23 ,24 ,25 ,26 ,27 ,28 ,29 ,30 ,31]\n", + "V=[set1,set2,set3,set4,set5]\n", + "answer=[]\n", + "final=0\n", + "for i in range(5):\n", + " Quest=input(\"nombre dans ce set? :\"+str(V[i]))\n", + " answer.append(int(Quest))\n", + "for i in range (len(answer)):\n", + " if answer[i]!=0:\n", + " final+=V[i][0]\n", + "print(final)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "**Excercice 10:**\n", + "\n", + "Ecrire un programme qui permet de génèrer de manière aléatoire un nombre à deux chiffres, invite l'utilisateur à saisir un nombre à deux chiffres et détermine si l'utilisateur gagne selon les règles suivantes :\n", + "* Si l'entrée de l'utilisateur correspond à la loterie (le nombre généré aléatoirement) dans l'ordre exact, la récompense est de 10 000€.\n", + "* Sinon, si les deux chiffres entrés par l'utilisateur correspondent aux deux chiffres du numéro de loterie, la récompense est de 3 000€.\n", + "* Sinon, si un chiffre dans l'entrée de l'utilisateur correspond à un chiffre dans le numéro de loterie, la récompense est de 1 000€.\n", + "\n", + "**Astuce :** Utiliser la fonction **random.randint(0, 99)** pour génèrer de manière aléatoire un nombre à deux chiffres. Cette fonction doit être accompagné par **import random** comme première instruction dans le code." + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": { + "slideshow": { + "slide_type": "notes" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "la loterie était le nombre 48!\n", + "votre réponse était le nombre 28!\n", + "Vous n'avez qu'un seul chiffre correct! Vous gangez 1000€!\n" + ] + } + ], + "source": [ + "import random\n", + "loterie=random.randint(10,99)\n", + "guess=input(\"saisir un nombre pour tenter de ganger de l'argent!\")\n", + "if int(guess)==loterie:\n", + " print(\"la loterie était le nombre \"+str(loterie)+\"!\")\n", + " print('votre réponse était le nombre '+str(guess)+\"!\")\n", + " print('bravo vous avez gangé 10 000€ !!!')\n", + "elif (guess[0] in str(loterie)) and (guess[1] in str(loterie)):\n", + " print(\"la loterie était le nombre \"+str(loterie)+\"!\")\n", + " print('votre réponse était le nombre '+str(guess)+\"!\")\n", + " print(\"Vous répondu avec un nombre dont les chiffres sont exactes mais ne sont pas dans l'ordre de la loterie, Vous gagnez 3 000€ !!\")\n", + "elif (guess[0] in str(loterie)) or (guess[1] in str(loterie)):\n", + " print(\"la loterie était le nombre \"+str(loterie)+\"!\")\n", + " print('votre réponse était le nombre '+str(guess)+\"!\")\n", + " print(\"Vous n'avez qu'un seul chiffre correct! Vous gangez 1000€!\")\n", + "else:\n", + " print(\"la loterie était le nombre \"+str(loterie)+\"!\")\n", + " print('votre réponse était le nombre '+str(guess)+\"!\")\n", + " print(\"predu! reesayez!\")\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Exercice 11:**\n", + " \n", + "Ecrire un programme qui permet de calculer la somme des chiffres d'un entier *n* donné. Le nombre *n* doit être compris entre 10 et 20 (bornes incluses)." + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "9\n" + ] + } + ], + "source": [ + "n=input(\"donnez nombre\")\n", + "somme=0\n", + "for i in range (len(n)):\n", + " somme+=int(n[i])\n", + "print(somme)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Exercice 12:**\n", + "\n", + "1. Ecrire un programme qui permet de générer aléatoirement deux nombres entre 0 et 9, de calculer leurs différences (en valeur absolue), puis d'inviter l'utilisateur à répondre à la question suivante *que vaut abs(number1 - number2)?*. Le programme doit permettre à l'utilisateur de répondre plusieurs fois jusqu'à la saisie de la bonne réponse.\n", + "2. Modifier le programme précédent de telle sorte qu'il génère cinq occurences à la suite invitant à répondre à la question précédente. A la fin, le programme affiche le nombre moyen de tentatives qu'il a fallu à l'utilisateur pour répondre à une question." + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "C'est ça! le resultat est 4!\n" + ] + } + ], + "source": [ + "n1=random.randint(0,9)\n", + "n2=random.randint(0,9)\n", + "result=n1-n2\n", + "reponse=0\n", + "if result<0:\n", + " result*=-1\n", + "while int(reponse)!=result:\n", + " reponse=input('que vaut abs(number1-number2)?')\n", + "print(\"C'est ça! le resultat est \"+str(result)+\"!\")" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "C'est ça! le resultat est 5!\n", + "Vous avez fait 2 tentatives avant de réussir!\n" + ] + } + ], + "source": [ + "n1=random.randint(0,9)\n", + "n2=random.randint(0,9)\n", + "result=n1-n2\n", + "reponse=0\n", + "lose=0\n", + "if result<0:\n", + " result*=-1\n", + "for i in range(5):\n", + "\n", + " reponse=input('que vaut abs(number1-number2)?')\n", + " if int(reponse)!=result:\n", + " lose+=1\n", + " else:\n", + " print(\"C'est ça! le resultat est \"+str(result)+\"!\")\n", + " print(\"Vous avez fait \"+str(lose)+\" tentatives avant de réussir!\")\n", + " break \n", + "if int(reponse)!=result:\n", + " print(\"temps mort! vous avez fait \"+ str(lose)+\"/5 !\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Exercice 13:**\n", + "\n", + "Ecrire un programme qui permet de calculer le nombre de mots dans une phrase saisie par l'utilisateur." + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Bonjour je m'appelle Sabri\n", + "il y a 5 mots.\n" + ] + } + ], + "source": [ + "phrase=input(\"donnez votre phrase\")\n", + "nbr_mots=1\n", + "print(phrase)\n", + "for i in range (len(phrase)):\n", + " if phrase[i]==\" \" or phrase[i]==\"'\":\n", + " nbr_mots+=1\n", + "print(\"il y a \"+str(nbr_mots)+\" mots.\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "---\n", + "\n", + "## 4. Pour s'entraîner\n", + "\n", + "**Exercice 14:**\n", + " \n", + "Soit la variable my_input = \"zoophysiology\". Ecrire un script qui permet d'afficher l'un des messages suivants en fonction du nombre maximum de *o* consécutifs dans la variable *my_input*. Par exemple, le script doit afficher \"I like studying birds! I want to become an ornithologist!\" parce qu'il y a deux *o* consécutifs, même s'il y a aussi des *o* individual.\n", + "Ignorer les *o* majuscules - recherchez que les *o* minuscules.\n", + "\n", + "* Si \"o\" apparaît trois fois ou plus de suite, afficher le message \"I like going to the zoo!\" \n", + "* Si \"o\" apparaît deux fois, afficher le message \"I like studying birds! I want to become an ornithologist!\" \n", + "* Si \"o\" apparaît une seule fois, afficher le message \"I like studying fish! I want to become an ichthyologist!\" \n", + "* Si \"o\" n'apparaît pas dans la variable *my_input*, afficher le message \"I miss going to the zoo!\" \n", + "\n", + "**Astuce :** Utiliser l'opérateur **in** qui renvoie **True** si la première chaîne se trouve dans la deuxième chaîne. " + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "metadata": { + "slideshow": { + "slide_type": "notes" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "i like studying birds! I want to become an ornithologist!\n" + ] + } + ], + "source": [ + "my_input=\"zoophysiology\"\n", + "nombre_o=1\n", + "if \"o\" in my_input :\n", + " for i in range (len(my_input)):\n", + " if my_input[i]==\"o\" and my_input[i+1]==\"o\":\n", + " nombre_o+=1\n", + "else:\n", + " nombre_o=0\n", + " print('i miss going to the zoo!')\n", + "\n", + "if nombre_o>=3:\n", + " print(\"i like going to the zoo!\")\n", + "elif nombre_o==2:\n", + " print(\"i like studying birds! I want to become an ornithologist!\")\n", + "elif nombre_o==1:\n", + " print('i like studying fish! i want to be come an ichtyologist!') " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "**Exercice 15:**\n", + " \n", + "Créer quatre variables nommées *team_1* et *team_2*, représentant deux noms d'équipes, et *team_1_score* et *team_2_score*, représentant les scores de ces deux équipes. \n", + "Une équipe gagne si son score est supérieur à l'autre score de l'autre équipe.\n", + " \n", + "Ecrire un premier script qui permet d'afficher les messages suivants selon les valeurs entrées, ceci en utilisant seulement les quatres variables créées :\n", + "* Si une équipe bat l'autre, affichez: \"\\[winner\\] beat \\[loser\\] by \\[margin\\]\"\n", + "* Si aucune des équipes n'a gagné, affichez: \"\\[team_1\\] played \\[team_2\\] and it was a tie\"\n", + "\n", + "Ecrire un deuxième script qui permet d'afficher les mêmes messages mais en ajoutant trois variables de plus :\n", + "* La variable *winner* pour définir l'équipe gagnante \n", + "* La variable *loser* pour définier l'équipe perdante \n", + "* La variable *margin* pour définir la différence entre les deux scores \n" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "metadata": { + "slideshow": { + "slide_type": "notes" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "paris beat marseille by 2\n" + ] + } + ], + "source": [ + "team_1=\"paris\"\n", + "team_2=\"marseille\"\n", + "team_1_score=2\n", + "team_2_score=0\n", + "margin=team_2_score-team_1_score\n", + "if margin<0:\n", + " margin=-margin\n", + "if team_1_score>team_2_score:\n", + " print(str(team_1)+\" beat \"+str(team_2)+\" by \"+str(margin))\n", + "elif team_1_scoreteam_2_score:\n", + " winner=team_1\n", + " loser=team_2\n", + " print(str(winner)+\" won by \"+str(margin))\n", + "elif team_1_score=nombre2:\n", + " reponse=int(input(\"quel est\"+str(nombre1)+\"-\"+str(nombre2)+\"?\"))\n", + " else:\n", + " reponse=int(input(\"quel est\"+str(nombre2)+\"-\"+str(nombre1)+\"?\"))\n", + " if reponse==nombre1-nombre2 or reponse==nombre2-nombre1:\n", + " print(\"bonne reponse\")\n", + " points+=1\n", + " else:\n", + " print(\"mauvaise reponse\")\n", + "temps2=time.time()\n", + "print(\"vous avez fait \",points,\"/5 réponses correctes\")\n", + "print(str(temps2-temps1)[0:4]+\"secondes\")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Faux\n", + "Faux\n", + "0\n", + "9\n" + ] + } + ], + "source": [ + "import random\n", + "import time\n", + "count=0\n", + "nbq=5\n", + "correct=0\n", + "t1=time.time()\n", + "confirm=\"Y\"\n", + "while confirm==\"Y\":\n", + " nb1=random.randint(0,9)\n", + " nb2=random.randint(0,9)\n", + " if nb1-2:\n", + " ordi=random.randint(0,2)\n", + " user=int(input(\"choisissez 0,1 ou 2\"))\n", + " if user==0:\n", + " if ordi==0:\n", + " print(\"match nul\")\n", + " elif ordi==1:\n", + " won-=1\n", + " print(\"perdu\")\n", + " elif ordi==2:\n", + " won+=1\n", + " print(\"gagné\")\n", + " elif user==1:\n", + " if ordi==0:\n", + " won+=1\n", + " print(\"gagné\")\n", + " elif ordi==1:\n", + " print(\"match nul\")\n", + " elif ordi==2:\n", + " won-=1\n", + " print(\"perdu\")\n", + " elif user==2:\n", + " if ordi==0:\n", + " won-=1\n", + " print(\"perdu\")\n", + " elif ordi==1:\n", + " won+=1\n", + " print(\"gagné\")\n", + " elif ordi==2:\n", + " print(\"match nul\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "password non valide\n" + ] + } + ], + "source": [ + "import string\n", + "import re \n", + "alph=0\n", + "ALPH=0\n", + "tags=0\n", + "num=0\n", + "password=input(\"entrez un mot de passe\")\n", + "if len(password)>=6 and len(password)<=16:\n", + " for i in range(len(password)):\n", + " if re.search(str(password[i]),(string.ascii_lowercase))!=None:\n", + " alph+=1\n", + " elif re.search(str(password[i]),(string.ascii_uppercase))!=None:\n", + " ALPH+=1\n", + " elif i== re.search(str(password[i]),\"0123456789\")!=None:\n", + " num+=1\n", + " elif re.search(str(password[i]),\"&#@\")!=None:\n", + " tags+=1\n", + " if alph>=1 and ALPH>=1 and tags>=1:\n", + " print(\"password valide\")\n", + " else:\n", + " print(\"password non valide\")\n", + "else:\n", + " print(\"password non valide\")\n", + "\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "host=\"hello\"\n", + "print(re.search(\"h\",host))" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "password valide\n" + ] + } + ], + "source": [ + "import re\n", + "def valide(passw):\n", + " if (6<=len(passw)<=16) and re.search(\"[a-z]\",passw) and re.search(\"[A-Z]\",passw) and re.search(\"[0-9]\",passw) and re.search(\"[#@$]\",passw):\n", + " return True\n", + " else:\n", + " return False\n", + "x=input(\"donner password\")\n", + "if valide(x):\n", + " print(\"password valide\")\n", + "else:\n", + " print(\"password invalide\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "celltoolbar": "Diaporama", + "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.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/exercises/TD03_fonctions/03_fonctions.ipynb b/exercises/TD03_fonctions/03_fonctions.ipynb index 5e08ec3cf..8f6c294bd 100644 --- a/exercises/TD03_fonctions/03_fonctions.ipynb +++ b/exercises/TD03_fonctions/03_fonctions.ipynb @@ -13,6 +13,13 @@ "Vous respecterez au mieux les règles d'écriture de code, en particulier chaque fonction devra avoir un **docstring** et des commentaires si nécessaire et les noms de variable seront illustratifs de leur usage. Vous utiliserez les outils de débogage (flake8, mypy, debugger, pythontutor ...) pour corriger vos bogues." ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "markdown", "metadata": {}, diff --git a/exercises/TD03_fonctions/TD3.py b/exercises/TD03_fonctions/TD3.py new file mode 100644 index 000000000..c9c94f864 --- /dev/null +++ b/exercises/TD03_fonctions/TD3.py @@ -0,0 +1,137 @@ +#temps[0] : jours, temps[1]: heures, temps[2]: minutes, temps[3]: secondes + +def tempsEnSeconde(temps): + return temps[0]*86400 + temps[1]*3600 + temps[2]*60 + temps[3]*1 + + +temps = (3,23,1,34) +print(type(temps)) +print(tempsEnSeconde(temps)) + +#def secondeEnTemps(seconde): +# """Renvoie le temps (jour, heure, minute, seconde) qui correspond au nombre de seconde passé en argument""" +# return (seconde//86400, seconde//3600, seconde//60, seconde//1) +# pass + +def secondeEnTemps(seconde): + + jour=seconde//(24*60*60) + reste=seconde%(24*60*60) + heure=reste//(60*60) + reste1=reste%(60*60) + minute=reste1//60 + seconde=reste1%60 + return(jour,heure,minute,seconde) + +temps = secondeEnTemps(100000) +print(temps[0],"jours",temps[1],"heures",temps[2],"minutes",temps[3],"secondes") + + + +def pluriel(mot,nombre): + if nombre>0: + print(" ",nombre,mot,end="") + if nombre>1: + print("s",end="") + + +def afficheTemps(temps): + pluriel("jour",temps[0]) + pluriel("heure",temps[1]) + pluriel("minute",temps[2]) + pluriel("seconde",temps[3]) + print() + + + +def demandeTemps(): + jour1=int(input("donnez nombr de jours")) + heure1=int(input("donnez nombre d'heures")) + minute1=int(input("donnez nombre de minutes")) + seconde1=int(input("donnez nombre de secondes")) + if heure1>=24: + while heure1>=24: + heure1=int(input("ce n'est pas correcte, donne le nombre d'heures")) + if minute1>=60: + while minute1>=60: + minute1=int(input("ce n'est pas correcte, donne nombre de minutes")) + if seconde1>=60: + while seconde1>=60: + seconde1=int(input("ce n'est pas correcte, donnez le nombre de secondes")) + return((jour1,heure1,minute1,seconde1)) + +#afficheTemps(demandeTemps()) + +def sommeTemps(temps1,temps2): + return (secondeEnTemps(tempsEnSeconde(temps1)+tempsEnSeconde(temps2))) + + + +#sommeTemps((2,3,4,25),(5,22,57,1)) + + +def proportionTemps(temps,proportion): + return secondeEnTemps(int(tempsEnSeconde(temps)*proportion)) + + +#afficheTemps((proportionTemps((2,0,36,0),0.2))) + +def tempsEnDate(temps): + annee=1970+(temps[0]//365) + jour=temps[0]%365+1 + heure=temps[1] + minute=temps[2] + seconde=temps[3] + return (annee,jour,heure,minute,seconde) + + +import time + +def afficheDate(date): + if len(date)==0: + date= tempsEnDate(secondeEnTemps(int(time.time))) + print("jour",date[1],"de l'année",date[0],"à",str(date[2])+":"+str(date[3])+":"+str(date[4])) +#temps = secondeEnTemps(1000000000) +#afficheTemps(temps) +#afficheDate(tempsEnDate(temps)) +#afficheDate() + + +def an_bissextile(annee): + return annee%4==0 and (annee%100!=0 or annee%400==0) + +def bisextile(jour): + annee=1970 + while jour>=365: + if an_bissextile(annee): + print("l'année"+str(annee)+"est bisextile") + jour-=366 + else: + jour-=365 + annee+=1 + +def nombrebisextile(jour): + count=0 + annee=1970 + while jour>=365: + if an_bissextile(annee): + print("l'année"+str(annee)+"est bisextile") + jour-=366 + count+=1 + else: + jour-=365 + annee+=1 + return count +#bisextile(20000) + +def tempsEnDateBisextile(temps): + jours,heures,minutes,secondes=temps + jours=jours-nombrebisextile(jours) + tempsbis=(jours,heures,minutes,secondes) + return tempsEnDate(tempsbis) + +temps = secondeEnTemps(1000000000) +afficheTemps(temps) +afficheDate(tempsEnDateBisextile(secondeEnTemps(int(time.time())))) + + diff --git a/exercises/TD03_fonctions/nahnigga.txt b/exercises/TD03_fonctions/nahnigga.txt new file mode 100644 index 000000000..395b66497 --- /dev/null +++ b/exercises/TD03_fonctions/nahnigga.txt @@ -0,0 +1 @@ +yo wassap cuzz \ No newline at end of file diff --git a/exercises/TD03_fonctions/test.py b/exercises/TD03_fonctions/test.py new file mode 100644 index 000000000..f4b5695d9 --- /dev/null +++ b/exercises/TD03_fonctions/test.py @@ -0,0 +1 @@ +print(3*0.1) \ No newline at end of file diff --git a/exercises/TD04_listes/04_listes.ipynb b/exercises/TD04_listes/04_listes.ipynb index 5ef60e5fa..e90862466 100644 --- a/exercises/TD04_listes/04_listes.ipynb +++ b/exercises/TD04_listes/04_listes.ipynb @@ -25,7 +25,9 @@ "execution_count": null, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "liste=[3,5,10]\n" + ] }, { "cell_type": "markdown", @@ -36,10 +38,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[3, 5, 10, 12, 17]\n" + ] + } + ], + "source": [ + "liste=[3,5,10]\n", + "liste.append(12)\n", + "liste.append(17)\n", + "print(liste)" + ] }, { "cell_type": "markdown", @@ -50,10 +65,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[3, 5, -7, 12, 17]\n" + ] + } + ], + "source": [ + "liste[2]=-7\n", + "print(liste)" + ] }, { "cell_type": "markdown", @@ -64,10 +90,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[6, 10, -14, 24, 34]\n" + ] + } + ], + "source": [ + "for i in range (len(liste)):\n", + " liste[i]*=2\n", + "print(liste)" + ] }, { "cell_type": "markdown", @@ -78,10 +116,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[6, 11, -12, 27, 38]\n" + ] + } + ], + "source": [ + "for i in range (len(liste)):\n", + " liste[i]+=i\n", + "print(liste)" + ] }, { "cell_type": "markdown", @@ -92,10 +142,37 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "68\n", + "26\n", + "77\n", + "13\n", + "557\n", + "13\n" + ] + } + ], + "source": [ + "import random\n", + "listebis=[]\n", + "nmax=0\n", + "somme=0\n", + "for i in range (10):\n", + " if nmax