Remarques :
\n", "Il est également possible d'ajouter une nouvelle cellule à l'aider du bouton (dans le menu en haut) ;
\n", "Toutes les cellules de ce notebook commençant par Entrée [x] sont à exécuter.
\n", "Remarque :
\n", "Une variante consiste à commencer un commentaire avec trois guillemets \"\"\" et à le finir de la même façon. C'est une façon aisée d'écrire un long commentaire qui court sur plusieurs lignes.
\n", "print est le nom de la commande Python qui envoie des messages vers la sortie : elle permet d'afficher la valeur d'une variable ou une chaîne de caractères (formatée) ;\n",
" ( ) après la commande print sont utilisées pour contenir ce que l'on souhaite afficher ;\n",
" Bonjour, Python ! à l'intérieur. \n",
"L'instruction n'est pas comprise par l'interpréteur qui génère une erreur et le force à s'arrêter.
\n", "En python, la partie entière d'un nombre réel (ex : 3.14159) est séparée de la partie fractionnaire par un point (convention anglaise) et non une virgule (convention française). En d'autres termes, le séparateur décimal est le point . et non la virgule ,
On obtient toujours un flottant lorsqu'on fait une division simple avec /, même entre deux entiers.
Remarque :
\n", "Bon usage : il faut éviter de faire commencer le nom d'une variable par une majuscule ou le caractère « _ ».
\n", "L'instruction type() permet d'obtenir le type d'une variable
Vous remarquerez que l'interpréteur Python a inféré (déduit) le type des variables b, n, x et s.
La séquence de caractères \\n permet de passer à la ligne.
**'**) qu'entre doubles guillemets (**\"**)."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"s1 = \"Bienvenue dans Python,\"\n",
"s2 = 'un langage de programmation simple'\n",
"\n",
"print(s1)\n",
"print(type(s1))\n",
"print(s2)\n",
"print(type(s2))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Remarque :"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"b = 'c\\'est' # si la chaîne de caractères contient un simple guillemet ' alors il faut le faire précéder d'un \\\n",
"b"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"b = \"c'est\" # ou alors on utilise les doubles guillemets \" \" sans le \\\n",
"b"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 5.1. Taille d'une chaîne de caractères\n",
"\n",
"Il existe une fonction **`len()`** qui permet de connaitre la taille d'une chaine de caractères :"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print(\"Taille de s1 =\", len(s1))\n",
"print(\"Taillle de s2 =\", len(s2))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 5.2. Concaténation de chaînes de caractères et répétition\n",
"\n",
"On peut concaténer (relier entre elles, joindre) deux chaînes de catactères grâce à l'opérateur **`+`** :"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"scrolled": true
},
"outputs": [],
"source": [
"# 3 manières de concaténer des chaînes de caractères\n",
"print(s1 + s2)\n",
"print(s1 + \" \" + s2)\n",
"print(\" \".join((s1, s2)))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"scrolled": true
},
"outputs": [],
"source": [
"print(\"Bienvenue dans Python,\" + \" un langage de programmation simple\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"scrolled": true
},
"outputs": [],
"source": [
"prenom = \"Jean\"\n",
"nom = 'Dupont'\n",
"print(prenom, nom )\n",
"\n",
"complet = prenom + \" \" + nom\n",
"print(\"\\nNom complet :\", complet)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Une opération interdite :"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"a = 0\n",
"s = \"e\"\n",
"print(a + s) # petit problème de type"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Répétition d'une chaîne de caractères :"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print(2 * '100')\n",
"print(2 * 'Python')\n",
"print(\"quatre fois ; \" * 4)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 5.3. Formatage d'une chaîne de caractères\n",
"\n",
"On peut formater les chaines de caractères grâce à l'usage combiné des accolades **`{}`** et de la méthode (fonction) **`format()`** :"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print('{0}{1}{0}'.format('abra', 'cad'))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print('{0}{1}{1}'.format(3,5))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"s = \"{1}bla\"\n",
"t = s.format(100,88)\n",
"print(s)\n",
"print(t)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"On peut faire de l'alignement :"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print(\"{:03}\".format( 1))\n",
"print(\"{:03}\".format( 10))\n",
"print(\"{:03}\".format(100))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"On peut remplacer un élément de la chaîne :"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"url = \"http://{language}.wikipedia.org/\"\n",
"url = url.format(language=\"fr\")\n",
"url"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"On peut tronquer un élément de la chaîne :"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"nom = \"Hugo\"\n",
"prenom = \"Lebon\"\n",
"nom_formate = \"%s, %s.\" % (nom, prenom[0])\n",
"nom_formate"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"On peut tronquer l'affichage d'un nombre après la virgule :"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print('{:0.4f}'.format(3.14159265359))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"round(3.14159265359, 4)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 5.4. Indexation\n",
"\n",
"On peut accéder à un caractère d'une chaîne de caractères grâce à la syntaxe : `chaine[index]`."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"sparta = 'C\\'est Sparta !'\n",
"sparta[0], sparta[2], sparta[-1], sparta[-3]"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"s = sparta\n",
"s[0]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 5.5. Le *slicing*"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"En programmation, et en Python en particulier, il arrive fréquemment, lorsque l'on travaille avec des chaînes de caractères, que l'on souhaite extraire une petite chaîne de caractères d'une chaîne plus longue. Python propose pour cela une technique simple appelée ***slicing*** (ou « decoupage en tranches »). Elle consiste à indiquer entre crochets les indices correspondant au début et à la fin de la « tranche » que l'on souhaite extraire.\n",
"\n",
"Ainsi, les slices sont des expressions qui permettent, en une ligne de code, d'extraire des éléments d'une chaîne de caractères."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Synthaxe :**"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"```python\n",
"chaine[debut:fin:saut]\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Remarque : dans la tranche, le début est inclu mais pas la fin.
\n", "Important :
\n", "Remarquez bien le : après le range(5) : cela marque le début du bloc.
Remarquez également le décalage du print qui indique qu'il appartient à la boucle for et ne sera exécuté QUE dans cette boucle.
\n",
"Table de 7 :\n",
" \n",
"1 x 7 = 7\n",
"2 x 7 = 14\n",
"3 x 7 = 21\n",
"4 x 7 = 28\n",
"5 x 7 = 35\n",
"6 x 7 = 42\n",
"7 x 7 = 49\n",
"8 x 7 = 56\n",
"9 x 7 = 63\n",
""
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Ecrire votre code ici"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### La boucle `for` sur une chaine de caractères :"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"C'est très facile de parcourir une chaîne de caractères avec une boucle `for` :"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"ADN = \"AGCTGTCGCG\"\n",
"for lettre in ADN:\n",
" print('la séquence ADN contient', lettre)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"qui est équivalent à :"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"for lettre in \"AGCTGTCGCG\":\n",
" print('la séquence ADN contient', lettre)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Exercice n°9 :** Exécuter et expliquer le code qui suit"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"chaine = input(\"Entrer une phrase:\") \n",
"for lettre in chaine:\n",
" if lettre in \"aeiouyAEIOUY\":\n",
" print(lettre)\n",
" elif lettre == \"I\":\n",
" print(lettre)\n",
" else:\n",
" print(\"*\") "
]
},
{
"cell_type": "raw",
"metadata": {},
"source": [
"Votre explication ..."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# 9. La boucle `While` (Tant que)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"La boucle `while` est une boucle non bornée : on l'utilise si on ne connait pas à l’avance le nombre de répétitions d'une opération.\n",
"\n",
"La structure d'une boucle `while` est la suivante :\n",
"\n",
"```python\n",
"while condition:\n",
" instruction1\n",
" instruction2\n",
" ...\n",
"suite programme\n",
"```\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Exécution :\n",
"- Tant que la `condition` reste vraie, les instructions à l'intérieur du bloc (partie indentée) seront exécutées. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"i = 0\n",
"while i < 10:\n",
" print(\"i vaut :\", i)\n",
" i = i + 1\n",
"print(\"C'est terminé.\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Analyse du code :\n",
"\n",
"- la boucle `while i < 0` s'exécutera tant que `i` sera inférieur à 10 ;\n",
"- à chaque tour de boucle, on incrémente `i`de 1 ;\n",
"- la variable `i` prendra les valeurs entières entre 0 et `9` ;\n",
"- quand `i` vaut 11, la boucle s'interrompt et le programme se termine."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Remarques :
\n", "- Si la condition est fausse (false) au départ, le corps de la boucle n’est jamais exécuté ;
- Si la condition reste toujours vraie (true), alors le corps de la boucle est répété indéfiniment, on parle de boucle infinie (le programme ne s'arrête jamais).
Remarques :
\n", "Dans le cas de boucles imbriquées, l’instruction break ne fait sortir que de la boucle dans laquelle elle se trouve.
Améliorations possibles :
\n", "- Vérifier que l'utilisateur entre bien un entier.
\n", "- Vérifier que le nombre entré est bien compris entre 0 et 100.
\n", "Pour aller plus loin :
\n", "