{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "\n", " \n", " \n", " \n", " \n", "\n", "

- TD1 -

\n", " 		\n", "

UFR de sociologie et d'informatique pour les sciences humaines

\n", "

Programmation en Python

\n", "
\n", "\n", "-----" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Notion de variables (en Python)

\n", "\n", "En __*Python*__, et en programmation plus largement, plutôt que d'écrire\n", "\n", "```python\n", " 3 + 8\n", "```\n", "\n", "on préfère écrire\n", "\n", "```python\n", " a = 3\n", " b = 8\n", " a + b\n", "```\n", "\n", "*a* et *b* sont ici des __*variables*__. On dit que l'on affecté à __*a*__ la valeur 3 et à __*b*__ la valeur 8.\n", "\n", "L'intérêt est que si l'on veut par exemple faire plusieurs fois le même type d'opération $a+b$, on désire pouvoir réutiliser l'addition en changeant seulement les valeurs de $a$ et de $b$.\n", "\n", "

Exemple

\n", "\n", "On a des prix de denrées alimentaires. Oeufs 2.10 €, sucre 3.50 €, farine 1.5 € et levure 1.1 €.\n", "\n", "Si pour chacun, on veut calculer le montant de la *TVA* à 5.5%, soit 0.055, on peut écrire (la multiplication est * en Python):\n", "\n", "```python\n", " tva = 0.055\n", " oeufs = 2.1\n", " sucre = 3.5\n", " farine = 1.5\n", " levure = 1.1\n", "```\n", "\n", "puis\n", "\n", "```python\n", " oeufs * tva\n", " sucre * tva\n", "```\n", "\n", "etc.\n", "\n", "Le jour où la TVA passe à 6%, il suffit juste de modifier la 1e ligne en\n", "\n", "```python\n", " tva = 0.06\n", "```\n", "\n", ".. et relancer les calculs. Notez ici que l'on a donné des noms plus *parlants* aux variables. Plutôt que d'écrire $a = 2.1$, on préfère *oeufs* $= 2.1$, ce qui est plus évocateur !\n", "\n", "Attention : __Python__ est sensible à la casse, c'est-à-dire que la variable *a* est différente de la variable *A*.\n", "\n", "

Fonction print()

\n", "\n", "Pour afficher à l'écran un résultat quelconque, qu'il soit numérique ou textuel, on utilise la fonction __*print()*__.\n", "\n", "```python\n", " print(a)\n", "```\n", "\n", "affiche le contenu de la variable *a*\n", "\n", "> **Exercice** | Exécutez la cellule ci-dessous (sélectionnez la cellule en *cliquant dedans* puis, appuyez sur le bouton \"*Exécuter*\" dans la barre d'outils)." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "m1 = \"bonjour \"\n", "m2 = \"Pollux\"\n", "print(m1)\n", "print(m2)\n", "print(m1 + m2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Modifiez la cellule __précédente__, puis exécutez-là à nouveau pour qu'elle affiche seulement : bonjour tout le monde (on peut l'exécuter autant de fois que l'on veut)\n", "\n", "Vous remarquez qu'un __*donnée numérique*__ s'écrit tout simplement comme on l'écrit (ex : a = 3). Une __*donnée textuelle*__ s'écrit en guillemets (m1 = \"bonjour\"). Une donnée textuelle est une __*chaîne de caractères*__.\n", "\n", "Une chaîne de caractères peut s'écrire de 3 façons : entre simple apostrophe, entre guillemets et entre triple guillemets.\n", "\n", "> **Exercice** | Exécutez la cellule ci-dessous :" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "p1 = 'je mange'\n", "p2 = \"du miel\"\n", "p3 = \"\"\"au soleil\"\"\"\n", "print(p1, p2, p3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "On remarque que pour afficher plusieurs variables, on peut les séparer par des __virgules__.\n", "\n", "On peut aussi mixer texte et valeur\n", "\n", "> **Exercice** | Exécutez la cellule ci-dessous :" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "nbdents = 32\n", "nom = 'Jules'\n", "print(nom, 'a', nbdents, 'dents')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Modifiez la cellule __précédente__ puis exécutez-là à nouveau pour qu'elle affiche : le petit Tom a 1 dent\n", "\n", "La virgule dans __print()__ génère une espace entre chaque entités. On peut choisir autre chose, cela se fait avec __sep=__\n", "\n", "> **Exercice** | Exécutez la cellule ci-dessous :" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "jour = 18\n", "mois = \"avril\"\n", "an = 2020\n", "print(jour, mois, an, sep='/')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Modifiez la cellule précédente puis Exercice | Exécutez-là pour qu'elle affiche : 5&&&décembre&&&1929\n", "\n", "Plusieurs __print()__ successifs générent des sauts de ligne.\n", "\n", "> **Exercice** | Exécutez la cellule ci-dessous :" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "age1 = 13\n", "age2 = 24\n", "nom1 = 'Alice'\n", "nom2 = 'Bob'\n", "print(nom1, 'a', age1, 'ans')\n", "print(nom2, 'a', age1, 'ans')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "On peut spécifier à un __print()__ de ne pas générer de saut de ligne avec __end=__\n", "\n", "> **Exercice** | Exécutez la cellule ci-dessous, puis modifiez le programme de la cellule __précédente__ pour qu'il affiche tout sur une seule ligne." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(3 * 6 + 2, end = '')\n", "print(\" bus\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Affectation

\n", "\n", "On peut affecter plusieurs valeurs à plusieurs variables en une ligne.\n", "\n", "Plutôt que d'écrire\n", "\n", "```python\n", " longueur = 34\n", " largeur = 20\n", " texte = \"Aire du rectangle :\"\n", " print(texte, longueur * largeur)\n", "```\n", "on peut écrire avantageusement\n", "\n", "```python\n", " longueur, largeur, texte = 34, 20, \"Aire du rectangle :\"\n", " print(texte, longueur * largeur)\n", "```\n", "L'affectation se fait dans le même ordre que l'écriture, et __simultanément__. Cela porte le nom d'__*affectation parallèle*__.\n", "\n", "> **Exercice** | Exécutez la cellule ci-dessous :" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a, b, c = \"lapins\", 13, \"détalent\"\n", "print(b, a, c)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "La notion de simultanéité peut être appréciée dans le programme suivant :\n", "\n", "> **Exercice** | Exécutez la cellule ci-dessous" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a, b = 10, 20\n", "a, b = a + b, b * 2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* La 1e ligne affecte à *a* la valeur 10 et à *b* la valeur 20\n", "* La 2e ligne affecte une nouvelle valeur à *a*, la somme de l'ancienne valeur de *a* avec l'ancienne valeur de *b* et... __simultanément__ elle affecte à *b* l'ancienne valeur de *b* multipliée par 2\n", "\n", "> **Exercice** | Modifiez la cellule précédente pour qu'elle affiche les valeur de *a* et de *b* après la 1e ligne de code, puis à la fin du programme\n", "\n", "Il y a aussi l'__*affectation multiple*__ qui est parfois bien pratique. Elle doit en général être réservée à des variables numériques et/ou chaîne de caractères.\n", "\n", "> **Exercice** | Exécutez la cellule ci-dessous :" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = b = c = 15\n", "d = e = \"poussins\"\n", "print(a, d, \"et\", c, e)\n", "print(\"b =\", b)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Entrée de données au clavier

\n", "\n", "La commande (c'est en fait une fonction, nous verrons cela plus tard...) __*input()*__ est faite pour\n", "améliorer l'interactivité d'un programme avec l'utilisateur. Elle permet d'affecter une valeur à la volée\n", "et de traiter cette valeur ensuite.\n", "\n", "On peut ajouter du texte pour rendre la commande plus lisible par l'utilisateur\n", "\n", "> **Exercice** | Exécutez la cellule ci-dessous :" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "pnom = input(\"Donne ton prénom :\")\n", "print(\"Bonjour\", pnom)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Le problème avec __*input()*__, c'est qu'il en ressort toujours une chaîne de caractères. Dans l'exemple précédent, __pnom__ contient donc une chaîne de caractères.\n", "\n", "> **Exercice** | Exécutez la cellule ci-dessous :" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "age = input(\"Quel est ton âge ?\")\n", "print(\"Tu as\", age, \"ans\")\n", "print(age * 2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Observez bien ce qui s'est passé !\n", "\n", "* le programme a bien écrit \"Tu as xx ans\"\n", "* mais il a écrit 2 fois l'âge plutôt que de faire la multiplication *age x 2* ! Cela vient du fait que __Python__ ne sait pas multiplier une chaîne par un entier autrement qu'en écrivant autant de fois qu'il faut cette chaîne.\n", "\n", "Il faut donc, si l'on veut faire une opération basique, transformer cette chaîne (*age*) en un nombre. La commande pour cela est __*eval()*__.\n", "\n", "> **Exercice** | Exécutez la cellule ci-dessous :" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "age = input(\"Quel est ton âge ?\")\n", "age = eval(age)\n", "print(\"Tu as\", age, \"ans\")\n", "print(age * 2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Cette fois *age* est une variable numérique et le programme affiche bien 2 fois l'âge. Remarquez que l'on pouvait écrire (et c'est plus simple) les 2 premières lignes en une seule.\n", "\n", "```python\n", " age = input(\"Quel est ton âge ?\")\n", " age = eval(age)\n", "```\n", "en\n", "```python\n", " age = eval(input(\"Quel est ton âge))\n", "```\n", "\n", "> **Exercice** | Écrivez un programme dans la cellule ci-dessous qui demande la taille (en cm) et qui affiche\n", "* \"Tu mesures xxx cm\"\n", "* \"À 2 ans tu devais mesurer xxxx cm\"\n", "\n", "où xxxx est le résultat de la taille divisé par 2. La division se fait avec le symbole / du clavier (ex : 7/2 donne 3.5).\n", "\n", "On peut mettre des __*commentaires*__ dans un programme à l'aide du caractère # (dièze = Alt Gr + 3). Tout ce qui suit ce caractère sur la ligne est ignoré par __Python__. Exemple ci-dessous..." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Entrez votre progamme ci-dessous.\n", "# On valide à la fin de chaque ligne pour passer à la suivante.\n", "# On exécute le programme en cliquant sur \"Exécuter\" dans la barre d'outils\n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Désormais, nous ferons figurer des commentaires dans le code pour nous aider à mieux comprendre. Vous êtes invités à faire de même, la relecture d'un code en est grandement facilitée.\n", "\n", "

Les opérations de base

\n", "\n", "Avec le numérique, vous pouvez écrire comme avec une calculatrice. Les opérations de base sont\n", "\n", "* l'addition + exemple : 17 + 5 (on met des espaces, c'est plus joli et simple à lire)\n", "* la soustraction - exemple : 17 - 5\n", "* la multiplication * exemple : 17 * 5\n", "* la division / exemple : 17 / 5\n", "* la division entière // (ou euclidienne pour les pros...) exemple : 17 // 5\n", "* l'exponentiation ** exemple 17 ** 5 (en fait $17^5$)\n", "* le modulo % qui donne le reste de la division entière exemple : 17 % 5\n", "\n", "> **Exercice** | Effectuez chacune des opérations précédentes dans la cellule ci-dessous : une opération, on valide, on remplace par la suivante, etc." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Mettez vos calculs ci-dessous\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Écrivez un programme ci-dessous qui demande à l'utilisateur son année de naissance, et qui affiche : vous avez xxx ans, en faisant l'opération adéquate" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Mettez votre code ci-dessous\n", "\n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Comportement des opérations avec les chaînes

\n", "\n", "Toutes les opérations ne sont pas compatibles avec les chaînes. Voici ce que l'on peut faire :\n", "\n", "* concaténation de 2 chaînes : exemple \"deux\" + \"lapins\", donne deuxlapins\n", "* duplication de chaîne : exemple 'gris' * 3, donne grisgrisgris\n", "\n", "Aucune autre opération n'est tolérée. Si vous faites par exemple\n", "\n", "```python\n", " print(3 + \"lapins\")\n", "```\n", "\n", "cela génère une erreur ! (on ne peut pas ajouter des carottes avec des choux-fleurs !!!)\n", "\n", "

Type de données

\n", "\n", "Pour pouvoir avoir des variables du même type, on doit pouvoir passer de l'un à l'autre, ce qu'à prévu __Python__.\n", "\n", "\n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
type int ou float (entier ou à virgule) type str (string ou chaîne de caractères)
5 ou 3.14$\\longrightarrow$ str(5)=\"5\" ou str(3.14)=\"3.14\"
eval(\"5\")=5 ou eval(\"3.14\")=3.14 $\\longleftarrow$ \"5\" ou \"3.14\"
\n", "\n", "> **Exercice** | Écrivez un programme ci-dessous qui demande à l'utilisateur, combien de frères et soeurs il a en tout (affectation à la variable *nbfrso* du nombre de frères et soeurs), qui multiplie ce nombre par 10, et qui concatène les mots suivants : \"tu aurais pu avoir\", \"frères et soeurs\" et *nbfrso* (dans le bon ordre)." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Mettez votre code ci-dessous\n", "\n", "\n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Il existe un autre type de donnée que vous devez connaître dès maintenant. C'est le __booléen__, en référence au mathématicien anglais *George Boole*.
Un booléen ne prend que 2 valeurs : __True__ ou __False__. En __Python__, __False__ correspond aussi à __0__, et __True__ à __1__.\n", " \n", "Comment générer un booléen ? Les booléens sont très utiles pour vérifier des conditions.\n", "\n", "> **Exercice** | Exécutez les lignes suivantes et observez ce qu'il en ressort." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a, b = 2, 'loup'\n", "print(a == 1 + 1) # se traduit par a est-il égal à 2. Remarquez le double =\n", "print(b == \"poul\")\n", "print(3 < 5) # ordre naturel\n", "print(\"abricot\" < \"zoo\") # ordre alphabétique\n", "print((a == 7) * 77)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Pour générer ces booléens, on utilise :\n", "\n", "* == pour tester une égalité (attention : un seul = est pour l'affectation, == pour tester l'égalité\n", "* != pour tester une différence\n", "* \\< pour tester une inégalité\n", "* \\> idem\n", "* \\<= signifie inférieur ou égal\n", "* \\>= idem\n", "\n", "__Python__ a prévu une commande, une fonction qui renvoie le type d'une donnée. Ceci est valable pour toutes les données que vous rencontrerez dans votre découverte de __Python__.\n", "\n", "Cette fonction est simplement __*type()*__.\n", "\n", "> **Exercice** | Exécutez le progamme suivant qui affiche le type de différentes variables." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = 521 # un entier\n", "b = 2.72 # un nombre à virgule\n", "c = \"poisson\" # une chaîne\n", "d = True\n", "print('a est de type', type(a))\n", "print('b est de type', type(b))\n", "print('c est de type', type(c))\n", "print('c est de type', type(d))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Résumé

\n", "\n", "Vous avez vu :\n", "* les opérations élémentaires utiles pour vos premiers pas en __Python__\n", "* la notion d'affectation de valeur à une variable et les différentes façon de la faire\n", "* les entrées-sorties avec l'écriture et l'entrée au clavier\n", "* l'usage des commentaires\n", "* le typage des données\n", "\n", "Vous allez mettre en oeuvre ces connaissances.\n", "\n", "

Exercices

\n", "\n", "> **Exercice** | Affichez les opérations ci-dessous en __Python__ et vérifiez si l'affichage correspond à ce qui est écrit.\n", " \n", "1. division entière de 7 par 3 = 2\n", "2. division entière de -17 par -5 = 3\n", "3. $1 - 5 \\times 2 = -9$\n", "4. reste de la division entière de 4 par 2 = 0\n", "5. $6^0+5 = 6$\n", "6. $12 - \\dfrac{4}{-2} = 14$\n", "7. $2^3=8$\n", "8. $2^{-2}=0.25$\n", "9. reste de la division entière de -7 par 2 = 1\n", "10. $(-1)^7=-1$\n", "11. reste de la division entière de 17 par 2 = 1" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# calculs\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Devinez ce que valent $a$ et $b$ à la fin de ces courts programmes. Exécutez-les __seulement après__ pour vérifier vos réponses." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a, b = 7, \"samouraïs\"\n", "a, b = a + 2, b * 3\n", "print(\"a =\", a, \"b =\", b)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a, b = 5, 7\n", "a, b = a + 1, b - 1\n", "print(\"a =\", a, \"b =\", b)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a, b = 1, 1\n", "a, b = b, a + b\n", "print(\"a =\", a, \"b =\", b)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a, b, c = 12, 3, \"mariages\"\n", "a, b = a // 3, b % 2\n", "a = str(a) + c + str(b) + \"enterrement\"\n", "print(\"a =\", a, \"b =\", b)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Selon Broca, le poids idéal est donné par la taille en cm, diminuée de 100. Écrivez un programme qui demande à un utilisateur sa taille en cm et qui affiche ensuite le poids idéal." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# poids idéal selon Broca\n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Selon Creff, le poids idéal est donné par la formule suivante :\n", " $$poidsideal = (taille-100+\\dfrac{age}{10})\\times 0.9$$\n", "Écrivez un programme qui demande à un utilisateur sa taille (en cm) et son âge (en années) et qui affiche son poids idéal.\n", "" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# poids idéal selon Creff\n", "\n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Écrivez un programme qui demande d'entrer un entier à 2 chiffres et qui affiche cet entier mais avec le chiffre des dizaines inversé avec celui des unités (exemple : si on entre 27, le programme doit afficher 72).\n", "\n", "Remarque vous pouvez tester les lignes suivantes qui explique l'astuce avant de vous lancer...\n", "\n", "```python\n", " print(34 % 10)\n", " print(45 % 10)\n", " print(45 - 45 % 10)\n", "```" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# inverser les 2 chiffres d'un nombre entier à 2 chiffres\n", "\n", "\n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Écrivez un programme qui assemble les mots suivants pour en faire une phrase tout à fait correcte.\n", "\n", "m1 = \"le\", m2 = \"tire\", m3 = \"lapin\", m4 = \"chasseur\", m5 = \"sur un\"" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# le lapin et le chasseur...\n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Complétez le programme ci-dessous qui doit simuler un bégaiement. Pour cela vous faites en sorte d'écrire la phrase \"je mange un pain\", en doublant les mots \"je\" et \"un\"." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# bégaiement\n", "m1, m2, m3, m4 = \"un\", \"pain\", \"je\", \"mange\"\n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Entrez et exécutez chacune des lignes suivantes, une à une.\n", "\n", "```python\n", " a, b = \"la\", 5\n", " print(a < \"le\")\n", " print(2 < b <= 7)\n", " print(a != '') # '' est une chaîne vide\n", "```" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# entrez et exécutez\n", "\n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Devinez ce que va afficher le programme ci-dessous. Ensuite seulement, exécutez-le pour vérifier votre réponse." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Que va afficher ce programme ?\n", "a1, a2 = 5, 2\n", "b1, b2 = \"cou\", \"lou\"\n", "print((a1 == 2) * b1 * 2 + (a2 == 2) * b2 * 2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", " \n", "Pour finir,\n", "\n", "## l'exercice qui tue ...##\n", "\n", "> **Exercice** | La carte vitale comporte un numéro d'identification à 13 chiffres, suivi d'un clé de contrôle (pour vérifier d'éventuelles erreurs dans les 13 chiffres). Il est connu que le 1e chiffre est le sexe (1 = homme et 2 = femme), les 2 suivants sont les 2 derniers chiffres de l'année de naissance, les 2 chiffres suivants le mois de naissance, etc.\n", "\n", "> Comment est calculé la clé de contrôle ? la cle est le résultat de : 97 moins le reste de la division entière du nombre à 13 chiffres par 97. Réalisez ci-dessous un programme qui donne le code d'un numéro de sécurité sociale à 13 chiffres. Essayez avec 2020548588157." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# carte vitale et clé\n", "\n", "\n", "\n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", " \n", "* Essayez toujours de donner comme nom de variable, des noms significatifs : une longueur peut être nommée *long*, un âge par le nom *age*, une lettre d'un mot par *lettre*, etc. Vos programmes seront d'autant plus agréables à lire, et relire par vous-même.\n", "\n", "Une variable doit en __Python__\n", "* toujours commencer par une lettre de *a* à *z* (voire *A* à *Z*)\n", "* ne pas commencer par un chiffre (et éviter de commencer par le symbole _ )\n", "* ne pas contenir d'accent\n", "\n", "Une variable en __Python__\n", "* peut contenir lettres et chiffres et le symbole _\n", "* doit être écrit en *minuscule* de préférence (voire CamelCase, exemple : *bordDuCarre*)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# FIN du TD1" ] } ], "metadata": { "celltoolbar": "Format de la Cellule Texte Brut", "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.8.3" } }, "nbformat": 4, "nbformat_minor": 4 }